Vereinfachen

Viele Grafiken sind größtenteils Wiederholungen. Zwei Ereignisse teilen sich vierzig IPs, und jede IP kostet einen Knoten, ein Label und zwei Kanten, obwohl es darauf ankommt, „diese beiden Ereignisse teilen sich vierzig IPs“. Ein Hub hat Dutzende Blätter, die nirgendwo sonst eine Verbindung herstellen. Vereinfachen faltet Knoten, die dieselbe Rolle spielen, zu einer Gruppe zusammen und zeichnet sie an ihrer Stelle:

const options = {
    render: {
        nodeTypeAccessor: (node) => node.getData().type,
    },
    UI: {
        simplify: {
            rules: [{ kind: 'neighbours', minSize: 5 }],
        },
    },
}

Gruppen sind eine Ansicht, keine Daten

graph.getNodes(), getEdges(), die Tabelle, Exporte und der Rückgängig-Verlauf sehen die echten Knoten. Bei jeder Änderung des Diagramms wird aus ihnen eine Gruppe neu berechnet und nichts davon wird gespeichert.

Sehen Sie, wie es auf der Karte Vereinfachen Sie das Diagramm ausgeführt wird.

Regeln

UI.simplify.rules ist eine geordnete Liste. Jede Regel gibt einigen Knoten einen Schlüssel, und Knoten, die einen Schlüssel teilen, werden zu einer Gruppe, solange es mindestens minSize davon gibt.

Regeln werden **in der Reihenfolge ** ausgeführt, und jeder sieht die Gruppen, die die darüber liegenden Regeln erstellt haben, als gewöhnliche Knoten. Eine Gruppe kann daher durch eine spätere Regel erneut gruppiert werden.
Regeln werden nach den Knotenfiltern ausgeführt, sodass eine Gruppe nur das enthält, was sie passiert: Verstecken Sie drei von vierzig IPs und die Gruppe liest 37. Randebenen ändern die Gruppen nicht; Wenn Sie eins ausschalten, werden nur Zeilen ausgeblendet.
Ein Knoten mit angehängter Notiz und ein erweiterter Cluster werden nie gruppiert. Ein geschlossener Cluster gruppiert sich wie jeder andere Knoten.
Eine deklarierte Regel ist aktiviert, es sei denn, sie sagt enabled: false.

Ohne UI.simplify bietet der full-Modus die integrierten Regeln, die im Simplify-Rail-Modus deaktiviert sind; In den anderen Modi läuft nichts. UI.simplify.enabled: false entfernt die Funktion.

Die Nachbarregel

{ kind: 'neighbours', minSize: 5, typeOf: (node) => node.getData().type }

Es faltet Knoten von einem Typ, die mit genau denselben Knoten verknüpfen, in der gleichen Reihenfolge: dieselben Knoten, die auf sie zeigen, und dieselben Knoten, auf die sie zeigen. Die Blätter einer Nabe sind der einfachste Fall. Wenn sich die Ereignisse A und B drei TTPs teilen und jedes über zwei eigene verfügt, erhält man drei Gruppen: die gemeinsamen drei zwischen A und B und zwei auf jeder Seite.

Der Typ ist der der Regel eigene typeOf, sonst UI.simplify.typeOf, sonst render.nodeTypeAccessor. Knoten ohne Typgruppe untereinander.
Ein Knoten, der mit nichts verbunden ist, wird niemals gruppiert: Eine Gruppe braucht etwas, an dem sie hängen kann.
Ein Knoten, der eine Verbindung erhält, verlässt seine Gruppe und wechselt zu dem Knoten, der zu seinen neuen Nachbarn passt. Bleiben weniger als minSize übrig, löst sich die Gruppe auf.
Eine Gruppe behält ihre Identität, während sie die meisten ihrer Mitglieder behält, sodass ein neuer Knoten, der mit denselben Nachbarn landet, der bestehenden Gruppe beitritt, ohne sie zu verschieben.

Die Kettenregel

{ kind: 'chains', minSize: 5, typeOf: (node) => node.getData().type }

