/********************************************************************************

* *

* This file is part of IfcOpenShell. *

* *

* IfcOpenShell is free software: you can redistribute it and/or modify *

* it under the terms of the Lesser GNU General Public License as published by *

* the Free Software Foundation, either version 3.0 of the License, or *

* (at your option) any later version. *

* *

* IfcOpenShell 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 *

* Lesser GNU General Public License for more details. *

* *

* You should have received a copy of the Lesser GNU General Public License *

* along with this program. If not, see <http://www.gnu.org/licenses/>. *

* *

********************************************************************************/

/********************************************************************************

* *

* Implementations of the various conversion functions defined in IfcGeom.h *

* *

********************************************************************************/

#include <set>

#include <cassert>

#include <algorithm>

#include <gp_Pnt.hxx>

#include <gp_Vec.hxx>

#include <gp_Dir.hxx>

#include <gp_Pnt2d.hxx>

#include <gp_Vec2d.hxx>

#include <gp_Dir2d.hxx>

#include <gp_Mat.hxx>

#include <gp_Mat2d.hxx>

#include <gp_GTrsf.hxx>

#include <gp_GTrsf2d.hxx>

#include <gp_Trsf.hxx>

#include <gp_Trsf2d.hxx>

#include <gp_Ax3.hxx>

#include <gp_Ax2d.hxx>

#include <gp_Pln.hxx>

#include <gp_Circ.hxx>

#include <boost/range/irange.hpp>

#include <boost/range/algorithm_ext/push_back.hpp>

#include <TColgp_Array1OfPnt.hxx>

#include <TColgp_Array1OfPnt2d.hxx>

#include <TColStd_Array1OfReal.hxx>

#include <TColStd_Array1OfInteger.hxx>

#include <Geom_Line.hxx>

#include <Geom_Circle.hxx>

#include <Geom_Ellipse.hxx>

#include <Geom_TrimmedCurve.hxx>

#include <Geom_Plane.hxx>

#include <Geom_OffsetCurve.hxx>

#include <Geom_OffsetSurface.hxx>

#include <Geom_CylindricalSurface.hxx>

#include <Geom_SurfaceOfLinearExtrusion.hxx>

#include <GeomAPI_IntCS.hxx>

#include <GeomAPI_IntSS.hxx>

#include <BRepBndLib.hxx>

#include <BRepOffsetAPI_Sewing.hxx>

#include <BRepBuilderAPI_MakeFace.hxx>

#include <BRepBuilderAPI_MakeEdge.hxx>

#include <BRepBuilderAPI_MakeWire.hxx>

#include <BRepBuilderAPI_MakePolygon.hxx>

#include <BRepBuilderAPI_MakeVertex.hxx>

#include <TopoDS.hxx>

#include <TopoDS_Wire.hxx>

#include <TopoDS_Face.hxx>

#include <TopoDS_CompSolid.hxx>

#include <TopExp.hxx>

#include <TopExp_Explorer.hxx>

#include <BRepPrimAPI_MakePrism.hxx>

#include <BRepBuilderAPI_MakeShell.hxx>

#include <BRepBuilderAPI_MakeSolid.hxx>

#include <BRepPrimAPI_MakeHalfSpace.hxx>

#include <BRepAlgoAPI_Cut.hxx>

#include <BRepAlgoAPI_Fuse.hxx>

#include <BRepAlgoAPI_Common.hxx>

#include <BRepAlgoAPI_BooleanOperation.hxx>

#include <BRepAlgo_NormalProjection.hxx>

#include <ShapeFix_Shape.hxx>

#include <ShapeFix_ShapeTolerance.hxx>

#include <ShapeFix_Solid.hxx>

#include <ShapeAnalysis_Curve.hxx>

#include <ShapeAnalysis_Wire.hxx>

#include <ShapeAnalysis_Surface.hxx>

#include <ShapeAnalysis_ShapeTolerance.hxx>

#include <BRepFilletAPI_MakeFillet2d.hxx>

#include <TopLoc_Location.hxx>

#include <GProp_GProps.hxx>

#include <BRepGProp.hxx>

#include <BRepBuilderAPI_Copy.hxx>

#include <BRepBuilderAPI_Transform.hxx>

#include <BRepBuilderAPI_GTransform.hxx>

#include <BRepCheck_Analyzer.hxx>

#include <BRepGProp_Face.hxx>

#include <BRepMesh_IncrementalMesh.hxx>

#include <BRepTools.hxx>

#include <BRepTools_WireExplorer.hxx>

#include <Poly_Triangulation.hxx>

#include <Poly_Array1OfTriangle.hxx>

#include <TopTools_IndexedMapOfShape.hxx>

#include <TopTools_IndexedDataMapOfShapeListOfShape.hxx>

#include <TopTools_ListIteratorOfListOfShape.hxx>

#include <TopTools_HSequenceOfShape.hxx>

#include <BOPAlgo_PaveFiller.hxx>

#include <BOPAlgo_BOP.hxx>

