luke
/
klayout
mirror of https://github.com/KLayout/klayout.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Refactoring: shape processors now allow modifying properties

This commit is contained in:
Matthias Koefferlein 2025-07-26 18:09:31 +02:00
parent 2369c69f69
commit 80276f8799
21 changed files with 191 additions and 401 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/db/db/db.pro
View File

@ -58,6 +58,7 @@ SOURCES = \
dbLog.cc \
dbManager.cc \
dbMatrix.cc \
dbMeasure.cc \
dbMemStatistics.cc \
dbMutableEdgePairs.cc \
dbMutableEdges.cc \
@ -295,6 +296,7 @@ HEADERS = \
dbLog.h \
dbManager.h \
dbMatrix.h \
dbMeasure.h \
dbMemStatistics.h \
dbMetaInfo.h \
dbMutableEdgePairs.h \

38
src/db/db/dbAsIfFlatEdgePairs.cc
View File

@ -160,13 +160,17 @@ AsIfFlatEdgePairs::processed (const EdgePairProcessorBase &filter) const
{
std::unique_ptr<FlatEdgePairs> edge_pairs (new FlatEdgePairs ());
std::vector<db::EdgePair> res_edge_pairs;
std::vector<db::EdgePairWithProperties> res_edge_pairs;
for (EdgePairsIterator e = begin (); ! e.at_end (); ++e) {
res_edge_pairs.clear ();
filter.process (*e, res_edge_pairs);
for (std::vector<db::EdgePair>::const_iterator er = res_edge_pairs.begin (); er != res_edge_pairs.end (); ++er) {
edge_pairs->insert (*er);
filter.process (e.wp (), res_edge_pairs);
for (auto er = res_edge_pairs.begin (); er != res_edge_pairs.end (); ++er) {
if (er->properties_id () != 0) {
edge_pairs->insert (*er);
} else {
edge_pairs->insert (er->base ());
}
}
}
@ -182,17 +186,16 @@ AsIfFlatEdgePairs::processed_to_polygons (const EdgePairToPolygonProcessorBase &
region->set_merged_semantics (false);
}
std::vector<db::Polygon> res_polygons;
std::vector<db::PolygonWithProperties> res_polygons;
for (EdgePairsIterator e (begin ()); ! e.at_end (); ++e) {
res_polygons.clear ();
filter.process (*e, res_polygons);
for (std::vector<db::Polygon>::const_iterator pr = res_polygons.begin (); pr != res_polygons.end (); ++pr) {
db::properties_id_type prop_id = e.prop_id ();
if (prop_id != 0) {
region->insert (db::PolygonWithProperties (*pr, prop_id));
} else {
filter.process (e.wp (), res_polygons);
for (auto pr = res_polygons.begin (); pr != res_polygons.end (); ++pr) {
if (pr->properties_id () != 0) {
region->insert (*pr);
} else {
region->insert (pr->base ());
}
}
}
@ -209,17 +212,16 @@ AsIfFlatEdgePairs::processed_to_edges (const EdgePairToEdgeProcessorBase &filter
edges->set_merged_semantics (false);
}
std::vector<db::Edge> res_edges;
std::vector<db::EdgeWithProperties> res_edges;
for (EdgePairsIterator e (begin ()); ! e.at_end (); ++e) {
res_edges.clear ();
filter.process (*e, res_edges);
for (std::vector<db::Edge>::const_iterator pr = res_edges.begin (); pr != res_edges.end (); ++pr) {
db::properties_id_type prop_id = e.prop_id ();
if (prop_id != 0) {
edges->insert (db::EdgeWithProperties (*pr, prop_id));
} else {
filter.process (e.wp (), res_edges);
for (auto pr = res_edges.begin (); pr != res_edges.end (); ++pr) {
if (pr->properties_id () != 0) {
edges->insert (*pr);
} else {
edges->insert (pr->base ());
}
}
}

36
src/db/db/dbAsIfFlatEdges.cc
View File

@ -648,13 +648,17 @@ AsIfFlatEdges::processed (const EdgeProcessorBase &filter) const
edges->set_merged_semantics (false);
}
std::vector<db::Edge> res_edges;
std::vector<db::EdgeWithProperties> res_edges;
for (EdgesIterator e (filter.requires_raw_input () ? begin () : begin_merged ()); ! e.at_end (); ++e) {
res_edges.clear ();
filter.process (*e, res_edges);
for (std::vector<db::Edge>::const_iterator er = res_edges.begin (); er != res_edges.end (); ++er) {
edges->insert (*er);
filter.process (e.wp (), res_edges);
for (auto er = res_edges.begin (); er != res_edges.end (); ++er) {
if (er->properties_id () != 0) {
edges->insert (*er);
} else {
edges->insert (er->base ());
}
}
}
@ -670,13 +674,17 @@ AsIfFlatEdges::processed_to_edge_pairs (const EdgeToEdgePairProcessorBase &filte
edge_pairs->set_merged_semantics (false);
}
std::vector<db::EdgePair> res_edge_pairs;
std::vector<db::EdgePairWithProperties> res_edge_pairs;
for (EdgesIterator e (filter.requires_raw_input () ? begin () : begin_merged ()); ! e.at_end (); ++e) {
res_edge_pairs.clear ();
filter.process (*e, res_edge_pairs);
for (std::vector<db::EdgePair>::const_iterator epr = res_edge_pairs.begin (); epr != res_edge_pairs.end (); ++epr) {
edge_pairs->insert (*epr);
filter.process (e.wp (), res_edge_pairs);
for (auto epr = res_edge_pairs.begin (); epr != res_edge_pairs.end (); ++epr) {
if (epr->properties_id () != 0) {
edge_pairs->insert (*epr);
} else {
edge_pairs->insert (epr->base ());
}
}
}
@ -692,13 +700,17 @@ AsIfFlatEdges::processed_to_polygons (const EdgeToPolygonProcessorBase &filter)
region->set_merged_semantics (false);
}
std::vector<db::Polygon> res_polygons;
std::vector<db::PolygonWithProperties> res_polygons;
for (EdgesIterator e (filter.requires_raw_input () ? begin () : begin_merged ()); ! e.at_end (); ++e) {
res_polygons.clear ();
filter.process (*e, res_polygons);
for (std::vector<db::Polygon>::const_iterator pr = res_polygons.begin (); pr != res_polygons.end (); ++pr) {
region->insert (*pr);
filter.process (e.wp (), res_polygons);
for (auto pr = res_polygons.begin (); pr != res_polygons.end (); ++pr) {
if (pr->properties_id () != 0) {
region->insert (*pr);
} else {
region->insert (pr->base ());
}
}
}

52
src/db/db/dbAsIfFlatRegion.cc
View File

@ -155,29 +155,29 @@ AsIfFlatRegion::edges (const EdgeFilterBase *filter, const PolygonToEdgeProcesso
}
result->reserve (n);
std::vector<db::Edge> heap;
std::vector<db::EdgeWithProperties> heap;
for (RegionIterator p (begin_merged ()); ! p.at_end (); ++p) {
db::properties_id_type prop_id = p.prop_id ();
if (proc) {
heap.clear ();
proc->process (*p, heap);
proc->process (p.wp (), heap);
for (auto e = heap.begin (); e != heap.end (); ++e) {
if (! filter || filter->selected (*e, prop_id)) {
if (prop_id != 0) {
result->insert (db::EdgeWithProperties (*e, prop_id));
} else {
if (! filter || filter->selected (*e, e->properties_id ())) {
if (e->properties_id () != 0) {
result->insert (*e);
} else {
result->insert (e->base ());
}
}
}
} else {
auto prop_id = p.prop_id ();
for (db::Polygon::polygon_edge_iterator e = p->begin_edge (); ! e.at_end (); ++e) {
if (! filter || filter->selected (*e, prop_id)) {
if (prop_id != 0) {
@ -460,17 +460,17 @@ AsIfFlatRegion::processed (const PolygonProcessorBase &filter) const
new_region->set_merged_semantics (false);
}
std::vector<db::Polygon> poly_res;
std::vector<db::PolygonWithProperties> poly_res;
for (RegionIterator p (filter.requires_raw_input () ? begin () : begin_merged ()); ! p.at_end (); ++p) {
poly_res.clear ();
filter.process (*p, poly_res);
for (std::vector<db::Polygon>::const_iterator pr = poly_res.begin (); pr != poly_res.end (); ++pr) {
if (p.prop_id () != 0) {
new_region->insert (db::PolygonWithProperties (*pr, p.prop_id ()));
} else {
filter.process (p.wp (), poly_res);
for (auto pr = poly_res.begin (); pr != poly_res.end (); ++pr) {
if (pr->properties_id () != 0) {
new_region->insert (*pr);
} else {
new_region->insert (pr->base ());
}
}
@ -487,17 +487,17 @@ AsIfFlatRegion::processed_to_edges (const PolygonToEdgeProcessorBase &filter) co
new_edges->set_merged_semantics (false);
}
std::vector<db::Edge> edge_res;
std::vector<db::EdgeWithProperties> edge_res;
for (RegionIterator p (filter.requires_raw_input () ? begin () : begin_merged ()); ! p.at_end (); ++p) {
edge_res.clear ();
filter.process (*p, edge_res);
for (std::vector<db::Edge>::const_iterator er = edge_res.begin (); er != edge_res.end (); ++er) {
if (p.prop_id () != 0) {
new_edges->insert (db::EdgeWithProperties (*er, p.prop_id ()));
} else {
filter.process (p.wp (), edge_res);
for (auto er = edge_res.begin (); er != edge_res.end (); ++er) {
if (er->properties_id () != 0) {
new_edges->insert (*er);
} else {
new_edges->insert (er->base ());
}
}
@ -514,17 +514,17 @@ AsIfFlatRegion::processed_to_edge_pairs (const PolygonToEdgePairProcessorBase &f
new_edge_pairs->set_merged_semantics (false);
}
std::vector<db::EdgePair> edge_pair_res;
std::vector<db::EdgePairWithProperties> edge_pair_res;
for (RegionIterator p (filter.requires_raw_input () ? begin () : begin_merged ()); ! p.at_end (); ++p) {
edge_pair_res.clear ();
filter.process (*p, edge_pair_res);
for (std::vector<db::EdgePair>::const_iterator epr = edge_pair_res.begin (); epr != edge_pair_res.end (); ++epr) {
if (p.prop_id () != 0) {
new_edge_pairs->insert (db::EdgePairWithProperties (*epr, p.prop_id ()));
} else {
filter.process (p.wp (), edge_pair_res);
for (auto epr = edge_pair_res.begin (); epr != edge_pair_res.end (); ++epr) {
if (epr->properties_id () != 0) {
new_edge_pairs->insert (*epr);
} else {
new_edge_pairs->insert (epr->base ());
}
}

24
src/db/db/dbAsIfFlatTexts.cc
View File

@ -193,13 +193,17 @@ AsIfFlatTexts::processed (const TextProcessorBase &filter) const
{
std::unique_ptr<FlatTexts> texts (new FlatTexts ());
std::vector<db::Text> res_texts;
std::vector<db::TextWithProperties> res_texts;
for (TextsIterator e = begin (); ! e.at_end (); ++e) {
res_texts.clear ();
filter.process (*e, res_texts);
for (std::vector<db::Text>::const_iterator er = res_texts.begin (); er != res_texts.end (); ++er) {
texts->insert (*er);
filter.process (e.wp (), res_texts);
for (auto er = res_texts.begin (); er != res_texts.end (); ++er) {
if (er->properties_id () != 0) {
texts->insert (*er);
} else {
texts->insert (er->base ());
}
}
}
@ -215,16 +219,16 @@ AsIfFlatTexts::processed_to_polygons (const TextToPolygonProcessorBase &filter)
region->set_merged_semantics (false);
}
std::vector<db::Polygon> res_polygons;
std::vector<db::PolygonWithProperties> res_polygons;
for (TextsIterator e (begin ()); ! e.at_end (); ++e) {
res_polygons.clear ();
filter.process (*e, res_polygons);
for (std::vector<db::Polygon>::const_iterator pr = res_polygons.begin (); pr != res_polygons.end (); ++pr) {
if (e.prop_id () != 0) {
region->insert (db::PolygonWithProperties (*pr, e.prop_id ()));
} else {
filter.process (e.wp (), res_polygons);
for (auto pr = res_polygons.begin (); pr != res_polygons.end (); ++pr) {
if (pr->properties_id () != 0) {
region->insert (*pr);
} else {
region->insert (pr->base ());
}
}
}

13
src/db/db/dbDeepRegion.cc
View File

@ -1505,12 +1505,13 @@ DeepRegion::edges (const EdgeFilterBase *filter, const PolygonToEdgeProcessorBas
const db::Shapes &s = c->shapes (polygons.layer ());
db::Shapes &st = c->shapes (res->deep_layer ().layer ());
std::vector<db::Edge> heap;
std::vector<db::EdgeWithProperties> heap;
for (db::Shapes::shape_iterator si = s.begin (db::ShapeIterator::All); ! si.at_end (); ++si) {
db::Polygon poly;
db::PolygonWithProperties poly;
si->polygon (poly);
poly.properties_id (si->prop_id ());
if (proc) {
@ -1518,16 +1519,16 @@ DeepRegion::edges (const EdgeFilterBase *filter, const PolygonToEdgeProcessorBas
proc->process (poly, heap);
for (auto e = heap.begin (); e != heap.end (); ++e) {
if (! filter || filter->selected ((*e).transformed (tr), si->prop_id ())) {
st.insert (db::EdgeWithProperties (*e, si->prop_id ()));
if (! filter || filter->selected ((*e).transformed (tr), e->properties_id ())) {
st.insert (*e);
}
}
} else {
for (db::Polygon::polygon_edge_iterator e = poly.begin_edge (); ! e.at_end (); ++e) {
if (! filter || filter->selected ((*e).transformed (tr), si->prop_id ())) {
st.insert (db::EdgeWithProperties (*e, si->prop_id ()));
if (! filter || filter->selected ((*e).transformed (tr), poly.properties_id ())) {
st.insert (db::EdgeWithProperties (*e, poly.properties_id ()));
}
}

39
src/db/db/dbEdgePairsDelegate.h
View File

@ -52,14 +52,6 @@ public:
: m_e (e)
{ }
void process(const EdgePair &ep, std::vector<db::Polygon> &res) const
{
db::Polygon poly = ep.normalized ().to_polygon (m_e);
if (poly.vertices () >= 3) {
res.push_back (poly);
}
}
void process(const EdgePairWithProperties &ep, std::vector<db::PolygonWithProperties> &res) const
{
db::Polygon poly = ep.normalized ().to_polygon (m_e);
@ -80,12 +72,6 @@ public:
EdgePairToEdgesProcessor ()
{ }
void process(const EdgePair &ep, std::vector<db::Edge> &res) const
{
res.push_back (ep.first ());
res.push_back (ep.second ());
}
void process(const EdgePairWithProperties &ep, std::vector<db::EdgeWithProperties> &res) const
{
res.push_back (db::EdgeWithProperties (ep.first (), ep.properties_id ()));
@ -101,14 +87,6 @@ public:
EdgePairToFirstEdgesProcessor ()
{ }
void process(const EdgePair &ep, std::vector<db::Edge> &res) const
{
res.push_back (ep.first ());
if (ep.is_symmetric ()) {
res.push_back (ep.second ());
}
}
void process(const EdgePairWithProperties &ep, std::vector<db::EdgeWithProperties> &res) const
{
res.push_back (db::EdgeWithProperties (ep.first (), ep.properties_id ()));
@ -126,13 +104,6 @@ public:
EdgePairToSecondEdgesProcessor ()
{ }
void process(const EdgePair &ep, std::vector<db::Edge> &res) const
{
if (! ep.is_symmetric ()) {
res.push_back (ep.second ());
}
}
void process(const EdgePairWithProperties &ep, std::vector<db::EdgeWithProperties> &res) const
{
if (! ep.is_symmetric ()) {
@ -149,11 +120,6 @@ public:
EdgePairToLesserEdgesProcessor ()
{ }
void process(const EdgePair &ep, std::vector<db::Edge> &res) const
{
res.push_back (ep.lesser ());
}
void process(const EdgePairWithProperties &ep, std::vector<db::EdgeWithProperties> &res) const
{
res.push_back (db::EdgeWithProperties (ep.lesser (), ep.properties_id ()));
@ -168,11 +134,6 @@ public:
EdgePairToGreaterEdgesProcessor ()
{ }
void process(const EdgePair &ep, std::vector<db::Edge> &res) const
{
res.push_back (ep.greater ());
}
void process(const EdgePairWithProperties &ep, std::vector<db::EdgeWithProperties> &res) const
{
res.push_back (db::EdgeWithProperties (ep.greater (), ep.properties_id ()));

28
src/db/db/dbEdgesUtils.cc
View File

@ -184,34 +184,6 @@ EdgeSegmentSelector::EdgeSegmentSelector (int mode, Edge::distance_type length,
EdgeSegmentSelector::~EdgeSegmentSelector ()
{ }
void
EdgeSegmentSelector::process (const db::Edge &edge, std::vector<db::Edge> &res) const
{
double l = std::max (edge.double_length () * m_fraction, double (m_length));
db::DVector ds;
if (! edge.is_degenerate ()) {
ds = db::DVector (edge.d ()) * (l / edge.double_length ());
}
if (m_mode < 0) {
res.push_back (db::Edge (edge.p1 (), db::Point (db::DPoint (edge.p1 ()) + ds)));
} else if (m_mode > 0) {
res.push_back (db::Edge (db::Point (db::DPoint (edge.p2 ()) - ds), edge.p2 ()));
} else {
db::DVector dl = ds * 0.5;
db::DPoint center = db::DPoint (edge.p1 ()) + db::DVector (edge.p2 () - edge.p1 ()) * 0.5;
res.push_back (db::Edge (db::Point (center - dl), db::Point (center + dl)));
}
}
void
EdgeSegmentSelector::process (const db::EdgeWithProperties &edge, std::vector<db::EdgeWithProperties> &res) const
{

6
src/db/db/dbEdgesUtils.h
View File

@ -644,11 +644,6 @@ public:
: m_ext_b (ext_b), m_ext_e (ext_e), m_ext_o (ext_o), m_ext_i (ext_i)
{ }
virtual void process (const Edge &edge, std::vector<db::Polygon> &res) const
{
res.push_back (extended_edge (edge, m_ext_b, m_ext_e, m_ext_o, m_ext_i));
}
virtual void process (const EdgeWithProperties &edge, std::vector<db::PolygonWithProperties> &res) const
{
res.push_back (db::PolygonWithProperties (extended_edge (edge, m_ext_b, m_ext_e, m_ext_o, m_ext_i), edge.properties_id ()));
@ -668,7 +663,6 @@ public:
EdgeSegmentSelector (int mode, Edge::distance_type length, double fraction);
~EdgeSegmentSelector ();
virtual void process (const db::Edge &edge, std::vector<db::Edge> &res) const;
virtual void process (const db::EdgeWithProperties &edge, std::vector<db::EdgeWithProperties> &res) const;
virtual const TransformationReducer *vars () const { return &m_vars; }

16
src/db/db/dbFlatEdges.cc
View File

@ -226,7 +226,7 @@ Box FlatEdges::compute_bbox () const
EdgesDelegate *
FlatEdges::processed_in_place (const EdgeProcessorBase &filter)
{
std::vector<db::Edge> edge_res;
std::vector<db::EdgeWithProperties> edge_res;
db::Shapes &e = *mp_edges;
@ -236,22 +236,22 @@ FlatEdges::processed_in_place (const EdgeProcessorBase &filter)
for (EdgesIterator p (filter.requires_raw_input () ? begin () : begin_merged ()); ! p.at_end (); ++p) {
edge_res.clear ();
filter.process (*p, edge_res);
filter.process (p.wp (), edge_res);
for (std::vector<db::Edge>::const_iterator pr = edge_res.begin (); pr != edge_res.end (); ++pr) {
if (p.prop_id () != 0) {
for (auto pr = edge_res.begin (); pr != edge_res.end (); ++pr) {
if (pr->properties_id () != 0) {
if (pw_wp == e.get_layer<db::EdgeWithProperties, db::unstable_layer_tag> ().end ()) {
e.get_layer<db::EdgeWithProperties, db::unstable_layer_tag> ().insert (db::EdgeWithProperties (*pr, p.prop_id ()));
e.get_layer<db::EdgeWithProperties, db::unstable_layer_tag> ().insert (*pr);
pw_wp = e.get_layer<db::EdgeWithProperties, db::unstable_layer_tag> ().end ();
} else {
e.get_layer<db::EdgeWithProperties, db::unstable_layer_tag> ().replace (pw_wp++, db::EdgeWithProperties (*pr, p.prop_id ()));
e.get_layer<db::EdgeWithProperties, db::unstable_layer_tag> ().replace (pw_wp++, *pr);
}
} else {
if (pw == e.get_layer<db::Edge, db::unstable_layer_tag> ().end ()) {
e.get_layer<db::Edge, db::unstable_layer_tag> ().insert (*pr);
e.get_layer<db::Edge, db::unstable_layer_tag> ().insert (pr->base ());
pw = e.get_layer<db::Edge, db::unstable_layer_tag> ().end ();
} else {
e.get_layer<db::Edge, db::unstable_layer_tag> ().replace (pw++, *pr);
e.get_layer<db::Edge, db::unstable_layer_tag> ().replace (pw++, pr->base ());
}
}
}

14
src/db/db/dbFlatRegion.cc
View File

@ -220,16 +220,16 @@ RegionDelegate *FlatRegion::process_in_place (const PolygonProcessorBase &filter
db::layer<db::PolygonWithProperties, db::unstable_layer_tag> &poly_layer_wp = mp_polygons->get_layer<db::PolygonWithProperties, db::unstable_layer_tag> ();
db::layer<db::PolygonWithProperties, db::unstable_layer_tag> out_wp;
std::vector<db::Polygon> poly_res;
std::vector<db::PolygonWithProperties> poly_res;
for (RegionIterator p (filter.requires_raw_input () ? begin () : begin_merged ()); ! p.at_end (); ++p) {
poly_res.clear ();
filter.process (*p, poly_res);
if (p.prop_id () != 0) {
for (auto r = poly_res.begin (); r != poly_res.end (); ++r) {
out_wp.insert (db::PolygonWithProperties (*r, p.prop_id ()));
filter.process (p.wp (), poly_res);
for (auto r = poly_res.begin (); r != poly_res.end (); ++r) {
if (r->properties_id () != 0) {
out_wp.insert (*r);
} else {
out_wp.insert (r->base ());
}
} else {
out.insert (poly_res.begin (), poly_res.end ());
}
}

6
src/db/db/dbGenericShapeIterator.h
View File

@ -284,6 +284,7 @@ class DB_PUBLIC generic_shape_iterator
public:
typedef T value_type;
typedef const value_type &reference;
typedef const db::object_with_properties<value_type> with_properties_type;
typedef const value_type *pointer;
typedef std::forward_iterator_tag iterator_category;
typedef void difference_type;
@ -373,6 +374,11 @@ public:
return mp_delegate->get ();
}
with_properties_type wp () const
{
return with_properties_type (*mp_delegate->get (), mp_delegate->prop_id ());
}
generic_shape_iterator &operator++ ()
{
mp_delegate->increment ();

45
src/db/db/dbMeasure.cc Normal file
View File

@ -0,0 +1,45 @@
/*
KLayout Layout Viewer
Copyright (C) 2006-2025 Matthias Koefferlein
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include "dbMeasure.h"
#include "dbRegion.h"
#include "dbEdges.h"
#include "dbEdgePairs.h"
#include "dbTexts.h"
#include "tlExpression.h"
namespace db
{
template <class Container>
void compute_as_properties (Container *container, const std::map<tl::Variant, std::string> &expressions, bool clear_properties)
{
// - collect property names
// - define functions for
}
}

0
src/db/db/dbMeasure.h Normal file
View File

16
src/db/db/dbObjectWithProperties.h
View File

@ -186,6 +186,22 @@ public:
return db::properties_id_less (m_id, d.m_id);
}
/**
* @brief Downcase to base object (non-const)
*/
Obj &base ()
{
return *this;
}
/**
* @brief Downcase to base object (const)
*/
const Obj &base () const
{
return *this;
}
/**
* @brief Properties Id read accessor
*/

117
src/db/db/dbRegionProcessors.cc
View File

@ -97,14 +97,6 @@ void CornerDetectorCore::detect_corners (const db::PolygonWithProperties &poly,
// -----------------------------------------------------------------------------------
// Extents implementation
void Extents::process (const db::Polygon &poly, std::vector<db::Polygon> &result) const
{
db::Box b = poly.box ();
if (! b.empty ()) {
result.push_back (db::Polygon (b));
}
}
void Extents::process (const db::PolygonWithProperties &poly, std::vector<db::PolygonWithProperties> &result) const
{
db::Box b = poly.box ();
@ -116,19 +108,6 @@ void Extents::process (const db::PolygonWithProperties &poly, std::vector<db::Po
// -----------------------------------------------------------------------------------
// RelativeExtents implementation
void RelativeExtents::process (const db::Polygon &poly, std::vector<db::Polygon> &result) const
{
db::Box b = poly.box ();
db::Point p1 (b.left () + db::coord_traits<db::Coord>::rounded (m_fx1 * b.width ()),
b.bottom () + db::coord_traits<db::Coord>::rounded (m_fy1 * b.height ()));
db::Point p2 (b.left () + db::coord_traits<db::Coord>::rounded (m_fx2 * b.width ()),
b.bottom () + db::coord_traits<db::Coord>::rounded (m_fy2 * b.height ()));
db::Box box = db::Box (p1, p2).enlarged (db::Vector (m_dx, m_dy));
if (! box.empty ()) {
result.push_back (db::Polygon (box));
}
}
void RelativeExtents::process (const db::PolygonWithProperties &poly, std::vector<db::PolygonWithProperties> &result) const
{
db::Box b = poly.box ();
@ -156,16 +135,6 @@ const TransformationReducer *RelativeExtents::vars () const
// -----------------------------------------------------------------------------------
// RelativeExtentsAsEdges implementation
void RelativeExtentsAsEdges::process (const db::Polygon &poly, std::vector<db::Edge> &result) const
{
db::Box b = poly.box ();
db::Point p1 (b.left () + db::coord_traits<db::Coord>::rounded (m_fx1 * b.width ()),
b.bottom () + db::coord_traits<db::Coord>::rounded (m_fy1 * b.height ()));
db::Point p2 (b.left () + db::coord_traits<db::Coord>::rounded (m_fx2 * b.width ()),
b.bottom () + db::coord_traits<db::Coord>::rounded (m_fy2 * b.height ()));
result.push_back (db::Edge (p1, p2));
}
void RelativeExtentsAsEdges::process (const db::PolygonWithProperties &poly, std::vector<db::EdgeWithProperties> &result) const
{
db::Box b = poly.box ();
@ -280,23 +249,6 @@ contour_to_edges (const db::Polygon::contour_type &contour, PolygonToEdgeProcess
}
}
void PolygonToEdgeProcessor::process (const db::Polygon &poly, std::vector<db::Edge> &result) const
{
if (m_mode == All) {
for (db::Polygon::polygon_edge_iterator e = poly.begin_edge (); ! e.at_end (); ++e) {
result.push_back (*e);
}
} else {
for (unsigned int i = 0; i < poly.holes () + 1; ++i) {
contour_to_edges (poly.contour (i), m_mode, result);
}
}
}
void PolygonToEdgeProcessor::process (const db::PolygonWithProperties &poly, std::vector<db::EdgeWithProperties> &result) const
{
if (m_mode == All) {
@ -322,15 +274,6 @@ void PolygonToEdgeProcessor::process (const db::PolygonWithProperties &poly, std
// -----------------------------------------------------------------------------------
// ConvexDecomposition implementation
void ConvexDecomposition::process (const db::Polygon &poly, std::vector<db::Polygon> &result) const
{
db::SimplePolygonContainer sp;
db::decompose_convex (poly, m_mode, sp);
for (std::vector <db::SimplePolygon>::const_iterator i = sp.polygons ().begin (); i != sp.polygons ().end (); ++i) {
result.push_back (db::simple_polygon_to_polygon (*i));
}
}
void ConvexDecomposition::process (const db::PolygonWithProperties &poly, std::vector<db::PolygonWithProperties> &result) const
{
db::SimplePolygonContainer sp;
@ -343,15 +286,6 @@ void ConvexDecomposition::process (const db::PolygonWithProperties &poly, std::v
// -----------------------------------------------------------------------------------
// TrapezoidDecomposition implementation
void TrapezoidDecomposition::process (const db::Polygon &poly, std::vector<db::Polygon> &result) const
{
db::SimplePolygonContainer sp;
db::decompose_trapezoids (poly, m_mode, sp);
for (std::vector <db::SimplePolygon>::const_iterator i = sp.polygons ().begin (); i != sp.polygons ().end (); ++i) {
result.push_back (db::simple_polygon_to_polygon (*i));
}
}
void TrapezoidDecomposition::process (const db::PolygonWithProperties &poly, std::vector<db::PolygonWithProperties> &result) const
{
db::SimplePolygonContainer sp;
@ -364,21 +298,6 @@ void TrapezoidDecomposition::process (const db::PolygonWithProperties &poly, std
// -----------------------------------------------------------------------------------
// PolygonBreaker implementation
void PolygonBreaker::process (const db::Polygon &poly, std::vector<db::Polygon> &result) const
{
if (db::suggest_split_polygon (poly, m_max_vertex_count, m_max_area_ratio)) {
std::vector<db::Polygon> split_polygons;
db::split_polygon (poly, split_polygons);
for (std::vector<db::Polygon>::const_iterator p = split_polygons.begin (); p != split_polygons.end (); ++p) {
process (*p, result);
}
} else {
result.push_back (poly);
}
}
void PolygonBreaker::process (const db::PolygonWithProperties &poly, std::vector<db::PolygonWithProperties> &result) const
{
if (db::suggest_split_polygon (poly, m_max_vertex_count, m_max_area_ratio)) {
@ -412,14 +331,6 @@ PolygonSizer::~PolygonSizer ()
delete m_vars;
}
void PolygonSizer::process (const db::Polygon &poly, std::vector<db::Polygon> &result) const
{
db::PolygonContainer pr (result);
db::PolygonGenerator pg2 (pr, false /*don't resolve holes*/, true /*min. coherence*/);
db::SizingPolygonFilter siz (pg2, m_dx, m_dy, m_mode);
siz.put (poly);
}
void PolygonSizer::process (const db::PolygonWithProperties &poly, std::vector<db::PolygonWithProperties> &result) const
{
db::PolygonContainerWithProperties pr (result, poly.properties_id ());
@ -447,27 +358,6 @@ TriangulationProcessor::TriangulationProcessor (double max_area, double min_b)
m_param.min_b = min_b;
}
void
TriangulationProcessor::process (const db::Polygon &poly, std::vector<db::Polygon> &result) const
{
// NOTE: we center the polygon for better numerical stability
db::CplxTrans trans = db::CplxTrans (triangulation_dbu) * db::ICplxTrans (db::Trans (db::Point () - poly.box ().center ()));
db::plc::Graph tri;
db::plc::Triangulation (&tri).triangulate (poly, m_param, trans);
db::Point pts [3];
auto trans_inv = trans.inverted ();
for (auto t = tri.begin (); t != tri.end (); ++t) {
for (int i = 0; i < 3; ++i) {
pts [i] = trans_inv * *t->vertex (i);
}
result.push_back (db::Polygon ());
result.back ().assign_hull (pts + 0, pts + 3);
}
}
void
TriangulationProcessor::process (const db::PolygonWithProperties &poly, std::vector<db::PolygonWithProperties> &result) const
{
@ -600,13 +490,6 @@ DRCHullProcessor::process (const db::PolygonWithProperties &poly, std::vector<db
do_process (poly, psink);
}
void
DRCHullProcessor::process (const db::Polygon &poly, std::vector<db::Polygon> &result) const
{
db::PolygonContainer psink (result);
do_process (poly, psink);
}
void
DRCHullProcessor::do_process (const db::Polygon &poly, db::PolygonSink &psink) const
{

30
src/db/db/dbRegionProcessors.h
View File

@ -180,11 +180,6 @@ public:
// .. nothing yet ..
}
void process (const db::Polygon &poly, std::vector<db::Polygon> &result) const
{
detect_corners (poly, CornerRectDelivery (m_dim, result));
}
void process (const db::PolygonWithProperties &poly, std::vector<db::PolygonWithProperties> &result) const
{
detect_corners (poly, CornerRectDelivery (m_dim, result));
@ -214,11 +209,6 @@ public:
// .. nothing yet ..
}
void process (const db::Polygon &poly, std::vector<db::Edge> &result) const
{
detect_corners (poly, CornerDotDelivery (result));
}
void process (const db::PolygonWithProperties &poly, std::vector<db::EdgeWithProperties> &result) const
{
detect_corners (poly, CornerDotDelivery (result));
@ -244,11 +234,6 @@ public:
// .. nothing yet ..
}
void process (const db::Polygon &poly, std::vector<db::EdgePair> &result) const
{
detect_corners (poly, CornerEdgePairDelivery (result));
}
void process (const db::PolygonWithProperties &poly, std::vector<db::EdgePairWithProperties> &result) const
{
detect_corners (poly, CornerEdgePairDelivery (result));
@ -276,7 +261,6 @@ public:
// .. nothing yet ..
}
void process (const db::Polygon &poly, std::vector<db::Polygon> &result) const;
void process (const db::PolygonWithProperties &poly, std::vector<db::PolygonWithProperties> &result) const;
virtual const TransformationReducer *vars () const { return 0; }
@ -301,7 +285,6 @@ public:
// .. nothing yet ..
}
void process (const db::Polygon &poly, std::vector<db::Polygon> &result) const;
void process (const db::PolygonWithProperties &poly, std::vector<db::PolygonWithProperties> &result) const;
virtual const TransformationReducer *vars () const;
@ -334,7 +317,6 @@ public:
// .. nothing yet ..
}
void process (const db::Polygon &poly, std::vector<db::Edge> &result) const;
void process (const db::PolygonWithProperties &poly, std::vector<db::EdgeWithProperties> &result) const;
virtual const TransformationReducer *vars () const;
@ -361,7 +343,6 @@ public:
PolygonToEdgeProcessor (EdgeMode mode = All);
void process (const db::Polygon &poly, std::vector<db::Edge> &result) const;
void process (const db::PolygonWithProperties &poly, std::vector<db::EdgeWithProperties> &result) const;
private:
@ -381,7 +362,6 @@ public:
// .. nothing yet ..
}
void process (const db::Polygon &poly, std::vector<db::Polygon> &result) const;
void process (const db::PolygonWithProperties &poly, std::vector<db::PolygonWithProperties> &result) const;
virtual const TransformationReducer *vars () const { return &m_vars; }
@ -408,7 +388,6 @@ public:
// .. nothing yet ..
}
void process (const db::Polygon &poly, std::vector<db::Polygon> &result) const;
void process (const db::PolygonWithProperties &poly, std::vector<db::PolygonWithProperties> &result) const;
virtual const TransformationReducer *vars () const { return &m_vars; }
@ -438,7 +417,6 @@ public:
// .. nothing yet ..
}
void process (const db::Polygon &poly, std::vector<db::Polygon> &result) const;
void process (const db::PolygonWithProperties &poly, std::vector<db::PolygonWithProperties> &result) const;
virtual const TransformationReducer *vars () const { return 0; }
@ -464,7 +442,6 @@ public:
virtual const TransformationReducer *vars () const { return m_vars; }
void process (const db::Polygon &poly, std::vector<db::Polygon> &result) const;
void process (const db::PolygonWithProperties &poly, std::vector<db::PolygonWithProperties> &result) const;
virtual bool result_is_merged () const;
@ -487,7 +464,6 @@ class DB_PUBLIC TriangulationProcessor
public:
TriangulationProcessor (double max_area = 0.0, double min_b = 1.0);
void process (const db::Polygon &poly, std::vector<db::Polygon> &result) const;
void process (const db::PolygonWithProperties &poly, std::vector<db::PolygonWithProperties> &result) const;
virtual const TransformationReducer *vars () const { return &m_vars; }
@ -516,11 +492,6 @@ public:
// .. nothing yet ..
}
void process (const db::Polygon &poly, std::vector<db::Polygon> &result) const
{
result.push_back (db::minkowski_sum (poly, m_q, false));
}
void process (const db::PolygonWithProperties &poly, std::vector<db::PolygonWithProperties> &result) const
{
result.push_back (db::PolygonWithProperties (db::minkowski_sum (poly, m_q, false), poly.properties_id ()));
@ -547,7 +518,6 @@ class DB_PUBLIC_TEMPLATE DRCHullProcessor
public:
DRCHullProcessor (db::Coord d, db::metrics_type metrics, size_t n_circle = 64);
void process (const db::Polygon &poly, std::vector<db::Polygon> &result) const;
void process (const db::PolygonWithProperties &poly, std::vector<db::PolygonWithProperties> &result) const;
private:

58
src/db/db/dbRegionUtils.cc
View File

@ -354,23 +354,6 @@ SinglePolygonCheck::SinglePolygonCheck (db::edge_relation_type rel, db::Coord d,
: m_relation (rel), m_d (d), m_options (options)
{ }
void
SinglePolygonCheck::process (const db::Polygon &polygon, std::vector<db::EdgePair> &res) const
{
std::unordered_set<db::EdgePair> result;
EdgeRelationFilter check (m_relation, m_d, m_options);
edge2edge_check_negative_or_positive <std::unordered_set<db::EdgePair> > edge_check (check, result, m_options.negative, false /*=same polygons*/, false /*=same layers*/, m_options.shielded, true /*=symmetric*/);
poly2poly_check<db::Polygon> poly_check (edge_check);
do {
poly_check.single (polygon, 0);
} while (edge_check.prepare_next_pass ());
res.insert (res.end (), result.begin (), result.end ());
}
void
SinglePolygonCheck::process (const db::PolygonWithProperties &polygon, std::vector<db::EdgePairWithProperties> &res) const
{
@ -412,19 +395,6 @@ StrangePolygonCheckProcessor::StrangePolygonCheckProcessor () { }
StrangePolygonCheckProcessor::~StrangePolygonCheckProcessor () { }
void
StrangePolygonCheckProcessor::process (const db::Polygon &poly, std::vector<db::Polygon> &res) const
{
EdgeProcessor ep;
ep.insert (poly);
StrangePolygonInsideFunc inside;
db::GenericMerge<StrangePolygonInsideFunc> op (inside);
db::PolygonContainer pc (res, false);
db::PolygonGenerator pg (pc, false, false);
ep.process (pg, op);
}
void
StrangePolygonCheckProcessor::process (const db::PolygonWithProperties &poly, std::vector<db::PolygonWithProperties> &res) const
{
@ -445,12 +415,6 @@ SmoothingProcessor::SmoothingProcessor (db::Coord d, bool keep_hv) : m_d (d), m_
SmoothingProcessor::~SmoothingProcessor () { }
void
SmoothingProcessor::process (const db::Polygon &poly, std::vector<db::Polygon> &res) const
{
res.push_back (db::smooth (poly, m_d, m_keep_hv));
}
void
SmoothingProcessor::process (const db::PolygonWithProperties &poly, std::vector<db::PolygonWithProperties> &res) const
{
@ -467,12 +431,6 @@ RoundedCornersProcessor::RoundedCornersProcessor (double rinner, double router,
RoundedCornersProcessor::~RoundedCornersProcessor ()
{ }
void
RoundedCornersProcessor::process (const db::Polygon &poly, std::vector<db::Polygon> &res) const
{
res.push_back (db::compute_rounded (poly, m_rinner, m_router, m_n));
}
void
RoundedCornersProcessor::process (const db::PolygonWithProperties &poly, std::vector<db::PolygonWithProperties> &res) const
{
@ -490,15 +448,6 @@ HolesExtractionProcessor::~HolesExtractionProcessor ()
{
}
void
HolesExtractionProcessor::process (const db::Polygon &poly, std::vector<db::Polygon> &res) const
{
for (size_t i = 0; i < poly.holes (); ++i) {
res.push_back (db::Polygon ());
res.back ().assign_hull (poly.begin_hole ((unsigned int) i), poly.end_hole ((unsigned int) i));
}
}
void
HolesExtractionProcessor::process (const db::PolygonWithProperties &poly, std::vector<db::PolygonWithProperties> &res) const
{
@ -520,13 +469,6 @@ HullExtractionProcessor::~HullExtractionProcessor ()
{
}
void
HullExtractionProcessor::process (const db::Polygon &poly, std::vector<db::Polygon> &res) const
{
res.push_back (db::Polygon ());
res.back ().assign_hull (poly.begin_hull (), poly.end_hull ());
}
void
HullExtractionProcessor::process (const db::PolygonWithProperties &poly, std::vector<db::PolygonWithProperties> &res) const
{

6
src/db/db/dbRegionUtils.h
View File

@ -488,7 +488,6 @@ public:
StrangePolygonCheckProcessor ();
~StrangePolygonCheckProcessor ();
virtual void process (const db::Polygon &poly, std::vector<db::Polygon> &res) const;
virtual void process (const db::PolygonWithProperties &poly, std::vector<db::PolygonWithProperties> &res) const;
virtual const TransformationReducer *vars () const { return 0; }
@ -508,7 +507,6 @@ public:
SmoothingProcessor (db::Coord d, bool keep_hv);
~SmoothingProcessor ();
virtual void process (const db::Polygon &poly, std::vector<db::Polygon> &res) const;
virtual void process (const db::PolygonWithProperties &poly, std::vector<db::PolygonWithProperties> &res) const;
virtual const TransformationReducer *vars () const { return &m_vars; }
@ -533,7 +531,6 @@ public:
RoundedCornersProcessor (double rinner, double router, unsigned int n);
~RoundedCornersProcessor ();
virtual void process (const db::Polygon &poly, std::vector<db::Polygon> &res) const;
virtual void process (const db::PolygonWithProperties &poly, std::vector<db::PolygonWithProperties> &res) const;
virtual const TransformationReducer *vars () const { return &m_vars; }
@ -558,7 +555,6 @@ public:
HolesExtractionProcessor ();
~HolesExtractionProcessor ();
virtual void process (const db::Polygon &poly, std::vector<db::Polygon> &res) const;
virtual void process (const db::PolygonWithProperties &poly, std::vector<db::PolygonWithProperties> &res) const;
virtual const TransformationReducer *vars () const { return 0; }
@ -578,7 +574,6 @@ public:
HullExtractionProcessor ();
~HullExtractionProcessor ();
virtual void process (const db::Polygon &poly, std::vector<db::Polygon> &res) const;
virtual void process (const db::PolygonWithProperties &poly, std::vector<db::PolygonWithProperties> &res) const;
virtual const TransformationReducer *vars () const { return 0; }
@ -597,7 +592,6 @@ class DB_PUBLIC SinglePolygonCheck
public:
SinglePolygonCheck (db::edge_relation_type rel, db::Coord d, const RegionCheckOptions &options);
virtual void process (const db::Polygon &polygon, std::vector<db::EdgePair> &res) const;
virtual void process (const db::PolygonWithProperties &polygon, std::vector<db::EdgePairWithProperties> &res) const;
virtual const TransformationReducer *vars () const { return &m_vars; }
virtual bool wants_variants () const { return true; }

42
src/db/db/dbShapeCollectionUtils.h
View File

@ -61,17 +61,10 @@ public:
*/
virtual ~shape_collection_processor () { }
/**
* @brief Performs the actual processing
* This method will take the input edge from "edge" and puts the results into "res".
* "res" can be empty - in this case, the edge will be skipped.
*/
virtual void process (const Shape &shape, std::vector<Result> &res) const = 0;
/**
* @brief Performs the actual processing with properties
* This method will take the input edge from "edge" and puts the results into "res".
* "res" can be empty - in this case, the edge will be skipped.
* This method will take the input edge from "shape" and puts the results into "res".
* "res" can be empty - in this case, the shape will be skipped.
*/
virtual void process (const db::object_with_properties<Shape> &shape, std::vector<db::object_with_properties<Result> > &res) const = 0;
@ -194,7 +187,7 @@ shape_collection_processed_impl (const db::DeepLayer &input, const shape_collect
}
std::vector<Result> heap;
std::vector<db::object_with_properties<Result> > heap;
std::map<db::cell_index_type, std::map<db::ICplxTrans, db::Shapes> > to_commit;
std::unique_ptr<OutputContainer> res (new OutputContainer (input.derived ()));
@ -225,16 +218,17 @@ shape_collection_processed_impl (const db::DeepLayer &input, const shape_collect
db::ICplxTrans trinv = tr.inverted ();
for (db::Shapes::shape_iterator si = s.begin (db::ShapeIterator::All); ! si.at_end (); ++si) {
Shape s;
db::object_with_properties<Shape> s;
si->instantiate (s);
s.properties_id (si->prop_id ());
s.transform (tr);
heap.clear ();
filter.process (s, heap);
for (typename std::vector<Result>::const_iterator i = heap.begin (); i != heap.end (); ++i) {
if (si->prop_id ()) {
delivery_wp.put (db::object_with_properties<Result> (i->transformed (trinv), si->prop_id ()));
for (auto i = heap.begin (); i != heap.end (); ++i) {
if (i->properties_id ()) {
delivery_wp.put (db::object_with_properties<Result> (i->transformed (trinv), i->properties_id ()));
} else {
delivery.put (i->transformed (trinv));
delivery.put (i->base ().transformed (trinv));
}
}
}
@ -248,15 +242,16 @@ shape_collection_processed_impl (const db::DeepLayer &input, const shape_collect
shape_collection_processor_delivery<db::object_with_properties<Result> > delivery_wp (&layout, &st);
for (db::Shapes::shape_iterator si = s.begin (db::ShapeIterator::All); ! si.at_end (); ++si) {
Shape s;
db::object_with_properties<Shape> s;
si->instantiate (s);
s.properties_id (si->prop_id ());
heap.clear ();
filter.process (s, heap);
for (typename std::vector<Result>::const_iterator i = heap.begin (); i != heap.end (); ++i) {
for (auto i = heap.begin (); i != heap.end (); ++i) {
if (si->prop_id ()) {
delivery_wp.put (db::object_with_properties<Result> (*i, si->prop_id ()));
delivery_wp.put (*i);
} else {
delivery.put (*i);
delivery.put (i->base ());
}
}
}
@ -287,15 +282,6 @@ public:
: m_dx (dx), m_dy (dy)
{ }
virtual void process (const Shape &s, std::vector<db::Polygon> &res) const
{
db::box_convert<Shape> bc;
db::Box box = bc (s).enlarged (db::Vector (m_dx, m_dy));
if (! box.empty ()) {
res.push_back (db::Polygon (box));
}
}
virtual void process (const db::object_with_properties<Shape> &s, std::vector<db::PolygonWithProperties> &res) const
{
db::box_convert<db::object_with_properties<Shape> > bc;

4
src/db/unit_tests/dbRegionProcessorTests.cc
View File

@ -48,11 +48,11 @@ TEST(1_RegionToEdgesProcessor)
db::Point (100, 900)
};
db::Polygon poly;
db::PolygonWithProperties poly;
poly.assign_hull (hull + 0, hull + sizeof (hull) / sizeof (hull[0]));
poly.insert_hole (hole + 0, hole + sizeof (hole) / sizeof (hole[0]));
std::vector<db::Edge> result;
std::vector<db::EdgeWithProperties> result;
result.clear ();
db::PolygonToEdgeProcessor ().process (poly, result);