bool CSpatialReference::IsProjected() const
{
if(!m_Handle)
{
return false;
}
OGRSpatialReference* psr = (OGRSpatialReference*)m_Handle;
return psr->IsProjected();
}
static int32_t GetCoordinateSystemId(const char* pszProjection) {
int32_t coordinateSystemId = 0;
OGRSpatialReference* poSRS = BuildSRS(pszProjection);
if (poSRS != nullptr) {
std::string pszRoot;
if (poSRS->IsProjected()) {
pszRoot = "PROJCS";
} else {
pszRoot = "GEOCS";
}
const char *pszAuthName = poSRS->GetAuthorityName(pszRoot.c_str());
const char *pszAuthCode = poSRS->GetAuthorityCode(pszRoot.c_str());
if (pszAuthName != nullptr && EQUAL(pszAuthName, "EPSG")
&& pszAuthCode != nullptr) {
coordinateSystemId = atoi(pszAuthCode);
}
}
delete poSRS;
return coordinateSystemId;
}
bool ShpReader::SetupVectorProjection(OGRDataSource* OGRDataset, StudyControllerPtr studyController, OGRLayer* poLayer, VectorMapControllerPtr vectorMapController)
{
//If there exists a map layer, the vector file will be projected based on the projection of the map layer
if ( App::Inst().GetLayerTreeController()->GetNumMapLayers() > 0 )
{
ProjectionToolPtr projTool = studyController->GetProjectionTool();
OGRSpatialReference* currentShpSR = poLayer->GetSpatialRef();
if (!studyController->IsProjectData() && !studyController->IsGeographic())
{
needProjection=false;
Log::Inst().Write("The projection information for this study is being ignored.");
}
else
{
if(currentShpSR != NULL)
{
if(currentShpSR->IsGeographic())
{
Log::Inst().Write("Loading vector map with geographic coordinates.");
studyController->SetProjectData(true);
studyController->SetGeographic(true);
needProjection=true;
poTransform = studyController->GetProjectionTool();
}
else if(currentShpSR->IsProjected())
{
studyController->SetProjectData(true);
studyController->SetGeographic(false);
needProjection=true;
Log::Inst().Write("Loading vector map with projected coordinates.");
ProjectionToolPtr projTool = studyController->GetProjectionTool();
//OGRSpatialReference* currentLatLong = currentShpSR->CloneGeogCS();
OGRSpatialReference *targetCS= projTool->GetTargetCS ();
if(targetCS != NULL && !currentShpSR->IsSame(targetCS))
poTransform.reset(OGRCreateCoordinateTransformation(currentShpSR, targetCS));
else
needProjection=false;
}
else
{
// The user should probably be made aware of this warning.
Log::Inst().Warning("(Warning) Unknown type of coordinate system.");
return false;
}
}
else
{
//studyController->SetProjectData(false);
//studyController->SetGeographic(false);
needProjection=false;
Log::Inst().Write("Coordinate system information is not available for this map.");
Log::Inst().Write("As a result, the projection information for this study is being ignored.");
Log::Inst().Write("");
}
return true;
}
}
// App::Inst().GetLayerTreeController()->GetNumMapLayers() ==0
else
{
OGRSpatialReference* currentShpSR = poLayer->GetSpatialRef();
//OGRSpatialReference oSource;
if(currentShpSR != NULL)
{
if(currentShpSR->IsGeographic())
{
// lat/lon coordinates are using the geographic projection (aka, plate carrée)
Log::Inst().Write("Loading vector map with lat/long coordinates.");
studyController->SetProjectData(true);
studyController->SetGeographic(true);
needProjection=true;
// determine centre of map
VectorMapModelPtr vectorMapModel = vectorMapController->GetVectorMapModel();
float vectorMinX= vectorMapModel->GetVectorBoundary_MinX();
float vectorMinY = vectorMapModel->GetVectorBoundary_MinY();
float vectorMaxX = vectorMapModel->GetVectorBoundary_MaxX();
float vectorMaxY = vectorMapModel->GetVectorBoundary_MaxY();
studyController->SetCentreLongitude(float(vectorMinX + fabs(vectorMinX - vectorMaxX) / 2.0));
studyController->SetCentreLatitude(float(vectorMinY + fabs(vectorMinY - vectorMaxY) / 2.0));
studyController->SetFirstStandardParallel(vectorMinY);
studyController->SetSecondStandardParallel(vectorMaxY);
studyController->CalculateProjectionTool(currentShpSR);
poTransform = studyController->GetProjectionTool();
}
else if(currentShpSR->IsProjected())
{
studyController->SetProjectData(true);
studyController->SetGeographic(false);
Log::Inst().Write("Loading vector map with projected coordinates.");
studyController->CalculateProjectionTool(currentShpSR);
poTransform = studyController->GetProjectionTool();
needProjection=false;
}
else
{
// The user should probably be made aware of this warning.
Log::Inst().Warning("(Warning) Unknown type of coordinate system.");
return false;
}
}
else
{
studyController->SetProjectData(false);
studyController->SetGeographic(false);
needProjection=false;
Log::Inst().Write("Coordinate system information is not available for this map.");
Log::Inst().Write("As a result, the projection information for this study is being ignored.");
Log::Inst().Write("To overlaid a Vector map on top of this map, the vector map must be specified in the same coordinate system as this map");
Log::Inst().Write("");
}
}
return true;
}
OGRErr OGRSpatialReference::exportToERM( char *pszProj, char *pszDatum,
char *pszUnits )
{
strcpy( pszProj, "RAW" );
strcpy( pszDatum, "RAW" );
strcpy( pszUnits, "METERS" );
if( !IsProjected() && !IsGeographic() )
return TRUE;
/* -------------------------------------------------------------------- */
/* Try to find the EPSG code. */
/* -------------------------------------------------------------------- */
int nEPSGCode = 0;
if( IsProjected() )
{
const char *pszAuthName = GetAuthorityName( "PROJCS" );
if( pszAuthName != NULL && EQUAL(pszAuthName,"epsg") )
{
nEPSGCode = atoi(GetAuthorityCode( "PROJCS" ));
}
}
else if( IsGeographic() )
{
const char *pszAuthName = GetAuthorityName( "GEOGCS" );
if( pszAuthName != NULL && EQUAL(pszAuthName,"epsg") )
{
nEPSGCode = atoi(GetAuthorityCode( "GEOGCS" ));
}
}
/* -------------------------------------------------------------------- */
/* Is our GEOGCS name already defined in ecw_cs.dat? */
/* -------------------------------------------------------------------- */
OGRSpatialReference oSRSWork;
const char *pszWKTDatum = GetAttrValue( "DATUM" );
if( pszWKTDatum != NULL
&& oSRSWork.importFromDict( "ecw_cs.wkt", pszWKTDatum ) == OGRERR_NONE)
{
strncpy( pszDatum, pszWKTDatum, 32 );
pszDatum[31] = '\0';
}
/* -------------------------------------------------------------------- */
/* Is this a "well known" geographic coordinate system? */
/* -------------------------------------------------------------------- */
if( EQUAL(pszDatum,"RAW") )
{
int nEPSGGCSCode = GetEPSGGeogCS();
if( nEPSGGCSCode == 4326 )
strcpy( pszDatum, "WGS84" );
else if( nEPSGGCSCode == 4322 )
strcpy( pszDatum, "WGS72DOD" );
else if( nEPSGGCSCode == 4267 )
strcpy( pszDatum, "NAD27" );
else if( nEPSGGCSCode == 4269 )
strcpy( pszDatum, "NAD83" );
else if( nEPSGGCSCode == 4277 )
strcpy( pszDatum, "OSGB36" );
else if( nEPSGGCSCode == 4278 )
strcpy( pszDatum, "OSGB78" );
else if( nEPSGGCSCode == 4201 )
strcpy( pszDatum, "ADINDAN" );
else if( nEPSGGCSCode == 4202 )
strcpy( pszDatum, "AGD66" );
else if( nEPSGGCSCode == 4203 )
strcpy( pszDatum, "AGD84" );
else if( nEPSGGCSCode == 4209 )
strcpy( pszDatum, "ARC1950" );
else if( nEPSGGCSCode == 4210 )
strcpy( pszDatum, "ARC1960" );
else if( nEPSGGCSCode == 4275 )
strcpy( pszDatum, "NTF" );
else if( nEPSGGCSCode == 4283 )
strcpy( pszDatum, "GDA94" );
else if( nEPSGGCSCode == 4284 )
strcpy( pszDatum, "PULKOVO" );
}
/* -------------------------------------------------------------------- */
/* Are we working with a geographic (geodetic) coordinate system? */
/* -------------------------------------------------------------------- */
if( IsGeographic() )
{
if( EQUAL(pszDatum,"RAW") )
return OGRERR_UNSUPPORTED_SRS;
else
{
strcpy( pszProj, "GEODETIC" );
return OGRERR_NONE;
}
}
/* -------------------------------------------------------------------- */
/* Is this a UTM projection? */
/* -------------------------------------------------------------------- */
int bNorth, nZone;
nZone = GetUTMZone( &bNorth );
if( nZone > 0 )
{
if( EQUAL(pszDatum,"GDA94") && !bNorth && nZone >= 48 && nZone <= 58)
{
sprintf( pszProj, "MGA%02d", nZone );
}
else
{
if( bNorth )
sprintf( pszProj, "NUTM%02d", nZone );
else
sprintf( pszProj, "SUTM%02d", nZone );
}
}
/* -------------------------------------------------------------------- */
/* Is our PROJCS name already defined in ecw_cs.dat? */
/* -------------------------------------------------------------------- */
else
{
const char *pszPROJCS = GetAttrValue( "PROJCS" );
if( pszPROJCS != NULL
&& oSRSWork.importFromDict( "ecw_cs.wkt", pszPROJCS ) == OGRERR_NONE
&& oSRSWork.IsProjected() )
{
strncpy( pszProj, pszPROJCS, 32 );
pszProj[31] = '\0';
}
}
/* -------------------------------------------------------------------- */
/* If we have not translated it yet, but we have an EPSG code */
/* then use EPSG:n notation. */
/* -------------------------------------------------------------------- */
if( (EQUAL(pszDatum,"RAW") || EQUAL(pszProj,"RAW")) && nEPSGCode != 0 )
{
sprintf( pszProj, "EPSG:%d", nEPSGCode );
sprintf( pszDatum, "EPSG:%d", nEPSGCode );
}
/* -------------------------------------------------------------------- */
/* Handle the units. */
/* -------------------------------------------------------------------- */
double dfUnits = GetLinearUnits();
if( fabs(dfUnits-0.3048) < 0.0001 )
strcpy( pszUnits, "FEET" );
else
strcpy( pszUnits, "METERS" );
if( EQUAL(pszProj,"RAW") )
return OGRERR_UNSUPPORTED_SRS;
else
return OGRERR_NONE;
}
void GRIBDataset::SetGribMetaData(grib_MetaData* meta)
{
nRasterXSize = meta->gds.Nx;
nRasterYSize = meta->gds.Ny;
/* -------------------------------------------------------------------- */
/* Image projection. */
/* -------------------------------------------------------------------- */
OGRSpatialReference oSRS;
switch(meta->gds.projType)
{
case GS3_LATLON:
case GS3_GAUSSIAN_LATLON:
// No projection, only latlon system (geographic)
break;
case GS3_MERCATOR:
oSRS.SetMercator(meta->gds.meshLat, meta->gds.orientLon,
1.0, 0.0, 0.0);
break;
case GS3_POLAR:
oSRS.SetPS(meta->gds.meshLat, meta->gds.orientLon,
meta->gds.scaleLat1,
0.0, 0.0);
break;
case GS3_LAMBERT:
oSRS.SetLCC(meta->gds.scaleLat1, meta->gds.scaleLat2,
0.0, meta->gds.orientLon,
0.0, 0.0); // set projection
break;
case GS3_ORTHOGRAPHIC:
//oSRS.SetOrthographic(0.0, meta->gds.orientLon,
// meta->gds.lon2, meta->gds.lat2);
//oSRS.SetGEOS(meta->gds.orientLon, meta->gds.stretchFactor, meta->gds.lon2, meta->gds.lat2);
oSRS.SetGEOS( 0, 35785831, 0, 0 ); // hardcoded for now, I don't know yet how to parse the meta->gds section
break;
case GS3_EQUATOR_EQUIDIST:
break;
case GS3_AZIMUTH_RANGE:
break;
}
/* -------------------------------------------------------------------- */
/* Earth model */
/* -------------------------------------------------------------------- */
double a = meta->gds.majEarth * 1000.0; // in meters
double b = meta->gds.minEarth * 1000.0;
if( a == 0 && b == 0 )
{
a = 6377563.396;
b = 6356256.910;
}
if (meta->gds.f_sphere)
{
oSRS.SetGeogCS( "Coordinate System imported from GRIB file",
NULL,
"Sphere",
a, 0.0 );
}
else
{
double fInv = a/(a-b);
oSRS.SetGeogCS( "Coordinate System imported from GRIB file",
NULL,
"Spheroid imported from GRIB file",
a, fInv );
}
OGRSpatialReference oLL; // construct the "geographic" part of oSRS
oLL.CopyGeogCSFrom( &oSRS );
double rMinX;
double rMaxY;
double rPixelSizeX;
double rPixelSizeY;
if (meta->gds.projType == GS3_ORTHOGRAPHIC)
{
//rMinX = -meta->gds.Dx * (meta->gds.Nx / 2); // This is what should work, but it doesn't .. Dx seems to have an inverse relation with pixel size
//rMaxY = meta->gds.Dy * (meta->gds.Ny / 2);
const double geosExtentInMeters = 11137496.552; // hardcoded for now, assumption: GEOS projection, full disc (like MSG)
rMinX = -(geosExtentInMeters / 2);
rMaxY = geosExtentInMeters / 2;
rPixelSizeX = geosExtentInMeters / meta->gds.Nx;
rPixelSizeY = geosExtentInMeters / meta->gds.Ny;
}
else if( oSRS.IsProjected() )
{
rMinX = meta->gds.lon1; // longitude in degrees, to be transformed to meters (or degrees in case of latlon)
rMaxY = meta->gds.lat1; // latitude in degrees, to be transformed to meters
OGRCoordinateTransformation *poTransformLLtoSRS = OGRCreateCoordinateTransformation( &(oLL), &(oSRS) );
if ((poTransformLLtoSRS != NULL) && poTransformLLtoSRS->Transform( 1, &rMinX, &rMaxY )) // transform it to meters
{
if (meta->gds.scan == GRIB2BIT_2) // Y is minY, GDAL wants maxY
rMaxY += (meta->gds.Ny - 1) * meta->gds.Dy; // -1 because we GDAL needs the coordinates of the centre of the pixel
rPixelSizeX = meta->gds.Dx;
rPixelSizeY = meta->gds.Dy;
}
else
{
rMinX = 0.0;
rMaxY = 0.0;
rPixelSizeX = 1.0;
rPixelSizeY = -1.0;
oSRS.Clear();
CPLError( CE_Warning, CPLE_AppDefined,
"Unable to perform coordinate transformations, so the correct\n"
"projected geotransform could not be deduced from the lat/long\n"
"control points. Defaulting to ungeoreferenced." );
}
delete poTransformLLtoSRS;
}
else
{
rMinX = meta->gds.lon1; // longitude in degrees, to be transformed to meters (or degrees in case of latlon)
rMaxY = meta->gds.lat1; // latitude in degrees, to be transformed to meters
if (meta->gds.lat2 > rMaxY)
rMaxY = meta->gds.lat2;
rPixelSizeX = meta->gds.Dx;
rPixelSizeY = meta->gds.Dy;
}
adfGeoTransform[0] = rMinX;
adfGeoTransform[3] = rMaxY;
adfGeoTransform[1] = rPixelSizeX;
adfGeoTransform[5] = -rPixelSizeY;
CPLFree( pszProjection );
pszProjection = NULL;
oSRS.exportToWkt( &(pszProjection) );
}
GDALJP2Box *GDALJP2Metadata::CreateGMLJP2( int nXSize, int nYSize )
{
/* -------------------------------------------------------------------- */
/* This is a backdoor to let us embed a literal gmljp2 chunk */
/* supplied by the user as an external file. This is mostly */
/* for preparing test files with exotic contents. */
/* -------------------------------------------------------------------- */
if( CPLGetConfigOption( "GMLJP2OVERRIDE", NULL ) != NULL )
{
VSILFILE *fp = VSIFOpenL( CPLGetConfigOption( "GMLJP2OVERRIDE",""), "r" );
char *pszGML = NULL;
if( fp == NULL )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Unable to open GMLJP2OVERRIDE file." );
return NULL;
}
VSIFSeekL( fp, 0, SEEK_END );
int nLength = (int) VSIFTellL( fp );
pszGML = (char *) CPLCalloc(1,nLength+1);
VSIFSeekL( fp, 0, SEEK_SET );
VSIFReadL( pszGML, 1, nLength, fp );
VSIFCloseL( fp );
GDALJP2Box *apoGMLBoxes[2];
apoGMLBoxes[0] = GDALJP2Box::CreateLblBox( "gml.data" );
apoGMLBoxes[1] =
GDALJP2Box::CreateLabelledXMLAssoc( "gml.root-instance",
pszGML );
GDALJP2Box *poGMLData = GDALJP2Box::CreateAsocBox( 2, apoGMLBoxes);
delete apoGMLBoxes[0];
delete apoGMLBoxes[1];
CPLFree( pszGML );
return poGMLData;
}
/* -------------------------------------------------------------------- */
/* Try do determine a PCS or GCS code we can use. */
/* -------------------------------------------------------------------- */
OGRSpatialReference oSRS;
char *pszWKTCopy = (char *) pszProjection;
int nEPSGCode = 0;
char szSRSName[100];
int bNeedAxisFlip = FALSE;
if( oSRS.importFromWkt( &pszWKTCopy ) != OGRERR_NONE )
return NULL;
if( oSRS.IsProjected() )
{
const char *pszAuthName = oSRS.GetAuthorityName( "PROJCS" );
if( pszAuthName != NULL && EQUAL(pszAuthName,"epsg") )
{
nEPSGCode = atoi(oSRS.GetAuthorityCode( "PROJCS" ));
}
}
else if( oSRS.IsGeographic() )
{
const char *pszAuthName = oSRS.GetAuthorityName( "GEOGCS" );
if( pszAuthName != NULL && EQUAL(pszAuthName,"epsg") )
{
nEPSGCode = atoi(oSRS.GetAuthorityCode( "GEOGCS" ));
bNeedAxisFlip = TRUE;
}
}
if( nEPSGCode != 0 )
sprintf( szSRSName, "urn:ogc:def:crs:EPSG::%d", nEPSGCode );
else
strcpy( szSRSName,
"gmljp2://xml/CRSDictionary.gml#ogrcrs1" );
/* -------------------------------------------------------------------- */
/* Prepare coverage origin and offset vectors. Take axis */
/* order into account if needed. */
/* -------------------------------------------------------------------- */
double adfOrigin[2];
double adfXVector[2];
double adfYVector[2];
adfOrigin[0] = adfGeoTransform[0] + adfGeoTransform[1] * 0.5
+ adfGeoTransform[4] * 0.5;
adfOrigin[1] = adfGeoTransform[3] + adfGeoTransform[2] * 0.5
+ adfGeoTransform[5] * 0.5;
adfXVector[0] = adfGeoTransform[1];
adfXVector[1] = adfGeoTransform[2];
adfYVector[0] = adfGeoTransform[4];
adfYVector[1] = adfGeoTransform[5];
if( bNeedAxisFlip
&& CSLTestBoolean( CPLGetConfigOption( "GDAL_IGNORE_AXIS_ORIENTATION",
"FALSE" ) ) )
{
bNeedAxisFlip = FALSE;
CPLDebug( "GMLJP2", "Supressed axis flipping on write based on GDAL_IGNORE_AXIS_ORIENTATION." );
}
if( bNeedAxisFlip )
{
double dfTemp;
CPLDebug( "GMLJP2", "Flipping GML coverage axis order." );
dfTemp = adfOrigin[0];
adfOrigin[0] = adfOrigin[1];
adfOrigin[1] = dfTemp;
dfTemp = adfXVector[0];
adfXVector[0] = adfXVector[1];
adfXVector[1] = dfTemp;
dfTemp = adfYVector[0];
adfYVector[0] = adfYVector[1];
adfYVector[1] = dfTemp;
}
/* -------------------------------------------------------------------- */
/* For now we hardcode for a minimal instance format. */
/* -------------------------------------------------------------------- */
CPLString osDoc;
osDoc.Printf(
"<gml:FeatureCollection\n"
" xmlns:gml=\"http://www.opengis.net/gml\"\n"
" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"\n"
" xsi:schemaLocation=\"http://www.opengeospatial.net/gml http://schemas.opengis.net/gml/3.1.1/profiles/gmlJP2Profile/1.0.0/gmlJP2Profile.xsd\">\n"
" <gml:boundedBy>\n"
" <gml:Null>withheld</gml:Null>\n"
" </gml:boundedBy>\n"
" <gml:featureMember>\n"
" <gml:FeatureCollection>\n"
" <gml:featureMember>\n"
" <gml:RectifiedGridCoverage dimension=\"2\" gml:id=\"RGC0001\">\n"
" <gml:rectifiedGridDomain>\n"
" <gml:RectifiedGrid dimension=\"2\">\n"
" <gml:limits>\n"
" <gml:GridEnvelope>\n"
" <gml:low>0 0</gml:low>\n"
" <gml:high>%d %d</gml:high>\n"
" </gml:GridEnvelope>\n"
" </gml:limits>\n"
" <gml:axisName>x</gml:axisName>\n"
" <gml:axisName>y</gml:axisName>\n"
" <gml:origin>\n"
" <gml:Point gml:id=\"P0001\" srsName=\"%s\">\n"
" <gml:pos>%.15g %.15g</gml:pos>\n"
" </gml:Point>\n"
" </gml:origin>\n"
" <gml:offsetVector srsName=\"%s\">%.15g %.15g</gml:offsetVector>\n"
" <gml:offsetVector srsName=\"%s\">%.15g %.15g</gml:offsetVector>\n"
" </gml:RectifiedGrid>\n"
" </gml:rectifiedGridDomain>\n"
" <gml:rangeSet>\n"
" <gml:File>\n"
" <gml:fileName>gmljp2://codestream/0</gml:fileName>\n"
" <gml:fileStructure>Record Interleaved</gml:fileStructure>\n"
" </gml:File>\n"
" </gml:rangeSet>\n"
" </gml:RectifiedGridCoverage>\n"
" </gml:featureMember>\n"
" </gml:FeatureCollection>\n"
" </gml:featureMember>\n"
"</gml:FeatureCollection>\n",
nXSize-1, nYSize-1, szSRSName, adfOrigin[0], adfOrigin[1],
szSRSName, adfXVector[0], adfXVector[1],
szSRSName, adfYVector[0], adfYVector[1] );
/* -------------------------------------------------------------------- */
/* If we need a user defined CRSDictionary entry, prepare it */
/* here. */
/* -------------------------------------------------------------------- */
CPLString osDictBox;
if( nEPSGCode == 0 )
{
char *pszGMLDef = NULL;
if( oSRS.exportToXML( &pszGMLDef, NULL ) == OGRERR_NONE )
{
osDictBox.Printf(
"<gml:Dictionary gml:id=\"CRSU1\" \n"
" xmlns:gml=\"http://www.opengis.net/gml\"\n"
" xmlns:xlink=\"http://www.w3.org/1999/xlink\"\n"
" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\">\n"
" <gml:dictionaryEntry>\n"
"%s\n"
" </gml:dictionaryEntry>\n"
"</gml:Dictionary>\n",
pszGMLDef );
}
CPLFree( pszGMLDef );
}
/* -------------------------------------------------------------------- */
/* Setup the gml.data label. */
/* -------------------------------------------------------------------- */
GDALJP2Box *apoGMLBoxes[5];
int nGMLBoxes = 0;
apoGMLBoxes[nGMLBoxes++] = GDALJP2Box::CreateLblBox( "gml.data" );
/* -------------------------------------------------------------------- */
/* Setup gml.root-instance. */
/* -------------------------------------------------------------------- */
apoGMLBoxes[nGMLBoxes++] =
GDALJP2Box::CreateLabelledXMLAssoc( "gml.root-instance", osDoc );
/* -------------------------------------------------------------------- */
/* Add optional dictionary. */
/* -------------------------------------------------------------------- */
if( strlen(osDictBox) > 0 )
apoGMLBoxes[nGMLBoxes++] =
GDALJP2Box::CreateLabelledXMLAssoc( "CRSDictionary.gml",
osDictBox );
/* -------------------------------------------------------------------- */
/* Bundle gml.data boxes into an association. */
/* -------------------------------------------------------------------- */
GDALJP2Box *poGMLData = GDALJP2Box::CreateAsocBox( nGMLBoxes, apoGMLBoxes);
/* -------------------------------------------------------------------- */
/* Cleanup working boxes. */
/* -------------------------------------------------------------------- */
while( nGMLBoxes > 0 )
delete apoGMLBoxes[--nGMLBoxes];
return poGMLData;
}
CPLErr IDADataset::SetProjection( const char *pszWKTIn )
{
OGRSpatialReference oSRS;
oSRS.importFromWkt( (char **) &pszWKTIn );
if( !oSRS.IsGeographic() && !oSRS.IsProjected() )
GDALPamDataset::SetProjection( pszWKTIn );
/* -------------------------------------------------------------------- */
/* Clear projection parameters. */
/* -------------------------------------------------------------------- */
dfParallel1 = 0.0;
dfParallel2 = 0.0;
dfLatCenter = 0.0;
dfLongCenter = 0.0;
/* -------------------------------------------------------------------- */
/* Geographic. */
/* -------------------------------------------------------------------- */
if( oSRS.IsGeographic() )
{
// If no change, just return.
if( nProjection == 3 )
return CE_None;
nProjection = 3;
}
/* -------------------------------------------------------------------- */
/* Verify we don't have a false easting or northing as these */
/* will be ignored for the projections we do support. */
/* -------------------------------------------------------------------- */
if( oSRS.GetProjParm( SRS_PP_FALSE_EASTING ) != 0.0
|| oSRS.GetProjParm( SRS_PP_FALSE_NORTHING ) != 0.0 )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Attempt to set a projection on an IDA file with a non-zero\n"
"false easting and/or northing. This is not supported." );
return CE_Failure;
}
/* -------------------------------------------------------------------- */
/* Lambert Conformal Conic. Note that we don't support false */
/* eastings or nothings. */
/* -------------------------------------------------------------------- */
const char *pszProjection = oSRS.GetAttrValue( "PROJECTION" );
if( pszProjection == NULL )
{
/* do nothing - presumably geographic */;
}
else if( EQUAL(pszProjection,SRS_PT_LAMBERT_CONFORMAL_CONIC_2SP) )
{
nProjection = 4;
dfParallel1 = oSRS.GetNormProjParm(SRS_PP_STANDARD_PARALLEL_1,0.0);
dfParallel2 = oSRS.GetNormProjParm(SRS_PP_STANDARD_PARALLEL_2,0.0);
dfLatCenter = oSRS.GetNormProjParm(SRS_PP_LATITUDE_OF_ORIGIN,0.0);
dfLongCenter = oSRS.GetNormProjParm(SRS_PP_CENTRAL_MERIDIAN,0.0);
}
else if( EQUAL(pszProjection,SRS_PT_LAMBERT_AZIMUTHAL_EQUAL_AREA) )
{
nProjection = 6;
dfLatCenter = oSRS.GetNormProjParm(SRS_PP_LATITUDE_OF_ORIGIN,0.0);
dfLongCenter = oSRS.GetNormProjParm(SRS_PP_CENTRAL_MERIDIAN,0.0);
}
else if( EQUAL(pszProjection,SRS_PT_ALBERS_CONIC_EQUAL_AREA) )
{
nProjection = 8;
dfParallel1 = oSRS.GetNormProjParm(SRS_PP_STANDARD_PARALLEL_1,0.0);
dfParallel2 = oSRS.GetNormProjParm(SRS_PP_STANDARD_PARALLEL_2,0.0);
dfLatCenter = oSRS.GetNormProjParm(SRS_PP_LATITUDE_OF_ORIGIN,0.0);
dfLongCenter = oSRS.GetNormProjParm(SRS_PP_CENTRAL_MERIDIAN,0.0);
}
else if( EQUAL(pszProjection,SRS_PT_GOODE_HOMOLOSINE) )
{
nProjection = 9;
dfLongCenter = oSRS.GetNormProjParm(SRS_PP_CENTRAL_MERIDIAN,0.0);
}
else
{
return GDALPamDataset::SetProjection( pszWKTIn );
}
/* -------------------------------------------------------------------- */
/* Update header and mark it as dirty. */
/* -------------------------------------------------------------------- */
bHeaderDirty = TRUE;
abyHeader[23] = (GByte) nProjection;
c2tp( dfLatCenter, abyHeader + 120 );
c2tp( dfLongCenter, abyHeader + 126 );
c2tp( dfParallel1, abyHeader + 156 );
c2tp( dfParallel2, abyHeader + 162 );
return CE_None;
}
bool DemReader::SetupProjection(GDALDataset* gdalDataset, StudyControllerPtr studyController, double* adfGeoTransform, uint nCols, uint nRows, bool bElevationMap)
{
// getting the string about projection system for this dataset.
const char* currentWkt = gdalDataset->GetProjectionRef();
OGRSpatialReference oSource;
if((currentWkt != NULL && oSource.importFromWkt( (char**)¤tWkt ) != OGRERR_CORRUPT_DATA))
{
if(oSource.IsGeographic())
{
// lat/lon coordinates are using the geographic projection (aka, plate carrée)
if(!App::Inst().GetLayerTreeController()->GetIsBlankRaster())
Log::Inst().Write("Loading map with lat/long coordinates.");
studyController->SetProjectData(true);
studyController->SetGeographic(true);
studyController->SetUsingProjection(true);
studyController->SetUsingGeographic(true);
// determine centre of map
double longStart = adfGeoTransform[0];
double longEnd = adfGeoTransform[0] + nCols*adfGeoTransform[1];
studyController->SetCentreLongitude(float(longStart + fabs(longStart - longEnd) / 2.0));
double latStart = adfGeoTransform[3] + nRows*adfGeoTransform[5];
double latEnd = adfGeoTransform[3];
studyController->SetCentreLatitude(float(latStart + fabs(latStart - latEnd) / 2.0));
studyController->SetFirstStandardParallel(latStart);
studyController->SetSecondStandardParallel(latEnd);
studyController->CalculateProjectionTool(&oSource);
}
else if(oSource.IsProjected())
{
studyController->SetProjectData(true);
studyController->SetGeographic(false);
studyController->SetUsingProjection(true);
studyController->SetUsingGeographic(false);
if (!App::Inst().GetLayerTreeController()->GetIsBlankRaster())
Log::Inst().Write("Loading map with projected coordinates.");
studyController->CalculateProjectionTool(&oSource);
}
else
{
// The user should probably be made aware of this warning.
Log::Inst().Warning("(Warning) Unknown type of coordinate system.");
return false;
}
}
else
{
studyController->SetProjectData(false);
studyController->SetGeographic(false);
studyController->SetUsingProjection(false);
studyController->SetUsingGeographic(false);
if(bElevationMap)
{
// The user should probably be made aware of this warning.
Log::Inst().Warning("(Warning) Well-Known text which specified coordinate system information is missing or not recognized.");
Log::Inst().Warning("(Warning) The projection information for this study is being ignored.");
Log::Inst().Warning("(Warning) Location sites and leaf nodes must be specified in the same coordinate system as this map.");
Log::Inst().Warning("");
}
else
{
// Right now we assume that any 3-channel map (i.e., non-elevational) should be projected using the
// the geographic projection (aka, plate carrée)
studyController->SetUsingProjection(false);
studyController->SetUsingGeographic(true);
Log::Inst().Write("Coordinate system information is not available for this map.");
Log::Inst().Write("As a result, the projection information for this study is being ignored.");
Log::Inst().Write("");
}
}
return true;
}
