FreeCAD

1
# Script to create a Menger sponge
2
# (c) 2012 Werner Mayer LGPL
3

4
# The script is based on the work of daxmick at
5
# https://forum.freecad.org/viewtopic.php?f=3&t=2307
6

7
import threading
8
import Mesh
9

10
# Create a global mesh and make copies of them
11
# This makes the algorithm faster by ~60%.
12
box = Mesh.createBox(1,1,1)
13

14
# Create a Box and Place it a coords (x,y,z)
15
def PlaceBox(x,y,z):
16
   global box
17
   mbox=box.copy()
18
   mbox.translate(x,y,z)
19
   return mbox
20

21
def Sierpinski(level,x0,y0,z0):
22
   #print(threading.current_thread().name)
23
   boxnums = pow(3,level)
24
   thirds = boxnums / 3
25
   twothirds = thirds * 2
26
   if(level == 0):
27
      rangerx = [x0]
28
      rangery = [y0]
29
      rangerz = [z0]
30
   else:
31
      rangerx = [ x0, x0 + thirds, x0 + twothirds ]
32
      rangery = [ y0, y0 + thirds, y0 + twothirds ]
33
      rangerz = [ z0, z0 + thirds, z0 + twothirds ]
34
   block = 1
35
   skip=[5,11,13,14,15,17,23]
36
   mesh=Mesh.Mesh()
37
   for i in rangerx:
38
      for j in rangery:
39
         for k in rangerz:
40
            if block not in skip:
41
               if(level > 0):
42
                  mesh.addMesh(Sierpinski(level-1,i,j,k))
43
               else:
44
                  mesh.addMesh(PlaceBox(i,j,k))
45
            block+=1
46
   return mesh
47

48
### Multi-threaded ###
49

50
class MengerThread(threading.Thread):
51
    def __init__(self,args):
52
        self.args=args
53
        self.mesh=Mesh.Mesh()
54
        threading.Thread.__init__(self)
55
    def run(self):
56
        for i in self.args:
57
            self.mesh.addMesh(Sierpinski(*i))
58

59
def makeMengerSponge_mt(level=3,x0=0,y0=0,z0=0):
60
    """
61
    Is much slower than makeMengerSponge!!! :(
62
    """
63
    if level == 0:
64
        mesh=Sierpinski(level,x0,y0,z0)
65
        Mesh.show(mesh)
66
        return
67

68
    boxnums = pow(3,level)
69
    thirds = boxnums / 3
70
    twothirds = thirds * 2
71

72
    rangerx = [ x0, x0 + thirds, x0 + twothirds ]
73
    rangery = [ y0, y0 + thirds, y0 + twothirds ]
74
    rangerz = [ z0, z0 + thirds, z0 + twothirds ]
75
    block = 1
76
    skip=[5,11,13,14,15,17,23]
77

78
    # collect the arguments for the algorithm in a list
79
    args=[]
80
    for i in rangerx:
81
        for j in rangery:
82
            for k in rangerz:
83
                if block not in skip:
84
                    args.append((level-1,i,j,k))
85
                block+=1
86

87
    numJobs = 4
88
    threads=[]
89
    while numJobs > 0:
90
        size = len(args)
91
        count = size / numJobs
92
        numJobs-=1
93
        thr=MengerThread(args[:count])
94
        threads.append(thr)
95
        args=args[count:]
96

97
    print("Number of threads: %i" % (len(threads)))
98
    for thr in threads:
99
        thr.start()
100
    for thr in threads:
101
        thr.join()
102

103
    mesh=Mesh.Mesh()
104
    for thr in threads:
105
        mesh.addMesh(thr.mesh)
106
        del thr.mesh
107

108
    print(mesh)
109
    mesh.removeDuplicatedPoints()
110
    mesh.removeFacets(mesh.getInternalFacets())
111
    mesh.rebuildNeighbourHood()
112
    print("Mesh is solid: %s" % (mesh.isSolid()))
113
    Mesh.show(mesh)
114

115

116
### Single-threaded ###
117

118
def makeMengerSponge(level=3,x0=0,y0=0,z0=0):
119
    mesh=Sierpinski(level,x0,y0,z0)
120
    mesh.removeDuplicatedPoints()
121
    mesh.removeFacets(mesh.getInternalFacets())
122
    mesh.rebuildNeighbourHood()
123
    print("Mesh is solid: %s" % (mesh.isSolid()))
124
    Mesh.show(mesh)
125