geometryfactorytest.cpp

在Linux下做的QuadTree的程序

// $Id: GeometryFactoryTest.cpp 2040 2007-12-13 16:09:25Z mloskot $
// 
// Test Suite for geos::geom::GeometryFactory class.

// TUT
#include <tut.h>
// GEOS
#include <geos/geom/GeometryFactory.h>
#include <geos/geom/GeometryCollection.h>
#include <geos/geom/Coordinate.h>
#include <geos/geom/CoordinateArraySequence.h>
#include <geos/geom/CoordinateArraySequenceFactory.h>
#include <geos/geom/CoordinateSequenceFactory.h>
#include <geos/geom/Dimension.h>
#include <geos/geom/LinearRing.h>
#include <geos/geom/LineString.h>
#include <geos/geom/MultiPoint.h>
#include <geos/geom/MultiLineString.h>
#include <geos/geom/MultiPolygon.h>
#include <geos/geom/Point.h>
#include <geos/geom/Polygon.h>
#include <geos/geom/PrecisionModel.h>
#include <geos/io/WKTReader.h>
#include <geos/util/IllegalArgumentException.h>
// STL
#include <vector>
#include <cstring> // std::size_t

/*!
 * \brief
 * Write brief comment for tut here.
 * 
 * Write detailed description for tut here.
 * 
 * \remarks
 * Write remarks for tut here.
 * 
 * \see
 * Separate items with the '|' character.
 */
namespace tut
{
	//
	// Test Group
	//

	// Common data used by tests
	struct test_geometryfactory_data
	{
		// Typedefs used as short names by test cases

		typedef geos::geom::Coordinate* CoordinatePtr;
		typedef geos::geom::Coordinate const* CoordinateCPtr;

		typedef geos::geom::CoordinateArraySequence* CoordArrayPtr;
		typedef geos::geom::CoordinateArraySequence const* CoordArrayCPtr;
		
		typedef geos::geom::Geometry* GeometryPtr;
		typedef geos::geom::Geometry const* GeometryCPtr;

		typedef geos::geom::Point* PointPtr;
		typedef geos::geom::Point const* PointCPtr;
		typedef geos::geom::LinearRing* LinearRingPtr;
		typedef geos::geom::LinearRing const* LinearRingCPtr;
		typedef geos::geom::LineString* LineStringPtr;
		typedef geos::geom::LineString const* LineStringCPtr;
		typedef geos::geom::Polygon* PolygonPtr;
		typedef geos::geom::Polygon const* PolygonCPtr;

		typedef geos::geom::GeometryCollection* GeometryColPtr;
		typedef geos::geom::GeometryCollection const* GeometryColCPtr;

		typedef geos::geom::MultiPoint* MultiPointPtr;
		typedef geos::geom::MultiPoint const* MultiPointCPtr;
		typedef geos::geom::MultiLineString* MultiLineStringPtr;
		typedef geos::geom::MultiLineString const* MultiLineStringCPtr;
		typedef geos::geom::MultiPolygon* MultiPolygonPtr;
		typedef geos::geom::MultiPolygon const* MultiPolygonCPtr;

		// Test data
		const int x_;
		const int y_;
		const int z_;

		const int srid_;
		geos::geom::PrecisionModel pm_;
		geos::geom::GeometryFactory factory_;
		geos::io::WKTReader reader_;

		test_geometryfactory_data()
			: x_(5), y_(10), z_(15), srid_(666), pm_(1.0), factory_(&pm_, srid_), reader_(&factory_)
		{}
	};

	typedef test_group<test_geometryfactory_data> group;
	typedef group::object object;

	group test_geometryfactory_group("geos::geom::GeometryFactory");

	//
	// Test Cases
	//

	// Test of default constructor
	template<>
	template<>
	void object::test<1>()
	{
		geos::geom::GeometryFactory gf;

		ensure_equals( gf.getSRID(), 0 );
		ensure_equals( gf.getPrecisionModel()->getType(), geos::geom::PrecisionModel::FLOATING );

		geos::geom::Geometry* geo = gf.createEmptyGeometry();
		ensure( "createEmptyGeometry() returned null pointer.", geo != 0 );
		ensure_equals( geo->getSRID() , gf.getSRID() );
		ensure_equals( geo->getPrecisionModel()->getType(), geos::geom::PrecisionModel::FLOATING );
		
		// FREE MEMORY
		gf.destroyGeometry(geo);
	}

	// Test of user's constructor
	template<>
	template<>
	void object::test<2>()
	{
		using geos::geom::GeometryFactory;
		using geos::geom::PrecisionModel;
		using geos::geom::CoordinateArraySequenceFactory;

		CoordinateArraySequenceFactory csf;

		{
			PrecisionModel pm(1.0);
			GeometryFactory gf(&pm, srid_, &csf);

			ensure_equals( gf.getSRID(), srid_ );
			ensure_equals( gf.getPrecisionModel()->getType(), geos::geom::PrecisionModel::FIXED );

			ensure_equals( &csf, gf.getCoordinateSequenceFactory() );

			GeometryPtr geo = gf.createEmptyGeometry();
			ensure( "createEmptyGeometry() returned null pointer.", geo != 0 );
			ensure_equals( geo->getSRID() , gf.getSRID() );
			ensure_equals( geo->getPrecisionModel()->getType(), geos::geom::PrecisionModel::FIXED );
			
			// FREE MEMORY
			gf.destroyGeometry(geo);
		}
		// csf lifetime must exceed lifetime of the GeometryFactory instance

	} // test<2>

