geometryfactorytest.cpp

在Linux下做的QuadTree的程序

		ensure( col->getCentroid() == 0 );
		ensure_equals( col->getGeometryTypeId(), geos::geom::GEOS_GEOMETRYCOLLECTION );
		ensure_equals( col->getDimension(), geos::geom::Dimension::False );
		ensure_equals( col->getBoundaryDimension(), geos::geom::Dimension::False );
		ensure_equals( col->getNumPoints(), 0u );
		ensure_equals( col->getLength(), 0.0 );
		ensure_equals( col->getArea(), 0.0 );

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

	// Test of createGeometryCollection(std::vector<Geometry*>* newGeoms) const
	template<>
	template<>
	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);
	}

	// Test of createGeometryCollection(const std::vector<Geometry*>& newGeoms) const
	template<>
	template<>
	void object::test<23>()
	{
		const std::size_t size = 3;
		geos::geom::Coordinate coord(x_, y_, z_);

		std::vector<GeometryPtr> vec;

		GeometryPtr geo = 0;
		geo = factory_.createPoint(coord);
		vec.push_back(geo);

		coord.x *= 2;
		coord.y *= 2;
		coord.z *= 2;
		geo = factory_.createPoint(coord);
		vec.push_back(geo);

		coord.x *= 3;
		coord.y *= 3;
		coord.z *= 3;
		geo = factory_.createPoint(coord);
		vec.push_back(geo);

		// Factory creates copy of the vec collection
		GeometryColPtr col = factory_.createGeometryCollection(vec);
		ensure( col != 0 );
		ensure_equals( col->getGeometryTypeId() , geos::geom::GEOS_GEOMETRYCOLLECTION );
		ensure_equals( col->getNumGeometries() , size );

		// FREE MEMORY
		factory_.destroyGeometry(col);
		std::vector<GeometryPtr>::const_iterator it;
		for (it = vec.begin(); it != vec.end(); ++it)
		{
			delete (*it);
		}
	}

	// Test of createMultiPoint() const
	template<>
	template<>
	void object::test<24>()
	{
		MultiPointPtr mp = factory_.createMultiPoint();

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

		GeometryPtr geo = 0;

		// TODO - mloskot - waiting for resolution
		// http://geos.refractions.net/pipermail/geos-devel/2006-March/002011.html
		//geo = poly->getEnvelope();
		//ensure( geo != 0 );
		//ensure( geo->isEmpty() );
		//factory_.destroyGeometry(geo);

		geo = mp->getBoundary();
		ensure( geo != 0 );
		ensure( geo->isEmpty() );
		factory_.destroyGeometry(geo);

		geo = mp->convexHull();
		ensure( geo != 0 );
		ensure( geo->isEmpty() );
		factory_.destroyGeometry(geo);

		ensure_equals( mp->getGeometryTypeId(), geos::geom::GEOS_MULTIPOINT );
		ensure_equals( mp->getDimension(), geos::geom::Dimension::P );
		ensure_equals( mp->getBoundaryDimension(), geos::geom::Dimension::False );
		ensure_equals( mp->getNumPoints(), 0u );
		ensure_equals( mp->getLength(), 0.0 );
		ensure_equals( mp->getArea(), 0.0 );

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

	// Test of createMultiPoint(std::vector<Geometry*>* newPoints) const
	template<>
	template<>
	void object::test<25>()
	{
		const std::size_t size = 3;
		geos::geom::Coordinate coord(x_, y_, z_);

		std::vector<GeometryPtr>* vec = new std::vector<GeometryPtr>();

		GeometryPtr geo = 0;
		geo = factory_.createPoint(coord);
		ensure( geo != 0 );
		vec->push_back(geo);

		coord.x *= 2;
		coord.y *= 2;
		coord.z *= 2;
		geo = factory_.createPoint(coord);
		ensure( geo != 0 );
		vec->push_back(geo);

		coord.x *= 3;
		coord.y *= 3;
		coord.z *= 3;
		geo = factory_.createPoint(coord);
		ensure( geo != 0 );
		vec->push_back(geo);

		// Factory creates copy of the vec collection
		MultiPointPtr mp = factory_.createMultiPoint(vec);
		ensure( mp != 0 );
		ensure( mp->isValid() );
		ensure( mp->isSimple() );
		ensure_equals( mp->getNumGeometries(), size );
		ensure_equals( mp->getGeometryTypeId(), geos::geom::GEOS_MULTIPOINT );

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

	// Test of createMultiPoint(const std::vector<Geometry*>& fromPoints) const
	template<>
	template<>
	void object::test<26>()
	{
		const std::size_t size = 3;
		geos::geom::Coordinate coord(x_, y_, z_);

		std::vector<GeometryPtr> vec;

		GeometryPtr geo = 0;
		geo = factory_.createPoint(coord);
		vec.push_back(geo);

		coord.x *= 2;
		coord.y *= 2;
		coord.z *= 2;
		geo = factory_.createPoint(coord);
		vec.push_back(geo);

		coord.x *= 3;
		coord.y *= 3;
		coord.z *= 3;
		geo = factory_.createPoint(coord);
		vec.push_back(geo);

		// Factory creates copy of the vec collection
		MultiPointPtr mp = factory_.createMultiPoint(vec);
		ensure( mp != 0 );
		ensure( mp->isValid() );
		ensure( mp->isSimple() );
		ensure_equals( mp->getNumGeometries(), size );
		ensure_equals( mp->getGeometryTypeId(), geos::geom::GEOS_MULTIPOINT );

		// FREE MEMORY
		factory_.destroyGeometry(mp);
		std::vector<GeometryPtr>::const_iterator it;
		for (it = vec.begin(); it != vec.end(); ++it)
		{
			delete (*it);
		}
	}

	// Test of createMultiPoint(const CoordinateSequence& fromCoords) const
	template<>
	template<>
	void object::test<27>()
	{
		using geos::geom::Coordinate;
		const std::size_t size = 3;

		// Add collection of coordinates
		geos::geom::CoordinateArraySequence coords(size);
		coords.setAt(Coordinate(0, 0), 0);
		coords.setAt(Coordinate(5, 5), 1);
		coords.setAt(Coordinate(10, 5), 2);
		ensure_equals( coords.getSize(), size );

		MultiPointPtr mp = factory_.createMultiPoint(coords);
		ensure( mp != 0 );
		ensure( mp->isValid() );
		ensure( mp->isSimple() );
		ensure_equals( mp->getNumGeometries(), size );
		ensure_equals( mp->getGeometryTypeId(), geos::geom::GEOS_MULTIPOINT );
		
		// FREE MEMORY
		factory_.destroyGeometry(mp);
	}

	// Test of createMultiLineString() const
	template<>
	template<>
	void object::test<28>()
	{
		MultiLineStringPtr mls = factory_.createMultiLineString();

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

		GeometryPtr geo = 0;

		// TODO - mloskot - waiting for resolution
		// http://geos.refractions.net/pipermail/geos-devel/2006-March/002011.html
		//geo = poly->getEnvelope();
		//ensure( geo != 0 );
		//ensure( geo->isEmpty() );
		//factory_.destroyGeometry(geo);

		geo = mls->getBoundary();
		ensure( geo != 0 );
		ensure( geo->isEmpty() );
		factory_.destroyGeometry(geo);

		geo = mls->convexHull();
		ensure( geo != 0 );
		ensure( geo->isEmpty() );
		factory_.destroyGeometry(geo);

		ensure_equals( mls->getGeometryTypeId(), geos::geom::GEOS_MULTILINESTRING );
		ensure_equals( mls->getDimension(), geos::geom::Dimension::L );
		ensure_equals( mls->getBoundaryDimension(), geos::geom::Dimension::P );
		ensure_equals( mls->getNumPoints(), 0u );
		ensure_equals( mls->getLength(), 0.0 );
		ensure_equals( mls->getArea(), 0.0 );

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

	// Test of createMultiLineString(std::vector<Geometry*>* newLines) const
	template<>
	template<>
	void object::test<29>()
	{
		using geos::geom::Coordinate;
		
		const std::size_t size = 5;
		const std::size_t lineSize = 2;

		std::vector<GeometryPtr>* lines = new std::vector<GeometryPtr>();

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

	// Test of createMultiLineString(const std::vector<Geometry*>& fromLines) const
	template<>
	template<>
	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);
		}
	}

	// Test of createMultiPolygon() const
	template<>
	template<>
	void object::test<31>()
	{
		// TODO - mloskot
		//inform("Test not implemented!");
	}

	// Test of createMultiPolygon(std::vector<Geometry>* newPolys) const
	template<>
	template<>
	void object::test<32>()
	{
		// TODO - mloskot
		//inform("Test not implemented!");
	}

	// Test of createMultiPolygon(const std::vector<Geometry*>& fromPolys) const
	template<>
	template<>
	void object::test<33>()
	{
		// TODO - mloskot
		//inform("Test not implemented!");
	}

	// Test of buildGeometry(std::vector<Geometry*>* geoms) const
	template<>
	template<>
	void object::test<34>()
	{
		// TODO - mloskot
		//inform("Test not implemented!");
	}

	// Test of buildGeometry(const std::vector<Geometry*>& geoms)
	template<>
	template<>
	void object::test<35>()
	{
		// TODO - mloskot
		//inform("Test not implemented!");
	}

} // namespace tut