OGRFeature *OGROpenAirLabelLayer::GetNextRawFeature() { const char* pszLine; double dfLat = 0, dfLon = 0; int bHasCoord = FALSE; while(TRUE) { pszLine = CPLReadLine2L(fpOpenAir, 1024, NULL); if (pszLine == NULL) return NULL; if (pszLine[0] == '*' || pszLine[0] == '\0') continue; if (EQUALN(pszLine, "AC ", 3)) { if (osCLASS.size() != 0) { osNAME = ""; osCEILING = ""; osFLOOR = ""; } osCLASS = pszLine + 3; } else if (EQUALN(pszLine, "AN ", 3)) osNAME = pszLine + 3; else if (EQUALN(pszLine, "AH ", 3)) osCEILING = pszLine + 3; else if (EQUALN(pszLine, "AL ", 3)) osFLOOR = pszLine + 3; else if (EQUALN(pszLine, "AT ", 3)) { bHasCoord = OGROpenAirGetLatLon(pszLine + 3, dfLat, dfLon); break; } } OGRFeature* poFeature = new OGRFeature(poFeatureDefn); poFeature->SetField(0, osCLASS.c_str()); poFeature->SetField(1, osNAME.c_str()); poFeature->SetField(2, osFLOOR.c_str()); poFeature->SetField(3, osCEILING.c_str()); CPLString osStyle; osStyle.Printf("LABEL(t:\"%s\")", osNAME.c_str()); poFeature->SetStyleString(osStyle.c_str()); if (bHasCoord) { OGRPoint* poPoint = new OGRPoint(dfLon, dfLat); poPoint->assignSpatialReference(poSRS); poFeature->SetGeometryDirectly(poPoint); } poFeature->SetFID(nNextFID++); return poFeature; }
OGRGeometry *OGRPoint::clone() const { OGRPoint *poNewPoint = new OGRPoint( x, y, z ); poNewPoint->assignSpatialReference( getSpatialReference() ); return poNewPoint; }
OGRGeometry *OGRPoint::clone() const { OGRPoint *poNewPoint = new OGRPoint( x, y, z ); poNewPoint->assignSpatialReference( getSpatialReference() ); poNewPoint->setCoordinateDimension( nCoordDimension ); return poNewPoint; }
OGRGeometry *OGRPoint::clone() const { OGRPoint *poNewPoint = new (std::nothrow) OGRPoint( x, y, z, m ); if( poNewPoint == NULL ) return NULL; poNewPoint->assignSpatialReference( getSpatialReference() ); poNewPoint->flags = flags; return poNewPoint; }
OGRFeature *OGROGDILayer::GetNextRawFeature() { ecs_Result *psResult; int i; OGRFeature *poFeature; /* -------------------------------------------------------------------- */ /* Retrieve object from OGDI server and create new feature */ /* -------------------------------------------------------------------- */ psResult = cln_GetNextObject(m_nClientID); if (! ECSSUCCESS(psResult)) { // We probably reached EOF... keep track of shape count. m_nTotalShapeCount = m_iNextShapeId - m_nFilteredOutShapes; return NULL; } poFeature = new OGRFeature(m_poFeatureDefn); poFeature->SetFID( m_iNextShapeId++ ); m_nFeaturesRead++; /* -------------------------------------------------------------------- */ /* Process geometry */ /* -------------------------------------------------------------------- */ if (m_eFamily == Point) { ecs_Point *psPoint = &(ECSGEOM(psResult).point); OGRPoint *poOGRPoint = new OGRPoint(psPoint->c.x, psPoint->c.y); poOGRPoint->assignSpatialReference(m_poSpatialRef); poFeature->SetGeometryDirectly(poOGRPoint); } else if (m_eFamily == Line) { ecs_Line *psLine = &(ECSGEOM(psResult).line); OGRLineString *poOGRLine = new OGRLineString(); poOGRLine->setNumPoints( psLine->c.c_len ); for( i=0; i < (int) psLine->c.c_len; i++ ) { poOGRLine->setPoint(i, psLine->c.c_val[i].x, psLine->c.c_val[i].y); } poOGRLine->assignSpatialReference(m_poSpatialRef); poFeature->SetGeometryDirectly(poOGRLine); } else if (m_eFamily == Area) { ecs_Area *psArea = &(ECSGEOM(psResult).area); OGRPolygon *poOGRPolygon = new OGRPolygon(); for(int iRing=0; iRing < (int) psArea->ring.ring_len; iRing++) { ecs_FeatureRing *psRing = &(psArea->ring.ring_val[iRing]); OGRLinearRing *poOGRRing = new OGRLinearRing(); poOGRRing->setNumPoints( psRing->c.c_len ); for( i=0; i < (int) psRing->c.c_len; i++ ) { poOGRRing->setPoint(i, psRing->c.c_val[i].x, psRing->c.c_val[i].y); } poOGRPolygon->addRingDirectly(poOGRRing); } // __TODO__ // When OGR supports polygon centroids then we should carry them here poOGRPolygon->assignSpatialReference(m_poSpatialRef); poFeature->SetGeometryDirectly(poOGRPolygon); } else if (m_eFamily == Text) { // __TODO__ // For now text is treated as a point and string is lost // ecs_Text *psText = &(ECSGEOM(psResult).text); OGRPoint *poOGRPoint = new OGRPoint(psText->c.x, psText->c.y); poOGRPoint->assignSpatialReference(m_poSpatialRef); poFeature->SetGeometryDirectly(poOGRPoint); } else { CPLAssert(FALSE); } /* -------------------------------------------------------------------- */ /* Set attributes */ /* -------------------------------------------------------------------- */ char *pszAttrList = ECSOBJECTATTR(psResult); for( int iField = 0; iField < m_poFeatureDefn->GetFieldCount(); iField++ ) { char *pszFieldStart; int nNameLen; char chSavedChar; /* parse out the next attribute value */ if( !ecs_FindElement( pszAttrList, &pszFieldStart, &pszAttrList, &nNameLen, NULL ) ) { nNameLen = 0; pszFieldStart = pszAttrList; } /* Skip any trailing white space (for string constants). */ if( nNameLen > 0 && pszFieldStart[nNameLen-1] == ' ' ) nNameLen--; /* skip leading white space */ while( pszFieldStart[0] == ' ' && nNameLen > 0 ) { pszFieldStart++; nNameLen--; } /* zero terminate the single field value, but save the */ /* character we overwrote, so we can restore it when done. */ chSavedChar = pszFieldStart[nNameLen]; pszFieldStart[nNameLen] = '\0'; /* OGR takes care of all field type conversions for us! */ poFeature->SetField(iField, pszFieldStart); pszFieldStart[nNameLen] = chSavedChar; } /* -------------------------------------------------------------------- */ /* Apply the text associated with text features if appropriate. */ /* -------------------------------------------------------------------- */ if( m_eFamily == Text ) { poFeature->SetField( "text", ECSGEOM(psResult).text.desc ); } return poFeature; }
OGRFeature *OGRPCIDSKLayer::GetFeature( GIntBig nFID ) { /* -------------------------------------------------------------------- */ /* Create the OGR feature. */ /* -------------------------------------------------------------------- */ OGRFeature *poFeature; poFeature = new OGRFeature( poFeatureDefn ); poFeature->SetFID( (int) nFID ); /* -------------------------------------------------------------------- */ /* Set attributes for any indicated attribute records. */ /* -------------------------------------------------------------------- */ try { std::vector<PCIDSK::ShapeField> aoFields; unsigned int i; poVecSeg->GetFields( (int) nFID, aoFields ); for( i=0; i < aoFields.size(); i++ ) { if( (int) i == iRingStartField ) continue; switch( aoFields[i].GetType() ) { case PCIDSK::FieldTypeNone: // null field value. break; case PCIDSK::FieldTypeInteger: poFeature->SetField( i, aoFields[i].GetValueInteger() ); break; case PCIDSK::FieldTypeFloat: poFeature->SetField( i, aoFields[i].GetValueFloat() ); break; case PCIDSK::FieldTypeDouble: poFeature->SetField( i, aoFields[i].GetValueDouble() ); break; case PCIDSK::FieldTypeString: poFeature->SetField( i, aoFields[i].GetValueString().c_str() ); break; case PCIDSK::FieldTypeCountedInt: std::vector<PCIDSK::int32> list = aoFields[i].GetValueCountedInt(); poFeature->SetField( i, list.size(), &(list[0]) ); break; } } /* -------------------------------------------------------------------- */ /* Translate the geometry. */ /* -------------------------------------------------------------------- */ std::vector<PCIDSK::ShapeVertex> aoVertices; poVecSeg->GetVertices( (int) nFID, aoVertices ); /* -------------------------------------------------------------------- */ /* Point */ /* -------------------------------------------------------------------- */ if( poFeatureDefn->GetGeomType() == wkbPoint25D || (wkbFlatten(poFeatureDefn->GetGeomType()) == wkbUnknown && aoVertices.size() == 1) ) { if( aoVertices.size() == 1 ) { OGRPoint* poPoint = new OGRPoint( aoVertices[0].x, aoVertices[0].y, aoVertices[0].z ); if (poSRS) poPoint->assignSpatialReference(poSRS); poFeature->SetGeometryDirectly(poPoint); } else { // report issue? } } /* -------------------------------------------------------------------- */ /* LineString */ /* -------------------------------------------------------------------- */ else if( poFeatureDefn->GetGeomType() == wkbLineString25D || (wkbFlatten(poFeatureDefn->GetGeomType()) == wkbUnknown && aoVertices.size() > 1) ) { // We should likely be applying ringstart to break things into // a multilinestring in some cases. if( aoVertices.size() > 1 ) { OGRLineString *poLS = new OGRLineString(); poLS->setNumPoints( aoVertices.size() ); for( i = 0; i < aoVertices.size(); i++ ) poLS->setPoint( i, aoVertices[i].x, aoVertices[i].y, aoVertices[i].z ); if (poSRS) poLS->assignSpatialReference(poSRS); poFeature->SetGeometryDirectly( poLS ); } else { // report issue? } } /* -------------------------------------------------------------------- */ /* Polygon - Currently we have no way to recognise if we are */ /* dealing with a multipolygon when we have more than one */ /* ring. Also, PCIDSK allows the rings to be in arbitrary */ /* order, not necessarily outside first which we are not yet */ /* ready to address in the following code. */ /* -------------------------------------------------------------------- */ else if( poFeatureDefn->GetGeomType() == wkbPolygon25D ) { std::vector<PCIDSK::int32> anRingStart; OGRPolygon *poPoly = new OGRPolygon(); unsigned int iRing; if( iRingStartField != -1 ) anRingStart = aoFields[iRingStartField].GetValueCountedInt(); for( iRing = 0; iRing < anRingStart.size()+1; iRing++ ) { int iStartVertex, iEndVertex, iVertex; OGRLinearRing *poRing = new OGRLinearRing(); if( iRing == 0 ) iStartVertex = 0; else iStartVertex = anRingStart[iRing-1]; if( iRing == anRingStart.size() ) iEndVertex = aoVertices.size() - 1; else iEndVertex = anRingStart[iRing] - 1; poRing->setNumPoints( iEndVertex - iStartVertex + 1 ); for( iVertex = iStartVertex; iVertex <= iEndVertex; iVertex++ ) { poRing->setPoint( iVertex - iStartVertex, aoVertices[iVertex].x, aoVertices[iVertex].y, aoVertices[iVertex].z ); } poPoly->addRingDirectly( poRing ); } if (poSRS) poPoly->assignSpatialReference(poSRS); poFeature->SetGeometryDirectly( poPoly ); } } /* -------------------------------------------------------------------- */ /* Trap exceptions and report as CPL errors. */ /* -------------------------------------------------------------------- */ catch( PCIDSK::PCIDSKException ex ) { delete poFeature; CPLError( CE_Failure, CPLE_AppDefined, "%s", ex.what() ); return NULL; } catch(...) { delete poFeature; CPLError( CE_Failure, CPLE_AppDefined, "Non-PCIDSK exception trapped." ); return NULL; } m_nFeaturesRead++; return poFeature; }
OGRFeature *OGRIdrisiLayer::GetNextRawFeature() { while(TRUE) { if (eGeomType == wkbPoint) { double dfId; double dfX, dfY; if (VSIFReadL(&dfId, sizeof(double), 1, fp) != 1 || VSIFReadL(&dfX, sizeof(double), 1, fp) != 1 || VSIFReadL(&dfY, sizeof(double), 1, fp) != 1) { return NULL; } CPL_LSBPTR64(&dfId); CPL_LSBPTR64(&dfX); CPL_LSBPTR64(&dfY); if (m_poFilterGeom != NULL && (dfX < m_sFilterEnvelope.MinX || dfX > m_sFilterEnvelope.MaxX || dfY < m_sFilterEnvelope.MinY || dfY > m_sFilterEnvelope.MaxY)) { nNextFID ++; continue; } OGRPoint* poGeom = new OGRPoint(dfX, dfY); if (poSRS) poGeom->assignSpatialReference(poSRS); OGRFeature* poFeature = new OGRFeature(poFeatureDefn); poFeature->SetField(0, dfId); poFeature->SetFID(nNextFID ++); poFeature->SetGeometryDirectly(poGeom); ReadAVLLine(poFeature); return poFeature; } else if (eGeomType == wkbLineString) { double dfId; double dfMinXShape, dfMaxXShape, dfMinYShape, dfMaxYShape; unsigned int nNodes; if (VSIFReadL(&dfId, sizeof(double), 1, fp) != 1 || VSIFReadL(&dfMinXShape, sizeof(double), 1, fp) != 1 || VSIFReadL(&dfMaxXShape, sizeof(double), 1, fp) != 1 || VSIFReadL(&dfMinYShape, sizeof(double), 1, fp) != 1 || VSIFReadL(&dfMaxYShape, sizeof(double), 1, fp) != 1) { return NULL; } CPL_LSBPTR64(&dfId); CPL_LSBPTR64(&dfMinXShape); CPL_LSBPTR64(&dfMaxXShape); CPL_LSBPTR64(&dfMinYShape); CPL_LSBPTR64(&dfMaxYShape); if (VSIFReadL(&nNodes, sizeof(unsigned int), 1, fp) != 1) { return NULL; } CPL_LSBPTR32(&nNodes); if (nNodes > 100 * 1000 * 1000) return NULL; if (m_poFilterGeom != NULL && (dfMaxXShape < m_sFilterEnvelope.MinX || dfMinXShape > m_sFilterEnvelope.MaxX || dfMaxYShape < m_sFilterEnvelope.MinY || dfMinYShape > m_sFilterEnvelope.MaxY)) { nNextFID ++; VSIFSeekL(fp, sizeof(OGRRawPoint) * nNodes, SEEK_CUR); continue; } OGRRawPoint* poRawPoints = (OGRRawPoint*)VSIMalloc2(sizeof(OGRRawPoint), nNodes); if (poRawPoints == NULL) { return NULL; } if ((unsigned int)VSIFReadL(poRawPoints, sizeof(OGRRawPoint), nNodes, fp) != nNodes) { VSIFree(poRawPoints); return NULL; } #if defined(CPL_MSB) for(unsigned int iNode=0; iNode<nNodes; iNode++) { CPL_LSBPTR64(&poRawPoints[iNode].x); CPL_LSBPTR64(&poRawPoints[iNode].y); } #endif OGRLineString* poGeom = new OGRLineString(); poGeom->setPoints(nNodes, poRawPoints, NULL); VSIFree(poRawPoints); if (poSRS) poGeom->assignSpatialReference(poSRS); OGRFeature* poFeature = new OGRFeature(poFeatureDefn); poFeature->SetField(0, dfId); poFeature->SetFID(nNextFID ++); poFeature->SetGeometryDirectly(poGeom); ReadAVLLine(poFeature); return poFeature; } else /* if (eGeomType == wkbPolygon) */ { double dfId; double dfMinXShape, dfMaxXShape, dfMinYShape, dfMaxYShape; unsigned int nParts; unsigned int nTotalNodes; if (VSIFReadL(&dfId, sizeof(double), 1, fp) != 1 || VSIFReadL(&dfMinXShape, sizeof(double), 1, fp) != 1 || VSIFReadL(&dfMaxXShape, sizeof(double), 1, fp) != 1 || VSIFReadL(&dfMinYShape, sizeof(double), 1, fp) != 1 || VSIFReadL(&dfMaxYShape, sizeof(double), 1, fp) != 1) { return NULL; } CPL_LSBPTR64(&dfId); CPL_LSBPTR64(&dfMinXShape); CPL_LSBPTR64(&dfMaxXShape); CPL_LSBPTR64(&dfMinYShape); CPL_LSBPTR64(&dfMaxYShape); if (VSIFReadL(&nParts, sizeof(unsigned int), 1, fp) != 1 || VSIFReadL(&nTotalNodes, sizeof(unsigned int), 1, fp) != 1) { return NULL; } CPL_LSBPTR32(&nParts); CPL_LSBPTR32(&nTotalNodes); if (nParts > 100000 || nTotalNodes > 100 * 1000 * 1000) return NULL; if (m_poFilterGeom != NULL && (dfMaxXShape < m_sFilterEnvelope.MinX || dfMinXShape > m_sFilterEnvelope.MaxX || dfMaxYShape < m_sFilterEnvelope.MinY || dfMinYShape > m_sFilterEnvelope.MaxY)) { VSIFSeekL(fp, sizeof(unsigned int) * nParts + sizeof(OGRRawPoint) * nTotalNodes, SEEK_CUR); nNextFID ++; continue; } OGRRawPoint* poRawPoints = (OGRRawPoint*)VSIMalloc2(sizeof(OGRRawPoint), nTotalNodes); if (poRawPoints == NULL) { return NULL; } unsigned int* panNodesCount = NULL; if( nParts > 1 ) { panNodesCount = (unsigned int *)CPLMalloc(sizeof(unsigned int) * nParts); if (VSIFReadL(panNodesCount, sizeof(unsigned int) * nParts, 1, fp) != 1) { VSIFree(poRawPoints); VSIFree(panNodesCount); return NULL; } #if defined(CPL_MSB) for(unsigned int iPart=0; iPart < nParts; iPart ++) { CPL_LSBPTR32(&panNodesCount[iPart]); } #endif } else { unsigned int nNodes; if (VSIFReadL(&nNodes, sizeof(unsigned int) * nParts, 1, fp) != 1) { VSIFree(poRawPoints); return NULL; } CPL_LSBPTR32(&nNodes); if( nNodes != nTotalNodes ) { VSIFree(poRawPoints); return NULL; } } unsigned int iPart; OGRPolygon* poGeom = new OGRPolygon(); for(iPart = 0; iPart < nParts; iPart ++) { unsigned int nNodes = (nParts > 1) ? panNodesCount[iPart] : nTotalNodes; if (nNodes > nTotalNodes || (unsigned int)VSIFReadL(poRawPoints, sizeof(OGRRawPoint), nNodes, fp) != nNodes) { VSIFree(poRawPoints); VSIFree(panNodesCount); delete poGeom; return NULL; } #if defined(CPL_MSB) for(unsigned int iNode=0; iNode<nNodes; iNode++) { CPL_LSBPTR64(&poRawPoints[iNode].x); CPL_LSBPTR64(&poRawPoints[iNode].y); } #endif OGRLinearRing* poLR = new OGRLinearRing(); poGeom->addRingDirectly(poLR); poLR->setPoints(nNodes, poRawPoints, NULL); } VSIFree(poRawPoints); VSIFree(panNodesCount); if (poSRS) poGeom->assignSpatialReference(poSRS); OGRFeature* poFeature = new OGRFeature(poFeatureDefn); poFeature->SetField(0, dfId); poFeature->SetFID(nNextFID ++); poFeature->SetGeometryDirectly(poGeom); ReadAVLLine(poFeature); return poFeature; } } }
OGRFeature *OGRHTFSoundingLayer::GetNextRawFeature() { const char* pszLine; OGRLinearRing oLR; while( (pszLine = CPLReadLine2L(fpHTF, 1024, NULL)) != NULL) { if (pszLine[0] == ';') { /* comment */ ; } else if (pszLine[0] == 0) { bEOF = TRUE; return NULL; } else if (strcmp(pszLine, "END OF SOUNDING DATA") == 0) { bEOF = TRUE; return NULL; } else break; } if (pszLine == NULL) { bEOF = TRUE; return NULL; } int i; double dfEasting = 0, dfNorthing = 0; OGRFeature* poFeature = new OGRFeature(poFeatureDefn); char* pszStr = (char*)pszLine; for(i=0;i<poFeatureDefn->GetFieldCount();i++) { if (!panFieldPresence[i]) continue; char* pszSpace = strchr(pszStr, ' '); if (pszSpace) *pszSpace = '\0'; if (strcmp(pszStr, "*") != 0) poFeature->SetField(i, pszStr); if (i == nEastingIndex) dfEasting = poFeature->GetFieldAsDouble(i); else if (i == nNorthingIndex) dfNorthing = poFeature->GetFieldAsDouble(i); if (pszSpace == NULL) break; pszStr = pszSpace + 1; } OGRPoint* poPoint = new OGRPoint(dfEasting, dfNorthing); poPoint->assignSpatialReference(poSRS); poFeature->SetGeometryDirectly(poPoint); poFeature->SetFID(nNextFID++); return poFeature; }
OGRFeature *OGRGFTLayer::BuildFeatureFromSQL(const char* pszLine) { OGRFeature* poFeature = new OGRFeature(poFeatureDefn); char** papszTokens = OGRGFTCSVSplitLine(pszLine, ','); int nTokens = CSLCount(papszTokens); CPLString osFID; int nAttrOffset = 0; int iROWID = -1; if (bFirstTokenIsFID) { osFID = papszTokens[0]; nAttrOffset = 1; } else { iROWID = poFeatureDefn->GetFieldIndex("rowid"); if (iROWID < 0) iROWID = poFeatureDefn->GetFieldIndex("ROWID"); } int nFieldCount = poFeatureDefn->GetFieldCount(); if (nTokens == nFieldCount + bHiddenGeometryField + nAttrOffset) { for(int i=0;i<nFieldCount+bHiddenGeometryField;i++) { const char* pszVal = papszTokens[i+nAttrOffset]; if (pszVal[0]) { if (i<nFieldCount) poFeature->SetField(i, pszVal); if (i == iGeometryField && i != iLatitudeField) { if (pszVal[0] == '-' || (pszVal[0] >= '0' && pszVal[0] <= '9')) { char** papszLatLon = CSLTokenizeString2(pszVal, " ,", 0); if (CSLCount(papszLatLon) == 2 && CPLGetValueType(papszLatLon[0]) != CPL_VALUE_STRING && CPLGetValueType(papszLatLon[1]) != CPL_VALUE_STRING) { OGRPoint* poPoint = new OGRPoint(CPLAtof( papszLatLon[1]), CPLAtof( papszLatLon[0])); poPoint->assignSpatialReference(poSRS); poFeature->SetGeometryDirectly(poPoint); } CSLDestroy(papszLatLon); } else if (strstr(pszVal, "<Point>") || strstr(pszVal, "<LineString>") || strstr(pszVal, "<Polygon>")) { OGRGeometry* poGeom = ParseKMLGeometry(pszVal); if (poGeom) { poGeom->assignSpatialReference(poSRS); poFeature->SetGeometryDirectly(poGeom); } } } else if (i == iROWID) { osFID = pszVal; } } } if (iLatitudeField >= 0 && iLongitudeField >= 0) { const char* pszLat = papszTokens[iLatitudeField+nAttrOffset]; const char* pszLong = papszTokens[iLongitudeField+nAttrOffset]; if (pszLat[0] != 0 && pszLong[0] != 0 && CPLGetValueType(pszLat) != CPL_VALUE_STRING && CPLGetValueType(pszLong) != CPL_VALUE_STRING) { OGRPoint* poPoint = new OGRPoint(CPLAtof(pszLong), CPLAtof(pszLat)); poPoint->assignSpatialReference(poSRS); poFeature->SetGeometryDirectly(poPoint); } } } else { CPLDebug("GFT", "Only %d columns for feature %s", nTokens, osFID.c_str()); } CSLDestroy(papszTokens); int nFID = atoi(osFID); if (strcmp(CPLSPrintf("%d", nFID), osFID.c_str()) == 0) poFeature->SetFID(nFID); else poFeature->SetFID(nNextInSeq); return poFeature; }
void OGRSVGLayer::startElementCbk(const char *pszName, const char **ppszAttr) { int i; if (bStopParsing) return; nWithoutEventCounter = 0; if (svgGeomType == SVG_POINTS && strcmp(pszName, "circle") == 0 && strcmp(OGRSVGGetClass(ppszAttr), "point") == 0) { int bHasFoundX = FALSE, bHasFoundY = FALSE; double dfX = 0, dfY = 0; for (i = 0; ppszAttr[i]; i += 2) { if (strcmp(ppszAttr[i], "cx") == 0) { bHasFoundX = TRUE; dfX = CPLAtof(ppszAttr[i + 1]); } else if (strcmp(ppszAttr[i], "cy") == 0) { bHasFoundY = TRUE; /* Cloudmade --> negate y */ dfY = - CPLAtof(ppszAttr[i + 1]); } } if (bHasFoundX && bHasFoundY) { interestingDepthLevel = depthLevel; inInterestingElement = TRUE; if (poFeature) delete poFeature; poFeature = new OGRFeature( poFeatureDefn ); poFeature->SetFID( nNextFID++ ); OGRPoint* poPoint = new OGRPoint( dfX, dfY ); poPoint->assignSpatialReference(poSRS); poFeature->SetGeometryDirectly( poPoint ); } } else if (svgGeomType == SVG_LINES && strcmp(pszName, "path") == 0 && strcmp(OGRSVGGetClass(ppszAttr), "line") == 0) { const char* pszD = NULL; for (i = 0; ppszAttr[i]; i += 2) { if (strcmp(ppszAttr[i], "d") == 0) { pszD = ppszAttr[i + 1]; break; } } if (pszD) { interestingDepthLevel = depthLevel; inInterestingElement = TRUE; if (poFeature) delete poFeature; poFeature = new OGRFeature( poFeatureDefn ); poFeature->SetFID( nNextFID++ ); OGRLineString* poLS = new OGRLineString(); OGRSVGParseD(poLS, pszD); poLS->assignSpatialReference(poSRS); poFeature->SetGeometryDirectly( poLS ); } } else if (svgGeomType == SVG_POLYGONS && strcmp(pszName, "path") == 0 && strcmp(OGRSVGGetClass(ppszAttr), "polygon") == 0) { const char* pszD = NULL; for (i = 0; ppszAttr[i]; i += 2) { if (strcmp(ppszAttr[i], "d") == 0) { pszD = ppszAttr[i + 1]; break; } } if (pszD) { interestingDepthLevel = depthLevel; inInterestingElement = TRUE; if (poFeature) delete poFeature; poFeature = new OGRFeature( poFeatureDefn ); poFeature->SetFID( nNextFID++ ); OGRPolygon* poPolygon = new OGRPolygon(); OGRLinearRing* poLS = new OGRLinearRing(); OGRSVGParseD(poLS, pszD); poPolygon->addRingDirectly(poLS); poPolygon->assignSpatialReference(poSRS); poFeature->SetGeometryDirectly( poPolygon ); } } else if (inInterestingElement && depthLevel == interestingDepthLevel + 1 && STARTS_WITH(pszName, "cm:")) { iCurrentField = poFeatureDefn->GetFieldIndex(pszName + 3); } depthLevel++; }