GDALOverviewDataset::GDALOverviewDataset(GDALDataset* poMainDS,
int nOvrLevel,
int bThisLevelOnly,
int bOwnDS)
{
this->poMainDS = poMainDS;
this->nOvrLevel = nOvrLevel;
this->bOwnDS = bOwnDS;
this->bThisLevelOnly = bThisLevelOnly;
eAccess = poMainDS->GetAccess();
nRasterXSize = poMainDS->GetRasterBand(1)->GetOverview(nOvrLevel)->GetXSize();
nRasterYSize = poMainDS->GetRasterBand(1)->GetOverview(nOvrLevel)->GetYSize();
poOvrDS = poMainDS->GetRasterBand(1)->GetOverview(nOvrLevel)->GetDataset();
if( poOvrDS != NULL && poOvrDS == poMainDS )
{
CPLDebug("GDAL", "Dataset of overview is the same as the main band. This is not expected");
poOvrDS = NULL;
}
nBands = poMainDS->GetRasterCount();
for(int i=0; i<nBands; i++)
{
SetBand(i+1, new GDALOverviewBand(this, i+1));
}
nGCPCount = 0;
pasGCPList = NULL;
papszMD_RPC = NULL;
papszMD_GEOLOCATION = NULL;
/* We create a fake driver that has the same name as the original */
/* one, but we cannot use the real driver object, so that code */
/* doesn't try to cast the GDALOverviewDataset* as a native dataset */
/* object */
if( poMainDS->GetDriver() != NULL )
{
poDriver = new GDALDriver();
poDriver->SetDescription(poMainDS->GetDriver()->GetDescription());
poDriver->SetMetadata(poMainDS->GetDriver()->GetMetadata());
}
SetDescription( poMainDS->GetDescription() );
CPLDebug( "GDAL", "GDALOverviewDataset(%s, this=%p) creation.",
poMainDS->GetDescription(), this );
papszOpenOptions = CSLDuplicate(poMainDS->GetOpenOptions());
/* Add OVERVIEW_LEVEL if not called from GDALOpenEx() but directly */
papszOpenOptions = CSLSetNameValue(papszOpenOptions, "OVERVIEW_LEVEL",
CPLSPrintf("%d", nOvrLevel));
}
OGRLayer *GNMGenericNetwork::CopyLayer(OGRLayer *poSrcLayer,
const char *pszNewName, char **papszOptions)
{
if(CSLFindName(papszOptions, "DST_SRSWKT") == -1)
{
papszOptions = CSLAddNameValue(papszOptions, "DST_SRSWKT",
GetProjectionRef());
}
else
{
papszOptions = CSLSetNameValue(papszOptions, "DST_SRSWKT",
GetProjectionRef());
}
return GDALDataset::CopyLayer(poSrcLayer, pszNewName, papszOptions);
}
OGRPLScenesDataV1Dataset::~OGRPLScenesDataV1Dataset()
{
for( int i = 0; i < m_nLayers; i++ )
delete m_papoLayers[i];
CPLFree(m_papoLayers);
if( m_bMustCleanPersistent )
{
char **papszOptions =
CSLSetNameValue(
nullptr, "CLOSE_PERSISTENT", CPLSPrintf("PLSCENES:%p", this));
CPLHTTPDestroyResult(CPLHTTPFetch(m_osBaseURL, papszOptions));
CSLDestroy(papszOptions);
}
}
void CCreateMapFineTune::slotSave()
{
IMap& map = CMapDB::self().getMap();
GDALDataset * srcds = map.getDataset();
if(srcds == 0)
{
return;
}
double adfGeoTransform[6];
double u1, v1, u2, v2;
map.dimensions(u1, v1, u2, v2);
map.convertRad2M(u1, v1);
map.convertRad2M(u2, v2);
srcds->GetGeoTransform( adfGeoTransform );
adfGeoTransform[0] = u1;
adfGeoTransform[3] = v1;
progressBar->show();
GDALDriver * driver = srcds->GetDriver();
char **papszOptions = NULL;
papszOptions = CSLSetNameValue( papszOptions, "TILED", "YES" );
papszOptions = CSLSetNameValue( papszOptions, "COMPRESS", "DEFLATE" );
GDALDataset * dstds = driver->CreateCopy(labelOutfile->text().toLocal8Bit(), srcds, false, papszOptions, ProgressFunc, this);
if(dstds)
{
dstds->SetGeoTransform( adfGeoTransform );
GDALClose(dstds);
}
CSLDestroy( papszOptions );
progressBar->hide();
}
OGRS57DataSource::OGRS57DataSource(char** papszOpenOptionsIn) :
pszName(NULL),
nLayers(0),
papoLayers(NULL),
poSpatialRef(new OGRSpatialReference()),
papszOptions(NULL),
nModules(0),
papoModules(NULL),
poWriter(NULL),
poClassContentExplorer(NULL),
bExtentsSet(false)
{
poSpatialRef->SetWellKnownGeogCS( "WGS84" );
/* -------------------------------------------------------------------- */
/* Allow initialization of options from the environment. */
/* -------------------------------------------------------------------- */
const char *pszOptString = CPLGetConfigOption( "OGR_S57_OPTIONS", NULL );
if ( pszOptString == NULL )
return;
papszOptions =
CSLTokenizeStringComplex( pszOptString, ",", FALSE, FALSE );
if ( papszOptions && *papszOptions )
{
CPLDebug( "S57", "The following S57 options are being set:" );
char **papszCurOption = papszOptions;
while( *papszCurOption )
CPLDebug( "S57", " %s", *papszCurOption++ );
}
/* -------------------------------------------------------------------- */
/* And from open options. */
/* -------------------------------------------------------------------- */
for(char** papszIter = papszOpenOptionsIn; papszIter && *papszIter; ++papszIter )
{
char* pszKey = NULL;
const char* pszValue = CPLParseNameValue(*papszIter, &pszKey);
if( pszKey && pszValue )
{
papszOptions = CSLSetNameValue(papszOptions, pszKey, pszValue);
}
CPLFree(pszKey);
}
}
OGRCouchDBDataSource::~OGRCouchDBDataSource()
{
for( int i = 0; i < nLayers; i++ )
delete papoLayers[i];
CPLFree( papoLayers );
if( bMustCleanPersistent )
{
char** papszOptions = NULL;
papszOptions = CSLSetNameValue(papszOptions, "CLOSE_PERSISTENT", CPLSPrintf("CouchDB:%p", this));
CPLHTTPDestroyResult( CPLHTTPFetch( osURL, papszOptions ) );
CSLDestroy(papszOptions);
}
CPLFree( pszName );
}
OGRGFTDataSource::~OGRGFTDataSource()
{
for( int i = 0; i < nLayers; i++ )
delete papoLayers[i];
CPLFree( papoLayers );
if (bMustCleanPersistent)
{
char** papszOptions = nullptr;
papszOptions = CSLSetNameValue(papszOptions, "CLOSE_PERSISTENT", CPLSPrintf("GFT:%p", this));
CPLHTTPDestroyResult( CPLHTTPFetch( GetAPIURL(), papszOptions) );
CSLDestroy(papszOptions);
}
CPLFree( pszName );
}
void PAuxRasterBand::SetDescription( const char *pszNewDescription )
{
if( GetAccess() == GA_Update )
{
char szTarget[128];
snprintf( szTarget, sizeof(szTarget), "ChanDesc-%d", nBand );
PAuxDataset *poPDS = reinterpret_cast<PAuxDataset *>( poDS );
poPDS->papszAuxLines =
CSLSetNameValue( poPDS->papszAuxLines,
szTarget, pszNewDescription );
poPDS->bAuxUpdated = TRUE;
}
GDALRasterBand::SetDescription( pszNewDescription );
}
OGRCARTODBDataSource::~OGRCARTODBDataSource()
{
for( int i = 0; i < nLayers; i++ )
delete papoLayers[i];
CPLFree( papoLayers );
if (bMustCleanPersistant)
{
char** papszOptions = NULL;
papszOptions = CSLSetNameValue(papszOptions, "CLOSE_PERSISTENT", CPLSPrintf("CARTODB:%p", this));
CPLHTTPFetch( GetAPIURL(), papszOptions);
CSLDestroy(papszOptions);
}
CPLFree( pszName );
CPLFree( pszAccount );
}
OGRAmigoCloudDataSource::~OGRAmigoCloudDataSource()
{
for( int i = 0; i < nLayers; i++ )
delete papoLayers[i];
CPLFree( papoLayers );
if( bMustCleanPersistent )
{
char** papszOptions = NULL;
papszOptions = CSLSetNameValue(papszOptions, "CLOSE_PERSISTENT", CPLSPrintf("AMIGOCLOUD:%p", this));
CPLHTTPDestroyResult( CPLHTTPFetch( GetAPIURL(), papszOptions) );
CSLDestroy(papszOptions);
}
CPLFree( pszName );
CPLFree(pszProjetctId);
}
int
makeGeotiff (struct deminfo *d0, char *outpath,int nodata)
{
GDALAllRegister ();
GDALDataType band_type = GDT_Float32;
int bands = 1;
int dsn_xsize = (d0->highx - d0->lowx + 1);
int dsn_ysize = (d0->highy - d0->lowy + 1);
char **papszCreateOptions = NULL;
papszCreateOptions = CSLSetNameValue (papszCreateOptions, "PROFILE", "GeoTIFF");
//papszCreateOptions = CSLSetNameValue( papszCreateOptions, "TFW", "YES" );
//papszCreateOptions = CSLSetNameValue (papszCreateOptions, "INTERLEAVE", "PIXEL");
//papszCreateOptions = CSLSetNameValue (papszCreateOptions, "TILED", "YES");
//papszCreateOptions = CSLSetNameValue (papszCreateOptions, "COMPRESS", "LZW");
GDALDriverH hDriver = GDALGetDriverByName ("GTiff");
GDALDatasetH hDsnDS = GDALCreate (hDriver, outpath, dsn_xsize, dsn_ysize, bands, band_type, papszCreateOptions);
double dsnGeoTransform[6];
dsnGeoTransform[0] = d0->W;
dsnGeoTransform[1] = (d0->E - d0->W) / dsn_xsize;
dsnGeoTransform[2] = 0;
dsnGeoTransform[3] = d0->N;
dsnGeoTransform[4] = 0;
dsnGeoTransform[5] = -1.0 * (d0->N - d0->S) / dsn_ysize;
GDALSetGeoTransform (hDsnDS, dsnGeoTransform);
char pszSRS_WKT[1024] = "GEOGCS[\"JGD2000\", DATUM[\"Japanese Geodetic Datum 2000\", SPHEROID[\"GRS 1980\", 6378137.0, 298.257222101, AUTHORITY[\"EPSG\",\"7019\"]], TOWGS84[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],AUTHORITY[\"EPSG\",\"6612\"]], PRIMEM[\"Greenwich\", 0.0, AUTHORITY[\"EPSG\",\"8901\"]], UNIT[\"degree\", 0.017453292519943295], AXIS[\"Geodetic longitude\", EAST], AXIS[\"Geodetic latitude\", NORTH], AUTHORITY[\"EPSG\",\"4612\"]]";
GDALSetProjection (hDsnDS, pszSRS_WKT);
GDALRasterBandH t_band = GDALGetRasterBand (hDsnDS, 1);
if(nodata==1){
GDALSetRasterNoDataValue (t_band, -9999);
}
GDALRasterIO (t_band, GF_Write, 0, 0, dsn_xsize, dsn_ysize, d0->alti, dsn_xsize, dsn_ysize, band_type, 0, 0);
CSLDestroy (papszCreateOptions);
GDALClose (hDsnDS);
return 0;
}
void PAuxRasterBand::SetDescription( const char *pszNewDescription )
{
PAuxDataset *poPDS = (PAuxDataset *) poDS;
if( GetAccess() == GA_Update )
{
char szTarget[128];
sprintf( szTarget, "ChanDesc-%d", nBand );
poPDS->papszAuxLines =
CSLSetNameValue( poPDS->papszAuxLines,
szTarget, pszNewDescription );
poPDS->bAuxUpdated = TRUE;
}
GDALRasterBand::SetDescription( pszNewDescription );
}
std::string Polygon::json(double precision) const
{
std::ostringstream prec;
prec << precision;
char **papszOptions = NULL;
papszOptions = CSLSetNameValue(papszOptions, "COORDINATE_PRECISION",
prec.str().c_str() );
std::string w(wkt());
gdal::SpatialRef srs(m_srs.getWKT(pdal::SpatialReference::eCompoundOK));
gdal::Geometry g(w, srs);
char* json = OGR_G_ExportToJsonEx(g.get(), papszOptions);
std::string output(json);
OGRFree(json);
return output;
}
int VICARKeywordHandler::ReadGroup( CPL_UNUSED const char *pszPathPrefix ) {
CPLString osName, osValue, osProperty;
for( ; true; ) {
if( !ReadPair( osName, osValue ) )
return FALSE;
if( EQUAL(osName,"END") )
return TRUE;
if( EQUAL(osName,"PROPERTY") || EQUAL(osName,"HISTORY") || EQUAL(osName,"TASK"))
osProperty = osValue;
else {
if ( !EQUAL(osProperty,"") )
osName = osProperty + "." + osName;
papszKeywordList = CSLSetNameValue( papszKeywordList, osName, osValue );
}
}
}
static dErr JakoGDALMemAddBand(GDALDatasetH dset,GDALDataType dtype,void *memory)
{
char buf[256] = {0},**bandoptions = NULL;
int bytes,nx,ny;
CPLErr cplerr;
dErr err;
dFunctionBegin;
bytes = GDALGetDataTypeSize(dtype);
nx = GDALGetRasterXSize(dset);
ny = GDALGetRasterYSize(dset);
err = dMalloc(nx*ny*bytes,(void**)memory);dCHK(err);
// This is where the API moves from merely cumbersome to outright demeaning, like some twisted hazing ritual.
CPLPrintPointer(buf,*(void**)memory,sizeof(buf));
bandoptions = CSLSetNameValue(bandoptions,"DATAPOINTER",buf);
cplerr = GDALAddBand(dset,dtype,bandoptions);dCPLCHK(cplerr);
CSLDestroy(bandoptions);
dFunctionReturn(0);
}
// set a single metadata item
CPLErr KEADataset::SetMetadataItem(const char *pszName, const char *pszValue, const char *pszDomain)
{
// only deal with 'default' domain - no geolocation etc
if( ( pszDomain != NULL ) && ( *pszDomain != '\0' ) )
return CE_Failure;
try
{
this->m_pImageIO->setImageMetaData(pszName, pszValue );
// CSLSetNameValue will update if already there
m_papszMetadataList = CSLSetNameValue( m_papszMetadataList, pszName, pszValue );
return CE_None;
}
catch (kealib::KEAIOException &e)
{
CPLError( CE_Failure, CPLE_AppDefined,
"Unable to write metadata: %s", e.what() );
return CE_Failure;
}
}
void GDALJP2Metadata::CollectGMLData( GDALJP2Box *poGMLData )
{
GDALJP2Box oChildBox( poGMLData->GetFILE() );
oChildBox.ReadFirstChild( poGMLData );
while( strlen(oChildBox.GetType()) > 0 )
{
if( EQUAL(oChildBox.GetType(),"asoc") )
{
GDALJP2Box oSubChildBox( oChildBox.GetFILE() );
char *pszLabel = NULL;
char *pszXML = NULL;
oSubChildBox.ReadFirstChild( &oChildBox );
while( strlen(oSubChildBox.GetType()) > 0 )
{
if( EQUAL(oSubChildBox.GetType(),"lbl ") )
pszLabel = (char *)oSubChildBox.ReadBoxData();
else if( EQUAL(oSubChildBox.GetType(),"xml ") )
pszXML = (char *) oSubChildBox.ReadBoxData();
oSubChildBox.ReadNextChild( &oChildBox );
}
if( pszLabel != NULL && pszXML != NULL )
papszGMLMetadata = CSLSetNameValue( papszGMLMetadata,
pszLabel, pszXML );
CPLFree( pszLabel );
CPLFree( pszXML );
}
oChildBox.ReadNextChild( poGMLData );
}
}
CPLErr PAuxRasterBand::SetNoDataValue( double dfNewValue )
{
if( GetAccess() == GA_ReadOnly )
{
CPLError( CE_Failure, CPLE_NoWriteAccess,
"Can't update readonly dataset." );
return CE_Failure;
}
char szTarget[128];
char szValue[128];
snprintf( szTarget, sizeof(szTarget), "METADATA_IMG_%d_NO_DATA_VALUE", nBand );
CPLsnprintf( szValue, sizeof(szValue), "%24.12f", dfNewValue );
PAuxDataset *poPDS = reinterpret_cast<PAuxDataset *>( poDS );
poPDS->papszAuxLines =
CSLSetNameValue( poPDS->papszAuxLines, szTarget, szValue );
poPDS->bAuxUpdated = TRUE;
return CE_None;
}
NITFDES *NITFDESAccess( NITFFile *psFile, int iSegment )
{
NITFDES *psDES;
char *pachHeader;
NITFSegmentInfo *psSegInfo;
char szDESID[26];
char szTemp[128];
int nOffset;
int bHasDESOFLW;
int nDESSHL;
/* -------------------------------------------------------------------- */
/* Verify segment, and return existing DES accessor if there */
/* is one. */
/* -------------------------------------------------------------------- */
if( iSegment < 0 || iSegment >= psFile->nSegmentCount )
return NULL;
psSegInfo = psFile->pasSegmentInfo + iSegment;
if( !EQUAL(psSegInfo->szSegmentType,"DE") )
return NULL;
if( psSegInfo->hAccess != NULL )
return (NITFDES *) psSegInfo->hAccess;
/* -------------------------------------------------------------------- */
/* Read the DES subheader. */
/* -------------------------------------------------------------------- */
if (psSegInfo->nSegmentHeaderSize < 200)
{
CPLError(CE_Failure, CPLE_AppDefined,
"DES header too small");
return NULL;
}
pachHeader = (char*) VSIMalloc(psSegInfo->nSegmentHeaderSize);
if (pachHeader == NULL)
{
CPLError(CE_Failure, CPLE_OutOfMemory,
"Cannot allocate memory for segment header");
return NULL;
}
retry:
if( VSIFSeekL( psFile->fp, psSegInfo->nSegmentHeaderStart,
SEEK_SET ) != 0
|| VSIFReadL( pachHeader, 1, psSegInfo->nSegmentHeaderSize,
psFile->fp ) != psSegInfo->nSegmentHeaderSize )
{
CPLError( CE_Failure, CPLE_FileIO,
"Failed to read %u byte DES subheader from " CPL_FRMT_GUIB ".",
psSegInfo->nSegmentHeaderSize,
psSegInfo->nSegmentHeaderStart );
CPLFree(pachHeader);
return NULL;
}
if (!EQUALN(pachHeader, "DE", 2))
{
if (EQUALN(pachHeader + 4, "DERegistered", 12))
{
/* BAO_46_Ed1/rpf/conc/concz10/000fz010.ona and cie are buggy */
CPLDebug("NITF", "Patching nSegmentHeaderStart and nSegmentStart for DE segment %d", iSegment);
psSegInfo->nSegmentHeaderStart += 4;
psSegInfo->nSegmentStart += 4;
goto retry;
}
CPLError(CE_Failure, CPLE_AppDefined,
"Invalid segment prefix for DE segment %d", iSegment);
CPLFree(pachHeader);
return NULL;
}
/* -------------------------------------------------------------------- */
/* Initialize DES object. */
/* -------------------------------------------------------------------- */
psDES = (NITFDES *) CPLCalloc(sizeof(NITFDES),1);
psDES->psFile = psFile;
psDES->iSegment = iSegment;
psDES->pachHeader = pachHeader;
psSegInfo->hAccess = psDES;
/* -------------------------------------------------------------------- */
/* Collect a variety of information as metadata. */
/* -------------------------------------------------------------------- */
#define GetMD( length, name ) \
do { NITFExtractMetadata( &(psDES->papszMetadata), pachHeader, \
nOffset, length, \
"NITF_" #name ); \
nOffset += length; } while(0)
nOffset = 2;
GetMD( 25, DESID );
GetMD( 2, DESVER );
GetMD( 1, DECLAS );
GetMD( 2, DESCLSY );
GetMD( 11, DESCODE );
GetMD( 2, DESCTLH );
GetMD( 20, DESREL );
GetMD( 2, DESDCTP );
GetMD( 8, DESDCDT );
GetMD( 4, DESDCXM );
GetMD( 1, DESDG );
GetMD( 8, DESDGDT );
GetMD( 43, DESCLTX );
GetMD( 1, DESCATP );
GetMD( 40, DESCAUT );
GetMD( 1, DESCRSN );
GetMD( 8, DESSRDT );
GetMD( 15, DESCTLN );
/* Load DESID */
NITFGetField( szDESID, pachHeader, 2, 25);
/* For NITF < 02.10, we cannot rely on DESID=TRE_OVERFLOW to detect */
/* if DESOFLW and DESITEM are present. So if the next 4 bytes are non */
/* numeric, we'll assume that DESOFLW is there */
bHasDESOFLW = EQUALN(szDESID, "TRE_OVERFLOW", strlen("TRE_OVERFLOW")) ||
(!((pachHeader[nOffset+0] >= '0' && pachHeader[nOffset+0] <= '9') &&
(pachHeader[nOffset+1] >= '0' && pachHeader[nOffset+1] <= '9') &&
(pachHeader[nOffset+2] >= '0' && pachHeader[nOffset+2] <= '9') &&
(pachHeader[nOffset+3] >= '0' && pachHeader[nOffset+3] <= '9')));
if (bHasDESOFLW)
{
if ((int)psSegInfo->nSegmentHeaderSize < nOffset + 6 + 3 )
{
CPLError(CE_Failure, CPLE_AppDefined,
"DES header too small");
NITFDESDeaccess(psDES);
return NULL;
}
GetMD( 6, DESOFLW );
GetMD( 3, DESITEM );
}
if ((int)psSegInfo->nSegmentHeaderSize < nOffset + 4 )
{
CPLError(CE_Failure, CPLE_AppDefined,
"DES header too small");
NITFDESDeaccess(psDES);
return NULL;
}
nDESSHL = atoi(NITFGetField( szTemp, pachHeader, nOffset, 4));
nOffset += 4;
if (nDESSHL < 0)
{
CPLError(CE_Failure, CPLE_AppDefined,
"Invalid value for DESSHL");
NITFDESDeaccess(psDES);
return NULL;
}
if ( (int)psSegInfo->nSegmentHeaderSize < nOffset + nDESSHL)
{
CPLError(CE_Failure, CPLE_AppDefined,
"DES header too small");
NITFDESDeaccess(psDES);
return NULL;
}
if (EQUALN(szDESID, "CSSHPA DES", strlen("CSSHPA DES")))
{
if ( nDESSHL != 62 && nDESSHL != 80)
{
CPLError(CE_Failure, CPLE_AppDefined,
"Invalid DESSHL for CSSHPA DES");
NITFDESDeaccess(psDES);
return NULL;
}
GetMD( 25, SHAPE_USE );
GetMD( 10, SHAPE_CLASS );
if (nDESSHL == 80)
GetMD( 18, CC_SOURCE );
GetMD( 3, SHAPE1_NAME );
GetMD( 6, SHAPE1_START );
GetMD( 3, SHAPE2_NAME );
GetMD( 6, SHAPE2_START );
GetMD( 3, SHAPE3_NAME );
GetMD( 6, SHAPE3_START );
}
else if (nDESSHL > 0)
GetMD( nDESSHL, DESSHF );
if ((int)psSegInfo->nSegmentHeaderSize > nOffset)
{
char* pszEscapedDESDATA =
CPLEscapeString( pachHeader + nOffset,
(int)psSegInfo->nSegmentHeaderSize - nOffset,
CPLES_BackslashQuotable );
psDES->papszMetadata = CSLSetNameValue( psDES->papszMetadata,
"NITF_DESDATA",
pszEscapedDESDATA );
CPLFree(pszEscapedDESDATA);
}
return psDES;
}
int msUVRASTERLayerWhichShapes(layerObj *layer, rectObj rect, int isQuery)
{
uvRasterLayerInfo *uvlinfo = (uvRasterLayerInfo *) layer->layerinfo;
imageObj *image_tmp;
outputFormatObj *outputformat = NULL;
mapObj *map_tmp;
double map_cellsize;
unsigned int spacing;
int width, height, u_src_off, v_src_off, i, x, y;
char **alteredProcessing = NULL, *saved_layer_mask;
char **savedProcessing = NULL;
if (layer->debug)
msDebug("Entering msUVRASTERLayerWhichShapes().\n");
if( uvlinfo == NULL )
return MS_FAILURE;
/* QUERY NOT SUPPORTED YET */
if (isQuery == MS_TRUE) {
msSetError( MS_MISCERR, "Query is not supported for UV layer.", "msUVRASTERLayerWhichShapes()" );
return MS_FAILURE;
}
if( CSLFetchNameValue( layer->processing, "BANDS" ) == NULL ) {
msSetError( MS_MISCERR, "BANDS processing option is required for UV layer. You have to specified 2 bands.",
"msUVRASTERLayerWhichShapes()" );
return MS_FAILURE;
}
/*
** Allocate mapObj structure
*/
map_tmp = (mapObj *)msSmallCalloc(sizeof(mapObj),1);
if(initMap(map_tmp) == -1) { /* initialize this map */
msFree(map_tmp);
return(MS_FAILURE);
}
/* -------------------------------------------------------------------- */
/* Determine desired spacing. Default to 32 if not otherwise set */
/* -------------------------------------------------------------------- */
spacing = 32;
if( CSLFetchNameValue( layer->processing, "UV_SPACING" ) != NULL ) {
spacing =
atoi(CSLFetchNameValue( layer->processing, "UV_SPACING" ));
}
width = (int)ceil(layer->map->width/spacing);
height = (int)ceil(layer->map->height/spacing);
map_cellsize = MS_MAX(MS_CELLSIZE(rect.minx, rect.maxx,layer->map->width),
MS_CELLSIZE(rect.miny,rect.maxy,layer->map->height));
map_tmp->cellsize = map_cellsize*spacing;
if (layer->debug)
msDebug("msUVRASTERLayerWhichShapes(): width: %d, height: %d, cellsize: %g\n",
width, height, map_tmp->cellsize);
/* Initialize our dummy map */
MS_INIT_COLOR(map_tmp->imagecolor, 255,255,255,255);
map_tmp->resolution = layer->map->resolution;
map_tmp->defresolution = layer->map->defresolution;
outputformat = (outputFormatObj *) msSmallCalloc(1,sizeof(outputFormatObj));
outputformat->bands = uvlinfo->band_count = 2;
outputformat->name = NULL;
outputformat->driver = NULL;
outputformat->refcount = 0;
outputformat->vtable = NULL;
outputformat->device = NULL;
outputformat->renderer = MS_RENDER_WITH_RAWDATA;
outputformat->imagemode = MS_IMAGEMODE_FLOAT32;
msAppendOutputFormat(map_tmp, outputformat);
msCopyHashTable(&map_tmp->configoptions, &layer->map->configoptions);
map_tmp->mappath = msStrdup(layer->map->mappath);
map_tmp->shapepath = msStrdup(layer->map->shapepath);
map_tmp->extent.minx = rect.minx-(0.5*map_cellsize)+(0.5*map_tmp->cellsize);
map_tmp->extent.miny = rect.miny-(0.5*map_cellsize)+(0.5*map_tmp->cellsize);
map_tmp->extent.maxx = map_tmp->extent.minx+((width-1)*map_tmp->cellsize);
map_tmp->extent.maxy = map_tmp->extent.miny+((height-1)*map_tmp->cellsize);
map_tmp->gt.rotation_angle = 0.0;
msCopyProjection(&map_tmp->projection, &layer->projection);
if (layer->debug == 5)
msDebug("msUVRASTERLayerWhichShapes(): extent: %g %g %g %g\n",
map_tmp->extent.minx, map_tmp->extent.miny,
map_tmp->extent.maxx, map_tmp->extent.maxy);
/* important to use that function, to compute map
geotransform, used by the resampling*/
msMapSetSize(map_tmp, width, height);
if (layer->debug == 5)
msDebug("msUVRASTERLayerWhichShapes(): geotransform: %g %g %g %g %g %g\n",
map_tmp->gt.geotransform[0], map_tmp->gt.geotransform[1],
map_tmp->gt.geotransform[2], map_tmp->gt.geotransform[3],
map_tmp->gt.geotransform[4], map_tmp->gt.geotransform[5]);
uvlinfo->extent = map_tmp->extent;
image_tmp = msImageCreate(width, height, map_tmp->outputformatlist[0],
NULL, NULL, map_tmp->resolution, map_tmp->defresolution,
&(map_tmp->imagecolor));
/* Default set to AVERAGE resampling */
if( CSLFetchNameValue( layer->processing, "RESAMPLE" ) == NULL ) {
alteredProcessing = CSLDuplicate( layer->processing );
alteredProcessing =
CSLSetNameValue( alteredProcessing, "RESAMPLE",
"AVERAGE");
savedProcessing = layer->processing;
layer->processing = alteredProcessing;
}
/* disable masking at this level: we don't want to apply the mask at the raster level,
* it will be applied with the correct cellsize and image size in the vector rendering
* phase.
*/
saved_layer_mask = layer->mask;
layer->mask = NULL;
if (msDrawRasterLayerLow(map_tmp, layer, image_tmp, NULL ) == MS_FAILURE) {
msSetError(MS_MISCERR, "Unable to draw raster data.", "msUVRASTERLayerWhichShapes()");
layer->mask = saved_layer_mask;
return MS_FAILURE;
}
/* restore layer mask */
layer->mask = saved_layer_mask;
/* restore the saved processing */
if (alteredProcessing != NULL) {
layer->processing = savedProcessing;
CSLDestroy(alteredProcessing);
}
/* free old query arrays */
if (uvlinfo->u) {
for (i=0; i<uvlinfo->width; ++i) {
free(uvlinfo->u[i]);
}
free(uvlinfo->u);
}
if (uvlinfo->v) {
for (i=0; i<uvlinfo->height; ++i) {
free(uvlinfo->v[i]);
}
free(uvlinfo->v);
}
/* Update our uv layer structure */
uvlinfo->width = width;
uvlinfo->height = height;
uvlinfo->query_results = width*height;
uvlinfo->u = (float **)msSmallMalloc(sizeof(float *)*width);
uvlinfo->v = (float **)msSmallMalloc(sizeof(float *)*width);
for (x = 0; x < width; ++x) {
uvlinfo->u[x] = (float *)msSmallMalloc(height * sizeof(float));
uvlinfo->v[x] = (float *)msSmallMalloc(height * sizeof(float));
for (y = 0; y < height; ++y) {
u_src_off = v_src_off = x + y * width;
v_src_off += width*height;
uvlinfo->u[x][y] = image_tmp->img.raw_float[u_src_off];
uvlinfo->v[x][y] = image_tmp->img.raw_float[v_src_off];
/* null vector? update the number of results */
if (uvlinfo->u[x][y] == 0 && uvlinfo->v[x][y] == 0)
--uvlinfo->query_results;
}
}
msFreeImage(image_tmp); /* we do not need the imageObj anymore */
msFreeMap(map_tmp);
uvlinfo->next_shape = 0;
return MS_SUCCESS;
}
GDALDataset *HDF4Dataset::Open( GDALOpenInfo * poOpenInfo )
{
int32 i;
if( !Identify( poOpenInfo ) )
return NULL;
/* -------------------------------------------------------------------- */
/* Try opening the dataset. */
/* -------------------------------------------------------------------- */
int32 hHDF4;
hHDF4 = Hopen(poOpenInfo->pszFilename, DFACC_READ, 0);
if( hHDF4 <= 0 )
return( NULL );
Hclose( hHDF4 );
/* -------------------------------------------------------------------- */
/* Create a corresponding GDALDataset. */
/* -------------------------------------------------------------------- */
HDF4Dataset *poDS;
poDS = new HDF4Dataset();
poDS->fp = poOpenInfo->fp;
poOpenInfo->fp = NULL;
/* -------------------------------------------------------------------- */
/* Open HDF SDS Interface. */
/* -------------------------------------------------------------------- */
poDS->hSD = SDstart( poOpenInfo->pszFilename, DFACC_READ );
if ( poDS->hSD == -1 )
{
delete poDS;
return NULL;
}
/* -------------------------------------------------------------------- */
/* Now read Global Attributes. */
/* -------------------------------------------------------------------- */
if ( poDS->ReadGlobalAttributes( poDS->hSD ) != CE_None )
{
delete poDS;
return NULL;
}
poDS->SetMetadata( poDS->papszGlobalMetadata, "" );
/* -------------------------------------------------------------------- */
/* Determine type of file we read. */
/* -------------------------------------------------------------------- */
const char *pszValue;
if ( (pszValue = CSLFetchNameValue(poDS->papszGlobalMetadata,
"Signature"))
&& EQUAL( pszValue, pszGDALSignature ) )
{
poDS->iSubdatasetType = H4ST_GDAL;
poDS->pszSubdatasetType = "GDAL_HDF4";
}
else if ( (pszValue = CSLFetchNameValue(poDS->papszGlobalMetadata, "Title"))
&& EQUAL( pszValue, "SeaWiFS Level-1A Data" ) )
{
poDS->iSubdatasetType = H4ST_SEAWIFS_L1A;
poDS->pszSubdatasetType = "SEAWIFS_L1A";
}
else if ( (pszValue = CSLFetchNameValue(poDS->papszGlobalMetadata, "Title"))
&& EQUAL( pszValue, "SeaWiFS Level-2 Data" ) )
{
poDS->iSubdatasetType = H4ST_SEAWIFS_L2;
poDS->pszSubdatasetType = "SEAWIFS_L2";
}
else if ( (pszValue = CSLFetchNameValue(poDS->papszGlobalMetadata, "Title"))
&& EQUAL( pszValue, "SeaWiFS Level-3 Standard Mapped Image" ) )
{
poDS->iSubdatasetType = H4ST_SEAWIFS_L3;
poDS->pszSubdatasetType = "SEAWIFS_L3";
}
else if ( (pszValue = CSLFetchNameValue(poDS->papszGlobalMetadata,
"L1 File Generated By"))
&& EQUALN( pszValue, "HYP version ", 12 ) )
{
poDS->iSubdatasetType = H4ST_HYPERION_L1;
poDS->pszSubdatasetType = "HYPERION_L1";
}
else
{
poDS->iSubdatasetType = H4ST_UNKNOWN;
poDS->pszSubdatasetType = "UNKNOWN";
}
/* -------------------------------------------------------------------- */
/* If we have HDF-EOS dataset, process it here. */
/* -------------------------------------------------------------------- */
char szName[VSNAMELENMAX + 1], szTemp[8192];
char *pszString;
const char *pszName;
int nCount;
int32 aiDimSizes[H4_MAX_VAR_DIMS];
int32 iRank, iNumType, nAttrs;
bool bIsHDF = true;
// Sometimes "HDFEOSVersion" attribute is not defined and we will
// determine HDF-EOS datasets using other records
// (see ReadGlobalAttributes() method).
if ( poDS->bIsHDFEOS
|| CSLFetchNameValue(poDS->papszGlobalMetadata, "HDFEOSVersion") )
{
bIsHDF = false;
int32 nSubDatasets, nStrBufSize;
/* -------------------------------------------------------------------- */
/* Process swath layers. */
/* -------------------------------------------------------------------- */
hHDF4 = SWopen( poOpenInfo->pszFilename, DFACC_READ );
if( hHDF4 < 0)
{
delete poDS;
CPLError( CE_Failure, CPLE_OpenFailed, "Failed to open HDF4 `%s'.\n", poOpenInfo->pszFilename );
return NULL;
}
nSubDatasets = SWinqswath(poOpenInfo->pszFilename, NULL, &nStrBufSize);
#if DEBUG
CPLDebug( "HDF4", "Number of HDF-EOS swaths: %d", (int)nSubDatasets );
#endif
if ( nSubDatasets > 0 && nStrBufSize > 0 )
{
char *pszSwathList;
char **papszSwaths;
pszSwathList = (char *)CPLMalloc( nStrBufSize + 1 );
SWinqswath( poOpenInfo->pszFilename, pszSwathList, &nStrBufSize );
pszSwathList[nStrBufSize] = '\0';
#if DEBUG
CPLDebug( "HDF4", "List of HDF-EOS swaths: %s", pszSwathList );
#endif
papszSwaths =
CSLTokenizeString2( pszSwathList, ",", CSLT_HONOURSTRINGS );
CPLFree( pszSwathList );
if ( nSubDatasets != CSLCount(papszSwaths) )
{
CSLDestroy( papszSwaths );
delete poDS;
CPLDebug( "HDF4", "Can not parse list of HDF-EOS grids." );
return NULL;
}
for ( i = 0; i < nSubDatasets; i++)
{
char *pszFieldList;
char **papszFields;
int32 *paiRank, *paiNumType;
int32 hSW, nFields, j;
hSW = SWattach( hHDF4, papszSwaths[i] );
nFields = SWnentries( hSW, HDFE_NENTDFLD, &nStrBufSize );
pszFieldList = (char *)CPLMalloc( nStrBufSize + 1 );
paiRank = (int32 *)CPLMalloc( nFields * sizeof(int32) );
paiNumType = (int32 *)CPLMalloc( nFields * sizeof(int32) );
SWinqdatafields( hSW, pszFieldList, paiRank, paiNumType );
#if DEBUG
{
char *pszTmp =
SPrintArray( GDT_UInt32, paiRank, nFields, "," );
CPLDebug( "HDF4", "Number of data fields in swath %d: %d",
(int) i, (int) nFields );
CPLDebug( "HDF4", "List of data fields in swath %d: %s",
(int) i, pszFieldList );
CPLDebug( "HDF4", "Data fields ranks: %s", pszTmp );
CPLFree( pszTmp );
}
#endif
papszFields = CSLTokenizeString2( pszFieldList, ",",
CSLT_HONOURSTRINGS );
for ( j = 0; j < nFields; j++ )
{
SWfieldinfo( hSW, papszFields[j], &iRank, aiDimSizes,
&iNumType, NULL );
if ( iRank < 2 )
continue;
// Add field to the list of GDAL subdatasets
nCount = CSLCount( poDS->papszSubDatasets ) / 2;
sprintf( szTemp, "SUBDATASET_%d_NAME", nCount + 1 );
// We will use the field index as an identificator.
poDS->papszSubDatasets =
CSLSetNameValue( poDS->papszSubDatasets, szTemp,
CPLSPrintf("HDF4_EOS:EOS_SWATH:\"%s\":%s:%s",
poOpenInfo->pszFilename,
papszSwaths[i], papszFields[j]) );
sprintf( szTemp, "SUBDATASET_%d_DESC", nCount + 1 );
pszString = SPrintArray( GDT_UInt32, aiDimSizes,
iRank, "x" );
poDS->papszSubDatasets =
CSLSetNameValue( poDS->papszSubDatasets, szTemp,
CPLSPrintf( "[%s] %s %s (%s)", pszString,
papszFields[j],
papszSwaths[i],
poDS->GetDataTypeName(iNumType) ) );
CPLFree( pszString );
}
CSLDestroy( papszFields );
CPLFree( paiNumType );
CPLFree( paiRank );
CPLFree( pszFieldList );
SWdetach( hSW );
}
CSLDestroy( papszSwaths );
}
SWclose( hHDF4 );
/* -------------------------------------------------------------------- */
/* Process grid layers. */
/* -------------------------------------------------------------------- */
hHDF4 = GDopen( poOpenInfo->pszFilename, DFACC_READ );
nSubDatasets = GDinqgrid( poOpenInfo->pszFilename, NULL, &nStrBufSize );
#if DEBUG
CPLDebug( "HDF4", "Number of HDF-EOS grids: %d", (int)nSubDatasets );
#endif
if ( nSubDatasets > 0 && nStrBufSize > 0 )
{
char *pszGridList;
char **papszGrids;
pszGridList = (char *)CPLMalloc( nStrBufSize + 1 );
GDinqgrid( poOpenInfo->pszFilename, pszGridList, &nStrBufSize );
#if DEBUG
CPLDebug( "HDF4", "List of HDF-EOS grids: %s", pszGridList );
#endif
papszGrids =
CSLTokenizeString2( pszGridList, ",", CSLT_HONOURSTRINGS );
CPLFree( pszGridList );
if ( nSubDatasets != CSLCount(papszGrids) )
{
CSLDestroy( papszGrids );
delete poDS;
CPLDebug( "HDF4", "Can not parse list of HDF-EOS grids." );
return NULL;
}
for ( i = 0; i < nSubDatasets; i++)
{
char *pszFieldList;
char **papszFields;
int32 *paiRank, *paiNumType;
int32 hGD, nFields, j;
hGD = GDattach( hHDF4, papszGrids[i] );
nFields = GDnentries( hGD, HDFE_NENTDFLD, &nStrBufSize );
pszFieldList = (char *)CPLMalloc( nStrBufSize + 1 );
paiRank = (int32 *)CPLMalloc( nFields * sizeof(int32) );
paiNumType = (int32 *)CPLMalloc( nFields * sizeof(int32) );
GDinqfields( hGD, pszFieldList, paiRank, paiNumType );
#if DEBUG
{
char* pszTmp =
SPrintArray( GDT_UInt32, paiRank, nFields, "," );
CPLDebug( "HDF4", "Number of fields in grid %d: %d",
(int) i, (int) nFields );
CPLDebug( "HDF4", "List of fields in grid %d: %s",
(int) i, pszFieldList );
CPLDebug( "HDF4", "Fields ranks: %s",
pszTmp );
CPLFree( pszTmp );
}
#endif
papszFields = CSLTokenizeString2( pszFieldList, ",",
CSLT_HONOURSTRINGS );
for ( j = 0; j < nFields; j++ )
{
GDfieldinfo( hGD, papszFields[j], &iRank, aiDimSizes,
&iNumType, NULL );
if ( iRank < 2 )
continue;
// Add field to the list of GDAL subdatasets
nCount = CSLCount( poDS->papszSubDatasets ) / 2;
sprintf( szTemp, "SUBDATASET_%d_NAME", nCount + 1 );
// We will use the field index as an identificator.
poDS->papszSubDatasets =
CSLSetNameValue(poDS->papszSubDatasets, szTemp,
CPLSPrintf( "HDF4_EOS:EOS_GRID:\"%s\":%s:%s",
poOpenInfo->pszFilename,
papszGrids[i], papszFields[j]));
sprintf( szTemp, "SUBDATASET_%d_DESC", nCount + 1 );
pszString = SPrintArray( GDT_UInt32, aiDimSizes,
iRank, "x" );
poDS->papszSubDatasets =
CSLSetNameValue( poDS->papszSubDatasets, szTemp,
CPLSPrintf("[%s] %s %s (%s)", pszString,
papszFields[j],
papszGrids[i],
poDS->GetDataTypeName(iNumType)) );
CPLFree( pszString );
}
CSLDestroy( papszFields );
CPLFree( paiNumType );
CPLFree( paiRank );
CPLFree( pszFieldList );
GDdetach( hGD );
}
CSLDestroy( papszGrids );
GDclose( hHDF4 );
}
GDclose( hHDF4 );
bIsHDF = ( nSubDatasets == 0 ); // Try to read as HDF
}
if( bIsHDF )
{
/* -------------------------------------------------------------------- */
/* Make a list of subdatasets from SDSs contained in input HDF file. */
/* -------------------------------------------------------------------- */
int32 nDatasets;
if ( SDfileinfo( poDS->hSD, &nDatasets, &nAttrs ) != 0 )
return NULL;
for ( i = 0; i < nDatasets; i++ )
{
int32 iSDS;
iSDS = SDselect( poDS->hSD, i );
if ( SDgetinfo( iSDS, szName, &iRank, aiDimSizes, &iNumType, &nAttrs) != 0 )
return NULL;
if ( iRank == 1 ) // Skip 1D datsets
continue;
// Do sort of known datasets. We will display only image bands
if ( (poDS->iSubdatasetType == H4ST_SEAWIFS_L1A ) &&
!EQUALN( szName, "l1a_data", 8 ) )
continue;
else
pszName = szName;
// Add datasets with multiple dimensions to the list of GDAL subdatasets
nCount = CSLCount( poDS->papszSubDatasets ) / 2;
sprintf( szTemp, "SUBDATASET_%d_NAME", nCount + 1 );
// We will use SDS index as an identificator, because SDS names
// are not unique. Filename also needed for further file opening
poDS->papszSubDatasets = CSLSetNameValue(poDS->papszSubDatasets, szTemp,
CPLSPrintf( "HDF4_SDS:%s:\"%s\":%ld", poDS->pszSubdatasetType,
poOpenInfo->pszFilename, (long)i) );
sprintf( szTemp, "SUBDATASET_%d_DESC", nCount + 1 );
pszString = SPrintArray( GDT_UInt32, aiDimSizes, iRank, "x" );
poDS->papszSubDatasets = CSLSetNameValue(poDS->papszSubDatasets, szTemp,
CPLSPrintf( "[%s] %s (%s)", pszString,
pszName, poDS->GetDataTypeName(iNumType)) );
CPLFree( pszString );
SDendaccess( iSDS );
}
SDend( poDS->hSD );
poDS->hSD = 0;
}
/* -------------------------------------------------------------------- */
/* Build a list of raster images. Note, that HDF-EOS dataset may */
/* contain a raster image as well. */
/* -------------------------------------------------------------------- */
hHDF4 = Hopen(poOpenInfo->pszFilename, DFACC_READ, 0);
poDS->hGR = GRstart( hHDF4 );
if ( poDS->hGR != -1 )
{
if ( GRfileinfo( poDS->hGR, &poDS->nImages, &nAttrs ) == -1 )
return NULL;
for ( i = 0; i < poDS->nImages; i++ )
{
int32 iInterlaceMode;
int32 iGR = GRselect( poDS->hGR, i );
// iRank in GR interface has another meaning. It represents number
// of samples per pixel. aiDimSizes has only two dimensions.
if ( GRgetiminfo( iGR, szName, &iRank, &iNumType, &iInterlaceMode,
aiDimSizes, &nAttrs ) != 0 )
return NULL;
nCount = CSLCount( poDS->papszSubDatasets ) / 2;
sprintf( szTemp, "SUBDATASET_%d_NAME", nCount + 1 );
poDS->papszSubDatasets = CSLSetNameValue(poDS->papszSubDatasets,
szTemp,CPLSPrintf( "HDF4_GR:UNKNOWN:\"%s\":%ld",
poOpenInfo->pszFilename, (long)i));
sprintf( szTemp, "SUBDATASET_%d_DESC", nCount + 1 );
pszString = SPrintArray( GDT_UInt32, aiDimSizes, 2, "x" );
poDS->papszSubDatasets = CSLSetNameValue(poDS->papszSubDatasets,
szTemp, CPLSPrintf( "[%sx%ld] %s (%s)", pszString, (long)iRank,
szName, poDS->GetDataTypeName(iNumType)) );
CPLFree( pszString );
GRendaccess( iGR );
}
GRend( poDS->hGR );
poDS->hGR = 0;
}
Hclose( hHDF4 );
poDS->nRasterXSize = poDS->nRasterYSize = 512; // XXX: bogus values
// Make sure we don't try to do any pam stuff with this dataset.
poDS->nPamFlags |= GPF_NOSAVE;
/* -------------------------------------------------------------------- */
/* If we have single subdataset only, open it immediately */
/* -------------------------------------------------------------------- */
if ( CSLCount( poDS->papszSubDatasets ) / 2 == 1 )
{
char *pszSDSName;
pszSDSName = CPLStrdup( CSLFetchNameValue( poDS->papszSubDatasets,
"SUBDATASET_1_NAME" ));
delete poDS;
poDS = NULL;
GDALDataset* poRetDS = (GDALDataset*) GDALOpen( pszSDSName, poOpenInfo->eAccess );
CPLFree( pszSDSName );
if (poRetDS)
{
poRetDS->SetDescription(poOpenInfo->pszFilename);
}
return poRetDS;
}
else
{
/* -------------------------------------------------------------------- */
/* Confirm the requested access is supported. */
/* -------------------------------------------------------------------- */
if( poOpenInfo->eAccess == GA_Update )
{
delete poDS;
CPLError( CE_Failure, CPLE_NotSupported,
"The HDF4 driver does not support update access to existing"
" datasets.\n" );
return NULL;
}
}
return( poDS );
}
CPLErr EXIFExtractMetadata(char**& papszMetadata,
void *fpInL, int nOffset,
int bSwabflag, int nTIFFHEADER,
int& nExifOffset, int& nInterOffset, int& nGPSOffset)
{
GUInt16 nEntryCount;
int space;
unsigned int n,i;
char pszTemp[MAXSTRINGLENGTH];
char pszName[128];
VSILFILE* fp = (VSILFILE* )fpInL;
TIFFDirEntry *poTIFFDirEntry;
TIFFDirEntry *poTIFFDir;
const struct tagname *poExifTags ;
const struct intr_tag *poInterTags = intr_tags;
const struct gpsname *poGPSTags;
/* -------------------------------------------------------------------- */
/* Read number of entry in directory */
/* -------------------------------------------------------------------- */
if( VSIFSeekL(fp, nOffset+nTIFFHEADER, SEEK_SET) != 0
|| VSIFReadL(&nEntryCount,1,sizeof(GUInt16),fp) != sizeof(GUInt16) )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Error reading EXIF Directory count at %d.",
nOffset + nTIFFHEADER );
return CE_Failure;
}
if (bSwabflag)
TIFFSwabShort(&nEntryCount);
// Some apps write empty directories - see bug 1523.
if( nEntryCount == 0 )
return CE_None;
// Some files are corrupt, a large entry count is a sign of this.
if( nEntryCount > 125 )
{
CPLError( CE_Warning, CPLE_AppDefined,
"Ignoring EXIF directory with unlikely entry count (%d).",
nEntryCount );
return CE_Warning;
}
poTIFFDir = (TIFFDirEntry *)CPLMalloc(nEntryCount * sizeof(TIFFDirEntry));
/* -------------------------------------------------------------------- */
/* Read all directory entries */
/* -------------------------------------------------------------------- */
n = VSIFReadL(poTIFFDir, 1,nEntryCount*sizeof(TIFFDirEntry),fp);
if (n != nEntryCount*sizeof(TIFFDirEntry))
{
CPLError( CE_Failure, CPLE_AppDefined,
"Could not read all directories");
CPLFree(poTIFFDir);
return CE_Failure;
}
/* -------------------------------------------------------------------- */
/* Parse all entry information in this directory */
/* -------------------------------------------------------------------- */
for(poTIFFDirEntry = poTIFFDir,i=nEntryCount; i > 0; i--,poTIFFDirEntry++) {
if (bSwabflag) {
TIFFSwabShort(&poTIFFDirEntry->tdir_tag);
TIFFSwabShort(&poTIFFDirEntry->tdir_type);
TIFFSwabLong (&poTIFFDirEntry->tdir_count);
TIFFSwabLong (&poTIFFDirEntry->tdir_offset);
}
/* -------------------------------------------------------------------- */
/* Find Tag name in table */
/* -------------------------------------------------------------------- */
pszName[0] = '\0';
pszTemp[0] = '\0';
for (poExifTags = tagnames; poExifTags->tag; poExifTags++)
if(poExifTags->tag == poTIFFDirEntry->tdir_tag) {
CPLAssert( NULL != poExifTags && NULL != poExifTags->name );
strcpy(pszName, poExifTags->name);
break;
}
if( nOffset == nGPSOffset) {
for( poGPSTags = gpstags; poGPSTags->tag != 0xffff; poGPSTags++ )
if( poGPSTags->tag == poTIFFDirEntry->tdir_tag ) {
CPLAssert( NULL != poGPSTags && NULL != poGPSTags->name );
strcpy(pszName, poGPSTags->name);
break;
}
}
/* -------------------------------------------------------------------- */
/* If the tag was not found, look into the interoperability table */
/* -------------------------------------------------------------------- */
if( nOffset == nInterOffset ) {
for(poInterTags = intr_tags; poInterTags->tag; poInterTags++)
if(poInterTags->tag == poTIFFDirEntry->tdir_tag) {
CPLAssert( NULL != poInterTags && NULL != poInterTags->name );
strcpy(pszName, poInterTags->name);
break;
}
}
/* -------------------------------------------------------------------- */
/* Save important directory tag offset */
/* -------------------------------------------------------------------- */
if( poTIFFDirEntry->tdir_tag == EXIFOFFSETTAG )
nExifOffset=poTIFFDirEntry->tdir_offset;
if( poTIFFDirEntry->tdir_tag == INTEROPERABILITYOFFSET )
nInterOffset=poTIFFDirEntry->tdir_offset;
if( poTIFFDirEntry->tdir_tag == GPSOFFSETTAG ) {
nGPSOffset=poTIFFDirEntry->tdir_offset;
}
/* -------------------------------------------------------------------- */
/* If we didn't recognise the tag just ignore it. To see all */
/* tags comment out the continue. */
/* -------------------------------------------------------------------- */
if( pszName[0] == '\0' )
{
sprintf( pszName, "EXIF_%d", poTIFFDirEntry->tdir_tag );
continue;
}
/* -------------------------------------------------------------------- */
/* For UserComment we need to ignore the language binding and */
/* just return the actual contents. */
/* -------------------------------------------------------------------- */
if( EQUAL(pszName,"EXIF_UserComment") )
{
poTIFFDirEntry->tdir_type = TIFF_ASCII;
if( poTIFFDirEntry->tdir_count >= 8 )
{
poTIFFDirEntry->tdir_count -= 8;
poTIFFDirEntry->tdir_offset += 8;
}
}
/* -------------------------------------------------------------------- */
/* Make some UNDEFINED or BYTE fields ASCII for readability. */
/* -------------------------------------------------------------------- */
if( EQUAL(pszName,"EXIF_ExifVersion")
|| EQUAL(pszName,"EXIF_FlashPixVersion")
|| EQUAL(pszName,"EXIF_MakerNote")
|| EQUAL(pszName,"GPSProcessingMethod") )
poTIFFDirEntry->tdir_type = TIFF_ASCII;
/* -------------------------------------------------------------------- */
/* Print tags */
/* -------------------------------------------------------------------- */
int nDataWidth = TIFFDataWidth((TIFFDataType) poTIFFDirEntry->tdir_type);
space = poTIFFDirEntry->tdir_count * nDataWidth;
/* Previous multiplication could overflow, hence this additional check */
if (poTIFFDirEntry->tdir_count > MAXSTRINGLENGTH)
{
CPLError( CE_Warning, CPLE_AppDefined,
"Too many bytes in tag: %u, ignoring tag.",
poTIFFDirEntry->tdir_count );
}
else if (nDataWidth == 0 || poTIFFDirEntry->tdir_type >= TIFF_IFD )
{
CPLError( CE_Warning, CPLE_AppDefined,
"Invalid or unhandled EXIF data type: %d, ignoring tag.",
poTIFFDirEntry->tdir_type );
}
/* -------------------------------------------------------------------- */
/* This is at most 4 byte data so we can read it from tdir_offset */
/* -------------------------------------------------------------------- */
else if (space >= 0 && space <= 4) {
unsigned char data[4];
memcpy(data, &poTIFFDirEntry->tdir_offset, 4);
if (bSwabflag)
{
// Unswab 32bit value, and reswab per data type.
TIFFSwabLong((GUInt32*) data);
switch (poTIFFDirEntry->tdir_type) {
case TIFF_LONG:
case TIFF_SLONG:
case TIFF_FLOAT:
TIFFSwabLong((GUInt32*) data);
break;
case TIFF_SSHORT:
case TIFF_SHORT:
TIFFSwabArrayOfShort((GUInt16*) data,
poTIFFDirEntry->tdir_count);
break;
default:
break;
}
}
EXIFPrintData(pszTemp,
poTIFFDirEntry->tdir_type,
poTIFFDirEntry->tdir_count, data);
}
/* -------------------------------------------------------------------- */
/* The data is being read where tdir_offset point to in the file */
/* -------------------------------------------------------------------- */
else if (space > 0 && space < MAXSTRINGLENGTH)
{
unsigned char *data = (unsigned char *)VSIMalloc(space);
if (data) {
VSIFSeekL(fp,poTIFFDirEntry->tdir_offset+nTIFFHEADER,SEEK_SET);
VSIFReadL(data, 1, space, fp);
if (bSwabflag) {
switch (poTIFFDirEntry->tdir_type) {
case TIFF_SHORT:
case TIFF_SSHORT:
TIFFSwabArrayOfShort((GUInt16*) data,
poTIFFDirEntry->tdir_count);
break;
case TIFF_LONG:
case TIFF_SLONG:
case TIFF_FLOAT:
TIFFSwabArrayOfLong((GUInt32*) data,
poTIFFDirEntry->tdir_count);
break;
case TIFF_RATIONAL:
case TIFF_SRATIONAL:
TIFFSwabArrayOfLong((GUInt32*) data,
2*poTIFFDirEntry->tdir_count);
break;
case TIFF_DOUBLE:
TIFFSwabArrayOfDouble((double*) data,
poTIFFDirEntry->tdir_count);
break;
default:
break;
}
}
EXIFPrintData(pszTemp, poTIFFDirEntry->tdir_type,
poTIFFDirEntry->tdir_count, data);
CPLFree(data);
}
}
else
{
CPLError( CE_Warning, CPLE_AppDefined,
"Invalid EXIF header size: %ld, ignoring tag.",
(long) space );
}
papszMetadata = CSLSetNameValue(papszMetadata, pszName, pszTemp);
}
CPLFree(poTIFFDir);
return CE_None;
}
static int GDAL_IMD_AA2R( char ***ppapszIMD )
{
char **papszIMD = *ppapszIMD;
/* -------------------------------------------------------------------- */
/* Verify that we have a new format file. */
/* -------------------------------------------------------------------- */
const char *pszValue = CSLFetchNameValue( papszIMD, "version" );
if( pszValue == NULL )
return FALSE;
if( EQUAL(pszValue,"\"R\"") )
return TRUE;
if( !EQUAL(pszValue,"\"AA\"") )
{
CPLDebug( "IMD", "The file is not the expected 'version = \"AA\"' format.\nProceeding, but file may be corrupted." );
}
/* -------------------------------------------------------------------- */
/* Fix the version line. */
/* -------------------------------------------------------------------- */
papszIMD = CSLSetNameValue( papszIMD, "version", "\"R\"" );
/* -------------------------------------------------------------------- */
/* remove a bunch of fields. */
/* -------------------------------------------------------------------- */
int iKey;
static const char *apszToRemove[] = {
"productCatalogId",
"childCatalogId",
"productType",
"numberOfLooks",
"effectiveBandwidth",
"mode",
"scanDirection",
"cloudCover",
"productGSD",
NULL };
for( iKey = 0; apszToRemove[iKey] != NULL; iKey++ )
{
int iTarget = CSLFindName( papszIMD, apszToRemove[iKey] );
if( iTarget != -1 )
papszIMD = CSLRemoveStrings( papszIMD, iTarget, 1, NULL );
}
/* -------------------------------------------------------------------- */
/* Replace various min/mean/max with just the mean. */
/* -------------------------------------------------------------------- */
static const char *keylist[] = {
"CollectedRowGSD",
"CollectedColGSD",
"SunAz",
"SunEl",
"SatAz",
"SatEl",
"InTrackViewAngle",
"CrossTrackViewAngle",
"OffNadirViewAngle",
NULL };
for( iKey = 0; keylist[iKey] != NULL; iKey++ )
{
CPLString osTarget;
int iTarget;
osTarget.Printf( "IMAGE_1.min%s", keylist[iKey] );
iTarget = CSLFindName( papszIMD, osTarget );
if( iTarget != -1 )
papszIMD = CSLRemoveStrings( papszIMD, iTarget, 1, NULL );
osTarget.Printf( "IMAGE_1.max%s", keylist[iKey] );
iTarget = CSLFindName( papszIMD, osTarget );
if( iTarget != -1 )
papszIMD = CSLRemoveStrings( papszIMD, iTarget, 1, NULL );
osTarget.Printf( "IMAGE_1.mean%s", keylist[iKey] );
iTarget = CSLFindName( papszIMD, osTarget );
if( iTarget != -1 )
{
CPLString osValue = CSLFetchNameValue( papszIMD, osTarget );
CPLString osLine;
osTarget.Printf( "IMAGE_1.%c%s",
tolower(keylist[iKey][0]),
keylist[iKey]+1 );
osLine = osTarget + "=" + osValue;
CPLFree( papszIMD[iTarget] );
papszIMD[iTarget] = CPLStrdup(osLine);
}
}
*ppapszIMD = papszIMD;
return TRUE;
}
CPLErr RasterliteDataset::CreateOverviewLevel(int nOvrFactor,
GDALProgressFunc pfnProgress,
void * pProgressData)
{
double dfXResolution = padfXResolutions[0] * nOvrFactor;
double dfYResolution = padfXResolutions[0] * nOvrFactor;
CPLString osSQL;
int nBlockXSize = 256;
int nBlockYSize = 256;
int nOvrXSize = nRasterXSize / nOvrFactor;
int nOvrYSize = nRasterYSize / nOvrFactor;
if (nOvrXSize == 0 || nOvrYSize == 0)
return CE_Failure;
int nXBlocks = (nOvrXSize + nBlockXSize - 1) / nBlockXSize;
int nYBlocks = (nOvrYSize + nBlockYSize - 1) / nBlockYSize;
const char* pszDriverName = "GTiff";
GDALDriverH hTileDriver = GDALGetDriverByName(pszDriverName);
if (hTileDriver == NULL)
{
CPLError(CE_Failure, CPLE_AppDefined, "Cannot load GDAL %s driver", pszDriverName);
return CE_Failure;
}
GDALDriverH hMemDriver = GDALGetDriverByName("MEM");
if (hMemDriver == NULL)
{
CPLError(CE_Failure, CPLE_AppDefined, "Cannot load GDAL MEM driver");
return CE_Failure;
}
GDALDataType eDataType = GetRasterBand(1)->GetRasterDataType();
int nDataTypeSize = GDALGetDataTypeSize(eDataType) / 8;
GByte* pabyMEMDSBuffer =
(GByte*)VSIMalloc3(nBlockXSize, nBlockYSize, nBands * nDataTypeSize);
if (pabyMEMDSBuffer == NULL)
{
return CE_Failure;
}
char** papszTileDriverOptions = NULL;
CPLString osTempFileName;
osTempFileName.Printf("/vsimem/%p", hDS);
int nTileId = 0;
int nBlocks = 0;
int nTotalBlocks = nXBlocks * nYBlocks;
CPLString osRasterLayer;
osRasterLayer.Printf("%s_rasters", osTableName.c_str());
CPLString osMetatadataLayer;
osMetatadataLayer.Printf("%s_metadata", osTableName.c_str());
OGRLayerH hRasterLayer = OGR_DS_GetLayerByName(hDS, osRasterLayer.c_str());
OGRLayerH hMetadataLayer = OGR_DS_GetLayerByName(hDS, osMetatadataLayer.c_str());
CPLString osSourceName = "unknown";
osSQL.Printf("SELECT source_name FROM \"%s\" WHERE "
"pixel_x_size >= %.15f AND pixel_x_size <= %.15f AND "
"pixel_y_size >= %.15f AND pixel_y_size <= %.15f LIMIT 1",
osMetatadataLayer.c_str(),
padfXResolutions[0] - 1e-15, padfXResolutions[0] + 1e-15,
padfYResolutions[0] - 1e-15, padfYResolutions[0] + 1e-15);
OGRLayerH hSQLLyr = OGR_DS_ExecuteSQL(hDS, osSQL.c_str(), NULL, NULL);
if (hSQLLyr)
{
OGRFeatureH hFeat = OGR_L_GetNextFeature(hSQLLyr);
if (hFeat)
{
const char* pszVal = OGR_F_GetFieldAsString(hFeat, 0);
if (pszVal)
osSourceName = pszVal;
OGR_F_Destroy(hFeat);
}
OGR_DS_ReleaseResultSet(hDS, hSQLLyr);
}
/* -------------------------------------------------------------------- */
/* Compute up to which existing overview level we can use for */
/* computing the requested overview */
/* -------------------------------------------------------------------- */
int iLev;
nLimitOvrCount = 0;
for(iLev=1;iLev<nResolutions;iLev++)
{
if (!(padfXResolutions[iLev] < dfXResolution - 1e-10 &&
padfYResolutions[iLev] < dfYResolution - 1e-10))
{
break;
}
nLimitOvrCount++;
}
/* -------------------------------------------------------------------- */
/* Iterate over blocks to add data into raster and metadata tables */
/* -------------------------------------------------------------------- */
OGR_DS_ExecuteSQL(hDS, "BEGIN", NULL, NULL);
CPLErr eErr = CE_None;
int nBlockXOff, nBlockYOff;
for(nBlockYOff=0;eErr == CE_None && nBlockYOff<nYBlocks;nBlockYOff++)
{
for(nBlockXOff=0;eErr == CE_None && nBlockXOff<nXBlocks;nBlockXOff++)
{
/* -------------------------------------------------------------------- */
/* Create in-memory tile */
/* -------------------------------------------------------------------- */
int nReqXSize = nBlockXSize, nReqYSize = nBlockYSize;
if ((nBlockXOff+1) * nBlockXSize > nOvrXSize)
nReqXSize = nOvrXSize - nBlockXOff * nBlockXSize;
if ((nBlockYOff+1) * nBlockYSize > nOvrYSize)
nReqYSize = nOvrYSize - nBlockYOff * nBlockYSize;
eErr = RasterIO(GF_Read,
nBlockXOff * nBlockXSize * nOvrFactor,
nBlockYOff * nBlockYSize * nOvrFactor,
nReqXSize * nOvrFactor, nReqYSize * nOvrFactor,
pabyMEMDSBuffer, nReqXSize, nReqYSize,
eDataType, nBands, NULL,
0, 0, 0);
if (eErr != CE_None)
{
break;
}
GDALDatasetH hMemDS = GDALCreate(hMemDriver, "MEM:::",
nReqXSize, nReqYSize, 0,
eDataType, NULL);
if (hMemDS == NULL)
{
eErr = CE_Failure;
break;
}
int iBand;
for(iBand = 0; iBand < nBands; iBand ++)
{
char** papszOptions = NULL;
char szTmp[64];
memset(szTmp, 0, sizeof(szTmp));
CPLPrintPointer(szTmp,
pabyMEMDSBuffer + iBand * nDataTypeSize *
nReqXSize * nReqYSize, sizeof(szTmp));
papszOptions = CSLSetNameValue(papszOptions, "DATAPOINTER", szTmp);
GDALAddBand(hMemDS, eDataType, papszOptions);
CSLDestroy(papszOptions);
}
GDALDatasetH hOutDS = GDALCreateCopy(hTileDriver,
osTempFileName.c_str(), hMemDS, FALSE,
papszTileDriverOptions, NULL, NULL);
GDALClose(hMemDS);
if (hOutDS)
GDALClose(hOutDS);
else
{
eErr = CE_Failure;
break;
}
/* -------------------------------------------------------------------- */
/* Insert new entry into raster table */
/* -------------------------------------------------------------------- */
vsi_l_offset nDataLength;
GByte *pabyData = VSIGetMemFileBuffer( osTempFileName.c_str(),
&nDataLength, FALSE);
OGRFeatureH hFeat = OGR_F_Create( OGR_L_GetLayerDefn(hRasterLayer) );
OGR_F_SetFieldBinary(hFeat, 0, (int)nDataLength, pabyData);
OGR_L_CreateFeature(hRasterLayer, hFeat);
/* Query raster ID to set it as the ID of the associated metadata */
int nRasterID = (int)OGR_F_GetFID(hFeat);
OGR_F_Destroy(hFeat);
VSIUnlink(osTempFileName.c_str());
/* -------------------------------------------------------------------- */
/* Insert new entry into metadata table */
/* -------------------------------------------------------------------- */
hFeat = OGR_F_Create( OGR_L_GetLayerDefn(hMetadataLayer) );
OGR_F_SetFID(hFeat, nRasterID);
OGR_F_SetFieldString(hFeat, 0, osSourceName);
OGR_F_SetFieldInteger(hFeat, 1, nTileId ++);
OGR_F_SetFieldInteger(hFeat, 2, nReqXSize);
OGR_F_SetFieldInteger(hFeat, 3, nReqYSize);
OGR_F_SetFieldDouble(hFeat, 4, dfXResolution);
OGR_F_SetFieldDouble(hFeat, 5, dfYResolution);
double minx, maxx, maxy, miny;
minx = adfGeoTransform[0] +
(nBlockXSize * nBlockXOff) * dfXResolution;
maxx = adfGeoTransform[0] +
(nBlockXSize * nBlockXOff + nReqXSize) * dfXResolution;
maxy = adfGeoTransform[3] +
(nBlockYSize * nBlockYOff) * (-dfYResolution);
miny = adfGeoTransform[3] +
(nBlockYSize * nBlockYOff + nReqYSize) * (-dfYResolution);
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);
OGR_L_CreateFeature(hMetadataLayer, hFeat);
OGR_F_Destroy(hFeat);
nBlocks++;
if (pfnProgress && !pfnProgress(1.0 * nBlocks / nTotalBlocks,
NULL, pProgressData))
eErr = CE_Failure;
}
}
nLimitOvrCount = -1;
if (eErr == CE_None)
OGR_DS_ExecuteSQL(hDS, "COMMIT", NULL, NULL);
else
OGR_DS_ExecuteSQL(hDS, "ROLLBACK", NULL, NULL);
VSIFree(pabyMEMDSBuffer);
/* -------------------------------------------------------------------- */
/* Update raster_pyramids table */
/* -------------------------------------------------------------------- */
if (eErr == CE_None)
{
OGRLayerH hRasterPyramidsLyr = OGR_DS_GetLayerByName(hDS, "raster_pyramids");
if (hRasterPyramidsLyr == NULL)
{
osSQL.Printf ("CREATE TABLE raster_pyramids ("
"table_prefix TEXT NOT NULL,"
"pixel_x_size DOUBLE NOT NULL,"
"pixel_y_size DOUBLE NOT NULL,"
"tile_count INTEGER NOT NULL)");
OGR_DS_ExecuteSQL(hDS, osSQL.c_str(), NULL, NULL);
/* Re-open the DB to take into account the new tables*/
OGRReleaseDataSource(hDS);
CPLString osOldVal = CPLGetConfigOption("SQLITE_LIST_ALL_TABLES", "FALSE");
CPLSetThreadLocalConfigOption("SQLITE_LIST_ALL_TABLES", "TRUE");
hDS = OGROpen(osFileName.c_str(), TRUE, NULL);
CPLSetThreadLocalConfigOption("SQLITE_LIST_ALL_TABLES", osOldVal.c_str());
}
/* Insert base resolution into raster_pyramids if not already done */
int bHasBaseResolution = FALSE;
osSQL.Printf("SELECT * FROM raster_pyramids WHERE "
"table_prefix = '%s' AND pixel_x_size >= %.15f AND pixel_x_size <= %.15f AND "
"pixel_y_size >= %.15f AND pixel_y_size <= %.15f",
osTableName.c_str(),
padfXResolutions[0] - 1e-15, padfXResolutions[0] + 1e-15,
padfYResolutions[0] - 1e-15, padfYResolutions[0] + 1e-15);
hSQLLyr = OGR_DS_ExecuteSQL(hDS, osSQL.c_str(), NULL, NULL);
if (hSQLLyr)
{
OGRFeatureH hFeat = OGR_L_GetNextFeature(hSQLLyr);
if (hFeat)
{
bHasBaseResolution = TRUE;
OGR_F_Destroy(hFeat);
}
OGR_DS_ReleaseResultSet(hDS, hSQLLyr);
}
if (!bHasBaseResolution)
{
osSQL.Printf("SELECT COUNT(*) FROM \"%s\" WHERE "
"pixel_x_size >= %.15f AND pixel_x_size <= %.15f AND "
"pixel_y_size >= %.15f AND pixel_y_size <= %.15f",
osMetatadataLayer.c_str(),
padfXResolutions[0] - 1e-15, padfXResolutions[0] + 1e-15,
padfYResolutions[0] - 1e-15, padfYResolutions[0] + 1e-15);
int nBlocksMainRes = 0;
hSQLLyr = OGR_DS_ExecuteSQL(hDS, osSQL.c_str(), NULL, NULL);
if (hSQLLyr)
{
OGRFeatureH hFeat = OGR_L_GetNextFeature(hSQLLyr);
if (hFeat)
{
nBlocksMainRes = OGR_F_GetFieldAsInteger(hFeat, 0);
OGR_F_Destroy(hFeat);
}
OGR_DS_ReleaseResultSet(hDS, hSQLLyr);
}
osSQL.Printf("INSERT INTO raster_pyramids "
"( table_prefix, pixel_x_size, pixel_y_size, tile_count ) "
"VALUES ( '%s', %.18f, %.18f, %d )",
osTableName.c_str(), padfXResolutions[0], padfYResolutions[0],
nBlocksMainRes);
OGR_DS_ExecuteSQL(hDS, osSQL.c_str(), NULL, NULL);
}
osSQL.Printf("INSERT INTO raster_pyramids "
"( table_prefix, pixel_x_size, pixel_y_size, tile_count ) "
"VALUES ( '%s', %.18f, %.18f, %d )",
osTableName.c_str(), dfXResolution, dfYResolution,
nTotalBlocks);
OGR_DS_ExecuteSQL(hDS, osSQL.c_str(), NULL, NULL);
}
return eErr;
}
int main( int nArgc, char ** papszArgv )
{
char **papszOptions = NULL;
int bReturnPrimitives = FALSE;
char *pszDataPath = NULL;
if( nArgc < 2 )
{
printf( "Usage: s57dump [-pen] [-split] [-lnam] [-return-prim] [-no-update]\n"
" [-return-link] [-data <dirpath>] filename\n" );
exit( 1 );
}
/* -------------------------------------------------------------------- */
/* Process commandline arguments. */
/* -------------------------------------------------------------------- */
for( int iArg = 1; iArg < nArgc-1; iArg++ )
{
if( EQUAL(papszArgv[iArg],"-split") )
papszOptions =
CSLSetNameValue( papszOptions, S57O_SPLIT_MULTIPOINT, "ON" );
else if( EQUAL(papszArgv[iArg],"-data") )
pszDataPath = papszArgv[++iArg];
else if( EQUAL(papszArgv[iArg],"-no-update") )
papszOptions =
CSLSetNameValue( papszOptions, S57O_UPDATES, "OFF" );
else if( EQUAL(papszArgv[iArg],"-pen") )
papszOptions =
CSLSetNameValue( papszOptions, S57O_PRESERVE_EMPTY_NUMBERS,
"ON" );
else if( EQUALN(papszArgv[iArg],"-return-prim",12) )
{
papszOptions =
CSLSetNameValue( papszOptions, S57O_RETURN_PRIMITIVES,
"ON" );
bReturnPrimitives = TRUE;
}
else if( EQUALN(papszArgv[iArg],"-lnam",4) )
papszOptions =
CSLSetNameValue( papszOptions, S57O_LNAM_REFS, "ON" );
else if( EQUALN(papszArgv[iArg],"-return-link",12) )
papszOptions =
CSLSetNameValue( papszOptions, S57O_RETURN_LINKAGES, "ON" );
}
/* -------------------------------------------------------------------- */
/* Load the class definitions into the registrar. */
/* -------------------------------------------------------------------- */
S57ClassRegistrar oRegistrar;
int bRegistrarLoaded;
bRegistrarLoaded = oRegistrar.LoadInfo( pszDataPath, NULL, TRUE );
S57ClassContentExplorer *poClassContentExplorer = NULL;
if (bRegistrarLoaded)
poClassContentExplorer = new S57ClassContentExplorer(&oRegistrar);
/* -------------------------------------------------------------------- */
/* Get a list of candidate files. */
/* -------------------------------------------------------------------- */
char **papszFiles;
int iFile;
papszFiles = S57FileCollector( papszArgv[nArgc-1] );
for( iFile = 0; papszFiles != NULL && papszFiles[iFile] != NULL; iFile++ )
{
printf( "Found: %s\n", papszFiles[iFile] );
}
for( iFile = 0; papszFiles != NULL && papszFiles[iFile] != NULL; iFile++ )
{
printf( "<------------------------------------------------------------------------->\n" );
printf( "\nFile: %s\n\n", papszFiles[iFile] );
S57Reader oReader( papszFiles[iFile] );
oReader.SetOptions( papszOptions );
int nOptionFlags = oReader.GetOptionFlags();
if( !oReader.Open( FALSE ) )
continue;
if( bRegistrarLoaded )
{
int bGeneric = FALSE;
std::vector<int> anClassList;
unsigned int i;
oReader.CollectClassList(anClassList);
oReader.SetClassBased( &oRegistrar, poClassContentExplorer );
printf( "Classes found:\n" );
for( i = 0; i < anClassList.size(); i++ )
{
if( anClassList[i] == 0 )
continue;
if( poClassContentExplorer->SelectClass( i ) )
{
printf( "%d: %s/%s\n",
i,
poClassContentExplorer->GetAcronym(),
poClassContentExplorer->GetDescription() );
oReader.AddFeatureDefn(
S57GenerateObjectClassDefn( &oRegistrar,
poClassContentExplorer,
i, nOptionFlags ) );
}
else
{
printf( "%d: unrecognised ... treat as generic.\n", i );
bGeneric = TRUE;
}
}
if( bGeneric )
{
oReader.AddFeatureDefn(
S57GenerateGeomFeatureDefn( wkbUnknown, nOptionFlags ) );
}
}
else
{
oReader.AddFeatureDefn(
S57GenerateGeomFeatureDefn( wkbPoint, nOptionFlags ) );
oReader.AddFeatureDefn(
S57GenerateGeomFeatureDefn( wkbLineString, nOptionFlags ) );
oReader.AddFeatureDefn(
S57GenerateGeomFeatureDefn( wkbPolygon, nOptionFlags ) );
oReader.AddFeatureDefn(
S57GenerateGeomFeatureDefn( wkbNone, nOptionFlags ) );
}
if( bReturnPrimitives )
{
oReader.AddFeatureDefn(
S57GenerateVectorPrimitiveFeatureDefn( RCNM_VI, nOptionFlags));
oReader.AddFeatureDefn(
S57GenerateVectorPrimitiveFeatureDefn( RCNM_VC, nOptionFlags));
oReader.AddFeatureDefn(
S57GenerateVectorPrimitiveFeatureDefn( RCNM_VE, nOptionFlags));
oReader.AddFeatureDefn(
S57GenerateVectorPrimitiveFeatureDefn( RCNM_VF, nOptionFlags));
}
oReader.AddFeatureDefn( S57GenerateDSIDFeatureDefn() );
OGRFeature *poFeature;
int nFeatures = 0;
DDFModule oUpdate;
while( (poFeature = oReader.ReadNextFeature()) != NULL )
{
poFeature->DumpReadable( stdout );
nFeatures++;
delete poFeature;
}
printf( "Feature Count: %d\n", nFeatures );
}
return 0;
}
int main( int nArgc, char ** papszArgv )
{
// register drivers
GDALAllRegister();
if( nArgc < 2 )
return EXIT_FAILURE;
double dfaCornersX[5] = {0};
double dfaCornersY[5] = {0};
CPLString sFileName;
// parse input values
for( int iArg = 1; iArg < nArgc; iArg++ )
{
if( EQUAL(papszArgv[iArg],"-nw"))
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(2);
const char* pszCoord = papszArgv[++iArg];
dfaCornersY[1] = CPLAtofM(pszCoord);
pszCoord = papszArgv[++iArg];
dfaCornersX[1] = CPLAtofM(pszCoord);
}
else if( EQUAL(papszArgv[iArg],"-ne"))
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(2);
const char* pszCoord = papszArgv[++iArg];
dfaCornersY[2] = CPLAtofM(pszCoord);
pszCoord = papszArgv[++iArg];
dfaCornersX[2] = CPLAtofM(pszCoord);
}
else if( EQUAL(papszArgv[iArg],"-se"))
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(2);
const char* pszCoord = papszArgv[++iArg];
dfaCornersY[3] = CPLAtofM(pszCoord);
pszCoord = papszArgv[++iArg];
dfaCornersX[3] = CPLAtofM(pszCoord);
}
else if( EQUAL(papszArgv[iArg],"-sw"))
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(2);
const char* pszCoord = papszArgv[++iArg];
dfaCornersY[4] = CPLAtofM(pszCoord);
pszCoord = papszArgv[++iArg];
dfaCornersX[4] = CPLAtofM(pszCoord);
}
else if( EQUAL(papszArgv[iArg],"-c"))
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(2);
const char* pszCoord = papszArgv[++iArg];
dfaCornersY[0] = CPLAtofM(pszCoord);
pszCoord = papszArgv[++iArg];
dfaCornersX[0] = CPLAtofM(pszCoord);
}
else if(sFileName.empty())
sFileName = papszArgv[iArg];
}
OGRSpatialReference oOGRSpatialReference(SRS_WKT_WGS84);
int nZoneNo = ceil( (180.0 + dfaCornersX[0]) / 6.0 );
OGRSpatialReference oDstSpatialReference(SRS_WKT_WGS84);
oDstSpatialReference.SetUTM(nZoneNo, dfaCornersY[0] > 0);
// transform coordinates from WGS84 to UTM
OGRCoordinateTransformation *poCT = OGRCreateCoordinateTransformation( &oOGRSpatialReference, &oDstSpatialReference);
if(!poCT)
{
Usage("get coordinate transformation failed");
return EXIT_FAILURE;
}
int nResult = poCT->Transform(5, dfaCornersX, dfaCornersY, NULL);
if(!nResult)
{
Usage("transformation failed");
return EXIT_FAILURE;
}
// open input dataset
GDALDataset *poSrcDataset = (GDALDataset *) GDALOpen( sFileName, GA_ReadOnly ); // GA_Update
char* pszSpaRefDef = NULL;
if( oDstSpatialReference.exportToWkt(&pszSpaRefDef) != OGRERR_NONE)
{
CPLFree( pszSpaRefDef );
GDALClose( (GDALDatasetH) poSrcDataset );
return EXIT_FAILURE;
}
// search point along image
// add GCP to opened raster
OGRPoint ptCenter(dfaCornersX[0], dfaCornersY[0]);
OGRPoint pt1(dfaCornersX[1], dfaCornersY[1]); // NW Cormer
OGRPoint pt2(dfaCornersX[2], dfaCornersY[2]); // NE Corner
OGRPoint pt3(dfaCornersX[3], dfaCornersY[3]); // SE Corner
OGRPoint pt4(dfaCornersX[4], dfaCornersY[4]); // SW Corner
int nGCPCount = 0;
OGREnvelope DstEnv;
GDAL_GCP *paGSPs = PrepareGCP(sFileName, &pt1, &pt2, &pt3, &pt4, &ptCenter, oDstSpatialReference, poSrcDataset->GetRasterXSize(), poSrcDataset->GetRasterYSize(), nGCPCount, DstEnv);
if(poSrcDataset->SetGCPs(nGCPCount, paGSPs, pszSpaRefDef) != CE_None)
{
Usage( "Set GCPs failed" );
return EXIT_FAILURE;
}
// create warper
char **papszTO = NULL;
papszTO = CSLSetNameValue( papszTO, "METHOD", "GCP_TPS" );
papszTO = CSLSetNameValue( papszTO, "NUM_THREADS", "4" );
papszTO = CSLSetNameValue( papszTO, "DST_SRS", pszSpaRefDef );
papszTO = CSLSetNameValue( papszTO, "SRC_SRS", pszSpaRefDef );
papszTO = CSLSetNameValue( papszTO, "INSERT_CENTER_LONG", "FALSE" );
GDALDriver *poOutputDriver = (GDALDriver *) GDALGetDriverByName( "GTiff" );
CPLSetConfigOption( "CHECK_WITH_INVERT_PROJ", "TRUE" );
void* hTransformArg = GDALCreateGenImgProjTransformer2( poSrcDataset, NULL, papszTO );
GDALTransformerInfo* psInfo = (GDALTransformerInfo*)hTransformArg;
double adfThisGeoTransform[6];
double adfExtent[4];
int nThisPixels, nThisLines;
// suggest the raster output size
if( GDALSuggestedWarpOutput2( poSrcDataset, psInfo->pfnTransform, hTransformArg, adfThisGeoTransform, &nThisPixels, &nThisLines, adfExtent, 0 ) != CE_None )
{
Usage( "Suggest Output failed" );
return EXIT_FAILURE;
}
adfThisGeoTransform[0] = DstEnv.MinX;
adfThisGeoTransform[3] = DstEnv.MaxY;
int nPixels = (int) ((DstEnv.MaxX - DstEnv.MinX) / adfThisGeoTransform[1] + 0.5);
int nLines = (int) ((DstEnv.MaxY - DstEnv.MinY) / -adfThisGeoTransform[5] + 0.5);
GDALSetGenImgProjTransformerDstGeoTransform( hTransformArg, adfThisGeoTransform);
// create new raster
CPLString sOutputRasterPath = CPLResetExtension(sFileName, "tif");
GDALDataset *poDstDataset = poOutputDriver->Create(sOutputRasterPath, nPixels, nLines, poSrcDataset->GetRasterCount(), GDT_Byte, NULL );
if( NULL == poDstDataset )
{
Usage( "Create Output failed" );
return EXIT_FAILURE;
}
poDstDataset->SetProjection( pszSpaRefDef );
poDstDataset->SetGeoTransform( adfThisGeoTransform );
#ifdef APRROX_MAXERROR
hTransformArg = GDALCreateApproxTransformer( GDALGenImgProjTransform, hTransformArg, APRROX_MAXERROR);
GDALTransformerFunc pfnTransformer = GDALApproxTransform;
GDALApproxTransformerOwnsSubtransformer(hTransformArg, TRUE);
#else
GDALTransformerFunc pfnTransformer = GDALGenImgProjTransform;
#endif // APRROX_MAXERROR
// warp
GDALWarpOptions *psWO = GDALCreateWarpOptions();
psWO->eWorkingDataType = GDT_Byte;
psWO->eResampleAlg = GRA_NearestNeighbour;
psWO->hSrcDS = poSrcDataset;
psWO->hDstDS = poDstDataset;
psWO->pfnTransformer = pfnTransformer;
psWO->pTransformerArg = hTransformArg;
psWO->pfnProgress = GDALTermProgress;
psWO->nBandCount = poSrcDataset->GetRasterCount();
psWO->panSrcBands = (int *) CPLMalloc(psWO->nBandCount*sizeof(int));
psWO->panDstBands = (int *) CPLMalloc(psWO->nBandCount*sizeof(int));
for(int i = 0; i < psWO->nBandCount; ++i )
{
psWO->panSrcBands[i] = i+1;
psWO->panDstBands[i] = i+1;
}
GDALWarpOperation oWO;
if( oWO.Initialize( psWO ) == CE_None )
{
#ifdef MULTI
if( oWO.ChunkAndWarpMulti( 0, 0, poDstDataset->GetRasterXSize(), poDstDataset->GetRasterYSize() ) != CE_None)
#else //MULTI
if( oWO.ChunkAndWarpImage( 0, 0, poDstDataset->GetRasterXSize(), poDstDataset->GetRasterYSize() ) != CE_None)
#endif //MULTI
{
const char* err = CPLGetLastErrorMsg();
Usage( CPLSPrintf("Warp failed.%s", err) );
return EXIT_FAILURE;
}
}
// cleanup
GDALDestroyWarpOptions( psWO );
CSLDestroy( papszTO );
CPLFree( pszSpaRefDef );
GDALClose( (GDALDatasetH) poSrcDataset );
GDALClose( (GDALDatasetH) poDstDataset );
GDALDestroyDriverManager();
return EXIT_SUCCESS;
}
int main( int argc, char ** argv )
{
const char *pszSrcFilename = NULL;
const char *pszDstFilename = NULL;
int nOrder = 0;
void *hTransformArg;
GDALTransformerFunc pfnTransformer = NULL;
int nGCPCount = 0;
GDAL_GCP *pasGCPs = NULL;
int bInverse = FALSE;
char **papszTO = NULL;
/* Check that we are running against at least GDAL 1.5 */
/* Note to developers : if we use newer API, please change the requirement */
if (atoi(GDALVersionInfo("VERSION_NUM")) < 1500)
{
fprintf(stderr, "At least, GDAL >= 1.5.0 is required for this version of %s, "
"which was compiled against GDAL %s\n", argv[0], GDAL_RELEASE_NAME);
exit(1);
}
GDALAllRegister();
argc = GDALGeneralCmdLineProcessor( argc, &argv, 0 );
if( argc < 1 )
exit( -argc );
/* -------------------------------------------------------------------- */
/* Parse arguments. */
/* -------------------------------------------------------------------- */
int i;
for( i = 1; i < argc; i++ )
{
if( EQUAL(argv[i], "--utility_version") )
{
printf("%s was compiled against GDAL %s and is running against GDAL %s\n",
argv[0], GDAL_RELEASE_NAME, GDALVersionInfo("RELEASE_NAME"));
return 0;
}
else if( EQUAL(argv[i],"-t_srs") && i < argc-1 )
{
char *pszSRS = SanitizeSRS(argv[++i]);
papszTO = CSLSetNameValue( papszTO, "DST_SRS", pszSRS );
CPLFree( pszSRS );
}
else if( EQUAL(argv[i],"-s_srs") && i < argc-1 )
{
char *pszSRS = SanitizeSRS(argv[++i]);
papszTO = CSLSetNameValue( papszTO, "SRC_SRS", pszSRS );
CPLFree( pszSRS );
}
else if( EQUAL(argv[i],"-order") && i < argc-1 )
{
nOrder = atoi(argv[++i]);
papszTO = CSLSetNameValue( papszTO, "MAX_GCP_ORDER", argv[i] );
}
else if( EQUAL(argv[i],"-tps") )
{
papszTO = CSLSetNameValue( papszTO, "METHOD", "GCP_TPS" );
nOrder = -1;
}
else if( EQUAL(argv[i],"-rpc") )
{
papszTO = CSLSetNameValue( papszTO, "METHOD", "RPC" );
}
else if( EQUAL(argv[i],"-geoloc") )
{
papszTO = CSLSetNameValue( papszTO, "METHOD", "GEOLOC_ARRAY" );
}
else if( EQUAL(argv[i],"-i") )
{
bInverse = TRUE;
}
else if( EQUAL(argv[i],"-to") && i < argc-1 )
{
papszTO = CSLAddString( papszTO, argv[++i] );
}
else if( EQUAL(argv[i],"-gcp") && i < argc - 4 )
{
char* endptr = NULL;
/* -gcp pixel line easting northing [elev] */
nGCPCount++;
pasGCPs = (GDAL_GCP *)
CPLRealloc( pasGCPs, sizeof(GDAL_GCP) * nGCPCount );
GDALInitGCPs( 1, pasGCPs + nGCPCount - 1 );
pasGCPs[nGCPCount-1].dfGCPPixel = atof(argv[++i]);
pasGCPs[nGCPCount-1].dfGCPLine = atof(argv[++i]);
pasGCPs[nGCPCount-1].dfGCPX = atof(argv[++i]);
pasGCPs[nGCPCount-1].dfGCPY = atof(argv[++i]);
if( argv[i+1] != NULL
&& (CPLStrtod(argv[i+1], &endptr) != 0.0 || argv[i+1][0] == '0') )
{
/* Check that last argument is really a number and not a filename */
/* looking like a number (see ticket #863) */
if (endptr && *endptr == 0)
pasGCPs[nGCPCount-1].dfGCPZ = atof(argv[++i]);
}
/* should set id and info? */
}
else if( argv[i][0] == '-' )
Usage();
else if( pszSrcFilename == NULL )
pszSrcFilename = argv[i];
else if( pszDstFilename == NULL )
pszDstFilename = argv[i];
else
Usage();
}
/* -------------------------------------------------------------------- */
/* Open src and destination file, if appropriate. */
/* -------------------------------------------------------------------- */
GDALDatasetH hSrcDS = NULL, hDstDS = NULL;
if( pszSrcFilename != NULL )
{
hSrcDS = GDALOpen( pszSrcFilename, GA_ReadOnly );
if( hSrcDS == NULL )
exit( 1 );
}
if( pszDstFilename != NULL )
{
hDstDS = GDALOpen( pszDstFilename, GA_ReadOnly );
if( hDstDS == NULL )
exit( 1 );
}
if( hSrcDS != NULL && nGCPCount > 0 )
{
fprintf( stderr, "Commandline GCPs and input file specified, specify one or the other.\n" );
exit( 1 );
}
/* -------------------------------------------------------------------- */
/* Create a transformation object from the source to */
/* destination coordinate system. */
/* -------------------------------------------------------------------- */
if( nGCPCount != 0 && nOrder == -1 )
{
pfnTransformer = GDALTPSTransform;
hTransformArg =
GDALCreateTPSTransformer( nGCPCount, pasGCPs, FALSE );
}
else if( nGCPCount != 0 )
{
pfnTransformer = GDALGCPTransform;
hTransformArg =
GDALCreateGCPTransformer( nGCPCount, pasGCPs, nOrder, FALSE );
}
else
{
pfnTransformer = GDALGenImgProjTransform;
hTransformArg =
GDALCreateGenImgProjTransformer2( hSrcDS, hDstDS, papszTO );
}
CSLDestroy( papszTO );
if( hTransformArg == NULL )
{
exit( 1 );
}
/* -------------------------------------------------------------------- */
/* Read points from stdin, transform and write to stdout. */
/* -------------------------------------------------------------------- */
while( !feof(stdin) )
{
char szLine[1024];
if( fgets( szLine, sizeof(szLine)-1, stdin ) == NULL )
break;
char **papszTokens = CSLTokenizeString(szLine);
double dfX, dfY, dfZ = 0.0;
int bSuccess = TRUE;
if( CSLCount(papszTokens) < 2 )
{
CSLDestroy(papszTokens);
continue;
}
dfX = atof(papszTokens[0]);
dfY = atof(papszTokens[1]);
if( CSLCount(papszTokens) >= 3 )
dfZ = atof(papszTokens[2]);
if( pfnTransformer( hTransformArg, bInverse, 1,
&dfX, &dfY, &dfZ, &bSuccess )
&& bSuccess )
{
printf( "%.15g %.15g %.15g\n", dfX, dfY, dfZ );
}
else
{
printf( "transformation failed.\n" );
}
CSLDestroy(papszTokens);
}
if( nGCPCount != 0 && nOrder == -1 )
{
GDALDestroyTPSTransformer(hTransformArg);
}
else if( nGCPCount != 0 )
{
GDALDestroyGCPTransformer(hTransformArg);
}
else
{
GDALDestroyGenImgProjTransformer(hTransformArg);
}
if (nGCPCount)
{
GDALDeinitGCPs( nGCPCount, pasGCPs );
CPLFree( pasGCPs );
}
if (hSrcDS)
GDALClose(hSrcDS);
if (hDstDS)
GDALClose(hDstDS);
GDALDumpOpenDatasets( stderr );
GDALDestroyDriverManager();
CSLDestroy( argv );
return 0;
}
/**
* \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);
}
int OGRS57DataSource::Open( const char * pszFilename, int bTestOpen )
{
int iModule;
pszName = CPLStrdup( pszFilename );
/* -------------------------------------------------------------------- */
/* Check a few bits of the header to see if it looks like an */
/* S57 file (really, if it looks like an ISO8211 file). */
/* -------------------------------------------------------------------- */
if( bTestOpen )
{
FILE *fp;
char pachLeader[10];
fp = VSIFOpenL( pszFilename, "rb" );
if( fp == NULL )
return FALSE;
if( VSIFReadL( pachLeader, 1, 10, fp ) != 10
|| (pachLeader[5] != '1' && pachLeader[5] != '2'
&& pachLeader[5] != '3' )
|| pachLeader[6] != 'L'
|| (pachLeader[8] != '1' && pachLeader[8] != ' ') )
{
VSIFCloseL( fp );
return FALSE;
}
VSIFCloseL( fp );
}
/* -------------------------------------------------------------------- */
/* Setup reader options. */
/* -------------------------------------------------------------------- */
char **papszReaderOptions = NULL;
S57Reader *poModule;
poModule = new S57Reader( pszFilename );
papszReaderOptions = CSLSetNameValue(papszReaderOptions,
S57O_LNAM_REFS, "ON" );
if( GetOption(S57O_UPDATES) != NULL )
papszReaderOptions =
CSLSetNameValue( papszReaderOptions, S57O_UPDATES,
GetOption(S57O_UPDATES));
if( GetOption(S57O_SPLIT_MULTIPOINT) != NULL )
papszReaderOptions =
CSLSetNameValue( papszReaderOptions, S57O_SPLIT_MULTIPOINT,
GetOption(S57O_SPLIT_MULTIPOINT) );
if( GetOption(S57O_ADD_SOUNDG_DEPTH) != NULL )
papszReaderOptions =
CSLSetNameValue( papszReaderOptions, S57O_ADD_SOUNDG_DEPTH,
GetOption(S57O_ADD_SOUNDG_DEPTH));
if( GetOption(S57O_PRESERVE_EMPTY_NUMBERS) != NULL )
papszReaderOptions =
CSLSetNameValue( papszReaderOptions, S57O_PRESERVE_EMPTY_NUMBERS,
GetOption(S57O_PRESERVE_EMPTY_NUMBERS) );
if( GetOption(S57O_RETURN_PRIMITIVES) != NULL )
papszReaderOptions =
CSLSetNameValue( papszReaderOptions, S57O_RETURN_PRIMITIVES,
GetOption(S57O_RETURN_PRIMITIVES) );
if( GetOption(S57O_RETURN_LINKAGES) != NULL )
papszReaderOptions =
CSLSetNameValue( papszReaderOptions, S57O_RETURN_LINKAGES,
GetOption(S57O_RETURN_LINKAGES) );
if( GetOption(S57O_RETURN_DSID) != NULL )
papszReaderOptions =
CSLSetNameValue( papszReaderOptions, S57O_RETURN_DSID,
GetOption(S57O_RETURN_DSID) );
poModule->SetOptions( papszReaderOptions );
CSLDestroy( papszReaderOptions );
/* -------------------------------------------------------------------- */
/* Try opening. */
/* */
/* Eventually this should check for catalogs, and if found */
/* instantiate a whole series of modules. */
/* -------------------------------------------------------------------- */
if( !poModule->Open( bTestOpen ) )
{
delete poModule;
return FALSE;
}
int bSuccess = TRUE;
nModules = 1;
papoModules = (S57Reader **) CPLMalloc(sizeof(void*));
papoModules[0] = poModule;
/* -------------------------------------------------------------------- */
/* Add the header layers if they are called for. */
/* -------------------------------------------------------------------- */
if( GetOption( S57O_RETURN_DSID ) == NULL
|| CSLTestBoolean(GetOption( S57O_RETURN_DSID )) )
{
OGRFeatureDefn *poDefn;
poDefn = S57GenerateDSIDFeatureDefn();
AddLayer( new OGRS57Layer( this, poDefn ) );
}
/* -------------------------------------------------------------------- */
/* Add the primitive layers if they are called for. */
/* -------------------------------------------------------------------- */
if( GetOption( S57O_RETURN_PRIMITIVES ) != NULL )
{
OGRFeatureDefn *poDefn;
poDefn = S57GenerateVectorPrimitiveFeatureDefn( RCNM_VI, poModule->GetOptionFlags());
AddLayer( new OGRS57Layer( this, poDefn ) );
poDefn = S57GenerateVectorPrimitiveFeatureDefn( RCNM_VC, poModule->GetOptionFlags());
AddLayer( new OGRS57Layer( this, poDefn ) );
poDefn = S57GenerateVectorPrimitiveFeatureDefn( RCNM_VE, poModule->GetOptionFlags());
AddLayer( new OGRS57Layer( this, poDefn ) );
poDefn = S57GenerateVectorPrimitiveFeatureDefn( RCNM_VF, poModule->GetOptionFlags());
AddLayer( new OGRS57Layer( this, poDefn ) );
}
/* -------------------------------------------------------------------- */
/* Initialize a layer for each type of geometry. Eventually */
/* we will do this by object class. */
/* -------------------------------------------------------------------- */
if( OGRS57Driver::GetS57Registrar() == NULL )
{
OGRFeatureDefn *poDefn;
poDefn = S57GenerateGeomFeatureDefn( wkbPoint,
poModule->GetOptionFlags() );
AddLayer( new OGRS57Layer( this, poDefn ) );
poDefn = S57GenerateGeomFeatureDefn( wkbLineString,
poModule->GetOptionFlags() );
AddLayer( new OGRS57Layer( this, poDefn ) );
poDefn = S57GenerateGeomFeatureDefn( wkbPolygon,
poModule->GetOptionFlags() );
AddLayer( new OGRS57Layer( this, poDefn ) );
poDefn = S57GenerateGeomFeatureDefn( wkbNone,
poModule->GetOptionFlags() );
AddLayer( new OGRS57Layer( this, poDefn ) );
}
/* -------------------------------------------------------------------- */
/* Initialize a feature definition for each class that actually */
/* occurs in the dataset. */
/* -------------------------------------------------------------------- */
else
{
OGRFeatureDefn *poDefn;
int *panClassCount;
int iClass, bGeneric = FALSE;
for( iModule = 0; iModule < nModules; iModule++ )
papoModules[iModule]->SetClassBased( OGRS57Driver::GetS57Registrar() );
panClassCount = (int *) CPLCalloc(sizeof(int),MAX_CLASSES);
for( iModule = 0; iModule < nModules; iModule++ )
{
bSuccess &=
papoModules[iModule]->CollectClassList(panClassCount,
MAX_CLASSES);
}
for( iClass = 0; iClass < MAX_CLASSES; iClass++ )
{
if( panClassCount[iClass] > 0 )
{
poDefn =
S57GenerateObjectClassDefn( OGRS57Driver::GetS57Registrar(),
iClass,
poModule->GetOptionFlags() );
if( poDefn != NULL )
AddLayer( new OGRS57Layer( this, poDefn,
panClassCount[iClass] ) );
else
{
bGeneric = TRUE;
CPLDebug( "S57",
"Unable to find definition for OBJL=%d\n",
iClass );
}
}
}
if( bGeneric )
{
poDefn = S57GenerateGeomFeatureDefn( wkbUnknown,
poModule->GetOptionFlags() );
AddLayer( new OGRS57Layer( this, poDefn ) );
}
CPLFree( panClassCount );
}
/* -------------------------------------------------------------------- */
/* Attach the layer definitions to each of the readers. */
/* -------------------------------------------------------------------- */
for( iModule = 0; iModule < nModules; iModule++ )
{
for( int iLayer = 0; iLayer < nLayers; iLayer++ )
{
papoModules[iModule]->AddFeatureDefn(
papoLayers[iLayer]->GetLayerDefn() );
}
}
return bSuccess;
}
GDALRasterizeOptions *GDALRasterizeOptionsNew(char** papszArgv,
GDALRasterizeOptionsForBinary* psOptionsForBinary)
{
GDALRasterizeOptions *psOptions = new GDALRasterizeOptions;
psOptions->pszFormat = CPLStrdup("GTiff");
psOptions->pfnProgress = GDALDummyProgress;
psOptions->pProgressData = NULL;
psOptions->bCreateOutput = FALSE;
psOptions->b3D = FALSE;
psOptions->bInverse = FALSE;
memset(&(psOptions->sEnvelop), 0, sizeof(psOptions->sEnvelop));
psOptions->papszCreationOptions = NULL;
psOptions->papszLayers = NULL;
psOptions->pszSQL = NULL;
psOptions->pszDialect = NULL;
psOptions->pszBurnAttribute = NULL;
psOptions->pszWHERE = NULL;
psOptions->papszRasterizeOptions = NULL;
psOptions->dfXRes = 0;
psOptions->dfYRes = 0;
psOptions->bCreateOutput = FALSE;
psOptions->eOutputType = GDT_Float64;
psOptions->bNoDataSet = FALSE;
psOptions->dfNoData = 0;
psOptions->bGotBounds = FALSE;
psOptions->nXSize = 0;
psOptions->nYSize = 0;
psOptions->hSRS = NULL;
psOptions->bTargetAlignedPixels = FALSE;
/* -------------------------------------------------------------------- */
/* Handle command line arguments. */
/* -------------------------------------------------------------------- */
int argc = CSLCount(papszArgv);
for( int i = 0; i < argc; i++ )
{
if( EQUAL(papszArgv[i],"-of") && i < argc-1 )
{
++i;
CPLFree(psOptions->pszFormat);
psOptions->pszFormat = CPLStrdup(papszArgv[i]);
psOptions->bCreateOutput = TRUE;
if( psOptionsForBinary )
{
psOptionsForBinary->bFormatExplicitlySet = TRUE;
}
}
else if( EQUAL(papszArgv[i],"-q") || EQUAL(papszArgv[i],"-quiet") )
{
if( psOptionsForBinary )
psOptionsForBinary->bQuiet = TRUE;
}
else if( EQUAL(papszArgv[i],"-a") && i < argc-1 )
{
CPLFree(psOptions->pszBurnAttribute);
psOptions->pszBurnAttribute = CPLStrdup(papszArgv[++i]);
}
else if( EQUAL(papszArgv[i],"-b") && i < argc-1 )
{
if (strchr(papszArgv[i+1], ' '))
{
char** papszTokens = CSLTokenizeString( papszArgv[i+1] );
char** papszIter = papszTokens;
while(papszIter && *papszIter)
{
psOptions->anBandList.push_back(atoi(*papszIter));
papszIter ++;
}
CSLDestroy(papszTokens);
i += 1;
}
else
{
while(i < argc-1 && ArgIsNumeric(papszArgv[i+1]))
{
psOptions->anBandList.push_back(atoi(papszArgv[i+1]));
i += 1;
}
}
}
else if( EQUAL(papszArgv[i],"-3d") )
{
psOptions->b3D = TRUE;
psOptions->papszRasterizeOptions =
CSLSetNameValue( psOptions->papszRasterizeOptions, "BURN_VALUE_FROM", "Z");
}
else if( EQUAL(papszArgv[i],"-add") )
{
psOptions->papszRasterizeOptions =
CSLSetNameValue( psOptions->papszRasterizeOptions, "MERGE_ALG", "ADD");
}
else if( EQUAL(papszArgv[i],"-chunkysize") && i < argc-1 )
{
psOptions->papszRasterizeOptions =
CSLSetNameValue( psOptions->papszRasterizeOptions, "CHUNKYSIZE",
papszArgv[++i] );
}
else if( EQUAL(papszArgv[i],"-i") )
{
psOptions->bInverse = TRUE;
}
else if( EQUAL(papszArgv[i],"-at") )
{
psOptions->papszRasterizeOptions =
CSLSetNameValue( psOptions->papszRasterizeOptions, "ALL_TOUCHED", "TRUE" );
}
else if( EQUAL(papszArgv[i],"-burn") && i < argc-1 )
{
if (strchr(papszArgv[i+1], ' '))
{
char** papszTokens = CSLTokenizeString( papszArgv[i+1] );
char** papszIter = papszTokens;
while(papszIter && *papszIter)
{
psOptions->adfBurnValues.push_back(CPLAtof(*papszIter));
papszIter ++;
}
CSLDestroy(papszTokens);
i += 1;
}
else
{
while(i < argc-1 && ArgIsNumeric(papszArgv[i+1]))
{
psOptions->adfBurnValues.push_back(CPLAtof(papszArgv[i+1]));
i += 1;
}
}
}
else if( EQUAL(papszArgv[i],"-where") && i < argc-1 )
{
CPLFree(psOptions->pszWHERE);
psOptions->pszWHERE = CPLStrdup(papszArgv[++i]);
}
else if( EQUAL(papszArgv[i],"-l") && i < argc-1 )
{
psOptions->papszLayers = CSLAddString( psOptions->papszLayers, papszArgv[++i] );
}
else if( EQUAL(papszArgv[i],"-sql") && i < argc-1 )
{
CPLFree(psOptions->pszSQL);
psOptions->pszSQL = CPLStrdup(papszArgv[++i]);
}
else if( EQUAL(papszArgv[i],"-dialect") && i < argc-1 )
{
CPLFree(psOptions->pszDialect);
psOptions->pszDialect = CPLStrdup(papszArgv[++i]);
}
else if( EQUAL(papszArgv[i],"-init") && i < argc - 1 )
{
if (strchr(papszArgv[i+1], ' '))
{
char** papszTokens = CSLTokenizeString( papszArgv[i+1] );
char** papszIter = papszTokens;
while(papszIter && *papszIter)
{
psOptions->adfInitVals.push_back(CPLAtof(*papszIter));
papszIter ++;
}
CSLDestroy(papszTokens);
i += 1;
}
else
{
while(i < argc-1 && ArgIsNumeric(papszArgv[i+1]))
{
psOptions->adfInitVals.push_back(CPLAtof(papszArgv[i+1]));
i += 1;
}
}
psOptions->bCreateOutput = TRUE;
}
else if( EQUAL(papszArgv[i],"-a_nodata") && i < argc - 1 )
{
psOptions->dfNoData = CPLAtof(papszArgv[i+1]);
psOptions->bNoDataSet = TRUE;
i += 1;
psOptions->bCreateOutput = TRUE;
}
else if( EQUAL(papszArgv[i],"-a_srs") && i < argc-1 )
{
OSRDestroySpatialReference(psOptions->hSRS);
psOptions->hSRS = OSRNewSpatialReference( NULL );
if( OSRSetFromUserInput(psOptions->hSRS, papszArgv[i+1]) != OGRERR_NONE )
{
CPLError(CE_Failure, CPLE_AppDefined,
"Failed to process SRS definition: %s",
papszArgv[i+1] );
GDALRasterizeOptionsFree(psOptions);
return NULL;
}
i++;
psOptions->bCreateOutput = TRUE;
}
else if( EQUAL(papszArgv[i],"-te") && i < argc - 4 )
{
psOptions->sEnvelop.MinX = CPLAtof(papszArgv[++i]);
psOptions->sEnvelop.MinY = CPLAtof(papszArgv[++i]);
psOptions->sEnvelop.MaxX = CPLAtof(papszArgv[++i]);
psOptions->sEnvelop.MaxY = CPLAtof(papszArgv[++i]);
psOptions->bGotBounds = TRUE;
psOptions->bCreateOutput = TRUE;
}
else if( EQUAL(papszArgv[i],"-a_ullr") && i < argc - 4 )
{
psOptions->sEnvelop.MinX = CPLAtof(papszArgv[++i]);
psOptions->sEnvelop.MaxY = CPLAtof(papszArgv[++i]);
psOptions->sEnvelop.MaxX = CPLAtof(papszArgv[++i]);
psOptions->sEnvelop.MinY = CPLAtof(papszArgv[++i]);
psOptions->bGotBounds = TRUE;
psOptions->bCreateOutput = TRUE;
}
else if( EQUAL(papszArgv[i],"-co") && i < argc-1 )
{
psOptions->papszCreationOptions = CSLAddString( psOptions->papszCreationOptions, papszArgv[++i] );
psOptions->bCreateOutput = TRUE;
}
else if( EQUAL(papszArgv[i],"-ot") && i < argc-1 )
{
int iType;
for( iType = 1; iType < GDT_TypeCount; iType++ )
{
if( GDALGetDataTypeName((GDALDataType)iType) != NULL
&& EQUAL(GDALGetDataTypeName((GDALDataType)iType),
papszArgv[i+1]) )
{
psOptions->eOutputType = (GDALDataType) iType;
}
}
if( psOptions->eOutputType == GDT_Unknown )
{
CPLError(CE_Failure, CPLE_AppDefined,
"Unknown output pixel type: %s", papszArgv[i+1] );
GDALRasterizeOptionsFree(psOptions);
return NULL;
}
i++;
psOptions->bCreateOutput = TRUE;
}
else if( (EQUAL(papszArgv[i],"-ts") || EQUAL(papszArgv[i],"-outsize")) && i < argc-2 )
{
psOptions->nXSize = atoi(papszArgv[++i]);
psOptions->nYSize = atoi(papszArgv[++i]);
if (psOptions->nXSize <= 0 || psOptions->nYSize <= 0)
{
CPLError(CE_Failure, CPLE_AppDefined,
"Wrong value for -outsize parameter.");
GDALRasterizeOptionsFree(psOptions);
return NULL;
}
psOptions->bCreateOutput = TRUE;
}
else if( EQUAL(papszArgv[i],"-tr") && i < argc-2 )
{
psOptions->dfXRes = CPLAtof(papszArgv[++i]);
psOptions->dfYRes = fabs(CPLAtof(papszArgv[++i]));
if( psOptions->dfXRes == 0 || psOptions->dfYRes == 0 )
{
CPLError(CE_Failure, CPLE_AppDefined,
"Wrong value for -tr parameter.");
GDALRasterizeOptionsFree(psOptions);
return NULL;
}
psOptions->bCreateOutput = TRUE;
}
else if( EQUAL(papszArgv[i],"-tap") )
{
psOptions->bTargetAlignedPixels = TRUE;
psOptions->bCreateOutput = TRUE;
}
else if( papszArgv[i][0] == '-' )
{
CPLError(CE_Failure, CPLE_NotSupported,
"Unknown option name '%s'", papszArgv[i]);
GDALRasterizeOptionsFree(psOptions);
return NULL;
}
else if( psOptionsForBinary && psOptionsForBinary->pszSource == NULL )
{
psOptionsForBinary->pszSource = CPLStrdup(papszArgv[i]);
}
else if( psOptionsForBinary && psOptionsForBinary->pszDest == NULL )
{
psOptionsForBinary->pszDest = CPLStrdup(papszArgv[i]);
}
else
{
CPLError(CE_Failure, CPLE_NotSupported,
"Too many command options '%s'", papszArgv[i]);
GDALRasterizeOptionsFree(psOptions);
return NULL;
}
}
if( psOptions->adfBurnValues.size() == 0 &&
psOptions->pszBurnAttribute == NULL && !(psOptions->b3D) )
{
if( psOptionsForBinary == NULL )
psOptions->adfBurnValues.push_back(255);
else
{
CPLError(CE_Failure, CPLE_NotSupported, "At least one of -3d, -burn or -a required." );
GDALRasterizeOptionsFree(psOptions);
return NULL;
}
}
if( psOptions->bCreateOutput )
{
if( psOptions->dfXRes == 0 && psOptions->dfYRes == 0 && psOptions->nXSize == 0 && psOptions->nYSize == 0 )
{
CPLError(CE_Failure, CPLE_NotSupported, "'-tr xres yres' or '-ts xsize ysize' is required." );
GDALRasterizeOptionsFree(psOptions);
return NULL;
}
if (psOptions->bTargetAlignedPixels && psOptions->dfXRes == 0 && psOptions->dfYRes == 0)
{
CPLError(CE_Failure, CPLE_NotSupported, "-tap option cannot be used without using -tr.");
GDALRasterizeOptionsFree(psOptions);
return NULL;;
}
if( psOptions->anBandList.size() != 0 )
{
CPLError(CE_Failure, CPLE_NotSupported, "-b option cannot be used when creating a GDAL dataset." );
GDALRasterizeOptionsFree(psOptions);
return NULL;
}
int nBandCount = 1;
if (psOptions->adfBurnValues.size() != 0)
nBandCount = static_cast<int>(psOptions->adfBurnValues.size());
if ((int)psOptions->adfInitVals.size() > nBandCount)
nBandCount = static_cast<int>(psOptions->adfInitVals.size());
if (psOptions->adfInitVals.size() == 1)
{
for(int i=1;i<=nBandCount - 1;i++)
psOptions->adfInitVals.push_back( psOptions->adfInitVals[0] );
}
int i;
for(i=1;i<=nBandCount;i++)
psOptions->anBandList.push_back( i );
}
else
{
if( psOptions->anBandList.size() == 0 )
psOptions->anBandList.push_back( 1 );
}
if( psOptions->pszDialect != NULL && psOptions->pszWHERE != NULL && psOptions->pszSQL == NULL )
{
CPLError( CE_Warning, CPLE_AppDefined,
"-dialect is ignored with -where. Use -sql instead" );
}
if( psOptionsForBinary )
{
psOptionsForBinary->bCreateOutput = psOptions->bCreateOutput;
psOptionsForBinary->pszFormat = CPLStrdup(psOptions->pszFormat);
}
return psOptions;
}
