GDALDataset *GSAGDataset::CreateCopy( const char *pszFilename,
GDALDataset *poSrcDS,
int bStrict,
CPL_UNUSED char **papszOptions,
GDALProgressFunc pfnProgress,
void *pProgressData )
{
if( pfnProgress == NULL )
pfnProgress = GDALDummyProgress;
int nBands = poSrcDS->GetRasterCount();
if (nBands == 0)
{
CPLError( CE_Failure, CPLE_NotSupported,
"GSAG driver does not support source dataset with zero band.\n");
return NULL;
}
else if (nBands > 1)
{
if( bStrict )
{
CPLError( CE_Failure, CPLE_NotSupported,
"Unable to create copy, Golden Software ASCII Grid "
"format only supports one raster band.\n" );
return NULL;
}
else
CPLError( CE_Warning, CPLE_NotSupported,
"Golden Software ASCII Grid format only supports one "
"raster band, first band will be copied.\n" );
}
if( !pfnProgress( 0.0, NULL, pProgressData ) )
{
CPLError( CE_Failure, CPLE_UserInterrupt, "User terminated\n" );
return NULL;
}
VSILFILE *fp = VSIFOpenL( pszFilename, "w+b" );
if( fp == NULL )
{
CPLError( CE_Failure, CPLE_OpenFailed,
"Attempt to create file '%s' failed.\n",
pszFilename );
return NULL;
}
int nXSize = poSrcDS->GetRasterXSize();
int nYSize = poSrcDS->GetRasterYSize();
double adfGeoTransform[6];
poSrcDS->GetGeoTransform( adfGeoTransform );
std::ostringstream ssHeader;
ssHeader.precision( nFIELD_PRECISION );
ssHeader.setf( std::ios::uppercase );
ssHeader << "DSAA\x0D\x0A";
ssHeader << nXSize << " " << nYSize << "\x0D\x0A";
ssHeader << adfGeoTransform[0] + adfGeoTransform[1] / 2 << " "
<< adfGeoTransform[1] * (nXSize - 0.5) + adfGeoTransform[0]
<< "\x0D\x0A";
ssHeader << adfGeoTransform[5] * (nYSize - 0.5) + adfGeoTransform[3] << " "
<< adfGeoTransform[3] + adfGeoTransform[5] / 2
<< "\x0D\x0A";
if( VSIFWriteL( (void *)ssHeader.str().c_str(), 1, ssHeader.str().length(),
fp ) != ssHeader.str().length() )
{
VSIFCloseL( fp );
CPLError( CE_Failure, CPLE_FileIO,
"Unable to create copy, writing header failed.\n" );
return NULL;
}
/* Save the location and write placeholders for the min/max Z value */
vsi_l_offset nRangeStart = VSIFTellL( fp );
const char *szDummyRange = "0.0000000000001 0.0000000000001\x0D\x0A";
size_t nDummyRangeLen = strlen( szDummyRange );
if( VSIFWriteL( (void *)szDummyRange, 1, nDummyRangeLen,
fp ) != nDummyRangeLen )
{
VSIFCloseL( fp );
CPLError( CE_Failure, CPLE_FileIO,
"Unable to create copy, writing header failed.\n" );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Copy band data. */
/* -------------------------------------------------------------------- */
double *pdfData = (double *)VSIMalloc2( nXSize, sizeof( double ) );
if( pdfData == NULL )
{
VSIFCloseL( fp );
CPLError( CE_Failure, CPLE_OutOfMemory,
"Unable to create copy, unable to allocate line buffer.\n" );
return NULL;
}
GDALRasterBand *poSrcBand = poSrcDS->GetRasterBand(1);
int bSrcHasNDValue;
double dfSrcNoDataValue = poSrcBand->GetNoDataValue( &bSrcHasNDValue );
double dfMin = DBL_MAX;
double dfMax = -DBL_MAX;
for( int iRow=0; iRow<nYSize; iRow++ )
{
CPLErr eErr = poSrcBand->RasterIO( GF_Read, 0, nYSize-iRow-1,
nXSize, 1, pdfData,
nXSize, 1, GDT_Float64, 0, 0, NULL );
if( eErr != CE_None )
{
VSIFCloseL( fp );
VSIFree( pdfData );
return NULL;
}
for( int iCol=0; iCol<nXSize; )
{
for( int iCount=0;
iCount<10 && iCol<nXSize;
iCount++, iCol++ )
{
double dfValue = pdfData[iCol];
if( bSrcHasNDValue && AlmostEqual( dfValue, dfSrcNoDataValue ) )
{
dfValue = dfNODATA_VALUE;
}
else
{
if( dfValue > dfMax )
dfMax = dfValue;
if( dfValue < dfMin )
dfMin = dfValue;
}
std::ostringstream ssOut;
ssOut.precision(nFIELD_PRECISION);
ssOut.setf( std::ios::uppercase );
ssOut << dfValue << " ";
CPLString sOut = ssOut.str();
if( VSIFWriteL( sOut.c_str(), 1, sOut.length(), fp )
!= sOut.length() )
{
VSIFCloseL( fp );
VSIFree( pdfData );
CPLError( CE_Failure, CPLE_FileIO,
"Unable to write grid cell. Disk full?\n" );
return NULL;
}
}
if( VSIFWriteL( (void *)"\x0D\x0A", 1, 2, fp ) != 2 )
{
VSIFCloseL( fp );
VSIFree( pdfData );
CPLError( CE_Failure, CPLE_FileIO,
"Unable to finish write of grid line. Disk full?\n" );
return NULL;
}
}
if( VSIFWriteL( (void *)"\x0D\x0A", 1, 2, fp ) != 2 )
{
VSIFCloseL( fp );
VSIFree( pdfData );
CPLError( CE_Failure, CPLE_FileIO,
"Unable to finish write of grid row. Disk full?\n" );
return NULL;
}
if( !pfnProgress( static_cast<double>(iRow + 1)/nYSize,
NULL, pProgressData ) )
{
VSIFCloseL( fp );
VSIFree( pdfData );
CPLError( CE_Failure, CPLE_UserInterrupt, "User terminated" );
return NULL;
}
}
VSIFree( pdfData );
/* write out the min and max values */
std::ostringstream ssRange;
ssRange.precision( nFIELD_PRECISION );
ssRange.setf( std::ios::uppercase );
ssRange << dfMin << " " << dfMax << "\x0D\x0A";
if( ssRange.str().length() != nDummyRangeLen )
{
int nShiftSize = ssRange.str().length() - nDummyRangeLen;
if( ShiftFileContents( fp, nRangeStart + nDummyRangeLen,
nShiftSize, "\x0D\x0A" ) != CE_None )
{
VSIFCloseL( fp );
CPLError( CE_Failure, CPLE_FileIO,
"Unable to shift file contents.\n" );
return NULL;
}
}
if( VSIFSeekL( fp, nRangeStart, SEEK_SET ) != 0 )
{
VSIFCloseL( fp );
CPLError( CE_Failure, CPLE_FileIO,
"Unable to seek to start of grid file copy.\n" );
return NULL;
}
if( VSIFWriteL( (void *)ssRange.str().c_str(), 1, ssRange.str().length(),
fp ) != ssRange.str().length() )
{
VSIFCloseL( fp );
CPLError( CE_Failure, CPLE_FileIO,
"Unable to write range information.\n" );
return NULL;
}
VSIFCloseL( fp );
GDALPamDataset *poDS = (GDALPamDataset *)GDALOpen( pszFilename,
GA_Update );
if (poDS)
{
poDS->CloneInfo( poSrcDS, GCIF_PAM_DEFAULT );
}
return poDS;
}
GDALDataset * SRTMHGTDataset::CreateCopy( const char * pszFilename, GDALDataset *poSrcDS,
int bStrict, char ** papszOptions,
GDALProgressFunc pfnProgress, void * pProgressData )
{
int nBands = poSrcDS->GetRasterCount();
int nXSize = poSrcDS->GetRasterXSize();
int nYSize = poSrcDS->GetRasterYSize();
if( pfnProgress && !pfnProgress( 0.0, NULL, pProgressData ) )
return NULL;
/* -------------------------------------------------------------------- */
/* Some some rudimentary checks */
/* -------------------------------------------------------------------- */
if (nBands == 0)
{
CPLError( CE_Failure, CPLE_NotSupported,
"SRTMHGT driver does not support source dataset with zero band.\n");
return NULL;
}
else if (nBands != 1)
{
CPLError( (bStrict) ? CE_Failure : CE_Warning, CPLE_NotSupported,
"SRTMHGT driver only uses the first band of the dataset.\n");
if (bStrict)
return NULL;
}
/* -------------------------------------------------------------------- */
/* Checks the input SRS */
/* -------------------------------------------------------------------- */
OGRSpatialReference ogrsr_input;
OGRSpatialReference ogrsr_wgs84;
char* c = (char*)poSrcDS->GetProjectionRef();
ogrsr_input.importFromWkt(&c);
ogrsr_wgs84.SetWellKnownGeogCS( "WGS84" );
if ( ogrsr_input.IsSameGeogCS(&ogrsr_wgs84) == FALSE)
{
CPLError( CE_Warning, CPLE_AppDefined,
"The source projection coordinate system is %s. Only WGS 84 is supported.\n"
"The SRTMHGT driver will generate a file as if the source was WGS 84 projection coordinate system.",
poSrcDS->GetProjectionRef() );
}
/* -------------------------------------------------------------------- */
/* Work out the LL origin. */
/* -------------------------------------------------------------------- */
int nLLOriginLat, nLLOriginLong;
double adfGeoTransform[6];
if (poSrcDS->GetGeoTransform( adfGeoTransform ) != CE_None)
{
CPLError( CE_Failure, CPLE_AppDefined,
"Source image must have a geo transform matrix.");
return NULL;
}
nLLOriginLat = (int)
floor(adfGeoTransform[3]
+ poSrcDS->GetRasterYSize() * adfGeoTransform[5] + 0.5);
nLLOriginLong = (int) floor(adfGeoTransform[0] + 0.5);
if (fabs(nLLOriginLat - (adfGeoTransform[3]
+ (poSrcDS->GetRasterYSize() - 0.5) * adfGeoTransform[5])) > 1e-10 ||
fabs(nLLOriginLong - (adfGeoTransform[0] + 0.5 * adfGeoTransform[1])) > 1e-10)
{
CPLError( CE_Warning, CPLE_AppDefined,
"The corner coordinates of the source are not properly "
"aligned on plain latitude/longitude boundaries.");
}
/* -------------------------------------------------------------------- */
/* Check image dimensions. */
/* -------------------------------------------------------------------- */
if (!((nXSize == 1201 && nYSize == 1201) || (nXSize == 3601 && nYSize == 3601)))
{
CPLError( CE_Failure, CPLE_AppDefined,
"Image dimensions should be 1201x1201 or 3601x3601.");
return NULL;
}
/* -------------------------------------------------------------------- */
/* Check filename. */
/* -------------------------------------------------------------------- */
char expectedFileName[12];
snprintf(expectedFileName, sizeof(expectedFileName), "%c%02d%c%03d.HGT",
(nLLOriginLat >= 0) ? 'N' : 'S',
(nLLOriginLat >= 0) ? nLLOriginLat : -nLLOriginLat,
(nLLOriginLong >= 0) ? 'E' : 'W',
(nLLOriginLong >= 0) ? nLLOriginLong : -nLLOriginLong);
if (!EQUAL(expectedFileName, CPLGetFilename(pszFilename)))
{
CPLError( CE_Warning, CPLE_AppDefined,
"Expected output filename is %s.", expectedFileName);
}
/* -------------------------------------------------------------------- */
/* Write output file. */
/* -------------------------------------------------------------------- */
VSILFILE* fp = VSIFOpenL(pszFilename, "wb");
if (fp == NULL)
{
CPLError( CE_Failure, CPLE_FileIO,
"Cannot create file %s", pszFilename );
return NULL;
}
GInt16* panData = (GInt16*) CPLMalloc(sizeof(GInt16) * nXSize);
GDALRasterBand* poSrcBand = poSrcDS->GetRasterBand(1);
int bSrcBandHasNoData;
double srcBandNoData = poSrcBand->GetNoDataValue(&bSrcBandHasNoData);
for( int iY = 0; iY < nYSize; iY++ )
{
poSrcBand->RasterIO( GF_Read, 0, iY, nXSize, 1,
(void *) panData, nXSize, 1,
GDT_Int16, 0, 0 );
/* Translate nodata values */
if (bSrcBandHasNoData && srcBandNoData != SRTMHG_NODATA_VALUE)
{
for( int iX = 0; iX < nXSize; iX++ )
{
if (panData[iX] == srcBandNoData)
panData[iX] = SRTMHG_NODATA_VALUE;
}
}
#ifdef CPL_LSB
GDALSwapWords(panData, 2, nXSize, 2);
#endif
if( VSIFWriteL( panData,sizeof(GInt16) * nXSize,1,fp ) != 1)
{
CPLError( CE_Failure, CPLE_FileIO,
"Failed to write line %d in SRTMHGT dataset.\n",
iY );
VSIFCloseL(fp);
CPLFree( panData );
return NULL;
}
if( pfnProgress && !pfnProgress((iY+1) / (double) nYSize, NULL, pProgressData ) )
{
CPLError( CE_Failure, CPLE_UserInterrupt,
"User terminated CreateCopy()" );
VSIFCloseL(fp);
CPLFree( panData );
return NULL;
}
}
CPLFree( panData );
VSIFCloseL(fp);
/* -------------------------------------------------------------------- */
/* Reopen and copy missing information into a PAM file. */
/* -------------------------------------------------------------------- */
GDALPamDataset *poDS = (GDALPamDataset *)
GDALOpen( pszFilename, GA_ReadOnly );
if( poDS )
poDS->CloneInfo( poSrcDS, GCIF_PAM_DEFAULT);
return poDS;
}
GDALDataset* ZMapDataset::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,
"ZMap driver does not support source dataset with zero band.\n");
return NULL;
}
if (nBands != 1)
{
CPLError( (bStrict) ? CE_Failure : CE_Warning, CPLE_NotSupported,
"ZMap 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();
if (nXSize == 1 || nYSize == 1)
{
return NULL;
}
double adfGeoTransform[6];
poSrcDS->GetGeoTransform(adfGeoTransform);
if (adfGeoTransform[2] != 0 || adfGeoTransform[4] != 0)
{
CPLError( CE_Failure, CPLE_NotSupported,
"ZMap driver does not support CreateCopy() from skewed or rotated dataset.\n");
return NULL;
}
/* -------------------------------------------------------------------- */
/* Create target file */
/* -------------------------------------------------------------------- */
VSILFILE* fp = VSIFOpenL(pszFilename, "wb");
if (fp == NULL)
{
CPLError( CE_Failure, CPLE_AppDefined,
"Cannot create %s", pszFilename );
return NULL;
}
int nFieldSize = 20;
int nValuesPerLine = 4;
int nDecimalCount = 7;
int bHasNoDataValue = FALSE;
double dfNoDataValue =
poSrcDS->GetRasterBand(1)->GetNoDataValue(&bHasNoDataValue);
if (!bHasNoDataValue)
dfNoDataValue = 1.e30;
VSIFPrintfL(fp, "!\n");
VSIFPrintfL(fp, "! Created by GDAL.\n");
VSIFPrintfL(fp, "!\n");
VSIFPrintfL(fp, "@GRID FILE, GRID, %d\n", nValuesPerLine);
WriteRightJustified(fp, nFieldSize, 10);
VSIFPrintfL(fp, ",");
WriteRightJustified(fp, dfNoDataValue, 10);
VSIFPrintfL(fp, ",");
WriteRightJustified(fp, "", 10);
VSIFPrintfL(fp, ",");
WriteRightJustified(fp, nDecimalCount, 10);
VSIFPrintfL(fp, ",");
WriteRightJustified(fp, 1, 10);
VSIFPrintfL(fp, "\n");
WriteRightJustified(fp, nYSize, 10);
VSIFPrintfL(fp, ",");
WriteRightJustified(fp, nXSize, 10);
VSIFPrintfL(fp, ",");
if (CSLTestBoolean(CPLGetConfigOption("ZMAP_PIXEL_IS_POINT", "FALSE")))
{
WriteRightJustified(fp, adfGeoTransform[0] + adfGeoTransform[1] / 2, 14, 7);
VSIFPrintfL(fp, ",");
WriteRightJustified(fp, adfGeoTransform[0] + adfGeoTransform[1] * nXSize -
adfGeoTransform[1] / 2, 14, 7);
VSIFPrintfL(fp, ",");
WriteRightJustified(fp, adfGeoTransform[3] + adfGeoTransform[5] * nYSize -
adfGeoTransform[5] / 2, 14, 7);
VSIFPrintfL(fp, ",");
WriteRightJustified(fp, adfGeoTransform[3] + adfGeoTransform[5] / 2, 14, 7);
}
else
{
WriteRightJustified(fp, adfGeoTransform[0], 14, 7);
VSIFPrintfL(fp, ",");
WriteRightJustified(fp, adfGeoTransform[0] + adfGeoTransform[1] * nXSize, 14, 7);
VSIFPrintfL(fp, ",");
WriteRightJustified(fp, adfGeoTransform[3] + adfGeoTransform[5] * nYSize, 14, 7);
VSIFPrintfL(fp, ",");
WriteRightJustified(fp, adfGeoTransform[3], 14, 7);
}
VSIFPrintfL(fp, "\n");
VSIFPrintfL(fp, "0.0, 0.0, 0.0\n");
VSIFPrintfL(fp, "@\n");
/* -------------------------------------------------------------------- */
/* Copy imagery */
/* -------------------------------------------------------------------- */
double* padfLineBuffer = (double*) CPLMalloc(nYSize * sizeof(double));
int i, j;
CPLErr eErr = CE_None;
for(i=0;i<nXSize && eErr == CE_None;i++)
{
eErr = poSrcDS->GetRasterBand(1)->RasterIO(
GF_Read, i, 0, 1, nYSize,
padfLineBuffer, 1, nYSize,
GDT_Float64, 0, 0);
if (eErr != CE_None)
break;
int bEOLPrinted = FALSE;
for(j=0;j<nYSize;j++)
{
WriteRightJustified(fp, padfLineBuffer[j], nFieldSize, nDecimalCount);
if (((j + 1) % nValuesPerLine) == 0)
{
bEOLPrinted = TRUE;
VSIFPrintfL(fp, "\n");
}
else
bEOLPrinted = FALSE;
}
if (!bEOLPrinted)
VSIFPrintfL(fp, "\n");
if (!pfnProgress( (j+1) * 1.0 / nYSize, NULL, pProgressData))
{
eErr = CE_Failure;
break;
}
}
CPLFree(padfLineBuffer);
VSIFCloseL(fp);
if (eErr != CE_None)
return NULL;
return (GDALDataset*) GDALOpen(pszFilename, GA_ReadOnly);
}
GDALDataset *GSBGDataset::CreateCopy( const char *pszFilename,
GDALDataset *poSrcDS,
int bStrict, char **papszOptions,
GDALProgressFunc pfnProgress,
void *pProgressData )
{
if( pfnProgress == NULL )
pfnProgress = GDALDummyProgress;
int nBands = poSrcDS->GetRasterCount();
if (nBands == 0)
{
CPLError( CE_Failure, CPLE_NotSupported,
"GSBG driver does not support source dataset with zero band.\n");
return NULL;
}
else if (nBands > 1)
{
if( bStrict )
{
CPLError( CE_Failure, CPLE_NotSupported,
"Unable to create copy, Golden Software Binary Grid "
"format only supports one raster band.\n" );
return NULL;
}
else
CPLError( CE_Warning, CPLE_NotSupported,
"Golden Software Binary Grid format only supports one "
"raster band, first band will be copied.\n" );
}
GDALRasterBand *poSrcBand = poSrcDS->GetRasterBand( 1 );
if( poSrcBand->GetXSize() > SHRT_MAX
|| poSrcBand->GetYSize() > SHRT_MAX )
{
CPLError( CE_Failure, CPLE_IllegalArg,
"Unable to create grid, Golden Software Binary Grid format "
"only supports sizes up to %dx%d. %dx%d not supported.\n",
SHRT_MAX, SHRT_MAX,
poSrcBand->GetXSize(), poSrcBand->GetYSize() );
return NULL;
}
if( !pfnProgress( 0.0, NULL, pProgressData ) )
{
CPLError( CE_Failure, CPLE_UserInterrupt, "User terminated\n" );
return NULL;
}
VSILFILE *fp = VSIFOpenL( pszFilename, "w+b" );
if( fp == NULL )
{
CPLError( CE_Failure, CPLE_OpenFailed,
"Attempt to create file '%s' failed.\n",
pszFilename );
return NULL;
}
GInt16 nXSize = poSrcBand->GetXSize();
GInt16 nYSize = poSrcBand->GetYSize();
double adfGeoTransform[6];
poSrcDS->GetGeoTransform( adfGeoTransform );
double dfMinX = adfGeoTransform[0] + adfGeoTransform[1] / 2;
double dfMaxX = adfGeoTransform[1] * (nXSize - 0.5) + adfGeoTransform[0];
double dfMinY = adfGeoTransform[5] * (nYSize - 0.5) + adfGeoTransform[3];
double dfMaxY = adfGeoTransform[3] + adfGeoTransform[5] / 2;
CPLErr eErr = WriteHeader( fp, nXSize, nYSize,
dfMinX, dfMaxX, dfMinY, dfMaxY, 0.0, 0.0 );
if( eErr != CE_None )
{
VSIFCloseL( fp );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Copy band data. */
/* -------------------------------------------------------------------- */
float *pfData = (float *)VSIMalloc2( nXSize, sizeof( float ) );
if( pfData == NULL )
{
VSIFCloseL( fp );
CPLError( CE_Failure, CPLE_OutOfMemory,
"Unable to create copy, unable to allocate line buffer.\n" );
return NULL;
}
int bSrcHasNDValue;
float fSrcNoDataValue = poSrcBand->GetNoDataValue( &bSrcHasNDValue );
double dfMinZ = DBL_MAX;
double dfMaxZ = -DBL_MAX;
for( GInt16 iRow = nYSize - 1; iRow >= 0; iRow-- )
{
eErr = poSrcBand->RasterIO( GF_Read, 0, iRow,
nXSize, 1, pfData,
nXSize, 1, GDT_Float32, 0, 0 );
if( eErr != CE_None )
{
VSIFCloseL( fp );
VSIFree( pfData );
return NULL;
}
for( int iCol=0; iCol<nXSize; iCol++ )
{
if( bSrcHasNDValue && pfData[iCol] == fSrcNoDataValue )
{
pfData[iCol] = fNODATA_VALUE;
}
else
{
if( pfData[iCol] > dfMaxZ )
dfMaxZ = pfData[iCol];
if( pfData[iCol] < dfMinZ )
dfMinZ = pfData[iCol];
}
CPL_LSBPTR32( pfData+iCol );
}
if( VSIFWriteL( (void *)pfData, 4, nXSize,
fp ) != static_cast<unsigned>(nXSize) )
{
VSIFCloseL( fp );
VSIFree( pfData );
CPLError( CE_Failure, CPLE_FileIO,
"Unable to write grid row. Disk full?\n" );
return NULL;
}
if( !pfnProgress( static_cast<double>(iRow)/nYSize,
NULL, pProgressData ) )
{
VSIFCloseL( fp );
VSIFree( pfData );
CPLError( CE_Failure, CPLE_UserInterrupt, "User terminated" );
return NULL;
}
}
VSIFree( pfData );
/* write out the min and max values */
eErr = WriteHeader( fp, nXSize, nYSize,
dfMinX, dfMaxX, dfMinY, dfMaxY, dfMinZ, dfMaxZ );
if( eErr != CE_None )
{
VSIFCloseL( fp );
return NULL;
}
VSIFCloseL( fp );
GDALPamDataset *poDstDS = (GDALPamDataset *)GDALOpen( pszFilename,
GA_Update );
if( poDstDS == NULL )
{
VSIUnlink( pszFilename );
CPLError( CE_Failure, CPLE_FileIO,
"Unable to open copy of dataset.\n" );
return NULL;
}
else if( dynamic_cast<GSBGDataset *>(poDstDS) == NULL )
{
VSIUnlink( pszFilename );
delete poDstDS;
CPLError( CE_Failure, CPLE_FileIO,
"Copy dataset not opened as Golden Surfer Binary Grid!?\n" );
return NULL;
}
GDALRasterBand *poDstBand = poSrcDS->GetRasterBand(1);
if( poDstBand == NULL )
{
VSIUnlink( pszFilename );
delete poDstDS;
CPLError( CE_Failure, CPLE_FileIO,
"Unable to open copy of raster band?\n" );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Attempt to copy metadata. */
/* -------------------------------------------------------------------- */
if( !bStrict )
CPLPushErrorHandler( CPLQuietErrorHandler );
/* non-zero transform 2 or 4 or negative 1 or 5 not supported natively */
/*if( adfGeoTransform[2] != 0.0 || adfGeoTransform[4] != 0.0
|| adfGeoTransform[1] < 0.0 || adfGeoTransform[5] < 0.0 )
poDstDS->GDALPamDataset::SetGeoTransform( adfGeoTransform );*/
const char *szProjectionRef = poSrcDS->GetProjectionRef();
if( *szProjectionRef != '\0' )
poDstDS->SetProjection( szProjectionRef );
char **pszMetadata = poSrcDS->GetMetadata();
if( pszMetadata != NULL )
poDstDS->SetMetadata( pszMetadata );
/* FIXME: Should the dataset description be copied as well, or is it
* always the file name? */
poDstBand->SetDescription( poSrcBand->GetDescription() );
int bSuccess;
double dfOffset = poSrcBand->GetOffset( &bSuccess );
if( bSuccess && dfOffset != 0.0 )
poDstBand->SetOffset( dfOffset );
double dfScale = poSrcBand->GetScale( &bSuccess );
if( bSuccess && dfScale != 1.0 )
poDstBand->SetScale( dfScale );
GDALColorInterp oColorInterp = poSrcBand->GetColorInterpretation();
if( oColorInterp != GCI_Undefined )
poDstBand->SetColorInterpretation( oColorInterp );
char **pszCatNames = poSrcBand->GetCategoryNames();
if( pszCatNames != NULL)
poDstBand->SetCategoryNames( pszCatNames );
GDALColorTable *poColorTable = poSrcBand->GetColorTable();
if( poColorTable != NULL )
poDstBand->SetColorTable( poColorTable );
if( !bStrict )
CPLPopErrorHandler();
return poDstDS;
}
GDALDataset* XYZDataset::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,
"XYZ driver does not support source dataset with zero band.\n");
return NULL;
}
if (nBands != 1)
{
CPLError( (bStrict) ? CE_Failure : CE_Warning, CPLE_NotSupported,
"XYZ 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);
if (adfGeoTransform[2] != 0 || adfGeoTransform[4] != 0)
{
CPLError( CE_Failure, CPLE_NotSupported,
"XYZ driver does not support CreateCopy() from skewed or rotated dataset.\n");
return NULL;
}
const GDALDataType eSrcDT = poSrcDS->GetRasterBand(1)->GetRasterDataType();
GDALDataType eReqDT;
if (eSrcDT == GDT_Byte || eSrcDT == GDT_Int16 ||
eSrcDT == GDT_UInt16 || eSrcDT == GDT_Int32)
eReqDT = GDT_Int32;
else
eReqDT = GDT_Float32;
/* -------------------------------------------------------------------- */
/* Create target file */
/* -------------------------------------------------------------------- */
VSILFILE* fp = VSIFOpenL(pszFilename, "wb");
if (fp == NULL)
{
CPLError( CE_Failure, CPLE_AppDefined,
"Cannot create %s", pszFilename );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Read creation options */
/* -------------------------------------------------------------------- */
const char* pszColSep =
CSLFetchNameValue(papszOptions, "COLUMN_SEPARATOR");
if (pszColSep == NULL)
pszColSep = " ";
else if (EQUAL(pszColSep, "COMMA"))
pszColSep = ",";
else if (EQUAL(pszColSep, "SPACE"))
pszColSep = " ";
else if (EQUAL(pszColSep, "SEMICOLON"))
pszColSep = ";";
else if (EQUAL(pszColSep, "\\t") || EQUAL(pszColSep, "TAB"))
pszColSep = "\t";
#ifdef DEBUG_VERBOSE
else
CPLDebug("XYZ", "Using raw column separator: '%s' ",
pszColSep);
#endif
const char* pszAddHeaderLine =
CSLFetchNameValue(papszOptions, "ADD_HEADER_LINE");
if (pszAddHeaderLine != NULL && CPLTestBool(pszAddHeaderLine))
{
VSIFPrintfL(fp, "X%sY%sZ\n", pszColSep, pszColSep);
}
/* -------------------------------------------------------------------- */
/* Copy imagery */
/* -------------------------------------------------------------------- */
void* pLineBuffer
= reinterpret_cast<void *>( CPLMalloc( nXSize * sizeof(int) ) );
CPLErr eErr = CE_None;
for( int j=0; j < nYSize && eErr == CE_None; j++ )
{
eErr = poSrcDS->GetRasterBand(1)->RasterIO(
GF_Read, 0, j, nXSize, 1,
pLineBuffer, nXSize, 1,
eReqDT, 0, 0, NULL);
if (eErr != CE_None)
break;
const double dfY = adfGeoTransform[3] + (j + 0.5) * adfGeoTransform[5];
CPLString osBuf;
for( int i = 0; i < nXSize; i++ )
{
const double dfX
= adfGeoTransform[0] + (i + 0.5) * adfGeoTransform[1];
char szBuf[256];
if (eReqDT == GDT_Int32)
CPLsnprintf(szBuf, sizeof(szBuf), "%.18g%c%.18g%c%d\n",
dfX, pszColSep[0], dfY, pszColSep[0],
reinterpret_cast<int *>( pLineBuffer )[i] );
else
CPLsnprintf(szBuf, sizeof(szBuf), "%.18g%c%.18g%c%.18g\n",
dfX, pszColSep[0], dfY, pszColSep[0],
reinterpret_cast<float *>( pLineBuffer )[i]);
osBuf += szBuf;
if( (i & 1023) == 0 || i == nXSize - 1 )
{
if ( VSIFWriteL( osBuf,
static_cast<int>( osBuf.size() ), 1, fp )
!= 1 )
{
eErr = CE_Failure;
CPLError( CE_Failure, CPLE_AppDefined,
"Write failed, disk full?\n" );
break;
}
osBuf = "";
}
}
if ( pfnProgress
&& !pfnProgress( (j+1) * 1.0 / nYSize, NULL, pProgressData ) )
{
eErr = CE_Failure;
break;
}
}
CPLFree(pLineBuffer);
VSIFCloseL(fp);
if (eErr != CE_None)
return NULL;
/* -------------------------------------------------------------------- */
/* We don't want to call GDALOpen() since it will be expensive, */
/* so we "hand prepare" an XYZ dataset referencing our file. */
/* -------------------------------------------------------------------- */
XYZDataset* poXYZ_DS = new XYZDataset();
poXYZ_DS->nRasterXSize = nXSize;
poXYZ_DS->nRasterYSize = nYSize;
poXYZ_DS->nBands = 1;
poXYZ_DS->SetBand( 1, new XYZRasterBand( poXYZ_DS, 1, eReqDT ) );
/* If writing to stdout, we can't reopen it --> silence warning */
CPLPushErrorHandler(CPLQuietErrorHandler);
poXYZ_DS->fp = VSIFOpenL( pszFilename, "rb" );
CPLPopErrorHandler();
memcpy( &(poXYZ_DS->adfGeoTransform), adfGeoTransform, sizeof(double)*6 );
poXYZ_DS->nXIndex = 0;
poXYZ_DS->nYIndex = 1;
poXYZ_DS->nZIndex = 2;
if( pszAddHeaderLine )
{
poXYZ_DS->nDataLineNum = 1;
poXYZ_DS->bHasHeaderLine = TRUE;
}
return poXYZ_DS;
}
static GDALDataset *
DTEDCreateCopy( const char * pszFilename, GDALDataset *poSrcDS,
int bStrict, char ** /* papszOptions */,
GDALProgressFunc pfnProgress, void *pProgressData)
{
/* -------------------------------------------------------------------- */
/* Some some rudimentary checks */
/* -------------------------------------------------------------------- */
const int nBands = poSrcDS->GetRasterCount();
if (nBands == 0)
{
CPLError( CE_Failure, CPLE_NotSupported,
"DTED driver does not support source dataset with zero band.\n");
return NULL;
}
if (nBands != 1)
{
CPLError( (bStrict) ? CE_Failure : CE_Warning, CPLE_NotSupported,
"DTED driver only uses the first band of the dataset.\n");
if (bStrict)
return NULL;
}
if( pfnProgress && !pfnProgress( 0.0, NULL, pProgressData ) )
return NULL;
/* -------------------------------------------------------------------- */
/* Work out the level. */
/* -------------------------------------------------------------------- */
int nLevel;
if( poSrcDS->GetRasterYSize() == 121 )
nLevel = 0;
else if( poSrcDS->GetRasterYSize() == 1201 )
nLevel = 1;
else if( poSrcDS->GetRasterYSize() == 3601 )
nLevel = 2;
else
{
CPLError( CE_Warning, CPLE_AppDefined,
"The source does not appear to be a properly formatted cell." );
nLevel = 1;
}
/* -------------------------------------------------------------------- */
/* Checks the input SRS */
/* -------------------------------------------------------------------- */
char* c = (char*)poSrcDS->GetProjectionRef();
OGRSpatialReference ogrsr_input;
ogrsr_input.importFromWkt(&c);
OGRSpatialReference ogrsr_wgs84;
ogrsr_wgs84.SetWellKnownGeogCS( "WGS84" );
if ( ogrsr_input.IsSameGeogCS(&ogrsr_wgs84) == FALSE)
{
CPLError( CE_Warning, CPLE_AppDefined,
"The source projection coordinate system is %s. Only WGS 84 is supported.\n"
"The DTED driver will generate a file as if the source was WGS 84 projection coordinate system.",
poSrcDS->GetProjectionRef() );
}
/* -------------------------------------------------------------------- */
/* Work out the LL origin. */
/* -------------------------------------------------------------------- */
double adfGeoTransform[6];
poSrcDS->GetGeoTransform( adfGeoTransform );
int nLLOriginLat = (int)
floor(adfGeoTransform[3]
+ poSrcDS->GetRasterYSize() * adfGeoTransform[5] + 0.5);
int nLLOriginLong = (int) floor(adfGeoTransform[0] + 0.5);
if (fabs(nLLOriginLat - (adfGeoTransform[3]
+ (poSrcDS->GetRasterYSize() - 0.5) * adfGeoTransform[5])) > 1e-10 ||
fabs(nLLOriginLong - (adfGeoTransform[0] + 0.5 * adfGeoTransform[1])) > 1e-10)
{
CPLError( CE_Warning, CPLE_AppDefined,
"The corner coordinates of the source are not properly "
"aligned on plain latitude/longitude boundaries.");
}
/* -------------------------------------------------------------------- */
/* Check horizontal source size. */
/* -------------------------------------------------------------------- */
int expectedXSize;
if( ABS(nLLOriginLat) >= 80 )
expectedXSize = (poSrcDS->GetRasterYSize() - 1) / 6 + 1;
else if( ABS(nLLOriginLat) >= 75 )
expectedXSize = (poSrcDS->GetRasterYSize() - 1) / 4 + 1;
else if( ABS(nLLOriginLat) >= 70 )
expectedXSize = (poSrcDS->GetRasterYSize() - 1) / 3 + 1;
else if( ABS(nLLOriginLat) >= 50 )
expectedXSize = (poSrcDS->GetRasterYSize() - 1) / 2 + 1;
else
expectedXSize = poSrcDS->GetRasterYSize();
if (poSrcDS->GetRasterXSize() != expectedXSize)
{
CPLError( CE_Warning, CPLE_AppDefined,
"The horizontal source size is not conformant with the one "
"expected by DTED Level %d at this latitude (%d pixels found instead of %d).", nLevel,
poSrcDS->GetRasterXSize(), expectedXSize);
}
/* -------------------------------------------------------------------- */
/* Create the output dted file. */
/* -------------------------------------------------------------------- */
const char *pszError
= DTEDCreate( pszFilename, nLevel, nLLOriginLat, nLLOriginLong );
if( pszError != NULL )
{
CPLError( CE_Failure, CPLE_AppDefined,
"%s", pszError );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Open the DTED file so we can output the data to it. */
/* -------------------------------------------------------------------- */
DTEDInfo *psDTED
= DTEDOpen( pszFilename, "rb+", FALSE );
if( psDTED == NULL )
return NULL;
/* -------------------------------------------------------------------- */
/* Read all the data in a single buffer. */
/* -------------------------------------------------------------------- */
GDALRasterBand *poSrcBand = poSrcDS->GetRasterBand( 1 );
GInt16 *panData = (GInt16 *)
VSI_MALLOC_VERBOSE(sizeof(GInt16) * psDTED->nXSize * psDTED->nYSize);
if (panData == NULL)
{
DTEDClose(psDTED);
return NULL;
}
for( int iY = 0; iY < psDTED->nYSize; iY++ )
{
if( poSrcBand->RasterIO( GF_Read, 0, iY, psDTED->nXSize, 1,
(void *) (panData + iY * psDTED->nXSize), psDTED->nXSize, 1,
GDT_Int16, 0, 0, NULL ) != CE_None )
{
DTEDClose( psDTED );
CPLFree( panData );
return NULL;
}
if( pfnProgress && !pfnProgress(0.5 * (iY+1) / (double) psDTED->nYSize, NULL, pProgressData ) )
{
CPLError( CE_Failure, CPLE_UserInterrupt,
"User terminated CreateCopy()" );
DTEDClose( psDTED );
CPLFree( panData );
return NULL;
}
}
int bSrcBandHasNoData;
double srcBandNoData = poSrcBand->GetNoDataValue(&bSrcBandHasNoData);
/* -------------------------------------------------------------------- */
/* Write all the profiles. */
/* -------------------------------------------------------------------- */
GInt16 anProfData[3601];
int dfNodataCount=0;
GByte iPartialCell;
for( int iProfile = 0; iProfile < psDTED->nXSize; iProfile++ )
{
for( int iY = 0; iY < psDTED->nYSize; iY++ )
{
anProfData[iY] = panData[iProfile + iY * psDTED->nXSize];
if ( bSrcBandHasNoData && anProfData[iY] == srcBandNoData)
{
anProfData[iY] = DTED_NODATA_VALUE;
dfNodataCount++;
}
else if ( anProfData[iY] == DTED_NODATA_VALUE )
dfNodataCount++;
}
DTEDWriteProfile( psDTED, iProfile, anProfData );
if( pfnProgress
&& !pfnProgress( 0.5 + 0.5 * (iProfile+1) / (double) psDTED->nXSize,
NULL, pProgressData ) )
{
CPLError( CE_Failure, CPLE_UserInterrupt,
"User terminated CreateCopy()" );
DTEDClose( psDTED );
CPLFree( panData );
return NULL;
}
}
CPLFree( panData );
/* -------------------------------------------------------------------- */
/* Partial cell indicator: 0 for complete coverage; 1-99 for incomplete */
/* -------------------------------------------------------------------- */
char szPartialCell[3];
if ( dfNodataCount == 0 )
iPartialCell = 0;
else
{
iPartialCell = (GByte)int(floor(100.0 -
(dfNodataCount*100.0/(psDTED->nXSize * psDTED->nYSize))));
if (iPartialCell < 1)
iPartialCell=1;
}
snprintf( szPartialCell, sizeof(szPartialCell), "%02d",iPartialCell);
DTEDSetMetadata(psDTED, DTEDMD_PARTIALCELL_DSI, szPartialCell);
/* -------------------------------------------------------------------- */
/* Try to copy any matching available metadata. */
/* -------------------------------------------------------------------- */
if( poSrcDS->GetMetadataItem( "DTED_VerticalAccuracy_UHL" ) != NULL )
DTEDSetMetadata( psDTED, DTEDMD_VERTACCURACY_UHL,
poSrcDS->GetMetadataItem( "DTED_VerticalAccuracy_UHL" ) );
if( poSrcDS->GetMetadataItem( "DTED_VerticalAccuracy_ACC" ) != NULL )
DTEDSetMetadata( psDTED, DTEDMD_VERTACCURACY_ACC,
poSrcDS->GetMetadataItem( "DTED_VerticalAccuracy_ACC" ) );
if( poSrcDS->GetMetadataItem( "DTED_SecurityCode_UHL" ) != NULL )
DTEDSetMetadata( psDTED, DTEDMD_SECURITYCODE_UHL,
poSrcDS->GetMetadataItem( "DTED_SecurityCode_UHL" ) );
if( poSrcDS->GetMetadataItem( "DTED_SecurityCode_DSI" ) != NULL )
DTEDSetMetadata( psDTED, DTEDMD_SECURITYCODE_DSI,
poSrcDS->GetMetadataItem( "DTED_SecurityCode_DSI" ) );
if( poSrcDS->GetMetadataItem( "DTED_UniqueRef_UHL" ) != NULL )
DTEDSetMetadata( psDTED, DTEDMD_UNIQUEREF_UHL,
poSrcDS->GetMetadataItem( "DTED_UniqueRef_UHL" ) );
if( poSrcDS->GetMetadataItem( "DTED_UniqueRef_DSI" ) != NULL )
DTEDSetMetadata( psDTED, DTEDMD_UNIQUEREF_DSI,
poSrcDS->GetMetadataItem( "DTED_UniqueRef_DSI" ) );
if( poSrcDS->GetMetadataItem( "DTED_DataEdition" ) != NULL )
DTEDSetMetadata( psDTED, DTEDMD_DATA_EDITION,
poSrcDS->GetMetadataItem( "DTED_DataEdition" ) );
if( poSrcDS->GetMetadataItem( "DTED_MatchMergeVersion" ) != NULL )
DTEDSetMetadata( psDTED, DTEDMD_MATCHMERGE_VERSION,
poSrcDS->GetMetadataItem( "DTED_MatchMergeVersion" ) );
if( poSrcDS->GetMetadataItem( "DTED_MaintenanceDate" ) != NULL )
DTEDSetMetadata( psDTED, DTEDMD_MAINT_DATE,
poSrcDS->GetMetadataItem( "DTED_MaintenanceDate" ) );
if( poSrcDS->GetMetadataItem( "DTED_MatchMergeDate" ) != NULL )
DTEDSetMetadata( psDTED, DTEDMD_MATCHMERGE_DATE,
poSrcDS->GetMetadataItem( "DTED_MatchMergeDate" ) );
if( poSrcDS->GetMetadataItem( "DTED_MaintenanceDescription" ) != NULL )
DTEDSetMetadata( psDTED, DTEDMD_MAINT_DESCRIPTION,
poSrcDS->GetMetadataItem( "DTED_MaintenanceDescription" ) );
if( poSrcDS->GetMetadataItem( "DTED_Producer" ) != NULL )
DTEDSetMetadata( psDTED, DTEDMD_PRODUCER,
poSrcDS->GetMetadataItem( "DTED_Producer" ) );
if( poSrcDS->GetMetadataItem( "DTED_VerticalDatum" ) != NULL )
DTEDSetMetadata( psDTED, DTEDMD_VERTDATUM,
poSrcDS->GetMetadataItem( "DTED_VerticalDatum" ) );
if( poSrcDS->GetMetadataItem( "DTED_HorizontalDatum" ) != NULL )
DTEDSetMetadata( psDTED, DTEDMD_HORIZDATUM,
poSrcDS->GetMetadataItem( "DTED_HorizontalDatum" ) );
if( poSrcDS->GetMetadataItem( "DTED_DigitizingSystem" ) != NULL )
DTEDSetMetadata( psDTED, DTEDMD_DIGITIZING_SYS,
poSrcDS->GetMetadataItem( "DTED_DigitizingSystem" ) );
if( poSrcDS->GetMetadataItem( "DTED_CompilationDate" ) != NULL )
DTEDSetMetadata( psDTED, DTEDMD_COMPILATION_DATE,
poSrcDS->GetMetadataItem( "DTED_CompilationDate" ) );
if( poSrcDS->GetMetadataItem( "DTED_HorizontalAccuracy" ) != NULL )
DTEDSetMetadata( psDTED, DTEDMD_HORIZACCURACY,
poSrcDS->GetMetadataItem( "DTED_HorizontalAccuracy" ) );
if( poSrcDS->GetMetadataItem( "DTED_RelHorizontalAccuracy" ) != NULL )
DTEDSetMetadata( psDTED, DTEDMD_REL_HORIZACCURACY,
poSrcDS->GetMetadataItem( "DTED_RelHorizontalAccuracy" ) );
if( poSrcDS->GetMetadataItem( "DTED_RelVerticalAccuracy" ) != NULL )
DTEDSetMetadata( psDTED, DTEDMD_REL_VERTACCURACY,
poSrcDS->GetMetadataItem( "DTED_RelVerticalAccuracy" ) );
/* -------------------------------------------------------------------- */
/* Try to open the resulting DTED file. */
/* -------------------------------------------------------------------- */
DTEDClose( psDTED );
/* -------------------------------------------------------------------- */
/* Reopen and copy missing information into a PAM file. */
/* -------------------------------------------------------------------- */
GDALPamDataset *poDS = (GDALPamDataset *)
GDALOpen( pszFilename, GA_ReadOnly );
if( poDS )
poDS->CloneInfo( poSrcDS, GCIF_PAM_DEFAULT );
return poDS;
}
GDALDataset *
EpsilonDatasetCreateCopy( const char * pszFilename, GDALDataset *poSrcDS,
int bStrict, char ** papszOptions,
GDALProgressFunc pfnProgress, void * pProgressData )
{
int nBands = poSrcDS->GetRasterCount();
if ((nBands != 1 && nBands != 3) ||
(nBands > 0 && poSrcDS->GetRasterBand(1)->GetColorTable() != NULL))
{
CPLError(CE_Failure, CPLE_NotSupported,
"The EPSILON driver only supports 1 band (grayscale) "
"or 3 band (RGB) data");
return NULL;
}
/* -------------------------------------------------------------------- */
/* Fetch and check creation options */
/* -------------------------------------------------------------------- */
int nBlockXSize =
atoi(CSLFetchNameValueDef(papszOptions, "BLOCKXSIZE", "256"));
int nBlockYSize =
atoi(CSLFetchNameValueDef(papszOptions, "BLOCKYSIZE", "256"));
if ((nBlockXSize != 32 && nBlockXSize != 64 && nBlockXSize != 128 &&
nBlockXSize != 256 && nBlockXSize != 512 && nBlockXSize != 1024) ||
(nBlockYSize != 32 && nBlockYSize != 64 && nBlockYSize != 128 &&
nBlockYSize != 256 && nBlockYSize != 512 && nBlockYSize != 1024))
{
CPLError(CE_Failure, CPLE_NotSupported,
"Block size must be a power of 2 between 32 et 1024");
return NULL;
}
const char* pszFilter =
CSLFetchNameValueDef(papszOptions, "FILTER", "daub97lift");
char** papszFBID = eps_get_fb_info(EPS_FB_ID);
char** papszFBIDIter = papszFBID;
int bFound = FALSE;
int nIndexFB = 0;
while(papszFBIDIter && *papszFBIDIter && !bFound)
{
if (strcmp(*papszFBIDIter, pszFilter) == 0)
bFound = TRUE;
else
nIndexFB ++;
papszFBIDIter ++;
}
eps_free_fb_info(papszFBID);
if (!bFound)
{
CPLError(CE_Failure, CPLE_NotSupported, "FILTER='%s' not supported",
pszFilter);
return NULL;
}
int eMode = EPS_MODE_OTLPF;
const char* pszMode = CSLFetchNameValueDef(papszOptions, "MODE", "OTLPF");
if (EQUAL(pszMode, "NORMAL"))
eMode = EPS_MODE_NORMAL;
else if (EQUAL(pszMode, "OTLPF"))
eMode = EPS_MODE_OTLPF;
else
{
CPLError(CE_Failure, CPLE_NotSupported, "MODE='%s' not supported",
pszMode);
return NULL;
}
char** papszFBType = eps_get_fb_info(EPS_FB_TYPE);
int bIsBiOrthogonal = EQUAL(papszFBType[nIndexFB], "biorthogonal");
eps_free_fb_info(papszFBType);
if (eMode == EPS_MODE_OTLPF && !bIsBiOrthogonal)
{
CPLError(CE_Failure, CPLE_NotSupported,
"MODE=OTLPF can only be used with biorthogonal filters. "
"Use MODE=NORMAL instead");
return NULL;
}
int bRasterliteOutput =
CSLTestBoolean(CSLFetchNameValueDef(papszOptions,
"RASTERLITE_OUTPUT", "NO"));
int nYRatio = EPS_Y_RT;
int nCbRatio = EPS_Cb_RT;
int nCrRatio = EPS_Cr_RT;
int eResample;
if (CSLTestBoolean(CSLFetchNameValueDef(papszOptions,
"RGB_RESAMPLE", "YES")))
eResample = EPS_RESAMPLE_420;
else
eResample = EPS_RESAMPLE_444;
const char* pszTarget = CSLFetchNameValueDef(papszOptions, "TARGET", "96");
double dfReductionFactor = 1 - atof(pszTarget) / 100;
if (dfReductionFactor > 1)
dfReductionFactor = 1;
else if (dfReductionFactor < 0)
dfReductionFactor = 0;
/* -------------------------------------------------------------------- */
/* Open file */
/* -------------------------------------------------------------------- */
VSILFILE* fp = VSIFOpenL(pszFilename, "wb");
if (fp == NULL)
return NULL;
/* -------------------------------------------------------------------- */
/* Compute number of blocks, block size, etc... */
/* -------------------------------------------------------------------- */
int nXSize = poSrcDS->GetRasterXSize();
int nYSize = poSrcDS->GetRasterYSize();
if (eMode == EPS_MODE_OTLPF)
{
nBlockXSize ++;
nBlockYSize ++;
}
int nXBlocks = (nXSize + nBlockXSize - 1) / nBlockXSize;
int nYBlocks = (nYSize + nBlockYSize - 1) / nBlockYSize;
int nBlocks = nXBlocks * nYBlocks;
int nUncompressedFileSize = nXSize * nYSize * nBands;
int nUncompressedBlockSize = nUncompressedFileSize / nBlocks;
int nTargetBlockSize = (int) (dfReductionFactor * nUncompressedBlockSize);
if (nBands == 1)
nTargetBlockSize = MAX (nTargetBlockSize, EPS_MIN_GRAYSCALE_BUF + 1);
else
nTargetBlockSize = MAX (nTargetBlockSize, EPS_MIN_TRUECOLOR_BUF + 1);
/* -------------------------------------------------------------------- */
/* Allocate work buffers */
/* -------------------------------------------------------------------- */
GByte* pabyBuffer = (GByte*)VSIMalloc3(nBlockXSize, nBlockYSize, nBands);
if (pabyBuffer == NULL)
{
VSIFCloseL(fp);
return NULL;
}
GByte* pabyOutBuf = (GByte*)VSIMalloc(nTargetBlockSize);
if (pabyOutBuf == NULL)
{
VSIFree(pabyBuffer);
VSIFCloseL(fp);
return NULL;
}
GByte** apapbyRawBuffer[3];
int i, j;
for(i=0;i<nBands;i++)
{
apapbyRawBuffer[i] = (GByte**) VSIMalloc(sizeof(GByte*) * nBlockYSize);
for(j=0;j<nBlockYSize;j++)
{
apapbyRawBuffer[i][j] =
pabyBuffer + (i * nBlockXSize + j) * nBlockYSize;
}
}
if (bRasterliteOutput)
{
const char* pszHeader = RASTERLITE_WAVELET_HEADER;
VSIFWriteL(pszHeader, 1, strlen(pszHeader) + 1, fp);
}
/* -------------------------------------------------------------------- */
/* Iterate over blocks */
/* -------------------------------------------------------------------- */
int nBlockXOff, nBlockYOff;
CPLErr eErr = CE_None;
for(nBlockYOff = 0;
eErr == CE_None && nBlockYOff < nYBlocks; nBlockYOff ++)
{
for(nBlockXOff = 0;
eErr == CE_None && nBlockXOff < nXBlocks; nBlockXOff ++)
{
int bMustMemset = FALSE;
int nReqXSize = nBlockXSize, nReqYSize = nBlockYSize;
if ((nBlockXOff+1) * nBlockXSize > nXSize)
{
bMustMemset = TRUE;
nReqXSize = nXSize - nBlockXOff * nBlockXSize;
}
if ((nBlockYOff+1) * nBlockYSize > nYSize)
{
bMustMemset = TRUE;
nReqYSize = nYSize - nBlockYOff * nBlockYSize;
}
if (bMustMemset)
memset(pabyBuffer, 0, nBands * nBlockXSize * nBlockYSize);
eErr = poSrcDS->RasterIO(GF_Read,
nBlockXOff * nBlockXSize,
nBlockYOff * nBlockYSize,
nReqXSize, nReqYSize,
pabyBuffer,
nReqXSize, nReqYSize,
GDT_Byte, nBands, NULL,
1,
nBlockXSize,
nBlockXSize * nBlockYSize);
int nOutBufSize = nTargetBlockSize;
if (eErr == CE_None && nBands == 1)
{
if (EPS_OK != eps_encode_grayscale_block(apapbyRawBuffer[0],
nXSize, nYSize,
nReqXSize, nReqYSize,
nBlockXOff * nBlockXSize,
nBlockYOff * nBlockYSize,
pabyOutBuf, &nOutBufSize,
(char*) pszFilter, eMode))
{
CPLError(CE_Failure, CPLE_AppDefined,
"Error occured when encoding block (%d, %d)",
nBlockXOff, nBlockYOff);
eErr = CE_Failure;
}
}
else if (eErr == CE_None)
{
if (EPS_OK != eps_encode_truecolor_block(
apapbyRawBuffer[0],
apapbyRawBuffer[1],
apapbyRawBuffer[2],
nXSize, nYSize,
nReqXSize, nReqYSize,
nBlockXOff * nBlockXSize,
nBlockYOff * nBlockYSize,
eResample,
pabyOutBuf, &nOutBufSize,
nYRatio, nCbRatio, nCrRatio,
(char*) pszFilter, eMode))
{
CPLError(CE_Failure, CPLE_AppDefined,
"Error occured when encoding block (%d, %d)",
nBlockXOff, nBlockYOff);
eErr = CE_Failure;
}
}
if (eErr == CE_None)
{
if ((int)VSIFWriteL(pabyOutBuf, 1, nOutBufSize, fp) !=
nOutBufSize)
eErr = CE_Failure;
char chEPSMarker = EPS_MARKER;
VSIFWriteL(&chEPSMarker, 1, 1, fp);
if (pfnProgress && !pfnProgress(
1.0 * (nBlockYOff * nXBlocks + nBlockXOff + 1) / nBlocks,
NULL, pProgressData))
{
eErr = CE_Failure;
}
}
}
}
if (bRasterliteOutput)
{
const char* pszFooter = RASTERLITE_WAVELET_FOOTER;
VSIFWriteL(pszFooter, 1, strlen(pszFooter) + 1, fp);
}
/* -------------------------------------------------------------------- */
/* Cleanup work buffers */
/* -------------------------------------------------------------------- */
for(i=0;i<nBands;i++)
{
VSIFree(apapbyRawBuffer[i]);
}
VSIFree(pabyOutBuf);
VSIFree(pabyBuffer);
VSIFCloseL(fp);
if (eErr != CE_None)
return NULL;
/* -------------------------------------------------------------------- */
/* Reopen the dataset, unless asked for not (Rasterlite optim) */
/* -------------------------------------------------------------------- */
return (GDALDataset*) GDALOpen(pszFilename, GA_ReadOnly);
}
GDALDataset *
GIFDataset::CreateCopy( const char * pszFilename, GDALDataset *poSrcDS,
int bStrict, char ** papszOptions,
GDALProgressFunc pfnProgress, void * pProgressData )
{
int nBands = poSrcDS->GetRasterCount();
int nXSize = poSrcDS->GetRasterXSize();
int nYSize = poSrcDS->GetRasterYSize();
int bInterlace = FALSE;
/* -------------------------------------------------------------------- */
/* Check for interlaced option. */
/* -------------------------------------------------------------------- */
bInterlace = CSLFetchBoolean(papszOptions, "INTERLACING", FALSE);
/* -------------------------------------------------------------------- */
/* Some some rudimentary checks */
/* -------------------------------------------------------------------- */
if( nBands != 1 )
{
CPLError( CE_Failure, CPLE_NotSupported,
"GIF driver only supports one band images.\n" );
return NULL;
}
if (nXSize > 65535 || nYSize > 65535)
{
CPLError( CE_Failure, CPLE_NotSupported,
"GIF driver only supports datasets up to 65535x65535 size.\n" );
return NULL;
}
if( poSrcDS->GetRasterBand(1)->GetRasterDataType() != GDT_Byte
&& bStrict )
{
CPLError( CE_Failure, CPLE_NotSupported,
"GIF driver doesn't support data type %s. "
"Only eight bit bands supported.\n",
GDALGetDataTypeName(
poSrcDS->GetRasterBand(1)->GetRasterDataType()) );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Open the output file. */
/* -------------------------------------------------------------------- */
GifFileType *hGifFile;
VSILFILE *fp;
fp = VSIFOpenL( pszFilename, "wb" );
if( fp == NULL )
{
CPLError( CE_Failure, CPLE_OpenFailed,
"Failed to create %s:\n%s",
pszFilename, VSIStrerror( errno ) );
return NULL;
}
hGifFile = EGifOpen( fp, VSIGIFWriteFunc );
if( hGifFile == NULL )
{
VSIFCloseL( fp );
CPLError( CE_Failure, CPLE_OpenFailed,
"EGifOpenFilename(%s) failed. Does file already exist?",
pszFilename );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Prepare colortable. */
/* -------------------------------------------------------------------- */
GDALRasterBand *poBand = poSrcDS->GetRasterBand(1);
ColorMapObject *psGifCT;
int iColor;
if( poBand->GetColorTable() == NULL )
{
psGifCT = MakeMapObject( 256, NULL );
for( iColor = 0; iColor < 256; iColor++ )
{
psGifCT->Colors[iColor].Red = (GifByteType) iColor;
psGifCT->Colors[iColor].Green = (GifByteType) iColor;
psGifCT->Colors[iColor].Blue = (GifByteType) iColor;
}
}
else
{
GDALColorTable *poCT = poBand->GetColorTable();
int nFullCount = 1;
while( nFullCount < poCT->GetColorEntryCount() )
nFullCount = nFullCount * 2;
psGifCT = MakeMapObject( nFullCount, NULL );
for( iColor = 0; iColor < poCT->GetColorEntryCount(); iColor++ )
{
GDALColorEntry sEntry;
poCT->GetColorEntryAsRGB( iColor, &sEntry );
psGifCT->Colors[iColor].Red = (GifByteType) sEntry.c1;
psGifCT->Colors[iColor].Green = (GifByteType) sEntry.c2;
psGifCT->Colors[iColor].Blue = (GifByteType) sEntry.c3;
}
for( ; iColor < nFullCount; iColor++ )
{
psGifCT->Colors[iColor].Red = 0;
psGifCT->Colors[iColor].Green = 0;
psGifCT->Colors[iColor].Blue = 0;
}
}
/* -------------------------------------------------------------------- */
/* Setup parameters. */
/* -------------------------------------------------------------------- */
if (EGifPutScreenDesc(hGifFile, nXSize, nYSize,
psGifCT->ColorCount, 255, psGifCT) == GIF_ERROR)
{
FreeMapObject(psGifCT);
PrintGifError();
CPLError( CE_Failure, CPLE_AppDefined,
"Error writing gif file." );
EGifCloseFile(hGifFile);
VSIFCloseL( fp );
return NULL;
}
FreeMapObject(psGifCT);
psGifCT = NULL;
/* Support for transparency */
int bNoDataValue;
double noDataValue = poBand->GetNoDataValue(&bNoDataValue);
if (bNoDataValue && noDataValue >= 0 && noDataValue <= 255)
{
unsigned char extensionData[4];
extensionData[0] = 1; /* Transparent Color Flag */
extensionData[1] = 0;
extensionData[2] = 0;
extensionData[3] = (unsigned char)noDataValue;
EGifPutExtension(hGifFile, 0xf9, 4, extensionData);
}
if (EGifPutImageDesc(hGifFile, 0, 0, nXSize, nYSize, bInterlace, NULL) == GIF_ERROR )
{
PrintGifError();
CPLError( CE_Failure, CPLE_AppDefined,
"Error writing gif file." );
EGifCloseFile(hGifFile);
VSIFCloseL( fp );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Loop over image, copying image data. */
/* -------------------------------------------------------------------- */
CPLErr eErr;
GDALPamDataset *poDS;
GByte *pabyScanline;
pabyScanline = (GByte *) CPLMalloc( nXSize );
if( !pfnProgress( 0.0, NULL, pProgressData ) )
eErr = CE_Failure;
if( !bInterlace )
{
for( int iLine = 0; iLine < nYSize; iLine++ )
{
eErr = poBand->RasterIO( GF_Read, 0, iLine, nXSize, 1,
pabyScanline, nXSize, 1, GDT_Byte,
nBands, nBands * nXSize );
if( eErr != CE_None || EGifPutLine( hGifFile, pabyScanline, nXSize ) == GIF_ERROR )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Error writing gif file." );
goto error;
}
if( !pfnProgress( (iLine + 1) * 1.0 / nYSize, NULL, pProgressData ) )
{
goto error;
}
}
}
else
{
int i, j;
int nLinesRead = 0;
int nLinesToRead = 0;
for ( i = 0; i < 4; i++)
{
for (j = InterlacedOffset[i]; j < nYSize; j += InterlacedJumps[i])
{
nLinesToRead ++;
}
}
/* Need to perform 4 passes on the images: */
for ( i = 0; i < 4; i++)
{
for (j = InterlacedOffset[i]; j < nYSize; j += InterlacedJumps[i])
{
eErr= poBand->RasterIO( GF_Read, 0, j, nXSize, 1,
pabyScanline, nXSize, 1, GDT_Byte,
1, nXSize );
if (eErr != CE_None || EGifPutLine(hGifFile, pabyScanline, nXSize) == GIF_ERROR)
{
CPLError( CE_Failure, CPLE_AppDefined,
"Error writing gif file." );
goto error;
}
nLinesRead ++;
if( !pfnProgress( nLinesRead * 1.0 / nYSize, NULL, pProgressData ) )
{
goto error;
}
}
}
}
CPLFree( pabyScanline );
pabyScanline = NULL;
/* -------------------------------------------------------------------- */
/* cleanup */
/* -------------------------------------------------------------------- */
if (EGifCloseFile(hGifFile) == GIF_ERROR)
{
CPLError( CE_Failure, CPLE_AppDefined,
"EGifCloseFile() failed.\n" );
hGifFile = NULL;
goto error;
}
hGifFile = NULL;
VSIFCloseL( fp );
fp = NULL;
/* -------------------------------------------------------------------- */
/* Do we need a world file? */
/* -------------------------------------------------------------------- */
if( CSLFetchBoolean( papszOptions, "WORLDFILE", FALSE ) )
{
double adfGeoTransform[6];
if( poSrcDS->GetGeoTransform( adfGeoTransform ) == CE_None )
GDALWriteWorldFile( pszFilename, "wld", adfGeoTransform );
}
/* -------------------------------------------------------------------- */
/* Re-open dataset, and copy any auxilary pam information. */
/* -------------------------------------------------------------------- */
/* If outputing to stdout, we can't reopen it, so we'll return */
/* a fake dataset to make the caller happy */
CPLPushErrorHandler(CPLQuietErrorHandler);
poDS = (GDALPamDataset*) GDALOpen(pszFilename, GA_ReadOnly);
CPLPopErrorHandler();
if (poDS)
{
poDS->CloneInfo( poSrcDS, GCIF_PAM_DEFAULT );
return poDS;
}
else
{
CPLErrorReset();
GIFDataset* poGIF_DS = new GIFDataset();
poGIF_DS->nRasterXSize = nXSize;
poGIF_DS->nRasterYSize = nYSize;
for(int i=0;i<nBands;i++)
poGIF_DS->SetBand( i+1, new GIFRasterBand( poGIF_DS, i+1, NULL, 0 ) );
return poGIF_DS;
}
error:
if (hGifFile)
EGifCloseFile(hGifFile);
if (fp)
VSIFCloseL( fp );
if (pabyScanline)
CPLFree( pabyScanline );
return NULL;
}
GDALDataset* HF2Dataset::CreateCopy( const char * pszFilename,
GDALDataset *poSrcDS,
int bStrict, char ** papszOptions,
GDALProgressFunc pfnProgress,
void * pProgressData )
{
/* -------------------------------------------------------------------- */
/* Some some rudimentary checks */
/* -------------------------------------------------------------------- */
int nBands = poSrcDS->GetRasterCount();
if (nBands == 0)
{
CPLError( CE_Failure, CPLE_NotSupported,
"HF2 driver does not support source dataset with zero band.\n");
return NULL;
}
if (nBands != 1)
{
CPLError( (bStrict) ? CE_Failure : CE_Warning, CPLE_NotSupported,
"HF2 driver only uses the first band of the dataset.\n");
if (bStrict)
return NULL;
}
if( pfnProgress && !pfnProgress( 0.0, NULL, pProgressData ) )
return NULL;
/* -------------------------------------------------------------------- */
/* Get source dataset info */
/* -------------------------------------------------------------------- */
int nXSize = poSrcDS->GetRasterXSize();
int nYSize = poSrcDS->GetRasterYSize();
double adfGeoTransform[6];
poSrcDS->GetGeoTransform(adfGeoTransform);
int bHasGeoTransform = !(adfGeoTransform[0] == 0 &&
adfGeoTransform[1] == 1 &&
adfGeoTransform[2] == 0 &&
adfGeoTransform[3] == 0 &&
adfGeoTransform[4] == 0 &&
adfGeoTransform[5] == 1);
if (adfGeoTransform[2] != 0 || adfGeoTransform[4] != 0)
{
CPLError( CE_Failure, CPLE_NotSupported,
"HF2 driver does not support CreateCopy() from skewed or rotated dataset.\n");
return NULL;
}
GDALDataType eSrcDT = poSrcDS->GetRasterBand(1)->GetRasterDataType();
GDALDataType eReqDT;
float fVertPres = (float) 0.01;
if (eSrcDT == GDT_Byte || eSrcDT == GDT_Int16)
{
fVertPres = 1;
eReqDT = GDT_Int16;
}
else
eReqDT = GDT_Float32;
/* -------------------------------------------------------------------- */
/* Read creation options */
/* -------------------------------------------------------------------- */
const char* pszCompressed = CSLFetchNameValue(papszOptions, "COMPRESS");
int bCompress = FALSE;
if (pszCompressed)
bCompress = CSLTestBoolean(pszCompressed);
const char* pszVerticalPrecision = CSLFetchNameValue(papszOptions, "VERTICAL_PRECISION");
if (pszVerticalPrecision)
{
fVertPres = (float) CPLAtofM(pszVerticalPrecision);
if (fVertPres <= 0)
{
CPLError(CE_Warning, CPLE_AppDefined,
"Unsupported value for VERTICAL_PRECISION. Defaulting to 0.01");
fVertPres = (float) 0.01;
}
if (eReqDT == GDT_Int16 && fVertPres > 1)
eReqDT = GDT_Float32;
}
const char* pszBlockSize = CSLFetchNameValue(papszOptions, "BLOCKSIZE");
int nTileSize = 256;
if (pszBlockSize)
{
nTileSize = atoi(pszBlockSize);
if (nTileSize < 8 || nTileSize > 4096)
{
CPLError(CE_Warning, CPLE_AppDefined,
"Unsupported value for BLOCKSIZE. Defaulting to 256");
nTileSize = 256;
}
}
/* -------------------------------------------------------------------- */
/* Parse source dataset georeferencing info */
/* -------------------------------------------------------------------- */
int nExtendedHeaderLen = 0;
if (bHasGeoTransform)
nExtendedHeaderLen += 58;
const char* pszProjectionRef = poSrcDS->GetProjectionRef();
int nDatumCode = -2;
int nUTMZone = 0;
int bNorth = FALSE;
int nEPSGCode = 0;
int nExtentUnits = 1;
if (pszProjectionRef != NULL && pszProjectionRef[0] != '\0')
{
OGRSpatialReference oSRS;
char* pszTemp = (char*) pszProjectionRef;
if (oSRS.importFromWkt(&pszTemp) == OGRERR_NONE)
{
const char* pszValue = NULL;
if( oSRS.GetAuthorityName( "GEOGCS|DATUM" ) != NULL
&& EQUAL(oSRS.GetAuthorityName( "GEOGCS|DATUM" ),"EPSG") )
nDatumCode = atoi(oSRS.GetAuthorityCode( "GEOGCS|DATUM" ));
else if ((pszValue = oSRS.GetAttrValue("GEOGCS|DATUM")) != NULL)
{
if (strstr(pszValue, "WGS") && strstr(pszValue, "84"))
nDatumCode = 6326;
}
nUTMZone = oSRS.GetUTMZone(&bNorth);
}
if( oSRS.GetAuthorityName( "PROJCS" ) != NULL
&& EQUAL(oSRS.GetAuthorityName( "PROJCS" ),"EPSG") )
nEPSGCode = atoi(oSRS.GetAuthorityCode( "PROJCS" ));
if( oSRS.IsGeographic() )
{
nExtentUnits = 0;
}
else
{
double dfLinear = oSRS.GetLinearUnits();
if( ABS(dfLinear - 0.3048) < 0.0000001 )
nExtentUnits = 2;
else if( ABS(dfLinear - atof(SRS_UL_US_FOOT_CONV)) < 0.00000001 )
nExtentUnits = 3;
else
nExtentUnits = 1;
}
}
if (nDatumCode != -2)
nExtendedHeaderLen += 26;
if (nUTMZone != 0)
nExtendedHeaderLen += 26;
if (nEPSGCode)
nExtendedHeaderLen += 26;
/* -------------------------------------------------------------------- */
/* Create target file */
/* -------------------------------------------------------------------- */
CPLString osFilename;
if (bCompress)
{
osFilename = "/vsigzip/";
osFilename += pszFilename;
}
else
osFilename = pszFilename;
VSILFILE* fp = VSIFOpenL(osFilename.c_str(), "wb");
if (fp == NULL)
{
CPLError( CE_Failure, CPLE_AppDefined,
"Cannot create %s", pszFilename );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Write header */
/* -------------------------------------------------------------------- */
VSIFWriteL("HF2\0", 4, 1, fp);
WriteShort(fp, 0);
WriteInt(fp, nXSize);
WriteInt(fp, nYSize);
WriteShort(fp, (GInt16) nTileSize);
WriteFloat(fp, fVertPres);
float fHorizScale = (float) ((fabs(adfGeoTransform[1]) + fabs(adfGeoTransform[5])) / 2);
WriteFloat(fp, fHorizScale);
WriteInt(fp, nExtendedHeaderLen);
/* -------------------------------------------------------------------- */
/* Write extended header */
/* -------------------------------------------------------------------- */
char szBlockName[16 + 1];
if (bHasGeoTransform)
{
VSIFWriteL("bin\0", 4, 1, fp);
memset(szBlockName, 0, 16 + 1);
strcpy(szBlockName, "georef-extents");
VSIFWriteL(szBlockName, 16, 1, fp);
WriteInt(fp, 34);
WriteShort(fp, (GInt16) nExtentUnits);
WriteDouble(fp, adfGeoTransform[0]);
WriteDouble(fp, adfGeoTransform[0] + nXSize * adfGeoTransform[1]);
WriteDouble(fp, adfGeoTransform[3] + nYSize * adfGeoTransform[5]);
WriteDouble(fp, adfGeoTransform[3]);
}
if (nUTMZone != 0)
{
VSIFWriteL("bin\0", 4, 1, fp);
memset(szBlockName, 0, 16 + 1);
strcpy(szBlockName, "georef-utm");
VSIFWriteL(szBlockName, 16, 1, fp);
WriteInt(fp, 2);
WriteShort(fp, (GInt16) ((bNorth) ? nUTMZone : -nUTMZone));
}
if (nDatumCode != -2)
{
VSIFWriteL("bin\0", 4, 1, fp);
memset(szBlockName, 0, 16 + 1);
strcpy(szBlockName, "georef-datum");
VSIFWriteL(szBlockName, 16, 1, fp);
WriteInt(fp, 2);
WriteShort(fp, (GInt16) nDatumCode);
}
if (nEPSGCode != 0)
{
VSIFWriteL("bin\0", 4, 1, fp);
memset(szBlockName, 0, 16 + 1);
strcpy(szBlockName, "georef-epsg-prj");
VSIFWriteL(szBlockName, 16, 1, fp);
WriteInt(fp, 2);
WriteShort(fp, (GInt16) nEPSGCode);
}
/* -------------------------------------------------------------------- */
/* Copy imagery */
/* -------------------------------------------------------------------- */
int nXBlocks = (nXSize + nTileSize - 1) / nTileSize;
int nYBlocks = (nYSize + nTileSize - 1) / nTileSize;
void* pTileBuffer = (void*) VSIMalloc(nTileSize * nTileSize * (GDALGetDataTypeSize(eReqDT) / 8));
if (pTileBuffer == NULL)
{
CPLError( CE_Failure, CPLE_OutOfMemory, "Out of memory");
VSIFCloseL(fp);
return NULL;
}
int i, j, k, l;
CPLErr eErr = CE_None;
for(j=0;j<nYBlocks && eErr == CE_None;j++)
{
for(i=0;i<nXBlocks && eErr == CE_None;i++)
{
int nReqXSize = MIN(nTileSize, nXSize - i * nTileSize);
int nReqYSize = MIN(nTileSize, nYSize - j * nTileSize);
eErr = poSrcDS->GetRasterBand(1)->RasterIO(GF_Read,
i * nTileSize, MAX(0, nYSize - (j + 1) * nTileSize),
nReqXSize, nReqYSize,
pTileBuffer, nReqXSize, nReqYSize,
eReqDT, 0, 0);
if (eErr != CE_None)
break;
if (eReqDT == GDT_Int16)
{
WriteFloat(fp, 1); /* scale */
WriteFloat(fp, 0); /* offset */
for(k=0;k<nReqYSize;k++)
{
int nLastVal = ((short*)pTileBuffer)[(nReqYSize - k - 1) * nReqXSize + 0];
GByte nWordSize = 1;
for(l=1;l<nReqXSize;l++)
{
int nVal = ((short*)pTileBuffer)[(nReqYSize - k - 1) * nReqXSize + l];
int nDiff = nVal - nLastVal;
if (nDiff < -32768 || nDiff > 32767)
{
nWordSize = 4;
break;
}
if (nDiff < -128 || nDiff > 127)
nWordSize = 2;
nLastVal = nVal;
}
VSIFWriteL(&nWordSize, 1, 1, fp);
nLastVal = ((short*)pTileBuffer)[(nReqYSize - k - 1) * nReqXSize + 0];
WriteInt(fp, nLastVal);
for(l=1;l<nReqXSize;l++)
{
int nVal = ((short*)pTileBuffer)[(nReqYSize - k - 1) * nReqXSize + l];
int nDiff = nVal - nLastVal;
if (nWordSize == 1)
{
CPLAssert(nDiff >= -128 && nDiff <= 127);
char chDiff = (char)nDiff;
VSIFWriteL(&chDiff, 1, 1, fp);
}
else if (nWordSize == 2)
{
CPLAssert(nDiff >= -32768 && nDiff <= 32767);
WriteShort(fp, (short)nDiff);
}
else
{
WriteInt(fp, nDiff);
}
nLastVal = nVal;
}
}
}
else
{
float fMinVal = ((float*)pTileBuffer)[0];
float fMaxVal = fMinVal;
for(k=1;k<nReqYSize*nReqXSize;k++)
{
float fVal = ((float*)pTileBuffer)[k];
if (fVal < fMinVal) fMinVal = fVal;
if (fVal > fMaxVal) fMaxVal = fVal;
}
float fIntRange = (fMaxVal - fMinVal) / fVertPres;
float fScale = (fMinVal == fMaxVal) ? 1 : (fMaxVal - fMinVal) / fIntRange;
float fOffset = fMinVal;
WriteFloat(fp, fScale); /* scale */
WriteFloat(fp, fOffset); /* offset */
for(k=0;k<nReqYSize;k++)
{
float fLastVal = ((float*)pTileBuffer)[(nReqYSize - k - 1) * nReqXSize + 0];
float fIntLastVal = (fLastVal - fOffset) / fScale;
CPLAssert(fIntLastVal >= -2147483648.0f && fIntLastVal <= 2147483647.0f);
int nLastVal = (int)fIntLastVal;
GByte nWordSize = 1;
for(l=1;l<nReqXSize;l++)
{
float fVal = ((float*)pTileBuffer)[(nReqYSize - k - 1) * nReqXSize + l];
float fIntVal = (fVal - fOffset) / fScale;
CPLAssert(fIntVal >= -2147483648.0f && fIntVal <= 2147483647.0f);
int nVal = (int)fIntVal;
int nDiff = nVal - nLastVal;
CPLAssert((int)((GIntBig)nVal - nLastVal) == nDiff);
if (nDiff < -32768 || nDiff > 32767)
{
nWordSize = 4;
break;
}
if (nDiff < -128 || nDiff > 127)
nWordSize = 2;
nLastVal = nVal;
}
VSIFWriteL(&nWordSize, 1, 1, fp);
fLastVal = ((float*)pTileBuffer)[(nReqYSize - k - 1) * nReqXSize + 0];
fIntLastVal = (fLastVal - fOffset) / fScale;
nLastVal = (int)fIntLastVal;
WriteInt(fp, nLastVal);
for(l=1;l<nReqXSize;l++)
{
float fVal = ((float*)pTileBuffer)[(nReqYSize - k - 1) * nReqXSize + l];
float fIntVal = (fVal - fOffset) / fScale;
int nVal = (int)fIntVal;
int nDiff = nVal - nLastVal;
CPLAssert((int)((GIntBig)nVal - nLastVal) == nDiff);
if (nWordSize == 1)
{
CPLAssert(nDiff >= -128 && nDiff <= 127);
char chDiff = (char)nDiff;
VSIFWriteL(&chDiff, 1, 1, fp);
}
else if (nWordSize == 2)
{
CPLAssert(nDiff >= -32768 && nDiff <= 32767);
WriteShort(fp, (short)nDiff);
}
else
{
WriteInt(fp, nDiff);
}
nLastVal = nVal;
}
}
}
if( pfnProgress && !pfnProgress( (j * nXBlocks + i + 1) * 1.0 / (nXBlocks * nYBlocks), NULL, pProgressData ) )
{
eErr = CE_Failure;
break;
}
}
}
CPLFree(pTileBuffer);
VSIFCloseL(fp);
if (eErr != CE_None)
return NULL;
return (GDALDataset*) GDALOpen(osFilename.c_str(), GA_ReadOnly);
}
GDALDataset *
RasterliteCreateCopy( const char * pszFilename, GDALDataset *poSrcDS,
CPL_UNUSED int bStrict,
char ** papszOptions,
GDALProgressFunc pfnProgress, void * pProgressData )
{
const int nBands = poSrcDS->GetRasterCount();
if (nBands == 0)
{
CPLError(CE_Failure, CPLE_NotSupported, "nBands == 0");
return NULL;
}
const char* pszDriverName = CSLFetchNameValueDef(papszOptions, "DRIVER", "GTiff");
if (EQUAL(pszDriverName, "MEM") || EQUAL(pszDriverName, "VRT"))
{
CPLError(CE_Failure, CPLE_AppDefined, "GDAL %s driver cannot be used as underlying driver",
pszDriverName);
return NULL;
}
GDALDriverH hTileDriver = GDALGetDriverByName(pszDriverName);
if ( hTileDriver == NULL)
{
CPLError(CE_Failure, CPLE_AppDefined, "Cannot load GDAL %s driver", pszDriverName);
return NULL;
}
GDALDriverH hMemDriver = GDALGetDriverByName("MEM");
if (hMemDriver == NULL)
{
CPLError(CE_Failure, CPLE_AppDefined, "Cannot load GDAL MEM driver");
return NULL;
}
const int nXSize = GDALGetRasterXSize(poSrcDS);
const int nYSize = GDALGetRasterYSize(poSrcDS);
double adfGeoTransform[6];
if (poSrcDS->GetGeoTransform(adfGeoTransform) != CE_None)
{
adfGeoTransform[0] = 0;
adfGeoTransform[1] = 1;
adfGeoTransform[2] = 0;
adfGeoTransform[3] = 0;
adfGeoTransform[4] = 0;
adfGeoTransform[5] = -1;
}
else if (adfGeoTransform[2] != 0.0 || adfGeoTransform[4] != 0.0)
{
CPLError(CE_Failure, CPLE_AppDefined, "Cannot use geotransform with rotational terms");
return NULL;
}
const bool bTiled = CPLTestBool(CSLFetchNameValueDef(papszOptions, "TILED", "YES"));
int nBlockXSize, nBlockYSize;
if (bTiled)
{
nBlockXSize = atoi(CSLFetchNameValueDef(papszOptions, "BLOCKXSIZE", "256"));
nBlockYSize = atoi(CSLFetchNameValueDef(papszOptions, "BLOCKYSIZE", "256"));
if (nBlockXSize < 64) nBlockXSize = 64;
else if (nBlockXSize > 4096) nBlockXSize = 4096;
if (nBlockYSize < 64) nBlockYSize = 64;
else if (nBlockYSize > 4096) nBlockYSize = 4096;
}
else
{
nBlockXSize = nXSize;
nBlockYSize = nYSize;
}
/* -------------------------------------------------------------------- */
/* Analyze arguments */
/* -------------------------------------------------------------------- */
/* Skip optional RASTERLITE: prefix */
const char* pszFilenameWithoutPrefix = pszFilename;
if (STARTS_WITH_CI(pszFilename, "RASTERLITE:"))
pszFilenameWithoutPrefix += 11;
char** papszTokens = CSLTokenizeStringComplex(
pszFilenameWithoutPrefix, ",", FALSE, FALSE );
const int nTokens = CSLCount(papszTokens);
CPLString osDBName;
CPLString osTableName;
if (nTokens == 0)
{
osDBName = pszFilenameWithoutPrefix;
osTableName = CPLGetBasename(pszFilenameWithoutPrefix);
}
else
{
osDBName = papszTokens[0];
int i;
for(i=1;i<nTokens;i++)
{
if (STARTS_WITH_CI(papszTokens[i], "table="))
osTableName = papszTokens[i] + 6;
else
{
CPLError(CE_Warning, CPLE_AppDefined,
"Invalid option : %s", papszTokens[i]);
}
}
}
CSLDestroy(papszTokens);
papszTokens = NULL;
VSIStatBuf sBuf;
const bool bExists = (VSIStat(osDBName.c_str(), &sBuf) == 0);
if (osTableName.size() == 0)
{
if (bExists)
{
CPLError(CE_Failure, CPLE_AppDefined,
"Database already exists. Explicit table name must be specified");
return NULL;
}
osTableName = CPLGetBasename(osDBName.c_str());
}
CPLString osRasterLayer;
osRasterLayer.Printf("%s_rasters", osTableName.c_str());
CPLString osMetadataLayer;
osMetadataLayer.Printf("%s_metadata", osTableName.c_str());
/* -------------------------------------------------------------------- */
/* Create or open the SQLite DB */
/* -------------------------------------------------------------------- */
if (OGRGetDriverCount() == 0)
OGRRegisterAll();
OGRSFDriverH hSQLiteDriver = OGRGetDriverByName("SQLite");
if (hSQLiteDriver == NULL)
{
CPLError(CE_Failure, CPLE_AppDefined, "Cannot load OGR SQLite driver");
return NULL;
}
OGRDataSourceH hDS;
if (!bExists)
{
char** papszOGROptions = CSLAddString(NULL, "SPATIALITE=YES");
hDS = OGR_Dr_CreateDataSource(hSQLiteDriver,
osDBName.c_str(), papszOGROptions);
CSLDestroy(papszOGROptions);
}
else
{
hDS = RasterliteOpenSQLiteDB(osDBName.c_str(), GA_Update);
}
if (hDS == NULL)
{
CPLError(CE_Failure, CPLE_AppDefined,
"Cannot load or create SQLite database");
return NULL;
}
CPLString osSQL;
/* -------------------------------------------------------------------- */
/* Get the SRID for the SRS */
/* -------------------------------------------------------------------- */
int nSRSId = RasterliteInsertSRID(hDS, poSrcDS->GetProjectionRef());
/* -------------------------------------------------------------------- */
/* Create or wipe existing tables */
/* -------------------------------------------------------------------- */
const int bWipeExistingData =
CPLTestBool(CSLFetchNameValueDef(papszOptions, "WIPE", "NO"));
hDS = RasterliteCreateTables(hDS, osTableName.c_str(),
nSRSId, bWipeExistingData);
if (hDS == NULL)
return NULL;
OGRLayerH hRasterLayer = OGR_DS_GetLayerByName(hDS, osRasterLayer.c_str());
OGRLayerH hMetadataLayer = OGR_DS_GetLayerByName(hDS, osMetadataLayer.c_str());
if (hRasterLayer == NULL || hMetadataLayer == NULL)
{
CPLError(CE_Failure, CPLE_AppDefined,
"Cannot find metadata and/or raster tables");
OGRReleaseDataSource(hDS);
return NULL;
}
/* -------------------------------------------------------------------- */
/* Check if there is overlapping data and warn the user */
/* -------------------------------------------------------------------- */
double minx = adfGeoTransform[0];
double maxx = adfGeoTransform[0] + nXSize * adfGeoTransform[1];
double maxy = adfGeoTransform[3];
double miny = adfGeoTransform[3] + nYSize * adfGeoTransform[5];
osSQL.Printf("SELECT COUNT(geometry) FROM \"%s\" "
"WHERE rowid IN "
"(SELECT pkid FROM \"idx_%s_metadata_geometry\" "
"WHERE %s) AND %s",
osMetadataLayer.c_str(),
osTableName.c_str(),
RasterliteGetSpatialFilterCond(minx, miny, maxx, maxy).c_str(),
RasterliteGetPixelSizeCond(adfGeoTransform[1], -adfGeoTransform[5]).c_str());
int nOverlappingGeoms = 0;
OGRLayerH hCountLyr = OGR_DS_ExecuteSQL(hDS, osSQL.c_str(), NULL, NULL);
if (hCountLyr)
{
OGRFeatureH hFeat = OGR_L_GetNextFeature(hCountLyr);
if (hFeat)
{
nOverlappingGeoms = OGR_F_GetFieldAsInteger(hFeat, 0);
OGR_F_Destroy(hFeat);
}
OGR_DS_ReleaseResultSet(hDS, hCountLyr);
}
if (nOverlappingGeoms != 0)
{
CPLError(CE_Warning, CPLE_AppDefined,
"Raster tiles already exist in the %s table within "
"the extent of the data to be inserted in",
osTableName.c_str());
}
/* -------------------------------------------------------------------- */
/* Iterate over blocks to add data into raster and metadata tables */
/* -------------------------------------------------------------------- */
int nXBlocks = (nXSize + nBlockXSize - 1) / nBlockXSize;
int nYBlocks = (nYSize + nBlockYSize - 1) / nBlockYSize;
GDALDataType eDataType = poSrcDS->GetRasterBand(1)->GetRasterDataType();
int nDataTypeSize = GDALGetDataTypeSize(eDataType) / 8;
GByte* pabyMEMDSBuffer =
reinterpret_cast<GByte *>(
VSIMalloc3(nBlockXSize, nBlockYSize, nBands * nDataTypeSize) );
if (pabyMEMDSBuffer == NULL)
{
OGRReleaseDataSource(hDS);
return NULL;
}
CPLString osTempFileName;
osTempFileName.Printf("/vsimem/%p", hDS);
int nTileId = 0;
int nBlocks = 0;
int nTotalBlocks = nXBlocks * nYBlocks;
char** papszTileDriverOptions = RasterliteGetTileDriverOptions(papszOptions);
OGR_DS_ExecuteSQL(hDS, "BEGIN", NULL, NULL);
CPLErr eErr = CE_None;
for(int nBlockYOff=0;eErr == CE_None && nBlockYOff<nYBlocks;nBlockYOff++)
{
for(int nBlockXOff=0;eErr == CE_None && nBlockXOff<nXBlocks;nBlockXOff++)
{
/* -------------------------------------------------------------------- */
/* Create in-memory tile */
/* -------------------------------------------------------------------- */
int nReqXSize = nBlockXSize, nReqYSize = nBlockYSize;
if ((nBlockXOff+1) * nBlockXSize > nXSize)
nReqXSize = nXSize - nBlockXOff * nBlockXSize;
if ((nBlockYOff+1) * nBlockYSize > nYSize)
nReqYSize = nYSize - nBlockYOff * nBlockYSize;
eErr = poSrcDS->RasterIO(GF_Read,
nBlockXOff * nBlockXSize,
nBlockYOff * nBlockYSize,
nReqXSize, nReqYSize,
pabyMEMDSBuffer, nReqXSize, nReqYSize,
eDataType, nBands, NULL,
0, 0, 0, NULL);
if (eErr != CE_None)
{
break;
}
GDALDatasetH hMemDS = GDALCreate(hMemDriver, "MEM:::",
nReqXSize, nReqYSize, 0,
eDataType, NULL);
if (hMemDS == NULL)
{
eErr = CE_Failure;
break;
}
for( int iBand = 0; iBand < nBands; iBand ++)
{
char szTmp[64];
memset(szTmp, 0, sizeof(szTmp));
CPLPrintPointer(szTmp,
pabyMEMDSBuffer + iBand * nDataTypeSize *
nReqXSize * nReqYSize, sizeof(szTmp));
char** papszMEMDSOptions
= CSLSetNameValue(NULL, "DATAPOINTER", szTmp);
GDALAddBand(hMemDS, eDataType, papszMEMDSOptions);
CSLDestroy(papszMEMDSOptions);
}
GDALDatasetH hOutDS = GDALCreateCopy(hTileDriver,
osTempFileName.c_str(), hMemDS, FALSE,
papszTileDriverOptions, NULL, NULL);
GDALClose(hMemDS);
if ( !hOutDS )
{
eErr = CE_Failure;
break;
}
GDALClose(hOutDS);
/* -------------------------------------------------------------------- */
/* Insert new entry into raster table */
/* -------------------------------------------------------------------- */
vsi_l_offset nDataLength = 0;
GByte *pabyData = VSIGetMemFileBuffer( osTempFileName.c_str(),
&nDataLength, FALSE);
OGRFeatureH hFeat = OGR_F_Create( OGR_L_GetLayerDefn(hRasterLayer) );
OGR_F_SetFieldBinary(
hFeat, 0, static_cast<int>( nDataLength ), pabyData);
if( OGR_L_CreateFeature(hRasterLayer, hFeat) != OGRERR_NONE )
eErr = CE_Failure;
/* Query raster ID to set it as the ID of the associated metadata */
int nRasterID = static_cast<int>( OGR_F_GetFID( hFeat ) );
OGR_F_Destroy(hFeat);
VSIUnlink(osTempFileName.c_str());
if( eErr == CE_Failure )
break;
/* -------------------------------------------------------------------- */
/* Insert new entry into metadata table */
/* -------------------------------------------------------------------- */
hFeat = OGR_F_Create( OGR_L_GetLayerDefn(hMetadataLayer) );
OGR_F_SetFID(hFeat, nRasterID);
OGR_F_SetFieldString(hFeat, 0, GDALGetDescription(poSrcDS));
OGR_F_SetFieldInteger(hFeat, 1, nTileId ++);
OGR_F_SetFieldInteger(hFeat, 2, nReqXSize);
OGR_F_SetFieldInteger(hFeat, 3, nReqYSize);
OGR_F_SetFieldDouble(hFeat, 4, adfGeoTransform[1]);
OGR_F_SetFieldDouble(hFeat, 5, -adfGeoTransform[5]);
minx = adfGeoTransform[0] +
(nBlockXSize * nBlockXOff) * adfGeoTransform[1];
maxx = adfGeoTransform[0] +
(nBlockXSize * nBlockXOff + nReqXSize) * adfGeoTransform[1];
maxy = adfGeoTransform[3] +
(nBlockYSize * nBlockYOff) * adfGeoTransform[5];
miny = adfGeoTransform[3] +
(nBlockYSize * nBlockYOff + nReqYSize) * adfGeoTransform[5];
OGRGeometryH hRectangle = OGR_G_CreateGeometry(wkbPolygon);
OGRGeometryH hLinearRing = OGR_G_CreateGeometry(wkbLinearRing);
OGR_G_AddPoint_2D(hLinearRing, minx, miny);
OGR_G_AddPoint_2D(hLinearRing, minx, maxy);
OGR_G_AddPoint_2D(hLinearRing, maxx, maxy);
OGR_G_AddPoint_2D(hLinearRing, maxx, miny);
OGR_G_AddPoint_2D(hLinearRing, minx, miny);
OGR_G_AddGeometryDirectly(hRectangle, hLinearRing);
OGR_F_SetGeometryDirectly(hFeat, hRectangle);
if( OGR_L_CreateFeature(hMetadataLayer, hFeat) != OGRERR_NONE )
eErr = CE_Failure;
OGR_F_Destroy(hFeat);
nBlocks++;
if (pfnProgress && !pfnProgress(1.0 * nBlocks / nTotalBlocks,
NULL, pProgressData))
eErr = CE_Failure;
}
}
if (eErr == CE_None)
OGR_DS_ExecuteSQL(hDS, "COMMIT", NULL, NULL);
else
OGR_DS_ExecuteSQL(hDS, "ROLLBACK", NULL, NULL);
CSLDestroy(papszTileDriverOptions);
VSIFree(pabyMEMDSBuffer);
OGRReleaseDataSource(hDS);
if( eErr == CE_Failure )
return NULL;
return reinterpret_cast<GDALDataset *>(
GDALOpen( pszFilename, GA_Update ) );
}
GDALDataset *GS7BGDataset::CreateCopy( const char *pszFilename,
GDALDataset *poSrcDS,
int bStrict,
CPL_UNUSED char **papszOptions,
GDALProgressFunc pfnProgress,
void *pProgressData )
{
if( pfnProgress == NULL )
pfnProgress = GDALDummyProgress;
int nBands = poSrcDS->GetRasterCount();
if (nBands == 0)
{
CPLError( CE_Failure, CPLE_NotSupported,
"Driver does not support source dataset with zero band.\n");
return NULL;
}
else if (nBands > 1)
{
if( bStrict )
{
CPLError( CE_Failure, CPLE_NotSupported,
"Unable to create copy, "
"format only supports one raster band.\n" );
return NULL;
}
else
CPLError( CE_Warning, CPLE_NotSupported,
"Format only supports one "
"raster band, first band will be copied.\n" );
}
GDALRasterBand *poSrcBand = poSrcDS->GetRasterBand( 1 );
if( !pfnProgress( 0.0, NULL, pProgressData ) )
{
CPLError( CE_Failure, CPLE_UserInterrupt, "User terminated\n" );
return NULL;
}
VSILFILE *fp = VSIFOpenL( pszFilename, "w+b" );
if( fp == NULL )
{
CPLError( CE_Failure, CPLE_OpenFailed,
"Attempt to create file '%s' failed.\n",
pszFilename );
return NULL;
}
GInt32 nXSize = poSrcBand->GetXSize();
GInt32 nYSize = poSrcBand->GetYSize();
double adfGeoTransform[6];
poSrcDS->GetGeoTransform( adfGeoTransform );
double dfMinX = adfGeoTransform[0] + adfGeoTransform[1] / 2;
double dfMaxX = adfGeoTransform[1] * (nXSize - 0.5) + adfGeoTransform[0];
double dfMinY = adfGeoTransform[5] * (nYSize - 0.5) + adfGeoTransform[3];
double dfMaxY = adfGeoTransform[3] + adfGeoTransform[5] / 2;
CPLErr eErr = WriteHeader( fp, nXSize, nYSize,
dfMinX, dfMaxX, dfMinY, dfMaxY, 0.0, 0.0 );
if( eErr != CE_None )
{
VSIFCloseL( fp );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Copy band data. */
/* -------------------------------------------------------------------- */
double *pfData = (double *)VSIMalloc2( nXSize, sizeof( double ) );
if( pfData == NULL )
{
VSIFCloseL( fp );
CPLError( CE_Failure, CPLE_OutOfMemory,
"Unable to create copy, unable to allocate line buffer.\n" );
return NULL;
}
int bSrcHasNDValue;
double dfSrcNoDataValue = poSrcBand->GetNoDataValue( &bSrcHasNDValue );
double dfMinZ = DBL_MAX;
double dfMaxZ = -DBL_MAX;
for( GInt32 iRow = nYSize - 1; iRow >= 0; iRow-- )
{
eErr = poSrcBand->RasterIO( GF_Read, 0, iRow,
nXSize, 1, pfData,
nXSize, 1, GDT_Float64, 0, 0, NULL );
if( eErr != CE_None )
{
VSIFCloseL( fp );
VSIFree( pfData );
return NULL;
}
for( int iCol=0; iCol<nXSize; iCol++ )
{
if( bSrcHasNDValue && pfData[iCol] == dfSrcNoDataValue )
{
pfData[iCol] = dfNoData_Value;
}
else
{
if( pfData[iCol] > dfMaxZ )
dfMaxZ = pfData[iCol];
if( pfData[iCol] < dfMinZ )
dfMinZ = pfData[iCol];
}
CPL_LSBPTR32( pfData+iCol );
}
if( VSIFWriteL( (void *)pfData, sizeof( double ), nXSize,
fp ) != static_cast<unsigned>(nXSize) )
{
VSIFCloseL( fp );
VSIFree( pfData );
CPLError( CE_Failure, CPLE_FileIO,
"Unable to write grid row. Disk full?\n" );
return NULL;
}
if( !pfnProgress( static_cast<double>(nYSize - iRow)/nYSize,
NULL, pProgressData ) )
{
VSIFCloseL( fp );
VSIFree( pfData );
CPLError( CE_Failure, CPLE_UserInterrupt, "User terminated" );
return NULL;
}
}
VSIFree( pfData );
/* write out the min and max values */
eErr = WriteHeader( fp, nXSize, nYSize,
dfMinX, dfMaxX, dfMinY, dfMaxY, dfMinZ, dfMaxZ );
if( eErr != CE_None )
{
VSIFCloseL( fp );
return NULL;
}
VSIFCloseL( fp );
GDALPamDataset *poDS = (GDALPamDataset *)GDALOpen( pszFilename,
GA_Update );
if (poDS)
{
poDS->CloneInfo( poSrcDS, GCIF_PAM_DEFAULT );
}
return poDS;
}
GDALDataset *
RCreateCopy( const char * pszFilename, GDALDataset *poSrcDS,
int bStrict, char ** papszOptions,
GDALProgressFunc pfnProgress, void * pProgressData )
{
int nBands = poSrcDS->GetRasterCount();
int nXSize = poSrcDS->GetRasterXSize();
int nYSize = poSrcDS->GetRasterYSize();
int bASCII = CSLFetchBoolean( papszOptions, "ASCII", FALSE );
int bCompressed = CSLFetchBoolean( papszOptions, "COMPRESS", !bASCII );
/* -------------------------------------------------------------------- */
/* Some some rudimentary checks */
/* -------------------------------------------------------------------- */
/* -------------------------------------------------------------------- */
/* Setup the filename to actually use. We prefix with */
/* /vsigzip/ if we want compressed output. */
/* -------------------------------------------------------------------- */
CPLString osAdjustedFilename;
if( bCompressed )
osAdjustedFilename = "/vsigzip/";
osAdjustedFilename += pszFilename;
/* -------------------------------------------------------------------- */
/* Create the file. */
/* -------------------------------------------------------------------- */
FILE *fp;
fp = VSIFOpenL( osAdjustedFilename, "wb" );
if( fp == NULL )
{
CPLError( CE_Failure, CPLE_OpenFailed,
"Unable to create file %s.\n",
pszFilename );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Write header with version, etc. */
/* -------------------------------------------------------------------- */
if( bASCII )
{
const char *pszHeader = "RDA2\nA\n";
VSIFWriteL( pszHeader, 1, strlen(pszHeader), fp );
}
else
{
const char *pszHeader = "RDX2\nX\n";
VSIFWriteL( pszHeader, 1, strlen(pszHeader), fp );
}
RWriteInteger( fp, bASCII, 2 );
RWriteInteger( fp, bASCII, 133377 );
RWriteInteger( fp, bASCII, 131840 );
/* -------------------------------------------------------------------- */
/* Establish the primary pairlist with one component object. */
/* -------------------------------------------------------------------- */
RWriteInteger( fp, bASCII, 1026 );
RWriteInteger( fp, bASCII, 1 );
/* -------------------------------------------------------------------- */
/* Write the object name. Eventually we should derive this */
/* from the filename, possible with override by a creation */
/* option. */
/* -------------------------------------------------------------------- */
RWriteString( fp, bASCII, "gg" );
/* -------------------------------------------------------------------- */
/* For now we write the raster as a numeric array with */
/* attributes (526). */
/* -------------------------------------------------------------------- */
RWriteInteger( fp, bASCII, 526 );
RWriteInteger( fp, bASCII, nXSize * nYSize * nBands );
/* -------------------------------------------------------------------- */
/* Write the raster data. */
/* -------------------------------------------------------------------- */
double *padfScanline;
CPLErr eErr = CE_None;
int iLine;
padfScanline = (double *) CPLMalloc( nXSize * sizeof(double) );
for( int iBand = 0; iBand < nBands; iBand++ )
{
GDALRasterBand * poBand = poSrcDS->GetRasterBand( iBand+1 );
for( iLine = 0; iLine < nYSize && eErr == CE_None; iLine++ )
{
int iValue;
eErr = poBand->RasterIO( GF_Read, 0, iLine, nXSize, 1,
padfScanline, nXSize, 1, GDT_Float64,
sizeof(double), 0 );
if( bASCII )
{
for( iValue = 0; iValue < nXSize; iValue++ )
{
char szValue[128];
sprintf(szValue,"%.16g\n", padfScanline[iValue] );
VSIFWriteL( szValue, 1, strlen(szValue), fp );
}
}
else
{
for( iValue = 0; iValue < nXSize; iValue++ )
CPL_MSBPTR64( padfScanline + iValue );
VSIFWriteL( padfScanline, 8, nXSize, fp );
}
if( eErr == CE_None
&& !pfnProgress( (iLine+1) / (double) nYSize,
NULL, pProgressData ) )
{
eErr = CE_Failure;
CPLError( CE_Failure, CPLE_UserInterrupt,
"User terminated CreateCopy()" );
}
}
}
CPLFree( padfScanline );
/* -------------------------------------------------------------------- */
/* Write out the dims attribute. */
/* -------------------------------------------------------------------- */
RWriteInteger( fp, bASCII, 1026 );
RWriteInteger( fp, bASCII, 1 );
RWriteString( fp, bASCII, "dim" );
RWriteInteger( fp, bASCII, 13 );
RWriteInteger( fp, bASCII, 3 );
RWriteInteger( fp, bASCII, nXSize );
RWriteInteger( fp, bASCII, nYSize );
RWriteInteger( fp, bASCII, nBands );
RWriteInteger( fp, bASCII, 254 );
/* -------------------------------------------------------------------- */
/* Terminate overall pairlist. */
/* -------------------------------------------------------------------- */
RWriteInteger( fp, bASCII, 254 );
/* -------------------------------------------------------------------- */
/* Cleanup. */
/* -------------------------------------------------------------------- */
VSIFCloseL( fp );
if( eErr != CE_None )
return NULL;
/* -------------------------------------------------------------------- */
/* Re-open dataset, and copy any auxilary pam information. */
/* -------------------------------------------------------------------- */
GDALPamDataset *poDS =
(GDALPamDataset *) GDALOpen( pszFilename, GA_ReadOnly );
if( poDS )
poDS->CloneInfo( poSrcDS, GCIF_PAM_DEFAULT );
return poDS;
}
GDALDataset *IntergraphDataset::CreateCopy( const char *pszFilename,
GDALDataset *poSrcDS,
int bStrict,
char **papszOptions,
GDALProgressFunc pfnProgress,
void *pProgressData )
{
(void) bStrict;
int nBands = poSrcDS->GetRasterCount();
if (nBands == 0)
{
CPLError( CE_Failure, CPLE_NotSupported,
"Intergraph driver does not support source dataset with zero band.\n");
return NULL;
}
if( !pfnProgress( 0.0, NULL, pProgressData ) )
{
return NULL;
}
// --------------------------------------------------------------------
// Query GDAL Data Type
// --------------------------------------------------------------------
GDALDataType eType = poSrcDS->GetRasterBand(1)->GetRasterDataType();
// --------------------------------------------------------------------
// Copy metadata
// --------------------------------------------------------------------
char **papszCreateOptions = CSLDuplicate( papszOptions );
const char *pszValue;
pszValue = CSLFetchNameValue(papszCreateOptions, "RESOLUTION");
if( pszValue == NULL )
{
const char *value = poSrcDS->GetMetadataItem("RESOLUTION");
if (value)
{
papszCreateOptions = CSLSetNameValue( papszCreateOptions, "RESOLUTION",
value );
}
}
// --------------------------------------------------------------------
// Create IntergraphDataset
// --------------------------------------------------------------------
IntergraphDataset *poDstDS;
poDstDS = (IntergraphDataset*) IntergraphDataset::Create( pszFilename,
poSrcDS->GetRasterXSize(),
poSrcDS->GetRasterYSize(),
poSrcDS->GetRasterCount(),
eType,
papszCreateOptions );
CSLDestroy( papszCreateOptions );
if( poDstDS == NULL )
{
return NULL;
}
// --------------------------------------------------------------------
// Copy Transformation Matrix to the dataset
// --------------------------------------------------------------------
double adfGeoTransform[6];
poDstDS->SetProjection( poSrcDS->GetProjectionRef() );
poSrcDS->GetGeoTransform( adfGeoTransform );
poDstDS->SetGeoTransform( adfGeoTransform );
// --------------------------------------------------------------------
// Copy information to the raster band
// --------------------------------------------------------------------
GDALRasterBand *poSrcBand;
GDALRasterBand *poDstBand;
double dfMin;
double dfMax;
double dfMean;
double dfStdDev = -1;
for( int i = 1; i <= poDstDS->nBands; i++)
{
delete poDstDS->GetRasterBand(i);
}
poDstDS->nBands = 0;
if( poDstDS->hHeaderOne.DataTypeCode == Uncompressed24bit )
{
poDstDS->SetBand( 1, new IntergraphRGBBand( poDstDS, 1, 0, 3 ) );
poDstDS->SetBand( 2, new IntergraphRGBBand( poDstDS, 2, 0, 2 ) );
poDstDS->SetBand( 3, new IntergraphRGBBand( poDstDS, 3, 0, 1 ) );
poDstDS->nBands = 3;
}
else
{
for( int i = 1; i <= poSrcDS->GetRasterCount(); i++ )
{
poSrcBand = poSrcDS->GetRasterBand(i);
eType = poSrcDS->GetRasterBand(i)->GetRasterDataType();
poDstBand = new IntergraphRasterBand( poDstDS, i, 0, eType );
poDstDS->SetBand( i, poDstBand );
poDstBand->SetCategoryNames( poSrcBand->GetCategoryNames() );
poDstBand->SetColorTable( poSrcBand->GetColorTable() );
poSrcBand->GetStatistics( false, true, &dfMin, &dfMax, &dfMean, &dfStdDev );
poDstBand->SetStatistics( dfMin, dfMax, dfMean, dfStdDev );
}
}
// --------------------------------------------------------------------
// Copy image data
// --------------------------------------------------------------------
int nXSize = poDstDS->GetRasterXSize();
int nYSize = poDstDS->GetRasterYSize();
int nBlockXSize;
int nBlockYSize;
CPLErr eErr = CE_None;
for( int iBand = 1; iBand <= poSrcDS->GetRasterCount(); iBand++ )
{
GDALRasterBand *poDstBand = poDstDS->GetRasterBand( iBand );
GDALRasterBand *poSrcBand = poSrcDS->GetRasterBand( iBand );
// ------------------------------------------------------------
// Copy Untiled / Uncompressed
// ------------------------------------------------------------
int iYOffset, iXOffset;
void *pData;
poSrcBand->GetBlockSize( &nBlockXSize, &nBlockYSize );
nBlockXSize = nXSize;
nBlockYSize = 1;
pData = CPLMalloc( nBlockXSize * nBlockYSize * GDALGetDataTypeSize( eType ) / 8 );
for( iYOffset = 0; iYOffset < nYSize; iYOffset += nBlockYSize )
{
for( iXOffset = 0; iXOffset < nXSize; iXOffset += nBlockXSize )
{
eErr = poSrcBand->RasterIO( GF_Read,
iXOffset, iYOffset,
nBlockXSize, nBlockYSize,
pData, nBlockXSize, nBlockYSize,
eType, 0, 0 );
if( eErr != CE_None )
{
return NULL;
}
eErr = poDstBand->RasterIO( GF_Write,
iXOffset, iYOffset,
nBlockXSize, nBlockYSize,
pData, nBlockXSize, nBlockYSize,
eType, 0, 0 );
if( eErr != CE_None )
{
return NULL;
}
}
if( ( eErr == CE_None ) && ( ! pfnProgress(
( iYOffset + 1 ) / ( double ) nYSize, NULL, pProgressData ) ) )
{
eErr = CE_Failure;
CPLError( CE_Failure, CPLE_UserInterrupt, "User terminated CreateCopy()" );
}
}
CPLFree( pData );
}
// --------------------------------------------------------------------
// Finalize
// --------------------------------------------------------------------
poDstDS->FlushCache();
return poDstDS;
}
/* TODO: check if georeference is the same as for BLX files, WGS84
*/
static GDALDataset *
BLXCreateCopy( const char * pszFilename, GDALDataset *poSrcDS,
int bStrict, char ** papszOptions,
GDALProgressFunc pfnProgress, void * pProgressData )
{
int nBands = poSrcDS->GetRasterCount();
int nXSize = poSrcDS->GetRasterXSize();
int nYSize = poSrcDS->GetRasterYSize();
int zscale = 1;
int fillundef = 1, fillundefval = 0;
int endian = LITTLEENDIAN;
// --------------------------------------------------------------------
// Some rudimentary checks
// --------------------------------------------------------------------
if( nBands != 1 )
{
CPLError( CE_Failure, CPLE_NotSupported,
"BLX driver doesn't support %d bands. Must be 1 (grey) ",
nBands );
return NULL;
}
if( poSrcDS->GetRasterBand(1)->GetRasterDataType() != GDT_Int16 && bStrict )
{
CPLError( CE_Failure, CPLE_NotSupported,
"BLX driver doesn't support data type %s. "
"Only 16 bit byte bands supported.\n",
GDALGetDataTypeName(
poSrcDS->GetRasterBand(1)->GetRasterDataType()) );
return NULL;
}
if( (nXSize % 128 != 0) || (nYSize % 128 != 0) ) {
CPLError( CE_Failure, CPLE_NotSupported,
"BLX driver doesn't support dimensions that are not a multiple of 128.\n");
return NULL;
}
// --------------------------------------------------------------------
// What options has the user selected?
// --------------------------------------------------------------------
if( CSLFetchNameValue(papszOptions,"ZSCALE") != NULL ) {
zscale = atoi(CSLFetchNameValue(papszOptions,"ZSCALE"));
if( zscale < 1 ) {
CPLError( CE_Failure, CPLE_IllegalArg,
"ZSCALE=%s is not a legal value in the range >= 1.",
CSLFetchNameValue(papszOptions,"ZSCALE") );
return NULL;
}
}
if( CSLFetchNameValue(papszOptions,"FILLUNDEF") != NULL
&& EQUAL(CSLFetchNameValue(papszOptions,"FILLUNDEF"),"NO") )
fillundef = 0;
else
fillundef = 1;
if( CSLFetchNameValue(papszOptions,"FILLUNDEFVAL") != NULL ) {
fillundefval = atoi(CSLFetchNameValue(papszOptions,"FILLUNDEFVAL"));
if( (fillundefval < -32768) || (fillundefval > 32767) ) {
CPLError( CE_Failure, CPLE_IllegalArg,
"FILLUNDEFVAL=%s is not a legal value in the range -32768, 32767.",
CSLFetchNameValue(papszOptions,"FILLUNDEFVAL") );
return NULL;
}
}
if( CSLFetchNameValue(papszOptions,"BIGENDIAN") != NULL
&& !EQUAL(CSLFetchNameValue(papszOptions,"BIGENDIAN"),"NO") )
endian = BIGENDIAN;
// --------------------------------------------------------------------
// Create the dataset.
// --------------------------------------------------------------------
blxcontext_t *ctx;
// Create a BLX context
ctx = blx_create_context();
// Setup BLX parameters
ctx->cell_rows = nYSize / ctx->cell_ysize;
ctx->cell_cols = nXSize / ctx->cell_xsize;
ctx->zscale = zscale;
ctx->fillundef = fillundef;
ctx->fillundefval = fillundefval;
ctx->endian = endian;
if(blxopen(ctx, pszFilename, "wb")) {
CPLError( CE_Failure, CPLE_OpenFailed,
"Unable to create blx file %s.\n",
pszFilename );
blx_free_context(ctx);
return NULL;
}
// --------------------------------------------------------------------
// Loop over image, copying image data.
// --------------------------------------------------------------------
GInt16 *pabyTile;
CPLErr eErr=CE_None;
pabyTile = (GInt16 *) VSIMalloc( sizeof(GInt16)*ctx->cell_xsize*ctx->cell_ysize );
if (pabyTile == NULL)
{
CPLError( CE_Failure, CPLE_OutOfMemory, "Out of memory");
blxclose(ctx);
blx_free_context(ctx);
return NULL;
}
if( !pfnProgress( 0.0, NULL, pProgressData ) )
eErr = CE_Failure;
for(int i=0; (i < ctx->cell_rows) && (eErr == CE_None); i++)
for(int j=0; j < ctx->cell_cols; j++) {
blxdata *celldata;
GDALRasterBand * poBand = poSrcDS->GetRasterBand( 1 );
eErr = poBand->RasterIO( GF_Read, j*ctx->cell_xsize, i*ctx->cell_ysize,
ctx->cell_xsize, ctx->cell_ysize,
pabyTile, ctx->cell_xsize, ctx->cell_ysize, GDT_Int16,
0, 0 );
if(eErr >= CE_Failure)
break;
celldata = pabyTile;
if (blx_writecell(ctx, celldata, i, j) != 0)
{
eErr = CE_Failure;
break;
}
if ( ! pfnProgress( 1.0 * (i * ctx->cell_cols + j) / (ctx->cell_rows * ctx->cell_cols), NULL, pProgressData ))
{
eErr = CE_Failure;
break;
}
}
pfnProgress( 1.0, NULL, pProgressData );
CPLFree( pabyTile );
double adfGeoTransform[6];
if( poSrcDS->GetGeoTransform( adfGeoTransform ) == CE_None )
{
ctx->lon = adfGeoTransform[0];
ctx->lat = adfGeoTransform[3];
ctx->pixelsize_lon = adfGeoTransform[1];
ctx->pixelsize_lat = adfGeoTransform[5];
}
blxclose(ctx);
blx_free_context(ctx);
if (eErr == CE_None)
return (GDALDataset *) GDALOpen( pszFilename, GA_ReadOnly );
else
return NULL;
}
