Simplificar

Muchos gráficos son en su mayoría repeticiones. Dos eventos comparten cuarenta IP y cada IP cuesta un nodo, un etiqueta y dos aristas aunque lo que importa es "estos dos eventos comparten cuarenta IP". Un centro tiene decenas de hojas que no se unen a ningún otro lugar. Simplificar dobla los nodos que desempeñan el mismo papel en un grupo, sorteado en su lugar:

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

Los grupos son una vista, no datos

graph.getNodes(), getEdges(), la tabla, las exportaciones y el historial de deshacer ven los nodos reales. A partir de ellos se vuelve a calcular un grupo cada vez que cambia el gráfico y no se guarda nada al respecto.

Véalo ejecutándose en Simplifica el gráfico tarjeta.

Reglas

UI.simplify.rules es una lista ordenada. Cada regla proporciona una clave a algunos nodos y los nodos que comparten una La clave se convierte en un grupo, siempre que haya al menos minSize de ellos.

• Las reglas se ejecutan en orden, y cada una ve los grupos que las reglas anteriores crearon como normales nodos. Por lo tanto, un grupo puede volver a agruparse mediante una regla posterior.
• Las reglas se ejecutan después de los filtros de nodo, por lo que un grupo solo retiene lo que les pasa: ocultar tres de cuarenta IP y el grupo dice 37. Las capas de borde no cambian de grupo; apagando solo uno oculta líneas.
• Un nodo con una nota adjunta y un clúster expandido nunca se agrupan. Un grupo cerrado grupos como cualquier otro nodo.
• Una regla declarada está activada a menos que diga enabled: false.

Sin UI.simplify, el modo full ofrece las reglas integradas desactivadas en el carril Simplificar modo; los otros modos no ejecutan nada. UI.simplify.enabled: false elimina la función.

La regla del vecino

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

Pliega nodos de un tipo que se vinculan a exactamente los mismos nodos, de la misma manera: los mismos nodos que apuntan a ellos y los mismos nodos a los que apuntan. Las hojas de un cubo son las caso más simple. Como los eventos A y B comparten tres TTP y cada uno tiene dos propios, se obtiene tres grupos: los tres compartidos entre A y B, y dos en cada lado.

• El tipo es el propio de la regla typeOf, de lo contrario UI.simplify.typeOf, más render.nodeTypeAccessor. Los nodos sin tipo se agrupan entre sí.
• Un nodo vinculado a nada nunca está agrupado: un grupo necesita algo de qué colgarse.
• Un nodo que obtiene un enlace abandona su grupo por el que coincide con sus nuevos vecinos. si que deja menos de minSize, el grupo se disuelve.
• Un grupo mantiene su identidad mientras mantiene a la mayoría de sus miembros, por lo que un nuevo nodo que aterriza con el Los mismos vecinos se unen al grupo existente sin moverlo.

La regla de la cadena

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

Pliega cadenas que cuelgan de un nodo. Un evento que contiene treinta archivos, cada uno con su propio hash, son treinta cadenas file > sha256: los archivos no comparten ningún vecino, ya que cada uno vincula su propio hash, entonces la regla del vecino los deja en paz. La regla de la cadena los pliega en un grupo de archivos. vinculado a un grupo de hashes y dibuja los treinta enlaces entre ellos como una línea.

• La cola de un nodo es un nodo cuyo único enlace proviene de él, seguido aguas abajo mientras cada eslabones escalonados sólo a lo largo de la cadena. Un nodo unido por otros dos, una rama o un ciclo finaliza el cadena allí.
• Nodos que conducen cadenas de la misma forma se pliegan entre sí, cuando comparten la misma otra enlaces y tipo. Cinco pares aislados domain → ip dan un grupo de cinco dominios vinculados a uno grupo de cinco IP.
• Cada nivel de las cadenas también se pliega: debajo del grupo de sus cabezas, o debajo de una cabeza de el suyo cuando no tiene rival.
• Los enlaces cuentan solo en sentido descendente: un nodo cuyo único enlace apunta a otro no es el de ese nodo cola.
• Colocado después de la regla del vecino, dobla lo que queda de esa regla. Un grupo que hizo la regla vecina puede ser una cola.

