SegmentNode.h

/**********************************************************************
 *
 * GEOS - Geometry Engine Open Source
 * http://geos.osgeo.org
 *
 * Copyright (C) 2006      Refractions Research Inc.
 *
 * This is free software; you can redistribute and/or modify it under
 * the terms of the GNU Lesser General Public Licence as published
 * by the Free Software Foundation.
 * See the COPYING file for more information.
 *
 **********************************************************************
 *
 * Last port: noding/SegmentNode.java 4667170ea (JTS-1.17)
 *
 **********************************************************************/
 
#pragma once
 
#include <geos/export.h>
#include <geos/geom/Coordinate.h>
#include <geos/noding/SegmentPointComparator.h>
#include <geos/noding/SegmentString.h>
 
#include <vector>
#include <iostream>
 
namespace geos {
namespace noding { // geos.noding
 
class GEOS_DLL SegmentNode {
private:
    int segmentOctant;
 
    bool isInteriorVar;
 
public:
    friend std::ostream& operator<< (std::ostream& os, const SegmentNode& n);
 
    geom::CoordinateXYZM coord;
 
    std::size_t segmentIndex;
 
    template<typename CoordType>
    SegmentNode(const SegmentString& ss,
        const CoordType& nCoord,
        std::size_t nSegmentIndex, int nSegmentOctant)
        : segmentOctant(nSegmentOctant)
        , coord(nCoord)
        , segmentIndex(nSegmentIndex)
    {
        // Number of points in NodedSegmentString is one-more number of segments
        assert(segmentIndex < ss.size());
        isInteriorVar = !coord.equals2D(ss.getCoordinate(segmentIndex));
    }
 
    ~SegmentNode() {}
 
    bool
    isInterior() const
    {
        return isInteriorVar;
    }
 
    bool isEndPoint(unsigned int maxSegmentIndex) const
    {
        if(segmentIndex == 0 && ! isInteriorVar) {
            return true;
        }
        if(segmentIndex == maxSegmentIndex) {
            return true;
        }
        return false;
    };
 
    int compareTo(const SegmentNode& other) const
    {
        if (segmentIndex < other.segmentIndex) {
            return -1;
        }
        if (segmentIndex > other.segmentIndex) {
            return 1;
        }
 
        if (coord.equals2D(other.coord)) {
 
            return 0;
        }
 
        // an exterior node is the segment start point,
        // so always sorts first
        // this guards against a robustness problem
        // where the octants are not reliable
        if (!isInteriorVar) return -1;
        if (!other.isInteriorVar) return 1;
 
        return SegmentPointComparator::compare(
            segmentOctant, coord,
            other.coord);
    };
 
};
 
// std::ostream& operator<< (std::ostream& os, const SegmentNode& n);
 
struct GEOS_DLL SegmentNodeLT {
    bool
    operator()(SegmentNode* s1, SegmentNode* s2) const
    {
        return s1->compareTo(*s2) < 0;
    }
 
    bool
    operator()(const SegmentNode& s1, const SegmentNode& s2) const
    {
        return s1.compareTo(s2) < 0;
    }
};
 
 
} // namespace geos.noding
} // namespace geos