static void ReportOnLayer( OGRLayer * poLayer, int bVerbose ) { OGRFeatureDefn *poDefn = poLayer->GetLayerDefn(); /* -------------------------------------------------------------------- */ /* Report various overall information. */ /* -------------------------------------------------------------------- */ printf( "\n" ); printf( "Layer name: %s\n", poLayer->GetName() ); if( bVerbose ) { int nGeomFieldCount = poLayer->GetLayerDefn()->GetGeomFieldCount(); if( nGeomFieldCount > 1 ) { for(int iGeom = 0;iGeom < nGeomFieldCount; iGeom ++ ) { OGRGeomFieldDefn* poGFldDefn = poLayer->GetLayerDefn()->GetGeomFieldDefn(iGeom); printf( "Geometry (%s): %s\n", poGFldDefn->GetNameRef(), OGRGeometryTypeToName( poGFldDefn->GetType() ) ); } } else { printf( "Geometry: %s\n", OGRGeometryTypeToName( poLayer->GetGeomType() ) ); } printf( "Feature Count: " CPL_FRMT_GIB "\n", poLayer->GetFeatureCount() ); OGREnvelope oExt; if( nGeomFieldCount > 1 ) { for(int iGeom = 0;iGeom < nGeomFieldCount; iGeom ++ ) { if (poLayer->GetExtent(iGeom, &oExt, TRUE) == OGRERR_NONE) { OGRGeomFieldDefn* poGFldDefn = poLayer->GetLayerDefn()->GetGeomFieldDefn(iGeom); CPLprintf("Extent (%s): (%f, %f) - (%f, %f)\n", poGFldDefn->GetNameRef(), oExt.MinX, oExt.MinY, oExt.MaxX, oExt.MaxY); } } } else if ( poLayer->GetExtent(&oExt, TRUE) == OGRERR_NONE) { CPLprintf("Extent: (%f, %f) - (%f, %f)\n", oExt.MinX, oExt.MinY, oExt.MaxX, oExt.MaxY); } char *pszWKT; if( nGeomFieldCount > 1 ) { for(int iGeom = 0;iGeom < nGeomFieldCount; iGeom ++ ) { OGRGeomFieldDefn* poGFldDefn = poLayer->GetLayerDefn()->GetGeomFieldDefn(iGeom); OGRSpatialReference* poSRS = poGFldDefn->GetSpatialRef(); if( poSRS == NULL ) pszWKT = CPLStrdup( "(unknown)" ); else { poSRS->exportToPrettyWkt( &pszWKT ); } printf( "SRS WKT (%s):\n%s\n", poGFldDefn->GetNameRef(), pszWKT ); CPLFree( pszWKT ); } } else { if( poLayer->GetSpatialRef() == NULL ) pszWKT = CPLStrdup( "(unknown)" ); else { poLayer->GetSpatialRef()->exportToPrettyWkt( &pszWKT ); } printf( "Layer SRS WKT:\n%s\n", pszWKT ); CPLFree( pszWKT ); } if( strlen(poLayer->GetFIDColumn()) > 0 ) printf( "FID Column = %s\n", poLayer->GetFIDColumn() ); for(int iGeom = 0;iGeom < nGeomFieldCount; iGeom ++ ) { OGRGeomFieldDefn* poGFldDefn = poLayer->GetLayerDefn()->GetGeomFieldDefn(iGeom); if( nGeomFieldCount == 1 && EQUAL(poGFldDefn->GetNameRef(), "") && poGFldDefn->IsNullable() ) break; printf( "Geometry Column "); if( nGeomFieldCount > 1 ) printf("%d ", iGeom + 1); if( !poGFldDefn->IsNullable() ) printf("NOT NULL "); printf("= %s\n", poGFldDefn->GetNameRef() ); } for( int iAttr = 0; iAttr < poDefn->GetFieldCount(); iAttr++ ) { OGRFieldDefn *poField = poDefn->GetFieldDefn( iAttr ); const char* pszType = (poField->GetSubType() != OFSTNone) ? CPLSPrintf("%s(%s)", poField->GetFieldTypeName( poField->GetType() ), poField->GetFieldSubTypeName(poField->GetSubType())) : poField->GetFieldTypeName( poField->GetType() ); printf( "%s: %s (%d.%d)", poField->GetNameRef(), pszType, poField->GetWidth(), poField->GetPrecision() ); if( !poField->IsNullable() ) printf(" NOT NULL"); if( poField->GetDefault() != NULL ) printf(" DEFAULT %s", poField->GetDefault() ); printf( "\n" ); } } /* -------------------------------------------------------------------- */ /* Read, and dump features. */ /* -------------------------------------------------------------------- */ OGRFeature *poFeature = NULL; while( (poFeature = poLayer->GetNextFeature()) != NULL ) { poFeature->DumpReadable( NULL ); OGRFeature::DestroyFeature( poFeature ); } }
static void ParseObject(const char* pszId, json_object* poObj, OGRGeoJSONLayer* poLayer, json_object* poArcsDB, ScalingParams* psParams) { json_object* poType = OGRGeoJSONFindMemberByName(poObj, "type"); if( poType == NULL || json_object_get_type(poType) != json_type_string ) return; const char* pszType = json_object_get_string(poType); json_object* poArcsObj = OGRGeoJSONFindMemberByName(poObj, "arcs"); json_object* poCoordinatesObj = OGRGeoJSONFindMemberByName(poObj, "coordinates"); if( strcmp(pszType, "Point") == 0 || strcmp(pszType, "MultiPoint") == 0 ) { if( poCoordinatesObj == NULL || json_type_array != json_object_get_type(poCoordinatesObj) ) return; } else { if( poArcsObj == NULL || json_type_array != json_object_get_type(poArcsObj) ) return; } if( pszId == NULL ) { json_object* poId = OGRGeoJSONFindMemberByName(poObj, "id"); if( poId != NULL && (json_type_string == json_object_get_type(poId) || json_type_int == json_object_get_type(poId)) ) { pszId = json_object_get_string(poId); } } OGRFeature* poFeature = new OGRFeature(poLayer->GetLayerDefn()); if( pszId != NULL ) poFeature->SetField("id", pszId); json_object* poProperties = OGRGeoJSONFindMemberByName(poObj, "properties"); if( poProperties != NULL && json_type_object == json_object_get_type(poProperties) ) { json_object* poName = OGRGeoJSONFindMemberByName(poProperties, "name"); if( poName != NULL && json_type_string == json_object_get_type(poName) ) { const char* pszName = json_object_get_string(poName); poFeature->SetField("name", pszName); } } OGRGeometry* poGeom = NULL; if( strcmp(pszType, "Point") == 0 ) { double dfX = 0.0, dfY = 0.0; if( ParsePoint( poCoordinatesObj, &dfX, &dfY ) ) { dfX = dfX * psParams->dfScale0 + psParams->dfTranslate0; dfY = dfY * psParams->dfScale1 + psParams->dfTranslate1; poGeom = new OGRPoint(dfX, dfY); } else poGeom = new OGRPoint(); } else if( strcmp(pszType, "MultiPoint") == 0 ) { OGRMultiPoint* poMP = new OGRMultiPoint(); poGeom = poMP; int nTuples = json_object_array_length(poCoordinatesObj); for(int i=0; i<nTuples; i++) { json_object* poPair = json_object_array_get_idx(poCoordinatesObj, i); double dfX = 0.0, dfY = 0.0; if( ParsePoint( poPair, &dfX, &dfY ) ) { dfX = dfX * psParams->dfScale0 + psParams->dfTranslate0; dfY = dfY * psParams->dfScale1 + psParams->dfTranslate1; poMP->addGeometryDirectly(new OGRPoint(dfX, dfY)); } } } else if( strcmp(pszType, "LineString") == 0 ) { OGRLineString* poLS = new OGRLineString(); poGeom = poLS; ParseLineString(poLS, poArcsObj, poArcsDB, psParams); } else if( strcmp(pszType, "MultiLineString") == 0 ) { OGRMultiLineString* poMLS = new OGRMultiLineString(); poGeom = poMLS; ParseMultiLineString(poMLS, poArcsObj, poArcsDB, psParams); } else if( strcmp(pszType, "Polygon") == 0 ) { OGRPolygon* poPoly = new OGRPolygon(); poGeom = poPoly; ParsePolygon(poPoly, poArcsObj, poArcsDB, psParams); } else if( strcmp(pszType, "MultiPolygon") == 0 ) { OGRMultiPolygon* poMultiPoly = new OGRMultiPolygon(); poGeom = poMultiPoly; ParseMultiPolygon(poMultiPoly, poArcsObj, poArcsDB, psParams); } if( poGeom != NULL ) poFeature->SetGeometryDirectly(poGeom); poLayer->AddFeature(poFeature); delete 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; } double dfEasting = 0; double dfNorthing = 0; OGRFeature* poFeature = new OGRFeature(poFeatureDefn); char* pszStr = const_cast<char *>(pszLine); for( int 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; }
void OGRPDFLayer::Fill( GDALPDFArray* poArray ) { for(int i=0;i<poArray->GetLength();i++) { GDALPDFObject* poFeatureObj = poArray->Get(i); if (poFeatureObj->GetType() != PDFObjectType_Dictionary) continue; GDALPDFObject* poA = poFeatureObj->GetDictionary()->Get("A"); if (!(poA != NULL && poA->GetType() == PDFObjectType_Dictionary)) continue; GDALPDFObject* poP = poA->GetDictionary()->Get("P"); if (!(poP != NULL && poP->GetType() == PDFObjectType_Array)) continue; GDALPDFObject* poK = poFeatureObj->GetDictionary()->Get("K"); int nK = -1; if (poK != NULL && poK->GetType() == PDFObjectType_Int) nK = poK->GetInt(); GDALPDFArray* poPArray = poP->GetArray(); int j; for(j = 0;j<poPArray->GetLength();j++) { GDALPDFObject* poKV = poPArray->Get(j); if (poKV->GetType() == PDFObjectType_Dictionary) { GDALPDFObject* poN = poKV->GetDictionary()->Get("N"); GDALPDFObject* poV = poKV->GetDictionary()->Get("V"); if (poN != NULL && poN->GetType() == PDFObjectType_String && poV != NULL) { int nIdx = GetLayerDefn()->GetFieldIndex( poN->GetString().c_str() ); OGRFieldType eType = OFTString; if (poV->GetType() == PDFObjectType_Int) eType = OFTInteger; else if (poV->GetType() == PDFObjectType_Real) eType = OFTReal; if (nIdx < 0) { OGRFieldDefn oField(poN->GetString().c_str(), eType); CreateField(&oField); } else if (GetLayerDefn()->GetFieldDefn(nIdx)->GetType() != eType && GetLayerDefn()->GetFieldDefn(nIdx)->GetType() != OFTString) { OGRFieldDefn oField(poN->GetString().c_str(), OFTString); AlterFieldDefn( nIdx, &oField, ALTER_TYPE_FLAG ); } } } } OGRFeature* poFeature = new OGRFeature(GetLayerDefn()); for(j = 0;j<poPArray->GetLength();j++) { GDALPDFObject* poKV = poPArray->Get(j); if (poKV->GetType() == PDFObjectType_Dictionary) { GDALPDFObject* poN = poKV->GetDictionary()->Get("N"); GDALPDFObject* poV = poKV->GetDictionary()->Get("V"); if (poN != NULL && poN->GetType() == PDFObjectType_String && poV != NULL) { if (poV->GetType() == PDFObjectType_String) poFeature->SetField(poN->GetString().c_str(), poV->GetString().c_str()); else if (poV->GetType() == PDFObjectType_Int) poFeature->SetField(poN->GetString().c_str(), poV->GetInt()); else if (poV->GetType() == PDFObjectType_Real) poFeature->SetField(poN->GetString().c_str(), poV->GetReal()); } } } if (nK >= 0) { OGRGeometry* poGeom = poDS->GetGeometryFromMCID(nK); if (poGeom) { poGeom->assignSpatialReference(GetSpatialRef()); poFeature->SetGeometry(poGeom); } } OGRGeometry* poGeom = poFeature->GetGeometryRef(); if( !bGeomTypeMixed && poGeom != NULL ) { if (!bGeomTypeSet) { bGeomTypeSet = TRUE; GetLayerDefn()->SetGeomType(poGeom->getGeometryType()); } else if (GetLayerDefn()->GetGeomType() != poGeom->getGeometryType()) { bGeomTypeMixed = TRUE; GetLayerDefn()->SetGeomType(wkbUnknown); } } ICreateFeature(poFeature); delete poFeature; } }
OGRFeature *OGRPCIDSKLayer::GetFeature( long 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; }
OGRErr OGRLayer::GetExtent(OGREnvelope *psExtent, int bForce ) { OGRFeature *poFeature; OGREnvelope oEnv; GBool bExtentSet = FALSE; psExtent->MinX = 0.0; psExtent->MaxX = 0.0; psExtent->MinY = 0.0; psExtent->MaxY = 0.0; /* -------------------------------------------------------------------- */ /* If this layer has a none geometry type, then we can */ /* reasonably assume there are not extents available. */ /* -------------------------------------------------------------------- */ if( GetLayerDefn()->GetGeomType() == wkbNone ) return OGRERR_FAILURE; /* -------------------------------------------------------------------- */ /* If not forced, we should avoid having to scan all the */ /* features and just return a failure. */ /* -------------------------------------------------------------------- */ if( !bForce ) return OGRERR_FAILURE; /* -------------------------------------------------------------------- */ /* OK, we hate to do this, but go ahead and read through all */ /* the features to collect geometries and build extents. */ /* -------------------------------------------------------------------- */ ResetReading(); while( (poFeature = GetNextFeature()) != NULL ) { OGRGeometry *poGeom = poFeature->GetGeometryRef(); if (poGeom == NULL || poGeom->IsEmpty()) { /* Do nothing */ } else if (!bExtentSet) { poGeom->getEnvelope(psExtent); bExtentSet = TRUE; } else { poGeom->getEnvelope(&oEnv); if (oEnv.MinX < psExtent->MinX) psExtent->MinX = oEnv.MinX; if (oEnv.MinY < psExtent->MinY) psExtent->MinY = oEnv.MinY; if (oEnv.MaxX > psExtent->MaxX) psExtent->MaxX = oEnv.MaxX; if (oEnv.MaxY > psExtent->MaxY) psExtent->MaxY = oEnv.MaxY; } delete poFeature; } ResetReading(); return (bExtentSet ? OGRERR_NONE : OGRERR_FAILURE); }
OGRFeature *OGRAVCE00Layer::GetFeature( long nFID ) { /* -------------------------------------------------------------------- */ /* If we haven't started yet, open the file now. */ /* -------------------------------------------------------------------- */ if( psRead == NULL ) { psRead = AVCE00ReadOpenE00(psSection->pszFilename); if (psRead == NULL) return NULL; /* advance to the specified line number */ if (AVCE00ReadGotoSectionE00(psRead, psSection, 0) != 0) return NULL; nNextFID = 1; } /* -------------------------------------------------------------------- */ /* Read the raw feature - the -3 fid is a special flag */ /* indicating serial access. */ /* -------------------------------------------------------------------- */ void *pFeature; if( nFID == -3 ) { while( (pFeature = AVCE00ReadNextObjectE00(psRead)) != NULL && psRead->hParseInfo->eFileType != AVCFileUnknown && !MatchesSpatialFilter( pFeature ) ) { nNextFID++; } } else { bNeedReset = TRUE; if (nNextFID > nFID) { /* advance to the specified line number */ if (AVCE00ReadGotoSectionE00(psRead, psSection, 0) != 0) return NULL; } do { pFeature = AVCE00ReadNextObjectE00(psRead); ++nNextFID; } while (NULL != pFeature && nNextFID <= nFID); } if( pFeature == NULL ) return NULL; /* -------------------------------------------------------------------- */ /* Translate the feature. */ /* -------------------------------------------------------------------- */ OGRFeature *poFeature; poFeature = TranslateFeature( pFeature ); if( poFeature == NULL ) return NULL; /* -------------------------------------------------------------------- */ /* LAB's we have to assign the FID to directly, since it */ /* doesn't seem to be stored in the file structure. */ /* -------------------------------------------------------------------- */ if( psSection->eType == AVCFileLAB ) { if( nFID == -3 ) poFeature->SetFID( nNextFID++ ); else poFeature->SetFID( nFID ); } /* -------------------------------------------------------------------- */ /* If this is a polygon layer, try to assemble the arcs to form */ /* the whole polygon geometry. */ /* -------------------------------------------------------------------- */ if( psSection->eType == AVCFilePAL || psSection->eType == AVCFileRPL ) { FormPolygonGeometry( poFeature, (AVCPal *) pFeature ); } /* -------------------------------------------------------------------- */ /* If we have an attribute table, append the attributes now. */ /* -------------------------------------------------------------------- */ AppendTableFields( poFeature ); return poFeature; }
OGRFeature *OGRAeronavFAARouteLayer::GetNextRawFeature() { OGRFeature* poFeature = nullptr; OGRLineString* poLS = nullptr; while( true ) { const char* pszLine = nullptr; if (!osLastReadLine.empty()) pszLine = osLastReadLine.c_str(); else pszLine = CPLReadLine2L(fpAeronavFAA, 87, nullptr); osLastReadLine = ""; if (pszLine == nullptr) { bEOF = true; break; } if (strlen(pszLine) != 85) continue; if (bIsDPOrSTARS && STARTS_WITH(pszLine, "===") && pszLine[3] != '=') { osAPTName = pszLine + 3; const char* pszComma = strchr(pszLine + 3, ','); if (pszComma) { osAPTName.resize(pszComma - (pszLine + 3)); osStateName = pszComma + 2; const char* pszEqual = strchr(pszComma + 2, '='); if (pszEqual) osStateName.resize(pszEqual - (pszComma + 2)); } else { const char* pszEqual = strchr(pszLine + 3, '='); if (pszEqual) osAPTName.resize(pszEqual - (pszLine + 3)); osStateName = ""; } } if (STARTS_WITH(pszLine + 2, "FACILITY OR")) continue; if (STARTS_WITH(pszLine + 2, "INTERSECTION")) continue; if (strcmp(pszLine, "================================DELETIONS LIST=================================198326") == 0) { bEOF = true; break; } if (poFeature == nullptr) { if (pszLine[2] == ' ' || pszLine[2] == '-' ) { continue; } if (STARTS_WITH(pszLine + 29, " ") || strchr(pszLine, '(') != nullptr) { CPLString osName = pszLine + 2; osName.resize(60); while(!osName.empty() && osName.back() == ' ') { osName.resize(osName.size()-1); } if (strcmp(osName.c_str(), "(DELETIONS LIST)") == 0) { bEOF = true; return nullptr; } poFeature = new OGRFeature(poFeatureDefn); poFeature->SetFID(nNextFID ++); if (bIsDPOrSTARS) { poFeature->SetField(0, osAPTName); poFeature->SetField(1, osStateName); poFeature->SetField(2, osName); } else poFeature->SetField(0, osName); poLS = new OGRLineString(); } continue; } if (STARTS_WITH(pszLine, " 0")) { if (poLS->getNumPoints() == 0) continue; else break; } if (pszLine[29 - 1] == ' ' && pszLine[42 - 1] == ' ') continue; if (strstr(pszLine, "RWY") || strchr(pszLine, '(')) { osLastReadLine = pszLine; break; } double dfLat = 0.0; double dfLon = 0.0; GetLatLon(pszLine + 29 - 1, pszLine + 42 - 1, dfLat, dfLon); poLS->addPoint(dfLon, dfLat); } if( poFeature != nullptr ) poFeature->SetGeometryDirectly(poLS); return poFeature; }
OGRFeature *OGRAeronavFAAIAPLayer::GetNextRawFeature() { char szBuffer[87]; int nCountUnderscoreLines = 0; while( true ) { const char* pszLine = CPLReadLine2L(fpAeronavFAA, 87, nullptr); if (pszLine == nullptr) { bEOF = true; return nullptr; } if (strlen(pszLine) != 85) continue; if (STARTS_WITH(pszLine, "DELETIONS")) { bEOF = true; return nullptr; } if (nNextFID == 0 && nCountUnderscoreLines < 2) { if (strcmp(pszLine, "_____________________________________________________________________________ 285285") == 0) nCountUnderscoreLines ++; continue; } if (pszLine[1] != ' ') continue; if (STARTS_WITH(pszLine, " ")) continue; if (strstr(pszLine, "NAVIGATIONAL AIDS") != nullptr) continue; if (strstr(pszLine, "TERMINAL INSTRUMENT FIXES") != nullptr) continue; const char* pszComma = strchr(pszLine, ','); if (pszComma) { const char* pszBegin = pszLine; while( *pszBegin == ' ') pszBegin ++; osCityName = pszBegin; osCityName.resize(pszComma - pszBegin); osStateName = pszComma + 2; osStateName.resize(78 - (pszComma + 2 - pszLine)); while(!osStateName.empty() && osStateName.back() == ' ') { osStateName.resize(osStateName.size()-1); } osAPTName = ""; osAPTId = ""; continue; } const char* pszLeftParenthesis = strstr(pszLine, " ("); if (pszLeftParenthesis) { const char* pszRightParenthesis = strchr(pszLeftParenthesis, ')'); if (pszRightParenthesis) { const char* pszBegin = pszLine; while( *pszBegin == ' ') pszBegin ++; osAPTName = pszBegin; osAPTName.resize(pszLeftParenthesis - pszBegin); osAPTId = pszLeftParenthesis + 2; osAPTId.resize(pszRightParenthesis - (pszLeftParenthesis + 2)); } continue; } OGRFeature* poFeature = new OGRFeature(poFeatureDefn); poFeature->SetFID(nNextFID ++); poFeature->SetField(0, osCityName); poFeature->SetField(1, osStateName); poFeature->SetField(2, osAPTName); poFeature->SetField(3, osAPTId); for( int i=0; i<psRecordDesc->nFields; i++) { int nWidth = psRecordDesc->pasFields[i].nLastCol - psRecordDesc->pasFields[i].nStartCol + 1; strncpy(szBuffer, pszLine + psRecordDesc->pasFields[i].nStartCol - 1, nWidth); szBuffer[nWidth] = 0; while(nWidth > 0 && szBuffer[nWidth - 1] == ' ') { szBuffer[nWidth - 1] = 0; nWidth --; } if (nWidth != 0) poFeature->SetField(i + 4, szBuffer); } double dfLat = 0.0; double dfLon = 0.0; GetLatLon(pszLine + 16 - 1, (pszLine[34 - 1] != ' ') ? pszLine + 34 - 1 : pszLine + 35 - 1, dfLat, dfLon); OGRGeometry* poGeom = new OGRPoint(dfLon, dfLat); poGeom->assignSpatialReference(poSRS); poFeature->SetGeometryDirectly( poGeom ); return poFeature; } }
// This function does NOT work for now bool GdaCache::CacheLayer(std::string ext_ds_name, OGRLayerProxy* ext_layer_proxy) { OGRLayer* poSrcLayer = ext_layer_proxy->layer; // get information from current layer: geomtype, layer_name // (NOTE: we don't consider coodinator system and translation here) OGRFeatureDefn *poSrcFDefn = poSrcLayer->GetLayerDefn(); int eGType = poSrcFDefn->GetGeomType(); const char* pszNewLayerName = poSrcLayer->GetName(); int bForceToPolygon = FALSE; int bForceToMultiPolygon = FALSE; int bForceToMultiLineString = FALSE; if( wkbFlatten(eGType) == wkbPolygon ) bForceToPolygon = TRUE; else if( wkbFlatten(eGType) == wkbMultiPolygon ) bForceToMultiPolygon = TRUE; else if( wkbFlatten(eGType) == wkbMultiLineString ) bForceToMultiLineString = TRUE; //Setup coordinate transformation if we need it. OGRCoordinateTransformation *poCT = NULL; bool bTransform = FALSE; OGRSpatialReference *poSourceSRS = NULL; // todo OGRSpatialReference *poOutputSRS = new OGRSpatialReference("EPSG:4326"); // Cache char *papszLCO[] = {"OVERWRITE=yes","FORMAT=Spatialite"}; std::string cache_layer_name = ext_ds_name + "_"+ext_layer_proxy->name; GDALDataset *poDstDS = cach_ds_proxy->ds; OGRLayer *poDstLayer = poDstDS->CreateLayer(cache_layer_name.c_str(), poOutputSRS, (OGRwkbGeometryType)eGType, papszLCO); if (poDstLayer == NULL) { // raise create cache failed. return false; } // Process Layer style table poDstLayer->SetStyleTable( poSrcLayer->GetStyleTable () ); // Add fields. here to copy all field. int nSrcFieldCount = poSrcFDefn->GetFieldCount(); int iField; OGRFeatureDefn *poDstFDefn = poDstLayer->GetLayerDefn(); for( iField = 0; iField < nSrcFieldCount; iField++ ) { OGRFieldDefn* poSrcFieldDefn = poSrcFDefn->GetFieldDefn(iField); OGRFieldDefn oFieldDefn( poSrcFieldDefn ); // The field may have been already created at layer creation if (poDstLayer->CreateField( &oFieldDefn ) == OGRERR_NONE) { // now that we've created a field, GetLayerDefn() won't return NULL if (poDstFDefn == NULL) poDstFDefn = poDstLayer->GetLayerDefn(); } } // Transfer feature from Source Layer to Dest Layer OGRFeature *poFeature; GIntBig nFeaturesWritten = 0; poSrcLayer->ResetReading(); while (poFeature = poSrcLayer->GetNextFeature()) { OGRFeature *poDstFeature = OGRFeature::CreateFeature( poDstLayer->GetLayerDefn() ); poDstFeature->SetFrom(poFeature); OGRGeometry *poDstGeometry = poDstFeature->GetGeometryRef(); if (poDstGeometry != NULL) { if( bForceToPolygon ) { poDstFeature->SetGeometryDirectly( OGRGeometryFactory::forceToPolygon( poDstFeature->StealGeometry())); } else if( bForceToMultiPolygon ) { poDstFeature->SetGeometryDirectly( OGRGeometryFactory::forceToMultiPolygon( poDstFeature->StealGeometry() ) ); } else if ( bForceToMultiLineString ) { poDstFeature->SetGeometryDirectly( OGRGeometryFactory::forceToMultiLineString( poDstFeature->StealGeometry() ) ); } } if( poDstLayer->CreateFeature( poDstFeature ) == OGRERR_NONE ) { nFeaturesWritten ++; } OGRFeature::DestroyFeature( poDstFeature ); OGRFeature::DestroyFeature( poFeature ); } //OGRDataSource::DestroyDataSource(poDstDS); GDALClose(poDstDS); // XXX // delete poDstLayer; return true; }
boost::optional<mapnik::datasource::geometry_t> ogr_datasource::get_geometry_type() const { boost::optional<mapnik::datasource::geometry_t> result; if (dataset_ && layer_.is_valid()) { OGRLayer* layer = layer_.layer(); // NOTE: wkbFlatten macro in ogr flattens 2.5d types into base 2d type #if GDAL_VERSION_NUM < 1800 switch (wkbFlatten(layer->GetLayerDefn()->GetGeomType())) #else switch (wkbFlatten(layer->GetGeomType())) #endif { case wkbPoint: case wkbMultiPoint: result.reset(mapnik::datasource::Point); break; case wkbLinearRing: case wkbLineString: case wkbMultiLineString: result.reset(mapnik::datasource::LineString); break; case wkbPolygon: case wkbMultiPolygon: result.reset(mapnik::datasource::Polygon); break; case wkbGeometryCollection: result.reset(mapnik::datasource::Collection); break; case wkbNone: case wkbUnknown: { // fallback to inspecting first actual geometry // TODO - csv and shapefile inspect first 4 features if (dataset_ && layer_.is_valid()) { layer = layer_.layer(); // only new either reset of setNext //layer->ResetReading(); layer->SetNextByIndex(0); OGRFeature *poFeature; while ((poFeature = layer->GetNextFeature()) != NULL) { OGRGeometry* geom = poFeature->GetGeometryRef(); if (geom && ! geom->IsEmpty()) { switch (wkbFlatten(geom->getGeometryType())) { case wkbPoint: case wkbMultiPoint: result.reset(mapnik::datasource::Point); break; case wkbLinearRing: case wkbLineString: case wkbMultiLineString: result.reset(mapnik::datasource::LineString); break; case wkbPolygon: case wkbMultiPolygon: result.reset(mapnik::datasource::Polygon); break; case wkbGeometryCollection: result.reset(mapnik::datasource::Collection); break; default: break; } } OGRFeature::DestroyFeature( poFeature ); break; } } break; } default: break; } } return result; }
int OGRCARTODataSource::Open( const char * pszFilename, char** papszOpenOptionsIn, int bUpdateIn ) { bReadWrite = CPL_TO_BOOL(bUpdateIn); bBatchInsert = CPLTestBool( CSLFetchNameValueDef(papszOpenOptionsIn, "BATCH_INSERT", "YES")); pszName = CPLStrdup( pszFilename ); if( CSLFetchNameValue(papszOpenOptionsIn, "ACCOUNT") ) pszAccount = CPLStrdup(CSLFetchNameValue(papszOpenOptionsIn, "ACCOUNT")); else { if( STARTS_WITH_CI(pszFilename, "CARTODB:") ) pszAccount = CPLStrdup(pszFilename + strlen("CARTODB:")); else pszAccount = CPLStrdup(pszFilename + strlen("CARTO:")); char* pchSpace = strchr(pszAccount, ' '); if( pchSpace ) *pchSpace = '\0'; if( pszAccount[0] == 0 ) { CPLError(CE_Failure, CPLE_AppDefined, "Missing account name"); return FALSE; } } osAPIKey = CSLFetchNameValueDef( papszOpenOptionsIn, "API_KEY", CPLGetConfigOption("CARTO_API_KEY", CPLGetConfigOption("CARTODB_API_KEY", ""))); CPLString osTables = OGRCARTOGetOptionValue(pszFilename, "tables"); /*if( osTables.size() == 0 && osAPIKey.size() == 0 ) { CPLError(CE_Failure, CPLE_AppDefined, "When not specifying tables option, CARTO_API_KEY must be defined"); return FALSE; }*/ bUseHTTPS = CPLTestBool( CPLGetConfigOption("CARTO_HTTPS", CPLGetConfigOption("CARTODB_HTTPS", "YES"))); OGRLayer* poSchemaLayer = ExecuteSQLInternal("SELECT current_schema()"); if( poSchemaLayer ) { OGRFeature* poFeat = poSchemaLayer->GetNextFeature(); if( poFeat ) { if( poFeat->GetFieldCount() == 1 ) { osCurrentSchema = poFeat->GetFieldAsString(0); } delete poFeat; } ReleaseResultSet(poSchemaLayer); } if( osCurrentSchema.size() == 0 ) return FALSE; /* -------------------------------------------------------------------- */ /* Find out PostGIS version */ /* -------------------------------------------------------------------- */ if( bReadWrite ) { OGRLayer* poPostGISVersionLayer = ExecuteSQLInternal("SELECT postgis_version()"); if( poPostGISVersionLayer ) { OGRFeature* poFeat = poPostGISVersionLayer->GetNextFeature(); if( poFeat ) { if( poFeat->GetFieldCount() == 1 ) { const char* pszVersion = poFeat->GetFieldAsString(0); nPostGISMajor = atoi(pszVersion); const char* pszDot = strchr(pszVersion, '.'); nPostGISMinor = 0; if( pszDot ) nPostGISMinor = atoi(pszDot + 1); } delete poFeat; } ReleaseResultSet(poPostGISVersionLayer); } } if( osAPIKey.size() && bUpdateIn ) { ExecuteSQLInternal( "DROP FUNCTION IF EXISTS ogr_table_metadata(TEXT,TEXT); " "CREATE OR REPLACE FUNCTION ogr_table_metadata(schema_name TEXT, table_name TEXT) RETURNS TABLE " "(attname TEXT, typname TEXT, attlen INT, format_type TEXT, " "attnum INT, attnotnull BOOLEAN, indisprimary BOOLEAN, " "defaultexpr TEXT, dim INT, srid INT, geomtyp TEXT, srtext TEXT) AS $$ " "SELECT a.attname::text, t.typname::text, a.attlen::int, " "format_type(a.atttypid,a.atttypmod)::text, " "a.attnum::int, " "a.attnotnull::boolean, " "i.indisprimary::boolean, " "pg_get_expr(def.adbin, c.oid)::text AS defaultexpr, " "(CASE WHEN t.typname = 'geometry' THEN postgis_typmod_dims(a.atttypmod) ELSE NULL END)::int dim, " "(CASE WHEN t.typname = 'geometry' THEN postgis_typmod_srid(a.atttypmod) ELSE NULL END)::int srid, " "(CASE WHEN t.typname = 'geometry' THEN postgis_typmod_type(a.atttypmod) ELSE NULL END)::text geomtyp, " "srtext " "FROM pg_class c " "JOIN pg_attribute a ON a.attnum > 0 AND " "a.attrelid = c.oid AND c.relname = $2 " "AND c.relname IN (SELECT CDB_UserTables())" "JOIN pg_type t ON a.atttypid = t.oid " "JOIN pg_namespace n ON c.relnamespace=n.oid AND n.nspname = $1 " "LEFT JOIN pg_index i ON c.oid = i.indrelid AND " "i.indisprimary = 't' AND a.attnum = ANY(i.indkey) " "LEFT JOIN pg_attrdef def ON def.adrelid = c.oid AND " "def.adnum = a.attnum " "LEFT JOIN spatial_ref_sys srs ON srs.srid = postgis_typmod_srid(a.atttypmod) " "ORDER BY a.attnum " "$$ LANGUAGE SQL"); } if (osTables.size() != 0) { char** papszTables = CSLTokenizeString2(osTables, ",", 0); for(int i=0;papszTables && papszTables[i];i++) { papoLayers = (OGRCARTOTableLayer**) CPLRealloc( papoLayers, (nLayers + 1) * sizeof(OGRCARTOTableLayer*)); papoLayers[nLayers ++] = new OGRCARTOTableLayer(this, papszTables[i]); } CSLDestroy(papszTables); return TRUE; } OGRLayer* poTableListLayer = ExecuteSQLInternal("SELECT CDB_UserTables()"); if( poTableListLayer ) { OGRFeature* poFeat; while( (poFeat = poTableListLayer->GetNextFeature()) != NULL ) { if( poFeat->GetFieldCount() == 1 ) { papoLayers = (OGRCARTOTableLayer**) CPLRealloc( papoLayers, (nLayers + 1) * sizeof(OGRCARTOTableLayer*)); papoLayers[nLayers ++] = new OGRCARTOTableLayer( this, poFeat->GetFieldAsString(0)); } delete poFeat; } ReleaseResultSet(poTableListLayer); } else if( osCurrentSchema == "public" ) return FALSE; /* There's currently a bug with CDB_UserTables() on multi-user accounts */ if( nLayers == 0 && osCurrentSchema != "public" ) { CPLString osSQL; osSQL.Printf("SELECT c.relname FROM pg_class c, pg_namespace n " "WHERE c.relkind in ('r', 'v') AND c.relname !~ '^pg_' AND c.relnamespace=n.oid AND n.nspname = '%s'", OGRCARTOEscapeLiteral(osCurrentSchema).c_str()); poTableListLayer = ExecuteSQLInternal(osSQL); if( poTableListLayer ) { OGRFeature* poFeat; while( (poFeat = poTableListLayer->GetNextFeature()) != NULL ) { if( poFeat->GetFieldCount() == 1 ) { papoLayers = (OGRCARTOTableLayer**) CPLRealloc( papoLayers, (nLayers + 1) * sizeof(OGRCARTOTableLayer*)); papoLayers[nLayers ++] = new OGRCARTOTableLayer( this, poFeat->GetFieldAsString(0)); } delete poFeat; } ReleaseResultSet(poTableListLayer); } else return FALSE; } return TRUE; }
bool Shape::load(const std::string& filename) { GDALAllRegister(); GDALDataset* poDS; poDS = (GDALDataset*)GDALOpenEx(filename.c_str(), GDAL_OF_VECTOR, NULL, NULL, NULL); if (poDS == NULL) return false; // 初期化 shapeObjects.clear(); minBound.x = std::numeric_limits<float>::max(); minBound.y = std::numeric_limits<float>::max(); minBound.z = std::numeric_limits<float>::max(); maxBound.x = -std::numeric_limits<float>::max(); maxBound.y = -std::numeric_limits<float>::max(); maxBound.z = -std::numeric_limits<float>::max(); int nLayers = poDS->GetLayerCount(); int i = 0; for (int n = 0; n < nLayers; ++n) { OGRLayer* poLayer = poDS->GetLayer(n); shapeType = poLayer->GetGeomType(); shapeObjects.resize(shapeObjects.size() + poLayer->GetFeatureCount()); OGRFeature* poFeature; poLayer->ResetReading(); while ((poFeature = poLayer->GetNextFeature()) != NULL) { // 属性の名前を読み込む std::vector<std::string> fieldNames; for (int j = 0; j < poFeature->GetFieldCount(); ++j) { OGRFieldDefn* poFieldDefn = poFeature->GetFieldDefnRef(j); fieldNames.push_back(poFieldDefn->GetNameRef()); } // 属性の値を読み込む OGRFeatureDefn *poFDefn = poLayer->GetLayerDefn(); for (int j = 0; j < poFDefn->GetFieldCount(); ++j) { OGRFieldDefn* poFieldDefn = poFDefn->GetFieldDefn(j); if (poFieldDefn->GetType() == OFTInteger) { shapeObjects[i].attributes[fieldNames[j]] = Variant(poFeature->GetFieldAsInteger(j)); } else if (poFieldDefn->GetType() == OFTInteger64) { shapeObjects[i].attributes[fieldNames[j]] = Variant(poFeature->GetFieldAsInteger(j)); } else if (poFieldDefn->GetType() == OFTReal) { shapeObjects[i].attributes[fieldNames[j]] = Variant(poFeature->GetFieldAsDouble(j)); } else if (poFieldDefn->GetType() == OFTString) { shapeObjects[i].attributes[fieldNames[j]] = Variant(poFeature->GetFieldAsString(j)); } else { shapeObjects[i].attributes[fieldNames[j]] = Variant(poFeature->GetFieldAsString(j)); } } // このshapeのベクトルデータを読み込む OGRGeometry* poGeometry = poFeature->GetGeometryRef(); if (poGeometry != NULL) { if (wkbFlatten(poGeometry->getGeometryType()) == wkbPoint) { shapeObjects[i].parts.resize(1); shapeObjects[i].parts[0].points.resize(1); OGRPoint* poPoint = (OGRPoint*)poGeometry; shapeObjects[i].parts[0].points[0].x = poPoint->getX(); shapeObjects[i].parts[0].points[0].y = poPoint->getY(); updateBounds(poPoint); } else if (wkbFlatten(poGeometry->getGeometryType()) == wkbLineString) { OGRLineString* poLineString = (OGRLineString*)poGeometry; readLineString(poLineString, shapeObjects[i]); } else if (wkbFlatten(poGeometry->getGeometryType()) == wkbPolygon) { OGRPolygon* poPolygon = (OGRPolygon*)poGeometry; readPolygon(poPolygon, shapeObjects[i]); } else if (wkbFlatten(poGeometry->getGeometryType()) == wkbMultiPolygon) { OGRMultiPolygon* poMultiPolygon = (OGRMultiPolygon*)poGeometry; readMultiPolygon(poMultiPolygon, shapeObjects[i]); } else { // not supported } } // shapeObjectsのインデックスをインクリメント i++; // OGRが取得したメモリを開放 OGRFeature::DestroyFeature(poFeature); } } GDALClose(poDS); return true; }
bool Shape::save(const std::string& filename) { if (shapeType == -1) { std::cout << "Shape type is not set." << std::endl; return false; } if (shapeObjects.size() == 0) { std::cout << "No shape exists." << std::endl; return false; } const char *pszDriverName = "ESRI Shapefile"; GDALDriver *poDriver; GDALAllRegister(); poDriver = GetGDALDriverManager()->GetDriverByName(pszDriverName); if (poDriver == NULL) { printf("%s driver not available.\n", pszDriverName); return false; } GDALDataset *poDS; poDS = poDriver->Create(filename.c_str(), 0, 0, 0, GDT_Unknown, NULL); if (poDS == NULL) { printf("Creation of output file failed.\n"); return false; } OGRLayer *poLayer; if (shapeType == wkbPoint) { poLayer = poDS->CreateLayer("point_out", NULL, wkbPoint, NULL); } else if (shapeType == wkbLineString) { poLayer = poDS->CreateLayer("point_out", NULL, wkbLineString, NULL); } else if (shapeType == wkbPolygon) { poLayer = poDS->CreateLayer("point_out", NULL, wkbPolygon, NULL); } if (poLayer == NULL) { printf("Layer creation failed.\n"); return false; } for (auto it = shapeObjects[0].attributes.begin(); it != shapeObjects[0].attributes.end(); ++it) { OGRFieldDefn oField(it->first.c_str(), static_cast<OGRFieldType>(it->second.type)); if (it->second.type == OFTString) { oField.SetWidth(it->second.stringValue().size()); } if (poLayer->CreateField(&oField) != OGRERR_NONE) { printf("Creating Name field failed.\n"); return false; } } for (int i = 0; i < shapeObjects.size(); ++i) { if (shapeObjects[i].parts.size() == 0) continue; OGRFeature *poFeature; poFeature = OGRFeature::CreateFeature(poLayer->GetLayerDefn()); // 属性をセット for (auto it = shapeObjects[i].attributes.begin(); it != shapeObjects[i].attributes.end(); ++it) { poFeature->SetField(it->first.c_str(), it->second.stringValue().c_str()); } // ジオメトリ情報をセット if (shapeType == wkbPoint) { OGRPoint point; point.setX(shapeObjects[i].parts[0].points[0].x); point.setY(shapeObjects[i].parts[0].points[0].y); point.setZ(shapeObjects[i].parts[0].points[0].z); poFeature->SetGeometry(&point); } else if (shapeType == wkbLineString) { OGRLineString lineString; for (int k = 0; k < shapeObjects[i].parts[0].points.size(); ++k) { lineString.addPoint(shapeObjects[i].parts[0].points[k].x, shapeObjects[i].parts[0].points[k].y, shapeObjects[i].parts[0].points[k].z); } poFeature->SetGeometry(&lineString); } else if (shapeType == wkbPolygon) { OGRPolygon polygon; for (int j = 0; j < shapeObjects[i].parts.size(); ++j) { OGRLinearRing linearRing; for (int k = 0; k < shapeObjects[i].parts[j].points.size(); ++k) { linearRing.addPoint(shapeObjects[i].parts[j].points[k].x, shapeObjects[i].parts[j].points[k].y, shapeObjects[i].parts[j].points[k].z); } polygon.addRing(&linearRing); } poFeature->SetGeometry(&polygon); } if (poLayer->CreateFeature(poFeature) != OGRERR_NONE) { printf("Failed to create feature in shapefile.\n"); return false; } OGRFeature::DestroyFeature(poFeature); } GDALClose(poDS); return true; }
OGRFeature *OGROpenAirLayer::GetNextRawFeature() { const char* pszLine; CPLString osCLASS, osNAME, osFLOOR, osCEILING; OGRLinearRing oLR; double dfLastLat = 0, dfLastLon = 0; int bFirst = TRUE; int bClockWise = TRUE; double dfCenterLat = 0, dfCenterLon = 0; int bHasCenter = FALSE; OpenAirStyle sStyle; sStyle.penStyle = -1; sStyle.penWidth = -1; sStyle.penR = sStyle.penG = sStyle.penB = -1; sStyle.fillR = sStyle.fillG = sStyle.fillB = -1; if (bEOF) return NULL; while(TRUE) { if (bFirst && bHasLastLine) { pszLine = osLastLine.c_str(); bFirst = FALSE; } else { pszLine = CPLReadLine2L(fpOpenAir, 1024, NULL); if (pszLine == NULL) { bEOF = TRUE; if (oLR.getNumPoints() == 0) return NULL; if (osCLASS.size() != 0 && oStyleMap.find(osCLASS) != oStyleMap.end()) { memcpy(&sStyle, oStyleMap[osCLASS], sizeof(sStyle)); } break; } osLastLine = pszLine; bHasLastLine = TRUE; } if (pszLine[0] == '*' || pszLine[0] == '\0') continue; if (EQUALN(pszLine, "AC ", 3) || EQUALN(pszLine, "AC,", 3)) { if (osCLASS.size() != 0) { if (sStyle.penStyle != -1 || sStyle.fillR != -1) { if (oLR.getNumPoints() == 0) { OpenAirStyle* psStyle; if (oStyleMap.find(osCLASS) == oStyleMap.end()) { psStyle = (OpenAirStyle*)CPLMalloc( sizeof(OpenAirStyle)); oStyleMap[osCLASS] = psStyle; } else psStyle = oStyleMap[osCLASS]; memcpy(psStyle, &sStyle, sizeof(sStyle)); } else break; } else if (oStyleMap.find(osCLASS) != oStyleMap.end()) { memcpy(&sStyle, oStyleMap[osCLASS], sizeof(sStyle)); break; } else break; } sStyle.penStyle = -1; sStyle.penWidth = -1; sStyle.penR = sStyle.penG = sStyle.penB = -1; sStyle.fillR = sStyle.fillG = sStyle.fillB = -1; osCLASS = pszLine + 3; bClockWise = TRUE; bHasCenter = FALSE; } else if (EQUALN(pszLine, "AN ", 3)) { if (osNAME.size() != 0) break; 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)) { /* Ignored for that layer*/ } else if (EQUALN(pszLine, "SP ", 3)) { if (osCLASS.size() != 0) { char** papszTokens = CSLTokenizeString2(pszLine+3, ", ", 0); if (CSLCount(papszTokens) == 5) { sStyle.penStyle = atoi(papszTokens[0]); sStyle.penWidth = atoi(papszTokens[1]); sStyle.penR = atoi(papszTokens[2]); sStyle.penG = atoi(papszTokens[3]); sStyle.penB = atoi(papszTokens[4]); } CSLDestroy(papszTokens); } } else if (EQUALN(pszLine, "SB ", 3)) { if (osCLASS.size() != 0) { char** papszTokens = CSLTokenizeString2(pszLine+3, ", ", 0); if (CSLCount(papszTokens) == 3) { sStyle.fillR = atoi(papszTokens[0]); sStyle.fillG = atoi(papszTokens[1]); sStyle.fillB = atoi(papszTokens[2]); } CSLDestroy(papszTokens); } } else if (EQUALN(pszLine, "DP ", 3)) { pszLine += 3; double dfLat, dfLon; if (!OGROpenAirGetLatLon(pszLine, dfLat, dfLon)) continue; oLR.addPoint(dfLon, dfLat); dfLastLat = dfLat; dfLastLon = dfLon; } else if (EQUALN(pszLine, "DA ", 3)) { pszLine += 3; char* pszStar = strchr((char*)pszLine, '*'); if (pszStar) *pszStar = 0; char** papszTokens = CSLTokenizeString2(pszLine, ",", 0); if (bHasCenter && CSLCount(papszTokens) == 3) { double dfRadius = atof(papszTokens[0]) * 1852; double dfStartAngle = atof(papszTokens[1]); double dfEndAngle = atof(papszTokens[2]); if (bClockWise && dfEndAngle < dfStartAngle) dfEndAngle += 360; else if (!bClockWise && dfStartAngle < dfEndAngle) dfEndAngle -= 360; double dfStartDistance = dfRadius; double dfEndDistance = dfRadius; int nSign = (bClockWise) ? 1 : -1; double dfAngle; double dfLat, dfLon; for(dfAngle = dfStartAngle; (dfAngle - dfEndAngle) * nSign < 0; dfAngle += nSign) { double pct = (dfAngle - dfStartAngle) / (dfEndAngle - dfStartAngle); double dfDist = dfStartDistance * (1-pct) + dfEndDistance * pct; OGRXPlane_ExtendPosition(dfCenterLat, dfCenterLon, dfDist, dfAngle, &dfLat, &dfLon); oLR.addPoint(dfLon, dfLat); } OGRXPlane_ExtendPosition(dfCenterLat, dfCenterLon, dfEndDistance, dfEndAngle, &dfLat, &dfLon); oLR.addPoint(dfLon, dfLat); dfLastLat = oLR.getY(oLR.getNumPoints() - 1); dfLastLon = oLR.getX(oLR.getNumPoints() - 1); } CSLDestroy(papszTokens); } else if (EQUALN(pszLine, "DB ", 3)) { pszLine += 3; char* pszStar = strchr((char*)pszLine, '*'); if (pszStar) *pszStar = 0; char** papszTokens = CSLTokenizeString2(pszLine, ",", 0); double dfFirstLat, dfFirstLon; double dfSecondLat, dfSecondLon; if (bHasCenter && CSLCount(papszTokens) == 2 && OGROpenAirGetLatLon(papszTokens[0], dfFirstLat, dfFirstLon) && OGROpenAirGetLatLon(papszTokens[1], dfSecondLat, dfSecondLon)) { double dfStartDistance =OGRXPlane_Distance(dfCenterLat, dfCenterLon, dfFirstLat, dfFirstLon); double dfEndDistance = OGRXPlane_Distance(dfCenterLat, dfCenterLon, dfSecondLat, dfSecondLon); double dfStartAngle = OGRXPlane_Track(dfCenterLat, dfCenterLon, dfFirstLat, dfFirstLon); double dfEndAngle = OGRXPlane_Track(dfCenterLat, dfCenterLon, dfSecondLat, dfSecondLon); if (bClockWise && dfEndAngle < dfStartAngle) dfEndAngle += 360; else if (!bClockWise && dfStartAngle < dfEndAngle) dfEndAngle -= 360; int nSign = (bClockWise) ? 1 : -1; double dfAngle; for(dfAngle = dfStartAngle; (dfAngle - dfEndAngle) * nSign < 0; dfAngle += nSign) { double dfLat, dfLon; double pct = (dfAngle - dfStartAngle) / (dfEndAngle - dfStartAngle); double dfDist = dfStartDistance * (1-pct) + dfEndDistance * pct; OGRXPlane_ExtendPosition(dfCenterLat, dfCenterLon, dfDist, dfAngle, &dfLat, &dfLon); oLR.addPoint(dfLon, dfLat); } oLR.addPoint(dfSecondLon, dfSecondLat); dfLastLat = oLR.getY(oLR.getNumPoints() - 1); dfLastLon = oLR.getX(oLR.getNumPoints() - 1); } CSLDestroy(papszTokens); } else if ((EQUALN(pszLine, "DC ", 3) || EQUALN(pszLine, "DC=", 3)) && (bHasCenter || strstr(pszLine, "V X=") != NULL)) { if (!bHasCenter) { const char* pszVX = strstr(pszLine, "V X="); bHasCenter = OGROpenAirGetLatLon(pszVX, dfCenterLat, dfCenterLon); } if (bHasCenter) { pszLine += 3; double dfRADIUS = atof(pszLine) * 1852; double dfAngle; double dfLat, dfLon; for(dfAngle = 0; dfAngle < 360; dfAngle += 1) { OGRXPlane_ExtendPosition(dfCenterLat, dfCenterLon, dfRADIUS, dfAngle, &dfLat, &dfLon); oLR.addPoint(dfLon, dfLat); } OGRXPlane_ExtendPosition(dfCenterLat, dfCenterLon, dfRADIUS, 0, &dfLat, &dfLon); oLR.addPoint(dfLon, dfLat); dfLastLat = oLR.getY(oLR.getNumPoints() - 1); dfLastLon = oLR.getX(oLR.getNumPoints() - 1); } } else if (EQUALN(pszLine, "V X=", 4)) { bHasCenter = OGROpenAirGetLatLon(pszLine + 4, dfCenterLat, dfCenterLon); } else if (EQUALN(pszLine, "V D=-", 5)) { bClockWise = FALSE; } else if (EQUALN(pszLine, "V D=+", 5)) { bClockWise = TRUE; } else { //CPLDebug("OpenAir", "Unexpected content : %s", pszLine); } } 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()); if (sStyle.penStyle != -1 || sStyle.fillR != -1) { CPLString osStyle; if (sStyle.penStyle != -1) { osStyle += CPLString().Printf("PEN(c:#%02X%02X%02X,w:%dpt", sStyle.penR, sStyle.penG, sStyle.penB, sStyle.penWidth); if (sStyle.penStyle == 1) osStyle += ",p:\"5px 5px\""; osStyle += ")"; } if (sStyle.fillR != -1) { if (osStyle.size() != 0) osStyle += ";"; osStyle += CPLString().Printf("BRUSH(fc:#%02X%02X%02X)", sStyle.fillR, sStyle.fillG, sStyle.fillB); } else { if (osStyle.size() != 0) osStyle += ";"; osStyle += "BRUSH(fc:#00000000,id:\"ogr-brush-1\")"; } if (osStyle.size() != 0) poFeature->SetStyleString(osStyle); } OGRPolygon* poPoly = new OGRPolygon(); oLR.closeRings(); poPoly->addRing(&oLR); poPoly->assignSpatialReference(poSRS); poFeature->SetGeometryDirectly(poPoly); poFeature->SetFID(nNextFID++); return poFeature; }
OGRFeature *OGRWalkLayer::GetNextRawFeature() { if( GetStatement() == nullptr ) return nullptr; /* -------------------------------------------------------------------- */ /* If we are marked to restart then do so, and fetch a record. */ /* -------------------------------------------------------------------- */ if( !poStmt->Fetch() ) { delete poStmt; poStmt = nullptr; return nullptr; } /* -------------------------------------------------------------------- */ /* Create a feature from the current result. */ /* -------------------------------------------------------------------- */ OGRFeature *poFeature = new OGRFeature( poFeatureDefn ); if( pszFIDColumn != nullptr && poStmt->GetColId(pszFIDColumn) > -1 ) poFeature->SetFID( atoi(poStmt->GetColData(poStmt->GetColId(pszFIDColumn))) ); else poFeature->SetFID( iNextShapeId ); iNextShapeId++; m_nFeaturesRead++; /* -------------------------------------------------------------------- */ /* Set the fields. */ /* -------------------------------------------------------------------- */ for( int iField = 0; iField < poFeatureDefn->GetFieldCount(); iField++ ) { int iSrcField = panFieldOrdinals[iField]-1; const char *pszValue = poStmt->GetColData( iSrcField ); if( pszValue == nullptr ) poFeature->SetFieldNull( iField ); else if( poFeature->GetFieldDefnRef(iField)->GetType() == OFTBinary ) poFeature->SetField( iField, poStmt->GetColDataLength(iSrcField), (GByte *) pszValue ); else poFeature->SetField( iField, pszValue ); } /* -------------------------------------------------------------------- */ /* Try to extract a geometry. */ /* -------------------------------------------------------------------- */ if( pszGeomColumn != nullptr ) { int iField = poStmt->GetColId( pszGeomColumn ); const char *pszGeomBin = poStmt->GetColData( iField ); int nGeomLength = poStmt->GetColDataLength( iField ); OGRGeometry *poGeom = nullptr; OGRErr eErr = OGRERR_NONE; if( pszGeomBin != nullptr && bGeomColumnWKB ) { WKBGeometry *WalkGeom = (WKBGeometry *)CPLMalloc(sizeof(WKBGeometry)); if( Binary2WkbGeom((unsigned char *)pszGeomBin, WalkGeom, nGeomLength) != OGRERR_NONE ) { CPLFree(WalkGeom); return nullptr; } eErr = TranslateWalkGeom(&poGeom, WalkGeom); DeleteWKBGeometry(*WalkGeom); CPLFree(WalkGeom); } if ( eErr != OGRERR_NONE ) { const char *pszMessage = nullptr; switch ( eErr ) { case OGRERR_NOT_ENOUGH_DATA: pszMessage = "Not enough data to deserialize"; break; case OGRERR_UNSUPPORTED_GEOMETRY_TYPE: pszMessage = "Unsupported geometry type"; break; case OGRERR_CORRUPT_DATA: pszMessage = "Corrupt data"; break; default: pszMessage = "Unrecognized error"; } CPLError(CE_Failure, CPLE_AppDefined, "GetNextRawFeature(): %s", pszMessage); } if( poGeom != nullptr && eErr == OGRERR_NONE ) { poGeom->assignSpatialReference( poSRS ); poFeature->SetGeometryDirectly( poGeom ); } } return poFeature; }
OGRFeature *OGRNASLayer::GetNextFeature() { GMLFeature *poNASFeature = NULL; OGRGeometry *poGeom = NULL; if( iNextNASId == 0 ) ResetReading(); /* ==================================================================== */ /* Loop till we find and translate a feature meeting all our */ /* requirements. */ /* ==================================================================== */ while( TRUE ) { /* -------------------------------------------------------------------- */ /* Cleanup last feature, and get a new raw nas feature. */ /* -------------------------------------------------------------------- */ delete poNASFeature; delete poGeom; poNASFeature = NULL; poGeom = NULL; poNASFeature = poDS->GetReader()->NextFeature(); if( poNASFeature == NULL ) return NULL; /* -------------------------------------------------------------------- */ /* Is it of the proper feature class? */ /* -------------------------------------------------------------------- */ // We count reading low level NAS features as a feature read for // work checking purposes, though at least we didn't necessary // have to turn it into an OGRFeature. m_nFeaturesRead++; if( poNASFeature->GetClass() != poFClass ) continue; iNextNASId++; /* -------------------------------------------------------------------- */ /* Does it satisfy the spatial query, if there is one? */ /* -------------------------------------------------------------------- */ const CPLXMLNode* const * papsGeometry = poNASFeature->GetGeometryList(); if (papsGeometry[0] != NULL) { poGeom = (OGRGeometry*) OGR_G_CreateFromGMLTree(papsGeometry[0]); if( EQUAL( papsGeometry[0]->pszValue, "CompositeCurve" ) || EQUAL( papsGeometry[0]->pszValue, "MultiCurve" ) || EQUAL( papsGeometry[0]->pszValue, "LineString" ) || EQUAL( papsGeometry[0]->pszValue, "MultiLineString" ) || EQUAL( papsGeometry[0]->pszValue, "Curve" ) ) { poGeom = OGRGeometryFactory::forceToLineString( poGeom, false ); } // poGeom->dumpReadable( 0, "NAS: " ); // We assume the OGR_G_CreateFromGMLTree() function would have already // reported an error. if( poGeom == NULL ) { delete poNASFeature; return NULL; } if( m_poFilterGeom != NULL && !FilterGeometry( poGeom ) ) continue; } /* -------------------------------------------------------------------- */ /* Convert the whole feature into an OGRFeature. */ /* -------------------------------------------------------------------- */ int iField; OGRFeature *poOGRFeature = new OGRFeature( GetLayerDefn() ); poOGRFeature->SetFID( iNextNASId ); for( iField = 0; iField < poFClass->GetPropertyCount(); iField++ ) { const GMLProperty *psGMLProperty = poNASFeature->GetProperty( iField ); if( psGMLProperty == NULL || psGMLProperty->nSubProperties == 0 ) continue; switch( poFClass->GetProperty(iField)->GetType() ) { case GMLPT_Real: { poOGRFeature->SetField( iField, CPLAtof(psGMLProperty->papszSubProperties[0]) ); } break; case GMLPT_IntegerList: { int nCount = psGMLProperty->nSubProperties; int *panIntList = (int *) CPLMalloc(sizeof(int) * nCount ); int i; for( i = 0; i < nCount; i++ ) panIntList[i] = atoi(psGMLProperty->papszSubProperties[i]); poOGRFeature->SetField( iField, nCount, panIntList ); CPLFree( panIntList ); } break; case GMLPT_RealList: { int nCount = psGMLProperty->nSubProperties; double *padfList = (double *)CPLMalloc(sizeof(double)*nCount); int i; for( i = 0; i < nCount; i++ ) padfList[i] = CPLAtof(psGMLProperty->papszSubProperties[i]); poOGRFeature->SetField( iField, nCount, padfList ); CPLFree( padfList ); } break; case GMLPT_StringList: { poOGRFeature->SetField( iField, psGMLProperty->papszSubProperties ); } break; default: poOGRFeature->SetField( iField, psGMLProperty->papszSubProperties[0] ); break; } } /* -------------------------------------------------------------------- */ /* Test against the attribute query. */ /* -------------------------------------------------------------------- */ if( m_poAttrQuery != NULL && !m_poAttrQuery->Evaluate( poOGRFeature ) ) { delete poOGRFeature; continue; } /* -------------------------------------------------------------------- */ /* Wow, we got our desired feature. Return it. */ /* -------------------------------------------------------------------- */ if( poGeom && poOGRFeature->SetGeometryDirectly( poGeom ) != OGRERR_NONE ) { int iId = poNASFeature->GetClass()->GetPropertyIndex( "gml_id" ); const GMLProperty *poIdProp = poNASFeature->GetProperty(iId); CPLError( CE_Warning, CPLE_AppDefined, "NAS: could not set geometry (gml_id:%s)", poIdProp && poIdProp->nSubProperties>0 && poIdProp->papszSubProperties[0] ? poIdProp->papszSubProperties[0] : "(null)" ); } delete poNASFeature; return poOGRFeature; } return NULL; }
void OGRILI1Layer::PolygonizeAreaLayer( OGRILI1Layer* poAreaLineLayer, int nAreaFieldIndex, int nPointFieldIndex ) { //add all lines from poAreaLineLayer to collection OGRGeometryCollection *gc = new OGRGeometryCollection(); poAreaLineLayer->ResetReading(); while (OGRFeature *feature = poAreaLineLayer->GetNextFeatureRef()) gc->addGeometry(feature->GetGeometryRef()); //polygonize lines CPLDebug( "OGR_ILI", "Polygonizing layer %s with %d multilines", poAreaLineLayer->GetLayerDefn()->GetName(), gc->getNumGeometries()); poAreaLineLayer = 0; OGRMultiPolygon* polys = Polygonize( gc , false); CPLDebug( "OGR_ILI", "Resulting polygons: %d", polys->getNumGeometries()); if (polys->getNumGeometries() != GetFeatureCount()) { CPLDebug( "OGR_ILI", "Feature count of layer %s: %d", GetLayerDefn()->GetName(), GetFeatureCount()); CPLDebug( "OGR_ILI", "Polygonizing again with crossing line fix"); delete polys; polys = Polygonize( gc, true ); //try again with crossing line fix } delete gc; //associate polygon feature with data row according to centroid #if defined(HAVE_GEOS) int i; OGRPolygon emptyPoly; GEOSGeom *ahInGeoms = NULL; CPLDebug( "OGR_ILI", "Associating layer %s with area polygons", GetLayerDefn()->GetName()); ahInGeoms = (GEOSGeom *) CPLCalloc(sizeof(void*), polys->getNumGeometries()); GEOSContextHandle_t hGEOSCtxt = OGRGeometry::createGEOSContext(); for( i = 0; i < polys->getNumGeometries(); i++ ) { ahInGeoms[i] = polys->getGeometryRef(i)->exportToGEOS(hGEOSCtxt); if (!GEOSisValid_r(hGEOSCtxt, ahInGeoms[i])) ahInGeoms[i] = NULL; } for ( int nFidx = 0; nFidx < nFeatures; nFidx++) { OGRFeature *feature = papoFeatures[nFidx]; OGRGeometry* geomRef = feature->GetGeomFieldRef(nPointFieldIndex); if( !geomRef ) { continue; } GEOSGeom point = (GEOSGeom)(geomRef->exportToGEOS(hGEOSCtxt)); for (i = 0; i < polys->getNumGeometries(); i++ ) { if (ahInGeoms[i] && GEOSWithin_r(hGEOSCtxt, point, ahInGeoms[i])) { feature->SetGeomField(nAreaFieldIndex, polys->getGeometryRef(i)); break; } } if (i == polys->getNumGeometries()) { CPLDebug( "OGR_ILI", "Association between area and point failed."); feature->SetGeometry( &emptyPoly ); } GEOSGeom_destroy_r( hGEOSCtxt, point ); } for( i = 0; i < polys->getNumGeometries(); i++ ) GEOSGeom_destroy_r( hGEOSCtxt, ahInGeoms[i] ); CPLFree( ahInGeoms ); OGRGeometry::freeGEOSContext( hGEOSCtxt ); #endif poAreaLineLayer = 0; delete polys; }
OGRLayer * OGRSQLiteExecuteSQL( OGRDataSource* poDS, const char *pszStatement, OGRGeometry *poSpatialFilter, const char *pszDialect ) { char* pszTmpDBName = (char*) CPLMalloc(256); sprintf(pszTmpDBName, "/vsimem/ogr2sqlite/temp_%p.db", pszTmpDBName); OGRSQLiteDataSource* poSQLiteDS = NULL; int nRet; int bSpatialiteDB = FALSE; CPLString osOldVal; const char* pszOldVal = CPLGetConfigOption("OGR_SQLITE_STATIC_VIRTUAL_OGR", NULL); if( pszOldVal != NULL ) { osOldVal = pszOldVal; pszOldVal = osOldVal.c_str(); } /* -------------------------------------------------------------------- */ /* Create in-memory sqlite/spatialite DB */ /* -------------------------------------------------------------------- */ #ifdef HAVE_SPATIALITE /* -------------------------------------------------------------------- */ /* Creating an empty spatialite DB (with spatial_ref_sys populated */ /* has a non-neglectable cost. So at the first attempt, let's make */ /* one and cache it for later use. */ /* -------------------------------------------------------------------- */ #if 1 static vsi_l_offset nEmptyDBSize = 0; static GByte* pabyEmptyDB = NULL; { static void* hMutex = NULL; CPLMutexHolder oMutexHolder(&hMutex); static int bTried = FALSE; if( !bTried && CSLTestBoolean(CPLGetConfigOption("OGR_SQLITE_DIALECT_USE_SPATIALITE", "YES")) ) { bTried = TRUE; char* pszCachedFilename = (char*) CPLMalloc(256); sprintf(pszCachedFilename, "/vsimem/ogr2sqlite/reference_%p.db",pszCachedFilename); char** papszOptions = CSLAddString(NULL, "SPATIALITE=YES"); OGRSQLiteDataSource* poCachedDS = new OGRSQLiteDataSource(); nRet = poCachedDS->Create( pszCachedFilename, papszOptions ); CSLDestroy(papszOptions); papszOptions = NULL; delete poCachedDS; if( nRet ) /* Note: the reference file keeps the ownership of the data, so that */ /* it gets released with VSICleanupFileManager() */ pabyEmptyDB = VSIGetMemFileBuffer( pszCachedFilename, &nEmptyDBSize, FALSE ); CPLFree( pszCachedFilename ); } } /* The following configuration option is usefull mostly for debugging/testing */ if( pabyEmptyDB != NULL && CSLTestBoolean(CPLGetConfigOption("OGR_SQLITE_DIALECT_USE_SPATIALITE", "YES")) ) { GByte* pabyEmptyDBClone = (GByte*)VSIMalloc(nEmptyDBSize); if( pabyEmptyDBClone == NULL ) { CPLFree(pszTmpDBName); return NULL; } memcpy(pabyEmptyDBClone, pabyEmptyDB, nEmptyDBSize); VSIFCloseL(VSIFileFromMemBuffer( pszTmpDBName, pabyEmptyDBClone, nEmptyDBSize, TRUE )); poSQLiteDS = new OGRSQLiteDataSource(); CPLSetThreadLocalConfigOption("OGR_SQLITE_STATIC_VIRTUAL_OGR", "NO"); nRet = poSQLiteDS->Open( pszTmpDBName, TRUE ); CPLSetThreadLocalConfigOption("OGR_SQLITE_STATIC_VIRTUAL_OGR", pszOldVal); if( !nRet ) { /* should not happen really ! */ delete poSQLiteDS; VSIUnlink(pszTmpDBName); CPLFree(pszTmpDBName); return NULL; } bSpatialiteDB = TRUE; } #else /* No caching version */ poSQLiteDS = new OGRSQLiteDataSource(); char** papszOptions = CSLAddString(NULL, "SPATIALITE=YES"); CPLSetThreadLocalConfigOption("OGR_SQLITE_STATIC_VIRTUAL_OGR", "NO"); nRet = poSQLiteDS->Create( pszTmpDBName, papszOptions ); CPLSetThreadLocalConfigOption("OGR_SQLITE_STATIC_VIRTUAL_OGR", pszOldVal); CSLDestroy(papszOptions); papszOptions = NULL; if( nRet ) { bSpatialiteDB = TRUE; } #endif else { delete poSQLiteDS; poSQLiteDS = NULL; #else // HAVE_SPATIALITE if( TRUE ) { #endif // HAVE_SPATIALITE poSQLiteDS = new OGRSQLiteDataSource(); CPLSetThreadLocalConfigOption("OGR_SQLITE_STATIC_VIRTUAL_OGR", "NO"); nRet = poSQLiteDS->Create( pszTmpDBName, NULL ); CPLSetThreadLocalConfigOption("OGR_SQLITE_STATIC_VIRTUAL_OGR", pszOldVal); if( !nRet ) { delete poSQLiteDS; VSIUnlink(pszTmpDBName); CPLFree(pszTmpDBName); return NULL; } } /* -------------------------------------------------------------------- */ /* Attach the Virtual Table OGR2SQLITE module to it. */ /* -------------------------------------------------------------------- */ OGR2SQLITEModule* poModule = OGR2SQLITE_Setup(poDS, poSQLiteDS); sqlite3* hDB = poSQLiteDS->GetDB(); /* -------------------------------------------------------------------- */ /* Analysze the statement to determine which tables will be used. */ /* -------------------------------------------------------------------- */ std::set<LayerDesc> oSetLayers; std::set<CPLString> oSetSpatialIndex; CPLString osModifiedSQL; OGR2SQLITEGetPotentialLayerNames(pszStatement, oSetLayers, oSetSpatialIndex, osModifiedSQL); std::set<LayerDesc>::iterator oIter = oSetLayers.begin(); if( strcmp(pszStatement, osModifiedSQL.c_str()) != 0 ) CPLDebug("OGR", "Modified SQL: %s", osModifiedSQL.c_str()); pszStatement = osModifiedSQL.c_str(); /* do not use it anymore */ int bFoundOGRStyle = ( osModifiedSQL.ifind("OGR_STYLE") != std::string::npos ); /* -------------------------------------------------------------------- */ /* For each of those tables, create a Virtual Table. */ /* -------------------------------------------------------------------- */ for(; oIter != oSetLayers.end(); ++oIter) { const LayerDesc& oLayerDesc = *oIter; /*CPLDebug("OGR", "Layer desc : %s, %s, %s, %s", oLayerDesc.osOriginalStr.c_str(), oLayerDesc.osSubstitutedName.c_str(), oLayerDesc.osDSName.c_str(), oLayerDesc.osLayerName.c_str());*/ CPLString osSQL; OGRLayer* poLayer = NULL; CPLString osTableName; int nExtraDS; if( oLayerDesc.osDSName.size() == 0 ) { poLayer = poDS->GetLayerByName(oLayerDesc.osLayerName); /* Might be a false positive (unlikely) */ if( poLayer == NULL ) continue; osTableName = oLayerDesc.osLayerName; nExtraDS = -1; osSQL.Printf("CREATE VIRTUAL TABLE \"%s\" USING VirtualOGR(%d,'%s',%d)", OGRSQLiteEscapeName(osTableName).c_str(), nExtraDS, OGRSQLiteEscape(osTableName).c_str(), bFoundOGRStyle); } else { OGRDataSource* poOtherDS = (OGRDataSource* ) OGROpen(oLayerDesc.osDSName, FALSE, NULL); if( poOtherDS == NULL ) { CPLError(CE_Failure, CPLE_AppDefined, "Cannot open datasource '%s'", oLayerDesc.osDSName.c_str() ); delete poSQLiteDS; VSIUnlink(pszTmpDBName); CPLFree(pszTmpDBName); return NULL; } poLayer = poOtherDS->GetLayerByName(oLayerDesc.osLayerName); if( poLayer == NULL ) { CPLError(CE_Failure, CPLE_AppDefined, "Cannot find layer '%s' in '%s'", oLayerDesc.osLayerName.c_str(), oLayerDesc.osDSName.c_str() ); delete poOtherDS; delete poSQLiteDS; VSIUnlink(pszTmpDBName); CPLFree(pszTmpDBName); return NULL; } osTableName = oLayerDesc.osSubstitutedName; nExtraDS = OGR2SQLITE_AddExtraDS(poModule, poOtherDS); osSQL.Printf("CREATE VIRTUAL TABLE \"%s\" USING VirtualOGR(%d,'%s',%d)", OGRSQLiteEscapeName(osTableName).c_str(), nExtraDS, OGRSQLiteEscape(oLayerDesc.osLayerName).c_str(), bFoundOGRStyle); } char* pszErrMsg = NULL; int rc = sqlite3_exec( hDB, osSQL.c_str(), NULL, NULL, &pszErrMsg ); if( rc != SQLITE_OK ) { CPLError(CE_Failure, CPLE_AppDefined, "Cannot create virtual table for layer '%s' : %s", osTableName.c_str(), pszErrMsg); sqlite3_free(pszErrMsg); continue; } if( poLayer->GetGeomType() == wkbNone ) continue; CPLString osGeomColRaw(OGR2SQLITE_GetNameForGeometryColumn(poLayer)); const char* pszGeomColRaw = osGeomColRaw.c_str(); CPLString osGeomColEscaped(OGRSQLiteEscape(pszGeomColRaw)); const char* pszGeomColEscaped = osGeomColEscaped.c_str(); CPLString osLayerNameEscaped(OGRSQLiteEscape(osTableName)); const char* pszLayerNameEscaped = osLayerNameEscaped.c_str(); CPLString osIdxNameRaw(CPLSPrintf("idx_%s_%s", oLayerDesc.osLayerName.c_str(), pszGeomColRaw)); CPLString osIdxNameEscaped(OGRSQLiteEscapeName(osIdxNameRaw)); /* Make sure that the SRS is injected in spatial_ref_sys */ OGRSpatialReference* poSRS = poLayer->GetSpatialRef(); int nSRSId = poSQLiteDS->GetUndefinedSRID(); if( poSRS != NULL ) nSRSId = poSQLiteDS->FetchSRSId(poSRS); int bCreateSpatialIndex = FALSE; if( !bSpatialiteDB ) { osSQL.Printf("INSERT INTO geometry_columns (f_table_name, " "f_geometry_column, geometry_format, geometry_type, " "coord_dimension, srid) " "VALUES ('%s','%s','SpatiaLite',%d,%d,%d)", pszLayerNameEscaped, pszGeomColEscaped, (int) wkbFlatten(poLayer->GetGeomType()), ( poLayer->GetGeomType() & wkb25DBit ) ? 3 : 2, nSRSId); } #ifdef HAVE_SPATIALITE else { /* We detect the need for creating a spatial index by 2 means : */ /* 1) if there's an explicit reference to a 'idx_layername_geometrycolumn' */ /* table in the SQL --> old/traditionnal way of requesting spatial indices */ /* with spatialite. */ std::set<LayerDesc>::iterator oIter2 = oSetLayers.begin(); for(; oIter2 != oSetLayers.end(); ++oIter2) { const LayerDesc& oLayerDescIter = *oIter2; if( EQUAL(oLayerDescIter.osLayerName, osIdxNameRaw) ) { bCreateSpatialIndex = TRUE; break; } } /* 2) or if there's a SELECT FROM SpatialIndex WHERE f_table_name = 'layername' */ if( !bCreateSpatialIndex ) { std::set<CPLString>::iterator oIter3 = oSetSpatialIndex.begin(); for(; oIter3 != oSetSpatialIndex.end(); ++oIter3) { const CPLString& osNameIter = *oIter3; if( EQUAL(osNameIter, oLayerDesc.osLayerName) ) { bCreateSpatialIndex = TRUE; break; } } } if( poSQLiteDS->HasSpatialite4Layout() ) { int nGeomType = poLayer->GetGeomType(); int nCoordDimension = 2; if( nGeomType & wkb25DBit ) { nGeomType += 1000; nCoordDimension = 3; } osSQL.Printf("INSERT INTO geometry_columns (f_table_name, " "f_geometry_column, geometry_type, coord_dimension, " "srid, spatial_index_enabled) " "VALUES ('%s',Lower('%s'),%d ,%d ,%d, %d)", pszLayerNameEscaped, pszGeomColEscaped, nGeomType, nCoordDimension, nSRSId, bCreateSpatialIndex ); } else { const char *pszGeometryType = OGRToOGCGeomType(poLayer->GetGeomType()); if (pszGeometryType[0] == '\0') pszGeometryType = "GEOMETRY"; osSQL.Printf("INSERT INTO geometry_columns (f_table_name, " "f_geometry_column, type, coord_dimension, " "srid, spatial_index_enabled) " "VALUES ('%s','%s','%s','%s',%d, %d)", pszLayerNameEscaped, pszGeomColEscaped, pszGeometryType, ( poLayer->GetGeomType() & wkb25DBit ) ? "XYZ" : "XY", nSRSId, bCreateSpatialIndex ); } } #endif // HAVE_SPATIALITE sqlite3_exec( hDB, osSQL.c_str(), NULL, NULL, NULL ); #ifdef HAVE_SPATIALITE /* -------------------------------------------------------------------- */ /* Should we create a spatial index ?. */ /* -------------------------------------------------------------------- */ if( !bSpatialiteDB || !bCreateSpatialIndex ) continue; CPLDebug("SQLITE", "Create spatial index %s", osIdxNameRaw.c_str()); /* ENABLE_VIRTUAL_OGR_SPATIAL_INDEX is not defined */ #ifdef ENABLE_VIRTUAL_OGR_SPATIAL_INDEX osSQL.Printf("CREATE VIRTUAL TABLE \"%s\" USING " "VirtualOGRSpatialIndex(%d, '%s', pkid, xmin, xmax, ymin, ymax)", osIdxNameEscaped.c_str(), nExtraDS, OGRSQLiteEscape(oLayerDesc.osLayerName).c_str()); rc = sqlite3_exec( hDB, osSQL.c_str(), NULL, NULL, NULL ); if( rc != SQLITE_OK ) { CPLDebug("SQLITE", "Error occured during spatial index creation : %s", sqlite3_errmsg(hDB)); } #else // ENABLE_VIRTUAL_OGR_SPATIAL_INDEX rc = sqlite3_exec( hDB, "BEGIN", NULL, NULL, NULL ); osSQL.Printf("CREATE VIRTUAL TABLE \"%s\" " "USING rtree(pkid, xmin, xmax, ymin, ymax)", osIdxNameEscaped.c_str()); if( rc == SQLITE_OK ) rc = sqlite3_exec( hDB, osSQL.c_str(), NULL, NULL, NULL ); sqlite3_stmt *hStmt = NULL; if( rc == SQLITE_OK ) { const char* pszInsertInto = CPLSPrintf( "INSERT INTO \"%s\" (pkid, xmin, xmax, ymin, ymax) " "VALUES (?,?,?,?,?)", osIdxNameEscaped.c_str()); rc = sqlite3_prepare(hDB, pszInsertInto, -1, &hStmt, NULL); } OGRFeature* poFeature; OGREnvelope sEnvelope; OGR2SQLITE_IgnoreAllFieldsExceptGeometry(poLayer); poLayer->ResetReading(); while( rc == SQLITE_OK && (poFeature = poLayer->GetNextFeature()) != NULL ) { OGRGeometry* poGeom = poFeature->GetGeometryRef(); if( poGeom != NULL && !poGeom->IsEmpty() ) { poGeom->getEnvelope(&sEnvelope); sqlite3_bind_int64(hStmt, 1, (sqlite3_int64) poFeature->GetFID() ); sqlite3_bind_double(hStmt, 2, sEnvelope.MinX); sqlite3_bind_double(hStmt, 3, sEnvelope.MaxX); sqlite3_bind_double(hStmt, 4, sEnvelope.MinY); sqlite3_bind_double(hStmt, 5, sEnvelope.MaxY); rc = sqlite3_step(hStmt); if( rc == SQLITE_OK || rc == SQLITE_DONE ) rc = sqlite3_reset(hStmt); } delete poFeature; } poLayer->SetIgnoredFields(NULL); sqlite3_finalize(hStmt); if( rc == SQLITE_OK ) rc = sqlite3_exec( hDB, "COMMIT", NULL, NULL, NULL ); else { CPLDebug("SQLITE", "Error occured during spatial index creation : %s", sqlite3_errmsg(hDB)); rc = sqlite3_exec( hDB, "ROLLBACK", NULL, NULL, NULL ); } #endif // ENABLE_VIRTUAL_OGR_SPATIAL_INDEX #endif // HAVE_SPATIALITE } /* -------------------------------------------------------------------- */ /* Reload, so that virtual tables are recognized */ /* -------------------------------------------------------------------- */ poSQLiteDS->ReloadLayers(); /* -------------------------------------------------------------------- */ /* Prepare the statement. */ /* -------------------------------------------------------------------- */ /* This will speed-up layer creation */ /* ORDER BY are costly to evaluate and are not necessary to establish */ /* the layer definition. */ int bUseStatementForGetNextFeature = TRUE; int bEmptyLayer = FALSE; sqlite3_stmt *hSQLStmt = NULL; int rc = sqlite3_prepare( hDB, pszStatement, strlen(pszStatement), &hSQLStmt, NULL ); if( rc != SQLITE_OK ) { CPLError( CE_Failure, CPLE_AppDefined, "In ExecuteSQL(): sqlite3_prepare(%s):\n %s", pszStatement, sqlite3_errmsg(hDB) ); if( hSQLStmt != NULL ) { sqlite3_finalize( hSQLStmt ); } delete poSQLiteDS; VSIUnlink(pszTmpDBName); CPLFree(pszTmpDBName); return NULL; } /* -------------------------------------------------------------------- */ /* Do we get a resultset? */ /* -------------------------------------------------------------------- */ rc = sqlite3_step( hSQLStmt ); if( rc != SQLITE_ROW ) { if ( rc != SQLITE_DONE ) { CPLError( CE_Failure, CPLE_AppDefined, "In ExecuteSQL(): sqlite3_step(%s):\n %s", pszStatement, sqlite3_errmsg(hDB) ); sqlite3_finalize( hSQLStmt ); delete poSQLiteDS; VSIUnlink(pszTmpDBName); CPLFree(pszTmpDBName); return NULL; } if( !EQUALN(pszStatement, "SELECT ", 7) ) { sqlite3_finalize( hSQLStmt ); delete poSQLiteDS; VSIUnlink(pszTmpDBName); CPLFree(pszTmpDBName); return NULL; } bUseStatementForGetNextFeature = FALSE; bEmptyLayer = TRUE; } /* -------------------------------------------------------------------- */ /* Create layer. */ /* -------------------------------------------------------------------- */ OGRSQLiteSelectLayer *poLayer = NULL; poLayer = new OGRSQLiteExecuteSQLLayer( pszTmpDBName, poSQLiteDS, pszStatement, hSQLStmt, bUseStatementForGetNextFeature, bEmptyLayer ); if( poSpatialFilter != NULL ) poLayer->SetSpatialFilter( poSpatialFilter ); return poLayer; } /************************************************************************/ /* OGRSQLiteGetReferencedLayers() */ /************************************************************************/ std::set<LayerDesc> OGRSQLiteGetReferencedLayers(const char* pszStatement) { /* -------------------------------------------------------------------- */ /* Analysze the statement to determine which tables will be used. */ /* -------------------------------------------------------------------- */ std::set<LayerDesc> oSetLayers; std::set<CPLString> oSetSpatialIndex; CPLString osModifiedSQL; OGR2SQLITEGetPotentialLayerNames(pszStatement, oSetLayers, oSetSpatialIndex, osModifiedSQL); return oSetLayers; }
bool CStakeInfo::Load() { OGRRegisterAll(); OGRDataSource* poDataSource = NULL; poDataSource = OGRSFDriverRegistrar::Open(m_strPath.c_str()); if (poDataSource == NULL) { printf("Open file faild [%s]", m_strPath.c_str()); return false; } OGRLayer *poLayer; OGRFeature *poFeature; poLayer = poDataSource->GetLayerByName(CPLGetBasename(m_strPath.c_str())); poLayer->ResetReading(); while ((poFeature = poLayer->GetNextFeature()) != NULL) { StakeInfo stStakeInfo; try { stStakeInfo.routeID = poFeature->GetFieldAsString("RD_NAME"); stStakeInfo.lLinkID = poFeature->GetFieldAsInteger("LINKID"); stStakeInfo.dcoord.Lat = poFeature->GetFieldAsDouble("XSWD"); stStakeInfo.dcoord.Lon = poFeature->GetFieldAsDouble("XSJD"); #ifdef ONLY_STAKE_DATA stStakeInfo.strRouteName = poFeature->GetFieldAsString("LXMC"); stStakeInfo.iDir = poFeature->GetFieldAsInteger("SXX"); stStakeInfo.stakeID = atoi(poFeature->GetFieldAsString("LCZ")); #else stStakeInfo.stakeID = (int)poFeature->GetFieldAsDouble("LCZ"); #endif // auto itWay = m_mapStakeInfo.find(stStakeInfo.routeID); if (itWay != m_mapStakeInfo.end()) { std::map<long long, std::vector<StakeInfo>>& mapStakeLink = itWay->second; auto itLink = mapStakeLink.find(stStakeInfo.lLinkID); if (itLink != mapStakeLink.end()) { std::vector<StakeInfo>& vecStakeInfo = itLink->second; for (int ii = 0;ii < vecStakeInfo.size(); ii++) { if (vecStakeInfo[ii].stakeID == stStakeInfo.stakeID) { auto itStake = vecStakeInfo.begin(); itStake += ii; vecStakeInfo.erase(itStake); } } vecStakeInfo.push_back(stStakeInfo); } else { std::vector<StakeInfo> vecStakeInfo; mapStakeLink.insert(std::pair<long long, std::vector<StakeInfo>>(stStakeInfo.lLinkID, vecStakeInfo)); itLink = mapStakeLink.find(stStakeInfo.lLinkID); itLink->second.push_back(stStakeInfo); } } else { std::map<long long, std::vector<StakeInfo>> mapStakeLink; m_mapStakeInfo.insert(std::pair<std::string, std::map<long long, std::vector<StakeInfo>>>( stStakeInfo.routeID, mapStakeLink)); itWay = m_mapStakeInfo.find(stStakeInfo.routeID); std::vector<StakeInfo> vecStakeInfo; itWay->second.insert(std::pair<long long, std::vector<StakeInfo>>(stStakeInfo.lLinkID, vecStakeInfo)); auto itLink = itWay->second.find(stStakeInfo.lLinkID); itLink->second.push_back(stStakeInfo); } } catch (const std::exception&) { return false; } OGRFeature::DestroyFeature(poFeature); } OGRDataSource::DestroyDataSource(poDataSource); return true; }
int OGRAVCE00Layer::FormPolygonGeometry( OGRFeature *poFeature, AVCPal *psPAL ) { /* -------------------------------------------------------------------- */ /* Try to find the corresponding ARC layer if not already */ /* recorded. */ /* -------------------------------------------------------------------- */ if( poArcLayer == NULL ) { int i; for( i = 0; i < poDS->GetLayerCount(); i++ ) { OGRAVCE00Layer *poLayer = (OGRAVCE00Layer *) poDS->GetLayer(i); if( poLayer->eSectionType == AVCFileARC ) poArcLayer = poLayer; } if( poArcLayer == NULL ) return FALSE; } /* -------------------------------------------------------------------- */ /* Read all the arcs related to this polygon, making a working */ /* copy of them since the one returned by AVC is temporary. */ /* -------------------------------------------------------------------- */ OGRGeometryCollection oArcs; int iArc; for( iArc = 0; iArc < psPAL->numArcs; iArc++ ) { OGRFeature *poArc; if( psPAL->pasArcs[iArc].nArcId == 0 ) continue; // If the other side of the line is the same polygon then this // arc is a "bridge" arc and can be discarded. If we don't discard // it, then we should double it as bridge arcs seem to only appear // once. But by discarding it we ensure a multi-ring polygon will be // properly formed. if( psPAL->pasArcs[iArc].nAdjPoly == psPAL->nPolyId ) continue; poArc = poArcLayer->GetFeature( ABS(psPAL->pasArcs[iArc].nArcId) ); if( poArc == NULL ) return FALSE; if( poArc->GetGeometryRef() == NULL ) return FALSE; oArcs.addGeometry( poArc->GetGeometryRef() ); OGRFeature::DestroyFeature( poArc ); } OGRErr eErr; OGRPolygon *poPolygon; poPolygon = (OGRPolygon *) OGRBuildPolygonFromEdges( (OGRGeometryH) &oArcs, TRUE, FALSE, 0.0, &eErr ); if( poPolygon != NULL ) poFeature->SetGeometryDirectly( poPolygon ); return eErr == OGRERR_NONE; }
OGRFeature *OGRMSSQLSpatialLayer::GetNextRawFeature() { if( GetStatement() == NULL ) return NULL; /* -------------------------------------------------------------------- */ /* If we are marked to restart then do so, and fetch a record. */ /* -------------------------------------------------------------------- */ if( !poStmt->Fetch() ) { delete poStmt; poStmt = NULL; return NULL; } /* -------------------------------------------------------------------- */ /* Create a feature from the current result. */ /* -------------------------------------------------------------------- */ int iField; OGRFeature *poFeature = new OGRFeature( poFeatureDefn ); if( pszFIDColumn != NULL && poStmt->GetColId(pszFIDColumn) > -1 ) poFeature->SetFID( CPLAtoGIntBig(poStmt->GetColData(poStmt->GetColId(pszFIDColumn))) ); else poFeature->SetFID( iNextShapeId ); iNextShapeId++; m_nFeaturesRead++; /* -------------------------------------------------------------------- */ /* Set the fields. */ /* -------------------------------------------------------------------- */ for( iField = 0; iField < poFeatureDefn->GetFieldCount(); iField++ ) { if ( poFeatureDefn->GetFieldDefn(iField)->IsIgnored() ) continue; int iSrcField = panFieldOrdinals[iField]; const char *pszValue = poStmt->GetColData( iSrcField ); if( pszValue == NULL ) /* no value */; else if( poFeature->GetFieldDefnRef(iField)->GetType() == OFTBinary ) poFeature->SetField( iField, poStmt->GetColDataLength(iSrcField), (GByte *) pszValue ); else poFeature->SetField( iField, pszValue ); } /* -------------------------------------------------------------------- */ /* Try to extract a geometry. */ /* -------------------------------------------------------------------- */ if( pszGeomColumn != NULL && !poFeatureDefn->IsGeometryIgnored()) { int iField = poStmt->GetColId( pszGeomColumn ); const char *pszGeomText = poStmt->GetColData( iField ); OGRGeometry *poGeom = NULL; OGRErr eErr = OGRERR_NONE; if( pszGeomText != NULL ) { int nLength = poStmt->GetColDataLength( iField ); if ( nGeomColumnType == MSSQLCOLTYPE_GEOMETRY || nGeomColumnType == MSSQLCOLTYPE_GEOGRAPHY || nGeomColumnType == MSSQLCOLTYPE_BINARY) { switch ( poDS->GetGeometryFormat() ) { case MSSQLGEOMETRY_NATIVE: { OGRMSSQLGeometryParser oParser( nGeomColumnType ); eErr = oParser.ParseSqlGeometry( (unsigned char *) pszGeomText, nLength, &poGeom ); nSRSId = oParser.GetSRSId(); } break; case MSSQLGEOMETRY_WKB: case MSSQLGEOMETRY_WKBZM: eErr = OGRGeometryFactory::createFromWkb((unsigned char *) pszGeomText, NULL, &poGeom, nLength); break; case MSSQLGEOMETRY_WKT: eErr = OGRGeometryFactory::createFromWkt((char **) &pszGeomText, NULL, &poGeom); break; } } else if (nGeomColumnType == MSSQLCOLTYPE_TEXT) { eErr = OGRGeometryFactory::createFromWkt((char **) &pszGeomText, NULL, &poGeom); } } if ( eErr != OGRERR_NONE ) { const char *pszMessage; switch ( eErr ) { case OGRERR_NOT_ENOUGH_DATA: pszMessage = "Not enough data to deserialize"; break; case OGRERR_UNSUPPORTED_GEOMETRY_TYPE: pszMessage = "Unsupported geometry type"; break; case OGRERR_CORRUPT_DATA: pszMessage = "Corrupt data"; break; default: pszMessage = "Unrecognized error"; } CPLError(CE_Failure, CPLE_AppDefined, "GetNextRawFeature(): %s", pszMessage); } if( poGeom != NULL ) { if ( GetSpatialRef() ) poGeom->assignSpatialReference( poSRS ); poFeature->SetGeometryDirectly( poGeom ); } } return poFeature; }
OGRFeature *OGRAVCLayer::TranslateFeature( void *pAVCFeature ) { m_nFeaturesRead++; switch( eSectionType ) { /* ==================================================================== */ /* ARC */ /* ==================================================================== */ case AVCFileARC: { AVCArc *psArc = static_cast<AVCArc *>( pAVCFeature ); /* -------------------------------------------------------------------- */ /* Create feature. */ /* -------------------------------------------------------------------- */ OGRFeature *poOGRFeature = new OGRFeature( GetLayerDefn() ); poOGRFeature->SetFID( psArc->nArcId ); /* -------------------------------------------------------------------- */ /* Apply the line geometry. */ /* -------------------------------------------------------------------- */ OGRLineString *poLine = new OGRLineString(); poLine->setNumPoints( psArc->numVertices ); for( int iVert = 0; iVert < psArc->numVertices; iVert++ ) poLine->setPoint( iVert, psArc->pasVertices[iVert].x, psArc->pasVertices[iVert].y ); poOGRFeature->SetGeometryDirectly( poLine ); /* -------------------------------------------------------------------- */ /* Apply attributes. */ /* -------------------------------------------------------------------- */ poOGRFeature->SetField( 0, psArc->nUserId ); poOGRFeature->SetField( 1, psArc->nFNode ); poOGRFeature->SetField( 2, psArc->nTNode ); poOGRFeature->SetField( 3, psArc->nLPoly ); poOGRFeature->SetField( 4, psArc->nRPoly ); return poOGRFeature; } /* ==================================================================== */ /* PAL (Polygon) */ /* RPL (Region) */ /* ==================================================================== */ case AVCFilePAL: case AVCFileRPL: { AVCPal *psPAL = static_cast<AVCPal *>( pAVCFeature ); /* -------------------------------------------------------------------- */ /* Create feature. */ /* -------------------------------------------------------------------- */ OGRFeature *poOGRFeature = new OGRFeature( GetLayerDefn() ); poOGRFeature->SetFID( psPAL->nPolyId ); /* -------------------------------------------------------------------- */ /* Apply attributes. */ /* -------------------------------------------------------------------- */ // Setup ArcId list. int *panArcs = static_cast<int *>( CPLMalloc(sizeof(int) * psPAL->numArcs ) ); for( int i = 0; i < psPAL->numArcs; i++ ) panArcs[i] = psPAL->pasArcs[i].nArcId; poOGRFeature->SetField( 0, psPAL->numArcs, panArcs ); CPLFree( panArcs ); return poOGRFeature; } /* ==================================================================== */ /* CNT (Centroid) */ /* ==================================================================== */ case AVCFileCNT: { AVCCnt *psCNT = (AVCCnt *) pAVCFeature; /* -------------------------------------------------------------------- */ /* Create feature. */ /* -------------------------------------------------------------------- */ OGRFeature *poOGRFeature = new OGRFeature( GetLayerDefn() ); poOGRFeature->SetFID( psCNT->nPolyId ); /* -------------------------------------------------------------------- */ /* Apply Geometry */ /* -------------------------------------------------------------------- */ poOGRFeature->SetGeometryDirectly( new OGRPoint( psCNT->sCoord.x, psCNT->sCoord.y ) ); /* -------------------------------------------------------------------- */ /* Apply attributes. */ /* -------------------------------------------------------------------- */ poOGRFeature->SetField( 0, psCNT->numLabels, psCNT->panLabelIds ); return poOGRFeature; } /* ==================================================================== */ /* LAB (Label) */ /* ==================================================================== */ case AVCFileLAB: { AVCLab *psLAB = static_cast<AVCLab *>( pAVCFeature ); /* -------------------------------------------------------------------- */ /* Create feature. */ /* -------------------------------------------------------------------- */ OGRFeature *poOGRFeature = new OGRFeature( GetLayerDefn() ); poOGRFeature->SetFID( psLAB->nValue ); /* -------------------------------------------------------------------- */ /* Apply Geometry */ /* -------------------------------------------------------------------- */ poOGRFeature->SetGeometryDirectly( new OGRPoint( psLAB->sCoord1.x, psLAB->sCoord1.y ) ); /* -------------------------------------------------------------------- */ /* Apply attributes. */ /* -------------------------------------------------------------------- */ poOGRFeature->SetField( 0, psLAB->nValue ); poOGRFeature->SetField( 1, psLAB->nPolyId ); return poOGRFeature; } /* ==================================================================== */ /* TXT/TX6 (Text) */ /* ==================================================================== */ case AVCFileTXT: case AVCFileTX6: { AVCTxt *psTXT = static_cast<AVCTxt *>( pAVCFeature ); /* -------------------------------------------------------------------- */ /* Create feature. */ /* -------------------------------------------------------------------- */ OGRFeature *poOGRFeature = new OGRFeature( GetLayerDefn() ); poOGRFeature->SetFID( psTXT->nTxtId ); /* -------------------------------------------------------------------- */ /* Apply Geometry */ /* -------------------------------------------------------------------- */ if( psTXT->numVerticesLine > 0 ) poOGRFeature->SetGeometryDirectly( new OGRPoint( psTXT->pasVertices[0].x, psTXT->pasVertices[0].y ) ); /* -------------------------------------------------------------------- */ /* Apply attributes. */ /* -------------------------------------------------------------------- */ poOGRFeature->SetField( 0, psTXT->nUserId ); poOGRFeature->SetField( 1, reinterpret_cast<char *>( psTXT->pszText ) ); poOGRFeature->SetField( 2, psTXT->dHeight ); poOGRFeature->SetField( 3, psTXT->nLevel ); return poOGRFeature; } default: return NULL; } }
TABFeature* IMapInfoFile::CreateTABFeature(OGRFeature *poFeature) { TABFeature *poTABFeature; OGRGeometry *poGeom; OGRwkbGeometryType eGType; TABPoint *poTABPointFeature = NULL; TABRegion *poTABRegionFeature = NULL; TABPolyline *poTABPolylineFeature = NULL; /*----------------------------------------------------------------- * MITAB won't accept new features unless they are in a type derived * from TABFeature... so we have to do our best to map to the right * feature type based on the geometry type. *----------------------------------------------------------------*/ poGeom = poFeature->GetGeometryRef(); if( poGeom != NULL ) eGType = poGeom->getGeometryType(); else eGType = wkbNone; switch( wkbFlatten(eGType) ) { /*------------------------------------------------------------- * POINT *------------------------------------------------------------*/ case wkbPoint: poTABFeature = new TABPoint(poFeature->GetDefnRef()); if(poFeature->GetStyleString()) { poTABPointFeature = (TABPoint*)poTABFeature; poTABPointFeature->SetSymbolFromStyleString( poFeature->GetStyleString()); } break; /*------------------------------------------------------------- * REGION *------------------------------------------------------------*/ case wkbPolygon: case wkbMultiPolygon: poTABFeature = new TABRegion(poFeature->GetDefnRef()); if(poFeature->GetStyleString()) { poTABRegionFeature = (TABRegion*)poTABFeature; poTABRegionFeature->SetPenFromStyleString( poFeature->GetStyleString()); poTABRegionFeature->SetBrushFromStyleString( poFeature->GetStyleString()); } break; /*------------------------------------------------------------- * LINE/PLINE/MULTIPLINE *------------------------------------------------------------*/ case wkbLineString: case wkbMultiLineString: poTABFeature = new TABPolyline(poFeature->GetDefnRef()); if(poFeature->GetStyleString()) { poTABPolylineFeature = (TABPolyline*)poTABFeature; poTABPolylineFeature->SetPenFromStyleString( poFeature->GetStyleString()); } break; /*------------------------------------------------------------- * Collection types that are not directly supported... convert * to multiple features in output file through recursive calls. *------------------------------------------------------------*/ case wkbGeometryCollection: case wkbMultiPoint: { OGRErr eStatus = OGRERR_NONE; int i; OGRGeometryCollection *poColl = (OGRGeometryCollection*)poGeom; OGRFeature *poTmpFeature = poFeature->Clone(); for (i=0; eStatus==OGRERR_NONE && i<poColl->getNumGeometries(); i++) { poTmpFeature->SetFID(OGRNullFID); poTmpFeature->SetGeometry(poColl->getGeometryRef(i)); eStatus = ICreateFeature(poTmpFeature); } delete poTmpFeature; return NULL; } break; /*------------------------------------------------------------- * Unsupported type.... convert to MapInfo geometry NONE *------------------------------------------------------------*/ case wkbUnknown: default: poTABFeature = new TABFeature(poFeature->GetDefnRef()); break; } if( poGeom != NULL ) poTABFeature->SetGeometryDirectly(poGeom->clone()); for (int i=0; i< poFeature->GetDefnRef()->GetFieldCount();i++) { poTABFeature->SetField(i,poFeature->GetRawFieldRef( i )); } poTABFeature->SetFID(poFeature->GetFID()); return poTABFeature; }
OGRFeature *OGRDXFLayer::TranslateHATCH() { char szLineBuf[257]; int nCode; OGRFeature *poFeature = new OGRFeature( poFeatureDefn ); CPLString osHatchPattern; int nFillFlag = 0; OGRGeometryCollection oGC; while( (nCode = poDS->ReadValue(szLineBuf,sizeof(szLineBuf))) > 0 ) { switch( nCode ) { case 70: nFillFlag = atoi(szLineBuf); break; case 2: osHatchPattern = szLineBuf; poFeature->SetField( "Text", osHatchPattern.c_str() ); break; case 91: { int nBoundaryPathCount = atoi(szLineBuf); int iBoundary; for( iBoundary = 0; iBoundary < nBoundaryPathCount; iBoundary++ ) { CollectBoundaryPath( &oGC ); } } break; default: TranslateGenericProperty( poFeature, nCode, szLineBuf ); break; } } if( nCode == 0 ) poDS->UnreadValue(); /* -------------------------------------------------------------------- */ /* Try to turn the set of lines into something useful. */ /* -------------------------------------------------------------------- */ OGRErr eErr; OGRGeometry* poFinalGeom = (OGRGeometry *) OGRBuildPolygonFromEdges( (OGRGeometryH) &oGC, TRUE, TRUE, 0.0000001, &eErr ); ApplyOCSTransformer( poFinalGeom ); poFeature->SetGeometryDirectly( poFinalGeom ); /* -------------------------------------------------------------------- */ /* Work out the color for this feature. For now we just assume */ /* solid fill. We cannot trivially translate the various sorts */ /* of hatching. */ /* -------------------------------------------------------------------- */ CPLString osLayer = poFeature->GetFieldAsString("Layer"); int nColor = 256; if( oStyleProperties.count("Color") > 0 ) nColor = atoi(oStyleProperties["Color"]); // Use layer color? if( nColor < 1 || nColor > 255 ) { const char *pszValue = poDS->LookupLayerProperty( osLayer, "Color" ); if( pszValue != NULL ) nColor = atoi(pszValue); } /* -------------------------------------------------------------------- */ /* Setup the style string. */ /* -------------------------------------------------------------------- */ if( nColor >= 1 && nColor <= 255 ) { CPLString osStyle; const unsigned char *pabyDXFColors = ACGetColorTable(); osStyle.Printf( "BRUSH(fc:#%02x%02x%02x)", pabyDXFColors[nColor*3+0], pabyDXFColors[nColor*3+1], pabyDXFColors[nColor*3+2] ); poFeature->SetStyleString( osStyle ); } return poFeature; }
GDALDataset* OGRPLScenesDataset::OpenRasterScene(GDALOpenInfo* poOpenInfo, CPLString osScene, char** papszOptions) { if( !(poOpenInfo->nOpenFlags & GDAL_OF_RASTER) ) { return NULL; } for( char** papszIter = papszOptions; papszIter && *papszIter; papszIter ++ ) { char* pszKey; const char* pszValue = CPLParseNameValue(*papszIter, &pszKey); if( pszValue != NULL ) { if( !EQUAL(pszKey, "api_key") && !EQUAL(pszKey, "scene") && !EQUAL(pszKey, "product_type") ) { CPLError(CE_Failure, CPLE_NotSupported, "Unsupported option %s", pszKey); CPLFree(pszKey); return NULL; } CPLFree(pszKey); } } const char* pszProductType = CSLFetchNameValueDef(papszOptions, "product_type", CSLFetchNameValueDef(poOpenInfo->papszOpenOptions, "PRODUCT_TYPE", "visual")); CPLString osRasterURL; osRasterURL = osBaseURL; osRasterURL += "ortho/"; osRasterURL += osScene; json_object* poObj = RunRequest( osRasterURL ); if( poObj == NULL ) return NULL; json_object* poProperties = json_object_object_get(poObj, "properties"); if( poProperties == NULL || json_object_get_type(poProperties) != json_type_object ) { CPLError(CE_Failure, CPLE_AppDefined, "Cannot find properties object"); json_object_put(poObj); return NULL; } const char* pszLink = NULL; if( EQUAL(pszProductType, "thumb") ) { json_object* poLinks = json_object_object_get(poProperties, "links"); if( poLinks != NULL && json_object_get_type(poLinks) == json_type_object ) { json_object* poThumbnail = json_object_object_get(poLinks, "thumbnail"); if( poThumbnail && json_object_get_type(poThumbnail) == json_type_string ) pszLink = json_object_get_string(poThumbnail); } } else { json_object* poData = json_object_object_get(poProperties, "data"); if( poData != NULL && json_object_get_type(poData) == json_type_object ) { json_object* poProducts = json_object_object_get(poData, "products"); if( poProducts != NULL && json_object_get_type(poProducts) == json_type_object ) { json_object* poProduct = json_object_object_get(poProducts, pszProductType); if( poProduct != NULL && json_object_get_type(poProduct) == json_type_object ) { json_object* poFull = json_object_object_get(poProduct, "full"); if( poFull && json_object_get_type(poFull) == json_type_string ) pszLink = json_object_get_string(poFull); } } } } osRasterURL = pszLink ? pszLink : ""; json_object_put(poObj); if( osRasterURL.size() == 0 ) { CPLError(CE_Failure, CPLE_AppDefined, "Cannot find link to scene %s", osScene.c_str()); return NULL; } if( strncmp(osRasterURL, "http://", strlen("http://")) == 0 ) { osRasterURL = "http://" + osAPIKey + ":@" + osRasterURL.substr(strlen("http://")); } else if( strncmp(osRasterURL, "https://", strlen("https://")) == 0 ) { osRasterURL = "https://" + osAPIKey + ":@" + osRasterURL.substr(strlen("https://")); } CPLString osOldHead(CPLGetConfigOption("CPL_VSIL_CURL_USE_HEAD", "")); CPLString osOldExt(CPLGetConfigOption("CPL_VSIL_CURL_ALLOWED_EXTENSIONS", "")); int bUseVSICURL = CSLFetchBoolean(poOpenInfo->papszOpenOptions, "RANDOM_ACCESS", TRUE); if( bUseVSICURL && !(strncmp(osBaseURL, "/vsimem/", strlen("/vsimem/")) == 0) ) { CPLSetThreadLocalConfigOption("CPL_VSIL_CURL_USE_HEAD", "NO"); CPLSetThreadLocalConfigOption("CPL_VSIL_CURL_ALLOWED_EXTENSIONS", "{noext}"); VSIStatBufL sStat; if( VSIStatL(("/vsicurl/" + osRasterURL).c_str(), &sStat) == 0 && sStat.st_size > 0 ) { osRasterURL = "/vsicurl/" + osRasterURL; } else { CPLDebug("PLSCENES", "Cannot use random access for that file"); } } GDALDataset* poOutDS = (GDALDataset*) GDALOpen(osRasterURL, GA_ReadOnly); if( poOutDS ) { poOutDS->SetDescription(poOpenInfo->pszFilename); poOutDS->GetFileList(); /* so as to probe all auxiliary files before reseting the allowed extensions */ if( !EQUAL(pszProductType, "thumb") ) { OGRPLScenesLayer* poLayer = new OGRPLScenesLayer(this, "ortho", (osBaseURL + "ortho/").c_str()); papoLayers = (OGRPLScenesLayer**) CPLRealloc(papoLayers, sizeof(OGRPLScenesLayer*) * (nLayers + 1)); papoLayers[nLayers ++] = poLayer; /* Attach scene matadata */ poLayer->SetAttributeFilter(CPLSPrintf("id = '%s'", osScene.c_str())); OGRFeature* poFeat = poLayer->GetNextFeature(); if( poFeat ) { for(int i=0;i<poFeat->GetFieldCount();i++) { if( poFeat->IsFieldSet(i) ) { const char* pszKey = poFeat->GetFieldDefnRef(i)->GetNameRef(); const char* pszVal = poFeat->GetFieldAsString(i); if( strstr(pszKey, "file_size") == NULL && strstr(pszVal, "https://") == NULL ) { poOutDS->SetMetadataItem(pszKey, pszVal); } } } } delete poFeat; } } if( bUseVSICURL ) { CPLSetThreadLocalConfigOption("CPL_VSIL_CURL_USE_HEAD", osOldHead.size() ? osOldHead.c_str(): NULL); CPLSetThreadLocalConfigOption("CPL_VSIL_CURL_ALLOWED_EXTENSIONS", osOldExt.size() ? osOldExt.c_str(): NULL); } return poOutDS; }
OGRFeature *OGRHTFPolygonLayer::GetNextRawFeature() { OGRFeature* poFeature = new OGRFeature(poFeatureDefn); const char* pszLine; OGRLinearRing oLR; bool bHasFirstCoord = false; double dfFirstEasting = 0; double dfFirstNorthing = 0; double dfIslandEasting = 0; double dfIslandNorthing = 0; bool bInIsland = false; OGRPolygon* poPoly = new OGRPolygon(); while( (pszLine = CPLReadLine2L(fpHTF, 1024, NULL)) != NULL) { if (pszLine[0] == ';') { /* comment */ ; } else if (pszLine[0] == 0) { /* end of polygon is marked by a blank line */ break; } else if (STARTS_WITH(pszLine, "POLYGON DESCRIPTION: ")) { poFeature->SetField(0, pszLine + strlen("POLYGON DESCRIPTION: ")); } else if (STARTS_WITH(pszLine, "POLYGON IDENTIFIER: ")) { poFeature->SetField(1, pszLine + strlen("POLYGON IDENTIFIER: ")); } else if (STARTS_WITH(pszLine, "SEAFLOOR COVERAGE: ")) { const char* pszVal = pszLine + strlen("SEAFLOOR COVERAGE: "); if (*pszVal != '*') poFeature->SetField(2, pszVal); } else if (STARTS_WITH(pszLine, "POSITION ACCURACY: ")) { const char* pszVal = pszLine + strlen("POSITION ACCURACY: "); if (*pszVal != '*') poFeature->SetField(3, pszVal); } else if (STARTS_WITH(pszLine, "DEPTH ACCURACY: ")) { const char* pszVal = pszLine + strlen("DEPTH ACCURACY: "); if (*pszVal != '*') poFeature->SetField(4, pszVal); } else if (strcmp(pszLine, "END OF POLYGON DATA") == 0) { bEOF = true; break; } else { char** papszTokens = CSLTokenizeString(pszLine); if (CSLCount(papszTokens) == 4) { const double dfEasting = CPLAtof(papszTokens[2]); const double dfNorthing = CPLAtof(papszTokens[3]); if (!bHasFirstCoord) { bHasFirstCoord = true; dfFirstEasting = dfEasting; dfFirstNorthing = dfNorthing; oLR.addPoint(dfEasting, dfNorthing); } else if (dfFirstEasting == dfEasting && dfFirstNorthing == dfNorthing) { if (!bInIsland) { oLR.addPoint(dfEasting, dfNorthing); poPoly->addRing(&oLR); oLR.empty(); bInIsland = true; } } else if (bInIsland && oLR.getNumPoints() == 0) { dfIslandEasting = dfEasting; dfIslandNorthing = dfNorthing; oLR.addPoint(dfEasting, dfNorthing); } else if (bInIsland && dfIslandEasting == dfEasting && dfIslandNorthing == dfNorthing) { oLR.addPoint(dfEasting, dfNorthing); poPoly->addRing(&oLR); oLR.empty(); } else { oLR.addPoint(dfEasting, dfNorthing); } } CSLDestroy(papszTokens); } } if (pszLine == NULL) bEOF = true; if (oLR.getNumPoints() >= 3) { oLR.closeRings(); poPoly->addRing(&oLR); } poPoly->assignSpatialReference(poSRS); poFeature->SetGeometryDirectly(poPoly); poFeature->SetFID(nNextFID++); return poFeature; }
bool RainWaterHarvestingOptions::initmodel() { sink = new DynaMindStreamLogSink(); Log::init(sink, Error); simreg = new SimulationRegistry(); nodereg = new NodeRegistry(); //s = 0; std::map<std::string, Flow::CalculationUnit> flowdef; flowdef["Q"]=Flow::flow; Flow::undefine(); Flow::define(flowdef); QDir dir("./"); Logger(Standard) << dir.absolutePath().toStdString(); cd3_start_date = this->start_date; cd3_end_date =this->end_date; DM::Logger(DM::Standard) << cd3_start_date; DM::Logger(DM::Standard) << cd3_end_date; if (start_date_from_global) { global_object.resetReading(); OGRFeature * f; while (f = global_object.getNextFeature()) { cd3_start_date = f->GetFieldAsString(start_date_name.c_str()); cd3_end_date = f->GetFieldAsString(end_date_name.c_str()); break; // we assume only one global feature } } try{ // Register default simulation #if defined(_WIN32) this->simreg->addNativePlugin(this->getSimulation()->getSimulationConfig().getDefaultLibraryPath() + "/cd3core"); #else this->simreg->addNativePlugin(this->getSimulation()->getSimulationConfig().getDefaultLibraryPath() + "/libcd3core"); #endif // Register default modules #if defined(_WIN32) nodereg->addNativePlugin(this->getSimulation()->getSimulationConfig().getDefaultLibraryPath() + "/cd3core"); #else nodereg->addNativePlugin(this->getSimulation()->getSimulationConfig().getDefaultLibraryPath() + "/libcd3core"); #endif #if defined(_WIN32) QString dance_nodes = QString::fromStdString(this->getSimulation()->getSimulationConfig().getDefaultModulePath() + "/CD3Modules/dance4water-nodes"); #else QString dance_nodes = QString::fromStdString(this->getSimulation()->getSimulationConfig().getDefaultModulePath() + "/CD3Modules/libdance4water-nodes"); #endif nodereg->addNativePlugin(dance_nodes.toStdString()); nodereg->addToPythonPath(this->getSimulation()->getSimulationConfig().getDefaultModulePath() + "/CD3Modules/CD3Waterbalance/Module"); nodereg->addToPythonPath(this->getSimulation()->getSimulationConfig().getDefaultModulePath() + "/CD3Modules/CD3Waterbalance/WaterDemandModel"); try{ nodereg->addPythonPlugin(this->getSimulation()->getSimulationConfig().getDefaultModulePath() + "/CD3Modules/CD3Waterbalance/Module/cd3waterbalancemodules.py"); } catch(...) { Logger(Error) << "Please point path to CD3 water balance modules"; this->setStatus(DM::MOD_EXECUTION_ERROR); return false; } p = new SimulationParameters(); p->dt = lexical_cast<int>(this->timestep); p->start = time_from_string(this->cd3_start_date); p->stop = time_from_string(this->cd3_end_date); } catch(...) { DM::Logger(DM::Error) << "Cannot start CD3 simulation"; } DM::Logger(DM::Debug) << "CD3 simulation finished"; m = new MapBasedModel(); n_d = nodereg->createNode("SourceVector"); //n_d->setParameter("source",sum_demand); m->addNode("demand", n_d); n_r = nodereg->createNode("SourceVector"); //n_r->setParameter("source",runoff); m->addNode("runoff", n_r); //RWHT rwht = nodereg->createNode("RWHT"); //rwht->setParameter("storage_volume", storage_volume); m->addNode("rain_tank", rwht); //Flow meter flow_p = nodereg->createNode("FlowProbe"); m->addNode("flow_probe", flow_p); //Stormwater m->addConnection(new NodeConnection(n_r,"out",rwht,"in_sw" )); m->addConnection(new NodeConnection(n_d,"out",rwht,"in_np" )); m->addConnection(new NodeConnection(rwht,"out_sw",flow_p,"in" )); s = simreg->createSimulation("DefaultSimulation"); DM::Logger(DM::Debug) << "CD3 Simulation: " << simreg->getRegisteredNames().front(); s->setModel(m); return true; }
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 *OGRPGeoLayer::GetNextRawFeature() { OGRErr err = OGRERR_NONE; if( GetStatement() == NULL ) return NULL; /* -------------------------------------------------------------------- */ /* If we are marked to restart then do so, and fetch a record. */ /* -------------------------------------------------------------------- */ if( !poStmt->Fetch() ) { delete poStmt; poStmt = NULL; return NULL; } /* -------------------------------------------------------------------- */ /* Create a feature from the current result. */ /* -------------------------------------------------------------------- */ int iField; OGRFeature *poFeature = new OGRFeature( poFeatureDefn ); if( pszFIDColumn != NULL && poStmt->GetColId(pszFIDColumn) > -1 ) poFeature->SetFID( atoi(poStmt->GetColData(poStmt->GetColId(pszFIDColumn))) ); else poFeature->SetFID( iNextShapeId ); iNextShapeId++; m_nFeaturesRead++; /* -------------------------------------------------------------------- */ /* Set the fields. */ /* -------------------------------------------------------------------- */ for( iField = 0; iField < poFeatureDefn->GetFieldCount(); iField++ ) { int iSrcField = panFieldOrdinals[iField]-1; const char *pszValue = poStmt->GetColData( iSrcField ); if( pszValue == NULL ) /* no value */; else if( poFeature->GetFieldDefnRef(iField)->GetType() == OFTBinary ) poFeature->SetField( iField, poStmt->GetColDataLength(iSrcField), (GByte *) pszValue ); else poFeature->SetField( iField, pszValue ); } /* -------------------------------------------------------------------- */ /* Try to extract a geometry. */ /* -------------------------------------------------------------------- */ if( pszGeomColumn != NULL ) { int iField = poStmt->GetColId( pszGeomColumn ); GByte *pabyShape = (GByte *) poStmt->GetColData( iField ); int nBytes = poStmt->GetColDataLength(iField); OGRGeometry *poGeom = NULL; if( pabyShape != NULL ) { err = createFromShapeBin( pabyShape, &poGeom, nBytes ); if( OGRERR_NONE != err ) { CPLDebug( "PGeo", "Translation shape binary to OGR geometry failed (FID=%ld)", (long)poFeature->GetFID() ); } } if( poGeom != NULL && OGRERR_NONE == err ) { poGeom->assignSpatialReference( poSRS ); poFeature->SetGeometryDirectly( poGeom ); } } return poFeature; }