static
GDALDatasetH CreateOutputDataset(std::vector<OGRLayerH> ahLayers,
OGRSpatialReferenceH hSRS,
int bGotBounds, OGREnvelope sEnvelop,
GDALDriverH hDriver, const char* pszDest,
int nXSize, int nYSize, double dfXRes, double dfYRes,
int bTargetAlignedPixels,
int nBandCount, GDALDataType eOutputType,
char** papszCreationOptions, std::vector<double> adfInitVals,
int bNoDataSet, double dfNoData)
{
int bFirstLayer = TRUE;
char* pszWKT = NULL;
GDALDatasetH hDstDS = NULL;
unsigned int i;
for( i = 0; i < ahLayers.size(); i++ )
{
OGRLayerH hLayer = ahLayers[i];
if (!bGotBounds)
{
OGREnvelope sLayerEnvelop;
if (OGR_L_GetExtent(hLayer, &sLayerEnvelop, TRUE) != OGRERR_NONE)
{
CPLError(CE_Failure, CPLE_AppDefined, "Cannot get layer extent");
return NULL;
}
/* Voluntarily increase the extent by a half-pixel size to avoid */
/* missing points on the border */
if (!bTargetAlignedPixels && dfXRes != 0 && dfYRes != 0)
{
sLayerEnvelop.MinX -= dfXRes / 2;
sLayerEnvelop.MaxX += dfXRes / 2;
sLayerEnvelop.MinY -= dfYRes / 2;
sLayerEnvelop.MaxY += dfYRes / 2;
}
if (bFirstLayer)
{
sEnvelop.MinX = sLayerEnvelop.MinX;
sEnvelop.MinY = sLayerEnvelop.MinY;
sEnvelop.MaxX = sLayerEnvelop.MaxX;
sEnvelop.MaxY = sLayerEnvelop.MaxY;
if (hSRS == NULL)
hSRS = OGR_L_GetSpatialRef(hLayer);
bFirstLayer = FALSE;
}
else
{
sEnvelop.MinX = MIN(sEnvelop.MinX, sLayerEnvelop.MinX);
sEnvelop.MinY = MIN(sEnvelop.MinY, sLayerEnvelop.MinY);
sEnvelop.MaxX = MAX(sEnvelop.MaxX, sLayerEnvelop.MaxX);
sEnvelop.MaxY = MAX(sEnvelop.MaxY, sLayerEnvelop.MaxY);
}
}
else
{
if (bFirstLayer)
{
if (hSRS == NULL)
hSRS = OGR_L_GetSpatialRef(hLayer);
bFirstLayer = FALSE;
}
}
}
if (dfXRes == 0 && dfYRes == 0)
{
dfXRes = (sEnvelop.MaxX - sEnvelop.MinX) / nXSize;
dfYRes = (sEnvelop.MaxY - sEnvelop.MinY) / nYSize;
}
else if (bTargetAlignedPixels && dfXRes != 0 && dfYRes != 0)
{
sEnvelop.MinX = floor(sEnvelop.MinX / dfXRes) * dfXRes;
sEnvelop.MaxX = ceil(sEnvelop.MaxX / dfXRes) * dfXRes;
sEnvelop.MinY = floor(sEnvelop.MinY / dfYRes) * dfYRes;
sEnvelop.MaxY = ceil(sEnvelop.MaxY / dfYRes) * dfYRes;
}
double adfProjection[6];
adfProjection[0] = sEnvelop.MinX;
adfProjection[1] = dfXRes;
adfProjection[2] = 0;
adfProjection[3] = sEnvelop.MaxY;
adfProjection[4] = 0;
adfProjection[5] = -dfYRes;
if (nXSize == 0 && nYSize == 0)
{
nXSize = (int)(0.5 + (sEnvelop.MaxX - sEnvelop.MinX) / dfXRes);
nYSize = (int)(0.5 + (sEnvelop.MaxY - sEnvelop.MinY) / dfYRes);
}
hDstDS = GDALCreate(hDriver, pszDest, nXSize, nYSize,
nBandCount, eOutputType, papszCreationOptions);
if (hDstDS == NULL)
{
CPLError(CE_Failure, CPLE_AppDefined, "Cannot create %s", pszDest);
return NULL;
}
GDALSetGeoTransform(hDstDS, adfProjection);
if (hSRS)
OSRExportToWkt(hSRS, &pszWKT);
if (pszWKT)
GDALSetProjection(hDstDS, pszWKT);
CPLFree(pszWKT);
int iBand;
/*if( nBandCount == 3 || nBandCount == 4 )
{
for(iBand = 0; iBand < nBandCount; iBand++)
{
GDALRasterBandH hBand = GDALGetRasterBand(hDstDS, iBand + 1);
GDALSetRasterColorInterpretation(hBand, (GDALColorInterp)(GCI_RedBand + iBand));
}
}*/
if (bNoDataSet)
{
for(iBand = 0; iBand < nBandCount; iBand++)
{
GDALRasterBandH hBand = GDALGetRasterBand(hDstDS, iBand + 1);
GDALSetRasterNoDataValue(hBand, dfNoData);
}
}
if (adfInitVals.size() != 0)
{
for(iBand = 0; iBand < MIN(nBandCount,(int)adfInitVals.size()); iBand++)
{
GDALRasterBandH hBand = GDALGetRasterBand(hDstDS, iBand + 1);
GDALFillRaster(hBand, adfInitVals[iBand], 0);
}
}
return hDstDS;
}
static CPLErr ProcessLayer( OGRLayerH hSrcLayer, GDALDatasetH hDstDS,
OGRGeometry *poClipSrc,
GUInt32 nXSize, GUInt32 nYSize, int nBand,
int& bIsXExtentSet, int& bIsYExtentSet,
double& dfXMin, double& dfXMax,
double& dfYMin, double& dfYMax,
const char *pszBurnAttribute,
const double dfIncreaseBurnValue,
const double dfMultiplyBurnValue,
GDALDataType eType,
GDALGridAlgorithm eAlgorithm, void *pOptions,
int bQuiet, GDALProgressFunc pfnProgress )
{
/* -------------------------------------------------------------------- */
/* Get field index, and check. */
/* -------------------------------------------------------------------- */
int iBurnField = -1;
if ( pszBurnAttribute )
{
iBurnField = OGR_FD_GetFieldIndex( OGR_L_GetLayerDefn( hSrcLayer ),
pszBurnAttribute );
if( iBurnField == -1 )
{
printf( "Failed to find field %s on layer %s, skipping.\n",
pszBurnAttribute,
OGR_FD_GetName( OGR_L_GetLayerDefn( hSrcLayer ) ) );
return CE_Failure;
}
}
/* -------------------------------------------------------------------- */
/* Collect the geometries from this layer, and build list of */
/* values to be interpolated. */
/* -------------------------------------------------------------------- */
OGRFeature *poFeat;
std::vector<double> adfX, adfY, adfZ;
OGR_L_ResetReading( hSrcLayer );
while( (poFeat = (OGRFeature *)OGR_L_GetNextFeature( hSrcLayer )) != NULL )
{
OGRGeometry *poGeom = poFeat->GetGeometryRef();
double dfBurnValue = 0.0;
if ( iBurnField >= 0 )
dfBurnValue = poFeat->GetFieldAsDouble( iBurnField );
ProcessCommonGeometry(poGeom, poClipSrc, iBurnField, dfBurnValue,
dfIncreaseBurnValue, dfMultiplyBurnValue, adfX, adfY, adfZ);
OGRFeature::DestroyFeature( poFeat );
}
if ( adfX.size() == 0 )
{
printf( "No point geometry found on layer %s, skipping.\n",
OGR_FD_GetName( OGR_L_GetLayerDefn( hSrcLayer ) ) );
return CE_None;
}
/* -------------------------------------------------------------------- */
/* Compute grid geometry. */
/* -------------------------------------------------------------------- */
if ( !bIsXExtentSet || !bIsYExtentSet )
{
OGREnvelope sEnvelope;
OGR_L_GetExtent( hSrcLayer, &sEnvelope, TRUE );
if ( !bIsXExtentSet )
{
dfXMin = sEnvelope.MinX;
dfXMax = sEnvelope.MaxX;
bIsXExtentSet = TRUE;
}
if ( !bIsYExtentSet )
{
dfYMin = sEnvelope.MinY;
dfYMax = sEnvelope.MaxY;
bIsYExtentSet = TRUE;
}
}
/* -------------------------------------------------------------------- */
/* Perform gridding. */
/* -------------------------------------------------------------------- */
const double dfDeltaX = ( dfXMax - dfXMin ) / nXSize;
const double dfDeltaY = ( dfYMax - dfYMin ) / nYSize;
if ( !bQuiet )
{
printf( "Grid data type is \"%s\"\n", GDALGetDataTypeName(eType) );
printf( "Grid size = (%lu %lu).\n",
(unsigned long)nXSize, (unsigned long)nYSize );
printf( "Corner coordinates = (%f %f)-(%f %f).\n",
dfXMin - dfDeltaX / 2, dfYMax + dfDeltaY / 2,
dfXMax + dfDeltaX / 2, dfYMin - dfDeltaY / 2 );
printf( "Grid cell size = (%f %f).\n", dfDeltaX, dfDeltaY );
printf( "Source point count = %lu.\n", (unsigned long)adfX.size() );
PrintAlgorithmAndOptions( eAlgorithm, pOptions );
printf("\n");
}
GDALRasterBandH hBand = GDALGetRasterBand( hDstDS, nBand );
if (adfX.size() == 0)
{
// FIXME: Shoulda' set to nodata value instead
GDALFillRaster( hBand, 0.0 , 0.0 );
return CE_None;
}
GUInt32 nXOffset, nYOffset;
int nBlockXSize, nBlockYSize;
int nDataTypeSize = GDALGetDataTypeSize(eType) / 8;
// Try to grow the work buffer up to 16 MB if it is smaller
GDALGetBlockSize( hBand, &nBlockXSize, &nBlockYSize );
const GUInt32 nDesiredBufferSize = 16*1024*1024;
if( (GUInt32)nBlockXSize < nXSize && (GUInt32)nBlockYSize < nYSize &&
(GUInt32)nBlockXSize < nDesiredBufferSize / (nBlockYSize * nDataTypeSize) )
{
int nNewBlockXSize = nDesiredBufferSize / (nBlockYSize * nDataTypeSize);
nBlockXSize = (nNewBlockXSize / nBlockXSize) * nBlockXSize;
if( (GUInt32)nBlockXSize > nXSize )
nBlockXSize = nXSize;
}
else if( (GUInt32)nBlockXSize == nXSize && (GUInt32)nBlockYSize < nYSize &&
(GUInt32)nBlockYSize < nDesiredBufferSize / (nXSize * nDataTypeSize) )
{
int nNewBlockYSize = nDesiredBufferSize / (nXSize * nDataTypeSize);
nBlockYSize = (nNewBlockYSize / nBlockYSize) * nBlockYSize;
if( (GUInt32)nBlockYSize > nYSize )
nBlockYSize = nYSize;
}
CPLDebug("GDAL_GRID", "Work buffer: %d * %d", nBlockXSize, nBlockYSize);
void *pData =
VSIMalloc3( nBlockXSize, nBlockYSize, nDataTypeSize );
if( pData == NULL )
{
CPLError(CE_Failure, CPLE_OutOfMemory, "Cannot allocate work buffer");
return CE_Failure;
}
GUInt32 nBlock = 0;
GUInt32 nBlockCount = ((nXSize + nBlockXSize - 1) / nBlockXSize)
* ((nYSize + nBlockYSize - 1) / nBlockYSize);
CPLErr eErr = CE_None;
for ( nYOffset = 0; nYOffset < nYSize && eErr == CE_None; nYOffset += nBlockYSize )
{
for ( nXOffset = 0; nXOffset < nXSize && eErr == CE_None; nXOffset += nBlockXSize )
{
void *pScaledProgress;
pScaledProgress =
GDALCreateScaledProgress( (double)nBlock / nBlockCount,
(double)(nBlock + 1) / nBlockCount,
pfnProgress, NULL );
nBlock ++;
int nXRequest = nBlockXSize;
if (nXOffset + nXRequest > nXSize)
nXRequest = nXSize - nXOffset;
int nYRequest = nBlockYSize;
if (nYOffset + nYRequest > nYSize)
nYRequest = nYSize - nYOffset;
eErr = GDALGridCreate( eAlgorithm, pOptions,
adfX.size(), &(adfX[0]), &(adfY[0]), &(adfZ[0]),
dfXMin + dfDeltaX * nXOffset,
dfXMin + dfDeltaX * (nXOffset + nXRequest),
dfYMin + dfDeltaY * nYOffset,
dfYMin + dfDeltaY * (nYOffset + nYRequest),
nXRequest, nYRequest, eType, pData,
GDALScaledProgress, pScaledProgress );
if( eErr == CE_None )
eErr = GDALRasterIO( hBand, GF_Write, nXOffset, nYOffset,
nXRequest, nYRequest, pData,
nXRequest, nYRequest, eType, 0, 0 );
GDALDestroyScaledProgress( pScaledProgress );
}
}
CPLFree( pData );
return eErr;
}