Geometry.h

/**********************************************************************
 * $Id: Geometry.h 2556 2009-06-06 22:22:28Z strk $
 *
 * GEOS - Geometry Engine Open Source
 * http://geos.refractions.net
 *
 * Copyright (C) 2009  Sandro Santilli <strk@keybit.net>
 * Copyright (C) 2005 2006 Refractions Research Inc.
 * Copyright (C) 2001-2002 Vivid Solutions 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: geom/Geometry.java rev. 1.112
 *
 **********************************************************************/

#ifndef GEOS_GEOM_GEOMETRY_H
#define GEOS_GEOM_GEOMETRY_H

#include <geos/export.h>
#include <geos/platform.h>
#include <geos/inline.h>
#include <geos/geom/Envelope.h>
#include <geos/geom/Dimension.h> // for Dimension::DimensionType
#include <geos/geom/GeometryComponentFilter.h> // for inheritance

#include <string>
#include <iostream>
#include <vector>
#include <memory>

// Forward declarations
namespace geos {
        namespace geom {
                class Coordinate;
                class CoordinateFilter;
                class CoordinateSequence;
                class CoordinateSequenceFilter;
                class Envelope;
                class GeometryComponentFilter;
                class GeometryFactory;
                class GeometryFilter;
                class IntersectionMatrix;
                class PrecisionModel;
                class Point;
        }
        namespace io { // geos.io
                class Unload;
        } // namespace geos.io
}

namespace geos {
namespace geom { // geos::geom

enum GeometryTypeId {
        GEOS_POINT,
        GEOS_LINESTRING,
        GEOS_LINEARRING,
        GEOS_POLYGON,
        GEOS_MULTIPOINT,
        GEOS_MULTILINESTRING,
        GEOS_MULTIPOLYGON,
        GEOS_GEOMETRYCOLLECTION
};

class GEOS_DLL Geometry {

public:

        friend class GeometryFactory;

        friend std::ostream& operator<< (std::ostream& os, const Geometry& geom);

        typedef std::vector<const Geometry *> ConstVect;

        typedef std::vector<Geometry *> NonConstVect;

        typedef std::auto_ptr<Geometry> AutoPtr;

        virtual Geometry* clone() const=0;

        virtual ~Geometry();


        const GeometryFactory* getFactory() const { return factory; }

        void setUserData(void* newUserData) { userData=newUserData; }

        void* getUserData() { return userData; }

        /*
         * \brief
         * Returns the ID of the Spatial Reference System used by the
         * <code>Geometry</code>.
         *
         * GEOS supports Spatial Reference System information in the simple way
         * defined in the SFS. A Spatial Reference System ID (SRID) is present
         * in each <code>Geometry</code> object. <code>Geometry</code>
         * provides basic accessor operations for this field, but no others.
         * The SRID is represented as an integer.
         *
         * @return the ID of the coordinate space in which the
         * <code>Geometry</code> is defined.
         *
         */
        virtual int getSRID() const { return SRID; }

        /*
         * Sets the ID of the Spatial Reference System used by the
         * <code>Geometry</code>.
         */
        virtual void setSRID(int newSRID) { SRID=newSRID; }

        const PrecisionModel* getPrecisionModel() const;

        virtual const Coordinate* getCoordinate() const=0; //Abstract

        virtual CoordinateSequence* getCoordinates() const=0; //Abstract

        virtual size_t getNumPoints() const=0; //Abstract

        virtual bool isSimple() const; 

        virtual std::string getGeometryType() const=0; //Abstract

        virtual GeometryTypeId getGeometryTypeId() const=0; //Abstract

        virtual size_t getNumGeometries() const { return 1; }

        virtual const Geometry* getGeometryN(size_t /*n*/) const { return this; }

        virtual bool isValid() const;

        virtual bool isEmpty() const=0; //Abstract

        virtual bool isRectangle() const { return false; }

        virtual Dimension::DimensionType getDimension() const=0; //Abstract

        virtual Geometry* getBoundary() const=0; //Abstract

        virtual int getBoundaryDimension() const=0; //Abstract

        virtual Geometry* getEnvelope() const;

        virtual const Envelope* getEnvelopeInternal() const;

        virtual bool disjoint(const Geometry *other) const;

        virtual bool touches(const Geometry *other) const;

