OGRErr OGRWarpedLayer::CreateFeature( OGRFeature *poFeature )
{
OGRGeometry* poOrigGeom = poFeature->GetGeometryRef();
OGRErr eErr;
if( poOrigGeom != NULL )
{
if( m_poReversedCT == NULL )
return OGRERR_FAILURE;
OGRGeometry* poTransformedGeom = poOrigGeom->clone();
if( poTransformedGeom->transform(m_poReversedCT) != OGRERR_NONE )
{
delete poTransformedGeom;
return OGRERR_FAILURE;
}
poFeature->StealGeometry();
poFeature->SetGeometryDirectly(poTransformedGeom);
eErr = m_poDecoratedLayer->CreateFeature(poFeature);
poFeature->StealGeometry();
poFeature->SetGeometryDirectly(poOrigGeom);
delete poTransformedGeom;
}
else
eErr = m_poDecoratedLayer->CreateFeature(poFeature);
return eErr;
}
OGRErr GTMWaypointLayer::CreateFeature (OGRFeature *poFeature)
{
FILE* fp = poDS->getOutputFP();
if (fp == 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 waypoints layer." );
return OGRERR_FAILURE;
}
if (NULL != poCT)
{
poGeom = poGeom->clone();
poGeom->transform( poCT );
}
switch( poGeom->getGeometryType() )
{
case wkbPoint:
case wkbPoint25D:
{
OGRPoint* point = (OGRPoint*)poGeom;
double lat = point->getY();
double lon = point->getX();
CheckAndFixCoordinatesValidity(lat, lon);
poDS->checkBounds((float)lat, (float)lon);
writeDouble(fp, lat);
writeDouble(fp, lon);
float altitude = 0.0;
if (poGeom->getGeometryType() == wkbPoint25D)
altitude = (float) point->getZ();
WriteFeatureAttributes(poFeature, altitude);
break;
}
default:
{
CPLError( CE_Failure, CPLE_NotSupported,
"Geometry type of `%s' not supported for 'waypoint' element.\n",
OGRGeometryTypeToName(poGeom->getGeometryType()) );
return OGRERR_FAILURE;
}
}
if (NULL != poCT)
delete poGeom;
return OGRERR_NONE;
}
/*!
\brief Get feature (private)
\return pointer to OGRFeature
\return NULL not found
*/
OGRFeature *OGRVFKLayer::GetFeature(VFKFeature *poVFKFeature)
{
OGRGeometry *poGeom;
/* skip feature with unknown geometry type */
if (poVFKFeature->GetGeometryType() == wkbUnknown)
return NULL;
/* get features geometry */
poGeom = CreateGeometry(poVFKFeature);
if (poGeom != NULL)
poGeom->assignSpatialReference(poSRS);
/* does it satisfy the spatial query, if there is one? */
if (m_poFilterGeom != NULL && poGeom && !FilterGeometry(poGeom)) {
return NULL;
}
/* convert the whole feature into an OGRFeature */
OGRFeature *poOGRFeature = new OGRFeature(GetLayerDefn());
poOGRFeature->SetFID(poVFKFeature->GetFID());
// poOGRFeature->SetFID(++m_iNextFeature);
for (int iField = 0; iField < poDataBlock->GetPropertyCount(); iField++) {
if (poVFKFeature->GetProperty(iField)->IsNull())
continue;
OGRFieldType fType = poOGRFeature->GetDefnRef()->GetFieldDefn(iField)->GetType();
if (fType == OFTInteger)
poOGRFeature->SetField(iField,
poVFKFeature->GetProperty(iField)->GetValueI());
else if (fType == OFTReal)
poOGRFeature->SetField(iField,
poVFKFeature->GetProperty(iField)->GetValueD());
else
poOGRFeature->SetField(iField,
poVFKFeature->GetProperty(iField)->GetValueS());
}
/* test against the attribute query */
if (m_poAttrQuery != NULL &&
!m_poAttrQuery->Evaluate(poOGRFeature)) {
delete poOGRFeature;
return NULL;
}
if (poGeom)
poOGRFeature->SetGeometryDirectly(poGeom->clone());
return poOGRFeature;
}
/*!
\brief Get feature (private)
\return pointer to OGRFeature or NULL not found
*/
OGRFeature *OGRVFKLayer::GetFeature(IVFKFeature *poVFKFeature)
{
OGRGeometry *poGeom;
/* skip feature with unknown geometry type */
if (poVFKFeature->GetGeometryType() == wkbUnknown)
return NULL;
/* get features geometry */
poGeom = CreateGeometry(poVFKFeature);
if (poGeom != NULL)
poGeom->assignSpatialReference(poSRS);
/* does it satisfy the spatial query, if there is one? */
if (m_poFilterGeom != NULL && poGeom && !FilterGeometry(poGeom)) {
return NULL;
}
/* convert the whole feature into an OGRFeature */
OGRFeature *poOGRFeature = new OGRFeature(GetLayerDefn());
poOGRFeature->SetFID(poVFKFeature->GetFID());
// poOGRFeature->SetFID(++m_iNextFeature);
poVFKFeature->LoadProperties(poOGRFeature);
/* test against the attribute query */
if (m_poAttrQuery != NULL &&
!m_poAttrQuery->Evaluate(poOGRFeature)) {
delete poOGRFeature;
return NULL;
}
if (poGeom)
poOGRFeature->SetGeometryDirectly(poGeom->clone());
return poOGRFeature;
}
OGRErr GTMTrackLayer::ICreateFeature (OGRFeature *poFeature)
{
VSILFILE* fpTmpTrackpoints = poDS->getTmpTrackpointsFP();
if (fpTmpTrackpoints == nullptr)
return OGRERR_FAILURE;
VSILFILE* fpTmpTracks = poDS->getTmpTracksFP();
if (fpTmpTracks == nullptr)
return OGRERR_FAILURE;
OGRGeometry *poGeom = poFeature->GetGeometryRef();
if ( poGeom == nullptr )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Features without geometry not supported by GTM writer in "
"track layer." );
return OGRERR_FAILURE;
}
if (nullptr != poCT)
{
poGeom = poGeom->clone();
poGeom->transform( poCT );
}
switch( poGeom->getGeometryType() )
{
case wkbLineString:
case wkbLineString25D:
{
WriteFeatureAttributes(poFeature);
OGRLineString* line = poGeom->toLineString();
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 = static_cast<float>(line->getZ(i));
WriteTrackpoint( lat, lon, altitude, i==0 );
}
break;
}
case wkbMultiLineString:
case wkbMultiLineString25D:
{
for( auto&& line: poGeom->toMultiLineString() )
{
WriteFeatureAttributes(poFeature);
int n = line->getNumPoints();
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 = static_cast<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 (nullptr != poCT)
delete poGeom;
return OGRERR_FAILURE;
}
}
if (nullptr != poCT)
delete poGeom;
return OGRERR_NONE;
}
/**********************************************************************
* IMapInfoFile::CreateFeature()
*
* Standard OGR CreateFeature implementation. This method is used
* to create a new feature in current dataset
**********************************************************************/
OGRErr IMapInfoFile::CreateFeature(OGRFeature *poFeature)
{
TABFeature *poTABFeature;
OGRGeometry *poGeom;
OGRwkbGeometryType eGType;
OGRErr eErr;
TABPoint *poTABPointFeature = NULL;
TABRegion *poTABRegionFeature = NULL;
TABPolyline *poTABPolylineFeature = NULL;
/*-----------------------------------------------------------------
* MITAB won't accept new features unless they are in a type derived
* from TABFeature... so we have to do our best to map to the right
* feature type based on the geometry type.
*----------------------------------------------------------------*/
poGeom = poFeature->GetGeometryRef();
if( poGeom != NULL )
eGType = poGeom->getGeometryType();
else
eGType = wkbNone;
switch( wkbFlatten(eGType) )
{
/*-------------------------------------------------------------
* POINT
*------------------------------------------------------------*/
case wkbPoint:
poTABFeature = new TABPoint(poFeature->GetDefnRef());
if(poFeature->GetStyleString())
{
poTABPointFeature = (TABPoint*)poTABFeature;
poTABPointFeature->SetSymbolFromStyleString(
poFeature->GetStyleString());
}
break;
/*-------------------------------------------------------------
* REGION
*------------------------------------------------------------*/
case wkbPolygon:
case wkbMultiPolygon:
poTABFeature = new TABRegion(poFeature->GetDefnRef());
if(poFeature->GetStyleString())
{
poTABRegionFeature = (TABRegion*)poTABFeature;
poTABRegionFeature->SetPenFromStyleString(
poFeature->GetStyleString());
poTABRegionFeature->SetBrushFromStyleString(
poFeature->GetStyleString());
}
break;
/*-------------------------------------------------------------
* LINE/PLINE/MULTIPLINE
*------------------------------------------------------------*/
case wkbLineString:
case wkbMultiLineString:
poTABFeature = new TABPolyline(poFeature->GetDefnRef());
if(poFeature->GetStyleString())
{
poTABPolylineFeature = (TABPolyline*)poTABFeature;
poTABPolylineFeature->SetPenFromStyleString(
poFeature->GetStyleString());
}
break;
/*-------------------------------------------------------------
* Collection types that are not directly supported... convert
* to multiple features in output file through recursive calls.
*------------------------------------------------------------*/
case wkbGeometryCollection:
case wkbMultiPoint:
{
OGRErr eStatus = OGRERR_NONE;
int i;
OGRGeometryCollection *poColl = (OGRGeometryCollection*)poGeom;
OGRFeature *poTmpFeature = poFeature->Clone();
for (i=0; eStatus==OGRERR_NONE && i<poColl->getNumGeometries(); i++)
{
poTmpFeature->SetGeometry(poColl->getGeometryRef(i));
eStatus = CreateFeature(poTmpFeature);
}
delete poTmpFeature;
return eStatus;
}
break;
/*-------------------------------------------------------------
* Unsupported type.... convert to MapInfo geometry NONE
*------------------------------------------------------------*/
case wkbUnknown:
default:
poTABFeature = new TABFeature(poFeature->GetDefnRef());
break;
}
if( poGeom != NULL )
poTABFeature->SetGeometryDirectly(poGeom->clone());
for (int i=0; i< poFeature->GetDefnRef()->GetFieldCount(); i++)
{
poTABFeature->SetField(i,poFeature->GetRawFieldRef( i ));
}
eErr = CreateFeature(poTABFeature);
delete poTABFeature;
return eErr;
}
OGRErr OGRGFTTableLayer::ISetFeature( OGRFeature *poFeature )
{
GetLayerDefn();
if (!poDS->IsReadWrite())
{
CPLError(CE_Failure, CPLE_AppDefined,
"Operation not available in read-only mode");
return OGRERR_FAILURE;
}
if (osTableId.size() == 0)
{
CPLError(CE_Failure, CPLE_NotSupported,
"Cannot set feature to non-created table");
return OGRERR_FAILURE;
}
if (poDS->GetAccessToken().size() == 0)
{
CPLError(CE_Failure, CPLE_AppDefined,
"Operation not available in unauthenticated mode");
return OGRERR_FAILURE;
}
if (poFeature->GetFID() == OGRNullFID)
{
CPLError( CE_Failure, CPLE_AppDefined,
"FID required on features given to SetFeature()." );
return OGRERR_FAILURE;
}
CPLString osCommand;
osCommand += "UPDATE ";
osCommand += osTableId;
osCommand += " SET ";
int iField;
int nFieldCount = poFeatureDefn->GetFieldCount();
for(iField = 0; iField < nFieldCount + bHiddenGeometryField; iField++)
{
if (iField > 0)
osCommand += ", ";
if (iField == nFieldCount)
{
osCommand += EscapeAndQuote(GetGeometryColumn());
}
else
{
const char* pszFieldName =
poFeatureDefn->GetFieldDefn(iField)->GetNameRef();
osCommand += EscapeAndQuote(pszFieldName);
}
osCommand += " = ";
OGRGeometry* poGeom = poFeature->GetGeometryRef();
if (iGeometryField != iLatitudeField && iField == iGeometryField &&
(iField == nFieldCount || poGeom != NULL || !poFeature->IsFieldSet( iField )))
{
if (poGeom == NULL)
osCommand += "''";
else
{
char* pszKML;
if (poGeom->getSpatialReference() != NULL &&
!poGeom->getSpatialReference()->IsSame(poSRS))
{
OGRGeometry* poGeom4326 = poGeom->clone();
poGeom4326->transformTo(poSRS);
pszKML = poGeom4326->exportToKML();
delete poGeom4326;
}
else
{
pszKML = poGeom->exportToKML();
}
osCommand += "'";
osCommand += pszKML;
osCommand += "'";
CPLFree(pszKML);
}
continue;
}
if( !poFeature->IsFieldSet( iField ) )
{
osCommand += "''";
}
else
{
OGRFieldType eType = poFeatureDefn->GetFieldDefn(iField)->GetType();
if (eType != OFTInteger && eType != OFTReal)
{
CPLString osTmp;
const char* pszVal = poFeature->GetFieldAsString(iField);
if (!CPLIsUTF8(pszVal, -1))
{
static int bFirstTime = TRUE;
if (bFirstTime)
{
bFirstTime = FALSE;
CPLError(CE_Warning, CPLE_AppDefined,
"%s is not a valid UTF-8 string. Forcing it to ASCII.\n"
"This warning won't be issued anymore", pszVal);
}
else
{
CPLDebug("OGR", "%s is not a valid UTF-8 string. Forcing it to ASCII",
pszVal);
}
char* pszEscaped = CPLForceToASCII(pszVal, -1, '?');
osTmp = pszEscaped;
CPLFree(pszEscaped);
pszVal = osTmp.c_str();
}
osCommand += EscapeAndQuote(pszVal);
}
else
osCommand += poFeature->GetFieldAsString(iField);
}
}
osCommand += " WHERE ROWID = '";
osCommand += CPLSPrintf(CPL_FRMT_GIB, poFeature->GetFID());
osCommand += "'";
CPLHTTPResult * psResult = poDS->RunSQL(osCommand);
if (psResult == NULL)
{
CPLError(CE_Failure, CPLE_AppDefined, "Feature update failed (1)");
return OGRERR_FAILURE;
}
/* -------------------------------------------------------------------- */
/* We expect a response like "affected_rows\n1". */
/* -------------------------------------------------------------------- */
char* pszLine = (char*) psResult->pabyData;
if (pszLine == NULL ||
strncmp(pszLine, "affected_rows\n1\n", 16) != 0 ||
psResult->pszErrBuf != NULL)
{
CPLDebug( "GFT", "%s/%s",
pszLine ? pszLine : "null",
psResult->pszErrBuf ? psResult->pszErrBuf : "null");
CPLError(CE_Failure, CPLE_AppDefined, "Feature update failed (2)");
CPLHTTPDestroyResult(psResult);
return OGRERR_FAILURE;
}
CPLHTTPDestroyResult(psResult);
return OGRERR_NONE;
}
OGRErr OGRGFTTableLayer::ICreateFeature( OGRFeature *poFeature )
{
if (!poDS->IsReadWrite())
{
CPLError(CE_Failure, CPLE_AppDefined,
"Operation not available in read-only mode");
return OGRERR_FAILURE;
}
if (osTableId.size() == 0)
{
CreateTableIfNecessary();
if (osTableId.size() == 0)
{
CPLError(CE_Failure, CPLE_NotSupported,
"Cannot add feature to non-created table");
return OGRERR_FAILURE;
}
}
if (poDS->GetAccessToken().size() == 0)
{
CPLError(CE_Failure, CPLE_AppDefined,
"Operation not available in unauthenticated mode");
return OGRERR_FAILURE;
}
CPLString osCommand;
osCommand += "INSERT INTO ";
osCommand += osTableId;
osCommand += " (";
int iField;
int nFieldCount = poFeatureDefn->GetFieldCount();
for(iField = 0; iField < nFieldCount; iField++)
{
if (iField > 0)
osCommand += ", ";
const char* pszFieldName =
poFeatureDefn->GetFieldDefn(iField)->GetNameRef();
osCommand += EscapeAndQuote(pszFieldName);
}
if (bHiddenGeometryField)
{
if (iField > 0)
osCommand += ", ";
osCommand += EscapeAndQuote(GetGeometryColumn());
}
osCommand += ") VALUES (";
for(iField = 0; iField < nFieldCount + bHiddenGeometryField; iField++)
{
if (iField > 0)
osCommand += ", ";
OGRGeometry* poGeom = poFeature->GetGeometryRef();
/* If there's a geometry, let's use it in priority over the textual */
/* content of the field. */
if (iGeometryField != iLatitudeField && iField == iGeometryField &&
(iField == nFieldCount || poGeom != NULL || !poFeature->IsFieldSet( iField )))
{
if (poGeom == NULL)
osCommand += "''";
else
{
char* pszKML;
if (poGeom->getSpatialReference() != NULL &&
!poGeom->getSpatialReference()->IsSame(poSRS))
{
OGRGeometry* poGeom4326 = poGeom->clone();
poGeom4326->transformTo(poSRS);
pszKML = poGeom4326->exportToKML();
delete poGeom4326;
}
else
{
pszKML = poGeom->exportToKML();
}
osCommand += "'";
osCommand += pszKML;
osCommand += "'";
CPLFree(pszKML);
}
continue;
}
if( !poFeature->IsFieldSet( iField ) )
{
osCommand += "''";
}
else
{
OGRFieldType eType = poFeatureDefn->GetFieldDefn(iField)->GetType();
if (eType != OFTInteger && eType != OFTReal)
{
CPLString osTmp;
const char* pszVal = poFeature->GetFieldAsString(iField);
if (!CPLIsUTF8(pszVal, -1))
{
static int bFirstTime = TRUE;
if (bFirstTime)
{
bFirstTime = FALSE;
CPLError(CE_Warning, CPLE_AppDefined,
"%s is not a valid UTF-8 string. Forcing it to ASCII.\n"
"This warning won't be issued anymore", pszVal);
}
else
{
CPLDebug("OGR", "%s is not a valid UTF-8 string. Forcing it to ASCII",
pszVal);
}
char* pszEscaped = CPLForceToASCII(pszVal, -1, '?');
osTmp = pszEscaped;
CPLFree(pszEscaped);
pszVal = osTmp.c_str();
}
osCommand += EscapeAndQuote(pszVal);
}
else
osCommand += poFeature->GetFieldAsString(iField);
}
}
osCommand += ")";
//CPLDebug("GFT", "%s", osCommand.c_str());
if (bInTransaction)
{
nFeaturesInTransaction ++;
if (nFeaturesInTransaction > 1)
osTransaction += "; ";
osTransaction += osCommand;
return OGRERR_NONE;
}
CPLHTTPResult * psResult = poDS->RunSQL(osCommand);
if (psResult == NULL)
{
CPLError(CE_Failure, CPLE_AppDefined, "Feature creation failed");
return OGRERR_FAILURE;
}
char* pszLine = (char*) psResult->pabyData;
if (pszLine == NULL ||
strncmp(pszLine, "rowid", 5) != 0 ||
psResult->pszErrBuf != NULL)
{
CPLError(CE_Failure, CPLE_AppDefined, "Feature creation failed");
CPLHTTPDestroyResult(psResult);
return OGRERR_FAILURE;
}
pszLine = OGRGFTGotoNextLine(pszLine);
if (pszLine == NULL)
{
CPLError(CE_Failure, CPLE_AppDefined, "Feature creation failed");
CPLHTTPDestroyResult(psResult);
return OGRERR_FAILURE;
}
char* pszNextLine = OGRGFTGotoNextLine(pszLine);
if (pszNextLine)
pszNextLine[-1] = 0;
CPLDebug("GFT", "Feature id = %s", pszLine);
int nFID = atoi(pszLine);
if (strcmp(CPLSPrintf("%d", nFID), pszLine) == 0)
poFeature->SetFID(nFID);
CPLHTTPDestroyResult(psResult);
return OGRERR_NONE;
}
OGRErr GTMTrackLayer::CreateFeature (OGRFeature *poFeature)
{
FILE* fpTmpTrackpoints = poDS->getTmpTrackpointsFP();
if (fpTmpTrackpoints == NULL)
return CE_Failure;
FILE* 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;
}
int main (int argc, const char * argv[]) {
if (argc < 2 || argc > 3 || strcmp(argv[1], "-h") == 0 || strcmp(argv[1], "--help") == 0) {
std::cout << "=== prepair Help ===\n" << std::endl;
std::cout << "Usage: triface 'POLYGON(...)'" << std::endl;
std::cout << "OR" << std::endl;
std::cout << "Usage: triface -f infile.txt (infile.txt must contain one WKT on the 1st line)" << std::endl;
return 0;
}
// Read input
unsigned int bufferSize = 10000000;
char *inputWKT = (char *)malloc(bufferSize*sizeof(char *));
for (int argNum = 1; argNum < argc; ++argNum) {
if (strcmp(argv[argNum], "-f") == 0) {
if (argNum + 1 <= argc - 1 && argv[argNum+1][0] != '-') {
std::ifstream infile(argv[argNum+1], std::ifstream::in);
infile.getline(inputWKT, bufferSize);
++argNum;
} else {
std::cerr << "Error: Missing input file name." << std::endl;
return 1;
}
}
else
strcpy(inputWKT, argv[argNum]);
}
// std::cout << "Processing: " << inputWKT << std::endl;
OGRGeometry *geometry;
OGRGeometryFactory::createFromWkt(&inputWKT, NULL, &geometry);
if (geometry == NULL) {
std::cout << "Error: WKT is not valid" << std::endl;
return 1;
}
if (geometry->getGeometryType() != wkbPolygon25D) {
std::cout << "Error: input geometry is not a 3D polygon" << std::endl;
return 1;
}
//-- project to proper plane + get flattened geometry
int proj = get_projection_plane(geometry);
OGRGeometry *flatgeom = geometry->clone();
if (proj == 1) {
OGRPolygon *polygon = (OGRPolygon *)flatgeom;
for (int curp = 0; curp < polygon->getExteriorRing()->getNumPoints(); ++curp)
polygon->getExteriorRing()->setPoint(curp, polygon->getExteriorRing()->getX(curp), polygon->getExteriorRing()->getZ(curp), 0);
for (int currentRing = 0; currentRing < polygon->getNumInteriorRings(); ++currentRing) {
for (int curp = 0; curp < polygon->getInteriorRing(currentRing)->getNumPoints(); ++curp)
polygon->getInteriorRing(currentRing)->setPoint(curp, polygon->getInteriorRing(currentRing)->getX(curp), polygon->getInteriorRing(currentRing)->getZ(curp), 0);
}
}
else if (proj == 0) {
OGRPolygon *polygon = (OGRPolygon *)geometry;
for (int curp = 0; curp < polygon->getExteriorRing()->getNumPoints(); ++curp)
polygon->getExteriorRing()->setPoint(curp, polygon->getExteriorRing()->getY(curp), polygon->getExteriorRing()->getZ(curp), 0);
for (int currentRing = 0; currentRing < polygon->getNumInteriorRings(); ++currentRing) {
for (int curp = 0; curp < polygon->getInteriorRing(currentRing)->getNumPoints(); ++curp)
polygon->getInteriorRing(currentRing)->setPoint(curp, polygon->getInteriorRing(currentRing)->getY(curp), polygon->getInteriorRing(currentRing)->getZ(curp), 0);
}
}
flatgeom->flattenTo2D();
// std::cout << "geom: " << geometry->getCoordinateDimension() << std::endl;
// std::cout << "flatgeom: " << flatgeom->getCoordinateDimension() << std::endl;
//-- check if flattened geometry is valid
if (flatgeom->IsValid() == FALSE) {
std::cout << "Error: input polygon is not valid." << std::endl;
return 1;
}
if (proj == 2) {
Triangulationxy triangulation;
triangulateandtag_xy(geometry, triangulation);
for (Triangulationxy::Finite_faces_iterator currentFace = triangulation.finite_faces_begin(); currentFace != triangulation.finite_faces_end(); ++currentFace) {
std::cout << "--triangle--" << std::endl;
Point p = currentFace->vertex(0)->point();
std::cout << p.x() << ", " << p.y() << ", " << p.z() << std::endl;
p = currentFace->vertex(1)->point();
std::cout << p.x() << ", " << p.y() << ", " << p.z() << std::endl;
p = currentFace->vertex(2)->point();
std::cout << p.x() << ", " << p.y() << ", " << p.z() << std::endl;
}
}
else if (proj == 1) {
Triangulationxz triangulation;
triangulateandtag_xz(geometry, triangulation);
for (Triangulationxz::Finite_faces_iterator currentFace = triangulation.finite_faces_begin(); currentFace != triangulation.finite_faces_end(); ++currentFace) {
std::cout << "--triangle--" << std::endl;
Point p = currentFace->vertex(0)->point();
std::cout << p.x() << ", " << p.y() << ", " << p.z() << std::endl;
p = currentFace->vertex(1)->point();
std::cout << p.x() << ", " << p.y() << ", " << p.z() << std::endl;
p = currentFace->vertex(2)->point();
std::cout << p.x() << ", " << p.y() << ", " << p.z() << std::endl;
}
}
else { //-- proj == 0
Triangulationyz triangulation;
triangulateandtag_yz(geometry, triangulation);
for (Triangulationyz::Finite_faces_iterator currentFace = triangulation.finite_faces_begin(); currentFace != triangulation.finite_faces_end(); ++currentFace) {
std::cout << "--triangle--" << std::endl;
Point p = currentFace->vertex(0)->point();
std::cout << p.x() << ", " << p.y() << ", " << p.z() << std::endl;
p = currentFace->vertex(1)->point();
std::cout << p.x() << ", " << p.y() << ", " << p.z() << std::endl;
p = currentFace->vertex(2)->point();
std::cout << p.x() << ", " << p.y() << ", " << p.z() << std::endl;
}
}
return 0;
}
int Raster::VectortoRaster(const char * sVectorSourcePath,
const char * sRasterOutputPath,
const char * psFieldName,
RasterMeta * p_rastermeta ){
OGRRegisterAll();
OGRDataSource * pDSVectorInput;
pDSVectorInput = OGRSFDriverRegistrar::Open( sVectorSourcePath, FALSE );
if (pDSVectorInput == NULL)
return INPUT_FILE_ERROR;
OGRLayer * poLayer = pDSVectorInput->GetLayer(0);
// The type of the field.
OGRFeature * feat1 = poLayer->GetFeature(0);
int fieldindex = feat1->GetFieldIndex(psFieldName);
OGRFieldType fieldType = feat1->GetFieldDefnRef(fieldindex)->GetType();
OGRFeature::DestroyFeature( feat1 );
// The data type we're going to use for the file
GDALDataType OutputDataType = GDT_Byte;
// Handle field types according to their type:
switch (fieldType) {
case OFTString:
CSVWriteVectorValues(poLayer, psFieldName, sRasterOutputPath);
break;
case OFTInteger:
break;
case OFTReal:
OutputDataType = GDT_Float64;
default:
throw RasterManagerException(VECTOR_FIELD_NOT_VALID, "Type of field not recognized.");
break;
}
// Get our projection and set the rastermeta accordingly.
// -------------------------------------------------------
char *pszWKT = NULL;
OGRSpatialReference* poSRS = poLayer->GetSpatialRef();
poSRS->exportToWkt(&pszWKT);
p_rastermeta->SetProjectionRef(pszWKT);
CPLFree(pszWKT);
OSRDestroySpatialReference(poSRS);
// Create the output dataset for writing
GDALDataset * pDSOutput = CreateOutputDS(sRasterOutputPath, p_rastermeta);
// Create a list of burn-in values
// -------------------------------------------------------
std::vector<OGRGeometryH> ogrBurnGeometries;
std::vector<double> dBurnValues;
poLayer->ResetReading();
OGRFeature * ogrFeat = poLayer->GetNextFeature(); // <------- DRMEM!!! UNADDRESSABLE ACCESS of freed memory
while( ogrFeat != NULL ){
OGRGeometry * ogrGeom = ogrFeat->GetGeometryRef();
// No geometry found. Move along.
if( ogrGeom == NULL )
{
OGRFeature::DestroyFeature( ogrFeat );
continue;
}
OGRGeometry * geoClone = ogrGeom->clone(); // <------- DRMEM!!! UNADDRESSABLE ACCESS of freed memory AND LEAK 20 direct bytes
// Push a clone of this geometry onto the list of shapes to burn
ogrBurnGeometries.push_back( (OGRGeometryH) geoClone );
if (fieldType == OFTString){
// If it's a string type we burn the FID. The value is then placed in a CSV file
dBurnValues.push_back( ogrFeat->GetFID() );
}
else {
// If it's a float type or a byte type we write it directly.
dBurnValues.push_back( ogrFeat->GetFieldAsDouble(psFieldName) );
}
// GetNextFeature() creates a clone so we must delete it.
OGRFeature::DestroyFeature( ogrFeat ); // <------- DRMEM!!! UNADDRESSABLE ACCESS beyond heap bounds:
ogrFeat = poLayer->GetNextFeature(); // <------- DRMEM!!! UNADDRESSABLE ACCESS of freed memory
}
// Do the Actual Burning of Geometries.
// -------------------------------------------------------
int band = 1;
char **papszRasterizeOptions = NULL;
papszRasterizeOptions =
CSLSetNameValue( papszRasterizeOptions, "ALL_TOUCHED", "TRUE" );
CPLErr err = GDALRasterizeGeometries( pDSOutput, 1, &band,
ogrBurnGeometries.size(),
&(ogrBurnGeometries[0]),
NULL, NULL,
&(dBurnValues[0]),
NULL,
NULL, NULL );
if (err) { }
ogrBurnGeometries.clear();
dBurnValues.clear();
// Done. Calculate stats and close file
CalculateStats(pDSOutput->GetRasterBand(1));
CSLDestroy(papszRasterizeOptions);
GDALClose(pDSOutput);
pDSVectorInput->Release(); // <------- DRMEM!!! UNADDRESSABLE ACCESS beyond heap bounds:
//This is where the implementation actually goes
return PROCESS_OK;
}
/*!
\brief Set feature geometry
Also checks if given geometry is valid
\param poGeom pointer to OGRGeometry
\param ftype geometry VFK type
\return TRUE on valid feature or otherwise FALSE
*/
bool IVFKFeature::SetGeometry(OGRGeometry *poGeom, const char *ftype)
{
m_bGeometry = TRUE;
delete m_paGeom;
m_paGeom = NULL;
m_bValid = TRUE;
if (!poGeom) {
return m_bValid;
}
/* check empty geometries */
if (m_nGeometryType == wkbNone && poGeom->IsEmpty()) {
CPLError(CE_Warning, CPLE_AppDefined,
"%s: empty geometry fid = " CPL_FRMT_GIB,
m_poDataBlock->GetName(), m_nFID);
m_bValid = FALSE;
}
/* check coordinates */
if (m_nGeometryType == wkbPoint) {
double x, y;
x = ((OGRPoint *) poGeom)->getX();
y = ((OGRPoint *) poGeom)->getY();
if (x > -430000 || x < -910000 ||
y > -930000 || y < -1230000) {
CPLDebug("OGR-VFK", "%s: invalid point fid = " CPL_FRMT_GIB,
m_poDataBlock->GetName(), m_nFID);
m_bValid = FALSE;
}
}
/* check degenerated polygons */
if (m_nGeometryType == wkbPolygon) {
OGRLinearRing *poRing;
poRing = ((OGRPolygon *) poGeom)->getExteriorRing();
if (!poRing || poRing->getNumPoints() < 3) {
CPLDebug("OGR-VFK", "%s: invalid polygon fid = " CPL_FRMT_GIB,
m_poDataBlock->GetName(), m_nFID);
m_bValid = FALSE;
}
}
if (m_bValid) {
if (ftype) {
OGRPoint pt;
OGRGeometry *poGeomCurved;
OGRCircularString poGeomString;
poGeomCurved = NULL;
if (EQUAL(ftype, "15") || EQUAL(ftype, "16")) { /* -> circle or arc */
int npoints;
npoints = ((OGRLineString *) poGeom)->getNumPoints();
for (int i = 0; i < npoints; i++) {
((OGRLineString *) poGeom)->getPoint(i, &pt);
poGeomString.addPoint(&pt);
}
if (EQUAL(ftype, "15")) {
/* compute center and radius of a circle */
double x[3], y[3];
double m1, n1, m2, n2, c1, c2, mx;
double c_x, c_y;
for (int i = 0; i < npoints; i++) {
((OGRLineString *) poGeom)->getPoint(i, &pt);
x[i] = pt.getX();
y[i] = pt.getY();
}
m1 = (x[0] + x[1]) / 2.0;
n1 = (y[0] + y[1]) / 2.0;
m2 = (x[0] + x[2]) / 2.0;
n2 = (y[0] + y[2]) / 2.0;
c1 = (x[1] - x[0]) * m1 + (y[1] - y[0]) * n1;
c2 = (x[2] - x[0]) * m2 + (y[2] - y[0]) * n2;
mx = (x[1] - x[0]) * (y[2] - y[0]) + (y[1] - y[0]) * (x[0] - x[2]);
c_x = (c1 * (y[2] - y[0]) + c2 * (y[0] - y[1])) / mx;
c_y = (c1 * (x[0] - x[2]) + c2 * (x[1] - x[0])) / mx;
/* compute a new intermediate point */
pt.setX(c_x - (x[1] - c_x));
pt.setY(c_y - (y[1] - c_y));
poGeomString.addPoint(&pt);
/* add last point */
((OGRLineString *) poGeom)->getPoint(0, &pt);
poGeomString.addPoint(&pt);
}
}
else if (strlen(ftype) > 2 && EQUALN(ftype, "15", 2)) { /* -> circle with radius */
float r;
char s[3]; /* 15 */
r = 0;
if (2 != sscanf(ftype, "%s %f", s, &r) || r < 0) {
CPLDebug("OGR-VFK", "%s: invalid circle (unknown or negative radius) "
"fid = " CPL_FRMT_GIB, m_poDataBlock->GetName(), m_nFID);
m_bValid = FALSE;
}
else {
double c_x, c_y;
((OGRLineString *) poGeom)->getPoint(0, &pt);
c_x = pt.getX();
c_y = pt.getY();
/* define first point on a circle */
pt.setX(c_x + r);
pt.setY(c_y);
poGeomString.addPoint(&pt);
/* define second point on a circle */
pt.setX(c_x);
pt.setY(c_y + r);
poGeomString.addPoint(&pt);
/* define third point on a circle */
pt.setX(c_x - r);
pt.setY(c_y);
poGeomString.addPoint(&pt);
/* define fourth point on a circle */
pt.setX(c_x);
pt.setY(c_y - r);
poGeomString.addPoint(&pt);
/* define last point (=first) on a circle */
pt.setX(c_x + r);
pt.setY(c_y);
poGeomString.addPoint(&pt);
}
}
else if (EQUAL(ftype, "11")) { /* curve */
int npoints;
npoints = ((OGRLineString *) poGeom)->getNumPoints();
if (npoints > 2) { /* circular otherwise line string */
for (int i = 0; i < npoints; i++) {
((OGRLineString *) poGeom)->getPoint(i, &pt);
poGeomString.addPoint(&pt);
}
}
}
if (!poGeomString.IsEmpty())
poGeomCurved = poGeomString.CurveToLine();
if (poGeomCurved) {
int npoints;
npoints = ((OGRLineString *) poGeomCurved)->getNumPoints();
CPLDebug("OGR-VFK", "%s: curve (type=%s) to linestring (npoints=%d) fid = " CPL_FRMT_GIB,
m_poDataBlock->GetName(), ftype,
npoints, m_nFID);
if (npoints > 1)
m_paGeom = (OGRGeometry *) poGeomCurved->clone();
delete poGeomCurved;
}
}
if (!m_paGeom) {
/* check degenerated linestrings */
if (m_nGeometryType == wkbLineString) {
int npoints;
npoints = ((OGRLineString *) poGeom)->getNumPoints();
if (npoints < 2) {
CPLError(CE_Warning, CPLE_AppDefined,
"%s: invalid linestring (%d vertices) fid = " CPL_FRMT_GIB,
m_poDataBlock->GetName(), npoints, m_nFID);
m_bValid = FALSE;
}
}
if (m_bValid)
m_paGeom = (OGRGeometry *) poGeom->clone(); /* make copy */
}
}
return m_bValid;
}
OGRDataSource *AoIIntersection::intersectAoIWithLayers ( OGRDataSource *ogrSourceData, OGRPolygon *aoiPoly, IntersectionSummary *summary, const char *outFmt )
{
OGRDataSource *ogrIntersection = NULL;
// Spatial reference setup
// make a spatial reference for the area of interest polygon
OGRSpatialReference aoiRef;
aoiRef.SetWellKnownGeogCS( "WGS84" );
// make a spatial reference for the coord sys we will use to calculate area in acres - Albers USA equal area conic
bool acreageCalcAvailable = true;
char *aecWkt = "PROJCS[\"USA_Contiguous_Lambert_Conformal_Conic\",GEOGCS[\"GCS_North_American_1983\",DATUM[\"North_American_Datum_1983\",SPHEROID[\"GRS_1980\",6378137,298.257222101]],PRIMEM[\"Greenwich\",0],UNIT[\"Degree\",0.017453292519943295]],PROJECTION[\"Lambert_Conformal_Conic_2SP\"],PARAMETER[\"False_Easting\",0],PARAMETER[\"False_Northing\",0],PARAMETER[\"Central_Meridian\",-96],PARAMETER[\"Standard_Parallel_1\",33],PARAMETER[\"Standard_Parallel_2\",45],PARAMETER[\"Latitude_Of_Origin\",39],UNIT[\"Meter\",1],AUTHORITY[\"EPSG\",\"102004\"]]";
OGRSpatialReference aecRef;
OGRErr ogrErr = aecRef.importFromWkt( &aecWkt );
if ( ogrErr != OGRERR_NONE )
{
setError ( NO_SPATIAL_REFERENCE );
acreageCalcAvailable = false;
}
// begin creating the output data structure
// OGRDataSource is the root
ogrIntersection = buildIntersectionDataSource( outFmt );
if (! ogrIntersection )
{
setError( NO_OUTPUT_DATASOURCE );
return 0;
}
int acreIndex = 0, areaIndex = 0;
OGRFieldDefn *acreFldDefn = NULL, *areaPctFldDefn = NULL;
OGRFeatureDefn *featureDefn = buildFeatureDefinition( acreIndex, areaIndex, acreFldDefn, areaPctFldDefn );
// walk the layers in the input data
//
OGRLayer *inputLayer;
summary->numLayers = ogrSourceData->GetLayerCount();
for (int layerCt = 0; layerCt < summary->numLayers; ++layerCt)
{
inputLayer = ogrSourceData->GetLayer( layerCt );
if ( inputLayer == NULL )
{
setError( NO_INPUT_LAYER );
// clean up
delete ogrIntersection;
return 0;
}
// make a clone of aoi polygon to be manipulated
OGRPolygon *aoiClone = (OGRPolygon *)aoiPoly->clone();
if ( ! aoiClone )
{
setError( NO_AOI_CLONE );
// clean up
delete ogrIntersection;
return 0;
}
// ensure that the area of interest polygon is in the same spatial reference as the data layer
// find the spatial reference for the layer
OGRSpatialReference *dataRef = inputLayer->GetSpatialRef();
if ( dataRef )
{
OGRCoordinateTransformation *aoiTransform = OGRCreateCoordinateTransformation( &aoiRef, dataRef );
if( aoiTransform == NULL )
{
setError( NO_AOI_TRANSFORM );
// clean up
delete ogrIntersection;
delete aoiClone;
return 0;
}
aoiClone->transform( aoiTransform );
delete aoiTransform;
}
// find the transform from data layer's CS to Albers USA
// for acreage calculation
OGRCoordinateTransformation *aecTransform = NULL;
acreageCalcAvailable = false;
if ( dataRef )
{
aecTransform = OGRCreateCoordinateTransformation( dataRef, &aecRef );
if( aecTransform == NULL )
{
setError( NO_ACRE_TRANSFORM );
}
else
acreageCalcAvailable = true;
}
// the area enclosed by the AoI
// used for computing the percentage of the AoI intersected by polygons
summary->aoiArea = aoiClone->getExteriorRing()->get_Area();
// create a layer for outputting the intersecting polygons
OGRLayer *intersectionLayer = ogrIntersection->CreateLayer( inputLayer->GetLayerDefn()->GetName(), dataRef, wkbPolygon, 0 );
if ( ! intersectionLayer )
{
setError( NO_OUTPUT_LAYER );
// clean up
delete ogrIntersection;
delete aoiClone;
delete aecTransform;
return 0;
}
// add fields to layer
ogrErr = intersectionLayer->CreateField( acreFldDefn );
if ( ogrErr != OGRERR_NONE )
{
setError( NO_ACRE_FIELD );
// clean up
delete ogrIntersection;
delete aoiClone;
delete aecTransform;
return 0;
}
ogrErr = intersectionLayer->CreateField( areaPctFldDefn );
if ( ogrErr != OGRERR_NONE )
{
setError( NO_AREA_FIELD );
// clean up
delete ogrIntersection;
delete aoiClone;
delete aecTransform;
return 0;
}
// march through the geometry in the layer seeking overlap with area of interest
//
inputLayer->ResetReading();
OGRFeature *inputFeature;
while( (inputFeature = inputLayer->GetNextFeature()) != NULL )
{
// get the geometry part of the feature
OGRGeometry *inputGeometry = inputFeature->GetGeometryRef();
// test for polygon type - the only type we read
if( inputGeometry != NULL
&& wkbFlatten(inputGeometry->getGeometryType()) == wkbPolygon )
{
OGRPolygon *inputPolygon = (OGRPolygon *) inputGeometry;
++summary->totalInputPolyCt;
double inputPolyArea = inputPolygon->get_Area();
summary->totalInputPolyArea += inputPolyArea;
// here's the important test - does this polygon intersect our area of interest?
if (aoiClone->Intersects( inputGeometry ))
{
// generate a polygon that represents the intersection of the polygon with the AoI
OGRGeometry *intersectionGeometry = aoiClone->Intersection( inputGeometry );
if ( intersectionGeometry && wkbFlatten(intersectionGeometry->getGeometryType()) == wkbPolygon )
{
double intersectionArea = ((OGRPolygon *)intersectionGeometry)->get_Area();
summary->totalIntersectionArea += intersectionArea;
++summary->intersectionCt;
if (intersectionArea < inputPolyArea)
++summary->partEnclosedCt;
// create a feature with feature definition, add geometry to it and add it to our layer
OGRFeature *intersectionFeature = new OGRFeature( featureDefn );
if (! intersectionFeature )
{
setError( NO_OUTPUT_FEATURE );
// clean up
delete ogrIntersection;
delete aoiClone;
delete aecTransform;
return 0;
}
intersectionFeature->SetGeometry( intersectionGeometry );
double percentOfAoI = intersectionArea / summary->aoiArea;
intersectionFeature->SetField( areaIndex, percentOfAoI);
summary->totalPercentOfAoI += percentOfAoI;
if ( acreageCalcAvailable )
{
OGRGeometry *intersectionCopy = intersectionGeometry->clone();
if ( intersectionCopy )
{
ogrErr = intersectionCopy->transform( aecTransform );
if ( ogrErr != OGRERR_NONE )
{
setError( NO_ACRE_TRANSFORMATION );
// clean up
delete ogrIntersection;
delete aoiClone;
delete aecTransform;
delete intersectionCopy;
return 0;
}
// get area in known metric CS
double intersectionAcreage = ((OGRPolygon *)intersectionCopy)->get_Area();
// convert sq m to acres
double MetersToFt = 3.28084;
double SqFtPerAcre = 43560.0;
intersectionAcreage *= ((MetersToFt * MetersToFt) / SqFtPerAcre);
intersectionFeature->SetField( acreIndex, intersectionAcreage );
summary->totalIntersectionAcres += intersectionAcreage;
delete intersectionCopy;
}
else
{
setError( NO_ACRE_OBJECT );
// clean up
delete ogrIntersection;
delete aoiClone;
delete aecTransform;
return 0;
}
}
intersectionLayer->CreateFeature( intersectionFeature );
if ( ogrErr != OGRERR_NONE )
{
setError( NO_FEATURE_ADDED );
// clean up
delete ogrIntersection;
delete aoiClone;
delete aecTransform;
return 0;
}
}
else
{
}
}
}
else
{
printf( "no polygon geometry\n" );
}
OGRFeature::DestroyFeature( inputFeature );
}
delete aoiClone;
delete aecTransform;
}
return ogrIntersection;
}
OGRErr OGRGMLLayer::ICreateFeature( OGRFeature *poFeature )
{
int bIsGML3Output = poDS->IsGML3Output();
VSILFILE *fp = poDS->GetOutputFP();
int bWriteSpaceIndentation = poDS->WriteSpaceIndentation();
const char* pszPrefix = poDS->GetAppPrefix();
int bRemoveAppPrefix = poDS->RemoveAppPrefix();
if( !bWriter )
return OGRERR_FAILURE;
poFeature->FillUnsetWithDefault(TRUE, NULL);
if( !poFeature->Validate( OGR_F_VAL_ALL & ~OGR_F_VAL_GEOM_TYPE & ~OGR_F_VAL_ALLOW_NULL_WHEN_DEFAULT, TRUE ) )
return OGRERR_FAILURE;
if (bWriteSpaceIndentation)
VSIFPrintfL(fp, " ");
if (bIsGML3Output)
{
if( bRemoveAppPrefix )
poDS->PrintLine( fp, "<featureMember>" );
else
poDS->PrintLine( fp, "<%s:featureMember>", pszPrefix );
}
else
poDS->PrintLine( fp, "<gml:featureMember>" );
if( iNextGMLId == 0 )
{
bSameSRS = true;
for( int iGeomField = 1; iGeomField < poFeatureDefn->GetGeomFieldCount(); iGeomField++ )
{
OGRGeomFieldDefn *poFieldDefn0 = poFeatureDefn->GetGeomFieldDefn(0);
OGRGeomFieldDefn *poFieldDefn = poFeatureDefn->GetGeomFieldDefn(iGeomField);
OGRSpatialReference* poSRS0 = poFieldDefn0->GetSpatialRef();
OGRSpatialReference* poSRS = poFieldDefn->GetSpatialRef();
if( poSRS0 != NULL && poSRS == NULL )
bSameSRS = false;
else if( poSRS0 == NULL && poSRS != NULL )
bSameSRS = false;
else if( poSRS0 != NULL && poSRS != NULL &&
poSRS0 != poSRS && !poSRS0->IsSame(poSRS) )
{
bSameSRS = false;
}
}
}
if( poFeature->GetFID() == OGRNullFID )
poFeature->SetFID( iNextGMLId++ );
int nGMLIdIndex = -1;
if (bWriteSpaceIndentation)
VSIFPrintfL(fp, " ");
VSIFPrintfL(fp, "<");
if( !bRemoveAppPrefix )
VSIFPrintfL(fp, "%s:", pszPrefix);
if (bIsGML3Output)
{
nGMLIdIndex = poFeatureDefn->GetFieldIndex("gml_id");
if (nGMLIdIndex >= 0 && poFeature->IsFieldSet( nGMLIdIndex ) )
poDS->PrintLine( fp, "%s gml:id=\"%s\">",
poFeatureDefn->GetName(),
poFeature->GetFieldAsString(nGMLIdIndex) );
else
poDS->PrintLine( fp, "%s gml:id=\"%s." CPL_FRMT_GIB "\">",
poFeatureDefn->GetName(),
poFeatureDefn->GetName(),
poFeature->GetFID() );
}
else
{
nGMLIdIndex = poFeatureDefn->GetFieldIndex("fid");
if (bUseOldFIDFormat)
{
poDS->PrintLine( fp, "%s fid=\"F" CPL_FRMT_GIB "\">",
poFeatureDefn->GetName(),
poFeature->GetFID() );
}
else if (nGMLIdIndex >= 0 && poFeature->IsFieldSet( nGMLIdIndex ) )
{
poDS->PrintLine( fp, "%s fid=\"%s\">",
poFeatureDefn->GetName(),
poFeature->GetFieldAsString(nGMLIdIndex) );
}
else
{
poDS->PrintLine( fp, "%s fid=\"%s." CPL_FRMT_GIB "\">",
poFeatureDefn->GetName(),
poFeatureDefn->GetName(),
poFeature->GetFID() );
}
}
for( int iGeomField = 0; iGeomField < poFeatureDefn->GetGeomFieldCount(); iGeomField++ )
{
OGRGeomFieldDefn *poFieldDefn = poFeatureDefn->GetGeomFieldDefn(iGeomField);
// Write out Geometry - for now it isn't indented properly.
/* GML geometries don't like very much the concept of empty geometry */
OGRGeometry* poGeom = poFeature->GetGeomFieldRef(iGeomField);
if( poGeom != NULL && !poGeom->IsEmpty())
{
char *pszGeometry;
OGREnvelope3D sGeomBounds;
int nCoordDimension = poGeom->getCoordinateDimension();
poGeom->getEnvelope( &sGeomBounds );
if( bSameSRS )
poDS->GrowExtents( &sGeomBounds, nCoordDimension );
if (poGeom->getSpatialReference() == NULL && poFieldDefn->GetSpatialRef() != NULL)
poGeom->assignSpatialReference(poFieldDefn->GetSpatialRef());
if (bIsGML3Output && poDS->WriteFeatureBoundedBy())
{
bool bCoordSwap;
char* pszSRSName = GML_GetSRSName(poGeom->getSpatialReference(), poDS->IsLongSRSRequired(), &bCoordSwap);
char szLowerCorner[75], szUpperCorner[75];
if (bCoordSwap)
{
OGRMakeWktCoordinate(szLowerCorner, sGeomBounds.MinY, sGeomBounds.MinX, sGeomBounds.MinZ, nCoordDimension);
OGRMakeWktCoordinate(szUpperCorner, sGeomBounds.MaxY, sGeomBounds.MaxX, sGeomBounds.MaxZ, nCoordDimension);
}
else
{
OGRMakeWktCoordinate(szLowerCorner, sGeomBounds.MinX, sGeomBounds.MinY, sGeomBounds.MinZ, nCoordDimension);
OGRMakeWktCoordinate(szUpperCorner, sGeomBounds.MaxX, sGeomBounds.MaxY, sGeomBounds.MaxZ, nCoordDimension);
}
if (bWriteSpaceIndentation)
VSIFPrintfL(fp, " ");
poDS->PrintLine( fp, "<gml:boundedBy><gml:Envelope%s%s><gml:lowerCorner>%s</gml:lowerCorner><gml:upperCorner>%s</gml:upperCorner></gml:Envelope></gml:boundedBy>",
(nCoordDimension == 3) ? " srsDimension=\"3\"" : "",pszSRSName, szLowerCorner, szUpperCorner);
CPLFree(pszSRSName);
}
char** papszOptions = (bIsGML3Output) ? CSLAddString(NULL, "FORMAT=GML3") : NULL;
if (bIsGML3Output && !poDS->IsLongSRSRequired())
papszOptions = CSLAddString(papszOptions, "GML3_LONGSRS=NO");
const char* pszSRSDimensionLoc = poDS->GetSRSDimensionLoc();
if( pszSRSDimensionLoc != NULL )
papszOptions = CSLSetNameValue(papszOptions, "SRSDIMENSION_LOC", pszSRSDimensionLoc);
if (poDS->IsGML32Output())
{
if( poFeatureDefn->GetGeomFieldCount() > 1 )
papszOptions = CSLAddString(papszOptions,
CPLSPrintf("GMLID=%s.%s." CPL_FRMT_GIB,
poFeatureDefn->GetName(),
poFieldDefn->GetNameRef(),
poFeature->GetFID()));
else
papszOptions = CSLAddString(papszOptions,
CPLSPrintf("GMLID=%s.geom." CPL_FRMT_GIB,
poFeatureDefn->GetName(), poFeature->GetFID()));
}
if( !bIsGML3Output && OGR_GT_IsNonLinear(poGeom->getGeometryType()) )
{
OGRGeometry* poGeomTmp = OGRGeometryFactory::forceTo(
poGeom->clone(),OGR_GT_GetLinear(poGeom->getGeometryType()));
pszGeometry = poGeomTmp->exportToGML(papszOptions);
delete poGeomTmp;
}
else
pszGeometry = poGeom->exportToGML(papszOptions);
CSLDestroy(papszOptions);
if (bWriteSpaceIndentation)
VSIFPrintfL(fp, " ");
if( bRemoveAppPrefix )
poDS->PrintLine( fp, "<%s>%s</%s>",
poFieldDefn->GetNameRef(),
pszGeometry,
poFieldDefn->GetNameRef() );
else
poDS->PrintLine( fp, "<%s:%s>%s</%s:%s>",
pszPrefix, poFieldDefn->GetNameRef(),
pszGeometry,
pszPrefix, poFieldDefn->GetNameRef() );
CPLFree( pszGeometry );
}
}
// Write all "set" fields.
for( int iField = 0; iField < poFeatureDefn->GetFieldCount(); iField++ )
{
OGRFieldDefn *poFieldDefn = poFeatureDefn->GetFieldDefn( iField );
if( poFeature->IsFieldSet( iField ) && iField != nGMLIdIndex )
{
OGRFieldType eType = poFieldDefn->GetType();
if (eType == OFTStringList )
{
char ** papszIter = poFeature->GetFieldAsStringList( iField );
while( papszIter != NULL && *papszIter != NULL )
{
char *pszEscaped = OGRGetXML_UTF8_EscapedString( *papszIter );
GMLWriteField(poDS, fp, bWriteSpaceIndentation, pszPrefix,
bRemoveAppPrefix, poFieldDefn, pszEscaped);
CPLFree( pszEscaped );
papszIter ++;
}
}
else if (eType == OFTIntegerList )
{
int nCount = 0;
const int* panVals = poFeature->GetFieldAsIntegerList( iField, &nCount );
if( poFieldDefn->GetSubType() == OFSTBoolean )
{
for(int i = 0; i < nCount; i++)
{
/* 0 and 1 are OK, but the canonical representation is false and true */
GMLWriteField(poDS, fp, bWriteSpaceIndentation, pszPrefix,
bRemoveAppPrefix, poFieldDefn,
panVals[i] ? "true" : "false");
}
}
else
{
for(int i = 0; i < nCount; i++)
{
GMLWriteField(poDS, fp, bWriteSpaceIndentation, pszPrefix,
bRemoveAppPrefix, poFieldDefn,
CPLSPrintf("%d", panVals[i]));
}
}
}
else if (eType == OFTInteger64List )
{
int nCount = 0;
const GIntBig* panVals = poFeature->GetFieldAsInteger64List( iField, &nCount );
if( poFieldDefn->GetSubType() == OFSTBoolean )
{
for(int i = 0; i < nCount; i++)
{
/* 0 and 1 are OK, but the canonical representation is false and true */
GMLWriteField(poDS, fp, bWriteSpaceIndentation, pszPrefix,
bRemoveAppPrefix, poFieldDefn,
panVals[i] ? "true" : "false");
}
}
else
{
for(int i = 0; i < nCount; i++)
{
GMLWriteField(poDS, fp, bWriteSpaceIndentation, pszPrefix,
bRemoveAppPrefix, poFieldDefn,
CPLSPrintf(CPL_FRMT_GIB, panVals[i]));
}
}
}
else if (eType == OFTRealList )
{
int nCount = 0;
const double* padfVals = poFeature->GetFieldAsDoubleList( iField, &nCount );
for(int i = 0; i < nCount; i++)
{
char szBuffer[80];
CPLsnprintf( szBuffer, sizeof(szBuffer), "%.15g", padfVals[i]);
GMLWriteField(poDS, fp, bWriteSpaceIndentation, pszPrefix,
bRemoveAppPrefix, poFieldDefn, szBuffer);
}
}
else if ((eType == OFTInteger || eType == OFTInteger64) &&
poFieldDefn->GetSubType() == OFSTBoolean )
{
/* 0 and 1 are OK, but the canonical representation is false and true */
GMLWriteField(poDS, fp, bWriteSpaceIndentation, pszPrefix,
bRemoveAppPrefix, poFieldDefn,
(poFeature->GetFieldAsInteger(iField)) ? "true" : "false");
}
else
{
const char *pszRaw = poFeature->GetFieldAsString( iField );
char *pszEscaped = OGRGetXML_UTF8_EscapedString( pszRaw );
GMLWriteField(poDS, fp, bWriteSpaceIndentation, pszPrefix,
bRemoveAppPrefix, poFieldDefn, pszEscaped);
CPLFree( pszEscaped );
}
}
}
if (bWriteSpaceIndentation)
VSIFPrintfL(fp, " ");
if( bRemoveAppPrefix )
poDS->PrintLine( fp, "</%s>", poFeatureDefn->GetName() );
else
poDS->PrintLine( fp, "</%s:%s>", pszPrefix, poFeatureDefn->GetName() );
if (bWriteSpaceIndentation)
VSIFPrintfL(fp, " ");
if (bIsGML3Output)
{
if( bRemoveAppPrefix )
poDS->PrintLine( fp, "</featureMember>" );
else
poDS->PrintLine( fp, "</%s:featureMember>", pszPrefix );
}
else
poDS->PrintLine( fp, "</gml:featureMember>" );
return OGRERR_NONE;
}
bool SubrasterByVector(wxGISFeatureDatasetSPtr pSrcFeatureDataSet, wxGISRasterDatasetSPtr pSrcRasterDataSet, CPLString &szDstFolderPath, wxGxRasterFilter* pFilter, GDALDataType eOutputType, int nBandCount, int *panBandList, bool bUseCounter, int nCounterBegin, int nFieldNo, double dfOutResX, double dfOutResY, bool bCopyNodata, bool bSkipSourceMetadata, char** papszOptions, ITrackCancel* pTrackCancel)
{
//check if openned or/and open dataset
if(!pSrcFeatureDataSet->IsOpened())
{
if(!pSrcFeatureDataSet->Open(true))
{
if(pTrackCancel)
pTrackCancel->PutMessage(_("Source vector dataset open failed"), -1, enumGISMessageErr);
return false;
}
}
if(!pSrcRasterDataSet->IsOpened())
{
if(!pSrcRasterDataSet->Open(true))
{
if(pTrackCancel)
pTrackCancel->PutMessage(_("Source raster dataset open failed"), -1, enumGISMessageErr);
return false;
}
}
const OGRSpatialReferenceSPtr pSrsSRS = pSrcFeatureDataSet->GetSpatialReference();
const OGRSpatialReferenceSPtr pDstSRS = pSrcRasterDataSet->GetSpatialReference();
OGRCoordinateTransformation *poCT(NULL);
bool bSame = pSrsSRS == NULL || pDstSRS == NULL || pSrsSRS->IsSame(pDstSRS.get());
if( !bSame )
{
poCT = OGRCreateCoordinateTransformation( pSrsSRS.get(), pDstSRS.get() );
if(poCT == NULL)
{
const char* err = CPLGetLastErrorMsg();
wxString sWarn = wxString::Format(_("Create OGRCreateCoordinateTransformation failed! GDAL error: %s"), wxString(err, wxConvUTF8).c_str());
wxLogWarning(sWarn);
if(pTrackCancel)
pTrackCancel->PutMessage(sWarn, -1, enumGISMessageWarning);
}
}
IProgressor* pProgressor(NULL);
if(pTrackCancel)
{
pProgressor = pTrackCancel->GetProgressor();
pTrackCancel->PutMessage(wxString::Format(_("Start clip '%s' by geometry from '%s'"), wxString(pSrcRasterDataSet->GetPath(), wxConvUTF8).c_str(), wxString(pSrcFeatureDataSet->GetPath(), wxConvUTF8).c_str()), -1, enumGISMessageNorm);
}
int nCounter(0);
if(pProgressor)
pProgressor->SetRange(pSrcFeatureDataSet->GetFeatureCount());
/* -------------------------------------------------------------------- */
/* Build band list to translate */
/* -------------------------------------------------------------------- */
if( nBandCount == 0 )
{
nBandCount = pSrcRasterDataSet->GetBandCount();
if( nBandCount == 0 )
{
if(pTrackCancel)
pTrackCancel->PutMessage(_("Input file has no bands, and so cannot be translated."), -1, enumGISMessageErr);
return false;
}
panBandList = (int *) CPLMalloc(sizeof(int)*nBandCount);
for(size_t i = 0; i < nBandCount; ++i )
panBandList[i] = i + 1;
}
else
{
for(size_t i = 0; i < nBandCount; ++i )
{
if( panBandList[i] > pSrcRasterDataSet->GetBandCount() )
{
if(pTrackCancel)
pTrackCancel->PutMessage(wxString::Format(_("Band %d requested, but only bands 1 to %d available."), panBandList[i], pSrcRasterDataSet->GetBandCount()), -1, enumGISMessageErr);
return false;
}
}
}
bool bDefaultfilter(false);
if(pFilter == NULL)
{
pFilter = new wxGxRasterFilter(enumRasterTiff);
bDefaultfilter = true;
}
CPLString szDriver(pFilter->GetDriver().mb_str());
CPLString szExt(pFilter->GetExt().mb_str());
CPLString szBaseName = CPLGetBasename(pSrcRasterDataSet->GetPath());
GDALDriver* pDriver = (GDALDriver*)GDALGetDriverByName( szDriver );
if( pDriver == NULL )
{
if(pTrackCancel)
pTrackCancel->PutMessage(wxString::Format(_("Output driver '%s' not recognised."), szDriver.c_str()), -1, enumGISMessageErr);
if(bDefaultfilter)
wxDELETE(pFilter);
return false;
}
pSrcFeatureDataSet->Reset();
OGRFeatureSPtr pFeature;
size_t nNameCounter(nCounterBegin);
while((pFeature = pSrcFeatureDataSet->Next()) != NULL)
{
if(pTrackCancel && !pTrackCancel->Continue())
{
wxString sErr(_("Interrupted by user"));
CPLString sFullErr(sErr.mb_str());
CPLError( CE_Warning, CPLE_AppDefined, sFullErr );
if(pTrackCancel)
pTrackCancel->PutMessage(wxString(sFullErr, wxConvLocal), -1, enumGISMessageErr);
if(bDefaultfilter)
wxDELETE(pFilter);
return false;
}
OGRGeometry *pGeom = pFeature->GetGeometryRef();
if(wkbFlatten(pSrcFeatureDataSet->GetGeometryType()) != wkbUnknown && !pGeom)
continue;
OGRGeometry *pNewGeom(NULL);
if( !bSame && poCT )
{
if(pGeom)
{
pNewGeom = pGeom->clone();
OGRErr eErr = pNewGeom->transform(poCT);
if(eErr != OGRERR_NONE)
wxDELETE(pNewGeom);
}
}
else
pNewGeom = pGeom->clone();
OGREnvelope GeomEnv;
pNewGeom->getEnvelope(&GeomEnv);
OGREnvelope RasterEnv = pSrcRasterDataSet->GetEnvelope();
GeomEnv.Intersect(RasterEnv);
if(GeomEnv.IsInit())
{
CPLString szPath;
if(bUseCounter)
{
szPath.Printf("%s_%d", szBaseName.c_str(), nNameCounter++);
CPLString sNewName(CheckUniqName(szDstFolderPath, szPath, szExt).mb_str(wxConvUTF8));
szPath = CPLFormFilename(szDstFolderPath, sNewName, szExt);
}
else
{
CPLString szName = pFeature->GetFieldAsString(nFieldNo);
CPLString sNewName(CheckUniqName(szDstFolderPath, szName, szExt).mb_str(wxConvUTF8));
szPath = CPLFormFilename(szDstFolderPath, sNewName, szExt);
}
CreateSubRaster(pSrcRasterDataSet, GeomEnv, pNewGeom, pDriver, szPath, eOutputType, nBandCount, panBandList, dfOutResX, dfOutResY, bCopyNodata, bSkipSourceMetadata, papszOptions, pTrackCancel);
}
nCounter++;
if(pProgressor)
pProgressor->SetValue(nCounter);
}
if(poCT)
OCTDestroyCoordinateTransformation(poCT);
if(bDefaultfilter)
wxDELETE(pFilter);
return true;
}
