GDALDataset* HF2Dataset::CreateCopy( const char * pszFilename,
GDALDataset *poSrcDS,
int bStrict, char ** papszOptions,
GDALProgressFunc pfnProgress,
void * pProgressData )
{
/* -------------------------------------------------------------------- */
/* Some some rudimentary checks */
/* -------------------------------------------------------------------- */
int nBands = poSrcDS->GetRasterCount();
if (nBands == 0)
{
CPLError( CE_Failure, CPLE_NotSupported,
"HF2 driver does not support source dataset with zero band.\n");
return NULL;
}
if (nBands != 1)
{
CPLError( (bStrict) ? CE_Failure : CE_Warning, CPLE_NotSupported,
"HF2 driver only uses the first band of the dataset.\n");
if (bStrict)
return NULL;
}
if( pfnProgress && !pfnProgress( 0.0, NULL, pProgressData ) )
return NULL;
/* -------------------------------------------------------------------- */
/* Get source dataset info */
/* -------------------------------------------------------------------- */
int nXSize = poSrcDS->GetRasterXSize();
int nYSize = poSrcDS->GetRasterYSize();
double adfGeoTransform[6];
poSrcDS->GetGeoTransform(adfGeoTransform);
int bHasGeoTransform = !(adfGeoTransform[0] == 0 &&
adfGeoTransform[1] == 1 &&
adfGeoTransform[2] == 0 &&
adfGeoTransform[3] == 0 &&
adfGeoTransform[4] == 0 &&
adfGeoTransform[5] == 1);
if (adfGeoTransform[2] != 0 || adfGeoTransform[4] != 0)
{
CPLError( CE_Failure, CPLE_NotSupported,
"HF2 driver does not support CreateCopy() from skewed or rotated dataset.\n");
return NULL;
}
GDALDataType eSrcDT = poSrcDS->GetRasterBand(1)->GetRasterDataType();
GDALDataType eReqDT;
float fVertPres = (float) 0.01;
if (eSrcDT == GDT_Byte || eSrcDT == GDT_Int16)
{
fVertPres = 1;
eReqDT = GDT_Int16;
}
else
eReqDT = GDT_Float32;
/* -------------------------------------------------------------------- */
/* Read creation options */
/* -------------------------------------------------------------------- */
const char* pszCompressed = CSLFetchNameValue(papszOptions, "COMPRESS");
int bCompress = FALSE;
if (pszCompressed)
bCompress = CSLTestBoolean(pszCompressed);
const char* pszVerticalPrecision = CSLFetchNameValue(papszOptions, "VERTICAL_PRECISION");
if (pszVerticalPrecision)
{
fVertPres = (float) CPLAtofM(pszVerticalPrecision);
if (fVertPres <= 0)
{
CPLError(CE_Warning, CPLE_AppDefined,
"Unsupported value for VERTICAL_PRECISION. Defaulting to 0.01");
fVertPres = (float) 0.01;
}
if (eReqDT == GDT_Int16 && fVertPres > 1)
eReqDT = GDT_Float32;
}
const char* pszBlockSize = CSLFetchNameValue(papszOptions, "BLOCKSIZE");
int nTileSize = 256;
if (pszBlockSize)
{
nTileSize = atoi(pszBlockSize);
if (nTileSize < 8 || nTileSize > 4096)
{
CPLError(CE_Warning, CPLE_AppDefined,
"Unsupported value for BLOCKSIZE. Defaulting to 256");
nTileSize = 256;
}
}
/* -------------------------------------------------------------------- */
/* Parse source dataset georeferencing info */
/* -------------------------------------------------------------------- */
int nExtendedHeaderLen = 0;
if (bHasGeoTransform)
nExtendedHeaderLen += 58;
const char* pszProjectionRef = poSrcDS->GetProjectionRef();
int nDatumCode = -2;
int nUTMZone = 0;
int bNorth = FALSE;
int nEPSGCode = 0;
int nExtentUnits = 1;
if (pszProjectionRef != NULL && pszProjectionRef[0] != '\0')
{
OGRSpatialReference oSRS;
char* pszTemp = (char*) pszProjectionRef;
if (oSRS.importFromWkt(&pszTemp) == OGRERR_NONE)
{
const char* pszValue = NULL;
if( oSRS.GetAuthorityName( "GEOGCS|DATUM" ) != NULL
&& EQUAL(oSRS.GetAuthorityName( "GEOGCS|DATUM" ),"EPSG") )
nDatumCode = atoi(oSRS.GetAuthorityCode( "GEOGCS|DATUM" ));
else if ((pszValue = oSRS.GetAttrValue("GEOGCS|DATUM")) != NULL)
{
if (strstr(pszValue, "WGS") && strstr(pszValue, "84"))
nDatumCode = 6326;
}
nUTMZone = oSRS.GetUTMZone(&bNorth);
}
if( oSRS.GetAuthorityName( "PROJCS" ) != NULL
&& EQUAL(oSRS.GetAuthorityName( "PROJCS" ),"EPSG") )
nEPSGCode = atoi(oSRS.GetAuthorityCode( "PROJCS" ));
if( oSRS.IsGeographic() )
{
nExtentUnits = 0;
}
else
{
double dfLinear = oSRS.GetLinearUnits();
if( ABS(dfLinear - 0.3048) < 0.0000001 )
nExtentUnits = 2;
else if( ABS(dfLinear - CPLAtof(SRS_UL_US_FOOT_CONV)) < 0.00000001 )
nExtentUnits = 3;
else
nExtentUnits = 1;
}
}
if (nDatumCode != -2)
nExtendedHeaderLen += 26;
if (nUTMZone != 0)
nExtendedHeaderLen += 26;
if (nEPSGCode)
nExtendedHeaderLen += 26;
/* -------------------------------------------------------------------- */
/* Create target file */
/* -------------------------------------------------------------------- */
CPLString osFilename;
if (bCompress)
{
osFilename = "/vsigzip/";
osFilename += pszFilename;
}
else
osFilename = pszFilename;
VSILFILE* fp = VSIFOpenL(osFilename.c_str(), "wb");
if (fp == NULL)
{
CPLError( CE_Failure, CPLE_AppDefined,
"Cannot create %s", pszFilename );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Write header */
/* -------------------------------------------------------------------- */
VSIFWriteL("HF2\0", 4, 1, fp);
WriteShort(fp, 0);
WriteInt(fp, nXSize);
WriteInt(fp, nYSize);
WriteShort(fp, (GInt16) nTileSize);
WriteFloat(fp, fVertPres);
float fHorizScale = (float) ((fabs(adfGeoTransform[1]) + fabs(adfGeoTransform[5])) / 2);
WriteFloat(fp, fHorizScale);
WriteInt(fp, nExtendedHeaderLen);
/* -------------------------------------------------------------------- */
/* Write extended header */
/* -------------------------------------------------------------------- */
char szBlockName[16 + 1];
if (bHasGeoTransform)
{
VSIFWriteL("bin\0", 4, 1, fp);
memset(szBlockName, 0, 16 + 1);
strcpy(szBlockName, "georef-extents");
VSIFWriteL(szBlockName, 16, 1, fp);
WriteInt(fp, 34);
WriteShort(fp, (GInt16) nExtentUnits);
WriteDouble(fp, adfGeoTransform[0]);
WriteDouble(fp, adfGeoTransform[0] + nXSize * adfGeoTransform[1]);
WriteDouble(fp, adfGeoTransform[3] + nYSize * adfGeoTransform[5]);
WriteDouble(fp, adfGeoTransform[3]);
}
if (nUTMZone != 0)
{
VSIFWriteL("bin\0", 4, 1, fp);
memset(szBlockName, 0, 16 + 1);
strcpy(szBlockName, "georef-utm");
VSIFWriteL(szBlockName, 16, 1, fp);
WriteInt(fp, 2);
WriteShort(fp, (GInt16) ((bNorth) ? nUTMZone : -nUTMZone));
}
if (nDatumCode != -2)
{
VSIFWriteL("bin\0", 4, 1, fp);
memset(szBlockName, 0, 16 + 1);
strcpy(szBlockName, "georef-datum");
VSIFWriteL(szBlockName, 16, 1, fp);
WriteInt(fp, 2);
WriteShort(fp, (GInt16) nDatumCode);
}
if (nEPSGCode != 0)
{
VSIFWriteL("bin\0", 4, 1, fp);
memset(szBlockName, 0, 16 + 1);
strcpy(szBlockName, "georef-epsg-prj");
VSIFWriteL(szBlockName, 16, 1, fp);
WriteInt(fp, 2);
WriteShort(fp, (GInt16) nEPSGCode);
}
/* -------------------------------------------------------------------- */
/* Copy imagery */
/* -------------------------------------------------------------------- */
int nXBlocks = (nXSize + nTileSize - 1) / nTileSize;
int nYBlocks = (nYSize + nTileSize - 1) / nTileSize;
void* pTileBuffer = (void*) VSIMalloc(nTileSize * nTileSize * (GDALGetDataTypeSize(eReqDT) / 8));
if (pTileBuffer == NULL)
{
CPLError( CE_Failure, CPLE_OutOfMemory, "Out of memory");
VSIFCloseL(fp);
return NULL;
}
int i, j, k, l;
CPLErr eErr = CE_None;
for(j=0;j<nYBlocks && eErr == CE_None;j++)
{
for(i=0;i<nXBlocks && eErr == CE_None;i++)
{
int nReqXSize = MIN(nTileSize, nXSize - i * nTileSize);
int nReqYSize = MIN(nTileSize, nYSize - j * nTileSize);
eErr = poSrcDS->GetRasterBand(1)->RasterIO(GF_Read,
i * nTileSize, MAX(0, nYSize - (j + 1) * nTileSize),
nReqXSize, nReqYSize,
pTileBuffer, nReqXSize, nReqYSize,
eReqDT, 0, 0, NULL);
if (eErr != CE_None)
break;
if (eReqDT == GDT_Int16)
{
WriteFloat(fp, 1); /* scale */
WriteFloat(fp, 0); /* offset */
for(k=0;k<nReqYSize;k++)
{
int nLastVal = ((short*)pTileBuffer)[(nReqYSize - k - 1) * nReqXSize + 0];
GByte nWordSize = 1;
for(l=1;l<nReqXSize;l++)
{
int nVal = ((short*)pTileBuffer)[(nReqYSize - k - 1) * nReqXSize + l];
int nDiff = nVal - nLastVal;
if (nDiff < -32768 || nDiff > 32767)
{
nWordSize = 4;
break;
}
if (nDiff < -128 || nDiff > 127)
nWordSize = 2;
nLastVal = nVal;
}
VSIFWriteL(&nWordSize, 1, 1, fp);
nLastVal = ((short*)pTileBuffer)[(nReqYSize - k - 1) * nReqXSize + 0];
WriteInt(fp, nLastVal);
for(l=1;l<nReqXSize;l++)
{
int nVal = ((short*)pTileBuffer)[(nReqYSize - k - 1) * nReqXSize + l];
int nDiff = nVal - nLastVal;
if (nWordSize == 1)
{
CPLAssert(nDiff >= -128 && nDiff <= 127);
signed char chDiff = (signed char)nDiff;
VSIFWriteL(&chDiff, 1, 1, fp);
}
else if (nWordSize == 2)
{
CPLAssert(nDiff >= -32768 && nDiff <= 32767);
WriteShort(fp, (short)nDiff);
}
else
{
WriteInt(fp, nDiff);
}
nLastVal = nVal;
}
}
}
else
{
float fMinVal = ((float*)pTileBuffer)[0];
float fMaxVal = fMinVal;
for(k=1;k<nReqYSize*nReqXSize;k++)
{
float fVal = ((float*)pTileBuffer)[k];
if (fVal < fMinVal) fMinVal = fVal;
if (fVal > fMaxVal) fMaxVal = fVal;
}
float fIntRange = (fMaxVal - fMinVal) / fVertPres;
float fScale = (fMinVal == fMaxVal) ? 1 : (fMaxVal - fMinVal) / fIntRange;
float fOffset = fMinVal;
WriteFloat(fp, fScale); /* scale */
WriteFloat(fp, fOffset); /* offset */
for(k=0;k<nReqYSize;k++)
{
float fLastVal = ((float*)pTileBuffer)[(nReqYSize - k - 1) * nReqXSize + 0];
float fIntLastVal = (fLastVal - fOffset) / fScale;
CPLAssert(fIntLastVal >= -2147483648.0f && fIntLastVal <= 2147483647.0f);
int nLastVal = (int)fIntLastVal;
GByte nWordSize = 1;
for(l=1;l<nReqXSize;l++)
{
float fVal = ((float*)pTileBuffer)[(nReqYSize - k - 1) * nReqXSize + l];
float fIntVal = (fVal - fOffset) / fScale;
CPLAssert(fIntVal >= -2147483648.0f && fIntVal <= 2147483647.0f);
int nVal = (int)fIntVal;
int nDiff = nVal - nLastVal;
CPLAssert((int)((GIntBig)nVal - nLastVal) == nDiff);
if (nDiff < -32768 || nDiff > 32767)
{
nWordSize = 4;
break;
}
if (nDiff < -128 || nDiff > 127)
nWordSize = 2;
nLastVal = nVal;
}
VSIFWriteL(&nWordSize, 1, 1, fp);
fLastVal = ((float*)pTileBuffer)[(nReqYSize - k - 1) * nReqXSize + 0];
fIntLastVal = (fLastVal - fOffset) / fScale;
nLastVal = (int)fIntLastVal;
WriteInt(fp, nLastVal);
for(l=1;l<nReqXSize;l++)
{
float fVal = ((float*)pTileBuffer)[(nReqYSize - k - 1) * nReqXSize + l];
float fIntVal = (fVal - fOffset) / fScale;
int nVal = (int)fIntVal;
int nDiff = nVal - nLastVal;
CPLAssert((int)((GIntBig)nVal - nLastVal) == nDiff);
if (nWordSize == 1)
{
CPLAssert(nDiff >= -128 && nDiff <= 127);
signed char chDiff = (signed char)nDiff;
VSIFWriteL(&chDiff, 1, 1, fp);
}
else if (nWordSize == 2)
{
CPLAssert(nDiff >= -32768 && nDiff <= 32767);
WriteShort(fp, (short)nDiff);
}
else
{
WriteInt(fp, nDiff);
}
nLastVal = nVal;
}
}
}
if( pfnProgress && !pfnProgress( (j * nXBlocks + i + 1) * 1.0 / (nXBlocks * nYBlocks), NULL, pProgressData ) )
{
eErr = CE_Failure;
break;
}
}
}
CPLFree(pTileBuffer);
VSIFCloseL(fp);
if (eErr != CE_None)
return NULL;
return (GDALDataset*) GDALOpen(osFilename.c_str(), GA_ReadOnly);
}
void ROIPACDataset::FlushCache( void )
{
RawDataset::FlushCache();
GDALRasterBand *band = (GetRasterCount() > 0) ? GetRasterBand(1) : NULL;
if ( eAccess == GA_ReadOnly || band == NULL )
return;
// If opening an existing file in Update mode (i.e. "r+") we need to make
// sure any existing content is cleared, otherwise the file may contain
// trailing content from the previous write.
CPL_IGNORE_RET_VAL(VSIFTruncateL( fpRsc, 0 ));
CPL_IGNORE_RET_VAL(VSIFSeekL( fpRsc, 0, SEEK_SET ));
/* -------------------------------------------------------------------- */
/* Rewrite out the header. */
/* -------------------------------------------------------------------- */
/* -------------------------------------------------------------------- */
/* Raster dimensions. */
/* -------------------------------------------------------------------- */
CPL_IGNORE_RET_VAL(VSIFPrintfL( fpRsc, "%-40s %d\n", "WIDTH", nRasterXSize ));
CPL_IGNORE_RET_VAL(VSIFPrintfL( fpRsc, "%-40s %d\n", "FILE_LENGTH", nRasterYSize ));
/* -------------------------------------------------------------------- */
/* Georeferencing. */
/* -------------------------------------------------------------------- */
if ( pszProjection != NULL )
{
char *pszProjectionTmp = pszProjection;
OGRSpatialReference oSRS;
if( oSRS.importFromWkt( &pszProjectionTmp ) == OGRERR_NONE )
{
int bNorth;
int iUTMZone = oSRS.GetUTMZone( &bNorth );
if ( iUTMZone != 0 )
{
CPL_IGNORE_RET_VAL(VSIFPrintfL( fpRsc, "%-40s %s%d\n", "PROJECTION", "UTM", iUTMZone ));
}
else if ( oSRS.IsGeographic() )
{
CPL_IGNORE_RET_VAL(VSIFPrintfL( fpRsc, "%-40s %s\n", "PROJECTION", "LL" ));
}
else
{
CPLError( CE_Warning, CPLE_AppDefined,
"ROI_PAC format only support Latitude/Longitude and "
"UTM projections, discarding projection.");
}
if ( oSRS.GetAttrValue( "DATUM" ) != NULL )
{
if ( strcmp( oSRS.GetAttrValue( "DATUM" ), "WGS_1984" ) == 0 )
{
CPL_IGNORE_RET_VAL(VSIFPrintfL( fpRsc, "%-40s %s\n", "DATUM", "WGS84" ));
}
else
{
CPLError( CE_Warning, CPLE_AppDefined,
"Datum \"%s\" probably not supported in the "
"ROI_PAC format, saving it anyway",
oSRS.GetAttrValue( "DATUM" ) );
CPL_IGNORE_RET_VAL(VSIFPrintfL( fpRsc, "%-40s %s\n", "DATUM", oSRS.GetAttrValue( "DATUM" ) ));
}
}
if ( oSRS.GetAttrValue( "UNIT" ) != NULL )
{
CPL_IGNORE_RET_VAL(VSIFPrintfL( fpRsc, "%-40s %s\n", "X_UNIT", oSRS.GetAttrValue( "UNIT" ) ));
CPL_IGNORE_RET_VAL(VSIFPrintfL( fpRsc, "%-40s %s\n", "Y_UNIT", oSRS.GetAttrValue( "UNIT" ) ));
}
}
}
if( bValidGeoTransform )
{
if ( adfGeoTransform[2] != 0 || adfGeoTransform[4] != 0 )
{
CPLError( CE_Warning, CPLE_AppDefined,
"ROI_PAC format do not support geotransform with "
"rotation, discarding info.");
}
else
{
CPL_IGNORE_RET_VAL(VSIFPrintfL( fpRsc, "%-40s %.16g\n", "X_FIRST", adfGeoTransform[0] ));
CPL_IGNORE_RET_VAL(VSIFPrintfL( fpRsc, "%-40s %.16g\n", "X_STEP", adfGeoTransform[1] ));
CPL_IGNORE_RET_VAL(VSIFPrintfL( fpRsc, "%-40s %.16g\n", "Y_FIRST", adfGeoTransform[3] ));
CPL_IGNORE_RET_VAL(VSIFPrintfL( fpRsc, "%-40s %.16g\n", "Y_STEP", adfGeoTransform[5] ));
CPL_IGNORE_RET_VAL(VSIFPrintfL( fpRsc, "%-40s %.16g\n", "Z_OFFSET", band->GetOffset(NULL) ));
CPL_IGNORE_RET_VAL(VSIFPrintfL( fpRsc, "%-40s %.16g\n", "Z_SCALE", band->GetScale(NULL) ));
}
}
/* -------------------------------------------------------------------- */
/* Metadata stored in the ROI_PAC domain. */
/* -------------------------------------------------------------------- */
char** papszROIPACMetadata = GetMetadata( "ROI_PAC" );
for (int i = 0; i < CSLCount( papszROIPACMetadata ); i++)
{
/* Get the tokens from the metadata item */
char **papszTokens = CSLTokenizeString2( papszROIPACMetadata[i],
"=",
CSLT_STRIPLEADSPACES
| CSLT_STRIPENDSPACES);
if ( CSLCount( papszTokens ) != 2 )
{
CPLDebug("ROI_PAC",
"Line of header file could not be split at = into two elements: %s",
papszROIPACMetadata[i]);
CSLDestroy( papszTokens );
continue;
}
/* Don't write it out if it is one of the bits of metadata that is
* written out elsewhere in this routine */
if ( strcmp( papszTokens[0], "WIDTH" ) == 0
|| strcmp( papszTokens[0], "FILE_LENGTH" ) == 0 )
{
CSLDestroy( papszTokens );
continue;
}
CPL_IGNORE_RET_VAL(VSIFPrintfL( fpRsc, "%-40s %s\n", papszTokens[0], papszTokens[1] ));
CSLDestroy( papszTokens );
}
}