SIGDEMRasterBand::SIGDEMRasterBand(
SIGDEMDataset *poDSIn,
VSILFILE *fpRawIn,
double dfMinZ,
double dfMaxZ) :
dfOffsetZ(poDSIn->sHeader.dfOffsetZ),
dfScaleFactorZ(poDSIn->sHeader.dfScaleFactorZ),
fpRawL(fpRawIn) {
this->poDS = poDSIn;
this->nBand = 1;
this->nRasterXSize = poDSIn->GetRasterXSize();
this->nRasterYSize = poDSIn->GetRasterYSize();
this->nBlockXSize = this->nRasterXSize;
this->nBlockYSize = 1;
this->eDataType = GDT_Float64;
this->nBlockSizeBytes = nRasterXSize * CELL_SIZE_FILE;
this->pBlockBuffer = static_cast<int32_t*>(
VSI_MALLOC2_VERBOSE(nRasterXSize, sizeof(int32_t)));
SetNoDataValue(-9999);
CPLString osValue;
SetMetadataItem("STATISTICS_MINIMUM", osValue.Printf("%.15g", dfMinZ));
SetMetadataItem("STATISTICS_MAXIMUM", osValue.Printf("%.15g", dfMaxZ));
}
CPLErr GDALRescaledAlphaBand::IRasterIO(
GDALRWFlag eRWFlag,
int nXOff, int nYOff, int nXSize, int nYSize,
void * pData, int nBufXSize, int nBufYSize,
GDALDataType eBufType,
GSpacing nPixelSpace,
GSpacing nLineSpace,
GDALRasterIOExtraArg* psExtraArg )
{
// Optimization in common use case.
// This avoids triggering the block cache on this band, which helps
// reducing the global block cache consumption.
if( eRWFlag == GF_Read && eBufType == GDT_Byte &&
nXSize == nBufXSize && nYSize == nBufYSize &&
nPixelSpace == 1 )
{
if( pTemp == NULL )
{
pTemp = VSI_MALLOC2_VERBOSE( sizeof(GUInt16), nRasterXSize );
if( pTemp == NULL )
{
return CE_Failure;
}
}
for( int j = 0; j < nBufYSize; j++ )
{
const CPLErr eErr =
poParent->RasterIO( GF_Read, nXOff, nYOff + j, nXSize, 1,
pTemp, nBufXSize, 1,
GDT_UInt16,
0, 0, NULL );
if( eErr != CE_None )
return eErr;
GByte* pabyImage = static_cast<GByte*>(pData) + j * nLineSpace;
GUInt16* pSrc = static_cast<GUInt16 *>(pTemp);
for( int i = 0; i < nBufXSize; i++ )
{
// In case the dynamics was actually 0-255 and not 0-65535 as
// expected, we want to make sure non-zero alpha will still
// be non-zero.
if( pSrc[i] > 0 && pSrc[i] < 257 )
pabyImage[i] = 1;
else
pabyImage[i] = static_cast<GByte>((pSrc[i] * 255) / 65535);
}
}
return CE_None;
}
return GDALRasterBand::IRasterIO( eRWFlag, nXOff, nYOff, nXSize, nYSize,
pData, nBufXSize, nBufYSize,
eBufType,
nPixelSpace, nLineSpace, psExtraArg );
}
CPLErr GS7BGRasterBand::ScanForMinMaxZ()
{
GS7BGDataset* poGDS = reinterpret_cast<GS7BGDataset*>(poDS);
double *pafRowVals = (double *)VSI_MALLOC2_VERBOSE( nRasterXSize, sizeof(double));
if( pafRowVals == NULL )
{
return CE_Failure;
}
double dfNewMinZ = DBL_MAX;
double dfNewMaxZ = -DBL_MAX;
int nNewMinZRow = 0;
int nNewMaxZRow = 0;
/* Since we have to scan, lets calc. statistics too */
double dfSum = 0.0;
double dfSum2 = 0.0;
unsigned long nValuesRead = 0;
for( int iRow=0; iRow<nRasterYSize; iRow++ )
{
CPLErr eErr = IReadBlock( 0, iRow, pafRowVals );
if( eErr != CE_None )
{
VSIFree( pafRowVals );
return CE_Failure;
}
pafRowMinZ[iRow] = FLT_MAX;
pafRowMaxZ[iRow] = -FLT_MAX;
for( int iCol=0; iCol<nRasterXSize; iCol++ )
{
if( pafRowVals[iCol] == poGDS->dfNoData_Value )
continue;
if( pafRowVals[iCol] < pafRowMinZ[iRow] )
pafRowMinZ[iRow] = pafRowVals[iCol];
if( pafRowVals[iCol] > pafRowMinZ[iRow] )
pafRowMaxZ[iRow] = pafRowVals[iCol];
dfSum += pafRowVals[iCol];
dfSum2 += pafRowVals[iCol] * pafRowVals[iCol];
nValuesRead++;
}
if( pafRowMinZ[iRow] < dfNewMinZ )
{
dfNewMinZ = pafRowMinZ[iRow];
nNewMinZRow = iRow;
}
if( pafRowMaxZ[iRow] > dfNewMaxZ )
{
dfNewMaxZ = pafRowMaxZ[iRow];
nNewMaxZRow = iRow;
}
}
VSIFree( pafRowVals );
if( nValuesRead == 0 )
{
dfMinZ = 0.0;
dfMaxZ = 0.0;
nMinZRow = 0;
nMaxZRow = 0;
return CE_None;
}
dfMinZ = dfNewMinZ;
dfMaxZ = dfNewMaxZ;
nMinZRow = nNewMinZRow;
nMaxZRow = nNewMaxZRow;
double dfMean = dfSum / nValuesRead;
double dfStdDev = sqrt((dfSum2 / nValuesRead) - (dfMean * dfMean));
SetStatistics( dfMinZ, dfMaxZ, dfMean, dfStdDev );
return CE_None;
}
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 *)VSI_MALLOC2_VERBOSE( nXSize, sizeof( double ) );
if( pfData == NULL )
{
VSIFCloseL( fp );
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] = dfDefaultNoDataValue;
}
else
{
if( pfData[iCol] > dfMaxZ )
dfMaxZ = pfData[iCol];
if( pfData[iCol] < dfMinZ )
dfMinZ = pfData[iCol];
}
CPL_LSBPTR64( 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;
}
int OGRSOSIDataSource::Open( const char *pszFilename, int bUpdate ) {
papoBuiltGeometries = NULL;
poFileadm = NULL;
poBaseadm = NULL;
char *pszPos;
if ( bUpdate ) {
CPLError( CE_Failure, CPLE_OpenFailed,
"Update access not supported by the SOSI driver." );
return FALSE;
}
/* Check that the file exists otherwise HO_TestSOSI() emits an error */
VSIStatBuf sStat;
if( VSIStat(pszFilename, &sStat) != 0 )
return FALSE;
pszName = CPLStrdup( pszFilename );
/* We ignore any layer parameters for now. */
pszPos = strchr(pszName, ',');
if (pszPos != NULL) {
pszPos[0] = '\0';
}
/* Confirm that we are dealing with a SOSI file. Used also by data
* format auto-detection in some ogr utilities. */
UT_INT64 nEnd = 0;
int bIsSosi = HO_TestSOSI ( pszName, &nEnd );
if ( bIsSosi == UT_FALSE ) {
return FALSE; /* No error message: This is used by file format auto-detection */
}
short nStatus = 0, nDetStatus = 0; /* immediate status, detailed status */
/* open index base and sosi file */
poBaseadm = LC_OpenBase(LC_BASE);
nStatus = LC_OpenSos(pszName, LC_BASE_FRAMGR, LC_GML_IDX, LC_INGEN_STATUS,
&poFileadm, &nDetStatus);
if ( nStatus == UT_FALSE ) {
char *pszErrorMessage;
LC_StrError(nDetStatus, &pszErrorMessage);
CPLError( CE_Failure, CPLE_OpenFailed,
"File %s could not be opened by SOSI Driver: %s", pszName, pszErrorMessage );
return FALSE;
}
/* --------------------------------------------------------------------*
* Prefetch all the information needed to determine layers *
* and prebuild LineString features for later assembly. *
* --------------------------------------------------------------------*/
/* allocate room for one pointer per feature */
nNumFeatures = static_cast<unsigned int>(poFileadm->lAntGr);
void* mem = VSI_MALLOC2_VERBOSE(nNumFeatures, sizeof(void*));
if (mem == NULL) {
return FALSE;
} else {
papoBuiltGeometries = (OGRGeometry**)mem;
}
for (unsigned int i=0; i<nNumFeatures; i++) papoBuiltGeometries[i] = NULL;
/* Various iterators and return values used to iterate through SOSI features */
short nName, nNumLines;
long nNumCoo;
unsigned short nInfo;
LC_SNR_ADM oSnradm;
LC_BGR oNextSerial;
LC_BGR *poNextSerial;
poNextSerial =&oNextSerial;
bool bPointLayer = FALSE; /* Initialize four layers for the different geometry types */
bool bCurveLayer = FALSE;
bool bPolyLayer = FALSE;
bool bTextLayer = FALSE;
poPolyHeaders = new S2I();
poPointHeaders = new S2I();
poCurveHeaders = new S2I();
poTextHeaders = new S2I();
LC_SBSn(&oSnradm, poFileadm, 0, nNumFeatures); /* Set FYBA search limits */
LC_InitNextBgr(poNextSerial);
/* Prebuilding simple features and extracting layer information. */
while (LC_NextBgr(poNextSerial,LC_FRAMGR)) {
/* Fetch next group information */
nName = LC_RxGr(poNextSerial, LES_OPTIMALT, &nNumLines, &nNumCoo, &nInfo);
S2S oHeaders;
S2S::iterator iHeaders;
int iH;
/* Extract all strings from group header. */
for (short i=1; i<=nNumLines; i++) {
char *pszLine = LC_GetGi(i); /* Get one header line */
if ((pszLine[0] == ':')||(pszLine[0] == '(')) continue; /* If we have a continued REF line, skip it. */
if (pszLine[0] == '!') continue; /* If we have a comment line, skip it. */
char *pszUTFLine = CPLRecode(pszLine, pszEncoding, CPL_ENC_UTF8); /* switch to UTF encoding here, if it is known. */
char *pszUTFLineIter = pszUTFLine;
while (pszUTFLineIter[0] == '.') pszUTFLineIter++; /* Skipping the dots at the beginning of a SOSI line */
char *pszPos2 = strstr(pszUTFLineIter, " "); /* Split header and value */
if (pszPos2 != NULL) {
CPLString osKey = CPLString(std::string(pszUTFLineIter,pszPos2)); /* FIXME: clean instantiation of CPLString? */
CPLString osValue = CPLString(pszPos2+1);
oHeaders[osKey]=osValue; /* Add to header map */
switch (nName) { /* Add to header list for the corresponding layer, if it is not */
case L_FLATE: { /* in there already */
if (poPolyHeaders->find(osKey) == poPolyHeaders->end()) {
iH = static_cast<int>(poPolyHeaders->size());
(*poPolyHeaders)[osKey] = iH;
}
break;
}
case L_KURVE:
case L_LINJE:
case L_BUEP: { /* FIXME: maybe not use the same headers for both */
if (poCurveHeaders->find(osKey) == poCurveHeaders->end()) {
iH = static_cast<int>(poCurveHeaders->size());
(*poCurveHeaders)[osKey] = iH;
}
break;
}
case L_PUNKT:
case L_SYMBOL: {
if (poPointHeaders->find(osKey) == poPointHeaders->end()) {
iH = static_cast<int>(poPointHeaders->size());
(*poPointHeaders)[osKey] = iH;
}
break;
}
case L_TEKST: {
if (poTextHeaders->find(osKey) == poTextHeaders->end()) {
iH = static_cast<int>(poTextHeaders->size());
(*poTextHeaders)[osKey] = iH;
}
break;
}
}
}
CPLFree(pszUTFLine);
}
/* Feature-specific tasks */
switch (nName) {
case L_PUNKT: {
/* Pre-build a point feature. Activate point layer. */
bPointLayer = TRUE;
buildOGRPoint(oNextSerial.lNr);
break;
}
case L_FLATE: {
/* Activate polygon layer. */
bPolyLayer = TRUE;
/* cannot build geometries that reference others yet */
break;
}
case L_KURVE:
case L_LINJE: {
/* Pre-build a line feature. Activate line/curve layer. */
bCurveLayer = TRUE;
buildOGRLineString(static_cast<int>(nNumCoo), oNextSerial.lNr);
break;
}
case L_BUEP: {
/* Pre-build a line feature as interpolation from an arc. Activate line/curve layer. */
bCurveLayer = TRUE;
buildOGRLineStringFromArc(oNextSerial.lNr);
break;
}
case L_TEKST: {
/* Pre-build a text line contour feature. Activate text layer. */
/* Todo: observe only points 2ff if more than one point is given for follow mode */
bTextLayer = TRUE;
buildOGRMultiPoint(static_cast<int>(nNumCoo), oNextSerial.lNr);
break;
}
case L_HODE: {
/* Get SRS from SOSI header. */
unsigned short nMask = LC_TR_ALLT;
LC_TRANSPAR oTrans;
if (LC_GetTransEx(&nMask,&oTrans) == UT_FALSE) {
CPLError( CE_Failure, CPLE_OpenFailed,
"TRANSPAR section not found - No reference system information available.");
return FALSE;
}
poSRS = new OGRSpatialReference();
/* Get coordinate system from SOSI header. */
int nEPSG = sosi2epsg(oTrans.sKoordsys);
if (poSRS->importFromEPSG(nEPSG) != OGRERR_NONE) {
CPLError( CE_Failure, CPLE_OpenFailed,
"OGR could not load coordinate system definition EPSG:%i.", nEPSG);
return FALSE;
}
/* Get character encoding from SOSI header. */
iHeaders = oHeaders.find("TEGNSETT");
if (iHeaders != oHeaders.end()) {
CPLString osLine = iHeaders->second;
if (osLine.compare("ISO8859-1")==0) {
pszEncoding = CPL_ENC_ISO8859_1;
} else if (osLine.compare("ISO8859-10")==0) {
pszEncoding = CPL_ENC_ISO8859_10;
} else if (osLine.compare("UTF-8")==0) {
pszEncoding = CPL_ENC_UTF8;
}
}
break;
}
default: {
break;
}
}
}
/* -------------------------------------------------------------------- *
* Create a corresponding layers. One per geometry type *
* -------------------------------------------------------------------- */
int l_nLayers = 0;
if (bPolyLayer) l_nLayers++;
if (bCurveLayer) l_nLayers++;
if (bPointLayer) l_nLayers++;
if (bTextLayer) l_nLayers++;
this->nLayers = l_nLayers;
/* allocate some memory for up to three layers */
papoLayers = (OGRSOSILayer **) VSI_MALLOC2_VERBOSE(sizeof(void*), l_nLayers);
if( papoLayers == NULL )
{
this->nLayers = 0;
return FALSE;
}
/* Define each layer, using a proper feature definition, geometry type,
* and adding every SOSI header encountered in the file as field. */
S2I::iterator i;
if (bPolyLayer) {
S2I * poHeadersNew = new S2I();
OGRFeatureDefn *poFeatureDefn = defineLayer("polygons", wkbPolygon, poPolyHeaders, &poHeadersNew);
delete poPolyHeaders;
poPolyHeaders = poHeadersNew;
poFeatureDefn->Reference();
papoLayers[--l_nLayers] = new OGRSOSILayer( this, poFeatureDefn, poFileadm, poPolyHeaders );
} else {
delete poPolyHeaders;
poPolyHeaders = NULL;
}
if (bCurveLayer) {
S2I * poHeadersNew = new S2I();
OGRFeatureDefn *poFeatureDefn = defineLayer("lines", wkbLineString, poCurveHeaders, &poHeadersNew);
delete poCurveHeaders;
poCurveHeaders = poHeadersNew;
poFeatureDefn->Reference();
papoLayers[--l_nLayers] = new OGRSOSILayer( this, poFeatureDefn, poFileadm, poCurveHeaders );
} else {
delete poCurveHeaders;
poCurveHeaders = NULL;
}
if (bPointLayer) {
S2I * poHeadersNew = new S2I();
OGRFeatureDefn *poFeatureDefn = defineLayer("points", wkbPoint, poPointHeaders, &poHeadersNew);
delete poPointHeaders;
poPointHeaders = poHeadersNew;
poFeatureDefn->Reference();
papoLayers[--l_nLayers] = new OGRSOSILayer( this, poFeatureDefn, poFileadm, poPointHeaders );
} else {
delete poPointHeaders;
poPointHeaders = NULL;
}
if (bTextLayer) {
S2I * poHeadersNew = new S2I();
OGRFeatureDefn *poFeatureDefn = defineLayer("text", wkbMultiPoint, poTextHeaders, &poHeadersNew);
delete poTextHeaders;
poTextHeaders = poHeadersNew;
poFeatureDefn->Reference();
papoLayers[--l_nLayers] = new OGRSOSILayer( this, poFeatureDefn, poFileadm, poTextHeaders );
} else {
delete poTextHeaders;
poTextHeaders = NULL;
}
return TRUE;
}
static CPLErr
GDALMultiFilter( GDALRasterBandH hTargetBand,
GDALRasterBandH hTargetMaskBand,
GDALRasterBandH hFiltMaskBand,
int nIterations,
GDALProgressFunc pfnProgress,
void * pProgressArg )
{
const int nXSize = GDALGetRasterBandXSize(hTargetBand);
const int nYSize = GDALGetRasterBandYSize(hTargetBand);
/* -------------------------------------------------------------------- */
/* Report starting progress value. */
/* -------------------------------------------------------------------- */
if( !pfnProgress( 0.0, "Smoothing Filter...", pProgressArg ) )
{
CPLError( CE_Failure, CPLE_UserInterrupt, "User terminated" );
return CE_Failure;
}
/* -------------------------------------------------------------------- */
/* Allocate rotating buffers. */
/* -------------------------------------------------------------------- */
const int nBufLines = nIterations + 2;
GByte *pabyTMaskBuf =
static_cast<GByte *>(VSI_MALLOC2_VERBOSE(nXSize, nBufLines));
GByte *pabyFMaskBuf =
static_cast<GByte *>(VSI_MALLOC2_VERBOSE(nXSize, nBufLines));
float *paf3PassLineBuf = static_cast<float *>(
VSI_MALLOC3_VERBOSE(nXSize, nBufLines, 3 * sizeof(float)));
if( pabyTMaskBuf == nullptr || pabyFMaskBuf == nullptr ||
paf3PassLineBuf == nullptr )
{
CPLFree( pabyTMaskBuf );
CPLFree( pabyFMaskBuf );
CPLFree( paf3PassLineBuf );
return CE_Failure;
}
/* -------------------------------------------------------------------- */
/* Process rotating buffers. */
/* -------------------------------------------------------------------- */
CPLErr eErr = CE_None;
int iPassCounter = 0;
for( int nNewLine = 0; // Line being loaded (zero based scanline).
eErr == CE_None && nNewLine < nYSize+nIterations;
nNewLine++ )
{
/* -------------------------------------------------------------------- */
/* Rotate pass buffers. */
/* -------------------------------------------------------------------- */
iPassCounter = (iPassCounter + 1) % 3;
float * const pafSLastPass =
paf3PassLineBuf + ((iPassCounter + 0) % 3) * nXSize * nBufLines;
float * const pafLastPass =
paf3PassLineBuf + ((iPassCounter + 1) % 3) * nXSize * nBufLines;
float * const pafThisPass =
paf3PassLineBuf + ((iPassCounter + 2) % 3) * nXSize * nBufLines;
/* -------------------------------------------------------------------- */
/* Where does the new line go in the rotating buffer? */
/* -------------------------------------------------------------------- */
const int iBufOffset = nNewLine % nBufLines;
/* -------------------------------------------------------------------- */
/* Read the new data line if it is't off the bottom of the */
/* image. */
/* -------------------------------------------------------------------- */
if( nNewLine < nYSize )
{
eErr =
GDALRasterIO( hTargetMaskBand, GF_Read,
0, nNewLine, nXSize, 1,
pabyTMaskBuf + nXSize * iBufOffset, nXSize, 1,
GDT_Byte, 0, 0 );
if( eErr != CE_None )
break;
eErr =
GDALRasterIO( hFiltMaskBand, GF_Read,
0, nNewLine, nXSize, 1,
pabyFMaskBuf + nXSize * iBufOffset, nXSize, 1,
GDT_Byte, 0, 0 );
if( eErr != CE_None )
break;
eErr =
GDALRasterIO( hTargetBand, GF_Read,
0, nNewLine, nXSize, 1,
pafThisPass + nXSize * iBufOffset, nXSize, 1,
GDT_Float32, 0, 0 );
if( eErr != CE_None )
break;
}
/* -------------------------------------------------------------------- */
/* Loop over the loaded data, applying the filter to all loaded */
/* lines with neighbours. */
/* -------------------------------------------------------------------- */
for( int iFLine = nNewLine-1;
eErr == CE_None && iFLine >= nNewLine-nIterations;
iFLine-- )
{
const int iLastOffset = (iFLine-1) % nBufLines;
const int iThisOffset = (iFLine ) % nBufLines;
const int iNextOffset = (iFLine+1) % nBufLines;
// Default to preserving the old value.
if( iFLine >= 0 )
memcpy( pafThisPass + iThisOffset * nXSize,
pafLastPass + iThisOffset * nXSize,
sizeof(float) * nXSize );
// TODO: Enable first and last line.
// Skip the first and last line.
if( iFLine < 1 || iFLine >= nYSize-1 )
{
continue;
}
GDALFilterLine(
pafSLastPass + iLastOffset * nXSize,
pafLastPass + iThisOffset * nXSize,
pafThisPass + iNextOffset * nXSize,
pafThisPass + iThisOffset * nXSize,
pabyTMaskBuf + iLastOffset * nXSize,
pabyTMaskBuf + iThisOffset * nXSize,
pabyTMaskBuf + iNextOffset * nXSize,
pabyFMaskBuf + iThisOffset * nXSize,
nXSize );
}
/* -------------------------------------------------------------------- */
/* Write out the top data line that will be rolling out of our */
/* buffer. */
/* -------------------------------------------------------------------- */
const int iLineToSave = nNewLine - nIterations;
if( iLineToSave >= 0 && eErr == CE_None )
{
const int iBufOffset2 = iLineToSave % nBufLines;
eErr =
GDALRasterIO( hTargetBand, GF_Write,
0, iLineToSave, nXSize, 1,
pafThisPass + nXSize * iBufOffset2, nXSize, 1,
GDT_Float32, 0, 0 );
}
/* -------------------------------------------------------------------- */
/* Report progress. */
/* -------------------------------------------------------------------- */
if( eErr == CE_None &&
!pfnProgress(
(nNewLine + 1) / static_cast<double>(nYSize+nIterations),
"Smoothing Filter...", pProgressArg) )
{
CPLError( CE_Failure, CPLE_UserInterrupt, "User terminated" );
eErr = CE_Failure;
}
}
/* -------------------------------------------------------------------- */
/* Cleanup */
/* -------------------------------------------------------------------- */
CPLFree( pabyTMaskBuf );
CPLFree( pabyFMaskBuf );
CPLFree( paf3PassLineBuf );
return eErr;
}
Track* GTM::fetchNextTrack()
{
/* Point to the actual track offset */
if ( VSIFSeekL(pGTMFile, actualTrackOffset, SEEK_SET) != 0)
return nullptr;
/* Read string length */
const unsigned short stringSize = readUShort(pGTMFile);
/* Read name string */
char* pszName = (char*) VSI_MALLOC2_VERBOSE(sizeof(char), stringSize+1);
if( pszName == nullptr )
return nullptr;
if ( stringSize != 0 && !readFile( pszName, 1, sizeof(char) * stringSize ) )
{
CPLFree(pszName);
return nullptr;
}
pszName[stringSize] = '\0';
/* Read type */
const unsigned char type = readUChar(pGTMFile);
/* Read color */
const int color = readInt(pGTMFile);
Track* poTrack = new Track(pszName, type, color);
CPLFree(pszName);
/* Adjust actual Track offset */
actualTrackOffset = VSIFTellL(pGTMFile) + 7;
++trackFetched;
/* Now, We read all trackpoints for this track */
double latitude = 0.0;
double longitude = 0.0;
GIntBig datetime = 0;
unsigned char start = 0;
float altitude = 0.0f;
/* NOTE: Parameters are passed by reference */
if ( !readTrackPoints(latitude, longitude, datetime, start, altitude) )
{
delete poTrack;
return nullptr;
}
/* Check if it is the start, if not we have done something wrong */
if (start != 1)
{
delete poTrack;
return nullptr;
}
poTrack->addPoint(longitude, latitude, datetime, altitude);
do
{
/* NOTE: Parameters are passed by reference */
if ( !readTrackPoints(latitude, longitude, datetime, start, altitude) )
{
delete poTrack;
return nullptr;
}
if (start == 0)
poTrack->addPoint(longitude, latitude, datetime, altitude);
} while(start == 0 && trackpointFetched < ntcks);
/* We have read one more than necessary, so we adjust the offset */
if (trackpointFetched < ntcks)
{
actualTrackpointOffset -= 25;
--trackpointFetched;
}
return poTrack;
}
Waypoint* GTM::fetchNextWaypoint()
{
/* Point to the actual waypoint offset */
if ( VSIFSeekL(pGTMFile, actualWaypointOffset, SEEK_SET) != 0)
return nullptr;
const double latitude = readDouble(pGTMFile);
const double longitude = readDouble(pGTMFile);
char name[11];
if ( !readFile( name, 1, 10 ) )
return nullptr;
/* Trim string name */
{
int i = 9; // Used after for.
for( ; i >= 0; --i)
{
if (name[i] != ' ')
{
name[i+1] = '\0';
break;
}
}
if (i < 0)
name[0] = '\0';
}
/* Read String Length */
const unsigned short stringSize = readUShort(pGTMFile);
/* Read Comment String */
char* comment = static_cast<char *>(
VSI_MALLOC2_VERBOSE(sizeof(char), stringSize+1) );
if( comment == nullptr )
return nullptr;
if ( stringSize != 0 && !readFile( comment, 1, sizeof(char)*stringSize ) )
{
CPLFree(comment);
return nullptr;
}
comment[stringSize] = '\0';
/* Read Icon */
const unsigned short icon = readUShort(pGTMFile);
/* Display number */
readUChar(pGTMFile);
/* Waypoint date */
GIntBig wptdate = readInt(pGTMFile);
if (wptdate != 0)
wptdate += GTM_EPOCH;
/* Rotation text angle */
readUShort(pGTMFile);
/* Altitude */
const float altitude = readFloat(pGTMFile);
Waypoint* poWaypoint = new Waypoint(latitude, longitude, altitude,
name, comment, (int) icon, wptdate);
/* Set actual waypoint offset to the next it there is one */
++waypointFetched;
if (waypointFetched < nwpts)
{
actualWaypointOffset +=
8 + 8 + 10 + 2 + stringSize + 2 + 1 + 4 + 2 + 4 + 2;
}
CPLFree(comment);
return poWaypoint;
}
static int GeoLocLoadFullData( GDALGeoLocTransformInfo *psTransform )
{
int nXSize, nYSize;
int nXSize_XBand = GDALGetRasterXSize( psTransform->hDS_X );
int nYSize_XBand = GDALGetRasterYSize( psTransform->hDS_X );
int nXSize_YBand = GDALGetRasterXSize( psTransform->hDS_Y );
int nYSize_YBand = GDALGetRasterYSize( psTransform->hDS_Y );
if (nYSize_XBand == 1 && nYSize_YBand == 1)
{
nXSize = nXSize_XBand;
nYSize = nXSize_YBand;
}
else
{
nXSize = nXSize_XBand;
nYSize = nYSize_XBand;
}
psTransform->nGeoLocXSize = nXSize;
psTransform->nGeoLocYSize = nYSize;
psTransform->padfGeoLocY = (double *)
VSI_MALLOC3_VERBOSE(sizeof(double), nXSize, nYSize);
psTransform->padfGeoLocX = (double *)
VSI_MALLOC3_VERBOSE(sizeof(double), nXSize, nYSize);
if( psTransform->padfGeoLocX == NULL ||
psTransform->padfGeoLocY == NULL )
{
return FALSE;
}
if (nYSize_XBand == 1 && nYSize_YBand == 1)
{
/* Case of regular grid */
/* The XBAND contains the x coordinates for all lines */
/* The YBAND contains the y coordinates for all columns */
double* padfTempX = (double*)VSI_MALLOC2_VERBOSE(nXSize, sizeof(double));
double* padfTempY = (double*)VSI_MALLOC2_VERBOSE(nYSize, sizeof(double));
if (padfTempX == NULL || padfTempY == NULL)
{
CPLFree(padfTempX);
CPLFree(padfTempY);
return FALSE;
}
CPLErr eErr = CE_None;
eErr = GDALRasterIO( psTransform->hBand_X, GF_Read,
0, 0, nXSize, 1,
padfTempX, nXSize, 1,
GDT_Float64, 0, 0 );
int i,j;
for(j=0;j<nYSize;j++)
{
memcpy( psTransform->padfGeoLocX + j * nXSize,
padfTempX,
nXSize * sizeof(double) );
}
if (eErr == CE_None)
{
eErr = GDALRasterIO( psTransform->hBand_Y, GF_Read,
0, 0, nYSize, 1,
padfTempY, nYSize, 1,
GDT_Float64, 0, 0 );
for(j=0;j<nYSize;j++)
{
for(i=0;i<nXSize;i++)
{
psTransform->padfGeoLocY[j * nXSize + i] = padfTempY[j];
}
}
}
CPLFree(padfTempX);
CPLFree(padfTempY);
if (eErr != CE_None)
return FALSE;
}
else
{
if( GDALRasterIO( psTransform->hBand_X, GF_Read,
0, 0, nXSize, nYSize,
psTransform->padfGeoLocX, nXSize, nYSize,
GDT_Float64, 0, 0 ) != CE_None
|| GDALRasterIO( psTransform->hBand_Y, GF_Read,
0, 0, nXSize, nYSize,
psTransform->padfGeoLocY, nXSize, nYSize,
GDT_Float64, 0, 0 ) != CE_None )
return FALSE;
}
psTransform->dfNoDataX = GDALGetRasterNoDataValue( psTransform->hBand_X,
&(psTransform->bHasNoData) );
return TRUE;
}
CPLErr AirSARDataset::LoadLine( int iLine )
{
if( iLine == nLoadedLine )
return CE_None;
/* -------------------------------------------------------------------- */
/* allocate working buffers if we don't have them already. */
/* -------------------------------------------------------------------- */
if( pabyCompressedLine == NULL )
{
pabyCompressedLine = (GByte *) VSI_MALLOC2_VERBOSE(nRasterXSize, 10);
padfMatrix = (double *) VSI_MALLOC2_VERBOSE(10* sizeof(double), nRasterXSize);
if (pabyCompressedLine == NULL ||
padfMatrix == NULL)
{
CPLFree (pabyCompressedLine);
CPLFree (padfMatrix);
return CE_Failure;
}
}
CPLAssert( nRecordLength == nRasterXSize * 10 );
/* -------------------------------------------------------------------- */
/* Load raw compressed data. */
/* -------------------------------------------------------------------- */
if( VSIFSeekL( fp, nDataStart + iLine * nRecordLength, SEEK_SET ) != 0
|| ((int) VSIFReadL( pabyCompressedLine, 10, nRasterXSize, fp ))
!= nRasterXSize )
{
CPLError( CE_Failure, CPLE_FileIO,
"Error reading %d bytes for line %d at offset %d.\n%s",
nRasterXSize * 10, iLine, nDataStart + iLine * nRecordLength,
VSIStrerror( errno ) );
return CE_Failure;
}
/* -------------------------------------------------------------------- */
/* Build stokes matrix */
/* -------------------------------------------------------------------- */
for( int iPixel = 0; iPixel < nRasterXSize; iPixel++ )
{
double *M = padfMatrix + 10 * iPixel;
signed char *byte = (signed char *) pabyCompressedLine + 10*iPixel - 1;
const double gen_fac = 1.0; // should we have a general scale factor?
M[M11] = (byte[2] / 254.0 + 1.5) * pow(2.0,byte[1]) * gen_fac;
M[M12] = byte[3] * M[M11] / 127.0;
M[M13] = byte[4] * fabs((double) byte[4]) * M[M11] / (127*127);
M[M14] = byte[5] * fabs((double) byte[5]) * M[M11] / (127*127);
M[M23] = byte[6] * fabs((double) byte[6]) * M[M11] / (127*127);
M[M24] = byte[7] * fabs((double) byte[7]) * M[M11] / (127*127);
M[M33] = byte[8] * M[M11] / 127;
M[M34] = byte[9] * M[M11] / 127;
M[M44] = byte[10] * M[M11] / 127;
M[M22] = M[M11] - M[M33] - M[M44];
}
return CE_None;
}
GDALDataset* SGIDataset::Open(GDALOpenInfo* poOpenInfo)
{
/* -------------------------------------------------------------------- */
/* First we check to see if the file has the expected header */
/* bytes. */
/* -------------------------------------------------------------------- */
if(poOpenInfo->nHeaderBytes < 12 || poOpenInfo->fpL == nullptr )
return nullptr;
ImageRec tmpImage;
memcpy(&tmpImage.imagic, poOpenInfo->pabyHeader + 0, 2);
memcpy(&tmpImage.type, poOpenInfo->pabyHeader + 2, 1);
memcpy(&tmpImage.bpc, poOpenInfo->pabyHeader + 3, 1);
memcpy(&tmpImage.dim, poOpenInfo->pabyHeader + 4, 2);
memcpy(&tmpImage.xsize, poOpenInfo->pabyHeader + 6, 2);
memcpy(&tmpImage.ysize, poOpenInfo->pabyHeader + 8, 2);
memcpy(&tmpImage.zsize, poOpenInfo->pabyHeader + 10, 2);
tmpImage.Swap();
if(tmpImage.imagic != 474)
return nullptr;
if (tmpImage.type != 0 && tmpImage.type != 1)
return nullptr;
if (tmpImage.bpc != 1 && tmpImage.bpc != 2)
return nullptr;
if (tmpImage.dim != 1 && tmpImage.dim != 2 && tmpImage.dim != 3)
return nullptr;
if(tmpImage.bpc != 1)
{
CPLError(CE_Failure, CPLE_NotSupported,
"The SGI driver only supports 1 byte channel values.\n");
return nullptr;
}
/* -------------------------------------------------------------------- */
/* Create a corresponding GDALDataset. */
/* -------------------------------------------------------------------- */
SGIDataset* poDS = new SGIDataset();
poDS->eAccess = poOpenInfo->eAccess;
poDS->fpImage = poOpenInfo->fpL;
poOpenInfo->fpL = nullptr;
/* -------------------------------------------------------------------- */
/* Read pre-image data after ensuring the file is rewound. */
/* -------------------------------------------------------------------- */
VSIFSeekL(poDS->fpImage, 0, SEEK_SET);
if(VSIFReadL(reinterpret_cast<void*>( &(poDS->image) ),
1, 12, poDS->fpImage)
!= 12)
{
CPLError(CE_Failure, CPLE_OpenFailed, "file read error while reading header in sgidataset.cpp");
delete poDS;
return nullptr;
}
poDS->image.Swap();
poDS->image.file = poDS->fpImage;
poDS->image.fileName = poOpenInfo->pszFilename;
/* -------------------------------------------------------------------- */
/* Capture some information from the file that is of interest. */
/* -------------------------------------------------------------------- */
poDS->nRasterXSize = poDS->image.xsize;
poDS->nRasterYSize = poDS->image.ysize;
if (poDS->nRasterXSize <= 0 || poDS->nRasterYSize <= 0)
{
CPLError(CE_Failure, CPLE_OpenFailed,
"Invalid image dimensions : %d x %d", poDS->nRasterXSize, poDS->nRasterYSize);
delete poDS;
return nullptr;
}
poDS->nBands = std::max(static_cast<GUInt16>(1), poDS->image.zsize);
if (poDS->nBands > 256)
{
CPLError(CE_Failure, CPLE_OpenFailed,
"Too many bands : %d", poDS->nBands);
delete poDS;
return nullptr;
}
const int numItems
= (static_cast<int>( poDS->image.bpc ) == 1) ? 256 : 65536;
if( poDS->image.xsize > INT_MAX / numItems )
{
delete poDS;
return nullptr;
}
poDS->image.tmpSize = poDS->image.xsize * numItems;
poDS->image.tmp = (unsigned char*)VSI_CALLOC_VERBOSE(poDS->image.xsize,numItems);
if (poDS->image.tmp == nullptr)
{
delete poDS;
return nullptr;
}
/* -------------------------------------------------------------------- */
/* Read RLE Pointer tables. */
/* -------------------------------------------------------------------- */
if( static_cast<int>( poDS->image.type ) == 1 ) // RLE compressed
{
const size_t x = static_cast<size_t>(poDS->image.ysize) * poDS->nBands * sizeof(GUInt32);
poDS->image.rowStart = reinterpret_cast<GUInt32*>(
VSI_MALLOC2_VERBOSE(poDS->image.ysize, poDS->nBands * sizeof(GUInt32) ) );
poDS->image.rowSize = reinterpret_cast<GInt32 *>(
VSI_MALLOC2_VERBOSE(poDS->image.ysize, poDS->nBands * sizeof(GUInt32) ) );
if (poDS->image.rowStart == nullptr || poDS->image.rowSize == nullptr)
{
delete poDS;
return nullptr;
}
memset(poDS->image.rowStart, 0, x);
memset(poDS->image.rowSize, 0, x);
poDS->image.rleEnd = static_cast<GUInt32>(512 + (2 * x));
VSIFSeekL(poDS->fpImage, 512, SEEK_SET);
if( VSIFReadL(poDS->image.rowStart, 1, x, poDS->image.file ) != x )
{
delete poDS;
CPLError(CE_Failure, CPLE_OpenFailed,
"file read error while reading start positions in sgidataset.cpp");
return nullptr;
}
if( VSIFReadL(poDS->image.rowSize, 1, x, poDS->image.file) != x)
{
delete poDS;
CPLError(CE_Failure, CPLE_OpenFailed,
"file read error while reading row lengths in sgidataset.cpp");
return nullptr;
}
ConvertLong(poDS->image.rowStart,
static_cast<int>(x / static_cast<int>( sizeof(GUInt32))) );
ConvertLong(reinterpret_cast<GUInt32 *>( poDS->image.rowSize ),
static_cast<int>(x / static_cast<int>( sizeof(GInt32) )) );
}
else // uncompressed.
{
poDS->image.rowStart = nullptr;
poDS->image.rowSize = nullptr;
}
/* -------------------------------------------------------------------- */
/* Create band information objects. */
/* -------------------------------------------------------------------- */
for(int iBand = 0; iBand < poDS->nBands; iBand++)
poDS->SetBand(iBand+1, new SGIRasterBand(poDS, iBand+1));
/* -------------------------------------------------------------------- */
/* Check for world file. */
/* -------------------------------------------------------------------- */
poDS->bGeoTransformValid =
GDALReadWorldFile(poOpenInfo->pszFilename, ".wld",
poDS->adfGeoTransform);
/* -------------------------------------------------------------------- */
/* Initialize any PAM information. */
/* -------------------------------------------------------------------- */
poDS->SetDescription(poOpenInfo->pszFilename);
poDS->TryLoadXML();
/* -------------------------------------------------------------------- */
/* Check for overviews. */
/* -------------------------------------------------------------------- */
poDS->oOvManager.Initialize( poDS, poOpenInfo->pszFilename );
return poDS;
}
bool LevellerRasterBand::Init()
{
m_pLine = reinterpret_cast<float*>(
VSI_MALLOC2_VERBOSE( sizeof(float), nBlockXSize) );
return m_pLine != NULL;
}
GDALDataset* SIGDEMDataset::CreateCopy(
const char * pszFilename,
GDALDataset * poSrcDS,
int /*bStrict*/,
char ** /*papszOptions*/,
GDALProgressFunc pfnProgress,
void * pProgressData) {
const int nBands = poSrcDS->GetRasterCount();
double adfGeoTransform[6] = { };
if (poSrcDS->GetGeoTransform(adfGeoTransform) != CE_None) {
CPLError(CE_Failure, CPLE_NotSupported,
"SIGDEM driver requires a valid GeoTransform.");
return nullptr;
}
if (nBands != 1) {
CPLError(CE_Failure, CPLE_NotSupported,
"SIGDEM driver doesn't support %d bands. Must be 1 band.",
nBands);
return nullptr;
}
VSILFILE *fp = VSIFOpenL(pszFilename, "wb");
if (fp == nullptr) {
CPLError(CE_Failure, CPLE_OpenFailed,
"Attempt to create file `%s' failed.", pszFilename);
return nullptr;
}
GDALRasterBand* band = poSrcDS->GetRasterBand(1);
const char* pszProjection = poSrcDS->GetProjectionRef();
int32_t nCols = poSrcDS->GetRasterXSize();
int32_t nRows = poSrcDS->GetRasterYSize();
int32_t nCoordinateSystemId = GetCoordinateSystemId(pszProjection);
SIGDEMHeader sHeader;
sHeader.nCoordinateSystemId = nCoordinateSystemId;
sHeader.dfMinX = adfGeoTransform[0];
const char* pszMin = band->GetMetadataItem("STATISTICS_MINIMUM");
if (pszMin == nullptr) {
sHeader.dfMinZ = -10000;
} else {
sHeader.dfMinZ = CPLAtof(pszMin);
}
sHeader.dfMaxY = adfGeoTransform[3];
const char* pszMax = band->GetMetadataItem("STATISTICS_MAXIMUM");
if (pszMax == nullptr) {
sHeader.dfMaxZ = 10000;
} else {
sHeader.dfMaxZ = CPLAtof(pszMax);
}
sHeader.nCols = poSrcDS->GetRasterXSize();
sHeader.nRows = poSrcDS->GetRasterYSize();
sHeader.dfXDim = adfGeoTransform[1];
sHeader.dfYDim = -adfGeoTransform[5];
sHeader.dfMaxX = sHeader.dfMinX + sHeader.nCols * sHeader.dfXDim;
sHeader.dfMinY = sHeader.dfMaxY - sHeader.nRows * sHeader.dfYDim;
sHeader.dfOffsetX = sHeader.dfMinX;
sHeader.dfOffsetY = sHeader.dfMinY;
if( !sHeader.Write(fp) )
{
VSIUnlink(pszFilename);
VSIFCloseL(fp);
return nullptr;
}
// Write fill with all NO_DATA values
int32_t* row = static_cast<int32_t*>(VSI_MALLOC2_VERBOSE(nCols, sizeof(int32_t)));
if( !row ) {
VSIUnlink(pszFilename);
VSIFCloseL(fp);
return nullptr;
}
std::fill(row, row + nCols, CPL_MSBWORD32(NO_DATA));
for (int i = 0; i < nRows; i++) {
if( VSIFWriteL(row, CELL_SIZE_FILE, nCols, fp) !=
static_cast<size_t>(nCols) )
{
VSIFree(row);
VSIUnlink(pszFilename);
VSIFCloseL(fp);
return nullptr;
}
}
VSIFree(row);
if (VSIFCloseL(fp) != 0) {
return nullptr;
}
if (nCoordinateSystemId <= 0) {
if (!EQUAL(pszProjection, "")) {
CPLString osPrjFilename = CPLResetExtension(pszFilename, "prj");
VSILFILE *fpProj = VSIFOpenL(osPrjFilename, "wt");
if (fpProj != nullptr) {
OGRSpatialReference oSRS;
oSRS.importFromWkt(pszProjection);
oSRS.morphToESRI();
char *pszESRIProjection = nullptr;
oSRS.exportToWkt(&pszESRIProjection);
CPL_IGNORE_RET_VAL(
VSIFWriteL(pszESRIProjection, 1,
strlen(pszESRIProjection), fpProj));
CPL_IGNORE_RET_VAL(VSIFCloseL(fpProj));
CPLFree(pszESRIProjection);
} else {
CPLError(CE_Failure, CPLE_FileIO, "Unable to create file %s.",
osPrjFilename.c_str());
}
}
}
GDALOpenInfo oOpenInfo(pszFilename, GA_Update);
GDALDataset * poDstDS = Open(&oOpenInfo);
if (poDstDS != nullptr &&
GDALDatasetCopyWholeRaster(poSrcDS, poDstDS, nullptr, pfnProgress,
pProgressData) == OGRERR_NONE) {
return poDstDS;
} else {
VSIUnlink(pszFilename);
return nullptr;
}
}
CPLErr GS7BGRasterBand::IWriteBlock( int nBlockXOff, int nBlockYOff,
void *pImage )
{
if( eAccess == GA_ReadOnly )
{
CPLError( CE_Failure, CPLE_NoWriteAccess,
"Unable to write block, dataset opened read only.\n" );
return CE_Failure;
}
if( nBlockYOff < 0 || nBlockYOff > nRasterYSize - 1 || nBlockXOff != 0 )
return CE_Failure;
GS7BGDataset *poGDS = (GS7BGDataset *) ( poDS );
if( pafRowMinZ == NULL || pafRowMaxZ == NULL
|| nMinZRow < 0 || nMaxZRow < 0 )
{
pafRowMinZ = (double *)VSI_MALLOC2_VERBOSE( nRasterYSize,sizeof(double) );
if( pafRowMinZ == NULL )
{
return CE_Failure;
}
pafRowMaxZ = (double *)VSI_MALLOC2_VERBOSE( nRasterYSize,sizeof(double) );
if( pafRowMaxZ == NULL )
{
VSIFree( pafRowMinZ );
pafRowMinZ = NULL;
return CE_Failure;
}
CPLErr eErr = ScanForMinMaxZ();
if( eErr != CE_None )
return eErr;
}
if( VSIFSeekL( poGDS->fp,
GS7BGDataset::nHEADER_SIZE +
sizeof(double) * nRasterXSize * (nRasterYSize - nBlockYOff - 1),
SEEK_SET ) != 0 )
{
CPLError( CE_Failure, CPLE_FileIO,
"Unable to seek to beginning of grid row.\n" );
return CE_Failure;
}
double *pdfImage = (double *)pImage;
pafRowMinZ[nBlockYOff] = DBL_MAX;
pafRowMaxZ[nBlockYOff] = -DBL_MAX;
for( int iPixel=0; iPixel<nBlockXSize; iPixel++ )
{
if( pdfImage[iPixel] != poGDS->dfNoData_Value )
{
if( pdfImage[iPixel] < pafRowMinZ[nBlockYOff] )
pafRowMinZ[nBlockYOff] = pdfImage[iPixel];
if( pdfImage[iPixel] > pafRowMaxZ[nBlockYOff] )
pafRowMaxZ[nBlockYOff] = pdfImage[iPixel];
}
CPL_LSBPTR64( pdfImage+iPixel );
}
if( VSIFWriteL( pImage, sizeof(double), nBlockXSize,
poGDS->fp ) != static_cast<unsigned>(nBlockXSize) )
{
CPLError( CE_Failure, CPLE_FileIO,
"Unable to write block to grid file.\n" );
return CE_Failure;
}
/* Update min/max Z values as appropriate */
bool bHeaderNeedsUpdate = false;
if( nMinZRow == nBlockYOff && pafRowMinZ[nBlockYOff] > dfMinZ )
{
double dfNewMinZ = DBL_MAX;
for( int iRow=0; iRow<nRasterYSize; iRow++ )
{
if( pafRowMinZ[iRow] < dfNewMinZ )
{
dfNewMinZ = pafRowMinZ[iRow];
nMinZRow = iRow;
}
}
if( dfNewMinZ != dfMinZ )
{
dfMinZ = dfNewMinZ;
bHeaderNeedsUpdate = true;
}
}
if( nMaxZRow == nBlockYOff && pafRowMaxZ[nBlockYOff] < dfMaxZ )
{
double dfNewMaxZ = -DBL_MAX;
for( int iRow=0; iRow<nRasterYSize; iRow++ )
{
if( pafRowMaxZ[iRow] > dfNewMaxZ )
{
dfNewMaxZ = pafRowMaxZ[iRow];
nMaxZRow = iRow;
}
}
if( dfNewMaxZ != dfMaxZ )
{
dfMaxZ = dfNewMaxZ;
bHeaderNeedsUpdate = true;
}
}
if( pafRowMinZ[nBlockYOff] < dfMinZ || pafRowMaxZ[nBlockYOff] > dfMaxZ )
{
if( pafRowMinZ[nBlockYOff] < dfMinZ )
{
dfMinZ = pafRowMinZ[nBlockYOff];
nMinZRow = nBlockYOff;
}
if( pafRowMaxZ[nBlockYOff] > dfMaxZ )
{
dfMaxZ = pafRowMaxZ[nBlockYOff];
nMaxZRow = nBlockYOff;
}
bHeaderNeedsUpdate = true;
}
if( bHeaderNeedsUpdate && dfMaxZ > dfMinZ )
{
CPLErr eErr = poGDS->WriteHeader( poGDS->fp,
nRasterXSize, nRasterYSize,
dfMinX, dfMaxX,
dfMinY, dfMaxY,
dfMinZ, dfMaxZ );
return eErr;
}
return CE_None;
}
int CPL_STDCALL
GDALSimpleImageWarp( GDALDatasetH hSrcDS, GDALDatasetH hDstDS,
int nBandCount, int *panBandList,
GDALTransformerFunc pfnTransform, void *pTransformArg,
GDALProgressFunc pfnProgress, void *pProgressArg,
char **papszWarpOptions )
{
VALIDATE_POINTER1( hSrcDS, "GDALSimpleImageWarp", 0 );
VALIDATE_POINTER1( hDstDS, "GDALSimpleImageWarp", 0 );
bool bError = false;
/* -------------------------------------------------------------------- */
/* If no bands provided assume we should process all bands. */
/* -------------------------------------------------------------------- */
if( nBandCount == 0 )
{
nBandCount = GDALGetRasterCount( hSrcDS );
if (nBandCount == 0)
{
CPLError(CE_Failure, CPLE_AppDefined,
"No raster band in source dataset");
return FALSE;
}
panBandList = (int *) CPLCalloc(sizeof(int),nBandCount);
for( int iBand = 0; iBand < nBandCount; iBand++ )
panBandList[iBand] = iBand+1;
const int nResult =
GDALSimpleImageWarp( hSrcDS, hDstDS, nBandCount, panBandList,
pfnTransform, pTransformArg,
pfnProgress, pProgressArg,
papszWarpOptions );
CPLFree( panBandList );
return nResult;
}
/* -------------------------------------------------------------------- */
/* Post initial progress. */
/* -------------------------------------------------------------------- */
if( pfnProgress )
{
if( !pfnProgress( 0.0, "", pProgressArg ) )
return FALSE;
}
/* -------------------------------------------------------------------- */
/* Load the source image band(s). */
/* -------------------------------------------------------------------- */
const int nSrcXSize = GDALGetRasterXSize(hSrcDS);
const int nSrcYSize = GDALGetRasterYSize(hSrcDS);
GByte **papabySrcData = static_cast<GByte **>(
CPLCalloc(nBandCount, sizeof(GByte*)) );
bool ok = true;
for( int iBand = 0; iBand < nBandCount; iBand++ )
{
papabySrcData[iBand] = static_cast<GByte *>(
VSI_MALLOC2_VERBOSE(nSrcXSize, nSrcYSize) );
if( papabySrcData[iBand] == NULL )
{
CPLError( CE_Failure, CPLE_OutOfMemory,
"GDALSimpleImageWarp out of memory.\n" );
ok = false;
break;
}
if( GDALRasterIO( GDALGetRasterBand(hSrcDS,panBandList[iBand]), GF_Read,
0, 0, nSrcXSize, nSrcYSize,
papabySrcData[iBand], nSrcXSize, nSrcYSize, GDT_Byte,
0, 0 ) != CE_None )
{
CPLError( CE_Failure, CPLE_FileIO, "GDALSimpleImageWarp "
"GDALRasterIO failure %s ",
CPLGetLastErrorMsg() );
ok = false;
break;
}
}
if( !ok ) {
for( int i=0; i <= nBandCount; i++ )
{
VSIFree(papabySrcData[i]);
}
CPLFree(papabySrcData);
return FALSE;
}
/* -------------------------------------------------------------------- */
/* Check for remap request(s). */
/* -------------------------------------------------------------------- */
GDALSimpleWarpRemapping( nBandCount, papabySrcData, nSrcXSize, nSrcYSize,
papszWarpOptions );
/* -------------------------------------------------------------------- */
/* Allocate scanline buffers for output image. */
/* -------------------------------------------------------------------- */
const int nDstXSize = GDALGetRasterXSize( hDstDS );
const int nDstYSize = GDALGetRasterYSize( hDstDS );
GByte **papabyDstLine = static_cast<GByte **>(
CPLCalloc(nBandCount, sizeof(GByte*)) );
for( int iBand = 0; iBand < nBandCount; iBand++ )
papabyDstLine[iBand] = static_cast<GByte *>(CPLMalloc( nDstXSize ));
/* -------------------------------------------------------------------- */
/* Allocate x,y,z coordinate arrays for transformation ... one */
/* scanlines worth of positions. */
/* -------------------------------------------------------------------- */
double *padfX = static_cast<double *>(
CPLMalloc(sizeof(double) * nDstXSize) );
double *padfY = static_cast<double *>(
CPLMalloc(sizeof(double) * nDstXSize) );
double *padfZ = static_cast<double *>(
CPLMalloc(sizeof(double) * nDstXSize) );
int *pabSuccess = static_cast<int *>( CPLMalloc(sizeof(int) * nDstXSize) );
/* -------------------------------------------------------------------- */
/* Establish the value we will use to initialize the bands. We */
/* default to -1 indicating the initial value should be read */
/* and preserved from the source file, but allow this to be */
/* overridden by passed */
/* option(s). */
/* -------------------------------------------------------------------- */
int * const panBandInit =
static_cast<int *>( CPLCalloc(sizeof(int), nBandCount) );
if( CSLFetchNameValue( papszWarpOptions, "INIT" ) )
{
char **papszTokens =
CSLTokenizeStringComplex( CSLFetchNameValue( papszWarpOptions,
"INIT" ),
" ,", FALSE, FALSE );
const int nTokenCount = CSLCount(papszTokens);
for( int iBand = 0; iBand < nBandCount; iBand++ )
{
if( nTokenCount == 0 )
panBandInit[iBand] = 0;
else
panBandInit[iBand] =
atoi(papszTokens[MIN(iBand,nTokenCount-1)]);
}
CSLDestroy(papszTokens);
}
/* -------------------------------------------------------------------- */
/* Loop over all the scanlines in the output image. */
/* -------------------------------------------------------------------- */
for( int iDstY = 0; iDstY < nDstYSize; iDstY++ )
{
// Clear output buffer to "transparent" value. Should not we
// really be reading from the destination file to support overlay?
for( int iBand = 0; iBand < nBandCount; iBand++ )
{
if( panBandInit[iBand] == -1 )
{
if( GDALRasterIO( GDALGetRasterBand(hDstDS,iBand+1), GF_Read,
0, iDstY, nDstXSize, 1,
papabyDstLine[iBand], nDstXSize, 1, GDT_Byte,
0, 0 ) != CE_None )
{
bError = TRUE;
break;
}
}
else
memset( papabyDstLine[iBand], panBandInit[iBand], nDstXSize );
}
// Set point to transform.
for( int iDstX = 0; iDstX < nDstXSize; iDstX++ )
{
padfX[iDstX] = iDstX + 0.5;
padfY[iDstX] = iDstY + 0.5;
padfZ[iDstX] = 0.0;
}
// Transform the points from destination pixel/line coordinates
// to source pixel/line coordinates.
pfnTransform( pTransformArg, TRUE, nDstXSize,
padfX, padfY, padfZ, pabSuccess );
// Loop over the output scanline.
for( int iDstX = 0; iDstX < nDstXSize; iDstX++ )
{
if( !pabSuccess[iDstX] )
continue;
// We test against the value before casting to avoid the
// problem of asymmetric truncation effects around zero. That is
// -0.5 will be 0 when cast to an int.
if( padfX[iDstX] < 0.0 || padfY[iDstX] < 0.0 )
continue;
const int iSrcX = static_cast<int>( padfX[iDstX] );
const int iSrcY = static_cast<int>( padfY[iDstX] );
if( iSrcX >= nSrcXSize || iSrcY >= nSrcYSize )
continue;
const int iSrcOffset = iSrcX + iSrcY * nSrcXSize;
for( int iBand = 0; iBand < nBandCount; iBand++ )
papabyDstLine[iBand][iDstX] = papabySrcData[iBand][iSrcOffset];
}
// Write scanline to disk.
for( int iBand = 0; iBand < nBandCount; iBand++ )
{
if( GDALRasterIO( GDALGetRasterBand(hDstDS,iBand+1), GF_Write,
0, iDstY, nDstXSize, 1,
papabyDstLine[iBand], nDstXSize, 1, GDT_Byte, 0, 0 ) != CE_None )
{
bError = TRUE;
break;
}
}
if( pfnProgress != NULL )
{
if( !pfnProgress( (iDstY+1) / (double) nDstYSize,
"", pProgressArg ) )
{
CPLError( CE_Failure, CPLE_UserInterrupt, "User terminated" );
bError = TRUE;
break;
}
}
}
/* -------------------------------------------------------------------- */
/* Cleanup working buffers. */
/* -------------------------------------------------------------------- */
for( int iBand = 0; iBand < nBandCount; iBand++ )
{
CPLFree( papabyDstLine[iBand] );
CPLFree( papabySrcData[iBand] );
}
CPLFree( panBandInit );
CPLFree( papabyDstLine );
CPLFree( papabySrcData );
CPLFree( padfX );
CPLFree( padfY );
CPLFree( padfZ );
CPLFree( pabSuccess );
return !bError;
}
OGRLayer *OGRSelafinDataSource::ICreateLayer( const char *pszLayerName, OGRSpatialReference *poSpatialRefP, OGRwkbGeometryType eGType, char ** papszOptions ) {
CPLDebug("Selafin","CreateLayer(%s,%s)",pszLayerName,(eGType==wkbPoint)?"wkbPoint":"wkbPolygon");
// Verify we are in update mode.
if (!bUpdate) {
CPLError( CE_Failure, CPLE_NoWriteAccess, "Data source %s opened read-only.\n" "New layer %s cannot be created.\n", pszName, pszLayerName );
return NULL;
}
// Check that new layer is a point or polygon layer
if (eGType!=wkbPoint) {
CPLError( CE_Failure, CPLE_NoWriteAccess, "Selafin format can only handle %s layers whereas input is %s\n.", OGRGeometryTypeToName(wkbPoint),OGRGeometryTypeToName(eGType));
return NULL;
}
// Parse options
double dfDate;
const char *pszTemp=CSLFetchNameValue(papszOptions,"DATE");
if (pszTemp!=NULL) dfDate=CPLAtof(pszTemp); else dfDate=0.0;
// Set the SRS of the datasource if this is the first layer
if (nLayers==0 && poSpatialRefP!=NULL) {
poSpatialRef=poSpatialRefP;
poSpatialRef->Reference();
const char* szEpsg=poSpatialRef->GetAttrValue("GEOGCS|AUTHORITY",1);
int nEpsg=0;
if (szEpsg!=NULL) nEpsg=(int)strtol(szEpsg,NULL,10);
if (nEpsg==0) {
CPLError(CE_Warning,CPLE_AppDefined,"Could not find EPSG code for SRS. The SRS won't be saved in the datasource.");
} else {
poHeader->nEpsg=nEpsg;
}
}
// Create the new layer in the Selafin file by adding a "time step" at the end
// Beware, as the new layer shares the same header, it automatically contains the same number of features and fields as the existing ones. This may not be intuitive for the user.
if (VSIFSeekL(poHeader->fp,0,SEEK_END)!=0) return NULL;
if (Selafin::write_integer(poHeader->fp,4)==0 ||
Selafin::write_float(poHeader->fp,dfDate)==0 ||
Selafin::write_integer(poHeader->fp,4)==0) {
CPLError( CE_Failure, CPLE_FileIO, "Could not write to Selafin file %s.\n",pszName);
return NULL;
}
double *pdfValues=NULL;
if (poHeader->nPoints>0)
{
pdfValues=(double*)VSI_MALLOC2_VERBOSE(sizeof(double),poHeader->nPoints);
if( pdfValues == NULL )
return NULL;
}
for (int i=0;i<poHeader->nVar;++i) {
if (Selafin::write_floatarray(poHeader->fp,pdfValues,poHeader->nPoints)==0) {
CPLError( CE_Failure, CPLE_FileIO, "Could not write to Selafin file %s.\n",pszName);
CPLFree(pdfValues);
return NULL;
}
}
CPLFree(pdfValues);
VSIFFlushL(poHeader->fp);
poHeader->nSteps++;
// Create two layers as usual, one for points and one for elements
nLayers+=2;
papoLayers = (OGRSelafinLayer **) CPLRealloc(papoLayers, sizeof(void*) * nLayers);
CPLString szName=pszLayerName;
CPLString szNewLayerName=szName+"_p";
papoLayers[nLayers-2] = new OGRSelafinLayer( szNewLayerName, bUpdate, poSpatialRef, poHeader,poHeader->nSteps-1,POINTS);
szNewLayerName=szName+"_e";
papoLayers[nLayers-1] = new OGRSelafinLayer( szNewLayerName, bUpdate, poSpatialRef, poHeader,poHeader->nSteps-1,ELEMENTS);
return papoLayers[nLayers-2];
}
CPLErr CPL_STDCALL
GDALComputeProximity( GDALRasterBandH hSrcBand,
GDALRasterBandH hProximityBand,
char **papszOptions,
GDALProgressFunc pfnProgress,
void * pProgressArg )
{
VALIDATE_POINTER1( hSrcBand, "GDALComputeProximity", CE_Failure );
VALIDATE_POINTER1( hProximityBand, "GDALComputeProximity", CE_Failure );
if( pfnProgress == NULL )
pfnProgress = GDALDummyProgress;
/* -------------------------------------------------------------------- */
/* Are we using pixels or georeferenced coordinates for distances? */
/* -------------------------------------------------------------------- */
double dfDistMult = 1.0;
const char *pszOpt = CSLFetchNameValue( papszOptions, "DISTUNITS" );
if( pszOpt )
{
if( EQUAL(pszOpt, "GEO") )
{
GDALDatasetH hSrcDS = GDALGetBandDataset( hSrcBand );
if( hSrcDS )
{
double adfGeoTransform[6] = { 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 };
GDALGetGeoTransform( hSrcDS, adfGeoTransform );
if( std::abs(adfGeoTransform[1]) !=
std::abs(adfGeoTransform[5]) )
CPLError(
CE_Warning, CPLE_AppDefined,
"Pixels not square, distances will be inaccurate." );
dfDistMult = std::abs(adfGeoTransform[1]);
}
}
else if( !EQUAL(pszOpt, "PIXEL") )
{
CPLError(
CE_Failure, CPLE_AppDefined,
"Unrecognized DISTUNITS value '%s', should be GEO or PIXEL.",
pszOpt );
return CE_Failure;
}
}
/* -------------------------------------------------------------------- */
/* What is our maxdist value? */
/* -------------------------------------------------------------------- */
pszOpt = CSLFetchNameValue( papszOptions, "MAXDIST" );
const double dfMaxDist = pszOpt ?
CPLAtof(pszOpt) / dfDistMult :
GDALGetRasterBandXSize(hSrcBand) + GDALGetRasterBandYSize(hSrcBand);
CPLDebug( "GDAL", "MAXDIST=%g, DISTMULT=%g", dfMaxDist, dfDistMult );
/* -------------------------------------------------------------------- */
/* Verify the source and destination are compatible. */
/* -------------------------------------------------------------------- */
const int nXSize = GDALGetRasterBandXSize( hSrcBand );
const int nYSize = GDALGetRasterBandYSize( hSrcBand );
if( nXSize != GDALGetRasterBandXSize( hProximityBand )
|| nYSize != GDALGetRasterBandYSize( hProximityBand ))
{
CPLError( CE_Failure, CPLE_AppDefined,
"Source and proximity bands are not the same size." );
return CE_Failure;
}
/* -------------------------------------------------------------------- */
/* Get input NODATA value. */
/* -------------------------------------------------------------------- */
double dfSrcNoDataValue = 0.0;
double *pdfSrcNoData = NULL;
if( CPLFetchBool( papszOptions, "USE_INPUT_NODATA", false ) )
{
int bSrcHasNoData = 0;
dfSrcNoDataValue = GDALGetRasterNoDataValue( hSrcBand, &bSrcHasNoData );
if( bSrcHasNoData )
pdfSrcNoData = &dfSrcNoDataValue;
}
/* -------------------------------------------------------------------- */
/* Get output NODATA value. */
/* -------------------------------------------------------------------- */
float fNoDataValue = 0.0f;
pszOpt = CSLFetchNameValue( papszOptions, "NODATA" );
if( pszOpt != NULL )
{
fNoDataValue = static_cast<float>(CPLAtof(pszOpt));
}
else
{
int bSuccess = FALSE;
fNoDataValue = static_cast<float>(
GDALGetRasterNoDataValue( hProximityBand, &bSuccess ) );
if( !bSuccess )
fNoDataValue = 65535.0;
}
/* -------------------------------------------------------------------- */
/* Is there a fixed value we wish to force the buffer area to? */
/* -------------------------------------------------------------------- */
double dfFixedBufVal = 0.0;
bool bFixedBufVal = false;
pszOpt = CSLFetchNameValue( papszOptions, "FIXED_BUF_VAL" );
if( pszOpt )
{
dfFixedBufVal = CPLAtof(pszOpt);
bFixedBufVal = true;
}
/* -------------------------------------------------------------------- */
/* Get the target value(s). */
/* -------------------------------------------------------------------- */
int *panTargetValues = NULL;
int nTargetValues = 0;
pszOpt = CSLFetchNameValue( papszOptions, "VALUES" );
if( pszOpt != NULL )
{
char **papszValuesTokens =
CSLTokenizeStringComplex( pszOpt, ",", FALSE, FALSE);
nTargetValues = CSLCount(papszValuesTokens);
panTargetValues = static_cast<int *>(
CPLCalloc(sizeof(int), nTargetValues) );
for( int i = 0; i < nTargetValues; i++ )
panTargetValues[i] = atoi(papszValuesTokens[i]);
CSLDestroy( papszValuesTokens );
}
/* -------------------------------------------------------------------- */
/* Initialize progress counter. */
/* -------------------------------------------------------------------- */
if( !pfnProgress( 0.0, "", pProgressArg ) )
{
CPLError( CE_Failure, CPLE_UserInterrupt, "User terminated" );
CPLFree(panTargetValues);
return CE_Failure;
}
/* -------------------------------------------------------------------- */
/* We need a signed type for the working proximity values kept */
/* on disk. If our proximity band is not signed, then create a */
/* temporary file for this purpose. */
/* -------------------------------------------------------------------- */
GDALRasterBandH hWorkProximityBand = hProximityBand;
GDALDatasetH hWorkProximityDS = NULL;
const GDALDataType eProxType = GDALGetRasterDataType(hProximityBand);
CPLErr eErr = CE_None;
// TODO(schwehr): Localize after removing gotos.
float *pafProximity = NULL;
int *panNearX = NULL;
int *panNearY = NULL;
GInt32 *panSrcScanline = NULL;
if( eProxType == GDT_Byte
|| eProxType == GDT_UInt16
|| eProxType == GDT_UInt32 )
{
GDALDriverH hDriver = GDALGetDriverByName("GTiff");
if( hDriver == NULL )
{
CPLError( CE_Failure, CPLE_AppDefined,
"GDALComputeProximity needs GTiff driver" );
eErr = CE_Failure;
goto end;
}
CPLString osTmpFile = CPLGenerateTempFilename( "proximity" );
hWorkProximityDS =
GDALCreate( hDriver, osTmpFile,
nXSize, nYSize, 1, GDT_Float32, NULL );
if( hWorkProximityDS == NULL )
{
eErr = CE_Failure;
goto end;
}
hWorkProximityBand = GDALGetRasterBand( hWorkProximityDS, 1 );
}
/* -------------------------------------------------------------------- */
/* Allocate buffer for two scanlines of distances as floats */
/* (the current and last line). */
/* -------------------------------------------------------------------- */
pafProximity =
static_cast<float *>(VSI_MALLOC2_VERBOSE(sizeof(float), nXSize));
panNearX =
static_cast<int *>(VSI_MALLOC2_VERBOSE(sizeof(int), nXSize));
panNearY =
static_cast<int *>(VSI_MALLOC2_VERBOSE(sizeof(int), nXSize));
panSrcScanline =
static_cast<GInt32 *>(VSI_MALLOC2_VERBOSE(sizeof(GInt32), nXSize));
if( pafProximity == NULL
|| panNearX == NULL
|| panNearY == NULL
|| panSrcScanline == NULL)
{
eErr = CE_Failure;
goto end;
}
/* -------------------------------------------------------------------- */
/* Loop from top to bottom of the image. */
/* -------------------------------------------------------------------- */
for( int i = 0; i < nXSize; i++ )
{
panNearX[i] = -1;
panNearY[i] = -1;
}
for( int iLine = 0; eErr == CE_None && iLine < nYSize; iLine++ )
{
// Read for target values.
eErr = GDALRasterIO( hSrcBand, GF_Read, 0, iLine, nXSize, 1,
panSrcScanline, nXSize, 1, GDT_Int32, 0, 0 );
if( eErr != CE_None )
break;
for( int i = 0; i < nXSize; i++ )
pafProximity[i] = -1.0;
// Left to right.
ProcessProximityLine( panSrcScanline, panNearX, panNearY,
TRUE, iLine, nXSize, dfMaxDist, pafProximity,
pdfSrcNoData, nTargetValues, panTargetValues );
// Right to Left.
ProcessProximityLine( panSrcScanline, panNearX, panNearY,
FALSE, iLine, nXSize, dfMaxDist, pafProximity,
pdfSrcNoData, nTargetValues, panTargetValues );
// Write out results.
eErr =
GDALRasterIO( hWorkProximityBand, GF_Write, 0, iLine, nXSize, 1,
pafProximity, nXSize, 1, GDT_Float32, 0, 0 );
if( eErr != CE_None )
break;
if( !pfnProgress( 0.5 * (iLine+1) / static_cast<double>(nYSize),
"", pProgressArg ) )
{
CPLError( CE_Failure, CPLE_UserInterrupt, "User terminated" );
eErr = CE_Failure;
}
}
/* -------------------------------------------------------------------- */
/* Loop from bottom to top of the image. */
/* -------------------------------------------------------------------- */
for( int i = 0; i < nXSize; i++ )
{
panNearX[i] = -1;
panNearY[i] = -1;
}
for( int iLine = nYSize-1; eErr == CE_None && iLine >= 0; iLine-- )
{
// Read first pass proximity.
eErr =
GDALRasterIO( hWorkProximityBand, GF_Read, 0, iLine, nXSize, 1,
pafProximity, nXSize, 1, GDT_Float32, 0, 0 );
if( eErr != CE_None )
break;
// Read pixel values.
eErr = GDALRasterIO( hSrcBand, GF_Read, 0, iLine, nXSize, 1,
panSrcScanline, nXSize, 1, GDT_Int32, 0, 0 );
if( eErr != CE_None )
break;
// Right to left.
ProcessProximityLine( panSrcScanline, panNearX, panNearY,
FALSE, iLine, nXSize, dfMaxDist, pafProximity,
pdfSrcNoData, nTargetValues, panTargetValues );
// Left to right.
ProcessProximityLine( panSrcScanline, panNearX, panNearY,
TRUE, iLine, nXSize, dfMaxDist, pafProximity,
pdfSrcNoData, nTargetValues, panTargetValues );
// Final post processing of distances.
for( int i = 0; i < nXSize; i++ )
{
if( pafProximity[i] < 0.0 )
pafProximity[i] = fNoDataValue;
else if( pafProximity[i] > 0.0 )
{
if( bFixedBufVal )
pafProximity[i] = static_cast<float>( dfFixedBufVal );
else
pafProximity[i] =
static_cast<float>(pafProximity[i] * dfDistMult);
}
}
// Write out results.
eErr =
GDALRasterIO( hProximityBand, GF_Write, 0, iLine, nXSize, 1,
pafProximity, nXSize, 1, GDT_Float32, 0, 0 );
if( eErr != CE_None )
break;
if( !pfnProgress( 0.5 +
0.5 * (nYSize-iLine) / static_cast<double>( nYSize ),
"", pProgressArg ) )
{
CPLError( CE_Failure, CPLE_UserInterrupt, "User terminated" );
eErr = CE_Failure;
}
}
/* -------------------------------------------------------------------- */
/* Cleanup */
/* -------------------------------------------------------------------- */
end:
CPLFree( panNearX );
CPLFree( panNearY );
CPLFree( panSrcScanline );
CPLFree( pafProximity );
CPLFree( panTargetValues );
if( hWorkProximityDS != NULL )
{
CPLString osProxFile = GDALGetDescription( hWorkProximityDS );
GDALClose( hWorkProximityDS );
GDALDeleteDataset( GDALGetDriverByName( "GTiff" ), osProxFile );
}
return eErr;
}