#include <GCPnts_AbscissaPoint.hxx>

#include <BRepClass3d_SolidClassifier.hxx>

#include <GeomAPI_ExtremaCurveCurve.hxx>

#include <Extrema_ExtPC.hxx>

#include <BRepAdaptor_Curve.hxx>

#include <Standard_Version.hxx>

#include "../ifcparse/IfcSIPrefix.h"

#include "../ifcparse/IfcFile.h"

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

#include "../ifcgeom/IfcGeomTree.h"

#if OCC_VERSION_HEX < 0x60900

#ifdef _MSC_VER

#pragma message("warning: You are linking against Open CASCADE version " OCC_VERSION_COMPLETE ". Version 6.9.0 introduces various improvements with relation to boolean operations. You are advised to upgrade.")

#else

#warning "You are linking against linking against an older version of Open CASCADE. Version 6.9.0 introduces various improvements with relation to boolean operations. You are advised to upgrade."

#endif

#endif

namespace {

void copy_operand(const TopTools_ListOfShape& l, TopTools_ListOfShape& r) {

#if OCC_VERSION_HEX < 0x70000

TopTools_ListIteratorOfListOfShape it(l);

for (; it.More(); it.Next()) {

r.Append(BRepBuilderAPI_Copy(it.Value()));

}

#else

// On OCCT 7.0 and higher BRepAlgoAPI_BuilderAlgo::SetNonDestructive(true) is

// called. Not entirely sure on the behaviour before 7.0, so overcautiously

// create copies.

r.Assign(l);

#endif

}

TopoDS_Shape copy_operand(const TopoDS_Shape& s) {

#if OCC_VERSION_HEX < 0x70000

return BRepBuilderAPI_Copy(s);

#else

return s;

#endif

}

double min_edge_length(const TopoDS_Shape& a) {

double min_edge_len = std::numeric_limits<double>::infinity();

TopExp_Explorer exp(a, TopAbs_EDGE);

for (; exp.More(); exp.Next()) {

GProp_GProps prop;

BRepGProp::LinearProperties(exp.Current(), prop);

double l = prop.Mass();

if (l < min_edge_len) {

min_edge_len = l;

}

}

return min_edge_len;

}

double min_vertex_edge_distance(const TopoDS_Shape& a, double t) {

TopExp_Explorer exp(a, TopAbs_VERTEX);

double M = std::numeric_limits<double>::infinity();

for (; exp.More(); exp.Next()) {

if (exp.Current().Orientation() != TopAbs_FORWARD) {

continue;

}

const TopoDS_Vertex& v = TopoDS::Vertex(exp.Current());

gp_Pnt p = BRep_Tool::Pnt(v);

TopExp_Explorer exp2(a, TopAbs_EDGE);

for (; exp2.More(); exp2.Next()) {

const TopoDS_Edge& e = TopoDS::Edge(exp2.Current());

TopoDS_Vertex v1, v2;

TopExp::Vertices(e, v1, v2);

if (v.IsSame(v1) || v.IsSame(v2)) {

continue;

}

BRepAdaptor_Curve crv(e);

Extrema_ExtPC ext(p, crv);

if (!ext.IsDone()) {

continue;

}

for (int i = 1; i <= ext.NbExt(); ++i) {

const double m = sqrt(ext.SquareDistance(i));

if (m < M && m > t) {

M = m;

}

}

}

}

return M;

}

bool is_manifold(const TopoDS_Shape& a) {

TopTools_IndexedDataMapOfShapeListOfShape map;

TopExp::MapShapesAndAncestors(a, TopAbs_EDGE, TopAbs_FACE, map);

for (int i = 1; i <= map.Extent(); ++i) {

if (map.FindFromIndex(i).Extent() != 2) {

return false;

}

}

return true;

}

bool is_manifold(const TopTools_ListOfShape& l) {

TopTools_ListOfShape r;

TopTools_ListIteratorOfListOfShape it(l);

for (; it.More(); it.Next()) {

if (!is_manifold(it.Value())) {

return false;

}

}

return true;

}

void bounding_box_overlap(double p, const TopoDS_Shape& a, const TopTools_ListOfShape& b, TopTools_ListOfShape& c) {

Bnd_Box A;

BRepBndLib::Add(a, A);

if (A.IsVoid()) {

return;

}

TopTools_ListIteratorOfListOfShape it(b);

for (; it.More(); it.Next()) {

Bnd_Box B;

BRepBndLib::Add(it.Value(), B);

if (B.IsVoid()) {

continue;

}

if (A.Distance(B) < p) {

c.Append(it.Value());

}

}

}

}

bool IfcGeom::Kernel::create_solid_from_compound(const TopoDS_Shape& compound, TopoDS_Shape& shape) {

TopTools_ListOfShape face_list;

TopExp_Explorer exp(compound, TopAbs_FACE);

for (; exp.More(); exp.Next()) {

TopoDS_Face face = TopoDS::Face(exp.Current());

face_list.Append(face);

}

if (face_list.Extent() == 0) {

return false;

}

return create_solid_from_faces(face_list, shape);

}