Es faltet Ketten, die an einem Knoten hängen. Ein Ereignis, das dreißig Dateien mit jeweils eigenem Hash enthält, besteht aus dreißig Ketten file > sha256: Die Dateien teilen sich keinen Nachbarn, da jede ihren eigenen Hash verknüpft, sodass die Nachbarregel sie in Ruhe lässt. Die Kettenregel faltet sie in einer Gruppe von Dateien zusammen, die mit einer Gruppe von Hashes verknüpft sind, und zeichnet die dreißig Verknüpfungen zwischen ihnen als eine Linie.

Der Schwanz eines Knotens ist ein Knoten, dessen einzige Verbindung von ihm kommt und stromabwärts folgt, während jeder Schritt nur entlang der Kette verknüpft ist. Ein aus zwei anderen Knoten, einem Zweig oder einem Zyklus verknüpfter Knoten beendet die Kette dort.
Knoten, die Ketten gleicher Form führen, falten sich zusammen, wenn sie die gleichen anderen Glieder und den gleichen Typ haben. Fünf isolierte Paare domain → ip ergeben eine Gruppe von fünf Domänen, die mit einer Gruppe von fünf IPs verknüpft sind.
Jede Ebene der Ketten wird ebenfalls gefaltet: unter der Gruppe ihrer Köpfe oder unter einem eigenen Kopf, wenn es keine Übereinstimmung gibt.
Links zählen nur Downstream: ein Knoten, dessen einziger Link auf einen anderen zeigt, ist nicht das Ende dieses Knotens.
Nach der Nachbarregel platziert, faltet es den Rest dieser Regel. Eine Gruppe, die die Nachbarregel erstellt hat, kann ein Schwanz sein.

Wenige Links und der Kern

{ kind: 'degree', minDegree: 2 }
{ kind: 'kcore', k: 2 }

Diese Regeln nehmen Knoten aus der Arbeitsfläche, je nachdem, wie gut sie verknüpft sind, und falten sie in die Knoten, an denen sie hängen, sodass die Anzahl auf der Arbeitsfläche bleibt:

Wenige Links (degree) faltet Knoten mit weniger als minDegree Links: Bei 2 werden die Blätter eines Hubs zu einer Gruppe auf dem Hub.
Außerhalb des Kerns (kcore) schält Knoten mit weniger als k Verbindungen ab und macht es dann erneut mit dem, was übrig bleibt, bis jeder verbleibende Knoten k Verbindungen unter den anderen hat. Bei 2 werden ganze Bäume, die an der Grafik hängen, gefaltet, nicht nur ihre Blätter.

Gefaltete Knoten, die dieselben verbleibenden Knoten berühren, teilen sich eine Gruppe, unabhängig von ihrem Typ, und eine Gruppe kann einen einzelnen Knoten enthalten: Auf ihrem Anker steht „1 mehr“. Gefaltete Knoten, die miteinander verbunden sind, gehören zur gleichen Gruppe, sodass sich ein Pfad, der an einem Knotenpunkt hängt, mit den Blättern des Knotenpunktes faltet. Eine Reihe gefalteter Knoten, die nichts berühren, was noch übrig ist, ist eine eigene Gruppe, und jeder Knoten, der mit nichts verbunden ist, teilt eine Gruppe. Beide Einstellungen gehen von 1 bis 10 und Links zählen in beide Richtungen.

Nach der Nachbarregel ist eine Gruppe ein Knotenpunkt dieser Regeln: ihre Verbindungen sind ihre Linien. Eine Gruppe, die alleine vor Anker hängt, bleibt, wie sie ist.

Gemeinschaften

{ kind: 'communities', level: 4 }

Bei Diagrammen, die für die oben genannten Regeln zu groß sind, faltet Communities ganze Nachbarschaften: Knoten, die dichter miteinander verbunden sind als mit dem Rest des Diagramms, werden unabhängig von ihrem Typ zu einer Gruppe. Sie werden mit dem Leiden-Algorithmus gefunden und sind jedes Mal dieselben für denselben Graphen.

