expansion.h

/*
 * vim: ts=4 sw=4 et tw=0 wm=0
 *
 * libdialect - A library for computing DiAlEcT layouts:
 *                 D = Decompose/Distribute
 *                 A = Arrange
 *                 E = Expand/Emend
 *                 T = Transform
 *
 * Copyright (C) 2018  Monash University
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 * See the file LICENSE.LGPL distributed with the library.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 *
 * Author(s):   Steve Kieffer   <http://skieffer.info>
*/

#ifndef DIALECT_EXPANSION_H
#define DIALECT_EXPANSION_H

#include <memory>
#include <map>
#include <string>
#include <deque>

#include "libvpsc/rectangle.h"
#include "libavoid/geomtypes.h"

#include "libdialect/commontypes.h"
#include "libdialect/treeplacement.h"
#include "libdialect/ortho.h"

namespace dialect {

class ExpansionGoal;

class ExpansionManager {
public:
    ExpansionManager(TreePlacement_SP tp, vpsc::Dim primaryDim=vpsc::HORIZONTAL, double padding=-1);

    bool isAxial(vpsc::Dim dim) { return dim == m_axialDim; }

    bool isTransverse(vpsc::Dim dim) { return dim == m_transDim; }

    double estimateCost(void) const;

    std::map<vpsc::Dim, double> estimateCostByDimension(void) const;

    std::map<vpsc::Dim, double> estimateCostByDimension2(void) const;

    std::map<CardinalDir, double> estimateCostByDirection(void) const;

    ExpansionGoals getGoals(void) { return m_goals; }

    ProjSeq_SP extendProjSeq(ProjSeq_SP ps0);

private:

    ExpansionGoal_SP addGoalInDirec(CardinalDir dir);
    void computeGoals(vpsc::Dim dim);

    TreePlacement_SP m_tp;
    vpsc::Dim m_primaryDim;
    double m_padding;
    vpsc::Dim m_axialDim;
    vpsc::Dim m_transDim;
    unsigned m_goalCounter = 0;
    ExpansionGoals m_goals;
    ExpansionGoals m_primaryDimGoals;
    ExpansionGoals m_secondaryDimGoals;
};

struct ContainedSegment;
typedef std::shared_ptr<ContainedSegment> ContainedSegment_SP;

class ExpansionGoal {
public:

    ExpansionGoal(unsigned id, TreePlacement_SP tp, CardinalDir direc, double padding)
        : m_id(id), m_tp(tp), m_direc(direc), m_padding(padding) {
        // The generated SepCos will operate at right angles to the direction of this
        // goal, i.e. in the constant dimension of this goal's direction.
        m_dim = Compass::constDim.at(m_direc);
    }

    ContainedSegment_SP computeContainedSegment(bool ignoreCollateralTreeBoxes=false);

    CardinalDir getDirec(void) const { return m_direc; }

    ProjSeq_SP tryExpansionRec(ProjSeq_SP ps0, std::deque<ExpansionGoal_SP> &remainingGoals);

private:

    void computeGoalSegmentEndpoints(Avoid::Point &p0, Avoid::Point &p1);

    unsigned m_id;
    TreePlacement_SP m_tp;
    CardinalDir m_direc;
    double m_padding;
    vpsc::Dim m_dim;
};

struct ContainedSegment {

    ContainedSegment(unsigned goalID, Avoid::Point basept, Avoid::Point localGoalPt, Avoid::Point globalGoalPt,
                     double padding, TreePlacement_SP tp, vpsc::Dim sepDim);

    double measureShortage(void) const;

    std::string toString(void) const;

    void makeRoomForTreeNode(ProjSeq_SP ps0, bool doProject = true);

    unsigned goalID;
    Avoid::Point basept;
    Avoid::Point localGoalPt;
    Avoid::Point globalGoalPt;
    double padding;
    TreePlacement_SP tp;
    vpsc::Dim sepDim;
    LineSegment localGoalSeg;
    LineSegment globalGoalSeg;

private:
    void addSepCoForPtAndNode(Avoid::Point &pt, Node_SP &node, dimensions nodeDims, SepCoSet &sepcos, Node_SP &treeBox);
};


} // namespace dialect

#endif // DIALECT_EXPANSION_H