/usr/lib/python3/dist-packages/stl/stl.py is in python3-stl 2.3.2-1.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
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 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 | from __future__ import (absolute_import, division, print_function,
unicode_literals)
import io
import os
import enum
import numpy
import struct
import logging
import datetime
from . import base
from . import __about__ as metadata
from .utils import b
from .utils import s
try:
from . import _speedups
except ImportError: # pragma: no cover
_speedups = None
logger = logging.getLogger(__name__)
class Mode(enum.IntEnum):
#: Automatically detect whether the output is a TTY, if so, write ASCII
#: otherwise write BINARY
AUTOMATIC = 0
#: Force writing ASCII
ASCII = 1
#: Force writing BINARY
BINARY = 2
# For backwards compatibility, leave the original references
AUTOMATIC = Mode.AUTOMATIC
ASCII = Mode.ASCII
BINARY = Mode.BINARY
#: Amount of bytes to read while using buffered reading
BUFFER_SIZE = 4096
#: The amount of bytes in the header field
HEADER_SIZE = 80
#: The amount of bytes in the count field
COUNT_SIZE = 4
#: The maximum amount of triangles we can read from binary files
MAX_COUNT = 1e8
class BaseStl(base.BaseMesh):
@classmethod
def load(cls, fh, mode=AUTOMATIC, speedups=True):
'''Load Mesh from STL file
Automatically detects binary versus ascii STL files.
:param file fh: The file handle to open
:param int mode: Automatically detect the filetype or force binary
'''
header = fh.read(HEADER_SIZE).lower()
if not header:
return
if isinstance(header, str): # pragma: no branch
header = b(header)
name = ''
if mode in (AUTOMATIC, ASCII) and header.startswith(b('solid')):
try:
name, data = cls._load_ascii(
fh, header, speedups=speedups)
except RuntimeError as exception:
(recoverable, e) = exception.args
# If we didn't read beyond the header the stream is still
# readable through the binary reader
if recoverable:
name, data = cls._load_binary(fh, header, check_size=False)
else:
# Apparently we've read beyond the header. Let's try
# seeking :)
# Note that this fails when reading from stdin, we can't
# recover from that.
fh.seek(HEADER_SIZE)
# Since we know this is a seekable file now and we're not
# 100% certain it's binary, check the size while reading
name, data = cls._load_binary(fh, header, check_size=True)
else:
name, data = cls._load_binary(fh, header)
return name, data
@classmethod
def _load_binary(cls, fh, header, check_size=False):
# Read the triangle count
count_data = fh.read(COUNT_SIZE)
if len(count_data) != COUNT_SIZE:
count = 0
else:
count, = struct.unpack(s('<i'), b(count_data))
# raise RuntimeError()
assert count < MAX_COUNT, ('File too large, got %d triangles which '
'exceeds the maximum of %d') % (
count, MAX_COUNT)
if check_size:
try:
# Check the size of the file
fh.seek(0, os.SEEK_END)
raw_size = fh.tell() - HEADER_SIZE - COUNT_SIZE
expected_count = int(raw_size / cls.dtype.itemsize)
assert expected_count == count, ('Expected %d vectors but '
'header indicates %d') % (
expected_count, count)
fh.seek(HEADER_SIZE + COUNT_SIZE)
except IOError: # pragma: no cover
pass
name = header.strip()
# Read the rest of the binary data
return name, numpy.fromfile(fh, dtype=cls.dtype, count=count)
@classmethod
def _ascii_reader(cls, fh, header):
if b'\n' in header:
recoverable = [True]
else:
recoverable = [False]
header += b(fh.read(BUFFER_SIZE))
lines = b(header).split(b('\n'))
def get(prefix=''):
prefix = b(prefix)
if lines:
line = lines.pop(0)
else:
raise RuntimeError(recoverable[0], 'Unable to find more lines')
if not lines:
recoverable[0] = False
# Read more lines and make sure we prepend any old data
lines[:] = b(fh.read(BUFFER_SIZE)).split(b('\n'))
line += lines.pop(0)
line = line.lower().strip()
if line == b(''):
return get(prefix)
if prefix:
if line.startswith(prefix):
values = line.replace(prefix, b(''), 1).strip().split()
elif line.startswith(b('endsolid')):
# go back to the beginning of new solid part
size_unprocessedlines = sum(len(l) + 1 for l in lines) - 1
if size_unprocessedlines > 0:
position = fh.tell()
fh.seek(position - size_unprocessedlines)
raise StopIteration()
else:
raise RuntimeError(recoverable[0],
'%r should start with %r' % (line,
prefix))
if len(values) == 3:
return [float(v) for v in values]
else: # pragma: no cover
raise RuntimeError(recoverable[0],
'Incorrect value %r' % line)
else:
return b(line)
line = get()
if not line.startswith(b('solid ')) and line.startswith(b('solid')):
cls.warning('ASCII STL files should start with solid <space>. '
'The application that produced this STL file may be '
'faulty, please report this error. The erroneous '
'line: %r', line)
if not lines:
raise RuntimeError(recoverable[0],
'No lines found, impossible to read')
# Yield the name
yield line[5:].strip()
while True:
# Read from the header lines first, until that point we can recover
# and go to the binary option. After that we cannot due to
# unseekable files such as sys.stdin
#
# Numpy doesn't support any non-file types so wrapping with a
# buffer and/or StringIO does not work.
try:
normals = get('facet normal')
assert get() == b('outer loop')
v0 = get('vertex')
v1 = get('vertex')
v2 = get('vertex')
assert get() == b('endloop')
assert get() == b('endfacet')
attrs = 0
yield (normals, (v0, v1, v2), attrs)
except AssertionError as e: # pragma: no cover
raise RuntimeError(recoverable[0], e)
except StopIteration:
raise
@classmethod
def _load_ascii(cls, fh, header, speedups=True):
if _speedups and speedups:
return _speedups.ascii_read(fh, header)
else:
iterator = cls._ascii_reader(fh, header)
name = next(iterator)
return name, numpy.fromiter(iterator, dtype=cls.dtype)
def save(self, filename, fh=None, mode=AUTOMATIC, update_normals=True):
'''Save the STL to a (binary) file
If mode is :py:data:`AUTOMATIC` an :py:data:`ASCII` file will be
written if the output is a TTY and a :py:data:`BINARY` file otherwise.
:param str filename: The file to load
:param file fh: The file handle to open
:param int mode: The mode to write, default is :py:data:`AUTOMATIC`.
:param bool update_normals: Whether to update the normals
'''
assert filename, 'Filename is required for the STL headers'
if update_normals:
self.update_normals()
if mode is AUTOMATIC:
if fh and os.isatty(fh.fileno()): # pragma: no cover
write = self._write_ascii
else:
write = self._write_binary
elif mode is BINARY:
write = self._write_binary
elif mode is ASCII:
write = self._write_ascii
else:
raise ValueError('Mode %r is invalid' % mode)
name = os.path.split(filename)[-1]
try:
if fh:
write(fh, name)
else:
with open(filename, 'wb') as fh:
write(fh, filename)
except IOError: # pragma: no cover
pass
def _write_ascii(self, fh, name):
if _speedups and self.speedups:
_speedups.ascii_write(fh, b(name), self.data)
else:
def p(s, file):
file.write(b('%s\n' % s))
p('solid %s' % name, file=fh)
for row in self.data:
vectors = row['vectors']
p('facet normal %f %f %f' % tuple(row['normals']), file=fh)
p(' outer loop', file=fh)
p(' vertex %f %f %f' % tuple(vectors[0]), file=fh)
p(' vertex %f %f %f' % tuple(vectors[1]), file=fh)
p(' vertex %f %f %f' % tuple(vectors[2]), file=fh)
p(' endloop', file=fh)
p('endfacet', file=fh)
p('endsolid %s' % name, file=fh)
def _write_binary(self, fh, name):
# Create the header
header = '%s (%s) %s %s' % (
metadata.__package_name__,
metadata.__version__,
datetime.datetime.now(),
name,
)
# Make it exactly 80 characters
header = header[:80].ljust(80, ' ')
packed = struct.pack(s('<i'), self.data.size)
if isinstance(fh, io.TextIOWrapper): # pragma: no cover
packed = str(packed)
else:
header = b(header)
packed = b(packed)
fh.write(header)
fh.write(packed)
self.data.tofile(fh)
if self.data.size: # pragma: no cover
assert fh.tell() > 84, (
'numpy silently refused to write our file. Note that writing '
'to `StringIO` objects is not supported by `numpy`')
@classmethod
def from_file(cls, filename, calculate_normals=True, fh=None,
mode=Mode.AUTOMATIC, speedups=True, **kwargs):
'''Load a mesh from a STL file
:param str filename: The file to load
:param bool calculate_normals: Whether to update the normals
:param file fh: The file handle to open
:param dict \**kwargs: The same as for :py:class:`stl.mesh.Mesh`
'''
if fh:
name, data = cls.load(
fh, mode=mode, speedups=speedups)
else:
try:
with open(filename, 'rb') as fh:
name, data = cls.load(
fh, mode=mode, speedups=speedups)
except AssertionError: # pragma: no cover
logger.warn('Unable to read the file with speedups, retrying')
with open(filename, 'rb') as fh:
name, data = cls.load(
fh, mode=Mode.ASCII, speedups=False)
return cls(data, calculate_normals, name=name,
speedups=speedups, **kwargs)
@classmethod
def from_multi_file(cls, filename, calculate_normals=True, fh=None,
mode=ASCII, speedups=True, **kwargs):
'''Load multiple meshes from a STL file
:param str filename: The file to load
:param bool calculate_normals: Whether to update the normals
:param file fh: The file handle to open
:param dict \**kwargs: The same as for :py:class:`stl.mesh.Mesh`
'''
if fh:
close = False
else:
fh = open(filename, 'rb')
close = True
try:
raw_data = cls.load(fh, mode=mode, speedups=speedups)
while raw_data:
name, data = raw_data
yield cls(data, calculate_normals, name=name,
speedups=speedups, **kwargs)
raw_data = cls.load(fh, mode=mode,
speedups=speedups)
finally:
if close:
fh.close()
StlMesh = BaseStl.from_file
|