level reicht von 1, fein, viele kleine Gemeinden, bis 7, grob, eine Handvoll großer. Im Vereinfachungsmodus handelt es sich um einen Schieberegler, der beim Loslassen aktiviert wird.
Die Communities werden in einem Worker, außerhalb der Seite und nur dann wieder gefunden, wenn sich die Form des Diagramms ändert. In der Zwischenzeit steht auf der Karte Gruppierung… und die vorherigen Gruppen bleiben erhalten. Wo kein Worker starten kann, beispielsweise eine Inhaltssicherheitsrichtlinie, die Blob-Worker blockiert, wird derselbe Code auf der Seite ausgeführt. useWorker: false fragt danach.
Eine Gemeinschaft aus einem Knoten bleibt ein Knoten, und mit Anmerkungen versehene Knoten bleiben wie bei jeder Regel außen vor.
Im Gegensatz zu den anderen integrierten Regeln befindet sich Communities bei der Deklaration nur im Vereinfachungsmodus.

Pivot-Landungen

{ kind: 'landings', minSize: 2 }

In eine Gruppe aufnehmen, in der Fußzeile des Pivot Überprüfungsbereichs, landet die ausgewählten Zeilen gefaltet: eine Gruppe pro Typ, hängend an dem Knoten, auf dem Sie geschwenkt haben. Vierzig IPs kommen als „40 × IP“ statt vierzig Punkte an.

Eine Gruppe enthält das, was diese Aufnahme hinzugefügt enthält. Ein Knoten, der sich bereits auf der Arbeitsfläche befand, bleibt dort, wo er war.
Im Gegensatz zur Nachbarregel bleibt ein Mitglied ****, egal mit welchem Element es später verknüpft wird. Ziehen Sie es heraus, löschen Sie es oder machen Sie die Aufnahme rückgängig, um es zu entfernen. Mit „Rückgängig“ wird die Gruppe aufgelöst, mit „Wiederholen“ wird sie wiederhergestellt.
Ein Typ mit weniger Knoten als minSize (standardmäßig 2) landet als einfache Knoten.
Die Regel wird zuerst ausgeführt, daher sehen die nachfolgenden Regeln jeden Absatz als einen Knoten. Sie müssen es nicht deklarieren: Der erste gruppierte Treppenabsatz fügt es oben im aktivierten Vereinfachungsmodus hinzu. Deklarieren Sie es, um es woanders abzulegen oder seine kleinste Gruppe zu ändern.
Welche Landungen gruppiert werden, gilt für die Sitzung, wie bei offenen Gruppen.
Die landing einer Landing-Gruppe gibt an, woher sie stammt: { runId, pivotId, pivotLabel }, mit der Bezeichnung aus der Pivot-Definition. Ein Chip kann 12 × ip · Event elements lesen, ohne die Lauf-ID zu analysieren.

Um jedes Pivot-Ergebnis gruppiert zu erhalten, legen Sie pivotIngestGrouped fest. Ein-Klick-Läufe und autoIngest Pivots, die nie die Überprüfung öffnen, landen dann auch gruppiert:

new Pivotick(el, data, { pivotIngestGrouped: true })

Die Fußzeile der Rezension folgt der Option:

`pivotIngestGrouped`	Ausgewählte Aufnahme und Alles aufnehmen	Zweiter Knopf
aus (Standard)	Land locker	In einer Gruppe aufnehmen
auf	Land gruppiert	Los einnehmen

Wenn UI.simplify ausgeschaltet ist, führt die Option nichts aus und es gibt keine zweite Schaltfläche.

Um eine Aufnahme aus dem Code auszuwählen, übergeben Sie group:

await graph.pivots.ingest('correlations', 'triage', { group: true })

Benutzerdefinierte Regeln

Eine eigene Regel ist eine partition(view), die einen Schlüssel pro Knoten zurückgibt:

{
    kind: 'custom',
    id: 'bySensor',
    label: 'By sensor',                      // its name in the Simplify mode
    description: 'Sightings reported by the same sensor.',
    minSize: 2,                              // the default for a custom rule
    partition: (view) => new Map(view.nodes
        .filter((node) => view.typeOf(node) === 'sighting')
        .map((node) => [node.id, node.getData().sensor])),
}

