int kml2tessellate_rec (
GeometryPtr poKmlGeometry,
int *pnTessellate )
{
LineStringPtr poKmlLineString;
PolygonPtr poKmlPolygon;
MultiGeometryPtr poKmlMultiGeometry;
size_t nGeom;
size_t i;
switch ( poKmlGeometry->Type ( ) ) {
case kmldom::Type_Point:
break;
case kmldom::Type_LineString:
poKmlLineString = AsLineString ( poKmlGeometry );
if ( poKmlLineString->has_tessellate ( ) ) {
*pnTessellate = poKmlLineString->get_tessellate ( );
return TRUE;
}
break;
case kmldom::Type_LinearRing:
break;
case kmldom::Type_Polygon:
poKmlPolygon = AsPolygon ( poKmlGeometry );
if ( poKmlPolygon->has_tessellate ( ) ) {
*pnTessellate = poKmlPolygon->get_tessellate ( );
return TRUE;
}
break;
case kmldom::Type_MultiGeometry:
poKmlMultiGeometry = AsMultiGeometry ( poKmlGeometry );
nGeom = poKmlMultiGeometry->get_geometry_array_size ( );
for ( i = 0; i < nGeom; i++ ) {
if ( kml2tessellate_rec ( poKmlMultiGeometry->
get_geometry_array_at ( i ),
pnTessellate ) )
return TRUE;
}
break;
default:
break;
}
return FALSE;
}
void ogr2tessellate_rec (
int nTessellate,
GeometryPtr poKmlGeometry )
{
LineStringPtr poKmlLineString;
PolygonPtr poKmlPolygon;
MultiGeometryPtr poKmlMultiGeometry;
size_t nGeom;
size_t i;
switch ( poKmlGeometry->Type ( ) ) {
case kmldom::Type_Point:
break;
case kmldom::Type_LineString:
poKmlLineString = AsLineString ( poKmlGeometry );
poKmlLineString->set_tessellate ( nTessellate );
break;
case kmldom::Type_LinearRing:
break;
case kmldom::Type_Polygon:
poKmlPolygon = AsPolygon ( poKmlGeometry );
poKmlPolygon->set_tessellate ( nTessellate );
break;
case kmldom::Type_MultiGeometry:
poKmlMultiGeometry = AsMultiGeometry ( poKmlGeometry );
nGeom = poKmlMultiGeometry->get_geometry_array_size ( );
for ( i = 0; i < nGeom; i++ ) {
ogr2tessellate_rec ( nTessellate,
poKmlMultiGeometry->
get_geometry_array_at ( i ) );
}
break;
default:
break;
}
}
void object::test<30>()
{
const size_t holesNum = 1;
GeometryPtr geo = nullptr;
geo = reader_.read("POLYGON ((0 0, 100 0, 100 100, 0 100, 0 0), (1 1, 1 10, 10 10, 10 1, 1 1) )");
ensure( geo != nullptr );
ensure_equals( geo->getGeometryTypeId(), geos::geom::GEOS_POLYGON );
PolygonPtr poly = dynamic_cast<PolygonPtr>(geo);
ensure( poly != nullptr );
ensure_equals( poly->getNumInteriorRing(), holesNum );
LineStringCPtr interior = poly->getInteriorRingN(0);
ensure( interior != nullptr );
ensure( interior->isRing() );
ensure_equals( interior->getGeometryTypeId(), geos::geom::GEOS_LINEARRING );
factory_->destroyGeometry(geo);
}
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);
}
void object::test<18>()
{
PolygonPtr poly = factory_.createPolygon();
ensure( "createPolygon() returned null pointer.", poly != 0 );
ensure( "createPolygon() returned non-empty point.", poly->isEmpty() );
ensure( poly->isSimple() );
ensure( poly->isValid() );
ensure( poly->getCentroid() == 0 );
// TODO - mloskot - waiting for some decision
// http://geos.refractions.net/pipermail/geos-devel/2006-March/002006.html
//ensure( poly->getCoordinate() == 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 = poly->getBoundary();
ensure( geo != 0 );
ensure( geo->isEmpty() );
factory_.destroyGeometry(geo);
geo = poly->convexHull();
ensure( geo != 0 );
ensure( geo->isEmpty() );
factory_.destroyGeometry(geo);
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(), 0u );
ensure_equals( poly->getLength(), 0.0 );
ensure_equals( poly->getArea(), 0.0 );
// FREE MEMORY
factory_.destroyGeometry(poly);
}
static OGRGeometry *kml2geom_rec (
GeometryPtr poKmlGeometry,
OGRSpatialReference *poOgrSRS)
{
/***** ogr geom vars *****/
OGRPoint *poOgrPoint;
OGRLineString *poOgrLineString;
OGRLinearRing *poOgrLinearRing;
OGRPolygon *poOgrPolygon;
OGRGeometryCollection *poOgrMultiGeometry;
OGRGeometry *poOgrGeometry = NULL;
OGRGeometry *poOgrTmpGeometry = NULL;
/***** libkml geom vars *****/
CoordinatesPtr poKmlCoordinates;
PointPtr poKmlPoint;
LineStringPtr poKmlLineString;
LinearRingPtr poKmlLinearRing;
OuterBoundaryIsPtr poKmlOuterRing;
InnerBoundaryIsPtr poKmlInnerRing;
PolygonPtr poKmlPolygon;
MultiGeometryPtr poKmlMultiGeometry;
GxTrackPtr poKmlGxTrack;
GxMultiTrackPtr poKmlGxMultiTrack;
GeometryPtr poKmlTmpGeometry;
Vec3 oKmlVec;
size_t nRings,
nCoords,
nGeom,
i;
switch ( poKmlGeometry->Type ( ) ) {
case kmldom::Type_Point:
poKmlPoint = AsPoint ( poKmlGeometry );
if ( poKmlPoint->has_coordinates ( ) ) {
poKmlCoordinates = poKmlPoint->get_coordinates ( );
nCoords = poKmlCoordinates->get_coordinates_array_size ( );
if (nCoords > 0)
{
oKmlVec = poKmlCoordinates->get_coordinates_array_at ( 0 );
if ( oKmlVec.has_altitude ( ) )
poOgrPoint = new OGRPoint ( oKmlVec.get_longitude ( ),
oKmlVec.get_latitude ( ),
oKmlVec.get_altitude ( ) );
else
poOgrPoint = new OGRPoint ( oKmlVec.get_longitude ( ),
oKmlVec.get_latitude ( ) );
poOgrGeometry = poOgrPoint;
}
else
{
poOgrGeometry = new OGRPoint();
}
}
else
{
poOgrGeometry = new OGRPoint();
}
break;
case kmldom::Type_LineString:
poKmlLineString = AsLineString ( poKmlGeometry );
poOgrLineString = new OGRLineString ( );
if ( poKmlLineString->has_coordinates ( ) ) {
poKmlCoordinates = poKmlLineString->get_coordinates ( );
nCoords = poKmlCoordinates->get_coordinates_array_size ( );
for ( i = 0; i < nCoords; i++ ) {
oKmlVec = poKmlCoordinates->get_coordinates_array_at ( i );
if ( oKmlVec.has_altitude ( ) )
poOgrLineString->
addPoint ( oKmlVec.get_longitude ( ),
oKmlVec.get_latitude ( ),
oKmlVec.get_altitude ( ) );
else
poOgrLineString->
addPoint ( oKmlVec.get_longitude ( ),
oKmlVec.get_latitude ( ) );
}
}
poOgrGeometry = poOgrLineString;
break;
case kmldom::Type_LinearRing:
poKmlLinearRing = AsLinearRing ( poKmlGeometry );
poOgrLinearRing = new OGRLinearRing ( );
if ( poKmlLinearRing->has_coordinates ( ) ) {
poKmlCoordinates = poKmlLinearRing->get_coordinates ( );
nCoords = poKmlCoordinates->get_coordinates_array_size ( );
for ( i = 0; i < nCoords; i++ ) {
oKmlVec = poKmlCoordinates->get_coordinates_array_at ( i );
if ( oKmlVec.has_altitude ( ) )
poOgrLinearRing->
addPoint ( oKmlVec.get_longitude ( ),
oKmlVec.get_latitude ( ),
oKmlVec.get_altitude ( ) );
else
poOgrLinearRing->
addPoint ( oKmlVec.get_longitude ( ),
oKmlVec.get_latitude ( ) );
}
}
poOgrGeometry = poOgrLinearRing;
break;
case kmldom::Type_Polygon:
poKmlPolygon = AsPolygon ( poKmlGeometry );
poOgrPolygon = new OGRPolygon ( );
if ( poKmlPolygon->has_outerboundaryis ( ) ) {
poKmlOuterRing = poKmlPolygon->get_outerboundaryis ( );
poKmlLinearRing = poKmlOuterRing->get_linearring ( );
if (poKmlLinearRing)
{
poOgrTmpGeometry = kml2geom_rec ( poKmlLinearRing, poOgrSRS );
poOgrPolygon->
addRingDirectly ( ( OGRLinearRing * ) poOgrTmpGeometry );
}
}
nRings = poKmlPolygon->get_innerboundaryis_array_size ( );
for ( i = 0; i < nRings; i++ ) {
poKmlInnerRing = poKmlPolygon->get_innerboundaryis_array_at ( i );
poKmlLinearRing = poKmlInnerRing->get_linearring ( );
if (poKmlLinearRing)
{
poOgrTmpGeometry = kml2geom_rec ( poKmlLinearRing, poOgrSRS );
poOgrPolygon->
addRingDirectly ( ( OGRLinearRing * ) poOgrTmpGeometry );
}
}
poOgrGeometry = poOgrPolygon;
break;
case kmldom::Type_MultiGeometry:
{
poKmlMultiGeometry = AsMultiGeometry ( poKmlGeometry );
nGeom = poKmlMultiGeometry->get_geometry_array_size ( );
// Detect subgeometry type to instantiate appropriate
// multi geometry type.
kmldom::KmlDomType type = kmldom::Type_Unknown;
for ( i = 0; i < nGeom; i++ ) {
poKmlTmpGeometry = poKmlMultiGeometry->get_geometry_array_at ( i );
if (type == kmldom::Type_Unknown)
type = poKmlTmpGeometry->Type();
else if (type != poKmlTmpGeometry->Type())
{
type = kmldom::Type_Unknown;
break;
}
}
if (type == kmldom::Type_Point)
poOgrMultiGeometry = new OGRMultiPoint();
else if (type == kmldom::Type_LineString)
poOgrMultiGeometry = new OGRMultiLineString();
else if (type == kmldom::Type_Polygon)
poOgrMultiGeometry = new OGRMultiPolygon();
else
poOgrMultiGeometry = new OGRGeometryCollection ();
for ( i = 0; i < nGeom; i++ ) {
poKmlTmpGeometry = poKmlMultiGeometry->get_geometry_array_at ( i );
poOgrTmpGeometry = kml2geom_rec ( poKmlTmpGeometry, poOgrSRS );
poOgrMultiGeometry->addGeometryDirectly ( poOgrTmpGeometry );
}
poOgrGeometry = poOgrMultiGeometry;
break;
}
case kmldom::Type_GxTrack:
poKmlGxTrack = AsGxTrack ( poKmlGeometry );
nCoords = poKmlGxTrack->get_gx_coord_array_size();
poOgrLineString = new OGRLineString ( );
for ( i = 0; i < nCoords; i++ ) {
oKmlVec = poKmlGxTrack->get_gx_coord_array_at ( i );
if ( oKmlVec.has_altitude ( ) )
poOgrLineString->
addPoint ( oKmlVec.get_longitude ( ),
oKmlVec.get_latitude ( ),
oKmlVec.get_altitude ( ) );
else
poOgrLineString->
addPoint ( oKmlVec.get_longitude ( ),
oKmlVec.get_latitude ( ) );
}
poOgrGeometry = poOgrLineString;
break;
case kmldom::Type_GxMultiTrack:
{
poKmlGxMultiTrack = AsGxMultiTrack ( poKmlGeometry );
nGeom = poKmlGxMultiTrack->get_gx_track_array_size ( );
poOgrMultiGeometry = new OGRMultiLineString();
for( size_t j = 0; j < nGeom; j++ )
{
poKmlGxTrack = poKmlGxMultiTrack->get_gx_track_array_at ( j );
nCoords = poKmlGxTrack->get_gx_coord_array_size();
poOgrLineString = new OGRLineString ( );
for ( i = 0; i < nCoords; i++ ) {
oKmlVec = poKmlGxTrack->get_gx_coord_array_at ( i );
if ( oKmlVec.has_altitude ( ) )
poOgrLineString->
addPoint ( oKmlVec.get_longitude ( ),
oKmlVec.get_latitude ( ),
oKmlVec.get_altitude ( ) );
else
poOgrLineString->
addPoint ( oKmlVec.get_longitude ( ),
oKmlVec.get_latitude ( ) );
}
poOgrMultiGeometry->addGeometryDirectly(poOgrLineString);
}
poOgrGeometry = poOgrMultiGeometry;
break;
}
default:
break;
}
if (poOgrGeometry)
poOgrGeometry->assignSpatialReference(poOgrSRS);
return poOgrGeometry;
}
int kml2altitudemode_rec (
GeometryPtr poKmlGeometry,
int *pnAltitudeMode,
int *pbIsGX )
{
PointPtr poKmlPoint;
LineStringPtr poKmlLineString;
PolygonPtr poKmlPolygon;
MultiGeometryPtr poKmlMultiGeometry;
size_t nGeom;
size_t i;
switch ( poKmlGeometry->Type ( ) ) {
case kmldom::Type_Point:
poKmlPoint = AsPoint ( poKmlGeometry );
if ( poKmlPoint->has_altitudemode ( ) ) {
*pnAltitudeMode = poKmlPoint->get_altitudemode ( );
return TRUE;
}
else if ( poKmlPoint->has_gx_altitudemode ( ) ) {
*pnAltitudeMode = poKmlPoint->get_gx_altitudemode ( );
*pbIsGX = TRUE;
return TRUE;
}
break;
case kmldom::Type_LineString:
poKmlLineString = AsLineString ( poKmlGeometry );
if ( poKmlLineString->has_altitudemode ( ) ) {
*pnAltitudeMode = poKmlLineString->get_altitudemode ( );
return TRUE;
}
else if ( poKmlLineString->has_gx_altitudemode ( ) ) {
*pnAltitudeMode = poKmlLineString->get_gx_altitudemode ( );
*pbIsGX = TRUE;
return TRUE;
}
break;
case kmldom::Type_LinearRing:
break;
case kmldom::Type_Polygon:
poKmlPolygon = AsPolygon ( poKmlGeometry );
if ( poKmlPolygon->has_altitudemode ( ) ) {
*pnAltitudeMode = poKmlPolygon->get_altitudemode ( );
return TRUE;
}
else if ( poKmlPolygon->has_gx_altitudemode ( ) ) {
*pnAltitudeMode = poKmlPolygon->get_gx_altitudemode ( );
*pbIsGX = TRUE;
return TRUE;
}
break;
case kmldom::Type_MultiGeometry:
poKmlMultiGeometry = AsMultiGeometry ( poKmlGeometry );
nGeom = poKmlMultiGeometry->get_geometry_array_size ( );
for ( i = 0; i < nGeom; i++ ) {
if ( kml2altitudemode_rec ( poKmlMultiGeometry->
get_geometry_array_at ( i ),
pnAltitudeMode, pbIsGX ) )
return TRUE;
}
break;
default:
break;
}
return FALSE;
}
void ogr2altitudemode_rec (
GeometryPtr poKmlGeometry,
int iAltitudeMode,
int isGX )
{
PointPtr poKmlPoint;
LineStringPtr poKmlLineString;
PolygonPtr poKmlPolygon;
MultiGeometryPtr poKmlMultiGeometry;
size_t nGeom;
size_t i;
switch ( poKmlGeometry->Type ( ) ) {
case kmldom::Type_Point:
poKmlPoint = AsPoint ( poKmlGeometry );
if ( !isGX )
poKmlPoint->set_altitudemode ( iAltitudeMode );
else
poKmlPoint->set_gx_altitudemode ( iAltitudeMode );
break;
case kmldom::Type_LineString:
poKmlLineString = AsLineString ( poKmlGeometry );
if ( !isGX )
poKmlLineString->set_altitudemode ( iAltitudeMode );
else
poKmlLineString->set_gx_altitudemode ( iAltitudeMode );
break;
case kmldom::Type_LinearRing:
break;
case kmldom::Type_Polygon:
poKmlPolygon = AsPolygon ( poKmlGeometry );
if ( !isGX )
poKmlPolygon->set_altitudemode ( iAltitudeMode );
else
poKmlPolygon->set_gx_altitudemode ( iAltitudeMode );
break;
case kmldom::Type_MultiGeometry:
poKmlMultiGeometry = AsMultiGeometry ( poKmlGeometry );
nGeom = poKmlMultiGeometry->get_geometry_array_size ( );
for ( i = 0; i < nGeom; i++ ) {
ogr2altitudemode_rec ( poKmlMultiGeometry->
get_geometry_array_at ( i ), iAltitudeMode,
isGX );
}
break;
default:
break;
}
}
