void object::test<22>()
{
using geos::geom::Coordinate;
// Buffer for geometries
std::vector<GeometryPtr>* vec = new std::vector<GeometryPtr>();
// Add single point
Coordinate coord(x_, y_, z_);
GeometryPtr point = factory_.createPoint(coord);
ensure( point != 0 );
vec->push_back(point);
// Add single LineString
CoordArrayPtr coords = new geos::geom::CoordinateArraySequence(3);
ensure( coords != 0 );
coords->setAt(Coordinate(0, 0), 0);
coords->setAt(Coordinate(5, 5), 1);
coords->setAt(Coordinate(10, 5), 2);
ensure_equals( coords->getSize(), 3u );
GeometryPtr line = factory_.createLineString(coords);
vec->push_back(line);
// Create geometry collection
GeometryColPtr col = factory_.createGeometryCollection(vec);
ensure( coords != 0 );
ensure_equals( col->getGeometryTypeId(), geos::geom::GEOS_GEOMETRYCOLLECTION );
ensure_equals( col->getNumGeometries(), 2u );
// FREE MEMORY
factory_.destroyGeometry(col);
}
void object::test<3>()
{
// Single-element sequence of coordiantes
CoordArrayPtr pseq = 0;
try
{
pseq = new geos::geom::CoordinateArraySequence();
ensure( "sequence is null pointer.", pseq != 0 );
pseq->add(geos::geom::Coordinate(0, 0, 0));
ensure_equals( pseq->size(), 1u );
// Create incomplete linstring
LineStringAutoPtr ls(factory_.createLineString(pseq));
fail("IllegalArgumentException expected.");
}
catch (geos::util::IllegalArgumentException const& e)
{
// TODO - mloskot - is waiting for "exception-safety" and bugs resolution
// If removed, memory 3 leaks occur
//delete pseq;
const char* msg = e.what(); // OK
ensure( msg != 0 );
}
}
void object::test<16>()
{
const std::size_t size = 5;
CoordArrayPtr coords = new geos::geom::CoordinateArraySequence(size);
ensure( coords != 0 );
ensure_equals( coords->getSize(), size );
LineStringPtr line = factory_.createLineString(coords);
ensure( "createLineString() returned null pointer.", line != 0 );
ensure( "createLineString() returned empty point.", !line->isEmpty() );
ensure( line->isSimple() );
ensure( line->getCoordinate() != 0 );
// TODO - mloskot - is this correct?
//ensure( line->isValid() );
ensure_equals( line->getGeometryTypeId(), geos::geom::GEOS_LINESTRING );
ensure_equals( line->getDimension(), geos::geom::Dimension::L );
ensure_equals( line->getBoundaryDimension(), geos::geom::Dimension::False );
ensure_equals( line->getNumPoints(), size );
ensure_equals( line->getLength(), 0.0 );
ensure_equals( line->getArea(), 0.0 );
// FREE MEMORY
factory_.destroyGeometry(line);
}
void object::test<10>()
{
geos::geom::Coordinate coord(x_, y_, z_);
CoordArrayPtr sequence = new geos::geom::CoordinateArraySequence();
ensure( "sequence is null pointer.", sequence != 0 );
sequence->add(coord);
PointPtr pt = factory_.createPoint(sequence);
ensure( "createPoint() returned null pointer.", pt != 0 );
ensure( "createPoint() returned empty point.", !pt->isEmpty() );
ensure( pt->isSimple() );
ensure( pt->isValid() );
ensure( pt->getCoordinate() != 0 );
CoordinateCPtr pcoord = pt->getCoordinate();
ensure( pcoord != 0 );
ensure_equals( pcoord->x, x_ );
ensure_equals( pcoord->y, y_ );
ensure_equals( pcoord->z, z_ );
GeometryPtr geo = 0;
geo = pt->getEnvelope();
ensure( geo != 0 );
ensure( !geo->isEmpty() );
factory_.destroyGeometry(geo);
geo = pt->getCentroid();
ensure( geo != 0 );
ensure( !geo->isEmpty() );
factory_.destroyGeometry(geo);
geo = pt->getBoundary();
ensure( geo != 0 );
ensure( geo->isEmpty() );
factory_.destroyGeometry(geo);
geo = pt->convexHull();
ensure( geo != 0 );
ensure( !geo->isEmpty() );
factory_.destroyGeometry(geo);
ensure_equals( pt->getGeometryTypeId(), geos::geom::GEOS_POINT );
ensure_equals( pt->getDimension(), geos::geom::Dimension::P );
ensure_equals( pt->getBoundaryDimension(), geos::geom::Dimension::False );
ensure_equals( pt->getNumPoints(), 1u );
ensure_equals( pt->getLength(), 0.0 );
ensure_equals( pt->getArea(), 0.0 );
// FREE MEMORY
factory_.destroyGeometry(pt);
}
void object::test<4>()
{
using geos::geom::Coordinate;
// Non-empty sequence of coordiantes
const size_t size = 3;
CoordArrayPtr pseq = new geos::geom::CoordinateArraySequence();
ensure( "sequence is null pointer.", pseq != 0 );
pseq->add(Coordinate(0, 0, 0));
pseq->add(Coordinate(5, 5, 5));
pseq->add(Coordinate(10, 10, 10));
ensure_equals( pseq->size(), size );
// Create examplar of linstring instance
LineStringAutoPtr examplar(factory_.createLineString(pseq));
// Create copy
LineStringAutoPtr copy(dynamic_cast<geos::geom::LineString*>(examplar->clone()));
ensure( 0 != copy.get() );
ensure( !copy->isEmpty() );
ensure( copy->isSimple() );
ensure( copy->isValid() );
ensure( !copy->isClosed() );
ensure( !copy->isRing() );
GeometryPtr geo = 0;
geo = copy->getEnvelope();
ensure( geo != 0 );
ensure( !geo->isEmpty() );
factory_.destroyGeometry(geo);
geo = copy->getBoundary();
ensure( geo != 0 );
ensure( !geo->isEmpty() );
factory_.destroyGeometry(geo);
geo = copy->convexHull();
ensure( geo != 0 );
ensure( !geo->isEmpty() );
factory_.destroyGeometry(geo);
ensure_equals( copy->getGeometryTypeId(), geos::geom::GEOS_LINESTRING );
ensure_equals( copy->getDimension(), geos::geom::Dimension::L );
ensure_equals( copy->getBoundaryDimension(), geos::geom::Dimension::P );
ensure_equals( copy->getNumPoints(), size );
ensure_equals( copy->getArea(), 0.0 );
ensure( copy->getLength() != 0.0 );
}
void object::test<2>()
{
using geos::geom::Coordinate;
// Non-empty sequence of coordiantes
const size_t size3 = 3;
CoordArrayPtr pseq = new geos::geom::CoordinateArraySequence();
ensure( "sequence is null pointer.", pseq != 0 );
pseq->add(Coordinate(0, 0, 0));
pseq->add(Coordinate(5, 5, 5));
pseq->add(Coordinate(10, 10, 10));
ensure_equals( pseq->size(), size3 );
// Create non-empty linstring instance
LineStringAutoPtr ls(factory_.createLineString(pseq));
ensure( !ls->isEmpty() );
ensure( ls->isSimple() );
ensure( ls->isValid() );
ensure( !ls->isClosed() );
ensure( !ls->isRing() );
GeometryPtr geo = 0;
geo = ls->getEnvelope();
ensure( geo != 0 );
ensure( !geo->isEmpty() );
factory_.destroyGeometry(geo);
geo = ls->getBoundary();
ensure( geo != 0 );
ensure( !geo->isEmpty() );
factory_.destroyGeometry(geo);
geo = ls->convexHull();
ensure( geo != 0 );
ensure( !geo->isEmpty() );
factory_.destroyGeometry(geo);
ensure_equals( ls->getGeometryTypeId(), geos::geom::GEOS_LINESTRING );
ensure_equals( ls->getDimension(), geos::geom::Dimension::L );
ensure_equals( ls->getBoundaryDimension(), geos::geom::Dimension::P );
ensure_equals( ls->getCoordinateDimension(), 3 );
ensure_equals( ls->getNumPoints(), size3 );
ensure_equals( ls->getArea(), 0.0 );
ensure( ls->getLength() != 0.0 );
}
void object::test<30>()
{
using geos::geom::Coordinate;
const std::size_t size = 5;
const std::size_t lineSize = 2;
std::vector<GeometryPtr> lines;
for (std::size_t i = 0; i < size; ++i)
{
const std::size_t factor = i * i;
CoordArrayPtr coords = new geos::geom::CoordinateArraySequence(lineSize);
ensure( coords != 0 );
coords->setAt(Coordinate(0 + factor, 0 + factor), 0);
coords->setAt(Coordinate(5 + factor, 5 + factor), 1);
ensure_equals( coords->getSize(), lineSize );
LineStringPtr line = factory_.createLineString(coords);
ensure( "createLineString() returned empty point.", !line->isEmpty() );
ensure_equals( line->getNumPoints(), lineSize );
ensure( line->isSimple() );
ensure( line->getCoordinate() != 0 );
ensure_equals( line->getGeometryTypeId(), geos::geom::GEOS_LINESTRING );
lines.push_back(line);
}
MultiLineStringPtr mls = factory_.createMultiLineString(lines);
ensure( mls != 0 );
// TODO - mloskot - why isValid() returns false?
//ensure( mls->isValid() );
ensure_equals( mls->getNumGeometries(), size );
ensure_equals( mls->getGeometryTypeId(), geos::geom::GEOS_MULTILINESTRING );
// FREE MEMORY
factory_.destroyGeometry(mls);
std::vector<GeometryPtr>::const_iterator it;
for (it = lines.begin(); it != lines.end(); ++it)
{
delete (*it);
}
}
void object::test<1>()
{
using geos::geom::Coordinate;
// Create non-empty Coordiantes sequence for Exterior LinearRing
const size_t size = 7;
CoordArrayPtr coords = new geos::geom::CoordinateArraySequence();
ensure( "sequence is null pointer.", coords != nullptr );
coords->add(Coordinate(0, 10));
coords->add(Coordinate(5, 5));
coords->add(Coordinate(10, 5));
coords->add(Coordinate(15, 10));
coords->add(Coordinate(10, 15));
coords->add(Coordinate(5, 15));
coords->add(Coordinate(0, 10));
ensure_equals( coords->size(), size );
try
{
// Create non-empty LinearRing instance
geos::geom::LinearRing ring(coords, factory_.get());
ensure( !ring.isEmpty() );
ensure( ring.isClosed() );
ensure( ring.isRing() );
ensure( ring.isSimple() );
// Exterior (clone is required here because Polygon takes ownership)
GeometryPtr geo = ring.clone();
LinearRingPtr exterior = dynamic_cast<LinearRingPtr>(geo);
// Create non-empty Polygon
//geos::geom::Polygon poly(exterior, 0, &factory_);
PolygonAutoPtr poly(factory_->createPolygon(exterior, nullptr));
ensure( !poly->isEmpty() );
ensure( poly->isSimple() );
ensure( poly->isValid() );
ensure_equals( poly->getNumGeometries(), 1u );
ensure_equals( poly->getNumInteriorRing(), 0u );
ensure_equals( poly->getNumPoints(), size );
}
catch (geos::util::IllegalArgumentException const& e)
{
fail(e.what());
}
}
void object::test<19>()
{
using geos::geom::Coordinate;
const std::size_t size = 7;
// Create sequence of coordiantes
CoordArrayPtr coords = new geos::geom::CoordinateArraySequence(size);
ensure( coords != 0 );
coords->setAt(Coordinate(0, 10), 0);
coords->setAt(Coordinate(5, 5), 1);
coords->setAt(Coordinate(10, 5), 2);
coords->setAt(Coordinate(15, 10), 3);
coords->setAt(Coordinate(10, 15), 4);
coords->setAt(Coordinate(5, 15), 5);
coords->setAt(Coordinate(0, 10), 6);
ensure_equals( coords->getSize(), size );
// Create exterior ring
LinearRingPtr exterior = factory_.createLinearRing(coords);
ensure( "createLinearRing returned null pointer.", exterior != 0 );
ensure( "createLinearRing() returned empty point.", !exterior->isEmpty() );
ensure( exterior->isSimple() );
ensure_equals( exterior->getGeometryTypeId(), geos::geom::GEOS_LINEARRING );
ensure_equals( exterior->getDimension(), geos::geom::Dimension::L );
ensure_equals( exterior->getBoundaryDimension(), geos::geom::Dimension::False );
ensure_equals( exterior->getNumPoints(), size );
ensure_equals( exterior->getArea(), 0.0 );
ensure_not_equals( exterior->getLength(), 0.0 );
// Create polygon
PolygonPtr poly = factory_.createPolygon(exterior, 0);
ensure( "createPolygon returned null pointer.", poly != 0 );
ensure( "createPolygon() returned empty point.", !poly->isEmpty() );
ensure( poly->isSimple() );
ensure_equals( poly->getGeometryTypeId(), geos::geom::GEOS_POLYGON );
ensure_equals( poly->getDimension(), geos::geom::Dimension::A );
ensure_equals( poly->getBoundaryDimension(), geos::geom::Dimension::L );
ensure_equals( poly->getNumPoints(), size );
ensure_not_equals( poly->getArea(), 0.0 );
ensure_not_equals( poly->getLength(), 0.0 );
// FREE MEMORY
factory_.destroyGeometry(poly);
}
void object::test<20>()
{
using geos::geom::Coordinate;
const std::size_t exteriorSize = 7;
const std::size_t interiorSize = 5;
// Create sequence of coordiantes
CoordArrayPtr coords = new geos::geom::CoordinateArraySequence(exteriorSize);
ensure( coords != 0 );
coords->setAt(Coordinate(0, 10), 0);
coords->setAt(Coordinate(5, 5), 1);
coords->setAt(Coordinate(10, 5), 2);
coords->setAt(Coordinate(15, 10), 3);
coords->setAt(Coordinate(10, 15), 4);
coords->setAt(Coordinate(5, 15), 5);
coords->setAt(Coordinate(0, 10), 6);
ensure_equals( coords->getSize(), exteriorSize );
// Create exterior ring
LinearRingPtr exterior = factory_.createLinearRing(coords);
ensure( "createLinearRing returned null pointer.", exterior != 0 );
ensure( "createLinearRing() returned empty point.", !exterior->isEmpty() );
ensure( exterior->isSimple() );
ensure_equals( exterior->getGeometryTypeId(), geos::geom::GEOS_LINEARRING );
ensure_equals( exterior->getDimension(), geos::geom::Dimension::L );
ensure_equals( exterior->getBoundaryDimension(), geos::geom::Dimension::False );
ensure_equals( exterior->getNumPoints(), exteriorSize );
ensure_equals( exterior->getArea(), 0.0 );
ensure_not_equals( exterior->getLength(), 0.0 );
// Create collection of holes
GeometryPtr geo = reader_.read(("LINEARRING(7 7, 12 7, 12 12, 7 12, 7 7)"));
ensure( geo != 0 );
LinearRingPtr hole = static_cast<LinearRingPtr>(geo);
ensure( hole->isRing() );
ensure_equals( hole->getNumPoints(), interiorSize );
// REMEMBER TO DEALLOCATE THIS COLLECTION
std::vector<GeometryPtr> holes;
holes.push_back(hole);
// Create polygon using copy ctor
PolygonPtr poly = factory_.createPolygon((*exterior), holes);
ensure( "createPolygon returned null pointer.", poly != 0 );
ensure( "createPolygon() returned empty point.", !poly->isEmpty() );
ensure( poly->isSimple() );
ensure_equals( poly->getGeometryTypeId(), geos::geom::GEOS_POLYGON );
ensure_equals( poly->getDimension(), geos::geom::Dimension::A );
ensure_equals( poly->getBoundaryDimension(), geos::geom::Dimension::L );
ensure_equals( poly->getNumPoints(), exteriorSize + interiorSize );
ensure_not_equals( poly->getArea(), 0.0 );
ensure_not_equals( poly->getLength(), 0.0 );
ensure_equals( poly->getNumGeometries(), 1u );
ensure_equals( poly->getNumInteriorRing(), 1u );
// FREE MEMORY
std::vector<GeometryPtr>::const_iterator it;
for (it = holes.begin(); it != holes.end(); ++it)
{
delete (*it);
}
holes.clear();
factory_.destroyGeometry(exterior);
factory_.destroyGeometry(poly);
}