view ist der Graph, wie ihn diese Regel sieht:

Mitglied	Was es ist
`nodes`	Die Knoten, die diese Regel gruppieren kann: Was die Filter passiert, wobei die Gruppen früherer Regeln anstelle ihrer Mitglieder verwendet werden. Annotierte Knoten, herausgezogene Knoten und erweiterte Cluster werden weggelassen.
`inNeighbours(node)` / `outNeighbours(node)`	Die gezeichneten Knoten mit einer Linie zu oder von diesem.
`typeOf(node)`	Der Typ, nach dem die Regel gruppiert: `UI.simplify.typeOf`, sonst `render.nodeTypeAccessor`.
`groupOf(node)`	Die Gruppe hinter einem Knoten, wenn es sich um einen Knoten handelt, bei dem zuvor eine Regel erstellt wurde.

Ein aus der Karte ausgeschlossener Knoten bleibt er selbst und IDs, die nicht in view.nodes sind, werden ignoriert. Eine Regel, die auslöst, wird ausgeschaltet, ihre Karte im Vereinfachungsmodus sagt dies und die anderen Regeln laufen weiterhin.

Der Vereinfachungsmodus

Die Schaltfläche Vereinfachen auf der Leiste öffnet eine Karte pro Regel in der Reihenfolge der Ausführung: ein Schalter, seine Einstellung und was die Regel bewirkt hat. Die Einstellung ist ein −/+ Stepper für die kleinste Gruppe, die wenigsten Links oder die Kernstärke und ein Schieberegler für die Community-Ebene. Von der App deklarierte Regeln tragen ein app-Tag. In der Zusammenfassung oben wird angezeigt, wie viele Knoten sich auf der Arbeitsfläche befinden und wie viele die Filter passieren. Die Leistenschaltfläche zählt die Gruppen, während alle Regeln aufgehoben werden.

Arbeiten mit einer Gruppe

Eine Gruppe wird als Knoten gezeichnet und fungiert für ihre Mitglieder, sofern dies eindeutig ist.

Öffnen es mit einem Doppelklick, Enter, der Seitenleiste oder dem Kontextmenü. Seine Mitglieder kehren als gewöhnliche Knoten zurück, innerhalb einer Waschung in der Farbe der Gruppe, und ein leichter Zug hält sie zusammen. Ziehen Sie den Chip darüber, um sie alle zu verschieben. Sein × faltet sie zurück. Der Tooltip benennt die Regel, die die Gruppe erstellt hat. Die Mitglieder kehren dorthin zurück, wo sie gesessen haben. Diejenigen, die keinen eigenen freien Platz haben, verteilen sich in der Gruppe, und die Live-Physik erhält einen sanften Schub, wie bei einem Cluster. simulation.fitViewOnExpandCollapse Passt zur Ansicht beim Öffnen und Schließen. Eine Gruppe mit mehr als UI.simplify.openConfirmAbove (100) Mitgliedern fragt zuerst.
Wählen es aus, um seine Mitglieder in der Seitenleiste in einer sortierbaren Liste anzuzeigen. Herausziehen hält ein Mitglied aus der Gruppe heraus, bis es über sein Kontextmenü wieder eingefügt wird: auf der Arbeitsfläche, während die Gruppe geöffnet ist, oder über seine Zeile im Datendock, unabhängig davon, ob die Gruppe geöffnet ist oder nicht. Bei einer Auswahl werden alle ausgewählten Elemente herausgezogen.
In Tabelle anzeigen, in der Seitenleiste oder im Kontextmenü, listet die Mitglieder im Datendock auf, wo die Spaltenfilter sie weiter eingrenzen. Der Chip über der Tabelle listet jeden Knoten noch einmal auf.
Mitglieder auswählen, Pivot und Löschen wirken sich auf die Mitglieder aus. „Pivot“ und „Delete“ durchlaufen die üblichen Hooks, sodass onBeforeDelete die echten Knoten sieht. Ausblenden, Löschen und Pivotieren einer Auswahl, die Gruppen enthält, wirken sich auch auf ihre Mitglieder aus.
Durch Auswahl einer Gruppe werden die Knoten beleuchtet, mit denen sie verknüpft ist, während durch Auswahl eines Knotens dessen Nachbarn beleuchtet werden. Bearbeiten und Verbinden werden für eine Gruppe nicht angeboten: Sie verfügt über keine eigenen Daten.

