Merge branch 'master' into v0.6.0

# Conflicts: # src/ifcconvert/IfcConvert.cpp # src/ifcgeom/IfcGeomFilter.h # src/ifcgeom/IfcGeomIteratorImplementation.h # src/ifcgeom/IfcGeomWires.cpp # src/ifcparse/IfcFile.h # src/ifcparse/IfcLogger.cpp # src/ifcparse/IfcLogger.h # src/ifcparse/IfcParse.cpp # src/serializers/SvgSerializer.cpp # src/serializers/schema_dependent/XmlSerializer.cpp
2026-08-29 00:03:17 +00:00 · 2018-07-07 17:15:54 +02:00
parent 5aebfe9f22 6fdd2049a2
commit d105292817
33 changed files with 3564 additions and 335 deletions
@@ -85,11 +85,169 @@

 #include <Geom_BSplineCurve.hxx>
 #include <BRepTools_WireExplorer.hxx>
+#include <ShapeBuild_ReShape.hxx>
+#include <TopTools_ListOfShape.hxx>
+#include <TopTools_ListIteratorOfListOfShape.hxx>

 #include "../ifcgeom/IfcGeom.h"

 #define Kernel MAKE_TYPE_NAME(Kernel)

+namespace {
+	// Returns the other vertex of an edge
+	TopoDS_Vertex other(const TopoDS_Edge& e, const TopoDS_Vertex& v) {
+		TopoDS_Vertex a, b;
+		TopExp::Vertices(e, a, b);
+		return v.IsSame(b) ? a : b;
+	}
+
+	TopoDS_Edge first_edge(const TopoDS_Wire& w) {
+		TopoDS_Vertex v1, v2;
+		TopExp::Vertices(w, v1, v2);
+		TopTools_IndexedDataMapOfShapeListOfShape wm;
+		TopExp::MapShapesAndAncestors(w, TopAbs_VERTEX, TopAbs_EDGE, wm);
+		return TopoDS::Edge(wm.FindFromKey(v1).First());
+	}
+
+	// Returns new wire with the edge replaced by a linear edge with the vertex v moved to p
+	TopoDS_Wire adjust(const TopoDS_Wire& w, const TopoDS_Vertex& v, const gp_Pnt& p) {
+		BRep_Builder b;
+		TopoDS_Vertex v2;
+		b.MakeVertex(v2, p, BRep_Tool::Tolerance(v));
+
+		ShapeBuild_ReShape reshape;
+		reshape.Replace(v.Oriented(TopAbs_FORWARD), v2);
+
+		return TopoDS::Wire(reshape.Apply(w));
+	}
+
+	// A wrapper around BRepBuilderAPI_MakeWire that makes sure segments are connected either by moving end points or by adding intermediate segments
+	class wire_builder {
+	private:
+		BRepBuilderAPI_MakeWire mw_;
+		double p_;
+		bool override_next_;
+		gp_Pnt next_override_;
+		const IfcUtil::IfcBaseClass* inst_;
+
+	public:
+		wire_builder(double p, const IfcUtil::IfcBaseClass* inst = 0) : p_(p), override_next_(false), inst_(inst) {}
+
+		void operator()(const TopoDS_Shape& a) {
+			const TopoDS_Wire& w = TopoDS::Wire(a);
+			if (override_next_) {
+				override_next_ = false;
+				TopoDS_Edge e = first_edge(w);
+				mw_.Add(adjust(w, TopExp::FirstVertex(e, true), next_override_));
+			} else {
+				mw_.Add(w);
+			}			
+		}
+
+		void operator()(const TopoDS_Shape& a, const TopoDS_Shape& b, bool last) {
+			TopoDS_Wire w1 = TopoDS::Wire(a);
+			const TopoDS_Wire& w2 = TopoDS::Wire(b);
+
+			if (override_next_) {
+				override_next_ = false;
+				TopoDS_Edge e = first_edge(w1);
+				w1 = adjust(w1, TopExp::FirstVertex(e, true), next_override_);
+			}
+
+			TopoDS_Vertex w11, w12, w21, w22;
+			TopExp::Vertices(w1, w11, w12);
+			TopExp::Vertices(w2, w21, w22);
+
+			gp_Pnt p1 = BRep_Tool::Pnt(w12);
+			gp_Pnt p2 = BRep_Tool::Pnt(w21);
+
+			double dist = p1.Distance(p2);
+
+			// Distance is within 2p, this is fine
+			if (dist < p_) {
+				mw_.Add(w1);
+				goto check;
+			}
+
+			// Distance is too large for attempting to move end points, add intermediate edge
+			if (dist > 1000. * p_) {
+				mw_.Add(w1);
+				mw_.Add(BRepBuilderAPI_MakeEdge(p1, p2));
+				Logger::Message(Logger::LOG_ERROR, "Added additional segment to close gap with length " + boost::lexical_cast<std::string>(dist) + " to:", inst_);
+				goto check;
+			}
+
+			{
+				TopTools_IndexedDataMapOfShapeListOfShape wmap1, wmap2;
+
+				// Find edges connected to end- and begin vertex
+				TopExp::MapShapesAndAncestors(w1, TopAbs_VERTEX, TopAbs_EDGE, wmap1);
+				TopExp::MapShapesAndAncestors(w2, TopAbs_VERTEX, TopAbs_EDGE, wmap2);
+
+				const TopTools_ListOfShape& last_edges = wmap1.FindFromKey(w12);
+				const TopTools_ListOfShape& first_edges = wmap2.FindFromKey(w21);
+
+				double _, __;
+				if (last_edges.Extent() == 1 && first_edges.Extent() == 1) {
+					Handle(Geom_Curve) c1 = BRep_Tool::Curve(TopoDS::Edge(last_edges.First()), _, __);
+					Handle(Geom_Curve) c2 = BRep_Tool::Curve(TopoDS::Edge(first_edges.First()), _, __);
+
+					const bool is_line1 = c1->DynamicType() == STANDARD_TYPE(Geom_Line);
+					const bool is_line2 = c2->DynamicType() == STANDARD_TYPE(Geom_Line);
+
+					// Adjust the segment that is linear
+					if (is_line1) {
+						mw_.Add(adjust(w1, w12, p2));
+						Logger::Message(Logger::LOG_ERROR, "Adjusted edge end-point with distance " + boost::lexical_cast<std::string>(dist) + " on:", inst_);
+					} else if (is_line2 && !last) {
+						mw_.Add(w1);
+						override_next_ = true;
+						next_override_ = p1;
+						Logger::Message(Logger::LOG_ERROR, "Adjusted edge end-point with distance " + boost::lexical_cast<std::string>(dist) + " on:", inst_);
+					} else {
+						// If both aren't linear an edge is added
+						mw_.Add(w1);
+						mw_.Add(BRepBuilderAPI_MakeEdge(p1, p2));
+						Logger::Message(Logger::LOG_ERROR, "Added additional segment to close gap with length " + boost::lexical_cast<std::string>(dist) + " to:", inst_);
+					}
+				} else {
+					Logger::Error("Internal error, inconsistent wire segments", inst_);
+					mw_.Add(w1);
+				}
+			}
+
+		check:
+			if (mw_.Error() == BRepBuilderAPI_NonManifoldWire) {
+				Logger::Error("Non-manifold curve segments:", inst_);
+			} else if (mw_.Error() == BRepBuilderAPI_DisconnectedWire) {
+				Logger::Error("Failed to join curve segments:", inst_);
+			}
+		}
+
+		const TopoDS_Wire& wire() { return mw_.Wire(); }
+	};
+
+	template <typename Fn>
+	void shape_pair_enumerate(TopTools_ListIteratorOfListOfShape& it, Fn& fn, bool closed) {
+		bool is_first = true;
+		TopoDS_Shape first, previous, current;
+		for (; it.More(); it.Next(), is_first = false) {
+			current = it.Value();
+			if (is_first) {
+				first = current;
+			} else {
+				fn(previous, current, false);
+			}
+			previous = current;
+		}
+		if (closed) {
+			fn(current, first, true);
+		} else {
+			fn(current);
+		}
+	}
+}
+
 bool IfcGeom::Kernel::convert(const IfcSchema::IfcCompositeCurve* l, TopoDS_Wire& wire) {
 	if ( getValue(GV_PLANEANGLE_UNIT)<0 ) {
 		Logger::Message(Logger::LOG_WARNING,"Creating a composite curve without unit information:",l);
@@ -167,105 +325,45 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcCompositeCurve* l, TopoDS_Wire
 		return use_radians || use_degrees;
 	}

-	BRepBuilderAPI_MakeWire w;
-	TopoDS_Vertex wire_first_vertex, wire_last_vertex, edge_first_vertex, edge_last_vertex;
+	
 	IfcSchema::IfcCompositeCurveSegment::list::ptr segments = l->Segments();

-	const double precision_sq_2 = 2 * getValue(GV_PRECISION) * getValue(GV_PRECISION);
+	TopTools_ListOfShape converted_segments;
 	
-	for(IfcSchema::IfcCompositeCurveSegment::list::it it = segments->begin(); it != segments->end(); ++it) {
-		
+	for (IfcSchema::IfcCompositeCurveSegment::list::it it = segments->begin(); it != segments->end(); ++it) {
+
 		IfcSchema::IfcCurve* curve = (*it)->ParentCurve();
 		TopoDS_Wire segment;
-		
+
 		if (!convert_wire(curve, segment)) {
 			Logger::Message(Logger::LOG_ERROR, "Failed to convert curve:", curve);
 			continue;
 		}
-		
+
 		if (!(*it)->SameSense()) {
 			segment.Reverse();
 		}
-		
+
 		ShapeFix_ShapeTolerance FTol;
 		FTol.SetTolerance(segment, getValue(GV_PRECISION), TopAbs_WIRE);
-		
-		TopExp::Vertices(segment, edge_first_vertex, edge_last_vertex);

-		if (it == segments->begin()) {
-			wire_first_vertex = edge_first_vertex;
-		} else {
-			gp_Pnt first = BRep_Tool::Pnt(edge_first_vertex);
-			gp_Pnt last = BRep_Tool::Pnt(wire_last_vertex);
+		converted_segments.Append(segment);

-			Standard_Real distance = first.SquareDistance(last);
-			if (distance > precision_sq_2) {
-				w.Add(BRepBuilderAPI_MakeEdge(wire_last_vertex, edge_first_vertex));
-
-				Logger::Message(Logger::LOG_ERROR, "Closed gap on:", l);
-			}
-		}
-
-		w.Add(segment);
-
-		if ( w.Error() != BRepBuilderAPI_WireDone ) {
-			if (w.Error() == BRepBuilderAPI_NonManifoldWire) {
-
-				Logger::Message(Logger::LOG_ERROR, "Non-manifold curve segments:", l);
-
-			} else if (w.Error() == BRepBuilderAPI_DisconnectedWire) {
-
-				Logger::Message(Logger::LOG_ERROR, "Failed to join curve segments:", l);
-
-				gp_Pnt p1, p2;
-				int precision = 4;
-				double d = 0.;
-				
-				if (!wire_last_vertex.IsNull()) {
-					p1 = BRep_Tool::Pnt(wire_last_vertex);
-				}
-				if (!edge_first_vertex.IsNull()) {
-					p2 = BRep_Tool::Pnt(edge_first_vertex);
-				}
-				if (!wire_last_vertex.IsNull() && !edge_first_vertex.IsNull()) {
-					d = p1.Distance(p2);
-					precision = ceil(-log10(d)) + 3;
-				}
-
-				if (!wire_last_vertex.IsNull()) {
-					std::stringstream ss;
-					ss << std::setprecision(precision) << "Last vertex at (" << p1.X() << " " << p1.Y() << " " << p1.Z() << ")";
-					Logger::Message(Logger::LOG_NOTICE, ss.str());
-				}
-
-				if (!edge_first_vertex.IsNull()) {
-					std::stringstream ss;
-					ss << std::setprecision(precision) << "Segment starts at (" << p2.X() << " " << p2.Y() << " " << p2.Z() << ")";
-					if (d > 0.) {
-						ss << ", distance " << d << " > precision " << std::fixed << getValue(GV_PRECISION) / 10.;
-					}
-					ss << " for:";
-					Logger::Message(Logger::LOG_NOTICE, ss.str(), (*it));
-				}
-			}
-			
-			return false;
-		}
-
-		wire_last_vertex = edge_last_vertex;
 	}

-	gp_Pnt first = BRep_Tool::Pnt(edge_last_vertex);
-	gp_Pnt last = BRep_Tool::Pnt(wire_first_vertex);
+	BRepBuilderAPI_MakeWire w;
+	TopoDS_Vertex wire_first_vertex, wire_last_vertex, edge_first_vertex, edge_last_vertex;

-	Standard_Real distance = first.SquareDistance(last);
-	if (distance > precision_sq_2) {
-		w.Add(BRepBuilderAPI_MakeEdge(edge_last_vertex, wire_first_vertex));
+	const double precision_sq_2 = 2 * getValue(GV_PRECISION) * getValue(GV_PRECISION);

-		Logger::Message(Logger::LOG_ERROR, "Closed gap on:", l);
-	}
+	TopTools_ListIteratorOfListOfShape it(converted_segments);

-	wire = w.Wire();
+	IfcEntityList::ptr profile = l->data().getInverse(&IfcSchema::IfcProfileDef::Class(), -1);
+	const bool force_close = profile && profile->size() > 0;
+
+	wire_builder bld(getValue(GV_PRECISION), l);
+	shape_pair_enumerate(it, bld, force_close);
+	wire = bld.wire();

 	return true;
 }
@@ -395,14 +493,25 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcPolyline* l, TopoDS_Wire& resu
 		polygon.Append(pnt);
 	}

