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::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;
}
OGRGeometry* OGRGeometryCollection::getCurveGeometry(
const char* const* papszOptions) const
{
OGRGeometryCollection* poGC =
OGRGeometryFactory::createGeometry(
OGR_GT_GetCurve(getGeometryType()))->toGeometryCollection();
if( poGC == nullptr )
return nullptr;
poGC->assignSpatialReference( getSpatialReference() );
bool bHasCurveGeometry = false;
for( int iGeom = 0; iGeom < nGeomCount; iGeom++ )
{
OGRGeometry* poSubGeom =
papoGeoms[iGeom]->getCurveGeometry(papszOptions);
if( poSubGeom->hasCurveGeometry() )
bHasCurveGeometry = true;
poGC->addGeometryDirectly( poSubGeom );
}
if( !bHasCurveGeometry )
{
delete poGC;
return clone();
}
return poGC;
}
OGRGeometryCollection* make()
{
OGRGeometryCollection* poCollection = new OGRGeometryCollection();
poCollection->addGeometryDirectly(make<OGRPoint>());
poCollection->addGeometryDirectly(make<OGRLinearRing>());
return poCollection;
}
OGRGeometry *OGRGeometryCollection::clone() const
{
OGRGeometryCollection *poNewGC;
poNewGC = new OGRGeometryCollection;
poNewGC->assignSpatialReference( getSpatialReference() );
for( int i = 0; i < nGeomCount; i++ )
{
poNewGC->addGeometry( papoGeoms[i] );
}
return poNewGC;
}
OGRGeometry* OGRGeometryCollection::getLinearGeometry(double dfMaxAngleStepSizeDegrees,
const char* const* papszOptions) const
{
OGRGeometryCollection* poGC = (OGRGeometryCollection*)
OGRGeometryFactory::createGeometry(OGR_GT_GetLinear(getGeometryType()));
if( poGC == NULL )
return NULL;
poGC->assignSpatialReference( getSpatialReference() );
for( int iGeom = 0; iGeom < nGeomCount; iGeom++ )
{
OGRGeometry* poSubGeom = papoGeoms[iGeom]->getLinearGeometry(dfMaxAngleStepSizeDegrees,
papszOptions);
poGC->addGeometryDirectly( poSubGeom );
}
return poGC;
}
// [[Rcpp::export]]
Rcpp::NumericVector CPL_length(Rcpp::List sfc) {
std::vector<OGRGeometry *> g = ogr_from_sfc(sfc, NULL);
Rcpp::NumericVector out(sfc.length());
for (size_t i = 0; i < g.size(); i++) {
OGRwkbGeometryType gt = OGR_GT_Flatten(g[i]->getGeometryType());
if (gt == wkbLineString || gt == wkbCircularString || gt == wkbCompoundCurve || gt == wkbCurve) {
OGRCurve *a = (OGRCurve *) g[i];
out[i] = a->get_Length();
} else {
OGRGeometryCollection *a = (OGRGeometryCollection *) g[i];
out[i] = a->get_Length();
}
delete g[i];
}
return out;
}
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();
}
// [[Rcpp::export]]
Rcpp::List CPL_gdal_linestring_sample(Rcpp::List sfc, Rcpp::List distLst) {
if (sfc.size() != distLst.size())
throw std::invalid_argument("sfc and dist should have equal length");
std::vector<OGRGeometry *> g = ogr_from_sfc(sfc, NULL);
std::vector<OGRGeometry *> out(g.size());
for (size_t i = 0; i < g.size(); i++) {
OGRGeometryCollection *gc = new OGRGeometryCollection;
Rcpp::NumericVector dists = distLst[i];
for (size_t j = 0; j < dists.size(); j++) {
OGRPoint *poPoint = new OGRPoint;
((OGRLineString *) g[i])->Value(dists[j], poPoint);
gc->addGeometry(poPoint);
}
out[i] = OGRGeometryFactory::forceToMultiPoint(gc);
}
Rcpp::List ret = sfc_from_ogr(out, true);
ret.attr("crs") = sfc.attr("crs");
return ret;
}
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;
}
}
OGRGeometryCollection* OGRMSSQLGeometryParser::ReadGeometryCollection(int iShape)
{
int i;
OGRGeometryCollection* poGeomColl = new OGRGeometryCollection();
OGRGeometry* poGeom;
for (i = iShape + 1; i < nNumShapes; i++)
{
poGeom = NULL;
if (ParentOffset(i) == (unsigned int)iShape)
{
switch (ShapeType(i))
{
case ST_POINT:
poGeom = ReadPoint(i);
break;
case ST_LINESTRING:
poGeom = ReadLineString(i);
break;
case ST_POLYGON:
poGeom = ReadPolygon(i);
break;
case ST_MULTIPOINT:
poGeom = ReadMultiPoint(i);
break;
case ST_MULTILINESTRING:
poGeom = ReadMultiLineString(i);
break;
case ST_MULTIPOLYGON:
poGeom = ReadMultiPolygon(i);
break;
case ST_GEOMETRYCOLLECTION:
poGeom = ReadGeometryCollection(i);
break;
}
}
if ( poGeom )
poGeomColl->addGeometryDirectly( poGeom );
}
return poGeomColl;
}
OGRGeometry *OGRGeometryCollection::clone() const
{
OGRGeometryCollection *poNewGC =
OGRGeometryFactory::createGeometry(getGeometryType())->
toGeometryCollection();
poNewGC->assignSpatialReference( getSpatialReference() );
poNewGC->flags = flags;
for( auto&& poSubGeom: *this )
{
if( poNewGC->addGeometry( poSubGeom ) != OGRERR_NONE )
{
delete poNewGC;
return nullptr;
}
}
return poNewGC;
}
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;
}
int OGRDB2GeometryValidator::ValidateMultiLineString(
OGRMultiLineString * poGeom)
{
int i, j;
OGRGeometry* poLineString;
OGRGeometryCollection* poGeometries = NULL;
for (i = 0; i < poGeom->getNumGeometries(); i++)
{
poLineString = poGeom->getGeometryRef(i);
if (poLineString->getGeometryType() != wkbLineString
&& poLineString->getGeometryType() != wkbLineString25D)
{
// non linestring geometry
if (!poGeometries)
{
poGeometries = new OGRGeometryCollection();
for (j = 0; j < i; j++)
poGeometries->addGeometry(poGeom->getGeometryRef(j));
}
if (ValidateGeometry(poLineString))
poGeometries->addGeometry(poLineString);
else
poGeometries->addGeometry(poValidGeometry);
continue;
}
if (!ValidateLineString((OGRLineString*)poLineString))
{
// non valid linestring
if (!poGeometries)
{
poGeometries = new OGRGeometryCollection();
for (j = 0; j < i; j++)
poGeometries->addGeometry(poGeom->getGeometryRef(j));
}
poGeometries->addGeometry(poValidGeometry);
continue;
}
if (poGeometries)
poGeometries->addGeometry(poLineString);
}
if (poGeometries)
{
if (poValidGeometry)
delete poValidGeometry;
poValidGeometry = poGeometries;
}
return (poValidGeometry == NULL);
}
int OGRDB2GeometryValidator::ValidateMultiPolygon(OGRMultiPolygon* poGeom)
{
int i, j;
OGRGeometry* poPolygon;
OGRGeometryCollection* poGeometries = NULL;
for (i = 0; i < poGeom->getNumGeometries(); i++)
{
poPolygon = poGeom->getGeometryRef(i);
if (poPolygon->getGeometryType() != wkbPolygon
&& poPolygon->getGeometryType() != wkbPolygon25D)
{
// non polygon geometry
if (!poGeometries)
{
poGeometries = new OGRGeometryCollection();
for (j = 0; j < i; j++)
poGeometries->addGeometry(poGeom->getGeometryRef(j));
}
if (ValidateGeometry(poPolygon))
poGeometries->addGeometry(poPolygon);
else
poGeometries->addGeometry(poValidGeometry);
continue;
}
if (!ValidatePolygon((OGRPolygon*)poPolygon))
{
// non valid polygon
if (!poGeometries)
{
poGeometries = new OGRGeometryCollection();
for (j = 0; j < i; j++)
poGeometries->addGeometry(poGeom->getGeometryRef(j));
}
poGeometries->addGeometry(poValidGeometry);
continue;
}
if (poGeometries)
poGeometries->addGeometry(poPolygon);
}
if (poGeometries)
{
if (poValidGeometry)
delete poValidGeometry;
poValidGeometry = poGeometries;
}
return poValidGeometry == NULL;
}
int OGRDB2GeometryValidator::ValidateGeometryCollection(
OGRGeometryCollection* poGeom)
{
int i, j;
OGRGeometry* poGeometry;
OGRGeometryCollection* poGeometries = NULL;
for (i = 0; i < poGeom->getNumGeometries(); i++)
{
poGeometry = poGeom->getGeometryRef(i);
if (!ValidateGeometry(poGeometry))
{
// non valid geometry
if (!poGeometries)
{
poGeometries = new OGRGeometryCollection();
for (j = 0; j < i; j++)
poGeometries->addGeometry(poGeom->getGeometryRef(j));
}
if (poValidGeometry)
poGeometries->addGeometry(poValidGeometry);
continue;
}
if (poGeometries)
poGeometries->addGeometry(poGeometry);
}
if (poGeometries)
{
if (poValidGeometry)
delete poValidGeometry;
poValidGeometry = poGeometries;
}
return (poValidGeometry == NULL);
}
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();
}
}
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;
}
}
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 *OGRGeometryCollection::clone() const
{
OGRGeometryCollection *poNewGC;
poNewGC = (OGRGeometryCollection*)
OGRGeometryFactory::createGeometry(getGeometryType());
if( poNewGC == NULL )
return NULL;
poNewGC->assignSpatialReference( getSpatialReference() );
poNewGC->flags = flags;
for( int i = 0; i < nGeomCount; i++ )
{
if( poNewGC->addGeometry( papoGeoms[i] ) != OGRERR_NONE )
{
delete poNewGC;
return NULL;
}
}
return poNewGC;
}
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;
}
int OGRDB2GeometryValidator::ValidatePolygon(OGRPolygon* poGeom)
{
int i,j;
OGRLinearRing* poRing = poGeom->getExteriorRing();
OGRGeometry* poInteriorRing;
if (poRing == NULL)
return FALSE;
OGRGeometryCollection* poGeometries = NULL;
if (!ValidateLinearRing(poRing))
{
if (poGeom->getNumInteriorRings() > 0)
{
poGeometries = new OGRGeometryCollection();
poGeometries->addGeometryDirectly(poValidGeometry);
}
}
for (i = 0; i < poGeom->getNumInteriorRings(); i++)
{
poInteriorRing = poGeom->getInteriorRing(i);
if (!ValidateLinearRing((OGRLinearRing*)poInteriorRing))
{
if (!poGeometries)
{
poGeometries = new OGRGeometryCollection();
poGeometries->addGeometry(poRing);
for (j = 0; j < i; j++)
poGeometries->addGeometry(poGeom->getInteriorRing(j));
}
poGeometries->addGeometry(poValidGeometry);
continue;
}
if (poGeometries)
poGeometries->addGeometry(poInteriorRing);
}
if (poGeometries)
{
if (poValidGeometry)
delete poValidGeometry;
poValidGeometry = poGeometries;
}
return (poValidGeometry == NULL);
}
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;
}
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;
}
OGRGeometry* GML_BuildOGRGeometryFromList(const CPLXMLNode* const * papsGeometry,
int bTryToMakeMultipolygons,
int bInvertAxisOrderIfLatLong,
const char* pszDefaultSRSName,
int bConsiderEPSGAsURN,
int bGetSecondaryGeometryOption,
void* hCacheSRS,
int bFaceHoleNegative)
{
OGRGeometry* poGeom = NULL;
int i;
OGRGeometryCollection* poCollection = NULL;
for(i=0;papsGeometry[i] != NULL;i++)
{
OGRGeometry* poSubGeom = GML2OGRGeometry_XMLNode( papsGeometry[i],
bGetSecondaryGeometryOption,
0, 0, FALSE, TRUE,
bFaceHoleNegative );
if (poSubGeom)
{
if (poGeom == NULL)
poGeom = poSubGeom;
else
{
if (poCollection == NULL)
{
if (bTryToMakeMultipolygons &&
wkbFlatten(poGeom->getGeometryType()) == wkbPolygon &&
wkbFlatten(poSubGeom->getGeometryType()) == wkbPolygon)
{
OGRGeometryCollection* poGeomColl = new OGRMultiPolygon();
poGeomColl->addGeometryDirectly(poGeom);
poGeomColl->addGeometryDirectly(poSubGeom);
poGeom = poGeomColl;
}
else if (bTryToMakeMultipolygons &&
wkbFlatten(poGeom->getGeometryType()) == wkbMultiPolygon &&
wkbFlatten(poSubGeom->getGeometryType()) == wkbPolygon)
{
OGRGeometryCollection* poGeomColl = (OGRGeometryCollection* )poGeom;
poGeomColl->addGeometryDirectly(poSubGeom);
}
else if (bTryToMakeMultipolygons &&
wkbFlatten(poGeom->getGeometryType()) == wkbMultiPolygon &&
wkbFlatten(poSubGeom->getGeometryType()) == wkbMultiPolygon)
{
OGRGeometryCollection* poGeomColl = (OGRGeometryCollection* )poGeom;
OGRGeometryCollection* poGeomColl2 = (OGRGeometryCollection* )poSubGeom;
int nCount = poGeomColl2->getNumGeometries();
int i;
for(i=0;i<nCount;i++)
{
poGeomColl->addGeometry(poGeomColl2->getGeometryRef(i));
}
delete poSubGeom;
}
else if (bTryToMakeMultipolygons &&
wkbFlatten(poGeom->getGeometryType()) == wkbMultiPolygon)
{
delete poGeom;
delete poSubGeom;
return GML_BuildOGRGeometryFromList(papsGeometry, FALSE,
bInvertAxisOrderIfLatLong,
pszDefaultSRSName,
bConsiderEPSGAsURN,
bGetSecondaryGeometryOption,
hCacheSRS);
}
else
{
poCollection = new OGRGeometryCollection();
poCollection->addGeometryDirectly(poGeom);
poGeom = poCollection;
}
}
if (poCollection != NULL)
{
poCollection->addGeometryDirectly(poSubGeom);
}
}
}
}
if( poGeom == NULL )
return NULL;
std::string osWork;
const char* pszSRSName = GML_ExtractSrsNameFromGeometry(papsGeometry, osWork,
bConsiderEPSGAsURN);
const char* pszNameLookup = pszSRSName;
if( pszNameLookup == NULL )
pszNameLookup = pszDefaultSRSName;
if (pszNameLookup != NULL)
{
SRSCache* poSRSCache = (SRSCache*)hCacheSRS;
SRSDesc& oSRSDesc = poSRSCache->Get(pszNameLookup);
poGeom->assignSpatialReference(oSRSDesc.poSRS);
if (oSRSDesc.bAxisInvert && bInvertAxisOrderIfLatLong)
poGeom->swapXY();
}
return poGeom;
}
/**********************************************************************
* 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;
}
OGRGeometry *ILI2Reader::getGeometry(DOMElement *elem, int type) {
OGRGeometryCollection *gm = new OGRGeometryCollection();
DOMElement *childElem = elem;
while (childElem != NULL) {
char* pszTagName = XMLString::transcode(childElem->getTagName());
switch (type) {
case ILI2_COORD_TYPE :
if (cmpStr(ILI2_COORD, pszTagName) == 0)
{
delete gm;
XMLString::release(&pszTagName);
return getPoint(childElem);
}
break;
case ILI2_ARC_TYPE :
// is it possible here? It have to be a ARC or COORD before (getPreviousSibling)
if (cmpStr(ILI2_ARC, pszTagName) == 0)
{
delete gm;
XMLString::release(&pszTagName);
return getArc(childElem);
}
break;
case ILI2_POLYLINE_TYPE :
if (cmpStr(ILI2_POLYLINE, pszTagName) == 0)
{
delete gm;
XMLString::release(&pszTagName);
return getLineString(childElem, FALSE);
}
break;
case ILI2_BOUNDARY_TYPE :
if (cmpStr(ILI2_BOUNDARY, pszTagName) == 0)
{
delete gm;
XMLString::release(&pszTagName);
return getLineString(childElem, FALSE);
}
break;
case ILI2_AREA_TYPE :
if ((cmpStr(ILI2_AREA, pszTagName) == 0) ||
(cmpStr(ILI2_SURFACE, pszTagName) == 0))
{
delete gm;
XMLString::release(&pszTagName);
return getPolygon(childElem);
}
break;
default :
if (type >= ILI2_GEOMCOLL_TYPE) {
int subType = getGeometryTypeOfElem(childElem); //????
gm->addGeometryDirectly(getGeometry(childElem, subType));
}
break;
}
XMLString::release(&pszTagName);
// GEOMCOLL
childElem = (DOMElement *)childElem->getNextSibling();
}
return gm;
}
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;
}
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;
}