def render_animation(name, func1, func2, circuit_qcircuit='', equation_latex='',
save=False, fps=20, preview=True, **kwargs):
with draw.animation.AnimationContext(animate_bloch.draw_frame,
jupyter=preview, delay=0
) as anim:
state = animate_bloch.AnimState(anim, fps=fps)
func1(state)
frames1 = anim.frames
with draw.animation.AnimationContext(animate_bloch.draw_frame,
jupyter=preview, delay=0
) as anim:
state = animate_bloch.AnimState(anim, fps=fps)
func2(state)
frames2 = anim.frames
g = draw.Group()
# Equals sign
g.append(draw.Rectangle(-0.4, 0.075, 0.8, 0.075, fill='#000'))
g.append(draw.Rectangle(-0.4, -0.15, 0.8, 0.075, fill='#000'))
if circuit_qcircuit:
circuit_elem = latextools.render_qcircuit(circuit_qcircuit).as_svg()
g.draw(circuit_elem, x=0, y=2, center=True, scale=0.04)
if equation_latex:
equation_elem = latextools.render_snippet(
equation_latex, latextools.pkg.qcircuit).as_svg()
g.draw(equation_elem, x=0, y=-0.8, center=True, scale=0.03)
extra_elements = (g,)
save_side_by_side(name, frames1, frames2, extra_elements=extra_elements,
save=save, fps=fps, preview=preview, **kwargs)
def draw_frame(t):
d = draw.Drawing(2, 5.00, origin=(-1, -1.05))
d.setRenderSize(h=150)
d.append(draw.Rectangle(-4, -4, 8, 10, fill='white'))
d.append(draw.Rectangle(-1, -1.00, 8, 1.05, fill='brown'))
t = (t + 1) % 2 - 1
y = 4 - t**2 * 4
d.append(draw.Circle(0, y, 1, fill='lime'))
return d
def draw(self, x=0, y=0, xscale=1.0):
h = self.h
a = self.a * xscale
b = self.b * xscale
x = x * xscale
#assert isinstance(x, float) and isinstance(y, float)
d = draw.Group(transform="translate({} {})".format(x, y))
d.append(
draw.Rectangle(a, 0, b - a, h, fill=self.color, stroke=self.color))
if 'f' in self.direction:
d.append(
draw.Lines(b,
0,
b + 5, (h / 2),
b,
h,
fill=self.color,
stroke=self.color))
if 'r' in self.direction:
d.append(
draw.Lines(a,
0,
a - 5, (h / 2),
a,
h,
fill=self.color,
stroke=self.color))
for r_a, r_b, color in self.regions:
r_a = r_a * xscale
r_b = r_b * xscale
d.append(
draw.Rectangle(r_a, 0, r_b - r_a, h, fill=color, stroke=color))
for tick in self.ticks:
tick = tick * xscale
d.append(draw.Lines(tick, 0, tick, h, stroke='red'))
if self.label:
label = self.label
font_size = 10
offset = h + font_size
if isinstance(self.label, Label):
d.append(label.draw(x=(b + a) / 2))
elif isinstance(self.label, str):
d.append(Label(0, self.label).draw(x=(b + a) / 2))
return d
def draw_line(self, dims, vals, grid_size=10, color='#ffffff'):
anim = draw.Drawing(330, 120, origin=(0, 0))
for x in range(dims[0]):
group = draw.Group()
group.draw(
draw.Rectangle(
100 * x + grid_size, # origin x coords
grid_size, # origin y coords
100, # grid width
100, # grid height
stroke_width=grid_size, # outline size
stroke='black', # outline color
fill=color)) # fill color
string_output = str(vals[x])
font_size = 50 / len(string_output) + 25
group.draw(
draw.Text(
string_output,
font_size,
100 * x + grid_size + font_size / 3 +
2 * len(string_output), # origin x coords
grid_size + 2250 / (font_size + 20), # origin y coords
center=0))
anim.append(group)
return anim
def draw_pads(board_data, d, data, factor):
for index, element in data.iterrows():
red = element['MEAS_3_CLAMPED']
green = element['MEAS_5_CLAMPED']
blue = element['MEAS_6_CLAMPED']
color = rgb_to_hex((int(red / 4), int(green), int(blue)))
part_name = element.name[0]
pad_index = str(element.name[1])
part = board_data[part_name + '_' + pad_index]
element_x = float(part[5]) * factor
element_y = float(part[6]) * factor
pad_width = float(part[8]) * factor
pad_length = float(part[7]) * factor
rot_angle = int(part[9])
rotation = str.format("translate({1}, {2}) rotate({0})",
str(-rot_angle), str(element_x), str(-element_y))
d.append(
drawSvg.Rectangle(-pad_width / 2,
-pad_length / 2,
pad_width,
pad_length,
stroke_width=1,
stroke="black",
fill=color,
transform=rotation))
def drawlayOut(self):
self.d.append(
draw.Rectangle(0,
0,
self.widthView,
self.heightView,
fill='#ffffff'))
def draw_keyboard(keyboard_or_index: Union[int, Keyboard]) -> draw.Group:
keyboard: Keyboard = keyboards[keyboard_or_index] if isinstance(
keyboard_or_index, int) else keyboard_or_index
outlines = draw.Group(
transform=f"translate({-keyboard.left},{-keyboard.top})")
chars = draw.Group(transform="scale(1,-1)")
for key in keyboard.values():
outlines.append(
draw.Rectangle(key.x,
key.y,
key.width,
key.height,
fill='transparent',
stroke_width=5,
stroke='blue'))
if key.code > 0:
chars.append(
draw.Text(key.char,
fontSize=25,
x=key.x + key.width / 2,
y=-key.y - key.height / 2,
center=True))
outlines.append(chars)
return outlines
def draw_points(pts,
name,
bg_margin_ratio,
bg_col='#1248ff',
path_kwargs=def_path_kwargs):
"""
Draws a path connecting the points and saves
it as a svg image.
"""
n = pts.shape[1]
p = draw.Path(**path_kwargs)
p.M(*pts[:, -1])
for k in range(n):
p.L(*pts[:, k])
p.Z()
# Background
sz_half = int(bg_margin_ratio * np.max(np.abs(pts)))
sz = 2 * sz_half
bg_rect = draw.Rectangle(-sz_half, -sz_half, sz, sz, fill=bg_col)
# Draw
d = draw.Drawing(sz, sz, origin='center')
d.append(bg_rect)
d.append(p)
# Save
save_path = get_img_path(name)
d.saveSvg(save_path)
def draw_via_pads(d, via_list, factor):
for via_name, via in via_list:
via_x = float(via.x) * factor
via_y = float(via.y) * factor
via_length = float(via.length) * factor
via_width = float(via.width) * factor
via_drill = float(via.drill) * factor
rotation = str.format("translate({1}, {2}) rotate({0}) ",
str(-via.rotation), str(via_x), str(-via_y))
color = "lightgreen"
d.append(
draw.Rectangle(-via_width / 2,
-via_drill / 2 - 0.25 * factor,
via_width,
via_length,
fill=color,
stroke_width=1,
stroke="black",
opacity="0.7",
transform=rotation,
rx=via_width / 2,
ry=via_width / 2))
d.append(
draw.Circle(via_x,
via_y,
via_drill / 2,
fill="orange",
stroke_width=1,
stroke="black",
opacity="0.7"))
def generate_svg(root_image_path, svg_save_path):
with open(os.path.join(root_image_path, "draw_objects.pickle"), 'rb') as f:
draw_objects = pickle.load(f)
canvas_shape = (0, 0
) # automatically find the shape through maximizing
for draw_object in draw_objects:
points = draw_object["points"]
canvas_shape = np.maximum(canvas_shape, points.max(axis=0))
canvas_shape = canvas_shape.astype(np.int)
image = draw.Drawing(*canvas_shape, displayInline=False)
image.append(draw.Rectangle(0, 0, *canvas_shape, fill='black'))
# shuffle(draw_objects) # don't shuffle the polygons :), they are overlaid over each other
for idx, draw_object in enumerate(draw_objects):
polygon = draw_object["points"]
color = draw_object["color"]
polygon = polygon.astype(np.int)
color = color.astype(np.int)
color = color.tolist()
BGR, alpha = color[:-1], color[-1] / MAX_COLOR
draw_svg_polygon(image, polygon, BGR, alpha)
temp_svg = "/tmp/temp.svg"
image.saveSvg(temp_svg)
drawing = svg2rlg(temp_svg)
os.remove(temp_svg)
drawing.transform = (1, 0, 0, -1, 0, canvas_shape[1]
) # reflect and translate
renderPDF.drawToFile(drawing, svg_save_path)
def render(circles, data, size, highlight=[], output='circles.svg'):
d = draw.Drawing(size, size, origin='center')
d.append(draw.Rectangle(
-size / 2,
-size / 2,
size,
size,
fill='white',
))
for i, item in enumerate(zip(circles, data)):
circle = item[0]
if item[1][1] > 0:
color = '#3b3b3b'
else:
if item[1][0] and item[1][0] in highlight:
color = '#ffff00'
else:
color = '#84ab3f'
d.append(
draw.Circle(
*circle,
fill=color,
amount=item[1][1],
person=html.escape(item[1][0]),
target=html.escape(item[1][2]) if len(item[1]) >= 4 else '',
description=html.escape(item[1][3])
if len(item[1]) >= 4 else '',
))
d.saveSvg(output)
def test_draw_coverage(svg_differ):
expected_figure = Figure()
expected_figure.add(Track(0, 1, color='', h=-4)) # Just a spacer.
expected_figure.add(Track(100, 200, label='Bar'))
expected_svg = expected_figure.show()
expected_svg.insert(0, draw.Rectangle(100, 20, 25, 5, fill='blue'))
expected_svg.insert(1, draw.Rectangle(125, 20, 25, 10, fill='blue'))
expected_svg.insert(2, draw.Rectangle(175, 20, 25, 1, fill='blue'))
figure = Figure()
coverage_depths = 25 * [5] + 25 * [10] + 25 * [0] + 25 * [1]
figure.add(SmoothCoverage(100, 200, coverage_depths), gap=-4)
figure.add(Track(100, 200, label="Bar"))
svg = figure.show()
svg_differ.assert_equal(svg, expected_svg, 'test_draw_coverage')
def render_rect(rect, model, target, style=None):
style = style_join(style or {}, rect.style)
assert len(style) > 0
w = N(model[rect.width])
h = N(model[rect.height])
x = N(model[rect.x])
y = M(model[rect.y], target) - h
target.append(draw.Rectangle(x, y, w, h, **style))
def draw_green_pixel(self, x, y, a=0.2):
r = draw.Rectangle(round(x),
round(-y + self.dimension - 1),
1,
1,
fill="green",
fill_opacity=a)
self.draw.append(r)
def create_tria_svg():
"""
Creates the fancy triangular shape and saves
it as a .svg image.
"""
# Parameters
d_0 = 0.3
d_1 = 0.4
f = 0.43
alpha = 54
s = 300
bg_col = '#1248ff'
fg_col = '#000000'
name = 'fancy_tria'
# Compute triangles
main_tria = get_iso_tria(s)
inner_tria = get_iso_tria(f * s, -alpha)
# Draw
sz = 800
d = draw.Drawing(sz, sz, origin='center')
# Background
bg_rect = draw.Rectangle(-sz / 2, -sz / 2, sz, sz, fill=bg_col)
d.append(bg_rect)
p = draw.Path(stroke_width=0,
stroke=fg_col,
fill=fg_col,
fill_opacity=1.0)
prev_corner = main_tria[:, -1]
p.M(*prev_corner)
for k in range(3):
# Compute points
curr_corner = main_tria[:, k]
side_vec = curr_corner - prev_corner
side_pt1 = prev_corner + d_0 * side_vec
side_pt2 = prev_corner + (1 - d_1) * side_vec
inner_pt = inner_tria[:, (k + 1) % 3]
# Draw points
p.L(*side_pt1)
p.L(*inner_pt)
p.L(*side_pt2)
p.L(*curr_corner)
prev_corner = curr_corner
p.Z()
d.append(p)
# Save
save_path = get_img_path(name)
d.saveSvg(save_path)
def draw_frame(*args, background='white', **kwargs):
d = draw.Drawing(5, 3, origin='center')
d.setRenderSize(624)
if background:
d.append(draw.Rectangle(-100, -100, 200, 200, fill=background))
g = draw.Group()
draw_bloch_sphere(g, background=None, *args, **kwargs)
d.append(g)
return d
def draw_whole_frame(f1, f2, background='white', extra_elements=()):
d = draw.Drawing(10, 4, origin=(-5, -1.5))
d.setRenderSize(624 * 2)
if background:
d.append(draw.Rectangle(-100, -100, 200, 200, fill=background))
d.append(draw.Group([f1.elements[-1]], transform='translate(-2.5)'))
d.append(draw.Group([f2.elements[-1]], transform='translate(2.5)'))
d.extend(extra_elements)
return d
def draw_pixel(self, x, y, c):
x = round(x)
y = round(y)
self.image[x][y] = c
r = draw.Rectangle(x,
-y + self.dimension - 1,
1,
1,
fill=c.to_hex(),
fill_opacity=c.a)
self.draw.append(r)
def generateBoundingBox(self):
boxWidth = self.rightBound - self.leftBound + self.boxThickness
boxHeight = self.topBound - self.bottomBound + self.boxThickness
return draw.Rectangle(self.leftBound - (self.boxThickness / 2),
self.bottomBound - (self.boxThickness / 2),
boxWidth,
boxHeight,
fill_opacity=0,
stroke_width=self.boxThickness,
stroke=self.boxColor)
def drawRect(d, x, y, color):
d.append(draw.Rectangle(
x,
y,
9,
9,
fill=color,
))
d.setPixelScale(2) # Set number of pixels per geometry unit
# Display in Jupyter notebook
d.rasterize() # Display as PNG
return d # Display as SVG
def setup():
if not os.path.exists(OUTPUT_DIR):
os.makedirs(OUTPUT_DIR)
if not os.path.exists(TEMP_DIR):
os.makedirs(TEMP_DIR)
background_top = INPUT_DIR + "axiom_beta_mixed_panel.top_rotated.png"
background_bottom = INPUT_DIR + "axiom_beta_mixed_panel.bottom_rotated.png"
board_x = 0
board_y = 0
board_outline = gerberex.read('output_stage1/axiom_beta_mixed_panel.boardoutline.ger')
board_width = board_outline.size[1]
board_height = board_outline.size[0]
image_width, image_height = get_image_size(background_top)
global drawing_top, drawing_bottom, factor, output_image_height
output_image_width = image_width / 2
output_image_height = image_height / 2
factor = (output_image_width / board_width + output_image_height / board_height) / 2
# Fixed size for PCB image
drawing_top = draw.Drawing(output_image_width, output_image_height)
drawing_bottom = draw.Drawing(output_image_width, output_image_height)
# Draw background
drawing_top.append(draw.Image(board_x * factor, board_y * factor,
output_image_width, output_image_height, background_top))
drawing_top.append(draw.Rectangle(0, 0, output_image_width, output_image_height, fill="black", opacity=0.5))
drawing_bottom.append(draw.Image(board_x * factor, board_y * factor,
output_image_width, output_image_height, background_bottom))
drawing_bottom.append(draw.Rectangle(0, 0, output_image_width, output_image_height, fill="black", opacity=0.5))
def drawColumn(self,add,colors,columnCounter,j,cell):
x = abs(add + self.FindYofRightEdgeOFCoulumn(j)) + self.widthOfSingleColumn
y = abs(self.convertY(self.findZeroInSVG()))
width = abs((add + self.FindYofRightEdgeOFCoulumn(j)) - (add + self.FindYofLeftEdgeOFCoulumn(j)))
height = self.convertY(cell.value) - self.convertY(self.findZeroInSVG())
if self.animation:
if height > -1:
t = draw.Rectangle(x, y + height, width, height, stroke=colors[columnCounter], stroke_width=self.xUnit / 60,
Class=str(self.Index), id=self.Index,
transform="rotate(180," + str(x) + ',' + str(-abs(y + height)) + ')',
fill=colors[columnCounter], fill_opacity=0.5)
t.appendAnim(draw.Animate('height', '1s', from_or_values=0, to=height,
repeatCount='1'))
self.d.append(t)
else:
t = draw.Rectangle(x - self.widthOfSingleColumn, y - abs(height), width, abs(height), Class=str(self.Index),
id=self.Index,
stroke=colors[columnCounter],
stroke_width=self.xUnit / 30,
fill=colors[columnCounter], fill_opacity=0.5)
t.appendAnim(draw.Animate('height', '1s', from_or_values=0, to=abs(height),
repeatCount='1'))
self.d.append(t)
else:
if height > -1:
r = draw.Rectangle(x, y + height, width, height, stroke=colors[columnCounter], stroke_width=self.xUnit / 60,Class=str(self.Index),id=self.Index,
transform="rotate(180," + str(x) + ',' + str(-abs(y + height)) + ')',
fill=colors[columnCounter], fill_opacity=0.5)
self.d.append(r)
else:
r = draw.Rectangle(x - self.widthOfSingleColumn, y - abs(height), width, abs(height),Class=str(self.Index),id=self.Index,
stroke=colors[columnCounter],
stroke_width=self.xUnit / 30,
fill=colors[columnCounter], fill_opacity=0.5)
self.d.append(r)
def saveMap(self,Id_env,list_obstacle):
num_obstacle = len(list_obstacle)
map_data = np.zeros([self.size_load_map[0], self.size_load_map[1]])
aspect = self.size_load_map[0] / self.size_load_map[1]
xmin = -0.5
ymin = -0.5
xmax = self.size_load_map[0] - 0.5
ymax = self.size_load_map[1] - 0.5
d = draw.Drawing(self.size_load_map[0], self.size_load_map[1], origin=(xmin,ymin))
# d.append(draw.Rectangle(xmin, ymin, self.size_load_map[0], self.size_load_map[1], stroke='black',fill = 'white'))
# d.append(draw.Rectangle(xmin, ymin, xmax, ymax, stroke_width=0.1, stroke='black', fill='white'))
d.append(draw.Rectangle(xmin, ymin, self.size_load_map[0], self.size_load_map[1], stroke_width=0.1, stroke='black', fill='white'))
# d = draw.Drawing(self.size_load_map[0], self.size_load_map[1], origin=(0, 0))
# d.append(draw.Rectangle(0, 0, self.size_load_map[0], self.size_load_map[1], stroke_width=0, stroke='black', fill='white'))
for ID_obs in range(num_obstacle):
obstacleIndexX = list_obstacle[ID_obs][0]
obstacleIndexY = list_obstacle[ID_obs][1]
map_data[obstacleIndexX][obstacleIndexY] = 1
d.append(draw.Rectangle(obstacleIndexY-0.5, obstacleIndexX-0.5, 1, 1, stroke='black', stroke_width=0, fill='black'))
# d.append(draw.Rectangle(obstacleIndexX, obstacleIndexY, 0.5, 0.5, stroke='black', fill='black'))
# d.append(draw.Rectangle(obstacleIndexX - 0.5, obstacleIndexY - 0.5, 1, 1, stroke='black', stroke_width=1,
# fill='black'))
# setup figure
name_map = os.path.join(self.dirName_mapSet, 'IDMap{:05d}.png'.format(Id_env))
# d.setPixelScale(2) # Set number of pixels per geometry unit
d.setRenderSize(200, 200) # Alternative to setPixelScale
d.savePng(name_map)
def draw(self, x=0, y=0, xscale=1.0):
a = self.a * xscale
x = x * xscale
d = draw.Group(transform="translate({} {})".format(x, y))
yscale = self.h / max(y for y, count in self.coverage_groups)
pos = 0
for y, count in self.coverage_groups:
if y != 0:
d.append(
draw.Rectangle(a + (pos * xscale),
self.h // 2 - 1,
count * xscale,
y * yscale,
fill=self.get_color(y),
fill_opacity=self.opacity,
shape_rendering='crispEdges'))
pos += count
return d
def draw(self, x=0, y=0, xscale=1.0):
#assert isinstance(x, int) and isinstance(y, int)
h = self.h
a = self.a * xscale
b = self.b * xscale
x = x * xscale
d = draw.Group(transform="translate({} {})".format(x, y))
yscale = self.h / max(self.ys)
for i, v in enumerate(self.ys):
d.append(
draw.Rectangle(
a + (i * xscale),
0,
xscale,
v * yscale,
fill=self.color,
fill_opacity=self.opacity)) #, stroke=self.color))
return d
def draw_event(d, event):
# Monday is 0 and Sunday is 6
start_x_pos = event.start_datetime().weekday() * COL_WIDTH
start_y_pos = COL_HEIGHT - (event.start_hour_decimal() - 10) * HOUR_HEIGHT
end_y_pos = COL_HEIGHT - (event.end_hour_decimal() - 10) * HOUR_HEIGHT
height = event.hour_duration_decimal() * HOUR_HEIGHT
rect = draw.Rectangle(start_x_pos,
end_y_pos,
COL_WIDTH,
height,
fill=GREEN)
text = draw.Text('busy',
10,
start_x_pos + 5,
start_y_pos - 10,
center=0,
fill='white')
d.append(rect)
d.append(text)
def draw_smd_pads(d, smd_list, factor):
for pad_name, pad in smd_list:
pad_x = float(pad.x) * factor
pad_y = float(pad.y) * factor
pad_width = float(pad.width) * factor
pad_length = float(pad.length) * factor
# rotation=str.format(
# "translate({0}, {1})", str(pad_x), str(-pad_y))
rotation = str.format("translate({1}, {2}) rotate({0})",
str(-pad.rotation), str(pad_x), str(-pad_y))
fill_color = "lightskyblue"
d.append(
draw.Rectangle(-pad_width / 2,
-pad_length / 2,
pad_width,
pad_length,
stroke_width=1,
stroke="black",
fill=fill_color,
transform=rotation))
# Draw midpoint
color = "red" # if item.rotation != 45 else "yellow"
radius = pad_width / 2 if pad_width < pad_length else pad_length / 2
d.append(
draw.Circle(pad_x,
pad_y,
radius / 2,
fill=color,
stroke_width=1,
stroke="black"))
d.append(
draw.Text(pad_name,
30,
pad_x,
pad_y,
fill="yellow",
stroke="orange"))
def draw_days(d):
for day_num, day_name in enumerate([
'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday',
'Sunday'
]):
x_pos = day_num * COL_WIDTH
r = draw.Rectangle(x_pos,
COL_HEIGHT,
COL_WIDTH,
BANNER_HEIGHT,
fill='black',
stroke='white')
t = draw.Text(day_name,
10,
x_pos + 5,
COL_HEIGHT + 5,
center=0,
fill='white')
d.append(r)
d.append(t)
def AnimateForward(self, url):
total_frames = 200
d = self.d
p = draw.Rectangle(0,
0,
self.width,
self.height,
fill="black",
id="Square")
d.append(p)
def draw_frame(i):
std.d.elements[-1].args["y"] += (self.height / total_frames)
#d.setRenderSize(h=self.height)
#d.saveSvg(url)
return (d)
with draw.animate_jupyter(draw_frame, delay=0.05) as anim:
for i in range(total_frames):
anim.draw_frame(i)
def __init__(self,
treefile,
eventsfile,
height,
width,
padding=15,
background=None):
self.height = height
self.width = width
self.padding = padding
self.branch2features, self.n_leaves, self.total_time = self._read_eventsfile(
eventsfile)
self.tree = self._read_treefile(treefile)
self.node2coor = self._get_coordinates()
self.d = draw.Drawing(self.width,
self.height,
origin=(0, 0),
displayInline=False)
if background != None:
self.d.draw(draw.Rectangle(0, 0, width, height, fill=background))
