Merge pull request #1992 from KLayout/feature/issue-1989

Feature/issue 1989

Author: klayoutmatthias

src/db/db/dbAsIfFlatEdgePairs.cc

@@ -226,6 +226,16 @@ AsIfFlatEdgePairs::processed_to_edges (const EdgePairToEdgeProcessorBase &filter
   return edges.release ();
 }
 
+static void
+insert_ep (FlatEdgePairs *dest, const db::EdgePair &ep, db::properties_id_type prop_id)
+{
+  if (prop_id != 0) {
+    dest->insert (db::EdgePairWithProperties (ep, prop_id));
+  } else {
+    dest->insert (ep);
+  }
+}
+
 EdgePairsDelegate *
 AsIfFlatEdgePairs::filtered (const EdgePairFilterBase &filter) const
 {
@@ -234,18 +244,28 @@ AsIfFlatEdgePairs::filtered (const EdgePairFilterBase &filter) const
 
   for (EdgePairsIterator p (begin ()); ! p.at_end (); ++p) {
     if (filter.selected (*p)) {
-      db::properties_id_type prop_id = pm (p.prop_id ());
-      if (prop_id != 0) {
-        new_edge_pairs->insert (db::EdgePairWithProperties (*p, prop_id));
-      } else {
-        new_edge_pairs->insert (*p);
-      }
+      insert_ep (new_edge_pairs.get (), *p, pm (p.prop_id ()));
     }
   }
 
   return new_edge_pairs.release ();
 }
 
+std::pair <EdgePairsDelegate *, EdgePairsDelegate *>
+AsIfFlatEdgePairs::filtered_pair (const EdgePairFilterBase &filter) const
+{
+  std::unique_ptr<FlatEdgePairs> new_edge_pairs_true (new FlatEdgePairs ());
+  std::unique_ptr<FlatEdgePairs> new_edge_pairs_false (new FlatEdgePairs ());
+  db::PropertyMapper pm (new_edge_pairs_true->properties_repository (), properties_repository ());
+
+  for (EdgePairsIterator p (begin ()); ! p.at_end (); ++p) {
+    FlatEdgePairs *dest = filter.selected (*p) ? new_edge_pairs_true.get () : new_edge_pairs_false.get ();
+    insert_ep (dest, *p, pm (p.prop_id ()));
+  }
+
+  return std::make_pair (new_edge_pairs_true.release (), new_edge_pairs_false.release ());
+}
+
 RegionDelegate *
 AsIfFlatEdgePairs::pull_interacting (const Region &other) const
 {

src/db/db/dbAsIfFlatEdgePairs.h

@@ -53,6 +53,7 @@ class DB_PUBLIC AsIfFlatEdgePairs
   }
 
   virtual EdgePairsDelegate *filtered (const EdgePairFilterBase &) const;
+  virtual std::pair<EdgePairsDelegate *, EdgePairsDelegate *> filtered_pair (const EdgePairFilterBase &filter) const;
 
   virtual EdgePairsDelegate *process_in_place (const EdgePairProcessorBase &proc)
   {

src/db/db/dbAsIfFlatEdges.cc

@@ -717,6 +717,23 @@ AsIfFlatEdges::filtered (const EdgeFilterBase &filter) const
   return new_region.release ();
 }
 
+std::pair<EdgesDelegate *, EdgesDelegate *>
+AsIfFlatEdges::filtered_pair (const EdgeFilterBase &filter) const
+{
+  std::unique_ptr<FlatEdges> new_region_true (new FlatEdges ());
+  std::unique_ptr<FlatEdges> new_region_false (new FlatEdges ());
+
+  for (EdgesIterator p (begin_merged ()); ! p.at_end (); ++p) {
+    if (filter.selected (*p)) {
+      new_region_true->insert (*p);
+    } else {
+      new_region_false->insert (*p);
+    }
+  }
+
+  return std::make_pair (new_region_true.release (), new_region_false.release ());
+}
+
 EdgePairsDelegate *
 AsIfFlatEdges::run_check (db::edge_relation_type rel, const Edges *other, db::Coord d, const db::EdgesCheckOptions &options) const
 {

src/db/db/dbAsIfFlatEdges.h

@@ -101,6 +101,7 @@ class DB_PUBLIC AsIfFlatEdges
   }
 
   virtual EdgesDelegate *filtered (const EdgeFilterBase &) const;
+  virtual std::pair<EdgesDelegate *, EdgesDelegate *> filtered_pair (const EdgeFilterBase &filter) const;
 
   virtual EdgesDelegate *merged_in_place ()
   {

src/db/db/dbAsIfFlatRegion.cc

@@ -414,6 +414,25 @@ AsIfFlatRegion::filtered (const PolygonFilterBase &filter) const
   return new_region.release ();
 }
 
