geomtypes.h

Go to the documentation of this file.

/*
 * vim: ts=4 sw=4 et tw=0 wm=0
 *
 * libavoid - Fast, Incremental, Object-avoiding Line Router
 *
 * Copyright (C) 2004-2014  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.
 *
 * Licensees holding a valid commercial license may use this file in
 * accordance with the commercial license agreement provided 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):   Michael Wybrow
*/



#ifndef AVOID_GEOMTYPES_H
#define AVOID_GEOMTYPES_H

#include <cstdlib>
#include <vector>
#include <utility>

#include "libavoid/dllexport.h"


namespace Avoid
{

static const size_t XDIM = 0;
static const size_t YDIM = 1;

class Polygon;

class AVOID_EXPORT Point
{
    public:
        Point();
        Point(const double xv, const double yv);

        bool operator==(const Point& rhs) const;
        bool equals(const Point& rhs, double epsilon = 0.0001) const;
        bool operator!=(const Point& rhs) const;
        bool operator<(const Point& rhs) const;

        double& operator[](const size_t dimension);
        const double& operator[](const size_t dimension) const;

        Point operator+(const Point& rhs) const;
        Point operator-(const Point& rhs) const;

        double x;
        double y;
        unsigned int id;
        unsigned short vn;

};


static const unsigned short kUnassignedVertexNumber = 8;

static const unsigned short kShapeConnectionPin = 9;


typedef Point Vector;

class AVOID_EXPORT Box
{
    public:
        Point min;
        Point max;

        double length(size_t dimension) const;
        double width(void) const;
        double height(void) const;
};



class AVOID_EXPORT PolygonInterface
{
    public:
        PolygonInterface() { }
        virtual ~PolygonInterface() { }
        virtual void clear(void) = 0;
        virtual bool empty(void) const = 0;
        virtual size_t size(void) const = 0;
        virtual int id(void) const = 0;
        virtual const Point& at(size_t index) const = 0;
        Polygon boundingRectPolygon(void) const;
        Box offsetBoundingBox(double offset) const;

        Polygon offsetPolygon(double offset) const;
};


class AVOID_EXPORT Edge
{
    public:
        Point a;
        Point b;
};


class Router;
class ReferencingPolygon;


class AVOID_EXPORT Polygon : public PolygonInterface
{
    public:
        Polygon();
        Polygon(const int n);
        Polygon(const PolygonInterface& poly);
        void clear(void);
        bool empty(void) const;
        size_t size(void) const;
        int id(void) const;
        const Point& at(size_t index) const;
        void setPoint(size_t index, const Point& point);
        Polygon simplify(void) const;
        Polygon curvedPolyline(const double curve_amount, 
                const bool closed = false) const;
        void translate(const double xDist, const double yDist);

        int _id;
        std::vector<Point> ps;
        std::vector<char> ts;

        // @brief  If used, denotes checkpoints through which the route travels
        //         and the relevant segment of the route.
        //
        // Set and used by the orthogonal routing code. Note the first value
        // in the pair doesn't correspond to the segment index containing the 
        // checkpoint, but rather the segment or bendpoint on which it lies.
        //    0 if on ps[0]
        //    1 if on line ps[0]-ps[1]
        //    2 if on ps[1]
        //    3 if on line ps[1]-ps[2]
        //    etc.
        std::vector<std::pair<size_t, Point> > checkpointsOnRoute;

        // Returns true if at least one checkpoint lies on the line segment
        // or at either end of it.  An indexModifier of +1 will cause it to
        // ignore a checkpoint on the corner at the start of the segment and
        // -1 will cause it to do the same for the corner at the end of the
        // segment.
        std::vector<Point> checkpointsOnSegment(size_t segmentLowerIndex,
                int indexModifier = 0) const;
};


typedef Polygon PolyLine;


class AVOID_EXPORT ReferencingPolygon : public PolygonInterface
{
    public:
        ReferencingPolygon();
        ReferencingPolygon(const Polygon& poly, const Router *router);
        void clear(void);
        bool empty(void) const;
        size_t size(void) const;
        int id(void) const;
        const Point& at(size_t index) const;

        int _id;
        std::vector<std::pair<const Polygon *, unsigned short> > psRef;
        std::vector<Point> psPoints;
};


class AVOID_EXPORT Rectangle : public Polygon
{
    public:
        Rectangle(const Point& topLeft, const Point& bottomRight);
        
        Rectangle(const Point& centre, const double width, const double height);
};


}

#endif