def test_diagram_includes_edges(self):
code = """
diagram {
A -> B -> C;
}
"""
tree = parse_string(code)
self.assertIsInstance(tree, Diagram)
self.assertEqual(1, len(tree.stmts))
self.assertIsInstance(tree.stmts[0], Statements)
self.assertEqual(2, len(tree.stmts[0].stmts))
self.assertIsInstance(tree.stmts[0].stmts[0], Edge)
self.assertIsInstance(tree.stmts[0].stmts[1], Edge)
code = """
diagram {
A -> B -> C [style = dotted];
D -> E, F;
}
"""
tree = parse_string(code)
self.assertIsInstance(tree, Diagram)
self.assertEqual(2, len(tree.stmts))
self.assertIsInstance(tree.stmts[0], Statements)
self.assertEqual(2, len(tree.stmts[0].stmts))
self.assertIsInstance(tree.stmts[0].stmts[0], Edge)
self.assertIsInstance(tree.stmts[0].stmts[1], Edge)
self.assertIsInstance(tree.stmts[1], Statements)
self.assertEqual(1, len(tree.stmts[1].stmts))
self.assertIsInstance(tree.stmts[1].stmts[0], Edge)
def node2diagram(self, node):
try:
tree = parser.parse_string(node['code'])
except:
code = 'blockdiag { %s }' % node['code']
tree = parser.parse_string(code)
node['code'] = code # replace if suceeded
return ScreenNodeBuilder.build(tree)
def test_empty_diagram(self):
code = """
diagram {
}
"""
tree = parse_string(code)
self.assertIsInstance(tree, Diagram)
code = """
{
}
"""
tree = parse_string(code)
self.assertIsInstance(tree, Diagram)
def test_diagram_includes_groups(self):
code = """
diagram {
group {
A; B;
}
group {
C -> D;
}
}
"""
tree = parse_string(code)
self.assertIsInstance(tree, Diagram)
self.assertEqual(2, len(tree.stmts))
self.assertIsInstance(tree.stmts[0], Group)
self.assertEqual(2, len(tree.stmts[0].stmts))
self.assertIsInstance(tree.stmts[0].stmts[0], Statements)
self.assertIsInstance(tree.stmts[0].stmts[0].stmts[0], Node)
self.assertIsInstance(tree.stmts[0].stmts[1], Statements)
self.assertIsInstance(tree.stmts[0].stmts[1].stmts[0], Node)
self.assertIsInstance(tree.stmts[1], Group)
self.assertEqual(1, len(tree.stmts[1].stmts))
self.assertIsInstance(tree.stmts[1].stmts[0], Statements)
self.assertIsInstance(tree.stmts[1].stmts[0].stmts[0], Edge)
def renderToFile(self, content, imagePath):
"""
content - текст, описывающий диаграмму
imagePath - полный путь до создаваемого файла
"""
from blockdiag.parser import parse_string
from blockdiag.drawer import DiagramDraw
from blockdiag.builder import ScreenNodeBuilder
from blockdiag.utils.fontmap import FontMap
font = os.path.join(os.path.dirname(os.path.abspath(__file__)),
u"fonts",
self._fontDefault)
fontmap = FontMap()
fontmap.set_default_font(font)
text = u"blockdiag {{ {content} }}".format(content=content)
tree = parse_string(text)
diagram = ScreenNodeBuilder.build(tree)
draw = DiagramDraw("png", diagram, imagePath,
fontmap=fontmap, antialias=True)
draw.draw()
draw.save()
def draw_diagram(graph, module="blockdiag", format="pillow", **options):
"""
Draw a graph based on module :epkg:`blockdiag`.
@param graph graph definition,
see `syntax <http://blockdiag.com/en/blockdiag/examples.html>`_
@param module ``'blockdiag'`` (only available value)
@param format can be a filename or a module name (``'pillow'``)
@param options additional options for :epkg:`blockdiag`
@return graph
::
blockdiag {
A -> B -> C -> D;
A -> E -> F -> G;
}
See notebook :ref:`drawdiagramrst`.
"""
if module == "blockdiag":
import blockdiag
module = blockdiag
import blockdiag.parser
parser = blockdiag.parser
import blockdiag.builder
builder = blockdiag.builder
import blockdiag.drawer
drawer = blockdiag.drawer
else:
raise ValueError(
"Unexected value for 'blockdiag': '{0}'".format(module))
if format in ("pillow", "png"):
ftype = "png"
elif format == "svg":
ftype = "svg"
else:
raise ValueError("format should in ['pillow', 'svg']")
fontmap = _create_fontmap(fontmap=options.get('fontmap', None),
font=options.get('font', None))
tree = parser.parse_string(graph)
res = _build_diagram(module=module,
builder=builder,
drawer=drawer,
tree=tree,
code=graph,
fontmap=fontmap,
type=ftype,
antialias=options.get('antialias', True),
nodoctype=options.get('nodoctype', False),
transparency=options.get('transparency', False),
size=options.get('size', None))
if format == "pillow":
from PIL import Image
image = Image.open(io.BytesIO(res))
return image
else:
return res
def test_without_diagram_id(self):
code = """
diagram {
A -> B -> C, D;
}
"""
tree = parse_string(code)
self.assertIsInstance(tree, Diagram)
code = """
{
A -> B -> C, D;
}
"""
tree = parse_string(code)
self.assertIsInstance(tree, Diagram)
def renderToFile(self, content, imagePath):
"""
content - текст, описывающий диаграмму
imagePath - полный путь до создаваемого файла
"""
from blockdiag.parser import parse_string
from blockdiag.drawer import DiagramDraw
from blockdiag.builder import ScreenNodeBuilder
from blockdiag.utils.fontmap import FontMap
font = os.path.join(os.path.dirname(os.path.abspath(__file__)),
u"fonts", self._fontDefault)
fontmap = FontMap()
fontmap.set_default_font(font)
text = u"blockdiag {{ {content} }}".format(content=content)
tree = parse_string(text)
diagram = ScreenNodeBuilder.build(tree)
draw = DiagramDraw("png",
diagram,
imagePath,
fontmap=fontmap,
antialias=True)
draw.draw()
draw.save()
def flowchartdiag_generate_image(source, format):
from blockdiag import parser, builder, drawer
from blockdiag.utils.fontmap import FontMap
from StringIO import StringIO
from flowchartdiag import parse, write_stmt
try:
ast = parse(source)
dot = StringIO()
dot.write("{\n")
dot.write(" orientation = portrait\n")
dot.write(" edge_layout = flowchart\n")
dot.write(" node_width = 256\n")
write_stmt(dot, ast.body)
dot.write("}\n")
tree = parser.parse_string(dot.getvalue())
diagram = builder.ScreenNodeBuilder.build(tree)
draw = drawer.DiagramDraw(format, diagram, fontmap=FontMap(),
ignore_pil=True)
draw.draw()
image = draw.save()
etype = None
error = None
except Exception, e:
image = ''
etype = e.__class__.__name__
error = str(e)
def test_diagram_includes_nodes(self):
code = """
diagram {
A;
B [label = "foobar"];
C [color = "red"];
D [label = 'foobar'];
E [color = 'red'];
F [label = \"\"\"foobar\"\"\"];
G [label = \'\'\'foobar\'\'\'];
H [label = \"\"\"foo"bar\"\"\"];
I [label = \'\'\'foo'bar\'\'\'];
}
"""
tree = parse_string(code)
self.assertIsInstance(tree, Diagram)
self.assertEqual(9, len(tree.stmts))
self.assertIsInstance(tree.stmts[0], Statements)
self.assertIsInstance(tree.stmts[0].stmts[0], Node)
self.assertIsInstance(tree.stmts[1], Statements)
self.assertIsInstance(tree.stmts[1].stmts[0], Node)
self.assertIsInstance(tree.stmts[2], Statements)
self.assertIsInstance(tree.stmts[2].stmts[0], Node)
self.assertIsInstance(tree.stmts[3], Statements)
self.assertIsInstance(tree.stmts[3].stmts[0], Node)
self.assertIsInstance(tree.stmts[4], Statements)
self.assertIsInstance(tree.stmts[4].stmts[0], Node)
self.assertIsInstance(tree.stmts[5], Statements)
self.assertIsInstance(tree.stmts[5].stmts[0], Node)
self.assertIsInstance(tree.stmts[6], Statements)
self.assertIsInstance(tree.stmts[6].stmts[0], Node)
self.assertIsInstance(tree.stmts[7], Statements)
self.assertIsInstance(tree.stmts[7].stmts[0], Node)
self.assertIsInstance(tree.stmts[8], Statements)
self.assertIsInstance(tree.stmts[8].stmts[0], Node)
def test_diagram_includes_diagram_attributes(self):
code = """
diagram {
fontsize = 12;
node_width = 80;
}
"""
tree = parse_string(code)
self.assertIsInstance(tree, Diagram)
self.assertEqual(2, len(tree.stmts))
def test_basic(self):
# basic digram
code = """
diagram test {
A -> B -> C, D;
}
"""
tree = parse_string(code)
self.assertIsInstance(tree, Diagram)
def draw_diagram(graph, module="blockdiag", format="pillow", **options):
"""
Draws a graph based on module :epkg:`blockdiag`.
@param graph graph definition,
see `syntax <http://blockdiag.com/en/blockdiag/examples.html>`_
@param module ``'blockdiag'`` (only available value)
@param format can be a filename or a module name (``'pillow'``)
@param options additional options for :epkg:`blockdiag`
@return graph
::
blockdiag {
A -> B -> C -> D;
A -> E -> F -> G;
}
See notebook :ref:`drawdiagramrst`.
"""
if module == "blockdiag":
import blockdiag
module = blockdiag
import blockdiag.parser
parser = blockdiag.parser
import blockdiag.builder
builder = blockdiag.builder
import blockdiag.drawer
drawer = blockdiag.drawer
else:
raise ValueError(
"Unexected value for 'blockdiag': '{0}'".format(module))
if format in ("pillow", "png"):
ftype = "png"
elif format == "svg":
ftype = "svg"
else:
raise ValueError("format should in ['pillow', 'svg']")
fontmap = _create_fontmap(fontmap=options.get('fontmap', None),
font=options.get('font', None))
tree = parser.parse_string(graph)
res = _build_diagram(module=module, builder=builder, drawer=drawer,
tree=tree, code=graph, fontmap=fontmap, type=ftype,
antialias=options.get('antialias', True),
nodoctype=options.get('nodoctype', False),
transparency=options.get('transparency', False),
size=options.get('size', None))
if format == "pillow":
from PIL import Image
image = Image.open(io.BytesIO(res))
return image
else:
return res
def test_diagram_includes_nodes(self):
code = """
diagram {
A;
B [label = "foobar"];
C [color = "red"];
}
"""
tree = parse_string(code)
self.assertIsInstance(tree, Diagram)
self.assertEqual(3, len(tree.stmts))
self.assertIsInstance(tree.stmts[0], Statements)
self.assertIsInstance(tree.stmts[0].stmts[0], Node)
self.assertIsInstance(tree.stmts[1], Statements)
self.assertIsInstance(tree.stmts[1].stmts[0], Node)
self.assertIsInstance(tree.stmts[2], Statements)
self.assertIsInstance(tree.stmts[2].stmts[0], Node)
def blockdiag_generate_image(source, format):
from blockdiag import parser, builder, drawer
try:
tree = parser.parse_string(source)
diagram = builder.ScreenNodeBuilder.build(tree)
draw = drawer.DiagramDraw(format,
diagram,
fontmap=get_fontmap(),
ignore_pil=True)
draw.draw()
image = draw.save()
etype = None
error = None
except Exception, e:
image = ''
etype = e.__class__.__name__
error = str(e)
logging.exception(e)
def __init__(self, _parent):
super(QtWidgets.QDialog, self).__init__(_parent)
# create dialog screen for each parameter in curr_params
self.parent = _parent
self.batchlocations = self.parent.tools_widget.batchlocations
self.locationgroups = self.parent.tools_widget.locationgroups
self.load_definition = self.parent.tools_widget.load_definition
self.view = self.parent.batchlocations_view
self.model = self.parent.batchlocations_model
self.statusbar = self.parent.statusBar()
svg.setup(svg) # needed for pyinstaller
roundedbox.setup(roundedbox) # needed for pyinstaller
# find out which batchlocation was selected
self.row = self.view.selectedIndexes()[0].row()
batchlocation = self.batchlocations[self.locationgroups[self.row][0]]
env = dummy_env()
curr_params = {}
curr_diagram = None
# load default settings list
if (batchlocation[0] == "WaferSource"):
curr_params = WaferSource(env).params
curr_diagram = WaferSource(env).diagram
elif (batchlocation[0] == "WaferStacker"):
curr_params = WaferStacker(env).params
curr_diagram = WaferStacker(env).diagram
elif (batchlocation[0] == "WaferUnstacker"):
curr_params = WaferUnstacker(env).params
curr_diagram = WaferUnstacker(env).diagram
elif (batchlocation[0] == "BatchTex"):
curr_params = BatchTex(env).params
curr_diagram = BatchTex(env).diagram
elif (batchlocation[0] == "BatchClean"):
curr_params = BatchClean(env).params
curr_diagram = BatchClean(env).diagram
elif (batchlocation[0] == "TubeFurnace"):
curr_params = TubeFurnace(env).params
curr_diagram = TubeFurnace(env).diagram
elif (batchlocation[0] == "SingleSideEtch"):
curr_params = SingleSideEtch(env).params
curr_diagram = SingleSideEtch(env).diagram
elif (batchlocation[0] == "TubePECVD"):
curr_params = TubePECVD(env).params
curr_diagram = TubePECVD(env).diagram
elif (batchlocation[0] == "PrintLine"):
curr_params = PrintLine(env).params
curr_diagram = PrintLine(env).diagram
elif (batchlocation[0] == "WaferBin"):
curr_params = WaferBin(env).params
curr_diagram = WaferBin(env).diagram
elif (batchlocation[0] == "Buffer"):
curr_params = Buffer(env).params
curr_diagram = Buffer(env).diagram
elif (batchlocation[0] == "IonImplanter"):
curr_params = IonImplanter(env).params
curr_diagram = IonImplanter(env).diagram
elif (batchlocation[0] == "SpatialALD"):
curr_params = SpatialALD(env).params
curr_diagram = SpatialALD(env).diagram
elif (batchlocation[0] == "InlinePECVD"):
curr_params = InlinePECVD(env).params
curr_diagram = InlinePECVD(env).diagram
elif (batchlocation[0] == "PlasmaEtcher"):
curr_params = PlasmaEtcher(env).params
curr_diagram = PlasmaEtcher(env).diagram
else:
return
# update default settings list with currently stored settings
curr_params.update(batchlocation[1])
self.setWindowTitle(self.tr("Tool group settings"))
tabwidget = QtWidgets.QTabWidget()
self.strings = []
self.integers = []
self.doubles = []
self.booleans = []
setting_types = ["configuration", "process", "automation", "downtime"]
setting_type_tabs = {
"configuration": "Configuration",
"process": "Process",
"automation": "Automation",
"downtime": "Downtime"
}
setting_type_titles = {
"configuration": "<b>Tool configuration</b>",
"process": "<b>Process settings</b>",
"automation": "<b>Automation settings</b>",
"downtime": "<b>Downtime settings</b>"
}
for j in setting_types:
if not (j in curr_params.values()):
continue
vbox = QtWidgets.QVBoxLayout()
vbox.addWidget(QtWidgets.QLabel(setting_type_titles[j]))
for i in sorted(curr_params.keys()):
# Make QSpinBox or QDoubleSpinbox for integers and doubles
if isinstance(curr_params[i],
int) and (curr_params[i + "_type"] == j):
hbox = QtWidgets.QHBoxLayout()
description = QtWidgets.QLabel(curr_params[i + "_desc"])
self.integers.append(QtWidgets.QSpinBox())
self.integers[-1].setAccelerated(True)
self.integers[-1].setMaximum(999999999)
self.integers[-1].setValue(curr_params[i])
self.integers[-1].setObjectName(i)
if (curr_params[i] >= 100):
self.integers[-1].setSingleStep(100)
elif (curr_params[i] >= 10):
self.integers[-1].setSingleStep(10)
if i + "_desc" in curr_params:
self.integers[-1].setToolTip(curr_params[i + "_desc"])
hbox.addWidget(self.integers[-1])
hbox.addWidget(description)
hbox.addStretch(1)
vbox.addLayout(hbox)
elif isinstance(curr_params[i],
float) and (curr_params[i + "_type"] == j):
hbox = QtWidgets.QHBoxLayout()
description = QtWidgets.QLabel(curr_params[i + "_desc"])
self.doubles.append(QtWidgets.QDoubleSpinBox())
self.doubles[-1].setAccelerated(True)
self.doubles[-1].setMaximum(999999999)
self.doubles[-1].setValue(curr_params[i])
self.doubles[-1].setSingleStep(0.1)
self.doubles[-1].setObjectName(i)
if i + "_desc" in curr_params:
self.doubles[-1].setToolTip(curr_params[i + "_desc"])
hbox.addWidget(self.doubles[-1])
hbox.addWidget(description)
hbox.addStretch(1)
vbox.addLayout(hbox)
vbox.addStretch(1)
generic_widget = QtWidgets.QWidget()
generic_widget.setLayout(vbox)
tabwidget.addTab(
generic_widget,
setting_type_tabs[j]) #QtCore.QString(setting_type_tabs[j]))
### Description tab ###
vbox_description = QtWidgets.QVBoxLayout(
) # vbox for description elements
# Diagram
tree = parser.parse_string(curr_diagram)
diagram = builder.ScreenNodeBuilder.build(tree)
draw = drawer.DiagramDraw('SVG', diagram, filename="")
draw.draw()
svg_string = draw.save()
svg_widget = QtSvg.QSvgWidget()
svg_widget.load(str(svg_string).encode('latin-1'))
hbox = QtWidgets.QHBoxLayout()
hbox.addStretch(1)
hbox.addWidget(svg_widget)
hbox.addStretch(1)
vbox_description.addLayout(hbox)
# Text
hbox = QtWidgets.QHBoxLayout()
browser = QtWidgets.QTextBrowser()
browser.insertHtml(curr_params['specification'])
browser.moveCursor(QtGui.QTextCursor.Start)
hbox.addWidget(browser)
vbox_description.addLayout(hbox)
generic_widget_description = QtWidgets.QWidget()
generic_widget_description.setLayout(vbox_description)
tabwidget.addTab(generic_widget_description, "Description")
layout = QtWidgets.QVBoxLayout(self)
layout.addWidget(tabwidget)
### Avoid shrinking all the diagrams ###
#svg_widget.setMinimumHeight(svg_widget.height())
### Buttonbox for ok or cancel ###
buttonbox = QtWidgets.QDialogButtonBox(
QtWidgets.QDialogButtonBox.Ok | QtWidgets.QDialogButtonBox.Cancel)
buttonbox.accepted.connect(self.read)
buttonbox.rejected.connect(self.reject)
if _platform == "linux" or _platform == "linux2":
buttonbox.layout().setDirection(QtWidgets.QBoxLayout.RightToLeft)
layout.addWidget(buttonbox)
self.setMinimumWidth(800)
// Set group shape to 'line group' (default is box)
shape = line;
// Set line style (effects to 'line group' only)
style = dashed;
6 -> 8 ;7
}
}"""
output_formatv = "png" #or svg,
default_shadow_color = (255, 255, 255) # RGB white
default_nodeline_color = (255, 255, 255) # RGB white
size = None
tree = parser.parse_string(graph_string)
fontmap = _create_fontmap(fontmap=None, font=None)
ScreenNodeBuilder = blockdiag.builder.ScreenNodeBuilder
diagram = ScreenNodeBuilder.build(tree, None)
diagram.separated = True
diagram.set_color('red')
diagram.set_orientation('portrait')
diagram.set_default_linecolor(default_nodeline_color)
metrics = DiagramMetrics(diagram=diagram, drawer=None, fontmap=fontmap)
drawer = blockdiag.drawer.DiagramDraw(_format=output_formatv,
diagram=diagram,
fontmap=fontmap,
code=graph_string,
bdiagsrc += prevdir + ' -> ' + d + ';'
prevdir = dend
for filename in sorted(dirs[d].keys()):
bdiagsrc += filename + ' [label = "' + filename + ' - ' + ';'.join(
str(t)
for t in dirs[d][filename]) + '", shape = roundedbox];\n'
bdiagsrc += d + ' -> ' + filename + ' -> ' + dend + ';\n'
# bdiagsrc += d + ' -> ' + filename + ';\n'
# prevtable = filename
# for table in sorted(dirs[d][filename]):
# bdiagsrc += table + ' [label = "' + table + '"];\n'
# bdiagsrc += prevtable + ' -> ' + table + ';\n'
# prevtable = table
# bdiagsrc += prevtable + ' -> ' + dend + ';\n'
bdiagsrc += '}'
tree = parser.parse_string(bdiagsrc)
diagram = builder.ScreenNodeBuilder.build(tree)
draw = drawer.DiagramDraw('PNG', diagram, filename="diagram.png")
draw.draw()
draw.save()
masterlogger.finalize()
print('Finished!')
if counters['inserts'] > 0:
print(str(counters['inserts']) + ' inserts')
if counters['updates'] > 0:
print(str(counters['updates']) + ' updates')
if counters['warnings'] > 0:
print(str(counters['warnings']) + ' warnings')
if counters['errors'] > 0:
blockdiag {
span_width = 200;
span_height = 100;
default_fontsize = 16;
//orientation = portrait;
default_linecolor = "blue";
default_textcolor = "brown";
//edge_layout = flowchart;
init -> runblock;
runblock -> Card1;
Card1 -> browser;
Card1 -> Card2;
Card2 -> Card1;
browser <- Card1;
browser -> webserver;
browser <- webserver;
browser <- webserver;
browser -> browser;
}
"""
block_tree = parser.parse_string(block_diagram_definition)
block_diagram = builder.ScreenNodeBuilder.build(block_tree)
block_draw = drawer.DiagramDraw('PNG', block_diagram, filename="block_diagram.png")
block_draw.draw()
block_draw.save()
span_width = 200;
span_height = 100;
default_fontsize = 16;
//orientation = portrait;
default_linecolor = "blue";
default_textcolor = "brown";
//edge_layout = flowchart;
init -> runblock;
runblock -> Card1;
Card1 -> browser;
Card1 -> Card2;
Card2 -> Card1;
browser <- Card1;
browser -> webserver;
browser <- webserver;
browser <- webserver;
browser -> browser;
}
"""
block_tree = parser.parse_string(block_diagram_definition)
block_diagram = builder.ScreenNodeBuilder.build(block_tree)
block_draw = drawer.DiagramDraw('PNG',
block_diagram,
filename="block_diagram.png")
block_draw.draw()
block_draw.save()
#str = neolib.StrFromFile('C:/TMP/diagrams/background_url_image.diag')
bytes = neolib.HexString2ByteArray("102300")
print(",".join('{:02X}'.format(x) for x in bytes))
exit()
for path,dirs,files in os.walk('C:/TMP/diagrams'):
for tmpfile in files :
if ".diag" in tmpfile:
allpath = path+"\\"+tmpfile
dstfile = path+"\\"+re.sub(r'(\w+)\.diag',r'\1.png',tmpfile)
print(dstfile)
#continue
str = neolib.StrFromFile(allpath)
tree = parser.parse_string(str)
diagram = builder.ScreenNodeBuilder.build(tree)
draw = drawer.DiagramDraw('PNG', diagram, filename=dstfile)
draw.draw()
draw.save()
bytes = neolib.HexString2ByteArray("102300")
",".join('{:02X}'.format(ord(x)) for x in bytes)
exit()
import binascii
ber = (
"\x63\x04hell" # simple tag, len
"\x64\x04hell" # test read length
def draw_diagram(string_commands):
#output_formatv = "svg" #or svg,
default_shadow_color = (255, 255, 255) # RGB white
default_nodeline_color = (255, 255, 255) # RGB white
size=None
graph_string = string_commands
tree = parser.parse_string(graph_string)
diagram = blockdiag.builder.ScreenNodeBuilder.build(tree, None)
diagram.separated=True
diagram.set_color('red')
diagram.set_orientation('portrait')
diagram.set_default_linecolor(default_nodeline_color)
fontmap = blockdiag.utils.fontmap.FontMap()
font_loc = '/home/alireza/group-diagrams/Notebooks/Fonts/georgia.ttf'
fontmap.set_default_font(path = font_loc)
metrics = DiagramMetrics(diagram=diagram, drawer=None, fontmap=fontmap)
#fontmap.set_default_fontfamily(fontfamily='serif-bold')
#fontmap.set_default_fontfamily(fontfamily='serif')
fontmap.fontsize =10
#fontmap = _create_fontmap(fontmap=None, font=None)
drawer = blockdiag.drawer.DiagramDraw(_format='svg',
diagram=diagram,
fontmap=fontmap,
code=graph_string,
antialias=True,
nodoctype=False,
transparency=False)
drawer.shadow = default_shadow_color
drawer.draw()
svg = drawer.save()
svg2png(bytestring = svg, write_to='/home/XXX/group-diagrams/Notebooks/output2.png',scale=4)
#img = Image.open(io.BytesIO(res))
img = Image.open('/home/XXX/group-diagrams/Notebooks/output2.png')
nodes_coordinates=[]
nodes_ids=[]
for node in drawer.nodes:
r = noderenderer.get(node.shape)
shape = r(node, metrics)
box = metrics.cell(node).box
nodes_coordinates.append([box.topleft,
box.bottomright,
box.width,
box.height,
box.center,
(box.center[0],box.center[1]-int(box.height/2)),
])
nodes_ids.append(int(node.id))
if int(node.id)==9:
NODE=node
nodes_info = pd.DataFrame(nodes_coordinates,index=nodes_ids,columns=['top_left', 'bottom_right', 'width', 'height', 'center','top_center'])
nodes_info.index.name='node id'
for node_id in input_df.index:
if input_df.at[node_id,'node_flag']:
flag_img = Image.open('country-flags-master/png100px/'
+input_df.at[node_id,'node_flag']
+'.png', 'r')
flag_img.thumbnail((100,100), Image.ANTIALIAS) # resizing the flag
img.paste(flag_img, (nodes_info.at[node_id, 'bottom_right'][0]*4-50,
nodes_info.at[node_id, 'bottom_right'][1]*4-30))
draw = ImageDraw.Draw(img)
for node_id in input_df.index:
if input_df.at[node_id,'edge_label']:
for child_id, edge_label in zip(input_df.at[node_id,'directed_to'], input_df.at[node_id,'edge_label']):
draw.text((nodes_info.at[child_id, 'top_center'][0]*4+25,
nodes_info.at[child_id, 'top_center'][1]*4-50),
edge_label,
(0,0,0),
font=ImageFont.truetype(font_loc, 40))
return img, svg, nodes_info
def main(args):
print("YASM: Starting...")
url_paths = []
root = {}
with open(args.file) as json_file:
data = json.load(json_file)
if args.sdsp:
data = rewrite_subdomains_as_slash(data)
# Split URL paths into elements along /
for item in data:
split = item['url'].rstrip("/").split('/')
url_paths.append(split[2:])
if args.sdsp:
url_paths[-1].append({'title': item['title'], 'url': split[-1],
'subdomain': item['subdomain']})
else:
url_paths[-1].append({'title': item['title'], 'url': split[-1]})
# Build tree structure from elements
for path in url_paths:
# Get element if it exists, set to empty if not
branch = root.setdefault(path[0], [{}, []])
for i in path[1:-1]:
branch = branch[0].setdefault(i, [{}, []])
branch[1].append(path[-1])
# Delete empty elements
delete_empty(root)
# Output JSON file (Maybe move to util file)
output_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)),
"output")
if not os.path.exists(output_dir):
os.makedirs(output_dir)
output_file_json = os.path.join(output_dir, os.path.split(args.file)[-1])
with open(output_file_json, 'w') as outfile:
json.dump(root, outfile, indent=2, ensure_ascii=False)
# To append .gv, .pdf/.png/.svg later
output_name = output_file_json[:-len(".json")]
if args.depth == 694201337:
calc_max_depth = get_max_depth(root)
else:
calc_max_depth = args.depth
# Sitemap via dot or blockdiag
if args.engine == "dot":
dot = Digraph()
dot.graph_attr['rankdir'] = 'TB'
dot.graph_attr['splines'] = 'ortho'
dot.graph_attr['concentrate'] = 'true'
# User formatting options
dot.graph_attr['nodesep'] = args.widthpadding
dot.graph_attr['ranksep'] = args.heightpadding
dot.node_attr['shape'] = 'rect'
dot.node_attr['style'] = 'filled'
last = create_nodes(root, dot, args.depth, calc_max_depth=calc_max_depth)
graphviz_legend(last, dot)
# Save to file
# GV creates a PDF/SVG and .gv at the same time, need to rename one
dot.format = args.type
output_file_gv = output_name + ".gv"
dot.render(output_name, view=args.instant)
os.rename(output_name, output_file_gv)
elif args.engine == "blockdiag":
dotDiag = Digraph()
create_nodes(root, dotDiag, args.depth, blockdiag=True, calc_max_depth=calc_max_depth)
source = dotDiag.source
source = source.replace("digraph", "blockdiag")
# Legend/Key
blockdiag_legend = """group {
label = "Legend";
color="#808080";
Parent -> Child;
}
}"""
source = source.replace("}", blockdiag_legend)
# Colors
source = source.replace("subgraph", "group")
source = source.replace("fillcolor", ",color")
source = source.replace("style=filled", "")
# User formatting options
source = add_blockdiag_option(source,
"orientation", args.orientation)
source = add_blockdiag_option(source,
"span_width", args.widthpadding)
source = add_blockdiag_option(source,
"span_height", args.heightpadding)
tree = blockdiagParser.parse_string(source)
diagram = builder.ScreenNodeBuilder.build(tree)
# Font only needed for PDF output
# use project specific font file
fontname = "DejaVuSans.ttf"
fontpath = os.path.join(os.path.dirname(os.path.abspath(__file__)),
"..", "util", fontname)
fontmap = FontMap()
fontmap.set_default_font(fontpath)
draw = drawer.DiagramDraw(args.type, diagram,
filename=output_name + '.' + args.type,
fontmap=fontmap)
draw.draw()
draw.save()
print("YASM: Finished.")
def __init__(self, _parent):
super(QtWidgets.QDialog, self).__init__(_parent)
# create dialog screen for each parameter in curr_params
self.parent = _parent
self.batchlocations = self.parent.tools_widget.batchlocations
self.locationgroups = self.parent.tools_widget.locationgroups
self.load_definition = self.parent.tools_widget.load_definition
self.view = self.parent.batchlocations_view
self.model = self.parent.batchlocations_model
self.statusbar = self.parent.statusBar()
svg.setup(svg) # needed for pyinstaller
roundedbox.setup(roundedbox) # needed for pyinstaller
# find out which batchlocation was selected
self.row = self.view.selectedIndexes()[0].row()
batchlocation = self.batchlocations[self.locationgroups[self.row][0]]
env = dummy_env()
curr_params = {}
curr_diagram = None
# load default settings list
if (batchlocation[0] == "WaferSource"):
curr_params = WaferSource(env).params
curr_diagram = WaferSource(env).diagram
elif (batchlocation[0] == "WaferStacker"):
curr_params = WaferStacker(env).params
curr_diagram = WaferStacker(env).diagram
elif (batchlocation[0] == "WaferUnstacker"):
curr_params = WaferUnstacker(env).params
curr_diagram = WaferUnstacker(env).diagram
elif (batchlocation[0] == "BatchTex"):
curr_params = BatchTex(env).params
curr_diagram = BatchTex(env).diagram
elif (batchlocation[0] == "BatchClean"):
curr_params = BatchClean(env).params
curr_diagram = BatchClean(env).diagram
elif (batchlocation[0] == "TubeFurnace"):
curr_params = TubeFurnace(env).params
curr_diagram = TubeFurnace(env).diagram
elif (batchlocation[0] == "SingleSideEtch"):
curr_params = SingleSideEtch(env).params
curr_diagram = SingleSideEtch(env).diagram
elif (batchlocation[0] == "TubePECVD"):
curr_params = TubePECVD(env).params
curr_diagram = TubePECVD(env).diagram
elif (batchlocation[0] == "PrintLine"):
curr_params = PrintLine(env).params
curr_diagram = PrintLine(env).diagram
elif (batchlocation[0] == "WaferBin"):
curr_params = WaferBin(env).params
curr_diagram = WaferBin(env).diagram
elif (batchlocation[0] == "Buffer"):
curr_params = Buffer(env).params
curr_diagram = Buffer(env).diagram
elif (batchlocation[0] == "IonImplanter"):
curr_params = IonImplanter(env).params
curr_diagram = IonImplanter(env).diagram
elif (batchlocation[0] == "SpatialALD"):
curr_params = SpatialALD(env).params
curr_diagram = SpatialALD(env).diagram
elif (batchlocation[0] == "InlinePECVD"):
curr_params = InlinePECVD(env).params
curr_diagram = InlinePECVD(env).diagram
elif (batchlocation[0] == "PlasmaEtcher"):
curr_params = PlasmaEtcher(env).params
curr_diagram = PlasmaEtcher(env).diagram
else:
return
# update default settings list with currently stored settings
curr_params.update(batchlocation[1])
self.setWindowTitle(self.tr("Tool group settings"))
tabwidget = QtWidgets.QTabWidget()
self.strings = []
self.integers = []
self.doubles = []
self.booleans = []
setting_types = ["configuration","process","automation","downtime"]
setting_type_tabs = {"configuration" : "Configuration",
"process" : "Process",
"automation" : "Automation",
"downtime" : "Downtime"}
setting_type_titles = {"configuration" : "<b>Tool configuration</b>",
"process" : "<b>Process settings</b>",
"automation" : "<b>Automation settings</b>",
"downtime" : "<b>Downtime settings</b>"}
for j in setting_types:
if not (j in curr_params.values()):
continue
vbox = QtWidgets.QVBoxLayout()
vbox.addWidget(QtWidgets.QLabel(setting_type_titles[j]))
for i in sorted(curr_params.keys()):
# Make QSpinBox or QDoubleSpinbox for integers and doubles
if isinstance(curr_params[i], int) and (curr_params[i + "_type"] == j):
hbox = QtWidgets.QHBoxLayout()
description = QtWidgets.QLabel(curr_params[i + "_desc"])
self.integers.append(QtWidgets.QSpinBox())
self.integers[-1].setAccelerated(True)
self.integers[-1].setMaximum(999999999)
self.integers[-1].setValue(curr_params[i])
self.integers[-1].setObjectName(i)
if (curr_params[i] >= 100):
self.integers[-1].setSingleStep(100)
elif (curr_params[i] >= 10):
self.integers[-1].setSingleStep(10)
if i + "_desc" in curr_params:
self.integers[-1].setToolTip(curr_params[i + "_desc"])
hbox.addWidget(self.integers[-1])
hbox.addWidget(description)
hbox.addStretch(1)
vbox.addLayout(hbox)
elif isinstance(curr_params[i], float) and (curr_params[i + "_type"] == j):
hbox = QtWidgets.QHBoxLayout()
description = QtWidgets.QLabel(curr_params[i + "_desc"])
self.doubles.append(QtWidgets.QDoubleSpinBox())
self.doubles[-1].setAccelerated(True)
self.doubles[-1].setMaximum(999999999)
self.doubles[-1].setValue(curr_params[i])
self.doubles[-1].setSingleStep(0.1)
self.doubles[-1].setObjectName(i)
if i + "_desc" in curr_params:
self.doubles[-1].setToolTip(curr_params[i + "_desc"])
hbox.addWidget(self.doubles[-1])
hbox.addWidget(description)
hbox.addStretch(1)
vbox.addLayout(hbox)
vbox.addStretch(1)
generic_widget = QtWidgets.QWidget()
generic_widget.setLayout(vbox)
tabwidget.addTab(generic_widget, setting_type_tabs[j])#QtCore.QString(setting_type_tabs[j]))
### Description tab ###
vbox_description = QtWidgets.QVBoxLayout() # vbox for description elements
# Diagram
tree = parser.parse_string(curr_diagram)
diagram = builder.ScreenNodeBuilder.build(tree)
draw = drawer.DiagramDraw('SVG', diagram, filename="")
draw.draw()
svg_string = draw.save()
svg_widget = QtSvg.QSvgWidget()
svg_widget.load(str(svg_string).encode('latin-1'))
hbox = QtWidgets.QHBoxLayout()
hbox.addStretch(1)
hbox.addWidget(svg_widget)
hbox.addStretch(1)
vbox_description.addLayout(hbox)
# Text
hbox = QtWidgets.QHBoxLayout()
browser = QtWidgets.QTextBrowser()
browser.insertHtml(curr_params['specification'])
browser.moveCursor(QtGui.QTextCursor.Start)
hbox.addWidget(browser)
vbox_description.addLayout(hbox)
generic_widget_description = QtWidgets.QWidget()
generic_widget_description.setLayout(vbox_description)
tabwidget.addTab(generic_widget_description, "Description")
layout = QtWidgets.QVBoxLayout(self)
layout.addWidget(tabwidget)
### Avoid shrinking all the diagrams ###
#svg_widget.setMinimumHeight(svg_widget.height())
### Buttonbox for ok or cancel ###
buttonbox = QtWidgets.QDialogButtonBox(QtWidgets.QDialogButtonBox.Ok | QtWidgets.QDialogButtonBox.Cancel)
buttonbox.accepted.connect(self.read)
buttonbox.rejected.connect(self.reject)
if _platform == "linux" or _platform == "linux2":
buttonbox.layout().setDirection(QtWidgets.QBoxLayout.RightToLeft)
layout.addWidget(buttonbox)
self.setMinimumWidth(800)
def __call__(self, source, config):
tree = parser.parse_string(source)
diagram = builder.ScreenNodeBuilder.build(tree, config)
drawing = drawer.DiagramDraw('SVG', diagram) # DO NOT PASS FILENAME
drawing.draw()
return drawing.save()
def test_parenthesis_ness(self):
with self.assertRaises(ParseException):
code = ""
parse_string(code)
def diagram(self):
return parse_string(self.diag)
'dejavu-fonts-ttf-2.33/ttf/DejaVuSans-Oblique.ttf')),
('sansserif-normal', os.path.abspath(
'dejavu-fonts-ttf-2.33/ttf/DejaVuSans.ttf'))]
fontmap.set_default_fontfamily('sansserif-normal')
fontmap.set_default_font(os.path.abspath('dejavu-fonts-ttf-2.33/ttf/DejaVuSans.ttf'))
# Add all the fonts to the fontmap.
[fontmap.append_font(ttf_font[0], ttf_font[1]) for ttf_font in ttf_fonts]
for filename in glob.glob('blockdiag/*'):
diagram_definition = open(filename).read()
tree = parser.parse_string(diagram_definition)
diagram = builder.ScreenNodeBuilder.build(tree)
image_path = \
"../docs/images/{0}".format(filename[len('blockdiag/'):-4] + 'png')
print 'saving', image_path
draw = drawer.DiagramDraw('PNG',
diagram,
filename=image_path,
fontmap=fontmap,
antialias=True,
transparency=True)
draw.draw()
draw.save()
def is_valid(self):
try:
parse_string(self.diag)
return True
except ParseException:
return False
B [label = "left or\nright?"]
B [shape = flowchart.condition]
C [label = "swim or\nwait?"]
C [shape = flowchart.condition]
D [label = "Which door?"]
D [shape = flowchart.condition]
E [label = "You Win!"]
group vertical {
orientation = portrait
A -> B;
B -> C [label = "Left", fontsize = 8];
C -> D [label = "Wait", fontsize = 8];
D -> E [label = "Yellow", fontsize = 8];
color = "#FFFFFF";
}
F [label = "Game Over."]
G [label = "Game Over."]
H [label = "Game Over."]
I [label = "Game Over."]
B -> F [label = "Right", fontsize = 8];
C -> G [label = "Swim", fontsize = 8];
I <- D [label = "Red", fontsize = 8];
D -> H [label = "Blue", fontsize = 8];
}
"""
tree = parser.parse_string(source)
diagram = builder.ScreenNodeBuilder.build(tree)
draw = drawer.DiagramDraw('PNG', diagram, filename="Day3_task.png")
draw.draw()
draw.save()
def create_diagram(diagram_txt):
tree = parser.parse_string(diagram_txt)
diagram = builder.ScreenNodeBuilder.build(tree)
drawing = drawer.DiagramDraw('SVG', diagram) # DO NOT PASS FILENAME
drawing.draw()
return drawing.save()
