DistanceOp.h

/**********************************************************************
 *
 * GEOS - Geometry Engine Open Source
 * http://geos.osgeo.org
 *
 * Copyright (C) 2011 Sandro Santilli <strk@keybit.net>
 * 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: operation/distance/DistanceOp.java r335 (JTS-1.12-)
 *
 **********************************************************************/
 
#ifndef GEOS_OP_DISTANCE_DISTANCEOP_H
#define GEOS_OP_DISTANCE_DISTANCEOP_H
 
#include <geos/export.h>
 
#include <geos/algorithm/PointLocator.h> // for composition
 
#include <vector>
 
#ifdef _MSC_VER
#pragma warning(push)
#pragma warning(disable: 4251) // warning C4251: needs to have dll-interface to be used by clients of class
#endif
 
// Forward declarations
namespace geos {
        namespace geom { 
                class Coordinate;
                class Polygon;
                class LineString;
                class Point;
                class Geometry;
                class CoordinateSequence;
        }
        namespace operation { 
                namespace distance { 
                        class GeometryLocation;
                }
        }
}
 
 
namespace geos {
namespace operation { // geos::operation
namespace distance { // geos::operation::distance

class GEOS_DLL DistanceOp {
public:
        static double distance(const geom::Geometry& g0,
                               const geom::Geometry& g1);

        static double distance(const geom::Geometry *g0,
                                const geom::Geometry *g1);

        static bool isWithinDistance(const geom::Geometry& g0,
                                     const geom::Geometry& g1,
                                                    double distance);

        static geom::CoordinateSequence* nearestPoints(
                                                const geom::Geometry *g0,
                                                const geom::Geometry *g1);

        static geom::CoordinateSequence* closestPoints(
                                                const geom::Geometry *g0,
                                                const geom::Geometry *g1);

        DistanceOp(const geom::Geometry *g0, const geom::Geometry *g1);

        DistanceOp(const geom::Geometry& g0, const geom::Geometry& g1);

        DistanceOp(const geom::Geometry& g0, const geom::Geometry& g1,
                                              double terminateDistance);
 
        ~DistanceOp();

        double distance();

        geom::CoordinateSequence* closestPoints();

        geom::CoordinateSequence* nearestPoints();
 
private:

        std::vector<GeometryLocation*>* nearestLocations();
 
        // input (TODO: use two references instead..)
        std::vector<geom::Geometry const*> geom;
        double terminateDistance; 
 
        // working 
        algorithm::PointLocator ptLocator;
        // TODO: use auto_ptr
        std::vector<GeometryLocation*> *minDistanceLocation;
        double minDistance;
 
        // memory management
        std::vector<geom::Coordinate *> newCoords;
 
 
        void updateMinDistance(std::vector<GeometryLocation*>& locGeom,
                               bool flip);
 
        void computeMinDistance();
 
        void computeContainmentDistance();
 
        void computeInside(std::vector<GeometryLocation*> *locs,
                        const std::vector<const geom::Polygon*>& polys,
                        std::vector<GeometryLocation*> *locPtPoly);
 
        void computeInside(GeometryLocation *ptLoc,
                        const geom::Polygon *poly,
                        std::vector<GeometryLocation*> *locPtPoly);

        void computeFacetDistance();
 
        void computeMinDistanceLines(
                        const std::vector<const geom::LineString*>& lines0,
                        const std::vector<const geom::LineString*>& lines1,
                        std::vector<GeometryLocation*>& locGeom);
 
        void computeMinDistancePoints(
                        const std::vector<const geom::Point*>& points0,
                        const std::vector<const geom::Point*>& points1,
                        std::vector<GeometryLocation*>& locGeom);
 
        void computeMinDistanceLinesPoints(
                        const std::vector<const geom::LineString*>& lines0,
                        const std::vector<const geom::Point*>& points1,
                        std::vector<GeometryLocation*>& locGeom);
 
        void computeMinDistance(const geom::LineString *line0,
                        const geom::LineString *line1,
                        std::vector<GeometryLocation*>& locGeom);
 
        void computeMinDistance(const geom::LineString *line,
                        const geom::Point *pt,
                        std::vector<GeometryLocation*>& locGeom);
};
 
 
} // namespace geos::operation::distance
} // namespace geos::operation
} // namespace geos
 
#ifdef _MSC_VER
#pragma warning(pop)
#endif
 
#endif // GEOS_OP_DISTANCE_DISTANCEOP_H