Pocos enlaces y el núcleo.

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

Estas reglas eliminan los nodos del lienzo según lo bien vinculados que estén y los pliegan en el nodos de los que cuelgan, por lo que el recuento permanece en el lienzo:

• Pocos enlaces (degree) dobla nodos con menos de minDegree enlaces: en 2, las hojas de un centro conviértase en un grupo en el centro.
• Fuera del núcleo (kcore) elimina los nodos con menos de k enlaces y luego lo vuelve a hacer con lo que queda, hasta que cada nodo en pie tenga k enlaces entre los demás. A las 2 se pliega Árboles enteros que cuelgan del gráfico, no sólo sus hojas.

Los nodos plegados que tocan los mismos nodos que quedan en pie comparten un grupo, cualquiera que sea su tipo, y un grupo puede contener un solo nodo: se lee "1 más" en su ancla. Nodos plegados unidos entre sí. van al mismo grupo, por lo que un camino que cuelga de un centro se pliega con las hojas del centro. una racha de Los nodos plegados que no tocan nada que quede en pie son un grupo en sí mismos, y cada nodo vinculado a nada comparte un grupo. Ambas configuraciones van del 1 al 10 y los enlaces cuentan en ambos sentidos.

Después de la regla de vecino, un grupo es un nodo de estas reglas: sus enlaces son sus líneas. un grupo colgando solo de su ancla se queda como está.

Comunidades

{ kind: 'communities', level: 4 }

Para gráficos demasiado grandes para las reglas anteriores, Comunidades pliega vecindarios enteros: nodos más densamente vinculados entre sí que con el resto del gráfico se convierten en un grupo, cualquiera que sea su tipos. Se encuentran con el algoritmo de Leiden, siempre los mismos para el mismo gráfico.

• level va de 1, fino, muchas comunidades pequeñas, a 7, grueso, un puñado de grandes unos. En el modo Simplificar, es un control deslizante que se aplica cuando lo sueltas.
• Las comunidades se encuentran en un trabajador, fuera de la página y solo nuevamente cuando el gráfico cambios de forma. Mientras tanto en la tarjeta se lee Agrupando… y los grupos anteriores quedan. donde no trabajador puede iniciar, una política de seguridad de contenido que bloquea a los trabajadores de blobs, por ejemplo, el mismo código se ejecuta en la página; useWorker: false pide eso.
• Una comunidad de un nodo sigue siendo un nodo y los nodos anotados quedan fuera, como ocurre con todas las reglas.
• A diferencia de otras reglas integradas, Comunidades solo está en modo Simplificar cuando se declara.

Aterrizajes de pivote

{ kind: 'landings', minSize: 2 }

Ingerir en un grupo, en el pivote Pie de página del panel de revisión, coloca las filas seleccionadas Doblado: un grupo por tipo, colgando del nodo sobre el que giró. Cuarenta IP llegan como "40 × ip" en lugar de cuarenta puntos.

• Un grupo retiene lo que ingieren añadido. Queda un nodo que ya estaba en el lienzo donde estaba.
• Un miembro permanece con lo que se vincule más adelante, a diferencia de la regla del vecino. Sácalo, bórralo o deshacer la ingesta para eliminarlo. Deshacer disuelve el grupo y rehacer lo devuelve.
• Un tipo con menos nodos que minSize (2 por defecto) aterriza como nodos simples.
• La regla se ejecuta primero, por lo que las reglas posteriores ven cada aterrizaje como un nodo. No es necesario declararlo: el primer rellano agrupado lo agrega en la parte superior del modo Simplificar, activado. Declarelo para ponerlo en otro lugar o cambiar su grupo más pequeño.
• Los descansillos que se agrupan duran toda la sesión, al igual que los grupos abiertos.
• Los nombres landing de un grupo de aterrizaje de donde proviene: { runId, pivotId, pivotLabel }, con la etiqueta de la definición del pivote. Un chip puede leer 12 × ip · Event elements sin analizar la identificación de ejecución.

