茂之钳
853070f668
- industrial_formats.h: +46 lines (XtBinaryHeader, SabHeader, JtSegmentHeader structs + binary API) - industrial_formats.cpp: +310 lines (XT binary encode/decode, SAB parse, JT binary stream, auto-detect) - test_industrial_formats.cpp: +187 lines (12 binary tests) - 44/44 tests passing, zero regressions Auto-detect: magic bytes check before text parsing for all formats
825 lines
26 KiB
C++
825 lines
26 KiB
C++
#include <gtest/gtest.h>
|
|
#include <fstream>
|
|
#include <cstdio>
|
|
#include <cmath>
|
|
#include "vde/foundation/industrial_formats.h"
|
|
#include "vde/brep/modeling.h"
|
|
|
|
using namespace vde::io;
|
|
using namespace vde::brep;
|
|
using namespace vde::core;
|
|
|
|
// ═══════════════════════════════════════════════════════════════
|
|
// 辅助函数
|
|
// ═══════════════════════════════════════════════════════════════
|
|
|
|
static BrepModel make_test_box() {
|
|
return make_box(2.0, 3.0, 4.0);
|
|
}
|
|
|
|
static BrepModel make_test_cylinder() {
|
|
return make_cylinder(1.0, 5.0);
|
|
}
|
|
|
|
// 清理临时文件
|
|
static void clean(const char* path) {
|
|
std::remove(path);
|
|
}
|
|
|
|
// 验证 BrepModel 的基本有效性
|
|
static void expect_valid_body(const BrepModel& m) {
|
|
EXPECT_GT(m.num_vertices(), 0);
|
|
EXPECT_GT(m.num_edges(), 0);
|
|
EXPECT_GT(m.num_faces(), 0);
|
|
EXPECT_GT(m.num_bodies(), 0);
|
|
}
|
|
|
|
// ═══════════════════════════════════════════════════════════════
|
|
// JT 测试 (ISO 14306)
|
|
// ═══════════════════════════════════════════════════════════════
|
|
|
|
TEST(IndustrialJT, ExportBoxToJt) {
|
|
auto box = make_test_box();
|
|
const char* path = "/tmp/test_box.jt";
|
|
clean(path);
|
|
|
|
ASSERT_NO_THROW(export_jt(box, path));
|
|
|
|
std::ifstream f(path, std::ios::binary);
|
|
ASSERT_TRUE(f.good());
|
|
|
|
// 检查 JT 版本字符串
|
|
char version[80] = {};
|
|
f.read(version, 80);
|
|
EXPECT_NE(std::string(version).find("JT"), std::string::npos);
|
|
|
|
// 检查字节序标记
|
|
char byte_order;
|
|
f.read(&byte_order, 1);
|
|
EXPECT_EQ(byte_order, 0); // LE
|
|
|
|
clean(path);
|
|
}
|
|
|
|
TEST(IndustrialJT, ImportExportedJt) {
|
|
auto box = make_test_box();
|
|
const char* path = "/tmp/test_roundtrip.jt";
|
|
clean(path);
|
|
|
|
export_jt(box, path);
|
|
|
|
// 使用默认选项导入（加载网格）
|
|
JTOptions opts;
|
|
opts.load_mesh = true;
|
|
opts.load_brep = false;
|
|
|
|
auto imported = import_jt(path, opts);
|
|
expect_valid_body(imported);
|
|
|
|
clean(path);
|
|
}
|
|
|
|
TEST(IndustrialJT, ImportJtWithBrepOption) {
|
|
auto box = make_test_box();
|
|
const char* path = "/tmp/test_jt_brep.jt";
|
|
clean(path);
|
|
export_jt(box, path);
|
|
|
|
JTOptions opts;
|
|
opts.load_brep = true;
|
|
opts.load_mesh = false;
|
|
|
|
auto imported = import_jt(path, opts);
|
|
// 即使 B-Rep 加载失败，也应返回有效（可能为空）模型
|
|
EXPECT_NO_THROW(import_jt(path, opts));
|
|
|
|
clean(path);
|
|
}
|
|
|
|
TEST(IndustrialJT, ImportJtWithCustomLod) {
|
|
auto box = make_test_box();
|
|
const char* path = "/tmp/test_jt_lod.jt";
|
|
clean(path);
|
|
export_jt(box, path);
|
|
|
|
JTOptions opts;
|
|
opts.max_lod = 1;
|
|
auto imported = import_jt(path, opts);
|
|
expect_valid_body(imported);
|
|
|
|
clean(path);
|
|
}
|
|
|
|
TEST(IndustrialJT, ImportJtWithPmiOption) {
|
|
auto box = make_test_box();
|
|
const char* path = "/tmp/test_jt_pmi.jt";
|
|
clean(path);
|
|
export_jt(box, path);
|
|
|
|
JTOptions opts;
|
|
opts.load_pmi = true;
|
|
opts.load_meta = true;
|
|
auto imported = import_jt(path, opts);
|
|
expect_valid_body(imported);
|
|
|
|
clean(path);
|
|
}
|
|
|
|
TEST(IndustrialJT, ImportJtNonexistentFile) {
|
|
EXPECT_THROW(import_jt("/tmp/nonexistent_jt_file.jt"), std::runtime_error);
|
|
}
|
|
|
|
// ═══════════════════════════════════════════════════════════════
|
|
// Parasolid XT 测试
|
|
// ═══════════════════════════════════════════════════════════════
|
|
|
|
TEST(IndustrialParasolid, ExportBoxToXt) {
|
|
auto box = make_test_box();
|
|
const char* path = "/tmp/test_box.x_t";
|
|
clean(path);
|
|
|
|
ASSERT_NO_THROW(export_parasolid_xt(box, path));
|
|
|
|
std::ifstream f(path);
|
|
ASSERT_TRUE(f.good());
|
|
std::string first_line;
|
|
std::getline(f, first_line);
|
|
// Parasolid text 格式以 "**" 开头
|
|
EXPECT_EQ(first_line.substr(0, 2), "**");
|
|
|
|
clean(path);
|
|
}
|
|
|
|
TEST(IndustrialParasolid, ImportExportedXt) {
|
|
auto box = make_test_box();
|
|
const char* path = "/tmp/test_xt_roundtrip.x_t";
|
|
clean(path);
|
|
|
|
export_parasolid_xt(box, path);
|
|
auto imported = import_parasolid_xt(path);
|
|
expect_valid_body(imported);
|
|
|
|
clean(path);
|
|
}
|
|
|
|
TEST(IndustrialParasolid, ImportXtWithVertexData) {
|
|
auto box = make_test_box();
|
|
const char* path = "/tmp/test_xt_vertex.x_t";
|
|
clean(path);
|
|
export_parasolid_xt(box, path);
|
|
|
|
auto imported = import_parasolid_xt(path);
|
|
EXPECT_GT(imported.num_vertices(), 0);
|
|
EXPECT_GT(imported.num_edges(), 0);
|
|
EXPECT_GT(imported.num_faces(), 0);
|
|
|
|
clean(path);
|
|
}
|
|
|
|
TEST(IndustrialParasolid, ExportCylinderToXt) {
|
|
auto cyl = make_test_cylinder();
|
|
const char* path = "/tmp/test_cyl.x_t";
|
|
clean(path);
|
|
|
|
export_parasolid_xt(cyl, path);
|
|
std::ifstream f(path);
|
|
std::string content((std::istreambuf_iterator<char>(f)), {});
|
|
EXPECT_NE(content.find("VERTEX"), std::string::npos);
|
|
EXPECT_NE(content.find("EDGE"), std::string::npos);
|
|
|
|
clean(path);
|
|
}
|
|
|
|
TEST(IndustrialParasolid, ImportXtNonexistentFile) {
|
|
EXPECT_THROW(import_parasolid_xt("/tmp/nonexistent_xt.x_t"), std::runtime_error);
|
|
}
|
|
|
|
// ═══════════════════════════════════════════════════════════════
|
|
// Parasolid XT 二进制测试
|
|
// ═══════════════════════════════════════════════════════════════
|
|
|
|
TEST(IndustrialParasolidBinary, ExportBoxToXBinary) {
|
|
auto box = make_test_box();
|
|
const char* path = "/tmp/test_box.x_b";
|
|
clean(path);
|
|
|
|
ASSERT_NO_THROW(export_parasolid_xt_binary(box, path));
|
|
|
|
// 检查文件存在且以 "PARA" 开头
|
|
std::ifstream f(path, std::ios::binary);
|
|
ASSERT_TRUE(f.good());
|
|
char magic[4] = {};
|
|
f.read(magic, 4);
|
|
EXPECT_EQ(magic[0], 'P');
|
|
EXPECT_EQ(magic[1], 'A');
|
|
EXPECT_EQ(magic[2], 'R');
|
|
EXPECT_EQ(magic[3], 'A');
|
|
|
|
clean(path);
|
|
}
|
|
|
|
TEST(IndustrialParasolidBinary, ImportExportedXBinary) {
|
|
auto box = make_test_box();
|
|
const char* path = "/tmp/test_xb_roundtrip.x_b";
|
|
clean(path);
|
|
|
|
export_parasolid_xt_binary(box, path);
|
|
auto imported = import_parasolid_xt(path); // auto-detect binary
|
|
expect_valid_body(imported);
|
|
|
|
clean(path);
|
|
}
|
|
|
|
TEST(IndustrialParasolidBinary, ExportBinaryToString) {
|
|
auto box = make_test_box();
|
|
std::string bin = export_parasolid_xt_binary_str(box);
|
|
EXPECT_GT(bin.size(), 40u) << "Binary data should exceed header size";
|
|
// 检查 magic
|
|
EXPECT_EQ(bin[0], 'P');
|
|
EXPECT_EQ(bin[1], 'A');
|
|
EXPECT_EQ(bin[2], 'R');
|
|
EXPECT_EQ(bin[3], 'A');
|
|
}
|
|
|
|
TEST(IndustrialParasolidBinary, ImportFromMemory) {
|
|
auto box = make_test_box();
|
|
std::string bin = export_parasolid_xt_binary_str(box);
|
|
|
|
auto imported = import_parasolid_xt_binary(
|
|
reinterpret_cast<const uint8_t*>(bin.data()), bin.size());
|
|
expect_valid_body(imported);
|
|
}
|
|
|
|
TEST(IndustrialParasolidBinary, AutoDetectBinaryPath) {
|
|
auto box = make_test_box();
|
|
const char* path = "/tmp/test_autodetect.x_b";
|
|
clean(path);
|
|
export_parasolid_xt_binary(box, path);
|
|
|
|
// import_parasolid_xt should auto-detect binary format
|
|
auto imported = import_parasolid_xt(path);
|
|
expect_valid_body(imported);
|
|
|
|
clean(path);
|
|
}
|
|
|
|
TEST(IndustrialParasolidBinary, ExportCylinderBinary) {
|
|
auto cyl = make_test_cylinder();
|
|
const char* path = "/tmp/test_cyl.x_b";
|
|
clean(path);
|
|
|
|
export_parasolid_xt_binary(cyl, path);
|
|
auto imported = import_parasolid_xt(path);
|
|
expect_valid_body(imported);
|
|
|
|
clean(path);
|
|
}
|
|
|
|
TEST(IndustrialParasolidBinary, InvalidMagicThrows) {
|
|
// 制造无效的二进制数据
|
|
uint8_t bad_data[40] = {};
|
|
bad_data[0] = 'X'; bad_data[1] = 'X'; bad_data[2] = 'X'; bad_data[3] = 'X';
|
|
EXPECT_THROW(import_parasolid_xt_binary(bad_data, 40), std::runtime_error);
|
|
}
|
|
|
|
TEST(IndustrialParasolidBinary, TooSmallThrows) {
|
|
uint8_t tiny[4] = {'P', 'A', 'R', 'A'};
|
|
EXPECT_THROW(import_parasolid_xt_binary(tiny, 4), std::runtime_error);
|
|
}
|
|
|
|
// ═══════════════════════════════════════════════════════════════
|
|
// ACIS SAB 二进制测试
|
|
// ═══════════════════════════════════════════════════════════════
|
|
|
|
TEST(IndustrialACISSAB, ImportMinimalSAB) {
|
|
// 构造最小 SAB 数据: header(16) + 空字符串表 + 0浮点 + 0整数
|
|
std::string sab;
|
|
sab += "SAB "; // magic
|
|
uint32_t data_size = 16; // header only
|
|
sab.push_back(static_cast<char>(data_size & 0xFF));
|
|
sab.push_back(static_cast<char>((data_size >> 8) & 0xFF));
|
|
sab.push_back(static_cast<char>((data_size >> 16) & 0xFF));
|
|
sab.push_back(static_cast<char>((data_size >> 24) & 0xFF));
|
|
uint32_t version = 2700; // V27
|
|
sab.push_back(static_cast<char>(version & 0xFF));
|
|
sab.push_back(static_cast<char>((version >> 8) & 0xFF));
|
|
sab.push_back(static_cast<char>((version >> 16) & 0xFF));
|
|
sab.push_back(static_cast<char>((version >> 24) & 0xFF));
|
|
uint32_t str_size = 0;
|
|
sab.push_back(static_cast<char>(str_size & 0xFF));
|
|
sab.push_back(static_cast<char>((str_size >> 8) & 0xFF));
|
|
sab.push_back(static_cast<char>((str_size >> 16) & 0xFF));
|
|
sab.push_back(static_cast<char>((str_size >> 24) & 0xFF));
|
|
|
|
// 不应崩溃
|
|
auto model = import_acis_sat_binary(
|
|
reinterpret_cast<const uint8_t*>(sab.data()), sab.size());
|
|
// 空数据可能返回空模型
|
|
EXPECT_NO_THROW(import_acis_sat_binary(
|
|
reinterpret_cast<const uint8_t*>(sab.data()), sab.size()));
|
|
}
|
|
|
|
TEST(IndustrialACISSAB, SATFileAutoDetectSAB) {
|
|
// 写入 SAB 格式文件，import_acis_sat 应自动检测
|
|
std::string sab;
|
|
sab += "SAB ";
|
|
for (int i = 0; i < 12; ++i) sab.push_back('\0'); // 填充 header
|
|
const char* path = "/tmp/test_autodetect.sab";
|
|
clean(path);
|
|
{
|
|
std::ofstream f(path, std::ios::binary);
|
|
f.write(sab.data(), static_cast<std::streamsize>(sab.size()));
|
|
}
|
|
|
|
auto model = import_acis_sat(path);
|
|
// 应能检测 SAB 格式而不崩溃
|
|
EXPECT_NO_THROW(import_acis_sat(path));
|
|
|
|
clean(path);
|
|
}
|
|
|
|
// ═══════════════════════════════════════════════════════════════
|
|
// JT 二进制测试
|
|
// ═══════════════════════════════════════════════════════════════
|
|
|
|
TEST(IndustrialJTBinary, ImportFromMemory) {
|
|
auto box = make_test_box();
|
|
const char* path = "/tmp/test_jt_bin.jt";
|
|
clean(path);
|
|
export_jt(box, path);
|
|
|
|
// 读取文件内容作为二进制数据
|
|
std::ifstream f(path, std::ios::binary);
|
|
std::string data((std::istreambuf_iterator<char>(f)), {});
|
|
f.close();
|
|
|
|
JTOptions opts;
|
|
opts.load_mesh = true;
|
|
opts.load_brep = false;
|
|
|
|
auto imported = import_jt_binary(
|
|
reinterpret_cast<const uint8_t*>(data.data()), data.size(), opts);
|
|
expect_valid_body(imported);
|
|
|
|
clean(path);
|
|
}
|
|
|
|
TEST(IndustrialJTBinary, ImportFromMemoryWithBrepOption) {
|
|
auto box = make_test_box();
|
|
const char* path = "/tmp/test_jt_bin2.jt";
|
|
clean(path);
|
|
export_jt(box, path);
|
|
|
|
std::ifstream f(path, std::ios::binary);
|
|
std::string data((std::istreambuf_iterator<char>(f)), {});
|
|
f.close();
|
|
|
|
JTOptions opts;
|
|
opts.load_brep = true;
|
|
opts.load_mesh = false;
|
|
|
|
// 不应崩溃
|
|
EXPECT_NO_THROW(import_jt_binary(
|
|
reinterpret_cast<const uint8_t*>(data.data()), data.size(), opts));
|
|
|
|
clean(path);
|
|
}
|
|
|
|
TEST(IndustrialACIS, ExportBoxToSatV27) {
|
|
auto box = make_test_box();
|
|
const char* path = "/tmp/test_box.sat";
|
|
clean(path);
|
|
|
|
ASSERT_NO_THROW(export_acis_sat(box, path, ACISVersion::V27));
|
|
|
|
std::ifstream f(path);
|
|
ASSERT_TRUE(f.good());
|
|
std::string first_line;
|
|
std::getline(f, first_line);
|
|
// 第一行应包含版本号
|
|
EXPECT_NE(first_line.find("27"), std::string::npos);
|
|
|
|
clean(path);
|
|
}
|
|
|
|
TEST(IndustrialACIS, ExportBoxToSatV16) {
|
|
auto box = make_test_box();
|
|
const char* path = "/tmp/test_box_v16.sat";
|
|
clean(path);
|
|
|
|
export_acis_sat(box, path, ACISVersion::V16);
|
|
std::ifstream f(path);
|
|
std::string first_line;
|
|
std::getline(f, first_line);
|
|
EXPECT_NE(first_line.find("16"), std::string::npos);
|
|
|
|
clean(path);
|
|
}
|
|
|
|
TEST(IndustrialACIS, ImportExportedSat) {
|
|
auto box = make_test_box();
|
|
const char* path = "/tmp/test_sat_roundtrip.sat";
|
|
clean(path);
|
|
|
|
export_acis_sat(box, path);
|
|
auto imported = import_acis_sat(path);
|
|
expect_valid_body(imported);
|
|
|
|
clean(path);
|
|
}
|
|
|
|
TEST(IndustrialACIS, ImportSatWithEndMarker) {
|
|
auto box = make_test_box();
|
|
const char* path = "/tmp/test_sat_end.sat";
|
|
clean(path);
|
|
export_acis_sat(box, path);
|
|
|
|
std::ifstream f(path);
|
|
std::string content((std::istreambuf_iterator<char>(f)), {});
|
|
EXPECT_NE(content.find("End-of-ACIS-data"), std::string::npos);
|
|
|
|
auto imported = import_acis_sat(path);
|
|
expect_valid_body(imported);
|
|
|
|
clean(path);
|
|
}
|
|
|
|
TEST(IndustrialACIS, ExportCylinderToSat) {
|
|
auto cyl = make_test_cylinder();
|
|
const char* path = "/tmp/test_cyl.sat";
|
|
clean(path);
|
|
|
|
export_acis_sat(cyl, path);
|
|
std::ifstream f(path);
|
|
std::string content((std::istreambuf_iterator<char>(f)), {});
|
|
EXPECT_NE(content.find("ViewDesignEngine"), std::string::npos);
|
|
EXPECT_NE(content.find("body"), std::string::npos);
|
|
|
|
clean(path);
|
|
}
|
|
|
|
TEST(IndustrialACIS, ImportSatNonexistentFile) {
|
|
EXPECT_THROW(import_acis_sat("/tmp/nonexistent.sat"), std::runtime_error);
|
|
}
|
|
|
|
// ═══════════════════════════════════════════════════════════════
|
|
// IFC 测试 (ISO 16739)
|
|
// ═══════════════════════════════════════════════════════════════
|
|
|
|
static std::string make_minimal_ifc() {
|
|
return R"(ISO-10303-21;
|
|
HEADER;
|
|
FILE_DESCRIPTION(('ViewDesignEngine Test'),'2;1');
|
|
FILE_NAME('test.ifc','2025-01-01',('VDE'),(''),'','');
|
|
FILE_SCHEMA(('IFC4'));
|
|
ENDSEC;
|
|
DATA;
|
|
#1=IFCPROJECT('proj',$,'Test Project',$,$,$,$,(#2),#10);
|
|
#2=IFCSITE('site',$,$,$,$,$,$,$,$,$,$,$);
|
|
#3=IFCWALL('wall1',$,'Wall 300x3000x240',$,$,#20,#30,$);
|
|
#10=IFCOWNERHISTORY(#11,#12,$,$,$,$,$,$);
|
|
#11=IFCPERSON('user','','',$,$,$,$,$);
|
|
#12=IFCORGANIZATION('VDE','',$,$);
|
|
#20=IFCLOCALPLACEMENT($,#21);
|
|
#21=IFCAXIS2PLACEMENT3D(#22,$,$);
|
|
#22=IFCCARTESIANPOINT((0.0,0.0,0.0));
|
|
#30=IFCPRODUCTDEFINITIONSHAPE($,$,(#40));
|
|
#40=IFCSHAPEREPRESENTATION($,'Body','SweptSolid',(#50));
|
|
#50=IFCEXTRUDEDAREASOLID(#60,$,$,3.0);
|
|
#60=IFCRECTANGLEPROFILEDEF(.AREA.,$,#70,5.0,0.24);
|
|
#70=IFCAXIS2PLACEMENT2D(#71,$);
|
|
#71=IFCCARTESIANPOINT((0.0,0.0));
|
|
#80=IFCSLAB('slab1',$,'Slab 4000x300x4000',$,$,#90,#100,$);
|
|
#90=IFCLOCALPLACEMENT($,#91);
|
|
#91=IFCAXIS2PLACEMENT3D(#92,$,$);
|
|
#92=IFCCARTESIANPOINT((0.0,0.0,0.0));
|
|
#100=IFCPRODUCTDEFINITIONSHAPE($,$,(#110));
|
|
#110=IFCSHAPEREPRESENTATION($,'Body','SweptSolid',(#120));
|
|
#120=IFCEXTRUDEDAREASOLID(#130,$,$,0.3);
|
|
#130=IFCRECTANGLEPROFILEDEF(.AREA.,$,#140,4.0,4.0);
|
|
#140=IFCAXIS2PLACEMENT2D(#141,$);
|
|
#141=IFCCARTESIANPOINT((0.0,0.0));
|
|
#150=IFCBEAM('beam1',$,'Beam 4000x300x300',$,$,#160,#170,$);
|
|
#160=IFCLOCALPLACEMENT($,#161);
|
|
#161=IFCAXIS2PLACEMENT3D(#162,$,$);
|
|
#162=IFCCARTESIANPOINT((0.0,0.0,3.0));
|
|
#170=IFCPRODUCTDEFINITIONSHAPE($,$,(#180));
|
|
#180=IFCSHAPEREPRESENTATION($,'Body','SweptSolid',(#190));
|
|
#190=IFCEXTRUDEDAREASOLID(#200,$,$,0.3);
|
|
#200=IFCRECTANGLEPROFILEDEF(.AREA.,$,#210,0.3,0.3);
|
|
#210=IFCAXIS2PLACEMENT2D(#211,$);
|
|
#211=IFCCARTESIANPOINT((0.0,0.0));
|
|
ENDSEC;
|
|
END-ISO-10303-21;
|
|
)";
|
|
}
|
|
|
|
TEST(IndustrialIFC, ImportWall) {
|
|
std::string ifc = make_minimal_ifc();
|
|
const char* path = "/tmp/test_wall.ifc";
|
|
clean(path);
|
|
{
|
|
std::ofstream f(path);
|
|
f << ifc;
|
|
}
|
|
|
|
auto models = import_ifc(path);
|
|
EXPECT_GE(models.size(), 1u) << "Should find at least one IFC product";
|
|
|
|
if (!models.empty()) {
|
|
const auto& wall = models[0];
|
|
EXPECT_GT(wall.num_vertices(), 0);
|
|
EXPECT_GT(wall.num_bodies(), 0);
|
|
}
|
|
|
|
clean(path);
|
|
}
|
|
|
|
TEST(IndustrialIFC, ImportSlab) {
|
|
std::string ifc = make_minimal_ifc();
|
|
const char* path = "/tmp/test_slab.ifc";
|
|
clean(path);
|
|
{
|
|
std::ofstream f(path);
|
|
f << ifc;
|
|
}
|
|
|
|
auto models = import_ifc(path);
|
|
// 应找到 wall + slab + beam
|
|
EXPECT_GE(models.size(), 2u);
|
|
|
|
clean(path);
|
|
}
|
|
|
|
TEST(IndustrialIFC, ImportBeam) {
|
|
std::string ifc = make_minimal_ifc();
|
|
const char* path = "/tmp/test_beam.ifc";
|
|
clean(path);
|
|
{
|
|
std::ofstream f(path);
|
|
f << ifc;
|
|
}
|
|
|
|
auto models = import_ifc(path);
|
|
EXPECT_GE(models.size(), 3u);
|
|
|
|
clean(path);
|
|
}
|
|
|
|
TEST(IndustrialIFC, ImportProductCount) {
|
|
std::string ifc = make_minimal_ifc();
|
|
const char* path = "/tmp/test_count.ifc";
|
|
clean(path);
|
|
{
|
|
std::ofstream f(path);
|
|
f << ifc;
|
|
}
|
|
|
|
auto models = import_ifc(path);
|
|
// IFC 包含 IfcWall + IfcSlab + IfcBeam
|
|
EXPECT_EQ(models.size(), 3u);
|
|
|
|
clean(path);
|
|
}
|
|
|
|
TEST(IndustrialIFC, WallHasCorrectDimensions) {
|
|
std::string ifc = make_minimal_ifc();
|
|
const char* path = "/tmp/test_wall_dims.ifc";
|
|
clean(path);
|
|
{
|
|
std::ofstream f(path);
|
|
f << ifc;
|
|
}
|
|
|
|
auto models = import_ifc(path);
|
|
ASSERT_GE(models.size(), 1u);
|
|
|
|
// 验证模型有顶点
|
|
const auto& wall = models[0];
|
|
EXPECT_GT(wall.num_vertices(), 0);
|
|
EXPECT_GT(wall.num_faces(), 0);
|
|
|
|
clean(path);
|
|
}
|
|
|
|
TEST(IndustrialIFC, ImportNonexistentFile) {
|
|
EXPECT_THROW(import_ifc("/tmp/nonexistent.ifc"), std::runtime_error);
|
|
}
|
|
|
|
// ═══════════════════════════════════════════════════════════════
|
|
// STEP AP242 测试
|
|
// ═══════════════════════════════════════════════════════════════
|
|
|
|
TEST(IndustrialStepAP242, ExportSingleBox) {
|
|
auto box = make_test_box();
|
|
std::string result = export_step_ap242({box});
|
|
|
|
EXPECT_NE(result.find("ISO-10303-21"), std::string::npos);
|
|
EXPECT_NE(result.find("AP242"), std::string::npos);
|
|
EXPECT_NE(result.find("MANIFOLD_SOLID_BREP"), std::string::npos);
|
|
EXPECT_NE(result.find("ENDSEC"), std::string::npos);
|
|
EXPECT_NE(result.find("END-ISO-10303-21"), std::string::npos);
|
|
}
|
|
|
|
TEST(IndustrialStepAP242, ExportMultipleBodies) {
|
|
auto box = make_test_box();
|
|
auto cyl = make_test_cylinder();
|
|
std::string result = export_step_ap242({box, cyl});
|
|
|
|
// 应包含两个 PRODUCT
|
|
EXPECT_NE(result.find("PRODUCT"), std::string::npos);
|
|
EXPECT_NE(result.find("CLOSED_SHELL"), std::string::npos);
|
|
}
|
|
|
|
TEST(IndustrialStepAP242, ExportWithPMIAnnotations) {
|
|
auto box = make_test_box();
|
|
|
|
std::vector<StepPMIAnnotation> annotations;
|
|
StepPMIAnnotation ann;
|
|
ann.type = "linear_dimension";
|
|
ann.id = "DIM001";
|
|
ann.description = "Length dimension";
|
|
ann.nominal_value = 100.0;
|
|
ann.upper_tolerance = 0.1;
|
|
ann.lower_tolerance = -0.1;
|
|
ann.datum_system = "Datum_A";
|
|
annotations.push_back(ann);
|
|
|
|
std::string result = export_step_ap242({box}, annotations);
|
|
|
|
EXPECT_NE(result.find("PRODUCT_MANUFACTURING_INFORMATION"), std::string::npos);
|
|
EXPECT_NE(result.find("DIMENSIONAL_CHARACTERISTIC_REPRESENTATION"), std::string::npos);
|
|
EXPECT_NE(result.find("SHAPE_DIMENSION_REPRESENTATION"), std::string::npos);
|
|
}
|
|
|
|
TEST(IndustrialStepAP242, ExportWithGeometricTolerance) {
|
|
auto box = make_test_box();
|
|
|
|
std::vector<StepPMIAnnotation> annotations;
|
|
StepPMIAnnotation ann;
|
|
ann.type = "angular_dimension";
|
|
ann.id = "TOL001";
|
|
ann.description = "Angular tolerance";
|
|
ann.nominal_value = 90.0;
|
|
ann.upper_tolerance = 0.5;
|
|
ann.lower_tolerance = -0.5;
|
|
ann.datum_system = "Datum_B";
|
|
annotations.push_back(ann);
|
|
|
|
std::string result = export_step_ap242({box}, annotations);
|
|
|
|
EXPECT_NE(result.find("GEOMETRIC_TOLERANCE"), std::string::npos);
|
|
EXPECT_NE(result.find("DATUM_SYSTEM"), std::string::npos);
|
|
}
|
|
|
|
TEST(IndustrialStepAP242, ExportWithMaterial) {
|
|
auto box = make_test_box();
|
|
StepAP242Options opts;
|
|
opts.include_material = true;
|
|
opts.include_pmi = false;
|
|
|
|
std::string result = export_step_ap242({box}, {}, opts);
|
|
|
|
EXPECT_NE(result.find("MATERIAL_DESIGNATION"), std::string::npos);
|
|
EXPECT_NE(result.find("MATERIAL_PROPERTY"), std::string::npos);
|
|
}
|
|
|
|
TEST(IndustrialStepAP242, ExportWithoutPmi) {
|
|
auto box = make_test_box();
|
|
StepAP242Options opts;
|
|
opts.include_pmi = false;
|
|
opts.include_tolerance = false;
|
|
|
|
std::string result = export_step_ap242({box}, {}, opts);
|
|
|
|
// 不应包含 PMI 实体
|
|
EXPECT_EQ(result.find("PRODUCT_MANUFACTURING_INFORMATION"), std::string::npos);
|
|
// 但基本几何信息应存在
|
|
EXPECT_NE(result.find("CARTESIAN_POINT"), std::string::npos);
|
|
}
|
|
|
|
TEST(IndustrialStepAP242, ExportValidationProperties) {
|
|
auto box = make_test_box();
|
|
StepAP242Options opts;
|
|
opts.include_validation = true;
|
|
|
|
std::string result = export_step_ap242({box}, {}, opts);
|
|
EXPECT_NE(result.find("VALIDATION"), std::string::npos);
|
|
}
|
|
|
|
TEST(IndustrialStepAP242, ExportToFile) {
|
|
auto box = make_test_box();
|
|
const char* path = "/tmp/test_ap242.stp";
|
|
clean(path);
|
|
|
|
export_step_ap242_file(path, {box});
|
|
|
|
std::ifstream f(path);
|
|
ASSERT_TRUE(f.good());
|
|
std::string content((std::istreambuf_iterator<char>(f)), {});
|
|
EXPECT_NE(content.find("AP242"), std::string::npos);
|
|
|
|
clean(path);
|
|
}
|
|
|
|
TEST(IndustrialStepAP242, ExportToFileWithPMI) {
|
|
auto box = make_test_box();
|
|
const char* path = "/tmp/test_ap242_pmi.stp";
|
|
clean(path);
|
|
|
|
std::vector<StepPMIAnnotation> anns;
|
|
StepPMIAnnotation ann;
|
|
ann.type = "linear_dimension";
|
|
ann.id = "PMI1";
|
|
ann.nominal_value = 50.0;
|
|
anns.push_back(ann);
|
|
|
|
export_step_ap242_file(path, {box}, anns);
|
|
|
|
std::ifstream f(path);
|
|
std::string content((std::istreambuf_iterator<char>(f)), {});
|
|
EXPECT_NE(content.find("PRODUCT_MANUFACTURING_INFORMATION"), std::string::npos);
|
|
|
|
clean(path);
|
|
}
|
|
|
|
// ═══════════════════════════════════════════════════════════════
|
|
// PDF 3D 测试
|
|
// ═══════════════════════════════════════════════════════════════
|
|
|
|
TEST(IndustrialPDF3D, ExportBoxToPdf) {
|
|
auto box = make_test_box();
|
|
auto pdf_data = export_pdf3d(box);
|
|
|
|
EXPECT_GT(pdf_data.size(), 100u) << "PDF should have meaningful content";
|
|
|
|
// 检查 PDF 头部
|
|
std::string header(pdf_data.begin(), pdf_data.begin() + std::min(size_t(8), pdf_data.size()));
|
|
EXPECT_EQ(header, "%PDF-1.7");
|
|
}
|
|
|
|
TEST(IndustrialPDF3D, ExportContainsU3D) {
|
|
auto box = make_test_box();
|
|
auto pdf_data = export_pdf3d(box);
|
|
|
|
// 查找 U3D 标记
|
|
std::string content(pdf_data.begin(), pdf_data.end());
|
|
EXPECT_NE(content.find("U3D"), std::string::npos);
|
|
EXPECT_NE(content.find("/Subtype /U3D"), std::string::npos);
|
|
}
|
|
|
|
TEST(IndustrialPDF3D, ExportToFile) {
|
|
auto box = make_test_box();
|
|
const char* path = "/tmp/test_3d.pdf";
|
|
clean(path);
|
|
|
|
export_pdf3d_file(path, box);
|
|
|
|
std::ifstream f(path, std::ios::binary);
|
|
ASSERT_TRUE(f.good());
|
|
|
|
char magic[8] = {};
|
|
f.read(magic, 8);
|
|
EXPECT_EQ(std::string(magic, 8), "%PDF-1.7");
|
|
|
|
// 读取全部内容检查
|
|
f.seekg(0, std::ios::end);
|
|
auto size = f.tellg();
|
|
EXPECT_GT(size, 200) << "PDF file should be at least 200 bytes";
|
|
|
|
clean(path);
|
|
}
|
|
|
|
TEST(IndustrialPDF3D, ExportContains3DAnnotation) {
|
|
auto box = make_test_box();
|
|
auto pdf_data = export_pdf3d(box);
|
|
|
|
std::string content(pdf_data.begin(), pdf_data.end());
|
|
EXPECT_NE(content.find("/Subtype /3D"), std::string::npos);
|
|
EXPECT_NE(content.find("/3DA"), std::string::npos);
|
|
}
|
|
|
|
// ═══════════════════════════════════════════════════════════════
|
|
// 边界情况测试
|
|
// ═══════════════════════════════════════════════════════════════
|
|
|
|
TEST(IndustrialBoundary, ExportEmptyBrep) {
|
|
BrepModel empty;
|
|
// 导出空模型不应崩溃
|
|
EXPECT_NO_THROW(export_jt(empty, "/tmp/test_empty.jt"));
|
|
EXPECT_NO_THROW(export_parasolid_xt(empty, "/tmp/test_empty.x_t"));
|
|
EXPECT_NO_THROW(export_acis_sat(empty, "/tmp/test_empty.sat"));
|
|
|
|
clean("/tmp/test_empty.jt");
|
|
clean("/tmp/test_empty.x_t");
|
|
clean("/tmp/test_empty.sat");
|
|
}
|
|
|
|
TEST(IndustrialBoundary, StepAp242EmptyAnnotations) {
|
|
auto box = make_test_box();
|
|
std::vector<StepPMIAnnotation> empty_anns;
|
|
std::string result = export_step_ap242({box}, empty_anns);
|
|
// 不应崩溃，且应包含基本结构
|
|
EXPECT_NE(result.find("ISO-10303-21"), std::string::npos);
|
|
}
|