Offene Gruppen und herausgezogene Knoten bleiben für die Sitzung bestehen und sind keine Rückgängig-Schritte. Um sie wiederherzustellen, rufen Sie graph.simplify.open() und pullOut() auf.

Von Hand gefertigte Gruppen

Wählen Sie zwei oder mehr Knoten aus, dann Gruppieren in der Massenleiste der Seitenleiste oder Ausgewählte Knoten gruppieren im Kontextmenü eines ausgewählten Knotens. Geben Sie einen Titel ein oder behalten Sie den angebotenen Titel bei („3 × IP, 2 × Domain“), und die Auswahl wird in einer Gruppe unter diesem Titel zusammengefasst.

Eine handgemachte Gruppe gewinnt. Ihre Regel, Handgefertigt, läuft vor allen anderen, sodass ein ausgewählter Knoten jede Regelgruppe verlässt. Eine ausgewählte Gruppe gibt ihre Mitglieder ab, und ein in eine zweite handgemachte Gruppe aufgenommener Knoten verlässt die erste. Annotierte Knoten und offene Cluster bleiben außen vor, und die Eingabeaufforderung gibt an, wie viele.
Es behält seine Mitglieder was auch immer sie verlinken. Eines, das gelöscht oder herausgefiltert wird, wird nicht gezeichnet; Eine Gruppe, die mit einem Mitglied übrig bleibt, wird überhaupt nicht gezogen und kommt mit ihren Mitgliedern zurück.
Umbenennen und Gruppierung aufheben über die Seitenleiste oder das Kontextmenü. Ein leerer Titel beschriftet es erneut nach seinen Typen. Die Funktion Gruppierung aufheben der Massenleiste entfernt jede handgemachte Gruppe, die die Auswahl enthält oder in der sie sich befindet.
Gruppieren, Umbenennen und Gruppierung aufheben sind Schritte zum Rückgängigmachen, im Gegensatz zum Öffnen oder Herausziehen.
Der Ansichtsstatus lautet: nicht exportiert und beim erneuten Laden verschwunden. Um es zu behalten, speichern Sie getManualGroups() und geben Sie es an setManualGroups() zurück. Gruppen, die direkt nach new Graph() wiederhergestellt, geöffnet oder gezogen werden, sind Teil des Eröffnungslayouts: Eine geschlossene Gruppe wird als ein Punkt platziert, die Mitglieder einer offenen Gruppe werden zusammengehalten.

const id = graph.simplify.groupNodes(['ip-1', 'ip-2', 'dom-7'], 'Suspicious infra')
graph.simplify.renameGroup(id, 'Cleared infra')
graph.simplify.ungroup(id)

Suchen

Die Suche durchsucht jeden Knoten, auch die gefalteten.

Ein Match innerhalb einer Gruppe sagt dies in seiner Ergebniszeile: in 12 × ip.
Wenn Sie darauf klicken, wird die Gruppe geöffnet und der Knoten ausgewählt, wie es bei Mitglieder auswählen der Fall wäre. Eine Gruppe mit mehr als openConfirmAbove Mitgliedern bleibt geschlossen und wird stattdessen ausgewählt.
Alles auf der Arbeitsfläche anzeigen, die letzte Zeile der Ergebnisse oder Umschalt+Eingabetaste, schließt die Suche und beleuchtet jede Übereinstimmung; alles andere verblasst. Eine Gruppe mit Streichhölzern ist ebenfalls beleuchtet und ein Bogen in der Motivfarbe über dem Ring zeigt ihren Anteil an. Der Tooltip zählt sie: 2 von 12 entsprechen „198,51“. Esc, ein Klick auf eine leere Arbeitsfläche oder die nächste Suche beendet sie.