        virtual bool intersects(const Geometry *g) const;

        virtual bool crosses(const Geometry *g) const;

        virtual bool within(const Geometry *g) const;

        virtual bool contains(const Geometry *g) const;

        virtual bool overlaps(const Geometry *g) const;

        virtual bool relate(const Geometry *g,
                        const std::string& intersectionPattern) const;

        bool relate(const Geometry& g, const std::string& intersectionPattern) const
        {
                return relate(&g, intersectionPattern);
        }

        virtual IntersectionMatrix* relate(const Geometry *g) const;
        IntersectionMatrix* relate(const Geometry &g) const {
                return relate(&g);
        }

        virtual bool equals(const Geometry *g) const;

        bool covers(const Geometry* g) const;

        bool coveredBy(const Geometry* g) const {
          return g->covers(this);
        }


        virtual std::string toString() const;

        virtual std::string toText() const;
        
        //
        virtual Geometry* buffer(double distance) const;

        //
        virtual Geometry* buffer(double distance,int quadrantSegments) const;

        virtual Geometry* buffer(double distance, int quadrantSegments,
                        int endCapStyle) const;

        virtual Geometry* convexHull() const;

        virtual Geometry* intersection(const Geometry *other) const;

        virtual Geometry* Union(const Geometry *other) const;
                // throw(IllegalArgumentException *, TopologyException *);

        virtual Geometry* difference(const Geometry *other) const;

        virtual Geometry* symDifference(const Geometry *other) const;

        virtual bool equalsExact(const Geometry *other, double tolerance=0)
                const=0; //Abstract

        virtual void apply_rw(const CoordinateFilter *filter)=0; //Abstract
        virtual void apply_ro(CoordinateFilter *filter) const=0; //Abstract
        virtual void apply_rw(GeometryFilter *filter);
        virtual void apply_ro(GeometryFilter *filter) const;
        virtual void apply_rw(GeometryComponentFilter *filter);
        virtual void apply_ro(GeometryComponentFilter *filter) const;

        virtual void apply_rw(CoordinateSequenceFilter& filter)=0;

        virtual void apply_ro(CoordinateSequenceFilter& filter) const=0;

        template <class T>
        void applyComponentFilter(T& f) const
        {
                for(size_t i=0, n=getNumGeometries(); i<n; ++i)
                        f.filter(getGeometryN(i));
        }

        virtual void normalize()=0; //Abstract

        virtual int compareTo(const Geometry *geom) const;

        virtual double distance(const Geometry *g) const;

        virtual double getArea() const;

        virtual double getLength() const;

        virtual bool isWithinDistance(const Geometry *geom,double cDistance);

        virtual Point* getCentroid() const;

        //
        virtual bool getCentroid(Coordinate& ret) const;

        virtual Point* getInteriorPoint() const;

        /*
         * \brief
         * Notifies this Geometry that its Coordinates have been changed
         * by an external party (using a CoordinateFilter, for example).
         */
        virtual void geometryChanged();

        void geometryChangedAction();

protected:

        mutable std::auto_ptr<Envelope> envelope;
        
        static bool hasNonEmptyElements(const std::vector<Geometry *>* geometries);

        static bool hasNullElements(const CoordinateSequence* list);

        static bool hasNullElements(const std::vector<Geometry *>* lrs);

//      static void reversePointOrder(CoordinateSequence* coordinates);
//      static Coordinate& minCoordinate(CoordinateSequence* coordinates);
//      static void scroll(CoordinateSequence* coordinates,Coordinate* firstCoordinate);
//      static int indexOf(Coordinate* coordinate,CoordinateSequence* coordinates);
//
        virtual bool isEquivalentClass(const Geometry *other) const;

        static void checkNotGeometryCollection(const Geometry *g);
                        // throw(IllegalArgumentException *);

        //virtual void checkEqualSRID(Geometry *other);

        //virtual void checkEqualPrecisionModel(Geometry *other);

        virtual Envelope::AutoPtr computeEnvelopeInternal() const=0; //Abstract

        virtual int compareToSameClass(const Geometry *geom) const=0; //Abstract

        int compare(std::vector<Coordinate> a, std::vector<Coordinate> b) const;

        int compare(std::vector<Geometry *> a, std::vector<Geometry *> b) const;

        bool equal(const Coordinate& a, const Coordinate& b,
                        double tolerance) const;
        int SRID;

