cqfantasy 2.3.0__py3-none-any.whl

cqfantasy/arch/BasicArch.py

@@ -0,0 +1,117 @@
+# Copyright 2025 James Adams
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import math
+import cadquery as cq
+from cadqueryhelper import Base
+from . import arch
+
+
+class BasicArch(Base):
+    def __init__(self):
+        super().__init__()
+
+        # parameters
+        self.length:float = 30
+        self.width:float = 5
+        self.height:float = 75
+        self.outside_margin:float = 10
+        self.inside_margin:float = 5
+        
+        # shapes
+        self.outline:cq.Workplane|None = None
+        self.outside_outline:cq.Workplane|None = None
+        self.inside_outline:cq.Workplane|None = None
+        self.column_outline:cq.Workplane|None = None
+        
+    def calculate_column_height(self) -> float:
+        return (self.height)-self.length/2
+    
+    def calculate_perimeter(self) -> float:
+        perimeter = 2*math.pi*self.length/2
+        return perimeter
+    
+    def calculate_inside_perimeter(self) -> float:
+        perimeter = 2*math.pi*(self.length-self.inside_margin*2)/2
+        return perimeter
+    
+    def calculate_outside_perimeter(self) -> float:
+        perimeter = 2*math.pi*(self.length+self.outside_margin*2)/2
+        return perimeter
+        
+        
+    def make_outline(self):
+        self.outline = arch(
+            self.length, 
+            self.width, 
+            self.height
+        )
+        
+    def make_outside_outline(self):
+        self.outside_outline = arch(
+            self.length+self.outside_margin*2, 
+            self.width, 
+            self.height+self.outside_margin
+        ).translate((0,0,self.outside_margin/2))
+        
+    def make_inside_outline(self):
+        self.inside_outline = arch(
+            self.length-self.inside_margin*2, 
+            self.width, 
+            self.height-self.inside_margin
+        ).translate((0,0,-self.inside_margin/2))
+        
+    def make_column_outline(self):
+        height = self.calculate_column_height()
+        outline = (
+            cq.Workplane("XY")
+            .box(
+                self.length+self.outside_margin*2,
+                self.width,
+                height
+            )
+            .translate((0,0,-self.height/2+height/2))
+        )
+        self.column_outline = outline
+        
+    def make(self, parent=None):
+        super().make(parent)
+        self.make_outline()
+        self.make_outside_outline()
+        self.make_inside_outline()
+        self.make_column_outline()
+        
+    def build(self) -> cq.Workplane:
+        super().build()
+        scene = (
+            cq.Workplane("XY")
+        )
+
+        if self.outline:
+            scene = scene.add(self.outline)
+
+        if self.outside_outline:
+            scene = scene.add(self.outside_outline)
+
+        if self.inside_outline:
+            scene = scene.cut(self.inside_outline)
+
+        return scene
+    
+    def build_outline(self) -> cq.Workplane:
+        scene = cq.Workplane("XY")
+        
+        if self.outline:
+            scene = scene.union(self.outline)
+        return scene

cqfantasy/arch/StoneArch.py

