OptimalHierarchyClusterLayout.h

Go to the documentation of this file.

/*
 * $Revision: 2299 $
 * 
 * last checkin:
 *   $Author: gutwenger $ 
 *   $Date: 2012-05-07 15:57:08 +0200 (Mon, 07 May 2012) $ 
 ***************************************************************/
 
#ifdef _MSC_VER
#pragma once
#endif

#ifndef OGDF_OPTIMAL_HIERARCHY_CLUSTER_LAYOUT_H
#define OGDF_OPTIMAL_HIERARCHY_CLUSTER_LAYOUT_H



#include <ogdf/module/HierarchyClusterLayoutModule.h>
#include <ogdf/basic/tuples.h>


namespace ogdf {



class OGDF_EXPORT OptimalHierarchyClusterLayout : public HierarchyClusterLayoutModule
{
#ifndef OGDF_LP_SOLVER
protected:
    void doCall(const ExtendedNestingGraph& H,ClusterGraphCopyAttributes &ACGC) {
        OGDF_THROW_PARAM(LibraryNotSupportedException, lnscCoin);
    }

#else

public:
    OptimalHierarchyClusterLayout();

    OptimalHierarchyClusterLayout(const OptimalHierarchyClusterLayout &);

    // destructor
    ~OptimalHierarchyClusterLayout() { }


    OptimalHierarchyClusterLayout &operator=(const OptimalHierarchyClusterLayout &);



    double nodeDistance() const {
        return m_nodeDistance;
    }

    void nodeDistance(double x) {
        if(x >= 0)
            m_nodeDistance = x;
    }

    double layerDistance() const {
        return m_layerDistance;
    }

    void layerDistance(double x) {
        if(x >= 0)
            m_layerDistance = x;
    }


    bool fixedLayerDistance() const {
        return m_fixedLayerDistance;
    }

    void fixedLayerDistance(bool b) {
        m_fixedLayerDistance = b;
    }

    double weightSegments() const {
        return m_weightSegments;
    }

    void weightSegments(double w) {
        if(w > 0.0 && w <= 100.0)
            m_weightSegments = w;
    }

    double weightBalancing() const {
        return m_weightBalancing;
    }

    void weightBalancing(double w) {
        if(w >= 0.0 && w <= 100.0)
            m_weightBalancing = w;
    }

    double weightClusters() const {
        return m_weightClusters;
    }

    void weightClusters(double w) {
        if(w > 0.0 && w <= 100.0)
            m_weightClusters = w;
    }


protected:
    void doCall(const ExtendedNestingGraph& H,ClusterGraphCopyAttributes &ACGC);

private:
    void buildLayerList(
        const LHTreeNode *vNode,
        List<Tuple2<int,double> > &L);

    void computeXCoordinates(
        const ExtendedNestingGraph& H,
        ClusterGraphCopyAttributes &AGC);
    void computeYCoordinates(
        const ExtendedNestingGraph& H,
        ClusterGraphCopyAttributes &AGC);

    // options
    double m_nodeDistance;       
    double m_layerDistance;      
    bool   m_fixedLayerDistance; 

    double m_weightSegments;  
    double m_weightBalancing; 
    double m_weightClusters;  

    // auxiliary data
    ClusterGraphCopyAttributes *m_pACGC;
    const ExtendedNestingGraph *m_pH;

    int m_vertexOffset;
    int m_segmentOffset;
    int m_clusterLeftOffset;
    int m_clusterRightOffset;

    NodeArray<bool>   m_isVirtual;
    NodeArray<int>    m_vIndex;
    ClusterArray<int> m_cIndex;

#endif
};

}


#endif