technical_graph 0.3.2 → 0.4.0

data/lib/technical_graph/graph_image_drawer.rb

@@ -1,8 +1,7 @@
 #encoding: utf-8
 
-require 'rubygems'
-require 'RMagick'
 require 'date'
+require 'zlib'
 
 # Universal class for creating graphs/charts.
 
@@ -16,6 +15,24 @@ require 'date'
 
 class GraphImageDrawer
 
+  # Which type of drawing class use?
+  def drawing_class
+    if options[:drawer_class] == :rasem
+      require 'technical_graph/graph_image_drawer_rasem'
+      return GraphImageDrawerRasem
+    end
+
+    if options[:drawer_class] == :rmagick
+      require 'technical_graph/graph_image_drawer_rmagick'
+      return GraphImageDrawerRmagick
+    end
+  end
+
+  # Best output image format, used for testing
+  def best_output_format
+    @technical_graph.best_output_format
+  end
+
   attr_reader :technical_graph
 
   # Accessor for options Hash
@@ -38,6 +55,10 @@ class GraphImageDrawer
     @technical_graph.axis
   end
 
+  def logger
+    @technical_graph.logger
+  end
+
   def truncate_string
     options[:truncate_string]
   end
@@ -54,18 +75,25 @@ class GraphImageDrawer
   def initialize(technical_graph)
     @technical_graph = technical_graph
 
+    t = Time.now
+
+    # drawer type
+    #options[:drawer_class] ||= :rmagick
+    options[:drawer_class] ||= :rasem
+
     options[:width] ||= DEFAULT_WIDTH
     options[:height] ||= DEFAULT_HEIGHT
 
+    options[:axis_value_and_param_labels] = true if options[:axis_value_and_param_labels].nil?
+    options[:axis_zero_labels] = true if options[:axis_zero_labels].nil?
+
     # colors
     options[:background_color] ||= 'white'
     options[:background_hatch_color] ||= 'lightcyan2'
-    options[:axis_color] ||= '#aaaaaa'
+    options[:axis_color] ||= '#000000'
 
     # antialias
-    options[:layers_antialias] = false if options[:layers_antialias].nil?
-    options[:axis_antialias] = false if options[:axis_antialias].nil?
-    options[:font_antialias] = false if options[:font_antialias].nil?
+    options[:antialias] = false if options[:antialias].nil?
 
     # font sizes
     options[:axis_font_size] ||= 10
@@ -82,6 +110,9 @@ class GraphImageDrawer
 
     # array of all points drawn on graph, used for auto positioning of legend
     @drawn_points = Array.new
+
+    logger.debug "initializing #{self.class}"
+    logger.debug " TIME COST #{Time.now - t}"
   end
 
   def width
@@ -100,8 +131,8 @@ class GraphImageDrawer
     options[:height] = h.to_i if h.to_i > 0
   end
 
-  def font_antialias
-    options[:font_antialias] == true
+  def antialias
+    options[:antialias] == true
   end
 
   def draw_legend?
@@ -152,48 +183,17 @@ class GraphImageDrawer
   # Create background image
   def crate_blank_graph_image
     pre_image_create_calculations
-
-    @image = Magick::ImageList.new
-    @image.new_image(
-      width,
-      height,
-      Magick::HatchFill.new(
-        options[:background_color],
-        options[:background_hatch_color]
-      )
-    )
-
-    return @image
+    # create drawing proxy
+    @drawer = drawing_class.new(self)
   end
 
-  attr_reader :image
+  attr_reader :drawer
 
-  # Render data layer
+  # Render data layer, calculate coords and execute proxy
   def render_data_layer(l)
     layer_data = l.processed_data
 
-    layer_line = Magick::Draw.new
-    layer_text = Magick::Draw.new
-
-    # global layer antialias can be override using layer option
-    layer_antialias = l.antialias
-    layer_antialias = options[:layers_antialias] if layer_antialias.nil?
-
-    layer_line.stroke_antialias(layer_antialias)
-    layer_line.fill(l.color)
-    layer_line.fill_opacity(1)
-    layer_line.stroke(l.color)
-    layer_line.stroke_opacity(1.0)
-    layer_line.stroke_width(1.0)
-    layer_line.stroke_linecap('square')
-    layer_line.stroke_linejoin('miter')
-
-    layer_text.text_antialias(font_antialias)
-    layer_text.pointsize(options[:layers_font_size])
-    layer_text.font_family('helvetica')
-    layer_text.font_style(Magick::NormalStyle)
-    layer_text.text_align(Magick::LeftAlign)
-    layer_text.text_undercolor(options[:background_color])
+    t = Time.now
 
     # calculate coords, draw text, and then lines and circles
     coords = Array.new