Para agrupar todos los resultados de pivote, establezca pivotIngestGrouped. Se ejecuta con un clic y autoIngest pivotes, que nunca abren Revisión, luego aterrizan agrupados también:

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

El pie de página de la reseña sigue la opción:

pivotIngestGrouped	Ingerir seleccionado y Ingerir todo	Segundo botón
apagado (predeterminado)	tierra suelta	Ingerir en grupo
en	terreno agrupado	Ingerir suelto

Con UI.simplify desactivado, la opción no hace nada y no hay un segundo botón.

Para elegir una ingesta del código, pase group:

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

Reglas personalizadas

Una regla propia es partition(view) que devuelve una clave por nodo:

{
    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 es el gráfico tal como lo ve esta regla:

Miembro	que es
nodes	Los nodos que esta regla puede agrupar: lo que pasa los filtros, con grupos de reglas anteriores en lugar de sus miembros. Los nodos anotados, los nodos extraídos y los clústeres expandidos quedan fuera.
inNeighbours(node) / outNeighbours(node)	Los nodos dibujados con una línea hacia o desde este.
typeOf(node)	Escriba la regla agrupa por: UI.simplify.typeOf, de lo contrario render.nodeTypeAccessor.
groupOf(node)	El grupo detrás de un nodo, cuando es uno creado por una regla anterior.

Un nodo que se deja fuera del mapa permanece y los identificadores que no están en view.nodes se ignoran. un La regla que lanza está desactivada, su tarjeta en el modo Simplificar lo dice y las otras reglas todavía corre.

El modo simplificar

El botón Simplificar en el riel abre una tarjeta por regla, en orden de ejecución: un interruptor, su configuración y lo que la regla plegó. La configuración es un paso a paso − / + para el grupo más pequeño, el la menor cantidad de enlaces o la fortaleza principal, y un control deslizante para el nivel de Comunidades. Reglas declaradas por la aplicación lleva una etiqueta app. El resumen en la parte superior lee cuántos nodos hay en el lienzo. de cuántos pasan los filtros, y el botón del carril cuenta los grupos mientras se pliega cualquier regla.

Trabajando con un grupo

Un grupo se dibuja como un nodo y actúa en nombre de sus miembros siempre que esto sea inequívoco.

• Ábrelo con un doble clic, Intro, la barra lateral o el menú contextual. sus miembros vienen como nudos ordinarios, dentro de un lavado en el color del grupo, y un ligero tirón los mantiene juntos. Arrastra el chip encima de ellos para moverlos a todos; sus × los dobla hacia atrás. Su información sobre herramientas nombra la regla que formó el grupo. Los miembros regresan a donde estaban; aquellos sin libertad lugar propio se extiende por todo el grupo, y la física en vivo recibe un suave empujón, como para un cúmulo. simulation.fitViewOnExpandCollapse ajusta la vista en apertura y cierre. un grupo con más miembros que UI.simplify.openConfirmAbove (100) pregunta primero.
• Seleccione para ver sus miembros en la barra lateral, en una lista ordenable. Extraer mantiene un miembro fuera del grupo hasta que se vuelva a colocar, desde su menú contextual: en el lienzo mientras el grupo está abierto, o desde su fila en el panel de datos, ya sea que el grupo esté abierto o no. Sobre una selección, extrae a todos los miembros seleccionados.
• Ver en tabla, en la barra lateral o en el menú contextual, enumera los miembros en el panel de datos, donde los filtros de columna los estrechan aún más. El chip sobre la mesa enumera cada nodo nuevamente.
• Seleccionar miembros, Pivotar y Eliminar actúan sobre los miembros. Pasar por Pivotar y Eliminar los ganchos habituales, por lo que onBeforeDelete ve los nodos reales. Ocultar, eliminar y pivotar en un La selección que sostiene a los grupos también actúa sobre sus miembros.
• Seleccionar un grupo ilumina los nodos a los que se vincula, del mismo modo que al seleccionar un nodo se ilumina su vecinos. La edición y la conexión no se ofrecen en un grupo: no tiene datos propios.

Los grupos abiertos y los nodos extraídos duran toda la sesión y no son pasos para deshacer. para restaurar ellos, llame a graph.simplify.open() y pullOut().

Grupos hechos a mano.

Seleccione dos nodos o más, luego Agrupar en la barra de volumen de la barra lateral o Agrupar nodos seleccionados en el menú contextual de un nodo seleccionado. Escriba un título o conserve el ofrecido ("3 × ip, 2 × dominio"), y la selección se agrupa en un grupo bajo ese título.

• Un grupo hecho a mano gana. Su regla, A mano, se ejecuta antes que cualquier otra, por lo que un nodo elegido abandona cualquier grupo de reglas. Un grupo seleccionado da a sus miembros, y un nodo elegido en un segundo El grupo hecho a mano sale del primero. Los nodos anotados y los clusters abiertos quedan fuera, y el El mensaje dice cuántos.
• Mantiene a sus miembros independientemente de lo que enlacen. Uno que se elimina o filtra no es dibujado; un grupo que se queda con un miembro no se sortea en absoluto y regresa con sus miembros.
• Renombrar y Desagrupar desde su panel de barra lateral o su menú contextual. Un título vacío lo etiqueta por sus tipos nuevamente. Desagrupar de la barra de volumen elimina todos los grupos hechos a mano que la selección se mantiene o se sienta.
• Agrupar, Cambiar nombre y Desagrupar son pasos para deshacer, a diferencia de abrir o retirar.
• Es el estado de visualización: no exportado y se ha recargado. Para conservarlo, guarde getManualGroups() y devuélvelo a setManualGroups(). Grupos restaurados, abiertos o retirados inmediatamente después new Graph() son parte del diseño de apertura: un grupo cerrado se coloca como un punto, un grupo abierto los miembros de uno se mantienen juntos.

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

Buscando

La búsqueda examina todos los nodos, incluidos los plegados.

• Una coincidencia dentro de un grupo lo dice en su fila de resultados: in 12 × ip.
• Al seleccionarlo se abre el grupo y se selecciona el nodo, como lo haría Seleccionar miembros. un grupo con más miembros que openConfirmAbove permanece cerrado y se selecciona en su lugar.
• Mostrar todo en el lienzo, la última fila de los resultados o Shift+Enter, cierra el busca y enciende cada cerilla; todo lo demás se desvanece. También se enciende un grupo con cerillas, y un arco en el color del tema sobre su anillo muestra su participación. Su descripción emergente los cuenta: 2 de 12 coinciden "198.51". Esc, un clic en el lienzo vacío o la siguiente búsqueda lo finaliza.

Al pasar el cursor sobre una entrada de leyenda, se marcan los grupos de la misma manera: un grupo que contiene nodos de esa entrada se ilumina, con su parte en su anillo, por lo que un grupo que mezcla tipos no se lee como uno solo.

Una aplicación con búsqueda propia puede marcar sus coincidencias de la misma manera con graph.simplify.setMatches(nodes, query) y bórrelos con setMatches([]).

la mirada

Un grupo es un anillo alrededor de un disco del color de su tipo, con la cuenta en el disco una vez que hay espacio para ello y una etiqueta debajo. Crece con su cuenta, hasta un límite. Un grupo que mezcla tipos obtiene un disco neutral y un anillo dividido por tipo.

La etiqueta es 12 × ip de forma predeterminada. typeLabel nombra tus tipos:

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

render.groupStyle(group) devuelve un NodeStyle superpuesto al valor predeterminado, por lo que tiers, html, shape y las insignias funcionan en un grupo como en un nodo. render.groupOutline(group) establece lo que chip sobre un grupo abierto dice:

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

groupStyle también recibe base, el estilo que dibujaría la biblioteca. Lo que devuelves reemplaza sus claves, por lo que un host que agrega un nivel se extiende base.tiers para mantener la cuenta en el disco:

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

Cada uno recibe un GroupInfo:

campo	que es
id	Estable mientras el grupo mantiene a la mayoría de sus miembros.
rule	'neighbours', 'chains', 'degree', 'kcore', 'communities', 'landings', 'manual' o id de una regla personalizada.
members	Los nodos reales que representa.
typeCounts	Cuántos miembros de cada tipo; '' no es ningún tipo.
anchors	Los nodos dibujados a los que se vincula, incluidos los grupos.
open	Si sus miembros están de vuelta en la lona.
level	El nivel de comunidades en el que se encontró.
title	El título de un grupo hecho a mano.
landing	Carrera y pivote de un grupo de aterrizaje: { runId, pivotId, pivotLabel }.

La información sobre herramientas de un grupo nombra su regla, enumera a qué se vincula y, para un grupo mixto, su miembros por tipo. tooltip.renderGroupExtra(group, ctx) agrega tus propias líneas, como renderNodeExtra lo hace para un nodo. Un grupo se salta tooltip.render y renderNodeExtra, lo que están escritos para los datos de un nodo.

Tipos y colores del anfitrión.

Los grupos cuentan sus partes por render.nodeTypeAccessor y coloréalas según el nombre de cada miembro. color de estilo. Dos opciones UI.simplify cambian eso para cada regla y grupo, sin tocando estilos, la leyenda o filtros:

• typeOf(node) es el tipo por el que se agrupa cada regla y cada grupo cuenta sus partes por: el etiqueta, acciones de un anillo mixto, título de un grupo hecho a mano. La propia regla typeOf todavía gana por esa regla.
• colorOf(node) es el color que representa un nodo en un grupo: el disco y el anillo, el abierto lavar, las virutas de la información sobre herramientas. Al regresar undefined se vuelve al color de estilo del nodo. un El propio groupStyle del grupo aún tiene la última palabra sobre el sorteo cerrado.

Un host que diseña por elemento, agrupa por subtipo y dibuja sus nodos él mismo:

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],
        },
    },
}

