diff --git a/src/db/db/dbCellVariants.cc b/src/db/db/dbCellVariants.cc index 0126a75c3..5f36cc7b7 100644 --- a/src/db/db/dbCellVariants.cc +++ b/src/db/db/dbCellVariants.cc @@ -511,19 +511,52 @@ VariantsCollectorBase::create_var_instances_non_tl_invariant (db::Cell &in_cell, std::map >::const_iterator f = var_table.find (i->object ().cell_index ()); if (f == var_table.end ()) { - in_cell.insert (*i); + in_cell.insert (*i); } else { const std::map &vt = f->second; - for (db::CellInstArray::iterator ia = i->begin (); ! ia.at_end (); ++ia) { + bool need_explode = false; + bool first = true; + db::cell_index_type ci = 0; + + for (db::CellInstArray::iterator ia = i->begin (); ! ia.at_end () && ! need_explode; ++ia) { db::ICplxTrans rt = mp_red->reduce (for_var * mp_red->reduce_trans (i->complex_trans (*ia))); std::map::const_iterator v = vt.find (rt); tl_assert (v != vt.end ()); - in_cell.insert (db::CellInstArrayWithProperties (db::CellInstArray (db::CellInst (v->second), i->complex_trans (*ia)), i->properties_id ())); + if (first) { + ci = v->second; + first = false; + } else { + need_explode = (ci != v->second); + } + + } + + if (need_explode) { + + for (db::CellInstArray::iterator ia = i->begin (); ! ia.at_end (); ++ia) { + + db::ICplxTrans rt = mp_red->reduce (for_var * mp_red->reduce_trans (i->complex_trans (*ia))); + std::map::const_iterator v = vt.find (rt); + tl_assert (v != vt.end ()); + + in_cell.insert (db::CellInstArrayWithProperties (db::CellInstArray (db::CellInst (v->second), i->complex_trans (*ia)), i->properties_id ())); + + } + + } else if (ci != i->object ().cell_index ()) { + + db::CellInstArray new_array = *i; + new_array.object () = db::CellInst (ci); + in_cell.insert (db::CellInstArrayWithProperties (new_array, i->properties_id ())); + + } else { + + in_cell.insert (*i); } diff --git a/src/db/db/dbLayoutDiff.cc b/src/db/db/dbLayoutDiff.cc index e57cd0240..e7940a24b 100644 --- a/src/db/db/dbLayoutDiff.cc +++ b/src/db/db/dbLayoutDiff.cc @@ -287,6 +287,32 @@ private: db::Coord m_tolerance; }; +/** + * @brief A fuzzy compare operator for edge pairs + * Compares two edge pair objects applying a tolerance between them. The tolerance is the allowed deviation + * of points in database units. + */ +struct EdgePairCompareOpWithTolerance +{ + EdgePairCompareOpWithTolerance (db::Coord tolerance) + : m_ec (tolerance) + { } + + bool operator() (const db::EdgePair &a, const db::EdgePair &b) const + { + if (m_ec (a.first (), b.first ())) { + return true; + } else if (m_ec (b.first (), a.first ())) { + return false; + } else { + return m_ec (a.second (), b.second ()); + } + } + +private: + EdgeCompareOpWithTolerance m_ec; +}; + /** * @brief A fuzzy compare operator for boxes * Compares two box objects applying a tolerance between them. The tolerance is the allowed deviation @@ -492,6 +518,12 @@ make_edge_compare_func (db::Coord tolerance) return pair_compare_func > (EdgeCompareOpWithTolerance (tolerance), std_compare_func ()); } +pair_compare_func > +make_edge_pair_compare_func (db::Coord tolerance) +{ + return pair_compare_func > (EdgePairCompareOpWithTolerance (tolerance), std_compare_func ()); +} + pair_compare_func > make_box_compare_func (db::Coord tolerance) { @@ -540,6 +572,21 @@ collect_edges (const db::Layout & /*l*/, const db::Cell *c, unsigned int layer, } } +static void +collect_edge_pairs (const db::Layout & /*l*/, const db::Cell *c, unsigned int layer, unsigned int flags, std::vector< std::pair > &shapes, PropertyMapper &pn) +{ + shapes.clear (); + + for (db::ShapeIterator s = c->shapes (layer).begin (db::ShapeIterator::EdgePairs); !s.at_end (); ++s) { + db::properties_id_type prop_id = 0; + if (! (flags & layout_diff::f_no_properties)) { + prop_id = pn (s->prop_id ()); + } + shapes.push_back (std::make_pair (db::EdgePair (), prop_id)); + s->edge_pair (shapes.back ().first); + } +} + static void collect_boxes (const db::Layout &, const db::Cell *c, unsigned int layer, unsigned int flags, std::vector< std::pair > &shapes, PropertyMapper &pn) { @@ -828,6 +875,8 @@ do_compare_layouts (const db::Layout &a, const db::Cell *top_a, const db::Layout std::vector > boxes_b; std::vector > edges_a; std::vector > edges_b; + std::vector > edge_pairs_a; + std::vector > edge_pairs_b; for (unsigned int cci = 0; cci < common_cells.size (); ++cci) { @@ -1053,6 +1102,31 @@ do_compare_layouts (const db::Layout &a, const db::Cell *top_a, const db::Layout r.end_edge_differences (); } + // compare edge pairs + + edge_pairs_a.clear(); + edge_pairs_b.clear(); + if (is_valid_a) { + collect_edge_pairs (a, cell_a, layer_a, flags, edge_pairs_a, prop_normalize_a); + } + if (is_valid_b) { + collect_edge_pairs (b, cell_b, layer_b, flags, edge_pairs_b, prop_normalize_b); + } + + reduce (edge_pairs_a, edge_pairs_b, make_edge_pair_compare_func (tolerance), tolerance > 0); + + if (!edge_pairs_a.empty () || !edge_pairs_b.empty ()) { + differs = true; + if (flags & layout_diff::f_silent) { + return false; + } + r.begin_edge_pair_differences (); + if (verbose) { + r.detailed_diff (n.properties_repository (), edge_pairs_a, edge_pairs_b); + } + r.end_edge_pair_differences (); + } + r.end_layer (); } @@ -1130,6 +1204,9 @@ public: void begin_edge_differences (); void detailed_diff (const db::PropertiesRepository &pr, const std::vector > &a, const std::vector > &b); void end_edge_differences (); + void begin_edge_pair_differences (); + void detailed_diff (const db::PropertiesRepository &pr, const std::vector > &a, const std::vector > &b); + void end_edge_pair_differences (); void begin_text_differences (); void detailed_diff (const db::PropertiesRepository &pr, const std::vector > &a, const std::vector > &b); void end_text_differences (); @@ -1525,6 +1602,34 @@ PrintingDifferenceReceiver::end_edge_differences () { } +void +PrintingDifferenceReceiver::begin_edge_pair_differences () +{ + try { + enough (tl::error) << "Edge pairs differ for layer " << m_layer.to_string () << " in cell " << m_cellname; + } catch (tl::CancelException &) { + // ignore cancel exceptions + } +} + +void +PrintingDifferenceReceiver::detailed_diff (const db::PropertiesRepository &pr, const std::vector > &a, const std::vector > &b) +{ + try { + enough (tl::info) << "Not in b but in a:"; + print_diffs (pr, a, b); + enough (tl::info) << "Not in a but in b:"; + print_diffs (pr, b, a); + } catch (tl::CancelException &) { + // ignore cancel exceptions + } +} + +void +PrintingDifferenceReceiver::end_edge_pair_differences () +{ +} + void PrintingDifferenceReceiver::begin_text_differences () { diff --git a/src/db/db/dbLayoutDiff.h b/src/db/db/dbLayoutDiff.h index ed0e01e0b..4482c5009 100644 --- a/src/db/db/dbLayoutDiff.h +++ b/src/db/db/dbLayoutDiff.h @@ -119,6 +119,9 @@ public: virtual void begin_edge_differences () { } virtual void detailed_diff (const db::PropertiesRepository & /*pr*/, const std::vector > & /*a*/, const std::vector > & /*b*/) { } virtual void end_edge_differences () { } + virtual void begin_edge_pair_differences () { } + virtual void detailed_diff (const db::PropertiesRepository & /*pr*/, const std::vector > & /*a*/, const std::vector > & /*b*/) { } + virtual void end_edge_pair_differences () { } virtual void begin_text_differences () { } virtual void detailed_diff (const db::PropertiesRepository & /*pr*/, const std::vector > & /*a*/, const std::vector > & /*b*/) { } virtual void end_text_differences () { } diff --git a/src/db/db/dbLayoutUtils.cc b/src/db/db/dbLayoutUtils.cc index 23a5d33a2..2196f9fa4 100644 --- a/src/db/db/dbLayoutUtils.cc +++ b/src/db/db/dbLayoutUtils.cc @@ -507,9 +507,6 @@ scale_and_snap (db::Layout &layout, db::Cell &cell, db::Coord g, db::Coord m, db std::vector heap; std::vector iterated_array_vectors; - std::vector new_insts_with_props; - std::vector new_insts; - std::vector instances_to_replace; for (db::Layout::iterator c = layout.begin (); c != layout.end (); ++c) { @@ -530,8 +527,7 @@ scale_and_snap (db::Layout &layout, db::Cell &cell, db::Coord g, db::Coord m, db for (db::Layout::layer_iterator l = layout.begin_layers (); l != layout.end_layers (); ++l) { db::Shapes &s = c->shapes ((*l).first); - - // TODO: properties, edges, edge pairs + db::Shapes new_shapes; for (db::Shapes::shape_iterator si = s.begin (db::ShapeIterator::Polygons | db::ShapeIterator::Paths | db::ShapeIterator::Boxes); ! si.at_end (); ++si) { @@ -541,7 +537,11 @@ scale_and_snap (db::Layout &layout, db::Cell &cell, db::Coord g, db::Coord m, db poly = scaled_and_snapped_polygon (poly, g, m, d, tr_disp.x (), g, m, d, tr_disp.y (), heap); poly.transform (trinv); - s.replace (*si, poly); + if (si->is_box () && poly.is_box ()) { + new_shapes.insert (db::BoxWithProperties (poly.box (), si->prop_id ())); + } else { + new_shapes.insert (db::PolygonWithProperties (poly, si->prop_id ())); + } } @@ -553,7 +553,7 @@ scale_and_snap (db::Layout &layout, db::Cell &cell, db::Coord g, db::Coord m, db text.trans (db::Trans (text.trans ().rot (), scaled_and_snapped_vector (text.trans ().disp (), g, m, d, tr_disp.x (), g, m, d, tr_disp.y ()))); text.transform (trinv); - s.replace (*si, text); + new_shapes.insert (db::TextWithProperties (text, si->prop_id ())); } @@ -565,7 +565,7 @@ scale_and_snap (db::Layout &layout, db::Cell &cell, db::Coord g, db::Coord m, db edge = scaled_and_snapped_edge (edge, g, m , d, tr_disp.x (), tr_disp.y ()); edge.transform (trinv); - s.replace (*si, edge); + new_shapes.insert (db::EdgeWithProperties (edge, si->prop_id ())); } @@ -578,127 +578,56 @@ scale_and_snap (db::Layout &layout, db::Cell &cell, db::Coord g, db::Coord m, db scaled_and_snapped_edge (edge_pair.second (), g, m , d, tr_disp.x (), tr_disp.y ())); edge_pair.transform (trinv); - s.replace (*si, edge_pair); + new_shapes.insert (db::EdgePairWithProperties (edge_pair, si->prop_id ())); } + s.swap (new_shapes); + } // Snap instance placements to grid and magnify // NOTE: we can modify the instances because the ScaleAndGridReducer marked every cell with children // as a variant cell (an effect of ScaleAndGridReducer::want_variants(cell) == true where cells have children). - // Variant cells are not copied blindly back to the original layout. - - new_insts.clear (); - new_insts_with_props.clear (); - instances_to_replace.clear (); + // The variant formation also made sure the iterated and regular arrays are exploded where required. for (db::Cell::const_iterator inst = c->begin (); ! inst.at_end (); ++inst) { const db::CellInstArray &ia = inst->cell_inst (); - // shortcut if we do not need to explode the array - iterated_array_vectors.clear (); db::Vector a, b; unsigned long na, nb; - bool need_explode = false; db::CellInstArray new_array (ia); - if (tr.is_complex ()) { + if (ia.is_iterated_array (&iterated_array_vectors)) { - need_explode = ia.size () > 1; - - } else if (ia.is_iterated_array (&iterated_array_vectors)) { - - for (std::vector::const_iterator i = iterated_array_vectors.begin (); ! need_explode && i != iterated_array_vectors.end (); ++i) { - need_explode = ! is_on_grid (*i, g, m, d); + bool needs_update = false; + for (std::vector::iterator i = iterated_array_vectors.begin (); i != iterated_array_vectors.end (); ++i) { + db::Vector v = scaled_and_snapped_vector (*i, g, m, d, tr_disp.x (), g, m, d, tr_disp.y ()); + if (v != *i) { + needs_update = true; + *i = v; + } } - if (! need_explode) { - - bool needs_update = false; - for (std::vector::iterator i = iterated_array_vectors.begin (); ! need_explode && i != iterated_array_vectors.end (); ++i) { - db::Vector v = scaled_and_snapped_vector (*i, g, m, d, tr_disp.x (), g, m, d, tr_disp.y ()); - if (v != *i) { - needs_update = true; - *i = v; - } - } - - if (needs_update) { - if (ia.is_complex ()) { - new_array = db::CellInstArray (ia.object (), ia.complex_trans (ia.front ()), iterated_array_vectors.begin (), iterated_array_vectors.end ()); - } else { - new_array = db::CellInstArray (ia.object (), ia.front (), iterated_array_vectors.begin (), iterated_array_vectors.end ()); - } - } - + if (needs_update) { + new_array = db::CellInstArray (ia.object (), ia.complex_trans (ia.front ()), iterated_array_vectors.begin (), iterated_array_vectors.end ()); } } else if (ia.is_regular_array (a, b, na, nb)) { - need_explode = (na > 1 && ! is_on_grid (a, g, m, d)) && (nb > 1 && ! is_on_grid (b, g, m, d)); + a = scaled_and_snapped_vector (a, g, m, d, tr_disp.x (), g, m, d, tr_disp.y ()); + b = scaled_and_snapped_vector (b, g, m, d, tr_disp.x (), g, m, d, tr_disp.y ()); - if (! need_explode) { - - a = scaled_and_snapped_vector (a, g, m, d, tr_disp.x (), g, m, d, tr_disp.y ()); - b = scaled_and_snapped_vector (b, g, m, d, tr_disp.x (), g, m, d, tr_disp.y ()); - - if (ia.is_complex ()) { - new_array = db::CellInstArray (ia.object (), ia.complex_trans (ia.front ()), a, b, na, nb); - } else { - new_array = db::CellInstArray (ia.object (), ia.front (), a, b, na, nb); - } - - } + new_array = db::CellInstArray (ia.object (), ia.complex_trans (ia.front ()), a, b, na, nb); } - if (! need_explode) { + scale_and_snap_cell_instance (new_array, tr, trinv, tr_disp, g, m, d); + c->replace (*inst, new_array); - scale_and_snap_cell_instance (new_array, tr, trinv, tr_disp, g, m, d); - c->replace (*inst, new_array); - - } else { - - instances_to_replace.push_back (*inst); - - for (db::CellInstArray::iterator i = ia.begin (); ! i.at_end (); ++i) { - - db::Trans ti (*i); - db::Vector ti_disp = ti.disp (); - ti_disp.transform (tr); - ti_disp = scaled_and_snapped_vector (ti_disp, g, m, d, tr_disp.x (), g, m, d, tr_disp.y ()); - ti_disp.transform (trinv); - ti.disp (ti_disp); - - db::CellInstArray new_array; - if (ia.is_complex ()) { - new_array = db::CellInstArray (ia.object (), ia.complex_trans (ti)); - } else { - new_array = db::CellInstArray (ia.object (), ti); - } - - if (inst->prop_id () > 0) { - new_insts_with_props.push_back (db::CellInstArrayWithProperties (new_array, inst->prop_id ())); - } else { - new_insts.push_back (new_array); - } - - } - - } - - } - - c->erase_insts (instances_to_replace); - for (std::vector::const_iterator i = new_insts.begin (); i != new_insts.end (); ++i) { - c->insert (*i); - } - for (std::vector::const_iterator i = new_insts_with_props.begin (); i != new_insts_with_props.end (); ++i) { - c->insert (*i); } } diff --git a/src/db/db/dbTestSupport.cc b/src/db/db/dbTestSupport.cc index aa5522df0..090e849a2 100644 --- a/src/db/db/dbTestSupport.cc +++ b/src/db/db/dbTestSupport.cc @@ -138,7 +138,7 @@ void compare_layouts (tl::TestBase *_this, const db::Layout &layout, const std:: equal = db::compare_layouts (*subject, layout_au, (n > 0 ? db::layout_diff::f_silent : db::layout_diff::f_verbose) | ((norm & AsPolygons) != 0 ? db::layout_diff::f_boxes_as_polygons + db::layout_diff::f_paths_as_polygons : 0) - | db::layout_diff::f_flatten_array_insts + | ((norm & WithArrays) != 0 ? 0 : db::layout_diff::f_flatten_array_insts) /*| db::layout_diff::f_no_text_details | db::layout_diff::f_no_text_orientation*/ , tolerance, 100 /*max diff lines*/); if (equal && n > 0) { diff --git a/src/db/db/dbTestSupport.h b/src/db/db/dbTestSupport.h index 9b031fdce..8f89cf7e9 100644 --- a/src/db/db/dbTestSupport.h +++ b/src/db/db/dbTestSupport.h @@ -56,7 +56,8 @@ enum NormalizationMode WriteOAS = 2, // normalize subject by writing to OASIS and reading back NormFileMask = 7, // bits the extract for file mode NoContext = 8, // write tmp file without context - AsPolygons = 16 // paths and boxes are treated as polygons + AsPolygons = 16, // paths and boxes are treated as polygons + WithArrays = 32 // do not flatten arrays }; /** diff --git a/src/db/unit_tests/dbLayoutUtilsTests.cc b/src/db/unit_tests/dbLayoutUtilsTests.cc index 3dac06878..26130e050 100644 --- a/src/db/unit_tests/dbLayoutUtilsTests.cc +++ b/src/db/unit_tests/dbLayoutUtilsTests.cc @@ -25,6 +25,8 @@ #include "dbCellMapping.h" #include "dbTestSupport.h" #include "dbReader.h" +#include "dbLayoutDiff.h" +#include "dbPropertiesRepository.h" #include "tlString.h" #include "tlUnitTest.h" @@ -653,3 +655,127 @@ TEST(18_scale_and_snap) CHECKPOINT(); db::compare_layouts (_this, l1, tl::testdata () + "/algo/layout_utils_au_sns3.gds"); } + +TEST(19_scale_and_snap_basic) +{ + db::Layout l1; + db::Layout l2; + + db::PropertiesRepository::properties_set ps1; + ps1.insert (std::make_pair (l1.properties_repository ().prop_name_id (tl::Variant ("p")), tl::Variant (17))); + db::properties_id_type pid1 = l1.properties_repository ().properties_id (ps1); + + db::PropertiesRepository::properties_set ps2; + ps2.insert (std::make_pair (l2.properties_repository ().prop_name_id (tl::Variant ("p")), tl::Variant (17))); + db::properties_id_type pid2 = l2.properties_repository ().properties_id (ps2); + + db::Cell &top1 = l1.cell (l1.add_cell ("TOP")); + db::Cell &top2 = l2.cell (l2.add_cell ("TOP")); + + db::Cell &a1 = l1.cell (l1.add_cell ("A")); + db::Cell &a2a = l2.cell (l2.add_cell ("A")); + + unsigned int layer1 = l1.insert_layer (db::LayerProperties (1, 0)); + unsigned int layer2 = l2.insert_layer (db::LayerProperties (1, 0)); + + a1.shapes (layer1).insert (db::Box (0, 0, 100, 100)); + a2a.shapes (layer2).insert (db::Box (0, 0, 100, 100)); + + top1.shapes (layer1).insert (db::Box (11, 21, 31, 41)); + top2.shapes (layer2).insert (db::Box (10, 20, 30, 40)); + + top1.shapes (layer1).insert (db::BoxWithProperties (db::Box (11, 21, 31, 41), pid1)); + top2.shapes (layer2).insert (db::BoxWithProperties (db::Box (10, 20, 30, 40), pid2)); + + top1.shapes (layer1).insert (db::Edge (11, 21, 31, 41)); + top2.shapes (layer2).insert (db::Edge (10, 20, 30, 40)); + + top1.shapes (layer1).insert (db::EdgeWithProperties (db::Edge (11, 21, 31, 41), pid1)); + top2.shapes (layer2).insert (db::EdgeWithProperties (db::Edge (10, 20, 30, 40), pid2)); + + top1.shapes (layer1).insert (db::EdgePair (db::Edge (11, 21, 31, 41), db::Edge (111, 121, 131, 141))); + top2.shapes (layer2).insert (db::EdgePair (db::Edge (10, 20, 30, 40), db::Edge (110, 120, 130, 140))); + + top1.shapes (layer1).insert (db::EdgePairWithProperties (db::EdgePair (db::Edge (11, 21, 31, 41), db::Edge (111, 121, 131, 141)), pid1)); + top2.shapes (layer2).insert (db::EdgePairWithProperties (db::EdgePair (db::Edge (10, 20, 30, 40), db::Edge (110, 120, 130, 140)), pid2)); + + top1.shapes (layer1).insert (db::Polygon (db::Box (11, 21, 31, 41))); + top2.shapes (layer2).insert (db::Polygon (db::Box (10, 20, 30, 40))); + + top1.shapes (layer1).insert (db::PolygonWithProperties (db::Polygon (db::Box (11, 21, 31, 41)), pid1)); + top2.shapes (layer2).insert (db::PolygonWithProperties (db::Polygon (db::Box (10, 20, 30, 40)), pid2)); + + db::Point pts1[] = { + db::Point (1, 101), + db::Point (101, 101), + db::Point (101, 201) + }; + + db::Point pts2[] = { + db::Point (0, 100), + db::Point (100, 100), + db::Point (100, 200) + }; + + top1.shapes (layer1).insert (db::Path (&pts1 [0], &pts1 [sizeof (pts1) / sizeof(pts1 [0])], 20)); + top2.shapes (layer2).insert (db::Path (&pts2 [0], &pts2 [sizeof (pts2) / sizeof(pts2 [0])], 20)); + + top1.shapes (layer1).insert (db::PathWithProperties (db::Path (&pts1 [0], &pts1 [sizeof (pts1) / sizeof(pts1 [0])], 20), pid1)); + top2.shapes (layer2).insert (db::PathWithProperties (db::Path (&pts2 [0], &pts2 [sizeof (pts2) / sizeof(pts2 [0])], 20), pid2)); + + top1.shapes (layer1).insert (db::Text ("t1", db::Trans (db::Vector (11, 21)))); + top2.shapes (layer2).insert (db::Text ("t1", db::Trans (db::Vector (10, 20)))); + + top1.shapes (layer1).insert (db::TextWithProperties (db::Text ("t1", db::Trans (db::Vector (11, 21))), pid1)); + top2.shapes (layer2).insert (db::TextWithProperties (db::Text ("t1", db::Trans (db::Vector (10, 20))), pid2)); + + top1.insert (db::CellInstArray (db::CellInst (a1.cell_index ()), db::Trans (db::Vector (11, 21)))); + top2.insert (db::CellInstArray (db::CellInst (a2a.cell_index ()), db::Trans (db::Vector (10, 20)))); + + top1.insert (db::CellInstArrayWithProperties (db::CellInstArray (db::CellInst (a1.cell_index ()), db::Trans (db::Vector (11, 21))), pid1)); + top2.insert (db::CellInstArrayWithProperties (db::CellInstArray (db::CellInst (a2a.cell_index ()), db::Trans (db::Vector (10, 20))), pid2)); + + top1.insert (db::CellInstArray (db::CellInst (a1.cell_index ()), db::Trans (db::Vector (11, 21)), db::Vector (0, 10), db::Vector (10, 0), 2, 3)); + top2.insert (db::CellInstArray (db::CellInst (a2a.cell_index ()), db::Trans (db::Vector (10, 20)), db::Vector (0, 10), db::Vector (10, 0), 2, 3)); + + top1.insert (db::CellInstArrayWithProperties (db::CellInstArray (db::CellInst (a1.cell_index ()), db::Trans (db::Vector (11, 21)), db::Vector (0, 10), db::Vector (10, 0), 2, 3), pid1)); + top2.insert (db::CellInstArrayWithProperties (db::CellInstArray (db::CellInst (a2a.cell_index ()), db::Trans (db::Vector (10, 20)), db::Vector (0, 10), db::Vector (10, 0), 2, 3), pid2)); + + std::vector ia; + ia.push_back (db::Vector (0, 0)); + ia.push_back (db::Vector (10, 0)); + ia.push_back (db::Vector (0, 10)); + + top1.insert (db::CellInstArray (db::CellInst (a1.cell_index ()), db::Trans (db::Vector (11, 21)), ia.begin (), ia.end ())); + top2.insert (db::CellInstArray (db::CellInst (a2a.cell_index ()), db::Trans (db::Vector (10, 20)), ia.begin (), ia.end ())); + + top1.insert (db::CellInstArrayWithProperties (db::CellInstArray (db::CellInst (a1.cell_index ()), db::Trans (db::Vector (11, 21)), ia.begin (), ia.end ()), pid1)); + top2.insert (db::CellInstArrayWithProperties (db::CellInstArray (db::CellInst (a2a.cell_index ()), db::Trans (db::Vector (10, 20)), ia.begin (), ia.end ()), pid2)); + + db::scale_and_snap (l1, top1, 10, 1, 1); + + bool equal = db::compare_layouts (l1, l2, + db::layout_diff::f_verbose + | db::layout_diff::f_boxes_as_polygons + | db::layout_diff::f_paths_as_polygons + , 0, 100 /*max diff lines*/); + EXPECT_EQ (equal, true); +} + +TEST(20_scale_and_snap) +{ + db::Layout l1; + { + std::string fn (tl::testdata ()); + fn += "/algo/scale_and_snap4.oas"; + tl::InputStream stream (fn); + db::Reader reader (stream); + reader.read (l1); + } + + db::scale_and_snap (l1, l1.cell (*l1.begin_top_down ()), 10, 95, 100); + + CHECKPOINT(); + db::compare_layouts (_this, l1, tl::testdata () + "/algo/layout_utils_au_sns4.oas", db::NormalizationMode (db::WriteOAS + db::WithArrays)); +} + diff --git a/testdata/algo/layout_utils_au_sns4.oas b/testdata/algo/layout_utils_au_sns4.oas new file mode 100644 index 000000000..3213ccba4 Binary files /dev/null and b/testdata/algo/layout_utils_au_sns4.oas differ diff --git a/testdata/algo/scale_and_snap4.oas b/testdata/algo/scale_and_snap4.oas new file mode 100644 index 000000000..a92021ed5 Binary files /dev/null and b/testdata/algo/scale_and_snap4.oas differ