Class mxOrganicLayout
- All Implemented Interfaces:
mxIGraphLayout
In addition to the four aesthetic criteria the concept of a border line
which induces an energy cost to nodes in proximity to the graph bounds is
introduced to attempt to restrain the graph. All of the 5 factors can be
switched on or off using the isOptimize...
variables.
Simulated Annealing is a force-directed layout and is one of the more expensive, but generally effective layouts of this type. Layouts like the spring layout only really factor in edge length and inter-node distance being the lowest CPU intensive for the most aesthetic gain. The additional factors are more expensive but can have very attractive results.
The main loop of the algorithm consist of processing the nodes in a
deterministic order. During the processing of each node a circle of radius
moveRadius
is made around the node and split into
triesPerCell
equal segments. Each point between neighbour
segments is determined and the new energy of the system if the node were
moved to that position calculated. Only the necessary nodes and edges are
processed new energy values resulting in quadratic performance, O(VE),
whereas calculating the total system energy would be cubic. The default
implementation only checks 8 points around the radius of the circle, as
opposed to the suggested 30 in the paper. Doubling the number of points
double the CPU load and 8 works almost as well as 30.
The moveRadius
replaces the temperature as the influencing
factor in the way the graph settles in later iterations. If the user does
not set the initial move radius it is set to half the maximum dimension
of the graph. Thus, in 2 iterations a node may traverse the entire graph,
and it is more sensible to find minima this way that uphill moves, which
are little more than an expensive 'tilt' method. The factor by which
the radius is multiplied by after each iteration is important, lowering
it improves performance but raising it towards 1.0 can improve the
resulting graph aesthetics. When the radius hits the minimum move radius
defined, the layout terminates. The minimum move radius should be set
a value where the move distance is too minor to be of interest.
Also, the idea of a fine tuning phase is used, as described in the paper.
This involves only calculating the edge to node distance energy cost
at the end of the algorithm since it is an expensive calculation and
it really an 'optimizating' function. fineTuningRadius
defines the radius value that, when reached, causes the edge to node
distance to be calculated.
There are other special cases that are processed after each iteration.
unchangedEnergyRoundTermination
defines the number of
iterations, after which the layout terminates. If nothing is being moved
it is assumed a good layout has been found. In addition to this if
no nodes are moved during an iteration the move radius is halved, presuming
that a finer granularity is required.
-
Nested Class Summary
Nested ClassesModifier and TypeClassDescriptionclass
Internal representation of a node or edge that holds cached information to enable the layout to perform more quickly and to simplify the code -
Field Summary
FieldsModifier and TypeFieldDescriptionprotected boolean
Whether or not to use approximate node dimensions or not.protected double
The average amount of area allocated per node.protected double
Cost factor applied to energy calculations for node promixity to the notional border of the graph.protected double
The height coordinate of the final graphprotected double
The width coordinate of the final graphprotected double
The x coordinate of the final graphprotected double
The y coordinate of the final graphprotected boolean
Specifies if the STYLE_NOEDGESTYLE flag should be set on edges that are modified by the result.protected mxOrganicLayout.CellWrapper[]
Internal models collection of edges to be laid outprotected double
Cost factor applied to energy calculations involving edges that cross over one another.protected double
Cost factor applied to energy calculations involving the distance nodes and edges.protected double
Cost factor applied to energy calculations for the edge lengths.protected double
The radius below which fine tuning of the layout should start This involves allowing the distance between nodes and edges to be taken into account in the total energy calculation.protected double
The initial value ofmoveRadius
.protected boolean
Whether or not fine tuning is on.protected boolean
Whether or not nodes will contribute an energy cost as they approach the bound of the graph.protected boolean
Whether or not edges crosses will be calculated as an energy cost function.protected boolean
Whether or not the distance between edge and nodes will be calculated as an energy cost function.protected boolean
Whether or not edge lengths will be calculated as an energy cost function.protected boolean
Whether or not node distribute will contribute an energy cost where nodes are close together.protected int
current iteration number of the layoutprotected double
distance limit beyond which energy costs due to object repulsive is not calculated as it would be too insignificantprotected double
cached version ofmaxDistanceLimit
squaredprotected int
Limit to the number of iterations that may take place.protected double
prevents from dividing with zero and from creating excessive energy valuesprotected double
cached version ofminDistanceLimit
squaredprotected double
whenmoveRadius
reaches this value, the algorithm is terminatedprotected double
The current radius around each node where the next position energy values will be calculated for a possible moveprotected double
Cost factor applied to energy calculations involving the general node distribution of the graph.protected double
The factor by which themoveRadius
is multiplied by after every iteration.protected boolean
Specifies if all edge points of traversed edges should be removed.protected int
determines, in how many segments the circle around cells is divided, to find a new position for the cell.protected int
Keeps track of how many consecutive round have passed without any energy changesprotected int
The number of round of no node moves taking placed that the layout terminatesprotected mxOrganicLayout.CellWrapper[]
Internal models collection of nodes ( vertices ) to be laid outprotected double[]
Array of the x portion of the normalised test vectors that are tested for a lower energy around each vertex.protected double[]
Array of the y portion of the normalised test vectors that are tested for a lower energy around each vertex.Fields inherited from class com.mxgraph.layout.mxGraphLayout
graph, parent, useBoundingBox
-
Constructor Summary
ConstructorsConstructorDescriptionmxOrganicLayout
(mxGraph graph) Constructor for mxOrganicLayout.mxOrganicLayout
(mxGraph graph, Rectangle2D bounds) Constructor for mxOrganicLayout. -
Method Summary
Modifier and TypeMethodDescriptionprotected double
calcEnergyDelta
(int index, double oldNodeDistribution, double oldEdgeDistance, double oldEdgeCrossing, double oldBorderLine, double oldEdgeLength, double oldAdditionalFactorsEnergy) Calculates the change in energy for the specified node.void
Implements invalid input: '<'mxGraphLayout.execute>.protected double
getAdditionFactorsEnergy
(int i) Hook method to adding additional energy factors into the layout.double
protected double
getBorderline
(int i) This method calculates the energy of the distance of the specified node to the notional border of the graph.double
protected int[]
getConnectedEdges
(int cellIndex) Returns all Edges that are connected with the specified cellprotected double
getEdgeCrossing
(int i) This method calculates the energy of the distance from the specified edge crossing any other edges.protected double
getEdgeCrossingAffectedEdges
(int node) Obtains the energy cost function for the specified node being moved.double
protected double
getEdgeDistanceAffectedNodes
(int node) Obtains the energy cost function for the specified node being moved.double
protected double
getEdgeDistanceFromEdge
(int i) This method calculates the energy of the distance between Cells and Edges.protected double
getEdgeDistanceFromNode
(int i) This method calculates the energy of the distance between Cells and Edges.protected double
getEdgeLength
(int i) This method calculates the energy due to the length of the specified edge.protected double
getEdgeLengthAffectedEdges
(int node) Obtains the energy cost function for the specified node being moved.double
double
double
double
int
double
double
protected double
getNodeDistribution
(int i) Calculates the energy cost of the specified node relative to all other nodes.double
double
protected int[]
getRelevantEdges
(int cellIndex) Returns all Edges that are not connected to the specified cellint
int
boolean
boolean
boolean
boolean
boolean
boolean
boolean
boolean
boolean
boolean
isVertexIgnored
(Object vertex) Returns true if the given vertex has no connected edges.protected void
The main round of the algorithm.void
setApproxNodeDimensions
(boolean approxNodeDimensions) void
setAverageNodeArea
(double averageNodeArea) void
setBorderLineCostFactor
(double borderLineCostFactor) void
setDisableEdgeStyle
(boolean disableEdgeStyle) void
setEdgeCrossingCostFactor
(double edgeCrossingCostFactor) void
setEdgeDistanceCostFactor
(double edgeDistanceCostFactor) void
setEdgeLengthCostFactor
(double edgeLengthCostFactor) void
setFineTuning
(boolean isFineTuning) void
setFineTuningRadius
(double fineTuningRadius) void
setInitialMoveRadius
(double initialMoveRadius) void
setMaxDistanceLimit
(double maxDistanceLimit) void
setMaxIterations
(int maxIterations) void
setMinDistanceLimit
(double minDistanceLimit) void
setMinMoveRadius
(double minMoveRadius) void
setNodeDistributionCostFactor
(double nodeDistributionCostFactor) void
setOptimizeBorderLine
(boolean isOptimizeBorderLine) void
setOptimizeEdgeCrossing
(boolean isOptimizeEdgeCrossing) void
setOptimizeEdgeDistance
(boolean isOptimizeEdgeDistance) void
setOptimizeEdgeLength
(boolean isOptimizeEdgeLength) void
setOptimizeNodeDistribution
(boolean isOptimizeNodeDistribution) void
setRadiusScaleFactor
(double radiusScaleFactor) void
setResetEdges
(boolean resetEdges) void
setTriesPerCell
(int triesPerCell) void
setUnchangedEnergyRoundTermination
(int unchangedEnergyRoundTermination) toString()
ReturnsOrganic
, the name of this algorithm.Methods inherited from class com.mxgraph.layout.mxGraphLayout
arrangeGroups, getConstraint, getConstraint, getGraph, getParentOffset, getVertexBounds, isEdgeIgnored, isUseBoundingBox, isVertexMovable, moveCell, setEdgePoints, setEdgeStyleEnabled, setOrthogonalEdge, setUseBoundingBox, setVertexLocation
-
Field Details
-
isOptimizeEdgeDistance
protected boolean isOptimizeEdgeDistanceWhether or not the distance between edge and nodes will be calculated as an energy cost function. This function is CPU intensive and is best only used in the fine tuning phase. -
isOptimizeEdgeCrossing
protected boolean isOptimizeEdgeCrossingWhether or not edges crosses will be calculated as an energy cost function. This function is CPU intensive, though if some iterations without it are required, it is best to have a few cycles at the start of the algorithm using it, then use it intermittantly through the rest of the layout. -
isOptimizeEdgeLength
protected boolean isOptimizeEdgeLengthWhether or not edge lengths will be calculated as an energy cost function. This function not CPU intensive. -
isOptimizeBorderLine
protected boolean isOptimizeBorderLineWhether or not nodes will contribute an energy cost as they approach the bound of the graph. The cost increases to a limit close to the border and stays constant outside the bounds of the graph. This function is not CPU intensive -
isOptimizeNodeDistribution
protected boolean isOptimizeNodeDistributionWhether or not node distribute will contribute an energy cost where nodes are close together. The function is moderately CPU intensive. -
minMoveRadius
protected double minMoveRadiuswhenmoveRadius
reaches this value, the algorithm is terminated -
moveRadius
protected double moveRadiusThe current radius around each node where the next position energy values will be calculated for a possible move -
initialMoveRadius
protected double initialMoveRadiusThe initial value ofmoveRadius
. If this is set to zero the layout will automatically determine a suitable value. -
radiusScaleFactor
protected double radiusScaleFactorThe factor by which themoveRadius
is multiplied by after every iteration. A value of 0.75 is a good balance between performance and aesthetics. Increasing the value provides more chances to find minimum energy positions and decreasing it causes the minimum radius termination condition to occur more quickly. -
averageNodeArea
protected double averageNodeAreaThe average amount of area allocated per node. Ifbounds
is not set this value mutiplied by the number of nodes to find the total graph area. The graph is assumed square. -
fineTuningRadius
protected double fineTuningRadiusThe radius below which fine tuning of the layout should start This involves allowing the distance between nodes and edges to be taken into account in the total energy calculation. If this is set to zero, the layout will automatically determine a suitable value -
maxIterations
protected int maxIterationsLimit to the number of iterations that may take place. This is only reached if one of the termination conditions does not occur first. -
edgeDistanceCostFactor
protected double edgeDistanceCostFactorCost factor applied to energy calculations involving the distance nodes and edges. Increasing this value tends to cause nodes to move away from edges, at the partial cost of other graph aesthetics.isOptimizeEdgeDistance
must be true for edge to nodes distances to be taken into account. -
edgeCrossingCostFactor
protected double edgeCrossingCostFactorCost factor applied to energy calculations involving edges that cross over one another. Increasing this value tends to result in fewer edge crossings, at the partial cost of other graph aesthetics.isOptimizeEdgeCrossing
must be true for edge crossings to be taken into account. -
nodeDistributionCostFactor
protected double nodeDistributionCostFactorCost factor applied to energy calculations involving the general node distribution of the graph. Increasing this value tends to result in a better distribution of nodes across the available space, at the partial cost of other graph aesthetics.isOptimizeNodeDistribution
must be true for this general distribution to be applied. -
borderLineCostFactor
protected double borderLineCostFactorCost factor applied to energy calculations for node promixity to the notional border of the graph. Increasing this value results in nodes tending towards the centre of the drawing space, at the partial cost of other graph aesthetics.isOptimizeBorderLine
must be true for border repulsion to be applied. -
edgeLengthCostFactor
protected double edgeLengthCostFactorCost factor applied to energy calculations for the edge lengths. Increasing this value results in the layout attempting to shorten all edges to the minimum edge length, at the partial cost of other graph aesthetics.isOptimizeEdgeLength
must be true for edge length shortening to be applied. -
boundsX
protected double boundsXThe x coordinate of the final graph -
boundsY
protected double boundsYThe y coordinate of the final graph -
boundsWidth
protected double boundsWidthThe width coordinate of the final graph -
boundsHeight
protected double boundsHeightThe height coordinate of the final graph -
iteration
protected int iterationcurrent iteration number of the layout -
triesPerCell
protected int triesPerCelldetermines, in how many segments the circle around cells is divided, to find a new position for the cell. Doubling this value doubles the CPU load. Increasing it beyond 16 might mean a change to theperformRound
method might further improve accuracy for a small performance hit. The change is described in the method comment. -
minDistanceLimit
protected double minDistanceLimitprevents from dividing with zero and from creating excessive energy values -
minDistanceLimitSquared
protected double minDistanceLimitSquaredcached version ofminDistanceLimit
squared -
maxDistanceLimit
protected double maxDistanceLimitdistance limit beyond which energy costs due to object repulsive is not calculated as it would be too insignificant -
maxDistanceLimitSquared
protected double maxDistanceLimitSquaredcached version ofmaxDistanceLimit
squared -
unchangedEnergyRoundCount
protected int unchangedEnergyRoundCountKeeps track of how many consecutive round have passed without any energy changes -
unchangedEnergyRoundTermination
protected int unchangedEnergyRoundTerminationThe number of round of no node moves taking placed that the layout terminates -
approxNodeDimensions
protected boolean approxNodeDimensionsWhether or not to use approximate node dimensions or not. Set to true the radius squared of the smaller dimension is used. Set to false the radiusSquared variable of the CellWrapper contains the width squared and heightSquared is used in the obvious manner. -
v
Internal models collection of nodes ( vertices ) to be laid out -
e
Internal models collection of edges to be laid out -
xNormTry
protected double[] xNormTryArray of the x portion of the normalised test vectors that are tested for a lower energy around each vertex. The vector of the combined x and y normals are multipled by the current radius to obtain test points for each vector in the array. -
yNormTry
protected double[] yNormTryArray of the y portion of the normalised test vectors that are tested for a lower energy around each vertex. The vector of the combined x and y normals are multipled by the current radius to obtain test points for each vector in the array. -
isFineTuning
protected boolean isFineTuningWhether or not fine tuning is on. The determines whether or not node to edge distances are calculated in the total system energy. This cost function , besides detecting line intersection, is a performance intensive component of this algorithm and best left to optimization phase.isFineTuning
is switched totrue
if and when thefineTuningRadius
radius is reached. Switching this variable totrue
before the algorithm runs mean the node to edge cost function is always calculated. -
disableEdgeStyle
protected boolean disableEdgeStyleSpecifies if the STYLE_NOEDGESTYLE flag should be set on edges that are modified by the result. Default is true. -
resetEdges
protected boolean resetEdgesSpecifies if all edge points of traversed edges should be removed. Default is true.
-
-
Constructor Details
-
mxOrganicLayout
Constructor for mxOrganicLayout. -
mxOrganicLayout
Constructor for mxOrganicLayout.
-
-
Method Details
-
isVertexIgnored
Returns true if the given vertex has no connected edges.- Overrides:
isVertexIgnored
in classmxGraphLayout
- Parameters:
vertex
- Object that represents the vertex to be tested.- Returns:
- Returns true if the vertex should be ignored.
-
execute
Implements invalid input: '<'mxGraphLayout.execute>.- Specified by:
execute
in interfacemxIGraphLayout
- Overrides:
execute
in classmxGraphLayout
- Parameters:
parent
- Parent cell that contains the children to be layed out.
-
performRound
protected void performRound()The main round of the algorithm. Firstly, a permutation of nodes is created and worked through in that random order. Then, for each node a number of point of a circle of radiusmoveRadius
are selected and the total energy of the system calculated if that node were moved to that new position. If a lower energy position is found this is accepted and the algorithm moves onto the next node. There may be a slightly lower energy value yet to be found, but forcing the loop to check all possible positions adds nearly the current processing time again, and for little benefit. Another possible strategy would be to take account of the fact that the energy values around the circle decrease for half the loop and increase for the other, as a general rule. If part of the decrease were seen, then when the energy of a node increased, the previous node position was almost always the lowest energy position. This adds about two loop iterations to the inner loop and only makes sense with 16 tries or more. -
calcEnergyDelta
protected double calcEnergyDelta(int index, double oldNodeDistribution, double oldEdgeDistance, double oldEdgeCrossing, double oldBorderLine, double oldEdgeLength, double oldAdditionalFactorsEnergy) Calculates the change in energy for the specified node. The new energy is calculated from the cost function methods and the old energy values for each cost function are passed in as parameters- Parameters:
index
- The index of the node in thevertices
arrayoldNodeDistribution
- The previous node distribution energy cost of this nodeoldEdgeDistance
- The previous edge distance energy cost of this nodeoldEdgeCrossing
- The previous edge crossing energy cost for edges connected to this nodeoldBorderLine
- The previous border line energy cost for this nodeoldEdgeLength
- The previous edge length energy cost for edges connected to this nodeoldAdditionalFactorsEnergy
- The previous energy cost for additional factors from sub-classes- Returns:
- the delta of the new energy cost to the old energy cost
-
getNodeDistribution
protected double getNodeDistribution(int i) Calculates the energy cost of the specified node relative to all other nodes. Basically produces a higher energy the closer nodes are together.- Parameters:
i
- the index of the node in the arrayv
- Returns:
- the total node distribution energy of the specified node
-
getBorderline
protected double getBorderline(int i) This method calculates the energy of the distance of the specified node to the notional border of the graph. The energy increases up to a limited maximum close to the border and stays at that maximum up to and over the border.- Parameters:
i
- the index of the node in the arrayv
- Returns:
- the total border line energy of the specified node
-
getEdgeLengthAffectedEdges
protected double getEdgeLengthAffectedEdges(int node) Obtains the energy cost function for the specified node being moved. This involves callinggetEdgeLength
for all edges connected to the specified node- Parameters:
node
- the node whose connected edges cost functions are to be calculated- Returns:
- the total edge length energy of the connected edges
-
getEdgeLength
protected double getEdgeLength(int i) This method calculates the energy due to the length of the specified edge. The energy is proportional to the length of the edge, making shorter edges preferable in the layout.- Parameters:
i
- the index of the edge in the arraye
- Returns:
- the total edge length energy of the specified edge
-
getEdgeCrossingAffectedEdges
protected double getEdgeCrossingAffectedEdges(int node) Obtains the energy cost function for the specified node being moved. This involves callinggetEdgeCrossing
for all edges connected to the specified node- Parameters:
node
- the node whose connected edges cost functions are to be calculated- Returns:
- the total edge crossing energy of the connected edges
-
getEdgeCrossing
protected double getEdgeCrossing(int i) This method calculates the energy of the distance from the specified edge crossing any other edges. Each crossing add a constant factor to the total energy- Parameters:
i
- the index of the edge in the arraye
- Returns:
- the total edge crossing energy of the specified edge
-
getEdgeDistanceFromNode
protected double getEdgeDistanceFromNode(int i) This method calculates the energy of the distance between Cells and Edges. This version of the edge distance cost calculates the energy cost from a specified node. The distance cost to all unconnected edges is calculated and the total returned.- Parameters:
i
- the index of the node in the arrayv
- Returns:
- the total edge distance energy of the node
-
getEdgeDistanceAffectedNodes
protected double getEdgeDistanceAffectedNodes(int node) Obtains the energy cost function for the specified node being moved. This involves callinggetEdgeDistanceFromEdge
for all edges connected to the specified node- Parameters:
node
- the node whose connected edges cost functions are to be calculated- Returns:
- the total edge distance energy of the connected edges
-
getEdgeDistanceFromEdge
protected double getEdgeDistanceFromEdge(int i) This method calculates the energy of the distance between Cells and Edges. This version of the edge distance cost calculates the energy cost from a specified edge. The distance cost to all unconnected nodes is calculated and the total returned.- Parameters:
i
- the index of the edge in the arraye
- Returns:
- the total edge distance energy of the edge
-
getAdditionFactorsEnergy
protected double getAdditionFactorsEnergy(int i) Hook method to adding additional energy factors into the layout. Calculates the energy just for the specified node.- Parameters:
i
- the nodes whose energy is being calculated- Returns:
- the energy of this node caused by the additional factors
-
getRelevantEdges
protected int[] getRelevantEdges(int cellIndex) Returns all Edges that are not connected to the specified cell- Parameters:
cellIndex
- the cell index to which the edges are not connected- Returns:
- Array of all interesting Edges
-
getConnectedEdges
protected int[] getConnectedEdges(int cellIndex) Returns all Edges that are connected with the specified cell- Parameters:
cellIndex
- the cell index to which the edges are connected- Returns:
- Array of all connected Edges
-
toString
ReturnsOrganic
, the name of this algorithm. -
getAverageNodeArea
public double getAverageNodeArea()- Returns:
- Returns the averageNodeArea.
-
setAverageNodeArea
public void setAverageNodeArea(double averageNodeArea) - Parameters:
averageNodeArea
- The averageNodeArea to set.
-
getBorderLineCostFactor
public double getBorderLineCostFactor()- Returns:
- Returns the borderLineCostFactor.
-
setBorderLineCostFactor
public void setBorderLineCostFactor(double borderLineCostFactor) - Parameters:
borderLineCostFactor
- The borderLineCostFactor to set.
-
getEdgeCrossingCostFactor
public double getEdgeCrossingCostFactor()- Returns:
- Returns the edgeCrossingCostFactor.
-
setEdgeCrossingCostFactor
public void setEdgeCrossingCostFactor(double edgeCrossingCostFactor) - Parameters:
edgeCrossingCostFactor
- The edgeCrossingCostFactor to set.
-
getEdgeDistanceCostFactor
public double getEdgeDistanceCostFactor()- Returns:
- Returns the edgeDistanceCostFactor.
-
setEdgeDistanceCostFactor
public void setEdgeDistanceCostFactor(double edgeDistanceCostFactor) - Parameters:
edgeDistanceCostFactor
- The edgeDistanceCostFactor to set.
-
getEdgeLengthCostFactor
public double getEdgeLengthCostFactor()- Returns:
- Returns the edgeLengthCostFactor.
-
setEdgeLengthCostFactor
public void setEdgeLengthCostFactor(double edgeLengthCostFactor) - Parameters:
edgeLengthCostFactor
- The edgeLengthCostFactor to set.
-
getFineTuningRadius
public double getFineTuningRadius()- Returns:
- Returns the fineTuningRadius.
-
setFineTuningRadius
public void setFineTuningRadius(double fineTuningRadius) - Parameters:
fineTuningRadius
- The fineTuningRadius to set.
-
getInitialMoveRadius
public double getInitialMoveRadius()- Returns:
- Returns the initialMoveRadius.
-
setInitialMoveRadius
public void setInitialMoveRadius(double initialMoveRadius) - Parameters:
initialMoveRadius
- The initialMoveRadius to set.
-
isFineTuning
public boolean isFineTuning()- Returns:
- Returns the isFineTuning.
-
setFineTuning
public void setFineTuning(boolean isFineTuning) - Parameters:
isFineTuning
- The isFineTuning to set.
-
isOptimizeBorderLine
public boolean isOptimizeBorderLine()- Returns:
- Returns the isOptimizeBorderLine.
-
setOptimizeBorderLine
public void setOptimizeBorderLine(boolean isOptimizeBorderLine) - Parameters:
isOptimizeBorderLine
- The isOptimizeBorderLine to set.
-
isOptimizeEdgeCrossing
public boolean isOptimizeEdgeCrossing()- Returns:
- Returns the isOptimizeEdgeCrossing.
-
setOptimizeEdgeCrossing
public void setOptimizeEdgeCrossing(boolean isOptimizeEdgeCrossing) - Parameters:
isOptimizeEdgeCrossing
- The isOptimizeEdgeCrossing to set.
-
isOptimizeEdgeDistance
public boolean isOptimizeEdgeDistance()- Returns:
- Returns the isOptimizeEdgeDistance.
-
setOptimizeEdgeDistance
public void setOptimizeEdgeDistance(boolean isOptimizeEdgeDistance) - Parameters:
isOptimizeEdgeDistance
- The isOptimizeEdgeDistance to set.
-
isOptimizeEdgeLength
public boolean isOptimizeEdgeLength()- Returns:
- Returns the isOptimizeEdgeLength.
-
setOptimizeEdgeLength
public void setOptimizeEdgeLength(boolean isOptimizeEdgeLength) - Parameters:
isOptimizeEdgeLength
- The isOptimizeEdgeLength to set.
-
isOptimizeNodeDistribution
public boolean isOptimizeNodeDistribution()- Returns:
- Returns the isOptimizeNodeDistribution.
-
setOptimizeNodeDistribution
public void setOptimizeNodeDistribution(boolean isOptimizeNodeDistribution) - Parameters:
isOptimizeNodeDistribution
- The isOptimizeNodeDistribution to set.
-
getMaxIterations
public int getMaxIterations()- Returns:
- Returns the maxIterations.
-
setMaxIterations
public void setMaxIterations(int maxIterations) - Parameters:
maxIterations
- The maxIterations to set.
-
getMinDistanceLimit
public double getMinDistanceLimit()- Returns:
- Returns the minDistanceLimit.
-
setMinDistanceLimit
public void setMinDistanceLimit(double minDistanceLimit) - Parameters:
minDistanceLimit
- The minDistanceLimit to set.
-
getMinMoveRadius
public double getMinMoveRadius()- Returns:
- Returns the minMoveRadius.
-
setMinMoveRadius
public void setMinMoveRadius(double minMoveRadius) - Parameters:
minMoveRadius
- The minMoveRadius to set.
-
getNodeDistributionCostFactor
public double getNodeDistributionCostFactor()- Returns:
- Returns the nodeDistributionCostFactor.
-
setNodeDistributionCostFactor
public void setNodeDistributionCostFactor(double nodeDistributionCostFactor) - Parameters:
nodeDistributionCostFactor
- The nodeDistributionCostFactor to set.
-
getRadiusScaleFactor
public double getRadiusScaleFactor()- Returns:
- Returns the radiusScaleFactor.
-
setRadiusScaleFactor
public void setRadiusScaleFactor(double radiusScaleFactor) - Parameters:
radiusScaleFactor
- The radiusScaleFactor to set.
-
getTriesPerCell
public int getTriesPerCell()- Returns:
- Returns the triesPerCell.
-
setTriesPerCell
public void setTriesPerCell(int triesPerCell) - Parameters:
triesPerCell
- The triesPerCell to set.
-
getUnchangedEnergyRoundTermination
public int getUnchangedEnergyRoundTermination()- Returns:
- Returns the unchangedEnergyRoundTermination.
-
setUnchangedEnergyRoundTermination
public void setUnchangedEnergyRoundTermination(int unchangedEnergyRoundTermination) - Parameters:
unchangedEnergyRoundTermination
- The unchangedEnergyRoundTermination to set.
-
getMaxDistanceLimit
public double getMaxDistanceLimit()- Returns:
- Returns the maxDistanceLimit.
-
setMaxDistanceLimit
public void setMaxDistanceLimit(double maxDistanceLimit) - Parameters:
maxDistanceLimit
- The maxDistanceLimit to set.
-
isApproxNodeDimensions
public boolean isApproxNodeDimensions()- Returns:
- the approxNodeDimensions
-
setApproxNodeDimensions
public void setApproxNodeDimensions(boolean approxNodeDimensions) - Parameters:
approxNodeDimensions
- the approxNodeDimensions to set
-
isDisableEdgeStyle
public boolean isDisableEdgeStyle()- Returns:
- the disableEdgeStyle
-
setDisableEdgeStyle
public void setDisableEdgeStyle(boolean disableEdgeStyle) - Parameters:
disableEdgeStyle
- the disableEdgeStyle to set
-
isResetEdges
public boolean isResetEdges()- Returns:
- the resetEdges
-
setResetEdges
public void setResetEdges(boolean resetEdges) - Parameters:
resetEdges
- the resetEdges to set
-