taskjuggler 0.0.7 → 0.0.8

data/lib/reports/GanttChart.rb

@@ -198,9 +198,9 @@ class TaskJuggler
     end
 
     # This is a noop function.
-    def to_csv
+    def to_csv(csv, startColumn)
       # Can't put a Gantt chart into a CSV file.
-      ''
+      0
     end
 
     # Utility function that convers a date to the corresponding X-position in
@@ -240,16 +240,30 @@ class TaskJuggler
         @height = line.y + line.height if line.y + line.height > @height
       end
 
+      # To layout the dependency lines, we use a GanttRouter. We only provide
+      # the start and end coordinates of each line and it will do the layout
+      # and routing.
       @router = GanttRouter.new(@width, @height)
 
+      # We don't want horizontal lines to cross the task bars. So we block
+      # these chart zones. Milestones should not be crossed in any direction.
       @lines.each do |line|
         line.addBlockedZones(@router)
       end
 
+      # Also protect the current date line from other vertical lines.
       @router.addZone(@header.nowLineX - 1, 0, 3, @height - 1, false, true)
 
+      # Generate the dependency arrows for all visible tasks.
       @tasks.each do |task, lines|
-        generateDepArrows(task, lines)
+        generateDepLines(task, lines)
+      end
+
+      # Make sure we have exactly one arrow head for each line end point even
+      # if the point is used by multiple lines.
+      @depArrows.each do |line|
+        endPoint = line.last
+        @arrowHeads << endPoint unless @arrowHeads.include?(endPoint)
       end
     end
 
@@ -257,18 +271,18 @@ class TaskJuggler
     # for a specific _task_. _lines_ is a list of GanttLines that the tasks are
     # displayed on. Reports with multiple scenarios have multiple lines per
     # task.
-    def generateDepArrows(task, lines)
+    def generateDepLines(task, lines)
       # Since we need the line and the index we use an index iterator.
       lines.length.times do |lineIndex|
         line = lines[lineIndex]
         scenarioIdx = line.query.scenarioIdx
 
         # Generate the dependencies on the start of the task.
