void ProjectionDlg::OnItemRightClick( wxListEvent &event )
{
int item_clicked = event.GetIndex();
OGR_SRSNode *root = m_proj.GetRoot();
OGR_SRSNode *node, *par1, *par2;
const char *value;
int children = root->GetChildCount();
int i, item = 0;
wxString str;
for (i = 0; i < children; i++)
{
node = root->GetChild(i);
value = node->GetValue();
if (strcmp(value, "PARAMETER"))
continue;
par1 = node->GetChild(0);
par2 = node->GetChild(1);
value = par2->GetValue();
if (item == item_clicked)
{
wxString caption = _("Value for ");
str = wxString(par1->GetValue(), wxConvUTF8);
caption += str;
str = wxString(value, wxConvUTF8);
wxString result = wxGetTextFromUser(caption, _("Enter new value"),
str, this);
if (result != _T(""))
{
// double newval = atof((const char *)result);
par2->SetValue(result.mb_str(wxConvUTF8));
DisplayProjectionSpecificParams();
return;
}
}
item++;
}
}
void ProjectionDlg::DisplayProjectionSpecificParams()
{
m_pParamCtrl->DeleteAllItems();
OGR_SRSNode *root = m_proj.GetRoot();
if (!root)
{
m_pParamCtrl->InsertItem(0, _("(Invalid projection)"));
return; // bogus projection
}
OGR_SRSNode *node, *par1, *par2;
const char *value;
int children = root->GetChildCount();
int i, item = 0;
wxString str;
for (i = 0; i < children; i++)
{
node = root->GetChild(i);
value = node->GetValue();
if (!strcmp(value, "PARAMETER"))
{
par1 = node->GetChild(0);
value = par1->GetValue();
str = wxString(value, wxConvUTF8);
item = m_pParamCtrl->InsertItem(item, str);
par2 = node->GetChild(1);
value = par2->GetValue();
str = wxString(value, wxConvUTF8);
m_pParamCtrl->SetItem(item, 1, str);
item++;
}
}
}
OGRErr OGRSpatialReference::Validate(OGR_SRSNode *poRoot)
{
if( !EQUAL(poRoot->GetValue(),"GEOGCS")
&& !EQUAL(poRoot->GetValue(),"PROJCS")
&& !EQUAL(poRoot->GetValue(),"LOCAL_CS")
&& !EQUAL(poRoot->GetValue(),"GEOCCS")
&& !EQUAL(poRoot->GetValue(),"VERT_CS")
&& !EQUAL(poRoot->GetValue(),"COMPD_CS"))
{
CPLDebug( "OGRSpatialReference::Validate",
"Unrecognised root node `%s'\n",
poRoot->GetValue() );
return OGRERR_CORRUPT_DATA;
}
/* -------------------------------------------------------------------- */
/* For a COMPD_CS, validate subparameters and head & tail cs */
/* -------------------------------------------------------------------- */
if( EQUAL(poRoot->GetValue(),"COMPD_CS") )
{
OGR_SRSNode *poNode;
int i;
for( i = 1; i < poRoot->GetChildCount(); i++ )
{
poNode = poRoot->GetChild(i);
if( EQUAL(poNode->GetValue(),"GEOGCS") ||
EQUAL(poNode->GetValue(),"PROJCS") ||
EQUAL(poNode->GetValue(),"LOCAL_CS") ||
EQUAL(poNode->GetValue(),"GEOCCS") ||
EQUAL(poNode->GetValue(),"VERT_CS") ||
EQUAL(poNode->GetValue(),"COMPD_CS") )
{
OGRErr eErr = Validate(poNode);
if (eErr != OGRERR_NONE)
return eErr;
}
else if( EQUAL(poNode->GetValue(),"AUTHORITY") )
{
OGRErr eErr = ValidateAuthority(poNode);
if (eErr != OGRERR_NONE)
return eErr;
}
else
{
CPLDebug( "OGRSpatialReference::Validate",
"Unexpected child for COMPD_CS `%s'.\n",
poNode->GetValue() );
return OGRERR_CORRUPT_DATA;
}
}
return OGRERR_NONE;
}
/* -------------------------------------------------------------------- */
/* Validate VERT_CS */
/* -------------------------------------------------------------------- */
if( EQUAL(poRoot->GetValue(),"VERT_CS") )
{
OGR_SRSNode *poNode;
int i;
int bGotVertDatum = FALSE;
int bGotUnit = FALSE;
int nCountAxis = 0;
for( i = 1; i < poRoot->GetChildCount(); i++ )
{
poNode = poRoot->GetChild(i);
if( EQUAL(poNode->GetValue(),"VERT_DATUM") )
{
OGRErr eErr = ValidateVertDatum(poNode);
if (eErr != OGRERR_NONE)
return eErr;
bGotVertDatum = TRUE;
}
else if( EQUAL(poNode->GetValue(),"UNIT") )
{
OGRErr eErr = ValidateUnit(poNode);
if (eErr != OGRERR_NONE)
return eErr;
bGotUnit = TRUE;
}
else if( EQUAL(poNode->GetValue(),"AXIS") )
{
OGRErr eErr = ValidateAxis(poNode);
if (eErr != OGRERR_NONE)
return eErr;
nCountAxis ++;
}
else if( EQUAL(poNode->GetValue(),"AUTHORITY") )
{
OGRErr eErr = ValidateAuthority(poNode);
if (eErr != OGRERR_NONE)
return eErr;
}
else
{
CPLDebug( "OGRSpatialReference::Validate",
"Unexpected child for VERT_CS `%s'.\n",
poNode->GetValue() );
return OGRERR_CORRUPT_DATA;
}
}
if (!bGotVertDatum)
{
CPLDebug( "OGRSpatialReference::Validate",
"No VERT_DATUM child in VERT_CS.\n" );
return OGRERR_CORRUPT_DATA;
}
if (!bGotUnit)
{
CPLDebug( "OGRSpatialReference::Validate",
"No UNIT child in VERT_CS.\n" );
return OGRERR_CORRUPT_DATA;
}
if (nCountAxis > 1)
{
CPLDebug( "OGRSpatialReference::Validate",
"Too many AXIS children in VERT_CS.\n" );
return OGRERR_CORRUPT_DATA;
}
return OGRERR_NONE;
}
/* -------------------------------------------------------------------- */
/* For a PROJCS, validate subparameters (other than GEOGCS). */
/* -------------------------------------------------------------------- */
if( EQUAL(poRoot->GetValue(),"PROJCS") )
{
OGR_SRSNode *poNode;
int i;
for( i = 1; i < poRoot->GetChildCount(); i++ )
{
poNode = poRoot->GetChild(i);
if( EQUAL(poNode->GetValue(),"GEOGCS") )
{
/* validated elsewhere */
}
else if( EQUAL(poNode->GetValue(),"UNIT") )
{
OGRErr eErr = ValidateUnit(poNode);
if (eErr != OGRERR_NONE)
return eErr;
}
else if( EQUAL(poNode->GetValue(),"PARAMETER") )
{
if( poNode->GetChildCount() != 2 )
{
CPLDebug( "OGRSpatialReference::Validate",
"PARAMETER has wrong number of children (%d),"
"not 2 as expected.\n",
poNode->GetChildCount() );
return OGRERR_CORRUPT_DATA;
}
else if( CSLFindString( (char **)papszParameters,
poNode->GetChild(0)->GetValue()) == -1)
{
CPLDebug( "OGRSpatialReference::Validate",
"Unrecognised PARAMETER `%s'.\n",
poNode->GetChild(0)->GetValue() );
return OGRERR_UNSUPPORTED_SRS;
}
}
else if( EQUAL(poNode->GetValue(),"PROJECTION") )
{
if( poNode->GetChildCount() != 1 && poNode->GetChildCount() != 2 )
{
CPLDebug( "OGRSpatialReference::Validate",
"PROJECTION has wrong number of children (%d),"
"not 1 or 2 as expected.\n",
poNode->GetChildCount() );
return OGRERR_CORRUPT_DATA;
}
else if( CSLFindString( (char **)papszProjectionSupported,
poNode->GetChild(0)->GetValue()) == -1
&& CSLFindString( (char **)papszProjectionUnsupported,
poNode->GetChild(0)->GetValue()) == -1)
{
CPLDebug( "OGRSpatialReference::Validate",
"Unrecognised PROJECTION `%s'.\n",
poNode->GetChild(0)->GetValue() );
return OGRERR_UNSUPPORTED_SRS;
}
else if( CSLFindString( (char **)papszProjectionSupported,
poNode->GetChild(0)->GetValue()) == -1)
{
CPLDebug( "OGRSpatialReference::Validate",
"Unsupported, but recognised PROJECTION `%s'.\n",
poNode->GetChild(0)->GetValue() );
return OGRERR_UNSUPPORTED_SRS;
}
if (poNode->GetChildCount() == 2)
{
poNode = poNode->GetChild(1);
if( EQUAL(poNode->GetValue(),"AUTHORITY") )
{
OGRErr eErr = ValidateAuthority(poNode);
if (eErr != OGRERR_NONE)
return eErr;
}
else
{
CPLDebug( "OGRSpatialReference::Validate",
"Unexpected child for PROJECTION `%s'.\n",
poNode->GetValue() );
return OGRERR_CORRUPT_DATA;
}
}
}
else if( EQUAL(poNode->GetValue(),"AUTHORITY") )
{
OGRErr eErr = ValidateAuthority(poNode);
if (eErr != OGRERR_NONE)
return eErr;
}
else if( EQUAL(poNode->GetValue(),"AXIS") )
{
OGRErr eErr = ValidateAxis(poNode);
if (eErr != OGRERR_NONE)
return eErr;
}
else if( EQUAL(poNode->GetValue(),"EXTENSION") )
{
// We do not try to control the sub-organization of
// EXTENSION nodes.
}
else
{
CPLDebug( "OGRSpatialReference::Validate",
"Unexpected child for PROJCS `%s'.\n",
poNode->GetValue() );
return OGRERR_CORRUPT_DATA;
}
}
}
/* -------------------------------------------------------------------- */
/* Validate GEOGCS if found. */
/* -------------------------------------------------------------------- */
OGR_SRSNode *poGEOGCS = poRoot->GetNode( "GEOGCS" );
if( poGEOGCS != NULL )
{
OGR_SRSNode *poNode;
int i;
for( i = 1; i < poGEOGCS->GetChildCount(); i++ )
{
poNode = poGEOGCS->GetChild(i);
if( EQUAL(poNode->GetValue(),"DATUM") )
{
/* validated elsewhere */
}
else if( EQUAL(poNode->GetValue(),"PRIMEM") )
{
if( poNode->GetChildCount() < 2
|| poNode->GetChildCount() > 3 )
{
CPLDebug( "OGRSpatialReference::Validate",
"PRIMEM has wrong number of children (%d),"
"not 2 or 3 as expected.\n",
poNode->GetChildCount() );
return OGRERR_CORRUPT_DATA;
}
}
else if( EQUAL(poNode->GetValue(),"UNIT") )
{
OGRErr eErr = ValidateUnit(poNode);
if (eErr != OGRERR_NONE)
return eErr;
}
else if( EQUAL(poNode->GetValue(),"AXIS") )
{
OGRErr eErr = ValidateAxis(poNode);
if (eErr != OGRERR_NONE)
return eErr;
}
else if( EQUAL(poNode->GetValue(),"AUTHORITY") )
{
OGRErr eErr = ValidateAuthority(poNode);
if (eErr != OGRERR_NONE)
return eErr;
}
else
{
CPLDebug( "OGRSpatialReference::Validate",
"Unexpected child for GEOGCS `%s'.\n",
poNode->GetValue() );
return OGRERR_CORRUPT_DATA;
}
}
if( poGEOGCS->GetNode("DATUM") == NULL )
{
CPLDebug( "OGRSpatialReference::Validate",
"No DATUM child in GEOGCS.\n" );
return OGRERR_CORRUPT_DATA;
}
}
/* -------------------------------------------------------------------- */
/* Validate DATUM/SPHEROID. */
/* -------------------------------------------------------------------- */
OGR_SRSNode *poDATUM = poRoot->GetNode( "DATUM" );
if( poDATUM != NULL )
{
OGR_SRSNode *poSPHEROID;
int bGotSpheroid = FALSE;
int i;
if( poDATUM->GetChildCount() == 0 )
{
CPLDebug( "OGRSpatialReference::Validate",
"DATUM has no children." );
return OGRERR_CORRUPT_DATA;
}
for( i = 1; i < poDATUM->GetChildCount(); i++ )
{
OGR_SRSNode *poNode;
poNode = poDATUM->GetChild(i);
if( EQUAL(poNode->GetValue(),"SPHEROID") )
{
poSPHEROID = poDATUM->GetChild(1);
bGotSpheroid = TRUE;
if( poSPHEROID->GetChildCount() != 3
&& poSPHEROID->GetChildCount() != 4 )
{
CPLDebug( "OGRSpatialReference::Validate",
"SPHEROID has wrong number of children (%d),"
"not 3 or 4 as expected.\n",
poSPHEROID->GetChildCount() );
return OGRERR_CORRUPT_DATA;
}
else if( CPLAtof(poSPHEROID->GetChild(1)->GetValue()) == 0.0 )
{
CPLDebug( "OGRSpatialReference::Validate",
"SPHEROID semi-major axis is zero (%s)!\n",
poSPHEROID->GetChild(1)->GetValue() );
return OGRERR_CORRUPT_DATA;
}
}
else if( EQUAL(poNode->GetValue(),"AUTHORITY") )
{
OGRErr eErr = ValidateAuthority(poNode);
if (eErr != OGRERR_NONE)
return eErr;
}
else if( EQUAL(poNode->GetValue(),"TOWGS84") )
{
if( poNode->GetChildCount() != 3
&& poNode->GetChildCount() != 7)
{
CPLDebug( "OGRSpatialReference::Validate",
"TOWGS84 has wrong number of children (%d), not 3 or 7.\n",
poNode->GetChildCount() );
return OGRERR_CORRUPT_DATA;
}
}
else
{
CPLDebug( "OGRSpatialReference::Validate",
"Unexpected child for DATUM `%s'.\n",
poNode->GetValue() );
return OGRERR_CORRUPT_DATA;
}
}
if( !bGotSpheroid )
{
CPLDebug( "OGRSpatialReference::Validate",
"No SPHEROID child in DATUM.\n" );
return OGRERR_CORRUPT_DATA;
}
}
/* -------------------------------------------------------------------- */
/* If this is projected, try to validate the detailed set of */
/* parameters used for the projection. */
/* -------------------------------------------------------------------- */
OGRErr eErr;
eErr = ValidateProjection(poRoot);
if( eErr != OGRERR_NONE )
return eErr;
/* -------------------------------------------------------------------- */
/* Final check. */
/* -------------------------------------------------------------------- */
if( EQUAL(poRoot->GetValue(),"GEOCCS") )
return OGRERR_UNSUPPORTED_SRS;
return OGRERR_NONE;
}
/**
* \brief Validate the current PROJECTION's arguments.
*
* @return OGRERR_NONE if the PROJECTION's arguments validate, an error code
* otherwise
*/
OGRErr OGRSpatialReference::ValidateProjection(OGR_SRSNode *poRoot)
{
OGR_SRSNode *poPROJCS = poRoot->GetNode( "PROJCS" );
if( poPROJCS == NULL )
return OGRERR_NONE;
if( poPROJCS->GetNode( "PROJECTION" ) == NULL )
{
CPLDebug( "OGRSpatialReference::Validate",
"PROJCS does not have PROJECTION subnode." );
return OGRERR_CORRUPT_DATA;
}
/* -------------------------------------------------------------------- */
/* Find the matching group in the proj and parms table. */
/* -------------------------------------------------------------------- */
const char *pszProjection;
int iOffset;
pszProjection = poPROJCS->GetNode("PROJECTION")->GetChild(0)->GetValue();
for( iOffset = 0;
papszProjWithParms[iOffset] != NULL
&& !EQUAL(papszProjWithParms[iOffset],pszProjection); )
{
while( papszProjWithParms[iOffset] != NULL )
iOffset++;
iOffset++;
}
if( papszProjWithParms[iOffset] == NULL )
return OGRERR_UNSUPPORTED_SRS;
iOffset++;
/* -------------------------------------------------------------------- */
/* Check all parameters, and verify they are in the permitted */
/* list. */
/* -------------------------------------------------------------------- */
int iNode;
for( iNode = 0; iNode < poPROJCS->GetChildCount(); iNode++ )
{
OGR_SRSNode *poParm = poPROJCS->GetChild(iNode);
int i;
const char *pszParmName;
if( !EQUAL(poParm->GetValue(),"PARAMETER") )
continue;
pszParmName = poParm->GetChild(0)->GetValue();
for( i = iOffset; papszProjWithParms[i] != NULL; i++ )
{
if( EQUAL(papszProjWithParms[i],pszParmName) )
break;
}
/* This parameter is not an exact match, is it an alias? */
if( papszProjWithParms[i] == NULL )
{
for( i = iOffset; papszProjWithParms[i] != NULL; i++ )
{
if( IsAliasFor(papszProjWithParms[i],pszParmName) )
break;
}
if( papszProjWithParms[i] == NULL )
{
CPLDebug( "OGRSpatialReference::Validate",
"PARAMETER %s for PROJECTION %s is not permitted.",
pszParmName, pszProjection );
return OGRERR_CORRUPT_DATA;
}
else
{
CPLDebug( "OGRSpatialReference::Validate",
"PARAMETER %s for PROJECTION %s is an alias for %s.",
pszParmName, pszProjection,
papszProjWithParms[i] );
return OGRERR_CORRUPT_DATA;
}
}
}
return OGRERR_NONE;
}
OGRBoolean CheckCitationKeyForStatePlaneUTM(GTIF* hGTIF, GTIFDefn* psDefn, OGRSpatialReference* poSRS, OGRBoolean* pLinearUnitIsSet)
{
if( !hGTIF || !psDefn || !poSRS )
return FALSE;
/* -------------------------------------------------------------------- */
/* For ESRI builds we are interested in maximizing PE */
/* compatability, but generally we prefer to use EPSG */
/* definitions of the coordinate system if PCS is defined. */
/* -------------------------------------------------------------------- */
#if !defined(ESRI_BUILD)
if( psDefn->PCS != KvUserDefined )
return FALSE;
#endif
char szCTString[512];
szCTString[0] = '\0';
/* Check units */
char units[32];
units[0] = '\0';
OGRBoolean hasUnits = FALSE;
if( GTIFKeyGet( hGTIF, GTCitationGeoKey, szCTString, 0, sizeof(szCTString) ) )
{
CPLString osLCCT = szCTString;
osLCCT.tolower();
if( strstr(osLCCT,"us") && strstr(osLCCT,"survey")
&& (strstr(osLCCT,"feet") || strstr(osLCCT,"foot")) )
strcpy(units, "us_survey_feet");
else if(strstr(osLCCT, "linear_feet")
|| strstr(osLCCT, "linear_foot")
|| strstr(osLCCT, "international"))
strcpy(units, "international_feet");
else if( strstr(osLCCT,"meter") )
strcpy(units, "meters");
if (strlen(units) > 0)
hasUnits = TRUE;
if( strstr( szCTString, "Projection Name = ") && strstr( szCTString, "_StatePlane_"))
{
const char *pStr = strstr( szCTString, "Projection Name = ") + strlen("Projection Name = ");
const char* pReturn = strchr( pStr, '\n');
char CSName[128];
strncpy(CSName, pStr, pReturn-pStr);
CSName[pReturn-pStr] = '\0';
if( poSRS->ImportFromESRIStatePlaneWKT(0, NULL, NULL, 32767, CSName) == OGRERR_NONE )
{
// for some erdas citation keys, the state plane CS name is incomplete, the unit check is necessary.
OGRBoolean done = FALSE;
if (hasUnits)
{
OGR_SRSNode *poUnit = poSRS->GetAttrNode( "PROJCS|UNIT" );
if( poUnit != NULL && poUnit->GetChildCount() >= 2 )
{
CPLString unitName = poUnit->GetChild(0)->GetValue();
unitName.tolower();
if (strstr(units, "us_survey_feet"))
{
if (strstr(unitName, "us_survey_feet") || strstr(unitName, "foot_us") )
done = TRUE;
}
else if (strstr(units, "international_feet"))
{
if (strstr(unitName, "feet") || strstr(unitName, "foot"))
done = TRUE;
}
else if (strstr(units, "meters"))
{
if (strstr(unitName, "meter") )
done = TRUE;
}
}
}
if (done)
return TRUE;
}
}
}
if( !hasUnits )
{
char *pszUnitsName = NULL;
GTIFGetUOMLengthInfo( psDefn->UOMLength, &pszUnitsName, NULL );
if( pszUnitsName && strlen(pszUnitsName) > 0 )
{
CPLString osLCCT = pszUnitsName;
GTIFFreeMemory( pszUnitsName );
osLCCT.tolower();
if( strstr(osLCCT, "us") && strstr(osLCCT, "survey")
&& (strstr(osLCCT, "feet") || strstr(osLCCT, "foot")))
strcpy(units, "us_survey_feet");
else if(strstr(osLCCT, "feet") || strstr(osLCCT, "foot"))
strcpy(units, "international_feet");
else if(strstr(osLCCT, "meter"))
strcpy(units, "meters");
hasUnits = TRUE;
}
}
if (strlen(units) == 0)
strcpy(units, "meters");
/* check PCSCitationGeoKey if it exists */
szCTString[0] = '\0';
if( hGTIF && GTIFKeyGet( hGTIF, PCSCitationGeoKey, szCTString, 0, sizeof(szCTString)) )
{
/* For tif created by LEICA(ERDAS), ESRI state plane pe string was used and */
/* the state plane zone is given in PCSCitation. Therefore try Esri pe string first. */
SetCitationToSRS(hGTIF, szCTString, strlen(szCTString), PCSCitationGeoKey, poSRS, pLinearUnitIsSet);
const char *pcsName = poSRS->GetAttrValue("PROJCS");
const char *pStr = NULL;
if( (pcsName && (pStr = strstr(pcsName, "State Plane Zone ")) != NULL)
|| (pStr = strstr(szCTString, "State Plane Zone ")) != NULL )
{
pStr += strlen("State Plane Zone ");
int statePlaneZone = abs(atoi(pStr));
char nad[32];
strcpy(nad, "HARN");
if( strstr(szCTString, "NAD83") || strstr(szCTString, "NAD = 83") )
strcpy(nad, "NAD83");
else if( strstr(szCTString, "NAD27") || strstr(szCTString, "NAD = 27") )
strcpy(nad, "NAD27");
if( poSRS->ImportFromESRIStatePlaneWKT(statePlaneZone, (const char*)nad, (const char*)units, psDefn->PCS) == OGRERR_NONE )
return TRUE;
}
else if( pcsName && (pStr = strstr(pcsName, "UTM Zone ")) != NULL )
CheckUTM( psDefn, szCTString );
}
/* check state plane again to see if a pe string is available */
if( psDefn->PCS != KvUserDefined )
{
if( poSRS->ImportFromESRIStatePlaneWKT(0, NULL, (const char*)units, psDefn->PCS) == OGRERR_NONE )
return TRUE;
}
return FALSE;
}
int OGRProj4CT::InitializeNoLock( OGRSpatialReference * poSourceIn,
OGRSpatialReference * poTargetIn )
{
if( poSourceIn == NULL || poTargetIn == NULL )
return FALSE;
poSRSSource = poSourceIn->Clone();
poSRSTarget = poTargetIn->Clone();
bSourceLatLong = poSRSSource->IsGeographic();
bTargetLatLong = poSRSTarget->IsGeographic();
/* -------------------------------------------------------------------- */
/* Setup source and target translations to radians for lat/long */
/* systems. */
/* -------------------------------------------------------------------- */
dfSourceToRadians = DEG_TO_RAD;
bSourceWrap = FALSE;
dfSourceWrapLong = 0.0;
if( bSourceLatLong )
{
OGR_SRSNode *poUNITS = poSRSSource->GetAttrNode( "GEOGCS|UNIT" );
if( poUNITS && poUNITS->GetChildCount() >= 2 )
{
dfSourceToRadians = atof(poUNITS->GetChild(1)->GetValue());
if( dfSourceToRadians == 0.0 )
dfSourceToRadians = DEG_TO_RAD;
}
}
dfTargetFromRadians = RAD_TO_DEG;
bTargetWrap = FALSE;
dfTargetWrapLong = 0.0;
if( bTargetLatLong )
{
OGR_SRSNode *poUNITS = poSRSTarget->GetAttrNode( "GEOGCS|UNIT" );
if( poUNITS && poUNITS->GetChildCount() >= 2 )
{
double dfTargetToRadians = atof(poUNITS->GetChild(1)->GetValue());
if( dfTargetToRadians != 0.0 )
dfTargetFromRadians = 1 / dfTargetToRadians;
}
}
/* -------------------------------------------------------------------- */
/* Preliminary logic to setup wrapping. */
/* -------------------------------------------------------------------- */
const char *pszCENTER_LONG;
if( CPLGetConfigOption( "CENTER_LONG", NULL ) != NULL )
{
bSourceWrap = bTargetWrap = TRUE;
dfSourceWrapLong = dfTargetWrapLong =
atof(CPLGetConfigOption( "CENTER_LONG", "" ));
CPLDebug( "OGRCT", "Wrap at %g.", dfSourceWrapLong );
}
pszCENTER_LONG = poSRSSource->GetExtension( "GEOGCS", "CENTER_LONG" );
if( pszCENTER_LONG != NULL )
{
dfSourceWrapLong = atof(pszCENTER_LONG);
bSourceWrap = TRUE;
CPLDebug( "OGRCT", "Wrap source at %g.", dfSourceWrapLong );
}
pszCENTER_LONG = poSRSTarget->GetExtension( "GEOGCS", "CENTER_LONG" );
if( pszCENTER_LONG != NULL )
{
dfTargetWrapLong = atof(pszCENTER_LONG);
bTargetWrap = TRUE;
CPLDebug( "OGRCT", "Wrap target at %g.", dfTargetWrapLong );
}
bCheckWithInvertProj = CSLTestBoolean(CPLGetConfigOption( "CHECK_WITH_INVERT_PROJ", "NO" ));
/* The threshold is rather experimental... Works well with the cases of ticket #2305 */
if (bSourceLatLong)
dfThreshold = atof(CPLGetConfigOption( "THRESHOLD", ".1" ));
else
/* 1 works well for most projections, except for +proj=aeqd that requires */
/* a tolerance of 10000 */
dfThreshold = atof(CPLGetConfigOption( "THRESHOLD", "10000" ));
/* -------------------------------------------------------------------- */
/* Establish PROJ.4 handle for source if projection. */
/* -------------------------------------------------------------------- */
// OGRThreadSafety: The following variable is not a thread safety issue
// since the only issue is incrementing while accessing which at worse
// means debug output could be one "increment" late.
static int nDebugReportCount = 0;
char *pszSrcProj4Defn = NULL;
if( poSRSSource->exportToProj4( &pszSrcProj4Defn ) != OGRERR_NONE )
{
CPLFree( pszSrcProj4Defn );
return FALSE;
}
if( strlen(pszSrcProj4Defn) == 0 )
{
CPLFree( pszSrcProj4Defn );
CPLError( CE_Failure, CPLE_AppDefined,
"No PROJ.4 translation for source SRS, coordinate\n"
"transformation initialization has failed." );
return FALSE;
}
if (pjctx)
psPJSource = pfn_pj_init_plus_ctx( pjctx, pszSrcProj4Defn );
else
psPJSource = pfn_pj_init_plus( pszSrcProj4Defn );
if( psPJSource == NULL )
{
if( pjctx != NULL)
{
int pj_errno = pfn_pj_ctx_get_errno(pjctx);
/* pfn_pj_strerrno not yet thread-safe in PROJ 4.8.0 */
CPLMutexHolderD(&hPROJMutex);
CPLError( CE_Failure, CPLE_NotSupported,
"Failed to initialize PROJ.4 with `%s'.\n%s",
pszSrcProj4Defn, pfn_pj_strerrno(pj_errno) );
}
else if( pfn_pj_get_errno_ref != NULL
&& pfn_pj_strerrno != NULL )
{
int *p_pj_errno = pfn_pj_get_errno_ref();
CPLError( CE_Failure, CPLE_NotSupported,
"Failed to initialize PROJ.4 with `%s'.\n%s",
pszSrcProj4Defn, pfn_pj_strerrno(*p_pj_errno) );
}
else
{
CPLError( CE_Failure, CPLE_NotSupported,
"Failed to initialize PROJ.4 with `%s'.\n",
pszSrcProj4Defn );
}
}
if( nDebugReportCount < 10 )
CPLDebug( "OGRCT", "Source: %s", pszSrcProj4Defn );
if( psPJSource == NULL )
{
CPLFree( pszSrcProj4Defn );
return FALSE;
}
/* -------------------------------------------------------------------- */
/* Establish PROJ.4 handle for target if projection. */
/* -------------------------------------------------------------------- */
char *pszDstProj4Defn = NULL;
if( poSRSTarget->exportToProj4( &pszDstProj4Defn ) != OGRERR_NONE )
{
CPLFree( pszSrcProj4Defn );
CPLFree( pszDstProj4Defn );
return FALSE;
}
if( strlen(pszDstProj4Defn) == 0 )
{
CPLFree( pszSrcProj4Defn );
CPLFree( pszDstProj4Defn );
CPLError( CE_Failure, CPLE_AppDefined,
"No PROJ.4 translation for destination SRS, coordinate\n"
"transformation initialization has failed." );
return FALSE;
}
if (pjctx)
psPJTarget = pfn_pj_init_plus_ctx( pjctx, pszDstProj4Defn );
else
psPJTarget = pfn_pj_init_plus( pszDstProj4Defn );
if( psPJTarget == NULL )
CPLError( CE_Failure, CPLE_NotSupported,
"Failed to initialize PROJ.4 with `%s'.",
pszDstProj4Defn );
if( nDebugReportCount < 10 )
{
CPLDebug( "OGRCT", "Target: %s", pszDstProj4Defn );
nDebugReportCount++;
}
if( psPJTarget == NULL )
{
CPLFree( pszSrcProj4Defn );
CPLFree( pszDstProj4Defn );
return FALSE;
}
/* Determine if we really have a transformation to do */
bIdentityTransform = (strcmp(pszSrcProj4Defn, pszDstProj4Defn) == 0);
/* In case of identity transform, under the following conditions, */
/* we can also avoid transforming from deegrees <--> radians. */
if( bIdentityTransform && bSourceLatLong && !bSourceWrap &&
bTargetLatLong && !bTargetWrap &&
abs(dfSourceToRadians * dfTargetFromRadians - 1.0) < 1e-10 )
{
/*bSourceLatLong = FALSE;
bTargetLatLong = FALSE;*/
}
CPLFree( pszSrcProj4Defn );
CPLFree( pszDstProj4Defn );
return TRUE;
}
int OGRProj4CT::InitializeNoLock( OGRSpatialReference * poSourceIn,
OGRSpatialReference * poTargetIn )
{
if( poSourceIn == NULL || poTargetIn == NULL )
return FALSE;
poSRSSource = poSourceIn->Clone();
poSRSTarget = poTargetIn->Clone();
bSourceLatLong = CPL_TO_BOOL(poSRSSource->IsGeographic());
bTargetLatLong = CPL_TO_BOOL(poSRSTarget->IsGeographic());
/* -------------------------------------------------------------------- */
/* Setup source and target translations to radians for lat/long */
/* systems. */
/* -------------------------------------------------------------------- */
dfSourceToRadians = DEG_TO_RAD;
bSourceWrap = false;
dfSourceWrapLong = 0.0;
if( bSourceLatLong )
{
OGR_SRSNode *poUNITS = poSRSSource->GetAttrNode( "GEOGCS|UNIT" );
if( poUNITS && poUNITS->GetChildCount() >= 2 )
{
dfSourceToRadians = CPLAtof(poUNITS->GetChild(1)->GetValue());
if( dfSourceToRadians == 0.0 )
dfSourceToRadians = DEG_TO_RAD;
}
}
dfTargetFromRadians = RAD_TO_DEG;
bTargetWrap = false;
dfTargetWrapLong = 0.0;
if( bTargetLatLong )
{
OGR_SRSNode *poUNITS = poSRSTarget->GetAttrNode( "GEOGCS|UNIT" );
if( poUNITS && poUNITS->GetChildCount() >= 2 )
{
double dfTargetToRadians = CPLAtof(poUNITS->GetChild(1)->GetValue());
if( dfTargetToRadians != 0.0 )
dfTargetFromRadians = 1 / dfTargetToRadians;
}
}
/* -------------------------------------------------------------------- */
/* Preliminary logic to setup wrapping. */
/* -------------------------------------------------------------------- */
if( CPLGetConfigOption( "CENTER_LONG", NULL ) != NULL )
{
bSourceWrap = true;
bTargetWrap = true;
dfSourceWrapLong = dfTargetWrapLong =
CPLAtof(CPLGetConfigOption( "CENTER_LONG", "" ));
CPLDebug( "OGRCT", "Wrap at %g.", dfSourceWrapLong );
}
const char *pszCENTER_LONG =
poSRSSource->GetExtension( "GEOGCS", "CENTER_LONG" );
if( pszCENTER_LONG != NULL )
{
dfSourceWrapLong = CPLAtof(pszCENTER_LONG);
bSourceWrap = true;
CPLDebug( "OGRCT", "Wrap source at %g.", dfSourceWrapLong );
}
pszCENTER_LONG = poSRSTarget->GetExtension( "GEOGCS", "CENTER_LONG" );
if( pszCENTER_LONG != NULL )
{
dfTargetWrapLong = CPLAtof(pszCENTER_LONG);
bTargetWrap = true;
CPLDebug( "OGRCT", "Wrap target at %g.", dfTargetWrapLong );
}
bCheckWithInvertProj =
CPLTestBool(CPLGetConfigOption( "CHECK_WITH_INVERT_PROJ", "NO" ));
// The threshold is experimental. Works well with the cases of ticket #2305.
if( bSourceLatLong )
dfThreshold = CPLAtof(CPLGetConfigOption( "THRESHOLD", ".1" ));
else
// 1 works well for most projections, except for +proj=aeqd that
// requires a tolerance of 10000.
dfThreshold = CPLAtof(CPLGetConfigOption( "THRESHOLD", "10000" ));
// OGRThreadSafety: The following variable is not a thread safety issue
// since the only issue is incrementing while accessing which at worse
// means debug output could be one "increment" late.
static int nDebugReportCount = 0;
char *pszSrcProj4Defn = NULL;
if( poSRSSource->exportToProj4( &pszSrcProj4Defn ) != OGRERR_NONE )
{
CPLFree( pszSrcProj4Defn );
return FALSE;
}
if( strlen(pszSrcProj4Defn) == 0 )
{
CPLFree( pszSrcProj4Defn );
CPLError( CE_Failure, CPLE_AppDefined,
"No PROJ.4 translation for source SRS, coordinate\n"
"transformation initialization has failed." );
return FALSE;
}
char *pszDstProj4Defn = NULL;
if( poSRSTarget->exportToProj4( &pszDstProj4Defn ) != OGRERR_NONE )
{
CPLFree( pszSrcProj4Defn );
CPLFree( pszDstProj4Defn );
return FALSE;
}
if( strlen(pszDstProj4Defn) == 0 )
{
CPLFree( pszSrcProj4Defn );
CPLFree( pszDstProj4Defn );
CPLError( CE_Failure, CPLE_AppDefined,
"No PROJ.4 translation for destination SRS, coordinate\n"
"transformation initialization has failed." );
return FALSE;
}
/* -------------------------------------------------------------------- */
/* Optimization to avoid useless nadgrids evaluation. */
/* For example when converting between WGS84 and WebMercator */
/* -------------------------------------------------------------------- */
if( pszSrcProj4Defn[strlen(pszSrcProj4Defn)-1] == ' ' )
pszSrcProj4Defn[strlen(pszSrcProj4Defn)-1] = 0;
if( pszDstProj4Defn[strlen(pszDstProj4Defn)-1] == ' ' )
pszDstProj4Defn[strlen(pszDstProj4Defn)-1] = 0;
char* pszNeedle = strstr(pszSrcProj4Defn, " ");
if( pszNeedle )
memmove(pszNeedle, pszNeedle + 1, strlen(pszNeedle + 1)+1);
pszNeedle = strstr(pszDstProj4Defn, " ");
if( pszNeedle )
memmove(pszNeedle, pszNeedle + 1, strlen(pszNeedle + 1)+1);
if( (strstr(pszSrcProj4Defn, "+datum=WGS84") != NULL ||
strstr(pszSrcProj4Defn, "+ellps=WGS84 +towgs84=0,0,0,0,0,0,0 ") != NULL) &&
strstr(pszDstProj4Defn, "+nadgrids=@null ") != NULL &&
strstr(pszDstProj4Defn, "+towgs84") == NULL )
{
char* pszDst = strstr(pszSrcProj4Defn, "+towgs84=0,0,0,0,0,0,0 ");
if( pszDst != NULL )
{
char *pszSrc = pszDst + strlen("+towgs84=0,0,0,0,0,0,0 ");
memmove(pszDst, pszSrc, strlen(pszSrc)+1);
}
else
{
memcpy(strstr(pszSrcProj4Defn, "+datum=WGS84"), "+ellps", 6);
}
pszDst = strstr(pszDstProj4Defn, "+nadgrids=@null ");
char *pszSrc = pszDst + strlen("+nadgrids=@null ");
memmove(pszDst, pszSrc, strlen(pszSrc)+1);
pszDst = strstr(pszDstProj4Defn, "+wktext ");
if( pszDst )
{
pszSrc = pszDst + strlen("+wktext ");
memmove(pszDst, pszSrc, strlen(pszSrc)+1);
}
//bWGS84ToWebMercator =
// strcmp(pszSrcProj4Defn, "+proj=longlat +ellps=WGS84 +no_defs") == 0 &&
// strcmp(pszDstProj4Defn, "+proj=merc +a=6378137 +b=6378137 +lat_ts=0.0 +lon_0=0.0 +x_0=0.0 +y_0=0 +k=1.0 +units=m +no_defs") == 0;
}
else
if( (strstr(pszDstProj4Defn, "+datum=WGS84") != NULL ||
strstr(pszDstProj4Defn, "+ellps=WGS84 +towgs84=0,0,0,0,0,0,0 ") != NULL) &&
strstr(pszSrcProj4Defn, "+nadgrids=@null ") != NULL &&
strstr(pszSrcProj4Defn, "+towgs84") == NULL )
{
char* pszDst = strstr(pszDstProj4Defn, "+towgs84=0,0,0,0,0,0,0 ");
if( pszDst != NULL)
{
char* pszSrc = pszDst + strlen("+towgs84=0,0,0,0,0,0,0 ");
memmove(pszDst, pszSrc, strlen(pszSrc)+1);
}
else
memcpy(strstr(pszDstProj4Defn, "+datum=WGS84"), "+ellps", 6);
pszDst = strstr(pszSrcProj4Defn, "+nadgrids=@null ");
char* pszSrc = pszDst + strlen("+nadgrids=@null ");
memmove(pszDst, pszSrc, strlen(pszSrc)+1);
pszDst = strstr(pszSrcProj4Defn, "+wktext ");
if( pszDst )
{
pszSrc = pszDst + strlen("+wktext ");
memmove(pszDst, pszSrc, strlen(pszSrc)+1);
}
bWebMercatorToWGS84 =
strcmp(pszDstProj4Defn,
"+proj=longlat +ellps=WGS84 +no_defs") == 0 &&
strcmp(pszSrcProj4Defn,
"+proj=merc +a=6378137 +b=6378137 +lat_ts=0.0 +lon_0=0.0 "
"+x_0=0.0 +y_0=0 +k=1.0 +units=m +no_defs") == 0;
}
/* -------------------------------------------------------------------- */
/* Establish PROJ.4 handle for source if projection. */
/* -------------------------------------------------------------------- */
if( !bWebMercatorToWGS84 )
{
if (pjctx)
psPJSource = pfn_pj_init_plus_ctx( pjctx, pszSrcProj4Defn );
else
psPJSource = pfn_pj_init_plus( pszSrcProj4Defn );
if( psPJSource == NULL )
{
if( pjctx != NULL)
{
int l_pj_errno = pfn_pj_ctx_get_errno(pjctx);
/* pfn_pj_strerrno not yet thread-safe in PROJ 4.8.0 */
CPLMutexHolderD(&hPROJMutex);
CPLError( CE_Failure, CPLE_NotSupported,
"Failed to initialize PROJ.4 with `%s'.\n%s",
pszSrcProj4Defn, pfn_pj_strerrno(l_pj_errno) );
}
else if( pfn_pj_get_errno_ref != NULL
&& pfn_pj_strerrno != NULL )
{
int *p_pj_errno = pfn_pj_get_errno_ref();
CPLError( CE_Failure, CPLE_NotSupported,
"Failed to initialize PROJ.4 with `%s'.\n%s",
pszSrcProj4Defn, pfn_pj_strerrno(*p_pj_errno) );
}
else
{
CPLError( CE_Failure, CPLE_NotSupported,
"Failed to initialize PROJ.4 with `%s'.\n",
pszSrcProj4Defn );
}
}
}
if( nDebugReportCount < 10 )
CPLDebug( "OGRCT", "Source: %s", pszSrcProj4Defn );
if( !bWebMercatorToWGS84 && psPJSource == NULL )
{
CPLFree( pszSrcProj4Defn );
CPLFree( pszDstProj4Defn );
return FALSE;
}
/* -------------------------------------------------------------------- */
/* Establish PROJ.4 handle for target if projection. */
/* -------------------------------------------------------------------- */
if( !bWebMercatorToWGS84 )
{
if (pjctx)
psPJTarget = pfn_pj_init_plus_ctx( pjctx, pszDstProj4Defn );
else
psPJTarget = pfn_pj_init_plus( pszDstProj4Defn );
if( psPJTarget == NULL )
CPLError( CE_Failure, CPLE_NotSupported,
"Failed to initialize PROJ.4 with `%s'.",
pszDstProj4Defn );
}
if( nDebugReportCount < 10 )
{
CPLDebug( "OGRCT", "Target: %s", pszDstProj4Defn );
nDebugReportCount++;
}
if( !bWebMercatorToWGS84 && psPJTarget == NULL )
{
CPLFree( pszSrcProj4Defn );
CPLFree( pszDstProj4Defn );
return FALSE;
}
/* Determine if we really have a transformation to do */
bIdentityTransform = strcmp(pszSrcProj4Defn, pszDstProj4Defn) == 0;
#if 0
/* In case of identity transform, under the following conditions, */
/* we can also avoid transforming from degrees <--> radians. */
if( bIdentityTransform && bSourceLatLong && !bSourceWrap &&
bTargetLatLong && !bTargetWrap &&
fabs(dfSourceToRadians * dfTargetFromRadians - 1.0) < 1e-10 )
{
// bSourceLatLong = false;
// bTargetLatLong = false;
}
#endif
CPLFree( pszSrcProj4Defn );
CPLFree( pszDstProj4Defn );
return TRUE;
}
bool rspfOgcWktTranslator::toOssimKwl( const rspfString& wktString,
rspfKeywordlist &kwl,
const char *prefix)const
{
static const char MODULE[] = "rspfOgcWktTranslator::toOssimKwl";
if(traceDebug())
{
rspfNotify(rspfNotifyLevel_DEBUG) << MODULE << " entered...\n";
}
const char* wkt = wktString.c_str();
OGRSpatialReferenceH hSRS = NULL;
rspfDpt falseEastingNorthing;
hSRS = OSRNewSpatialReference(NULL);
if( OSRImportFromWkt( hSRS, (char **) &wkt ) != OGRERR_NONE )
{
OSRDestroySpatialReference( hSRS );
return false;
}
rspfString rspfProj = "";
const char* epsg_code = OSRGetAttrValue( hSRS, "AUTHORITY", 1 );
if(traceDebug())
{
rspfNotify(rspfNotifyLevel_DEBUG)
<< "epsg_code: " << (epsg_code?epsg_code:"null") << "\n";
}
const char* units = NULL;
OGR_SRSNode* node = ((OGRSpatialReference *)hSRS)->GetRoot();
int nbChild = node->GetChildCount();
for (int i = 0; i < nbChild; i++)
{
OGR_SRSNode* curChild = node->GetChild(i);
if (strcmp(curChild->GetValue(), "UNIT") == 0)
{
units = curChild->GetChild(0)->GetValue();
}
}
if(traceDebug())
{
rspfNotify(rspfNotifyLevel_DEBUG)
<< "units: " << (units?units:"null") << "\n";
}
rspfString rspf_units;
bool bGeog = OSRIsGeographic(hSRS);
if ( bGeog == false )
{
rspf_units = "meters";
if ( units != NULL )
{
rspfString s = units;
s.downcase();
if( ( s == rspfString("us survey foot") ) ||
( s == rspfString("u.s. foot") ) ||
( s == rspfString("foot_us") ) )
{
rspf_units = "us_survey_feet";
}
else if( s == rspfString("degree") )
{
rspf_units = "degrees";
}
else if( ( s == rspfString("meter") ) ||
( s == rspfString("metre") ) )
{
rspf_units = "meters";
}
}
}
else
{
rspf_units = "degrees";
}
if(traceDebug())
{
rspfNotify(rspfNotifyLevel_DEBUG)
<< "rspf_units: " << rspf_units << "\n";
}
if (epsg_code)
{
rspfString epsg_spec ("EPSG:");
epsg_spec += rspfString::toString(epsg_code);
rspfProjection* proj = rspfEpsgProjectionFactory::instance()->createProjection(epsg_spec);
if (proj)
rspfProj = proj->getClassName();
delete proj;
}
if(rspfProj == "")
{
const char* pszProjection = OSRGetAttrValue( hSRS, "PROJECTION", 0 );
if(pszProjection)
{
rspfProj = wktToOssimProjection(pszProjection);
}
else
{
rspfString localCs = OSRGetAttrValue( hSRS, "LOCAL_CS", 0 );
localCs = localCs.upcase();
if(localCs == "GREATBRITAIN_GRID")
{
rspfProj = "rspfBngProjection";
}
else if (rspf_units.contains("degree"))
{
rspfProj = "rspfEquDistCylProjection";
}
}
}
if(rspfProj == "rspfEquDistCylProjection" )
rspf_units = "degrees";
kwl.add(prefix, rspfKeywordNames::UNITS_KW, rspf_units, true);
if (traceDebug())
{
rspfNotify(rspfNotifyLevel_DEBUG)
<< MODULE << "DEBUG:"
<< "\nrspfProj = " << rspfProj << endl;
}
kwl.add(prefix, rspfKeywordNames::TYPE_KW, rspfProj.c_str(), true);
falseEastingNorthing.x = OSRGetProjParm(hSRS, SRS_PP_FALSE_EASTING, 0.0, NULL);
falseEastingNorthing.y = OSRGetProjParm(hSRS, SRS_PP_FALSE_NORTHING, 0.0, NULL);
if (epsg_code)
{
kwl.add(prefix, rspfKeywordNames::PCS_CODE_KW, epsg_code, true);
}
if(rspfProj == "rspfBngProjection")
{
kwl.add(prefix,
rspfKeywordNames::TYPE_KW,
"rspfBngProjection",
true);
}
else if(rspfProj == "rspfCylEquAreaProjection")
{
kwl.add(prefix,
rspfKeywordNames::STD_PARALLEL_1_KW,
OSRGetProjParm(hSRS, SRS_PP_STANDARD_PARALLEL_1, 0.0, NULL),
true);
kwl.add(prefix,
rspfKeywordNames::ORIGIN_LATITUDE_KW,
OSRGetProjParm(hSRS, SRS_PP_STANDARD_PARALLEL_1, 0.0, NULL),
true);
rspfUnitType units =
static_cast<rspfUnitType>(rspfUnitTypeLut::instance()->
getEntryNumber(rspf_units.c_str()));
if ( units == RSPF_METERS ||
units == RSPF_FEET ||
units == RSPF_US_SURVEY_FEET )
{
kwl.add(prefix,
rspfKeywordNames::FALSE_EASTING_NORTHING_KW,
falseEastingNorthing.toString(),
true);
kwl.add(prefix,
rspfKeywordNames::FALSE_EASTING_NORTHING_UNITS_KW,
rspf_units,
true);
}
}
else if(rspfProj == "rspfEquDistCylProjection")
{
kwl.add(prefix,
rspfKeywordNames::TYPE_KW,
"rspfEquDistCylProjection",
true);
rspfUnitType units =
static_cast<rspfUnitType>(rspfUnitTypeLut::instance()->
getEntryNumber(rspf_units.c_str()));
if ( units == RSPF_METERS ||
units == RSPF_FEET ||
units == RSPF_US_SURVEY_FEET )
{
kwl.add(prefix,
rspfKeywordNames::FALSE_EASTING_NORTHING_KW,
falseEastingNorthing.toString(),
true);
kwl.add(prefix,
rspfKeywordNames::FALSE_EASTING_NORTHING_UNITS_KW,
rspf_units,
true);
}
kwl.add(prefix,
rspfKeywordNames::ORIGIN_LATITUDE_KW,
OSRGetProjParm(hSRS, SRS_PP_LATITUDE_OF_ORIGIN, 0.0, NULL),
true);
kwl.add(prefix,
rspfKeywordNames::CENTRAL_MERIDIAN_KW,
OSRGetProjParm(hSRS, SRS_PP_CENTRAL_MERIDIAN, 0.0, NULL),
true);
}
else if( (rspfProj == "rspfLambertConformalConicProjection") ||
(rspfProj == "rspfAlbersProjection") )
{
kwl.add(prefix,
rspfKeywordNames::TYPE_KW,
rspfProj.c_str(),
true);
kwl.add(prefix,
rspfKeywordNames::FALSE_EASTING_NORTHING_KW,
falseEastingNorthing.toString(),
true);
kwl.add(prefix,
rspfKeywordNames::FALSE_EASTING_NORTHING_UNITS_KW,
rspf_units,
true);
kwl.add(prefix,
rspfKeywordNames::ORIGIN_LATITUDE_KW,
OSRGetProjParm(hSRS, SRS_PP_LATITUDE_OF_ORIGIN, 0.0, NULL),
true);
kwl.add(prefix,
rspfKeywordNames::CENTRAL_MERIDIAN_KW,
OSRGetProjParm(hSRS, SRS_PP_CENTRAL_MERIDIAN, 0.0, NULL),
true);
kwl.add(prefix,
rspfKeywordNames::STD_PARALLEL_1_KW,
OSRGetProjParm(hSRS, SRS_PP_STANDARD_PARALLEL_1, 0.0, NULL),
true);
kwl.add(prefix,
rspfKeywordNames::STD_PARALLEL_2_KW,
OSRGetProjParm(hSRS, SRS_PP_STANDARD_PARALLEL_2, 0.0, NULL),
true);
}
else if(rspfProj == "rspfMercatorProjection")
{
kwl.add(prefix,
rspfKeywordNames::TYPE_KW,
"rspfMercatorProjection",
true);
kwl.add(prefix,
rspfKeywordNames::ORIGIN_LATITUDE_KW,
OSRGetProjParm(hSRS, SRS_PP_LATITUDE_OF_ORIGIN, 0.0, NULL),
true);
kwl.add(prefix,
rspfKeywordNames::CENTRAL_MERIDIAN_KW,
OSRGetProjParm(hSRS, SRS_PP_CENTRAL_MERIDIAN, 0.0, NULL),
true);
kwl.add(prefix,
rspfKeywordNames::FALSE_EASTING_NORTHING_KW,
falseEastingNorthing.toString(),
true);
kwl.add(prefix,
rspfKeywordNames::FALSE_EASTING_NORTHING_UNITS_KW,
rspf_units,
true);
}
else if(rspfProj == "rspfSinusoidalProjection")
{
kwl.add(prefix,
rspfKeywordNames::TYPE_KW,
"rspfSinusoidalProjection",
true);
kwl.add(prefix,
rspfKeywordNames::CENTRAL_MERIDIAN_KW,
OSRGetProjParm(hSRS, SRS_PP_CENTRAL_MERIDIAN, 0.0, NULL),
true);
kwl.add(prefix,
rspfKeywordNames::FALSE_EASTING_NORTHING_KW,
falseEastingNorthing.toString(),
true);
kwl.add(prefix,
rspfKeywordNames::FALSE_EASTING_NORTHING_UNITS_KW,
rspf_units,
true);
}
else if(rspfProj == "rspfTransMercatorProjection")
{
int bNorth;
int nZone = OSRGetUTMZone( hSRS, &bNorth );
if( nZone != 0 )
{
kwl.add(prefix,
rspfKeywordNames::TYPE_KW,
"rspfUtmProjection",
true);
kwl.add(prefix,
rspfKeywordNames::ZONE_KW,
nZone,
true);
if( bNorth )
{
kwl.add(prefix, rspfKeywordNames::HEMISPHERE_KW, "N", true);
}
else
{
kwl.add(prefix, rspfKeywordNames::HEMISPHERE_KW, "S", true);
}
}
else
{
kwl.add(prefix,
rspfKeywordNames::TYPE_KW,
"rspfTransMercatorProjection",
true);
kwl.add(prefix,
rspfKeywordNames::SCALE_FACTOR_KW,
OSRGetProjParm(hSRS, SRS_PP_SCALE_FACTOR, 1.0, NULL),
true);
kwl.add(prefix,
rspfKeywordNames::ORIGIN_LATITUDE_KW,
OSRGetProjParm(hSRS, SRS_PP_LATITUDE_OF_ORIGIN, 0.0, NULL),
true);
kwl.add(prefix,
rspfKeywordNames::CENTRAL_MERIDIAN_KW,
OSRGetProjParm(hSRS, SRS_PP_CENTRAL_MERIDIAN, 0.0, NULL),
true);
kwl.add(prefix,
rspfKeywordNames::FALSE_EASTING_NORTHING_KW,
falseEastingNorthing.toString(),
true);
kwl.add(prefix,
rspfKeywordNames::FALSE_EASTING_NORTHING_UNITS_KW,
rspf_units,
true);
}
}
else
{
if (traceDebug())
{
rspfNotify(rspfNotifyLevel_DEBUG)
<< "rspfOgcWktTranslator::toOssimKwl DEBUG:\n"
<< "Projection conversion to RSPF not supported !!!!!!!!!\n"
<< "Please send the following string to the development staff\n"
<< "to be added to the transaltion to RSPF\n"
<< wkt << endl;
}
return false;
}
const char *datum = OSRGetAttrValue( hSRS, "DATUM", 0 );
rspfString oDatum = "WGE";
if( datum )
{
oDatum = wktToOssimDatum(datum);
if(oDatum == "")
{
oDatum = "WGE";
}
}
kwl.add(prefix, rspfKeywordNames::DATUM_KW, oDatum, true);
OSRDestroySpatialReference( hSRS );
if (traceDebug())
{
rspfNotify(rspfNotifyLevel_DEBUG)
<< MODULE << " exit status = true"
<< std::endl;
}
return true;
}