com.mxgraph.layout.hierarchical.stage

## Class mxCoordinateAssignment

- java.lang.Object
- - com.mxgraph.layout.hierarchical.stage.mxCoordinateAssignment

- All Implemented Interfaces:
    mxHierarchicalLayoutStage

      public class mxCoordinateAssignment
      extends java.lang.Object
      implements mxHierarchicalLayoutStage

  Sets the horizontal locations of node and edge dummy nodes on each layer. Uses median down and up weighings as well as heuristics to straighten edges as far as possible.

- - ### Nested Class Summary

    Nested Classes
    Modifier and Type | Class and Description
    --- | ---
    `protected class` | `mxCoordinateAssignment.AreaSpatialCache` Utility class that stores a collection of vertices and edge points within a certain area.
    `protected class` | `mxCoordinateAssignment.WeightedCellSorter` A utility class used to track cells whilst sorting occurs on the weighted sum of their connected edges.

  - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `protected int` | `channelBuffer` The size of the vertical buffer in the center of inter-rank channels where edge control points should not be placed
    `protected double` | `currentXDelta` The sum of x-displacements for the current iteration
    `protected boolean` | `disableEdgeStyle` Specifies if the STYLE_NOEDGESTYLE flag should be set on edges that are modified by the result.
    `protected com.mxgraph.layout.hierarchical.stage.mxCoordinateAssignment.HierarchicalEdgeStyle` | `edgeStyle` The style to apply between cell layers to edge segments
    `protected boolean` | `fineTuning` Whether or not to perform local optimisations and iterate multiple times through the algorithm
    `protected int` | `groupPadding` Padding added to resized parents
    `protected double` | `initialX` The minimum x position node placement starts at
    `protected double` | `interRankCellSpacing` The minimum distance between cells on adjacent ranks
    `protected double` | `intraCellSpacing` The minimum buffer between cells on the same rank
    `protected java.util.Map<mxGraphHierarchyEdge,double[]>` | `jettyPositions` Map of internal edges and (x,y) pair of positions of the start and end jetty for that edge where it connects to the source and target vertices.
    `protected mxHierarchicalLayout` | `layout` Reference to the enclosing layout algorithm
    `protected double` | `limitX` The maximum x value this positioning lays up to
    `protected int` | `maxIterations` The number of heuristic iterations to run
    `protected int` | `minEdgeJetty` The minimum distance for an edge jetty from a vertex
    `protected mxGraphAbstractHierarchyCell[][]` | `nextLayerConnectedCache` A store of connections to the layer above for speed
    `protected int` | `orientation` The position of the root ( start ) node(s) relative to the rest of the laid out graph
    `protected double` | `parallelEdgeSpacing` The distance between each parallel edge on each ranks for long edges
    `protected int` | `prefHozEdgeSep` The preferred horizontal distance between edges exiting a vertex
    `protected int` | `prefVertEdgeOff` The preferred vertical offset between edges exiting a vertex
    `protected mxGraphAbstractHierarchyCell[][]` | `previousLayerConnectedCache` A store of connections to the layer below for speed
    `protected double[]` | `rankBottomY` Internal cache of bottom-most value of Y for each rank
    `protected double[]` | `rankTopY` Internal cache of top-most values of Y for each rank
    `protected double[]` | `rankWidths` The width of all the ranks
    `protected double[]` | `rankY` The Y-coordinate of all the ranks
    `protected double` | `vertexConnectionBuffer` The buffer on either side of a vertex where edges must not connect.
    `protected int` | `widestRank` The rank that has the widest x position
    `protected double` | `widestRankValue` The X-coordinate of the edge of the widest rank

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `mxCoordinateAssignment(mxHierarchicalLayout layout, double intraCellSpacing, double interRankCellSpacing, int orientation, double initialX, double parallelEdgeSpacing)` Creates a coordinate assignment.

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `protected void` | `adjustParents(java.util.Set<java.lang.Object> parentsChanged)` Adjust parent cells whose child geometries have changed.
    `protected void` | `calculateWidestRank(mxGraph graph, mxGraphHierarchyModel model)` Calculates the width rank in the hierarchy.
    `void` | `execute(java.lang.Object parent)` A basic horizontal coordinate assignment algorithm
    `double` | `getInterRankCellSpacing()`
    `double` | `getIntraCellSpacing()`
    `double` | `getLimitX()`
    `int` | `getOrientation()`
    `boolean` | `isFineTuning()`
    `protected void` | `localEdgeProcessing(mxGraphHierarchyModel model)` Separates the x position of edges as they connect to vertices
    `protected void` | `minPath(mxGraphHierarchyModel model)` Straightens out chains of virtual nodes where possible
    `void` | `printStatus()` Utility method to display the x co-ords
    `protected void` | `processReversedEdge(mxGraphHierarchyEdge edge, java.lang.Object realEdge)` Hook to add additional processing
    `protected void` | `rankCoordinates(int rankValue, mxGraph graph, mxGraphHierarchyModel model)` Sets up the layout in an initial positioning.
    `protected void` | `rankMedianPosition(int rankValue, mxGraphHierarchyModel model, int nextRankValue)` Performs median minimisation over one rank.
    `protected boolean` | `repositionValid(mxGraphHierarchyModel model, mxGraphAbstractHierarchyCell cell, int rank, double position)` Determines whether or not a node may be moved to the specified x position on the specified rank
    `protected void` | `setCellLocations(mxGraph graph, mxGraphHierarchyModel model)` Sets the cell locations in the facade to those stored after this layout processing step has completed.
    `protected void` | `setEdgePosition(mxGraphAbstractHierarchyCell cell)` Fixes the control points
    `void` | `setFineTuning(boolean fineTuning)`
    `void` | `setInterRankCellSpacing(double interRankCellSpacing)`
    `void` | `setIntraCellSpacing(double intraCellSpacing)`
    `void` | `setLimitX(double limitX)`
    `void` | `setLoggerLevel(java.util.logging.Level level)` Sets the logging level of this class
    `void` | `setOrientation(int orientation)`
    `protected void` | `setVertexLocation(mxGraphAbstractHierarchyCell cell)` Fixes the position of the specified vertex

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

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