@@ -216,44 +216,19 @@ class GraphImageDrawer
       }
     end
 
-    # labels
-    if l.value_labels
-      coords.each do |c|
-        string_label = "#{truncate_string % c[:dy]}"
-        layer_text.text(
-          c[:ax] + 5, c[:ay],
-          string_label
-        )
-      end
-      layer_text.draw(@image)
-    end
+    logger.debug "rendering layer of size #{layer_data.size}, bitmap position calculation"
+    logger.debug " TIME COST #{Time.now - t}"
+    t = Time.now
 
-    # lines and circles
-    coords.each do |c|
-      # additional circle
-      layer_line.circle(
-        c[:ax], c[:ay],
-        c[:ax] + 3, c[:ay]
-      )
-      layer_line.circle(
-        c[:bx], c[:by],
-        c[:bx] + 3, c[:by]
-      )
-
-      # line
-      layer_line.line(
-        c[:ax], c[:ay],
-        c[:bx], c[:by]
-      )
-
-      # used for auto positioning of legend
-      if legend_auto_position
-        @drawn_points << { :x => c[:ax], :y => c[:ay] }
-        @drawn_points << { :x => c[:bx], :y => c[:by] }
-      end
-    end
-    layer_line.draw(@image)
+    # draw using proxy
+    drawer.render_data_layer(l, coords)
+  end
 
+  # Used for auto position for legend
+  def post_dot_drawn(bx, by)
+    if legend_auto_position
+      @drawn_points << { :x => bx, :y => by }
+    end
   end
 
   # height of 1 layer
@@ -262,7 +237,7 @@ class GraphImageDrawer
   # Choose best location
   def recalculate_legend_position
     return unless legend_auto_position
-    puts "Auto position calculation, drawn points #{@drawn_points.size}"
+    logger.debug "Auto position calculation, drawn points #{@drawn_points.size}"
 
     legend_height = layers.size * ONE_LAYER_LEGEND_HEIGHT
 
@@ -278,6 +253,8 @@ class GraphImageDrawer
       { :x => width - legend_margin - legend_width, :y => height - legend_margin - legend_height }, # bottom-right
     ]
 
+    t = Time.now
+
     # calculate nearest distance of all drawn points
     positions.each do |p|
       p[:distance] = (width ** 2 + height ** 2) ** 0.5 # max distance, diagonal of graph
@@ -291,71 +268,77 @@ class GraphImageDrawer
       end
     end
 
-    # chose position with hihest distance
+    logger.debug "auto legend best position distance calc."
+    logger.debug " TIME COST #{Time.now - t}"
+    t = Time.now
+
+    # chose position with highest distance
     positions.sort! { |a, b| a[:distance] <=> b[:distance] }
     best_position = positions.last
     options[:legend_x] = best_position[:x]
     options[:legend_y] = best_position[:y]
 
-    puts "Best position x #{options[:legend_x]}, y #{options[:legend_y]}, distance #{best_position[:distance]}"
-    # puts positions.to_yaml
+    logger.debug "Best position x #{options[:legend_x]}, y #{options[:legend_y]}, distance #{best_position[:distance]}"
+    logger.debug " TIME COST #{Time.now - t}"
   end
 
   # Render legend on graph
   def render_data_legend
     return unless draw_legend?
-
     recalculate_legend_position
 
-    legend_text = Magick::Draw.new
-    legend_text_antialias = options[:layers_font_size]
-    legend_text.stroke_antialias(legend_text_antialias)
-    legend_text.text_antialias(legend_text_antialias)
-    legend_text.pointsize(options[:axis_font_size])
-    legend_text.font_family('helvetica')
-    legend_text.font_style(Magick::NormalStyle)
-    legend_text.text_align(Magick::LeftAlign)
-    legend_text.text_undercolor(options[:background_color])
-
     x = legend_x
     y = legend_y
 
