void object::test<4>()
{
GeomPtr geom ( wktreader.read("POINT(-117 33 120)") );
std::string result;
wktwriter.setOutputDimension(2);
wktwriter.setTrim( true );
wktwriter.setOld3D( false );
result = wktwriter.write( geom.get() );
ensure_equals( result, std::string("POINT (-117 33)") );
}
void object::test<6>()
{
GeomPtr geom;
try {
geom.reset(wktreader.read("POLYGON( EMPTY, (1 1,2 2,1 2,1 1))"));
ensure( !"Didn't get expected exception" );
} catch (const geos::util::IllegalArgumentException& ex) {
ensure( "Did get expected exception" );
ex.what();
} catch (...) {
ensure( !"Got unexpected exception" );
}
}
void object::test<4>()
{
GeomPtr geom = fromWKT("POLYGON ((0 0, 0 10, 10 10, 10 0, 0 0), (1 1, 2 1, 2 2, 1 2, 1 1) ))");
Polygon* poly = dynamic_cast<Polygon*>(geom.get());
ensure(nullptr != poly);
const LineString* ring = poly->getInteriorRingN(0);
const LinearRing* lr = dynamic_cast<const LinearRing*>(ring);
ensure(nullptr != lr);
LinearRing* nclr = const_cast<LinearRing*>(lr);
updateNonClosedRing(*nclr);
checkIsValid(*geom, false);
}
GeomPtr
readGeometry(const std::string& wkt)
{
GeomPtr g;
if(wkt[0] == '0' || wkt[0] == '1') {
WKBReader r;
std::istringstream is(wkt);
g.reset(r.readHEX(is));
}
else {
WKTReader r;
g.reset(r.read(wkt));
}
return g;
}
void object::test<1>()
{
GeomPtr geom ( wktreader.read("POINT(-117 33)") );
std::string result;
wktwriter.setTrim(false);
result = wktwriter.write( geom.get() );
ensure_equals( result , "POINT (-117.000 33.000)" );
wktwriter.setTrim(true);
result = wktwriter.write( geom.get() );
ensure_equals( result , "POINT (-117 33)" );
}
void object::test<2>()
{
GeomPtr geom ( wktreader.read("POINT(-117.1234567 33.1234567)") );
std::string result;
wktwriter.setTrim(false);
result = wktwriter.write( geom.get() );
ensure_equals( result , "POINT (-117.123 33.123)" );
wktwriter.setRoundingPrecision(2);
result = wktwriter.write( geom.get() );
ensure_equals( result , "POINT (-117.12 33.12)" );
}
void runLineSequencer(const char * const * inputWKT,
const std::string& expectedWKT)
{
readWKT(inputWKT, inpGeoms);
LineSequencer sequencer;
sequencer.add(inpGeoms);
if ( ! sequencer.isSequenceable() ) {
ensure( expectedWKT.empty() );
} else {
GeomPtr expected = readWKT(expectedWKT);
GeomPtr result ( sequencer.getSequencedLineStrings() );
ensure( expected->equalsExact( result.get() ) );
bool isSequenced = LineSequencer::isSequenced(result.get());
ensure( isSequenced );
}
}
void object::test<1>()
{
CoordinateSequence* cs = new CoordinateArraySequence();
cs->add(Coordinate(0.0, 0.0));
cs->add(Coordinate(1.0, DoubleNotANumber));
GeomPtr line ( factory_.createLineString(cs) );
IsValidOp isValidOp(line.get());
bool valid = isValidOp.isValid();
TopologyValidationError* err = isValidOp.getValidationError();
ensure(0 != err);
const Coordinate& errCoord = err->getCoordinate();
ensure_equals( err->getErrorType(),
TopologyValidationError::eInvalidCoordinate );
ensure(0 != ISNAN(errCoord.y));
ensure_equals(valid, false);
}
void object::test<13>()
{
Coordinate p1(-123456789, -40);
Coordinate p2(381039468754763.0, 123456789);
Coordinate q(0, 0);
using geos::geom::CoordinateSequence;
using geos::geom::GeometryFactory;
using geos::geom::LineString;
GeometryFactory::Ptr factory = GeometryFactory::create();
CoordinateSequence* cs = new CoordinateArraySequence();
cs->add(p1);
cs->add(p2);
GeomPtr l ( factory->createLineString(cs) );
GeomPtr p ( factory->createPoint(q) );
ensure(!l->intersects(p.get()));
ensure(!CGAlgorithms::isOnLine(q, cs));
ensure_equals(CGAlgorithms::computeOrientation(p1, p2, q), -1);
}
void doClipTest(const char* inputWKT, const std::string& expectedWKT, const Rectangle& rect, double tolerance=0)
{
GeomPtr g = readWKT(inputWKT);
ensure(g.get());
GeomPtr obt = RectangleIntersection::clip(*g,rect);
ensure(obt.get());
bool ok = isEqual(*readWKT(expectedWKT), *obt, tolerance);
ensure(ok);
// Compare with GEOSIntersection output
#if 0
GeomPtr g2 ( rect.toPolygon(*g->getFactory()) );
obt.reset(g->intersection(g2.get()));
ensure(obt.get());
ok = isEqual(*readWKT(expectedWKT), *obt, tolerance);
ensure(ok);
#endif
}
bool
pointsWithinDistance(vector<Coordinate>& coords, double dist)
{
// we expect some numerical instability here
// OffsetPointGenerator could produce points
// at *slightly* farther locations then
// requested
//
dist *= 1.0000001;
for (size_t i=0, n=coords.size(); i<n; ++i)
{
const Coordinate& c = coords[i];
auto_ptr<Geometry> pg(gf.createPoint(c));
double rdist = g->distance(pg.get());
if ( rdist > dist )
{
return false;
}
}
return true;
}
group test_dpsimp_group("geos::simplify::DouglasPeuckerSimplifier");
//
// Test Cases
//
// 1 - PolygonNoReduction
template<>
template<>
void object::test<1>()
{
std::string wkt("POLYGON((20 220, 40 220, 60 220, 80 220, 100 220, \
120 220, 140 220, 140 180, 100 180, 60 180, 20 180, 20 220))");
GeomPtr g(wktreader.read(wkt));
GeomPtr simplified = DouglasPeuckerSimplifier::simplify(
g.get(), 10.0);
ensure( simplified->isValid() );
// topology is unchanged
ensure( simplified->equals(g.get()) );
}
// 2 - PolygonReductionWithSplit
template<>
template<>
void object::test<2>()
{
group test_tpsimp_group("geos::simplify::TopologyPreservingSimplifier");
//
// Test Cases
//
// PolygonNoReduction
template<>
template<>
void object::test<1>()
{
std::string wkt("POLYGON((20 220, 40 220, 60 220, 80 220, \
100 220, 120 220, 140 220, 140 180, 100 180, \
60 180, 20 180, 20 220))");
GeomPtr g(wktreader.read(wkt));
GeomPtr simplified = TopologyPreservingSimplifier::simplify(g.get(), 10.0);
ensure( "Simplified geometry is invalid!", simplified->isValid() );
ensure( "Simplified and original geometry inequal", simplified->equals(g.get()) );
ensure_equals_geometry( g.get(), simplified.get() );
}
// PolygonNoReductionWithConflicts
template<>
template<>
void object::test<2>()
{
std::string wkt("POLYGON ((40 240, 160 241, 280 240, 280 160, \
160 240, 40 140, 40 240))");
void runIsSequenced(const std::string& inputWKT, bool exp)
{
GeomPtr g = readWKT(inputWKT);
bool isSequenced = LineSequencer::isSequenced(g.get());
ensure_equals( isSequenced, exp );
}
/*public*/
std::unique_ptr<geom::Geometry>
UnaryUnionOp::Union()
{
using geom::Puntal;
typedef std::unique_ptr<geom::Geometry> GeomPtr;
GeomPtr ret;
if(! geomFact) {
return ret;
}
/**
* For points and lines, only a single union operation is
* required, since the OGC model allowings self-intersecting
* MultiPoint and MultiLineStrings.
* This is not the case for polygons, so Cascaded Union is required.
*/
GeomPtr unionPoints;
if(!points.empty()) {
GeomPtr ptGeom = geomFact->buildGeometry(points.begin(),
points.end());
unionPoints = unionNoOpt(*ptGeom);
}
GeomPtr unionLines;
if(!lines.empty()) {
/* JTS compatibility NOTE:
* we use cascaded here for robustness [1]
* but also add a final unionNoOpt step to deal with
* self-intersecting lines [2]
*
* [1](http://trac.osgeo.org/geos/ticket/392
* [2](http://trac.osgeo.org/geos/ticket/482
*
*/
unionLines.reset(CascadedUnion::Union(lines.begin(),
lines.end()));
if(unionLines.get()) {
unionLines = unionNoOpt(*unionLines);
}
}
GeomPtr unionPolygons;
if(!polygons.empty()) {
unionPolygons.reset(CascadedPolygonUnion::Union(polygons.begin(),
polygons.end()));
}
/**
* Performing two unions is somewhat inefficient,
* but is mitigated by unioning lines and points first
*/
GeomPtr unionLA = unionWithNull(std::move(unionLines), std::move(unionPolygons));
assert(!unionLines.get());
assert(!unionPolygons.get());
if(! unionPoints.get()) {
ret = std::move(unionLA);
assert(!unionLA.get());
}
else if(! unionLA.get()) {
ret = std::move(unionPoints);
assert(!unionPoints.get());
}
else {
Puntal& up = dynamic_cast<Puntal&>(*unionPoints);
ret = PointGeometryUnion::Union(up, *unionLA);
}
if(! ret.get()) {
ret.reset(geomFact->createGeometryCollection());
}
return ret;
}