Wenn Sie den Mauszeiger über einen Legendeneintrag bewegen, werden Gruppen auf die gleiche Weise markiert: Eine Gruppe, die Knoten dieses Eintrags enthält, wird mit ihrem Anteil auf dem Ring beleuchtet, sodass eine Gruppe, die Typen mischt, nicht als alles von einem gelesen wird.

Eine App mit eigener Suche kann ihre Treffer auf die gleiche Weise mit graph.simplify.setMatches(nodes, query) markieren und mit setMatches([]) löschen.

Das Aussehen

Eine Gruppe ist ein Ring um eine Scheibe in der Farbe ihres Typs, mit der Zählung auf der Scheibe, sobald Platz dafür ist, und einer Beschriftung darunter. Es wächst mit seiner Anzahl bis zu einer bestimmten Grenze. Eine Gruppe, die Typen mischt, erhält eine neutrale Scheibe und einen nach Typen aufgeteilten Ring.

Die Bezeichnung ist standardmäßig 12 × ip. typeLabel benennt Ihre Typen:

UI: {
    simplify: {
        typeLabel: (type, count) => `${count} ${count === 1 ? type : `${type}s`}`,
    },
}

render.groupStyle(group) gibt eine NodeStyle zurück, die über dem Standard liegt, sodass tiers, html, shape und Abzeichen auf einer Gruppe wie auf einem Knoten funktionieren. render.groupOutline(group) legt fest, was der Chip über einer offenen Gruppe sagt:

render: {
    groupStyle: (group) => group.rule === 'bySensor' ? { color: '#6b7280' } : undefined,
    groupOutline: (group) => `${group.members.length} from ${group.rule}`,
}

groupStyle erhält außerdem base, den Stil, den die Bibliothek zeichnen würde. Was Sie zurückgeben, ersetzt seine Schlüssel, sodass ein Host, der eine Stufe hinzufügt, base.tiers verteilt, um die Zählung auf der Disc beizubehalten:

render: {
    groupStyle: (group, base) => ({
        tiers: [...(base.tiers ?? []), { width: 140, height: 44, style: { html: () => chip(group) } }],
    }),
}

Jeder erhält eine GroupInfo:

Feld	Was es ist
`id`	Stabil, während die Gruppe die meisten ihrer Mitglieder behält.
`rule`	`'neighbours'`, `'chains'`, `'degree'`, `'kcore'`, `'communities'`, `'landings'`, `'manual'` oder `id` einer benutzerdefinierten Regel.
`members`	Die echten Knoten, für die es steht.
`typeCounts`	Wie viele Mitglieder jedes Typs; `''` ist kein Typ.
`anchors`	Die gezeichneten Knoten, mit denen es verknüpft ist, einschließlich Gruppen.
`open`	Ob seine Mitglieder wieder auf der Arbeitsfläche sind.
`level`	Die Community-Ebene, auf der es gefunden wurde.
`title`	Der Titel einer handgemachten Gruppe.
`landing`	Lauf und Pivot einer Landegruppe: `{ runId, pivotId, pivotLabel }`.

Der Tooltip einer Gruppe benennt ihre Regel, listet auf, worauf sie verweist, und bei einer gemischten Gruppe ihre Mitglieder nach Typ. tooltip.renderGroupExtra(group, ctx) fügt Ihre eigenen Zeilen hinzu, wie es renderNodeExtra für einen Knoten tut. Eine Gruppe überspringt tooltip.render und renderNodeExtra, die für die Daten eines Knotens geschrieben werden.

Typen und Farben vom Gastgeber

Gruppen zählen ihre Teile mit render.nodeTypeAccessor und färben sie entsprechend der Stilfarbe jedes Mitglieds. Zwei UI.simplify Optionen ändern das für jede Regel und Gruppe, ohne Stile, Legende oder Filter zu berühren:

