Package ghidra.graph.viewer.layout

# Class AbstractVisualGraphLayout<V extends VisualVertex,E extends VisualEdge<V>>

java.lang.Object
edu.uci.ics.jung.algorithms.layout.AbstractLayout<V,E>
ghidra.graph.viewer.layout.AbstractVisualGraphLayout<V,E>

Type Parameters:
  `V` - the vertex type
  `E` - the edge type

All Implemented Interfaces:
  `com.google.common.base.Function<V,Point2D>`, `edu.uci.ics.jung.algorithms.layout.Layout<V,E>`, `VisualGraphLayout<V,E>`, `Function<V,Point2D>`

public abstract class AbstractVisualGraphLayout<V extends VisualVertex,E extends VisualEdge<V>> extends edu.uci.ics.jung.algorithms.layout.AbstractLayout<V,E> implements VisualGraphLayout<V,E>
A base layout that marries the Visual Graph and Jung layout interfaces. This class allows you to create new layouts while stubbing the Jung layout methods.

This class essentially takes in client-produced grid row and column indices and produces layout locations for those values.

This an implementation the Jung `Layout` interface that handles most of the layout implementation for you. Things to know:

- You should call initialize() inside of your constructor
- You must implement `performInitialGridLayout(VisualGraph)` - this is where you align your vertices (and optionally edge articulations) on a grid. This grid will be translated into layout space points for you.
- If you wish to use articulation points in your edges, you must override `usesEdgeArticulations()` to return true.

By default, this class will create x-position values that are aligned with the column's x-position. You can override `getVertexLocation(VisualVertex, Column, Row, Rectangle)` in order to center the vertex within its column `getCenteredVertexLocation(VisualVertex, Column, Row, Rectangle)`. Also note though that if your layout returns true for `isCondensedLayout()`, then the centering will be condensed and slightly off.

See Also:
  - `GridLocationMap`
  - `LayoutPositions`

- ## Field Summary

  Fields
  Modifier and Type
  Field
  Description
  `protected boolean`
  `layoutInitialized`
  `protected String`
  `layoutName`
  `protected TaskMonitor`
  `monitor`

  ### Fields inherited from class edu.uci.ics.jung.algorithms.layout.AbstractLayout

  `graph, initialized, locations, size`

- ## Constructor Summary

  Constructors
  Modifier
  Constructor
  Description
  `protected`
  `AbstractVisualGraphLayout(edu.uci.ics.jung.graph.Graph<V,E> graph, String layoutName)`