@@ -0,0 +1,267 @@
+# Copyright 2025 James Adams
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import cadquery as cq
+from . import BasicArch, arch
+
+class StoneArch(BasicArch):
+    def __init__(self):
+        super().__init__()
+        
+        # parameters
+        self.stone_count:int = 8
+        self.stone_arch_count:int = 4
+        
+        self.stone_margin:float = .5
+        self.width_margin:float = .5
+        self.stone_modulus:int = 2
+        self.outside_stone_position:int = 0
+        self.stone_arch_modulus:int = 2
+        self.outside_stone_arch_position:int = 1
+        
+        # shapes
+        self.inside_stone:cq.Workplane|None = None
+        self.outside_stone:cq.Workplane|None = None
+        self.column_stones:cq.Workplane|None = None
+        
+        self.inside_arch_stone:cq.Workplane|None = None
+        self.outside_arch_stone:cq.Workplane|None = None
+        self.arch_stones:cq.Workplane|None = None
+        
+        self.margin_outline:cq.Workplane|None = None
+        self.outside_margin_outline:cq.Workplane|None = None
+        self.inside_margin_outline:cq.Workplane|None = None
+        
+    def calculate_stone_height(self) -> float:
+        column_height = self.calculate_column_height()
+        stone_height = column_height / self.stone_count
+        return stone_height
+    
+    def calculate_stone_margin_height(self) -> float:
+        stone_height = self.calculate_stone_height()
+        return stone_height - self.stone_margin
+    
+    def calculate_arch_stone_height(self) -> float:
+        perimeter = self.calculate_perimeter() / 2
+        height = perimeter / self.stone_arch_count
+        return height
+    
+    def calculate_arch_stone_margin_height(self) -> float:
+        height = self.calculate_arch_stone_height() 
+        return height - self.stone_margin
+    
+    def calculate_inside_arch_stone_height(self) -> float:
+        perimeter = self.calculate_inside_perimeter() / 2
+        height = perimeter / self.stone_arch_count
+        return height
+    
+    def calculate_inside_arch_stone_margin_height(self) -> float:
+        height = self.calculate_inside_arch_stone_height() 
+        return height - self.stone_margin
+    
+    def calculate_outside_arch_stone_height(self) -> float:
+        perimeter = self.calculate_outside_perimeter() / 2
+        height = perimeter / self.stone_arch_count
+        return height
+    
+    def calculate_outside_arch_stone_margin_height(self) -> float:
+        height = self.calculate_outside_arch_stone_height() 
+        return height - self.stone_margin
+        
+    def make_inside_stone(self):
+        stone_height = self.calculate_stone_margin_height()
+        self.inside_stone = cq.Workplane("XY").box(
+            self.inside_margin,
+            self.width,
+            stone_height
+        ).rotate((1,0,0),(0,0,0),90)
+        
+    def make_outside_stone(self):
+        stone_height = self.calculate_stone_margin_height()
+        length = self.inside_margin+self.outside_margin
+        self.outside_stone = cq.Workplane("XY").box(
+            length,
+            self.width,
+            stone_height
+        ).translate((-length/2+self.inside_margin/2,0,0)).rotate((1,0,0),(0,0,0),90)
+        
+    def make_column_stones(self):
+        def add_stone():
+            count = 0
+            def add_stone_count(loc:cq.Location) -> cq.Shape:
+                nonlocal count
+                stone = self.inside_stone
+                
+                if count % self.stone_modulus == self.outside_stone_position and self.outside_stone:
+                    stone = (
+                        self.outside_stone
+                        .translate((
+                            0,
+                            0,
+                            0)
+                        )
+                    )
+                count += 1
+                #log(f'test {count}')
+                return stone.val().located(loc) #type:ignore
+            return add_stone_count
+        
+        stone_height = self.calculate_stone_height()
+        
+        stones = (
+            cq.Workplane("XY")
+            .rarray(
+                xSpacing = stone_height, 
+                ySpacing = stone_height,
+                xCount = 1, 
+                yCount= self.stone_count, 
+                center = True)
+            .eachpoint(add_stone())
+        ).rotate((1,0,0),(0,0,0),90)
+        
+        self.column_stones = stones
+        
+    def make_margin_outline(self):
+        self.margin_outline = arch(
+            self.length-self.width_margin, 
+            self.width-self.width_margin*2, 
+            self.height
+        )
+        
+    def make_outside_margin_outline(self):
+        self.outside_margin_outline = arch(
+            self.length+self.outside_margin*2, 
+            self.width-self.width_margin*2,
+            self.height+self.outside_margin
+        ).translate((0,0,self.outside_margin/2))
+        
+    def make_inside_margin_outline(self):
+        self.inside_margin_outline = arch(
+            self.length-self.inside_margin*2+self.width_margin, 
+            self.width-self.width_margin*2, 
+            self.height-self.inside_margin
+        ).translate((0,0,-self.inside_margin/2))
+        
+    def make_inside_arch_stone(self):
+        height = self.calculate_arch_stone_margin_height()
+        inside_height = self.calculate_inside_arch_stone_margin_height()
+        
+        pts = [
+            (0,0),
+            (0,height),
+            (self.inside_margin,height-(height-inside_height)/2),
+            (self.inside_margin,(height-inside_height)/2)
+        ]
+        
+        stone = (
+            cq.Workplane("XZ")
+            .center(-self.inside_margin/2,-height/2)
+            .polyline(pts)
+            .close()
+            .extrude(self.width)
+            .translate((-self.length/2+self.inside_margin/2,self.width/2,0))
+        )
+        
+        self.inside_arch_stone = stone
+        
+    def make_outside_arch_stone(self):
+        length = self.inside_margin+self.outside_margin
+        height = self.calculate_outside_arch_stone_margin_height()
+        inside_height = self.calculate_inside_arch_stone_margin_height()
+        inside_length = self.length-self.inside_margin*2
+        
+        pts = [
+            (0,0),
+            (0,height),
+            (length,height-(height-inside_height)/2),
+            (length,(height-inside_height)/2)
+        ]
+        
+        stone = (
+            cq.Workplane("XZ")
+            .center(-length,-height/2)
+            .polyline(pts)
+            .close()
+            .extrude(self.width)
+            .translate((-inside_length/2,self.width/2,0))
+        )
+
+        self.outside_arch_stone = stone
+        
+    def make_arch_stones(self):
+        rotate_degrees = 180 / self.stone_arch_count
+        
+        arch_stones = cq.Workplane("XY")
+        for i in range(self.stone_arch_count+1):
+            stone = cq.Workplane("XY")
+
+            if self.inside_arch_stone:
+                stone = self.inside_arch_stone
+            
+            if i % self.stone_arch_modulus == self.outside_stone_arch_position:
+                stone = self.outside_arch_stone
+            
+            arch_stones.add(stone.rotate((0,1,0),(0,0,0),-rotate_degrees*i)) #type:ignore
+            
+        self.arch_stones = arch_stones
+    
+    def make(self, parent=None):
+        super().make(parent)
+        self.make_inside_stone()
+        self.make_outside_stone()
+        self.make_column_stones()
+        
+        self.make_margin_outline()
+        self.make_outside_margin_outline()
+        self.make_inside_margin_outline()
+        
+        self.make_inside_arch_stone()
+        self.make_outside_arch_stone()
+        self.make_arch_stones()
+        
+    def build(self) -> cq.Workplane:
+        super().build()
+        column_height = self.calculate_column_height()
+        
+        scene = (
+            cq.Workplane("XY")
+            #.add(self.outside_margin_outline)
+            #.add(self.inside_stone)
+            #.add(self.outside_stone)
+            #.add(self.inside_arch_stone)
+            #.add(self.outside_arch_stone)
+            #.add(self.column_outline)
+        )
+
+        if self.margin_outline:
+            scene = scene.add(self.margin_outline)
+
+        if self.inside_margin_outline:
+            scene = scene.cut(self.inside_margin_outline)
+
+        if self.column_stones:
+            scene = (
+                scene
+                .add(self.column_stones.translate((-self.length/2+self.inside_margin/2,0,-self.height/2+column_height/2)))
+                .add(self.column_stones.translate((-self.length/2+self.inside_margin/2,0,-self.height/2+column_height/2)).rotate((0,0,1),(0,0,0),180))
+            )
+
+        if self.arch_stones and self.column_outline:
+            arch_stones = (
+                self.arch_stones.translate((0,0,self.height/2-self.length/2))
+                .cut(self.column_outline)
+            )
+            scene = scene.add(arch_stones)
+
+        return scene

