bool CommandCat::run() {
if (m_input_files.size() == 1) { // single input file
m_vout << "Copying input file '" << m_input_files[0].filename() << "'\n";
osmium::io::Reader reader(m_input_files[0], osm_entity_bits());
osmium::io::Header header = reader.header();
setup_header(header);
osmium::io::Writer writer(m_output_file, header, m_output_overwrite, m_fsync);
while (osmium::memory::Buffer buffer = reader.read()) {
writer(std::move(buffer));
}
writer.close();
reader.close();
} else { // multiple input files
osmium::io::Header header;
setup_header(header);
osmium::io::Writer writer(m_output_file, header, m_output_overwrite, m_fsync);
for (const auto& input_file : m_input_files) {
m_vout << "Copying input file '" << input_file.filename() << "'\n";
osmium::io::Reader reader(input_file, osm_entity_bits());
while (osmium::memory::Buffer buffer = reader.read()) {
writer(std::move(buffer));
}
reader.close();
}
writer.close();
}
show_memory_used();
m_vout << "Done.\n";
return true;
}
bool CommandGetParents::run() {
m_vout << "Opening input file...\n";
osmium::io::Reader reader{m_input_file, get_needed_types()};
m_vout << "Opening output file...\n";
osmium::io::Header header = reader.header();
setup_header(header);
osmium::io::Writer writer{m_output_file, header, m_output_overwrite, m_fsync};
m_vout << "Copying matching objects to output file...\n";
osmium::ProgressBar progress_bar{reader.file_size(), display_progress()};
while (osmium::memory::Buffer buffer = reader.read()) {
progress_bar.update(reader.offset());
for (const auto& object : buffer.select<osmium::OSMObject>()) {
if (m_add_self && m_ids(object.type()).get(object.positive_id())) {
writer(object);
continue;
}
if (object.type() == osmium::item_type::way) {
const auto& way = static_cast<const osmium::Way&>(object);
for (const auto& nr : way.nodes()) {
if (m_ids(osmium::item_type::node).get(nr.positive_ref())) {
writer(object);
break;
}
}
} else if (object.type() == osmium::item_type::relation) {
const auto& relation = static_cast<const osmium::Relation&>(object);
for (const auto& member : relation.members()) {
if (m_ids(member.type()).get(member.positive_ref())) {
writer(object);
break;
}
}
}
}
}
progress_bar.done();
m_vout << "Closing output file...\n";
writer.close();
m_vout << "Closing input file...\n";
reader.close();
show_memory_used();
m_vout << "Done.\n";
return true;
}
bool CommandMergeChanges::run() {
m_vout << "Opening output file...\n";
osmium::io::Header header;
header.set("generator", m_generator);
osmium::io::Writer writer(m_output_file, header, m_output_overwrite, m_fsync);
auto out = osmium::io::make_output_iterator(writer);
// this will contain all the buffers with the input data
std::vector<osmium::memory::Buffer> changes;
osmium::ObjectPointerCollection objects;
// read all input files, keep the buffers around and add pointer
// to each object to objects collection.
m_vout << "Reading change file contents...\n";
for (osmium::io::File& change_file : m_input_files) {
osmium::io::Reader reader(change_file, osmium::osm_entity_bits::object);
while (osmium::memory::Buffer buffer = reader.read()) {
osmium::apply(buffer, objects);
changes.push_back(std::move(buffer));
}
reader.close();
}
// Now we sort all objects and write them in order into the
// output_buffer, flushing the output_buffer whenever it is full.
if (m_simplify_change) {
// If the --simplify option was given we sort with the
// largest version of each object first and then only
// copy this last version of any object to the output_buffer.
m_vout << "Sorting change data...\n";
objects.sort(osmium::object_order_type_id_reverse_version());
m_vout << "Writing last version of each object to output...\n";
std::unique_copy(objects.cbegin(), objects.cend(), out, osmium::object_equal_type_id());
} else {
// If the --simplify option was not given, this
// is a straightforward sort and copy.
m_vout << "Sorting change data...\n";
objects.sort(osmium::object_order_type_id_version());
m_vout << "Writing all objects to output...\n";
std::copy(objects.cbegin(), objects.cend(), out);
}
m_vout << "Closing output file...\n";
writer.close();
show_memory_used();
m_vout << "Done.\n";
return true;
}
bool CommandTimeFilter::run() {
m_vout << "Opening input file...\n";
osmium::io::Reader reader(m_input_file, osmium::osm_entity_bits::object);
m_vout << "Opening output file...\n";
osmium::io::Header header = reader.header();
header.set("generator", m_generator);
osmium::io::Writer writer(m_output_file, header, m_output_overwrite, m_fsync);
m_vout << "Filter data while copying it from input to output...\n";
auto input = osmium::io::make_input_iterator_range<osmium::OSMObject>(reader);
auto diff_begin = osmium::make_diff_iterator(input.begin(), input.end());
auto diff_end = osmium::make_diff_iterator(input.end(), input.end());
auto out = osmium::io::make_output_iterator(writer);
if (m_from == m_to) {
std::copy_if(
diff_begin,
diff_end,
out,
[this](const osmium::DiffObject& d){
return d.is_visible_at(m_from);
});
} else {
std::copy_if(
diff_begin,
diff_end,
out,
[this](const osmium::DiffObject& d){
return d.is_between(m_from, m_to);
});
}
m_vout << "Closing output file...\n";
writer.close();
m_vout << "Closing input file...\n";
reader.close();
show_memory_used();
m_vout << "Done.\n";
return true;
}
bool CommandCheckRefs::run() {
osmium::io::Reader reader{m_input_file};
osmium::ProgressBar progress_bar{reader.file_size(), display_progress()};
RefCheckHandler handler{m_vout, progress_bar, m_show_ids, m_check_relations};
while (osmium::memory::Buffer buffer = reader.read()) {
progress_bar.update(reader.offset());
osmium::apply(buffer, handler);
}
progress_bar.done();
reader.close();
if (m_check_relations) {
handler.find_missing_relations();
if (m_show_ids) {
handler.show_missing_relation_ids();
}
}
std::cerr << "There are " << handler.node_count() << " nodes, "
<< handler.way_count() << " ways, and "
<< handler.relation_count() << " relations in this file.\n";
if (m_check_relations) {
std::cerr << "Nodes in ways missing: " << handler.missing_nodes_in_ways() << "\n";
std::cerr << "Nodes in relations missing: " << handler.missing_nodes_in_relations() << "\n";
std::cerr << "Ways in relations missing: " << handler.missing_ways_in_relations() << "\n";
std::cerr << "Relations in relations missing: " << handler.missing_relations_in_relations() << "\n";
} else {
std::cerr << "Nodes in ways missing: " << handler.missing_nodes_in_ways() << "\n";
}
m_vout << "Memory used for indexes: " << (handler.used_memory() / (1024 * 1024)) << " MBytes\n";
show_memory_used();
m_vout << "Done.\n";
return handler.no_errors();
}
bool CommandAddRefs::run() {
if (!m_input_files.empty()) {
read_input_files();
}
bool todo = !m_relation_ids.empty();
if (!m_relation_ids.empty()) {
todo = find_relations_in_relations();
}
if (todo) {
find_nodes_and_ways_in_relations();
}
if (!m_way_ids.empty()) {
find_nodes_in_ways();
}
osmium::io::Reader reader(m_source_file, osmium::osm_entity_bits::object);
osmium::io::Header header = reader.header();
header.set("generator", m_generator);
m_vout << "Opening output file...\n";
osmium::io::Writer writer(m_output_file, header, m_output_overwrite, m_fsync);
m_vout << "Copying from source to output file...\n";
while (osmium::memory::Buffer buffer = reader.read()) {
for (auto it = buffer.begin<osmium::OSMObject>(); it != buffer.end<osmium::OSMObject>(); ++it) {
switch (it->type()) {
case osmium::item_type::node:
if (m_node_ids.count(it->id())) {
m_node_ids.erase(it->id());
writer(*it);
}
break;
case osmium::item_type::way:
if (m_way_ids.count(it->id())) {
m_way_ids.erase(it->id());
writer(*it);
}
break;
case osmium::item_type::relation:
if (m_relation_ids.count(it->id())) {
m_relation_ids.erase(it->id());
writer(*it);
}
break;
default:
break;
}
}
}
writer.close();
reader.close();
print_missing_ids("node", m_node_ids);
print_missing_ids("way", m_way_ids);
print_missing_ids("relation", m_relation_ids);
show_memory_used();
m_vout << "Done.\n";
return m_node_ids.empty() && m_way_ids.empty() && m_relation_ids.empty();
}
bool CommandSort::run_single_pass() {
std::vector<osmium::memory::Buffer> data;
osmium::ObjectPointerCollection objects;
osmium::Box bounding_box;
uint64_t buffers_count = 0;
uint64_t buffers_size = 0;
uint64_t buffers_capacity = 0;
m_vout << "Reading contents of input files...\n";
osmium::ProgressBar progress_bar{file_size_sum(m_input_files), display_progress()};
for (const std::string& file_name : m_filenames) {
osmium::io::Reader reader{file_name, osmium::osm_entity_bits::object};
osmium::io::Header header{reader.header()};
bounding_box.extend(header.joined_boxes());
while (osmium::memory::Buffer buffer = reader.read()) {
++buffers_count;
buffers_size += buffer.committed();
buffers_capacity += buffer.capacity();
progress_bar.update(reader.offset());
osmium::apply(buffer, objects);
data.push_back(std::move(buffer));
}
progress_bar.file_done(reader.file_size());
reader.close();
}
progress_bar.done();
m_vout << "Number of buffers: " << buffers_count << "\n";
const auto buffers_size_rounded = static_cast<double>(buffers_size / (1000 * 1000)) / 1000; // NOLINT(bugprone-integer-division)
m_vout << "Sum of buffer sizes: " << buffers_size << " (" << buffers_size_rounded << " GB)\n";
const auto buffers_capacity_rounded = static_cast<double>(buffers_capacity / (1000 * 1000)) / 1000; // NOLINT(bugprone-integer-division)
if (buffers_capacity != 0) {
const auto fill_factor = std::round(100 * static_cast<double>(buffers_size) / static_cast<double>(buffers_capacity));
m_vout << "Sum of buffer capacities: " << buffers_capacity << " (" << buffers_capacity_rounded << " GB, " << fill_factor << "% full)\n";
} else {
m_vout << "Sum of buffer capacities: 0 (0 GB)\n";
}
m_vout << "Opening output file...\n";
osmium::io::Header header;
setup_header(header);
if (bounding_box) {
header.add_box(bounding_box);
}
osmium::io::Writer writer{m_output_file, header, m_output_overwrite, m_fsync};
m_vout << "Sorting data...\n";
objects.sort(osmium::object_order_type_id_version());
m_vout << "Writing out sorted data...\n";
auto out = osmium::io::make_output_iterator(writer);
std::copy(objects.begin(), objects.end(), out);
m_vout << "Closing output file...\n";
writer.close();
show_memory_used();
m_vout << "Done.\n";
return true;
}
