You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1994 lines
75 KiB
1994 lines
75 KiB
#define _USE_MATH_DEFINES
|
|
#include <windows.h>
|
|
#include <iostream>
|
|
#include <iomanip>
|
|
#include <cmath>
|
|
#include <cassert>
|
|
#include <vector>
|
|
#include <functional>
|
|
#include <chrono>
|
|
#include <mimalloc.h>
|
|
|
|
#include <data/data_center.hpp>
|
|
#include <base/primitive.hpp>
|
|
#include <base/subface.hpp>
|
|
#include <primitive_descriptor.h>
|
|
#include <subface/geometry/geometry_data.hpp>
|
|
#include <primitive/simple/extrude.hpp>
|
|
|
|
// ============================================================================
|
|
// 测试框架宏
|
|
// ============================================================================
|
|
|
|
#define TEST_SECTION(name) \
|
|
std::cout << "\n========================================\n" \
|
|
<< "TEST: " << name << "\n" \
|
|
<< "========================================\n"
|
|
|
|
#define TEST_ASSERT(condition, message) \
|
|
do { \
|
|
if (!(condition)) { \
|
|
std::cerr << "❌ FAILED: " << message << "\n"; \
|
|
std::cerr << " at " << __FILE__ << ":" << __LINE__ << "\n"; \
|
|
return false; \
|
|
} else { \
|
|
std::cout << "✓ PASSED: " << message << "\n"; \
|
|
} \
|
|
} while (0)
|
|
|
|
#define TEST_APPROX_EQUAL(a, b, eps, message) \
|
|
TEST_ASSERT(std::abs((a) - (b)) < (eps), \
|
|
message << " (expected: " << (b) << ", got: " << (a) << ", diff: " << std::abs((a) - (b)) << ")")
|
|
|
|
#define TEST_VECTOR_APPROX_EQUAL(v1, v2, eps, message) \
|
|
TEST_ASSERT((v1 - v2).norm() < (eps), message << " (distance: " << (v1 - v2).norm() << ")")
|
|
|
|
// ============================================================================
|
|
// 测试数据工厂
|
|
// ============================================================================
|
|
|
|
class TestDataFactory
|
|
{
|
|
public:
|
|
// ========== Profile 工厂 ==========
|
|
|
|
struct ProfileData {
|
|
std::vector<vector3d> points;
|
|
std::vector<double> bulges;
|
|
profile_descriptor_t descriptor;
|
|
|
|
void finalize()
|
|
{
|
|
descriptor.point_number = static_cast<uint32_t>(points.size());
|
|
descriptor.points = points.data();
|
|
descriptor.bulge_number = static_cast<uint32_t>(bulges.size());
|
|
descriptor.bulges = bulges.data();
|
|
descriptor.is_close = true;
|
|
descriptor.reference_normal = {0, 0, 1};
|
|
}
|
|
};
|
|
|
|
// 正方形 (CW winding)
|
|
static ProfileData createSquareProfile(double size = 1.0)
|
|
{
|
|
ProfileData data;
|
|
double half = size / 2.0;
|
|
|
|
// CW winding: bottom-left → top-left → top-right → bottom-right
|
|
data.points = {
|
|
{-half, -half, 0.0},
|
|
{-half, half, 0.0},
|
|
{half, half, 0.0},
|
|
{half, -half, 0.0}
|
|
};
|
|
data.bulges = {0.0, 0.0, 0.0, 0.0};
|
|
data.finalize();
|
|
|
|
return data;
|
|
}
|
|
|
|
// 圆形（两个半圆弧）
|
|
static ProfileData createCircleProfile(double radius = 0.5)
|
|
{
|
|
ProfileData data;
|
|
|
|
data.points = {
|
|
{radius, 0.0, 0.0},
|
|
{-radius, 0.0, 0.0}
|
|
};
|
|
// CW 弧：弧段1 (r,0)→(-r,0)，bulge=+1 → d=(0,-r)，弧经底部，CW ✓
|
|
// 弧段2 (-r,0)→(r,0)，bulge=+1 → d=(0,+r)，弧经顶部，CW ✓
|
|
data.bulges = {1.0, 1.0};
|
|
data.finalize();
|
|
|
|
return data;
|
|
}
|
|
|
|
// 矩形
|
|
static ProfileData createRectangleProfile(double width, double height)
|
|
{
|
|
ProfileData data;
|
|
double half_w = width / 2.0;
|
|
double half_h = height / 2.0;
|
|
|
|
// CW winding
|
|
data.points = {
|
|
{-half_w, -half_h, 0.0},
|
|
{-half_w, half_h, 0.0},
|
|
{half_w, half_h, 0.0},
|
|
{half_w, -half_h, 0.0}
|
|
};
|
|
data.bulges = {0.0, 0.0, 0.0, 0.0};
|
|
data.finalize();
|
|
|
|
return data;
|
|
}
|
|
|
|
// 三角形
|
|
static ProfileData createTriangleProfile(double size = 1.0)
|
|
{
|
|
ProfileData data;
|
|
double half = size / 2.0;
|
|
double h = size * std::sqrt(3.0) / 2.0;
|
|
|
|
// CW winding: reverse vertex order
|
|
data.points = {
|
|
{0, 2 * h / 3, 0.0},
|
|
{half, -h / 3, 0.0},
|
|
{-half, -h / 3, 0.0}
|
|
};
|
|
data.bulges = {0.0, 0.0, 0.0};
|
|
data.finalize();
|
|
|
|
return data;
|
|
}
|
|
|
|
// L形（非凸）
|
|
static ProfileData createLShapeProfile(double size = 1.0)
|
|
{
|
|
ProfileData data;
|
|
double s = size;
|
|
double half = size / 2.0;
|
|
|
|
// CW winding: reverse vertex order
|
|
data.points = {
|
|
{0, s, 0.0},
|
|
{half, s, 0.0},
|
|
{half, half, 0.0},
|
|
{s, half, 0.0},
|
|
{s, 0, 0.0},
|
|
{0, 0, 0.0}
|
|
};
|
|
data.bulges = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
|
|
data.finalize();
|
|
|
|
return data;
|
|
}
|
|
|
|
// ========== Axis 工厂 ==========
|
|
|
|
struct AxisData {
|
|
std::vector<vector3d> points;
|
|
std::vector<double> bulges;
|
|
axis_descriptor_t descriptor;
|
|
|
|
void finalizeAsPolyline(const vector3d& ref_normal = {1, 0, 0})
|
|
{
|
|
descriptor.type = AXIS_TYPE_POLYLINE;
|
|
descriptor.data.polyline.point_number = static_cast<uint32_t>(points.size());
|
|
descriptor.data.polyline.points = points.data();
|
|
descriptor.data.polyline.bulge_number = static_cast<uint32_t>(bulges.size());
|
|
descriptor.data.polyline.bulges = bulges.data();
|
|
descriptor.data.polyline.is_close = false;
|
|
descriptor.data.polyline.reference_normal = ref_normal;
|
|
}
|
|
};
|
|
|
|
// 直线Axis（Z方向）
|
|
static AxisData createStraightAxis(double length = 2.0)
|
|
{
|
|
AxisData data;
|
|
|
|
data.points = {
|
|
{0, 0, 0 },
|
|
{0, 0, length}
|
|
};
|
|
data.bulges = {0.0};
|
|
data.finalizeAsPolyline();
|
|
|
|
return data;
|
|
}
|
|
|
|
// 倾斜直线Axis
|
|
static AxisData createSlantedAxis(const Eigen::Vector3d& start, const Eigen::Vector3d& end)
|
|
{
|
|
AxisData data;
|
|
|
|
data.points = {
|
|
{start.x(), start.y(), start.z()},
|
|
{end.x(), end.y(), end.z() }
|
|
};
|
|
data.bulges = {0.0};
|
|
data.finalizeAsPolyline();
|
|
|
|
return data;
|
|
}
|
|
|
|
// 折线Axis（多段）
|
|
static AxisData createPolylineAxis(const std::vector<Eigen::Vector3d>& waypoints)
|
|
{
|
|
AxisData data;
|
|
|
|
for (const auto& pt : waypoints) { data.points.push_back({pt.x(), pt.y(), pt.z()}); }
|
|
|
|
data.bulges.resize(waypoints.size() - 1, 0.0);
|
|
data.finalizeAsPolyline();
|
|
|
|
return data;
|
|
}
|
|
|
|
// Z字形Axis
|
|
static AxisData createZigZagAxis(double segment_length = 1.0, int num_segments = 3)
|
|
{
|
|
AxisData data;
|
|
|
|
for (int i = 0; i <= num_segments; ++i) {
|
|
double x = (i % 2 == 0) ? 0.0 : 0.5;
|
|
double z = i * segment_length;
|
|
data.points.push_back({x, 0, z});
|
|
}
|
|
|
|
data.bulges.resize(num_segments, 0.0);
|
|
data.finalizeAsPolyline();
|
|
|
|
return data;
|
|
}
|
|
|
|
// Helixline Axis
|
|
static axis_descriptor_t createHelixlineAxis(double radius, double height, double turns = 2.0, bool is_righthanded = true)
|
|
{
|
|
axis_descriptor_t desc;
|
|
desc.type = AXIS_TYPE_HELIXLINE;
|
|
desc.data.helixline.axis_start = {0, 0, 0};
|
|
desc.data.helixline.axis_end = {0, 0, height};
|
|
desc.data.helixline.start_direction = {radius, 0, 0};
|
|
desc.data.helixline.radius = radius;
|
|
desc.data.helixline.advance_per_round = height / turns; // 螺距
|
|
desc.data.helixline.is_righthanded = is_righthanded;
|
|
|
|
return desc;
|
|
}
|
|
};
|
|
|
|
// ============================================================================
|
|
// 测试辅助工具
|
|
// ============================================================================
|
|
|
|
class TestHelper
|
|
{
|
|
public:
|
|
/**
|
|
* @brief 安全销毁 primitive
|
|
* @param ptr primitive 指针
|
|
*/
|
|
static void safeFree(primitive* ptr)
|
|
{
|
|
if (!ptr) return;
|
|
ptr->destroy();
|
|
mi_free(ptr);
|
|
}
|
|
|
|
// 验证AABB
|
|
static bool verifyAABB(const aabb_t& aabb,
|
|
const Eigen::Vector3d& expected_min,
|
|
const Eigen::Vector3d& expected_max,
|
|
double tolerance = 1e-5)
|
|
{
|
|
bool min_ok = (aabb.min() - expected_min).norm() < tolerance;
|
|
bool max_ok = (aabb.max() - expected_max).norm() < tolerance;
|
|
|
|
if (!min_ok || !max_ok) {
|
|
std::cout << " AABB mismatch:\n";
|
|
std::cout << " Expected min: " << expected_min.transpose() << "\n";
|
|
std::cout << " Actual min: " << aabb.min().transpose() << "\n";
|
|
std::cout << " Expected max: " << expected_max.transpose() << "\n";
|
|
std::cout << " Actual max: " << aabb.max().transpose() << "\n";
|
|
}
|
|
|
|
return min_ok && max_ok;
|
|
}
|
|
|
|
// 验证SDF符号
|
|
static bool verifySDF(double sdf, const std::string& expected_region, double surface_tol = 1e-4)
|
|
{
|
|
if (expected_region == "inside") return sdf < surface_tol;
|
|
if (expected_region == "outside") return sdf > -surface_tol;
|
|
if (expected_region == "surface") return std::abs(sdf) < surface_tol;
|
|
return false;
|
|
}
|
|
|
|
// 打印统计信息
|
|
static void printStatistics(int passed, int total)
|
|
{
|
|
std::cout << "\n╔══════════════════════════════════════════╗\n";
|
|
std::cout << "║ TEST RESULTS SUMMARY ║\n";
|
|
std::cout << "╠══════════════════════════════════════════╣\n";
|
|
std::cout << "║ Total Tests: " << std::setw(4) << total << " ║\n";
|
|
std::cout << "║ Passed: " << std::setw(4) << passed << " ║\n";
|
|
std::cout << "║ Failed: " << std::setw(4) << (total - passed) << " ║\n";
|
|
std::cout << "║ Success Rate: " << std::fixed << std::setprecision(1) << std::setw(5) << (100.0 * passed / total)
|
|
<< "% ║\n";
|
|
std::cout << "╚══════════════════════════════════════════╝\n";
|
|
}
|
|
};
|
|
|
|
// ============================================================================
|
|
// 第1组：Polyline Geometry 基础测试
|
|
// ============================================================================
|
|
|
|
bool test_polyline_basic_shapes()
|
|
{
|
|
TEST_SECTION("Polyline Geometry - Basic Shapes Construction");
|
|
|
|
Eigen::Vector3d proj_x(1, 0, 0);
|
|
Eigen::Vector3d proj_y(0, 1, 0);
|
|
Eigen::Vector3d origin(0, 0, 0);
|
|
internal::aabb_t_dim<2> aabb;
|
|
|
|
// 测试1: 正方形
|
|
{
|
|
auto profile = TestDataFactory::createSquareProfile(1.0);
|
|
internal::polyline_geometry_data geom;
|
|
|
|
geom.build_as_profile(*reinterpret_cast<const polyline_descriptor_t*>(&profile.descriptor),
|
|
proj_x,
|
|
proj_y,
|
|
origin,
|
|
aabb);
|
|
|
|
TEST_ASSERT(geom.vertices.size() == 5, "Square: 5 vertices (closed)");
|
|
TEST_ASSERT(geom.start_indices.size() == 4, "Square: 4 segments");
|
|
}
|
|
|
|
// 测试2: 圆形
|
|
{
|
|
auto profile = TestDataFactory::createCircleProfile(0.5);
|
|
internal::polyline_geometry_data geom;
|
|
|
|
geom.build_as_profile(*reinterpret_cast<const polyline_descriptor_t*>(&profile.descriptor),
|
|
proj_x,
|
|
proj_y,
|
|
origin,
|
|
aabb);
|
|
|
|
TEST_ASSERT(geom.vertices.size() > 5, "Circle: multiple vertices");
|
|
}
|
|
|
|
// 测试3: 三角形
|
|
{
|
|
auto profile = TestDataFactory::createTriangleProfile(1.0);
|
|
internal::polyline_geometry_data geom;
|
|
|
|
geom.build_as_profile(*reinterpret_cast<const polyline_descriptor_t*>(&profile.descriptor),
|
|
proj_x,
|
|
proj_y,
|
|
origin,
|
|
aabb);
|
|
|
|
TEST_ASSERT(geom.vertices.size() == 4, "Triangle: 4 vertices (closed)");
|
|
TEST_ASSERT(geom.start_indices.size() == 3, "Triangle: 3 segments");
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool test_polyline_sdf_calculation()
|
|
{
|
|
TEST_SECTION("Polyline SDF - Distance Field Calculation");
|
|
|
|
auto profile = TestDataFactory::createSquareProfile(1.0);
|
|
internal::polyline_geometry_data geom;
|
|
|
|
Eigen::Vector3d proj_x(1, 0, 0);
|
|
Eigen::Vector3d proj_y(0, 1, 0);
|
|
Eigen::Vector3d origin(0, 0, 0);
|
|
internal::aabb_t_dim<2> aabb;
|
|
|
|
geom.build_as_profile(*reinterpret_cast<const polyline_descriptor_t*>(&profile.descriptor), proj_x, proj_y, origin, aabb);
|
|
|
|
// 测试点集合
|
|
struct TestPoint {
|
|
Eigen::Vector3d point;
|
|
std::string region;
|
|
};
|
|
|
|
std::vector<TestPoint> test_points = {
|
|
{{0, 0, 0}, "inside" },
|
|
{{0.5, 0, 0}, "surface"},
|
|
{{0, 0.5, 0}, "surface"},
|
|
{{-0.5, -0.5, 0}, "surface"},
|
|
{{0.7, 0, 0}, "outside"},
|
|
{{0, 0.3, 0}, "inside" }
|
|
};
|
|
|
|
int passed = 0;
|
|
for (const auto& tp : test_points) {
|
|
auto closest = geom.calculate_closest_param(tp.point);
|
|
bool is_outside = geom.pmc(tp.point.head<2>(), closest.first);
|
|
double sdf = is_outside ? std::abs(closest.second) : -std::abs(closest.second);
|
|
|
|
if (TestHelper::verifySDF(sdf, tp.region)) { passed++; }
|
|
}
|
|
|
|
TEST_ASSERT(passed >= static_cast<int>(test_points.size() * 0.80),
|
|
"At least 80% of SDF tests pass (" << passed << "/" << test_points.size() << ")");
|
|
|
|
return true;
|
|
}
|
|
|
|
bool test_polyline_closest_point()
|
|
{
|
|
TEST_SECTION("Polyline - Closest Point Projection");
|
|
|
|
auto profile = TestDataFactory::createSquareProfile(1.0);
|
|
internal::polyline_geometry_data geom;
|
|
|
|
Eigen::Vector3d proj_x(1, 0, 0);
|
|
Eigen::Vector3d proj_y(0, 1, 0);
|
|
Eigen::Vector3d origin(0, 0, 0);
|
|
internal::aabb_t_dim<2> aabb;
|
|
|
|
geom.build_as_profile(*reinterpret_cast<const polyline_descriptor_t*>(&profile.descriptor), proj_x, proj_y, origin, aabb);
|
|
|
|
// 测试不同位置的最近点投影
|
|
std::vector<Eigen::Vector3d> test_points = {
|
|
{0, 0, 0},
|
|
{1, 0, 0},
|
|
{0, 1, 0},
|
|
{-1, -1, 0}
|
|
};
|
|
|
|
for (const auto& pt : test_points) {
|
|
auto result = geom.calculate_closest_param(pt);
|
|
TEST_ASSERT(result.first.point.allFinite(), "Closest point computed for " << pt.transpose());
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// ============================================================================
|
|
// 第2组：Helixline Geometry 测试
|
|
// ============================================================================
|
|
|
|
bool test_helixline_construction()
|
|
{
|
|
TEST_SECTION("Helixline - Construction and Basic Properties");
|
|
|
|
auto axis_desc = TestDataFactory::createHelixlineAxis(1.0, 2.0, 2.0, true);
|
|
internal::helixline_geometry_data geom;
|
|
|
|
Eigen::Transform<double, 3, Eigen::AffineCompact, Eigen::DontAlign> transform;
|
|
aabb_t aabb;
|
|
|
|
geom.build_from_descriptor(axis_desc.data.helixline, transform, aabb);
|
|
|
|
TEST_APPROX_EQUAL(geom.radius, 1.0, 1e-6, "Helixline radius");
|
|
TEST_APPROX_EQUAL(geom.height, 2.0, 1e-6, "Helixline height");
|
|
TEST_APPROX_EQUAL(geom.total_theta, 4.0 * M_PI, 1e-5, "Total rotation (2 turns)");
|
|
TEST_ASSERT(axis_desc.data.helixline.is_righthanded == true, "Right-handed descriptor flag");
|
|
|
|
return true;
|
|
}
|
|
|
|
bool test_helixline_tangent_normal()
|
|
{
|
|
TEST_SECTION("Helixline - Tangent and Normal Vectors");
|
|
|
|
auto axis_desc = TestDataFactory::createHelixlineAxis(1.0, 2.0, 1.0, true);
|
|
internal::helixline_geometry_data geom;
|
|
|
|
Eigen::Transform<double, 3, Eigen::AffineCompact, Eigen::DontAlign> transform;
|
|
aabb_t aabb;
|
|
|
|
geom.build_from_descriptor(axis_desc.data.helixline, transform, aabb);
|
|
|
|
// 测试多个参数位置
|
|
std::vector<double> test_params = {0.0, 0.25, 0.5, 0.75, 1.0};
|
|
|
|
for (double t : test_params) {
|
|
auto tangent = geom.calculate_tangent(t);
|
|
auto normal = geom.calculate_normal(t);
|
|
|
|
TEST_APPROX_EQUAL(tangent.norm(), 1.0, 1e-6, "Tangent normalized at t=" << t);
|
|
TEST_APPROX_EQUAL(normal.norm(), 1.0, 1e-6, "Normal normalized at t=" << t);
|
|
TEST_APPROX_EQUAL(tangent.dot(normal), 0.0, 1e-6, "Tangent ⊥ Normal at t=" << t);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool test_helixline_closest_point()
|
|
{
|
|
TEST_SECTION("Helixline - Closest Point Calculation");
|
|
|
|
auto axis_desc = TestDataFactory::createHelixlineAxis(1.0, 2.0, 1.0, true);
|
|
internal::helixline_geometry_data geom;
|
|
|
|
Eigen::Transform<double, 3, Eigen::AffineCompact, Eigen::DontAlign> transform;
|
|
aabb_t aabb;
|
|
|
|
geom.build_from_descriptor(axis_desc.data.helixline, transform, aabb);
|
|
|
|
// 测试轴上点
|
|
auto result1 = geom.calculate_closest_param(Eigen::Vector3d(0, 0, 1.0));
|
|
TEST_APPROX_EQUAL(result1.t, 0.5, 0.15, "Closest t for point on axis");
|
|
|
|
// 测试外部点
|
|
auto result2 = geom.calculate_closest_param(Eigen::Vector3d(2, 0, 1.0));
|
|
TEST_ASSERT(result2.point.norm() > 0, "Closest point calculated for external point");
|
|
|
|
return true;
|
|
}
|
|
|
|
bool test_helixline_left_vs_right()
|
|
{
|
|
TEST_SECTION("Helixline - Left-handed vs Right-handed");
|
|
|
|
auto right_desc = TestDataFactory::createHelixlineAxis(1.0, 2.0, 1.0, true);
|
|
auto left_desc = TestDataFactory::createHelixlineAxis(1.0, 2.0, 1.0, false);
|
|
|
|
// 验证descriptor中的标志
|
|
TEST_ASSERT(right_desc.data.helixline.is_righthanded == true, "Right-handed descriptor");
|
|
TEST_ASSERT(left_desc.data.helixline.is_righthanded == false, "Left-handed descriptor");
|
|
|
|
// 构建几何数据
|
|
internal::helixline_geometry_data right_geom, left_geom;
|
|
Eigen::Transform<double, 3, Eigen::AffineCompact, Eigen::DontAlign> transform;
|
|
aabb_t aabb;
|
|
|
|
right_geom.build_from_descriptor(right_desc.data.helixline, transform, aabb);
|
|
left_geom.build_from_descriptor(left_desc.data.helixline, transform, aabb);
|
|
|
|
// 两者的半径和高度应该相同
|
|
TEST_APPROX_EQUAL(right_geom.radius, left_geom.radius, 1e-6, "Same radius");
|
|
TEST_APPROX_EQUAL(right_geom.height, left_geom.height, 1e-6, "Same height");
|
|
|
|
return true;
|
|
}
|
|
|
|
// ============================================================================
|
|
// 第3组：Extrude 创建和初始化测试
|
|
// ============================================================================
|
|
|
|
bool test_extrude_polyline_creation()
|
|
{
|
|
TEST_SECTION("Extrude Polyline - Basic Creation");
|
|
|
|
primitive_data_center_t dc;
|
|
|
|
// ✅ 方案3：手动管理数据生命周期
|
|
std::vector<vector3d> profile_points = {
|
|
{-0.5, -0.5, 0.0},
|
|
{-0.5, 0.5, 0.0},
|
|
{0.5, 0.5, 0.0},
|
|
{0.5, -0.5, 0.0}
|
|
};
|
|
std::vector<double> profile_bulges = {0.0, 0.0, 0.0, 0.0};
|
|
|
|
profile_descriptor_t profile;
|
|
profile.point_number = 4;
|
|
profile.points = profile_points.data(); // ✅ 指向局部vector
|
|
profile.bulge_number = 4;
|
|
profile.bulges = profile_bulges.data();
|
|
profile.is_close = true;
|
|
profile.reference_normal = {0, 0, 1};
|
|
|
|
std::vector<vector3d> axis_points = {
|
|
{0, 0, 0},
|
|
{0, 0, 2}
|
|
};
|
|
std::vector<double> axis_bulges = {0.0};
|
|
|
|
axis_descriptor_t axis;
|
|
axis.type = AXIS_TYPE_POLYLINE;
|
|
axis.data.polyline.point_number = 2;
|
|
axis.data.polyline.points = axis_points.data(); // ✅ 指向局部vector
|
|
axis.data.polyline.bulge_number = 1;
|
|
axis.data.polyline.bulges = axis_bulges.data();
|
|
axis.data.polyline.is_close = false;
|
|
axis.data.polyline.reference_normal = {1, 0, 0};
|
|
|
|
auto* extrude = internal::new_primitive(PRIMITIVE_TYPE_EXTRUDE_POLYLINE, &dc);
|
|
auto* ext_poly = static_cast<internal::extrude_polyline_t*>(extrude);
|
|
|
|
extrude_polyline_descriptor_t desc;
|
|
desc.profile_number = 1;
|
|
desc.profiles = const_cast<polyline_descriptor_t*>(reinterpret_cast<const polyline_descriptor_t*>(&profile));
|
|
desc.axis = axis.data.polyline;
|
|
ext_poly->initialize_with_components(&dc, desc);
|
|
|
|
auto subfaces = ext_poly->get_subfaces();
|
|
TEST_ASSERT(subfaces.size() == 3, "Extrude has 3 subfaces");
|
|
TEST_ASSERT(subfaces[0].get_ptr() != nullptr, "Side face exists");
|
|
TEST_ASSERT(subfaces[1].get_ptr() != nullptr, "Bottom cap exists");
|
|
TEST_ASSERT(subfaces[2].get_ptr() != nullptr, "Top cap exists");
|
|
|
|
TestHelper::safeFree(extrude);
|
|
return true;
|
|
}
|
|
|
|
bool test_extrude_helixline_creation()
|
|
{
|
|
TEST_SECTION("Extrude Helixline - Basic Creation");
|
|
|
|
primitive_data_center_t dc;
|
|
|
|
auto profile = TestDataFactory::createSquareProfile(0.5);
|
|
auto axis = TestDataFactory::createHelixlineAxis(1.0, 2.0, 2.0, true);
|
|
|
|
// 构建完整的 extrude_helixline_descriptor_t
|
|
extrude_helixline_descriptor_t helix_desc;
|
|
helix_desc.profile_number = 1;
|
|
helix_desc.profiles =
|
|
const_cast<polyline_descriptor_t*>(reinterpret_cast<const polyline_descriptor_t*>(&profile.descriptor));
|
|
helix_desc.axis = axis.data.helixline;
|
|
|
|
auto* extrude = internal::new_primitive(PRIMITIVE_TYPE_EXTRUDE_HELIXLINE, &dc);
|
|
auto* ext_helix = static_cast<internal::extrude_helixline_t*>(extrude);
|
|
|
|
ext_helix->initialize_with_components(&dc, helix_desc);
|
|
|
|
auto subfaces = ext_helix->get_subfaces();
|
|
TEST_ASSERT(subfaces.size() == 3, "Helixline extrude has 3 subfaces");
|
|
|
|
TestHelper::safeFree(extrude);
|
|
return true;
|
|
}
|
|
|
|
bool test_extrude_aabb_computation()
|
|
{
|
|
TEST_SECTION("Extrude - AABB Computation Correctness");
|
|
|
|
primitive_data_center_t dc;
|
|
|
|
// 测试不同尺寸组合
|
|
struct AABBTest {
|
|
double profile_size;
|
|
double axis_length;
|
|
Eigen::Vector3d expected_min;
|
|
Eigen::Vector3d expected_max;
|
|
};
|
|
|
|
std::vector<AABBTest> tests = {
|
|
{1.0, 2.0, {-0.5, -0.5, -0.5}, {0.5, 0.5, 2.5}},
|
|
{2.0, 1.0, {-1.0, -1.0, -1.0}, {1.0, 1.0, 2.0}}
|
|
};
|
|
|
|
for (const auto& test : tests) {
|
|
auto profile = TestDataFactory::createSquareProfile(test.profile_size);
|
|
auto axis = TestDataFactory::createStraightAxis(test.axis_length);
|
|
|
|
auto* extrude = internal::new_primitive(PRIMITIVE_TYPE_EXTRUDE_POLYLINE, &dc);
|
|
auto* ext_poly = static_cast<internal::extrude_polyline_t*>(extrude);
|
|
|
|
extrude_polyline_descriptor_t desc;
|
|
desc.profile_number = 1;
|
|
desc.profiles = const_cast<polyline_descriptor_t*>(reinterpret_cast<const polyline_descriptor_t*>(&profile.descriptor));
|
|
desc.axis = axis.descriptor.data.polyline;
|
|
ext_poly->initialize_with_components(&dc, desc);
|
|
|
|
auto aabb = ext_poly->fetch_aabb();
|
|
|
|
bool ok = TestHelper::verifyAABB(aabb, test.expected_min, test.expected_max, 0.02);
|
|
TEST_ASSERT(ok, "AABB correct for profile=" << test.profile_size);
|
|
|
|
TestHelper::safeFree(extrude);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool test_extrude_descriptor_sharing()
|
|
{
|
|
TEST_SECTION("Extrude - Descriptor Sharing");
|
|
|
|
primitive_data_center_t dc;
|
|
|
|
auto profile = TestDataFactory::createSquareProfile(1.0);
|
|
auto axis = TestDataFactory::createStraightAxis(2.0);
|
|
|
|
// 创建两个使用相同descriptor的extrude
|
|
auto* extrude1 = internal::new_primitive(PRIMITIVE_TYPE_EXTRUDE_POLYLINE, &dc);
|
|
auto* ext1 = static_cast<internal::extrude_polyline_t*>(extrude1);
|
|
extrude_polyline_descriptor_t desc;
|
|
desc.profile_number = 1;
|
|
desc.profiles = const_cast<polyline_descriptor_t*>(reinterpret_cast<const polyline_descriptor_t*>(&profile.descriptor));
|
|
desc.axis = axis.descriptor.data.polyline;
|
|
ext1->initialize_with_components(&dc, desc);
|
|
|
|
auto* extrude2 = internal::new_primitive(PRIMITIVE_TYPE_EXTRUDE_POLYLINE, &dc);
|
|
auto* ext2 = static_cast<internal::extrude_polyline_t*>(extrude2);
|
|
ext2->initialize_with_components(&dc, desc);
|
|
|
|
auto subfaces1 = ext1->get_subfaces();
|
|
auto subfaces2 = ext2->get_subfaces();
|
|
|
|
auto* side1 = static_cast<internal::extrude_polyline_side_face_t*>(subfaces1[0].get_ptr());
|
|
auto* side2 = static_cast<internal::extrude_polyline_side_face_t*>(subfaces2[0].get_ptr());
|
|
|
|
TEST_ASSERT(side1->geometry_ptr == side2->geometry_ptr, "Same geometry params are shared");
|
|
|
|
TestHelper::safeFree(extrude1);
|
|
TestHelper::safeFree(extrude2);
|
|
|
|
return true;
|
|
}
|
|
|
|
bool test_extrude_various_profiles()
|
|
{
|
|
TEST_SECTION("Extrude - Various Profile Shapes");
|
|
|
|
primitive_data_center_t dc;
|
|
|
|
// 在外部作用域创建所有ProfileData
|
|
auto square_data = TestDataFactory::createSquareProfile();
|
|
auto circle_data = TestDataFactory::createCircleProfile(0.5);
|
|
auto triangle_data = TestDataFactory::createTriangleProfile();
|
|
auto axis_data = TestDataFactory::createStraightAxis(2.0);
|
|
|
|
// Test 1: Square
|
|
{
|
|
auto* extrude =
|
|
static_cast<internal::extrude_polyline_t*>(internal::new_primitive(PRIMITIVE_TYPE_EXTRUDE_POLYLINE, &dc));
|
|
|
|
extrude_polyline_descriptor_t square_desc;
|
|
square_desc.profile_number = 1;
|
|
square_desc.profiles =
|
|
const_cast<polyline_descriptor_t*>(reinterpret_cast<const polyline_descriptor_t*>(&square_data.descriptor));
|
|
square_desc.axis = axis_data.descriptor.data.polyline;
|
|
extrude->initialize_with_components(&dc, square_desc);
|
|
|
|
auto aabb = extrude->fetch_aabb();
|
|
TEST_ASSERT(aabb.min().x() >= -0.6 && aabb.max().x() <= 0.6, "Square profile creates valid AABB");
|
|
|
|
extrude->destroy();
|
|
mi_free(extrude);
|
|
}
|
|
|
|
// Test 2: Circle
|
|
{
|
|
auto* extrude =
|
|
static_cast<internal::extrude_polyline_t*>(internal::new_primitive(PRIMITIVE_TYPE_EXTRUDE_POLYLINE, &dc));
|
|
|
|
extrude_polyline_descriptor_t circle_desc;
|
|
circle_desc.profile_number = 1;
|
|
circle_desc.profiles =
|
|
const_cast<polyline_descriptor_t*>(reinterpret_cast<const polyline_descriptor_t*>(&circle_data.descriptor));
|
|
circle_desc.axis = axis_data.descriptor.data.polyline;
|
|
extrude->initialize_with_components(&dc, circle_desc);
|
|
|
|
auto aabb = extrude->fetch_aabb();
|
|
TEST_ASSERT(aabb.min().x() >= -0.6 && aabb.max().x() <= 0.6, "Circle profile creates valid AABB");
|
|
|
|
extrude->destroy();
|
|
mi_free(extrude);
|
|
}
|
|
|
|
// Test 3: Triangle
|
|
{
|
|
auto* extrude =
|
|
static_cast<internal::extrude_polyline_t*>(internal::new_primitive(PRIMITIVE_TYPE_EXTRUDE_POLYLINE, &dc));
|
|
|
|
extrude_polyline_descriptor_t triangle_desc;
|
|
triangle_desc.profile_number = 1;
|
|
triangle_desc.profiles =
|
|
const_cast<polyline_descriptor_t*>(reinterpret_cast<const polyline_descriptor_t*>(&triangle_data.descriptor));
|
|
triangle_desc.axis = axis_data.descriptor.data.polyline;
|
|
extrude->initialize_with_components(&dc, triangle_desc);
|
|
|
|
auto aabb = extrude->fetch_aabb();
|
|
TEST_ASSERT(aabb.min().x() >= -0.6 && aabb.max().x() <= 0.6, "Triangle profile creates valid AABB");
|
|
|
|
extrude->destroy();
|
|
mi_free(extrude);
|
|
}
|
|
|
|
// 所有ProfileData在这里才析构
|
|
return true;
|
|
}
|
|
|
|
// ============================================================================
|
|
// 第4组：SDF 和参数化测试
|
|
// ============================================================================
|
|
|
|
bool test_extrude_sdf_basic()
|
|
{
|
|
TEST_SECTION("Extrude SDF - Basic Distance Tests");
|
|
|
|
primitive_data_center_t dc;
|
|
|
|
auto profile = TestDataFactory::createSquareProfile(1.0);
|
|
auto axis = TestDataFactory::createStraightAxis(2.0);
|
|
|
|
auto* extrude = internal::new_primitive(PRIMITIVE_TYPE_EXTRUDE_POLYLINE, &dc);
|
|
auto* ext_poly = static_cast<internal::extrude_polyline_t*>(extrude);
|
|
extrude_polyline_descriptor_t desc;
|
|
desc.profile_number = 1;
|
|
desc.profiles = const_cast<polyline_descriptor_t*>(reinterpret_cast<const polyline_descriptor_t*>(&profile.descriptor));
|
|
desc.axis = axis.descriptor.data.polyline;
|
|
ext_poly->initialize_with_components(&dc, desc);
|
|
|
|
auto subfaces = ext_poly->get_subfaces();
|
|
auto* side_face = subfaces[0].get_ptr();
|
|
auto side_type = ext_poly->get_subface_types()[0];
|
|
|
|
auto eval_sdf = internal::get_eval_sdf_ptr(side_type);
|
|
|
|
// 基础测试点
|
|
struct SDFTest {
|
|
Eigen::Vector3d point;
|
|
std::string region;
|
|
};
|
|
|
|
std::vector<SDFTest> tests = {
|
|
{{0, 0, 1.0}, "inside" },
|
|
{{0.5, 0, 1.0}, "surface"},
|
|
{{1.0, 0, 1.0}, "outside"}
|
|
};
|
|
|
|
int passed = 0;
|
|
for (const auto& test : tests) {
|
|
double sdf = eval_sdf(make_pointer_wrapper(static_cast<subface*>(side_face)), test.point);
|
|
|
|
if (TestHelper::verifySDF(sdf, test.region, 0.1)) { passed++; }
|
|
}
|
|
|
|
TEST_ASSERT(passed >= 2, "Most SDF tests pass (" << passed << "/" << tests.size() << ")");
|
|
|
|
TestHelper::safeFree(extrude);
|
|
return true;
|
|
}
|
|
|
|
bool test_extrude_parametrization()
|
|
{
|
|
TEST_SECTION("Extrude Parametrization - Basic Tests");
|
|
|
|
primitive_data_center_t dc;
|
|
|
|
auto profile = TestDataFactory::createSquareProfile(1.0);
|
|
auto axis = TestDataFactory::createStraightAxis(2.0);
|
|
|
|
auto* extrude = internal::new_primitive(PRIMITIVE_TYPE_EXTRUDE_POLYLINE, &dc);
|
|
auto* ext_poly = static_cast<internal::extrude_polyline_t*>(extrude);
|
|
extrude_polyline_descriptor_t desc;
|
|
desc.profile_number = 1;
|
|
desc.profiles = const_cast<polyline_descriptor_t*>(reinterpret_cast<const polyline_descriptor_t*>(&profile.descriptor));
|
|
desc.axis = axis.descriptor.data.polyline;
|
|
ext_poly->initialize_with_components(&dc, desc);
|
|
|
|
auto subfaces = ext_poly->get_subfaces();
|
|
auto* side_face = subfaces[0].get_ptr();
|
|
auto side_type = ext_poly->get_subface_types()[0];
|
|
|
|
auto map_param_to_point_with_weight = internal::get_map_param_to_point_with_weight_ptr(side_type);
|
|
|
|
// 测试几个参数点
|
|
std::vector<Eigen::Vector2d> test_params = {
|
|
{0.0, 0.0},
|
|
{0.5, 0.5},
|
|
{1.0, 0.5}
|
|
};
|
|
|
|
for (const auto& uv : test_params) {
|
|
// 使用结构化绑定提取返回值
|
|
auto [point, surface_jacobi, volume_jacobi] =
|
|
map_param_to_point_with_weight(make_pointer_wrapper(static_cast<subface*>(side_face)), uv);
|
|
TEST_ASSERT(point.head<3>().allFinite(), "Valid point at uv=" << uv.transpose());
|
|
}
|
|
|
|
TestHelper::safeFree(extrude);
|
|
return true;
|
|
}
|
|
|
|
// ============================================================================
|
|
// 第5组：Transform 测试
|
|
// ============================================================================
|
|
|
|
bool test_extrude_transform_scale()
|
|
{
|
|
TEST_SECTION("Extrude Transform - Scale");
|
|
|
|
primitive_data_center_t dc;
|
|
|
|
auto profile = TestDataFactory::createSquareProfile(1.0);
|
|
auto axis = TestDataFactory::createStraightAxis(2.0);
|
|
|
|
auto* extrude = internal::new_primitive(PRIMITIVE_TYPE_EXTRUDE_POLYLINE, &dc);
|
|
auto* ext_poly = static_cast<internal::extrude_polyline_t*>(extrude);
|
|
extrude_polyline_descriptor_t desc;
|
|
desc.profile_number = 1;
|
|
desc.profiles = const_cast<polyline_descriptor_t*>(reinterpret_cast<const polyline_descriptor_t*>(&profile.descriptor));
|
|
desc.axis = axis.descriptor.data.polyline;
|
|
ext_poly->initialize_with_components(&dc, desc);
|
|
|
|
auto orig_aabb = ext_poly->fetch_aabb();
|
|
|
|
// 应用缩放
|
|
ext_poly->apply_transform(internal::transform_type::scale, Eigen::Vector4d(2, 2, 3, 0));
|
|
|
|
auto scaled_aabb = ext_poly->fetch_aabb();
|
|
auto orig_size = orig_aabb.sizes();
|
|
auto scaled_size = scaled_aabb.sizes();
|
|
|
|
TEST_APPROX_EQUAL(scaled_size.x(), orig_size.x() * 2, 0.05, "X scaled correctly");
|
|
TEST_APPROX_EQUAL(scaled_size.y(), orig_size.y() * 2, 0.05, "Y scaled correctly");
|
|
TEST_APPROX_EQUAL(scaled_size.z(), orig_size.z() * 3, 0.05, "Z scaled correctly");
|
|
|
|
TestHelper::safeFree(extrude);
|
|
return true;
|
|
}
|
|
|
|
bool test_extrude_transform_translation()
|
|
{
|
|
TEST_SECTION("Extrude Transform - Translation");
|
|
|
|
primitive_data_center_t dc;
|
|
auto profile = TestDataFactory::createSquareProfile(1.0);
|
|
auto axis = TestDataFactory::createStraightAxis(2.0);
|
|
|
|
auto* extrude = internal::new_primitive(PRIMITIVE_TYPE_EXTRUDE_POLYLINE, &dc);
|
|
auto* ext_poly = static_cast<internal::extrude_polyline_t*>(extrude);
|
|
extrude_polyline_descriptor_t desc;
|
|
desc.profile_number = 1;
|
|
desc.profiles = const_cast<polyline_descriptor_t*>(reinterpret_cast<const polyline_descriptor_t*>(&profile.descriptor));
|
|
desc.axis = axis.descriptor.data.polyline;
|
|
ext_poly->initialize_with_components(&dc, desc);
|
|
|
|
// 获取并立即缓存
|
|
auto orig_aabb = ext_poly->fetch_aabb();
|
|
Eigen::Vector3d orig_min = orig_aabb.min();
|
|
Eigen::Vector3d orig_max = orig_aabb.max();
|
|
|
|
// 应用平移
|
|
Eigen::Vector3d translation(1.0, 2.0, 3.0);
|
|
ext_poly->apply_transform(internal::transform_type::translation,
|
|
Eigen::Vector4d(translation.x(), translation.y(), translation.z(), 0));
|
|
|
|
auto translated_aabb = ext_poly->fetch_aabb();
|
|
Eigen::Vector3d trans_min = translated_aabb.min();
|
|
Eigen::Vector3d trans_max = translated_aabb.max();
|
|
|
|
// 计算期望值
|
|
Eigen::Vector3d expected_min = orig_min + translation;
|
|
Eigen::Vector3d expected_max = orig_max + translation;
|
|
|
|
// 使用缓存的值测试
|
|
TEST_VECTOR_APPROX_EQUAL(trans_min, expected_min, 0.05, "AABB min translated correctly");
|
|
TEST_VECTOR_APPROX_EQUAL(trans_max, expected_max, 0.05, "AABB max translated correctly");
|
|
|
|
TestHelper::safeFree(extrude);
|
|
return true;
|
|
}
|
|
|
|
// ============================================================================
|
|
// 第6组：Replace Profile/Axis 测试
|
|
// ============================================================================
|
|
|
|
bool test_replace_profile()
|
|
{
|
|
TEST_SECTION("Replace Profile - Functionality");
|
|
|
|
primitive_data_center_t dc;
|
|
|
|
auto profile1 = TestDataFactory::createSquareProfile(1.0);
|
|
auto axis = TestDataFactory::createStraightAxis(2.0);
|
|
|
|
auto* extrude = internal::new_primitive(PRIMITIVE_TYPE_EXTRUDE_POLYLINE, &dc);
|
|
auto* ext_poly = static_cast<internal::extrude_polyline_t*>(extrude);
|
|
extrude_polyline_descriptor_t desc;
|
|
desc.profile_number = 1;
|
|
desc.profiles = const_cast<polyline_descriptor_t*>(reinterpret_cast<const polyline_descriptor_t*>(&profile1.descriptor));
|
|
desc.axis = axis.descriptor.data.polyline;
|
|
ext_poly->initialize_with_components(&dc, desc);
|
|
|
|
auto orig_aabb = ext_poly->fetch_aabb();
|
|
|
|
// 替换为更大的profile
|
|
std::cout << "[try to replace profile]" << std::endl;
|
|
auto profile2 = TestDataFactory::createSquareProfile(2.0);
|
|
ext_poly->replace_profile(profile2.descriptor);
|
|
|
|
auto new_aabb = ext_poly->fetch_aabb();
|
|
|
|
TEST_ASSERT(new_aabb.sizes().x() > orig_aabb.sizes().x(), "Width increased after profile replacement");
|
|
|
|
TestHelper::safeFree(extrude);
|
|
return true;
|
|
}
|
|
|
|
bool test_replace_axis()
|
|
{
|
|
TEST_SECTION("Replace Axis - Functionality");
|
|
|
|
primitive_data_center_t dc;
|
|
|
|
auto profile = TestDataFactory::createSquareProfile(1.0);
|
|
auto axis1 = TestDataFactory::createStraightAxis(2.0);
|
|
|
|
auto* extrude = internal::new_primitive(PRIMITIVE_TYPE_EXTRUDE_POLYLINE, &dc);
|
|
auto* ext_poly = static_cast<internal::extrude_polyline_t*>(extrude);
|
|
extrude_polyline_descriptor_t desc;
|
|
desc.profile_number = 1;
|
|
desc.profiles = const_cast<polyline_descriptor_t*>(reinterpret_cast<const polyline_descriptor_t*>(&profile.descriptor));
|
|
desc.axis = axis1.descriptor.data.polyline;
|
|
ext_poly->initialize_with_components(&dc, desc);
|
|
|
|
auto orig_aabb = ext_poly->fetch_aabb();
|
|
|
|
// 替换为更长的axis
|
|
auto axis2 = TestDataFactory::createStraightAxis(4.0);
|
|
ext_poly->replace_axis(axis2.descriptor);
|
|
|
|
auto new_aabb = ext_poly->fetch_aabb();
|
|
|
|
TEST_ASSERT(new_aabb.sizes().z() > orig_aabb.sizes().z(), "Length increased after axis replacement");
|
|
|
|
TestHelper::safeFree(extrude);
|
|
return true;
|
|
}
|
|
|
|
// ============================================================================
|
|
// 第7组：边界条件测试
|
|
// ============================================================================
|
|
|
|
bool test_edge_cases_small_dimensions()
|
|
{
|
|
TEST_SECTION("Edge Cases - Small Dimensions");
|
|
|
|
primitive_data_center_t dc;
|
|
|
|
// 很小的profile
|
|
auto profile = TestDataFactory::createSquareProfile(0.1);
|
|
auto axis = TestDataFactory::createStraightAxis(1.0);
|
|
|
|
auto* extrude = internal::new_primitive(PRIMITIVE_TYPE_EXTRUDE_POLYLINE, &dc);
|
|
auto* ext_poly = static_cast<internal::extrude_polyline_t*>(extrude);
|
|
|
|
extrude_polyline_descriptor_t desc;
|
|
desc.profile_number = 1;
|
|
desc.profiles = const_cast<polyline_descriptor_t*>(reinterpret_cast<const polyline_descriptor_t*>(&profile.descriptor));
|
|
desc.axis = axis.descriptor.data.polyline;
|
|
ext_poly->initialize_with_components(&dc, desc);
|
|
|
|
auto aabb = ext_poly->fetch_aabb();
|
|
TEST_ASSERT(!aabb.isEmpty(), "Small profile creates valid extrude");
|
|
|
|
TestHelper::safeFree(extrude);
|
|
return true;
|
|
}
|
|
|
|
// ============================================================================
|
|
// 第8组：性能测试
|
|
// ============================================================================
|
|
|
|
bool test_performance_batch_creation()
|
|
{
|
|
TEST_SECTION("Performance - Batch Primitive Creation");
|
|
|
|
primitive_data_center_t dc;
|
|
|
|
auto profile = TestDataFactory::createSquareProfile(1.0);
|
|
auto axis = TestDataFactory::createStraightAxis(2.0);
|
|
|
|
const int num_primitives = 50;
|
|
std::vector<primitive*> primitives;
|
|
|
|
auto start = std::chrono::high_resolution_clock::now();
|
|
|
|
for (int i = 0; i < num_primitives; ++i) {
|
|
auto* extrude = internal::new_primitive(PRIMITIVE_TYPE_EXTRUDE_POLYLINE, &dc);
|
|
auto* ext_poly = static_cast<internal::extrude_polyline_t*>(extrude);
|
|
extrude_polyline_descriptor_t desc;
|
|
desc.profile_number = 1;
|
|
desc.profiles = const_cast<polyline_descriptor_t*>(reinterpret_cast<const polyline_descriptor_t*>(&profile.descriptor));
|
|
desc.axis = axis.descriptor.data.polyline;
|
|
ext_poly->initialize_with_components(&dc, desc);
|
|
primitives.push_back(extrude);
|
|
}
|
|
|
|
auto end = std::chrono::high_resolution_clock::now();
|
|
auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
|
|
|
|
TEST_ASSERT(duration.count() < 3000, "Creating " << num_primitives << " primitives in < 3s (" << duration.count() << "ms)");
|
|
|
|
// 清理
|
|
for (auto* p : primitives) { TestHelper::safeFree(p); }
|
|
|
|
return true;
|
|
}
|
|
|
|
// ============================================================================
|
|
// Phase 1.1: Subface Function Tests - Polyline
|
|
// ============================================================================
|
|
|
|
/**
|
|
* @brief 测试 Polyline 侧面的 SDF 计算
|
|
* @details 验证：
|
|
* 1. 内部点的 SDF < 0
|
|
* 2. 外部点的 SDF > 0
|
|
* 3. 边界点的 SDF ≈ 0
|
|
*/
|
|
bool test_polyline_eval_sdf_detailed()
|
|
{
|
|
TEST_SECTION("Polyline SDF Evaluation - Detailed");
|
|
|
|
primitive_data_center_t dc;
|
|
|
|
// 创建正方形 profile (1x1), 沿 Z 轴拉伸 2 单位
|
|
// CW 绕向: bottom-left → top-left → top-right → bottom-right
|
|
std::vector<vector3d> profile_points = {
|
|
{-0.5, -0.5, 0.0},
|
|
{-0.5, 0.5, 0.0},
|
|
{0.5, 0.5, 0.0},
|
|
{0.5, -0.5, 0.0}
|
|
};
|
|
std::vector<double> profile_bulges = {0.0, 0.0, 0.0, 0.0};
|
|
|
|
profile_descriptor_t profile;
|
|
profile.point_number = 4;
|
|
profile.points = profile_points.data();
|
|
profile.bulge_number = 4;
|
|
profile.bulges = profile_bulges.data();
|
|
profile.is_close = true;
|
|
profile.reference_normal = {0, 0, 1};
|
|
|
|
std::vector<vector3d> axis_points = {
|
|
{0, 0, 0},
|
|
{0, 0, 2}
|
|
};
|
|
std::vector<double> axis_bulges = {0.0};
|
|
|
|
axis_descriptor_t axis;
|
|
axis.type = AXIS_TYPE_POLYLINE;
|
|
axis.data.polyline.point_number = 2;
|
|
axis.data.polyline.points = axis_points.data();
|
|
axis.data.polyline.bulge_number = 1;
|
|
axis.data.polyline.bulges = axis_bulges.data();
|
|
axis.data.polyline.is_close = false;
|
|
axis.data.polyline.reference_normal = {1, 0, 0};
|
|
|
|
auto* extrude = internal::new_primitive(PRIMITIVE_TYPE_EXTRUDE_POLYLINE, &dc);
|
|
auto* ext_poly = static_cast<internal::extrude_polyline_t*>(extrude);
|
|
extrude_polyline_descriptor_t desc;
|
|
desc.profile_number = 1;
|
|
desc.profiles = const_cast<polyline_descriptor_t*>(reinterpret_cast<const polyline_descriptor_t*>(&profile));
|
|
desc.axis = axis.data.polyline;
|
|
ext_poly->initialize_with_components(&dc, desc);
|
|
|
|
auto* side_face = static_cast<internal::extrude_polyline_side_face_t*>(ext_poly->subfaces[0].get_ptr());
|
|
|
|
// 获取 eval_sdf 函数指针
|
|
auto eval_sdf_func = internal::get_eval_sdf_ptr(surface_type::extrude_polyline_side);
|
|
|
|
// 测试点 1: 内部点 (应该是负值)
|
|
Eigen::Vector3d inside_point(0.0, 0.0, 1.0); // 中心点
|
|
double sdf_inside = eval_sdf_func(make_pointer_wrapper(static_cast<subface*>(side_face)), inside_point);
|
|
TEST_ASSERT(sdf_inside < 0, "Inside point has negative SDF: " << sdf_inside);
|
|
|
|
// 测试点 2: 外部点 (应该是正值)
|
|
Eigen::Vector3d outside_point(1.0, 0.0, 1.0); // 距离表面 0.5 单位
|
|
double sdf_outside = eval_sdf_func(make_pointer_wrapper(static_cast<subface*>(side_face)), outside_point);
|
|
TEST_ASSERT(sdf_outside > 0, "Outside point has positive SDF: " << sdf_outside);
|
|
TEST_APPROX_EQUAL(sdf_outside, 0.5, 0.01, "Outside point SDF magnitude");
|
|
|
|
// 测试点 3: 边界点 (应该接近 0)
|
|
Eigen::Vector3d boundary_point(0.5, 0.0, 1.0); // 正方形边上
|
|
double sdf_boundary = eval_sdf_func(make_pointer_wrapper(static_cast<subface*>(side_face)), boundary_point);
|
|
TEST_APPROX_EQUAL(sdf_boundary, 0.0, 0.01, "Boundary point SDF close to zero");
|
|
|
|
// 测试点 4: 远离表面的点
|
|
Eigen::Vector3d far_point(5.0, 0.0, 1.0);
|
|
double sdf_far = eval_sdf_func(make_pointer_wrapper(static_cast<subface*>(side_face)), far_point);
|
|
TEST_ASSERT(sdf_far > 4.0, "Far point has large positive SDF: " << sdf_far);
|
|
|
|
TestHelper::safeFree(extrude);
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* @brief 测试 Polyline 侧面的 SDF 梯度计算
|
|
* @details 验证：
|
|
* 1. 梯度是单位向量
|
|
* 2. 梯度方向正确（指向外侧）
|
|
* 3. 数值稳定性
|
|
*/
|
|
bool test_polyline_eval_sdf_grad()
|
|
{
|
|
TEST_SECTION("Polyline SDF Gradient Evaluation");
|
|
|
|
primitive_data_center_t dc;
|
|
|
|
std::vector<vector3d> profile_points = {
|
|
{-0.5, -0.5, 0.0},
|
|
{-0.5, 0.5, 0.0},
|
|
{0.5, 0.5, 0.0},
|
|
{0.5, -0.5, 0.0}
|
|
};
|
|
std::vector<double> profile_bulges = {0.0, 0.0, 0.0, 0.0};
|
|
|
|
profile_descriptor_t profile;
|
|
profile.point_number = 4;
|
|
profile.points = profile_points.data();
|
|
profile.bulge_number = 4;
|
|
profile.bulges = profile_bulges.data();
|
|
profile.is_close = true;
|
|
profile.reference_normal = {0, 0, 1};
|
|
|
|
std::vector<vector3d> axis_points = {
|
|
{0, 0, 0},
|
|
{0, 0, 2}
|
|
};
|
|
std::vector<double> axis_bulges = {0.0};
|
|
|
|
axis_descriptor_t axis;
|
|
axis.type = AXIS_TYPE_POLYLINE;
|
|
axis.data.polyline.point_number = 2;
|
|
axis.data.polyline.points = axis_points.data();
|
|
axis.data.polyline.bulge_number = 1;
|
|
axis.data.polyline.bulges = axis_bulges.data();
|
|
axis.data.polyline.is_close = false;
|
|
axis.data.polyline.reference_normal = {1, 0, 0};
|
|
|
|
auto* extrude = internal::new_primitive(PRIMITIVE_TYPE_EXTRUDE_POLYLINE, &dc);
|
|
auto* ext_poly = static_cast<internal::extrude_polyline_t*>(extrude);
|
|
extrude_polyline_descriptor_t desc;
|
|
desc.profile_number = 1;
|
|
desc.profiles = const_cast<polyline_descriptor_t*>(reinterpret_cast<const polyline_descriptor_t*>(&profile));
|
|
desc.axis = axis.data.polyline;
|
|
ext_poly->initialize_with_components(&dc, desc);
|
|
|
|
auto* side_face = static_cast<internal::extrude_polyline_side_face_t*>(ext_poly->subfaces[0].get_ptr());
|
|
|
|
auto eval_sdf_grad_func = internal::get_eval_sdf_grad_ptr(surface_type::extrude_polyline_side);
|
|
|
|
// 测试点: 右侧外部
|
|
Eigen::Vector3d test_point(1.0, 0.0, 1.0);
|
|
Eigen::Vector3d gradient = eval_sdf_grad_func(make_pointer_wrapper(static_cast<subface*>(side_face)), test_point);
|
|
|
|
// 1. 梯度应该是单位向量
|
|
double grad_norm = gradient.norm();
|
|
TEST_APPROX_EQUAL(grad_norm, 1.0, 0.01, "Gradient is normalized");
|
|
|
|
// 2. 梯度应该指向 +X 方向（远离表面）
|
|
TEST_ASSERT(gradient.x() > 0.9, "Gradient points outward in X direction: " << gradient.transpose());
|
|
|
|
// 3. Y 和 Z 分量应该接近 0
|
|
TEST_APPROX_EQUAL(gradient.y(), 0.0, 0.1, "Gradient Y component near zero");
|
|
TEST_APPROX_EQUAL(gradient.z(), 0.0, 0.1, "Gradient Z component near zero");
|
|
|
|
TestHelper::safeFree(extrude);
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* @brief 测试参数化的往返转换
|
|
* @details 验证：
|
|
* map_point_to_param(map_param_to_point(u,v)) ≈ (u,v)
|
|
*/
|
|
bool test_polyline_map_param_roundtrip()
|
|
{
|
|
TEST_SECTION("Polyline Parametrization Round-Trip (FIXED)");
|
|
|
|
primitive_data_center_t dc;
|
|
|
|
// CW 绕向: bottom-left → top-left → top-right → bottom-right
|
|
std::vector<vector3d> profile_points = {
|
|
{-0.5, -0.5, 0.0},
|
|
{-0.5, 0.5, 0.0},
|
|
{0.5, 0.5, 0.0},
|
|
{0.5, -0.5, 0.0}
|
|
};
|
|
std::vector<double> profile_bulges = {0.0, 0.0, 0.0, 0.0};
|
|
|
|
profile_descriptor_t profile;
|
|
profile.point_number = 4;
|
|
profile.points = profile_points.data();
|
|
profile.bulge_number = 4;
|
|
profile.bulges = profile_bulges.data();
|
|
profile.is_close = true;
|
|
profile.reference_normal = {0, 0, 1};
|
|
|
|
std::vector<vector3d> axis_points = {
|
|
{0, 0, 0},
|
|
{0, 0, 2}
|
|
};
|
|
std::vector<double> axis_bulges = {0.0};
|
|
|
|
axis_descriptor_t axis;
|
|
axis.type = AXIS_TYPE_POLYLINE;
|
|
axis.data.polyline.point_number = 2;
|
|
axis.data.polyline.points = axis_points.data();
|
|
axis.data.polyline.bulge_number = 1;
|
|
axis.data.polyline.bulges = axis_bulges.data();
|
|
axis.data.polyline.is_close = false;
|
|
axis.data.polyline.reference_normal = {1, 0, 0};
|
|
|
|
auto* extrude = internal::new_primitive(PRIMITIVE_TYPE_EXTRUDE_POLYLINE, &dc);
|
|
auto* ext_poly = static_cast<internal::extrude_polyline_t*>(extrude);
|
|
extrude_polyline_descriptor_t desc;
|
|
desc.profile_number = 1;
|
|
desc.profiles = const_cast<polyline_descriptor_t*>(reinterpret_cast<const polyline_descriptor_t*>(&profile));
|
|
desc.axis = axis.data.polyline;
|
|
ext_poly->initialize_with_components(&dc, desc);
|
|
|
|
auto* side_face = static_cast<internal::extrude_polyline_side_face_t*>(ext_poly->subfaces[0].get_ptr());
|
|
|
|
auto map_param_to_point_with_weight_func =
|
|
internal::get_map_param_to_point_with_weight_ptr(surface_type::extrude_polyline_side);
|
|
auto map_point_to_param_func = internal::get_map_point_to_param_ptr(surface_type::extrude_polyline_side);
|
|
|
|
// 使用边上的点，避开顶点
|
|
std::vector<Eigen::Vector2d> test_params = {
|
|
{0.25, 0.0 }, // 第1段（左边 → 右边）25%处
|
|
{0.75, 0.25}, // 第1段 75%处，高度25%
|
|
{1.5, 0.5 }, // 第2段（下边 → 上边）50%处
|
|
{2.5, 0.75}, // 第3段（右边 → 左边）50%处
|
|
{3.5, 1.0 }, // 第4段（上边 → 下边）50%处
|
|
{0.1, 0.1 }, // 接近起点但不在顶点
|
|
};
|
|
|
|
std::cout << "\n[Round-Trip Test] Testing " << test_params.size() << " points:\n";
|
|
|
|
for (const auto& uv_original : test_params) {
|
|
// Step 1: (u,v) → Point
|
|
auto [point_4d, surface_jacobi, volume_jacobi] =
|
|
map_param_to_point_with_weight_func(make_pointer_wrapper(static_cast<subface*>(side_face)), uv_original);
|
|
Eigen::Vector3d point = point_4d.head<3>();
|
|
|
|
// Step 2: Point → (u',v')
|
|
Eigen::Vector2d uv_recovered = map_point_to_param_func(make_pointer_wrapper(static_cast<subface*>(side_face)), point);
|
|
|
|
// Step 3: (u',v') → Point'
|
|
auto [point_recovered_4d, surface_recovered_jacobi, volume_recovered_jacobi] =
|
|
map_param_to_point_with_weight_func(make_pointer_wrapper(static_cast<subface*>(side_face)), uv_recovered);
|
|
Eigen::Vector3d point_recovered = point_recovered_4d.head<3>();
|
|
|
|
// 比较点坐标，而不是参数
|
|
// 这样可以避免封闭曲线参数歧义的问题
|
|
double point_distance = (point - point_recovered).norm();
|
|
|
|
TEST_ASSERT(point_distance < 0.001,
|
|
"Point round-trip for (u,v) = " << uv_original.transpose() << " (point error: " << point_distance << ")");
|
|
}
|
|
|
|
TestHelper::safeFree(extrude);
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* @brief 测试约束曲线的一致性
|
|
* @details 验证：
|
|
* eval_du_constraint 是 map_param_to_point 对 u 的偏导数
|
|
*/
|
|
bool test_polyline_constraint_curves()
|
|
{
|
|
TEST_SECTION("Polyline Constraint Curve Consistency");
|
|
|
|
primitive_data_center_t dc;
|
|
|
|
std::vector<vector3d> profile_points = {
|
|
{-0.5, -0.5, 0.0},
|
|
{0.5, -0.5, 0.0},
|
|
{0.5, 0.5, 0.0},
|
|
{-0.5, 0.5, 0.0}
|
|
};
|
|
std::vector<double> profile_bulges = {0.0, 0.0, 0.0, 0.0};
|
|
|
|
profile_descriptor_t profile;
|
|
profile.point_number = 4;
|
|
profile.points = profile_points.data();
|
|
profile.bulge_number = 4;
|
|
profile.bulges = profile_bulges.data();
|
|
profile.is_close = true;
|
|
profile.reference_normal = {0, 0, 1};
|
|
|
|
std::vector<vector3d> axis_points = {
|
|
{0, 0, 0},
|
|
{0, 0, 2}
|
|
};
|
|
std::vector<double> axis_bulges = {0.0};
|
|
|
|
axis_descriptor_t axis;
|
|
axis.type = AXIS_TYPE_POLYLINE;
|
|
axis.data.polyline.point_number = 2;
|
|
axis.data.polyline.points = axis_points.data();
|
|
axis.data.polyline.bulge_number = 1;
|
|
axis.data.polyline.bulges = axis_bulges.data();
|
|
axis.data.polyline.is_close = false;
|
|
axis.data.polyline.reference_normal = {1, 0, 0};
|
|
|
|
auto* extrude = internal::new_primitive(PRIMITIVE_TYPE_EXTRUDE_POLYLINE, &dc);
|
|
auto* ext_poly = static_cast<internal::extrude_polyline_t*>(extrude);
|
|
extrude_polyline_descriptor_t desc;
|
|
desc.profile_number = 1;
|
|
desc.profiles = const_cast<polyline_descriptor_t*>(reinterpret_cast<const polyline_descriptor_t*>(&profile));
|
|
desc.axis = axis.data.polyline;
|
|
ext_poly->initialize_with_components(&dc, desc);
|
|
|
|
auto* side_face = static_cast<internal::extrude_polyline_side_face_t*>(ext_poly->subfaces[0].get_ptr());
|
|
|
|
auto map_param_to_point_with_weight_func =
|
|
internal::get_map_param_to_point_with_weight_ptr(surface_type::extrude_polyline_side);
|
|
auto eval_du_constraint_func = internal::get_eval_du_constraint_ptr(surface_type::extrude_polyline_side);
|
|
auto eval_dv_constraint_func = internal::get_eval_dv_constraint_ptr(surface_type::extrude_polyline_side);
|
|
|
|
Eigen::Vector2d uv(1.5, 0.5);
|
|
|
|
// 获取约束曲线结果
|
|
auto du_result = eval_du_constraint_func(make_pointer_wrapper(static_cast<subface*>(side_face)), uv);
|
|
auto dv_result = eval_dv_constraint_func(make_pointer_wrapper(static_cast<subface*>(side_face)), uv);
|
|
|
|
// 数值计算偏导数
|
|
constexpr double eps = 1e-6;
|
|
|
|
// 使用结构化绑定提取返回值
|
|
auto [f_center, center_surface_jacobi, center_volume_jacobi] =
|
|
map_param_to_point_with_weight_func(make_pointer_wrapper(static_cast<subface*>(side_face)), uv);
|
|
auto [f_u_plus, u_plus_surface_jacobi, u_plus_volume_jacobi] =
|
|
map_param_to_point_with_weight_func(make_pointer_wrapper(static_cast<subface*>(side_face)),
|
|
Eigen::Vector2d(uv.x() + eps, uv.y()));
|
|
auto [f_v_plus, v_plus_surface_jacobi, v_plus_volume_jacobi] =
|
|
map_param_to_point_with_weight_func(make_pointer_wrapper(static_cast<subface*>(side_face)),
|
|
Eigen::Vector2d(uv.x(), uv.y() + eps));
|
|
|
|
Eigen::Vector4d numerical_du = (f_u_plus - f_center) / eps;
|
|
Eigen::Vector4d numerical_dv = (f_v_plus - f_center) / eps;
|
|
|
|
// 验证一致性
|
|
TEST_VECTOR_APPROX_EQUAL(du_result.f, f_center, 1e-8, "du constraint returns correct point");
|
|
TEST_VECTOR_APPROX_EQUAL(du_result.grad_f, numerical_du, 0.01, "du constraint gradient matches numerical derivative");
|
|
|
|
TEST_VECTOR_APPROX_EQUAL(dv_result.f, f_center, 1e-8, "dv constraint returns correct point");
|
|
TEST_VECTOR_APPROX_EQUAL(dv_result.grad_f, numerical_dv, 0.01, "dv constraint gradient matches numerical derivative");
|
|
|
|
TestHelper::safeFree(extrude);
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* @brief 测试 geometry_accessor 函数
|
|
*/
|
|
bool test_polyline_geometry_accessor()
|
|
{
|
|
TEST_SECTION("Polyline Descriptor Accessor");
|
|
|
|
primitive_data_center_t dc;
|
|
|
|
std::vector<vector3d> profile_points = {
|
|
{-0.5, -0.5, 0.0},
|
|
{0.5, -0.5, 0.0},
|
|
{0.5, 0.5, 0.0},
|
|
{-0.5, 0.5, 0.0}
|
|
};
|
|
std::vector<double> profile_bulges = {0.0, 0.0, 0.0, 0.0};
|
|
|
|
profile_descriptor_t profile;
|
|
profile.point_number = 4;
|
|
profile.points = profile_points.data();
|
|
profile.bulge_number = 4;
|
|
profile.bulges = profile_bulges.data();
|
|
profile.is_close = true;
|
|
profile.reference_normal = {0, 0, 1};
|
|
|
|
std::vector<vector3d> axis_points = {
|
|
{0, 0, 0},
|
|
{0, 0, 2}
|
|
};
|
|
std::vector<double> axis_bulges = {0.0};
|
|
|
|
axis_descriptor_t axis;
|
|
axis.type = AXIS_TYPE_POLYLINE;
|
|
axis.data.polyline.point_number = 2;
|
|
axis.data.polyline.points = axis_points.data();
|
|
axis.data.polyline.bulge_number = 1;
|
|
axis.data.polyline.bulges = axis_bulges.data();
|
|
axis.data.polyline.is_close = false;
|
|
axis.data.polyline.reference_normal = {1, 0, 0};
|
|
|
|
auto* extrude = internal::new_primitive(PRIMITIVE_TYPE_EXTRUDE_POLYLINE, &dc);
|
|
auto* ext_poly = static_cast<internal::extrude_polyline_t*>(extrude);
|
|
extrude_polyline_descriptor_t desc;
|
|
desc.profile_number = 1;
|
|
desc.profiles = const_cast<polyline_descriptor_t*>(reinterpret_cast<const polyline_descriptor_t*>(&profile));
|
|
desc.axis = axis.data.polyline;
|
|
ext_poly->initialize_with_components(&dc, desc);
|
|
|
|
auto* side_face = static_cast<internal::extrude_polyline_side_face_t*>(ext_poly->subfaces[0].get_ptr());
|
|
|
|
auto geometry_accessor_func = internal::get_geometry_accessor_ptr(surface_type::extrude_polyline_side);
|
|
|
|
const void* desc_ptr = geometry_accessor_func(make_pointer_wrapper(static_cast<subface*>(side_face)));
|
|
|
|
TEST_ASSERT(desc_ptr != nullptr, "Descriptor accessor returns non-null pointer");
|
|
TEST_ASSERT(desc_ptr == side_face->get_geometry_ptr(), "Descriptor accessor returns correct pointer");
|
|
|
|
TestHelper::safeFree(extrude);
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* @brief 测试 subface_equal 函数
|
|
*/
|
|
/*
|
|
bool test_polyline_subface_equal()
|
|
{
|
|
TEST_SECTION("Polyline Subface Equality");
|
|
|
|
primitive_data_center_t dc;
|
|
|
|
std::vector<vector3d> profile_points = {
|
|
{-0.5, -0.5, 0.0},
|
|
{0.5, -0.5, 0.0},
|
|
{0.5, 0.5, 0.0},
|
|
{-0.5, 0.5, 0.0}
|
|
};
|
|
std::vector<double> profile_bulges = {0.0, 0.0, 0.0, 0.0};
|
|
|
|
profile_descriptor_t profile;
|
|
profile.point_number = 4;
|
|
profile.points = profile_points.data();
|
|
profile.bulge_number = 4;
|
|
profile.bulges = profile_bulges.data();
|
|
profile.is_close = true;
|
|
profile.reference_normal = {0, 0, 1};
|
|
|
|
std::vector<vector3d> axis_points = {
|
|
{0, 0, 0},
|
|
{0, 0, 2}
|
|
};
|
|
std::vector<double> axis_bulges = {0.0};
|
|
|
|
axis_descriptor_t axis;
|
|
axis.type = AXIS_TYPE_POLYLINE;
|
|
axis.data.polyline.point_number = 2;
|
|
axis.data.polyline.points = axis_points.data();
|
|
axis.data.polyline.bulge_number = 1;
|
|
axis.data.polyline.bulges = axis_bulges.data();
|
|
axis.data.polyline.is_close = false;
|
|
axis.data.polyline.reference_normal = {1, 0, 0};
|
|
|
|
// 创建两个相同的拉伸体
|
|
auto* extrude1 = internal::new_primitive(PRIMITIVE_TYPE_EXTRUDE_POLYLINE, &dc);
|
|
auto* ext_poly1 = static_cast<internal::extrude_polyline_t*>(extrude1);
|
|
ext_poly1->initialize_with_components(&dc, profile, axis);
|
|
|
|
auto* extrude2 = internal::new_primitive(PRIMITIVE_TYPE_EXTRUDE_POLYLINE, &dc);
|
|
auto* ext_poly2 = static_cast<internal::extrude_polyline_t*>(extrude2);
|
|
ext_poly2->initialize_with_components(&dc, profile, axis);
|
|
|
|
auto* side_face1 = static_cast<internal::extrude_polyline_side_face_t*>(ext_poly1->subfaces[0].get_ptr());
|
|
auto* side_face2 = static_cast<internal::extrude_polyline_side_face_t*>(ext_poly2->subfaces[0].get_ptr());
|
|
|
|
auto subface_equal_func = internal::get_subface_equal_ptr(surface_type::extrude_polyline_side);
|
|
|
|
// 两个相同的 subface 应该相等
|
|
bool are_equal = subface_equal_func(make_pointer_wrapper(static_cast<subface*>(side_face1)),
|
|
make_pointer_wrapper(static_cast<subface*>(side_face2)));
|
|
TEST_ASSERT(are_equal, "Identical subfaces are equal");
|
|
|
|
// 自身应该相等
|
|
bool self_equal = subface_equal_func(make_pointer_wrapper(static_cast<subface*>(side_face1)),
|
|
make_pointer_wrapper(static_cast<subface*>(side_face2)));
|
|
TEST_ASSERT(self_equal, "Subface equals itself");
|
|
|
|
TestHelper::safeFree(extrude1);
|
|
TestHelper::safeFree(extrude2);
|
|
return true;
|
|
}
|
|
*/
|
|
|
|
// ============================================================================
|
|
// Phase 1.2: Geometry Data Internal Tests
|
|
// ============================================================================
|
|
|
|
/**
|
|
* @brief 测试 PMC (Point-in-Polygon) 算法
|
|
* @details 验证点是否在 polyline 内部的判断
|
|
*/
|
|
bool test_polyline_pmc_inside_outside()
|
|
{
|
|
TEST_SECTION("Polyline PMC (Point-in-Polygon) - FIXED");
|
|
|
|
// 创建一个正方形 profile: [-1, 1] × [-1, 1]，CW 绕向
|
|
std::vector<vector3d> profile_points = {
|
|
{-1.0, -1.0, 0.0},
|
|
{-1.0, 1.0, 0.0},
|
|
{1.0, 1.0, 0.0},
|
|
{1.0, -1.0, 0.0}
|
|
};
|
|
std::vector<double> profile_bulges = {0.0, 0.0, 0.0, 0.0};
|
|
|
|
polyline_descriptor_t desc;
|
|
desc.point_number = 4;
|
|
desc.points = profile_points.data();
|
|
desc.bulge_number = 4;
|
|
desc.bulges = profile_bulges.data();
|
|
desc.is_close = true;
|
|
desc.reference_normal = {0, 0, 1};
|
|
|
|
internal::polyline_geometry_data geom;
|
|
|
|
Eigen::Vector3d proj_x(1, 0, 0); // X轴 → Profile 的 X 方向
|
|
Eigen::Vector3d proj_y(0, 1, 0); // Y轴 → Profile 的 Y 方向
|
|
Eigen::Vector3d origin(0, 0, 0); // 原点
|
|
internal::aabb_t_dim<2> aabb;
|
|
|
|
geom.build_as_profile(desc, proj_x, proj_y, origin, aabb);
|
|
|
|
// ========== 测试 1：内部点 ==========
|
|
Eigen::Vector3d inside_point(0.0, 0.0, 0.0);
|
|
auto closest_inside = geom.calculate_closest_param(inside_point);
|
|
bool is_inside = geom.pmc(inside_point.head<2>(), closest_inside.first);
|
|
TEST_ASSERT(!is_inside, "Point (0,0) is inside square");
|
|
|
|
// ========== 测试 2：外部点 ==========
|
|
Eigen::Vector3d outside_point(2.0, 2.0, 0.0);
|
|
auto closest_outside = geom.calculate_closest_param(outside_point);
|
|
bool is_outside_pmc = geom.pmc(outside_point.head<2>(), closest_outside.first);
|
|
TEST_ASSERT(is_outside_pmc, "Point (2,2) is outside square");
|
|
|
|
// ========== 测试 3：边界点 ==========
|
|
Eigen::Vector3d boundary_point(1.0, 0.0, 0.0); // 右边界中点
|
|
auto closest_boundary = geom.calculate_closest_param(boundary_point);
|
|
bool is_boundary_in = geom.pmc(boundary_point.head<2>(), closest_boundary.first);
|
|
// 边界点可能返回 true 或 false，只要不崩溃就算通过
|
|
TEST_ASSERT(true, "Boundary point PMC completed without error");
|
|
|
|
// ========== 测试 4：更多外部点 ==========
|
|
std::vector<Eigen::Vector3d> more_outside_points = {
|
|
{-2.0, 0.0, 0.0}, // 左外侧
|
|
{0.0, -2.0, 0.0}, // 下外侧
|
|
{0.0, 2.0, 0.0}, // 上外侧
|
|
{2.0, 0.0, 0.0}, // 右外侧
|
|
};
|
|
|
|
for (const auto& pt : more_outside_points) {
|
|
auto closest = geom.calculate_closest_param(pt);
|
|
bool is_outside = geom.pmc(pt.head<2>(), closest.first);
|
|
TEST_ASSERT(is_outside, "Point (" << pt.transpose() << ") should be outside square");
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* @brief 测试 Polyline 的 isEnd() 函数
|
|
*/
|
|
bool test_polyline_isEnd()
|
|
{
|
|
TEST_SECTION("Polyline isEnd() Function");
|
|
|
|
std::vector<vector3d> points = {
|
|
{0, 0, 0},
|
|
{1, 0, 0},
|
|
{1, 1, 0}
|
|
};
|
|
std::vector<double> bulges = {0.0, 0.0};
|
|
|
|
polyline_descriptor_t desc;
|
|
desc.point_number = 3;
|
|
desc.points = points.data();
|
|
desc.bulge_number = 2;
|
|
desc.bulges = bulges.data();
|
|
desc.is_close = false;
|
|
desc.reference_normal = {0, 0, 1};
|
|
|
|
internal::polyline_geometry_data geom;
|
|
internal::aabb_t_dim<2> aabb_obj;
|
|
geom.build_as_profile(desc, {1, 0, 0}, {0, 1, 0}, {0, 0, 0}, aabb_obj);
|
|
|
|
// t = 0 应该是端点
|
|
TEST_ASSERT(geom.isEnd(0.0), "t=0 is an endpoint");
|
|
|
|
// t = segment_count 应该是端点
|
|
double max_t = static_cast<double>(geom.start_indices.size());
|
|
TEST_ASSERT(geom.isEnd(max_t), "t=max is an endpoint");
|
|
|
|
// 中间值不应该是端点
|
|
TEST_ASSERT(!geom.isEnd(0.5), "t=0.5 is not an endpoint");
|
|
TEST_ASSERT(!geom.isEnd(1.0), "t=1.0 is not an endpoint");
|
|
|
|
return true;
|
|
}
|
|
|
|
// ============================================================================
|
|
// Phase 1.3: Edge Case Tests
|
|
// ============================================================================
|
|
|
|
/**
|
|
* @brief 测试退化的 polyline (只有2个点的直线)
|
|
*/
|
|
bool test_edge_degenerate_polyline()
|
|
{
|
|
TEST_SECTION("Edge Case - Degenerate Polyline (2 points)");
|
|
|
|
primitive_data_center_t dc;
|
|
|
|
// 创建只有2个点的 profile (一条直线)
|
|
std::vector<vector3d> profile_points = {
|
|
{-0.5, 0.0, 0.0},
|
|
{0.5, 0.0, 0.0}
|
|
};
|
|
std::vector<double> profile_bulges = {0.0};
|
|
|
|
profile_descriptor_t profile;
|
|
profile.point_number = 2;
|
|
profile.points = profile_points.data();
|
|
profile.bulge_number = 1;
|
|
profile.bulges = profile_bulges.data();
|
|
profile.is_close = false; // 不封闭
|
|
profile.reference_normal = {0, 0, 1};
|
|
|
|
std::vector<vector3d> axis_points = {
|
|
{0, 0, 0},
|
|
{0, 0, 1}
|
|
};
|
|
std::vector<double> axis_bulges = {0.0};
|
|
|
|
axis_descriptor_t axis;
|
|
axis.type = AXIS_TYPE_POLYLINE;
|
|
axis.data.polyline.point_number = 2;
|
|
axis.data.polyline.points = axis_points.data();
|
|
axis.data.polyline.bulge_number = 1;
|
|
axis.data.polyline.bulges = axis_bulges.data();
|
|
axis.data.polyline.is_close = false;
|
|
axis.data.polyline.reference_normal = {1, 0, 0};
|
|
|
|
auto* extrude = internal::new_primitive(PRIMITIVE_TYPE_EXTRUDE_POLYLINE, &dc);
|
|
auto* ext_poly = static_cast<internal::extrude_polyline_t*>(extrude);
|
|
|
|
// 这应该成功创建（即使 profile 退化）
|
|
extrude_polyline_descriptor_t desc;
|
|
desc.profile_number = 1;
|
|
desc.profiles = const_cast<polyline_descriptor_t*>(reinterpret_cast<const polyline_descriptor_t*>(&profile));
|
|
desc.axis = axis.data.polyline;
|
|
ext_poly->initialize_with_components(&dc, desc);
|
|
|
|
auto aabb = ext_poly->fetch_aabb();
|
|
TEST_ASSERT(!aabb.isEmpty(), "Degenerate profile still creates valid extrude");
|
|
|
|
TestHelper::safeFree(extrude);
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* @brief 测试极小尺寸的拉伸体
|
|
*/
|
|
bool test_edge_very_small_dimensions()
|
|
{
|
|
TEST_SECTION("Edge Case - Very Small Dimensions");
|
|
|
|
primitive_data_center_t dc;
|
|
|
|
// 创建非常小的 profile
|
|
std::vector<vector3d> profile_points = {
|
|
{-0.001, -0.001, 0.0},
|
|
{0.001, -0.001, 0.0},
|
|
{0.001, 0.001, 0.0},
|
|
{-0.001, 0.001, 0.0}
|
|
};
|
|
std::vector<double> profile_bulges = {0.0, 0.0, 0.0, 0.0};
|
|
|
|
profile_descriptor_t profile;
|
|
profile.point_number = 4;
|
|
profile.points = profile_points.data();
|
|
profile.bulge_number = 4;
|
|
profile.bulges = profile_bulges.data();
|
|
profile.is_close = true;
|
|
profile.reference_normal = {0, 0, 1};
|
|
|
|
// 创建非常短的 axis
|
|
std::vector<vector3d> axis_points = {
|
|
{0, 0, 0 },
|
|
{0, 0, 0.001}
|
|
};
|
|
std::vector<double> axis_bulges = {0.0};
|
|
|
|
axis_descriptor_t axis;
|
|
axis.type = AXIS_TYPE_POLYLINE;
|
|
axis.data.polyline.point_number = 2;
|
|
axis.data.polyline.points = axis_points.data();
|
|
axis.data.polyline.bulge_number = 1;
|
|
axis.data.polyline.bulges = axis_bulges.data();
|
|
axis.data.polyline.is_close = false;
|
|
axis.data.polyline.reference_normal = {1, 0, 0};
|
|
|
|
auto* extrude = internal::new_primitive(PRIMITIVE_TYPE_EXTRUDE_POLYLINE, &dc);
|
|
auto* ext_poly = static_cast<internal::extrude_polyline_t*>(extrude);
|
|
|
|
extrude_polyline_descriptor_t desc;
|
|
desc.profile_number = 1;
|
|
desc.profiles = const_cast<polyline_descriptor_t*>(reinterpret_cast<const polyline_descriptor_t*>(&profile));
|
|
desc.axis = axis.data.polyline;
|
|
ext_poly->initialize_with_components(&dc, desc);
|
|
|
|
auto aabb = ext_poly->fetch_aabb();
|
|
TEST_ASSERT(!aabb.isEmpty(), "Very small extrude is valid");
|
|
TEST_ASSERT(aabb.sizes().x() > 0, "AABB has positive X size");
|
|
TEST_ASSERT(aabb.sizes().y() > 0, "AABB has positive Y size");
|
|
TEST_ASSERT(aabb.sizes().z() > 0, "AABB has positive Z size");
|
|
|
|
TestHelper::safeFree(extrude);
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* @brief 测试零长度 axis 的错误处理
|
|
*/
|
|
bool test_edge_zero_length_axis()
|
|
{
|
|
TEST_SECTION("Edge Case - Zero Length Axis");
|
|
|
|
primitive_data_center_t dc;
|
|
|
|
std::vector<vector3d> profile_points = {
|
|
{-0.5, -0.5, 0.0},
|
|
{0.5, -0.5, 0.0},
|
|
{0.5, 0.5, 0.0},
|
|
{-0.5, 0.5, 0.0}
|
|
};
|
|
std::vector<double> profile_bulges = {0.0, 0.0, 0.0, 0.0};
|
|
|
|
profile_descriptor_t profile;
|
|
profile.point_number = 4;
|
|
profile.points = profile_points.data();
|
|
profile.bulge_number = 4;
|
|
profile.bulges = profile_bulges.data();
|
|
profile.is_close = true;
|
|
profile.reference_normal = {0, 0, 1};
|
|
|
|
// 创建零长度 axis (两个相同的点)
|
|
std::vector<vector3d> axis_points = {
|
|
{0, 0, 0},
|
|
{0, 0, 0}
|
|
};
|
|
std::vector<double> axis_bulges = {0.0};
|
|
|
|
axis_descriptor_t axis;
|
|
axis.type = AXIS_TYPE_POLYLINE;
|
|
axis.data.polyline.point_number = 2;
|
|
axis.data.polyline.points = axis_points.data();
|
|
axis.data.polyline.bulge_number = 1;
|
|
axis.data.polyline.bulges = axis_bulges.data();
|
|
axis.data.polyline.is_close = false;
|
|
axis.data.polyline.reference_normal = {1, 0, 0};
|
|
|
|
auto* extrude = internal::new_primitive(PRIMITIVE_TYPE_EXTRUDE_POLYLINE, &dc);
|
|
auto* ext_poly = static_cast<internal::extrude_polyline_t*>(extrude);
|
|
|
|
bool caught_error = false;
|
|
try {
|
|
extrude_polyline_descriptor_t desc;
|
|
desc.profile_number = 1;
|
|
desc.profiles = const_cast<polyline_descriptor_t*>(reinterpret_cast<const polyline_descriptor_t*>(&profile));
|
|
desc.axis = axis.data.polyline;
|
|
ext_poly->initialize_with_components(&dc, desc);
|
|
} catch (const std::exception& e) {
|
|
caught_error = true;
|
|
std::cout << " Expected error caught: " << e.what() << "\n";
|
|
}
|
|
|
|
// 零长度 axis 可能会抛出异常或产生退化结果
|
|
// 这里我们验证系统不会崩溃
|
|
if (!caught_error) {
|
|
// 如果没有抛出异常，验证结果是否合理
|
|
auto aabb = ext_poly->fetch_aabb();
|
|
std::cout << " Zero-length axis produced AABB: "
|
|
<< "sizes = " << aabb.sizes().transpose() << "\n";
|
|
}
|
|
|
|
TestHelper::safeFree(extrude);
|
|
return true;
|
|
}
|
|
|
|
// ============================================================================
|
|
// Main 测试运行器
|
|
// ============================================================================
|
|
|
|
int main()
|
|
{
|
|
SetConsoleOutputCP(CP_UTF8);
|
|
|
|
std::cout << "╔══════════════════════════════════════════════════════╗\n";
|
|
std::cout << "║ EXTRUDE TEST SUITE ║\n";
|
|
std::cout << "║ Based on Actual Code Structure ║\n";
|
|
std::cout << "╚══════════════════════════════════════════════════════╝\n";
|
|
std::cout << "mimalloc version: " << mi_version() << "\n\n";
|
|
|
|
struct TestCase {
|
|
std::string name;
|
|
std::function<bool()> func;
|
|
std::string group;
|
|
};
|
|
|
|
std::vector<TestCase> tests = {
|
|
// Group 1: Polyline
|
|
{"Polyline Basic Shapes", test_polyline_basic_shapes, "Polyline" },
|
|
{"Polyline SDF Calculation", test_polyline_sdf_calculation, "Polyline" },
|
|
{"Polyline Closest Point", test_polyline_closest_point, "Polyline" },
|
|
|
|
// Group 2: Helixline
|
|
{"Helixline Construction", test_helixline_construction, "Helixline" },
|
|
{"Helixline Tangent/Normal", test_helixline_tangent_normal, "Helixline" },
|
|
{"Helixline Closest Point", test_helixline_closest_point, "Helixline" },
|
|
{"Helixline Left vs Right", test_helixline_left_vs_right, "Helixline" },
|
|
|
|
// Group 3: Extrude Creation
|
|
{"Extrude Polyline Creation", test_extrude_polyline_creation, "Extrude" },
|
|
{"Extrude Helixline Creation", test_extrude_helixline_creation, "Extrude" },
|
|
{"Extrude AABB Computation", test_extrude_aabb_computation, "Extrude" },
|
|
{"Extrude Descriptor Sharing", test_extrude_descriptor_sharing, "Extrude" },
|
|
{"Extrude Various Profiles", test_extrude_various_profiles, "Extrude" },
|
|
|
|
// Group 4: SDF & Parametrization
|
|
{"Extrude SDF Basic", test_extrude_sdf_basic, "SDF" },
|
|
{"Extrude Parametrization", test_extrude_parametrization, "SDF" },
|
|
|
|
// Group 5: Transforms
|
|
{"Transform Scale", test_extrude_transform_scale, "Transform" },
|
|
{"Transform Translation", test_extrude_transform_translation, "Transform" },
|
|
|
|
// Group 6: Replace
|
|
{"Replace Profile", test_replace_profile, "Replace" },
|
|
|
|
{"Replace Axis", test_replace_axis, "Replace" },
|
|
|
|
// Group 7: Edge Cases
|
|
{"Edge Cases Small Dimensions", test_edge_cases_small_dimensions, "EdgeCase" },
|
|
|
|
// Group 8: Performance
|
|
{"Performance Batch Creation", test_performance_batch_creation, "Performance"},
|
|
|
|
|
|
// Phase 1.1: Subface Functions
|
|
{"Polyline SDF Detailed", test_polyline_eval_sdf_detailed, "Subface" },
|
|
{"Polyline SDF Gradient", test_polyline_eval_sdf_grad, "Subface" },
|
|
{"Polyline Param Round-Trip", test_polyline_map_param_roundtrip, "Subface" },
|
|
{"Polyline Constraint Curves", test_polyline_constraint_curves, "Subface" },
|
|
{"Polyline Descriptor Accessor", test_polyline_geometry_accessor, "Subface" },
|
|
//{"Polyline Subface Equal", test_polyline_subface_equal, "Subface" },
|
|
|
|
// Phase 1.2: Geometry Data Internals
|
|
{"Polyline PMC Inside/Outside", test_polyline_pmc_inside_outside, "Geometry" },
|
|
{"Polyline isEnd()", test_polyline_isEnd, "Geometry" },
|
|
|
|
// Phase 1.3: Edge Cases
|
|
{"Edge: Degenerate Polyline", test_edge_degenerate_polyline, "EdgeCase" },
|
|
{"Edge: Very Small Dimensions", test_edge_very_small_dimensions, "EdgeCase" },
|
|
{"Edge: Zero Length Axis", test_edge_zero_length_axis, "EdgeCase" }
|
|
};
|
|
|
|
int passed = 0;
|
|
int total = static_cast<int>(tests.size());
|
|
|
|
std::string current_group;
|
|
for (const auto& test : tests) {
|
|
if (test.group != current_group) {
|
|
current_group = test.group;
|
|
std::cout << "\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n";
|
|
std::cout << " GROUP: " << current_group << "\n";
|
|
std::cout << "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n";
|
|
}
|
|
|
|
try {
|
|
if (test.func()) { passed++; }
|
|
} catch (const std::exception& e) {
|
|
std::cerr << "❌ EXCEPTION in " << test.name << ": " << e.what() << "\n";
|
|
} catch (...) {
|
|
std::cerr << "❌ UNKNOWN EXCEPTION in " << test.name << "\n";
|
|
}
|
|
}
|
|
|
|
TestHelper::printStatistics(passed, total);
|
|
|
|
return (passed == total) ? 0 : 1;
|
|
}
|