int main()
{
GDALAllRegister(); //register all the format drivers
cout << "GDAL All Registed!" << endl;
GDALDataset *poDS; //Data source
poDS = (GDALDataset*) GDALOpenEx("./beijing/road/Nbeijing_point.shp", GDAL_OF_VECTOR, NULL, NULL, NULL);
if(poDS == NULL)
{
cout << "Open shp file failed!" << endl;
exit(1);
}
cout << "Data source open success!" << endl;
int layerNum = poDS->GetLayerCount(); //a dataset may have many layers
cout << "Layer number:" << layerNum << endl;
OGRLayer *poLayer;
poLayer = poDS->GetLayerByName("Nbeijing_point");
//feature is a geometry and a set of attributes
OGRFeature *poFeature;
poLayer->ResetReading(); //Start at the beginning of the layer
cout << "Feature number:" << poLayer->GetFeatureCount() << endl;
stringstream ss;
map<string, pair<double, double> > mip;
map<string, pair<double, double> >::iterator imip;
ofstream ofile("beijingNode");
string id;
int crossFlag;
string stmp, stmp2;
vector<string> vs;
vector<string>::iterator ivs;
while((poFeature = poLayer->GetNextFeature()) != NULL)
{
//Defn contains the definition of all the fields
OGRFeatureDefn *poFDefn = poLayer->GetLayerDefn();
// for(iField = 0; iField < poFDefn->GetFieldCount(); iField++)
// {
// OGRFieldDefn * poFieldDefn = poFDefn->GetFieldDefn(iField);
id = poFeature->GetFieldAsString(1);
ofile << id;
crossFlag = poFeature->GetFieldAsInteger(4);
if(crossFlag == 0)
{
ofile << "\t" << crossFlag << "\t" << 0 << "\t" << 0 << "\t" << 0;
}
else if(crossFlag == 1)
{
ofile << "\t" << crossFlag << "\t" << 0 << "\t" << poFeature->GetFieldAsInteger(7) << "\t" << 0;
}
else if(crossFlag == 2)
{
stmp = poFeature->GetFieldAsString(6);
vs = split(stmp, "|");
ofile << "\t" << crossFlag << "\t" << vs.size();
for(ivs = vs.begin(); ivs != vs.end(); ivs++)
ofile << "\t" << *ivs;
vs.clear();
ofile << "\t" << poFeature->GetFieldAsInteger(7) << "\t" << 0;
}
else if(crossFlag == 3)
{
stmp = poFeature->GetFieldAsString(6);
vs = split(stmp, "|");
ofile << "\t" << crossFlag << "\t" << vs.size();
for(ivs = vs.begin(); ivs != vs.end(); ivs++)
ofile << "\t" << *ivs;
vs.clear();
ofile << "\t" << poFeature->GetFieldAsInteger(7);
stmp = poFeature->GetFieldAsString(8);
stmp2 = poFeature->GetFieldAsString(9);
if(stmp2 != "")
stmp += "|" + stmp2;
vs = split(stmp, "|");
ofile << "\t" << vs.size();
for(ivs = vs.begin(); ivs != vs.end(); ivs++)
ofile << "\t" << *ivs;
vs.clear();
}
ofile << "\t" << poFeature->GetFieldAsString(11);
stmp = poFeature->GetFieldAsString(12);
vs = split(stmp, "|");
ofile << "\t" << vs.size();
for(ivs = vs.begin(); ivs != vs.end(); ivs++)
ofile << "\t" << *ivs;
vs.clear();
/* if(poFieldDefn->GetType() == OFTInteger)
cout << poFeature->GetFieldAsInteger(iField) << ", ";
else if(poFieldDefn->GetType() == OFTInteger64)
cout << poFeature->GetFieldAsInteger64(iField) << ", ";
else if(poFieldDefn->GetType() == OFTReal)
cout << setprecision(15) << poFeature->GetFieldAsDouble(iField) << ", ";
else if(poFieldDefn->GetType() == OFTString)
cout << poFeature->GetFieldAsString(iField) << ", ";
else
cout << poFeature->GetFieldAsString(iField) << ", ";*/
// }
OGRGeometry *poGeometry;
poGeometry = poFeature->GetGeometryRef();
// cout << "Geometry Type:" << poGeometry->getGeometryType() << endl;
if(poGeometry != NULL && wkbFlatten(poGeometry->getGeometryType()) == wkbMultiPoint)
{
OGRMultiPoint *poMultiPoint = (OGRMultiPoint*)poGeometry;
// cout << "Number in the MultiPoint:" << poMultiPoint->getNumGeometries() << endl;
OGRGeometry *pG;
pG = poMultiPoint->getGeometryRef(0);
OGRPoint *pP = (OGRPoint*)pG;
ofile << "\t" << pP->getY() << "\t" << pP->getX();
// pP->flattenTo2D();
// cout << setprecision(15) << pP->getY() << ", " << pP->getX() << endl;
// mip[id] = make_pair(pP->getY(), pP->getX());
}
else
cout << "No Point Geometry" << endl;
ofile << endl;
OGRFeature::DestroyFeature(poFeature);
}
/* cout << "Writing nodes" << endl;
for(imip = mip.begin(); imip != mip.end(); imip++)
ofile << setprecision(15) << (*imip).first << "\t" << (*imip).second.first << "\t" << (*imip).second.second << endl;*/
GDALClose(poFeature);
ofile.close();
return 0;
}
OGRFeature *OGRSOSILayer::GetNextFeature() {
short nName, nNumLines;
long nNumCoo;
unsigned short nInfo;
/* iterate through the SOSI groups*/
while (LC_NextBgr(poNextSerial,LC_FRAMGR)) {
nName = LC_RxGr(&oNextSerial, LES_OPTIMALT, &nNumLines, &nNumCoo, &nInfo);
S2S oHeaders;
S2S::iterator iHeaders;
/* extract reference strings from group header */
CPLString osKey, osValue;
for (short i=1; i<=nNumLines; i++) {
char *pszLine = LC_GetGi(i);
if (pszLine[0] == '!') continue; /* If we have a comment line, skip it. */
if ((pszLine[0] == ':')||(pszLine[0] == '(')) { /* if we have a continued REF line... */
osValue.append(CPLString(pszLine)); /* append to previous line. */
oHeaders.insert(std::pair<CPLString,CPLString>(osKey,osValue));
continue;
}
while (pszLine[0] == '.') pszLine++; /* skipping the dots at the beginning of a SOSI line */
char *pszUTFLine = CPLRecode(pszLine, poParent->pszEncoding, CPL_ENC_UTF8); /* switch to UTF encoding here */
char *pszPos = strstr(pszUTFLine, " ");
if (pszPos != NULL) {
osKey = CPLString(std::string(pszUTFLine,pszPos));
osValue = CPLString(pszPos+1);
oHeaders.insert(std::pair<CPLString,CPLString>(osKey,osValue));
}
CPLFree(pszUTFLine);
}
/* get Feature from fyba, according to feature definition */
OGRGeometry *poGeom = NULL;
OGRwkbGeometryType oGType = wkbUnknown;
switch (nName) {
case INGEN_GRUPPE: { /* No group */
CPLDebug( "[GetNextFeature]", "Could not load further groups - FYBA reported INGEN_GRUPPE.");
break;
}
case L_FLATE: { /* Area */
oGType = wkbPolygon;
OGRLinearRing *poOuter = new OGRLinearRing(); /* Initialize a new closed polygon */
long nRefNr;
unsigned char nRefStatus;
long nRefCount;
bool correct = true;
LC_GRF_STATUS oGrfStat;
// Iterate through all objects that constitute this area.
LC_InitGetRefFlate(&oGrfStat);
nRefCount = LC_GetRefFlate(&oGrfStat, GRF_YTRE, &nRefNr, &nRefStatus, 1);
while (nRefCount > 0) {
if (poParent->papoBuiltGeometries[nRefNr] == NULL) {
// This should not happen under normal operation.
CPLError( CE_Warning, CPLE_AppDefined, "Feature %li referenced by %li, but it was not initialized. Geometry may be broken.", nRefNr, oNextSerial.lNr);
correct = false;
//return NULL;
break;
}
OGRGeometry *geom = poParent->papoBuiltGeometries[nRefNr];
if (geom->getGeometryType() == wkbLineString) {
OGRLineString *poCurve = (OGRLineString*)geom;
if (nRefStatus == LC_MED_DIG) { /* clockwise */
poOuter->addSubLineString(poCurve);
} else if (nRefStatus == LC_MOT_DIG) { /* counter-clockwise */
poOuter->addSubLineString(poCurve,poCurve->getNumPoints()-1,0);
} else {
CPLError( CE_Failure, CPLE_OpenFailed, "Internal error: GRF_*_OY encountered.");
return NULL;
}
} else {
CPLError( CE_Warning, CPLE_AppDefined, "Element %li composed of non-linestrings (REF %li of type %i). Ignored.", oNextSerial.lNr, nRefNr, geom->getGeometryType());
}
nRefCount = LC_GetRefFlate(&oGrfStat, GRF_YTRE, &nRefNr, &nRefStatus, 1);
}
if (correct) {
OGRPolygon *poLy = new OGRPolygon();
poOuter->closeRings();
poLy->addRingDirectly(poOuter);
OGRLinearRing *poInner = 0;
nRefCount = LC_GetRefFlate(&oGrfStat, GRF_INDRE, &nRefNr, &nRefStatus, 1);
while (nRefCount > 0) {
if (nRefNr == -1) {
if (poInner && (poInner->getNumPoints()>2)) { /* If this is not the first polygon, terminate and add the last */
poInner->closeRings();
poLy->addRingDirectly(poInner);
}
poInner = new OGRLinearRing(); /* Initialize a new closed polygon */
} else {
if (poParent->papoBuiltGeometries[nRefNr] == NULL) { /* this shouldn't happen under normal operation */
CPLError( CE_Fatal, CPLE_AppDefined, "Feature %li referenced by %li, but it was not initialized.", nRefNr, oNextSerial.lNr);
return NULL;
}
OGRGeometry *geom = poParent->papoBuiltGeometries[nRefNr];
if (geom->getGeometryType() == wkbLineString) {
OGRLineString *poCurve = (OGRLineString*)geom;
if (nRefStatus == LC_MED_DIG) { /* clockwise */
poInner->addSubLineString(poCurve);
} else if (nRefStatus == LC_MOT_DIG) { /* counter-clockwise */
poInner->addSubLineString(poCurve,poCurve->getNumPoints()-1,0);
} else {
CPLError( CE_Failure, CPLE_OpenFailed, "Internal error: GRF_*_OY encountered.");
return NULL;
}
} else {
CPLError( CE_Warning, CPLE_AppDefined, "Element %li composed of non-linestrings (REF %li of type %i). Ignored.", oNextSerial.lNr, nRefNr, geom->getGeometryType());
}
}
nRefCount = LC_GetRefFlate(&oGrfStat, GRF_INDRE, &nRefNr, &nRefStatus, 1);
}
poGeom = poLy;
}
break;
}
case L_KURVE: /* curve */
case L_LINJE: /* curve, not simplifyable */
case L_BUEP: { /* curve, interpolated from circular arc */
oGType = wkbLineString;
OGRLineString *poCurve = (OGRLineString*)(poParent->papoBuiltGeometries[oNextSerial.lNr]);
if (poCurve == NULL) {
CPLError( CE_Fatal, CPLE_AppDefined, "Curve %li was not initialized.", oNextSerial.lNr);
return NULL;
}
poGeom = poCurve->clone();
break;
}
case L_TEKST: { /* text */
oGType = wkbMultiPoint;
OGRMultiPoint *poMP = (OGRMultiPoint*)(poParent->papoBuiltGeometries[oNextSerial.lNr]);
if (poMP == NULL) {
CPLError( CE_Fatal, CPLE_AppDefined, "Tekst %li was not initialized.", oNextSerial.lNr);
return NULL;
}
poGeom = poMP->clone();
break;
}
case L_SYMBOL: {
//CPLError( CE_Warning, CPLE_OpenFailed, "Geometry of type SYMBOL treated as point (PUNKT).");
}
case L_PUNKT: { /* point */
oGType = wkbPoint;
OGRPoint *poPoint = (OGRPoint*)(poParent->papoBuiltGeometries[oNextSerial.lNr]);
if (poPoint == NULL) {
CPLError( CE_Fatal, CPLE_AppDefined, "Point %li was not initialized.", oNextSerial.lNr);
return NULL;
}
poGeom = poPoint->clone();
break;
}
case L_DEF: /* skip user definitions and headers here */
case L_HODE: {
break;
}
default: { /* complain a bit about anything else that is not implemented */
CPLError( CE_Failure, CPLE_OpenFailed, "Unrecognized geometry of type %i.", nName);
break;
}
}
if (poGeom == NULL) continue; /* skipping L_HODE and unrecognized groups */
if (oGType != poFeatureDefn->GetGeomType()) {
if (poGeom != NULL) delete poGeom;
continue; /* skipping features that are not the correct geometry */
}
OGRFeature *poFeature = new OGRFeature( poFeatureDefn );
/* set all headers found in this group - we export everything, just in case */
for (iHeaders = oHeaders.begin(); iHeaders != oHeaders.end(); iHeaders++) {
OGRSOSIDataType *poType = SOSIGetType(iHeaders->first);
OGRSOSISimpleDataType *poElements = poType->getElements();
const char *pszLine = iHeaders->second.c_str();
char** tokens = CSLTokenizeString(iHeaders->second.c_str());
for (int k=0; k<poType->getElementCount(); k++) {
if (tokens[k] == 0) break;
if (strcmp(poElements[k].GetName(),"")==0) continue;
int iHNr = poHeaderDefn->find(poElements[k].GetName())->second;
if (iHNr == -1) {
CPLError( CE_Warning, CPLE_AppDefined, "Could not find field definition for %s.", poElements[k].GetName());
continue;
}
OGRFieldType nType = poElements[k].GetType();
switch (nType) {
case OFTInteger: {
poFeature->SetField( iHNr, SOSITypeToInt(tokens[k]));
break;
}
case OFTDate: {
int date[3];
SOSITypeToDate(tokens[k], date);
poFeature->SetField( iHNr, date[0], date[1], date[2]);
break;
}
case OFTDateTime: {
int date[6];
SOSITypeToDateTime(tokens[k], date);
if (date[0]>0)
poFeature->SetField( iHNr, date[0], date[1], date[2], date[3], date[4], static_cast<float>(date[5]), 1);
break;
}
case OFTReal: {
poFeature->SetField( iHNr, SOSITypeToReal(tokens[k]));
break;
}
default: {
if ((k==0)&&((pszLine[0] == '\'')||(pszLine[0] == '\"'))) { /* If the value is quoted, ignore these */
int nLen = static_cast<int>(strlen(pszLine));
char *pszNline = (char*)CPLMalloc(nLen-1);
strncpy(pszNline, pszLine+1, nLen-2);
pszNline[nLen-2] = '\0';
poFeature->SetField( iHNr, pszNline);
CPLFree(pszNline);
} else {
poFeature->SetField( iHNr, tokens[k]);
}
break;
}
}
}
CSLDestroy(tokens);
}
if( poGeom != NULL )
poGeom->assignSpatialReference(poParent->poSRS);
poFeature->SetGeometryDirectly( poGeom );
poFeature->SetFID( nNextFID++ );
/* Loop until we have a feature that matches the definition */
if ( (m_poFilterGeom == NULL || FilterGeometry( poFeature->GetGeometryRef() ) )
&& (m_poAttrQuery == NULL || m_poAttrQuery->Evaluate( poFeature )) )
return poFeature;
delete poFeature;
}
return NULL;
}
void
PCLoaderArcView::load(const std::string& file, OptionsCont& oc, PCPolyContainer& toFill,
PCTypeMap&) {
#ifdef HAVE_GDAL
GeoConvHelper& geoConvHelper = GeoConvHelper::getProcessing();
// get defaults
std::string prefix = oc.getString("prefix");
std::string type = oc.getString("type");
RGBColor color = RGBColor::parseColor(oc.getString("color"));
int layer = oc.getInt("layer");
std::string idField = oc.getString("shapefile.id-column");
// start parsing
std::string shpName = file + ".shp";
OGRRegisterAll();
OGRDataSource* poDS = OGRSFDriverRegistrar::Open(shpName.c_str(), FALSE);
if (poDS == NULL) {
throw ProcessError("Could not open shape description '" + shpName + "'.");
}
// begin file parsing
OGRLayer* poLayer = poDS->GetLayer(0);
poLayer->ResetReading();
// build coordinate transformation
OGRSpatialReference* origTransf = poLayer->GetSpatialRef();
OGRSpatialReference destTransf;
// use wgs84 as destination
destTransf.SetWellKnownGeogCS("WGS84");
OGRCoordinateTransformation* poCT = OGRCreateCoordinateTransformation(origTransf, &destTransf);
if (poCT == NULL) {
if (oc.isSet("shapefile.guess-projection")) {
OGRSpatialReference origTransf2;
origTransf2.SetWellKnownGeogCS("WGS84");
poCT = OGRCreateCoordinateTransformation(&origTransf2, &destTransf);
}
if (poCT == 0) {
WRITE_WARNING("Could not create geocoordinates converter; check whether proj.4 is installed.");
}
}
OGRFeature* poFeature;
poLayer->ResetReading();
while ((poFeature = poLayer->GetNextFeature()) != NULL) {
// read in edge attributes
std::string id = poFeature->GetFieldAsString(idField.c_str());
id = StringUtils::prune(id);
if (id == "") {
throw ProcessError("Missing id under '" + idField + "'");
}
id = prefix + id;
// read in the geometry
OGRGeometry* poGeometry = poFeature->GetGeometryRef();
if (poGeometry != 0) {
// try transform to wgs84
poGeometry->transform(poCT);
}
OGRwkbGeometryType gtype = poGeometry->getGeometryType();
switch (gtype) {
case wkbPoint: {
OGRPoint* cgeom = (OGRPoint*) poGeometry;
Position pos((SUMOReal) cgeom->getX(), (SUMOReal) cgeom->getY());
if (!geoConvHelper.x2cartesian(pos)) {
WRITE_ERROR("Unable to project coordinates for POI '" + id + "'.");
}
PointOfInterest* poi = new PointOfInterest(id, type, pos, color);
if (!toFill.insert(id, poi, layer)) {
WRITE_ERROR("POI '" + id + "' could not been added.");
delete poi;
}
}
break;
case wkbLineString: {
OGRLineString* cgeom = (OGRLineString*) poGeometry;
PositionVector shape;
for (int j = 0; j < cgeom->getNumPoints(); j++) {
Position pos((SUMOReal) cgeom->getX(j), (SUMOReal) cgeom->getY(j));
if (!geoConvHelper.x2cartesian(pos)) {
WRITE_ERROR("Unable to project coordinates for polygon '" + id + "'.");
}
shape.push_back_noDoublePos(pos);
}
Polygon* poly = new Polygon(id, type, color, shape, false);
if (!toFill.insert(id, poly, layer)) {
WRITE_ERROR("Polygon '" + id + "' could not been added.");
delete poly;
}
}
break;
case wkbPolygon: {
OGRLinearRing* cgeom = ((OGRPolygon*) poGeometry)->getExteriorRing();
PositionVector shape;
for (int j = 0; j < cgeom->getNumPoints(); j++) {
Position pos((SUMOReal) cgeom->getX(j), (SUMOReal) cgeom->getY(j));
if (!geoConvHelper.x2cartesian(pos)) {
WRITE_ERROR("Unable to project coordinates for polygon '" + id + "'.");
}
shape.push_back_noDoublePos(pos);
}
Polygon* poly = new Polygon(id, type, color, shape, true);
if (!toFill.insert(id, poly, layer)) {
WRITE_ERROR("Polygon '" + id + "' could not been added.");
delete poly;
}
}
break;
case wkbMultiPoint: {
OGRMultiPoint* cgeom = (OGRMultiPoint*) poGeometry;
for (int i = 0; i < cgeom->getNumGeometries(); ++i) {
OGRPoint* cgeom2 = (OGRPoint*) cgeom->getGeometryRef(i);
Position pos((SUMOReal) cgeom2->getX(), (SUMOReal) cgeom2->getY());
std::string tid = id + "#" + toString(i);
if (!geoConvHelper.x2cartesian(pos)) {
WRITE_ERROR("Unable to project coordinates for POI '" + tid + "'.");
}
PointOfInterest* poi = new PointOfInterest(tid, type, pos, color);
if (!toFill.insert(tid, poi, layer)) {
WRITE_ERROR("POI '" + tid + "' could not been added.");
delete poi;
}
}
}
break;
case wkbMultiLineString: {
OGRMultiLineString* cgeom = (OGRMultiLineString*) poGeometry;
for (int i = 0; i < cgeom->getNumGeometries(); ++i) {
OGRLineString* cgeom2 = (OGRLineString*) cgeom->getGeometryRef(i);
PositionVector shape;
std::string tid = id + "#" + toString(i);
for (int j = 0; j < cgeom2->getNumPoints(); j++) {
Position pos((SUMOReal) cgeom2->getX(j), (SUMOReal) cgeom2->getY(j));
if (!geoConvHelper.x2cartesian(pos)) {
WRITE_ERROR("Unable to project coordinates for polygon '" + tid + "'.");
}
shape.push_back_noDoublePos(pos);
}
Polygon* poly = new Polygon(tid, type, color, shape, false);
if (!toFill.insert(tid, poly, layer)) {
WRITE_ERROR("Polygon '" + tid + "' could not been added.");
delete poly;
}
}
}
break;
case wkbMultiPolygon: {
OGRMultiPolygon* cgeom = (OGRMultiPolygon*) poGeometry;
for (int i = 0; i < cgeom->getNumGeometries(); ++i) {
OGRLinearRing* cgeom2 = ((OGRPolygon*) cgeom->getGeometryRef(i))->getExteriorRing();
PositionVector shape;
std::string tid = id + "#" + toString(i);
for (int j = 0; j < cgeom2->getNumPoints(); j++) {
Position pos((SUMOReal) cgeom2->getX(j), (SUMOReal) cgeom2->getY(j));
if (!geoConvHelper.x2cartesian(pos)) {
WRITE_ERROR("Unable to project coordinates for polygon '" + tid + "'.");
}
shape.push_back_noDoublePos(pos);
}
Polygon* poly = new Polygon(tid, type, color, shape, true);
if (!toFill.insert(tid, poly, layer)) {
WRITE_ERROR("Polygon '" + tid + "' could not been added.");
delete poly;
}
}
}
break;
default:
WRITE_WARNING("Unsupported shape type occured (id='" + id + "').");
break;
}
OGRFeature::DestroyFeature(poFeature);
}
PROGRESS_DONE_MESSAGE();
#else
WRITE_ERROR("SUMO was compiled without GDAL support.");
#endif
}
OGRErr OGROCIWritableLayer::TranslateToSDOGeometry( OGRGeometry * poGeometry,
int *pnGType )
{
nOrdinalCount = 0;
nElemInfoCount = 0;
if( poGeometry == NULL )
return OGRERR_FAILURE;
/* ==================================================================== */
/* Handle a point geometry. */
/* ==================================================================== */
if( wkbFlatten(poGeometry->getGeometryType()) == wkbPoint )
{
#ifdef notdef
char szResult[1024];
OGRPoint *poPoint = (OGRPoint *) poGeometry;
if( nDimension == 2 )
CPLsprintf( szResult,
"%s(%d,%s,MDSYS.SDO_POINT_TYPE(%.16g,%.16g,0.0),NULL,NULL)",
SDO_GEOMETRY, 2001, szSRID,
poPoint->getX(), poPoint->getY() );
else
CPLsprintf( szResult,
"%s(%d,%s,MDSYS.SDO_POINT_TYPE(%.16g,%.16g,%.16g),NULL,NULL)",
SDO_GEOMETRY, 3001, szSRID,
poPoint->getX(), poPoint->getY(), poPoint->getZ() );
return CPLStrdup(szResult );
#endif
}
/* ==================================================================== */
/* Handle a line string geometry. */
/* ==================================================================== */
else if( wkbFlatten(poGeometry->getGeometryType()) == wkbLineString )
{
*pnGType = nDimension * 1000 + 2;
TranslateElementGroup( poGeometry );
return OGRERR_NONE;
}
/* ==================================================================== */
/* Handle a polygon geometry. */
/* ==================================================================== */
else if( wkbFlatten(poGeometry->getGeometryType()) == wkbPolygon )
{
*pnGType = nDimension == 2 ? 2003 : 3003;
TranslateElementGroup( poGeometry );
return OGRERR_NONE;
}
/* ==================================================================== */
/* Handle a multi point geometry. */
/* ==================================================================== */
else if( wkbFlatten(poGeometry->getGeometryType()) == wkbMultiPoint )
{
OGRMultiPoint *poMP = (OGRMultiPoint *) poGeometry;
int iVert;
*pnGType = nDimension*1000 + 5;
PushElemInfo( 1, 1, poMP->getNumGeometries() );
for( iVert = 0; iVert < poMP->getNumGeometries(); iVert++ )
{
OGRPoint *poPoint = (OGRPoint *)poMP->getGeometryRef( iVert );
PushOrdinal( poPoint->getX() );
PushOrdinal( poPoint->getY() );
if( nDimension == 3 )
PushOrdinal( poPoint->getZ() );
}
return OGRERR_NONE;
}
/* ==================================================================== */
/* Handle other geometry collections. */
/* ==================================================================== */
else
{
/* -------------------------------------------------------------------- */
/* Identify the GType. */
/* -------------------------------------------------------------------- */
if( wkbFlatten(poGeometry->getGeometryType()) == wkbMultiLineString )
*pnGType = nDimension * 1000 + 6;
else if( wkbFlatten(poGeometry->getGeometryType()) == wkbMultiPolygon )
*pnGType = nDimension * 1000 + 7;
else if( wkbFlatten(poGeometry->getGeometryType())
== wkbGeometryCollection )
*pnGType = nDimension * 1000 + 4;
else
{
CPLError( CE_Failure, CPLE_AppDefined,
"Unexpected geometry type (%d/%s) in "
"OGROCIWritableLayer::TranslateToSDOGeometry()",
poGeometry->getGeometryType(),
poGeometry->getGeometryName() );
return OGRERR_FAILURE;
}
/* -------------------------------------------------------------------- */
/* Translate each child in turn. */
/* -------------------------------------------------------------------- */
OGRGeometryCollection *poGC = (OGRGeometryCollection *) poGeometry;
int iChild;
for( iChild = 0; iChild < poGC->getNumGeometries(); iChild++ )
TranslateElementGroup( poGC->getGeometryRef(iChild) );
return OGRERR_NONE;
}
return OGRERR_FAILURE;
}
static void ParseObject(const char* pszId,
json_object* poObj, OGRGeoJSONLayer* poLayer,
json_object* poArcsDB, ScalingParams* psParams)
{
json_object* poType = OGRGeoJSONFindMemberByName(poObj, "type");
if( poType == NULL || json_object_get_type(poType) != json_type_string )
return;
const char* pszType = json_object_get_string(poType);
json_object* poArcsObj = OGRGeoJSONFindMemberByName(poObj, "arcs");
json_object* poCoordinatesObj = OGRGeoJSONFindMemberByName(poObj, "coordinates");
if( strcmp(pszType, "Point") == 0 || strcmp(pszType, "MultiPoint") == 0 )
{
if( poCoordinatesObj == NULL || json_type_array != json_object_get_type(poCoordinatesObj) )
return;
}
else
{
if( poArcsObj == NULL || json_type_array != json_object_get_type(poArcsObj) )
return;
}
if( pszId == NULL )
{
json_object* poId = OGRGeoJSONFindMemberByName(poObj, "id");
if( poId != NULL &&
(json_type_string == json_object_get_type(poId) ||
json_type_int == json_object_get_type(poId)) )
{
pszId = json_object_get_string(poId);
}
}
OGRFeature* poFeature = new OGRFeature(poLayer->GetLayerDefn());
if( pszId != NULL )
poFeature->SetField("id", pszId);
json_object* poProperties = OGRGeoJSONFindMemberByName(poObj, "properties");
if( poProperties != NULL && json_type_object == json_object_get_type(poProperties) )
{
json_object* poName = OGRGeoJSONFindMemberByName(poProperties, "name");
if( poName != NULL && json_type_string == json_object_get_type(poName) )
{
const char* pszName = json_object_get_string(poName);
poFeature->SetField("name", pszName);
}
}
OGRGeometry* poGeom = NULL;
if( strcmp(pszType, "Point") == 0 )
{
double dfX = 0.0, dfY = 0.0;
if( ParsePoint( poCoordinatesObj, &dfX, &dfY ) )
{
dfX = dfX * psParams->dfScale0 + psParams->dfTranslate0;
dfY = dfY * psParams->dfScale1 + psParams->dfTranslate1;
poGeom = new OGRPoint(dfX, dfY);
}
else
poGeom = new OGRPoint();
}
else if( strcmp(pszType, "MultiPoint") == 0 )
{
OGRMultiPoint* poMP = new OGRMultiPoint();
poGeom = poMP;
int nTuples = json_object_array_length(poCoordinatesObj);
for(int i=0; i<nTuples; i++)
{
json_object* poPair = json_object_array_get_idx(poCoordinatesObj, i);
double dfX = 0.0, dfY = 0.0;
if( ParsePoint( poPair, &dfX, &dfY ) )
{
dfX = dfX * psParams->dfScale0 + psParams->dfTranslate0;
dfY = dfY * psParams->dfScale1 + psParams->dfTranslate1;
poMP->addGeometryDirectly(new OGRPoint(dfX, dfY));
}
}
}
else if( strcmp(pszType, "LineString") == 0 )
{
OGRLineString* poLS = new OGRLineString();
poGeom = poLS;
ParseLineString(poLS, poArcsObj, poArcsDB, psParams);
}
else if( strcmp(pszType, "MultiLineString") == 0 )
{
OGRMultiLineString* poMLS = new OGRMultiLineString();
poGeom = poMLS;
ParseMultiLineString(poMLS, poArcsObj, poArcsDB, psParams);
}
else if( strcmp(pszType, "Polygon") == 0 )
{
OGRPolygon* poPoly = new OGRPolygon();
poGeom = poPoly;
ParsePolygon(poPoly, poArcsObj, poArcsDB, psParams);
}
else if( strcmp(pszType, "MultiPolygon") == 0 )
{
OGRMultiPolygon* poMultiPoly = new OGRMultiPolygon();
poGeom = poMultiPoly;
ParseMultiPolygon(poMultiPoly, poArcsObj, poArcsDB, psParams);
}
if( poGeom != NULL )
poFeature->SetGeometryDirectly(poGeom);
poLayer->AddFeature(poFeature);
delete poFeature;
}
int S57Writer::WritePrimitive( OGRFeature *poFeature )
{
DDFRecord *poRec = MakeRecord();
DDFField *poField;
OGRGeometry *poGeom = poFeature->GetGeometryRef();
/* -------------------------------------------------------------------- */
/* Add the VRID field. */
/* -------------------------------------------------------------------- */
poField = poRec->AddField( poModule->FindFieldDefn( "VRID" ) );
poRec->SetIntSubfield ( "VRID", 0, "RCNM", 0,
poFeature->GetFieldAsInteger( "RCNM") );
poRec->SetIntSubfield ( "VRID", 0, "RCID", 0,
poFeature->GetFieldAsInteger( "RCID") );
poRec->SetIntSubfield ( "VRID", 0, "RVER", 0, 1 );
poRec->SetIntSubfield ( "VRID", 0, "RUIN", 0, 1 );
/* -------------------------------------------------------------------- */
/* Handle simple point. */
/* -------------------------------------------------------------------- */
if( poGeom != NULL && wkbFlatten(poGeom->getGeometryType()) == wkbPoint )
{
double dfX, dfY, dfZ;
OGRPoint *poPoint = (OGRPoint *) poGeom;
CPLAssert( poFeature->GetFieldAsInteger( "RCNM") == RCNM_VI
|| poFeature->GetFieldAsInteger( "RCNM") == RCNM_VC );
dfX = poPoint->getX();
dfY = poPoint->getY();
dfZ = poPoint->getZ();
if( dfZ == 0.0 )
WriteGeometry( poRec, 1, &dfX, &dfY, NULL );
else
WriteGeometry( poRec, 1, &dfX, &dfY, &dfZ );
}
/* -------------------------------------------------------------------- */
/* For multipoints we assuming SOUNDG, and write out as SG3D. */
/* -------------------------------------------------------------------- */
else if( poGeom != NULL
&& wkbFlatten(poGeom->getGeometryType()) == wkbMultiPoint )
{
OGRMultiPoint *poMP = (OGRMultiPoint *) poGeom;
int i, nVCount = poMP->getNumGeometries();
double *padfX, *padfY, *padfZ;
CPLAssert( poFeature->GetFieldAsInteger( "RCNM") == RCNM_VI
|| poFeature->GetFieldAsInteger( "RCNM") == RCNM_VC );
padfX = (double *) CPLMalloc(sizeof(double) * nVCount);
padfY = (double *) CPLMalloc(sizeof(double) * nVCount);
padfZ = (double *) CPLMalloc(sizeof(double) * nVCount);
for( i = 0; i < nVCount; i++ )
{
OGRPoint *poPoint = (OGRPoint *) poMP->getGeometryRef( i );
padfX[i] = poPoint->getX();
padfY[i] = poPoint->getY();
padfZ[i] = poPoint->getZ();
}
WriteGeometry( poRec, nVCount, padfX, padfY, padfZ );
CPLFree( padfX );
CPLFree( padfY );
CPLFree( padfZ );
}
/* -------------------------------------------------------------------- */
/* Handle LINESTRINGs (edge) geometry. */
/* -------------------------------------------------------------------- */
else if( poGeom != NULL
&& wkbFlatten(poGeom->getGeometryType()) == wkbLineString )
{
OGRLineString *poLS = (OGRLineString *) poGeom;
int i, nVCount = poLS->getNumPoints();
double *padfX, *padfY;
CPLAssert( poFeature->GetFieldAsInteger( "RCNM") == RCNM_VE );
padfX = (double *) CPLMalloc(sizeof(double) * nVCount);
padfY = (double *) CPLMalloc(sizeof(double) * nVCount);
for( i = 0; i < nVCount; i++ )
{
padfX[i] = poLS->getX(i);
padfY[i] = poLS->getY(i);
}
WriteGeometry( poRec, nVCount, padfX, padfY, NULL );
CPLFree( padfX );
CPLFree( padfY );
}
/* -------------------------------------------------------------------- */
/* edge node linkages. */
/* -------------------------------------------------------------------- */
if( poFeature->GetDefnRef()->GetFieldIndex( "NAME_RCNM_0" ) >= 0 )
{
DDFField *poField;
char szName[5];
int nRCID;
CPLAssert( poFeature->GetFieldAsInteger( "NAME_RCNM_0") == RCNM_VC );
poField = poRec->AddField( poModule->FindFieldDefn( "VRPT" ) );
nRCID = poFeature->GetFieldAsInteger( "NAME_RCID_0");
szName[0] = RCNM_VC;
szName[1] = nRCID & 0xff;
szName[2] = (nRCID & 0xff00) >> 8;
szName[3] = (nRCID & 0xff0000) >> 16;
szName[4] = (nRCID & 0xff000000) >> 24;
poRec->SetStringSubfield( "VRPT", 0, "NAME", 0, szName, 5 );
poRec->SetIntSubfield ( "VRPT", 0, "ORNT", 0,
poFeature->GetFieldAsInteger( "ORNT_0") );
poRec->SetIntSubfield ( "VRPT", 0, "USAG", 0,
poFeature->GetFieldAsInteger( "USAG_0") );
poRec->SetIntSubfield ( "VRPT", 0, "TOPI", 0,
poFeature->GetFieldAsInteger( "TOPI_0") );
poRec->SetIntSubfield ( "VRPT", 0, "MASK", 0,
poFeature->GetFieldAsInteger( "MASK_0") );
nRCID = poFeature->GetFieldAsInteger( "NAME_RCID_1");
szName[0] = RCNM_VC;
szName[1] = nRCID & 0xff;
szName[2] = (nRCID & 0xff00) >> 8;
szName[3] = (nRCID & 0xff0000) >> 16;
szName[4] = (nRCID & 0xff000000) >> 24;
poRec->SetStringSubfield( "VRPT", 0, "NAME", 1, szName, 5 );
poRec->SetIntSubfield ( "VRPT", 0, "ORNT", 1,
poFeature->GetFieldAsInteger( "ORNT_1") );
poRec->SetIntSubfield ( "VRPT", 0, "USAG", 1,
poFeature->GetFieldAsInteger( "USAG_1") );
poRec->SetIntSubfield ( "VRPT", 0, "TOPI", 1,
poFeature->GetFieldAsInteger( "TOPI_1") );
poRec->SetIntSubfield ( "VRPT", 0, "MASK", 1,
poFeature->GetFieldAsInteger( "MASK_1") );
}