- ## Method Summary

  Modifier and Type
  Method
  Description
  `void`
  `addLayoutListener(LayoutListener<V,E> listener)`
  Adds a layout listener
  `protected void`
  `applyNewArticulations(Map<E,List<Point2D>> edgeArticulations)`
  `protected void`
  `applyNewLocations(Map<V,Point2D> newLocations)`
  `LayoutPositions<V,E>`
  `calculateLocations(VisualGraph<V,E> visualGraph, TaskMonitor taskMonitor)`
  Signals to again layout the current graph.
  `VisualGraphLayout<V,E>`
  `cloneLayout(VisualGraph<V,E> newGraph)`
  Creates a new version of this layout using the given graph.
  `protected void`
  `condenseEdges(List<Row<V>> rows, Map<E,List<Point2D>> newEdgeArticulations, double centerX, double centerY)`
  `protected void`
  `condenseVertices(List<Row<V>> rows, Map<V,Point2D> newLocations, VisualGraphVertexShapeTransformer<V> transformer, double centerX, double centerY)`
  `abstract AbstractVisualGraphLayout<V,E>`
  `createClonedLayout(VisualGraph<V,E> newGraph)`
  This class has implemented `cloneLayout(VisualGraph)` in order to properly initialize location information in the layout so that subclasses do not have to.
  `void`
  `dispose()`
  Cleanup any resource being managed by this layout.
  `protected LayoutPositions<V,E>`
  `doCalculateLocations(VisualGraph<V,E> g, TaskMonitor taskMonitor)`
  `protected Point2D`
  `getCenteredEdgeLocation(Column col, Row<V> row)`
  `protected Point2D`
  `getCenteredVertexLocation(V v, Column col, Row<V> row, Rectangle bounds)`
  Returns a location for the given vertex that is centered within its cell
  `protected double`
  `getCondenseFactor()`
  The amount (from 0 to 1.0) by which to condense the vertices of the graph when that feature is enabled.
  `edu.uci.ics.jung.visualization.renderers.Renderer.EdgeLabel<V,E>`
  `getEdgeLabelRenderer()`
  Returns an optional custom edge label renderer.
  `protected Point2D`
  `getEdgeLocation(Column col, Row<V> row)`
  `edu.uci.ics.jung.visualization.renderers.BasicEdgeRenderer<V,E>`
  `getEdgeRenderer()`
  Returns an optional edge renderer.
  `com.google.common.base.Function<E,Shape>`
  `getEdgeShapeTransformer()`
  Returns an optional edge shape transformer.
  `String`
  `getLayoutName()`
  Returns the name of this layout
  `protected Point2D`
  `getVertexLocation(V v, Column col, Row<V> row, Rectangle bounds)`
  `void`
  `initialize()`
  `protected void`
  `initializeClonedLayout(AbstractVisualGraphLayout<V,E> newLayout)`
  Takes the given layout and copies the layout information this layout into that layout
  `protected boolean`
  `isCondensedLayout()`
  Returns true if this layout is in a condensed mode, which means to reduce space between vertices and edges.
  `protected abstract GridLocationMap<V,E>`
  `performInitialGridLayout(VisualGraph<V,E> g)`
  This is the method that is called to perform the actual layout.
  `protected Map<E,List<Point2D>>`
  `positionEdgeArticulationsInLayoutSpace(VisualGraphVertexShapeTransformer<V> transformer, Map<V,Point2D> vertexLayoutLocations, Collection<E> edges, LayoutLocationMap<V,E> layoutLocations)`
  `protected LayoutPositions<V,E>`
  `positionInLayoutSpaceFromGrid(VisualGraph<V,E> visualGraph, GridLocationMap<V,E> gridLocations)`
  `void`
  `removeLayoutListener(LayoutListener<V,E> listener)`
  Removes a layout listener
  `void`
  `reset()`
  `void`
  `setLocation(V v, Point2D location)`
  `void`
  `setLocation(V v, Point2D location, LayoutListener.ChangeType changeType)`
  Allows the client to change the location while specifying the type of change
  `void`
  `setTaskMonitor(TaskMonitor monitor)`
  `boolean`
  `usesEdgeArticulations()`
  Returns true if this layout uses articulated edges.

  ### Methods inherited from class edu.uci.ics.jung.algorithms.layout.AbstractLayout

  `apply, getGraph, getSize, getX, getY, isLocked, lock, lock, offsetVertex, setGraph, setInitializer, setLocation, setSize`

  ### Methods inherited from class java.lang.Object

  `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

  ### Methods inherited from interface com.google.common.base.Function

  `apply, equals`

  ### Methods inherited from interface java.util.function.Function

  `andThen, compose`

  ### Methods inherited from interface edu.uci.ics.jung.algorithms.layout.Layout

  `getGraph, getSize, isLocked, lock, setGraph, setInitializer, setSize`

  ### Methods inherited from interface ghidra.graph.viewer.layout.VisualGraphLayout

  `getVisualGraph`

- ## Field Details

  - ### layoutName

    protected String layoutName

  - ### layoutInitialized

    protected boolean layoutInitialized

  - ### monitor

    protected TaskMonitor monitor

- ## Constructor Details

  - ### AbstractVisualGraphLayout

    protected AbstractVisualGraphLayout(edu.uci.ics.jung.graph.Graph<V,E> graph, String layoutName)

- ## Method Details

  - ### getLayoutName

    public String getLayoutName()
    Returns the name of this layout
    Returns:
      the name of this layout

  - ### performInitialGridLayout

    protected abstract GridLocationMap<V,E> performInitialGridLayout(VisualGraph<V,E> g) throws CancelledException
    This is the method that is called to perform the actual layout. While this method is running, the `monitor` variable has been set so that you can call `TaskMonitor.checkCancelled()`.
    Parameters:
      `g` - the graph
    Returns:
      the new grid location
    Throws:
      `CancelledException` - if the operation was cancelled

  - ### setTaskMonitor

    public void setTaskMonitor(TaskMonitor monitor)

  - ### getEdgeRenderer

    public edu.uci.ics.jung.visualization.renderers.BasicEdgeRenderer<V,E> getEdgeRenderer()
    Description copied from interface: `VisualGraphLayout`
    Returns an optional edge renderer. This is used to render each edge.
    Specified by:
      `getEdgeRenderer` in interface `VisualGraphLayout<V extends VisualVertex,E extends VisualEdge<V>>`
    Returns:
      an optional edge renderer

  - ### getEdgeShapeTransformer

    public com.google.common.base.Function<E,Shape> getEdgeShapeTransformer()
    Description copied from interface: `VisualGraphLayout`
    Returns an optional edge shape transformer. This is used to create shapes for each edge.
    Specified by:
      `getEdgeShapeTransformer` in interface `VisualGraphLayout<V extends VisualVertex,E extends VisualEdge<V>>`
    Returns:
      an optional edge shape transformer

  - ### getEdgeLabelRenderer

    public edu.uci.ics.jung.visualization.renderers.Renderer.EdgeLabel<V,E> getEdgeLabelRenderer()
    Description copied from interface: `VisualGraphLayout`
    Returns an optional custom edge label renderer. This is used to add labels to the edges.
    Specified by:
      `getEdgeLabelRenderer` in interface `VisualGraphLayout<V extends VisualVertex,E extends VisualEdge<V>>`
    Returns:
      an optional renderer

  - ### usesEdgeArticulations

    public boolean usesEdgeArticulations()
    Description copied from interface: `VisualGraphLayout`
    Returns true if this layout uses articulated edges. All `VisualEdge`s have the ability to articulate. This method servers as a shortcut for algorithms so that they need not loop over all edges to determine if they have articulations. (Looping over large graphs is time intensive.)

    What are articulations?

    Specified by:
      `usesEdgeArticulations` in interface `VisualGraphLayout<V extends VisualVertex,E extends VisualEdge<V>>`
    Returns:
      true if this layout uses articulated edges.

  - ### reset

    public void reset()
    Specified by:
      `reset` in interface `edu.uci.ics.jung.algorithms.layout.Layout<V extends VisualVertex,E extends VisualEdge<V>>`

  - ### dispose

    public void dispose()
    Description copied from interface: `VisualGraphLayout`
    Cleanup any resource being managed by this layout.
    Specified by:
      `dispose` in interface `VisualGraphLayout<V extends VisualVertex,E extends VisualEdge<V>>`

  - ### isCondensedLayout

    protected boolean isCondensedLayout()
    Returns true if this layout is in a condensed mode, which means to reduce space between vertices and edges. This is useful to save space. Subclasses may choose to have this setting controlled via an option that the user can toggle.
    Returns:
      true for a condensed layout

  - ### initialize

    public void initialize()
    Specified by:
      `initialize` in interface `edu.uci.ics.jung.algorithms.layout.Layout<V extends VisualVertex,E extends VisualEdge<V>>`

  - ### calculateLocations

    public LayoutPositions<V,E> calculateLocations(VisualGraph<V,E> visualGraph, TaskMonitor taskMonitor)
    Description copied from interface: `VisualGraphLayout`
    Signals to again layout the current graph. The locations generated by the layout will be returned, but not actually applied to the graph. This allows clients to generate new locations and then apply them in a delayed fashion, like for animation.
    Specified by:
      `calculateLocations` in interface `VisualGraphLayout<V extends VisualVertex,E extends VisualEdge<V>>`
    Parameters:
      `visualGraph` - the graph that contains the vertices to layout
      `taskMonitor` - the task monitor used to report progress or to cancel
    Returns:
      the layout locations

  - ### doCalculateLocations

    protected LayoutPositions<V,E> doCalculateLocations(VisualGraph<V,E> g, TaskMonitor taskMonitor)

  - ### createClonedLayout

    public abstract AbstractVisualGraphLayout<V,E> createClonedLayout(VisualGraph<V,E> newGraph)
    This class has implemented `cloneLayout(VisualGraph)` in order to properly initialize location information in the layout so that subclasses do not have to. Each subclass still needs to create the new instance of the layout that is being cloned, as this class does not know how to do so.
    Parameters:
      `newGraph` - the new graph for the new layout
    Returns:
      the new layout

  - ### cloneLayout

    public VisualGraphLayout<V,E> cloneLayout(VisualGraph<V,E> newGraph)
    Description copied from interface: `VisualGraphLayout`
    Creates a new version of this layout using the given graph. Also, the new layout will have the same state as this layout (i.e., vertex positions (and edge articulations, if applicable)).
    Specified by:
      `cloneLayout` in interface `VisualGraphLayout<V extends VisualVertex,E extends VisualEdge<V>>`
    Parameters:
      `newGraph` - the new graph for the new layout
    Returns:
      the new layout

  - ### initializeClonedLayout

    protected void initializeClonedLayout(AbstractVisualGraphLayout<V,E> newLayout)
    Takes the given layout and copies the layout information this layout into that layout
    Parameters:
      `newLayout` - the new layout to update

  - ### applyNewLocations

    protected void applyNewLocations(Map<V,Point2D> newLocations)

  - ### applyNewArticulations

    protected void applyNewArticulations(Map<E,List<Point2D>> edgeArticulations)

  - ### positionInLayoutSpaceFromGrid

    protected LayoutPositions<V,E> positionInLayoutSpaceFromGrid(VisualGraph<V,E> visualGraph, GridLocationMap<V,E> gridLocations) throws CancelledException
    Throws:
      `CancelledException`

  - ### getVertexLocation

    protected Point2D getVertexLocation(V v, Column col, Row<V> row, Rectangle bounds)

  - ### getCenteredVertexLocation

    protected Point2D getCenteredVertexLocation(V v, Column col, Row<V> row, Rectangle bounds)
    Returns a location for the given vertex that is centered within its cell
    Parameters:
      `v` - the vertex
      `col` - the vertex's column in the grid
      `row` - the vertex's row in the grid
      `bounds` - the bounds of the vertex in the layout space
    Returns:
      the centered location

  - ### positionEdgeArticulationsInLayoutSpace

    protected Map<E,List<Point2D>> positionEdgeArticulationsInLayoutSpace(VisualGraphVertexShapeTransformer<V> transformer, Map<V,Point2D> vertexLayoutLocations, Collection<E> edges, LayoutLocationMap<V,E> layoutLocations) throws CancelledException
    Throws:
      `CancelledException`

  - ### getEdgeLocation

    protected Point2D getEdgeLocation(Column col, Row<V> row)

  - ### getCenteredEdgeLocation

    protected Point2D getCenteredEdgeLocation(Column col, Row<V> row)

  - ### condenseVertices

    protected void condenseVertices(List<Row<V>> rows, Map<V,Point2D> newLocations, VisualGraphVertexShapeTransformer<V> transformer, double centerX, double centerY)

  - ### condenseEdges

    protected void condenseEdges(List<Row<V>> rows, Map<E,List<Point2D>> newEdgeArticulations, double centerX, double centerY)

  - ### getCondenseFactor

    protected double getCondenseFactor()
    The amount (from 0 to 1.0) by which to condense the vertices of the graph when that feature is enabled. The default is .5 (50%). A value of 1.0 would be fully-condensed such that all vertices are aligned on the x-axis on the center of the graph.
    Returns:
      the condense factor

  - ### addLayoutListener

    public void addLayoutListener(LayoutListener<V,E> listener)
    Description copied from interface: `VisualGraphLayout`
    Adds a layout listener
    Specified by:
      `addLayoutListener` in interface `VisualGraphLayout<V extends VisualVertex,E extends VisualEdge<V>>`
    Parameters:
      `listener` - the listener

  - ### removeLayoutListener

    public void removeLayoutListener(LayoutListener<V,E> listener)
    Description copied from interface: `VisualGraphLayout`
    Removes a layout listener
    Specified by:
      `removeLayoutListener` in interface `VisualGraphLayout<V extends VisualVertex,E extends VisualEdge<V>>`
    Parameters:
      `listener` - the listener

  - ### setLocation

    public void setLocation(V v, Point2D location)
    Specified by:
      `setLocation` in interface `edu.uci.ics.jung.algorithms.layout.Layout<V extends VisualVertex,E extends VisualEdge<V>>`
    Overrides:
      `setLocation` in class `edu.uci.ics.jung.algorithms.layout.AbstractLayout<V extends VisualVertex,E extends VisualEdge<V>>`

  - ### setLocation

    public void setLocation(V v, Point2D location, LayoutListener.ChangeType changeType)
    Description copied from interface: `VisualGraphLayout`
    Allows the client to change the location while specifying the type of change
    Specified by:
      `setLocation` in interface `VisualGraphLayout<V extends VisualVertex,E extends VisualEdge<V>>`
    Parameters:
      `v` - the vertex
      `location` - the new location
      `changeType` - the type of change