fix bug in spline computation

Author: ifcapps

IfcPlusPlus/src/ifcpp/geometry/CurveConverter.h

@@ -220,9 +220,7 @@ class CurveConverter : public StatusCallback
 			if( bspline_curve )
 			{
 				m_spline_converter->convertBSplineCurve(bspline_curve, target_vec, segment_start_points);
-
 				// TODO: handle trim points
-
 				return;
 			}
 
@@ -844,7 +842,7 @@ class CurveConverter : public StatusCallback
 		bool p1_success = PointConverter::convertIfcVertex(edge_end, p1, length_factor);
 
 
-		//std::cout << "IfcEdgeLoop: IfcPointOnCurve, IfcPointOnSurface not implemented" << std::endl;
+		
 
 		bool simpleStraightEdge = false;
 		if( simpleStraightEdge )
@@ -854,14 +852,9 @@ class CurveConverter : public StatusCallback
 			return;
 		}
 
-
-		// TODO: try use EdgeStart and EdgeEnd as trimming points
-
 		const shared_ptr<IfcOrientedEdge> orientedEdge = dynamic_pointer_cast<IfcOrientedEdge>(edge);
 		if( orientedEdge )
 		{
-			//#3517327= IFCORIENTEDEDGE(*,*,#3517018,.T.);
-
 			//shared_ptr<IfcEdge>										m_EdgeElement;
 			//shared_ptr<IfcBoolean>									m_Orientation;
 			bool orientedEdgeOrientation = orientedEdge->m_Orientation->m_value;
@@ -878,8 +871,6 @@ class CurveConverter : public StatusCallback
 		const shared_ptr<IfcSubedge> subEdge = dynamic_pointer_cast<IfcSubedge>(edge);
 		if( subEdge )
 		{
-			//shared_ptr<IfcEdge>										m_ParentEdge;
-			
 			if( subEdge->m_ParentEdge )
 			{
 				std::vector<vec3> loopPointsParentEdge;
@@ -889,7 +880,6 @@ class CurveConverter : public StatusCallback
 			}
 		}
 
-
 		const shared_ptr<IfcEdgeCurve> edgeCurve = dynamic_pointer_cast<IfcEdgeCurve>(edge);
 		if( edgeCurve )
 		{
@@ -901,11 +891,6 @@ class CurveConverter : public StatusCallback
 				edgeSameSense = edgeCurve->m_SameSense->m_value;
 			}
 
-			//#3517014= IFCBSPLINECURVEWITHKNOTS(3,(#3517000,#3517000,#3517006,#3517008,#3517010,#3517012,#3517003),.UNSPECIFIED.,.F.,.U.,(4,1,1,1,4),(0.,0.166666666666667,0.333333333333333,0.666666666666667,1.),.UNSPECIFIED.);
-			//#3517018= IFCEDGECURVE(#3517002,#3517005,#3517014,.T.);
-			//#3517327= IFCORIENTEDEDGE(*,*,#3517018,.T.);
-			//#3517329= IFCEDGELOOP((#3517326,#3517327,#3517328));
-			
 			if( !edgeSameSense )
 			{
 				vec3 temp = p0;
@@ -915,12 +900,12 @@ class CurveConverter : public StatusCallback
 
 			std::vector<vec3> curvePoints;
 			std::vector<vec3> segmentStartPoints;
-			const shared_ptr<IfcCurve> edgeCurveCurve = edgeCurve->m_EdgeGeometry;
+			const shared_ptr<IfcCurve> edgeCurveGeometry = edgeCurve->m_EdgeGeometry;
 			bool senseAgreement = true;
 
-			if( edgeCurveCurve )
+			if( edgeCurveGeometry )
 			{
-				shared_ptr<IfcTrimmedCurve> trimmedCurve = dynamic_pointer_cast<IfcTrimmedCurve>(edgeCurveCurve);
+				shared_ptr<IfcTrimmedCurve> trimmedCurve = dynamic_pointer_cast<IfcTrimmedCurve>(edgeCurveGeometry);
 				if( trimmedCurve )
 				{
 					const shared_ptr<IfcCurve> basisCurve = trimmedCurve->m_BasisCurve;
@@ -931,15 +916,15 @@ class CurveConverter : public StatusCallback
 						std::vector<shared_ptr<IfcTrimmingSelect> > curve_trim2_vec;
 
 						shared_ptr<IfcCartesianPoint> trim1(new IfcCartesianPoint());
-						trim1->m_Coordinates[0] = p0.x;
-						trim1->m_Coordinates[1] = p0.y;
-						trim1->m_Coordinates[2] = p0.z;
+						trim1->m_Coordinates[0] = p0.x / length_factor;  // in convertIfcCurve, the trim point will be multiplied with length_factor
+						trim1->m_Coordinates[1] = p0.y / length_factor;
+						trim1->m_Coordinates[2] = p0.z / length_factor;
 						curve_trim1_vec.push_back(trim1);
 
 						shared_ptr<IfcCartesianPoint> trim2(new IfcCartesianPoint());
-						trim2->m_Coordinates[0] = p1.x;
-						trim2->m_Coordinates[1] = p1.y;
-						trim2->m_Coordinates[2] = p1.z;
+						trim2->m_Coordinates[0] = p1.x / length_factor;
+						trim2->m_Coordinates[1] = p1.y / length_factor;
+						trim2->m_Coordinates[2] = p1.z / length_factor;
 						curve_trim2_vec.push_back(trim2);
 						convertIfcCurve(basisCurve, curvePoints, segmentStartPoints, curve_trim1_vec, curve_trim2_vec, senseAgreement);
 					}
@@ -948,7 +933,7 @@ class CurveConverter : public StatusCallback
 				{
 					std::vector<shared_ptr<IfcTrimmingSelect> > curve_trim1_vec;
 					std::vector<shared_ptr<IfcTrimmingSelect> > curve_trim2_vec;
-					convertIfcCurve(edgeCurveCurve, curvePoints, segmentStartPoints, curve_trim1_vec, curve_trim2_vec, senseAgreement);
+					convertIfcCurve(edgeCurveGeometry, curvePoints, segmentStartPoints, curve_trim1_vec, curve_trim2_vec, senseAgreement);
 				}
 			}
 			else
@@ -977,7 +962,7 @@ class CurveConverter : public StatusCallback
 				glm::vec4 color(0.5, 0.5, 0.5, 1);
 				if( dist0 > EPS_M6 || dist1 > EPS_M6 )
 				{
-					GeomDebugDump::dumpPolyline(curvePoints, color, false);
+					//GeomDebugDump::dumpPolyline(curvePoints, color, false);
 				}
 
 				if( dist0 > EPS_M6 )
@@ -986,7 +971,7 @@ class CurveConverter : public StatusCallback
 					//std::cout << std::endl << "check EdgeStart IfcEdgeCurve, dist0 = " << dist0  << ", tag: " << tag << std::endl;
 
 					std::vector<vec3> segmentStartEndPoints = { p0, p1 };
-					GeomDebugDump::dumpPolyline(segmentStartEndPoints, color, true);
+					//GeomDebugDump::dumpPolyline(segmentStartEndPoints, color, true);
 				}
 
 				if( false )
@@ -1098,22 +1083,18 @@ class CurveConverter : public StatusCallback
 
 			for( const shared_ptr<IfcOrientedEdge>& oriented_edge : edge_loop->m_EdgeList )
 			{
-				//  shared_ptr<IfcVertex>									m_EdgeStart;
-				//  shared_ptr<IfcVertex>									m_EdgeEnd;
-
 				// IfcOrientedEdge -----------------------------------------------------------
 				// attributes:
 				//shared_ptr<IfcEdge>										m_EdgeElement;
 				//shared_ptr<IfcBoolean>									m_Orientation;
 
-				shared_ptr<IfcEdge> edge = oriented_edge->m_EdgeElement;
-
 				bool orientation = true;
 				if( oriented_edge->m_Orientation )
 				{
 					orientation = oriented_edge->m_Orientation->m_value;
 				}
 
+				shared_ptr<IfcEdge> edge = oriented_edge->m_EdgeElement;
 				std::vector<vec3> edge_points;
 				convertIfcEdge(edge, edge_points, length_factor);
 
@@ -1125,6 +1106,11 @@ class CurveConverter : public StatusCallback
 				{
 					std::copy(edge_points.rbegin(), edge_points.rend(), std::back_inserter(loop_points));
 				}
+
+#ifdef _DEBUG
+				//glm::vec4 color(0.5, 0.5, 0.5, 1);
+				//GeomDebugDump::dumpPolyline(loop_points, color, false);
+#endif
 			}
 
 			GeomUtils::removeDuplicates(loop_points);

IfcPlusPlus/src/ifcpp/geometry/FaceConverter.h

@@ -348,7 +348,7 @@ class FaceConverter : public StatusCallback
 			if( advancedFace )
 			{
 				int tag = advancedFace->m_tag;
-				if( tag == 3518020 )
+				if( tag == 1261069 )
 				{
 					std::cout << "IfcAdvancedFace, tag=" << tag << std::endl;
 				}
@@ -420,9 +420,9 @@ class FaceConverter : public StatusCallback
 			MeshUtils::createTriangulated3DFace( face_loops, poly_cache, params );
 
 #ifdef _DEBUG
-			if( ifc_face->m_tag == 46832 )
+			if( ifc_face->m_tag == 1261069 )
 			{
-				params.debugDump = true;
+				//params.debugDump = true;
 			}
 
 			//if( ifc_face->m_tag == 2529 )
@@ -439,7 +439,7 @@ class FaceConverter : public StatusCallback
 					GeomDebugDump::dumpPolyline(loop, color, false);
 				}
 
-				if( ii == 34 )
+				//if( ii == 34 )
 				{
 					PolyInputCache3D poly_cache_dump(CARVE_EPSILON);
 					MeshUtils::createTriangulated3DFace(face_loops, poly_cache_dump, params);

IfcPlusPlus/src/ifcpp/geometry/GeometryConverter.h

@@ -62,8 +62,10 @@ class GeometryConverter : public StatusCallback
 	vec3 m_siteOffset;
 	double m_recent_progress = 0;
 	std::map<int, std::vector<shared_ptr<StatusCallback::Message> > > m_messages;
+
 #ifdef _OPENMP
 	Mutex m_writelock_messages;
+	Mutex m_writelock_item_cache;
 #endif
 
 public:
@@ -92,7 +94,11 @@ class GeometryConverter : public StatusCallback
 		m_ifc_model->setMessageTarget( this );
 		m_representation_converter->setMessageTarget( this );
 	}
-	virtual ~GeometryConverter() {}
+	virtual ~GeometryConverter()
+	{
+		m_callback_object_geometry_converted = nullptr;
+		m_callback_func_geometry_converted = nullptr;
+	}
 
 	void setGeometryCallbackFunction( void* obj_ptr, void (*func)(void*, shared_ptr<ProductShapeData> t) )
 	{
@@ -798,8 +804,7 @@ class GeometryConverter : public StatusCallback
 						if( m_callback_object_geometry_converted )
 						{
 #ifdef _OPENMP
-							// Note: this lock protects accesses only for this instance. If several StatusCallback (or derived) objects are bound to the same callback function, a lock is necessary there.
-							ScopedLock lock( m_writelock );
+							//ScopedLock lock( m_writelock_geom_callback );
 #endif
 							m_callback_func_geometry_converted( m_callback_object_geometry_converted, product_geom_input_data );
 						}
@@ -808,7 +813,7 @@ class GeometryConverter : public StatusCallback
 
 				// progress callback
 				double progress = (double)i / (double)num_object_definitions;
-				if( progress - m_recent_progress > 0.02 )
+				if( progress - m_recent_progress > 0.01 )
 				{
 
 #ifdef _OPENMP
@@ -1056,9 +1061,47 @@ class GeometryConverter : public StatusCallback
 				}
 			}
 		}
