第08章：CSG布尔运算与实体操作

public abstract class SolidOperation
{
    // 是否为挖空体（Subtract 操作）
    public bool IsVoid { get; set; }

    // 是否生成实心体（3D）还是仅生成面（2D 用于 Lamina）
    public bool IsSolid { get; set; }
}

public class Extrude : SolidOperation
{
    // 剖面/轮廓（可含空洞，定义拉伸的截面形状）
    public Profile Profile { get; set; }

    // 拉伸长度（单位：米）
    public double Extent { get; set; }

    // 拉伸方向（单位向量）
    public Vector3 Direction { get; set; }

    // 是否从剖面位置双向拉伸各一半
    public bool BothSides { get; set; }

    // 拉伸体的深度（通常由 Extent 和 Direction 决定）
    // 仅在需要通过深度而非 Extent 指定长度时使用
    public double Depth { get; set; }
}

// 一个 10m × 5m 的矩形楼板，厚 0.2m
var slabProfile = new Profile(
    Polygon.Rectangle(10.0, 5.0)
);

var slabExtrude = new Extrude(
    slabProfile,        // 截面
    0.2,               // 厚度（Extent）
    Vector3.ZAxis,     // 向上拉伸
    false              // 不双向
);

// 外径 0.5m，内径 0.4m 的圆管截面
var outerCircle = new Circle(Vector3.Origin, 0.5).ToPolygon(64);
var innerCircle = new Circle(Vector3.Origin, 0.4).ToPolygon(64);

var pipeProfile = new Profile(outerCircle, new[] { innerCircle });

var pipe = new Extrude(
    pipeProfile,
    10.0,
    Vector3.ZAxis,
    false
);

// 梁的截面宽 0.3m，高 0.6m，以定位线为中心双向拉伸
var beamProfile = new Profile(
    Polygon.Rectangle(0.3, 0.6)
);

var beamExtrude = new Extrude(
    beamProfile,
    6.0,                  // 总长度 6m
    Vector3.XAxis,        // 沿 X 轴
    true                  // 双向各拉 3m
);

public class Sweep : SolidOperation
{
    // 截面轮廓
    public Profile Profile { get; set; }

    // 扫描路径（任意曲线）
    public Curve Curve { get; set; }

    // 沿路径起始位置回退的距离
    public double StartSetback { get; set; }

    // 沿路径终止位置回退的距离
    public double EndSetback { get; set; }

    // 扫描的子分段数（控制曲面精度）
    public int Segments { get; set; }
}

// 90° 弧线，半径 3m
var arc = new Arc(
    Vector3.Origin,
    3.0,
    0.0,                    // 起始角 0°
    Math.PI / 2            // 终止角 90°
);

// 圆形截面，半径 0.1m
var section = new Profile(
    new Circle(Vector3.Origin, 0.1).ToPolygon(32)
);

var sweep = new Sweep(
    section,
    arc,
    0,                      // 无起始退距
    0                       // 无终止退距
);

// 直线路径，但在两端各退 0.05m（给连接件留空间）
var pipeLine = new Line(
    new Vector3(0, 0, 3),
    new Vector3(8, 0, 3)
);

var pipeSection = new Profile(
    new Circle(Vector3.Origin, 0.15).ToPolygon(32)
);

var pipeSweep = new Sweep(
    pipeSection,
    pipeLine,
    0.05,                   // 起始退距
    0.05                    // 终止退距
);

public class Lamina : SolidOperation
{
    // 层板的外围轮廓
    public Polygon Perimeter { get; set; }

    // 层板内的空洞
    public IList<Polygon> Voids { get; set; }
}

// 2m × 3m 的矩形面板
var panelOutline = Polygon.Rectangle(2.0, 3.0);

// 中间的圆形孔洞
var hole = new Circle(Vector3.Origin, 0.3).ToPolygon(32);

var lamina = new Lamina(panelOutline, new[] { hole });

// 普通拉伸：生成一个实心方块
var solidBlock = new Extrude(
    new Profile(Polygon.Rectangle(1, 1)),
    1.0,
    Vector3.ZAxis,
    false
)
{
    IsVoid = false    // 默认值，生成实体材料
};