cqfantasy/arch/__init__.py

@@ -0,0 +1,3 @@
+from .arch import arch
+from .BasicArch import BasicArch
+from .StoneArch import StoneArch

cqfantasy/arch/arch.py

@@ -0,0 +1,32 @@
+# Copyright 2025 James Adams
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import cadquery as cq
+
+def arch(
+        length:float = 30, 
+        width:float = 5, 
+        height:float = 75
+    ) -> cq.Workplane:
+    if length > height:
+        raise Exception(f'{length=} is greater than {height=}')
+    cylinder = cq.Workplane("XZ").cylinder(width, length/2)
+    base = cq.Workplane("XY").box(length, width, height-length/2)
+    
+    combined_arch = (
+        base
+        .union(cylinder.translate((0,0,height/2-length/4)))
+        .translate((0,0,-length/4))
+    )
+    return combined_arch

cqfantasy/corner/AshlarCorner.py

@@ -0,0 +1,155 @@
+import cadquery as cq
+from cadqueryhelper import Base
+import math
+
+class AshlarCorner(Base):
+    def __init__(self):
+        super().__init__()
+        #parameter
+        self.length:float = 30
+        self.width:float = 30
+        self.height:float = 75
+        self.stone_height = 5
+        self.chamfer:float = 1
+        self.corner_cut_length:float|None = 3
+        self.corner_cut_width:float|None = 3
+        
+        #shapes
+        self.outline:cq.Workplane|None = None
+        self.small_stone = None
+        self.large_stone = None
+        self.stones = None
+        self.mirror_stones = None
+        self.corner_cut = None
+        
+        
+    def make_outline(self):
+        outline = cq.Workplane("XY").box(
+            self.length,
+            self.width,
+            self.height
+        )
+        
+        self.outline = outline
+        
+    def calculate_stone_count(self):
+        return math.floor(self.height / self.stone_height)
+    
+    def make_small_stone(self):
+        length = self.length / 2
+        width = self.width / 2
+        height = self.stone_height
+        small_stone = (
+            cq.Workplane("XY")
+            .box(length,width,height)
+            .translate((length/2,width/2,0))
+        )
+        
+        if self.chamfer:
+            small_stone = small_stone.chamfer(self.chamfer)
+            
+        self.small_stone = small_stone
+    
+    def make_large_stone(self):
+        length = self.length
+        width = self.width
+        height = self.stone_height
+        large_stone = cq.Workplane("XY").box(length,width,height)
+        
+        if self.chamfer:
+            large_stone = large_stone.chamfer(self.chamfer)
+            
+        self.large_stone = large_stone
+        
+    def make_corner_cut(self):
+        # cut stone
+        length = self.length / 2
+        width = self.width / 2
+        
+        if self.corner_cut_length:
+            length = self.length - self.corner_cut_length
+        
+        if self.corner_cut_width:
+            width = self.width - self.corner_cut_width
+        
+        height = self.height
+        x_translate = self.length/2 - length/2
+        y_translate = self.width/2 - width/2
+        
+        corner_cut = (
+            cq.Workplane("XY")
+            .box(length,width,height)
+            .translate((-x_translate,-y_translate,self.height/2))
+        )
+        
+        self.corner_cut = corner_cut
+    
+    def make_stones(self):
+        stones = cq.Workplane("XY")
+        stone_count = self.calculate_stone_count()
+        
+        for i in range(stone_count):
+            if i % 2 == 0:
+                stones = stones.add(self.large_stone.translate((0,0,i * self.stone_height)))
+            else:
+                stones = stones.add(self.small_stone.translate((0,0,i * self.stone_height)))
+            
+        self.stones = stones
+        
+    def make_mirror_stones(self):
+        stones = cq.Workplane("XY")
+        stone_count = self.calculate_stone_count()
+        small_length = self.length / 2
+        
+        for i in range(stone_count):
+            if i % 2 == 0:
+                stones = stones.add(self.large_stone.translate((0,0,i * self.stone_height)))
+            else:
+                stones = stones.add(self.small_stone.translate((-small_length,0,i * self.stone_height)))
+            
+        self.mirror_stones = stones
+        
+    def make(self):
+        super().make()
+        self.make_outline()
+        self.make_small_stone()
+        self.make_large_stone()
+        self.make_stones()
+        self.make_mirror_stones()
+        self.make_corner_cut()
+        
+    def build_outline(self)->cq.Workplane:
+        super().build()
+        
+        part = cq.Workplane("XY")
+        
+        if self.outline:
+            part = part.add(self.outline.translate((0,0,self.height/2)))
+        
+        return part
+        
+    def build(self)->cq.Workplane:
+        super().build()
+        
+        part = cq.Workplane("XY")
+        
+        if self.stones:
+            part = part.add(self.stones.translate((0,0,self.stone_height/2)))
+            
+        if self.corner_cut:
+            part = part.cut(self.corner_cut)
+        
+        return part.rotate((0,0,1),(0,0,0),180)
+    
+    def build_mirror(self)->cq.Workplane:
+        super().build()
+        
+        part = cq.Workplane("XY")
+        
+        if self.stones:
+            part = part.add(self.mirror_stones.translate((0,0,self.stone_height/2)))
+            
+        if self.corner_cut:
+            part = part.cut(self.corner_cut.translate((self.corner_cut_length,0,0)))
+        
+        return part.rotate((0,0,1),(0,0,0),180)