- - ### Field Detail

    - #### layout

          protected mxHierarchicalLayout layout

      Reference to the enclosing layout algorithm

    - #### intraCellSpacing

          protected double intraCellSpacing

      The minimum buffer between cells on the same rank

    - #### interRankCellSpacing

          protected double interRankCellSpacing

      The minimum distance between cells on adjacent ranks

    - #### parallelEdgeSpacing

          protected double parallelEdgeSpacing

      The distance between each parallel edge on each ranks for long edges

    - #### vertexConnectionBuffer

          protected double vertexConnectionBuffer

      The buffer on either side of a vertex where edges must not connect.

    - #### maxIterations

          protected int maxIterations

      The number of heuristic iterations to run

    - #### prefHozEdgeSep

          protected int prefHozEdgeSep

      The preferred horizontal distance between edges exiting a vertex

    - #### prefVertEdgeOff

          protected int prefVertEdgeOff

      The preferred vertical offset between edges exiting a vertex

    - #### minEdgeJetty

          protected int minEdgeJetty

      The minimum distance for an edge jetty from a vertex

    - #### channelBuffer

          protected int channelBuffer

      The size of the vertical buffer in the center of inter-rank channels where edge control points should not be placed

    - #### jettyPositions

          protected java.util.Map<mxGraphHierarchyEdge,double[]> jettyPositions

      Map of internal edges and (x,y) pair of positions of the start and end jetty for that edge where it connects to the source and target vertices. Note this should technically be a WeakHashMap, but since JS does not have an equivalent, housekeeping must be performed before using. i.e. check all edges are still in the model and clear the values. Note that the y co-ord is the offset of the jetty, not the absolute point

    - #### orientation

          protected int orientation

      The position of the root ( start ) node(s) relative to the rest of the laid out graph

    - #### initialX

          protected double initialX

      The minimum x position node placement starts at

    - #### limitX

          protected double limitX

      The maximum x value this positioning lays up to

    - #### currentXDelta

          protected double currentXDelta

      The sum of x-displacements for the current iteration

    - #### widestRank

          protected int widestRank

      The rank that has the widest x position

    - #### rankTopY

          protected double[] rankTopY

      Internal cache of top-most values of Y for each rank

    - #### rankBottomY

          protected double[] rankBottomY

      Internal cache of bottom-most value of Y for each rank

    - #### widestRankValue

          protected double widestRankValue

      The X-coordinate of the edge of the widest rank

    - #### rankWidths

          protected double[] rankWidths

      The width of all the ranks

    - #### rankY

          protected double[] rankY

      The Y-coordinate of all the ranks

    - #### fineTuning

          protected boolean fineTuning

      Whether or not to perform local optimisations and iterate multiple times through the algorithm

    - #### disableEdgeStyle

          protected boolean disableEdgeStyle

      Specifies if the STYLE_NOEDGESTYLE flag should be set on edges that are modified by the result. Default is true.

    - #### edgeStyle

          protected com.mxgraph.layout.hierarchical.stage.mxCoordinateAssignment.HierarchicalEdgeStyle edgeStyle

      The style to apply between cell layers to edge segments

    - #### nextLayerConnectedCache

          protected mxGraphAbstractHierarchyCell[][] nextLayerConnectedCache

      A store of connections to the layer above for speed

    - #### groupPadding

          protected int groupPadding

      Padding added to resized parents

    - #### previousLayerConnectedCache

          protected mxGraphAbstractHierarchyCell[][] previousLayerConnectedCache

      A store of connections to the layer below for speed

  - ### Constructor Detail

    - #### mxCoordinateAssignment

          public mxCoordinateAssignment(mxHierarchicalLayout layout,
                                double intraCellSpacing,
                                double interRankCellSpacing,
                                int orientation,
                                double initialX,
                                double parallelEdgeSpacing)

      Creates a coordinate assignment.
      Parameters:
        `intraCellSpacing` - the minimum buffer between cells on the same rank
        `interRankCellSpacing` - the minimum distance between cells on adjacent ranks
        `orientation` - the position of the root node(s) relative to the graph
        `initialX` - the leftmost coordinate node placement starts at

  - ### Method Detail

    - #### printStatus

          public void printStatus()

      Utility method to display the x co-ords

    - #### execute

          public void execute(java.lang.Object parent)

      A basic horizontal coordinate assignment algorithm
      Specified by:
        `execute` in interface `mxHierarchicalLayoutStage`

    - #### rankMedianPosition

          protected void rankMedianPosition(int rankValue,
                                mxGraphHierarchyModel model,
                                int nextRankValue)

      Performs median minimisation over one rank.
      Parameters:
        `rankValue` - the layer number of this rank
        `model` - an internal model of the hierarchical layout
        `nextRankValue` - the layer number whose connected cels are to be laid out relative to

    - #### rankCoordinates

          protected void rankCoordinates(int rankValue,
                             mxGraph graph,
                             mxGraphHierarchyModel model)

      Sets up the layout in an initial positioning. All the first cells in each rank are moved to the left and the rest of the rank inserted as close together as their size and buffering permits. This method works on just the specified rank.
      Parameters:
        `rankValue` - the current rank being processed
        `graph` - the facade describing the input graph
        `model` - an internal model of the hierarchical layout

    - #### calculateWidestRank

          protected void calculateWidestRank(mxGraph graph,
                                 mxGraphHierarchyModel model)

      Calculates the width rank in the hierarchy. Also set the y value of each rank whilst performing the calculation
      Parameters:
        `graph` - the facade describing the input graph
        `model` - an internal model of the hierarchical layout

    - #### minPath

          protected void minPath(mxGraphHierarchyModel model)

      Straightens out chains of virtual nodes where possible
      Parameters:
        `model` - an internal model of the hierarchical layout

    - #### repositionValid

          protected boolean repositionValid(mxGraphHierarchyModel model,
                                mxGraphAbstractHierarchyCell cell,
                                int rank,
                                double position)

      Determines whether or not a node may be moved to the specified x position on the specified rank
      Parameters:
        `model` - the layout model
        `cell` - the cell being analysed
        `rank` - the layer of the cell
        `position` - the x position being sought
      Returns:
        whether or not the virtual node can be moved to this position

    - #### setCellLocations

          protected void setCellLocations(mxGraph graph,
                              mxGraphHierarchyModel model)

      Sets the cell locations in the facade to those stored after this layout processing step has completed.
      Parameters:
        `graph` - the facade describing the input graph
        `model` - an internal model of the hierarchical layout

    - #### adjustParents

          protected void adjustParents(java.util.Set<java.lang.Object> parentsChanged)

      Adjust parent cells whose child geometries have changed. The default implementation adjusts the group to just fit around the children with a padding.

    - #### localEdgeProcessing

          protected void localEdgeProcessing(mxGraphHierarchyModel model)

      Separates the x position of edges as they connect to vertices
      Parameters:
        `model` - an internal model of the hierarchical layout

    - #### setEdgePosition

          protected void setEdgePosition(mxGraphAbstractHierarchyCell cell)

      Fixes the control points
      Parameters:
        `cell` -

    - #### setVertexLocation

          protected void setVertexLocation(mxGraphAbstractHierarchyCell cell)

      Fixes the position of the specified vertex
      Parameters:
        `cell` - the vertex to position

    - #### processReversedEdge

          protected void processReversedEdge(mxGraphHierarchyEdge edge,
                                 java.lang.Object realEdge)

      Hook to add additional processing
      Parameters:
        `edge` - The hierarchical model edge
        `realEdge` - The real edge in the graph

    - #### getInterRankCellSpacing

          public double getInterRankCellSpacing()

      Returns:
        Returns the interRankCellSpacing.

    - #### setInterRankCellSpacing

          public void setInterRankCellSpacing(double interRankCellSpacing)

      Parameters:
        `interRankCellSpacing` - The interRankCellSpacing to set.

    - #### getIntraCellSpacing

          public double getIntraCellSpacing()

      Returns:
        Returns the intraCellSpacing.

    - #### setIntraCellSpacing

          public void setIntraCellSpacing(double intraCellSpacing)

      Parameters:
        `intraCellSpacing` - The intraCellSpacing to set.

    - #### getOrientation

          public int getOrientation()

      Returns:
        Returns the orientation.

    - #### setOrientation

          public void setOrientation(int orientation)

      Parameters:
        `orientation` - The orientation to set.

    - #### getLimitX

          public double getLimitX()

      Returns:
        Returns the limitX.

    - #### setLimitX

          public void setLimitX(double limitX)

      Parameters:
        `limitX` - The limitX to set.

    - #### isFineTuning

          public boolean isFineTuning()

      Returns:
        Returns the fineTuning.

    - #### setFineTuning

          public void setFineTuning(boolean fineTuning)

      Parameters:
        `fineTuning` - The fineTuning to set.

    - #### setLoggerLevel

          public void setLoggerLevel(java.util.logging.Level level)

      Sets the logging level of this class
      Parameters:
        `level` - the logging level to set

Copyright (c) 2010 Gaudenz Alder. All rights reserved.