// 挖空拉伸：从其他实体中切除这个形状
var voidBlock = new Extrude(
    new Profile(Polygon.Rectangle(0.5, 0.5)),
    1.0,
    Vector3.ZAxis,
    false
)
{
    IsVoid = true     // 标记为挖空，用于开洞
};

var wall = new Wall(
    new Line(new Vector3(0, 0, 0), new Vector3(5, 0, 0)),
    new Profile(Polygon.Rectangle(0.2, 3.0)),
    3.0
);

// 在墙上开一个 1m 宽 × 2.1m 高的门洞
var doorOpening = new Opening(
    Polygon.Rectangle(1.0, 2.1),    // 门洞轮廓
    0.2,                             // 深度（略大于墙厚）
    new Transform(2.0, 0, 0)         // 位于墙的中间
);

// Opening 内部会自动创建 IsVoid=true 的 Extrude

var floor = new Floor(
    Polygon.Rectangle(6.0, 8.0),
    0.2
);

// 在楼板上方创建一个天窗开洞
var skylightOpening = new Opening(
    Polygon.Rectangle(1.5, 1.5),
    0.3,                              // 深度略大于楼板厚度
    new Transform(3.0, 4.0, 0.05)     // 中心位置，略高于楼板表面
);

public class StuccoWall : Wall
{
    public override void UpdateRepresentations()
    {
        Representation = new Representation();

        // 操作 1：混凝土核心（180mm 厚）
        var core = new Extrude(
            new Profile(Polygon.Rectangle(0.18, 3.0)),
            CenterLine.Length(),
            CenterLine.Direction().Unitized(),
            false
        )
        { IsVoid = false };

        // 操作 2：外饰面层（20mm 厚），向外偏移 90mm
        var exteriorFinish = new Extrude(
            new Profile(Polygon.Rectangle(0.02, 3.0)),
            CenterLine.Length(),
            CenterLine.Direction().Unitized(),
            false
        )
        {
            IsVoid = false,
            // 需要配合 Transform 偏移到混凝土外侧
        };

        // 操作 3：内饰面层（20mm 厚）
        var interiorFinish = new Extrude(
            new Profile(Polygon.Rectangle(0.02, 3.0)),
            CenterLine.Length(),
            CenterLine.Direction().Unitized(),
            false
        )
        {
            IsVoid = false,
            // 需要配合 Transform 偏移到混凝土内侧
        };

        Representation.SolidOperations.AddRange(
            new SolidOperation[] { core, exteriorFinish, interiorFinish }
        );
    }
}

// 以下两种写法效果完全相同

// 写法 A：先实体后挖空
Representation.SolidOperations.Add(beamExtrude);   // IsVoid = false
Representation.SolidOperations.Add(holeVoid);      // IsVoid = true

// 写法 B：先挖空后实体
Representation.SolidOperations.Add(holeVoid);      // IsVoid = true
Representation.SolidOperations.Add(beamExtrude);   // IsVoid = false

// 创建一个空心柱的 Representation
var rep = new Representation();

// 操作 1：实心方形柱（0.3m × 0.3m × 3m）
var solidColumn = new Extrude(
    new Profile(Polygon.Rectangle(0.3, 0.3)),
    3.0,
    Vector3.ZAxis,
    false
)
{ IsVoid = false };

// 操作 2：内部的圆形挖空（直径 0.2m）
var innerVoid = new Extrude(
    new Profile(new Circle(Vector3.Origin, 0.1).ToPolygon(32)),
    3.0,
    Vector3.ZAxis,
    false
)
{ IsVoid = true };

// 注意：挖空的截面圆心在 (0,0)，柱的矩形也以 (0,0) 为中心
// 如果要对齐到柱的中心，两者需要在同一局部坐标空间

rep.SolidOperations.Add(solidColumn);
rep.SolidOperations.Add(innerVoid);

public static class SolidOperationUtils
{
    public static Csg.Solid GetFinalCsgFromSolids(
        IList<SolidOperation> solidOperations,
        out Csg.Solid consolidatedSolid,
        out List<Csg.Solid> voidSolids
    );
}

using Elements.Geometry.Solids;

