static short ReadShort(VSILFILE* fp, int bOzi3 = FALSE, int nKeyInit = 0)
{
short nVal;
VSIFReadL(&nVal, 1, 2, fp);
if (bOzi3) OZIDecrypt(&nVal, 2, (GByte) nKeyInit);
CPL_LSBPTR16(&nVal);
return nVal;
}
static short ReadShort(GByte**pptr)
{
short nVal;
memcpy(&nVal, *pptr, 2);
*pptr += 2;
CPL_LSBPTR16(&nVal);
return nVal;
}
bool TerragenDataset::get(GUInt16& value)
{
if(1 == VSIFReadL(&value, sizeof(value), 1, m_fp))
{
CPL_LSBPTR16(&value);
return true;
}
return false;
}
static unsigned short readUShort( VSILFILE* fp, bool *pbSuccess = nullptr )
{
unsigned short val;
if (VSIFReadL( &val, 1, 2, fp ) != 2)
{
if (pbSuccess) *pbSuccess = false;
return 0;
}
if (pbSuccess) *pbSuccess = true;
CPL_LSBPTR16(&val);
return val;
}
static void WriteShort(VSILFILE* fp, GInt16 val)
{
CPL_LSBPTR16(&val);
VSIFWriteL(&val, 2, 1, fp);
}
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 );
}
bool TerragenDataset::put(GInt16 n)
{
CPL_LSBPTR16(&n);
return (1 == VSIFWriteL(&n, sizeof(n), 1, m_fp));
}
void appendUShort(void* pBuffer, unsigned short val)
{
CPL_LSBPTR16(&val);
memcpy(pBuffer, &val, 2);
}
void writeUShort(VSILFILE* fp, unsigned short val)
{
CPL_LSBPTR16(&val);
VSIFWriteL(&val, 1, 2, fp);
}
void LANDataset::CheckForStatistics()
{
/* -------------------------------------------------------------------- */
/* Do we have a statistics file? */
/* -------------------------------------------------------------------- */
osSTAFilename = CPLResetExtension(GetDescription(),"sta");
VSILFILE *fpSTA = VSIFOpenL( osSTAFilename, "r" );
if( fpSTA == NULL && VSIIsCaseSensitiveFS(osSTAFilename) )
{
osSTAFilename = CPLResetExtension(GetDescription(),"STA");
fpSTA = VSIFOpenL( osSTAFilename, "r" );
}
if( fpSTA == NULL )
{
osSTAFilename = "";
return;
}
/* -------------------------------------------------------------------- */
/* Read it one band at a time. */
/* -------------------------------------------------------------------- */
GByte abyBandInfo[1152] = { '\0' };
for( int iBand = 0; iBand < nBands; iBand++ )
{
if( VSIFReadL( abyBandInfo, 1152, 1, fpSTA ) != 1 )
break;
const int nBandNumber = abyBandInfo[7];
GDALRasterBand *poBand = GetRasterBand(nBandNumber);
if( poBand == NULL )
break;
GInt16 nMin = 0;
GInt16 nMax = 0;
if( poBand->GetRasterDataType() != GDT_Byte )
{
memcpy( &nMin, abyBandInfo + 28, 2 );
memcpy( &nMax, abyBandInfo + 30, 2 );
CPL_LSBPTR16( &nMin );
CPL_LSBPTR16( &nMax );
}
else
{
nMin = abyBandInfo[9];
nMax = abyBandInfo[8];
}
float fMean = 0.0;
float fStdDev = 0.0;
memcpy( &fMean, abyBandInfo + 12, 4 );
memcpy( &fStdDev, abyBandInfo + 24, 4 );
CPL_LSBPTR32( &fMean );
CPL_LSBPTR32( &fStdDev );
poBand->SetStatistics( nMin, nMax, fMean, fStdDev );
}
CPL_IGNORE_RET_VAL(VSIFCloseL( fpSTA ));
}
GDALDataset *LANDataset::Open( GDALOpenInfo * poOpenInfo )
{
/* -------------------------------------------------------------------- */
/* We assume the user is pointing to the header (.pcb) file. */
/* Does this appear to be a pcb file? */
/* -------------------------------------------------------------------- */
if( poOpenInfo->nHeaderBytes < ERD_HEADER_SIZE )
return NULL;
if( !STARTS_WITH_CI( reinterpret_cast<char *>(poOpenInfo->pabyHeader),
"HEADER" )
&& !STARTS_WITH_CI( reinterpret_cast<char *>(poOpenInfo->pabyHeader),
"HEAD74" ) )
return NULL;
/* -------------------------------------------------------------------- */
/* Create a corresponding GDALDataset. */
/* -------------------------------------------------------------------- */
LANDataset *poDS = new LANDataset();
poDS->eAccess = poOpenInfo->eAccess;
/* -------------------------------------------------------------------- */
/* Adopt the openinfo file pointer for use with this 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;
}
/* -------------------------------------------------------------------- */
/* Do we need to byte swap the headers to local machine order? */
/* -------------------------------------------------------------------- */
int bBigEndian = poOpenInfo->pabyHeader[8] == 0;
memcpy( poDS->pachHeader, poOpenInfo->pabyHeader, ERD_HEADER_SIZE );
#ifdef CPL_LSB
const int bNeedSwap = bBigEndian;
#else
const int bNeedSwap = !bBigEndian;
#endif
if( bNeedSwap )
{
CPL_SWAP16PTR( poDS->pachHeader + 6 );
CPL_SWAP16PTR( poDS->pachHeader + 8 );
CPL_SWAP32PTR( poDS->pachHeader + 16 );
CPL_SWAP32PTR( poDS->pachHeader + 20 );
CPL_SWAP32PTR( poDS->pachHeader + 24 );
CPL_SWAP32PTR( poDS->pachHeader + 28 );
CPL_SWAP16PTR( poDS->pachHeader + 88 );
CPL_SWAP16PTR( poDS->pachHeader + 90 );
CPL_SWAP16PTR( poDS->pachHeader + 106 );
CPL_SWAP32PTR( poDS->pachHeader + 108 );
CPL_SWAP32PTR( poDS->pachHeader + 112 );
CPL_SWAP32PTR( poDS->pachHeader + 116 );
CPL_SWAP32PTR( poDS->pachHeader + 120 );
CPL_SWAP32PTR( poDS->pachHeader + 124 );
}
/* -------------------------------------------------------------------- */
/* Capture some information from the file that is of interest. */
/* -------------------------------------------------------------------- */
if( STARTS_WITH_CI(poDS->pachHeader,"HEADER") )
{
float fTmp = 0.0;
memcpy(&fTmp, poDS->pachHeader + 16, 4);
CPL_LSBPTR32(&fTmp);
poDS->nRasterXSize = (int) fTmp;
memcpy(&fTmp, poDS->pachHeader + 20, 4);
CPL_LSBPTR32(&fTmp);
poDS->nRasterYSize = (int) fTmp;
}
else
{
GInt32 nTmp = 0;
memcpy(&nTmp, poDS->pachHeader + 16, 4);
CPL_LSBPTR32(&nTmp);
poDS->nRasterXSize = nTmp;
memcpy(&nTmp, poDS->pachHeader + 20, 4);
CPL_LSBPTR32(&nTmp);
poDS->nRasterYSize = nTmp;
}
GInt16 nTmp16 = 0;
memcpy(&nTmp16, poDS->pachHeader + 6, 2);
CPL_LSBPTR16(&nTmp16);
int nPixelOffset = 0;
GDALDataType eDataType = GDT_Unknown;
if( nTmp16 == 0 )
{
eDataType = GDT_Byte;
nPixelOffset = 1;
}
else if( nTmp16 == 1 ) // 4 bit
{
eDataType = GDT_Byte;
nPixelOffset = -1;
}
else if( nTmp16 == 2 )
{
nPixelOffset = 2;
eDataType = GDT_Int16;
}
else
{
CPLError( CE_Failure, CPLE_AppDefined,
"Unsupported pixel type (%d).",
nTmp16 );
delete poDS;
return NULL;
}
memcpy(&nTmp16, poDS->pachHeader + 8, 2);
CPL_LSBPTR16(&nTmp16);
const int nBandCount = nTmp16;
if( !GDALCheckDatasetDimensions(poDS->nRasterXSize, poDS->nRasterYSize) ||
!GDALCheckBandCount(nBandCount, FALSE) )
{
delete poDS;
return NULL;
}
if( nPixelOffset != -1 &&
poDS->nRasterXSize > INT_MAX / (nPixelOffset * nBandCount) )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Int overflow occurred." );
delete poDS;
return NULL;
}
/* -------------------------------------------------------------------- */
/* Create band information object. */
/* -------------------------------------------------------------------- */
CPLErrorReset();
for( int iBand = 1; iBand <= nBandCount; iBand++ )
{
if( nPixelOffset == -1 ) /* 4 bit case */
poDS->SetBand( iBand,
new LAN4BitRasterBand( poDS, iBand ) );
else
poDS->SetBand(
iBand,
new RawRasterBand( poDS, iBand, poDS->fpImage,
ERD_HEADER_SIZE + (iBand-1)
* nPixelOffset * poDS->nRasterXSize,
nPixelOffset,
poDS->nRasterXSize*nPixelOffset*nBandCount,
eDataType, !bNeedSwap, TRUE ));
if( CPLGetLastErrorType() != CE_None )
{
delete poDS;
return NULL;
}
}
/* -------------------------------------------------------------------- */
/* Initialize any PAM information. */
/* -------------------------------------------------------------------- */
poDS->SetDescription( poOpenInfo->pszFilename );
poDS->CheckForStatistics();
poDS->TryLoadXML();
/* -------------------------------------------------------------------- */
/* Check for overviews. */
/* -------------------------------------------------------------------- */
poDS->oOvManager.Initialize( poDS, poOpenInfo->pszFilename );
/* -------------------------------------------------------------------- */
/* Try to interpret georeferencing. */
/* -------------------------------------------------------------------- */
float fTmp = 0.0;
memcpy(&fTmp, poDS->pachHeader + 112, 4);
CPL_LSBPTR32(&fTmp);
poDS->adfGeoTransform[0] = fTmp;
memcpy(&fTmp, poDS->pachHeader + 120, 4);
CPL_LSBPTR32(&fTmp);
poDS->adfGeoTransform[1] = fTmp;
poDS->adfGeoTransform[2] = 0.0;
memcpy(&fTmp, poDS->pachHeader + 116, 4);
CPL_LSBPTR32(&fTmp);
poDS->adfGeoTransform[3] = fTmp;
poDS->adfGeoTransform[4] = 0.0;
memcpy(&fTmp, poDS->pachHeader + 124, 4);
CPL_LSBPTR32(&fTmp);
poDS->adfGeoTransform[5] = - fTmp;
// adjust for center of pixel vs. top left corner of pixel.
poDS->adfGeoTransform[0] -= poDS->adfGeoTransform[1] * 0.5;
poDS->adfGeoTransform[3] -= poDS->adfGeoTransform[5] * 0.5;
/* -------------------------------------------------------------------- */
/* If we didn't get any georeferencing, try for a worldfile. */
/* -------------------------------------------------------------------- */
if( poDS->adfGeoTransform[1] == 0.0
|| poDS->adfGeoTransform[5] == 0.0 )
{
if( !GDALReadWorldFile( poOpenInfo->pszFilename, NULL,
poDS->adfGeoTransform ) )
GDALReadWorldFile( poOpenInfo->pszFilename, ".wld",
poDS->adfGeoTransform );
}
/* -------------------------------------------------------------------- */
/* Try to come up with something for the coordinate system. */
/* -------------------------------------------------------------------- */
memcpy(&nTmp16, poDS->pachHeader + 88, 2);
CPL_LSBPTR16(&nTmp16);
int nCoordSys = nTmp16;
if( nCoordSys == 0 )
{
poDS->pszProjection = CPLStrdup(SRS_WKT_WGS84);
}
else if( nCoordSys == 1 )
{
poDS->pszProjection =
CPLStrdup( "LOCAL_CS[\"UTM - Zone Unknown\",UNIT[\"Meter\",1]]" );
}
else if( nCoordSys == 2 )
{
poDS->pszProjection =
CPLStrdup(
"LOCAL_CS[\"State Plane - Zone Unknown\","
"UNIT[\"US survey foot\",0.3048006096012192]]" );
}
else
{
poDS->pszProjection =
CPLStrdup( "LOCAL_CS[\"Unknown\",UNIT[\"Meter\",1]]" );
}
/* -------------------------------------------------------------------- */
/* Check for a trailer file with a colormap in it. */
/* -------------------------------------------------------------------- */
char *pszPath = CPLStrdup( CPLGetPath(poOpenInfo->pszFilename) );
char *pszBasename = CPLStrdup( CPLGetBasename(poOpenInfo->pszFilename) );
const char *pszTRLFilename =
CPLFormCIFilename( pszPath, pszBasename, "trl" );
VSILFILE *fpTRL = VSIFOpenL( pszTRLFilename, "rb" );
if( fpTRL != NULL )
{
char szTRLData[896] = { '\0' };
CPL_IGNORE_RET_VAL(VSIFReadL( szTRLData, 1, 896, fpTRL ));
CPL_IGNORE_RET_VAL(VSIFCloseL( fpTRL ));
GDALColorTable *poCT = new GDALColorTable();
for( int iColor = 0; iColor < 256; iColor++ )
{
GDALColorEntry sEntry = { 0, 0, 0, 0};
sEntry.c2 = reinterpret_cast<GByte *>(szTRLData)[iColor+128];
sEntry.c1 = reinterpret_cast<GByte *>(szTRLData)[iColor+128+256];
sEntry.c3 = reinterpret_cast<GByte *>(szTRLData)[iColor+128+512];
sEntry.c4 = 255;
poCT->SetColorEntry( iColor, &sEntry );
// Only 16 colors in 4bit files.
if( nPixelOffset == -1 && iColor == 15 )
break;
}
poDS->GetRasterBand(1)->SetColorTable( poCT );
poDS->GetRasterBand(1)->SetColorInterpretation( GCI_PaletteIndex );
delete poCT;
}
CPLFree( pszPath );
CPLFree( pszBasename );
return poDS;
}
CPLErr NWT_GRDRasterBand::IReadBlock( int nBlockXOff, int nBlockYOff, void *pImage )
{
NWT_GRDDataset *poGDS = (NWT_GRDDataset *) poDS;
char *pszRecord;
int nRecordSize = nBlockXSize * 2;
int i;
unsigned short raw1;
VSIFSeekL( poGDS->fp, 1024 + nRecordSize * (vsi_l_offset)nBlockYOff, SEEK_SET );
pszRecord = (char *) CPLMalloc( nRecordSize );
VSIFReadL( pszRecord, 1, nRecordSize, poGDS->fp );
if( nBand == 4 ) //Z values
{
for( i = 0; i < nBlockXSize; i++ )
{
memcpy( (void *) &raw1, (void *)(pszRecord + 2 * i), 2 );
CPL_LSBPTR16(&raw1);
if( raw1 == 0 )
{
((float *)pImage)[i] = (float)-1.e37; // null value
}
else
{
((float *)pImage)[i] = (float) (dfOffset + ((raw1 - 1) * dfScale));
}
}
}
else if( nBand == 1 ) // red values
{
for( i = 0; i < nBlockXSize; i++ )
{
memcpy( (void *) &raw1, (void *)(pszRecord + 2 * i), 2 );
CPL_LSBPTR16(&raw1);
((char *)pImage)[i] = poGDS->ColorMap[raw1 / 16].r;
}
}
else if( nBand == 2 ) // green
{
for( i = 0; i < nBlockXSize; i++ )
{
memcpy( (void *) &raw1, (void *)(pszRecord + 2 * i), 2 );
CPL_LSBPTR16(&raw1);
((char *) pImage)[i] = poGDS->ColorMap[raw1 / 16].g;
}
}
else if( nBand == 3 ) // blue
{
for( i = 0; i < nBlockXSize; i++ )
{
memcpy( (void *) &raw1, (void *) (pszRecord + 2 * i), 2 );
CPL_LSBPTR16(&raw1);
((char *) pImage)[i] = poGDS->ColorMap[raw1 / 16].b;
}
}
else
{
CPLError( CE_Failure, CPLE_IllegalArg,
"No band number %d",
nBand );
if( pszRecord != NULL )
CPLFree( pszRecord );
return CE_Failure;
}
if( pszRecord != NULL )
{
CPLFree( pszRecord );
}
return CE_None;
}
CPLErr NWT_GRDRasterBand::IReadBlock( CPL_UNUSED int nBlockXOff,
int nBlockYOff,
void *pImage )
{
NWT_GRDDataset *poGDS = reinterpret_cast<NWT_GRDDataset *>( poDS );
if( nBlockXSize > INT_MAX / 2 )
return CE_Failure;
const int nRecordSize = nBlockXSize * 2;
unsigned short raw1;
VSIFSeekL( poGDS->fp,
1024 + nRecordSize
* static_cast<vsi_l_offset>( nBlockYOff ),
SEEK_SET );
GByte *pabyRecord = reinterpret_cast<GByte *>( VSI_MALLOC_VERBOSE( nRecordSize ) );
if( pabyRecord == NULL )
return CE_Failure;
if( (int)VSIFReadL( pabyRecord, 1, nRecordSize, poGDS->fp ) != nRecordSize )
{
CPLFree( pabyRecord );
return CE_Failure;
}
if( nBand == 4 ) //Z values
{
for( int i = 0; i < nBlockXSize; i++ )
{
memcpy( reinterpret_cast<void *>( &raw1 ),
reinterpret_cast<void *>(pabyRecord + 2 * i), 2 );
CPL_LSBPTR16(&raw1);
if( raw1 == 0 )
{
reinterpret_cast<float *>( pImage )[i] = -1.e37f; // null value
}
else
{
reinterpret_cast<float *>( pImage )[i]
= static_cast<float>( dfOffset + ((raw1 - 1) * dfScale) );
}
}
}
else if( nBand == 1 ) // red values
{
for( int i = 0; i < nBlockXSize; i++ )
{
memcpy( reinterpret_cast<void *>( &raw1 ),
reinterpret_cast<void *>(pabyRecord + 2 * i),
2 );
CPL_LSBPTR16(&raw1);
reinterpret_cast<char *>( pImage )[i]
= poGDS->ColorMap[raw1 / 16].r;
}
}
else if( nBand == 2 ) // green
{
for( int i = 0; i < nBlockXSize; i++ )
{
memcpy( reinterpret_cast<void *> ( &raw1 ),
reinterpret_cast<void *> ( pabyRecord + 2 * i ),
2 );
CPL_LSBPTR16(&raw1);
reinterpret_cast<char *>( pImage )[i] = poGDS->ColorMap[raw1 / 16].g;
}
}
else if( nBand == 3 ) // blue
{
for( int i = 0; i < nBlockXSize; i++ )
{
memcpy( reinterpret_cast<void *>( &raw1 ),
reinterpret_cast<void *>( pabyRecord + 2 * i ),
2 );
CPL_LSBPTR16(&raw1);
reinterpret_cast<char *>( pImage )[i] = poGDS->ColorMap[raw1 / 16].b;
}
}
else
{
CPLError( CE_Failure, CPLE_IllegalArg,
"No band number %d",
nBand );
CPLFree( pabyRecord );
return CE_Failure;
}
CPLFree( pabyRecord );
return CE_None;
}
int nwt_ParseHeader( NWT_GRID * pGrd, char *nwtHeader )
{
int i;
unsigned short usTmp;
/* double dfTmp; */
unsigned char cTmp[256];
if( nwtHeader[4] == '1' )
pGrd->cFormat = 0x00; // grd - surface type
else if( nwtHeader[4] == '8' )
pGrd->cFormat = 0x80; // grc classified type
pGrd->stClassDict = NULL;
memcpy( (void *) &pGrd->fVersion, (void *) &nwtHeader[5],
sizeof(pGrd->fVersion) );
CPL_LSBPTR32(&pGrd->fVersion);
memcpy( (void *) &usTmp, (void *) &nwtHeader[9], 2 );
CPL_LSBPTR16(&usTmp);
pGrd->nXSide = (unsigned int) usTmp;
if( pGrd->nXSide == 0 )
{
memcpy( (void *) &pGrd->nXSide, (void *) &nwtHeader[128],
sizeof(pGrd->nXSide) );
CPL_LSBPTR32(&pGrd->nXSide);
}
memcpy( (void *) &usTmp, (void *) &nwtHeader[11], 2 );
CPL_LSBPTR16(&usTmp);
pGrd->nYSide = (unsigned int) usTmp;
if( pGrd->nYSide == 0 )
{
memcpy( (void *) &pGrd->nYSide, (void *) &nwtHeader[132],
sizeof(pGrd->nYSide) );
CPL_LSBPTR32(&pGrd->nYSide);
}
memcpy( (void *) &pGrd->dfMinX, (void *) &nwtHeader[13],
sizeof(pGrd->dfMinX) );
CPL_LSBPTR64(&pGrd->dfMinX);
memcpy( (void *) &pGrd->dfMaxX, (void *) &nwtHeader[21],
sizeof(pGrd->dfMaxX) );
CPL_LSBPTR64(&pGrd->dfMaxX);
memcpy( (void *) &pGrd->dfMinY, (void *) &nwtHeader[29],
sizeof(pGrd->dfMinY) );
CPL_LSBPTR64(&pGrd->dfMinY);
memcpy( (void *) &pGrd->dfMaxY, (void *) &nwtHeader[37],
sizeof(pGrd->dfMaxY) );
CPL_LSBPTR64(&pGrd->dfMaxY);
pGrd->dfStepSize = (pGrd->dfMaxX - pGrd->dfMinX) / (pGrd->nXSide - 1);
/* dfTmp = (pGrd->dfMaxY - pGrd->dfMinY) / (pGrd->nYSide - 1); */
memcpy( (void *) &pGrd->fZMin, (void *) &nwtHeader[45],
sizeof(pGrd->fZMin) );
CPL_LSBPTR32(&pGrd->fZMin);
memcpy( (void *) &pGrd->fZMax, (void *) &nwtHeader[49],
sizeof(pGrd->fZMax) );
CPL_LSBPTR32(&pGrd->fZMax);
memcpy( (void *) &pGrd->fZMinScale, (void *) &nwtHeader[53],
sizeof(pGrd->fZMinScale) );
CPL_LSBPTR32(&pGrd->fZMinScale);
memcpy( (void *) &pGrd->fZMaxScale, (void *) &nwtHeader[57],
sizeof(pGrd->fZMaxScale) );
CPL_LSBPTR32(&pGrd->fZMaxScale);
memcpy( (void *) &pGrd->cDescription, (void *) &nwtHeader[61],
sizeof(pGrd->cDescription) );
memcpy( (void *) &pGrd->cZUnits, (void *) &nwtHeader[93],
sizeof(pGrd->cZUnits) );
memcpy( (void *) &i, (void *) &nwtHeader[136], 4 );
CPL_LSBPTR32(&i);
if( i == 1129336130 )
{ //BMPC
if( nwtHeader[140] & 0x01 )
{
pGrd->cHillShadeBrightness = nwtHeader[144];
pGrd->cHillShadeContrast = nwtHeader[145];
}
}
memcpy( (void *) &pGrd->cMICoordSys, (void *) &nwtHeader[256],
sizeof(pGrd->cMICoordSys) );
pGrd->cMICoordSys[sizeof(pGrd->cMICoordSys)-1] = '\0';
pGrd->iZUnits = nwtHeader[512];
if( nwtHeader[513] & 0x80 )
pGrd->bShowGradient = true;
if( nwtHeader[513] & 0x40 )
pGrd->bShowHillShade = true;
if( nwtHeader[513] & 0x20 )
pGrd->bHillShadeExists = true;
memcpy( (void *) &pGrd->iNumColorInflections, (void *) &nwtHeader[516],
2 );
CPL_LSBPTR16(&pGrd->iNumColorInflections);
if (pGrd->iNumColorInflections > 32)
{
CPLError(CE_Failure, CPLE_AppDefined, "Corrupt header");
pGrd->iNumColorInflections = (unsigned short)i;
return FALSE;
}
for( i = 0; i < pGrd->iNumColorInflections; i++ )
{
memcpy( (void *) &pGrd->stInflection[i].zVal,
(void *) &nwtHeader[518 + (7 * i)], 4 );
CPL_LSBPTR32(&pGrd->stInflection[i].zVal);
memcpy( (void *) &pGrd->stInflection[i].r,
(void *) &nwtHeader[522 + (7 * i)], 1 );
memcpy( (void *) &pGrd->stInflection[i].g,
(void *) &nwtHeader[523 + (7 * i)], 1 );
memcpy( (void *) &pGrd->stInflection[i].b,
(void *) &nwtHeader[524 + (7 * i)], 1 );
}
memcpy( (void *) &pGrd->fHillShadeAzimuth, (void *) &nwtHeader[966],
sizeof(pGrd->fHillShadeAzimuth) );
CPL_LSBPTR32(&pGrd->fHillShadeAzimuth);
memcpy( (void *) &pGrd->fHillShadeAngle, (void *) &nwtHeader[970],
sizeof(pGrd->fHillShadeAngle) );
CPL_LSBPTR32(&pGrd->fHillShadeAngle);
pGrd->cFormat += nwtHeader[1023]; // the msb for grd/grc was already set
// there are more types than this - need to build other types for testing
if( pGrd->cFormat & 0x80 )
{
if( nwtHeader[1023] == 0 )
pGrd->nBitsPerPixel = 16;
else
pGrd->nBitsPerPixel = nwtHeader[1023] * 4;
}
else
pGrd->nBitsPerPixel = nwtHeader[1023] * 8;
if( pGrd->cFormat & 0x80 ) // if is GRC load the Dictionary
{
VSIFSeekL( pGrd->fp,
1024 + (pGrd->nXSide * pGrd->nYSide) * (pGrd->nBitsPerPixel/8),
SEEK_SET );
if( !VSIFReadL( &usTmp, 2, 1, pGrd->fp) )
{
CPLError( CE_Failure, CPLE_FileIO,
"Read failure, file short?" );
return FALSE;
}
CPL_LSBPTR16(&usTmp);
pGrd->stClassDict =
(NWT_CLASSIFIED_DICT *) calloc( sizeof(NWT_CLASSIFIED_DICT), 1 );
pGrd->stClassDict->nNumClassifiedItems = usTmp;
pGrd->stClassDict->stClassifedItem =
(NWT_CLASSIFIED_ITEM **) calloc( sizeof(NWT_CLASSIFIED_ITEM *),
pGrd->
stClassDict->nNumClassifiedItems +
1 );
//load the dictionary
for( usTmp=0; usTmp < pGrd->stClassDict->nNumClassifiedItems; usTmp++ )
{
NWT_CLASSIFIED_ITEM *psItem =
pGrd->stClassDict->stClassifedItem[usTmp] =
(NWT_CLASSIFIED_ITEM *) calloc(sizeof(NWT_CLASSIFIED_ITEM), 1);
if( !VSIFReadL( &cTmp, 9, 1, pGrd->fp ) )
{
CPLError( CE_Failure, CPLE_FileIO,
"Read failure, file short?" );
return FALSE;
}
memcpy( (void *) &psItem->usPixVal, (void *) &cTmp[0], 2 );
CPL_LSBPTR16(&psItem->usPixVal);
memcpy( (void *) &psItem->res1,
(void *) &cTmp[2], 1 );
memcpy( (void *) &psItem->r,
(void *) &cTmp[3], 1 );
memcpy( (void *) &psItem->g,
(void *) &cTmp[4], 1 );
memcpy( (void *) &psItem->b,
(void *) &cTmp[5], 1 );
memcpy( (void *) &psItem->res2,
(void *) &cTmp[6], 1 );
memcpy( (void *) &psItem->usLen,
(void *) &cTmp[7], 2 );
CPL_LSBPTR16(&psItem->usLen);
if ( psItem->usLen > sizeof(psItem->szClassName)-1 )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Unexpected long class name, %d characters long - unable to read file.",
psItem->usLen );
return FALSE;
}
if( !VSIFReadL( &psItem->szClassName, psItem->usLen, 1, pGrd->fp ) )
return FALSE;
}
}
return TRUE;
}
void LANDataset::CheckForStatistics()
{
/* -------------------------------------------------------------------- */
/* Do we have a statistics file? */
/* -------------------------------------------------------------------- */
osSTAFilename = CPLResetExtension(GetDescription(),"sta");
FILE *fpSTA = VSIFOpenL( osSTAFilename, "r" );
#ifndef WIN32
if( fpSTA == NULL )
{
osSTAFilename = CPLResetExtension(GetDescription(),"STA");
fpSTA = VSIFOpenL( osSTAFilename, "r" );
}
#endif
if( fpSTA == NULL )
{
osSTAFilename = "";
return;
}
/* -------------------------------------------------------------------- */
/* Read it one band at a time. */
/* -------------------------------------------------------------------- */
GByte abyBandInfo[1152];
int iBand;
for( iBand = 0; iBand < nBands; iBand++ )
{
if( VSIFReadL( abyBandInfo, 1152, 1, fpSTA ) != 1 )
break;
int nBandNumber = abyBandInfo[7];
GDALRasterBand *poBand = GetRasterBand(nBandNumber);
if( poBand == NULL )
break;
float fMean, fStdDev;
GInt16 nMin, nMax;
if( poBand->GetRasterDataType() != GDT_Byte )
{
memcpy( &nMin, abyBandInfo + 28, 2 );
memcpy( &nMax, abyBandInfo + 30, 2 );
CPL_LSBPTR16( &nMin );
CPL_LSBPTR16( &nMax );
}
else
{
nMin = abyBandInfo[9];
nMax = abyBandInfo[8];
}
memcpy( &fMean, abyBandInfo + 12, 4 );
memcpy( &fStdDev, abyBandInfo + 24, 4 );
CPL_LSBPTR32( &fMean );
CPL_LSBPTR32( &fStdDev );
poBand->SetStatistics( nMin, nMax, fMean, fStdDev );
}
VSIFCloseL( fpSTA );
}
