BIM: ArchWindow, add unit tests
TODO: check comments on test_create_with_width_height_no_baseobj_initially
This commit is contained in:
Furgo
@@ -41,27 +41,6 @@ class TestArch(TestArchBase.TestArchBase):
|
||||
s = Arch.makeStructure(length=2,width=3,height=5)
|
||||
self.assertTrue(s,"BIM Structure failed")
|
||||
|
||||
def testWindow(self):
|
||||
operation = "Arch Window"
|
||||
_msg(" Test '{}'".format(operation))
|
||||
line = Draft.makeLine(App.Vector(0, 0, 0), App.Vector(3000, 0, 0))
|
||||
wall = Arch.makeWall(line)
|
||||
sk = App.ActiveDocument.addObject("Sketcher::SketchObject", "Sketch001")
|
||||
sk.Placement.Rotation = App.Rotation(App.Vector(1, 0, 0), 90)
|
||||
sk.addGeometry(Part.LineSegment(App.Vector( 500, 800, 0), App.Vector(1500, 800, 0)))
|
||||
sk.addGeometry(Part.LineSegment(App.Vector(1500, 800, 0), App.Vector(1500, 2000, 0)))
|
||||
sk.addGeometry(Part.LineSegment(App.Vector(1500, 2000, 0), App.Vector( 500, 2000, 0)))
|
||||
sk.addGeometry(Part.LineSegment(App.Vector( 500, 2000, 0), App.Vector( 500, 800, 0)))
|
||||
sk.addConstraint(Sketcher.Constraint('Coincident', 0, 2, 1, 1))
|
||||
sk.addConstraint(Sketcher.Constraint('Coincident', 1, 2, 2, 1))
|
||||
sk.addConstraint(Sketcher.Constraint('Coincident', 2, 2, 3, 1))
|
||||
sk.addConstraint(Sketcher.Constraint('Coincident', 3, 2, 0, 1))
|
||||
App.ActiveDocument.recompute()
|
||||
win = Arch.makeWindow(sk)
|
||||
Arch.removeComponents(win, host=wall)
|
||||
App.ActiveDocument.recompute()
|
||||
self.assertTrue(win, "'{}' failed".format(operation))
|
||||
|
||||
def testAxis(self):
|
||||
App.Console.PrintLog ('Checking Arch Axis...\n')
|
||||
a = Arch.makeAxis()
|
||||
|
||||
@@ -22,16 +22,629 @@
|
||||
# * *
|
||||
# ***************************************************************************
|
||||
|
||||
import Arch
|
||||
import FreeCAD
|
||||
from bimtests import TestArchBase
|
||||
import Arch
|
||||
import ArchWindow # For ArchWindow._Window proxy class
|
||||
import Part
|
||||
import Draft
|
||||
import Sketcher
|
||||
|
||||
class TestArchWindow(TestArchBase.TestArchBase):
|
||||
|
||||
def test_makeWindow(self):
|
||||
"""Test the makeWindow function."""
|
||||
operation = "Testing makeWindow function"
|
||||
self.printTestMessage(operation)
|
||||
def test_create_no_args(self):
|
||||
"""Test creating a window with no arguments."""
|
||||
window = Arch.makeWindow(name="Window_NoArgs")
|
||||
self.assertIsNotNone(window)
|
||||
self.assertTrue(hasattr(window, "Proxy") and isinstance(window.Proxy, ArchWindow._Window),
|
||||
"Window proxy is not of expected ArchWindow._Window type")
|
||||
self.assertEqual(window.Label, "Window_NoArgs")
|
||||
self.assertEqual(window.IfcType, "Window")
|
||||
self.assertIsNone(window.Base)
|
||||
self.assertEqual(len(window.WindowParts), 0)
|
||||
self.assertTrue(window.Shape.isNull())
|
||||
self.document.recompute()
|
||||
self.assertTrue(window.Shape.isNull())
|
||||
|
||||
window = Arch.makeWindow(width=1200, height=1000)
|
||||
self.assertIsNotNone(window, "makeWindow failed to create a window object.")
|
||||
self.assertEqual(window.Label, "Window", "Window label is incorrect.")
|
||||
def test_create_from_sketch_single_wire_default_parts(self):
|
||||
"""Test creating a window from a single-wire sketch, relying on default parts."""
|
||||
sketch = self._create_sketch_with_wires("SketchSingle", [(0, 0, 1000, 1200)])
|
||||
window = Arch.makeWindow(baseobj=sketch, name="Window_SketchSingle_Default")
|
||||
self.document.recompute()
|
||||
|
||||
self.assertEqual(window.Base, sketch)
|
||||
self.assertTrue(len(window.WindowParts) >= 5, "Should have at least one default part (5 elements).")
|
||||
self.assertEqual(window.WindowParts[0], "Default")
|
||||
self.assertEqual(window.WindowParts[1], "Solid panel", "Default part type incorrect for single-wire sketch.")
|
||||
self.assertIn("Wire0", window.WindowParts[2])
|
||||
self.assertFalse(window.Shape.isNull())
|
||||
self.assertGreater(len(window.Shape.Solids), 0)
|
||||
|
||||
def test_create_from_sketch_two_wires_default_parts(self):
|
||||
"""Test creating a window from two-wire sketch (concentric), relying on default parts."""
|
||||
sketch = self._create_sketch_with_wires("SketchTwoWires", [(0, 0, 1000, 1200), (100, 100, 800, 1000)])
|
||||
window = Arch.makeWindow(baseobj=sketch, name="Window_SketchTwo_Default")
|
||||
self.document.recompute()
|
||||
|
||||
self.assertEqual(window.Base, sketch)
|
||||
self.assertGreaterEqual(len(window.WindowParts), 5)
|
||||
self.assertEqual(window.WindowParts[0], "Default")
|
||||
self.assertEqual(window.WindowParts[1], "Frame", "Default type for multi-wire should be Frame.")
|
||||
self.assertIn("Wire0", window.WindowParts[2])
|
||||
self.assertIn("Wire1", window.WindowParts[2])
|
||||
self.assertFalse(window.Shape.isNull())
|
||||
self.assertGreater(len(window.Shape.Solids), 0)
|
||||
|
||||
def test_sketch_named_constraints_driven_by_window_props(self):
|
||||
"""Test that window Width/Height properties drive sketch's named constraints."""
|
||||
sketch_width, sketch_height = 800.0, 1000.0
|
||||
sketch = self._create_sketch_with_named_constraints("SketchNamed", sketch_width, sketch_height)
|
||||
|
||||
window = Arch.makeWindow(baseobj=sketch, name="Window_NamedSketch")
|
||||
# Set window Width/Height to ensure they become the drivers if sketch also has the constraints.
|
||||
# They need to be set explicitly after creating the window, as they are not automatically initialized
|
||||
# from the sketch.
|
||||
window.Width = sketch_width
|
||||
window.Height = sketch_height
|
||||
self.document.recompute()
|
||||
|
||||
self.assertEqual(sketch.getDatum("Width").Value, sketch_width)
|
||||
self.assertEqual(sketch.getDatum("Height").Value, sketch_height)
|
||||
|
||||
new_win_width = 1200.0
|
||||
window.Width = new_win_width
|
||||
self.document.recompute()
|
||||
self.assertEqual(sketch.getDatum("Width").Value, new_win_width, "Window.Width should drive sketch 'Width' constraint.")
|
||||
|
||||
new_win_height = 1500.0
|
||||
window.Height = new_win_height
|
||||
self.document.recompute()
|
||||
self.assertEqual(sketch.getDatum("Height").Value, new_win_height, "Window.Height should drive sketch 'Height' constraint.")
|
||||
|
||||
def test_create_from_sketch_with_custom_parts(self):
|
||||
"""Test creating a window from sketch with explicit custom parts."""
|
||||
sketch = self._create_sketch_with_wires("SketchCustom", [(0,0,1200,1000), (100,100,1000,800)])
|
||||
custom_parts = [
|
||||
"OuterFrame", "Frame", "Wire0,Wire1", "70", "0",
|
||||
"GlassPane", "Glass panel", "Wire1", "20", "25"
|
||||
]
|
||||
window = Arch.makeWindow(baseobj=sketch, parts=custom_parts, name="Window_Custom")
|
||||
self.document.recompute()
|
||||
|
||||
self.assertEqual(window.Base, sketch)
|
||||
self.assertEqual(list(window.WindowParts), custom_parts)
|
||||
self.assertFalse(window.Shape.isNull())
|
||||
self.assertEqual(len(window.Shape.Solids), 2, "Expected two solids for frame and glass.")
|
||||
|
||||
def test_custom_parts_with_plus_v_references(self):
|
||||
"""Test creating a window with custom parts using '+V' to reference window.Frame and window.Offset."""
|
||||
sketch = self._create_sketch_with_wires("SketchPlusV", [(0,0,1000,800)])
|
||||
frame_val = 60.0
|
||||
offset_val = 10.0
|
||||
|
||||
custom_parts_plus_v = [
|
||||
"MainFrame", "Frame", "Wire0", "50+V", "5+V"
|
||||
]
|
||||
window = Arch.makeWindow(baseobj=sketch, parts=custom_parts_plus_v, name="Window_PlusV")
|
||||
window.Frame = frame_val
|
||||
window.Offset = offset_val
|
||||
self.document.recompute()
|
||||
|
||||
self.assertFalse(window.Shape.isNull())
|
||||
self.assertGreater(len(window.Shape.Solids), 0)
|
||||
|
||||
def test_create_with_width_height_no_baseobj_initially(self):
|
||||
"""
|
||||
Test Arch.makeWindow(width, height) current behavior regarding window.Base.
|
||||
It verifies that window.Base is not automatically created and remains None,
|
||||
and that Width/Height properties are correctly set on the window object.
|
||||
"""
|
||||
win_w, win_h = 1000.0, 1200.0
|
||||
window_name = "Window_W_H_NoAutoBase"
|
||||
window = Arch.makeWindow(width=win_w, height=win_h, name=window_name)
|
||||
|
||||
# 1. Check initial state after makeWindow call
|
||||
self.assertEqual(window.Label, window_name)
|
||||
self.assertIsNone(window.Base,
|
||||
"Immediately after makeWindow(W,H), window.Base should be None.")
|
||||
self.assertTrue(window.Shape.isNull(),
|
||||
"Initially, window.Shape should be null as no Base or Parts yet.")
|
||||
self.assertAlmostEqual(window.Width.Value, win_w, places=5,
|
||||
msg="Window.Width property not correctly set by makeWindow.")
|
||||
self.assertAlmostEqual(window.Height.Value, win_h, places=5,
|
||||
msg="Window.Height property not correctly set by makeWindow.")
|
||||
|
||||
# 2. Perform a document recompute
|
||||
# This should trigger window.execute() -> ArchComponent.ensureBase()
|
||||
self.document.recompute()
|
||||
|
||||
# 3. Assert the CURRENT BEHAVIOR: window.Base remains None
|
||||
# The original ArchComponent.ensureBase does not create a sketch if Base is None
|
||||
# and only Width/Height are provided to the object.
|
||||
self.assertIsNone(window.Base,
|
||||
"Current Behavior: window.Base should remain None even after recomputes for makeWindow(W,H).")
|
||||
|
||||
# 4. Consequently, window.Shape should still be null.
|
||||
self.assertTrue(window.Shape.isNull(),
|
||||
"window.Shape should remain null if window.Base was not created.")
|
||||
|
||||
# 5. Attempting to set parts that rely on a Base sketch (e.g., "Wire0")
|
||||
# should not produce a shape if Base is None.
|
||||
window.WindowParts = ["Default", "Frame", "Wire0", "50", "0"]
|
||||
self.document.recompute()
|
||||
self.assertTrue(window.Shape.isNull(),
|
||||
"window.Shape should still be null if WindowParts reference Wire0 from a non-existent Base.")
|
||||
|
||||
def test_window_in_wall_creates_opening(self):
|
||||
"""
|
||||
Test if a window hosted in a wall creates a geometric opening,
|
||||
verifying changes in Volume and VerticalArea.
|
||||
Manually sets win.Width and win.Height after Arch.makeWindow(sk)
|
||||
as current Arch.makeWindow(sk) behavior does not initialize these
|
||||
properties from the sketch. It expects win.Placement to remain identity.
|
||||
"""
|
||||
# 1. Create Wall
|
||||
wall_length = 3000.0
|
||||
wall_thickness = 200.0
|
||||
wall_height = 2400.0
|
||||
|
||||
line = Draft.makeLine(FreeCAD.Vector(0, 0, 0), FreeCAD.Vector(wall_length, 0, 0))
|
||||
self.document.recompute()
|
||||
|
||||
wall = Arch.makeWall(line,
|
||||
width=wall_thickness,
|
||||
height=wall_height,
|
||||
align="Left",
|
||||
name="TestWall_ForOpening_Args")
|
||||
self.document.recompute()
|
||||
|
||||
initial_wall_volume = wall.Shape.Volume
|
||||
initial_wall_vertical_area = wall.VerticalArea.Value
|
||||
|
||||
# 2. Create Sketch for Window profile
|
||||
sketch_profile_width = 800.0
|
||||
sketch_profile_height = 1000.0
|
||||
sk = self._create_sketch_with_wires("WindowSketch_Args", [(0, 0, sketch_profile_width, sketch_profile_height)])
|
||||
|
||||
# Position and orient the sketch in 3D space
|
||||
sk.Placement.Rotation = FreeCAD.Rotation(FreeCAD.Vector(1, 0, 0), 90)
|
||||
win_global_x_start = (wall.Length.Value - sketch_profile_width) / 2
|
||||
win_global_z_start = 900.0
|
||||
sk.Placement.Base = FreeCAD.Vector(win_global_x_start, 0, win_global_z_start)
|
||||
self.document.recompute()
|
||||
|
||||
# 3. Create Window from sketch
|
||||
win = Arch.makeWindow(sk, name="WindowInWall_Args")
|
||||
|
||||
# Manually set Width and Height to match the sketch profile dimensions
|
||||
win.Width = sketch_profile_width
|
||||
win.Height = sketch_profile_height
|
||||
# win.Placement remains identity
|
||||
|
||||
win.HoleDepth = 0 # Use "smart" hole depth calculation
|
||||
win.WindowParts = ["DefaultFrame", "Frame", "Wire0", "60", "0"]
|
||||
|
||||
win.recompute()
|
||||
self.document.recompute()
|
||||
|
||||
self.assertFalse(win.Shape.isNull(), "Window must have a valid shape.")
|
||||
self.assertEqual(win.Placement, FreeCAD.Placement(),
|
||||
f"Window.Placement should be identity; got {win.Placement}")
|
||||
self.assertAlmostEqual(win.Width.Value, sketch_profile_width, 5)
|
||||
self.assertAlmostEqual(win.Height.Value, sketch_profile_height, 5)
|
||||
|
||||
|
||||
# 4. Add Window to Wall
|
||||
Arch.addComponents(win, host=wall)
|
||||
self.document.recompute()
|
||||
|
||||
# 5. Assertions
|
||||
# Wall.Subtractions PropertyLinkList check (informational, expected to be empty)
|
||||
wall_subtractions_prop = wall.Subtractions if hasattr(wall, "Subtractions") else []
|
||||
self.assertEqual(
|
||||
len(wall_subtractions_prop), 0,
|
||||
f"Wall.Subtractions property list expected to be empty, but: "
|
||||
f"{wall_subtractions_prop}"
|
||||
)
|
||||
|
||||
# Geometric checks
|
||||
current_wall_volume = wall.Shape.Volume
|
||||
self.assertLess(
|
||||
current_wall_volume, initial_wall_volume,
|
||||
f"Wall volume should decrease. Before: {initial_wall_volume}, "
|
||||
f"After: {current_wall_volume}"
|
||||
)
|
||||
|
||||
ideal_removed_volume = win.Width.Value * win.Height.Value * wall.Width.Value
|
||||
self.assertAlmostEqual(
|
||||
current_wall_volume, initial_wall_volume - ideal_removed_volume, places=3,
|
||||
msg=f"Wall volume cut not as expected. Initial: {initial_wall_volume}, "
|
||||
f"Current: {current_wall_volume}, IdealRemoved: {ideal_removed_volume}"
|
||||
)
|
||||
|
||||
# Check VerticalArea
|
||||
current_wall_vertical_area = wall.VerticalArea.Value
|
||||
|
||||
window_opening_area_on_one_face = win.Width.Value * win.Height.Value
|
||||
area_of_side_reveals = 2 * win.Height.Value * wall.Width.Value
|
||||
expected_wall_vertical_area_after = (initial_wall_vertical_area -
|
||||
(2 * window_opening_area_on_one_face) + area_of_side_reveals)
|
||||
|
||||
self.assertAlmostEqual(
|
||||
current_wall_vertical_area, expected_wall_vertical_area_after, places=3,
|
||||
msg=f"Wall VerticalArea change not as expected. Initial: "
|
||||
f"{initial_wall_vertical_area}, Current: {current_wall_vertical_area}, "
|
||||
f"ExpectedAfter: {expected_wall_vertical_area_after}"
|
||||
)
|
||||
|
||||
def test_clone_window(self):
|
||||
"""Test cloning an Arch.Window object.
|
||||
|
||||
Notes:
|
||||
- The clone's name is automatically generated, the `name` argument is ignored.
|
||||
- The clone's WindowParts, Sill and other properties are always empty, despite the original having them.
|
||||
|
||||
"""
|
||||
sketch = self._create_sketch_with_wires("OriginalSketch", [(0, 0, 600, 800)])
|
||||
original_parts = ["MainFrame", "Frame", "Wire0", "50", "10"]
|
||||
original_window = Arch.makeWindow(baseobj=sketch, parts=original_parts, name="OriginalWindow")
|
||||
original_window.Frame = 60.0
|
||||
original_window.Sill = 100.0
|
||||
self.document.recompute()
|
||||
|
||||
self.assertEqual(original_window.Label, "OriginalWindow")
|
||||
|
||||
cloned_window = Arch.makeWindow(baseobj=original_window)
|
||||
self.document.recompute()
|
||||
|
||||
self.assertIsNotNone(cloned_window)
|
||||
self.assertIsNotNone(cloned_window.CloneOf)
|
||||
self.assertEqual(cloned_window.CloneOf, original_window)
|
||||
|
||||
self.assertEqual(cloned_window.IfcType, original_window.IfcType)
|
||||
|
||||
self.assertFalse(cloned_window.Shape.isNull())
|
||||
self.assertAlmostEqual(cloned_window.Shape.Volume, original_window.Shape.Volume, delta=1e-5,
|
||||
msg="Cloned window volume should match original.")
|
||||
|
||||
def test_create_window_on_xz_plane(self):
|
||||
"""Test creating a window oriented on the XZ (vertical) plane."""
|
||||
sketch = self._create_sketch_with_wires("Sketch_XZ_Plane",
|
||||
[(0,0,1000,1200), (100,100,800,1000)])
|
||||
|
||||
sketch.Placement.Rotation = FreeCAD.Rotation(FreeCAD.Vector(1,0,0), 90)
|
||||
self.document.recompute()
|
||||
|
||||
window = Arch.makeWindow(baseobj=sketch, name="Window_XZ_Plane")
|
||||
window.WindowParts = [
|
||||
"Frame", "Frame", "Wire0,Wire1", "60", "0",
|
||||
"Glass", "Glass panel", "Wire1", "10", "25"
|
||||
]
|
||||
self.document.recompute()
|
||||
|
||||
self.assertFalse(window.Shape.isNull())
|
||||
self.assertGreater(len(window.Shape.Solids), 0)
|
||||
|
||||
expected_normal_y = 1.0
|
||||
|
||||
self.assertAlmostEqual(window.Normal.x, 0.0, places=5)
|
||||
self.assertAlmostEqual(window.Normal.y, expected_normal_y, places=5,
|
||||
msg=f"Window normal Y component incorrect. Expected approx {expected_normal_y}, got {window.Normal.y}")
|
||||
self.assertAlmostEqual(window.Normal.z, 0.0, places=5)
|
||||
|
||||
bb = window.Shape.BoundBox
|
||||
self.assertGreater(bb.XLength, bb.YLength,
|
||||
"Window XLength (width) should be greater than YLength (thickness).")
|
||||
self.assertGreater(bb.ZLength, bb.YLength,
|
||||
"Window ZLength (height) should be greater than YLength (thickness).")
|
||||
|
||||
def test_opening_property_rotates_component(self):
|
||||
"""Test that setting the Opening property rotates a hinged component."""
|
||||
# Create a window from a preset with a hinge
|
||||
window = Arch.makeWindowPreset("Open 1-pane", width=1000, height=1200,
|
||||
h1=50, h2=50, h3=0, w1=100, w2=50, o1=0, o2=50)
|
||||
self.document.recompute()
|
||||
|
||||
# The preset creates an outer frame, an inner opening frame, and glass.
|
||||
self.assertEqual(len(window.Shape.Solids), 3, "Preset should create three solids.")
|
||||
|
||||
# Solid[1] is the inner, opening frame.
|
||||
opening_pane = window.Shape.Solids[1]
|
||||
|
||||
# Get initial position
|
||||
initial_center = opening_pane.CenterOfMass
|
||||
|
||||
# Set opening to 50%. The 'Opening' property is App::PropertyPercent, which expects an integer.
|
||||
window.Opening = 50
|
||||
|
||||
self.document.recompute()
|
||||
|
||||
# Get new position of the same component
|
||||
new_opening_pane = window.Shape.Solids[1]
|
||||
new_center = new_opening_pane.CenterOfMass
|
||||
|
||||
# Assert that the Z-coordinate has changed, indicating rotation around a horizontal hinge.
|
||||
self.assertNotAlmostEqual(initial_center.z, new_center.z, places=3,
|
||||
msg="The Z-coordinate of the opening pane's center should change upon rotation.")
|
||||
# The Y-coordinate should remain largely unchanged for a bottom-hinged (awning-style) window.
|
||||
self.assertAlmostEqual(initial_center.y, new_center.y, places=3)
|
||||
|
||||
def test_symbol_plan_creates_wire_geometry(self):
|
||||
"""Test that enabling SymbolPlan adds 2D wire geometry to the window's shape."""
|
||||
# Create a window with an opening mode
|
||||
window = Arch.makeWindowPreset("Open 1-pane", width=1000, height=1200,
|
||||
h1=50, h2=50, h3=0, w1=100, w2=50, o1=0, o2=50)
|
||||
|
||||
# SymbolPlan is True by default for presets with hinges, but we set it explicitly
|
||||
window.SymbolPlan = True
|
||||
|
||||
self.document.recompute()
|
||||
|
||||
# Assert that the shape contains both solids and the 2D symbol edges.
|
||||
self.assertIsInstance(window.Shape, Part.Compound, "Window shape should be a compound.")
|
||||
|
||||
# Find symbol edges by finding edges that do not belong to any face in the shape
|
||||
face_edge_hashes = {e.hashCode() for face in window.Shape.Faces for e in face.Edges}
|
||||
all_edge_hashes = {e.hashCode() for e in window.Shape.Edges}
|
||||
symbol_edge_hashes = all_edge_hashes - face_edge_hashes
|
||||
|
||||
self.assertEqual(len(window.Shape.Solids), 3, "Window shape should contain 3 solids.")
|
||||
self.assertEqual(len(symbol_edge_hashes), 2, "Expected 2 edges for the plan symbol (arc and line).")
|
||||
|
||||
def test_custom_subvolume_creates_opening(self):
|
||||
"""Test that a custom Subvolume shape correctly creates an opening in a host wall."""
|
||||
# Create a wall and store its initial state
|
||||
wall_base = Draft.makeLine(FreeCAD.Vector(0,0,0), FreeCAD.Vector(4000,0,0))
|
||||
wall = Arch.makeWall(wall_base, width=200, height=3000, align="Left")
|
||||
self.document.recompute()
|
||||
initial_wall_volume = wall.Shape.Volume
|
||||
initial_wall_shape = wall.Shape.copy() # Store initial shape for accurate intersection calculation
|
||||
|
||||
# Create a simple window
|
||||
window_sketch = self._create_sketch_with_wires("WinSketch", [(0,0,10,10)])
|
||||
window = Arch.makeWindow(window_sketch)
|
||||
|
||||
# Create a custom cutting box as the window's Subvolume
|
||||
cutting_box = self.document.addObject("Part::Box", "CuttingBox")
|
||||
cutting_box.Length = 800
|
||||
cutting_box.Width = 300 # Wider than wall
|
||||
cutting_box.Height = 1000
|
||||
cutting_box.Placement.Base = FreeCAD.Vector(1600, -50, 800)
|
||||
self.document.recompute()
|
||||
|
||||
window.Subvolume = cutting_box
|
||||
|
||||
# Add window to wall to create opening using Arch.addComponents
|
||||
Arch.addComponents(window, host=wall)
|
||||
self.document.recompute()
|
||||
|
||||
# Assert volume has decreased by the intersecting part of the box's volume
|
||||
expected_volume_change = cutting_box.Shape.common(initial_wall_shape).Volume
|
||||
final_wall_volume = wall.Shape.Volume
|
||||
self.assertAlmostEqual(final_wall_volume, initial_wall_volume - expected_volume_change, places=3,
|
||||
msg="Wall volume did not decrease correctly after applying custom Subvolume.")
|
||||
|
||||
def test_door_preset_sets_ifctype_door(self):
|
||||
"""Test that creating a window from a 'door' preset correctly sets its IfcType to 'Door'."""
|
||||
# Create a door using a preset with non-zero values for all required parameters
|
||||
door = Arch.makeWindowPreset("Simple door", width=900, height=2100,
|
||||
h1=50, h2=50, h3=0, w1=100, w2=40, o1=0, o2=0)
|
||||
self.assertIsNotNone(door, "makeWindowPreset for a door should create an object.")
|
||||
self.document.recompute()
|
||||
|
||||
# Assert IfcType is "Door"
|
||||
self.assertEqual(door.IfcType, "Door", "IfcType should be 'Door' for a door preset.")
|
||||
|
||||
# Assert component count
|
||||
# A simple door preset has an outer frame and a solid door panel
|
||||
self.assertEqual(len(door.Shape.Solids), 2, "A simple door should have 2 solid components (frame and panel).")
|
||||
|
||||
def test_cloned_window_in_wall_creates_opening(self):
|
||||
"""Tests if a cloned Arch.Window, when hosted in a wall, creates a geometric opening."""
|
||||
|
||||
# Create the host wall
|
||||
wall_length = 3000.0
|
||||
wall_thickness = 200.0
|
||||
wall_height = 2500.0
|
||||
wall_base = Draft.makeLine(FreeCAD.Vector(0, 0, 0), FreeCAD.Vector(wall_length, 0, 0))
|
||||
wall = Arch.makeWall(wall_base, width=wall_thickness, height=wall_height, name="WallForClonedWindow")
|
||||
self.document.recompute()
|
||||
initial_wall_volume = wall.Shape.Volume
|
||||
self.assertGreater(initial_wall_volume, 0, "Wall should have a positive volume initially.")
|
||||
|
||||
# Create the original window's sketch
|
||||
window_width = 800.0
|
||||
window_height = 1200.0
|
||||
original_sketch = self._create_sketch_with_wires("OriginalWinSketch", [(0, 0, window_width, window_height)])
|
||||
|
||||
# Orient the sketch to be vertical before creating the window
|
||||
# This mimics the behavior of the interactive Arch_Window tool.
|
||||
original_sketch.Placement.Rotation = FreeCAD.Rotation(FreeCAD.Vector(1, 0, 0), 90)
|
||||
self.document.recompute()
|
||||
|
||||
# Create the original window from the now-oriented sketch
|
||||
original_window = Arch.makeWindow(baseobj=original_sketch, name="OriginalWindow")
|
||||
original_window.Width = window_width # Explicitly set properties
|
||||
original_window.Height = window_height
|
||||
self.document.recompute()
|
||||
self.assertFalse(original_window.Shape.isNull(), "Original window shape should not be null.")
|
||||
|
||||
# Create the clone
|
||||
cloned_window = Draft.clone(original_window)
|
||||
cloned_window.Label = "ClonedWindow"
|
||||
|
||||
# Position the clone inside the wall
|
||||
clone_x = 1100.0 # Center of the clone in the wall's length
|
||||
clone_y = wall_thickness / 2 # Center of the clone in the wall's thickness
|
||||
clone_z = 800.0 # Sill height
|
||||
cloned_window.Placement.Base = FreeCAD.Vector(clone_x, clone_y, clone_z)
|
||||
self.document.recompute()
|
||||
|
||||
self.assertIsNotNone(cloned_window.CloneOf, "Cloned window should have CloneOf property set.")
|
||||
self.assertEqual(cloned_window.CloneOf, original_window, "CloneOf should point to the original window.")
|
||||
self.assertAlmostEqual(cloned_window.Shape.Volume, original_window.Shape.Volume, delta=1e-5)
|
||||
|
||||
# Add the clone to the wall's hosts
|
||||
Arch.addComponents(cloned_window, host=wall)
|
||||
self.document.recompute()
|
||||
|
||||
self.assertIn(wall, cloned_window.Hosts, "Wall should be in the cloned window's Hosts list.")
|
||||
|
||||
final_wall_volume = wall.Shape.Volume
|
||||
self.assertLess(final_wall_volume, initial_wall_volume,
|
||||
"Wall volume should have decreased after hosting the cloned window.")
|
||||
|
||||
expected_removed_volume = window_width * window_height * wall.Width.Value
|
||||
self.assertAlmostEqual(initial_wall_volume - final_wall_volume, expected_removed_volume, delta=1e-5,
|
||||
msg="The volume removed from the wall by the cloned window is incorrect.")
|
||||
|
||||
def test_addComponents_window_to_wall(self):
|
||||
"""
|
||||
Tests the Arch.addComponents function for adding a window to a wall.
|
||||
Verifies that the Hosts, InList, and OutList properties are correctly
|
||||
updated, and that the geometric opening is created.
|
||||
"""
|
||||
self.printTestMessage("Testing Arch.addComponents for window-wall hosting...")
|
||||
|
||||
# Create the wall and window
|
||||
wall_base = Draft.makeLine(FreeCAD.Vector(0, 0, 0), FreeCAD.Vector(3000, 0, 0))
|
||||
wall = Arch.makeWall(wall_base, width=200, height=2500, name="HostWall")
|
||||
self.document.recompute()
|
||||
initial_wall_volume = wall.Shape.Volume
|
||||
|
||||
window_width = 800.0
|
||||
window_height = 1200.0
|
||||
window_sketch = self._create_sketch_with_wires("WindowSketchForAdd", [(0, 0, window_width, window_height)])
|
||||
window_sketch.Placement.Rotation = FreeCAD.Rotation(FreeCAD.Vector(1, 0, 0), 90)
|
||||
window_sketch.Placement.Base = FreeCAD.Vector(1100, 100, 800) # Position it within the wall
|
||||
self.document.recompute()
|
||||
|
||||
window = Arch.makeWindow(baseobj=window_sketch, name="HostedWindow")
|
||||
window.Width = window_width
|
||||
window.Height = window_height
|
||||
self.document.recompute()
|
||||
|
||||
# Initial state verification
|
||||
self.assertEqual(len(window.Hosts), 0, "Window.Hosts should be empty initially.")
|
||||
self.assertNotIn(window, wall.InList, "Window should not be in wall's InList initially.")
|
||||
|
||||
# Add the window to the wall
|
||||
Arch.addComponents(window, wall)
|
||||
self.document.recompute()
|
||||
|
||||
# Check all relationships and the final geometry
|
||||
# Property assertions
|
||||
self.assertIn(wall, window.Hosts, "Wall should be in window.Hosts after addComponents.")
|
||||
self.assertEqual(len(window.Hosts), 1, "Window.Hosts should contain exactly one host.")
|
||||
|
||||
# Dependency graph assertions
|
||||
self.assertIn(window, wall.InList, "Window should be in wall's InList after hosting.")
|
||||
self.assertIn(wall, window.OutList, "Wall should be in window's OutList after hosting.")
|
||||
|
||||
# Negative assertion
|
||||
self.assertNotIn(window, wall.Subtractions,
|
||||
"Window should not be in wall's Subtractions list for this hosting mechanism.")
|
||||
|
||||
# Geometric assertion
|
||||
final_wall_volume = wall.Shape.Volume
|
||||
self.assertLess(final_wall_volume, initial_wall_volume,
|
||||
"Wall volume should decrease after hosting the window.")
|
||||
|
||||
expected_removed_volume = window_width * window_height * wall.Width.Value
|
||||
self.assertAlmostEqual(initial_wall_volume - final_wall_volume, expected_removed_volume, delta=1e-5,
|
||||
msg="The volume removed from the wall is incorrect.")
|
||||
|
||||
def _create_sketch_with_wires(self, name: str, wire_definitions: list[tuple[float, float, float, float]]) -> "FreeCAD.DocumentObject":
|
||||
"""
|
||||
Helper to create a sketch with one or more specified rectangular wires.
|
||||
|
||||
Each rectangle is defined in the sketch's local XY plane. The sketch
|
||||
is created in the current document (`self.document`). After adding all
|
||||
geometry and basic coincident constraints for each rectangle, the
|
||||
document is recomputed.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
name : str
|
||||
The name for the new Sketcher.SketchObject.
|
||||
wire_definitions : list[tuple[float, float, float, float]]
|
||||
A list where each element defines one rectangular wire.
|
||||
Each tuple within the list should be in the format `(x, y, w, h)`:
|
||||
- `x` (float): The x-coordinate of the bottom-left corner of the rectangle
|
||||
in the sketch's local coordinate system.
|
||||
- `y` (float): The y-coordinate of the bottom-left corner of the rectangle
|
||||
in the sketch's local coordinate system.
|
||||
- `w` (float): The width of the rectangle (along the sketch's local X-axis).
|
||||
- `h` (float): The height of the rectangle (along the sketch's local Y-axis).
|
||||
For example, `[(0, 0, 100, 200)]` creates one 100x200 rectangle at the
|
||||
sketch origin. `[(0,0,100,100), (10,10,80,80)]` creates two concentric
|
||||
rectangles if used as outer and inner boundaries. The order of wires
|
||||
in this list corresponds to `Wire0`, `Wire1`, etc., when used by
|
||||
Arch objects. The sketch is recomputed and returned.
|
||||
|
||||
Returns
|
||||
-------
|
||||
FreeCAD.DocumentObject
|
||||
The created Sketcher object (specifically, an object of type "Sketcher::SketchObject").
|
||||
"""
|
||||
sketch: FreeCAD.DocumentObject = self.document.addObject("Sketcher::SketchObject", name)
|
||||
|
||||
for i, (x, y, w, h) in enumerate(wire_definitions):
|
||||
sketch.addGeometry(Part.LineSegment(FreeCAD.Vector(x, y, 0), FreeCAD.Vector(x + w, y, 0)))
|
||||
sketch.addGeometry(Part.LineSegment(FreeCAD.Vector(x + w, y, 0), FreeCAD.Vector(x + w, y + h, 0)))
|
||||
sketch.addGeometry(Part.LineSegment(FreeCAD.Vector(x + w, y + h, 0), FreeCAD.Vector(x, y + h, 0)))
|
||||
sketch.addGeometry(Part.LineSegment(FreeCAD.Vector(x, y + h, 0), FreeCAD.Vector(x, y, 0)))
|
||||
base_idx = i * 4
|
||||
sketch.addConstraint(Sketcher.Constraint('Coincident', base_idx, 2, base_idx + 1, 1))
|
||||
sketch.addConstraint(Sketcher.Constraint('Coincident', base_idx + 1, 2, base_idx + 2, 1))
|
||||
sketch.addConstraint(Sketcher.Constraint('Coincident', base_idx + 2, 2, base_idx + 3, 1))
|
||||
sketch.addConstraint(Sketcher.Constraint('Coincident', base_idx + 3, 2, base_idx, 1))
|
||||
|
||||
self.document.recompute()
|
||||
|
||||
return sketch
|
||||
|
||||
def _create_sketch_with_named_constraints(self, name: str, initial_width: float, initial_height: float) -> "FreeCAD.DocumentObject":
|
||||
"""
|
||||
Helper to create a rectangular sketch with "Width" and "Height" named constraints.
|
||||
|
||||
The sketch is created in the current document (`self.document`) on the
|
||||
default XY plane. It consists of a single rectangle defined by four
|
||||
line segments, with its bottom-left corner at (0,0,0) in the
|
||||
sketch's local coordinates.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
name : str
|
||||
The name for the new Sketcher.SketchObject.
|
||||
initial_width : float
|
||||
The initial value for the "Width" constraint (along sketch's X-axis).
|
||||
initial_height : float
|
||||
The initial value for the "Height" constraint (along sketch's Y-axis).
|
||||
|
||||
Returns
|
||||
-------
|
||||
FreeCAD.DocumentObject
|
||||
The created Sketcher object (specifically, an object of type "Sketcher::SketchObject").
|
||||
"""
|
||||
sketch: FreeCAD.DocumentObject = self.document.addObject("Sketcher::SketchObject", name)
|
||||
|
||||
sketch.addGeometry(Part.LineSegment(FreeCAD.Vector(0,0,0), FreeCAD.Vector(initial_width,0,0)), False)
|
||||
sketch.addGeometry(Part.LineSegment(FreeCAD.Vector(initial_width,0,0), FreeCAD.Vector(initial_width,initial_height,0)), False)
|
||||
sketch.addGeometry(Part.LineSegment(FreeCAD.Vector(initial_width,initial_height,0), FreeCAD.Vector(0,initial_height,0)), False)
|
||||
sketch.addGeometry(Part.LineSegment(FreeCAD.Vector(0,initial_height,0), FreeCAD.Vector(0,0,0)), False)
|
||||
sketch.addConstraint(Sketcher.Constraint('Coincident',0,2,1,1))
|
||||
sketch.addConstraint(Sketcher.Constraint('Coincident',1,2,2,1))
|
||||
sketch.addConstraint(Sketcher.Constraint('Coincident',2,2,3,1))
|
||||
sketch.addConstraint(Sketcher.Constraint('Coincident',3,2,0,1))
|
||||
sketch.addConstraint(Sketcher.Constraint('Horizontal',0)); sketch.addConstraint(Sketcher.Constraint('Vertical',1))
|
||||
sketch.addConstraint(Sketcher.Constraint('Horizontal',2)); sketch.addConstraint(Sketcher.Constraint('Vertical',3))
|
||||
|
||||
sketch.addConstraint(Sketcher.Constraint('DistanceX',0,1,0,2,initial_width))
|
||||
sketch.renameConstraint(sketch.ConstraintCount - 1, "Width")
|
||||
sketch.addConstraint(Sketcher.Constraint('DistanceY',1,1,1,2,initial_height))
|
||||
sketch.renameConstraint(sketch.ConstraintCount - 1, "Height")
|
||||
|
||||
self.document.recompute()
|
||||
|
||||
return sketch
|
||||
|
||||
Reference in New Issue
Block a user