def an_envelop(width, height, spec):
envelop_group, envelop_width, envelop_height = a_rectangle(width,
height,
spec=spec)
# two lines from center to top left and top right to give it an envelop look
center_point = Point(width / 2, height / 2)
top_left_point = Point(0, 0)
top_right_point = Point(width, 0)
points = [top_left_point, center_point, top_right_point, top_left_point]
# the lines' color is shapes stroke
line_style = StyleBuilder(spec['style']).getStyle()
line1_svg = Line(x1=0,
y1=0,
x2=width / 2,
y2=height / 2,
style=spec['style'])
line2_svg = Line(x1=width / 2,
y1=height / 2,
x2=width,
y2=0,
style=spec['style'])
line1_svg.set_style(line_style)
line2_svg.set_style(line_style)
envelop_group.addElement(line1_svg)
envelop_group.addElement(line2_svg)
return envelop_group, width, height
def a_lightning(width, height, spec):
diagonal = math.sqrt(width * width + height * height)
len_mb_mt = (diagonal / 2) * 0.3
len_mt_tl = (diagonal / 2) * 0.4
angle_bl_tr = math.atan(height / width)
angle_mt_tl = math.pi / 2
bottom_left = Point(0, height)
mid_top = bottom_left.to_point(math.degrees(angle_bl_tr),
diagonal / 2 + len_mb_mt / 2)
mid_bottom = bottom_left.to_point(math.degrees(angle_bl_tr),
diagonal / 2 - len_mb_mt / 2)
top_left = mid_top.to_point(math.degrees(angle_mt_tl + angle_bl_tr),
len_mt_tl)
top_right = Point(width, 0)
bottom_right = mid_bottom.to_point(
-math.degrees(angle_mt_tl - angle_bl_tr), len_mt_tl)
lightning_points = [
bottom_left, top_left, mid_top, top_right, bottom_right, mid_bottom
]
# lightning_points = [bottom_left, top_left, mid_top]
lightning_svg = Polygon(points=points_to_str(lightning_points))
lightning_svg.set_style(StyleBuilder(spec['style']).getStyle())
return lightning_svg, width, height
def a_gear(radius, spec):
mark_length = radius * 0.3
circle_radius = radius - mark_length
gear_group_svg, _, _ = a_circle(radius=circle_radius, spec=spec)
# the inner circle
inner_circle_radius = radius * 0.1
inner_circle_svg = Circle(cx=circle_radius,
cy=circle_radius,
r=inner_circle_radius)
inner_circle_svg.set_style(StyleBuilder(spec['style']).getStyle())
gear_group_svg.addElement(inner_circle_svg)
# the hour marks
center_point = Point(circle_radius, circle_radius)
for mark in range(0, 9):
point_on_circle = center_point.to_point(40 * mark, circle_radius)
point_outside = center_point.to_point(40 * mark,
circle_radius + mark_length)
mark_svg = Line(x1=point_on_circle.x,
y1=point_on_circle.y,
x2=point_outside.x,
y2=point_outside.y)
mark_svg.set_style(StyleBuilder(spec['style']).getStyle())
gear_group_svg.addElement(mark_svg)
# add to group
return gear_group_svg, radius * 2, radius * 2
def connect_southward(self, from_lane_number, point_from, to_lane_number, point_to):
# see if there is one or more lanes between the from-lane and to-lane
if to_lane_number > from_lane_number + 1:
# yes we have lanes in between
# we bypass the northmost (first) lane
lane_number_to_bypass = from_lane_number + 1
lane_to_bypass = self.pool_collection_list[lane_number_to_bypass]
margin_spec = self.margin_spec(lane_number_to_bypass)
points_to_bypass_the_lane = lane_to_bypass.bypass_vertically(coming_from=point_from, going_to=point_to, margin_spec=margin_spec)
return [point_from] + points_to_bypass_the_lane + self.connect_southward(lane_number_to_bypass, points_to_bypass_the_lane[-1], to_lane_number, point_to)
else:
# there is no lane in between
if point_from.y == point_to.y:
# they are on the same horizontal line - inside a lane routing area
return [point_from, Point(point_from.x, point_to.y), point_to]
else:
# they are not on a line, we need a connecting path, looks like one or both of them are at eastern/western boundary
# the north (point_from) needs to come down to southern boundary
point_from_next = Point(point_from.x, self.pool_collection_list[from_lane_number].element.xy.y + self.pool_collection_list[from_lane_number].element.height + self.margin_spec(to_lane_number)['bottom'])
# the south (point_to) needs to move up to northern boundary
point_to_next = Point(point_to.x, self.pool_collection_list[to_lane_number].element.xy.y - self.margin_spec(to_lane_number)['top'])
return [point_from, point_from_next, point_to_next, point_to]
def an_upword_arrowhead(width, height, spec):
mid_point = Point(width / 2, height / 2)
top_point = Point(width / 2, 0)
left_point = Point(0, height)
right_point = Point(width, height)
arrowhead_points = [mid_point, left_point, top_point, right_point]
arrowhead_svg = Polygon(points=points_to_str(arrowhead_points))
arrowhead_svg.set_style(StyleBuilder(spec['style']).getStyle())
return arrowhead_svg, width, height
def snap_points(self, width, height):
snaps = super().snap_points(width, height)
# add two more (slight left and slight right) for north-middle)
snaps['north']['middle'].append(
SnapPoint(point=Point(width * 0.40, self.snap_point_offset * -1)))
snaps['north']['middle'].append(
SnapPoint(point=Point(width * 0.60, self.snap_point_offset * -1)))
# add two more (slight left and slight right) for south-middle)
snaps['south']['middle'].append(
SnapPoint(point=Point(width * 0.40, height +
self.snap_point_offset * 1)))
snaps['south']['middle'].append(
SnapPoint(point=Point(width * 0.60, height +
self.snap_point_offset * 1)))
# add two more (slight up and slight down) for east-middle)
snaps['east']['middle'].append(
SnapPoint(point=Point(width + self.snap_point_offset * 1, height *
0.40)))
snaps['east']['middle'].append(
SnapPoint(point=Point(width + self.snap_point_offset * 1, height *
0.60)))
# add two more (slight up and slight down) for west-middle)
snaps['west']['middle'].append(
SnapPoint(point=Point(self.snap_point_offset * -1, height * 0.40)))
snaps['west']['middle'].append(
SnapPoint(point=Point(self.snap_point_offset * -1, height * 0.60)))
return snaps
def assemble_labels(self):
group_id = '{0}:{1}-pools-labels'.format(self.bpmn_id, self.lane_id)
svg_group = G(id=group_id)
group_width = 0
transformer = TransformBuilder()
for child_pool_class in self.child_pool_classes:
child_label_element = child_pool_class.assemble_labels()
if child_label_element is None:
continue
# the y position of this pool label in the group will be its corresponding swim-pool's y position
child_label_xy = Point(0, child_pool_class.svg_element.xy.y)
transformer.setTranslation(child_label_xy)
child_label_element.svg.set_transform(transformer.getTransform())
svg_group.addElement(child_label_element.svg)
group_width = max(child_label_element.width, group_width)
group_height = self.svg_element.height
# wrap it in a svg element
self.label_element = SvgElement(svg=svg_group,
width=group_width,
height=group_height)
return self.label_element
def assemble_elements(self):
info('assembling lanes for [{0}] DONE'.format(self.bpmn_id))
# wrap it in a svg group
group_id = '{0}-lanes'.format(self.bpmn_id)
svg_group = G(id=group_id)
# height of the lane collection is sum of height of all lanes with gaps between lanes
max_lane_width = self.theme['pad-spec']['left']
current_y = self.theme['pad-spec']['top']
transformer = TransformBuilder()
for child_lane_class in self.child_lane_classes:
swim_lane_element = child_lane_class.assemble_elements()
current_x = self.theme['pad-spec']['left'] + float(child_lane_class.lane_data['styles'].get('move_x', 0))
swim_lane_element.xy = Point(current_x, current_y)
transformer.setTranslation(swim_lane_element.xy)
swim_lane_element.svg.set_transform(transformer.getTransform())
svg_group.addElement(swim_lane_element.svg)
max_lane_width = max(max_lane_width, current_x + swim_lane_element.width)
current_y = current_y + swim_lane_element.height + self.theme['dy-between-lanes']
group_width = self.theme['pad-spec']['left'] + max_lane_width + self.theme['pad-spec']['right']
group_height = current_y - self.theme['dy-between-lanes'] + self.theme['pad-spec']['bottom']
# add the ractangle
lane_collection_rect_svg = Rect(width=group_width, height=group_height)
lane_collection_rect_svg.set_style(StyleBuilder(self.theme['style']).getStyle())
svg_group.addElement(lane_collection_rect_svg)
# wrap it in a svg element
self.svg_element = SvgElement(svg=svg_group, width=group_width, height=group_height)
self.lane_collection.element = self.svg_element
info('assembling lanes for [{0}] DONE'.format(self.bpmn_id))
return self.svg_element
def a_diamond(diagonal_x, diagonal_y, spec):
svg_group = G()
points = [
Point(0, diagonal_y / 2),
Point(diagonal_x / 2, 0),
Point(diagonal_x, diagonal_y / 2),
Point(diagonal_x / 2, diagonal_y),
Point(0, diagonal_y / 2)
]
diamond_svg = Polygon(points=points_to_str(points))
diamond_svg.set_style(StyleBuilder(spec['style']).getStyle())
# add to group
svg_group.addElement(diamond_svg)
return svg_group, diagonal_x, diagonal_y
def an_equilateral_triangle_inside_a_circular_shape(radius, inner_shape_spec):
# in a trangle ABC, A is alwys the top vertex
svg_group = G()
pad = radius * 0.4
center_to_vertex = radius - pad
center_point = Point(radius, radius)
point_a = center_point.to_point(90, center_to_vertex)
point_b = center_point.to_point(210, center_to_vertex)
point_c = center_point.to_point(330, center_to_vertex)
points = [point_a, point_b, point_c, point_a]
triangle_svg = Polygon(points=points_to_str(points))
triangle_svg.set_style(StyleBuilder(inner_shape_spec['style']).getStyle())
# add to group
svg_group.addElement(triangle_svg)
return svg_group, radius * 2, radius * 2
def an_equilateral_pentagon_inside_a_circular_shape(radius, inner_shape_spec):
svg_group = G()
pad = radius * 0.4
center_to_vertex = radius - pad
center_point = Point(radius, radius)
point_a = center_point.to_point(90 - (72 * 0), center_to_vertex)
point_b = center_point.to_point(90 - (72 * 1), center_to_vertex)
point_c = center_point.to_point(90 - (72 * 2), center_to_vertex)
point_d = center_point.to_point(90 - (72 * 3), center_to_vertex)
point_e = center_point.to_point(90 - (72 * 4), center_to_vertex)
points = [point_a, point_b, point_c, point_d, point_e, point_a]
pentagon_svg = Polygon(points=points_to_str(points))
pentagon_svg.set_style(StyleBuilder(inner_shape_spec['style']).getStyle())
# add to group
svg_group.addElement(pentagon_svg)
return svg_group, radius * 2, radius * 2
def a_page(width, height, spec):
rect_svg_group, _, _ = a_rectangle(width=width, height=height, spec=spec)
left_edge = width * 0.1
right_edge = width * 0.1
num_lines = 4
y_gap_between_lines = height / (num_lines + 1)
for line in range(1, num_lines + 1):
y_len = line * y_gap_between_lines
left_point = Point(left_edge, y_len)
right_point = Point(width - right_edge, y_len)
line_svg = Line(x1=left_point.x,
y1=left_point.y,
x2=right_point.x,
y2=right_point.y)
line_svg.set_style(StyleBuilder(spec['style']).getStyle())
rect_svg_group.addElement(line_svg)
return rect_svg_group, width, height
def connect_southward(self, point_from, point_to):
if point_from == point_to:
return [point_from]
# see if there is any channel (vertically or horizontally) between point_from and point_to
channels_vertically_between, channels_horizontally_between = self.channels_blocking_southward(
point_from, point_to)
# first we bypass the channels which are obstructing the path vertically
if len(channels_vertically_between) > 0:
# we bypass the northmost (first) channel
channel_to_bypass = channels_vertically_between[0]
debug('bypassing vertically blocking channel [{0}:{1}]'.format(
channel_to_bypass.number, channel_to_bypass.name))
# self.mark_points([point_from], self.element.svg, 'red')
# self.mark_points([point_to], self.element.svg, 'green')
points_to_bypass_the_channel = channel_to_bypass.bypass_vertically(
coming_from=point_from, going_to=point_to)
# debug('[{0}] -> [{1}] channel [{2}:{3}] bypass points [{4}]'.format(point_from, point_to, channel_to_bypass.number, channel_to_bypass.name, points_to_bypass_the_channel))
# self.mark_points(points_to_bypass_the_channel, self.element.svg, 'blue')
points = [
point_from
] + points_to_bypass_the_channel + self.connect_southward(
points_to_bypass_the_channel[-1], point_to)
# debug('[{0}] -> [{1}] connection points [{2}]'.format(point_from, point_to, points))
return points
# next we handle the channels which are obstructing the path horizontally only when we have no vertical obstruction
elif len(channels_horizontally_between) > 0:
# debug('...horizontally blocking channels')
# for channel in channels_horizontally_between:
# debug('......[{0}]:[{1}]'.format(channel.number, channel.name))
# there may be a number of such obstructing channels, our target is to, find the channel closest to point_to (the last channel)
channel_to_bypass = channels_horizontally_between[-1]
# debug('bypassing [{0}]:[{1}] from {2} towards {3}'.format(channel_to_bypass.number, channel_to_bypass.name, point_to, point_from))
points_to_bypass_the_channel = channel_to_bypass.bypass_vertically(
coming_from=point_to, going_to=point_from)
points_to_bypass_the_channel.reverse()
points = self.connect_southward(
point_from, points_to_bypass_the_channel[0]
) + points_to_bypass_the_channel + [point_to]
return points
else:
# there is no channel in between, we can just return the intersection point
if point_from.x == point_to.x or point_from.y == point_to.y:
return [point_from, point_to]
else:
return [point_from, Point(point_from.x, point_to.y), point_to]
def a_triangular_rewind(width, height, spec):
svg_group = G()
left_arrow_point_left = Point(0, height / 2)
left_arrow_point_top = Point(width / 2, 0)
left_arrow_point_bottom = Point(width / 2, height)
right_arrow_point_left = Point(width / 2, height / 2)
right_arrow_point_top = Point(width, 0)
right_arrow_point_bottom = Point(width, height)
left_arrow_points = [
left_arrow_point_left, left_arrow_point_top, left_arrow_point_bottom
]
right_arrow_points = [
right_arrow_point_left, right_arrow_point_top, right_arrow_point_bottom
]
left_arrow_svg = Polygon(points=points_to_str(left_arrow_points))
left_arrow_svg.set_style(StyleBuilder(spec['style']).getStyle())
right_arrow_svg = Polygon(points=points_to_str(right_arrow_points))
right_arrow_svg.set_style(StyleBuilder(spec['style']).getStyle())
svg_group.addElement(left_arrow_svg)
svg_group.addElement(right_arrow_svg)
return svg_group, width, height
def two_gears_inside_a_circular_shape(radius, inner_shape_spec):
svg_group = G()
gear_radius = radius * 0.7
gear1_svg_group, _, _ = a_gear(radius=gear_radius, spec=inner_shape_spec)
gear2_svg_group, _, _ = a_gear(radius=gear_radius, spec=inner_shape_spec)
# gear1 is towards top left
north_west_point_on_circle = Point(radius, radius).to_point(135, radius)
gear1_center_point = north_west_point_on_circle.to_point(-45, gear_radius)
gear1_svg_group_xy = '{0},{1}'.format(gear1_center_point.x - gear_radius,
gear1_center_point.y - gear_radius)
transformer = TransformBuilder()
transformer.setTranslation(gear1_svg_group_xy)
gear1_svg_group.set_transform(transformer.getTransform())
svg_group.addElement(gear1_svg_group)
# gear2 is towards bottom right
south_east_point_on_circle = Point(radius, radius).to_point(-45, radius)
gear2_center_point = south_east_point_on_circle.to_point(135, gear_radius)
gear2_svg_group_xy = '{0},{1}'.format(gear2_center_point.x - gear_radius,
gear2_center_point.y - gear_radius)
transformer = TransformBuilder()
transformer.setTranslation(gear2_svg_group_xy)
gear2_svg_group.set_transform(transformer.getTransform())
svg_group.addElement(gear2_svg_group)
return svg_group, radius * 2, radius * 2
def a_clock(radius, spec):
clock_group_svg, _, _ = a_circle(radius, spec)
hour_mark_length = radius * 0.3
minute_hand_length = radius * 0.6
hour_hand_length = radius * 0.4
minute_hand_svg = Line(x1=radius,
y1=radius,
x2=radius,
y2=(radius - minute_hand_length))
minute_hand_svg.set_style(StyleBuilder(spec['style']).getStyle())
hour_hand_svg = Line(x1=radius,
y1=radius,
x2=radius + hour_hand_length,
y2=radius)
hour_hand_svg.set_style(StyleBuilder(spec['style']).getStyle())
clock_group_svg.addElement(minute_hand_svg)
clock_group_svg.addElement(hour_hand_svg)
# the hour marks
center_point = Point(radius, radius)
for hour in range(0, 12):
point_on_circle = center_point.to_point(30 * hour, radius)
point_inside = center_point.to_point(30 * hour,
radius - hour_mark_length)
hour_mark_svg = Line(x1=point_on_circle.x,
y1=point_on_circle.y,
x2=point_inside.x,
y2=point_inside.y)
hour_mark_svg.set_style(StyleBuilder(spec['style']).getStyle())
clock_group_svg.addElement(hour_mark_svg)
# add to group
return clock_group_svg, radius * 2, radius * 2
def a_right_arrow(width, height, spec):
arrow_height = height / 3
top_left = Point(0, (height - arrow_height) / 2)
mid_top = Point(width / 2, (height - arrow_height) / 2)
top = Point(width / 2, 0)
right = Point(width, height / 2)
bottom = Point(width / 2, height)
mid_bottom = Point(width / 2, (height + arrow_height) / 2)
bottom_left = Point(0, (height + arrow_height) / 2)
arrow_points = [
top_left, mid_top, top, right, bottom, mid_bottom, bottom_left
]
arrow_svg = Polygon(points=points_to_str(arrow_points))
arrow_svg.set_style(StyleBuilder(spec['style']).getStyle())
return arrow_svg, width, height
def main(argv=None):
pygame.init()
if len(argv) == 0:
sys.exit(1)
data_filename = argv[0]
data = load_sense_data(data_filename)
windowSize = grid.GRID_SIZE * CELL_PIX
window = pygame.display.set_mode((windowSize, windowSize))
board = grid.OccupancyGrid(grid.GRID_SIZE, grid.CELL_SIZE, Point(0, 0))
sonarModel = nao_sonar_model()
send_sense(data, board, window, sonarModel)
#generate_random_board(board)
render_grid(window, board)
pygame.display.flip()
wait_for_exit()
def a_folded_rectangle(width, height, spec):
svg_group = G()
top_left = Point(0, 0)
mid_top = Point(width - spec['fold-length'], 0)
mid_right = Point(width, spec['fold-length'])
bottom_right = Point(width, height)
bottom_left = Point(0, height)
shape1_points = [
top_left, mid_top, mid_right, bottom_right, bottom_left, top_left
]
shape1_svg = Polygon(points=points_to_str(shape1_points))
shape1_svg.set_style(StyleBuilder(spec['style']).getStyle())
mid = Point(width - spec['fold-length'], spec['fold-length'])
shape2_points = [mid_top, mid, mid_right]
shape2_svg = Polygon(points=points_to_str(shape2_points))
shape2_svg.set_style(StyleBuilder(spec['style']).getStyle())
# add to group
svg_group.addElement(shape1_svg)
svg_group.addElement(shape2_svg)
return svg_group, width, height
def a_cross(width, height, x_bar_height, y_bar_width, spec):
svg_group = G()
# make the X inside the group
cross_points = [
Point(0, (height + x_bar_height) / 2),
Point(0, (height - x_bar_height) / 2),
Point((width - y_bar_width) / 2, (height - x_bar_height) / 2),
Point((width - y_bar_width) / 2, 0),
Point((width + y_bar_width) / 2, 0),
Point((width + y_bar_width) / 2, (height - x_bar_height) / 2),
Point(width, (height - x_bar_height) / 2),
Point(width, (height + x_bar_height) / 2),
Point((width + y_bar_width) / 2, (height + x_bar_height) / 2),
Point((width + y_bar_width) / 2, height),
Point((width - y_bar_width) / 2, height),
Point((width - y_bar_width) / 2, (height + x_bar_height) / 2)
]
cross_svg = Polygon(points=points_to_str(cross_points))
cross_svg.set_style(StyleBuilder(spec['style']).getStyle())
# add to group
svg_group.addElement(cross_svg)
return svg_group, width, height
def to_svg(self):
info('......processing node [{0}:{1}:{2}:{3}]'.format(
self.bpmn_id, self.lane_id, self.pool_id, self.node_id))
# the label element
label_group, label_group_width, label_group_height = text_inside_a_rectangle(
text=self.node_data['label'],
min_width=self.theme['rectangle']['min-width'],
max_width=self.theme['rectangle']['max-width'],
rect_spec=self.theme['rectangle'],
text_spec=self.theme['text'])
# the circle element
if 'inner-circle' in self.theme:
circle_group, circle_group_width, circle_group_height = two_concentric_circles(
outer_radius=self.theme['circle']['radius'],
inner_radius=self.theme['inner-circle']['radius'],
outer_circle_spec=self.theme['circle'],
inner_circle_spec=self.theme['inner-circle'])
else:
circle_group, circle_group_width, circle_group_height = a_circle(
radius=self.theme['circle']['radius'],
spec=self.theme['circle'])
# get the inside element
inside_element = self.get_inside_element()
# if an inside element is to be placed inside the circle group, place it so that the inside object's center and the circle's center is same
if inside_element is not None:
inside_group, inside_group_width, inside_group_height = inside_element.svg, inside_element.width, inside_element.height
inside_group_xy = Point(
(circle_group_width - inside_group_width) / 2,
(circle_group_height - inside_group_height) / 2)
transformer = TransformBuilder()
transformer.setTranslation(inside_group_xy)
inside_group.set_transform(transformer.getTransform())
circle_group.addElement(inside_group)
# wrap it in a svg group
svg_group = G(id=self.group_id)
# the circle is vertically below the label, keep a gap of *snap_point_offset*
circle_group_xy = Point((label_group_width - circle_group_width) / 2,
label_group_height + self.snap_point_offset)
transformer = TransformBuilder()
transformer.setTranslation(circle_group_xy)
circle_group.set_transform(transformer.getTransform())
# where the label will be positioned depends on the value of label_pos
if self.label_pos == 'bottom':
label_group_xy = Point(
0, label_group_height + self.snap_point_offset +
circle_group_height + self.snap_point_offset)
transformer = TransformBuilder()
transformer.setTranslation(label_group_xy)
label_group.set_transform(transformer.getTransform())
# place the label and circle
svg_group.addElement(label_group)
svg_group.addElement(circle_group)
# extend the height so that a blank space of the same height as text is at the bottom so that the circle's left edge is at dead vertical center
group_width = label_group_width
group_height = label_group_height + self.snap_point_offset + circle_group_height + self.snap_point_offset + label_group_height
# snap points
snap_points = self.snap_points(group_width, group_height)
self.snap_offset_x = (label_group_width -
circle_group_width) / 2 + self.snap_point_offset
self.snap_offset_y = label_group_height + self.snap_point_offset * 2
# self.draw_snaps(snap_points, svg_group, x_offset=self.snap_offset_x, y_offset=self.snap_offset_y)
info('......processing node [{0}:{1}:{2}:{3}] DONE'.format(
self.bpmn_id, self.lane_id, self.pool_id, self.node_id))
self.svg_element = SvgElement(svg=svg_group,
width=group_width,
height=group_height,
snap_points=snap_points,
label_pos=self.label_pos)
return self.svg_element
def to_svg(self):
info('......processing node [{0}:{1}:{2}:{3}]'.format(
self.bpmn_id, self.lane_id, self.pool_id, self.node_id))
# the label element
label_group, label_group_width, label_group_height = text_inside_a_rectangle(
text=self.node_data['label'],
min_width=self.theme['rectangle']['min-width'],
max_width=self.theme['rectangle']['max-width'],
rect_spec=self.theme['rectangle'],
text_spec=self.theme['text'])
# the folded rectangle
folded_rectangle_group, folded_rectangle_group_width, folded_rectangle_group_height = a_folded_rectangle(
width=self.theme['folded-rectangle']['width'],
height=self.theme['folded-rectangle']['height'],
spec=self.theme['folded-rectangle'])
# top left element inside -------------------------------------------------------
top_left_element = self.get_top_left_element()
# position properly inside the folder rectangle at top left
if top_left_element is not None:
top_left_group, top_left_group_width, top_left_group_height = top_left_element.svg, top_left_element.width, top_left_element.height
top_left_group_xy = Point(
self.theme['folded-rectangle']['pad-spec']['left'],
self.theme['folded-rectangle']['pad-spec']['top'])
transformer = TransformBuilder()
transformer.setTranslation(top_left_group_xy)
top_left_group.set_transform(transformer.getTransform())
folded_rectangle_group.addElement(top_left_group)
# bottom center element inside -------------------------------------------------------
bottom_center_element = self.get_bottom_center_element()
# position properly inside the folder rectangle at bottom center
if bottom_center_element is not None:
bottom_center_group, bottom_center_group_width, bottom_center_group_height = bottom_center_element.svg, bottom_center_element.width, bottom_center_element.height
bottom_center_group_xy = '{0},{1}'.format(
(folded_rectangle_group_width - bottom_center_group_width) / 2,
folded_rectangle_group_height - bottom_center_group_height -
self.theme['folded-rectangle']['pad-spec']['bottom'])
transformer = TransformBuilder()
transformer.setTranslation(bottom_center_group_xy)
bottom_center_group.set_transform(transformer.getTransform())
folded_rectangle_group.addElement(bottom_center_group)
# wrap them in a svg group -----------------------------------------------------------------
svg_group = G(id=self.group_id)
# the folded rectangle is below an empty space of the same height of the label
folded_rectangle_group_xy = Point(
(label_group_width - folded_rectangle_group_width) / 2,
label_group_height + self.snap_point_offset)
transformer = TransformBuilder()
transformer.setTranslation(folded_rectangle_group_xy)
folded_rectangle_group.set_transform(transformer.getTransform())
# where the label will be positioned depends on the value of label_pos
if self.label_pos == 'bottom':
label_group_xy = Point(
0, label_group_height + self.snap_point_offset +
folded_rectangle_group_height + self.snap_point_offset)
transformer = TransformBuilder()
transformer.setTranslation(label_group_xy)
label_group.set_transform(transformer.getTransform())
# place the elements
svg_group.addElement(folded_rectangle_group)
svg_group.addElement(label_group)
# extend the height so that a blank space of the same height as text is at the bottom so that the circle's left edge is at dead vertical center
group_width = label_group_width
group_height = label_group_height + self.snap_point_offset + folded_rectangle_group_height + self.snap_point_offset + label_group_height
# snap points
snap_points = self.snap_points(group_width, group_height)
self.snap_offset_x = (label_group_width - folded_rectangle_group_width
) / 2 + self.snap_point_offset
self.snap_offset_y = label_group_height + self.snap_point_offset * 2
# self.draw_snaps(snap_points, svg_group, x_offset=self.snap_offset_x, y_offset=self.snap_offset_y)
info('......processing node [{0}:{1}:{2}:{3}] DONE'.format(
self.bpmn_id, self.lane_id, self.pool_id, self.node_id))
self.svg_element = SvgElement(svg=svg_group,
width=group_width,
height=group_height,
snap_points=snap_points,
label_pos=self.label_pos)
return self.svg_element
def create_flow(self, from_node, to_node, label, label_style):
from_node_channel, from_node_ordinal = self.channel_collection.channel_and_ordinal(
from_node)
to_node_channel, to_node_ordinal = self.channel_collection.channel_and_ordinal(
to_node)
if self.validate(from_node_channel, to_node_channel, from_node,
to_node) == False:
return None
# first we need the diection from from_node to to_node
if from_node_channel.number < to_node_channel.number:
direction = 'south'
else:
direction = 'north'
# node-positions
if from_node_ordinal == len(from_node_channel.nodes) - 1:
from_node_position = 'east-most'
else:
from_node_position = '*'
if to_node_ordinal == 0:
to_node_position = 'west-most'
else:
to_node_position = '*'
# now we know the rule to chose for snapping and routing for the *from* and *to* node
from_node_spec = self.snap_rules[direction]['from-node'][
from_node_position][from_node.category]
to_node_spec = self.snap_rules[direction]['to-node'][to_node_position][
to_node.category]
from_node_points_in_pool_coordinate = self.channel_collection.points_to_pool_flow_area(
boundary=from_node_spec['cross-through-boundary'],
channel=from_node_channel,
node=from_node,
side=from_node_spec['side'],
position=from_node_spec['position'],
role='from',
approach_snap_point_from=from_node_spec[
'approach-snap-point-from'],
peer=to_node,
edge_type=self.edge_type)
if from_node_points_in_pool_coordinate is None:
warn('could not calculate snap points for from-node [{0}]'.format(
from_node.id))
return None
to_node_points_in_pool_coordinate = self.channel_collection.points_to_pool_flow_area(
boundary=to_node_spec['cross-through-boundary'],
channel=to_node_channel,
node=to_node,
side=to_node_spec['side'],
position=to_node_spec['position'],
role='to',
approach_snap_point_from=to_node_spec['approach-snap-point-from'],
peer=from_node,
edge_type=self.edge_type)
if to_node_points_in_pool_coordinate is None:
warn('could not calculate snap points for to-node [{0}]'.format(
to_node.id))
return None
# we always connect from the north point to the south point
# if the points are vertically close it means that they are inside the same pool-flow-area between same two channels, we just connect them by adjusting the to_point y positions
from_node_end_point = from_node_points_in_pool_coordinate[-1]
to_node_start_point = to_node_points_in_pool_coordinate[0]
# TODO: this 48 is a hack, it shold be the sy-between-channels value
if abs(from_node_end_point.y - to_node_start_point.y) <= 24:
joining_points = [
Point(to_node_start_point.x, from_node_end_point.y)
]
else:
# TODO: the connect_southward is problematic, no
if from_node_points_in_pool_coordinate[-1].north_of(
to_node_points_in_pool_coordinate[0]):
north_point = from_node_points_in_pool_coordinate[-1]
south_point = to_node_points_in_pool_coordinate[0]
joining_points = self.channel_collection.connect_southward(
point_from=north_point, point_to=south_point)
else:
# self.mark_points([from_node_points_in_pool_coordinate[-1]], self.channel_collection.element.svg, 'red')
# self.mark_points([to_node_points_in_pool_coordinate[0]], self.channel_collection.element.svg, 'green')
north_point = to_node_points_in_pool_coordinate[0]
south_point = from_node_points_in_pool_coordinate[-1]
joining_points = self.channel_collection.connect_southward(
point_from=north_point, point_to=south_point)
joining_points.reverse()
# self.mark_points(joining_points, self.channel_collection.element.svg, 'blue')
# self.mark_points(from_node_points_in_pool_coordinate, self.channel_collection.element.svg, 'red')
# self.mark_points(to_node_points_in_pool_coordinate, self.channel_collection.element.svg, 'green')
# we have the points, now create and return the flow
flow_points = from_node_points_in_pool_coordinate + joining_points + to_node_points_in_pool_coordinate
# debug('[{0}] -> [{1}] point outside channel from node: {2}'.format(from_node.id, to_node.id, from_node_points_in_pool_coordinate[-1]))
# debug('[{0}] -> [{1}] point outside channel to node: {2}'.format(from_node.id, to_node.id, to_node_points_in_pool_coordinate[0]))
# debug('[{0}] -> [{1}] joining points : {2}'.format(from_node.id, to_node.id, joining_points))
flow_points = optimize_points(flow_points)
# determine the placement of the label
label_data = None
if label is not None and label != '':
label_data = {}
label_data['text'] = label
# get the first vertical line segment having a min-length
point_from, point_to = first_vertical_line_segment_longer_than(
flow_points, 30)
# the main connecting line for ChannelFlow is a horizontal line
label_data['line-points'] = {'from': point_from, 'to': point_to}
label_data['line-direction'] = 'north-south'
# the text should be placed on top of the line
label_data['placement'] = label_style.get('placement', 'east')
label_data['move-x'] = float(label_style.get('move_x', 0))
label_data['move-y'] = float(label_style.get('move_y', 20))
flow_svg, flow_width, flow_height = a_flow(flow_points, label_data,
self.theme, self.flow_scope)
# debug('[{0}] -> [{1}] : {2}'.format(from_node.id, to_node.id, flow_points))
return SvgElement(svg=flow_svg, width=flow_width, height=flow_height)
def snap_points(self, width, height):
snaps = super().snap_points(width, height)
# add two more (slight left and slight right) for north-middle)
snaps['north']['middle'].append(
SnapPoint(point=Point(width * 0.45, self.snap_point_offset * -1)))
snaps['north']['middle'].append(
SnapPoint(point=Point(width * 0.55, self.snap_point_offset * -1)))
# add two more (slight left and slight right) for south-middle)
snaps['south']['middle'].append(
SnapPoint(point=Point(width * 0.45, height +
self.snap_point_offset * 1)))
snaps['south']['middle'].append(
SnapPoint(point=Point(width * 0.55, height +
self.snap_point_offset * 1)))
# add two more (slight up and slight down) for east-middle)
snaps['east']['middle'].append(
SnapPoint(point=Point(width + self.snap_point_offset * 1, height *
0.40)))
snaps['east']['middle'].append(
SnapPoint(point=Point(width + self.snap_point_offset * 1, height *
0.60)))
# add two more (slight up and slight down) for west-middle)
snaps['west']['middle'].append(
SnapPoint(point=Point(self.snap_point_offset * -1, height * 0.40)))
snaps['west']['middle'].append(
SnapPoint(point=Point(self.snap_point_offset * -1, height * 0.60)))
# activities have snap-points in north-left - one in mid-left and two more (slight left and slight right)
snaps['north']['left'] = [
SnapPoint(point=Point(width * 0.25, self.snap_point_offset * -1))
]
snaps['north']['left'].append(
SnapPoint(point=Point(width * 0.20, self.snap_point_offset * -1)))
snaps['north']['left'].append(
SnapPoint(point=Point(width * 0.30, self.snap_point_offset * -1)))
# activities have snap-points in north-right - one in mid-right and two more (slight left and slight right)
snaps['north']['right'] = [
SnapPoint(point=Point(width * 0.75, self.snap_point_offset * -1))
]
snaps['north']['right'].append(
SnapPoint(point=Point(width * 0.70, self.snap_point_offset * -1)))
snaps['north']['right'].append(
SnapPoint(point=Point(width * 0.80, self.snap_point_offset * -1)))
# activities have snap-points in south-left - one in mid-left and two more (slight left and slight right)
snaps['south']['left'] = [
SnapPoint(point=Point(width * 0.25, height +
self.snap_point_offset * 1))
]
snaps['south']['left'].append(
SnapPoint(point=Point(width * 0.20, height +
self.snap_point_offset * 1)))
snaps['south']['left'].append(
SnapPoint(point=Point(width * 0.30, height +
self.snap_point_offset * 1)))
# activities have snap-points in south-right - one in mid-right and two more (slight left and slight right)
snaps['south']['right'] = [
SnapPoint(point=Point(width * 0.75, height +
self.snap_point_offset * 1))
]
snaps['south']['right'].append(
SnapPoint(point=Point(width * 0.70, height +
self.snap_point_offset * 1)))
snaps['south']['right'].append(
SnapPoint(point=Point(width * 0.80, height +
self.snap_point_offset * 1)))
# activities have snap-points in east-top - one in mid-top and two more (slight up and slight down)
snaps['east']['top'] = [
SnapPoint(point=Point(width + self.snap_point_offset * 1, height *
0.25))
]
snaps['east']['top'].append(
SnapPoint(point=Point(width + self.snap_point_offset * 1, height *
0.15)))
snaps['east']['top'].append(
SnapPoint(point=Point(width + self.snap_point_offset * 1, height *
0.35)))
# activities have snap-points in east-bottom - one in mid-bottom and two more (slight up and slight down)
snaps['east']['bottom'] = [
SnapPoint(point=Point(width + self.snap_point_offset * 1, height *
0.75))
]
snaps['east']['bottom'].append(
SnapPoint(point=Point(width + self.snap_point_offset * 1, height *
0.65)))
snaps['east']['bottom'].append(
SnapPoint(point=Point(width + self.snap_point_offset * 1, height *
0.85)))
# activities have snap-points in west-top - one in mid-top and two more (slight up and slight down)
snaps['west']['top'] = [
SnapPoint(point=Point(self.snap_point_offset * -1, height * 0.25))
]
snaps['west']['top'].append(
SnapPoint(point=Point(self.snap_point_offset * -1, height * 0.15)))
snaps['west']['top'].append(
SnapPoint(point=Point(self.snap_point_offset * -1, height * 0.35)))
# activities have snap-points in west-bottom - one in mid-bottom and two more (slight up and slight down)
snaps['west']['bottom'] = [
SnapPoint(point=Point(self.snap_point_offset * -1, height * 0.75))
]
snaps['west']['bottom'].append(
SnapPoint(point=Point(self.snap_point_offset * -1, height * 0.65)))
snaps['west']['bottom'].append(
SnapPoint(point=Point(self.snap_point_offset * -1, height * 0.85)))
return snaps
def points_to_curved_path(points):
new_points = optimize_points(points)
# first we generate a new set of points for every three points so that if the three points make a turn we have actually 5 points
path = 'M {0}'.format(new_points[0])
# if we have only two points
if len(points) == 2:
path = '{0} L {1}'.format(path, points[1])
return path
default_offset = 5
i = 0
while i < (len(new_points) - 2):
p1, p2, p3 = new_points[i], new_points[i+1], new_points[i+2]
# we know that p1-p2 line is perpendicular to p2-p3 line
if p1.x == p2.x:
# line p1-p2 is vertical, so p2-p3 must be horizontal
if p1.y < p2.y:
# p1 is above p2
# we just add a new point p2a just vertically (q_offset) above p2.
# The default_offset may be greater than the vertical diff betwwen the points p1 and p2, we adjust it
q_offset = min(abs(p2.y - p1.y)/2, default_offset)
p2a = Point(p2.x, p2.y - q_offset)
# The default_offset may be greater than the horizontal diff betwwen the points p2 and p3, we adjust it
q_offset = min(abs(p3.x - p2.x)/2, default_offset)
if p2.x < p3.x:
# p2 is left to p3
# and another new point p2b just horizontally (q_offset) after p2
p2b = Point(p2.x + q_offset, p2.y)
else:
# p2 is right to p3
# and another new point p2b just horizontally (q_offset) before p2
p2b = Point(p2.x - q_offset, p2.y)
else:
# p1 is below p2
# we just add a new point p2a just vertically (q_offset) below p2
# The default_offset may be greater than the vertical diff betwwen the points p1 and p2, we adjust it
q_offset = min((p1.y - p2.y)/2, default_offset)
p2a = Point(p2.x, p2.y + q_offset)
# The default_offset may be greater than the horizontal diff betwwen the points p2 and p3, we adjust it
q_offset = min(abs(p3.x - p2.x)/2, default_offset)
if p2.x < p3.x:
# p2 is left to p3
# and another new point p2b just horizontally (q_offset) after p2
p2b = Point(p2.x + q_offset, p2.y)
else:
# p2 is right to p3
# and another new point p2b just horizontally (q_offset) before p2
p2b = Point(p2.x - q_offset, p2.y)
if p1.y == p2.y:
# line p1-p2 is horizontal, so p2-p3 must be vertical
if p1.x < p2.x:
# p1 is left to p2
# we just add a new point p2a just horizontally (q_offset) before p2
# The default_offset may be greater than the horizontal diff betwwen the points p1 and p2, we adjust it
q_offset = min(abs(p2.x - p1.x)/2, default_offset)
p2a = Point(p2.x - q_offset, p2.y)
# The default_offset may be greater than the vertical diff betwwen the points p2 and p3, we adjust it
q_offset = min(abs(p3.y - p2.y)/2, default_offset)
if p2.y < p3.y:
# p2 is above to p3
# and another new point p2b just vertically (q_offset) after p2
p2b = Point(p2.x, p2.y + q_offset)
else:
# p2 is below p3
# and another new point p2b just vertically (q_offset) before p2
p2b = Point(p2.x, p2.y - q_offset)
else:
# p1 is right to p2
# we just add a new point p2a just horizontally (q_offset) after p2
# The default_offset may be greater than the horizontal diff betwwen the points p1 and p2, we adjust it
q_offset = min(abs(p2.x - p1.x)/2, default_offset)
p2a = Point(p2.x + q_offset, p2.y)
# The default_offset may be greater than the vertical diff betwwen the points p2 and p3, we adjust it
q_offset = min(abs(p3.y - p2.y)/2, default_offset)
if p2.y < p3.y:
# p2 is above p3
# and another new point p2b just vertically (q_offset) after p2
p2b = Point(p2.x, p2.y + q_offset)
else:
# p2 is below p3
# and another new point p2b just vertically (q_offset) before p2
p2b = Point(p2.x, p2.y - q_offset)
# the path is 5 point path with p2 now as the Q point
# path = '{0} L {1} L {2} Q {3} {4} L {5}'.format(path, p1, p2a, p2, p2b, p3)
path = '{0} L {1} Q {2} {3}'.format(path, p2a, p2, p2b)
i = i + 1
path = '{0} L {1}'.format(path, new_points[-1])
return path
def create_svg(self):
info('assembling BPMN [{0}]'.format(self.bpmn_id))
# wrap it in a svg group
svg_group = G(id=self.bpmn_id)
bpmn_width = self.theme['bpmn-rect']['pad-spec'][
'left'] + self.label_element.width + self.body_element.width + self.theme[
'bpmn-rect']['pad-spec']['right']
# get the svg element for the label on top
bpmn_label_svg, label_width, label_height = text_inside_a_rectangle(
text=self.bpmn_data['label'],
min_width=bpmn_width,
max_width=bpmn_width,
rect_spec=self.theme['rectangle'],
text_spec=self.theme['text'],
debug_enabled=False)
bpmn_height = label_height + self.theme['bpmn-rect']['pad-spec'][
'top'] + self.body_element.height + self.theme['bpmn-rect'][
'pad-spec']['bottom']
body_rect_svg = Rect(width=bpmn_width, height=bpmn_height)
body_rect_svg.set_style(
StyleBuilder(self.theme['bpmn-rect']['style']).getStyle())
svg_group.addElement(body_rect_svg)
# assemble bpmn text and bpmn body. text stacked on top of body
# bpmn has a margin, so the outer group needs a transformation
svg_group_xy = Point(self.theme['margin-spec']['left'],
self.theme['margin-spec']['top'])
transformer = TransformBuilder()
transformer.setTranslation(svg_group_xy)
svg_group.set_transform(transformer.getTransform())
if 'hide_labels' in self.bpmn_data['styles'] and self.bpmn_data[
'styles']['hide_labels'] == 'true':
# place the bpmn body group just below the text group right to label
body_element_xy = Point(
self.theme['bpmn-rect']['pad-spec']['left'],
label_height + self.theme['bpmn-rect']['pad-spec']['top'])
transformer = TransformBuilder()
transformer.setTranslation(body_element_xy)
self.body_element.svg.set_transform(transformer.getTransform())
# place the bpmn label
svg_group.addElement(bpmn_label_svg)
svg_group.addElement(self.body_element.svg)
else:
# place the lane-pool label just below the text to the laft
label_element_xy = Point(
self.theme['bpmn-rect']['pad-spec']['left'],
label_height + self.theme['bpmn-rect']['pad-spec']['top'])
transformer = TransformBuilder()
transformer.setTranslation(label_element_xy)
self.label_element.svg.set_transform(transformer.getTransform())
# place the bpmn body group just below the text group right to label
body_element_xy = Point(
self.theme['bpmn-rect']['pad-spec']['left'] +
self.label_element.width,
label_height + self.theme['bpmn-rect']['pad-spec']['top'])
transformer = TransformBuilder()
transformer.setTranslation(body_element_xy)
self.body_element.svg.set_transform(transformer.getTransform())
# place the bpmn label
svg_group.addElement(bpmn_label_svg)
svg_group.addElement(self.label_element.svg)
svg_group.addElement(self.body_element.svg)
# wrap in canvas
canvas_width = self.theme['margin-spec'][
'left'] + bpmn_width + self.theme['margin-spec']['right']
canvas_height = self.theme['margin-spec'][
'top'] + bpmn_height + self.theme['margin-spec']['bottom']
svg = Svg(0, 0, width=canvas_width, height=canvas_height)
svg.addElement(svg_group)
info('assembling BPMN [{0}]'.format(self.bpmn_id))
return svg
def tune_labels(self):
# get the width of the lane label having the maximum width
max_lane_label_width = 0
max_pool_label_width = 0
for lane_group in self.label_element.svg.getAllElements():
# the first child is a rect and the rect element's width is the width of lane-label
lane_label_width = lane_group.getElementAt(0).getAttribute('width')
# print('lane {0} width: {1}'.format(lane_group.getAttribute('id'), lane_label_width))
max_lane_label_width = max(max_lane_label_width, lane_label_width)
# the pool labels are in a group which is the third child
for pool_group in lane_group.getElementAt(2).getAllElements():
# the first child is a rect and the rect element's width is the width of pool-label
pool_label_width = pool_group.getElementAt(0).getAttribute(
'width')
# print('....pool {0} width: {1}'.format(pool_group.getAttribute('id'), pool_label_width))
max_pool_label_width = max(max_pool_label_width,
pool_label_width)
# now we know the max width for lane and pool labels, we adjust them accordingly
for lane_group in self.label_element.svg.getAllElements():
# the first child is a rect and the rect element's width is the width of lane-label
lane_label_width_diff = max_lane_label_width - lane_group.getElementAt(
0).getAttribute('width')
if lane_label_width_diff == 0:
# we do nothing, this is already at the max width
pass
# change the rect's (first child) width
lane_group.getElementAt(0).setAttribute('width',
max_lane_label_width)
# second child is an svg whose width needs to be adjusted by diff
lane_label_svg_width = lane_group.getElementAt(1).getAttribute(
'width')
lane_group.getElementAt(1).setAttribute(
'width', lane_label_svg_width + lane_label_width_diff)
# third child is the pool label group, whose transform's translation's x position needs to be adjusted by diff
transform = lane_group.getElementAt(2).getAttribute('transform')
m = re.match('translate\((?P<x>.+),(?P<y>.+)\)', transform,
re.IGNORECASE)
if m and m.group('x') is not None and m.group('y') is not None:
point = Point(
float(m.group('x')) + lane_label_width_diff,
float(m.group('y')))
lane_group.getElementAt(2).setAttribute(
'transform', 'translate({0})'.format(point))
# the pool labels are in a group which is the third child
for pool_group in lane_group.getElementAt(2).getAllElements():
# the first child is a rect and the rect element's width is the width of pool-label
pool_label_width_diff = max_pool_label_width - pool_group.getElementAt(
0).getAttribute('width')
if pool_label_width_diff == 0:
# we do nothing, this is already at the max width
pass
# change the rect's (first child) width
pool_group.getElementAt(0).setAttribute(
'width', max_pool_label_width)
# second child is an svg whose width needs to be adjusted by diff
pool_label_svg_width = pool_group.getElementAt(1).getAttribute(
'width')
pool_group.getElementAt(1).setAttribute(
'width', pool_label_svg_width + pool_label_width_diff)
def a_path_with_label(points, label_data, spec, flow_scope):
svg_group = G()
path_data = points_to_curved_path(points)
# path_data = points_to_path(points)
# print(path_data)
svg = Path(pathData=path_data)
svg.set_style(StyleBuilder(spec['style'][flow_scope]).getStyle())
if label_data is not None:
# calculate max_width if line_direction is east-west
# print(label_data)
if label_data['line-direction'] == 'east-west':
max_width = abs(label_data['line-points']['to'].x -
label_data['line-points']['from'].x)
else:
max_width = spec['label']['rectangle']['max-width']
label_group, label_group_width, label_group_height = text_inside_a_rectangle(
text=label_data['text'],
min_width=min(spec['label']['rectangle']['min-width'], max_width),
max_width=max_width,
rect_spec=spec['label']['rectangle'],
text_spec=spec['label']['text'])
# for east-west (horizontal label line)
if label_data['line-direction'] == 'east-west':
if label_data['line-points']['to'].east_of(
label_data['line-points']['from']):
label_pos_x = label_data['line-points']['from'].x + label_data[
'move-x']
else:
label_pos_x = label_data['line-points'][
'from'].x - label_group_width + label_data['move-x']
if label_data['placement'] == 'north':
label_pos_y = min(label_data['line-points']['from'].y,
label_data['line-points']['to'].y
) - label_group_height + label_data['move-y']
else:
label_pos_y = min(
label_data['line-points']['from'].y,
label_data['line-points']['to'].y) + label_data['move-y']
# for north-south (vertical label line)
else:
# label should be nearer to the from point
if label_data['line-points']['to'].north_of(
label_data['line-points']['from']):
label_pos_y = label_data['line-points'][
'from'].y - label_group_height - label_data['move-y']
else:
label_pos_y = label_data['line-points']['from'].y + label_data[
'move-y']
if label_data['placement'] == 'east':
label_pos_x = min(
label_data['line-points']['from'].x,
label_data['line-points']['to'].x) + label_data['move-x']
else:
label_pos_x = min(label_data['line-points']['from'].x,
label_data['line-points']['to'].x
) - label_group_width + label_data['move-x']
# print('x: {} y: {} w: {} h: {}'.format(label_pos_x, label_pos_y, label_group_width, label_group_height))
# add label to group
label_pos_xy = Point(label_pos_x, label_pos_y)
transformer = TransformBuilder()
transformer.setTranslation(label_pos_xy)
label_group.set_transform(transformer.getTransform())
svg_group.addElement(label_group)
# add flow to group
svg_group.addElement(svg)
return svg_group, 0, 0
def bypass_vertically(self, coming_from, going_to, margin_spec):
# the coming_from point is north of going_to, so we have to reach a point south of the lane either through east or west or directly dpending on which direction we are going_to
if coming_from.north_of(going_to):
# if the coming_from point is already below the lane, we have no point
if coming_from.y >= self.element.xy.y + self.element.height + margin_spec[
'bottom']:
return []
# if the coming_from point's x position is outside the lane, we can directly go south
elif (self.element.xy.x -
margin_spec['left']) >= coming_from.x or coming_from.x >= (
self.element.xy.x + self.element.width +
margin_spec['right']):
return [
Point(
coming_from.x, self.element.xy.y +
self.element.height + margin_spec['bottom'])
]
# if the coming_from point is properly above the lane, we make a path
else:
# to the lane north vertically below coming_from
p1 = Point(coming_from.x,
self.element.xy.y - margin_spec['top'])
if going_to.east_of(coming_from):
# to the lane north-east
p2 = Point(
self.element.xy.x + self.element.width +
margin_spec['right'], p1.y)
# debug('southward from: {0} to {1} new {2}'.format(point_from, point_to, new_target_point))
else:
# to the lane north-west
p2 = Point(self.element.xy.x - margin_spec['left'], p1.y)
# debug('northward from: {0} to {1} new {2}'.format(point_from, point_to, new_target_point))
# to the lane south vertically below p2
p3 = Point(
p2.x, self.element.xy.y + self.element.height +
margin_spec['bottom'])
# the coming_from point is south of lane, so we have to reach a point north of the lane either through east or west dpending on which direction we are going_to
else:
# if the coming_from point is already above the pool, we have no point
if coming_from.y <= self.element.xy.y - margin_spec['top']:
return []
# if the coming_from point's x position is outside the lane, we can directly go north
elif (self.element.xy.x -
margin_spec['left']) >= coming_from.x or coming_from.x >= (
self.element.xy.x + self.element.width +
margin_spec['right']):
return [
Point(coming_from.x,
self.element.xy.y - margin_spec['top'])
]
# if the coming_from point is properly below the lane, we make a path
else:
# to the lane south vertically above coming_from
p1 = Point(
coming_from.x, self.element.xy.y + self.element.height +
margin_spec['bottom'])
if going_to.east_of(coming_from):
# to the lane south-east
p2 = Point(
self.element.xy.x + self.element.width +
margin_spec['right'], p1.y)
# debug('southward from: {0} to {1} new {2}'.format(point_from, point_to, new_target_point))
else:
# to the lane south-west
p2 = Point(self.element.xy.x - margin_spec['left'], p1.y)
# debug('northward from: {0} to {1} new {2}'.format(point_from, point_to, new_target_point))
# to the lane north vertically above p2
p3 = Point(p2.x, self.element.xy.y - margin_spec['top'])
return [p1, p2, p3]
def outside_the_lane(self, lane_boundary, pool_boundary, pool_number,
channel_boundary, channel, node, side, position, role,
approach_snap_point_from, peer, edge_type,
lane_margin_spec):
# first get outside the lane
points_in_lane_coordinate = self.outside_the_pool(
pool_boundary, pool_number, channel_boundary, channel, node, side,
position, role, approach_snap_point_from, peer, edge_type)
# now get outside the lane (pool_collection) - to do so we we either go south or north depending on lane_boundary
last_pool_number = len(self.channel_collection_list) - 1
if lane_boundary == 'south':
# we have to get to the southern boundary of the lane
if role == 'from':
the_point = Point(
points_in_lane_coordinate[-1].x,
self.element.height + lane_margin_spec['bottom'])
the_points = self.connect_southward(
pool_number, points_in_lane_coordinate[-1],
last_pool_number, the_point)
else:
the_point = Point(
points_in_lane_coordinate[0].x,
self.element.height + lane_margin_spec['bottom'])
the_points = self.connect_southward(
pool_number, points_in_lane_coordinate[0],
last_pool_number, the_point)
elif lane_boundary == 'north':
# we have to get to the northern boundary of the lane
if role == 'from':
the_point = Point(points_in_lane_coordinate[-1].x,
-lane_margin_spec['top'])
the_points = self.connect_southward(
0, points_in_lane_coordinate[-1], pool_number, the_point)
else:
the_point = Point(points_in_lane_coordinate[0].x,
-lane_margin_spec['top'])
the_points = self.connect_southward(
0, points_in_lane_coordinate[0], pool_number, the_point)
elif lane_boundary == 'west':
# we have to get to the western boundary of the lane
if role == 'from':
the_points = [
Point(-lane_margin_spec['left'],
points_in_lane_coordinate[-1].y)
]
# the_points = self.connect_southward(points_in_lane_coordinate[-1], the_point)
else:
the_points = [
Point(-lane_margin_spec['left'],
points_in_lane_coordinate[0].y)
]
# the_points = self.connect_southward(points_in_lane_coordinate[0], the_point)
elif lane_boundary == 'east':
# we have to get to the eastern boundary of the lane
if role == 'from':
the_points = [
Point(self.element.width + lane_margin_spec['right'],
points_in_lane_coordinate[-1].y)
]
# the_points = self.connect_southward(points_in_lane_coordinate[-1], the_point)
else:
the_points = [
Point(self.element.width + lane_margin_spec['right'],
points_in_lane_coordinate[0].y)
]
# the_points = self.connect_southward(points_in_lane_coordinate[0], the_point)
else:
# should never happen
warn('lane boundary is unknown')
return points_in_lane_coordinate
# debug('{0} outside point for pool [{1}] xy: {2} ({3} x {4}) is at {5}'.format(pool_boundary, self.pool_id, self.element.xy, self.element.width, self.element.height, the_point))
if role == 'to':
return the_points + points_in_lane_coordinate
else:
return points_in_lane_coordinate + the_points