+
+		// check for existing meshes
+		// TODO: make sure that the meshes are not changed after here, for example with boolean operations
+		bool enableCaching = false;
+		if( enableCaching )
+		{
+			bool equalItemFound = false;
+			
+			for( auto it : m_product_shape_data )
+			{
+				const shared_ptr<ProductShapeData>& existingProductShape = it.second;
+				if( !existingProductShape )
+				{
+					continue;
+				}
+				for( auto rep : existingProductShape->m_vec_representations )
+				{
+					for( auto item : rep->m_vec_item_data )
+					{
+						//bool itemIsEqual = isEqual(item, geom_item_data);
+						//if( itemIsEqual )
+						{
+							//representation_data->m_vec_item_data.push_back(existingItem);
+							equalItemFound = true;
+						}
+					}
+				}
+			}
+			if( !equalItemFound )
+			{
+//				representation_data->m_vec_item_data.push_back(geom_item_data);
+//#ifdef _OPENMP
+//				ScopedLock lock( m_writelock_item_cache );
+//#endif
+//				m_map_item_data_cache.push_back(geom_item_data);
+			}
+		}
+		
 		if( m_clear_memory_immedeately )
 		{
-			vec_representations.clear();
+			ifc_product->m_Representation.reset();
 		}
 	}
 

