Ejemplo n.º 1
1
int main(int argc, char **argv)
{
  // Get data from ogr
  OGRRegisterAll();
  std::cout << "Opening: " << argv[1] << std::endl;

  OGRDataSource *shp = OGRSFDriverRegistrar::Open(argv[1], FALSE);
  IsValid(shp, "Error opening file.");

  std::cout << "Shape contains " << shp->GetLayerCount() << " layers." << std::endl;
  OGRLayer *layer = shp->GetLayerByName(argv[2]);
  IsValid(layer, "Couldn't grab layer");

  OGRSpatialReference *srcSRS = NULL;
  srcSRS = layer->GetSpatialRef();

  // Set up writing
  const char *kDriverName = "ESRI Shapefile";
  OGRSFDriver *shpDriver = OGRSFDriverRegistrar::GetRegistrar()->GetDriverByName(kDriverName);
  IsValid(shpDriver, "Couldn't grab the shapefile driver.");

  IsValid(argv[3], "Please provide a output shp.");
  std::cout << "Writing to: " << argv[3] << std::endl;
  OGRDataSource *shpOut = shpDriver->CreateDataSource(argv[3], NULL);
  IsValid(shpOut, "Couldn't open output file");

  OGRLayer *outLayer = shpOut->CreateLayer(layer->GetName(), srcSRS, wkbMultiLineString, NULL);
  IsValid(outLayer, "Couldn't create an output layer");

  // copy over the fields from the source file
  OGRFeatureDefn *source = layer->GetLayerDefn();
  for(int i=0; i < source->GetFieldCount(); i++){
    OGRFieldDefn *field = source->GetFieldDefn(i);
    if(outLayer->CreateField(field) != OGRERR_NONE) {
      std::cout << "Couldn't make layer" << std::endl; exit(1);
    };
  }

  // Loop through features and grab the hull and put it into CGAL then
  // skeletonize the points
  OGRFeature *feature;
  int count = 0;
  while((feature = layer->GetNextFeature()) != NULL)
  {
    OGRMultiPolygon *geometry = dynamic_cast<OGRMultiPolygon *>(OGRGeometryFactory::forceToMultiPolygon(feature->GetGeometryRef()));
    IsValid(geometry, "No geometry.");

    OGRFeature *outFeature = OGRFeature::CreateFeature(outLayer->GetLayerDefn());
    IsValid(outFeature, "Couldn't make a feature.");

    for(int i=0; i < source->GetFieldCount(); i++){
      OGRField *field = feature->GetRawFieldRef(i);
      outFeature->SetField(i, field);
    }

    OGRGeometry* line = NULL;
    for(int i=0; i < geometry->getNumGeometries(); i++){
      OGRGeometry* segment = BuildMultiLine(geometry->getGeometryRef(i));
      if(segment != NULL){
        if(line == NULL) { line = new OGRLineString; }
        OGRGeometry* tmp = line->Union(segment);
        if(tmp != NULL){
          delete line;
          line = tmp;
        }
        delete segment;
      }
    }
    outFeature->SetGeometry(line);
    if(outLayer->CreateFeature(outFeature) != OGRERR_NONE){
      std::cout << "Couldn't create feature." << std::endl;
      exit(1);
    }

    // clean up
    OGRFeature::DestroyFeature(outFeature);
    std::cout << std::endl << ++count << std::endl;
  }

  // cleanup
  OGRDataSource::DestroyDataSource(shp);
  OGRDataSource::DestroyDataSource(shpOut);
  return 0;
}
Ejemplo n.º 2
0
            explicit ProblemReporterOGR(OGRDataSource* data_source) :
                m_data_source(data_source) {

                OGRSpatialReference sparef;
                sparef.SetWellKnownGeogCS("WGS84");

                m_layer_perror = m_data_source->CreateLayer("perrors", &sparef, wkbPoint, nullptr);
                if (!m_layer_perror) {
                    std::runtime_error("Layer creation failed for layer 'perrors'");
                }

                OGRFieldDefn layer_perror_field_id1("id1", OFTReal);
                layer_perror_field_id1.SetWidth(10);

                if (m_layer_perror->CreateField(&layer_perror_field_id1) != OGRERR_NONE) {
                    std::runtime_error("Creating field 'id1' failed for layer 'perrors'");
                }

                OGRFieldDefn layer_perror_field_id2("id2", OFTReal);
                layer_perror_field_id2.SetWidth(10);

                if (m_layer_perror->CreateField(&layer_perror_field_id2) != OGRERR_NONE) {
                    std::runtime_error("Creating field 'id2' failed for layer 'perrors'");
                }

                OGRFieldDefn layer_perror_field_problem_type("problem_type", OFTString);
                layer_perror_field_problem_type.SetWidth(30);

                if (m_layer_perror->CreateField(&layer_perror_field_problem_type) != OGRERR_NONE) {
                    std::runtime_error("Creating field 'problem_type' failed for layer 'perrors'");
                }

                /**************/

                m_layer_lerror = m_data_source->CreateLayer("lerrors", &sparef, wkbLineString, nullptr);
                if (!m_layer_lerror) {
                    std::runtime_error("Layer creation failed for layer 'lerrors'");
                }

                OGRFieldDefn layer_lerror_field_id1("id1", OFTReal);
                layer_lerror_field_id1.SetWidth(10);

                if (m_layer_lerror->CreateField(&layer_lerror_field_id1) != OGRERR_NONE) {
                    std::runtime_error("Creating field 'id1' failed for layer 'lerrors'");
                }

                OGRFieldDefn layer_lerror_field_id2("id2", OFTReal);
                layer_lerror_field_id2.SetWidth(10);

                if (m_layer_lerror->CreateField(&layer_lerror_field_id2) != OGRERR_NONE) {
                    std::runtime_error("Creating field 'id2' failed for layer 'lerrors'");
                }

                OGRFieldDefn layer_lerror_field_problem_type("problem_type", OFTString);
                layer_lerror_field_problem_type.SetWidth(30);

                if (m_layer_lerror->CreateField(&layer_lerror_field_problem_type) != OGRERR_NONE) {
                    std::runtime_error("Creating field 'problem_type' failed for layer 'lerrors'");
                }
            }
Ejemplo n.º 3
0
JNIEXPORT jlong JNICALL Java_es_gva_cit_jogr_OGRDataSource_createLayerNat
  (JNIEnv *env, jobject obj, jlong cPtr, jstring pszName, jlong poSpatialRef, jstring eGType, jobjectArray papszOptions){
  	  	
  	OGRDataSource 		*ds = (OGRDataSource *) 0 ;
  	int 				longitud;
  	char				**opciones;
  	OGRLayer			*layer_dstno;
	OGRSpatialReference	*spatialRef;
  	long 				ptr_dtno=-1;
  	OGRwkbGeometryType	geomtype;
  	
  	ds = *(OGRDataSource **)&cPtr;
  	
	spatialRef = *(OGRSpatialReference **)&poSpatialRef;
			
  	if(ds!=NULL){
  		longitud = env->GetArrayLength( papszOptions); 
  		opciones = (char **)malloc(sizeof(char *)*longitud);
  		for(int i=0;i<longitud;i++){
	  		jstring el = (jstring)env->GetObjectArrayElement(papszOptions,i);
	  		const char *simple_option = env->GetStringUTFChars( el, 0);
	  		opciones[i]=(char *)malloc(strlen(simple_option));
	  		strcpy(opciones[i],simple_option);
	  		env->ReleaseStringUTFChars( el, simple_option);
  		}
  		
  		const char *type = env->GetStringUTFChars( eGType, 0);
  		const char *name = env->GetStringUTFChars( pszName, 0);
  		if(strcmp(type,"wkbUnknown")==0)geomtype = wkbUnknown;
  		else if(strcmp(type,"wkbPoint")==0)geomtype = wkbPoint;
  		else if(strcmp(type,"wkbLineString")==0)geomtype = wkbLineString;
  		else if(strcmp(type,"wkbPolygon")==0)geomtype = wkbPolygon;
  		else if(strcmp(type,"wkbMultiPoint")==0)geomtype = wkbMultiPoint;
  		else if(strcmp(type,"wkbMultiLineString")==0)geomtype = wkbMultiLineString;
  		else if(strcmp(type,"wkbMultiPolygon")==0)geomtype = wkbMultiPolygon;
  		else if(strcmp(type,"wkbGeometryCollection")==0)geomtype = wkbGeometryCollection;
  		else if(strcmp(type,"wkbNone")==0)geomtype = wkbNone;
  		else if(strcmp(type,"wkbLinearRing")==0)geomtype = wkbLinearRing;
		else if(strcmp(type,"wkbPoint25D")==0)geomtype = wkbPoint25D;
  		else if(strcmp(type,"wkbLineString25D")==0)geomtype = wkbLineString25D;
  		else if(strcmp(type,"wkbPolygon25D")==0)geomtype = wkbPolygon25D;
  		else if(strcmp(type,"wkbMultiPoint25D")==0)geomtype = wkbMultiPoint25D;
  		else if(strcmp(type,"wkbMultiLineString25D")==0)geomtype = wkbMultiLineString25D;
  		else if(strcmp(type,"wkbMultiPolygon25D")==0)geomtype = wkbMultiPolygon25D;
  		else if(strcmp(type,"wkbGeometryCollection25D")==0)geomtype = wkbGeometryCollection25D;
  		
  		layer_dstno = ds->CreateLayer(name, spatialRef, geomtype, opciones);
	  	env->ReleaseStringUTFChars( eGType, type);
	  	env->ReleaseStringUTFChars( pszName, name);
  	}
  	
  	for(int i=0;i<longitud;i++)free(opciones[i]);
  	free(opciones);
  	
  	if(layer_dstno==NULL)return -1;
  	
  	ptr_dtno = (long)&(*layer_dstno);
  	return (jlong)ptr_dtno;
  }