// 创建操作列表
var operations = new List<SolidOperation>
{
    new Extrude(
        new Profile(Polygon.Rectangle(10, 10)),
        0.5,
        Vector3.ZAxis,
        false
    )
    { IsVoid = false },  // 实心楼板

    new Extrude(
        new Profile(new Circle(Vector3.Origin, 1.0).ToPolygon(32)),
        1.0,
        Vector3.ZAxis,
        false
    )
    { IsVoid = true }    // 楼板上的圆洞
};

// 手动执行 CSG 计算
var finalSolid = SolidOperationUtils.GetFinalCsgFromSolids(
    operations,
    out var consolidated,  // Union 后的正形体（本例中就是楼板本身）
    out var voids          // 所有挖空体的列表
);

// finalSolid 就是"带圆洞的楼板"的精确 CSG 实体

using Elements.Geometry;

// 方法 1：从 Elements Solid 转换
var elementsSolid = Solid.SweptSolid(profile, curve);
var csgSolid = elementsSolid.ToCsg();

// 方法 2：Csg.Solid 自身的布尔运算
var cubeA = Csg.Solid.CreateCube(size: 1.0, center: true);
var cubeB = new Csg.Solid().Translate(0.5, 0.5, 0);
var result = cubeA.Union(cubeB);

// 方法 3：转回 Elements Solid 用于后续操作
var backToElements = new Solid(csgSolid);

// 不要这样比较
if (a.X == b.X) { ... }

// 应该这样比较
if (Math.Abs(a.X - b.X) < Vector3.EPSILON) { ... }

// 或者使用 Elements 提供的方法
if (a.IsAlmostEqualTo(b)) { ... }

// 在距离原点 100 公里处创建一个精密的 1mm 细节
var farAway = new Vector3(100000, 100000, 0);
var tinyHole = new Circle(farAway, 0.001).ToPolygon(64);
// 这个圆孔可能因为精度问题被 CSG 引擎忽略

// 在局部坐标 (0, 0, 0) 处创建模型
var localHole = new Circle(Vector3.Origin, 0.001).ToPolygon(64);
// 用元素的 Transform 将它放到远处
var beam = new Beam(...)
{
    Transform = new Transform(100000, 100000, 0)
};

public class ConstructedSolid : SolidOperation
{
    // 子 SolidOperation 列表
    public IList<SolidOperation> SolidOperations { get; set; }
}

// 创建一个复杂的"组合柱"：方形截面 + 内部圆管 + 四角倒角
var constructedSolid = new ConstructedSolid
{
    SolidOperations = new List<SolidOperation>()
};

// 子操作 1：方形柱体
var squareColumn = new Extrude(
    new Profile(Polygon.Rectangle(0.3, 0.3)),
    3.0,
    Vector3.ZAxis,
    false
)
{ IsVoid = false };

// 子操作 2：内部圆形空洞
var innerTube = new Extrude(
    new Profile(new Circle(Vector3.Origin, 0.08).ToPolygon(32)),
    3.0,
    Vector3.ZAxis,
    false
)
{ IsVoid = true };

// 子操作 3：四角倒角（四分之一圆弧，中心在角落，用圆柱减去）
// 为了简化，这里用一个小的方形挖空模拟
var chamfer = new Extrude(
    new Profile(Polygon.Rectangle(0.05, 0.05)),
    3.0,
    Vector3.ZAxis,
    false
)
{ IsVoid = true };

constructedSolid.SolidOperations.Add(squareColumn);
constructedSolid.SolidOperations.Add(innerTube);
constructedSolid.SolidOperations.Add(chamfer);

// 将 ConstructedSolid 作为整体添加到元素的 Representation 中
var columnRep = new Representation();
columnRep.SolidOperations.Add(constructedSolid);

using Elements;
using Elements.Geometry;
using Elements.Geometry.Solids;

var model = new Model();

// --- 墙体 ---
var wallProfile = new Profile(Polygon.Rectangle(0.2, 3.0));
var wall = new Wall(
    new Line(new Vector3(0, 0, 0), new Vector3(6, 0, 0)),
    wallProfile,
    3.0
)
{ Name = "南向外墙" };
model.AddElement(wall);

// --- 门洞 ---
var doorOpening = new Opening(
    Polygon.Rectangle(1.0, 2.1),    // 1m 宽 × 2.1m 高
    0.3,                             // 深度（略大于墙厚 0.2m）
    new Transform(1.5, 0, 0)        // 距离墙起点 1.5m
);
model.AddElement(doorOpening);

