added optional text to firings

Author: MarcG-TUE

package/cmtrace/cmtrace/dataflow/actor.py

@@ -4,28 +4,28 @@
 
 class Actor:
  """Represents an actor in a dataflow graph"""
- def __init__(self, name, actdelay, scenario=None):
+ def __init__(self, name, act_delay, scenario=None):
  self.name = name
- self.delay = actdelay
- self.inputs = dict()
+ self.delay = act_delay
+ self.inputs = {}
  self.primary_inputs = []
- self.state_inputs = dict()
+ self.state_inputs = {}
  self.firings = []
  self.scenario = scenario
 
- def add_channel_input(self, actor, initial_tokens=0, arcdelay=0, initial_time=MP_MINUS_INF):
+ def add_channel_input(self, actor, initial_tokens=0, arc_delay=0, initial_time=MP_MINUS_INF):
  """add a channel input dependency to another actor, including
- a time-offset arcdelay"""
- self.inputs[actor.name] = (actor, initial_tokens, arcdelay, initial_time)
+ a time-offset arc_delay"""
+ self.inputs[actor.name] = (actor, initial_tokens, arc_delay, initial_time)
 
- def add_state_input(self, state, tokendelay=0, arcdelay=0):
+ def add_state_input(self, state, token_delay=0, arc_delay=0):
  """Add a dependency on a state token for an SADF graph"""
- self.state_inputs[state.name] = (state, tokendelay, arcdelay)
+ self.state_inputs[state.name] = (state, token_delay, arc_delay)
  return
 
- def add_primary_input(self, priminput):
+ def add_primary_input(self, prim_input):
  """Add dependency to a primary input to the graph."""
- self.primary_inputs.append(priminput)
+ self.primary_inputs.append(prim_input)
 
  def completions(self):
  """returns the current completion times of the actor"""
@@ -37,13 +37,13 @@ def firing_intervals(self):
  return [(f, f+self.delay) for f in self.firings]
 
  def update_firings(self):
- """Recomput the firings of the actor based on its input dependencies.
+ """Recompute the firings of the actor based on its input dependencies.
  Returns a boolean indicating if the computed firings remained the same."""
- oldfirings = len(self.firings)
+ old_firings = len(self.firings)
  traces = []
  # collect all the incoming channels
- for i, (act, tok, arcdel, tokinit) in self.inputs.items():
- traces.append(output_sequence(act.completions(), tok, arcdel, tokinit))
+ for i, (act, tok, arc_del, tok_init) in self.inputs.items():
+ traces.append(output_sequence(act.completions(), tok, arc_del, tok_init))
  # collect traces for all primary inputs
  for i in self.primary_inputs:
  traces.append(i)
@@ -52,7 +52,7 @@ def update_firings(self):
 
  # determine the firings
  self.firings = mp_max(*traces)
- return oldfirings == len(self.firings)
+ return old_firings == len(self.firings)
 
  def set_scenario(self, scenario):
  """set the scenario in which the actor is active"""

package/cmtrace/cmtrace/graphics/svgcanvas.py

@@ -4,7 +4,7 @@
 from cmtrace.latexsvg.latexsvg import latex_to_svg
 
 # conversion constants
-MMPERPT = 0.352778
+MM_PER_PT = 0.352778
 
 # default font size
 DEFAULT_FONT_SIZE = 10
@@ -72,22 +72,22 @@ def draw_text(self, text, insert, fill=(0, 0, 0), font_size=None,
  font_size=the_font_size, font_family=font, text_anchor=text_anchor, \
  alignment_baseline="auto"))
 