typeOf(node) ist der Typ, nach dem jede Regel gruppiert, und jede Gruppe zählt ihre Teile nach: dem Label, den Anteilen eines gemischten Rings, dem Titel einer handgemachten Gruppe. Das eigene typeOf einer Regel gewinnt für diese Regel immer noch.
colorOf(node) ist die Farbe, für die ein Knoten in einer Gruppe steht: die Scheibe und der Ring, die offene Waschung, die Chips des Tooltips. Die Rückgabe von undefined greift auf die Stilfarbe des Knotens zurück. Der gruppeneigene groupStyle hat in der geschlossenen Verlosung weiterhin das letzte Wort.

Ein Host, der nach Elementen formatiert, nach Untertypen gruppiert und seine Knoten selbst zeichnet:

const options = {
    render: {
        nodeTypeAccessor: (node) => node.getData().element,
        nodeStyleMap: { attribute: { shape: 'none', html: drawAttribute } },
    },
    UI: {
        simplify: {
            typeOf: (node) => `${node.getData().element}:${node.getData().subtype}`,
            colorOf: (node) => palette[node.getData().subtype],
        },
    },
}

In der Tabelle

Das Datendock listet die realen Knoten auf. Ein gefalteter Knoten lautet grouped in der Spalte Sichtbarkeit und eine Spalte Gruppe benennt seine Gruppe, sofern es welche gibt. Eine Kante, deren Linie auf eine Gruppe gezeichnet wird, lautet ebenfalls grouped.

Zur Laufzeit

graph.simplify enthält die Regeln und die Gruppen:

Methode	Was es bewirkt
`setRules(rules)` / `getRules()`	Ersetzen Sie die Regeln; Lesen Sie den Zustand jedes Einzelnen und was er getan hat.
`setRuleEnabled(id, on)` / `setRuleSetting(id, n)`	Was der Schalter und der Stepper des Simplify-Modus bewirken. `setRuleMinSize(id, n)` legt nur eine kleinste Gruppe fest.
`getGroups()` / `groupOf(node)`	In jede Gruppe und in die erste Gruppe wurde ein Knoten gefaltet. Eine Gruppe, die später erneut gefaltet wurde, wird neben der Gruppe, die sie hält, ebenfalls aufgeführt, und beide listen ihre Mitglieder auf; `summary().groups` zählt die geschlossenen Gruppen, die die Arbeitsfläche zeichnet.
`open(group)` / `close(group)`	Platzieren Sie die Mitglieder einer Gruppe auf der Arbeitsfläche oder klappen Sie sie zurück.
`pullOut(node)` / `putBack(node)` / `isPulledOut(node)`	Halten Sie einen Knoten von einer Gruppe fern oder lassen Sie ihn zurück.
`groupNodes(nodes, title?)` / `renameGroup(group, title)` / `ungroup(groups)` / `isManual(group)`	Gruppen manuell erstellen, umbenennen oder entfernen; Jeder Schritt ist ein Rückgängigmachen.
`getManualGroups()` / `setManualGroups(list)`	Speichern Sie die handgefertigten Gruppen und stellen Sie sie wieder her.
`groupLanding(runId)` / `ungroupLanding(runId)` / `isLandingGrouped(runId)`	Falten Sie das, was ein Pivot-Lauf hinzufügt, in Landegruppen oder ziehen Sie es wieder los.
`summary()`	Wie viele Knoten werden gezeichnet, passieren die Filter und werden gefaltet?
`setMatches(nodes, query)` / `matchesIn(group)`	Markieren Sie die Übereinstimmungen einer Suche in den Gruppen, in denen sie enthalten sind. Lesen Sie, wie viele eine Gruppe fasst.
`onChange(listener)`	Wird aufgerufen, nachdem sich die Gruppierung geändert hat. gibt seine Abmeldung zurück.

Vereinfachen ​

Regeln ​

Die Nachbarregel ​

Die Kettenregel ​

Wenige Links und der Kern ​

Gemeinschaften ​

Pivot-Landungen ​

Benutzerdefinierte Regeln ​

Der Vereinfachungsmodus ​

Arbeiten mit einer Gruppe ​

Von Hand gefertigte Gruppen ​

Suchen ​

Das Aussehen ​

Typen und Farben vom Gastgeber ​

In der Tabelle ​

Zur Laufzeit ​