bool IfcGeom::Kernel::create_solid_from_faces(const TopTools_ListOfShape& face_list, TopoDS_Shape& shape) {

bool valid_shell = false;

int max_faces = getValue(GV_MAX_FACES_TO_SEW);

if (max_faces == -1) {

max_faces = 1000;

}

if (face_list.Extent() > max_faces) {

throw too_many_faces_exception();

}

TopTools_ListIteratorOfListOfShape face_iterator;

BRepOffsetAPI_Sewing builder;

builder.SetTolerance(getValue(GV_PRECISION));

builder.SetMaxTolerance(getValue(GV_PRECISION));

builder.SetMinTolerance(getValue(GV_PRECISION));

for (face_iterator.Initialize(face_list); face_iterator.More(); face_iterator.Next()) {

builder.Add(face_iterator.Value());

}

try {

builder.Perform();

shape = builder.SewedShape();

{

BRepCheck_Analyzer ana(shape);

if (!ana.IsValid()) {

ShapeFix_Shape sfs(shape);

sfs.Perform();

shape = sfs.Shape();

}

}

BRepCheck_Analyzer ana(shape);

valid_shell = ana.IsValid() != 0 && count(shape, TopAbs_SHELL) > 0;

} catch (const Standard_Failure& e) {

if (e.GetMessageString() && strlen(e.GetMessageString())) {

Logger::Error(e.GetMessageString());

} else {

Logger::Error("Unknown error sewing shell");

}

} catch (...) {

Logger::Error("Unknown error sewing shell");

}

if (valid_shell) {

TopoDS_Shape complete_shape;

TopExp_Explorer exp(shape, TopAbs_SHELL);

for (; exp.More(); exp.Next()) {

TopoDS_Shape result_shape = exp.Current();

try {

ShapeFix_Solid solid;

solid.SetMaxTolerance(getValue(GV_PRECISION));

TopoDS_Solid solid_shape = solid.SolidFromShell(TopoDS::Shell(exp.Current()));

if (!solid_shape.IsNull()) {

try {

BRepClass3d_SolidClassifier classifier(solid_shape);

result_shape = solid_shape;

classifier.PerformInfinitePoint(getValue(GV_PRECISION));

if (classifier.State() == TopAbs_IN) {

shape.Reverse();

}

} catch (const Standard_Failure& e) {

if (e.GetMessageString() && strlen(e.GetMessageString())) {

Logger::Error(e.GetMessageString());

} else {

Logger::Error("Unknown error classifying solid");

}

} catch (...) {

Logger::Error("Unknown error classifying solid");

}

}

} catch (const Standard_Failure& e) {

if (e.GetMessageString() && strlen(e.GetMessageString())) {

Logger::Error(e.GetMessageString());

} else {

Logger::Error("Unknown error creating solid");

}

} catch (...) {

Logger::Error("Unknown error creating solid");

}

if (complete_shape.IsNull()) {

complete_shape = result_shape;

} else {

BRep_Builder B;

if (complete_shape.ShapeType() != TopAbs_COMPOUND) {

TopoDS_Compound C;

B.MakeCompound(C);

B.Add(C, complete_shape);

complete_shape = C;

Logger::Message(Logger::LOG_ERROR, "Multiple components in IfcConnectedFaceSet");

}

B.Add(complete_shape, result_shape);

}

}

TopExp_Explorer loose_faces(shape, TopAbs_FACE, TopAbs_SHELL);

for (; loose_faces.More(); loose_faces.Next()) {

BRep_Builder B;

if (complete_shape.ShapeType() != TopAbs_COMPOUND) {

TopoDS_Compound C;

B.MakeCompound(C);

B.Add(C, complete_shape);

complete_shape = C;

Logger::Message(Logger::LOG_ERROR, "Loose faces in IfcConnectedFaceSet");

}

B.Add(complete_shape, loose_faces.Current());

}

shape = complete_shape;

} else {

Logger::Message(Logger::LOG_WARNING, "Failed to sew faceset");

}

return valid_shell;

}

bool IfcGeom::Kernel::is_compound(const TopoDS_Shape& shape) {

bool has_solids = TopExp_Explorer(shape,TopAbs_SOLID).More() != 0;

bool has_shells = TopExp_Explorer(shape,TopAbs_SHELL).More() != 0;

bool has_compounds = TopExp_Explorer(shape,TopAbs_COMPOUND).More() != 0;

bool has_faces = TopExp_Explorer(shape,TopAbs_FACE).More() != 0;

return has_compounds && has_faces && !has_solids && !has_shells;

}

const TopoDS_Shape& IfcGeom::Kernel::ensure_fit_for_subtraction(const TopoDS_Shape& shape, TopoDS_Shape& solid) {

const bool is_comp = is_compound(shape);

if (!is_comp) {

return solid = shape;

}

if (!create_solid_from_compound(shape, solid)) {

return solid = shape;

}

// If the SEW_SHELLS option had been set this precision had been applied

// at the end of the generic convert_shape() call.

const double precision = getValue(GV_PRECISION);

apply_tolerance(solid, precision);

return solid;

}

