geomUtil.h

/**********************************************************************
 * $Id: geomUtil.h,v 1.3 2004/07/19 13:19:31 strk Exp $
 *
 * GEOS - Geometry Engine Open Source
 * http://geos.refractions.net
 *
 * 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.
 *
 **********************************************************************
 * $Log: geomUtil.h,v $
 * Revision 1.3  2004/07/19 13:19:31  strk
 * Documentation fixes
 *
 * Revision 1.2  2004/07/08 19:34:49  strk
 * Mirrored JTS interface of CoordinateSequence, factory and
 * default implementations.
 * Added DefaultCoordinateSequenceFactory::instance() function.
 *
 * Revision 1.1  2004/07/02 13:20:42  strk
 * Header files moved under geos/ dir.
 *
 * Revision 1.4  2004/05/14 14:45:28  strk
 * Fixed bogus inheritance of LinearComponentExtracter
 *
 * Revision 1.3  2004/05/14 13:42:46  strk
 * DistanceOp bug removed, cascading errors fixed.
 *
 * Revision 1.2  2004/04/20 08:52:01  strk
 * GeometryFactory and Geometry const correctness.
 * Memory leaks removed from SimpleGeometryPrecisionReducer
 * and GeometryFactory.
 *
 * Revision 1.1  2004/04/04 06:29:11  ybychkov
 * "planargraph" and "geom/utill" upgraded to JTS 1.4
 *
 *
 */
#ifndef GEOS_GEOMUTIL_H
#define GEOS_GEOMUTIL_H

#include <geos/geom.h>
#include <geos/platform.h>
#include <vector>

using namespace std;

namespace geos {

/*
 * Extracts all the 2-dimensional (Polygon) components from a Geometry.
 */
class PolygonExtracter: public GeometryFilter {
public:
        static vector<Geometry*>* getPolygons(const Geometry *geom);
        PolygonExtracter(vector<Geometry*>* newComps);
        void filter_rw(Geometry *geom);
        void filter_ro(const Geometry *geom);
private:
        vector<Geometry*>* comps;
};

/*
 * Extracts all the 0-dimensional (Point) components from a Geometry.
 */
class PointExtracter: public GeometryFilter {
public:
        static vector<Geometry*>* getPoints(const Geometry *geom);
        PointExtracter(vector<Geometry*>* newComps);
        void filter_rw(Geometry *geom);
        void filter_ro(const Geometry *geom);
private:
        vector<Geometry*>* comps;
};

/*
 * Extracts all the 1-dimensional (LineString) components from a Geometry.
 */
class LinearComponentExtracter: public GeometryComponentFilter {
public:
        static vector<Geometry*>* getLines(const Geometry *geom);
        LinearComponentExtracter(vector<Geometry*>* newComps);
        void filter_rw(Geometry *geom);
        void filter_ro(const Geometry *geom);
private:
        vector<Geometry*>* comps;
};

/*
 * A interface which specifies an edit operation for Geometries.
 */
class GeometryEditorOperation {
public:
        virtual Geometry* edit(const Geometry *geometry, const GeometryFactory *factory)=0;
};

/*
 * A GeometryEditorOperation which modifies the coordinate list of a
 * Geometry.
 * Operates on Geometry subclasses which contains a single coordinate list.
 */
class CoordinateOperation: public GeometryEditorOperation {
public:
        virtual Geometry* edit(const Geometry *geometry, const GeometryFactory *factory);
        virtual CoordinateSequence* edit(const CoordinateSequence* coordinates, const Geometry *geometry)=0;
};

class gfCoordinateOperation: public CoordinateOperation {
public:
        virtual CoordinateSequence* edit(const CoordinateSequence *coordinates, const Geometry *geometry);
};


/*
 * Supports creating a new Geometry which is a modification of an existing one.
 * Geometry objects are intended to be treated as immutable.
 * This class allows you to "modify" a Geometry
 * by traversing it and creating a new Geometry with the same overall
 * structure but possibly modified components.
 *
 * The following kinds of modifications can be made:
 *
 * - the values of the coordinates may be changed.
 *   Changing coordinate values may make the result Geometry invalid;
 *   this is not checked by the GeometryEditor
 * - the coordinate lists may be changed
 *   (e.g. by adding or deleting coordinates).
 * The modifed coordinate lists must be consistent with their original parent component
 * (e.g. a LinearRing must always have at least 4 coordinates, and the first and last
 * coordinate must be equal)
 * <li>components of the original geometry may be deleted
 * (e.g. holes may be removed from a Polygon, or LineStrings removed from a MultiLineString).
 * Deletions will be propagated up the component tree appropriately.
 * </ul>
 * Note that all changes must be consistent with the original Geometry's structure
 * (e.g. a Polygon cannot be collapsed into a LineString).
 * <p>
 * The resulting Geometry is not checked for validity.
 * If validity needs to be enforced, the new Geometry's #isValid should be checked.
 *
 * @see Geometry#isValid
 *
 */
class GeometryEditor {
private:
        const GeometryFactory* factory;
        Polygon* editPolygon(const Polygon *polygon, GeometryEditorOperation *operation);
        GeometryCollection* editGeometryCollection(const GeometryCollection *collection,GeometryEditorOperation *operation);
public:
        GeometryEditor();
        GeometryEditor(const GeometryFactory *newFactory);
        Geometry* edit(const Geometry *geometry, GeometryEditorOperation *operation);
};


}
#endif

---