IfcGeom::BRepElement* IfcGeom::Kernel::create_brep_for_representation_and_product(
const IteratorSettings& settings, IfcSchema::IfcRepresentation* representation, IfcSchema::IfcProduct* product)
{
IfcGeom::Representation::BRep* shape;
IfcGeom::IfcRepresentationShapeItems shapes, shapes2;
if ( !convert_shapes(representation, shapes) ) {
return 0;
}
if (settings.get(IteratorSettings::APPLY_LAYERSETS)) {
TopoDS_Shape merge;
if (flatten_shape_list(shapes, merge, false)) {
if (count(merge, TopAbs_FACE) > 0) {
std::vector thickness;
std::vector layers;
std::vector< std::vector > folded_layers;
std::vector styles;
if (convert_layerset(product, layers, styles, thickness)) {
if (product->as() && fold_layers(product->as(), shapes, layers, thickness, folded_layers)) {
if (apply_folded_layerset(shapes, folded_layers, styles, shapes2)) {
std::swap(shapes, shapes2);
}
} else {
if (apply_layerset(shapes, layers, styles, shapes2)) {
std::swap(shapes, shapes2);
}
}
}
}
}
}
int parent_id = -1;
try {
IfcSchema::IfcObjectDefinition* parent_object = get_decomposing_entity(product);
if (parent_object) {
parent_id = parent_object->entity->id();
}
} catch (...) {}
const std::string name = product->hasName() ? product->Name() : "";
const std::string guid = product->GlobalId();
gp_Trsf trsf;
try {
convert(product->ObjectPlacement(),trsf);
} catch (...) {}
// Does the IfcElement have any IfcOpenings?
// Note that openings for IfcOpeningElements are not processed
IfcSchema::IfcRelVoidsElement::list::ptr openings = find_openings(product);
const std::string product_type = IfcSchema::Type::ToString(product->type());
ElementSettings element_settings(settings, getValue(GV_LENGTH_UNIT), product_type);
if (!settings.get(IfcGeom::IteratorSettings::DISABLE_OPENING_SUBTRACTIONS) && openings && openings->size()) {
IfcGeom::IfcRepresentationShapeItems opened_shapes;
try {
#if OCC_VERSION_HEX < 0x60900
const bool faster_booleans = settings.get(IteratorSettings::FASTER_BOOLEANS);
#else
const bool faster_booleans = true;
#endif
if (faster_booleans) {
bool succes = convert_openings_fast(product,openings,shapes,trsf,opened_shapes);
if ( ! succes ) {
opened_shapes.clear();
convert_openings(product,openings,shapes,trsf,opened_shapes);
}
} else {
convert_openings(product,openings,shapes,trsf,opened_shapes);
}
} catch(...) {
Logger::Message(Logger::LOG_ERROR,"Error processing openings for:",product->entity);
}
if (settings.get(IteratorSettings::USE_WORLD_COORDS)) {
for ( IfcGeom::IfcRepresentationShapeItems::iterator it = opened_shapes.begin(); it != opened_shapes.end(); ++ it ) {
it->prepend(trsf);
}
trsf = gp_Trsf();
}
shape = new IfcGeom::Representation::BRep(element_settings, representation->entity->id(), opened_shapes);
} else if (settings.get(IteratorSettings::USE_WORLD_COORDS)) {
for ( IfcGeom::IfcRepresentationShapeItems::iterator it = shapes.begin(); it != shapes.end(); ++ it ) {
it->prepend(trsf);
}
trsf = gp_Trsf();
shape = new IfcGeom::Representation::BRep(element_settings, representation->entity->id(), shapes);
} else {
shape = new IfcGeom::Representation::BRep(element_settings, representation->entity->id(), shapes);
}
std::string context_string = "";
if (representation->hasRepresentationIdentifier()) {
context_string = representation->RepresentationIdentifier();
} else if (representation->ContextOfItems()->hasContextType()) {
context_string = representation->ContextOfItems()->ContextType();
}
return new BRepElement(
product->entity->id(),
parent_id,
name,
product_type,
guid,
context_string,
trsf,
boost::shared_ptr(shape)
);
}
template
IfcGeom::BRepElement* IfcGeom::Kernel::create_brep_for_processed_representation(
const IteratorSettings& /*settings*/, IfcSchema::IfcRepresentation* representation, IfcSchema::IfcProduct* product,
IfcGeom::BRepElement
* brep)
{
int parent_id = -1;
try {
IfcSchema::IfcObjectDefinition* parent_object = get_decomposing_entity(product);
if (parent_object) {
parent_id = parent_object->entity->id();
}
} catch (...) {}
const std::string name = product->hasName() ? product->Name() : "";
const std::string guid = product->GlobalId();
gp_Trsf trsf;
try {
convert(product->ObjectPlacement(),trsf);
} catch (...) {}
std::string context_string = "";
if (representation->hasRepresentationIdentifier()) {
context_string = representation->RepresentationIdentifier();
} else if (representation->ContextOfItems()->hasContextType()) {
context_string = representation->ContextOfItems()->ContextType();
}
const std::string product_type = IfcSchema::Type::ToString(product->type());
return new BRepElement
(
product->entity->id(),
parent_id,
name,
product_type,
guid,
context_string,
trsf,
brep->geometry_pointer()
);
}
IfcSchema::IfcObjectDefinition* IfcGeom::Kernel::get_decomposing_entity(IfcSchema::IfcProduct* product) {
IfcSchema::IfcObjectDefinition* parent = 0;
// In case of an opening element, parent to the RelatingBuildingElement
if ( product->is(IfcSchema::Type::IfcOpeningElement ) ) {
IfcSchema::IfcOpeningElement* opening = (IfcSchema::IfcOpeningElement*)product;
IfcSchema::IfcRelVoidsElement::list::ptr voids = opening->VoidsElements();
if ( voids->size() ) {
IfcSchema::IfcRelVoidsElement* ifc_void = *voids->begin();
parent = ifc_void->RelatingBuildingElement();
}
} else if ( product->is(IfcSchema::Type::IfcElement ) ) {
IfcSchema::IfcElement* element = (IfcSchema::IfcElement*)product;
IfcSchema::IfcRelFillsElement::list::ptr fills = element->FillsVoids();
// Incase of a RelatedBuildingElement parent to the opening element
if ( fills->size() ) {
for ( IfcSchema::IfcRelFillsElement::list::it it = fills->begin(); it != fills->end(); ++ it ) {
IfcSchema::IfcRelFillsElement* fill = *it;
IfcSchema::IfcObjectDefinition* ifc_objectdef = fill->RelatingOpeningElement();
if ( product == ifc_objectdef ) continue;
parent = ifc_objectdef;
}
}
// Else simply parent to the containing structure
if (!parent) {
IfcSchema::IfcRelContainedInSpatialStructure::list::ptr parents = element->ContainedInStructure();
if ( parents->size() ) {
IfcSchema::IfcRelContainedInSpatialStructure* container = *parents->begin();
parent = container->RelatingStructure();
}
}
}
// Parent decompositions to the RelatingObject
if (!parent) {
IfcEntityList::ptr parents = product->entity->getInverse(IfcSchema::Type::IfcRelAggregates, -1);
parents->push(product->entity->getInverse(IfcSchema::Type::IfcRelNests, -1));
for ( IfcEntityList::it it = parents->begin(); it != parents->end(); ++ it ) {
IfcSchema::IfcRelDecomposes* decompose = (IfcSchema::IfcRelDecomposes*)*it;
IfcSchema::IfcObjectDefinition* ifc_objectdef;
#ifdef USE_IFC4
if (decompose->is(IfcSchema::Type::IfcRelAggregates)) {
ifc_objectdef = ((IfcSchema::IfcRelAggregates*)decompose)->RelatingObject();
} else {
continue;
}
#else
ifc_objectdef = decompose->RelatingObject();
#endif
if ( product == ifc_objectdef ) continue;
parent = ifc_objectdef;
}
}
return parent;
}
template IFC_GEOM_API IfcGeom::BRepElement* IfcGeom::Kernel::create_brep_for_representation_and_product(
const IteratorSettings& settings, IfcSchema::IfcRepresentation* representation, IfcSchema::IfcProduct* product);
template IFC_GEOM_API IfcGeom::BRepElement* IfcGeom::Kernel::create_brep_for_representation_and_product(
const IteratorSettings& settings, IfcSchema::IfcRepresentation* representation, IfcSchema::IfcProduct* product);
template IFC_GEOM_API IfcGeom::BRepElement* IfcGeom::Kernel::create_brep_for_processed_representation(
const IteratorSettings& settings, IfcSchema::IfcRepresentation* representation, IfcSchema::IfcProduct* product, IfcGeom::BRepElement* brep);
template IFC_GEOM_API IfcGeom::BRepElement* IfcGeom::Kernel::create_brep_for_processed_representation(
const IteratorSettings& settings, IfcSchema::IfcRepresentation* representation, IfcSchema::IfcProduct* product, IfcGeom::BRepElement* brep);
std::pair IfcGeom::Kernel::initializeUnits(IfcSchema::IfcUnitAssignment* unit_assignment) {
// Set default units, set length to meters, angles to undefined
setValue(IfcGeom::Kernel::GV_LENGTH_UNIT, 1.0);
setValue(IfcGeom::Kernel::GV_PLANEANGLE_UNIT, -1.0);
std::string unit_name = "METER";
double unit_magnitude = 1.;
try {
IfcEntityList::ptr units = unit_assignment->Units();
if (!units || !units->size()) {
Logger::Message(Logger::LOG_ERROR, "No unit information found");
} else {
for (IfcEntityList::it it = units->begin(); it != units->end(); ++it) {
IfcUtil::IfcBaseClass* base = *it;
if (base->is(IfcSchema::Type::IfcNamedUnit)) {
IfcSchema::IfcNamedUnit* named_unit = base->as();
if (named_unit->UnitType() == IfcSchema::IfcUnitEnum::IfcUnit_LENGTHUNIT ||
named_unit->UnitType() == IfcSchema::IfcUnitEnum::IfcUnit_PLANEANGLEUNIT)
{
std::string current_unit_name;
const double current_unit_magnitude = IfcParse::get_SI_equivalent(named_unit);
if (current_unit_magnitude != 0.) {
if (named_unit->is(IfcSchema::Type::IfcConversionBasedUnit)) {
IfcSchema::IfcConversionBasedUnit* u = (IfcSchema::IfcConversionBasedUnit*)base;
current_unit_name = u->Name();
} else if (named_unit->is(IfcSchema::Type::IfcSIUnit)) {
IfcSchema::IfcSIUnit* si_unit = named_unit->as();
if (si_unit->hasPrefix()) {
current_unit_name = IfcSchema::IfcSIPrefix::ToString(si_unit->Prefix()) + unit_name;
}
current_unit_name += IfcSchema::IfcSIUnitName::ToString(si_unit->Name());
}
if (named_unit->UnitType() == IfcSchema::IfcUnitEnum::IfcUnit_LENGTHUNIT) {
unit_name = current_unit_name;
unit_magnitude = current_unit_magnitude;
setValue(IfcGeom::Kernel::GV_LENGTH_UNIT, current_unit_magnitude);
} else {
setValue(IfcGeom::Kernel::GV_PLANEANGLE_UNIT, current_unit_magnitude);
}
}
}
}
}
}
} catch (const IfcParse::IfcException& ex) {
std::stringstream ss;
ss << "Failed to determine unit information '" << ex.what() << "'";
Logger::Message(Logger::LOG_ERROR, ss.str());
}
return std::pair(unit_name, unit_magnitude);
}
bool IfcGeom::Kernel::convert_layerset(const IfcSchema::IfcProduct* product, std::vector& surfaces, std::vector& styles, std::vector& thicknesses) {
IfcSchema::IfcMaterialLayerSetUsage* usage = 0;
Handle_Geom_Surface reference_surface;
IfcSchema::IfcRelAssociates::list::ptr associations = product->HasAssociations();
for (IfcSchema::IfcRelAssociates::list::it it = associations->begin(); it != associations->end(); ++it) {
IfcSchema::IfcRelAssociatesMaterial* associates_material = (**it).as();
if (associates_material) {
usage = associates_material->RelatingMaterial()->as();
break;
}
}
if (!usage) {
return false;
}
IfcSchema::IfcRepresentation* body_representation = find_representation(product, "Body");
IfcSchema::IfcRepresentation* axis_representation = find_representation(product, "Axis");
if (product->is(IfcSchema::Type::IfcWall)) {
if (!axis_representation) {
Logger::Message(Logger::LOG_WARNING, "No axis representation for:", product->entity);
return false;
}
IfcRepresentationShapeItems axis_items;
{
Kernel temp = *this;
temp.setValue(GV_DIMENSIONALITY, -1.);
temp.convert_shapes(axis_representation, axis_items);
}
TopoDS_Shape axis_shape;
flatten_shape_list(axis_items, axis_shape, false);
TopExp_Explorer exp(axis_shape, TopAbs_EDGE);
TopoDS_Edge axis_edge;
int edge_count = 0;
if (exp.More()) {
axis_edge = TopoDS::Edge(exp.Current());
++ edge_count;
} else {
Logger::Message(Logger::LOG_WARNING, "No edge found in axis representation:", product->entity);
return false;
}
double u1, u2;
Handle_Geom_Curve axis_curve = BRep_Tool::Curve(axis_edge, u1, u2);
if (true) { /**< @todo Why always true? */
if (axis_curve->DynamicType() == STANDARD_TYPE(Geom_Line)) {
Handle_Geom_Line axis_line = Handle_Geom_Line::DownCast(axis_curve);
reference_surface = new Geom_Plane(axis_line->Lin().Location(), axis_line->Lin().Direction() ^ gp::DZ());
} else if (axis_curve->DynamicType() == STANDARD_TYPE(Geom_Circle)) {
Handle_Geom_Circle axis_line = Handle_Geom_Circle::DownCast(axis_curve);
reference_surface = new Geom_CylindricalSurface(axis_line->Position(), axis_line->Radius());
} else {
Logger::Message(Logger::LOG_ERROR, "Unsupported underlying curve of Axis representation:", product->entity);
return false;
}
} else {
// Unfortunately this does not work when its intersection
// is calculated later on when the layerset is applied.
reference_surface = new Geom_SurfaceOfLinearExtrusion(axis_curve, gp::DZ());
}
} else {
IfcSchema::IfcExtrudedAreaSolid::list::ptr extrusions = body_representation->entity->file->traverse(body_representation)->as();
if (extrusions->size() != 1) {
Logger::Message(Logger::LOG_WARNING, "No single extrusion found in body representation for:", product->entity);
return false;
}
IfcSchema::IfcExtrudedAreaSolid* extrusion = *extrusions->begin();
gp_Trsf extrusion_position;
if (!convert(extrusion->Position(), extrusion_position)) {
Logger::Message(Logger::LOG_ERROR, "Failed to convert placement for extrusion of:", product->entity);
return false;
}
gp_Dir extrusion_direction;
if (!convert(extrusion->ExtrudedDirection(), extrusion_direction)) {
Logger::Message(Logger::LOG_ERROR, "Failed to convert direction for extrusion of:", product->entity);
return false;
}
reference_surface = new Geom_Plane(extrusion_position.TranslationPart(), extrusion_direction);
}
const IfcSchema::IfcMaterialLayerSet* layerset = usage->ForLayerSet();
const bool positive = usage->DirectionSense() == IfcSchema::IfcDirectionSenseEnum::IfcDirectionSense_POSITIVE;
double offset = usage->OffsetFromReferenceLine() * getValue(GV_LENGTH_UNIT);
IfcSchema::IfcMaterialLayer::list::ptr material_layers = layerset->MaterialLayers();
surfaces.push_back(new Geom_OffsetSurface(reference_surface, -offset));
for (IfcSchema::IfcMaterialLayer::list::it it = material_layers->begin(); it != material_layers->end(); ++it) {
styles.push_back(get_style((*it)->Material()));
double thickness = (*it)->LayerThickness() * getValue(GV_LENGTH_UNIT);
thicknesses.push_back(thickness);
if (!positive) {
thickness *= -1;
}
offset += thickness;
if (fabs(offset) < 1.e-7) {
surfaces.push_back(reference_surface);
} else {
surfaces.push_back(new Geom_OffsetSurface(reference_surface, -offset));
}
}
if (positive) {
std::reverse(surfaces.begin(), surfaces.end());
}
return true;
}
const Handle_Geom_Curve IfcGeom::Kernel::intersect(const Handle_Geom_Surface& a, const Handle_Geom_Surface& b) {
GeomAPI_IntSS x(a, b, 1.e-7);
if (x.IsDone() && x.NbLines() == 1) {
return x.Line(1);
} else {
return Handle_Geom_Curve();
}
}
const Handle_Geom_Curve IfcGeom::Kernel::intersect(const Handle_Geom_Surface& a, const TopoDS_Face& b) {
return intersect(a, BRep_Tool::Surface(b));
}
const Handle_Geom_Curve IfcGeom::Kernel::intersect(const TopoDS_Face& a, const Handle_Geom_Surface& b) {
return intersect(BRep_Tool::Surface(a), b);
}
bool IfcGeom::Kernel::intersect(const Handle_Geom_Curve& a, const Handle_Geom_Surface& b, gp_Pnt& p) {
GeomAPI_IntCS x(a, b);
if (x.IsDone() && x.NbPoints() == 1) {
p = x.Point(1);
return true;
} else {
return false;
}
}
bool IfcGeom::Kernel::intersect(const Handle_Geom_Curve& a, const TopoDS_Face& b, gp_Pnt &c) {
return intersect(a, BRep_Tool::Surface(b), c);
}
bool IfcGeom::Kernel::intersect(const Handle_Geom_Curve& a, const TopoDS_Shape& b, std::vector& out) {
TopExp_Explorer exp(b, TopAbs_FACE);
gp_Pnt p;
for (; exp.More(); exp.Next()) {
if (intersect(a, TopoDS::Face(exp.Current()), p)) {
out.push_back(p);
}
}
return !out.empty();
}
bool IfcGeom::Kernel::intersect(const Handle_Geom_Surface& a, const TopoDS_Shape& b, std::vector< std::pair >& out) {
TopExp_Explorer exp(b, TopAbs_FACE);
for (; exp.More(); exp.Next()) {
const TopoDS_Face& f = TopoDS::Face(exp.Current());
const Handle_Geom_Surface& s = BRep_Tool::Surface(f);
Handle_Geom_Curve crv = intersect(a, s);
if (!crv.IsNull()) {
out.push_back(std::make_pair(s, crv));
}
}
return !out.empty();
}
bool IfcGeom::Kernel::closest(const gp_Pnt& a, const std::vector& b, gp_Pnt& c) {
double minimal_distance = std::numeric_limits::infinity();
for (std::vector::const_iterator it = b.begin(); it != b.end(); ++it) {
const double d = a.Distance(*it);
if (d < minimal_distance) {
minimal_distance = d;
c = *it;
}
}
return minimal_distance != std::numeric_limits::infinity();
}
bool IfcGeom::Kernel::project(const Handle_Geom_Curve& crv, const gp_Pnt& pt, gp_Pnt& p, double& u, double& d) {
ShapeAnalysis_Curve sac;
sac.Project(crv, pt, 1e-3, p, u, false);
d = pt.Distance(p);
return true;
}
int IfcGeom::Kernel::count(const TopoDS_Shape& s, TopAbs_ShapeEnum t) {
int i = 0;
TopExp_Explorer exp(s, t);
for (; exp.More(); exp.Next()) {
++i;
}
return i;
}
bool IfcGeom::Kernel::find_wall_end_points(const IfcSchema::IfcWall* wall, gp_Pnt& start, gp_Pnt& end) {
IfcSchema::IfcRepresentation* axis_representation = find_representation(wall, "Axis");
if (!axis_representation) {
return false;
}
IfcRepresentationShapeItems items;
{
Kernel temp = *this;
temp.setValue(GV_DIMENSIONALITY, -1.);
temp.convert_shapes(axis_representation, items);
}
TopoDS_Vertex a, b;
for (IfcRepresentationShapeItems::const_iterator it = items.begin(); it != items.end(); ++it) {
TopExp_Explorer exp(it->Shape(), TopAbs_VERTEX);
for (; exp.More(); exp.Next()) {
b = TopoDS::Vertex(exp.Current());
if (a.IsNull()) {
a = b;
}
}
}
if (a.IsNull() || b.IsNull()) {
return false;
}
start = BRep_Tool::Pnt(a);
end = BRep_Tool::Pnt(b);
return true;
}
bool IfcGeom::Kernel::fold_layers(const IfcSchema::IfcWall* wall, const IfcRepresentationShapeItems& items, const std::vector& surfaces, const std::vector& thicknesses, std::vector< std::vector >& result) {
bool folds_made = false;
IfcSchema::IfcRelConnectsPathElements::list::ptr connections(new IfcSchema::IfcRelConnectsPathElements::list);
connections->push(wall->ConnectedFrom()->as());
connections->push( wall->ConnectedTo()->as());
typedef std::vector surfaces_t;
typedef std::pair curve_on_surface;
typedef std::vector curves_on_surfaces_t;
typedef std::vector< std::pair< std::pair, const IfcSchema::IfcProduct*> > endpoint_connections_t;
typedef std::vector< std::vector > result_t;
endpoint_connections_t endpoint_connections;
for (IfcSchema::IfcRelConnectsPathElements::list::it it = connections->begin(); it != connections->end(); ++it) {
IfcSchema::IfcRelConnectsPathElements* connection = *it;
IfcSchema::IfcConnectionTypeEnum::IfcConnectionTypeEnum own_type = connection->RelatedElement() == wall
? connection->RelatedConnectionType()
: connection->RelatingConnectionType();
IfcSchema::IfcConnectionTypeEnum::IfcConnectionTypeEnum other_type = connection->RelatedElement() == wall
? connection->RelatingConnectionType()
: connection->RelatedConnectionType();
if (other_type != IfcSchema::IfcConnectionTypeEnum::IfcConnectionType_ATPATH &&
(own_type == IfcSchema::IfcConnectionTypeEnum::IfcConnectionType_ATEND ||
own_type == IfcSchema::IfcConnectionTypeEnum::IfcConnectionType_ATSTART))
{
IfcSchema::IfcElement* other = connection->RelatedElement() == wall
? connection->RelatingElement()
: connection->RelatedElement();
if (other->as()) {
endpoint_connections.push_back(std::make_pair(std::make_pair(own_type, other_type), other));
}
}
}
if (endpoint_connections.size() == 0) {
return false;
}
int connection_type_count[2] = {0,0};
for (endpoint_connections_t::const_iterator it = endpoint_connections.begin(); it != endpoint_connections.end(); ++it) {
const int idx = it->first.first == IfcSchema::IfcConnectionTypeEnum::IfcConnectionType_ATSTART;
connection_type_count[idx] ++;
}
gp_Trsf local;
if (!convert(wall->ObjectPlacement(), local)) {
return false;
}
local.Invert();
{
// Copy the unfolded surfaces
result.resize(surfaces.size());
std::vector< std::vector >::iterator result_it = result.begin() + 1;
std::vector::const_iterator input_it = surfaces.begin() + 1;
for(; input_it != surfaces.end() - 1; ++result_it, ++input_it) {
result_it->push_back(*input_it);
}
}
gp_Pnt own_axis_start, own_axis_end;
find_wall_end_points(wall, own_axis_start, own_axis_end);
for (int idx = 0; idx < 2; ++idx) {
if (connection_type_count[idx] <= 1) {
continue;
}
/*
IfcSchema::IfcConnectionTypeEnum::IfcConnectionTypeEnum connection_type = idx == 1
? IfcSchema::IfcConnectionTypeEnum::IfcConnectionType_ATSTART
: IfcSchema::IfcConnectionTypeEnum::IfcConnectionType_ATEND;
*/
std::set others;
endpoint_connections_t::iterator it = endpoint_connections.begin();
while (it != endpoint_connections.end()) {
const IfcSchema::IfcProduct* other = it->second;
if (others.find(other) != others.end()) {
it = endpoint_connections.erase(it);
-- connection_type_count[idx];
} else {
others.insert(other);
++it;
}
}
/*
Additionally one could check whether the end points are of the wall are really ~1 LayerThickness away from each other
for (endpoint_connections_t::const_iterator it = endpoint_connections.begin(); it != endpoint_connections.end(); ++it) {
IfcSchema::IfcConnectionTypeEnum::IfcConnectionTypeEnum relating_connection_type = it->first.first;
IfcSchema::IfcConnectionTypeEnum::IfcConnectionTypeEnum related_connection_type = it->first.second;
if (connection_type != relating_connection_type) {
continue;
}
gp_Pnt other_axis_start, other_axis_end;
find_wall_end_points(it->second->as(), other_axis_start, other_axis_end);
gp_Trsf other;
if (!convert(it->second->ObjectPlacement(), other)) {
continue;
}
other.Transforms(other_axis_start.ChangeCoord());
local.Transforms(other_axis_start.ChangeCoord());
other.Transforms(other_axis_end.ChangeCoord());
local.Transforms(other_axis_end.ChangeCoord());
const gp_Pnt& a = relating_connection_type == IfcSchema::IfcConnectionTypeEnum::IfcConnectionType_ATSTART
? own_axis_start
: own_axis_end;
const gp_Pnt& b = related_connection_type == IfcSchema::IfcConnectionTypeEnum::IfcConnectionType_ATSTART
? other_axis_start
: other_axis_end;
const double d = a.Distance(b);
}
*/
}
for (endpoint_connections_t::const_iterator it = endpoint_connections.begin(); it != endpoint_connections.end(); ++it) {
IfcSchema::IfcConnectionTypeEnum::IfcConnectionTypeEnum connection_type = it->first.first;
// If more than one wall connects to this start/end -point assume layers do not need to be folded
const int idx = connection_type == IfcSchema::IfcConnectionTypeEnum::IfcConnectionType_ATSTART;
if (connection_type_count[idx] > 1) continue;
const gp_Pnt& own_end_point = connection_type == IfcSchema::IfcConnectionTypeEnum::IfcConnectionType_ATEND
? own_axis_end
: own_axis_start;
const IfcSchema::IfcProduct* other_wall = it->second;
gp_Trsf other;
if (!convert(other_wall->ObjectPlacement(), other)) {
continue;
}
IfcSchema::IfcRepresentation* axis_representation = find_representation(other_wall, "Axis");
IfcRepresentationShapeItems axis_items;
{
Kernel temp = *this;
temp.setValue(GV_DIMENSIONALITY, -1.);
temp.convert_shapes(axis_representation, axis_items);
}
TopoDS_Shape axis_shape;
flatten_shape_list(axis_items, axis_shape, false);
// local and other are IfcLocalPlacements and therefore have a unit
// scale factor that can be applied by means of TopoDS_Shape::Move()
axis_shape.Move(other);
axis_shape.Move(local);
TopoDS_Shape body_shape;
flatten_shape_list(items, body_shape, false);
Handle_Geom_Curve axis_curve;
double axis_u1, axis_u2;
{
TopExp_Explorer exp(axis_shape, TopAbs_EDGE);
if (!exp.More()) {
return false;
}
TopoDS_Edge axis_edge = TopoDS::Edge(exp.Current());
axis_curve = BRep_Tool::Curve(axis_edge, axis_u1, axis_u2);
gp_Pnt other_a_1, other_a_2;
axis_curve->D0(axis_u1, other_a_1);
axis_curve->D0(axis_u2, other_a_2);
if (axis_u2 < axis_u1) {
std::swap(axis_u1, axis_u2);
}
exp.Next();
for (; exp.More(); exp.Next()) {
TopoDS_Edge axis_edge2 = TopoDS::Edge(exp.Current());
TopExp_Explorer exp2(axis_edge2, TopAbs_VERTEX);
for (; exp2.More(); exp2.Next()) {
gp_Pnt p = BRep_Tool::Pnt(TopoDS::Vertex(exp2.Current()));
gp_Pnt pp;
double u, d;
if (project(axis_curve, p, pp, u, d)) {
if (u < axis_u1) axis_u1 = u;
if (u > axis_u2) axis_u2 = u;
}
}
}
}
double layer_offset = 0;
std::vector::const_iterator thickness = thicknesses.begin();
result_t::iterator result_vector = result.begin() + 1;
for (surfaces_t::const_iterator jt = surfaces.begin() + 1; jt != surfaces.end() - 1; ++jt, ++result_vector) {
layer_offset += *thickness++;
bool found_intersection = false;
boost::optional point_outside_param_range;
//double param;
const Handle_Geom_Surface& surface = *jt;
GeomAPI_IntCS intersections(axis_curve, surface);
if (intersections.IsDone() && intersections.NbPoints() == 1) {
const gp_Pnt& p = intersections.Point(1);
double u, v, w;
intersections.Parameters(1, u, v, w);
if (w < axis_u1 || w > axis_u2) {
point_outside_param_range = p;
//param = w;
} else {
// Found an intersection. Layer end point is covered by connecting wall
found_intersection = true;
break;
}
}
if (!found_intersection && point_outside_param_range) {
/*
Is there a bug in Open Cascade related to the intersection
of offset surfaces constructed from linear extrusions?
Handle_Geom_Surface xy = new Geom_Plane(gp::Origin(), gp::DZ());
// Handle_Geom_Surface yz = new Geom_Plane(gp::Origin(), gp::DX());
// Handle_Geom_Surface yz2 = new Geom_OffsetSurface(yz, 1.);
Handle_Geom_Curve ln = new Geom_Line(gp::Origin(), gp::DX());
Handle_Geom_Surface yz = new Geom_SurfaceOfLinearExtrusion(ln, gp::DZ());
Handle_Geom_Surface yz2 = new Geom_OffsetSurface(yz, 1.);
intersect(xy, yz2);
*/
Handle_Geom_Surface plane = new Geom_Plane(*point_outside_param_range, gp::DZ());
curves_on_surfaces_t layer_ends;
intersect(surface, body_shape, layer_ends);
Handle_Geom_Curve layer_body_intersection;
Handle_Geom_Surface body_surface;
double mind = std::numeric_limits::infinity();
for (curves_on_surfaces_t::const_iterator kt = layer_ends.begin(); kt != layer_ends.end(); ++kt) {
gp_Pnt p;
gp_Vec v;
double u, d;
kt->second->D1(0., p, v);
if (ALMOST_THE_SAME(0., v.Dot(gp::DZ()))) {
// Filter horizontal curves
continue;
}
if (project(kt->second, own_end_point, p, u, d)) {
if (d < mind) {
body_surface = kt->first;
layer_body_intersection = kt->second;
mind = d;
}
}
}
GeomAPI_IntCS intersection2(layer_body_intersection, plane);
if (intersection2.IsDone() && intersection2.NbPoints() == 1) {
const gp_Pnt& layer_end_point = intersection2.Point(1);
GeomAPI_IntSS intersection3(surface, plane, 1.e-7);
if (intersection3.IsDone() && intersection3.NbLines() == 1) {
Handle_Geom_Curve layer_line = intersection3.Line(1);
GeomAdaptor_Curve layer_line_adaptor(layer_line);
ShapeAnalysis_Curve sac;
gp_Pnt layer_end_point_projected; double layer_end_point_param;
sac.Project(layer_line, layer_end_point, 1e-3, layer_end_point_projected, layer_end_point_param, false);
GCPnts_AbscissaPoint dst(layer_line_adaptor, layer_offset, layer_end_point_param);
if (dst.IsDone()) {
gp_Pnt layer_fold_point;
layer_line->D0(dst.Parameter(), layer_fold_point);
GeomAPI_IntSS intersection4(body_surface, plane, 1.e-7);
if (intersection4.IsDone() && intersection4.NbLines() == 1) {
Handle_Geom_Curve body_trim_curve = intersection4.Line(1);
ShapeAnalysis_Curve sac2;
gp_Pnt layer_fold_point_projected; double layer_fold_point_param;
sac2.Project(body_trim_curve, layer_fold_point, 1.e-7, layer_fold_point_projected, layer_fold_point_param, false);
Handle_Geom_Curve fold_curve = new Geom_OffsetCurve(body_trim_curve->Reversed(), layer_fold_point_projected.Distance(layer_fold_point), gp::DZ());
Handle_Geom_Surface fold_surface = new Geom_SurfaceOfLinearExtrusion(fold_curve, gp::DZ());
result_vector->push_back(fold_surface);
folds_made = true;
}
}
}
}
}
}
}
return folds_made;
}
bool IfcGeom::Kernel::apply_folded_layerset(const IfcRepresentationShapeItems& items, const std::vector< std::vector >& surfaces, const std::vector& styles, IfcRepresentationShapeItems& result) {
Bnd_Box bb;
TopoDS_Shape input;
flatten_shape_list(items, input, false);
BRepBndLib::Add(input, bb);
std::vector bb_coords(6);
bb.Get(bb_coords[0], bb_coords[1], bb_coords[2], bb_coords[3], bb_coords[4], bb_coords[5]);
typedef std::vector< std::vector > folded_surfaces_t;
typedef std::vector< std::pair< TopoDS_Face, std::pair > > faces_with_mass_t;
std::vector shells;
// result = items;
for (folded_surfaces_t::const_iterator it = surfaces.begin(); it != surfaces.end(); ++it) {
if (it->empty()) {
continue;
} else if (it->size() == 1) {
const Handle_Geom_Surface& surface = (*it)[0];
double u1, v1, u2, v2;
if (!project(surface, input, u1, v1, u2, v2)) {
continue;
}
shells.push_back(BRepBuilderAPI_MakeShell(surface, u1, v1, u2, v2).Shell());
} else {
faces_with_mass_t solids;
for (folded_surfaces_t::value_type::const_iterator jt = it->begin(); jt != it->end(); ++jt) {
const Handle_Geom_Surface& surface = *jt;
double u1, v1, u2, v2;
if (!project(surface, input, u1, v1, u2, v2)) {
continue;
}
TopoDS_Face face = BRepBuilderAPI_MakeFace(surface, u1, u2, v1, v2, 1.e-7).Face();
gp_Pnt p, p1, p2; gp_Vec vu, vv, n;
surface->D1((u1+u2)/2., (v1+v2)/2., p, vu, vv);
n = vu ^ vv;
p1 = p.Translated( n);
p2 = p.Translated(-n);
solids.push_back(std::make_pair(face, std::make_pair(p1, p2)));
}
if (solids.empty()) {
continue;
}
faces_with_mass_t::iterator jt = solids.begin();
TopoDS_Face& A = jt->first;
TopoDS_Shape An = BRepPrimAPI_MakeHalfSpace(A, jt->second.second).Solid();
for (++jt; jt != solids.end(); ++jt) {
TopoDS_Face& B = jt->first;
TopoDS_Shape Bn = BRepPrimAPI_MakeHalfSpace(B, jt->second.second).Solid();
TopoDS_Shape a = BRepAlgoAPI_Cut(A, Bn);
if (count(a, TopAbs_FACE) == 1) {
A = TopoDS::Face(TopExp_Explorer(a, TopAbs_FACE).Current());
}
TopoDS_Shape b = BRepAlgoAPI_Cut(B, An);
if (count(b, TopAbs_FACE) == 1) {
B = TopoDS::Face(TopExp_Explorer(b, TopAbs_FACE).Current());
}
}
BRepOffsetAPI_Sewing builder;
for (faces_with_mass_t::const_iterator kt = solids.begin(); kt != solids.end(); ++kt) {
builder.Add(kt->first);
}
builder.Perform();
shells.push_back(TopoDS::Shell(builder.SewedShape()));
}
}
if (shells.empty()) {
return false;
} else if (shells.size() == 1) {
for (IfcRepresentationShapeItems::const_iterator it = items.begin(); it != items.end(); ++it) {
TopoDS_Shape a,b;
if (split_solid_by_shell(it->Shape(), shells[0], a, b)) {
result.push_back(IfcRepresentationShapeItem(it->Placement(), b, styles[0] ? styles[0] : &it->Style()));
result.push_back(IfcRepresentationShapeItem(it->Placement(), a, styles[1] ? styles[1] : &it->Style()));
} else {
continue;
}
}
return true;
} else {
typedef std::vector< std::vector > temp_t;
temp_t temp;
for (IfcRepresentationShapeItems::const_iterator it = items.begin(); it != items.end(); ++it) {
const TopoDS_Shape& s = it->Shape();
TopoDS_Solid sld;
ensure_fit_for_subtraction(s, sld);
std::vector temp2;
temp2.push_back(sld);
temp.push_back(temp2);
}
for (unsigned i = 0; i < shells.size(); ++i) {
for(temp_t::iterator it = temp.begin(); it != temp.end(); ++it) {
TopoDS_Shape a,b;
TopoDS_Shape& ab = (*it)[(*it).size() - 1];
if (split_solid_by_shell(ab, shells[i], a, b)) {
ab = b;
it->push_back(a);
} else {
continue;
}
}
}
IfcRepresentationShapeItems::const_iterator it1 = items.begin();
temp_t::const_iterator it2 = temp.begin();
for(; it1 != items.end(); ++it1, ++it2) {
std::vector::const_iterator it4 = styles.begin();
for (temp_t::value_type::const_iterator it3 = it2->begin(); it3 != it2->end(); ++it3, ++it4) {
result.push_back(IfcRepresentationShapeItem(it1->Placement(), *it3, (*it4) ? (*it4) : &it1->Style()));
}
}
return true;
}
}
bool IfcGeom::Kernel::apply_layerset(const IfcRepresentationShapeItems& items, const std::vector& surfaces, const std::vector& styles, IfcRepresentationShapeItems& result) {
if (surfaces.size() < 3) {
return false;
} else if (surfaces.size() == 3) {
for (IfcRepresentationShapeItems::const_iterator it = items.begin(); it != items.end(); ++it) {
TopoDS_Shape a,b;
if (split_solid_by_surface(it->Shape(), surfaces[1], a, b)) {
result.push_back(IfcRepresentationShapeItem(it->Placement(), b, styles[0] ? styles[0] : &it->Style()));
result.push_back(IfcRepresentationShapeItem(it->Placement(), a, styles[1] ? styles[1] : &it->Style()));
} else {
continue;
}
}
return true;
} else {
/*
// Determine whether sequence of surfaces is consistent with surface normal, so that
// layer operations are applied in the correct order. This seems to be always the case.
Bnd_Box bb;
for (IfcRepresentationShapeItems::const_iterator it = items.begin(); it != items.end(); ++it) {
BRepBndLib::Add(it->Shape(), bb);
}
double x1, y1, z1, x2, y2, z2;
bb.Get(x1, y1, z1, x2, y2, z2);
gp_Pnt p1(x1, y1, z1);
gp_Pnt p2(x2, y2, z2);
gp_Pnt avg = (p1.XYZ() + p2.XYZ()) / 2.;
ShapeAnalysis_Surface sas1(surfaces[0]);
ShapeAnalysis_Surface sas2(surfaces[1]);
const gp_Pnt2d uv = sas1.ValueOfUV(avg, 1e-3);
gp_Pnt ps1, ps2, mass;
gp_Vec du1, dv1, du2, dv2;
surfaces[0]->D1(uv.X(), uv.Y(), ps1, du1, dv1);
const gp_Vec n1 = dv1.XYZ() ^ du1.XYZ();
const bool reversed = gp_Dir(ps2.XYZ() - ps1.XYZ()).Dot(n1) < 0.;
surfaces[surfaces.size() - 1]->D0(uv.X(), uv.Y(), mass);
mass.ChangeCoord() += n1.XYZ();
*/
typedef std::vector< std::vector > temp_t;
temp_t temp;
for (IfcRepresentationShapeItems::const_iterator it = items.begin(); it != items.end(); ++it) {
// No transformation on purpose in order not interfere with layerset alignment
const TopoDS_Shape& s = it->Shape();
TopoDS_Solid sld;
ensure_fit_for_subtraction(s, sld);
std::vector temp2;
temp2.push_back(sld);
temp.push_back(temp2);
}
for (unsigned i = 1; i < surfaces.size() - 1; ++i) {
for(temp_t::iterator it = temp.begin(); it != temp.end(); ++it) {
TopoDS_Shape a,b;
TopoDS_Shape& ab = (*it)[(*it).size() - 1];
if (split_solid_by_surface(ab, surfaces[i], a, b)) {
ab = b;
it->push_back(a);
} else {
continue;
}
}
}
IfcRepresentationShapeItems::const_iterator it1 = items.begin();
temp_t::const_iterator it2 = temp.begin();
for(; it1 != items.end(); ++it1, ++it2) {
std::vector::const_iterator it4 = styles.begin();
for (temp_t::value_type::const_iterator it3 = it2->begin(); it3 != it2->end(); ++it3, ++it4) {
result.push_back(IfcRepresentationShapeItem(it1->Placement(), *it3, (*it4) ? (*it4) : &it1->Style()));
}
}
return true;
}
}
IfcSchema::IfcRepresentation* IfcGeom::Kernel::find_representation(const IfcSchema::IfcProduct* product, const std::string& identifier) {
if (!product->hasRepresentation()) return 0;
IfcSchema::IfcProductRepresentation* prod_rep = product->Representation();
IfcSchema::IfcRepresentation::list::ptr reps = prod_rep->Representations();
for (IfcSchema::IfcRepresentation::list::it it = reps->begin(); it != reps->end(); ++it) {
if ((**it).hasRepresentationIdentifier() && (**it).RepresentationIdentifier() == identifier) {
return *it;
}
}
return 0;
}
bool IfcGeom::Kernel::split_solid_by_surface(const TopoDS_Shape& input, const Handle_Geom_Surface& surface, TopoDS_Shape& front, TopoDS_Shape& back) {
// Use an unbounded surface, that isolate part of the input shape,
// to split this shape into two parts. Make sure that the addition
// of the two result volumes matches that of the input.
double u1, v1, u2, v2;
if (!project(surface, input, u1, v1, u2, v2)) {
return false;
}
TopoDS_Face face = BRepBuilderAPI_MakeFace(surface, u1, u2, v1, v2, 1.e-7).Face();
gp_Pnt p, p1, p2; gp_Vec vu, vv, n;
surface->D1((u1+u2)/2., (v1+v2)/2., p, vu, vv);
n = vu ^ vv;
p1 = p.Translated(-n);
TopoDS_Solid solid = BRepPrimAPI_MakeHalfSpace(face, p1).Solid();
const bool b = split_solid_by_shell(input, solid, front, back);
return b;
}
bool IfcGeom::Kernel::split_solid_by_shell(const TopoDS_Shape& input, const TopoDS_Shape& shell, TopoDS_Shape& front, TopoDS_Shape& back) {
// Use a shell, typically one or more connected faces, that isolate part
// of the input shape, to split this shape into two parts. Make sure that
// the addition of the two result volumes matches that of the input.
TopoDS_Solid solid;
if (shell.ShapeType() == TopAbs_SHELL) {
solid = BRepBuilderAPI_MakeSolid(TopoDS::Shell(shell)).Solid();
} else if (shell.ShapeType() == TopAbs_SOLID) {
solid = TopoDS::Solid(shell);
} else {
return false;
}
apply_tolerance(solid, getValue(GV_PRECISION));
BOPCol_ListOfShape shapes;
shapes.Append(input);
shapes.Append(solid);
BOPAlgo_PaveFiller filler(new NCollection_IncAllocator); // TODO: Does this need to be freed?
filler.SetArguments(shapes);
filler.Perform();
front = BRepAlgoAPI_Cut(input, solid, filler);
back = BRepAlgoAPI_Common(input, solid, filler);
bool is_null[2];
for (int i = 0; i < 2; ++i) {
TopoDS_Shape& shape = i == 0 ? front : back;
const bool result_is_null = is_null[i] = shape.IsNull();
if (result_is_null) {
continue;
}
try {
ShapeFix_Shape fix(shape);
if (fix.Perform()) {
shape = fix.Shape();
}
} catch(...) {}
BRepCheck_Analyzer analyser(shape);
bool is_valid = analyser.IsValid() != 0;
if (!is_valid) {
return false;
}
}
if (is_null[0] || is_null[1]) {
Logger::Message(Logger::LOG_ERROR, "Null result obtained from layerset slicing");
if (is_null[0] && is_null[1]) {
return false;
}
}
const double ab = shape_volume(input);
const double a = shape_volume(front);
const double b = shape_volume(back);
return ALMOST_THE_SAME(ab, a+b, 1.e-3);
}
bool IfcGeom::Kernel::project(const Handle_Geom_Surface& srf, const TopoDS_Shape& shp, double& u1, double& v1, double& u2, double& v2, double widen) {
ShapeAnalysis_Surface sas(srf);
u1 = v1 = +std::numeric_limits::infinity();
u2 = v2 = -std::numeric_limits::infinity();
gp_Pnt median;
int vertex_count = 0;
for (TopExp_Explorer exp(shp, TopAbs_VERTEX); exp.More(); exp.Next(), ++vertex_count) {
gp_Pnt p = BRep_Tool::Pnt(TopoDS::Vertex(exp.Current()));
median.ChangeCoord() += p.XYZ();
const gp_Pnt2d uv = sas.ValueOfUV(p, 1e-3);
if (uv.X() < u1) u1 = uv.X();
if (uv.Y() < v1) v1 = uv.Y();
if (uv.X() > u2) u2 = uv.X();
if (uv.Y() > v2) v2 = uv.Y();
}
if (vertex_count == 0) {
return false;
}
// Add a little bit of resulution so that the median is shifted towards the mass
// of the curve. This helps to find the parameter ordering for conic surfaces.
for (TopExp_Explorer exp(shp, TopAbs_EDGE); exp.More(); exp.Next(), ++vertex_count) {
const TopoDS_Edge& e = TopoDS::Edge(exp.Current());
double a, b;
Handle_Geom_Curve crv = BRep_Tool::Curve(e, a, b);
gp_Pnt p;
crv->D0((a + b) / 2., p);
median.ChangeCoord() += p.XYZ();
}
median.ChangeCoord().Divide(vertex_count);
const gp_Pnt2d uv = sas.ValueOfUV(median, 1e-3);
if (uv.X() < u1 || uv.X() > u2) {
std::swap(u1, u2);
}
u1 -= widen;
u2 += widen;
v1 -= widen;
v2 += widen;
return true;
}
const IfcSchema::IfcRepresentationItem* IfcGeom::Kernel::find_item_carrying_style(const IfcSchema::IfcRepresentationItem* item) {
if (item->StyledByItem()->size()) {
return item;
}
while (item->is(IfcSchema::Type::IfcBooleanClippingResult)) {
// All instantiations of IfcBooleanOperand (type of FirstOperand) are subtypes of
// IfcGeometricRepresentationItem
item = (IfcSchema::IfcGeometricRepresentationItem*) ((IfcSchema::IfcBooleanClippingResult*) item)->FirstOperand();
if (item->StyledByItem()->size()) {
return item;
}
}
// TODO: Ideally this would be done for other entities (such as IfcCsgSolid) as well.
// But neither are these very prevalent, nor does the current IfcOpenShell style
// mechanism enable to conveniently style subshapes, which would be necessary for
// distinctly styled union operands.
return item;
}
bool IfcGeom::Kernel::is_identity_transform(IfcUtil::IfcBaseClass* l) {
IfcSchema::IfcAxis2Placement2D* ax2d;
IfcSchema::IfcAxis2Placement3D* ax3d;
IfcSchema::IfcCartesianTransformationOperator2D* op2d;
IfcSchema::IfcCartesianTransformationOperator3D* op3d;
IfcSchema::IfcCartesianTransformationOperator2DnonUniform* op2dnonu;
IfcSchema::IfcCartesianTransformationOperator3DnonUniform* op3dnonu;
if((op2dnonu = l->as()) != 0) {
gp_GTrsf2d gtrsf2d;
convert(op2dnonu, gtrsf2d);
return gtrsf2d.Form() == gp_Identity;
} else if ((op2d = l->as()) != 0) {
gp_Trsf2d trsf2d;
convert(op2d, trsf2d);
return trsf2d.Form() == gp_Identity;
} else if((op3dnonu = l->as()) != 0) {
gp_GTrsf gtrsf;
convert(op3dnonu, gtrsf);
return gtrsf.Form() == gp_Identity;
} else if ((op3d = l->as()) != 0) {
gp_Trsf trsf;
convert(op3d, trsf);
return trsf.Form() == gp_Identity;
} else if((ax2d = l->as()) != 0) {
gp_Trsf2d trsf2d;
convert(ax2d, trsf2d);
return trsf2d.Form() == gp_Identity;
} else if ((ax3d = l->as()) != 0) {
gp_Trsf trsf;
convert(ax3d, trsf);
return trsf.Form() == gp_Identity;
} else {
throw IfcParse::IfcException("Invalid valuation for IfcAxis2Placement / IfcCartesianTransformationOperator");
}
}
bool IfcGeom::Kernel::approximate_plane_through_wire(const TopoDS_Wire& wire, gp_Pln& plane) {
// Newell's Method is used for the normal calculation
// as a simple edge cross product can give opposite results
// for a concave face boundary.
// Reference: Graphics Gems III p. 231
double x = 0, y = 0, z = 0;
gp_Pnt current, previous, first;
gp_XYZ center;
int n = 0;
BRepTools_WireExplorer exp(wire);
for (;; exp.Next()) {
const bool has_more = exp.More() != 0;
if (has_more) {
const TopoDS_Vertex& v = exp.CurrentVertex();
current = BRep_Tool::Pnt(v);
center += current.XYZ();
} else {
current = first;
}
if (n) {
const double& xn = previous.X();
const double& yn = previous.Y();
const double& zn = previous.Z();
const double& xn1 = current.X();
const double& yn1 = current.Y();
const double& zn1 = current.Z();
x += (yn - yn1)*(zn + zn1);
y += (xn + xn1)*(zn - zn1);
z += (xn - xn1)*(yn + yn1);
} else {
first = current;
}
if (!has_more) {
break;
}
previous = current;
++n;
}
if (n < 3) {
return false;
}
plane = gp_Pln(center / n, gp_Dir(x, y, z));
return true;
}
bool IfcGeom::Kernel::flatten_wire(TopoDS_Wire& wire) {
gp_Pln pln;
if (!approximate_plane_through_wire(wire, pln)) {
return false;
}
TopoDS_Face face = BRepBuilderAPI_MakeFace(pln).Face();
BRepAlgo_NormalProjection proj(face);
proj.Add(wire);
proj.Build();
if (!proj.IsDone()) {
return false;
}
TopTools_ListOfShape list;
proj.BuildWire(list);
if (list.Extent() != 1) {
return false;
}
wire = TopoDS::Wire(list.First());
return true;
}
TopoDS_Shape IfcGeom::Kernel::apply_transformation(const TopoDS_Shape& s, const gp_Trsf& t) {
if (t.Form() == gp_Identity) {
return s;
} else {
/// @todo set to 1. and exactly 1. or use epsilon?
if (t.ScaleFactor() != 1.) {
return BRepBuilderAPI_Transform(s, t, true);
} else {
return s.Moved(t);
}
}
}
TopoDS_Shape IfcGeom::Kernel::apply_transformation(const TopoDS_Shape& s, const gp_GTrsf& t) {
if (t.Form() == gp_Other) {
return BRepBuilderAPI_GTransform(s, t, true);
} else {
return apply_transformation(s, t.Trsf());
}
}