        //Geometry* toInternalGeometry(const Geometry *g) const;

        //Geometry* fromInternalGeometry(const Geometry *g) const;

        //virtual bool isRectangle() const { return false; } -- moved to public

        Geometry(const Geometry &geom);

        Geometry(const GeometryFactory *factory);

private:



        int getClassSortIndex() const;

        class GeometryChangedFilter : public GeometryComponentFilter
        {
        public:
                void filter_rw(Geometry* geom)
                {
                        geom->geometryChangedAction();
                }
        };

        static GeometryChangedFilter geometryChangedFilter;

        //
        const GeometryFactory *factory;

        static const GeometryFactory* INTERNAL_GEOMETRY_FACTORY;

        void* userData;
};

std::ostream& operator<< (std::ostream& os, const Geometry& geom);

struct GEOS_DLL GeometryGreaterThen {
        bool operator()(const Geometry *first, const Geometry *second);
};


std::string geosversion();

std::string jtsport();


} // namespace geos::geom
} // namespace geos

#ifdef GEOS_INLINE
# include <geos/geom/Geometry.inl>
#endif

#endif // ndef GEOS_GEOM_GEOMETRY_H

/**********************************************************************
 * $Log$
 * Revision 1.14  2006/07/08 00:33:55  strk
 *         * configure.in: incremented CAPI minor version, to avoid                        falling behind any future version from the 2.2. branch.
 *         * source/geom/Geometry.cpp, source/geom/GeometryFactory.cpp,
 *         source/geomgraph/EdgeRing.cpp,
 *         source/headers/geos/geom/Geometry.h,
 *         source/headers/geos/geom/GeometryFactory.h,
 *         source/headers/geos/geom/GeometryFactory.inl,
 *         source/headers/geos/geomgraph/EdgeRing.h:
 *         updated doxygen comments (sync with JTS head).
 *         * source/headers/geos/platform.h.in: include <inttypes.h>
 *         rather then <stdint.h>
 *
 * Revision 1.13  2006/06/12 10:10:39  strk
 * Fixed getGeometryN() to take size_t rather then int, changed unsigned int parameters to size_t.
 *
 * Revision 1.12  2006/05/18 08:56:50  strk
 *         * source/geom/Geometry.cpp,
 *         source/headers/geos/geom/Geometry.h: added
 *         covers() and isCoveredBy() predicates.
 *         * tests/unit/Makefile.am,
 *         tests/unit/geom/Geometry/coversTest.cpp:
 *         added test for covers() predicates.
 *
 * Revision 1.11  2006/05/04 15:49:39  strk
 * updated all Geometry::getDimension() methods to return Dimension::DimensionType (closes bug#93)
 *
 * Revision 1.10  2006/04/28 10:55:39  strk
 * Geometry constructors made protected, to ensure all constructions use GeometryFactory,
 * which has been made friend of all Geometry derivates. getNumPoints() changed to return
 * size_t.
 *
 * Revision 1.9  2006/04/11 09:31:47  strk
 * Added Geometry::AutoPtr typedef
 *
 * Revision 1.8  2006/04/10 18:15:09  strk
 * Changed Geometry::envelope member to be of type auto_ptr<Envelope>.
 * Changed computeEnvelopeInternal() signater to return auto_ptr<Envelope>
 *
 * Revision 1.7  2006/04/07 09:54:30  strk
 * Geometry::getNumGeometries() changed to return 'unsigned int'
 * rather then 'int'
 *
 * Revision 1.6  2006/03/31 16:53:53  strk
 * Added comment about possible NULL return from getCoordinate()
 *
 * Revision 1.5  2006/03/24 09:52:41  strk
 * USE_INLINE => GEOS_INLINE
 *
 * Revision 1.4  2006/03/23 15:10:29  strk
 * Dropped by-pointer TopologyException constructor, various small cleanups
 *
 * Revision 1.3  2006/03/23 12:12:01  strk
 * Fixes to allow build with -DGEOS_INLINE
 *
 * Revision 1.2  2006/03/20 12:03:25  strk
 * Added operator<< for Geometry, writing HEXWKB
 *
 * Revision 1.1  2006/03/09 16:46:49  strk
 * geos::geom namespace definition, first pass at headers split
 *
 **********************************************************************/

---