bool IfcGeom::Kernel::convert_openings(const IfcSchema::IfcProduct* entity, const IfcSchema::IfcRelVoidsElement::list::ptr& openings,

const IfcGeom::IfcRepresentationShapeItems& entity_shapes, const gp_Trsf& entity_trsf, IfcGeom::IfcRepresentationShapeItems& cut_shapes) {

// TODO: Refactor convert_openings() convert_openings_fast() and convert(IfcBooleanResult) to use

// the same code base and conform to the same checks and logging messages.

// Iterate over IfcOpeningElements

IfcGeom::IfcRepresentationShapeItems opening_shapes;

unsigned int last_size = 0;

for ( IfcSchema::IfcRelVoidsElement::list::it it = openings->begin(); it != openings->end(); ++ it ) {

IfcSchema::IfcRelVoidsElement* v = *it;

IfcSchema::IfcFeatureElementSubtraction* fes = v->RelatedOpeningElement();

if ( fes->is(IfcSchema::Type::IfcOpeningElement) ) {

if (!fes->hasRepresentation()) continue;

// Convert the IfcRepresentation of the IfcOpeningElement

gp_Trsf opening_trsf;

if (fes->hasObjectPlacement()) {

try {

convert(fes->ObjectPlacement(),opening_trsf);

} catch (const std::exception& e) {

Logger::Error(e);

} catch (...) {

Logger::Error("Failed to construct placement");

}

}

// Move the opening into the coordinate system of the IfcProduct

opening_trsf.PreMultiply(entity_trsf.Inverted());

IfcSchema::IfcProductRepresentation* prodrep = fes->Representation();

IfcSchema::IfcRepresentation::list::ptr reps = prodrep->Representations();

for ( IfcSchema::IfcRepresentation::list::it it2 = reps->begin(); it2 != reps->end(); ++ it2 ) {

convert_shapes(*it2,opening_shapes);

}

const unsigned int current_size = (const unsigned int) opening_shapes.size();

for ( unsigned int i = last_size; i < current_size; ++ i ) {

opening_shapes[i].prepend(opening_trsf);

}

last_size = current_size;

}

}

// Iterate over the shapes of the IfcProduct

for ( IfcGeom::IfcRepresentationShapeItems::const_iterator it3 = entity_shapes.begin(); it3 != entity_shapes.end(); ++ it3 ) {

TopoDS_Shape entity_shape_solid;

const TopoDS_Shape& entity_shape_unlocated = ensure_fit_for_subtraction(it3->Shape(),entity_shape_solid);

const gp_GTrsf& entity_shape_gtrsf = it3->Placement();

if ( entity_shape_gtrsf.Form() == gp_Other ) {

Logger::Message(Logger::LOG_WARNING, "Applying non uniform transformation to:", entity->entity);

}

TopoDS_Shape entity_shape = apply_transformation(entity_shape_unlocated, entity_shape_gtrsf);

// Iterate over the shapes of the IfcOpeningElements

for ( IfcGeom::IfcRepresentationShapeItems::const_iterator it4 = opening_shapes.begin(); it4 != opening_shapes.end(); ++ it4 ) {

TopoDS_Shape opening_shape_solid;

const TopoDS_Shape& opening_shape_unlocated = ensure_fit_for_subtraction(it4->Shape(),opening_shape_solid);

const gp_GTrsf& opening_shape_gtrsf = it4->Placement();

if ( opening_shape_gtrsf.Form() == gp_Other ) {

Logger::Message(Logger::LOG_WARNING,"Applying non uniform transformation to opening of:",entity->entity);

}

TopoDS_Shape opening_shape = apply_transformation(opening_shape_unlocated, opening_shape_gtrsf);

double opening_volume;

if (Logger::LOG_WARNING >= Logger::Verbosity()) {

opening_volume = shape_volume(opening_shape);

if ( opening_volume <= ALMOST_ZERO )

Logger::Message(Logger::LOG_WARNING,"Empty opening for:",entity->entity);

}

if (entity_shape.ShapeType() == TopAbs_COMPSOLID) {

// For compound solids process the subtraction for the constituent

// solids individually and write the result back as a compound solid.

TopoDS_CompSolid compound;

BRep_Builder builder;

builder.MakeCompSolid(compound);

TopExp_Explorer exp(entity_shape, TopAbs_SOLID);

for (; exp.More(); exp.Next()) {

#if OCC_VERSION_HEX < 0x60900

BRepAlgoAPI_Cut brep_cut(exp.Current(), opening_shape);

#else

BRepAlgoAPI_Cut brep_cut;

TopTools_ListOfShape s1s;

s1s.Append(exp.Current());

TopTools_ListOfShape s2s;

s2s.Append(opening_shape);

brep_cut.SetFuzzyValue(getValue(GV_PRECISION));

brep_cut.SetArguments(s1s);

brep_cut.SetTools(s2s);

brep_cut.Build();

#endif

bool added = false;

if ( brep_cut.IsDone() ) {

TopoDS_Shape brep_cut_result = brep_cut;

BRepCheck_Analyzer analyser(brep_cut_result);

bool is_valid = analyser.IsValid() != 0;

if (is_valid) {

TopExp_Explorer exp2(brep_cut_result, TopAbs_SOLID);

for (; exp2.More(); exp2.Next()) {

builder.Add(compound, exp2.Current());

added = true;

}

}

}

if (!added) {

// Add the original in case subtraction fails

builder.Add(compound, exp.Current());

} else {

Logger::Message(Logger::LOG_ERROR,"Failed to process subtraction:",entity->entity);

}

}

entity_shape = compound;

} else {

#if OCC_VERSION_HEX < 0x60900

BRepAlgoAPI_Cut brep_cut(entity_shape,opening_shape);

#else

BRepAlgoAPI_Cut brep_cut;

TopTools_ListOfShape s1s;

s1s.Append(entity_shape);

TopTools_ListOfShape s2s;

s2s.Append(opening_shape);

brep_cut.SetFuzzyValue(getValue(GV_PRECISION));

brep_cut.SetArguments(s1s);

brep_cut.SetTools(s2s);

brep_cut.Build();

#endif

if ( brep_cut.IsDone() ) {

TopoDS_Shape brep_cut_result = brep_cut;

ShapeFix_Shape fix(brep_cut_result);

try {

fix.Perform();

brep_cut_result = fix.Shape();

} catch (...) {

Logger::Message(Logger::LOG_WARNING, "Shape healing failed on opening subtraction result", entity->entity);

}

BRepCheck_Analyzer analyser(brep_cut_result);

bool is_valid = analyser.IsValid() != 0;

if ( is_valid ) {

entity_shape = brep_cut_result;

if (Logger::LOG_WARNING >= Logger::Verbosity()) {

const double volume_after_subtraction = shape_volume(entity_shape);

double original_shape_volume = shape_volume(entity_shape);

if ( ALMOST_THE_SAME(original_shape_volume,volume_after_subtraction) )

Logger::Message(Logger::LOG_WARNING,"Subtraction yields unchanged volume:",entity->entity);

}

} else {

Logger::Message(Logger::LOG_ERROR,"Invalid result from subtraction:",entity->entity);

}

} else {

Logger::Message(Logger::LOG_ERROR,"Failed to process subtraction:",entity->entity);

}

}

}

cut_shapes.push_back(IfcGeom::IfcRepresentationShapeItem(entity_shape, &it3->Style()));

}

return true;

}

