Package com.macrofocus.treemap.originalfastvoronoi

Interface VoronoiTreemapInterface

  • All Known Implementing Classes:
    VoronoiTreemap
    public interface VoronoiTreemapInterface
    Main interface to use the library. First the hierarchy (tree) with weights and root polygon has to be set. Every functionality should go through this interface.

    • Method Detail

      • compute

        void compute()
        After setting at least the rootPolygon and the treeStructure(see setTreeAndWeights(PolygonSimple, ArrayList, ArrayList, ArrayList)), the voronoi Treemap can be computed. For every computed Node finishedNode(...) will be called in the StatusObject. If the computation is completed finished() will be called in the Statusobject.

      • setAggressiveMode

        void setAggressiveMode​(boolean mode)
        the aggressive mode modifies the weights of the sites very aggressively and is not 100% stable (some cells can get empty), anyway sometimes it yields better local minima.
        Parameters:
        mode -

      • getAggressiveMode

        boolean getAggressiveMode()
        true: aggressive weight modification false: normal weight modification
        Returns:

      • setRandomSeed

        void setRandomSeed​(long seed)
        Sets the seed for the random position generator which is used to initialize the sites.
        Parameters:
        seed -

      • getRandomSeed

        long getRandomSeed()
        Seed which is used for random initialization of the sites.
        Returns:

      • setTreeAndWeights

        void setTreeAndWeights​(PolygonSimple rootPolygon,
                       java.util.ArrayList<java.util.ArrayList<java.lang.Integer>> treeStructure,
                       java.util.ArrayList<Tuple2ID> areaGoals,
                       java.util.ArrayList<Tuple3ID> referenceMapPositions)
        All necessary things are set here such that a Voronoi Treemap can be computed. AreaGoals and refereceMapPositions can be null.

      • setTree

        void setTree​(java.util.ArrayList<java.util.ArrayList<java.lang.Integer>> treeStructure)
        Sets the tree.
        Parameters:
        treeStructure - defines a tree by an adjacency list, node a has children b,c,d (list(a,b,c,d))

      • setAreaGoals

        void setAreaGoals​(java.util.ArrayList<Tuple2ID> areaGoals)
        Sets a weighting for each nodes which influences the final area the node polygon has. the weightings are normalized so that the sum over the weightings of descendant nodes equals to one. this function must be called after the tree structure is defined (setTree(...)).
        Parameters:
        areaGoals - Tupel2ID with (NodeId, weight)

      • setReferenceMap

        void setReferenceMap​(java.util.ArrayList<Tuple3ID> relativePositions)
        ReferenceMap, which consists of a relative x,y position for each node: each coordinate must be in the range between [0...1]
        Parameters:
        relativePositions - Tupel3ID with (NodeId, relative x, relative y), x,y in range [0,1]

      • getShowLeafs

        boolean getShowLeafs()

      • setShrinkPercentage

        void setShrinkPercentage​(double shrinkPercentage)
        Sets the factor which scales every iteration, so 1-shrinkPercentage is equally the border percentage.
        Parameters:
        shrinkPercentage - preferred between 0 < shrinkPercentage <= 1

      • setUseBorder

        void setUseBorder​(boolean useBorder)
        Sets whether there borders are added for every iteration level or not.
        Parameters:
        useBorder -

      • setNumberMaxIterations

        void setNumberMaxIterations​(int numberMaxIterations)
        Sets the default maximal number of iterations done in a single level computation.
        Parameters:
        numberMaxIterations -

      • getNumberMaxIterations

        int getNumberMaxIterations()
        the maximal number of iterations.
        Returns:
        cancelOnMaxIterat

      • setPreflowPercentage

        void setPreflowPercentage​(double preflowPercentage)
        If the desire of a cell (site) to increase its area is above this percentage, then this cell pushes the other cells away. This option reduces the number of needed iteration if there is high variance in the desired cell sizes.
        Parameters:
        preflowPercentage -

      • setPreflowIncrease

        void setPreflowIncrease​(double preflowIncrease)
        Parameters:
        preflowIncrease - the preflowIncrease to set

      • getPreflowIncrease

        double getPreflowIncrease()
        Returns:
        the preflowIncrease

      • setUseExtrapolation

        void setUseExtrapolation​(boolean useExtrapolation)
        Activates the speed up heuristic which uses some kind of force to make more space for big cells.
        Parameters:
        useExtrapolation - the useExtrapolation to set

      • setCancelOnThreshold

        void setCancelOnThreshold​(boolean cancelOnThreshold)
        true: the optimization process is canceled when the area error is below the given threshold.
        Parameters:
        cancelOnThreshold - the cancelOnThreshold to set

      • getCancelErrorThreshold

        double getCancelErrorThreshold()
        maximal error threshold to cancel the optimization process.
        Returns:

      • setCancelOnMaxIteration

        void setCancelOnMaxIteration​(boolean cancelOnMaxIterat)
        true: The optimization process is canceled when the maximal iteration number is reached.
        Parameters:
        cancelOnMaxIterat - the cancelOnMaxIterat to set

      • getCancelOnMaxIteration

        boolean getCancelOnMaxIteration()

      • setRootPolygon

        void setRootPolygon​(PolygonSimple rootPolygon)
        Sets the convex root polygon in which the treemap is computed. The result will always be included into the root polygon. Currently the root polygon has to be convex, if you have a fast implementation for the intersection of non convex polygons, I could easily extend the library to simple polygons.
        Parameters:
        rootPolygon - the root Polygon to be set (must be convex currently)

      • setRootRectangle

        void setRootRectangle​(double x,
                      double y,
                      double width,
                      double height)
        Sets the a rectangle (as root polygon) in which the treemap is computed.
        Parameters:
        x - x-coordinate of the upper left point of the rectangle
        y - y-coordinate of the upper left point of the rectangle
        width - width of the rectangle
        height - height of the rectangle

      • getRootPolygon

        PolygonSimple getRootPolygon()
        Returns the root polygon.
        Returns:
        the rootPolygon

      • setGuaranteeValidCells

        void setGuaranteeValidCells​(boolean guaranteeInvariant)
        true: guarantees that the weight adaption does not cause empty cells. false:computation is approx. 30 % faster, but exception could be thrown in the optimization process
        Parameters:
        guaranteeInvariant - guarantee non empty cells

      • setNumberThreads

        void setNumberThreads​(int numberThreads)
        If possible the given number of threads will be started to speed up the optimization process. Usually this is possible after the computation of the first hierarchy level has been finished.
        Parameters:
        numberThreads - the numberThreads to set

      • setStatusObject

        void setStatusObject​(StatusObject statusObject)
        This status object is notified when the children of a node are processed and when the whole computation has finished.
        Parameters:
        statusObject - the tellTheEndObject to set

      • isUseNegativeWeights

        boolean isUseNegativeWeights()
        Return whether negative weights for the sites are allowed. Negative weights should result in a faster convergence.
        Returns:

      • setUseNegativeWeights

        void setUseNegativeWeights​(boolean use)
        set usage of negative weights for the sites. Negative weights should result in a faster convergence.
        Parameters:
        use -

      • clear

        void clear()
        Clears the used datastructures.