fix: 编译通过 — CMake + 命名空间 + 头文件修复
- CMake: INTERFACE 库修复、vde_compile_options 顺序修复 - 命名空间: 所有模块添加 using 声明 - 类型补全: Ray3Dd、Point4D - 头文件: tolerance 泛型化、std::optional include - 警告: 放宽 -Wconversion/-Wsign-conversion - 构建结果: 0 errors, 22/25 tests passed
This commit is contained in:
ViewDesignEngine
+9
-9
@@ -125,15 +125,15 @@ target_link_libraries(vde_collision
|
||||
# ── 聚合库 ──────────────────────────────────────────
|
||||
add_library(vde INTERFACE)
|
||||
target_link_libraries(vde
|
||||
PUBLIC vde_foundation
|
||||
PUBLIC vde_core
|
||||
PUBLIC vde_curves
|
||||
PUBLIC vde_mesh
|
||||
PUBLIC vde_spatial
|
||||
PUBLIC vde_boolean
|
||||
PUBLIC vde_collision
|
||||
PUBLIC vde_brep
|
||||
PUBLIC vde_sketch
|
||||
INTERFACE vde_foundation
|
||||
INTERFACE vde_core
|
||||
INTERFACE vde_curves
|
||||
INTERFACE vde_mesh
|
||||
INTERFACE vde_spatial
|
||||
INTERFACE vde_boolean
|
||||
INTERFACE vde_collision
|
||||
INTERFACE vde_brep
|
||||
INTERFACE vde_sketch
|
||||
)
|
||||
add_library(vde::engine ALIAS vde)
|
||||
|
||||
|
||||
@@ -3,6 +3,7 @@
|
||||
#include <cmath>
|
||||
|
||||
namespace vde::boolean {
|
||||
using core::Vector2D;
|
||||
|
||||
std::vector<Polygon2D> polygon_offset(const Polygon2D& poly, double distance) {
|
||||
const auto& verts = poly.vertices();
|
||||
|
||||
@@ -4,6 +4,8 @@
|
||||
#include <limits>
|
||||
|
||||
namespace vde::collision {
|
||||
using core::Point3D;
|
||||
using core::Vector3D;
|
||||
|
||||
namespace {
|
||||
|
||||
|
||||
@@ -2,6 +2,11 @@
|
||||
#include <cmath>
|
||||
|
||||
namespace vde::collision {
|
||||
using core::Point3D;
|
||||
using core::Vector3D;
|
||||
using core::Triangle3D;
|
||||
using core::Ray3Dd;
|
||||
using core::Segment3Dd;
|
||||
|
||||
std::optional<RayTriResult> ray_triangle_intersect(
|
||||
const Point3D& origin, const Vector3D& dir, const Triangle3D& tri) {
|
||||
|
||||
@@ -4,6 +4,8 @@
|
||||
#include <limits>
|
||||
|
||||
namespace vde::collision {
|
||||
using core::Point3D;
|
||||
using core::Vector3D;
|
||||
|
||||
static Vector3D compute_normal(const Point3D& a, const Point3D& b, const Point3D& c) {
|
||||
return (b-a).cross(c-a).normalized();
|
||||
|
||||
@@ -2,6 +2,9 @@
|
||||
#include <cmath>
|
||||
|
||||
namespace vde::collision {
|
||||
using core::Point3D;
|
||||
using core::Vector3D;
|
||||
using core::Triangle3D;
|
||||
|
||||
// Separating axis test for two triangles
|
||||
static bool on_opposite_sides(const Point3D& p, const Point3D& q, const Point3D& a, const Point3D& b) {
|
||||
|
||||
+1
-1
@@ -87,7 +87,7 @@ ICPResult icp_register(const std::vector<Point3D>& source,
|
||||
Point3D nearest = find_nearest(aligned[i], tree);
|
||||
rms += (aligned[i] - nearest).squaredNorm();
|
||||
}
|
||||
rms = std::sqrt(rms / aligned.size());
|
||||
rms = std::sqrt(rms / static_cast<double>(aligned.size()));
|
||||
|
||||
result.iterations = iter + 1;
|
||||
result.rms_error = rms;
|
||||
|
||||
+17
-55
@@ -1,22 +1,10 @@
|
||||
#include "vde/core/voronoi.h"
|
||||
#include "vde/mesh/delaunay_2d.h"
|
||||
#include <unordered_map>
|
||||
#include <algorithm>
|
||||
#include <cmath>
|
||||
|
||||
namespace vde::core {
|
||||
|
||||
// Edge key for unordered_map
|
||||
struct EdgeKey {
|
||||
int a, b;
|
||||
EdgeKey(int va, int vb) : a(std::min(va, vb)), b(std::max(va, vb)) {}
|
||||
bool operator==(const EdgeKey& o) const { return a == o.a && b == o.b; }
|
||||
};
|
||||
struct EdgeKeyHash {
|
||||
size_t operator()(const EdgeKey& e) const {
|
||||
return (static_cast<uint64_t>(e.a) << 32) | static_cast<uint64_t>(e.b);
|
||||
}
|
||||
};
|
||||
|
||||
std::vector<VoronoiCell> voronoi_2d(const std::vector<Point2D>& points) {
|
||||
std::vector<VoronoiCell> cells(points.size());
|
||||
for (size_t i = 0; i < points.size(); ++i)
|
||||
@@ -24,7 +12,6 @@ std::vector<VoronoiCell> voronoi_2d(const std::vector<Point2D>& points) {
|
||||
|
||||
if (points.size() < 3) return cells;
|
||||
|
||||
// Compute Delaunay triangulation
|
||||
auto dresult = mesh::delaunay_2d(points);
|
||||
const auto& verts = dresult.vertices;
|
||||
const auto& tris = dresult.triangles;
|
||||
@@ -32,69 +19,44 @@ std::vector<VoronoiCell> voronoi_2d(const std::vector<Point2D>& points) {
|
||||
// Compute circumcenters for each Delaunay triangle
|
||||
std::vector<Point2D> circumcenters;
|
||||
for (const auto& tri : tris) {
|
||||
Point2D a = verts[tri[0]], b = verts[tri[1]], c = verts[tri[2]];
|
||||
double d = 2 * (a.x()*(b.y()-c.y()) + b.x()*(c.y()-a.y()) + c.x()*(a.y()-b.y()));
|
||||
Point2D a = verts[tri[0]], b_p = verts[tri[1]], c_p = verts[tri[2]];
|
||||
double d = 2 * (a.x()*(b_p.y()-c_p.y()) + b_p.x()*(c_p.y()-a.y()) + c_p.x()*(a.y()-b_p.y()));
|
||||
if (std::abs(d) < 1e-12) { circumcenters.push_back({0,0}); continue; }
|
||||
double ux = ((a.x()*a.x()+a.y()*a.y())*(b.y()-c.y())
|
||||
+ (b.x()*b.x()+b.y()*b.y())*(c.y()-a.y())
|
||||
+ (c.x()*c.x()+c.y()*c.y())*(a.y()-b.y())) / d;
|
||||
double uy = ((a.x()*a.x()+a.y()*a.y())*(c.x()-b.x())
|
||||
+ (b.x()*b.x()+b.y()*b.y())*(a.x()-c.x())
|
||||
+ (c.x()*c.x()+c.y()*c.y())*(b.x()-a.x())) / d;
|
||||
double ux = ((a.x()*a.x()+a.y()*a.y())*(b_p.y()-c_p.y())
|
||||
+ (b_p.x()*b_p.x()+b_p.y()*b_p.y())*(c_p.y()-a.y())
|
||||
+ (c_p.x()*c_p.x()+c_p.y()*c_p.y())*(a.y()-b_p.y())) / d;
|
||||
double uy = ((a.x()*a.x()+a.y()*a.y())*(c_p.x()-b_p.x())
|
||||
+ (b_p.x()*b_p.x()+b_p.y()*b_p.y())*(a.x()-c_p.x())
|
||||
+ (c_p.x()*c_p.x()+c_p.y()*c_p.y())*(b_p.x()-a.x())) / d;
|
||||
circumcenters.push_back({ux, uy});
|
||||
}
|
||||
|
||||
// For each vertex, collect circumcenters of adjacent triangles
|
||||
for (size_t i = 0; i < points.size(); ++i) {
|
||||
std::vector<Point2D> cell_verts;
|
||||
std::unordered_map<EdgeKey, int, EdgeKeyHash> edge_first;
|
||||
|
||||
// Find all triangles containing this vertex
|
||||
for (size_t ti = 0; ti < tris.size(); ++ti) {
|
||||
const auto& tri = tris[ti];
|
||||
for (int j = 0; j < 3; ++j) {
|
||||
if (tri[j] == static_cast<int>(i) || tri[(j+1)%3] == static_cast<int>(i)) {
|
||||
int v0 = tri[(j+0)%3], v1 = tri[(j+1)%3];
|
||||
// Edge v0-v1 connects two circumcenters
|
||||
// Find neighboring triangle sharing edge v0-v1
|
||||
for (size_t tj = ti + 1; tj < tris.size(); ++tj) {
|
||||
const auto& tri2 = tris[tj];
|
||||
bool shares[3] = {false, false, false};
|
||||
for (int k = 0; k < 3; ++k)
|
||||
shares[k] = (tri2[k] == v0 || tri2[k] == v1 ||
|
||||
tri2[k] == tri[(j+2)%3]);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Simplified: just collect circumcenters of adjacent triangles
|
||||
for (size_t ti = 0; ti < tris.size(); ++ti) {
|
||||
const auto& tri = tris[ti];
|
||||
bool contains = false;
|
||||
for (int j = 0; j < 3; ++j)
|
||||
if (tri[j] == static_cast<int>(i)) { contains = true; break; }
|
||||
if (contains) {
|
||||
if (contains)
|
||||
cells[i].vertices.push_back(circumcenters[ti]);
|
||||
}
|
||||
}
|
||||
|
||||
// Sort circumcenters angularly around site for proper polygon
|
||||
// Sort angularly around site
|
||||
if (cells[i].vertices.size() >= 3) {
|
||||
std::sort(cells[i].vertices.begin(), cells[i].vertices.end(),
|
||||
[&](const Point2D& a, const Point2D& b) {
|
||||
return std::atan2(a.y() - points[i].y(), a.x() - points[i].x()) <
|
||||
std::atan2(b.y() - points[i].y(), b.x() - points[i].x());
|
||||
[&](const Point2D& pa, const Point2D& pb) {
|
||||
return std::atan2(pa.y()-points[i].y(), pa.x()-points[i].x())
|
||||
< std::atan2(pb.y()-points[i].y(), pb.x()-points[i].x());
|
||||
});
|
||||
// Deduplicate
|
||||
// Dedup
|
||||
auto last = std::unique(cells[i].vertices.begin(), cells[i].vertices.end(),
|
||||
[](const Point2D& a, const Point2D& b) {
|
||||
return (a-b).norm() < 1e-9;
|
||||
[](const Point2D& pa, const Point2D& pb) {
|
||||
return (pa-pb).norm() < 1e-9;
|
||||
});
|
||||
cells[i].vertices.erase(last, cells[i].vertices.end());
|
||||
}
|
||||
}
|
||||
|
||||
return cells;
|
||||
}
|
||||
|
||||
|
||||
@@ -24,10 +24,10 @@ Point3D NurbsCurve::evaluate(double t) const {
|
||||
Vector3D NurbsCurve::derivative(double t, int order) const {
|
||||
// Simplified: use B-Spline derivative on homogenized points
|
||||
if (order <= 0) return evaluate(t) - Point3D::Zero();
|
||||
std::vector<Point4D> hpts;
|
||||
std::vector<Eigen::Vector4d> hpts;
|
||||
for (size_t i = 0; i < cp_.size(); ++i) {
|
||||
double w = weights_[i];
|
||||
hpts.emplace_back(cp_[i].x() * w, cp_[i].y() * w, cp_[i].z() * w, w);
|
||||
hpts.push_back(Eigen::Vector4d(cp_[i].x() * w, cp_[i].y() * w, cp_[i].z() * w, w));
|
||||
}
|
||||
// Derivative in homogeneous space then project
|
||||
return Vector3D::Zero(); // TODO: proper NURBS derivative
|
||||
|
||||
+21
-47
@@ -1,30 +1,23 @@
|
||||
#include "vde/foundation/io_gltf.h"
|
||||
#include "vde/core/aabb.h"
|
||||
#include <fstream>
|
||||
#include <sstream>
|
||||
#include <algorithm>
|
||||
#include <cmath>
|
||||
#include <string>
|
||||
|
||||
namespace vde::foundation {
|
||||
|
||||
namespace {
|
||||
|
||||
std::string vec3_to_json(double x, double y, double z) {
|
||||
static std::string vec3_json(double x, double y, double z) {
|
||||
return "[" + std::to_string(x) + "," + std::to_string(y) + "," + std::to_string(z) + "]";
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
bool write_gltf(const std::string& filepath, const mesh::HalfedgeMesh& mesh) {
|
||||
std::ofstream file(filepath);
|
||||
if (!file) return false;
|
||||
|
||||
size_t nv = mesh.num_vertices();
|
||||
size_t nf = mesh.num_faces();
|
||||
|
||||
// Count total indices (triangles * 3)
|
||||
size_t index_count = nf * 3;
|
||||
|
||||
// Build min/max for accessor bounds
|
||||
core::AABB3D bounds = mesh.bounds();
|
||||
|
||||
file << "{\n";
|
||||
@@ -32,59 +25,40 @@ bool write_gltf(const std::string& filepath, const mesh::HalfedgeMesh& mesh) {
|
||||
file << " \"scene\": 0,\n";
|
||||
file << " \"scenes\": [{\"nodes\": [0]}],\n";
|
||||
file << " \"nodes\": [{\"mesh\": 0}],\n";
|
||||
file << " \"meshes\": [{\n";
|
||||
file << " \"primitives\": [{\n";
|
||||
file << " \"attributes\": {\"POSITION\": 0},\n";
|
||||
file << " \"indices\": 1\n";
|
||||
file << " }]\n";
|
||||
file << " }],\n";
|
||||
|
||||
// Buffers and bufferViews
|
||||
file << " \"buffers\": [{\"uri\": \"data:application/octet-stream;base64,";
|
||||
|
||||
// Write binary data as base64 (simplified: write inline as hex-ish)
|
||||
// For simplicity, write a separate .bin file reference
|
||||
file << "mesh.bin\",\"byteLength\": " << (nv*12 + index_count*4) << "}],\n";
|
||||
|
||||
file << " \"meshes\": [{\"primitives\": [{\"attributes\": {\"POSITION\": 0},\"indices\": 1}]}],\n";
|
||||
file << " \"buffers\": [{\"uri\": \"mesh.bin\",\"byteLength\": " << (nv*12+index_count*4) << "}],\n";
|
||||
file << " \"bufferViews\": [\n";
|
||||
file << " {\"buffer\": 0, \"byteOffset\": 0, \"byteLength\": " << (nv*12) << "},\n";
|
||||
file << " {\"buffer\": 0, \"byteOffset\": " << (nv*12) << ", \"byteLength\": " << (index_count*4) << "}\n";
|
||||
file << " ],\n";
|
||||
|
||||
// Accessors
|
||||
file << " \"accessors\": [\n";
|
||||
file << " {\"bufferView\": 0, \"componentType\": 5126, \"count\": " << nv
|
||||
<< ", \"type\": \"VEC3\", \"max\": " << vec3_to_json(bounds.max().x(),bounds.max().y(),bounds.max().z())
|
||||
<< ", \"min\": " << vec3_to_json(bounds.min().x(),bounds.min().y(),bounds.min().z()) << "},\n";
|
||||
file << " {\"bufferView\": 1, \"componentType\": 5125, \"count\": " << index_count
|
||||
<< ", \"type\": \"SCALAR\"}\n";
|
||||
file << " ]\n";
|
||||
file << "}\n";
|
||||
|
||||
// Write binary data file
|
||||
std::string binpath = filepath;
|
||||
size_t dot = binpath.rfind(.);
|
||||
if (dot != std::string::npos) binpath = binpath.substr(0, dot);
|
||||
binpath += ".bin";
|
||||
<< ", \"type\": \"VEC3\", \"max\": " << vec3_json(bounds.max().x(),bounds.max().y(),bounds.max().z())
|
||||
<< ", \"min\": " << vec3_json(bounds.min().x(),bounds.min().y(),bounds.min().z()) << "},\n";
|
||||
file << " {\"bufferView\": 1, \"componentType\": 5125, \"count\": " << index_count << ", \"type\": \"SCALAR\"}\n";
|
||||
file << " ]\n}\n";
|
||||
|
||||
// Write binary data
|
||||
std::string dot = ".";
|
||||
std::string binpath = filepath.substr(0, filepath.rfind(dot)) + ".bin";
|
||||
std::ofstream bin(binpath, std::ios::binary);
|
||||
// Vertices (float32)
|
||||
|
||||
for (size_t i = 0; i < nv; ++i) {
|
||||
const auto& v = mesh.vertex(i);
|
||||
float fx=v.x(), fy=v.y(), fz=v.z();
|
||||
bin.write(reinterpret_cast<const char*>(&fx),4);
|
||||
bin.write(reinterpret_cast<const char*>(&fy),4);
|
||||
bin.write(reinterpret_cast<const char*>(&fz),4);
|
||||
float fx = static_cast<float>(v.x());
|
||||
float fy = static_cast<float>(v.y());
|
||||
float fz = static_cast<float>(v.z());
|
||||
bin.write(reinterpret_cast<const char*>(&fx), 4);
|
||||
bin.write(reinterpret_cast<const char*>(&fy), 4);
|
||||
bin.write(reinterpret_cast<const char*>(&fz), 4);
|
||||
}
|
||||
// Indices (uint32)
|
||||
for (size_t i = 0; i < nf; ++i) {
|
||||
auto vis = mesh.face_vertices(static_cast<int>(i));
|
||||
for (size_t j = 0; j < std::min(vis.size(), size_t(3)); ++j) {
|
||||
uint32_t idx = vis[j];
|
||||
bin.write(reinterpret_cast<const char*>(&idx),4);
|
||||
uint32_t idx = static_cast<uint32_t>(vis[j]);
|
||||
bin.write(reinterpret_cast<const char*>(&idx), 4);
|
||||
}
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
@@ -4,105 +4,96 @@
|
||||
|
||||
namespace vde::foundation {
|
||||
|
||||
namespace {
|
||||
|
||||
template<typename T>
|
||||
void write_le(std::vector<uint8_t>& buf, T val) {
|
||||
for (size_t i = 0; i < sizeof(T); ++i)
|
||||
buf.push_back(static_cast<uint8_t>((val >> (i*8)) & 0xFF));
|
||||
static void write_bytes(std::vector<uint8_t>& buf, const void* data, size_t len) {
|
||||
const auto* p = static_cast<const uint8_t*>(data);
|
||||
buf.insert(buf.end(), p, p + len);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
T read_le(const uint8_t*& ptr) {
|
||||
T val = 0;
|
||||
for (size_t i = 0; i < sizeof(T); ++i)
|
||||
val |= static_cast<T>(ptr[i]) << (i*8);
|
||||
static void write_val(std::vector<uint8_t>& buf, T val) {
|
||||
write_bytes(buf, &val, sizeof(T));
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
static T read_val(const uint8_t*& ptr) {
|
||||
T val;
|
||||
std::memcpy(&val, ptr, sizeof(T));
|
||||
ptr += sizeof(T);
|
||||
return val;
|
||||
}
|
||||
|
||||
} // namespace
|
||||
static void write_u32(std::vector<uint8_t>& buf, uint32_t v) { write_val(buf, v); }
|
||||
static void write_u64(std::vector<uint8_t>& buf, uint64_t v) { write_val(buf, v); }
|
||||
static void write_f64(std::vector<uint8_t>& buf, double v) { write_val(buf, v); }
|
||||
static void write_i32(std::vector<uint8_t>& buf, int32_t v) { write_val(buf, v); }
|
||||
|
||||
std::vector<uint8_t> BinarySerializer::serialize(const HalfedgeMesh& mesh) {
|
||||
std::vector<uint8_t> BinarySerializer::serialize(const mesh::HalfedgeMesh& mesh) {
|
||||
std::vector<uint8_t> buf;
|
||||
write_u64(buf, VDE_MAGIC);
|
||||
write_u32(buf, VDE_FORMAT_VERSION);
|
||||
write_u32(buf, 0);
|
||||
|
||||
// Header
|
||||
write_le(buf, VDE_MAGIC);
|
||||
write_le(buf, VDE_FORMAT_VERSION);
|
||||
write_le(buf, static_cast<uint32_t>(0)); // flags
|
||||
|
||||
// Vertex data
|
||||
uint32_t nv = static_cast<uint32_t>(mesh.num_vertices());
|
||||
write_le(buf, nv);
|
||||
write_u32(buf, nv);
|
||||
for (size_t i = 0; i < nv; ++i) {
|
||||
const auto& v = mesh.vertex(i);
|
||||
write_le(buf, v.x()); write_le(buf, v.y()); write_le(buf, v.z());
|
||||
write_f64(buf, v.x()); write_f64(buf, v.y()); write_f64(buf, v.z());
|
||||
}
|
||||
|
||||
// Face data
|
||||
uint32_t nf = static_cast<uint32_t>(mesh.num_faces());
|
||||
write_le(buf, nf);
|
||||
write_u32(buf, nf);
|
||||
for (size_t i = 0; i < nf; ++i) {
|
||||
auto vis = mesh.face_vertices(static_cast<int>(i));
|
||||
uint32_t nfv = static_cast<uint32_t>(vis.size());
|
||||
write_le(buf, nfv);
|
||||
for (int vi : vis) write_le(buf, static_cast<int32_t>(vi));
|
||||
write_u32(buf, static_cast<uint32_t>(vis.size()));
|
||||
for (int vi : vis) write_i32(buf, vi);
|
||||
}
|
||||
|
||||
return buf;
|
||||
}
|
||||
|
||||
HalfedgeMesh BinarySerializer::deserialize(const std::vector<uint8_t>& data) {
|
||||
HalfedgeMesh mesh;
|
||||
mesh::HalfedgeMesh BinarySerializer::deserialize(const std::vector<uint8_t>& data) {
|
||||
mesh::HalfedgeMesh mesh;
|
||||
if (data.size() < 16) return mesh;
|
||||
|
||||
const uint8_t* ptr = data.data();
|
||||
uint64_t magic = read_le<uint64_t>(ptr);
|
||||
if (magic != VDE_MAGIC) return mesh;
|
||||
|
||||
read_le<uint32_t>(ptr); // version
|
||||
read_le<uint32_t>(ptr); // flags
|
||||
if (read_val<uint64_t>(ptr) != VDE_MAGIC) return mesh;
|
||||
read_val<uint32_t>(ptr); // version
|
||||
read_val<uint32_t>(ptr); // flags
|
||||
|
||||
uint32_t nv = read_le<uint32_t>(ptr);
|
||||
std::vector<Point3D> verts;
|
||||
verts.reserve(nv);
|
||||
uint32_t nv = read_val<uint32_t>(ptr);
|
||||
std::vector<Point3D> verts; verts.reserve(nv);
|
||||
for (uint32_t i = 0; i < nv; ++i) {
|
||||
double x = read_le<double>(ptr);
|
||||
double y = read_le<double>(ptr);
|
||||
double z = read_le<double>(ptr);
|
||||
double x = read_val<double>(ptr), y = read_val<double>(ptr), z = read_val<double>(ptr);
|
||||
verts.emplace_back(x, y, z);
|
||||
}
|
||||
|
||||
uint32_t nf = read_le<uint32_t>(ptr);
|
||||
uint32_t nf = read_val<uint32_t>(ptr);
|
||||
std::vector<std::array<int, 3>> tris;
|
||||
for (uint32_t i = 0; i < nf; ++i) {
|
||||
uint32_t nfv = read_le<uint32_t>(ptr);
|
||||
uint32_t nfv = read_val<uint32_t>(ptr);
|
||||
std::vector<int> vis;
|
||||
for (uint32_t j = 0; j < nfv; ++j)
|
||||
vis.push_back(read_le<int32_t>(ptr));
|
||||
if (vis.size() >= 3)
|
||||
tris.push_back({vis[0], vis[1], vis[2]});
|
||||
for (uint32_t j = 0; j < nfv; ++j) vis.push_back(read_val<int32_t>(ptr));
|
||||
if (vis.size() >= 3) tris.push_back({vis[0], vis[1], vis[2]});
|
||||
}
|
||||
|
||||
mesh.build_from_triangles(verts, tris);
|
||||
return mesh;
|
||||
}
|
||||
|
||||
bool BinarySerializer::write_file(const std::string& path, const HalfedgeMesh& mesh) {
|
||||
bool BinarySerializer::write_file(const std::string& path, const mesh::HalfedgeMesh& mesh) {
|
||||
auto data = serialize(mesh);
|
||||
std::ofstream file(path, std::ios::binary);
|
||||
if (!file) return false;
|
||||
file.write(reinterpret_cast<const char*>(data.data()), data.size());
|
||||
file.write(reinterpret_cast<const char*>(data.data()), static_cast<std::streamsize>(data.size()));
|
||||
return file.good();
|
||||
}
|
||||
|
||||
HalfedgeMesh BinarySerializer::read_file(const std::string& path) {
|
||||
mesh::HalfedgeMesh BinarySerializer::read_file(const std::string& path) {
|
||||
std::ifstream file(path, std::ios::binary | std::ios::ate);
|
||||
if (!file) return {};
|
||||
auto size = file.tellg();
|
||||
file.seekg(0);
|
||||
std::vector<uint8_t> data(static_cast<size_t>(size));
|
||||
file.read(reinterpret_cast<char*>(data.data()), size);
|
||||
file.read(reinterpret_cast<char*>(data.data()), static_cast<std::streamsize>(size));
|
||||
return deserialize(data);
|
||||
}
|
||||
|
||||
|
||||
+13
-24
@@ -1,23 +1,19 @@
|
||||
#include "vde/mesh/mesh_boolean.h"
|
||||
#include "vde/spatial/bvh.h"
|
||||
#include <unordered_map>
|
||||
#include <array>
|
||||
#include "vde/core/line.h"
|
||||
// Note: line.h already provides Ray3Dd
|
||||
|
||||
namespace vde::mesh {
|
||||
|
||||
namespace {
|
||||
using core::Triangle3D;
|
||||
using core::Ray3Dd;
|
||||
|
||||
// Simple mesh boolean via triangle classification + clipping
|
||||
// Determines if a triangle is inside another mesh using ray casting
|
||||
bool is_point_inside(const Point3D& p, const HalfedgeMesh& mesh, const spatial::BVH& bvh) {
|
||||
// Ray cast in +X direction, count intersections
|
||||
static bool is_point_inside(const Point3D& p, const HalfedgeMesh& mesh, const spatial::BVH& bvh) {
|
||||
int hits = 0;
|
||||
Vector3D dir(1, 0, 0);
|
||||
Ray3Dd ray(p, dir);
|
||||
|
||||
auto results = bvh.query_ray(ray);
|
||||
for (const auto& tri : results) {
|
||||
// Use Möller-Trumbore
|
||||
Vector3D e1 = tri.v(1)-tri.v(0), e2 = tri.v(2)-tri.v(0);
|
||||
Vector3D h = dir.cross(e2);
|
||||
double a = e1.dot(h);
|
||||
@@ -35,10 +31,7 @@ bool is_point_inside(const Point3D& p, const HalfedgeMesh& mesh, const spatial::
|
||||
return (hits % 2) == 1;
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
HalfedgeMesh mesh_boolean(const HalfedgeMesh& a, const HalfedgeMesh& b, BooleanOp op) {
|
||||
// Build BVH for both meshes
|
||||
spatial::BVH bvh_a, bvh_b;
|
||||
{
|
||||
std::vector<Triangle3D> tris;
|
||||
@@ -62,16 +55,15 @@ HalfedgeMesh mesh_boolean(const HalfedgeMesh& a, const HalfedgeMesh& b, BooleanO
|
||||
std::vector<Point3D> out_verts;
|
||||
std::vector<std::array<int, 3>> out_tris;
|
||||
|
||||
auto add_tri = [&](const Point3D& v0, const Point3D& v1, const Point3D& v2) -> bool {
|
||||
auto add_tri = [&](const Point3D& v0, const Point3D& v1, const Point3D& v2) {
|
||||
Vector3D n = (v1-v0).cross(v2-v0);
|
||||
if (n.norm() < 1e-12) return false;
|
||||
if (n.norm() < 1e-12) return;
|
||||
int idx = static_cast<int>(out_verts.size());
|
||||
out_verts.insert(out_verts.end(), {v0, v1, v2});
|
||||
out_verts.push_back(v0); out_verts.push_back(v1); out_verts.push_back(v2);
|
||||
out_tris.push_back({idx, idx+1, idx+2});
|
||||
return true;
|
||||
};
|
||||
|
||||
auto class_for_op = [&](bool in_a, bool in_b, BooleanOp o) -> bool {
|
||||
auto class_for = [](bool in_a, bool in_b, BooleanOp o) -> bool {
|
||||
switch (o) {
|
||||
case BooleanOp::Union: return !in_a && !in_b;
|
||||
case BooleanOp::Intersection: return in_a && in_b;
|
||||
@@ -80,24 +72,21 @@ HalfedgeMesh mesh_boolean(const HalfedgeMesh& a, const HalfedgeMesh& b, BooleanO
|
||||
}
|
||||
};
|
||||
|
||||
// Classify and collect triangles from A
|
||||
for (size_t fi = 0; fi < a.num_faces(); ++fi) {
|
||||
auto vis = a.face_vertices(static_cast<int>(fi));
|
||||
if (vis.size() != 3) continue;
|
||||
Point3D v0 = a.vertex(vis[0]), v1 = a.vertex(vis[1]), v2 = a.vertex(vis[2]);
|
||||
Point3D c = (v0+v1+v2) / 3.0;
|
||||
bool in_b = is_point_inside(c, b, bvh_b);
|
||||
if (class_for_op(true, in_b, op)) add_tri(v0, v1, v2);
|
||||
if (class_for(true, is_point_inside(c, b, bvh_b), op))
|
||||
add_tri(v0, v1, v2);
|
||||
}
|
||||
|
||||
// Classify and collect triangles from B
|
||||
for (size_t fi = 0; fi < b.num_faces(); ++fi) {
|
||||
auto vis = b.face_vertices(static_cast<int>(fi));
|
||||
if (vis.size() != 3) continue;
|
||||
Point3D v0 = b.vertex(vis[0]), v1 = b.vertex(vis[1]), v2 = b.vertex(vis[2]);
|
||||
Point3D c = (v0+v1+v2) / 3.0;
|
||||
bool in_a = is_point_inside(c, a, bvh_a);
|
||||
if (class_for_op(false, in_a, op)) add_tri(v0, v1, v2);
|
||||
if (class_for(false, is_point_inside(c, a, bvh_a), op))
|
||||
add_tri(v0, v1, v2);
|
||||
}
|
||||
|
||||
HalfedgeMesh result;
|
||||
|
||||
@@ -48,7 +48,7 @@ std::vector<T> KDTree<T>::query_knn(const Point3D& point, size_t k) const {
|
||||
if constexpr (std::is_same_v<T, Point3D>) d = (item - point).norm();
|
||||
dists.emplace_back(d, item);
|
||||
}
|
||||
std::partial_sort(dists.begin(), dists.begin() + std::min(k, dists.size()), dists.end());
|
||||
std::partial_sort(dists.begin(), dists.begin() + std::min(k, dists.size()), dists.end(), [](const auto& a, const auto& b) { return a.first < b.first; });
|
||||
std::vector<T> result;
|
||||
for (size_t i = 0; i < std::min(k, dists.size()); ++i)
|
||||
result.push_back(dists[i].second);
|
||||
|
||||
Reference in New Issue
Block a user