+std::pair<RegionDelegate *, RegionDelegate *>
+AsIfFlatRegion::filtered_pair (const PolygonFilterBase &filter) const
+{
+  std::unique_ptr<FlatRegion> new_region_true (new FlatRegion ());
+  std::unique_ptr<FlatRegion> new_region_false (new FlatRegion ());
+
+  for (RegionIterator p (begin_merged ()); ! p.at_end (); ++p) {
+    if (filter.selected (*p)) {
+      new_region_true->insert (*p);
+    } else {
+      new_region_false->insert (*p);
+    }
+  }
+
+  new_region_true->set_is_merged (true);
+  new_region_false->set_is_merged (true);
+  return std::make_pair (new_region_true.release (), new_region_false.release ());
+}
+
 RegionDelegate *
 AsIfFlatRegion::processed (const PolygonProcessorBase &filter) const
 {

src/db/db/dbAsIfFlatRegion.h

@@ -101,6 +101,7 @@ class DB_PUBLIC AsIfFlatRegion
   }
 
   virtual RegionDelegate *filtered (const PolygonFilterBase &filter) const;
+  virtual std::pair<RegionDelegate *, RegionDelegate *> filtered_pair (const PolygonFilterBase &filter) const;
 
   virtual RegionDelegate *merged_in_place ()
   {

src/db/db/dbAsIfFlatTexts.cc

@@ -164,6 +164,23 @@ AsIfFlatTexts::filtered (const TextFilterBase &filter) const
   return new_texts.release ();
 }
 
+std::pair<TextsDelegate *, TextsDelegate *>
+AsIfFlatTexts::filtered_pair (const TextFilterBase &filter) const
+{
+  std::unique_ptr<FlatTexts> new_texts_true (new FlatTexts ());
+  std::unique_ptr<FlatTexts> new_texts_false (new FlatTexts ());
+
+  for (TextsIterator p (begin ()); ! p.at_end (); ++p) {
+    if (filter.selected (*p)) {
+      new_texts_true->insert (*p);
+    } else {
+      new_texts_false->insert (*p);
+    }
+  }
+
+  return std::make_pair (new_texts_true.release (), new_texts_false.release ());
+}
+
 TextsDelegate *
 AsIfFlatTexts::processed (const TextProcessorBase &filter) const
 {

src/db/db/dbAsIfFlatTexts.h

@@ -54,6 +54,7 @@ class DB_PUBLIC AsIfFlatTexts
   }
 
   virtual TextsDelegate *filtered (const TextFilterBase &) const;
