int DDFFieldDefn::Initialize( DDFModule * poModuleIn,
const char * pszTagIn,
int nFieldEntrySize,
const char * pachFieldArea )
{
int iFDOffset = poModuleIn->GetFieldControlLength();
int nCharsConsumed;
poModule = poModuleIn;
pszTag = CPLStrdup( pszTagIn );
/* -------------------------------------------------------------------- */
/* Set the data struct and type codes. */
/* -------------------------------------------------------------------- */
switch( pachFieldArea[0] )
{
case ' ': /* for ADRG, DIGEST USRP, DIGEST ASRP files */
case '0':
_data_struct_code = dsc_elementary;
break;
case '1':
_data_struct_code = dsc_vector;
break;
case '2':
_data_struct_code = dsc_array;
break;
case '3':
_data_struct_code = dsc_concatenated;
break;
default:
CPLError( CE_Failure, CPLE_AppDefined,
"Unrecognized data_struct_code value %c.\n"
"Field %s initialization incorrect.",
pachFieldArea[0], pszTag );
_data_struct_code = dsc_elementary;
}
switch( pachFieldArea[1] )
{
case ' ': /* for ADRG, DIGEST USRP, DIGEST ASRP files */
case '0':
_data_type_code = dtc_char_string;
break;
case '1':
_data_type_code = dtc_implicit_point;
break;
case '2':
_data_type_code = dtc_explicit_point;
break;
case '3':
_data_type_code = dtc_explicit_point_scaled;
break;
case '4':
_data_type_code = dtc_char_bit_string;
break;
case '5':
_data_type_code = dtc_bit_string;
break;
case '6':
_data_type_code = dtc_mixed_data_type;
break;
default:
CPLError( CE_Failure, CPLE_AppDefined,
"Unrecognized data_type_code value %c.\n"
"Field %s initialization incorrect.",
pachFieldArea[1], pszTag );
_data_type_code = dtc_char_string;
}
/* -------------------------------------------------------------------- */
/* Capture the field name, description (sub field names), and */
/* format statements. */
/* -------------------------------------------------------------------- */
_fieldName =
DDFFetchVariable( pachFieldArea + iFDOffset,
nFieldEntrySize - iFDOffset,
DDF_UNIT_TERMINATOR, DDF_FIELD_TERMINATOR,
&nCharsConsumed );
iFDOffset += nCharsConsumed;
_arrayDescr =
DDFFetchVariable( pachFieldArea + iFDOffset,
nFieldEntrySize - iFDOffset,
DDF_UNIT_TERMINATOR, DDF_FIELD_TERMINATOR,
&nCharsConsumed );
iFDOffset += nCharsConsumed;
_formatControls =
DDFFetchVariable( pachFieldArea + iFDOffset,
nFieldEntrySize - iFDOffset,
DDF_UNIT_TERMINATOR, DDF_FIELD_TERMINATOR,
&nCharsConsumed );
/* -------------------------------------------------------------------- */
/* Parse the subfield info. */
/* -------------------------------------------------------------------- */
if( _data_struct_code != dsc_elementary )
{
if( !BuildSubfields() )
return FALSE;
if( !ApplyFormats() )
return FALSE;
}
return TRUE;
}
int swq_select::PushField( swq_expr_node *poExpr, const char *pszAlias,
int distinct_flag )
{
/* -------------------------------------------------------------------- */
/* Grow the array. */
/* -------------------------------------------------------------------- */
result_columns++;
column_defs = (swq_col_def *)
CPLRealloc( column_defs, sizeof(swq_col_def) * result_columns );
swq_col_def *col_def = column_defs + result_columns - 1;
memset( col_def, 0, sizeof(swq_col_def) );
/* -------------------------------------------------------------------- */
/* Try to capture a field name. */
/* -------------------------------------------------------------------- */
if( poExpr->eNodeType == SNT_COLUMN )
col_def->field_name =
CPLStrdup(poExpr->string_value);
else if( poExpr->eNodeType == SNT_OPERATION
&& (poExpr->nOperation == SWQ_CAST ||
(poExpr->nOperation >= SWQ_AVG &&
poExpr->nOperation <= SWQ_SUM))
&& poExpr->nSubExprCount >= 1
&& poExpr->papoSubExpr[0]->eNodeType == SNT_COLUMN )
col_def->field_name =
CPLStrdup(poExpr->papoSubExpr[0]->string_value);
else
col_def->field_name = CPLStrdup("");
/* -------------------------------------------------------------------- */
/* Initialize fields. */
/* -------------------------------------------------------------------- */
if( pszAlias != NULL )
col_def->field_alias = CPLStrdup( pszAlias );
else if( pszAlias == NULL && poExpr->eNodeType == SNT_OPERATION
&& poExpr->nSubExprCount >= 1
&& ( poExpr->nOperation == SWQ_CONCAT ||
poExpr->nOperation == SWQ_SUBSTR )
&& poExpr->papoSubExpr[0]->eNodeType == SNT_COLUMN )
{
const swq_operation *op = swq_op_registrar::GetOperator(
(swq_op) poExpr->nOperation );
col_def->field_alias = CPLStrdup( CPLSPrintf("%s_%s", op->pszName,
poExpr->papoSubExpr[0]->string_value));
}
col_def->table_index = -1;
col_def->field_index = -1;
col_def->field_type = SWQ_OTHER;
col_def->field_precision = -1;
col_def->target_type = SWQ_OTHER;
col_def->col_func = SWQCF_NONE;
col_def->distinct_flag = distinct_flag;
/* -------------------------------------------------------------------- */
/* Do we have a CAST operator in play? */
/* -------------------------------------------------------------------- */
if( poExpr->eNodeType == SNT_OPERATION
&& poExpr->nOperation == SWQ_CAST )
{
const char *pszTypeName = poExpr->papoSubExpr[1]->string_value;
int parse_precision = 0;
if( EQUAL(pszTypeName,"character") )
{
col_def->target_type = SWQ_STRING;
col_def->field_length = 1;
}
else if( strcasecmp(pszTypeName,"integer") == 0 )
{
col_def->target_type = SWQ_INTEGER;
}
else if( strcasecmp(pszTypeName,"float") == 0 )
{
col_def->target_type = SWQ_FLOAT;
}
else if( strcasecmp(pszTypeName,"numeric") == 0 )
{
col_def->target_type = SWQ_FLOAT;
parse_precision = 1;
}
else if( strcasecmp(pszTypeName,"timestamp") == 0 )
{
col_def->target_type = SWQ_TIMESTAMP;
}
else if( strcasecmp(pszTypeName,"date") == 0 )
{
col_def->target_type = SWQ_DATE;
}
else if( strcasecmp(pszTypeName,"time") == 0 )
{
col_def->target_type = SWQ_TIME;
}
else if( strcasecmp(pszTypeName,"geometry") == 0 )
{
col_def->target_type = SWQ_GEOMETRY;
}
else
{
CPLError( CE_Failure, CPLE_AppDefined,
"Unrecognized typename %s in CAST operator.",
pszTypeName );
CPLFree(col_def->field_name);
col_def->field_name = NULL;
CPLFree(col_def->field_alias);
col_def->field_alias = NULL;
result_columns--;
return FALSE;
}
if( col_def->target_type == SWQ_GEOMETRY )
{
if( poExpr->nSubExprCount > 2 )
{
if( poExpr->papoSubExpr[2]->field_type != SWQ_STRING )
{
CPLError( CE_Failure, CPLE_AppDefined,
"First argument of CAST operator should be an geometry type identifier." );
CPLFree(col_def->field_name);
col_def->field_name = NULL;
CPLFree(col_def->field_alias);
col_def->field_alias = NULL;
result_columns--;
return FALSE;
}
col_def->eGeomType =
OGRFromOGCGeomType(poExpr->papoSubExpr[2]->string_value);
// SRID
if( poExpr->nSubExprCount > 3 )
{
col_def->nSRID = poExpr->papoSubExpr[3]->int_value;
}
}
}
else
{
// field width.
if( poExpr->nSubExprCount > 2 )
{
if( poExpr->papoSubExpr[2]->field_type != SWQ_INTEGER )
{
CPLError( CE_Failure, CPLE_AppDefined,
"First argument of CAST operator should be of integer type." );
CPLFree(col_def->field_name);
col_def->field_name = NULL;
CPLFree(col_def->field_alias);
col_def->field_alias = NULL;
result_columns--;
return FALSE;
}
col_def->field_length = poExpr->papoSubExpr[2]->int_value;
}
// field width.
if( poExpr->nSubExprCount > 3 && parse_precision )
{
col_def->field_precision = poExpr->papoSubExpr[3]->int_value;
}
}
}
/* -------------------------------------------------------------------- */
/* Do we have a special column function in play? */
/* -------------------------------------------------------------------- */
if( poExpr->eNodeType == SNT_OPERATION
&& poExpr->nOperation >= SWQ_AVG
&& poExpr->nOperation <= SWQ_SUM )
{
if( poExpr->nSubExprCount != 1 )
{
const swq_operation *poOp =
swq_op_registrar::GetOperator( (swq_op)poExpr->nOperation );
CPLError( CE_Failure, CPLE_AppDefined,
"Column Summary Function '%s' has wrong number of arguments.",
poOp->pszName );
CPLFree(col_def->field_name);
col_def->field_name = NULL;
CPLFree(col_def->field_alias);
col_def->field_alias = NULL;
result_columns--;
return FALSE;
}
else if( poExpr->papoSubExpr[0]->eNodeType != SNT_COLUMN )
{
const swq_operation *poOp =
swq_op_registrar::GetOperator( (swq_op)poExpr->nOperation );
CPLError( CE_Failure, CPLE_AppDefined,
"Argument of column Summary Function '%s' should be a column.",
poOp->pszName );
CPLFree(col_def->field_name);
col_def->field_name = NULL;
CPLFree(col_def->field_alias);
col_def->field_alias = NULL;
result_columns--;
return FALSE;
}
else
{
col_def->col_func =
(swq_col_func) poExpr->nOperation;
swq_expr_node *poSubExpr = poExpr->papoSubExpr[0];
poExpr->papoSubExpr[0] = NULL;
poExpr->nSubExprCount = 0;
delete poExpr;
poExpr = poSubExpr;
}
}
col_def->expr = poExpr;
return TRUE;
}
CPLErr swq_select::parse( swq_field_list *field_list,
CPL_UNUSED int parse_flags )
{
int i;
CPLErr eError;
eError = expand_wildcard( field_list );
if( eError != CE_None )
return eError;
/* -------------------------------------------------------------------- */
/* Identify field information. */
/* -------------------------------------------------------------------- */
for( i = 0; i < result_columns; i++ )
{
swq_col_def *def = column_defs + i;
if( def->expr != NULL && def->expr->eNodeType != SNT_COLUMN )
{
def->field_index = -1;
def->table_index = -1;
if( def->expr->Check( field_list, TRUE ) == SWQ_ERROR )
return CE_Failure;
def->field_type = def->expr->field_type;
// If the field was changed from string constant to
// column field then adopt the name.
if( def->expr->eNodeType == SNT_COLUMN )
{
def->field_index = def->expr->field_index;
def->table_index = def->expr->table_index;
CPLFree( def->field_name );
def->field_name = CPLStrdup(def->expr->string_value);
}
}
else
{
swq_field_type this_type;
/* identify field */
def->field_index = swq_identify_field( def->field_name, field_list,
&this_type,
&(def->table_index) );
/* record field type */
def->field_type = this_type;
if( def->field_index == -1 && def->col_func != SWQCF_COUNT )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Unrecognised field name %s.",
def->field_name );
return CE_Failure;
}
}
/* identify column function if present */
if( (def->col_func == SWQCF_MIN
|| def->col_func == SWQCF_MAX
|| def->col_func == SWQCF_AVG
|| def->col_func == SWQCF_SUM)
&& (def->field_type == SWQ_STRING ||
def->field_type == SWQ_GEOMETRY) )
{
// possibly this is already enforced by the checker?
const swq_operation *op = swq_op_registrar::GetOperator(
(swq_op) def->col_func );
CPLError( CE_Failure, CPLE_AppDefined,
"Use of field function %s() on %s field %s illegal.",
op->pszName,
SWQFieldTypeToString(def->field_type),
def->field_name );
return CE_Failure;
}
}
/* -------------------------------------------------------------------- */
/* Check if we are producing a one row summary result or a set */
/* of records. Generate an error if we get conflicting */
/* indications. */
/* -------------------------------------------------------------------- */
query_mode = -1;
for( i = 0; i < result_columns; i++ )
{
swq_col_def *def = column_defs + i;
int this_indicator = -1;
if( def->col_func == SWQCF_MIN
|| def->col_func == SWQCF_MAX
|| def->col_func == SWQCF_AVG
|| def->col_func == SWQCF_SUM
|| def->col_func == SWQCF_COUNT )
{
this_indicator = SWQM_SUMMARY_RECORD;
if( def->col_func == SWQCF_COUNT &&
def->distinct_flag &&
def->field_type == SWQ_GEOMETRY )
{
CPLError( CE_Failure, CPLE_AppDefined,
"SELECT COUNT DISTINCT on a geometry not supported." );
return CE_Failure;
}
}
else if( def->col_func == SWQCF_NONE )
{
if( def->distinct_flag )
{
this_indicator = SWQM_DISTINCT_LIST;
if( def->field_type == SWQ_GEOMETRY )
{
CPLError( CE_Failure, CPLE_AppDefined,
"SELECT DISTINCT on a geometry not supported." );
return CE_Failure;
}
}
else
this_indicator = SWQM_RECORDSET;
}
if( this_indicator != query_mode
&& this_indicator != -1
&& query_mode != -1 )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Field list implies mixture of regular recordset mode, summary mode or distinct field list mode." );
return CE_Failure;
}
if( this_indicator != -1 )
query_mode = this_indicator;
}
if( result_columns > 1
&& query_mode == SWQM_DISTINCT_LIST )
{
CPLError( CE_Failure, CPLE_AppDefined,
"SELECTing more than one DISTINCT field is a query not supported." );
return CE_Failure;
}
else if (result_columns == 0)
{
query_mode = SWQM_RECORDSET;
}
/* -------------------------------------------------------------------- */
/* Process column names in JOIN specs. */
/* -------------------------------------------------------------------- */
for( i = 0; i < join_count; i++ )
{
swq_join_def *def = join_defs + i;
int table_id;
/* identify primary field */
def->primary_field = swq_identify_field( def->primary_field_name,
field_list, NULL, &table_id );
if( def->primary_field == -1 )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Unrecognised primary field %s in JOIN clause..",
def->primary_field_name );
return CE_Failure;
}
if( table_id != 0 )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Currently the primary key must come from the primary table in\n"
"JOIN, %s is not from the primary table.",
def->primary_field_name );
return CE_Failure;
}
/* identify secondary field */
def->secondary_field = swq_identify_field( def->secondary_field_name,
field_list, NULL,&table_id);
if( def->secondary_field == -1 )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Unrecognised secondary field %s in JOIN clause..",
def->secondary_field_name );
return CE_Failure;
}
if( table_id != def->secondary_table )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Currently the secondary key must come from the secondary table\n"
"listed in the JOIN. %s is not from table %s..",
def->secondary_field_name,
table_defs[def->secondary_table].table_name);
return CE_Failure;
}
}
/* -------------------------------------------------------------------- */
/* Process column names in order specs. */
/* -------------------------------------------------------------------- */
for( i = 0; i < order_specs; i++ )
{
swq_order_def *def = order_defs + i;
/* identify field */
swq_field_type field_type;
def->field_index = swq_identify_field( def->field_name, field_list,
&field_type, &(def->table_index) );
if( def->field_index == -1 )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Unrecognised field name %s in ORDER BY.",
def->field_name );
return CE_Failure;
}
if( def->table_index != 0 )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Cannot use field '%s' of a secondary table in a ORDER BY clause",
def->field_name );
return CE_Failure;
}
if( field_type == SWQ_GEOMETRY )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Cannot use geometry field '%s' in a ORDER BY clause",
def->field_name );
return CE_Failure;
}
}
/* -------------------------------------------------------------------- */
/* Post process the where clause, subbing in field indexes and */
/* doing final validation. */
/* -------------------------------------------------------------------- */
if( where_expr != NULL
&& where_expr->Check( field_list, FALSE ) == SWQ_ERROR )
{
return CE_Failure;
}
return CE_None;
}
OGRErr GTMTrackLayer::ICreateFeature (OGRFeature *poFeature)
{
VSILFILE* fpTmpTrackpoints = poDS->getTmpTrackpointsFP();
if (fpTmpTrackpoints == NULL)
return CE_Failure;
VSILFILE* fpTmpTracks = poDS->getTmpTracksFP();
if (fpTmpTracks == NULL)
return CE_Failure;
OGRGeometry *poGeom = poFeature->GetGeometryRef();
if ( poGeom == NULL )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Features without geometry not supported by GTM writer in track layer." );
return OGRERR_FAILURE;
}
if (NULL != poCT)
{
poGeom = poGeom->clone();
poGeom->transform( poCT );
}
switch( poGeom->getGeometryType() )
{
case wkbLineString:
case wkbLineString25D:
{
WriteFeatureAttributes(poFeature);
OGRLineString* line = (OGRLineString*)poGeom;
for(int i = 0; i < line->getNumPoints(); ++i)
{
double lat = line->getY(i);
double lon = line->getX(i);
float altitude = 0;
CheckAndFixCoordinatesValidity(lat, lon);
poDS->checkBounds((float)lat, (float)lon);
if (line->getGeometryType() == wkbLineString25D)
altitude = (float)line->getZ(i);
WriteTrackpoint( lat, lon, altitude, i==0 );
}
break;
}
case wkbMultiLineString:
case wkbMultiLineString25D:
{
int nGeometries = ((OGRGeometryCollection*)poGeom)->getNumGeometries ();
for(int j = 0; j < nGeometries; ++j)
{
WriteFeatureAttributes(poFeature);
OGRLineString* line = (OGRLineString*) ( ((OGRGeometryCollection*)poGeom)->getGeometryRef(j) );
int n = (line) ? line->getNumPoints() : 0;
for(int i = 0; i < n; ++i)
{
double lat = line->getY(i);
double lon = line->getX(i);
float altitude = 0;
CheckAndFixCoordinatesValidity(lat, lon);
if (line->getGeometryType() == wkbLineString25D)
altitude = (float) line->getZ(i);
WriteTrackpoint( lat, lon, altitude, i==0 );
}
}
break;
}
default:
{
CPLError( CE_Failure, CPLE_NotSupported,
"Geometry type of `%s' not supported for 'track' element.\n",
OGRGeometryTypeToName(poGeom->getGeometryType()) );
if (NULL != poCT)
delete poGeom;
return OGRERR_FAILURE;
}
}
if (NULL != poCT)
delete poGeom;
return OGRERR_NONE;
}
GDALDataset *ISIS3Dataset::Open( GDALOpenInfo * poOpenInfo )
{
/* -------------------------------------------------------------------- */
/* Does this look like a CUBE dataset? */
/* -------------------------------------------------------------------- */
if( !Identify( poOpenInfo ) )
return NULL;
/* -------------------------------------------------------------------- */
/* Open the file using the large file API. */
/* -------------------------------------------------------------------- */
FILE *fpQube = VSIFOpenL( poOpenInfo->pszFilename, "rb" );
if( fpQube == NULL )
return NULL;
ISIS3Dataset *poDS;
poDS = new ISIS3Dataset();
if( ! poDS->oKeywords.Ingest( fpQube, 0 ) )
{
VSIFCloseL( fpQube );
delete poDS;
return NULL;
}
VSIFCloseL( fpQube );
/* -------------------------------------------------------------------- */
/* Assume user is pointing to label (ie .lbl) file for detached option */
/* -------------------------------------------------------------------- */
// Image can be inline or detached and point to an image name
// the Format can be Tiled or Raw
// Object = Core
// StartByte = 65537
// Format = Tile
// TileSamples = 128
// TileLines = 128
//OR-----
// Object = Core
// StartByte = 1
// ^Core = r0200357_detatched.cub
// Format = BandSequential
//OR-----
// Object = Core
// StartByte = 1
// ^Core = r0200357_detached_tiled.cub
// Format = Tile
// TileSamples = 128
// TileLines = 128
/* -------------------------------------------------------------------- */
/* What file contains the actual data? */
/* -------------------------------------------------------------------- */
const char *pszCore = poDS->GetKeyword( "IsisCube.Core.^Core" );
CPLString osQubeFile;
if( EQUAL(pszCore,"") )
osQubeFile = poOpenInfo->pszFilename;
else
{
CPLString osPath = CPLGetPath( poOpenInfo->pszFilename );
osQubeFile = CPLFormFilename( osPath, pszCore, NULL );
poDS->osExternalCube = osQubeFile;
}
/* -------------------------------------------------------------------- */
/* Check if file an ISIS3 header file? Read a few lines of text */
/* searching for something starting with nrows or ncols. */
/* -------------------------------------------------------------------- */
GDALDataType eDataType = GDT_Byte;
OGRSpatialReference oSRS;
int nRows = -1;
int nCols = -1;
int nBands = 1;
int nSkipBytes = 0;
int tileSizeX = 0;
int tileSizeY = 0;
double dfULXMap=0.5;
double dfULYMap = 0.5;
double dfXDim = 1.0;
double dfYDim = 1.0;
double scaleFactor = 1.0;
double dfNoData = 0.0;
int bNoDataSet = FALSE;
char chByteOrder = 'M'; //default to MSB
char szLayout[32] = "BandSequential"; //default to band seq.
const char *target_name; //planet name
//projection parameters
const char *map_proj_name;
int bProjectionSet = TRUE;
char proj_target_name[200];
char geog_name[60];
char datum_name[60];
char sphere_name[60];
char bIsGeographic = TRUE;
double semi_major = 0.0;
double semi_minor = 0.0;
double iflattening = 0.0;
float center_lat = 0.0;
float center_lon = 0.0;
float first_std_parallel = 0.0;
float second_std_parallel = 0.0;
double radLat, localRadius;
FILE *fp;
/************* Skipbytes *****************************/
nSkipBytes = atoi(poDS->GetKeyword("IsisCube.Core.StartByte","")) - 1;
/******* Grab format type (BandSequential, Tiled) *******/
const char *value;
value = poDS->GetKeyword( "IsisCube.Core.Format", "" );
if (EQUAL(value,"Tile") ) { //Todo
strcpy(szLayout,"Tiled");
/******* Get Tile Sizes *********/
tileSizeX = atoi(poDS->GetKeyword("IsisCube.Core.TileSamples",""));
tileSizeY = atoi(poDS->GetKeyword("IsisCube.Core.TileLines",""));
if (tileSizeX <= 0 || tileSizeY <= 0)
{
CPLError( CE_Failure, CPLE_OpenFailed, "Wrong tile dimensions : %d x %d",
tileSizeX, tileSizeY);
delete poDS;
return NULL;
}
}
else if (EQUAL(value,"BandSequential") )
strcpy(szLayout,"BSQ");
else {
CPLError( CE_Failure, CPLE_OpenFailed,
"%s layout not supported. Abort\n\n", value);
delete poDS;
return NULL;
}
/*********** Grab samples lines band ************/
nCols = atoi(poDS->GetKeyword("IsisCube.Core.Dimensions.Samples",""));
nRows = atoi(poDS->GetKeyword("IsisCube.Core.Dimensions.Lines",""));
nBands = atoi(poDS->GetKeyword("IsisCube.Core.Dimensions.Bands",""));
/****** Grab format type - ISIS3 only supports 8,U16,S16,32 *****/
const char *itype;
itype = poDS->GetKeyword( "IsisCube.Core.Pixels.Type" );
if (EQUAL(itype,"UnsignedByte") ) {
eDataType = GDT_Byte;
dfNoData = NULL1;
bNoDataSet = TRUE;
}
else if (EQUAL(itype,"UnsignedWord") ) {
eDataType = GDT_UInt16;
dfNoData = NULL1;
bNoDataSet = TRUE;
}
else if (EQUAL(itype,"SignedWord") ) {
eDataType = GDT_Int16;
dfNoData = NULL2;
bNoDataSet = TRUE;
}
else if (EQUAL(itype,"Real") || EQUAL(value,"") ) {
eDataType = GDT_Float32;
dfNoData = NULL3;
bNoDataSet = TRUE;
}
else {
CPLError( CE_Failure, CPLE_OpenFailed,
"%s layout type not supported. Abort\n\n", itype);
delete poDS;
return NULL;
}
/*********** Grab samples lines band ************/
value = poDS->GetKeyword( "IsisCube.Core.Pixels.ByteOrder");
if (EQUAL(value,"Lsb"))
chByteOrder = 'I';
/*********** Grab Cellsize ************/
value = poDS->GetKeyword("IsisCube.Mapping.PixelResolution");
if (strlen(value) > 0 ) {
dfXDim = atof(value); /* values are in meters */
dfYDim = -atof(value);
}
/*********** Grab UpperLeftCornerY ************/
value = poDS->GetKeyword("IsisCube.Mapping.UpperLeftCornerY");
if (strlen(value) > 0) {
dfULYMap = atof(value);
}
/*********** Grab UpperLeftCornerX ************/
value = poDS->GetKeyword("IsisCube.Mapping.UpperLeftCornerX");
if( strlen(value) > 0 ) {
dfULXMap = atof(value);
}
/*********** Grab TARGET_NAME ************/
/**** This is the planets name i.e. Mars ***/
target_name = poDS->GetKeyword("IsisCube.Mapping.TargetName");
/*********** Grab MAP_PROJECTION_TYPE ************/
map_proj_name =
poDS->GetKeyword( "IsisCube.Mapping.ProjectionName");
/*********** Grab SEMI-MAJOR ************/
semi_major =
atof(poDS->GetKeyword( "IsisCube.Mapping.EquatorialRadius"));
/*********** Grab semi-minor ************/
semi_minor =
atof(poDS->GetKeyword( "IsisCube.Mapping.PolarRadius"));
/*********** Grab CENTER_LAT ************/
center_lat =
atof(poDS->GetKeyword( "IsisCube.Mapping.CenterLatitude"));
/*********** Grab CENTER_LON ************/
center_lon =
atof(poDS->GetKeyword( "IsisCube.Mapping.CenterLongitude"));
/*********** Grab 1st std parallel ************/
first_std_parallel =
atof(poDS->GetKeyword( "IsisCube.Mapping.FirstStandardParallel"));
/*********** Grab 2nd std parallel ************/
second_std_parallel =
atof(poDS->GetKeyword( "IsisCube.Mapping.SecondStandardParallel"));
/*********** Grab scaleFactor ************/
scaleFactor =
atof(poDS->GetKeyword( "IsisCube.Mapping.scaleFactor"));
/*** grab LatitudeType = Planetographic ****/
// Need to further study how ocentric/ographic will effect the gdal library
// So far we will use this fact to define a sphere or ellipse for some
// projections
// Frank - may need to talk this over
value = poDS->GetKeyword("IsisCube.Mapping.LatitudeType");
if (EQUAL( value, "\"Planetocentric\"" ))
bIsGeographic = FALSE;
//Set oSRS projection and parameters
//############################################################
//ISIS3 Projection types
// Equirectangular
// LambertConformal
// Mercator
// ObliqueCylindrical //Todo
// Orthographic
// PolarStereographic
// SimpleCylindrical
// Sinusoidal
// TransverseMercator
#ifdef DEBUG
CPLDebug( "ISIS3", "using projection %s", map_proj_name);
#endif
if ((EQUAL( map_proj_name, "Equirectangular" )) ||
(EQUAL( map_proj_name, "SimpleCylindrical" )) ) {
oSRS.OGRSpatialReference::SetEquirectangular2 ( 0.0, center_lon, center_lat, 0, 0 );
} else if (EQUAL( map_proj_name, "Orthographic" )) {
oSRS.OGRSpatialReference::SetOrthographic ( center_lat, center_lon, 0, 0 );
} else if (EQUAL( map_proj_name, "Sinusoidal" )) {
oSRS.OGRSpatialReference::SetSinusoidal ( center_lon, 0, 0 );
} else if (EQUAL( map_proj_name, "Mercator" )) {
oSRS.OGRSpatialReference::SetMercator ( center_lat, center_lon, scaleFactor, 0, 0 );
} else if (EQUAL( map_proj_name, "PolarStereographic" )) {
oSRS.OGRSpatialReference::SetPS ( center_lat, center_lon, scaleFactor, 0, 0 );
} else if (EQUAL( map_proj_name, "TransverseMercator" )) {
oSRS.OGRSpatialReference::SetTM ( center_lat, center_lon, scaleFactor, 0, 0 );
} else if (EQUAL( map_proj_name, "LambertConformal" )) {
oSRS.OGRSpatialReference::SetLCC ( first_std_parallel, second_std_parallel, center_lat, center_lon, 0, 0 );
} else {
CPLDebug( "ISIS3",
"Dataset projection %s is not supported. Continuing...",
map_proj_name );
bProjectionSet = FALSE;
}
if (bProjectionSet) {
//Create projection name, i.e. MERCATOR MARS and set as ProjCS keyword
strcpy(proj_target_name, map_proj_name);
strcat(proj_target_name, " ");
strcat(proj_target_name, target_name);
oSRS.SetProjCS(proj_target_name); //set ProjCS keyword
//The geographic/geocentric name will be the same basic name as the body name
//'GCS' = Geographic/Geocentric Coordinate System
strcpy(geog_name, "GCS_");
strcat(geog_name, target_name);
//The datum name will be the same basic name as the planet
strcpy(datum_name, "D_");
strcat(datum_name, target_name);
strcpy(sphere_name, target_name);
//strcat(sphere_name, "_IAU_IAG"); //Might not be IAU defined so don't add
//calculate inverse flattening from major and minor axis: 1/f = a/(a-b)
if ((semi_major - semi_minor) < 0.0000001)
iflattening = 0;
else
iflattening = semi_major / (semi_major - semi_minor);
//Set the body size but take into consideration which proj is being used to help w/ proj4 compatibility
//The use of a Sphere, polar radius or ellipse here is based on how ISIS does it internally
if ( ( (EQUAL( map_proj_name, "Stereographic" ) && (fabs(center_lat) == 90)) ) ||
(EQUAL( map_proj_name, "PolarStereographic" )) )
{
if (bIsGeographic) {
//Geograpraphic, so set an ellipse
oSRS.SetGeogCS( geog_name, datum_name, sphere_name,
semi_major, iflattening,
"Reference_Meridian", 0.0 );
} else {
//Geocentric, so force a sphere using the semi-minor axis. I hope...
strcat(sphere_name, "_polarRadius");
oSRS.SetGeogCS( geog_name, datum_name, sphere_name,
semi_minor, 0.0,
"Reference_Meridian", 0.0 );
}
}
else if ( (EQUAL( map_proj_name, "SimpleCylindrical" )) ||
(EQUAL( map_proj_name, "Orthographic" )) ||
(EQUAL( map_proj_name, "Stereographic" )) ||
(EQUAL( map_proj_name, "Sinusoidal" )) ) {
//isis uses the sphereical equation for these projections so force a sphere
oSRS.SetGeogCS( geog_name, datum_name, sphere_name,
semi_major, 0.0,
"Reference_Meridian", 0.0 );
}
else if (EQUAL( map_proj_name, "Equirectangular" )) {
//Calculate localRadius using ISIS3 simple elliptical method
// not the more standard Radius of Curvature method
//PI = 4 * atan(1);
radLat = center_lat * PI / 180; // in radians
localRadius = semi_major * semi_minor / sqrt(pow(semi_minor*cos(radLat),2)
+ pow(semi_major*sin(radLat),2) );
strcat(sphere_name, "_localRadius");
oSRS.SetGeogCS( geog_name, datum_name, sphere_name,
localRadius, 0.0,
"Reference_Meridian", 0.0 );
}
else {
//All other projections: Mercator, Transverse Mercator, Lambert Conformal, etc.
//Geographic, so set an ellipse
if (bIsGeographic) {
oSRS.SetGeogCS( geog_name, datum_name, sphere_name,
semi_major, iflattening,
"Reference_Meridian", 0.0 );
} else {
//Geocentric, so force a sphere. I hope...
oSRS.SetGeogCS( geog_name, datum_name, sphere_name,
semi_major, 0.0,
"Reference_Meridian", 0.0 );
}
}
// translate back into a projection string.
char *pszResult = NULL;
oSRS.exportToWkt( &pszResult );
poDS->osProjection = pszResult;
CPLFree( pszResult );
}
/* END ISIS3 Label Read */
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
/* -------------------------------------------------------------------- */
/* Is the CUB detached - if so, reset name to binary file? */
/* -------------------------------------------------------------------- */
#ifdef notdef
// Frank - is this correct?
//The extension already added on so don't add another. But is this needed?
char *pszPath = CPLStrdup( CPLGetPath( poOpenInfo->pszFilename ) );
char *pszName = CPLStrdup( CPLGetBasename( poOpenInfo->pszFilename ) );
if (bIsDetached)
pszCUBFilename = CPLFormCIFilename( pszPath, detachedCub, "" );
#endif
/* -------------------------------------------------------------------- */
/* 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 || nBands < 1 )
{
delete poDS;
return NULL;
}
/* -------------------------------------------------------------------- */
/* Capture some information from the file that is of interest. */
/* -------------------------------------------------------------------- */
poDS->nRasterXSize = nCols;
poDS->nRasterYSize = nRows;
/* -------------------------------------------------------------------- */
/* Open target binary file. */
/* -------------------------------------------------------------------- */
if( poOpenInfo->eAccess == GA_ReadOnly )
poDS->fpImage = VSIFOpenL( osQubeFile, "r" );
else
poDS->fpImage = VSIFOpenL( osQubeFile, "r+" );
if( poDS->fpImage == NULL )
{
CPLError( CE_Failure, CPLE_OpenFailed,
"Failed to open %s with write permission.\n%s",
osQubeFile.c_str(),
VSIStrerror( errno ) );
delete poDS;
return NULL;
}
poDS->eAccess = poOpenInfo->eAccess;
/* -------------------------------------------------------------------- */
/* Compute the line offset. */
/* -------------------------------------------------------------------- */
int nItemSize = GDALGetDataTypeSize(eDataType)/8;
int nLineOffset=0, nPixelOffset=0, nBandOffset=0;
if( EQUAL(szLayout,"BSQ") )
{
nPixelOffset = nItemSize;
nLineOffset = nPixelOffset * nCols;
nBandOffset = nLineOffset * nRows;
}
else /* Tiled */
{
}
/* -------------------------------------------------------------------- */
/* Create band information objects. */
/* -------------------------------------------------------------------- */
int i;
#ifdef CPL_LSB
int bNativeOrder = !(chByteOrder == 'M');
#else
int bNativeOrder = (chByteOrder == 'M');
#endif
for( i = 0; i < nBands; i++ )
{
GDALRasterBand *poBand;
if( EQUAL(szLayout,"Tiled") )
{
poBand = new ISISTiledBand( poDS, poDS->fpImage, i+1, eDataType,
tileSizeX, tileSizeY,
nSkipBytes, 0, 0,
bNativeOrder );
}
else
{
poBand =
new RawRasterBand( poDS, i+1, poDS->fpImage,
nSkipBytes + nBandOffset * i,
nPixelOffset, nLineOffset, eDataType,
#ifdef CPL_LSB
chByteOrder == 'I' || chByteOrder == 'L',
#else
chByteOrder == 'M',
#endif
TRUE );
}
poDS->SetBand( i+1, poBand );
if( bNoDataSet )
((GDALPamRasterBand *) poBand)->SetNoDataValue( dfNoData );
// Set offset/scale values at the PAM level.
poBand->SetOffset(
CPLAtofM(poDS->GetKeyword("IsisCube.Core.Pixels.Base","0.0")));
poBand->SetScale(
CPLAtofM(poDS->GetKeyword("IsisCube.Core.Pixels.Multiplier","1.0")));
}
/* -------------------------------------------------------------------- */
/* Check for a .prj file. For ISIS3 I would like to keep this in */
/* -------------------------------------------------------------------- */
CPLString osPath, osName;
osPath = CPLGetPath( poOpenInfo->pszFilename );
osName = CPLGetBasename(poOpenInfo->pszFilename);
const char *pszPrjFile = CPLFormCIFilename( osPath, osName, "prj" );
fp = VSIFOpen( pszPrjFile, "r" );
if( fp != NULL )
{
char **papszLines;
OGRSpatialReference oSRS;
VSIFClose( fp );
papszLines = CSLLoad( pszPrjFile );
if( oSRS.importFromESRI( papszLines ) == OGRERR_NONE )
{
char *pszResult = NULL;
oSRS.exportToWkt( &pszResult );
poDS->osProjection = pszResult;
CPLFree( pszResult );
}
CSLDestroy( papszLines );
}
if( dfULYMap != 0.5 || dfULYMap != 0.5 || dfXDim != 1.0 || dfYDim != 1.0 )
{
poDS->bGotTransform = TRUE;
poDS->adfGeoTransform[0] = dfULXMap;
poDS->adfGeoTransform[1] = dfXDim;
poDS->adfGeoTransform[2] = 0.0;
poDS->adfGeoTransform[3] = dfULYMap;
poDS->adfGeoTransform[4] = 0.0;
poDS->adfGeoTransform[5] = dfYDim;
}
if( !poDS->bGotTransform )
poDS->bGotTransform =
GDALReadWorldFile( poOpenInfo->pszFilename, "cbw",
poDS->adfGeoTransform );
if( !poDS->bGotTransform )
poDS->bGotTransform =
GDALReadWorldFile( poOpenInfo->pszFilename, "wld",
poDS->adfGeoTransform );
/* -------------------------------------------------------------------- */
/* Initialize any PAM information. */
/* -------------------------------------------------------------------- */
poDS->SetDescription( poOpenInfo->pszFilename );
poDS->TryLoadXML();
/* -------------------------------------------------------------------- */
/* Check for overviews. */
/* -------------------------------------------------------------------- */
poDS->oOvManager.Initialize( poDS, poOpenInfo->pszFilename );
return( poDS );
}
GDALDataset *TerragenDataset::Open( GDALOpenInfo * poOpenInfo )
{
// The file should have at least 32 header bytes
if( poOpenInfo->nHeaderBytes < 32 )
return NULL;
if( !EQUALN((const char *) poOpenInfo->pabyHeader,
"TERRAGENTERRAIN ", 16) )
return NULL;
/* -------------------------------------------------------------------- */
/* Create a corresponding GDALDataset. */
/* -------------------------------------------------------------------- */
TerragenDataset *poDS;
poDS = new TerragenDataset();
// Reopen for large file access.
if( poOpenInfo->eAccess == GA_Update )
poDS->m_fp = VSIFOpenL( poOpenInfo->pszFilename, "rb+" );
else
poDS->m_fp = VSIFOpenL( poOpenInfo->pszFilename, "rb" );
if( poDS->m_fp == NULL )
{
CPLError( CE_Failure, CPLE_OpenFailed,
"Failed to re-open %s within Terragen driver.\n",
poOpenInfo->pszFilename );
return NULL;
}
poDS->eAccess = poOpenInfo->eAccess;
/* -------------------------------------------------------------------- */
/* Read the file. */
/* -------------------------------------------------------------------- */
if( !poDS->LoadFromFile() )
{
delete poDS;
return NULL;
}
/* -------------------------------------------------------------------- */
/* Create band information objects. */
/* -------------------------------------------------------------------- */
poDS->SetBand( 1, new TerragenRasterBand( poDS ));
poDS->SetMetadataItem( GDALMD_AREA_OR_POINT, GDALMD_AOP_POINT );
/* -------------------------------------------------------------------- */
/* Initialize any PAM information. */
/* -------------------------------------------------------------------- */
poDS->SetDescription( poOpenInfo->pszFilename );
poDS->TryLoadXML();
/* -------------------------------------------------------------------- */
/* Support overviews. */
/* -------------------------------------------------------------------- */
poDS->oOvManager.Initialize( poDS, poOpenInfo->pszFilename );
return( poDS );
}
GDALDataset* TerragenDataset::Create
(
const char* pszFilename,
int nXSize, int nYSize, int nBands,
GDALDataType eType, char** papszOptions
)
{
TerragenDataset* poDS = new TerragenDataset();
poDS->eAccess = GA_Update;
poDS->m_pszFilename = CPLStrdup(pszFilename);
// --------------------------------------------------------------------
// Verify input options.
// --------------------------------------------------------------------
const char* pszValue = CSLFetchNameValue(
papszOptions,"MINUSERPIXELVALUE");
if( pszValue != NULL )
poDS->m_dLogSpan[0] = CPLAtof( pszValue );
pszValue = CSLFetchNameValue(
papszOptions,"MAXUSERPIXELVALUE");
if( pszValue != NULL )
poDS->m_dLogSpan[1] = CPLAtof( pszValue );
if( poDS->m_dLogSpan[1] <= poDS->m_dLogSpan[0] )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Inverted, flat, or unspecified span for Terragen file." );
delete poDS;
return NULL;
}
if( eType != GDT_Float32 )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Attempt to create Terragen dataset with a non-float32\n"
"data type (%s).\n",
GDALGetDataTypeName(eType) );
delete poDS;
return NULL;
}
if( nBands != 1 )
{
CPLError( CE_Failure, CPLE_NotSupported,
"Terragen driver doesn't support %d bands. Must be 1.\n",
nBands );
delete poDS;
return NULL;
}
// --------------------------------------------------------------------
// Try to create the file.
// --------------------------------------------------------------------
poDS->m_fp = VSIFOpenL( pszFilename, "wb+" );
if( poDS->m_fp == NULL )
{
CPLError( CE_Failure, CPLE_OpenFailed,
"Attempt to create file `%s' failed.\n",
pszFilename );
delete poDS;
return NULL;
}
poDS->nRasterXSize = nXSize;
poDS->nRasterYSize = nYSize;
// Don't bother writing the header here; the first
// call to IWriteBlock will do that instead, since
// the elevation data's location depends on the
// header size.
// --------------------------------------------------------------------
// Instance a band.
// --------------------------------------------------------------------
poDS->SetBand( 1, new TerragenRasterBand( poDS ) );
//VSIFClose( poDS->m_fp );
//return (GDALDataset *) GDALOpen( pszFilename, GA_Update );
return (GDALDataset *) poDS;
}
OGRErr OGRPGeoLayer::createFromShapeBin( GByte *pabyShape,
OGRGeometry **ppoGeom,
int nBytes )
{
*ppoGeom = NULL;
if( nBytes < 1 )
return OGRERR_FAILURE;
int nSHPType = pabyShape[0];
// CPLDebug( "PGeo",
// "Shape type read from PGeo data is nSHPType = %d",
// nSHPType );
/* -------------------------------------------------------------------- */
/* type 50 appears to just be an alias for normal line */
/* strings. (#1484) */
/* Type 51 appears to just be an alias for normal polygon. (#3100) */
/* TODO: These types include additional attributes including */
/* non-linear segments and such. They should be handled. */
/* -------------------------------------------------------------------- */
switch( nSHPType )
{
case 50:
nSHPType = SHPT_ARC;
break;
case 51:
nSHPType = SHPT_POLYGON;
break;
case 52:
nSHPType = SHPT_POINT;
break;
case 53:
nSHPType = SHPT_MULTIPOINT;
break;
case 54:
nSHPType = SHPT_MULTIPATCH;
}
/* ==================================================================== */
/* Extract vertices for a Polygon or Arc. */
/* ==================================================================== */
if( nSHPType == SHPT_ARC
|| nSHPType == SHPT_ARCZ
|| nSHPType == SHPT_ARCM
|| nSHPType == SHPT_ARCZM
|| nSHPType == SHPT_POLYGON
|| nSHPType == SHPT_POLYGONZ
|| nSHPType == SHPT_POLYGONM
|| nSHPType == SHPT_POLYGONZM
|| nSHPType == SHPT_MULTIPATCH
|| nSHPType == SHPT_MULTIPATCHM)
{
GInt32 nPoints, nParts;
int i, nOffset;
GInt32 *panPartStart;
if (nBytes < 44)
{
CPLError(CE_Failure, CPLE_AppDefined,
"Corrupted Shape : nBytes=%d, nSHPType=%d", nBytes, nSHPType);
return OGRERR_FAILURE;
}
/* -------------------------------------------------------------------- */
/* Extract part/point count, and build vertex and part arrays */
/* to proper size. */
/* -------------------------------------------------------------------- */
memcpy( &nPoints, pabyShape + 40, 4 );
memcpy( &nParts, pabyShape + 36, 4 );
CPL_LSBPTR32( &nPoints );
CPL_LSBPTR32( &nParts );
if (nPoints < 0 || nParts < 0 ||
nPoints > 50 * 1000 * 1000 || nParts > 10 * 1000 * 1000)
{
CPLError(CE_Failure, CPLE_AppDefined, "Corrupted Shape : nPoints=%d, nParts=%d.",
nPoints, nParts);
return OGRERR_FAILURE;
}
int bHasZ = ( nSHPType == SHPT_POLYGONZ
|| nSHPType == SHPT_POLYGONZM
|| nSHPType == SHPT_ARCZ
|| nSHPType == SHPT_ARCZM
|| nSHPType == SHPT_MULTIPATCH
|| nSHPType == SHPT_MULTIPATCHM );
int bIsMultiPatch = ( nSHPType == SHPT_MULTIPATCH || nSHPType == SHPT_MULTIPATCHM );
/* With the previous checks on nPoints and nParts, */
/* we should not overflow here and after */
/* since 50 M * (16 + 8 + 8) = 1 600 MB */
int nRequiredSize = 44 + 4 * nParts + 16 * nPoints;
if ( bHasZ )
{
nRequiredSize += 16 + 8 * nPoints;
}
if( bIsMultiPatch )
{
nRequiredSize += 4 * nParts;
}
if (nRequiredSize > nBytes)
{
CPLError(CE_Failure, CPLE_AppDefined,
"Corrupted Shape : nPoints=%d, nParts=%d, nBytes=%d, nSHPType=%d",
nPoints, nParts, nBytes, nSHPType);
return OGRERR_FAILURE;
}
panPartStart = (GInt32 *) VSICalloc(nParts,sizeof(GInt32));
if (panPartStart == NULL)
{
CPLError(CE_Failure, CPLE_OutOfMemory,
"Not enough memory for shape (nPoints=%d, nParts=%d)", nPoints, nParts);
return OGRERR_FAILURE;
}
/* -------------------------------------------------------------------- */
/* Copy out the part array from the record. */
/* -------------------------------------------------------------------- */
memcpy( panPartStart, pabyShape + 44, 4 * nParts );
for( i = 0; i < nParts; i++ )
{
CPL_LSBPTR32( panPartStart + i );
/* We check that the offset is inside the vertex array */
if (panPartStart[i] < 0 ||
panPartStart[i] >= nPoints)
{
CPLError(CE_Failure, CPLE_AppDefined,
"Corrupted Shape : panPartStart[%d] = %d, nPoints = %d",
i, panPartStart[i], nPoints);
CPLFree(panPartStart);
return OGRERR_FAILURE;
}
if (i > 0 && panPartStart[i] <= panPartStart[i-1])
{
CPLError(CE_Failure, CPLE_AppDefined,
"Corrupted Shape : panPartStart[%d] = %d, panPartStart[%d] = %d",
i, panPartStart[i], i - 1, panPartStart[i - 1]);
CPLFree(panPartStart);
return OGRERR_FAILURE;
}
}
nOffset = 44 + 4*nParts;
/* -------------------------------------------------------------------- */
/* If this is a multipatch, we will also have parts types. For */
/* now we ignore and skip past them. */
/* -------------------------------------------------------------------- */
if( bIsMultiPatch )
nOffset += 4*nParts;
/* -------------------------------------------------------------------- */
/* Copy out the vertices from the record. */
/* -------------------------------------------------------------------- */
double *padfX = (double *) VSIMalloc(sizeof(double)*nPoints);
double *padfY = (double *) VSIMalloc(sizeof(double)*nPoints);
double *padfZ = (double *) VSICalloc(sizeof(double),nPoints);
if (padfX == NULL || padfY == NULL || padfZ == NULL)
{
CPLFree( panPartStart );
CPLFree( padfX );
CPLFree( padfY );
CPLFree( padfZ );
CPLError(CE_Failure, CPLE_OutOfMemory,
"Not enough memory for shape (nPoints=%d, nParts=%d)", nPoints, nParts);
return OGRERR_FAILURE;
}
for( i = 0; i < nPoints; i++ )
{
memcpy(padfX + i, pabyShape + nOffset + i * 16, 8 );
memcpy(padfY + i, pabyShape + nOffset + i * 16 + 8, 8 );
CPL_LSBPTR64( padfX + i );
CPL_LSBPTR64( padfY + i );
}
nOffset += 16*nPoints;
/* -------------------------------------------------------------------- */
/* If we have a Z coordinate, collect that now. */
/* -------------------------------------------------------------------- */
if( bHasZ )
{
for( i = 0; i < nPoints; i++ )
{
memcpy( padfZ + i, pabyShape + nOffset + 16 + i*8, 8 );
CPL_LSBPTR64( padfZ + i );
}
nOffset += 16 + 8*nPoints;
}
/* -------------------------------------------------------------------- */
/* Build corresponding OGR objects. */
/* -------------------------------------------------------------------- */
if( nSHPType == SHPT_ARC
|| nSHPType == SHPT_ARCZ
|| nSHPType == SHPT_ARCM
|| nSHPType == SHPT_ARCZM )
{
/* -------------------------------------------------------------------- */
/* Arc - As LineString */
/* -------------------------------------------------------------------- */
if( nParts == 1 )
{
OGRLineString *poLine = new OGRLineString();
*ppoGeom = poLine;
poLine->setPoints( nPoints, padfX, padfY, padfZ );
}
/* -------------------------------------------------------------------- */
/* Arc - As MultiLineString */
/* -------------------------------------------------------------------- */
else
{
OGRMultiLineString *poMulti = new OGRMultiLineString;
*ppoGeom = poMulti;
for( i = 0; i < nParts; i++ )
{
OGRLineString *poLine = new OGRLineString;
int nVerticesInThisPart;
if( i == nParts-1 )
nVerticesInThisPart = nPoints - panPartStart[i];
else
nVerticesInThisPart =
panPartStart[i+1] - panPartStart[i];
poLine->setPoints( nVerticesInThisPart,
padfX + panPartStart[i],
padfY + panPartStart[i],
padfZ + panPartStart[i] );
poMulti->addGeometryDirectly( poLine );
}
}
} /* ARC */
/* -------------------------------------------------------------------- */
/* Polygon */
/* -------------------------------------------------------------------- */
else if( nSHPType == SHPT_POLYGON
|| nSHPType == SHPT_POLYGONZ
|| nSHPType == SHPT_POLYGONM
|| nSHPType == SHPT_POLYGONZM )
{
OGRPolygon *poMulti = new OGRPolygon;
*ppoGeom = poMulti;
for( i = 0; i < nParts; i++ )
{
OGRLinearRing *poRing = new OGRLinearRing;
int nVerticesInThisPart;
if( i == nParts-1 )
nVerticesInThisPart = nPoints - panPartStart[i];
else
nVerticesInThisPart =
panPartStart[i+1] - panPartStart[i];
poRing->setPoints( nVerticesInThisPart,
padfX + panPartStart[i],
padfY + panPartStart[i],
padfZ + panPartStart[i] );
poMulti->addRingDirectly( poRing );
}
} /* polygon */
/* -------------------------------------------------------------------- */
/* Multipatch */
/* -------------------------------------------------------------------- */
else if( bIsMultiPatch )
{
/* return to this later */
}
CPLFree( panPartStart );
CPLFree( padfX );
CPLFree( padfY );
CPLFree( padfZ );
if( !bHasZ )
(*ppoGeom)->setCoordinateDimension( 2 );
return OGRERR_NONE;
}
/* ==================================================================== */
/* Extract vertices for a MultiPoint. */
/* ==================================================================== */
else if( nSHPType == SHPT_MULTIPOINT
|| nSHPType == SHPT_MULTIPOINTM
|| nSHPType == SHPT_MULTIPOINTZ
|| nSHPType == SHPT_MULTIPOINTZM )
{
#ifdef notdef
int32 nPoints;
int i, nOffset;
memcpy( &nPoints, psSHP->pabyRec + 44, 4 );
if( bBigEndian ) SwapWord( 4, &nPoints );
psShape->nVertices = nPoints;
psShape->padfX = (double *) calloc(nPoints,sizeof(double));
psShape->padfY = (double *) calloc(nPoints,sizeof(double));
psShape->padfZ = (double *) calloc(nPoints,sizeof(double));
psShape->padfM = (double *) calloc(nPoints,sizeof(double));
for( i = 0; i < nPoints; i++ )
{
memcpy(psShape->padfX+i, psSHP->pabyRec + 48 + 16 * i, 8 );
memcpy(psShape->padfY+i, psSHP->pabyRec + 48 + 16 * i + 8, 8 );
if( bBigEndian ) SwapWord( 8, psShape->padfX + i );
if( bBigEndian ) SwapWord( 8, psShape->padfY + i );
}
nOffset = 48 + 16*nPoints;
/* -------------------------------------------------------------------- */
/* Get the X/Y bounds. */
/* -------------------------------------------------------------------- */
memcpy( &(psShape->dfXMin), psSHP->pabyRec + 8 + 4, 8 );
memcpy( &(psShape->dfYMin), psSHP->pabyRec + 8 + 12, 8 );
memcpy( &(psShape->dfXMax), psSHP->pabyRec + 8 + 20, 8 );
memcpy( &(psShape->dfYMax), psSHP->pabyRec + 8 + 28, 8 );
if( bBigEndian ) SwapWord( 8, &(psShape->dfXMin) );
if( bBigEndian ) SwapWord( 8, &(psShape->dfYMin) );
if( bBigEndian ) SwapWord( 8, &(psShape->dfXMax) );
if( bBigEndian ) SwapWord( 8, &(psShape->dfYMax) );
/* -------------------------------------------------------------------- */
/* If we have a Z coordinate, collect that now. */
/* -------------------------------------------------------------------- */
if( psShape->nSHPType == SHPT_MULTIPOINTZ || psShape->nSHPType == SHPT_MULTIPOINTZM )
{
memcpy( &(psShape->dfZMin), psSHP->pabyRec + nOffset, 8 );
memcpy( &(psShape->dfZMax), psSHP->pabyRec + nOffset + 8, 8 );
if( bBigEndian ) SwapWord( 8, &(psShape->dfZMin) );
if( bBigEndian ) SwapWord( 8, &(psShape->dfZMax) );
for( i = 0; i < nPoints; i++ )
{
memcpy( psShape->padfZ + i,
psSHP->pabyRec + nOffset + 16 + i*8, 8 );
if( bBigEndian ) SwapWord( 8, psShape->padfZ + i );
}
nOffset += 16 + 8*nPoints;
}
/* -------------------------------------------------------------------- */
/* If we have a M measure value, then read it now. We assume */
/* that the measure can be present for any shape if the size is */
/* big enough, but really it will only occur for the Z shapes */
/* (options), and the M shapes. */
/* -------------------------------------------------------------------- */
if( psSHP->panRecSize[hEntity]+8 >= nOffset + 16 + 8*nPoints )
{
memcpy( &(psShape->dfMMin), psSHP->pabyRec + nOffset, 8 );
memcpy( &(psShape->dfMMax), psSHP->pabyRec + nOffset + 8, 8 );
if( bBigEndian ) SwapWord( 8, &(psShape->dfMMin) );
if( bBigEndian ) SwapWord( 8, &(psShape->dfMMax) );
for( i = 0; i < nPoints; i++ )
{
memcpy( psShape->padfM + i,
psSHP->pabyRec + nOffset + 16 + i*8, 8 );
if( bBigEndian ) SwapWord( 8, psShape->padfM + i );
}
}
#endif
}
/* ==================================================================== */
/* Extract vertices for a point. */
/* ==================================================================== */
else if( nSHPType == SHPT_POINT
|| nSHPType == SHPT_POINTM
|| nSHPType == SHPT_POINTZ
|| nSHPType == SHPT_POINTZM )
{
int nOffset;
double dfX, dfY, dfZ = 0;
int bHasZ = (nSHPType == SHPT_POINTZ || nSHPType == SHPT_POINTZM);
if (nBytes < 4 + 8 + 8 + ((nSHPType == SHPT_POINTZ) ? 8 : 0))
{
CPLError(CE_Failure, CPLE_AppDefined,
"Corrupted Shape : nBytes=%d, nSHPType=%d", nBytes, nSHPType);
return OGRERR_FAILURE;
}
memcpy( &dfX, pabyShape + 4, 8 );
memcpy( &dfY, pabyShape + 4 + 8, 8 );
CPL_LSBPTR64( &dfX );
CPL_LSBPTR64( &dfY );
nOffset = 20 + 8;
if( bHasZ )
{
memcpy( &dfZ, pabyShape + 4 + 16, 8 );
CPL_LSBPTR64( &dfZ );
}
*ppoGeom = new OGRPoint( dfX, dfY, dfZ );
if( !bHasZ )
(*ppoGeom)->setCoordinateDimension( 2 );
return OGRERR_NONE;
}
char* pszHex = CPLBinaryToHex( nBytes, pabyShape );
CPLDebug( "PGEO", "Unsupported geometry type:%d\nnBytes=%d, hex=%s",
nSHPType, nBytes, pszHex );
CPLFree(pszHex);
return OGRERR_FAILURE;
}
swq_field_type swq_expr_node::Check( swq_field_list *poFieldList )
{
/* -------------------------------------------------------------------- */
/* If something is a string constant, we must check if it is */
/* actually a reference to a field in which case we will */
/* convert it into a column type. */
/* -------------------------------------------------------------------- */
if( eNodeType == SNT_CONSTANT && field_type == SWQ_STRING )
{
int wrk_field_index, wrk_table_index;
swq_field_type wrk_field_type;
wrk_field_index =
swq_identify_field( string_value, poFieldList,
&wrk_field_type, &wrk_table_index );
if( wrk_field_index >= 0 )
{
eNodeType = SNT_COLUMN;
field_index = -1;
table_index = -1;
}
}
/* -------------------------------------------------------------------- */
/* Otherwise we take constants literally. */
/* -------------------------------------------------------------------- */
if( eNodeType == SNT_CONSTANT )
return field_type;
/* -------------------------------------------------------------------- */
/* If this is intended to be a field definition, but has not */
/* yet been looked up, we do so now. */
/* -------------------------------------------------------------------- */
if( eNodeType == SNT_COLUMN && field_index == -1 )
{
field_index =
swq_identify_field( string_value, poFieldList,
&field_type, &table_index );
if( field_index < 0 )
{
CPLError( CE_Failure, CPLE_AppDefined,
"'%s' not recognised as an available field.",
string_value );
return SWQ_ERROR;
}
}
if( eNodeType == SNT_COLUMN )
return field_type;
/* -------------------------------------------------------------------- */
/* We are dealing with an operation - fetch the definition. */
/* -------------------------------------------------------------------- */
const swq_operation *poOp =
swq_op_registrar::GetOperator((swq_op)nOperation);
if( poOp == NULL )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Check(): Unable to find definition for operator %d.",
nOperation );
return SWQ_ERROR;
}
/* -------------------------------------------------------------------- */
/* Check subexpressions first. */
/* -------------------------------------------------------------------- */
int i;
for( i = 0; i < nSubExprCount; i++ )
{
if( papoSubExpr[i]->Check(poFieldList) == SWQ_ERROR )
return SWQ_ERROR;
}
/* -------------------------------------------------------------------- */
/* Check this node. */
/* -------------------------------------------------------------------- */
field_type = poOp->pfnChecker( this );
return field_type;
}
int OGRGPSBabelDataSource::Open( const char * pszDatasourceName,
const char* pszGPSBabelDriverNameIn,
char** papszOpenOptions )
{
int bExplicitFeatures = FALSE;
int bWaypoints = TRUE, bTracks = TRUE, bRoutes = TRUE;
if (!EQUALN(pszDatasourceName, "GPSBABEL:", 9))
{
CPLAssert(pszGPSBabelDriverNameIn);
pszGPSBabelDriverName = CPLStrdup(pszGPSBabelDriverNameIn);
pszFilename = CPLStrdup(pszDatasourceName);
}
else
{
if( CSLFetchNameValue(papszOpenOptions, "FILENAME") )
pszFilename = CPLStrdup(CSLFetchNameValue(papszOpenOptions,
"FILENAME"));
if( CSLFetchNameValue(papszOpenOptions, "GPSBABEL_DRIVER") )
{
if( pszFilename == NULL )
{
CPLError(CE_Failure, CPLE_AppDefined, "Missing FILENAME");
return FALSE;
}
pszGPSBabelDriverName = CPLStrdup(CSLFetchNameValue(papszOpenOptions,
"DRIVER"));
/* A bit of validation to avoid command line injection */
if (!IsValidDriverName(pszGPSBabelDriverName))
return FALSE;
}
}
pszName = CPLStrdup( pszDatasourceName );
if (pszGPSBabelDriverName == NULL)
{
const char* pszSep = strchr(pszDatasourceName + 9, ':');
if (pszSep == NULL)
{
CPLError(CE_Failure, CPLE_AppDefined,
"Wrong syntax. Expected GPSBabel:driver_name:file_name");
return FALSE;
}
pszGPSBabelDriverName = CPLStrdup(pszDatasourceName + 9);
*(strchr(pszGPSBabelDriverName, ':')) = '\0';
/* A bit of validation to avoid command line injection */
if (!IsValidDriverName(pszGPSBabelDriverName))
return FALSE;
/* Parse optionnal features= option */
if (EQUALN(pszSep+1, "features=", 9))
{
const char* pszNextSep = strchr(pszSep+1, ':');
if (pszNextSep == NULL)
{
CPLError(CE_Failure, CPLE_AppDefined,
"Wrong syntax. Expected GPSBabel:driver_name[,options]*:[features=waypoints,tracks,routes:]file_name");
return FALSE;
}
char* pszFeatures = CPLStrdup(pszSep+1+9);
*strchr(pszFeatures, ':') = 0;
char** papszTokens = CSLTokenizeString(pszFeatures);
char** papszIter = papszTokens;
int bErr = FALSE;
bExplicitFeatures = TRUE;
bWaypoints = bTracks = bRoutes = FALSE;
while(papszIter && *papszIter)
{
if (EQUAL(*papszIter, "waypoints"))
bWaypoints = TRUE;
else if (EQUAL(*papszIter, "tracks"))
bTracks = TRUE;
else if (EQUAL(*papszIter, "routes"))
bRoutes = TRUE;
else
{
CPLError(CE_Failure, CPLE_AppDefined, "Wrong value for 'features' options");
bErr = TRUE;
}
papszIter ++;
}
CSLDestroy(papszTokens);
CPLFree(pszFeatures);
if (bErr)
return FALSE;
pszSep = pszNextSep;
}
if( pszFilename == NULL )
pszFilename = CPLStrdup(pszSep+1);
}
const char* pszOptionUseTempFile = CPLGetConfigOption("USE_TEMPFILE", NULL);
if (pszOptionUseTempFile && CSLTestBoolean(pszOptionUseTempFile))
osTmpFileName = CPLGenerateTempFilename(NULL);
else
osTmpFileName.Printf("/vsimem/ogrgpsbabeldatasource_%p", this);
int bRet = FALSE;
if (IsSpecialFile(pszFilename))
{
/* Special file : don't try to open it */
char** argv = GetArgv(bExplicitFeatures, bWaypoints, bRoutes,
bTracks, pszGPSBabelDriverName, pszFilename);
VSILFILE* tmpfp = VSIFOpenL(osTmpFileName.c_str(), "wb");
bRet = (CPLSpawn(argv, NULL, tmpfp, TRUE) == 0);
VSIFCloseL(tmpfp);
tmpfp = NULL;
CSLDestroy(argv);
argv = NULL;
}
else
{
VSILFILE* fp = VSIFOpenL(pszFilename, "rb");
if (fp == NULL)
{
CPLError(CE_Failure, CPLE_AppDefined,
"Cannot open file %s", pszFilename);
return FALSE;
}
char** argv = GetArgv(bExplicitFeatures, bWaypoints, bRoutes,
bTracks, pszGPSBabelDriverName, "-");
VSILFILE* tmpfp = VSIFOpenL(osTmpFileName.c_str(), "wb");
CPLPushErrorHandler(CPLQuietErrorHandler);
bRet = (CPLSpawn(argv, fp, tmpfp, TRUE) == 0);
CPLPopErrorHandler();
CSLDestroy(argv);
argv = NULL;
CPLErr nLastErrorType = CPLGetLastErrorType();
int nLastErrorNo = CPLGetLastErrorNo();
CPLString osLastErrorMsg = CPLGetLastErrorMsg();
VSIFCloseL(tmpfp);
tmpfp = NULL;
VSIFCloseL(fp);
fp = NULL;
if (!bRet)
{
if (strstr(osLastErrorMsg.c_str(), "This format cannot be used in piped commands") == NULL)
{
CPLError(nLastErrorType, nLastErrorNo, "%s", osLastErrorMsg.c_str());
}
else
{
VSIStatBuf sStatBuf;
if (VSIStat(pszFilename, &sStatBuf) != 0)
{
CPLError(CE_Failure, CPLE_NotSupported,
"Driver %s only supports real (non virtual) files", pszGPSBabelDriverName);
return FALSE;
}
/* Try without piping in */
argv = GetArgv(bExplicitFeatures, bWaypoints, bRoutes,
bTracks, pszGPSBabelDriverName, pszFilename);
tmpfp = VSIFOpenL(osTmpFileName.c_str(), "wb");
bRet = (CPLSpawn(argv, NULL, tmpfp, TRUE) == 0);
VSIFCloseL(tmpfp);
tmpfp = NULL;
CSLDestroy(argv);
argv = NULL;
}
}
}
if (bRet)
{
poGPXDS = (GDALDataset*) GDALOpenEx(osTmpFileName.c_str(),
GDAL_OF_VECTOR, NULL, NULL, NULL);
if (poGPXDS)
{
OGRLayer* poLayer;
if (bWaypoints)
{
poLayer = poGPXDS->GetLayerByName("waypoints");
if (poLayer != NULL && poLayer->GetFeatureCount() != 0)
apoLayers[nLayers++] = poLayer;
}
if (bRoutes)
{
poLayer = poGPXDS->GetLayerByName("routes");
if (poLayer != NULL && poLayer->GetFeatureCount() != 0)
apoLayers[nLayers++] = poLayer;
poLayer = poGPXDS->GetLayerByName("route_points");
if (poLayer != NULL && poLayer->GetFeatureCount() != 0)
apoLayers[nLayers++] = poLayer;
}
if (bTracks)
{
poLayer = poGPXDS->GetLayerByName("tracks");
if (poLayer != NULL && poLayer->GetFeatureCount() != 0)
apoLayers[nLayers++] = poLayer;
poLayer = poGPXDS->GetLayerByName("track_points");
if (poLayer != NULL && poLayer->GetFeatureCount() != 0)
apoLayers[nLayers++] = poLayer;
}
}
}
return nLayers > 0;
}
void OGRPGeoLayer::LookupSRID( int nSRID )
{
/* -------------------------------------------------------------------- */
/* Fetch the corresponding WKT from the SpatialRef table. */
/* -------------------------------------------------------------------- */
CPLODBCStatement oStmt( poDS->GetSession() );
oStmt.Appendf( "SELECT srtext FROM GDB_SpatialRefs WHERE srid = %d",
nSRID );
if( !oStmt.ExecuteSQL() )
{
CPLError( CE_Failure, CPLE_AppDefined,
"'%s' failed.\n%s",
oStmt.GetCommand(),
poDS->GetSession()->GetLastError() );
return;
}
if( !oStmt.Fetch() )
{
CPLError( CE_Warning, CPLE_AppDefined,
"SRID %d lookup failed.\n%s",
nSRID, poDS->GetSession()->GetLastError() );
return;
}
/* -------------------------------------------------------------------- */
/* Check that it isn't just a GUID. We don't know how to */
/* translate those. */
/* -------------------------------------------------------------------- */
char *pszSRText = (char *) oStmt.GetColData(0);
if( pszSRText[0] == '{' )
{
CPLDebug( "PGEO", "Ignoreing GUID SRTEXT: %s", pszSRText );
return;
}
/* -------------------------------------------------------------------- */
/* Turn it into an OGRSpatialReference. */
/* -------------------------------------------------------------------- */
poSRS = new OGRSpatialReference();
if( poSRS->importFromWkt( &pszSRText ) != OGRERR_NONE )
{
CPLError( CE_Failure, CPLE_AppDefined,
"importFromWKT() failed on SRS '%s'.",
pszSRText);
delete poSRS;
poSRS = NULL;
}
else if( poSRS->morphFromESRI() != OGRERR_NONE )
{
CPLError( CE_Failure, CPLE_AppDefined,
"morphFromESRI() failed on SRS." );
delete poSRS;
poSRS = NULL;
}
else
nSRSId = nSRID;
}
GDALDataset *EIRDataset::Open( GDALOpenInfo * poOpenInfo )
{
int i;
VSILFILE *fp;
const char * pszLine;
if( !Identify( poOpenInfo ) )
return NULL;
fp = VSIFOpenL( poOpenInfo->pszFilename, "r" );
if( fp == NULL )
return NULL;
/* header example and description
IMAGINE_RAW_FILE // must be on first line, by itself
WIDTH 581 // number of columns in the image
HEIGHT 695 // number of rows in the image
NUM_LAYERS 3 // number of spectral bands in the image; default 1
PIXEL_FILES raw8_3n_ui_sanjack.bl // raster file
// default: same name with no extension
FORMAT BIL // BIL BIP BSQ; default BIL
DATATYPE U8 // U1 U2 U4 U8 U16 U32 S16 S32 F32 F64; default U8
BYTE_ORDER // LSB MSB; required for U16 U32 S16 S32 F32 F64
DATA_OFFSET // start of image data in raster file; default 0 bytes
END_RAW_FILE // end RAW file - stop reading
For a true color image with three bands (R, G, B) stored using 8 bits
for each pixel in each band, DATA_TYPE equals U8 and NUM_LAYERS equals
3 for a total of 24 bits per pixel.
Note that the current version of ERDAS Raw Raster Reader/Writer does
not support the LAYER_SKIP_BYTES, RECORD_SKIP_BYTES, TILE_WIDTH and
TILE_HEIGHT directives. Since the reader does not read the PIXEL_FILES
directive, the reader always assumes that the raw binary file is the
dataset, and the name of this file is the name of the header without the
extension. Currently, the reader does not support multiple raw binary
files in one dataset or a single file with both the header and the raw
binary data at the same time.
*/
bool bDone = FALSE;
int nRows = -1, nCols = -1, nBands = 1;
int nSkipBytes = 0;
int nLineCount = 0;
GDALDataType eDataType = GDT_Byte;
int nBits = 8;
char chByteOrder = 'M';
char szLayout[10] = "BIL";
char **papszHDR = NULL;
// default raster file: same name with no extension
CPLString osPath = CPLGetPath( poOpenInfo->pszFilename );
CPLString osName = CPLGetBasename( poOpenInfo->pszFilename );
CPLString osRasterFilename = CPLFormCIFilename( osPath, osName, "" );
// parse the header file
while( !bDone && (pszLine = CPLReadLineL( fp )) != NULL )
{
char **papszTokens;
nLineCount++;
if ( (nLineCount == 1) && !EQUAL(pszLine,"IMAGINE_RAW_FILE") ) {
return NULL;
}
if ( (nLineCount > 50) || EQUAL(pszLine,"END_RAW_FILE") ) {
bDone = TRUE;
break;
}
if( strlen(pszLine) > 1000 )
break;
papszHDR = CSLAddString( papszHDR, pszLine );
papszTokens = CSLTokenizeStringComplex( pszLine, " \t", TRUE, FALSE );
if( CSLCount( papszTokens ) < 2 )
{
CSLDestroy( papszTokens );
continue;
}
if( EQUAL(papszTokens[0],"WIDTH") )
{
nCols = atoi(papszTokens[1]);
}
else if( EQUAL(papszTokens[0],"HEIGHT") )
{
nRows = atoi(papszTokens[1]);
}
else if( EQUAL(papszTokens[0],"NUM_LAYERS") )
{
nBands = atoi(papszTokens[1]);
}
else if( EQUAL(papszTokens[0],"PIXEL_FILES") )
{
osRasterFilename = CPLFormCIFilename( osPath, papszTokens[1], "" );
}
else if( EQUAL(papszTokens[0],"FORMAT") )
{
strncpy( szLayout, papszTokens[1], sizeof(szLayout) );
szLayout[sizeof(szLayout)-1] = '\0';
}
else if( EQUAL(papszTokens[0],"DATATYPE") )
{
if ( EQUAL(papszTokens[1], "U1")
|| EQUAL(papszTokens[1], "U2")
|| EQUAL(papszTokens[1], "U4")
|| EQUAL(papszTokens[1], "U8") ) {
nBits = 8;
eDataType = GDT_Byte;
}
else if( EQUAL(papszTokens[1], "U16") ) {
nBits = 16;
eDataType = GDT_UInt16;
}
else if( EQUAL(papszTokens[1], "U32") ) {
nBits = 32;
eDataType = GDT_UInt32;
}
else if( EQUAL(papszTokens[1], "S16") ) {
nBits = 16;
eDataType = GDT_Int16;
}
else if( EQUAL(papszTokens[1], "S32") ) {
nBits = 32;
eDataType = GDT_Int32;
}
else if( EQUAL(papszTokens[1], "F32") ) {
nBits = 32;
eDataType = GDT_Float32;
}
else if( EQUAL(papszTokens[1], "F64") ) {
nBits = 64;
eDataType = GDT_Float64;
}
else {
CPLError( CE_Failure, CPLE_NotSupported,
"EIR driver does not support DATATYPE %s.",
papszTokens[1] );
CSLDestroy( papszTokens );
CSLDestroy( papszHDR );
VSIFCloseL( fp );
return NULL;
}
}
else if( EQUAL(papszTokens[0],"BYTE_ORDER") )
{
// M for MSB, L for LSB
chByteOrder = toupper(papszTokens[1][0]);
}
else if( EQUAL(papszTokens[0],"DATA_OFFSET") )
{
nSkipBytes = atoi(papszTokens[1]); // TBD: is this mapping right?
}
CSLDestroy( papszTokens );
}
VSIFCloseL( fp );
/* -------------------------------------------------------------------- */
/* 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 )
{
CSLDestroy( papszHDR );
return NULL;
}
if (!GDALCheckDatasetDimensions(nCols, nRows) ||
!GDALCheckBandCount(nBands, FALSE))
{
CSLDestroy( papszHDR );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Confirm the requested access is supported. */
/* -------------------------------------------------------------------- */
if( poOpenInfo->eAccess == GA_Update )
{
CSLDestroy( papszHDR );
CPLError( CE_Failure, CPLE_NotSupported,
"The EIR driver does not support update access to existing"
" datasets.\n" );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Create a corresponding GDALDataset. */
/* -------------------------------------------------------------------- */
EIRDataset *poDS;
poDS = new EIRDataset();
/* -------------------------------------------------------------------- */
/* Capture some information from the file that is of interest. */
/* -------------------------------------------------------------------- */
poDS->nRasterXSize = nCols;
poDS->nRasterYSize = nRows;
poDS->papszHDR = papszHDR;
/* -------------------------------------------------------------------- */
/* Open target binary file. */
/* -------------------------------------------------------------------- */
poDS->fpImage = VSIFOpenL( osRasterFilename.c_str(), "rb" );
if( poDS->fpImage == NULL )
{
CPLError( CE_Failure, CPLE_OpenFailed,
"Failed to open %s.\n%s",
osRasterFilename.c_str(), VSIStrerror( errno ) );
delete poDS;
return NULL;
}
poDS->papszExtraFiles =
CSLAddString( poDS->papszExtraFiles,
osRasterFilename );
poDS->eAccess = poOpenInfo->eAccess;
/* -------------------------------------------------------------------- */
/* Compute the line offset. */
/* -------------------------------------------------------------------- */
int nItemSize = GDALGetDataTypeSize(eDataType)/8;
int nPixelOffset, nLineOffset;
vsi_l_offset nBandOffset;
if( EQUAL(szLayout,"BIP") )
{
nPixelOffset = nItemSize * nBands;
nLineOffset = nPixelOffset * nCols;
nBandOffset = (vsi_l_offset)nItemSize;
}
else if( EQUAL(szLayout,"BSQ") )
{
nPixelOffset = nItemSize;
nLineOffset = nPixelOffset * nCols;
nBandOffset = (vsi_l_offset)nLineOffset * nRows;
}
else /* assume BIL */
{
nPixelOffset = nItemSize;
nLineOffset = nItemSize * nBands * nCols;
nBandOffset = (vsi_l_offset)nItemSize * nCols;
}
poDS->SetDescription( poOpenInfo->pszFilename );
poDS->PamInitialize();
/* -------------------------------------------------------------------- */
/* Create band information objects. */
/* -------------------------------------------------------------------- */
poDS->nBands = nBands;
for( i = 0; i < poDS->nBands; i++ )
{
RawRasterBand *poBand;
poBand =
new RawRasterBand( poDS, i+1, poDS->fpImage,
nSkipBytes + nBandOffset * i,
nPixelOffset, nLineOffset, eDataType,
#ifdef CPL_LSB
chByteOrder == 'I' || chByteOrder == 'L',
#else
chByteOrder == 'M',
#endif
nBits);
poDS->SetBand( i+1, poBand );
}
/* -------------------------------------------------------------------- */
/* look for a worldfile */
/* -------------------------------------------------------------------- */
if( !poDS->bGotTransform )
poDS->bGotTransform =
GDALReadWorldFile( poOpenInfo->pszFilename, 0,
poDS->adfGeoTransform );
if( !poDS->bGotTransform )
poDS->bGotTransform =
GDALReadWorldFile( poOpenInfo->pszFilename, "wld",
poDS->adfGeoTransform );
/* -------------------------------------------------------------------- */
/* Initialize any PAM information. */
/* -------------------------------------------------------------------- */
poDS->TryLoadXML();
/* -------------------------------------------------------------------- */
/* Check for overviews. */
/* -------------------------------------------------------------------- */
poDS->oOvManager.Initialize( poDS, poOpenInfo->pszFilename );
return( poDS );
}
BNARecord* BNA_GetNextRecord(VSILFILE* f,
int* ok,
int* curLine,
int verbose,
BNAFeatureType interestFeatureType)
{
BNARecord* record;
char c;
int inQuotes = FALSE;
int numField = 0;
char* ptrBeginningOfNumber = NULL;
int exponentFound = 0;
int exponentSignFound = 0;
int dotFound = 0;
int numChar = 0;
const char* detailedErrorMsg = NULL;
BNAFeatureType currentFeatureType = BNA_UNKNOWN;
int nbExtraId = 0;
char tmpBuffer[NB_MAX_BNA_IDS][TMP_BUFFER_SIZE+1];
int tmpBufferLength[NB_MAX_BNA_IDS] = {0, 0, 0};
char szLineBuffer[LINE_BUFFER_SIZE + 1];
record = (BNARecord*)CPLMalloc(sizeof(BNARecord));
memset(record, 0, sizeof(BNARecord));
while (TRUE)
{
numChar = 0;
(*curLine)++;
int retGetLine = BNA_GetLine(szLineBuffer, f);
if (retGetLine == BNA_LINE_TOO_LONG)
{
detailedErrorMsg = LINE_TOO_LONG;
goto error;
}
else if (retGetLine == BNA_LINE_EOF)
{
break;
}
char* ptrCurLine = szLineBuffer;
const char* ptrBeginLine = szLineBuffer;
if (*ptrCurLine == 0)
continue;
while(1)
{
numChar = ptrCurLine - ptrBeginLine;
c = *ptrCurLine;
if (c == 0) c = 10;
if (inQuotes)
{
if (c == 10)
{
detailedErrorMsg = STRING_NOT_TERMINATED;
goto error;
}
else if (c == '"' && ptrCurLine[1] == '"')
{
if (tmpBufferLength[numField] == TMP_BUFFER_SIZE)
{
detailedErrorMsg = TOO_LONG_ID;
goto error;
}
tmpBuffer[numField][tmpBufferLength[numField]++] = c;
ptrCurLine++;
}
else if (c == '"')
{
inQuotes = FALSE;
}
else
{
if (tmpBufferLength[numField] == TMP_BUFFER_SIZE)
{
detailedErrorMsg = TOO_LONG_ID;
goto error;
}
tmpBuffer[numField][tmpBufferLength[numField]++] = c;
}
}
else if (c == ' ' || c == '\t')
{
if (numField > NB_MIN_BNA_IDS + nbExtraId && ptrBeginningOfNumber != NULL)
{
do
{
ptrCurLine++;
numChar = ptrCurLine - ptrBeginLine;
c = *ptrCurLine;
if (!(c == ' ' || c == '\t'))
break;
} while(c);
if (c == 0) c = 10;
if (interestFeatureType == BNA_READ_ALL ||
interestFeatureType == currentFeatureType)
{
char* pszComma = strchr(ptrBeginningOfNumber, ',');
if (pszComma)
*pszComma = '\0';
record->tabCoords[(numField - nbExtraId - NB_MIN_BNA_IDS - 1) / 2]
[1 - ((numField - nbExtraId) % 2)] =
CPLAtof(ptrBeginningOfNumber);
if (pszComma)
*pszComma = ',';
}
if (numField == NB_MIN_BNA_IDS + 1 + nbExtraId + 2 * record->nCoords - 1)
{
if (c != 10)
{
if (verbose)
{
CPLError(CE_Warning, CPLE_AppDefined,
"At line %d, at char %d, extra data will be ignored!\n",
*curLine, numChar+1);
}
}
*ok = 1;
return record;
}
ptrBeginningOfNumber = NULL;
exponentFound = 0;
exponentSignFound = 0;
dotFound = 0;
numField++;
if (c == 10)
break;
if (c != ',')
{
/* don't increment ptrCurLine */
continue;
}
}
else
{
/* ignore */
}
}
else if (c == 10 || c == ',')
{
/* Eat a comma placed at end of line */
if (c == ',')
{
const char* ptr = ptrCurLine+1;
while(*ptr)
{
if (*ptr != ' ' && *ptr != '\t')
break;
ptr++;
}
if (*ptr == 0)
{
c = 10;
}
}
if (numField == 0)
{
/* Maybe not so mandatory.. Atlas MapMaker(TM) exports BNA files with empty primaryID */
/*
if (record->primaryID == NULL || *(record->primaryID) == 0)
{
detailedErrorMsg = PRIMARY_ID_MANDATORY;
goto error;
}
*/
}
else if (numField == NB_MIN_BNA_IDS + nbExtraId)
{
int nCoords;
if (ptrBeginningOfNumber == NULL)
{
detailedErrorMsg = INTEGER_NUMBER_EXPECTED;
goto error;
}
nCoords = atoi(ptrBeginningOfNumber);
if (nCoords == 0 || nCoords == -1)
{
detailedErrorMsg = INVALID_GEOMETRY_TYPE;
goto error;
}
else if (nCoords == 1)
{
currentFeatureType = record->featureType = BNA_POINT;
record->nCoords = 1;
}
else if (nCoords == 2)
{
currentFeatureType = record->featureType = BNA_ELLIPSE;
record->nCoords = 2;
}
else if (nCoords > 0)
{
currentFeatureType = record->featureType = BNA_POLYGON;
record->nCoords = nCoords;
}
else
{
currentFeatureType = record->featureType = BNA_POLYLINE;
record->nCoords = -nCoords;
}
record->nIDs = NB_MIN_BNA_IDS + nbExtraId;
if (interestFeatureType == BNA_READ_ALL ||
interestFeatureType == currentFeatureType)
{
int i;
for(i=0;i<NB_MAX_BNA_IDS;i++)
{
if (tmpBufferLength[i] && tmpBuffer[i][0])
{
record->ids[i] = (char*)CPLMalloc(tmpBufferLength[i] + 1);
tmpBuffer[i][tmpBufferLength[i]] = 0;
memcpy(record->ids[i], tmpBuffer[i], tmpBufferLength[i] + 1);
}
}
record->tabCoords =
(double(*)[2])VSIMalloc(record->nCoords * 2 * sizeof(double));
if (record->tabCoords == NULL)
{
detailedErrorMsg = NOT_ENOUGH_MEMORY;
goto error;
}
}
}
else if (numField > NB_MIN_BNA_IDS + nbExtraId)
{
if (ptrBeginningOfNumber == NULL)
{
detailedErrorMsg = FLOAT_NUMBER_EXPECTED;
goto error;
}
if (interestFeatureType == BNA_READ_ALL ||
interestFeatureType == currentFeatureType)
{
char* pszComma = strchr(ptrBeginningOfNumber, ',');
if (pszComma)
*pszComma = '\0';
record->tabCoords[(numField - nbExtraId - NB_MIN_BNA_IDS - 1) / 2]
[1 - ((numField - nbExtraId) % 2)] =
CPLAtof(ptrBeginningOfNumber);
if (pszComma)
*pszComma = ',';
}
if (numField == NB_MIN_BNA_IDS + 1 + nbExtraId + 2 * record->nCoords - 1)
{
if (c != 10)
{
if (verbose)
{
CPLError(CE_Warning, CPLE_AppDefined,
"At line %d, at char %d, extra data will be ignored!\n",
*curLine, numChar+1);
}
}
*ok = 1;
return record;
}
}
ptrBeginningOfNumber = NULL;
exponentFound = 0;
exponentSignFound = 0;
dotFound = 0;
numField++;
if (c == 10)
break;
}
else if (c == '"')
{
if (numField < NB_MIN_BNA_IDS)
{
inQuotes = TRUE;
}
else if (numField >= NB_MIN_BNA_IDS && currentFeatureType == BNA_UNKNOWN)
{
if (ptrBeginningOfNumber == NULL)
{
if (nbExtraId == NB_MAX_BNA_IDS - NB_MIN_BNA_IDS)
{
detailedErrorMsg = MAX_BNA_IDS_REACHED;
goto error;
}
nbExtraId ++;
inQuotes = TRUE;
}
else
{
detailedErrorMsg = BAD_INTEGER_NUMBER_FORMAT;
goto error;
}
}
else
{
detailedErrorMsg = NUMBER_EXPECTED;
goto error;
}
}
else
{
if (numField < NB_MIN_BNA_IDS || (numField == NB_MIN_BNA_IDS + nbExtraId - 1))
{
detailedErrorMsg = STRING_EXPECTED;
goto error;
}
else if (numField == NB_MIN_BNA_IDS + nbExtraId)
{
if (c >= '0' && c <= '9')
{
}
else if (c == '+' || c == '-')
{
if (ptrBeginningOfNumber != NULL)
{
detailedErrorMsg = BAD_INTEGER_NUMBER_FORMAT;
goto error;
}
}
else
{
detailedErrorMsg = BAD_INTEGER_NUMBER_FORMAT;
goto error;
}
if (ptrBeginningOfNumber == NULL)
ptrBeginningOfNumber = ptrCurLine;
}
else
{
if (c >= '0' && c <= '9')
{
}
else if (c == '.')
{
if (dotFound || exponentFound)
{
detailedErrorMsg = BAD_FLOAT_NUMBER_FORMAT;
goto error;
}
dotFound = 1;
}
else if (c == '+' || c == '-')
{
if (ptrBeginningOfNumber == NULL)
{
}
else if (exponentFound)
{
if (exponentSignFound == 0 && ptrCurLine > ptrBeginLine &&
(ptrCurLine[-1] == 'e' || ptrCurLine[-1] == 'E' ||
ptrCurLine[-1] == 'd' || ptrCurLine[-1] == 'D'))
{
exponentSignFound = 1;
}
else
{
detailedErrorMsg = BAD_FLOAT_NUMBER_FORMAT;
goto error;
}
}
else
{
detailedErrorMsg = BAD_FLOAT_NUMBER_FORMAT;
goto error;
}
}
else if (c == 'e' || c == 'E' || c == 'd' || c == 'D')
{
if (ptrBeginningOfNumber == NULL ||
!(ptrCurLine[-1] >= '0' && ptrCurLine[-1] <= '9') ||
exponentFound == 1)
{
detailedErrorMsg = BAD_FLOAT_NUMBER_FORMAT;
goto error;
}
exponentFound = 1;
}
else
{
detailedErrorMsg = BAD_FLOAT_NUMBER_FORMAT;
goto error;
}
if (ptrBeginningOfNumber == NULL)
ptrBeginningOfNumber = ptrCurLine;
}
}
ptrCurLine++;
}
}
if (numField == 0)
{
/* End of file */
*ok = 1;
BNA_FreeRecord(record);
return NULL;
}
else
{
detailedErrorMsg = MISSING_FIELDS;
goto error;
}
error:
if (verbose)
{
if (detailedErrorMsg)
{
CPLError(CE_Failure, CPLE_AppDefined,
"Parsing failed at line %d, at char %d : %s!\n",
*curLine, numChar+1, detailedErrorMsg);
}
else
{
CPLError(CE_Failure, CPLE_AppDefined,
"Parsing failed at line %d, at char %d!\n",
*curLine, numChar+1);
}
}
BNA_FreeRecord(record);
return NULL;
}
int DDFFieldDefn::ApplyFormats()
{
char *pszFormatList;
char **papszFormatItems;
/* -------------------------------------------------------------------- */
/* Verify that the format string is contained within brackets. */
/* -------------------------------------------------------------------- */
if( strlen(_formatControls) < 2
|| _formatControls[0] != '('
|| _formatControls[strlen(_formatControls)-1] != ')' )
{
CPLError( CE_Warning, (CPLErrorNum)CPLE_DiscardedFormat,
"Format controls for `%s' field missing brackets:%s",
pszTag, _formatControls );
return FALSE;
}
/* -------------------------------------------------------------------- */
/* Duplicate the string, and strip off the brackets. */
/* -------------------------------------------------------------------- */
pszFormatList = ExpandFormat( _formatControls );
/* -------------------------------------------------------------------- */
/* Tokenize based on commas. */
/* -------------------------------------------------------------------- */
papszFormatItems =
CSLTokenizeStringComplex(pszFormatList, ",", FALSE, FALSE );
CPLFree( pszFormatList );
/* -------------------------------------------------------------------- */
/* Apply the format items to subfields. */
/* -------------------------------------------------------------------- */
int iFormatItem;
for( iFormatItem = 0;
papszFormatItems[iFormatItem] != NULL;
iFormatItem++ )
{
const char *pszPastPrefix;
pszPastPrefix = papszFormatItems[iFormatItem];
while( *pszPastPrefix >= '0' && *pszPastPrefix <= '9' )
pszPastPrefix++;
///////////////////////////////////////////////////////////////
// Did we get too many formats for the subfields created
// by names? This may be legal by the 8211 specification, but
// isn't encountered in any formats we care about so we just
// blow.
if( iFormatItem >= nSubfieldCount )
{
CPLError( CE_Warning, (CPLErrorNum)CPLE_DiscardedFormat,
"Got more formats than subfields for field `%s'.",
pszTag );
break;
}
if( !papoSubfields[iFormatItem]->SetFormat(pszPastPrefix) )
{
CSLDestroy( papszFormatItems );
return FALSE;
}
}
/* -------------------------------------------------------------------- */
/* Verify that we got enough formats, cleanup and return. */
/* -------------------------------------------------------------------- */
CSLDestroy( papszFormatItems );
if( iFormatItem < nSubfieldCount )
{
CPLError( CE_Warning, (CPLErrorNum)CPLE_DiscardedFormat,
"Got less formats than subfields for field `%s'.",
pszTag );
return FALSE;
}
/* -------------------------------------------------------------------- */
/* If all the fields are fixed width, then we are fixed width */
/* too. This is important for repeating fields. */
/* -------------------------------------------------------------------- */
nFixedWidth = 0;
for( int i = 0; i < nSubfieldCount; i++ )
{
if( papoSubfields[i]->GetWidth() == 0 )
{
nFixedWidth = 0;
break;
}
else
nFixedWidth += papoSubfields[i]->GetWidth();
}
return TRUE;
}
int ods_formula_node::EvaluateIF(IODSCellEvaluator* poEvaluator)
{
CPLAssert( eNodeType == SNT_OPERATION );
CPLAssert( eOp == ODS_IF );
CPLAssert(nSubExprCount == 2 || nSubExprCount == 3);
if (!(papoSubExpr[0]->Evaluate(poEvaluator)))
return FALSE;
if (!(papoSubExpr[1]->Evaluate(poEvaluator)))
return FALSE;
if (nSubExprCount == 3 && !(papoSubExpr[2]->Evaluate(poEvaluator)))
return FALSE;
CPLAssert(papoSubExpr[0]->eNodeType == SNT_CONSTANT );
CPLAssert(papoSubExpr[1]->eNodeType == SNT_CONSTANT );
if (nSubExprCount == 3)
{
CPLAssert(papoSubExpr[2]->eNodeType == SNT_CONSTANT );
}
int bCond = FALSE;
if (papoSubExpr[0]->field_type == ODS_FIELD_TYPE_INTEGER)
{
bCond = (papoSubExpr[0]->int_value != 0);
}
else if (papoSubExpr[0]->field_type == ODS_FIELD_TYPE_FLOAT)
{
bCond = (papoSubExpr[0]->float_value != 0);
}
else
{
CPLError(CE_Failure, CPLE_NotSupported,
"Bad argument type for %s", ODSGetOperatorName(eOp));
return FALSE;
}
if (bCond)
{
eNodeType = SNT_CONSTANT;
field_type = papoSubExpr[1]->field_type;
if (field_type == ODS_FIELD_TYPE_INTEGER)
int_value = papoSubExpr[1]->int_value;
else if (field_type == ODS_FIELD_TYPE_FLOAT)
float_value = papoSubExpr[1]->float_value;
else if (field_type == ODS_FIELD_TYPE_STRING)
{
string_value = papoSubExpr[1]->string_value;
papoSubExpr[1]->string_value = NULL;
}
}
else if (nSubExprCount == 3)
{
eNodeType = SNT_CONSTANT;
field_type = papoSubExpr[2]->field_type;
if (field_type == ODS_FIELD_TYPE_INTEGER)
int_value = papoSubExpr[2]->int_value;
else if (field_type == ODS_FIELD_TYPE_FLOAT)
float_value = papoSubExpr[2]->float_value;
else if (field_type == ODS_FIELD_TYPE_STRING)
{
string_value = papoSubExpr[2]->string_value;
papoSubExpr[2]->string_value = NULL;
}
}
else
{
eNodeType = SNT_CONSTANT;
field_type = ODS_FIELD_TYPE_INTEGER;
int_value = FALSE;
}
FreeSubExpr();
return TRUE;
}
// Copies GDAL Band to KEA Band if nOverview == -1
// Otherwise it is assumed we are writing to the specified overview
static
bool KEACopyRasterData( GDALRasterBand *pBand, kealib::KEAImageIO *pImageIO, int nBand, int nOverview, int nTotalBands, GDALProgressFunc pfnProgress, void *pProgressData)
{
// get some info
kealib::KEADataType eKeaType = pImageIO->getImageBandDataType(nBand);
unsigned int nBlockSize;
if( nOverview == -1 )
nBlockSize = pImageIO->getImageBlockSize( nBand );
else
nBlockSize = pImageIO->getOverviewBlockSize(nBand, nOverview);
GDALDataType eGDALType = pBand->GetRasterDataType();
unsigned int nXSize = pBand->GetXSize();
unsigned int nYSize = pBand->GetYSize();
// allocate some space
int nPixelSize = GDALGetDataTypeSize( eGDALType ) / 8;
void *pData = VSIMalloc3( nPixelSize, nBlockSize, nBlockSize);
if( pData == NULL )
{
CPLError( CE_Failure, CPLE_AppDefined, "Unable to allocate memory" );
return false;
}
// for progress
int nTotalBlocks = static_cast<int>(std::ceil( (double)nXSize / (double)nBlockSize ) * std::ceil( (double)nYSize / (double)nBlockSize ));
int nBlocksComplete = 0;
double dLastFraction = -1;
// go through the image
for( unsigned int nY = 0; nY < nYSize; nY += nBlockSize )
{
// adjust for edge blocks
unsigned int nysize = nBlockSize;
unsigned int nytotalsize = nY + nBlockSize;
if( nytotalsize > nYSize )
nysize -= (nytotalsize - nYSize);
for( unsigned int nX = 0; nX < nXSize; nX += nBlockSize )
{
// adjust for edge blocks
unsigned int nxsize = nBlockSize;
unsigned int nxtotalsize = nX + nBlockSize;
if( nxtotalsize > nXSize )
nxsize -= (nxtotalsize - nXSize);
// read in from GDAL
if( pBand->RasterIO( GF_Read, nX, nY, nxsize, nysize, pData,
nxsize, nysize, eGDALType, nPixelSize,
nPixelSize * nBlockSize, NULL) != CE_None )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Unable to read block at %d %d\n", nX, nY );
return false;
}
// write out to KEA
if( nOverview == -1 )
pImageIO->writeImageBlock2Band( nBand, pData, nX, nY, nxsize, nysize, nBlockSize, nBlockSize, eKeaType);
else
pImageIO->writeToOverview( nBand, nOverview, pData, nX, nY, nxsize, nysize, nBlockSize, nBlockSize, eKeaType);
// progress
nBlocksComplete++;
if( nOverview == -1 )
{
double dFraction = (((double)nBlocksComplete / (double)nTotalBlocks) / (double)nTotalBands) + ((double)(nBand-1) * (1.0 / (double)nTotalBands));
if( dFraction != dLastFraction )
{
if( !pfnProgress( dFraction, NULL, pProgressData ) )
{
CPLFree( pData );
return false;
}
dLastFraction = dFraction;
}
}
}
}
CPLFree( pData );
return true;
}
int ods_formula_node::EvaluateGT(IODSCellEvaluator* poEvaluator)
{
CPLAssert( eNodeType == SNT_OPERATION );
CPLAssert( eOp == ODS_GT );
CPLAssert(nSubExprCount == 2);
if (!(papoSubExpr[0]->Evaluate(poEvaluator)))
return FALSE;
if (!(papoSubExpr[1]->Evaluate(poEvaluator)))
return FALSE;
CPLAssert(papoSubExpr[0]->eNodeType == SNT_CONSTANT );
CPLAssert(papoSubExpr[1]->eNodeType == SNT_CONSTANT );
int bVal = FALSE;
if (papoSubExpr[0]->field_type == ODS_FIELD_TYPE_INTEGER)
{
if (papoSubExpr[1]->field_type == ODS_FIELD_TYPE_INTEGER)
{
bVal = (papoSubExpr[0]->int_value > papoSubExpr[1]->int_value);
}
else if (papoSubExpr[1]->field_type == ODS_FIELD_TYPE_FLOAT)
{
bVal = (papoSubExpr[0]->int_value > papoSubExpr[1]->float_value);
}
}
else if (papoSubExpr[0]->field_type == ODS_FIELD_TYPE_FLOAT)
{
if (papoSubExpr[1]->field_type == ODS_FIELD_TYPE_INTEGER)
{
bVal = (papoSubExpr[0]->float_value > papoSubExpr[1]->int_value);
}
else if (papoSubExpr[1]->field_type == ODS_FIELD_TYPE_FLOAT)
{
bVal = (papoSubExpr[0]->float_value > papoSubExpr[1]->float_value);
}
}
else if (papoSubExpr[0]->field_type == ODS_FIELD_TYPE_STRING)
{
if (papoSubExpr[1]->field_type == ODS_FIELD_TYPE_STRING)
{
if (GetCase(papoSubExpr[0]->string_value) ==
GetCase(papoSubExpr[1]->string_value))
bVal = (strcmp(papoSubExpr[0]->string_value,
papoSubExpr[1]->string_value) > 0);
else
bVal = (strcasecmp(papoSubExpr[0]->string_value,
papoSubExpr[1]->string_value) > 0);
}
else
bVal = TRUE;
}
else
{
CPLError(CE_Failure, CPLE_NotSupported,
"Bad argument type for %s", ODSGetOperatorName(eOp));
return FALSE;
}
eNodeType = SNT_CONSTANT;
field_type = ODS_FIELD_TYPE_INTEGER;
int_value = bVal;
FreeSubExpr();
return TRUE;
}
CPLErr PrintSRS( const OGRSpatialReference &oSRS,
const char * pszOutputType,
bool bPretty, bool bPrintSep )
{
if ( ! pszOutputType || EQUAL(pszOutputType,""))
return CE_None;
CPLDebug( "gdalsrsinfo", "PrintSRS( oSRS, %s, %d, %d )\n",
pszOutputType, static_cast<int>(bPretty),
static_cast<int>(bPrintSep) );
char *pszOutput = NULL;
if ( EQUAL("proj4", pszOutputType ) ) {
if ( bPrintSep ) printf( "PROJ.4 : ");
oSRS.exportToProj4( &pszOutput );
printf( "\'%s\'\n", pszOutput );
}
else if ( EQUAL("wkt", pszOutputType ) ) {
if ( bPrintSep ) printf("OGC WKT :\n");
if ( bPretty )
oSRS.exportToPrettyWkt( &pszOutput, FALSE );
else
oSRS.exportToWkt( &pszOutput );
printf("%s\n",pszOutput);
}
else if ( EQUAL("wkt_simple", pszOutputType ) ) {
if ( bPrintSep ) printf("OGC WKT (simple) :\n");
oSRS.exportToPrettyWkt( &pszOutput, TRUE );
printf("%s\n",pszOutput);
}
else if ( EQUAL("wkt_noct", pszOutputType ) ) {
if ( bPrintSep ) printf("OGC WKT (no CT) :\n");
OGRSpatialReference *poSRS = oSRS.Clone();
poSRS->StripCTParms( );
if ( bPretty )
poSRS->exportToPrettyWkt( &pszOutput, FALSE );
else
poSRS->exportToWkt( &pszOutput );
OGRSpatialReference::DestroySpatialReference( poSRS );
printf("%s\n",pszOutput);
}
else if ( EQUAL("wkt_esri", pszOutputType ) ) {
if ( bPrintSep ) printf("ESRI WKT :\n");
OGRSpatialReference *poSRS = oSRS.Clone();
poSRS->morphToESRI( );
if ( bPretty )
poSRS->exportToPrettyWkt( &pszOutput, FALSE );
else
poSRS->exportToWkt( &pszOutput );
OGRSpatialReference::DestroySpatialReference( poSRS );
printf("%s\n",pszOutput);
}
else if ( EQUAL("mapinfo", pszOutputType ) ) {
if ( bPrintSep ) printf("MAPINFO : ");
oSRS.exportToMICoordSys( &pszOutput );
printf("\'%s\'\n",pszOutput);
}
else if ( EQUAL("xml", pszOutputType ) ) {
if ( bPrintSep ) printf("XML :\n");
oSRS.exportToXML( &pszOutput, NULL );
printf("%s\n",pszOutput);
}
else {
CPLError( CE_Failure, CPLE_AppDefined,
"ERROR - %s output not supported",
pszOutputType );
return CE_Failure;
}
CPLFree( pszOutput );
return CE_None;
}
bool TerragenDataset::write_header()
{
char szHeader[16];
memcpy(szHeader, "TERRAGENTERRAIN ", sizeof(szHeader));
if(1 != VSIFWriteL( (void *) szHeader, sizeof(szHeader), 1, m_fp ))
{
CPLError( CE_Failure, CPLE_FileIO,
"Couldn't write to Terragen file %s.\n"
"Is file system full?",
m_pszFilename );
VSIFCloseL( m_fp );
return false;
}
// --------------------------------------------------------------------
// Write out the heightfield dimensions, etc.
// --------------------------------------------------------------------
const int nXSize = this->GetRasterXSize();
const int nYSize = this->GetRasterYSize();
this->write_next_tag("SIZE");
this->put((GInt16)(min(nXSize, nYSize)-1));
this->pad(sizeof(GInt16));
if(nXSize != nYSize)
{
this->write_next_tag("XPTS");
this->put((GInt16)nXSize); this->pad(sizeof(GInt16));
this->write_next_tag("YPTS");
this->put((GInt16)nYSize); this->pad(sizeof(GInt16));
}
if(m_bIsGeo)
{
/*
With a geographic projection (degrees),
m_dGroundScale will be in degrees and
m_dMetersPerGroundUnit is undefined.
So we're going to estimate a m_dMetersPerGroundUnit
value here (i.e., meters per degree).
We figure out the degree size of one
pixel, and then the latitude degrees
of the heightfield's center. The circumference of
the latitude's great circle lets us know how
wide the pixel is in meters, and we
average that with the pixel's meter breadth,
which is based on the polar circumference.
*/
/*const double m_dDegLongPerPixel =
fabs(m_adfTransform[1]);*/
const double m_dDegLatPerPixel =
fabs(m_adfTransform[5]);
/*const double m_dCenterLongitude =
m_adfTransform[0] +
(0.5 * m_dDegLongPerPixel * (nXSize-1));*/
const double m_dCenterLatitude =
m_adfTransform[3] +
(0.5 * m_dDegLatPerPixel * (nYSize-1));
const double dLatCircum = kdEarthCircumEquat
* sin(degrees_to_radians(90.0 - m_dCenterLatitude));
const double dMetersPerDegLongitude = dLatCircum / 360;
/*const double dMetersPerPixelX =
(m_dDegLongPerPixel / 360) * dLatCircum;*/
const double dMetersPerDegLatitude =
kdEarthCircumPolar / 360;
/*const double dMetersPerPixelY =
(m_dDegLatPerPixel / 360) * kdEarthCircumPolar;*/
m_dMetersPerGroundUnit =
average(dMetersPerDegLongitude, dMetersPerDegLatitude);
}
m_dSCAL = m_dGroundScale * m_dMetersPerGroundUnit;
if(m_dSCAL != 30.0)
{
const float sc = (float)m_dSCAL;
this->write_next_tag("SCAL");
this->put(sc);
this->put(sc);
this->put(sc);
}
if(!this->write_next_tag("ALTW"))
{
CPLError( CE_Failure, CPLE_FileIO,
"Couldn't write to Terragen file %s.\n"
"Is file system full?",
m_pszFilename );
VSIFCloseL( m_fp );
return false;
}
// Compute physical scales and offsets.
m_span_m[0] = m_dLogSpan[0] * m_dMetersPerElevUnit;
m_span_m[1] = m_dLogSpan[1] * m_dMetersPerElevUnit;
m_span_px[0] = m_span_m[0] / m_dSCAL;
m_span_px[1] = m_span_m[1] / m_dSCAL;
const double span_px = m_span_px[1] - m_span_px[0];
m_nHeightScale = (GInt16)span_px;
if(m_nHeightScale == 0)
m_nHeightScale++;
#define P2L_PX(n, hs, bh) \
((double)(n) / 65536.0 * (hs) + (bh))
#define L2P_PX(n, hs, bh) \
((int)(((n)-(bh)) * 65536.0 / (hs)))
// Increase the heightscale until the physical span
// fits within a 16-bit range. The smaller the logical span,
// the more necessary this becomes.
int hs, bh=0;
for(hs = m_nHeightScale; hs <= 32767; hs++)
{
double prevdelta = 1.0e30;
for(bh = -32768; bh <= 32767; bh++)
{
int nValley = L2P_PX(m_span_px[0], hs, bh);
if(nValley < -32768) continue;
int nPeak = L2P_PX(m_span_px[1], hs, bh);
if(nPeak > 32767) continue;
// now see how closely the baseheight gets
// to the pixel span.
double d = P2L_PX(nValley, hs, bh);
double delta = fabs(d - m_span_px[0]);
if(delta < prevdelta) // Converging?
prevdelta = delta;
else
{
// We're diverging, so use the previous bh
// and stop looking.
bh--;
break;
}
}
if(bh != 32768) break;
}
if(hs == 32768)
{
CPLError( CE_Failure, CPLE_FileIO,
"Couldn't write to Terragen file %s.\n"
"Cannot find adequate heightscale/baseheight combination.",
m_pszFilename );
VSIFCloseL( m_fp );
return false;
}
m_nHeightScale = (GInt16) hs;
m_nBaseHeight = (GInt16) bh;
// m_nHeightScale is the one that gives us the
// widest use of the 16-bit space. However, there
// might be larger heightscales that, even though
// the reduce the space usage, give us a better fit
// for preserving the span extents.
return (this->put(m_nHeightScale) &&
this->put(m_nBaseHeight));
}
int main( int argc, char ** argv )
{
bool bGotSRS = false;
bool bPretty = false;
bool bValidate = false;
bool bFindEPSG = false;
int nEPSGCode = -1;
const char *pszInput = NULL;
const char *pszOutputType = "default";
OGRSpatialReference oSRS;
/* Check strict compilation and runtime library version as we use C++ API */
if (! GDAL_CHECK_VERSION(argv[0]))
exit(1);
EarlySetConfigOptions(argc, argv);
/* -------------------------------------------------------------------- */
/* Register standard GDAL and OGR drivers. */
/* -------------------------------------------------------------------- */
GDALAllRegister();
/* -------------------------------------------------------------------- */
/* Register standard GDAL drivers, and process generic GDAL */
/* command options. */
/* -------------------------------------------------------------------- */
argc = GDALGeneralCmdLineProcessor( argc, &argv, 0 );
if( argc < 1 )
exit( -argc );
/* -------------------------------------------------------------------- */
/* Parse arguments. */
/* -------------------------------------------------------------------- */
for( int i = 1; i < argc; i++ )
{
CPLDebug( "gdalsrsinfo", "got arg #%d : [%s]", i, argv[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"));
CSLDestroy( argv );
return 0;
}
else if( EQUAL(argv[i], "-h") || EQUAL(argv[i], "--help") )
Usage();
else if( EQUAL(argv[i], "-e") )
bFindEPSG = true;
else if( EQUAL(argv[i], "-o") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
pszOutputType = argv[++i];
}
else if( EQUAL(argv[i], "-p") )
bPretty = true;
else if( EQUAL(argv[i], "-V") )
bValidate = true;
else if( argv[i][0] == '-' )
{
Usage(CPLSPrintf("Unknown option name '%s'", argv[i]));
}
else
pszInput = argv[i];
}
if ( pszInput == NULL ) {
CSLDestroy( argv );
Usage("No input specified.");
}
/* Search for SRS */
/* coverity[tainted_data] */
bGotSRS = FindSRS( pszInput, oSRS ) == TRUE;
CPLDebug( "gdalsrsinfo",
"bGotSRS: %d bValidate: %d pszOutputType: %s bPretty: %d",
static_cast<int>(bGotSRS),
static_cast<int>(bValidate),
pszOutputType,
static_cast<int>(bPretty) );
/* Make sure we got a SRS */
if ( ! bGotSRS ) {
CPLError( CE_Failure, CPLE_AppDefined,
"ERROR - failed to load SRS definition from %s",
pszInput );
}
else {
/* Find EPSG code - experimental */
if ( EQUAL(pszOutputType,"epsg") )
bFindEPSG = true;
if ( bFindEPSG ) {
CPLError( CE_Warning, CPLE_AppDefined,
"EPSG detection is experimental and requires new data files (see bug #4345)" );
nEPSGCode = FindEPSG( oSRS );
/* If found, replace oSRS based on EPSG code */
if(nEPSGCode != -1) {
CPLDebug( "gdalsrsinfo",
"Found EPSG code %d", nEPSGCode );
OGRSpatialReference oSRS2;
if ( oSRS2.importFromEPSG( nEPSGCode ) == OGRERR_NONE )
oSRS = oSRS2;
}
}
/* Validate - not well tested!*/
if ( bValidate ) {
OGRErr eErr = oSRS.Validate( );
if ( eErr != OGRERR_NONE ) {
printf( "\nValidate Fails" );
if ( eErr == OGRERR_CORRUPT_DATA )
printf( " - SRS is not well formed");
else if ( eErr == OGRERR_UNSUPPORTED_SRS )
printf(" - contains non-standard PROJECTION[] values");
printf("\n");
}
else
printf( "\nValidate Succeeds\n" );
}
/* Output */
if ( EQUAL("default", pszOutputType ) ) {
/* does this work in MSVC? */
const char* papszOutputTypes[] =
{ "proj4", "wkt", NULL };
if ( bFindEPSG )
printf("\nEPSG:%d\n",nEPSGCode);
PrintSRSOutputTypes( oSRS, papszOutputTypes );
}
else if ( EQUAL("all", pszOutputType ) ) {
if ( bFindEPSG )
printf("\nEPSG:%d\n\n",nEPSGCode);
const char* papszOutputTypes[] =
{"proj4","wkt","wkt_simple","wkt_noct","wkt_esri","mapinfo","xml",NULL};
PrintSRSOutputTypes( oSRS, papszOutputTypes );
}
else if ( EQUAL("wkt_all", pszOutputType ) ) {
const char* papszOutputTypes[] =
{ "wkt", "wkt_simple", "wkt_noct", "wkt_esri", NULL };
PrintSRSOutputTypes( oSRS, papszOutputTypes );
}
else {
if ( bPretty )
printf( "\n" );
if ( EQUAL(pszOutputType,"epsg") )
printf("EPSG:%d\n",nEPSGCode);
else
PrintSRS( oSRS, pszOutputType, bPretty, FALSE );
if ( bPretty )
printf( "\n" );
}
}
/* cleanup anything left */
GDALDestroyDriverManager();
OGRCleanupAll();
CSLDestroy( argv );
return 0;
}
OGRDataSource *OGRCSVDriver::CreateDataSource( const char * pszName,
char **papszOptions )
{
/* -------------------------------------------------------------------- */
/* First, ensure there isn't any such file yet. */
/* -------------------------------------------------------------------- */
VSIStatBufL sStatBuf;
if( VSIStatL( pszName, &sStatBuf ) == 0 )
{
CPLError( CE_Failure, CPLE_AppDefined,
"It seems a file system object called '%s' already exists.",
pszName );
return NULL;
}
/* -------------------------------------------------------------------- */
/* If the target is not a simple .csv then create it as a */
/* directory. */
/* -------------------------------------------------------------------- */
CPLString osDirName;
if( EQUAL(CPLGetExtension(pszName),"csv") )
{
osDirName = CPLGetPath(pszName);
if( osDirName == "" )
osDirName = ".";
}
else
{
if( strncmp(pszName, "/vsizip/", 8) == 0)
{
/* do nothing */
}
else if( !EQUAL(pszName, "/vsistdout/") &&
VSIMkdir( pszName, 0755 ) != 0 )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Failed to create directory %s:\n%s",
pszName, VSIStrerror( errno ) );
return NULL;
}
osDirName = pszName;
}
/* -------------------------------------------------------------------- */
/* Force it to open as a datasource. */
/* -------------------------------------------------------------------- */
OGRCSVDataSource *poDS = new OGRCSVDataSource();
if( !poDS->Open( osDirName, TRUE, TRUE ) )
{
delete poDS;
return NULL;
}
if( osDirName != pszName )
poDS->SetDefaultCSVName( CPLGetFilename(pszName) );
return poDS;
}
/*****************************************************
* \brief Read a natural block of raster band data
*****************************************************/
CPLErr PostGISRasterTileRasterBand::IReadBlock(CPL_UNUSED int nBlockXOff,
CPL_UNUSED int nBlockYOff,
void * pImage)
{
CPLString osCommand;
PGresult * poResult = NULL;
int nWKBLength = 0;
int nPixelSize = GDALGetDataTypeSize(eDataType)/8;
PostGISRasterTileDataset * poRTDS =
(PostGISRasterTileDataset *)poDS;
// Get by PKID
if (poRTDS->poRDS->pszPrimaryKeyName) {
//osCommand.Printf("select ST_AsBinary(st_band(%s, %d),TRUE) from %s.%s where "
osCommand.Printf("select st_band(%s, %d) from %s.%s where "
"%s = '%s'", poRTDS->poRDS->pszColumn, nBand, poRTDS->poRDS->pszSchema, poRTDS->poRDS->pszTable,
poRTDS->poRDS->pszPrimaryKeyName, poRTDS->pszPKID);
}
// Get by upperleft
else {
osCommand.Printf("select st_band(%s, %d) from %s.%s where "
"abs(ST_UpperLeftX(%s) - %.8f) < 1e-8 and abs(ST_UpperLeftY(%s) - %.8f) < 1e-8",
poRTDS->poRDS->pszColumn, nBand, poRTDS->poRDS->pszSchema, poRTDS->poRDS->pszTable, poRTDS->poRDS->pszColumn,
poRTDS->adfGeoTransform[GEOTRSFRM_TOPLEFT_X], poRTDS->poRDS->pszColumn,
poRTDS->adfGeoTransform[GEOTRSFRM_TOPLEFT_Y]);
}
poResult = PQexec(poRTDS->poRDS->poConn, osCommand.c_str());
#ifdef DEBUG_QUERY
CPLDebug("PostGIS_Raster", "PostGISRasterTileRasterBand::IReadBlock(): "
"Query = \"%s\" --> number of rows = %d",
osCommand.c_str(), poResult ? PQntuples(poResult) : 0 );
#endif
if (poResult == NULL ||
PQresultStatus(poResult) != PGRES_TUPLES_OK ||
PQntuples(poResult) <= 0) {
if (poResult)
PQclear(poResult);
ReportError(CE_Failure, CPLE_AppDefined,
"Error getting block of data (upperpixel = %f, %f)",
poRTDS->adfGeoTransform[GEOTRSFRM_TOPLEFT_X],
poRTDS->adfGeoTransform[GEOTRSFRM_TOPLEFT_Y]);
return CE_Failure;
}
// TODO: Check this
if (bIsOffline) {
CPLError(CE_Failure, CPLE_AppDefined, "This raster has outdb "
"storage. This feature isn't still available");
PQclear(poResult);
return CE_Failure;
}
/* Copy only data size, without payload */
int nExpectedDataSize =
nBlockXSize * nBlockYSize * nPixelSize;
GByte * pbyData = CPLHexToBinary(PQgetvalue(poResult, 0, 0),
&nWKBLength);
int nExpectedWKBLength = RASTER_HEADER_SIZE + BAND_SIZE(nPixelSize, nExpectedDataSize);
CPLErr eRet = CE_None;
if( nWKBLength != nExpectedWKBLength )
{
CPLDebug("PostGIS_Raster", "nWKBLength=%d, nExpectedWKBLength=%d", nWKBLength, nExpectedWKBLength );
eRet = CE_Failure;
}
else
{
GByte * pbyDataToRead =
(GByte*)GET_BAND_DATA(pbyData,1, nPixelSize,
nExpectedDataSize);
// Do byte-swapping if necessary */
int bIsLittleEndian = (pbyData[0] == 1);
#ifdef CPL_LSB
int bSwap = !bIsLittleEndian;
#else
int bSwap = bIsLittleEndian;
#endif
if( bSwap && nPixelSize > 1 )
{
GDALSwapWords( pbyDataToRead, nPixelSize,
nBlockXSize * nBlockYSize,
nPixelSize );
}
memcpy(pImage, pbyDataToRead, nExpectedDataSize);
}
CPLFree(pbyData);
PQclear(poResult);
return eRet;
}
GTMTrackLayer::GTMTrackLayer( const char* pszName,
OGRSpatialReference* poSRSIn,
CPL_UNUSED int bWriterIn,
OGRGTMDataSource* poDSIn )
{
poCT = NULL;
/* We are implementing just WGS84, although GTM supports other datum
formats. */
if( poSRSIn != NULL )
{
poSRS = new OGRSpatialReference(NULL);
poSRS->SetWellKnownGeogCS( "WGS84" );
if (!poSRS->IsSame(poSRSIn))
{
poCT = OGRCreateCoordinateTransformation( poSRSIn, poSRS );
if( poCT == NULL && poDSIn->isFirstCTError() )
{
/* If we can't create a transformation, issue a warning - but
continue the transformation*/
char *pszWKT = NULL;
poSRSIn->exportToPrettyWkt( &pszWKT, FALSE );
CPLError( CE_Warning, CPLE_AppDefined,
"Failed to create coordinate transformation between the\n"
"input coordinate system and WGS84. This may be because they\n"
"are not transformable, or because projection services\n"
"(PROJ.4 DLL/.so) could not be loaded.\n"
"This message will not be issued any more. \n"
"\nSource:\n%s\n",
pszWKT );
CPLFree( pszWKT );
poDSIn->issuedFirstCTError();
}
}
}
else
{
poSRS = NULL;
}
poDS = poDSIn;
nNextFID = 0;
nTotalFCount = poDS->getNTracks();
poFeatureDefn = new OGRFeatureDefn( pszName );
SetDescription( poFeatureDefn->GetName() );
poFeatureDefn->Reference();
poFeatureDefn->SetGeomType ( wkbLineString );
poFeatureDefn->GetGeomFieldDefn(0)->SetSpatialRef(poSRS);
/* We implement just name, type, and color for tracks, if others
needed feel free to append more parameters and implement the
code */
OGRFieldDefn oFieldName( "name", OFTString );
poFeatureDefn->AddFieldDefn( &oFieldName );
OGRFieldDefn oFieldTrackType( "type", OFTInteger );
poFeatureDefn->AddFieldDefn( &oFieldTrackType );
OGRFieldDefn oFieldColor( "color", OFTInteger );
poFeatureDefn->AddFieldDefn( &oFieldColor );
this->pszName = CPLStrdup(pszName);
}
int ods_formula_node::EvaluateBinaryArithmetic(IODSCellEvaluator* poEvaluator)
{
CPLAssert( eNodeType == SNT_OPERATION );
CPLAssert( eOp >= ODS_ADD && eOp<= ODS_MODULUS );
CPLAssert(nSubExprCount == 2);
if (!(papoSubExpr[0]->Evaluate(poEvaluator)))
return FALSE;
if (!(papoSubExpr[1]->Evaluate(poEvaluator)))
return FALSE;
CPLAssert(papoSubExpr[0]->eNodeType == SNT_CONSTANT );
CPLAssert(papoSubExpr[1]->eNodeType == SNT_CONSTANT );
if (papoSubExpr[0]->field_type == ODS_FIELD_TYPE_INTEGER)
{
if (papoSubExpr[1]->field_type == ODS_FIELD_TYPE_INTEGER)
{
int nVal;
switch (eOp)
{
case ODS_ADD : nVal = (papoSubExpr[0]->int_value + papoSubExpr[1]->int_value); break;
case ODS_SUBTRACT : nVal = (papoSubExpr[0]->int_value - papoSubExpr[1]->int_value); break;
case ODS_MULTIPLY : nVal = (papoSubExpr[0]->int_value * papoSubExpr[1]->int_value); break;
case ODS_DIVIDE :
if (papoSubExpr[1]->int_value != 0)
nVal = (papoSubExpr[0]->int_value / papoSubExpr[1]->int_value);
else
return FALSE;
break;
case ODS_MODULUS :
if (papoSubExpr[1]->int_value != 0)
nVal = (papoSubExpr[0]->int_value % papoSubExpr[1]->int_value);
else
return FALSE;
break;
default: nVal = 0; CPLAssert(0);
}
eNodeType = SNT_CONSTANT;
field_type = ODS_FIELD_TYPE_INTEGER;
int_value = nVal;
FreeSubExpr();
return TRUE;
}
else if (papoSubExpr[1]->field_type == ODS_FIELD_TYPE_FLOAT)
{
papoSubExpr[0]->field_type = ODS_FIELD_TYPE_FLOAT;
papoSubExpr[0]->float_value = papoSubExpr[0]->int_value;
}
else
{
CPLError(CE_Failure, CPLE_NotSupported,
"Bad argument type for %s", ODSGetOperatorName(eOp));
return FALSE;
}
}
if (papoSubExpr[0]->field_type == ODS_FIELD_TYPE_FLOAT)
{
if (papoSubExpr[1]->field_type == ODS_FIELD_TYPE_INTEGER)
{
papoSubExpr[1]->field_type = ODS_FIELD_TYPE_FLOAT;
papoSubExpr[1]->float_value = papoSubExpr[1]->int_value;
}
if (papoSubExpr[1]->field_type == ODS_FIELD_TYPE_FLOAT)
{
float dfVal;
switch (eOp)
{
case ODS_ADD : dfVal = (papoSubExpr[0]->float_value + papoSubExpr[1]->float_value); break;
case ODS_SUBTRACT : dfVal = (papoSubExpr[0]->float_value - papoSubExpr[1]->float_value); break;
case ODS_MULTIPLY : dfVal = (papoSubExpr[0]->float_value * papoSubExpr[1]->float_value); break;
case ODS_DIVIDE :
if (papoSubExpr[1]->float_value != 0)
dfVal = (papoSubExpr[0]->float_value / papoSubExpr[1]->float_value);
else
return FALSE;
break;
case ODS_MODULUS :
if (papoSubExpr[1]->float_value != 0)
dfVal = fmod(papoSubExpr[0]->float_value, papoSubExpr[1]->float_value);
else
return FALSE;
break;
default: dfVal = 0.0; CPLAssert(0);
}
eNodeType = SNT_CONSTANT;
field_type = ODS_FIELD_TYPE_FLOAT;
float_value = dfVal;
FreeSubExpr();
return TRUE;
}
else
{
CPLError(CE_Failure, CPLE_NotSupported,
"Bad argument type for %s", ODSGetOperatorName(eOp));
return FALSE;
}
}
else
{
CPLError(CE_Failure, CPLE_NotSupported,
"Bad argument type for %s", ODSGetOperatorName(eOp));
return FALSE;
}
}
OGRErr OGRMySQLTableLayer::CreateField( OGRFieldDefn *poFieldIn, int bApproxOK )
{
MYSQL_RES *hResult=nullptr;
CPLString osCommand;
char szFieldType[256];
OGRFieldDefn oField( poFieldIn );
/* -------------------------------------------------------------------- */
/* Do we want to "launder" the column names into Postgres */
/* friendly format? */
/* -------------------------------------------------------------------- */
if( bLaunderColumnNames )
{
char *pszSafeName = poDS->LaunderName( oField.GetNameRef() );
oField.SetName( pszSafeName );
CPLFree( pszSafeName );
}
/* -------------------------------------------------------------------- */
/* Work out the MySQL type. */
/* -------------------------------------------------------------------- */
if( oField.GetType() == OFTInteger )
{
if( oField.GetWidth() > 0 && bPreservePrecision )
snprintf( szFieldType, sizeof(szFieldType), "DECIMAL(%d,0)", oField.GetWidth() );
else
strcpy( szFieldType, "INTEGER" );
}
else if( oField.GetType() == OFTInteger64 )
{
if( oField.GetWidth() > 0 && bPreservePrecision )
snprintf( szFieldType, sizeof(szFieldType), "DECIMAL(%d,0)", oField.GetWidth() );
else
strcpy( szFieldType, "BIGINT" );
}
else if( oField.GetType() == OFTReal )
{
if( oField.GetWidth() > 0 && oField.GetPrecision() > 0
&& bPreservePrecision )
snprintf( szFieldType, sizeof(szFieldType), "DOUBLE(%d,%d)",
oField.GetWidth(), oField.GetPrecision() );
else
strcpy( szFieldType, "DOUBLE" );
}
else if( oField.GetType() == OFTDate )
{
oField.SetDefault(nullptr);
snprintf( szFieldType, sizeof(szFieldType), "DATE" );
}
else if( oField.GetType() == OFTDateTime )
{
if( oField.GetDefault() != nullptr && STARTS_WITH_CI(oField.GetDefault(), "CURRENT_TIMESTAMP") )
snprintf( szFieldType, sizeof(szFieldType), "TIMESTAMP" );
else
snprintf( szFieldType, sizeof(szFieldType), "DATETIME" );
}
else if( oField.GetType() == OFTTime )
{
oField.SetDefault(nullptr);
snprintf( szFieldType, sizeof(szFieldType), "TIME" );
}
else if( oField.GetType() == OFTBinary )
{
snprintf( szFieldType, sizeof(szFieldType), "LONGBLOB" );
}
else if( oField.GetType() == OFTString )
{
if( oField.GetWidth() == 0 || !bPreservePrecision )
{
if( oField.GetDefault() != nullptr )
strcpy( szFieldType, "VARCHAR(256)" );
else
strcpy( szFieldType, "TEXT" );
}
else
snprintf( szFieldType, sizeof(szFieldType), "VARCHAR(%d)", oField.GetWidth() );
}
else if( bApproxOK )
{
CPLError( CE_Warning, CPLE_NotSupported,
"Can't create field %s with type %s on MySQL layers. Creating as TEXT.",
oField.GetNameRef(),
OGRFieldDefn::GetFieldTypeName(oField.GetType()) );
strcpy( szFieldType, "TEXT" );
oField.SetWidth(0);
oField.SetPrecision(0);
}
else
{
CPLError( CE_Failure, CPLE_NotSupported,
"Can't create field %s with type %s on MySQL layers.",
oField.GetNameRef(),
OGRFieldDefn::GetFieldTypeName(oField.GetType()) );
return OGRERR_FAILURE;
}
osCommand.Printf(
"ALTER TABLE `%s` ADD COLUMN `%s` %s%s",
poFeatureDefn->GetName(), oField.GetNameRef(), szFieldType,
(!oField.IsNullable()) ? " NOT NULL" : "");
if( oField.GetDefault() != nullptr && !oField.IsDefaultDriverSpecific() )
{
osCommand += " DEFAULT ";
osCommand += oField.GetDefault();
}
if( mysql_query(poDS->GetConn(), osCommand ) )
{
poDS->ReportError( osCommand );
return OGRERR_FAILURE;
}
// make sure to attempt to free results of successful queries
hResult = mysql_store_result( poDS->GetConn() );
if( hResult != nullptr )
mysql_free_result( hResult );
hResult = nullptr;
poFeatureDefn->AddFieldDefn( &oField );
return OGRERR_NONE;
}
int ods_formula_node::EvaluateListArgOp(IODSCellEvaluator* poEvaluator)
{
CPLAssert( eNodeType == SNT_OPERATION );
CPLAssert( eOp >= ODS_SUM && eOp <= ODS_COUNTA );
CPLAssert(nSubExprCount == 1);
CPLAssert(papoSubExpr[0]->eNodeType == SNT_OPERATION );
CPLAssert(papoSubExpr[0]->eOp == ODS_LIST );
std::vector<double> adfVal;
int i;
int nCount = 0, nCountA = 0;
for(i=0;i<papoSubExpr[0]->nSubExprCount;i++)
{
if (papoSubExpr[0]->papoSubExpr[i]->eNodeType == SNT_OPERATION &&
papoSubExpr[0]->papoSubExpr[i]->eOp == ODS_CELL_RANGE)
{
CPLAssert (papoSubExpr[0]->papoSubExpr[i]->nSubExprCount == 2);
CPLAssert (papoSubExpr[0]->papoSubExpr[i]->papoSubExpr[0]->eNodeType == SNT_CONSTANT);
CPLAssert (papoSubExpr[0]->papoSubExpr[i]->papoSubExpr[0]->field_type == ODS_FIELD_TYPE_STRING);
CPLAssert (papoSubExpr[0]->papoSubExpr[i]->papoSubExpr[1]->eNodeType == SNT_CONSTANT);
CPLAssert (papoSubExpr[0]->papoSubExpr[i]->papoSubExpr[1]->field_type == ODS_FIELD_TYPE_STRING);
if (poEvaluator == NULL)
{
CPLError(CE_Failure, CPLE_AppDefined, "No cell evaluator provided");
return FALSE;
}
const char* psz1 = papoSubExpr[0]->papoSubExpr[i]->papoSubExpr[0]->string_value;
const char* psz2 = papoSubExpr[0]->papoSubExpr[i]->papoSubExpr[1]->string_value;
int nRow1 = 0,nCol1 = 0;
if (!GetRowCol(psz1, nRow1, nCol1))
return FALSE;
int nRow2 = 0,nCol2 = 0;
if (!GetRowCol(psz2, nRow2, nCol2))
return FALSE;
std::vector<ods_formula_node> aoOutValues;
if (poEvaluator->EvaluateRange(nRow1, nCol1, nRow2, nCol2, aoOutValues))
{
for(size_t j = 0; j < aoOutValues.size(); j++)
{
if (aoOutValues[j].eNodeType == SNT_CONSTANT)
{
if (aoOutValues[j].field_type == ODS_FIELD_TYPE_INTEGER)
{
adfVal.push_back(aoOutValues[j].int_value);
nCount ++;
nCountA ++;
}
else if (aoOutValues[j].field_type == ODS_FIELD_TYPE_FLOAT)
{
adfVal.push_back(aoOutValues[j].float_value);
nCount ++;
nCountA ++;
}
else if (aoOutValues[j].field_type == ODS_FIELD_TYPE_STRING)
{
nCountA ++;
}
}
}
}
}
else
{
if (!(papoSubExpr[0]->papoSubExpr[i]->Evaluate(poEvaluator)))
return FALSE;
CPLAssert (papoSubExpr[0]->papoSubExpr[i]->eNodeType == SNT_CONSTANT );
if (papoSubExpr[0]->papoSubExpr[i]->field_type == ODS_FIELD_TYPE_INTEGER)
{
adfVal.push_back(papoSubExpr[0]->papoSubExpr[i]->int_value);
nCount ++;
nCountA ++;
}
else if (papoSubExpr[0]->papoSubExpr[i]->field_type == ODS_FIELD_TYPE_FLOAT)
{
adfVal.push_back(papoSubExpr[0]->papoSubExpr[i]->float_value);
nCount ++;
nCountA ++;
}
else if (eOp == ODS_COUNT || eOp == ODS_COUNTA)
{
if (papoSubExpr[0]->papoSubExpr[i]->field_type == ODS_FIELD_TYPE_STRING)
nCountA ++;
}
else
{
CPLError(CE_Failure, CPLE_NotSupported,
"Bad argument type for %s", ODSGetOperatorName(eOp));
return FALSE;
}
}
}
if (eOp == ODS_COUNT)
{
eNodeType = SNT_CONSTANT;
field_type = ODS_FIELD_TYPE_INTEGER;
int_value = nCount;
FreeSubExpr();
return TRUE;
}
if (eOp == ODS_COUNTA)
{
eNodeType = SNT_CONSTANT;
field_type = ODS_FIELD_TYPE_INTEGER;
int_value = nCountA;
FreeSubExpr();
return TRUE;
}
double dfVal = 0;
switch(eOp)
{
case ODS_SUM:
{
for(i=0;i<(int)adfVal.size();i++)
{
dfVal += adfVal[i];
}
break;
}
case ODS_AVERAGE:
{
for(i=0;i<(int)adfVal.size();i++)
{
dfVal += adfVal[i];
}
dfVal /= adfVal.size();
break;
}
case ODS_MIN:
{
dfVal = (adfVal.size() == 0) ? 0 :adfVal[0];
for(i=1;i<(int)adfVal.size();i++)
{
if (adfVal[i] < dfVal) dfVal = adfVal[i];
}
break;
}
case ODS_MAX:
{
dfVal = (adfVal.size() == 0) ? 0 :adfVal[0];
for(i=1;i<(int)adfVal.size();i++)
{
if (adfVal[i] > dfVal) dfVal = adfVal[i];
}
break;
}
default:
break;
}
eNodeType = SNT_CONSTANT;
field_type = ODS_FIELD_TYPE_FLOAT;
float_value = dfVal;
FreeSubExpr();
return TRUE;
}
CPLErr swq_select::expand_wildcard( swq_field_list *field_list )
{
int isrc;
/* ==================================================================== */
/* Check each pre-expansion field. */
/* ==================================================================== */
for( isrc = 0; isrc < result_columns; isrc++ )
{
const char *src_fieldname = column_defs[isrc].field_name;
int itable, new_fields, i, iout;
if( *src_fieldname == '\0'
|| src_fieldname[strlen(src_fieldname)-1] != '*' )
continue;
/* We don't want to expand COUNT(*) */
if( column_defs[isrc].col_func == SWQCF_COUNT )
continue;
/* -------------------------------------------------------------------- */
/* Parse out the table name, verify it, and establish the */
/* number of fields to insert from it. */
/* -------------------------------------------------------------------- */
if( strcmp(src_fieldname,"*") == 0 )
{
itable = -1;
new_fields = field_list->count;
}
else if( strlen(src_fieldname) < 3
|| src_fieldname[strlen(src_fieldname)-2] != '.' )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Ill formatted field definition '%s'.",
src_fieldname );
return CE_Failure;
}
else
{
char *table_name = CPLStrdup( src_fieldname );
table_name[strlen(src_fieldname)-2] = '\0';
for( itable = 0; itable < field_list->table_count; itable++ )
{
if( strcasecmp(table_name,
field_list->table_defs[itable].table_alias ) == 0 )
break;
}
if( itable == field_list->table_count )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Table %s not recognised from %s definition.",
table_name, src_fieldname );
CPLFree( table_name );
return CE_Failure;
}
CPLFree( table_name );
/* count the number of fields in this table. */
new_fields = 0;
for( i = 0; i < field_list->count; i++ )
{
if( field_list->table_ids[i] == itable )
new_fields++;
}
}
if (new_fields > 0)
{
/* -------------------------------------------------------------------- */
/* Reallocate the column list larger. */
/* -------------------------------------------------------------------- */
CPLFree( column_defs[isrc].field_name );
delete column_defs[isrc].expr;
column_defs = (swq_col_def *)
CPLRealloc( column_defs,
sizeof(swq_col_def) *
(result_columns + new_fields - 1 ) );
/* -------------------------------------------------------------------- */
/* Push the old definitions that came after the one to be */
/* replaced further up in the array. */
/* -------------------------------------------------------------------- */
if (new_fields != 1)
{
for( i = result_columns-1; i > isrc; i-- )
{
memcpy( column_defs + i + new_fields - 1,
column_defs + i,
sizeof( swq_col_def ) );
}
}
result_columns += (new_fields - 1 );
/* -------------------------------------------------------------------- */
/* Zero out all the stuff in the target column definitions. */
/* -------------------------------------------------------------------- */
memset( column_defs + isrc, 0,
new_fields * sizeof(swq_col_def) );
}
else
{
/* -------------------------------------------------------------------- */
/* The wildcard expands to nothing */
/* -------------------------------------------------------------------- */
CPLFree( column_defs[isrc].field_name );
delete column_defs[isrc].expr;
memmove( column_defs + isrc,
column_defs + isrc + 1,
sizeof( swq_col_def ) * (result_columns-1-isrc) );
result_columns --;
}
/* -------------------------------------------------------------------- */
/* Assign the selected fields. */
/* -------------------------------------------------------------------- */
iout = isrc;
for( i = 0; i < field_list->count; i++ )
{
swq_col_def *def;
int compose = itable != -1;
/* skip this field if it isn't in the target table. */
if( itable != -1 && itable != field_list->table_ids[i] )
continue;
/* set up some default values. */
def = column_defs + iout;
def->field_precision = -1;
def->target_type = SWQ_OTHER;
/* does this field duplicate an earlier one? */
if( field_list->table_ids[i] != 0
&& !compose )
{
int other;
for( other = 0; other < i; other++ )
{
if( strcasecmp(field_list->names[i],
field_list->names[other]) == 0 )
{
compose = 1;
break;
}
}
}
int itable = field_list->table_ids[i];
char *composed_name;
const char *field_name = field_list->names[i];
const char *table_alias =
field_list->table_defs[itable].table_alias;
composed_name = (char *)
CPLMalloc(strlen(field_name)+strlen(table_alias)+2);
sprintf( composed_name, "%s.%s", table_alias, field_name );
def->field_name = composed_name;
if( !compose )
def->field_alias = CPLStrdup( field_list->names[i] );
iout++;
/* All the other table info will be provided by the later
parse operation. */
}
/* If there are several occurrences of '*', go on, but stay on the */
/* same index in case '*' is expanded to nothing */
/* (the -- is to compensate the fact that isrc will be incremented in */
/* the after statement of the for loop) */
isrc --;
}
return CE_None;
}
int ods_formula_node::Evaluate(IODSCellEvaluator* poEvaluator)
{
if (eNodeType == SNT_CONSTANT)
return TRUE;
CPLAssert( eNodeType == SNT_OPERATION );
switch (eOp)
{
case ODS_OR: return EvaluateOR(poEvaluator);
case ODS_AND: return EvaluateAND(poEvaluator);
case ODS_NOT: return EvaluateNOT(poEvaluator);
case ODS_IF: return EvaluateIF(poEvaluator);
case ODS_PI:
eNodeType = SNT_CONSTANT;
field_type = ODS_FIELD_TYPE_FLOAT;
float_value = M_PI;
return TRUE;
case ODS_LEN : return EvaluateLEN(poEvaluator);
case ODS_LEFT : return EvaluateLEFT(poEvaluator);
case ODS_RIGHT : return EvaluateRIGHT(poEvaluator);
case ODS_MID : return EvaluateMID(poEvaluator);
case ODS_SUM:
case ODS_AVERAGE:
case ODS_MIN:
case ODS_MAX:
case ODS_COUNT:
case ODS_COUNTA:
return EvaluateListArgOp(poEvaluator);
case ODS_ABS:
case ODS_SQRT:
case ODS_COS:
case ODS_SIN:
case ODS_TAN:
case ODS_ACOS:
case ODS_ASIN:
case ODS_ATAN:
case ODS_EXP:
case ODS_LN:
case ODS_LOG:
return EvaluateSingleArgOp(poEvaluator);
case ODS_EQ: return EvaluateEQ(poEvaluator);
case ODS_NE: return EvaluateNE(poEvaluator);
case ODS_LE: return EvaluateLE(poEvaluator);
case ODS_GE: return EvaluateGE(poEvaluator);
case ODS_LT: return EvaluateLT(poEvaluator);
case ODS_GT: return EvaluateGT(poEvaluator);
case ODS_ADD:
case ODS_SUBTRACT:
case ODS_MULTIPLY:
case ODS_DIVIDE:
case ODS_MODULUS:
return EvaluateBinaryArithmetic(poEvaluator);
case ODS_CONCAT: return EvaluateCONCAT(poEvaluator);
case ODS_CELL: return EvaluateCELL(poEvaluator);
default:
{
CPLError(CE_Failure, CPLE_AppDefined,
"Unhandled case in Evaluate() for %s",
ODSGetOperatorName(eOp));
return FALSE;
}
}
}
/**********************************************************************
* TABIDFile::Open()
*
* Open a .ID file, and initialize the structures to be ready to read
* objects from it.
*
* If the filename that is passed in contains a .MAP extension then
* the extension will be changed to .ID before trying to open the file.
*
* Returns 0 on success, -1 on error.
**********************************************************************/
int TABIDFile::Open(const char *pszFname, TABAccess eAccess)
{
int nLen;
if (m_fp)
{
CPLError(CE_Failure, CPLE_FileIO,
"Open() failed: object already contains an open file");
return -1;
}
/*-----------------------------------------------------------------
* Validate access mode and make sure we use binary access.
* Note that in Write mode we need TABReadWrite since we do random
* updates in the index as data blocks are split
*----------------------------------------------------------------*/
const char* pszAccess = NULL;
if (eAccess == TABRead)
{
m_eAccessMode = TABRead;
pszAccess = "rb";
}
else if (eAccess == TABWrite)
{
m_eAccessMode = TABReadWrite;
pszAccess = "wb+";
}
else if (eAccess == TABReadWrite)
{
m_eAccessMode = TABReadWrite;
pszAccess = "rb+";
}
else
{
CPLError(CE_Failure, CPLE_FileIO,
"Open() failed: access mode \"%d\" not supported", eAccess);
return -1;
}
/*-----------------------------------------------------------------
* Change .MAP extension to .ID if necessary
*----------------------------------------------------------------*/
m_pszFname = CPLStrdup(pszFname);
nLen = strlen(m_pszFname);
if (nLen > 4 && strcmp(m_pszFname+nLen-4, ".MAP")==0)
strcpy(m_pszFname+nLen-4, ".ID");
else if (nLen > 4 && strcmp(m_pszFname+nLen-4, ".map")==0)
strcpy(m_pszFname+nLen-4, ".id");
/*-----------------------------------------------------------------
* Change .MAP extension to .ID if necessary
*----------------------------------------------------------------*/
#ifndef _WIN32
TABAdjustFilenameExtension(m_pszFname);
#endif
/*-----------------------------------------------------------------
* Open file
*----------------------------------------------------------------*/
m_fp = VSIFOpenL(m_pszFname, pszAccess);
if (m_fp == NULL)
{
CPLError(CE_Failure, CPLE_FileIO,
"Open() failed for %s", m_pszFname);
CPLFree(m_pszFname);
m_pszFname = NULL;
return -1;
}
if (m_eAccessMode == TABRead || m_eAccessMode == TABReadWrite)
{
/*-------------------------------------------------------------
* READ access:
* Establish the number of object IDs from the size of the file
*------------------------------------------------------------*/
VSIStatBufL sStatBuf;
if ( VSIStatL(m_pszFname, &sStatBuf) == -1 )
{
CPLError(CE_Failure, CPLE_FileIO,
"stat() failed for %s\n", m_pszFname);
Close();
return -1;
}
m_nMaxId = (int)(sStatBuf.st_size/4);
m_nBlockSize = MIN(1024, m_nMaxId*4);
/*-------------------------------------------------------------
* Read the first block from the file
*------------------------------------------------------------*/
m_poIDBlock = new TABRawBinBlock(m_eAccessMode, FALSE);
if (m_nMaxId == 0)
{
// .ID file size = 0 ... just allocate a blank block but
// it won't get really used anyways.
m_nBlockSize = 512;
m_poIDBlock->InitNewBlock(m_fp, m_nBlockSize, 0);
}
else if (m_poIDBlock->ReadFromFile(m_fp, 0, m_nBlockSize) != 0)
{
// CPLError() has already been called.
Close();
return -1;
}
}
else
{
/*-------------------------------------------------------------
* WRITE access:
* Get ready to write to the file
*------------------------------------------------------------*/
m_poIDBlock = new TABRawBinBlock(m_eAccessMode, FALSE);
m_nMaxId = 0;
m_nBlockSize = 1024;
m_poIDBlock->InitNewBlock(m_fp, m_nBlockSize, 0);
}
return 0;
}
OGRErr OGRPolygon::importFromWkb( unsigned char * pabyData,
int nSize )
{
OGRwkbByteOrder eByteOrder;
int nDataOffset, b3D;
if( nSize < 9 && nSize != -1 )
return OGRERR_NOT_ENOUGH_DATA;
/* -------------------------------------------------------------------- */
/* Get the byte order byte. */
/* -------------------------------------------------------------------- */
eByteOrder = DB2_V72_FIX_BYTE_ORDER((OGRwkbByteOrder) *pabyData);
if (!( eByteOrder == wkbXDR || eByteOrder == wkbNDR ))
return OGRERR_CORRUPT_DATA;
/* -------------------------------------------------------------------- */
/* Get the geometry feature type. For now we assume that */
/* geometry type is between 0 and 255 so we only have to fetch */
/* one byte. */
/* -------------------------------------------------------------------- */
#ifdef DEBUG
OGRwkbGeometryType eGeometryType;
if( eByteOrder == wkbNDR )
eGeometryType = (OGRwkbGeometryType) pabyData[1];
else
eGeometryType = (OGRwkbGeometryType) pabyData[4];
if( eGeometryType != wkbPolygon )
return OGRERR_CORRUPT_DATA;
#endif
if( eByteOrder == wkbNDR )
b3D = pabyData[4] & 0x80 || pabyData[2] & 0x80;
else
b3D = pabyData[1] & 0x80 || pabyData[3] & 0x80;
if( b3D )
nCoordDimension = 3;
else
nCoordDimension = 2;
/* -------------------------------------------------------------------- */
/* Do we already have some rings? */
/* -------------------------------------------------------------------- */
if( nRingCount != 0 )
{
for( int iRing = 0; iRing < nRingCount; iRing++ )
delete papoRings[iRing];
OGRFree( papoRings );
papoRings = NULL;
}
/* -------------------------------------------------------------------- */
/* Get the ring count. */
/* -------------------------------------------------------------------- */
memcpy( &nRingCount, pabyData + 5, 4 );
if( OGR_SWAP( eByteOrder ) )
nRingCount = CPL_SWAP32(nRingCount);
if (nRingCount < 0 || nRingCount > INT_MAX / 4)
{
nRingCount = 0;
return OGRERR_CORRUPT_DATA;
}
/* Each ring has a minimum of 4 bytes (point count) */
if (nSize != -1 && nSize - 9 < nRingCount * 4)
{
CPLError( CE_Failure, CPLE_AppDefined,
"Length of input WKB is too small" );
nRingCount = 0;
return OGRERR_NOT_ENOUGH_DATA;
}
papoRings = (OGRLinearRing **) VSIMalloc2(sizeof(void*), nRingCount);
if (nRingCount != 0 && papoRings == NULL)
{
nRingCount = 0;
return OGRERR_NOT_ENOUGH_MEMORY;
}
nDataOffset = 9;
if( nSize != -1 )
nSize -= nDataOffset;
/* -------------------------------------------------------------------- */
/* Get the rings. */
/* -------------------------------------------------------------------- */
for( int iRing = 0; iRing < nRingCount; iRing++ )
{
OGRErr eErr;
papoRings[iRing] = new OGRLinearRing();
eErr = papoRings[iRing]->_importFromWkb( eByteOrder, b3D,
pabyData + nDataOffset,
nSize );
if( eErr != OGRERR_NONE )
{
delete papoRings[iRing];
nRingCount = iRing;
return eErr;
}
if( nSize != -1 )
nSize -= papoRings[iRing]->_WkbSize( b3D );
nDataOffset += papoRings[iRing]->_WkbSize( b3D );
}
return OGRERR_NONE;
}
