/** Load proj.4 geoidgrids as GDAL dataset
*
* @param pszProj4Geoidgrids Value of proj.4 geoidgrids parameter.
* @param pbError If not NULL, the pointed value will be set to TRUE if an
* error occurred.
*
* @return a dataset. If not NULL, it must be closed with GDALClose().
*
* @since GDAL 2.2
*/
GDALDatasetH GDALOpenVerticalShiftGrid( const char* pszProj4Geoidgrids,
int* pbError )
{
char** papszGrids = CSLTokenizeString2( pszProj4Geoidgrids, ",", 0);
const int nGridCount = CSLCount(papszGrids);
if( nGridCount == 1 )
{
CSLDestroy(papszGrids);
bool bMissingOk = false;
if( *pszProj4Geoidgrids == '@' )
{
pszProj4Geoidgrids ++;
bMissingOk = true;
}
const CPLString osFilename(GetProj4Filename(pszProj4Geoidgrids));
const char* const papszOpenOptions[] =
{ "@SHIFT_ORIGIN_IN_MINUS_180_PLUS_180=YES", nullptr };
GDALDatasetH hDS = GDALOpenEx(osFilename, 0, nullptr, papszOpenOptions, nullptr);
if( hDS == nullptr )
{
CPLDebug("GDAL", "Cannot find file corresponding to %s",
pszProj4Geoidgrids);
}
if( pbError )
*pbError = (!bMissingOk && hDS == nullptr);
return hDS;
}
CPLStringList aosFilenames;
for( int i = nGridCount - 1; i >= 0; i-- )
{
const char* pszName = papszGrids[i];
bool bMissingOk = false;
if( *pszName == '@' )
{
pszName ++;
bMissingOk = true;
}
const CPLString osFilename(GetProj4Filename(pszName));
VSIStatBufL sStat;
if( osFilename.empty() || VSIStatL(osFilename, &sStat) != 0 )
{
CPLDebug("GDAL", "Cannot find file corresponding to %s",
pszName);
if( !bMissingOk )
{
if( pbError )
*pbError = true;
CSLDestroy(papszGrids);
return nullptr;
}
}
else
{
aosFilenames.AddString(osFilename);
}
}
CSLDestroy(papszGrids);
if( aosFilenames.empty() )
{
if( pbError )
*pbError = false;
return nullptr;
}
char** papszArgv = nullptr;
papszArgv = CSLAddString(papszArgv, "-resolution");
papszArgv = CSLAddString(papszArgv, "highest");
papszArgv = CSLAddString(papszArgv, "-vrtnodata");
papszArgv = CSLAddString(papszArgv, "-inf");
papszArgv = CSLAddString(papszArgv, "-oo");
papszArgv = CSLAddString(papszArgv, "@SHIFT_ORIGIN_IN_MINUS_180_PLUS_180=YES");
GDALBuildVRTOptions* psOptions = GDALBuildVRTOptionsNew(papszArgv, nullptr);
CSLDestroy(papszArgv);
GDALDatasetH hDS =
GDALBuildVRT( "", aosFilenames.size(), nullptr, aosFilenames.List(),
psOptions, nullptr );
GDALBuildVRTOptionsFree( psOptions );
if( pbError )
*pbError = hDS != nullptr;
return hDS;
}
CPLErr GDALWMSDataset::Initialize(CPLXMLNode *config) {
CPLErr ret = CE_None;
char* pszXML = CPLSerializeXMLTree( config );
if (pszXML)
{
m_osXML = pszXML;
CPLFree(pszXML);
}
// Initialize the minidriver, which can set parameters for the dataset using member functions
CPLXMLNode *service_node = CPLGetXMLNode(config, "Service");
if (service_node != NULL) {
const CPLString service_name = CPLGetXMLValue(service_node, "name", "");
if (!service_name.empty()) {
GDALWMSMiniDriverManager *const mdm = GetGDALWMSMiniDriverManager();
GDALWMSMiniDriverFactory *const mdf = mdm->Find(service_name);
if (mdf != NULL) {
m_mini_driver = mdf->New();
m_mini_driver->m_parent_dataset = this;
if (m_mini_driver->Initialize(service_node) == CE_None) {
m_mini_driver_caps.m_capabilities_version = -1;
m_mini_driver->GetCapabilities(&m_mini_driver_caps);
if (m_mini_driver_caps.m_capabilities_version == -1) {
CPLError(CE_Failure, CPLE_AppDefined, "GDALWMS: Internal error, mini-driver capabilities version not set.");
ret = CE_Failure;
}
} else {
delete m_mini_driver;
m_mini_driver = NULL;
CPLError(CE_Failure, CPLE_AppDefined, "GDALWMS: Failed to initialize minidriver.");
ret = CE_Failure;
}
} else {
CPLError(CE_Failure, CPLE_AppDefined,
"GDALWMS: No mini-driver registered for '%s'.", service_name.c_str());
ret = CE_Failure;
}
} else {
CPLError(CE_Failure, CPLE_AppDefined, "GDALWMS: No Service specified.");
ret = CE_Failure;
}
} else {
CPLError(CE_Failure, CPLE_AppDefined, "GDALWMS: No Service specified.");
ret = CE_Failure;
}
/*
Parameters that could be set by minidriver already, based on server side information.
If the size is set, minidriver has done this already
A "server" side minidriver needs to set at least:
- Blocksize (x and y)
- Clamp flag (defaults to true)
- DataWindow
- Band Count
- Data Type
It should also initialize and register the bands and overviews.
*/
if (m_data_window.m_sx<1) {
if (ret == CE_None) {
m_block_size_x = atoi(CPLGetXMLValue(config, "BlockSizeX", CPLString().Printf("%d", m_default_block_size_x)));
m_block_size_y = atoi(CPLGetXMLValue(config, "BlockSizeY", CPLString().Printf("%d", m_default_block_size_y)));
if (m_block_size_x <= 0 || m_block_size_y <= 0) {
CPLError( CE_Failure, CPLE_AppDefined, "GDALWMS: Invalid value in BlockSizeX or BlockSizeY" );
ret = CE_Failure;
}
}
if (ret == CE_None) {
m_clamp_requests = StrToBool(CPLGetXMLValue(config, "ClampRequests", "true"));
if (m_clamp_requests<0) {
CPLError(CE_Failure, CPLE_AppDefined, "GDALWMS: Invalid value of ClampRequests, true/false expected.");
ret = CE_Failure;
}
}
if (ret == CE_None) {
CPLXMLNode *data_window_node = CPLGetXMLNode(config, "DataWindow");
if (data_window_node == NULL && m_bNeedsDataWindow) {
CPLError(CE_Failure, CPLE_AppDefined, "GDALWMS: DataWindow missing.");
ret = CE_Failure;
} else {
CPLString osDefaultX0, osDefaultX1, osDefaultY0, osDefaultY1;
CPLString osDefaultTileCountX, osDefaultTileCountY, osDefaultTileLevel;
CPLString osDefaultOverviewCount;
osDefaultX0.Printf("%.8f", m_default_data_window.m_x0);
osDefaultX1.Printf("%.8f", m_default_data_window.m_x1);
osDefaultY0.Printf("%.8f", m_default_data_window.m_y0);
osDefaultY1.Printf("%.8f", m_default_data_window.m_y1);
osDefaultTileCountX.Printf("%d", m_default_tile_count_x);
osDefaultTileCountY.Printf("%d", m_default_tile_count_y);
if (m_default_data_window.m_tlevel >= 0)
osDefaultTileLevel.Printf("%d", m_default_data_window.m_tlevel);
if (m_default_overview_count >= 0)
osDefaultOverviewCount.Printf("%d", m_default_overview_count);
const char *overview_count = CPLGetXMLValue(config, "OverviewCount", osDefaultOverviewCount);
const char *ulx = CPLGetXMLValue(data_window_node, "UpperLeftX", osDefaultX0);
const char *uly = CPLGetXMLValue(data_window_node, "UpperLeftY", osDefaultY0);
const char *lrx = CPLGetXMLValue(data_window_node, "LowerRightX", osDefaultX1);
const char *lry = CPLGetXMLValue(data_window_node, "LowerRightY", osDefaultY1);
const char *sx = CPLGetXMLValue(data_window_node, "SizeX", "");
const char *sy = CPLGetXMLValue(data_window_node, "SizeY", "");
const char *tx = CPLGetXMLValue(data_window_node, "TileX", "0");
const char *ty = CPLGetXMLValue(data_window_node, "TileY", "0");
const char *tlevel = CPLGetXMLValue(data_window_node, "TileLevel", osDefaultTileLevel);
const char *str_tile_count_x = CPLGetXMLValue(data_window_node, "TileCountX", osDefaultTileCountX);
const char *str_tile_count_y = CPLGetXMLValue(data_window_node, "TileCountY", osDefaultTileCountY);
const char *y_origin = CPLGetXMLValue(data_window_node, "YOrigin", "default");
if (ret == CE_None) {
if ((ulx[0] != '\0') && (uly[0] != '\0') && (lrx[0] != '\0') && (lry[0] != '\0')) {
m_data_window.m_x0 = atof(ulx);
m_data_window.m_y0 = atof(uly);
m_data_window.m_x1 = atof(lrx);
m_data_window.m_y1 = atof(lry);
} else {
CPLError(CE_Failure, CPLE_AppDefined, "GDALWMS: Mandatory elements of DataWindow missing: UpperLeftX, UpperLeftY, LowerRightX, LowerRightY.");
ret = CE_Failure;
}
}
m_data_window.m_tlevel = atoi(tlevel);
if (ret == CE_None) {
if ((sx[0] != '\0') && (sy[0] != '\0')) {
m_data_window.m_sx = atoi(sx);
m_data_window.m_sy = atoi(sy);
} else if ((tlevel[0] != '\0') && (str_tile_count_x[0] != '\0') && (str_tile_count_y[0] != '\0')) {
int tile_count_x = atoi(str_tile_count_x);
int tile_count_y = atoi(str_tile_count_y);
m_data_window.m_sx = tile_count_x * m_block_size_x * (1 << m_data_window.m_tlevel);
m_data_window.m_sy = tile_count_y * m_block_size_y * (1 << m_data_window.m_tlevel);
} else {
CPLError(CE_Failure, CPLE_AppDefined, "GDALWMS: Mandatory elements of DataWindow missing: SizeX, SizeY.");
ret = CE_Failure;
}
}
if (ret == CE_None) {
if ((tx[0] != '\0') && (ty[0] != '\0')) {
m_data_window.m_tx = atoi(tx);
m_data_window.m_ty = atoi(ty);
} else {
CPLError(CE_Failure, CPLE_AppDefined, "GDALWMS: Mandatory elements of DataWindow missing: TileX, TileY.");
ret = CE_Failure;
}
}
if (ret == CE_None) {
if (overview_count[0] != '\0') {
m_overview_count = atoi(overview_count);
} else if (tlevel[0] != '\0') {
m_overview_count = m_data_window.m_tlevel;
} else {
const int min_overview_size = MAX(32, MIN(m_block_size_x, m_block_size_y));
double a = log(static_cast<double>(MIN(m_data_window.m_sx, m_data_window.m_sy))) / log(2.0)
- log(static_cast<double>(min_overview_size)) / log(2.0);
m_overview_count = MAX(0, MIN(static_cast<int>(ceil(a)), 32));
}
}
if (ret == CE_None) {
CPLString y_origin_str = y_origin;
if (y_origin_str == "top") {
m_data_window.m_y_origin = GDALWMSDataWindow::TOP;
} else if (y_origin_str == "bottom") {
m_data_window.m_y_origin = GDALWMSDataWindow::BOTTOM;
} else if (y_origin_str == "default") {
m_data_window.m_y_origin = GDALWMSDataWindow::DEFAULT;
} else {
CPLError(CE_Failure, CPLE_AppDefined, "GDALWMS: DataWindow YOrigin must be set to "
"one of 'default', 'top', or 'bottom', not '%s'.", y_origin_str.c_str());
ret = CE_Failure;
}
}
}
}
if (ret == CE_None) {
if (nBands<1)
nBands=atoi(CPLGetXMLValue(config,"BandsCount","3"));
if (nBands<1) {
CPLError(CE_Failure, CPLE_AppDefined, "GDALWMS: Bad number of bands.");
ret = CE_Failure;
}
}
if (ret == CE_None)
{
const char *data_type = CPLGetXMLValue(config, "DataType", "Byte");
m_data_type = GDALGetDataTypeByName( data_type );
if ( m_data_type == GDT_Unknown || m_data_type >= GDT_TypeCount )
{
CPLError( CE_Failure, CPLE_AppDefined,
"GDALWMS: Invalid value in DataType. Data type \"%s\" is not supported.", data_type );
ret = CE_Failure;
}
}
// Initialize the bands and the overviews. Assumes overviews are powers of two
if (ret == CE_None) {
nRasterXSize = m_data_window.m_sx;
nRasterYSize = m_data_window.m_sy;
if (!GDALCheckDatasetDimensions(nRasterXSize, nRasterYSize) ||
!GDALCheckBandCount(nBands, TRUE))
{
return CE_Failure;
}
GDALColorInterp default_color_interp[4][4] = {
{ GCI_GrayIndex, GCI_Undefined, GCI_Undefined, GCI_Undefined },
{ GCI_GrayIndex, GCI_AlphaBand, GCI_Undefined, GCI_Undefined },
{ GCI_RedBand, GCI_GreenBand, GCI_BlueBand, GCI_Undefined },
{ GCI_RedBand, GCI_GreenBand, GCI_BlueBand, GCI_AlphaBand }
};
for (int i = 0; i < nBands; ++i) {
GDALColorInterp color_interp = (nBands <= 4 && i <= 3 ? default_color_interp[nBands - 1][i] : GCI_Undefined);
GDALWMSRasterBand *band = new GDALWMSRasterBand(this, i, 1.0);
band->m_color_interp = color_interp;
SetBand(i + 1, band);
double scale = 0.5;
for (int j = 0; j < m_overview_count; ++j) {
band->AddOverview(scale);
band->m_color_interp = color_interp;
scale *= 0.5;
}
}
}
}
const char *pszUserAgent = CPLGetXMLValue(config, "UserAgent", "");
if (pszUserAgent[0] != '\0')
m_osUserAgent = pszUserAgent;
const char *pszReferer = CPLGetXMLValue(config, "Referer", "");
if (pszReferer[0] != '\0')
m_osReferer = pszReferer;
if (ret == CE_None) {
const char *pszHttpZeroBlockCodes = CPLGetXMLValue(config, "ZeroBlockHttpCodes", "");
if(pszHttpZeroBlockCodes == '\0') {
m_http_zeroblock_codes.push_back(204);
} else {
char **kv = CSLTokenizeString2(pszHttpZeroBlockCodes,",",CSLT_HONOURSTRINGS);
int nCount = CSLCount(kv);
for(int i=0; i<nCount; i++) {
int code = atoi(kv[i]);
if(code <= 0) {
CPLError(CE_Failure, CPLE_AppDefined, "GDALWMS: Invalid value of ZeroBlockHttpCodes \"%s\", comma separated HTTP response codes expected.",
kv[i]);
ret = CE_Failure;
break;
}
m_http_zeroblock_codes.push_back(code);
}
CSLDestroy(kv);
}
}
if (ret == CE_None) {
const char *pszZeroExceptions = CPLGetXMLValue(config, "ZeroBlockOnServerException", "");
if(pszZeroExceptions[0] != '\0') {
m_zeroblock_on_serverexceptions = StrToBool(pszZeroExceptions);
if (m_zeroblock_on_serverexceptions == -1) {
CPLError(CE_Failure, CPLE_AppDefined, "GDALWMS: Invalid value of ZeroBlockOnServerException \"%s\", true/false expected.",
pszZeroExceptions);
ret = CE_Failure;
}
}
}
if (ret == CE_None) {
const char *max_conn = CPLGetXMLValue(config, "MaxConnections", "");
if (max_conn[0] != '\0') {
m_http_max_conn = atoi(max_conn);
} else {
m_http_max_conn = 2;
}
}
if (ret == CE_None) {
const char *timeout = CPLGetXMLValue(config, "Timeout", "");
if (timeout[0] != '\0') {
m_http_timeout = atoi(timeout);
} else {
m_http_timeout = 300;
}
}
if (ret == CE_None) {
const char *offline_mode = CPLGetXMLValue(config, "OfflineMode", "");
if (offline_mode[0] != '\0') {
const int offline_mode_bool = StrToBool(offline_mode);
if (offline_mode_bool == -1) {
CPLError(CE_Failure, CPLE_AppDefined, "GDALWMS: Invalid value of OfflineMode, true / false expected.");
ret = CE_Failure;
} else {
m_offline_mode = offline_mode_bool;
}
} else {
m_offline_mode = 0;
}
}
if (ret == CE_None) {
const char *advise_read = CPLGetXMLValue(config, "AdviseRead", "");
if (advise_read[0] != '\0') {
const int advise_read_bool = StrToBool(advise_read);
if (advise_read_bool == -1) {
CPLError(CE_Failure, CPLE_AppDefined, "GDALWMS: Invalid value of AdviseRead, true / false expected.");
ret = CE_Failure;
} else {
m_use_advise_read = advise_read_bool;
}
} else {
m_use_advise_read = 0;
}
}
if (ret == CE_None) {
const char *verify_advise_read = CPLGetXMLValue(config, "VerifyAdviseRead", "");
if (m_use_advise_read) {
if (verify_advise_read[0] != '\0') {
const int verify_advise_read_bool = StrToBool(verify_advise_read);
if (verify_advise_read_bool == -1) {
CPLError(CE_Failure, CPLE_AppDefined, "GDALWMS: Invalid value of VerifyAdviseRead, true / false expected.");
ret = CE_Failure;
} else {
m_verify_advise_read = verify_advise_read_bool;
}
} else {
m_verify_advise_read = 1;
}
}
}
// Let the local configuration override the minidriver supplied projection
if (ret == CE_None) {
const char *proj = CPLGetXMLValue(config, "Projection", "");
if (proj[0] != '\0') {
m_projection = ProjToWKT(proj);
if (m_projection.size() == 0) {
CPLError(CE_Failure, CPLE_AppDefined, "GDALWMS: Bad projection specified.");
ret = CE_Failure;
}
}
}
if (ret == CE_None) {
CPLXMLNode *cache_node = CPLGetXMLNode(config, "Cache");
if (cache_node != NULL) {
m_cache = new GDALWMSCache();
if (m_cache->Initialize(cache_node) != CE_None) {
delete m_cache;
m_cache = NULL;
CPLError(CE_Failure, CPLE_AppDefined, "GDALWMS: Failed to initialize cache.");
ret = CE_Failure;
}
}
}
if (ret == CE_None) {
const int v = StrToBool(CPLGetXMLValue(config, "UnsafeSSL", "false"));
if (v == -1) {
CPLError(CE_Failure, CPLE_AppDefined, "GDALWMS: Invalid value of UnsafeSSL: true or false expected.");
ret = CE_Failure;
} else {
m_unsafeSsl = v;
}
}
if (ret == CE_None) {
/* If we dont have projection already set ask mini-driver. */
if (!m_projection.size()) {
const char *proj = m_mini_driver->GetProjectionInWKT();
if (proj != NULL) {
m_projection = proj;
}
}
}
return ret;
}
int main( int argc, char ** argv )
{
GDALDatasetH hDataset;
GDALRasterBandH hBand;
int i, iBand;
double adfGeoTransform[6];
GDALDriverH hDriver;
char **papszMetadata;
int bComputeMinMax = FALSE, bSample = FALSE;
int bShowGCPs = TRUE, bShowMetadata = TRUE, bShowRAT=TRUE;
int bStats = FALSE, bApproxStats = TRUE, iMDD;
int bShowColorTable = TRUE, bComputeChecksum = FALSE;
int bReportHistograms = FALSE;
int bReportProj4 = FALSE;
int nSubdataset = -1;
const char *pszFilename = NULL;
char **papszExtraMDDomains = NULL, **papszFileList;
const char *pszProjection = NULL;
OGRCoordinateTransformationH hTransform = NULL;
int bShowFileList = TRUE;
/* 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);
}
/* Must process GDAL_SKIP before GDALAllRegister(), but we can't call */
/* GDALGeneralCmdLineProcessor before it needs the drivers to be registered */
/* for the --format or --formats options */
for( i = 1; i < argc; i++ )
{
if( EQUAL(argv[i],"--config") && i + 2 < argc && EQUAL(argv[i + 1], "GDAL_SKIP") )
{
CPLSetConfigOption( argv[i+1], argv[i+2] );
i += 2;
}
}
GDALAllRegister();
argc = GDALGeneralCmdLineProcessor( argc, &argv, 0 );
if( argc < 1 )
exit( -argc );
/* -------------------------------------------------------------------- */
/* Parse arguments. */
/* -------------------------------------------------------------------- */
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], "-mm") )
bComputeMinMax = TRUE;
else if( EQUAL(argv[i], "-hist") )
bReportHistograms = TRUE;
else if( EQUAL(argv[i], "-proj4") )
bReportProj4 = TRUE;
else if( EQUAL(argv[i], "-stats") )
{
bStats = TRUE;
bApproxStats = FALSE;
}
else if( EQUAL(argv[i], "-approx_stats") )
{
bStats = TRUE;
bApproxStats = TRUE;
}
else if( EQUAL(argv[i], "-sample") )
bSample = TRUE;
else if( EQUAL(argv[i], "-checksum") )
bComputeChecksum = TRUE;
else if( EQUAL(argv[i], "-nogcp") )
bShowGCPs = FALSE;
else if( EQUAL(argv[i], "-nomd") )
bShowMetadata = FALSE;
else if( EQUAL(argv[i], "-norat") )
bShowRAT = FALSE;
else if( EQUAL(argv[i], "-noct") )
bShowColorTable = FALSE;
else if( EQUAL(argv[i], "-mdd") && i < argc-1 )
papszExtraMDDomains = CSLAddString( papszExtraMDDomains,
argv[++i] );
else if( EQUAL(argv[i], "-nofl") )
bShowFileList = FALSE;
else if( EQUAL(argv[i], "-sd") && i < argc-1 )
nSubdataset = atoi(argv[++i]);
else if( argv[i][0] == '-' )
Usage();
else if( pszFilename == NULL )
pszFilename = argv[i];
else
Usage();
}
if( pszFilename == NULL )
Usage();
/* -------------------------------------------------------------------- */
/* Open dataset. */
/* -------------------------------------------------------------------- */
hDataset = GDALOpen( pszFilename, GA_ReadOnly );
if( hDataset == NULL )
{
fprintf( stderr,
"gdalinfo failed - unable to open '%s'.\n",
pszFilename );
CSLDestroy( argv );
CSLDestroy( papszExtraMDDomains );
GDALDumpOpenDatasets( stderr );
GDALDestroyDriverManager();
CPLDumpSharedList( NULL );
exit( 1 );
}
/* -------------------------------------------------------------------- */
/* Read specified subdataset if requested. */
/* -------------------------------------------------------------------- */
if ( nSubdataset > 0 )
{
char **papszSubdatasets = GDALGetMetadata( hDataset, "SUBDATASETS" );
int nSubdatasets = CSLCount( papszSubdatasets );
if ( nSubdatasets > 0 && nSubdataset <= nSubdatasets )
{
char szKeyName[1024];
char *pszSubdatasetName;
snprintf( szKeyName, sizeof(szKeyName),
"SUBDATASET_%d_NAME", nSubdataset );
szKeyName[sizeof(szKeyName) - 1] = '\0';
pszSubdatasetName =
CPLStrdup( CSLFetchNameValue( papszSubdatasets, szKeyName ) );
GDALClose( hDataset );
hDataset = GDALOpen( pszSubdatasetName, GA_ReadOnly );
CPLFree( pszSubdatasetName );
}
else
{
fprintf( stderr,
"gdalinfo warning: subdataset %d of %d requested. "
"Reading the main dataset.\n",
nSubdataset, nSubdatasets );
}
}
/* -------------------------------------------------------------------- */
/* Report general info. */
/* -------------------------------------------------------------------- */
hDriver = GDALGetDatasetDriver( hDataset );
printf( "Driver: %s/%s\n",
GDALGetDriverShortName( hDriver ),
GDALGetDriverLongName( hDriver ) );
papszFileList = GDALGetFileList( hDataset );
if( CSLCount(papszFileList) == 0 )
{
printf( "Files: none associated\n" );
}
else
{
printf( "Files: %s\n", papszFileList[0] );
if( bShowFileList )
{
for( i = 1; papszFileList[i] != NULL; i++ )
printf( " %s\n", papszFileList[i] );
}
}
CSLDestroy( papszFileList );
printf( "Size is %d, %d\n",
GDALGetRasterXSize( hDataset ),
GDALGetRasterYSize( hDataset ) );
/* -------------------------------------------------------------------- */
/* Report projection. */
/* -------------------------------------------------------------------- */
if( GDALGetProjectionRef( hDataset ) != NULL )
{
OGRSpatialReferenceH hSRS;
char *pszProjection;
pszProjection = (char *) GDALGetProjectionRef( hDataset );
hSRS = OSRNewSpatialReference(NULL);
if( OSRImportFromWkt( hSRS, &pszProjection ) == CE_None )
{
char *pszPrettyWkt = NULL;
OSRExportToPrettyWkt( hSRS, &pszPrettyWkt, FALSE );
printf( "Coordinate System is:\n%s\n", pszPrettyWkt );
CPLFree( pszPrettyWkt );
}
else
printf( "Coordinate System is `%s'\n",
GDALGetProjectionRef( hDataset ) );
if ( bReportProj4 )
{
char *pszProj4 = NULL;
OSRExportToProj4( hSRS, &pszProj4 );
printf("PROJ.4 string is:\n\'%s\'\n",pszProj4);
CPLFree( pszProj4 );
}
OSRDestroySpatialReference( hSRS );
}
/* -------------------------------------------------------------------- */
/* Report Geotransform. */
/* -------------------------------------------------------------------- */
if( GDALGetGeoTransform( hDataset, adfGeoTransform ) == CE_None )
{
if( adfGeoTransform[2] == 0.0 && adfGeoTransform[4] == 0.0 )
{
printf( "Origin = (%.15f,%.15f)\n",
adfGeoTransform[0], adfGeoTransform[3] );
printf( "Pixel Size = (%.15f,%.15f)\n",
adfGeoTransform[1], adfGeoTransform[5] );
}
else
printf( "GeoTransform =\n"
" %.16g, %.16g, %.16g\n"
" %.16g, %.16g, %.16g\n",
adfGeoTransform[0],
adfGeoTransform[1],
adfGeoTransform[2],
adfGeoTransform[3],
adfGeoTransform[4],
adfGeoTransform[5] );
}
/* -------------------------------------------------------------------- */
/* Report GCPs. */
/* -------------------------------------------------------------------- */
if( bShowGCPs && GDALGetGCPCount( hDataset ) > 0 )
{
if (GDALGetGCPProjection(hDataset) != NULL)
{
OGRSpatialReferenceH hSRS;
char *pszProjection;
pszProjection = (char *) GDALGetGCPProjection( hDataset );
hSRS = OSRNewSpatialReference(NULL);
if( OSRImportFromWkt( hSRS, &pszProjection ) == CE_None )
{
char *pszPrettyWkt = NULL;
OSRExportToPrettyWkt( hSRS, &pszPrettyWkt, FALSE );
printf( "GCP Projection = \n%s\n", pszPrettyWkt );
CPLFree( pszPrettyWkt );
}
else
printf( "GCP Projection = %s\n",
GDALGetGCPProjection( hDataset ) );
OSRDestroySpatialReference( hSRS );
}
for( i = 0; i < GDALGetGCPCount(hDataset); i++ )
{
const GDAL_GCP *psGCP;
psGCP = GDALGetGCPs( hDataset ) + i;
printf( "GCP[%3d]: Id=%s, Info=%s\n"
" (%.15g,%.15g) -> (%.15g,%.15g,%.15g)\n",
i, psGCP->pszId, psGCP->pszInfo,
psGCP->dfGCPPixel, psGCP->dfGCPLine,
psGCP->dfGCPX, psGCP->dfGCPY, psGCP->dfGCPZ );
}
}
/* -------------------------------------------------------------------- */
/* Report metadata. */
/* -------------------------------------------------------------------- */
papszMetadata = (bShowMetadata) ? GDALGetMetadata( hDataset, NULL ) : NULL;
if( bShowMetadata && CSLCount(papszMetadata) > 0 )
{
printf( "Metadata:\n" );
for( i = 0; papszMetadata[i] != NULL; i++ )
{
printf( " %s\n", papszMetadata[i] );
}
}
for( iMDD = 0; bShowMetadata && iMDD < CSLCount(papszExtraMDDomains); iMDD++ )
{
papszMetadata = GDALGetMetadata( hDataset, papszExtraMDDomains[iMDD] );
if( CSLCount(papszMetadata) > 0 )
{
printf( "Metadata (%s):\n", papszExtraMDDomains[iMDD]);
for( i = 0; papszMetadata[i] != NULL; i++ )
{
if (EQUALN(papszExtraMDDomains[iMDD], "xml:", 4))
printf( "%s\n", papszMetadata[i] );
else
printf( " %s\n", papszMetadata[i] );
}
}
}
/* -------------------------------------------------------------------- */
/* Report "IMAGE_STRUCTURE" metadata. */
/* -------------------------------------------------------------------- */
papszMetadata = (bShowMetadata) ? GDALGetMetadata( hDataset, "IMAGE_STRUCTURE" ) : NULL;
if( bShowMetadata && CSLCount(papszMetadata) > 0 )
{
printf( "Image Structure Metadata:\n" );
for( i = 0; papszMetadata[i] != NULL; i++ )
{
printf( " %s\n", papszMetadata[i] );
}
}
/* -------------------------------------------------------------------- */
/* Report subdatasets. */
/* -------------------------------------------------------------------- */
papszMetadata = GDALGetMetadata( hDataset, "SUBDATASETS" );
if( CSLCount(papszMetadata) > 0 )
{
printf( "Subdatasets:\n" );
for( i = 0; papszMetadata[i] != NULL; i++ )
{
printf( " %s\n", papszMetadata[i] );
}
}
/* -------------------------------------------------------------------- */
/* Report geolocation. */
/* -------------------------------------------------------------------- */
papszMetadata = (bShowMetadata) ? GDALGetMetadata( hDataset, "GEOLOCATION" ) : NULL;
if( bShowMetadata && CSLCount(papszMetadata) > 0 )
{
printf( "Geolocation:\n" );
for( i = 0; papszMetadata[i] != NULL; i++ )
{
printf( " %s\n", papszMetadata[i] );
}
}
/* -------------------------------------------------------------------- */
/* Report RPCs */
/* -------------------------------------------------------------------- */
papszMetadata = (bShowMetadata) ? GDALGetMetadata( hDataset, "RPC" ) : NULL;
if( bShowMetadata && CSLCount(papszMetadata) > 0 )
{
printf( "RPC Metadata:\n" );
for( i = 0; papszMetadata[i] != NULL; i++ )
{
printf( " %s\n", papszMetadata[i] );
}
}
/* -------------------------------------------------------------------- */
/* Setup projected to lat/long transform if appropriate. */
/* -------------------------------------------------------------------- */
if( GDALGetGeoTransform( hDataset, adfGeoTransform ) == CE_None )
pszProjection = GDALGetProjectionRef(hDataset);
if( pszProjection != NULL && strlen(pszProjection) > 0 )
{
OGRSpatialReferenceH hProj, hLatLong = NULL;
hProj = OSRNewSpatialReference( pszProjection );
if( hProj != NULL )
hLatLong = OSRCloneGeogCS( hProj );
if( hLatLong != NULL )
{
CPLPushErrorHandler( CPLQuietErrorHandler );
hTransform = OCTNewCoordinateTransformation( hProj, hLatLong );
CPLPopErrorHandler();
OSRDestroySpatialReference( hLatLong );
}
if( hProj != NULL )
OSRDestroySpatialReference( hProj );
}
/* -------------------------------------------------------------------- */
/* Report corners. */
/* -------------------------------------------------------------------- */
printf( "Corner Coordinates:\n" );
GDALInfoReportCorner( hDataset, hTransform, "Upper Left",
0.0, 0.0 );
GDALInfoReportCorner( hDataset, hTransform, "Lower Left",
0.0, GDALGetRasterYSize(hDataset));
GDALInfoReportCorner( hDataset, hTransform, "Upper Right",
GDALGetRasterXSize(hDataset), 0.0 );
GDALInfoReportCorner( hDataset, hTransform, "Lower Right",
GDALGetRasterXSize(hDataset),
GDALGetRasterYSize(hDataset) );
GDALInfoReportCorner( hDataset, hTransform, "Center",
GDALGetRasterXSize(hDataset)/2.0,
GDALGetRasterYSize(hDataset)/2.0 );
if( hTransform != NULL )
{
OCTDestroyCoordinateTransformation( hTransform );
hTransform = NULL;
}
/* ==================================================================== */
/* Loop over bands. */
/* ==================================================================== */
for( iBand = 0; iBand < GDALGetRasterCount( hDataset ); iBand++ )
{
double dfMin, dfMax, adfCMinMax[2], dfNoData;
int bGotMin, bGotMax, bGotNodata, bSuccess;
int nBlockXSize, nBlockYSize, nMaskFlags;
double dfMean, dfStdDev;
GDALColorTableH hTable;
CPLErr eErr;
hBand = GDALGetRasterBand( hDataset, iBand+1 );
if( bSample )
{
float afSample[10000];
int nCount;
nCount = GDALGetRandomRasterSample( hBand, 10000, afSample );
printf( "Got %d samples.\n", nCount );
}
GDALGetBlockSize( hBand, &nBlockXSize, &nBlockYSize );
printf( "Band %d Block=%dx%d Type=%s, ColorInterp=%s\n", iBand+1,
nBlockXSize, nBlockYSize,
GDALGetDataTypeName(
GDALGetRasterDataType(hBand)),
GDALGetColorInterpretationName(
GDALGetRasterColorInterpretation(hBand)) );
if( GDALGetDescription( hBand ) != NULL
&& strlen(GDALGetDescription( hBand )) > 0 )
printf( " Description = %s\n", GDALGetDescription(hBand) );
dfMin = GDALGetRasterMinimum( hBand, &bGotMin );
dfMax = GDALGetRasterMaximum( hBand, &bGotMax );
if( bGotMin || bGotMax || bComputeMinMax )
{
printf( " " );
if( bGotMin )
printf( "Min=%.3f ", dfMin );
if( bGotMax )
printf( "Max=%.3f ", dfMax );
if( bComputeMinMax )
{
CPLErrorReset();
GDALComputeRasterMinMax( hBand, FALSE, adfCMinMax );
if (CPLGetLastErrorType() == CE_None)
{
printf( " Computed Min/Max=%.3f,%.3f",
adfCMinMax[0], adfCMinMax[1] );
}
}
printf( "\n" );
}
eErr = GDALGetRasterStatistics( hBand, bApproxStats, bStats,
&dfMin, &dfMax, &dfMean, &dfStdDev );
if( eErr == CE_None )
{
printf( " Minimum=%.3f, Maximum=%.3f, Mean=%.3f, StdDev=%.3f\n",
dfMin, dfMax, dfMean, dfStdDev );
}
if( bReportHistograms )
{
int nBucketCount, *panHistogram = NULL;
eErr = GDALGetDefaultHistogram( hBand, &dfMin, &dfMax,
&nBucketCount, &panHistogram,
TRUE, GDALTermProgress, NULL );
if( eErr == CE_None )
{
int iBucket;
printf( " %d buckets from %g to %g:\n ",
nBucketCount, dfMin, dfMax );
for( iBucket = 0; iBucket < nBucketCount; iBucket++ )
printf( "%d ", panHistogram[iBucket] );
printf( "\n" );
CPLFree( panHistogram );
}
}
if ( bComputeChecksum)
{
printf( " Checksum=%d\n",
GDALChecksumImage(hBand, 0, 0,
GDALGetRasterXSize(hDataset),
GDALGetRasterYSize(hDataset)));
}
dfNoData = GDALGetRasterNoDataValue( hBand, &bGotNodata );
if( bGotNodata )
{
if (CPLIsNan(dfNoData))
printf( " NoData Value=nan\n" );
else
printf( " NoData Value=%.18g\n", dfNoData );
}
if( GDALGetOverviewCount(hBand) > 0 )
{
int iOverview;
printf( " Overviews: " );
for( iOverview = 0;
iOverview < GDALGetOverviewCount(hBand);
iOverview++ )
{
GDALRasterBandH hOverview;
const char *pszResampling = NULL;
if( iOverview != 0 )
printf( ", " );
hOverview = GDALGetOverview( hBand, iOverview );
if (hOverview != NULL)
{
printf( "%dx%d",
GDALGetRasterBandXSize( hOverview ),
GDALGetRasterBandYSize( hOverview ) );
pszResampling =
GDALGetMetadataItem( hOverview, "RESAMPLING", "" );
if( pszResampling != NULL
&& EQUALN(pszResampling,"AVERAGE_BIT2",12) )
printf( "*" );
}
else
printf( "(null)" );
}
printf( "\n" );
if ( bComputeChecksum)
{
printf( " Overviews checksum: " );
for( iOverview = 0;
iOverview < GDALGetOverviewCount(hBand);
iOverview++ )
{
GDALRasterBandH hOverview;
if( iOverview != 0 )
printf( ", " );
hOverview = GDALGetOverview( hBand, iOverview );
if (hOverview)
printf( "%d",
GDALChecksumImage(hOverview, 0, 0,
GDALGetRasterBandXSize(hOverview),
GDALGetRasterBandYSize(hOverview)));
else
printf( "(null)" );
}
printf( "\n" );
}
}
if( GDALHasArbitraryOverviews( hBand ) )
{
printf( " Overviews: arbitrary\n" );
}
nMaskFlags = GDALGetMaskFlags( hBand );
if( (nMaskFlags & (GMF_NODATA|GMF_ALL_VALID)) == 0 )
{
GDALRasterBandH hMaskBand = GDALGetMaskBand(hBand) ;
printf( " Mask Flags: " );
if( nMaskFlags & GMF_PER_DATASET )
printf( "PER_DATASET " );
if( nMaskFlags & GMF_ALPHA )
printf( "ALPHA " );
if( nMaskFlags & GMF_NODATA )
printf( "NODATA " );
if( nMaskFlags & GMF_ALL_VALID )
printf( "ALL_VALID " );
printf( "\n" );
if( hMaskBand != NULL &&
GDALGetOverviewCount(hMaskBand) > 0 )
{
int iOverview;
printf( " Overviews of mask band: " );
for( iOverview = 0;
iOverview < GDALGetOverviewCount(hMaskBand);
iOverview++ )
{
GDALRasterBandH hOverview;
if( iOverview != 0 )
printf( ", " );
hOverview = GDALGetOverview( hMaskBand, iOverview );
printf( "%dx%d",
GDALGetRasterBandXSize( hOverview ),
GDALGetRasterBandYSize( hOverview ) );
}
printf( "\n" );
}
}
if( strlen(GDALGetRasterUnitType(hBand)) > 0 )
{
printf( " Unit Type: %s\n", GDALGetRasterUnitType(hBand) );
}
if( GDALGetRasterCategoryNames(hBand) != NULL )
{
char **papszCategories = GDALGetRasterCategoryNames(hBand);
int i;
printf( " Categories:\n" );
for( i = 0; papszCategories[i] != NULL; i++ )
printf( " %3d: %s\n", i, papszCategories[i] );
}
if( GDALGetRasterScale( hBand, &bSuccess ) != 1.0
|| GDALGetRasterOffset( hBand, &bSuccess ) != 0.0 )
printf( " Offset: %.15g, Scale:%.15g\n",
GDALGetRasterOffset( hBand, &bSuccess ),
GDALGetRasterScale( hBand, &bSuccess ) );
papszMetadata = (bShowMetadata) ? GDALGetMetadata( hBand, NULL ) : NULL;
if( bShowMetadata && CSLCount(papszMetadata) > 0 )
{
printf( " Metadata:\n" );
for( i = 0; papszMetadata[i] != NULL; i++ )
{
printf( " %s\n", papszMetadata[i] );
}
}
papszMetadata = (bShowMetadata) ? GDALGetMetadata( hBand, "IMAGE_STRUCTURE" ) : NULL;
if( bShowMetadata && CSLCount(papszMetadata) > 0 )
{
printf( " Image Structure Metadata:\n" );
for( i = 0; papszMetadata[i] != NULL; i++ )
{
printf( " %s\n", papszMetadata[i] );
}
}
if( GDALGetRasterColorInterpretation(hBand) == GCI_PaletteIndex
&& (hTable = GDALGetRasterColorTable( hBand )) != NULL )
{
int i;
printf( " Color Table (%s with %d entries)\n",
GDALGetPaletteInterpretationName(
GDALGetPaletteInterpretation( hTable )),
GDALGetColorEntryCount( hTable ) );
if (bShowColorTable)
{
for( i = 0; i < GDALGetColorEntryCount( hTable ); i++ )
{
GDALColorEntry sEntry;
GDALGetColorEntryAsRGB( hTable, i, &sEntry );
printf( " %3d: %d,%d,%d,%d\n",
i,
sEntry.c1,
sEntry.c2,
sEntry.c3,
sEntry.c4 );
}
}
}
if( bShowRAT && GDALGetDefaultRAT( hBand ) != NULL )
{
GDALRasterAttributeTableH hRAT = GDALGetDefaultRAT( hBand );
GDALRATDumpReadable( hRAT, NULL );
}
}
GDALClose( hDataset );
CSLDestroy( papszExtraMDDomains );
CSLDestroy( argv );
GDALDumpOpenDatasets( stderr );
GDALDestroyDriverManager();
CPLDumpSharedList( NULL );
CPLCleanupTLS();
exit( 0 );
}
static int msContourLayerGenerateContour(layerObj *layer)
{
OGRSFDriverH hDriver;
OGRFieldDefnH hFld;
OGRLayerH hLayer;
const char *elevItem;
char *option;
double interval = 1.0, levels[1000];
int levelCount = 0;
GDALRasterBandH hBand = NULL;
CPLErr eErr;
contourLayerInfo *clinfo = (contourLayerInfo *) layer->layerinfo;
OGRRegisterAll();
if (clinfo == NULL) {
msSetError(MS_MISCERR, "Assertion failed: Contour layer not opened!!!",
"msContourLayerCreateOGRDataSource()");
return MS_FAILURE;
}
hBand = GDALGetRasterBand(clinfo->hDS, 1);
if (hBand == NULL)
{
msSetError(MS_IMGERR,
"Band %d does not exist on dataset.",
"msContourLayerGenerateContour()", 1);
return MS_FAILURE;
}
/* Create the OGR DataSource */
hDriver = OGRGetDriverByName("Memory");
if (hDriver == NULL) {
msSetError(MS_OGRERR,
"Unable to get OGR driver 'Memory'.",
"msContourLayerCreateOGRDataSource()");
return MS_FAILURE;
}
clinfo->hOGRDS = OGR_Dr_CreateDataSource(hDriver, NULL, NULL);
if (clinfo->hOGRDS == NULL) {
msSetError(MS_OGRERR,
"Unable to create OGR DataSource.",
"msContourLayerCreateOGRDataSource()");
return MS_FAILURE;
}
hLayer = OGR_DS_CreateLayer(clinfo->hOGRDS, clinfo->ogrLayer.name, NULL,
wkbLineString, NULL );
hFld = OGR_Fld_Create("ID", OFTInteger);
OGR_Fld_SetWidth(hFld, 8);
OGR_L_CreateField(hLayer, hFld, FALSE);
OGR_Fld_Destroy(hFld);
/* Check if we have a coutour item specified */
elevItem = CSLFetchNameValue(layer->processing,"CONTOUR_ITEM");
if (elevItem && strlen(elevItem) > 0) {
hFld = OGR_Fld_Create(elevItem, OFTReal);
OGR_Fld_SetWidth(hFld, 12);
OGR_Fld_SetPrecision(hFld, 3);
OGR_L_CreateField(hLayer, hFld, FALSE);
OGR_Fld_Destroy(hFld);
}
else {
elevItem = NULL;
}
option = msContourGetOption(layer, "CONTOUR_INTERVAL");
if (option) {
interval = atof(option);
free(option);
}
option = msContourGetOption(layer, "CONTOUR_LEVELS");
if (option) {
int i,c;
char **levelsTmp;
levelsTmp = CSLTokenizeStringComplex(option, ",", FALSE, FALSE);
c = CSLCount(levelsTmp);
for (i=0;i<c && i<(int)(sizeof(levels)/sizeof(double)) ;++i)
levels[levelCount++] = atof(levelsTmp[i]);
CSLDestroy(levelsTmp);
free(option);
}
eErr = GDALContourGenerate( hBand, interval, 0.0,
levelCount, levels,
FALSE, 0.0, hLayer,
OGR_FD_GetFieldIndex(OGR_L_GetLayerDefn( hLayer),
"ID" ),
(elevItem == NULL) ? -1 :
OGR_FD_GetFieldIndex(OGR_L_GetLayerDefn( hLayer),
elevItem ),
NULL, NULL );
if (eErr != CE_None) {
msSetError( MS_IOERR, "GDALContourGenerate() failed: %s",
"msContourLayerGenerateContour()", CPLGetLastErrorMsg() );
return MS_FAILURE;
}
msConnPoolRegister(&clinfo->ogrLayer, clinfo->hOGRDS, msContourOGRCloseConnection);
return MS_SUCCESS;
}
OGRFeature * OGRCSVLayer::GetNextUnfilteredFeature()
{
if (fpCSV == NULL)
return NULL;
/* -------------------------------------------------------------------- */
/* Read the CSV record. */
/* -------------------------------------------------------------------- */
char **papszTokens;
while(TRUE)
{
papszTokens = OGRCSVReadParseLineL( fpCSV, chDelimiter, bDontHonourStrings );
if( papszTokens == NULL )
return NULL;
if( papszTokens[0] != NULL )
break;
CSLDestroy(papszTokens);
}
/* -------------------------------------------------------------------- */
/* Create the OGR feature. */
/* -------------------------------------------------------------------- */
OGRFeature *poFeature;
poFeature = new OGRFeature( poFeatureDefn );
/* -------------------------------------------------------------------- */
/* Set attributes for any indicated attribute records. */
/* -------------------------------------------------------------------- */
int iAttr;
int nAttrCount = MIN(CSLCount(papszTokens),
poFeatureDefn->GetFieldCount() );
for( iAttr = 0; iAttr < nAttrCount; iAttr++)
{
if( iAttr == iWktGeomReadField && papszTokens[iAttr][0] != '\0' )
{
char *pszWKT = papszTokens[iAttr];
OGRGeometry *poGeom = NULL;
if( OGRGeometryFactory::createFromWkt( &pszWKT, NULL, &poGeom )
== OGRERR_NONE )
poFeature->SetGeometryDirectly( poGeom );
}
if (poFeatureDefn->GetFieldDefn(iAttr)->GetType() == OFTReal)
{
if (papszTokens[iAttr][0] != '\0')
poFeature->SetField( iAttr, CPLAtof(papszTokens[iAttr]) );
}
else if (poFeatureDefn->GetFieldDefn(iAttr)->GetType() != OFTString)
{
if (papszTokens[iAttr][0] != '\0')
poFeature->SetField( iAttr, papszTokens[iAttr] );
}
else
poFeature->SetField( iAttr, papszTokens[iAttr] );
}
/* -------------------------------------------------------------------- */
/*http://www.faa.gov/airports/airport_safety/airportdata_5010/menu/index.cfm specific */
/* -------------------------------------------------------------------- */
if ( iNfdcLatitudeS != -1 &&
iNfdcLongitudeS != -1 &&
nAttrCount > iNfdcLatitudeS &&
nAttrCount > iNfdcLongitudeS &&
papszTokens[iNfdcLongitudeS][0] != 0 &&
papszTokens[iNfdcLatitudeS][0] != 0)
{
double dfLon = atof(papszTokens[iNfdcLongitudeS]) / 3600;
if (strchr(papszTokens[iNfdcLongitudeS], 'W'))
dfLon *= -1;
double dfLat = atof(papszTokens[iNfdcLatitudeS]) / 3600;
if (strchr(papszTokens[iNfdcLatitudeS], 'S'))
dfLat *= -1;
poFeature->SetGeometryDirectly( new OGRPoint(dfLon, dfLat) );
}
/* -------------------------------------------------------------------- */
/* GNIS specific */
/* -------------------------------------------------------------------- */
else if ( iLatitudeField != -1 &&
iLongitudeField != -1 &&
nAttrCount > iLatitudeField &&
nAttrCount > iLongitudeField &&
papszTokens[iLongitudeField][0] != 0 &&
papszTokens[iLatitudeField][0] != 0)
{
/* Some records have dummy 0,0 value */
if (papszTokens[iLongitudeField][0] != '0' ||
papszTokens[iLongitudeField][1] != '\0' ||
papszTokens[iLatitudeField][0] != '0' ||
papszTokens[iLatitudeField][1] != '\0')
{
double dfLon = atof(papszTokens[iLongitudeField]);
double dfLat = atof(papszTokens[iLatitudeField]);
poFeature->SetGeometryDirectly( new OGRPoint(dfLon, dfLat) );
}
}
CSLDestroy( papszTokens );
/* -------------------------------------------------------------------- */
/* Translate the record id. */
/* -------------------------------------------------------------------- */
poFeature->SetFID( nNextFID++ );
m_nFeaturesRead++;
return poFeature;
}
static void
CSV2HTML( const char * pszFilename, int nColumns, int * panColumns,
char ** papszOptions, int bSingletons )
{
FILE *fp;
char **papszFields, **papszFieldNames;
int iCol, nColCount;
/* -------------------------------------------------------------------- */
/* Open the source file. */
/* -------------------------------------------------------------------- */
fp = VSIFOpen( pszFilename, "rt" );
if( fp == NULL )
{
perror( "fopen" );
return;
}
/* -------------------------------------------------------------------- */
/* Read and emit the title line specially. */
/* -------------------------------------------------------------------- */
papszFieldNames = CSVReadParseLine( fp );
nColCount = CSLCount( papszFieldNames );
if( nColumns == 0 )
{
nColumns = nColCount;
panColumns = (int *) CPLMalloc(sizeof(int) * nColCount);
for( iCol = 0; iCol < nColCount; iCol++ )
panColumns[iCol] = iCol;
}
printf( "<table border>\n" );
if( !bSingletons )
{
for( iCol = 0; iCol < nColumns; iCol++ )
{
if( panColumns[iCol] < nColCount )
{
printf( "<th>%s\n", papszFieldNames[panColumns[iCol]] );
}
}
printf( "<tr>\n" );
}
/* -------------------------------------------------------------------- */
/* Read and emit normal records. */
/* -------------------------------------------------------------------- */
while( (papszFields = CSVReadParseLine( fp )) != NULL )
{
int bDisplay=TRUE, i;
nColCount = CSLCount( papszFields );
for( i = 0; papszOptions != NULL && papszOptions[i] != NULL; i++ )
{
if( EQUALN(papszOptions[i],"CODE=",5) )
{
if( atoi(papszOptions[i]+5) != atoi(papszFields[0]) )
bDisplay = FALSE;
}
else if( EQUALN(papszOptions[i],"CODE<",5) )
{
if( atoi(papszOptions[i]+5) <= atoi(papszFields[0]) )
bDisplay = FALSE;
}
else if( EQUALN(papszOptions[i],"CODE>",5) )
{
if( atoi(papszOptions[i]+5) >= atoi(papszFields[0]) )
bDisplay = FALSE;
}
else if( EQUALN(papszOptions[i],"NAMEKEY=",8) )
{
if( strstr(papszFields[1],papszOptions[i]+8) == NULL )
bDisplay = FALSE;
}
}
if( bDisplay )
{
for( iCol = 0; iCol < nColumns; iCol++ )
{
const char *pszSubTable = NULL;
const char *pszFieldName;
if( panColumns[iCol] < 0
|| panColumns[iCol] >= nColCount )
continue;
pszFieldName = papszFieldNames[panColumns[iCol]];
if( bSingletons )
{
printf( "<td>%s\n", pszFieldName );
}
if( EQUAL(pszFieldName,"PRIME_MERIDIAN_CODE") )
pszSubTable = "p_meridian";
else if( EQUAL(pszFieldName,"GEOD_DATUM_CODE") )
pszSubTable = "geod_datum";
else if( EQUAL(pszFieldName,"UOM_LENGTH_CODE") )
pszSubTable = "uom_length";
else if( EQUAL(pszFieldName,"UOM_ANGLE_CODE") )
pszSubTable = "uom_angle";
else if( EQUAL(pszFieldName,"SOURCE_GEOGCS_CODE") )
pszSubTable = "horiz_cs";
else if( EQUAL(pszFieldName,"PROJECTION_TRF_CODE") )
pszSubTable = "trf_nonpolynomial";
else if( EQUAL(pszFieldName,"ELLIPSOID_CODE") )
pszSubTable = "ellipsoid";
else if( EQUAL(pszFieldName,"COORD_TRF_METHOD_CODE") )
pszSubTable = "trf_method";
if( pszSubTable != NULL )
printf( "<td><a href="
"\"/cgi-bin/csv2html/TABLE=%s/CODE=%s/\">"
"%s</a>\n",
pszSubTable,papszFields[panColumns[iCol]],
papszFields[panColumns[iCol]] );
else
printf( "<td>%s\n", papszFields[panColumns[iCol]] );
if( bSingletons )
printf( "<tr>\n" );
}
if( !bSingletons )
printf( "<tr>\n" );
}
CSLDestroy( papszFields );
}
printf( "</table>\n" );
CSLDestroy( papszFieldNames );
VSIFClose( fp );
}
void IDADataset::ReadColorTable()
{
/* -------------------------------------------------------------------- */
/* Decide what .clr file to look for and try to open. */
/* -------------------------------------------------------------------- */
CPLString osCLRFilename;
osCLRFilename = CPLGetConfigOption( "IDA_COLOR_FILE", "" );
if( strlen(osCLRFilename) == 0 )
osCLRFilename = CPLResetExtension(GetDescription(), "clr" );
FILE *fp = VSIFOpen( osCLRFilename, "r" );
if( fp == NULL )
{
osCLRFilename = CPLResetExtension(osCLRFilename, "CLR" );
fp = VSIFOpen( osCLRFilename, "r" );
}
if( fp == NULL )
return;
/* -------------------------------------------------------------------- */
/* Skip first line, with the column titles. */
/* -------------------------------------------------------------------- */
CPLReadLine( fp );
/* -------------------------------------------------------------------- */
/* Create a RAT to populate. */
/* -------------------------------------------------------------------- */
GDALRasterAttributeTable *poRAT = new GDALDefaultRasterAttributeTable();
poRAT->CreateColumn( "FROM", GFT_Integer, GFU_Min );
poRAT->CreateColumn( "TO", GFT_Integer, GFU_Max );
poRAT->CreateColumn( "RED", GFT_Integer, GFU_Red );
poRAT->CreateColumn( "GREEN", GFT_Integer, GFU_Green );
poRAT->CreateColumn( "BLUE", GFT_Integer, GFU_Blue );
poRAT->CreateColumn( "LEGEND", GFT_String, GFU_Name );
/* -------------------------------------------------------------------- */
/* Apply lines. */
/* -------------------------------------------------------------------- */
const char *pszLine = CPLReadLine( fp );
int iRow = 0;
while( pszLine != NULL )
{
char **papszTokens =
CSLTokenizeStringComplex( pszLine, " \t", FALSE, FALSE );
if( CSLCount( papszTokens ) >= 5 )
{
poRAT->SetValue( iRow, 0, atoi(papszTokens[0]) );
poRAT->SetValue( iRow, 1, atoi(papszTokens[1]) );
poRAT->SetValue( iRow, 2, atoi(papszTokens[2]) );
poRAT->SetValue( iRow, 3, atoi(papszTokens[3]) );
poRAT->SetValue( iRow, 4, atoi(papszTokens[4]) );
// find name, first nonspace after 5th token.
const char *pszName = pszLine;
// skip from
while( *pszName == ' ' || *pszName == '\t' )
pszName++;
while( *pszName != ' ' && *pszName != '\t' && *pszName != '\0' )
pszName++;
// skip to
while( *pszName == ' ' || *pszName == '\t' )
pszName++;
while( *pszName != ' ' && *pszName != '\t' && *pszName != '\0' )
pszName++;
// skip red
while( *pszName == ' ' || *pszName == '\t' )
pszName++;
while( *pszName != ' ' && *pszName != '\t' && *pszName != '\0' )
pszName++;
// skip green
while( *pszName == ' ' || *pszName == '\t' )
pszName++;
while( *pszName != ' ' && *pszName != '\t' && *pszName != '\0' )
pszName++;
// skip blue
while( *pszName == ' ' || *pszName == '\t' )
pszName++;
while( *pszName != ' ' && *pszName != '\t' && *pszName != '\0' )
pszName++;
// skip pre-name white space
while( *pszName == ' ' || *pszName == '\t' )
pszName++;
poRAT->SetValue( iRow, 5, pszName );
iRow++;
}
CSLDestroy( papszTokens );
pszLine = CPLReadLine( fp );
}
VSIFClose( fp );
/* -------------------------------------------------------------------- */
/* Attach RAT to band. */
/* -------------------------------------------------------------------- */
((IDARasterBand *) GetRasterBand( 1 ))->poRAT = poRAT;
/* -------------------------------------------------------------------- */
/* Build a conventional color table from this. */
/* -------------------------------------------------------------------- */
((IDARasterBand *) GetRasterBand( 1 ))->poColorTable =
poRAT->TranslateToColorTable();
}
OGRErr OGRSpatialReference::importFromOzi( const char * const* papszLines )
{
int iLine;
const char *pszDatum, *pszProj = NULL, *pszProjParms = NULL;
Clear();
int nLines = CSLCount((char**)papszLines);
if( nLines < 5 )
return OGRERR_NOT_ENOUGH_DATA;
pszDatum = papszLines[4];
for ( iLine = 5; iLine < nLines; iLine++ )
{
if ( STARTS_WITH_CI(papszLines[iLine], "Map Projection") )
{
pszProj = papszLines[iLine];
}
else if ( STARTS_WITH_CI(papszLines[iLine], "Projection Setup") )
{
pszProjParms = papszLines[iLine];
}
}
if ( ! ( pszDatum && pszProj && pszProjParms ) )
return OGRERR_NOT_ENOUGH_DATA;
/* -------------------------------------------------------------------- */
/* Operate on the basis of the projection name. */
/* -------------------------------------------------------------------- */
char **papszProj = CSLTokenizeStringComplex( pszProj, ",", TRUE, TRUE );
char **papszProjParms = CSLTokenizeStringComplex( pszProjParms, ",",
TRUE, TRUE );
char **papszDatum = NULL;
if (CSLCount(papszProj) < 2)
{
goto not_enough_data;
}
if ( STARTS_WITH_CI(papszProj[1], "Latitude/Longitude") )
{
}
else if ( STARTS_WITH_CI(papszProj[1], "Mercator") )
{
if (CSLCount(papszProjParms) < 6) goto not_enough_data;
double dfScale = CPLAtof(papszProjParms[3]);
if (papszProjParms[3][0] == 0) dfScale = 1; /* if unset, default to scale = 1 */
SetMercator( CPLAtof(papszProjParms[1]), CPLAtof(papszProjParms[2]),
dfScale,
CPLAtof(papszProjParms[4]), CPLAtof(papszProjParms[5]) );
}
else if ( STARTS_WITH_CI(papszProj[1], "Transverse Mercator") )
{
if (CSLCount(papszProjParms) < 6) goto not_enough_data;
SetTM( CPLAtof(papszProjParms[1]), CPLAtof(papszProjParms[2]),
CPLAtof(papszProjParms[3]),
CPLAtof(papszProjParms[4]), CPLAtof(papszProjParms[5]) );
}
else if ( STARTS_WITH_CI(papszProj[1], "Lambert Conformal Conic") )
{
if (CSLCount(papszProjParms) < 8) goto not_enough_data;
SetLCC( CPLAtof(papszProjParms[6]), CPLAtof(papszProjParms[7]),
CPLAtof(papszProjParms[1]), CPLAtof(papszProjParms[2]),
CPLAtof(papszProjParms[4]), CPLAtof(papszProjParms[5]) );
}
else if ( STARTS_WITH_CI(papszProj[1], "Sinusoidal") )
{
if (CSLCount(papszProjParms) < 6) goto not_enough_data;
SetSinusoidal( CPLAtof(papszProjParms[2]),
CPLAtof(papszProjParms[4]), CPLAtof(papszProjParms[5]) );
}
else if ( STARTS_WITH_CI(papszProj[1], "Albers Equal Area") )
{
if (CSLCount(papszProjParms) < 8) goto not_enough_data;
SetACEA( CPLAtof(papszProjParms[6]), CPLAtof(papszProjParms[7]),
CPLAtof(papszProjParms[1]), CPLAtof(papszProjParms[2]),
CPLAtof(papszProjParms[4]), CPLAtof(papszProjParms[5]) );
}
else if ( STARTS_WITH_CI(papszProj[1], "(UTM) Universal Transverse Mercator") && nLines > 5 )
{
/* Look for the UTM zone in the calibration point data */
for ( iLine = 5; iLine < nLines; iLine++ )
{
if ( STARTS_WITH_CI(papszLines[iLine], "Point") )
{
char **papszTok = NULL;
papszTok = CSLTokenizeString2( papszLines[iLine], ",",
CSLT_ALLOWEMPTYTOKENS
| CSLT_STRIPLEADSPACES
| CSLT_STRIPENDSPACES );
if ( CSLCount(papszTok) < 17
|| EQUAL(papszTok[2], "")
|| EQUAL(papszTok[13], "")
|| EQUAL(papszTok[14], "")
|| EQUAL(papszTok[15], "")
|| EQUAL(papszTok[16], "") )
{
CSLDestroy(papszTok);
continue;
}
SetUTM( atoi(papszTok[13]), EQUAL(papszTok[16], "N") );
CSLDestroy(papszTok);
break;
}
}
if ( iLine == nLines ) /* Try to guess the UTM zone */
{
float fMinLongitude = 1000.0f;
float fMaxLongitude = -1000.0f;;
float fMinLatitude = 1000.0f;
float fMaxLatitude = -1000.0f;
bool bFoundMMPLL = false;
for ( iLine = 5; iLine < nLines; iLine++ )
{
if ( STARTS_WITH_CI(papszLines[iLine], "MMPLL") )
{
char **papszTok = NULL;
papszTok = CSLTokenizeString2( papszLines[iLine], ",",
CSLT_ALLOWEMPTYTOKENS
| CSLT_STRIPLEADSPACES
| CSLT_STRIPENDSPACES );
if ( CSLCount(papszTok) < 4 )
{
CSLDestroy(papszTok);
continue;
}
float fLongitude = static_cast<float>(CPLAtofM(papszTok[2]));
float fLatitude = static_cast<float>(CPLAtofM(papszTok[3]));
CSLDestroy(papszTok);
bFoundMMPLL = true;
if ( fMinLongitude > fLongitude )
fMinLongitude = fLongitude;
if ( fMaxLongitude < fLongitude )
fMaxLongitude = fLongitude;
if ( fMinLatitude > fLatitude )
fMinLatitude = fLatitude;
if ( fMaxLatitude < fLatitude )
fMaxLatitude = fLatitude;
}
}
float fMedianLatitude = ( fMinLatitude + fMaxLatitude ) / 2;
float fMedianLongitude = ( fMinLongitude + fMaxLongitude ) / 2;
if ( bFoundMMPLL && fMaxLatitude <= 90 )
{
int nUtmZone;
if ( fMedianLatitude >= 56 && fMedianLatitude <= 64 &&
fMedianLongitude >= 3 && fMedianLongitude <= 12 )
nUtmZone = 32; /* Norway exception */
else if ( fMedianLatitude >= 72 && fMedianLatitude <= 84 &&
fMedianLongitude >= 0 && fMedianLongitude <= 42 )
nUtmZone = (int) ((fMedianLongitude + 3 ) / 12) * 2 + 31; /* Svalbard exception */
else
nUtmZone = (int) ((fMedianLongitude + 180 ) / 6) + 1;
SetUTM( nUtmZone, fMedianLatitude >= 0 );
}
else
CPLDebug( "OSR_Ozi", "UTM Zone not found");
}
}
else if ( STARTS_WITH_CI(papszProj[1], "(I) France Zone I") )
{
SetLCC1SP( 49.5, 2.337229167, 0.99987734, 600000, 1200000 );
}
else if ( STARTS_WITH_CI(papszProj[1], "(II) France Zone II") )
{
SetLCC1SP( 46.8, 2.337229167, 0.99987742, 600000, 2200000 );
}
else if ( STARTS_WITH_CI(papszProj[1], "(III) France Zone III") )
{
SetLCC1SP( 44.1, 2.337229167, 0.99987750, 600000, 3200000 );
}
else if ( STARTS_WITH_CI(papszProj[1], "(IV) France Zone IV") )
{
SetLCC1SP( 42.165, 2.337229167, 0.99994471, 234.358, 4185861.369 );
}
/*
* Note : The following projections have not been implemented yet
*
*/
/*
else if ( STARTS_WITH_CI(papszProj[1], "(BNG) British National Grid") )
{
}
else if ( STARTS_WITH_CI(papszProj[1], "(IG) Irish Grid") )
{
}
else if ( STARTS_WITH_CI(papszProj[1], "(NZG) New Zealand Grid") )
{
}
else if ( STARTS_WITH_CI(papszProj[1], "(NZTM2) New Zealand TM 2000") )
{
}
else if ( STARTS_WITH_CI(papszProj[1], "(SG) Swedish Grid") )
{
}
else if ( STARTS_WITH_CI(papszProj[1], "(SUI) Swiss Grid") )
{
}
else if ( STARTS_WITH_CI(papszProj[1], "(A)Lambert Azimuthual Equal Area") )
{
}
else if ( STARTS_WITH_CI(papszProj[1], "(EQC) Equidistant Conic") )
{
}
else if ( STARTS_WITH_CI(papszProj[1], "Polyconic (American)") )
{
}
else if ( STARTS_WITH_CI(papszProj[1], "Van Der Grinten") )
{
}
else if ( STARTS_WITH_CI(papszProj[1], "Vertical Near-Sided Perspective") )
{
}
else if ( STARTS_WITH_CI(papszProj[1], "(WIV) Wagner IV") )
{
}
else if ( STARTS_WITH_CI(papszProj[1], "Bonne") )
{
}
else if ( STARTS_WITH_CI(papszProj[1], "(MT0) Montana State Plane Zone 2500") )
{
}
else if ( STARTS_WITH_CI(papszProj[1], "ITA1) Italy Grid Zone 1") )
{
}
else if ( STARTS_WITH_CI(papszProj[1], "ITA2) Italy Grid Zone 2") )
{
}
else if ( STARTS_WITH_CI(papszProj[1], "(VICMAP-TM) Victoria Aust.(pseudo AMG)") )
{
}
else if ( STARTS_WITH_CI(papszProj[1], "VICGRID) Victoria Australia") )
{
}
else if ( STARTS_WITH_CI(papszProj[1], "(VG94) VICGRID94 Victoria Australia") )
{
}
else if ( STARTS_WITH_CI(papszProj[1], "Gnomonic") )
{
}
*/
else
{
CPLDebug( "OSR_Ozi", "Unsupported projection: \"%s\"", papszProj[1] );
SetLocalCS( CPLString().Printf("\"Ozi\" projection \"%s\"",
papszProj[1]) );
}
/* -------------------------------------------------------------------- */
/* Try to translate the datum/spheroid. */
/* -------------------------------------------------------------------- */
papszDatum = CSLTokenizeString2( pszDatum, ",",
CSLT_ALLOWEMPTYTOKENS
| CSLT_STRIPLEADSPACES
| CSLT_STRIPENDSPACES );
if ( papszDatum == NULL)
goto not_enough_data;
if ( !IsLocal() )
{
/* -------------------------------------------------------------------- */
/* Verify that we can find the CSV file containing the datums */
/* -------------------------------------------------------------------- */
if( CSVScanFileByName( CSVFilename( "ozi_datum.csv" ),
"EPSG_DATUM_CODE",
"4326", CC_Integer ) == NULL )
{
CPLError( CE_Failure, CPLE_OpenFailed,
"Unable to open OZI support file %s.\n"
"Try setting the GDAL_DATA environment variable to point\n"
"to the directory containing OZI csv files.",
CSVFilename( "ozi_datum.csv" ) );
goto other_error;
}
/* -------------------------------------------------------------------- */
/* Search for matching datum */
/* -------------------------------------------------------------------- */
const char *pszOziDatum = CSVFilename( "ozi_datum.csv" );
CPLString osDName = CSVGetField( pszOziDatum, "NAME", papszDatum[0],
CC_ApproxString, "NAME" );
if( strlen(osDName) == 0 )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Failed to find datum %s in ozi_datum.csv.",
papszDatum[0] );
goto other_error;
}
int nDatumCode = atoi( CSVGetField( pszOziDatum, "NAME", papszDatum[0],
CC_ApproxString, "EPSG_DATUM_CODE" ) );
if ( nDatumCode > 0 ) // There is a matching EPSG code
{
OGRSpatialReference oGCS;
oGCS.importFromEPSG( nDatumCode );
CopyGeogCSFrom( &oGCS );
}
else // We use the parameters from the CSV files
{
CPLString osEllipseCode = CSVGetField( pszOziDatum, "NAME", papszDatum[0],
CC_ApproxString, "ELLIPSOID_CODE" );
double dfDeltaX = CPLAtof(CSVGetField( pszOziDatum, "NAME", papszDatum[0],
CC_ApproxString, "DELTAX" ) );
double dfDeltaY = CPLAtof(CSVGetField( pszOziDatum, "NAME", papszDatum[0],
CC_ApproxString, "DELTAY" ) );
double dfDeltaZ = CPLAtof(CSVGetField( pszOziDatum, "NAME", papszDatum[0],
CC_ApproxString, "DELTAZ" ) );
/* -------------------------------------------------------------------- */
/* Verify that we can find the CSV file containing the ellipsoids */
/* -------------------------------------------------------------------- */
if( CSVScanFileByName( CSVFilename( "ozi_ellips.csv" ),
"ELLIPSOID_CODE",
"20", CC_Integer ) == NULL )
{
CPLError( CE_Failure, CPLE_OpenFailed,
"Unable to open OZI support file %s.\n"
"Try setting the GDAL_DATA environment variable to point\n"
"to the directory containing OZI csv files.",
CSVFilename( "ozi_ellips.csv" ) );
goto other_error;
}
/* -------------------------------------------------------------------- */
/* Lookup the ellipse code. */
/* -------------------------------------------------------------------- */
const char *pszOziEllipse = CSVFilename( "ozi_ellips.csv" );
CPLString osEName = CSVGetField( pszOziEllipse, "ELLIPSOID_CODE", osEllipseCode,
CC_ApproxString, "NAME" );
if( strlen(osEName) == 0 )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Failed to find ellipsoid %s in ozi_ellips.csv.",
osEllipseCode.c_str() );
goto other_error;
}
double dfA = CPLAtof(CSVGetField( pszOziEllipse, "ELLIPSOID_CODE", osEllipseCode,
CC_ApproxString, "A" ));
double dfInvF = CPLAtof(CSVGetField( pszOziEllipse, "ELLIPSOID_CODE", osEllipseCode,
CC_ApproxString, "INVF" ));
/* -------------------------------------------------------------------- */
/* Create geographic coordinate system. */
/* -------------------------------------------------------------------- */
SetGeogCS( osDName, osDName, osEName, dfA, dfInvF );
SetTOWGS84( dfDeltaX, dfDeltaY, dfDeltaZ );
}
}
/* -------------------------------------------------------------------- */
/* Grid units translation */
/* -------------------------------------------------------------------- */
if( IsLocal() || IsProjected() )
SetLinearUnits( SRS_UL_METER, 1.0 );
FixupOrdering();
CSLDestroy(papszProj);
CSLDestroy(papszProjParms);
CSLDestroy(papszDatum);
return OGRERR_NONE;
not_enough_data:
CSLDestroy(papszProj);
CSLDestroy(papszProjParms);
CSLDestroy(papszDatum);
return OGRERR_NOT_ENOUGH_DATA;
other_error:
CSLDestroy(papszProj);
CSLDestroy(papszProjParms);
CSLDestroy(papszDatum);
return OGRERR_FAILURE;
}
CPLErr VRTDataset::XMLInit( CPLXMLNode *psTree, const char *pszVRTPath )
{
if( pszVRTPath != NULL )
this->pszVRTPath = CPLStrdup(pszVRTPath);
/* -------------------------------------------------------------------- */
/* Check for an SRS node. */
/* -------------------------------------------------------------------- */
if( strlen(CPLGetXMLValue(psTree, "SRS", "")) > 0 )
{
OGRSpatialReference oSRS;
CPLFree( pszProjection );
pszProjection = NULL;
if( oSRS.SetFromUserInput( CPLGetXMLValue(psTree, "SRS", "") )
== OGRERR_NONE )
oSRS.exportToWkt( &pszProjection );
}
/* -------------------------------------------------------------------- */
/* Check for a GeoTransform node. */
/* -------------------------------------------------------------------- */
if( strlen(CPLGetXMLValue(psTree, "GeoTransform", "")) > 0 )
{
const char *pszGT = CPLGetXMLValue(psTree, "GeoTransform", "");
char **papszTokens;
papszTokens = CSLTokenizeStringComplex( pszGT, ",", FALSE, FALSE );
if( CSLCount(papszTokens) != 6 )
{
CPLError( CE_Warning, CPLE_AppDefined,
"GeoTransform node does not have expected six values.");
}
else
{
for( int iTA = 0; iTA < 6; iTA++ )
adfGeoTransform[iTA] = atof(papszTokens[iTA]);
bGeoTransformSet = TRUE;
}
CSLDestroy( papszTokens );
}
/* -------------------------------------------------------------------- */
/* Check for GCPs. */
/* -------------------------------------------------------------------- */
CPLXMLNode *psGCPList = CPLGetXMLNode( psTree, "GCPList" );
if( psGCPList != NULL )
{
CPLXMLNode *psXMLGCP;
OGRSpatialReference oSRS;
const char *pszRawProj = CPLGetXMLValue(psGCPList, "Projection", "");
CPLFree( pszGCPProjection );
if( strlen(pszRawProj) > 0
&& oSRS.SetFromUserInput( pszRawProj ) == OGRERR_NONE )
oSRS.exportToWkt( &pszGCPProjection );
else
pszGCPProjection = CPLStrdup("");
// Count GCPs.
int nGCPMax = 0;
for( psXMLGCP = psGCPList->psChild; psXMLGCP != NULL;
psXMLGCP = psXMLGCP->psNext )
nGCPMax++;
pasGCPList = (GDAL_GCP *) CPLCalloc(sizeof(GDAL_GCP),nGCPMax);
for( psXMLGCP = psGCPList->psChild; psXMLGCP != NULL;
psXMLGCP = psXMLGCP->psNext )
{
GDAL_GCP *psGCP = pasGCPList + nGCPCount;
if( !EQUAL(psXMLGCP->pszValue,"GCP") ||
psXMLGCP->eType != CXT_Element )
continue;
GDALInitGCPs( 1, psGCP );
CPLFree( psGCP->pszId );
psGCP->pszId = CPLStrdup(CPLGetXMLValue(psXMLGCP,"Id",""));
CPLFree( psGCP->pszInfo );
psGCP->pszInfo = CPLStrdup(CPLGetXMLValue(psXMLGCP,"Info",""));
psGCP->dfGCPPixel = atof(CPLGetXMLValue(psXMLGCP,"Pixel","0.0"));
psGCP->dfGCPLine = atof(CPLGetXMLValue(psXMLGCP,"Line","0.0"));
psGCP->dfGCPX = atof(CPLGetXMLValue(psXMLGCP,"X","0.0"));
psGCP->dfGCPY = atof(CPLGetXMLValue(psXMLGCP,"Y","0.0"));
psGCP->dfGCPZ = atof(CPLGetXMLValue(psXMLGCP,"Z","0.0"));
nGCPCount++;
}
}
/* -------------------------------------------------------------------- */
/* Apply any dataset level metadata. */
/* -------------------------------------------------------------------- */
oMDMD.XMLInit( psTree, TRUE );
/* -------------------------------------------------------------------- */
/* Create dataset mask band. */
/* -------------------------------------------------------------------- */
CPLXMLNode *psChild;
/* Parse dataset mask band first */
CPLXMLNode* psMaskBandNode = CPLGetXMLNode(psTree, "MaskBand");
if (psMaskBandNode)
psChild = psMaskBandNode->psChild;
else
psChild = NULL;
for( ; psChild != NULL; psChild=psChild->psNext )
{
if( psChild->eType == CXT_Element
&& EQUAL(psChild->pszValue,"VRTRasterBand") )
{
VRTRasterBand *poBand = NULL;
const char *pszSubclass = CPLGetXMLValue( psChild, "subclass",
"VRTSourcedRasterBand" );
if( EQUAL(pszSubclass,"VRTSourcedRasterBand") )
poBand = new VRTSourcedRasterBand( this, 0 );
else if( EQUAL(pszSubclass, "VRTDerivedRasterBand") )
poBand = new VRTDerivedRasterBand( this, 0 );
else if( EQUAL(pszSubclass, "VRTRawRasterBand") )
poBand = new VRTRawRasterBand( this, 0 );
else if( EQUAL(pszSubclass, "VRTWarpedRasterBand") )
poBand = new VRTWarpedRasterBand( this, 0 );
else
CPLError( CE_Failure, CPLE_AppDefined,
"VRTRasterBand of unrecognised subclass '%s'.",
pszSubclass );
if( poBand != NULL
&& poBand->XMLInit( psChild, pszVRTPath ) == CE_None )
{
SetMaskBand(poBand);
break;
}
else
{
if( poBand )
delete poBand;
return CE_Failure;
}
}
}
/* -------------------------------------------------------------------- */
/* Create band information objects. */
/* -------------------------------------------------------------------- */
int nBands = 0;
for( psChild=psTree->psChild; psChild != NULL; psChild=psChild->psNext )
{
if( psChild->eType == CXT_Element
&& EQUAL(psChild->pszValue,"VRTRasterBand") )
{
VRTRasterBand *poBand = NULL;
const char *pszSubclass = CPLGetXMLValue( psChild, "subclass",
"VRTSourcedRasterBand" );
if( EQUAL(pszSubclass,"VRTSourcedRasterBand") )
poBand = new VRTSourcedRasterBand( this, nBands+1 );
else if( EQUAL(pszSubclass, "VRTDerivedRasterBand") )
poBand = new VRTDerivedRasterBand( this, nBands+1 );
else if( EQUAL(pszSubclass, "VRTRawRasterBand") )
poBand = new VRTRawRasterBand( this, nBands+1 );
else if( EQUAL(pszSubclass, "VRTWarpedRasterBand") )
poBand = new VRTWarpedRasterBand( this, nBands+1 );
else
CPLError( CE_Failure, CPLE_AppDefined,
"VRTRasterBand of unrecognised subclass '%s'.",
pszSubclass );
if( poBand != NULL
&& poBand->XMLInit( psChild, pszVRTPath ) == CE_None )
{
SetBand( ++nBands, poBand );
}
else
{
if( poBand )
delete poBand;
return CE_Failure;
}
}
}
return CE_None;
}
CPLString
OGRDXFWriterLayer::PrepareLineTypeDefinition( CPL_UNUSED OGRFeature *poFeature,
OGRStyleTool *poTool )
{
CPLString osDef;
OGRStylePen *poPen = (OGRStylePen *) poTool;
GBool bDefault;
const char *pszPattern;
/* -------------------------------------------------------------------- */
/* Fetch pattern. */
/* -------------------------------------------------------------------- */
pszPattern = poPen->Pattern( bDefault );
if( bDefault || strlen(pszPattern) == 0 )
return "";
/* -------------------------------------------------------------------- */
/* Split into pen up / pen down bits. */
/* -------------------------------------------------------------------- */
char **papszTokens = CSLTokenizeString(pszPattern);
int i;
double dfTotalLength = 0;
for( i = 0; papszTokens != NULL && papszTokens[i] != NULL; i++ )
{
const char *pszToken = papszTokens[i];
const char *pszUnit;
CPLString osAmount;
CPLString osDXFEntry;
// Split amount and unit.
for( pszUnit = pszToken;
strchr( "0123456789.", *pszUnit) != NULL;
pszUnit++ ) {}
osAmount.assign(pszToken,(int) (pszUnit-pszToken));
// If the unit is other than 'g' we really should be trying to
// do some type of transformation - but what to do? Pretty hard.
//
// Even entries are "pen down" represented as negative in DXF.
if( i%2 == 0 )
osDXFEntry.Printf( " 49\n-%s\n 74\n0\n", osAmount.c_str() );
else
osDXFEntry.Printf( " 49\n%s\n 74\n0\n", osAmount.c_str() );
osDef += osDXFEntry;
dfTotalLength += CPLAtof(osAmount);
}
/* -------------------------------------------------------------------- */
/* Prefix 73 and 40 items to the definition. */
/* -------------------------------------------------------------------- */
CPLString osPrefix;
osPrefix.Printf( " 73\n%d\n 40\n%.6g\n",
CSLCount(papszTokens),
dfTotalLength );
osDef = osPrefix + osDef;
CSLDestroy( papszTokens );
return osDef;
}
GDALDataset *
RasterliteCreateCopy( const char * pszFilename, GDALDataset *poSrcDS,
CPL_UNUSED int bStrict,
char ** papszOptions,
GDALProgressFunc pfnProgress, void * pProgressData )
{
int nBands = poSrcDS->GetRasterCount();
if (nBands == 0)
{
CPLError(CE_Failure, CPLE_NotSupported, "nBands == 0");
return NULL;
}
const char* pszDriverName = CSLFetchNameValueDef(papszOptions, "DRIVER", "GTiff");
if (EQUAL(pszDriverName, "MEM") || EQUAL(pszDriverName, "VRT"))
{
CPLError(CE_Failure, CPLE_AppDefined, "GDAL %s driver cannot be used as underlying driver",
pszDriverName);
return NULL;
}
GDALDriverH hTileDriver = GDALGetDriverByName(pszDriverName);
if ( hTileDriver == NULL)
{
CPLError(CE_Failure, CPLE_AppDefined, "Cannot load GDAL %s driver", pszDriverName);
return NULL;
}
GDALDriverH hMemDriver = GDALGetDriverByName("MEM");
if (hMemDriver == NULL)
{
CPLError(CE_Failure, CPLE_AppDefined, "Cannot load GDAL MEM driver");
return NULL;
}
int nXSize = GDALGetRasterXSize(poSrcDS);
int nYSize = GDALGetRasterYSize(poSrcDS);
double adfGeoTransform[6];
if (poSrcDS->GetGeoTransform(adfGeoTransform) != CE_None)
{
adfGeoTransform[0] = 0;
adfGeoTransform[1] = 1;
adfGeoTransform[2] = 0;
adfGeoTransform[3] = 0;
adfGeoTransform[4] = 0;
adfGeoTransform[5] = -1;
}
else if (adfGeoTransform[2] != 0.0 || adfGeoTransform[4] != 0.0)
{
CPLError(CE_Failure, CPLE_AppDefined, "Cannot use geotransform with rotational terms");
return NULL;
}
int bTiled = CSLTestBoolean(CSLFetchNameValueDef(papszOptions, "TILED", "YES"));
int nBlockXSize, nBlockYSize;
if (bTiled)
{
nBlockXSize = atoi(CSLFetchNameValueDef(papszOptions, "BLOCKXSIZE", "256"));
nBlockYSize = atoi(CSLFetchNameValueDef(papszOptions, "BLOCKYSIZE", "256"));
if (nBlockXSize < 64) nBlockXSize = 64;
else if (nBlockXSize > 4096) nBlockXSize = 4096;
if (nBlockYSize < 64) nBlockYSize = 64;
else if (nBlockYSize > 4096) nBlockYSize = 4096;
}
else
{
nBlockXSize = nXSize;
nBlockYSize = nYSize;
}
/* -------------------------------------------------------------------- */
/* Analyze arguments */
/* -------------------------------------------------------------------- */
CPLString osDBName;
CPLString osTableName;
VSIStatBuf sBuf;
int bExists;
/* Skip optionnal RASTERLITE: prefix */
const char* pszFilenameWithoutPrefix = pszFilename;
if (EQUALN(pszFilename, "RASTERLITE:", 11))
pszFilenameWithoutPrefix += 11;
char** papszTokens = CSLTokenizeStringComplex(
pszFilenameWithoutPrefix, ",", FALSE, FALSE );
int nTokens = CSLCount(papszTokens);
if (nTokens == 0)
{
osDBName = pszFilenameWithoutPrefix;
osTableName = CPLGetBasename(pszFilenameWithoutPrefix);
}
else
{
osDBName = papszTokens[0];
int i;
for(i=1;i<nTokens;i++)
{
if (EQUALN(papszTokens[i], "table=", 6))
osTableName = papszTokens[i] + 6;
else
{
CPLError(CE_Warning, CPLE_AppDefined,
"Invalid option : %s", papszTokens[i]);
}
}
}
CSLDestroy(papszTokens);
papszTokens = NULL;
bExists = (VSIStat(osDBName.c_str(), &sBuf) == 0);
if (osTableName.size() == 0)
{
if (bExists)
{
CPLError(CE_Failure, CPLE_AppDefined,
"Database already exists. Explicit table name must be specified");
return NULL;
}
osTableName = CPLGetBasename(osDBName.c_str());
}
CPLString osRasterLayer;
osRasterLayer.Printf("%s_rasters", osTableName.c_str());
CPLString osMetatadataLayer;
osMetatadataLayer.Printf("%s_metadata", osTableName.c_str());
/* -------------------------------------------------------------------- */
/* Create or open the SQLite DB */
/* -------------------------------------------------------------------- */
if (OGRGetDriverCount() == 0)
OGRRegisterAll();
OGRSFDriverH hSQLiteDriver = OGRGetDriverByName("SQLite");
if (hSQLiteDriver == NULL)
{
CPLError(CE_Failure, CPLE_AppDefined, "Cannot load OGR SQLite driver");
return NULL;
}
OGRDataSourceH hDS;
if (!bExists)
{
char** papszOGROptions = CSLAddString(NULL, "SPATIALITE=YES");
hDS = OGR_Dr_CreateDataSource(hSQLiteDriver,
osDBName.c_str(), papszOGROptions);
CSLDestroy(papszOGROptions);
}
else
{
hDS = RasterliteOpenSQLiteDB(osDBName.c_str(), GA_Update);
}
if (hDS == NULL)
{
CPLError(CE_Failure, CPLE_AppDefined,
"Cannot load or create SQLite database");
return NULL;
}
CPLString osSQL;
/* -------------------------------------------------------------------- */
/* Get the SRID for the SRS */
/* -------------------------------------------------------------------- */
int nSRSId = RasterliteInsertSRID(hDS, poSrcDS->GetProjectionRef());
/* -------------------------------------------------------------------- */
/* Create or wipe existing tables */
/* -------------------------------------------------------------------- */
int bWipeExistingData =
CSLTestBoolean(CSLFetchNameValueDef(papszOptions, "WIPE", "NO"));
hDS = RasterliteCreateTables(hDS, osTableName.c_str(),
nSRSId, bWipeExistingData);
if (hDS == NULL)
return NULL;
OGRLayerH hRasterLayer = OGR_DS_GetLayerByName(hDS, osRasterLayer.c_str());
OGRLayerH hMetadataLayer = OGR_DS_GetLayerByName(hDS, osMetatadataLayer.c_str());
if (hRasterLayer == NULL || hMetadataLayer == NULL)
{
CPLError(CE_Failure, CPLE_AppDefined,
"Cannot find metadata and/or raster tables");
OGRReleaseDataSource(hDS);
return NULL;
}
/* -------------------------------------------------------------------- */
/* Check if there is overlapping data and warn the user */
/* -------------------------------------------------------------------- */
double minx = adfGeoTransform[0];
double maxx = adfGeoTransform[0] + nXSize * adfGeoTransform[1];
double maxy = adfGeoTransform[3];
double miny = adfGeoTransform[3] + nYSize * adfGeoTransform[5];
osSQL.Printf("SELECT COUNT(geometry) FROM \"%s\" "
"WHERE rowid IN "
"(SELECT pkid FROM \"idx_%s_metadata_geometry\" "
"WHERE %s) AND %s",
osMetatadataLayer.c_str(),
osTableName.c_str(),
RasterliteGetSpatialFilterCond(minx, miny, maxx, maxy).c_str(),
RasterliteGetPixelSizeCond(adfGeoTransform[1], -adfGeoTransform[5]).c_str());
int nOverlappingGeoms = 0;
OGRLayerH hCountLyr = OGR_DS_ExecuteSQL(hDS, osSQL.c_str(), NULL, NULL);
if (hCountLyr)
{
OGRFeatureH hFeat = OGR_L_GetNextFeature(hCountLyr);
if (hFeat)
{
nOverlappingGeoms = OGR_F_GetFieldAsInteger(hFeat, 0);
OGR_F_Destroy(hFeat);
}
OGR_DS_ReleaseResultSet(hDS, hCountLyr);
}
if (nOverlappingGeoms != 0)
{
CPLError(CE_Warning, CPLE_AppDefined,
"Raster tiles already exist in the %s table within "
"the extent of the data to be inserted in",
osTableName.c_str());
}
/* -------------------------------------------------------------------- */
/* Iterate over blocks to add data into raster and metadata tables */
/* -------------------------------------------------------------------- */
int nXBlocks = (nXSize + nBlockXSize - 1) / nBlockXSize;
int nYBlocks = (nYSize + nBlockYSize - 1) / nBlockYSize;
GDALDataType eDataType = poSrcDS->GetRasterBand(1)->GetRasterDataType();
int nDataTypeSize = GDALGetDataTypeSize(eDataType) / 8;
GByte* pabyMEMDSBuffer =
(GByte*)VSIMalloc3(nBlockXSize, nBlockYSize, nBands * nDataTypeSize);
if (pabyMEMDSBuffer == NULL)
{
OGRReleaseDataSource(hDS);
return NULL;
}
CPLString osTempFileName;
osTempFileName.Printf("/vsimem/%p", hDS);
int nTileId = 0;
int nBlocks = 0;
int nTotalBlocks = nXBlocks * nYBlocks;
char** papszTileDriverOptions = RasterliteGetTileDriverOptions(papszOptions);
OGR_DS_ExecuteSQL(hDS, "BEGIN", NULL, NULL);
CPLErr eErr = CE_None;
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 > nXSize)
nReqXSize = nXSize - nBlockXOff * nBlockXSize;
if ((nBlockYOff+1) * nBlockYSize > nYSize)
nReqYSize = nYSize - nBlockYOff * nBlockYSize;
eErr = poSrcDS->RasterIO(GF_Read,
nBlockXOff * nBlockXSize,
nBlockYOff * nBlockYSize,
nReqXSize, nReqYSize,
pabyMEMDSBuffer, nReqXSize, nReqYSize,
eDataType, nBands, NULL,
0, 0, 0, NULL);
if (eErr != CE_None)
{
break;
}
GDALDatasetH hMemDS = GDALCreate(hMemDriver, "MEM:::",
nReqXSize, nReqYSize, 0,
eDataType, NULL);
if (hMemDS == NULL)
{
eErr = CE_Failure;
break;
}
int iBand;
for(iBand = 0; iBand < nBands; iBand ++)
{
char** papszMEMDSOptions = NULL;
char szTmp[64];
memset(szTmp, 0, sizeof(szTmp));
CPLPrintPointer(szTmp,
pabyMEMDSBuffer + iBand * nDataTypeSize *
nReqXSize * nReqYSize, sizeof(szTmp));
papszMEMDSOptions = CSLSetNameValue(papszMEMDSOptions, "DATAPOINTER", szTmp);
GDALAddBand(hMemDS, eDataType, papszMEMDSOptions);
CSLDestroy(papszMEMDSOptions);
}
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 = 0;
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, GDALGetDescription(poSrcDS));
OGR_F_SetFieldInteger(hFeat, 1, nTileId ++);
OGR_F_SetFieldInteger(hFeat, 2, nReqXSize);
OGR_F_SetFieldInteger(hFeat, 3, nReqYSize);
OGR_F_SetFieldDouble(hFeat, 4, adfGeoTransform[1]);
OGR_F_SetFieldDouble(hFeat, 5, -adfGeoTransform[5]);
minx = adfGeoTransform[0] +
(nBlockXSize * nBlockXOff) * adfGeoTransform[1];
maxx = adfGeoTransform[0] +
(nBlockXSize * nBlockXOff + nReqXSize) * adfGeoTransform[1];
maxy = adfGeoTransform[3] +
(nBlockYSize * nBlockYOff) * adfGeoTransform[5];
miny = adfGeoTransform[3] +
(nBlockYSize * nBlockYOff + nReqYSize) * adfGeoTransform[5];
OGRGeometryH hRectangle = OGR_G_CreateGeometry(wkbPolygon);
OGRGeometryH hLinearRing = OGR_G_CreateGeometry(wkbLinearRing);
OGR_G_AddPoint_2D(hLinearRing, minx, miny);
OGR_G_AddPoint_2D(hLinearRing, minx, maxy);
OGR_G_AddPoint_2D(hLinearRing, maxx, maxy);
OGR_G_AddPoint_2D(hLinearRing, maxx, miny);
OGR_G_AddPoint_2D(hLinearRing, minx, miny);
OGR_G_AddGeometryDirectly(hRectangle, hLinearRing);
OGR_F_SetGeometryDirectly(hFeat, hRectangle);
OGR_L_CreateFeature(hMetadataLayer, hFeat);
OGR_F_Destroy(hFeat);
nBlocks++;
if (pfnProgress && !pfnProgress(1.0 * nBlocks / nTotalBlocks,
NULL, pProgressData))
eErr = CE_Failure;
}
}
if (eErr == CE_None)
OGR_DS_ExecuteSQL(hDS, "COMMIT", NULL, NULL);
else
OGR_DS_ExecuteSQL(hDS, "ROLLBACK", NULL, NULL);
CSLDestroy(papszTileDriverOptions);
VSIFree(pabyMEMDSBuffer);
OGRReleaseDataSource(hDS);
return (GDALDataset*) GDALOpen(pszFilename, GA_Update);
}
GXFHandle GXFOpen( const char * pszFilename )
{
FILE *fp;
GXFInfo_t *psGXF;
char szTitle[71];
char **papszList;
int nHeaderCount = 0;
/* -------------------------------------------------------------------- */
/* We open in binary to ensure that we can efficiently seek() */
/* to any location when reading scanlines randomly. If we */
/* opened as text we might still be able to seek(), but I */
/* believe that on Windows, the C library has to read through */
/* all the data to find the right spot taking into account DOS */
/* CRs. */
/* -------------------------------------------------------------------- */
fp = VSIFOpen( pszFilename, "rb" );
if( fp == NULL )
{
/* how to effectively communicate this error out? */
CPLError( CE_Failure, CPLE_OpenFailed,
"Unable to open file: %s\n", pszFilename );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Create the GXF Information object. */
/* -------------------------------------------------------------------- */
psGXF = (GXFInfo_t *) VSICalloc( sizeof(GXFInfo_t), 1 );
psGXF->fp = fp;
psGXF->dfTransformScale = 1.0;
psGXF->nSense = GXFS_LL_RIGHT;
psGXF->dfXPixelSize = 1.0;
psGXF->dfYPixelSize = 1.0;
psGXF->dfSetDummyTo = -1e12;
psGXF->dfUnitToMeter = 1.0;
psGXF->pszTitle = VSIStrdup("");
/* -------------------------------------------------------------------- */
/* Read the header, one line at a time. */
/* -------------------------------------------------------------------- */
while( (papszList = GXFReadHeaderValue( fp, szTitle)) != NULL && nHeaderCount < MAX_HEADER_COUNT )
{
if( STARTS_WITH_CI(szTitle, "#TITL") )
{
CPLFree( psGXF->pszTitle );
psGXF->pszTitle = CPLStrdup( papszList[0] );
}
else if( STARTS_WITH_CI(szTitle, "#POIN") )
{
psGXF->nRawXSize = atoi(papszList[0]);
}
else if( STARTS_WITH_CI(szTitle, "#ROWS") )
{
psGXF->nRawYSize = atoi(papszList[0]);
}
else if( STARTS_WITH_CI(szTitle, "#PTSE") )
{
psGXF->dfXPixelSize = CPLAtof(papszList[0]);
}
else if( STARTS_WITH_CI(szTitle, "#RWSE") )
{
psGXF->dfYPixelSize = CPLAtof(papszList[0]);
}
else if( STARTS_WITH_CI(szTitle, "#DUMM") )
{
memset( psGXF->szDummy, 0, sizeof(psGXF->szDummy));
strncpy( psGXF->szDummy, papszList[0], sizeof(psGXF->szDummy) - 1);
psGXF->dfSetDummyTo = CPLAtof(papszList[0]);
}
else if( STARTS_WITH_CI(szTitle, "#XORI") )
{
psGXF->dfXOrigin = CPLAtof(papszList[0]);
}
else if( STARTS_WITH_CI(szTitle, "#YORI") )
{
psGXF->dfYOrigin = CPLAtof(papszList[0]);
}
else if( STARTS_WITH_CI(szTitle, "#ZMIN") )
{
psGXF->dfZMinimum = CPLAtof(papszList[0]);
}
else if( STARTS_WITH_CI(szTitle, "#ZMAX") )
{
psGXF->dfZMaximum = CPLAtof(papszList[0]);
}
else if( STARTS_WITH_CI(szTitle, "#SENS") )
{
psGXF->nSense = atoi(papszList[0]);
}
else if( STARTS_WITH_CI(szTitle,"#MAP_PROJECTION") )
{
psGXF->papszMapProjection = papszList;
papszList = NULL;
}
else if( STARTS_WITH_CI(szTitle,"#MAP_D") )
{
psGXF->papszMapDatumTransform = papszList;
papszList = NULL;
}
else if( STARTS_WITH_CI(szTitle, "#UNIT") )
{
char **papszFields;
papszFields = CSLTokenizeStringComplex( papszList[0], ", ",
TRUE, TRUE );
if( CSLCount(papszFields) > 1 )
{
psGXF->pszUnitName = VSIStrdup( papszFields[0] );
psGXF->dfUnitToMeter = CPLAtof( papszFields[1] );
if( psGXF->dfUnitToMeter == 0.0 )
psGXF->dfUnitToMeter = 1.0;
}
CSLDestroy( papszFields );
}
else if( STARTS_WITH_CI(szTitle, "#TRAN") )
{
char **papszFields;
papszFields = CSLTokenizeStringComplex( papszList[0], ", ",
TRUE, TRUE );
if( CSLCount(papszFields) > 1 )
{
psGXF->dfTransformScale = CPLAtof(papszFields[0]);
psGXF->dfTransformOffset = CPLAtof(papszFields[1]);
}
if( CSLCount(papszFields) > 2 )
psGXF->pszTransformName = CPLStrdup( papszFields[2] );
CSLDestroy( papszFields );
}
else if( STARTS_WITH_CI(szTitle,"#GTYPE") )
{
psGXF->nGType = atoi(papszList[0]);
}
CSLDestroy( papszList );
nHeaderCount ++;
}
CSLDestroy( papszList );
/* -------------------------------------------------------------------- */
/* Did we find the #GRID? */
/* -------------------------------------------------------------------- */
if( !STARTS_WITH_CI(szTitle, "#GRID") )
{
GXFClose( psGXF );
CPLError( CE_Failure, CPLE_WrongFormat,
"Didn't parse through to #GRID successfully in.\n"
"file `%s'.\n",
pszFilename );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Allocate, and initialize the raw scanline offset array. */
/* -------------------------------------------------------------------- */
if( psGXF->nRawYSize <= 0 )
{
GXFClose( psGXF );
return NULL;
}
psGXF->panRawLineOffset = (long *)
VSICalloc( sizeof(long), psGXF->nRawYSize+1 );
if( psGXF->panRawLineOffset == NULL )
{
GXFClose( psGXF );
return NULL;
}
psGXF->panRawLineOffset[0] = VSIFTell( psGXF->fp );
/* -------------------------------------------------------------------- */
/* Update the zmin/zmax values to take into account #TRANSFORM */
/* information. */
/* -------------------------------------------------------------------- */
if( psGXF->dfZMinimum != 0.0 || psGXF->dfZMaximum != 0.0 )
{
psGXF->dfZMinimum = (psGXF->dfZMinimum * psGXF->dfTransformScale)
+ psGXF->dfTransformOffset;
psGXF->dfZMaximum = (psGXF->dfZMaximum * psGXF->dfTransformScale)
+ psGXF->dfTransformOffset;
}
return( (GXFHandle) psGXF );
}
OGRFeature *OGROpenAirLayer::GetNextRawFeature()
{
const char* pszLine;
CPLString osCLASS, osNAME, osFLOOR, osCEILING;
OGRLinearRing oLR;
double dfLastLat = 0, dfLastLon = 0;
int bFirst = TRUE;
int bClockWise = TRUE;
double dfCenterLat = 0, dfCenterLon = 0;
int bHasCenter = FALSE;
OpenAirStyle sStyle;
sStyle.penStyle = -1;
sStyle.penWidth = -1;
sStyle.penR = sStyle.penG = sStyle.penB = -1;
sStyle.fillR = sStyle.fillG = sStyle.fillB = -1;
if (bEOF)
return NULL;
while(TRUE)
{
if (bFirst && bHasLastLine)
{
pszLine = osLastLine.c_str();
bFirst = FALSE;
}
else
{
pszLine = CPLReadLine2L(fpOpenAir, 1024, NULL);
if (pszLine == NULL)
{
bEOF = TRUE;
if (oLR.getNumPoints() == 0)
return NULL;
if (osCLASS.size() != 0 &&
oStyleMap.find(osCLASS) != oStyleMap.end())
{
memcpy(&sStyle, oStyleMap[osCLASS], sizeof(sStyle));
}
break;
}
osLastLine = pszLine;
bHasLastLine = TRUE;
}
if (pszLine[0] == '*' || pszLine[0] == '\0')
continue;
if (EQUALN(pszLine, "AC ", 3) || EQUALN(pszLine, "AC,", 3))
{
if (osCLASS.size() != 0)
{
if (sStyle.penStyle != -1 || sStyle.fillR != -1)
{
if (oLR.getNumPoints() == 0)
{
OpenAirStyle* psStyle;
if (oStyleMap.find(osCLASS) == oStyleMap.end())
{
psStyle = (OpenAirStyle*)CPLMalloc(
sizeof(OpenAirStyle));
oStyleMap[osCLASS] = psStyle;
}
else
psStyle = oStyleMap[osCLASS];
memcpy(psStyle, &sStyle, sizeof(sStyle));
}
else
break;
}
else if (oStyleMap.find(osCLASS) != oStyleMap.end())
{
memcpy(&sStyle, oStyleMap[osCLASS], sizeof(sStyle));
break;
}
else
break;
}
sStyle.penStyle = -1;
sStyle.penWidth = -1;
sStyle.penR = sStyle.penG = sStyle.penB = -1;
sStyle.fillR = sStyle.fillG = sStyle.fillB = -1;
osCLASS = pszLine + 3;
bClockWise = TRUE;
bHasCenter = FALSE;
}
else if (EQUALN(pszLine, "AN ", 3))
{
if (osNAME.size() != 0)
break;
osNAME = pszLine + 3;
}
else if (EQUALN(pszLine, "AH ", 3))
osCEILING = pszLine + 3;
else if (EQUALN(pszLine, "AL ", 3))
osFLOOR = pszLine + 3;
else if (EQUALN(pszLine, "AT ", 3))
{
/* Ignored for that layer*/
}
else if (EQUALN(pszLine, "SP ", 3))
{
if (osCLASS.size() != 0)
{
char** papszTokens = CSLTokenizeString2(pszLine+3, ", ", 0);
if (CSLCount(papszTokens) == 5)
{
sStyle.penStyle = atoi(papszTokens[0]);
sStyle.penWidth = atoi(papszTokens[1]);
sStyle.penR = atoi(papszTokens[2]);
sStyle.penG = atoi(papszTokens[3]);
sStyle.penB = atoi(papszTokens[4]);
}
CSLDestroy(papszTokens);
}
}
else if (EQUALN(pszLine, "SB ", 3))
{
if (osCLASS.size() != 0)
{
char** papszTokens = CSLTokenizeString2(pszLine+3, ", ", 0);
if (CSLCount(papszTokens) == 3)
{
sStyle.fillR = atoi(papszTokens[0]);
sStyle.fillG = atoi(papszTokens[1]);
sStyle.fillB = atoi(papszTokens[2]);
}
CSLDestroy(papszTokens);
}
}
else if (EQUALN(pszLine, "DP ", 3))
{
pszLine += 3;
double dfLat, dfLon;
if (!OGROpenAirGetLatLon(pszLine, dfLat, dfLon))
continue;
oLR.addPoint(dfLon, dfLat);
dfLastLat = dfLat;
dfLastLon = dfLon;
}
else if (EQUALN(pszLine, "DA ", 3))
{
pszLine += 3;
char* pszStar = strchr((char*)pszLine, '*');
if (pszStar) *pszStar = 0;
char** papszTokens = CSLTokenizeString2(pszLine, ",", 0);
if (bHasCenter && CSLCount(papszTokens) == 3)
{
double dfRadius = atof(papszTokens[0]) * 1852;
double dfStartAngle = atof(papszTokens[1]);
double dfEndAngle = atof(papszTokens[2]);
if (bClockWise && dfEndAngle < dfStartAngle)
dfEndAngle += 360;
else if (!bClockWise && dfStartAngle < dfEndAngle)
dfEndAngle -= 360;
double dfStartDistance = dfRadius;
double dfEndDistance = dfRadius;
int nSign = (bClockWise) ? 1 : -1;
double dfAngle;
double dfLat, dfLon;
for(dfAngle = dfStartAngle;
(dfAngle - dfEndAngle) * nSign < 0;
dfAngle += nSign)
{
double pct = (dfAngle - dfStartAngle) /
(dfEndAngle - dfStartAngle);
double dfDist = dfStartDistance * (1-pct) +
dfEndDistance * pct;
OGRXPlane_ExtendPosition(dfCenterLat, dfCenterLon,
dfDist, dfAngle, &dfLat, &dfLon);
oLR.addPoint(dfLon, dfLat);
}
OGRXPlane_ExtendPosition(dfCenterLat, dfCenterLon,
dfEndDistance, dfEndAngle, &dfLat, &dfLon);
oLR.addPoint(dfLon, dfLat);
dfLastLat = oLR.getY(oLR.getNumPoints() - 1);
dfLastLon = oLR.getX(oLR.getNumPoints() - 1);
}
CSLDestroy(papszTokens);
}
else if (EQUALN(pszLine, "DB ", 3))
{
pszLine += 3;
char* pszStar = strchr((char*)pszLine, '*');
if (pszStar) *pszStar = 0;
char** papszTokens = CSLTokenizeString2(pszLine, ",", 0);
double dfFirstLat, dfFirstLon;
double dfSecondLat, dfSecondLon;
if (bHasCenter && CSLCount(papszTokens) == 2 &&
OGROpenAirGetLatLon(papszTokens[0], dfFirstLat, dfFirstLon) &&
OGROpenAirGetLatLon(papszTokens[1], dfSecondLat, dfSecondLon))
{
double dfStartDistance =OGRXPlane_Distance(dfCenterLat,
dfCenterLon, dfFirstLat, dfFirstLon);
double dfEndDistance = OGRXPlane_Distance(dfCenterLat,
dfCenterLon, dfSecondLat, dfSecondLon);
double dfStartAngle = OGRXPlane_Track(dfCenterLat,
dfCenterLon, dfFirstLat, dfFirstLon);
double dfEndAngle = OGRXPlane_Track(dfCenterLat,
dfCenterLon, dfSecondLat, dfSecondLon);
if (bClockWise && dfEndAngle < dfStartAngle)
dfEndAngle += 360;
else if (!bClockWise && dfStartAngle < dfEndAngle)
dfEndAngle -= 360;
int nSign = (bClockWise) ? 1 : -1;
double dfAngle;
for(dfAngle = dfStartAngle;
(dfAngle - dfEndAngle) * nSign < 0;
dfAngle += nSign)
{
double dfLat, dfLon;
double pct = (dfAngle - dfStartAngle) /
(dfEndAngle - dfStartAngle);
double dfDist = dfStartDistance * (1-pct) +
dfEndDistance * pct;
OGRXPlane_ExtendPosition(dfCenterLat, dfCenterLon,
dfDist, dfAngle, &dfLat, &dfLon);
oLR.addPoint(dfLon, dfLat);
}
oLR.addPoint(dfSecondLon, dfSecondLat);
dfLastLat = oLR.getY(oLR.getNumPoints() - 1);
dfLastLon = oLR.getX(oLR.getNumPoints() - 1);
}
CSLDestroy(papszTokens);
}
else if ((EQUALN(pszLine, "DC ", 3) || EQUALN(pszLine, "DC=", 3)) &&
(bHasCenter || strstr(pszLine, "V X=") != NULL))
{
if (!bHasCenter)
{
const char* pszVX = strstr(pszLine, "V X=");
bHasCenter = OGROpenAirGetLatLon(pszVX, dfCenterLat, dfCenterLon);
}
if (bHasCenter)
{
pszLine += 3;
double dfRADIUS = atof(pszLine) * 1852;
double dfAngle;
double dfLat, dfLon;
for(dfAngle = 0; dfAngle < 360; dfAngle += 1)
{
OGRXPlane_ExtendPosition(dfCenterLat, dfCenterLon,
dfRADIUS, dfAngle, &dfLat, &dfLon);
oLR.addPoint(dfLon, dfLat);
}
OGRXPlane_ExtendPosition(dfCenterLat, dfCenterLon,
dfRADIUS, 0, &dfLat, &dfLon);
oLR.addPoint(dfLon, dfLat);
dfLastLat = oLR.getY(oLR.getNumPoints() - 1);
dfLastLon = oLR.getX(oLR.getNumPoints() - 1);
}
}
else if (EQUALN(pszLine, "V X=", 4))
{
bHasCenter =
OGROpenAirGetLatLon(pszLine + 4, dfCenterLat, dfCenterLon);
}
else if (EQUALN(pszLine, "V D=-", 5))
{
bClockWise = FALSE;
}
else if (EQUALN(pszLine, "V D=+", 5))
{
bClockWise = TRUE;
}
else
{
//CPLDebug("OpenAir", "Unexpected content : %s", pszLine);
}
}
OGRFeature* poFeature = new OGRFeature(poFeatureDefn);
poFeature->SetField(0, osCLASS.c_str());
poFeature->SetField(1, osNAME.c_str());
poFeature->SetField(2, osFLOOR.c_str());
poFeature->SetField(3, osCEILING.c_str());
if (sStyle.penStyle != -1 || sStyle.fillR != -1)
{
CPLString osStyle;
if (sStyle.penStyle != -1)
{
osStyle += CPLString().Printf("PEN(c:#%02X%02X%02X,w:%dpt",
sStyle.penR, sStyle.penG, sStyle.penB,
sStyle.penWidth);
if (sStyle.penStyle == 1)
osStyle += ",p:\"5px 5px\"";
osStyle += ")";
}
if (sStyle.fillR != -1)
{
if (osStyle.size() != 0)
osStyle += ";";
osStyle += CPLString().Printf("BRUSH(fc:#%02X%02X%02X)",
sStyle.fillR, sStyle.fillG, sStyle.fillB);
}
else
{
if (osStyle.size() != 0)
osStyle += ";";
osStyle += "BRUSH(fc:#00000000,id:\"ogr-brush-1\")";
}
if (osStyle.size() != 0)
poFeature->SetStyleString(osStyle);
}
OGRPolygon* poPoly = new OGRPolygon();
oLR.closeRings();
poPoly->addRing(&oLR);
poPoly->assignSpatialReference(poSRS);
poFeature->SetGeometryDirectly(poPoly);
poFeature->SetFID(nNextFID++);
return poFeature;
}
void ISCEDataset::FlushCache( void )
{
RawDataset::FlushCache();
GDALRasterBand *band = (GetRasterCount() > 0) ? GetRasterBand(1) : NULL;
if ( eAccess == GA_ReadOnly || band == NULL )
return;
/* -------------------------------------------------------------------- */
/* Recreate a XML doc with the dataset information. */
/* -------------------------------------------------------------------- */
char sBuf[64];
CPLXMLNode *psDocNode = CPLCreateXMLNode( NULL, CXT_Element, "imageFile" );
CPLXMLNode *psTmpNode
= CPLCreateXMLNode( psDocNode, CXT_Element, "property" );
CPLAddXMLAttributeAndValue( psTmpNode, "name", "WIDTH" );
snprintf(sBuf, sizeof(sBuf), "%d", nRasterXSize);
CPLCreateXMLElementAndValue( psTmpNode, "value", sBuf );
psTmpNode = CPLCreateXMLNode( psDocNode, CXT_Element, "property" );
CPLAddXMLAttributeAndValue( psTmpNode, "name", "LENGTH" );
snprintf(sBuf, sizeof(sBuf), "%d", nRasterYSize);
CPLCreateXMLElementAndValue( psTmpNode, "value", sBuf );
psTmpNode = CPLCreateXMLNode( psDocNode, CXT_Element, "property" );
CPLAddXMLAttributeAndValue( psTmpNode, "name", "NUMBER_BANDS" );
snprintf(sBuf, sizeof(sBuf), "%d", nBands);
CPLCreateXMLElementAndValue( psTmpNode, "value", sBuf );
const char *sType = GDALGetDataTypeName( band->GetRasterDataType() );
psTmpNode = CPLCreateXMLNode( psDocNode, CXT_Element, "property" );
CPLAddXMLAttributeAndValue( psTmpNode, "name", "DATA_TYPE" );
CPLCreateXMLElementAndValue( psTmpNode, "value",
CSLFetchNameValue(
(char **)apszGDAL2ISCEDatatypes,
sType ) );
const char *sScheme = apszSchemeNames[eScheme];
psTmpNode = CPLCreateXMLNode( psDocNode, CXT_Element, "property" );
CPLAddXMLAttributeAndValue( psTmpNode, "name", "SCHEME" );
CPLCreateXMLElementAndValue( psTmpNode, "value", sScheme );
psTmpNode = CPLCreateXMLNode( psDocNode, CXT_Element, "property" );
CPLAddXMLAttributeAndValue( psTmpNode, "name", "BYTE_ORDER" );
#ifdef CPL_LSB
CPLCreateXMLElementAndValue( psTmpNode, "value", "l" );
#else
CPLCreateXMLElementAndValue( psTmpNode, "value", "b" );
#endif
/* -------------------------------------------------------------------- */
/* Then, add the ISCE domain metadata. */
/* -------------------------------------------------------------------- */
char **papszISCEMetadata = GetMetadata( "ISCE" );
for (int i = 0; i < CSLCount( papszISCEMetadata ); i++)
{
/* Get the tokens from the metadata item */
char **papszTokens = CSLTokenizeString2( papszISCEMetadata[i],
"=",
CSLT_STRIPLEADSPACES
| CSLT_STRIPENDSPACES);
if ( CSLCount( papszTokens ) != 2 )
{
CPLDebug( "ISCE",
"Line of header file could not be split at = into two"
" elements: %s",
papszISCEMetadata[i] );
CSLDestroy( papszTokens );
continue;
}
/* Don't write it out if it is one of the bits of metadata that is
* written out elsewhere in this routine */
if ( strcmp( papszTokens[0], "WIDTH" ) == 0
|| strcmp( papszTokens[0], "LENGTH" ) == 0
|| strcmp( papszTokens[0], "NUMBER_BANDS" ) == 0
|| strcmp( papszTokens[0], "DATA_TYPE" ) == 0
|| strcmp( papszTokens[0], "SCHEME" ) == 0
|| strcmp( papszTokens[0], "BYTE_ORDER" ) == 0 )
{
CSLDestroy( papszTokens );
continue;
}
psTmpNode = CPLCreateXMLNode( psDocNode, CXT_Element, "property" );
CPLAddXMLAttributeAndValue( psTmpNode, "name", papszTokens[0] );
CPLCreateXMLElementAndValue( psTmpNode, "value", papszTokens[1] );
CSLDestroy( papszTokens );
}
/* -------------------------------------------------------------------- */
/* Write the XML file. */
/* -------------------------------------------------------------------- */
CPLSerializeXMLTreeToFile( psDocNode, pszXMLFilename );
/* -------------------------------------------------------------------- */
/* Free the XML Doc. */
/* -------------------------------------------------------------------- */
CPLDestroyXMLNode( psDocNode );
}
int OGRILI1DataSource::Open( const char * pszNewName, int bTestOpen )
{
FILE *fp;
char szHeader[1000];
std::string osBasename, osModelFilename;
if (strlen(pszNewName) == 0)
{
return FALSE;
}
char **filenames = CSLTokenizeString2( pszNewName, ",", 0 );
osBasename = filenames[0];
if( CSLCount(filenames) > 1 )
osModelFilename = filenames[1];
CSLDestroy( filenames );
/* -------------------------------------------------------------------- */
/* Open the source file. */
/* -------------------------------------------------------------------- */
fp = VSIFOpen( osBasename.c_str(), "r" );
if( fp == NULL )
{
if( !bTestOpen )
CPLError( CE_Failure, CPLE_OpenFailed,
"Failed to open ILI1 file `%s'.",
pszNewName );
return FALSE;
}
/* -------------------------------------------------------------------- */
/* If we aren't sure it is ILI1, load a header chunk and check */
/* for signs it is ILI1 */
/* -------------------------------------------------------------------- */
if( bTestOpen )
{
int nLen = (int)VSIFRead( szHeader, 1, sizeof(szHeader), fp );
if (nLen == sizeof(szHeader))
szHeader[sizeof(szHeader)-1] = '\0';
else
szHeader[nLen] = '\0';
if( strstr(szHeader,"SCNT") == NULL )
{
VSIFClose( fp );
return FALSE;
}
}
/* -------------------------------------------------------------------- */
/* We assume now that it is ILI1. Close and instantiate a */
/* ILI1Reader on it. */
/* -------------------------------------------------------------------- */
VSIFClose( fp );
poReader = CreateILI1Reader();
if( poReader == NULL )
{
CPLError( CE_Failure, CPLE_AppDefined,
"File %s appears to be ILI1 but the ILI1 reader can't\n"
"be instantiated, likely because Xerces support wasn't\n"
"configured in.",
pszNewName );
return FALSE;
}
poReader->OpenFile( osBasename.c_str() );
pszName = CPLStrdup( osBasename.c_str() );
if (osModelFilename.length() > 0 )
poReader->ReadModel( poImdReader, osModelFilename.c_str(), this );
if( getenv( "ARC_DEGREES" ) != NULL ) {
//No better way to pass arguments to the reader (it could even be an -lco arg)
poReader->SetArcDegrees( atof( getenv("ARC_DEGREES") ) );
}
//Parse model and read data - without surface joing and polygonizing
poReader->ReadFeatures();
return TRUE;
}
CPLErr VRTDataset::AddBand( GDALDataType eType, char **papszOptions )
{
int i;
const char *pszSubClass = CSLFetchNameValue(papszOptions, "subclass");
bNeedsFlush = 1;
/* ==================================================================== */
/* Handle a new raw band. */
/* ==================================================================== */
if( pszSubClass != NULL && EQUAL(pszSubClass,"VRTRawRasterBand") )
{
int nWordDataSize = GDALGetDataTypeSize( eType ) / 8;
vsi_l_offset nImageOffset = 0;
int nPixelOffset = nWordDataSize;
int nLineOffset = nWordDataSize * GetRasterXSize();
const char *pszFilename;
const char *pszByteOrder = NULL;
int bRelativeToVRT = FALSE;
/* -------------------------------------------------------------------- */
/* Collect required information. */
/* -------------------------------------------------------------------- */
if( CSLFetchNameValue(papszOptions, "ImageOffset") != NULL )
nImageOffset = atoi(CSLFetchNameValue(papszOptions, "ImageOffset"));
if( CSLFetchNameValue(papszOptions, "PixelOffset") != NULL )
nPixelOffset = atoi(CSLFetchNameValue(papszOptions,"PixelOffset"));
if( CSLFetchNameValue(papszOptions, "LineOffset") != NULL )
nLineOffset = atoi(CSLFetchNameValue(papszOptions, "LineOffset"));
if( CSLFetchNameValue(papszOptions, "ByteOrder") != NULL )
pszByteOrder = CSLFetchNameValue(papszOptions, "ByteOrder");
if( CSLFetchNameValue(papszOptions, "SourceFilename") != NULL )
pszFilename = CSLFetchNameValue(papszOptions, "SourceFilename");
else
{
CPLError( CE_Failure, CPLE_AppDefined,
"AddBand() requires a SourceFilename option for VRTRawRasterBands." );
return CE_Failure;
}
bRelativeToVRT =
CSLFetchBoolean( papszOptions, "RelativeToVRT", FALSE );
/* -------------------------------------------------------------------- */
/* Create and initialize the band. */
/* -------------------------------------------------------------------- */
CPLErr eErr;
VRTRawRasterBand *poBand =
new VRTRawRasterBand( this, GetRasterCount() + 1, eType );
eErr =
poBand->SetRawLink( pszFilename, NULL, FALSE,
nImageOffset, nPixelOffset, nLineOffset,
pszByteOrder );
if( eErr != CE_None )
{
delete poBand;
return eErr;
}
SetBand( GetRasterCount() + 1, poBand );
return CE_None;
}
/* ==================================================================== */
/* Handle a new "sourced" band. */
/* ==================================================================== */
else
{
VRTSourcedRasterBand *poBand;
/* ---- Check for our sourced band 'derived' subclass ---- */
if(pszSubClass != NULL && EQUAL(pszSubClass,"VRTDerivedRasterBand")) {
poBand = new VRTDerivedRasterBand
(this, GetRasterCount() + 1, eType,
GetRasterXSize(), GetRasterYSize());
}
else {
/* ---- Standard sourced band ---- */
poBand = new VRTSourcedRasterBand
(this, GetRasterCount() + 1, eType,
GetRasterXSize(), GetRasterYSize());
}
SetBand( GetRasterCount() + 1, poBand );
for( i=0; papszOptions != NULL && papszOptions[i] != NULL; i++ )
{
if( EQUALN(papszOptions[i],"AddFuncSource=", 14) )
{
VRTImageReadFunc pfnReadFunc = NULL;
void *pCBData = NULL;
double dfNoDataValue = VRT_NODATA_UNSET;
char **papszTokens = CSLTokenizeStringComplex( papszOptions[i]+14,
",", TRUE, FALSE );
if( CSLCount(papszTokens) < 1 )
{
CPLError( CE_Failure, CPLE_AppDefined,
"AddFuncSource() ... required argument missing." );
}
sscanf( papszTokens[0], "%p", &pfnReadFunc );
if( CSLCount(papszTokens) > 1 )
sscanf( papszTokens[1], "%p", &pCBData );
if( CSLCount(papszTokens) > 2 )
dfNoDataValue = atof( papszTokens[2] );
poBand->AddFuncSource( pfnReadFunc, pCBData, dfNoDataValue );
}
}
return CE_None;
}
}
int main( int argc, char ** argv )
{
GDALDatasetH hDataset, hOutDS;
int i;
const char *pszSource=NULL, *pszDest=NULL, *pszFormat = "GTiff";
int bFormatExplicitlySet = FALSE;
GDALDriverH hDriver;
GDALDataType eOutputType = GDT_Unknown;
char **papszCreateOptions = NULL;
GDALProgressFunc pfnProgress = GDALTermProgress;
int nLUTBins = 256;
const char *pszMethod = "minmax";
// double dfStdDevMult = 0.0;
double *padfScaleMin = NULL;
double *padfScaleMax = NULL;
int **papanLUTs = NULL;
int iBand;
const char *pszConfigFile = NULL;
int bQuiet = FALSE;
/* Check strict compilation and runtime library version as we use C++ API */
if (! GDAL_CHECK_VERSION(argv[0]))
exit(1);
/* -------------------------------------------------------------------- */
/* Register standard GDAL drivers, and process generic GDAL */
/* command options. */
/* -------------------------------------------------------------------- */
GDALAllRegister();
argc = GDALGeneralCmdLineProcessor( argc, &argv, 0 );
if( argc < 1 )
exit( -argc );
/* -------------------------------------------------------------------- */
/* Handle command line arguments. */
/* -------------------------------------------------------------------- */
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],"-of") && i < argc-1 )
{
pszFormat = argv[++i];
bFormatExplicitlySet = TRUE;
}
else if( EQUAL(argv[i],"-ot") && i < argc-1 )
{
int iType;
for( iType = 1; iType < GDT_TypeCount; iType++ )
{
if( GDALGetDataTypeName((GDALDataType)iType) != NULL
&& EQUAL(GDALGetDataTypeName((GDALDataType)iType),
argv[i+1]) )
{
eOutputType = (GDALDataType) iType;
}
}
if( eOutputType == GDT_Unknown )
{
printf( "Unknown output pixel type: %s\n", argv[i+1] );
Usage();
}
i++;
}
else if( STARTS_WITH_CI(argv[i], "-s_nodata") )
{
// TODO
i += 1;
}
else if( EQUAL(argv[i],"-co") && i < argc-1 )
{
papszCreateOptions = CSLAddString( papszCreateOptions, argv[++i] );
}
else if( STARTS_WITH_CI(argv[i], "-src_scale") && i < argc-2)
{
// TODO
i += 2;
}
else if( STARTS_WITH_CI(argv[i], "-dst_scale") && i < argc-2 )
{
// TODO
i += 2;
}
else if( EQUAL(argv[i],"-config") && i < argc-1 )
{
pszConfigFile = argv[++i];
}
else if( EQUAL(argv[i],"-equalize") )
{
pszMethod = "equalize";
}
else if( EQUAL(argv[i],"-quiet") )
{
pfnProgress = GDALDummyProgress;
bQuiet = TRUE;
}
else if( argv[i][0] == '-' )
{
printf( "Option %s incomplete, or not recognised.\n\n",
argv[i] );
Usage();
}
else if( pszSource == NULL )
{
pszSource = argv[i];
}
else if( pszDest == NULL )
{
pszDest = argv[i];
}
else
{
printf( "Too many command options.\n\n" );
Usage();
}
}
if( pszSource == NULL )
{
Usage();
}
/* -------------------------------------------------------------------- */
/* Attempt to open source file. */
/* -------------------------------------------------------------------- */
hDataset = GDALOpenShared( pszSource, GA_ReadOnly );
if( hDataset == NULL )
{
fprintf( stderr,
"GDALOpen failed - %d\n%s\n",
CPLGetLastErrorNo(), CPLGetLastErrorMsg() );
GDALDestroyDriverManager();
exit( 1 );
}
int nBandCount = GDALGetRasterCount(hDataset);
/* -------------------------------------------------------------------- */
/* Find the output driver. */
/* -------------------------------------------------------------------- */
hDriver = GDALGetDriverByName( pszFormat );
if( hDriver == NULL )
{
int iDr;
printf( "Output driver `%s' not recognised.\n", pszFormat );
printf( "The following format drivers are configured and support output:\n" );
for( iDr = 0; iDr < GDALGetDriverCount(); iDr++ )
{
hDriver = GDALGetDriver(iDr);
if( GDALGetMetadataItem( hDriver, GDAL_DCAP_RASTER, NULL) != NULL &&
(GDALGetMetadataItem( hDriver, GDAL_DCAP_CREATE, NULL ) != NULL
|| GDALGetMetadataItem( hDriver, GDAL_DCAP_CREATECOPY, NULL ) != NULL) )
{
printf( " %s: %s\n",
GDALGetDriverShortName( hDriver ),
GDALGetDriverLongName( hDriver ) );
}
}
printf( "\n" );
Usage();
}
if (!bQuiet && pszDest != NULL && !bFormatExplicitlySet)
CheckExtensionConsistency(pszDest, pszFormat);
/* -------------------------------------------------------------------- */
/* If histogram equalization is requested, do it now. */
/* -------------------------------------------------------------------- */
if( EQUAL(pszMethod,"equalize") )
{
ComputeEqualizationLUTs( hDataset, nLUTBins,
&padfScaleMin, &padfScaleMax,
&papanLUTs, pfnProgress );
}
/* -------------------------------------------------------------------- */
/* If we have a config file, assume it is for input and read */
/* it. */
/* -------------------------------------------------------------------- */
else if( pszConfigFile != NULL )
{
char **papszLines = CSLLoad( pszConfigFile );
if( CSLCount(papszLines) == 0 )
exit( 1 );
if( CSLCount(papszLines) != nBandCount )
{
fprintf( stderr, "Did not get %d lines in config file as expected.\n", nBandCount );
exit( 1 );
}
padfScaleMin = (double *) CPLCalloc(nBandCount,sizeof(double));
padfScaleMax = (double *) CPLCalloc(nBandCount,sizeof(double));
for( iBand = 0; iBand < nBandCount; iBand++ )
{
int iLUT;
char **papszTokens = CSLTokenizeString( papszLines[iBand] );
if( CSLCount(papszTokens) < 3
|| atoi(papszTokens[0]) != iBand+1 )
{
fprintf( stderr, "Line %d seems to be corrupt.\n", iBand+1 );
exit( 1 );
}
// Process scale min/max
padfScaleMin[iBand] = CPLAtof(papszTokens[1]);
padfScaleMax[iBand] = CPLAtof(papszTokens[2]);
if( CSLCount(papszTokens) == 3 )
continue;
// process lut
if( papanLUTs == NULL )
{
nLUTBins = CSLCount(papszTokens) - 3;
papanLUTs = (int **) CPLCalloc(sizeof(int*),nBandCount);
}
papanLUTs[iBand] = (int *) CPLCalloc(nLUTBins,sizeof(int));
for( iLUT = 0; iLUT < nLUTBins; iLUT++ )
papanLUTs[iBand][iLUT] = atoi(papszTokens[iLUT+3]);
CSLDestroy( papszTokens );
}
}
/* -------------------------------------------------------------------- */
/* If there is no destination, just report the scaling values */
/* and luts. */
/* -------------------------------------------------------------------- */
if( pszDest == NULL )
{
FILE *fpConfig = stdout;
if( pszConfigFile )
fpConfig = fopen( pszConfigFile, "w" );
for( iBand = 0; iBand < nBandCount; iBand++ )
{
fprintf( fpConfig, "%d:Band ", iBand+1 );
if( padfScaleMin != NULL )
fprintf( fpConfig, "%g:ScaleMin %g:ScaleMax ",
padfScaleMin[iBand], padfScaleMax[iBand] );
if( papanLUTs )
{
int iLUT;
for( iLUT = 0; iLUT < nLUTBins; iLUT++ )
fprintf( fpConfig, "%d ", papanLUTs[iBand][iLUT] );
}
fprintf( fpConfig, "\n" );
}
if( pszConfigFile )
fclose( fpConfig );
exit( 0 );
}
if (padfScaleMin == NULL || padfScaleMax == NULL)
{
fprintf( stderr, "-equalize or -config filename command line options must be specified.\n");
exit(1);
}
/* ==================================================================== */
/* Create a virtual dataset. */
/* ==================================================================== */
VRTDataset *poVDS;
EnhanceCBInfo *pasEInfo = (EnhanceCBInfo *)
CPLCalloc(nBandCount, sizeof(EnhanceCBInfo));
/* -------------------------------------------------------------------- */
/* Make a virtual clone. */
/* -------------------------------------------------------------------- */
poVDS = new VRTDataset( GDALGetRasterXSize(hDataset),
GDALGetRasterYSize(hDataset) );
if( GDALGetGCPCount(hDataset) == 0 )
{
const char *pszProjection;
double adfGeoTransform[6];
pszProjection = GDALGetProjectionRef( hDataset );
if( pszProjection != NULL && strlen(pszProjection) > 0 )
poVDS->SetProjection( pszProjection );
if( GDALGetGeoTransform( hDataset, adfGeoTransform ) == CE_None )
poVDS->SetGeoTransform( adfGeoTransform );
}
else
{
poVDS->SetGCPs( GDALGetGCPCount(hDataset),
GDALGetGCPs(hDataset),
GDALGetGCPProjection( hDataset ) );
}
poVDS->SetMetadata( ((GDALDataset*)hDataset)->GetMetadata() );
for( iBand = 0; iBand < nBandCount; iBand++ )
{
VRTSourcedRasterBand *poVRTBand;
GDALRasterBand *poSrcBand;
GDALDataType eBandType;
poSrcBand = ((GDALDataset *) hDataset)->GetRasterBand(iBand+1);
/* -------------------------------------------------------------------- */
/* Select output data type to match source. */
/* -------------------------------------------------------------------- */
if( eOutputType == GDT_Unknown )
eBandType = GDT_Byte;
else
eBandType = eOutputType;
/* -------------------------------------------------------------------- */
/* Create this band. */
/* -------------------------------------------------------------------- */
poVDS->AddBand( eBandType, NULL );
poVRTBand = (VRTSourcedRasterBand *) poVDS->GetRasterBand( iBand+1 );
/* -------------------------------------------------------------------- */
/* Create a function based source with info on how to apply the */
/* enhancement. */
/* -------------------------------------------------------------------- */
pasEInfo[iBand].poSrcBand = poSrcBand;
pasEInfo[iBand].eWrkType = eBandType;
pasEInfo[iBand].dfScaleMin = padfScaleMin[iBand];
pasEInfo[iBand].dfScaleMax = padfScaleMax[iBand];
pasEInfo[iBand].nLUTBins = nLUTBins;
if( papanLUTs )
pasEInfo[iBand].panLUT = papanLUTs[iBand];
poVRTBand->AddFuncSource( EnhancerCallback, pasEInfo + iBand );
/* -------------------------------------------------------------------- */
/* copy over some other information of interest. */
/* -------------------------------------------------------------------- */
poVRTBand->CopyCommonInfoFrom( poSrcBand );
}
/* -------------------------------------------------------------------- */
/* Write to the output file using CopyCreate(). */
/* -------------------------------------------------------------------- */
hOutDS = GDALCreateCopy( hDriver, pszDest, (GDALDatasetH) poVDS,
FALSE, papszCreateOptions,
pfnProgress, NULL );
if( hOutDS != NULL )
GDALClose( hOutDS );
GDALClose( (GDALDatasetH) poVDS );
GDALClose( hDataset );
/* -------------------------------------------------------------------- */
/* Cleanup and exit. */
/* -------------------------------------------------------------------- */
GDALDumpOpenDatasets( stderr );
GDALDestroyDriverManager();
CSLDestroy( argv );
CSLDestroy( papszCreateOptions );
exit( 0 );
}
int
HFAField::ExtractInstValue( const char * pszField, int nIndexValue,
GByte *pabyData, GUInt32 nDataOffset, int nDataSize,
char chReqType, void *pReqReturn )
{
char *pszStringRet = NULL;
int nIntRet = 0;
double dfDoubleRet = 0.0;
int nInstItemCount = GetInstCount( pabyData, nDataSize );
GByte *pabyRawData = NULL;
/* -------------------------------------------------------------------- */
/* Check the index value is valid. */
/* */
/* Eventually this will have to account for variable fields. */
/* -------------------------------------------------------------------- */
if( nIndexValue < 0 || nIndexValue >= nInstItemCount )
{
if( chItemType == 'b' && nIndexValue >= -3 && nIndexValue < 0 )
/* ok - special index values */;
else
return FALSE;
}
/* -------------------------------------------------------------------- */
/* If this field contains a pointer, then we will adjust the */
/* data offset relative to it. */
/* -------------------------------------------------------------------- */
if( chPointer != '\0' )
{
GUInt32 nOffset;
memcpy( &nOffset, pabyData+4, 4 );
HFAStandard( 4, &nOffset );
if( nOffset != (GUInt32) (nDataOffset + 8) )
{
#ifdef notdef
CPLError( CE_Warning, CPLE_AppDefined,
"%s.%s points at %d, not %d as expected\n",
pszFieldName, pszField ? pszField : "",
nOffset, nDataOffset+8 );
#endif
}
pabyData += 8;
nDataOffset += 8;
nDataSize -= 8;
}
/* -------------------------------------------------------------------- */
/* pointers to char or uchar arrays requested as strings are */
/* handled as a special case. */
/* -------------------------------------------------------------------- */
if( (chItemType == 'c' || chItemType == 'C') && chReqType == 's' )
{
*((GByte **)pReqReturn) = pabyData;
return( pabyData != NULL );
}
/* -------------------------------------------------------------------- */
/* Handle by type. */
/* -------------------------------------------------------------------- */
switch( chItemType )
{
case 'c':
case 'C':
nIntRet = pabyData[nIndexValue];
dfDoubleRet = nIntRet;
break;
case 'e':
case 's':
{
unsigned short nNumber;
memcpy( &nNumber, pabyData + nIndexValue*2, 2 );
HFAStandard( 2, &nNumber );
nIntRet = nNumber;
dfDoubleRet = nIntRet;
if( chItemType == 'e'
&& nIntRet >= 0 && nIntRet < CSLCount(papszEnumNames) )
{
pszStringRet = papszEnumNames[nIntRet];
}
}
break;
case 'S':
{
short nNumber;
memcpy( &nNumber, pabyData + nIndexValue*2, 2 );
HFAStandard( 2, &nNumber );
nIntRet = nNumber;
dfDoubleRet = nIntRet;
}
break;
case 't':
case 'l':
{
GUInt32 nNumber;
memcpy( &nNumber, pabyData + nIndexValue*4, 4 );
HFAStandard( 4, &nNumber );
nIntRet = nNumber;
dfDoubleRet = nIntRet;
}
break;
case 'L':
{
GInt32 nNumber;
memcpy( &nNumber, pabyData + nIndexValue*4, 4 );
HFAStandard( 4, &nNumber );
nIntRet = nNumber;
dfDoubleRet = nIntRet;
}
break;
case 'f':
{
float fNumber;
memcpy( &fNumber, pabyData + nIndexValue*4, 4 );
HFAStandard( 4, &fNumber );
dfDoubleRet = fNumber;
nIntRet = (int) fNumber;
}
break;
case 'd':
{
double dfNumber;
memcpy( &dfNumber, pabyData + nIndexValue*8, 8 );
HFAStandard( 8, &dfNumber );
dfDoubleRet = dfNumber;
nIntRet = (int) dfNumber;
}
break;
case 'b':
{
GInt32 nRows, nColumns;
GInt16 nBaseItemType;
if( nDataSize < 12 )
return FALSE;
memcpy( &nRows, pabyData, 4 );
HFAStandard( 4, &nRows );
memcpy( &nColumns, pabyData+4, 4 );
HFAStandard( 4, &nColumns );
memcpy( &nBaseItemType, pabyData+8, 2 );
HFAStandard( 2, &nBaseItemType );
// We ignore the 2 byte objecttype value.
if( nIndexValue < -3 || nIndexValue >= nRows * nColumns )
return FALSE;
pabyData += 12;
if( nIndexValue == -3 )
{
dfDoubleRet = nIntRet = nBaseItemType;
}
else if( nIndexValue == -2 )
{
dfDoubleRet = nIntRet = nColumns;
}
else if( nIndexValue == -1 )
{
dfDoubleRet = nIntRet = nRows;
}
else if( nBaseItemType == EPT_u8 )
{
dfDoubleRet = pabyData[nIndexValue];
nIntRet = pabyData[nIndexValue];
}
else if( nBaseItemType == EPT_s16 )
{
GInt16 nValue;
memcpy( &nValue, pabyData + 2*nIndexValue, 2 );
HFAStandard( 2, &nValue );
dfDoubleRet = nValue;
nIntRet = nValue;
}
else if( nBaseItemType == EPT_u16 )
{
GUInt16 nValue;
memcpy( &nValue, pabyData + 2*nIndexValue, 2 );
HFAStandard( 2, &nValue );
dfDoubleRet = nValue;
nIntRet = nValue;
}
else if( nBaseItemType == EPT_s32 )
{
GInt32 nValue;
memcpy( &nValue, pabyData + 4*nIndexValue, 4 );
HFAStandard( 4, &nValue );
dfDoubleRet = nValue;
nIntRet = nValue;
}
else if( nBaseItemType == EPT_u32 )
{
GUInt32 nValue;
memcpy( &nValue, pabyData + 4*nIndexValue, 4 );
HFAStandard( 4, &nValue );
dfDoubleRet = nValue;
nIntRet = nValue;
}
else if( nBaseItemType == EPT_f32 )
{
float fValue;
memcpy( &fValue, pabyData + 4*nIndexValue, 4 );
HFAStandard( 4, &fValue );
dfDoubleRet = fValue;
nIntRet = (int) fValue;
}
else if( nBaseItemType == EPT_f64 )
{
double dfValue;
memcpy( &dfValue, pabyData+8*nIndexValue, 8 );
HFAStandard( 8, &dfValue );
dfDoubleRet = dfValue;
nIntRet = (int) dfValue;
}
else
{
CPLAssert( FALSE );
return FALSE;
}
}
break;
case 'o':
if( poItemObjectType != NULL )
{
int nExtraOffset = 0;
int iIndexCounter;
if( poItemObjectType->nBytes > 0 )
{
nExtraOffset = poItemObjectType->nBytes * nIndexValue;
}
else
{
for( iIndexCounter = 0;
iIndexCounter < nIndexValue;
iIndexCounter++ )
{
nExtraOffset +=
poItemObjectType->GetInstBytes(pabyData + nExtraOffset,
nDataSize - nExtraOffset);
}
}
pabyRawData = pabyData + nExtraOffset;
if( pszField != NULL && strlen(pszField) > 0 )
{
return( poItemObjectType->
ExtractInstValue( pszField, pabyRawData,
nDataOffset + nExtraOffset,
nDataSize - nExtraOffset,
chReqType, pReqReturn ) );
}
}
break;
default:
return FALSE;
break;
}
/* -------------------------------------------------------------------- */
/* Return the appropriate representation. */
/* -------------------------------------------------------------------- */
if( chReqType == 's' )
{
if( pszStringRet == NULL )
{
sprintf( szNumberString, "%.14g", dfDoubleRet );
pszStringRet = szNumberString;
}
*((char **) pReqReturn) = pszStringRet;
return( TRUE );
}
else if( chReqType == 'd' )
{
*((double *)pReqReturn) = dfDoubleRet;
return( TRUE );
}
else if( chReqType == 'i' )
{
*((int *) pReqReturn) = nIntRet;
return( TRUE );
}
else if( chReqType == 'p' )
{
*((GByte **) pReqReturn) = pabyRawData;
return( TRUE );
}
else
{
CPLAssert( FALSE );
return FALSE;
}
}
int main( int nArgc, char ** papszArgv )
{
int nColumns = 0;
int *panColumnList = NULL;
const char *pszTable = "horiz_cs";
const char *pszTablePath = "/usr/local/share/epsg_csv";
char **papszOptions = NULL;
char szFilename[1024];
int i, bSingletons = FALSE;
printf( "Content-type: text/html\n\n" );
/* -------------------------------------------------------------------- */
/* Parse the PATH_INFO. */
/* -------------------------------------------------------------------- */
if( getenv( "PATH_INFO" ) != NULL )
{
papszOptions = CSLTokenizeStringComplex( getenv("PATH_INFO") + 1,
"/", TRUE, TRUE );
}
/* -------------------------------------------------------------------- */
/* Add commandline switch to the option list. */
/* -------------------------------------------------------------------- */
for( i = 1; i < nArgc; i++ )
papszOptions = CSLAddString( papszOptions, papszArgv[i] );
/* -------------------------------------------------------------------- */
/* Process program options. */
/* -------------------------------------------------------------------- */
for( i = 0; papszOptions != NULL && papszOptions[i] != NULL; i++ )
{
if( EQUALN(papszOptions[i],"FIELDS=",7) )
{
char **papszList;
int j;
papszList = CSLTokenizeStringComplex( papszOptions[i]+7, ",",
TRUE, TRUE );
nColumns = CSLCount( papszList );
panColumnList = (int *) CPLRealloc(panColumnList,
sizeof(int) * nColumns);
for( j = 0; j < nColumns; j++ )
panColumnList[j] = atoi(papszList[j]);
CSLDestroy( papszList );
}
else if( EQUALN(papszOptions[i],"TABLE=",6) )
{
pszTable = papszOptions[i] + 6;
}
else if( EQUALN(papszOptions[i],"CODE=",5) )
{
bSingletons = TRUE;
}
else if( EQUALN(papszOptions[i],"SINGLETON",6) )
{
bSingletons = TRUE;
}
}
/* -------------------------------------------------------------------- */
/* Derive the full filename. */
/* -------------------------------------------------------------------- */
sprintf( szFilename, "%s/%s.csv", pszTablePath, pszTable );
/* -------------------------------------------------------------------- */
/* Call function to translate to HTML. */
/* -------------------------------------------------------------------- */
CSV2HTML( szFilename, nColumns, panColumnList, papszOptions,
bSingletons );
return 0;
}
void OGRFeature::SetField( int iField, OGRField * puValue )
{
OGRFieldDefn *poFDefn = poDefn->GetFieldDefn( iField );
CPLAssert( poFDefn != NULL || iField == -1 );
if( poFDefn == NULL )
return;
if( poFDefn->GetType() == OFTInteger )
{
pauFields[iField] = *puValue;
}
else if( poFDefn->GetType() == OFTReal )
{
pauFields[iField] = *puValue;
}
else if( poFDefn->GetType() == OFTString )
{
if( IsFieldSet( iField ) )
CPLFree( pauFields[iField].String );
if( puValue->String == NULL )
pauFields[iField].String = NULL;
else if( puValue->Set.nMarker1 == OGRUnsetMarker
&& puValue->Set.nMarker2 == OGRUnsetMarker )
pauFields[iField] = *puValue;
else
pauFields[iField].String = CPLStrdup( puValue->String );
}
else if( poFDefn->GetType() == OFTIntegerList )
{
int nCount = puValue->IntegerList.nCount;
if( IsFieldSet( iField ) )
CPLFree( pauFields[iField].IntegerList.paList );
if( puValue->Set.nMarker1 == OGRUnsetMarker
&& puValue->Set.nMarker2 == OGRUnsetMarker )
{
pauFields[iField] = *puValue;
}
else
{
pauFields[iField].IntegerList.paList =
(int *) CPLMalloc(sizeof(int) * nCount);
memcpy( pauFields[iField].IntegerList.paList,
puValue->IntegerList.paList,
sizeof(int) * nCount );
pauFields[iField].IntegerList.nCount = nCount;
}
}
else if( poFDefn->GetType() == OFTRealList )
{
int nCount = puValue->RealList.nCount;
if( IsFieldSet( iField ) )
CPLFree( pauFields[iField].RealList.paList );
if( puValue->Set.nMarker1 == OGRUnsetMarker
&& puValue->Set.nMarker2 == OGRUnsetMarker )
{
pauFields[iField] = *puValue;
}
else
{
pauFields[iField].RealList.paList =
(double *) CPLMalloc(sizeof(double) * nCount);
memcpy( pauFields[iField].RealList.paList,
puValue->RealList.paList,
sizeof(double) * nCount );
pauFields[iField].RealList.nCount = nCount;
}
}
else if( poFDefn->GetType() == OFTStringList )
{
if( IsFieldSet( iField ) )
CSLDestroy( pauFields[iField].StringList.paList );
if( puValue->Set.nMarker1 == OGRUnsetMarker
&& puValue->Set.nMarker2 == OGRUnsetMarker )
{
pauFields[iField] = *puValue;
}
else
{
pauFields[iField].StringList.paList =
CSLDuplicate( puValue->StringList.paList );
pauFields[iField].StringList.nCount = puValue->StringList.nCount;
CPLAssert( CSLCount(puValue->StringList.paList)
== puValue->StringList.nCount );
}
}
else
/* do nothing for other field types */;
}
static int msContourLayerReadRaster(layerObj *layer, rectObj rect)
{
mapObj *map = layer->map;
char **bands;
char pointer[64], memDSPointer[128];
int band = 1;
double adfGeoTransform[6], adfInvGeoTransform[6];
double llx, lly, urx, ury;
rectObj copyRect, mapRect;
int dst_xsize, dst_ysize;
int virtual_grid_step_x, virtual_grid_step_y;
int src_xoff, src_yoff, src_xsize, src_ysize;
double map_cellsize_x, map_cellsize_y, dst_cellsize_x, dst_cellsize_y;
GDALRasterBandH hBand = NULL;
CPLErr eErr;
contourLayerInfo *clinfo = (contourLayerInfo *) layer->layerinfo;
if (layer->debug)
msDebug("Entering msContourLayerReadRaster().\n");
if (clinfo == NULL || clinfo->hOrigDS == NULL) {
msSetError(MS_MISCERR, "Assertion failed: Contour layer not opened!!!",
"msContourLayerReadRaster()");
return MS_FAILURE;
}
bands = CSLTokenizeStringComplex(
CSLFetchNameValue(layer->processing,"BANDS"), " ,", FALSE, FALSE );
if (CSLCount(bands) > 0) {
band = atoi(bands[0]);
if (band < 1 || band > GDALGetRasterCount(clinfo->hOrigDS)) {
msSetError( MS_IMGERR,
"BANDS PROCESSING directive includes illegal band '%d', should be from 1 to %d.",
"msContourLayerReadRaster()",
band, GDALGetRasterCount(clinfo->hOrigDS));
CSLDestroy(bands);
return MS_FAILURE;
}
}
CSLDestroy(bands);
hBand = GDALGetRasterBand(clinfo->hOrigDS, band);
if (hBand == NULL)
{
msSetError(MS_IMGERR,
"Band %d does not exist on dataset.",
"msContourLayerReadRaster()", band);
return MS_FAILURE;
}
if (layer->projection.numargs > 0 &&
EQUAL(layer->projection.args[0], "auto")) {
const char *wkt;
wkt = GDALGetProjectionRef(clinfo->hOrigDS);
if (wkt != NULL && strlen(wkt) > 0) {
if (msOGCWKT2ProjectionObj(wkt, &(layer->projection),
layer->debug) != MS_SUCCESS) {
char msg[MESSAGELENGTH*2];
errorObj *ms_error = msGetErrorObj();
snprintf( msg, sizeof(msg),
"%s\n"
"PROJECTION AUTO cannot be used for this "
"GDAL raster (`%s').",
ms_error->message, layer->data);
msg[MESSAGELENGTH-1] = '\0';
msSetError(MS_OGRERR, "%s","msDrawRasterLayer()",
msg);
return MS_FAILURE;
}
}
}
/*
* Compute the georeferenced window of overlap, and read the source data
* downsampled to match output resolution, or at full resolution if
* output resolution is lower than the source resolution.
*
* A large portion of this overlap calculation code was borrowed from
* msDrawRasterLayerGDAL().
* Would be possible to move some of this to a reusable function?
*
* Note: This code works only if no reprojection is involved. It would
* need rework to support cases where output projection differs from source
* data file projection.
*/
src_xsize = GDALGetRasterXSize(clinfo->hOrigDS);
src_ysize = GDALGetRasterYSize(clinfo->hOrigDS);
/* set the Dataset extent */
msGetGDALGeoTransform(clinfo->hOrigDS, map, layer, adfGeoTransform);
clinfo->extent.minx = adfGeoTransform[0];
clinfo->extent.maxy = adfGeoTransform[3];
clinfo->extent.maxx = adfGeoTransform[0] + src_xsize * adfGeoTransform[1];
clinfo->extent.miny = adfGeoTransform[3] + src_ysize * adfGeoTransform[5];
if (layer->transform) {
if (layer->debug)
msDebug("msContourLayerReadRaster(): Entering transform.\n");
InvGeoTransform(adfGeoTransform, adfInvGeoTransform);
mapRect = rect;
map_cellsize_x = map_cellsize_y = map->cellsize;
#ifdef USE_PROJ
/* if necessary, project the searchrect to source coords */
if (msProjectionsDiffer( &(map->projection), &(layer->projection))) {
if ( msProjectRect(&map->projection, &layer->projection, &mapRect)
!= MS_SUCCESS ) {
msDebug("msContourLayerReadRaster(%s): unable to reproject map request rectangle into layer projection, canceling.\n", layer->name);
return MS_FAILURE;
}
map_cellsize_x = MS_CELLSIZE(mapRect.minx, mapRect.maxx, map->width);
map_cellsize_y = MS_CELLSIZE(mapRect.miny, mapRect.maxy, map->height);
/* if the projection failed to project the extent requested, we need to
calculate the cellsize to preserve the initial map cellsize ratio */
if ( (mapRect.minx < GEO_TRANS(adfGeoTransform,0,src_ysize)) ||
(mapRect.maxx > GEO_TRANS(adfGeoTransform,src_xsize,0)) ||
(mapRect.miny < GEO_TRANS(adfGeoTransform+3,0,src_ysize)) ||
(mapRect.maxy > GEO_TRANS(adfGeoTransform+3,src_xsize,0)) ) {
int src_unit, dst_unit;
src_unit = GetMapserverUnitUsingProj(&map->projection);
dst_unit = GetMapserverUnitUsingProj(&layer->projection);
if (src_unit == -1 || dst_unit == -1) {
msDebug("msContourLayerReadRaster(%s): unable to reproject map request rectangle into layer projection, canceling.\n", layer->name);
return MS_FAILURE;
}
map_cellsize_x = MS_CONVERT_UNIT(src_unit, dst_unit,
MS_CELLSIZE(rect.minx, rect.maxx, map->width));
map_cellsize_y = MS_CONVERT_UNIT(src_unit, dst_unit,
MS_CELLSIZE(rect.miny, rect.maxy, map->height));
}
}
#endif
if (map_cellsize_x == 0 || map_cellsize_y == 0) {
if (layer->debug)
msDebug("msContourLayerReadRaster(): Cellsize can't be 0.\n");
return MS_FAILURE;
}
/* Adjust MapServer pixel model to GDAL pixel model */
mapRect.minx -= map_cellsize_x*0.5;
mapRect.maxx += map_cellsize_x*0.5;
mapRect.miny -= map_cellsize_y*0.5;
mapRect.maxy += map_cellsize_y*0.5;
/*
* If raw data cellsize (from geotransform) is larger than output map_cellsize
* then we want to extract only enough data to match the output map resolution
* which means that GDAL will automatically sample the data on read.
*
* To prevent bad contour effects on tile edges, we adjust the target cellsize
* to align the extracted window with a virtual grid based on the origin of the
* raw data and a virtual grid step size corresponding to an integer sampling step.
*
* If source data has a greater cellsize (i.e. lower res) that requested ouptut map
* then we use the raw data cellsize as target cellsize since there is no point in
* interpolating the data for contours in this case.
*/
virtual_grid_step_x = (int)floor(map_cellsize_x / ABS(adfGeoTransform[1]));
if (virtual_grid_step_x < 1)
virtual_grid_step_x = 1; /* Do not interpolate data if grid sampling step < 1 */
virtual_grid_step_y = (int)floor(map_cellsize_y / ABS(adfGeoTransform[5]));
if (virtual_grid_step_y < 1)
virtual_grid_step_y = 1; /* Do not interpolate data if grid sampling step < 1 */
/* target cellsize is a multiple of raw data cellsize based on grid step*/
dst_cellsize_x = ABS(adfGeoTransform[1]) * virtual_grid_step_x;
dst_cellsize_y = ABS(adfGeoTransform[5]) * virtual_grid_step_y;
/* Compute overlap between source and target views */
copyRect = mapRect;
if (copyRect.minx < GEO_TRANS(adfGeoTransform,0,src_ysize))
copyRect.minx = GEO_TRANS(adfGeoTransform,0,src_ysize);
if (copyRect.maxx > GEO_TRANS(adfGeoTransform,src_xsize,0))
copyRect.maxx = GEO_TRANS(adfGeoTransform,src_xsize,0);
if (copyRect.miny < GEO_TRANS(adfGeoTransform+3,0,src_ysize))
copyRect.miny = GEO_TRANS(adfGeoTransform+3,0,src_ysize);
if (copyRect.maxy > GEO_TRANS(adfGeoTransform+3,src_xsize,0))
copyRect.maxy = GEO_TRANS(adfGeoTransform+3,src_xsize,0);
if (copyRect.minx >= copyRect.maxx || copyRect.miny >= copyRect.maxy) {
if (layer->debug)
msDebug("msContourLayerReadRaster(): Error in overlap calculation.\n");
return MS_FAILURE;
}
/*
* Convert extraction window to raster coordinates
*/
llx = GEO_TRANS(adfInvGeoTransform+0,copyRect.minx,copyRect.miny);
lly = GEO_TRANS(adfInvGeoTransform+3,copyRect.minx,copyRect.miny);
urx = GEO_TRANS(adfInvGeoTransform+0,copyRect.maxx,copyRect.maxy);
ury = GEO_TRANS(adfInvGeoTransform+3,copyRect.maxx,copyRect.maxy);
/*
* Align extraction window with virtual grid
* (keep in mind raster coordinates origin is at upper-left)
* We also add an extra buffer to fix tile boundarie issues when zoomed
*/
llx = floor(llx / virtual_grid_step_x) * virtual_grid_step_x - (virtual_grid_step_x*5);
urx = ceil(urx / virtual_grid_step_x) * virtual_grid_step_x + (virtual_grid_step_x*5);
ury = floor(ury / virtual_grid_step_y) * virtual_grid_step_y - (virtual_grid_step_x*5);
lly = ceil(lly / virtual_grid_step_y) * virtual_grid_step_y + (virtual_grid_step_x*5);
src_xoff = MAX(0,(int) floor(llx+0.5));
src_yoff = MAX(0,(int) floor(ury+0.5));
src_xsize = MIN(MAX(0,(int) (urx - llx + 0.5)),
GDALGetRasterXSize(clinfo->hOrigDS) - src_xoff);
src_ysize = MIN(MAX(0,(int) (lly - ury + 0.5)),
GDALGetRasterYSize(clinfo->hOrigDS) - src_yoff);
/* Update the geographic extent (buffer added) */
/* TODO: a better way to go the geo_trans */
copyRect.minx = GEO_TRANS(adfGeoTransform+0,src_xoff,0);
copyRect.maxx = GEO_TRANS(adfGeoTransform+0,src_xoff+src_xsize,0);
copyRect.miny = GEO_TRANS(adfGeoTransform+3,0,src_yoff+src_ysize);
copyRect.maxy = GEO_TRANS(adfGeoTransform+3,0,src_yoff);
/*
* If input window is to small then stop here
*/
if (src_xsize < 2 || src_ysize < 2)
{
if (layer->debug)
msDebug("msContourLayerReadRaster(): input window too small, or no apparent overlap between map view and this window(1).\n");
return MS_FAILURE;
}
/* Target buffer size */
dst_xsize = (int)ceil((copyRect.maxx - copyRect.minx) / dst_cellsize_x);
dst_ysize = (int)ceil((copyRect.maxy - copyRect.miny) / dst_cellsize_y);
if (dst_xsize == 0 || dst_ysize == 0) {
if (layer->debug)
msDebug("msContourLayerReadRaster(): no apparent overlap between map view and this window(2).\n");
return MS_FAILURE;
}
if (layer->debug)
msDebug( "msContourLayerReadRaster(): src=%d,%d,%d,%d, dst=%d,%d,%d,%d\n",
src_xoff, src_yoff, src_xsize, src_ysize,
0, 0, dst_xsize, dst_ysize );
} else {
src_xoff = 0;
src_yoff = 0;
dst_xsize = src_xsize = MIN(map->width,src_xsize);
dst_ysize = src_ysize = MIN(map->height,src_ysize);
}
/* -------------------------------------------------------------------- */
/* Allocate buffer, and read data into it. */
/* -------------------------------------------------------------------- */
clinfo->buffer = (double *) malloc(sizeof(double) * dst_xsize * dst_ysize);
if (clinfo->buffer == NULL) {
msSetError(MS_MEMERR, "Malloc(): Out of memory.", "msContourLayerReadRaster()");
return MS_FAILURE;
}
eErr = GDALRasterIO(hBand, GF_Read,
src_xoff, src_yoff, src_xsize, src_ysize,
clinfo->buffer, dst_xsize, dst_ysize, GDT_Float64,
0, 0);
if (eErr != CE_None) {
msSetError( MS_IOERR, "GDALRasterIO() failed: %s",
"msContourLayerReadRaster()", CPLGetLastErrorMsg() );
free(clinfo->buffer);
return MS_FAILURE;
}
memset(pointer, 0, sizeof(pointer));
CPLPrintPointer(pointer, clinfo->buffer, sizeof(pointer));
sprintf(memDSPointer,"MEM:::DATAPOINTER=%s,PIXELS=%d,LINES=%d,BANDS=1,DATATYPE=Float64",
pointer, dst_xsize, dst_ysize);
clinfo->hDS = GDALOpen(memDSPointer, GA_ReadOnly);
if (clinfo->hDS == NULL) {
msSetError(MS_IMGERR,
"Unable to open GDAL Memory dataset.",
"msContourLayerReadRaster()");
free(clinfo->buffer);
return MS_FAILURE;
}
adfGeoTransform[0] = copyRect.minx;
adfGeoTransform[1] = dst_cellsize_x;
adfGeoTransform[2] = 0;
adfGeoTransform[3] = copyRect.maxy;
adfGeoTransform[4] = 0;
adfGeoTransform[5] = -dst_cellsize_y;
clinfo->cellsize = MAX(dst_cellsize_x, dst_cellsize_y);
{
char buf[64];
sprintf(buf, "%lf", clinfo->cellsize);
msInsertHashTable(&layer->metadata, "__data_cellsize__", buf);
}
GDALSetGeoTransform(clinfo->hDS, adfGeoTransform);
return MS_SUCCESS;
}
GDALDataset *SAGADataset::Open( GDALOpenInfo * poOpenInfo )
{
/* -------------------------------------------------------------------- */
/* We assume the user is pointing to the binary (ie. .sdat) file. */
/* -------------------------------------------------------------------- */
if( !EQUAL(CPLGetExtension( poOpenInfo->pszFilename ), "sdat"))
{
return NULL;
}
CPLString osPath = CPLGetPath( poOpenInfo->pszFilename );
CPLString osName = CPLGetBasename( poOpenInfo->pszFilename );
CPLString osHDRFilename;
osHDRFilename = CPLFormCIFilename( osPath, osName, ".sgrd" );
FILE *fp;
fp = VSIFOpenL( osHDRFilename, "r" );
if( fp == NULL )
{
return NULL;
}
/* -------------------------------------------------------------------- */
/* Is this file a SAGA header file? Read a few lines of text */
/* searching for something starting with nrows or ncols. */
/* -------------------------------------------------------------------- */
const char *pszLine;
int nRows = -1, nCols = -1;
double dXmin = 0.0, dYmin = 0.0, dCellsize = 0.0, dNoData = 0.0, dZFactor = 0.0;
int nLineCount = 0;
char szDataFormat[20] = "DOUBLE";
char szByteOrderBig[10] = "FALSE";
char szTopToBottom[10] = "FALSE";
char **papszHDR = NULL;
while( (pszLine = CPLReadLineL( fp )) )
{
char **papszTokens;
nLineCount++;
if( nLineCount > 50 || strlen(pszLine) > 1000 )
break;
papszHDR = CSLAddString( papszHDR, pszLine );
papszTokens = CSLTokenizeStringComplex( pszLine, " =", TRUE, FALSE );
if( CSLCount( papszTokens ) < 2 )
{
CSLDestroy( papszTokens );
continue;
}
if( EQUALN(papszTokens[0],"CELLCOUNT_X",strlen("CELLCOUNT_X")) )
nCols = atoi(papszTokens[1]);
else if( EQUALN(papszTokens[0],"CELLCOUNT_Y",strlen("CELLCOUNT_Y")) )
nRows = atoi(papszTokens[1]);
else if( EQUALN(papszTokens[0],"POSITION_XMIN",strlen("POSITION_XMIN")) )
dXmin = atof(papszTokens[1]);
else if( EQUALN(papszTokens[0],"POSITION_YMIN",strlen("POSITION_YMIN")) )
dYmin = atof(papszTokens[1]);
else if( EQUALN(papszTokens[0],"CELLSIZE",strlen("CELLSIZE")) )
dCellsize = atof(papszTokens[1]);
else if( EQUALN(papszTokens[0],"NODATA_VALUE",strlen("NODATA_VALUE")) )
dNoData = atof(papszTokens[1]);
else if( EQUALN(papszTokens[0],"DATAFORMAT",strlen("DATAFORMAT")) )
strncpy( szDataFormat, papszTokens[1], sizeof(szDataFormat)-1 );
else if( EQUALN(papszTokens[0],"BYTEORDER_BIG",strlen("BYTEORDER_BIG")) )
strncpy( szByteOrderBig, papszTokens[1], sizeof(szByteOrderBig)-1 );
else if( EQUALN(papszTokens[0],"TOPTOBOTTOM",strlen("TOPTOBOTTOM")) )
strncpy( szTopToBottom, papszTokens[1], sizeof(szTopToBottom)-1 );
else if( EQUALN(papszTokens[0],"Z_FACTOR",strlen("Z_FACTOR")) )
dZFactor = atof(papszTokens[1]);
CSLDestroy( papszTokens );
}
VSIFCloseL( fp );
CSLDestroy( papszHDR );
/* -------------------------------------------------------------------- */
/* Did we get the required keywords? If not we return with */
/* this never having been considered to be a match. This isn't */
/* an error! */
/* -------------------------------------------------------------------- */
if( nRows == -1 || nCols == -1 )
{
return NULL;
}
if (!GDALCheckDatasetDimensions(nCols, nRows))
{
return NULL;
}
if( EQUALN(szTopToBottom,"TRUE",strlen("TRUE")) )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Currently the SAGA Binary Grid driver does not support\n"
"SAGA grids written TOPTOBOTTOM.\n");
return NULL;
}
if( dZFactor != 1.0)
{
CPLError( CE_Warning, CPLE_AppDefined,
"Currently the SAGA Binary Grid driver does not support\n"
"ZFACTORs other than 1.\n");
}
/* -------------------------------------------------------------------- */
/* Create a corresponding GDALDataset. */
/* -------------------------------------------------------------------- */
SAGADataset *poDS = new SAGADataset();
poDS->eAccess = poOpenInfo->eAccess;
if( poOpenInfo->eAccess == GA_ReadOnly )
poDS->fp = VSIFOpenL( poOpenInfo->pszFilename, "rb" );
else
poDS->fp = VSIFOpenL( poOpenInfo->pszFilename, "r+b" );
if( poDS->fp == NULL )
{
delete poDS;
CPLError( CE_Failure, CPLE_OpenFailed,
"VSIFOpenL(%s) failed unexpectedly.",
poOpenInfo->pszFilename );
return NULL;
}
poDS->nRasterXSize = nCols;
poDS->nRasterYSize = nRows;
SAGARasterBand *poBand = new SAGARasterBand( poDS, 1 );
/* -------------------------------------------------------------------- */
/* Figure out the byte order. */
/* -------------------------------------------------------------------- */
if( EQUALN(szByteOrderBig,"TRUE",strlen("TRUE")) )
poBand->m_ByteOrder = 1;
else if( EQUALN(szByteOrderBig,"FALSE",strlen("FALSE")) )
poBand->m_ByteOrder = 0;
/* -------------------------------------------------------------------- */
/* Figure out the data type. */
/* -------------------------------------------------------------------- */
if( EQUAL(szDataFormat,"BIT") )
{
poBand->SetDataType(GDT_Byte);
poBand->m_nBits = 8;
}
else if( EQUAL(szDataFormat,"BYTE_UNSIGNED") )
{
poBand->SetDataType(GDT_Byte);
poBand->m_nBits = 8;
}
else if( EQUAL(szDataFormat,"BYTE") )
{
poBand->SetDataType(GDT_Byte);
poBand->m_nBits = 8;
}
else if( EQUAL(szDataFormat,"SHORTINT_UNSIGNED") )
{
poBand->SetDataType(GDT_UInt16);
poBand->m_nBits = 16;
}
else if( EQUAL(szDataFormat,"SHORTINT") )
{
poBand->SetDataType(GDT_Int16);
poBand->m_nBits = 16;
}
else if( EQUAL(szDataFormat,"INTEGER_UNSIGNED") )
{
poBand->SetDataType(GDT_UInt32);
poBand->m_nBits = 32;
}
else if( EQUAL(szDataFormat,"INTEGER") )
{
poBand->SetDataType(GDT_Int32);
poBand->m_nBits = 32;
}
else if( EQUAL(szDataFormat,"FLOAT") )
{
poBand->SetDataType(GDT_Float32);
poBand->m_nBits = 32;
}
else if( EQUAL(szDataFormat,"DOUBLE") )
{
poBand->SetDataType(GDT_Float64);
poBand->m_nBits = 64;
}
else
{
CPLError( CE_Failure, CPLE_NotSupported,
"SAGA driver does not support the dataformat %s.",
szDataFormat );
delete poBand;
delete poDS;
return NULL;
}
/* -------------------------------------------------------------------- */
/* Save band information */
/* -------------------------------------------------------------------- */
poBand->m_Xmin = dXmin;
poBand->m_Ymin = dYmin;
poBand->m_NoData = dNoData;
poBand->m_Cellsize = dCellsize;
poBand->m_Rows = nRows;
poBand->m_Cols = nCols;
poDS->SetBand( 1, poBand );
poDS->SetDescription( poOpenInfo->pszFilename );
return poDS;
}
OGRCSVLayer::OGRCSVLayer( const char *pszLayerNameIn,
VSILFILE * fp, const char *pszFilename, int bNew, int bInWriteMode,
char chDelimiter, const char* pszNfdcGeomField,
const char* pszGeonamesGeomFieldPrefix)
{
fpCSV = fp;
iWktGeomReadField = -1;
iNfdcLatitudeS = iNfdcLongitudeS = -1;
iLatitudeField = iLongitudeField = -1;
this->bInWriteMode = bInWriteMode;
this->bNew = bNew;
this->pszFilename = CPLStrdup(pszFilename);
this->chDelimiter = chDelimiter;
bFirstFeatureAppendedDuringSession = TRUE;
bUseCRLF = FALSE;
bNeedRewindBeforeRead = FALSE;
eGeometryFormat = OGR_CSV_GEOM_NONE;
nNextFID = 1;
poFeatureDefn = new OGRFeatureDefn( pszLayerNameIn );
poFeatureDefn->Reference();
poFeatureDefn->SetGeomType( wkbNone );
bCreateCSVT = FALSE;
bDontHonourStrings = FALSE;
nTotalFeatures = -1;
/* -------------------------------------------------------------------- */
/* If this is not a new file, read ahead to establish if it is */
/* already in CRLF (DOS) mode, or just a normal unix CR mode. */
/* -------------------------------------------------------------------- */
if( !bNew && bInWriteMode )
{
int nBytesRead = 0;
char chNewByte;
while( nBytesRead < 10000 && VSIFReadL( &chNewByte, 1, 1, fpCSV ) == 1 )
{
if( chNewByte == 13 )
{
bUseCRLF = TRUE;
break;
}
}
VSIRewindL( fpCSV );
}
/* -------------------------------------------------------------------- */
/* Check if the first record seems to be field definitions or */
/* not. We assume it is field definitions if none of the */
/* values are strictly numeric. */
/* -------------------------------------------------------------------- */
char **papszTokens = NULL;
int nFieldCount=0, iField;
if( !bNew )
{
papszTokens = OGRCSVReadParseLineL( fpCSV, chDelimiter, FALSE );
nFieldCount = CSLCount( papszTokens );
bHasFieldNames = TRUE;
}
else
bHasFieldNames = FALSE;
for( iField = 0; iField < nFieldCount && bHasFieldNames; iField++ )
{
const char *pszToken = papszTokens[iField];
int bAllNumeric = TRUE;
if (*pszToken != '\0')
{
while( *pszToken != '\0' && bAllNumeric )
{
if( *pszToken != '.' && *pszToken != '-'
&& (*pszToken < '0' || *pszToken > '9') )
bAllNumeric = FALSE;
pszToken++;
}
if( bAllNumeric )
bHasFieldNames = FALSE;
}
}
if( !bNew && !bHasFieldNames )
VSIRewindL( fpCSV );
/* -------------------------------------------------------------------- */
/* Search a csvt file for types */
/* -------------------------------------------------------------------- */
char** papszFieldTypes = NULL;
if (!bNew) {
char* dname = strdup(CPLGetDirname(pszFilename));
char* fname = strdup(CPLGetBasename(pszFilename));
VSILFILE* fpCSVT = VSIFOpenL(CPLFormFilename(dname, fname, ".csvt"), "r");
free(dname);
free(fname);
if (fpCSVT!=NULL) {
VSIRewindL(fpCSVT);
papszFieldTypes = OGRCSVReadParseLineL(fpCSVT, ',', FALSE);
VSIFCloseL(fpCSVT);
}
}
/* -------------------------------------------------------------------- */
/* Build field definitions. */
/* -------------------------------------------------------------------- */
for( iField = 0; iField < nFieldCount; iField++ )
{
char *pszFieldName = NULL;
char szFieldNameBuffer[100];
if( bHasFieldNames )
{
pszFieldName = papszTokens[iField];
// trim white space.
while( *pszFieldName == ' ' )
pszFieldName++;
while( pszFieldName[0] != '\0'
&& pszFieldName[strlen(pszFieldName)-1] == ' ' )
pszFieldName[strlen(pszFieldName)-1] = '\0';
if (*pszFieldName == '\0')
pszFieldName = NULL;
}
if (pszFieldName == NULL)
{
pszFieldName = szFieldNameBuffer;
sprintf( szFieldNameBuffer, "field_%d", iField+1 );
}
OGRFieldDefn oField(pszFieldName, OFTString);
if (papszFieldTypes!=NULL && iField<CSLCount(papszFieldTypes)) {
char* pszLeftParenthesis = strchr(papszFieldTypes[iField], '(');
if (pszLeftParenthesis && pszLeftParenthesis != papszFieldTypes[iField] &&
pszLeftParenthesis[1] >= '0' && pszLeftParenthesis[1] <= '9')
{
int nWidth = 0;
int nPrecision = 0;
char* pszDot = strchr(pszLeftParenthesis, '.');
if (pszDot) *pszDot = 0;
*pszLeftParenthesis = 0;
if (pszLeftParenthesis[-1] == ' ')
pszLeftParenthesis[-1] = 0;
nWidth = atoi(pszLeftParenthesis+1);
if (pszDot)
nPrecision = atoi(pszDot+1);
oField.SetWidth(nWidth);
oField.SetPrecision(nPrecision);
}
if (EQUAL(papszFieldTypes[iField], "Integer"))
oField.SetType(OFTInteger);
else if (EQUAL(papszFieldTypes[iField], "Real"))
oField.SetType(OFTReal);
else if (EQUAL(papszFieldTypes[iField], "String"))
oField.SetType(OFTString);
else if (EQUAL(papszFieldTypes[iField], "Date"))
oField.SetType(OFTDate);
else if (EQUAL(papszFieldTypes[iField], "Time"))
oField.SetType(OFTTime);
else if (EQUAL(papszFieldTypes[iField], "DateTime"))
oField.SetType(OFTDateTime);
else
CPLError(CE_Warning, CPLE_NotSupported, "Unknown type : %s", papszFieldTypes[iField]);
}
if( EQUAL(oField.GetNameRef(),"WKT")
&& oField.GetType() == OFTString
&& iWktGeomReadField == -1 )
{
iWktGeomReadField = iField;
poFeatureDefn->SetGeomType( wkbUnknown );
}
/*http://www.faa.gov/airports/airport_safety/airportdata_5010/menu/index.cfm specific */
if ( pszNfdcGeomField != NULL &&
EQUALN(oField.GetNameRef(), pszNfdcGeomField, strlen(pszNfdcGeomField)) &&
EQUAL(oField.GetNameRef() + strlen(pszNfdcGeomField), "LatitudeS") )
iNfdcLatitudeS = iField;
else if ( pszNfdcGeomField != NULL &&
EQUALN(oField.GetNameRef(), pszNfdcGeomField, strlen(pszNfdcGeomField)) &&
EQUAL(oField.GetNameRef() + strlen(pszNfdcGeomField), "LongitudeS") )
iNfdcLongitudeS = iField;
/* GNIS specific */
else if ( pszGeonamesGeomFieldPrefix != NULL &&
EQUALN(oField.GetNameRef(), pszGeonamesGeomFieldPrefix, strlen(pszGeonamesGeomFieldPrefix)) &&
(EQUAL(oField.GetNameRef() + strlen(pszGeonamesGeomFieldPrefix), "_LAT_DEC") ||
EQUAL(oField.GetNameRef() + strlen(pszGeonamesGeomFieldPrefix), "_LATITUDE_DEC") ||
EQUAL(oField.GetNameRef() + strlen(pszGeonamesGeomFieldPrefix), "_LATITUDE")) )
{
oField.SetType(OFTReal);
iLatitudeField = iField;
}
else if ( pszGeonamesGeomFieldPrefix != NULL &&
EQUALN(oField.GetNameRef(), pszGeonamesGeomFieldPrefix, strlen(pszGeonamesGeomFieldPrefix)) &&
(EQUAL(oField.GetNameRef() + strlen(pszGeonamesGeomFieldPrefix), "_LONG_DEC") ||
EQUAL(oField.GetNameRef() + strlen(pszGeonamesGeomFieldPrefix), "_LONGITUDE_DEC") ||
EQUAL(oField.GetNameRef() + strlen(pszGeonamesGeomFieldPrefix), "_LONGITUDE")) )
{
oField.SetType(OFTReal);
iLongitudeField = iField;
}
poFeatureDefn->AddFieldDefn( &oField );
}
if ( iNfdcLatitudeS != -1 && iNfdcLongitudeS != -1 )
{
bDontHonourStrings = TRUE;
poFeatureDefn->SetGeomType( wkbPoint );
}
else if ( iLatitudeField != -1 && iLongitudeField != -1 )
{
poFeatureDefn->SetGeomType( wkbPoint );
}
CSLDestroy( papszTokens );
CSLDestroy( papszFieldTypes );
}
GDALDataset *HDF4Dataset::Open( GDALOpenInfo * poOpenInfo )
{
if( !Identify( poOpenInfo ) )
return NULL;
CPLMutexHolderD(&hHDF4Mutex);
/* -------------------------------------------------------------------- */
/* Try opening the dataset. */
/* -------------------------------------------------------------------- */
// Attempt to increase maximum number of opened HDF files.
#ifdef HDF4_HAS_MAXOPENFILES
intn nCurrMax = 0;
intn nSysLimit = 0;
if ( SDget_maxopenfiles(&nCurrMax, &nSysLimit) >= 0
&& nCurrMax < nSysLimit )
{
/*intn res = */SDreset_maxopenfiles( nSysLimit );
}
#endif /* HDF4_HAS_MAXOPENFILES */
int32 hHDF4 = Hopen(poOpenInfo->pszFilename, DFACC_READ, 0);
if( hHDF4 <= 0 )
return NULL;
Hclose( hHDF4 );
/* -------------------------------------------------------------------- */
/* Create a corresponding GDALDataset. */
/* -------------------------------------------------------------------- */
// Release mutex otherwise we will deadlock with GDALDataset own mutex.
CPLReleaseMutex(hHDF4Mutex);
HDF4Dataset *poDS = new HDF4Dataset();
CPLAcquireMutex(hHDF4Mutex, 1000.0);
if( poOpenInfo->fpL != NULL )
{
VSIFCloseL(poOpenInfo->fpL);
poOpenInfo->fpL = NULL;
}
/* -------------------------------------------------------------------- */
/* Open HDF SDS Interface. */
/* -------------------------------------------------------------------- */
poDS->hSD = SDstart( poOpenInfo->pszFilename, DFACC_READ );
if ( poDS->hSD == -1 )
{
// Release mutex otherwise we will deadlock with GDALDataset own mutex.
CPLReleaseMutex(hHDF4Mutex);
delete poDS;
CPLAcquireMutex(hHDF4Mutex, 1000.0);
CPLError( CE_Failure, CPLE_OpenFailed,
"Failed to open HDF4 file \"%s\" for SDS reading.",
poOpenInfo->pszFilename );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Now read Global Attributes. */
/* -------------------------------------------------------------------- */
if ( poDS->ReadGlobalAttributes( poDS->hSD ) != CE_None )
{
// Release mutex otherwise we will deadlock with GDALDataset own mutex.
CPLReleaseMutex(hHDF4Mutex);
delete poDS;
CPLAcquireMutex(hHDF4Mutex, 1000.0);
CPLError( CE_Failure, CPLE_OpenFailed,
"Failed to read global attributes from HDF4 file \"%s\".",
poOpenInfo->pszFilename );
return NULL;
}
poDS->SetMetadata( poDS->papszGlobalMetadata, "" );
/* -------------------------------------------------------------------- */
/* Determine type of file we read. */
/* -------------------------------------------------------------------- */
const char *pszValue = CSLFetchNameValue(poDS->papszGlobalMetadata,
"Signature");
if ( pszValue != NULL && EQUAL( pszValue, pszGDALSignature ) )
{
poDS->iSubdatasetType = H4ST_GDAL;
poDS->pszSubdatasetType = "GDAL_HDF4";
}
else if ( (pszValue = CSLFetchNameValue(poDS->papszGlobalMetadata,
"Title")) != NULL
&& EQUAL( pszValue, "SeaWiFS Level-1A Data" ) )
{
poDS->iSubdatasetType = H4ST_SEAWIFS_L1A;
poDS->pszSubdatasetType = "SEAWIFS_L1A";
}
else if ( (pszValue = CSLFetchNameValue(poDS->papszGlobalMetadata,
"Title")) != NULL
&& EQUAL( pszValue, "SeaWiFS Level-2 Data" ) )
{
poDS->iSubdatasetType = H4ST_SEAWIFS_L2;
poDS->pszSubdatasetType = "SEAWIFS_L2";
}
else if ( (pszValue = CSLFetchNameValue(poDS->papszGlobalMetadata,
"Title")) != NULL
&& 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")) != NULL
&& STARTS_WITH_CI(pszValue, "HYP version ") )
{
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. */
/* -------------------------------------------------------------------- */
int32 aiDimSizes[H4_MAX_VAR_DIMS] = {}; // TODO: Get this off of the stack.
int32 iRank = 0;
int32 iNumType = 0;
int32 nAttrs = 0;
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") )
{
/* -------------------------------------------------------------------- */
/* Process swath layers. */
/* -------------------------------------------------------------------- */
hHDF4 = SWopen( poOpenInfo->pszFilename, DFACC_READ );
if( hHDF4 < 0)
{
// Release mutex otherwise we will deadlock with GDALDataset own
// mutex.
CPLReleaseMutex(hHDF4Mutex);
delete poDS;
CPLAcquireMutex(hHDF4Mutex, 1000.0);
CPLError( CE_Failure, CPLE_OpenFailed,
"Failed to open HDF-EOS file \"%s\" for swath reading.",
poOpenInfo->pszFilename );
return NULL;
}
int32 nStrBufSize = 0;
int32 nSubDatasets =
SWinqswath(poOpenInfo->pszFilename, NULL, &nStrBufSize);
#ifdef DEBUG
CPLDebug( "HDF4", "Number of HDF-EOS swaths: %d",
static_cast<int>( nSubDatasets ) );
#endif
if ( nSubDatasets > 0 && nStrBufSize > 0 )
{
char *pszSwathList =
static_cast<char *>( CPLMalloc( nStrBufSize + 1 ) );
SWinqswath( poOpenInfo->pszFilename, pszSwathList, &nStrBufSize );
pszSwathList[nStrBufSize] = '\0';
#ifdef DEBUG
CPLDebug( "HDF4", "List of HDF-EOS swaths: %s", pszSwathList );
#endif
char **papszSwaths =
CSLTokenizeString2( pszSwathList, ",", CSLT_HONOURSTRINGS );
CPLFree( pszSwathList );
if ( nSubDatasets != CSLCount(papszSwaths) )
{
CSLDestroy( papszSwaths );
// Release mutex otherwise we will deadlock with GDALDataset own
// mutex.
CPLReleaseMutex(hHDF4Mutex);
delete poDS;
CPLAcquireMutex(hHDF4Mutex, 1000.0);
CPLDebug( "HDF4", "Cannot parse list of HDF-EOS grids." );
return NULL;
}
for( int32 i = 0; i < nSubDatasets; i++)
{
const int32 hSW = SWattach( hHDF4, papszSwaths[i] );
const int32 nFields
= SWnentries( hSW, HDFE_NENTDFLD, &nStrBufSize );
char *pszFieldList = static_cast<char *>(
CPLMalloc( nStrBufSize + 1 ) );
int32 *paiRank = static_cast<int32 *>(
CPLMalloc( nFields * sizeof(int32) ) );
int32 *paiNumType = static_cast<int32 *>(
CPLMalloc( nFields * sizeof(int32) ) );
SWinqdatafields( hSW, pszFieldList, paiRank, paiNumType );
#ifdef DEBUG
{
char * const pszTmp =
SPrintArray( GDT_UInt32, paiRank, nFields, "," );
CPLDebug( "HDF4", "Number of data fields in swath %d: %d",
static_cast<int>( i ),
static_cast<int>( nFields ) );
CPLDebug( "HDF4", "List of data fields in swath %d: %s",
static_cast<int>( i ), pszFieldList );
CPLDebug( "HDF4", "Data fields ranks: %s", pszTmp );
CPLFree( pszTmp );
}
#endif
char **papszFields = CSLTokenizeString2( pszFieldList, ",",
CSLT_HONOURSTRINGS );
char szTemp[256] = {'\0'}; // TODO: Get this off the stack.
for( int32 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.
const int nCount = CSLCount( poDS->papszSubDatasets ) / 2;
snprintf( szTemp, sizeof(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]) );
snprintf( szTemp, sizeof(szTemp),
"SUBDATASET_%d_DESC", nCount + 1 );
char *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 );
szTemp[0] = '\0';
}
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 );
#ifdef DEBUG
CPLDebug( "HDF4", "Number of HDF-EOS grids: %d",
static_cast<int>( nSubDatasets ) );
#endif
if ( nSubDatasets > 0 && nStrBufSize > 0 )
{
char *pszGridList
= static_cast<char *>( CPLMalloc( nStrBufSize + 1 ) );
GDinqgrid( poOpenInfo->pszFilename, pszGridList, &nStrBufSize );
#ifdef DEBUG
CPLDebug( "HDF4", "List of HDF-EOS grids: %s", pszGridList );
#endif
char **papszGrids =
CSLTokenizeString2( pszGridList, ",", CSLT_HONOURSTRINGS );
CPLFree( pszGridList );
if ( nSubDatasets != CSLCount(papszGrids) )
{
CSLDestroy( papszGrids );
GDclose( hHDF4 );
// Release mutex otherwise we will deadlock with GDALDataset own
// mutex.
CPLReleaseMutex(hHDF4Mutex);
delete poDS;
CPLAcquireMutex(hHDF4Mutex, 1000.0);
CPLDebug( "HDF4", "Cannot parse list of HDF-EOS grids." );
return NULL;
}
for( int32 i = 0; i < nSubDatasets; i++)
{
const int32 hGD = GDattach( hHDF4, papszGrids[i] );
const int32 nFields
= GDnentries( hGD, HDFE_NENTDFLD, &nStrBufSize );
char *pszFieldList = static_cast<char *>(
CPLMalloc( nStrBufSize + 1 ) );
int32 *paiRank = static_cast<int32 *>(
CPLMalloc( nFields * sizeof(int32) ) );
int32 *paiNumType = static_cast<int32 *>(
CPLMalloc( nFields * sizeof(int32) ) );
GDinqfields( hGD, pszFieldList, paiRank, paiNumType );
#ifdef DEBUG
{
char* pszTmp =
SPrintArray( GDT_UInt32, paiRank, nFields, "," );
CPLDebug( "HDF4", "Number of fields in grid %d: %d",
static_cast<int>( i ),
static_cast<int>( nFields ) );
CPLDebug( "HDF4", "List of fields in grid %d: %s",
static_cast<int>( i ), pszFieldList );
CPLDebug( "HDF4", "Fields ranks: %s", pszTmp );
CPLFree( pszTmp );
}
#endif
char **papszFields = CSLTokenizeString2( pszFieldList, ",",
CSLT_HONOURSTRINGS );
char szTemp[256];
for( int32 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
const int nCount = CSLCount( poDS->papszSubDatasets ) / 2;
snprintf( szTemp, sizeof(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]));
snprintf( szTemp, sizeof(szTemp),
"SUBDATASET_%d_DESC", nCount + 1 );
char *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 );
bIsHDF = ( nSubDatasets == 0 ); // Try to read as HDF
}
char szName[VSNAMELENMAX + 1];
if( bIsHDF )
{
/* -------------------------------------------------------------------- */
/* Make a list of subdatasets from SDSs contained in input HDF file. */
/* -------------------------------------------------------------------- */
int32 nDatasets = 0;
if ( SDfileinfo( poDS->hSD, &nDatasets, &nAttrs ) != 0 )
return NULL;
char szTemp[256] = {'\0'}; // TODO: Get this off the stack.
const char *pszName = NULL;
for( int32 i = 0; i < nDatasets; i++ )
{
const int32 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 ) &&
!STARTS_WITH_CI(szName, "l1a_data") )
continue;
else
pszName = szName;
// Add datasets with multiple dimensions to the list of GDAL
// subdatasets.
const int nCount = CSLCount( poDS->papszSubDatasets ) / 2;
snprintf( szTemp, sizeof(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,
static_cast<long>( i ) ) );
snprintf( szTemp, sizeof(szTemp),
"SUBDATASET_%d_DESC", nCount + 1 );
char *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 );
szTemp[0] = '\0';
}
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 )
{
// Release mutex otherwise we will deadlock with GDALDataset own
// mutex.
CPLReleaseMutex(hHDF4Mutex);
GRend( poDS->hGR );
poDS->hGR = 0;
Hclose( hHDF4 );
delete poDS;
CPLAcquireMutex(hHDF4Mutex, 1000.0);
return NULL;
}
char szTemp[256] = {'\0'}; // TODO: Get this off the stack.
for( int32 i = 0; i < poDS->nImages; i++ )
{
const 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.
int32 iInterlaceMode = 0;
if ( GRgetiminfo( iGR, szName, &iRank, &iNumType, &iInterlaceMode,
aiDimSizes, &nAttrs ) != 0 )
{
// Release mutex otherwise we will deadlock with GDALDataset
// own mutex.
CPLReleaseMutex(hHDF4Mutex);
GRend( poDS->hGR );
poDS->hGR = 0;
Hclose( hHDF4 );
delete poDS;
CPLAcquireMutex(hHDF4Mutex, 1000.0);
return NULL;
}
const int nCount = CSLCount( poDS->papszSubDatasets ) / 2;
snprintf( szTemp, sizeof(szTemp),
"SUBDATASET_%d_NAME", nCount + 1 );
poDS->papszSubDatasets = CSLSetNameValue(poDS->papszSubDatasets,
szTemp,CPLSPrintf( "HDF4_GR:UNKNOWN:\"%s\":%ld",
poOpenInfo->pszFilename,
static_cast<long>( i ) ) );
snprintf( szTemp, sizeof(szTemp),
"SUBDATASET_%d_DESC", nCount + 1 );
char *pszString = SPrintArray( GDT_UInt32, aiDimSizes, 2, "x" );
poDS->papszSubDatasets = CSLSetNameValue(poDS->papszSubDatasets,
szTemp, CPLSPrintf( "[%sx%ld] %s (%s)", pszString,
static_cast<long>( iRank ),
szName, poDS->GetDataTypeName(iNumType)) );
CPLFree( pszString );
GRendaccess( iGR );
szTemp[0] = '\0';
}
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 = CPLStrdup( CSLFetchNameValue( poDS->papszSubDatasets,
"SUBDATASET_1_NAME" ));
// Release mutex otherwise we will deadlock with GDALDataset own mutex.
CPLReleaseMutex(hHDF4Mutex);
delete poDS;
poDS = NULL;
GDALDataset* poRetDS = reinterpret_cast<GDALDataset*>(
GDALOpen( pszSDSName, poOpenInfo->eAccess ) );
CPLFree( pszSDSName );
CPLAcquireMutex(hHDF4Mutex, 1000.0);
if (poRetDS)
{
poRetDS->SetDescription(poOpenInfo->pszFilename);
}
return poRetDS;
}
else
{
/* -------------------------------------------------------------------- */
/* Confirm the requested access is supported. */
/* -------------------------------------------------------------------- */
if( poOpenInfo->eAccess == GA_Update )
{
// Release mutex otherwise we will deadlock with GDALDataset own
// mutex.
CPLReleaseMutex(hHDF4Mutex);
delete poDS;
CPLAcquireMutex(hHDF4Mutex, 1000.0);
CPLError( CE_Failure, CPLE_NotSupported,
"The HDF4 driver does not support update access to "
"existing datasets." );
return NULL;
}
}
return poDS;
}
void BAGDataset::LoadMetadata()
{
/* -------------------------------------------------------------------- */
/* Load the metadata from the file. */
/* -------------------------------------------------------------------- */
hid_t hMDDS = H5Dopen( hHDF5, "/BAG_root/metadata" );
hid_t datatype = H5Dget_type( hMDDS );
hid_t dataspace = H5Dget_space( hMDDS );
hid_t native = H5Tget_native_type( datatype, H5T_DIR_ASCEND );
hsize_t dims[3], maxdims[3];
H5Sget_simple_extent_dims( dataspace, dims, maxdims );
pszXMLMetadata = (char *) CPLCalloc((int) (dims[0]+1),1);
H5Dread( hMDDS, native, H5S_ALL, dataspace, H5P_DEFAULT, pszXMLMetadata );
H5Tclose( native );
H5Sclose( dataspace );
H5Tclose( datatype );
H5Dclose( hMDDS );
if( strlen(pszXMLMetadata) == 0 )
return;
/* -------------------------------------------------------------------- */
/* Try to get the geotransform. */
/* -------------------------------------------------------------------- */
CPLXMLNode *psRoot = CPLParseXMLString( pszXMLMetadata );
if( psRoot == NULL )
return;
CPLStripXMLNamespace( psRoot, NULL, TRUE );
CPLXMLNode *psGeo = CPLSearchXMLNode( psRoot, "=MD_Georectified" );
if( psGeo != NULL )
{
char **papszCornerTokens =
CSLTokenizeStringComplex(
CPLGetXMLValue( psGeo, "cornerPoints.Point.coordinates", "" ),
" ,", FALSE, FALSE );
if( CSLCount(papszCornerTokens ) == 4 )
{
double dfLLX = atof( papszCornerTokens[0] );
double dfLLY = atof( papszCornerTokens[1] );
double dfURX = atof( papszCornerTokens[2] );
double dfURY = atof( papszCornerTokens[3] );
adfGeoTransform[0] = dfLLX;
adfGeoTransform[1] = (dfURX - dfLLX) / (GetRasterXSize()-1);
adfGeoTransform[3] = dfURY;
adfGeoTransform[5] = (dfLLY - dfURY) / (GetRasterYSize()-1);
adfGeoTransform[0] -= adfGeoTransform[1] * 0.5;
adfGeoTransform[3] -= adfGeoTransform[5] * 0.5;
}
CSLDestroy( papszCornerTokens );
}
/* -------------------------------------------------------------------- */
/* Try to get the coordinate system. */
/* -------------------------------------------------------------------- */
OGRSpatialReference oSRS;
if( OGR_SRS_ImportFromISO19115( &oSRS, pszXMLMetadata )
== OGRERR_NONE )
{
oSRS.exportToWkt( &pszProjection );
}
else
{
ParseWKTFromXML( pszXMLMetadata );
}
/* -------------------------------------------------------------------- */
/* Fetch acquisition date. */
/* -------------------------------------------------------------------- */
CPLXMLNode *psDateTime = CPLSearchXMLNode( psRoot, "=dateTime" );
if( psDateTime != NULL )
{
const char *pszDateTimeValue = CPLGetXMLValue( psDateTime, NULL, "" );
if( pszDateTimeValue )
SetMetadataItem( "BAG_DATETIME", pszDateTimeValue );
}
CPLDestroyXMLNode( psRoot );
}
OGRFeature *OGRHTFPolygonLayer::GetNextRawFeature()
{
OGRFeature* poFeature = new OGRFeature(poFeatureDefn);
const char* pszLine;
OGRLinearRing oLR;
bool bHasFirstCoord = false;
double dfFirstEasting = 0;
double dfFirstNorthing = 0;
double dfIslandEasting = 0;
double dfIslandNorthing = 0;
bool bInIsland = false;
OGRPolygon* poPoly = new OGRPolygon();
while( (pszLine = CPLReadLine2L(fpHTF, 1024, NULL)) != NULL)
{
if (pszLine[0] == ';')
{
/* comment */ ;
}
else if (pszLine[0] == 0)
{
/* end of polygon is marked by a blank line */
break;
}
else if (STARTS_WITH(pszLine, "POLYGON DESCRIPTION: "))
{
poFeature->SetField(0, pszLine + strlen("POLYGON DESCRIPTION: "));
}
else if (STARTS_WITH(pszLine, "POLYGON IDENTIFIER: "))
{
poFeature->SetField(1, pszLine + strlen("POLYGON IDENTIFIER: "));
}
else if (STARTS_WITH(pszLine, "SEAFLOOR COVERAGE: "))
{
const char* pszVal = pszLine + strlen("SEAFLOOR COVERAGE: ");
if (*pszVal != '*')
poFeature->SetField(2, pszVal);
}
else if (STARTS_WITH(pszLine, "POSITION ACCURACY: "))
{
const char* pszVal = pszLine + strlen("POSITION ACCURACY: ");
if (*pszVal != '*')
poFeature->SetField(3, pszVal);
}
else if (STARTS_WITH(pszLine, "DEPTH ACCURACY: "))
{
const char* pszVal = pszLine + strlen("DEPTH ACCURACY: ");
if (*pszVal != '*')
poFeature->SetField(4, pszVal);
}
else if (strcmp(pszLine, "END OF POLYGON DATA") == 0)
{
bEOF = true;
break;
}
else
{
char** papszTokens = CSLTokenizeString(pszLine);
if (CSLCount(papszTokens) == 4)
{
const double dfEasting = CPLAtof(papszTokens[2]);
const double dfNorthing = CPLAtof(papszTokens[3]);
if (!bHasFirstCoord)
{
bHasFirstCoord = true;
dfFirstEasting = dfEasting;
dfFirstNorthing = dfNorthing;
oLR.addPoint(dfEasting, dfNorthing);
}
else if (dfFirstEasting == dfEasting &&
dfFirstNorthing == dfNorthing)
{
if (!bInIsland)
{
oLR.addPoint(dfEasting, dfNorthing);
poPoly->addRing(&oLR);
oLR.empty();
bInIsland = true;
}
}
else if (bInIsland && oLR.getNumPoints() == 0)
{
dfIslandEasting = dfEasting;
dfIslandNorthing = dfNorthing;
oLR.addPoint(dfEasting, dfNorthing);
}
else if (bInIsland && dfIslandEasting == dfEasting &&
dfIslandNorthing == dfNorthing)
{
oLR.addPoint(dfEasting, dfNorthing);
poPoly->addRing(&oLR);
oLR.empty();
}
else
{
oLR.addPoint(dfEasting, dfNorthing);
}
}
CSLDestroy(papszTokens);
}
}
if (pszLine == NULL)
bEOF = true;
if (oLR.getNumPoints() >= 3)
{
oLR.closeRings();
poPoly->addRing(&oLR);
}
poPoly->assignSpatialReference(poSRS);
poFeature->SetGeometryDirectly(poPoly);
poFeature->SetFID(nNextFID++);
return poFeature;
}
GDALDataset *AirSARDataset::Open( GDALOpenInfo * poOpenInfo )
{
if( poOpenInfo->fp == NULL || poOpenInfo->nHeaderBytes < 800 )
return NULL;
/* -------------------------------------------------------------------- */
/* Check for AirSAR/ keyword. */
/* -------------------------------------------------------------------- */
if( !EQUALN((char *) poOpenInfo->pabyHeader, "RECORD LENGTH IN BYTES",22) )
return NULL;
if( strstr((char *) poOpenInfo->pabyHeader, "COMPRESSED") == NULL
|| strstr((char *) poOpenInfo->pabyHeader, "JPL AIRCRAFT") == NULL )
return NULL;
/* -------------------------------------------------------------------- */
/* Parse the header fields. We turn all the transform the */
/* keywords by converting spaces to underscores so they will be */
/* "well behaved" as metadata keywords. */
/* -------------------------------------------------------------------- */
char **papszMD = ReadHeader( poOpenInfo->fp, 0, "MH", 20 );
if( papszMD == NULL )
return NULL;
/* -------------------------------------------------------------------- */
/* Confirm the requested access is supported. */
/* -------------------------------------------------------------------- */
if( poOpenInfo->eAccess == GA_Update )
{
CPLError( CE_Failure, CPLE_NotSupported,
"The AIRSAR driver does not support update access to existing"
" datasets.\n" );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Create a corresponding GDALDataset. */
/* -------------------------------------------------------------------- */
AirSARDataset *poDS;
poDS = new AirSARDataset();
/* -------------------------------------------------------------------- */
/* Extract some key information. */
/* -------------------------------------------------------------------- */
poDS->nRasterXSize =
atoi(CSLFetchNameValue(papszMD,"MH_NUMBER_OF_SAMPLES_PER_RECORD"));
poDS->nRasterYSize =
atoi(CSLFetchNameValue(papszMD,"MH_NUMBER_OF_LINES_IN_IMAGE"));
poDS->nRecordLength = atoi(
CSLFetchNameValue( papszMD, "MH_RECORD_LENGTH_IN_BYTES" ) );
poDS->nDataStart = atoi(
CSLFetchNameValue( papszMD, "MH_BYTE_OFFSET_OF_FIRST_DATA_RECORD" ));
/* -------------------------------------------------------------------- */
/* Adopt the openinfo file pointer. */
/* -------------------------------------------------------------------- */
poDS->fp = poOpenInfo->fp;
poOpenInfo->fp = NULL;
/* -------------------------------------------------------------------- */
/* Read and merge parameter header into metadata. Prefix */
/* parameter header values with PH_. */
/* -------------------------------------------------------------------- */
int nPHOffset = 0;
if( CSLFetchNameValue( papszMD,
"MH_BYTE_OFFSET_OF_PARAMETER_HEADER" ) != NULL )
{
nPHOffset = atoi(CSLFetchNameValue(
papszMD, "MH_BYTE_OFFSET_OF_PARAMETER_HEADER"));
char **papszPHInfo = ReadHeader( poDS->fp, nPHOffset, "PH", 100 );
papszMD = CSLInsertStrings( papszMD, CSLCount(papszMD), papszPHInfo );
CSLDestroy( papszPHInfo );
}
/* -------------------------------------------------------------------- */
/* Read and merge calibration header into metadata. Prefix */
/* parameter header values with CH_. */
/* -------------------------------------------------------------------- */
if( nPHOffset != 0 )
{
char **papszCHInfo = ReadHeader( poDS->fp,
nPHOffset+poDS->nRecordLength,
"CH", 18 );
papszMD = CSLInsertStrings( papszMD, CSLCount(papszMD), papszCHInfo );
CSLDestroy( papszCHInfo );
}
/* -------------------------------------------------------------------- */
/* Assign metadata to dataset. */
/* -------------------------------------------------------------------- */
poDS->SetMetadata( papszMD );
CSLDestroy( papszMD );
/* -------------------------------------------------------------------- */
/* Create band information objects. */
/* -------------------------------------------------------------------- */
poDS->SetBand( 1, new AirSARRasterBand( poDS, 1 ));
poDS->SetBand( 2, new AirSARRasterBand( poDS, 2 ));
poDS->SetBand( 3, new AirSARRasterBand( poDS, 3 ));
poDS->SetBand( 4, new AirSARRasterBand( poDS, 4 ));
poDS->SetBand( 5, new AirSARRasterBand( poDS, 5 ));
poDS->SetBand( 6, new AirSARRasterBand( poDS, 6 ));
poDS->SetMetadataItem( "MATRIX_REPRESENTATION", "SYMMETRIZED_COVARIANCE" );
/* -------------------------------------------------------------------- */
/* Initialize any PAM information. */
/* -------------------------------------------------------------------- */
poDS->SetDescription( poOpenInfo->pszFilename );
poDS->TryLoadXML();
poDS->oOvManager.Initialize( poDS, poOpenInfo->pszFilename );
return( poDS );
}
int GDALJP2Metadata::ParseGMLCoverageDesc()
{
/* -------------------------------------------------------------------- */
/* Do we have an XML doc that is apparently a coverage */
/* description? */
/* -------------------------------------------------------------------- */
const char *pszCoverage = CSLFetchNameValue( papszGMLMetadata,
"gml.root-instance" );
if( pszCoverage == NULL )
return FALSE;
CPLDebug( "GDALJP2Metadata", "Found GML Box:\n%s", pszCoverage );
/* -------------------------------------------------------------------- */
/* Try parsing the XML. Wipe any namespace prefixes. */
/* -------------------------------------------------------------------- */
CPLXMLNode *psXML = CPLParseXMLString( pszCoverage );
if( psXML == NULL )
return FALSE;
CPLStripXMLNamespace( psXML, NULL, TRUE );
/* -------------------------------------------------------------------- */
/* Isolate RectifiedGrid. Eventually we will need to support */
/* other georeferencing objects. */
/* -------------------------------------------------------------------- */
CPLXMLNode *psRG = CPLSearchXMLNode( psXML, "=RectifiedGrid" );
CPLXMLNode *psOriginPoint = NULL;
const char *pszOffset1=NULL, *pszOffset2=NULL;
if( psRG != NULL )
{
psOriginPoint = CPLGetXMLNode( psRG, "origin.Point" );
CPLXMLNode *psOffset1 = CPLGetXMLNode( psRG, "offsetVector" );
if( psOffset1 != NULL )
{
pszOffset1 = CPLGetXMLValue( psOffset1, "", NULL );
pszOffset2 = CPLGetXMLValue( psOffset1->psNext, "=offsetVector",
NULL );
}
}
/* -------------------------------------------------------------------- */
/* If we are missing any of the origin or 2 offsets then give up. */
/* -------------------------------------------------------------------- */
if( psOriginPoint == NULL || pszOffset1 == NULL || pszOffset2 == NULL )
{
CPLDestroyXMLNode( psXML );
return FALSE;
}
/* -------------------------------------------------------------------- */
/* Extract origin location. */
/* -------------------------------------------------------------------- */
OGRPoint *poOriginGeometry = NULL;
const char *pszSRSName = NULL;
if( psOriginPoint != NULL )
{
poOriginGeometry = (OGRPoint *)
OGR_G_CreateFromGMLTree( psOriginPoint );
if( poOriginGeometry != NULL
&& wkbFlatten(poOriginGeometry->getGeometryType()) != wkbPoint )
{
delete poOriginGeometry;
poOriginGeometry = NULL;
}
// SRS?
pszSRSName = CPLGetXMLValue( psOriginPoint, "srsName", NULL );
}
/* -------------------------------------------------------------------- */
/* Extract offset(s) */
/* -------------------------------------------------------------------- */
char **papszOffset1Tokens = NULL;
char **papszOffset2Tokens = NULL;
int bSuccess = FALSE;
papszOffset1Tokens =
CSLTokenizeStringComplex( pszOffset1, " ,", FALSE, FALSE );
papszOffset2Tokens =
CSLTokenizeStringComplex( pszOffset2, " ,", FALSE, FALSE );
if( CSLCount(papszOffset1Tokens) >= 2
&& CSLCount(papszOffset2Tokens) >= 2
&& poOriginGeometry != NULL )
{
adfGeoTransform[0] = poOriginGeometry->getX();
adfGeoTransform[1] = atof(papszOffset1Tokens[0]);
adfGeoTransform[2] = atof(papszOffset2Tokens[0]);
adfGeoTransform[3] = poOriginGeometry->getY();
adfGeoTransform[4] = atof(papszOffset1Tokens[1]);
adfGeoTransform[5] = atof(papszOffset2Tokens[1]);
// offset from center of pixel.
adfGeoTransform[0] -= adfGeoTransform[1]*0.5;
adfGeoTransform[0] -= adfGeoTransform[2]*0.5;
adfGeoTransform[3] -= adfGeoTransform[4]*0.5;
adfGeoTransform[3] -= adfGeoTransform[5]*0.5;
bSuccess = TRUE;
bHaveGeoTransform = TRUE;
}
CSLDestroy( papszOffset1Tokens );
CSLDestroy( papszOffset2Tokens );
if( poOriginGeometry != NULL )
delete poOriginGeometry;
/* -------------------------------------------------------------------- */
/* If we still don't have an srsName, check for it on the */
/* boundedBy Envelope. Some products */
/* (ie. EuropeRasterTile23.jpx) use this as the only srsName */
/* delivery vehicle. */
/* -------------------------------------------------------------------- */
if( pszSRSName == NULL )
{
pszSRSName =
CPLGetXMLValue( psXML,
"=FeatureCollection.boundedBy.Envelope.srsName",
NULL );
}
/* -------------------------------------------------------------------- */
/* If we have gotten a geotransform, then try to interprete the */
/* srsName. */
/* -------------------------------------------------------------------- */
int bNeedAxisFlip = FALSE;
if( bSuccess && pszSRSName != NULL
&& (pszProjection == NULL || strlen(pszProjection) == 0) )
{
OGRSpatialReference oSRS;
if( EQUALN(pszSRSName,"epsg:",5) )
{
if( oSRS.SetFromUserInput( pszSRSName ) == OGRERR_NONE )
oSRS.exportToWkt( &pszProjection );
}
else if( EQUALN(pszSRSName,"urn:",4)
&& strstr(pszSRSName,":def:") != NULL
&& oSRS.importFromURN(pszSRSName) == OGRERR_NONE )
{
const char *pszCode = strrchr(pszSRSName,':') + 1;
oSRS.exportToWkt( &pszProjection );
// Per #2131
if( atoi(pszCode) >= 4000 && atoi(pszCode) <= 4999 )
{
CPLDebug( "GMLJP2", "Request axis flip for SRS=%s",
pszSRSName );
bNeedAxisFlip = TRUE;
}
}
else if( !GMLSRSLookup( pszSRSName ) )
{
CPLDebug( "GDALJP2Metadata",
"Unable to evaluate SRSName=%s",
pszSRSName );
}
}
if( pszProjection )
CPLDebug( "GDALJP2Metadata",
"Got projection from GML box: %s",
pszProjection );
CPLDestroyXMLNode( psXML );
psXML = NULL;
/* -------------------------------------------------------------------- */
/* Do we need to flip the axes? */
/* -------------------------------------------------------------------- */
if( bNeedAxisFlip
&& CSLTestBoolean( CPLGetConfigOption( "GDAL_IGNORE_AXIS_ORIENTATION",
"FALSE" ) ) )
{
bNeedAxisFlip = FALSE;
CPLDebug( "GMLJP2", "Supressed axis flipping based on GDAL_IGNORE_AXIS_ORIENTATION." );
}
if( bNeedAxisFlip )
{
double dfTemp;
CPLDebug( "GMLJP2",
"Flipping axis orientation in GMLJP2 coverage description." );
dfTemp = adfGeoTransform[0];
adfGeoTransform[0] = adfGeoTransform[3];
adfGeoTransform[3] = dfTemp;
dfTemp = adfGeoTransform[1];
adfGeoTransform[1] = adfGeoTransform[4];
adfGeoTransform[4] = dfTemp;
dfTemp = adfGeoTransform[2];
adfGeoTransform[2] = adfGeoTransform[5];
adfGeoTransform[5] = dfTemp;
}
return pszProjection != NULL && bSuccess;
}
int main( int argc, char ** argv )
{
int i, b3D = FALSE;
int bInverse = FALSE;
const char *pszSrcFilename = NULL;
const char *pszDstFilename = NULL;
char **papszLayers = NULL;
const char *pszSQL = NULL;
const char *pszBurnAttribute = NULL;
const char *pszWHERE = NULL;
std::vector<int> anBandList;
std::vector<double> adfBurnValues;
char **papszRasterizeOptions = NULL;
double dfXRes = 0, dfYRes = 0;
int bCreateOutput = FALSE;
const char* pszFormat = "GTiff";
int bFormatExplicitelySet = FALSE;
char **papszCreateOptions = NULL;
GDALDriverH hDriver = NULL;
GDALDataType eOutputType = GDT_Float64;
std::vector<double> adfInitVals;
int bNoDataSet = FALSE;
double dfNoData = 0;
OGREnvelope sEnvelop;
int bGotBounds = FALSE;
int nXSize = 0, nYSize = 0;
int bQuiet = FALSE;
GDALProgressFunc pfnProgress = GDALTermProgress;
OGRSpatialReferenceH hSRS = NULL;
int bTargetAlignedPixels = FALSE;
/* Check that we are running against at least GDAL 1.4 */
/* Note to developers : if we use newer API, please change the requirement */
if (atoi(GDALVersionInfo("VERSION_NUM")) < 1400)
{
fprintf(stderr, "At least, GDAL >= 1.4.0 is required for this version of %s, "
"which was compiled against GDAL %s\n", argv[0], GDAL_RELEASE_NAME);
exit(1);
}
GDALAllRegister();
OGRRegisterAll();
argc = GDALGeneralCmdLineProcessor( argc, &argv, 0 );
if( argc < 1 )
exit( -argc );
/* -------------------------------------------------------------------- */
/* Parse arguments. */
/* -------------------------------------------------------------------- */
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],"-q") || EQUAL(argv[i],"-quiet") )
{
bQuiet = TRUE;
pfnProgress = GDALDummyProgress;
}
else if( EQUAL(argv[i],"-a") && i < argc-1 )
{
pszBurnAttribute = argv[++i];
}
else if( EQUAL(argv[i],"-b") && i < argc-1 )
{
if (strchr(argv[i+1], ' '))
{
char** papszTokens = CSLTokenizeString( argv[i+1] );
char** papszIter = papszTokens;
while(papszIter && *papszIter)
{
anBandList.push_back(atoi(*papszIter));
papszIter ++;
}
CSLDestroy(papszTokens);
i += 1;
}
else
{
while(i < argc-1 && ArgIsNumeric(argv[i+1]))
{
anBandList.push_back(atoi(argv[i+1]));
i += 1;
}
}
}
else if( EQUAL(argv[i],"-3d") )
{
b3D = TRUE;
papszRasterizeOptions =
CSLSetNameValue( papszRasterizeOptions, "BURN_VALUE_FROM", "Z");
}
else if( EQUAL(argv[i],"-i") )
{
bInverse = TRUE;
}
else if( EQUAL(argv[i],"-at") )
{
papszRasterizeOptions =
CSLSetNameValue( papszRasterizeOptions, "ALL_TOUCHED", "TRUE" );
}
else if( EQUAL(argv[i],"-burn") && i < argc-1 )
{
if (strchr(argv[i+1], ' '))
{
char** papszTokens = CSLTokenizeString( argv[i+1] );
char** papszIter = papszTokens;
while(papszIter && *papszIter)
{
adfBurnValues.push_back(atof(*papszIter));
papszIter ++;
}
CSLDestroy(papszTokens);
i += 1;
}
else
{
while(i < argc-1 && ArgIsNumeric(argv[i+1]))
{
adfBurnValues.push_back(atof(argv[i+1]));
i += 1;
}
}
}
else if( EQUAL(argv[i],"-where") && i < argc-1 )
{
pszWHERE = argv[++i];
}
else if( EQUAL(argv[i],"-l") && i < argc-1 )
{
papszLayers = CSLAddString( papszLayers, argv[++i] );
}
else if( EQUAL(argv[i],"-sql") && i < argc-1 )
{
pszSQL = argv[++i];
}
else if( EQUAL(argv[i],"-of") && i < argc-1 )
{
pszFormat = argv[++i];
bFormatExplicitelySet = TRUE;
bCreateOutput = TRUE;
}
else if( EQUAL(argv[i],"-init") && i < argc - 1 )
{
if (strchr(argv[i+1], ' '))
{
char** papszTokens = CSLTokenizeString( argv[i+1] );
char** papszIter = papszTokens;
while(papszIter && *papszIter)
{
adfInitVals.push_back(atof(*papszIter));
papszIter ++;
}
CSLDestroy(papszTokens);
i += 1;
}
else
{
while(i < argc-1 && ArgIsNumeric(argv[i+1]))
{
adfInitVals.push_back(atof(argv[i+1]));
i += 1;
}
}
bCreateOutput = TRUE;
}
else if( EQUAL(argv[i],"-a_nodata") && i < argc - 1 )
{
dfNoData = atof(argv[i+1]);
bNoDataSet = TRUE;
i += 1;
bCreateOutput = TRUE;
}
else if( EQUAL(argv[i],"-a_srs") && i < argc-1 )
{
hSRS = OSRNewSpatialReference( NULL );
if( OSRSetFromUserInput(hSRS, argv[i+1]) != OGRERR_NONE )
{
fprintf( stderr, "Failed to process SRS definition: %s\n",
argv[i+1] );
exit( 1 );
}
i++;
bCreateOutput = TRUE;
}
else if( EQUAL(argv[i],"-te") && i < argc - 4 )
{
sEnvelop.MinX = atof(argv[++i]);
sEnvelop.MinY = atof(argv[++i]);
sEnvelop.MaxX = atof(argv[++i]);
sEnvelop.MaxY = atof(argv[++i]);
bGotBounds = TRUE;
bCreateOutput = TRUE;
}
else if( EQUAL(argv[i],"-a_ullr") && i < argc - 4 )
{
sEnvelop.MinX = atof(argv[++i]);
sEnvelop.MaxY = atof(argv[++i]);
sEnvelop.MaxX = atof(argv[++i]);
sEnvelop.MinY = atof(argv[++i]);
bGotBounds = TRUE;
bCreateOutput = TRUE;
}
else if( EQUAL(argv[i],"-co") && i < argc-1 )
{
papszCreateOptions = CSLAddString( papszCreateOptions, argv[++i] );
bCreateOutput = TRUE;
}
else if( EQUAL(argv[i],"-ot") && i < argc-1 )
{
int iType;
for( iType = 1; iType < GDT_TypeCount; iType++ )
{
if( GDALGetDataTypeName((GDALDataType)iType) != NULL
&& EQUAL(GDALGetDataTypeName((GDALDataType)iType),
argv[i+1]) )
{
eOutputType = (GDALDataType) iType;
}
}
if( eOutputType == GDT_Unknown )
{
printf( "Unknown output pixel type: %s\n", argv[i+1] );
Usage();
}
i++;
bCreateOutput = TRUE;
}
else if( (EQUAL(argv[i],"-ts") || EQUAL(argv[i],"-outsize")) && i < argc-2 )
{
nXSize = atoi(argv[++i]);
nYSize = atoi(argv[++i]);
if (nXSize <= 0 || nYSize <= 0)
{
printf( "Wrong value for -outsize parameters\n");
Usage();
}
bCreateOutput = TRUE;
}
else if( EQUAL(argv[i],"-tr") && i < argc-2 )
{
dfXRes = atof(argv[++i]);
dfYRes = fabs(atof(argv[++i]));
if( dfXRes == 0 || dfYRes == 0 )
{
printf( "Wrong value for -tr parameters\n");
Usage();
}
bCreateOutput = TRUE;
}
else if( EQUAL(argv[i],"-tap") )
{
bTargetAlignedPixels = TRUE;
bCreateOutput = TRUE;
}
else if( pszSrcFilename == NULL )
{
pszSrcFilename = argv[i];
}
else if( pszDstFilename == NULL )
{
pszDstFilename = argv[i];
}
else
Usage();
}
if( pszSrcFilename == NULL || pszDstFilename == NULL )
{
fprintf( stderr, "Missing source or destination.\n\n" );
Usage();
}
if( adfBurnValues.size() == 0 && pszBurnAttribute == NULL && !b3D )
{
fprintf( stderr, "At least one of -3d, -burn or -a required.\n\n" );
Usage();
}
if( bCreateOutput )
{
if( dfXRes == 0 && dfYRes == 0 && nXSize == 0 && nYSize == 0 )
{
fprintf( stderr, "'-tr xres yes' or '-ts xsize ysize' is required.\n\n" );
Usage();
}
if (bTargetAlignedPixels && dfXRes == 0 && dfYRes == 0)
{
fprintf( stderr, "-tap option cannot be used without using -tr\n");
Usage();
}
if( anBandList.size() != 0 )
{
fprintf( stderr, "-b option cannot be used when creating a GDAL dataset.\n\n" );
Usage();
}
int nBandCount = 1;
if (adfBurnValues.size() != 0)
nBandCount = adfBurnValues.size();
if ((int)adfInitVals.size() > nBandCount)
nBandCount = adfInitVals.size();
if (adfInitVals.size() == 1)
{
for(i=1;i<=nBandCount - 1;i++)
adfInitVals.push_back( adfInitVals[0] );
}
int i;
for(i=1;i<=nBandCount;i++)
anBandList.push_back( i );
}
else
{
if( anBandList.size() == 0 )
anBandList.push_back( 1 );
}
/* -------------------------------------------------------------------- */
/* Open source vector dataset. */
/* -------------------------------------------------------------------- */
OGRDataSourceH hSrcDS;
hSrcDS = OGROpen( pszSrcFilename, FALSE, NULL );
if( hSrcDS == NULL )
{
fprintf( stderr, "Failed to open feature source: %s\n",
pszSrcFilename);
exit( 1 );
}
if( pszSQL == NULL && papszLayers == NULL )
{
if( OGR_DS_GetLayerCount(hSrcDS) == 1 )
{
papszLayers = CSLAddString(NULL, OGR_L_GetName(OGR_DS_GetLayer(hSrcDS, 0)));
}
else
{
fprintf( stderr, "At least one of -l or -sql required.\n\n" );
Usage();
}
}
/* -------------------------------------------------------------------- */
/* Open target raster file. Eventually we will add optional */
/* creation. */
/* -------------------------------------------------------------------- */
GDALDatasetH hDstDS = NULL;
if (bCreateOutput)
{
/* -------------------------------------------------------------------- */
/* Find the output driver. */
/* -------------------------------------------------------------------- */
hDriver = GDALGetDriverByName( pszFormat );
if( hDriver == NULL
|| GDALGetMetadataItem( hDriver, GDAL_DCAP_CREATE, NULL ) == NULL )
{
int iDr;
printf( "Output driver `%s' not recognised or does not support\n",
pszFormat );
printf( "direct output file creation. The following format drivers are configured\n"
"and support direct output:\n" );
for( iDr = 0; iDr < GDALGetDriverCount(); iDr++ )
{
GDALDriverH hDriver = GDALGetDriver(iDr);
if( GDALGetMetadataItem( hDriver, GDAL_DCAP_CREATE, NULL) != NULL )
{
printf( " %s: %s\n",
GDALGetDriverShortName( hDriver ),
GDALGetDriverLongName( hDriver ) );
}
}
printf( "\n" );
exit( 1 );
}
if (!bQuiet && !bFormatExplicitelySet)
CheckExtensionConsistency(pszDstFilename, pszFormat);
}
else
{
hDstDS = GDALOpen( pszDstFilename, GA_Update );
if( hDstDS == NULL )
exit( 2 );
}
/* -------------------------------------------------------------------- */
/* Process SQL request. */
/* -------------------------------------------------------------------- */
if( pszSQL != NULL )
{
OGRLayerH hLayer;
hLayer = OGR_DS_ExecuteSQL( hSrcDS, pszSQL, NULL, NULL );
if( hLayer != NULL )
{
if (bCreateOutput)
{
std::vector<OGRLayerH> ahLayers;
ahLayers.push_back(hLayer);
hDstDS = CreateOutputDataset(ahLayers, hSRS,
bGotBounds, sEnvelop,
hDriver, pszDstFilename,
nXSize, nYSize, dfXRes, dfYRes,
bTargetAlignedPixels,
anBandList.size(), eOutputType,
papszCreateOptions, adfInitVals,
bNoDataSet, dfNoData);
}
ProcessLayer( hLayer, hSRS != NULL, hDstDS, anBandList,
adfBurnValues, b3D, bInverse, pszBurnAttribute,
papszRasterizeOptions, pfnProgress, NULL );
OGR_DS_ReleaseResultSet( hSrcDS, hLayer );
}
}
/* -------------------------------------------------------------------- */
/* Create output file if necessary. */
/* -------------------------------------------------------------------- */
int nLayerCount = CSLCount(papszLayers);
if (bCreateOutput && hDstDS == NULL)
{
std::vector<OGRLayerH> ahLayers;
for( i = 0; i < nLayerCount; i++ )
{
OGRLayerH hLayer = OGR_DS_GetLayerByName( hSrcDS, papszLayers[i] );
if( hLayer == NULL )
{
continue;
}
ahLayers.push_back(hLayer);
}
hDstDS = CreateOutputDataset(ahLayers, hSRS,
bGotBounds, sEnvelop,
hDriver, pszDstFilename,
nXSize, nYSize, dfXRes, dfYRes,
bTargetAlignedPixels,
anBandList.size(), eOutputType,
papszCreateOptions, adfInitVals,
bNoDataSet, dfNoData);
}
/* -------------------------------------------------------------------- */
/* Process each layer. */
/* -------------------------------------------------------------------- */
for( i = 0; i < nLayerCount; i++ )
{
OGRLayerH hLayer = OGR_DS_GetLayerByName( hSrcDS, papszLayers[i] );
if( hLayer == NULL )
{
fprintf( stderr, "Unable to find layer %s, skipping.\n",
papszLayers[i] );
continue;
}
if( pszWHERE )
{
if( OGR_L_SetAttributeFilter( hLayer, pszWHERE ) != OGRERR_NONE )
break;
}
void *pScaledProgress;
pScaledProgress =
GDALCreateScaledProgress( 0.0, 1.0 * (i + 1) / nLayerCount,
pfnProgress, NULL );
ProcessLayer( hLayer, hSRS != NULL, hDstDS, anBandList,
adfBurnValues, b3D, bInverse, pszBurnAttribute,
papszRasterizeOptions, GDALScaledProgress, pScaledProgress );
GDALDestroyScaledProgress( pScaledProgress );
}
/* -------------------------------------------------------------------- */
/* Cleanup */
/* -------------------------------------------------------------------- */
OGR_DS_Destroy( hSrcDS );
GDALClose( hDstDS );
OSRDestroySpatialReference(hSRS);
CSLDestroy( argv );
CSLDestroy( papszRasterizeOptions );
CSLDestroy( papszLayers );
CSLDestroy( papszCreateOptions );
GDALDestroyDriverManager();
OGRCleanupAll();
return 0;
}
int OGRNTFDataSource::Open( const char * pszFilename, int bTestOpen,
char ** papszLimitedFileList )
{
VSIStatBuf stat;
char **papszFileList = NULL;
pszName = CPLStrdup( pszFilename );
/* -------------------------------------------------------------------- */
/* Is the given path a directory or a regular file? */
/* -------------------------------------------------------------------- */
if( CPLStat( pszFilename, &stat ) != 0
|| (!VSI_ISDIR(stat.st_mode) && !VSI_ISREG(stat.st_mode)) )
{
if( !bTestOpen )
CPLError( CE_Failure, CPLE_AppDefined,
"%s is neither a file or directory, NTF access failed.\n",
pszFilename );
return FALSE;
}
/* -------------------------------------------------------------------- */
/* Build a list of filenames we figure are NTF files. */
/* -------------------------------------------------------------------- */
if( VSI_ISREG(stat.st_mode) )
{
papszFileList = CSLAddString( NULL, pszFilename );
}
else
{
char **candidateFileList = CPLReadDir( pszFilename );
int i;
for( i = 0;
candidateFileList != NULL && candidateFileList[i] != NULL;
i++ )
{
if( papszLimitedFileList != NULL
&& CSLFindString(papszLimitedFileList,
candidateFileList[i]) == -1 )
{
continue;
}
if( strlen(candidateFileList[i]) > 4
&& EQUALN(candidateFileList[i] + strlen(candidateFileList[i])-4,
".ntf",4) )
{
char fullFilename[2048];
sprintf( fullFilename, "%s%c%s",
pszFilename,
#ifdef WIN32
'\\',
#else
'/',
#endif
candidateFileList[i] );
papszFileList = CSLAddString( papszFileList, fullFilename );
}
}
CSLDestroy( candidateFileList );
if( CSLCount(papszFileList) == 0 )
{
if( !bTestOpen )
CPLError( CE_Failure, CPLE_OpenFailed,
"No candidate NTF files (.ntf) found in\n"
"directory: %s",
pszFilename );
return FALSE;
}
}
/* -------------------------------------------------------------------- */
/* Loop over all these files trying to open them. In testopen */
/* mode we first read the first 80 characters, to verify that */
/* it looks like an NTF file. Note that we don't keep the file */
/* open ... we don't want to occupy alot of file handles when */
/* handling a whole directory. */
/* -------------------------------------------------------------------- */
int i;
papoNTFFileReader = (NTFFileReader **)
CPLCalloc(sizeof(void*), CSLCount(papszFileList));
for( i = 0; papszFileList[i] != NULL; i++ )
{
if( bTestOpen )
{
char szHeader[80];
FILE *fp;
int j;
fp = VSIFOpen( papszFileList[i], "rb" );
if( fp == NULL )
continue;
if( VSIFRead( szHeader, 80, 1, fp ) < 1 )
{
VSIFClose( fp );
continue;
}
VSIFClose( fp );
if( !EQUALN(szHeader,"01",2) )
continue;
for( j = 0; j < 80; j++ )
{
if( szHeader[j] == 10 || szHeader[j] == 13 )
break;
}
if( j == 80 || szHeader[j-1] != '%' )
continue;
}
NTFFileReader *poFR;
poFR = new NTFFileReader( this );
if( !poFR->Open( papszFileList[i] ) )
{
delete poFR;
CSLDestroy( papszFileList );
return FALSE;
}
poFR->SetBaseFID( nNTFFileCount * 1000000 + 1 );
poFR->Close();
EnsureTileNameUnique( poFR );
papoNTFFileReader[nNTFFileCount++] = poFR;
}
CSLDestroy( papszFileList );
if( nNTFFileCount == 0 )
return FALSE;
/* -------------------------------------------------------------------- */
/* Establish generic layers. */
/* -------------------------------------------------------------------- */
EstablishGenericLayers();
/* -------------------------------------------------------------------- */
/* Loop over all the files, collecting a unique feature class */
/* listing. */
/* -------------------------------------------------------------------- */
for( int iSrcFile = 0; iSrcFile < nNTFFileCount; iSrcFile++ )
{
NTFFileReader *poSrcReader = papoNTFFileReader[iSrcFile];
for( int iSrcFC = 0; iSrcFC < poSrcReader->GetFCCount(); iSrcFC++ )
{
int iDstFC;
char *pszSrcFCName, *pszSrcFCNum;
poSrcReader->GetFeatureClass( iSrcFC, &pszSrcFCNum, &pszSrcFCName);
for( iDstFC = 0; iDstFC < nFCCount; iDstFC++ )
{
if( EQUAL(pszSrcFCNum,papszFCNum[iDstFC]) )
break;
}
if( iDstFC >= nFCCount )
{
nFCCount++;
papszFCNum = CSLAddString(papszFCNum,pszSrcFCNum);
papszFCName = CSLAddString(papszFCName,pszSrcFCName);
}
}
}
/* -------------------------------------------------------------------- */
/* Create a new layer specifically for feature classes. */
/* -------------------------------------------------------------------- */
if( nFCCount > 0 )
poFCLayer = new OGRNTFFeatureClassLayer( this );
else
poFCLayer = NULL;
return TRUE;
}
