Glassvision/IfcOpenShell
1
0
Fork 0
mirror of https://github.com/IfcOpenShell/IfcOpenShell.git synced 2026-08-11 02:02:22 +00:00
Code Issues Packages Projects Releases Wiki Activity

Wrap more classes into ifcopenshell:: namespace

Browse Source
This commit is contained in:
Thomas Krijnen
2026-08-08 13:58:39 +02:00
parent 2c47c9d4fa
commit 02481b3247
149 changed files with 678 additions and 627 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/bonsaiviewer/modules/models/Commands.cpp
+2 -2
View File
@@ -685,7 +685,7 @@ void convertIfcToDatabase(SessionState& session, QWidget& host) {
throw ifcopenshell::exception("RDB serializer does not support streaming from an input filename");
}
boost::shared_ptr<serializer> serializer = registry.create("rdb", context);
boost::shared_ptr<ifcopenshell::geom::serializer> serializer = registry.create("rdb", context);
serializer->finalize();
} catch (const std::exception& e) {
*error_message = QString::fromUtf8(e.what());
@@ -791,7 +791,7 @@ void exportGeometryDatabase(SessionState& session, QWidget& host) {
throw ifcopenshell::exception("RDB serializer does not support streaming from an input filename");
}
boost::shared_ptr<serializer> serializer = registry.create("rdb", context);
boost::shared_ptr<ifcopenshell::geom::serializer> serializer = registry.create("rdb", context);
serializer->finalize();
serializer.reset();
src/bonsaiviewer/modules/models/SettingsView.cpp
+2 -2
View File
@@ -75,10 +75,10 @@ QString formatCachedUnitScale(double meters_per_unit) {
return QString("Cached scale: 1 unit = %1 m").arg(formatNumber(meters_per_unit));
}
std::string enumString(const attribute_value& av) {
std::string enumString(const ifcopenshell::attribute_value& av) {
if (av.isNull()) return {};
if (av.type() != ifcopenshell::Argument_ENUMERATION) return {};
enumeration_reference enumeration = av;
ifcopenshell::enumeration_reference enumeration = av;
return std::string(enumeration.value() ? enumeration.value() : "");
}
src/examples/IfcParseExamples.cpp
+2 -2
View File
@@ -70,7 +70,7 @@ typedef IfcSchema::IfcBuildingElement element_t;
typedef IfcSchema::IfcBuiltElement element_t;
#endif
std::string format_string(const attribute_value& argument) {
std::string format_string(const ifcopenshell::attribute_value& argument) {
// Argument is a runtime tagged variant for the various data types in a IFC model,
// in this particular case we only care about flattening it to a string.
// @todo mostly duplicated from XmlSerializer.cpp
@@ -213,7 +213,7 @@ int main(int argc, char** argv) {
#endif
// Redirect the output (both progress and log) to stdout
::logger::root().set_output(&std::cout, &std::cout);
ifcopenshell::logger::root().set_output(&std::cout, &std::cout);
// Parse the IFC file provided in argv[1]
ifcopenshell::file file(argv[1]);
src/helpers/element.cpp
+4 -4
View File
@@ -52,7 +52,7 @@ std::string schema_name(const express::base& instance) {
// A primitive scalar attribute value formatted for display, or std::nullopt for
// IFC null and for non-primitive values (entity references, aggregates/lists,
// binary) — which the properties UI omits.
std::optional<std::string> format_scalar(const attribute_value& value) {
std::optional<std::string> format_scalar(const ifcopenshell::attribute_value& value) {
if (value.isNull()) {
return std::nullopt;
}
@@ -60,7 +60,7 @@ std::optional<std::string> format_scalar(const attribute_value& value) {
case ifcopenshell::Argument_STRING:
return static_cast<std::string>(value);
case ifcopenshell::Argument_ENUMERATION: {
const enumeration_reference enumeration = value;
const ifcopenshell::enumeration_reference enumeration = value;
return enumeration.value() ? std::string(enumeration.value()) : std::string();
}
case ifcopenshell::Argument_INT:
@@ -288,13 +288,13 @@ std::optional<std::string> get_string_attribute(const express::base& element,
if (index < 0) {
return std::nullopt;
}
const attribute_value value = element.get_attribute_value(static_cast<std::size_t>(index));
const ifcopenshell::attribute_value value = element.get_attribute_value(static_cast<std::size_t>(index));
if (value.isNull()) {
return std::nullopt;
}
switch (value.type()) {
case ifcopenshell::Argument_ENUMERATION: {
const enumeration_reference enumeration = value;
const ifcopenshell::enumeration_reference enumeration = value;
return enumeration.value() ? std::string(enumeration.value()) : std::string();
}
case ifcopenshell::Argument_STRING:
src/helpers/placement.cpp
+1 -1
View File
@@ -144,7 +144,7 @@ double get_storey_elevation_s(const express::base& storey) {
if (declaration != nullptr) {
const std::ptrdiff_t index = declaration->attribute_index("Elevation");
if (index >= 0) {
const attribute_value value = storey.get_attribute_value(static_cast<std::size_t>(index));
const ifcopenshell::attribute_value value = storey.get_attribute_value(static_cast<std::size_t>(index));
if (!value.isNull() && value.type() == ifcopenshell::Argument_DOUBLE) {
return static_cast<double>(value);
}
src/helpers/pset.cpp
+3 -3
View File
@@ -69,7 +69,7 @@ std::string schema_name(const express::base& instance) {
throw ifcopenshell::exception("No helper implementation was built for schema " + name);
}
property_value from_attribute(const attribute_value& value);
property_value from_attribute(const ifcopenshell::attribute_value& value);
template <typename T>
property_list scalar_list(const std::vector<T>& values) {
@@ -81,7 +81,7 @@ property_list scalar_list(const std::vector<T>& values) {
return result;
}
property_value from_attribute(const attribute_value& value) {
property_value from_attribute(const ifcopenshell::attribute_value& value) {
if (value.isNull()) {
return {};
}
@@ -103,7 +103,7 @@ property_value from_attribute(const attribute_value& value) {
case ifcopenshell::Argument_STRING:
return static_cast<std::string>(value);
case ifcopenshell::Argument_ENUMERATION: {
const enumeration_reference enumeration = value;
const ifcopenshell::enumeration_reference enumeration = value;
return enumeration.value() ? enumeration.value() : "";
}
case ifcopenshell::Argument_BINARY: {
src/ifcconvert/IfcConvert.cpp
+22 -22
View File
@@ -219,7 +219,7 @@ bool file_exists(const std::string& filename) {
static std::basic_stringstream<path_t::value_type> log_stream;
void write_log(bool);
void fix_quantities(ifcopenshell::file&, bool, bool, bool, logger& logger = ::logger::root());
void fix_quantities(ifcopenshell::file&, bool, bool, bool, ifcopenshell::logger& logger = ifcopenshell::logger::root());
std::string format_duration(time_t start, time_t end);
/// @todo make the filters non-global
@@ -249,7 +249,7 @@ size_t read_filters_from_file(const std::string&, inclusion_filter&, inclusion_t
void parse_filter(geom_filter &, const std::vector<std::string>&);
std::vector<ifcopenshell::geom::filter_t> setup_filters(const std::vector<geom_filter>&, const std::string&);
bool init_input_file(const std::string& filename, ifcopenshell::file*& ifc_file, bool no_progress, bool mmap, bool bypass_properties=false, logger& logger = ::logger::root());
bool init_input_file(const std::string& filename, ifcopenshell::file*& ifc_file, bool no_progress, bool mmap, bool bypass_properties=false, ifcopenshell::logger& logger = ifcopenshell::logger::root());
// from https://stackoverflow.com/questions/31696328/boost-program-options-using-zero-parameter-options-multiple-times
struct verbosity_counter {
@@ -271,7 +271,7 @@ int main(int argc, char** argv) {
typedef po::command_line_parser command_line_parser;
typedef char char_t;
#endif
logger logger;
ifcopenshell::logger logger;
inclusion_filter include_filter;
inclusion_traverse_filter include_traverse_filter;
@@ -471,9 +471,9 @@ int main(int argc, char** argv) {
if (vmap.count("log-format") == 1) {
boost::to_lower(log_format);
if (log_format == "plain") {
logger.output_format(::logger::FMT_PLAIN);
logger.output_format(ifcopenshell::logger::FMT_PLAIN);
} else if (log_format == "json") {
logger.output_format(::logger::FMT_JSON);
logger.output_format(ifcopenshell::logger::FMT_JSON);
} else {
cerr_ << "[error] --log-format should be either plain or json" << std::endl;
print_usage();
@@ -555,19 +555,19 @@ int main(int argc, char** argv) {
switch (vcounter.count) {
case 0:
logger.verbosity(::logger::LOG_ERROR);
logger.verbosity(ifcopenshell::logger::LOG_ERROR);
break;
case 1:
logger.verbosity(::logger::LOG_NOTICE);
logger.verbosity(ifcopenshell::logger::LOG_NOTICE);
break;
case 2:
logger.verbosity(::logger::LOG_DEBUG);
logger.verbosity(ifcopenshell::logger::LOG_DEBUG);
break;
case 3:
logger.verbosity(::logger::LOG_PERF);
logger.verbosity(ifcopenshell::logger::LOG_PERF);
break;
case 4:
logger.verbosity(::logger::LOG_PERF);
logger.verbosity(ifcopenshell::logger::LOG_PERF);
logger.print_performance_stats_on_element(true);
break;
}
@@ -618,7 +618,7 @@ int main(int argc, char** argv) {
context.schema_name = ifc_file ? ifc_file->schema()->name() : document_serializer_info->schema_name;
context.stream = use_input_filename;
boost::shared_ptr<serializer> serializer = document_serializer_registry.create(output_extension_utf8, context);
boost::shared_ptr<ifcopenshell::geom::serializer> serializer = document_serializer_registry.create(output_extension_utf8, context);
if (serializer->is_streaming() != use_input_filename) {
throw ifcopenshell::exception("Selected document serializer streaming mode does not match its registry metadata");
}
@@ -752,7 +752,7 @@ int main(int argc, char** argv) {
settings
};
boost::shared_ptr<geometry_serializer> serializer; /**< @todo use std::unique_ptr when possible */
boost::shared_ptr<ifcopenshell::geom::geometry_serializer> serializer; /**< @todo use std::unique_ptr when possible */
try {
geometry_serializer_registry.configure(output_extension_utf8, serializer_context);
serializer = geometry_serializer_registry.create(output_extension_utf8, serializer_context);
@@ -895,7 +895,7 @@ int main(int argc, char** argv) {
context_iterator.reset(new ifcopenshell::geom::iterator(ifcopenshell::geom::kernels::construct(ifc_file, geometry_kernel, settings), settings, ifc_file, filter_funcs, num_threads, logger));
}
logger.message(::logger::LOG_PERF, "file geometry conversion");
logger.message(ifcopenshell::logger::LOG_PERF, "file geometry conversion");
if (context_iterator && !context_iterator->initialize()) {
/// @todo It would be nice to know and print separate error prints for a case where we found no entities
@@ -965,7 +965,7 @@ int main(int argc, char** argv) {
if (stderr_progress)
cerr_ << std::flush;
} else if (vcounter.count == 2) {
logger.message(::logger::LOG_DEBUG, "SYS", 23, "Progress " + boost::lexical_cast<std::string>(progress));
logger.message(ifcopenshell::logger::LOG_DEBUG, "SYS", 23, "Progress " + boost::lexical_cast<std::string>(progress));
} else {
progress = progress / 2;
if (old_progress != progress) logger.progress_bar(progress);
@@ -1005,7 +1005,7 @@ int main(int argc, char** argv) {
// Make sure the dtor is explicitly run here (e.g. output files are closed before renaming them).
serializer.reset();
logger.message(::logger::LOG_PERF, "GEO", 26, "done file geometry conversion");
logger.message(ifcopenshell::logger::LOG_PERF, "GEO", 26, "done file geometry conversion");
bool successful;
if (geometry_serializer_info->writes_final_output) {
@@ -1023,17 +1023,17 @@ int main(int argc, char** argv) {
output_temp_filename << "' for the conversion result.";
}
if (settings.get<ifcopenshell::geom::settings::ValidateQuantities>().get() && logger.max_severity() >= ::logger::LOG_ERROR) {
if (settings.get<ifcopenshell::geom::settings::ValidateQuantities>().get() && logger.max_severity() >= ifcopenshell::logger::LOG_ERROR) {
logger.error("SYS", 24, "Errors encountered during processing.");
successful = false;
}
if (fail_on_error && logger.max_severity() >= ::logger::LOG_ERROR) {
if (fail_on_error && logger.max_severity() >= ifcopenshell::logger::LOG_ERROR) {
logger.error("SYS", 26, "Errors encountered during processing, failing due to --fail-on-error.");
successful = false;
}
if (logger.verbosity() == ::logger::LOG_PERF) {
if (logger.verbosity() == ifcopenshell::logger::LOG_PERF) {
logger.print_performance_stats();
}
@@ -1080,7 +1080,7 @@ void write_log(bool header) {
#include <boost/algorithm/string/predicate.hpp>
bool init_input_file(const std::string& filename, ifcopenshell::file*& ifc_file, bool no_progress, bool mmap, bool bypass_properties, logger& logger) {
bool init_input_file(const std::string& filename, ifcopenshell::file*& ifc_file, bool no_progress, bool mmap, bool bypass_properties, ifcopenshell::logger& logger) {
time_t start, end;
// Prevent file::Init() prints by setting output to null temporarily
@@ -1314,7 +1314,7 @@ namespace latebound_access {
enum_type->enumeration_items().end(),
t);
return set(inst, attr, enumeration_reference(enum_type, it - enum_type->enumeration_items().begin()));
return set(inst, attr, ifcopenshell::enumeration_reference(enum_type, it - enum_type->enumeration_items().begin()));
}
template <typename T>
@@ -1323,7 +1323,7 @@ namespace latebound_access {
auto i = decl->attribute_index(attr);
auto attr_type = decl->attribute_by_index(i)->type_of_attribute();
if (attr_type->as_named_type() && attr_type->as_named_type()->declared_type()->as_enumeration_type() && !std::is_same<T, enumeration_reference>::value) {
if (attr_type->as_named_type() && attr_type->as_named_type()->declared_type()->as_enumeration_type() && !std::is_same<T, ifcopenshell::enumeration_reference>::value) {
set_enumeration(inst, attr, attr_type->as_named_type()->declared_type()->as_enumeration_type(), t);
} else {
inst.set_attribute_value(i, t);
@@ -1336,7 +1336,7 @@ namespace latebound_access {
}
}
void fix_quantities(ifcopenshell::file& f, bool no_progress, bool quiet, bool stderr_progress, logger& logger) {
void fix_quantities(ifcopenshell::file& f, bool no_progress, bool quiet, bool stderr_progress, ifcopenshell::logger& logger) {
{
auto delete_reversed = [&f](const std::vector<express::base>& insts) {
// Lists are traversed back to front as the list may be mutated when
src/ifcconvert/validate_space_boundaries.cpp
+1 -1
View File
@@ -18,7 +18,7 @@ typedef CGAL::AABB_traits<Kernel_, Primitive> Traits;
typedef CGAL::AABB_tree<Traits> Tree;
typedef Tree::Point_and_primitive_id Point_and_primitive_id;
void fix_spaceboundaries(ifcopenshell::file& f, bool no_progress, bool quiet, bool stderr_progress, logger& logger = ::logger::root()) {
void fix_spaceboundaries(ifcopenshell::file& f, bool no_progress, bool quiet, bool stderr_progress, ifcopenshell::logger& logger = ifcopenshell::logger::root()) {
intersection_validator v(f, { "IfcWall", "IfcSpace", "IfcSlab", "IfcCovering" }, 1.e-5, no_progress, quiet, stderr_progress, logger);
auto rels = f.instances_by_type("IfcRelSpaceBoundary");
src/ifcconvert/validate_storey_containment.cpp
+1 -1
View File
@@ -9,7 +9,7 @@
#include <algorithm>
void fix_storeycontainment(ifcopenshell::file& f, bool no_progress, bool quiet, bool stderr_progress, logger& logger = ::logger::root()) {
void fix_storeycontainment(ifcopenshell::file& f, bool no_progress, bool quiet, bool stderr_progress, ifcopenshell::logger& logger = ifcopenshell::logger::root()) {
ifcopenshell::geom::settings settings;
settings.get<ifcopenshell::geom::settings::UseWorldCoords>().value = false;
src/ifcconvert/validate_wall_connectivity.cpp
+1 -1
View File
@@ -9,7 +9,7 @@
using namespace ifcopenshell::geom;
void fix_wallconnectivity(ifcopenshell::file& f, bool no_progress, bool quiet, bool stderr_progress, logger& logger = ::logger::root()) {
void fix_wallconnectivity(ifcopenshell::file& f, bool no_progress, bool quiet, bool stderr_progress, ifcopenshell::logger& logger = ifcopenshell::logger::root()) {
intersection_validator v(f, { "IfcWall" }, 1.e-3, no_progress, quiet, stderr_progress, logger);
ifcopenshell::geom::settings settings;
src/ifcconvert/validation_utils.h
+1 -1
View File
@@ -446,7 +446,7 @@ struct intersection_validator {
std::set<const ifcopenshell::IfcBaseEntity*> successfully_processed;
intersection_validator(ifcopenshell::file& f, std::initializer_list<std::string> entities, double eps, bool no_progress, bool quiet, bool stderr_progress, logger& logger = ::logger::root()) {
intersection_validator(ifcopenshell::file& f, std::initializer_list<std::string> entities, double eps, bool no_progress, bool quiet, bool stderr_progress, ifcopenshell::logger& logger = ifcopenshell::logger::root()) {
ifcopenshell::geom::settings settings;
settings.get<ifcopenshell::geom::settings::UseWorldCoords>().value = false;
src/ifcgeom/AbstractKernel.h
+6 -6
View File
@@ -66,12 +66,12 @@ namespace ifcopenshell {
protected:
std::string geometry_library_;
ifcopenshell::geom::settings settings_;
::logger& logger_;
ifcopenshell::logger& logger_;
public:
bool propagate_exceptions = false;
bool partial_success_is_success = true;
abstract_kernel(const std::string& geometry_library, const ifcopenshell::geom::settings& settings, ::logger& logger = ::logger::root())
abstract_kernel(const std::string& geometry_library, const ifcopenshell::geom::settings& settings, ifcopenshell::logger& logger = ifcopenshell::logger::root())
: geometry_library_(geometry_library)
, settings_(settings)
, logger_(logger) {}
@@ -89,7 +89,7 @@ namespace ifcopenshell {
virtual bool accepts(const ifcopenshell::geom::conversion_result_shape& shape) const {
return shape.backend_id() == backend_id();
}
::logger& logger() const { return logger_; }
ifcopenshell::logger& logger() const { return logger_; }
virtual bool supports_boolean_operations() const = 0;
@@ -137,7 +137,7 @@ namespace ifcopenshell {
const ifcopenshell::geom::conversion_results& entity_shapes, const ifcopenshell::geom::taxonomy::matrix4& entity_trsf, ifcopenshell::geom::conversion_results& cut_shapes) = 0;
virtual bool unify_shapes(const ifcopenshell::geom::conversion_results&, ifcopenshell::geom::conversion_results&) { throw not_implemented_error(); }
virtual abstract_kernel* clone(::logger& logger) const = 0;
virtual abstract_kernel* clone(ifcopenshell::logger& logger) const = 0;
};
}
}
@@ -229,7 +229,7 @@ namespace {
template <typename T>
struct dispatch_curve_creation<T, ifcopenshell::geom::taxonomy::curves::max> {
static bool dispatch(const ifcopenshell::geom::taxonomy::ptr& item, T&) {
::logger::root().error("GEO", 28, "No conversion for " + std::to_string(item->kind()));
ifcopenshell::logger::root().error("GEO", 28, "No conversion for " + std::to_string(item->kind()));
return false;
}
};
@@ -251,7 +251,7 @@ namespace {
template <typename T>
struct dispatch_surface_creation<T, ifcopenshell::geom::taxonomy::surfaces::max> {
static bool dispatch(const ifcopenshell::geom::taxonomy::ptr& item, T&) {
::logger::root().error("GEO", 29, "No conversion for " + std::to_string(item->kind()));
ifcopenshell::logger::root().error("GEO", 29, "No conversion for " + std::to_string(item->kind()));
return false;
}
};
src/ifcgeom/ConversionResult.cpp
+1 -1
View File
@@ -1,7 +1,7 @@
#include "ConversionResult.h"
#include "IfcGeomRepresentation.h"
ifcopenshell::geom::Representation::triangulation* ifcopenshell::geom::conversion_result_shape::Triangulate(const ifcopenshell::geom::settings& settings, ::logger& logger) const
ifcopenshell::geom::Representation::triangulation* ifcopenshell::geom::conversion_result_shape::Triangulate(const ifcopenshell::geom::settings& settings, ifcopenshell::logger& logger) const
{
auto t = ifcopenshell::geom::Representation::triangulation::empty(settings);
static ifcopenshell::geom::taxonomy::matrix4 iden;
src/ifcgeom/ConversionResult.h
+2 -2
View File
@@ -509,8 +509,8 @@ namespace ifcopenshell::geom {
#else
virtual std::string_view backend_id() const = 0;
#endif
virtual void Triangulate(ifcopenshell::geom::settings settings, const ifcopenshell::geom::taxonomy::matrix4& place, Representation::triangulation* t, int item_id, int surface_style_id, ::logger& logger = ::logger::root()) const = 0;
ifcopenshell::geom::Representation::triangulation* Triangulate(const ifcopenshell::geom::settings& settings, ::logger& logger = ::logger::root()) const;
virtual void Triangulate(ifcopenshell::geom::settings settings, const ifcopenshell::geom::taxonomy::matrix4& place, Representation::triangulation* t, int item_id, int surface_style_id, ifcopenshell::logger& logger = ifcopenshell::logger::root()) const = 0;
ifcopenshell::geom::Representation::triangulation* Triangulate(const ifcopenshell::geom::settings& settings, ifcopenshell::logger& logger = ifcopenshell::logger::root()) const;
virtual void Serialize(const ifcopenshell::geom::taxonomy::matrix4& place, std::string&) const = 0;
virtual int surface_genus() const = 0;
src/ifcgeom/Converter.cpp
+13 -13
View File
@@ -4,7 +4,7 @@
using namespace ifcopenshell::geom;
ifcopenshell::geom::converter::converter(std::unique_ptr<ifcopenshell::geom::kernels::abstract_kernel>&& geometry_library, ifcopenshell::file* file, ifcopenshell::geom::settings& settings, ::logger& logger)
ifcopenshell::geom::converter::converter(std::unique_ptr<ifcopenshell::geom::kernels::abstract_kernel>&& geometry_library, ifcopenshell::file* file, ifcopenshell::geom::settings& settings, ifcopenshell::logger& logger)
: kernel_(std::move(geometry_library))
, logger_(logger)
{
@@ -18,7 +18,7 @@ ifcopenshell::geom::converter::~converter() {
}
namespace {
void substitute_with_box_based_on_density(::logger& logger, ifcopenshell::geom::conversion_results& items, double& density) {
void substitute_with_box_based_on_density(ifcopenshell::logger& logger, ifcopenshell::geom::conversion_results& items, double& density) {
int nv = 0;
void* box = nullptr;
double volume = 0.;
@@ -102,7 +102,7 @@ ifcopenshell::geom::brep_element* ifcopenshell::geom::converter::create_brep_for
}
if (!success) {
::logger::root().error("Failed processing layerset");
ifcopenshell::logger::root().error("Failed processing layerset");
}
}
}
@@ -219,10 +219,10 @@ ifcopenshell::geom::brep_element* ifcopenshell::geom::converter::create_brep_for
kernel_->convert_openings(product, opening_items, shapes, *place, opened_shapes);
}
} catch (const std::exception& e) {
logger_.message(::logger::LOG_ERROR, "GEO", 33, std::string("Error processing openings for: ") + e.what() + ":", product);
logger_.message(ifcopenshell::logger::LOG_ERROR, "GEO", 33, std::string("Error processing openings for: ") + e.what() + ":", product);
caught_error = true;
} catch (...) {
logger_.message(::logger::LOG_ERROR, "GEO", 34, "Error processing openings for:", product);
logger_.message(ifcopenshell::logger::LOG_ERROR, "GEO", 34, "Error processing openings for:", product);
}
if (!(caught_error && opened_shapes.size() < shapes.size())) {
@@ -306,12 +306,12 @@ ifcopenshell::geom::brep_element* ifcopenshell::geom::converter::create_brep_for
if (elem->geometry().calculate_surface_area(a_calc)) {
double diff = std::abs(a_calc - a_file);
if (diff / std::sqrt(a_file) > getValue(GV_PRECISION)) {
::logger::root().error("Validation of surface area failed for:", product);
ifcopenshell::logger::root().error("Validation of surface area failed for:", product);
} else {
::logger::root().notice("Validation of surface area succeeded for:", product);
ifcopenshell::logger::root().notice("Validation of surface area succeeded for:", product);
}
} else {
::logger::root().error("Validation of surface area failed for:", product);
ifcopenshell::logger::root().error("Validation of surface area failed for:", product);
}
} else if (q->as<IfcSchema::IfcQuantityVolume>() && q->Name() == "Volume") {
double v_calc;
@@ -319,12 +319,12 @@ ifcopenshell::geom::brep_element* ifcopenshell::geom::converter::create_brep_for
if (elem->geometry().calculate_volume(v_calc)) {
double diff = std::abs(v_calc - v_file);
if (diff / std::sqrt(v_file) > getValue(GV_PRECISION)) {
::logger::root().error("Validation of volume failed for:", product);
ifcopenshell::logger::root().error("Validation of volume failed for:", product);
} else {
::logger::root().notice("Validation of volume succeeded for:", product);
ifcopenshell::logger::root().notice("Validation of volume succeeded for:", product);
}
} else {
::logger::root().error("Validation of volume failed for:", product);
ifcopenshell::logger::root().error("Validation of volume failed for:", product);
}
} else if (q->as<IfcSchema::IfcPhysicalComplexQuantity>() && q->Name() == "Shape Validation Properties") {
auto qs2 = q->as<IfcSchema::IfcPhysicalComplexQuantity>()->HasQuantities();
@@ -343,9 +343,9 @@ ifcopenshell::geom::brep_element* ifcopenshell::geom::converter::create_brep_for
}
}
if (!all_succeeded) {
::logger::root().error("Validation of surface genus failed for:", product);
ifcopenshell::logger::root().error("Validation of surface genus failed for:", product);
} else {
::logger::root().notice("Validation of surface genus succeeded for:", product);
ifcopenshell::logger::root().notice("Validation of surface genus succeeded for:", product);
}
}
}
src/ifcgeom/Converter.h
+3 -3
View File
@@ -21,17 +21,17 @@ namespace ifcopenshell { namespace geom {
std::unique_ptr<ifcopenshell::geom::kernels::abstract_kernel> kernel_;
ifcopenshell::geom::settings settings_;
std::map<ifcopenshell::geom::taxonomy::ptr, brep_ptr, ifcopenshell::geom::taxonomy::less_functor> cache_;
::logger& logger_;
ifcopenshell::logger& logger_;
public:
ifcopenshell::geom::kernels::abstract_kernel* kernel() { return &*kernel_; }
converter(std::unique_ptr<ifcopenshell::geom::kernels::abstract_kernel>&& geometry_library, ifcopenshell::file* file, ifcopenshell::geom::settings& settings, ::logger& logger = ::logger::root());
converter(std::unique_ptr<ifcopenshell::geom::kernels::abstract_kernel>&& geometry_library, ifcopenshell::file* file, ifcopenshell::geom::settings& settings, ifcopenshell::logger& logger = ifcopenshell::logger::root());
~converter();
ifcopenshell::geom::abstract_mapping* mapping() const { return mapping_; }
::logger& logger() const { return logger_; }
ifcopenshell::logger& logger() const { return logger_; }
/*
virtual NativeElement<double, double>* convert(
src/ifcgeom/GeometrySerializer.h
+7 -3
View File
@@ -62,12 +62,14 @@ public:
}
};
namespace ifcopenshell::geom {
class IFC_GEOM_API geometry_serializer : public serializer {
public:
enum read_type { READ_BREP, READ_TRIANGULATION };
geometry_serializer(const ifcopenshell::geom::settings& settings, ::logger* logger = nullptr)
: serializer(logger_or_root(logger))
geometry_serializer(const ifcopenshell::geom::settings& settings, ifcopenshell::logger* logger = nullptr)
: serializer(ifcopenshell::logger_or_root(logger))
, settings_(settings)
{}
virtual ~geometry_serializer() {}
@@ -96,11 +98,13 @@ protected:
class IFC_GEOM_API write_only_geometry_serializer : public geometry_serializer {
public:
write_only_geometry_serializer(const ifcopenshell::geom::settings& settings, ::logger* logger = nullptr) : geometry_serializer(settings, logger) {}
write_only_geometry_serializer(const ifcopenshell::geom::settings& settings, ifcopenshell::logger* logger = nullptr) : geometry_serializer(settings, logger) {}
virtual ifcopenshell::geom::element* read(ifcopenshell::file&, const std::string&, const std::string&, read_type = READ_BREP) {
throw std::runtime_error("Not supported");
};
};
} // namespace ifcopenshell::geom
#endif
src/ifcgeom/IfcGeomElement.h
+1 -1
View File
@@ -126,7 +126,7 @@ namespace ifcopenshell::geom {
oss << "product-" << ifcopenshell::global_id(guid).formatted();
} catch (const std::exception& e) {
oss << "product";
::logger::root().error("GEO", 39, e);
ifcopenshell::logger::root().error("GEO", 39, e);
}
}
src/ifcgeom/Iterator.cpp
+6 -6
View File
@@ -204,11 +204,11 @@ void ifcopenshell::geom::iterator::process_concurrently() {
worker_loggers_.reserve(conc_threads);
for (unsigned i = 0; i < conc_threads; ++i) {
worker_loggers_.emplace_back(std::make_unique<logger>());
::logger& worker_logger = *worker_loggers_.back();
ifcopenshell::logger& worker_logger = *worker_loggers_.back();
worker_logger.verbosity(logger_.verbosity());
worker_logger.output_format(logger_.output_format());
worker_logger.print_performance_stats_on_element(logger_.print_performance_stats_on_element());
if (worker_logger.output_format() != ::logger::FMT_INMEMORY) {
if (worker_logger.output_format() != ifcopenshell::logger::FMT_INMEMORY) {
worker_logger.set_output(static_cast<std::ostream*>(nullptr), static_cast<std::ostream*>(nullptr));
}
kernel_pool.push_back(new ifcopenshell::geom::converter(std::unique_ptr<ifcopenshell::geom::kernels::abstract_kernel>(converter_->kernel()->clone(worker_logger)), ifc_file, settings_, worker_logger));
@@ -362,7 +362,7 @@ express::base ifcopenshell::geom::iterator::create_shape_model_for_next_entity()
void ifcopenshell::geom::iterator::create_element_(ifcopenshell::geom::converter* kernel, ifcopenshell::geom::settings settings, geometry_conversion_result* rep)
{
::logger& kernel_logger = kernel->logger();
ifcopenshell::logger& kernel_logger = kernel->logger();
if (!settings_.get<ifcopenshell::geom::settings::NoParallelMapping>().get()) {
rep->item = kernel->mapping()->map(rep->representation);
@@ -422,13 +422,13 @@ void ifcopenshell::geom::iterator::create_element_(ifcopenshell::geom::converter
kernel_logger.set_product(std::optional<express::base>{});
}
ifcopenshell::geom::element* ifcopenshell::geom::iterator::process_based_on_settings(ifcopenshell::geom::settings settings, ifcopenshell::geom::brep_element* elem, ::logger& logger, ifcopenshell::geom::triangulation_element* previous)
ifcopenshell::geom::element* ifcopenshell::geom::iterator::process_based_on_settings(ifcopenshell::geom::settings settings, ifcopenshell::geom::brep_element* elem, ifcopenshell::logger& logger, ifcopenshell::geom::triangulation_element* previous)
{
if (settings.get<ifcopenshell::geom::settings::IteratorOutput>().get() == ifcopenshell::geom::settings::SERIALIZED) {
try {
return new ifcopenshell::geom::serialized_element(*elem);
} catch (...) {
logger.message(::logger::LOG_ERROR, "GEO", 54, "Getting a serialized element from model failed.");
logger.message(ifcopenshell::logger::LOG_ERROR, "GEO", 54, "Getting a serialized element from model failed.");
return nullptr;
}
} else if (settings.get<ifcopenshell::geom::settings::IteratorOutput>().get() == ifcopenshell::geom::settings::TRIANGULATED) {
@@ -440,7 +440,7 @@ ifcopenshell::geom::element* ifcopenshell::geom::iterator::process_based_on_sett
return new triangulation_element(*elem, previous->geometry_pointer());
}
} catch (...) {
logger.message(::logger::LOG_ERROR, "GEO", 55, "Getting a triangulation element from model failed.");
logger.message(ifcopenshell::logger::LOG_ERROR, "GEO", 55, "Getting a triangulation element from model failed.");
}
return (triangulation_element*)nullptr;
});
src/ifcgeom/Iterator.h
+6 -6
View File
@@ -128,14 +128,14 @@ namespace ifcopenshell::geom {
std::vector<ifcopenshell::geom::filter_t> filters_;
int num_threads_;
std::string geometry_library_;
::logger& logger_;
ifcopenshell::logger& logger_;
// When single-threaded
ifcopenshell::geom::converter* converter_;
// When multi-threaded
std::vector<ifcopenshell::geom::converter*> kernel_pool;
std::vector<std::unique_ptr<::logger>> worker_loggers_;
std::vector<std::unique_ptr<ifcopenshell::logger>> worker_loggers_;
// The object is fetched beforehand to be sure that get() returns a valid element
triangulation_element* current_triangulation;
@@ -170,7 +170,7 @@ namespace ifcopenshell::geom {
ifcopenshell::geom::element* process_based_on_settings(
ifcopenshell::geom::settings settings,
ifcopenshell::geom::brep_element* elem,
::logger& logger,
ifcopenshell::logger& logger,
ifcopenshell::geom::triangulation_element* previous = nullptr);
void flush_worker_log(ifcopenshell::geom::converter* kernel);
@@ -183,7 +183,7 @@ namespace ifcopenshell::geom {
ifcopenshell::geom::taxonomy::direction3::ptr remove_offset_();
public:
iterator(std::unique_ptr<ifcopenshell::geom::kernels::abstract_kernel>&& geometry_library, const ifcopenshell::geom::settings& settings, ifcopenshell::file* file, const std::vector<ifcopenshell::geom::filter_t>& filters, int num_threads, ::logger& logger = ::logger::root())
iterator(std::unique_ptr<ifcopenshell::geom::kernels::abstract_kernel>&& geometry_library, const ifcopenshell::geom::settings& settings, ifcopenshell::file* file, const std::vector<ifcopenshell::geom::filter_t>& filters, int num_threads, ifcopenshell::logger& logger = ifcopenshell::logger::root())
: settings_(settings)
, ifc_file(file)
, filters_(filters)
@@ -195,7 +195,7 @@ namespace ifcopenshell::geom {
{
}
iterator(std::unique_ptr<ifcopenshell::geom::kernels::abstract_kernel>&& geometry_library, const ifcopenshell::geom::settings& settings, ifcopenshell::file* file, ::logger& logger = ::logger::root())
iterator(std::unique_ptr<ifcopenshell::geom::kernels::abstract_kernel>&& geometry_library, const ifcopenshell::geom::settings& settings, ifcopenshell::file* file, ifcopenshell::logger& logger = ifcopenshell::logger::root())
: settings_(settings)
, ifc_file(file)
, num_threads_(1)
@@ -205,7 +205,7 @@ namespace ifcopenshell::geom {
{
}
iterator(std::unique_ptr<ifcopenshell::geom::kernels::abstract_kernel>&& geometry_library, const ifcopenshell::geom::settings& settings, ifcopenshell::file* file, int num_threads, ::logger& logger = ::logger::root())
iterator(std::unique_ptr<ifcopenshell::geom::kernels::abstract_kernel>&& geometry_library, const ifcopenshell::geom::settings& settings, ifcopenshell::file* file, int num_threads, ifcopenshell::logger& logger = ifcopenshell::logger::root())
: settings_(settings)
, ifc_file(file)
, num_threads_(num_threads)
src/ifcgeom/Serializer.h
+7 -3
View File
@@ -23,13 +23,15 @@
#include "ifc_geom_api.h"
#include "../ifcparse/file.h"
namespace ifcopenshell::geom {
class IFC_GEOM_API serializer {
::logger& logger_;
ifcopenshell::logger& logger_;
public:
explicit serializer(::logger& logger = ::logger::root()) : logger_(logger) {}
explicit serializer(ifcopenshell::logger& logger = ifcopenshell::logger::root()) : logger_(logger) {}
virtual ~serializer() {}
::logger& logger() const { return logger_; }
ifcopenshell::logger& logger() const { return logger_; }
virtual bool ready() = 0;
virtual bool is_streaming() const { return false; }
@@ -38,4 +40,6 @@ public:
virtual void setFile(ifcopenshell::file&) = 0;
};
} // namespace ifcopenshell::geom
#endif
src/ifcgeom/abstract_mapping.cpp
+2 -2
View File
@@ -23,7 +23,7 @@ void ifcopenshell::geom::impl::mapping_registry::bind(const std::string& schema_
entry.module_ = module.meta().id.empty() ? plugin::module(mapping_plugin_metadata(schema_name)) : module;
}
ifcopenshell::geom::abstract_mapping* ifcopenshell::geom::impl::mapping_registry::construct(ifcopenshell::file* file, ifcopenshell::geom::settings& settings, ::logger& log) {
ifcopenshell::geom::abstract_mapping* ifcopenshell::geom::impl::mapping_registry::construct(ifcopenshell::file* file, ifcopenshell::geom::settings& settings, ifcopenshell::logger& log) {
const std::string schema_name_lower = boost::to_lower_copy(file->schema()->name());
auto it = entries_.find(schema_name_lower);
if (it == entries_.end()) {
@@ -56,6 +56,6 @@ void ifcopenshell::geom::impl::mapping_factory_implementation::bind(const std::s
mapping_registry_instance().bind(schema_name, fn, plugin::module(mapping_plugin_metadata(schema_name)));
}
ifcopenshell::geom::abstract_mapping* ifcopenshell::geom::impl::mapping_factory_implementation::construct(ifcopenshell::file* file, ifcopenshell::geom::settings& settings, ::logger& log) {
ifcopenshell::geom::abstract_mapping* ifcopenshell::geom::impl::mapping_factory_implementation::construct(ifcopenshell::file* file, ifcopenshell::geom::settings& settings, ifcopenshell::logger& log) {
return mapping_registry_instance().construct(file, settings, log);
}
src/ifcgeom/abstract_mapping.h
+6 -6
View File
@@ -49,12 +49,12 @@ namespace geom {
class IFC_GEOM_API abstract_mapping {
protected:
ifcopenshell::geom::settings settings_;
::logger& logger_;
ifcopenshell::logger& logger_;
bool use_caching_ = true;
public:
abstract_mapping(ifcopenshell::geom::settings& settings, ::logger& logger = ::logger::root()) : settings_(settings), logger_(logger) {}
abstract_mapping(ifcopenshell::geom::settings& settings, ifcopenshell::logger& logger = ifcopenshell::logger::root()) : settings_(settings), logger_(logger) {}
virtual ~abstract_mapping() {}
virtual ifcopenshell::geom::taxonomy::ptr map(const express::base&) = 0;
@@ -73,19 +73,19 @@ namespace geom {
const ifcopenshell::geom::settings& settings() const { return settings_; }
ifcopenshell::geom::settings& settings() { return settings_; }
::logger& logger() const { return logger_; }
ifcopenshell::logger& logger() const { return logger_; }
bool use_caching() const { return use_caching_; }
bool& use_caching() { return use_caching_; }
};
namespace impl {
typedef boost::function3<abstract_mapping*, ifcopenshell::file*, ifcopenshell::geom::settings&, ::logger&> mapping_fn;
typedef boost::function3<abstract_mapping*, ifcopenshell::file*, ifcopenshell::geom::settings&, ifcopenshell::logger&> mapping_fn;
class IFC_GEOM_API mapping_registry {
public:
void bind(const std::string& schema_name, mapping_fn fn, const ifcopenshell::plugin::module& module = ifcopenshell::plugin::module());
abstract_mapping* construct(ifcopenshell::file* file, ifcopenshell::geom::settings& settings, ::logger& logger = ::logger::root());
abstract_mapping* construct(ifcopenshell::file* file, ifcopenshell::geom::settings& settings, ifcopenshell::logger& logger = ifcopenshell::logger::root());
private:
struct entry {
@@ -102,7 +102,7 @@ namespace geom {
public:
mapping_factory_implementation();
void bind(const std::string& schema_name, mapping_fn);
abstract_mapping* construct(ifcopenshell::file*, ifcopenshell::geom::settings&, ::logger& logger = ::logger::root());
abstract_mapping* construct(ifcopenshell::file*, ifcopenshell::geom::settings&, ifcopenshell::logger& logger = ifcopenshell::logger::root());
};
IFC_GEOM_API mapping_factory_implementation& mapping_implementations();
src/ifcgeom/function_item_evaluator.h
+2 -2
View File
@@ -23,7 +23,7 @@ static taxonomy::function_item::ptr convert_loop_to_function_item(taxonomy::loop
/// @brief Abstract class for evaluating a function_item. This class is specialized for each of the function_item types.
struct IFC_GEOM_API fn_evaluator {
fn_evaluator(const ifcopenshell::geom::settings& settings, logger& logger = ::logger::root()) : settings_(settings), logger_(logger) {
fn_evaluator(const ifcopenshell::geom::settings& settings, logger& logger = ifcopenshell::logger::root()) : settings_(settings), logger_(logger) {
}
fn_evaluator(const fn_evaluator& other) = default;
virtual ~fn_evaluator() = default;
@@ -44,7 +44,7 @@ struct IFC_GEOM_API fn_evaluator {
/// @brief utility class to evaluate function_item objects.
class IFC_GEOM_API function_item_evaluator {
public:
function_item_evaluator(const ifcopenshell::geom::settings& settings, taxonomy::function_item::const_ptr fn, logger& logger = ::logger::root());
function_item_evaluator(const ifcopenshell::geom::settings& settings, taxonomy::function_item::const_ptr fn, logger& logger = ifcopenshell::logger::root());
function_item_evaluator(const function_item_evaluator& other);
~function_item_evaluator();
src/ifcgeom/hybrid_kernel.h
+2 -2
View File
@@ -32,7 +32,7 @@ namespace ifcopenshell {
ifcopenshell::geom::abstract_mapping* mapping_;
ifcopenshell::file* file_;
public:
hybrid_kernel(const std::string& name, ifcopenshell::file* file, ifcopenshell::geom::settings& settings, std::vector<std::unique_ptr<abstract_kernel>>&& kernels, ::logger& logger = ::logger::root())
hybrid_kernel(const std::string& name, ifcopenshell::file* file, ifcopenshell::geom::settings& settings, std::vector<std::unique_ptr<abstract_kernel>>&& kernels, ifcopenshell::logger& logger = ifcopenshell::logger::root())
: abstract_kernel(name, settings, logger)
, kernels_(std::move(kernels))
, mapping_(ifcopenshell::geom::impl::mapping_implementations().construct(file, settings, logger))
@@ -127,7 +127,7 @@ namespace ifcopenshell {
}
return false;
}
virtual abstract_kernel* clone(::logger& logger) const
virtual abstract_kernel* clone(ifcopenshell::logger& logger) const
{
std::vector<std::unique_ptr<abstract_kernel>> ks;
for (auto& k : kernels_) {
src/ifcgeom/infra_sweep_helper.h
+1 -1
View File
@@ -21,7 +21,7 @@ namespace ifcopenshell {
}
};
IFC_GEOM_API taxonomy::loft::ptr make_loft(const ifcopenshell::geom::settings& settings, const express::base inst, const taxonomy::function_item::ptr& directrix, std::vector<cross_section>& cross_sections, logger& logger = ::logger::root());
IFC_GEOM_API taxonomy::loft::ptr make_loft(const ifcopenshell::geom::settings& settings, const express::base inst, const taxonomy::function_item::ptr& directrix, std::vector<cross_section>& cross_sections, logger& logger = ifcopenshell::logger::root());
}
}
src/ifcgeom/kernels/cgal/CgalConversionResult.cpp
+10 -8
View File
@@ -12,6 +12,8 @@
using ifcopenshell::geom::opaque_number;
using ifcopenshell::geom::opaque_coordinate;
using ifcopenshell::geom::conversion_result_shape;
using ifcopenshell::geom::normalized_plane_for_map;
using ifcopenshell::geom::plane_map;
#ifdef IFOPSH_SIMPLE_KERNEL
#define NumberType opaque_number
@@ -266,7 +268,7 @@ namespace {
}
}
ifcopenshell::geom::cgal_shape::cgal_shape(const cgal_shape_t& shape, bool convex, ::logger& logger) {
ifcopenshell::geom::cgal_shape::cgal_shape(const cgal_shape_t& shape, bool convex, ifcopenshell::logger& logger) {
shape_ = shape;
convex_tag_ = convex;
auto& poly = std::get<cgal_shape_t>(*shape_);
@@ -362,7 +364,7 @@ void ifcopenshell::geom::cgal_shape::to_nef() const {
}
#endif
void ifcopenshell::geom::cgal_shape::Triangulate(ifcopenshell::geom::settings settings, const ifcopenshell::geom::taxonomy::matrix4& place, ifcopenshell::geom::Representation::triangulation* t, int item_id, int surface_style_id, ::logger& logger) const {
void ifcopenshell::geom::cgal_shape::Triangulate(ifcopenshell::geom::settings settings, const ifcopenshell::geom::taxonomy::matrix4& place, ifcopenshell::geom::Representation::triangulation* t, int item_id, int surface_style_id, ifcopenshell::logger& logger) const {
if (is_point() || is_wire()) {
return;
}
@@ -415,7 +417,7 @@ void ifcopenshell::geom::cgal_shape::Triangulate(ifcopenshell::geom::settings se
if (!all_triangles) {
if (!shape_to_use->is_valid()) {
logger.message(::logger::LOG_ERROR, "GEO", 64, "Invalid Polyhedron_3 in object (before triangulation)");
logger.message(ifcopenshell::logger::LOG_ERROR, "GEO", 64, "Invalid Polyhedron_3 in object (before triangulation)");
return;
}
@@ -423,19 +425,19 @@ void ifcopenshell::geom::cgal_shape::Triangulate(ifcopenshell::geom::settings se
try {
success = CGAL::Polygon_mesh_processing::triangulate_faces(*shape_to_use);
} catch (...) {
logger.message(::logger::LOG_ERROR, "GEO", 65, "Triangulation crashed");
logger.message(ifcopenshell::logger::LOG_ERROR, "GEO", 65, "Triangulation crashed");
return;
}
CGAL::Polygon_mesh_processing::remove_degenerate_faces(*shape_to_use);
if (!success) {
logger.message(::logger::LOG_ERROR, "GEO", 66, "Triangulation failed");
logger.message(ifcopenshell::logger::LOG_ERROR, "GEO", 66, "Triangulation failed");
return;
}
if (!shape_to_use->is_valid()) {
logger.message(::logger::LOG_ERROR, "GEO", 67, "Invalid Polyhedron_3 in object (after triangulation)");
logger.message(ifcopenshell::logger::LOG_ERROR, "GEO", 67, "Invalid Polyhedron_3 in object (after triangulation)");
return;
}
}
@@ -464,7 +466,7 @@ void ifcopenshell::geom::cgal_shape::Triangulate(ifcopenshell::geom::settings se
try {
CGAL::Polygon_mesh_processing::compute_face_normals(*shape_to_use, face_normals_map);
} catch (...) {
logger.message(::logger::LOG_ERROR, "GEO", 68, "Face normal calculation failed");
logger.message(ifcopenshell::logger::LOG_ERROR, "GEO", 68, "Face normal calculation failed");
return;
}
@@ -1033,7 +1035,7 @@ bool ifcopenshell::geom::cgal_shape::surface_area_along_direction(double tol, co
#ifndef IFOPSH_SIMPLE_KERNEL
void ifcopenshell::geom::cgal_shape_half_space_decomposition::Triangulate(ifcopenshell::geom::settings settings, const ifcopenshell::geom::taxonomy::matrix4& place, ifcopenshell::geom::Representation::triangulation* t, int item_id, int surface_style_id, ::logger& logger) const {
void ifcopenshell::geom::cgal_shape_half_space_decomposition::Triangulate(ifcopenshell::geom::settings settings, const ifcopenshell::geom::taxonomy::matrix4& place, ifcopenshell::geom::Representation::triangulation* t, int item_id, int surface_style_id, ifcopenshell::logger& logger) const {
throw std::runtime_error("Not implemented");
}
src/ifcgeom/kernels/cgal/CgalConversionResult.h
+3 -3
View File
@@ -188,7 +188,7 @@ namespace ifcopenshell { namespace geom {
#endif
public:
cgal_shape(const cgal_shape_t& shape, bool convex = false, ::logger& logger = ::logger::root());
cgal_shape(const cgal_shape_t& shape, bool convex = false, ifcopenshell::logger& logger = ifcopenshell::logger::root());
cgal_shape(const cgal_point_t& point, bool convex = false);
cgal_shape(const cgal_wire_t& wire, bool convex = false);
@@ -226,7 +226,7 @@ namespace ifcopenshell { namespace geom {
const cgal_point_t& point() const { return std::get<cgal_point_t>(*shape_); }
const cgal_wire_t& wire() const { return std::get<cgal_wire_t>(*shape_); }
virtual void Triangulate(ifcopenshell::geom::settings settings, const ifcopenshell::geom::taxonomy::matrix4& place, ifcopenshell::geom::Representation::triangulation* t, int item_id, int surface_style_id, ::logger& logger = ::logger::root()) const;
virtual void Triangulate(ifcopenshell::geom::settings settings, const ifcopenshell::geom::taxonomy::matrix4& place, ifcopenshell::geom::Representation::triangulation* t, int item_id, int surface_style_id, ifcopenshell::logger& logger = ifcopenshell::logger::root()) const;
virtual void Serialize(const ifcopenshell::geom::taxonomy::matrix4& place, std::string&) const;
virtual ifcopenshell::geom::conversion_result_shape* clone() const {
@@ -319,7 +319,7 @@ namespace ifcopenshell { namespace geom {
#endif
}
virtual void Triangulate(ifcopenshell::geom::settings settings, const ifcopenshell::geom::taxonomy::matrix4& place, ifcopenshell::geom::Representation::triangulation* t, int item_id, int surface_style_id, ::logger& logger = ::logger::root()) const;
virtual void Triangulate(ifcopenshell::geom::settings settings, const ifcopenshell::geom::taxonomy::matrix4& place, ifcopenshell::geom::Representation::triangulation* t, int item_id, int surface_style_id, ifcopenshell::logger& logger = ifcopenshell::logger::root()) const;
virtual void Serialize(const ifcopenshell::geom::taxonomy::matrix4& place, std::string&) const;
virtual int surface_genus() const;
src/ifcgeom/kernels/cgal/CgalKernel.cpp
+33 -32
View File
@@ -40,6 +40,7 @@
using namespace ifcopenshell::geom;
using namespace ifcopenshell::geom::kernels;
using ifcopenshell::logger;
namespace {
struct polyhedron_builder : public CGAL::Modifier_base<CGAL::Polyhedron_3<kernel_>::HalfedgeDS> {
@@ -48,7 +49,7 @@ namespace {
logger& logger_;
public:
std::optional<cgal_shape_t> from_soup;
polyhedron_builder(std::list<cgal_face_t> *face_list, logger& logger = ::logger::root());
polyhedron_builder(std::list<cgal_face_t> *face_list, logger& logger = ifcopenshell::logger::root());
void operator()(CGAL::Polyhedron_3<kernel_>::HalfedgeDS &hds);
};
}
@@ -76,7 +77,7 @@ CGAL::Polyhedron_3<kernel_> ifcopenshell::geom::utils::create_polyhedron(std::li
polyhedron.normalize_border();
if (!polyhedron.is_valid(false, 1)) {
logger.message(::logger::LOG_ERROR, "GEO", 69, "create_polyhedron: Polyhedron not valid!");
logger.message(ifcopenshell::logger::LOG_ERROR, "GEO", 69, "create_polyhedron: Polyhedron not valid!");
// std::ofstream fresult;
// fresult.open("/Users/ken/Desktop/invalid.off");
// fresult << polyhedron << std::endl;
@@ -97,11 +98,11 @@ CGAL::Polyhedron_3<kernel_> ifcopenshell::geom::utils::create_polyhedron(const C
nef_polyhedron.convert_to_polyhedron(polyhedron);
return polyhedron;
} catch (...) {
logger.message(::logger::LOG_ERROR, "GEO", 70, "Conversion from Nef to polyhedron failed!");
logger.message(ifcopenshell::logger::LOG_ERROR, "GEO", 70, "Conversion from Nef to polyhedron failed!");
return CGAL::Polyhedron_3<kernel_>();
}
} else {
logger.message(::logger::LOG_ERROR, "GEO", 71, "Nef polyhedron not simple: cannot create polyhedron!");
logger.message(ifcopenshell::logger::LOG_ERROR, "GEO", 71, "Nef polyhedron not simple: cannot create polyhedron!");
return CGAL::Polyhedron_3<kernel_>();
}
}
@@ -114,7 +115,7 @@ CGAL::Nef_polyhedron_3<kernel_> ifcopenshell::geom::utils::create_nef_polyhedron
CGAL::Polygon_mesh_processing::reverse_face_orientations(polyhedron);
}
} catch (CGAL::Failure_exception& e) {
logger.message(::logger::LOG_ERROR, "GEO", 72, e);
logger.message(ifcopenshell::logger::LOG_ERROR, "GEO", 72, e);
}
}
CGAL::Polygon_mesh_processing::triangulate_faces(polyhedron);
@@ -122,7 +123,7 @@ CGAL::Nef_polyhedron_3<kernel_> ifcopenshell::geom::utils::create_nef_polyhedron
try {
nef_polyhedron = CGAL::Nef_polyhedron_3<kernel_>(polyhedron);
} catch (...) {
logger.message(::logger::LOG_ERROR, "GEO", 73, "Conversion to Nef polyhedron failed!");
logger.message(ifcopenshell::logger::LOG_ERROR, "GEO", 73, "Conversion to Nef polyhedron failed!");
}
return nef_polyhedron;
}
@@ -137,7 +138,7 @@ CGAL::Nef_polyhedron_3<kernel_> ifcopenshell::geom::utils::create_nef_polyhedron
CGAL::Polygon_mesh_processing::reverse_face_orientations(polyhedron);
}
} catch (CGAL::Failure_exception& e) {
logger.message(::logger::LOG_ERROR, "GEO", 74, e);
logger.message(ifcopenshell::logger::LOG_ERROR, "GEO", 74, e);
}
}
@@ -148,11 +149,11 @@ CGAL::Nef_polyhedron_3<kernel_> ifcopenshell::geom::utils::create_nef_polyhedron
try {
nef_polyhedron = CGAL::Nef_polyhedron_3<kernel_>(polyhedron);
} catch (...) {
logger.message(::logger::LOG_ERROR, "GEO", 75, "Conversion to Nef polyhedron failed!");
logger.message(ifcopenshell::logger::LOG_ERROR, "GEO", 75, "Conversion to Nef polyhedron failed!");
}
return nef_polyhedron;
} else {
logger.message(::logger::LOG_ERROR, "GEO", 76, "Polyhedron not valid: cannot create Nef polyhedron!");
logger.message(ifcopenshell::logger::LOG_ERROR, "GEO", 76, "Polyhedron not valid: cannot create Nef polyhedron!");
return CGAL::Nef_polyhedron_3<kernel_>();
}
}
@@ -215,10 +216,10 @@ bool cgal_kernel::convert(const taxonomy::shell::ptr l, cgal_shape_t& shape) {
if (!success) {
if (this->partial_success_is_success) {
logger().message(::logger::LOG_WARNING, "Failed to convert face, skipping:", f->instance);
logger().message(ifcopenshell::logger::LOG_WARNING, "Failed to convert face, skipping:", f->instance);
continue;
} else {
logger().message(::logger::LOG_ERROR, "Failed to convert face:", f->instance);
logger().message(ifcopenshell::logger::LOG_ERROR, "Failed to convert face:", f->instance);
return false;
}
}
@@ -241,7 +242,7 @@ bool cgal_kernel::convert(const taxonomy::face::ptr face, std::list<cgal_face_t>
}
if (face->children.size() > 1 && num_outer_bounds > 1 && face->children.size() != num_outer_bounds) {
logger().message(::logger::LOG_ERROR, "GEO", 80, "Invalid configuration of boundaries for:", face->instance);
logger().message(ifcopenshell::logger::LOG_ERROR, "GEO", 80, "Invalid configuration of boundaries for:", face->instance);
return false;
}
@@ -254,7 +255,7 @@ bool cgal_kernel::convert(const taxonomy::face::ptr face, std::list<cgal_face_t>
cgal_wire_t wire;
if (!convert(bound, wire)) {
logger().message(::logger::LOG_ERROR, "GEO", 81, "Failed to process face boundary loop", bound->instance);
logger().message(ifcopenshell::logger::LOG_ERROR, "GEO", 81, "Failed to process face boundary loop", bound->instance);
return false;
}
@@ -796,7 +797,7 @@ bool cgal_kernel::convert(const taxonomy::loop::ptr loop, cgal_wire_t& result) {
}
if (do_segments_intersect(segments)) {
logger().message(::logger::LOG_WARNING, "GEO", 86, "Skipping self-intersecting loop", loop->instance);
logger().message(ifcopenshell::logger::LOG_WARNING, "GEO", 86, "Skipping self-intersecting loop", loop->instance);
return false;
}
@@ -824,7 +825,7 @@ bool cgal_kernel::convert(const taxonomy::loop::ptr loop, cgal_wire_t& result) {
*/
if (count < 3) {
logger().message(::logger::LOG_ERROR, "GEO", 87, "Not enough edges for:", loop->instance);
logger().message(ifcopenshell::logger::LOG_ERROR, "GEO", 87, "Not enough edges for:", loop->instance);
return false;
}
@@ -1003,7 +1004,7 @@ bool ifcopenshell::geom::kernels::cgal_kernel::convert_openings(const express::b
try {
a.convert_to_polyhedron(a_poly);
} catch (...) {
logger().message(::logger::LOG_ERROR, "GEO", 88, "Could not convert from Nef:", entity);
logger().message(ifcopenshell::logger::LOG_ERROR, "GEO", 88, "Could not convert from Nef:", entity);
return false;
}
@@ -1202,7 +1203,7 @@ bool cgal_kernel::process_extrusion(const cgal_face_t& bottom_face, taxonomy::di
try {
nef_shape -= utils::create_nef_polyhedron(face_list);
} catch (...) {
::logger::root().message(::logger::LOG_ERROR, "IfcExtrudedAreaSolid: cannot subtract opening for:");
ifcopenshell::logger::root().message(ifcopenshell::logger::LOG_ERROR, "IfcExtrudedAreaSolid: cannot subtract opening for:");
return false;
}
}
@@ -1219,7 +1220,7 @@ bool cgal_kernel::process_extrusion(const cgal_face_t& bottom_face, taxonomy::di
nef_shape.convert_to_polyhedron(shape);
return true;
} catch (...) {
::logger::root().message(::logger::LOG_ERROR, "IfcExtrudedAreaSolid: cannot convert Nef to polyhedron for:");
ifcopenshell::logger::root().message(ifcopenshell::logger::LOG_ERROR, "IfcExtrudedAreaSolid: cannot convert Nef to polyhedron for:");
return false;
}
*/
@@ -1228,7 +1229,7 @@ bool cgal_kernel::process_extrusion(const cgal_face_t& bottom_face, taxonomy::di
bool cgal_kernel::convert(const taxonomy::extrusion::ptr extrusion, cgal_shape_t &shape) {
const double& height = extrusion->depth;
if (height < settings_.get<settings::Precision>().get()) {
logger().message(::logger::LOG_ERROR, "GEO", 89, "Non-positive extrusion height encountered for:", extrusion->instance);
logger().message(ifcopenshell::logger::LOG_ERROR, "GEO", 89, "Non-positive extrusion height encountered for:", extrusion->instance);
return false;
}
@@ -1364,13 +1365,13 @@ bool cgal_kernel::preprocess_boolean_operand(const express::base& log_reference,
cgal_shape_t shape = shape_const;
if (!shape.is_valid()) {
logger().message(::logger::LOG_ERROR, "GEO", 90, "Conversion to Nef will fail. Invalid geometry:", log_reference);
logger().message(ifcopenshell::logger::LOG_ERROR, "GEO", 90, "Conversion to Nef will fail. Invalid geometry:", log_reference);
return false;
}
if (!shape.is_closed()) {
// TODO: There can be substractions to remove parts of non-volumetric objects. Maybe iterate over all faces of an entity and put them in a Nef_polyhedron_3 through Boolean union? Highly inefficient but maybe desirable...
logger().message(::logger::LOG_ERROR, "UNS", 6, "Subtraction of openings not supported for non-closed geometry:", log_reference);
logger().message(ifcopenshell::logger::LOG_ERROR, "UNS", 6, "Subtraction of openings not supported for non-closed geometry:", log_reference);
return false;
}
@@ -1380,17 +1381,17 @@ bool cgal_kernel::preprocess_boolean_operand(const express::base& log_reference,
success = CGAL::Polygon_mesh_processing::triangulate_faces(shape);
} catch (CGAL::Failure_exception& e) {
logger().notice("GEO", 91, e);
logger().message(::logger::LOG_ERROR, "GEO", 92, "Triangulation of geometry crashed:", log_reference);
logger().message(ifcopenshell::logger::LOG_ERROR, "GEO", 92, "Triangulation of geometry crashed:", log_reference);
return false;
}
if (!success) {
logger().message(::logger::LOG_ERROR, "GEO", 93, "Triangulation of geometry failed:", log_reference);
logger().message(ifcopenshell::logger::LOG_ERROR, "GEO", 93, "Triangulation of geometry failed:", log_reference);
return false;
}
if (CGAL::Polygon_mesh_processing::does_self_intersect(shape)) {
logger().message(::logger::LOG_ERROR, "GEO", 94, "Conversion to Nef will fail. Self-intersecting geometry:", log_reference);
logger().message(ifcopenshell::logger::LOG_ERROR, "GEO", 94, "Conversion to Nef will fail. Self-intersecting geometry:", log_reference);
return false;
}
@@ -1463,7 +1464,7 @@ bool cgal_kernel::preprocess_boolean_operand(const express::base& log_reference,
result = CGAL::Nef_polyhedron_3<kernel_>(shape);
} catch (CGAL::Failure_exception& e) {
logger().notice("GEO", 95, e);
logger().message(::logger::LOG_ERROR, "GEO", 96, "Could not convert geometry to Nef:", log_reference);
logger().message(ifcopenshell::logger::LOG_ERROR, "GEO", 96, "Could not convert geometry to Nef:", log_reference);
return false;
}
@@ -1536,7 +1537,7 @@ bool cgal_kernel::preprocess_boolean_operand(const express::base& log_reference,
result = CGAL::minkowski_sum_3(result, precision_cube_);
} catch (CGAL::Failure_exception& e) {
logger().notice("GEO", 97, e);
logger().message(::logger::LOG_ERROR, "GEO", 98, "Could not dilate boolean operand", log_reference);
logger().message(ifcopenshell::logger::LOG_ERROR, "GEO", 98, "Could not dilate boolean operand", log_reference);
return false;
}
}
@@ -1562,7 +1563,7 @@ bool cgal_kernel::preprocess_boolean_operand(const express::base& log_reference,
result.convert_to_polyhedron(convert_back);
} catch (CGAL::Failure_exception& e) {
logger().notice("GEO", 99, e);
logger().message(::logger::LOG_WARNING, "GEO", 100, "Final conversion will likely fail. Could not convert geometry from Nef:", log_reference);
logger().message(ifcopenshell::logger::LOG_WARNING, "GEO", 100, "Final conversion will likely fail. Could not convert geometry from Nef:", log_reference);
}
return true;
@@ -2169,7 +2170,7 @@ bool cgal_kernel::convert_impl(const taxonomy::boolean_result::ptr br, conversio
try {
a.convert_to_polyhedron(a_poly);
} catch (...) {
logger().message(::logger::LOG_ERROR, "GEO", 104, "Could not convert geometry with openings from Nef:", br->instance);
logger().message(ifcopenshell::logger::LOG_ERROR, "GEO", 104, "Could not convert geometry with openings from Nef:", br->instance);
return false;
}
@@ -2260,7 +2261,7 @@ void polyhedron_builder::operator()(CGAL::Polyhedron_3<kernel_>::HalfedgeDS &hds
// For now let's just skip over the triangle. We can also use
// the Aff_transformation_3 stored in place to convert the 2d
// coords back to 3d.
::logger::root().warning("Ignoring triangulated facet with novel point likely due to self-intersections");
ifcopenshell::logger::root().warning("Ignoring triangulated facet with novel point likely due to self-intersections");
logger_.warning("GEO", 105, "Ignoring triangulated facet with novel point likely due to self-intersections");
facet_vertices.erase(facet_vertices.end() - 1);
break;
@@ -2301,7 +2302,7 @@ void polyhedron_builder::operator()(CGAL::Polyhedron_3<kernel_>::HalfedgeDS &hds
if (!CGAL::Polygon_mesh_processing::is_polygon_soup_a_polygon_mesh(facet_vertices)) {
// @todo seems to return false now, almost always?
// ::logger::root().warning("Reoriented polygonal surface");
// ifcopenshell::logger::root().warning("Reoriented polygonal surface");
CGAL::Polygon_mesh_processing::orient_polygon_soup(unique_points_as_vector, facet_vertices);
}
CGAL::Polygon_mesh_processing::polygon_soup_to_polygon_mesh(unique_points_as_vector, facet_vertices, *from_soup);
@@ -2321,12 +2322,12 @@ void polyhedron_builder::operator()(CGAL::Polyhedron_3<kernel_>::HalfedgeDS &hds
if (added_edges.find(p) != added_edges.end()) {
if (reoriented) {
facet_indices_to_delete.push_back(fi);
::logger::root().notice("Removed facet");
ifcopenshell::logger::root().notice("Removed facet");
valid = false;
break;
} else {
std::reverse(f.begin(), f.end());
::logger::root().notice("Reversed facet");
ifcopenshell::logger::root().notice("Reversed facet");
reoriented = true;
goto check_edge_existence;
}
src/ifcgeom/kernels/cgal/CgalKernel.h
+6 -6
View File
@@ -60,12 +60,12 @@ namespace ifcopenshell {
namespace utils {
IFC_GEOMLIBRARY_API CGAL::Polyhedron_3<kernel_> create_cube(double d);
IFC_GEOMLIBRARY_API CGAL::Polyhedron_3<kernel_> create_cube(const kernel_::Point_3& lower, const kernel_::Point_3& upper);
IFC_GEOMLIBRARY_API CGAL::Polyhedron_3<kernel_> create_polyhedron(std::list<cgal_face_t> &face_list, bool stitch_borders = false, logger& logger = ::logger::root());
IFC_GEOMLIBRARY_API CGAL::Polyhedron_3<kernel_> create_polyhedron(std::list<cgal_face_t> &face_list, bool stitch_borders = false, logger& logger = ifcopenshell::logger::root());
#ifndef IFOPSH_SIMPLE_KERNEL
IFC_GEOMLIBRARY_API CGAL::Polyhedron_3<kernel_> create_polyhedron(const CGAL::Nef_polyhedron_3<kernel_> &nef_polyhedron, logger& logger = ::logger::root());
IFC_GEOMLIBRARY_API CGAL::Nef_polyhedron_3<kernel_> create_nef_polyhedron(std::list<cgal_face_t> &face_list, logger& logger = ::logger::root());
IFC_GEOMLIBRARY_API CGAL::Nef_polyhedron_3<kernel_> create_nef_polyhedron(CGAL::Polyhedron_3<kernel_> &polyhedron, logger& logger = ::logger::root());
IFC_GEOMLIBRARY_API CGAL::Polyhedron_3<kernel_> create_polyhedron(const CGAL::Nef_polyhedron_3<kernel_> &nef_polyhedron, logger& logger = ifcopenshell::logger::root());
IFC_GEOMLIBRARY_API CGAL::Nef_polyhedron_3<kernel_> create_nef_polyhedron(std::list<cgal_face_t> &face_list, logger& logger = ifcopenshell::logger::root());
IFC_GEOMLIBRARY_API CGAL::Nef_polyhedron_3<kernel_> create_nef_polyhedron(CGAL::Polyhedron_3<kernel_> &polyhedron, logger& logger = ifcopenshell::logger::root());
#endif
}
@@ -93,11 +93,11 @@ namespace ifcopenshell {
#endif
public:
cgal_kernel(const ifcopenshell::geom::settings& settings, ::logger& logger = ::logger::root())
cgal_kernel(const ifcopenshell::geom::settings& settings, ifcopenshell::logger& logger = ifcopenshell::logger::root())
: abstract_kernel("cgal", settings, logger)
{}
virtual abstract_kernel* clone(::logger& logger) const {
virtual abstract_kernel* clone(ifcopenshell::logger& logger) const {
return new cgal_kernel(settings(), logger);
}
src/ifcgeom/kernels/cgal/nef_to_halfspace_tree.h
+4
View File
@@ -52,6 +52,8 @@
#include <memory>
#include <functional>
namespace ifcopenshell::geom {
// Functor to lexicographically sort Plane_3
template <typename Kernel>
struct plane_less {
@@ -1378,4 +1380,6 @@ bool write_to_obj(const CGAL::Nef_polyhedron_3<Kernel>& a, std::ostream& ofs, si
return volume_index == std::numeric_limits<size_t>::max();
}
} // namespace ifcopenshell::geom
#endif
src/ifcgeom/kernels/manifold/ManifoldConversionResult.cpp
+1 -1
View File
@@ -215,7 +215,7 @@ std::optional<manifold::Manifold> ifcopenshell::geom::manifold_shape::as_manifol
return manifold::Manifold::BatchBoolean(solids, manifold::OpType::Add);
}
void ifcopenshell::geom::manifold_shape::Triangulate(ifcopenshell::geom::settings, const ifcopenshell::geom::taxonomy::matrix4& place, ifcopenshell::geom::Representation::triangulation* t, int item_id, int surface_style_id, ::logger&) const {
void ifcopenshell::geom::manifold_shape::Triangulate(ifcopenshell::geom::settings, const ifcopenshell::geom::taxonomy::matrix4& place, ifcopenshell::geom::Representation::triangulation* t, int item_id, int surface_style_id, ifcopenshell::logger&) const {
for (const auto& part : parts_) {
auto mesh = transform_mesh(part.mesh, place);
std::vector<int> indices(mesh.NumVert());
src/ifcgeom/kernels/manifold/ManifoldConversionResult.h
+1 -1
View File
@@ -40,7 +40,7 @@ public:
std::optional<manifold::Manifold> as_manifold() const;
virtual std::string_view backend_id() const { return "manifold"; }
virtual void Triangulate(ifcopenshell::geom::settings settings, const ifcopenshell::geom::taxonomy::matrix4& place, ifcopenshell::geom::Representation::triangulation* t, int item_id, int surface_style_id, ::logger& logger = ::logger::root()) const;
virtual void Triangulate(ifcopenshell::geom::settings settings, const ifcopenshell::geom::taxonomy::matrix4& place, ifcopenshell::geom::Representation::triangulation* t, int item_id, int surface_style_id, ifcopenshell::logger& logger = ifcopenshell::logger::root()) const;
virtual void Serialize(const ifcopenshell::geom::taxonomy::matrix4& place, std::string&) const;
virtual int surface_genus() const;
src/ifcgeom/kernels/manifold/ManifoldKernel.cpp
+23 -23
View File
@@ -769,16 +769,16 @@ namespace {
const auto shell_info = diagnose_shell(shell);
const auto before = diagnose_mesh(before_part.mesh, precision);
const auto after = diagnose_mesh(after_mesh, precision);
::logger::root().warning(
ifcopenshell::logger::root().warning(
"Manifold kernel: solid shell manifold validation failed; before_transform=" +
std::string(before_part.solid ? "solid" : "mesh-only") +
" (" + manifold_error_string(before_status) + "), after_transform=(" + manifold_error_string(after_status) + ")",
shell->instance);
::logger::root().warning("Manifold kernel: solid shell diagnosis: " + solid_shell_failure_diagnosis(before_part, before, after, before_status, after_status), shell->instance);
::logger::root().warning("Manifold kernel: solid shell input: " + shell_diagnostics_string(shell_info), shell->instance);
::logger::root().warning("Manifold kernel: solid shell mesh before transform: " + mesh_diagnostics_string(before), shell->instance);
::logger::root().warning("Manifold kernel: solid shell transform: " + matrix_diagnostics_string(place), shell->instance);
::logger::root().warning("Manifold kernel: solid shell mesh after transform: " + mesh_diagnostics_string(after), shell->instance);
ifcopenshell::logger::root().warning("Manifold kernel: solid shell diagnosis: " + solid_shell_failure_diagnosis(before_part, before, after, before_status, after_status), shell->instance);
ifcopenshell::logger::root().warning("Manifold kernel: solid shell input: " + shell_diagnostics_string(shell_info), shell->instance);
ifcopenshell::logger::root().warning("Manifold kernel: solid shell mesh before transform: " + mesh_diagnostics_string(before), shell->instance);
ifcopenshell::logger::root().warning("Manifold kernel: solid shell transform: " + matrix_diagnostics_string(place), shell->instance);
ifcopenshell::logger::root().warning("Manifold kernel: solid shell mesh after transform: " + mesh_diagnostics_string(after), shell->instance);
}
double signed_area(const manifold::SimplePolygon& polygon) {
@@ -1492,7 +1492,7 @@ namespace {
bool manifold_kernel::convert_impl(const taxonomy::extrusion::ptr extrusion, ifcopenshell::geom::conversion_results& results) {
auto part = part_from_extrusion(extrusion, settings_.get<settings::Precision>().get(), dilation_hack, settings_.get<settings::CircleSegments>().get());
if (!part) {
::logger::root().warning("Manifold kernel: failed to convert extrusion, requires planar bounds with line, circle or ellipse edges", extrusion->instance);
ifcopenshell::logger::root().warning("Manifold kernel: failed to convert extrusion, requires planar bounds with line, circle or ellipse edges", extrusion->instance);
return false;
}
results.emplace_back(ifcopenshell::geom::conversion_result(
@@ -1507,11 +1507,11 @@ bool manifold_kernel::convert_impl(const taxonomy::shell::ptr shell, ifcopenshel
manifold::Manifold::Error status = manifold::Manifold::Error::NoError;
auto part = part_from_shell(shell, settings_.get<settings::Precision>().get(), dilation_hack, &status);
if (!part) {
::logger::root().warning("Manifold kernel: failed to convert shell, requires planar polygonal faces with explicit vertices", shell->instance);
ifcopenshell::logger::root().warning("Manifold kernel: failed to convert shell, requires planar polygonal faces with explicit vertices", shell->instance);
return false;
}
if (!part->solid) {
::logger::root().notice("Manifold kernel: shell converted as mesh only (" + manifold_error_string(status) + ")", shell->instance);
ifcopenshell::logger::root().notice("Manifold kernel: shell converted as mesh only (" + manifold_error_string(status) + ")", shell->instance);
}
results.emplace_back(ifcopenshell::geom::conversion_result(
shell->instance.id(),
@@ -1528,7 +1528,7 @@ bool manifold_kernel::convert_impl(const taxonomy::solid::ptr solid, ifcopenshel
manifold::Manifold::Error before_status = manifold::Manifold::Error::NoError;
auto part = part_from_shell(shell, precision, dilation_hack, &before_status);
if (!part) {
::logger::root().warning("Manifold kernel: failed to convert solid shell, requires planar polygonal faces with explicit vertices", shell->instance);
ifcopenshell::logger::root().warning("Manifold kernel: failed to convert solid shell, requires planar polygonal faces with explicit vertices", shell->instance);
return false;
}
auto place = shell->matrix ? shell->matrix : taxonomy::make<taxonomy::matrix4>();
@@ -1570,21 +1570,21 @@ bool manifold_kernel::convert_impl(const taxonomy::boolean_result::ptr br, ifcop
dilation_hack = first ? 0. : precision * 10.;
if (!first && br->operation == taxonomy::boolean_result::SUBTRACTION && face) {
if (!first_bbox) {
::logger::root().warning("Manifold kernel: cannot fit halfspace operand without a valid first operand bounds", child->instance);
ifcopenshell::logger::root().warning("Manifold kernel: cannot fit halfspace operand without a valid first operand bounds", child->instance);
return false;
}
halfspace_build_state state;
auto part = part_from_halfspace_solid(state, solid, face, *first_bbox, precision, dilation_hack);
if (!part) {
if (state.unchanged && br->operation == taxonomy::boolean_result::SUBTRACTION) {
::logger::root().warning("Manifold kernel: halfspace subtraction yields unchanged volume", child->instance);
ifcopenshell::logger::root().warning("Manifold kernel: halfspace subtraction yields unchanged volume", child->instance);
continue;
}
::logger::root().warning("Manifold kernel: failed to fit halfspace boolean operand to first operand bounds", child->instance);
ifcopenshell::logger::root().warning("Manifold kernel: failed to fit halfspace boolean operand to first operand bounds", child->instance);
return false;
}
if (!part->solid) {
::logger::root().warning("Manifold kernel: fitted halfspace operand is not a valid manifold solid", child->instance);
ifcopenshell::logger::root().warning("Manifold kernel: fitted halfspace operand is not a valid manifold solid", child->instance);
return false;
}
operand = *part->solid;
@@ -1594,12 +1594,12 @@ bool manifold_kernel::convert_impl(const taxonomy::boolean_result::ptr br, ifcop
} else {
ifcopenshell::geom::conversion_results converted;
if (!abstract_kernel::convert(child, converted)) {
::logger::root().warning("Manifold kernel: failed to convert boolean operand", child->instance);
ifcopenshell::logger::root().warning("Manifold kernel: failed to convert boolean operand", child->instance);
return false;
}
operand = results_to_operand(converted);
if (!operand) {
::logger::root().warning("Manifold kernel: boolean operand is not a valid manifold solid", child->instance);
ifcopenshell::logger::root().warning("Manifold kernel: boolean operand is not a valid manifold solid", child->instance);
return false;
}
if (!style) {
@@ -1612,7 +1612,7 @@ bool manifold_kernel::convert_impl(const taxonomy::boolean_result::ptr br, ifcop
if (first) {
auto bbox = operand->BoundingBox();
if (!bbox.IsFinite()) {
::logger::root().warning("Manifold kernel: first boolean operand has no valid bounds", child->instance);
ifcopenshell::logger::root().warning("Manifold kernel: first boolean operand has no valid bounds", child->instance);
return false;
}
first_bbox = bbox;
@@ -1623,7 +1623,7 @@ bool manifold_kernel::convert_impl(const taxonomy::boolean_result::ptr br, ifcop
dilation_hack = 0.;
auto result = boolean_result_from_operands(operands, br->operation);
if (!result || result->IsEmpty()) {
::logger::root().warning("Manifold kernel: boolean operation produced no result", br->instance);
ifcopenshell::logger::root().warning("Manifold kernel: boolean operation produced no result", br->instance);
return false;
}
results.emplace_back(ifcopenshell::geom::conversion_result(
@@ -1638,7 +1638,7 @@ bool manifold_kernel::convert_openings(const express::base&, const std::vector<s
std::vector<manifold::Manifold> opening_operands;
auto entity_bbox = results_bbox(entity_shapes);
if (!entity_bbox) {
::logger::root().warning("Manifold kernel: host shape has no valid bounds for halfspace fitting");
ifcopenshell::logger::root().warning("Manifold kernel: host shape has no valid bounds for halfspace fitting");
return false;
}
dilation_hack = settings_.get<settings::Precision>().get() * 10.;
@@ -1646,19 +1646,19 @@ bool manifold_kernel::convert_openings(const express::base&, const std::vector<s
const auto relative = taxonomy::make<taxonomy::matrix4>(entity_trsf.ccomponents().inverse() * opening.second.ccomponents());
ifcopenshell::geom::conversion_results converted;
if (!abstract_kernel::convert(opening.first, converted)) {
::logger::root().warning("Manifold kernel: failed to convert opening operand", opening.first->instance);
ifcopenshell::logger::root().warning("Manifold kernel: failed to convert opening operand", opening.first->instance);
return false;
}
for (const auto& result : converted) {
auto moved = std::unique_ptr<ifcopenshell::geom::conversion_result_shape>(result.Shape()->moved(taxonomy::make<taxonomy::matrix4>(relative->ccomponents() * result.Placement()->ccomponents())));
auto* shape = dynamic_cast<ifcopenshell::geom::manifold_shape*>(moved.get());
if (!shape) {
::logger::root().warning("Manifold kernel: opening result is not a manifold shape");
ifcopenshell::logger::root().warning("Manifold kernel: opening result is not a manifold shape");
return false;
}
auto operand = shape->as_manifold();
if (!operand) {
::logger::root().warning("Manifold kernel: opening result is not a valid manifold solid", opening.first->instance);
ifcopenshell::logger::root().warning("Manifold kernel: opening result is not a valid manifold solid", opening.first->instance);
return false;
}
opening_operands.push_back(*operand);
@@ -1672,7 +1672,7 @@ bool manifold_kernel::convert_openings(const express::base&, const std::vector<s
for (const auto& entity_shape : entity_shapes) {
auto operand = result_to_manifold(entity_shape);
if (!operand) {
::logger::root().warning("Manifold kernel: host shape is not a valid manifold solid");
ifcopenshell::logger::root().warning("Manifold kernel: host shape is not a valid manifold solid");
return false;
}
auto result = *operand - opening_union;
src/ifcgeom/kernels/manifold/ManifoldKernel.h
+2 -2
View File
@@ -13,10 +13,10 @@ namespace kernels {
class IFC_GEOMLIBRARY_API manifold_kernel : public abstract_kernel {
public:
manifold_kernel(const ifcopenshell::geom::settings& settings, ::logger& logger = ::logger::root())
manifold_kernel(const ifcopenshell::geom::settings& settings, ifcopenshell::logger& logger = ifcopenshell::logger::root())
: abstract_kernel("manifold", settings, logger) {}
virtual abstract_kernel* clone(::logger& logger) const {
virtual abstract_kernel* clone(ifcopenshell::logger& logger) const {
return new manifold_kernel(settings(), logger);
}
src/ifcgeom/kernels/opencascade/OpenCascadeConversionResult.cpp
+4 -4
View File
@@ -68,7 +68,7 @@ ifcopenshell::geom::conversion_result_shape* ifcopenshell::geom::open_cascade_sh
return new open_cascade_shape(shape_);
}
void ifcopenshell::geom::open_cascade_shape::Triangulate(ifcopenshell::geom::settings settings, const ifcopenshell::geom::taxonomy::matrix4& place, ifcopenshell::geom::Representation::triangulation* t, int item_id, int surface_style_id, ::logger& logger) const {
void ifcopenshell::geom::open_cascade_shape::Triangulate(ifcopenshell::geom::settings settings, const ifcopenshell::geom::taxonomy::matrix4& place, ifcopenshell::geom::Representation::triangulation* t, int item_id, int surface_style_id, ifcopenshell::logger& logger) const {
// @todo remove duplication with open_cascade_kernel::convert(const taxonomy::matrix4::ptr matrix, gp_GTrsf& trsf);
// above can be static?
@@ -108,7 +108,7 @@ void ifcopenshell::geom::open_cascade_shape::Triangulate(ifcopenshell::geom::set
try {
BRepMesh_IncrementalMesh(shape_, settings.get<settings::MesherLinearDeflection>().get(), false, settings.get<settings::MesherAngularDeflection>().get());
} catch (...) {
::logger::root().message(::logger::LOG_ERROR, "GEO", 183, "Failed to triangulate shape");
ifcopenshell::logger::root().message(ifcopenshell::logger::LOG_ERROR, "GEO", 183, "Failed to triangulate shape");
return;
}
}
@@ -134,7 +134,7 @@ void ifcopenshell::geom::open_cascade_shape::Triangulate(ifcopenshell::geom::set
opencascade::handle<Poly_Triangulation> tri = BRep_Tool::Triangulation(face, loc);
if (tri.IsNull()) {
::logger::root().message(::logger::LOG_ERROR, "GEO", 184, "Triangulation missing for face");
ifcopenshell::logger::root().message(ifcopenshell::logger::LOG_ERROR, "GEO", 184, "Triangulation missing for face");
} else {
// Keep track of the number of times an edge is used
// Manifold edges (i.e. edges used twice) are deemed invisible
@@ -640,7 +640,7 @@ namespace {
try {
BRepMesh_IncrementalMesh(s, tol);
} catch (...) {
::logger::root().message(::logger::LOG_ERROR, "GEO", 186, "Failed to triangulate shape");
ifcopenshell::logger::root().message(ifcopenshell::logger::LOG_ERROR, "GEO", 186, "Failed to triangulate shape");
return;
}
meshed = true;
src/ifcgeom/kernels/opencascade/OpenCascadeConversionResult.h
+1 -1
View File
@@ -49,7 +49,7 @@ namespace ifcopenshell {
operator const TopoDS_Shape& ();
virtual std::string_view backend_id() const;
virtual void Triangulate(ifcopenshell::geom::settings settings, const ifcopenshell::geom::taxonomy::matrix4& place, ifcopenshell::geom::Representation::triangulation* t, int item_id, int surface_style_id, ::logger& logger = ::logger::root()) const;
virtual void Triangulate(ifcopenshell::geom::settings settings, const ifcopenshell::geom::taxonomy::matrix4& place, ifcopenshell::geom::Representation::triangulation* t, int item_id, int surface_style_id, ifcopenshell::logger& logger = ifcopenshell::logger::root()) const;
virtual void Serialize(const ifcopenshell::geom::taxonomy::matrix4& place, std::string&) const;
virtual ifcopenshell::geom::conversion_result_shape* clone() const;
src/ifcgeom/kernels/opencascade/OpenCascadeKernel.cpp
+29 -29
View File
@@ -190,7 +190,7 @@ bool ifcopenshell::geom::open_cascade_kernel::convert_openings(const express::ba
const auto& m = it3->Placement()->ccomponents();
// @todo
// if (entity_shape_gtrsf.Form() == gp_Other) {
// ::logger::root().message(::logger::LOG_WARNING, "Applying non uniform transformation to:", entity);
// ifcopenshell::logger::root().message(ifcopenshell::logger::LOG_WARNING, "Applying non uniform transformation to:", entity);
// }
gp_Trsf entity_shape_gtrsf;
entity_shape_gtrsf.SetValues(
@@ -217,7 +217,7 @@ bool ifcopenshell::geom::open_cascade_kernel::convert_openings(const express::ba
if (util::boolean_operation(bst, result, opening_list, BOPAlgo_CUT, intermediate_result)) {
result = intermediate_result;
} else {
logger_.message(::logger::LOG_ERROR, "GEO", 192, "Opening subtraction failed for " + boost::lexical_cast<std::string>(std::distance(jt, it)) + " openings", entity);
logger_.message(ifcopenshell::logger::LOG_ERROR, "GEO", 192, "Opening subtraction failed for " + boost::lexical_cast<std::string>(std::distance(jt, it)) + " openings", entity);
}
jt = it;
@@ -417,7 +417,7 @@ bool ifcopenshell::geom::open_cascade_kernel::convert_impl(const taxonomy::revol
// }
//
// if (!success) {
// ::logger::root().error("Failed processing layerset");
// ifcopenshell::logger::root().error("Failed processing layerset");
// }
// }
// }
@@ -445,7 +445,7 @@ bool ifcopenshell::geom::open_cascade_kernel::convert_impl(const taxonomy::revol
// }
// }
// if (some_items_without_style) {
// ::logger::root().warning("No material and surface styles for:", product);
// ifcopenshell::logger::root().warning("No material and surface styles for:", product);
// }
// }
//
@@ -472,7 +472,7 @@ bool ifcopenshell::geom::open_cascade_kernel::convert_impl(const taxonomy::revol
// parent_id = parent_object->data().id();
// }
// } catch (const std::exception& e) {
// ::logger::root().error(e);
// ifcopenshell::logger::root().error(e);
// }
//
// const std::string name = product->Name().value_or("");
@@ -484,9 +484,9 @@ bool ifcopenshell::geom::open_cascade_kernel::convert_impl(const taxonomy::revol
// convert(product->ObjectPlacement(), trsf);
// }
// } catch (const std::exception& e) {
// ::logger::root().error(e);
// ifcopenshell::logger::root().error(e);
// } catch (...) {
// ::logger::root().error("Failed to construct placement");
// ifcopenshell::logger::root().error("Failed to construct placement");
// }
//
// // Does the IfcElement have any IfcOpenings?
@@ -507,10 +507,10 @@ bool ifcopenshell::geom::open_cascade_kernel::convert_impl(const taxonomy::revol
// try {
// convert_openings(product, openings, shapes, trsf, opened_shapes);
// } catch (const std::exception& e) {
// ::logger::root().message(::logger::LOG_ERROR, std::string("error processing openings for: ") + e.what() + ":", product);
// ifcopenshell::logger::root().message(ifcopenshell::logger::LOG_ERROR, std::string("error processing openings for: ") + e.what() + ":", product);
// caught_error = true;
// } catch (...) {
// ::logger::root().message(::logger::LOG_ERROR, "error processing openings for:", product);
// ifcopenshell::logger::root().message(ifcopenshell::logger::LOG_ERROR, "error processing openings for:", product);
// }
//
// if (caught_error && opened_shapes.size() < shapes.size()) {
@@ -575,12 +575,12 @@ bool ifcopenshell::geom::open_cascade_kernel::convert_impl(const taxonomy::revol
// if (elem->geometry().calculate_surface_area(a_calc)) {
// double diff = std::abs(a_calc - a_file);
// if (diff / std::sqrt(a_file) > getValue(GV_PRECISION)) {
// ::logger::root().error("Validation of surface area failed for:", product);
// ifcopenshell::logger::root().error("Validation of surface area failed for:", product);
// } else {
// ::logger::root().notice("Validation of surface area succeeded for:", product);
// ifcopenshell::logger::root().notice("Validation of surface area succeeded for:", product);
// }
// } else {
// ::logger::root().error("Validation of surface area failed for:", product);
// ifcopenshell::logger::root().error("Validation of surface area failed for:", product);
// }
// } else if (q->as<IfcSchema::IfcQuantityVolume>() && q->Name() == "Volume") {
// double v_calc;
@@ -588,12 +588,12 @@ bool ifcopenshell::geom::open_cascade_kernel::convert_impl(const taxonomy::revol
// if (elem->geometry().calculate_volume(v_calc)) {
// double diff = std::abs(v_calc - v_file);
// if (diff / std::sqrt(v_file) > getValue(GV_PRECISION)) {
// ::logger::root().error("Validation of volume failed for:", product);
// ifcopenshell::logger::root().error("Validation of volume failed for:", product);
// } else {
// ::logger::root().notice("Validation of volume succeeded for:", product);
// ifcopenshell::logger::root().notice("Validation of volume succeeded for:", product);
// }
// } else {
// ::logger::root().error("Validation of volume failed for:", product);
// ifcopenshell::logger::root().error("Validation of volume failed for:", product);
// }
// } else if (q->as<IfcSchema::IfcPhysicalComplexQuantity>() && q->Name() == "Shape Validation Properties") {
// auto qs2 = q->as<IfcSchema::IfcPhysicalComplexQuantity>()->HasQuantities();
@@ -612,9 +612,9 @@ bool ifcopenshell::geom::open_cascade_kernel::convert_impl(const taxonomy::revol
// }
// }
// if (!all_succeeded) {
// ::logger::root().error("Validation of surface genus failed for:", product);
// ifcopenshell::logger::root().error("Validation of surface genus failed for:", product);
// } else {
// ::logger::root().notice("Validation of surface genus succeeded for:", product);
// ifcopenshell::logger::root().notice("Validation of surface genus succeeded for:", product);
// }
// }
// }
@@ -646,7 +646,7 @@ bool ifcopenshell::geom::open_cascade_kernel::convert_impl(const taxonomy::revol
// }
// }
// } catch (const ifcopenshell::exception& e) {
// ::logger::root().error(e);
// ifcopenshell::logger::root().error(e);
// // @todo reset representation_mapped_to to zero?
// }
// return representation_mapped_to;
@@ -670,15 +670,15 @@ bool ifcopenshell::geom::open_cascade_kernel::convert_impl(const taxonomy::revol
// IfcSchema::IfcRepresentationMap::list::ptr maps = representation->RepresentationMap();
//
// if (products->size() && maps->size()) {
// ::logger::root().warning("Representation used by IfcRepresentationMap and IfcProductDefinitionShape", representation);
// ifcopenshell::logger::root().warning("Representation used by IfcRepresentationMap and IfcProductDefinitionShape", representation);
// }
//
// if (prodreps->size() > 1) {
// ::logger::root().warning("Multiple IfcProductDefinitionShapes for representation", representation);
// ifcopenshell::logger::root().warning("Multiple IfcProductDefinitionShapes for representation", representation);
// }
//
// if (maps->size() > 1) {
// ::logger::root().warning("Multiple IfcRepresentationMaps for representation", representation);
// ifcopenshell::logger::root().warning("Multiple IfcRepresentationMaps for representation", representation);
// }
//
// if (maps->size() == 1) {
@@ -721,7 +721,7 @@ bool ifcopenshell::geom::open_cascade_kernel::convert_impl(const taxonomy::revol
// parent_id = parent_object->data().id();
// }
// } catch (const std::exception& e) {
// ::logger::root().error(e);
// ifcopenshell::logger::root().error(e);
// }
//
// const std::string name = product->Name().value_or("");
@@ -733,9 +733,9 @@ bool ifcopenshell::geom::open_cascade_kernel::convert_impl(const taxonomy::revol
// convert(product->ObjectPlacement(), trsf);
// }
// } catch (const std::exception& e) {
// ::logger::root().error(e);
// ifcopenshell::logger::root().error(e);
// } catch (...) {
// ::logger::root().error("Failed to construct placement");
// ifcopenshell::logger::root().error("Failed to construct placement");
// }
//
// std::string context_string = "";
@@ -937,7 +937,7 @@ bool ifcopenshell::geom::open_cascade_kernel::convert_impl(const taxonomy::revol
// // range. It's only a safeguard though, so can probably be approximated.
// const double axis_length = own_axis_start.Distance(own_axis_end);
// if (length_required > axis_length) {
// ::logger::root().warning("The wall axis is not long enough to accommodate the fold points");
// ifcopenshell::logger::root().warning("The wall axis is not long enough to accommodate the fold points");
// return false;
// }
//
@@ -957,7 +957,7 @@ bool ifcopenshell::geom::open_cascade_kernel::convert_impl(const taxonomy::revol
// gp_Trsf other;
// if (other_wall->ObjectPlacement()) {
// if (!convert(other_wall->ObjectPlacement(), other)) {
// ::logger::root().error("Failed to convert placement", other_wall);
// ifcopenshell::logger::root().error("Failed to convert placement", other_wall);
// continue;
// }
// }
@@ -965,7 +965,7 @@ bool ifcopenshell::geom::open_cascade_kernel::convert_impl(const taxonomy::revol
// IfcSchema::IfcRepresentation* axis_representation = find_representation(other_wall, "Axis");
//
// if (!axis_representation) {
// ::logger::root().warning("Joined wall has no axis representation", other_wall);
// ifcopenshell::logger::root().warning("Joined wall has no axis representation", other_wall);
// continue;
// }
//
@@ -1059,7 +1059,7 @@ bool ifcopenshell::geom::open_cascade_kernel::convert_impl(const taxonomy::revol
// Vs1.Cross(Vs2);
//
// if (Vs1.IsNormal(Vc, 1.e-5)) {
// ::logger::root().warning("Connected walls are parallel");
// ifcopenshell::logger::root().warning("Connected walls are parallel");
// parallel = true;
// } else if (w < axis_u1 || w > axis_u2) {
// point_outside_param_range = p;
@@ -1394,7 +1394,7 @@ bool ifcopenshell::geom::open_cascade_kernel::convert_impl(const taxonomy::revol
// Handle_Geom_Circle axis_line = Handle_Geom_Circle::DownCast(axis_curve);
// reference_surface = new Geom_CylindricalSurface(axis_li->Position(), axis_line->Radius());
// } else {
// ::logger::root().message(::logger::LOG_ERROR, "Unsupported underlying curve of Axis representation:", product);
// ifcopenshell::logger::root().message(ifcopenshell::logger::LOG_ERROR, "Unsupported underlying curve of Axis representation:", product);
// return false;
// }
//
src/ifcgeom/kernels/opencascade/OpenCascadeKernel.h
+2 -2
View File
@@ -110,13 +110,13 @@ private:
double precision_;
public:
open_cascade_kernel(const ifcopenshell::geom::settings& settings, ::logger& logger = ::logger::root())
open_cascade_kernel(const ifcopenshell::geom::settings& settings, ifcopenshell::logger& logger = ifcopenshell::logger::root())
: abstract_kernel("opencascade", settings, logger)
, faceset_helper_(nullptr)
, precision_(settings.get<ifcopenshell::geom::settings::Precision>().get())
{}
virtual abstract_kernel* clone(::logger& logger) const {
virtual abstract_kernel* clone(ifcopenshell::logger& logger) const {
return new open_cascade_kernel(settings(), logger);
}
src/ifcgeom/kernels/opencascade/base_utils.cpp
+13 -13
View File
@@ -714,12 +714,12 @@ bool ifcopenshell::geom::util::create_solid_from_faces(const NCollection_List<To
valid_shell &= util::count(shape, TopAbs_SHELL) > 0;
} catch (const Standard_Failure& e) {
if (e.GetMessageString() && strlen(e.GetMessageString())) {
::logger::root().error("GEO", 106, e.GetMessageString());
ifcopenshell::logger::root().error("GEO", 106, e.GetMessageString());
} else {
::logger::root().error("GEO", 107, "Unknown error sewing shell");
ifcopenshell::logger::root().error("GEO", 107, "Unknown error sewing shell");
}
} catch (...) {
::logger::root().error("GEO", 108, "Unknown error sewing shell");
ifcopenshell::logger::root().error("GEO", 108, "Unknown error sewing shell");
}
if (valid_shell) {
@@ -747,22 +747,22 @@ bool ifcopenshell::geom::util::create_solid_from_faces(const NCollection_List<To
}
} catch (const Standard_Failure& e) {
if (e.GetMessageString() && strlen(e.GetMessageString())) {
::logger::root().error("GEO", 109, e.GetMessageString());
ifcopenshell::logger::root().error("GEO", 109, e.GetMessageString());
} else {
::logger::root().error("GEO", 110, "Unknown error classifying solid");
ifcopenshell::logger::root().error("GEO", 110, "Unknown error classifying solid");
}
} catch (...) {
::logger::root().error("GEO", 111, "Unknown error classifying solid");
ifcopenshell::logger::root().error("GEO", 111, "Unknown error classifying solid");
}
}
} catch (const Standard_Failure& e) {
if (e.GetMessageString() && strlen(e.GetMessageString())) {
::logger::root().error("GEO", 112, e.GetMessageString());
ifcopenshell::logger::root().error("GEO", 112, e.GetMessageString());
} else {
::logger::root().error("GEO", 113, "Unknown error creating solid");
ifcopenshell::logger::root().error("GEO", 113, "Unknown error creating solid");
}
} catch (...) {
::logger::root().error("GEO", 114, "Unknown error creating solid");
ifcopenshell::logger::root().error("GEO", 114, "Unknown error creating solid");
}
if (complete_shape.IsNull()) {
@@ -774,7 +774,7 @@ bool ifcopenshell::geom::util::create_solid_from_faces(const NCollection_List<To
B.MakeCompound(C);
B.Add(C, complete_shape);
complete_shape = C;
::logger::root().warning("GEO", 115, "Multiple components in IfcConnectedFaceSet");
ifcopenshell::logger::root().warning("GEO", 115, "Multiple components in IfcConnectedFaceSet");
}
B.Add(complete_shape, result_shape);
}
@@ -789,7 +789,7 @@ bool ifcopenshell::geom::util::create_solid_from_faces(const NCollection_List<To
B.MakeCompound(C);
B.Add(C, complete_shape);
complete_shape = C;
::logger::root().warning("GEO", 116, "Loose faces in IfcConnectedFaceSet");
ifcopenshell::logger::root().warning("GEO", 116, "Loose faces in IfcConnectedFaceSet");
}
B.Add(complete_shape, loose_faces.Current());
}
@@ -797,7 +797,7 @@ bool ifcopenshell::geom::util::create_solid_from_faces(const NCollection_List<To
shape = complete_shape;
} else {
::logger::root().error("GEO", 117, "Failed to sew faceset");
ifcopenshell::logger::root().error("GEO", 117, "Failed to sew faceset");
}
return valid_shell;
@@ -901,7 +901,7 @@ bool ifcopenshell::geom::util::validate_shape(const TopoDS_Shape& s) {
dump(s);
::logger::root().warning("GEO", 118, str.str());
ifcopenshell::logger::root().warning("GEO", 118, str.str());
return false;
}
src/ifcgeom/kernels/opencascade/boolean_result.cpp
+2 -2
View File
@@ -117,7 +117,7 @@ bool open_cascade_kernel::convert_impl(const taxonomy::boolean_result::ptr br, c
const double first_operand_volume = util::shape_volume(a);
if (first_operand_volume <= ALMOST_ZERO) {
logger_.message(::logger::LOG_WARNING, "GEO", 119, "Empty solid for:", c->instance);
logger_.message(ifcopenshell::logger::LOG_WARNING, "GEO", 119, "Empty solid for:", c->instance);
}
} else {
@@ -139,7 +139,7 @@ bool open_cascade_kernel::convert_impl(const taxonomy::boolean_result::ptr br, c
// #2665 we also set a precision-independent threshold, because in the boolean op routine
// the working fuzziness might still be increased.
if (d < tol * 20. || d < 0.00002) {
logger_.message(::logger::LOG_WARNING, "GEO", 121, "Halfspace subtraction yields unchanged volume:", c->instance);
logger_.message(ifcopenshell::logger::LOG_WARNING, "GEO", 121, "Halfspace subtraction yields unchanged volume:", c->instance);
continue;
} else {
S = result;
src/ifcgeom/kernels/opencascade/boolean_utils.cpp
+5 -5
View File
@@ -405,7 +405,7 @@ bool ifcopenshell::geom::util::is_extrusion(const gp_Vec & v, const TopoDS_Shape
return true;
}
int ifcopenshell::geom::util::eliminate_narrow_operands(double prec, const NCollection_List<TopoDS_Shape>& bs, NCollection_List<TopoDS_Shape> & c, ::logger& logger) {
int ifcopenshell::geom::util::eliminate_narrow_operands(double prec, const NCollection_List<TopoDS_Shape>& bs, NCollection_List<TopoDS_Shape> & c, ifcopenshell::logger& logger) {
int N = 0;
NCollection_List<TopoDS_Shape>::Iterator it(bs);
for (; it.More(); it.Next()) {
@@ -573,7 +573,7 @@ int ifcopenshell::geom::util::eliminate_touching_operands(double prec, const Top
return N;
}
bool ifcopenshell::geom::util::boolean_subtraction_2d_using_builder(const TopoDS_Shape & a_input, const NCollection_List<TopoDS_Shape> & b_input, TopoDS_Shape & result, double eps, ::logger& logger) {
bool ifcopenshell::geom::util::boolean_subtraction_2d_using_builder(const TopoDS_Shape & a_input, const NCollection_List<TopoDS_Shape> & b_input, TopoDS_Shape & result, double eps, ifcopenshell::logger& logger) {
ifcopenshell::geom::impl::tree<int> edge_tree;
NCollection_List<TopoDS_Shape> ab_input = b_input;
@@ -885,7 +885,7 @@ bool ifcopenshell::geom::util::boolean_operation(const boolean_settings& setting
a = unify(a_input, fuzziness * 1000.);
settings.log().message(
::logger::LOG_DEBUG, "GEO", 127,
ifcopenshell::logger::LOG_DEBUG, "GEO", 127,
"Simplified operand A from "s +
std::to_string(count(a_input, TopAbs_FACE)) +
" to "s +
@@ -897,7 +897,7 @@ bool ifcopenshell::geom::util::boolean_operation(const boolean_settings& setting
for (; it.More(); it.Next()) {
b.Append(unify(it.Value(), fuzziness));
settings.log().message(
::logger::LOG_DEBUG, "GEO", 128,
ifcopenshell::logger::LOG_DEBUG, "GEO", 128,
"Simplified operand B from "s +
std::to_string(count(it.Value(), TopAbs_FACE)) +
" to "s +
@@ -965,7 +965,7 @@ bool ifcopenshell::geom::util::boolean_operation(const boolean_settings& setting
return true;
}
if (!is_2d && ::logger::LOG_NOTICE >= settings.log().verbosity()) {
if (!is_2d && ifcopenshell::logger::LOG_NOTICE >= settings.log().verbosity()) {
PERF("preliminary manifoldness check");
if (!a.IsNull()) {
src/ifcgeom/kernels/opencascade/boolean_utils.h
+5 -5
View File
@@ -89,17 +89,17 @@ namespace ifcopenshell::geom {
IFC_GEOMLIBRARY_API int eliminate_touching_operands(double prec, const TopoDS_Shape& a, const NCollection_List<TopoDS_Shape>& bs, NCollection_List<TopoDS_Shape>& c);
IFC_GEOMLIBRARY_API int eliminate_narrow_operands(double prec, const NCollection_List<TopoDS_Shape>& bs, NCollection_List<TopoDS_Shape> & c, ::logger& logger = ::logger::root());
IFC_GEOMLIBRARY_API int eliminate_narrow_operands(double prec, const NCollection_List<TopoDS_Shape>& bs, NCollection_List<TopoDS_Shape> & c, ifcopenshell::logger& logger = ifcopenshell::logger::root());
IFC_GEOMLIBRARY_API bool boolean_subtraction_2d_using_builder(const TopoDS_Shape& a_input, const NCollection_List<TopoDS_Shape>& b_input, TopoDS_Shape& result, double eps, ::logger& logger = ::logger::root());
IFC_GEOMLIBRARY_API bool boolean_subtraction_2d_using_builder(const TopoDS_Shape& a_input, const NCollection_List<TopoDS_Shape>& b_input, TopoDS_Shape& result, double eps, ifcopenshell::logger& logger = ifcopenshell::logger::root());
struct boolean_settings {
bool debug, attempt_2d;
double precision;
// Set by callers that carry a per-conversion logger (e.g. kernels deriving
// from abstract_kernel). Falls back to the global ::logger::root() singleton.
::logger* logger = nullptr;
::logger& log() const { return logger ? *logger : ::logger::root(); }
// from abstract_kernel). Falls back to the global ifcopenshell::logger::root() singleton.
ifcopenshell::logger* logger = nullptr;
ifcopenshell::logger& log() const { return logger ? *logger : ifcopenshell::logger::root(); }
};
IFC_GEOMLIBRARY_API bool boolean_operation(const boolean_settings& settings, const TopoDS_Shape&, const NCollection_List<TopoDS_Shape>&, BOPAlgo_Operation, TopoDS_Shape&, double fuzziness = -1.);
src/ifcgeom/kernels/opencascade/clash_utils.cpp
+4
View File
@@ -6,6 +6,8 @@
#define GU_CULLING_EPSILON_RAY_TRIANGLE FLT_EPSILON*FLT_EPSILON
#define PX_MAX_F32 3.4028234663852885981170418348452e+38F
namespace ifcopenshell::geom {
typedef uint32_t px_u32;
// Why can't I use std::clamp?
@@ -588,3 +590,5 @@ bool trianglesIntersect(const gp_Vec& a1, const gp_Vec& b1, const gp_Vec& c1, co
}
return false;
}
} // namespace ifcopenshell::geom
src/ifcgeom/kernels/opencascade/clash_utils.h
+4
View File
@@ -5,6 +5,8 @@
#include "../ifc_geomlibrary_api.h"
namespace ifcopenshell::geom {
struct IFC_GEOMLIBRARY_API ray {
float origin[3];
float dir[3];
@@ -29,3 +31,5 @@ IFC_GEOMLIBRARY_API void edgeEdgeDist(gp_Vec& x, gp_Vec& y, // closest points
IFC_GEOMLIBRARY_API double distanceTriangleTriangleSquared(gp_Vec& cp, gp_Vec& cq, const std::array<gp_Vec, 3> p, const std::array<gp_Vec, 3> q);
IFC_GEOMLIBRARY_API bool trianglesIntersect(const gp_Vec& a1, const gp_Vec& b1, const gp_Vec& c1, const gp_Vec& a2, const gp_Vec& b2, const gp_Vec& c2/*, Segment* intersection*/, gp_Vec& int1, gp_Vec& int2, bool ignoreCoplanar);
} // namespace ifcopenshell::geom
src/ifcgeom/kernels/opencascade/extrusion.cpp
+2 -2
View File
@@ -9,7 +9,7 @@ bool open_cascade_kernel::convert(const taxonomy::extrusion::ptr extrusion, Topo
const double& height = extrusion->depth;
if (height < settings_.get<settings::Precision>().get()) {
::logger::root().error("GEO", 89, "Non-positive extrusion height encountered for:", extrusion->instance);
ifcopenshell::logger::root().error("GEO", 89, "Non-positive extrusion height encountered for:", extrusion->instance);
return false;
}
@@ -23,7 +23,7 @@ bool open_cascade_kernel::convert(const taxonomy::extrusion::ptr extrusion, Topo
// move the TopoDS_Shape, but obviously not both.
gp_GTrsf gtrsf;
if (!convert(&extrusion->matrix, gtrsf)) {
::logger::root().error("Unable to move extrusion");
ifcopenshell::logger::root().error("Unable to move extrusion");
}
auto trsf = gtrsf.Trsf();
*/
src/ifcgeom/kernels/opencascade/face.cpp
+14 -14
View File
@@ -174,7 +174,7 @@ namespace {
} else if (crv_or_wire.index() == 2) {
// @todo
const double precision_ = 1.e-5;
::logger::root().warning("GEO", 156, "Approximating BasisCurve due to possible discontinuities", i->instance);
ifcopenshell::logger::root().warning("GEO", 156, "Approximating BasisCurve due to possible discontinuities", i->instance);
const auto& w = std::get<TopoDS_Wire>(crv_or_wire);
#if OCC_VERSION_HEX < 0x70600
BRepAdaptor_CompCurve cc(w, true);
@@ -294,12 +294,12 @@ bool open_cascade_kernel::convert(const taxonomy::face::ptr face, TopoDS_Shape&
// the face will still be processed as long as there are no holes. A compound of faces
// is returned in that case.
if (num_bounds > 1 && num_outer_bounds > 1 && num_bounds != num_outer_bounds) {
::logger::root().message(::logger::LOG_ERROR, "GEO", 157, "Invalid configuration of boundaries for:", face->instance);
ifcopenshell::logger::root().message(ifcopenshell::logger::LOG_ERROR, "GEO", 157, "Invalid configuration of boundaries for:", face->instance);
return false;
}
if (num_outer_bounds > 1) {
::logger::root().message(::logger::LOG_WARNING, "GEO", 158, "Multiple outer boundaries for:", face->instance);
ifcopenshell::logger::root().message(ifcopenshell::logger::LOG_WARNING, "GEO", 158, "Multiple outer boundaries for:", face->instance);
fd.all_outer() = true;
}
@@ -320,11 +320,11 @@ bool open_cascade_kernel::convert(const taxonomy::face::ptr face, TopoDS_Shape&
TopoDS_Wire wire;
if (faceset_helper_ && bound->is_polyhedron()) {
if (!faceset_helper_->wire(bound, wire)) {
::logger::root().message(::logger::LOG_WARNING, "GEO", 159, "Face boundary loop not included", bound->instance);
ifcopenshell::logger::root().message(ifcopenshell::logger::LOG_WARNING, "GEO", 159, "Face boundary loop not included", bound->instance);
continue;
}
} else if (!convert(bound, wire)) {
::logger::root().message(::logger::LOG_ERROR, "GEO", 160, "Failed to process face boundary loop", bound->instance);
ifcopenshell::logger::root().message(ifcopenshell::logger::LOG_ERROR, "GEO", 160, "Failed to process face boundary loop", bound->instance);
return false;
}
@@ -341,7 +341,7 @@ bool open_cascade_kernel::convert(const taxonomy::face::ptr face, TopoDS_Shape&
};
NCollection_List<TopoDS_Shape> results;
if (settings.use_wire_intersection_check && util::wire_intersections(wire, results, settings)) {
::logger::root().warning("GEO", 161, "Self-intersections with " + boost::lexical_cast<std::string>(results.Extent()) + " cycles detected");
ifcopenshell::logger::root().warning("GEO", 161, "Self-intersections with " + boost::lexical_cast<std::string>(results.Extent()) + " cycles detected");
util::select_largest(results, wire);
}
@@ -352,7 +352,7 @@ bool open_cascade_kernel::convert(const taxonomy::face::ptr face, TopoDS_Shape&
}
if (fd.wires().empty()) {
::logger::root().warning("GEO", 162, "Face with no boundaries", face->instance);
ifcopenshell::logger::root().warning("GEO", 162, "Face with no boundaries", face->instance);
return false;
}
@@ -430,7 +430,7 @@ bool open_cascade_kernel::convert(const taxonomy::face::ptr face, TopoDS_Shape&
if (fd.surface().IsNull()) {
// The set of wires is triangulated in case no surface can be found
::logger::root().message(::logger::LOG_WARNING, "GEO", 163, "Triangulating face boundaries for face", face->instance);
ifcopenshell::logger::root().message(ifcopenshell::logger::LOG_WARNING, "GEO", 163, "Triangulating face boundaries for face", face->instance);
if (fd.all_outer()) {
for (const auto& w : fd.wires()) {
@@ -483,7 +483,7 @@ bool open_cascade_kernel::convert(const taxonomy::face::ptr face, TopoDS_Shape&
kt.Value().Original().ToUTF8CString(c);
std::string message = c;
delete[] c;
::logger::root().warning("GEO", 164, message, face->instance);
ifcopenshell::logger::root().warning("GEO", 164, message, face->instance);
}
}
@@ -495,17 +495,17 @@ bool open_cascade_kernel::convert(const taxonomy::face::ptr face, TopoDS_Shape&
if (it.Value().ShapeType() == TopAbs_FACE) {
face_list.Append(it.Value());
} else {
::logger::root().error("UNS", 7, "Unsupported output from face healing");
ifcopenshell::logger::root().error("UNS", 7, "Unsupported output from face healing");
}
}
} else {
::logger::root().error("UNS", 8, "Unsupported output from face healing");
ifcopenshell::logger::root().error("UNS", 8, "Unsupported output from face healing");
}
} else {
face_list.Append(f);
}
} else {
::logger::root().error("GEO", 165, "Internal error in face creation");
ifcopenshell::logger::root().error("GEO", 165, "Internal error in face creation");
return false;
}
} else {
@@ -546,14 +546,14 @@ bool open_cascade_kernel::convert(const taxonomy::face::ptr face, TopoDS_Shape&
delete[] c;
#if OCC_VERSION_MAJOR==7 && OCC_VERSION_MINOR >= 7
if (!reversed_surface && !fd.surface().IsNull() && fd.surface()->IsUPeriodic() && message == "Unknown message invoked with the keyword FixAdvFace.FixOrientation.MSG0") {
::logger::root().notice("GEO", 166, "Detected reversed wire, reattempting with reversed basis surface");
ifcopenshell::logger::root().notice("GEO", 166, "Detected reversed wire, reattempting with reversed basis surface");
TopoDS_Face reversed_result;
convert(face, reversed_result, true);
result = reversed_result;
return true;
} else
#endif
::logger::root().warning("GEO", 167, message, face->instance);
ifcopenshell::logger::root().warning("GEO", 167, message, face->instance);
}
}
}
src/ifcgeom/kernels/opencascade/faceset_helper.cpp
+3 -3
View File
@@ -149,7 +149,7 @@ ifcopenshell::geom::open_cascade_kernel::faceset_helper::faceset_helper(
auto num_retained = std::count(retained.begin(), retained.end(), true);
if (unique.size() != num_retained) {
::logger::root().notice("GEO", 168, "Collapsed vertices from " + std::to_string(pnts.size()) + " (" + std::to_string(unique.size()) + " unique) to " + std::to_string(num_retained));
ifcopenshell::logger::root().notice("GEO", 168, "Collapsed vertices from " + std::to_string(pnts.size()) + " (" + std::to_string(unique.size()) + " unique) to " + std::to_string(num_retained));
}
typedef std::array<int, 2> edge_t;
@@ -206,7 +206,7 @@ ifcopenshell::geom::open_cascade_kernel::faceset_helper::faceset_helper(
}
if (duplicates_.size() || loops_removed || (non_manifold && shell->closed.value_or(false))) {
::logger::root().warning("GEO", 169, boost::lexical_cast<std::string>(duplicate_faces) + " duplicate faces removed, " + boost::lexical_cast<std::string>(loops_removed) + " degenerate loops eliminated and " + boost::lexical_cast<std::string>(non_manifold) + " non-manifold edges");
ifcopenshell::logger::root().warning("GEO", 169, boost::lexical_cast<std::string>(duplicate_faces) + " duplicate faces removed, " + boost::lexical_cast<std::string>(loops_removed) + " degenerate loops eliminated and " + boost::lexical_cast<std::string>(non_manifold) + " non-manifold edges");
}
}
@@ -277,7 +277,7 @@ bool ifcopenshell::geom::open_cascade_kernel::faceset_helper::wires(const ifcope
!kernel_->settings().get<ifcopenshell::geom::settings::NoWireIntersectionTolerance>().get(), 0.,
kernel_->settings().get<ifcopenshell::geom::settings::Precision>().get()}))
{
::logger::root().warning("GEO", 170, "Self-intersections with " + boost::lexical_cast<std::string>(results.Extent()) + " cycles detected");
ifcopenshell::logger::root().warning("GEO", 170, "Self-intersections with " + boost::lexical_cast<std::string>(results.Extent()) + " cycles detected");
non_manifold_ = true;
wires = results;
} else {
src/ifcgeom/kernels/opencascade/layerset.cpp
+6 -6
View File
@@ -132,7 +132,7 @@ namespace {
}
}
::logger::root().error("GEO", 171, "Unable to map layer geometry to material index");
ifcopenshell::logger::root().error("GEO", 171, "Unable to map layer geometry to material index");
return false;
}
}
@@ -237,7 +237,7 @@ bool ifcopenshell::geom::util::apply_folded_layerset(const conversion_results& i
if (s.ShapeType() == TopAbs_SHELL) {
shells.Append(TopoDS::Shell(s));
} else {
::logger::root().error("GEO", 172, "Expected shell type in layerset processing");
ifcopenshell::logger::root().error("GEO", 172, "Expected shell type in layerset processing");
return false;
}
}
@@ -436,12 +436,12 @@ bool ifcopenshell::geom::util::split_solid_by_shell(const TopoDS_Shape& input, c
}
} catch (const Standard_Failure& e) {
if (e.GetMessageString() && strlen(e.GetMessageString())) {
::logger::root().error("GEO", 173, e.GetMessageString());
ifcopenshell::logger::root().error("GEO", 173, e.GetMessageString());
} else {
::logger::root().error("GEO", 174, "Unknown error performing fixes");
ifcopenshell::logger::root().error("GEO", 174, "Unknown error performing fixes");
}
} catch (...) {
::logger::root().error("GEO", 175, "Unknown error performing fixes");
ifcopenshell::logger::root().error("GEO", 175, "Unknown error performing fixes");
}
BRepCheck_Analyzer analyser(shape);
bool is_valid = analyser.IsValid() != 0;
@@ -451,7 +451,7 @@ bool ifcopenshell::geom::util::split_solid_by_shell(const TopoDS_Shape& input, c
}
if (is_null[0] || is_null[1]) {
::logger::root().message(::logger::LOG_ERROR, "GEO", 176, "Null result obtained from layerset slicing");
ifcopenshell::logger::root().message(ifcopenshell::logger::LOG_ERROR, "GEO", 176, "Null result obtained from layerset slicing");
if (is_null[0] && is_null[1]) {
return false;
}
src/ifcgeom/kernels/opencascade/loft.cpp
+4 -4
View File
@@ -82,7 +82,7 @@ bool open_cascade_kernel::convert(const taxonomy::loft::ptr loft, TopoDS_Shape&
if (non_polygonal) {
if (loft->children.size() < 2) {
::logger::root().error("GEO", 177, "Not enough sections to loft");
ifcopenshell::logger::root().error("GEO", 177, "Not enough sections to loft");
return false;
}
@@ -122,7 +122,7 @@ bool open_cascade_kernel::convert(const taxonomy::loft::ptr loft, TopoDS_Shape&
auto first_wire_count = sections.front().size();
for (auto& section : sections) {
if (section.size() != first_wire_count) {
::logger::root().error("GEO", 178, "Inconsistent number of wires in sections");
ifcopenshell::logger::root().error("GEO", 178, "Inconsistent number of wires in sections");
return false;
}
}
@@ -159,7 +159,7 @@ bool open_cascade_kernel::convert(const taxonomy::loft::ptr loft, TopoDS_Shape&
return true;
} else {
::logger::root().error("Lofting more than two sections is not supported");
ifcopenshell::logger::root().error("Lofting more than two sections is not supported");
return false;
}
}
@@ -275,7 +275,7 @@ bool open_cascade_kernel::convert(const taxonomy::loft::ptr loft, TopoDS_Shape&
*/
if (shps.size() < 2) {
::logger::root().error("GEO", 179, "Not enough sections to loft");
ifcopenshell::logger::root().error("GEO", 179, "Not enough sections to loft");
return false;
}
src/ifcgeom/kernels/opencascade/loop.cpp
+3 -3
View File
@@ -129,7 +129,7 @@ namespace {
} else {
// @todo
const double precision_ = 1.e-5;
::logger::root().warning("GEO", 180, "Approximating BasisCurve due to possible discontinuities", e->instance);
ifcopenshell::logger::root().warning("GEO", 180, "Approximating BasisCurve due to possible discontinuities", e->instance);
const auto& w = std::get<TopoDS_Wire>(crv_or_wire);
#if OCC_VERSION_HEX < 0x70600
BRepAdaptor_CompCurve cc(w, true);
@@ -283,7 +283,7 @@ bool open_cascade_kernel::convert(const taxonomy::loop::ptr loop, TopoDS_Wire& w
}
if (converted_segments.Extent() == 0) {
::logger::root().message(::logger::LOG_ERROR, "GEO", 181, "No segment successfully converted:", loop->instance);
ifcopenshell::logger::root().message(ifcopenshell::logger::LOG_ERROR, "GEO", 181, "No segment successfully converted:", loop->instance);
return false;
}
@@ -348,7 +348,7 @@ bool open_cascade_kernel::convert(const taxonomy::loop::ptr loop, TopoDS_Wire& w
if (ang < 0.0314) {
edges_to_tesselate.Add(crv1->DynamicType() == STANDARD_TYPE(Geom_Circle) ? edges.First() : edges.Last());
::logger::root().notice("GEO", 182, "Sharp circular corner detecting, substituting with linear approximation");
ifcopenshell::logger::root().notice("GEO", 182, "Sharp circular corner detecting, substituting with linear approximation");
}
}
}
src/ifcgeom/kernels/opencascade/shell.cpp
+3 -3
View File
@@ -57,7 +57,7 @@ bool open_cascade_kernel::convert(const taxonomy::shell::ptr l, TopoDS_Shape& sh
}
if (!success) {
logger_.message(::logger::LOG_WARNING, "GEO", 198, "Failed to convert face:", face->instance);
logger_.message(ifcopenshell::logger::LOG_WARNING, "GEO", 198, "Failed to convert face:", face->instance);
continue;
}
@@ -70,7 +70,7 @@ bool open_cascade_kernel::convert(const taxonomy::shell::ptr l, TopoDS_Shape& sh
if (face_area(triangle) > min_face_area) {
face_list.Append(triangle);
} else {
logger_.message(::logger::LOG_WARNING, "GEO", 199, "Degenerate face:", face->instance);
logger_.message(ifcopenshell::logger::LOG_WARNING, "GEO", 199, "Degenerate face:", face->instance);
}
}
}
@@ -78,7 +78,7 @@ bool open_cascade_kernel::convert(const taxonomy::shell::ptr l, TopoDS_Shape& sh
if (face_area(occ_face) > min_face_area) {
face_list.Append(occ_face);
} else {
logger_.message(::logger::LOG_WARNING, "GEO", 200, "Degenerate face:", face->instance);
logger_.message(ifcopenshell::logger::LOG_WARNING, "GEO", 200, "Degenerate face:", face->instance);
}
}
}
src/ifcgeom/kernels/opencascade/sweep_along_curve.cpp
+1 -1
View File
@@ -182,7 +182,7 @@ bool open_cascade_kernel::convert(const taxonomy::sweep_along_curve::ptr scs, To
for (TopExp_Explorer exp(wire, TopAbs_VERTEX); exp.More(); exp.Next()) {
if (pln.Distance(BRep_Tool::Pnt(TopoDS::Vertex(exp.Current()))) > ALMOST_ZERO) {
directrix_on_plane = false;
logger_.message(::logger::LOG_WARNING, "GEO", 202, "The Directrix does not lie on the ReferenceSurface", scs->instance);
logger_.message(ifcopenshell::logger::LOG_WARNING, "GEO", 202, "The Directrix does not lie on the ReferenceSurface", scs->instance);
break;
}
}
src/ifcgeom/kernels/opencascade/sweep_utils.cpp
+2 -2
View File
@@ -97,7 +97,7 @@ bool ifcopenshell::geom::util::wire_to_ax(const TopoDS_Wire & wire, gp_Ax2 & dir
Handle(Geom_Curve) crv = BRep_Tool::Curve(edge, u0, u1);
crv->D1(u0, directrix_origin, directrix_tangent);
} else {
::logger::root().error("GEO", 203, "Unable to locate first edge");
ifcopenshell::logger::root().error("GEO", 203, "Unable to locate first edge");
return false;
}
@@ -187,7 +187,7 @@ void ifcopenshell::geom::util::sort_edges(const TopoDS_Wire & wire, std::vector<
for (int i = 1; i <= map.Extent(); ++i) {
if (map.FindFromIndex(i).Extent() > 2) {
::logger::root().warning("GEO", 204, "Self-intersecting Directrix");
ifcopenshell::logger::root().warning("GEO", 204, "Self-intersecting Directrix");
}
}
src/ifcgeom/kernels/opencascade/wire_builder.cpp
+10 -10
View File
@@ -117,12 +117,12 @@ bool ifcopenshell::geom::util::create_edge_over_curve_with_log_messages(const op
}
}
if (dmin == std::numeric_limits<double>::infinity()) {
::logger::root().error("GEO", 205, "No extrema for point");
ifcopenshell::logger::root().error("GEO", 205, "No extrema for point");
} else if (dmin > eps2) {
::logger::root().error("GEO", 206, "Distance of " + boost::lexical_cast<std::string>(std::sqrt(dmin)) + " exceeds tolerance");
ifcopenshell::logger::root().error("GEO", 206, "Distance of " + boost::lexical_cast<std::string>(std::sqrt(dmin)) + " exceeds tolerance");
}
} else {
::logger::root().error("GEO", 207, "Failed to calculate extrema for point");
ifcopenshell::logger::root().error("GEO", 207, "Failed to calculate extrema for point");
}
}
}
@@ -172,7 +172,7 @@ void ifcopenshell::geom::util::wire_builder::operator()(const TopoDS_Shape& a, c
if (dist > 1000. * p_) {
mw_.Add(w1);
mw_.Add(BRepBuilderAPI_MakeEdge(p1, p2));
::logger::root().warning("GEO", 208, "Added additional segment to close gap with length " + boost::lexical_cast<std::string>(dist) + " to:", inst_);
ifcopenshell::logger::root().warning("GEO", 208, "Added additional segment to close gap with length " + boost::lexical_cast<std::string>(dist) + " to:", inst_);
goto check;
}
@@ -200,28 +200,28 @@ void ifcopenshell::geom::util::wire_builder::operator()(const TopoDS_Shape& a, c
// Preferably adjust the segment that is linear
if (is_line1 || (is_circle1 && !is_line2)) {
mw_.Add(adjust(w1, w12, p2));
::logger::root().notice("GEO", 209, "Adjusted edge end-point with distance " + boost::lexical_cast<std::string>(dist) + " on:", inst_);
ifcopenshell::logger::root().notice("GEO", 209, "Adjusted edge end-point with distance " + boost::lexical_cast<std::string>(dist) + " on:", inst_);
} else if ((is_line2 || is_circle2) && !last) {
mw_.Add(w1);
override_next_ = true;
next_override_ = p1;
::logger::root().notice("GEO", 210, "Adjusted edge end-point with distance " + boost::lexical_cast<std::string>(dist) + " on:", inst_);
ifcopenshell::logger::root().notice("GEO", 210, "Adjusted edge end-point with distance " + boost::lexical_cast<std::string>(dist) + " on:", inst_);
} else {
// In all other cases an edge is added
mw_.Add(w1);
mw_.Add(BRepBuilderAPI_MakeEdge(p1, p2));
::logger::root().warning("GEO", 211, "Added additional segment to close gap with length " + boost::lexical_cast<std::string>(dist) + " to:", inst_);
ifcopenshell::logger::root().warning("GEO", 211, "Added additional segment to close gap with length " + boost::lexical_cast<std::string>(dist) + " to:", inst_);
}
} else {
::logger::root().error("GEO", 212, "Internal error, inconsistent wire segments", inst_);
ifcopenshell::logger::root().error("GEO", 212, "Internal error, inconsistent wire segments", inst_);
mw_.Add(w1);
}
}
check:
if (mw_.Error() == BRepBuilderAPI_NonManifoldWire) {
::logger::root().error("GEO", 213, "Non-manifold curve segments:", inst_);
ifcopenshell::logger::root().error("GEO", 213, "Non-manifold curve segments:", inst_);
} else if (mw_.Error() == BRepBuilderAPI_DisconnectedWire) {
::logger::root().error("GEO", 214, "Failed to join curve segments:", inst_);
ifcopenshell::logger::root().error("GEO", 214, "Failed to join curve segments:", inst_);
}
}
src/ifcgeom/kernels/opencascade/wire_utils.cpp
+17 -17
View File
@@ -90,7 +90,7 @@ bool ifcopenshell::geom::util::approximate_plane_through_wire(const TopoDS_Wire&
// obtaining a 2d points for the Delaunay, infinity is passed here, so this
// can't for assessing degenerativeness.
if (v.Magnitude() < 1.e-7) {
::logger::root().warning("GEO", 215, "Degenerate face boundary in normal estimation");
ifcopenshell::logger::root().warning("GEO", 215, "Degenerate face boundary in normal estimation");
return false;
}
@@ -237,7 +237,7 @@ ifcopenshell::geom::util::triangulate_wire_result ifcopenshell::geom::util::tria
auto it = mapping.find(uvnodes[k]);
if (it == mapping.end()) {
::logger::root().error("GEO", 216, "Internal error: unable to unproject uv-mesh");
ifcopenshell::logger::root().error("GEO", 216, "Internal error: unable to unproject uv-mesh");
return TRIANGULATE_WIRE_FAIL;
}
@@ -281,7 +281,7 @@ ifcopenshell::geom::util::triangulate_wire_result ifcopenshell::geom::util::tria
}
faces.Append(triangle_face);
} else {
::logger::root().error("GEO", 217, "Internal error: missing face");
ifcopenshell::logger::root().error("GEO", 217, "Internal error: missing face");
return TRIANGULATE_WIRE_FAIL;
}
}
@@ -312,7 +312,7 @@ ifcopenshell::geom::util::triangulate_wire_result ifcopenshell::geom::util::tria
if (!contains) {
#endif
// All existing edges need to exist in the new faces
::logger::root().error("GEO", 218, "Internal error, missing edge from triangulation");
ifcopenshell::logger::root().error("GEO", 218, "Internal error, missing edge from triangulation");
non_manifold = true;
}
}
@@ -323,7 +323,7 @@ ifcopenshell::geom::util::triangulate_wire_result ifcopenshell::geom::util::tria
// Existing edges are boundaries with use 1
// New edges are internal with use 2
if (n != (mape.Contains(v) ? 1 : 2)) {
::logger::root().error("GEO", 219, "Internal error, non-manifold result from triangulation");
ifcopenshell::logger::root().error("GEO", 219, "Internal error, non-manifold result from triangulation");
non_manifold = true;
}
}
@@ -794,12 +794,12 @@ bool ifcopenshell::geom::util::fill_nonmanifold_wires_with_planar_faces(TopoDS_S
shape = solid.SolidFromShell(TopoDS::Shell(shape));
} catch (const Standard_Failure& e) {
if (e.GetMessageString() && strlen(e.GetMessageString())) {
::logger::root().error("GEO", 220, e.GetMessageString());
ifcopenshell::logger::root().error("GEO", 220, e.GetMessageString());
} else {
::logger::root().error("GEO", 221, "Unknown error creating solid");
ifcopenshell::logger::root().error("GEO", 221, "Unknown error creating solid");
}
} catch (...) {
::logger::root().error("GEO", 222, "Unknown error creating solid");
ifcopenshell::logger::root().error("GEO", 222, "Unknown error creating solid");
}
return true;
@@ -812,12 +812,12 @@ bool ifcopenshell::geom::util::convert_curve_to_wire(const opencascade::handle<G
return true;
} catch (const Standard_Failure& e) {
if (e.GetMessageString() && strlen(e.GetMessageString())) {
::logger::root().error("GEO", 223, e.GetMessageString());
ifcopenshell::logger::root().error("GEO", 223, e.GetMessageString());
} else {
::logger::root().error("GEO", 224, "Unknown error converting curve to wire");
ifcopenshell::logger::root().error("GEO", 224, "Unknown error converting curve to wire");
}
} catch (...) {
::logger::root().error("GEO", 225, "Unknown error converting curve to wire");
ifcopenshell::logger::root().error("GEO", 225, "Unknown error converting curve to wire");
}
return false;
}
@@ -838,7 +838,7 @@ void ifcopenshell::geom::util::assert_closed_wire(TopoDS_Wire& wire, double tol)
wire = mw.Wire();
}
::logger::root().warning("GEO", 226, "Wire not closed");
ifcopenshell::logger::root().warning("GEO", 226, "Wire not closed");
}
}
@@ -848,7 +848,7 @@ bool ifcopenshell::geom::util::convert_wire_to_face(const TopoDS_Wire& w, TopoDS
NCollection_List<TopoDS_Shape> results;
if (settings.use_wire_intersection_check && util::wire_intersections(wire, results, settings)) {
::logger::root().warning("GEO", 227, "Self-intersections with " + boost::lexical_cast<std::string>(results.Extent()) + " cycles detected");
ifcopenshell::logger::root().warning("GEO", 227, "Self-intersections with " + boost::lexical_cast<std::string>(results.Extent()) + " cycles detected");
util::select_largest(results, wire);
}
@@ -879,7 +879,7 @@ bool ifcopenshell::geom::util::convert_wire_to_face(const TopoDS_Wire& w, TopoDS
BRepBuilderAPI_FaceError er = mf.Error();
if (er != BRepBuilderAPI_FaceDone) {
::logger::root().error("GEO", 228, "Failed to create face.");
ifcopenshell::logger::root().error("GEO", 228, "Failed to create face.");
return false;
}
face = mf.Face();
@@ -906,7 +906,7 @@ bool ifcopenshell::geom::util::convert_wire_to_faces(const TopoDS_Wire& w, TopoD
NCollection_List<TopoDS_Shape> results;
if (settings.use_wire_intersection_check && util::wire_intersections(w, results, settings)) {
::logger::root().warning("GEO", 229, "Self-intersections with " + boost::lexical_cast<std::string>(results.Extent()) + " cycles detected");
ifcopenshell::logger::root().warning("GEO", 229, "Self-intersections with " + boost::lexical_cast<std::string>(results.Extent()) + " cycles detected");
} else {
results.Clear();
results.Append(w);
@@ -932,7 +932,7 @@ bool ifcopenshell::geom::util::convert_wire_to_faces(const TopoDS_Wire& w, TopoD
BRepBuilderAPI_FaceError er = mf.Error();
if (er != BRepBuilderAPI_FaceDone) {
::logger::root().error("GEO", 230, "Failed to create face.");
ifcopenshell::logger::root().error("GEO", 230, "Failed to create face.");
continue;
}
@@ -949,7 +949,7 @@ bool ifcopenshell::geom::util::convert_wire_to_faces(const TopoDS_Wire& w, TopoD
if (p.first >= max_area / 10.) {
B.Add(faces, p.second);
} else {
::logger::root().warning("GEO", 231, "Ignoring self-intersection loop with area " + boost::lexical_cast<std::string>(p.first));
ifcopenshell::logger::root().warning("GEO", 231, "Ignoring self-intersection loop with area " + boost::lexical_cast<std::string>(p.first));
}
}
src/ifcgeom/kernels/passthrough/PassthroughConversionResult.cpp
+1 -1
View File
@@ -286,7 +286,7 @@ ifcopenshell::geom::passthrough_shape::passthrough_shape(const std::vector<passt
ifcopenshell::geom::passthrough_shape::passthrough_shape(std::vector<passthrough_part>&& parts)
: parts_(normalize_parts(parts)) {}
void ifcopenshell::geom::passthrough_shape::Triangulate(ifcopenshell::geom::settings, const ifcopenshell::geom::taxonomy::matrix4& place, ifcopenshell::geom::Representation::triangulation* t, int item_id, int surface_style_id, ::logger&) const {
void ifcopenshell::geom::passthrough_shape::Triangulate(ifcopenshell::geom::settings, const ifcopenshell::geom::taxonomy::matrix4& place, ifcopenshell::geom::Representation::triangulation* t, int item_id, int surface_style_id, ifcopenshell::logger&) const {
auto mesh = build_mesh(parts_, &place);
std::vector<int> indices(mesh.vertices.size());
for (size_t i = 0; i < mesh.vertices.size(); ++i) {
src/ifcgeom/kernels/passthrough/PassthroughConversionResult.h
+1 -1
View File
@@ -24,7 +24,7 @@ public:
const std::vector<passthrough_part>& parts() const { return parts_; }
virtual std::string_view backend_id() const { return "passthrough"; }
virtual void Triangulate(ifcopenshell::geom::settings settings, const ifcopenshell::geom::taxonomy::matrix4& place, ifcopenshell::geom::Representation::triangulation* t, int item_id, int surface_style_id, ::logger& logger = ::logger::root()) const;
virtual void Triangulate(ifcopenshell::geom::settings settings, const ifcopenshell::geom::taxonomy::matrix4& place, ifcopenshell::geom::Representation::triangulation* t, int item_id, int surface_style_id, ifcopenshell::logger& logger = ifcopenshell::logger::root()) const;
virtual void Serialize(const ifcopenshell::geom::taxonomy::matrix4& place, std::string&) const;
virtual int surface_genus() const;
src/ifcgeom/kernels/passthrough/PassthroughKernel.h
+2 -2
View File
@@ -11,10 +11,10 @@ namespace kernels {
class IFC_GEOMLIBRARY_API passthrough_kernel : public abstract_kernel {
public:
passthrough_kernel(const ifcopenshell::geom::settings& settings, ::logger& logger = ::logger::root())
passthrough_kernel(const ifcopenshell::geom::settings& settings, ifcopenshell::logger& logger = ifcopenshell::logger::root())
: abstract_kernel("passthrough", settings, logger) {}
virtual abstract_kernel* clone(::logger& logger) const {
virtual abstract_kernel* clone(ifcopenshell::logger& logger) const {
return new passthrough_kernel(settings(), logger);
}
src/ifcgeom/mapping/IfcAsymmetricIShapeProfileDef.cpp
+1 -1
View File
@@ -58,7 +58,7 @@ taxonomy::ptr mapping::map_impl(const IfcSchema::IfcAsymmetricIShapeProfileDef&
const double tol = settings_.get<settings::Precision>().get();
if (xb < tol || xt < tol || y < tol || d1 < tol || ftb < tol || ftt < tol) {
logger_.message(::logger::LOG_NOTICE, "GEO", 264, "Skipping zero sized profile:", inst);
logger_.message(ifcopenshell::logger::LOG_NOTICE, "GEO", 264, "Skipping zero sized profile:", inst);
return nullptr;
}
src/ifcgeom/mapping/IfcAxis2PlacementLinear.cpp
+1 -1
View File
@@ -45,7 +45,7 @@ taxonomy::ptr mapping::map_impl(const IfcSchema::IfcAxis2PlacementLinear& inst)
/*
if (hasAxis != hasRef) {
::logger::root().warning("Axis and RefDirection should be specified together", inst);
ifcopenshell::logger::root().warning("Axis and RefDirection should be specified together", inst);
}
*/
src/ifcgeom/mapping/IfcCShapeProfileDef.cpp
+1 -1
View File
@@ -43,7 +43,7 @@ taxonomy::ptr mapping::map_impl(const IfcSchema::IfcCShapeProfileDef& inst) {
const double tol = settings_.get<settings::Precision>().get();
if ( x < tol || y < tol || d1 < tol || d2 < tol) {
logger_.message(::logger::LOG_NOTICE, "GEO", 241, "Skipping zero sized profile:", inst);
logger_.message(ifcopenshell::logger::LOG_NOTICE, "GEO", 241, "Skipping zero sized profile:", inst);
return nullptr;
}
src/ifcgeom/mapping/IfcCircle.cpp
+1 -1
View File
@@ -24,7 +24,7 @@ using namespace ifcopenshell::geom;
taxonomy::ptr mapping::map_impl(const IfcSchema::IfcCircle& inst) {
const double r = inst.Radius() * length_unit_;
if (r < settings_.get<settings::Precision>().get()) {
logger_.message(::logger::LOG_ERROR, "GEO", 237, "Radius not greater than zero for:", inst);
logger_.message(ifcopenshell::logger::LOG_ERROR, "GEO", 237, "Radius not greater than zero for:", inst);
return nullptr;
}
src/ifcgeom/mapping/IfcCompositeCurve.cpp
+5 -5
View File
@@ -128,7 +128,7 @@ taxonomy::ptr mapping::map_impl(const IfcSchema::IfcCompositeCurve* l, TopoDS_Wi
for (auto it = segments->begin(); it != segments->end(); ++it) {
if (!(*it)->declaration().is(IfcSchema::IfcCompositeCurveSegment::Class())) {
::logger::root().error("Not implemented", *it);
ifcopenshell::logger::root().error("Not implemented", *it);
return false;
}
@@ -141,13 +141,13 @@ taxonomy::ptr mapping::map_impl(const IfcSchema::IfcCompositeCurve* l, TopoDS_Wi
TopoDS_Wire segment;
if (curve->as<IfcSchema::IfcLine>()) {
::logger::root().notice("Infinite IfcLine used as ParentCurve of segment, treating as a segment", *it);
ifcopenshell::logger::root().notice("Infinite IfcLine used as ParentCurve of segment, treating as a segment", *it);
Handle_Geom_Curve handle;
convert_curve(curve, handle);
double u0 = 0.0;
double u1 = curve->as<IfcSchema::IfcLine>()->Dir()->Magnitude() * length_unit_;
if (u1 < getValue(GV_PRECISION)) {
::logger::root().warning("Segment length below tolerance", *it);
ifcopenshell::logger::root().warning("Segment length below tolerance", *it);
}
BRepBuilderAPI_MakeEdge me(handle, u0, u1);
if (me.IsDone()) {
@@ -157,7 +157,7 @@ taxonomy::ptr mapping::map_impl(const IfcSchema::IfcCompositeCurve* l, TopoDS_Wi
}
} else if (!convert_wire(curve, segment)) {
const bool failed_on_purpose = curve->as<IfcSchema::IfcPolyline>() && !segment.IsNull();
::logger::root().message(failed_on_purpose ? ::logger::LOG_WARNING : ::logger::LOG_ERROR, "Failed to convert curve:", curve);
ifcopenshell::logger::root().message(failed_on_purpose ? ifcopenshell::logger::LOG_WARNING : ifcopenshell::logger::LOG_ERROR, "Failed to convert curve:", curve);
continue;
}
@@ -173,7 +173,7 @@ taxonomy::ptr mapping::map_impl(const IfcSchema::IfcCompositeCurve* l, TopoDS_Wi
}
if (converted_segments.Extent() == 0) {
::logger::root().message(::logger::LOG_ERROR, "No segment successfully converted:", l);
ifcopenshell::logger::root().message(ifcopenshell::logger::LOG_ERROR, "No segment successfully converted:", l);
return false;
}
src/ifcgeom/mapping/IfcEdge.cpp
+2 -2
View File
@@ -25,14 +25,14 @@ taxonomy::ptr mapping::map_impl(const IfcSchema::IfcEdge& inst) {
auto v1 = inst.EdgeStart().as<IfcSchema::IfcVertexPoint>();
auto v2 = inst.EdgeEnd().as<IfcSchema::IfcVertexPoint>();
if (!v1 || !v2) {
logger_.message(::logger::LOG_ERROR, "GEO", 255, "Only IfcVertexPoints are supported for EdgeStart and -End", inst);
logger_.message(ifcopenshell::logger::LOG_ERROR, "GEO", 255, "Only IfcVertexPoints are supported for EdgeStart and -End", inst);
return nullptr;
}
auto pnt1 = v1.VertexGeometry();
auto pnt2 = v2.VertexGeometry();
if (!pnt1.declaration().is(IfcSchema::IfcCartesianPoint::Class()) || !pnt2.declaration().is(IfcSchema::IfcCartesianPoint::Class())) {
logger_.message(::logger::LOG_ERROR, "GEO", 256, "Only IfcCartesianPoints are supported for VertexGeometry", inst);
logger_.message(ifcopenshell::logger::LOG_ERROR, "GEO", 256, "Only IfcCartesianPoints are supported for VertexGeometry", inst);
return nullptr;
}
src/ifcgeom/mapping/IfcEllipse.cpp
+1 -1
View File
@@ -26,7 +26,7 @@ taxonomy::ptr mapping::map_impl(const IfcSchema::IfcEllipse& inst) {
double y = inst.SemiAxis2() * length_unit_;
const double tol = settings_.get<settings::Precision>().get();
if (x < tol || y < tol) {
logger_.message(::logger::LOG_ERROR, "GEO", 257, "Radius not greater than zero for:", inst);
logger_.message(ifcopenshell::logger::LOG_ERROR, "GEO", 257, "Radius not greater than zero for:", inst);
return nullptr;
}
src/ifcgeom/mapping/IfcEllipseProfileDef.cpp
+1 -1
View File
@@ -26,7 +26,7 @@ taxonomy::ptr mapping::map_impl(const IfcSchema::IfcEllipseProfileDef& inst) {
double ry = inst.SemiAxis2() * length_unit_;
const double tol = settings_.get<settings::Precision>().get();
if (rx < tol || ry < tol) {
logger_.message(::logger::LOG_ERROR, "GEO", 258, "Radius not greater than zero for:", inst);
logger_.message(ifcopenshell::logger::LOG_ERROR, "GEO", 258, "Radius not greater than zero for:", inst);
return nullptr;
}
src/ifcgeom/mapping/IfcExtrudedAreaSolid.cpp
+1 -1
View File
@@ -27,7 +27,7 @@ using namespace ifcopenshell::geom;
taxonomy::ptr mapping::map_impl(const IfcSchema::IfcExtrudedAreaSolid& inst) {
const double height = inst.Depth() * length_unit_;
if (height < settings_.get<settings::Precision>().get()) {
logger_.message(::logger::LOG_ERROR, "GEO", 89, "Non-positive extrusion height encountered for:", inst);
logger_.message(ifcopenshell::logger::LOG_ERROR, "GEO", 89, "Non-positive extrusion height encountered for:", inst);
#ifndef PERMISSIVE_EXTRUSION
return nullptr;
#endif
src/ifcgeom/mapping/IfcExtrudedAreaSolidTapered.cpp
+1 -1
View File
@@ -27,7 +27,7 @@ using namespace ifcopenshell::geom;
taxonomy::ptr mapping::map_impl(const IfcSchema::IfcExtrudedAreaSolidTapered& inst) {
const double height = inst.Depth() * length_unit_;
if (height < settings_.get<settings::Precision>().get()) {
logger_.message(::logger::LOG_ERROR, "GEO", 89, "Non-positive extrusion height encountered for:", inst);
logger_.message(ifcopenshell::logger::LOG_ERROR, "GEO", 89, "Non-positive extrusion height encountered for:", inst);
return nullptr;
}
src/ifcgeom/mapping/IfcFixedReferenceSweptAreaSolid.cpp
+1 -1
View File
@@ -98,7 +98,7 @@ taxonomy::ptr mapping::map_impl(const IfcSchema::IfcFixedReferenceSweptAreaSolid
auto condition_number = svd.singularValues()(0)
/ svd.singularValues()(svd.singularValues().size() - 1);
if (condition_number > 1.e10) {
::logger::root().error("Non-invertible matrix at " + std::to_string(distalong) + " conversion will likely fail.");
ifcopenshell::logger::root().error("Non-invertible matrix at " + std::to_string(distalong) + " conversion will likely fail.");
}
*/
}
src/ifcgeom/mapping/IfcHalfSpaceSolid.cpp
+1 -1
View File
@@ -25,7 +25,7 @@ taxonomy::ptr mapping::map_impl(const IfcSchema::IfcHalfSpaceSolid& inst) {
auto surface = inst.BaseSurface();
auto plane = surface.as<IfcSchema::IfcPlane>();
if (!plane) {
logger_.message(::logger::LOG_ERROR, "UNS", 16, "Unsupported BaseSurface:", surface);
logger_.message(ifcopenshell::logger::LOG_ERROR, "UNS", 16, "Unsupported BaseSurface:", surface);
return nullptr;
}
auto p = taxonomy::make<taxonomy::plane>();
src/ifcgeom/mapping/IfcIShapeProfileDef.cpp
+1 -1
View File
@@ -80,7 +80,7 @@ taxonomy::ptr mapping::map_impl(const IfcSchema::IfcIShapeProfileDef& inst) {
const double tol = settings_.get<settings::Precision>().get();
if (x1 < tol || x2 < tol || y < tol || d1 < tol || ft1 < tol || ft2 < tol) {
logger_.message(::logger::LOG_NOTICE, "GEO", 264, "Skipping zero sized profile:", inst);
logger_.message(ifcopenshell::logger::LOG_NOTICE, "GEO", 264, "Skipping zero sized profile:", inst);
return nullptr;
}
src/ifcgeom/mapping/IfcLShapeProfileDef.cpp
+2 -2
View File
@@ -45,7 +45,7 @@ taxonomy::ptr mapping::map_impl(const IfcSchema::IfcLShapeProfileDef& inst) {
const double tol = settings_.get<settings::Precision>().get();
if ( x < tol || y < tol || d < tol) {
logger_.message(::logger::LOG_NOTICE, "GEO", 265, "Skipping zero sized profile:", inst);
logger_.message(ifcopenshell::logger::LOG_NOTICE, "GEO", 265, "Skipping zero sized profile:", inst);
return nullptr;
}
@@ -77,7 +77,7 @@ taxonomy::ptr mapping::map_impl(const IfcSchema::IfcLShapeProfileDef& inst) {
const double det = a1*b2 - a2*b1;
if (std::fabs(det) < 1.e-5) {
logger_.message(::logger::LOG_NOTICE, "GEO", 266, "Legs do not intersect for:", inst);
logger_.message(ifcopenshell::logger::LOG_NOTICE, "GEO", 266, "Legs do not intersect for:", inst);
return nullptr;
}
src/ifcgeom/mapping/IfcObjectPlacement.cpp
+3 -3
View File
@@ -53,7 +53,7 @@ taxonomy::ptr mapping::map_impl(const IfcSchema::IfcObjectPlacement& inst) {
}
}
#else
::logger::root().warning("Using --site-local-placement or --building-local-placement on IFC4.2 might have issues");
ifcopenshell::logger::root().warning("Using --site-local-placement or --building-local-placement on IFC4.2 might have issues");
#endif
}
}
@@ -126,7 +126,7 @@ taxonomy::ptr mapping::map_impl(const IfcSchema::IfcObjectPlacement& inst) {
if (fallback) {
auto mapped_fallback = taxonomy::cast<taxonomy::matrix4>(map(fallback));
if (!result->ccomponents().isApprox(mapped_fallback->ccomponents())) {
::logger::root().warning("Computed placement differs from fallback", inst);
ifcopenshell::logger::root().warning("Computed placement differs from fallback", inst);
}
}
@@ -134,7 +134,7 @@ taxonomy::ptr mapping::map_impl(const IfcSchema::IfcObjectPlacement& inst) {
auto abs_det = std::abs(result->ccomponents().determinant());
if (abs_det < 1.e-7) {
::logger::root().warning("Ignoring singular matrix:", inst);
ifcopenshell::logger::root().warning("Ignoring singular matrix:", inst);
return nullptr;
}
src/ifcgeom/mapping/IfcPolyLoop.cpp
+3 -3
View File
@@ -36,7 +36,7 @@ taxonomy::ptr mapping::map_impl(const IfcSchema::IfcPolyLoop& inst) {
// A loop should consist of at least three vertices
int original_count = polygon.size();
if (original_count < 3) {
logger_.message(::logger::LOG_WARNING, "GEO", 278, "Not enough edges for:", inst);
logger_.message(ifcopenshell::logger::LOG_WARNING, "GEO", 278, "Not enough edges for:", inst);
return nullptr;
}
@@ -51,11 +51,11 @@ taxonomy::ptr mapping::map_impl(const IfcSchema::IfcPolyLoop& inst) {
int count = polygon.size();
if (original_count - count != 0) {
std::stringstream ss; ss << (original_count - count) << " edges removed for:";
logger_.message(::logger::LOG_WARNING, "GEO", 280, ss.str(), inst);
logger_.message(ifcopenshell::logger::LOG_WARNING, "GEO", 280, ss.str(), inst);
}
if (count < 3) {
logger_.message(::logger::LOG_WARNING, "GEO", 281, "Not enough edges for:", inst);
logger_.message(ifcopenshell::logger::LOG_WARNING, "GEO", 281, "Not enough edges for:", inst);
return nullptr;
}
src/ifcgeom/mapping/IfcRectangleHollowProfileDef.cpp
+1 -1
View File
@@ -37,7 +37,7 @@ taxonomy::ptr mapping::map_impl(const IfcSchema::IfcRectangleHollowProfileDef& i
const double tol = settings_.get<settings::Precision>().get();
if (x < tol || y < tol) {
logger_.message(::logger::LOG_NOTICE, "GEO", 282, "Skipping zero sized profile:", inst);
logger_.message(ifcopenshell::logger::LOG_NOTICE, "GEO", 282, "Skipping zero sized profile:", inst);
return nullptr;
}
src/ifcgeom/mapping/IfcRectangleProfileDef.cpp
+1 -1
View File
@@ -30,7 +30,7 @@ taxonomy::ptr mapping::map_impl(const IfcSchema::IfcRectangleProfileDef& inst) {
const double tol = settings_.get<settings::Precision>().get();
if (x < tol || y < tol) {
logger_.message(::logger::LOG_NOTICE, "GEO", 283, "Skipping zero sized profile:", inst);
logger_.message(ifcopenshell::logger::LOG_NOTICE, "GEO", 283, "Skipping zero sized profile:", inst);
return nullptr;
}
src/ifcgeom/mapping/IfcRectangularTrimmedSurface.cpp
+1 -1
View File
@@ -27,7 +27,7 @@ taxonomy::ptr mapping::map_impl(const IfcSchema::IfcRectangularTrimmedSurface& i
/*
if (!inst.BasisSurface()->declaration().is(IfcSchema::IfcPlane::Class())) {
::logger::root().message(::logger::LOG_ERROR, "Unsupported BasisSurface:", inst.BasisSurface());
ifcopenshell::logger::root().message(ifcopenshell::logger::LOG_ERROR, "Unsupported BasisSurface:", inst.BasisSurface());
return false;
}
gp_Pln pln;
src/ifcgeom/mapping/IfcRevolvedAreaSolid.cpp
+1 -1
View File
@@ -86,7 +86,7 @@ taxonomy::ptr mapping::map_impl(const IfcSchema::IfcRevolvedAreaSolid& inst) {
}
if (intersecting) {
::logger::root().warning("Warning Axis and SweptArea intersecting", l);
ifcopenshell::logger::root().warning("Warning Axis and SweptArea intersecting", l);
}
}
*/
src/ifcgeom/mapping/IfcRoundedRectangleProfileDef.cpp
+1 -1
View File
@@ -31,7 +31,7 @@ taxonomy::ptr mapping::map_impl(const IfcSchema::IfcRoundedRectangleProfileDef&
const double tol = settings_.get<settings::Precision>().get();
if (x < tol || y < tol) {
logger_.message(::logger::LOG_NOTICE, "GEO", 284, "Skipping zero sized profile:", inst);
logger_.message(ifcopenshell::logger::LOG_NOTICE, "GEO", 284, "Skipping zero sized profile:", inst);
return nullptr;
}
src/ifcgeom/mapping/IfcSurfaceCurveSweptAreaSolid.cpp
+3 -3
View File
@@ -49,11 +49,11 @@ taxonomy::ptr mapping::map_impl(const IfcSchema::IfcSurfaceCurveSweptAreaSolid&
if (!is_plane) {
TopoDS_Shape surface_shell;
if (!convert_shape(inst.ReferenceSurface(), surface_shell)) {
::logger::root().error("Failed to convert reference surface", l);
ifcopenshell::logger::root().error("Failed to convert reference surface", l);
return false;
}
if (util::count(surface_shell, TopAbs_FACE) != 1) {
::logger::root().error("Non-continuous reference surface", l);
ifcopenshell::logger::root().error("Non-continuous reference surface", l);
return false;
}
surface_face = TopoDS::Face(TopExp_Explorer(surface_shell, TopAbs_FACE).Current());
@@ -76,7 +76,7 @@ taxonomy::ptr mapping::map_impl(const IfcSchema::IfcSurfaceCurveSweptAreaSolid&
for (TopExp_Explorer exp(wire, TopAbs_VERTEX); exp.More(); exp.Next()) {
if (pln.Distance(BRep_Tool::Pnt(TopoDS::Vertex(exp.Current()))) > ALMOST_ZERO) {
directrix_on_plane = false;
::logger::root().message(::logger::LOG_WARNING, "The Directrix does not lie on the ReferenceSurface", l);
ifcopenshell::logger::root().message(ifcopenshell::logger::LOG_WARNING, "The Directrix does not lie on the ReferenceSurface", l);
break;
}
}
src/ifcgeom/mapping/IfcSweptDiskSolid.cpp
+6 -6
View File
@@ -241,19 +241,19 @@ taxonomy::ptr mapping::map_impl(const IfcSchema::IfcSweptDiskSolid& inst) {
i += 1;
j += 1;
} else {
::logger::root().error("Unexpected amount of fillet edges generated");
ifcopenshell::logger::root().error("Unexpected amount of fillet edges generated");
}
} else {
::logger::root().error("Unable to build fillet, probably edge too short");
ifcopenshell::logger::root().error("Unable to build fillet, probably edge too short");
}
} else {
::logger::root().error("Colinear edges, not applying fillet");
ifcopenshell::logger::root().error("Colinear edges, not applying fillet");
}
i++;
j++;
}
} else {
::logger::root().error("Not enough edges for applying fillet");
ifcopenshell::logger::root().error("Not enough edges for applying fillet");
}
TopoDS_Wire new_wire;
@@ -266,7 +266,7 @@ taxonomy::ptr mapping::map_impl(const IfcSchema::IfcSweptDiskSolid& inst) {
wire = new_wire;
} else {
::logger::root().error("Directrix is not polyhedral, ignoring FilletRadius");
ifcopenshell::logger::root().error("Directrix is not polyhedral, ignoring FilletRadius");
}
}
@@ -317,7 +317,7 @@ taxonomy::ptr mapping::map_impl(const IfcSchema::IfcSweptDiskSolid& inst) {
}
if (!is_valid) {
::logger::root().message(::logger::LOG_WARNING, "Failed to subtract inner radius void for:", l);
ifcopenshell::logger::root().message(ifcopenshell::logger::LOG_WARNING, "Failed to subtract inner radius void for:", l);
}
}
src/ifcgeom/mapping/IfcTShapeProfileDef.cpp
+2 -2
View File
@@ -40,7 +40,7 @@ taxonomy::ptr mapping::map_impl(const IfcSchema::IfcTShapeProfileDef& inst) {
const double tol = settings_.get<settings::Precision>().get();
if (x < tol || y < tol || d1 < tol || d2 < tol) {
logger_.message(::logger::LOG_NOTICE, "GEO", 296, "Skipping zero sized profile:", inst);
logger_.message(ifcopenshell::logger::LOG_NOTICE, "GEO", 296, "Skipping zero sized profile:", inst);
return nullptr;
}
@@ -88,7 +88,7 @@ taxonomy::ptr mapping::map_impl(const IfcSchema::IfcTShapeProfileDef& inst) {
const double det = a1*b2 - a2*b1;
if (std::fabs(det) < 1.e-5) {
logger_.message(::logger::LOG_NOTICE, "GEO", 297, "Web and flange do not intersect for:", inst);
logger_.message(ifcopenshell::logger::LOG_NOTICE, "GEO", 297, "Web and flange do not intersect for:", inst);
return nullptr;
}
src/ifcgeom/mapping/IfcTrapeziumProfileDef.cpp
+1 -1
View File
@@ -36,7 +36,7 @@ taxonomy::ptr mapping::map_impl(const IfcSchema::IfcTrapeziumProfileDef& inst) {
const double tol = settings_.get<settings::Precision>().get();
if (x1 < tol || w < tol || y < tol) {
logger_.message(::logger::LOG_NOTICE, "GEO", 294, "Skipping zero sized profile:", inst);
logger_.message(ifcopenshell::logger::LOG_NOTICE, "GEO", 294, "Skipping zero sized profile:", inst);
return nullptr;
}
src/ifcgeom/mapping/IfcTrimmedCurve.cpp
+3 -3
View File
@@ -76,7 +76,7 @@ taxonomy::ptr mapping::map_impl(const IfcSchema::IfcTrimmedCurve& inst) {
bool trim_cartesian_failed = !trim_cartesian;
if (trim_cartesian) {
if ((pnts[0]->ccomponents() - pnts[1]->ccomponents()).norm() < (2 * tol)) {
logger_.message(::logger::LOG_WARNING, "GEO", 295, "Skipping segment with length below tolerance level:", inst);
logger_.message(ifcopenshell::logger::LOG_WARNING, "GEO", 295, "Skipping segment with length below tolerance level:", inst);
return nullptr;
}
tc->start = pnts[0];
@@ -140,7 +140,7 @@ taxonomy::ptr mapping::map_impl(const IfcSchema::IfcTrimmedCurve& inst) {
TopoDS_Vertex v0, v1;
TopExp::Vertices(e, v0, v1);
if (v0.IsSame(v1)) {
::logger::root().warning("Skipping degenerate segment", l);
ifcopenshell::logger::root().warning("Skipping degenerate segment", l);
return false;
}
}
@@ -168,7 +168,7 @@ taxonomy::ptr mapping::map_impl(const IfcSchema::IfcTrimmedCurve& inst) {
TopoDS_Vertex v0, v1;
TopExp::Vertices(e, v0, v1);
e = TopoDS::Edge(BRepBuilderAPI_MakeEdge(v0, v1).Edge().Oriented(e.Orientation()));
::logger::root().warning("Substituted edge with linear approximation", l);
ifcopenshell::logger::root().warning("Substituted edge with linear approximation", l);
}
}
src/ifcgeom/mapping/IfcUShapeProfileDef.cpp
+1 -1
View File
@@ -54,7 +54,7 @@ taxonomy::ptr mapping::map_impl(const IfcSchema::IfcUShapeProfileDef& inst) {
const double tol = settings_.get<settings::Precision>().get();
if (x < tol || y < tol || d1 < tol || d2 < tol) {
logger_.message(::logger::LOG_NOTICE, "GEO", 298, "Skipping zero sized profile:", inst);
logger_.message(ifcopenshell::logger::LOG_NOTICE, "GEO", 298, "Skipping zero sized profile:", inst);
return nullptr;
}
src/ifcgeom/mapping/IfcZShapeProfileDef.cpp
+1 -1
View File
@@ -45,7 +45,7 @@ taxonomy::ptr mapping::map_impl(const IfcSchema::IfcZShapeProfileDef& inst) {
const double tol = settings_.get<settings::Precision>().get();
if (x < tol || y < tol || dx < tol || dy < tol) {
logger_.message(::logger::LOG_NOTICE, "GEO", 299, "Skipping zero sized profile:", inst);
logger_.message(ifcopenshell::logger::LOG_NOTICE, "GEO", 299, "Skipping zero sized profile:", inst);
return nullptr;
}
src/ifcgeom/mapping/mapping.cpp
+8 -8
View File
@@ -40,7 +40,7 @@ using namespace ifcopenshell::geom;
namespace {
struct POSTFIX_SCHEMA(factory_t) {
abstract_mapping* operator()(ifcopenshell::file* file, ifcopenshell::geom::settings& settings, ::logger& logger) const {
abstract_mapping* operator()(ifcopenshell::file* file, ifcopenshell::geom::settings& settings, ifcopenshell::logger& logger) const {
ifcopenshell::geom::POSTFIX_SCHEMA(mapping)* m = new ifcopenshell::geom::POSTFIX_SCHEMA(mapping)(file, settings, logger);
return m;
}
@@ -774,7 +774,7 @@ taxonomy::ptr mapping::map(const express::base& inst) {
cache_.insert({iden, item});
}
} else if (!matched) {
logger_.message(::logger::LOG_ERROR, "GEO", 307, "No operation defined for:", inst);
logger_.message(ifcopenshell::logger::LOG_ERROR, "GEO", 307, "No operation defined for:", inst);
}
return item;
}
@@ -927,7 +927,7 @@ void mapping::initialize_units_() {
} catch (const ifcopenshell::exception& ex) {
std::stringstream ss;
ss << "Failed to determine unit information '" << ex.what() << "'";
logger_.message(::logger::LOG_ERROR, "GEO", 311, ss.str());
logger_.message(ifcopenshell::logger::LOG_ERROR, "GEO", 311, ss.str());
}
if (!length_unit_encountered) {
@@ -1012,7 +1012,7 @@ void mapping::initialize_settings() {
if (any_precision_encountered) {
if (lowest_precision_encountered < 1.e-7) {
logger_.message(::logger::LOG_WARNING, "SYS", 33, "Precision lower than 0.0000001 meter not enforced");
logger_.message(ifcopenshell::logger::LOG_WARNING, "SYS", 33, "Precision lower than 0.0000001 meter not enforced");
precision_to_set = 1.e-7;
} else {
precision_to_set = lowest_precision_encountered;
@@ -1063,7 +1063,7 @@ bool mapping::get_layerset_information(const express::base& p, layerset_informat
IfcSchema::IfcRepresentation axis_representation = find_representation(product, "Axis");
if (!axis_representation) {
logger_.message(::logger::LOG_WARNING, "GEO", 315, "No axis representation for:", product);
logger_.message(ifcopenshell::logger::LOG_WARNING, "GEO", 315, "No axis representation for:", product);
return false;
}
@@ -1138,7 +1138,7 @@ bool mapping::get_layerset_information(const express::base& p, layerset_informat
}
if (extrusions.size() != 1) {
logger_.message(::logger::LOG_WARNING, "GEO", 316, "No single extrusion found in body representation for:", product);
logger_.message(ifcopenshell::logger::LOG_WARNING, "GEO", 316, "No single extrusion found in body representation for:", product);
return false;
}
@@ -1153,7 +1153,7 @@ bool mapping::get_layerset_information(const express::base& p, layerset_informat
if (has_position) {
auto m4 = taxonomy::cast<taxonomy::matrix4>(map(extrusion.Position()));
if (!m4) {
logger_.message(::logger::LOG_ERROR, "GEO", 317, "Failed to convert placement for extrusion of:", product);
logger_.message(ifcopenshell::logger::LOG_ERROR, "GEO", 317, "Failed to convert placement for extrusion of:", product);
return false;
} else {
extrusion_position = m4;
@@ -1163,7 +1163,7 @@ bool mapping::get_layerset_information(const express::base& p, layerset_informat
taxonomy::direction3::ptr extrusion_direction = taxonomy::cast<taxonomy::direction3>(map(extrusion.ExtrudedDirection()));
if (!extrusion_direction) {
logger_.message(::logger::LOG_ERROR, "GEO", 318, "Failed to convert direction for extrusion of:", product);
logger_.message(ifcopenshell::logger::LOG_ERROR, "GEO", 318, "Failed to convert direction for extrusion of:", product);
return false;
}
src/ifcgeom/mapping/mapping.h
+4 -4
View File
@@ -75,19 +75,19 @@ namespace geom {
}
}
} catch (const std::exception& e) {
logger_.message(::logger::LOG_ERROR, "GEO", 325, std::string(e.what()) + "\nFailed to convert:", inst);
logger_.message(ifcopenshell::logger::LOG_ERROR, "GEO", 325, std::string(e.what()) + "\nFailed to convert:", inst);
}
} else if (failed_on_purpose_.find(inst) == failed_on_purpose_.end()) {
logger_.message(::logger::LOG_ERROR, "GEO", 326, "Failed to convert:", inst);
logger_.message(ifcopenshell::logger::LOG_ERROR, "GEO", 326, "Failed to convert:", inst);
}
} catch (const std::exception& e) {
logger_.message(::logger::LOG_ERROR, "GEO", 327, std::string(e.what()) + "\nFailed to convert:", inst);
logger_.message(ifcopenshell::logger::LOG_ERROR, "GEO", 327, std::string(e.what()) + "\nFailed to convert:", inst);
}
}
}
IfcSchema::IfcStyledItem find_style(const IfcSchema::IfcRepresentationItem&);
public:
POSTFIX_SCHEMA(mapping)(ifcopenshell::file* file, ifcopenshell::geom::settings& settings, ::logger& logger = ::logger::root()) : abstract_mapping(settings, logger), file_(file), placement_rel_to_type_(nullptr) {
POSTFIX_SCHEMA(mapping)(ifcopenshell::file* file, ifcopenshell::geom::settings& settings, ifcopenshell::logger& logger = ifcopenshell::logger::root()) : abstract_mapping(settings, logger), file_(file), placement_rel_to_type_(nullptr) {
initialize_units_();
}
virtual ifcopenshell::geom::taxonomy::ptr map(const express::base&);
src/ifcgeom/mapping/plugin.cpp
+1 -1
View File
@@ -29,7 +29,7 @@ namespace ifcopenshell {
namespace {
struct POSTFIX_SCHEMA(factory_t) {
abstract_mapping* operator()(ifcopenshell::file* file, ifcopenshell::geom::settings& settings, ::logger& logger) const {
abstract_mapping* operator()(ifcopenshell::file* file, ifcopenshell::geom::settings& settings, ifcopenshell::logger& logger) const {
return new POSTFIX_SCHEMA(mapping)(file, settings, logger);
}
};
src/ifcgeom/profile_helper.cpp
+1 -1
View File
@@ -120,7 +120,7 @@ taxonomy::loop::ptr ifcopenshell::geom::profile_helper(const taxonomy::matrix4::
if (fillet.IsDone()) {
face = TopoDS::Face(fillet.Shape());
} else {
::logger::root().error("Failed to process profile fillets");
ifcopenshell::logger::root().error("Failed to process profile fillets");
}
}
*/
src/ifcgeom/taxonomy.cpp
+2 -2
View File
@@ -861,7 +861,7 @@ std::optional<function_item::ptr> ifcopenshell::geom::taxonomy::loop_to_function
spans.emplace_back(taxonomy::make<taxonomy::functor_item>(l, fn));
} else if (edge_->start.index() == 1 && edge_->end.index() == 1) {
if (edge_->basis && edge_->basis->kind() != LINE) {
::logger::root().message(::logger::severity::LOG_WARNING, "UNS", 20, "Basis curve not supported - edge is treated as a straight line edge");
ifcopenshell::logger::root().message(ifcopenshell::logger::severity::LOG_WARNING, "UNS", 20, "Basis curve not supported - edge is treated as a straight line edge");
}
const auto& s = std::get<point3::ptr>(edge_->start)->ccomponents();
const auto& e = std::get<point3::ptr>(edge_->end)->ccomponents();
@@ -876,7 +876,7 @@ std::optional<function_item::ptr> ifcopenshell::geom::taxonomy::loop_to_function
};
spans.emplace_back(taxonomy::make<taxonomy::functor_item>(l, fn));
} else {
::logger::root().message(::logger::severity::LOG_ERROR, "UNS", 21, "Basis curve not supported");
ifcopenshell::logger::root().message(ifcopenshell::logger::severity::LOG_ERROR, "UNS", 21, "Basis curve not supported");
return std::nullopt;
}
}
src/ifcgeom/taxonomy.h
+1 -1
View File
@@ -37,7 +37,7 @@
// @todo don't do std::less but use hashing and cache hash values.
namespace boost { inline std::size_t hash_value(const blank&) { return 0; } }
namespace boost { inline std::size_t hash_value(const boost::blank&) { return 0; } }
namespace ifcopenshell {
src/ifcparse/alignment_helper.cpp
+4 -4
View File
@@ -488,7 +488,7 @@ Ifc4x3_add2::IfcAlignment addAlignment(hierarchy_helper<Ifc4x3_add2>& file, cons
return alignment;
}
std::pair<Ifc4x3_add2::IfcCurveSegment, Ifc4x3_add2::IfcCurveSegment> mapAlignmentSegment(hierarchy_helper<Ifc4x3_add2>& file, const Ifc4x3_add2::IfcAlignmentSegment& segment, logger& logger) {
std::pair<Ifc4x3_add2::IfcCurveSegment, Ifc4x3_add2::IfcCurveSegment> mapAlignmentSegment(hierarchy_helper<Ifc4x3_add2>& file, const Ifc4x3_add2::IfcAlignmentSegment& segment, ifcopenshell::logger& logger) {
std::pair<Ifc4x3_add2::IfcCurveSegment, Ifc4x3_add2::IfcCurveSegment> result;
auto design_parameters = segment.DesignParameters();
auto horizontal = design_parameters.as<Ifc4x3_add2::IfcAlignmentHorizontalSegment>();
@@ -514,7 +514,7 @@ Ifc4x3_add2::IfcLengthMeasure create_length(hierarchy_helper<Ifc4x3_add2>& file,
}
}
std::pair<Ifc4x3_add2::IfcCurveSegment, Ifc4x3_add2::IfcCurveSegment> mapAlignmentHorizontalSegment(hierarchy_helper<Ifc4x3_add2>& file, const Ifc4x3_add2::IfcAlignmentHorizontalSegment& segment, logger& logger) {
std::pair<Ifc4x3_add2::IfcCurveSegment, Ifc4x3_add2::IfcCurveSegment> mapAlignmentHorizontalSegment(hierarchy_helper<Ifc4x3_add2>& file, const Ifc4x3_add2::IfcAlignmentHorizontalSegment& segment, ifcopenshell::logger& logger) {
std::pair<Ifc4x3_add2::IfcCurveSegment, Ifc4x3_add2::IfcCurveSegment> result;
auto start_point = segment.StartPoint();
auto start_direction = segment.StartDirection();
@@ -770,7 +770,7 @@ std::pair<Ifc4x3_add2::IfcCurveSegment, Ifc4x3_add2::IfcCurveSegment> mapAlignme
return result;
}
std::pair<Ifc4x3_add2::IfcCurveSegment, Ifc4x3_add2::IfcCurveSegment> mapAlignmentVerticalSegment(hierarchy_helper<Ifc4x3_add2>& file, const Ifc4x3_add2::IfcAlignmentVerticalSegment& segment, logger& logger) {
std::pair<Ifc4x3_add2::IfcCurveSegment, Ifc4x3_add2::IfcCurveSegment> mapAlignmentVerticalSegment(hierarchy_helper<Ifc4x3_add2>& file, const Ifc4x3_add2::IfcAlignmentVerticalSegment& segment, ifcopenshell::logger& logger) {
std::pair<Ifc4x3_add2::IfcCurveSegment, Ifc4x3_add2::IfcCurveSegment> result;
auto start_distance_along = segment.StartDistAlong();
auto horizontal_length = segment.HorizontalLength();
@@ -862,7 +862,7 @@ std::pair<Ifc4x3_add2::IfcCurveSegment, Ifc4x3_add2::IfcCurveSegment> mapAlignme
return result;
}
std::pair<Ifc4x3_add2::IfcCurveSegment, Ifc4x3_add2::IfcCurveSegment> mapAlignmentCantSegment(hierarchy_helper<Ifc4x3_add2>& file, const Ifc4x3_add2::IfcAlignmentCantSegment& segment, logger& logger) {
std::pair<Ifc4x3_add2::IfcCurveSegment, Ifc4x3_add2::IfcCurveSegment> mapAlignmentCantSegment(hierarchy_helper<Ifc4x3_add2>& file, const Ifc4x3_add2::IfcAlignmentCantSegment& segment, ifcopenshell::logger& logger) {
std::pair<Ifc4x3_add2::IfcCurveSegment, Ifc4x3_add2::IfcCurveSegment> result;
auto type = segment.PredefinedType();
if (type == Ifc4x3_add2::IfcAlignmentCantSegmentTypeEnum::IfcAlignmentCantSegmentType_BLOSSCURVE) {
src/ifcparse/alignment_helper.h
+4 -4
View File
@@ -45,10 +45,10 @@ IFC_SCHEMA_API Ifc4x3_add2::IfcAlignment addAlignment(hierarchy_helper<Ifc4x3_ad
// Maps horizontal alignment business logic to geometry.
// Bloss curves have two geometry elements for one horizontal alignment segment. That is the reason for returning a pair.
// Typically the first element of the pair will have the geometry and the second element will be nullptr
IFC_SCHEMA_API std::pair<Ifc4x3_add2::IfcCurveSegment, Ifc4x3_add2::IfcCurveSegment> mapAlignmentSegment(hierarchy_helper<Ifc4x3_add2>& model, const Ifc4x3_add2::IfcAlignmentSegment& segment, logger& logger = ::logger::root());
IFC_SCHEMA_API std::pair<Ifc4x3_add2::IfcCurveSegment, Ifc4x3_add2::IfcCurveSegment> mapAlignmentHorizontalSegment(hierarchy_helper<Ifc4x3_add2>& model, const Ifc4x3_add2::IfcAlignmentHorizontalSegment& segment, logger& logger = ::logger::root());
IFC_SCHEMA_API std::pair<Ifc4x3_add2::IfcCurveSegment, Ifc4x3_add2::IfcCurveSegment> mapAlignmentVerticalSegment(hierarchy_helper<Ifc4x3_add2>& model, const Ifc4x3_add2::IfcAlignmentVerticalSegment& segment, logger& logger = ::logger::root());
IFC_SCHEMA_API std::pair<Ifc4x3_add2::IfcCurveSegment, Ifc4x3_add2::IfcCurveSegment> mapAlignmentCantSegment(hierarchy_helper<Ifc4x3_add2>& model, const Ifc4x3_add2::IfcAlignmentCantSegment& segment, logger& logger = ::logger::root());
IFC_SCHEMA_API std::pair<Ifc4x3_add2::IfcCurveSegment, Ifc4x3_add2::IfcCurveSegment> mapAlignmentSegment(hierarchy_helper<Ifc4x3_add2>& model, const Ifc4x3_add2::IfcAlignmentSegment& segment, ifcopenshell::logger& logger = ifcopenshell::logger::root());
IFC_SCHEMA_API std::pair<Ifc4x3_add2::IfcCurveSegment, Ifc4x3_add2::IfcCurveSegment> mapAlignmentHorizontalSegment(hierarchy_helper<Ifc4x3_add2>& model, const Ifc4x3_add2::IfcAlignmentHorizontalSegment& segment, ifcopenshell::logger& logger = ifcopenshell::logger::root());
IFC_SCHEMA_API std::pair<Ifc4x3_add2::IfcCurveSegment, Ifc4x3_add2::IfcCurveSegment> mapAlignmentVerticalSegment(hierarchy_helper<Ifc4x3_add2>& model, const Ifc4x3_add2::IfcAlignmentVerticalSegment& segment, ifcopenshell::logger& logger = ifcopenshell::logger::root());
IFC_SCHEMA_API std::pair<Ifc4x3_add2::IfcCurveSegment, Ifc4x3_add2::IfcCurveSegment> mapAlignmentCantSegment(hierarchy_helper<Ifc4x3_add2>& model, const Ifc4x3_add2::IfcAlignmentCantSegment& segment, ifcopenshell::logger& logger = ifcopenshell::logger::root());
#endif
src/ifcparse/character_decoder.h
+1 -1
View File
@@ -57,7 +57,7 @@ class IFC_PARSE_API character_decoder {
inline static ConversionMode mode = UTF8;
inline static char substitution_character = '_';
character_decoder(Reader* stream, logger& logger = ::logger::root());
character_decoder(Reader* stream, logger& logger = ifcopenshell::logger::root());
~character_decoder();
// Gets a decoded string representation at the token stream
// read pointer and advances the underlying token stream.
src/ifcparse/entity_instance_data.cpp
+19 -17
View File
@@ -3,6 +3,8 @@
#include "exception.h"
#include "file.h"
using namespace ifcopenshell;
// @todo is size() still needed?
class size_visitor {
public:
@@ -37,7 +39,7 @@ namespace {
if (storage_model_ == 0) {
try {
return array_.storage_ptr->get<T>(index_);
} catch (const impl::storage_type_mismatch& e) {
} catch (const ::impl::storage_type_mismatch& e) {
throw ifcopenshell::exception(
// entity_or_type not passed, but in v0.9 this is beginning to make sense
(entity_or_type
@@ -66,7 +68,7 @@ namespace {
(is_header ? "h|" : (entity_or_type->as_entity() ? "i|" : "t|")) +
(is_header ? entity_or_type->name() : std::to_string(instance_name_)) + "|" +
std::to_string(index_), &str);
impl::deserialize(array_.db_ptr, str, val);
::impl::deserialize(array_.db_ptr, str, val);
} else {
static_assert(
std::is_same_v<T, enumeration_reference> ||
@@ -287,7 +289,7 @@ ifcopenshell::argument_type attribute_value::type() const
#ifdef IFOPSH_WITH_ROCKSDB
bool impl::serialize(std::string& val, const express::base& t)
bool ::impl::serialize(std::string& val, const express::base& t)
{
auto s = sizeof(size_t);
val.resize(s + 2);
@@ -300,7 +302,7 @@ bool impl::serialize(std::string& val, const express::base& t)
return true;
}
bool impl::serialize(std::string& val, const enumeration_reference& v)
bool ::impl::serialize(std::string& val, const enumeration_reference& v)
{
auto s = sizeof(size_t);
val.resize(s * 2 + 1);
@@ -312,7 +314,7 @@ bool impl::serialize(std::string& val, const enumeration_reference& v)
return true;
}
bool impl::serialize(std::string& val, const std::vector<express::base>& t)
bool ::impl::serialize(std::string& val, const std::vector<express::base>& t)
{
// no attempt at alignment
val.resize(t.size() * (sizeof(size_t) + 1) + 1);
@@ -328,7 +330,7 @@ bool impl::serialize(std::string& val, const std::vector<express::base>& t)
return true;
}
bool impl::serialize(std::string& val, const std::vector<std::vector<express::base>>& t)
bool ::impl::serialize(std::string& val, const std::vector<std::vector<express::base>>& t)
{
std::ostringstream oss;
oss.put(type_encoder::encode_type<std::vector<std::vector<express::base>>>());
@@ -363,35 +365,35 @@ bool impl::serialize(std::string& val, const std::vector<std::vector<express::ba
return true;
}
bool impl::serialize(std::string& val, const blank&)
bool ::impl::serialize(std::string& val, const blank&)
{
val.resize(1);
val[0] = type_encoder::encode_type<blank>();
return true;
}
bool impl::serialize(std::string& val, const derived&)
bool ::impl::serialize(std::string& val, const derived&)
{
val.resize(1);
val[0] = type_encoder::encode_type<derived>();
return true;
}
bool impl::serialize(std::string& val, const empty_aggregate_t&)
bool ::impl::serialize(std::string& val, const empty_aggregate_t&)
{
val.resize(1);
val[0] = type_encoder::encode_type<empty_aggregate_t>();
return true;
}
bool impl::serialize(std::string& val, const empty_aggregate_of_aggregate_t&)
bool ::impl::serialize(std::string& val, const empty_aggregate_of_aggregate_t&)
{
val.resize(1);
val[0] = type_encoder::encode_type<empty_aggregate_of_aggregate_t>();
return true;
}
bool impl::serialize(std::string& val, const boost::logic::tribool& t)
bool ::impl::serialize(std::string& val, const boost::logic::tribool& t)
{
char tt = t == boost::logic::indeterminate ? 2 : t ? 1 : 0;
val.resize(sizeof(char) + 1);
@@ -400,7 +402,7 @@ bool impl::serialize(std::string& val, const boost::logic::tribool& t)
return true;
}
bool impl::serialize(std::string& val, const boost::dynamic_bitset<>& t)
bool ::impl::serialize(std::string& val, const boost::dynamic_bitset<>& t)
{
std::string tmp;
boost::to_string(t, tmp);
@@ -408,7 +410,7 @@ bool impl::serialize(std::string& val, const boost::dynamic_bitset<>& t)
return true;
}
bool impl::deserialize(ifcopenshell::impl::rocks_db_file_storage*, const std::string& val, boost::logic::tribool& t) {
bool ::impl::deserialize(ifcopenshell::impl::rocks_db_file_storage*, const std::string& val, boost::logic::tribool& t) {
if (val[0] != type_encoder::encode_type<boost::logic::tribool>()) {
return false;
}
@@ -424,7 +426,7 @@ bool impl::deserialize(ifcopenshell::impl::rocks_db_file_storage*, const std::st
return true;
}
bool impl::deserialize(ifcopenshell::impl::rocks_db_file_storage*, const std::string& val, boost::dynamic_bitset<>& t) {
bool ::impl::deserialize(ifcopenshell::impl::rocks_db_file_storage*, const std::string& val, boost::dynamic_bitset<>& t) {
if (val[0] != type_encoder::encode_type<boost::dynamic_bitset<>>()) {
return false;
}
@@ -432,7 +434,7 @@ bool impl::deserialize(ifcopenshell::impl::rocks_db_file_storage*, const std::st
return true;
}
bool impl::deserialize(ifcopenshell::impl::rocks_db_file_storage* storage, const std::string& val, std::vector<express::base>& t) {
bool ::impl::deserialize(ifcopenshell::impl::rocks_db_file_storage* storage, const std::string& val, std::vector<express::base>& t) {
auto n = (val.size() - 1) / (sizeof(size_t) + 1);
for (int i = 0; i < n; ++i) {
auto ptr = val.data() + 1 + (sizeof(size_t) + 1) * i;
@@ -451,7 +453,7 @@ bool impl::deserialize(ifcopenshell::impl::rocks_db_file_storage* storage, const
return true;
}
bool impl::deserialize(ifcopenshell::impl::rocks_db_file_storage* storage, const std::string& val, std::vector<std::vector<express::base>>& t) {
bool ::impl::deserialize(ifcopenshell::impl::rocks_db_file_storage* storage, const std::string& val, std::vector<std::vector<express::base>>& t) {
char const* ptr = val.data() + 1;
// size_t outer_size;
@@ -514,7 +516,7 @@ void rocks_db_attribute_storage::set(void* storage, const ifcopenshell::declarat
const bool is_header = decl->schema() == &Header_section_schema::get_schema();
ifcopenshell::impl::rocks_db_file_storage* rdb_storage = (ifcopenshell::impl::rocks_db_file_storage*)storage;
std::string v;
impl::serialize(v, value);
::impl::serialize(v, value);
rdb_storage->db->Put(
rdb_storage->wopts,
(is_header ? "h|" : (decl->as_entity() ? "i|" : "t|")) +
src/ifcparse/express.cpp
+2 -2
View File
@@ -8,7 +8,7 @@ uint32_t express::base::identity() const { return data()->identity(); }
uint32_t express::base::id() const { return data()->id(); }
const instance_data* express::base::data() const {
const ifcopenshell::instance_data* express::base::data() const {
#ifdef IFOPSH_SAFE_INSTANCE
auto sp = data_.lock();
if (sp) {
@@ -21,7 +21,7 @@ const instance_data* express::base::data() const {
#endif
}
instance_data* express::base::data() {
ifcopenshell::instance_data* express::base::data() {
#ifdef IFOPSH_SAFE_INSTANCE
auto sp = data_.lock();
if (sp) {
src/ifcparse/express.h
+6 -4
View File
@@ -54,8 +54,10 @@ struct in_memory_file_storage;
}
} // namespace ifcopenshell
namespace ifcopenshell {
class instance_data;
class attribute_value;
}
namespace express {
@@ -67,8 +69,8 @@ class declared_type;
class IFC_PARSE_API base {
protected:
ifcopenshell::pointer_type data_;
const instance_data* data() const;
instance_data* data();
const ifcopenshell::instance_data* data() const;
ifcopenshell::instance_data* data();
public:
operator bool() const {
#ifdef IFOPSH_SAFE_INSTANCE
@@ -120,7 +122,7 @@ class IFC_PARSE_API base {
void unset_attribute_value(size_t attribute_index);
attribute_value get_attribute_value(size_t attribute_index) const;
ifcopenshell::attribute_value get_attribute_value(size_t attribute_index) const;
uint32_t identity() const;
@@ -160,7 +162,7 @@ class IFC_PARSE_API entity : public base {
public:
using base::base;
attribute_value get(const std::string& attribute_name) const;
ifcopenshell::attribute_value get(const std::string& attribute_name) const;
template <typename T>
T get_value(const std::string& attribute_name) const;
src/ifcparse/file.h
+13 -13
View File
@@ -102,7 +102,7 @@ private:
const ifcopenshell::schema_definition* schema_;
ifcopenshell::impl::in_memory_file_storage storage_;
ifcopenshell::file_open_status good_ = ifcopenshell::file_open_status::SUCCESS;
std::reference_wrapper<::logger> logger_;
std::reference_wrapper<ifcopenshell::logger> logger_;
int progress_;
ifcopenshell::unresolved_references references_to_resolve_;
int yielded_header_instances_ = 0;
@@ -156,13 +156,13 @@ private:
void push_page(const std::string& page_data);
instance_streamer(ifcopenshell::file* owner_file = nullptr, ::logger& logger = ::logger::root());
instance_streamer(ifcopenshell::file* owner_file = nullptr, ifcopenshell::logger& logger = ifcopenshell::logger::root());
instance_streamer(const std::string& path, bool use_mmap = false, ifcopenshell::file* owner_file = nullptr, ::logger& logger = ::logger::root());
instance_streamer(const std::string& path, bool use_mmap = false, ifcopenshell::file* owner_file = nullptr, ifcopenshell::logger& logger = ifcopenshell::logger::root());
instance_streamer(void* data, int data_size, ifcopenshell::file* owner_file = nullptr, ::logger& logger = ::logger::root());
instance_streamer(void* data, int data_size, ifcopenshell::file* owner_file = nullptr, ifcopenshell::logger& logger = ifcopenshell::logger::root());
instance_streamer(Reader* stream, ifcopenshell::file* owner_file = nullptr, ::logger& logger = ::logger::root());
instance_streamer(Reader* stream, ifcopenshell::file* owner_file = nullptr, ifcopenshell::logger& logger = ifcopenshell::logger::root());
void bypass_types(const std::set<std::string>& type_names);
@@ -210,7 +210,7 @@ public:
private:
file_open_status good_ = file_open_status::SUCCESS;
std::reference_wrapper<::logger> logger_;
std::reference_wrapper<ifcopenshell::logger> logger_;
const ifcopenshell::schema_definition* schema_;
const ifcopenshell::declaration* ifcroot_type_;
@@ -241,7 +241,7 @@ public:
/// </summary>
/// <param name="path">UTF-8 file path to an IFC-SPF file</param>
/// <param name="mmap">Whether to use memory-mapped I/O</param>
file(const std::string& path, bool use_mmap, ::logger& logger = ::logger::root());
file(const std::string& path, bool use_mmap, ifcopenshell::logger& logger = ifcopenshell::logger::root());
#endif
/// <summary>
/// Constructs an file object from a file path, supports IFC-SPF and the IfcOpenShell-specific RocksDB format.
@@ -250,17 +250,17 @@ public:
/// <param name="type">File type of the path</param>
/// <param name="read_only">Whether to open in read-only mode, only supported on RocksDB databases</param>
/// <param name="logger">Logger used while opening the file</param>
file(const std::string& path, filetype type = FT_AUTODETECT, bool read_only = false, ::logger& logger = ::logger::root());
file(const std::string& path, filetype type = FT_AUTODETECT, bool read_only = false, ifcopenshell::logger& logger = ifcopenshell::logger::root());
/// <summary>
/// Constructs an file object from a stream containing IFC-SPF data.
/// </summary>
file(std::istream& stream, int data_size, ::logger& logger = ::logger::root());
file(std::istream& stream, int data_size, ifcopenshell::logger& logger = ifcopenshell::logger::root());
/// <summary>
/// Constructs an file object from a memory buffer containing IFC-SPF data.
/// </summary>
file(void* data, int data_size, ::logger& logger = ::logger::root());
file(void* data, int data_size, ifcopenshell::logger& logger = ifcopenshell::logger::root());
/// <summary>
/// Constructs an file object with the specified schema, file type, and file path.
@@ -270,12 +270,12 @@ public:
/// <param name="type">The file type to use for the file. Defaults to FT_AUTODETECT.</param>
/// <param name="path">The file system path to the IFC file. Defaults to an empty string.</param>
/// <param name="logger">Logger used while creating the file.</param>
file(const ifcopenshell::schema_definition* schema = ifcopenshell::schema_by_name("IFC4"), filetype type = FT_AUTODETECT, const std::string& path = "", ::logger& logger = ::logger::root());
file(const ifcopenshell::schema_definition* schema = ifcopenshell::schema_by_name("IFC4"), filetype type = FT_AUTODETECT, const std::string& path = "", ifcopenshell::logger& logger = ifcopenshell::logger::root());
/// <summary>
/// Constructs an unitialized file object. Call initialize() later on. Allows to specify which types to bypass during load.
/// </summary>
file(const uninitialized_tag& tag, ::logger& logger = ::logger::root());
file(const uninitialized_tag& tag, ifcopenshell::logger& logger = ifcopenshell::logger::root());
bool initialize(const std::string& path, filetype type = FT_AUTODETECT, bool read_only = false);
#ifdef USE_MMAP
@@ -289,7 +289,7 @@ public:
~file();
ifcopenshell::file_open_status good() const { return good_; }
::logger& logger() const { return logger_.get(); }
ifcopenshell::logger& logger() const { return logger_.get(); }
/// Returns the first entity in the range of instances contained in the model,
/// in arbitrary order

Some files were not shown because too many files have changed in this diff Show More