Better handling of areas with duplicate segments.

If the duplicate segments are not in inner rings, they will now always
be reported. Also if complete ways are removed due to the detection of
duplicate segments, the entire area will be marked as invalid.

Author: joto

include/osmium/area/assembler.hpp

@@ -266,6 +266,9 @@ namespace osmium {
             // Statistics
             area_stats m_stats;
 
+            // The number of members the multipolygon relation has
+            size_t m_num_members = 0;
+
             bool debug() const noexcept {
                 return m_config.debug_level > 1;
             }
@@ -1168,6 +1171,20 @@ namespace osmium {
                 return true;
             }
 
+            /**
+             * Checks if any ways were completely removed in the
+             * erase_duplicate_segments step.
+             */
+            bool ways_were_lost() {
+                std::unordered_set<const osmium::Way*> ways_in_segments;
+
+                for (const auto& segment : m_segment_list) {
+                    ways_in_segments.insert(segment.way());
+                }
+
+                return ways_in_segments.size() < m_num_members;
+            }
+
             /**
              * Create rings from segments.
              */
@@ -1196,6 +1213,15 @@ namespace osmium {
                     return false;
                 }
 
+                // If one or more complete ways was removed because of
+                // duplicate segments, this isn't a valid area.
+                if (ways_were_lost()) {
+                    if (debug()) {
+                        std::cerr << "  Complete ways removed because of duplicate segments\n";
+                    }
+                    return false;
+                }
+
                 if (m_config.debug_level >= 3) {
                     std::cerr << "Sorted de-duplicated segment list:\n";
                     for (const auto& s : m_segment_list) {
@@ -1355,6 +1381,7 @@ namespace osmium {
             }
 
             bool create_area(osmium::memory::Buffer& out_buffer, const osmium::Relation& relation, const std::vector<const osmium::Way*>& members) {
+                m_num_members = members.size();
                 osmium::builder::AreaBuilder builder(out_buffer);
                 builder.initialize_from_object(relation);
 

include/osmium/area/detail/segment_list.hpp

@@ -261,11 +261,13 @@ namespace osmium {
                         }
 
                         // Only count and report duplicate segments if they
-                        // belong to the same way. Those cases are definitely
-                        // wrong. If the duplicate segments belong to
-                        // different ways, they could be touching inner rings
-                        // which are perfectly okay.
-                        if (it->way() == std::next(it)->way()) {
+                        // belong to the same way or if they don't both have
+                        // the role "inner". Those cases are definitely wrong.
+                        // If the duplicate segments belong to different
+                        // "inner" ways, they could be touching inner rings
+                        // which are perfectly okay. Note that for this check
+                        // the role has to be correct in the member data.
+                        if (it->way() == std::next(it)->way() || !it->role_inner() || !std::next(it)->role_inner()) {
                             ++duplicate_segments;
                             if (problem_reporter) {
                                 problem_reporter->report_duplicate_segment(it->first(), it->second());