NITFDES *NITFDESAccess( NITFFile *psFile, int iSegment )
{
NITFDES *psDES;
char *pachHeader;
NITFSegmentInfo *psSegInfo;
char szDESID[26];
char szTemp[128];
int nOffset;
int bHasDESOFLW;
int nDESSHL;
/* -------------------------------------------------------------------- */
/* Verify segment, and return existing DES accessor if there */
/* is one. */
/* -------------------------------------------------------------------- */
if( iSegment < 0 || iSegment >= psFile->nSegmentCount )
return NULL;
psSegInfo = psFile->pasSegmentInfo + iSegment;
if( !EQUAL(psSegInfo->szSegmentType,"DE") )
return NULL;
if( psSegInfo->hAccess != NULL )
return (NITFDES *) psSegInfo->hAccess;
/* -------------------------------------------------------------------- */
/* Read the DES subheader. */
/* -------------------------------------------------------------------- */
if (psSegInfo->nSegmentHeaderSize < 200)
{
CPLError(CE_Failure, CPLE_AppDefined,
"DES header too small");
return NULL;
}
pachHeader = (char*) VSIMalloc(psSegInfo->nSegmentHeaderSize);
if (pachHeader == NULL)
{
CPLError(CE_Failure, CPLE_OutOfMemory,
"Cannot allocate memory for segment header");
return NULL;
}
retry:
if( VSIFSeekL( psFile->fp, psSegInfo->nSegmentHeaderStart,
SEEK_SET ) != 0
|| VSIFReadL( pachHeader, 1, psSegInfo->nSegmentHeaderSize,
psFile->fp ) != psSegInfo->nSegmentHeaderSize )
{
CPLError( CE_Failure, CPLE_FileIO,
"Failed to read %u byte DES subheader from " CPL_FRMT_GUIB ".",
psSegInfo->nSegmentHeaderSize,
psSegInfo->nSegmentHeaderStart );
CPLFree(pachHeader);
return NULL;
}
if (!EQUALN(pachHeader, "DE", 2))
{
if (EQUALN(pachHeader + 4, "DERegistered", 12))
{
/* BAO_46_Ed1/rpf/conc/concz10/000fz010.ona and cie are buggy */
CPLDebug("NITF", "Patching nSegmentHeaderStart and nSegmentStart for DE segment %d", iSegment);
psSegInfo->nSegmentHeaderStart += 4;
psSegInfo->nSegmentStart += 4;
goto retry;
}
CPLError(CE_Failure, CPLE_AppDefined,
"Invalid segment prefix for DE segment %d", iSegment);
CPLFree(pachHeader);
return NULL;
}
/* -------------------------------------------------------------------- */
/* Initialize DES object. */
/* -------------------------------------------------------------------- */
psDES = (NITFDES *) CPLCalloc(sizeof(NITFDES),1);
psDES->psFile = psFile;
psDES->iSegment = iSegment;
psDES->pachHeader = pachHeader;
psSegInfo->hAccess = psDES;
/* -------------------------------------------------------------------- */
/* Collect a variety of information as metadata. */
/* -------------------------------------------------------------------- */
#define GetMD( length, name ) \
do { NITFExtractMetadata( &(psDES->papszMetadata), pachHeader, \
nOffset, length, \
"NITF_" #name ); \
nOffset += length; } while(0)
nOffset = 2;
GetMD( 25, DESID );
GetMD( 2, DESVER );
GetMD( 1, DECLAS );
GetMD( 2, DESCLSY );
GetMD( 11, DESCODE );
GetMD( 2, DESCTLH );
GetMD( 20, DESREL );
GetMD( 2, DESDCTP );
GetMD( 8, DESDCDT );
GetMD( 4, DESDCXM );
GetMD( 1, DESDG );
GetMD( 8, DESDGDT );
GetMD( 43, DESCLTX );
GetMD( 1, DESCATP );
GetMD( 40, DESCAUT );
GetMD( 1, DESCRSN );
GetMD( 8, DESSRDT );
GetMD( 15, DESCTLN );
/* Load DESID */
NITFGetField( szDESID, pachHeader, 2, 25);
/* For NITF < 02.10, we cannot rely on DESID=TRE_OVERFLOW to detect */
/* if DESOFLW and DESITEM are present. So if the next 4 bytes are non */
/* numeric, we'll assume that DESOFLW is there */
bHasDESOFLW = EQUALN(szDESID, "TRE_OVERFLOW", strlen("TRE_OVERFLOW")) ||
(!((pachHeader[nOffset+0] >= '0' && pachHeader[nOffset+0] <= '9') &&
(pachHeader[nOffset+1] >= '0' && pachHeader[nOffset+1] <= '9') &&
(pachHeader[nOffset+2] >= '0' && pachHeader[nOffset+2] <= '9') &&
(pachHeader[nOffset+3] >= '0' && pachHeader[nOffset+3] <= '9')));
if (bHasDESOFLW)
{
if ((int)psSegInfo->nSegmentHeaderSize < nOffset + 6 + 3 )
{
CPLError(CE_Failure, CPLE_AppDefined,
"DES header too small");
NITFDESDeaccess(psDES);
return NULL;
}
GetMD( 6, DESOFLW );
GetMD( 3, DESITEM );
}
if ((int)psSegInfo->nSegmentHeaderSize < nOffset + 4 )
{
CPLError(CE_Failure, CPLE_AppDefined,
"DES header too small");
NITFDESDeaccess(psDES);
return NULL;
}
nDESSHL = atoi(NITFGetField( szTemp, pachHeader, nOffset, 4));
nOffset += 4;
if (nDESSHL < 0)
{
CPLError(CE_Failure, CPLE_AppDefined,
"Invalid value for DESSHL");
NITFDESDeaccess(psDES);
return NULL;
}
if ( (int)psSegInfo->nSegmentHeaderSize < nOffset + nDESSHL)
{
CPLError(CE_Failure, CPLE_AppDefined,
"DES header too small");
NITFDESDeaccess(psDES);
return NULL;
}
if (EQUALN(szDESID, "CSSHPA DES", strlen("CSSHPA DES")))
{
if ( nDESSHL != 62 && nDESSHL != 80)
{
CPLError(CE_Failure, CPLE_AppDefined,
"Invalid DESSHL for CSSHPA DES");
NITFDESDeaccess(psDES);
return NULL;
}
GetMD( 25, SHAPE_USE );
GetMD( 10, SHAPE_CLASS );
if (nDESSHL == 80)
GetMD( 18, CC_SOURCE );
GetMD( 3, SHAPE1_NAME );
GetMD( 6, SHAPE1_START );
GetMD( 3, SHAPE2_NAME );
GetMD( 6, SHAPE2_START );
GetMD( 3, SHAPE3_NAME );
GetMD( 6, SHAPE3_START );
}
else if (nDESSHL > 0)
GetMD( nDESSHL, DESSHF );
if ((int)psSegInfo->nSegmentHeaderSize > nOffset)
{
char* pszEscapedDESDATA =
CPLEscapeString( pachHeader + nOffset,
(int)psSegInfo->nSegmentHeaderSize - nOffset,
CPLES_BackslashQuotable );
psDES->papszMetadata = CSLSetNameValue( psDES->papszMetadata,
"NITF_DESDATA",
pszEscapedDESDATA );
CPLFree(pszEscapedDESDATA);
}
return psDES;
}
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;
}
}
}
int GDALJP2Box::ReadBox()
{
GUInt32 nLBox;
GUInt32 nTBox;
nBoxOffset = VSIFTellL( fpVSIL );
if( VSIFReadL( &nLBox, 4, 1, fpVSIL ) != 1
|| VSIFReadL( &nTBox, 4, 1, fpVSIL ) != 1 )
{
return FALSE;
}
memcpy( szBoxType, &nTBox, 4 );
szBoxType[4] = '\0';
nLBox = CPL_MSBWORD32( nLBox );
if( nLBox != 1 )
{
nBoxLength = nLBox;
nDataOffset = nBoxOffset + 8;
}
else
{
GByte abyXLBox[8];
if( VSIFReadL( abyXLBox, 8, 1, fpVSIL ) != 1 )
return FALSE;
if( sizeof(nBoxLength) == 8 )
{
CPL_MSBPTR64( abyXLBox );
memcpy( &nBoxLength, abyXLBox, 8 );
}
else
{
CPL_MSBPTR32( abyXLBox+4 );
memcpy( &nBoxLength, abyXLBox+4, 4 );
}
nDataOffset = nBoxOffset + 16;
}
if( nBoxLength == 0 )
{
VSIFSeekL( fpVSIL, 0, SEEK_END );
nBoxLength = VSIFTellL( fpVSIL ) - nBoxOffset;
VSIFSeekL( fpVSIL, nDataOffset, SEEK_SET );
}
if( EQUAL(szBoxType,"uuid") )
{
if( VSIFReadL( abyUUID, 16, 1, fpVSIL ) != 1 )
return FALSE;
nDataOffset += 16;
}
if( GetDataLength() < 0 )
{
CPLDebug("GDALJP2", "Invalid length for box %s", szBoxType);
return FALSE;
}
return TRUE;
}
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 *GTXDataset::Open( GDALOpenInfo * poOpenInfo )
{
if( !Identify( poOpenInfo ) )
return NULL;
/* -------------------------------------------------------------------- */
/* Create a corresponding GDALDataset. */
/* -------------------------------------------------------------------- */
GTXDataset *poDS = new GTXDataset();
poDS->eAccess = poOpenInfo->eAccess;
/* -------------------------------------------------------------------- */
/* Open the file. */
/* -------------------------------------------------------------------- */
if( poOpenInfo->eAccess == GA_ReadOnly )
poDS->fpImage = VSIFOpenL( poOpenInfo->pszFilename, "rb" );
else
poDS->fpImage = VSIFOpenL( poOpenInfo->pszFilename, "rb+" );
if( poDS->fpImage == NULL )
{
delete poDS;
return NULL;
}
/* -------------------------------------------------------------------- */
/* Read the header. */
/* -------------------------------------------------------------------- */
poDS->adfGeoTransform[2] = 0.0;
poDS->adfGeoTransform[4] = 0.0;
CPL_IGNORE_RET_VAL(VSIFReadL( poDS->adfGeoTransform+3, 8, 1,
poDS->fpImage ));
CPL_IGNORE_RET_VAL(VSIFReadL( poDS->adfGeoTransform+0, 8, 1,
poDS->fpImage ));
CPL_IGNORE_RET_VAL(VSIFReadL( poDS->adfGeoTransform+5, 8, 1,
poDS->fpImage ));
CPL_IGNORE_RET_VAL(VSIFReadL( poDS->adfGeoTransform+1, 8, 1,
poDS->fpImage ));
CPL_IGNORE_RET_VAL(VSIFReadL( &(poDS->nRasterYSize), 4, 1, poDS->fpImage ));
CPL_IGNORE_RET_VAL(VSIFReadL( &(poDS->nRasterXSize), 4, 1, poDS->fpImage ));
CPL_MSBPTR32( &(poDS->nRasterYSize) );
CPL_MSBPTR32( &(poDS->nRasterXSize) );
CPL_MSBPTR64( poDS->adfGeoTransform + 0 );
CPL_MSBPTR64( poDS->adfGeoTransform + 1 );
CPL_MSBPTR64( poDS->adfGeoTransform + 3 );
CPL_MSBPTR64( poDS->adfGeoTransform + 5 );
poDS->adfGeoTransform[3] +=
poDS->adfGeoTransform[5] * (poDS->nRasterYSize-1);
poDS->adfGeoTransform[0] -= poDS->adfGeoTransform[1] * 0.5;
poDS->adfGeoTransform[3] += poDS->adfGeoTransform[5] * 0.5;
poDS->adfGeoTransform[5] *= -1;
if (!GDALCheckDatasetDimensions(poDS->nRasterXSize, poDS->nRasterYSize))
{
delete poDS;
return NULL;
}
/* -------------------------------------------------------------------- */
/* Guess the data type. Since October 1, 2009, it should be */
/* Float32. Before it was double. */
/* -------------------------------------------------------------------- */
CPL_IGNORE_RET_VAL(VSIFSeekL(poDS->fpImage, 0, SEEK_END));
const vsi_l_offset nSize = VSIFTellL(poDS->fpImage);
GDALDataType eDT = GDT_Float32;
if( nSize == 40 + 8 * static_cast<vsi_l_offset>(poDS->nRasterXSize) *
poDS->nRasterYSize )
eDT = GDT_Float64;
const int nDTSize = GDALGetDataTypeSizeBytes(eDT);
/* -------------------------------------------------------------------- */
/* Create band information object. */
/* -------------------------------------------------------------------- */
RawRasterBand *poBand = new RawRasterBand(
poDS, 1, poDS->fpImage,
(poDS->nRasterYSize-1) * poDS->nRasterXSize*nDTSize + 40,
nDTSize, poDS->nRasterXSize * -nDTSize,
eDT,
!CPL_IS_LSB, TRUE, FALSE );
poBand->SetNoDataValue( -88.8888 );
poDS->SetBand( 1, poBand );
/* -------------------------------------------------------------------- */
/* Initialize any PAM information. */
/* -------------------------------------------------------------------- */
poDS->SetDescription( poOpenInfo->pszFilename );
poDS->TryLoadXML();
/* -------------------------------------------------------------------- */
/* Check for overviews. */
/* -------------------------------------------------------------------- */
poDS->oOvManager.Initialize( poDS, poOpenInfo->pszFilename );
return poDS;
}
int TigerCompleteChain::AddShapePoints( int nTLID, int nRecordId,
OGRLineString * poLine, CPL_UNUSED int nSeqNum )
{
int nShapeRecId;
nShapeRecId = GetShapeRecordId( nRecordId, nTLID );
// -2 means an error occured.
if( nShapeRecId == -2 )
return FALSE;
// -1 means there are no extra shape vertices, but things worked fine.
if( nShapeRecId == -1 )
return TRUE;
/* -------------------------------------------------------------------- */
/* Read all the sequential records with the same TLID. */
/* -------------------------------------------------------------------- */
char achShapeRec[OGR_TIGER_RECBUF_LEN];
int nShapeRecLen = psRT2Info->nRecordLength + nRecordLength - psRT1Info->nRecordLength;
for( ; TRUE; nShapeRecId++ )
{
int nBytesRead = 0;
if( VSIFSeekL( fpShape, (nShapeRecId-1) * nShapeRecLen,
SEEK_SET ) != 0 )
{
CPLError( CE_Failure, CPLE_FileIO,
"Failed to seek to %d of %s2",
(nShapeRecId-1) * nShapeRecLen, pszModule );
return FALSE;
}
nBytesRead = VSIFReadL( achShapeRec, 1, psRT2Info->nRecordLength,
fpShape );
/*
** Handle case where the last record in the file is full. We will
** try to read another record but not find it. We require that we
** have found at least one shape record for this case though.
*/
if( nBytesRead <= 0 && VSIFEofL( fpShape )
&& poLine->getNumPoints() > 0 )
break;
if( nBytesRead != psRT2Info->nRecordLength )
{
CPLError( CE_Failure, CPLE_FileIO,
"Failed to read %d bytes of record %d of %s2 at offset %d",
psRT2Info->nRecordLength, nShapeRecId, pszModule,
(nShapeRecId-1) * nShapeRecLen );
return FALSE;
}
if( atoi(GetField(achShapeRec,6,15)) != nTLID )
break;
/* -------------------------------------------------------------------- */
/* Translate the locations into OGRLineString vertices. */
/* -------------------------------------------------------------------- */
int iVertex;
for( iVertex = 0; iVertex < 10; iVertex++ )
{
int iStart = 19 + 19*iVertex;
int nX = atoi(GetField(achShapeRec,iStart,iStart+9));
int nY = atoi(GetField(achShapeRec,iStart+10,iStart+18));
if( nX == 0 && nY == 0 )
break;
poLine->addPoint( nX / 1000000.0, nY / 1000000.0 );
}
/* -------------------------------------------------------------------- */
/* Don't get another record if this one was incomplete. */
/* -------------------------------------------------------------------- */
if( iVertex < 10 )
break;
}
return TRUE;
}
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 );
}
CPLErr GS7BGDataset::WriteHeader( VSILFILE *fp, GInt32 nXSize, GInt32 nYSize,
double dfMinX, double dfMaxX,
double dfMinY, double dfMaxY,
double dfMinZ, double dfMaxZ )
{
if( VSIFSeekL( fp, 0, SEEK_SET ) != 0 )
{
CPLError( CE_Failure, CPLE_FileIO,
"Unable to seek to start of grid file.\n" );
return CE_Failure;
}
GInt32 nTemp = CPL_LSBWORD32(nHEADER_TAG);
if( VSIFWriteL( (void *)&nTemp, sizeof(GInt32), 1, fp ) != 1 )
{
CPLError( CE_Failure, CPLE_FileIO,
"Unable to write header tag to grid file.\n" );
return CE_Failure;
}
nTemp = CPL_LSBWORD32(sizeof(GInt32)); // Size of version section.
if( VSIFWriteL( (void *)&nTemp, sizeof(GInt32), 1, fp ) != 1 )
{
CPLError( CE_Failure, CPLE_FileIO,
"Unable to write size to grid file.\n" );
return CE_Failure;
}
nTemp = CPL_LSBWORD32(1); // Version
if( VSIFWriteL( (void *)&nTemp, sizeof(GInt32), 1, fp ) != 1 )
{
CPLError( CE_Failure, CPLE_FileIO,
"Unable to write size to grid file.\n" );
return CE_Failure;
}
nTemp = CPL_LSBWORD32(nGRID_TAG); // Mark start of grid
if( VSIFWriteL( (void *)&nTemp, sizeof(GInt32), 1, fp ) != 1 )
{
CPLError( CE_Failure, CPLE_FileIO,
"Unable to write size to grid file.\n" );
return CE_Failure;
}
nTemp = CPL_LSBWORD32(72); // Grid info size (the remainder of the header)
if( VSIFWriteL( (void *)&nTemp, sizeof(GInt32), 1, fp ) != 1 )
{
CPLError( CE_Failure, CPLE_FileIO,
"Unable to write size to grid file.\n" );
return CE_Failure;
}
nTemp = CPL_LSBWORD32(nYSize);
if( VSIFWriteL( (void *)&nTemp, sizeof(GInt32), 1, fp ) != 1 )
{
CPLError( CE_Failure, CPLE_FileIO,
"Unable to write Y size to grid file.\n" );
return CE_Failure;
}
nTemp = CPL_LSBWORD32(nXSize);
if( VSIFWriteL( (void *)&nTemp, sizeof(GInt32), 1, fp ) != 1 )
{
CPLError( CE_Failure, CPLE_FileIO,
"Unable to write X size to grid file.\n" );
return CE_Failure;
}
double dfTemp = dfMinX;
CPL_LSBPTR64(&dfTemp);
if( VSIFWriteL( (void *)&dfTemp, sizeof(double), 1, fp ) != 1 )
{
CPLError( CE_Failure, CPLE_FileIO,
"Unable to write minimum X value to grid file.\n" );
return CE_Failure;
}
dfTemp = dfMinY;
CPL_LSBPTR64( &dfTemp );
if( VSIFWriteL( (void *)&dfTemp, sizeof(double), 1, fp ) != 1 )
{
CPLError( CE_Failure, CPLE_FileIO,
"Unable to write minimum Y value to grid file.\n" );
return CE_Failure;
}
// Write node spacing in x direction
dfTemp = (dfMaxX - dfMinX) / (nXSize - 1);
CPL_LSBPTR64(&dfTemp);
if( VSIFWriteL( (void *)&dfTemp, sizeof(double), 1, fp ) != 1 )
{
CPLError( CE_Failure, CPLE_FileIO,
"Unable to write spacing in X value.\n" );
return CE_Failure;
}
// Write node spacing in y direction
dfTemp = (dfMaxY - dfMinY) / (nYSize -1);
CPL_LSBPTR64( &dfTemp );
if( VSIFWriteL( (void *)&dfTemp, sizeof(double), 1, fp ) != 1 )
{
CPLError( CE_Failure, CPLE_FileIO,
"Unable to write spacing in Y value.\n" );
return CE_Failure;
}
dfTemp = dfMinZ;
CPL_LSBPTR64( &dfTemp );
if( VSIFWriteL( (void *)&dfTemp, sizeof(double), 1, fp ) != 1 )
{
CPLError( CE_Failure, CPLE_FileIO,
"Unable to write minimum Z value to grid file.\n" );
return CE_Failure;
}
dfTemp = dfMaxZ;
CPL_LSBPTR64( &dfTemp );
if( VSIFWriteL( (void *)&dfTemp, sizeof(double), 1, fp ) != 1 )
{
CPLError( CE_Failure, CPLE_FileIO,
"Unable to write maximum Z value to grid file.\n" );
return CE_Failure;
}
dfTemp = 0; // Rotation value is zero
CPL_LSBPTR64( &dfTemp );
if( VSIFWriteL( (void *)&dfTemp, sizeof(double), 1, fp ) != 1 )
{
CPLError( CE_Failure, CPLE_FileIO,
"Unable to write rotation value to grid file.\n" );
return CE_Failure;
}
dfTemp = dfDefaultNoDataValue;
CPL_LSBPTR64( &dfTemp );
if( VSIFWriteL( (void *)&dfTemp, sizeof(double), 1, fp ) != 1 )
{
CPLError( CE_Failure, CPLE_FileIO,
"Unable to write cell blank value to grid file.\n" );
return CE_Failure;
}
// Only supports 1 band so go ahead and write band info here
nTemp = CPL_LSBWORD32(nDATA_TAG); // Mark start of data
if( VSIFWriteL( (void *)&nTemp, sizeof(GInt32), 1, fp ) != 1 )
{
CPLError( CE_Failure, CPLE_FileIO,
"Unable to data tag to grid file.\n" );
return CE_Failure;
}
int nSize = nXSize * nYSize * (int)sizeof(double);
nTemp = CPL_LSBWORD32(nSize); // Mark size of data
if( VSIFWriteL( (void *)&nTemp, sizeof(GInt32), 1, fp ) != 1 )
{
CPLError( CE_Failure, CPLE_FileIO,
"Unable to write data size to grid file.\n" );
return CE_Failure;
}
return CE_None;
}
RPFToc* RPFTOCReadFromBuffer(const char* pszFilename, VSILFILE* fp, const char* tocHeader)
{
tocHeader += 1; /* skip endian */
tocHeader += 2; /* skip header length */
tocHeader += 12; /* skip file name : this should be A.TOC (padded) */
tocHeader += 1; /* skip new */
tocHeader += 15; /* skip standard_num */
tocHeader += 8; /* skip standard_date */
tocHeader += 1; /* skip classification */
tocHeader += 2; /* skip country */
tocHeader += 2; /* skip release */
unsigned int locationSectionPhysicalLocation;
memcpy(&locationSectionPhysicalLocation, tocHeader, sizeof(unsigned int));
CPL_MSBPTR32(&locationSectionPhysicalLocation);
if( VSIFSeekL( fp, locationSectionPhysicalLocation, SEEK_SET ) != 0)
{
CPLError( CE_Failure, CPLE_NotSupported,
"Invalid TOC file. Unable to seek to locationSectionPhysicalLocation at offset %d.",
locationSectionPhysicalLocation );
return nullptr;
}
int nSections;
NITFLocation* pasLocations = NITFReadRPFLocationTable(fp, &nSections);
unsigned int boundaryRectangleSectionSubHeaderPhysIndex = 0;
unsigned int boundaryRectangleTablePhysIndex = 0;
unsigned int frameFileIndexSectionSubHeaderPhysIndex = 0;
unsigned int frameFileIndexSubsectionPhysIndex = 0;
for( int i = 0; i < nSections; i++ )
{
if (pasLocations[i].nLocId == LID_BoundaryRectangleSectionSubheader)
{
boundaryRectangleSectionSubHeaderPhysIndex = pasLocations[i].nLocOffset;
}
else if (pasLocations[i].nLocId == LID_BoundaryRectangleTable)
{
boundaryRectangleTablePhysIndex = pasLocations[i].nLocOffset;
}
else if (pasLocations[i].nLocId == LID_FrameFileIndexSectionSubHeader)
{
frameFileIndexSectionSubHeaderPhysIndex = pasLocations[i].nLocOffset;
}
else if (pasLocations[i].nLocId == LID_FrameFileIndexSubsection)
{
frameFileIndexSubsectionPhysIndex = pasLocations[i].nLocOffset;
}
}
CPLFree(pasLocations);
if (boundaryRectangleSectionSubHeaderPhysIndex == 0)
{
CPLError( CE_Failure, CPLE_NotSupported,
"Invalid TOC file. Can't find LID_BoundaryRectangleSectionSubheader." );
return nullptr;
}
if (boundaryRectangleTablePhysIndex == 0)
{
CPLError( CE_Failure, CPLE_NotSupported,
"Invalid TOC file. Can't find LID_BoundaryRectangleTable." );
return nullptr;
}
if (frameFileIndexSectionSubHeaderPhysIndex == 0)
{
CPLError( CE_Failure, CPLE_NotSupported,
"Invalid TOC file. Can't find LID_FrameFileIndexSectionSubHeader." );
return nullptr;
}
if (frameFileIndexSubsectionPhysIndex == 0)
{
CPLError( CE_Failure, CPLE_NotSupported,
"Invalid TOC file. Can't find LID_FrameFileIndexSubsection." );
return nullptr;
}
if( VSIFSeekL( fp, boundaryRectangleSectionSubHeaderPhysIndex, SEEK_SET ) != 0)
{
CPLError( CE_Failure, CPLE_NotSupported,
"Invalid TOC file. Unable to seek to boundaryRectangleSectionSubHeaderPhysIndex at offset %d.",
boundaryRectangleSectionSubHeaderPhysIndex );
return nullptr;
}
unsigned int boundaryRectangleTableOffset;
bool bOK = VSIFReadL( &boundaryRectangleTableOffset, sizeof(boundaryRectangleTableOffset), 1, fp) == 1;
CPL_MSBPTR32( &boundaryRectangleTableOffset );
unsigned short boundaryRectangleCount;
bOK &= VSIFReadL( &boundaryRectangleCount, sizeof(boundaryRectangleCount), 1, fp) == 1;
CPL_MSBPTR16( &boundaryRectangleCount );
if( !bOK || VSIFSeekL( fp, boundaryRectangleTablePhysIndex, SEEK_SET ) != 0)
{
CPLError( CE_Failure, CPLE_NotSupported,
"Invalid TOC file. Unable to seek to boundaryRectangleTablePhysIndex at offset %d.",
boundaryRectangleTablePhysIndex );
return nullptr;
}
RPFToc* toc = reinterpret_cast<RPFToc *>( CPLMalloc( sizeof( RPFToc ) ) );
toc->nEntries = boundaryRectangleCount;
toc->entries = reinterpret_cast<RPFTocEntry *>(
CPLMalloc( boundaryRectangleCount * sizeof(RPFTocEntry) ) );
memset(toc->entries, 0, boundaryRectangleCount * sizeof(RPFTocEntry));
for( int i = 0; i < toc->nEntries; i++ )
{
toc->entries[i].isOverviewOrLegend = 0;
bOK &= VSIFReadL( toc->entries[i].type, 1, 5, fp) == 5;
toc->entries[i].type[5] = 0;
RPFTOCTrim(toc->entries[i].type);
bOK &= VSIFReadL( toc->entries[i].compression, 1, 5, fp) == 5;
toc->entries[i].compression[5] = 0;
RPFTOCTrim(toc->entries[i].compression);
bOK &= VSIFReadL( toc->entries[i].scale, 1, 12, fp) == 12;
toc->entries[i].scale[12] = 0;
RPFTOCTrim(toc->entries[i].scale);
if (toc->entries[i].scale[0] == '1' &&
toc->entries[i].scale[1] == ':')
{
memmove(toc->entries[i].scale,
toc->entries[i].scale+2,
strlen(toc->entries[i].scale+2)+1);
}
bOK &= VSIFReadL( toc->entries[i].zone, 1, 1, fp) == 1;
toc->entries[i].zone[1] = 0;
RPFTOCTrim(toc->entries[i].zone);
bOK &= VSIFReadL( toc->entries[i].producer, 1, 5, fp) == 5;
toc->entries[i].producer[5] = 0;
RPFTOCTrim(toc->entries[i].producer);
bOK &= VSIFReadL( &toc->entries[i].nwLat, sizeof(double), 1, fp) == 1;
CPL_MSBPTR64( &toc->entries[i].nwLat);
bOK &= VSIFReadL( &toc->entries[i].nwLong, sizeof(double), 1, fp) == 1;
CPL_MSBPTR64( &toc->entries[i].nwLong);
bOK &= VSIFReadL( &toc->entries[i].swLat, sizeof(double), 1, fp) == 1;
CPL_MSBPTR64( &toc->entries[i].swLat);
bOK &= VSIFReadL( &toc->entries[i].swLong, sizeof(double), 1, fp) == 1;
CPL_MSBPTR64( &toc->entries[i].swLong);
bOK &= VSIFReadL( &toc->entries[i].neLat, sizeof(double), 1, fp) == 1;
CPL_MSBPTR64( &toc->entries[i].neLat);
bOK &= VSIFReadL( &toc->entries[i].neLong, sizeof(double), 1, fp) == 1;
CPL_MSBPTR64( &toc->entries[i].neLong);
bOK &= VSIFReadL( &toc->entries[i].seLat, sizeof(double), 1, fp) == 1;
CPL_MSBPTR64( &toc->entries[i].seLat);
bOK &= VSIFReadL( &toc->entries[i].seLong, sizeof(double), 1, fp) == 1;
CPL_MSBPTR64( &toc->entries[i].seLong);
bOK &= VSIFReadL( &toc->entries[i].vertResolution, sizeof(double), 1, fp) == 1;
CPL_MSBPTR64( &toc->entries[i].vertResolution);
bOK &= VSIFReadL( &toc->entries[i].horizResolution, sizeof(double), 1, fp) == 1;
CPL_MSBPTR64( &toc->entries[i].horizResolution);
bOK &= VSIFReadL( &toc->entries[i].vertInterval, sizeof(double), 1, fp) == 1;
CPL_MSBPTR64( &toc->entries[i].vertInterval);
bOK &= VSIFReadL( &toc->entries[i].horizInterval, sizeof(double), 1, fp) == 1;
CPL_MSBPTR64( &toc->entries[i].horizInterval);
bOK &= VSIFReadL( &toc->entries[i].nVertFrames, sizeof(int), 1, fp) == 1;
CPL_MSBPTR32( &toc->entries[i].nVertFrames );
bOK &= VSIFReadL( &toc->entries[i].nHorizFrames, sizeof(int), 1, fp) == 1;
CPL_MSBPTR32( &toc->entries[i].nHorizFrames );
if( !bOK )
{
CPLError(CE_Failure, CPLE_FileIO, "I/O error");
toc->entries[i].nVertFrames = 0;
toc->entries[i].nHorizFrames = 0;
RPFTOCFree(toc);
return nullptr;
}
if( toc->entries[i].vertInterval <= 1e-10 ||
!CPLIsFinite(toc->entries[i].vertInterval) ||
toc->entries[i].horizInterval <= 1e-10 ||
!CPLIsFinite(toc->entries[i].horizInterval) ||
!(fabs(toc->entries[i].seLong) <= 360.0) ||
!(fabs(toc->entries[i].nwLong) <= 360.0) ||
!(fabs(toc->entries[i].nwLat) <= 90.0) ||
!(fabs(toc->entries[i].seLat) <= 90.0) ||
toc->entries[i].seLong < toc->entries[i].nwLong ||
toc->entries[i].nwLat < toc->entries[i].seLat ||
toc->entries[i].nHorizFrames == 0 ||
toc->entries[i].nVertFrames == 0 ||
toc->entries[i].nHorizFrames > INT_MAX / toc->entries[i].nVertFrames )
{
CPLError(CE_Failure, CPLE_FileIO, "Invalid TOC entry");
toc->entries[i].nVertFrames = 0;
toc->entries[i].nHorizFrames = 0;
RPFTOCFree(toc);
return nullptr;
}
// TODO: We could probably use another data structure, like a list,
// instead of an array referenced by the frame coordinate...
if( static_cast<int>(toc->entries[i].nHorizFrames *
toc->entries[i].nVertFrames) >
atoi(CPLGetConfigOption("RPFTOC_MAX_FRAME_COUNT", "1000000")) )
{
CPLError(CE_Failure, CPLE_AppDefined,
"nHorizFrames=%d x nVertFrames=%d > %d. Please raise "
"the value of the RPFTOC_MAX_FRAME_COUNT configuration "
"option to more than %d if this dataset is legitimate.",
toc->entries[i].nHorizFrames, toc->entries[i].nVertFrames,
atoi(CPLGetConfigOption("RPFTOC_MAX_FRAME_COUNT", "1000000")),
toc->entries[i].nHorizFrames * toc->entries[i].nVertFrames );
toc->entries[i].frameEntries = nullptr;
}
else
{
toc->entries[i].frameEntries = reinterpret_cast<RPFTocFrameEntry*>(
VSI_CALLOC_VERBOSE( toc->entries[i].nVertFrames * toc->entries[i].nHorizFrames,
sizeof(RPFTocFrameEntry) ) );
}
if (toc->entries[i].frameEntries == nullptr)
{
toc->entries[i].nVertFrames = 0;
toc->entries[i].nHorizFrames = 0;
RPFTOCFree(toc);
return nullptr;
}
CPLDebug("RPFTOC", "[%d] type=%s, compression=%s, scale=%s, zone=%s, producer=%s, nVertFrames=%d, nHorizFrames=%d",
i, toc->entries[i].type, toc->entries[i].compression, toc->entries[i].scale,
toc->entries[i].zone, toc->entries[i].producer, toc->entries[i].nVertFrames, toc->entries[i].nHorizFrames);
}
if( VSIFSeekL( fp, frameFileIndexSectionSubHeaderPhysIndex, SEEK_SET ) != 0)
{
CPLError( CE_Failure, CPLE_NotSupported,
"Invalid TOC file. Unable to seek to frameFileIndexSectionSubHeaderPhysIndex at offset %d.",
frameFileIndexSectionSubHeaderPhysIndex );
RPFTOCFree(toc);
return nullptr;
}
/* Skip 1 byte security classification */
bOK &= VSIFSeekL( fp, 1, SEEK_CUR ) == 0;
unsigned int frameIndexTableOffset;
bOK &= VSIFReadL( &frameIndexTableOffset, sizeof(frameIndexTableOffset), 1, fp) == 1;
CPL_MSBPTR32( &frameIndexTableOffset );
unsigned int nFrameFileIndexRecords;
bOK &= VSIFReadL( &nFrameFileIndexRecords, sizeof(nFrameFileIndexRecords), 1, fp) == 1;
CPL_MSBPTR32( &nFrameFileIndexRecords );
unsigned short nFrameFilePathnameRecords;
bOK &= VSIFReadL( &nFrameFilePathnameRecords, sizeof(nFrameFilePathnameRecords), 1, fp) == 1;
CPL_MSBPTR16( &nFrameFilePathnameRecords );
unsigned short frameFileIndexRecordLength;
bOK &= VSIFReadL( &frameFileIndexRecordLength, sizeof(frameFileIndexRecordLength), 1, fp) == 1;
CPL_MSBPTR16( &frameFileIndexRecordLength );
if( frameFileIndexRecordLength < 3 * sizeof(short) )
{
CPLError(CE_Failure, CPLE_FileIO, "Invalid file");
RPFTOCFree(toc);
return nullptr;
}
if( !bOK )
{
CPLError(CE_Failure, CPLE_FileIO, "I/O error");
RPFTOCFree(toc);
return nullptr;
}
int newBoundaryId = 0;
for( int i = 0; i < static_cast<int>( nFrameFileIndexRecords ); i++ )
{
if( VSIFSeekL( fp, frameFileIndexSubsectionPhysIndex + frameFileIndexRecordLength * i, SEEK_SET ) != 0)
{
CPLError( CE_Failure, CPLE_NotSupported,
"Invalid TOC file. Unable to seek to frameFileIndexSubsectionPhysIndex(%d) at offset %d.",
i, frameFileIndexSubsectionPhysIndex + frameFileIndexRecordLength * i);
RPFTOCFree(toc);
return nullptr;
}
unsigned short boundaryId;
if( VSIFReadL( &boundaryId, sizeof(boundaryId), 1, fp) != 1 )
{
CPLError(CE_Failure, CPLE_FileIO, "I/O error");
RPFTOCFree(toc);
return nullptr;
}
CPL_MSBPTR16( &boundaryId );
if (i == 0 && boundaryId == 0)
newBoundaryId = 1;
if (newBoundaryId == 0)
boundaryId--;
if (boundaryId >= toc->nEntries)
{
CPLError( CE_Failure, CPLE_NotSupported,
"Invalid TOC file. Bad boundary id (%d) for frame file index %d.",
boundaryId, i);
RPFTOCFree(toc);
return nullptr;
}
RPFTocEntry* entry = &toc->entries[boundaryId];
entry->boundaryId = boundaryId;
unsigned short frameRow;
bOK &= VSIFReadL( &frameRow, sizeof(frameRow), 1, fp) == 1;
CPL_MSBPTR16( &frameRow );
unsigned short frameCol;
bOK &= VSIFReadL( &frameCol, sizeof(frameCol), 1, fp) == 1;
CPL_MSBPTR16( &frameCol );
if( !bOK )
{
CPLError(CE_Failure, CPLE_FileIO, "I/O error");
RPFTOCFree(toc);
return nullptr;
}
if (newBoundaryId == 0)
{
frameRow--;
frameCol--;
}
else
{
/* Trick so that frames are numbered north to south */
frameRow = (unsigned short)((entry->nVertFrames-1) - frameRow);
}
if (frameRow >= entry->nVertFrames)
{
CPLError( CE_Failure, CPLE_NotSupported,
"Invalid TOC file. Bad row num (%d) for frame file index %d.",
frameRow, i);
RPFTOCFree(toc);
return nullptr;
}
if (frameCol >= entry->nHorizFrames)
{
CPLError( CE_Failure, CPLE_NotSupported,
"Invalid TOC file. Bad col num (%d) for frame file index %d.",
frameCol, i);
RPFTOCFree(toc);
return nullptr;
}
RPFTocFrameEntry* frameEntry
= &entry->frameEntries[frameRow * entry->nHorizFrames + frameCol ];
frameEntry->frameRow = frameRow;
frameEntry->frameCol = frameCol;
if (frameEntry->exists)
{
CPLError( CE_Warning, CPLE_AppDefined,
"Frame entry(%d,%d) for frame file index %d was already found.",
frameRow, frameCol, i);
CPLFree(frameEntry->directory);
frameEntry->directory = nullptr;
CPLFree(frameEntry->fullFilePath);
frameEntry->fullFilePath = nullptr;
frameEntry->exists = 0;
}
unsigned int offsetFrameFilePathName;
bOK &= VSIFReadL( &offsetFrameFilePathName, sizeof(offsetFrameFilePathName), 1, fp) == 1;
CPL_MSBPTR32( &offsetFrameFilePathName );
bOK &= VSIFReadL( frameEntry->filename, 1, 12, fp) == 12;
if( !bOK )
{
CPLError(CE_Failure, CPLE_FileIO, "I/O error");
RPFTOCFree(toc);
return nullptr;
}
frameEntry->filename[12] = '\0';
bOK &= strlen(frameEntry->filename) > 0;
/* Check if the filename is an overview or legend */
for( int j = 0; j < 12; j++ )
{
if (strcmp(&(frameEntry->filename[j]),".OVR") == 0 ||
strcmp(&(frameEntry->filename[j]),".ovr") == 0 ||
strcmp(&(frameEntry->filename[j]),".LGD") == 0 ||
strcmp(&(frameEntry->filename[j]),".lgd") == 0)
{
entry->isOverviewOrLegend = TRUE;
break;
}
}
/* Extract series code */
if (entry->seriesAbbreviation == nullptr)
{
const NITFSeries* series = NITFGetSeriesInfo(frameEntry->filename);
if (series)
{
entry->seriesAbbreviation = series->abbreviation;
entry->seriesName = series->name;
}
}
/* Get file geo reference */
bOK &= VSIFReadL( frameEntry->georef, 1, 6, fp) == 6;
frameEntry->georef[6] = '\0';
/* Go to start of pathname record */
/* New path_off offset from start of frame file index section of TOC?? */
/* Add pathoffset wrt frame file index table subsection (loc[3]) */
if( !bOK || VSIFSeekL( fp, frameFileIndexSubsectionPhysIndex + offsetFrameFilePathName, SEEK_SET ) != 0)
{
CPLError( CE_Failure, CPLE_NotSupported,
"Invalid TOC file. Unable to seek to "
"frameFileIndexSubsectionPhysIndex + "
"offsetFrameFilePathName(%d) at offset %d.",
i, frameFileIndexSubsectionPhysIndex + offsetFrameFilePathName);
RPFTOCFree(toc);
return nullptr;
}
unsigned short pathLength;
bOK &= VSIFReadL( &pathLength, sizeof(pathLength), 1, fp) == 1;
CPL_MSBPTR16( &pathLength );
/* if nFrameFileIndexRecords == 65535 and pathLength == 65535 for each record,
this leads to 4 GB allocation... Protect against this case */
if (!bOK || pathLength == 0 || pathLength > 256)
{
CPLError( CE_Failure, CPLE_NotSupported,
"Path length is invalid : %d. Probably corrupted TOC file.",
static_cast<int>( pathLength ) );
RPFTOCFree(toc);
return nullptr;
}
frameEntry->directory = reinterpret_cast<char *>( CPLMalloc(pathLength+1) );
bOK &= VSIFReadL( frameEntry->directory, 1, pathLength, fp) == pathLength;
if( !bOK )
{
CPLError(CE_Failure, CPLE_FileIO, "I/O error");
RPFTOCFree(toc);
return nullptr;
}
frameEntry->directory[pathLength] = 0;
if (pathLength > 0 && frameEntry->directory[pathLength-1] == '/')
frameEntry->directory[pathLength-1] = 0;
if (frameEntry->directory[0] == '.' && frameEntry->directory[1] == '/')
{
memmove(frameEntry->directory, frameEntry->directory+2, strlen(frameEntry->directory+2)+1);
// Some A.TOC have subdirectory names like ".//X/" ... (#5979)
// Check if it was not intended to be "./X/" instead.
VSIStatBufL sStatBuf;
if( frameEntry->directory[0] == '/' &&
VSIStatL(CPLFormFilename(CPLGetDirname(pszFilename), frameEntry->directory+1, nullptr), &sStatBuf) == 0 &&
VSI_ISDIR(sStatBuf.st_mode) )
{
memmove(frameEntry->directory, frameEntry->directory+1, strlen(frameEntry->directory+1)+1);
}
}
{
char* baseDir = CPLStrdup(CPLGetDirname(pszFilename));
VSIStatBufL sStatBuf;
char* subdir = nullptr;
if (CPLIsFilenameRelative(frameEntry->directory) == FALSE)
subdir = CPLStrdup(frameEntry->directory);
else if (frameEntry->directory[0] == '.' && frameEntry->directory[1] == 0)
subdir = CPLStrdup(baseDir);
else
subdir = CPLStrdup(CPLFormFilename(baseDir, frameEntry->directory, nullptr));
#if !defined(_WIN32) && !defined(_WIN32_CE)
if( VSIStatL( subdir, &sStatBuf ) != 0 && strlen(subdir) > strlen(baseDir) && subdir[strlen(baseDir)] != 0)
{
char* c = subdir + strlen(baseDir)+1;
while(*c)
{
if (*c >= 'A' && *c <= 'Z')
*c += 'a' - 'A';
c++;
}
}
#endif
frameEntry->fullFilePath = CPLStrdup(CPLFormFilename(
subdir,
frameEntry->filename, nullptr));
if( VSIStatL( frameEntry->fullFilePath, &sStatBuf ) != 0 )
{
#if !defined(_WIN32) && !defined(_WIN32_CE)
if( strlen(frameEntry->fullFilePath) > strlen(subdir) )
{
char* c = frameEntry->fullFilePath + strlen(subdir)+1;
while(*c)
{
if (*c >= 'A' && *c <= 'Z')
*c += 'a' - 'A';
c++;
}
}
if( VSIStatL( frameEntry->fullFilePath, &sStatBuf ) != 0 )
#endif
{
frameEntry->fileExists = 0;
CPLError( CE_Warning, CPLE_AppDefined,
"File %s does not exist.", frameEntry->fullFilePath );
}
#if !defined(_WIN32) && !defined(_WIN32_CE)
else
{
frameEntry->fileExists = 1;
}
#endif
}
else
{
frameEntry->fileExists = 1;
}
CPLFree(subdir);
CPLFree(baseDir);
}
CPLDebug("RPFTOC", "Entry %d : %s,%s (%d, %d)", boundaryId, frameEntry->directory, frameEntry->filename, frameRow, frameCol);
frameEntry->exists = 1;
}
return toc;
}
CPLErr GS7BGRasterBand::IWriteBlock( int nBlockXOff, int nBlockYOff,
void *pImage )
{
if( eAccess == GA_ReadOnly )
{
CPLError( CE_Failure, CPLE_NoWriteAccess,
"Unable to write block, dataset opened read only.\n" );
return CE_Failure;
}
if( nBlockYOff < 0 || nBlockYOff > nRasterYSize - 1 || nBlockXOff != 0 )
return CE_Failure;
GS7BGDataset *poGDS = (GS7BGDataset *) ( poDS );
if( pafRowMinZ == NULL || pafRowMaxZ == NULL
|| nMinZRow < 0 || nMaxZRow < 0 )
{
pafRowMinZ = (double *)VSI_MALLOC2_VERBOSE( nRasterYSize,sizeof(double) );
if( pafRowMinZ == NULL )
{
return CE_Failure;
}
pafRowMaxZ = (double *)VSI_MALLOC2_VERBOSE( nRasterYSize,sizeof(double) );
if( pafRowMaxZ == NULL )
{
VSIFree( pafRowMinZ );
pafRowMinZ = NULL;
return CE_Failure;
}
CPLErr eErr = ScanForMinMaxZ();
if( eErr != CE_None )
return eErr;
}
if( VSIFSeekL( poGDS->fp,
GS7BGDataset::nHEADER_SIZE +
sizeof(double) * nRasterXSize * (nRasterYSize - nBlockYOff - 1),
SEEK_SET ) != 0 )
{
CPLError( CE_Failure, CPLE_FileIO,
"Unable to seek to beginning of grid row.\n" );
return CE_Failure;
}
double *pdfImage = (double *)pImage;
pafRowMinZ[nBlockYOff] = DBL_MAX;
pafRowMaxZ[nBlockYOff] = -DBL_MAX;
for( int iPixel=0; iPixel<nBlockXSize; iPixel++ )
{
if( pdfImage[iPixel] != poGDS->dfNoData_Value )
{
if( pdfImage[iPixel] < pafRowMinZ[nBlockYOff] )
pafRowMinZ[nBlockYOff] = pdfImage[iPixel];
if( pdfImage[iPixel] > pafRowMaxZ[nBlockYOff] )
pafRowMaxZ[nBlockYOff] = pdfImage[iPixel];
}
CPL_LSBPTR64( pdfImage+iPixel );
}
if( VSIFWriteL( pImage, sizeof(double), nBlockXSize,
poGDS->fp ) != static_cast<unsigned>(nBlockXSize) )
{
CPLError( CE_Failure, CPLE_FileIO,
"Unable to write block to grid file.\n" );
return CE_Failure;
}
/* Update min/max Z values as appropriate */
bool bHeaderNeedsUpdate = false;
if( nMinZRow == nBlockYOff && pafRowMinZ[nBlockYOff] > dfMinZ )
{
double dfNewMinZ = DBL_MAX;
for( int iRow=0; iRow<nRasterYSize; iRow++ )
{
if( pafRowMinZ[iRow] < dfNewMinZ )
{
dfNewMinZ = pafRowMinZ[iRow];
nMinZRow = iRow;
}
}
if( dfNewMinZ != dfMinZ )
{
dfMinZ = dfNewMinZ;
bHeaderNeedsUpdate = true;
}
}
if( nMaxZRow == nBlockYOff && pafRowMaxZ[nBlockYOff] < dfMaxZ )
{
double dfNewMaxZ = -DBL_MAX;
for( int iRow=0; iRow<nRasterYSize; iRow++ )
{
if( pafRowMaxZ[iRow] > dfNewMaxZ )
{
dfNewMaxZ = pafRowMaxZ[iRow];
nMaxZRow = iRow;
}
}
if( dfNewMaxZ != dfMaxZ )
{
dfMaxZ = dfNewMaxZ;
bHeaderNeedsUpdate = true;
}
}
if( pafRowMinZ[nBlockYOff] < dfMinZ || pafRowMaxZ[nBlockYOff] > dfMaxZ )
{
if( pafRowMinZ[nBlockYOff] < dfMinZ )
{
dfMinZ = pafRowMinZ[nBlockYOff];
nMinZRow = nBlockYOff;
}
if( pafRowMaxZ[nBlockYOff] > dfMaxZ )
{
dfMaxZ = pafRowMaxZ[nBlockYOff];
nMaxZRow = nBlockYOff;
}
bHeaderNeedsUpdate = true;
}
if( bHeaderNeedsUpdate && dfMaxZ > dfMinZ )
{
CPLErr eErr = poGDS->WriteHeader( poGDS->fp,
nRasterXSize, nRasterYSize,
dfMinX, dfMaxX,
dfMinY, dfMaxY,
dfMinZ, dfMaxZ );
return eErr;
}
return CE_None;
}
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;
}
void GDALPamProxyDB::LoadDB()
{
/* -------------------------------------------------------------------- */
/* Open the database relating original names to proxy .aux.xml */
/* file names. */
/* -------------------------------------------------------------------- */
CPLString osDBName =
CPLFormFilename( osProxyDBDir, "gdal_pam_proxy", "dat" );
FILE *fpDB = VSIFOpenL( osDBName, "r" );
nUpdateCounter = 0;
if( fpDB == NULL )
return;
/* -------------------------------------------------------------------- */
/* Read header, verify and extract update counter. */
/* -------------------------------------------------------------------- */
GByte abyHeader[100];
if( VSIFReadL( abyHeader, 1, 100, fpDB ) != 100
|| strncmp( (const char *) abyHeader, "GDAL_PROXY", 10 ) != 0 )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Problem reading %s header - short or corrupt?",
osDBName.c_str() );
return;
}
nUpdateCounter = atoi((const char *) abyHeader + 10);
/* -------------------------------------------------------------------- */
/* Read the file in one gulp. */
/* -------------------------------------------------------------------- */
int nBufLength;
char *pszDBData;
VSIFSeekL( fpDB, 0, SEEK_END );
nBufLength = (int) (VSIFTellL(fpDB) - 100);
pszDBData = (char *) CPLCalloc(1,nBufLength+1);
VSIFSeekL( fpDB, 100, SEEK_SET );
VSIFReadL( pszDBData, 1, nBufLength, fpDB );
VSIFCloseL( fpDB );
/* -------------------------------------------------------------------- */
/* Parse the list of in/out names. */
/* -------------------------------------------------------------------- */
int iNext = 0;
while( iNext < nBufLength )
{
CPLString osOriginal, osProxy;
osOriginal.assign( pszDBData + iNext );
for( ; iNext < nBufLength && pszDBData[iNext] != '\0'; iNext++ ) {}
if( iNext == nBufLength )
break;
iNext++;
osProxy = osProxyDBDir;
osProxy += "/";
osProxy += pszDBData + iNext;
for( ; iNext < nBufLength && pszDBData[iNext] != '\0'; iNext++ ) {}
iNext++;
aosOriginalFiles.push_back( osOriginal );
aosProxyFiles.push_back( osProxy );
}
CPLFree( pszDBData );
}
RPFToc* RPFTOCReadFromBuffer(const char* pszFilename, FILE* fp, const char* tocHeader)
{
int i, j;
unsigned int locationSectionPhysicalLocation;
unsigned short nSections;
unsigned int boundaryRectangleSectionSubHeaderPhysIndex = 0, boundaryRectangleSectionSubHeaderLength = 0;
unsigned int boundaryRectangleTablePhysIndex = 0, boundaryRectangleTableLength = 0;
unsigned int frameFileIndexSectionSubHeaderPhysIndex = 0, frameFileIndexSectionSubHeaderLength = 0;
unsigned int frameFileIndexSubsectionPhysIndex = 0, frameFileIndexSubsectionLength = 0;
unsigned int boundaryRectangleTableOffset;
unsigned short boundaryRectangleCount;
unsigned int frameIndexTableOffset;
unsigned int nFrameFileIndexRecords;
unsigned short nFrameFilePathnameRecords;
unsigned short frameFileIndexRecordLength;
int newBoundaryId = 0;
RPFToc* toc;
tocHeader += 1; /* skip endian */
tocHeader += 2; /* skip header length */
tocHeader += 12; /* skip file name : this should be A.TOC (padded) */
tocHeader += 1; /* skip new */
tocHeader += 15; /* skip standard_num */
tocHeader += 8; /* skip standard_date */
tocHeader += 1; /* skip classification */
tocHeader += 2; /* skip country */
tocHeader += 2; /* skip release */
memcpy(&locationSectionPhysicalLocation, tocHeader, sizeof(unsigned int));
CPL_MSBPTR32(&locationSectionPhysicalLocation);
if( VSIFSeekL( fp, locationSectionPhysicalLocation, SEEK_SET ) != 0)
{
CPLError( CE_Failure, CPLE_NotSupported,
"Invalid TOC file. Unable to seek to locationSectionPhysicalLocation at offset %d.",
locationSectionPhysicalLocation );
return NULL;
}
/* Skip location section length (4) and component location table offset (2)*/
VSIFSeekL( fp, 4 + 2, SEEK_CUR);
/* How many sections: # of section location records */
VSIFReadL( &nSections, 1, sizeof(nSections), fp);
CPL_MSBPTR16( &nSections );
/* Skip location record length(2) + component aggregate length(4) */
VSIFSeekL( fp, 2 + 4, SEEK_CUR);
for (i = 0; i < nSections; i++)
{
unsigned short id;
unsigned int sectionLength, physIndex;
VSIFReadL( &id, 1, sizeof(id), fp);
CPL_MSBPTR16( &id );
VSIFReadL( §ionLength, 1, sizeof(sectionLength), fp);
CPL_MSBPTR32( §ionLength );
VSIFReadL( &physIndex, 1, sizeof(physIndex), fp);
CPL_MSBPTR32( &physIndex );
if (id == LID_BoundaryRectangleSectionSubheader)
{
boundaryRectangleSectionSubHeaderPhysIndex = physIndex;
boundaryRectangleSectionSubHeaderLength = sectionLength;
}
else if (id == LID_BoundaryRectangleTable)
{
boundaryRectangleTablePhysIndex = physIndex;
boundaryRectangleTableLength = sectionLength;
}
else if (id == LID_FrameFileIndexSectionSubHeader)
{
frameFileIndexSectionSubHeaderPhysIndex = physIndex;
frameFileIndexSectionSubHeaderLength = sectionLength;
}
else if (id == LID_FrameFileIndexSubsection)
{
frameFileIndexSubsectionPhysIndex = physIndex;
frameFileIndexSubsectionLength = sectionLength;
}
}
if (boundaryRectangleSectionSubHeaderPhysIndex == 0)
{
CPLError( CE_Failure, CPLE_NotSupported,
"Invalid TOC file. Can't find LID_BoundaryRectangleSectionSubheader." );
return NULL;
}
if (boundaryRectangleTablePhysIndex == 0)
{
CPLError( CE_Failure, CPLE_NotSupported,
"Invalid TOC file. Can't find LID_BoundaryRectangleTable." );
return NULL;
}
if (frameFileIndexSectionSubHeaderPhysIndex == 0)
{
CPLError( CE_Failure, CPLE_NotSupported,
"Invalid TOC file. Can't find LID_FrameFileIndexSectionSubHeader." );
return NULL;
}
if (frameFileIndexSubsectionPhysIndex == 0)
{
CPLError( CE_Failure, CPLE_NotSupported,
"Invalid TOC file. Can't find LID_FrameFileIndexSubsection." );
return NULL;
}
if( VSIFSeekL( fp, boundaryRectangleSectionSubHeaderPhysIndex, SEEK_SET ) != 0)
{
CPLError( CE_Failure, CPLE_NotSupported,
"Invalid TOC file. Unable to seek to boundaryRectangleSectionSubHeaderPhysIndex at offset %d.",
boundaryRectangleSectionSubHeaderPhysIndex );
return NULL;
}
VSIFReadL( &boundaryRectangleTableOffset, 1, sizeof(boundaryRectangleTableOffset), fp);
CPL_MSBPTR32( &boundaryRectangleTableOffset );
VSIFReadL( &boundaryRectangleCount, 1, sizeof(boundaryRectangleCount), fp);
CPL_MSBPTR16( &boundaryRectangleCount );
if( VSIFSeekL( fp, boundaryRectangleTablePhysIndex, SEEK_SET ) != 0)
{
CPLError( CE_Failure, CPLE_NotSupported,
"Invalid TOC file. Unable to seek to boundaryRectangleTablePhysIndex at offset %d.",
boundaryRectangleTablePhysIndex );
return NULL;
}
toc = (RPFToc*)CPLMalloc(sizeof(RPFToc));
toc->nEntries = boundaryRectangleCount;
toc->entries = (RPFTocEntry*)CPLMalloc(boundaryRectangleCount * sizeof(RPFTocEntry));
memset(toc->entries, 0, boundaryRectangleCount * sizeof(RPFTocEntry));
for(i=0;i<toc->nEntries;i++)
{
toc->entries[i].isOverviewOrLegend = 0;
VSIFReadL( toc->entries[i].type, 1, 5, fp);
toc->entries[i].type[5] = 0;
RPFTOCTrim(toc->entries[i].type);
VSIFReadL( toc->entries[i].compression, 1, 5, fp);
toc->entries[i].compression[5] = 0;
RPFTOCTrim(toc->entries[i].compression);
VSIFReadL( toc->entries[i].scale, 1, 12, fp);
toc->entries[i].scale[12] = 0;
RPFTOCTrim(toc->entries[i].scale);
if (toc->entries[i].scale[0] == '1' &&
toc->entries[i].scale[1] == ':')
{
memmove(toc->entries[i].scale,
toc->entries[i].scale+2,
strlen(toc->entries[i].scale+2)+1);
}
VSIFReadL( toc->entries[i].zone, 1, 1, fp);
toc->entries[i].zone[1] = 0;
RPFTOCTrim(toc->entries[i].zone);
VSIFReadL( toc->entries[i].producer, 1, 5, fp);
toc->entries[i].producer[5] = 0;
RPFTOCTrim(toc->entries[i].producer);
VSIFReadL( &toc->entries[i].nwLat, 1, sizeof(double), fp);
CPL_MSBPTR64( &toc->entries[i].nwLat);
VSIFReadL( &toc->entries[i].nwLong, 1, sizeof(double), fp);
CPL_MSBPTR64( &toc->entries[i].nwLong);
VSIFReadL( &toc->entries[i].swLat, 1, sizeof(double), fp);
CPL_MSBPTR64( &toc->entries[i].swLat);
VSIFReadL( &toc->entries[i].swLong, 1, sizeof(double), fp);
CPL_MSBPTR64( &toc->entries[i].swLong);
VSIFReadL( &toc->entries[i].neLat, 1, sizeof(double), fp);
CPL_MSBPTR64( &toc->entries[i].neLat);
VSIFReadL( &toc->entries[i].neLong, 1, sizeof(double), fp);
CPL_MSBPTR64( &toc->entries[i].neLong);
VSIFReadL( &toc->entries[i].seLat, 1, sizeof(double), fp);
CPL_MSBPTR64( &toc->entries[i].seLat);
VSIFReadL( &toc->entries[i].seLong, 1, sizeof(double), fp);
CPL_MSBPTR64( &toc->entries[i].seLong);
VSIFReadL( &toc->entries[i].vertResolution, 1, sizeof(double), fp);
CPL_MSBPTR64( &toc->entries[i].vertResolution);
VSIFReadL( &toc->entries[i].horizResolution, 1, sizeof(double), fp);
CPL_MSBPTR64( &toc->entries[i].horizResolution);
VSIFReadL( &toc->entries[i].vertInterval, 1, sizeof(double), fp);
CPL_MSBPTR64( &toc->entries[i].vertInterval);
VSIFReadL( &toc->entries[i].horizInterval, 1, sizeof(double), fp);
CPL_MSBPTR64( &toc->entries[i].horizInterval);
VSIFReadL( &toc->entries[i].nVertFrames, 1, sizeof(int), fp);
CPL_MSBPTR32( &toc->entries[i].nVertFrames );
VSIFReadL( &toc->entries[i].nHorizFrames, 1, sizeof(int), fp);
CPL_MSBPTR32( &toc->entries[i].nHorizFrames );
toc->entries[i].frameEntries = (RPFTocFrameEntry*)
VSIMalloc3(toc->entries[i].nVertFrames, toc->entries[i].nHorizFrames, sizeof(RPFTocFrameEntry));
if (toc->entries[i].frameEntries == NULL)
{
CPLError( CE_Failure, CPLE_OutOfMemory,
"RPFTOCReadFromBuffer : Out of memory. Probably due to corrupted TOC file.");
RPFTOCFree(toc);
return NULL;
}
memset(toc->entries[i].frameEntries, 0,
toc->entries[i].nVertFrames * toc->entries[i].nHorizFrames * sizeof(RPFTocFrameEntry));
CPLDebug("RPFTOC", "[%d] type=%s, compression=%s, scale=%s, zone=%s, producer=%s, nVertFrames=%d, nHorizFrames=%d",
i, toc->entries[i].type, toc->entries[i].compression, toc->entries[i].scale,
toc->entries[i].zone, toc->entries[i].producer, toc->entries[i].nVertFrames, toc->entries[i].nHorizFrames);
}
if( VSIFSeekL( fp, frameFileIndexSectionSubHeaderPhysIndex, SEEK_SET ) != 0)
{
CPLError( CE_Failure, CPLE_NotSupported,
"Invalid TOC file. Unable to seek to frameFileIndexSectionSubHeaderPhysIndex at offset %d.",
frameFileIndexSectionSubHeaderPhysIndex );
RPFTOCFree(toc);
return NULL;
}
/* Skip 1 byte security classification */
VSIFSeekL( fp, 1, SEEK_CUR );
VSIFReadL( &frameIndexTableOffset, 1, sizeof(frameIndexTableOffset), fp);
CPL_MSBPTR32( &frameIndexTableOffset );
VSIFReadL( &nFrameFileIndexRecords, 1, sizeof(nFrameFileIndexRecords), fp);
CPL_MSBPTR32( &nFrameFileIndexRecords );
VSIFReadL( &nFrameFilePathnameRecords, 1, sizeof(nFrameFilePathnameRecords), fp);
CPL_MSBPTR16( &nFrameFilePathnameRecords );
VSIFReadL( &frameFileIndexRecordLength, 1, sizeof(frameFileIndexRecordLength), fp);
CPL_MSBPTR16( &frameFileIndexRecordLength );
for (i=0;i<(int)nFrameFileIndexRecords;i++)
{
RPFTocEntry* entry;
RPFTocFrameEntry* frameEntry;
unsigned short boundaryId, frameRow, frameCol;
unsigned int offsetFrameFilePathName;
unsigned short pathLength;
if( VSIFSeekL( fp, frameFileIndexSubsectionPhysIndex + frameFileIndexRecordLength * i, SEEK_SET ) != 0)
{
CPLError( CE_Failure, CPLE_NotSupported,
"Invalid TOC file. Unable to seek to frameFileIndexSubsectionPhysIndex(%d) at offset %d.",
i, frameFileIndexSubsectionPhysIndex + frameFileIndexRecordLength * i);
RPFTOCFree(toc);
return NULL;
}
VSIFReadL( &boundaryId, 1, sizeof(boundaryId), fp);
CPL_MSBPTR16( &boundaryId );
if (i == 0 && boundaryId == 0)
newBoundaryId = 1;
if (newBoundaryId == 0)
boundaryId--;
if (boundaryId >= toc->nEntries)
{
CPLError( CE_Failure, CPLE_NotSupported,
"Invalid TOC file. Bad boundary id (%d) for frame file index %d.",
boundaryId, i);
RPFTOCFree(toc);
return NULL;
}
entry = &toc->entries[boundaryId];
entry->boundaryId = boundaryId;
VSIFReadL( &frameRow, 1, sizeof(frameRow), fp);
CPL_MSBPTR16( &frameRow );
VSIFReadL( &frameCol, 1, sizeof(frameCol), fp);
CPL_MSBPTR16( &frameCol );
if (newBoundaryId == 0)
{
frameRow--;
frameCol--;
}
else
{
/* Trick so that frames are numbered north to south */
frameRow = (unsigned short)((entry->nVertFrames-1) - frameRow);
}
if (frameRow >= entry->nVertFrames)
{
CPLError( CE_Failure, CPLE_NotSupported,
"Invalid TOC file. Bad row num (%d) for frame file index %d.",
frameRow, i);
RPFTOCFree(toc);
return NULL;
}
if (frameCol >= entry->nHorizFrames)
{
CPLError( CE_Failure, CPLE_NotSupported,
"Invalid TOC file. Bad col num (%d) for frame file index %d.",
frameCol, i);
RPFTOCFree(toc);
return NULL;
}
frameEntry = &entry->frameEntries[frameRow * entry->nHorizFrames + frameCol ];
frameEntry->frameRow = frameRow;
frameEntry->frameCol = frameCol;
if (frameEntry->exists)
{
CPLError( CE_Failure, CPLE_NotSupported,
"Invalid TOC file. Frame entry(%d,%d) for frame file index %d is a duplicate.",
frameRow, frameCol, i);
RPFTOCFree(toc);
return NULL;
}
VSIFReadL( &offsetFrameFilePathName, 1, sizeof(offsetFrameFilePathName), fp);
CPL_MSBPTR32( &offsetFrameFilePathName );
VSIFReadL( frameEntry->filename, 1, 12, fp);
frameEntry->filename[12] = '\0';
/* Check if the filename is an overview or legend */
for (j=0;j<12;j++)
{
if (strcmp(&(frameEntry->filename[j]),".OVR") == 0 ||
strcmp(&(frameEntry->filename[j]),".ovr") == 0 ||
strcmp(&(frameEntry->filename[j]),".LGD") == 0 ||
strcmp(&(frameEntry->filename[j]),".lgd") == 0)
{
entry->isOverviewOrLegend = TRUE;
break;
}
}
/* Extract series code */
if (entry->seriesAbbreviation == NULL)
{
const NITFSeries* series = NITFGetSeriesInfo(frameEntry->filename);
if (series)
{
entry->seriesAbbreviation = series->abbreviation;
entry->seriesName = series->name;
}
}
/* Get file geo reference */
VSIFReadL( frameEntry->georef, 1, 6, fp);
frameEntry->georef[6] = '\0';
/* Go to start of pathname record */
/* New path_off offset from start of frame file index section of TOC?? */
/* Add pathoffset wrt frame file index table subsection (loc[3]) */
if( VSIFSeekL( fp, frameFileIndexSubsectionPhysIndex + offsetFrameFilePathName, SEEK_SET ) != 0)
{
CPLError( CE_Failure, CPLE_NotSupported,
"Invalid TOC file. Unable to seek to frameFileIndexSubsectionPhysIndex + offsetFrameFilePathName(%d) at offset %d.",
i, frameFileIndexSubsectionPhysIndex + offsetFrameFilePathName);
RPFTOCFree(toc);
return NULL;
}
VSIFReadL( &pathLength, 1, sizeof(pathLength), fp);
CPL_MSBPTR16( &pathLength );
/* if nFrameFileIndexRecords == 65535 and pathLength == 65535 for each record,
this leads to 4 GB allocation... Protect against this case */
if (pathLength > 256)
{
CPLError( CE_Failure, CPLE_NotSupported,
"Path length is big : %d. Probably corrupted TOC file.", (int)pathLength);
RPFTOCFree(toc);
return NULL;
}
frameEntry->directory = (char *)CPLMalloc(pathLength+1);
VSIFReadL( frameEntry->directory, 1, pathLength, fp);
frameEntry->directory[pathLength] = 0;
if (pathLength > 0 && frameEntry->directory[pathLength-1] == '/')
frameEntry->directory[pathLength-1] = 0;
if (frameEntry->directory[0] == '.' && frameEntry->directory[1] == '/')
memmove(frameEntry->directory, frameEntry->directory+2, strlen(frameEntry->directory+2)+1);
{
char* baseDir = CPLStrdup(CPLGetDirname(pszFilename));
VSIStatBufL sStatBuf;
char* subdir;
if (CPLIsFilenameRelative(frameEntry->directory) == FALSE)
subdir = CPLStrdup(frameEntry->directory);
else if (frameEntry->directory[0] == '.' && frameEntry->directory[1] == 0)
subdir = CPLStrdup(baseDir);
else
subdir = CPLStrdup(CPLFormFilename(baseDir, frameEntry->directory, NULL));
#if !defined(_WIN32) && !defined(_WIN32_CE)
if( VSIStatL( subdir, &sStatBuf ) != 0 && subdir[strlen(baseDir)] != 0)
{
char* c = subdir + strlen(baseDir)+1;
while(*c)
{
if (*c >= 'A' && *c <= 'Z')
*c += 'a' - 'A';
c++;
}
}
#endif
frameEntry->fullFilePath = CPLStrdup(CPLFormFilename(
subdir,
frameEntry->filename, NULL));
if( VSIStatL( frameEntry->fullFilePath, &sStatBuf ) != 0 )
{
#if !defined(_WIN32) && !defined(_WIN32_CE)
char* c = frameEntry->fullFilePath + strlen(subdir)+1;
while(*c)
{
if (*c >= 'A' && *c <= 'Z')
*c += 'a' - 'A';
c++;
}
if( VSIStatL( frameEntry->fullFilePath, &sStatBuf ) != 0 )
#endif
{
frameEntry->fileExists = 0;
CPLError( CE_Warning, CPLE_AppDefined,
"File %s does not exist.", frameEntry->fullFilePath );
}
#if !defined(_WIN32) && !defined(_WIN32_CE)
else
{
frameEntry->fileExists = 1;
}
#endif
}
else
{
frameEntry->fileExists = 1;
}
CPLFree(subdir);
CPLFree(baseDir);
}
CPLDebug("RPFTOC", "Entry %d : %s,%s (%d, %d)", boundaryId, frameEntry->directory, frameEntry->filename, frameRow, frameCol);
frameEntry->exists = 1;
}
return toc;
}
CPLErr LevellerRasterBand::IReadBlock( int nBlockXOff, int nBlockYOff,
void* pImage )
{
CPLAssert( sizeof(float) == sizeof(GInt32) );
CPLAssert( nBlockXOff == 0 );
CPLAssert( pImage != NULL );
LevellerDataset *poGDS = (LevellerDataset *) poDS;
/* -------------------------------------------------------------------- */
/* Seek to scanline. */
/* -------------------------------------------------------------------- */
const size_t rowbytes = nBlockXSize * sizeof(float);
if(0 != VSIFSeekL(
poGDS->m_fp,
poGDS->m_nDataOffset + nBlockYOff * rowbytes,
SEEK_SET))
{
CPLError( CE_Failure, CPLE_FileIO,
".bt Seek failed:%s", VSIStrerror( errno ) );
return CE_Failure;
}
/* -------------------------------------------------------------------- */
/* Read the scanline into the image buffer. */
/* -------------------------------------------------------------------- */
if( VSIFReadL( pImage, rowbytes, 1, poGDS->m_fp ) != 1 )
{
CPLError( CE_Failure, CPLE_FileIO,
"Leveller read failed:%s", VSIStrerror( errno ) );
return CE_Failure;
}
/* -------------------------------------------------------------------- */
/* Swap on MSB platforms. */
/* -------------------------------------------------------------------- */
#ifdef CPL_MSB
GDALSwapWords( pImage, 4, nRasterXSize, 4 );
#endif
/* -------------------------------------------------------------------- */
/* Convert from legacy-format fixed-point if necessary. */
/* -------------------------------------------------------------------- */
float* pf = (float*)pImage;
if(poGDS->m_version < 6)
{
GInt32* pi = (int*)pImage;
for(size_t i = 0; i < (size_t)nBlockXSize; i++)
pf[i] = (float)pi[i] / 65536;
}
#if 0
/* -------------------------------------------------------------------- */
/* Convert raw elevations to realworld elevs. */
/* -------------------------------------------------------------------- */
for(size_t i = 0; i < nBlockXSize; i++)
pf[i] *= poGDS->m_dWorldscale; //this->GetScale();
#endif
return CE_None;
}
int TigerCompleteChain::SetModule( const char * pszModule )
{
if( !OpenFile( pszModule, "1" ) )
return FALSE;
EstablishFeatureCount();
/* -------------------------------------------------------------------- */
/* Is this a copyright record inserted at the beginning of the */
/* RT1 file by the folks at GDT? If so, setup to ignore the */
/* first record. */
/* -------------------------------------------------------------------- */
nRT1RecOffset = 0;
if( pszModule )
{
char achHeader[10];
VSIFSeekL( fpPrimary, 0, SEEK_SET );
VSIFReadL( achHeader, sizeof(achHeader), 1, fpPrimary );
if( EQUALN(achHeader,"Copyright",8) )
{
nRT1RecOffset = 1;
nFeatures--;
}
}
/* -------------------------------------------------------------------- */
/* Open the RT3 file */
/* -------------------------------------------------------------------- */
if( bUsingRT3 )
{
if( fpRT3 != NULL )
{
VSIFCloseL( fpRT3 );
fpRT3 = NULL;
}
if( pszModule )
{
char *pszFilename;
pszFilename = poDS->BuildFilename( pszModule, "3" );
fpRT3 = VSIFOpenL( pszFilename, "rb" );
CPLFree( pszFilename );
}
}
/* -------------------------------------------------------------------- */
/* Close the shape point file, if open and free the list of */
/* record ids. */
/* -------------------------------------------------------------------- */
if( fpShape != NULL )
{
VSIFCloseL( fpShape );
fpShape = NULL;
}
CPLFree( panShapeRecordId );
panShapeRecordId = NULL;
/* -------------------------------------------------------------------- */
/* Try to open the RT2 file corresponding to this RT1 file. */
/* -------------------------------------------------------------------- */
if( pszModule != NULL )
{
char *pszFilename;
pszFilename = poDS->BuildFilename( pszModule, "2" );
fpShape = VSIFOpenL( pszFilename, "rb" );
if( fpShape == NULL )
{
if( nRT1RecOffset == 0 )
CPLError( CE_Warning, CPLE_OpenFailed,
"Failed to open %s, intermediate shape arcs will not be available.\n",
pszFilename );
}
else
panShapeRecordId = (int *)CPLCalloc(sizeof(int),GetFeatureCount());
CPLFree( pszFilename );
}
return TRUE;
}
OGRFeature *OGRBNALayer::GetNextFeature()
{
OGRFeature *poFeature;
BNARecord* record;
int offset, line;
if (failed || eof) return NULL;
while(1)
{
int ok = FALSE;
offset = (int) VSIFTellL(fpBNA);
line = curLine;
if (nNextFID < nFeatures)
{
VSIFSeekL( fpBNA, offsetAndLineFeaturesTable[nNextFID].offset, SEEK_SET );
curLine = offsetAndLineFeaturesTable[nNextFID].line;
}
record = BNA_GetNextRecord(fpBNA, &ok, &curLine, TRUE, bnaFeatureType);
if (ok == FALSE)
{
BNA_FreeRecord(record);
failed = TRUE;
return NULL;
}
if (record == NULL)
{
/* end of file */
eof = TRUE;
/* and we have finally build the whole index table */
partialIndexTable = FALSE;
return NULL;
}
if (record->featureType == bnaFeatureType)
{
if (nNextFID >= nFeatures)
{
nFeatures++;
offsetAndLineFeaturesTable =
(OffsetAndLine*)CPLRealloc(offsetAndLineFeaturesTable, nFeatures * sizeof(OffsetAndLine));
offsetAndLineFeaturesTable[nFeatures-1].offset = offset;
offsetAndLineFeaturesTable[nFeatures-1].line = line;
}
poFeature = BuildFeatureFromBNARecord(record, nNextFID++);
BNA_FreeRecord(record);
if( (m_poFilterGeom == NULL
|| FilterGeometry( poFeature->GetGeometryRef() ) )
&& (m_poAttrQuery == NULL
|| m_poAttrQuery->Evaluate( poFeature )) )
{
return poFeature;
}
delete poFeature;
}
else
{
BNA_FreeRecord(record);
}
}
}
OGRFeature *TigerCompleteChain::GetFeature( int nRecordId )
{
char achRecord[OGR_TIGER_RECBUF_LEN];
if( nRecordId < 0 || nRecordId >= nFeatures )
{
CPLError( CE_Failure, CPLE_FileIO,
"Request for out-of-range feature %d of %s1",
nRecordId, pszModule );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Read the raw record data from the file. */
/* -------------------------------------------------------------------- */
if( fpPrimary == NULL )
return NULL;
if( VSIFSeekL( fpPrimary, (nRecordId+nRT1RecOffset) * nRecordLength,
SEEK_SET ) != 0 )
{
CPLError( CE_Failure, CPLE_FileIO,
"Failed to seek to %d of %s1",
nRecordId * nRecordLength, pszModule );
return NULL;
}
if( VSIFReadL( achRecord, psRT1Info->nRecordLength, 1, fpPrimary ) != 1 )
{
CPLError( CE_Failure, CPLE_FileIO,
"Failed to read %d bytes of record %d of %s1 at offset %d",
psRT1Info->nRecordLength, nRecordId, pszModule,
(nRecordId+nRT1RecOffset) * nRecordLength );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Set fields. */
/* -------------------------------------------------------------------- */
OGRFeature *poFeature = new OGRFeature( poFeatureDefn );
SetFields( psRT1Info, poFeature, achRecord );
/* -------------------------------------------------------------------- */
/* Read RT3 record, and apply fields. */
/* -------------------------------------------------------------------- */
if( fpRT3 != NULL )
{
char achRT3Rec[OGR_TIGER_RECBUF_LEN];
int nRT3RecLen = psRT3Info->nRecordLength + nRecordLength - psRT1Info->nRecordLength;
if( VSIFSeekL( fpRT3, nRecordId * nRT3RecLen, SEEK_SET ) != 0 )
{
CPLError( CE_Failure, CPLE_FileIO,
"Failed to seek to %d of %s3",
nRecordId * nRT3RecLen, pszModule );
return NULL;
}
if( VSIFReadL( achRT3Rec, psRT3Info->nRecordLength, 1, fpRT3 ) != 1 )
{
CPLError( CE_Failure, CPLE_FileIO,
"Failed to read record %d of %s3",
nRecordId, pszModule );
return NULL;
}
SetFields( psRT3Info, poFeature, achRT3Rec );
}
/* -------------------------------------------------------------------- */
/* Set geometry */
/* -------------------------------------------------------------------- */
OGRLineString *poLine = new OGRLineString();
poLine->setPoint(0,
atoi(GetField(achRecord, 191, 200)) / 1000000.0,
atoi(GetField(achRecord, 201, 209)) / 1000000.0 );
if( !AddShapePoints( poFeature->GetFieldAsInteger("TLID"), nRecordId,
poLine, 0 ) )
{
delete poFeature;
return NULL;
}
poLine->addPoint(atoi(GetField(achRecord, 210, 219)) / 1000000.0,
atoi(GetField(achRecord, 220, 228)) / 1000000.0 );
poFeature->SetGeometryDirectly( poLine );
return poFeature;
}
CPLErr E00GRIDRasterBand::IReadBlock( CPL_UNUSED int nBlockXOff,
int nBlockYOff,
void * pImage )
{
E00GRIDDataset *poGDS = (E00GRIDDataset *) poDS;
char szVal[E00_FLOAT_SIZE+1];
szVal[E00_FLOAT_SIZE] = 0;
float* pafImage = (float*)pImage;
int* panImage = (int*)pImage;
const float fNoData = static_cast<float>(poGDS->dfNoData);
/* A new data line begins on a new text line. So if the xsize */
/* is not a multiple of VALS_PER_LINE, there are padding values */
/* that must be ignored */
const int nRoundedBlockXSize = ((nBlockXSize + VALS_PER_LINE - 1) /
VALS_PER_LINE) * VALS_PER_LINE;
if (poGDS->e00ReadPtr)
{
if (poGDS->nLastYOff < 0)
{
E00ReadRewind(poGDS->e00ReadPtr);
for(int i=0;i<6;i++)
E00ReadNextLine(poGDS->e00ReadPtr);
}
if (nBlockYOff == poGDS->nLastYOff + 1)
{
}
else if (nBlockYOff <= poGDS->nMaxYOffset)
{
//CPLDebug("E00GRID", "Skip to %d from %d", nBlockYOff, poGDS->nLastYOff);
VSIFSeekL(poGDS->fp, poGDS->panOffsets[nBlockYOff], SEEK_SET);
poGDS->nPosBeforeReadLine = poGDS->panOffsets[nBlockYOff];
poGDS->e00ReadPtr->iInBufPtr = 0;
poGDS->e00ReadPtr->szInBuf[0] = '\0';
}
else if (nBlockYOff > poGDS->nLastYOff + 1)
{
//CPLDebug("E00GRID", "Forward skip to %d from %d", nBlockYOff, poGDS->nLastYOff);
for(int i=poGDS->nLastYOff + 1; i < nBlockYOff;i++)
IReadBlock(0, i, pImage);
}
if (nBlockYOff > poGDS->nMaxYOffset)
{
poGDS->panOffsets[nBlockYOff] = poGDS->nPosBeforeReadLine +
poGDS->e00ReadPtr->iInBufPtr;
poGDS->nMaxYOffset = nBlockYOff;
}
const char* pszLine = NULL;
for(int i=0;i<nBlockXSize;i++)
{
if ((i % VALS_PER_LINE) == 0)
{
pszLine = E00ReadNextLine(poGDS->e00ReadPtr);
if (pszLine == NULL || strlen(pszLine) < 5 * E00_FLOAT_SIZE)
return CE_Failure;
}
if (eDataType == GDT_Float32)
{
pafImage[i] = (float) CPLAtof(pszLine + (i%VALS_PER_LINE) * E00_FLOAT_SIZE);
/* Workaround single vs double precision problems */
if (fNoData != 0 && fabs((pafImage[i] - fNoData)/fNoData) < 1e-6)
pafImage[i] = fNoData;
}
else
{
panImage[i] = atoi(pszLine + (i%VALS_PER_LINE) * E00_FLOAT_SIZE);
}
}
poGDS->nLastYOff = nBlockYOff;
return CE_None;
}
vsi_l_offset nValsToSkip = (vsi_l_offset)nBlockYOff * nRoundedBlockXSize;
vsi_l_offset nLinesToSkip = nValsToSkip / VALS_PER_LINE;
int nBytesPerLine = VALS_PER_LINE * E00_FLOAT_SIZE + poGDS->nBytesEOL;
vsi_l_offset nPos = poGDS->nDataStart + nLinesToSkip * nBytesPerLine;
VSIFSeekL(poGDS->fp, nPos, SEEK_SET);
for(int i=0;i<nBlockXSize;i++)
{
if (VSIFReadL(szVal, E00_FLOAT_SIZE, 1, poGDS->fp) != 1)
return CE_Failure;
if (eDataType == GDT_Float32)
{
pafImage[i] = (float) CPLAtof(szVal);
/* Workaround single vs double precision problems */
if (fNoData != 0 && fabs((pafImage[i] - fNoData)/fNoData) < 1e-6)
pafImage[i] = fNoData;
}
else
{
panImage[i] = atoi(szVal);
}
if (((i+1) % VALS_PER_LINE) == 0)
VSIFReadL(szVal, poGDS->nBytesEOL, 1, poGDS->fp);
}
return CE_None;
}
int TigerCompleteChain::GetShapeRecordId( int nChainId, int nTLID )
{
CPLAssert( nChainId >= 0 && nChainId < GetFeatureCount() );
if( fpShape == NULL || panShapeRecordId == NULL )
return -1;
/* -------------------------------------------------------------------- */
/* Do we already have the answer? */
/* -------------------------------------------------------------------- */
if( panShapeRecordId[nChainId] != 0 )
return panShapeRecordId[nChainId];
/* -------------------------------------------------------------------- */
/* If we don't already have this value, then search from the */
/* previous known record. */
/* -------------------------------------------------------------------- */
int iTestChain, nWorkingRecId;
for( iTestChain = nChainId-1;
iTestChain >= 0 && panShapeRecordId[iTestChain] <= 0;
iTestChain-- ) {}
if( iTestChain < 0 )
{
iTestChain = -1;
nWorkingRecId = 1;
}
else
{
nWorkingRecId = panShapeRecordId[iTestChain]+1;
}
/* -------------------------------------------------------------------- */
/* If we have non existent records following (-1's) we can */
/* narrow our search a bit. */
/* -------------------------------------------------------------------- */
while( panShapeRecordId[iTestChain+1] == -1 )
{
iTestChain++;
}
/* -------------------------------------------------------------------- */
/* Read records up to the maximum distance that is possibly */
/* required, looking for our target TLID. */
/* -------------------------------------------------------------------- */
int nMaxChainToRead = nChainId - iTestChain;
int nChainsRead = 0;
char achShapeRec[OGR_TIGER_RECBUF_LEN];
int nShapeRecLen = psRT2Info->nRecordLength + nRecordLength - psRT1Info->nRecordLength;
while( nChainsRead < nMaxChainToRead )
{
if( VSIFSeekL( fpShape, (nWorkingRecId-1) * nShapeRecLen,
SEEK_SET ) != 0 )
{
CPLError( CE_Failure, CPLE_FileIO,
"Failed to seek to %d of %s2",
(nWorkingRecId-1) * nShapeRecLen, pszModule );
return -2;
}
if( VSIFReadL( achShapeRec, psRT2Info->nRecordLength, 1, fpShape ) != 1 )
{
if( !VSIFEofL( fpShape ) )
{
CPLError( CE_Failure, CPLE_FileIO,
"Failed to read record %d of %s2",
nWorkingRecId-1, pszModule );
return -2;
}
else
return -1;
}
if( atoi(GetField(achShapeRec,6,15)) == nTLID )
{
panShapeRecordId[nChainId] = nWorkingRecId;
return nWorkingRecId;
}
if( atoi(GetField(achShapeRec,16,18)) == 1 )
{
nChainsRead++;
}
nWorkingRecId++;
}
panShapeRecordId[nChainId] = -1;
return -1;
}
void E00GRIDDataset::ReadMetadata()
{
if (bHasReadMetadata)
return;
bHasReadMetadata = TRUE;
if (e00ReadPtr == NULL)
{
const int nRoundedBlockXSize = ((nRasterXSize + VALS_PER_LINE - 1) /
VALS_PER_LINE) * VALS_PER_LINE;
const vsi_l_offset nValsToSkip =
(vsi_l_offset)nRasterYSize * nRoundedBlockXSize;
const vsi_l_offset nLinesToSkip = nValsToSkip / VALS_PER_LINE;
const int nBytesPerLine = VALS_PER_LINE * E00_FLOAT_SIZE + nBytesEOL;
const vsi_l_offset nPos = nDataStart + nLinesToSkip * nBytesPerLine;
VSIFSeekL(fp, nPos, SEEK_SET);
}
else
{
nLastYOff = -1;
const unsigned int BUFFER_SIZE = 65536;
const unsigned int NEEDLE_SIZE = 3*5;
const unsigned int nToRead = BUFFER_SIZE - NEEDLE_SIZE;
char* pabyBuffer = (char*)CPLCalloc(1, BUFFER_SIZE+NEEDLE_SIZE);
int nRead;
int bEOGFound = FALSE;
VSIFSeekL(fp, 0, SEEK_END);
vsi_l_offset nEndPos = VSIFTellL(fp);
if (nEndPos > BUFFER_SIZE)
nEndPos -= BUFFER_SIZE;
else
nEndPos = 0;
VSIFSeekL(fp, nEndPos, SEEK_SET);
#define GOTO_NEXT_CHAR() \
i ++; \
if (pabyBuffer[i] == 13 || pabyBuffer[i] == 10) \
{ \
i++; \
if (pabyBuffer[i] == 10) \
i++; \
} \
while ((nRead = static_cast<int>(VSIFReadL(pabyBuffer, 1, nToRead, fp))) != 0)
{
int i;
for(i = 0; i < nRead; i++)
{
if (pabyBuffer[i] == 'E')
{
GOTO_NEXT_CHAR();
if (pabyBuffer[i] == 'O')
{
GOTO_NEXT_CHAR();
if (pabyBuffer[i] == 'G')
{
GOTO_NEXT_CHAR();
if (pabyBuffer[i] == '~')
{
GOTO_NEXT_CHAR();
if (pabyBuffer[i] == '}')
{
bEOGFound = TRUE;
break;
}
}
}
}
}
}
if (bEOGFound)
{
VSIFSeekL(fp, VSIFTellL(fp) - nRead + i + 1, SEEK_SET);
e00ReadPtr->iInBufPtr = 0;
e00ReadPtr->szInBuf[0] = '\0';
break;
}
if (nEndPos == 0)
break;
if ((unsigned int)nRead == nToRead)
{
memmove(pabyBuffer + nToRead, pabyBuffer, NEEDLE_SIZE);
if (nEndPos >= (vsi_l_offset)nToRead)
nEndPos -= nToRead;
else
nEndPos = 0;
VSIFSeekL(fp, nEndPos, SEEK_SET);
}
else
break;
}
CPLFree(pabyBuffer);
if (!bEOGFound)
return;
}
const char* pszLine = NULL;
bool bPRJFound = false;
bool bStatsFound = false;
while((pszLine = ReadLine()) != NULL)
{
if (STARTS_WITH_CI(pszLine, "PRJ 2"))
{
bPRJFound = true;
while((pszLine = ReadLine()) != NULL)
{
if (EQUAL(pszLine, "EOP"))
{
break;
}
papszPrj = CSLAddString(papszPrj, pszLine);
}
OGRSpatialReference oSRS;
if( oSRS.importFromESRI( papszPrj ) != OGRERR_NONE )
{
CPLError( CE_Warning, CPLE_AppDefined,
"Failed to parse PRJ section, ignoring." );
}
else
{
char* pszWKT = NULL;
if (oSRS.exportToWkt(&pszWKT) == OGRERR_NONE && pszWKT != NULL)
osProjection = pszWKT;
CPLFree(pszWKT);
}
if (bStatsFound)
break;
}
else if (strcmp(pszLine, "STDV 8-1 254-1 15 3 60-1 -1 -1-1 4-") == 0)
{
bStatsFound = true;
pszLine = ReadLine();
if (pszLine)
{
CPLString osStats = pszLine;
pszLine = ReadLine();
if (pszLine)
{
osStats += pszLine;
char** papszTokens = CSLTokenizeString(osStats);
if (CSLCount(papszTokens) == 4)
{
dfMin = CPLAtof(papszTokens[0]);
dfMax = CPLAtof(papszTokens[1]);
dfMean = CPLAtof(papszTokens[2]);
dfStddev = CPLAtof(papszTokens[3]);
bHasStats = TRUE;
}
CSLDestroy(papszTokens);
}
}
if (bPRJFound)
break;
}
}
}
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;
}
OGRErr OGRCSVLayer::CreateFeature( OGRFeature *poNewFeature )
{
int iField;
if( !bInWriteMode )
{
CPLError( CE_Failure, CPLE_AppDefined,
"The CreateFeature() operation is not permitted on a read-only CSV." );
return OGRERR_FAILURE;
}
/* If we need rewind, it means that we have just written a feature before */
/* so there's no point seeking to the end of the file, as we're already */
/* at the end */
int bNeedSeekEnd = !bNeedRewindBeforeRead;
bNeedRewindBeforeRead = TRUE;
/* -------------------------------------------------------------------- */
/* Write field names if we haven't written them yet. */
/* Write .csvt file if needed */
/* -------------------------------------------------------------------- */
if( bNew )
{
OGRErr eErr = WriteHeader();
if (eErr != OGRERR_NONE)
return eErr;
bNeedSeekEnd = FALSE;
}
if (fpCSV == NULL)
return OGRERR_FAILURE;
/* -------------------------------------------------------------------- */
/* Make sure we are at the end of the file. */
/* -------------------------------------------------------------------- */
if (bNeedSeekEnd)
{
if (bFirstFeatureAppendedDuringSession)
{
/* Add a newline character to the end of the file if necessary */
bFirstFeatureAppendedDuringSession = FALSE;
VSIFSeekL( fpCSV, 0, SEEK_END );
VSIFSeekL( fpCSV, VSIFTellL(fpCSV) - 1, SEEK_SET);
char chLast;
VSIFReadL( &chLast, 1, 1, fpCSV );
VSIFSeekL( fpCSV, 0, SEEK_END );
if (chLast != '\n')
{
if( bUseCRLF )
VSIFPutcL( 13, fpCSV );
VSIFPutcL( '\n', fpCSV );
}
}
else
{
VSIFSeekL( fpCSV, 0, SEEK_END );
}
}
/* -------------------------------------------------------------------- */
/* Write out the geometry */
/* -------------------------------------------------------------------- */
if (eGeometryFormat == OGR_CSV_GEOM_AS_WKT)
{
OGRGeometry *poGeom = poNewFeature->GetGeometryRef();
char* pszWKT = NULL;
if (poGeom && poGeom->exportToWkt(&pszWKT) == OGRERR_NONE)
{
VSIFPrintfL( fpCSV, "\"%s\"", pszWKT);
}
else
{
VSIFPrintfL( fpCSV, "\"\"");
}
CPLFree(pszWKT);
if (poFeatureDefn->GetFieldCount() > 0)
VSIFPrintfL( fpCSV, "%c", chDelimiter);
}
else if (eGeometryFormat == OGR_CSV_GEOM_AS_XYZ ||
eGeometryFormat == OGR_CSV_GEOM_AS_XY ||
eGeometryFormat == OGR_CSV_GEOM_AS_YX)
{
OGRGeometry *poGeom = poNewFeature->GetGeometryRef();
if (poGeom && wkbFlatten(poGeom->getGeometryType()) == wkbPoint)
{
OGRPoint* poPoint = (OGRPoint*) poGeom;
char szBuffer[75];
if (eGeometryFormat == OGR_CSV_GEOM_AS_XYZ )
OGRMakeWktCoordinate(szBuffer, poPoint->getX(), poPoint->getY(), poPoint->getZ(), 3);
else if (eGeometryFormat == OGR_CSV_GEOM_AS_XY )
OGRMakeWktCoordinate(szBuffer, poPoint->getX(), poPoint->getY(), 0, 2);
else
OGRMakeWktCoordinate(szBuffer, poPoint->getY(), poPoint->getX(), 0, 2);
char* pc = szBuffer;
while(*pc != '\0')
{
if (*pc == ' ')
*pc = chDelimiter;
pc ++;
}
VSIFPrintfL( fpCSV, "%s", szBuffer );
}
else
{
VSIFPrintfL( fpCSV, "%c", chDelimiter );
if (eGeometryFormat == OGR_CSV_GEOM_AS_XYZ)
VSIFPrintfL( fpCSV, "%c", chDelimiter );
}
if (poFeatureDefn->GetFieldCount() > 0)
VSIFPrintfL( fpCSV, "%c", chDelimiter );
}
/* -------------------------------------------------------------------- */
/* Write out all the field values. */
/* -------------------------------------------------------------------- */
int bNonEmptyLine = FALSE;
for( iField = 0; iField < poFeatureDefn->GetFieldCount(); iField++ )
{
char *pszEscaped;
if( iField > 0 )
VSIFPrintfL( fpCSV, "%c", chDelimiter );
if (poFeatureDefn->GetFieldDefn(iField)->GetType() == OFTReal)
{
pszEscaped = CPLStrdup(poNewFeature->GetFieldAsString(iField));
/* Use point as decimal separator */
char* pszComma = strchr(pszEscaped, ',');
if (pszComma)
*pszComma = '.';
}
else
{
pszEscaped =
CPLEscapeString( poNewFeature->GetFieldAsString(iField),
-1, CPLES_CSV );
}
int nLen = (int)strlen(pszEscaped);
bNonEmptyLine |= (nLen != 0);
VSIFWriteL( pszEscaped, 1, nLen, fpCSV );
CPLFree( pszEscaped );
}
if( poFeatureDefn->GetFieldCount() == 1 && !bNonEmptyLine )
VSIFPrintfL( fpCSV, "%c", chDelimiter );
if( bUseCRLF )
VSIFPutcL( 13, fpCSV );
VSIFPutcL( '\n', fpCSV );
return OGRERR_NONE;
}
CEOSImage * CEOSOpen( const char * pszFilename, const char * pszAccess )
{
VSILFILE *fp;
CEOSRecord *psRecord;
CEOSImage *psImage;
int nSeqNum, i;
GByte abyHeader[16];
/* -------------------------------------------------------------------- */
/* Try to open the imagery file. */
/* -------------------------------------------------------------------- */
fp = VSIFOpenL( pszFilename, pszAccess );
if( fp == NULL )
{
CPLError( CE_Failure, CPLE_OpenFailed,
"Failed to open CEOS file `%s' with access `%s'.\n",
pszFilename, pszAccess );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Create a CEOSImage structure, and initialize it. */
/* -------------------------------------------------------------------- */
psImage = (CEOSImage *) CPLCalloc(1,sizeof(CEOSImage));
psImage->fpImage = fp;
psImage->nPixels = psImage->nLines = psImage->nBands = 0;
/* -------------------------------------------------------------------- */
/* Preread info on the first record, to establish if it is */
/* little endian. */
/* -------------------------------------------------------------------- */
VSIFReadL( abyHeader, 16, 1, fp );
VSIFSeekL( fp, 0, SEEK_SET );
if( abyHeader[0] != 0 || abyHeader[1] != 0 )
psImage->bLittleEndian = TRUE;
/* -------------------------------------------------------------------- */
/* Try to read the header record. */
/* -------------------------------------------------------------------- */
psRecord = CEOSReadRecord( psImage );
if( psRecord == NULL )
{
CEOSClose( psImage );
return NULL;
}
if( psRecord->nRecordType != CRT_IMAGE_FDR )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Got a %X type record, instead of the expected\n"
"file descriptor record on file %s.\n",
psRecord->nRecordType, pszFilename );
CEOSDestroyRecord( psRecord );
CEOSClose( psImage );
return NULL;
}
/* -------------------------------------------------------------------- */
/* The sequence number should be 2 indicating this is the */
/* imagery file. */
/* -------------------------------------------------------------------- */
nSeqNum = CEOSScanInt( psRecord->pachData + 44, 4 );
if( nSeqNum != 2 )
{
CPLError( CE_Warning, CPLE_AppDefined,
"Got a %d file sequence number, instead of the expected\n"
"2 indicating imagery on file %s.\n"
"Continuing to access anyways.\n",
nSeqNum, pszFilename );
}
/* -------------------------------------------------------------------- */
/* Extract various information. */
/* -------------------------------------------------------------------- */
psImage->nImageRecCount = CEOSScanInt( psRecord->pachData+180, 6 );
psImage->nImageRecLength = CEOSScanInt( psRecord->pachData+186, 6 );
psImage->nBitsPerPixel = CEOSScanInt( psRecord->pachData+216, 4 );
psImage->nBands = CEOSScanInt( psRecord->pachData+232, 4 );
psImage->nLines = CEOSScanInt( psRecord->pachData+236, 8 );
psImage->nPixels = CEOSScanInt( psRecord->pachData+248, 8 );
psImage->nPrefixBytes = CEOSScanInt( psRecord->pachData+276, 4 );
psImage->nSuffixBytes = CEOSScanInt( psRecord->pachData+288, 4 );
if( psImage->nImageRecLength <= 0 ||
psImage->nPrefixBytes < 0 ||
psImage->nBands > INT_MAX / psImage->nImageRecLength ||
(size_t)psImage->nBands > INT_MAX / sizeof(int))
{
CEOSDestroyRecord( psRecord );
CEOSClose( psImage );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Try to establish the layout of the imagery data. */
/* -------------------------------------------------------------------- */
psImage->nLineOffset = psImage->nBands * psImage->nImageRecLength;
psImage->panDataStart = (int *) VSIMalloc(sizeof(int) * psImage->nBands);
if( psImage->panDataStart == NULL )
{
CEOSDestroyRecord( psRecord );
CEOSClose( psImage );
return NULL;
}
for( i = 0; i < psImage->nBands; i++ )
{
psImage->panDataStart[i] =
psRecord->nLength + i * psImage->nImageRecLength
+ 12 + psImage->nPrefixBytes;
}
CEOSDestroyRecord( psRecord );
return psImage;
}
static void msTransformToGeospatialPDF(imageObj *img, mapObj *map, cairo_renderer *r)
{
/* We need a GDAL 1.10 PDF driver at runtime, but as far as the C API is concerned, GDAL 1.9 is */
/* largely sufficient. */
#if defined(USE_GDAL) && defined(GDAL_VERSION_NUM) && GDAL_VERSION_NUM >= 1900
GDALDatasetH hDS = NULL;
const char* pszGEO_ENCODING = NULL;
GDALDriverH hPDFDriver = NULL;
const char* pszVirtualIO = NULL;
int bVirtualIO = FALSE;
char* pszTmpFilename = NULL;
VSILFILE* fp = NULL;
if (map == NULL)
return;
pszGEO_ENCODING = msGetOutputFormatOption(img->format, "GEO_ENCODING", NULL);
if (pszGEO_ENCODING == NULL)
return;
msGDALInitialize();
hPDFDriver = GDALGetDriverByName("PDF");
if (hPDFDriver == NULL)
return;
/* When compiled against libpoppler, the PDF driver is VirtualIO capable */
/* but not, when it is compiled against libpodofo. */
pszVirtualIO = GDALGetMetadataItem( hPDFDriver, GDAL_DCAP_VIRTUALIO, NULL );
if (pszVirtualIO)
bVirtualIO = CSLTestBoolean(pszVirtualIO);
if (bVirtualIO)
pszTmpFilename = msTmpFile(map, NULL, "/vsimem/mscairopdf/", "pdf");
else
pszTmpFilename = msTmpFile(map, map->mappath, NULL, "pdf");
/* Copy content of outputStream buffer into file */
fp = VSIFOpenL(pszTmpFilename, "wb");
if (fp == NULL) {
msFree(pszTmpFilename);
return;
}
VSIFWriteL(r->outputStream->data, 1, r->outputStream->size, fp);
VSIFCloseL(fp);
fp = NULL;
hDS = GDALOpen(pszTmpFilename, GA_Update);
if ( hDS != NULL ) {
char* pszWKT = msProjectionObj2OGCWKT( &(map->projection) );
if( pszWKT != NULL ) {
double adfGeoTransform[6];
int i;
/* Add user-specified options */
for( i = 0; i < img->format->numformatoptions; i++ ) {
const char* pszOption = img->format->formatoptions[i];
if( strncasecmp(pszOption,"METADATA_ITEM:",14) == 0 ) {
char* pszKey = NULL;
const char* pszValue = CPLParseNameValue(pszOption + 14,
&pszKey);
if( pszKey != NULL ) {
GDALSetMetadataItem(hDS, pszKey, pszValue, NULL);
CPLFree(pszKey);
}
}
}
/* We need to rescale the geotransform because GDAL will not necessary */
/* open the PDF with the DPI that was used to generate it */
memcpy(adfGeoTransform, map->gt.geotransform, 6 * sizeof(double));
adfGeoTransform[1] = adfGeoTransform[1] * map->width / GDALGetRasterXSize(hDS);
adfGeoTransform[5] = adfGeoTransform[5] * map->height / GDALGetRasterYSize(hDS);
GDALSetGeoTransform(hDS, adfGeoTransform);
GDALSetProjection(hDS, pszWKT);
msFree( pszWKT );
pszWKT = NULL;
CPLSetThreadLocalConfigOption("GDAL_PDF_GEO_ENCODING", pszGEO_ENCODING);
GDALClose(hDS);
hDS = NULL;
CPLSetThreadLocalConfigOption("GDAL_PDF_GEO_ENCODING", NULL);
/* We need to replace the buffer with the content of the GDAL file */
fp = VSIFOpenL(pszTmpFilename, "rb");
if( fp != NULL ) {
int nFileSize;
VSIFSeekL(fp, 0, SEEK_END);
nFileSize = (int)VSIFTellL(fp);
msBufferResize(r->outputStream, nFileSize);
VSIFSeekL(fp, 0, SEEK_SET);
r->outputStream->size = VSIFReadL(r->outputStream->data, 1, nFileSize, fp);
VSIFCloseL(fp);
fp = NULL;
}
}
}
if ( hDS != NULL )
GDALClose(hDS);
VSIUnlink(pszTmpFilename);
msFree(pszTmpFilename);
#endif
}
GDALDataset *DOQ1Dataset::Open( GDALOpenInfo * poOpenInfo )
{
int nWidth, nHeight, nBandStorage, nBandTypes;
/* -------------------------------------------------------------------- */
/* We assume the user is pointing to the binary (ie. .bil) file. */
/* -------------------------------------------------------------------- */
if( poOpenInfo->nHeaderBytes < 212 )
return NULL;
/* -------------------------------------------------------------------- */
/* Attempt to extract a few key values from the header. */
/* -------------------------------------------------------------------- */
nWidth = (int) DOQGetField(poOpenInfo->pabyHeader + 150, 6);
nHeight = (int) DOQGetField(poOpenInfo->pabyHeader + 144, 6);
nBandStorage = (int) DOQGetField(poOpenInfo->pabyHeader + 162, 3);
nBandTypes = (int) DOQGetField(poOpenInfo->pabyHeader + 156, 3);
/* -------------------------------------------------------------------- */
/* Do these values look coherent for a DOQ file? It would be */
/* nice to do a more comprehensive test than this! */
/* -------------------------------------------------------------------- */
if( nWidth < 500 || nWidth > 25000
|| nHeight < 500 || nHeight > 25000
|| nBandStorage < 0 || nBandStorage > 4
|| nBandTypes < 1 || nBandTypes > 9 )
return NULL;
/* -------------------------------------------------------------------- */
/* Check the configuration. We don't currently handle all */
/* variations, only the common ones. */
/* -------------------------------------------------------------------- */
if( nBandTypes > 5 )
{
CPLError( CE_Failure, CPLE_OpenFailed,
"DOQ Data Type (%d) is not a supported configuration.\n",
nBandTypes );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Confirm the requested access is supported. */
/* -------------------------------------------------------------------- */
if( poOpenInfo->eAccess == GA_Update )
{
CPLError( CE_Failure, CPLE_NotSupported,
"The DOQ1 driver does not support update access to existing"
" datasets.\n" );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Create a corresponding GDALDataset. */
/* -------------------------------------------------------------------- */
DOQ1Dataset *poDS;
poDS = new DOQ1Dataset();
/* -------------------------------------------------------------------- */
/* Capture some information from the file that is of interest. */
/* -------------------------------------------------------------------- */
poDS->nRasterXSize = nWidth;
poDS->nRasterYSize = nHeight;
poDS->fpImage = VSIFOpenL(poOpenInfo->pszFilename, "rb");
if (poDS->fpImage == NULL)
{
delete poDS;
return NULL;
}
/* -------------------------------------------------------------------- */
/* Compute layout of data. */
/* -------------------------------------------------------------------- */
int nSkipBytes, nBytesPerPixel=0, nBytesPerLine, i;
if( nBandTypes < 5 )
nBytesPerPixel = 1;
else if( nBandTypes == 5 )
nBytesPerPixel = 3;
nBytesPerLine = nBytesPerPixel * nWidth;
nSkipBytes = 4 * nBytesPerLine;
/* -------------------------------------------------------------------- */
/* Create band information objects. */
/* -------------------------------------------------------------------- */
poDS->nBands = nBytesPerPixel;
for( i = 0; i < poDS->nBands; i++ )
{
poDS->SetBand( i+1,
new RawRasterBand( poDS, i+1, poDS->fpImage,
nSkipBytes + i, nBytesPerPixel, nBytesPerLine,
GDT_Byte, TRUE, TRUE ) );
}
/* -------------------------------------------------------------------- */
/* Set the description. */
/* -------------------------------------------------------------------- */
DOQGetDescription(poDS, poOpenInfo->pabyHeader);
/* -------------------------------------------------------------------- */
/* Establish the projection string. */
/* -------------------------------------------------------------------- */
if( ((int) DOQGetField(poOpenInfo->pabyHeader + 195, 3)) != 1 )
poDS->pszProjection = VSIStrdup("");
else
{
const char *pszDatumLong, *pszDatumShort;
const char *pszUnits;
int nZone;
nZone = (int) DOQGetField(poOpenInfo->pabyHeader + 198, 6);
if( ((int) DOQGetField(poOpenInfo->pabyHeader + 204, 3)) == 1 )
pszUnits = "UNIT[\"US survey foot\",0.304800609601219]";
else
pszUnits = "UNIT[\"metre\",1]";
switch( (int) DOQGetField(poOpenInfo->pabyHeader + 167, 2) )
{
case 1:
pszDatumLong = NAD27_DATUM;
pszDatumShort = "NAD 27";
break;
case 2:
pszDatumLong = WGS72_DATUM;
pszDatumShort = "WGS 72";
break;
case 3:
pszDatumLong = WGS84_DATUM;
pszDatumShort = "WGS 84";
break;
case 4:
pszDatumLong = NAD83_DATUM;
pszDatumShort = "NAD 83";
break;
default:
pszDatumLong = "DATUM[\"unknown\"]";
pszDatumShort = "unknown";
break;
}
poDS->pszProjection =
CPLStrdup(CPLSPrintf( UTM_FORMAT, pszDatumShort, nZone,
pszDatumLong, nZone * 6 - 183, pszUnits ));
}
/* -------------------------------------------------------------------- */
/* Read the georeferencing information. */
/* -------------------------------------------------------------------- */
unsigned char abyRecordData[500];
if( VSIFSeekL( poDS->fpImage, nBytesPerLine * 2, SEEK_SET ) != 0
|| VSIFReadL(abyRecordData,sizeof(abyRecordData),1,poDS->fpImage) != 1 )
{
CPLError( CE_Failure, CPLE_FileIO,
"Header read error on %s.\n",
poOpenInfo->pszFilename );
delete poDS;
return NULL;
}
poDS->dfULX = DOQGetField( abyRecordData + 288, 24 );
poDS->dfULY = DOQGetField( abyRecordData + 312, 24 );
if( VSIFSeekL( poDS->fpImage, nBytesPerLine * 3, SEEK_SET ) != 0
|| VSIFReadL(abyRecordData,sizeof(abyRecordData),1,poDS->fpImage) != 1 )
{
CPLError( CE_Failure, CPLE_FileIO,
"Header read error on %s.\n",
poOpenInfo->pszFilename );
delete poDS;
return NULL;
}
poDS->dfXPixelSize = DOQGetField( abyRecordData + 59, 12 );
poDS->dfYPixelSize = DOQGetField( abyRecordData + 71, 12 );
/* -------------------------------------------------------------------- */
/* Initialize any PAM information. */
/* -------------------------------------------------------------------- */
poDS->SetDescription( poOpenInfo->pszFilename );
poDS->TryLoadXML();
/* -------------------------------------------------------------------- */
/* Check for overviews. */
/* -------------------------------------------------------------------- */
poDS->oOvManager.Initialize( poDS, poOpenInfo->pszFilename );
return( poDS );
}
int OGRSelafinDataSource::OpenTable(const char * pszFilename) {
#ifdef DEBUG_VERBOSE
CPLDebug("Selafin", "OpenTable(%s,%i)",
pszFilename, static_cast<int>(bUpdate));
#endif
// Open the file
VSILFILE *fp = nullptr;
if( bUpdate )
{
fp = VSIFOpenExL( pszFilename, "rb+", true );
}
else
{
fp = VSIFOpenExL( pszFilename, "rb", true );
}
if( fp == nullptr ) {
CPLError( CE_Warning, CPLE_OpenFailed, "Failed to open %s.", VSIGetLastErrorMsg() );
return FALSE;
}
if( !bUpdate && strstr(pszFilename, "/vsigzip/") == nullptr && strstr(pszFilename, "/vsizip/") == nullptr ) fp = (VSILFILE*) VSICreateBufferedReaderHandle((VSIVirtualHandle*)fp);
// Quickly check if the file is in Selafin format, before actually starting to read to make it faster
char szBuf[9];
VSIFReadL(szBuf,1,4,fp);
if (szBuf[0]!=0 || szBuf[1]!=0 || szBuf[2]!=0 || szBuf[3]!=0x50) {
VSIFCloseL(fp);
return FALSE;
}
VSIFSeekL(fp,84,SEEK_SET);
VSIFReadL(szBuf,1,8,fp);
if (szBuf[0]!=0 || szBuf[1]!=0 || szBuf[2]!=0 || szBuf[3]!=0x50 || szBuf[4]!=0 || szBuf[5]!=0 || szBuf[6]!=0 || szBuf[7]!=8) {
VSIFCloseL(fp);
return FALSE;
}
/* VSIFSeekL(fp,76,SEEK_SET);
VSIFReadL(szBuf,1,8,fp);
if (STRNCASECMP(szBuf,"Seraphin",8)!=0 && STRNCASECMP(szBuf,"Serafin",7)!=0) {
VSIFCloseL(fp);
return FALSE;
} */
// Get layer base name
CPLString osBaseLayerName = CPLGetBasename(pszFilename);
CPLString osExt = CPLGetExtension(pszFilename);
if( STARTS_WITH(pszFilename, "/vsigzip/") && EQUAL(osExt, "gz") ) {
size_t nPos=std::string::npos;
if (strlen(pszFilename)>3) nPos=osExt.find_last_of('.',strlen(pszFilename)-4);
if (nPos!=std::string::npos) {
osExt=osExt.substr(nPos+1,strlen(pszFilename)-4-nPos);
osBaseLayerName=osBaseLayerName.substr(0,nPos);
} else {
osExt="";
}
}
// Read header of file to get common information for all layers
// poHeader now owns fp
poHeader=Selafin::read_header(fp,pszFilename);
if (poHeader==nullptr) {
CPLError( CE_Failure, CPLE_OpenFailed, "Failed to open %s, wrong format.\n", pszFilename);
return FALSE;
}
if (poHeader->nEpsg!=0) {
poSpatialRef=new OGRSpatialReference();
poSpatialRef->SetAxisMappingStrategy(OAMS_TRADITIONAL_GIS_ORDER);
if (poSpatialRef->importFromEPSG(poHeader->nEpsg)!=OGRERR_NONE) {
CPLError( CE_Warning, CPLE_AppDefined, "EPSG %d not found. Could not set datasource SRS.\n", poHeader->nEpsg);
delete poSpatialRef;
poSpatialRef=nullptr;
}
}
// To prevent int overflow in poRange.getSize() call where we do
// nSteps * 2
if( poHeader->nSteps >= INT_MAX / 2 )
{
CPLError( CE_Failure, CPLE_OpenFailed, "Invalid nSteps value" );
return FALSE;
}
// Create two layers for each selected time step: one for points, the other for elements
poRange.setMaxValue(poHeader->nSteps);
const int nNewLayers = static_cast<int>(poRange.getSize());
if (EQUAL(pszFilename, "/vsistdin/")) osBaseLayerName = "layer";
CPLString osLayerName;
papoLayers = (OGRSelafinLayer **) CPLRealloc(papoLayers, sizeof(void*) * (nLayers+nNewLayers));
for (size_t j=0;j<2;++j) {
SelafinTypeDef eType=(j==0)?POINTS:ELEMENTS;
for (int i=0;i<poHeader->nSteps;++i) {
if (poRange.contains(eType,i)) {
char szTemp[30];
double dfTime = 0.0;
if( VSIFSeekL(fp, poHeader->getPosition(i)+4, SEEK_SET)!=0 ||
Selafin::read_float(fp, dfTime)==0 )
{
CPLError( CE_Failure, CPLE_OpenFailed, "Failed to open %s, wrong format.\n", pszFilename);
return FALSE;
}
if (poHeader->panStartDate==nullptr) snprintf(szTemp,29,"%d",i); else {
struct tm sDate;
memset(&sDate, 0, sizeof(sDate));
sDate.tm_year=poHeader->panStartDate[0]-1900;
sDate.tm_mon=poHeader->panStartDate[1]-1;
sDate.tm_mday=poHeader->panStartDate[2];
sDate.tm_hour=poHeader->panStartDate[3];
sDate.tm_min=poHeader->panStartDate[4];
double dfSec=poHeader->panStartDate[5]+dfTime;
if( dfSec >= 0 && dfSec < 60 )
sDate.tm_sec=static_cast<int>(dfSec);
mktime(&sDate);
strftime(szTemp,29,"%Y_%m_%d_%H_%M_%S",&sDate);
}
if (eType==POINTS) osLayerName=osBaseLayerName+"_p"+szTemp; else osLayerName=osBaseLayerName+"_e"+szTemp;
papoLayers[nLayers++] =
new OGRSelafinLayer( osLayerName, bUpdate, poSpatialRef,
poHeader, i, eType);
//poHeader->nRefCount++;
}
}
}
// Free allocated variables and exit
return TRUE;
}
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 );
}
OGRLayer *OGRSelafinDataSource::ICreateLayer( const char *pszLayerName, OGRSpatialReference *poSpatialRefP, OGRwkbGeometryType eGType, char ** papszOptions ) {
CPLDebug("Selafin","CreateLayer(%s,%s)",pszLayerName,(eGType==wkbPoint)?"wkbPoint":"wkbPolygon");
// Verify we are in update mode.
if ( !bUpdate )
{
CPLError( CE_Failure, CPLE_NoWriteAccess,
"Data source %s opened read-only. "
"New layer %s cannot be created.",
pszName, pszLayerName );
return nullptr;
}
// Check that new layer is a point or polygon layer
if( eGType != wkbPoint )
{
CPLError( CE_Failure, CPLE_NoWriteAccess, "Selafin format can only handle %s layers whereas input is %s\n.", OGRGeometryTypeToName(wkbPoint),OGRGeometryTypeToName(eGType));
return nullptr;
}
// Parse options
const char *pszTemp=CSLFetchNameValue(papszOptions,"DATE");
const double dfDate = pszTemp != nullptr ? CPLAtof(pszTemp) : 0.0;
// Set the SRS of the datasource if this is the first layer
if (nLayers==0 && poSpatialRefP!=nullptr) {
poSpatialRef=poSpatialRefP;
poSpatialRef->Reference();
const char* szEpsg=poSpatialRef->GetAttrValue("GEOGCS|AUTHORITY",1);
int nEpsg=0;
if (szEpsg!=nullptr) nEpsg=(int)strtol(szEpsg,nullptr,10);
if (nEpsg==0) {
CPLError(CE_Warning,CPLE_AppDefined,"Could not find EPSG code for SRS. The SRS won't be saved in the datasource.");
} else {
poHeader->nEpsg=nEpsg;
}
}
// Create the new layer in the Selafin file by adding a "time step" at the end
// Beware, as the new layer shares the same header, it automatically contains the same number of features and fields as the existing ones. This may not be intuitive for the user.
if (VSIFSeekL(poHeader->fp,0,SEEK_END)!=0) return nullptr;
if (Selafin::write_integer(poHeader->fp,4)==0 ||
Selafin::write_float(poHeader->fp,dfDate)==0 ||
Selafin::write_integer(poHeader->fp,4)==0) {
CPLError( CE_Failure, CPLE_FileIO, "Could not write to Selafin file %s.\n",pszName);
return nullptr;
}
double *pdfValues=nullptr;
if (poHeader->nPoints>0)
{
pdfValues=(double*)VSI_MALLOC2_VERBOSE(sizeof(double),poHeader->nPoints);
if( pdfValues == nullptr )
return nullptr;
}
for (int i=0;i<poHeader->nVar;++i) {
if (Selafin::write_floatarray(poHeader->fp,pdfValues,poHeader->nPoints)==0) {
CPLError( CE_Failure, CPLE_FileIO, "Could not write to Selafin file %s.\n",pszName);
CPLFree(pdfValues);
return nullptr;
}
}
CPLFree(pdfValues);
VSIFFlushL(poHeader->fp);
poHeader->nSteps++;
// Create two layers as usual, one for points and one for elements
nLayers+=2;
papoLayers = (OGRSelafinLayer **) CPLRealloc(papoLayers, sizeof(void*) * nLayers);
CPLString szName=pszLayerName;
CPLString szNewLayerName=szName+"_p";
papoLayers[nLayers-2] =
new OGRSelafinLayer( szNewLayerName, bUpdate, poSpatialRef, poHeader,
poHeader->nSteps-1, POINTS );
szNewLayerName=szName+"_e";
papoLayers[nLayers-1] =
new OGRSelafinLayer( szNewLayerName, bUpdate, poSpatialRef, poHeader,
poHeader->nSteps-1, ELEMENTS );
return papoLayers[nLayers-2];
}
int GDALJP2Box::SetOffset( GIntBig nNewOffset )
{
szBoxType[0] = '\0';
return VSIFSeekL( fpVSIL, nNewOffset, SEEK_SET ) == 0;
}
int NITFDESExtractShapefile(NITFDES* psDES, const char* pszRadixFileName)
{
NITFSegmentInfo* psSegInfo;
const char* apszExt[3];
int anOffset[4];
int iShpFile;
char* pszFilename;
if ( CSLFetchNameValue(psDES->papszMetadata, "NITF_SHAPE_USE") == NULL )
return FALSE;
psSegInfo = psDES->psFile->pasSegmentInfo + psDES->iSegment;
apszExt[0] = CSLFetchNameValue(psDES->papszMetadata, "NITF_SHAPE1_NAME");
anOffset[0] = atoi(CSLFetchNameValue(psDES->papszMetadata, "NITF_SHAPE1_START"));
apszExt[1] = CSLFetchNameValue(psDES->papszMetadata, "NITF_SHAPE2_NAME");
anOffset[1] = atoi(CSLFetchNameValue(psDES->papszMetadata, "NITF_SHAPE2_START"));
apszExt[2] = CSLFetchNameValue(psDES->papszMetadata, "NITF_SHAPE3_NAME");
anOffset[2] = atoi(CSLFetchNameValue(psDES->papszMetadata, "NITF_SHAPE3_START"));
anOffset[3] = (int) psSegInfo->nSegmentSize;
for(iShpFile = 0; iShpFile < 3; iShpFile ++)
{
if (!EQUAL(apszExt[iShpFile], "SHP") &&
!EQUAL(apszExt[iShpFile], "SHX") &&
!EQUAL(apszExt[iShpFile], "DBF"))
return FALSE;
if (anOffset[iShpFile] < 0 ||
anOffset[iShpFile] >= anOffset[iShpFile+1])
return FALSE;
}
pszFilename = (char*) VSIMalloc(strlen(pszRadixFileName) + 4 + 1);
if (pszFilename == NULL)
return FALSE;
for(iShpFile = 0; iShpFile < 3; iShpFile ++)
{
VSILFILE* fp;
GByte* pabyBuffer;
int nSize = anOffset[iShpFile+1] - anOffset[iShpFile];
pabyBuffer = (GByte*) VSIMalloc(nSize);
if (pabyBuffer == NULL)
{
VSIFree(pszFilename);
return FALSE;
}
VSIFSeekL(psDES->psFile->fp, psSegInfo->nSegmentStart + anOffset[iShpFile], SEEK_SET);
if (VSIFReadL(pabyBuffer, 1, nSize, psDES->psFile->fp) != nSize)
{
VSIFree(pabyBuffer);
VSIFree(pszFilename);
return FALSE;
}
sprintf(pszFilename, "%s.%s", pszRadixFileName, apszExt[iShpFile]);
fp = VSIFOpenL(pszFilename, "wb");
if (fp == NULL)
{
VSIFree(pabyBuffer);
VSIFree(pszFilename);
return FALSE;
}
VSIFWriteL(pabyBuffer, 1, nSize, fp);
VSIFCloseL(fp);
VSIFree(pabyBuffer);
}
VSIFree(pszFilename);
return TRUE;
}