QuadEdge.h

Go to the documentation of this file.

/**********************************************************************
 *
 * GEOS - Geometry Engine Open Source
 * http://geos.osgeo.org
 *
 * Copyright (C) 2012 Excensus LLC.
 * Copyright (C) 2019 Daniel Baston
 *
 * This is free software; you can redistribute and/or modify it under
 * the terms of the GNU Lesser General Licence as published
 * by the Free Software Foundation.
 * See the COPYING file for more information.
 *
 **********************************************************************
 *
 * Last port: triangulate/quadedge/QuadEdge.java r524
 *
 **********************************************************************/

#ifndef GEOS_TRIANGULATE_QUADEDGE_QUADEDGE_H
#define GEOS_TRIANGULATE_QUADEDGE_QUADEDGE_H

#include <memory>

#include <geos/triangulate/quadedge/Vertex.h>
#include <geos/geom/LineSegment.h>

namespace geos {
namespace triangulate { //geos.triangulate
namespace quadedge { //geos.triangulate.quadedge


class GEOS_DLL QuadEdgeQuartet;

class GEOS_DLL QuadEdge {
    friend class QuadEdgeQuartet;
public:
    static QuadEdge* makeEdge(const Vertex& o, const Vertex & d, std::deque<QuadEdgeQuartet> & edges);

    static QuadEdge* connect(QuadEdge& a, QuadEdge& b, std::deque<QuadEdgeQuartet> & edges);

    static void splice(QuadEdge& a, QuadEdge& b);

    static void swap(QuadEdge& e);

private:
    Vertex   vertex; // The vertex that this edge represents
    QuadEdge* next;  // A reference to a connected edge

    int8_t num;      // the position of the QuadEdge in the quartet (0-3)

    bool isAlive;
    bool visited;

    explicit QuadEdge(int8_t _num) :
        next(nullptr),
        num(_num),
        isAlive(true),
        visited(false) {
    }

public:
    const QuadEdge& getPrimary();

    void remove();

    inline bool
    isLive() const
    {
        return isAlive;
    }

    inline bool
    isVisited() const
    {
        return visited;
    }

    inline void
    setVisited(bool v) {
        visited = v;
    }

    inline void
    setNext(QuadEdge* p_next)
    {
        this->next = p_next;
    }

    /***************************************************************************
     * QuadEdge Algebra
     ***************************************************************************
     */

    inline const QuadEdge&
    rot() const
    {
        return (num < 3) ? *(this + 1) : *(this - 3);
    }

    inline QuadEdge&
    rot()
    {
        return (num < 3) ? *(this + 1) : *(this - 3);
    }

    inline const QuadEdge&
    invRot() const
    {
        return (num > 0) ? *(this - 1) : *(this + 3);
    }

    inline QuadEdge&
    invRot()
    {
        return (num > 0) ? *(this - 1) : *(this + 3);
    }

    inline const QuadEdge&
    sym() const
    {
        return (num < 2) ? *(this + 2) : *(this - 2);
    }

    inline QuadEdge&
    sym()
    {
        return (num < 2) ? *(this + 2) : *(this - 2);
    }

    inline const QuadEdge&
    oNext() const
    {
        return *next;
    }

    inline QuadEdge&
    oNext()
    {
        return *next;
    }

    inline const QuadEdge&
    oPrev() const
    {
        return rot().oNext().rot();
    }

    inline QuadEdge&
    oPrev()
    {
        return rot().oNext().rot();
    }

    inline const QuadEdge&
    dNext() const
    {
        return sym().oNext().sym();
    }

    inline const QuadEdge&
    dPrev() const
    {
        return invRot().oNext().invRot();
    }

    inline QuadEdge&
    dPrev()
    {
        return invRot().oNext().invRot();
    }

    inline const QuadEdge&
    lNext() const
    {
        return invRot().oNext().rot();
    }

    inline QuadEdge&
    lNext()
    {
        return invRot().oNext().rot();
    }

    inline const QuadEdge&
    lPrev() const
    {
        return oNext().sym();
    }

    inline QuadEdge&
    lPrev()
    {
        return oNext().sym();
    }

    inline const QuadEdge&
    rNext() const
    {
        return rot().oNext().invRot();
    }

    inline const QuadEdge&
    rPrev() const
    {
        return sym().oNext();
    }

    /***********************************************************************************************
     * Data Access
     **********************************************************************************************/
    inline void
    setOrig(const Vertex& o)
    {
        vertex = o;
    }

    inline void
    setDest(const Vertex& d)
    {
        sym().setOrig(d);
    }

    const Vertex&
    orig() const
    {
        return vertex;
    }

    const Vertex&
    dest() const
    {
        return sym().orig();
    }

    inline double
    getLength() const
    {
        return orig().getCoordinate().distance(dest().getCoordinate());
    }

    bool equalsNonOriented(const QuadEdge& qe) const;

    bool equalsOriented(const QuadEdge& qe) const;

    std::unique_ptr<geom::LineSegment> toLineSegment() const;
};

GEOS_DLL std::ostream& operator<< (std::ostream& os, const QuadEdge* e);

} //namespace geos.triangulate.quadedge
} //namespace geos.triangulate
} //namespace geos

#endif //GEOS_TRIANGULATE_QUADEDGE_QUADEDGE_H