OGRErr OGRGeometryCollection::importFromWkb( unsigned char * pabyData, int nSize ) { OGRwkbByteOrder eByteOrder; int nDataOffset; if( nSize < 9 && nSize != -1 ) return OGRERR_NOT_ENOUGH_DATA; /* -------------------------------------------------------------------- */ /* Get the byte order byte. */ /* -------------------------------------------------------------------- */ eByteOrder = DB2_V72_FIX_BYTE_ORDER((OGRwkbByteOrder) *pabyData); CPLAssert( eByteOrder == wkbXDR || eByteOrder == wkbNDR ); /* -------------------------------------------------------------------- */ /* Get the geometry feature type. For now we assume that */ /* geometry type is between 0 and 255 so we only have to fetch */ /* one byte. */ /* -------------------------------------------------------------------- */ #ifdef DEBUG OGRwkbGeometryType eGeometryType; if( eByteOrder == wkbNDR ) { eGeometryType = (OGRwkbGeometryType) pabyData[1]; } else { eGeometryType = (OGRwkbGeometryType) pabyData[4]; } CPLAssert( eGeometryType == wkbGeometryCollection || eGeometryType == wkbMultiPolygon || eGeometryType == wkbMultiLineString || eGeometryType == wkbMultiPoint ); #endif /* -------------------------------------------------------------------- */ /* Clear existing Geoms. */ /* -------------------------------------------------------------------- */ empty(); /* -------------------------------------------------------------------- */ /* Get the geometry count. */ /* -------------------------------------------------------------------- */ memcpy( &nGeomCount, pabyData + 5, 4 ); if( OGR_SWAP( eByteOrder ) ) nGeomCount = CPL_SWAP32(nGeomCount); papoGeoms = (OGRGeometry **) OGRMalloc(sizeof(void*) * nGeomCount); nDataOffset = 9; if( nSize != -1 ) nSize -= nDataOffset; /* -------------------------------------------------------------------- */ /* Get the Geoms. */ /* -------------------------------------------------------------------- */ for( int iGeom = 0; iGeom < nGeomCount; iGeom++ ) { OGRErr eErr; eErr = OGRGeometryFactory:: createFromWkb( pabyData + nDataOffset, NULL, papoGeoms + iGeom, nSize ); if( eErr != OGRERR_NONE ) { nGeomCount = iGeom; return eErr; } if (papoGeoms[iGeom]->getCoordinateDimension() == 3) nCoordDimension = 3; if( nSize != -1 ) nSize -= papoGeoms[iGeom]->WkbSize(); nDataOffset += papoGeoms[iGeom]->WkbSize(); } return OGRERR_NONE; }
int OGRKMLDataSource::Open( const char * pszNewName, int bTestOpen ) { CPLAssert( NULL != pszNewName ); int nCount = 0; OGRKMLLayer *poLayer = NULL; OGRwkbGeometryType poGeotype; /* -------------------------------------------------------------------- */ /* Create a KML object and open the source file. */ /* -------------------------------------------------------------------- */ poKMLFile_ = new KMLVector(); if( !poKMLFile_->open( pszNewName ) ) { delete poKMLFile_; poKMLFile_ = NULL; return FALSE; } pszName_ = CPLStrdup( pszNewName ); /* -------------------------------------------------------------------- */ /* If we aren't sure it is KML, validate it by start parsing */ /* -------------------------------------------------------------------- */ if( bTestOpen && !poKMLFile_->isValid() ) { delete poKMLFile_; poKMLFile_ = NULL; return FALSE; } /* -------------------------------------------------------------------- */ /* Prescan the KML file so we can later work with the structure */ /* -------------------------------------------------------------------- */ poKMLFile_->parse(); /* -------------------------------------------------------------------- */ /* Classify the nodes */ /* -------------------------------------------------------------------- */ if( !poKMLFile_->classifyNodes() ) { delete poKMLFile_; poKMLFile_ = NULL; return FALSE; } /* -------------------------------------------------------------------- */ /* Eliminate the empty containers (if there is at least one */ /* valid container !) */ /* -------------------------------------------------------------------- */ int bHasOnlyEmpty = poKMLFile_->hasOnlyEmpty(); if (bHasOnlyEmpty) CPLDebug("KML", "Has only empty containers"); else poKMLFile_->eliminateEmpty(); /* -------------------------------------------------------------------- */ /* Find layers to use in the KML structure */ /* -------------------------------------------------------------------- */ poKMLFile_->findLayers(NULL, bHasOnlyEmpty); /* -------------------------------------------------------------------- */ /* Print the structure */ /* -------------------------------------------------------------------- */ if( CPLGetConfigOption("KML_DEBUG",NULL) != NULL ) poKMLFile_->print(3); nLayers_ = poKMLFile_->getNumLayers(); /* -------------------------------------------------------------------- */ /* Allocate memory for the Layers */ /* -------------------------------------------------------------------- */ papoLayers_ = (OGRKMLLayer **) CPLMalloc( sizeof(OGRKMLLayer *) * nLayers_ ); OGRSpatialReference *poSRS = new OGRSpatialReference("GEOGCS[\"WGS 84\", " " DATUM[\"WGS_1984\"," " SPHEROID[\"WGS 84\",6378137,298.257223563," " AUTHORITY[\"EPSG\",\"7030\"]]," " AUTHORITY[\"EPSG\",\"6326\"]]," " PRIMEM[\"Greenwich\",0," " AUTHORITY[\"EPSG\",\"8901\"]]," " UNIT[\"degree\",0.01745329251994328," " AUTHORITY[\"EPSG\",\"9122\"]]," " AUTHORITY[\"EPSG\",\"4326\"]]"); /* -------------------------------------------------------------------- */ /* Create the Layers and fill them */ /* -------------------------------------------------------------------- */ for( nCount = 0; nCount < nLayers_; nCount++ ) { if( !poKMLFile_->selectLayer(nCount) ) { CPLError( CE_Failure, CPLE_AppDefined, "There are no layers or a layer can not be found!"); break; } if( poKMLFile_->getCurrentType() == Point ) poGeotype = wkbPoint; else if( poKMLFile_->getCurrentType() == LineString ) poGeotype = wkbLineString; else if( poKMLFile_->getCurrentType() == Polygon ) poGeotype = wkbPolygon; else if( poKMLFile_->getCurrentType() == MultiPoint ) poGeotype = wkbMultiPoint; else if( poKMLFile_->getCurrentType() == MultiLineString ) poGeotype = wkbMultiLineString; else if( poKMLFile_->getCurrentType() == MultiPolygon ) poGeotype = wkbMultiPolygon; else if( poKMLFile_->getCurrentType() == MultiGeometry ) poGeotype = wkbGeometryCollection; else poGeotype = wkbUnknown; if (poGeotype != wkbUnknown && poKMLFile_->is25D()) poGeotype = (OGRwkbGeometryType) (poGeotype | wkb25DBit); /* -------------------------------------------------------------------- */ /* Create the layer object. */ /* -------------------------------------------------------------------- */ CPLString sName( poKMLFile_->getCurrentName() ); if( sName.empty() ) { sName.Printf( "Layer #%d", nCount ); } poLayer = new OGRKMLLayer( sName.c_str(), poSRS, FALSE, poGeotype, this ); poLayer->SetLayerNumber( nCount ); /* -------------------------------------------------------------------- */ /* Add layer to data source layer list. */ /* -------------------------------------------------------------------- */ papoLayers_[nCount] = poLayer; } poSRS->Release(); 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; }
OGRErr OGRLineString::importFromWkb( unsigned char * pabyData, int nSize ) { OGRwkbByteOrder eByteOrder; if( nSize < 21 && nSize != -1 ) return OGRERR_NOT_ENOUGH_DATA; /* -------------------------------------------------------------------- */ /* Get the byte order byte. */ /* -------------------------------------------------------------------- */ eByteOrder = DB2_V72_FIX_BYTE_ORDER((OGRwkbByteOrder) *pabyData); assert( eByteOrder == wkbXDR || eByteOrder == wkbNDR ); /* -------------------------------------------------------------------- */ /* Get the geometry feature type. For now we assume that */ /* geometry type is between 0 and 255 so we only have to fetch */ /* one byte. */ /* -------------------------------------------------------------------- */ OGRwkbGeometryType eGeometryType; int bIs3D; if( eByteOrder == wkbNDR ) { eGeometryType = (OGRwkbGeometryType) pabyData[1]; bIs3D = pabyData[4] & 0x80 || pabyData[2] & 0x80; } else { eGeometryType = (OGRwkbGeometryType) pabyData[4]; bIs3D = pabyData[1] & 0x80 || pabyData[3] & 0x80; } #ifdef __WXOSX__ assert( eGeometryType == wkbLineString ); #else CPLAssert( eGeometryType == wkbLineString ); #endif /* -------------------------------------------------------------------- */ /* Get the vertex count. */ /* -------------------------------------------------------------------- */ int nNewNumPoints; memcpy( &nNewNumPoints, pabyData + 5, 4 ); if( OGR_SWAP( eByteOrder ) ) nNewNumPoints = CPL_SWAP32(nNewNumPoints); setNumPoints( nNewNumPoints ); if( bIs3D ) Make3D(); else Make2D(); /* -------------------------------------------------------------------- */ /* Get the vertex. */ /* -------------------------------------------------------------------- */ int i; if( bIs3D ) { for( i = 0; i < nPointCount; i++ ) { memcpy( paoPoints + i, pabyData + 9 + i*24, 16 ); memcpy( padfZ + i, pabyData + 9 + 16 + i*24, 8 ); } } else { memcpy( paoPoints, pabyData + 9, 16 * nPointCount ); } /* -------------------------------------------------------------------- */ /* Byte swap if needed. */ /* -------------------------------------------------------------------- */ if( OGR_SWAP( eByteOrder ) ) { for( i = 0; i < nPointCount; i++ ) { CPL_SWAPDOUBLE( &(paoPoints[i].x) ); CPL_SWAPDOUBLE( &(paoPoints[i].y) ); } if( bIs3D ) { for( i = 0; i < nPointCount; i++ ) { CPL_SWAPDOUBLE( padfZ + i ); } } } return OGRERR_NONE; }
OGRLayer * OGRKMLDataSource::CreateLayer( const char * pszLayerName, OGRSpatialReference *poSRS, OGRwkbGeometryType eType, char ** papszOptions ) { CPLAssert( NULL != pszLayerName); /* -------------------------------------------------------------------- */ /* Verify we are in update mode. */ /* -------------------------------------------------------------------- */ if( fpOutput_ == NULL ) { CPLError( CE_Failure, CPLE_NoWriteAccess, "Data source %s opened for read access.\n" "New layer %s cannot be created.\n", pszName_, pszLayerName ); return NULL; } /* -------------------------------------------------------------------- */ /* Close the previous layer (if there is one open) */ /* -------------------------------------------------------------------- */ if (GetLayerCount() > 0) { VSIFPrintfL( fpOutput_, "</Folder>\n"); ((OGRKMLLayer*)GetLayer(GetLayerCount()-1))->SetClosedForWriting(); } /* -------------------------------------------------------------------- */ /* Ensure name is safe as an element name. */ /* -------------------------------------------------------------------- */ char *pszCleanLayerName = CPLStrdup( pszLayerName ); CPLCleanXMLElementName( pszCleanLayerName ); if( strcmp(pszCleanLayerName, pszLayerName) != 0 ) { CPLError( CE_Warning, CPLE_AppDefined, "Layer name '%s' adjusted to '%s' for XML validity.", pszLayerName, pszCleanLayerName ); } VSIFPrintfL( fpOutput_, "<Folder><name>%s</name>\n", pszCleanLayerName); /* -------------------------------------------------------------------- */ /* Create the layer object. */ /* -------------------------------------------------------------------- */ OGRKMLLayer *poLayer; poLayer = new OGRKMLLayer( pszCleanLayerName, poSRS, TRUE, eType, this ); CPLFree( pszCleanLayerName ); /* -------------------------------------------------------------------- */ /* Add layer to data source layer list. */ /* -------------------------------------------------------------------- */ papoLayers_ = (OGRKMLLayer **) CPLRealloc( papoLayers_, sizeof(OGRKMLLayer *) * (nLayers_+1) ); papoLayers_[nLayers_++] = poLayer; return poLayer; }
int OGRTABDataSource::Open( const char * pszName, int bTestOpen ) { VSIStatBuf stat; CPLAssert( m_pszName == NULL ); m_pszName = CPLStrdup( pszName ); /* -------------------------------------------------------------------- */ /* Is this a file or directory? */ /* -------------------------------------------------------------------- */ if( VSIStat( pszName, &stat ) != 0 || (!VSI_ISDIR(stat.st_mode) && !VSI_ISREG(stat.st_mode)) ) { if( !bTestOpen ) { CPLError( CE_Failure, CPLE_OpenFailed, "%s is not a file or directory.\n" "Unable to open as a Mapinfo dataset.\n", pszName ); } return FALSE; } /* -------------------------------------------------------------------- */ /* If it is a file, try to open as a Mapinfo file. */ /* -------------------------------------------------------------------- */ if( VSI_ISREG(stat.st_mode) ) { IMapInfoFile *poFile; poFile = IMapInfoFile::SmartOpen( pszName, bTestOpen ); if( poFile == NULL ) return FALSE; m_nLayerCount = 1; m_papoLayers = (IMapInfoFile **) CPLMalloc(sizeof(void*)); m_papoLayers[0] = poFile; m_pszDirectory = CPLStrdup( CPLGetPath(pszName) ); } /* -------------------------------------------------------------------- */ /* Otherwise, we need to scan the whole directory for files */ /* ending in .tab or .mif. */ /* -------------------------------------------------------------------- */ else { char **papszFileList = CPLReadDir( pszName ); m_pszDirectory = CPLStrdup( pszName ); for( int iFile = 0; papszFileList != NULL && papszFileList[iFile] != NULL; iFile++ ) { IMapInfoFile *poFile; const char *pszExtension = CPLGetExtension(papszFileList[iFile]); char *pszSubFilename; if( !EQUAL(pszExtension,"tab") && !EQUAL(pszExtension,"mif") ) continue; pszSubFilename = CPLStrdup( CPLFormFilename( m_pszDirectory, papszFileList[iFile], NULL )); poFile = IMapInfoFile::SmartOpen( pszSubFilename, bTestOpen ); CPLFree( pszSubFilename ); if( poFile == NULL ) { CSLDestroy( papszFileList ); return FALSE; } m_nLayerCount++; m_papoLayers = (IMapInfoFile **) CPLRealloc(m_papoLayers,sizeof(void*)*m_nLayerCount); m_papoLayers[m_nLayerCount-1] = poFile; } CSLDestroy( papszFileList ); if( m_nLayerCount == 0 ) { if( !bTestOpen ) CPLError( CE_Failure, CPLE_OpenFailed, "No mapinfo files found in directory %s.\n", m_pszDirectory ); return FALSE; } } return TRUE; }
void NASReader::SetFeaturePropertyDirectly( const char *pszElement, char *pszValue ) { GMLFeature *poFeature = GetState()->m_poFeature; CPLAssert( poFeature != NULL ); /* -------------------------------------------------------------------- */ /* Does this property exist in the feature class? If not, add */ /* it. */ /* -------------------------------------------------------------------- */ GMLFeatureClass *poClass = poFeature->GetClass(); int iProperty; for( iProperty=0; iProperty < poClass->GetPropertyCount(); iProperty++ ) { if( EQUAL(poClass->GetProperty( iProperty )->GetSrcElement(), pszElement ) ) break; } if( iProperty == poClass->GetPropertyCount() ) { if( poClass->IsSchemaLocked() ) { CPLDebug("NAS","Encountered property missing from class schema."); CPLFree(pszValue); return; } CPLString osFieldName; if( strchr(pszElement,'|') == NULL ) osFieldName = pszElement; else { osFieldName = strrchr(pszElement,'|') + 1; if( poClass->GetPropertyIndex(osFieldName) != -1 ) osFieldName = pszElement; } // Does this conflict with an existing property name? while( poClass->GetProperty(osFieldName) != NULL ) { osFieldName += "_"; } GMLPropertyDefn *poPDefn = new GMLPropertyDefn(osFieldName,pszElement); if( EQUAL(CPLGetConfigOption( "GML_FIELDTYPES", ""), "ALWAYS_STRING") ) poPDefn->SetType( GMLPT_String ); poClass->AddProperty( poPDefn ); } /* -------------------------------------------------------------------- */ /* We want to handle <lage> specially to ensure it is zero */ /* filled, and treated as a string depspite the numeric */ /* content. https://trac.wheregroup.com/PostNAS/ticket/9 */ /* -------------------------------------------------------------------- */ if( strcmp(poClass->GetProperty(iProperty)->GetName(),"lage") == 0 ) { if( strlen(pszValue) < 5 ) { CPLString osValue = "00000"; osValue += pszValue; poFeature->SetPropertyDirectly( iProperty, CPLStrdup(osValue + osValue.size() - 5) ); CPLFree(pszValue); } else poFeature->SetPropertyDirectly( iProperty, pszValue ); if( !poClass->IsSchemaLocked() ) { poClass->GetProperty(iProperty)->SetWidth( 5 ); poClass->GetProperty(iProperty)->SetType( GMLPT_String ); } return; } /* -------------------------------------------------------------------- */ /* Set the property */ /* -------------------------------------------------------------------- */ poFeature->SetPropertyDirectly( iProperty, pszValue ); /* -------------------------------------------------------------------- */ /* Do we need to update the property type? */ /* -------------------------------------------------------------------- */ if( !poClass->IsSchemaLocked() ) { // Special handling for punktkennung per NAS #12 if( strcmp(poClass->GetProperty(iProperty)->GetName(), "punktkennung") == 0) { poClass->GetProperty(iProperty)->SetWidth( 15 ); poClass->GetProperty(iProperty)->SetType( GMLPT_String ); } // Special handling for artDerFlurstuecksgrenze per http://trac.osgeo.org/gdal/ticket/4255 else if( strcmp(poClass->GetProperty(iProperty)->GetName(), "artDerFlurstuecksgrenze") == 0) { poClass->GetProperty(iProperty)->SetType( GMLPT_IntegerList ); } else poClass->GetProperty(iProperty)->AnalysePropertyValue( poFeature->GetProperty(iProperty)); } }
int S57ClassRegistrar::LoadInfo( const char * pszDirectory, const char * pszProfile, int bReportErr ) { FILE *fp; char szTargetFile[1024]; if( pszDirectory == NULL ) pszDirectory = CPLGetConfigOption("S57_CSV",NULL); /* ==================================================================== */ /* Read the s57objectclasses file. */ /* ==================================================================== */ if( pszProfile == NULL ) pszProfile = CPLGetConfigOption( "S57_PROFILE", "" ); if( EQUAL(pszProfile, "Additional_Military_Layers") ) { sprintf( szTargetFile, "s57objectclasses_%s.csv", "aml" ); } else if ( EQUAL(pszProfile, "Inland_Waterways") ) { sprintf( szTargetFile, "s57objectclasses_%s.csv", "iw" ); } else if( strlen(pszProfile) > 0 ) { sprintf( szTargetFile, "s57objectclasses_%s.csv", pszProfile ); } else { strcpy( szTargetFile, "s57objectclasses.csv" ); } if( !FindFile( szTargetFile, pszDirectory, bReportErr, &fp ) ) return FALSE; /* -------------------------------------------------------------------- */ /* Skip the line defining the column titles. */ /* -------------------------------------------------------------------- */ const char * pszLine = ReadLine( fp ); if( !EQUAL(pszLine, "\"Code\",\"ObjectClass\",\"Acronym\",\"Attribute_A\"," "\"Attribute_B\",\"Attribute_C\",\"Class\",\"Primitives\"" ) ) { CPLError( CE_Failure, CPLE_AppDefined, "s57objectclasses columns don't match expected format!\n" ); return FALSE; } /* -------------------------------------------------------------------- */ /* Read and form string list. */ /* -------------------------------------------------------------------- */ CSLDestroy( papszClassesInfo ); papszClassesInfo = (char **) CPLCalloc(sizeof(char *),MAX_CLASSES); nClasses = 0; while( nClasses < MAX_CLASSES && (pszLine = ReadLine(fp)) != NULL ) { papszClassesInfo[nClasses] = CPLStrdup(pszLine); if( papszClassesInfo[nClasses] == NULL ) break; nClasses++; } if( nClasses == MAX_CLASSES ) CPLError( CE_Warning, CPLE_AppDefined, "MAX_CLASSES exceeded in S57ClassRegistrar::LoadInfo().\n" ); /* -------------------------------------------------------------------- */ /* Cleanup, and establish state. */ /* -------------------------------------------------------------------- */ if( fp != NULL ) VSIFClose( fp ); iCurrentClass = -1; if( nClasses == 0 ) return FALSE; /* ==================================================================== */ /* Read the attributes list. */ /* ==================================================================== */ if( EQUAL(pszProfile, "Additional_Military_Layers") ) { sprintf( szTargetFile, "s57attributes_%s.csv", "aml" ); } else if ( EQUAL(pszProfile, "Inland_Waterways") ) { sprintf( szTargetFile, "s57attributes_%s.csv", "iw" ); } else if( strlen(pszProfile) > 0 ) { sprintf( szTargetFile, "s57attributes_%s.csv", pszProfile ); } else { strcpy( szTargetFile, "s57attributes.csv" ); } if( !FindFile( szTargetFile, pszDirectory, bReportErr, &fp ) ) return FALSE; /* -------------------------------------------------------------------- */ /* Skip the line defining the column titles. */ /* -------------------------------------------------------------------- */ pszLine = ReadLine( fp ); if( !EQUAL(pszLine, "\"Code\",\"Attribute\",\"Acronym\",\"Attributetype\",\"Class\"") ) { CPLError( CE_Failure, CPLE_AppDefined, "s57attributes columns don't match expected format!\n" ); return FALSE; } /* -------------------------------------------------------------------- */ /* Prepare arrays for the per-attribute information. */ /* -------------------------------------------------------------------- */ nAttrMax = MAX_ATTRIBUTES-1; papszAttrNames = (char **) CPLCalloc(sizeof(char *),MAX_ATTRIBUTES); papszAttrAcronym = (char **) CPLCalloc(sizeof(char *),MAX_ATTRIBUTES); //papapszAttrValues = (char ***) CPLCalloc(sizeof(char **),MAX_ATTRIBUTES); pachAttrType = (char *) CPLCalloc(sizeof(char),MAX_ATTRIBUTES); pachAttrClass = (char *) CPLCalloc(sizeof(char),MAX_ATTRIBUTES); panAttrIndex = (int *) CPLCalloc(sizeof(int),MAX_ATTRIBUTES); /* -------------------------------------------------------------------- */ /* Read and form string list. */ /* -------------------------------------------------------------------- */ int iAttr; while( (pszLine = ReadLine(fp)) != NULL ) { char **papszTokens = CSLTokenizeStringComplex( pszLine, ",", TRUE, TRUE ); if( CSLCount(papszTokens) < 5 ) { CPLAssert( FALSE ); continue; } iAttr = atoi(papszTokens[0]); if( iAttr < 0 || iAttr >= nAttrMax || papszAttrNames[iAttr] != NULL ) { CPLDebug( "S57", "Duplicate definition for attribute %d:%s", iAttr, papszTokens[2] ); continue; } papszAttrNames[iAttr] = CPLStrdup(papszTokens[1]); papszAttrAcronym[iAttr] = CPLStrdup(papszTokens[2]); pachAttrType[iAttr] = papszTokens[3][0]; pachAttrClass[iAttr] = papszTokens[4][0]; CSLDestroy( papszTokens ); } if( fp != NULL ) VSIFClose( fp ); /* -------------------------------------------------------------------- */ /* Build unsorted index of attributes. */ /* -------------------------------------------------------------------- */ nAttrCount = 0; for( iAttr = 0; iAttr < nAttrMax; iAttr++ ) { if( papszAttrAcronym[iAttr] != NULL ) panAttrIndex[nAttrCount++] = iAttr; } /* -------------------------------------------------------------------- */ /* Sort index by acronym. */ /* -------------------------------------------------------------------- */ int bModified; do { bModified = FALSE; for( iAttr = 0; iAttr < nAttrCount-1; iAttr++ ) { if( strcmp(papszAttrAcronym[panAttrIndex[iAttr]], papszAttrAcronym[panAttrIndex[iAttr+1]]) > 0 ) { int nTemp; nTemp = panAttrIndex[iAttr]; panAttrIndex[iAttr] = panAttrIndex[iAttr+1]; panAttrIndex[iAttr+1] = nTemp; bModified = TRUE; } } } while( bModified ); return TRUE; }
int OGRMySQLDataSource::FetchSRSId( OGRSpatialReference * poSRS ) { char **papszRow; MYSQL_RES *hResult=NULL; char szCommand[10000]; char *pszWKT = NULL; int nSRSId; if( poSRS == NULL ) return -1; /* -------------------------------------------------------------------- */ /* Translate SRS to WKT. */ /* -------------------------------------------------------------------- */ if( poSRS->exportToWkt( &pszWKT ) != OGRERR_NONE ) return -1; CPLAssert( strlen(pszWKT) < sizeof(szCommand) - 500 ); /* -------------------------------------------------------------------- */ /* Try to find in the existing table. */ /* -------------------------------------------------------------------- */ sprintf( szCommand, "SELECT srid FROM spatial_ref_sys WHERE srtext = '%s'", pszWKT ); if( !mysql_query( GetConn(), szCommand ) ) hResult = mysql_store_result( GetConn() ); if (!mysql_num_rows(hResult)) { CPLDebug("MYSQL", "No rows exist currently exist in spatial_ref_sys"); mysql_free_result( hResult ); hResult = NULL; } papszRow = NULL; if( hResult != NULL ) papszRow = mysql_fetch_row( hResult ); if( papszRow != NULL && papszRow[0] != NULL ) { nSRSId = atoi(papszRow[0]); if( hResult != NULL ) mysql_free_result( hResult ); hResult = NULL; CPLFree(pszWKT); return nSRSId; } // make sure to attempt to free results of successful queries hResult = mysql_store_result( GetConn() ); if( hResult != NULL ) mysql_free_result( hResult ); hResult = NULL; /* -------------------------------------------------------------------- */ /* Get the current maximum srid in the srs table. */ /* -------------------------------------------------------------------- */ sprintf( szCommand, "SELECT MAX(srid) FROM spatial_ref_sys"); if( !mysql_query( GetConn(), szCommand ) ) { hResult = mysql_store_result( GetConn() ); papszRow = mysql_fetch_row( hResult ); } if( papszRow != NULL && papszRow[0] != NULL ) { nSRSId = atoi(papszRow[0]) + 1; } else nSRSId = 1; if( hResult != NULL ) mysql_free_result( hResult ); hResult = NULL; /* -------------------------------------------------------------------- */ /* Try adding the SRS to the SRS table. */ /* -------------------------------------------------------------------- */ sprintf( szCommand, "INSERT INTO spatial_ref_sys (srid,srtext) VALUES (%d,'%s')", nSRSId, pszWKT ); if( !mysql_query( GetConn(), szCommand ) ) hResult = mysql_store_result( GetConn() ); // make sure to attempt to free results of successful queries hResult = mysql_store_result( GetConn() ); if( hResult != NULL ) mysql_free_result( hResult ); hResult = NULL; CPLFree(pszWKT); return nSRSId; }
int GDALDefaultOverviews::HaveMaskFile( char ** papszSiblingFiles, const char *pszBasename ) { /* -------------------------------------------------------------------- */ /* Have we already checked for masks? */ /* -------------------------------------------------------------------- */ if( bCheckedForMask ) return poMaskDS != nullptr; if( papszSiblingFiles == nullptr ) papszSiblingFiles = papszInitSiblingFiles; /* -------------------------------------------------------------------- */ /* Are we an overview? If so we need to find the corresponding */ /* overview in the base files mask file (if there is one). */ /* -------------------------------------------------------------------- */ if( poBaseDS != nullptr && poBaseDS->oOvManager.HaveMaskFile() ) { GDALRasterBand * const poBaseBand = poBaseDS->GetRasterBand(1); GDALRasterBand * poBaseMask = poBaseBand != nullptr ? poBaseBand->GetMaskBand() : nullptr; const int nOverviewCount = poBaseMask != nullptr ? poBaseMask->GetOverviewCount() : 0; GDALDataset* poMaskDSTemp = nullptr; for( int iOver = 0; iOver < nOverviewCount; iOver++ ) { GDALRasterBand * const poOverBand = poBaseMask->GetOverview( iOver ); if( poOverBand == nullptr ) continue; if( poOverBand->GetXSize() == poDS->GetRasterXSize() && poOverBand->GetYSize() == poDS->GetRasterYSize() ) { poMaskDSTemp = poOverBand->GetDataset(); break; } } if( poMaskDSTemp != poDS ) { poMaskDS = poMaskDSTemp; bCheckedForMask = true; bOwnMaskDS = false; return poMaskDS != nullptr; } } /* -------------------------------------------------------------------- */ /* Are we even initialized? If not, we apparently don't want */ /* to support overviews and masks. */ /* -------------------------------------------------------------------- */ if( poDS == nullptr ) return FALSE; /* -------------------------------------------------------------------- */ /* Check for .msk file. */ /* -------------------------------------------------------------------- */ bCheckedForMask = true; if( pszBasename == nullptr ) pszBasename = poDS->GetDescription(); // Don't bother checking for masks of masks. if( EQUAL(CPLGetExtension(pszBasename),"msk") ) return FALSE; if( !GDALCanFileAcceptSidecarFile(pszBasename) ) return FALSE; CPLString osMskFilename; osMskFilename.Printf( "%s.msk", pszBasename ); std::vector<char> achMskFilename; achMskFilename.resize(osMskFilename.size() + 1); memcpy(&(achMskFilename[0]), osMskFilename.c_str(), osMskFilename.size() + 1); bool bExists = CPL_TO_BOOL( CPLCheckForFile( &achMskFilename[0], papszSiblingFiles ) ); osMskFilename = &achMskFilename[0]; #if !defined(WIN32) if( !bExists && !papszSiblingFiles ) { osMskFilename.Printf( "%s.MSK", pszBasename ); memcpy(&(achMskFilename[0]), osMskFilename.c_str(), osMskFilename.size() + 1); bExists = CPL_TO_BOOL( CPLCheckForFile( &achMskFilename[0], papszSiblingFiles ) ); osMskFilename = &achMskFilename[0]; } #endif if( !bExists ) return FALSE; /* -------------------------------------------------------------------- */ /* Open the file. */ /* -------------------------------------------------------------------- */ poMaskDS = GDALDataset::Open( osMskFilename, GDAL_OF_RASTER | (poDS->GetAccess() == GA_Update ? GDAL_OF_UPDATE : 0), nullptr, nullptr, papszInitSiblingFiles ); CPLAssert( poMaskDS != poDS ); if( poMaskDS == nullptr ) return FALSE; bOwnMaskDS = true; return TRUE; }
CPLErr GDALDefaultOverviews::BuildOverviews( const char * pszBasename, const char * pszResampling, int nOverviews, int * panOverviewList, int nBands, int * panBandList, GDALProgressFunc pfnProgress, void * pProgressData) { if( pfnProgress == nullptr ) pfnProgress = GDALDummyProgress; if( nOverviews == 0 ) return CleanOverviews(); /* -------------------------------------------------------------------- */ /* If we don't already have an overview file, we need to decide */ /* what format to use. */ /* -------------------------------------------------------------------- */ if( poODS == nullptr ) { bOvrIsAux = CPLTestBool(CPLGetConfigOption( "USE_RRD", "NO" )); if( bOvrIsAux ) { osOvrFilename = CPLResetExtension(poDS->GetDescription(),"aux"); VSIStatBufL sStatBuf; if( VSIStatExL( osOvrFilename, &sStatBuf, VSI_STAT_EXISTS_FLAG ) == 0 ) osOvrFilename.Printf( "%s.aux", poDS->GetDescription() ); } } /* -------------------------------------------------------------------- */ /* If we already have the overviews open, but they are */ /* read-only, then try and reopen them read-write. */ /* -------------------------------------------------------------------- */ else if( poODS->GetAccess() == GA_ReadOnly ) { GDALClose( poODS ); poODS = GDALDataset::Open( osOvrFilename, GDAL_OF_RASTER | GDAL_OF_UPDATE); if( poODS == nullptr ) return CE_Failure; } /* -------------------------------------------------------------------- */ /* Our TIFF overview support currently only works safely if all */ /* bands are handled at the same time. */ /* -------------------------------------------------------------------- */ if( !bOvrIsAux && nBands != poDS->GetRasterCount() ) { CPLError( CE_Failure, CPLE_NotSupported, "Generation of overviews in external TIFF currently only " "supported when operating on all bands. " "Operation failed." ); return CE_Failure; } /* -------------------------------------------------------------------- */ /* If a basename is provided, use it to override the internal */ /* overview filename. */ /* -------------------------------------------------------------------- */ if( pszBasename == nullptr && osOvrFilename.length() == 0 ) pszBasename = poDS->GetDescription(); if( pszBasename != nullptr ) { if( bOvrIsAux ) osOvrFilename.Printf( "%s.aux", pszBasename ); else osOvrFilename.Printf( "%s.ovr", pszBasename ); } /* -------------------------------------------------------------------- */ /* Establish which of the overview levels we already have, and */ /* which are new. We assume that band 1 of the file is */ /* representative. */ /* -------------------------------------------------------------------- */ GDALRasterBand *poBand = poDS->GetRasterBand( 1 ); int nNewOverviews = 0; int *panNewOverviewList = static_cast<int *>( CPLCalloc(sizeof(int), nOverviews) ); double dfAreaNewOverviews = 0; double dfAreaRefreshedOverviews = 0; std::vector<bool> abValidLevel(nOverviews, true); std::vector<bool> abRequireRefresh(nOverviews, false); bool bFoundSinglePixelOverview = false; for( int i = 0; i < nOverviews && poBand != nullptr; i++ ) { // If we already have a 1x1 overview and this new one would result // in it too, then don't create it. if( bFoundSinglePixelOverview && (poBand->GetXSize() + panOverviewList[i] - 1) / panOverviewList[i] == 1 && (poBand->GetXSize() + panOverviewList[i] - 1) / panOverviewList[i] == 1 ) { abValidLevel[i] = false; continue; } for( int j = 0; j < poBand->GetOverviewCount(); j++ ) { GDALRasterBand * poOverview = poBand->GetOverview( j ); if( poOverview == nullptr ) continue; int nOvFactor = GDALComputeOvFactor(poOverview->GetXSize(), poBand->GetXSize(), poOverview->GetYSize(), poBand->GetYSize()); if( nOvFactor == panOverviewList[i] || nOvFactor == GDALOvLevelAdjust2( panOverviewList[i], poBand->GetXSize(), poBand->GetYSize() ) ) { abRequireRefresh[i] = true; break; } } if( abValidLevel[i] ) { const double dfArea = 1.0 / (panOverviewList[i] * panOverviewList[i]); dfAreaRefreshedOverviews += dfArea; if( !abRequireRefresh[i] ) { dfAreaNewOverviews += dfArea; panNewOverviewList[nNewOverviews++] = panOverviewList[i]; } if( (poBand->GetXSize() + panOverviewList[i] - 1) / panOverviewList[i] == 1 && (poBand->GetXSize() + panOverviewList[i] - 1) / panOverviewList[i] == 1 ) { bFoundSinglePixelOverview = true; } } } /* -------------------------------------------------------------------- */ /* Build band list. */ /* -------------------------------------------------------------------- */ GDALRasterBand **pahBands = static_cast<GDALRasterBand **>( CPLCalloc(sizeof(GDALRasterBand *), nBands) ); for( int i = 0; i < nBands; i++ ) pahBands[i] = poDS->GetRasterBand( panBandList[i] ); /* -------------------------------------------------------------------- */ /* Build new overviews - Imagine. Keep existing file open if */ /* we have it. But mark all overviews as in need of */ /* regeneration, since HFAAuxBuildOverviews() doesn't actually */ /* produce the imagery. */ /* -------------------------------------------------------------------- */ CPLErr eErr = CE_None; void* pScaledProgress = GDALCreateScaledProgress( 0, dfAreaNewOverviews / dfAreaRefreshedOverviews, pfnProgress, pProgressData ); if( bOvrIsAux ) { if( nNewOverviews == 0 ) { /* if we call HFAAuxBuildOverviews() with nNewOverviews == 0 */ /* because that there's no new, this will wipe existing */ /* overviews (#4831) */ // eErr = CE_None; } else { eErr = HFAAuxBuildOverviews( osOvrFilename, poDS, &poODS, nBands, panBandList, nNewOverviews, panNewOverviewList, pszResampling, GDALScaledProgress, pScaledProgress ); } for( int j = 0; j < nOverviews; j++ ) { if( abValidLevel[j] ) abRequireRefresh[j] = true; } } /* -------------------------------------------------------------------- */ /* Build new overviews - TIFF. Close TIFF files while we */ /* operate on it. */ /* -------------------------------------------------------------------- */ else { if( poODS != nullptr ) { delete poODS; poODS = nullptr; } eErr = GTIFFBuildOverviews( osOvrFilename, nBands, pahBands, nNewOverviews, panNewOverviewList, pszResampling, GDALScaledProgress, pScaledProgress ); // Probe for proxy overview filename. if( eErr == CE_Failure ) { const char *pszProxyOvrFilename = poDS->GetMetadataItem("FILENAME","ProxyOverviewRequest"); if( pszProxyOvrFilename != nullptr ) { osOvrFilename = pszProxyOvrFilename; eErr = GTIFFBuildOverviews( osOvrFilename, nBands, pahBands, nNewOverviews, panNewOverviewList, pszResampling, GDALScaledProgress, pScaledProgress ); } } if( eErr == CE_None ) { poODS = GDALDataset::Open( osOvrFilename, GDAL_OF_RASTER | GDAL_OF_UPDATE ); if( poODS == nullptr ) eErr = CE_Failure; } } GDALDestroyScaledProgress( pScaledProgress ); /* -------------------------------------------------------------------- */ /* Refresh old overviews that were listed. */ /* -------------------------------------------------------------------- */ GDALRasterBand **papoOverviewBands = static_cast<GDALRasterBand **>( CPLCalloc(sizeof(void*), nOverviews) ); for( int iBand = 0; iBand < nBands && eErr == CE_None; iBand++ ) { poBand = poDS->GetRasterBand( panBandList[iBand] ); if( poBand == nullptr ) { eErr = CE_Failure; break; } nNewOverviews = 0; std::vector<bool> abAlreadyUsedOverviewBand( poBand->GetOverviewCount(), false); for( int i = 0; i < nOverviews; i++ ) { if( !abValidLevel[i] || !abRequireRefresh[i] ) continue; for( int j = 0; j < poBand->GetOverviewCount(); j++ ) { if( abAlreadyUsedOverviewBand[j] ) continue; GDALRasterBand * poOverview = poBand->GetOverview( j ); if( poOverview == nullptr ) continue; int bHasNoData = FALSE; double noDataValue = poBand->GetNoDataValue(&bHasNoData); if( bHasNoData ) poOverview->SetNoDataValue(noDataValue); const int nOvFactor = GDALComputeOvFactor(poOverview->GetXSize(), poBand->GetXSize(), poOverview->GetYSize(), poBand->GetYSize()); if( nOvFactor == panOverviewList[i] || nOvFactor == GDALOvLevelAdjust2( panOverviewList[i], poBand->GetXSize(), poBand->GetYSize() )) { abAlreadyUsedOverviewBand[j] = true; CPLAssert(nNewOverviews < poBand->GetOverviewCount()); papoOverviewBands[nNewOverviews++] = poOverview; break; } } } if( nNewOverviews > 0 ) { const double dfOffset = dfAreaNewOverviews / dfAreaRefreshedOverviews; const double dfScale = 1.0 - dfOffset; pScaledProgress = GDALCreateScaledProgress( dfOffset + dfScale * iBand / nBands, dfOffset + dfScale * (iBand+1) / nBands, pfnProgress, pProgressData ); eErr = GDALRegenerateOverviews( GDALRasterBand::ToHandle(poBand), nNewOverviews, reinterpret_cast<GDALRasterBandH*>(papoOverviewBands), pszResampling, GDALScaledProgress, pScaledProgress ); GDALDestroyScaledProgress( pScaledProgress ); } } /* -------------------------------------------------------------------- */ /* Cleanup */ /* -------------------------------------------------------------------- */ CPLFree( papoOverviewBands ); CPLFree( panNewOverviewList ); CPLFree( pahBands ); /* -------------------------------------------------------------------- */ /* If we have a mask file, we need to build its overviews too. */ /* -------------------------------------------------------------------- */ if( HaveMaskFile() && poMaskDS ) { // Some config option are not compatible with mask overviews // so unset them, and define more sensible values. const bool bJPEG = EQUAL(CPLGetConfigOption("COMPRESS_OVERVIEW", ""), "JPEG"); const bool bPHOTOMETRIC_YCBCR = EQUAL(CPLGetConfigOption("PHOTOMETRIC_OVERVIEW", ""), "YCBCR"); if( bJPEG ) CPLSetThreadLocalConfigOption("COMPRESS_OVERVIEW", "DEFLATE"); if( bPHOTOMETRIC_YCBCR ) CPLSetThreadLocalConfigOption("PHOTOMETRIC_OVERVIEW", ""); poMaskDS->BuildOverviews( pszResampling, nOverviews, panOverviewList, 0, nullptr, pfnProgress, pProgressData ); // Restore config option. if( bJPEG ) CPLSetThreadLocalConfigOption("COMPRESS_OVERVIEW", "JPEG"); if( bPHOTOMETRIC_YCBCR ) CPLSetThreadLocalConfigOption("PHOTOMETRIC_OVERVIEW", "YCBCR"); if( bOwnMaskDS ) { // Reset the poMask member of main dataset bands, since it // will become invalid after poMaskDS closing. for( int iBand = 1; iBand <= poDS->GetRasterCount(); iBand ++ ) { GDALRasterBand *poOtherBand = poDS->GetRasterBand(iBand); if( poOtherBand != nullptr ) poOtherBand->InvalidateMaskBand(); } GDALClose( poMaskDS ); } // force next request to reread mask file. poMaskDS = nullptr; bOwnMaskDS = false; bCheckedForMask = false; } /* -------------------------------------------------------------------- */ /* If we have an overview dataset, then mark all the overviews */ /* with the base dataset Used later for finding overviews */ /* masks. Uggg. */ /* -------------------------------------------------------------------- */ if( poODS ) { const int nOverviewCount = GetOverviewCount(1); for( int iOver = 0; iOver < nOverviewCount; iOver++ ) { GDALRasterBand *poOtherBand = GetOverview( 1, iOver ); GDALDataset *poOverDS = poOtherBand != nullptr ? poOtherBand->GetDataset() : nullptr; if( poOverDS != nullptr ) { poOverDS->oOvManager.poBaseDS = poDS; poOverDS->oOvManager.poDS = poOverDS; } } } return eErr; }
void OGRCompoundCurve::EndPoint(OGRPoint *p) const { CPLAssert(oCC.nCurveCount > 0); oCC.papoCurves[oCC.nCurveCount-1]->EndPoint(p); }
void OGRCompoundCurve::StartPoint(OGRPoint *p) const { CPLAssert(oCC.nCurveCount > 0); oCC.papoCurves[0]->StartPoint(p); }
GDALDataset* HF2Dataset::CreateCopy( const char * pszFilename, GDALDataset *poSrcDS, int bStrict, char ** papszOptions, GDALProgressFunc pfnProgress, void * pProgressData ) { /* -------------------------------------------------------------------- */ /* Some some rudimentary checks */ /* -------------------------------------------------------------------- */ int nBands = poSrcDS->GetRasterCount(); if (nBands == 0) { CPLError( CE_Failure, CPLE_NotSupported, "HF2 driver does not support source dataset with zero band.\n"); return NULL; } if (nBands != 1) { CPLError( (bStrict) ? CE_Failure : CE_Warning, CPLE_NotSupported, "HF2 driver only uses the first band of the dataset.\n"); if (bStrict) return NULL; } if( pfnProgress && !pfnProgress( 0.0, NULL, pProgressData ) ) return NULL; /* -------------------------------------------------------------------- */ /* Get source dataset info */ /* -------------------------------------------------------------------- */ int nXSize = poSrcDS->GetRasterXSize(); int nYSize = poSrcDS->GetRasterYSize(); double adfGeoTransform[6]; poSrcDS->GetGeoTransform(adfGeoTransform); int bHasGeoTransform = !(adfGeoTransform[0] == 0 && adfGeoTransform[1] == 1 && adfGeoTransform[2] == 0 && adfGeoTransform[3] == 0 && adfGeoTransform[4] == 0 && adfGeoTransform[5] == 1); if (adfGeoTransform[2] != 0 || adfGeoTransform[4] != 0) { CPLError( CE_Failure, CPLE_NotSupported, "HF2 driver does not support CreateCopy() from skewed or rotated dataset.\n"); return NULL; } GDALDataType eSrcDT = poSrcDS->GetRasterBand(1)->GetRasterDataType(); GDALDataType eReqDT; float fVertPres = (float) 0.01; if (eSrcDT == GDT_Byte || eSrcDT == GDT_Int16) { fVertPres = 1; eReqDT = GDT_Int16; } else eReqDT = GDT_Float32; /* -------------------------------------------------------------------- */ /* Read creation options */ /* -------------------------------------------------------------------- */ const char* pszCompressed = CSLFetchNameValue(papszOptions, "COMPRESS"); int bCompress = FALSE; if (pszCompressed) bCompress = CSLTestBoolean(pszCompressed); const char* pszVerticalPrecision = CSLFetchNameValue(papszOptions, "VERTICAL_PRECISION"); if (pszVerticalPrecision) { fVertPres = (float) CPLAtofM(pszVerticalPrecision); if (fVertPres <= 0) { CPLError(CE_Warning, CPLE_AppDefined, "Unsupported value for VERTICAL_PRECISION. Defaulting to 0.01"); fVertPres = (float) 0.01; } if (eReqDT == GDT_Int16 && fVertPres > 1) eReqDT = GDT_Float32; } const char* pszBlockSize = CSLFetchNameValue(papszOptions, "BLOCKSIZE"); int nTileSize = 256; if (pszBlockSize) { nTileSize = atoi(pszBlockSize); if (nTileSize < 8 || nTileSize > 4096) { CPLError(CE_Warning, CPLE_AppDefined, "Unsupported value for BLOCKSIZE. Defaulting to 256"); nTileSize = 256; } } /* -------------------------------------------------------------------- */ /* Parse source dataset georeferencing info */ /* -------------------------------------------------------------------- */ int nExtendedHeaderLen = 0; if (bHasGeoTransform) nExtendedHeaderLen += 58; const char* pszProjectionRef = poSrcDS->GetProjectionRef(); int nDatumCode = -2; int nUTMZone = 0; int bNorth = FALSE; int nEPSGCode = 0; int nExtentUnits = 1; if (pszProjectionRef != NULL && pszProjectionRef[0] != '\0') { OGRSpatialReference oSRS; char* pszTemp = (char*) pszProjectionRef; if (oSRS.importFromWkt(&pszTemp) == OGRERR_NONE) { const char* pszValue = NULL; if( oSRS.GetAuthorityName( "GEOGCS|DATUM" ) != NULL && EQUAL(oSRS.GetAuthorityName( "GEOGCS|DATUM" ),"EPSG") ) nDatumCode = atoi(oSRS.GetAuthorityCode( "GEOGCS|DATUM" )); else if ((pszValue = oSRS.GetAttrValue("GEOGCS|DATUM")) != NULL) { if (strstr(pszValue, "WGS") && strstr(pszValue, "84")) nDatumCode = 6326; } nUTMZone = oSRS.GetUTMZone(&bNorth); } if( oSRS.GetAuthorityName( "PROJCS" ) != NULL && EQUAL(oSRS.GetAuthorityName( "PROJCS" ),"EPSG") ) nEPSGCode = atoi(oSRS.GetAuthorityCode( "PROJCS" )); if( oSRS.IsGeographic() ) { nExtentUnits = 0; } else { double dfLinear = oSRS.GetLinearUnits(); if( ABS(dfLinear - 0.3048) < 0.0000001 ) nExtentUnits = 2; else if( ABS(dfLinear - atof(SRS_UL_US_FOOT_CONV)) < 0.00000001 ) nExtentUnits = 3; else nExtentUnits = 1; } } if (nDatumCode != -2) nExtendedHeaderLen += 26; if (nUTMZone != 0) nExtendedHeaderLen += 26; if (nEPSGCode) nExtendedHeaderLen += 26; /* -------------------------------------------------------------------- */ /* Create target file */ /* -------------------------------------------------------------------- */ CPLString osFilename; if (bCompress) { osFilename = "/vsigzip/"; osFilename += pszFilename; } else osFilename = pszFilename; VSILFILE* fp = VSIFOpenL(osFilename.c_str(), "wb"); if (fp == NULL) { CPLError( CE_Failure, CPLE_AppDefined, "Cannot create %s", pszFilename ); return NULL; } /* -------------------------------------------------------------------- */ /* Write header */ /* -------------------------------------------------------------------- */ VSIFWriteL("HF2\0", 4, 1, fp); WriteShort(fp, 0); WriteInt(fp, nXSize); WriteInt(fp, nYSize); WriteShort(fp, (GInt16) nTileSize); WriteFloat(fp, fVertPres); float fHorizScale = (float) ((fabs(adfGeoTransform[1]) + fabs(adfGeoTransform[5])) / 2); WriteFloat(fp, fHorizScale); WriteInt(fp, nExtendedHeaderLen); /* -------------------------------------------------------------------- */ /* Write extended header */ /* -------------------------------------------------------------------- */ char szBlockName[16 + 1]; if (bHasGeoTransform) { VSIFWriteL("bin\0", 4, 1, fp); memset(szBlockName, 0, 16 + 1); strcpy(szBlockName, "georef-extents"); VSIFWriteL(szBlockName, 16, 1, fp); WriteInt(fp, 34); WriteShort(fp, (GInt16) nExtentUnits); WriteDouble(fp, adfGeoTransform[0]); WriteDouble(fp, adfGeoTransform[0] + nXSize * adfGeoTransform[1]); WriteDouble(fp, adfGeoTransform[3] + nYSize * adfGeoTransform[5]); WriteDouble(fp, adfGeoTransform[3]); } if (nUTMZone != 0) { VSIFWriteL("bin\0", 4, 1, fp); memset(szBlockName, 0, 16 + 1); strcpy(szBlockName, "georef-utm"); VSIFWriteL(szBlockName, 16, 1, fp); WriteInt(fp, 2); WriteShort(fp, (GInt16) ((bNorth) ? nUTMZone : -nUTMZone)); } if (nDatumCode != -2) { VSIFWriteL("bin\0", 4, 1, fp); memset(szBlockName, 0, 16 + 1); strcpy(szBlockName, "georef-datum"); VSIFWriteL(szBlockName, 16, 1, fp); WriteInt(fp, 2); WriteShort(fp, (GInt16) nDatumCode); } if (nEPSGCode != 0) { VSIFWriteL("bin\0", 4, 1, fp); memset(szBlockName, 0, 16 + 1); strcpy(szBlockName, "georef-epsg-prj"); VSIFWriteL(szBlockName, 16, 1, fp); WriteInt(fp, 2); WriteShort(fp, (GInt16) nEPSGCode); } /* -------------------------------------------------------------------- */ /* Copy imagery */ /* -------------------------------------------------------------------- */ int nXBlocks = (nXSize + nTileSize - 1) / nTileSize; int nYBlocks = (nYSize + nTileSize - 1) / nTileSize; void* pTileBuffer = (void*) VSIMalloc(nTileSize * nTileSize * (GDALGetDataTypeSize(eReqDT) / 8)); if (pTileBuffer == NULL) { CPLError( CE_Failure, CPLE_OutOfMemory, "Out of memory"); VSIFCloseL(fp); return NULL; } int i, j, k, l; CPLErr eErr = CE_None; for(j=0;j<nYBlocks && eErr == CE_None;j++) { for(i=0;i<nXBlocks && eErr == CE_None;i++) { int nReqXSize = MIN(nTileSize, nXSize - i * nTileSize); int nReqYSize = MIN(nTileSize, nYSize - j * nTileSize); eErr = poSrcDS->GetRasterBand(1)->RasterIO(GF_Read, i * nTileSize, MAX(0, nYSize - (j + 1) * nTileSize), nReqXSize, nReqYSize, pTileBuffer, nReqXSize, nReqYSize, eReqDT, 0, 0); if (eErr != CE_None) break; if (eReqDT == GDT_Int16) { WriteFloat(fp, 1); /* scale */ WriteFloat(fp, 0); /* offset */ for(k=0;k<nReqYSize;k++) { int nLastVal = ((short*)pTileBuffer)[(nReqYSize - k - 1) * nReqXSize + 0]; GByte nWordSize = 1; for(l=1;l<nReqXSize;l++) { int nVal = ((short*)pTileBuffer)[(nReqYSize - k - 1) * nReqXSize + l]; int nDiff = nVal - nLastVal; if (nDiff < -32768 || nDiff > 32767) { nWordSize = 4; break; } if (nDiff < -128 || nDiff > 127) nWordSize = 2; nLastVal = nVal; } VSIFWriteL(&nWordSize, 1, 1, fp); nLastVal = ((short*)pTileBuffer)[(nReqYSize - k - 1) * nReqXSize + 0]; WriteInt(fp, nLastVal); for(l=1;l<nReqXSize;l++) { int nVal = ((short*)pTileBuffer)[(nReqYSize - k - 1) * nReqXSize + l]; int nDiff = nVal - nLastVal; if (nWordSize == 1) { CPLAssert(nDiff >= -128 && nDiff <= 127); char chDiff = (char)nDiff; VSIFWriteL(&chDiff, 1, 1, fp); } else if (nWordSize == 2) { CPLAssert(nDiff >= -32768 && nDiff <= 32767); WriteShort(fp, (short)nDiff); } else { WriteInt(fp, nDiff); } nLastVal = nVal; } } } else { float fMinVal = ((float*)pTileBuffer)[0]; float fMaxVal = fMinVal; for(k=1;k<nReqYSize*nReqXSize;k++) { float fVal = ((float*)pTileBuffer)[k]; if (fVal < fMinVal) fMinVal = fVal; if (fVal > fMaxVal) fMaxVal = fVal; } float fIntRange = (fMaxVal - fMinVal) / fVertPres; float fScale = (fMinVal == fMaxVal) ? 1 : (fMaxVal - fMinVal) / fIntRange; float fOffset = fMinVal; WriteFloat(fp, fScale); /* scale */ WriteFloat(fp, fOffset); /* offset */ for(k=0;k<nReqYSize;k++) { float fLastVal = ((float*)pTileBuffer)[(nReqYSize - k - 1) * nReqXSize + 0]; float fIntLastVal = (fLastVal - fOffset) / fScale; CPLAssert(fIntLastVal >= -2147483648.0f && fIntLastVal <= 2147483647.0f); int nLastVal = (int)fIntLastVal; GByte nWordSize = 1; for(l=1;l<nReqXSize;l++) { float fVal = ((float*)pTileBuffer)[(nReqYSize - k - 1) * nReqXSize + l]; float fIntVal = (fVal - fOffset) / fScale; CPLAssert(fIntVal >= -2147483648.0f && fIntVal <= 2147483647.0f); int nVal = (int)fIntVal; int nDiff = nVal - nLastVal; CPLAssert((int)((GIntBig)nVal - nLastVal) == nDiff); if (nDiff < -32768 || nDiff > 32767) { nWordSize = 4; break; } if (nDiff < -128 || nDiff > 127) nWordSize = 2; nLastVal = nVal; } VSIFWriteL(&nWordSize, 1, 1, fp); fLastVal = ((float*)pTileBuffer)[(nReqYSize - k - 1) * nReqXSize + 0]; fIntLastVal = (fLastVal - fOffset) / fScale; nLastVal = (int)fIntLastVal; WriteInt(fp, nLastVal); for(l=1;l<nReqXSize;l++) { float fVal = ((float*)pTileBuffer)[(nReqYSize - k - 1) * nReqXSize + l]; float fIntVal = (fVal - fOffset) / fScale; int nVal = (int)fIntVal; int nDiff = nVal - nLastVal; CPLAssert((int)((GIntBig)nVal - nLastVal) == nDiff); if (nWordSize == 1) { CPLAssert(nDiff >= -128 && nDiff <= 127); char chDiff = (char)nDiff; VSIFWriteL(&chDiff, 1, 1, fp); } else if (nWordSize == 2) { CPLAssert(nDiff >= -32768 && nDiff <= 32767); WriteShort(fp, (short)nDiff); } else { WriteInt(fp, nDiff); } nLastVal = nVal; } } } if( pfnProgress && !pfnProgress( (j * nXBlocks + i + 1) * 1.0 / (nXBlocks * nYBlocks), NULL, pProgressData ) ) { eErr = CE_Failure; break; } } } CPLFree(pTileBuffer); VSIFCloseL(fp); if (eErr != CE_None) return NULL; return (GDALDataset*) GDALOpen(osFilename.c_str(), GA_ReadOnly); }
int OGRMySQLDataSource::Open( const char * pszNewName, int bUpdate, int bTestOpen ) { CPLAssert( nLayers == 0 ); /* -------------------------------------------------------------------- */ /* Verify MySQL prefix. */ /* -------------------------------------------------------------------- */ if( !EQUALN(pszNewName,"MYSQL:",6) ) { if( !bTestOpen ) CPLError( CE_Failure, CPLE_AppDefined, "%s does not conform to MySQL naming convention," " MYSQL:dbname[, user=..][,password=..][,host=..][,port=..][tables=table;table;...]", pszNewName ); return FALSE; } /* -------------------------------------------------------------------- */ /* Use options process to get .my.cnf file contents. */ /* -------------------------------------------------------------------- */ int nPort = 0, i; char **papszTableNames=NULL; std::string oHost, oPassword, oUser, oDB; char *apszArgv[2] = { (char*) "org", NULL }; char **papszArgv = apszArgv; int nArgc = 1; const char *client_groups[] = {"client", "ogr", NULL }; my_init(); // I hope there is no problem with calling this multiple times! load_defaults( "my", client_groups, &nArgc, &papszArgv ); for( i = 0; i < nArgc; i++ ) { if( EQUALN(papszArgv[i],"--user="******"--host=",7) ) oHost = papszArgv[i] + 7; else if( EQUALN(papszArgv[i],"--password="******"--port=",7) ) nPort = atoi(papszArgv[i] + 7); } // cleanup free_defaults( papszArgv ); /* -------------------------------------------------------------------- */ /* Parse out connection information. */ /* -------------------------------------------------------------------- */ char **papszItems = CSLTokenizeString2( pszNewName+6, ",", CSLT_HONOURSTRINGS ); if( CSLCount(papszItems) < 1 ) { CSLDestroy( papszItems ); CPLError( CE_Failure, CPLE_AppDefined, "MYSQL: request missing databasename." ); return FALSE; } oDB = papszItems[0]; for( i = 1; papszItems[i] != NULL; i++ ) { if( EQUALN(papszItems[i],"user="******"password="******"host=",5) ) oHost = papszItems[i] + 5; else if( EQUALN(papszItems[i],"port=",5) ) nPort = atoi(papszItems[i] + 5); else if( EQUALN(papszItems[i],"tables=",7) ) { papszTableNames = CSLTokenizeStringComplex( papszItems[i] + 7, ";", FALSE, FALSE ); } else CPLError( CE_Warning, CPLE_AppDefined, "'%s' in MYSQL datasource definition not recognised and ignored.", papszItems[i] ); } CSLDestroy( papszItems ); /* -------------------------------------------------------------------- */ /* Try to establish connection. */ /* -------------------------------------------------------------------- */ hConn = mysql_init( NULL ); if( hConn == NULL ) { CPLError( CE_Failure, CPLE_AppDefined, "mysql_init() failed." ); } /* -------------------------------------------------------------------- */ /* Set desired options on the connection: charset and timeout. */ /* -------------------------------------------------------------------- */ if( hConn ) { const char *pszTimeoutLength = CPLGetConfigOption( "MYSQL_TIMEOUT", "0" ); unsigned int timeout = atoi(pszTimeoutLength); mysql_options(hConn, MYSQL_OPT_CONNECT_TIMEOUT, (char*)&timeout); mysql_options(hConn, MYSQL_SET_CHARSET_NAME, "utf8" ); } /* -------------------------------------------------------------------- */ /* Perform connection. */ /* -------------------------------------------------------------------- */ if( hConn && mysql_real_connect( hConn, oHost.length() ? oHost.c_str() : NULL, oUser.length() ? oUser.c_str() : NULL, oPassword.length() ? oPassword.c_str() : NULL, oDB.length() ? oDB.c_str() : NULL, nPort, NULL, CLIENT_INTERACTIVE ) == NULL ) { CPLError( CE_Failure, CPLE_AppDefined, "MySQL connect failed for: %s\n%s", pszNewName + 6, mysql_error( hConn ) ); mysql_close( hConn ); hConn = NULL; } if( hConn == NULL ) { CSLDestroy( papszTableNames ); return FALSE; } pszName = CPLStrdup( pszNewName ); bDSUpdate = bUpdate; /* -------------------------------------------------------------------- */ /* Get a list of available tables. */ /* -------------------------------------------------------------------- */ if( papszTableNames == NULL ) { MYSQL_RES *hResultSet; MYSQL_ROW papszRow; if( mysql_query( hConn, "SHOW TABLES" ) ) { ReportError( "SHOW TABLES Failed" ); return FALSE; } hResultSet = mysql_store_result( hConn ); if( hResultSet == NULL ) { ReportError( "mysql_store_result() failed on SHOW TABLES result."); return FALSE; } while( (papszRow = mysql_fetch_row( hResultSet )) != NULL ) { if( papszRow[0] == NULL ) continue; if( EQUAL(papszRow[0],"spatial_ref_sys") || EQUAL(papszRow[0],"geometry_columns") ) continue; papszTableNames = CSLAddString(papszTableNames, papszRow[0] ); } mysql_free_result( hResultSet ); } /* -------------------------------------------------------------------- */ /* Get the schema of the available tables. */ /* -------------------------------------------------------------------- */ int iRecord; for( iRecord = 0; papszTableNames != NULL && papszTableNames[iRecord] != NULL; iRecord++ ) { // FIXME: This should be fixed to deal with tables // for which we can't open because the name is bad/ OpenTable( papszTableNames[iRecord], bUpdate, FALSE ); } CSLDestroy( papszTableNames ); return nLayers > 0 || bUpdate; }
static GDALDataset * VRTCreateCopy( const char * pszFilename, GDALDataset *poSrcDS, int bStrict, char ** papszOptions, CPL_UNUSED GDALProgressFunc pfnProgress, CPL_UNUSED void * pProgressData ) { VRTDataset *poVRTDS = NULL; (void) bStrict; (void) papszOptions; CPLAssert( NULL != poSrcDS ); /* -------------------------------------------------------------------- */ /* If the source dataset is a virtual dataset then just write */ /* it to disk as a special case to avoid extra layers of */ /* indirection. */ /* -------------------------------------------------------------------- */ if( poSrcDS->GetDriver() != NULL && EQUAL(poSrcDS->GetDriver()->GetDescription(),"VRT") ) { /* -------------------------------------------------------------------- */ /* Convert tree to a single block of XML text. */ /* -------------------------------------------------------------------- */ char *pszVRTPath = CPLStrdup(CPLGetPath(pszFilename)); ((VRTDataset *) poSrcDS)->UnsetPreservedRelativeFilenames(); CPLXMLNode *psDSTree = ((VRTDataset *) poSrcDS)->SerializeToXML( pszVRTPath ); char *pszXML = CPLSerializeXMLTree( psDSTree ); CPLDestroyXMLNode( psDSTree ); CPLFree( pszVRTPath ); /* -------------------------------------------------------------------- */ /* Write to disk. */ /* -------------------------------------------------------------------- */ GDALDataset* pCopyDS = NULL; if( 0 != strlen( pszFilename ) ) { VSILFILE *fpVRT = NULL; fpVRT = VSIFOpenL( pszFilename, "wb" ); if (fpVRT == NULL) { CPLError(CE_Failure, CPLE_AppDefined, "Cannot create %s", pszFilename); CPLFree( pszXML ); return NULL; } VSIFWriteL( pszXML, 1, strlen(pszXML), fpVRT ); VSIFCloseL( fpVRT ); pCopyDS = (GDALDataset *) GDALOpen( pszFilename, GA_Update ); } else { /* No destination file is given, so pass serialized XML directly. */ pCopyDS = (GDALDataset *) GDALOpen( pszXML, GA_Update ); } CPLFree( pszXML ); return pCopyDS; } /* -------------------------------------------------------------------- */ /* Create the virtual dataset. */ /* -------------------------------------------------------------------- */ poVRTDS = (VRTDataset *) VRTDataset::Create( pszFilename, poSrcDS->GetRasterXSize(), poSrcDS->GetRasterYSize(), 0, GDT_Byte, NULL ); if (poVRTDS == NULL) return NULL; /* -------------------------------------------------------------------- */ /* Do we have a geotransform? */ /* -------------------------------------------------------------------- */ double adfGeoTransform[6]; if( poSrcDS->GetGeoTransform( adfGeoTransform ) == CE_None ) { poVRTDS->SetGeoTransform( adfGeoTransform ); } /* -------------------------------------------------------------------- */ /* Copy projection */ /* -------------------------------------------------------------------- */ poVRTDS->SetProjection( poSrcDS->GetProjectionRef() ); /* -------------------------------------------------------------------- */ /* Emit dataset level metadata. */ /* -------------------------------------------------------------------- */ poVRTDS->SetMetadata( poSrcDS->GetMetadata() ); /* -------------------------------------------------------------------- */ /* Copy any special domains that should be transportable. */ /* -------------------------------------------------------------------- */ char **papszMD; papszMD = poSrcDS->GetMetadata( "RPC" ); if( papszMD ) poVRTDS->SetMetadata( papszMD, "RPC" ); papszMD = poSrcDS->GetMetadata( "IMD" ); if( papszMD ) poVRTDS->SetMetadata( papszMD, "IMD" ); papszMD = poSrcDS->GetMetadata( "GEOLOCATION" ); if( papszMD ) poVRTDS->SetMetadata( papszMD, "GEOLOCATION" ); /* -------------------------------------------------------------------- */ /* GCPs */ /* -------------------------------------------------------------------- */ if( poSrcDS->GetGCPCount() > 0 ) { poVRTDS->SetGCPs( poSrcDS->GetGCPCount(), poSrcDS->GetGCPs(), poSrcDS->GetGCPProjection() ); } /* -------------------------------------------------------------------- */ /* Loop over all the bands. */ /* -------------------------------------------------------------------- */ for( int iBand = 0; iBand < poSrcDS->GetRasterCount(); iBand++ ) { GDALRasterBand *poSrcBand = poSrcDS->GetRasterBand( iBand+1 ); /* -------------------------------------------------------------------- */ /* Create the band with the appropriate band type. */ /* -------------------------------------------------------------------- */ poVRTDS->AddBand( poSrcBand->GetRasterDataType(), NULL ); VRTSourcedRasterBand *poVRTBand = (VRTSourcedRasterBand *) poVRTDS->GetRasterBand( iBand+1 ); /* -------------------------------------------------------------------- */ /* Setup source mapping. */ /* -------------------------------------------------------------------- */ poVRTBand->AddSimpleSource( poSrcBand ); /* -------------------------------------------------------------------- */ /* Emit various band level metadata. */ /* -------------------------------------------------------------------- */ poVRTBand->CopyCommonInfoFrom( poSrcBand ); /* -------------------------------------------------------------------- */ /* Add specific mask band. */ /* -------------------------------------------------------------------- */ if ( (poSrcBand->GetMaskFlags() & (GMF_PER_DATASET | GMF_ALL_VALID | GMF_NODATA)) == 0) { VRTSourcedRasterBand* poVRTMaskBand = new VRTSourcedRasterBand(poVRTDS, 0, poSrcBand->GetMaskBand()->GetRasterDataType(), poSrcDS->GetRasterXSize(), poSrcDS->GetRasterYSize()); poVRTMaskBand->AddMaskBandSource( poSrcBand ); poVRTBand->SetMaskBand( poVRTMaskBand ); } } /* -------------------------------------------------------------------- */ /* Add dataset mask band */ /* -------------------------------------------------------------------- */ if (poSrcDS->GetRasterCount() != 0 && poSrcDS->GetRasterBand(1) != NULL && poSrcDS->GetRasterBand(1)->GetMaskFlags() == GMF_PER_DATASET) { GDALRasterBand *poSrcBand = poSrcDS->GetRasterBand(1); VRTSourcedRasterBand* poVRTMaskBand = new VRTSourcedRasterBand(poVRTDS, 0, poSrcBand->GetMaskBand()->GetRasterDataType(), poSrcDS->GetRasterXSize(), poSrcDS->GetRasterYSize()); poVRTMaskBand->AddMaskBandSource( poSrcBand ); poVRTDS->SetMaskBand( poVRTMaskBand ); } poVRTDS->FlushCache(); return poVRTDS; }
int OGRTABDataSource::Create( const char * pszName, char **papszOptions ) { VSIStatBuf sStat; const char *pszOpt; CPLAssert( m_pszName == NULL ); m_pszName = CPLStrdup( pszName ); m_papszOptions = CSLDuplicate( papszOptions ); if( (pszOpt=CSLFetchNameValue(papszOptions,"FORMAT")) != NULL && EQUAL(pszOpt, "MIF") ) m_bCreateMIF = TRUE; else if( EQUAL(CPLGetExtension(pszName),"mif") || EQUAL(CPLGetExtension(pszName),"mid") ) m_bCreateMIF = TRUE; if( (pszOpt=CSLFetchNameValue(papszOptions,"SPATIAL_INDEX_MODE")) != NULL && EQUAL(pszOpt, "QUICK") ) m_bQuickSpatialIndexMode = TRUE; /* -------------------------------------------------------------------- */ /* Create a new empty directory. */ /* -------------------------------------------------------------------- */ if( strlen(CPLGetExtension(pszName)) == 0 ) { if( VSIStat( pszName, &sStat ) == 0 ) { if( !VSI_ISDIR(sStat.st_mode) ) { CPLError( CE_Failure, CPLE_OpenFailed, "Attempt to create dataset named %s,\n" "but that is an existing file.\n", pszName ); return FALSE; } } else { if( VSIMkdir( pszName, 0755 ) != 0 ) { CPLError( CE_Failure, CPLE_AppDefined, "Unable to create directory %s.\n", pszName ); return FALSE; } } m_pszDirectory = CPLStrdup(pszName); } /* -------------------------------------------------------------------- */ /* Create a new single file. */ /* -------------------------------------------------------------------- */ else { IMapInfoFile *poFile; if( m_bCreateMIF ) poFile = new MIFFile; else poFile = new TABFile; if( poFile->Open( pszName, "wb", FALSE ) != 0 ) { delete poFile; return FALSE; } m_nLayerCount = 1; m_papoLayers = (IMapInfoFile **) CPLMalloc(sizeof(void*)); m_papoLayers[0] = poFile; m_pszDirectory = CPLStrdup( CPLGetPath(pszName) ); m_bSingleFile = TRUE; } return TRUE; }
CPLErr EpsilonRasterBand::IReadBlock( int nBlockXOff, int nBlockYOff, void * pImage) { EpsilonDataset* poGDS = (EpsilonDataset*) poDS; //CPLDebug("EPSILON", "IReadBlock(nBand=%d,nBlockXOff=%d,nBlockYOff=%d)", // nBand, nBlockXOff, nBlockYOff); int nBlocksPerRow = (poGDS->nRasterXSize + nBlockXSize - 1) / nBlockXSize; int nBlock = nBlockXOff + nBlockYOff * nBlocksPerRow; BlockDesc* psDesc = &poGDS->pasBlocks[nBlock]; #ifdef DEBUG int nBlocksPerColumn = (poGDS->nRasterYSize + nBlockYSize - 1) / nBlockYSize; CPLAssert(psDesc->x == nBlockXOff * nBlockXSize); CPLAssert(psDesc->y == nBlockYOff * nBlockYSize); CPLAssert(psDesc->w == (nBlockXOff < nBlocksPerRow - 1) ? nBlockXSize : poGDS->nRasterXSize - psDesc->x); CPLAssert(psDesc->h == (nBlockYOff < nBlocksPerColumn - 1) ? nBlockYSize : poGDS->nRasterYSize - psDesc->y); #endif poGDS->Seek(psDesc->offset); if (!poGDS->GetNextBlockData()) { memset(pImage, 0, nBlockXSize * nBlockYSize); return CE_Failure; } eps_block_header hdr; if (eps_read_block_header (poGDS->pabyBlockData, poGDS->nBlockDataSize, &hdr) != EPS_OK) { CPLError(CE_Warning, CPLE_AppDefined, "cannot read block header"); memset(pImage, 0, nBlockXSize * nBlockYSize); return CE_Failure; } if (hdr.chk_flag == EPS_BAD_CRC || hdr.crc_flag == EPS_BAD_CRC) { CPLError(CE_Warning, CPLE_AppDefined, "bad CRC"); memset(pImage, 0, nBlockXSize * nBlockYSize); return CE_Failure; } int w = (hdr.block_type == EPS_GRAYSCALE_BLOCK) ? hdr.gs.w : hdr.tc.w; int h = (hdr.block_type == EPS_GRAYSCALE_BLOCK) ? hdr.gs.h : hdr.tc.h; int i; if (poGDS->nBands == 1) { unsigned char ** pTempData = (unsigned char **) CPLMalloc(h * sizeof(unsigned char*)); for(i=0;i<h;i++) pTempData[i] = ((GByte*)pImage) + i * nBlockXSize; if (w != nBlockXSize || h != nBlockYSize) memset(pImage, 0, nBlockXSize * nBlockYSize); if (eps_decode_grayscale_block (pTempData, poGDS->pabyBlockData, &hdr) != EPS_OK) { CPLFree(pTempData); memset(pImage, 0, nBlockXSize * nBlockYSize); return CE_Failure; } CPLFree(pTempData); } else { if (poGDS->pabyRGBData == NULL) { poGDS->pabyRGBData = (GByte*) VSIMalloc3(nBlockXSize, nBlockYSize, 3); if (poGDS->pabyRGBData == NULL) { memset(pImage, 0, nBlockXSize * nBlockYSize); return CE_Failure; } } if (poGDS->nBufferedBlock == nBlock) { memcpy(pImage, poGDS->pabyRGBData + (nBand - 1) * nBlockXSize * nBlockYSize, nBlockXSize * nBlockYSize); return CE_None; } unsigned char ** pTempData[3]; int iBand; for(iBand=0;iBand<3;iBand++) { pTempData[iBand] = (unsigned char **) CPLMalloc(h * sizeof(unsigned char*)); for(i=0;i<h;i++) pTempData[iBand][i] = poGDS->pabyRGBData + iBand * nBlockXSize * nBlockYSize + i * nBlockXSize; } if (w != nBlockXSize || h != nBlockYSize) memset(poGDS->pabyRGBData, 0, 3 * nBlockXSize * nBlockYSize); if (eps_decode_truecolor_block (pTempData[0], pTempData[1], pTempData[2], poGDS->pabyBlockData, &hdr) != EPS_OK) { for(iBand=0;iBand<poGDS->nBands;iBand++) CPLFree(pTempData[iBand]); memset(pImage, 0, nBlockXSize * nBlockYSize); return CE_Failure; } for(iBand=0;iBand<poGDS->nBands;iBand++) CPLFree(pTempData[iBand]); poGDS->nBufferedBlock = nBlock; memcpy(pImage, poGDS->pabyRGBData + (nBand - 1) * nBlockXSize * nBlockYSize, nBlockXSize * nBlockYSize); if (nBand == 1) { int iOtherBand; for(iOtherBand=2;iOtherBand<=poGDS->nBands;iOtherBand++) { GDALRasterBlock *poBlock; poBlock = poGDS->GetRasterBand(iOtherBand)-> GetLockedBlockRef(nBlockXOff,nBlockYOff, TRUE); if (poBlock == NULL) break; GByte* pabySrcBlock = (GByte *) poBlock->GetDataRef(); if( pabySrcBlock == NULL ) { poBlock->DropLock(); break; } memcpy(pabySrcBlock, poGDS->pabyRGBData + (iOtherBand - 1) * nBlockXSize * nBlockYSize, nBlockXSize * nBlockYSize); poBlock->DropLock(); } } } return CE_None; }
int OGRShapeDataSource::Open( const char * pszNewName, int bUpdate, int bTestOpen, int bForceSingleFileDataSource ) { VSIStatBufL stat; CPLAssert( nLayers == 0 ); pszName = CPLStrdup( pszNewName ); bDSUpdate = bUpdate; bSingleFileDataSource = bForceSingleFileDataSource; /* -------------------------------------------------------------------- */ /* If bSingleFileDataSource is TRUE we don't try to do anything else. */ /* This is only utilized when the OGRShapeDriver::Create() */ /* method wants to create a stub OGRShapeDataSource for a */ /* single shapefile. The driver will take care of creating the */ /* file by calling CreateLayer(). */ /* -------------------------------------------------------------------- */ if( bSingleFileDataSource ) return TRUE; /* -------------------------------------------------------------------- */ /* Is the given path a directory or a regular file? */ /* -------------------------------------------------------------------- */ if( VSIStatExL( pszNewName, &stat, VSI_STAT_EXISTS_FLAG | VSI_STAT_NATURE_FLAG ) != 0 || (!VSI_ISDIR(stat.st_mode) && !VSI_ISREG(stat.st_mode)) ) { if( !bTestOpen ) CPLError( CE_Failure, CPLE_AppDefined, "%s is neither a file or directory, Shape access failed.\n", pszNewName ); return FALSE; } /* -------------------------------------------------------------------- */ /* Build a list of filenames we figure are Shape files. */ /* -------------------------------------------------------------------- */ if( VSI_ISREG(stat.st_mode) ) { if( !OpenFile( pszNewName, bUpdate, bTestOpen ) ) { if( !bTestOpen ) CPLError( CE_Failure, CPLE_OpenFailed, "Failed to open shapefile %s.\n" "It may be corrupt or read-only file accessed in update mode.\n", pszNewName ); return FALSE; } bSingleFileDataSource = TRUE; return TRUE; } else { char **papszCandidates = CPLReadDir( pszNewName ); int iCan, nCandidateCount = CSLCount( papszCandidates ); int bMightBeOldCoverage = FALSE; for( iCan = 0; iCan < nCandidateCount; iCan++ ) { char *pszFilename; const char *pszCandidate = papszCandidates[iCan]; if( EQUAL(pszCandidate,"ARC") ) bMightBeOldCoverage = TRUE; if( strlen(pszCandidate) < 4 || !EQUAL(pszCandidate+strlen(pszCandidate)-4,".shp") ) continue; pszFilename = CPLStrdup(CPLFormFilename(pszNewName, pszCandidate, NULL)); if( !OpenFile( pszFilename, bUpdate, bTestOpen ) && !bTestOpen ) { CPLError( CE_Failure, CPLE_OpenFailed, "Failed to open shapefile %s.\n" "It may be corrupt or read-only file accessed in update mode.\n", pszFilename ); CPLFree( pszFilename ); return FALSE; } CPLFree( pszFilename ); } // Try and .dbf files without apparent associated shapefiles. for( iCan = 0; iCan < nCandidateCount; iCan++ ) { char *pszFilename; const char *pszCandidate = papszCandidates[iCan]; const char *pszLayerName; int iLayer, bGotAlready = FALSE; // We don't consume .dbf files in a directory that looks like // an old style Arc/Info (for PC?) that unless we found at least // some shapefiles. See Bug 493. if( bMightBeOldCoverage && nLayers == 0 ) continue; if( strlen(pszCandidate) < 4 || !EQUAL(pszCandidate+strlen(pszCandidate)-4,".dbf") ) continue; pszLayerName = CPLGetBasename(pszCandidate); for( iLayer = 0; iLayer < nLayers; iLayer++ ) { if( EQUAL(pszLayerName, GetLayer(iLayer)->GetLayerDefn()->GetName()) ) bGotAlready = TRUE; } if( bGotAlready ) continue; // We don't want to access .dbf files with an associated .tab // file, or it will never get recognised as a mapinfo dataset. int iCan2, bFoundTAB = FALSE; for( iCan2 = 0; iCan2 < nCandidateCount; iCan2++ ) { const char *pszCandidate2 = papszCandidates[iCan2]; if( EQUALN(pszCandidate2,pszLayerName,strlen(pszLayerName)) && EQUAL(pszCandidate2 + strlen(pszLayerName), ".tab") ) bFoundTAB = TRUE; } if( bFoundTAB ) continue; pszFilename = CPLStrdup(CPLFormFilename(pszNewName, pszCandidate, NULL)); if( !OpenFile( pszFilename, bUpdate, bTestOpen ) && !bTestOpen ) { CPLError( CE_Failure, CPLE_OpenFailed, "Failed to open dbf file %s.\n" "It may be corrupt or read-only file accessed in update mode.\n", pszFilename ); CPLFree( pszFilename ); return FALSE; } CPLFree( pszFilename ); } CSLDestroy( papszCandidates ); if( !bTestOpen && nLayers == 0 && !bUpdate ) { CPLError( CE_Failure, CPLE_OpenFailed, "No Shapefiles found in directory %s\n", pszNewName ); } } return nLayers > 0 || bUpdate; }
int OGRGMELayer::FetchDescribe() { CPLString osRequest = "tables/" + osTableId; CPLHTTPResult *psDescribe = poDS->MakeRequest(osRequest); if (psDescribe == NULL) return FALSE; CPLDebug("GME", "table doc = %s\n", psDescribe->pabyData); json_object *table_doc = OGRGMEParseJSON((const char *) psDescribe->pabyData); CPLHTTPDestroyResult(psDescribe); osTableName = OGRGMEGetJSONString(table_doc, "name"); poFeatureDefn = new OGRFeatureDefn(osTableName); poFeatureDefn->Reference(); json_object *schema_doc = json_object_object_get(table_doc, "schema"); json_object *columns_doc = json_object_object_get(schema_doc, "columns"); array_list *column_list = json_object_get_array(columns_doc); CPLString osLastGeomColumn; int field_count = array_list_length(column_list); for( int i = 0; i < field_count; i++ ) { OGRwkbGeometryType eFieldGeomType = wkbNone; json_object *field_obj = (json_object*) array_list_get_idx(column_list, i); const char* name = OGRGMEGetJSONString(field_obj, "name"); OGRFieldDefn oFieldDefn(name, OFTString); const char *type = OGRGMEGetJSONString(field_obj, "type"); if (EQUAL(type, "integer")) oFieldDefn.SetType(OFTInteger); else if (EQUAL(type, "double")) oFieldDefn.SetType(OFTReal); else if (EQUAL(type, "boolean")) oFieldDefn.SetType(OFTInteger); else if (EQUAL(type, "string")) oFieldDefn.SetType(OFTString); else if (EQUAL(type, "string")) { if (EQUAL(name, "gx_id")) { iGxIdField = i; } oFieldDefn.SetType(OFTString); } else if (EQUAL(type, "points")) eFieldGeomType = wkbPoint; else if (EQUAL(type, "linestrings")) eFieldGeomType = wkbLineString; else if (EQUAL(type, "polygons")) eFieldGeomType = wkbPolygon; else if (EQUAL(type, "mixedGeometry")) eFieldGeomType = wkbGeometryCollection; if (eFieldGeomType == wkbNone) { poFeatureDefn->AddFieldDefn(&oFieldDefn); } else { CPLAssert(EQUAL(osGeomColumnName,"")); osGeomColumnName = oFieldDefn.GetNameRef(); poFeatureDefn->SetGeomType(eFieldGeomType); poFeatureDefn->GetGeomFieldDefn(0)->SetSpatialRef(poSRS); } } json_object_put(table_doc); return TRUE; }
int OGRProj4CT::TransformEx( int nCount, double *x, double *y, double *z, int *pabSuccess ) { int err, i; /* -------------------------------------------------------------------- */ /* Potentially transform to radians. */ /* -------------------------------------------------------------------- */ if( bSourceLatLong ) { if( bSourceWrap ) { for( i = 0; i < nCount; i++ ) { if( x[i] != HUGE_VAL && y[i] != HUGE_VAL ) { if( x[i] < dfSourceWrapLong - 180.0 ) x[i] += 360.0; else if( x[i] > dfSourceWrapLong + 180 ) x[i] -= 360.0; } } } for( i = 0; i < nCount; i++ ) { if( x[i] != HUGE_VAL ) { x[i] *= dfSourceToRadians; y[i] *= dfSourceToRadians; } } } /* -------------------------------------------------------------------- */ /* Optimized transform from WebMercator to WGS84 */ /* -------------------------------------------------------------------- */ bool bTransformDone = false; if( bWebMercatorToWGS84 ) { #define REVERSE_SPHERE_RADIUS (1. / 6378137.) double y0 = y[0]; for( i = 0; i < nCount; i++ ) { if( x[i] != HUGE_VAL ) { x[i] = x[i] * REVERSE_SPHERE_RADIUS; if( x[i] > M_PI ) { if( x[i] < M_PI+1e-14 ) x[i] = M_PI; else if (bCheckWithInvertProj) { x[i] = y[i] = HUGE_VAL; y0 = HUGE_VAL; continue; } else { do { x[i] -= 2 * M_PI; } while ( x[i] > M_PI ); } } else if( x[i] < -M_PI ) { if( x[i] > -M_PI-1e-14 ) x[i] = -M_PI; else if (bCheckWithInvertProj) { x[i] = y[i] = HUGE_VAL; y0 = HUGE_VAL; continue; } else { do { x[i] += 2 * M_PI; } while( x[i] < -M_PI ); } } // Optimization for the case where we are provided a whole line of same northing if( i > 0 && y[i] == y0 ) y[i] = y[0]; else y[i] = M_PI / 2 - 2. * atan(exp(-y[i] * REVERSE_SPHERE_RADIUS)); } } bTransformDone = true; } else if( bIdentityTransform ) bTransformDone = true; /* -------------------------------------------------------------------- */ /* Do the transformation (or not...) using PROJ.4. */ /* -------------------------------------------------------------------- */ if( !bTransformDone && pjctx == NULL ) { /* The mutex has already been created */ CPLAssert(hPROJMutex != NULL); CPLAcquireMutex(hPROJMutex, 1000.0); } if( bTransformDone ) err = 0; else if (bCheckWithInvertProj) { /* For some projections, we cannot detect if we are trying to reproject */ /* coordinates outside the validity area of the projection. So let's do */ /* the reverse reprojection and compare with the source coordinates */ if (nCount > nMaxCount) { nMaxCount = nCount; padfOriX = (double*) CPLRealloc(padfOriX, sizeof(double)*nCount); padfOriY = (double*) CPLRealloc(padfOriY, sizeof(double)*nCount); padfOriZ = (double*) CPLRealloc(padfOriZ, sizeof(double)*nCount); padfTargetX = (double*) CPLRealloc(padfTargetX, sizeof(double)*nCount); padfTargetY = (double*) CPLRealloc(padfTargetY, sizeof(double)*nCount); padfTargetZ = (double*) CPLRealloc(padfTargetZ, sizeof(double)*nCount); } memcpy(padfOriX, x, sizeof(double)*nCount); memcpy(padfOriY, y, sizeof(double)*nCount); if (z) { memcpy(padfOriZ, z, sizeof(double)*nCount); } err = pfn_pj_transform( psPJSource, psPJTarget, nCount, 1, x, y, z ); if (err == 0) { memcpy(padfTargetX, x, sizeof(double)*nCount); memcpy(padfTargetY, y, sizeof(double)*nCount); if (z) { memcpy(padfTargetZ, z, sizeof(double)*nCount); } err = pfn_pj_transform( psPJTarget, psPJSource , nCount, 1, padfTargetX, padfTargetY, (z) ? padfTargetZ : NULL); if (err == 0) { for( i = 0; i < nCount; i++ ) { if ( x[i] != HUGE_VAL && y[i] != HUGE_VAL && (fabs(padfTargetX[i] - padfOriX[i]) > dfThreshold || fabs(padfTargetY[i] - padfOriY[i]) > dfThreshold) ) { x[i] = HUGE_VAL; y[i] = HUGE_VAL; } } } } } else { err = pfn_pj_transform( psPJSource, psPJTarget, nCount, 1, x, y, z ); } /* -------------------------------------------------------------------- */ /* Try to report an error through CPL. Get proj.4 error string */ /* if possible. Try to avoid reporting thousands of error */ /* ... suppress further error reporting on this OGRProj4CT if we */ /* have already reported 20 errors. */ /* -------------------------------------------------------------------- */ if( err != 0 ) { if( pabSuccess ) memset( pabSuccess, 0, sizeof(int) * nCount ); if( ++nErrorCount < 20 ) { if (pjctx != NULL) /* pfn_pj_strerrno not yet thread-safe in PROJ 4.8.0 */ CPLAcquireMutex(hPROJMutex, 1000.0); const char *pszError = NULL; if( pfn_pj_strerrno != NULL ) pszError = pfn_pj_strerrno( err ); if( pszError == NULL ) CPLError( CE_Failure, CPLE_AppDefined, "Reprojection failed, err = %d", err ); else CPLError( CE_Failure, CPLE_AppDefined, "%s", pszError ); if (pjctx != NULL) /* pfn_pj_strerrno not yet thread-safe in PROJ 4.8.0 */ CPLReleaseMutex(hPROJMutex); } else if( nErrorCount == 20 ) { CPLError( CE_Failure, CPLE_AppDefined, "Reprojection failed, err = %d, further errors will be suppressed on the transform object.", err ); } if (pjctx == NULL) CPLReleaseMutex(hPROJMutex); return FALSE; } if( !bTransformDone && pjctx == NULL ) CPLReleaseMutex(hPROJMutex); /* -------------------------------------------------------------------- */ /* Potentially transform back to degrees. */ /* -------------------------------------------------------------------- */ if( bTargetLatLong ) { for( i = 0; i < nCount; i++ ) { if( x[i] != HUGE_VAL && y[i] != HUGE_VAL ) { x[i] *= dfTargetFromRadians; y[i] *= dfTargetFromRadians; } } if( bTargetWrap ) { for( i = 0; i < nCount; i++ ) { if( x[i] != HUGE_VAL && y[i] != HUGE_VAL ) { if( x[i] < dfTargetWrapLong - 180.0 ) x[i] += 360.0; else if( x[i] > dfTargetWrapLong + 180 ) x[i] -= 360.0; } } } } /* -------------------------------------------------------------------- */ /* Establish error information if pabSuccess provided. */ /* -------------------------------------------------------------------- */ if( pabSuccess ) { for( i = 0; i < nCount; i++ ) { if( x[i] == HUGE_VAL || y[i] == HUGE_VAL ) pabSuccess[i] = FALSE; else pabSuccess[i] = TRUE; } } return TRUE; }
OGRFeature *OGRGMLLayer::GetNextFeature() { if (bWriter) { CPLError(CE_Failure, CPLE_NotSupported, "Cannot read features when writing a GML file"); return NULL; } if( poDS->GetLastReadLayer() != this ) { if( poDS->GetReadMode() != INTERLEAVED_LAYERS ) ResetReading(); poDS->SetLastReadLayer(this); } /* ==================================================================== */ /* Loop till we find and translate a feature meeting all our */ /* requirements. */ /* ==================================================================== */ while( true ) { GMLFeature *poGMLFeature = NULL; OGRGeometry *poGeom = NULL; poGMLFeature = poDS->PeekStoredGMLFeature(); if (poGMLFeature != NULL) poDS->SetStoredGMLFeature(NULL); else { poGMLFeature = poDS->GetReader()->NextFeature(); if( poGMLFeature == NULL ) return NULL; // We count reading low level GML 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++; } /* -------------------------------------------------------------------- */ /* Is it of the proper feature class? */ /* -------------------------------------------------------------------- */ if( poGMLFeature->GetClass() != poFClass ) { if( poDS->GetReadMode() == INTERLEAVED_LAYERS || (poDS->GetReadMode() == SEQUENTIAL_LAYERS && iNextGMLId != 0) ) { CPLAssert(poDS->PeekStoredGMLFeature() == NULL); poDS->SetStoredGMLFeature(poGMLFeature); return NULL; } else { delete poGMLFeature; continue; } } /* -------------------------------------------------------------------- */ /* Extract the fid: */ /* -Assumes the fids are non-negative integers with an optional */ /* prefix */ /* -If a prefix differs from the prefix of the first feature from */ /* the poDS then the fids from the poDS are ignored and are */ /* assigned serially thereafter */ /* -------------------------------------------------------------------- */ GIntBig nFID = -1; const char * pszGML_FID = poGMLFeature->GetFID(); if( bInvalidFIDFound ) { nFID = iNextGMLId++; } else if( pszGML_FID == NULL ) { bInvalidFIDFound = true; nFID = iNextGMLId++; } else if( iNextGMLId == 0 ) { int j = 0; int i = static_cast<int>(strlen( pszGML_FID ))-1; while( i >= 0 && pszGML_FID[i] >= '0' && pszGML_FID[i] <= '9' && j<20) i--, j++; /* i points the last character of the fid */ if( i >= 0 && j < 20 && pszFIDPrefix == NULL) { pszFIDPrefix = (char *) CPLMalloc(i+2); pszFIDPrefix[i+1] = '\0'; strncpy(pszFIDPrefix, pszGML_FID, i+1); } /* pszFIDPrefix now contains the prefix or NULL if no prefix is found */ if( j < 20 && sscanf(pszGML_FID+i+1, CPL_FRMT_GIB, &nFID)==1) { if( iNextGMLId <= nFID ) iNextGMLId = nFID + 1; } else { bInvalidFIDFound = true; nFID = iNextGMLId++; } } else if( iNextGMLId != 0 ) { const char* pszFIDPrefix_notnull = pszFIDPrefix; if (pszFIDPrefix_notnull == NULL) pszFIDPrefix_notnull = ""; int nLenPrefix = static_cast<int>(strlen(pszFIDPrefix_notnull)); if( strncmp(pszGML_FID, pszFIDPrefix_notnull, nLenPrefix) == 0 && strlen(pszGML_FID+nLenPrefix) < 20 && sscanf(pszGML_FID+nLenPrefix, CPL_FRMT_GIB, &nFID) == 1 ) { /* fid with the prefix. Using its numerical part */ if( iNextGMLId < nFID ) iNextGMLId = nFID + 1; } else { /* fid without the aforementioned prefix or a valid numerical part */ bInvalidFIDFound = true; nFID = iNextGMLId++; } } /* -------------------------------------------------------------------- */ /* Does it satisfy the spatial query, if there is one? */ /* -------------------------------------------------------------------- */ OGRGeometry** papoGeometries = NULL; const CPLXMLNode* const * papsGeometry = poGMLFeature->GetGeometryList(); if( poFeatureDefn->GetGeomFieldCount() > 1 ) { papoGeometries = (OGRGeometry**) CPLCalloc( poFeatureDefn->GetGeomFieldCount(), sizeof(OGRGeometry*) ); const char* pszSRSName = poDS->GetGlobalSRSName(); for( int i=0; i < poFeatureDefn->GetGeomFieldCount(); i++ ) { const CPLXMLNode* psGeom = poGMLFeature->GetGeometryRef(i); if( psGeom != NULL ) { const CPLXMLNode* myGeometryList[2]; myGeometryList[0] = psGeom; myGeometryList[1] = NULL; poGeom = GML_BuildOGRGeometryFromList(myGeometryList, true, poDS->GetInvertAxisOrderIfLatLong(), pszSRSName, poDS->GetConsiderEPSGAsURN(), poDS->GetSecondaryGeometryOption(), hCacheSRS, bFaceHoleNegative ); /* Do geometry type changes if needed to match layer geometry type */ if (poGeom != NULL) { papoGeometries[i] = OGRGeometryFactory::forceTo(poGeom, poFeatureDefn->GetGeomFieldDefn(i)->GetType()); poGeom = NULL; } else // We assume the createFromGML() function would have already // reported the error. { for( i=0; i < poFeatureDefn->GetGeomFieldCount(); i++) { delete papoGeometries[i]; } CPLFree(papoGeometries); delete poGMLFeature; return NULL; } } } if( m_poFilterGeom != NULL && m_iGeomFieldFilter >= 0 && m_iGeomFieldFilter < poFeatureDefn->GetGeomFieldCount() && papoGeometries[m_iGeomFieldFilter] && !FilterGeometry( papoGeometries[m_iGeomFieldFilter] ) ) { for( int i=0; i < poFeatureDefn->GetGeomFieldCount(); i++ ) { delete papoGeometries[i]; } CPLFree(papoGeometries); delete poGMLFeature; continue; } } else if (papsGeometry[0] != NULL) { const char* pszSRSName = poDS->GetGlobalSRSName(); poGeom = GML_BuildOGRGeometryFromList(papsGeometry, true, poDS->GetInvertAxisOrderIfLatLong(), pszSRSName, poDS->GetConsiderEPSGAsURN(), poDS->GetSecondaryGeometryOption(), hCacheSRS, bFaceHoleNegative ); /* Do geometry type changes if needed to match layer geometry type */ if (poGeom != NULL) { poGeom = OGRGeometryFactory::forceTo(poGeom, GetGeomType()); } else // We assume the createFromGML() function would have already // reported the error. { delete poGMLFeature; return NULL; } if( m_poFilterGeom != NULL && !FilterGeometry( poGeom ) ) { delete poGMLFeature; delete poGeom; continue; } } /* -------------------------------------------------------------------- */ /* Convert the whole feature into an OGRFeature. */ /* -------------------------------------------------------------------- */ int iField; int iDstField = 0; OGRFeature *poOGRFeature = new OGRFeature( poFeatureDefn ); poOGRFeature->SetFID( nFID ); if (poDS->ExposeId()) { if (pszGML_FID) poOGRFeature->SetField( iDstField, pszGML_FID ); iDstField ++; } int nPropertyCount = poFClass->GetPropertyCount(); for( iField = 0; iField < nPropertyCount; iField++, iDstField ++ ) { const GMLProperty *psGMLProperty = poGMLFeature->GetProperty( iField ); if( psGMLProperty == NULL || psGMLProperty->nSubProperties == 0 ) continue; switch( poFClass->GetProperty(iField)->GetType() ) { case GMLPT_Real: { poOGRFeature->SetField( iDstField, CPLAtof(psGMLProperty->papszSubProperties[0]) ); } break; case GMLPT_IntegerList: { int nCount = psGMLProperty->nSubProperties; int *panIntList = (int *) CPLMalloc(sizeof(int) * nCount ); for( int i = 0; i < nCount; i++ ) panIntList[i] = atoi(psGMLProperty->papszSubProperties[i]); poOGRFeature->SetField( iDstField, nCount, panIntList ); CPLFree( panIntList ); } break; case GMLPT_Integer64List: { int nCount = psGMLProperty->nSubProperties; GIntBig *panIntList = (GIntBig *) CPLMalloc(sizeof(GIntBig) * nCount ); for( int i = 0; i < nCount; i++ ) panIntList[i] = CPLAtoGIntBig(psGMLProperty->papszSubProperties[i]); poOGRFeature->SetField( iDstField, nCount, panIntList ); CPLFree( panIntList ); } break; case GMLPT_RealList: { int nCount = psGMLProperty->nSubProperties; double *padfList = (double *)CPLMalloc(sizeof(double)*nCount); for( int i = 0; i < nCount; i++ ) padfList[i] = CPLAtof(psGMLProperty->papszSubProperties[i]); poOGRFeature->SetField( iDstField, nCount, padfList ); CPLFree( padfList ); } break; case GMLPT_StringList: case GMLPT_FeaturePropertyList: { poOGRFeature->SetField( iDstField, psGMLProperty->papszSubProperties ); } break; case GMLPT_Boolean: { if( strcmp(psGMLProperty->papszSubProperties[0], "true") == 0 || strcmp(psGMLProperty->papszSubProperties[0], "1") == 0 ) { poOGRFeature->SetField( iDstField, 1); } else if( strcmp(psGMLProperty->papszSubProperties[0], "false") == 0 || strcmp(psGMLProperty->papszSubProperties[0], "0") == 0 ) { poOGRFeature->SetField( iDstField, 0); } else poOGRFeature->SetField( iDstField, psGMLProperty->papszSubProperties[0] ); break; } case GMLPT_BooleanList: { int nCount = psGMLProperty->nSubProperties; int *panIntList = (int *) CPLMalloc(sizeof(int) * nCount ); for( int i = 0; i < nCount; i++ ) { panIntList[i] = ( strcmp(psGMLProperty->papszSubProperties[i], "true") == 0 || strcmp(psGMLProperty->papszSubProperties[i], "1") == 0 ); } poOGRFeature->SetField( iDstField, nCount, panIntList ); CPLFree( panIntList ); break; } default: poOGRFeature->SetField( iDstField, psGMLProperty->papszSubProperties[0] ); break; } } delete poGMLFeature; poGMLFeature = NULL; /* Assign the geometry before the attribute filter because */ /* the attribute filter may use a special field like OGR_GEOMETRY */ if( papoGeometries != NULL ) { for( int i=0; i < poFeatureDefn->GetGeomFieldCount(); i++ ) { poOGRFeature->SetGeomFieldDirectly( i, papoGeometries[i] ); } CPLFree(papoGeometries); papoGeometries = NULL; } else poOGRFeature->SetGeometryDirectly( poGeom ); /* Assign SRS */ for( int i=0; i < poFeatureDefn->GetGeomFieldCount(); i++ ) { poGeom = poOGRFeature->GetGeomFieldRef(i); if( poGeom != NULL ) { OGRSpatialReference* poSRS = poFeatureDefn->GetGeomFieldDefn(i)->GetSpatialRef(); if (poSRS != NULL) poGeom->assignSpatialReference(poSRS); } } /* -------------------------------------------------------------------- */ /* Test against the attribute query. */ /* -------------------------------------------------------------------- */ if( m_poAttrQuery != NULL && !m_poAttrQuery->Evaluate( poOGRFeature ) ) { delete poOGRFeature; continue; } /* -------------------------------------------------------------------- */ /* Wow, we got our desired feature. Return it. */ /* -------------------------------------------------------------------- */ return poOGRFeature; } return NULL; }
int OGRKMLDataSource::Create( const char* pszName, char** papszOptions ) { CPLAssert( NULL != pszName ); if( fpOutput_ != NULL ) { CPLAssert( FALSE ); return FALSE; } if (CSLFetchNameValue(papszOptions, "NameField")) pszNameField_ = CPLStrdup(CSLFetchNameValue(papszOptions, "NameField")); else pszNameField_ = CPLStrdup("Name"); if (CSLFetchNameValue(papszOptions, "DescriptionField")) pszDescriptionField_ = CPLStrdup(CSLFetchNameValue(papszOptions, "DescriptionField")); else pszDescriptionField_ = CPLStrdup("Description"); pszAltitudeMode_ = CPLStrdup(CSLFetchNameValue(papszOptions, "AltitudeMode")); if( (NULL != pszAltitudeMode_) && strlen(pszAltitudeMode_) > 0) { //Check to see that the specified AltitudeMode is valid if ( EQUAL(pszAltitudeMode_, "clampToGround") || EQUAL(pszAltitudeMode_, "relativeToGround") || EQUAL(pszAltitudeMode_, "absolute")) { CPLDebug("KML", "Using '%s' for AltitudeMode", pszAltitudeMode_); } else { CPLFree( pszAltitudeMode_ ); pszAltitudeMode_ = NULL; CPLError( CE_Warning, CPLE_AppDefined, "Invalide AltitideMode specified, ignoring" ); } } else { CPLFree( pszAltitudeMode_ ); pszAltitudeMode_ = NULL; } /* -------------------------------------------------------------------- */ /* Create the output file. */ /* -------------------------------------------------------------------- */ if (strcmp(pszName, "/dev/stdout") == 0) pszName = "/vsistdout/"; pszName_ = CPLStrdup( pszName ); fpOutput_ = VSIFOpenL( pszName, "wb" ); if( fpOutput_ == NULL ) { CPLError( CE_Failure, CPLE_OpenFailed, "Failed to create KML file %s.", pszName ); return FALSE; } /* -------------------------------------------------------------------- */ /* Write out "standard" header. */ /* -------------------------------------------------------------------- */ VSIFPrintfL( fpOutput_, "<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n" ); VSIFPrintfL( fpOutput_, "<kml xmlns=\"http://www.opengis.net/kml/2.2\">\n<Document>" ); return TRUE; }
bool OGRPGeoDriver::FindDriverLib() { // Default name and path of driver library const char* aszDefaultLibName[] = { "libmdbodbc.so", "libmdbodbc.so.0" /* for Ubuntu 8.04 support */ }; const int nLibNames = sizeof(aszDefaultLibName) / sizeof(aszDefaultLibName[0]); const char* libPath[] = { "/usr/lib", "/usr/local/lib" }; const int nLibPaths = sizeof(libPath) / sizeof(libPath[0]); CPLString strLibPath(""); const char* pszDrvCfg = CPLGetConfigOption("MDBDRIVER_PATH", NULL); if ( NULL != pszDrvCfg ) { // Directory or file path strLibPath = pszDrvCfg; VSIStatBuf sStatBuf = { 0 }; if ( VSIStat( pszDrvCfg, &sStatBuf ) == 0 && VSI_ISDIR( sStatBuf.st_mode ) ) { // Find default library in custom directory const char* pszDriverFile = CPLFormFilename( pszDrvCfg, aszDefaultLibName[0], NULL ); CPLAssert( 0 != pszDriverFile ); strLibPath = pszDriverFile; } if ( LibraryExists( strLibPath.c_str() ) ) { // Save custom driver path osDriverFile = strLibPath; return true; } } // Try to find library in default path for ( int i = 0; i < nLibPaths; i++ ) { for ( int j = 0; j < nLibNames; j++ ) { const char* pszDriverFile = CPLFormFilename( libPath[i], aszDefaultLibName[j], NULL ); CPLAssert( 0 != pszDriverFile ); if ( LibraryExists( pszDriverFile ) ) { // Save default driver path osDriverFile = pszDriverFile; return true; } } } CPLError(CE_Failure, CPLE_AppDefined, "PGeo: MDB Tools driver not found!\n"); // Driver not found! return false; }
void OGRKMLDataSource::GrowExtents( OGREnvelope *psGeomBounds ) { CPLAssert( NULL != psGeomBounds ); oEnvelope_.Merge( *psGeomBounds ); }
int GDALMultiDomainMetadata::XMLInit( CPLXMLNode *psTree, int /* bMerge */ ) { CPLXMLNode *psMetadata = nullptr; /* ==================================================================== */ /* Process all <Metadata> elements, each for one domain. */ /* ==================================================================== */ for( psMetadata = psTree->psChild; psMetadata != nullptr; psMetadata = psMetadata->psNext ) { if( psMetadata->eType != CXT_Element || !EQUAL(psMetadata->pszValue,"Metadata") ) continue; const char *pszDomain = CPLGetXMLValue( psMetadata, "domain", "" ); const char *pszFormat = CPLGetXMLValue( psMetadata, "format", "" ); // Make sure we have a CPLStringList for this domain, // without wiping out an existing one. if( GetMetadata( pszDomain ) == nullptr ) SetMetadata( nullptr, pszDomain ); const int iDomain = CSLFindString( papszDomainList, pszDomain ); CPLAssert( iDomain != -1 ); CPLStringList *poMDList = papoMetadataLists[iDomain]; /* -------------------------------------------------------------------- */ /* XML format subdocuments. */ /* -------------------------------------------------------------------- */ if( EQUAL(pszFormat,"xml") ) { // Find first non-attribute child of current element. CPLXMLNode *psSubDoc = psMetadata->psChild; while( psSubDoc != nullptr && psSubDoc->eType == CXT_Attribute ) psSubDoc = psSubDoc->psNext; char *pszDoc = CPLSerializeXMLTree( psSubDoc ); poMDList->Clear(); poMDList->AddStringDirectly( pszDoc ); } /* -------------------------------------------------------------------- */ /* Name value format. */ /* <MDI key="...">value_Text</MDI> */ /* -------------------------------------------------------------------- */ else { for( CPLXMLNode *psMDI = psMetadata->psChild; psMDI != nullptr; psMDI = psMDI->psNext ) { if( !EQUAL(psMDI->pszValue,"MDI") || psMDI->eType != CXT_Element || psMDI->psChild == nullptr || psMDI->psChild->psNext == nullptr || psMDI->psChild->eType != CXT_Attribute || psMDI->psChild->psChild == nullptr ) continue; char* pszName = psMDI->psChild->psChild->pszValue; char* pszValue = psMDI->psChild->psNext->pszValue; if( pszName != nullptr && pszValue != nullptr ) poMDList->SetNameValue( pszName, pszValue ); } } } return CSLCount(papszDomainList) != 0; }
json_object* OGRGMEGeometryToGeoJSON(OGRGeometry* poGeometry) { if ( NULL == poGeometry ) return NULL; json_object* pjoGeometry = json_object_new_object(); CPLAssert( NULL != pjoGeometry ); /* -------------------------------------------------------------------- */ /* Build "type" member of GeoJSOn "geometry" object */ /* and "coordinates" member of GeoJSOn "geometry" object. */ /* -------------------------------------------------------------------- */ const char* pszType = NULL; OGRwkbGeometryType eType = poGeometry->getGeometryType(); json_object* pjoCoordinates = NULL; if( wkbGeometryCollection == eType || wkbGeometryCollection25D == eType ) { pszType = "GeometryCollection"; json_object *pjoGeometries = OGRGMEGeometryCollectionToGeoJSON(static_cast<OGRGeometryCollection*>(poGeometry)); if ( pjoGeometries ) { json_object *pjoType = json_object_new_string(pszType); json_object_object_add( pjoGeometry, "type", pjoType ); json_object_object_add( pjoGeometry, "geometries", pjoGeometries ); } else { json_object_put(pjoGeometry); pjoGeometry = NULL; } } else { if( wkbPoint == eType || wkbPoint25D == eType ) { pszType = "Point"; pjoCoordinates = OGRGMEPointToGeoJSON( static_cast<OGRPoint*>(poGeometry) ); } if( wkbMultiPoint == eType || wkbMultiPoint25D == eType ) { pszType = "MultiPoint"; pjoCoordinates = OGRGMEMultiPointToGeoJSON( static_cast<OGRMultiPoint*>(poGeometry) ); } else if( wkbLineString == eType || wkbLineString25D == eType ) { pszType = "LineString"; pjoCoordinates = OGRGMELineStringToGeoJSON( static_cast<OGRLineString*>(poGeometry) ); } else if( wkbMultiLineString == eType || wkbMultiLineString25D == eType ) { pszType = "MultiLineString"; pjoCoordinates = OGRGMEMultiLineStringToGeoJSON( static_cast<OGRMultiLineString*>(poGeometry) ); } else if( wkbPolygon == eType || wkbPolygon25D == eType ) { pszType = "Polygon"; pjoCoordinates = OGRGMEPolygonToGeoJSON( static_cast<OGRPolygon*>(poGeometry) ); } else if( wkbMultiPolygon == eType || wkbMultiPolygon25D == eType ) { pszType = "MultiPolygon"; pjoCoordinates = OGRGMEMultiPolygonToGeoJSON( static_cast<OGRMultiPolygon*>(poGeometry) ); } else { CPLDebug( "GME", "Unsupported geometry type detected. Geometry is IGNORED." ); } if ( pjoCoordinates && pszType ) { json_object *pjoType = json_object_new_string(pszType); json_object_object_add( pjoGeometry, "type", pjoType ); json_object_object_add( pjoGeometry, "coordinates", pjoCoordinates); } else { json_object_put(pjoGeometry); pjoGeometry = NULL; } } return pjoGeometry; }
int SDTSRasterReader::GetBlock( CPL_UNUSED int nXOffset, int nYOffset, void * pData ) { CPLAssert( nXOffset == 0 ); /* -------------------------------------------------------------------- */ /* Analyse the datatype. */ /* -------------------------------------------------------------------- */ CPLAssert( EQUAL(szFMT,"BI16") || EQUAL(szFMT,"BFP32") ); int nBytesPerValue; if( EQUAL(szFMT,"BI16") ) nBytesPerValue = 2; else nBytesPerValue = 4; DDFRecord *poRecord = NULL; for( int iTry = 0; iTry < 2; iTry++ ) { /* -------------------------------------------------------------------- */ /* Read through till we find the desired record. */ /* -------------------------------------------------------------------- */ CPLErrorReset(); while( (poRecord = oDDFModule.ReadRecord()) != NULL ) { if( poRecord->GetIntSubfield( "CELL", 0, "ROWI", 0 ) == nYOffset + nYStart ) { break; } } if( CPLGetLastErrorType() == CE_Failure ) return FALSE; /* -------------------------------------------------------------------- */ /* If we didn't get what we needed just start over. */ /* -------------------------------------------------------------------- */ if( poRecord == NULL ) { if (iTry == 0) oDDFModule.Rewind(); else { CPLError( CE_Failure, CPLE_AppDefined, "Cannot read scanline %d. Raster access failed.\n", nYOffset ); return FALSE; } } else { break; } } /* -------------------------------------------------------------------- */ /* Validate the records size. Does it represent exactly one */ /* scanline? */ /* -------------------------------------------------------------------- */ DDFField *poCVLS = poRecord->FindField( "CVLS" ); if( poCVLS == NULL ) return FALSE; if( poCVLS->GetRepeatCount() != nXSize ) { CPLError( CE_Failure, CPLE_AppDefined, "Cell record is %d long, but we expected %d, the number\n" "of pixels in a scanline. Raster access failed.\n", poCVLS->GetRepeatCount(), nXSize ); return FALSE; } /* -------------------------------------------------------------------- */ /* Does the CVLS field consist of exactly 1 B(16) field? */ /* -------------------------------------------------------------------- */ if( poCVLS->GetDataSize() < nBytesPerValue * nXSize || poCVLS->GetDataSize() > nBytesPerValue * nXSize + 1 ) { CPLError( CE_Failure, CPLE_AppDefined, "Cell record is not of expected format. Raster access " "failed.\n" ); return FALSE; } /* -------------------------------------------------------------------- */ /* Copy the data to the application buffer, and byte swap if */ /* required. */ /* -------------------------------------------------------------------- */ memcpy( pData, poCVLS->GetData(), nXSize * nBytesPerValue ); #ifdef CPL_LSB if( nBytesPerValue == 2 ) { for( int i = 0; i < nXSize; i++ ) { reinterpret_cast<GInt16 *>( pData )[i] = CPL_MSBWORD16( reinterpret_cast<GInt16 *>( pData )[i] ); } } else { for( int i = 0; i < nXSize; i++ ) { CPL_MSBPTR32( reinterpret_cast<GByte *>( pData ) + i*4 ); } } #endif return TRUE; }
int OGRODBCDataSource::Open( const char * pszNewName, int bUpdate, int bTestOpen ) { CPLAssert( nLayers == 0 ); if( !EQUALN(pszNewName, "ODBC:",5) && EQUAL(CPLGetExtension(pszNewName), "MDB") ) return OpenMDB(pszNewName, bUpdate); /* -------------------------------------------------------------------- */ /* Start parsing dataset name from the end of string, fetching */ /* the name of spatial reference table and names for SRID and */ /* SRTEXT columns first. */ /* -------------------------------------------------------------------- */ char *pszWrkName = CPLStrdup( pszNewName + 5 ); // Skip the 'ODBC:' part char **papszTables = NULL; char **papszGeomCol = NULL; char *pszSRSTableName = NULL; char *pszSRIDCol = NULL, *pszSRTextCol = NULL; char *pszDelimiter; if ( (pszDelimiter = strrchr( pszWrkName, ':' )) != NULL ) { char *pszOBracket = strchr( pszDelimiter + 1, '(' ); if( strchr(pszDelimiter,'\\') != NULL || strchr(pszDelimiter,'/') != NULL ) { /* ** if there are special tokens then this isn't really ** the srs table name, so avoid further processing. */ } else if( pszOBracket == NULL ) { pszSRSTableName = CPLStrdup( pszDelimiter + 1 ); *pszDelimiter = '\0'; } else { char *pszCBracket = strchr( pszOBracket, ')' ); if( pszCBracket != NULL ) *pszCBracket = '\0'; char *pszComma = strchr( pszOBracket, ',' ); if( pszComma != NULL ) { *pszComma = '\0'; pszSRIDCol = CPLStrdup( pszComma + 1 ); } *pszOBracket = '\0'; pszSRSTableName = CPLStrdup( pszDelimiter + 1 ); pszSRTextCol = CPLStrdup( pszOBracket + 1 ); *pszDelimiter = '\0'; } } /* -------------------------------------------------------------------- */ /* Strip off any comma delimeted set of tables names to access */ /* from the end of the string first. Also allow an optional */ /* bracketed geometry column name after the table name. */ /* -------------------------------------------------------------------- */ while( (pszDelimiter = strrchr( pszWrkName, ',' )) != NULL ) { char *pszOBracket = strstr( pszDelimiter + 1, "(" ); if( pszOBracket == NULL ) { papszTables = CSLAddString( papszTables, pszDelimiter + 1 ); papszGeomCol = CSLAddString( papszGeomCol, "" ); } else { char *pszCBracket = strstr(pszOBracket,")"); if( pszCBracket != NULL ) *pszCBracket = '\0'; *pszOBracket = '\0'; papszTables = CSLAddString( papszTables, pszDelimiter + 1 ); papszGeomCol = CSLAddString( papszGeomCol, pszOBracket+1 ); } *pszDelimiter = '\0'; } /* -------------------------------------------------------------------- */ /* Split out userid, password and DSN. The general form is */ /* user/password@dsn. But if there are no @ characters the */ /* whole thing is assumed to be a DSN. */ /* -------------------------------------------------------------------- */ char *pszUserid = NULL; char *pszPassword = NULL; char *pszDSN = NULL; if( strstr(pszWrkName,"@") == NULL ) { pszDSN = CPLStrdup( pszWrkName ); } else { char *pszTarget; pszDSN = CPLStrdup(strstr(pszWrkName, "@") + 1); if( *pszWrkName == '/' ) { pszPassword = CPLStrdup(pszWrkName + 1); pszTarget = strstr(pszPassword,"@"); *pszTarget = '\0'; } else { pszUserid = CPLStrdup(pszWrkName); pszTarget = strstr(pszUserid,"@"); *pszTarget = '\0'; pszTarget = strstr(pszUserid,"/"); if( pszTarget != NULL ) { *pszTarget = '\0'; pszPassword = CPLStrdup(pszTarget+1); } } } CPLFree( pszWrkName ); /* -------------------------------------------------------------------- */ /* Initialize based on the DSN. */ /* -------------------------------------------------------------------- */ CPLDebug( "OGR_ODBC", "EstablishSession(DSN:\"%s\", userid:\"%s\", password:\"%s\")", pszDSN, pszUserid ? pszUserid : "", pszPassword ? pszPassword : "" ); if( !oSession.EstablishSession( pszDSN, pszUserid, pszPassword ) ) { CPLError( CE_Failure, CPLE_AppDefined, "Unable to initialize ODBC connection to DSN for %s,\n" "%s", pszNewName+5, oSession.GetLastError() ); CSLDestroy( papszTables ); CSLDestroy( papszGeomCol ); CPLFree( pszDSN ); CPLFree( pszUserid ); CPLFree( pszPassword ); return FALSE; } CPLFree( pszDSN ); CPLFree( pszUserid ); CPLFree( pszPassword ); pszName = CPLStrdup( pszNewName ); bDSUpdate = bUpdate; /* -------------------------------------------------------------------- */ /* If no explicit list of tables was given, check for a list in */ /* a geometry_columns table. */ /* -------------------------------------------------------------------- */ if( papszTables == NULL ) { CPLODBCStatement oStmt( &oSession ); oStmt.Append( "SELECT f_table_name, f_geometry_column, geometry_type" " FROM geometry_columns" ); if( oStmt.ExecuteSQL() ) { while( oStmt.Fetch() ) { papszTables = CSLAddString( papszTables, oStmt.GetColData(0) ); papszGeomCol = CSLAddString( papszGeomCol, oStmt.GetColData(1) ); } } } /* -------------------------------------------------------------------- */ /* Otherwise our final resort is to return all tables as */ /* non-spatial tables. */ /* -------------------------------------------------------------------- */ if( papszTables == NULL ) { CPLODBCStatement oTableList( &oSession ); if( oTableList.GetTables() ) { while( oTableList.Fetch() ) { const char *pszSchema = oTableList.GetColData(1); CPLString osLayerName; if( pszSchema != NULL && strlen(pszSchema) > 0 ) { osLayerName = pszSchema; osLayerName += "."; } osLayerName += oTableList.GetColData(2); papszTables = CSLAddString( papszTables, osLayerName ); papszGeomCol = CSLAddString(papszGeomCol,""); } } } /* -------------------------------------------------------------------- */ /* If we have an explicit list of requested tables, use them */ /* (non-spatial). */ /* -------------------------------------------------------------------- */ for( int iTable = 0; papszTables != NULL && papszTables[iTable] != NULL; iTable++ ) { if( strlen(papszGeomCol[iTable]) > 0 ) OpenTable( papszTables[iTable], papszGeomCol[iTable], bUpdate ); else OpenTable( papszTables[iTable], NULL, bUpdate ); } CSLDestroy( papszTables ); CSLDestroy( papszGeomCol ); /* -------------------------------------------------------------------- */ /* If no explicit list of tables was given, check for a list in */ /* a geometry_columns table. */ /* -------------------------------------------------------------------- */ if ( pszSRSTableName ) { CPLODBCStatement oSRSList( &oSession ); if ( !pszSRTextCol ) pszSRTextCol = CPLStrdup( "srtext" ); if ( !pszSRIDCol ) pszSRIDCol = CPLStrdup( "srid" ); oSRSList.Append( "SELECT " ); oSRSList.Append( pszSRIDCol ); oSRSList.Append( "," ); oSRSList.Append( pszSRTextCol ); oSRSList.Append( " FROM " ); oSRSList.Append( pszSRSTableName ); CPLDebug( "OGR_ODBC", "ExecuteSQL(%s) to read SRS table", oSRSList.GetCommand() ); if ( oSRSList.ExecuteSQL() ) { int nRows = 256; // A reasonable number of SRIDs to start from panSRID = (int *)CPLMalloc( nRows * sizeof(int) ); papoSRS = (OGRSpatialReference **) CPLMalloc( nRows * sizeof(OGRSpatialReference*) ); while ( oSRSList.Fetch() ) { char *pszSRID = (char *) oSRSList.GetColData( pszSRIDCol ); if ( !pszSRID ) continue; char *pszSRText = (char *) oSRSList.GetColData( pszSRTextCol ); if ( pszSRText ) { if ( nKnownSRID > nRows ) { nRows *= 2; panSRID = (int *)CPLRealloc( panSRID, nRows * sizeof(int) ); papoSRS = (OGRSpatialReference **) CPLRealloc( papoSRS, nRows * sizeof(OGRSpatialReference*) ); } panSRID[nKnownSRID] = atoi( pszSRID ); papoSRS[nKnownSRID] = new OGRSpatialReference(); if ( papoSRS[nKnownSRID]->importFromWkt( &pszSRText ) != OGRERR_NONE ) { delete papoSRS[nKnownSRID]; continue; } nKnownSRID++; } } } } if ( pszSRIDCol ) CPLFree( pszSRIDCol ); if ( pszSRTextCol ) CPLFree( pszSRTextCol ); if ( pszSRSTableName ) CPLFree( pszSRSTableName ); return TRUE; }
swq_expr_node *SWQGeneralEvaluator( swq_expr_node *node, swq_expr_node **sub_node_values ) { swq_expr_node *poRet = NULL; /* -------------------------------------------------------------------- */ /* Floating point operations. */ /* -------------------------------------------------------------------- */ if( sub_node_values[0]->field_type == SWQ_FLOAT || (node->nSubExprCount > 1 && sub_node_values[1]->field_type == SWQ_FLOAT) ) { poRet = new swq_expr_node(0); poRet->field_type = node->field_type; if( SWQ_IS_INTEGER(sub_node_values[0]->field_type) ) sub_node_values[0]->float_value = (double) sub_node_values[0]->int_value; if( node->nSubExprCount > 1 && SWQ_IS_INTEGER(sub_node_values[1]->field_type) ) sub_node_values[1]->float_value = (double)sub_node_values[1]->int_value; if( node->nOperation != SWQ_ISNULL ) { for( int i = 0; i < node->nSubExprCount; i++ ) { if( sub_node_values[i]->is_null ) { if( poRet->field_type == SWQ_BOOLEAN ) { poRet->int_value = FALSE; return poRet; } else if( poRet->field_type == SWQ_FLOAT ) { poRet->float_value = 0; poRet->is_null = 1; return poRet; } else if( SWQ_IS_INTEGER(poRet->field_type) || node->nOperation == SWQ_MODULUS ) { poRet->field_type = SWQ_INTEGER; poRet->int_value = 0; poRet->is_null = 1; return poRet; } } } } switch( (swq_op) node->nOperation ) { case SWQ_EQ: poRet->int_value = sub_node_values[0]->float_value == sub_node_values[1]->float_value; break; case SWQ_NE: poRet->int_value = sub_node_values[0]->float_value != sub_node_values[1]->float_value; break; case SWQ_GT: poRet->int_value = sub_node_values[0]->float_value > sub_node_values[1]->float_value; break; case SWQ_LT: poRet->int_value = sub_node_values[0]->float_value < sub_node_values[1]->float_value; break; case SWQ_GE: poRet->int_value = sub_node_values[0]->float_value >= sub_node_values[1]->float_value; break; case SWQ_LE: poRet->int_value = sub_node_values[0]->float_value <= sub_node_values[1]->float_value; break; case SWQ_IN: { int i; poRet->int_value = 0; for( i = 1; i < node->nSubExprCount; i++ ) { if( sub_node_values[0]->float_value == sub_node_values[i]->float_value ) { poRet->int_value = 1; break; } } } break; case SWQ_BETWEEN: poRet->int_value = sub_node_values[0]->float_value >= sub_node_values[1]->float_value && sub_node_values[0]->float_value <= sub_node_values[2]->float_value; break; case SWQ_ISNULL: poRet->int_value = sub_node_values[0]->is_null; break; case SWQ_ADD: poRet->float_value = sub_node_values[0]->float_value + sub_node_values[1]->float_value; break; case SWQ_SUBTRACT: poRet->float_value = sub_node_values[0]->float_value - sub_node_values[1]->float_value; break; case SWQ_MULTIPLY: poRet->float_value = sub_node_values[0]->float_value * sub_node_values[1]->float_value; break; case SWQ_DIVIDE: if( sub_node_values[1]->float_value == 0 ) poRet->float_value = INT_MAX; else poRet->float_value = sub_node_values[0]->float_value / sub_node_values[1]->float_value; break; case SWQ_MODULUS: { GIntBig nRight = (GIntBig) sub_node_values[1]->float_value; poRet->field_type = SWQ_INTEGER; if (nRight == 0) poRet->int_value = INT_MAX; else poRet->int_value = ((GIntBig) sub_node_values[0]->float_value) % nRight; break; } default: CPLAssert( FALSE ); delete poRet; poRet = NULL; break; } } /* -------------------------------------------------------------------- */ /* integer/boolean operations. */ /* -------------------------------------------------------------------- */ else if( SWQ_IS_INTEGER(sub_node_values[0]->field_type) || sub_node_values[0]->field_type == SWQ_BOOLEAN ) { poRet = new swq_expr_node(0); poRet->field_type = node->field_type; if( node->nOperation != SWQ_ISNULL ) { for( int i = 0; i < node->nSubExprCount; i++ ) { if( sub_node_values[i]->is_null ) { if( poRet->field_type == SWQ_BOOLEAN ) { poRet->int_value = FALSE; return poRet; } else if( SWQ_IS_INTEGER(poRet->field_type) ) { poRet->int_value = 0; poRet->is_null = 1; return poRet; } } } } switch( (swq_op) node->nOperation ) { case SWQ_AND: poRet->int_value = sub_node_values[0]->int_value && sub_node_values[1]->int_value; break; case SWQ_OR: poRet->int_value = sub_node_values[0]->int_value || sub_node_values[1]->int_value; break; case SWQ_NOT: poRet->int_value = !sub_node_values[0]->int_value; break; case SWQ_EQ: poRet->int_value = sub_node_values[0]->int_value == sub_node_values[1]->int_value; break; case SWQ_NE: poRet->int_value = sub_node_values[0]->int_value != sub_node_values[1]->int_value; break; case SWQ_GT: poRet->int_value = sub_node_values[0]->int_value > sub_node_values[1]->int_value; break; case SWQ_LT: poRet->int_value = sub_node_values[0]->int_value < sub_node_values[1]->int_value; break; case SWQ_GE: poRet->int_value = sub_node_values[0]->int_value >= sub_node_values[1]->int_value; break; case SWQ_LE: poRet->int_value = sub_node_values[0]->int_value <= sub_node_values[1]->int_value; break; case SWQ_IN: { poRet->int_value = 0; for( int i = 1; i < node->nSubExprCount; i++ ) { if( sub_node_values[0]->int_value == sub_node_values[i]->int_value ) { poRet->int_value = 1; break; } } } break; case SWQ_BETWEEN: poRet->int_value = sub_node_values[0]->int_value >= sub_node_values[1]->int_value && sub_node_values[0]->int_value <= sub_node_values[2]->int_value; break; case SWQ_ISNULL: poRet->int_value = sub_node_values[0]->is_null; break; case SWQ_ADD: poRet->int_value = sub_node_values[0]->int_value + sub_node_values[1]->int_value; break; case SWQ_SUBTRACT: poRet->int_value = sub_node_values[0]->int_value - sub_node_values[1]->int_value; break; case SWQ_MULTIPLY: poRet->int_value = sub_node_values[0]->int_value * sub_node_values[1]->int_value; break; case SWQ_DIVIDE: if( sub_node_values[1]->int_value == 0 ) poRet->int_value = INT_MAX; else poRet->int_value = sub_node_values[0]->int_value / sub_node_values[1]->int_value; break; case SWQ_MODULUS: if( sub_node_values[1]->int_value == 0 ) poRet->int_value = INT_MAX; else poRet->int_value = sub_node_values[0]->int_value % sub_node_values[1]->int_value; break; default: CPLAssert( FALSE ); delete poRet; poRet = NULL; break; } } /* -------------------------------------------------------------------- */ /* String operations. */ /* -------------------------------------------------------------------- */ else { poRet = new swq_expr_node(0); poRet->field_type = node->field_type; if( node->nOperation != SWQ_ISNULL ) { for( int i = 0; i < node->nSubExprCount; i++ ) { if( sub_node_values[i]->is_null ) { if( poRet->field_type == SWQ_BOOLEAN ) { poRet->int_value = FALSE; return poRet; } else if( poRet->field_type == SWQ_STRING ) { poRet->string_value = CPLStrdup(""); poRet->is_null = 1; return poRet; } } } } switch( (swq_op) node->nOperation ) { case SWQ_EQ: { /* When comparing timestamps, the +00 at the end might be discarded */ /* if the other member has no explicit timezone */ if( (sub_node_values[0]->field_type == SWQ_TIMESTAMP || sub_node_values[0]->field_type == SWQ_STRING) && (sub_node_values[1]->field_type == SWQ_TIMESTAMP || sub_node_values[1]->field_type == SWQ_STRING) && strlen(sub_node_values[0]->string_value) > 3 && strlen(sub_node_values[1]->string_value) > 3 && (strcmp(sub_node_values[0]->string_value + strlen(sub_node_values[0]->string_value)-3, "+00") == 0 && sub_node_values[1]->string_value[strlen(sub_node_values[1]->string_value)-3] == ':') ) { poRet->int_value = EQUALN(sub_node_values[0]->string_value, sub_node_values[1]->string_value, strlen(sub_node_values[1]->string_value)); } else if( (sub_node_values[0]->field_type == SWQ_TIMESTAMP || sub_node_values[0]->field_type == SWQ_STRING) && (sub_node_values[1]->field_type == SWQ_TIMESTAMP || sub_node_values[1]->field_type == SWQ_STRING) && strlen(sub_node_values[0]->string_value) > 3 && strlen(sub_node_values[1]->string_value) > 3 && (sub_node_values[0]->string_value[strlen(sub_node_values[0]->string_value)-3] == ':') && strcmp(sub_node_values[1]->string_value + strlen(sub_node_values[1]->string_value)-3, "+00") == 0) { poRet->int_value = EQUALN(sub_node_values[0]->string_value, sub_node_values[1]->string_value, strlen(sub_node_values[0]->string_value)); } else { poRet->int_value = strcasecmp(sub_node_values[0]->string_value, sub_node_values[1]->string_value) == 0; } break; } case SWQ_NE: poRet->int_value = strcasecmp(sub_node_values[0]->string_value, sub_node_values[1]->string_value) != 0; break; case SWQ_GT: poRet->int_value = strcasecmp(sub_node_values[0]->string_value, sub_node_values[1]->string_value) > 0; break; case SWQ_LT: poRet->int_value = strcasecmp(sub_node_values[0]->string_value, sub_node_values[1]->string_value) < 0; break; case SWQ_GE: poRet->int_value = strcasecmp(sub_node_values[0]->string_value, sub_node_values[1]->string_value) >= 0; break; case SWQ_LE: poRet->int_value = strcasecmp(sub_node_values[0]->string_value, sub_node_values[1]->string_value) <= 0; break; case SWQ_IN: { int i; poRet->int_value = 0; for( i = 1; i < node->nSubExprCount; i++ ) { if( strcasecmp(sub_node_values[0]->string_value, sub_node_values[i]->string_value) == 0 ) { poRet->int_value = 1; break; } } } break; case SWQ_BETWEEN: poRet->int_value = strcasecmp(sub_node_values[0]->string_value, sub_node_values[1]->string_value) >= 0 && strcasecmp(sub_node_values[0]->string_value, sub_node_values[2]->string_value) <= 0; break; case SWQ_LIKE: { char chEscape = '\0'; if( node->nSubExprCount == 3 ) chEscape = sub_node_values[2]->string_value[0]; poRet->int_value = swq_test_like(sub_node_values[0]->string_value, sub_node_values[1]->string_value, chEscape); break; } case SWQ_ISNULL: poRet->int_value = sub_node_values[0]->is_null; break; case SWQ_CONCAT: case SWQ_ADD: { CPLString osResult = sub_node_values[0]->string_value; for( int i = 1; i < node->nSubExprCount; i++ ) osResult += sub_node_values[i]->string_value; poRet->string_value = CPLStrdup(osResult); poRet->is_null = sub_node_values[0]->is_null; break; } case SWQ_SUBSTR: { int nOffset, nSize; const char *pszSrcStr = sub_node_values[0]->string_value; if( SWQ_IS_INTEGER(sub_node_values[1]->field_type) ) nOffset = (int)sub_node_values[1]->int_value; else if( sub_node_values[1]->field_type == SWQ_FLOAT ) nOffset = (int) sub_node_values[1]->float_value; else nOffset = 0; if( node->nSubExprCount < 3 ) nSize = 100000; else if( SWQ_IS_INTEGER(sub_node_values[2]->field_type) ) nSize = (int)sub_node_values[2]->int_value; else if( sub_node_values[2]->field_type == SWQ_FLOAT ) nSize = (int) sub_node_values[2]->float_value; else nSize = 0; int nSrcStrLen = (int)strlen(pszSrcStr); /* In SQL, the first character is at offset 1 */ /* And 0 is considered as 1 */ if (nOffset > 0) nOffset --; /* Some implementations allow negative offsets, to start */ /* from the end of the string */ else if( nOffset < 0 ) { if( nSrcStrLen + nOffset >= 0 ) nOffset = nSrcStrLen + nOffset; else nOffset = 0; } if( nSize < 0 || nOffset > nSrcStrLen ) { nOffset = 0; nSize = 0; } else if( nOffset + nSize > nSrcStrLen ) nSize = nSrcStrLen - nOffset; CPLString osResult = pszSrcStr + nOffset; if( (int)osResult.size() > nSize ) osResult.resize( nSize ); poRet->string_value = CPLStrdup(osResult); poRet->is_null = sub_node_values[0]->is_null; break; } case SWQ_HSTORE_GET_VALUE: { const char *pszHStore = sub_node_values[0]->string_value; const char *pszSearchedKey = sub_node_values[1]->string_value; char* pszRet = OGRHStoreGetValue(pszHStore, pszSearchedKey); poRet->string_value = pszRet ? pszRet : CPLStrdup(""); poRet->is_null = (pszRet == NULL); break; } default: CPLAssert( FALSE ); delete poRet; poRet = NULL; break; } } return poRet; }