-    layers.each do |l|
-      legend_text.fill(l.color)
-
-      string_label = l.label
-      legend_text.text(
-        x, y,
-        string_label
-      )
+    legend_data = Array.new
 
-      # little dot
-      legend_text.circle(
-        x - 10, y,
-        x - 10 + 3, y
-      )
+    layers.each do |l|
+      h = Hash.new
+      h[:color] = l.color
+      h[:label] = l.label
+      h[:x] = x
+      h[:y] = y
 
+      legend_data << h
       y += ONE_LAYER_LEGEND_HEIGHT
     end
-    legend_text.draw(@image)
+
+    drawer.legend(legend_data)
   end
 
   # Save output to file
   def save_to_file(file)
-    @image.write(file)
+    t = Time.now
+
+    drawer.save(file)
+
+    logger.debug "saving image"
+    logger.debug " TIME COST #{Time.now - t}"
   end
 
   # Export image
   def to_format(format)
-    i = @image.flatten_images
-    i.format = format
-    return i.to_blob
+    t = Time.now
+
+    blob = drawer.to_format(format)
+
+    logger.debug "exporting image as string"
+    logger.debug " TIME COST #{Time.now - t}"
+
+    return blob
   end
 
   # Return binary PNG
   def to_png
-    to_format('png')
+    drawer.to_png
+  end
+
+  def to_svg
+    drawer.to_svg
   end
 
+  def to_svgz
+    drawer.to_svgz
+  end
 
 end

data/lib/technical_graph/graph_image_drawer_module.rb

@@ -0,0 +1,72 @@
+#encoding: utf-8
+
+module GraphImageDrawerModule
+
+  def initialize(drawer)
+    @drawer = drawer
+    create_blank_image
+  end
+
+  attr_reader :drawer
+
+  def width
+    drawer.width
+  end
+
+  def height
+    drawer.height
+  end
+
+  def truncate_string
+    drawer.truncate_string
+  end
+
+  def options
+    drawer.options
+  end
+
+  def logger
+    drawer.logger
+  end
+
+
+  # Draw one or many axis
+  def x_axis(x_array, options = { :color => 'black', :width => 1 })
+    axis(x_array, [], options)
+  end
+
+  # Draw one or many axis
+  def y_axis(y_array, options = { :color => 'black', :width => 1 })
+    axis([], y_array, options)
+  end
+
+  # Return binary PNG
+  def to_png
+    to_format('png')
+  end
+
+  def to_svg
+    to_format('svg')
+  end
+
+  def to_svgz
+    drawer.deflate_string( to_format('svg') )
+  end
+
+  def deflate_string(str, level = 9)
+    z = Zlib::Deflate.new(level)
+    dst = z.deflate(str, Zlib::FINISH)
+    z.close
+    dst
+  end
+
+  def format_from_filename(file)
+    file.gsub(/^.*\./, '')
+  end
+
+  # Used for creating temp files
+  def random_filename
+    (0...16).map{65.+(rand(25)).chr}.join
+  end
+
+end

data/lib/technical_graph/graph_image_drawer_rasem.rb