#if OCC_VERSION_HEX < 0x60900

bool IfcGeom::Kernel::convert_openings_fast(const IfcSchema::IfcProduct* entity, const IfcSchema::IfcRelVoidsElement::list::ptr& openings,

const IfcGeom::IfcRepresentationShapeItems& entity_shapes, const gp_Trsf& entity_trsf, IfcGeom::IfcRepresentationShapeItems& cut_shapes) {

// Create a compound of all opening shapes in order to speed up the boolean operations

TopoDS_Compound opening_compound;

BRep_Builder builder;

builder.MakeCompound(opening_compound);

for ( IfcSchema::IfcRelVoidsElement::list::it it = openings->begin(); it != openings->end(); ++ it ) {

IfcSchema::IfcRelVoidsElement* v = *it;

IfcSchema::IfcFeatureElementSubtraction* fes = v->RelatedOpeningElement();

if ( fes->is(IfcSchema::Type::IfcOpeningElement) ) {

if (!fes->hasRepresentation()) continue;

// Convert the IfcRepresentation of the IfcOpeningElement

gp_Trsf opening_trsf;

if (fes->hasObjectPlacement()) {

try {

convert(fes->ObjectPlacement(),opening_trsf);

} catch (const std::exception& e) {

Logger::Error(e);

} catch (...) {

Logger::Error("Failed to construct placement");

}

}

// Move the opening into the coordinate system of the IfcProduct

opening_trsf.PreMultiply(entity_trsf.Inverted());

IfcSchema::IfcProductRepresentation* prodrep = fes->Representation();

IfcSchema::IfcRepresentation::list::ptr reps = prodrep->Representations();

IfcGeom::IfcRepresentationShapeItems opening_shapes;

for ( IfcSchema::IfcRepresentation::list::it it2 = reps->begin(); it2 != reps->end(); ++ it2 ) {

convert_shapes(*it2,opening_shapes);

}

for ( unsigned int i = 0; i < opening_shapes.size(); ++ i ) {

gp_GTrsf gtrsf = opening_shapes[i].Placement();

gtrsf.PreMultiply(opening_trsf);

TopoDS_Shape opening_shape = apply_transformation(opening_shapes[i].Shape(), gtrsf);

builder.Add(opening_compound, opening_shape);

}

}

}

// Iterate over the shapes of the IfcProduct

for ( IfcGeom::IfcRepresentationShapeItems::const_iterator it3 = entity_shapes.begin(); it3 != entity_shapes.end(); ++ it3 ) {

TopoDS_Shape entity_shape_solid;

const TopoDS_Shape& entity_shape_unlocated = ensure_fit_for_subtraction(it3->Shape(),entity_shape_solid);

const gp_GTrsf& entity_shape_gtrsf = it3->Placement();

if (entity_shape_gtrsf.Form() == gp_Other) {

Logger::Message(Logger::LOG_WARNING, "Applying non uniform transformation to:", entity->entity);

}

TopoDS_Shape entity_shape = apply_transformation(entity_shape_unlocated, entity_shape_gtrsf);

BRepAlgoAPI_Cut brep_cut(entity_shape,opening_compound);

bool is_valid = false;

if ( brep_cut.IsDone() ) {

TopoDS_Shape brep_cut_result = brep_cut;

BRepCheck_Analyzer analyser(brep_cut_result);

is_valid = analyser.IsValid() != 0;

if ( is_valid ) {

cut_shapes.push_back(IfcGeom::IfcRepresentationShapeItem(brep_cut_result, &it3->Style()));

}

}

if ( !is_valid ) {

// Apparently processing the boolean operation failed or resulted in an invalid result

// in which case the original shape without the subtractions is returned instead

// we try convert the openings in the original way, one by one.

Logger::Message(Logger::LOG_WARNING,"Subtracting combined openings compound failed:",entity->entity);

return false;

}

}

return true;

}

