OGRMultiPolygon* OGRILI1Layer::Polygonize( OGRGeometryCollection* poLines, bool fix_crossing_lines )
{
OGRMultiPolygon *poPolygon = new OGRMultiPolygon();
if (poLines->getNumGeometries() == 0) return poPolygon;
#if defined(HAVE_GEOS)
GEOSGeom *ahInGeoms = NULL;
int i = 0;
OGRGeometryCollection *poNoncrossingLines = poLines;
GEOSGeom hResultGeom = NULL;
OGRGeometry *poMP = NULL;
if (fix_crossing_lines && poLines->getNumGeometries() > 0)
{
CPLDebug( "OGR_ILI", "Fixing crossing lines");
//A union of the geometry collection with one line fixes invalid geometries
poNoncrossingLines = (OGRGeometryCollection*)poLines->Union(poLines->getGeometryRef(0));
CPLDebug( "OGR_ILI", "Fixed lines: %d", poNoncrossingLines->getNumGeometries()-poLines->getNumGeometries());
}
GEOSContextHandle_t hGEOSCtxt = OGRGeometry::createGEOSContext();
ahInGeoms = (GEOSGeom *) CPLCalloc(sizeof(void*),poNoncrossingLines->getNumGeometries());
for( i = 0; i < poNoncrossingLines->getNumGeometries(); i++ )
ahInGeoms[i] = poNoncrossingLines->getGeometryRef(i)->exportToGEOS(hGEOSCtxt);
hResultGeom = GEOSPolygonize_r( hGEOSCtxt,
ahInGeoms,
poNoncrossingLines->getNumGeometries() );
for( i = 0; i < poNoncrossingLines->getNumGeometries(); i++ )
GEOSGeom_destroy_r( hGEOSCtxt, ahInGeoms[i] );
CPLFree( ahInGeoms );
if (poNoncrossingLines != poLines) delete poNoncrossingLines;
if( hResultGeom == NULL )
{
OGRGeometry::freeGEOSContext( hGEOSCtxt );
return NULL;
}
poMP = OGRGeometryFactory::createFromGEOS( hGEOSCtxt, hResultGeom );
GEOSGeom_destroy_r( hGEOSCtxt, hResultGeom );
OGRGeometry::freeGEOSContext( hGEOSCtxt );
return (OGRMultiPolygon *) poMP;
#endif
return poPolygon;
}
OGRGeometry *OGRGeometryFactory::forceToMultiPolygon( OGRGeometry *poGeom )
{
if( poGeom == NULL )
return NULL;
/* -------------------------------------------------------------------- */
/* Check for the case of a geometrycollection that can be */
/* promoted to MultiPolygon. */
/* -------------------------------------------------------------------- */
if( wkbFlatten(poGeom->getGeometryType()) == wkbGeometryCollection )
{
int iGeom;
int bAllPoly = TRUE;
OGRGeometryCollection *poGC = (OGRGeometryCollection *) poGeom;
for( iGeom = 0; iGeom < poGC->getNumGeometries(); iGeom++ )
{
if( wkbFlatten(poGC->getGeometryRef(iGeom)->getGeometryType())
!= wkbPolygon )
bAllPoly = FALSE;
}
if( !bAllPoly )
return poGeom;
OGRMultiPolygon *poMP = new OGRMultiPolygon();
while( poGC->getNumGeometries() > 0 )
{
poMP->addGeometryDirectly( poGC->getGeometryRef(0) );
poGC->removeGeometry( 0, FALSE );
}
delete poGC;
return poMP;
}
/* -------------------------------------------------------------------- */
/* Eventually we should try to split the polygon into component */
/* island polygons. But thats alot of work and can be put off. */
/* -------------------------------------------------------------------- */
if( wkbFlatten(poGeom->getGeometryType()) != wkbPolygon )
return poGeom;
OGRMultiPolygon *poMP = new OGRMultiPolygon();
poMP->addGeometryDirectly( poGeom );
return poMP;
}
OGRMultiPolygon* OGRILI1Layer::Polygonize( OGRGeometryCollection* poLines, bool fix_crossing_lines )
{
OGRMultiPolygon *poPolygon = new OGRMultiPolygon();
if (poLines->getNumGeometries() == 0) return poPolygon;
#if defined(HAVE_GEOS)
GEOSGeom *ahInGeoms = NULL;
int i = 0;
OGRGeometryCollection *poNoncrossingLines = poLines;
GEOSGeom hResultGeom = NULL;
OGRGeometry *poMP = NULL;
if (fix_crossing_lines && poLines->getNumGeometries() > 0)
{
#if (GEOS_VERSION_MAJOR >= 3)
CPLDebug( "OGR_ILI", "Fixing crossing lines");
//A union of the geometry collection with one line fixes invalid geometries
poNoncrossingLines = (OGRGeometryCollection*)poLines->Union(poLines->getGeometryRef(0));
CPLDebug( "OGR_ILI", "Fixed lines: %d", poNoncrossingLines->getNumGeometries()-poLines->getNumGeometries());
#else
#warning Interlis 1 AREA cleanup disabled. Needs GEOS >= 3.0
#endif
}
ahInGeoms = (GEOSGeom *) CPLCalloc(sizeof(void*),poNoncrossingLines->getNumGeometries());
for( i = 0; i < poNoncrossingLines->getNumGeometries(); i++ )
ahInGeoms[i] = poNoncrossingLines->getGeometryRef(i)->exportToGEOS();
hResultGeom = GEOSPolygonize( ahInGeoms,
poNoncrossingLines->getNumGeometries() );
for( i = 0; i < poNoncrossingLines->getNumGeometries(); i++ )
GEOSGeom_destroy( ahInGeoms[i] );
CPLFree( ahInGeoms );
if (poNoncrossingLines != poLines) delete poNoncrossingLines;
if( hResultGeom == NULL )
return NULL;
poMP = OGRGeometryFactory::createFromGEOS( hResultGeom );
GEOSGeom_destroy( hResultGeom );
return (OGRMultiPolygon *) poMP;
#endif
return poPolygon;
}
OGRGeometry *OGRGeometryFactory::forceToPolygon( OGRGeometry *poGeom )
{
if( poGeom == NULL )
return NULL;
if( wkbFlatten(poGeom->getGeometryType()) != wkbGeometryCollection
|| wkbFlatten(poGeom->getGeometryType()) != wkbMultiPolygon )
return poGeom;
// build an aggregated polygon from all the polygon rings in the container.
OGRPolygon *poPolygon = new OGRPolygon();
OGRGeometryCollection *poGC = (OGRGeometryCollection *) poGeom;
int iGeom;
for( iGeom = 0; iGeom < poGC->getNumGeometries(); iGeom++ )
{
if( wkbFlatten(poGC->getGeometryRef(iGeom)->getGeometryType())
!= wkbPolygon )
continue;
OGRPolygon *poOldPoly = (OGRPolygon *) poGC->getGeometryRef(iGeom);
int iRing;
poPolygon->addRing( poOldPoly->getExteriorRing() );
for( iRing = 0; iRing < poOldPoly->getNumInteriorRings(); iRing++ )
poPolygon->addRing( poOldPoly->getInteriorRing( iRing ) );
}
delete poGC;
return poPolygon;
}
OGRBoolean OGRGeometryCollection::Equals( OGRGeometry * poOther ) const
{
if( poOther == this )
return TRUE;
if( poOther->getGeometryType() != getGeometryType() )
return FALSE;
if ( IsEmpty() && poOther->IsEmpty() )
return TRUE;
OGRGeometryCollection *poOGC = (OGRGeometryCollection *) poOther;
if( getNumGeometries() != poOGC->getNumGeometries() )
return FALSE;
// we should eventually test the SRS.
for( int iGeom = 0; iGeom < nGeomCount; iGeom++ )
{
if( !getGeometryRef(iGeom)->Equals(poOGC->getGeometryRef(iGeom)) )
return FALSE;
}
return TRUE;
}
OGRGeometry *OGRGeometryFactory::forceToMultiLineString( OGRGeometry *poGeom )
{
if( poGeom == NULL )
return NULL;
/* -------------------------------------------------------------------- */
/* Check for the case of a geometrycollection that can be */
/* promoted to MultiLineString. */
/* -------------------------------------------------------------------- */
if( wkbFlatten(poGeom->getGeometryType()) == wkbGeometryCollection )
{
int iGeom;
int bAllLines = TRUE;
OGRGeometryCollection *poGC = (OGRGeometryCollection *) poGeom;
for( iGeom = 0; iGeom < poGC->getNumGeometries(); iGeom++ )
{
if( wkbFlatten(poGC->getGeometryRef(iGeom)->getGeometryType())
!= wkbLineString )
bAllLines = FALSE;
}
if( !bAllLines )
return poGeom;
OGRMultiLineString *poMP = new OGRMultiLineString();
while( poGC->getNumGeometries() > 0 )
{
poMP->addGeometryDirectly( poGC->getGeometryRef(0) );
poGC->removeGeometry( 0, FALSE );
}
delete poGC;
return poMP;
}
if( wkbFlatten(poGeom->getGeometryType()) != wkbLineString )
return poGeom;
OGRMultiLineString *poMP = new OGRMultiLineString();
poMP->addGeometryDirectly( poGeom );
return poMP;
}
void Shape::Dispatch(OGRGeometry *geom){
switch(geom->getGeometryType()){
case wkbPolygon:
{
PlotPolygon((OGRPolygon *)geom);
break;
}
case wkbMultiPolygon:
{
OGRGeometryCollection *coll = (OGRGeometryCollection *)geom;
for(int i = 0; i < coll->getNumGeometries(); i++)
Dispatch(coll->getGeometryRef(i));
break;
}
}
}
void wxGISSimpleMarkerSymbol::Draw(const wxGISGeometry &Geometry, int nLevel)
{
if(!Geometry.IsOk() ||!m_pDisplay)
return;
OGRwkbGeometryType eGeomType = wkbFlatten(Geometry.GetType());
if(eGeomType != wkbPoint && eGeomType != wkbMultiPoint)
return;
OGREnvelope Env = Geometry.GetEnvelope();
if(!m_pDisplay->CanDraw(Env))
return;
OGRGeometry *pGeom = Geometry;
if(eGeomType == wkbMultiPoint)
{
OGRGeometryCollection* pOGRGeometryCollection = (OGRGeometryCollection*)pGeom;
for(int i = 0; i < pOGRGeometryCollection->getNumGeometries(); ++i)
Draw(wxGISGeometry(pOGRGeometryCollection->getGeometryRef(i), false));
return;
}
wxCriticalSectionLocker lock(m_pDisplay->GetLock());
OGRPoint* pPoint = (OGRPoint*)pGeom;
if(m_dfOutlineSize)
{
if(!m_pDisplay->DrawPointFast(pPoint->getX(), pPoint->getY()))
{
return;
}
m_pDisplay->SetColor(m_OutlineColor);
m_pDisplay->SetLineWidth( m_dfSize + m_dfOutlineSize + m_dfOutlineSize);
m_pDisplay->Stroke();
}
if(!m_pDisplay->DrawPointFast(pPoint->getX(), pPoint->getY()))
{
return;
}
m_pDisplay->SetColor(m_Color);
m_pDisplay->SetLineWidth( m_dfSize );
m_pDisplay->SetLineCap(CAIRO_LINE_CAP_ROUND);
m_pDisplay->Stroke();
}
void GeomDrawBox::draw_geometry(cairo_t *cr, OGRGeometry *geom, double scale, double x, double y, double height)
{
switch (geom->getGeometryType())
{
case wkbPolygon:
draw_polygon(cr, dynamic_cast<OGRPolygon*>(geom), scale, x, y, height);
break;
case wkbMultiPolygon:
{
OGRGeometryCollection *geoCollection = dynamic_cast<OGRGeometryCollection*>(geom);
for (int i = 0; i < geoCollection->getNumGeometries(); ++i)
draw_geometry(cr, geoCollection->getGeometryRef(i), scale, x, y, height);
}
break;
default:
log_warning("Can't paint geometry type %s\n", geom->getGeometryName());
break;
}
}
OGRConvert::Geometry* OGRConvert::geometry ( OGRGeometry* geometry, OGRCoordinateTransformation *transform, double verticalOffset )
{
if ( 0x0 != geometry )
{
switch ( geometry->getGeometryType() )
{
case wkbPoint:
case wkbPoint25D:
case wkbLineString:
case wkbLineString25D:
case wkbLinearRing:
case wkbPolygon:
case wkbPolygon25D:
return OGRConvert::_geometry ( geometry, transform, verticalOffset );
break;
case wkbMultiPoint:
case wkbMultiPoint25D:
case wkbMultiLineString:
case wkbMultiLineString25D:
case wkbMultiPolygon:
case wkbMultiPolygon25D:
case wkbGeometryCollection:
case wkbGeometryCollection25D:
{
OGRGeometryCollection* collection ( static_cast<OGRGeometryCollection*> ( geometry ) );
Minerva::Core::Data::MultiGeometry::RefPtr multiGeometry ( new Minerva::Core::Data::MultiGeometry );
for ( int i = 0; i < collection->getNumGeometries(); ++i )
{
multiGeometry->addGeometry ( OGRConvert::_geometry ( collection->getGeometryRef ( i ), transform, verticalOffset ) );
}
return multiGeometry.release();
}
break;
case wkbNone:
case wkbUnknown:
return 0x0;
}
}
return 0x0;
}
void wxGISSimpleCollectionSymbol::Draw(const wxGISGeometry &Geometry, int nLevel)
{
if(!Geometry.IsOk() ||!m_pDisplay)
return;
if (!Geometry.IsOk())
return;
switch (wkbFlatten(Geometry.GetType()))
{
case wkbMultiPoint:
case wkbPoint:
m_pMarkerSymbol->Draw(Geometry);
break;
case wkbMultiPolygon:
case wkbPolygon:
m_pFillSymbol->Draw(Geometry);
break;
case wkbMultiLineString:
case wkbLineString:
m_pLineSymbol->Draw(Geometry);
break;
case wkbGeometryCollection:
{
OGRGeometryCollection* pOGRGeometryCollection = (OGRGeometryCollection*)Geometry.operator OGRGeometry *();
for (int i = 0; i < pOGRGeometryCollection->getNumGeometries(); ++i)
{
wxGISGeometry CollectionGeom(pOGRGeometryCollection->getGeometryRef(i), false);
Draw(CollectionGeom, nLevel);
}
}
break;
case wkbLinearRing:
case wkbUnknown:
case wkbNone:
default:
break;
}
}
void wxGISSimpleLineSymbol::Draw(const wxGISGeometry &Geometry, int nLevel)
{
if(!Geometry.IsOk() || !m_pDisplay)
return;
OGRwkbGeometryType eGeomType = wkbFlatten(Geometry.GetType());
if(eGeomType != wkbLineString && eGeomType != wkbLinearRing && eGeomType != wkbMultiLineString)
return;
OGREnvelope Env = Geometry.GetEnvelope();
if(!m_pDisplay->CanDraw(Env))
return;
wxCriticalSectionLocker lock(m_pDisplay->GetLock());
OGRGeometry *pGeom = Geometry;
if (eGeomType == wkbMultiLineString)
{
OGRGeometryCollection* pOGRGeometryCollection = (OGRGeometryCollection*)pGeom;
for(int i = 0; i < pOGRGeometryCollection->getNumGeometries(); ++i)
Draw(wxGISGeometry(pOGRGeometryCollection->getGeometryRef(i), false));
}
else
{
OGRLineString* pLine = (OGRLineString*)pGeom;
int nPointCount = pLine->getNumPoints();
if (!m_pDisplay->CheckDrawAsPoint(Env, m_dfWidth, false, 0, 0, false))
{
if(!DrawPreserved(pLine))
return;
SetStyleToDisplay();
}
else
{
SetLimitStyleToDisplay();
}
m_pDisplay->Stroke();
}
}
//! Simplifies the OGR-geometry (Removing duplicated points) when is applied the specified map2pixel context
bool QgsOgrMapToPixelSimplifier::simplifyOgrGeometry( OGRGeometry* geometry, bool isaLinearRing )
{
OGRwkbGeometryType wkbGeometryType = wkbFlatten( geometry->getGeometryType() );
// Simplify the geometry rewriting temporally its WKB-stream for saving calloc's.
if ( wkbGeometryType == wkbLineString )
{
OGRLineString* lineString = ( OGRLineString* )geometry;
int numPoints = lineString->getNumPoints();
if (( isaLinearRing && numPoints <= 5 ) || ( !isaLinearRing && numPoints <= 2 ) ) return false;
OGREnvelope env;
geometry->getEnvelope( &env );
QgsRectangle envelope( env.MinX, env.MinY, env.MaxX, env.MaxY );
// Can replace the geometry by its BBOX ?
if (( mSimplifyFlags & QgsMapToPixelSimplifier::SimplifyEnvelope ) && canbeGeneralizedByMapBoundingBox( envelope ) )
{
OGRRawPoint* points = NULL;
int numPoints = 0;
double x1 = envelope.xMinimum();
double y1 = envelope.yMinimum();
double x2 = envelope.xMaximum();
double y2 = envelope.yMaximum();
if ( isaLinearRing )
{
numPoints = 5;
points = mallocPoints( numPoints );
points[0].x = x1; points[0].y = y1;
points[1].x = x2; points[1].y = y1;
points[2].x = x2; points[2].y = y2;
points[3].x = x1; points[3].y = y2;
points[4].x = x1; points[4].y = y1;
}
else
{
numPoints = 2;
points = mallocPoints( numPoints );
points[0].x = x1; points[0].y = y1;
points[1].x = x2; points[1].y = y2;
}
lineString->setPoints( numPoints, points );
lineString->flattenTo2D();
return true;
}
else
if ( mSimplifyFlags & QgsMapToPixelSimplifier::SimplifyGeometry )
{
QGis::GeometryType geometryType = isaLinearRing ? QGis::Polygon : QGis::Line;
int numSimplifiedPoints = 0;
OGRRawPoint* points = mallocPoints( numPoints );
double* xptr = ( double* )points;
double* yptr = xptr + 1;
lineString->getPoints( points );
if ( simplifyOgrGeometry( geometryType, envelope, xptr, 16, yptr, 16, numPoints, numSimplifiedPoints ) )
{
lineString->setPoints( numSimplifiedPoints, points );
lineString->flattenTo2D();
}
return numSimplifiedPoints != numPoints;
}
}
else
if ( wkbGeometryType == wkbPolygon )
{
OGRPolygon* polygon = ( OGRPolygon* )geometry;
bool result = simplifyOgrGeometry( polygon->getExteriorRing(), true );
for ( int i = 0, numInteriorRings = polygon->getNumInteriorRings(); i < numInteriorRings; ++i )
{
result |= simplifyOgrGeometry( polygon->getInteriorRing( i ), true );
}
if ( result ) polygon->flattenTo2D();
return result;
}
else
if ( wkbGeometryType == wkbMultiLineString || wkbGeometryType == wkbMultiPolygon )
{
OGRGeometryCollection* collection = ( OGRGeometryCollection* )geometry;
bool result = false;
for ( int i = 0, numGeometries = collection->getNumGeometries(); i < numGeometries; ++i )
{
result |= simplifyOgrGeometry( collection->getGeometryRef( i ), wkbGeometryType == wkbMultiPolygon );
}
if ( result ) collection->flattenTo2D();
return result;
}
return false;
}
static void ProcessCommonGeometry(OGRGeometry* poGeom, OGRGeometry *poClipSrc,
int iBurnField, double dfBurnValue,
const double dfIncreaseBurnValue,
const double dfMultiplyBurnValue,
std::vector<double> &adfX,
std::vector<double> &adfY,
std::vector<double> &adfZ)
{
if (NULL == poGeom)
return;
OGRwkbGeometryType eType = wkbFlatten(poGeom->getGeometryType());
switch (eType)
{
case wkbPoint:
return ProcessGeometry((OGRPoint *)poGeom, poClipSrc,
iBurnField, dfBurnValue, dfIncreaseBurnValue, dfMultiplyBurnValue, adfX, adfY, adfZ);
case wkbLinearRing:
case wkbLineString:
{
OGRLineString *poLS = (OGRLineString*)poGeom;
OGRPoint point;
for (int pointIndex = 0; pointIndex < poLS->getNumPoints(); pointIndex++)
{
poLS->getPoint(pointIndex, &point);
ProcessCommonGeometry((OGRGeometry*)&point, poClipSrc,
iBurnField, dfBurnValue, dfIncreaseBurnValue, dfMultiplyBurnValue, adfX, adfY, adfZ);
}
}
break;
case wkbPolygon:
{
int nRings(0);
OGRPolygon* poPoly = (OGRPolygon*)poGeom;
OGRLinearRing* poRing = poPoly->getExteriorRing();
ProcessCommonGeometry((OGRGeometry*)poRing, poClipSrc,
iBurnField, dfBurnValue, dfIncreaseBurnValue, dfMultiplyBurnValue, adfX, adfY, adfZ);
nRings = poPoly->getNumInteriorRings();
if (nRings > 0)
{
for (int ir = 0; ir < nRings; ++ir)
{
OGRLinearRing* poRing = poPoly->getInteriorRing(ir);
ProcessCommonGeometry((OGRGeometry*)poRing, poClipSrc,
iBurnField, dfBurnValue, dfIncreaseBurnValue, dfMultiplyBurnValue, adfX, adfY, adfZ);
}
}
}
break;
case wkbMultiPoint:
case wkbMultiPolygon:
case wkbMultiLineString:
case wkbGeometryCollection:
{
OGRGeometryCollection* pOGRGeometryCollection = (OGRGeometryCollection*)poGeom;
for (int i = 0; i < pOGRGeometryCollection->getNumGeometries(); ++i)
{
ProcessCommonGeometry(pOGRGeometryCollection->getGeometryRef(i), poClipSrc,
iBurnField, dfBurnValue, dfIncreaseBurnValue, dfMultiplyBurnValue, adfX, adfY, adfZ);
}
}
break;
case wkbUnknown:
case wkbNone:
default:
break;
}
}
OGRErr OGROCIWritableLayer::TranslateToSDOGeometry( OGRGeometry * poGeometry,
int *pnGType )
{
nOrdinalCount = 0;
nElemInfoCount = 0;
if( poGeometry == NULL )
return OGRERR_FAILURE;
/* ==================================================================== */
/* Handle a point geometry. */
/* ==================================================================== */
if( wkbFlatten(poGeometry->getGeometryType()) == wkbPoint )
{
#ifdef notdef
char szResult[1024];
OGRPoint *poPoint = (OGRPoint *) poGeometry;
if( nDimension == 2 )
CPLsprintf( szResult,
"%s(%d,%s,MDSYS.SDO_POINT_TYPE(%.16g,%.16g,0.0),NULL,NULL)",
SDO_GEOMETRY, 2001, szSRID,
poPoint->getX(), poPoint->getY() );
else
CPLsprintf( szResult,
"%s(%d,%s,MDSYS.SDO_POINT_TYPE(%.16g,%.16g,%.16g),NULL,NULL)",
SDO_GEOMETRY, 3001, szSRID,
poPoint->getX(), poPoint->getY(), poPoint->getZ() );
return CPLStrdup(szResult );
#endif
}
/* ==================================================================== */
/* Handle a line string geometry. */
/* ==================================================================== */
else if( wkbFlatten(poGeometry->getGeometryType()) == wkbLineString )
{
*pnGType = nDimension * 1000 + 2;
TranslateElementGroup( poGeometry );
return OGRERR_NONE;
}
/* ==================================================================== */
/* Handle a polygon geometry. */
/* ==================================================================== */
else if( wkbFlatten(poGeometry->getGeometryType()) == wkbPolygon )
{
*pnGType = nDimension == 2 ? 2003 : 3003;
TranslateElementGroup( poGeometry );
return OGRERR_NONE;
}
/* ==================================================================== */
/* Handle a multi point geometry. */
/* ==================================================================== */
else if( wkbFlatten(poGeometry->getGeometryType()) == wkbMultiPoint )
{
OGRMultiPoint *poMP = (OGRMultiPoint *) poGeometry;
int iVert;
*pnGType = nDimension*1000 + 5;
PushElemInfo( 1, 1, poMP->getNumGeometries() );
for( iVert = 0; iVert < poMP->getNumGeometries(); iVert++ )
{
OGRPoint *poPoint = (OGRPoint *)poMP->getGeometryRef( iVert );
PushOrdinal( poPoint->getX() );
PushOrdinal( poPoint->getY() );
if( nDimension == 3 )
PushOrdinal( poPoint->getZ() );
}
return OGRERR_NONE;
}
/* ==================================================================== */
/* Handle other geometry collections. */
/* ==================================================================== */
else
{
/* -------------------------------------------------------------------- */
/* Identify the GType. */
/* -------------------------------------------------------------------- */
if( wkbFlatten(poGeometry->getGeometryType()) == wkbMultiLineString )
*pnGType = nDimension * 1000 + 6;
else if( wkbFlatten(poGeometry->getGeometryType()) == wkbMultiPolygon )
*pnGType = nDimension * 1000 + 7;
else if( wkbFlatten(poGeometry->getGeometryType())
== wkbGeometryCollection )
*pnGType = nDimension * 1000 + 4;
else
{
CPLError( CE_Failure, CPLE_AppDefined,
"Unexpected geometry type (%d/%s) in "
"OGROCIWritableLayer::TranslateToSDOGeometry()",
poGeometry->getGeometryType(),
poGeometry->getGeometryName() );
return OGRERR_FAILURE;
}
/* -------------------------------------------------------------------- */
/* Translate each child in turn. */
/* -------------------------------------------------------------------- */
OGRGeometryCollection *poGC = (OGRGeometryCollection *) poGeometry;
int iChild;
for( iChild = 0; iChild < poGC->getNumGeometries(); iChild++ )
TranslateElementGroup( poGC->getGeometryRef(iChild) );
return OGRERR_NONE;
}
return OGRERR_FAILURE;
}
//coordinate;//(double x, double y);
//contains the baseline/collection of baselines for the shoreline
void ShoreLine::getShapePoints(string filename){
RegisterOGRShape(); // OGR Drivers for reading shapefiles only
OGRDataSource *poDS;
cout<<"Reading in file shapefile"<<filename<<endl;
poDS = OGRSFDriverRegistrar::Open( filename.c_str(), FALSE );
if ( poDS == NULL ){
printf("Open fail");
exit(1);
}
OGRLayer *poLayer;
poLayer = poDS->GetLayer(0);
OGRGeometry *poGeometry;
//poGeometry = poLayer->
OGRFeature *poFeature;
poFeature= poLayer->GetNextFeature();
poLayer->ResetReading();
if (poGeometry==NULL){
return;
}
switch(wkbFlatten(poGeometry->getGeometryType()))
{
case wkbPoint:
{ ((OGRPoint*)poGeometry);/////////////////////////
break;
}
case wkbLineString:
case wkbLinearRing:
{
OGRLineString* poLS = (OGRLineString*) poGeometry;
for(int i=0;i<poLS->getNumPoints();i++)
shoreLinePoints.push_back(coordinate(poLS->getX(i),poLS->getY(i)));
break;
}
case wkbPolygon:
{
int i;
OGRPolygon* poPoly = (OGRPolygon*) poGeometry;
//SetZ(poPoly->getExteriorRing(), dfZ);
for(i=0;i<poPoly->getNumInteriorRings();i++)
// SetZ(poPoly->getInteriorRing(i), dfZ);
break;
}
case wkbMultiPoint:
case wkbMultiLineString:
case wkbMultiPolygon:
case wkbGeometryCollection:
{
int i;
OGRGeometryCollection* poGeometryColl = (OGRGeometryCollection*) poGeometry;
for(i=0;i<poGeometryColl->getNumGeometries();i++)
// SetZ(poGeometryColl->getGeometryRef(i), dfZ);
break;
}
default:
printf( "no readable geometry\n" );
break;
}
OGRFeature::DestroyFeature( poFeature );
OGRDataSource::DestroyDataSource( poDS );
return;
}
static int OGR2GML3GeometryAppend( OGRGeometry *poGeometry,
const OGRSpatialReference* poParentSRS,
char **ppszText, int *pnLength,
int *pnMaxLength,
int bIsSubGeometry,
int bLongSRS,
int bLineStringAsCurve,
const char* pszGMLId = NULL)
{
/* -------------------------------------------------------------------- */
/* Check for Spatial Reference System attached to given geometry */
/* -------------------------------------------------------------------- */
// Buffer for srsName and gml:id attributes (srsName="..." gml:id="...")
char szAttributes[256];
int nAttrsLength = 0;
szAttributes[0] = 0;
const OGRSpatialReference* poSRS = NULL;
if (poParentSRS)
poSRS = poParentSRS;
else
poParentSRS = poSRS = poGeometry->getSpatialReference();
int bCoordSwap = FALSE;
if( NULL != poSRS )
{
const char* pszAuthName = NULL;
const char* pszAuthCode = NULL;
const char* pszTarget = NULL;
if (poSRS->IsProjected())
pszTarget = "PROJCS";
else
pszTarget = "GEOGCS";
pszAuthName = poSRS->GetAuthorityName( pszTarget );
if( NULL != pszAuthName )
{
if( EQUAL( pszAuthName, "EPSG" ) )
{
pszAuthCode = poSRS->GetAuthorityCode( pszTarget );
if( NULL != pszAuthCode && strlen(pszAuthCode) < 10 )
{
if (bLongSRS && !((OGRSpatialReference*)poSRS)->EPSGTreatsAsLatLong())
{
OGRSpatialReference oSRS;
if (oSRS.importFromEPSGA(atoi(pszAuthCode)) == OGRERR_NONE)
{
if (oSRS.EPSGTreatsAsLatLong())
bCoordSwap = TRUE;
}
}
if (!bIsSubGeometry)
{
if (bLongSRS)
{
snprintf( szAttributes, sizeof(szAttributes),
" srsName=\"urn:ogc:def:crs:%s::%s\"",
pszAuthName, pszAuthCode );
}
else
{
snprintf( szAttributes, sizeof(szAttributes),
" srsName=\"%s:%s\"",
pszAuthName, pszAuthCode );
}
nAttrsLength = strlen(szAttributes);
}
}
}
}
}
if (pszGMLId != NULL && nAttrsLength + 9 + strlen(pszGMLId) + 1 < sizeof(szAttributes))
{
strcat(szAttributes, " gml:id=\"");
strcat(szAttributes, pszGMLId);
strcat(szAttributes, "\"");
nAttrsLength = strlen(szAttributes);
}
/* -------------------------------------------------------------------- */
/* 2D Point */
/* -------------------------------------------------------------------- */
if( poGeometry->getGeometryType() == wkbPoint )
{
char szCoordinate[256];
OGRPoint *poPoint = (OGRPoint *) poGeometry;
if (bCoordSwap)
OGRMakeWktCoordinate( szCoordinate,
poPoint->getY(), poPoint->getX(), 0.0, 2 );
else
OGRMakeWktCoordinate( szCoordinate,
poPoint->getX(), poPoint->getY(), 0.0, 2 );
_GrowBuffer( *pnLength + strlen(szCoordinate) + 60 + nAttrsLength,
ppszText, pnMaxLength );
sprintf( *ppszText + *pnLength,
"<gml:Point%s><gml:pos>%s</gml:pos></gml:Point>",
szAttributes, szCoordinate );
*pnLength += strlen( *ppszText + *pnLength );
}
/* -------------------------------------------------------------------- */
/* 3D Point */
/* -------------------------------------------------------------------- */
else if( poGeometry->getGeometryType() == wkbPoint25D )
{
char szCoordinate[256];
OGRPoint *poPoint = (OGRPoint *) poGeometry;
if (bCoordSwap)
OGRMakeWktCoordinate( szCoordinate,
poPoint->getY(), poPoint->getX(), poPoint->getZ(), 3 );
else
OGRMakeWktCoordinate( szCoordinate,
poPoint->getX(), poPoint->getY(), poPoint->getZ(), 3 );
_GrowBuffer( *pnLength + strlen(szCoordinate) + 70 + nAttrsLength,
ppszText, pnMaxLength );
sprintf( *ppszText + *pnLength,
"<gml:Point%s><gml:pos>%s</gml:pos></gml:Point>",
szAttributes, szCoordinate );
*pnLength += strlen( *ppszText + *pnLength );
}
/* -------------------------------------------------------------------- */
/* LineString and LinearRing */
/* -------------------------------------------------------------------- */
else if( poGeometry->getGeometryType() == wkbLineString
|| poGeometry->getGeometryType() == wkbLineString25D )
{
int bRing = EQUAL(poGeometry->getGeometryName(),"LINEARRING");
if (!bRing && bLineStringAsCurve)
{
AppendString( ppszText, pnLength, pnMaxLength,
"<gml:Curve" );
AppendString( ppszText, pnLength, pnMaxLength,
szAttributes );
AppendString( ppszText, pnLength, pnMaxLength,
"><gml:segments><gml:LineStringSegment>" );
AppendGML3CoordinateList( (OGRLineString *) poGeometry, bCoordSwap,
ppszText, pnLength, pnMaxLength );
AppendString( ppszText, pnLength, pnMaxLength,
"</gml:LineStringSegment></gml:segments></gml:Curve>" );
}
else
{
// Buffer for tag name + srsName attribute if set
const size_t nLineTagLength = 16;
char* pszLineTagName = NULL;
pszLineTagName = (char *) CPLMalloc( nLineTagLength + nAttrsLength + 1 );
if( bRing )
{
/* LinearRing isn't supposed to have srsName attribute according to GML3 SF-0 */
AppendString( ppszText, pnLength, pnMaxLength,
"<gml:LinearRing>" );
}
else
{
sprintf( pszLineTagName, "<gml:LineString%s>", szAttributes );
AppendString( ppszText, pnLength, pnMaxLength,
pszLineTagName );
}
// FREE TAG BUFFER
CPLFree( pszLineTagName );
AppendGML3CoordinateList( (OGRLineString *) poGeometry, bCoordSwap,
ppszText, pnLength, pnMaxLength );
if( bRing )
AppendString( ppszText, pnLength, pnMaxLength,
"</gml:LinearRing>" );
else
AppendString( ppszText, pnLength, pnMaxLength,
"</gml:LineString>" );
}
}
/* -------------------------------------------------------------------- */
/* Polygon */
/* -------------------------------------------------------------------- */
else if( poGeometry->getGeometryType() == wkbPolygon
|| poGeometry->getGeometryType() == wkbPolygon25D )
{
OGRPolygon *poPolygon = (OGRPolygon *) poGeometry;
// Buffer for polygon tag name + srsName attribute if set
const size_t nPolyTagLength = 13;
char* pszPolyTagName = NULL;
pszPolyTagName = (char *) CPLMalloc( nPolyTagLength + nAttrsLength + 1 );
// Compose Polygon tag with or without srsName attribute
sprintf( pszPolyTagName, "<gml:Polygon%s>", szAttributes );
AppendString( ppszText, pnLength, pnMaxLength,
pszPolyTagName );
// FREE TAG BUFFER
CPLFree( pszPolyTagName );
// Don't add srsName to polygon rings
if( poPolygon->getExteriorRing() != NULL )
{
AppendString( ppszText, pnLength, pnMaxLength,
"<gml:exterior>" );
if( !OGR2GML3GeometryAppend( poPolygon->getExteriorRing(), poSRS,
ppszText, pnLength, pnMaxLength,
TRUE, bLongSRS, bLineStringAsCurve ) )
{
return FALSE;
}
AppendString( ppszText, pnLength, pnMaxLength,
"</gml:exterior>" );
}
for( int iRing = 0; iRing < poPolygon->getNumInteriorRings(); iRing++ )
{
OGRLinearRing *poRing = poPolygon->getInteriorRing(iRing);
AppendString( ppszText, pnLength, pnMaxLength,
"<gml:interior>" );
if( !OGR2GML3GeometryAppend( poRing, poSRS, ppszText, pnLength,
pnMaxLength, TRUE, bLongSRS, bLineStringAsCurve ) )
return FALSE;
AppendString( ppszText, pnLength, pnMaxLength,
"</gml:interior>" );
}
AppendString( ppszText, pnLength, pnMaxLength,
"</gml:Polygon>" );
}
/* -------------------------------------------------------------------- */
/* MultiPolygon, MultiLineString, MultiPoint, MultiGeometry */
/* -------------------------------------------------------------------- */
else if( wkbFlatten(poGeometry->getGeometryType()) == wkbMultiPolygon
|| wkbFlatten(poGeometry->getGeometryType()) == wkbMultiLineString
|| wkbFlatten(poGeometry->getGeometryType()) == wkbMultiPoint
|| wkbFlatten(poGeometry->getGeometryType()) == wkbGeometryCollection )
{
OGRGeometryCollection *poGC = (OGRGeometryCollection *) poGeometry;
int iMember;
const char *pszElemClose = NULL;
const char *pszMemberElem = NULL;
// Buffer for opening tag + srsName attribute
char* pszElemOpen = NULL;
if( wkbFlatten(poGeometry->getGeometryType()) == wkbMultiPolygon )
{
pszElemOpen = (char *) CPLMalloc( 13 + nAttrsLength + 1 );
sprintf( pszElemOpen, "MultiSurface%s>", szAttributes );
pszElemClose = "MultiSurface>";
pszMemberElem = "surfaceMember>";
}
else if( wkbFlatten(poGeometry->getGeometryType()) == wkbMultiLineString )
{
pszElemOpen = (char *) CPLMalloc( 16 + nAttrsLength + 1 );
sprintf( pszElemOpen, "MultiCurve%s>", szAttributes );
pszElemClose = "MultiCurve>";
pszMemberElem = "curveMember>";
}
else if( wkbFlatten(poGeometry->getGeometryType()) == wkbMultiPoint )
{
pszElemOpen = (char *) CPLMalloc( 11 + nAttrsLength + 1 );
sprintf( pszElemOpen, "MultiPoint%s>", szAttributes );
pszElemClose = "MultiPoint>";
pszMemberElem = "pointMember>";
}
else
{
pszElemOpen = (char *) CPLMalloc( 19 + nAttrsLength + 1 );
sprintf( pszElemOpen, "MultiGeometry%s>", szAttributes );
pszElemClose = "MultiGeometry>";
pszMemberElem = "geometryMember>";
}
AppendString( ppszText, pnLength, pnMaxLength, "<gml:" );
AppendString( ppszText, pnLength, pnMaxLength, pszElemOpen );
for( iMember = 0; iMember < poGC->getNumGeometries(); iMember++)
{
OGRGeometry *poMember = poGC->getGeometryRef( iMember );
AppendString( ppszText, pnLength, pnMaxLength, "<gml:" );
AppendString( ppszText, pnLength, pnMaxLength, pszMemberElem );
if( !OGR2GML3GeometryAppend( poMember, poSRS,
ppszText, pnLength, pnMaxLength,
TRUE, bLongSRS, bLineStringAsCurve ) )
{
return FALSE;
}
AppendString( ppszText, pnLength, pnMaxLength, "</gml:" );
AppendString( ppszText, pnLength, pnMaxLength, pszMemberElem );
}
AppendString( ppszText, pnLength, pnMaxLength, "</gml:" );
AppendString( ppszText, pnLength, pnMaxLength, pszElemClose );
// FREE TAG BUFFER
CPLFree( pszElemOpen );
}
else
{
return FALSE;
}
return TRUE;
}
static int OGR2ILIGeometryAppend( OGRGeometry *poGeometry, VSILFILE* fp, const char *attrname, CPLString iliGeomType )
{
//CPLDebug( "OGR_ILI", "OGR2ILIGeometryAppend getGeometryType %s iliGeomType %s", poGeometry->getGeometryName(), iliGeomType.c_str());
/* -------------------------------------------------------------------- */
/* 2D/3D Point */
/* -------------------------------------------------------------------- */
if( poGeometry->getGeometryType() == wkbPoint || poGeometry->getGeometryType() == wkbPoint25D )
{
OGRPoint *poPoint = (OGRPoint *) poGeometry;
VSIFPrintfL(fp, "<%s>\n", attrname);
VSIFPrintfL(fp, "<COORD>");
VSIFPrintfL(fp, "<C1>%s</C1>", d2str(poPoint->getX()));
VSIFPrintfL(fp, "<C2>%s</C2>", d2str(poPoint->getY()));
if( poGeometry->getGeometryType() == wkbPoint25D )
VSIFPrintfL(fp, "<C3>%s</C3>", d2str(poPoint->getZ()));
VSIFPrintfL(fp, "</COORD>\n");
VSIFPrintfL(fp, "</%s>\n", attrname);
}
/* -------------------------------------------------------------------- */
/* LineString and LinearRing */
/* -------------------------------------------------------------------- */
else if( poGeometry->getGeometryType() == wkbLineString
|| poGeometry->getGeometryType() == wkbLineString25D )
{
if (attrname) VSIFPrintfL(fp, "<%s>\n", attrname);
VSIFPrintfL(fp, "<POLYLINE>\n");
// unclipped polyline, add one sequence
// VSIFPrintfL(fp, "<SEGMENTS>\n");
AppendCoordinateList( (OGRLineString *) poGeometry, fp );
// VSIFPrintfL(fp, "</SEGMENTS>\n");
VSIFPrintfL(fp, "</POLYLINE>\n");
if (attrname) VSIFPrintfL(fp, "</%s>\n", attrname);
}
/* -------------------------------------------------------------------- */
/* Polygon */
/* -------------------------------------------------------------------- */
else if( poGeometry->getGeometryType() == wkbPolygon
|| poGeometry->getGeometryType() == wkbPolygon25D )
{
OGRPolygon *poPolygon = (OGRPolygon *) poGeometry;
if (attrname) VSIFPrintfL(fp, "<%s>\n", attrname);
if( iliGeomType == "Surface" || iliGeomType == "Area" )
{
//VSIFPrintfL(fp, "<MULTISURFACE>\n");
VSIFPrintfL(fp, "<SURFACE>\n");
VSIFPrintfL(fp, "<BOUNDARY>\n");
}
if( poPolygon->getExteriorRing() != NULL )
{
if( !OGR2ILIGeometryAppend( poPolygon->getExteriorRing(), fp, NULL, "" ) )
return FALSE;
}
for( int iRing = 0; iRing < poPolygon->getNumInteriorRings(); iRing++ )
{
OGRLinearRing *poRing = poPolygon->getInteriorRing(iRing);
if( !OGR2ILIGeometryAppend( poRing, fp, NULL, "" ) )
return FALSE;
}
if( iliGeomType == "Surface" || iliGeomType == "Area" )
{
VSIFPrintfL(fp, "</BOUNDARY>\n");
VSIFPrintfL(fp, "</SURFACE>\n");
//VSIFPrintfL(fp, "</MULTISURFACE>\n");
}
if (attrname) VSIFPrintfL(fp, "</%s>\n", attrname);
}
/* -------------------------------------------------------------------- */
/* MultiPolygon */
/* -------------------------------------------------------------------- */
else if( wkbFlatten(poGeometry->getGeometryType()) == wkbMultiPolygon
|| wkbFlatten(poGeometry->getGeometryType()) == wkbMultiLineString
|| wkbFlatten(poGeometry->getGeometryType()) == wkbMultiPoint
|| wkbFlatten(poGeometry->getGeometryType()) == wkbGeometryCollection )
{
OGRGeometryCollection *poGC = (OGRGeometryCollection *) poGeometry;
int iMember;
if( wkbFlatten(poGeometry->getGeometryType()) == wkbMultiPolygon )
{
}
else if( wkbFlatten(poGeometry->getGeometryType()) == wkbMultiLineString )
{
}
else if( wkbFlatten(poGeometry->getGeometryType()) == wkbMultiPoint )
{
}
else
{
}
for( iMember = 0; iMember < poGC->getNumGeometries(); iMember++)
{
OGRGeometry *poMember = poGC->getGeometryRef( iMember );
if( !OGR2ILIGeometryAppend( poMember, fp, NULL, "" ) )
return FALSE;
}
}
else
return FALSE;
return TRUE;
}
int OGRILI1Layer::GeometryAppend( OGRGeometry *poGeometry )
{
/* -------------------------------------------------------------------- */
/* 2D Point */
/* -------------------------------------------------------------------- */
if( poGeometry->getGeometryType() == wkbPoint )
{
/* embedded in from non-geometry fields */
}
/* -------------------------------------------------------------------- */
/* 3D Point */
/* -------------------------------------------------------------------- */
else if( poGeometry->getGeometryType() == wkbPoint25D )
{
/* embedded in from non-geometry fields */
}
/* -------------------------------------------------------------------- */
/* LineString and LinearRing */
/* -------------------------------------------------------------------- */
else if( poGeometry->getGeometryType() == wkbLineString
|| poGeometry->getGeometryType() == wkbLineString25D )
{
AppendCoordinateList( (OGRLineString *) poGeometry, poDS );
}
/* -------------------------------------------------------------------- */
/* Polygon */
/* -------------------------------------------------------------------- */
else if( poGeometry->getGeometryType() == wkbPolygon
|| poGeometry->getGeometryType() == wkbPolygon25D )
{
OGRPolygon *poPolygon = (OGRPolygon *) poGeometry;
if( poPolygon->getExteriorRing() != NULL )
{
if( !GeometryAppend( poPolygon->getExteriorRing() ) )
return FALSE;
}
for( int iRing = 0; iRing < poPolygon->getNumInteriorRings(); iRing++ )
{
OGRLinearRing *poRing = poPolygon->getInteriorRing(iRing);
if( !GeometryAppend( poRing ) )
return FALSE;
}
}
/* -------------------------------------------------------------------- */
/* MultiPolygon */
/* -------------------------------------------------------------------- */
else if( wkbFlatten(poGeometry->getGeometryType()) == wkbMultiPolygon
|| wkbFlatten(poGeometry->getGeometryType()) == wkbMultiLineString
|| wkbFlatten(poGeometry->getGeometryType()) == wkbMultiPoint
|| wkbFlatten(poGeometry->getGeometryType()) == wkbGeometryCollection )
{
OGRGeometryCollection *poGC = (OGRGeometryCollection *) poGeometry;
int iMember;
if( wkbFlatten(poGeometry->getGeometryType()) == wkbMultiPolygon )
{
}
else if( wkbFlatten(poGeometry->getGeometryType()) == wkbMultiLineString )
{
}
else if( wkbFlatten(poGeometry->getGeometryType()) == wkbMultiPoint )
{
}
else
{
}
for( iMember = 0; iMember < poGC->getNumGeometries(); iMember++)
{
OGRGeometry *poMember = poGC->getGeometryRef( iMember );
if( !GeometryAppend( poMember ) )
return FALSE;
}
}
else
return FALSE;
return TRUE;
}
static bool OGR2KMLGeometryAppend( OGRGeometry *poGeometry,
char **ppszText, size_t *pnLength,
size_t *pnMaxLength, char *szAltitudeMode )
{
/* -------------------------------------------------------------------- */
/* 2D Point */
/* -------------------------------------------------------------------- */
if( poGeometry->getGeometryType() == wkbPoint )
{
OGRPoint* poPoint = static_cast<OGRPoint*>(poGeometry);
if (poPoint->getCoordinateDimension() == 0)
{
_GrowBuffer( *pnLength + 10,
ppszText, pnMaxLength );
strcat( *ppszText + *pnLength, "<Point/>");
*pnLength += strlen( *ppszText + *pnLength );
}
else
{
char szCoordinate[256] = { 0 };
MakeKMLCoordinate( szCoordinate, sizeof(szCoordinate),
poPoint->getX(), poPoint->getY(), 0.0, FALSE );
_GrowBuffer( *pnLength + strlen(szCoordinate) + 60,
ppszText, pnMaxLength );
snprintf( *ppszText + *pnLength, *pnMaxLength - *pnLength,
"<Point><coordinates>%s</coordinates></Point>",
szCoordinate );
*pnLength += strlen( *ppszText + *pnLength );
}
}
/* -------------------------------------------------------------------- */
/* 3D Point */
/* -------------------------------------------------------------------- */
else if( poGeometry->getGeometryType() == wkbPoint25D )
{
char szCoordinate[256] = { 0 };
OGRPoint *poPoint = static_cast<OGRPoint*>(poGeometry);
MakeKMLCoordinate( szCoordinate, sizeof(szCoordinate),
poPoint->getX(), poPoint->getY(), poPoint->getZ(),
true );
if (NULL == szAltitudeMode)
{
_GrowBuffer( *pnLength + strlen(szCoordinate) + 70,
ppszText, pnMaxLength );
snprintf( *ppszText + *pnLength, *pnMaxLength - *pnLength,
"<Point><coordinates>%s</coordinates></Point>",
szCoordinate );
}
else
{
_GrowBuffer( *pnLength + strlen(szCoordinate)
+ strlen(szAltitudeMode) + 70,
ppszText, pnMaxLength );
snprintf( *ppszText + *pnLength, *pnMaxLength - *pnLength,
"<Point>%s<coordinates>%s</coordinates></Point>",
szAltitudeMode, szCoordinate );
}
*pnLength += strlen( *ppszText + *pnLength );
}
/* -------------------------------------------------------------------- */
/* LineString and LinearRing */
/* -------------------------------------------------------------------- */
else if( poGeometry->getGeometryType() == wkbLineString
|| poGeometry->getGeometryType() == wkbLineString25D )
{
const bool bRing = EQUAL(poGeometry->getGeometryName(),"LINEARRING");
if( bRing )
AppendString( ppszText, pnLength, pnMaxLength,
"<LinearRing>" );
else
AppendString( ppszText, pnLength, pnMaxLength,
"<LineString>" );
if (NULL != szAltitudeMode)
{
AppendString( ppszText, pnLength, pnMaxLength, szAltitudeMode);
}
AppendCoordinateList( reinterpret_cast<OGRLineString *>(poGeometry),
ppszText, pnLength, pnMaxLength );
if( bRing )
AppendString( ppszText, pnLength, pnMaxLength,
"</LinearRing>" );
else
AppendString( ppszText, pnLength, pnMaxLength,
"</LineString>" );
}
/* -------------------------------------------------------------------- */
/* Polygon */
/* -------------------------------------------------------------------- */
else if( poGeometry->getGeometryType() == wkbPolygon
|| poGeometry->getGeometryType() == wkbPolygon25D )
{
OGRPolygon* poPolygon = static_cast<OGRPolygon*>(poGeometry);
AppendString( ppszText, pnLength, pnMaxLength, "<Polygon>" );
if (NULL != szAltitudeMode)
{
AppendString( ppszText, pnLength, pnMaxLength, szAltitudeMode);
}
if( poPolygon->getExteriorRing() != NULL )
{
AppendString( ppszText, pnLength, pnMaxLength,
"<outerBoundaryIs>" );
if( !OGR2KMLGeometryAppend( poPolygon->getExteriorRing(),
ppszText, pnLength, pnMaxLength,
szAltitudeMode ) )
{
return false;
}
AppendString( ppszText, pnLength, pnMaxLength,
"</outerBoundaryIs>" );
}
for( int iRing = 0; iRing < poPolygon->getNumInteriorRings(); iRing++ )
{
OGRLinearRing *poRing = poPolygon->getInteriorRing(iRing);
AppendString( ppszText, pnLength, pnMaxLength,
"<innerBoundaryIs>" );
if( !OGR2KMLGeometryAppend( poRing, ppszText, pnLength,
pnMaxLength, szAltitudeMode ) )
{
return false;
}
AppendString( ppszText, pnLength, pnMaxLength,
"</innerBoundaryIs>" );
}
AppendString( ppszText, pnLength, pnMaxLength,
"</Polygon>" );
}
/* -------------------------------------------------------------------- */
/* MultiPolygon */
/* -------------------------------------------------------------------- */
else if( wkbFlatten(poGeometry->getGeometryType()) == wkbMultiPolygon
|| wkbFlatten(poGeometry->getGeometryType()) == wkbMultiLineString
|| wkbFlatten(poGeometry->getGeometryType()) == wkbMultiPoint
|| wkbFlatten(poGeometry->getGeometryType()) ==
wkbGeometryCollection )
{
OGRGeometryCollection* poGC = NULL;
poGC = static_cast<OGRGeometryCollection*>(poGeometry);
AppendString( ppszText, pnLength, pnMaxLength, "<MultiGeometry>" );
// XXX - mloskot
//if (NULL != szAltitudeMode)
//{
// AppendString( ppszText, pnLength, pnMaxLength, szAltitudeMode);
//}
for( int iMember = 0; iMember < poGC->getNumGeometries(); iMember++)
{
OGRGeometry *poMember = poGC->getGeometryRef( iMember );
if( !OGR2KMLGeometryAppend( poMember, ppszText, pnLength,
pnMaxLength, szAltitudeMode ) )
{
return false;
}
}
AppendString( ppszText, pnLength, pnMaxLength, "</MultiGeometry>" );
}
else
{
return false;
}
return true;
}
void OGRILI1Layer::PolygonizeAreaLayer()
{
if (poAreaLineLayer == 0) return;
//add all lines from poAreaLineLayer to collection
OGRGeometryCollection *gc = new OGRGeometryCollection();
poAreaLineLayer->ResetReading();
while (OGRFeature *feature = poAreaLineLayer->GetNextFeatureRef())
gc->addGeometry(feature->GetGeometryRef());
//polygonize lines
CPLDebug( "OGR_ILI", "Polygonizing layer %s with %d multilines", poAreaLineLayer->GetLayerDefn()->GetName(), gc->getNumGeometries());
OGRMultiPolygon* polys = Polygonize( gc , false);
CPLDebug( "OGR_ILI", "Resulting polygons: %d", polys->getNumGeometries());
if (polys->getNumGeometries() != poAreaReferenceLayer->GetFeatureCount())
{
CPLDebug( "OGR_ILI", "Feature count of layer %s: %d", poAreaReferenceLayer->GetLayerDefn()->GetName(), GetFeatureCount());
CPLDebug( "OGR_ILI", "Polygonizing again with crossing line fix");
delete polys;
polys = Polygonize( gc, true ); //try again with crossing line fix
}
delete gc;
//associate polygon feature with data row according to centroid
#if defined(HAVE_GEOS)
int i;
OGRPolygon emptyPoly;
GEOSGeom *ahInGeoms = NULL;
CPLDebug( "OGR_ILI", "Associating layer %s with area polygons", GetLayerDefn()->GetName());
ahInGeoms = (GEOSGeom *) CPLCalloc(sizeof(void*),polys->getNumGeometries());
for( i = 0; i < polys->getNumGeometries(); i++ )
{
ahInGeoms[i] = polys->getGeometryRef(i)->exportToGEOS();
if (!GEOSisValid(ahInGeoms[i])) ahInGeoms[i] = NULL;
}
poAreaReferenceLayer->ResetReading();
while (OGRFeature *feature = poAreaReferenceLayer->GetNextFeatureRef())
{
GEOSGeom point = (GEOSGeom)feature->GetGeometryRef()->exportToGEOS();
for (i = 0; i < polys->getNumGeometries(); i++ )
{
if (ahInGeoms[i] && GEOSWithin(point, ahInGeoms[i]))
{
OGRFeature* areaFeature = feature->Clone();
areaFeature->SetGeometry( polys->getGeometryRef(i) );
AddFeature(areaFeature);
break;
}
}
if (i == polys->getNumGeometries())
{
CPLDebug( "OGR_ILI", "Association between area and point failed.");
feature->SetGeometry( &emptyPoly );
}
GEOSGeom_destroy( point );
}
for( i = 0; i < polys->getNumGeometries(); i++ )
GEOSGeom_destroy( ahInGeoms[i] );
CPLFree( ahInGeoms );
#endif
poAreaReferenceLayer = 0;
poAreaLineLayer = 0;
}
static int OGR2GML3GeometryAppend( const OGRGeometry *poGeometry,
const OGRSpatialReference* poParentSRS,
char **ppszText, int *pnLength,
int *pnMaxLength,
int bIsSubGeometry,
int bLongSRS,
int bLineStringAsCurve,
const char* pszGMLId,
int nSRSDimensionLocFlags,
int bForceLineStringAsLinearRing )
{
/* -------------------------------------------------------------------- */
/* Check for Spatial Reference System attached to given geometry */
/* -------------------------------------------------------------------- */
// Buffer for srsName, srsDimension and gml:id attributes (srsName="..." gml:id="...")
char szAttributes[256];
int nAttrsLength = 0;
szAttributes[0] = 0;
const OGRSpatialReference* poSRS = NULL;
if (poParentSRS)
poSRS = poParentSRS;
else
poParentSRS = poSRS = poGeometry->getSpatialReference();
int bCoordSwap = FALSE;
if( NULL != poSRS )
{
const char* pszAuthName = NULL;
const char* pszAuthCode = NULL;
const char* pszTarget = NULL;
if (poSRS->IsProjected())
pszTarget = "PROJCS";
else
pszTarget = "GEOGCS";
pszAuthName = poSRS->GetAuthorityName( pszTarget );
if( NULL != pszAuthName )
{
if( EQUAL( pszAuthName, "EPSG" ) )
{
pszAuthCode = poSRS->GetAuthorityCode( pszTarget );
if( NULL != pszAuthCode && strlen(pszAuthCode) < 10 )
{
if (bLongSRS && !(((OGRSpatialReference*)poSRS)->EPSGTreatsAsLatLong() ||
((OGRSpatialReference*)poSRS)->EPSGTreatsAsNorthingEasting()))
{
OGRSpatialReference oSRS;
if (oSRS.importFromEPSGA(atoi(pszAuthCode)) == OGRERR_NONE)
{
if (oSRS.EPSGTreatsAsLatLong() || oSRS.EPSGTreatsAsNorthingEasting())
bCoordSwap = TRUE;
}
}
if (!bIsSubGeometry)
{
if (bLongSRS)
{
snprintf( szAttributes, sizeof(szAttributes),
" srsName=\"urn:ogc:def:crs:%s::%s\"",
pszAuthName, pszAuthCode );
}
else
{
snprintf( szAttributes, sizeof(szAttributes),
" srsName=\"%s:%s\"",
pszAuthName, pszAuthCode );
}
nAttrsLength = strlen(szAttributes);
}
}
}
}
}
if( (nSRSDimensionLocFlags & SRSDIM_LOC_GEOMETRY) != 0 &&
wkbHasZ(poGeometry->getGeometryType()) )
{
strcat(szAttributes, " srsDimension=\"3\"");
nAttrsLength = strlen(szAttributes);
nSRSDimensionLocFlags &= ~SRSDIM_LOC_GEOMETRY;
}
if (pszGMLId != NULL && nAttrsLength + 9 + strlen(pszGMLId) + 1 < sizeof(szAttributes))
{
strcat(szAttributes, " gml:id=\"");
strcat(szAttributes, pszGMLId);
strcat(szAttributes, "\"");
nAttrsLength = strlen(szAttributes);
}
OGRwkbGeometryType eType = poGeometry->getGeometryType();
OGRwkbGeometryType eFType = wkbFlatten(eType);
/* -------------------------------------------------------------------- */
/* 2D Point */
/* -------------------------------------------------------------------- */
if( eType == wkbPoint )
{
char szCoordinate[256];
OGRPoint *poPoint = (OGRPoint *) poGeometry;
if (bCoordSwap)
OGRMakeWktCoordinate( szCoordinate,
poPoint->getY(), poPoint->getX(), 0.0, 2 );
else
OGRMakeWktCoordinate( szCoordinate,
poPoint->getX(), poPoint->getY(), 0.0, 2 );
_GrowBuffer( *pnLength + strlen(szCoordinate) + 60 + nAttrsLength,
ppszText, pnMaxLength );
sprintf( *ppszText + *pnLength,
"<gml:Point%s><gml:pos>%s</gml:pos></gml:Point>",
szAttributes, szCoordinate );
*pnLength += strlen( *ppszText + *pnLength );
}
/* -------------------------------------------------------------------- */
/* 3D Point */
/* -------------------------------------------------------------------- */
else if( eType == wkbPoint25D )
{
char szCoordinate[256];
OGRPoint *poPoint = (OGRPoint *) poGeometry;
if (bCoordSwap)
OGRMakeWktCoordinate( szCoordinate,
poPoint->getY(), poPoint->getX(), poPoint->getZ(), 3 );
else
OGRMakeWktCoordinate( szCoordinate,
poPoint->getX(), poPoint->getY(), poPoint->getZ(), 3 );
_GrowBuffer( *pnLength + strlen(szCoordinate) + 70 + nAttrsLength,
ppszText, pnMaxLength );
sprintf( *ppszText + *pnLength,
"<gml:Point%s><gml:pos>%s</gml:pos></gml:Point>",
szAttributes, szCoordinate );
*pnLength += strlen( *ppszText + *pnLength );
}
/* -------------------------------------------------------------------- */
/* LineString and LinearRing */
/* -------------------------------------------------------------------- */
else if( eFType == wkbLineString )
{
int bRing = EQUAL(poGeometry->getGeometryName(),"LINEARRING") ||
bForceLineStringAsLinearRing;
if (!bRing && bLineStringAsCurve)
{
AppendString( ppszText, pnLength, pnMaxLength,
"<gml:Curve" );
AppendString( ppszText, pnLength, pnMaxLength,
szAttributes );
AppendString( ppszText, pnLength, pnMaxLength,
"><gml:segments><gml:LineStringSegment>" );
AppendGML3CoordinateList( (OGRLineString *) poGeometry, bCoordSwap,
ppszText, pnLength, pnMaxLength, nSRSDimensionLocFlags );
AppendString( ppszText, pnLength, pnMaxLength,
"</gml:LineStringSegment></gml:segments></gml:Curve>" );
}
else
{
// Buffer for tag name + srsName attribute if set
const size_t nLineTagLength = 16;
char* pszLineTagName = NULL;
pszLineTagName = (char *) CPLMalloc( nLineTagLength + nAttrsLength + 1 );
if( bRing )
{
/* LinearRing isn't supposed to have srsName attribute according to GML3 SF-0 */
AppendString( ppszText, pnLength, pnMaxLength,
"<gml:LinearRing>" );
}
else
{
sprintf( pszLineTagName, "<gml:LineString%s>", szAttributes );
AppendString( ppszText, pnLength, pnMaxLength,
pszLineTagName );
}
// FREE TAG BUFFER
CPLFree( pszLineTagName );
AppendGML3CoordinateList( (OGRLineString *) poGeometry, bCoordSwap,
ppszText, pnLength, pnMaxLength, nSRSDimensionLocFlags );
if( bRing )
AppendString( ppszText, pnLength, pnMaxLength,
"</gml:LinearRing>" );
else
AppendString( ppszText, pnLength, pnMaxLength,
"</gml:LineString>" );
}
}
/* -------------------------------------------------------------------- */
/* ArcString or Circle */
/* -------------------------------------------------------------------- */
else if( eFType == wkbCircularString )
{
AppendString( ppszText, pnLength, pnMaxLength,
"<gml:Curve" );
AppendString( ppszText, pnLength, pnMaxLength,
szAttributes );
OGRSimpleCurve* poSC = (OGRSimpleCurve *) poGeometry;
/* SQL MM has a unique type for arc and circle, GML not */
if( poSC->getNumPoints() == 3 &&
poSC->getX(0) == poSC->getX(2) &&
poSC->getY(0) == poSC->getY(2) )
{
double dfMidX = (poSC->getX(0) + poSC->getX(1)) / 2;
double dfMidY = (poSC->getY(0) + poSC->getY(1)) / 2;
double dfDirX = (poSC->getX(1) - poSC->getX(0)) / 2;
double dfDirY = (poSC->getY(1) - poSC->getY(0)) / 2;
double dfNormX = -dfDirY;
double dfNormY = dfDirX;
double dfNewX = dfMidX + dfNormX;
double dfNewY = dfMidY + dfNormY;
OGRLineString* poLS = new OGRLineString();
OGRPoint p;
poSC->getPoint(0, &p);
poLS->addPoint(&p);
poSC->getPoint(1, &p);
if( poSC->getCoordinateDimension() == 3 )
poLS->addPoint(dfNewX, dfNewY, p.getZ());
else
poLS->addPoint(dfNewX, dfNewY);
poLS->addPoint(&p);
AppendString( ppszText, pnLength, pnMaxLength,
"><gml:segments><gml:Circle>" );
AppendGML3CoordinateList( poLS, bCoordSwap,
ppszText, pnLength, pnMaxLength, nSRSDimensionLocFlags );
AppendString( ppszText, pnLength, pnMaxLength,
"</gml:Circle></gml:segments></gml:Curve>" );
delete poLS;
}
else
{
AppendString( ppszText, pnLength, pnMaxLength,
"><gml:segments><gml:ArcString>" );
AppendGML3CoordinateList( poSC, bCoordSwap,
ppszText, pnLength, pnMaxLength, nSRSDimensionLocFlags );
AppendString( ppszText, pnLength, pnMaxLength,
"</gml:ArcString></gml:segments></gml:Curve>" );
}
}
/* -------------------------------------------------------------------- */
/* CompositeCurve */
/* -------------------------------------------------------------------- */
else if( eFType == wkbCompoundCurve )
{
AppendString( ppszText, pnLength, pnMaxLength,
"<gml:CompositeCurve" );
AppendString( ppszText, pnLength, pnMaxLength,
szAttributes );
AppendString( ppszText, pnLength, pnMaxLength,">");
OGRCompoundCurve* poCC = (OGRCompoundCurve*)poGeometry;
for(int i=0;i<poCC->getNumCurves();i++)
{
AppendString( ppszText, pnLength, pnMaxLength,
"<gml:curveMember>" );
if( !OGR2GML3GeometryAppend( poCC->getCurve(i), poSRS, ppszText, pnLength,
pnMaxLength, TRUE, bLongSRS,
bLineStringAsCurve,
NULL, nSRSDimensionLocFlags, FALSE) )
return FALSE;
AppendString( ppszText, pnLength, pnMaxLength,
"</gml:curveMember>" );
}
AppendString( ppszText, pnLength, pnMaxLength,
"</gml:CompositeCurve>" );
}
/* -------------------------------------------------------------------- */
/* Polygon */
/* -------------------------------------------------------------------- */
else if( eFType == wkbPolygon || eFType == wkbCurvePolygon )
{
OGRCurvePolygon *poCP = (OGRCurvePolygon *) poGeometry;
// Buffer for polygon tag name + srsName attribute if set
const size_t nPolyTagLength = 13;
char* pszPolyTagName = NULL;
pszPolyTagName = (char *) CPLMalloc( nPolyTagLength + nAttrsLength + 1 );
// Compose Polygon tag with or without srsName attribute
sprintf( pszPolyTagName, "<gml:Polygon%s>", szAttributes );
AppendString( ppszText, pnLength, pnMaxLength,
pszPolyTagName );
// FREE TAG BUFFER
CPLFree( pszPolyTagName );
// Don't add srsName to polygon rings
if( poCP->getExteriorRingCurve() != NULL )
{
AppendString( ppszText, pnLength, pnMaxLength,
"<gml:exterior>" );
if( !OGR2GML3GeometryAppend( poCP->getExteriorRingCurve(), poSRS,
ppszText, pnLength, pnMaxLength,
TRUE, bLongSRS, bLineStringAsCurve,
NULL, nSRSDimensionLocFlags, TRUE) )
{
return FALSE;
}
AppendString( ppszText, pnLength, pnMaxLength,
"</gml:exterior>" );
}
for( int iRing = 0; iRing < poCP->getNumInteriorRings(); iRing++ )
{
OGRCurve *poRing = poCP->getInteriorRingCurve(iRing);
AppendString( ppszText, pnLength, pnMaxLength,
"<gml:interior>" );
if( !OGR2GML3GeometryAppend( poRing, poSRS, ppszText, pnLength,
pnMaxLength, TRUE, bLongSRS,
bLineStringAsCurve,
NULL, nSRSDimensionLocFlags, TRUE) )
return FALSE;
AppendString( ppszText, pnLength, pnMaxLength,
"</gml:interior>" );
}
AppendString( ppszText, pnLength, pnMaxLength,
"</gml:Polygon>" );
}
/* -------------------------------------------------------------------- */
/* MultiSurface, MultiCurve, MultiPoint, MultiGeometry */
/* -------------------------------------------------------------------- */
else if( eFType == wkbMultiPolygon
|| eFType == wkbMultiSurface
|| eFType == wkbMultiLineString
|| eFType == wkbMultiCurve
|| eFType == wkbMultiPoint
|| eFType == wkbGeometryCollection )
{
OGRGeometryCollection *poGC = (OGRGeometryCollection *) poGeometry;
int iMember;
const char *pszElemClose = NULL;
const char *pszMemberElem = NULL;
// Buffer for opening tag + srsName attribute
char* pszElemOpen = NULL;
if( eFType == wkbMultiPolygon || eFType == wkbMultiSurface )
{
pszElemOpen = (char *) CPLMalloc( 13 + nAttrsLength + 1 );
sprintf( pszElemOpen, "MultiSurface%s>", szAttributes );
pszElemClose = "MultiSurface>";
pszMemberElem = "surfaceMember>";
}
else if( eFType == wkbMultiLineString || eFType == wkbMultiCurve )
{
pszElemOpen = (char *) CPLMalloc( 16 + nAttrsLength + 1 );
sprintf( pszElemOpen, "MultiCurve%s>", szAttributes );
pszElemClose = "MultiCurve>";
pszMemberElem = "curveMember>";
}
else if( eFType == wkbMultiPoint )
{
pszElemOpen = (char *) CPLMalloc( 11 + nAttrsLength + 1 );
sprintf( pszElemOpen, "MultiPoint%s>", szAttributes );
pszElemClose = "MultiPoint>";
pszMemberElem = "pointMember>";
}
else
{
pszElemOpen = (char *) CPLMalloc( 19 + nAttrsLength + 1 );
sprintf( pszElemOpen, "MultiGeometry%s>", szAttributes );
pszElemClose = "MultiGeometry>";
pszMemberElem = "geometryMember>";
}
AppendString( ppszText, pnLength, pnMaxLength, "<gml:" );
AppendString( ppszText, pnLength, pnMaxLength, pszElemOpen );
for( iMember = 0; iMember < poGC->getNumGeometries(); iMember++)
{
OGRGeometry *poMember = poGC->getGeometryRef( iMember );
AppendString( ppszText, pnLength, pnMaxLength, "<gml:" );
AppendString( ppszText, pnLength, pnMaxLength, pszMemberElem );
char* pszGMLIdSub = NULL;
if (pszGMLId != NULL)
pszGMLIdSub = CPLStrdup(CPLSPrintf("%s.%d", pszGMLId, iMember));
if( !OGR2GML3GeometryAppend( poMember, poSRS,
ppszText, pnLength, pnMaxLength,
TRUE, bLongSRS, bLineStringAsCurve,
pszGMLIdSub, nSRSDimensionLocFlags, FALSE ) )
{
CPLFree(pszGMLIdSub);
return FALSE;
}
CPLFree(pszGMLIdSub);
AppendString( ppszText, pnLength, pnMaxLength, "</gml:" );
AppendString( ppszText, pnLength, pnMaxLength, pszMemberElem );
}
AppendString( ppszText, pnLength, pnMaxLength, "</gml:" );
AppendString( ppszText, pnLength, pnMaxLength, pszElemClose );
// FREE TAG BUFFER
CPLFree( pszElemOpen );
}
else
{
CPLError(CE_Failure, CPLE_NotSupported, "Unsupported geometry type %s",
OGRGeometryTypeToName(eType));
return FALSE;
}
return TRUE;
}
OGRGeometryH OGRBuildPolygonFromEdges( OGRGeometryH hLines,
int bBestEffort,
int bAutoClose,
double dfTolerance,
OGRErr * peErr )
{
int bSuccess = TRUE;
OGRGeometryCollection *poLines = (OGRGeometryCollection *) hLines;
OGRPolygon *poPolygon = new OGRPolygon();
(void) bBestEffort;
/* -------------------------------------------------------------------- */
/* Setup array of line markers indicating if they have been */
/* added to a ring yet. */
/* -------------------------------------------------------------------- */
int nEdges = poLines->getNumGeometries();
int *panEdgeConsumed, nRemainingEdges = nEdges;
panEdgeConsumed = (int *) CPLCalloc(sizeof(int),nEdges);
/* ==================================================================== */
/* Loop generating rings. */
/* ==================================================================== */
while( nRemainingEdges > 0 )
{
int iEdge;
OGRLineString *poLine;
/* -------------------------------------------------------------------- */
/* Find the first unconsumed edge. */
/* -------------------------------------------------------------------- */
for( iEdge = 0; panEdgeConsumed[iEdge]; iEdge++ ) {}
poLine = (OGRLineString *) poLines->getGeometryRef(iEdge);
/* -------------------------------------------------------------------- */
/* Start a new ring, copying in the current line directly */
/* -------------------------------------------------------------------- */
OGRLinearRing *poRing = new OGRLinearRing();
AddEdgeToRing( poRing, poLine, FALSE );
panEdgeConsumed[iEdge] = TRUE;
nRemainingEdges--;
/* ==================================================================== */
/* Loop adding edges to this ring until we make a whole pass */
/* within finding anything to add. */
/* ==================================================================== */
int bWorkDone = TRUE;
double dfBestDist = dfTolerance;
while( !CheckPoints(poRing,0,poRing,poRing->getNumPoints()-1,NULL)
&& nRemainingEdges > 0
&& bWorkDone )
{
int iBestEdge = -1, bReverse = FALSE;
bWorkDone = FALSE;
dfBestDist = dfTolerance;
// We consider linking the end to the beginning. If this is
// closer than any other option we will just close the loop.
//CheckPoints(poRing,0,poRing,poRing->getNumPoints()-1,&dfBestDist);
// Find unused edge with end point closest to our loose end.
for( iEdge = 0; iEdge < nEdges; iEdge++ )
{
if( panEdgeConsumed[iEdge] )
continue;
poLine = (OGRLineString *) poLines->getGeometryRef(iEdge);
if( CheckPoints(poLine,0,poRing,poRing->getNumPoints()-1,
&dfBestDist) )
{
iBestEdge = iEdge;
bReverse = FALSE;
}
if( CheckPoints(poLine,poLine->getNumPoints()-1,
poRing,poRing->getNumPoints()-1,
&dfBestDist) )
{
iBestEdge = iEdge;
bReverse = TRUE;
}
}
// We found one within tolerance - add it.
if( iBestEdge != -1 )
{
poLine = (OGRLineString *)
poLines->getGeometryRef(iBestEdge);
AddEdgeToRing( poRing, poLine, bReverse );
panEdgeConsumed[iBestEdge] = TRUE;
nRemainingEdges--;
bWorkDone = TRUE;
}
}
/* -------------------------------------------------------------------- */
/* Did we fail to complete the ring? */
/* -------------------------------------------------------------------- */
dfBestDist = dfTolerance;
if( !CheckPoints(poRing,0,poRing,poRing->getNumPoints()-1,
&dfBestDist) )
{
CPLDebug( "OGR",
"Failed to close ring %d.\n"
"End Points are: (%.8f,%.7f) and (%.7f,%.7f)\n",
poPolygon->getNumInteriorRings()+1,
poRing->getX(0), poRing->getY(0),
poRing->getX(poRing->getNumPoints()-1),
poRing->getY(poRing->getNumPoints()-1) );
bSuccess = FALSE;
}
/* -------------------------------------------------------------------- */
/* Do we need to auto-close this ring? */
/* -------------------------------------------------------------------- */
if( bAutoClose
&& !CheckPoints(poRing,0,poRing,poRing->getNumPoints()-1,NULL) )
{
poRing->addPoint( poRing->getX(0),
poRing->getY(0),
poRing->getZ(0));
}
poPolygon->addRingDirectly( poRing );
} /* next ring */
/* -------------------------------------------------------------------- */
/* Cleanup. */
/* -------------------------------------------------------------------- */
CPLFree( panEdgeConsumed );
// Eventually we should at least identify the external ring properly,
// perhaps even ordering the direction of rings, though this isn't
// required by the OGC geometry model.
if( peErr != NULL )
{
if( bSuccess )
*peErr = OGRERR_NONE;
else
*peErr = OGRERR_FAILURE;
}
return (OGRGeometryH) poPolygon;
}
ElementPtr geom2kml (
OGRGeometry * poOgrGeom,
int extra,
KmlFactory * poKmlFactory )
{
int i;
if ( !poOgrGeom ) {
return NULL;
}
/***** ogr geom vars *****/
OGRPoint *poOgrPoint = NULL;
OGRLineString *poOgrLineString;
OGRPolygon *poOgrPolygon;
OGRGeometryCollection *poOgrMultiGeom;
/***** libkml geom vars *****/
CoordinatesPtr coordinates;
PointPtr poKmlPoint;
LineStringPtr poKmlLineString;
LinearRingPtr poKmlLinearRing;
OuterBoundaryIsPtr poKmlOuterRing;
InnerBoundaryIsPtr poKmlInnerRing;
PolygonPtr poKmlPolygon;
MultiGeometryPtr poKmlMultiGeometry;
ElementPtr poKmlGeometry;
ElementPtr poKmlTmpGeometry;
/***** other vars *****/
double x,
y,
z;
int numpoints = 0;
int nGeom;
OGRwkbGeometryType type = poOgrGeom->getGeometryType ( );
switch ( type ) {
case wkbPoint:
poOgrPoint = ( OGRPoint * ) poOgrGeom;
if (poOgrPoint->getCoordinateDimension() == 0)
{
poKmlGeometry = poKmlPoint = poKmlFactory->CreatePoint ( );
}
else
{
x = poOgrPoint->getX ( );
y = poOgrPoint->getY ( );
if ( x > 180 )
x -= 360;
coordinates = poKmlFactory->CreateCoordinates ( );
coordinates->add_latlng ( y, x );
poKmlGeometry = poKmlPoint = poKmlFactory->CreatePoint ( );
poKmlPoint->set_coordinates ( coordinates );
}
break;
case wkbPoint25D:
poOgrPoint = ( OGRPoint * ) poOgrGeom;
x = poOgrPoint->getX ( );
y = poOgrPoint->getY ( );
z = poOgrPoint->getZ ( );
if ( x > 180 )
x -= 360;
coordinates = poKmlFactory->CreateCoordinates ( );
coordinates->add_latlngalt ( y, x, z );
poKmlGeometry = poKmlPoint = poKmlFactory->CreatePoint ( );
poKmlPoint->set_coordinates ( coordinates );
break;
case wkbLineString:
poOgrLineString = ( OGRLineString * ) poOgrGeom;
if( extra >= 0 )
{
((OGRLinearRing*)poOgrGeom)->closeRings();
}
numpoints = poOgrLineString->getNumPoints ( );
if( extra >= 0 )
{
if( numpoints < 4 &&
CPLTestBool(CPLGetConfigOption("LIBKML_STRICT_COMPLIANCE", "TRUE")) )
{
CPLError(CE_Failure, CPLE_NotSupported, "A linearring should have at least 4 points");
return NULL;
}
}
else
{
if( numpoints < 2 &&
CPLTestBool(CPLGetConfigOption("LIBKML_STRICT_COMPLIANCE", "TRUE")) )
{
CPLError(CE_Failure, CPLE_NotSupported, "A linestring should have at least 2 points");
return NULL;
}
}
coordinates = poKmlFactory->CreateCoordinates ( );
poOgrPoint = new OGRPoint ( );
for ( i = 0; i < numpoints; i++ ) {
poOgrLineString->getPoint ( i, poOgrPoint );
x = poOgrPoint->getX ( );
y = poOgrPoint->getY ( );
if ( x > 180 )
x -= 360;
coordinates->add_latlng ( y, x );
}
delete poOgrPoint;
/***** check if its a wkbLinearRing *****/
if ( extra < 0 ) {
poKmlGeometry = poKmlLineString =
poKmlFactory->CreateLineString ( );
poKmlLineString->set_coordinates ( coordinates );
break;
}
/***** fallthrough *****/
case wkbLinearRing: //this case is for readability only
poKmlLinearRing = poKmlFactory->CreateLinearRing ( );
poKmlLinearRing->set_coordinates ( coordinates );
if ( !extra ) {
poKmlOuterRing = poKmlFactory->CreateOuterBoundaryIs ( );
poKmlOuterRing->set_linearring ( poKmlLinearRing );
poKmlGeometry = poKmlOuterRing;
}
else {
poKmlGeometry = poKmlInnerRing =
poKmlFactory->CreateInnerBoundaryIs ( );
poKmlInnerRing->set_linearring ( poKmlLinearRing );
}
break;
case wkbLineString25D:
poOgrLineString = ( OGRLineString * ) poOgrGeom;
if( extra >= 0 )
{
((OGRLinearRing*)poOgrGeom)->closeRings();
}
numpoints = poOgrLineString->getNumPoints ( );
if( extra >= 0 )
{
if( numpoints < 4 &&
CPLTestBool(CPLGetConfigOption("LIBKML_STRICT_COMPLIANCE", "TRUE")) )
{
CPLError(CE_Failure, CPLE_NotSupported, "A linearring should have at least 4 points");
return NULL;
}
}
else
{
if( numpoints < 2 &&
CPLTestBool(CPLGetConfigOption("LIBKML_STRICT_COMPLIANCE", "TRUE")) )
{
CPLError(CE_Failure, CPLE_NotSupported, "A linestring should have at least 2 points");
return NULL;
}
}
coordinates = poKmlFactory->CreateCoordinates ( );
poOgrPoint = new OGRPoint ( );
for ( i = 0; i < numpoints; i++ ) {
poOgrLineString->getPoint ( i, poOgrPoint );
x = poOgrPoint->getX ( );
y = poOgrPoint->getY ( );
z = poOgrPoint->getZ ( );
if ( x > 180 )
x -= 360;
coordinates->add_latlngalt ( y, x, z );
}
delete poOgrPoint;
/***** check if its a wkbLinearRing *****/
if ( extra < 0 ) {
poKmlGeometry = poKmlLineString =
poKmlFactory->CreateLineString ( );
poKmlLineString->set_coordinates ( coordinates );
break;
}
/***** fallthrough *****/
//case wkbLinearRing25D: // this case is for readability only
poKmlLinearRing = poKmlFactory->CreateLinearRing ( );
poKmlLinearRing->set_coordinates ( coordinates );
if ( !extra ) {
poKmlGeometry = poKmlOuterRing =
poKmlFactory->CreateOuterBoundaryIs ( );
poKmlOuterRing->set_linearring ( poKmlLinearRing );
}
else {
poKmlGeometry = poKmlInnerRing =
poKmlFactory->CreateInnerBoundaryIs ( );
poKmlInnerRing->set_linearring ( poKmlLinearRing );
}
break;
case wkbPolygon:
CPLErrorReset();
if( CPLTestBool(CPLGetConfigOption("LIBKML_STRICT_COMPLIANCE", "TRUE")) &&
OGRGeometryFactory::haveGEOS() && (!poOgrGeom->IsValid() ||
CPLGetLastErrorType() != CE_None) )
{
CPLError(CE_Failure, CPLE_NotSupported, "Invalid polygon");
return NULL;
}
poOgrPolygon = ( OGRPolygon * ) poOgrGeom;
poKmlGeometry = poKmlPolygon = poKmlFactory->CreatePolygon ( );
poKmlTmpGeometry = geom2kml ( poOgrPolygon->getExteriorRing ( ),
0, poKmlFactory );
poKmlPolygon->
set_outerboundaryis ( AsOuterBoundaryIs ( poKmlTmpGeometry ) );
nGeom = poOgrPolygon->getNumInteriorRings ( );
for ( i = 0; i < nGeom; i++ ) {
poKmlTmpGeometry = geom2kml ( poOgrPolygon->getInteriorRing ( i ),
i + 1, poKmlFactory );
poKmlPolygon->
add_innerboundaryis ( AsInnerBoundaryIs ( poKmlTmpGeometry ) );
}
break;
case wkbPolygon25D:
CPLErrorReset();
if( CPLTestBool(CPLGetConfigOption("LIBKML_STRICT_COMPLIANCE", "TRUE")) &&
OGRGeometryFactory::haveGEOS() && (!poOgrGeom->IsValid() ||
CPLGetLastErrorType() != CE_None) )
{
CPLError(CE_Failure, CPLE_NotSupported, "Invalid polygon");
return NULL;
}
poOgrPolygon = ( OGRPolygon * ) poOgrGeom;
poKmlGeometry = poKmlPolygon = poKmlFactory->CreatePolygon ( );
poKmlTmpGeometry = geom2kml ( poOgrPolygon->getExteriorRing ( ),
0, poKmlFactory );
poKmlPolygon->
set_outerboundaryis ( AsOuterBoundaryIs ( poKmlTmpGeometry ) );
nGeom = poOgrPolygon->getNumInteriorRings ( );
for ( i = 0; i < nGeom; i++ ) {
poKmlTmpGeometry = geom2kml ( poOgrPolygon->getInteriorRing ( i ),
i + 1, poKmlFactory );
poKmlPolygon->
add_innerboundaryis ( AsInnerBoundaryIs ( poKmlTmpGeometry ) );
}
break;
case wkbMultiPoint:
case wkbMultiLineString:
case wkbMultiPolygon:
case wkbGeometryCollection:
case wkbMultiPoint25D:
case wkbMultiLineString25D:
case wkbMultiPolygon25D:
case wkbGeometryCollection25D:
poOgrMultiGeom = ( OGRGeometryCollection * ) poOgrGeom;
nGeom = poOgrMultiGeom->getNumGeometries ( );
if( nGeom == 1 &&
CPLTestBool(CPLGetConfigOption("LIBKML_STRICT_COMPLIANCE", "TRUE")) )
{
CPLDebug("LIBKML", "Turning multiple geometry into single geometry");
poKmlGeometry = geom2kml( poOgrMultiGeom->getGeometryRef ( 0 ),
-1, poKmlFactory );
}
else
{
if( nGeom == 0 &&
CPLTestBool(CPLGetConfigOption("LIBKML_STRICT_COMPLIANCE", "TRUE")) )
{
CPLError(CE_Warning, CPLE_AppDefined, "Empty multi geometry are not recommended");
}
poKmlGeometry = poKmlMultiGeometry =
poKmlFactory->CreateMultiGeometry ( );
for ( i = 0; i < nGeom; i++ ) {
poKmlTmpGeometry = geom2kml ( poOgrMultiGeom->getGeometryRef ( i ),
-1, poKmlFactory );
poKmlMultiGeometry->
add_geometry ( AsGeometry ( poKmlTmpGeometry ) );
}
}
break;
case wkbUnknown:
case wkbNone:
default:
break;
}
return poKmlGeometry;
}
void OGRDXFDataSource::ReadBlocksSection()
{
char szLineBuf[257];
int nCode;
OGRDXFLayer *poReaderLayer = (OGRDXFLayer *) GetLayerByName( "Entities" );
iEntitiesSectionOffset = oReader.iSrcBufferFileOffset + oReader.iSrcBufferOffset;
while( (nCode = ReadValue( szLineBuf, sizeof(szLineBuf) )) > -1
&& !EQUAL(szLineBuf,"ENDSEC") )
{
// We are only interested in extracting blocks.
if( nCode != 0 || !EQUAL(szLineBuf,"BLOCK") )
continue;
// Process contents of BLOCK definition till we find the
// first entity.
CPLString osBlockName;
while( (nCode = ReadValue( szLineBuf,sizeof(szLineBuf) )) > 0 )
{
if( nCode == 2 )
osBlockName = szLineBuf;
// anything else we want?
}
if( EQUAL(szLineBuf,"ENDBLK") )
continue;
UnreadValue();
// Now we will process entities till we run out at the ENDBLK code.
// we aggregate the geometries of the features into a multi-geometry,
// but throw away other stuff attached to the features.
OGRFeature *poFeature;
OGRGeometryCollection *poColl = new OGRGeometryCollection();
std::vector<OGRFeature*> apoFeatures;
while( (poFeature = poReaderLayer->GetNextUnfilteredFeature()) != NULL )
{
if( poFeature->GetStyleString() != NULL
&& strstr(poFeature->GetStyleString(),"LABEL") != NULL )
{
apoFeatures.push_back( poFeature );
}
else
{
poColl->addGeometryDirectly( poFeature->StealGeometry() );
delete poFeature;
}
}
if( poColl->getNumGeometries() == 0 )
delete poColl;
else
oBlockMap[osBlockName].poGeometry = SimplifyBlockGeometry(poColl);
if( apoFeatures.size() > 0 )
oBlockMap[osBlockName].apoFeatures = apoFeatures;
}
CPLDebug( "DXF", "Read %d blocks with meaningful geometry.",
(int) oBlockMap.size() );
}
static int OGR2GMLGeometryAppend( OGRGeometry *poGeometry,
char **ppszText, int *pnLength,
int *pnMaxLength,
int bIsSubGeometry )
{
/* -------------------------------------------------------------------- */
/* Check for Spatial Reference System attached to given geometry */
/* -------------------------------------------------------------------- */
// Buffer for srsName attribute (srsName="...")
char szAttributes[30] = { 0 };
int nAttrsLength = 0;
const OGRSpatialReference* poSRS = NULL;
poSRS = poGeometry->getSpatialReference();
if( NULL != poSRS && !bIsSubGeometry )
{
const char* pszAuthName = NULL;
const char* pszAuthCode = NULL;
const char* pszTarget = NULL;
if (poSRS->IsProjected())
pszTarget = "PROJCS";
else
pszTarget = "GEOGCS";
pszAuthName = poSRS->GetAuthorityName( pszTarget );
if( NULL != pszAuthName )
{
if( EQUAL( pszAuthName, "EPSG" ) )
{
pszAuthCode = poSRS->GetAuthorityCode( pszTarget );
if( NULL != pszAuthCode && strlen(pszAuthCode) < 10 )
{
sprintf( szAttributes, " srsName=\"%s:%s\"",
pszAuthName, pszAuthCode );
nAttrsLength = strlen(szAttributes);
}
}
}
}
/* -------------------------------------------------------------------- */
/* 2D Point */
/* -------------------------------------------------------------------- */
if( poGeometry->getGeometryType() == wkbPoint )
{
char szCoordinate[256];
OGRPoint *poPoint = (OGRPoint *) poGeometry;
MakeGMLCoordinate( szCoordinate,
poPoint->getX(), poPoint->getY(), 0.0, FALSE );
_GrowBuffer( *pnLength + strlen(szCoordinate) + 60 + nAttrsLength,
ppszText, pnMaxLength );
sprintf( *ppszText + *pnLength,
"<gml:Point%s><gml:coordinates>%s</gml:coordinates></gml:Point>",
szAttributes, szCoordinate );
*pnLength += strlen( *ppszText + *pnLength );
}
/* -------------------------------------------------------------------- */
/* 3D Point */
/* -------------------------------------------------------------------- */
else if( poGeometry->getGeometryType() == wkbPoint25D )
{
char szCoordinate[256];
OGRPoint *poPoint = (OGRPoint *) poGeometry;
MakeGMLCoordinate( szCoordinate,
poPoint->getX(), poPoint->getY(), poPoint->getZ(),
TRUE );
_GrowBuffer( *pnLength + strlen(szCoordinate) + 70 + nAttrsLength,
ppszText, pnMaxLength );
sprintf( *ppszText + *pnLength,
"<gml:Point%s><gml:coordinates>%s</gml:coordinates></gml:Point>",
szAttributes, szCoordinate );
*pnLength += strlen( *ppszText + *pnLength );
}
/* -------------------------------------------------------------------- */
/* LineString and LinearRing */
/* -------------------------------------------------------------------- */
else if( poGeometry->getGeometryType() == wkbLineString
|| poGeometry->getGeometryType() == wkbLineString25D )
{
int bRing = EQUAL(poGeometry->getGeometryName(),"LINEARRING");
// Buffer for tag name + srsName attribute if set
const size_t nLineTagLength = 16;
char* pszLineTagName = NULL;
pszLineTagName = (char *) CPLMalloc( nLineTagLength + nAttrsLength + 1 );
if( bRing )
{
sprintf( pszLineTagName, "<gml:LinearRing%s>", szAttributes );
AppendString( ppszText, pnLength, pnMaxLength,
pszLineTagName );
}
else
{
sprintf( pszLineTagName, "<gml:LineString%s>", szAttributes );
AppendString( ppszText, pnLength, pnMaxLength,
pszLineTagName );
}
// FREE TAG BUFFER
CPLFree( pszLineTagName );
AppendCoordinateList( (OGRLineString *) poGeometry,
ppszText, pnLength, pnMaxLength );
if( bRing )
AppendString( ppszText, pnLength, pnMaxLength,
"</gml:LinearRing>" );
else
AppendString( ppszText, pnLength, pnMaxLength,
"</gml:LineString>" );
}
/* -------------------------------------------------------------------- */
/* Polygon */
/* -------------------------------------------------------------------- */
else if( poGeometry->getGeometryType() == wkbPolygon
|| poGeometry->getGeometryType() == wkbPolygon25D )
{
OGRPolygon *poPolygon = (OGRPolygon *) poGeometry;
// Buffer for polygon tag name + srsName attribute if set
const size_t nPolyTagLength = 13;
char* pszPolyTagName = NULL;
pszPolyTagName = (char *) CPLMalloc( nPolyTagLength + nAttrsLength + 1 );
// Compose Polygon tag with or without srsName attribute
sprintf( pszPolyTagName, "<gml:Polygon%s>", szAttributes );
AppendString( ppszText, pnLength, pnMaxLength,
pszPolyTagName );
// FREE TAG BUFFER
CPLFree( pszPolyTagName );
// Don't add srsName to polygon rings
if( poPolygon->getExteriorRing() != NULL )
{
AppendString( ppszText, pnLength, pnMaxLength,
"<gml:outerBoundaryIs>" );
if( !OGR2GMLGeometryAppend( poPolygon->getExteriorRing(),
ppszText, pnLength, pnMaxLength,
TRUE ) )
{
return FALSE;
}
AppendString( ppszText, pnLength, pnMaxLength,
"</gml:outerBoundaryIs>" );
}
for( int iRing = 0; iRing < poPolygon->getNumInteriorRings(); iRing++ )
{
OGRLinearRing *poRing = poPolygon->getInteriorRing(iRing);
AppendString( ppszText, pnLength, pnMaxLength,
"<gml:innerBoundaryIs>" );
if( !OGR2GMLGeometryAppend( poRing, ppszText, pnLength,
pnMaxLength, TRUE ) )
return FALSE;
AppendString( ppszText, pnLength, pnMaxLength,
"</gml:innerBoundaryIs>" );
}
AppendString( ppszText, pnLength, pnMaxLength,
"</gml:Polygon>" );
}
/* -------------------------------------------------------------------- */
/* MultiPolygon, MultiLineString, MultiPoint, MultiGeometry */
/* -------------------------------------------------------------------- */
else if( wkbFlatten(poGeometry->getGeometryType()) == wkbMultiPolygon
|| wkbFlatten(poGeometry->getGeometryType()) == wkbMultiLineString
|| wkbFlatten(poGeometry->getGeometryType()) == wkbMultiPoint
|| wkbFlatten(poGeometry->getGeometryType()) == wkbGeometryCollection )
{
OGRGeometryCollection *poGC = (OGRGeometryCollection *) poGeometry;
int iMember;
const char *pszElemClose = NULL;
const char *pszMemberElem = NULL;
// Buffer for opening tag + srsName attribute
char* pszElemOpen = NULL;
if( wkbFlatten(poGeometry->getGeometryType()) == wkbMultiPolygon )
{
pszElemOpen = (char *) CPLMalloc( 13 + nAttrsLength + 1 );
sprintf( pszElemOpen, "MultiPolygon%s>", szAttributes );
pszElemClose = "MultiPolygon>";
pszMemberElem = "polygonMember>";
}
else if( wkbFlatten(poGeometry->getGeometryType()) == wkbMultiLineString )
{
pszElemOpen = (char *) CPLMalloc( 16 + nAttrsLength + 1 );
sprintf( pszElemOpen, "MultiLineString%s>", szAttributes );
pszElemClose = "MultiLineString>";
pszMemberElem = "lineStringMember>";
}
else if( wkbFlatten(poGeometry->getGeometryType()) == wkbMultiPoint )
{
pszElemOpen = (char *) CPLMalloc( 11 + nAttrsLength + 1 );
sprintf( pszElemOpen, "MultiPoint%s>", szAttributes );
pszElemClose = "MultiPoint>";
pszMemberElem = "pointMember>";
}
else
{
pszElemOpen = (char *) CPLMalloc( 19 + nAttrsLength + 1 );
sprintf( pszElemOpen, "MultiGeometry%s>", szAttributes );
pszElemClose = "MultiGeometry>";
pszMemberElem = "geometryMember>";
}
AppendString( ppszText, pnLength, pnMaxLength, "<gml:" );
AppendString( ppszText, pnLength, pnMaxLength, pszElemOpen );
for( iMember = 0; iMember < poGC->getNumGeometries(); iMember++)
{
OGRGeometry *poMember = poGC->getGeometryRef( iMember );
AppendString( ppszText, pnLength, pnMaxLength, "<gml:" );
AppendString( ppszText, pnLength, pnMaxLength, pszMemberElem );
if( !OGR2GMLGeometryAppend( poMember,
ppszText, pnLength, pnMaxLength,
TRUE ) )
{
return FALSE;
}
AppendString( ppszText, pnLength, pnMaxLength, "</gml:" );
AppendString( ppszText, pnLength, pnMaxLength, pszMemberElem );
}
AppendString( ppszText, pnLength, pnMaxLength, "</gml:" );
AppendString( ppszText, pnLength, pnMaxLength, pszElemClose );
// FREE TAG BUFFER
CPLFree( pszElemOpen );
}
else
{
return FALSE;
}
return TRUE;
}
OGRFeature *OGRDXFLayer::TranslateHATCH()
{
char szLineBuf[257];
int nCode;
OGRFeature *poFeature = new OGRFeature( poFeatureDefn );
CPLString osHatchPattern;
int nFillFlag = 0;
OGRGeometryCollection oGC;
while( (nCode = poDS->ReadValue(szLineBuf,sizeof(szLineBuf))) > 0 )
{
switch( nCode )
{
case 70:
nFillFlag = atoi(szLineBuf);
break;
case 2:
osHatchPattern = szLineBuf;
poFeature->SetField( "Text", osHatchPattern.c_str() );
break;
case 91:
{
int nBoundaryPathCount = atoi(szLineBuf);
int iBoundary;
for( iBoundary = 0; iBoundary < nBoundaryPathCount; iBoundary++ )
{
if (CollectBoundaryPath( &oGC ) != OGRERR_NONE)
break;
}
}
break;
default:
TranslateGenericProperty( poFeature, nCode, szLineBuf );
break;
}
}
if( nCode == 0 )
poDS->UnreadValue();
/* -------------------------------------------------------------------- */
/* Try to turn the set of lines into something useful. */
/* -------------------------------------------------------------------- */
OGRErr eErr;
OGRGeometry* poFinalGeom = (OGRGeometry *)
OGRBuildPolygonFromEdges( (OGRGeometryH) &oGC,
TRUE, TRUE, 0.0000001, &eErr );
if( eErr != OGRERR_NONE )
{
delete poFinalGeom;
OGRMultiLineString* poMLS = new OGRMultiLineString();
for(int i=0;i<oGC.getNumGeometries();i++)
poMLS->addGeometry(oGC.getGeometryRef(i));
poFinalGeom = poMLS;
}
ApplyOCSTransformer( poFinalGeom );
poFeature->SetGeometryDirectly( poFinalGeom );
/* -------------------------------------------------------------------- */
/* Work out the color for this feature. For now we just assume */
/* solid fill. We cannot trivially translate the various sorts */
/* of hatching. */
/* -------------------------------------------------------------------- */
CPLString osLayer = poFeature->GetFieldAsString("Layer");
int nColor = 256;
if( oStyleProperties.count("Color") > 0 )
nColor = atoi(oStyleProperties["Color"]);
// Use layer color?
if( nColor < 1 || nColor > 255 )
{
const char *pszValue = poDS->LookupLayerProperty( osLayer, "Color" );
if( pszValue != NULL )
nColor = atoi(pszValue);
}
/* -------------------------------------------------------------------- */
/* Setup the style string. */
/* -------------------------------------------------------------------- */
if( nColor >= 1 && nColor <= 255 )
{
CPLString osStyle;
const unsigned char *pabyDXFColors = ACGetColorTable();
osStyle.Printf( "BRUSH(fc:#%02x%02x%02x)",
pabyDXFColors[nColor*3+0],
pabyDXFColors[nColor*3+1],
pabyDXFColors[nColor*3+2] );
poFeature->SetStyleString( osStyle );
}
return poFeature;
}
static void GDALCollectRingsFromGeometry(
OGRGeometry *poShape,
std::vector<double> &aPointX, std::vector<double> &aPointY,
std::vector<double> &aPointVariant,
std::vector<int> &aPartSize, GDALBurnValueSrc eBurnValueSrc)
{
if( poShape == NULL )
return;
OGRwkbGeometryType eFlatType = wkbFlatten(poShape->getGeometryType());
int i;
if ( eFlatType == wkbPoint )
{
OGRPoint *poPoint = (OGRPoint *) poShape;
int nNewCount = aPointX.size() + 1;
aPointX.reserve( nNewCount );
aPointY.reserve( nNewCount );
aPointX.push_back( poPoint->getX() );
aPointY.push_back( poPoint->getY() );
aPartSize.push_back( 1 );
if( eBurnValueSrc != GBV_UserBurnValue )
{
/*switch( eBurnValueSrc )
{
case GBV_Z:*/
aPointVariant.reserve( nNewCount );
aPointVariant.push_back( poPoint->getZ() );
/*break;
case GBV_M:
aPointVariant.reserve( nNewCount );
aPointVariant.push_back( poPoint->getM() );
}*/
}
}
else if ( eFlatType == wkbLineString )
{
OGRLineString *poLine = (OGRLineString *) poShape;
int nCount = poLine->getNumPoints();
int nNewCount = aPointX.size() + nCount;
aPointX.reserve( nNewCount );
aPointY.reserve( nNewCount );
if( eBurnValueSrc != GBV_UserBurnValue )
aPointVariant.reserve( nNewCount );
for ( i = nCount - 1; i >= 0; i-- )
{
aPointX.push_back( poLine->getX(i) );
aPointY.push_back( poLine->getY(i) );
if( eBurnValueSrc != GBV_UserBurnValue )
{
/*switch( eBurnValueSrc )
{
case GBV_Z:*/
aPointVariant.push_back( poLine->getZ(i) );
/*break;
case GBV_M:
aPointVariant.push_back( poLine->getM(i) );
}*/
}
}
aPartSize.push_back( nCount );
}
else if ( EQUAL(poShape->getGeometryName(),"LINEARRING") )
{
OGRLinearRing *poRing = (OGRLinearRing *) poShape;
int nCount = poRing->getNumPoints();
int nNewCount = aPointX.size() + nCount;
aPointX.reserve( nNewCount );
aPointY.reserve( nNewCount );
if( eBurnValueSrc != GBV_UserBurnValue )
aPointVariant.reserve( nNewCount );
for ( i = nCount - 1; i >= 0; i-- )
{
aPointX.push_back( poRing->getX(i) );
aPointY.push_back( poRing->getY(i) );
}
if( eBurnValueSrc != GBV_UserBurnValue )
{
/*switch( eBurnValueSrc )
{
case GBV_Z:*/
aPointVariant.push_back( poRing->getZ(i) );
/*break;
case GBV_M:
aPointVariant.push_back( poRing->getM(i) );
}*/
}
aPartSize.push_back( nCount );
}
else if( eFlatType == wkbPolygon )
{
OGRPolygon *poPolygon = (OGRPolygon *) poShape;
GDALCollectRingsFromGeometry( poPolygon->getExteriorRing(),
aPointX, aPointY, aPointVariant,
aPartSize, eBurnValueSrc );
for( i = 0; i < poPolygon->getNumInteriorRings(); i++ )
GDALCollectRingsFromGeometry( poPolygon->getInteriorRing(i),
aPointX, aPointY, aPointVariant,
aPartSize, eBurnValueSrc );
}
else if( eFlatType == wkbMultiPoint
|| eFlatType == wkbMultiLineString
|| eFlatType == wkbMultiPolygon
|| eFlatType == wkbGeometryCollection )
{
OGRGeometryCollection *poGC = (OGRGeometryCollection *) poShape;
for( i = 0; i < poGC->getNumGeometries(); i++ )
GDALCollectRingsFromGeometry( poGC->getGeometryRef(i),
aPointX, aPointY, aPointVariant,
aPartSize, eBurnValueSrc );
}
else
{
CPLDebug( "GDAL", "Rasterizer ignoring non-polygonal geometry." );
}
}
/**********************************************************************
* IMapInfoFile::CreateFeature()
*
* Standard OGR CreateFeature implementation. This method is used
* to create a new feature in current dataset
**********************************************************************/
OGRErr IMapInfoFile::CreateFeature(OGRFeature *poFeature)
{
TABFeature *poTABFeature;
OGRGeometry *poGeom;
OGRwkbGeometryType eGType;
OGRErr eErr;
TABPoint *poTABPointFeature = NULL;
TABRegion *poTABRegionFeature = NULL;
TABPolyline *poTABPolylineFeature = NULL;
/*-----------------------------------------------------------------
* MITAB won't accept new features unless they are in a type derived
* from TABFeature... so we have to do our best to map to the right
* feature type based on the geometry type.
*----------------------------------------------------------------*/
poGeom = poFeature->GetGeometryRef();
if( poGeom != NULL )
eGType = poGeom->getGeometryType();
else
eGType = wkbNone;
switch( wkbFlatten(eGType) )
{
/*-------------------------------------------------------------
* POINT
*------------------------------------------------------------*/
case wkbPoint:
poTABFeature = new TABPoint(poFeature->GetDefnRef());
if(poFeature->GetStyleString())
{
poTABPointFeature = (TABPoint*)poTABFeature;
poTABPointFeature->SetSymbolFromStyleString(
poFeature->GetStyleString());
}
break;
/*-------------------------------------------------------------
* REGION
*------------------------------------------------------------*/
case wkbPolygon:
case wkbMultiPolygon:
poTABFeature = new TABRegion(poFeature->GetDefnRef());
if(poFeature->GetStyleString())
{
poTABRegionFeature = (TABRegion*)poTABFeature;
poTABRegionFeature->SetPenFromStyleString(
poFeature->GetStyleString());
poTABRegionFeature->SetBrushFromStyleString(
poFeature->GetStyleString());
}
break;
/*-------------------------------------------------------------
* LINE/PLINE/MULTIPLINE
*------------------------------------------------------------*/
case wkbLineString:
case wkbMultiLineString:
poTABFeature = new TABPolyline(poFeature->GetDefnRef());
if(poFeature->GetStyleString())
{
poTABPolylineFeature = (TABPolyline*)poTABFeature;
poTABPolylineFeature->SetPenFromStyleString(
poFeature->GetStyleString());
}
break;
/*-------------------------------------------------------------
* Collection types that are not directly supported... convert
* to multiple features in output file through recursive calls.
*------------------------------------------------------------*/
case wkbGeometryCollection:
case wkbMultiPoint:
{
OGRErr eStatus = OGRERR_NONE;
int i;
OGRGeometryCollection *poColl = (OGRGeometryCollection*)poGeom;
OGRFeature *poTmpFeature = poFeature->Clone();
for (i=0; eStatus==OGRERR_NONE && i<poColl->getNumGeometries(); i++)
{
poTmpFeature->SetGeometry(poColl->getGeometryRef(i));
eStatus = CreateFeature(poTmpFeature);
}
delete poTmpFeature;
return eStatus;
}
break;
/*-------------------------------------------------------------
* Unsupported type.... convert to MapInfo geometry NONE
*------------------------------------------------------------*/
case wkbUnknown:
default:
poTABFeature = new TABFeature(poFeature->GetDefnRef());
break;
}
if( poGeom != NULL )
poTABFeature->SetGeometryDirectly(poGeom->clone());
for (int i=0; i< poFeature->GetDefnRef()->GetFieldCount(); i++)
{
poTABFeature->SetField(i,poFeature->GetRawFieldRef( i ));
}
eErr = CreateFeature(poTABFeature);
delete poTABFeature;
return eErr;
}
OGRErr OGRWritableDWGLayer::WriteEntity( OGRGeometry *poGeom,
OdDbObjectPtr *ppObjectRet )
{
switch( wkbFlatten(poGeom->getGeometryType()) )
{
case wkbPoint:
{
OGRPoint *poOGRPoint = (OGRPoint *) poGeom;
OdDbPointPtr pPoint = OdDbPoint::createObject();
pPoint->setPosition(
OdGePoint3d(poOGRPoint->getX(), poOGRPoint->getY(),
poOGRPoint->getZ() ) );
pPoint->setLayer( hLayerId, false );
poDS->pMs->appendOdDbEntity( pPoint );
if( ppObjectRet != NULL )
*ppObjectRet = pPoint;
return OGRERR_NONE;
}
case wkbLineString:
{
OGRLineString *poLine = (OGRLineString *) poGeom;
// Add a 2d polyline with vertices.
OdDb2dPolylinePtr p2dPl = OdDb2dPolyline::createObject();
int i;
for (i = 0; i < poLine->getNumPoints(); i++)
{
OdDb2dVertexPtr pV;
OdGePoint3d pos;
pos.x = poLine->getX(i);
pos.y = poLine->getY(i);
pos.z = poLine->getZ(i);
pV = OdDb2dVertex::createObject();
p2dPl->appendVertex(pV);
pV->setPosition(pos);
}
p2dPl->setLayer( hLayerId, false );
poDS->pMs->appendOdDbEntity( p2dPl );
if( ppObjectRet != NULL )
*ppObjectRet = p2dPl;
return OGRERR_NONE;
}
case wkbPolygon:
{
OGRPolygon *poPoly = (OGRPolygon *) poGeom;
int iRing;
OGRErr eErr;
for( iRing = -1; iRing < poPoly->getNumInteriorRings(); iRing++ )
{
OGRLinearRing *poRing;
if( iRing == -1 )
poRing = poPoly->getExteriorRing();
else
poRing = poPoly->getInteriorRing( iRing );
if( iRing == -1 )
eErr = WriteEntity( poRing, ppObjectRet );
else
eErr = WriteEntity( poRing, NULL );
if( eErr != OGRERR_NONE )
return eErr;
}
return OGRERR_NONE;
}
case wkbGeometryCollection:
case wkbMultiPolygon:
case wkbMultiPoint:
case wkbMultiLineString:
{
OGRGeometryCollection *poColl = (OGRGeometryCollection *) poGeom;
int iSubGeom;
OGRErr eErr;
for( iSubGeom=0; iSubGeom < poColl->getNumGeometries(); iSubGeom++ )
{
OGRGeometry *poGeom = poColl->getGeometryRef( iSubGeom );
if( iSubGeom == 0 )
eErr = WriteEntity( poGeom, ppObjectRet );
else
eErr = WriteEntity( poGeom, NULL );
if( eErr != OGRERR_NONE )
return eErr;
}
return OGRERR_NONE;
}
default:
return OGRERR_FAILURE;
}
}