	// Test of user's constructor
	template<>
	template<>
	void object::test<3>()
	{
		using geos::geom::GeometryFactory;
		using geos::geom::CoordinateArraySequenceFactory;

		CoordinateArraySequenceFactory csf;

		{
			GeometryFactory gf(&csf);

			ensure_equals( gf.getSRID(), 0 );
			ensure_equals( gf.getPrecisionModel()->getType(), geos::geom::PrecisionModel::FLOATING );

			GeometryPtr geo = gf.createEmptyGeometry();
			ensure( "createEmptyGeometry() returned null pointer.", geo != 0 );
			ensure_equals( geo->getSRID() , gf.getSRID() );
			ensure_equals( geo->getPrecisionModel()->getType(), geos::geom::PrecisionModel::FLOATING );
			
			// FREE MEMORY
			gf.destroyGeometry(geo);
		}
		// csf lifetime must exceed lifetime of the GeometryFactory instance
	}

	// Test of user's constructor
	template<>
	template<>
	void object::test<4>()
	{
		using geos::geom::PrecisionModel;

		PrecisionModel pm(PrecisionModel::FIXED);
		geos::geom::GeometryFactory gf(&pm);

		ensure_equals( gf.getSRID(), 0 );
		ensure_equals( gf.getPrecisionModel()->getType(), PrecisionModel::FIXED );

		GeometryPtr geo = gf.createEmptyGeometry();
		ensure( "createEmptyGeometry() returned null pointer.", geo != 0 );
		ensure_equals( geo->getSRID() , gf.getSRID() );
		ensure_equals( geo->getPrecisionModel()->getType(), PrecisionModel::FIXED );
		
		// FREE MEMORY
		gf.destroyGeometry(geo);
	}

	// Test of user's constructor
	template<>
	template<>
	void object::test<5>()
	{
		using geos::geom::PrecisionModel;

		PrecisionModel pm(PrecisionModel::FIXED);
		geos::geom::GeometryFactory gf(&pm, srid_);

		ensure_equals( gf.getSRID(), srid_ );
		ensure_equals( gf.getPrecisionModel()->getType(), PrecisionModel::FIXED );

		GeometryPtr geo = gf.createEmptyGeometry();
		ensure( "createEmptyGeometry() returned null pointer.", geo != 0 );
		ensure_equals( geo->getSRID() , gf.getSRID() );
		ensure_equals( geo->getPrecisionModel()->getType(), PrecisionModel::FIXED );
		
		// FREE MEMORY
		gf.destroyGeometry(geo);
	}

	// Test of copy constructor
	template<>
	template<>
	void object::test<6>()
	{
		geos::geom::GeometryFactory gf(factory_);

		ensure_equals( factory_.getSRID(), gf.getSRID() );
		ensure_equals( factory_.getPrecisionModel()->getType(), gf.getPrecisionModel()->getType() );
	}

	// Test of createEmptyGeometry() const
	template<>
	template<>
	void object::test<7>()
	{
		GeometryPtr geo = factory_.createEmptyGeometry();

		ensure( "createEmptyGeometry() returned null pointer.", geo != 0 );
		ensure( "createEmptyGeometry() returned non-empty geometry.", geo->isEmpty() );

		// TODO - mloskot
		// http://geos.refractions.net/pipermail/geos-devel/2006-March/001960.html
		/*		
		ensure( geo->isSimple() );
		ensure( geo->isValid() );

		ensure( geo->getCentroid() == 0 );
		ensure( geo->getCoordinate() == 0 );
		*/

		// FREE MEMORY
		factory_.destroyGeometry(geo);
	}

	// Test of createPoint() const
	template<>
	template<>
	void object::test<8>()
	{
		PointPtr pt = factory_.createPoint();

		ensure( "createPoint() returned null pointer.", pt != 0 );
		ensure( "createPoint() returned non-empty point.", pt->isEmpty() );
		ensure( pt->isSimple() );
		ensure( pt->isValid() );
		ensure( pt->getCentroid() == 0 );
		ensure( pt->getCoordinate() == 0 );

		GeometryPtr geo = 0;
		geo = pt->getEnvelope();
		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(), 0u );	
		ensure_equals( pt->getLength(), 0.0 );
		ensure_equals( pt->getArea(), 0.0 );

		// FREE MEMORY
		factory_.destroyGeometry(pt);
	}

	// Test of createPoint(const Coordinate &coordinate) const
	template<>
	template<>
	void object::test<9>()
	{
		geos::geom::Coordinate coord(x_, y_, z_);

		PointPtr pt = factory_.createPoint(coord);

		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);
	}

	// Test of createPoint(CoordinateSequence *coordinates) const
	template<>
	template<>
	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);
	}

	// Test of createPoint(const CoordinateSequence &coordinates) const
	template<>
	template<>
	void object::test<11>()
	{
		geos::geom::Coordinate coord(x_, y_, z_);

		geos::geom::CoordinateArraySequence sequence;
		sequence.add(coord);