connector.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-2015  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_CONNECTOR_H
#define AVOID_CONNECTOR_H

#include <utility>
#include <list>
#include <vector>

#include "libavoid/dllexport.h"
#include "libavoid/vertices.h"
#include "libavoid/geometry.h"
#include "libavoid/connend.h"


namespace Avoid {

class Router;
class ConnRef;
class JunctionRef;
class ShapeRef;
typedef std::list<ConnRef *> ConnRefList;


enum ConnType {
    ConnType_None       = 0,
    ConnType_PolyLine   = 1,
    ConnType_Orthogonal = 2
};

class AVOID_EXPORT Checkpoint
{
    public:
        Checkpoint(const Point& p)
            : point(p),
              arrivalDirections(ConnDirAll),
              departureDirections(ConnDirAll)
        {
        }
        Checkpoint(const Point& p, ConnDirFlags ad, ConnDirFlags dd)
            : point(p),
              arrivalDirections(ad),
              departureDirections(dd)
        {
        }
        // Default constructor.
        Checkpoint()
            : point(Point()),
              arrivalDirections(ConnDirAll),
              departureDirections(ConnDirAll)
        {
        }

        Point point;
        ConnDirFlags arrivalDirections;
        ConnDirFlags departureDirections;
};


class AVOID_EXPORT ConnRef
{
    public:
        ConnRef(Router *router, const unsigned int id = 0);
        ConnRef(Router *router, const ConnEnd& src, const ConnEnd& dst,
                const unsigned int id = 0);

// To prevent C++ objects from being destroyed in garbage collected languages
// when the libraries are called from SWIG, we hide the declarations of the
// destructors and prevent generation of default destructors.
#ifndef SWIG
        ~ConnRef();
#endif        
        void setEndpoints(const ConnEnd& srcPoint, const ConnEnd& dstPoint);
        
        void setSourceEndpoint(const ConnEnd& srcPoint);
        
        void setDestEndpoint(const ConnEnd& dstPoint);
        
        unsigned int id(void) const;
        
        Router *router(void) const;

        bool needsRepaint(void) const;
        
        const PolyLine& route(void) const;
        
        PolyLine& displayRoute(void);
        
        void setCallback(void (*cb)(void *), void *ptr);
        
        ConnType routingType(void) const;
        
        void setRoutingType(ConnType type);
       
        std::pair<JunctionRef *, ConnRef *> splitAtSegment(
                const size_t segmentN);

        void setRoutingCheckpoints(const std::vector<Checkpoint>& checkpoints);

        std::vector<Checkpoint> routingCheckpoints(void) const;
        
        std::pair<ConnEnd, ConnEnd> endpointConnEnds(void) const;

        // @brief   Returns the source endpoint vertex in the visibility graph.
        // @returns The source endpoint vertex.
        VertInf *src(void) const;
        // @brief   Returns the destination endpoint vertex in the 
        //          visibility graph.
        // @returns The destination endpoint vertex.
        VertInf *dst(void) const;
        
        void setFixedRoute(const PolyLine& route);

        void setFixedExistingRoute(void);

        bool hasFixedRoute(void) const;

        void clearFixedRoute(void);

        void set_route(const PolyLine& route);
        void calcRouteDist(void);
        void makeActive(void);
        void makeInactive(void);
        VertInf *start(void);
        void removeFromGraph(void);
        bool isInitialised(void) const;
        void makePathInvalid(void);
        void setHateCrossings(bool value);
        bool doesHateCrossings(void) const;
        void setEndpoint(const unsigned int type, const ConnEnd& connEnd);
        bool setEndpoint(const unsigned int type, const VertID& pointID, 
                Point *pointSuggestion = nullptr);
        std::vector<Point> possibleDstPinPoints(void) const;
    
    private:
        friend class Router;
        friend class ConnEnd;
        friend class JunctionRef;
        friend class ConnRerouteFlagDelegate;
        friend class HyperedgeImprover;
        friend struct HyperedgeTreeEdge;
        friend struct HyperedgeTreeNode;
        friend class HyperedgeRerouter;