-        collectAndSortArrows('startsuccs', task, scenarioIdx, lineIndex,
+        generateTaskDepLines('startsuccs', task, scenarioIdx, lineIndex,
                              *line.getTask.startDepLineStart)
 
         # Generate the dependencies on the end of the task.
-        collectAndSortArrows('endsuccs', task, scenarioIdx, lineIndex,
+        generateTaskDepLines('endsuccs', task, scenarioIdx, lineIndex,
                              *line.getTask.endDepLineStart)
       end
     end
@@ -278,11 +292,9 @@ class TaskJuggler
     # and _startY_ are the graphic coordinates for the begin of the arrow
     # line. _task_ references the Task in question and _scenarioIdx_ the
     # scenario. _lineIndex_ specifies the line number in the chart.
-    def collectAndSortArrows(kind, task, scenarioIdx, lineIndex, startX, startY)
-      # We need to sort the arrows. This is an Array that holds 6 values for
-      # each entry: The x and y coordinates for start and end points, the
-      # sinus value of the angle between a vertical and the line specified by
-      # the points and the length of the line.
+    def generateTaskDepLines(kind, task, scenarioIdx, lineIndex, startX, startY)
+      # This is an Array that holds 4 values for
+      # each entry: The x and y coordinates for start and end points.
       touples = []
       task[kind, scenarioIdx].each do |t, onEnd|
         # Skip inherited dependencies and tasks that are not included in the
@@ -294,37 +306,9 @@ class TaskJuggler
         end
         endX, endY = @tasks[t][lineIndex].getTask.send(
           onEnd ? :endDepLineEnd : :startDepLineEnd)
-        # To make sure that we minimize the crossings of arrows that
-        # originate from the same position, we sort the arrows by the
-        # smallest angle between the vertical line through the task end
-        # and the line between the start and end of the arrow.
-        oppLeg = endX - startX
-        adjLeg = (startY - endY).abs
-        hypothenuse = Math.sqrt(adjLeg ** 2 + oppLeg ** 2)
-        # We can now calculate the sinus values of the angle between the
-        # vertical and a line through the coordinates.
-        touples << [ startX, startY, endX, endY,
-                     (oppLeg / hypothenuse), hypothenuse ]
-      end
-      # We sort the arrows from small to a large angle. In case the angle is
-      # identical, we use the length of the line as second criteria.
-      touples.sort! { |t1, t2| t1[4] == t2[4] ? t1[5] <=> t2[5] :
-                                                t1[4] <=> t2[4] }
-      touples.each do |t|
-        routeArrow(*t[0, 4])
-      end
-    end
-
-    # Route the dependency lines from the start to the end point.
-    def routeArrow(startX, startY, endX, endY)
-      @depArrows << @router.route([startX, startY], [endX, endY])
-
-      # It's enough to have only a single arrow drawn at the end point even if
-      # it's the destination of multiple lines.
-      @arrowHeads.each do |x, y|
-        return if x == endX && y == endY
+        touples << [ startX, startY, endX, endY ]
       end
-      @arrowHeads << [ endX, endY ]
+      @depArrows += @router.routeLines(touples) unless touples.empty?()
     end
 
   end

data/lib/reports/GanttRouter.rb

@@ -10,6 +10,8 @@
 # published by the Free Software Foundation.
 #
 
+require 'reports/CollisionDetector'
+
 class TaskJuggler
 
   # The GanttRouter is used by the GanttChart to route the dependency lines from
@@ -17,11 +19,15 @@ class TaskJuggler
   # width and height. The graphical elements of the Gantt chart can be
   # registered as don't-cross-zones. These zones block the either horizontal or
   # vertical lines (or both) from crossing the zone. Zones can be registered by
-  # calling addZone(). The route() method returns routed path from start to end
-  # point.
+  # calling addZone(). The route() method returns routed path from
+  # start to end point.
   class GanttRouter
 
-    include HTMLGraphics
+    # Minimum distance between the starting point and the first turning point.
+    MinStartGap = 5
+    # Minimum distance between the last turning point and the tip of the
+    # arrow.
+    MinEndGap = 10
 
     # Create a GanttRouter object. _width_ and _height_ describe the size of the
     # rectangular area this router is operating on.
@@ -29,77 +35,86 @@ class TaskJuggler
       @width = width.to_i
       @height = height.to_i
 
-      # The zones are stored as Arrays of line segments. Horizontal blocks are
-      # stored separately from vertical blocks. Blocked segments for a
-      # particular x coordinate are stored in @vLines, for y coordinates in
-      # @hLines. Each entry is an Array of [ start, end ] values that describe
-      # the blocked segments of that particular line. Start and end point are
-      # part of the segment. A listed segment will not be overwritten during
-      # routing.
-      @hLines = Array.new(@height) { |i| i = [] }
-      @vLines = Array.new(@width) { |i| i = [] }
+      @detector = CollisionDetector.new(@width, @height)
     end
 
-    # This function registers an area as don't-cross-zone. The rectangular zone
-    # is described by _x_, _y_, _w_ and _h_. If _horiz_ is true, the zone will
-    # be blocked for horizontal lines, if _vert_ is true the zone will be
-    # blocked for vertical lines.
     def addZone(x, y, w, h, horiz, vert)
-      # Clip the input rectangle to fit within the handled area of this router.
-      x = clip(x.to_i, @width - 1)
-      y = clip(y.to_i, @height - 1)
-      w = clip(w.to_i, @width - x)
-      h = clip(h.to_i, @height - y)
+      @detector.addBlockedZone(x, y, w, h, horiz, vert)
+    end
 
-      # We can ignore empty zones.
-      return if w == 0 || h == 0
+    def routeLines(fromToPoints)
+      # We first convert the fromToPoints list into a more readable list of
+      # Hash objects.
+      routes = []
+      fromToPoints.each do |touple|
+        routes << {
+          :startX => touple[0],
+          :startY => touple[1],
+          :endX => touple[2],
+          :endY => touple[3],
+          :id => touple[4]
+        }
+      end
 
-      # Break the rectangle into line segments and add them to the appropriate
-      # line Arrays.
-      if horiz
-        y.upto(y + h - 1) do |i|
-          addSegment(@hLines[i], [ x, x + w - 1 ])
-        end
+      # To make sure that we minimize the crossings of arrows that
+      # originate from the same position, we sort the arrows by the
+      # smallest angle between the vertical line through the task end
+      # and the line between the start and end of the arrow.
+      routes.each do |r|
+        adjLeg = (r[:endX] - MinEndGap) - (r[:startX] + MinStartGap)
+        oppLeg = (r[:startY] - r[:endY]).abs
+        r[:distance] = Math.sqrt(adjLeg ** 2 + oppLeg ** 2)
+        # We can now calculate the sinus values of the angle between the
+        # vertical and a line through the coordinates.
+        sinus = oppLeg.abs / r[:distance]
+        r[:angle] = (adjLeg < 0 ? Math::PI / 2 + Math.asin(Math::PI/2 - sinus) :
+                                  Math.asin(sinus)) / (Math::PI / (2 * 90))
       end
-      if vert
-        x.upto(x + w - 1) do |i|
-          addSegment(@vLines[i], [ y, y + h - 1 ])
-        end
+      # We sort the arrows from small to a large angle. In case the angle is
+      # identical, we use the length of the line as second criteria.
+      routes.sort! { |r1, r2| (r1[:angle] / 5).to_i == (r2[:angle] / 5).to_i ?
+                              -(r1[:distance] <=> r2[:distance]) :
+                              -(r1[:angle] <=> r2[:angle]) }
+
+      # Now that the routes are in proper order, we can actually lay the
+      # routes.
+      routePoints = []
+      routes.each do |r|
+        routePoints << route(r[:startX], r[:startY], r[:endX], r[:endY])
       end
+      routePoints
     end
 
     # Find a non-blocked route from the _startPoint_ [ x, y ] to the
     # _endPoint_ [ x, y ]. The route always starts from the start point towards
     # the right side of the chart and reaches the end point from the left side
     # of the chart. All lines are always strictly horizontal or vertical. There
-    # are no diagonal lines.
-    def route(startPoint, endPoint)
-      points = [ startPoint ]
-      # Minimum distance between the starting point and the first turning point.
-      startGap = 5
-      # Minimum distance between the last turning point and the tip of the
-      # arrow.
-      endGap = 10
-
-      if endPoint[0] - startPoint[0] > startGap + endGap + 2
+    # are no diagonal lines. The result is an Array of [ x, y ] points that
+    # include the _startPoint_ as first and _endPoint_ as last element.
+    def route(startX, startY, endX, endY)
+      points = [ [ startX, startY ] ]
+      startGap = MinStartGap
+      endGap = MinEndGap
+
+      if endX - startX > startGap + endGap + 2
         # If the horizontal distance between start and end point is large enough
         # we can try a direct route.
         #
-        #                     xSeg
-        #            |startGap|
-        # startPoint X--------1
-        #                     |
-        #                     |
-        #                     2------X end Point
-        #                     |endGap|
+        #                       xSeg
+        #              |startGap|
+        # startX/endX  X--------1
+        #                       |
+        #                       |
+        #                       2------X endX/endY
+        #                       |endGap|
         #
-        xSeg = placeLine([ startPoint[1] + (startPoint[1] < endPoint[1] ?
-                                            1 : -1), endPoint[1] ],
-                         false, startPoint[0] + startGap, 1)
-        if xSeg && xSeg < endPoint[0] - endGap
-          addLineTo(points, xSeg, startPoint[1])  # Point 1
-          addLineTo(points, xSeg, endPoint[1])    # Point 2
-          addLineTo(points, *endPoint)
+        xSeg = placeLine([ startY + (startY < endY ?  1 : -1), endY ],
+                         false, startX + startGap, 1)
+        if xSeg && xSeg < endX - endGap
+          # The simple version works. Add the lines.
+          addLineTo(points, xSeg, startY)  # Point 1
+          addLineTo(points, xSeg, endY)    # Point 2
+          addLineTo(points, endX, endY)
           return points
         end
       end
@@ -107,40 +122,39 @@ class TaskJuggler
       # If the simple approach above fails, the try a more complex routing
       # strategy.
       #
-      #                     x1
-      #            |startGap|
-      # startPoint X--------1 yLS
-      #                     |
-      #     3---------------2 ySeg
-      #     |
-      #     4------X endPoint
-      #     |endGap|
-      #     x2
+      #                         x1
+      #                |startGap|
+      # startX/startY  X--------1 yLS
+      #                         |
+      #         3---------------2 ySeg
+      #         |
+      #         4------X endX/endY
+      #         |endGap|
+      #         x2
 
       # Place horizontal segue. We don't know the width yet, so we have to
       # assume full width. That's acceptable for horizontal lines.
-      ySeg = placeLine([ 0, @width - 1 ], true, startPoint[1],
-                        startPoint[1] < endPoint[1] ? 1 : -1)
+      deltaY = startY < endY ? 1 : -1
+      ySeg = placeLine([ 0, @width - 1 ], true, startY + 2 * deltaY, deltaY)
       raise "Routing failed" unless ySeg
 
       # Place 1st vertical
-      x1 = placeLine([ startPoint[1] + (startPoint[1] < endPoint[1] ? 1 : -1),
-                       ySeg ], false, startPoint[0] + startGap, 1)
+      x1 = placeLine([ startY + deltaY, ySeg ], false, startX + startGap, 1)
       raise "Routing failed" unless x1
 
       # Place 2nd vertical
-      x2 = placeLine([ ySeg, endPoint[1] ], false, endPoint[0] - endGap, -1)
+      x2 = placeLine([ ySeg + deltaY, endY ], false, endX - endGap, -1)
       raise "Routing failed" unless x2
 
       # Now add the points 1 - 4 to the list and mark the zones around them. For
       # vertical lines, we only mark vertical zones and vice versa.
-      addLineTo(points, x1, startPoint[1])  # Point 1
+      addLineTo(points, x1, startY)  # Point 1
       if x1 != x2
         addLineTo(points, x1, ySeg)          # Point 2
         addLineTo(points, x2, ySeg)          # Point 3
       end
-      addLineTo(points, x2, endPoint[1])     # Point 4
-      addLineTo(points, *endPoint)
+      addLineTo(points, x2, endY)     # Point 4
+      addLineTo(points, endX, endY)
 
       points
     end
@@ -148,138 +162,11 @@ class TaskJuggler
     # This function is only intended for debugging purposes. It marks either the
     # vertical or horizontal zones in the chart.
     def to_html
-      html = []
-      # Change this to determine what zones you want to see.
-      if true
-        # Show vertical blocks
-        x = 0
-        @vLines.each do |line|
-          line.each do |segment|
-            html << lineToHTML(x, segment[0], x, segment[1], 'white')
-          end
-          x += 1
-        end
-      else
-        # Show horizontal blocks
-        y = 0
-        @hLines.each do |line|
-          line.each do |segment|
-            html << lineToHTML(segment[0], y, segment[1], y, 'white')
-          end
-          y += 1
-        end
-      end
-      html
+      @detector.to_html
     end
 
   private
 
-    # Simple utility function to limit _v_ between 0 and _max_.
-    def clip(v, max)
-      v = 0 if v < 0
-      v = max if v > max
-      v
-    end
-
-    # This function makes sure that the rectangle described by _x_, _y_, _w_ and
-    # _h_ is properly justfified. If the width or height are negative, _x_ and
-    # _y_ are adjusted to describe the same rectangle with all positive
-    # coordinates.
-    def justify(x, y, w, h)
-      if w < 0
-        w = -w
-        x = x - w + 1
-      end
-      if h < 0
-        h = -h
-        y = y - h + 1
-      end
-      # Return the potentially adjusted rectangle coordinates.
-      return x, y, w, h
-    end
-
-    # This function adds a new segment to the line. In case the new segment
-    # overlaps with or directly attaches to existing segments, these segments
-    # are merged into a single segment.
-    def addSegment(line, newSegment)
-      # Search for overlaping or directly attaching segments in the list.
-      i = 0
-      while (i < line.length)
-        segment = line[i]
-        if mergeable?(newSegment, segment)
-          # Merge exiting segment into new one
-          merge(newSegment, segment)
-          # Remove the old one from the list and restart with the newly created
-          # one at the same position.
-          line.delete_at(i)
-          next
-        elsif segment[0] > newSegment[1]
-          # Segments are stored in ascending order. If the next segment starts
-          # with a larger value, we insert the new segment before the larger
-          # one.
-          line.insert(i, newSegment)
-          return
-        end
-        i += 1
-      end
-      # Append new segment
-      line << newSegment
-    end
-
-    # Return true if the two segments described by _s1_ and _s2_ overlap each
-    # other. A segment is a [ start, end ] Array. The two points are part of the
-    # segment.
-    def overlaps?(s1, s2)
-      (s1[0] <= s2[0] && s2[0] <= s1[1]) ||
-      (s2[0] <= s1[0] && s1[0] <= s2[1])
-    end
-
-    # Return true if the two segments described by _s1_ and _s2_ overlap each
-    # other or are directly attached to each other.
-    def mergeable?(s1, s2)
-      overlaps?(s1, s2) ||
-      (s1[1] + 1 == s2[0]) ||
-      (s2[1] + 1 == s1[0])
-    end
-
-    # Merge the two segments described by _dst_ and _src_ into _dst_.
-    def merge(dst, seg)
-      dst[0] = seg[0] if seg[0] < dst[0]
-      dst[1] = seg[1] if seg[1] > dst[1]
-    end
-
-    # Find out if any of the segments in _line_ overlap with the _probeSegment_.
-    # If so, return true, false otherwise.
-    def collision?(line, probeSegment)
-      # For complex charts, the segment lists can be rather long. We use a
-      # binary search to be fairly efficient.
-      l = 0
-      u = line.length - 1
-      while l <= u
-        # Look at the element in the middle between l and u.
-        p = l + ((u - l) / 2).to_i
-        return true if overlaps?(line[p], probeSegment)
-
-        if probeSegment[0] > line[p][1]
-          # The potential target is above p. Adjust lower bound.
-          l = p + 1
-        else
-          # The potential target is below p. Adjust upper bound.
-          u = p - 1
-        end
-      end
-      # TODO: This code uses a simple linear search to double check the above
-      # binary search. It can be removed once we know the above code always
-      # works properly.
-      line.each do |segment|
-        if overlaps?(probeSegment, segment)
-          raise "Binary search failed to find collision"
-        end
-      end
-
-      false
-    end
-
     # This function is at the heart of the routing algorithm. It tries to find a
     # place for the line described by _segment_ without overlapping with the
     # defined zones. _horizontal_ determines whether the line is running
@@ -297,10 +184,9 @@ class TaskJuggler
 
       # Make sure that the segment coordinates are in ascending order.
       segment.sort!
-      lines = horizontal ? @hLines : @vLines
       # TODO: Remove this check once the code becomes stable.
       #checkLines(lines)
-      while collision?(lines[pos], segment)
+      while @detector.collision?(pos, segment, horizontal)
         pos += delta
         # Check if we have exceded the chart area towards top/left.
         if delta < 0
@@ -312,7 +198,6 @@ class TaskJuggler
           break if pos >= (horizontal ? @height : @width)
         end
       end
-      doubleCheckLine(horizontal ? @hLines : @vLines, pos, segment)
       pos
     end
 
@@ -339,38 +224,24 @@ class TaskJuggler
       end
     end
 
-    # This is just an internal sanity check that is not needed for normal
-    # operation. It checks that all the line segments are valid and stored in
-    # ascending order.
-    def checkLines(lines)
-      lines.each do |line|
-        v = nil
-        line.each do |segment|
-          if segment[0] > segment[1]
-            raise "Invalid segment [#{segment[0]}, #{segment[1]}]"
-          end
-          if v
-            raise "Segment sequence error" if v >= segment[0]
-          end
-          v = segment[1]
-        end
+    # This function makes sure that the rectangle described by _x_, _y_, _w_
+    # and _h_ is properly justfified. If the width or height are negative, _x_
+    # and _y_ are adjusted to describe the same rectangle with all positive
+    # coordinates.
+    def justify(x, y, w, h)
+      if w < 0
+        w = -w
+        x = x - w + 1
       end
-    end
-
-    # Internal function that is only used for testing. It raises an exception if
-    # the placed line at _pos_ and [ _lineSegment_[0], _lineSegment_[1] ]
-    # overlaps with a segment of _lines_.
-    def doubleCheckLine(lines, pos, lineSegment)
-      return if pos < 0 || lines[pos].nil?
-      lines[pos].each do |segment|
-        if overlaps?(lineSegment, segment)
-          raise "Internal router failure for #{lines == @vLines ? 'v' : 'h'}" +
-                "Line #{pos}: [#{lineSegment.join(', ')}] overlaps with " +
-                "[#{segment.join(', ')}]."
-        end
+      if h < 0
+        h = -h
+        y = y - h + 1
       end
+      # Return the potentially adjusted rectangle coordinates.
+      return x, y, w, h
     end
 
+
   end
 
 end