OGRLayer   *OGRDataSourceWithTransaction::ICreateLayer( const char *pszName,
        OGRSpatialReference *poSpatialRef,
        OGRwkbGeometryType eGType,
        char ** papszOptions)
{
    if( !m_poBaseDataSource ) return NULL;
    return WrapLayer(m_poBaseDataSource->CreateLayer(pszName, poSpatialRef, eGType, papszOptions));
}
Ejemplo n.º 5
0
OGRDataSource * VectorCreate( const char * pszFormat, const char * pszFilename, char ** papszOptions/*=NULL*/ )
{
	OGRSFDriver * poDriver = GetVectorDriver(pszFormat);
	OGRDataSource * poOGRDataSource =
	    poDriver->CreateDataSource(pszFilename, papszOptions);

#ifdef TRACEON
	//测试时使用文件型数据库,没有图层时打开有问题,因此在这里放一个图层
	//这样才能打开,不用测试可以关闭,在release中没有
	poOGRDataSource->CreateLayer("TEMP", NULL, wkbUnknown, NULL);
#endif

	return poOGRDataSource;
}
Ejemplo n.º 6
0
    OGRLayer* init_layer(const std::string& name, const stringv& fields, const OGRwkbGeometryType type) {
        std::cerr << "Creating layer: " << name << "\n";

        OGRLayer* layer = m_data_source->CreateLayer(name.c_str(), &m_srs_out, type, NULL);
        if (layer == NULL) {
            std::cerr << "Layer creation failed (" << name << ").\n";
            exit(1);
        }

        std::cerr << "  Creating field: osm_id\n";
        OGRFieldDefn field_osm_id("osm_id", OFTString);
        field_osm_id.SetWidth(11);
        if (layer->CreateField(&field_osm_id) != OGRERR_NONE ) {
            std::cerr << "Creating field 'osm_id' failed.\n";
            exit(1);
        }

        std::cerr << "  Creating field: z_order\n";
        OGRFieldDefn field_z_order("z_order", OFTInteger);
        field_z_order.SetWidth(4);
        if (layer->CreateField(&field_z_order) != OGRERR_NONE ) {
            std::cerr << "Creating field 'z_order' failed.\n";
            exit(1);
        }

        std::cerr << "  Creating field: way_area\n";
        OGRFieldDefn field_way_area("way_area", OFTReal);
        field_way_area.SetWidth(10);
        if (layer->CreateField(&field_way_area) != OGRERR_NONE ) {
            std::cerr << "Creating field 'way_area' failed.\n";
            exit(1);
        }

        stringv::const_iterator it;
        for (it = fields.begin(); it != fields.end(); ++it) {
            std::cerr << "  Creating field: " << *it << "\n";
            OGRFieldDefn field_tag((*it).c_str(), OFTString);
            field_tag.SetWidth(255);
            if (layer->CreateField(&field_tag) != OGRERR_NONE ) {
                std::cerr << "Creating field '" << *it << "' failed.\n";
                exit(1);
            }
        }

        return layer;
    }
Ejemplo n.º 7
0
void ShapefileWriter::writePolygons(shared_ptr<const OsmMap> map, const QString& path)
{
  OGRRegisterAll();

  _removeShapefile(path);

  const char *pszDriverName = "ESRI Shapefile";
  OGRSFDriver *poDriver = OGRSFDriverRegistrar::GetRegistrar()->GetDriverByName(pszDriverName);
  if( poDriver == NULL )
  {
    throw HootException(QString("%1 driver not available.").arg(pszDriverName));
  }

  OGRDataSource* poDS = poDriver->CreateDataSource(path.toAscii(), NULL );
  if( poDS == NULL )
  {
    throw HootException(QString("Data source creation failed. %1").arg(path));
  }

  OgrOptions options;
  options["ENCODING"] = "UTF-8";

  OGRLayer *poLayer;

  QString layerName;
  layerName = QFileInfo(path).baseName();
  poLayer = poDS->CreateLayer(layerName.toAscii(),
                              map->getProjection().get(), wkbMultiPolygon,
                              options.getCrypticOptions());
  if( poLayer == NULL )
  {
    throw HootException(QString("Layer creation failed. %1").arg(path));
  }

  QStringList shpColumns;
  QStringList columns = getColumns(map, ElementType::Unknown);

  for (int i = 0; i < columns.size(); i++)
  {
    OGRFieldDefn oField(columns[i].toAscii(), OFTString);

    oField.SetWidth(64);

    if( poLayer->CreateField( &oField ) != OGRERR_NONE )
    {
      throw HootException(QString("Error creating field (%1).").arg(columns[i]));
    }

    shpColumns.append(poLayer->GetLayerDefn()->GetFieldDefn(i)->GetNameRef());
  }

  if (_includeInfo)
  {
    OGRFieldDefn oField("error_circ", OFTReal);
    if( poLayer->CreateField( &oField ) != OGRERR_NONE )
    {
      throw HootException(QString("Error creating field (error:circular)."));
    }
    _circularErrorIndex = poLayer->GetLayerDefn()->GetFieldCount() - 1;
  }

  const WayMap& ways = map->getWays();
  for (WayMap::const_iterator it = ways.begin(); it != ways.end(); it++)
  {
    shared_ptr<Way> way = it->second;

    if (OsmSchema::getInstance().isArea(way))
    {
      _writeWayPolygon(map, way, poLayer, columns, shpColumns);
    }
  }

  const RelationMap& relations = map->getRelationMap();
  for (RelationMap::const_iterator it = relations.begin(); it != relations.end(); it++)
  {
    shared_ptr<Relation> relation = it->second;

    if (relation->isMultiPolygon())
    {
      _writeRelationPolygon(map, relation, poLayer, columns, shpColumns);
    }
  }

  OGRDataSource::DestroyDataSource(poDS);
}
Ejemplo n.º 8
0
void ShapefileWriter::writePoints(shared_ptr<const OsmMap> map, const QString& path)
{
  OGRRegisterAll();

  _removeShapefile(path);

  const char *pszDriverName = "ESRI Shapefile";
  OGRSFDriver *poDriver = OGRSFDriverRegistrar::GetRegistrar()->GetDriverByName(pszDriverName);
  if( poDriver == NULL )
  {
    throw HootException(QString("%1 driver not available.").arg(pszDriverName));
  }

  OGRDataSource* poDS = poDriver->CreateDataSource(path.toAscii(), NULL );
  if( poDS == NULL )
  {
    throw HootException(QString("Data source creation failed. %1").arg(path));
  }

  OgrOptions options;
  options["ENCODING"] = "UTF-8";

  OGRLayer *poLayer;

  QString layerName;
  layerName = QFileInfo(path).baseName();
  poLayer = poDS->CreateLayer(layerName.toAscii(),
                              map->getProjection().get(), wkbPoint, options.getCrypticOptions());
  if( poLayer == NULL )
  {
    throw HootException(QString("Layer creation failed. %1").arg(path));
  }

  QStringList shpColumns;
  QStringList columns = getColumns(map, ElementType::Node);

  for (int i = 0; i < columns.size(); i++)
  {
    OGRFieldDefn oField(columns[i].toAscii(), OFTString);

    oField.SetWidth(64);

    if( poLayer->CreateField( &oField ) != OGRERR_NONE )
    {
      throw HootException(QString("Error creating field (%1).").arg(columns[i]));
    }

    shpColumns.append(poLayer->GetLayerDefn()->GetFieldDefn(i)->GetNameRef());
  }

  if (_includeInfo)
  {
    OGRFieldDefn oField("error_circ", OFTReal);
    if( poLayer->CreateField( &oField ) != OGRERR_NONE )
    {
      throw HootException(QString("Error creating field (error:circular)."));
    }
    _circularErrorIndex = poLayer->GetLayerDefn()->GetFieldCount() - 1;
  }

  const NodeMap& nodes = map->getNodeMap();
  for (NodeMap::const_iterator it = nodes.begin(); it != nodes.end(); ++it)
  {
    const shared_ptr<Node>& node = it->second;

    if (node->getTags().getNonDebugCount() > 0)
    {
      OGRFeature* poFeature = OGRFeature::CreateFeature( poLayer->GetLayerDefn() );
      // set all the column values.
      for (int i = 0; i < columns.size(); i++)
      {
        if (node->getTags().contains(columns[i]))
        {
          QByteArray c = shpColumns[i].toAscii();
          QByteArray v = node->getTags()[columns[i]].toUtf8();
          poFeature->SetField(c.constData(), v.constData());
        }
      }

      if (_includeInfo)
      {
        poFeature->SetField(_circularErrorIndex, node->getCircularError());
      }

      // convert the geometry.
      OGRGeometry* geom = new OGRPoint(node->getX(), node->getY());

      if (poFeature->SetGeometryDirectly(geom) != OGRERR_NONE)
      {
        throw HootException(QString("Error setting geometry"));
      }

      if (poLayer->CreateFeature(poFeature) != OGRERR_NONE)
      {
        throw HootException(QString("Error creating feature"));
      }

      OGRFeature::DestroyFeature(poFeature);
    }
  }

  OGRDataSource::DestroyDataSource(poDS);
}
Ejemplo n.º 9
0
void ShapefileWriter::writeLines(shared_ptr<const OsmMap> map, const QString& path)
{
  OGRRegisterAll();

  _removeShapefile(path);

  const char *pszDriverName = "ESRI Shapefile";
  OGRSFDriver *poDriver = OGRSFDriverRegistrar::GetRegistrar()->GetDriverByName(pszDriverName);
  if( poDriver == NULL )
  {
    throw HootException(QString("%1 driver not available.").arg(pszDriverName));
  }

  OGRDataSource* poDS = poDriver->CreateDataSource(path.toAscii(), NULL );
  if( poDS == NULL )
  {
    throw HootException(QString("Data source creation failed. %1").arg(path));
  }

  OGRLayer *poLayer;

  OgrOptions options;
  options["ENCODING"] = "UTF-8";

  QString layerName;
  layerName = QFileInfo(path).baseName();
  poLayer = poDS->CreateLayer(layerName.toAscii(),
                              map->getProjection().get(), wkbLineString,
                              options.getCrypticOptions());
  if( poLayer == NULL )
  {
    throw HootException(QString("Layer creation failed. %1").arg(path));
  }

  QStringList shpColumns;
  QStringList columns = getColumns(map, ElementType::Way);

  for (int i = 0; i < columns.size(); i++)
  {
    OGRFieldDefn oField(columns[i].toAscii(), OFTString);

    oField.SetWidth(64);

    if( poLayer->CreateField( &oField ) != OGRERR_NONE )
    {
      throw HootException(QString("Error creating field (%1).").arg(columns[i]));
    }

    shpColumns.append(poLayer->GetLayerDefn()->GetFieldDefn(i)->GetNameRef());
  }

  if (_includeInfo)
  {
    OGRFieldDefn oField("error_circ", OFTReal);
    if( poLayer->CreateField( &oField ) != OGRERR_NONE )
    {
      throw HootException(QString("Error creating field (error:circular)."));
    }
    _circularErrorIndex = poLayer->GetLayerDefn()->GetFieldCount() - 1;
  }

  const WayMap& ways = map->getWays();
  for (WayMap::const_iterator it = ways.begin(); it != ways.end(); it++)
  {
    shared_ptr<Way> way = it->second;

    if (OsmSchema::getInstance().isArea(way) == false)
    {
      OGRFeature* poFeature = OGRFeature::CreateFeature( poLayer->GetLayerDefn() );
      // set all the column values.
      for (int i = 0; i < columns.size(); i++)
      {
        if (way->getTags().contains(columns[i]))
        {
          QByteArray c = shpColumns[i].toAscii();
          QByteArray v = way->getTags()[columns[i]].toUtf8();
          poFeature->SetField(c.constData(), v.constData());
        }
      }

      if (_includeInfo)
      {
        poFeature->SetField(_circularErrorIndex, way->getCircularError());
      }

      // convert the geometry.
      std::string wkt = ElementConverter(map).convertToLineString(way)->toString();
      char* t = (char*)wkt.data();
      OGRGeometry* geom;
      if (OGRGeometryFactory::createFromWkt(&t, poLayer->GetSpatialRef(), &geom) != OGRERR_NONE)
      {
        throw HootException(QString("Error parsing WKT (%1)").arg(QString::fromStdString(wkt)));
      }

      if (poFeature->SetGeometryDirectly(geom) != OGRERR_NONE)
      {
        throw HootException(QString("Error setting geometry"));
      }

      if (poLayer->CreateFeature(poFeature) != OGRERR_NONE)
      {
        throw HootException(QString("Error creating feature"));
      }

      OGRFeature::DestroyFeature(poFeature);
    }
  }

  OGRDataSource::DestroyDataSource(poDS);
}
Ejemplo n.º 10
0
    MyOGRHandler(const std::string& driver_name, const std::string& filename) {

        OGRRegisterAll();

        OGRSFDriver* driver = OGRSFDriverRegistrar::GetRegistrar()->GetDriverByName(driver_name.c_str());
        if (!driver) {
            std::cerr << driver_name << " driver not available.\n";
            exit(1);
        }

        CPLSetConfigOption("OGR_SQLITE_SYNCHRONOUS", "FALSE");
        const char* options[] = { "SPATIALITE=TRUE", nullptr };
        m_data_source = driver->CreateDataSource(filename.c_str(), const_cast<char**>(options));
        if (!m_data_source) {
            std::cerr << "Creation of output file failed.\n";
            exit(1);
        }

        OGRSpatialReference sparef;
        sparef.importFromProj4(m_factory.proj_string().c_str());

        m_layer_point = m_data_source->CreateLayer("postboxes", &sparef, wkbPoint, nullptr);
        if (!m_layer_point) {
            std::cerr << "Layer creation failed.\n";
            exit(1);
        }

        OGRFieldDefn layer_point_field_id("id", OFTReal);
        layer_point_field_id.SetWidth(10);

        if (m_layer_point->CreateField(&layer_point_field_id) != OGRERR_NONE) {
            std::cerr << "Creating id field failed.\n";
            exit(1);
        }

        OGRFieldDefn layer_point_field_operator("operator", OFTString);
        layer_point_field_operator.SetWidth(30);

        if (m_layer_point->CreateField(&layer_point_field_operator) != OGRERR_NONE) {
            std::cerr << "Creating operator field failed.\n";
            exit(1);
        }

        /* Transactions might make things faster, then again they might not.
           Feel free to experiment and benchmark and report back. */
        m_layer_point->StartTransaction();

        m_layer_linestring = m_data_source->CreateLayer("roads", &sparef, wkbLineString, nullptr);
        if (!m_layer_linestring) {
            std::cerr << "Layer creation failed.\n";
            exit(1);
        }

        OGRFieldDefn layer_linestring_field_id("id", OFTReal);
        layer_linestring_field_id.SetWidth(10);

        if (m_layer_linestring->CreateField(&layer_linestring_field_id) != OGRERR_NONE) {
            std::cerr << "Creating id field failed.\n";
            exit(1);
        }

        OGRFieldDefn layer_linestring_field_type("type", OFTString);
        layer_linestring_field_type.SetWidth(30);

        if (m_layer_linestring->CreateField(&layer_linestring_field_type) != OGRERR_NONE) {
            std::cerr << "Creating type field failed.\n";
            exit(1);
        }

        m_layer_linestring->StartTransaction();

        m_layer_polygon = m_data_source->CreateLayer("buildings", &sparef, wkbMultiPolygon, nullptr);
        if (!m_layer_polygon) {
            std::cerr << "Layer creation failed.\n";
            exit(1);
        }

        OGRFieldDefn layer_polygon_field_id("id", OFTInteger);
        layer_polygon_field_id.SetWidth(10);

        if (m_layer_polygon->CreateField(&layer_polygon_field_id) != OGRERR_NONE) {
            std::cerr << "Creating id field failed.\n";
            exit(1);
        }

        OGRFieldDefn layer_polygon_field_type("type", OFTString);
        layer_polygon_field_type.SetWidth(30);

        if (m_layer_polygon->CreateField(&layer_polygon_field_type) != OGRERR_NONE) {
            std::cerr << "Creating type field failed.\n";
            exit(1);
        }

        m_layer_polygon->StartTransaction();
    }
