index/chain/MonotoneChain.h
/**********************************************************************
*
* GEOS - Geometry Engine Open Source
* http://geos.osgeo.org
*
* 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: index/chain/MonotoneChain.java rev. 1.15 (JTS-1.10)
*
**********************************************************************/
#pragma once
#include <geos/export.h>
#include <geos/geom/CoordinateSequence.h> // for inline
#include <geos/geom/Envelope.h> // for inline
#include <geos/geom/LineSegment.h> // for inline
#include <memory> // for unique_ptr
// Forward declarations
namespace geos {
namespace geom {
class LineSegment;
class CoordinateSequence;
}
namespace index {
namespace chain {
class MonotoneChainSelectAction;
class MonotoneChainOverlapAction;
}
}
}
namespace geos {
namespace index { // geos::index
namespace chain { // geos::index::chain
class GEOS_DLL MonotoneChain {
public:
MonotoneChain(const geom::CoordinateSequence& pts,
std::size_t start, std::size_t end, void* context);
~MonotoneChain() = default;
const geom::Envelope& getEnvelope() const;
const geom::Envelope& getEnvelope(double expansionDistance) const;
size_t
getStartIndex() const
{
return start;
}
size_t
getEndIndex() const
{
return end;
}
void getLineSegment(std::size_t index, geom::LineSegment& ls) const {
pts->getAt(index, ls.p0);
pts->getAt(index + 1, ls.p1);
}
std::unique_ptr<geom::CoordinateSequence> getCoordinates() const;
void select(const geom::Envelope& searchEnv,
MonotoneChainSelectAction& mcs) const;
void computeOverlaps(const MonotoneChain* mc,
MonotoneChainOverlapAction* mco) const;
void computeOverlaps(const MonotoneChain* mc, double overlapTolerance,
MonotoneChainOverlapAction* mco) const;
void*
getContext() const
{
return context;
}
private:
void computeSelect(const geom::Envelope& searchEnv,
std::size_t start0,
std::size_t end0,
MonotoneChainSelectAction& mcs) const;
void computeOverlaps(std::size_t start0, std::size_t end0, const MonotoneChain& mc,
std::size_t start1, std::size_t end1,
double overlapTolerance,
MonotoneChainOverlapAction& mco) const;
bool overlaps(std::size_t start0, std::size_t end0,
const MonotoneChain& mc, std::size_t start1, std::size_t end1,
double overlapTolerance) const {
if (overlapTolerance > 0.0) {
return overlaps(pts->getAt<geom::CoordinateXY>(start0),
pts->getAt<geom::CoordinateXY>(end0),
mc.pts->getAt<geom::CoordinateXY>(start1),
mc.pts->getAt<geom::CoordinateXY>(end1),
overlapTolerance);
}
return geom::Envelope::intersects(pts->getAt<geom::CoordinateXY>(start0),
pts->getAt<geom::CoordinateXY>(end0),
mc.pts->getAt<geom::CoordinateXY>(start1),
mc.pts->getAt<geom::CoordinateXY>(end1));
}
static bool overlaps(const geom::CoordinateXY& p1, const geom::CoordinateXY& p2,
const geom::CoordinateXY& q1, const geom::CoordinateXY& q2,
double overlapTolerance);
const geom::CoordinateSequence* pts;
void* context;
std::size_t start;
std::size_t end;
mutable geom::Envelope env;
};
} // namespace geos::index::chain
} // namespace geos::index
} // namespace geos
geos::geom::CoordinateSequence
The internal representation of a list of coordinates inside a Geometry.
Definition CoordinateSequence.h:56
geos::geom::Envelope
An Envelope defines a rectangulare region of the 2D coordinate plane.
Definition Envelope.h:59
geos::geom::Envelope::intersects
static bool intersects(const CoordinateXY &p1, const CoordinateXY &p2, const CoordinateXY &q)
Test the point q to see whether it intersects the Envelope defined by p1-p2.
geos::geom::LineSegment
Definition LineSegment.h:61
geos::geom::LineSegment::p1
Coordinate p1
Segment start.
Definition LineSegment.h:66
geos::index::chain::MonotoneChainOverlapAction
The action for the internal iterator for performing overlap queries on a MonotoneChain.
Definition MonotoneChainOverlapAction.h:42
geos::index::chain::MonotoneChainSelectAction
Definition MonotoneChainSelectAction.h:44
geos::index::chain::MonotoneChain
Monotone Chains are a way of partitioning the segments of a linestring to allow for fast searching of...
Definition index/chain/MonotoneChain.h:85
geos::index::chain::MonotoneChain::MonotoneChain
MonotoneChain(const geom::CoordinateSequence &pts, std::size_t start, std::size_t end, void *context)
geos::index::chain::MonotoneChain::getEnvelope
const geom::Envelope & getEnvelope() const
Returned envelope is owned by this class.
geos::index::chain::MonotoneChain::getLineSegment
void getLineSegment(std::size_t index, geom::LineSegment &ls) const
Set given LineSegment with points of the segment starting at the given index.
Definition index/chain/MonotoneChain.h:123
geos::index::chain::MonotoneChain::select
void select(const geom::Envelope &searchEnv, MonotoneChainSelectAction &mcs) const
geos::index::chain::MonotoneChain::getCoordinates
std::unique_ptr< geom::CoordinateSequence > getCoordinates() const
geos::geom::CoordinateSequence::getAt
const T & getAt(std::size_t i) const
Returns a read-only reference to Coordinate at position i.
Definition CoordinateSequence.h:249
geos::geom
Definition Angle.h:26
geos::index::chain
Contains classes that implement Monotone Chains.
Definition index/chain/MonotoneChain.h:35
geos::index
Provides classes for various kinds of spatial indexes.
Definition CleanCoverage.h:39
geos
Basic namespace for all GEOS functionalities.
Definition geos.h:38