Glassvision/IfcOpenShell
1
0
Fork 0
mirror of https://github.com/IfcOpenShell/IfcOpenShell.git synced 2026-08-10 17:58:20 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
b5eca8335767a08bf0bbbd55eacc74b7eb3217bf
IfcOpenShell/src/ifcviewer/GeometryStreamer.cpp
T
Thomas Krijnen b5eca83357 Adapt for namespaces changes
2026-08-09 12:48:35 +02:00

708 lines
30 KiB
C++
Raw Blame History

/********************************************************************************
* *
* This file is part of IfcOpenShell. *
* *
* IfcOpenShell is free software: you can redistribute it and/or modify *
* it under the terms of the Lesser GNU General Public License as published by *
* the Free Software Foundation, either version 3.0 of the License, or *
* (at your option) any later version. *
* *
* IfcOpenShell is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* Lesser GNU General Public License for more details. *
* *
* You should have received a copy of the Lesser GNU General Public License *
* along with this program. If not, see <http://www.gnu.org/licenses/>. *
* *
********************************************************************************/
#include "GeometryStreamer.h"
#include "AppSettings.h"
#include "../ifcgeom/hybrid_kernel.h"
#include "../ifcgeom/taxonomy.h"
#include "../ifcgeom/filter.h"
#include "../ifcparse/express.h"
#include <Eigen/Dense>
#include <thread>
#include <unordered_map>
#include <cmath>
#include <cstring>
#include <algorithm>
#include <limits>
#include <set>
#include <cstdio>
#include <QElapsedTimer>
struct MaterialInfo {
float r = 0.75f, g = 0.75f, b = 0.78f, a = 1.0f;
};
static MaterialInfo materialFromStyle(const ifcopenshell::geom::taxonomy::style::ptr& style) {
MaterialInfo material;
if (!style) return material;
const auto& color = style->get_color();
if (color) {
material.r = static_cast<float>(color.r());
material.g = static_cast<float>(color.g());
material.b = static_cast<float>(color.b());
}
if (!std::isnan(style->transparency)) {
material.a = 1.0f - static_cast<float>(style->transparency);
}
return material;
}
static inline uint32_t packRGBA8(const MaterialInfo& material) {
auto to_byte = [](float channel_value) -> uint32_t {
float clamped_value = std::clamp(channel_value, 0.0f, 1.0f);
return static_cast<uint32_t>(clamped_value * 255.0f + 0.5f);
};
uint32_t r = to_byte(material.r);
uint32_t g = to_byte(material.g);
uint32_t b = to_byte(material.b);
uint32_t a = to_byte(material.a);
// Little-endian byte layout [r,g,b,a] for GL_UNSIGNED_BYTE * 4 normalized.
return r | (g << 8) | (b << 16) | (a << 24);
}
GeometryStreamer::GeometryStreamer(QObject* parent)
: QObject(parent)
{
}
GeometryStreamer::~GeometryStreamer() {
cancel();
if (worker_thread_ && worker_thread_->isRunning()) {
worker_thread_->quit();
worker_thread_->wait();
}
}
void GeometryStreamer::setIfcFile(std::unique_ptr<ifcopenshell::file> file) {
ifc_file_ = std::move(file);
}
void GeometryStreamer::loadFile(const std::string& path, uint32_t session_model_id, int num_threads) {
if (running_.load()) {
cancel();
if (worker_thread_ && worker_thread_->isRunning()) {
worker_thread_->quit();
worker_thread_->wait();
}
}
cancel_requested_ = false;
succeeded_ = false;
running_ = true;
progress_ = 0;
next_object_id_ = 1; // model-local; globalized at applyCachedModel install time
session_model_id_ = session_model_id;
{
std::lock_guard<std::mutex> lock(elements_mutex_);
pending_elements_.clear();
}
if (num_threads <= 0) {
num_threads = std::max(1u, std::thread::hardware_concurrency());
}
worker_thread_ = std::make_unique<QThread>();
QObject* context = new QObject();
context->moveToThread(worker_thread_.get());
connect(worker_thread_.get(), &QThread::started, context, [this, path, num_threads, context]() {
run(path, num_threads);
context->deleteLater();
worker_thread_->quit();
});
connect(worker_thread_.get(), &QThread::finished, this, [this]() {
running_ = false;
if (succeeded_.load()) {
emit finished();
} else if (cancel_requested_.load()) {
emit cancelled();
}
});
worker_thread_->start();
}
void GeometryStreamer::cancel() {
cancel_requested_ = true;
}
std::vector<ElementInfo> GeometryStreamer::drainElements() {
std::lock_guard<std::mutex> lock(elements_mutex_);
std::vector<ElementInfo> result;
result.swap(pending_elements_);
return result;
}
// Build a streamed mesh record (local coords, 28-byte interleaved vertices) from a
// TriangulationElement. Per-vertex color is baked from material_ids so that
// triangulations with per-face materials still render correctly.
// Vertex rebasing: when `offset` is non-zero, every vertex position is
// subtracted by it so the emitted mesh-local coordinates stay near the
// origin (and float32 precision survives upload to the GPU). Caller
// compensates by post-multiplying each instance's PlacementTransformation
// by T(+offset), which is mathematically the identity overall but moves
// the magnitude off the float-precision-sensitive vertex column.
static StreamedMesh buildStreamedMesh(uint32_t session_model_id,
uint32_t local_mesh_id,
const ifcopenshell::geom::triangulation_element* elem,
const Eigen::Vector3d& offset) {
StreamedMesh mesh;
mesh.session_model_id = session_model_id;
mesh.local_mesh_id = local_mesh_id;
const auto& geom = elem->geometry();
const auto& verts = geom.verts();
const auto& faces = geom.faces();
const auto& normals = geom.normals();
const auto& materials = geom.materials();
const auto& material_ids = geom.material_ids();
if (verts.empty() || faces.empty()) return mesh;
const size_t num_verts_src = verts.size() / 3;
const size_t num_tris = faces.size() / 3;
const bool have_per_tri_material = (material_ids.size() == num_tris);
// Dedupe (original vertex index, material id) so vertices shared across
// triangles of the same material stay shared; vertices spanning multiple
// materials are split (per-face color demands it).
auto make_key = [](uint32_t orig_idx, int mat_id) -> uint64_t {
return (static_cast<uint64_t>(orig_idx) << 32) | static_cast<uint32_t>(mat_id);
};
std::unordered_map<uint64_t, uint32_t> remap;
remap.reserve(num_verts_src);
mesh.vertices.reserve(num_verts_src * INSTANCED_VERTEX_STRIDE_FLOATS);
mesh.indices.reserve(faces.size());
// Track local AABB as we emit vertices.
float local_aabb_min[3] = { std::numeric_limits<float>::max(),
std::numeric_limits<float>::max(),
std::numeric_limits<float>::max() };
float local_aabb_max[3] = { -std::numeric_limits<float>::max(),
-std::numeric_limits<float>::max(),
-std::numeric_limits<float>::max() };
auto emit_vertex = [&](uint32_t orig_idx, int mat_id) -> uint32_t {
const uint64_t key = make_key(orig_idx, mat_id);
auto it = remap.find(key);
if (it != remap.end()) return it->second;
const uint32_t new_idx = static_cast<uint32_t>(
mesh.vertices.size() / INSTANCED_VERTEX_STRIDE_FLOATS);
// Subtract in double, narrow to float — preserves precision when
// verts are far from origin and offset cancels the magnitude.
float px = static_cast<float>(verts[orig_idx * 3 + 0] - offset.x());
float py = static_cast<float>(verts[orig_idx * 3 + 1] - offset.y());
float pz = static_cast<float>(verts[orig_idx * 3 + 2] - offset.z());
mesh.vertices.push_back(px);
mesh.vertices.push_back(py);
mesh.vertices.push_back(pz);
if (px < local_aabb_min[0]) local_aabb_min[0] = px;
if (px > local_aabb_max[0]) local_aabb_max[0] = px;
if (py < local_aabb_min[1]) local_aabb_min[1] = py;
if (py > local_aabb_max[1]) local_aabb_max[1] = py;
if (pz < local_aabb_min[2]) local_aabb_min[2] = pz;
if (pz > local_aabb_max[2]) local_aabb_max[2] = pz;
if (orig_idx * 3 + 2 < normals.size()) {
mesh.vertices.push_back(static_cast<float>(normals[orig_idx * 3 + 0]));
mesh.vertices.push_back(static_cast<float>(normals[orig_idx * 3 + 1]));
mesh.vertices.push_back(static_cast<float>(normals[orig_idx * 3 + 2]));
} else {
mesh.vertices.push_back(0.0f);
mesh.vertices.push_back(1.0f);
mesh.vertices.push_back(0.0f);
}
MaterialInfo m;
if (mat_id >= 0 && mat_id < static_cast<int>(materials.size())) {
m = materialFromStyle(materials[mat_id]);
}
uint32_t packed = packRGBA8(m);
float packed_as_float;
std::memcpy(&packed_as_float, &packed, sizeof(float));
mesh.vertices.push_back(packed_as_float);
remap.emplace(key, new_idx);
return new_idx;
};
for (size_t t = 0; t < num_tris; ++t) {
const int mat_id = have_per_tri_material ? material_ids[t] : -1;
mesh.indices.push_back(emit_vertex(static_cast<uint32_t>(faces[t * 3 + 0]), mat_id));
mesh.indices.push_back(emit_vertex(static_cast<uint32_t>(faces[t * 3 + 1]), mat_id));
mesh.indices.push_back(emit_vertex(static_cast<uint32_t>(faces[t * 3 + 2]), mat_id));
}
if (mesh.vertices.empty()) {
for (int a = 0; a < 3; ++a) local_aabb_min[a] = local_aabb_max[a] = 0.0f;
}
for (int a = 0; a < 3; ++a) {
mesh.local_aabb_min[a] = local_aabb_min[a];
mesh.local_aabb_max[a] = local_aabb_max[a];
}
return mesh;
}
// Port of ifcopenshell.util.representation.get_prioritised_contexts: rank every
// IfcGeometricRepresentationContext (and SubContext) by (ContextType,
// ContextIdentifier, TargetView, TargetScale) — tuple comparison, descending —
// and return the resulting context ids high-priority first. Used to drive a
// pass-per-context iteration in the streamer (mirrors bonsai's
// create_generic_element loop), so each element is rendered from its
// preferred representation if available, falling back to lower-priority
// contexts only when the preferred one is missing.
static std::vector<int> prioritisedContextIds(ifcopenshell::file* ifc_file) {
static const std::vector<std::string> type_order = {
// "Annotation" accommodates broken Revit files that put 3D bodies
// under a context typed Annotation. See revit-ifc#187.
"Model", "Plan", "Annotation",
};
static const std::vector<std::string> identifier_order = {
"Body", "Body-FallBack", "Facetation", "FootPrint", "Profile",
"Surface", "Reference", "Axis", "Clearance", "Box", "Lighting",
"Annotation", "CoG",
};
static const std::vector<std::string> target_view_order = {
"MODEL_VIEW", "PLAN_VIEW", "REFLECTED_PLAN_VIEW", "ELEVATION_VIEW",
"SECTION_VIEW", "GRAPH_VIEW", "SKETCH_VIEW", "USERDEFINED",
"NOTDEFINED",
};
auto rank = [](const std::vector<std::string>& order,
const std::string& value) -> int {
if (value.empty()) return 0;
auto it = std::find(order.begin(), order.end(), value);
if (it == order.end()) return 0;
return static_cast<int>(order.size() - (it - order.begin()));
};
struct ContextInfo {
int id;
int type_priority;
int identifier_priority;
int target_view_priority;
double target_scale;
};
std::vector<ContextInfo> infos;
auto contexts =
ifc_file->instances_by_type("IfcGeometricRepresentationContext");
infos.reserve(contexts.size());
for (const auto& ctx : contexts) {
ContextInfo info{};
info.id = ctx.id();
const auto entity = ctx.as<express::Entity>();
const std::string ctype =
entity.get_value<std::string>("ContextType", "");
const std::string cident =
entity.get_value<std::string>("ContextIdentifier", "");
info.type_priority = rank(type_order, ctype);
info.identifier_priority = rank(identifier_order, cident);
// TargetView and TargetScale only exist on
// IfcGeometricRepresentationSubContext; get() throws on the parent
// type, so gate by declaration before reading.
if (ctx.declaration().is("IfcGeometricRepresentationSubContext")) {
try {
auto tv = entity.get("TargetView");
if (!tv.isNull()) {
ifcopenshell::enumeration_reference er = tv;
info.target_view_priority =
rank(target_view_order, er.value());
}
} catch (...) {}
try {
auto ts = entity.get("TargetScale");
if (!ts.isNull()) {
info.target_scale = static_cast<double>(ts);
}
} catch (...) {}
}
infos.push_back(info);
}
std::sort(infos.begin(), infos.end(),
[](const ContextInfo& a, const ContextInfo& b) {
if (a.type_priority != b.type_priority)
return a.type_priority > b.type_priority;
if (a.identifier_priority != b.identifier_priority)
return a.identifier_priority > b.identifier_priority;
if (a.target_view_priority != b.target_view_priority)
return a.target_view_priority > b.target_view_priority;
return a.target_scale > b.target_scale;
});
std::vector<int> result;
result.reserve(infos.size());
for (const auto& i : infos) result.push_back(i.id);
return result;
}
// Compute the world-space AABB by transforming the 8 corners of the local
// AABB through the column-major 4x4 transform.
static void worldAabbFromLocal(const float local_min[3],
const float local_max[3],
const float M[16],
float out_min[3], float out_max[3]) {
out_min[0] = out_min[1] = out_min[2] = std::numeric_limits<float>::max();
out_max[0] = out_max[1] = out_max[2] = -std::numeric_limits<float>::max();
for (int c = 0; c < 8; ++c) {
float x = (c & 1) ? local_max[0] : local_min[0];
float y = (c & 2) ? local_max[1] : local_min[1];
float z = (c & 4) ? local_max[2] : local_min[2];
// Column-major: world = M * [x,y,z,1].
float wx = M[0]*x + M[4]*y + M[8]*z + M[12];
float wy = M[1]*x + M[5]*y + M[9]*z + M[13];
float wz = M[2]*x + M[6]*y + M[10]*z + M[14];
if (wx < out_min[0]) out_min[0] = wx; if (wx > out_max[0]) out_max[0] = wx;
if (wy < out_min[1]) out_min[1] = wy; if (wy > out_max[1]) out_max[1] = wy;
if (wz < out_min[2]) out_min[2] = wz; if (wz > out_max[2]) out_max[2] = wz;
}
}
void GeometryStreamer::run(const std::string& path, int num_threads) {
try {
// read_only is a no-op for SPF; for RocksDB it allows concurrent
// readers and avoids acquiring the exclusive DB lock.
ifc_file_ = std::make_unique<ifcopenshell::file>(
path, ifcopenshell::FT_AUTODETECT, /*read_only=*/true);
} catch (const std::exception& e) {
emit errorOccurred(QString("Failed to parse IFC file: %1").arg(e.what()));
return;
}
ifcopenshell::geom::settings settings;
// Instancing path: geometry stays in local coords; the transform is
// applied on the GPU per instance.
settings.set("use-world-coords", false);
settings.set("weld-vertices", false);
settings.set("apply-default-materials", false);
// Off by default in IfcOpenShell — makes face winding consistent within
// each shell, which we need for GL_CULL_FACE and for per-vertex normals
// to shade a solid without dark inside-out patches. Costs some iterator
// time, but results are cached in the sidecar so it's a one-shot hit.
settings.set("reorient-shells", true);
settings.set("layerset-first", true);
settings.set("mesher-linear-deflection", AppSettings::instance().deflectionTolerance());
settings.set("mesher-angular-deflection", AppSettings::instance().angularTolerance());
// Wire intersection checks is prohibitively slow on advanced breps. See bug #5999.
settings.set("no-wire-intersection-check", true);
// Mirror bonsai's IfcImporter.process_element_filter: walk IfcElement
// (plus IfcProxy on IFC2X3/IFC4), drop IfcFeatureElement except
// IfcSurfaceFeature, pick up spatial elements, and split elements
// with more openings than the configured void limit into a "gross"
// set that is rendered without opening subtractions. Both sets
// become include filters so we don't waste time mapping openings.
std::set<int> net_ids;
std::set<int> gross_ids;
{
const std::string& schema_name = ifc_file_->schema()->name();
std::vector<express::Base> elements =
ifc_file_->instances_by_type("IfcElement");
if (schema_name == "IFC2X3" || schema_name == "IFC4") {
auto proxies = ifc_file_->instances_by_type("IfcProxy");
elements.insert(elements.end(), proxies.begin(), proxies.end());
}
const char* spatial_root = (schema_name == "IFC2X3")
? "IfcSpatialStructureElement"
: "IfcSpatialElement";
auto spatials = ifc_file_->instances_by_type(spatial_root);
elements.insert(elements.end(), spatials.begin(), spatials.end());
const int void_limit = AppSettings::instance().voidLimit();
for (const auto& e : elements) {
const auto& decl = e.declaration();
if (decl.is("IfcFeatureElement") && !decl.is("IfcSurfaceFeature")) {
continue;
}
int opening_count = 0;
if (decl.is("IfcElement")) {
try {
opening_count = static_cast<int>(
e.as<express::Entity>().get_inverse("HasOpenings").size());
} catch (...) {
// HasOpenings not declared on this entity — treat as 0.
}
}
if (opening_count > void_limit) {
gross_ids.insert(e.id());
} else {
net_ids.insert(e.id());
}
}
}
if (net_ids.empty() && gross_ids.empty()) {
emit errorOccurred("No geometry-bearing elements found in IFC file");
return;
}
if (!gross_ids.empty()) {
std::fprintf(stderr,
"[info] Excessive voids: %zu element(s) will be loaded without "
"opening subtractions\n",
gross_ids.size());
}
// Shared dedup + AABB state across passes — same geom.id() across
// net/gross passes still maps to one mesh upload.
std::unordered_map<std::string, uint32_t> geom_to_local_mesh_id;
// Per-unique-mesh state shared across instances. `offset` is the stage-1
// rebase applied to verts (zero when the mesh's first vert is near origin
// and rebasing wasn't worth it).
struct MeshAabb {
float lmin[3], lmax[3];
double offset[3] = {0.0, 0.0, 0.0};
bool has_offset = false;
};
std::vector<MeshAabb> mesh_aabbs;
uint32_t total_shapes = 0;
uint32_t total_meshes = 0;
QElapsedTimer stream_timer;
stream_timer.start();
// Drive the bar from yields across all passes/contexts. Earlier the
// [0,100] range was carved evenly across N prioritised contexts, but
// in practice nearly every element yields from the first (Body)
// context, so smooth progress only ever filled 1/n of the bar before
// jumping to the next allocation — visually, a typical 5-context
// file looked like it capped at ~20%.
const size_t total_count = net_ids.size() + gross_ids.size();
size_t yielded_count = 0;
int last_emitted_progress = 0;
// High-priority context first, so each element gets its preferred
// representation; lower-priority contexts only pick up elements the
// earlier passes didn't yield geometry for. Mirrors bonsai's
// create_generic_element loop over context_settings.
const std::vector<int> prioritised_contexts =
prioritisedContextIds(ifc_file_.get());
auto run_pass = [&](const std::set<int>& include_ids,
bool is_gross) -> bool {
if (include_ids.empty()) return true;
ifcopenshell::geom::settings base_settings = settings;
if (is_gross) {
base_settings.set("disable-opening-subtractions", true);
}
// Elements that haven't yet produced geometry from any context.
std::set<int> remaining = include_ids;
auto run_iterator = [&](ifcopenshell::geom::settings& iter_settings) -> bool {
if (remaining.empty()) return true;
std::vector<ifcopenshell::geom::filter_function> filters;
ifcopenshell::geom::instance_id_filter idf{
/*include=*/true, /*traverse=*/false, remaining};
filters.push_back(idf);
std::unique_ptr<ifcopenshell::geom::iterator> iterator;
try {
const std::string geometry_library =
AppSettings::instance().geometryLibrary().toStdString();
auto kernel = ifcopenshell::geom::kernels::construct(
ifc_file_.get(), geometry_library, iter_settings);
iterator = std::make_unique<ifcopenshell::geom::iterator>(
std::move(kernel), iter_settings, ifc_file_.get(),
filters, num_threads);
} catch (const std::exception& e) {
emit errorOccurred(QString("Failed to create geometry iterator: %1").arg(e.what()));
return false;
}
if (!iterator->initialize()) {
// No geometry survived this context for the remaining ids.
// Subsequent contexts will pick them up; nothing to emit.
return true;
}
do {
if (cancel_requested_.load()) break;
auto element = iterator->get();
const ifcopenshell::geom::element* elem = element.get();
if (!elem) continue;
const auto* tri_elem = dynamic_cast<const ifcopenshell::geom::triangulation_element*>(elem);
if (!tri_elem) continue;
const auto& geom = tri_elem->geometry();
if (geom.verts().empty() || geom.faces().empty()) continue;
// Once an element yields geometry from this context, drop it
// from the remaining set so lower-priority contexts don't
// re-render it.
remaining.erase(tri_elem->id());
uint32_t object_id = next_object_id_++;
ElementInfo info;
info.object_id = object_id;
info.session_model_id = session_model_id_;
info.ifc_id = tri_elem->id();
info.guid = tri_elem->guid();
info.name = tri_elem->name();
info.type = tri_elem->type();
{
std::lock_guard<std::mutex> lock(elements_mutex_);
pending_elements_.push_back(std::move(info));
}
const std::string& geom_id = geom.id();
uint32_t local_mesh_id;
bool first_sight = false;
if (geom_id.empty()) {
local_mesh_id = total_meshes++;
first_sight = true;
} else {
auto it = geom_to_local_mesh_id.find(geom_id);
if (it == geom_to_local_mesh_id.end()) {
local_mesh_id = total_meshes++;
geom_to_local_mesh_id.emplace(geom_id, local_mesh_id);
first_sight = true;
} else {
local_mesh_id = it->second;
}
}
if (first_sight) {
// Vertex rebasing: pick a rebase offset when the mesh's
// first source vertex is far from origin (>1 km in metres,
// matching bonsai's distance_limit default). Iterator
// outputs metres, so the threshold is in metres directly.
Eigen::Vector3d offset = Eigen::Vector3d::Zero();
constexpr double kFarAwayThresholdMeters = 1000.0;
const auto& src_verts = tri_elem->geometry().verts();
if (src_verts.size() >= 3) {
const double x = src_verts[0];
const double y = src_verts[1];
const double z = src_verts[2];
if (std::abs(x) > kFarAwayThresholdMeters ||
std::abs(y) > kFarAwayThresholdMeters ||
std::abs(z) > kFarAwayThresholdMeters) {
offset = Eigen::Vector3d(x, y, z);
}
}
StreamedMesh streamed_mesh =
buildStreamedMesh(session_model_id_, local_mesh_id, tri_elem, offset);
MeshAabb mesh_aabb;
for (int a = 0; a < 3; ++a) {
mesh_aabb.lmin[a] = streamed_mesh.local_aabb_min[a];
mesh_aabb.lmax[a] = streamed_mesh.local_aabb_max[a];
mesh_aabb.offset[a] = offset[a];
}
mesh_aabb.has_offset = (offset.squaredNorm() > 0.0);
if (mesh_aabbs.size() <= local_mesh_id) mesh_aabbs.resize(local_mesh_id + 1);
mesh_aabbs[local_mesh_id] = mesh_aabb;
if (!streamed_mesh.indices.empty()) {
emit meshReady(std::move(streamed_mesh));
}
}
// Vertex rebasing cont.: post-multiply the per-instance
// PlacementTransformation by T(+offset) so world position is
// preserved. Keep the emitted placement in double so later
// CoordinateOperation / false-origin composition can cancel
// large translations before the final GPU float upload.
Eigen::Matrix4d mat_d =
tri_elem->transformation().data()->ccomponents();
if (mesh_aabbs[local_mesh_id].has_offset) {
const Eigen::Vector3d mesh_rebase_offset(
mesh_aabbs[local_mesh_id].offset[0],
mesh_aabbs[local_mesh_id].offset[1],
mesh_aabbs[local_mesh_id].offset[2]);
mat_d.block<3, 1>(0, 3) += mat_d.block<3, 3>(0, 0) * mesh_rebase_offset;
}
StreamedInstance inst;
inst.session_model_id = session_model_id_;
inst.local_mesh_id = local_mesh_id;
inst.object_id = object_id;
inst.color_override_rgba8 = 0;
for (int i = 0; i < 16; ++i) {
inst.transform[i] = mat_d.data()[i];
}
const MeshAabb& mesh_aabb = mesh_aabbs[local_mesh_id];
float mat_f[16];
for (int i = 0; i < 16; ++i) {
mat_f[i] = static_cast<float>(inst.transform[i]);
}
worldAabbFromLocal(mesh_aabb.lmin, mesh_aabb.lmax, mat_f,
inst.world_aabb_min, inst.world_aabb_max);
emit instanceReady(std::move(inst));
total_shapes++;
yielded_count++;
const int progress_percent = total_count > 0
? static_cast<int>((100 * yielded_count) / total_count)
: 100;
if (progress_percent != last_emitted_progress) {
last_emitted_progress = progress_percent;
progress_ = progress_percent;
emit progressChanged(progress_percent);
}
} while (iterator->next());
return true;
};
if (prioritised_contexts.empty()) {
// No IfcGeometricRepresentationContext entities — fall back to
// a single iterator pass without context-id filtering.
return run_iterator(base_settings);
}
for (size_t i = 0; i < prioritised_contexts.size(); ++i) {
if (cancel_requested_.load()) break;
if (remaining.empty()) break;
ifcopenshell::geom::settings iter_settings = base_settings;
iter_settings.set("context-ids",
std::set<int>{ prioritised_contexts[i] });
if (!run_iterator(iter_settings)) return false;
}
return true;
};
if (!run_pass(net_ids, /*is_gross=*/false)) return;
if (!cancel_requested_.load()) {
run_pass(gross_ids, /*is_gross=*/true);
}
progress_ = 100;
emit progressChanged(100);
double dedup_ratio = total_meshes > 0
? static_cast<double>(total_shapes) / static_cast<double>(total_meshes) : 1.0;
std::fprintf(stderr,
"[info] Streamer done: %s %.2fs shapes=%u unique_meshes=%u dedup=%.2fx\n",
path.c_str(), stream_timer.elapsed() / 1000.0,
total_shapes, total_meshes, dedup_ratio);
succeeded_ = !cancel_requested_.load();
}
Reference in New Issue View Git Blame Copy Permalink