茂之钳
248 lines
9.4 KiB
C++
248 lines
9.4 KiB
C++
#include <gtest/gtest.h>
|
||
#include "vde/brep/trimmed_surface.h"
|
||
#include "vde/curves/nurbs_surface.h"
|
||
#include <cmath>
|
||
|
||
using namespace vde::brep;
|
||
using namespace vde::curves;
|
||
using vde::core::Point3D;
|
||
|
||
namespace {
|
||
|
||
/// Helper: create a simple 10×10 planar NURBS surface in the XY plane
|
||
/// Control grid: 2×2, degree 1×1, knots {0,0,1,1}
|
||
/// Domain: u∈[0,1], v∈[0,1] → maps to XY square [0,10]×[0,10] at Z=0
|
||
NurbsSurface make_plane() {
|
||
std::vector<std::vector<Point3D>> cp = {
|
||
{Point3D(0, 0, 0), Point3D(0, 10, 0)},
|
||
{Point3D(10, 0, 0), Point3D(10, 10, 0)}
|
||
};
|
||
std::vector<double> ku = {0, 0, 1, 1};
|
||
std::vector<double> kv = {0, 0, 1, 1};
|
||
std::vector<std::vector<double>> w = {{1, 1}, {1, 1}};
|
||
return NurbsSurface(cp, ku, kv, w, 1, 1);
|
||
}
|
||
|
||
/// Helper: create a linear p-curve line segment in parameter space
|
||
PCurve make_pcurve_line(double ua, double va, double ub, double vb) {
|
||
std::vector<Point3D> cps = { Point3D(ua, va, 0.0), Point3D(ub, vb, 0.0) };
|
||
std::vector<double> knots = { 0.0, 0.0, 1.0, 1.0 };
|
||
std::vector<double> weights = { 1.0, 1.0 };
|
||
return PCurve(cps, knots, weights, 1);
|
||
}
|
||
|
||
/// Helper: create a rectangular trim loop
|
||
TrimLoop make_rect_loop(double u0, double u1, double v0, double v1) {
|
||
TrimLoop loop;
|
||
loop.is_outer = true;
|
||
loop.p_curves.push_back(make_pcurve_line(u0, v0, u1, v0)); // bottom
|
||
loop.p_curves.push_back(make_pcurve_line(u1, v0, u1, v1)); // right
|
||
loop.p_curves.push_back(make_pcurve_line(u1, v1, u0, v1)); // top
|
||
loop.p_curves.push_back(make_pcurve_line(u0, v1, u0, v0)); // left
|
||
return loop;
|
||
}
|
||
|
||
} // anonymous namespace
|
||
|
||
// ═══════════════════════════════════════════════════════════
|
||
// Untrimmed surface
|
||
// ═══════════════════════════════════════════════════════════
|
||
|
||
TEST(TrimmedSurfaceTest, Untrimmed_EvaluatesAllCorners) {
|
||
auto surf = make_plane();
|
||
auto ts = TrimmedSurface::from_surface(surf);
|
||
|
||
// All points in the parameter domain should evaluate successfully
|
||
auto p00 = ts.evaluate(0.0, 0.0);
|
||
ASSERT_TRUE(p00.has_value());
|
||
EXPECT_NEAR(p00->x(), 0.0, 1e-6);
|
||
EXPECT_NEAR(p00->y(), 0.0, 1e-6);
|
||
EXPECT_NEAR(p00->z(), 0.0, 1e-6);
|
||
|
||
auto p11 = ts.evaluate(1.0, 1.0);
|
||
ASSERT_TRUE(p11.has_value());
|
||
EXPECT_NEAR(p11->x(), 10.0, 1e-6);
|
||
EXPECT_NEAR(p11->y(), 10.0, 1e-6);
|
||
EXPECT_NEAR(p11->z(), 0.0, 1e-6);
|
||
|
||
auto p10 = ts.evaluate(1.0, 0.0);
|
||
ASSERT_TRUE(p10.has_value());
|
||
EXPECT_NEAR(p10->x(), 10.0, 1e-6);
|
||
EXPECT_NEAR(p10->y(), 0.0, 1e-6);
|
||
|
||
auto p01 = ts.evaluate(0.0, 1.0);
|
||
ASSERT_TRUE(p01.has_value());
|
||
EXPECT_NEAR(p01->x(), 0.0, 1e-6);
|
||
EXPECT_NEAR(p01->y(), 10.0, 1e-6);
|
||
|
||
// Center
|
||
auto pc = ts.evaluate(0.5, 0.5);
|
||
ASSERT_TRUE(pc.has_value());
|
||
EXPECT_NEAR(pc->x(), 5.0, 1e-6);
|
||
EXPECT_NEAR(pc->y(), 5.0, 1e-6);
|
||
}
|
||
|
||
TEST(TrimmedSurfaceTest, Untrimmed_IsInsideAlwaysTrue) {
|
||
auto surf = make_plane();
|
||
auto ts = TrimmedSurface::from_surface(surf);
|
||
|
||
EXPECT_TRUE(ts.is_inside(0.0, 0.0));
|
||
EXPECT_TRUE(ts.is_inside(0.5, 0.5));
|
||
EXPECT_TRUE(ts.is_inside(1.0, 1.0));
|
||
EXPECT_TRUE(ts.is_inside(0.123, 0.789));
|
||
}
|
||
|
||
// ═══════════════════════════════════════════════════════════
|
||
// Rectangular trim
|
||
// ═══════════════════════════════════════════════════════════
|
||
|
||
TEST(TrimmedSurfaceTest, RectTrim_InsideRegion) {
|
||
auto surf = make_plane();
|
||
auto ts = TrimmedSurface::from_rect(surf, 0.0, 0.5, 0.0, 0.5);
|
||
|
||
// Point at (0.25, 0.25) → 3D: (2.5, 2.5, 0) — inside trim
|
||
auto p = ts.evaluate(0.25, 0.25);
|
||
ASSERT_TRUE(p.has_value());
|
||
EXPECT_NEAR(p->x(), 2.5, 1e-6);
|
||
EXPECT_NEAR(p->y(), 2.5, 1e-6);
|
||
EXPECT_NEAR(p->z(), 0.0, 1e-6);
|
||
|
||
EXPECT_TRUE(ts.is_inside(0.25, 0.25));
|
||
}
|
||
|
||
TEST(TrimmedSurfaceTest, RectTrim_OutsideRegion) {
|
||
auto surf = make_plane();
|
||
auto ts = TrimmedSurface::from_rect(surf, 0.0, 0.5, 0.0, 0.5);
|
||
|
||
// Point at (0.75, 0.25) — outside trim (u > 0.5)
|
||
auto p = ts.evaluate(0.75, 0.25);
|
||
EXPECT_FALSE(p.has_value());
|
||
EXPECT_FALSE(ts.is_inside(0.75, 0.25));
|
||
|
||
// Point at (0.25, 0.75) — outside trim (v > 0.5)
|
||
EXPECT_FALSE(ts.is_inside(0.25, 0.75));
|
||
|
||
// Point at (0.75, 0.75) — outside both
|
||
EXPECT_FALSE(ts.is_inside(0.75, 0.75));
|
||
}
|
||
|
||
TEST(TrimmedSurfaceTest, RectTrim_BoundaryIsInside) {
|
||
auto surf = make_plane();
|
||
auto ts = TrimmedSurface::from_rect(surf, 0.0, 0.5, 0.0, 0.5);
|
||
|
||
// Points on the boundary should be considered inside (convention)
|
||
EXPECT_TRUE(ts.is_inside(0.0, 0.0));
|
||
EXPECT_TRUE(ts.is_inside(0.5, 0.5));
|
||
EXPECT_TRUE(ts.is_inside(0.0, 0.5));
|
||
EXPECT_TRUE(ts.is_inside(0.5, 0.0));
|
||
}
|
||
|
||
// ═══════════════════════════════════════════════════════════
|
||
// Hole (inner loop)
|
||
// ═══════════════════════════════════════════════════════════
|
||
|
||
TEST(TrimmedSurfaceTest, Hole_CenterIsOutside) {
|
||
auto surf = make_plane();
|
||
TrimmedSurface ts;
|
||
ts.base_surface = surf;
|
||
|
||
// Outer loop: full [0,1]×[0,1] rectangle
|
||
ts.loops.push_back(make_rect_loop(0.0, 1.0, 0.0, 1.0));
|
||
|
||
// Inner loop (hole): [0.25,0.75]×[0.25,0.75] square
|
||
auto hole = make_rect_loop(0.25, 0.75, 0.25, 0.75);
|
||
hole.is_outer = false;
|
||
ts.loops.push_back(hole);
|
||
|
||
// Center (0.5, 0.5) is inside the hole → outside trimmed surface
|
||
EXPECT_FALSE(ts.is_inside(0.5, 0.5));
|
||
auto p_center = ts.evaluate(0.5, 0.5);
|
||
EXPECT_FALSE(p_center.has_value());
|
||
|
||
// Corner (0.1, 0.1) is inside outer, outside hole → inside trimmed surface
|
||
EXPECT_TRUE(ts.is_inside(0.1, 0.1));
|
||
auto p_corner = ts.evaluate(0.1, 0.1);
|
||
ASSERT_TRUE(p_corner.has_value());
|
||
EXPECT_NEAR(p_corner->x(), 1.0, 1e-6);
|
||
EXPECT_NEAR(p_corner->y(), 1.0, 1e-6);
|
||
|
||
// Point inside hole boundary
|
||
EXPECT_FALSE(ts.is_inside(0.3, 0.3));
|
||
}
|
||
|
||
// ═══════════════════════════════════════════════════════════
|
||
// Bounds
|
||
// ═══════════════════════════════════════════════════════════
|
||
|
||
TEST(TrimmedSurfaceTest, Bounds_Untrimmed) {
|
||
auto surf = make_plane();
|
||
auto ts = TrimmedSurface::from_surface(surf);
|
||
auto b = ts.bounds();
|
||
|
||
// The plane spans [0,10]×[0,10] at Z=0
|
||
EXPECT_NEAR(b.min().x(), 0.0, 1e-6);
|
||
EXPECT_NEAR(b.max().x(), 10.0, 1e-6);
|
||
EXPECT_NEAR(b.min().y(), 0.0, 1e-6);
|
||
EXPECT_NEAR(b.max().y(), 10.0, 1e-6);
|
||
EXPECT_NEAR(b.min().z(), 0.0, 1e-6);
|
||
EXPECT_NEAR(b.max().z(), 0.0, 1e-6);
|
||
}
|
||
|
||
TEST(TrimmedSurfaceTest, Bounds_RectangularTrim) {
|
||
auto surf = make_plane();
|
||
auto ts = TrimmedSurface::from_rect(surf, 0.25, 0.75, 0.25, 0.75);
|
||
auto b = ts.bounds();
|
||
|
||
// Trimmed to [2.5, 7.5]×[2.5, 7.5] at Z=0
|
||
EXPECT_NEAR(b.min().x(), 2.5, 1e-6);
|
||
EXPECT_NEAR(b.max().x(), 7.5, 1e-6);
|
||
EXPECT_NEAR(b.min().y(), 2.5, 1e-6);
|
||
EXPECT_NEAR(b.max().y(), 7.5, 1e-6);
|
||
EXPECT_NEAR(b.min().z(), 0.0, 1e-6);
|
||
EXPECT_NEAR(b.max().z(), 0.0, 1e-6);
|
||
}
|
||
|
||
TEST(TrimmedSurfaceTest, Bounds_WithHole) {
|
||
auto surf = make_plane();
|
||
TrimmedSurface ts;
|
||
ts.base_surface = surf;
|
||
ts.loops.push_back(make_rect_loop(0.2, 0.8, 0.2, 0.8));
|
||
auto hole = make_rect_loop(0.3, 0.7, 0.3, 0.7);
|
||
hole.is_outer = false;
|
||
ts.loops.push_back(hole);
|
||
|
||
auto b = ts.bounds();
|
||
|
||
// Bounds are computed from outer loop only, spans [2,8]×[2,8] at Z=0
|
||
EXPECT_NEAR(b.min().x(), 2.0, 1e-6);
|
||
EXPECT_NEAR(b.max().x(), 8.0, 1e-6);
|
||
EXPECT_NEAR(b.min().y(), 2.0, 1e-6);
|
||
EXPECT_NEAR(b.max().y(), 8.0, 1e-6);
|
||
}
|
||
|
||
// ═══════════════════════════════════════════════════════════
|
||
// from_surface constructor
|
||
// ═══════════════════════════════════════════════════════════
|
||
|
||
TEST(TrimmedSurfaceTest, FromSurface_HasNoLoops) {
|
||
auto surf = make_plane();
|
||
auto ts = TrimmedSurface::from_surface(surf);
|
||
|
||
EXPECT_TRUE(ts.loops.empty());
|
||
EXPECT_TRUE(ts.is_inside(0.5, 0.5));
|
||
}
|
||
|
||
// ═══════════════════════════════════════════════════════════
|
||
// from_rect constructor
|
||
// ═══════════════════════════════════════════════════════════
|
||
|
||
TEST(TrimmedSurfaceTest, FromRect_CreatesOneOuterLoop) {
|
||
auto surf = make_plane();
|
||
auto ts = TrimmedSurface::from_rect(surf, 0.0, 1.0, 0.0, 1.0);
|
||
|
||
EXPECT_EQ(ts.loops.size(), 1u);
|
||
EXPECT_TRUE(ts.loops[0].is_outer);
|
||
// Rectangular loop has 4 p-curves (one per side)
|
||
EXPECT_EQ(ts.loops[0].p_curves.size(), 4u);
|
||
}
|