ortho.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_ORTHO_H
#define DIALECT_ORTHO_H

#include <vector>
#include <set>
#include <memory>
#include <map>
#include <string>
#include <functional>
#include <algorithm>
#include <utility>

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

#include "libdialect/commontypes.h"

namespace dialect {

class Node;

enum class CompassDir {
    EAST,
    SOUTH,
    WEST,
    NORTH,
    SE,
    SW,
    NW,
    NE
};

enum class CardinalDir {
    EAST,
    SOUTH,
    WEST,
    NORTH
};

typedef std::vector<CompassDir> CompassDirs;
typedef std::vector<CardinalDir> CardinalDirs;

struct Compass {

    static bool isVertical(CompassDir d) {
        return d == CompassDir::NORTH || d == CompassDir::SOUTH;
    }

    static bool isHorizontal(CompassDir d) {
        return d == CompassDir::EAST || d == CompassDir::WEST;
    }

    static bool isVerticalCard(CardinalDir d) {
        return d == CardinalDir::NORTH || d == CardinalDir::SOUTH;
    }

    static bool isHorizontalCard(CardinalDir d) {
        return d == CardinalDir::EAST || d == CardinalDir::WEST;
    }

    static bool isInDim(CompassDir d, vpsc::Dim dim) {
        return dim == vpsc::HORIZONTAL ? isHorizontal(d) : isVertical(d);
    }

    static bool isIncreasing(CompassDir d) {
        return d == CompassDir::EAST || d == CompassDir::SOUTH;
    }

    static bool isDecreasing(CompassDir d) {
        return d == CompassDir::NORTH || d == CompassDir::WEST;
    }

    static bool isIncreasingCard(CardinalDir d) {
        return d == CardinalDir::EAST || d == CardinalDir::SOUTH;
    }

    static bool isDecreasingCard(CardinalDir d) {
        return d == CardinalDir::WEST || d == CardinalDir::NORTH;
    }

    static bool sameDimension(CardinalDir d0, CardinalDir d1) {
        return (unsigned)(d0) % 2 == (unsigned)(d1) % 2;
    }

    static bool arePerpendicular(CardinalDir d0, CardinalDir d1) {
        return (unsigned)(d0) % 2 != (unsigned)(d1) % 2;
    }

    static CompassDir compassDirection(Avoid::Point p0, Avoid::Point p1);

    static CompassDir compassDirection(std::shared_ptr<Node> u0, std::shared_ptr<Node> u1);

    static CardinalDir cardinalDirection(Avoid::Point p0, Avoid::Point p1);

    static CardinalDir cardinalDirection(std::shared_ptr<Node> u0, std::shared_ptr<Node> u1);

    static bool isCardinal(CompassDir d) { return ((unsigned) d) < 4; }

    static CardinalDir cardRotateCw90(CardinalDir d);

    static CardinalDir cardRotateAcw90(CardinalDir d);

    static CardinalDir cardFlip(CardinalDir d);

    static std::string dirToString(CompassDir d);

    static std::string cardToString(CardinalDir d);

    static CardinalDirs cardinalComponents(CompassDir d);

    static PlaneMap getRotationFunction(CardinalDir fromDir, CardinalDir toDir);

    static InplacePlaneMap getInplaceRotationFunction(CardinalDir fromDir, CardinalDir toDir);

    static Avoid::Point vectorSigns(CompassDir d);

    static const CardinalDirs cwCards;

    static const CardinalDirs acwCards;

    static const CompassDirs cwAllDoubled;

    static const CompassDirs acwAllDoubled;

    static const std::set<CardinalDir> vertical;

    static const std::set<CardinalDir> horizontal;

    static const std::map<CardinalDir, Avoid::ConnDirFlag> libavoidConnDirs;

    static const std::map<CompassDir, CompassDir> rotateCw90;

    static const std::map<CompassDir, CompassDir> flip;

    static const std::map<CardinalDir, vpsc::Dim> varDim;

    static const std::map<CardinalDir, vpsc::Dim> constDim;

};

typedef std::pair<double, double> interval;

struct LineSegment {
    LineSegment(Avoid::Point p0, Avoid::Point p1)
        : p0(p0), p1(p1),
          x0(p0.x), y0(p0.y),
          x1(p1.x), y1(p1.y),
          direc(Compass::cardinalDirection(p0, p1)),
          varDim(Compass::varDim.at(direc)),
          constDim(Compass::constDim.at(direc))
    {
        if (Compass::isVerticalCard(direc)) {
            z = x0; w0 = y0; w1 = y1;
        } else {
            z = y0; w0 = x0; w1 = x1;
        }
        auto p = std::minmax(w0, w1);
        wl = p.first;
        wh = p.second;
        length = wh - wl;
    }

    double getConstCoord(void) const { return z; }

    bool closedIntervalIntersects(double a, double b) const;

    bool openIntervalIntersects(double a, double b) const;

    bool closedIntervalIncludesCoord(double a) const;

    bool openIntervalIncludesCoord(double a) const;

    interval closedIntervalIntersection(double a, double b) const;

    interval openIntervalIntersection(double a, double b) const;

    int ptOnWhichSide(Avoid::Point p) const;

    int coordOnWhichSide(double z1) const;

    static const double EPSILON;

    Avoid::Point p0;
    Avoid::Point p1;
    double x0;
    double y0;
    double x1;
    double y1;
    CardinalDir direc;
    vpsc::Dim varDim;
    vpsc::Dim constDim;
    double z;
    double w0;
    double w1;
    double wl;
    double wh;
    double length;
};


} // namespace dialect

#endif // DIALECT_ORTHO_H