        PolyLine& routeRef(void);
        void freeRoutes(void);
        void performCallback(void);
        bool generatePath(void);
        void generateCheckpointsPath(std::vector<Point>& path,
                std::vector<VertInf *>& vertices);
        void generateStandardPath(std::vector<Point>& path,
                std::vector<VertInf *>& vertices);
        void unInitialise(void);
        void updateEndPoint(const unsigned int type, const ConnEnd& connEnd);
        void common_updateEndPoint(const unsigned int type, ConnEnd connEnd);
        void freeActivePins(void);
        bool getConnEndForEndpointVertex(VertInf *vertex, ConnEnd& connEnd) 
                const;
        std::pair<Obstacle *, Obstacle *> endpointAnchors(void) const;
        void outputCode(FILE *fp) const;
        std::pair<bool, bool> assignConnectionPinVisibility(const bool connect);


        Router *m_router;
        unsigned int m_id;
        ConnType m_type;
        bool *m_reroute_flag_ptr;
        bool m_needs_reroute_flag:1;
        bool m_false_path:1;
        bool m_needs_repaint:1;
        bool m_active:1;
        bool m_initialised:1;
        bool m_hate_crossings:1;
        bool m_has_fixed_route:1;
        PolyLine m_route;
        Polygon m_display_route;
        double m_route_dist;
        ConnRefList::iterator m_connrefs_pos;
        VertInf *m_src_vert;
        VertInf *m_dst_vert;
        VertInf *m_start_vert;
        void (*m_callback_func)(void *);
        void *m_connector;
        ConnEnd *m_src_connend;
        ConnEnd *m_dst_connend;
        std::vector<Checkpoint> m_checkpoints;
        std::vector<VertInf *> m_checkpoint_vertices;
};


typedef std::pair<Point *, ConnRef *> PtConnPtrPair;

typedef std::vector< PtConnPtrPair > PointRepVector;
typedef std::list<std::pair<size_t, size_t> > NodeIndexPairLinkList;

class PtOrder
{
    public:
        PtOrder();
        ~PtOrder();
        void addPoints(const size_t dim, const PtConnPtrPair& arg1, 
                const PtConnPtrPair& arg2);
        void addOrderedPoints(const size_t dim, const PtConnPtrPair& innerArg, 
                const PtConnPtrPair& outerArg, bool swapped);
        int positionFor(const size_t dim, const ConnRef *conn);
        PointRepVector sortedPoints(const size_t dim);
    private:
        size_t insertPoint(const size_t dim, const PtConnPtrPair& point);
        void sort(const size_t dim);

        // One for each dimension.
        bool sorted[2];
        PointRepVector nodes[2];
        NodeIndexPairLinkList links[2];
        PointRepVector sortedConnVector[2];
};

typedef std::map<Avoid::Point,PtOrder> PtOrderMap;
typedef std::set<Avoid::Point> PointSet;


const unsigned int CROSSING_NONE = 0;
const unsigned int CROSSING_TOUCHES = 1;
const unsigned int CROSSING_SHARES_PATH = 2;
const unsigned int CROSSING_SHARES_PATH_AT_END = 4;
const unsigned int CROSSING_SHARES_FIXED_SEGMENT = 8;


typedef std::pair<int, unsigned int> CrossingsInfoPair;
typedef std::vector<Avoid::Point> PointList;
typedef std::vector<PointList> SharedPathList;

class ConnectorCrossings
{
    public:
        ConnectorCrossings(Avoid::Polygon& poly, bool polyIsConn, 
                Avoid::Polygon& conn, ConnRef *polyConnRef = nullptr, 
                ConnRef *connConnRef = nullptr);
        void clear(void);
        void countForSegment(size_t cIndex, const bool finalSegment);

        Avoid::Polygon& poly;
        bool polyIsConn; 
        Avoid::Polygon& conn; 
        bool checkForBranchingSegments;
        ConnRef *polyConnRef;
        ConnRef *connConnRef;
        
        unsigned int crossingCount;
        unsigned int crossingFlags;
        PointSet *crossingPoints;
        PtOrderMap *pointOrders;
        SharedPathList *sharedPaths;
        
        double firstSharedPathAtEndLength;
        double secondSharedPathAtEndLength;
};

extern void splitBranchingSegments(Avoid::Polygon& poly, bool polyIsConn,
        Avoid::Polygon& conn, const double tolerance = 0);
extern bool validateBendPoint(VertInf *aInf, VertInf *bInf, VertInf *cInf);

}


#endif