def writeparsetree(self, tree):
out = StringIO.StringIO()
parser.show(out, tree)
self.root.append(ET.Comment(out.getvalue().replace("--", " - - ")))
to_subelement(d_el, drum, 'voice')
to_subelement(d_el, drum, 'drum', 'name')
to_subelement(d_el, drum, 'stem')
to_subelement(d_el, drum, 'shortcut')
if instrument['id'] in channels:
for channel in channels[instrument['id']].values():
ch_el = ET.SubElement(el, 'Channel')
to_attribute(ch_el, channel, 'channel', 'name')
bank = channel['Bank']
prog = channel['Prog']
msb = channel['MSB']
lsb = channel['LSB']
sound = channel["MS General sound"]
assert int(bank) == (int(msb) * 128) + int(lsb)
ch_el.append(ET.Comment("MIDI: Bank {0}, Prog {1}; MS General: {2}".format(bank, prog, sound)))
if msb != "0":
con_el = ET.SubElement(ch_el, 'controller')
con_el.set('ctrl', "0")
con_el.set('value', msb)
ch_el.append(ET.Comment("Bank MSB"))
if lsb != "0":
con_el = ET.SubElement(ch_el, 'controller')
con_el.set('ctrl', "32")
con_el.set('value', lsb)
ch_el.append(ET.Comment("Bank LSB"))
ET.SubElement(ch_el, 'program').set('value', channel['Prog'])
if is_drumset:
try: to_comment(ch_el, gs_drumkits[channel['Prog']], 'name')
except KeyError: ch_el.append(ET.Comment("Non-GS drum kit"))
else:
def main(src, output_filename=None, id=None, diskId=None):
add_wix_to_path()
while src[-1] in ('/', '\\'):
src = src[:-1]
name = os.path.basename(src)
id = id or name.replace('-', '_').replace(' ', '_')
output_filename = output_filename or _adjacent_file(id + ".wxi")
import subprocess
def check_call(args):
print " ".join(args)
subprocess.check_call(args)
#subprocess.check_call('set path'.split(), shell=True)
#subprocess.check_call('where heat'.split(), shell=True)
check_call([
'heat', 'dir',
_adjacent_file(src), '-template', 'fragment', '-sreg', '-scom', '-o',
output_filename, '-ag', '-cg', id, '-srd', '-var', 'var.' + id, '-dr',
id, '-nologo'
])
ElementTree.register_namespace("",
"http://schemas.microsoft.com/wix/2006/wi")
tree = ElementTree.parse(output_filename,
parser=CommentedTreeBuilder()).getroot()
tree.insert(
0, ElementTree.Comment('generated with gen_dir_wxi.py %s\n' % src))
tree.insert(
0,
ElementTree.ProcessingInstruction(
'define', '%s=%s' % (id, os.path.normpath(src))))
parent_map = dict((c, p) for p in tree.getiterator() for c in p)
for file in tree.findall(
".//{http://schemas.microsoft.com/wix/2006/wi}Component/{http://schemas.microsoft.com/wix/2006/wi}File"
):
file_Source = file.get('Source', '')
if file_Source.find('.svn') != -1 or os.path.basename(file_Source) in (
'Thumbs.db', 'desktop.ini',
'.DS_Store') or file_Source.endswith('.pyc'):
comp = parent_map[file]
parent_map[comp].remove(comp)
for dir in tree.findall(
".//{http://schemas.microsoft.com/wix/2006/wi}Directory"):
if dir.get('Name', '') == '.svn':
for dirref in tree.findall(
".//{http://schemas.microsoft.com/wix/2006/wi}DirectoryRef"
):
if dirref.get('Id', '') == dir.get('Id', ''):
frag = parent_map[dirref]
parent_map[frag].remove(frag)
parent_map[dir].remove(dir)
if diskId:
for component in tree.findall(
".//{http://schemas.microsoft.com/wix/2006/wi}Component"):
component.attrib['DiskId'] = diskId
ElementTree.ElementTree(tree).write(output_filename,
xml_declaration=True,
encoding='utf-8')
'stars',
'sun',
'thermometer-3',
'wind',
'umberla',
'sun-nwave',
'tree-3' }
symbol_count = 0
mypath = '/etc/openhab2/html/matrix-theme/original-svgs'
onlyfiles = [f for f in listdir(mypath) if isfile(join(mypath, f))]
ET.register_namespace("","http://www.w3.org/2000/svg")
top = ET.Element('svg', attrib = { 'version':'1.1', 'xmlns:xlink':'http://www.w3.org/1999/xlink', 'x':"0px", 'y':"0px", 'viewBox':"0 0 48 48", 'enable-background':"new 0 0 48 48", 'xml:space':"preserve"})
comment = ET.Comment('Generated by SVG-Combiner')
top.append(comment)
for file in onlyfiles:
if(file[:1] != '.'):
print "Processing file: " + file
r = requests.get('http://127.0.0.1:8080/static/matrix-theme/original-svgs/' + file)
print r.status_code
if(len(r.text)>0):
xml = ET.fromstring(r.text)
for child in xml:
if(len(child.getchildren())>0 and 'id' in child.attrib):
if(child.attrib['id'] in symbols):
for node in child.findall('.//*[@fill]'):
if ('stroke' in node.attrib): node.attrib.pop('stroke')
def comment(self,s):
self.doc.insert(len(list(self.doc)), ET.Comment(s))
if self.logger:
self.logger(s)
def add_comment(element, comment):
element.append(ElementTree.Comment(text=comment))
def main():
"""First, build fire. Second, start coffee."""
ap = argparse.ArgumentParser(
description=
('Concentrically arranges randomly sized arcs into a pretty disc shape. Output is '
'generated as a set of vector shapes in Scalable Vector Graphics (SVG) format and printed '
'on the standard output stream.'),
epilog=
'Report bugs, request features, or provide suggestions via https://github.com/the-real-tokai/macuahuitl/issues',
add_help=False,
)
g = ap.add_argument_group('Startup')
g.add_argument(
'-V',
'--version',
action='version',
help="show version number and exit",
version='%(prog)s {}'.format(__version__),
)
g.add_argument('-h',
'--help',
action='help',
help='show this help message and exit')
g = ap.add_argument_group('Algorithm')
g.add_argument(
'--circles',
metavar='INT',
type=int,
help=
'number of concentric arc elements to generate inside the disc [:21]',
default=21)
g.add_argument('--stroke-width',
metavar='FLOAT',
type=float,
help='width of the generated strokes [:6]',
default=6.0)
g.add_argument('--gap',
metavar='FLOAT',
type=float,
help='distance between the generated strokes')
g.add_argument('--inner-radius',
metavar='FLOAT',
type=float,
help='setup inner disc radius to create an annular shape')
g.add_argument('--hoffset',
metavar='FLOAT',
type=float,
help='shift the whole disc horizontally [:0.0]',
default=0.0)
g.add_argument('--voffset',
metavar='FLOAT',
type=float,
help='shift the whole disc vertically [:0.0]',
default=0.0)
g.add_argument(
'--color',
metavar='COLOR',
type=str,
help='SVG compliant color specification or identifier [:black]',
default='black')
g.add_argument(
'--random-seed',
metavar='INT',
type=int,
help=
'fixed initialization of the random number generator for predictable results'
)
g.add_argument(
'--randomize',
action='store_true',
help=
'generate truly random disc layouts; other algorithm values provided via command line parameters are utilized as limits'
)
g = ap.add_argument_group('Miscellaneous')
g.add_argument(
'--separate-paths',
action='store_true',
help=
'generate separate <path> elements for each arc; automatically implied when animation support is enabled'
)
g.add_argument('--outline-mode',
help='generate bounding outline circles [:both]',
choices=['both', 'outside', 'inside', 'none'],
default='both')
g.add_argument(
'--background-color',
metavar='COLOR',
type=str,
help=
'SVG compliant color specification or identifier; adds a background <rect> to the SVG output'
)
g.add_argument(
'--disc-color',
metavar='COLOR',
type=str,
help=
'SVG compliant color specification or identifier; fills the background of the generated disc by adding an extra <circle> element'
)
g.add_argument(
'--animation-mode',
help='enables SVG <animateTransform> support',
choices=['random', 'bidirectional', 'cascade-in', 'cascade-out'])
g.add_argument(
'--animation-duration',
metavar='FLOAT',
type=float,
help=
'defines base duration of one full 360° arc rotation (in seconds); negative inputs switch to counter-clockwise base direction [:6.0]',
default=6.0)
g.add_argument(
'--animation-offset',
metavar='FLOAT',
type=float,
help=
'offset the animation (in seconds) to support rendering to frame sequences for frame based animation formats. [:0]',
default=0.0)
g = ap.add_argument_group('Output')
g.add_argument(
'-o',
'--output',
metavar='FILENAME',
type=str,
help=
'optionally rasterize the generated vector paths and write the result into a PNG file (requires the `svgcairo\' Python module)'
)
g.add_argument(
'--output-size',
metavar='INT',
type=int,
help=
'force pixel width and height of the raster image; if omitted the generated SVG viewbox dimensions are used'
)
user_input = ap.parse_args()
# Initialize…
#
chaos = random.Random(user_input.random_seed)
circles = user_input.circles
stroke = abs(user_input.stroke_width) if user_input.stroke_width else 1.0
gap = user_input.gap if (user_input.gap is not None) else stroke
radius = abs(user_input.inner_radius) if (user_input.inner_radius
is not None) else stroke
x = user_input.hoffset
y = user_input.voffset
color = user_input.color
if user_input.randomize:
circles = chaos.randrange(0, circles) if circles else 0
stroke = chaos.uniform(0, stroke)
stroke = 1.0 if stroke == 0 else stroke
gap = chaos.uniform(0, gap)
radius = chaos.uniform(0, radius)
x = chaos.uniform(-x, x) if x else 0.0
y = chaos.uniform(-y, y) if y else 0.0
color = '#{:02x}{:02x}{:02x}'.format(chaos.randrange(0, 255),
chaos.randrange(0, 255),
chaos.randrange(0, 255))
# TODO: randomize background and disc color too when the respective parameters are used
# (needs to respect color harmonies)
if radius < stroke:
radius = stroke
# Generate data…
#
outlines = []
arcs = []
if user_input.outline_mode in ('both', 'inside'):
outlines.append({'x': x, 'y': y, 'r': radius})
radius += (gap + stroke)
for _ in range(circles):
# Calculate angular space requirement for the "round" stroke caps to avoid some overlapping
sqrd2 = 2.0 * math.pow(radius, 2.0)
theta = ((2.0 * math.acos((sqrd2 - math.pow(
(stroke / 2.0), 2.0)) / sqrd2)) * (180.0 / math.pi))
arcs.append(
SVGArcPathSegment(offset=chaos.uniform(0, 359.0),
angle=chaos.uniform(0, 359.0 - theta),
radius=radius,
x=x,
y=y))
radius += (gap + stroke)
if user_input.outline_mode in ('both', 'outside'):
outlines.append({'x': x, 'y': y, 'r': radius})
else:
radius -= (gap + stroke)
# Generate SVG/XML…
#
def _f(v, max_digits=9):
if isinstance(v, float):
v = round(v, max_digits)
return v if isinstance(v, str) else str(v)
vb_dim = (radius + (stroke * 0.5)) * (
256.0 / (256.0 - 37.35)
) # 37px border for 256x256; a golden ratio in there… somewhere…
vb_off = _f(vb_dim * -1.0, 2)
vb_dim = _f(vb_dim * 2.0, 2)
config = {'stroke': color, 'stroke-width': _f(stroke), 'fill': 'none'}
svg = xtree.Element(
'svg', {
'width': '100%',
'height': '100%',
'xmlns': 'http://www.w3.org/2000/svg',
'viewBox': '{o} {o} {s} {s}'.format(o=vb_off, s=vb_dim)
})
title = xtree.SubElement(svg, 'title')
title.text = 'A Comitl Artwork'
if user_input.background_color:
xtree.SubElement(
svg, 'rect', {
'id': 'background',
'x': vb_off,
'y': vb_off,
'width': vb_dim,
'height': vb_dim,
'fill': user_input.background_color
})
svg_m = xtree.SubElement(svg, 'g', {'id': 'comitl-disc'})
if user_input.disc_color:
xtree.SubElement(
svg_m, 'circle', {
'id': 'disc-background',
'cx': _f(x),
'cy': _f(y),
'r': _f(radius),
'fill': user_input.disc_color
})
if arcs:
if user_input.separate_paths or user_input.animation_mode:
svg_ga = xtree.SubElement(svg_m, 'g', {'id': 'arcs'})
for aid, a in enumerate(arcs):
svg_arc = xtree.SubElement(
svg_ga, 'path', {
'id': 'arc-{}'.format(aid + 1),
'stroke-linecap': 'round',
**config
})
shift = 0.0
if user_input.animation_mode:
if user_input.animation_mode == 'cascade-out':
d = user_input.animation_duration * (
(aid + 1) * 0.25
) # TODO: 1/4 decay value could be configurable
elif user_input.animation_mode == 'cascade-in':
d = user_input.animation_duration * (
(len(arcs) - aid + 1) * 0.25)
else:
# limits duration range into a 50% variation window to avoid super fast arcs with values closer to 0
d = chaos.uniform(
abs(user_input.animation_duration) * 0.5,
abs(user_input.animation_duration)
) # TODO: variation could be configurable
if user_input.animation_duration < 0:
d *= -1 # restore user direction
if (user_input.animation_mode
== 'bidirectional') and (chaos.random() < 0.5):
d *= -1 # switch direction randomly
shift = (360.0 / d) * user_input.animation_offset
xtree.SubElement(
svg_arc, 'animateTransform', {
'attributeName': 'transform',
'type': 'rotate',
'from': '{} {} {}'.format(360 if d < 0 else 0, x,
y),
'to': '{} {} {}'.format(0 if d < 0 else 360, x, y),
'dur': '{}s'.format(abs(d)),
'repeatCount': 'indefinite'
})
a.offset += shift
svg_arc.set('d', str(a))
else:
xtree.SubElement(
svg_m, 'path', {
'id': 'arcs',
'd': ''.join(map(str, arcs)),
'stroke-linecap': 'round',
**config
})
if outlines:
svg_go = xtree.SubElement(svg_m, 'g', {'id': 'outlines'})
for oid, o in enumerate(outlines):
xtree.SubElement(
svg_go, 'circle', {
'id': 'outline-{}'.format(oid + 1),
'cx': _f(o['x']),
'cy': _f(o['y']),
'r': _f(o['r']),
**config
})
svg.append(
xtree.Comment(
' Generator: comitl.py {} (https://github.com/the-real-tokai/macuahuitl) '
.format(__version__)))
rawxml = xtree.tostring(svg, encoding='unicode')
# Send happy little arcs out into the world…
#
if not user_input.output:
print(rawxml)
else:
try:
from cairosvg import svg2png
svg2png(bytestring=rawxml,
write_to=os.path.realpath(
os.path.expanduser(user_input.output)),
output_width=user_input.output_size,
output_height=user_input.output_size)
except ImportError as e:
print(
'Couldn\'t rasterize nor write a PNG file. Required Python module \'cairosvg\' is not available: {}'
.format(str(e)),
file=sys.stderr)
def write(filename, mesh, binary=True, compression="zlib", header_type=None):
# Writing XML with an etree required first transforming the (potentially large)
# arrays into string, which are much larger in memory still. This makes this writer
# very memory hungry. See <https://stackoverflow.com/q/59272477/353337>.
from .._cxml import etree as ET
# Check if the mesh contains polyhedral cells, this will require special treatment
# in certain places.
is_polyhedron_grid = False
for c in mesh.cells:
if c.type[:10] == "polyhedron":
is_polyhedron_grid = True
break
# The current implementation cannot mix polyhedral cells with other cell types.
# To write such meshes, represent all cells as polyhedra.
if is_polyhedron_grid:
for c in mesh.cells:
if c.type[:10] != "polyhedron":
raise ValueError(
"VTU export cannot mix polyhedral cells with other cell types"
)
if not binary:
logging.warning("VTU ASCII files are only meant for debugging.")
if mesh.points.shape[1] == 2:
logging.warning("VTU requires 3D points, but 2D points given. "
"Appending 0 third component.")
mesh.points = np.column_stack([
mesh.points[:, 0], mesh.points[:, 1],
np.zeros(mesh.points.shape[0])
])
vtk_file = ET.Element(
"VTKFile",
type="UnstructuredGrid",
version="0.1",
# Use the native endianness. Not strictly necessary, but this simplifies things
# a bit.
byte_order=("LittleEndian"
if sys.byteorder == "little" else "BigEndian"),
)
header_type = ("UInt32" if header_type is None else vtk_file.set(
"header_type", header_type))
assert header_type is not None
if binary and compression:
# TODO lz4, lzma <https://vtk.org/doc/nightly/html/classvtkDataCompressor.html>
compressions = {
"lzma": "vtkLZMADataCompressor",
"zlib": "vtkZLibDataCompressor",
}
assert compression in compressions
vtk_file.set("compressor", compressions[compression])
# swap the data to match the system byteorder
# Don't use byteswap to make sure that the dtype is changed; see
# <https://github.com/numpy/numpy/issues/10372>.
points = mesh.points.astype(mesh.points.dtype.newbyteorder("="),
copy=False)
for k, (cell_type, data) in enumerate(mesh.cells):
# Treatment of polyhedra is different from other types
if is_polyhedron_grid:
new_cell_info = []
for cell_info in data:
new_face_info = []
for face_info in cell_info:
face_info = np.asarray(face_info)
new_face_info.append(
face_info.astype(face_info.dtype.newbyteorder("="),
copy=False))
new_cell_info.append(new_face_info)
mesh.cells[k] = CellBlock(cell_type, new_cell_info)
else:
mesh.cells[k] = CellBlock(
cell_type, data.astype(data.dtype.newbyteorder("="),
copy=False))
for key, data in mesh.point_data.items():
mesh.point_data[key] = data.astype(data.dtype.newbyteorder("="),
copy=False)
for data in mesh.cell_data.values():
for k, dat in enumerate(data):
data[k] = dat.astype(dat.dtype.newbyteorder("="), copy=False)
for key, data in mesh.field_data.items():
mesh.field_data[key] = data.astype(data.dtype.newbyteorder("="),
copy=False)
def numpy_to_xml_array(parent, name, data):
vtu_type = numpy_to_vtu_type[data.dtype]
fmt = "{:.11e}" if vtu_type.startswith("Float") else "{:d}"
da = ET.SubElement(parent, "DataArray", type=vtu_type, Name=name)
if len(data.shape) == 2:
da.set("NumberOfComponents", "{}".format(data.shape[1]))
if binary:
da.set("format", "binary")
if compression:
# compressed write
def text_writer(f):
max_block_size = 32768
data_bytes = data.tobytes()
# round up
num_blocks = -int(-len(data_bytes) // max_block_size)
last_block_size = (len(data_bytes) -
(num_blocks - 1) * max_block_size)
# It's too bad that we have to keep all blocks in memory. This is
# necessary because the header, written first, needs to know the
# lengths of all blocks. Also, the blocks are encoded _after_ having
# been concatenated.
c = {"lzma": lzma, "zlib": zlib}[compression]
compressed_blocks = [
# This compress is the slowest part of the writer
c.compress(block)
for block in _chunk_it(data_bytes, max_block_size)
]
# collect header
header = np.array(
[num_blocks, max_block_size, last_block_size] +
[len(b) for b in compressed_blocks],
dtype=vtu_to_numpy_type[header_type],
)
f.write(base64.b64encode(header.tobytes()).decode())
f.write(
base64.b64encode(b"".join(compressed_blocks)).decode())
else:
# uncompressed write
def text_writer(f):
data_bytes = data.tobytes()
# collect header
header = np.array(len(data_bytes),
dtype=vtu_to_numpy_type[header_type])
f.write(
base64.b64encode(header.tobytes() +
data_bytes).decode())
else:
da.set("format", "ascii")
def text_writer(f):
# This write() loop is the bottleneck for the write. Alternatives:
# savetxt is super slow:
# np.savetxt(f, data.reshape(-1), fmt=fmt)
# joining and writing is a bit faster, but consumes huge amounts of
# memory:
# f.write("\n".join(map(fmt.format, data.reshape(-1))))
for item in data.reshape(-1):
f.write((fmt + "\n").format(item))
da.text_writer = text_writer
def _polyhedron_face_cells(face_cells):
# Define the faces of each cell on the format specfied for VTU Polyhedron cells.
# These are defined in Mesh.polyhedron_faces, as block data. The block consists
# of a nested list (outer list represents cell, inner is faces for this cells),
# where the items of the inner list are the nodes of specific faces.
#
# The output format is specified at https://vtk.org/Wiki/VTK/Polyhedron_Support
# Initialize array for size of data per cell.
data_size_per_cell = np.zeros(len(face_cells), dtype=int)
# The data itself is of unknown size, and cannot be initialized
data = []
for ci, cell in enumerate(face_cells):
# Number of faces for this cell
data.append(len(cell))
for face in cell:
# Number of nodes for this face
data.append(face.size)
# The nodes themselves
data += face.tolist()
data_size_per_cell[ci] = len(data)
# The returned data corresponds to the faces and faceoffsets fields in the
# vtu polyhedron data format
return data, data_size_per_cell.tolist()
comment = ET.Comment(f"This file was created by meshio v{__version__}")
vtk_file.insert(1, comment)
grid = ET.SubElement(vtk_file, "UnstructuredGrid")
total_num_cells = sum([len(c.data) for c in mesh.cells])
piece = ET.SubElement(
grid,
"Piece",
NumberOfPoints="{}".format(len(points)),
NumberOfCells=f"{total_num_cells}",
)
# points
if points is not None:
pts = ET.SubElement(piece, "Points")
numpy_to_xml_array(pts, "Points", points)
if mesh.cells is not None and len(mesh.cells) > 0:
cls = ET.SubElement(piece, "Cells")
faces = None
faceoffsets = None
if is_polyhedron_grid:
# The VTK polyhedron format requires both Cell-node connectivity, and a
# definition of faces. The cell-node relation must be recoved from the
# cell-face-nodes currently in CellBlocks.
# NOTE: If polyhedral cells are implemented for more mesh types, this code
# block may be useful for those as well.
con = []
num_nodes_per_cell = []
for block in mesh.cells:
for cell in block.data:
nodes_this_cell = []
for face in cell:
nodes_this_cell += face.tolist()
unique_nodes = np.unique(nodes_this_cell).tolist()
con += unique_nodes
num_nodes_per_cell.append(len(unique_nodes))
connectivity = np.array(con)
# offsets = np.hstack(([0], np.cumsum(num_nodes_per_cell)[:-1]))
offsets = np.cumsum(num_nodes_per_cell)
# Initialize data structures for polyhedral cells
faces = []
faceoffsets = []
else:
# create connectivity, offset, type arrays
connectivity = np.concatenate([
v.data[:,
_meshio_to_vtk_order(v.type, v.data.shape[1])].reshape(
-1) for v in mesh.cells
])
# offset (points to the first element of the next cell)
offsets = [
v.data.shape[1] *
np.arange(1, v.data.shape[0] + 1, dtype=connectivity.dtype)
for v in mesh.cells
]
for k in range(1, len(offsets)):
offsets[k] += offsets[k - 1][-1]
offsets = np.concatenate(offsets)
# types
types_array = []
for k, v in mesh.cells:
# For polygon and polyhedron grids, the number of nodes is part of the cell
# type key. This part must be stripped away.
special_cells = [
"polygon",
"polyhedron",
"VTK_LAGRANGE_CURVE",
"VTK_LAGRANGE_TRIANGLE",
"VTK_LAGRANGE_QUADRILATERAL",
"VTK_LAGRANGE_TETRAHEDRON",
"VTK_LAGRANGE_HEXAHEDRON",
"VTK_LAGRANGE_WEDGE",
"VTK_LAGRANGE_PYRAMID",
]
key_ = None
for string in special_cells:
if k.startswith(string):
key_ = string
if key_ is None:
# No special treatment
key_ = k
# further adaptions for polyhedron
if k.startswith("polyhedron"):
# Get face-cell relation on the vtu format. See comments in helper
# function for more information of how to specify this.
faces_loc, faceoffsets_loc = _polyhedron_face_cells(v)
# Adjust offsets to global numbering
assert faceoffsets is not None
if len(faceoffsets) > 0:
faceoffsets_loc = [
fi + faceoffsets[-1] for fi in faceoffsets_loc
]
assert faces is not None
faces += faces_loc
faceoffsets += faceoffsets_loc
types_array.append(np.full(len(v), meshio_to_vtk_type[key_]))
types = np.concatenate(
types_array
# [np.full(len(v), meshio_to_vtk_type[k]) for k, v in mesh.cells]
)
numpy_to_xml_array(cls, "connectivity", connectivity)
numpy_to_xml_array(cls, "offsets", offsets)
numpy_to_xml_array(cls, "types", types)
if is_polyhedron_grid:
# Also store face-node relation
numpy_to_xml_array(cls, "faces", np.array(faces, dtype=int))
numpy_to_xml_array(cls, "faceoffsets",
np.array(faceoffsets, dtype=int))
if mesh.point_data:
pd = ET.SubElement(piece, "PointData")
for name, data in mesh.point_data.items():
numpy_to_xml_array(pd, name, data)
if mesh.cell_data:
cd = ET.SubElement(piece, "CellData")
for name, data in raw_from_cell_data(mesh.cell_data).items():
numpy_to_xml_array(cd, name, data)
# write_xml(filename, vtk_file, pretty_xml)
tree = ET.ElementTree(vtk_file)
tree.write(filename)
def make_xml(pmx_data, filepath, use_japanese_name, xml_save_versions):
# const
# "\u0030\u003a\u0062\u0061\u0073\u0065\u0028\u56fa\u5b9a\u0029\u0031\u003a\u307e\u3086\u0020\u0032\u003a\u76ee\u0020\u0033\u003a\u30ea\u30c3\u30d7\u0020\u0034\u003a\u305d\u306e\u4ed6"
J_Face_Comment = "\u8868\u60C5\u30B0\u30EB\u30FC\u30D7\u0020\u0030\u003A\u4F7F\u7528\u4E0D\u53EF\u0020\u0031\u003A\u307E\u3086\u0020\u0032\u003A\u76EE\u0020\u0033\u003A\u30EA\u30C3\u30D7\u0020\u0034\u003A\u305D\u306E\u4ED6"
# filename
root, ext = os.path.splitext(filepath)
xml_path = root + ".xml"
num = 1
xml_exist_list = []
a = re.search(r'[0-9]{1,2}$', root)
if a is not None:
num += int(a.group())
root = root.rstrip(a.group())
for index in range(num, xml_save_versions + 1):
if not os.path.isfile(xml_path):
break
xml_exist_list.append(bpy.path.basename(xml_path))
xml_path = root + str(index) + ".xml"
save_message = 'Save As "%s"' % bpy.path.basename(xml_path)
bpy.ops.b2pmxe.message('INVOKE_DEFAULT', type='INFO', line1=save_message)
# print xml_exist_list
if len(xml_exist_list):
print("xml_file is exist:")
for data in xml_exist_list:
print(" --> %s" % data)
#
# XML
#
root = etree.Element('{local}pmxstatus', attrib={'{http://www.w3.org/XML/1998/namespace}lang': 'jp'})
#
# Header
# Name
# Comment
# Add Info
infonode = etree.SubElement(root, "pmdinfo")
infonode.tail = "\r\n"
# Add Name
pmx_name = etree.SubElement(infonode, "name")
pmx_name.text = pmx_data.Name.rstrip()
pmx_name_e = etree.SubElement(infonode, "name_e")
pmx_name_e.text = pmx_data.Name_E.rstrip()
# Add Comment
pmx_cmment = etree.SubElement(infonode, "comment")
pmx_cmment.text = pmx_data.Comment.rstrip()
pmx_cmment_e = etree.SubElement(infonode, "comment_e")
pmx_cmment_e.text = pmx_data.Comment_E.rstrip()
#
# Morphs
#
# Add Morph
morph_root = etree.SubElement(root, "morphs")
morph_root.tail = "\r\n"
morph_comment = etree.Comment(J_Face_Comment)
morph_comment.tail = "\r\n"
morph_root.append(morph_comment)
# Morph
# Name # morph name
# Name_E # morph name English
# Panel # [1:Eyebrows 2:Mouth 3:Eye 4:Other 0:System]
# Type # [0:Group 1:Vertex 2:Bone 3:UV 4:ExUV1 5:ExUV2 6:ExUV3 7:ExUV4 8:Material]
# Offsets # offset data
for (morph_index, pmx_morph) in enumerate(pmx_data.Morphs):
blender_morph_name = Get_JP_or_EN_Name(pmx_morph.Name.rstrip(), pmx_morph.Name_E.rstrip(), use_japanese_name)
morph_node = etree.SubElement(morph_root, "morph")
morph_node.tail = "\r\n"
# morph_node.set('index' , str(morph_index))
morph_node.set('group', str(pmx_morph.Panel))
morph_node.set('name', pmx_morph.Name.rstrip())
morph_node.set('name_e', pmx_morph.Name_E.rstrip())
morph_node.set('b_name', blender_morph_name)
#
# Bones
#
bone_root = etree.SubElement(root, "bones")
bone_root.tail = "\r\n"
blender_bone_list = {}
for (bone_index, pmx_bone) in enumerate(pmx_data.Bones):
blender_bone_name = Get_JP_or_EN_Name(pmx_bone.Name, pmx_bone.Name_E, use_japanese_name, bone_mode=True)
blender_bone_list[bone_index] = (blender_bone_name)
for (bone_index, pmx_bone) in enumerate(pmx_data.Bones):
blender_bone_name = blender_bone_list[bone_index]
bone_node = etree.SubElement(bone_root, "bone")
bone_node.tail = "\r\n"
# bone_node.set("index" , str(bone_index))
bone_node.set("name", pmx_bone.Name)
bone_node.set("name_e", pmx_bone.Name_E)
bone_node.set("b_name", blender_bone_name)
# Bone Status
bone_node.set("rotatable", str(pmx_bone.Rotatable))
bone_node.set("movable", str(pmx_bone.Movable))
bone_node.set("visible", str(pmx_bone.Visible))
bone_node.set("operational", str(pmx_bone.Operational))
bone_node.set("ik", str(pmx_bone.UseIK))
bone_node.set("add_rot", str(pmx_bone.AdditionalRotation))
if pmx_bone.AdditionalBoneIndex >= 0:
bone_node.set("target", blender_bone_list[pmx_bone.AdditionalBoneIndex])
bone_node.set("power", str(pmx_bone.AdditionalPower))
bone_node.set("add_move", str(pmx_bone.AdditionalMovement))
if pmx_bone.AdditionalMovement == 1 or pmx_bone.AdditionalRotation == 1:
bone_node.set("target", blender_bone_list[pmx_bone.AdditionalBoneIndex])
bone_node.set("power", str(pmx_bone.AdditionalPower))
bone_node.set("fixed_axis", str(pmx_bone.UseFixedAxis))
bone_node.set("local_axis", str(pmx_bone.UseLocalAxis))
set_Vector(bone_node, pmx_bone.LocalAxisX, "local_x")
set_Vector(bone_node, pmx_bone.LocalAxisZ, "local_z")
bone_node.set("level", str(pmx_bone.Level))
bone_node.set("after_physical", str(pmx_bone.AfterPhysical))
# if pmx_bone.AfterPhysical = 0 unsupport
# if pmx_bone.ExternalBone = 0 unsupport
#
# Labels
#
# Add Labels
labels_root = etree.SubElement(root, "labels")
labels_root.text = "\r\n"
labels_root.tail = "\r\n"
for (label_index, pmx_label) in enumerate(pmx_data.DisplayFrames):
label_node = etree.SubElement(labels_root, "label")
label_node.tail = "\r\n"
# label_node.set("index" , str(label_index))
label_node.set("name", pmx_label.Name)
label_node.set("name_e", pmx_label.Name_E)
label_node.set("type", str(pmx_label.Type))
for (index, member) in enumerate(pmx_label.Members):
member_node = etree.SubElement(label_node, "tab")
member_node.tail = "\r\n"
# member_node.set("index" , str(index))
if member[0] == 0:
member_node.set("type", "bone")
member_node.set("name", blender_bone_list[member[1]])
else:
member_node.set("type", "morph")
label_morph_name = Get_JP_or_EN_Name(
pmx_data.Morphs[member[1]].Name,
pmx_data.Morphs[member[1]].Name_E,
use_japanese_name)
member_node.set("name", label_morph_name)
#
# Materials
#
material_root = etree.SubElement(root, "materials")
material_root.tail = "\r\n"
for (mat_index, pmx_mat) in enumerate(pmx_data.Materials):
blender_mat_name = Get_JP_or_EN_Name(pmx_mat.Name, pmx_mat.Name_E, use_japanese_name)
material_node = etree.SubElement(material_root, "material")
material_node.tail = "\r\n"
# material_node.set("index",str(mat_index))
material_node.set("name", pmx_mat.Name)
material_node.set("name_e", pmx_mat.Name_E)
material_node.set("b_name", blender_mat_name)
material_node.set("use_systemtoon", str(pmx_mat.UseSystemToon))
if pmx_mat.UseSystemToon == 1:
material_node.set("toon", str(pmx_mat.ToonIndex))
elif pmx_mat.ToonIndex < 0:
material_node.set("toon", "-1")
else:
material_node.set("toon", str(pmx_data.Textures[pmx_mat.ToonIndex].Path))
material_node.set("both", str(pmx_mat.Both))
material_node.set("ground_shadow", str(pmx_mat.GroundShadow))
material_node.set("drop_shadow", str(pmx_mat.DropShadow))
material_node.set("on_shadow", str(pmx_mat.OnShadow))
material_node.set("on_edge", str(pmx_mat.OnEdge))
material_node.set("edge_size", str(pmx_mat.EdgeSize))
material_node.set("power", str(pmx_mat.Power))
material_edge_color = etree.SubElement(material_node, "edge_color")
material_edge_color.set("r", str(pmx_mat.EdgeColor.x))
material_edge_color.set("g", str(pmx_mat.EdgeColor.y))
material_edge_color.set("b", str(pmx_mat.EdgeColor.z))
material_edge_color.set("a", str(pmx_mat.EdgeColor.w))
material_deffuse = etree.SubElement(material_node, "deffuse")
material_deffuse.set("r", str(pmx_mat.Deffuse.x))
material_deffuse.set("g", str(pmx_mat.Deffuse.y))
material_deffuse.set("b", str(pmx_mat.Deffuse.z))
material_deffuse.set("a", str(pmx_mat.Deffuse.w))
material_specular = etree.SubElement(material_node, "specular")
material_specular.set("r", str(pmx_mat.Specular.x))
material_specular.set("g", str(pmx_mat.Specular.y))
material_specular.set("b", str(pmx_mat.Specular.z))
material_ambient = etree.SubElement(material_node, "ambient")
material_ambient.set("r", str(pmx_mat.Ambient.x))
material_ambient.set("g", str(pmx_mat.Ambient.y))
material_ambient.set("b", str(pmx_mat.Ambient.z))
if pmx_mat.SphereIndex != -1 and len(pmx_data.Textures) > pmx_mat.SphereIndex:
material_sphere = etree.SubElement(material_node, "sphere")
material_sphere.set("type", str(pmx_mat.SphereType))
material_sphere.set("path", str(pmx_data.Textures[pmx_mat.SphereIndex].Path))
#
# Rigid
#
rigid_root = etree.SubElement(root, "rigid_bodies")
rigid_root.text = "\r\n"
rigid_root.tail = "\r\n"
for (rigid_index, pmx_rigid) in enumerate(pmx_data.Rigids):
rigid_node = etree.SubElement(rigid_root, "rigid")
rigid_node.tail = "\r\n"
# rigid_node.set("index",str(rigid_index))
rigid_node.set("name", pmx_rigid.Name)
rigid_node.set("name_e", pmx_rigid.Name_E)
if (pmx_rigid.Bone < 0):
rigid_node.set("attach", "World")
else:
rigid_node.set("attach", blender_bone_list[pmx_rigid.Bone])
rigid_node.set("type", str(pmx_rigid.PhysicalType))
rigid_node.set("group", str(pmx_rigid.Group))
rigid_node.set("groups", str(pmx_rigid.NoCollision))
rigid_node.set("shape", str(pmx_rigid.BoundType))
rigid_size = etree.SubElement(rigid_node, "size")
rigid_size.set("a", str("%.7f" % pmx_rigid.Size[0]))
rigid_size.set("b", str("%.7f" % pmx_rigid.Size[1]))
rigid_size.set("c", str("%.7f" % pmx_rigid.Size[2]))
set_Vector(rigid_node, pmx_rigid.Position, "pos")
set_Vector_Deg(rigid_node, pmx_rigid.Rotate, "rot")
rigid_node.set("mass", str("%.7f" % pmx_rigid.Mass))
rigid_node.set("pos_dump", str("%.7f" % pmx_rigid.PosLoss))
rigid_node.set("rot_dump", str("%.7f" % pmx_rigid.RotLoss))
rigid_node.set("restitution", str("%.7f" % pmx_rigid.OpPos))
rigid_node.set("friction", str("%.7f" % pmx_rigid.Friction))
#
# Joint
#
joint_root = etree.SubElement(root, "constraints")
joint_root.text = "\r\n"
joint_root.tail = "\r\n"
for (joint_index, pmx_joint) in enumerate(pmx_data.Joints):
joint_node = etree.SubElement(joint_root, "constraint")
joint_node.tail = "\r\n"
# joint_node.set("index",str(joint_index))
joint_node.set("name", pmx_joint.Name)
joint_node.set("name_e", pmx_joint.Name_E)
joint_node.set("body_A", str(pmx_joint.Parent))
joint_node.set("body_B", str(pmx_joint.Child))
set_Vector(joint_node, pmx_joint.Position, "pos")
set_Vector_Deg(joint_node, pmx_joint.Rotate, "rot")
joint_pos_limit = etree.SubElement(joint_node, "pos_limit")
set_Vector(joint_pos_limit, pmx_joint.PosLowerLimit, "from")
set_Vector(joint_pos_limit, pmx_joint.PosUpperLimit, "to")
joint_rot_limit = etree.SubElement(joint_node, "rot_limit")
set_Vector_Deg(joint_rot_limit, pmx_joint.RotLowerLimit, "from")
set_Vector_Deg(joint_rot_limit, pmx_joint.RotUpperLimit, "to")
set_Vector(joint_node, pmx_joint.PosSpring, "pos_spring")
set_Vector(joint_node, pmx_joint.RotSpring, "rot_spring")
tree = etree.ElementTree(root)
tree.write(xml_path, encoding="utf-8")
return blender_bone_list
from collections import OrderedDict
import re
from xml.etree import ElementTree
from . import base
tag_regexp = re.compile("{([^}]*)}(.*)")
ElementTreeCommentType = ElementTree.Comment("asd").tag
class TreeWalker(base.NonRecursiveTreeWalker): # pylint:disable=unused-variable
"""Given the particular ElementTree representation, this implementation,
to avoid using recursion, returns "nodes" as tuples with the following
content:
1. The current element
2. The index of the element relative to its parent
3. A stack of ancestor elements
4. A flag "text", "tail" or None to indicate if the current node is a
text node; either the text or tail of the current element (1)
"""
def getNodeDetails(self, node):
if isinstance(node, tuple): # It might be the root Element
elt, _, _, flag = node
if flag in ("text", "tail"):
return base.TEXT, getattr(elt, flag)
else:
def adjust(self):
""" Export data to GNU Gama xml, adjust the network and read result
:returns: result list of adjusment and blunder from GNU Gama
"""
# gama-local OK?
if self.gama_path is None:
logging.error("GNU gama path is None")
return (None, None)
# fix = 0 free network
fix = sum([1 for p, s in self.points if s == 'FIX'])
adj = sum([1 for p, s in self.points if s == 'ADJ'])
if adj == 0 or len(self.observations) < 2:
# no unknowns or observations
logging.error("GNU gama no unknowns or not enough observations")
return (None, None)
gama_local = ET.Element('gama-local', {'version': '2.0'})
comment = ET.Comment('Gama XML created by Ulyxes')
gama_local.append(comment)
network = ET.SubElement(gama_local, 'network',
{'axes-xy': 'ne', 'angles': 'left-handed'})
description = ET.SubElement(network, 'description')
if self.dimension == 1:
description.text = 'GNU Gama 1D network'
elif self.dimension == 2:
description.text = 'GNU Gama 2D network'
elif self.dimension == 3:
description.text = 'GNU Gama 3D network'
parameters = ET.SubElement(network, 'parameters',
{'sigma-apr': '1', 'conf-pr': str(self.probability),
'tol-abs': '1000', 'sigma-act': 'aposteriori',
'update-constrained-coordinates': 'yes'})
points_observations = ET.SubElement(network, 'points-observations',
{'distance-stdev': str(self.stdev_dist)+' '+str(self.stdev_dist1),
'direction-stdev': str(self.stdev_angle / 3600.0 * 10000.0),
'angle-stdev': str(math.sqrt(2)*self.stdev_angle/3600.0*10000),
'zenith-angle-stdev': str(self.stdev_angle/3600.0*10000.0)})
for p, s in self.points:
attr = {}
if self.dimension == 1:
attr['id'] = p['id']
if 'elev' in p and p['elev'] is not None:
attr['z'] = str(p['elev'])
if s == 'FIX':
attr['fix'] = 'z'
else:
if fix == 0:
attr['adj'] = 'Z'
else:
attr['adj'] = 'z'
tmp = ET.SubElement(points_observations, 'point', attr)
elif self.dimension == 2:
attr['id'] = p['id']
if 'east' in p and 'north' in p and \
p['east'] is not None and p['north'] is not None:
attr['y'] = str(p['east'])
attr['x'] = str(p['north'])
if s == 'FIX':
attr['fix'] = 'xy'
else:
if fix == 0:
# free network
attr['adj'] = 'XY'
else:
attr['adj'] = 'xy'
tmp = ET.SubElement(points_observations, 'point', attr)
elif self.dimension == 3:
attr['id'] = p['id']
if 'east' in p and 'north' in p and \
p['east'] is not None and p['north'] is not None:
attr['y'] = str(p['east'])
attr['x'] = str(p['north'])
if 'elev' in p and p['elev'] is not None:
attr['z'] = str(p['elev'])
if s == 'FIX':
attr['fix'] = 'xyz'
else:
if fix == 0:
attr['adj'] = 'XYZ'
else:
attr['adj'] = 'xyz'
tmp = ET.SubElement(points_observations, 'point', attr)
for o in self.observations:
if 'station' in o:
# station record
attr = {}
attr['from'] = o['station']
# instrument height
ih = 0
if 'ih' in o:
ih = o['ih']
sta = ET.SubElement(points_observations, 'obs', attr)
else:
# observation
th = 0
if 'th' in o:
th = o['th']
if self.dimension == 2:
# horizontal network
if 'hz' in o:
attr = {}
attr['to'] = o['id']
attr['val'] = str(o['hz'].GetAngle('GON'))
tmp = ET.SubElement(sta, 'direction', attr)
if 'distance' in o and 'v' in o:
# horizontal distance
attr = {}
hd = math.sin(o['v'].GetAngle()) * o['distance']
attr['to'] = o['id']
attr['val'] = str(hd)
tmp = ET.SubElement(sta, 'direction', attr)
elif self.dimension == 1:
# elevations only
pass
elif self.dimension == 3:
# 3d
if 'hz' in o:
attr = {}
attr['to'] = o['id']
attr['val'] = str(o['hz'].GetAngle('GON'))
tmp = ET.SubElement(sta, 'direction', attr)
if 'distance' in o:
attr = {}
attr['to'] = o['id']
attr['val'] = str(o['distance'])
attr['from_dh'] = str(ih)
attr['to_dh'] = str(th)
tmp = ET.SubElement(sta, 's-distance', attr)
if 'v' in o:
attr = {}
attr['to'] = o['id']
attr['val'] = str(o['v'].GetAngle('GON'))
attr['from_dh'] = str(ih)
attr['to_dh'] = str(th)
tmp = ET.SubElement(sta, 'z-angle', attr)
else:
# unknown dimension
logging.error("GNU gama unknown dimension")
return (None, None)
# generate temp file name
f = tempfile.NamedTemporaryFile()
tmp_name = f.name
f.close()
f = open(tmp_name + '.xml', 'w')
w = ET.tostring(gama_local).decode('utf-8')
f.write(w)
f.close()
# run gama-local
status = os.system(self.gama_path + ' ' + tmp_name + '.xml --text ' +
tmp_name + '.txt --xml ' + tmp_name + 'out.xml ' +
'--cov-band 0')
if status != 0:
logging.error("GNU gama failed")
return (None, None)
doc = ET.parse(tmp_name + 'out.xml')
root = doc.getroot()
if not root.tag.endswith("gama-local-adjustment"):
#return res
print("***")
root_tag = re.sub('gama-local-adjustment$', '', root.tag)
p = {} # the single adjusted point from result
blunder = {'std-residual': 0}
for child in root:
if root_tag + "coordinates" == child.tag:
for gchild in child:
if root_tag + "adjusted" == gchild.tag:
for ggchild in gchild:
if root_tag + "point" == ggchild.tag:
for pdata in ggchild:
if root_tag + "id" == pdata.tag:
p['id'] = pdata.text
elif root_tag + "y" == pdata.tag:
p['east'] = float(pdata.text)
elif root_tag + "x" == pdata.tag:
p['north'] = float(pdata.text)
elif root_tag + "z" == pdata.tag:
p['elev'] = float(pdata.text)
if root_tag + "orientation-shifts" == gchild.tag:
for ggchild in gchild:
if root_tag + "orientation" == ggchild.tag:
for pdata in ggchild:
if root_tag + "approx" == pdata.tag:
p['approx_ori'] = float(pdata.text)
if root_tag + "adj" == pdata.tag:
p['ori'] = float(pdata.text)
if root_tag + "cov-mat" == gchild.tag:
i = 0
idx = ['std_east', 'std_north', 'std_elev', 'std_ori']
for ggchild in gchild:
if root_tag + "flt" == ggchild.tag:
p[idx[i]] = math.sqrt(float(ggchild.text))
i += 1
if root_tag + "observations" == child.tag:
for gchild in child:
o = {'std-residual': 0}
if gchild.tag in (root_tag + "direction",
root_tag + "slope-distance",
root_tag + "zenith-angle"):
o["type"] = re.sub('^' + root_tag, '', gchild.tag)
for ggchild in gchild:
if root_tag + "from" == ggchild.tag:
o["from"] = ggchild.text
if root_tag + "to" == ggchild.tag:
o["to"] = ggchild.text
if root_tag + "f" == ggchild.tag:
o["f"] = float(ggchild.text)
if root_tag + "std-residual" == ggchild.tag:
o["std-residual"] = float(ggchild.text)
if o['std-residual'] > self.krit and \
o['std-residual'] > blunder['std-residual'] and \
o['f'] > 10: # extra observations ratio
blunder = o
# remove input xml and output xml
os.remove(tmp_name + '.xml')
os.remove(tmp_name + '.txt')
os.remove(tmp_name + 'out.xml')
return (p, blunder)
def setUp(self):
# Create comment node
self.comment = etree.Comment('foo')
def write(filename, mesh, binary=True, compression="zlib", header_type=None):
# Writing XML with an etree required first transforming the (potentially large)
# arrays into string, which are much larger in memory still. This makes this writer
# very memory hungry. See <https://stackoverflow.com/q/59272477/353337>.
from .._cxml import etree as ET
if not binary:
logging.warning("VTU ASCII files are only meant for debugging.")
if mesh.points.shape[1] == 2:
logging.warning("VTU requires 3D points, but 2D points given. "
"Appending 0 third component.")
mesh.points = numpy.column_stack([
mesh.points[:, 0], mesh.points[:, 1],
numpy.zeros(mesh.points.shape[0])
])
vtk_file = ET.Element(
"VTKFile",
type="UnstructuredGrid",
version="0.1",
# Use the native endianness. Not strictly necessary, but this simplifies things
# a bit.
byte_order=("LittleEndian"
if sys.byteorder == "little" else "BigEndian"),
)
header_type = ("UInt32" if header_type is None else vtk_file.set(
"header_type", header_type))
if binary and compression:
# TODO lz4, lzma <https://vtk.org/doc/nightly/html/classvtkDataCompressor.html>
compressions = {
"lzma": "vtkLZMADataCompressor",
"zlib": "vtkZLibDataCompressor",
}
assert compression in compressions
vtk_file.set("compressor", compressions[compression])
# swap the data to match the system byteorder
# Don't use byteswap to make sure that the dtype is changed; see
# <https://github.com/numpy/numpy/issues/10372>.
points = mesh.points.astype(mesh.points.dtype.newbyteorder("="))
for key, data in mesh.point_data.items():
mesh.point_data[key] = data.astype(data.dtype.newbyteorder("="))
for data in mesh.cell_data.values():
for k, dat in enumerate(data):
data[k] = dat.astype(dat.dtype.newbyteorder("="))
for key, data in mesh.field_data.items():
mesh.field_data[key] = data.astype(data.dtype.newbyteorder("="))
def numpy_to_xml_array(parent, name, fmt, data):
da = ET.SubElement(parent,
"DataArray",
type=numpy_to_vtu_type[data.dtype],
Name=name)
if len(data.shape) == 2:
da.set("NumberOfComponents", "{}".format(data.shape[1]))
if binary:
da.set("format", "binary")
if compression:
# compressed write
def text_writer(f):
max_block_size = 32768
data_bytes = data.tostring()
# round up
num_blocks = -int(-len(data_bytes) // max_block_size)
last_block_size = (len(data_bytes) -
(num_blocks - 1) * max_block_size)
# It's too bad that we have to keep all blocks in memory. This is
# necessary because the header, written first, needs to know the
# lengths of all blocks. Also, the blocks are encoded _after_ having
# been concatenated.
c = {"lzma": lzma, "zlib": zlib}[compression]
compressed_blocks = [
# This compress is the slowest part of the writer
c.compress(block)
for block in _chunk_it(data_bytes, max_block_size)
]
# collect header
header = numpy.array(
[num_blocks, max_block_size, last_block_size] +
[len(b) for b in compressed_blocks],
dtype=vtu_to_numpy_type[header_type],
)
f.write(base64.b64encode(header.tostring()).decode())
f.write(
base64.b64encode(b"".join(compressed_blocks)).decode())
else:
# uncompressed write
def text_writer(f):
data_bytes = data.tostring()
# collect header
header = numpy.array(len(data_bytes),
dtype=vtu_to_numpy_type[header_type])
f.write(
base64.b64encode(header.tostring() +
data_bytes).decode())
else:
da.set("format", "ascii")
def text_writer(f):
# This write() loop is the bottleneck for the write. Alternatives:
# savetxt is super slow:
# numpy.savetxt(f, data.reshape(-1), fmt=fmt)
# joining and writing is a bit faster, but consumes huge amounts of
# memory:
# f.write("\n".join(map(fmt.format, data.reshape(-1))))
for item in data.reshape(-1):
f.write((fmt + "\n").format(item))
da.text_writer = text_writer
return
comment = ET.Comment(
"This file was created by meshio v{}".format(__version__))
vtk_file.insert(1, comment)
grid = ET.SubElement(vtk_file, "UnstructuredGrid")
total_num_cells = sum([len(c.data) for c in mesh.cells])
piece = ET.SubElement(
grid,
"Piece",
NumberOfPoints="{}".format(len(points)),
NumberOfCells="{}".format(total_num_cells),
)
# points
if points is not None:
pts = ET.SubElement(piece, "Points")
numpy_to_xml_array(pts, "Points", "{:.11e}", points)
if mesh.cells is not None:
cls = ET.SubElement(piece, "Cells")
# create connectivity, offset, type arrays
connectivity = numpy.concatenate(
[v.data.reshape(-1) for v in mesh.cells])
# offset (points to the first element of the next cell)
offsets = [
v.data.shape[1] *
numpy.arange(1, v.data.shape[0] + 1, dtype=connectivity.dtype)
for v in mesh.cells
]
for k in range(1, len(offsets)):
offsets[k] += offsets[k - 1][-1]
offsets = numpy.concatenate(offsets)
# types
types = numpy.concatenate(
[numpy.full(len(v), meshio_to_vtk_type[k]) for k, v in mesh.cells])
numpy_to_xml_array(cls, "connectivity", "{:d}", connectivity)
numpy_to_xml_array(cls, "offsets", "{:d}", offsets)
numpy_to_xml_array(cls, "types", "{:d}", types)
if mesh.point_data:
pd = ET.SubElement(piece, "PointData")
for name, data in mesh.point_data.items():
numpy_to_xml_array(pd, name, "{:.11e}", data)
if mesh.cell_data:
cd = ET.SubElement(piece, "CellData")
for name, data in raw_from_cell_data(mesh.cell_data).items():
numpy_to_xml_array(cd, name, "{:.11e}", data)
# write_xml(filename, vtk_file, pretty_xml)
tree = ET.ElementTree(vtk_file)
tree.write(filename)
import xml.etree.ElementTree as etree
import xlrd
xlsdoc = xlrd.open_workbook('E:/PythonProject/Python3/019/number.xls')
sheet = xlsdoc.sheet_by_index(0)
row = sheet.nrows
col = sheet.ncols
alldata = []
for i in range(0, row):
l = sheet.row_values(i)
alldata.append(l)
comment = etree.Comment('数字信息')
root = etree.Element('root')
root.insert(1, comment)
son = etree.SubElement(root, 'numbers')
son.text = str(alldata)
xmldoc = etree.ElementTree(root)
xmldoc.write('E:/PythonProject/Python3/019/number.xml',
encoding='utf-8',
xml_declaration=True)
import blob
parser = argparse.ArgumentParser()
parser.add_argument('Files', nargs = '+', help = "Manifest files")
parser.add_argument('--update', action="store_true", help="Edit manifest files with the updated heatshrink params.")
args = parser.parse_args()
update = True if args.update else False
for manifest_path in args.Files:
if not os.path.isfile(manifest_path):
print("Invalid path: %s" % manifest_path)
continue
tree = ET.parse(manifest_path)
root = tree.getroot()
root.insert(0, ET.Comment(blob.Blob.manifest_comment()))
manifest_entries = root.find("manifest_entries")
if manifest_entries is None:
print("Cannot find <manifest_entries> element in manifest \"%s\"" % manifest_path)
continue
for entry in manifest_entries:
if 'hs_window' in entry.attrib and entry.attrib['hs_window'] != '0' and 'hs_lookahead' in entry.attrib and entry.attrib['hs_lookahead'] != 0:
# Now, do an analysis on the file represented by the entry
path = entry.attrib['path']
path = blob.Blob.parse_path(path, manifest_path, "Continuous", "../..")
if not os.path.isfile(path):
continue
print("\nTesting file %s ..." % path)
smallest = (0, 0, 0)
for window in range(6, 13):
for lookahead in range(3, 7):
def gen_xml_program (self, filename, table_filepath, table_index = None):
''' Generate a series of XML TAGS to program the device using JTAG.
filename Output XML file name to use.
table_filepath Filename for the binary file that holds the Firmware Table info.'''
def add_basic_xml_attributes (xml_elem, operation, filename, start_sect, num_sect):
''' Add the filename, number of sectors and start sectors into a new element.
For example, xml_elem, 'erase', 'fdt.bin', 0, 3 would generate:
<erase filename="fdt.bin" num_partition_sectors="3", start_sector="0" /> '''
element = ET.SubElement(xml_str, operation)
element.set ('filename', filename)
element.set ('start_sector', str(int(start_sect)))
element.set ('num_partition_sectors', str(int(num_sect)))
return element
if table_index == None:
table_list = self.tables
start_block = 0
else:
if not isinstance(table_index, int):
logging.error("Table index is not valid %s" % (str(table_index)))
raise AssertionError("Invalid table index")
if table_index >= len(self.tables) or table_index < 0:
logging.error("Table index out of range %d >= %d" % (table_index, len(self.tables)))
raise AssertionError("Invalid table index, too large or small.")
table_list = []
table_list.append(self.tables[table_index])
start_block = table_index
xml_str = ET.Element('jdata')
xml_str.append(ET.Comment('This is an autogenerated file'))
xml_str.append(ET.Comment('Sector size used is %d' % (self.block_size)))
table_binary = self.tables_to_binary(table_list)
table_len = len(table_binary)
try:
with open(table_filepath , 'wb') as f:
f.seek(0)
f.write(table_binary)
f.close()
except IOError as e:
logging.exception("Unable to open the file '%s'\n" %
(table_filepath))
raise AssertionError("Can't open file %s" % (table_filepath))
table_len_blocks = table_len / self.block_size
# Erase the sectors, then program them.
table_filename = ntpath.basename(table_filepath)
add_basic_xml_attributes (xml_str, 'program', table_filename, start_block, table_len_blocks)
if table_index == None:
count = 0
else:
count = table_index
for table in table_list:
logging.info('Checking for files to add to the image for Firmware Descriptor Table %d' % (count))
count = count + 1
for entry in table:
block_start = entry.get_start_block()
size_blocks = math.ceil (entry.size_in_kb * 1024.0 / float(self.block_size))
# Erase the whole partition
if entry.erase == True:
add_basic_xml_attributes (xml_str, 'erase', entry.filename, block_start, size_blocks)
if len(entry.filename) > 0:
# Try to get the file size to only program the file data, if it can't open use the whole partition.
logging.debug('Will try to open file %s to check size' % (entry.filename))
try:
file_size = os.path.getsize(entry.filename)
file_size_blocks = math.ceil (float(file_size) / float(self.block_size))
if file_size_blocks > size_blocks:
logging.error ("The partition size (%d blocks) isn't large enough to hold the file %s (%d blocks)" % (size_blocks, entry.filename, file_size_blocks))
except:
logging.debug("Unable to access the file '%s', Can't check if it fits in the partition.\n" % (entry.filename))
# Now program only the file data.
add_basic_xml_attributes (xml_str, 'program', entry.filename, block_start, size_blocks)
logging.debug('Completed generating the XML for programming.')
xml_unformat = ET.tostring(xml_str, 'utf-8')
reparse = minidom.parseString(xml_unformat)
reparse.toprettyxml(indent=" ")
try:
with open(filename , 'wb') as f:
f.seek(0)
f.write(reparse.toprettyxml(indent=" "))
f.close()
except IOError as e:
logging.exception("Unable to open the file '%s'\n" %
(filename))
raise AssertionError("Can't open file %s" % (filename))
logging.info('Done Generating XML file to program.')
def __str__(self):
"""Render the output of the PaloAltoFirewall policy into config."""
# IPv4 addresses are normalized into the policy as IPv6 addresses
# using ::<ipv4-address>. The 0.0.0.0-255.255.255.255 range is
# equivalent to ::0/96 which will only match IPv4 addresses; when
# negated it will match only IPv6 addresses.
# Used for address families inet and inet6 when source and
# destination address are not specified (any any).
ANY_IPV4_RANGE = "0.0.0.0-255.255.255.255"
add_any_ipv4 = False
address_book_names_dict = {}
address_book_groups_dict = {}
for zone in self.addressbook:
# building individual addresses dictionary
groups = sorted(self.addressbook[zone])
for group in groups:
for address, name in self.addressbook[zone][group]:
if name in address_book_names_dict:
if address_book_names_dict[name].supernet_of(address):
continue
address_book_names_dict[name] = address
# building individual address-group dictionary
for nested_group in groups:
group_names = []
for address, name in self.addressbook[zone][nested_group]:
group_names.append(name)
address_book_groups_dict[nested_group] = group_names
# sort address books and address sets
address_book_groups_dict = collections.OrderedDict(
sorted(address_book_groups_dict.items()))
address_book_keys = sorted(list(address_book_names_dict.keys()),
key=self._SortAddressBookNumCheck)
# INITAL CONFIG
config = etree.Element("config", {
"version": "8.1.0",
"urldb": "paloaltonetworks"
})
devices = etree.SubElement(config, "devices")
device_entry = etree.SubElement(devices, "entry",
{"name": "localhost.localdomain"})
vsys = etree.SubElement(device_entry, "vsys")
vsys_entry = etree.SubElement(vsys, "entry", {"name": "vsys1"})
# APPLICATION
app_entries = etree.Element("application")
for app_name in self.applications:
if app_name not in self.application_refs:
# this is not a custom application.
continue
app = self.application_refs[app_name]
app_entry = etree.SubElement(app_entries, "entry",
{"name": app_name})
for k in self.application_refs[app_name]:
if isinstance(app[k], (str)):
etree.SubElement(app_entry, k).text = app[k]
elif isinstance(app[k], (dict)):
if k == "default":
default_props = etree.SubElement(app_entry, "default")
else:
continue
for prop in app[k]:
if k == "default" and prop in [
"ident-by-icmp-type", "ident-by-icmp6-type"
]:
icmp_type_props = etree.SubElement(
default_props, prop)
etree.SubElement(icmp_type_props,
"type").text = app[k][prop]
else:
pass
vsys_entry.append(app_entries)
# APPLICATION GROUPS
etree.SubElement(vsys_entry, "application-group")
# SERVICES
vsys_entry.append(etree.Comment(" Services "))
service = etree.SubElement(vsys_entry, "service")
for k, v in self.service_map.entries.items():
entry = etree.SubElement(service, "entry", {"name": v["name"]})
proto0 = etree.SubElement(entry, "protocol")
proto = etree.SubElement(proto0, k[2])
# destination port
port = etree.SubElement(proto, "port")
tup = str(k[1])[1:-1]
if tup[-1] == ",":
tup = tup[:-1]
port.text = tup.replace("'", "").replace(", ", ",")
# source port
if len(k[0]):
sport = etree.SubElement(proto, "source-port")
tup = str(k[0])[1:-1]
if tup[-1] == ",":
tup = tup[:-1]
sport.text = tup.replace("'", "").replace(", ", ",")
# RULES
vsys_entry.append(etree.Comment(" Rules "))
rulebase = etree.SubElement(vsys_entry, "rulebase")
security = etree.SubElement(rulebase, "security")
rules = etree.SubElement(security, "rules")
tag = etree.Element("tag")
tag_num = 0
# pytype: disable=key-error
# pylint: disable=unused-variable
for (header, pa_rules, filter_options) in self.pafw_policies:
tag_name = None
if header.comment:
comment = " ".join(header.comment).strip()
if comment:
tag_num += 1
# max tag len 127, max zone len 31
tag_name = self._TAG_NAME_FORMAT.format(
from_zone=filter_options[1],
to_zone=filter_options[3],
num=tag_num)
tag_entry = etree.SubElement(tag, "entry",
{"name": tag_name})
comments = etree.SubElement(tag_entry, "comments")
if len(comment) > self._MAX_TAG_COMMENTS_LENGTH:
logging.warning(
"WARNING: tag %s comments exceeds maximum "
"length %d, truncated.", tag_name,
self._MAX_TAG_COMMENTS_LENGTH)
comments.text = comment[:self._MAX_TAG_COMMENTS_LENGTH]
no_addr_obj = True if (
len(filter_options) > 5
and filter_options[5] == "no-addr-obj") else False
for name, options in pa_rules.items():
entry = etree.SubElement(rules, "entry", {"name": name})
if options["description"]:
descr = etree.SubElement(entry, "description")
x = " ".join(options["description"])
if len(x) > self._MAX_RULE_DESCRIPTION_LENGTH:
logging.warning(
"WARNING: rule %s description exceeds maximum "
"length %d, truncated.", name,
self._MAX_RULE_DESCRIPTION_LENGTH)
descr.text = x[:self._MAX_RULE_DESCRIPTION_LENGTH]
to = etree.SubElement(entry, "to")
for x in options["to_zone"]:
member = etree.SubElement(to, "member")
member.text = x
from_ = etree.SubElement(entry, "from")
for x in options["from_zone"]:
member = etree.SubElement(from_, "member")
member.text = x
af = filter_options[4] if len(filter_options) > 4 else "inet"
max_src_dst = 0
source = etree.SubElement(entry, "source")
if not options["source"]:
member = etree.SubElement(source, "member")
if not options["destination"] and af != "mixed":
# only inet and inet6 use the any-ipv4 object
member.text = "any-ipv4"
add_any_ipv4 = True
else:
member.text = "any"
else:
for x in options["source"]:
if no_addr_obj:
for group in address_book_groups_dict[x]:
member = etree.SubElement(source, "member")
member.text = str(
address_book_names_dict[group])
max_src_dst += 1
else:
member = etree.SubElement(source, "member")
member.text = x
max_src_dst += 1
if max_src_dst > self._MAX_RULE_SRC_DST_MEMBERS:
raise UnsupportedFilterError(
"term %s source members exceeds maximum of %d: %d" %
(name, self._MAX_RULE_SRC_DST_MEMBERS, max_src_dst))
max_src_dst = 0
dest = etree.SubElement(entry, "destination")
if not options["destination"]:
member = etree.SubElement(dest, "member")
if options["source"]:
member.text = "any"
else:
if af != "mixed":
# only inet and inet6 use the any-ipv4 object
member.text = "any-ipv4"
if af == "inet6":
for x in [
"negate-source", "negate-destination"
]:
negate = etree.SubElement(entry, x)
negate.text = "yes"
else:
member.text = "any"
else:
for x in options["destination"]:
if no_addr_obj:
for group in address_book_groups_dict[x]:
member = etree.SubElement(dest, "member")
member.text = str(
address_book_names_dict[group])
max_src_dst += 1
else:
member = etree.SubElement(dest, "member")
member.text = x
max_src_dst += 1
if max_src_dst > self._MAX_RULE_SRC_DST_MEMBERS:
raise UnsupportedFilterError(
"term %s destination members exceeds maximum of %d: %d"
% (name, self._MAX_RULE_SRC_DST_MEMBERS, max_src_dst))
# service section of a policy rule.
service = etree.SubElement(entry, "service")
if not options["service"] and not options["application"]:
member = etree.SubElement(service, "member")
member.text = "any"
elif not options["service"] and options["application"]:
# Adds custom applications.
member = etree.SubElement(service, "member")
member.text = "application-default"
else:
# Adds services.
for x in options["service"]:
member = etree.SubElement(service, "member")
member.text = x
# ACTION
action = etree.SubElement(entry, "action")
action.text = options["action"]
# check whether the rule is interzone
if list(
set(options["from_zone"]).difference(
options["to_zone"])):
type_ = etree.SubElement(entry, "rule-type")
type_.text = "interzone"
elif not options["from_zone"] and not options["to_zone"]:
type_ = etree.SubElement(entry, "rule-type")
type_.text = "interzone"
# APPLICATION
app = etree.SubElement(entry, "application")
if not options["application"]:
member = etree.SubElement(app, "member")
member.text = "any"
else:
for x in options["application"]:
member = etree.SubElement(app, "member")
member.text = x
if tag_name is not None:
rules_tag = etree.SubElement(entry, "tag")
member = etree.SubElement(rules_tag, "member")
member.text = tag_name
# LOGGING
if options["logging"]:
if "disable" in options["logging"]:
log = etree.SubElement(entry, "log-start")
log.text = "no"
log = etree.SubElement(entry, "log-end")
log.text = "no"
if "log-start" in options["logging"]:
log = etree.SubElement(entry, "log-start")
log.text = "yes"
if "log-end" in options["logging"]:
log = etree.SubElement(entry, "log-end")
log.text = "yes"
# pytype: enable=key-error
if no_addr_obj:
address_book_groups_dict = {}
address_book_keys = {}
# ADDRESS
vsys_entry.append(etree.Comment(" Address Groups "))
addr_group = etree.SubElement(vsys_entry, "address-group")
for group, address_list in address_book_groups_dict.items():
entry = etree.SubElement(addr_group, "entry", {"name": group})
static = etree.SubElement(entry, "static")
for name in address_list:
member = etree.SubElement(static, "member")
member.text = name
vsys_entry.append(etree.Comment(" Addresses "))
addr = etree.SubElement(vsys_entry, "address")
for name in address_book_keys:
entry = etree.SubElement(addr, "entry", {"name": name})
desc = etree.SubElement(entry, "description")
desc.text = name
ip = etree.SubElement(entry, "ip-netmask")
ip.text = str(address_book_names_dict[name])
if add_any_ipv4:
entry = etree.SubElement(addr, "entry", {"name": "any-ipv4"})
desc = etree.SubElement(entry, "description")
desc.text = ("Object to match all IPv4 addresses; "
"negate to match all IPv6 addresses.")
range = etree.SubElement(entry, "ip-range")
range.text = ANY_IPV4_RANGE
vsys_entry.append(tag)
self.config = config
document = etree.tostring(config, encoding="UTF-8")
dom = minidom.parseString(document.decode("UTF-8"))
return dom.toprettyxml(indent=self.INDENT)
def add_comment(self, text):
self.element().append(ET.Comment(text))
elem.tail = j
return elem
def name_parser(name):
'''
name convention:
[name or id] : [ description ]
'''
return name.split(':')
srcdir = sys.argv[1]
dst = sys.argv[2]
top = ET.Element('qgis_style', version="1")
comment = ET.Comment('geologic symbols for QGis')
top.append(comment)
symbols = ET.SubElement(top, 'symbols')
count_dict = {}
status_file = open('../STATUS.md','w')
for rootdir, dirs, files in os.walk( srcdir ):
for filename in files:
if filename.endswith(".xml"):
xmlfile = os.path.join(rootdir, filename)
auth = os.path.dirname( xmlfile ).split('/')[-1]
if auth not in count_dict.keys():
count_dict[auth] = 0
def generate(self):
if len(self.tasks_results) != 1:
raise exceptions.RallyException(
"Only one test suite is expected to be exported.")
t = self.tasks_results[0]
created_at = dt.datetime.strptime(t["created_at"], "%Y-%m-%dT%H:%M:%S")
updated_at = dt.datetime.strptime(t["updated_at"], "%Y-%m-%dT%H:%M:%S")
task = {
"id": t["uuid"],
"name": "heketi-rally-cases",
"tests": 0,
"errors": "0",
"skipped": "0",
"failures": 0,
"time": "%.2f" % (updated_at - created_at).total_seconds(),
"timestamp": t["created_at"],
}
test_cases = []
for workload in itertools.chain(
*[s["workloads"] for s in t["subtasks"]]):
class_name, name = workload["name"].split(".", 1)
test_case = {
"id": workload["uuid"],
"time": "%.2f" % workload["full_duration"],
"name": name,
"classname": class_name,
"timestamp": workload["created_at"]
}
if not workload["pass_sla"]:
task["failures"] += 1
test_case["failure"] = "\n".join([
s["detail"] for s in workload["sla_results"]["sla"]
if not s["success"]
])
test_cases.append(test_case)
task["tests"] = str(len(test_cases))
task["failures"] = str(task["failures"])
testsuite = ET.Element("testsuite", task)
testsuite.append(
ET.Comment(
"Report is generated by Rally %s at %s" %
(version.version_string(), dt.datetime.utcnow().strftime(
consts.TimeFormat.ISO8601))))
for test_case in test_cases:
failure = test_case.pop("failure", None)
test_case = ET.SubElement(testsuite, "testcase", test_case)
if failure:
ET.SubElement(test_case, "failure").text = failure
utils.prettify_xml(testsuite)
raw_report = ET.tostring(testsuite, encoding="utf-8").decode("utf-8")
if self.output_destination:
return {
"files": {
self.output_destination: raw_report
},
"open": "file://" + os.path.abspath(self.output_destination),
}
else:
return {"print": raw_report}
def main(argv):
global top_layers
global list_layers
global output_fd
global root
parser = argparse.ArgumentParser(
description=
'toaster_fixture.py: create Toaster fixture file from setup output')
parser.add_argument('--project-dir',
dest='project_dir',
help='Project Directory')
parser.add_argument('--verbose',
'-v',
action='store_true',
dest='verbose',
help='Verbose mode')
args = parser.parse_args()
# Core paths
script_dir = os.path.dirname(os.path.abspath(argv[0]))
wrlinux_dir = os.path.dirname(script_dir)
if args.project_dir:
install_dir = args.project_dir
else:
install_dir = os.getcwd()
# Read setup default.xml data
default_xml_file = os.path.join(install_dir, 'default.xml')
if not os.path.exists(default_xml_file):
print(
"ERROR: 'default.xml' does not exist. You need to run the 'setup' program."
)
exit(-1)
else:
remote_base_fetch, remote_base_revision, bitbake_branch, bitbake_path = read_default_xml(
default_xml_file)
bitbake_url = os.path.join(remote_base_fetch, bitbake_path)
# Load layer index cache
json_cache = os.path.join(install_dir,
settings.INDEXES[0]['CACHE'] + '.json')
read_layer_index_cache(json_cache)
# Discover the XML directory
xml_dir = os.path.join(wrlinux_dir, 'data/xml')
if os.path.exists(
os.path.join(install_dir, 'config', 'mirror-index', 'xml')):
xml_dir = os.path.join(install_dir, 'config', 'mirror-index', 'xml')
# Prepare the output file
output_fd = open(os.path.join(install_dir, FIXTURE_FILE), 'w')
write_prolog()
# Write Toaster environment hints
# 1. Point Toaster to the wrlinux-x directory
root.append(ET.Comment(' HINT:WRLINUX_DIR="%s" ' % wrlinux_dir))
# Write default setting overrides
root.append(ET.Comment(' Set the project default values '))
append_setting('DEFCONF_DISTRO', settings.DEFAULT_DISTRO, 1)
append_setting('DEFAULT_RELEASE', remote_base_revision, 2)
append_setting('DEFCONF_MACHINE', settings.DEFAULT_MACHINE, 4)
# append custom settings
setting_pk = CUSTOM_SETTINGS_BASE
setting_pk = append_setting('DEFCONF_LINUX_KERNEL_TYPE',
settings.DEFAULT_KTYPE, setting_pk)
setting_pk = append_setting('DEFAULT_KTYPE_LIST',
'standard preempt-rt tiny', setting_pk)
setting_pk = append_setting('CUSTOM_LAYERINDEX_SERVER', json_cache,
setting_pk)
setting_pk = append_setting('SETUP_XMLDIR', xml_dir, setting_pk)
setting_pk = append_setting('SETUP_GITURL', remote_base_fetch, setting_pk)
setting_pk = append_setting('SETUP_PATH_FILTER',
's|layers/[a-zA-Z0-9_-]*||', setting_pk)
# Write bitbake version
root.append(
ET.Comment(
' Bitbake versions which correspond to the metadata release '))
bitbake_pk = 1
bitbake_pk = append_bitbake(remote_base_revision, bitbake_url,
bitbake_branch, bitbake_pk)
# Write releases
root.append(ET.Comment(' Releases available '))
append_releases(
remote_base_revision, "Wind River Linux " + remote_base_revision, 1,
remote_base_revision,
"Toaster will run your builds using the tip of the Wind River Linux '%s' branch."
% remote_base_revision)
# Write base default layers
for layer in settings.BASE_LAYERS.split():
top_layers.append(layer)
# Write DEFAULT_MACHINE layer
add_machine_layers(settings.DEFAULT_MACHINE)
# Write DEFAULT_DISTRO layer
add_distro_layers(settings.DEFAULT_DISTRO)
# Resolve dependent layers, exclude optional layers
for layer in top_layers:
add_dependent_layers(layer, INCLUDE_DEFAULT_LAYERS)
# Write default layer list per release
root.append(ET.Comment(' Default project layers for each release '))
default_layers_pk = 1
default_layers_pk = write_default_layer_release(1, default_layers_pk)
# Write layer list
root.append(ET.Comment(' Default layers from wrlinux defaults '))
layer_pk, layer_version_pk = write_layer_release(1, 1, TYPE_LAYERINDEX)
write_epilog()
output_fd.close()
if args.verbose:
print("Done:")
print(
" Layers=%d, LayerRelease=%d, LayerVersions=%d, Custom Settings=%d"
% (len(list_layers), layer_pk, layer_version_pk,
setting_pk - CUSTOM_SETTINGS_BASE))
print(" Default Layers=%s" % list_layers)
def build(root, textures, links_param_revert):
"""
Creates textures with in the scene.
Return a list of texture ids.
"""
verbose = config.verbose
if verbose: print("textures_builder_fbx launched")
comment = etree.Comment("Textures with ids")
root.append(comment)
textures_id = {}
if textures != [] and not os.path.exists(config.filepath +
"export\\textures"):
os.makedirs(config.filepath + "export\\textures")
copyfile(config.curr_place + "\\missing_texture.png",
config.filepath + "export\\textures\\missing_texture.png")
# Go through all textures in the scene
for texture in textures:
id, type, obj = texture.get("value").replace("::", "").split(",")
rel_reference = texture.find("RelativeFilename").text.strip()
abs_reference = texture.find("FileName").text.strip()
properties = tools.getProperties(texture)
uoff, voff = properties["Translation"][
-3:-1] if "Translation" in properties else ["0", "0"]
uscaling, vscaling = properties["Scaling"][
-3:-1] if "Scaling" in properties else ["1", "1"]
if rel_reference == "" and abs_reference == "":
if verbose:
print("Empty reference for id " + id +
", replacing with error texture")
reference = "textures\\missing_texture.png"
# Try relative path then absolute if it did'nt work
elif not Path(config.filepath + rel_reference).is_file():
if not Path(abs_reference).is_file():
if verbose: print("Missing texture : " + rel_reference)
reference = "textures\\missing_texture.png"
else:
new_reference = "textures\\" + id + "." + abs_reference.split(
".")[-1]
copyfile(abs_reference,
config.filepath + "export\\" + new_reference)
reference = new_reference
else:
new_reference = "textures\\" + id + "." + abs_reference.split(
".")[-1]
copyfile(config.filepath + rel_reference,
config.filepath + "export\\" + new_reference)
reference = new_reference
if id not in links_param_revert:
if verbose:
print("Texture " + reference +
" never used. Not writing it to file.")
elif any(reference.lower().endswith(s)
for s in [".bmp", ".jpg", ".png", ".tga", ".exr"]):
textures_id[id] = properties
textures_id[id]["reference"] = reference
curr_texture = tools.create_obj(root, "texture", "bitmap", id)
tools.set_value(curr_texture, "string", "filename", reference)
# Avoid cluttering for the final file, removing 0 offsets and 1 scaling
if uoff != "0":
tools.set_value(curr_texture, "float", "uoffset", uoff)
if voff != "0":
tools.set_value(curr_texture, "float", "voffset", voff)
if uscaling != "1":
tools.set_value(curr_texture, "float", "uscale", uscaling)
if vscaling != "-1":
tools.set_value(curr_texture, "float", "vscale",
str(-float(vscaling)))
# Textures in 3dsmax have their v values inverted compared to mitsuba.
else:
print("Unknown texture file type : " + reference.split(".")[-1])
print("for file : " + reference)
return textures_id
def salvar_partida_completa(c, dados=None):
"""
Salva os dados da partida em um arquivo para ser recuperado depois.
Os dados seguem as seguintes restricoes:
Devem ser um dicionario com as chaves todas como string
Ele aceita valores de conteudo como int, float ou string
Ele aceita que o valor seja uma lista, porem:
Todos os elementos devem ser do mesmo tipo.
Os elementos seguem as mesmas regras acima (int, float, string)
Retorna 0
"""
peoes = _coletar_peoes(c) # coleta as peoes do BD
tabuleiro = _coletar_tabuleiro(c) # coleta as peoes no tabuleiro do BD
jogo = ET.Element('jogo') # topo do xml
jogo.append(ET.Comment("Dados de uma partida de ludo"))
# para peoes e tabuleiros, preciso criar um elemento
# depois, criar um elemento para cada objeto, e com seus dados,
# criar um elemento para cada dado, setando o seu tipo e seu conteudo
elementos_peoes = ET.SubElement(jogo, 'peoes') # guardando as peoes
for p in peoes:
elemento_peao = ET.SubElement(elementos_peoes, 'peao')
for d in p:
elemento_dado = ET.SubElement(elemento_peao,
d) # chave do dicionario
elemento_dado.text = str(p[d]) # conteudo do dicionario
elemento_dado.set(
'tipo', str(type(p[d]).__name__)
) # armazena o tipo da variavel para converter dps
# repete a mesma coisa para o tabuleiro
elementos_tabuleiro = ET.SubElement(jogo, 'tabuleiros')
for t in tabuleiro:
elemento_tabuleiro = ET.SubElement(elementos_tabuleiro, 'tabuleiro')
for d in t:
elemento_dado = ET.SubElement(elemento_tabuleiro, d)
elemento_dado.text = str(t[d])
elemento_dado.set('tipo', str(type(t[d]).__name__))
# para dados, eh mais complicado.
# funciona parecido, mas eh mais geral
# se o dado for uma lista, preciso converter toda a lista.
# CONSIDERANDO QUE TODOS OS ELEMENTOS DA LISTA SAO DO MESMO TIPO
if dados is not None:
elemento_dados = ET.SubElement(jogo, 'dados')
for d in dados:
if type(dados[d]) == list: # se o dado for uma lista
elemento_dado = ET.SubElement(elemento_dados, d)
elemento_dado.text = ','.join([str(x) for x in dados[d]
]) # junta tudo com virgulas
elemento_dado.set('tipo', 'list')
if not dados[d]:
elemento_dado.set(
'subtipo',
'str') # se a lista estiver vazia, fala que eh string
else:
elemento_dado.set('subtipo', str(
type(dados[d][0]).__name__)) # pega o tipo do primeiro
elif type(dados[d]) not in [str, int, float]:
print("Nao consegui armazenar o dado:", d, dados[d])
else:
elemento_dado = ET.SubElement(elemento_dados, d)
elemento_dado.text = str(dados[d])
elemento_dado.set('tipo', str(type(dados[d]).__name__))
saida = _formata_xml(jogo) # copia dos slides 15
with open(PATH + ARQUIVO_PARTIDA, "w+") as f:
f.write(saida)
return 0
def create_comment_element(text):
"""
creates and returns a xml comment element
"""
elem = ElementTree.Comment(text)
return elem
def rupture_to_element(rupture, parent=None):
"""
Convert a rupture object into an Element object.
:param rupture:
must have attributes .rupture, .tag and .seed
:param parent:
if None a new element is created, otherwise a sub element is
attached to the parent.
"""
if parent is None:
rup_elem = et.Element('rupture')
else:
rup_elem = et.SubElement(parent, 'rupture')
rup_elem.append(et.Comment('rupture seed=%d' % rupture.seed))
rup = rupture.rupture
rup_elem.set('id', rupture.tag)
rup_elem.set('magnitude', str(rup.magnitude))
rup_elem.set('strike', str(rup.strike))
rup_elem.set('dip', str(rup.dip))
rup_elem.set('rake', str(rup.rake))
rup_elem.set('tectonicRegion', str(rup.tectonic_region_type))
if rup.is_from_fault_source:
# rup is from a simple or complex fault source
# the rup geometry is represented by a mesh of 3D
# points
mesh_elem = et.SubElement(rup_elem, 'mesh')
# we assume the mesh components (lons, lats, depths)
# are of uniform shape
for i, row in enumerate(rup.lons):
for j, col in enumerate(row):
node_elem = et.SubElement(mesh_elem, 'node')
node_elem.set('row', str(i))
node_elem.set('col', str(j))
node_elem.set('lon', str(rup.lons[i][j]))
node_elem.set('lat', str(rup.lats[i][j]))
node_elem.set('depth', str(rup.depths[i][j]))
try:
# if we never entered the loop above, it's possible
# that i and j will be undefined
mesh_elem.set('rows', str(i + 1))
mesh_elem.set('cols', str(j + 1))
except NameError:
raise ValueError('Invalid rupture mesh')
else:
# rupture is from a multi surface fault source
if rup.is_multi_surface:
# the arrays lons, lats and depths contain 4*N elements,
# where N is the number of planar surfaces contained in the
# multisurface; each planar surface if characterised by 4
# vertices top_left, top_right, bottom_left, bottom_right
assert len(rup.lons) % 4 == 0
assert len(rup.lons) == len(rup.lats) == len(rup.depths)
for offset in range(len(rup.lons) / 4):
# looping on the coordinates of the sub surfaces, one
# planar surface at the time
start = offset * 4
end = offset * 4 + 4
lons = rup.lons[start:end] # 4 lons of the current surface
lats = rup.lats[start:end] # 4 lats of the current surface
depths = rup.depths[start:end] # 4 depths
ps_elem = et.SubElement(rup_elem, 'planarSurface')
top_left, top_right, bottom_left, bottom_right = \
zip(lons, lats, depths)
for el_name, corner in (('topLeft', top_left),
('topRight', top_right), ('bottomLeft',
bottom_left),
('bottomRight', bottom_right)):
corner_elem = et.SubElement(ps_elem, el_name)
corner_elem.set('lon', str(corner[0]))
corner_elem.set('lat', str(corner[1]))
corner_elem.set('depth', str(corner[2]))
else:
# rupture is from a point or area source
# the rupture geometry is represented by four 3D
# corner points
ps_elem = et.SubElement(rup_elem, 'planarSurface')
# create the corner point elements, in the order of:
# * top left
# * top right
# * bottom left
# * bottom right
for el_name, corner in (('topLeft', rup.top_left_corner),
('topRight', rup.top_right_corner),
('bottomLeft', rup.bottom_left_corner),
('bottomRight', rup.bottom_right_corner)):
corner_elem = et.SubElement(ps_elem, el_name)
corner_elem.set('lon', str(corner[0]))
corner_elem.set('lat', str(corner[1]))
corner_elem.set('depth', str(corner[2]))
return rup_elem
def test_write_comment(self):
el = ET.Comment('Test comment')
c = StringIO()
self.assertTrue(self.provider.write_comment(c, el))
self.assertEqual(c.getvalue(), '#Test comment\n')
del(c, el)
def to_comment(el, data, key):
val = data[key]
if val and val != null:
el.append(ET.Comment(val))
def generate_ome_xml_description(cls, axes, shape, dtype, filename=''):
"""
Generate an OME XML description of the data we're exporting,
suitable for the image_description tag of the first page.
axes and shape should be provided in C-order (will be reversed in the XML)
"""
import uuid
import xml.etree.ElementTree as ET
# Normalize the inputs
axes = "".join(axes)
shape = tuple(shape)
if not isinstance(dtype, type):
dtype = dtype().type
ome = ET.Element('OME')
uuid_str = "urn:uuid:" + str(uuid.uuid1())
ome.set('UUID', uuid_str)
ome.set('xmlns:xsi', "http://www.w3.org/2001/XMLSchema-instance")
ome.set(
'xsi:schemaLocation',
"http://www.openmicroscopy.org/Schemas/OME/2015-01 "
"http://www.openmicroscopy.org/Schemas/OME/2015-01/ome.xsd")
image = ET.SubElement(ome, 'Image')
image.set('ID', 'Image:0')
image.set('Name', 'exported-data')
pixels = ET.SubElement(image, 'Pixels')
pixels.set('BigEndian', 'true')
pixels.set('ID', 'Pixels:0')
fortran_axes = "".join(reversed(axes)).upper()
pixels.set('DimensionOrder', fortran_axes)
for axis, dim in zip(axes.upper(), shape):
pixels.set('Size' + axis, str(dim))
types = {
numpy.uint8: 'uint8',
numpy.uint16: 'uint16',
numpy.uint32: 'uint32',
numpy.int8: 'int8',
numpy.int16: 'int16',
numpy.int32: 'int32',
numpy.float32: 'float',
numpy.float64: 'double',
numpy.complex64: 'complex',
numpy.complex128: 'double-complex'
}
pixels.set('Type', types[dtype])
# Omit channel information (is that okay?)
# channel0 = ET.SubElement(pixels, "Channel")
# channel0.set("ID", "Channel0:0")
# channel0.set("SamplesPerPixel", "1")
assert axes[-2:] == "yx"
for page_index, page_ndindex in enumerate(numpy.ndindex(*shape[:-2])):
tiffdata = ET.SubElement(pixels, "TiffData")
for axis, index in zip(axes[:-2].upper(), page_ndindex):
tiffdata.set("First" + axis, str(index))
tiffdata.set("PlaneCount", "1")
tiffdata.set("IFD", str(page_index))
uuid_tag = ET.SubElement(tiffdata, "UUID")
uuid_tag.text = uuid_str
uuid_tag.set('FileName', filename)
from textwrap import dedent
from StringIO import StringIO
xml_stream = StringIO()
comment = ET.Comment(
dedent(
'\
<!-- Warning: this comment is an OME-XML metadata block, which contains crucial '
'dimensional parameters and other important metadata. Please edit cautiously '
'(if at all), and back up the original data before doing so. For more information, '
'see the OME-TIFF web site: http://ome-xml.org/wiki/OmeTiff. -->'
))
tree = ET.ElementTree(ome)
tree.write(xml_stream, encoding='utf-8', xml_declaration=True)
if logger.isEnabledFor(logging.DEBUG):
import xml.dom.minidom
reparsed = xml.dom.minidom.parseString(xml_stream.getvalue())
logger.debug("Generated OME-TIFF metadata:\n" +
reparsed.toprettyxml())
return xml_stream.getvalue()
def write_xacro(self):
# Defining the robot
root = ET.Element('robot')
root.set('name','{}_robot'.format(self.getID()))
root.set('xmlns:xacro','http://www.ros.org/wiki/xacro')
# Initializing the constants for the robot
Comment = [ET.Comment('Constants for robot dimensions')]
root.append(Comment[-1])
pi = ET.SubElement(root,'xacro:property')
pi.set('name','PI')
pi.set('value','3.1415926535897931')
dens = ET.SubElement(root,'xacro:property')
dens.set('name','density')
dens.set('value',str(self._dens))
axel_offset = ET.SubElement(root,'xacro:property')
axel_offset.set('name','axel_offset')
axel_offset.set('value','0.05')
# Importing Gazebo elements
find_gazebo = ET.SubElement(root, 'xacro:include')
ID = self.getID()
find_gazebo.set('filename','$(find robot_generator)/urdf/{0}_root/{0}_robot.gazebo'.format(ID))
# Importing materials
materials = ET.SubElement(root, 'xacro:include')
materials.set('filename','$(find robot_generator)/urdf/materials.xacro'.format(ID))
# World link to connect the robot to the Gazebo frame of reference with a fixed joint
Comment.append(ET.Comment('World link for fixing robot to Gazebo frame'))
root.append(Comment[-1])
link = [ET.SubElement(root,'link')]
link[-1].set('name','world')
joint = [ET.SubElement(root,'joint')]
joint[-1].set('name','joint0')
joint[-1].set('type','fixed')
parent = [ET.SubElement(joint[-1],'parent')]
parent[-1].set('link','world')
child = [ET.SubElement(joint[-1],'child')]
child[-1].set('link','link1')
# Creating newly generated robot
Comment.append(ET.Comment('Start of generated robot'))
root.append(Comment[-1])
for k in range(self.getLinkNo()):
root = self.add_link(root,k)
if k == 0: continue
root = self.add_joint(root,k)
root = self.add_transmission(root,k)
ID = self.getID()
finalString = self.xml_space(root)
# Write file to a urdf file with the robot's ID. Eg. robot_1.urdf
fileName = '{}_robot.xacro'.format(ID)
self.write_file(finalString,fileName)
def header(self, comment):
self.rec = ElementTree.Element('add')
cmt_el = ElementTree.Comment(' Generated on {} {} '.format(
datetime.date.today(), comment))
self.rec.append(cmt_el)