#else

bool IfcGeom::Kernel::convert_openings_fast(const IfcSchema::IfcProduct* entity, const IfcSchema::IfcRelVoidsElement::list::ptr& openings,

const IfcGeom::IfcRepresentationShapeItems& entity_shapes, const gp_Trsf& entity_trsf, IfcGeom::IfcRepresentationShapeItems& cut_shapes) {

TopTools_ListOfShape opening_shapelist;

for ( IfcSchema::IfcRelVoidsElement::list::it it = openings->begin(); it != openings->end(); ++ it ) {

IfcSchema::IfcRelVoidsElement* v = *it;

IfcSchema::IfcFeatureElementSubtraction* fes = v->RelatedOpeningElement();

if ( fes->is(IfcSchema::Type::IfcOpeningElement) ) {

if (!fes->hasRepresentation()) continue;

// Convert the IfcRepresentation of the IfcOpeningElement

gp_Trsf opening_trsf;

if (fes->hasObjectPlacement()) {

try {

convert(fes->ObjectPlacement(),opening_trsf);

} catch (const std::exception& e) {

Logger::Error(e);

} catch (...) {

Logger::Error("Failed to construct placement");

}

}

// Move the opening into the coordinate system of the IfcProduct

opening_trsf.PreMultiply(entity_trsf.Inverted());

IfcSchema::IfcProductRepresentation* prodrep = fes->Representation();

IfcSchema::IfcRepresentation::list::ptr reps = prodrep->Representations();

IfcGeom::IfcRepresentationShapeItems opening_shapes;

for ( IfcSchema::IfcRepresentation::list::it it2 = reps->begin(); it2 != reps->end(); ++ it2 ) {

convert_shapes(*it2,opening_shapes);

}

for ( unsigned int i = 0; i < opening_shapes.size(); ++ i ) {

TopoDS_Shape opening_shape_solid;

const TopoDS_Shape& opening_shape_unlocated = ensure_fit_for_subtraction(opening_shapes[i].Shape(), opening_shape_solid);

gp_GTrsf gtrsf = opening_shapes[i].Placement();

gtrsf.PreMultiply(opening_trsf);

TopoDS_Shape opening_shape = apply_transformation(opening_shape_unlocated, gtrsf);

opening_shapelist.Append(opening_shape);

}

}

}

// Iterate over the shapes of the IfcProduct

for ( IfcGeom::IfcRepresentationShapeItems::const_iterator it3 = entity_shapes.begin(); it3 != entity_shapes.end(); ++ it3 ) {

TopoDS_Shape entity_shape_solid;

const TopoDS_Shape& entity_shape_unlocated = ensure_fit_for_subtraction(it3->Shape(),entity_shape_solid);

const gp_GTrsf& entity_shape_gtrsf = it3->Placement();

if (entity_shape_gtrsf.Form() == gp_Other) {

Logger::Message(Logger::LOG_WARNING, "Applying non uniform transformation to:", entity->entity);

}

TopoDS_Shape entity_shape = apply_transformation(entity_shape_unlocated, entity_shape_gtrsf);

TopoDS_Shape result;

if (boolean_operation(entity_shape, opening_shapelist, BOPAlgo_CUT, result)) {

cut_shapes.push_back(IfcGeom::IfcRepresentationShapeItem(result, &it3->Style()));

} else {

Logger::Message(Logger::LOG_ERROR, "Opening subtraction failed:", entity->entity);

cut_shapes.push_back(IfcGeom::IfcRepresentationShapeItem(entity_shape, &it3->Style()));

}

}

return true;

}