cqfantasy/corner/__init__.py

@@ -0,0 +1 @@
+from .AshlarCorner import AshlarCorner

cqfantasy/door/ArchDoor.py

@@ -0,0 +1,73 @@
+# Copyright 2025 James Adams
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import cadquery as cq
+from cadqueryhelper import Base
+from ..arch import StoneArch
+from . import VDoor
+
+class ArchDoor(Base):
+    def __init__(self):
+        super().__init__()
+        
+        self.length:float = 50
+        self.width:float = 7
+        self.height:float = 75
+        self.door_inset:float = 2
+        
+        #blueprints
+        self.bp_arch = StoneArch()
+        self.bp_arch.outside_margin = 5
+        self.bp_arch.outside_stone_position = 0
+        self.bp_arch.stone_arch_count = 6
+        self.bp_arch.stone_arch_modulus = 2
+        
+        self.bp_door = VDoor()
+        
+    def make_arch(self):
+        if self.bp_arch:
+            self.bp_arch.length = self.length
+            self.bp_arch.width = self.width
+            self.bp_arch.height = self.height
+            self.bp_arch.make()
+    
+    def make_door(self):
+        if self.bp_door:
+            self.bp_door.length = self.length - self.bp_arch.inside_margin*2
+            self.bp_door.width = self.width - self.door_inset
+            self.bp_door.height = self.height - self.bp_arch.inside_margin
+            self.bp_door.make()
+        
+    def make(self, parent=None):
+        super().make(parent)
+        self.make_arch()
+        self.make_door()
+        
+        
+    def build(self):
+        super().build()
+        scene = cq.Workplane("XY")
+        
+        if self.bp_arch:
+            ex_arch = self.bp_arch.build()
+            scene = scene.add(ex_arch)
+            
+        if self.bp_door:
+            ex_door = self.bp_door.build()
+            scene = scene.add(ex_door.translate((0,0,- self.bp_arch.inside_margin/2)))
+            
+        return scene
+    
+    def build_outline(self):
+        return self.bp_arch.build_outline()