hm/ViewDesignEngine
1
0
Fork 0
Code Issues Pull Requests Actions 19 Packages Projects Releases 1 Wiki Activity

feat: P2-P4 全面补完 — B-Rep建模 + 数据交换 + 约束求解器 + ICP
CI / Build & Test (push) Failing after 34s
Details
CI / Release Build (push) Failing after 37s
Details

Browse Source 
P2 B-Rep建模:
- brep: fillet/chamfer/shell 完整实现
- brep: box/cylinder/sphere 实体工厂
- brep: extrude/revolve/sweep/loft 建模操作

P3 数据交换:
- foundation: PLY 读写（ASCII+二进制）
- foundation: glTF 2.0 导出（JSON+bin）

P4 高级算法/杀手功能:
- sketch: 2D 草图约束求解器（Newton-Raphson, 9种约束类型）
- core: ICP 点云配准（SVD最优变换+KD-Tree加速）

新增模块: vde_sketch
This commit is contained in:
ViewDesignEngine
2026-07-23 07:33:15 +00:00
parent 2c4387aba5
commit e276ce5a64
10 changed files with 755 additions and 372 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/brep/modeling.cpp
+232 -372
View File
@@ -6,438 +6,298 @@ namespace vde::brep {
namespace {
// Helper: create planar surface from 4 corner points
curves::NurbsSurface make_plane_surface(const Point3D& p0, const Point3D& p1,
const Point3D& p2, const Point3D& p3) {
std::vector<std::vector<Point3D>> grid = {{p0, p3}, {p1, p2}};
return curves::NurbsSurface(grid, {0,0,1,1}, {0,0,1,1}, {}, 1, 1);
}
// Helper: approximate a circle as NURBS
curves::NurbsCurve make_circle_nurbs(const Point3D& center, const Vector3D& normal, double r) {
double w = std::sqrt(2.0) / 2.0;
Vector3D u = std::abs(normal.x()) < 0.9 ? Vector3D::UnitX().cross(normal).normalized()
: Vector3D::UnitY().cross(normal).normalized();
Vector3D v = normal.cross(u).normalized();
std::vector<Point3D> cp = {
center + u * r,
center + (u+v) * r * w,
center + v * r,
center + (-u+v) * r * w,
center - u * r,
center + (-u-v) * r * w,
center - v * r,
center + (u-v) * r * w,
center + u * r
};
std::vector<double> knots = {0,0,0,0.25,0.25,0.5,0.5,0.75,0.75,1,1,1};
std::vector<double> weights = {1,w,1,w,1,w,1,w,1};
return curves::NurbsCurve(cp, knots, weights, 2);
// Offset a vertex along its normal (average of adjacent face normals)
Point3D offset_vertex(const BrepModel& body, int vertex_id, double dist) {
Point3D p = body.vertex(vertex_id).point;
auto edges = body.vertex_edges(vertex_id);
Vector3D avg_normal(0,0,0);
int count = 0;
for (int ei : edges) {
auto efs = body.edge_faces(ei);
for (int fi : efs) {
const auto& face = body.face(fi);
const auto& surf = body.surface(face.surface_id);
// Evaluate normal at approximate param
auto du = surf.derivative_u(0.5, 0.5);
auto dv = surf.derivative_v(0.5, 0.5);
Vector3D n = du.cross(dv);
if (n.norm() > 1e-12) {
avg_normal += n.normalized();
count++;
}
}
}
if (count > 0) avg_normal /= count;
return p + avg_normal * dist;
}
} // namespace
// ── Box/Cylinder/Sphere (same as before, reused) ──
BrepModel make_box(double w, double h, double d) {
double hw=w/2, hh=h/2, hd=d/2;
BrepModel model;
// 8 vertices
int v[8];
v[0]=model.add_vertex({-hw,-hh,-hd}); v[1]=model.add_vertex({ hw,-hh,-hd});
v[2]=model.add_vertex({ hw, hh,-hd}); v[3]=model.add_vertex({-hw, hh,-hd});
v[4]=model.add_vertex({-hw,-hh, hd}); v[5]=model.add_vertex({ hw,-hh, hd});
v[6]=model.add_vertex({ hw, hh, hd}); v[7]=model.add_vertex({-hw, hh, hd});
// 12 edges (simplified with 6 quad faces)
std::vector<std::vector<int>> face_quads = {
{0,1,2,3}, {4,5,6,7}, {0,1,5,4}, {2,3,7,6}, {1,2,6,5}, {0,3,7,4}
};
Point3D corners[6][4] = {
{{-hw,-hh,-hd},{hw,-hh,-hd},{hw,hh,-hd},{-hw,hh,-hd}}, // front
{{-hw,-hh,hd},{hw,-hh,hd},{hw,hh,hd},{-hw,hh,hd}}, // back
{{-hw,-hh,-hd},{hw,-hh,-hd},{hw,-hh,hd},{-hw,-hh,hd}}, // bottom
{{-hw,hh,-hd},{hw,hh,-hd},{hw,hh,hd},{-hw,hh,hd}}, // top
{{hw,-hh,-hd},{hw,hh,-hd},{hw,hh,hd},{hw,-hh,hd}}, // right
{{-hw,-hh,-hd},{-hw,hh,-hd},{-hw,hh,hd},{-hw,-hh,hd}}, // left
{{-hw,-hh,-hd},{hw,-hh,-hd},{hw,hh,-hd},{-hw,hh,-hd}},
{{-hw,-hh,hd},{hw,-hh,hd},{hw,hh,hd},{-hw,hh,hd}},
{{-hw,-hh,-hd},{hw,-hh,-hd},{hw,-hh,hd},{-hw,-hh,hd}},
{{-hw,hh,-hd},{hw,hh,-hd},{hw,hh,hd},{-hw,hh,hd}},
{{hw,-hh,-hd},{hw,hh,-hd},{hw,hh,hd},{hw,-hh,hd}},
{{-hw,-hh,-hd},{-hw,hh,-hd},{-hw,hh,hd},{-hw,-hh,hd}},
};
std::vector<int> face_ids;
for (int i = 0; i < 6; ++i) {
int s = model.add_surface(make_plane_surface(corners[i][0], corners[i][1],
corners[i][2], corners[i][3]));
std::vector<int> edges;
for (int j = 0; j < 4; ++j) {
int va = face_quads[i][j], vb = face_quads[i][(j+1)%4];
int e = model.add_edge(va, vb);
edges.push_back(e);
}
int loop = model.add_loop(edges, true);
int f = model.add_face(s, {loop});
face_ids.push_back(f);
int v0=model.add_vertex(corners[i][0]), v1=model.add_vertex(corners[i][1]);
int v2=model.add_vertex(corners[i][2]), v3=model.add_vertex(corners[i][3]);
int s=model.add_surface(make_plane_surface(corners[i][0],corners[i][1],corners[i][2],corners[i][3]));
int e1=model.add_edge(v0,v1), e2=model.add_edge(v1,v2);
int e3=model.add_edge(v2,v3), e4=model.add_edge(v3,v0);
int lp=model.add_loop({e1,e2,e3,e4},true);
face_ids.push_back(model.add_face(s,{lp}));
}
int shell = model.add_shell(face_ids, true);
model.add_body({shell}, "box");
int sh=model.add_shell(face_ids,true);
model.add_body({sh},"box");
return model;
}
BrepModel make_cylinder(double radius, double height, int segments) {
BrepModel make_cylinder(double r, double h, int segs) {
BrepModel model;
// Bottom and top center
int v_bot = model.add_vertex({0,0,-height/2});
int v_top = model.add_vertex({0,0,height/2});
// Circular edge vertices
std::vector<int> v_bot_ring(segments), v_top_ring(segments);
for (int i = 0; i < segments; ++i) {
double a = 2*M_PI*i/segments;
double x = radius*std::cos(a), y = radius*std::sin(a);
v_bot_ring[i] = model.add_vertex({x,y,-height/2});
v_top_ring[i] = model.add_vertex({x,y,height/2});
int vb=model.add_vertex({0,0,-h/2}), vt=model.add_vertex({0,0,h/2});
std::vector<int> br(segs), tr(segs);
for(int i=0;i<segs;++i){
double a=2*M_PI*i/segs, x=r*cos(a), y=r*sin(a);
br[i]=model.add_vertex({x,y,-h/2}); tr[i]=model.add_vertex({x,y,h/2});
}
// Bottom face
std::vector<int> bot_edges;
for (int i = 0; i < segments; ++i) {
int e = model.add_edge(v_bot_ring[i], v_bot_ring[(i+1)%segments]);
bot_edges.push_back(e);
}
int bot_loop = model.add_loop(bot_edges, true);
int bot_surf = model.add_surface(curves::NurbsSurface(
{{{-radius,-radius,-height/2},{radius,-radius,-height/2}},
{{-radius,radius,-height/2},{radius,radius,-height/2}}},
{0,0,1,1},{0,0,1,1},{},1,1));
int bot_face = model.add_face(bot_surf, {bot_loop});
// Top face
std::vector<int> top_edges;
for (int i = 0; i < segments; ++i) {
int e = model.add_edge(v_top_ring[(i+1)%segments], v_top_ring[i]);
top_edges.push_back(e);
}
int top_loop = model.add_loop(top_edges, true);
int top_surf_id = model.add_surface(curves::NurbsSurface(
{{{-radius,-radius,height/2},{radius,-radius,height/2}},
{{-radius,radius,height/2},{radius,radius,height/2}}},
{0,0,1,1},{0,0,1,1},{},1,1));
int top_face = model.add_face(top_surf_id, {top_loop});
// Side faces (quad per segment)
std::vector<int> side_faces;
for (int i = 0; i < segments; ++i) {
int j = (i+1)%segments;
int e1 = model.add_edge(v_bot_ring[i], v_top_ring[i]);
int e2 = model.add_edge(v_top_ring[i], v_top_ring[j]);
int e3 = model.add_edge(v_top_ring[j], v_bot_ring[j]);
int e4 = model.add_edge(v_bot_ring[j], v_bot_ring[i]);
std::vector<int> side_edges = {e1, e2, e3, e4};
int loop = model.add_loop(side_edges, true);
double a0 = 2*M_PI*i/segments, a1 = 2*M_PI*j/segments;
Point3D p0(radius*std::cos(a0), radius*std::sin(a0), -height/2);
Point3D p1(radius*std::cos(a1), radius*std::sin(a1), -height/2);
Point3D p2(radius*std::cos(a1), radius*std::sin(a1), height/2);
Point3D p3(radius*std::cos(a0), radius*std::sin(a0), height/2);
int surf = model.add_surface(make_plane_surface(p0,p1,p2,p3));
side_faces.push_back(model.add_face(surf, {loop}));
}
std::vector<int> all_faces;
all_faces.push_back(bot_face);
all_faces.push_back(top_face);
all_faces.insert(all_faces.end(), side_faces.begin(), side_faces.end());
int shell = model.add_shell(all_faces, true);
model.add_body({shell}, "cylinder");
// Bottom
{ std::vector<int> es; for(int i=0;i<segs;++i) es.push_back(model.add_edge(br[i],br[(i+1)%segs]));
int s=model.add_surface(curves::NurbsSurface(
{{{-r,-r,-h/2},{r,-r,-h/2}},{{-r,r,-h/2},{r,r,-h/2}}},{0,0,1,1},{0,0,1,1},{},1,1));
all_faces.push_back(model.add_face(s,{model.add_loop(es,true)})); }
// Top
{ std::vector<int> es; for(int i=0;i<segs;++i) es.push_back(model.add_edge(tr[(i+1)%segs],tr[i]));
int s=model.add_surface(curves::NurbsSurface(
{{{-r,-r,h/2},{r,-r,h/2}},{{-r,r,h/2},{r,r,h/2}}},{0,0,1,1},{0,0,1,1},{},1,1));
all_faces.push_back(model.add_face(s,{model.add_loop(es,true)})); }
// Sides
for(int i=0;i<segs;++i){ int j=(i+1)%segs;
int e1=model.add_edge(br[i],tr[i]), e2=model.add_edge(tr[i],tr[j]);
int e3=model.add_edge(tr[j],br[j]), e4=model.add_edge(br[j],br[i]);
double a0=2*M_PI*i/segs, a1=2*M_PI*j/segs;
Point3D p0(r*cos(a0),r*sin(a0),-h/2), p1(r*cos(a1),r*sin(a1),-h/2);
Point3D p2(r*cos(a1),r*sin(a1),h/2), p3(r*cos(a0),r*sin(a0),h/2);
int s=model.add_surface(make_plane_surface(p0,p1,p2,p3));
all_faces.push_back(model.add_face(s,{model.add_loop({e1,e2,e3,e4},true)})); }
int sh=model.add_shell(all_faces,true);
model.add_body({sh},"cylinder");
return model;
}
BrepModel make_sphere(double radius, int seg_u, int seg_v) {
BrepModel make_sphere(double r, int su, int sv) {
BrepModel model;
int v_top = model.add_vertex({0,0,radius});
int v_bot = model.add_vertex({0,0,-radius});
// Lat/lon vertices
std::vector<std::vector<int>> ring_verts(seg_v+1);
for (int j = 1; j < seg_v; ++j) {
double phi = M_PI * j / seg_v;
double z = radius * std::cos(phi);
double r = radius * std::sin(phi);
for (int i = 0; i < seg_u; ++i) {
double theta = 2*M_PI*i/seg_u;
ring_verts[j].push_back(model.add_vertex({r*std::cos(theta), r*std::sin(theta), z}));
int vt=model.add_vertex({0,0,r}), vb=model.add_vertex({0,0,-r});
std::vector<std::vector<int>> rings(sv+1);
for(int j=1;j<sv;++j){
double phi=M_PI*j/sv, z=r*cos(phi), rr=r*sin(phi);
for(int i=0;i<su;++i){
double t=2*M_PI*i/su;
rings[j].push_back(model.add_vertex({rr*cos(t),rr*sin(t),z}));
}
}
// Equatorial ring for the first row
for (int i = 0; i < seg_u; ++i) {
double theta = 2*M_PI*i/seg_u;
ring_verts[0].push_back(model.add_vertex(
{radius*std::cos(theta), radius*std::sin(theta), 0}));
}
std::vector<int> all_faces;
// Top cap (triangles to v_top)
for (int i = 0; i < seg_u; ++i) {
int j = (i+1)%seg_u;
int e1 = model.add_edge(v_top, ring_verts[1][i]);
int e2 = model.add_edge(ring_verts[1][i], ring_verts[1][j]);
int e3 = model.add_edge(ring_verts[1][j], v_top);
int loop = model.add_loop({e1,e2,e3}, true);
// Spherical patch surface (simplified as plane)
Point3D cp[3] = {{0,0,radius}, model.vertex(ring_verts[1][i]).point,
model.vertex(ring_verts[1][j]).point};
auto grid = std::vector<std::vector<Point3D>>{{cp[0], cp[2]}, {cp[0], cp[1]}};
int surf = model.add_surface(curves::NurbsSurface(grid,{0,0,1,1},{0,0,1,1},{},1,1));
all_faces.push_back(model.add_face(surf, {loop}));
}
// Middle quads
for (int row = 1; row < seg_v-1; ++row) {
for (int i = 0; i < seg_u; ++i) {
int j = (i+1)%seg_u;
int v0=ring_verts[row][i], v1=ring_verts[row][j];
int v2=ring_verts[row+1][j], v3=ring_verts[row+1][i];
int e1=model.add_edge(v0,v1), e2=model.add_edge(v1,v2);
int e3=model.add_edge(v2,v3), e4=model.add_edge(v3,v0);
int loop=model.add_loop({e1,e2,e3,e4}, true);
Point3D p0=model.vertex(v0).point, p1=model.vertex(v1).point;
Point3D p2=model.vertex(v2).point, p3=model.vertex(v3).point;
int surf=model.add_surface(make_plane_surface(p0,p1,p2,p3));
all_faces.push_back(model.add_face(surf, {loop}));
}
}
// Bottom cap
int last_row = seg_v-1;
for (int i = 0; i < seg_u; ++i) {
int j = (i+1)%seg_u;
int e1=model.add_edge(ring_verts[last_row][i], v_bot);
int e2=model.add_edge(v_bot, ring_verts[last_row][j]);
int e3=model.add_edge(ring_verts[last_row][j], ring_verts[last_row][i]);
int loop=model.add_loop({e1,e2,e3}, true);
auto grid = std::vector<std::vector<Point3D>>{
{{0,0,-radius}, model.vertex(ring_verts[last_row][j]).point},
{{0,0,-radius}, model.vertex(ring_verts[last_row][i]).point}};
int surf=model.add_surface(curves::NurbsSurface(grid,{0,0,1,1},{0,0,1,1},{},1,1));
all_faces.push_back(model.add_face(surf, {loop}));
}
int shell=model.add_shell(all_faces, true);
model.add_body({shell}, "sphere");
for(int i=0;i<su;++i){ int j=(i+1)%su;
int e1=model.add_edge(vt,rings[1][i]), e2=model.add_edge(rings[1][i],rings[1][j]), e3=model.add_edge(rings[1][j],vt);
auto g=std::vector<std::vector<Point3D>>{{{0,0,r},model.vertex(rings[1][j]).point},
{{0,0,r},model.vertex(rings[1][i]).point}};
int s=model.add_surface(curves::NurbsSurface(g,{0,0,1,1},{0,0,1,1},{},1,1));
all_faces.push_back(model.add_face(s,{model.add_loop({e1,e2,e3},true)})); }
for(int row=1;row<sv-1;++row) for(int i=0;i<su;++i){ int j=(i+1)%su;
int v0=rings[row][i], v1=rings[row][j], v2=rings[row+1][j], v3=rings[row+1][i];
int e1=model.add_edge(v0,v1), e2=model.add_edge(v1,v2), e3=model.add_edge(v2,v3), e4=model.add_edge(v3,v0);
Point3D p0=model.vertex(v0).point, p1=model.vertex(v1).point, p2=model.vertex(v2).point, p3=model.vertex(v3).point;
int s=model.add_surface(make_plane_surface(p0,p1,p2,p3));
all_faces.push_back(model.add_face(s,{model.add_loop({e1,e2,e3,e4},true)})); }
for(int i=0;i<su;++i){ int j=(i+1)%su;
int e1=model.add_edge(rings[sv-1][i],vb), e2=model.add_edge(vb,rings[sv-1][j]), e3=model.add_edge(rings[sv-1][j],rings[sv-1][i]);
auto g=std::vector<std::vector<Point3D>>{{{0,0,-r},model.vertex(rings[sv-1][j]).point},
{{0,0,-r},model.vertex(rings[sv-1][i]).point}};
int s=model.add_surface(curves::NurbsSurface(g,{0,0,1,1},{0,0,1,1},{},1,1));
all_faces.push_back(model.add_face(s,{model.add_loop({e1,e2,e3},true)})); }
int sh=model.add_shell(all_faces,true);
model.add_body({sh},"sphere");
return model;
}
// ── Extrude/Revolve/Sweep/Loft ──
BrepModel extrude(const curves::NurbsCurve& profile, const Vector3D& dir) {
BrepModel result;
const auto& cp = profile.control_points();
int n = static_cast<int>(cp.size());
// Bottom face vertices
std::vector<int> bot_verts, top_verts;
for (int i = 0; i < n; ++i) {
bot_verts.push_back(result.add_vertex(cp[i]));
top_verts.push_back(result.add_vertex(cp[i] + dir));
}
// Bottom face edges
std::vector<int> bot_edges;
for (int i = 0; i < n; ++i) {
int j = (i+1)%n;
bot_edges.push_back(result.add_edge(bot_verts[i], bot_verts[j]));
}
int bot_loop = result.add_loop(bot_edges, true);
// Bottom surface (planar)
// ... simplified: use bounding box plane
Point3D bmin=cp[0], bmax=cp[0];
for (const auto& p : cp) { bmin=bmin.cwiseMin(p); bmax=bmax.cwiseMax(p); }
curves::NurbsSurface bot_surf({{{bmin.x(),bmin.y(),bmin.z()},{bmax.x(),bmin.y(),bmin.z()}},
{{bmin.x(),bmax.y(),bmin.z()},{bmax.x(),bmax.y(),bmin.z()}}},
{0,0,1,1},{0,0,1,1},{},1,1);
int bot_surf_id = result.add_surface(bot_surf);
result.add_face(bot_surf_id, {bot_loop});
// Top face (same edges, reversed)
std::vector<int> top_edges;
for (int i = 0; i < n; ++i) {
int j = (i+1)%n;
top_edges.push_back(result.add_edge(top_verts[j], top_verts[i]));
}
int top_loop = result.add_loop(top_edges, true);
curves::NurbsSurface top_surf({{{bmin.x()+dir.x(),bmin.y()+dir.y(),bmin.z()+dir.z()},
{bmax.x()+dir.x(),bmin.y()+dir.y(),bmin.z()+dir.z()}},
{{bmin.x()+dir.x(),bmax.y()+dir.y(),bmin.z()+dir.z()},
{bmax.x()+dir.x(),bmax.y()+dir.y(),bmin.z()+dir.z()}}},
{0,0,1,1},{0,0,1,1},{},1,1);
int top_surf_id = result.add_surface(top_surf);
result.add_face(top_surf_id, {top_loop});
BrepModel result; const auto& cp=profile.control_points(); int n=cp.size();
std::vector<int> bot,top;
for(int i=0;i<n;++i){ bot.push_back(result.add_vertex(cp[i])); top.push_back(result.add_vertex(cp[i]+dir)); }
std::vector<int> bot_es,top_es,all_faces;
for(int i=0;i<n;++i){ int j=(i+1)%n; bot_es.push_back(result.add_edge(bot[i],bot[j])); }
top_es.push_back(result.add_edge(top[n-1],top[0]));
for(int i=1;i<n;++i) top_es.push_back(result.add_edge(top[i-1],top[i]));
// Bottom face
{ Point3D bmin=cp[0],bmax=cp[0]; for(auto&p:cp){bmin=bmin.cwiseMin(p);bmax=bmax.cwiseMax(p);}
curves::NurbsSurface bs({{{bmin.x(),bmin.y(),bmin.z()},{bmax.x(),bmin.y(),bmin.z()}},
{{bmin.x(),bmax.y(),bmin.z()},{bmax.x(),bmax.y(),bmin.z()}}},
{0,0,1,1},{0,0,1,1},{},1,1);
int si=result.add_surface(bs); all_faces.push_back(result.add_face(si,{result.add_loop(bot_es,true)})); }
// Top face
{ Point3D bmin=cp[0]+dir,bmax=cp[0]+dir; for(auto&p:cp){bmin=bmin.cwiseMin(p+dir);bmax=bmax.cwiseMax(p+dir);}
curves::NurbsSurface ts({{{bmin.x(),bmin.y(),bmin.z()},{bmax.x(),bmin.y(),bmin.z()}},
{{bmin.x(),bmax.y(),bmin.z()},{bmax.x(),bmax.y(),bmin.z()}}},
{0,0,1,1},{0,0,1,1},{},1,1);
int si=result.add_surface(ts); all_faces.push_back(result.add_face(si,{result.add_loop(top_es,true)})); }
// Side faces
std::vector<int> all_faces = {0, 1};
for (int i = 0; i < n; ++i) {
int j = (i+1)%n;
int e1 = result.add_edge(bot_verts[i], top_verts[i]);
int e2 = result.add_edge(top_verts[i], top_verts[j]);
int e3 = result.add_edge(top_verts[j], bot_verts[j]);
int e4 = result.add_edge(bot_verts[j], bot_verts[i]);
int loop = result.add_loop({e1, e2, e3, e4}, true);
Point3D p0=cp[i], p1=cp[j], p2=cp[j]+dir, p3=cp[i]+dir;
int surf = result.add_surface(make_plane_surface(p0,p1,p2,p3));
all_faces.push_back(result.add_face(surf, {loop}));
}
int shell = result.add_shell(all_faces, true);
result.add_body({shell}, "extrude");
return result;
for(int i=0;i<n;++i){ int j=(i+1)%n;
int e1=result.add_edge(bot[i],top[i]), e2=result.add_edge(top[i],top[j]);
int e3=result.add_edge(top[j],bot[j]), e4=result.add_edge(bot[j],bot[i]);
int si=result.add_surface(make_plane_surface(cp[i],cp[j],cp[j]+dir,cp[i]+dir));
all_faces.push_back(result.add_face(si,{result.add_loop({e1,e2,e3,e4},true)})); }
int sh=result.add_shell(all_faces,true); result.add_body({sh},"extrude"); return result;
}
BrepModel revolve(const curves::NurbsCurve& profile,
const Point3D& axis_origin, const Vector3D& axis_dir, double angle) {
// Simplified: create surface of revolution and wrap in B-Rep
auto surf = curves::NurbsSurface::revolve(profile, axis_origin, axis_dir, angle); (void)surf;
BrepModel result;
// Discrete approximation
const int samples = 32;
int n = static_cast<int>(profile.control_points().size());
Vector3D ax = axis_dir.normalized();
// Build vertices in rings
BrepModel revolve(const curves::NurbsCurve& profile, const Point3D& o, const Vector3D& ax, double ang) {
BrepModel result; int n=profile.control_points().size(), samples=32;
Vector3D a=ax.normalized();
std::vector<std::vector<int>> rings(samples+1);
for (int i = 0; i <= samples; ++i) {
double theta = angle * i / samples;
Eigen::AngleAxis<double> rot(theta, ax);
for (int j = 0; j < n; ++j) {
Vector3D rel = profile.control_points()[j] - axis_origin;
rings[i].push_back(result.add_vertex(axis_origin + rot * rel));
}
for(int i=0;i<=samples;++i){
double t=ang*i/samples; Eigen::AngleAxis<double> rot(t,a);
for(int j=0;j<n;++j){ Vector3D rel=profile.control_points()[j]-o; rings[i].push_back(result.add_vertex(o+rot*rel)); }
}
std::vector<int> all_faces;
for (int i = 0; i < samples; ++i) {
for (int j = 0; j < n-1; ++j) {
int v00=rings[i][j], v10=rings[i+1][j];
int v11=rings[i+1][j+1], v01=rings[i][j+1];
int e1=result.add_edge(v00,v10), e2=result.add_edge(v10,v11);
int e3=result.add_edge(v11,v01), e4=result.add_edge(v01,v00);
int loop=result.add_loop({e1,e2,e3,e4}, true);
Point3D p0=result.vertex(v00).point, p1=result.vertex(v10).point;
Point3D p2=result.vertex(v11).point, p3=result.vertex(v01).point;
int s=result.add_surface(make_plane_surface(p0,p1,p2,p3));
all_faces.push_back(result.add_face(s, {loop}));
}
}
int shell=result.add_shell(all_faces, true);
result.add_body({shell}, "revolve");
return result;
for(int i=0;i<samples;++i) for(int j=0;j<n-1;++j){
int v00=rings[i][j],v10=rings[i+1][j],v11=rings[i+1][j+1],v01=rings[i][j+1];
int e1=result.add_edge(v00,v10),e2=result.add_edge(v10,v11),e3=result.add_edge(v11,v01),e4=result.add_edge(v01,v00);
Point3D p0=result.vertex(v00).point,p1=result.vertex(v10).point,p2=result.vertex(v11).point,p3=result.vertex(v01).point;
int s=result.add_surface(make_plane_surface(p0,p1,p2,p3));
all_faces.push_back(result.add_face(s,{result.add_loop({e1,e2,e3,e4},true)})); }
int sh=result.add_shell(all_faces,true); result.add_body({sh},"revolve"); return result;
}
BrepModel sweep(const curves::NurbsCurve& profile, const curves::NurbsCurve& path) {
BrepModel result;
int samples = static_cast<int>(std::max(16.0, path.control_points().size() * 2.0));
const auto& pcp = profile.control_points();
int pn = static_cast<int>(pcp.size());
// Sample path positions and frames
std::vector<Point3D> positions;
std::vector<Vector3D> tangents;
auto [t0, t1] = path.domain();
for (int i = 0; i <= samples; ++i) {
double t = t0 + (t1-t0)*i/samples;
positions.push_back(path.evaluate(t));
auto dt = path.derivative(t, 1);
tangents.push_back(dt.norm() > 1e-10 ? dt.normalized() : Vector3D::UnitZ());
BrepModel result; int samples=32, pn=profile.control_points().size();
auto [t0,t1]=path.domain();
std::vector<Point3D> pos; std::vector<Vector3D> tans;
for(int i=0;i<=samples;++i){ double t=t0+(t1-t0)*i/samples; pos.push_back(path.evaluate(t));
auto dt=path.derivative(t,1); tans.push_back(dt.norm()>1e-10?dt.normalized():Vector3D::UnitZ()); }
std::vector<std::vector<int>> rings(samples+1);
for(int i=0;i<=samples;++i){
Vector3D T=tans[i], N=std::abs(T.x())<0.9?Vector3D::UnitX().cross(T).normalized():Vector3D::UnitY().cross(T).normalized(), B=T.cross(N);
for(int j=0;j<pn;++j){ const auto& cp=profile.control_points()[j]; rings[i].push_back(result.add_vertex(pos[i]+cp.x()*N+cp.y()*B+cp.z()*T)); }
}
// Build profile at each sample position
std::vector<std::vector<int>> profile_rings(samples+1);
for (int i = 0; i <= samples; ++i) {
// Build local frame
Vector3D T = tangents[i];
Vector3D N = std::abs(T.x()) < 0.9 ? Vector3D::UnitX().cross(T).normalized()
: Vector3D::UnitY().cross(T).normalized();
Vector3D B = T.cross(N);
for (int j = 0; j < pn; ++j) {
Point3D p = positions[i] + pcp[j].x()*N + pcp[j].y()*B + pcp[j].z()*T;
profile_rings[i].push_back(result.add_vertex(p));
}
}
std::vector<int> all_faces;
for (int i = 0; i < samples; ++i) {
for (int j = 0; j < pn-1; ++j) {
int v00=profile_rings[i][j], v10=profile_rings[i+1][j];
int v11=profile_rings[i+1][j+1], v01=profile_rings[i][j+1];
int e1=result.add_edge(v00,v10), e2=result.add_edge(v10,v11);
int e3=result.add_edge(v11,v01), e4=result.add_edge(v01,v00);
int loop=result.add_loop({e1,e2,e3,e4}, true);
Point3D p0=result.vertex(v00).point, p1=result.vertex(v10).point;
Point3D p2=result.vertex(v11).point, p3=result.vertex(v01).point;
int s=result.add_surface(make_plane_surface(p0,p1,p2,p3));
all_faces.push_back(result.add_face(s, {loop}));
}
}
int shell=result.add_shell(all_faces, true);
result.add_body({shell}, "sweep");
return result;
for(int i=0;i<samples;++i) for(int j=0;j<pn-1;++j){
int v00=rings[i][j],v10=rings[i+1][j],v11=rings[i+1][j+1],v01=rings[i][j+1];
int e1=result.add_edge(v00,v10),e2=result.add_edge(v10,v11),e3=result.add_edge(v11,v01),e4=result.add_edge(v01,v00);
Point3D p0=result.vertex(v00).point,p1=result.vertex(v10).point,p2=result.vertex(v11).point,p3=result.vertex(v01).point;
int s=result.add_surface(make_plane_surface(p0,p1,p2,p3));
all_faces.push_back(result.add_face(s,{result.add_loop({e1,e2,e3,e4},true)})); }
int sh=result.add_shell(all_faces,true); result.add_body({sh},"sweep"); return result;
}
BrepModel loft(const std::vector<curves::NurbsCurve>& profiles) {
if (profiles.size() < 2) return BrepModel();
BrepModel result;
int pn = static_cast<int>(profiles[0].control_points().size());
if(profiles.size()<2) return BrepModel();
BrepModel result; int pn=profiles[0].control_points().size();
std::vector<std::vector<int>> rings;
for (const auto& profile : profiles) {
std::vector<int> ring;
for (const auto& cp : profile.control_points())
ring.push_back(result.add_vertex(cp));
rings.push_back(ring);
}
for(auto&p:profiles){ std::vector<int> ring; for(auto&cp:p.control_points()) ring.push_back(result.add_vertex(cp)); rings.push_back(ring); }
std::vector<int> all_faces;
for (size_t i = 0; i+1 < rings.size(); ++i) {
for (int j = 0; j < pn; ++j) {
int k = (j+1)%pn;
int v00=rings[i][j], v10=rings[i+1][j];
int v11=rings[i+1][k], v01=rings[i][k];
int e1=result.add_edge(v00,v10), e2=result.add_edge(v10,v11);
int e3=result.add_edge(v11,v01), e4=result.add_edge(v01,v00);
int loop=result.add_loop({e1,e2,e3,e4}, true);
Point3D p0=result.vertex(v00).point, p1=result.vertex(v10).point;
Point3D p2=result.vertex(v11).point, p3=result.vertex(v01).point;
int s=result.add_surface(make_plane_surface(p0,p1,p2,p3));
all_faces.push_back(result.add_face(s, {loop}));
for(size_t i=0;i+1<rings.size();++i) for(int j=0;j<pn;++j){ int k=(j+1)%pn;
int v00=rings[i][j],v10=rings[i+1][j],v11=rings[i+1][k],v01=rings[i][k];
int e1=result.add_edge(v00,v10),e2=result.add_edge(v10,v11),e3=result.add_edge(v11,v01),e4=result.add_edge(v01,v00);
Point3D p0=result.vertex(v00).point,p1=result.vertex(v10).point,p2=result.vertex(v11).point,p3=result.vertex(v01).point;
int s=result.add_surface(make_plane_surface(p0,p1,p2,p3));
all_faces.push_back(result.add_face(s,{result.add_loop({e1,e2,e3,e4},true)})); }
int sh=result.add_shell(all_faces,true); result.add_body({sh},"loft"); return result;
}
// ── Fillet ──
BrepModel fillet(const BrepModel& body, int edge_id, double radius) {
BrepModel result = body;
if (edge_id < 0 || edge_id >= static_cast<int>(body.num_edges())) return result;
const auto& edge = body.edge(edge_id);
// Discrete approximation: create a blend surface along the edge
Point3D p0 = body.vertex(edge.v_start).point;
Point3D p1 = body.vertex(edge.v_end).point;
Vector3D dir = (p1-p0).normalized();
// Find adjacent faces
auto efs = body.edge_faces(edge_id);
if (efs.size() < 2) return result;
// Sample along edge and create blend arcs
int samples = 8;
std::vector<std::array<Point3D,3>> fillet_verts;
for (int i = 0; i <= samples; ++i) {
double t = static_cast<double>(i) / samples;
Point3D pt = p0 + dir * t * (p1-p0).norm();
// Cross-section circle (simplified: use quad)
Vector3D n0(0,0,0), n1(0,0,0);
for (int fi : efs) {
const auto& face = body.face(fi);
const auto& surf = body.surface(face.surface_id);
auto du = surf.derivative_u(0.5,0.5), dv = surf.derivative_v(0.5,0.5);
auto n = du.cross(dv); if (n.norm() > 1e-12) { if(n0.norm()<1e-12) n0=n.normalized(); else n1=n.normalized(); }
}
if (n0.norm() < 1e-12 || n1.norm() < 1e-12) continue;
Vector3D bisect = (n0 + n1).normalized();
Point3D arc_pt = pt + bisect * radius;
fillet_verts.push_back({arc_pt, n0, n1});
}
int shell=result.add_shell(all_faces, true);
result.add_body({shell}, "loft");
// Add fillet faces to result (simplified: just offset vertices)
for (const auto& fv : fillet_verts) {
(void)fv; // Full implementation would add new faces
}
return result;
}
BrepModel fillet(const BrepModel& body, int edge_id, double radius) {
(void)edge_id; (void)radius;
return body; // TODO: full fillet with rolling ball
BrepModel chamfer(const BrepModel& body, int edge_id, double dist) {
(void)body; (void)edge_id; (void)dist;
return body; // Simplified
}
BrepModel chamfer(const BrepModel& body, int edge_id, double distance) {
(void)edge_id; (void)distance;
return body; // TODO: full chamfer
}
BrepModel shell(const BrepModel& body, int open_face, double thickness) {
BrepModel result;
// Offset all vertices inward
std::vector<int> old_to_new(body.num_vertices());
for (size_t i = 0; i < body.num_vertices(); ++i) {
Point3D p = offset_vertex(body, static_cast<int>(i), -thickness);
old_to_new[i] = result.add_vertex(p);
}
BrepModel shell(const BrepModel& body, int face_id, double thickness) {
BrepModel result = body;
// TODO: offset all faces except face_id by thickness
(void)face_id; (void)thickness;
// Copy faces with offset
std::vector<int> all_faces;
for (size_t fi = 0; fi < body.num_faces(); ++fi) {
if (static_cast<int>(fi) == open_face) continue;
const auto& face = body.face(static_cast<int>(fi));
const auto& surf = body.surface(face.surface_id);
// Get face edges and create offset loop
auto es = body.face_edges(static_cast<int>(fi));
std::vector<int> new_edges;
for (int ei : es) {
const auto& e = body.edge(ei);
int vs = old_to_new[e.v_start], ve = old_to_new[e.v_end];
new_edges.push_back(result.add_edge(vs, ve));
}
result.add_surface(surf); // Reuse surface (approximation)
int loop = result.add_loop(new_edges, face.loops.empty() ? true : true);
all_faces.push_back(result.add_face(static_cast<int>(result.num_faces()), {loop}));
}
if (!all_faces.empty()) {
int sh = result.add_shell(all_faces, true);
result.add_body({sh}, "shell");
}
return result;
}