// --- 窗洞 ---
var windowOpening = new Opening(
    Polygon.Rectangle(1.2, 1.5),    // 1.2m 宽 × 1.5m 高
    0.3,                              // 深度
    new Transform(4.0, 0, 1.0)      // 距离墙起点 4m，窗台高度 1m
);
model.AddElement(windowOpening);

// 导出
model.ToGlTF("wall_with_openings.glb");

var model = new Model();

// --- 楼板：8m × 6m，厚 0.2m ---
var floor = new Floor(
    Polygon.Rectangle(8.0, 6.0),
    0.2
)
{ Name = "顶层楼板" };
model.AddElement(floor);

// --- 矩形天窗开洞 1：2m × 1.5m ---
var skylight1 = new Opening(
    Polygon.Rectangle(2.0, 1.5),
    0.3,
    new Transform(2.5, 3.0, 0.05)
);
model.AddElement(skylight1);

// --- 矩形天窗开洞 2：2m × 1.5m ---
var skylight2 = new Opening(
    Polygon.Rectangle(2.0, 1.5),
    0.3,
    new Transform(5.5, 3.0, 0.05)
);
model.AddElement(skylight2);

// --- 圆形天窗开洞 ---
var skylight3 = new Opening(
    new Circle(Vector3.Origin, 0.8).ToPolygon(32),
    0.3,
    new Transform(4.0, 1.5, 0.05)
);
model.AddElement(skylight3);

model.ToGlTF("floor_with_skylights.glb");

using Elements;
using Elements.Geometry;
using Elements.Geometry.Solids;

var model = new Model();

// 定义空心柱：外方内圆
// 我们需要手动构建 Representation，因为标准 Column 只支持实心
var hollowColumn = new Column(
    new Vector3(5, 5, 0),      // 柱底位置
    4.0,                       // 高度 4m
    new Profile(Polygon.Rectangle(0.5, 0.5)),  // 外部 500mm × 500mm
    0.0                        // 底部偏移
)
{ Name = "设备竖井" };

// 手动添加内部挖空操作
// 注意：需要在构造后修改 Representation
hollowColumn.Representation = new Representation();

// 外部实心方柱
hollowColumn.Representation.SolidOperations.Add(
    new Extrude(
        new Profile(Polygon.Rectangle(0.5, 0.5)),
        4.0,
        Vector3.ZAxis,
        false
    )
    { IsVoid = false }
);

// 内部圆形挖空（直径 0.3m），偏移到方柱中心
var innerVoidProfile = new Profile(
    new Circle(Vector3.Origin, 0.15).ToPolygon(32)
);

hollowColumn.Representation.SolidOperations.Add(
    new Extrude(
        innerVoidProfile,
        4.0,
        Vector3.ZAxis,
        false
    )
    { IsVoid = true }
);

model.AddElement(hollowColumn);
model.ToGlTF("hollow_column.glb");

using Elements;
using Elements.Geometry;
using Elements.Geometry.Solids;

var model = new Model();

// --- 墙体：5m 长，0.3m 厚，3m 高 ---
var wallProfile = new Profile(Polygon.Rectangle(0.3, 3.0));
var wall = new Wall(
    new Line(new Vector3(0, 0, 0), new Vector3(5, 0, 0)),
    wallProfile,
    3.0
)
{ Name = "装饰壁龛墙" };
model.AddElement(wall);

// --- 创建壁龛（不贯穿的挖空）---
// 三个等距的壁龛，深度 0.15m（墙的一半深），不贯穿
for (int i = 0; i < 3; i++)
{
    var nicheX = 1.0 + i * 1.5;  // 间距 1.5m
    var nicheProfile = Polygon.Rectangle(0.6, 0.8);  // 0.6m 宽 × 0.8m 高

    var niche = new Opening(
        nicheProfile,
        0.15,                           // 深度 0.15m，不贯穿 0.3m 的墙
        new Transform(nicheX, -0.05, 1.2)  // 在前面板上，距地 1.2m
    );
    model.AddElement(niche);
}

model.ToGlTF("wall_with_niches.glb");

using Elements;
using Elements.Geometry;
using Elements.Geometry.Solids;

