SegmentIntersectionDetector.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.
 *
 *
 **********************************************************************/
 
#ifndef GEOS_GEOM_PREP_SEGMENTINTERSECTIONDETECTOR_H
#define GEOS_GEOM_PREP_SEGMENTINTERSECTIONDETECTOR_H
 
#include <geos/noding/SegmentIntersector.h>
#include <geos/algorithm/LineIntersector.h>
#include <geos/geom/Coordinate.h>
#include <geos/geom/CoordinateSequence.h>
#include <geos/noding/SegmentString.h>
 
using namespace geos::algorithm;
 
namespace geos {
namespace noding { // geos::noding

class SegmentIntersectionDetector : public SegmentIntersector 
{
private:
        LineIntersector * li;
 
        bool findProper;
        bool findAllTypes;
 
        bool _hasIntersection;
        bool _hasProperIntersection;
        bool _hasNonProperIntersection;
 
        const geom::Coordinate * intPt;
        geom::CoordinateSequence * intSegments;
 
protected:
public:
        SegmentIntersectionDetector( LineIntersector * li) 
                :
                li( li),
                findProper(false),
                findAllTypes(false),
                _hasIntersection(false),
                _hasProperIntersection(false),
                _hasNonProperIntersection(false),
                intPt( NULL),
                intSegments( NULL)
        { }
 
        ~SegmentIntersectionDetector()
        {
                //delete intPt;
                delete intSegments;
        }
 
 
        void setFindProper( bool findProper)
        {
                this->findProper = findProper;
        }
  
        void setFindAllIntersectionTypes( bool findAllTypes)
        {
                this->findAllTypes = findAllTypes;
        }
  
        bool hasIntersection() const
        { 
                return _hasIntersection; 
        }
  
        bool hasProperIntersection() const 
        { 
                return _hasProperIntersection; 
        }
  
        bool hasNonProperIntersection() const
        { 
                return _hasNonProperIntersection; 
        }
  
        const geom::Coordinate * const getIntersection()  const
        {    
                return intPt;  
        }
 

        const geom::CoordinateSequence * getIntersectionSegments() const
        {
                return intSegments;
        }
  
        bool isDone() const
        { 
                // If finding all types, we can stop
                // when both possible types have been found.
                if (findAllTypes)
                        return _hasProperIntersection && _hasNonProperIntersection;
 
                // If searching for a proper intersection, only stop if one is found
                if (findProper)
                        return _hasProperIntersection;
 
                return _hasIntersection;
        }

        void processIntersections(      noding::SegmentString * e0, int segIndex0,
                                                                noding::SegmentString * e1, int segIndex1 );
  
};
 
} // namespace geos::noding
} // namespace geos
 
#endif // GEOS_GEOM_PREP_SEGMENTINTERSECTIONDETECTOR_H