Ejemplo n.º 11
0
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;
}
Ejemplo n.º 12
0
void CDlg_GISDataExchange::ExportToGISFile(LPCTSTR lpszCSVFileName,LPCTSTR lpszShapeFileName, CString GISTypeString )
{

#ifndef _WIN64

	m_MessageList.ResetContent ();

	CWaitCursor wait;
	CCSVParser parser;
	int i= 0;


	// open csv file
	if (parser.OpenCSVFile(lpszCSVFileName))
	{

		CString message_str;

		OGRSFDriver *poDriver;

		OGRRegisterAll();

		poDriver = OGRSFDriverRegistrar::GetRegistrar()->GetDriverByName(GISTypeString );
		if( poDriver == NULL )
		{
			message_str.Format ( "%s driver not available.", GISTypeString );
			m_MessageList.AddString (message_str);
			return;
		}

		OGRDataSource *poDS;

		poDS = poDriver->CreateDataSource(lpszShapeFileName, NULL );
		if( poDS == NULL )
		{
			message_str.Format ( "Creation of GIS output file %s failed.\nPlease do not overwrite the exiting file and please select a new file name.", 
				lpszShapeFileName );
			m_MessageList.AddString (message_str);
			return;
		}

		///// export to link layer

		// link layer 

		OGRLayer *poLayer;
		poLayer = poDS->CreateLayer( "link", NULL, wkbLineString, NULL );
		if( poLayer == NULL )
		{
			m_MessageList.AddString ("link Layer creation failed");
			return;
		}



		vector<string> HeaderVector = parser.GetHeaderVector();

		std::vector <CString> LongFieldVector;
		for(unsigned int i = 0; i < HeaderVector.size(); i++)
		{
			if(HeaderVector[i].find ("geometry") !=  string::npos||  HeaderVector[i].find ("name") !=  string::npos || HeaderVector[i].find ("code") !=  string::npos)
			{
				OGRFieldDefn oField (HeaderVector[i].c_str (), OFTString);

				CString str;  
				if( poLayer->CreateField( &oField ) != OGRERR_NONE ) 
				{ 
					str.Format("Creating field %s failed", oField.GetNameRef()); 

					m_MessageList.AddString (str);
					return; 

				}
			}else
			{
				CString field_string  = HeaderVector[i].c_str ();

				OGRFieldDefn oField (field_string, OFTReal);

				CString str;  
				if( poLayer->CreateField( &oField ) != OGRERR_NONE ) 
				{ 
					str.Format("Creating field %s failed", oField.GetNameRef()); 

					m_MessageList.AddString (str);
					return; 
				}

			}

			if(HeaderVector[i].size()>=11)
			{
				LongFieldVector.push_back (HeaderVector[i].c_str ());
			}

		}

		message_str.Format ("%d fields have been created.",HeaderVector.size());
		m_MessageList.AddString (message_str);

		if(LongFieldVector.size() >=1)
		{
			message_str.Format("Warning: Arc GIS file only supports field names with not more than 10 characters.\nThe following fields have long field names. "); 
			m_MessageList.AddString (message_str);
			for(unsigned l = 0; l< LongFieldVector.size(); l++)
			{
				message_str.Format ("%s",LongFieldVector[l]);
				m_MessageList.AddString (message_str);


			}
		}

		int count = 0 ;
		while(parser.ReadRecord())
		{
			//create feature
			OGRFeature *poFeature;
			poFeature = OGRFeature::CreateFeature( poLayer->GetLayerDefn() );

			//step 1: write all fields except geometry
			for(unsigned int i = 0; i < HeaderVector.size(); i++)
			{
				if(HeaderVector[i]!="geometry")
				{
					if(HeaderVector[i].find ("name") !=  string::npos || HeaderVector[i].find ("code") !=  string::npos)
					{

						std::string str_value;

						parser.GetValueByFieldName(HeaderVector[i],str_value);

						//							TRACE("field: %s, value = %s\n",HeaderVector[i].c_str (),str_value.c_str ());
						poFeature->SetField(i,str_value.c_str ());
					}else
					{
						double value = 0;

						parser.GetValueByFieldName(HeaderVector[i],value);

						//							TRACE("field: %s, value = %f\n",HeaderVector[i].c_str (),value);

						CString field_name = HeaderVector[i].c_str ();
						poFeature->SetField(i,value);



					}

				}
			}

			string geo_string;
			std::vector<CCoordinate> CoordinateVector;
			if(parser.GetValueByFieldName("geometry",geo_string))
			{
				// overwrite when the field "geometry" exists
				CGeometry geometry(geo_string);
				CoordinateVector = geometry.GetCoordinateList();

				if( m_GIS_data_type == GIS_Point_Type && CoordinateVector.size ()==1)
				{
					OGRPoint pt;
					pt.setX( CoordinateVector[0].X );
					pt.setY( CoordinateVector[0].Y);
					poFeature->SetGeometry( &pt ); 

				}



				if( m_GIS_data_type == GIS_Line_Type)
				{


					OGRLineString line;
					for(unsigned int si = 0; si< CoordinateVector.size(); si++)
					{
						line.addPoint (CoordinateVector[si].X , CoordinateVector[si].Y);
					}

					poFeature->SetGeometry( &line ); 
				}


				if( m_GIS_data_type == GIS_Polygon_Type)
				{

					OGRPolygon polygon;
					OGRLinearRing  ring;

					for(unsigned int si = 0; si<  CoordinateVector.size(); si++)
					{
						ring.addPoint (CoordinateVector[si].X , CoordinateVector[si].Y,1);
					}

					polygon.addRing(&ring);

					poFeature->SetGeometry( &polygon ); 

				}


			} else
			{ // no geometry field


				/// create geometry data from m_GIS_data_type == GIS_Point_Type

				if( m_GIS_data_type == GIS_Point_Type )
				{

					double x, y;
					if(parser.GetValueByFieldName("x",x) && parser.GetValueByFieldName("y",y) )
					{
						OGRPoint pt;
						pt.setX( CoordinateVector[0].X );
						pt.setY( CoordinateVector[0].Y);
						poFeature->SetGeometry( &pt ); 

					}else
					{
						AfxMessageBox("Pleaes prepare fields x and y in the csv file in order to create a node GIS layer.", MB_ICONINFORMATION);
						return;

					}

				}

				///create geometry

				if( m_GIS_data_type == GIS_Line_Type)
				{

					int number_of_shape_points = 0;
					if(parser.GetValueByFieldName("number_of_shape_points", number_of_shape_points))
					{

						if(number_of_shape_points>=2)
						{

							OGRLineString line;

							for(int s= 1; s<= number_of_shape_points; s++)
							{
								CString str_x, str_y;
								str_x.Format ("x%d",s);
								str_y.Format ("y%d",s);
								double x = 0;
								double y = 0;

								string string_x, string_y;
								string_x  = m_pDoc->CString2StdString (str_x);
								string_y  = m_pDoc->CString2StdString (str_y);

								if(parser.GetValueByFieldName(string_x, x) && parser.GetValueByFieldName(string_y, y))
								{
									line.addPoint(x,y);
								}else
								{
									AfxMessageBox("Pleaes prepare fields x1,y1,x2,y2,...,xn,yn in the csv file in order to create a link GIS layer.", MB_ICONINFORMATION);

									return; 
								}


							}
							poFeature->SetGeometry( &line ); 

						}

					}else
					{ 
						AfxMessageBox("Pleaes prepare fields number_of_shape_points, x1,y1,x2,y2,...,xn,yn in the csv file in order to create a link GIS layer.", MB_ICONINFORMATION);
						return;
					}


				}

				// 


				if( m_GIS_data_type == GIS_Polygon_Type)
				{

					OGRPolygon polygon;
					OGRLinearRing  ring;

					int number_of_shape_points = 0;
					if(parser.GetValueByFieldName("number_of_shape_points", number_of_shape_points))
					{

						if(number_of_shape_points>=2)
						{

							OGRLineString line;

							for(int s= 0; s< number_of_shape_points; s++)
							{
								CString str_x, str_y;
								str_x.Format ("x%d",str_x);
								str_y.Format ("y%d",str_y);
								double x = 0;
								double y = 0;

								string string_x, string_y;
								string_x  = m_pDoc->CString2StdString (str_x);
								string_y  = m_pDoc->CString2StdString (str_y);

								if(parser.GetValueByFieldName(string_x, x) && parser.GetValueByFieldName(string_y, y))
								{
									ring.addPoint (x,y,1);
								}else
								{
									AfxMessageBox("Pleaes prepare fields x1,y1,x2,y2,...,xn,yn in the csv file in order to create a zone GIS layer.", MB_ICONINFORMATION);

									return; 
								}

							}
							polygon.addRing(&ring);

							poFeature->SetGeometry( &polygon ); 

						}


					}


				}

			}


			if( poLayer->CreateFeature( poFeature ) != OGRERR_NONE )
			{
				AfxMessageBox("Failed to create line feature in shapefile.\n");
				return;

			}  

			OGRFeature::DestroyFeature( poFeature );

			count++;
		}

		message_str.Format ("%d records have been created.",count);
		m_MessageList.AddString (message_str);


		OGRDataSource::DestroyDataSource( poDS );

		CString ShapeFile = lpszShapeFileName;
		CString ShapeFileFolder = ShapeFile.Left(ShapeFile.ReverseFind('\\') + 1);

		ShellExecute( NULL,  "explore", ShapeFileFolder, NULL,  NULL, SW_SHOWNORMAL );

	}
#endif

}
Ejemplo n.º 13
0
bool GdaCache::CacheLayer(std::string ext_ds_name, 
						  OGRLayerProxy* ext_layer_proxy)
{
	OGRLayer* poSrcLayer = ext_layer_proxy->layer;
	
	// get information from current layer: geomtype, layer_name
    // (NOTE: we don't consider coodinator system and translation here)
    OGRFeatureDefn *poSrcFDefn = poSrcLayer->GetLayerDefn();
    int eGType = poSrcFDefn->GetGeomType();
    const char* pszNewLayerName = poSrcLayer->GetName();
    int bForceToPolygon = FALSE;
    int bForceToMultiPolygon = FALSE;
    int bForceToMultiLineString = FALSE;
	
    if( wkbFlatten(eGType) == wkbPolygon )
        bForceToPolygon = TRUE;
    else if( wkbFlatten(eGType) == wkbMultiPolygon )
        bForceToMultiPolygon = TRUE;
    else if( wkbFlatten(eGType) == wkbMultiLineString )
        bForceToMultiLineString = TRUE;
	
	//Setup coordinate transformation if we need it.
	OGRCoordinateTransformation *poCT = NULL;
	bool bTransform                   = FALSE;
	OGRSpatialReference *poSourceSRS = NULL;
	// todo
	OGRSpatialReference *poOutputSRS = new OGRSpatialReference("EPSG:4326");

	// Cache
	char *papszLCO[] = {"OVERWRITE=yes","FORMAT=Spatialite"};
	std::string cache_layer_name = ext_ds_name + "_"+ext_layer_proxy->name;
    OGRDataSource *poDstDS = cach_ds_proxy->ds;
    OGRLayer *poDstLayer = poDstDS->CreateLayer(cache_layer_name.c_str(), 
												poOutputSRS, 
												(OGRwkbGeometryType)eGType, 
												papszLCO);
	if (poDstLayer == NULL) {
		// raise create cache failed.
		return false;
	}
    // Process Layer style table
    poDstLayer->SetStyleTable( poSrcLayer->GetStyleTable () );
	
    // Add fields. here to copy all field.
    int nSrcFieldCount = poSrcFDefn->GetFieldCount();
    int iField;
    OGRFeatureDefn *poDstFDefn = poDstLayer->GetLayerDefn();
	
    for( iField = 0; iField < nSrcFieldCount; iField++ )
    {    
        OGRFieldDefn* poSrcFieldDefn = poSrcFDefn->GetFieldDefn(iField);
        OGRFieldDefn oFieldDefn( poSrcFieldDefn );
		
        // The field may have been already created at layer creation 
		if (poDstLayer->CreateField( &oFieldDefn ) == OGRERR_NONE)
        {    
            // now that we've created a field, GetLayerDefn() won't return NULL
            if (poDstFDefn == NULL)
                poDstFDefn = poDstLayer->GetLayerDefn();
        }    
    }    
	
    // Transfer feature from Source Layer to Dest Layer
    OGRFeature  *poFeature;
    GIntBig      nFeaturesWritten = 0;
    poSrcLayer->ResetReading();
	
    while (poFeature = poSrcLayer->GetNextFeature())
    {
        OGRFeature *poDstFeature = OGRFeature::CreateFeature(
										poDstLayer->GetLayerDefn() );
        poDstFeature->SetFrom(poFeature);
		
        OGRGeometry *poDstGeometry = poDstFeature->GetGeometryRef();
        if (poDstGeometry != NULL)
        {
            if( bForceToPolygon )
            {
                poDstFeature->SetGeometryDirectly(
					OGRGeometryFactory::forceToPolygon(
						poDstFeature->StealGeometry()));
            }
            else if( bForceToMultiPolygon )
            {
                poDstFeature->SetGeometryDirectly(
					OGRGeometryFactory::forceToMultiPolygon(
					    poDstFeature->StealGeometry() ) );
            }
            else if ( bForceToMultiLineString )
            {
                poDstFeature->SetGeometryDirectly(
					OGRGeometryFactory::forceToMultiLineString(
						poDstFeature->StealGeometry() ) );
            }
        }
        if( poDstLayer->CreateFeature( poDstFeature ) == OGRERR_NONE )
        {
            nFeaturesWritten ++;
        }            
        OGRFeature::DestroyFeature( poDstFeature );
        OGRFeature::DestroyFeature( poFeature );
    }
    OGRDataSource::DestroyDataSource(poDstDS);
    // XXX
    // delete poDstLayer;
	return true;
}
Ejemplo n.º 14
0
// export
bool ImportExportGdal::export_(const QList<Feature *>& featList)
{
    const char *pszDriverName = "SQLite";
    OGRSFDriver *poDriver;

    OGRRegisterAll();

    poDriver = OGRSFDriverRegistrar::GetRegistrar()->GetDriverByName(pszDriverName);
    if( poDriver == NULL )
    {
        qDebug( "%s driver not available.", pszDriverName );
        return false;
    }

    OGRDataSource *poDS;

    QFile::remove(QString(HOMEDIR + "/test.sqlite"));
    poDS = poDriver->CreateDataSource( QString(HOMEDIR + "/test.sqlite").toUtf8().constData(), NULL );
    if( poDS == NULL )
    {
        qDebug( "Creation of output file failed." );
        return false;
    }
    poDS->ExecuteSQL("PRAGMA synchronous = OFF", NULL, NULL);

    OGRSpatialReference *poSRS;
    poSRS = new OGRSpatialReference();
    poSRS->importFromEPSG(4326);

    char **papszOptions = NULL;
    papszOptions = CSLSetNameValue( papszOptions, "SPATIALITE", "YES" );
    papszOptions = CSLSetNameValue( papszOptions, "FORMAT", "SPATIALITE" );
    papszOptions = CSLSetNameValue( papszOptions, "SPATIAL_INDEX", "YES" );

    OGRLayer *poLayer;
    poLayer = poDS->CreateLayer( "osm", poSRS, wkbUnknown, papszOptions);
    CSLDestroy( papszOptions );

    if( poLayer == NULL )
    {
        qDebug( "Layer creation failed." );
        return false;
    }

    OGRFieldDefn oField("osm_id", OFTReal);
    if( poLayer->CreateField( &oField ) != OGRERR_NONE )
    {
        qDebug( "Creating field failed." );
        return false;
    }
    oField.Set("osm_version", OFTInteger );
    poLayer->CreateField( &oField );
    oField.Set("osm_timestamp", OFTInteger );
    poLayer->CreateField( &oField );

    OGRFeature *poFeature;
    foreach (Feature* F, featList) {
        poFeature = OGRFeature::CreateFeature( poLayer->GetLayerDefn() );
        poFeature->SetField( "osm_id", (qreal)(F->id().numId));
#ifndef FRISIUS_BUILD
        poFeature->SetField( "osm_version", F->versionNumber());
        poFeature->SetField( "osm_timestamp", (int)F->time().toTime_t());
#endif

        if (CHECK_NODE(F)) {
            Node* N = STATIC_CAST_NODE(F);

            OGRPoint pt;
            pt.setX(N->position().x());
            pt.setY(N->position().y());

            poFeature->SetGeometry( &pt );
        } else if (CHECK_WAY(F)) {
            Way* W = STATIC_CAST_WAY(F);

            OGRLineString ls;
            ls.setNumPoints(W->size());
            for (int i=0; i<W->size(); ++i) {
                ls.setPoint(i, W->getNode(i)->position().x(), W->getNode(i)->position().y(), 0);
            }
            poFeature->SetGeometry( &ls );
        }

        if( poLayer->CreateFeature( poFeature ) != OGRERR_NONE )
        {
           qDebug( "Failed to create feature in output." );
           return false;
        }
        OGRFeature::DestroyFeature( poFeature );
    }
Ejemplo n.º 15
0
void writePolygons(RegionMap* regionMap)
{
    char* driverName = (char *)ogrDriver->c_str();
    char* outFilePath =  (char *)outFile->c_str();

    cout << "Creating output file \"" << outFilePath << "\" (\"" << driverName << "\" format)...";
    OGRSFDriver* driver = (OGRSFDriver*)OGRSFDriverRegistrar::GetRegistrar()->GetDriverByName(ogrDriver->c_str());
    if (driver == NULL) {
        localExit(new string(string("FATAL: OGR driver \"") + string(driverName) +  string("\" is not available.\n")), 1);
    }
    
    char* dataSourceName = NULL;
    bool cleanupDataSource = false;
    if (ogrDriver->compare("KML") == 0 && kmlStyleFile != NULL) {
        dataSourceName = tmpnam(NULL);
        //mkstemp(dataSourceName);
        cleanupDataSource = true;
    }
    else if (ogrDriver->compare("ESRI Shapefile") == 0) {
        string* dsStr = removeFromLastOccurrence(outFilePath, '/');
        dsStr = removeFromLastOccurrence((char *)dsStr->c_str(), '\\');
        dataSourceName = (char *)dsStr->c_str();
    } else {
        dataSourceName = outFilePath;
    }
    
    OGRDataSource* ds = driver->CreateDataSource(dataSourceName);
    if(ds == NULL) {
        localExit(new string(string("FATAL: Unable to create output file \"") + string(outFilePath) + string("\"\n")), 1);
    }
    
    cout << "[ok]\n";

    OGRCoordinateTransformation* transform = NULL;
    const string* rmSpatialRefStr = regionMap->getSpatialRef();
    if (rmSpatialRefStr != NULL && rmSpatialRefStr->compare("") != 0) {
        OGRSpatialReference* spatialRef = new OGRSpatialReference(rmSpatialRefStr->c_str());
        transform = OGRCreateCoordinateTransformation(spatialRef, outSpatialRef);
    }

    char* layerName = (char *)pointToFilename(outFilePath, true)->c_str();
    OGRLayer* layer = ds->CreateLayer(layerName, outSpatialRef, wkbPolygon);
    layer->CreateField(new OGRFieldDefn("RegionID", OFTInteger), 0);
    layer->CreateField(new OGRFieldDefn("Category", OFTString), 0);
    layer->CreateField(new OGRFieldDefn("Threshold", OFTReal), 0);

    cout << "Writing polygon data to file...";
    int count = 0;
    int currRegionID = 0;
    int numRegions =  regionMap->getNumRegions();
    while (currRegionID < numRegions) {

        Region *currRegion = regionMap->getRegion(currRegionID);
        Polygon* poly = currRegion->toPolygon();
        if(poly == NULL) {
            currRegionID += 1;
            continue;
        }
        count++;

        OGRFeature* feature = new OGRFeature(layer->GetLayerDefn());
        feature->SetField(feature->GetFieldIndex("RegionID"), currRegionID);
        feature->SetField(feature->GetFieldIndex("Category"), currRegion->getCategory()->getName()->c_str());
        feature->SetField(feature->GetFieldIndex("Threshold"), currRegion->getCategory()->minThreshold());

        OGRGeometry* geom = BuildOgrPolygon(poly, transform);
        feature->SetGeometry(geom);

        if (layer->CreateFeature(feature) != OGRERR_NONE)
            localExit(new string("ERROR: Unable to create feature for region #\n"), 2);

        //OGRFeature::DestroyFeature(feature);
        currRegionID += 1;

        if (currRegionID % 100 == 0)
            cout << ".";
    }
    //CPLFree(transform);
    //CPLFree(layer);
    OGRDataSource::DestroyDataSource(ds);
    cout << "[ok] Wrote "<< count << " polygons\n";

    if(kmlStyleFile != NULL) {
#ifdef USE_XALAN
        XALAN_USING_XERCES(XMLPlatformUtils)
        XALAN_USING_XALAN(XalanTransformer)
        XMLPlatformUtils::Initialize();
        XalanTransformer::initialize();
        XalanTransformer theXalanTransformer;
        cout << "Transforing KML file ..." << outFile->c_str();
        if(theXalanTransformer.transform(dataSourceName, kmlStyleFile->c_str(), outFile->c_str()) != 0) {
            cout << "[!!]\n";
            cout << "ERROR doing XSLT transform using " << kmlStyleFile->c_str() << "\n";
        } else {
            cout << "...[ok]\n";
        }
#endif /* USE_XALAN */
#ifdef USE_LIBXSLT
        xsltStylesheetPtr cur = NULL;
        xmlDocPtr doc, res;
        const char *params[16 + 1];
        params[0] = NULL;
        xmlSubstituteEntitiesDefault(1);
        xmlLoadExtDtdDefaultValue = 1;
        cur = xsltParseStylesheetFile((const xmlChar *) kmlStyleFile->c_str());
        doc = xmlParseFile(dataSourceName);
        res = xsltApplyStylesheet(cur, doc, params);
        FILE* f = fopen(outFile->c_str(), "w");
        xsltSaveResultToFile(f, res, cur);
        fclose(f);

        xsltFreeStylesheet(cur);
        xmlFreeDoc(res);
        xmlFreeDoc(doc);

        xsltCleanupGlobals();
        xmlCleanupParser();
#endif /* USE_LIBXSLT */
    }
    if(cleanupDataSource) {
        if(!remove(dataSourceName)) {
            fprintf(stderr, "Error deleting temporary file: %s\n", dataSourceName);
        }
    }
}
Ejemplo n.º 16
0
int main(int argc, char *argv[])
{
    LogPolicy::GetInstance().Unmute();
    try
    {
        // enable logging
        if (argc < 3)
        {
            SimpleLogger().Write(logWARNING) << "usage:\n" << argv[0]
                                             << " <osrm> <osrm.restrictions>";
            return -1;
        }

        SimpleLogger().Write() << "Using restrictions from file: " << argv[2];
        std::ifstream restriction_ifstream(argv[2], std::ios::binary);
        const FingerPrint fingerprint_orig;
        FingerPrint fingerprint_loaded;
        restriction_ifstream.read((char *)&fingerprint_loaded, sizeof(FingerPrint));

        // check fingerprint and warn if necessary
        if (!fingerprint_loaded.TestGraphUtil(fingerprint_orig))
        {
            SimpleLogger().Write(logWARNING) << argv[2] << " was prepared with a different build. "
                                                           "Reprocess to get rid of this warning.";
        }

        if (!restriction_ifstream.good())
        {
            throw osrm::exception("Could not access <osrm-restrictions> files");
        }
        uint32_t usable_restrictions = 0;
        restriction_ifstream.read((char *)&usable_restrictions, sizeof(uint32_t));
        restriction_list.resize(usable_restrictions);

        // load restrictions
        if (usable_restrictions > 0)
        {
            restriction_ifstream.read((char *)&(restriction_list[0]),
                                      usable_restrictions * sizeof(TurnRestriction));
        }
        restriction_ifstream.close();

        std::ifstream input_stream(argv[1], std::ifstream::in | std::ifstream::binary);
        if (!input_stream.is_open())
        {
            throw osrm::exception("Cannot open osrm file");
        }

        // load graph data
        std::vector<ImportEdge> edge_list;
        const NodeID number_of_nodes = readBinaryOSRMGraphFromStream(input_stream,
                                                                     edge_list,
                                                                     bollard_node_list,
                                                                     traffic_lights_list,
                                                                     &coordinate_list,
                                                                     restriction_list);
        input_stream.close();


        BOOST_ASSERT_MSG(restriction_list.size() == usable_restrictions,
                         "size of restriction_list changed");

        SimpleLogger().Write() << restriction_list.size() << " restrictions, "
                               << bollard_node_list.size() << " bollard nodes, "
                               << traffic_lights_list.size() << " traffic lights";

        traffic_lights_list.clear();
        traffic_lights_list.shrink_to_fit();

        // Building an node-based graph
        DeallocatingVector<TarjanEdge> graph_edge_list;
        for (const NodeBasedEdge &input_edge : edge_list)
        {
            if (input_edge.source == input_edge.target)
            {
                continue;
            }

            if (input_edge.forward)
            {
                graph_edge_list.emplace_back(input_edge.source,
                                       input_edge.target,
                                       (std::max)((int)input_edge.weight, 1),
                                       input_edge.name_id);
            }
            if (input_edge.backward)
            {
                graph_edge_list.emplace_back(input_edge.target,
                                       input_edge.source,
                                       (std::max)((int)input_edge.weight, 1),
                                       input_edge.name_id);
            }
        }
        edge_list.clear();
        edge_list.shrink_to_fit();
        BOOST_ASSERT_MSG(0 == edge_list.size() && 0 == edge_list.capacity(),
                         "input edge vector not properly deallocated");

        tbb::parallel_sort(graph_edge_list.begin(), graph_edge_list.end());
        auto graph = std::make_shared<TarjanDynamicGraph>(number_of_nodes, graph_edge_list);
        edge_list.clear();
        edge_list.shrink_to_fit();

        SimpleLogger().Write() << "Starting SCC graph traversal";

        RestrictionMap restriction_map(restriction_list);
        auto tarjan = osrm::make_unique<TarjanSCC<TarjanDynamicGraph>>(graph,
                                                                       restriction_map,
                                                                       bollard_node_list);
        tarjan->run();
        SimpleLogger().Write() << "identified: " << tarjan->get_number_of_components()
                           << " many components";
        SimpleLogger().Write() << "identified " << tarjan->get_size_one_count() << " SCCs of size 1";

        // output
        TIMER_START(SCC_RUN_SETUP);

        // remove files from previous run if exist
        DeleteFileIfExists("component.dbf");
        DeleteFileIfExists("component.shx");
        DeleteFileIfExists("component.shp");

        Percent p(graph->GetNumberOfNodes());

        OGRRegisterAll();

        const char *pszDriverName = "ESRI Shapefile";
        OGRSFDriver *poDriver =
            OGRSFDriverRegistrar::GetRegistrar()->GetDriverByName(pszDriverName);
        if (nullptr == poDriver)
        {
            throw osrm::exception("ESRI Shapefile driver not available");
        }
        OGRDataSource *poDS = poDriver->CreateDataSource("component.shp", nullptr);

        if (nullptr == poDS)
        {
            throw osrm::exception("Creation of output file failed");
        }

        OGRSpatialReference *poSRS = new OGRSpatialReference();
        poSRS->importFromEPSG(4326);

        OGRLayer *poLayer = poDS->CreateLayer("component", poSRS, wkbLineString, nullptr);

        if (nullptr == poLayer)
        {
            throw osrm::exception("Layer creation failed.");
        }
        TIMER_STOP(SCC_RUN_SETUP);
        SimpleLogger().Write() << "shapefile setup took " << TIMER_MSEC(SCC_RUN_SETUP)/1000. << "s";

        uint64_t total_network_distance = 0;
        p.reinit(graph->GetNumberOfNodes());
        TIMER_START(SCC_OUTPUT);
        for (const NodeID source : osrm::irange(0u, graph->GetNumberOfNodes()))
        {
            p.printIncrement();
            for (const auto current_edge : graph->GetAdjacentEdgeRange(source))
            {
                const TarjanDynamicGraph::NodeIterator target = graph->GetTarget(current_edge);

                if (source < target || graph->EndEdges(target) == graph->FindEdge(target, source))
                {
                    total_network_distance +=
                        100 * FixedPointCoordinate::ApproximateEuclideanDistance(
                                  coordinate_list[source].lat,
                                  coordinate_list[source].lon,
                                  coordinate_list[target].lat,
                                  coordinate_list[target].lon);

                    BOOST_ASSERT(current_edge != SPECIAL_EDGEID);
                    BOOST_ASSERT(source != SPECIAL_NODEID);
                    BOOST_ASSERT(target != SPECIAL_NODEID);

                    const unsigned size_of_containing_component =
                        std::min(tarjan->get_component_size(source),
                                 tarjan->get_component_size(target));

                    // edges that end on bollard nodes may actually be in two distinct components
                    if (size_of_containing_component < 1000)
                    {
                        OGRLineString lineString;
                        lineString.addPoint(coordinate_list[source].lon / COORDINATE_PRECISION,
                                            coordinate_list[source].lat / COORDINATE_PRECISION);
                        lineString.addPoint(coordinate_list[target].lon / COORDINATE_PRECISION,
                                            coordinate_list[target].lat / COORDINATE_PRECISION);

                        OGRFeature *poFeature = OGRFeature::CreateFeature(poLayer->GetLayerDefn());

                        poFeature->SetGeometry(&lineString);
                        if (OGRERR_NONE != poLayer->CreateFeature(poFeature))
                        {
                            throw osrm::exception("Failed to create feature in shapefile.");
                        }
                        OGRFeature::DestroyFeature(poFeature);
                    }
                }
            }
        }
        OGRSpatialReference::DestroySpatialReference(poSRS);
        OGRDataSource::DestroyDataSource(poDS);
        TIMER_STOP(SCC_OUTPUT);
        SimpleLogger().Write() << "generating output took: " << TIMER_MSEC(SCC_OUTPUT)/1000. << "s";

        SimpleLogger().Write() << "total network distance: "
                               << (uint64_t)total_network_distance / 100 / 1000. << " km";

        SimpleLogger().Write() << "finished component analysis";
    }
    catch (const std::exception &e)
    {
        SimpleLogger().Write(logWARNING) << "[exception] " << e.what();
    }
    return 0;
}
Ejemplo n.º 17
0
    TestHandler(OGRDataSource* data_source) :
        m_data_source(data_source),
        m_out("multipolygon-tests.json") {

        OGRSpatialReference sparef;
        sparef.SetWellKnownGeogCS("WGS84");

        /**************/

        m_layer_point = m_data_source->CreateLayer("points", &sparef, wkbPoint, nullptr);
        if (!m_layer_point) {
            std::cerr << "Layer creation failed.\n";
            exit(1);
        }

        OGRFieldDefn layer_point_field_id("id", OFTReal);
        layer_point_field_id.SetWidth(10);

        if (m_layer_point->CreateField(&layer_point_field_id) != OGRERR_NONE) {
            std::cerr << "Creating id field failed.\n";
            exit(1);
        }

        OGRFieldDefn layer_point_field_type("type", OFTString);
        layer_point_field_type.SetWidth(30);

        if (m_layer_point->CreateField(&layer_point_field_type) != OGRERR_NONE) {
            std::cerr << "Creating type field failed.\n";
            exit(1);
        }

        /**************/

        m_layer_linestring = m_data_source->CreateLayer("lines", &sparef, wkbLineString, nullptr);
        if (!m_layer_linestring) {
            std::cerr << "Layer creation failed.\n";
            exit(1);
        }

        OGRFieldDefn layer_linestring_field_id("id", OFTReal);
        layer_linestring_field_id.SetWidth(10);

        if (m_layer_linestring->CreateField(&layer_linestring_field_id) != OGRERR_NONE) {
            std::cerr << "Creating id field failed.\n";
            exit(1);
        }

        OGRFieldDefn layer_linestring_field_type("type", OFTString);
        layer_linestring_field_type.SetWidth(30);

        if (m_layer_linestring->CreateField(&layer_linestring_field_type) != OGRERR_NONE) {
            std::cerr << "Creating type field failed.\n";
            exit(1);
        }

        /**************/

        m_layer_polygon = m_data_source->CreateLayer("multipolygons", &sparef, wkbMultiPolygon, nullptr);
        if (!m_layer_polygon) {
            std::cerr << "Layer creation failed.\n";
            exit(1);
        }

        OGRFieldDefn layer_polygon_field_id("id", OFTInteger);
        layer_polygon_field_id.SetWidth(10);

        if (m_layer_polygon->CreateField(&layer_polygon_field_id) != OGRERR_NONE) {
            std::cerr << "Creating id field failed.\n";
            exit(1);
        }

        OGRFieldDefn layer_polygon_field_from_type("from_type", OFTString);
        layer_polygon_field_from_type.SetWidth(1);

        if (m_layer_polygon->CreateField(&layer_polygon_field_from_type) != OGRERR_NONE) {
            std::cerr << "Creating from_type field failed.\n";
            exit(1);
        }
    }
Ejemplo n.º 18
0
int main( int nArgc, char ** papszArgv )

{
    int   nFirstSourceDataset = -1, bLayersWildcarded = TRUE, iArg;
    const char *pszFormat = "ESRI Shapefile";
    const char *pszTileIndexField = "LOCATION";
    const char *pszOutputName = NULL;
    int write_absolute_path = FALSE;
    int skip_different_projection = FALSE;
    char* current_path = NULL;
    int accept_different_schemas = FALSE;
    int bFirstWarningForNonMatchingAttributes = TRUE;
    
    /* Check strict compilation and runtime library version as we use C++ API */
    if (! GDAL_CHECK_VERSION(papszArgv[0]))
        exit(1);
/* -------------------------------------------------------------------- */
/*      Register format(s).                                             */
/* -------------------------------------------------------------------- */
    OGRRegisterAll();
    
/* -------------------------------------------------------------------- */
/*      Processing command line arguments.                              */
/* -------------------------------------------------------------------- */
    for( iArg = 1; iArg < nArgc; iArg++ )
    {
        if( EQUAL(papszArgv[iArg], "--utility_version") )
        {
            printf("%s was compiled against GDAL %s and is running against GDAL %s\n",
                   papszArgv[0], GDAL_RELEASE_NAME, GDALVersionInfo("RELEASE_NAME"));
            return 0;
        }
        else if( EQUAL(papszArgv[iArg],"-f") && iArg < nArgc-1 )
        {
            pszFormat = papszArgv[++iArg];
        }
        else if( EQUAL(papszArgv[iArg],"-write_absolute_path"))
        {
            write_absolute_path = TRUE;
        }
        else if( EQUAL(papszArgv[iArg],"-skip_different_projection"))
        {
            skip_different_projection = TRUE;
        }
        else if( EQUAL(papszArgv[iArg],"-accept_different_schemas"))
        {
            accept_different_schemas = TRUE;
        }
        else if( EQUAL(papszArgv[iArg],"-tileindex") && iArg < nArgc-1 )
        {
            pszTileIndexField = papszArgv[++iArg];
        }
        else if( EQUAL(papszArgv[iArg],"-lnum") 
                 || EQUAL(papszArgv[iArg],"-lname") )
        {
            iArg++;
            bLayersWildcarded = FALSE;
        }
        else if( papszArgv[iArg][0] == '-' )
            Usage();
        else if( pszOutputName == NULL )
            pszOutputName = papszArgv[iArg];
        else if( nFirstSourceDataset == -1 )
            nFirstSourceDataset = iArg;
    }

    if( pszOutputName == NULL || nFirstSourceDataset == -1 )
        Usage();

/* -------------------------------------------------------------------- */
/*      Try to open as an existing dataset for update access.           */
/* -------------------------------------------------------------------- */
    OGRDataSource *poDstDS;
    OGRLayer *poDstLayer = NULL;

    poDstDS = OGRSFDriverRegistrar::Open( pszOutputName, TRUE );

/* -------------------------------------------------------------------- */
/*      If that failed, find the driver so we can create the tile index.*/
/* -------------------------------------------------------------------- */
    if( poDstDS == NULL )
    {
        OGRSFDriverRegistrar     *poR = OGRSFDriverRegistrar::GetRegistrar();
        OGRSFDriver              *poDriver = NULL;
        int                      iDriver;

        for( iDriver = 0;
             iDriver < poR->GetDriverCount() && poDriver == NULL;
             iDriver++ )
        {
            if( EQUAL(poR->GetDriver(iDriver)->GetName(),pszFormat) )
            {
                poDriver = poR->GetDriver(iDriver);
            }
        }

        if( poDriver == NULL )
        {
            fprintf( stderr, "Unable to find driver `%s'.\n", pszFormat );
            fprintf( stderr, "The following drivers are available:\n" );
        
            for( iDriver = 0; iDriver < poR->GetDriverCount(); iDriver++ )
            {
                fprintf( stderr, "  -> `%s'\n", poR->GetDriver(iDriver)->GetName() );
            }
            exit( 1 );
        }

        if( !poDriver->TestCapability( ODrCCreateDataSource ) )
        {
            fprintf( stderr, "%s driver does not support data source creation.\n",
                    pszFormat );
            exit( 1 );
        }

/* -------------------------------------------------------------------- */
/*      Now create it.                                                  */
/* -------------------------------------------------------------------- */
        
        poDstDS = poDriver->CreateDataSource( pszOutputName, NULL );
        if( poDstDS == NULL )
        {
            fprintf( stderr, "%s driver failed to create %s\n", 
                    pszFormat, pszOutputName );
            exit( 1 );
        }

        if( poDstDS->GetLayerCount() == 0 )
        {
            OGRFieldDefn oLocation( pszTileIndexField, OFTString );
            
            oLocation.SetWidth( 200 );
            
            if( nFirstSourceDataset < nArgc && papszArgv[nFirstSourceDataset][0] == '-' )
            {
                nFirstSourceDataset++;
            }
            
            OGRSpatialReference* poSrcSpatialRef = NULL;
            
            /* Fetches the SRS of the first layer and use it when creating the tileindex layer */
            if (nFirstSourceDataset < nArgc)
            {
                OGRDataSource* poDS = OGRSFDriverRegistrar::Open( papszArgv[nFirstSourceDataset], 
                                           FALSE );
                                           
                if (poDS)
                {
                    int iLayer;

                    for( iLayer = 0; iLayer < poDS->GetLayerCount(); iLayer++ )
                    {
                        int bRequested = bLayersWildcarded;
                        OGRLayer *poLayer = poDS->GetLayer(iLayer);

                        for( iArg = 1; iArg < nArgc && !bRequested; iArg++ )
                        {
                            if( EQUAL(papszArgv[iArg],"-lnum") 
                                && atoi(papszArgv[iArg+1]) == iLayer )
                                bRequested = TRUE;
                            else if( EQUAL(papszArgv[iArg],"-lname") 
                                     && EQUAL(papszArgv[iArg+1],
                                              poLayer->GetLayerDefn()->GetName()) )
                                bRequested = TRUE;
                        }

                        if( !bRequested )
                            continue;
                            
                        if ( poLayer->GetSpatialRef() )
                            poSrcSpatialRef = poLayer->GetSpatialRef()->Clone();
                        break;
                    }
                }
                
                OGRDataSource::DestroyDataSource( poDS );
            }

            poDstLayer = poDstDS->CreateLayer( "tileindex", poSrcSpatialRef );
            poDstLayer->CreateField( &oLocation, OFTString );
            
            OGRSpatialReference::DestroySpatialReference( poSrcSpatialRef );
        }
    }

/* -------------------------------------------------------------------- */
/*      Identify target layer and field.                                */
/* -------------------------------------------------------------------- */
    int   iTileIndexField;

    poDstLayer = poDstDS->GetLayer(0);
    if( poDstLayer == NULL )
    {
        fprintf( stderr, "Can't find any layer in output tileindex!\n" );
        exit( 1 );
    }

    iTileIndexField = 
        poDstLayer->GetLayerDefn()->GetFieldIndex( pszTileIndexField );
    if( iTileIndexField == -1 )
    {
        fprintf( stderr, "Can't find %s field in tile index dataset.\n", 
                pszTileIndexField );
        exit( 1 );
    }

    OGRFeatureDefn* poFeatureDefn = NULL;

    /* Load in memory existing file names in SHP */
    int nExistingLayers = 0;
    char** existingLayersTab = NULL;
    OGRSpatialReference* alreadyExistingSpatialRef = NULL;
    int alreadyExistingSpatialRefValid = FALSE;
    nExistingLayers = poDstLayer->GetFeatureCount();
    if (nExistingLayers)
    {
        int i;
        existingLayersTab = (char**)CPLMalloc(nExistingLayers * sizeof(char*));
        for(i=0;i<nExistingLayers;i++)
        {
            OGRFeature* feature = poDstLayer->GetNextFeature();
            existingLayersTab[i] = CPLStrdup(feature->GetFieldAsString( iTileIndexField));
            if (i == 0)
            {
                OGRDataSource       *poDS;
                char* filename = CPLStrdup(existingLayersTab[i]);
                int j;
                for(j=strlen(filename)-1;j>=0;j--)
                {
                    if (filename[j] == ',')
                        break;
                }
                if (j >= 0)
                {
                    int iLayer = atoi(filename + j + 1);
                    filename[j] = 0;
                    poDS = OGRSFDriverRegistrar::Open(filename, 
                                                    FALSE );
                    if (poDS)
                    {
                        OGRLayer *poLayer = poDS->GetLayer(iLayer);
                        if (poLayer)
                        {
                            alreadyExistingSpatialRefValid = TRUE;
                            alreadyExistingSpatialRef =
                                    (poLayer->GetSpatialRef()) ? poLayer->GetSpatialRef()->Clone() : NULL;
                                    
                            if (poFeatureDefn == NULL)
                                poFeatureDefn = poLayer->GetLayerDefn()->Clone();
                        }
                        OGRDataSource::DestroyDataSource( poDS );
                    }
                }
            }
        }
    }


    if (write_absolute_path)
    {
        current_path = CPLGetCurrentDir();
        if (current_path == NULL)
        {
            fprintf( stderr, "This system does not support the CPLGetCurrentDir call. "
                             "The option -write_absolute_path will have no effect\n");
            write_absolute_path = FALSE;
        }
    }
/* ==================================================================== */
/*      Process each input datasource in turn.                          */
/* ==================================================================== */

	for(; nFirstSourceDataset < nArgc; nFirstSourceDataset++ )
    {
        int i;
        OGRDataSource       *poDS;

        if( papszArgv[nFirstSourceDataset][0] == '-' )
        {
            nFirstSourceDataset++;
            continue;
        }
        
        char* fileNameToWrite;
        VSIStatBuf sStatBuf;

        if (write_absolute_path && CPLIsFilenameRelative( papszArgv[nFirstSourceDataset] ) &&
            VSIStat( papszArgv[nFirstSourceDataset], &sStatBuf ) == 0)
        {
            fileNameToWrite = CPLStrdup(CPLProjectRelativeFilename(current_path,papszArgv[nFirstSourceDataset]));
        }
        else
        {
            fileNameToWrite = CPLStrdup(papszArgv[nFirstSourceDataset]);
        }

        poDS = OGRSFDriverRegistrar::Open( papszArgv[nFirstSourceDataset], 
                                           FALSE );

        if( poDS == NULL )
        {
            fprintf( stderr, "Failed to open dataset %s, skipping.\n", 
                    papszArgv[nFirstSourceDataset] );
            CPLFree(fileNameToWrite);
            continue;
        }

/* -------------------------------------------------------------------- */
/*      Check all layers, and see if they match requests.               */
/* -------------------------------------------------------------------- */
        int iLayer;

        for( iLayer = 0; iLayer < poDS->GetLayerCount(); iLayer++ )
        {
            int bRequested = bLayersWildcarded;
            OGRLayer *poLayer = poDS->GetLayer(iLayer);

            for( iArg = 1; iArg < nArgc && !bRequested; iArg++ )
            {
                if( EQUAL(papszArgv[iArg],"-lnum") 
                    && atoi(papszArgv[iArg+1]) == iLayer )
                    bRequested = TRUE;
                else if( EQUAL(papszArgv[iArg],"-lname") 
                         && EQUAL(papszArgv[iArg+1],
                                  poLayer->GetLayerDefn()->GetName()) )
                    bRequested = TRUE;
            }

            if( !bRequested )
                continue;

            /* Checks that the layer is not already in tileindex */
            for(i=0;i<nExistingLayers;i++)
            {
                char        szLocation[5000];
                sprintf( szLocation, "%s,%d", 
                        fileNameToWrite, iLayer );
                if (EQUAL(szLocation, existingLayersTab[i]))
                {
                    fprintf(stderr, "Layer %d of %s is already in tileindex. Skipping it.\n",
                            iLayer, papszArgv[nFirstSourceDataset]);
                    break;
                }
            }
            if (i != nExistingLayers)
            {
                continue;
            }

            OGRSpatialReference* spatialRef = poLayer->GetSpatialRef();
            if (alreadyExistingSpatialRefValid)
            {
                if ((spatialRef != NULL && alreadyExistingSpatialRef != NULL &&
                     spatialRef->IsSame(alreadyExistingSpatialRef) == FALSE) ||
                    ((spatialRef != NULL) != (alreadyExistingSpatialRef != NULL)))
                {
                    fprintf(stderr, "Warning : layer %d of %s is not using the same projection system as "
                                "other files in the tileindex. This may cause problems when "
                                "using it in MapServer for example.%s\n", iLayer, papszArgv[nFirstSourceDataset],
                                (skip_different_projection) ? " Skipping it" : "");
                    if (skip_different_projection)
                    {
                        continue;
                    }
                }
            }
            else
            {
                alreadyExistingSpatialRefValid = TRUE;
                alreadyExistingSpatialRef = (spatialRef) ? spatialRef->Clone() : NULL;
            }

/* -------------------------------------------------------------------- */
/*		Check if all layers in dataset have the same attributes	schema. */
/* -------------------------------------------------------------------- */
			if( poFeatureDefn == NULL )
			{
				poFeatureDefn = poLayer->GetLayerDefn()->Clone();
			}
			else if ( !accept_different_schemas )
			{
				OGRFeatureDefn* poFeatureDefnCur = poLayer->GetLayerDefn();
				assert(NULL != poFeatureDefnCur);

				int fieldCount = poFeatureDefnCur->GetFieldCount();

				if( fieldCount != poFeatureDefn->GetFieldCount())
				{
					fprintf( stderr, "Number of attributes of layer %s of %s does not match ... skipping it.\n",
                             poLayer->GetLayerDefn()->GetName(), papszArgv[nFirstSourceDataset]);
                    if (bFirstWarningForNonMatchingAttributes)
                    {
                        fprintf( stderr, "Note : you can override this behaviour with -accept_different_schemas option\n"
                                         "but this may result in a tileindex incompatible with MapServer\n");
                        bFirstWarningForNonMatchingAttributes = FALSE;
                    }
					continue;
				}
				
                int bSkip = FALSE;
				for( int fn = 0; fn < poFeatureDefnCur->GetFieldCount(); fn++ )
				{
 					OGRFieldDefn* poField = poFeatureDefn->GetFieldDefn(fn);
 					OGRFieldDefn* poFieldCur = poFeatureDefnCur->GetFieldDefn(fn);

					/* XXX - Should those pointers be checked against NULL? */ 
					assert(NULL != poField);
					assert(NULL != poFieldCur);

					if( poField->GetType() != poFieldCur->GetType() 
						|| poField->GetWidth() != poFieldCur->GetWidth() 
						|| poField->GetPrecision() != poFieldCur->GetPrecision() 
						|| !EQUAL( poField->GetNameRef(), poFieldCur->GetNameRef() ) )
					{
						fprintf( stderr, "Schema of attributes of layer %s of %s does not match ... skipping it.\n",
                                 poLayer->GetLayerDefn()->GetName(), papszArgv[nFirstSourceDataset]);
                        if (bFirstWarningForNonMatchingAttributes)
                        {
                            fprintf( stderr, "Note : you can override this behaviour with -accept_different_schemas option\n"
                                             "but this may result in a tileindex incompatible with MapServer\n");
                            bFirstWarningForNonMatchingAttributes = FALSE;
                        }
                        bSkip = TRUE; 
                        break;
					}
				}
                
                if (bSkip)
                    continue;
			}


/* -------------------------------------------------------------------- */
/*      Get layer extents, and create a corresponding polygon           */
/*      geometry.                                                       */
/* -------------------------------------------------------------------- */
            OGREnvelope sExtents;
            OGRPolygon oRegion;
            OGRLinearRing oRing;

            if( poLayer->GetExtent( &sExtents, TRUE ) != OGRERR_NONE )
            {
                fprintf( stderr, "GetExtent() failed on layer %s of %s, skipping.\n", 
                        poLayer->GetLayerDefn()->GetName(), 
                        papszArgv[nFirstSourceDataset] );
                continue;
            }
            
            oRing.addPoint( sExtents.MinX, sExtents.MinY );
            oRing.addPoint( sExtents.MinX, sExtents.MaxY );
            oRing.addPoint( sExtents.MaxX, sExtents.MaxY );
            oRing.addPoint( sExtents.MaxX, sExtents.MinY );
            oRing.addPoint( sExtents.MinX, sExtents.MinY );

            oRegion.addRing( &oRing );

/* -------------------------------------------------------------------- */
/*      Add layer to tileindex.                                         */
/* -------------------------------------------------------------------- */
            char        szLocation[5000];
            OGRFeature  oTileFeat( poDstLayer->GetLayerDefn() );

            sprintf( szLocation, "%s,%d", 
                     fileNameToWrite, iLayer );
            oTileFeat.SetGeometry( &oRegion );
            oTileFeat.SetField( iTileIndexField, szLocation );

            if( poDstLayer->CreateFeature( &oTileFeat ) != OGRERR_NONE )
            {
                fprintf( stderr, "Failed to create feature on tile index ... terminating." );
                OGRDataSource::DestroyDataSource( poDstDS );
                exit( 1 );
            }
        }

/* -------------------------------------------------------------------- */
/*      Cleanup this data source.                                       */
/* -------------------------------------------------------------------- */
        CPLFree(fileNameToWrite);
        OGRDataSource::DestroyDataSource( poDS );
    }

/* -------------------------------------------------------------------- */
/*      Close tile index and clear buffers.                             */
/* -------------------------------------------------------------------- */
    OGRDataSource::DestroyDataSource( poDstDS );
	OGRFeatureDefn::DestroyFeatureDefn( poFeatureDefn );
  
    if (alreadyExistingSpatialRef != NULL)
        OGRSpatialReference::DestroySpatialReference( alreadyExistingSpatialRef );
  
    CPLFree(current_path);
    
    if (nExistingLayers)
    {
        int i;
        for(i=0;i<nExistingLayers;i++)
        {
            CPLFree(existingLayersTab[i]);
        }
        CPLFree(existingLayersTab);
    }

    return 0;
}
Ejemplo n.º 19
0
    TestOverviewHandler(const std::string& driver_name, const std::string& filename) {

        OGRRegisterAll();

        OGRSFDriver* driver = OGRSFDriverRegistrar::GetRegistrar()->GetDriverByName(driver_name.c_str());
        if (!driver) {
            std::cerr << driver_name << " driver not available.\n";
            exit(1);
        }

        CPLSetConfigOption("OGR_SQLITE_SYNCHRONOUS", "FALSE");
        const char* options[] = { "SPATIALITE=TRUE", nullptr };
        m_data_source = driver->CreateDataSource(filename.c_str(), const_cast<char**>(options));
        if (!m_data_source) {
            std::cerr << "Creation of output file failed.\n";
            exit(1);
        }

        OGRSpatialReference sparef;
        sparef.SetWellKnownGeogCS("WGS84");

        // nodes layer

        m_layer_nodes = m_data_source->CreateLayer("nodes", &sparef, wkbPoint, nullptr);
        if (!m_layer_nodes) {
            std::cerr << "Layer creation failed.\n";
            exit(1);
        }

        OGRFieldDefn layer_nodes_field_id("id", OFTReal);
        layer_nodes_field_id.SetWidth(10);

        if (m_layer_nodes->CreateField(&layer_nodes_field_id) != OGRERR_NONE) {
            std::cerr << "Creating id field failed.\n";
            exit(1);
        }

        // labels layer

        m_layer_labels = m_data_source->CreateLayer("labels", &sparef, wkbPoint, nullptr);
        if (!m_layer_labels) {
            std::cerr << "Layer creation failed.\n";
            exit(1);
        }

        OGRFieldDefn layer_labels_field_id("id", OFTReal);
        layer_labels_field_id.SetWidth(10);

        if (m_layer_labels->CreateField(&layer_labels_field_id) != OGRERR_NONE) {
            std::cerr << "Creating id field failed.\n";
            exit(1);
        }

        OGRFieldDefn layer_labels_field_label("label", OFTString);
        layer_labels_field_label.SetWidth(30);

        if (m_layer_labels->CreateField(&layer_labels_field_label) != OGRERR_NONE) {
            std::cerr << "Creating label field failed.\n";
            exit(1);
        }

        // ways layer

        m_layer_ways = m_data_source->CreateLayer("ways", &sparef, wkbLineString, nullptr);
        if (!m_layer_ways) {
            std::cerr << "Layer creation failed.\n";
            exit(1);
        }

        OGRFieldDefn layer_way_field_id("id", OFTReal);
        layer_way_field_id.SetWidth(10);

        if (m_layer_ways->CreateField(&layer_way_field_id) != OGRERR_NONE) {
            std::cerr << "Creating id field failed.\n";
            exit(1);
        }

        OGRFieldDefn layer_way_field_test("test", OFTInteger);
        layer_way_field_test.SetWidth(3);

        if (m_layer_ways->CreateField(&layer_way_field_test) != OGRERR_NONE) {
            std::cerr << "Creating test field failed.\n";
            exit(1);
        }
    }