IfcPlusPlus/src/ifcpp/geometry/GeometryInputData.h

@@ -681,6 +681,7 @@ class ItemShapeData
 	weak_ptr<RepresentationData>							m_parent_representation;  // Pointer to representation object that this item belongs to
 	shared_ptr<IFC4X3::IfcRepresentationItem>				m_ifc_item;
 	std::vector<shared_ptr<carve::input::VertexData> >	m_vertex_points;
+	std::set<int> m_usedInRepresentations;
 
 public:
 	bool isEmpty()
@@ -1588,7 +1589,72 @@ class ProductShapeData
 	}
 };
 
+inline bool isEqual(const shared_ptr<carve::mesh::MeshSet<3> >& existingMesh, const shared_ptr<carve::mesh::MeshSet<3> >& checkMesh)
+{
+	if( existingMesh->meshes.size() != checkMesh->meshes.size() ) { return false; }
+	if( existingMesh->vertex_storage.size() != checkMesh->vertex_storage.size() ) { return false; }
+
+	for( size_t ii = 0; ii < existingMesh->meshes.size(); ++ii )
+	{
+		const carve::mesh::Mesh<3>* mesh1 = existingMesh->meshes[ii];
+		const carve::mesh::Mesh<3>* mesh2 = checkMesh->meshes[ii];
+		if( mesh1->closed_edges.size() != mesh2->closed_edges.size() ) { return false; }
+		if( mesh1->open_edges.size() != mesh2->open_edges.size() ) { return false; }
+		if( mesh1->faces.size() != mesh2->faces.size() ) { return false; }
+
+		for( size_t jj = 0; jj < mesh1->faces.size(); ++jj )
+		{
+			const carve::mesh::Face<3>* face1 = mesh1->faces[jj];
+			const carve::mesh::Face<3>* face2 = mesh2->faces[jj];
+			if( face1->n_edges != face2->n_edges ) { return false; }
+
+			const carve::mesh::Edge<3>* edge1 = face1->edge;
+			const carve::mesh::Edge<3>* edge2 = face2->edge;
+
+			for( size_t kk = 0; kk < face1->n_edges; ++kk )
+			{
+				const carve::mesh::Vertex<3>* vertex1 = edge1->vert;
+				const carve::mesh::Vertex<3>* vertex2 = edge2->vert;
+				vec3 delt = vertex1->v - vertex2->v;
+				if( delt.x > 0.0001 ) { return false; }
+				if( delt.x < -0.0001 ) { return false; }
+				if( delt.y > 0.0001 ) { return false; }
+				if( delt.y < -0.0001 ) { return false; }
+				if( delt.z > 0.0001 ) { return false; }
+				if( delt.z < -0.0001 ) { return false; }
+				edge1 = edge1->next;
+				edge2 = edge2->next;
+			}
+		}
+	}
+	return true;
+}
 
