int HF2Dataset::LoadBlockMap() { if (bHasLoaderBlockMap) return panBlockOffset != NULL; bHasLoaderBlockMap = TRUE; const int nXBlocks = (nRasterXSize + nTileSize - 1) / nTileSize; const int nYBlocks = (nRasterYSize + nTileSize - 1) / nTileSize; panBlockOffset = (vsi_l_offset*) VSIMalloc3(sizeof(vsi_l_offset), nXBlocks, nYBlocks); if (panBlockOffset == NULL) { return FALSE; } for(int j = 0; j < nYBlocks; j++) { for(int i = 0; i < nXBlocks; i++) { vsi_l_offset nOff = VSIFTellL(fp); panBlockOffset[(nYBlocks - 1 - j) * nXBlocks + i] = nOff; //VSIFSeekL(fp, 4 + 4, SEEK_CUR); float fScale, fOff; VSIFReadL(&fScale, 4, 1, fp); VSIFReadL(&fOff, 4, 1, fp); CPL_LSBPTR32(&fScale); CPL_LSBPTR32(&fOff); //printf("fScale = %f, fOff = %f\n", fScale, fOff); const int nCols = MIN(nTileSize, nRasterXSize - nTileSize *i); const int nLines = MIN(nTileSize, nRasterYSize - nTileSize *j); for(int k = 0; k < nLines; k++) { GByte nWordSize; if( VSIFReadL(&nWordSize, 1, 1, fp) != 1 ) { CPLError(CE_Failure, CPLE_FileIO, "File too short"); VSIFree(panBlockOffset); panBlockOffset = NULL; return FALSE; } //printf("nWordSize=%d\n", nWordSize); if (nWordSize == 1 || nWordSize == 2 || nWordSize == 4) VSIFSeekL(fp, static_cast<vsi_l_offset>(4 + nWordSize * (nCols - 1)), SEEK_CUR); else { CPLError(CE_Failure, CPLE_AppDefined, "Got unexpected byte depth (%d) for block (%d, %d) line %d", (int)nWordSize, i, j, k); VSIFree(panBlockOffset); panBlockOffset = NULL; return FALSE; } } } } return TRUE; }
void TABRawBinBlock::Dump(FILE *fpOut /*=NULL*/) { if (fpOut == NULL) fpOut = stdout; fprintf(fpOut, "----- TABRawBinBlock::Dump() -----\n"); if (m_pabyBuf == NULL) { fprintf(fpOut, "Block has not been initialized yet."); } else { if( m_nBlockType == TABMAP_GARB_BLOCK ) { fprintf(fpOut,"Garbage Block (type %d) at offset %d.\n", m_nBlockType, m_nFileOffset); int nNextGarbageBlock = 0; memcpy(&nNextGarbageBlock, m_pabyBuf + 2, 4); CPL_LSBPTR32(&nNextGarbageBlock); fprintf(fpOut," m_nNextGarbageBlock = %d\n", nNextGarbageBlock); } else { fprintf(fpOut, "Block (type %d) size=%d bytes at offset %d in file.\n", m_nBlockType, m_nBlockSize, m_nFileOffset); fprintf(fpOut, "Current pointer at byte %d\n", m_nCurPos); } } fflush(fpOut); }
static int readInt(VSILFILE* fp) { int val; VSIFReadL( &val, 1, 4, fp ); CPL_LSBPTR32(&val); return val; }
static float readFloat(VSILFILE* fp) { float val; VSIFReadL( &val, 1, 4, fp ); CPL_LSBPTR32(&val); return val; }
CPLErr GSBGRasterBand::IReadBlock( int nBlockXOff, int nBlockYOff, void * pImage ) { if( nBlockYOff < 0 || nBlockYOff > nRasterYSize - 1 || nBlockXOff != 0 ) return CE_Failure; GSBGDataset *poGDS = reinterpret_cast<GSBGDataset *>(poDS); if( VSIFSeekL( poGDS->fp, GSBGDataset::nHEADER_SIZE + 4 * static_cast<vsi_l_offset>(nRasterXSize) * (nRasterYSize - nBlockYOff - 1), SEEK_SET ) != 0 ) { CPLError( CE_Failure, CPLE_FileIO, "Unable to seek to beginning of grid row.\n" ); return CE_Failure; } if( VSIFReadL( pImage, sizeof(float), nBlockXSize, poGDS->fp ) != static_cast<unsigned>(nBlockXSize) ) { CPLError( CE_Failure, CPLE_FileIO, "Unable to read block from grid file.\n" ); return CE_Failure; } #ifdef CPL_MSB float *pfImage = (float *)pImage; for( int iPixel=0; iPixel<nBlockXSize; iPixel++ ) { CPL_LSBPTR32( pfImage+iPixel ); } #endif return CE_None; }
int TABRawBinBlock::WriteFloat(float fValue) { #ifdef CPL_MSB CPL_LSBPTR32(&fValue); #endif return WriteBytes(4, (GByte*)&fValue); }
static int ReadInt(VSILFILE* fp, int bOzi3 = FALSE, int nKeyInit = 0) { int nVal; VSIFReadL(&nVal, 1, 4, fp); if (bOzi3) OZIDecrypt(&nVal, 4, (GByte) nKeyInit); CPL_LSBPTR32(&nVal); return nVal; }
static int ReadInt(GByte**pptr) { int nVal; memcpy(&nVal, *pptr, 4); *pptr += 4; CPL_LSBPTR32(&nVal); return nVal; }
int TABRawBinBlock::WriteFloat(float fValue) { #ifdef CPL_MSB CPL_LSBPTR32(&fValue); #endif return WriteBytes(4, reinterpret_cast<GByte*>(&fValue)); }
bool TerragenDataset::get(float& value) { if(1 == VSIFReadL(&value, sizeof(value), 1, m_fp)) { CPL_LSBPTR32(&value); return true; } return false; }
float TABRawBinBlock::ReadFloat() { float fValue = 0.0f; ReadBytes(4, (GByte*)(&fValue)); #ifdef CPL_MSB CPL_LSBPTR32(&fValue); #endif return fValue; }
float TABRawBinBlock::ReadFloat() { float fValue = 0.0f; ReadBytes(4, reinterpret_cast<GByte*>(&fValue)); #ifdef CPL_MSB CPL_LSBPTR32(&fValue); #endif return fValue; }
OGRErr Binary2WkbGeom(unsigned char *p, WKBGeometry* geom, int nBytes) { GUInt32 i; if( nBytes < 28 ) { CPLError(CE_Failure, CPLE_AppDefined, "WalkGeom binary size (%d) too small", nBytes); return OGRERR_FAILURE; } memcpy(&geom->wkbType, p, 4); CPL_LSBPTR32( &geom->wkbType ); switch(geom->wkbType) { case wkbPoint: case wkbLineString: case wkbPolygon: case wkbMultiPoint: case wkbMultiLineString: case wkbMultiPolygon: return Binary2WkbMGeom(p, geom, nBytes); case wkbGeometryCollection: p += 4; memcpy(&geom->mgeometries.num_wkbSGeometries, p, 4); CPL_LSBPTR32( &geom->mgeometries.num_wkbSGeometries ); p += 4; geom->mgeometries.WKBGeometries = new WKBSimpleGeometry[geom->mgeometries.num_wkbSGeometries]; for(i = 0; i < geom->mgeometries.num_wkbSGeometries; i++) Binary2WkbMGeom(p, (WKBGeometry*)(&geom->mgeometries.WKBGeometries[i]), nBytes-8); break; default: geom->wkbType=wkbUnknown; return OGRERR_FAILURE; } return OGRERR_NONE; }
OGRIdrisiLayer::OGRIdrisiLayer( const char* pszFilename, const char* pszLayerName, VSILFILE* fp, OGRwkbGeometryType eGeomType, const char* pszWTKString ) { this->fp = fp; this->eGeomType = eGeomType; nNextFID = 1; bEOF = FALSE; fpAVL = NULL; if (pszWTKString) { poSRS = new OGRSpatialReference(); char* pszTmp = (char*)pszWTKString; poSRS->importFromWkt(&pszTmp); } else poSRS = NULL; poFeatureDefn = new OGRFeatureDefn( pszLayerName ); SetDescription( poFeatureDefn->GetName() ); poFeatureDefn->Reference(); poFeatureDefn->GetGeomFieldDefn(0)->SetSpatialRef(poSRS); poFeatureDefn->SetGeomType( eGeomType ); OGRFieldDefn oFieldDefn("id", OFTReal); poFeatureDefn->AddFieldDefn( &oFieldDefn ); bExtentValid = FALSE; dfMinX = dfMinY = dfMaxX = dfMaxY = 0.0; VSIFSeekL( fp, 1, SEEK_SET ); if (VSIFReadL( &nTotalFeatures, sizeof(unsigned int), 1, fp ) != 1) nTotalFeatures = 0; CPL_LSBPTR32(&nTotalFeatures); if (nTotalFeatures != 0) { if (!Detect_AVL_ADC(pszFilename)) { if( fpAVL != NULL ) VSIFCloseL( fpAVL ); fpAVL = NULL; } } ResetReading(); }
bool LevellerDataset::get(int& n, VSILFILE* fp, const char* psz) { vsi_l_offset offset; size_t len; if(this->locate_data(offset, len, fp, psz)) { GInt32 value; if(1 == VSIFReadL(&value, sizeof(value), 1, fp)) { CPL_LSBPTR32(&value); n = (int)value; return true; } } return false; }
CPLErr BTRasterBand::SetUnitType(const char* psz) { BTDataset& ds = *(BTDataset*)poDS; if(EQUAL(psz, "m")) ds.m_fVscale = 1.0f; else if(EQUAL(psz, "ft")) ds.m_fVscale = 0.3048f; else if(EQUAL(psz, "sft")) ds.m_fVscale = 1200.0f / 3937.0f; else return CE_Failure; float fScale = ds.m_fVscale; CPL_LSBPTR32(&fScale); // Update header's elevation scale field. memcpy(ds.abyHeader + 62, &fScale, sizeof(fScale)); ds.bHeaderModified = TRUE; return CE_None; }
GDALDataset *LOSLASDataset::Open( GDALOpenInfo * poOpenInfo ) { if( !Identify( poOpenInfo ) ) return NULL; /* -------------------------------------------------------------------- */ /* Create a corresponding GDALDataset. */ /* -------------------------------------------------------------------- */ LOSLASDataset *poDS = new LOSLASDataset(); /* -------------------------------------------------------------------- */ /* Open the file. */ /* -------------------------------------------------------------------- */ poDS->fpImage = VSIFOpenL( poOpenInfo->pszFilename, "rb" ); if( poDS->fpImage == NULL ) { delete poDS; return NULL; } /* -------------------------------------------------------------------- */ /* Read the header. */ /* -------------------------------------------------------------------- */ CPL_IGNORE_RET_VAL(VSIFSeekL( poDS->fpImage, 64, SEEK_SET )); CPL_IGNORE_RET_VAL(VSIFReadL( &(poDS->nRasterXSize), 4, 1, poDS->fpImage )); CPL_IGNORE_RET_VAL(VSIFReadL( &(poDS->nRasterYSize), 4, 1, poDS->fpImage )); CPL_LSBPTR32( &(poDS->nRasterXSize) ); CPL_LSBPTR32( &(poDS->nRasterYSize) ); if (!GDALCheckDatasetDimensions(poDS->nRasterXSize, poDS->nRasterYSize)) { delete poDS; return NULL; } CPL_IGNORE_RET_VAL(VSIFSeekL( poDS->fpImage, 76, SEEK_SET )); float min_lon, min_lat, delta_lon, delta_lat; CPL_IGNORE_RET_VAL(VSIFReadL( &min_lon, 4, 1, poDS->fpImage )); CPL_IGNORE_RET_VAL(VSIFReadL( &delta_lon, 4, 1, poDS->fpImage )); CPL_IGNORE_RET_VAL(VSIFReadL( &min_lat, 4, 1, poDS->fpImage )); CPL_IGNORE_RET_VAL(VSIFReadL( &delta_lat, 4, 1, poDS->fpImage )); CPL_LSBPTR32( &min_lon ); CPL_LSBPTR32( &delta_lon ); CPL_LSBPTR32( &min_lat ); CPL_LSBPTR32( &delta_lat ); poDS->nRecordLength = poDS->nRasterXSize * 4 + 4; /* -------------------------------------------------------------------- */ /* Create band information object. */ /* */ /* Note we are setting up to read from the last image record to */ /* the first since the data comes with the southern most record */ /* first, not the northernmost like we would want. */ /* -------------------------------------------------------------------- */ poDS->SetBand( 1, new RawRasterBand( poDS, 1, poDS->fpImage, poDS->nRasterYSize * poDS->nRecordLength + 4, 4, -1 * poDS->nRecordLength, GDT_Float32, CPL_IS_LSB, TRUE, FALSE ) ); /* -------------------------------------------------------------------- */ /* Setup georeferencing. */ /* -------------------------------------------------------------------- */ poDS->adfGeoTransform[0] = min_lon - delta_lon*0.5; poDS->adfGeoTransform[1] = delta_lon; poDS->adfGeoTransform[2] = 0.0; poDS->adfGeoTransform[3] = min_lat + (poDS->nRasterYSize-0.5) * delta_lat; poDS->adfGeoTransform[4] = 0.0; poDS->adfGeoTransform[5] = -1 * delta_lat; /* -------------------------------------------------------------------- */ /* Initialize any PAM information. */ /* -------------------------------------------------------------------- */ poDS->SetDescription( poOpenInfo->pszFilename ); poDS->TryLoadXML(); /* -------------------------------------------------------------------- */ /* Check for overviews. */ /* -------------------------------------------------------------------- */ poDS->oOvManager.Initialize( poDS, poOpenInfo->pszFilename ); return( poDS ); }
OGRFeature *OGRIdrisiLayer::GetNextRawFeature() { while(TRUE) { if (eGeomType == wkbPoint) { double dfId; double dfX, dfY; if (VSIFReadL(&dfId, sizeof(double), 1, fp) != 1 || VSIFReadL(&dfX, sizeof(double), 1, fp) != 1 || VSIFReadL(&dfY, sizeof(double), 1, fp) != 1) { return NULL; } CPL_LSBPTR64(&dfId); CPL_LSBPTR64(&dfX); CPL_LSBPTR64(&dfY); if (m_poFilterGeom != NULL && (dfX < m_sFilterEnvelope.MinX || dfX > m_sFilterEnvelope.MaxX || dfY < m_sFilterEnvelope.MinY || dfY > m_sFilterEnvelope.MaxY)) { nNextFID ++; continue; } OGRPoint* poGeom = new OGRPoint(dfX, dfY); if (poSRS) poGeom->assignSpatialReference(poSRS); OGRFeature* poFeature = new OGRFeature(poFeatureDefn); poFeature->SetField(0, dfId); poFeature->SetFID(nNextFID ++); poFeature->SetGeometryDirectly(poGeom); ReadAVLLine(poFeature); return poFeature; } else if (eGeomType == wkbLineString) { double dfId; double dfMinXShape, dfMaxXShape, dfMinYShape, dfMaxYShape; unsigned int nNodes; if (VSIFReadL(&dfId, sizeof(double), 1, fp) != 1 || VSIFReadL(&dfMinXShape, sizeof(double), 1, fp) != 1 || VSIFReadL(&dfMaxXShape, sizeof(double), 1, fp) != 1 || VSIFReadL(&dfMinYShape, sizeof(double), 1, fp) != 1 || VSIFReadL(&dfMaxYShape, sizeof(double), 1, fp) != 1) { return NULL; } CPL_LSBPTR64(&dfId); CPL_LSBPTR64(&dfMinXShape); CPL_LSBPTR64(&dfMaxXShape); CPL_LSBPTR64(&dfMinYShape); CPL_LSBPTR64(&dfMaxYShape); if (VSIFReadL(&nNodes, sizeof(unsigned int), 1, fp) != 1) { return NULL; } CPL_LSBPTR32(&nNodes); if (nNodes > 100 * 1000 * 1000) return NULL; if (m_poFilterGeom != NULL && (dfMaxXShape < m_sFilterEnvelope.MinX || dfMinXShape > m_sFilterEnvelope.MaxX || dfMaxYShape < m_sFilterEnvelope.MinY || dfMinYShape > m_sFilterEnvelope.MaxY)) { nNextFID ++; VSIFSeekL(fp, sizeof(OGRRawPoint) * nNodes, SEEK_CUR); continue; } OGRRawPoint* poRawPoints = (OGRRawPoint*)VSIMalloc2(sizeof(OGRRawPoint), nNodes); if (poRawPoints == NULL) { return NULL; } if ((unsigned int)VSIFReadL(poRawPoints, sizeof(OGRRawPoint), nNodes, fp) != nNodes) { VSIFree(poRawPoints); return NULL; } #if defined(CPL_MSB) for(unsigned int iNode=0; iNode<nNodes; iNode++) { CPL_LSBPTR64(&poRawPoints[iNode].x); CPL_LSBPTR64(&poRawPoints[iNode].y); } #endif OGRLineString* poGeom = new OGRLineString(); poGeom->setPoints(nNodes, poRawPoints, NULL); VSIFree(poRawPoints); if (poSRS) poGeom->assignSpatialReference(poSRS); OGRFeature* poFeature = new OGRFeature(poFeatureDefn); poFeature->SetField(0, dfId); poFeature->SetFID(nNextFID ++); poFeature->SetGeometryDirectly(poGeom); ReadAVLLine(poFeature); return poFeature; } else /* if (eGeomType == wkbPolygon) */ { double dfId; double dfMinXShape, dfMaxXShape, dfMinYShape, dfMaxYShape; unsigned int nParts; unsigned int nTotalNodes; if (VSIFReadL(&dfId, sizeof(double), 1, fp) != 1 || VSIFReadL(&dfMinXShape, sizeof(double), 1, fp) != 1 || VSIFReadL(&dfMaxXShape, sizeof(double), 1, fp) != 1 || VSIFReadL(&dfMinYShape, sizeof(double), 1, fp) != 1 || VSIFReadL(&dfMaxYShape, sizeof(double), 1, fp) != 1) { return NULL; } CPL_LSBPTR64(&dfId); CPL_LSBPTR64(&dfMinXShape); CPL_LSBPTR64(&dfMaxXShape); CPL_LSBPTR64(&dfMinYShape); CPL_LSBPTR64(&dfMaxYShape); if (VSIFReadL(&nParts, sizeof(unsigned int), 1, fp) != 1 || VSIFReadL(&nTotalNodes, sizeof(unsigned int), 1, fp) != 1) { return NULL; } CPL_LSBPTR32(&nParts); CPL_LSBPTR32(&nTotalNodes); if (nParts > 100000 || nTotalNodes > 100 * 1000 * 1000) return NULL; if (m_poFilterGeom != NULL && (dfMaxXShape < m_sFilterEnvelope.MinX || dfMinXShape > m_sFilterEnvelope.MaxX || dfMaxYShape < m_sFilterEnvelope.MinY || dfMinYShape > m_sFilterEnvelope.MaxY)) { VSIFSeekL(fp, sizeof(unsigned int) * nParts + sizeof(OGRRawPoint) * nTotalNodes, SEEK_CUR); nNextFID ++; continue; } OGRRawPoint* poRawPoints = (OGRRawPoint*)VSIMalloc2(sizeof(OGRRawPoint), nTotalNodes); if (poRawPoints == NULL) { return NULL; } unsigned int* panNodesCount = NULL; if( nParts > 1 ) { panNodesCount = (unsigned int *)CPLMalloc(sizeof(unsigned int) * nParts); if (VSIFReadL(panNodesCount, sizeof(unsigned int) * nParts, 1, fp) != 1) { VSIFree(poRawPoints); VSIFree(panNodesCount); return NULL; } #if defined(CPL_MSB) for(unsigned int iPart=0; iPart < nParts; iPart ++) { CPL_LSBPTR32(&panNodesCount[iPart]); } #endif } else { unsigned int nNodes; if (VSIFReadL(&nNodes, sizeof(unsigned int) * nParts, 1, fp) != 1) { VSIFree(poRawPoints); return NULL; } CPL_LSBPTR32(&nNodes); if( nNodes != nTotalNodes ) { VSIFree(poRawPoints); return NULL; } } unsigned int iPart; OGRPolygon* poGeom = new OGRPolygon(); for(iPart = 0; iPart < nParts; iPart ++) { unsigned int nNodes = (nParts > 1) ? panNodesCount[iPart] : nTotalNodes; if (nNodes > nTotalNodes || (unsigned int)VSIFReadL(poRawPoints, sizeof(OGRRawPoint), nNodes, fp) != nNodes) { VSIFree(poRawPoints); VSIFree(panNodesCount); delete poGeom; return NULL; } #if defined(CPL_MSB) for(unsigned int iNode=0; iNode<nNodes; iNode++) { CPL_LSBPTR64(&poRawPoints[iNode].x); CPL_LSBPTR64(&poRawPoints[iNode].y); } #endif OGRLinearRing* poLR = new OGRLinearRing(); poGeom->addRingDirectly(poLR); poLR->setPoints(nNodes, poRawPoints, NULL); } VSIFree(poRawPoints); VSIFree(panNodesCount); if (poSRS) poGeom->assignSpatialReference(poSRS); OGRFeature* poFeature = new OGRFeature(poFeatureDefn); poFeature->SetField(0, dfId); poFeature->SetFID(nNextFID ++); poFeature->SetGeometryDirectly(poGeom); ReadAVLLine(poFeature); return poFeature; } } }
void appendInt(void* pBuffer, int val) { CPL_LSBPTR32(&val); memcpy(pBuffer, &val, 4); }
static void WriteInt(VSILFILE* fp, GInt32 val) { CPL_LSBPTR32(&val); VSIFWriteL(&val, 4, 1, fp); }
static void WriteFloat(VSILFILE* fp, float val) { CPL_LSBPTR32(&val); VSIFWriteL(&val, 4, 1, fp); }
CPLErr HF2RasterBand::IReadBlock( int nBlockXOff, int nLineYOff, void * pImage ) { HF2Dataset *poGDS = (HF2Dataset *) poDS; int nXBlocks = (nRasterXSize + nBlockXSize - 1) / nBlockXSize; int nYBlocks = (nRasterYSize + nBlockXSize - 1) / nBlockXSize; if (!poGDS->LoadBlockMap()) return CE_Failure; if (pafBlockData == NULL) { pafBlockData = (float*)VSIMalloc3(nXBlocks * sizeof(float), poGDS->nTileSize, poGDS->nTileSize); if (pafBlockData == NULL) return CE_Failure; } nLineYOff = nRasterYSize - 1 - nLineYOff; int nBlockYOff = nLineYOff / nBlockXSize; int nYOffInTile = nLineYOff % nBlockXSize; if (nBlockYOff != nLastBlockYOff) { nLastBlockYOff = nBlockYOff; memset(pafBlockData, 0, nXBlocks * sizeof(float) * nBlockXSize * nBlockXSize); /* 4 * nBlockXSize is the upper bound */ void* pabyData = CPLMalloc( 4 * nBlockXSize ); int nxoff; for(nxoff = 0; nxoff < nXBlocks; nxoff++) { VSIFSeekL(poGDS->fp, poGDS->panBlockOffset[(nYBlocks - 1 - nBlockYOff) * nXBlocks + nxoff], SEEK_SET); float fScale, fOff; VSIFReadL(&fScale, 4, 1, poGDS->fp); VSIFReadL(&fOff, 4, 1, poGDS->fp); CPL_LSBPTR32(&fScale); CPL_LSBPTR32(&fOff); int nTileWidth = MIN(nBlockXSize, nRasterXSize - nxoff * nBlockXSize); int nTileHeight = MIN(nBlockXSize, nRasterYSize - nBlockYOff * nBlockXSize); int j; for(j=0;j<nTileHeight;j++) { GByte nWordSize; VSIFReadL(&nWordSize, 1, 1, poGDS->fp); if (nWordSize != 1 && nWordSize != 2 && nWordSize != 4) { CPLError(CE_Failure, CPLE_AppDefined, "Unexpected word size : %d", (int)nWordSize); break; } GInt32 nVal; VSIFReadL(&nVal, 4, 1, poGDS->fp); CPL_LSBPTR32(&nVal); VSIFReadL(pabyData, nWordSize * (nTileWidth - 1), 1, poGDS->fp); #if defined(CPL_MSB) if (nWordSize > 1) GDALSwapWords(pabyData, nWordSize, nTileWidth - 1, nWordSize); #endif pafBlockData[nxoff * nBlockXSize * nBlockXSize + j * nBlockXSize + 0] = nVal * fScale + fOff; int i; for(i=1;i<nTileWidth;i++) { if (nWordSize == 1) nVal += ((signed char*)pabyData)[i-1]; else if (nWordSize == 2) nVal += ((GInt16*)pabyData)[i-1]; else nVal += ((GInt32*)pabyData)[i-1]; pafBlockData[nxoff * nBlockXSize * nBlockXSize + j * nBlockXSize + i] = nVal * fScale + fOff; } } } CPLFree(pabyData); } int nTileWidth = MIN(nBlockXSize, nRasterXSize - nBlockXOff * nBlockXSize); memcpy(pImage, pafBlockData + nBlockXOff * nBlockXSize * nBlockXSize + nYOffInTile * nBlockXSize, nTileWidth * sizeof(float)); return CE_None; }
GDALDataset *HF2Dataset::Open( GDALOpenInfo * poOpenInfo ) { CPLString osOriginalFilename(poOpenInfo->pszFilename); if (!Identify(poOpenInfo)) return NULL; GDALOpenInfo* poOpenInfoToDelete = NULL; /* GZipped .hf2 files are common, so automagically open them */ /* if the /vsigzip/ has not been explicitly passed */ CPLString osFilename(poOpenInfo->pszFilename); if ((EQUAL(CPLGetExtension(poOpenInfo->pszFilename), "hfz") || (strlen(poOpenInfo->pszFilename) > 6 && EQUAL(poOpenInfo->pszFilename + strlen(poOpenInfo->pszFilename) - 6, "hf2.gz"))) && !EQUALN(poOpenInfo->pszFilename, "/vsigzip/", 9)) { osFilename = "/vsigzip/"; osFilename += poOpenInfo->pszFilename; poOpenInfo = poOpenInfoToDelete = new GDALOpenInfo(osFilename.c_str(), GA_ReadOnly, poOpenInfo->GetSiblingFiles()); } /* -------------------------------------------------------------------- */ /* Parse header */ /* -------------------------------------------------------------------- */ int nXSize, nYSize; memcpy(&nXSize, poOpenInfo->pabyHeader + 6, 4); CPL_LSBPTR32(&nXSize); memcpy(&nYSize, poOpenInfo->pabyHeader + 10, 4); CPL_LSBPTR32(&nYSize); GUInt16 nTileSize; memcpy(&nTileSize, poOpenInfo->pabyHeader + 14, 2); CPL_LSBPTR16(&nTileSize); float fVertPres, fHorizScale; memcpy(&fVertPres, poOpenInfo->pabyHeader + 16, 4); CPL_LSBPTR32(&fVertPres); memcpy(&fHorizScale, poOpenInfo->pabyHeader + 20, 4); CPL_LSBPTR32(&fHorizScale); GUInt32 nExtendedHeaderLen; memcpy(&nExtendedHeaderLen, poOpenInfo->pabyHeader + 24, 4); CPL_LSBPTR32(&nExtendedHeaderLen); delete poOpenInfoToDelete; poOpenInfoToDelete = NULL; if (nTileSize < 8) return NULL; if (nXSize <= 0 || nXSize > INT_MAX - nTileSize || nYSize <= 0 || nYSize > INT_MAX - nTileSize) return NULL; /* To avoid later potential int overflows */ if (nExtendedHeaderLen > 1024 * 65536) return NULL; if (!GDALCheckDatasetDimensions(nXSize, nYSize)) { return NULL; } /* -------------------------------------------------------------------- */ /* Parse extended blocks */ /* -------------------------------------------------------------------- */ VSILFILE* fp = VSIFOpenL(osFilename.c_str(), "rb"); if (fp == NULL) return NULL; VSIFSeekL(fp, 28, SEEK_SET); int bHasExtent = FALSE; double dfMinX = 0, dfMaxX = 0, dfMinY = 0, dfMaxY = 0; int bHasUTMZone = FALSE; GInt16 nUTMZone = 0; int bHasEPSGDatumCode = FALSE; GInt16 nEPSGDatumCode = 0; int bHasEPSGCode = FALSE; GInt16 nEPSGCode = 0; int bHasRelativePrecision = FALSE; float fRelativePrecision = 0; char szApplicationName[256]; szApplicationName[0] = 0; GUInt32 nExtendedHeaderOff = 0; while(nExtendedHeaderOff < nExtendedHeaderLen) { char pabyBlockHeader[24]; VSIFReadL(pabyBlockHeader, 24, 1, fp); char szBlockName[16 + 1]; memcpy(szBlockName, pabyBlockHeader + 4, 16); szBlockName[16] = 0; GUInt32 nBlockSize; memcpy(&nBlockSize, pabyBlockHeader + 20, 4); CPL_LSBPTR32(&nBlockSize); if (nBlockSize > 65536) break; nExtendedHeaderOff += 24 + nBlockSize; if (strcmp(szBlockName, "georef-extents") == 0 && nBlockSize == 34) { char pabyBlockData[34]; VSIFReadL(pabyBlockData, 34, 1, fp); memcpy(&dfMinX, pabyBlockData + 2, 8); CPL_LSBPTR64(&dfMinX); memcpy(&dfMaxX, pabyBlockData + 2 + 8, 8); CPL_LSBPTR64(&dfMaxX); memcpy(&dfMinY, pabyBlockData + 2 + 8 + 8, 8); CPL_LSBPTR64(&dfMinY); memcpy(&dfMaxY, pabyBlockData + 2 + 8 + 8 + 8, 8); CPL_LSBPTR64(&dfMaxY); bHasExtent = TRUE; } else if (strcmp(szBlockName, "georef-utm") == 0 && nBlockSize == 2) { VSIFReadL(&nUTMZone, 2, 1, fp); CPL_LSBPTR16(&nUTMZone); CPLDebug("HF2", "UTM Zone = %d", nUTMZone); bHasUTMZone = TRUE; } else if (strcmp(szBlockName, "georef-datum") == 0 && nBlockSize == 2) { VSIFReadL(&nEPSGDatumCode, 2, 1, fp); CPL_LSBPTR16(&nEPSGDatumCode); CPLDebug("HF2", "EPSG Datum Code = %d", nEPSGDatumCode); bHasEPSGDatumCode = TRUE; } else if (strcmp(szBlockName, "georef-epsg-prj") == 0 && nBlockSize == 2) { VSIFReadL(&nEPSGCode, 2, 1, fp); CPL_LSBPTR16(&nEPSGCode); CPLDebug("HF2", "EPSG Code = %d", nEPSGCode); bHasEPSGCode = TRUE; } else if (strcmp(szBlockName, "precis-rel") == 0 && nBlockSize == 4) { VSIFReadL(&fRelativePrecision, 4, 1, fp); CPL_LSBPTR32(&fRelativePrecision); bHasRelativePrecision = TRUE; } else if (strcmp(szBlockName, "app-name") == 0 && nBlockSize < 256) { VSIFReadL(szApplicationName, nBlockSize, 1, fp); szApplicationName[nBlockSize] = 0; } else { CPLDebug("HF2", "Skipping block %s", szBlockName); VSIFSeekL(fp, nBlockSize, SEEK_CUR); } } /* -------------------------------------------------------------------- */ /* Create a corresponding GDALDataset. */ /* -------------------------------------------------------------------- */ HF2Dataset *poDS; poDS = new HF2Dataset(); poDS->fp = fp; poDS->nRasterXSize = nXSize; poDS->nRasterYSize = nYSize; poDS->nTileSize = nTileSize; CPLDebug("HF2", "nXSize = %d, nYSize = %d, nTileSize = %d", nXSize, nYSize, nTileSize); if (bHasExtent) { poDS->adfGeoTransform[0] = dfMinX; poDS->adfGeoTransform[3] = dfMaxY; poDS->adfGeoTransform[1] = (dfMaxX - dfMinX) / nXSize; poDS->adfGeoTransform[5] = -(dfMaxY - dfMinY) / nYSize; } else { poDS->adfGeoTransform[1] = fHorizScale; poDS->adfGeoTransform[5] = fHorizScale; } if (bHasEPSGCode) { OGRSpatialReference oSRS; if (oSRS.importFromEPSG(nEPSGCode) == OGRERR_NONE) oSRS.exportToWkt(&poDS->pszWKT); } else { int bHasSRS = FALSE; OGRSpatialReference oSRS; oSRS.SetGeogCS("unknown", "unknown", "unknown", SRS_WGS84_SEMIMAJOR, SRS_WGS84_INVFLATTENING); if (bHasEPSGDatumCode) { if (nEPSGDatumCode == 23 || nEPSGDatumCode == 6326) { bHasSRS = TRUE; oSRS.SetWellKnownGeogCS("WGS84"); } else if (nEPSGDatumCode >= 6000) { char szName[32]; sprintf( szName, "EPSG:%d", nEPSGDatumCode-2000 ); oSRS.SetWellKnownGeogCS( szName ); bHasSRS = TRUE; } } if (bHasUTMZone && ABS(nUTMZone) >= 1 && ABS(nUTMZone) <= 60) { bHasSRS = TRUE; oSRS.SetUTM(ABS(nUTMZone), nUTMZone > 0); } if (bHasSRS) oSRS.exportToWkt(&poDS->pszWKT); } /* -------------------------------------------------------------------- */ /* Create band information objects. */ /* -------------------------------------------------------------------- */ poDS->nBands = 1; int i; for( i = 0; i < poDS->nBands; i++ ) { poDS->SetBand( i+1, new HF2RasterBand( poDS, i+1, GDT_Float32 ) ); poDS->GetRasterBand(i+1)->SetUnitType("m"); } if (szApplicationName[0] != '\0') poDS->SetMetadataItem("APPLICATION_NAME", szApplicationName); poDS->SetMetadataItem("VERTICAL_PRECISION", CPLString().Printf("%f", fVertPres)); if (bHasRelativePrecision) poDS->SetMetadataItem("RELATIVE_VERTICAL_PRECISION", CPLString().Printf("%f", fRelativePrecision)); /* -------------------------------------------------------------------- */ /* Initialize any PAM information. */ /* -------------------------------------------------------------------- */ poDS->SetDescription( osOriginalFilename.c_str() ); poDS->TryLoadXML(); /* -------------------------------------------------------------------- */ /* Support overviews. */ /* -------------------------------------------------------------------- */ poDS->oOvManager.Initialize( poDS, osOriginalFilename.c_str() ); return( poDS ); }
GDALDataset *GS7BGDataset::Open( GDALOpenInfo * poOpenInfo ) { if( !Identify(poOpenInfo) ) { return NULL; } /* ------------------------------------------------------------------- */ /* Create a corresponding GDALDataset. */ /* ------------------------------------------------------------------- */ GS7BGDataset *poDS = new GS7BGDataset(); /* ------------------------------------------------------------------- */ /* Open file with large file API. */ /* ------------------------------------------------------------------- */ poDS->eAccess = poOpenInfo->eAccess; if( poOpenInfo->eAccess == GA_ReadOnly ) poDS->fp = VSIFOpenL( poOpenInfo->pszFilename, "rb" ); else poDS->fp = VSIFOpenL( poOpenInfo->pszFilename, "r+b" ); if( poDS->fp == NULL ) { delete poDS; CPLError( CE_Failure, CPLE_OpenFailed, "VSIFOpenL(%s) failed unexpectedly.", poOpenInfo->pszFilename ); return NULL; } /* ------------------------------------------------------------------- */ /* Read the header. The Header section must be the first section */ /* in the file. */ /* ------------------------------------------------------------------- */ if( VSIFSeekL( poDS->fp, 0, SEEK_SET ) != 0 ) { delete poDS; CPLError( CE_Failure, CPLE_FileIO, "Unable to seek to start of grid file header.\n" ); return NULL; } GInt32 nTag; if( VSIFReadL( (void *)&nTag, sizeof(GInt32), 1, poDS->fp ) != 1 ) { delete poDS; CPLError( CE_Failure, CPLE_FileIO, "Unable to read Tag.\n" ); return NULL; } CPL_LSBPTR32( &nTag ); if(nTag != nHEADER_TAG) { delete poDS; CPLError( CE_Failure, CPLE_FileIO, "Header tag not found.\n" ); return NULL; } GUInt32 nSize; if( VSIFReadL( (void *)&nSize, sizeof(GUInt32), 1, poDS->fp ) != 1 ) { delete poDS; CPLError( CE_Failure, CPLE_FileIO, "Unable to read file section size.\n" ); return NULL; } CPL_LSBPTR32( &nSize ); GInt32 nVersion; if( VSIFReadL( (void *)&nVersion, sizeof(GInt32), 1, poDS->fp ) != 1 ) { delete poDS; CPLError( CE_Failure, CPLE_FileIO, "Unable to read file version.\n" ); return NULL; } CPL_LSBPTR32( &nVersion ); if(nVersion != 1 && nVersion != 2) { delete poDS; CPLError( CE_Failure, CPLE_FileIO, "Incorrect file version (%d).", nVersion ); return NULL; } // advance until the grid tag is found while(nTag != nGRID_TAG) { if( VSIFReadL( (void *)&nTag, sizeof(GInt32), 1, poDS->fp ) != 1 ) { delete poDS; CPLError( CE_Failure, CPLE_FileIO, "Unable to read Tag.\n" ); return NULL; } CPL_LSBPTR32( &nTag ); if( VSIFReadL( (void *)&nSize, sizeof(GUInt32), 1, poDS->fp ) != 1 ) { delete poDS; CPLError( CE_Failure, CPLE_FileIO, "Unable to read file section size.\n" ); return NULL; } CPL_LSBPTR32( &nSize ); if(nTag != nGRID_TAG) { if( VSIFSeekL( poDS->fp, nSize, SEEK_CUR ) != 0 ) { delete poDS; CPLError( CE_Failure, CPLE_FileIO, "Unable to seek to end of file section.\n" ); return NULL; } } } /* --------------------------------------------------------------------*/ /* Read the grid. */ /* --------------------------------------------------------------------*/ /* Parse number of Y axis grid rows */ GInt32 nRows; if( VSIFReadL( (void *)&nRows, sizeof(GInt32), 1, poDS->fp ) != 1 ) { delete poDS; CPLError( CE_Failure, CPLE_FileIO, "Unable to read raster Y size.\n" ); return NULL; } CPL_LSBPTR32( &nRows ); poDS->nRasterYSize = nRows; /* Parse number of X axis grid columns */ GInt32 nCols; if( VSIFReadL( (void *)&nCols, sizeof(GInt32), 1, poDS->fp ) != 1 ) { delete poDS; CPLError( CE_Failure, CPLE_FileIO, "Unable to read raster X size.\n" ); return NULL; } CPL_LSBPTR32( &nCols ); poDS->nRasterXSize = nCols; if (!GDALCheckDatasetDimensions(poDS->nRasterXSize, poDS->nRasterYSize)) { delete poDS; return NULL; } /* --------------------------------------------------------------------*/ /* Create band information objects. */ /* --------------------------------------------------------------------*/ GS7BGRasterBand *poBand = new GS7BGRasterBand( poDS, 1 ); poDS->SetBand( 1, poBand ); // find the min X Value of the grid double dfTemp; if( VSIFReadL( (void *)&dfTemp, sizeof(double), 1, poDS->fp ) != 1 ) { delete poDS; CPLError( CE_Failure, CPLE_FileIO, "Unable to read minimum X value.\n" ); return NULL; } CPL_LSBPTR64( &dfTemp ); poBand->dfMinX = dfTemp; // find the min Y value of the grid if( VSIFReadL( (void *)&dfTemp, sizeof(double), 1, poDS->fp ) != 1 ) { delete poDS; CPLError( CE_Failure, CPLE_FileIO, "Unable to read minimum X value.\n" ); return NULL; } CPL_LSBPTR64( &dfTemp ); poBand->dfMinY = dfTemp; // find the spacing between adjacent nodes in the X direction // (between columns) if( VSIFReadL( (void *)&dfTemp, sizeof(double), 1, poDS->fp ) != 1 ) { delete poDS; CPLError( CE_Failure, CPLE_FileIO, "Unable to read spacing in X value.\n" ); return NULL; } CPL_LSBPTR64( &dfTemp ); poBand->dfMaxX = poBand->dfMinX + (dfTemp * (nCols - 1)); // find the spacing between adjacent nodes in the Y direction // (between rows) if( VSIFReadL( (void *)&dfTemp, sizeof(double), 1, poDS->fp ) != 1 ) { delete poDS; CPLError( CE_Failure, CPLE_FileIO, "Unable to read spacing in Y value.\n" ); return NULL; } CPL_LSBPTR64( &dfTemp ); poBand->dfMaxY = poBand->dfMinY + (dfTemp * (nRows - 1)); // set the z min if( VSIFReadL( (void *)&dfTemp, sizeof(double), 1, poDS->fp ) != 1 ) { delete poDS; CPLError( CE_Failure, CPLE_FileIO, "Unable to read Z min value.\n" ); return NULL; } CPL_LSBPTR64( &dfTemp ); poBand->dfMinZ = dfTemp; // set the z max if( VSIFReadL( (void *)&dfTemp, sizeof(double), 1, poDS->fp ) != 1 ) { delete poDS; CPLError( CE_Failure, CPLE_FileIO, "Unable to read Z max value.\n" ); return NULL; } CPL_LSBPTR64( &dfTemp ); poBand->dfMaxZ = dfTemp; // read and ignore the rotation value //(This is not used in the current version). if( VSIFReadL( (void *)&dfTemp, sizeof(double), 1, poDS->fp ) != 1 ) { delete poDS; CPLError( CE_Failure, CPLE_FileIO, "Unable to read rotation value.\n" ); return NULL; } // read and set the cell blank value if( VSIFReadL( (void *)&dfTemp, sizeof(double), 1, poDS->fp ) != 1 ) { delete poDS; CPLError( CE_Failure, CPLE_FileIO, "Unable to Blank value.\n" ); return NULL; } CPL_LSBPTR64( &dfTemp ); poDS->dfNoData_Value = dfTemp; /* --------------------------------------------------------------------*/ /* Set the current offset of the grid data. */ /* --------------------------------------------------------------------*/ if( VSIFReadL( (void *)&nTag, sizeof(GInt32), 1, poDS->fp ) != 1 ) { delete poDS; CPLError( CE_Failure, CPLE_FileIO, "Unable to read Tag.\n" ); return NULL; } CPL_LSBPTR32( &nTag ); if(nTag != nDATA_TAG) { delete poDS; CPLError( CE_Failure, CPLE_FileIO, "Data tag not found.\n" ); return NULL; } if( VSIFReadL( (void *)&nSize, sizeof(GInt32), 1, poDS->fp ) != 1 ) { delete poDS; CPLError( CE_Failure, CPLE_FileIO, "Unable to data section size.\n" ); return NULL; } poDS->nData_Position = (size_t) VSIFTellL(poDS->fp); /* --------------------------------------------------------------------*/ /* Initialize any PAM information. */ /* --------------------------------------------------------------------*/ poDS->SetDescription( poOpenInfo->pszFilename ); poDS->TryLoadXML(); /* -------------------------------------------------------------------- */ /* Check for external overviews. */ /* -------------------------------------------------------------------- */ poDS->oOvManager.Initialize( poDS, poOpenInfo->pszFilename, poOpenInfo->GetSiblingFiles() ); return poDS; }
GDALDataset *GSCDataset::Open( GDALOpenInfo * poOpenInfo ) { int nPixels, nLines, i, nRecordLen; /* -------------------------------------------------------------------- */ /* Does this plausible look like a GSC Geogrid file? */ /* -------------------------------------------------------------------- */ if( poOpenInfo->nHeaderBytes < 20 ) return NULL; if( poOpenInfo->pabyHeader[12] != 0x02 || poOpenInfo->pabyHeader[13] != 0x00 || poOpenInfo->pabyHeader[14] != 0x00 || poOpenInfo->pabyHeader[15] != 0x00 ) return NULL; nRecordLen = CPL_LSBWORD32(((GInt32 *) poOpenInfo->pabyHeader)[0]); nPixels = CPL_LSBWORD32(((GInt32 *) poOpenInfo->pabyHeader)[1]); nLines = CPL_LSBWORD32(((GInt32 *) poOpenInfo->pabyHeader)[2]); if( nPixels < 1 || nLines < 1 || nPixels > 100000 || nLines > 100000 ) return NULL; if( nRecordLen != nPixels * 4 ) return NULL; /* -------------------------------------------------------------------- */ /* Confirm the requested access is supported. */ /* -------------------------------------------------------------------- */ if( poOpenInfo->eAccess == GA_Update ) { CPLError( CE_Failure, CPLE_NotSupported, "The GSC driver does not support update access to existing" " datasets.\n" ); return NULL; } nRecordLen += 8; /* for record length markers */ /* -------------------------------------------------------------------- */ /* Create a corresponding GDALDataset. */ /* -------------------------------------------------------------------- */ GSCDataset *poDS; poDS = new GSCDataset(); poDS->nRasterXSize = nPixels; poDS->nRasterYSize = nLines; /* -------------------------------------------------------------------- */ /* Assume ownership of the file handled from the GDALOpenInfo. */ /* -------------------------------------------------------------------- */ poDS->fpImage = VSIFOpenL(poOpenInfo->pszFilename, "rb"); if (poDS->fpImage == NULL) { delete poDS; return NULL; } /* -------------------------------------------------------------------- */ /* Read the header information in the second record. */ /* -------------------------------------------------------------------- */ float afHeaderInfo[8]; if( VSIFSeekL( poDS->fpImage, nRecordLen + 12, SEEK_SET ) != 0 || VSIFReadL( afHeaderInfo, sizeof(float), 8, poDS->fpImage ) != 8 ) { CPLError( CE_Failure, CPLE_FileIO, "Failure reading second record of GSC file with %d record length.", nRecordLen ); delete poDS; return NULL; } for( i = 0; i < 8; i++ ) { CPL_LSBPTR32( afHeaderInfo + i ); } poDS->adfGeoTransform[0] = afHeaderInfo[2]; poDS->adfGeoTransform[1] = afHeaderInfo[0]; poDS->adfGeoTransform[2] = 0.0; poDS->adfGeoTransform[3] = afHeaderInfo[5]; poDS->adfGeoTransform[4] = 0.0; poDS->adfGeoTransform[5] = -afHeaderInfo[1]; /* -------------------------------------------------------------------- */ /* Create band information objects. */ /* -------------------------------------------------------------------- */ RawRasterBand *poBand; #ifdef CPL_LSB int bNative = TRUE; #else int bNative = FALSE; #endif poBand = new RawRasterBand( poDS, 1, poDS->fpImage, nRecordLen * 2 + 4, sizeof(float), nRecordLen, GDT_Float32, bNative, TRUE ); poDS->SetBand( 1, poBand ); poBand->SetNoDataValue( -1.0000000150474662199e+30 ); /* -------------------------------------------------------------------- */ /* Initialize any PAM information. */ /* -------------------------------------------------------------------- */ poDS->SetDescription( poOpenInfo->pszFilename ); poDS->TryLoadXML(); /* -------------------------------------------------------------------- */ /* Check for overviews. */ /* -------------------------------------------------------------------- */ poDS->oOvManager.Initialize( poDS, poOpenInfo->pszFilename ); return( poDS ); }
OGRErr OGRCreateFromGeomedia( GByte *pabyGeom, OGRGeometry **ppoGeom, int nBytes ) { *ppoGeom = NULL; if( nBytes < 16 ) return OGRERR_FAILURE; if( !(pabyGeom[1] == 0xFF && pabyGeom[2] == 0xD2 && pabyGeom[3] == 0x0F) ) return OGRERR_FAILURE; int nGeomType = pabyGeom[0]; pabyGeom += 16; nBytes -= 16; if( nGeomType == GEOMEDIA_POINT || nGeomType == GEOMEDIA_ORIENTED_POINT ) { if (nBytes < 3 * 8) return OGRERR_FAILURE; double dfX, dfY, dfZ; memcpy(&dfX, pabyGeom, 8); CPL_LSBPTR64(&dfX); memcpy(&dfY, pabyGeom + 8, 8); CPL_LSBPTR64(&dfY); memcpy(&dfZ, pabyGeom + 16, 8); CPL_LSBPTR64(&dfZ); *ppoGeom = new OGRPoint( dfX, dfY, dfZ ); return OGRERR_NONE; } else if ( nGeomType == GEOMEDIA_POLYLINE ) { if (nBytes < 4) return OGRERR_FAILURE; int nPoints; memcpy(&nPoints, pabyGeom, 4); CPL_LSBPTR32(&nPoints); pabyGeom += 4; nBytes -= 4; if (nPoints < 0 || nPoints > INT_MAX / 24 || nBytes < nPoints * 24) return OGRERR_FAILURE; OGRLineString* poLS = new OGRLineString(); poLS->setNumPoints(nPoints); int i; for(i=0;i<nPoints;i++) { double dfX, dfY, dfZ; memcpy(&dfX, pabyGeom, 8); CPL_LSBPTR64(&dfX); memcpy(&dfY, pabyGeom + 8, 8); CPL_LSBPTR64(&dfY); memcpy(&dfZ, pabyGeom + 16, 8); CPL_LSBPTR64(&dfZ); poLS->setPoint(i, dfX, dfY, dfZ); pabyGeom += 24; } *ppoGeom = poLS; return OGRERR_NONE; } else if ( nGeomType == GEOMEDIA_POLYGON ) { if (nBytes < 4) return OGRERR_FAILURE; int nPoints; memcpy(&nPoints, pabyGeom, 4); CPL_LSBPTR32(&nPoints); pabyGeom += 4; nBytes -= 4; if (nPoints < 0 || nPoints > INT_MAX / 24 || nBytes < nPoints * 24) return OGRERR_FAILURE; OGRLinearRing* poRing = new OGRLinearRing(); poRing->setNumPoints(nPoints); int i; for(i=0;i<nPoints;i++) { double dfX, dfY, dfZ; memcpy(&dfX, pabyGeom, 8); CPL_LSBPTR64(&dfX); memcpy(&dfY, pabyGeom + 8, 8); CPL_LSBPTR64(&dfY); memcpy(&dfZ, pabyGeom + 16, 8); CPL_LSBPTR64(&dfZ); poRing->setPoint(i, dfX, dfY, dfZ); pabyGeom += 24; } OGRPolygon* poPoly = new OGRPolygon(); poPoly->addRingDirectly(poRing); *ppoGeom = poPoly; return OGRERR_NONE; } else if ( nGeomType == GEOMEDIA_BOUNDARY ) { if (nBytes < 4) return OGRERR_FAILURE; int nExteriorSize; memcpy(&nExteriorSize, pabyGeom, 4); CPL_LSBPTR32(&nExteriorSize); pabyGeom += 4; nBytes -= 4; if (nBytes < nExteriorSize) return OGRERR_FAILURE; OGRGeometry* poExteriorGeom = NULL; if (OGRCreateFromGeomedia( pabyGeom, &poExteriorGeom, nExteriorSize ) != OGRERR_NONE) return OGRERR_FAILURE; if ( wkbFlatten( poExteriorGeom->getGeometryType() ) != wkbPolygon ) { delete poExteriorGeom; return OGRERR_FAILURE; } pabyGeom += nExteriorSize; nBytes -= nExteriorSize; if (nBytes < 4) { delete poExteriorGeom; return OGRERR_FAILURE; } int nInteriorSize; memcpy(&nInteriorSize, pabyGeom, 4); CPL_LSBPTR32(&nInteriorSize); pabyGeom += 4; nBytes -= 4; if (nBytes < nInteriorSize) { delete poExteriorGeom; return OGRERR_FAILURE; } OGRGeometry* poInteriorGeom = NULL; if (OGRCreateFromGeomedia( pabyGeom, &poInteriorGeom, nInteriorSize ) != OGRERR_NONE) { delete poExteriorGeom; return OGRERR_FAILURE; } OGRwkbGeometryType interiorGeomType = wkbFlatten( poInteriorGeom->getGeometryType() ); if ( interiorGeomType == wkbPolygon ) { ((OGRPolygon*)poExteriorGeom)->addRing(((OGRPolygon*)poInteriorGeom)->getExteriorRing()); } else if ( interiorGeomType == wkbMultiPolygon ) { int numGeom = ((OGRMultiPolygon*)poInteriorGeom)->getNumGeometries(); for ( int i = 0; i < numGeom; ++i ) { OGRPolygon* poInteriorPolygon = (OGRPolygon*)((OGRMultiPolygon*)poInteriorGeom)->getGeometryRef(i); ((OGRPolygon*)poExteriorGeom)->addRing( poInteriorPolygon->getExteriorRing() ); } } else { delete poExteriorGeom; delete poInteriorGeom; return OGRERR_FAILURE; } delete poInteriorGeom; *ppoGeom = poExteriorGeom; return OGRERR_NONE; } else if ( nGeomType == GEOMEDIA_COLLECTION || nGeomType == GEOMEDIA_MULTILINE || nGeomType == GEOMEDIA_MULTIPOLYGON ) { if (nBytes < 4) return OGRERR_FAILURE; int i; int nParts; memcpy(&nParts, pabyGeom, 4); CPL_LSBPTR32(&nParts); pabyGeom += 4; nBytes -= 4; if (nParts < 0 || nParts > INT_MAX / (4 + 16) || nBytes < nParts * (4 + 16)) return OGRERR_FAILURE; /* Can this collection be considered as a multipolyline or multipolygon ? */ if ( nGeomType == GEOMEDIA_COLLECTION ) { GByte* pabyGeomBackup = pabyGeom; int nBytesBackup = nBytes; int bAllPolyline = TRUE; int bAllPolygon = TRUE; for(i=0;i<nParts;i++) { if (nBytes < 4) return OGRERR_FAILURE; int nSubBytes; memcpy(&nSubBytes, pabyGeom, 4); CPL_LSBPTR32(&nSubBytes); if (nSubBytes < 0) { return OGRERR_FAILURE; } pabyGeom += 4; nBytes -= 4; if (nBytes < nSubBytes) { return OGRERR_FAILURE; } if( nSubBytes < 16 ) return OGRERR_FAILURE; if( !(pabyGeom[1] == 0xFF && pabyGeom[2] == 0xD2 && pabyGeom[3] == 0x0F) ) return OGRERR_FAILURE; int nSubGeomType = pabyGeom[0]; if ( nSubGeomType != GEOMEDIA_POLYLINE ) bAllPolyline = FALSE; if ( nSubGeomType != GEOMEDIA_POLYGON ) bAllPolygon = FALSE; pabyGeom += nSubBytes; nBytes -= nSubBytes; } pabyGeom = pabyGeomBackup; nBytes = nBytesBackup; if (bAllPolyline) nGeomType = GEOMEDIA_MULTILINE; else if (bAllPolygon) nGeomType = GEOMEDIA_MULTIPOLYGON; } OGRGeometryCollection* poColl = (nGeomType == GEOMEDIA_MULTILINE) ? new OGRMultiLineString() : (nGeomType == GEOMEDIA_MULTIPOLYGON) ? new OGRMultiPolygon() : new OGRGeometryCollection(); for(i=0;i<nParts;i++) { if (nBytes < 4) return OGRERR_FAILURE; int nSubBytes; memcpy(&nSubBytes, pabyGeom, 4); CPL_LSBPTR32(&nSubBytes); if (nSubBytes < 0) { delete poColl; return OGRERR_FAILURE; } pabyGeom += 4; nBytes -= 4; if (nBytes < nSubBytes) { delete poColl; return OGRERR_FAILURE; } OGRGeometry* poSubGeom = NULL; if (OGRCreateFromGeomedia( pabyGeom, &poSubGeom, nSubBytes ) == OGRERR_NONE) { if (wkbFlatten(poColl->getGeometryType()) == wkbMultiPolygon && wkbFlatten(poSubGeom->getGeometryType()) == wkbLineString) { OGRPolygon* poPoly = new OGRPolygon(); OGRLinearRing* poRing = new OGRLinearRing(); poRing->addSubLineString((OGRLineString*)poSubGeom); poPoly->addRingDirectly(poRing); delete poSubGeom; poSubGeom = poPoly; } if (poColl->addGeometryDirectly(poSubGeom) != OGRERR_NONE) { //printf("%d %d\n", poColl->getGeometryType() & ~wkb25DBit, poSubGeom->getGeometryType() & ~wkb25DBit); delete poSubGeom; } } pabyGeom += nSubBytes; nBytes -= nSubBytes; } *ppoGeom = poColl; return OGRERR_NONE; } else { CPLDebug("GEOMEDIA", "Unhandled type %d", nGeomType); } return OGRERR_FAILURE; }
bool LevellerDataset::write(size_t n) { CPL_LSBPTR32(&n); return (1 == VSIFWriteL(&n, sizeof(n), 1, m_fp)); }
bool TerragenDataset::put(float f) { CPL_LSBPTR32(&f); return( 1 == VSIFWriteL(&f, sizeof(f), 1, m_fp) ); }
GDALDataset *BTDataset::Create( const char * pszFilename, int nXSize, int nYSize, int nBands, GDALDataType eType, CPL_UNUSED char ** papszOptions ) { /* -------------------------------------------------------------------- */ /* Verify input options. */ /* -------------------------------------------------------------------- */ if( eType != GDT_Int16 && eType != GDT_Int32 && eType != GDT_Float32 ) { CPLError( CE_Failure, CPLE_AppDefined, "Attempt to create .bt dataset with an illegal " "data type (%s), only Int16, Int32 and Float32 supported.", GDALGetDataTypeName(eType) ); return NULL; } if( nBands != 1 ) { CPLError( CE_Failure, CPLE_AppDefined, "Attempt to create .bt dataset with %d bands, only 1 supported", nBands ); return NULL; } /* -------------------------------------------------------------------- */ /* Try to create the file. */ /* -------------------------------------------------------------------- */ VSILFILE *fp = VSIFOpenL( pszFilename, "wb" ); if( fp == NULL ) { CPLError( CE_Failure, CPLE_OpenFailed, "Attempt to create file `%s' failed.", pszFilename ); return NULL; } /* -------------------------------------------------------------------- */ /* Setup base header. */ /* -------------------------------------------------------------------- */ unsigned char abyHeader[256] = {}; memcpy( abyHeader, "binterr1.3", 10 ); GInt32 nTemp = CPL_LSBWORD32( nXSize ); memcpy( abyHeader+10, &nTemp, 4 ); nTemp = CPL_LSBWORD32( nYSize ); memcpy( abyHeader+14, &nTemp, 4 ); GInt16 nShortTemp = static_cast<GInt16>( CPL_LSBWORD16( (GInt16)(GDALGetDataTypeSize( eType ) / 8 )) ); memcpy( abyHeader + 18, &nShortTemp, 2 ); if( eType == GDT_Float32 ) abyHeader[20] = 1; else abyHeader[20] = 0; nShortTemp = CPL_LSBWORD16( 1 ); /* meters */ memcpy( abyHeader + 22, &nShortTemp, 2 ); nShortTemp = CPL_LSBWORD16( 0 ); /* not utm */ memcpy( abyHeader + 24, &nShortTemp, 2 ); nShortTemp = CPL_LSBWORD16( -2 ); /* datum unknown */ memcpy( abyHeader + 26, &nShortTemp, 2 ); /* -------------------------------------------------------------------- */ /* Set dummy extents. */ /* -------------------------------------------------------------------- */ double dfLeft = 0.0; double dfRight = nXSize; double dfTop = nYSize; double dfBottom = 0.0; memcpy( abyHeader + 28, &dfLeft, 8 ); memcpy( abyHeader + 36, &dfRight, 8 ); memcpy( abyHeader + 44, &dfBottom, 8 ); memcpy( abyHeader + 52, &dfTop, 8 ); CPL_LSBPTR64( abyHeader + 28 ); CPL_LSBPTR64( abyHeader + 36 ); CPL_LSBPTR64( abyHeader + 44 ); CPL_LSBPTR64( abyHeader + 52 ); /* -------------------------------------------------------------------- */ /* Set dummy scale. */ /* -------------------------------------------------------------------- */ float fScale = 1.0; memcpy( abyHeader + 62, &fScale, 4 ); CPL_LSBPTR32( abyHeader + 62 ); /* -------------------------------------------------------------------- */ /* Write to disk. */ /* -------------------------------------------------------------------- */ if( VSIFWriteL( (void *) abyHeader, 256, 1, fp ) != 1 || VSIFSeekL( fp, (GDALGetDataTypeSize(eType)/8) * nXSize * (vsi_l_offset)nYSize - 1, SEEK_CUR ) != 0 || VSIFWriteL( abyHeader+255, 1, 1, fp ) != 1 ) { CPLError( CE_Failure, CPLE_FileIO, "Failed to extent file to its full size, out of disk space?" ); CPL_IGNORE_RET_VAL(VSIFCloseL( fp )); VSIUnlink( pszFilename ); return NULL; } if( VSIFCloseL( fp ) != 0 ) { CPLError( CE_Failure, CPLE_FileIO, "Failed to extent file to its full size, out of disk space?" ); VSIUnlink( pszFilename ); return NULL; } return (GDALDataset *) GDALOpen( pszFilename, GA_Update ); }
GDALDataset *BTDataset::Open( GDALOpenInfo * poOpenInfo ) { /* -------------------------------------------------------------------- */ /* Verify that this is some form of binterr file. */ /* -------------------------------------------------------------------- */ if( poOpenInfo->nHeaderBytes < 256) return NULL; if( !STARTS_WITH((const char *) poOpenInfo->pabyHeader, "binterr") ) return NULL; /* -------------------------------------------------------------------- */ /* Create the dataset. */ /* -------------------------------------------------------------------- */ BTDataset *poDS = new BTDataset(); memcpy( poDS->abyHeader, poOpenInfo->pabyHeader, 256 ); /* -------------------------------------------------------------------- */ /* Get the version. */ /* -------------------------------------------------------------------- */ char szVersion[4] = {}; strncpy( szVersion, (char *) (poDS->abyHeader + 7), 3 ); szVersion[3] = '\0'; poDS->nVersionCode = static_cast<int>(CPLAtof(szVersion) * 10); /* -------------------------------------------------------------------- */ /* Extract core header information, being careful about the */ /* version. */ /* -------------------------------------------------------------------- */ GInt32 nIntTemp = 0; memcpy( &nIntTemp, poDS->abyHeader + 10, 4 ); poDS->nRasterXSize = CPL_LSBWORD32( nIntTemp ); memcpy( &nIntTemp, poDS->abyHeader + 14, 4 ); poDS->nRasterYSize = CPL_LSBWORD32( nIntTemp ); if( !GDALCheckDatasetDimensions(poDS->nRasterXSize, poDS->nRasterYSize) ) { delete poDS; return NULL; } GInt16 nDataSize = 0; memcpy( &nDataSize, poDS->abyHeader+18, 2 ); nDataSize = CPL_LSBWORD16( nDataSize ); GDALDataType eType = GDT_Unknown; if( poDS->abyHeader[20] != 0 && nDataSize == 4 ) eType = GDT_Float32; else if( poDS->abyHeader[20] == 0 && nDataSize == 4 ) eType = GDT_Int32; else if( poDS->abyHeader[20] == 0 && nDataSize == 2 ) eType = GDT_Int16; else { CPLError( CE_Failure, CPLE_AppDefined, ".bt file data type unknown, got datasize=%d.", nDataSize ); delete poDS; return NULL; } /* rcg, apr 7/06: read offset 62 for vert. units. If zero, assume 1.0 as per spec. */ memcpy( &poDS->m_fVscale, poDS->abyHeader + 62, 4 ); CPL_LSBPTR32(&poDS->m_fVscale); if(poDS->m_fVscale == 0.0f) poDS->m_fVscale = 1.0f; /* -------------------------------------------------------------------- */ /* Try to read a .prj file if it is indicated. */ /* -------------------------------------------------------------------- */ OGRSpatialReference oSRS; if( poDS->nVersionCode >= 12 && poDS->abyHeader[60] != 0 ) { const char *pszPrjFile = CPLResetExtension( poOpenInfo->pszFilename, "prj" ); VSILFILE *fp = VSIFOpenL( pszPrjFile, "rt" ); if( fp != NULL ) { const int nBufMax = 10000; char *pszBuffer = static_cast<char *>(CPLMalloc(nBufMax)); const int nBytes = static_cast<int>(VSIFReadL( pszBuffer, 1, nBufMax-1, fp )); CPL_IGNORE_RET_VAL(VSIFCloseL( fp )); pszBuffer[nBytes] = '\0'; char *pszBufPtr = pszBuffer; if( oSRS.importFromWkt( &pszBufPtr ) != OGRERR_NONE ) { CPLError( CE_Warning, CPLE_AppDefined, "Unable to parse .prj file, " "coordinate system missing." ); } CPLFree( pszBuffer ); } } /* -------------------------------------------------------------------- */ /* If we didn't find a .prj file, try to use internal info. */ /* -------------------------------------------------------------------- */ if( oSRS.GetRoot() == NULL ) { GInt16 nUTMZone = 0; memcpy( &nUTMZone, poDS->abyHeader + 24, 2 ); nUTMZone = CPL_LSBWORD16( nUTMZone ); GInt16 nDatum = 0; memcpy( &nDatum, poDS->abyHeader + 26, 2 ); nDatum = CPL_LSBWORD16( nDatum ); GInt16 nHUnits = 0; memcpy( &nHUnits, poDS->abyHeader + 22, 2 ); nHUnits = CPL_LSBWORD16( nHUnits ); if( nUTMZone != 0 ) oSRS.SetUTM( std::abs(static_cast<int>(nUTMZone)), nUTMZone > 0 ); else if( nHUnits != 0 ) oSRS.SetLocalCS( "Unknown" ); if( nHUnits == 1 ) oSRS.SetLinearUnits( SRS_UL_METER, 1.0 ); else if( nHUnits == 2 ) oSRS.SetLinearUnits( SRS_UL_FOOT, CPLAtof(SRS_UL_FOOT_CONV) ); else if( nHUnits == 3 ) oSRS.SetLinearUnits( SRS_UL_US_FOOT, CPLAtof(SRS_UL_US_FOOT_CONV) ); // Translate some of the more obvious old USGS datum codes if( nDatum == 0 ) nDatum = 6201; else if( nDatum == 1 ) nDatum = 6209; else if( nDatum == 2 ) nDatum = 6210; else if( nDatum == 3 ) nDatum = 6202; else if( nDatum == 4 ) nDatum = 6203; else if( nDatum == 6 ) nDatum = 6222; else if( nDatum == 7 ) nDatum = 6230; else if( nDatum == 13 ) nDatum = 6267; else if( nDatum == 14 ) nDatum = 6269; else if( nDatum == 17 ) nDatum = 6277; else if( nDatum == 19 ) nDatum = 6284; else if( nDatum == 21 ) nDatum = 6301; else if( nDatum == 22 ) nDatum = 6322; else if( nDatum == 23 ) nDatum = 6326; if( !oSRS.IsLocal() ) { if( nDatum >= 6000 ) { char szName[32]; snprintf( szName, sizeof(szName), "EPSG:%d", nDatum-2000 ); oSRS.SetWellKnownGeogCS( szName ); } else oSRS.SetWellKnownGeogCS( "WGS84" ); } } /* -------------------------------------------------------------------- */ /* Convert coordinate system back to WKT. */ /* -------------------------------------------------------------------- */ if( oSRS.GetRoot() != NULL ) oSRS.exportToWkt( &poDS->pszProjection ); /* -------------------------------------------------------------------- */ /* Get georeferencing bounds. */ /* -------------------------------------------------------------------- */ if( poDS->nVersionCode >= 11 ) { double dfLeft = 0.0; memcpy( &dfLeft, poDS->abyHeader + 28, 8 ); CPL_LSBPTR64( &dfLeft ); double dfRight = 0.0; memcpy( &dfRight, poDS->abyHeader + 36, 8 ); CPL_LSBPTR64( &dfRight ); double dfBottom = 0.0; memcpy( &dfBottom, poDS->abyHeader + 44, 8 ); CPL_LSBPTR64( &dfBottom ); double dfTop = 0.0; memcpy( &dfTop, poDS->abyHeader + 52, 8 ); CPL_LSBPTR64( &dfTop ); poDS->adfGeoTransform[0] = dfLeft; poDS->adfGeoTransform[1] = (dfRight - dfLeft) / poDS->nRasterXSize; poDS->adfGeoTransform[2] = 0.0; poDS->adfGeoTransform[3] = dfTop; poDS->adfGeoTransform[4] = 0.0; poDS->adfGeoTransform[5] = (dfBottom - dfTop) / poDS->nRasterYSize; poDS->bGeoTransformValid = TRUE; } /* -------------------------------------------------------------------- */ /* Re-open the file with the desired access. */ /* -------------------------------------------------------------------- */ if( poOpenInfo->eAccess == GA_Update ) poDS->fpImage = VSIFOpenL( poOpenInfo->pszFilename, "rb+" ); else poDS->fpImage = VSIFOpenL( poOpenInfo->pszFilename, "rb" ); if( poDS->fpImage == NULL ) { CPLError( CE_Failure, CPLE_OpenFailed, "Failed to re-open %s within BT driver.\n", poOpenInfo->pszFilename ); delete poDS; return NULL; } poDS->eAccess = poOpenInfo->eAccess; /* -------------------------------------------------------------------- */ /* Create band information objects */ /* -------------------------------------------------------------------- */ poDS->SetBand( 1, new BTRasterBand( poDS, poDS->fpImage, eType ) ); #ifdef notdef poDS->bGeoTransformValid = GDALReadWorldFile( poOpenInfo->pszFilename, ".wld", poDS->adfGeoTransform ); #endif /* -------------------------------------------------------------------- */ /* Initialize any PAM information. */ /* -------------------------------------------------------------------- */ poDS->SetDescription( poOpenInfo->pszFilename ); poDS->TryLoadXML(); /* -------------------------------------------------------------------- */ /* Check for overviews. */ /* -------------------------------------------------------------------- */ poDS->oOvManager.Initialize( poDS, poOpenInfo->pszFilename ); return poDS; }