/**
* \private \memberof mapcache_source_gdal
* \sa mapcache_source::render_metatile()
*/
void _mapcache_source_gdal_render_metatile(mapcache_context *ctx, mapcache_metatile *tile)
{
mapcache_source_gdal *gdal = (mapcache_source_gdal*)tile->tile.tileset->source;
char *srcSRS = "", *dstSRS;
mapcache_buffer *data = mapcache_buffer_create(0,ctx->pool);
GC_CHECK_ERROR(ctx);
GDALDatasetH hDataset;
GDALAllRegister();
OGRSpatialReferenceH hSRS;
CPLErrorReset();
hSRS = OSRNewSpatialReference( NULL );
if( OSRSetFromUserInput( hSRS, tile->tile.grid->srs ) == OGRERR_NONE )
OSRExportToWkt( hSRS, &dstSRS );
else {
ctx->set_error(ctx,MAPCACHE_SOURCE_GDAL_ERROR,"failed to parse gdal srs %s",tile->tile.grid->srs);
return;
}
OSRDestroySpatialReference( hSRS );
hDataset = GDALOpen( gdal->datastr, GA_ReadOnly );
if( hDataset == NULL ) {
ctx->set_error(ctx,MAPCACHE_SOURCE_GDAL_ERROR,"GDAL failed to open %s",gdal->datastr);
return;
}
/* -------------------------------------------------------------------- */
/* Check that there's at least one raster band */
/* -------------------------------------------------------------------- */
if ( GDALGetRasterCount(hDataset) == 0 ) {
ctx->set_error(ctx,MAPCACHE_SOURCE_GDAL_ERROR,"raster %s has no bands",gdal->datastr);
return;
}
if( GDALGetProjectionRef( hDataset ) != NULL
&& strlen(GDALGetProjectionRef( hDataset )) > 0 )
srcSRS = apr_pstrdup(ctx->pool,GDALGetProjectionRef( hDataset ));
else if( GDALGetGCPProjection( hDataset ) != NULL
&& strlen(GDALGetGCPProjection(hDataset)) > 0
&& GDALGetGCPCount( hDataset ) > 1 )
srcSRS = apr_pstrdup(ctx->pool,GDALGetGCPProjection( hDataset ));
GDALDriverH hDriver = GDALGetDriverByName( "MEM" );
GDALDatasetH hDstDS;
/* -------------------------------------------------------------------- */
/* Create a transformation object from the source to */
/* destination coordinate system. */
/* -------------------------------------------------------------------- */
void *hTransformArg =
GDALCreateGenImgProjTransformer( hDataset, srcSRS,
NULL, dstSRS,
TRUE, 1000.0, 0 );
if( hTransformArg == NULL ) {
ctx->set_error(ctx,MAPCACHE_SOURCE_GDAL_ERROR,"gdal failed to create SRS transformation object");
return;
}
/* -------------------------------------------------------------------- */
/* Get approximate output definition. */
/* -------------------------------------------------------------------- */
int nPixels, nLines;
double adfDstGeoTransform[6];
if( GDALSuggestedWarpOutput( hDataset,
GDALGenImgProjTransform, hTransformArg,
adfDstGeoTransform, &nPixels, &nLines )
!= CE_None ) {
ctx->set_error(ctx,MAPCACHE_SOURCE_GDAL_ERROR,"gdal failed to create suggested warp output");
return;
}
GDALDestroyGenImgProjTransformer( hTransformArg );
double dfXRes = (tile->bbox[2] - tile->bbox[0]) / tile->sx;
double dfYRes = (tile->bbox[3] - tile->bbox[1]) / tile->sy;
adfDstGeoTransform[0] = tile->bbox[0];
adfDstGeoTransform[3] = tile->bbox[3];
adfDstGeoTransform[1] = dfXRes;
adfDstGeoTransform[5] = -dfYRes;
hDstDS = GDALCreate( hDriver, "tempd_gdal_image", tile->sx, tile->sy, 4, GDT_Byte, NULL );
/* -------------------------------------------------------------------- */
/* Write out the projection definition. */
/* -------------------------------------------------------------------- */
GDALSetProjection( hDstDS, dstSRS );
GDALSetGeoTransform( hDstDS, adfDstGeoTransform );
char **papszWarpOptions = NULL;
papszWarpOptions = CSLSetNameValue( papszWarpOptions, "INIT", "0" );
/* -------------------------------------------------------------------- */
/* Create a transformation object from the source to */
/* destination coordinate system. */
/* -------------------------------------------------------------------- */
GDALTransformerFunc pfnTransformer = NULL;
void *hGenImgProjArg=NULL, *hApproxArg=NULL;
hTransformArg = hGenImgProjArg =
GDALCreateGenImgProjTransformer( hDataset, srcSRS,
hDstDS, dstSRS,
TRUE, 1000.0, 0 );
if( hTransformArg == NULL )
exit( 1 );
pfnTransformer = GDALGenImgProjTransform;
hTransformArg = hApproxArg =
GDALCreateApproxTransformer( GDALGenImgProjTransform,
hGenImgProjArg, 0.125 );
pfnTransformer = GDALApproxTransform;
/* -------------------------------------------------------------------- */
/* Now actually invoke the warper to do the work. */
/* -------------------------------------------------------------------- */
GDALSimpleImageWarp( hDataset, hDstDS, 0, NULL,
pfnTransformer, hTransformArg,
GDALDummyProgress, NULL, papszWarpOptions );
CSLDestroy( papszWarpOptions );
if( hApproxArg != NULL )
GDALDestroyApproxTransformer( hApproxArg );
if( hGenImgProjArg != NULL )
GDALDestroyGenImgProjTransformer( hGenImgProjArg );
if(GDALGetRasterCount(hDstDS) != 4) {
ctx->set_error(ctx,MAPCACHE_SOURCE_GDAL_ERROR,"gdal did not create a 4 band image");
return;
}
GDALRasterBandH *redband, *greenband, *blueband, *alphaband;
redband = GDALGetRasterBand(hDstDS,1);
greenband = GDALGetRasterBand(hDstDS,2);
blueband = GDALGetRasterBand(hDstDS,3);
alphaband = GDALGetRasterBand(hDstDS,4);
unsigned char *rasterdata = apr_palloc(ctx->pool,tile->sx*tile->sy*4);
data->buf = rasterdata;
data->avail = tile->sx*tile->sy*4;
data->size = tile->sx*tile->sy*4;
GDALRasterIO(redband,GF_Read,0,0,tile->sx,tile->sy,(void*)(rasterdata),tile->sx,tile->sy,GDT_Byte,4,4*tile->sx);
GDALRasterIO(greenband,GF_Read,0,0,tile->sx,tile->sy,(void*)(rasterdata+1),tile->sx,tile->sy,GDT_Byte,4,4*tile->sx);
GDALRasterIO(blueband,GF_Read,0,0,tile->sx,tile->sy,(void*)(rasterdata+2),tile->sx,tile->sy,GDT_Byte,4,4*tile->sx);
if(GDALGetRasterCount(hDataset)==4)
GDALRasterIO(alphaband,GF_Read,0,0,tile->sx,tile->sy,(void*)(rasterdata+3),tile->sx,tile->sy,GDT_Byte,4,4*tile->sx);
else {
unsigned char *alphaptr;
int i;
for(alphaptr = rasterdata+3, i=0; i<tile->sx*tile->sy; i++, alphaptr+=4) {
*alphaptr = 255;
}
}
tile->imdata = mapcache_image_create(ctx);
tile->imdata->w = tile->sx;
tile->imdata->h = tile->sy;
tile->imdata->stride = tile->sx * 4;
tile->imdata->data = rasterdata;
GDALClose( hDstDS );
GDALClose( hDataset);
}
/**
* GDALReprojectImage() method with a ChunkAndWarpImage replaced with ChunkAndWarpMulti
*/
CPLErr GDALReprojectImageMulti( GDALDatasetH hSrcDS, const char *pszSrcWKT,
GDALDatasetH hDstDS, const char *pszDstWKT,
GDALResampleAlg eResampleAlg,
double dfWarpMemoryLimit,
double dfMaxError,
GDALProgressFunc pfnProgress, void *pProgressArg,
GDALWarpOptions *psOptions )
{
GDALWarpOptions *psWOptions;
/* -------------------------------------------------------------------- */
/* Setup a reprojection based transformer. */
/* -------------------------------------------------------------------- */
void *hTransformArg;
hTransformArg =
GDALCreateGenImgProjTransformer( hSrcDS, pszSrcWKT, hDstDS, pszDstWKT,
TRUE, 1000.0, 0 );
if( hTransformArg == NULL )
return CE_Failure;
/* -------------------------------------------------------------------- */
/* Create a copy of the user provided options, or a defaulted */
/* options structure. */
/* -------------------------------------------------------------------- */
if( psOptions == NULL )
psWOptions = GDALCreateWarpOptions();
else
psWOptions = GDALCloneWarpOptions( psOptions );
psWOptions->eResampleAlg = eResampleAlg;
/* -------------------------------------------------------------------- */
/* Set transform. */
/* -------------------------------------------------------------------- */
if( dfMaxError > 0.0 )
{
psWOptions->pTransformerArg =
GDALCreateApproxTransformer( GDALGenImgProjTransform,
hTransformArg, dfMaxError );
psWOptions->pfnTransformer = GDALApproxTransform;
}
else
{
psWOptions->pfnTransformer = GDALGenImgProjTransform;
psWOptions->pTransformerArg = hTransformArg;
}
/* -------------------------------------------------------------------- */
/* Set file and band mapping. */
/* -------------------------------------------------------------------- */
int iBand;
psWOptions->hSrcDS = hSrcDS;
psWOptions->hDstDS = hDstDS;
if( psWOptions->nBandCount == 0 )
{
psWOptions->nBandCount = MIN(GDALGetRasterCount(hSrcDS),
GDALGetRasterCount(hDstDS));
psWOptions->panSrcBands = (int *)
CPLMalloc(sizeof(int) * psWOptions->nBandCount);
psWOptions->panDstBands = (int *)
CPLMalloc(sizeof(int) * psWOptions->nBandCount);
for( iBand = 0; iBand < psWOptions->nBandCount; iBand++ )
{
psWOptions->panSrcBands[iBand] = iBand+1;
psWOptions->panDstBands[iBand] = iBand+1;
}
}
/* -------------------------------------------------------------------- */
/* Set source nodata values if the source dataset seems to have */
/* any. Same for target nodata values */
/* -------------------------------------------------------------------- */
for( iBand = 0; iBand < psWOptions->nBandCount; iBand++ )
{
GDALRasterBandH hBand = GDALGetRasterBand( hSrcDS, iBand+1 );
int bGotNoData = FALSE;
double dfNoDataValue;
if (GDALGetRasterColorInterpretation(hBand) == GCI_AlphaBand)
{
psWOptions->nSrcAlphaBand = iBand + 1;
}
dfNoDataValue = GDALGetRasterNoDataValue( hBand, &bGotNoData );
if( bGotNoData )
{
if( psWOptions->padfSrcNoDataReal == NULL )
{
int ii;
psWOptions->padfSrcNoDataReal = (double *)
CPLMalloc(sizeof(double) * psWOptions->nBandCount);
psWOptions->padfSrcNoDataImag = (double *)
CPLMalloc(sizeof(double) * psWOptions->nBandCount);
for( ii = 0; ii < psWOptions->nBandCount; ii++ )
{
psWOptions->padfSrcNoDataReal[ii] = -1.1e20;
psWOptions->padfSrcNoDataImag[ii] = 0.0;
}
}
psWOptions->padfSrcNoDataReal[iBand] = dfNoDataValue;
}
// Deal with target band
hBand = GDALGetRasterBand( hDstDS, iBand+1 );
if (hBand && GDALGetRasterColorInterpretation(hBand) == GCI_AlphaBand)
{
psWOptions->nDstAlphaBand = iBand + 1;
}
dfNoDataValue = GDALGetRasterNoDataValue( hBand, &bGotNoData );
if( bGotNoData )
{
if( psWOptions->padfDstNoDataReal == NULL )
{
int ii;
psWOptions->padfDstNoDataReal = (double *)
CPLMalloc(sizeof(double) * psWOptions->nBandCount);
psWOptions->padfDstNoDataImag = (double *)
CPLMalloc(sizeof(double) * psWOptions->nBandCount);
for( ii = 0; ii < psWOptions->nBandCount; ii++ )
{
psWOptions->padfDstNoDataReal[ii] = -1.1e20;
psWOptions->padfDstNoDataImag[ii] = 0.0;
}
}
psWOptions->padfDstNoDataReal[iBand] = dfNoDataValue;
}
}
/* -------------------------------------------------------------------- */
/* Set the progress function. */
/* -------------------------------------------------------------------- */
if( pfnProgress != NULL )
{
psWOptions->pfnProgress = pfnProgress;
psWOptions->pProgressArg = pProgressArg;
}
/* -------------------------------------------------------------------- */
/* Create a warp options based on the options. */
/* -------------------------------------------------------------------- */
GDALWarpOperation oWarper;
CPLErr eErr;
eErr = oWarper.Initialize( psWOptions );
if( eErr == CE_None )
eErr = oWarper.ChunkAndWarpMulti( 0, 0,
GDALGetRasterXSize(hDstDS),
GDALGetRasterYSize(hDstDS) );
/* -------------------------------------------------------------------- */
/* Cleanup. */
/* -------------------------------------------------------------------- */
GDALDestroyGenImgProjTransformer( hTransformArg );
if( dfMaxError > 0.0 )
GDALDestroyApproxTransformer( psWOptions->pTransformerArg );
GDALDestroyWarpOptions( psWOptions );
return eErr;
}
int main( int argc, char ** argv )
{
GDALDatasetH hSrcDS, hDstDS;
const char *pszFormat = "GTiff";
char *pszTargetSRS = NULL;
char *pszSourceSRS = NULL;
const char *pszSrcFilename = NULL, *pszDstFilename = NULL;
int bCreateOutput = FALSE, i, nOrder = 0;
void *hTransformArg, *hGenImgProjArg=NULL, *hApproxArg=NULL;
char **papszWarpOptions = NULL;
double dfErrorThreshold = 0.125;
GDALTransformerFunc pfnTransformer = NULL;
char **papszCreateOptions = NULL;
GDALAllRegister();
/* -------------------------------------------------------------------- */
/* Parse arguments. */
/* -------------------------------------------------------------------- */
for( i = 1; i < argc; i++ )
{
if( EQUAL(argv[i],"--version") )
{
printf( "%s\n", GDALVersionInfo( "--version" ) );
exit( 0 );
}
else if( EQUAL(argv[i],"--formats") )
{
int iDr;
printf( "Supported Formats:\n" );
for( iDr = 0; iDr < GDALGetDriverCount(); iDr++ )
{
GDALDriverH hDriver = GDALGetDriver(iDr);
printf( " %s: %s\n",
GDALGetDriverShortName( hDriver ),
GDALGetDriverLongName( hDriver ) );
}
exit( 0 );
}
else if( EQUAL(argv[i],"-co") && i < argc-1 )
{
papszCreateOptions = CSLAddString( papszCreateOptions, argv[++i] );
bCreateOutput = TRUE;
}
else if( EQUAL(argv[i],"-of") && i < argc-1 )
{
pszFormat = argv[++i];
bCreateOutput = TRUE;
}
else if( EQUAL(argv[i],"-t_srs") && i < argc-1 )
{
pszTargetSRS = SanitizeSRS(argv[++i]);
}
else if( EQUAL(argv[i],"-s_srs") && i < argc-1 )
{
pszSourceSRS = SanitizeSRS(argv[++i]);
}
else if( EQUAL(argv[i],"-order") && i < argc-1 )
{
nOrder = atoi(argv[++i]);
}
else if( EQUAL(argv[i],"-et") && i < argc-1 )
{
dfErrorThreshold = CPLAtof(argv[++i]);
}
else if( EQUAL(argv[i],"-tr") && i < argc-2 )
{
dfXRes = CPLAtof(argv[++i]);
dfYRes = fabs(CPLAtof(argv[++i]));
bCreateOutput = TRUE;
}
else if( EQUAL(argv[i],"-ts") && i < argc-2 )
{
nForcePixels = atoi(argv[++i]);
nForceLines = atoi(argv[++i]);
bCreateOutput = TRUE;
}
else if( EQUAL(argv[i],"-te") && i < argc-4 )
{
dfMinX = CPLAtof(argv[++i]);
dfMinY = CPLAtof(argv[++i]);
dfMaxX = CPLAtof(argv[++i]);
dfMaxY = CPLAtof(argv[++i]);
bCreateOutput = TRUE;
}
else if( argv[i][0] == '-' )
Usage();
else if( pszSrcFilename == NULL )
pszSrcFilename = argv[i];
else if( pszDstFilename == NULL )
pszDstFilename = argv[i];
else
Usage();
}
if( pszDstFilename == NULL )
Usage();
/* -------------------------------------------------------------------- */
/* Open source dataset. */
/* -------------------------------------------------------------------- */
hSrcDS = GDALOpen( pszSrcFilename, GA_ReadOnly );
if( hSrcDS == NULL )
exit( 2 );
/* -------------------------------------------------------------------- */
/* Check that there's at least one raster band */
/* -------------------------------------------------------------------- */
if ( GDALGetRasterCount(hSrcDS) == 0 )
{
fprintf(stderr, "Input file %s has no raster bands.\n", pszSrcFilename );
exit( 2 );
}
if( pszSourceSRS == NULL )
{
if( GDALGetProjectionRef( hSrcDS ) != NULL
&& strlen(GDALGetProjectionRef( hSrcDS )) > 0 )
pszSourceSRS = CPLStrdup(GDALGetProjectionRef( hSrcDS ));
else if( GDALGetGCPProjection( hSrcDS ) != NULL
&& strlen(GDALGetGCPProjection(hSrcDS)) > 0
&& GDALGetGCPCount( hSrcDS ) > 1 )
pszSourceSRS = CPLStrdup(GDALGetGCPProjection( hSrcDS ));
else
pszSourceSRS = CPLStrdup("");
}
if( pszTargetSRS == NULL )
pszTargetSRS = CPLStrdup(pszSourceSRS);
/* -------------------------------------------------------------------- */
/* Does the output dataset already exist? */
/* -------------------------------------------------------------------- */
CPLPushErrorHandler( CPLQuietErrorHandler );
hDstDS = GDALOpen( pszDstFilename, GA_Update );
CPLPopErrorHandler();
if( hDstDS != NULL && bCreateOutput )
{
fprintf( stderr,
"Output dataset %s exists,\n"
"but some commandline options were provided indicating a new dataset\n"
"should be created. Please delete existing dataset and run again.",
pszDstFilename );
exit( 1 );
}
/* -------------------------------------------------------------------- */
/* If not, we need to create it. */
/* -------------------------------------------------------------------- */
if( hDstDS == NULL )
{
hDstDS = GDALWarpCreateOutput( hSrcDS, pszDstFilename, pszFormat,
pszSourceSRS, pszTargetSRS, nOrder,
papszCreateOptions );
papszWarpOptions = CSLSetNameValue( papszWarpOptions, "INIT", "0" );
CSLDestroy( papszCreateOptions );
papszCreateOptions = NULL;
}
if( hDstDS == NULL )
exit( 1 );
/* -------------------------------------------------------------------- */
/* Create a transformation object from the source to */
/* destination coordinate system. */
/* -------------------------------------------------------------------- */
hTransformArg = hGenImgProjArg =
GDALCreateGenImgProjTransformer( hSrcDS, pszSourceSRS,
hDstDS, pszTargetSRS,
TRUE, 1000.0, nOrder );
if( hTransformArg == NULL )
exit( 1 );
pfnTransformer = GDALGenImgProjTransform;
/* -------------------------------------------------------------------- */
/* Warp the transformer with a linear approximator unless the */
/* acceptable error is zero. */
/* -------------------------------------------------------------------- */
if( dfErrorThreshold != 0.0 )
{
hTransformArg = hApproxArg =
GDALCreateApproxTransformer( GDALGenImgProjTransform,
hGenImgProjArg, dfErrorThreshold );
pfnTransformer = GDALApproxTransform;
}
/* -------------------------------------------------------------------- */
/* Now actually invoke the warper to do the work. */
/* -------------------------------------------------------------------- */
GDALSimpleImageWarp( hSrcDS, hDstDS, 0, NULL,
pfnTransformer, hTransformArg,
GDALTermProgress, NULL, papszWarpOptions );
CSLDestroy( papszWarpOptions );
if( hApproxArg != NULL )
GDALDestroyApproxTransformer( hApproxArg );
if( hGenImgProjArg != NULL )
GDALDestroyGenImgProjTransformer( hGenImgProjArg );
/* -------------------------------------------------------------------- */
/* Cleanup. */
/* -------------------------------------------------------------------- */
GDALClose( hDstDS );
GDALClose( hSrcDS );
GDALDumpOpenDatasets( stderr );
GDALDestroyDriverManager();
exit( 0 );
}