en la mesa

La base de datos enumera los nodos reales. Un nodo plegado dice grouped en la columna Visibilidad, y una columna Grupo nombra su grupo mientras haya alguno. Un borde cuya línea se dibuja a un el grupo también lee grouped.

En tiempo de ejecución

graph.simplify contiene las reglas y los grupos:

Método	que hace
setRules(rules) / getRules()	Reemplazar las reglas; lea el estado de cada uno y lo que dobló.
setRuleEnabled(id, on) / setRuleSetting(id, n)	Qué hacen el interruptor y el paso a paso del modo Simplificar. setRuleMinSize(id, n) establece solo un grupo más pequeño.
getGroups() / groupOf(node)	Cada grupo, y el primer grupo en el que se integró un nodo. Un grupo cuya regla posterior se vuelve a plegar también aparece en la lista, junto al grupo que la contiene, y ambos enumeran sus miembros; summary().groups cuenta los grupos cerrados que dibuja el lienzo.
open(group) / close(group)	Coloque a los miembros de un grupo en el lienzo o dóblelos.
pullOut(node) / putBack(node) / isPulledOut(node)	Mantenga un nodo fuera de cualquier grupo o déjelo regresar.
groupNodes(nodes, title?) / renameGroup(group, title) / ungroup(groups) / isManual(group)	Cree, cambie el título o elimine grupos a mano; cada uno es un paso para deshacer.
getManualGroups() / setManualGroups(list)	Guarde los grupos hechos a mano y restáurelos.
groupLanding(runId) / ungroupLanding(runId) / isLandingGrouped(runId)	Doble lo que agrega una carrera de pivote en grupos de aterrizaje, o suéltelo nuevamente.
summary()	Cuantos nodos se dibujan, pasan los filtros y se pliegan.
setMatches(nodes, query) / matchesIn(group)	Marcar las coincidencias de una búsqueda en los grupos que las contienen; lea cuántos tiene un grupo.
onChange(listener)	Se llama después de que cambia la agrupación; devuelve su baja.