OGRErr OGRCompoundCurve::addCurveDirectlyInternal( OGRCurve* poCurve, double dfToleranceEps, int bNeedRealloc ) { if( poCurve->getNumPoints() == 1 ) { CPLError(CE_Failure, CPLE_AppDefined, "Invalid curve: not enough points"); return OGRERR_FAILURE; } const OGRwkbGeometryType eCurveType = wkbFlatten(poCurve->getGeometryType()); if( EQUAL(poCurve->getGeometryName(), "LINEARRING") ) { CPLError(CE_Failure, CPLE_AppDefined, "Linearring not allowed."); return OGRERR_FAILURE; } else if( eCurveType == wkbCompoundCurve ) { CPLError(CE_Failure, CPLE_AppDefined, "Cannot add a compound curve inside a compound curve"); return OGRERR_FAILURE; } if( oCC.nCurveCount > 0 ) { if( oCC.papoCurves[oCC.nCurveCount-1]->IsEmpty() || poCurve->IsEmpty() ) { CPLError(CE_Failure, CPLE_AppDefined, "Non contiguous curves"); return OGRERR_FAILURE; } OGRPoint end; OGRPoint start; oCC.papoCurves[oCC.nCurveCount-1]->EndPoint(&end); poCurve->StartPoint(&start); if( fabs(end.getX() - start.getX()) > dfToleranceEps || fabs(end.getY() - start.getY()) > dfToleranceEps || fabs(end.getZ() - start.getZ()) > dfToleranceEps ) { poCurve->EndPoint(&start); if( fabs(end.getX() - start.getX()) > dfToleranceEps || fabs(end.getY() - start.getY()) > dfToleranceEps || fabs(end.getZ() - start.getZ()) > dfToleranceEps ) { CPLError(CE_Failure, CPLE_AppDefined, "Non contiguous curves"); return OGRERR_FAILURE; } CPLDebug("GML", "reversing curve"); ((OGRSimpleCurve*)poCurve)->reversePoints(); } // Patch so that it matches exactly. ((OGRSimpleCurve*)poCurve)->setPoint(0, &end); } return oCC.addCurveDirectly(this, poCurve, bNeedRealloc); }
osg::Geometry* multiPointToDrawable(OGRMultiPoint* mpoint) const { osg::Geometry* geom = new osg::Geometry; osg::Geometry* pointGeom = new osg::Geometry(); osg::Vec3Array* vertices = new osg::Vec3Array(); vertices->reserve(mpoint->getNumGeometries()); for (int i = 0; i < mpoint->getNumGeometries(); i++ ) { OGRGeometry* ogrGeom = mpoint->getGeometryRef(i); OGRwkbGeometryType ogrGeomType = ogrGeom->getGeometryType(); if (wkbPoint != ogrGeomType && wkbPoint25D != ogrGeomType) continue; // skip OGRPoint* points = static_cast<OGRPoint*>(ogrGeom); vertices->push_back(osg::Vec3(points->getX(), points->getY(), points->getZ())); } pointGeom->setVertexArray(vertices); pointGeom->addPrimitiveSet(new osg::DrawArrays(osg::PrimitiveSet::POINTS, 0, vertices->size())); if (pointGeom->getVertexArray()) { OSG_INFO << "osgOgrFeature::multiPointToDrawable " << geom->getVertexArray()->getNumElements() << " vertexes"<< std::endl; } return pointGeom; }
OGRBoolean OGRPoint::Equals( OGRGeometry * poOther ) const { if( poOther== this ) return TRUE; if( poOther->getGeometryType() != getGeometryType() ) return FALSE; OGRPoint *poOPoint = dynamic_cast<OGRPoint *>(poOther); if( poOPoint == NULL ) { CPLError(CE_Fatal, CPLE_AppDefined, "dynamic_cast failed. Expected OGRPoint."); return FALSE; } if( flags != poOPoint->flags ) return FALSE; if( IsEmpty() ) return TRUE; // Should eventually test the SRS. if( poOPoint->getX() != getX() || poOPoint->getY() != getY() || poOPoint->getZ() != getZ() ) return FALSE; return TRUE; }
OGRErr GTMWaypointLayer::CreateFeature (OGRFeature *poFeature) { FILE* fp = poDS->getOutputFP(); if (fp == NULL) return CE_Failure; OGRGeometry *poGeom = poFeature->GetGeometryRef(); if ( poGeom == NULL ) { CPLError( CE_Failure, CPLE_AppDefined, "Features without geometry not supported by GTM writer in waypoints layer." ); return OGRERR_FAILURE; } if (NULL != poCT) { poGeom = poGeom->clone(); poGeom->transform( poCT ); } switch( poGeom->getGeometryType() ) { case wkbPoint: case wkbPoint25D: { OGRPoint* point = (OGRPoint*)poGeom; double lat = point->getY(); double lon = point->getX(); CheckAndFixCoordinatesValidity(lat, lon); poDS->checkBounds((float)lat, (float)lon); writeDouble(fp, lat); writeDouble(fp, lon); float altitude = 0.0; if (poGeom->getGeometryType() == wkbPoint25D) altitude = (float) point->getZ(); WriteFeatureAttributes(poFeature, altitude); break; } default: { CPLError( CE_Failure, CPLE_NotSupported, "Geometry type of `%s' not supported for 'waypoint' element.\n", OGRGeometryTypeToName(poGeom->getGeometryType()) ); return OGRERR_FAILURE; } } if (NULL != poCT) delete poGeom; return OGRERR_NONE; }
osg::Geometry* polygonToDrawable(OGRPolygon* polygon) const { osg::Geometry* geom = new osg::Geometry(); osg::Vec3Array* vertices = new osg::Vec3Array(); geom->setVertexArray(vertices); { OGRLinearRing *ring = polygon->getExteriorRing(); OGRPoint point; for(int i = 0; i < ring->getNumPoints(); i++) { ring->getPoint(i, &point); vertices->push_back(osg::Vec3(point.getX(), point.getY(), point.getZ())); } geom->addPrimitiveSet(new osg::DrawArrays(osg::PrimitiveSet::LINE_LOOP, 0, vertices->size())); } if (polygon->getNumInteriorRings()) { for (int i = 0; i < polygon->getNumInteriorRings(); i++) { OGRLinearRing *ring = polygon->getInteriorRing(i); OGRPoint point; for (int j = 0; j < ring->getNumPoints(); j++) { ring->getPoint(j, &point); vertices->push_back(osg::Vec3(point.getX(), point.getY(), point.getZ())); } geom->addPrimitiveSet(new osg::DrawArrays(osg::PrimitiveSet::LINE_LOOP, vertices->size()-ring->getNumPoints() , ring->getNumPoints())); } } osgUtil::Tessellator tsl; tsl.setTessellationType(osgUtil::Tessellator::TESS_TYPE_GEOMETRY); tsl.setBoundaryOnly(false); tsl.retessellatePolygons(*geom); osg::Vec3Array* array = triangulizeGeometry(geom); geom->setVertexArray(array); geom->removePrimitiveSet(0,geom->getNumPrimitiveSets()); geom->addPrimitiveSet(new osg::DrawArrays(osg::PrimitiveSet::TRIANGLES, 0, array->size())); return geom; }
inline Usul::Math::Vec3d convertAndTransform ( const OGRPoint& point, OGRCoordinateTransformation* transform, double verticalOffset ) { // Declare the point. Usul::Math::Vec3d p ( point.getX(), point.getY(), point.getZ() + verticalOffset ); // Transform the point. if ( 0x0 != transform ) { transform->Transform ( 1, &p[0], &p[1], &p[2] ); } return p; }
OGRErr OGRDXFWriterLayer::WriteINSERT( OGRFeature *poFeature ) { WriteValue( 0, "INSERT" ); WriteCore( poFeature ); WriteValue( 100, "AcDbEntity" ); WriteValue( 100, "AcDbBlockReference" ); WriteValue( 2, poFeature->GetFieldAsString("BlockName") ); /* -------------------------------------------------------------------- */ /* Write location. */ /* -------------------------------------------------------------------- */ OGRPoint *poPoint = (OGRPoint *) poFeature->GetGeometryRef(); WriteValue( 10, poPoint->getX() ); if( !WriteValue( 20, poPoint->getY() ) ) return OGRERR_FAILURE; if( poPoint->getGeometryType() == wkbPoint25D ) { if( !WriteValue( 30, poPoint->getZ() ) ) return OGRERR_FAILURE; } /* -------------------------------------------------------------------- */ /* Write scaling. */ /* -------------------------------------------------------------------- */ int nScaleCount; const double *padfScale = poFeature->GetFieldAsDoubleList( "BlockScale", &nScaleCount ); if( nScaleCount == 3 ) { WriteValue( 41, padfScale[0] ); WriteValue( 42, padfScale[1] ); WriteValue( 43, padfScale[2] ); } /* -------------------------------------------------------------------- */ /* Write rotation. */ /* -------------------------------------------------------------------- */ double dfAngle = poFeature->GetFieldAsDouble( "BlockAngle" ); if( dfAngle != 0.0 ) { WriteValue( 50, dfAngle ); // degrees } return OGRERR_NONE; }
void OGRLinearRing::reverseWindingOrder() { int pos = 0; OGRPoint tempPoint; for( int i = 0; i < nPointCount / 2; i++ ) { getPoint( i, &tempPoint ); pos = nPointCount - i - 1; setPoint( i, getX(pos), getY(pos), getZ(pos) ); setPoint( pos, tempPoint.getX(), tempPoint.getY(), tempPoint.getZ() ); } }
osg::Geometry* linearRingToDrawable(OGRLinearRing* ring) const { osg::Geometry* contourGeom = new osg::Geometry(); osg::Vec3Array* vertices = new osg::Vec3Array(); OGRPoint point; for(int j = 0; j < ring->getNumPoints(); j++) { ring->getPoint(j, &point); vertices->push_back(osg::Vec3(point.getX(), point.getY(),point.getZ())); } contourGeom->setVertexArray(vertices); contourGeom->addPrimitiveSet(new osg::DrawArrays(osg::PrimitiveSet::LINE_LOOP, 0, vertices->size())); return contourGeom; }
OGRErr OGRMultiPoint::exportToWkt( char ** ppszDstText ) const { int nMaxString = getNumGeometries() * 20 + 128; int nRetLen = 0; if( getNumGeometries() == 0 ) { *ppszDstText = CPLStrdup("MULTIPOINT(EMPTY)"); return OGRERR_NONE; } *ppszDstText = (char *) VSIMalloc( nMaxString ); if( *ppszDstText == NULL ) return OGRERR_NOT_ENOUGH_MEMORY; sprintf( *ppszDstText, "%s (", getGeometryName() ); for( int i = 0; i < getNumGeometries(); i++ ) { OGRPoint *poPoint = (OGRPoint *) getGeometryRef( i ); if( i > 0 ) strcat( *ppszDstText + nRetLen, "," ); nRetLen += strlen(*ppszDstText + nRetLen); if( nMaxString < nRetLen + 100 ) { nMaxString = nMaxString * 2; *ppszDstText = (char *) CPLRealloc(*ppszDstText,nMaxString); } if( poPoint->getCoordinateDimension() == 3 ) OGRMakeWktCoordinate( *ppszDstText + nRetLen, poPoint->getX(), poPoint->getY(), poPoint->getZ() ); else OGRMakeWktCoordinate( *ppszDstText + nRetLen, poPoint->getX(), poPoint->getY(), 0.0 ); } strcat( *ppszDstText+nRetLen, ")" ); return OGRERR_NONE; }
osg::ref_ptr<osg::Group> MapExtruder::osg_assemble() { osg::ref_ptr<osg::Group> osg = new osg::Group; osg::ref_ptr<osg::Node> surface = osgDB::readNodeFile(_map2dFile); ExtrudeVisitor extrude(_height); surface->accept(extrude); osg->addChild(surface); int n = _sides ->getNumGeometries(); osg::ref_ptr<osg::Geode> geode = new osg::Geode; for(int i=0;i<n;i++) { osg::ref_ptr<osg::Geometry> geom = new osg::Geometry; osg::ref_ptr<osg::Vec3Array> verts = new osg::Vec3Array; std::vector<OGRPoint> points; OGRLinearRing *ring = ((OGRPolygon*)_sides->getGeometryRef(i))->getExteriorRing(); int m = ring->getNumPoints(); for(int j=0;j<m;j++) { OGRPoint pt; ring->getPoint(j,&pt); verts->push_back(osg::Vec3(pt.getX(),pt.getY(),pt.getZ())); } geom->setVertexArray(verts); osg::Vec4Array* colors = new osg::Vec4Array; colors->push_back(YELLOW); geom->setColorArray(colors); geom->setColorBinding(osg::Geometry::BIND_OVERALL); geom->addPrimitiveSet(new osg::DrawArrays(osg::PrimitiveSet::POLYGON,0,m)); geode->addDrawable(geom); } osg->addChild(geode); return osg; }
OGRErr OGRDXFWriterLayer::WritePOINT( OGRFeature *poFeature ) { WriteValue( 0, "POINT" ); WriteCore( poFeature ); WriteValue( 100, "AcDbEntity" ); WriteValue( 100, "AcDbPoint" ); // Write style pen color OGRStyleTool *poTool = nullptr; OGRStyleMgr oSM; if( poFeature->GetStyleString() != nullptr ) { oSM.InitFromFeature( poFeature ); if( oSM.GetPartCount() > 0 ) poTool = oSM.GetPart(0); } if( poTool && poTool->GetType() == OGRSTCPen ) { OGRStylePen *poPen = (OGRStylePen *) poTool; GBool bDefault; if( poPen->Color(bDefault) != nullptr && !bDefault ) WriteValue( 62, ColorStringToDXFColor( poPen->Color(bDefault) ) ); } delete poTool; OGRPoint *poPoint = poFeature->GetGeometryRef()->toPoint(); WriteValue( 10, poPoint->getX() ); if( !WriteValue( 20, poPoint->getY() ) ) return OGRERR_FAILURE; if( poPoint->getGeometryType() == wkbPoint25D ) { if( !WriteValue( 30, poPoint->getZ() ) ) return OGRERR_FAILURE; } return OGRERR_NONE; }
OGRBoolean OGRPoint::Equals( OGRGeometry * poOther ) const { OGRPoint *poOPoint = (OGRPoint *) poOther; if( poOPoint== this ) return TRUE; if( poOther->getGeometryType() != getGeometryType() ) return FALSE; // we should eventually test the SRS. if( poOPoint->getX() != getX() || poOPoint->getY() != getY() || poOPoint->getZ() != getZ() ) return FALSE; else return TRUE; }
OGRErr OGRDXFWriterLayer::WritePOINT( OGRFeature *poFeature ) { WriteValue( 0, "POINT" ); WriteCore( poFeature ); WriteValue( 100, "AcDbEntity" ); WriteValue( 100, "AcDbPoint" ); OGRPoint *poPoint = (OGRPoint *) poFeature->GetGeometryRef(); WriteValue( 10, poPoint->getX() ); if( !WriteValue( 20, poPoint->getY() ) ) return OGRERR_FAILURE; if( poPoint->getGeometryType() == wkbPoint25D ) { if( !WriteValue( 30, poPoint->getZ() ) ) return OGRERR_FAILURE; } return OGRERR_NONE; }
void OGRLinearRing::reverseWindingOrder() { int pos = 0; OGRPoint tempPoint; for( int i = 0; i < nPointCount / 2; i++ ) { getPoint( i, &tempPoint ); pos = nPointCount - i - 1; if( getCoordinateDimension() == 2 ) { setPoint( i, getX(pos), getY(pos) ); setPoint( pos, tempPoint.getX(), tempPoint.getY() ); } else { setPoint( i, getX(pos), getY(pos), getZ(pos) ); setPoint( pos, tempPoint.getX(), tempPoint.getY(), tempPoint.getZ() ); } } }
OGRBoolean OGRPoint::Equals( OGRGeometry * poOther ) const { if( poOther== this ) return TRUE; if( poOther->getGeometryType() != getGeometryType() ) return FALSE; OGRPoint *poOPoint = (OGRPoint *) poOther; if ( nCoordDimension != poOPoint->nCoordDimension ) return FALSE; if ( IsEmpty() ) return TRUE; // we should eventually test the SRS. if( poOPoint->getX() != getX() || poOPoint->getY() != getY() || poOPoint->getZ() != getZ() ) return FALSE; else return TRUE; }
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; }
OGRErr OGRILI1Layer::ICreateFeature( OGRFeature *poFeature ) { static long tid = -1; //system generated TID (must be unique within table) VSIFPrintf( poDS->GetTransferFile(), "OBJE" ); if ( poFeatureDefn->GetFieldCount() && !EQUAL(poFeatureDefn->GetFieldDefn(0)->GetNameRef(), "TID") ) { //Input is not generated from an Interlis 1 source if (poFeature->GetFID() != OGRNullFID) tid = (int)poFeature->GetFID(); else ++tid; VSIFPrintf( poDS->GetTransferFile(), " %ld", tid ); //Embedded geometry if( poFeature->GetGeometryRef() != NULL ) { OGRGeometry *poGeometry = poFeature->GetGeometryRef(); // 2D Point if( poGeometry->getGeometryType() == wkbPoint ) { OGRPoint *poPoint = (OGRPoint *) poGeometry; VSIFPrintf( poDS->GetTransferFile(), " %s", d2str(poPoint->getX()) ); VSIFPrintf( poDS->GetTransferFile(), " %s", d2str(poPoint->getY()) ); } // 3D Point else if( poGeometry->getGeometryType() == wkbPoint25D ) { OGRPoint *poPoint = (OGRPoint *) poGeometry; VSIFPrintf( poDS->GetTransferFile(), " %s", d2str(poPoint->getX()) ); VSIFPrintf( poDS->GetTransferFile(), " %s", d2str(poPoint->getY()) ); VSIFPrintf( poDS->GetTransferFile(), " %s", d2str(poPoint->getZ()) ); } } } // Write all fields. for(int iField = 0; iField < poFeatureDefn->GetFieldCount(); iField++ ) { if ( poFeature->IsFieldSet( iField ) ) { const char *pszRaw = poFeature->GetFieldAsString( iField ); if (poFeatureDefn->GetFieldDefn( iField )->GetType() == OFTString) { //Interlis 1 encoding is ISO 8859-1 (Latin1) -> Recode from UTF-8 char* pszString = CPLRecode(pszRaw, CPL_ENC_UTF8, CPL_ENC_ISO8859_1); //Replace spaces for(size_t i=0; i<strlen(pszString); i++ ) { if (pszString[i] == ' ') pszString[i] = '_'; } VSIFPrintf( poDS->GetTransferFile(), " %s", pszString ); CPLFree( pszString ); } else { VSIFPrintf( poDS->GetTransferFile(), " %s", pszRaw ); } } else { VSIFPrintf( poDS->GetTransferFile(), " @" ); } } VSIFPrintf( poDS->GetTransferFile(), "\n" ); // Write out Geometry if( poFeature->GetGeometryRef() != NULL ) { GeometryAppend(poFeature->GetGeometryRef()); } return OGRERR_NONE; }
OGRErr OGRPCIDSKLayer::ISetFeature( OGRFeature *poFeature ) { PCIDSK::ShapeId id = (PCIDSK::ShapeId) poFeature->GetFID(); /* -------------------------------------------------------------------- */ /* Translate attribute fields. */ /* -------------------------------------------------------------------- */ try { int iPCI; std::vector<PCIDSK::ShapeField> aoPCIFields; aoPCIFields.resize(poVecSeg->GetFieldCount()); for( iPCI = 0; iPCI < poVecSeg->GetFieldCount(); iPCI++ ) { int iOGR; iOGR = poFeatureDefn->GetFieldIndex( poVecSeg->GetFieldName(iPCI).c_str() ); if( iOGR == -1 ) continue; switch( poVecSeg->GetFieldType(iPCI) ) { case PCIDSK::FieldTypeInteger: aoPCIFields[iPCI].SetValue( poFeature->GetFieldAsInteger( iOGR ) ); break; case PCIDSK::FieldTypeFloat: aoPCIFields[iPCI].SetValue( (float) poFeature->GetFieldAsDouble( iOGR ) ); break; case PCIDSK::FieldTypeDouble: aoPCIFields[iPCI].SetValue( (double) poFeature->GetFieldAsDouble( iOGR ) ); break; case PCIDSK::FieldTypeString: aoPCIFields[iPCI].SetValue( poFeature->GetFieldAsString( iOGR ) ); break; case PCIDSK::FieldTypeCountedInt: { int nCount; const int *panList = poFeature->GetFieldAsIntegerList( iOGR, &nCount ); std::vector<PCIDSK::int32> anList; anList.resize( nCount ); memcpy( &(anList[0]), panList, 4 * anList.size() ); aoPCIFields[iPCI].SetValue( anList ); } break; default: CPLAssert( FALSE ); break; } } if( poVecSeg->GetFieldCount() > 0 ) poVecSeg->SetFields( id, aoPCIFields ); /* -------------------------------------------------------------------- */ /* Translate the geometry. */ /* -------------------------------------------------------------------- */ std::vector<PCIDSK::ShapeVertex> aoVertices; OGRGeometry *poGeometry = poFeature->GetGeometryRef(); if( poGeometry == NULL ) { } else if( wkbFlatten(poGeometry->getGeometryType()) == wkbPoint ) { OGRPoint *poPoint = (OGRPoint *) poGeometry; aoVertices.resize(1); aoVertices[0].x = poPoint->getX(); aoVertices[0].y = poPoint->getY(); aoVertices[0].z = poPoint->getZ(); } else if( wkbFlatten(poGeometry->getGeometryType()) == wkbLineString ) { OGRLineString *poLS = (OGRLineString *) poGeometry; unsigned int i; aoVertices.resize(poLS->getNumPoints()); for( i = 0; i < aoVertices.size(); i++ ) { aoVertices[i].x = poLS->getX(i); aoVertices[i].y = poLS->getY(i); aoVertices[i].z = poLS->getZ(i); } } else { CPLDebug( "PCIDSK", "Unsupported geometry type in SetFeature(): %s", poGeometry->getGeometryName() ); } poVecSeg->SetVertices( id, aoVertices ); } /* try */ /* -------------------------------------------------------------------- */ /* Trap exceptions and report as CPL errors. */ /* -------------------------------------------------------------------- */ catch( PCIDSK::PCIDSKException ex ) { CPLError( CE_Failure, CPLE_AppDefined, "%s", ex.what() ); return OGRERR_FAILURE; } catch(...) { CPLError( CE_Failure, CPLE_AppDefined, "Non-PCIDSK exception trapped." ); return OGRERR_FAILURE; } return OGRERR_NONE; }
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; }
OGRErr OGRILI1Layer::CreateFeature( OGRFeature *poFeature ) { static long tid = -1; //system generated TID (must be unique within table) VSIFPrintf( poDS->GetTransferFile(), "OBJE" ); if ( !EQUAL(poFeatureDefn->GetFieldDefn(0)->GetNameRef(), "TID") ) { //Input is not generated from an Interlis 1 source if (poFeature->GetFID() != OGRNullFID) tid = poFeature->GetFID(); else ++tid; VSIFPrintf( poDS->GetTransferFile(), " %ld", tid ); //Embedded geometry if( poFeature->GetGeometryRef() != NULL ) { OGRGeometry *poGeometry = poFeature->GetGeometryRef(); // 2D Point if( poGeometry->getGeometryType() == wkbPoint ) { OGRPoint *poPoint = (OGRPoint *) poGeometry; VSIFPrintf( poDS->GetTransferFile(), " %s", d2str(poPoint->getX()) ); VSIFPrintf( poDS->GetTransferFile(), " %s", d2str(poPoint->getY()) ); } // 3D Point else if( poGeometry->getGeometryType() == wkbPoint25D ) { OGRPoint *poPoint = (OGRPoint *) poGeometry; VSIFPrintf( poDS->GetTransferFile(), " %s", d2str(poPoint->getX()) ); VSIFPrintf( poDS->GetTransferFile(), " %s", d2str(poPoint->getY()) ); VSIFPrintf( poDS->GetTransferFile(), " %s", d2str(poPoint->getZ()) ); } } } // Write all fields. for(int iField = 0; iField < poFeatureDefn->GetFieldCount(); iField++ ) { if ( !EQUAL(poFeatureDefn->GetFieldDefn(iField)->GetNameRef(), "ILI_Geometry") ) { if ( poFeature->IsFieldSet( iField ) ) { const char *pszRaw = poFeature->GetFieldAsString( iField ); VSIFPrintf( poDS->GetTransferFile(), " %s", pszRaw ); } else { VSIFPrintf( poDS->GetTransferFile(), " @" ); } } } VSIFPrintf( poDS->GetTransferFile(), "\n" ); // Write out Geometry if( poFeature->GetGeometryRef() != NULL ) { if (EQUAL(poFeatureDefn->GetFieldDefn(poFeatureDefn->GetFieldCount()-1)->GetNameRef(), "ILI_Geometry")) { //Write original ILI geometry VSIFPrintf( poDS->GetTransferFile(), "%s", poFeature->GetFieldAsString( poFeatureDefn->GetFieldCount()-1 ) ); } else { //Convert to ILI geometry GeometryAppend(poFeature->GetGeometryRef()); } } return OGRERR_NONE; }
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; }
OGRErr OGRCSVLayer::CreateFeature( OGRFeature *poNewFeature ) { int iField; if( !bInWriteMode ) { CPLError( CE_Failure, CPLE_AppDefined, "The CreateFeature() operation is not permitted on a read-only CSV." ); return OGRERR_FAILURE; } /* If we need rewind, it means that we have just written a feature before */ /* so there's no point seeking to the end of the file, as we're already */ /* at the end */ int bNeedSeekEnd = !bNeedRewindBeforeRead; bNeedRewindBeforeRead = TRUE; /* -------------------------------------------------------------------- */ /* Write field names if we haven't written them yet. */ /* Write .csvt file if needed */ /* -------------------------------------------------------------------- */ if( bNew ) { OGRErr eErr = WriteHeader(); if (eErr != OGRERR_NONE) return eErr; bNeedSeekEnd = FALSE; } if (fpCSV == NULL) return OGRERR_FAILURE; /* -------------------------------------------------------------------- */ /* Make sure we are at the end of the file. */ /* -------------------------------------------------------------------- */ if (bNeedSeekEnd) { if (bFirstFeatureAppendedDuringSession) { /* Add a newline character to the end of the file if necessary */ bFirstFeatureAppendedDuringSession = FALSE; VSIFSeekL( fpCSV, 0, SEEK_END ); VSIFSeekL( fpCSV, VSIFTellL(fpCSV) - 1, SEEK_SET); char chLast; VSIFReadL( &chLast, 1, 1, fpCSV ); VSIFSeekL( fpCSV, 0, SEEK_END ); if (chLast != '\n') { if( bUseCRLF ) VSIFPutcL( 13, fpCSV ); VSIFPutcL( '\n', fpCSV ); } } else { VSIFSeekL( fpCSV, 0, SEEK_END ); } } /* -------------------------------------------------------------------- */ /* Write out the geometry */ /* -------------------------------------------------------------------- */ if (eGeometryFormat == OGR_CSV_GEOM_AS_WKT) { OGRGeometry *poGeom = poNewFeature->GetGeometryRef(); char* pszWKT = NULL; if (poGeom && poGeom->exportToWkt(&pszWKT) == OGRERR_NONE) { VSIFPrintfL( fpCSV, "\"%s\"", pszWKT); } else { VSIFPrintfL( fpCSV, "\"\""); } CPLFree(pszWKT); if (poFeatureDefn->GetFieldCount() > 0) VSIFPrintfL( fpCSV, "%c", chDelimiter); } else if (eGeometryFormat == OGR_CSV_GEOM_AS_XYZ || eGeometryFormat == OGR_CSV_GEOM_AS_XY || eGeometryFormat == OGR_CSV_GEOM_AS_YX) { OGRGeometry *poGeom = poNewFeature->GetGeometryRef(); if (poGeom && wkbFlatten(poGeom->getGeometryType()) == wkbPoint) { OGRPoint* poPoint = (OGRPoint*) poGeom; char szBuffer[75]; if (eGeometryFormat == OGR_CSV_GEOM_AS_XYZ ) OGRMakeWktCoordinate(szBuffer, poPoint->getX(), poPoint->getY(), poPoint->getZ(), 3); else if (eGeometryFormat == OGR_CSV_GEOM_AS_XY ) OGRMakeWktCoordinate(szBuffer, poPoint->getX(), poPoint->getY(), 0, 2); else OGRMakeWktCoordinate(szBuffer, poPoint->getY(), poPoint->getX(), 0, 2); char* pc = szBuffer; while(*pc != '\0') { if (*pc == ' ') *pc = chDelimiter; pc ++; } VSIFPrintfL( fpCSV, "%s", szBuffer ); } else { VSIFPrintfL( fpCSV, "%c", chDelimiter ); if (eGeometryFormat == OGR_CSV_GEOM_AS_XYZ) VSIFPrintfL( fpCSV, "%c", chDelimiter ); } if (poFeatureDefn->GetFieldCount() > 0) VSIFPrintfL( fpCSV, "%c", chDelimiter ); } /* -------------------------------------------------------------------- */ /* Write out all the field values. */ /* -------------------------------------------------------------------- */ int bNonEmptyLine = FALSE; for( iField = 0; iField < poFeatureDefn->GetFieldCount(); iField++ ) { char *pszEscaped; if( iField > 0 ) VSIFPrintfL( fpCSV, "%c", chDelimiter ); if (poFeatureDefn->GetFieldDefn(iField)->GetType() == OFTReal) { pszEscaped = CPLStrdup(poNewFeature->GetFieldAsString(iField)); /* Use point as decimal separator */ char* pszComma = strchr(pszEscaped, ','); if (pszComma) *pszComma = '.'; } else { pszEscaped = CPLEscapeString( poNewFeature->GetFieldAsString(iField), -1, CPLES_CSV ); } int nLen = (int)strlen(pszEscaped); bNonEmptyLine |= (nLen != 0); VSIFWriteL( pszEscaped, 1, nLen, fpCSV ); CPLFree( pszEscaped ); } if( poFeatureDefn->GetFieldCount() == 1 && !bNonEmptyLine ) VSIFPrintfL( fpCSV, "%c", chDelimiter ); if( bUseCRLF ) VSIFPutcL( 13, fpCSV ); VSIFPutcL( '\n', fpCSV ); return OGRERR_NONE; }
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; }
OGRErr OGROCIWritableLayer::TranslateElementGroup( OGRGeometry *poGeometry ) { switch( wkbFlatten(poGeometry->getGeometryType()) ) { case wkbPoint: { OGRPoint *poPoint = (OGRPoint *) poGeometry; PushElemInfo( nOrdinalCount+1, 1, 1 ); PushOrdinal( poPoint->getX() ); PushOrdinal( poPoint->getY() ); if( nDimension == 3 ) PushOrdinal( poPoint->getZ() ); return OGRERR_NONE; } case wkbLineString: { OGRLineString *poLine = (OGRLineString *) poGeometry; int iVert; PushElemInfo( nOrdinalCount+1, 2, 1 ); for( iVert = 0; iVert < poLine->getNumPoints(); iVert++ ) { PushOrdinal( poLine->getX(iVert) ); PushOrdinal( poLine->getY(iVert) ); if( nDimension == 3 ) PushOrdinal( poLine->getZ(iVert) ); } return OGRERR_NONE; } case wkbPolygon: { OGRPolygon *poPoly = (OGRPolygon *) poGeometry; int iRing; for( iRing = -1; iRing < poPoly->getNumInteriorRings(); iRing++ ) { OGRLinearRing *poRing; int iVert; if( iRing == -1 ) poRing = poPoly->getExteriorRing(); else poRing = poPoly->getInteriorRing(iRing); if( iRing == -1 ) PushElemInfo( nOrdinalCount+1, 1003, 1 ); else PushElemInfo( nOrdinalCount+1, 2003, 1 ); if( (iRing == -1 && poRing->isClockwise()) || (iRing != -1 && !poRing->isClockwise()) ) { for( iVert = poRing->getNumPoints()-1; iVert >= 0; iVert-- ) { PushOrdinal( poRing->getX(iVert) ); PushOrdinal( poRing->getY(iVert) ); if( nDimension == 3 ) PushOrdinal( poRing->getZ(iVert) ); } } else { for( iVert = 0; iVert < poRing->getNumPoints(); iVert++ ) { PushOrdinal( poRing->getX(iVert) ); PushOrdinal( poRing->getY(iVert) ); if( nDimension == 3 ) PushOrdinal( poRing->getZ(iVert) ); } } } return OGRERR_NONE; } default: { return OGRERR_FAILURE; } } }
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; }
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; }
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; }
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; } }
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." ); } }