var model = new Model();

// --- 圆柱形塔身：半径 3m，高 12m ---
var towerProfile = new Profile(
    new Circle(Vector3.Origin, 3.0).ToPolygon(64)
);

var towerExtrude = new Extrude(
    towerProfile,
    12.0,
    Vector3.ZAxis,
    false
);

// 手动创建元素
var towerBody = new Mass(towerProfile, 12.0)
{ Name = "圆形塔楼" };
model.AddElement(towerBody);

// --- 弧形窗（多排）---
var windowWidth = 1.2;           // 窗宽（弧长方向）
var windowHeight = 2.0;          // 窗高
var windowArc = 1.2 / 3.0;       // 窗弧对应的弧度（弧长 / 半径）
var radius = 2.8;                // 窗的位置半径（略小于塔的 3m）

for (int floor = 0; floor < 5; floor++)
{
    var height = 1.5 + floor * 2.5;    // 第 0 层距地 1.5m

    for (int i = 0; i < 8; i++)
    {
        var startAngle = i * Math.PI / 4;  // 8 扇窗均匀分布 360°

        // 创建弧形窗的扫掠路径
        var windowArcPath = new Arc(
            new Vector3(0, 0, height),
            radius,
            startAngle,                 // 起始角
            startAngle + windowArc      // 终止角
        );

        // 窗的截面轮廓（矩形）
        var windowSection = new Profile(
            Polygon.Rectangle(0.3, windowHeight)  // 深 0.3m，高 2m
        );

        // 创建弧形窗的 Sweep（IsVoid = true）
        var windowVoid = new Sweep(
            windowSection,
            windowArcPath,
            0,
            0
        )
        { IsVoid = true };

        // 将挖空 Sweep 直接添加到塔身的 Representation
        towerBody.Representation.SolidOperations.Add(windowVoid);
    }
}

// 重新计算几何
towerBody.UpdateBoundsAndComputeSolid();

model.ToGlTF("circular_tower_with_windows.glb");

using Elements;
using Elements.Geometry;
using Elements.Geometry.Solids;

var model = new Model();

// --- 创建楼梯的 ConstructedSolid ---
var staircase = new ConstructedSolid
{
    SolidOperations = new List<SolidOperation>()
};

// 子操作 1：楼梯侧板（左）
var leftStringer = new Extrude(
    new Profile(Polygon.Rectangle(0.15, 1.0)),
    6.0,                                    // 6m 长的侧板
    new Vector3(1, 0, 1).Unitized(),        // 沿 45° 斜向上
    false
)
{ IsVoid = false };

// 子操作 2：楼梯侧板（右）
var rightStringer = new Extrude(
    new Profile(Polygon.Rectangle(0.15, 1.0)),
    6.0,
    new Vector3(1, 0, 1).Unitized(),
    false
)
{ IsVoid = false };

// 子操作 3：踏步（简化为一个整体斜面）
var treadSlab = new Extrude(
    new Profile(Polygon.Rectangle(1.2, 1.0)),
    6.0,
    new Vector3(1, 0, 1).Unitized(),
    false
)
{ IsVoid = false };

// 子操作 4：扶手（用 Sweep 沿着楼梯扶手线）
var handrailPath = new Line(
    new Vector3(0, -0.65, 0.9),
    new Vector3(6, -0.65, 6.9)
);

var handrailProfile = new Profile(
    new Circle(Vector3.Origin, 0.04).ToPolygon(16)
);

var handrail = new Sweep(
    handrailProfile,
    handrailPath,
    0.1,                     // 起始退距
    0.1                      // 终止退距
)
{ IsVoid = false };

staircase.SolidOperations.Add(leftStringer);
staircase.SolidOperations.Add(rightStringer);
staircase.SolidOperations.Add(treadSlab);
staircase.SolidOperations.Add(handrail);

// 将 ConstructedSolid 添加到元素
var stairElement = new Mass(
    new Profile(Polygon.Rectangle(1.3, 6.0)),
    4.0
)
{ Name = "楼梯-ConstructedSolid", };
stairElement.Representation = new Representation();
stairElement.Representation.SolidOperations.Add(staircase);

model.AddElement(stairElement);
model.ToGlTF("staircase_constructed.glb");