@@ -0,0 +1,185 @@
+#encoding: utf-8
+
+require 'technical_graph/graph_image_drawer_module'
+require 'rubygems'
+require 'rasem'
+require 'tmpdir'
+
+class GraphImageDrawerRasem
+  include GraphImageDrawerModule
+
+  # Initialize blank image
+  def create_blank_image
+    @image = Rasem::SVGImage.new(drawer.width, drawer.height)
+  end
+
+  # Draw both array axis
+  def axis(x_array, y_array, _options = { :color => 'black', :width => 1 }, render_labels = false, x_labels = [], y_labels = [])
+    # for single axis
+    x_array = [x_array] if not x_array.kind_of? Array
+    y_array = [y_array] if not y_array.kind_of? Array
+
+    _s = self
+
+    @image.group :stroke => _options[:color], :stroke_width => _options[:width] do
+      x_array.each_with_index do |x, i|
+        line(x, 0, x, _s.height, { })
+
+        # labels
+        label = x_labels[i]
+        if render_labels and not label.nil?
+          label = "#{_s.truncate_string % label}"
+          text(x + 15, _s.height - 15, label, { })
+        end
+      end
+
+      y_array.each_with_index do |y, i|
+        line(0, y, _s.width, y, { })
+
+        # labels
+        label = y_labels[i]
+        if render_labels and not label.nil?
+          label = "#{_s.truncate_string % label}"
+          text(15, y + 15, label, { })
+        end
+      end
+    end
+  end
+
+  # Label for parameters and values
+  def axis_labels(parameter_label, value_label, _options = { :color => 'black', :width => 1, :size => 20 })
+    _s = self
+    @image.group :stroke => _options[:color], :stroke_width => _options[:width] do
+      text(
+        (_s.width / 2).to_i,
+        _s.height - 40,
+        parameter_label, { 'font-size' => "#{_options[:size]}px" }
+      )
+
+      text(
+        (_s.height / 2).to_i,
+        -40,
+        value_label, { :transform => 'rotate(90 0,0)', 'font-size' => "#{_options[:size]}px" }
+      )
+    end
+  end
+
+  def render_data_layer(l, coords)
+    _s = self
+    _l = l
+    _coords = coords
+
+    # value labels
+    if l.value_labels
+      t = Time.now
+
+      @image.group :stroke => _s.options[:axis_color], :stroke_width => 1 do
+        _coords.each do |c|
+          string_label = "#{_s.truncate_string % c[:dy]}"
+          text(
+            c[:ax] + 5, c[:ay],
+            string_label
+          )
+        end
+      end
+
+      logger.debug "labels"
+      logger.debug " TIME COST #{Time.now - t}"
+    end
+
+    t = Time.now
+
+    # lines and dots
+    @image.group :stroke => l.color, :stroke_width => 1 do
+      _coords.each do |c|
+        # additional circle
+        circle(c[:ax], c[:ay], 2, { :fill => l.color })
+        circle(c[:bx], c[:by], 2, { :fill => l.color })
+        # line
+        line(
+          c[:ax], c[:ay],
+          c[:bx], c[:by],
+          { }
+        )
+
+        _s.drawer.post_dot_drawn(c[:ax], c[:ay])
+        _s.drawer.post_dot_drawn(c[:bx], c[:by])
+      end
+    end
+
+    logger.debug "dots and lines"
+    logger.debug " TIME COST #{Time.now - t}"
+  end
+
+  def legend(legend_data)
+    _s = self
+
+    @image.group :stroke_width => 1, :stroke => '' do
+      legend_data.each do |l|
+        circle(l[:x], l[:y], 2, { :stroke => l[:color], :fill => l[:color] })
+        text(l[:x] + 5, l[:y], l[:label], { :stroke => l[:color], :fill => l[:color] })
+      end
+    end
+  end
+
+# Needed before saving?
+  def close
+    @image.close if not closed?
+    @closed = true
+  end
+
+  def closed?
+    @closed
+  end
+
+  # Save to file, convert when needed
+  def save(file)
+    close
+
+    format = format_from_filename(file)
+    case format
+      when 'svg' then
+        string = to_svg
+      when 'svgz' then
+        string = to_svgz
+      else
+        # ugly hack, save to svg and then convert using image magick
+        tmp_file = file.gsub(/#{format}/, 'svg')
+        # save to svg
+        save(tmp_file)
+        # convert
+        `convert "#{tmp_file}" "#{file}"`
+        return
+    end
+
+    File.open(file, 'w') do |f|
+      f << string
+    end
+  end
+
+
+  def to_format(format)
+    close
+
+    return @image.output if format == 'svg'
+    return to_svgz if format == 'svgz'
+
+    #raise 'Not implemented' if not format == 'svg'
+    return ugly_convert(format)
+  end
+
+  # Ugly, save temporary file, convert, read, delete temp file
+  def ugly_convert(format)
+    # create temp file
+    tmp_file = File.join(Dir.tmpdir, "#{random_filename}.#{format}")
+    save(tmp_file)
+    # read content
+    contents = open(tmp_file, "rb") { |io| io.read }
+    # remove temp file
+    File.delete(tmp_file)
+
+    # return content
+    contents
+  end
+
+end