def _draw_line_to_non_period_event(self, view_properties, event, rect):
x = self._scene.x_pos_for_time(event.mean_time())
y = rect.Y + rect.Height / 2
stroke = {True: "red", False: "black"}[view_properties.is_selected(event)]
line = ShapeBuilder().createLine(x, y, x, self._scene.divider_y, stroke=stroke)
circle = ShapeBuilder().createCircle(x, self._scene.divider_y, 2)
return line, circle
def _draw_event_rect(self, event, rect):
boxBorderColor = self._get_event_border_color(event)
if event.is_container() and EXTENDED_CONTAINER_HEIGHT.enabled():
svg_rect = ShapeBuilder().createRect(rect.X, rect.Y - Y_RECT_OFFSET, rect.GetWidth(),
rect.GetHeight() + Y_RECT_OFFSET,
stroke=boxBorderColor,
fill=self._get_event_box_color(event))
else:
svg_rect = ShapeBuilder().createRect(rect.X, rect.Y, rect.GetWidth(), rect.GetHeight(),
stroke=boxBorderColor, fill=self._get_event_box_color(event))
if self._shadow_flag:
svg_rect.set_filter("url(#filterShadow)")
return svg_rect
def createblock(number):
colors = {}
colors[None] = ('#eee4da', '#776e65')
colors[2] = ('#eee4da', '#776e65')
colors[4] = ('#ede0c8', '#776e65')
colors[8] = ('#f2b179', '#f9f6f2')
colors[16] = ('#f59563', '#f9f6f2')
colors[32] = ('#f67c5f', '#f9f6f2')
colors[64] = ('#f65e3b', '#f9f6f2')
colors[128] = ('#edcf72', '#f9f6f2')
colors[256] = ('#edcc61', '#f9f6f2')
colors[512] = ('#eee4da', '#776e65')
colors[1024] = ('#edc53f', '#f9f6f2')
colors[2048] = ('#edc22e', '#f9f6f2')
canvas = Svg(0, 0, 100, 100)
sb = ShapeBuilder()
canvas.addElement(sb.createRect(5, 5, 90, 90, fill=colors[number][0]))
t = Text(number, 50, 60)
t.set_style(
"font-family:FreeSans;font-weight:bold;font-size:36px;text-anchor:middle"
)
t.set_fill(colors[number][1])
canvas.addElement(t)
return canvas.getXML()
def _draw_background(self):
svg_color = self._map_svg_color(self._appearence.get_bg_colour()[:3])
return ShapeBuilder().createRect(0,
0,
self._scene.width,
self._scene.height,
fill=svg_color)
def test_appending(self):
frag_file = "tmp/b.svg"
main_file = "tmp/a.svg"
main = svg()
frag = svg()
exp = svg()
sb = ShapeBuilder()
main.addElement(sb.createRect(0, 0, "200px", "100px"))
exp.addElement(sb.createRect(0, 0, "200px", "100px"))
frag.addElement(text("Hello World", x=210, y=110))
exp.addElement(text("Hello World", x=210, y=110))
main.save(main_file)
frag.save(frag_file)
append_svg_to_file(frag_file, main_file)
svg_main = parse(main_file)
gotS = str(svg_main.getXML())
expS = str(exp.getXML())
print "Got:", gotS
print "Exp:", expS
#self.assertEqual(exp.getXML(), svg_main.getXML(), "Appended files are equal" )
if gotS != expS:
print "Different\nGot:\n", gotS, "\nExp:\n", expS
def between(x, y, x2, y2, outie=10, angle=45, color=PUR_3, width=4):
"""outie direction is billowing if it were traveling counterclockwise"""
points = []
sb = ShapeBuilder()
points.append('{0},{1}'.format(x, y))
slope = slope_angle(x, y, x2, y2)
out_angle = slope + angle
out_r = out_angle * math.pi / 180
next_x = x + outie * math.cos(out_r)
next_y = y - outie * math.sin(out_r)
points.append('{0},{1}'.format(next_x, next_y))
slope_r = slope * math.pi / 180
distance = math.sqrt((x2 - x)**2 + (y2 - y)**2)
flat_len = distance - 2 * outie * (math.cos(out_r))
next_x2 = next_x + flat_len * math.cos(slope_r)
next_y2 = next_y - flat_len * math.sin(slope_r)
points.append('{0},{1}'.format(next_x2, next_y2))
points.append('{0},{1}'.format(x2, y2))
line = sb.createPolyline(points=' '.join(points))
style = 'fill:{0};stroke-width:{1};stroke:{2};stroke-linecap:round'.format(
ALPHA, width, color)
line.set_style(style)
return [line]
def get_svg_groups(self, h_offset: int = 0, v_offset: int = 0, scaling: float = 1.,
screenwidth: int = 1024, colours: Dict[str, str] = None,
overview: bool = False, prefix: str = "dummy") -> List[Group]:
""" Returns all SVG elements required to draw the Cluster """
if not colours:
colours = {}
groups = []
group = Group()
self._add_label(group, v_offset)
line_y = 35 + v_offset
group.addElement(ShapeBuilder().createLine(10, line_y,
10 + (screenwidth * 0.75), line_y,
strokewidth=1, stroke="grey"))
groups.append(group)
# Add gene arrows
arrow_y = line_y + 5
offset = h_offset - self.start
if self.reversed:
offset = h_offset + self.end
for i, gene in enumerate(self.genes):
group = Group()
arrow = gene.get_arrow_polygon(scaling=scaling, offset=offset,
base=arrow_y,
colour=colours.get(gene.name, "white"))
if overview:
label = "all_"
else:
label = "h"
arrow.set_id("%s-%d_%s%d_%s_%s" % (prefix, self.query_cluster_number, label,
self.query_cluster_number, self.rank, i))
group.addElement(arrow)
# Can be used for domains
group.set_id("a%s_00%s" % (self.query_cluster_number, i))
groups.append(group)
return groups
def get_svg_groups(self, h_offset: int = 0, v_offset: int = 0, scaling: float = 1.,
screenwidth: int = 1024, colours: Dict[str, str] = None,
overview: bool = False, prefix: str = "dummy") -> List[Group]:
""" Returns all SVG elements required to draw the Cluster """
if not colours:
colours = {}
groups = []
group = Group()
acc = Text(self.description, 5, 20)
acc.set_class("clusterblast-acc")
group.addElement(acc)
line_y = 35 + v_offset
group.addElement(ShapeBuilder().createLine(10, line_y, 10 + (screenwidth * 0.75),
line_y, strokewidth=1, stroke="grey"))
group.setAttribute('label', self.description)
group.set_class('clusterblast-cluster')
groups.append(group)
base = line_y + 5
offset = h_offset + 10 - self.start # 10 for margin
for index, gene in enumerate(self.genes):
arrow = gene.get_arrow_polygon(scaling=scaling, offset=offset,
base=base, colour=colours.get(gene.name, "white"))
arrow.set_id("%s-%s_q%s_%s_%s" % (prefix, self.query_cluster_number, index, self.rank, "all"))
group.addElement(arrow)
return groups
def _draw_categories_box(self, nbr_of_categories):
return ShapeBuilder().createRect(
self._get_categories_box_x(),
self._get_categories_box_y(nbr_of_categories),
self._get_categories_box_width(),
self._get_categories_box_height(nbr_of_categories),
fill='white')
def _draw_divider_line(self):
return ShapeBuilder().createLine(0,
self._scene.divider_y,
self._scene.width,
self._scene.divider_y,
strokewidth=0.5,
stroke="grey")
def _draw_vertical_line(self, x, colour):
return ShapeBuilder().createLine(x,
0,
x,
self._scene.height,
strokewidth=0.5,
stroke=colour)
def triangle(x1, y1, x2, y2, x3, y3, fill):
points = []
sb = ShapeBuilder()
for x, y in [(x1, y1), (x2, y2), (x3, y3), (x1, y1)]:
points.append('{0},{1}'.format(x, y))
pl = sb.createPolyline(points=' '.join(points))
style = 'fill:{0}'.format(fill)
pl.set_style(style)
return [pl]
def _draw_category_color_box(self, item_height, x, y, cat):
base_color = self._map_svg_color(cat.color)
border_color = self._map_svg_color(darken_color(cat.color))
return ShapeBuilder().createRect(x + OUTER_PADDING,
y,
item_height,
item_height,
fill=base_color,
stroke=border_color)
def _draw_era_strip(self, era):
svg_color = self._map_svg_color(era.get_color()[:3])
x, width = self._calc_era_strip_metrics(era)
return ShapeBuilder().createRect(x,
INNER_PADDING,
width,
self._scene.height -
2 * INNER_PADDING,
fill=svg_color,
strokewidth=0)
def testIterationsWithAttributesChange():
s = Svg()
sb = ShapeBuilder()
coords = [(1, 1), (200, 200)]
for (x, y) in coords:
rectangle = sb.createRect(0, 0, 100, 200, fill='000')
rectangle.set_x(x)
rectangle.set_y(y)
s.addElement(rectangle)
s.save('./testoutput/iterationsWithAttributesChange.svg')
def get_arrow_polygon(self, scaling: float = 1., offset: int = 0, base: int = 35,
height: int = 10, colour: str = "white") -> Polygon:
""" Returns an SVG polygon shaped like an arrow that represents the Gene """
if self.reversed:
start = int((offset - self.get_start()) * scaling)
end = int((offset - self.get_end()) * scaling)
else:
start = int((self.get_start() + offset) * scaling)
end = int((self.get_end() + offset) * scaling)
start, end = sorted([start, end])
builder = ShapeBuilder()
arrow_size = height // 2
if abs(start - end) < arrow_size:
if self.strand > -1:
points = [(start, base),
(end, base - arrow_size),
(start, base - height),
(start, base)]
else:
points = [(start, base - arrow_size),
(end, base - height),
(end, base),
(start, base - arrow_size)]
else:
if self.strand > -1:
arrowstart = end - arrow_size
points = [(start, base),
(arrowstart, base),
(end, base - arrow_size),
(arrowstart, base - height),
(start, base - height),
(start, base)]
else:
arrowstart = start + arrow_size
points = [(start, base - arrow_size),
(arrowstart, base - height),
(end, base - height),
(end, base),
(arrowstart, base),
(start, base - arrow_size)]
arrow = builder.createPolygon(strokewidth=1, stroke='black', fill=colour,
points=builder.convertTupleArrayToPoints(points))
locus_tag = self.name
if self.protein:
locus_tag = self.protein.get_id()
arrow.setAttribute('description', self._get_description())
arrow.setAttribute('locus_tag', locus_tag)
arrow.set_class('clusterblast-orf')
return arrow
def _draw_contents_indicator(self, event, rect):
"""
The data contents indicator is a small triangle drawn in the upper
right corner of the event rectangle.
"""
corner_x = rect.X + rect.Width
points = "%d,%d %d,%d %d,%d" % \
(corner_x - DATA_INDICATOR_SIZE, rect.Y,
corner_x, rect.Y,
corner_x, rect.Y + DATA_INDICATOR_SIZE)
color = self._get_box_indicator_color(event)
indicator = ShapeBuilder().createPolygon(points, fill=color, stroke=color)
# TODO (low): Transparency ?
return indicator
def testIterationsWithUse():
s = Svg()
d = Defs()
sb = ShapeBuilder()
rectangle = sb.createRect(0, 0, 100, 200, fill='000')
rectangle.set_id('baseRect')
d.addElement(rectangle)
s.addElement(d)
coords = [(1, 1), (200, 200)]
for (x, y) in coords:
r = Use()
r.set_x(x)
r.set_y(y)
r.set_xlink_href('#baseRect')
s.addElement(r)
s.save('./testoutput/iterationsWithUse.svg')
def diff(spikes=9, radius=10):
points = []
sb = ShapeBuilder()
for i, angle in enumerate(xrange(0, 360 + 1, float(180) / spikes)):
if i % 2 == 0:
r = radius * .8
else:
r = radius
radians = angle * math.pi / 180
coord = '{0},{1}'.format(r * math.cos(radians), r * math.sin(radians))
print "ANGLE", angle, "COOR", coord, "RAD", radians
points.append(coord)
print "POINTS", points
line = sb.createPolyline(points=' '.join(points))
fill = BLACK
stroke = ORANGE_3
style = 'fill:{0};stroke-width:{1};stroke:{2}'.format(fill, 2, stroke)
line.set_style(style)
return [line]
from pysvg.builders import Svg, ShapeBuilder, StyleBuilder
from pysvg.text import *
canvas = Svg(0, 0, 100, 100)
sb = ShapeBuilder()
canvas.addElement(sb.createRect(5, 5, 90, 90, fill="#00FF00"))
t = Text('Hello!', 50, 50)
t.set_style(
"font-family:FreeSans;font-weight:bold;font-size:24px;text-anchor:middle")
t.set_fill("#FF0000")
canvas.addElement(t)
canvas.save('/tmp/try7.svg')
