1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
|
"""
This page is in the table of contents.
The slc.py script is an import translator plugin to get a carving from an slc file.
An import plugin is a script in the import_plugins folder which has the function getCarving. It is meant to be run from the interpret tool. To ensure that the plugin works on platforms which do not handle file capitalization properly, give the plugin a lower case name.
The getCarving function takes the file name of an slc file and returns the carving.
This example gets a triangle mesh for the slc file rotor.slc. This example is run in a terminal in the folder which contains rotor.slc and slc.py.
> python
Python 2.5.1 (r251:54863, Sep 22 2007, 01:43:31)
[GCC 4.2.1 (SUSE Linux)] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> import slc
>>> slc.getCarving()
0.20000000298, 999999999.0, -999999999.0, [8.72782748851e-17, None
..
many more lines of the carving
..
An explanation of the SLC format can be found at:
http://rapid.lpt.fi/archives/rp-ml-1999/0713.html
"""
from __future__ import absolute_import
#Init has to be imported first because it has code to workaround the python bug where relative imports don't work if the module is imported as a main module.
import __init__
from skeinforge_tools.skeinforge_utilities.vector3 import Vector3
from skeinforge_tools.skeinforge_utilities import euclidean
from skeinforge_tools.skeinforge_utilities import gcodec
from struct import unpack
import sys
__author__ = "Enrique Perez (perez_enrique@yahoo.com)"
__credits__ = 'Nophead <http://hydraraptor.blogspot.com/>\nArt of Illusion <http://www.artofillusion.org/>'
__date__ = "$Date: 2008/21/04 $"
__license__ = "GPL 3.0"
def getCarving( fileName = '' ):
"Get the triangle mesh for the slc file."
if fileName == '':
unmodified = gcodec.getFilesWithFileTypeWithoutWords( 'slc' )
if len( unmodified ) == 0:
print( "There is no slc file in this folder." )
return None
fileName = unmodified[ 0 ]
carving = SLCCarving()
carving.readFile( fileName )
return carving
def getLittleEndianFloatGivenFile( file ):
"Get little endian float given a file."
return unpack( '<f', file.read( 4 ) )[ 0 ]
def getLittleEndianUnsignedLongGivenFile( file ):
"Get little endian float given a file."
return unpack( '<L', file.read( 4 ) )[ 0 ]
def getPointsFromFile( numPoints, file ):
"Process the vertice points for a given boundary."
points = []
for pointIndex in xrange( numPoints ):
x = getLittleEndianFloatGivenFile( file )
y = getLittleEndianFloatGivenFile( file )
points.append( complex( x, y ) )
return points
def readHeader( file ):
"Read the slc header."
while ord( file.read( 1 ) ) != 0x1A:
pass
class SampleTableEntry:
"Sample table entry."
def __init__( self, file ):
"Read in the sampling table section. It contains a table length (byte) and the table entries."
self.min_z_level = getLittleEndianFloatGivenFile( file )
self.layer_thickness = getLittleEndianFloatGivenFile( file )
self.beam_comp = getLittleEndianFloatGivenFile( file )
getLittleEndianFloatGivenFile( file )
def __repr__( self ):
"Get the string representation of this sample table entry."
return '%s, %s, %s' % ( self.min_z_level, self.layer_thickness, self.beam_comp )
class SLCCarving:
"An slc carving."
def __init__( self ):
"Add empty lists."
self.maximumZ = - 999999999.0
self.minimumZ = 999999999.0
self.layerThickness = None
self.rotatedBoundaryLayers = []
def __repr__( self ):
"Get the string representation of this carving."
return '%s, %s, %s, %s' % ( self.layerThickness, self.minimumZ, self.maximumZ, self.rotatedBoundaryLayers )
def getCarveCornerMaximum( self ):
"Get the corner maximum of the vertices."
return self.cornerMaximum
def getCarveCornerMinimum( self ):
"Get the corner minimum of the vertices."
return self.cornerMinimum
def getCarveLayerThickness( self ):
"Get the layer thickness."
return self.layerThickness
def getCarveRotatedBoundaryLayers( self ):
"Get the rotated boundary layers."
self.cornerMaximum = Vector3( - 999999999.0, - 999999999.0, self.maximumZ )
self.cornerMinimum = Vector3( 999999999.0, 999999999.0, self.minimumZ )
for rotatedBoundaryLayer in self.rotatedBoundaryLayers:
for loop in rotatedBoundaryLayer.loops:
for point in loop:
pointVector3 = Vector3( point.real, point.imag, rotatedBoundaryLayer.z )
self.cornerMaximum = euclidean.getPointMaximum( self.cornerMaximum, pointVector3 )
self.cornerMinimum = euclidean.getPointMinimum( self.cornerMinimum, pointVector3 )
halfLayerThickness = 0.5 * self.layerThickness
self.cornerMaximum.z += halfLayerThickness
self.cornerMinimum.z -= halfLayerThickness
return self.rotatedBoundaryLayers
def processContourLayers( self, file ):
"Process a contour layer at a time until the top of the part."
while True:
minLayer = getLittleEndianFloatGivenFile( file )
numContours = getLittleEndianUnsignedLongGivenFile( file )
if numContours == 0xFFFFFFFF:
return
rotatedBoundaryLayer = euclidean.RotatedLoopLayer( minLayer )
self.rotatedBoundaryLayers.append( rotatedBoundaryLayer )
for contourIndex in xrange( numContours ):
numPoints = getLittleEndianUnsignedLongGivenFile( file )
numGaps = getLittleEndianUnsignedLongGivenFile( file )
if numPoints > 2:
rotatedBoundaryLayer.loops.append( getPointsFromFile( numPoints, file ) )
def readFile( self, fileName ):
"Read SLC and store the layers."
pslcfile = open( fileName, 'rb' )
readHeader( pslcfile )
pslcfile.read( 256 ) #Go past the 256 byte 3D Reserved Section.
self.readTableEntry( pslcfile )
self.processContourLayers( pslcfile )
pslcfile.close()
def readTableEntry( self, file ):
"Read in the sampling table section. It contains a table length (byte) and the table entries."
tableEntrySize = ord( file.read( 1 ) )
if tableEntrySize == 0:
print( "Sampling table size is zero!" )
exit()
for index in xrange( tableEntrySize ):
sampleTableEntry = SampleTableEntry( file )
self.layerThickness = sampleTableEntry.layer_thickness
def setCarveBridgeLayerThickness( self, bridgeLayerThickness ):
"Set the bridge layer thickness. If the infill is not in the direction of the bridge, the bridge layer thickness should be given as None or not set at all."
pass
def setCarveLayerThickness( self, layerThickness ):
"Set the layer thickness."
pass
def setCarveImportRadius( self, importRadius ):
"Set the import radius."
pass
def setCarveIsCorrectMesh( self, isCorrectMesh ):
"Set the is correct mesh flag."
pass
def main():
"Display the inset dialog."
if len( sys.argv ) > 1:
getCarving( ' '.join( sys.argv[ 1 : ] ) )
if __name__ == "__main__":
main()
|