+  virtual std::pair<TextsDelegate *, TextsDelegate *> filtered_pair (const TextFilterBase &filter) const;
 
   virtual TextsDelegate *process_in_place (const TextProcessorBase &proc)
   {

src/db/db/dbDeepEdgePairs.cc

@@ -375,18 +375,24 @@ EdgePairsDelegate *
 DeepEdgePairs::filter_in_place (const EdgePairFilterBase &filter)
 {
   //  TODO: implement to be really in-place
-  *this = *apply_filter (filter);
+  *this = *apply_filter (filter, true, false).first;
   return this;
 }
 
 EdgePairsDelegate *
 DeepEdgePairs::filtered (const EdgePairFilterBase &filter) const
 {
-  return apply_filter (filter);
+  return apply_filter (filter, true, false).first;
 }
 
-DeepEdgePairs *
-DeepEdgePairs::apply_filter (const EdgePairFilterBase &filter) const
+std::pair<EdgePairsDelegate *, EdgePairsDelegate *>
+DeepEdgePairs::filtered_pair (const EdgePairFilterBase &filter) const
+{
+  return apply_filter (filter, true, true);
+}
+
+std::pair<DeepEdgePairs *, DeepEdgePairs *>
+DeepEdgePairs::apply_filter (const EdgePairFilterBase &filter, bool with_true, bool with_false) const
 {
   const db::DeepLayer &edge_pairs = deep_layer ();
   db::Layout &layout = const_cast<db::Layout &> (edge_pairs.layout ());
@@ -404,9 +410,10 @@ DeepEdgePairs::apply_filter (const EdgePairFilterBase &filter) const
 
   }
 
-  std::map<db::cell_index_type, std::map<db::ICplxTrans, db::Shapes> > to_commit;
+  std::map<db::cell_index_type, std::map<db::ICplxTrans, db::Shapes> > to_commit_true, to_commit_false;
 
-  std::unique_ptr<db::DeepEdgePairs> res (new db::DeepEdgePairs (edge_pairs.derived ()));
+  std::unique_ptr<db::DeepEdgePairs> res_true (with_true ? new db::DeepEdgePairs (edge_pairs.derived ()) : 0);
+  std::unique_ptr<db::DeepEdgePairs> res_false (with_false ? new db::DeepEdgePairs (edge_pairs.derived ()) : 0);
   for (db::Layout::iterator c = layout.begin (); c != layout.end (); ++c) {
 
     const db::Shapes &s = c->shapes (edge_pairs.layer ());
@@ -416,42 +423,70 @@ DeepEdgePairs::apply_filter (const EdgePairFilterBase &filter) const
       const std::set<db::ICplxTrans> &vv = vars->variants (c->cell_index ());
       for (auto v = vv.begin (); v != vv.end (); ++v) {
 
-        db::Shapes *st;
+        db::Shapes *st_true = 0, *st_false = 0;
         if (vv.size () == 1) {
-          st = & c->shapes (res->deep_layer ().layer ());
+          if (with_true) {
+            st_true = & c->shapes (res_true->deep_layer ().layer ());
+          }
+          if (with_false) {
+            st_false = & c->shapes (res_false->deep_layer ().layer ());
+          }
         } else {
-          st = & to_commit [c->cell_index ()] [*v];
+          if (with_true) {
+            st_true = & to_commit_true [c->cell_index ()] [*v];
+          }
+          if (with_false) {
+            st_false = & to_commit_false [c->cell_index ()] [*v];
+          }
         }
 
         const db::ICplxTrans &tr = *v;
 
         for (db::Shapes::shape_iterator si = s.begin (db::ShapeIterator::EdgePairs); ! si.at_end (); ++si) {
           if (filter.selected (si->edge_pair ().transformed (tr))) {
-            st->insert (*si);
+            if (st_true) {
+              st_true->insert (*si);
+            }
+          } else {
+            if (st_false) {
+              st_false->insert (*si);
+            }
           }
         }
 
       }
 
     } else {
 
-      db::Shapes &st = c->shapes (res->deep_layer ().layer ());
+      db::Shapes *st_true = with_true ? &c->shapes (res_true->deep_layer ().layer ()) : 0;
+      db::Shapes *st_false = with_false ? &c->shapes (res_false->deep_layer ().layer ()) : 0;
 
       for (db::Shapes::shape_iterator si = s.begin (db::ShapeIterator::EdgePairs); ! si.at_end (); ++si) {
         if (filter.selected (si->edge_pair ())) {
-          st.insert (*si);
+          if (with_true) {
+            st_true->insert (*si);
+          }
+        } else {
+          if (with_false) {
+            st_false->insert (*si);
+          }
         }
       }
 
     }
 
   }
 
-  if (! to_commit.empty () && vars.get ()) {
-    vars->commit_shapes (res->deep_layer ().layer (), to_commit);
+  if (! to_commit_true.empty () && vars.get ()) {
+    tl_assert (res_true.get () != 0);
+    vars->commit_shapes (res_true->deep_layer ().layer (), to_commit_true);
+  }
+  if (! to_commit_false.empty () && vars.get ()) {
+    tl_assert (res_false.get () != 0);
+    vars->commit_shapes (res_false->deep_layer ().layer (), to_commit_false);
   }
 
-  return res.release ();
+  return std::make_pair (res_true.release (), res_false.release ());
 }
 
 EdgePairsDelegate *DeepEdgePairs::process_in_place (const EdgePairProcessorBase &filter)

src/db/db/dbDeepEdgePairs.h

@@ -78,6 +78,7 @@ class DB_PUBLIC DeepEdgePairs
 
   virtual EdgePairsDelegate *filter_in_place (const EdgePairFilterBase &filter);
   virtual EdgePairsDelegate *filtered (const EdgePairFilterBase &) const;
+  virtual std::pair<EdgePairsDelegate *, EdgePairsDelegate *> filtered_pair (const EdgePairFilterBase &filter) const;
   virtual EdgePairsDelegate *process_in_place (const EdgePairProcessorBase &);
   virtual EdgePairsDelegate *processed (const EdgePairProcessorBase &) const;
   virtual RegionDelegate *processed_to_polygons (const EdgePairToPolygonProcessorBase &filter) const;
@@ -117,7 +118,7 @@ class DB_PUBLIC DeepEdgePairs
 
   void init ();
   EdgesDelegate *generic_edges (bool first, bool second) const;
-  DeepEdgePairs *apply_filter (const EdgePairFilterBase &filter) const;
+  std::pair<DeepEdgePairs *, DeepEdgePairs *> apply_filter (const EdgePairFilterBase &filter, bool with_true, bool with_false) const;
 };
 
 }