def main(path):
df = pd.read_csv('{}/wire_locations.csv'.format(path), header=0)
df *= 1000 # converting to mm
wire_locations = np.array(df['z'])
wire_radius = df.iloc[0, -1] # wire radius converted to mm
former_radius = df.iloc[0, 0] + wire_radius # radius of coil former
inner_radius = df.iloc[0, -3] # center of inner wire position
drawing = draw.Drawing(2.1*former_radius, 2.1*wire_locations[-1], origin='center')
# draws wire grooves
wire_groups = np.split(wire_locations, np.where(np.diff(wire_locations) > 2.5*wire_radius)[0]+1) # finds bundled wire groups
for group in wire_groups:
groove(drawing, group, former_radius, inner_radius, wire_radius)
drawing.setRenderSize(w=5000)
drawing.saveSvg('{}/grooves.svg'.format(path))
# draws wires on previous drawing
for wire in wire_locations:
for turn in df.iloc[0, :-1]:
drawing.append(draw.Circle(turn, wire, wire_radius,
fill='none', stroke_width=0.01, stroke='black'))
drawing.setRenderSize(w=5000)
drawing.saveSvg('{}/grooves_and_wires.svg'.format(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 render_circle(circle, model, target, style=None):
style = style_join(style or {}, circle.style)
assert len(style) > 0
x = N(model[circle.x])
y = M(model[circle.y], target)
r = N(model[circle.radius])
target.append(draw.Circle(x, y, r, **style))
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 drawText(self):
oldstartPoint = 0
startX = 0
length = 0
if self.xColumn.columnType == enums.ColumnDataType.Measures.value:
for cell, cell2, i in zip(self.LabelColumn.cells,
self.xColumn.cells,
range(0, len(self.LabelColumn.cells))):
if (type(cell2.value) != str):
if (i != 0):
length += 1
startX += oldstartPoint
height = self.getLength(double(cell2.value))
oldstartPoint = height
text = str(cell.value) + ": " + str(
self.percentageOfValue(double(
cell2.value)))[0:4] + "%"
self.d.append(
draw.Circle(self.widthView - 300,
length * 80 + 50,
20,
fill=self.colorList[i - 1],
fill_opacity=0.5,
stroke_width=0))
self.d.append(
draw.Text(text=str(text),
fontSize=30,
x=self.widthView - 250,
y=length * 80 + 50,
Class=str(self.Index),
id=self.Index))
self.metaData.append(text)
self.Index += 1
def draw_harbours(self, harbour_list):
for col, row, adj_tiles, harbour_type in harbour_list:
c_x, c_y = self._get_hexagon_coords(col, row)
t = draw.Text(harbour_type,
42,
c_x,
-c_y,
center=True,
stroke="lime")
c = draw.Circle(c_x, -c_y, r=32, fill="white", stroke="black")
n = set(
chain.from_iterable([(a, b) for _, _, type, a, b in adj_tiles
if not type == 'harbour']))
# 0 = 90° theta, 1= 30*, 2 = -30°, 3 = - 90°
for corner in n:
theta = 90 - corner * 60
e_x = int(self.HALF_TILE *
np.math.cos(np.math.radians(theta)) + c_x)
e_y = int(self.HALF_TILE *
np.math.sin(np.math.radians(theta)) + c_y)
line = draw.Line(c_x, -c_y, e_x, -e_y, **{
"stroke": "red",
"stroke-width": "5px"
})
self.drawing.extend([line])
self.drawing.extend([c, t])
def generateDot(self):
#determine angle
angle = 2 * np.pi * rand.random()
#determine the distance from the center
#distance must place the whole dot within the canvas
#should have greater likelihood to place near the center as controlled by some kind of parameter
multiplier = abs(rand.gauss(0, 0.2))
if multiplier > 1:
multiplier = 1
magnitude = multiplier * ((self.canvasWidth / 2) - self.dotRadius -
(self.boxThickness / 2))
#convert to cartesian
(cx, cy) = pol2cart(magnitude, angle)
#adjust bounds
self.adjustBounds(cx, cy)
#create circle
return draw.Circle(cx,
cy,
self.dotRadius,
fill=self.dotColor,
stroke_width=0)
def drawCircle(self, d, x, y, r, fill="f", pen=5):
pen = int(pen)
if fill == "f":
kwargs = {"fill_opacity": 0}
elif fill == "F":
kwargs = {"fill": self.STROKE_COLOR}
else:
kwargs = {"fill_opacity": 0}
x = int(x)
y = int(y)
r = int(r)
d.append(
draw.Circle(x,
y,
r,
stroke_width=pen,
stroke=self.STROKE_COLOR,
**kwargs))
v_list = [(x, y + r), (x, y - r), (x + r, y), (x - r, y)]
self.update_svg_boundary(v_list)
return d
def DrawCells(self,
url,
stroke="red",
stroke_width=1,
radius=3,
inter_distance=2,
fill="transparent",
draw_h=True,
h_line_width=1,
draw_out=False):
spacing = self.width / (self.n_leaves + 1)
width = self.width
height = self.height
d = self.d
#d.append(draw.Circle(150, 100, radius, stroke_width=2, stroke='white', stroke_dasharray="5,5", fill="transparent"))
#d.append(draw.Ellipse(150, 100, 80, 60, stroke_width=3, stroke='white', fill ="transparent"))
for n in self.tree.traverse():
# Inner tree, vertical lines
x_0, y_0, y_1 = n.x_coor, n.y_coor, self._y_scaling(n.dist)
n_cells = int(y_1 / ((radius * 2) + inter_distance))
for i in range(n_cells):
d.append(
draw.Circle(x_0,
y_0 + (inter_distance * i) + (i * radius * 2) +
inter_distance,
radius,
stroke_width=stroke_width,
stroke=stroke,
fill=fill))
if draw_out:
if i == 0:
continue
p = draw.Path(stroke_width=stroke_width,
stroke=stroke,
fill="none")
p.M(
x_0, y_0 + (inter_distance * i) + (i * radius * 2) +
inter_distance).l(-radius * 3, -radius * 3)
d.append(p)
if draw_h:
if not n.is_leaf():
c1, c2 = n.get_children()
# Horizontal lines
# Inner Tree
p = draw.Path(stroke=stroke,
stroke_width=h_line_width,
fill='none')
p.M(c1.x_coor, n.y_coor).L(c2.x_coor, n.y_coor)
d.append(p)
d.setRenderSize(h=self.height)
d.saveSvg(url)
return (d)
def _draw_number(self, x, y, val):
text = draw.Text(str(val), self.FONT_SIZE, x, -(y), center=True)
circle = draw.Circle(x,
-(y + 4),
r=self.FONT_SIZE * 0.75,
fill="beige",
stroke="black")
return [circle, text]
def __init__(self):
"""반지름이 1인 원을 생성하고, group하나를 만든다."""
self.image_size = 500
self.d = draw.Drawing(2, 2, origin='center') # viewbox(-1, -1, 2, 2)
self.d.setRenderSize(self.image_size)
self.d.append(draw.Circle(0, 0, 1, fill='orange'))
group = draw.Group()
self.d.append(group)
def draw_number(drawing,
viewport,
number,
number_offset,
number_total,
recursion_depth=0):
if number == 1:
drawing.append(
draw.Circle(viewport.cx,
viewport.cy,
viewport.scale,
fill=col(number_offset / number_total),
stroke_width=0.25,
stroke='black'))
return
n = largest_prime_factor(number)
alpha = tau / n
# calculate the major circle radius
R = viewport.scale
if recursion_depth > 0:
R *= 0.95 # add some padding between intermediate levels
# calculate the minor circle radius
r = R - R / (
1 + math.sin(alpha / 2)
) # small circle radius needed to form a ring of circles inscribed in R
d = R - r
# special case for repeated 2-factors to eliminate excessive padding
if n == 2 and number > 2:
r *= 1.25
#if n == number: # optional: shade the inside of the smallest prime factor
# e = math.cos(alpha/2) * d
# drawing.append(draw.Circle(viewport.cx, viewport.cy, e, fill = '#eee'))
for i in range(n):
angle = (viewport.angle + i / n * tau) % tau
v = Viewport()
# rotate the viewport
v.cx, v.cy = viewport.cx + d * math.cos(
angle), viewport.cy + d * math.sin(angle)
v.scale = r
v.angle = angle
if n == 2:
# special case 90° rotation to make repeated factors 2 tile in both directions (can probably be generalized)
v.angle += tau / 4
# recursion – cycle colors except for the last grouping (unless it's a prime)
draw_number(
drawing, v, number // n, number_offset +
(recursion_depth == 0 or n != number) * i * number // n,
number_total, recursion_depth + 1)
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_ball(self, p, radius):
c = draw.Circle(
p.x,
p.y,
radius,
fill='pink',
fill_opacity=.25,
stroke_width=.5,
stroke='black',
)
context.append(c)
def drawCircle(self):
colorList = self.generateRandomColorsList(len(self.firstColumn.cells))
xCenter = self.xCenter
yCenter = self.yCenter
r = self.r
oldEndangle = 0
endAngle = 0
length = 0
for cell, cell2, i in zip(self.firstColumn.cells,
self.secondColumn.cells,
range(0, len(self.firstColumn.cells))):
if (type(cell2.value) != str):
if (i != 0):
length += 1
startangle = oldEndangle
endAngle += self.getAngle(double(cell2.value))
oldEndangle = endAngle
radiansconversion = np.pi / 180.
xstartpoint = xCenter + r * np.cos(
startangle * radiansconversion)
ystartpoint = yCenter - r * np.sin(
startangle * radiansconversion)
xendpoint = xCenter + r * np.cos(
endAngle * radiansconversion)
yendpoint = yCenter - r * np.sin(
endAngle * radiansconversion)
large_arc_flag = 0
if endAngle - startangle > 180: large_arc_flag = 1
M = ("M %s %s" % (xstartpoint, ystartpoint))
a = ("A %s %s 0 %s 0 %s %s" %
(r, r, large_arc_flag, xendpoint, yendpoint))
L = ("L %s %s" % (xCenter, yCenter))
p = draw.Path(stroke_width=10,
stroke="white",
fill=colorList[i - 1],
fill_opacity=0.5,
d=M + a + L)
p.Z()
self.d.append(p)
text = str(cell.value) + ": " + str(
self.percentageOfValue(double(cell2.value)))[0:4] + "%"
self.d.append(
draw.Circle(self.widthView + 100,
length * 80,
20,
fill=colorList[i - 1],
fill_opacity=0.5,
stroke_width=0))
self.d.append(
draw.Text(text=str(text),
fontSize=30,
x=self.widthView + 150,
y=length * 80 - 10))
def drawColmunsColorList(self, colors: List[str]):
if((self.widthView / (len(self.dataSourceTableWithoutXcolumn.columns) + 1)) / 15 <(self.heightView / (len(self.dataSourceTableWithoutXcolumn.columns) + 1)) / 15):
fontSize = (self.widthView / (len(self.dataSourceTableWithoutXcolumn.columns) + 1)) / 15
else:
fontSize = (self.heightView / (len(self.dataSourceTableWithoutXcolumn.columns) + 1)) / 15
add = self.widthView / 50
num = "X:" + str(self.xColumn.name)
if (len(str(num)) > 10):
num = num[0:8] + "..."
self.metaData.append("X:" + str(self.xColumn.name))
self.Index += 1
c = draw.Circle(add, self.heightOfXLabels / 4 +(fontSize / 2), fontSize / 2, fill="black", stroke_width=0,stroke='black',fill_opacity=1)
t =draw.Text(text=str(num), fontSize=fontSize, x=add + (fontSize * 2),y=self.heightOfXLabels / 4 + (fontSize / 3),style="font-size : " + str(fontSize),Class=str(self.Index),id=str(self.Index))
if self.animation:
t.appendAnim(draw.Animate('x', str((self.Index / 20) ) + 's', from_or_values=0, to=add + (fontSize * 2),repeatCount='1'))
c.appendAnim(draw.Animate('cx', str((self.Index / 20) - 0.1) + 's', from_or_values=0, to=add + (fontSize * 2),repeatCount='1'))
self.d.append(t)
self.d.append(c)
add += self.widthView / (len(self.dataSourceTableWithoutXcolumn.columns) + 3)
columnCounter = 0
for column in self.dataSourceTableWithoutXcolumn.columns:
if column !=self.xColumn:
if column.columnType == enums.ColumnDataType.Measures.value:
num = column.name
if (len(str(num)) > 10):
num = num[0:8] + "..."
self.metaData.append(num)
c = draw.Circle(add, self.heightOfXLabels / 4 + (fontSize / 2), fontSize / 2, fill=colors[columnCounter],stroke_width=0,stroke='black')
t = draw.Text(text=str(num), fontSize=fontSize, x=add + (fontSize * 2),y=self.heightOfXLabels / 4 + (fontSize / 3),style="font-size : " +str(fontSize),Class=str(self.Index),id=str(self.Index))
if self.animation:
t.appendAnim(draw.Animate('x', str((self.Index / 20) ) + 's', from_or_values=0, to=add + (fontSize * 2),repeatCount='1'))
c.appendAnim(draw.Animate('cx', str((self.Index / 20) - 0.1) + 's', from_or_values=0, to=add + (fontSize * 2),repeatCount='1'))
c.appendAnim(draw.Animate('r', '3.2s', from_or_values=fontSize, to=abs(fontSize / 2), repeatCount='1'))
self.d.append(t)
self.d.append(c)
add += self.widthView / (len(self.dataSourceTableWithoutXcolumn.columns) + 3)
self.Index += 1
columnCounter += 1
def draw_legend(d):
d.append(draw.Circle(250, 320, 20, fill="yellow", stroke="orange"))
d.append(
draw.Line(0,
0,
0,
200,
stroke_width=2,
stroke="red",
fill="yellow",
transform="translate(250, -320) rotate(-80)"))
d.append(draw.Circle(550, 320, 20, fill="yellow", stroke="orange"))
d.append(
draw.Line(0,
-100,
0,
100,
stroke_width=2,
stroke="green",
fill="yellow",
transform="translate(550, -320) rotate(-30)"))
def draw_component_positions(filename, drawing, bottom_layer=False):
file = open(filename, 'r')
offset_x, offset_y, *temp = file.readline().replace(',', '.').split('|')
file.readline() # Skip empty line
for entry in file:
name, tele_id, x, y, rotation = entry.replace(',', '.').rstrip().split('|')
x = float(x) + float(offset_x)
y = float(y) + float(offset_y)
x = x * factor
y = y * factor
if bottom_layer:
y = output_image_height - y
rotation = int(rotation) + 180
drawing.append(
draw.Circle(x, y, 0.3 * factor, fill="yellow"))
rotation_transform = str.format(
"translate({1}, {2}) rotate({0}) ", str(-int(rotation)), str(x), str(-y))
drawing.append(
draw.Line(0, 0, 0, 1 * factor, stroke="red", stroke_width=2, transform=rotation_transform))
if name in part_package:
package = part_package[name]
if package in first_pads:
pad_position = first_pads[package]
pad_x = pad_position[0] * factor
pad_y = pad_position[1] * factor
angle_rad = radians(int(rotation))
rot_x = pad_x * math.cos(angle_rad) - pad_y * math.sin(angle_rad)
rot_y = pad_x * math.sin(angle_rad) + pad_y * math.cos(angle_rad)
rotation_transform = str.format(
"translate({1}, {2}) rotate({0})", str(-int(rotation)), str(x), str(-y))
drawing.append(draw.Circle(pad_x, pad_y, 0.2 * factor, fill="blue", transform=rotation_transform))
drawing.append(
draw.Text(name, 1 * factor, x - rot_x, y + rot_y, stroke="#444444", fill="lightgreen"))
def drawPoint(self):
i =1
for x,y,data in zip(self.lngColumn.cells[1:],self.latColumn.cells[1:],self.xColumn.cells[1:]):
text = self.xColumn.name + ":" + str(data.value)
for column in self.dataSourceTableWithoutXcolumn.columns:
text += ' '+'<br/>' +column.name + ":" + str(column.cells[i].value)
c = draw.Circle(self.convertX(x.value)+self.zeroX,self.convertY(y.value)+self.zeroY, 0.9 , fill="green", stroke_width=0, stroke='green',Class=self.Index,fill_opacity=1, transform="translate(-163.3,-120.8) ")
if self.animation:
c.appendAnim(draw.Animate('r', '3.2s', from_or_values=15, to=abs(1), repeatCount='1'))
c.appendAnim(draw.Animate('cx', '2s', from_or_values=0, to=abs(self.convertX(x.value)+self.zeroX), repeatCount='1'))
self.d.append(c)
self.metaData.append(text)
self.Index += 1
i += 1
def drawCircle(self):
xcenter = self.xCenter
ycenter = self.yCenter
r = self.r
Y = -self.yCenter
length = -1
for cell, cell2, i in zip(self.firstColumn.cells, self.secondColumn.cells,
range(0, len(self.firstColumn.cells))):
if (type(cell2.value) != str):
if (i != 0):
length += 1
startangle = 0
endangle = self.getAngle(double(cell2.value))
radiansconversion = np.pi / 180.
xstartpoint = xcenter + r * np.cos(startangle * radiansconversion)
ystartpoint = ycenter - r * np.sin(startangle * radiansconversion)
xendpoint = xcenter + r * np.cos(endangle * radiansconversion)
yendpoint = ycenter - r * np.sin(endangle * radiansconversion)
large_arc_flag = 0
if endangle - startangle > 180: large_arc_flag = 1
M = ("M %s %s" % (xstartpoint, ystartpoint))
a = ("A %s %s 0 %s 0 %s %s" % (r, r, large_arc_flag, xendpoint, yendpoint))
L = ("L %s %s" % (xcenter, ycenter))
p = draw.Path(stroke_width=10, stroke="white", fill=self.colorList[i - 1], fill_opacity=1,
d=M + a + L,Class=str(self.Index),id=self.Index)
p.Z()
self.d.append(p)
text = str(self.firstColumn.cells[i - len(self.firstColumn.cells)].value) + ": " + str(
self.percentageOfValue(cell2.value))[0:4] + "%"
self.metaData.append(text)
r -= self.r / len(self.firstColumn.cells)
c=draw.Circle(-ycenter, xcenter, r, fill="white", fill_opacity=1,
stroke="white", stroke_width=10)
if self.animation:
c.appendAnim(draw.Animate('r', '0.35s', from_or_values=0, to=r, repeatCount='1'))
self.d.append(c)
t =draw.Text(text=str(text), fontSize=30, x=str((length * 55 + 8) - 50), y=Y -50, style="font-size : "+str(30),
transform="rotate(90," + str(self.xCenter - 40) + "," + str(
-length * 55 + 8) + ")",Class=str(self.Index),id=self.Index
,Style="font-size : " + str(10))
if self.animation:
t.appendAnim(draw.Animate('x', str(length/4)+'s', from_or_values=0, to=(length * 55 + 8) - 50, repeatCount='1'))
self.d.append(t)
self.Index += 1
Y -= ((self.r / len(self.firstColumn.cells)) / 100)-10
def show(self):
d = draw.Drawing(1.4, 1.4, origin='center')
d.append(
draw.Circle(0,
0,
0.5,
stroke_width='0.005',
stroke=self.color,
fill_opacity='0.0'))
for region in self.regions:
d.append(region.draw(self.length))
d.setRenderSize(self.size)
return d
def drawXPointsWithXValueSteps(self):
add = self.widthOfYLabels
for cell, i in zip(self.xColumn.cells[0:], range(1, len(self.xColumn.cells))):
add += self.xUnit
num = self.xColumn.cells[i].value
self.metaData.append(str(num))
if (len(str(num)) > 10):
num = num[0:8] + "..."
self.d.append(
draw.Circle(add, self.heightOfXLabels, self.xUnit / 35, fill="black", stroke_width=0, stroke='black'))
self.d.append(
draw.Text(text=str(num), fontSize=self.heightOfXLabels /10, x=add ,
y=self.heightOfXLabels /1.29,
id=str(self.Index),Class=str(self.Index),
style="font-size : " + str(self.heightOfXLabels / 10),
transform="rotate(90," + str(add ) + "," + str(-self.heightOfXLabels / 1.29) + ")"))
self.Index += 1
def draw(self, x=0, y=0, xscale=1.0):
h = self.h
a = self.x * xscale
b = (self.x + self.w) * xscale
x = x * xscale
r = h / 2
font_size = h * 0.55
arrow_size = 7
if self.direction >= 0:
line_start = a
arrow_end = b
arrow_start = max(arrow_end - arrow_size, line_start)
else:
line_start = b
arrow_end = a
arrow_start = min(arrow_end + arrow_size, line_start)
centre = (a + b) / 2
arrow_y = h / 2 + self.elevation * r
group = draw.Group(transform="translate({} {})".format(x, y))
group.append(
draw.Line(line_start,
arrow_y,
arrow_start,
arrow_y,
stroke='black'))
group.append(
draw.Circle(centre, h / 2, r, fill='ivory', stroke='black'))
group.append(
draw.Lines(arrow_end,
arrow_y,
arrow_start,
arrow_y + arrow_size / 2,
arrow_start,
arrow_y - arrow_size / 2,
arrow_end,
arrow_y,
fill='black'))
group.append(
draw.Text(self.label,
font_size,
centre,
h / 2,
text_anchor='middle',
dy="0.35em"))
return group
def drawText(self):
h = 40
i = 1
for cell in self.xColumn.cells[1:]:
self.d.append(
draw.Circle(self.widthView - 230,
h,
20,
fill=self.colorList[i - 1],
fill_opacity=0.5,
stroke_width=0))
self.d.append(
draw.Text(text=str(cell.value),
fontSize=30,
x=self.widthView - 200,
y=h))
h += 60
i += 1
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 drawNote(self, d: dsvg.Drawing, x: float, y: float) -> float:
fs = self.fretStyle
if self.individualMarked:
textY = y - fs.fontSize / 4.0
d.append(
dsvg.Circle(x + fs.circleX,
y,
fs.radius,
fill=fs.circleFillColor,
stroke_width=2,
stroke=fs.circleStrokeColor))
d.append(
dsvg.Text(self.noteName,
fs.fontSize,
x + fs.circleX,
textY,
fill=fs.circleStrokeColor,
center=False,
text_anchor='middle'))
return fs.fretWidth
def drawPointsOfValuesInDataSourceTableWithoutXColumn(self, colors: List[str]):
columnCounter = 0
for column in self.dataSourceTableWithoutXcolumn.columns:
if column.columnType == enums.ColumnDataType.Measures.value:
if (column != self.xColumn):
add = self.widthOfYLabels
for cell, i in zip(column.cells, range(0, len(self.xColumn.cells))):
if (i != 0):
add += self.xUnit
self.metaData.append("(" + str(self.xColumn.cells[i].value) + "," + str(cell.value) + ")")
c = draw.Circle(add, self.convertY(double(cell.value)), self.xUnit / 25,
fill=colors[columnCounter],
stroke_width=0,Class=str(self.Index),
stroke=colors[columnCounter], id=(self.Index))
if self.animation:
c.appendAnim(draw.Animate('cx', '2s', from_or_values=0, to=abs(add),repeatCount='1'))
c.appendAnim(
draw.Animate('r', '3.2s', from_or_values=(self.xUnit / 25)*2, to=abs(self.xUnit / 25), repeatCount='1'))
self.d.append(c)
self.Index += 1
columnCounter += 1
def draw_svg(json_articles, width, height, colors, sizes, country_font_size=30, directory=None):
"""
Given a json of cleaned articles (popularity score scaled), calculate the country label positions and draw the entire svg
"""
drawing = draw.Drawing(width, height, origin="center")
draw_dash_boundary(directory + '/boundary.csv', drawing)
draw_elevation(directory + '/elevation.csv', drawing)
for v in json_articles.values():
# Draw each article
title = v["Article"]
x = v["x"] * XY_RATIO
y = v["y"] * XY_RATIO # The original x, y are too small to visualize
country = v["Country"]
size = sizes[v['Article']] # Augment the font_size and circle size correspondingly
drawing.append(draw.Circle(x, y, size, **{ 'fill' : colors[country], 'fill-opacity' : 0.6 }))
if size > 0.2:
adjusted_x, adjusted_y = x - 0.5*len(title)*XY_RATIO, y - 0.5*size
drawing.append(draw.Text(title, int(size), adjusted_x, adjusted_y))
# Draw country labels
country_labels_xy = get_country_labels_xy(json_articles)
draw_country_labels(drawing, country_labels_xy, country_font_size, colors)
return drawing
def drawSigil(points, canvas, color='white'): # draw sigil from coordinate list
# setup sigil
dash = svg.Marker(-0.5, -0.5, 0.5, 0.5, scale=5, orient='auto') # define line to terminate the sigil
dash.append(svg.Line(-0., -0.5, 0., 0.5, stroke_width=0.2, stroke=color))
dot = svg.Marker(-0.8, -0.5, 0.5, 0.5, scale=5, orient='auto') # define circle to start the sigil
dot.append(svg.Circle(-0.3, 0.0, 0.3, stroke_width=0.2, stroke=color, fill='none'))
p = svg.Path(stroke_width=7, stroke=color, fill='none', marker_start=dot, marker_end=dash)
# draw sigil
for point in points:
if points.index(point) == 0:
originX = point[0]
originY = point[1]
p.M(originX, originY)
else:
x = point[0] - originX # abs. to rel. coords
y = point[1] - originY # abs. to rel. coords
p.l(x, y) # draw
originX = point[0]
originY = point[1]
# add to canvas
canvas.append(p)
def render(self, dpi=96, background=None):
# self.printState()
# TODO: implement polyline
d = draw.Drawing(self.diameter, self.diameter, origin='center')
radius = self.diameter / 2.0
if background is not None:
d.append(
draw.Rectangle(-radius,
-radius,
self.diameter,
self.diameter,
fill=background))
d.append(
draw.Circle(0,
0,
radius,
stroke='black',
stroke_width=5,
stroke_opacity=1,
fill='none'))
for i in range(self.n_pins - 1, 0, -1):
for j in range(0, i):
for yarn in self.state[i][j]:
endPoint = self._get_point(i)
startPoint = self._get_point(j)
d.append(
draw.Line(startPoint.x,
startPoint.y,
endPoint.x,
endPoint.y,
stroke_width=yarn.width,
stroke=yarn.color,
stroke_opacity=0.4,
fill='none'))
d.setPixelScale(dpi * 0.393701 / 10)
return d
