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:

  • 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 VisualEdges 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<V> col, Row<V> row, Rectangle bounds)

    • getCenteredVertexLocation

      protected Point2D getCenteredVertexLocation(V v, Column<V> 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<V> col, Row<V> row)

    • getCenteredEdgeLocation

      protected Point2D getCenteredEdgeLocation(Column<V> 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