def read(self, stream: Stream, version):
self.symbol_level = SymbolLayer.read_symbol_level(stream)
# consume unused properties - MultiLayerMarkerSymbol implements IMarkerSymbol
# so that the size/offsets/angle are required properties. But they aren't used
# or exposed anywhere for MultiLayerMarkerSymbol
_ = stream.read_double('unused marker size')
_ = stream.read_double('unused marker x/y/offset or angle')
_ = stream.read_double('unused marker x/y/offset or angle')
_ = stream.read_double('unused marker x/y/offset or angle')
_ = stream.read_object('unused color')
self.halo = stream.read_int() == 1
self.halo_size = stream.read_double('halo size')
self.halo_symbol = stream.read_object('halo')
# useful stuff
number_layers = stream.read_int('layers')
for i in range(number_layers):
layer = stream.read_object('symbol layer {}/{}'.format(i + 1, number_layers))
self.layers.extend([layer])
for l in self.layers:
l.read_enabled(stream)
for l in self.layers:
l.read_locked(stream)
if version > 1:
_ = stream.read_double('unknown size')
_ = stream.read_double('unknown size')
if version >= 3:
for l in self.layers:
l.read_tags(stream)
def read(self, stream: Stream, version):
self.color = stream.read_object('color')
self.unicode = stream.read_int('unicode')
self.units = stream.read_int('units')
self.angle = stream.read_double('angle')
self.size = stream.read_double('size')
self.depth = stream.read_double('depth')
self.normalized_origin_x = stream.read_double('normalized origin x')
self.normalized_origin_y = stream.read_double('normalized origin y')
self.normalized_origin_z = stream.read_double('normalized origin z')
self.x_offset = stream.read_double('x offset')
self.y_offset = stream.read_double('y offset')
self.z_offset = stream.read_double('z offset')
self.font = stream.read_object('font')
self.read_symbol_level(stream)
stream.read_ushort('unknown', expected=65535)
self.character_marker_symbol = stream.read_object('character marker')
self.vertical_orientation = stream.read_uchar(
'vertical orientation') != 0
self.x_rotation = stream.read_double('x rotation')
self.y_rotation = stream.read_double('y rotation')
self.width = stream.read_double('width')
self.maintain_aspect_ratio = stream.read_ushort(
'maintain aspect ratio') != 0
self.billboard_display = stream.read_ushort('billboard display') != 0
def read_symbol_level(stream: Stream):
"""
Reads the symbol level from the stream
"""
# actually raster op
assert stream.read_int('terminator') == 13
# symbol level of 0xffffffff = merge and join
return stream.read_int('symbol level')
def read(self, stream: Stream, version):
self.texture = stream.read_object('texture')
self.color = stream.read_object('color')
self.transparency_color = stream.read_object('transparency color')
self.outline = stream.read_object('outline')
self.angle = stream.read_double('angle')
self.size = stream.read_double('size')
stream.read_int('raster op', expected=13)
self.symbol_level = stream.read_int('level')
def read(self, stream: Stream, version):
self.color = stream.read_object('color')
self.width = stream.read_double('width')
self.type = stream.read_int('type', expected=(0, 1, 2))
self.quality = stream.read_double('quality')
self.symbol_level = SymbolLayer.read_symbol_level(stream)
def read(self, stream: Stream, version):
self.color = stream.read_object('color')
self.size_z = stream.read_double('size z')
self.type = stream.read_int('type', expected=(0, 1, 2, 3, 4, 5, 6))
self.quality = stream.read_double('quality') # 0->1
self.symbol_level = SymbolLayer.read_symbol_level(stream)
self.z_rotation = stream.read_double('z rotation')
self.x_offset = stream.read_double('x offset')
self.y_offset = stream.read_double('y offset')
self.z_offset = stream.read_double('z offset')
stream.read_ushort('unknown', expected=65535)
self.dx = stream.read_double('dx')
self.dy = stream.read_double('dy')
self.dz = stream.read_double('dz')
self.x_rotation = stream.read_double('x rotation')
self.y_rotation = stream.read_double('y rotation')
self.width = stream.read_double('width')
self.depth_y = stream.read_double('depth y')
self.keep_aspect_ratio = stream.read_ushort('keep aspect ratio') != 0
self.billboard_display = stream.read_ushort('display front face') != 0
def read(self, stream: Stream, version):
self.color = stream.read_object('color')
self.size = stream.read_double('size')
type_code = stream.read_int()
type_dict = {
0: 'circle',
1: 'square',
2: 'cross',
3: 'x',
4: 'diamond'
}
if type_code not in type_dict:
raise UnreadableSymbolException(
'Unknown marker type at {}, got {}'.format(hex(stream.tell() - 4),
type_code))
stream.log('found a {}'.format(type_dict[type_code]), 4)
self.type = type_dict[type_code]
self.symbol_level = SymbolLayer.read_symbol_level(stream)
self.angle = stream.read_double('angle')
self.x_offset = stream.read_double('x offset')
self.y_offset = stream.read_double('y offset')
self.outline_enabled = stream.read_uchar('has outline') != 0
self.outline_width = stream.read_double('outline width')
self.outline_color = stream.read_object('outline color')
if version > 1:
self.rotate_with_transform = stream.read_ushort('rotate with transform') != 0
def read(self, stream: Stream, version):
self.color = stream.read_object('color')
self.size_z = stream.read_double('size z')
self.geometry = stream.read_object('multipatch')
stream.read_double('unknown', expected=0)
stream.read_double('unknown', expected=0)
stream.read_int('unknown', expected=9)
self.origin_x = stream.read_double('origin x')
self.origin_y = stream.read_double('origin y')
self.origin_z = stream.read_double('origin z')
self.material_draping = stream.read_ushort('no material draping') == 0
stream.read_int('unknown', expected=13)
stream.read_int('unknown', expected=0)
self.rotation_z = stream.read_double('rotation z')
self.offset_x = stream.read_double('offset x')
self.offset_y = stream.read_double('offset y')
self.offset_z = stream.read_double('offset z')
stream.read_ushort('unknown', expected=65535)
self.picture = stream.read_object('picture')
self.rotation_x = stream.read_double('rotation x')
self.rotation_y = stream.read_double('rotation y')
self.size_x = stream.read_double('size x')
self.size_y = stream.read_double('size y')
self.keep_aspect = stream.read_ushort('keep aspect') != 0
stream.read_ushort('unknown', expected=0)
if version == 7:
return
self.display_face_front = stream.read_ushort('display face front') != 0
if version < 7:
stream.read_int('unknown', expected=0)
stream.read_double('unknown')
stream.read_ushort('unknown', expected=0)
stream.read_ushort('unknown', expected=65535)
if version > 8:
stream.read_ushort('unknown', expected=0)
stream.read_int('unknown', expected=0)
def read(self, stream: Stream, version):
if version in (3, 4, 5):
self.picture = stream.read_object('picture')
elif version in (7, 8):
_ = stream.read_ushort('pic version?')
_ = stream.read_uint('picture type?')
self.picture = stream.read_object('picture')
elif version == 9:
self.picture = Picture.create_from_stream(stream)
if version < 4:
_ = stream.read_object()
if version <= 8:
_ = stream.read_object()
self.color_foreground = stream.read_object('color 1')
self.color_background = stream.read_object('color 2')
if version >= 9:
self.color_transparent = stream.read_object('color 3')
self.angle = stream.read_double('angle')
self.size = stream.read_double('size')
self.x_offset = stream.read_double('x offset')
self.y_offset = stream.read_double('y offset')
self.x_scale = stream.read_double('x scale')
self.y_scale = stream.read_double('y scale')
self.symbol_level = SymbolLayer.read_symbol_level(stream)
self.swap_fb_gb = bool(stream.read_uchar('swap fgbg'))
self.rotate_with_transform = stream.read_ushort(
'rotate with transform') != 0
if version < 5:
return
stream.read_int('unknown', expected=0)
stream.read_ushort('unknown', expected=0)
if version == 7:
return
if 5 < version <= 8:
size = stream.read_int('unknown size')
stream.read(size)
def read(self, stream: Stream, version):
self.color = stream.read_object('color')
self.unicode = stream.read_int('unicode')
self.angle = stream.read_double('angle')
self.size = stream.read_double('size')
self.x_offset = stream.read_double('x offset')
self.y_offset = stream.read_double('y offset')
self.x_scale = stream.read_double('x scale')
self.y_scale = stream.read_double('y scale')
if version <= 2:
self.std_font = stream.read_object('font')
self.font = self.std_font.font_name
self.symbol_level = SymbolLayer.read_symbol_level(stream)
if version > 1:
self.rotate_with_transform = stream.read_ushort('rotate with transform') != 0
if version >= 3:
self.font = stream.read_string('font name')
# lot of unknown stuff
stream.read_double('unknown 3', expected=0) # or object?
stream.read_double('unknown 4', expected=0) # or object?
stream.read_int('font weight')
stream.read_int('unknown', expected=0)
stream.read_int('font size * 10000') / 10000
if version >= 4:
# std OLE font .. maybe contains useful stuff like bold/etc, but these aren't exposed in ArcGIS anyway..
self.std_font = stream.read_object('font')
def read(self, stream: Stream, version):
has_picture = stream.read_int('has picture') != 0
stream.read_int('unknown')
stream.read_int('unknown')
stream.read_int('unknown')
stream.read_int('unknown')
stream.read_int('unknown')
stream.read_int('unknown')
stream.read_int('unknown')
stream.read_int('unknown')
self.transparency = stream.read_double('transparency')
self.color = stream.read_object('color')
self.transparent_texture_color = stream.read_object('transparent texture color')
if has_picture:
self.picture = BmpPicture()
self.picture.read(stream, 1)
def read_join(stream: Stream):
"""
Reads a line join style from the stream
"""
join_bin = stream.read_int('join')
if join_bin == 0:
return 'miter'
elif join_bin == 1:
return 'round'
elif join_bin == 2:
return 'bevel'
else:
raise UnreadableSymbolException('unknown join style {}'.format(join_bin))
def read_cap(stream: Stream):
"""
Reads a line cap style from the stream
"""
cap_bin = stream.read_int('cap')
if cap_bin == 0:
return 'butt'
elif cap_bin == 1:
return 'round'
elif cap_bin == 2:
return 'square'
else:
raise UnreadableSymbolException('unknown cap style {}'.format(cap_bin))
def read(self, stream: Stream, version):
self.pattern_interval = stream.read_double('pattern interval')
pattern_part_count = stream.read_int('pattern parts')
self.pattern_parts = []
for p in range(pattern_part_count):
filled_squares = stream.read_double()
empty_squares = stream.read_double()
self.pattern_parts.append([filled_squares, empty_squares])
pattern = ''
for p in self.pattern_parts:
pattern += '-' * int(p[0]) + '.' * int(p[1])
stream.log('deciphered line pattern {} ending'.format(pattern))
def read(self, stream: Stream, version):
self.random = bool(stream.read_int('random'))
self.offset_x = stream.read_double('offset x')
self.offset_y = stream.read_double('offset y')
self.separation_x = stream.read_double('separation x')
self.separation_y = stream.read_double('separation y')
_ = stream.read_double('unused double')
_ = stream.read_double('unused double')
self.marker = stream.read_object('fill marker')
# either an entire LineSymbol or just a LineSymbolLayer
self.outline = stream.read_object('outline')
self.symbol_level = SymbolLayer.read_symbol_level(stream)
self.grid_angle = stream.read_double('grid angle')
def read(self, stream: Stream, version):
self.symbol_level = SymbolLayer.read_symbol_level(stream)
_ = stream.read_object('unused color')
number_layers = stream.read_int('layers')
for i in range(number_layers):
layer = stream.read_object('symbol layer {}/{}'.format(i + 1, number_layers))
self.layers.extend([layer])
for l in self.layers:
l.read_enabled(stream)
for l in self.layers:
l.read_locked(stream)
if version >= 2:
for l in self.layers:
l.read_tags(stream)
def read(self, stream: Stream, version):
version = binascii.hexlify(stream.read(1))
if version != b'01':
raise UnsupportedVersionException(
'Unsupported Font version {}'.format(version))
self.charset = stream.read_ushort('charset')
# Not exposed in ArcMap front end:
attributes = stream.read_uchar('attributes')
self.italic = bool(attributes & self.Italic)
self.underline = bool(attributes & self.Underline)
self.strikethrough = bool(attributes & self.Strikethrough)
self.weight = stream.read_ushort('weight')
# From https://docs.microsoft.com/en-us/windows/desktop/api/olectl/ns-olectl-tagfontdesc
# Use the int64 member of the CY structure and scale your font size (in points) by 10000.
self.size = stream.read_int('font size') / 10000
name_length = stream.read_uchar('font name size')
self.font_name = stream.read(name_length).decode(
Font.CHARSET_MAP[self.charset])
def read(self, stream: Stream, version):
self.color = stream.read_object('color')
stream.read_int('raster op', expected=13)
stream.read_int('unknown', expected=0)
stream.read_int(
'unknown'
) # expected=(0,194149600, 239970880, 324278056, 6757008) )
self.color_ramp = stream.read_object('color ramp')
self.invert = stream.read_ushort('invert') != 0
self.legend_class_index = stream.read_int('legend class index')
if 2 < version < 5:
stream.read_int('unknown', expected=0)
stream.read_ushort('unknown', expected=0)
elif version >= 5:
stream.read_ushort('unknown', expected=0)
stream.read_int('unknown', expected=0)
self.number_of_label = stream.read_int('number of labels')
self.horizontal = stream.read_ushort('horizontal') != 0
self.show_ticks = stream.read_ushort('show ticks') != 0
def read(self, stream: Stream, version):
size = stream.read_int('size')
# TODO - reverse engineer
stream.read(size)
self.crs = stream.read_object('crs')
def read(self, stream: Stream, version):
# first bit is either an entire LineSymbol or just a LineSymbolLayer
self.outline = stream.read_object('outline')
self.color = stream.read_object('color')
self.symbol_level = SymbolLayer.read_symbol_level(stream)
self.fill_style = stream.read_int('fill style')
def read(self, stream: Stream, version):
self.color = stream.read_object('color')
self.symbol_level = SymbolLayer.read_symbol_level(stream)
stream.read_int('unknown int')
def read(self, stream: Stream, version):
size = stream.read_int('size')
# TODO - reverse engineer
stream.read(size)
return
