chains.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_CHAINS_H
#define DIALECT_CHAINS_H

#include <deque>
#include <memory>
#include <vector>
#include <map>
#include <utility>

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


namespace dialect {

enum class LinkShape {
    TLC, // top-left corner
    H, // horizontal
    BLC, // bottom-left corner
    TRC, // top-right corner
    V, // vertical
    BRC // bottom-right corner
};

typedef std::vector<LinkShape> LinkShapes;

extern const LinkShapes bentLinkShapeCw;

LinkShapes bentLinkShapeCwFromStartingPt(LinkShape start);

extern const std::map<LinkShape, std::map<CardinalDir, CardinalDir>> applyBendToDir;

extern const std::map<LinkShape, CardinalDir> cwIncomingDirForBend;

extern const std::map<CompassDir, std::map<CardinalDir, std::map<CardinalDir, std::vector<std::vector<LinkShape>>>>> minimalBendSeqs;

std::vector<std::vector<LinkShape>> lookupMinimalBendSeqs(Node_SP A, CardinalDir d0, Node_SP Z, CardinalDir d1);


CardinalDirs possibleCardinalDirections(Node_SP node1, Node_SP node2);


LinkShape shapeOfLink(Node_SP link);


struct BendSequence {

    BendSequence(LinkShapes &shapes) : bendTypes(shapes) {}

    BendSequence(LinkShapes &shapes, CardinalDir inDir, CardinalDir outDir)
        : bendTypes(shapes), incomingDirec(inDir), outgoingDirec(outDir) {}

    size_t size(void) const { return bendTypes.size(); }

    LinkShapes bendTypes;

    std::vector<size_t> bendPoints;

    double cost = 0;
    CardinalDir incomingDirec;
    CardinalDir outgoingDirec;
};

typedef std::shared_ptr<BendSequence> BendSequence_SP;
typedef std::vector<BendSequence_SP> BendSequences;

struct AestheticBend {

    AestheticBend(Edge_SP edge, Node_SP bendNode, Node_SP nbrNode1, Node_SP nbrNode2)
        : edge(edge), bendNode(bendNode), nbrNode1(nbrNode1), nbrNode2(nbrNode2) {}

    void addBendToEdge(void);

    Edge_SP edge;
    Node_SP bendNode;
    Node_SP nbrNode1;
    Node_SP nbrNode2;

};

typedef std::shared_ptr<AestheticBend> AestheticBend_SP;
typedef std::vector<AestheticBend_SP> AestheticBends;

typedef std::vector<std::pair<CardinalDir, CardinalDir>> ChainConfigSeq;

class Chain {
public:

    Chain(Graph_SP G, std::deque<Node_SP> nodes, bool isCycle=false);

    Node_SP getNode(int i) const;

    Edge_SP getEdge(int i) const;

    double bendCost(LinkShape bendType, size_t i0) const;

    size_t size(void) const { return m_n; }

    BendSequences computePossibleBendSequences(void) const;

    void evaluateBendSequence(BendSequence_SP bendSeq) const;

    ChainConfigSeq writeConfigSeq(BendSequence_SP bendSeq) const;

    void takeShapeBasedConfiguration(void);

    void addAestheticBendsToEdges(void);

    static const size_t npos;

private:

    double nextLocalOptimalPoint(size_t i0, LinkShape bendType, size_t remaining, size_t &i1) const;

    double globalOptimalPoint(LinkShape bendType, size_t &i1, size_t beginAt = 0) const;

    size_t getNumPotentialBendPlaces(void) const { size_t M = 2*m_n - 1; if (m_isCycle) ++M; return M; }

    Graph_SP m_graph;
    size_t m_n;
    Nodes m_nodes;
    bool m_isCycle;
    LinkShapes m_linkShapes;
    Edges m_edges;
    Node_SP m_anchorNodeLeft = nullptr;
    Edge_SP m_anchorEdgeLeft = nullptr;
    Node_SP m_anchorNodeRight = nullptr;
    Edge_SP m_anchorEdgeRight = nullptr;
    Edge_SP m_returnEdge = nullptr;
    AestheticBends m_aestheticBends;

};

typedef std::shared_ptr<Chain> Chain_SP;
typedef std::vector<Chain_SP> Chains;

Chains buildAllChainsInGraph(std::shared_ptr<dialect::Graph> graph);



} // namespace dialect

#endif // DIALECT_CHAINS_H