#endif

bool IfcGeom::Kernel::convert_wire_to_face(const TopoDS_Wire& w, TopoDS_Face& face) {

TopoDS_Wire wire = w;

TopTools_ListOfShape results;

if (wire_intersections(wire, results)) {

Logger::Error("Self-intersections with " + boost::lexical_cast<std::string>(results.Extent()) + " cycles detected");

select_largest(results, wire);

}

bool is_2d = true;

TopExp_Explorer exp(wire, TopAbs_EDGE);

for (; exp.More(); exp.Next()) {

double a, b;

Handle(Geom_Curve) crv = BRep_Tool::Curve(TopoDS::Edge(exp.Current()), a, b);

if (crv->DynamicType() != STANDARD_TYPE(Geom_Line)) {

is_2d = false;

break;

}

Handle(Geom_Line) line = Handle(Geom_Line)::DownCast(crv);

if (line->Lin().Direction().Z() > ALMOST_ZERO) {

is_2d = false;

break;

}

}

if (!is_2d) {

// For 2d wires (e.g. profiles) a higher tolerance for plane fitting is never required.

ShapeFix_ShapeTolerance FTol;

FTol.SetTolerance(wire, getValue(GV_PRECISION), TopAbs_WIRE);

}

BRepBuilderAPI_MakeFace mf(wire, false);

BRepBuilderAPI_FaceError er = mf.Error();

if (er != BRepBuilderAPI_FaceDone) {

Logger::Error("Failed to create face.");

return false;

}

face = mf.Face();

return true;

}

bool IfcGeom::Kernel::convert_curve_to_wire(const Handle(Geom_Curve)& curve, TopoDS_Wire& wire) {

try {

wire = BRepBuilderAPI_MakeWire(BRepBuilderAPI_MakeEdge(curve));

return true;

} catch (const Standard_Failure& e) {

if (e.GetMessageString() && strlen(e.GetMessageString())) {

Logger::Error(e.GetMessageString());

} else {

Logger::Error("Unknown error converting curve to wire");

}

} catch (...) {

Logger::Error("Unknown error converting curve to wire");

}

return false;

}

bool IfcGeom::Kernel::profile_helper(int numVerts, double* verts, int numFillets, int* filletIndices, double* filletRadii, gp_Trsf2d trsf, TopoDS_Shape& face_shape) {

TopoDS_Vertex* vertices = new TopoDS_Vertex[numVerts];

for ( int i = 0; i < numVerts; i ++ ) {

gp_XY xy (verts[2*i],verts[2*i+1]);

trsf.Transforms(xy);

vertices[i] = BRepBuilderAPI_MakeVertex(gp_Pnt(xy.X(),xy.Y(),0.0f));

}

BRepBuilderAPI_MakeWire w;

for ( int i = 0; i < numVerts; i ++ )

w.Add(BRepBuilderAPI_MakeEdge(vertices[i],vertices[(i+1)%numVerts]));

TopoDS_Face face;

convert_wire_to_face(w.Wire(),face);

if ( numFillets && *std::max_element(filletRadii, filletRadii + numFillets) > ALMOST_ZERO ) {

BRepFilletAPI_MakeFillet2d fillet (face);

for ( int i = 0; i < numFillets; i ++ ) {

const double radius = filletRadii[i];

if ( radius <= ALMOST_ZERO ) continue;

fillet.AddFillet(vertices[filletIndices[i]],radius);

}

fillet.Build();

if (fillet.IsDone()) {

face = TopoDS::Face(fillet.Shape());

} else {

Logger::Message(Logger::LOG_WARNING, "Failed to process profile fillets");

}

}

face_shape = face;

delete[] vertices;

return true;

}

double IfcGeom::Kernel::shape_volume(const TopoDS_Shape& s) {

GProp_GProps prop;

BRepGProp::VolumeProperties(s, prop);

return prop.Mass();

}

double IfcGeom::Kernel::face_area(const TopoDS_Face& f) {

GProp_GProps prop;

BRepGProp::SurfaceProperties(f,prop);

return prop.Mass();

}