+	const double eps = getValue(GV_PRECISION) * 10;
+	const bool closed_by_proximity = polygon.Length() >= 2 && polygon.First().Distance(polygon.Last()) < eps;
+	if (closed_by_proximity) {
+		// tfk: note 1-based
+		polygon.Remove(polygon.Length());
+	}
+
 	// Remove points that are too close to one another
-	remove_duplicate_points_from_loop(polygon, false);
+	remove_duplicate_points_from_loop(polygon, closed_by_proximity, eps);
 	
 	BRepBuilderAPI_MakePolygon w;
 	for (int i = 1; i <= polygon.Length(); ++i) {
 		w.Add(polygon.Value(i));
 	}

+	if (closed_by_proximity) {
+		w.Close();
+	}
+
 	result = w.Wire();
 	return true;
 }
@@ -426,7 +535,8 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcPolyLoop* l, TopoDS_Wire& resu
 	}

 	// Remove points that are too close to one another
-	remove_duplicate_points_from_loop(polygon, true);
+	const double eps = getValue(GV_PRECISION) * 10;
+	remove_duplicate_points_from_loop(polygon, true, eps);

 	int count = polygon.Length();
 	if (original_count - count != 0) {
@@ -445,7 +555,14 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcPolyLoop* l, TopoDS_Wire& resu
 	}
 	w.Close();

-	result = w.Wire();	
+	result = w.Wire();
+
+	TopTools_ListOfShape results;
+	if (wire_intersections(result, results)) {
+		Logger::Error("Self-intersections with " + boost::lexical_cast<std::string>(results.Extent()) + " cycles detected", l);
+		select_largest(results, result);
+	}
+
 	return true;
 }