int main(int argc, char* argv[]) {
po::options_description desc("OPTIONS");
desc.add_options()
("help,h", "Print usage information")
("verbose,v", "Enable verbose output")
("output,o", po::value<std::string>(), "Output file name")
("output-format,f", po::value<std::string>()->default_value("SQLite"), "Output OGR format (Default: 'SQLite')")
("add-untagged-nodes", "Add untagged nodes to point layer")
("add-metadata", "Add columns for version, changeset, timestamp, uid, and user")
("features-per-transaction", po::value<int>()->default_value(100000), "Number of features to add per transaction")
;
po::options_description hidden;
hidden.add_options()
("input-filename", po::value<std::string>(), "OSM input file")
;
po::options_description parsed_options;
parsed_options.add(desc).add(hidden);
po::positional_options_description positional;
positional.add("input-filename", 1);
po::variables_map vm;
po::store(po::command_line_parser(argc, argv).options(parsed_options).positional(positional).run(), vm);
po::notify(vm);
std::string input_filename;
std::string output_filename;
std::string output_format{"SQLite"};
bool debug = false;
config cfg;
if (vm.count("help")) {
print_help(desc);
std::exit(0);
}
if (vm.count("verbose")) {
cfg.verbose = true;
}
if (vm.count("output-format")) {
output_format = vm["output-format"].as<std::string>();
}
if (vm.count("input-filename")) {
input_filename = vm["input-filename"].as<std::string>();
}
if (vm.count("output")) {
output_filename = vm["output"].as<std::string>();
} else {
auto slash = input_filename.rfind('/');
if (slash == std::string::npos) {
slash = 0;
} else {
++slash;
}
output_filename = input_filename.substr(slash);
auto dot = output_filename.find('.');
if (dot != std::string::npos) {
output_filename.erase(dot);
}
output_filename.append(".db");
}
int features_per_transaction = 0;
if (vm.count("features-per-transaction")) {
features_per_transaction = vm["features-per-transaction"].as<int>();
}
if (vm.count("add-untagged-nodes")) {
cfg.add_untagged_nodes = true;
}
if (vm.count("add-metadata")) {
cfg.add_metadata = true;
}
osmium::util::VerboseOutput vout{cfg.verbose};
vout << "Writing to '" << output_filename << "'\n";
osmium::area::Assembler::config_type assembler_config;
if (debug) {
assembler_config.debug_level = 1;
}
osmium::area::MultipolygonCollector<osmium::area::Assembler> collector{assembler_config};
vout << "Pass 1...\n";
osmium::io::Reader reader1(input_filename);
collector.read_relations(reader1);
reader1.close();
vout << "Pass 1 done\n";
index_type index_pos;
location_handler_type location_handler{index_pos};
location_handler.ignore_errors();
osmium::geom::OGRFactory<> factory {};
CPLSetConfigOption("OGR_SQLITE_SYNCHRONOUS", "OFF");
gdalcpp::Dataset dataset{output_format, output_filename, gdalcpp::SRS{factory.proj_string()}, { "SPATIALITE=TRUE", "INIT_WITH_EPSG=no" }};
dataset.exec("PRAGMA journal_mode = OFF;");
if (features_per_transaction) {
dataset.enable_auto_transactions(features_per_transaction);
}
MyOGRHandler<decltype(factory)::projection_type> ogr_handler(dataset, factory, cfg);
vout << "Pass 2...\n";
osmium::io::Reader reader2{input_filename};
osmium::apply(reader2, location_handler, ogr_handler, collector.handler([&ogr_handler](const osmium::memory::Buffer& area_buffer) {
osmium::apply(area_buffer, ogr_handler);
}));
reader2.close();
vout << "Pass 2 done\n";
auto incomplete_relations = collector.get_incomplete_relations();
if (!incomplete_relations.empty()) {
std::cerr << "Warning! Some member ways missing for these multipolygon relations:";
for (const auto* relation : incomplete_relations) {
std::cerr << " " << relation->id();
}
std::cerr << '\n';
}
osmium::MemoryUsage memory;
if (memory.peak()) {
vout << "Memory used: " << memory.peak() << " MBytes\n";
}
}
int main(int argc, char* argv[]) {
static struct option long_options[] = {
{"help", no_argument, 0, 'h'},
{"format", required_argument, 0, 'f'},
{0, 0, 0, 0}
};
std::string output_format("SQLite");
while (true) {
int c = getopt_long(argc, argv, "hf:", long_options, 0);
if (c == -1) {
break;
}
switch (c) {
case 'h':
print_help();
exit(0);
case 'f':
output_format = optarg;
break;
default:
exit(1);
}
}
std::string input_filename;
std::string output_filename("ogr_out");
int remaining_args = argc - optind;
if (remaining_args > 2) {
std::cerr << "Usage: " << argv[0] << " [OPTIONS] [INFILE [OUTFILE]]" << std::endl;
exit(1);
} else if (remaining_args == 2) {
input_filename = argv[optind];
output_filename = argv[optind+1];
} else if (remaining_args == 1) {
input_filename = argv[optind];
} else {
input_filename = "-";
}
index_type index_pos;
location_handler_type location_handler(index_pos);
osmium::experimental::FlexReader<location_handler_type> exr(input_filename, location_handler, osmium::osm_entity_bits::object);
MyOGRHandler ogr_handler(output_format, output_filename);
while (auto buffer = exr.read()) {
osmium::apply(buffer, ogr_handler);
}
exr.close();
std::vector<const osmium::Relation*> incomplete_relations = exr.collector().get_incomplete_relations();
if (!incomplete_relations.empty()) {
std::cerr << "Warning! Some member ways missing for these multipolygon relations:";
for (const auto* relation : incomplete_relations) {
std::cerr << " " << relation->id();
}
std::cerr << "\n";
}
google::protobuf::ShutdownProtobufLibrary();
}
int main(int argc, char* argv[]) {
const auto& map_factory = osmium::index::MapFactory<osmium::unsigned_object_id_type, osmium::Location>::instance();
static struct option long_options[] = {
{"help", no_argument, 0, 'h'},
{"format", required_argument, 0, 'f'},
{"location_store", required_argument, 0, 'l'},
{"list_location_stores", no_argument, 0, 'L'},
{0, 0, 0, 0}
};
std::string output_format { "SQLite" };
std::string location_store { "sparse_mem_array" };
while (true) {
int c = getopt_long(argc, argv, "hf:l:L", long_options, 0);
if (c == -1) {
break;
}
switch (c) {
case 'h':
print_help();
exit(0);
case 'f':
output_format = optarg;
break;
case 'l':
location_store = optarg;
break;
case 'L':
std::cout << "Available map types:\n";
for (const auto& map_type : map_factory.map_types()) {
std::cout << " " << map_type << "\n";
}
exit(0);
default:
exit(1);
}
}
std::string input_filename;
std::string output_filename("ogr_out");
int remaining_args = argc - optind;
if (remaining_args > 2) {
std::cerr << "Usage: " << argv[0] << " [OPTIONS] [INFILE [OUTFILE]]" << std::endl;
exit(1);
} else if (remaining_args == 2) {
input_filename = argv[optind];
output_filename = argv[optind+1];
} else if (remaining_args == 1) {
input_filename = argv[optind];
} else {
input_filename = "-";
}
osmium::io::Reader reader(input_filename);
std::unique_ptr<index_pos_type> index_pos = map_factory.create_map(location_store);
index_neg_type index_neg;
location_handler_type location_handler(*index_pos, index_neg);
location_handler.ignore_errors();
MyOGRHandler ogr_handler(output_format, output_filename);
osmium::apply(reader, location_handler, ogr_handler);
reader.close();
int locations_fd = open("locations.dump", O_WRONLY | O_CREAT, 0644);
if (locations_fd < 0) {
throw std::system_error(errno, std::system_category(), "Open failed");
}
index_pos->dump_as_list(locations_fd);
close(locations_fd);
}