- def draw_rect(self, insert, size, fillcolor=(0, 0, 0), stroke_width=MMPERPT, \
+ def draw_rect(self, insert, size, fillcolor=(0, 0, 0), stroke_width=MM_PER_PT, \
  stroke_color=(0, 0, 0)):
  """ draw a rectangle """
  # add rectangle to the drawing
  self.drawing.add(self.drawing.rect(insert=(insert[0], insert[1]), size=(size[0], size[1]), \
  fill=svgwrite.rgb(*fillcolor), stroke_width=stroke_width, \
  stroke=svgwrite.rgb(*stroke_color)))
 
- def draw_line(self, start, end, stroke_width=MMPERPT, stroke_color=(0, 0, 0)):
+ def draw_line(self, start, end, stroke_width=MM_PER_PT, stroke_color=(0, 0, 0)):
  """
  draw a line from start (x1, y1) to end (x2, y2), using stroke_width
  """
  self.drawing.add(self.drawing.line(start=(start[0], start[1]), end=(end[0], end[1]), \
  stroke_width=stroke_width, stroke=svgwrite.rgb(*stroke_color)))
 
- def draw_path(self, path_spec, stroke_width=MMPERPT, stroke_color=(0, 0, 0), is_arrow=False, \
+ def draw_path(self, path_spec, stroke_width=MM_PER_PT, stroke_color=(0, 0, 0), is_arrow=False, \
  fill='none', offset_pre=None, offset_post=None,
  scale=None):
  """ add a path to the drawing, optionally apply offset and scale and optionally make
@@ -117,7 +117,7 @@ def draw_path(self, path_spec, stroke_width=MMPERPT, stroke_color=(0, 0, 0), is_
  if is_arrow:
  path.set_markers((None, None, self.arrow_marker))
 
- def draw_circle(self, insert, radius, fillcolor=(0, 0, 0), stroke_width=MMPERPT,
+ def draw_circle(self, insert, radius, fillcolor=(0, 0, 0), stroke_width=MM_PER_PT,
  stroke_color=(0, 0, 0)):
  """ draw a circle """
  self.drawing.add(self.drawing.circle(center=(insert[0], insert[1]), r=radius, \

package/cmtrace/cmtrace/graphics/svggraphics.py

@@ -3,7 +3,7 @@
 import os
 from functools import reduce
 from sys import modules as sysmodules
-from cmtrace.graphics.svgcanvas import SVGCanvas, MMPERPT
+from cmtrace.graphics.svgcanvas import SVGCanvas, MM_PER_PT
 from cmtrace.graphics.tracesettings import TraceSettings
 if 'cairosvg' in sysmodules:
  import cairosvg
@@ -25,7 +25,7 @@ def alternate_color(self, col):
  """ modify the color to be used for alternating colors """
  return (col[0] * 0.9, col[1] * 0.9, col[2] * 0.9)
 
- def draw_firings(self, firing_intervals, lb, ub):
+ def draw_firings(self, firing_intervals, lb, _ub):
  """ draw firings in figure; firings are tuple (start, end, actor name, scenario name)"""
  # sort the firings on start time
  firing_intervals.sort()
@@ -55,7 +55,7 @@ def draw_firings(self, firing_intervals, lb, ub):
  if coloring_mode == "by-actor":
  f_color = color_map[firing[2]]
  elif coloring_mode == "by-iteration":
- f_color = color_palette[firing[4] % len(color_palette)]
+ f_color = color_palette[firing[5] % len(color_palette)]
  elif coloring_mode == "by-scenario":
  f_color = color_map[firing[3]]
  if self.settings.alternate_color():
@@ -84,10 +84,20 @@ def draw_firings(self, firing_intervals, lb, ub):
  self.settings.scale_mm_per_unit_x(), self.settings.origin_y() \
  +(lb+self.settings.overlap_offset()*active_offset)* \
  self.settings.scale_mm_per_unit_y()
- bottom_right = self.settings.scale_mm_per_unit_x()*(f_duration), \
+ width_height = self.settings.scale_mm_per_unit_x()*(f_duration), \
  self.settings.scale_mm_per_unit_y()
- self.canvas.draw_rect(top_left, bottom_right, f_color,
+ self.canvas.draw_rect(top_left, width_height, f_color,
  stroke_width=self.settings.firing_stroke_width())
+ if firing[4] is not None:
+ self.canvas.draw_text(
+ firing[4],
+ (top_left[0]+width_height[0]/2, top_left[1]+width_height[1]/2),
+ font=self.settings.font(),
+ font_size=0.5*self.settings.font_size(),
+ text_anchor="middle",
+ alignment_baseline="central"
+ )
+
  f_count += 1
  last_end = f_start+f_duration
 
@@ -117,21 +127,21 @@ def draw_traces(self, actors, num_arrivals, trace_heights):
  mix = num_arrivals
  for (label, actor_list) in actors:
  self.draw_label(label, 0.5*(lb[mix]+ub[mix]))
- scaled_firings = list()
+ scaled_firings = []
  for actor in actor_list:
  if not actor is None:
  fix = 0
  for firing in actor.firing_intervals():
  scaled_firings.append([firing[0]/unit, firing[1]/unit,
- actor.name, actor.scenario, actor.text, fix])
+ actor.name, actor.scenario, firing[3], fix])
  fix += 1
  self.draw_firings(scaled_firings, lb[mix], ub[mix])
  mix += 1
 
  def draw_arrivals(self, arrivals, offset):
  """ draw the arrival event sequences """
- coloring_mode = self.settings.vector_color_mode()
- color_index = self.settings.color_map()
+ # coloring_mode = self.settings.vector_color_mode()
+ # color_index = self.settings.color_map()
  nix = offset
  for label in arrivals.keys():
  # draw the label
@@ -196,7 +206,7 @@ def draw_sequences(self, sequences):
  # draw the label
  lx = self.settings.origin_x() - self.settings.label_separation()
  ly = self.settings.origin_y()+(nix+0.5)*self.settings.scale_mm_per_unit_y() + \
- 3.0*MMPERPT
+ 3.0*MM_PER_PT
  self.canvas.draw_text(
  label,
  (lx, ly),
@@ -414,8 +424,8 @@ def save_gantt(self, actors, arrivals, outputs, filename='trace.svg'):
  canvas = self.make_gantt_svg(actors, arrivals, outputs, filename)
  canvas.save()
 
- def __make_vector_svg(self, event_seqs, filename='trace.svg', height_in_mm=200,
- width_in_mm=300):
+ def __make_vector_svg(self, event_seqs, filename='trace.svg', _height_in_mm=200,
+ _width_in_mm=300):
  """ make a graph in svg of the event sequences and save to file """
 
  # determine settings

package/cmtrace/example/trace.xml

@@ -1,16 +1,16 @@
 <?xml version="1.0"?>
 <trace>
  <firings>
- <firing id="0" start="0" end="2" actor="B" scenario="a" iteration="0"/>
+ <firing id="0" start="0" end="2" actor="B" scenario="a" text= "B0" iteration="0"/>
  <firing id="1" start="0" end="2" actor="C" scenario="a" iteration="0"/>
  <firing id="2" start="2" end="3" actor="A" scenario="a" iteration="0"/>
- <firing id="3" start="3" end="6" actor="B" scenario="b" iteration="1"/>
+ <firing id="3" start="3" end="6" actor="B" scenario="b" iteration="1" text= "B1"/>
  <firing id="4" start="2" end="3" actor="C" scenario="b" iteration="1"/>
  <firing id="5" start="3" end="4" actor="A" scenario="b" iteration="1"/>
- <firing id="6" start="4" end="7" actor="B" scenario="b" iteration="2"/>
+ <firing id="6" start="4" end="7" actor="B" scenario="b" iteration="2" text= "B2"/>
  <firing id="7" start="6" end="7" actor="C" scenario="b" iteration="2"/>
  <firing id="8" start="7" end="8" actor="A" scenario="b" iteration="2"/>
- <firing id="9" start="8" end="10" actor="B" scenario="a" iteration="3"/>
+ <firing id="9" start="8" end="10" actor="B" scenario="a" iteration="3" text= "B3"/>
  <firing id="10" start="7" end="9" actor="C" scenario="a" iteration="3"/>
  <firing id="11" start="9" end="10" actor="A" scenario="a" iteration="3"/>
  </firings>