bool IfcGeom::Kernel::is_convex(const TopoDS_Wire& wire) {

for ( TopExp_Explorer exp1(wire,TopAbs_VERTEX); exp1.More(); exp1.Next() ) {

TopoDS_Vertex V1 = TopoDS::Vertex(exp1.Current());

gp_Pnt P1 = BRep_Tool::Pnt(V1);

// Store the neighboring points

std::vector<gp_Pnt> neighbors;

for ( TopExp_Explorer exp3(wire,TopAbs_EDGE); exp3.More(); exp3.Next() ) {

TopoDS_Edge edge = TopoDS::Edge(exp3.Current());

std::vector<gp_Pnt> edge_points;

for ( TopExp_Explorer exp2(edge,TopAbs_VERTEX); exp2.More(); exp2.Next() ) {

TopoDS_Vertex V2 = TopoDS::Vertex(exp2.Current());

gp_Pnt P2 = BRep_Tool::Pnt(V2);

edge_points.push_back(P2);

}

if ( edge_points.size() != 2 ) continue;

if ( edge_points[0].IsEqual(P1,getValue(GV_POINT_EQUALITY_TOLERANCE))) neighbors.push_back(edge_points[1]);

else if ( edge_points[1].IsEqual(P1, getValue(GV_POINT_EQUALITY_TOLERANCE))) neighbors.push_back(edge_points[0]);

}

// There should be two of these

if ( neighbors.size() != 2 ) return false;

// Now find the non neighboring points

std::vector<gp_Pnt> non_neighbors;

for ( TopExp_Explorer exp2(wire,TopAbs_VERTEX); exp2.More(); exp2.Next() ) {

TopoDS_Vertex V2 = TopoDS::Vertex(exp2.Current());

gp_Pnt P2 = BRep_Tool::Pnt(V2);

if ( P1.IsEqual(P2,getValue(GV_POINT_EQUALITY_TOLERANCE)) ) continue;

bool found = false;

for( std::vector<gp_Pnt>::const_iterator it = neighbors.begin(); it != neighbors.end(); ++ it ) {

if ( (*it).IsEqual(P2,getValue(GV_POINT_EQUALITY_TOLERANCE)) ) { found = true; break; }

}

if ( ! found ) non_neighbors.push_back(P2);

}

// Calculate the angle between the two edges of the vertex

gp_Dir dir1(neighbors[0].XYZ() - P1.XYZ());

gp_Dir dir2(neighbors[1].XYZ() - P1.XYZ());

const double angle = acos(dir1.Dot(dir2)) + 0.0001;

// Now for the non-neighbors see whether a greater angle can be found with one of the edges

for ( std::vector<gp_Pnt>::const_iterator it = non_neighbors.begin(); it != non_neighbors.end(); ++ it ) {

gp_Dir dir3((*it).XYZ() - P1.XYZ());

const double angle2 = acos(dir3.Dot(dir1));

const double angle3 = acos(dir3.Dot(dir2));

if ( angle2 > angle || angle3 > angle ) return false;

}

}

return true;

}

TopoDS_Shape IfcGeom::Kernel::halfspace_from_plane(const gp_Pln& pln,const gp_Pnt& cent) {

TopoDS_Face face = BRepBuilderAPI_MakeFace(pln).Face();

return BRepPrimAPI_MakeHalfSpace(face,cent).Solid();

}

gp_Pln IfcGeom::Kernel::plane_from_face(const TopoDS_Face& face) {

BRepGProp_Face prop(face);

Standard_Real u1,u2,v1,v2;

prop.Bounds(u1,u2,v1,v2);

Standard_Real u = (u1+u2)/2.0;

Standard_Real v = (v1+v2)/2.0;

gp_Pnt p;

gp_Vec n;

prop.Normal(u,v,p,n);

return gp_Pln(p,n);

}

gp_Pnt IfcGeom::Kernel::point_above_plane(const gp_Pln& pln, bool agree) {

if ( agree ) {

return pln.Location().Translated(pln.Axis().Direction());

} else {

return pln.Location().Translated(-pln.Axis().Direction());

}

}

void IfcGeom::Kernel::apply_tolerance(TopoDS_Shape& s, double t) {

/*

// This does not result in actionable error messages and has been disabled.

ShapeAnalysis_ShapeTolerance toler;

if (Logger::LOG_WARNING >= Logger::Verbosity()) {

if (toler.Tolerance(s, 0) > t * 10.) {

Handle_TopTools_HSequenceOfShape shapes = toler.OverTolerance(s, t * 10.);

for (int i = 1; i <= shapes->Length(); ++i) {

const TopoDS_Shape& sub = shapes->Value(i);

std::stringstream ss;

TopAbs::Print(sub.ShapeType(), ss);

Logger::Warning("Tolerance of " + boost::lexical_cast<std::string>(toler.Tolerance(sub, 0)) + " on " + ss.str());

}

}

}

*/

#if OCC_VERSION_HEX < 0x60900

// This tolerance hack is not required as the boolean ops use a fuzziness value

ShapeFix_ShapeTolerance tol;

tol.LimitTolerance(s, t);

#else

(void)s;

(void)t;

#endif

}

void IfcGeom::Kernel::setValue(GeomValue var, double value) {

switch (var) {

case GV_DEFLECTION_TOLERANCE:

deflection_tolerance = value;

break;

case GV_WIRE_CREATION_TOLERANCE:

wire_creation_tolerance = value;

break;

case GV_POINT_EQUALITY_TOLERANCE:

point_equality_tolerance = value;

break;

case GV_MAX_FACES_TO_SEW:

max_faces_to_sew = value;

break;

case GV_LENGTH_UNIT:

ifc_length_unit = value;

break;

case GV_PLANEANGLE_UNIT:

ifc_planeangle_unit = value;

break;