/*private*/
void
ConvexHull::cleanRing(const Coordinate::ConstVect &original,
Coordinate::ConstVect &cleaned)
{
size_t npts=original.size();
const Coordinate *last = original[npts-1];
//util::Assert::equals(*(original[0]), *last);
assert(last);
assert(original[0]->equals2D(*last));
const Coordinate *prev = NULL;
for (size_t i=0; i<npts-1; ++i)
{
const Coordinate *curr = original[i];
const Coordinate *next = original[i+1];
// skip consecutive equal coordinates
if (curr->equals2D(*next)) continue;
if ( prev != NULL && isBetween(*prev, *curr, *next) )
{
continue;
}
cleaned.push_back(curr);
prev=curr;
}
cleaned.push_back(last);
}
/* static */
bool
LineSequencer::isSequenced(const Geometry* geom)
{
const MultiLineString *mls;
if ( nullptr == (mls=dynamic_cast<const MultiLineString *>(geom)) )
{
return true;
}
// the nodes in all subgraphs which have been completely scanned
Coordinate::ConstSet prevSubgraphNodes;
Coordinate::ConstVect currNodes;
const Coordinate* lastNode = nullptr;
for (std::size_t i=0, n=mls->getNumGeometries(); i<n; ++i)
{
const LineString* lineptr = \
dynamic_cast<const LineString*>(mls->getGeometryN(i));
assert(lineptr);
const LineString& line = *lineptr;
const Coordinate* startNode = &(line.getCoordinateN(0));
const Coordinate* endNode = &(line.getCoordinateN(line.getNumPoints() - 1));
/**
* If this linestring is connected to a previous subgraph,
* geom is not sequenced
*/
if (prevSubgraphNodes.find(startNode) != prevSubgraphNodes.end())
{
return false;
}
if (prevSubgraphNodes.find(endNode) != prevSubgraphNodes.end())
{
return false;
}
if (lastNode != nullptr)
{
if (! startNode->equals2D(*lastNode))
{
// start new connected sequence
prevSubgraphNodes.insert(currNodes.begin(),
currNodes.end());
currNodes.clear();
}
}
currNodes.push_back(startNode);
currNodes.push_back(endNode);
lastNode = endNode;
}
return true;
}
/*private*/
void
ConvexHull::grahamScan(const Coordinate::ConstVect &c,
Coordinate::ConstVect &ps)
{
ps.push_back(c[0]);
ps.push_back(c[1]);
ps.push_back(c[2]);
for(size_t i=3, n=c.size(); i<n; ++i)
{
const Coordinate *p = ps.back(); ps.pop_back();
while (!ps.empty() &&
CGAlgorithms::computeOrientation(
*(ps.back()), *p, *(c[i])) > 0)
{
p = ps.back(); ps.pop_back();
}
ps.push_back(p);
ps.push_back(c[i]);
}
ps.push_back(c[0]);
}
/* private */
bool
ConvexHull::computeOctRing(const Coordinate::ConstVect &inputPts,
Coordinate::ConstVect &dest)
{
computeOctPts(inputPts, dest);
// Remove consecutive equal Coordinates
// unique() returns an iterator to the end of the resulting
// sequence, we erase from there to the end.
dest.erase( std::unique(dest.begin(),dest.end()), dest.end() );
// points must all lie in a line
if ( dest.size() < 3 ) return false;
// close ring
dest.push_back(dest[0]);
return true;
}