+inline bool isEqual(const shared_ptr<ItemShapeData>& existingItem, const shared_ptr<ItemShapeData>& checkItem)
+{
+	if( existingItem->m_meshsets.size() != checkItem->m_meshsets.size() ) { return false; }
+	if( existingItem->m_meshsets_open.size() != checkItem->m_meshsets_open.size() ) { return false; }
+
+	for( size_t ii = 0; ii < existingItem->m_meshsets.size(); ++ii )
+	{
+		shared_ptr<carve::mesh::MeshSet<3> >& meshset1 = existingItem->m_meshsets[ii];
+		shared_ptr<carve::mesh::MeshSet<3> >& meshset2 = checkItem->m_meshsets[ii];
+		if( !isEqual(meshset1, meshset2) )
+		{
+			return false;
+		}
+	}
+	for( size_t ii = 0; ii < existingItem->m_meshsets_open.size(); ++ii )
+	{
+		shared_ptr<carve::mesh::MeshSet<3> >& meshset1 = existingItem->m_meshsets_open[ii];
+		shared_ptr<carve::mesh::MeshSet<3> >& meshset2 = checkItem->m_meshsets_open[ii];
+		if( !isEqual(meshset1, meshset2) )
+		{
+			return false;
+		}
+	}
+	return true;
+}
 
 static carve::geom::aabb<3> computeBoundingBoxLocalCoords( const shared_ptr<ProductShapeData>& productData, bool includeChildren )
 {

IfcPlusPlus/src/ifcpp/geometry/GeometrySettings.h

@@ -117,8 +117,8 @@ class GeometrySettings
 	int	m_num_vertices_per_circle = 14;
 	int m_num_vertices_per_circle_default = 14;
 	int m_min_num_vertices_per_arc = 5;
-	int m_num_vertices_per_control_point = 4;
-	int m_num_vertices_per_control_point_default = 4;
+	int m_num_vertices_per_control_point = 1;
+	int m_num_vertices_per_control_point_default = 1;
 	bool m_show_text_literals = false;
 	bool m_ignore_profile_radius = false;
 	bool m_handle_styled_items = true;