dont put haplotypes in ReferencePathOverlays

bdsg/include/bdsg/overlays/reference_path_overlay.hpp

@@ -42,11 +42,17 @@ class ReferencePathOverlay : public PathPositionHandleGraph {
 
 public:
 
-    /// Create a ReferencePathOverlay indexing all non-hidden paths in the
-    /// backing graph (which show up in for_each_path_handle()). For path names
-    /// in extra_path_names, look them up and index them too, even if they are
-    /// hidden.
-    ReferencePathOverlay(const PathHandleGraph* graph, const std::unordered_set<std::string>& extra_path_names = {});
+    /// Create a ReferencePathOverlay indexing paths in the backing graph.
+    /// If all_paths is true, indexes all paths visible via for_each_path_handle().
+    /// If false (default), indexes only REFERENCE and GENERIC sense paths.
+    /// For path names in extra_path_names, look them up and index them too,
+    /// even if they are hidden.
+    ReferencePathOverlay(const PathHandleGraph* graph, bool all_paths = false);
+
+    /// Same, but also indexes hidden paths listed in extra_path_names.
+    ReferencePathOverlay(const PathHandleGraph* graph,
+                         const std::unordered_set<std::string>& extra_path_names,
+                         bool all_paths = false);
     ReferencePathOverlay() = default;
     ~ReferencePathOverlay() = default;
 

bdsg/src/reference_path_overlay.cpp

@@ -13,26 +13,39 @@ namespace bdsg {
 using namespace std;
 using namespace handlegraph;
 
-ReferencePathOverlay::ReferencePathOverlay(const PathHandleGraph* graph, const std::unordered_set<std::string>& extra_path_names) : graph(graph) {
-
-    // Get step counts for all paths we want to process, once.
+ReferencePathOverlay::ReferencePathOverlay(const PathHandleGraph* graph, bool all_paths)
+    : ReferencePathOverlay(graph, std::unordered_set<std::string>{}, all_paths) {
+}
+
+ReferencePathOverlay::ReferencePathOverlay(const PathHandleGraph* graph,
+                                           const std::unordered_set<std::string>& extra_path_names,
+                                           bool all_paths) : graph(graph) {
+
     std::unordered_map<path_handle_t, size_t> cached_step_counts;
-    graph->for_each_path_handle([&](const path_handle_t& path) {
-        // Find and measure all the non-hidden paths.
-        // TODO: If we made the overlay transparent so we could access paths
-        // that didn't get indexed, we wouldn't be weirdly indexing haplotype
-        // paths from backends that don't hide them in the "reference" path
-        // overlay.
-        cached_step_counts[path] = graph->get_step_count(path);
-    });
+
+    if (all_paths) {
+        // Index ALL visible paths
+        graph->for_each_path_handle([&](const path_handle_t& path) {
+            cached_step_counts[path] = graph->get_step_count(path);
+            return true;
+        });
+    } else {
+        // Only index REFERENCE and GENERIC paths (the default)
+        std::unordered_set<PathSense> senses = {PathSense::REFERENCE, PathSense::GENERIC};
+        graph->for_each_path_matching(&senses, nullptr, nullptr, [&](const path_handle_t& path) {
+            cached_step_counts[path] = graph->get_step_count(path);
+            return true;
+        });
+    }
+
     for (auto& path_name : extra_path_names) {
         // Also index hidden paths that the user is asking for by name.
         if (graph->has_path(path_name)) {
             // The graph actually has this path.
             path_handle_t path = graph->get_path_handle(path_name);
             auto found = cached_step_counts.find(path);
             if (found == cached_step_counts.end()) {
-                // And it's not already reference sense.
+                // And it's not already indexed.
                 // Count steps and remember it
                 cached_step_counts.emplace_hint(found, path, graph->get_step_count(path));
             }