BufferBuilder.h

/**********************************************************************
 *
 * GEOS - Geometry Engine Open Source
 * http://geos.osgeo.org
 *
 * Copyright (C) 2009-2011 Sandro Santilli <strk@keybit.net>
 * Copyright (C) 2008-2010 Safe Software Inc.
 * Copyright (C) 2006-2007 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/buffer/BufferBuilder.java r378 (JTS-1.12)
 *
 **********************************************************************/
 
#ifndef GEOS_OP_BUFFER_BUFFERBUILDER_H
#define GEOS_OP_BUFFER_BUFFERBUILDER_H
 
#include <geos/export.h>
 
#include <vector>
 
#include <geos/operation/buffer/BufferOp.h> // for inlines (BufferOp enums)
#include <geos/operation/buffer/OffsetCurveBuilder.h> // for inline (OffsetCurveBuilder enums)
#include <geos/geomgraph/EdgeList.h> // for composition
 
#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 PrecisionModel;
                class Geometry;
                class GeometryFactory;
        }
        namespace algorithm {
                class CGAlgorithms;
                class LineIntersector;
        }
        namespace noding {
                class Noder;
                class SegmentString;
                class IntersectionAdder;
        }
        namespace geomgraph {
                class Edge;
                class Label;
                class PlanarGraph;
        }
        namespace operation {
                namespace buffer {
                        class BufferSubgraph;
                }
                namespace overlay {
                        class PolygonBuilder;
                }
        }
}
 
namespace geos {
namespace operation { // geos.operation
namespace buffer { // geos.operation.buffer

class GEOS_DLL BufferBuilder {
 
public:
        BufferBuilder(const BufferParameters& nBufParams)
                :
                bufParams(nBufParams),
                workingPrecisionModel(NULL),
                li(NULL),
                intersectionAdder(NULL),
                workingNoder(NULL),
                geomFact(NULL),
                edgeList()
        {}
 
        ~BufferBuilder();
 

        void setWorkingPrecisionModel(const geom::PrecisionModel *pm) {
                workingPrecisionModel=pm;
        }

        void setNoder(noding::Noder* newNoder) { workingNoder = newNoder; }
 
        geom::Geometry* buffer(const geom::Geometry *g, double distance);
                // throw (GEOSException);

        geom::Geometry* bufferLineSingleSided( const geom::Geometry* g,
                                        double distance, bool leftSide ) ;
                // throw (GEOSException);
 
private:

        static int depthDelta(const geomgraph::Label& label);
 
        const BufferParameters& bufParams; 
 
        const geom::PrecisionModel* workingPrecisionModel;
 
        algorithm::LineIntersector* li;
 
        noding::IntersectionAdder* intersectionAdder;
 
        noding::Noder* workingNoder;
 
        const geom::GeometryFactory* geomFact;
 
        geomgraph::EdgeList edgeList;
 
        std::vector<geomgraph::Label *> newLabels;
 
        void computeNodedEdges(std::vector<noding::SegmentString*>& bufSegStr,
                        const geom::PrecisionModel *precisionModel);
                        // throw(GEOSException);

        void insertUniqueEdge(geomgraph::Edge *e);
 
        void createSubgraphs(geomgraph::PlanarGraph *graph,
                        std::vector<BufferSubgraph*>& list);

        void buildSubgraphs(const std::vector<BufferSubgraph*>& subgraphList,
                        overlay::PolygonBuilder& polyBuilder);

        //
        noding::Noder* getNoder(const geom::PrecisionModel* precisionModel);
 

        geom::Geometry* createEmptyResultGeometry() const;
    
    // Declare type as noncopyable
    BufferBuilder(const BufferBuilder& other);
    BufferBuilder& operator=(const BufferBuilder& rhs);
};
 
} // namespace geos::operation::buffer
} // namespace geos::operation
} // namespace geos
 
#ifdef _MSC_VER
#pragma warning(pop)
#endif
 
#endif // ndef GEOS_OP_BUFFER_BUFFERBUILDER_H