rchart 1.2.2 → 2.0.1

data/Rakefile

@@ -11,9 +11,9 @@ begin
     gem.homepage = "http://github.com/amardaxini/rchart"
     gem.authors = ["amardaxini"]
     gem.rubyforge_project = "rchart"
-#    gem.add_development_dependency "thoughtbot-shoulda", ">= 0"
-    gem.add_development_dependency "ruby-gd",">=0.8.0"
-    gem.files = [Dir['fonts/*'],Dir['examples/*'],".document", ".gitignore","LICENSE","README.rdoc","Rakefile","VERSION",  "lib/rchart.rb","lib/rdata.rb","lib/version.rb","test/helper.rb","test/test_rchart.rb"]
+  #  gem.add_development_dependency "ruby-gd",">=0.8.0"
+    gem.add_development_dependency "rgd2-ffij"
+    gem.files = [Dir['fonts/*'],Dir['examples/*'],Dir['lib/*.rb'],".document", ".gitignore","LICENSE","README.rdoc","Rakefile","VERSION", "test/helper.rb","test/test_rchart.rb"]
     gem.requirements << "libgd-ruby, libpng-dev, libgd-dev package are required"
     # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
   end

data/VERSION

@@ -1 +1 @@
-1.2.2
+2.0.1

data/lib/bar_chart.rb

@@ -0,0 +1,166 @@
+module BarChart
+# This function will draw a bar graph using all the registered series.
+  # When creating a bar graph, don't forget to set the with_margin parameter of the draw_scale function to true.
+  # Setting shadow to true will draw a shadow behind each series, this will also slow down a bit the renderer engine.
+
+  def draw_bar_graph(data,data_description,shadow=false,alpha=100)
+    data_description = self.validate_data_description("drawBarGraph",data_description)
+    validate_data("drawBarGraph",data)
+
+   # graph_id      = 0
+    series       = (data_description["values"]).count
+    series_width  = @division_width / (series+1)
+    serie_x_offset = @division_width / 2 - series_width / 2
+
+    y_zero  = @g_area_y2 - ((0-@vmin) * @division_ratio)
+    y_zero = @g_area_y2 if ( y_zero> @g_area_y2 )
+    serie_id = 0
+    color_id =0
+    id = 0
+    data_description["values"].each do |col_name|
+      data_description["description"].each do |key_i,value_i|
+        if ( key_i == col_name )
+          color_id = id
+          id = id+1
+        end
+      end
+      x_pos = @g_area_x1 + @g_area_x_offset - serie_x_offset + series_width * serie_id
+    #  x_last = -1
+      data.each do |key|
+        if ( !key[col_name].nil?)
+          if ( key[col_name].is_a?(Numeric) )
+            value = key[col_name]
+            y_pos = @g_area_y2 - ((value-@vmin) * @division_ratio)
+            #  Save point into the image map if option activated */
+            if (@build_map )
+              #add_to_image_map(x_pos+1,[y_zero,y_pos].min,x_pos+series_width-1,[y_zero,y_pos].max,data_description["description"][col_name],data[key][col_name].data_description["unit"]["y"],"Bar")
+            end
+            if ( shadow && alpha == 100 )
+              draw_rectangle(x_pos+1,y_zero,x_pos+series_width-1,y_pos,25,25,25)
+            end
+            draw_filled_rectangle(x_pos+1,y_zero,x_pos+series_width-1,y_pos,@palette[color_id]["r"],@palette[color_id]["g"],@palette[color_id]["b"],true,alpha)
+          end
+          x_pos = x_pos + @division_width
+        end
+      end
+      serie_id = serie_id+1
+    end
+  end
+
+  # This function will draw a stacked bar graph using all the registered series.
+  # When creating a bar graph, don't forget to set the with_margin parameter of the draw_scale function to true.
+  # Don't forget to change the automatic scaling to Rchart::SCALE_ADDALL to have an accurate scaling mode.
+  # You can specify the transparency and if the bars must be contiguous or with space (default)
+  def draw_stacked_bar_graph(data,data_description,alpha=50,contiguous=false)
+    # /* Validate the Data and data_description array */
+    data_description = validate_data_description("draw_bar_graph",data_description)
+    validate_data("draw_bar_graph",data)
+    graph_id      = 0
+    series       = (data_description["values"].count)
+    if ( contiguous )
+      series_width  = @division_width
+    else
+      series_width  = @division_width * 0.8
+    end
+    y_zero  = @g_area_y2 - ((0-@vmin) * @division_ratio)
+    y_zero = @g_area_y2 if ( y_zero > @g_area_y2 )
+    series_id = 0
+    last_value = {}
+    id = 0
+    color_id = 0
+    data_description["values"].each do |col_name|
+      data_description["description"].each do |key_i,value_i|
+        if ( key_i == col_name )
+          color_id = id
+          id = id+1
+        end
+      end
+      x_pos  = @g_area_x1 + @g_area_x_offset - series_width / 2
+      x_last = -1
+      data.each do |key|
+        if ( !key[col_name].nil?)
+          if ( key[col_name].is_a?(Numeric) )
+            value = key[col_name]
+            if (!last_value[key].nil?)
+              y_pos    = @g_area_y2 - (((value+last_value[key])-@vmin) * @division_ratio)
+              y_bottom = @g_area_y2 - ((last_value[key]-@vmin) * @division_ratio)
+              last_value[key] += value
+            else
+              y_pos    = @g_area_y2 - ((value-@vmin) * @division_ratio)
+              y_bottom = y_zero
+              last_value[key] = value
+            end
+            # Save point into the image map if option activated
+            if ( @build_map )
+              #add_to_image_map(x_pos+1,[y_bottom,y_pos].min,x_pos+series_width-1,[y_bottom,y_pos].max,data_description["description"][col_name],data[key][col_name].data_description["unit"]["y"],"sBar")
+            end
+            draw_filled_rectangle(x_pos+1,y_bottom,x_pos+series_width-1,y_pos,@palette[color_id]["r"],@palette[color_id]["g"],@palette[color_id]["b"],true,alpha)
+          end
+        end
+        x_pos = x_pos + @division_width
+      end
+      series_id+=1
+    end
+  end
+  # This function will draw a superposed bar graph using all the registered series.
+  # You can provide the alpha value used when merging all series layers.
+
+  def draw_overlay_bar_graph(data,data_description,alpha=50)
+    data_description = validate_data_description("draw_overlay_bar_graph",data_description)
+    validate_data("draw_overlay_bar_graph",data)
+    layer_width  = @g_area_x2-@g_area_x1
+    layer_height = @g_area_y2-@g_area_y1
+    graph_id = 0
+    color_id =0
+    id =0
+    data_description["values"].each do |col_name|
+      data_description["description"].each do |key_i,value_i|
+        if ( key_i == col_name )
+          color_id = id
+          id = id+1
+        end
+      end
+      @layers[graph_id] = image_create_true_color(layer_width,layer_height)
+      image_filled_rectangle(@layers[graph_id],0,0,layer_width,layer_height,255,255,255)
+      image_color_transparent(@layers[graph_id],255,255,255)
+      x_width = @division_width / 4
+      x_pos   = @g_area_x_offset
+      y_zero  = layer_height - ((0-@vmin) * @division_ratio)
+      x_last  = -1
+      points_count = 2
+      data.each do |key|
+        if(!key[col_name].nil?)
+          if(key[col_name].is_a?(Numeric))
+            value = key[col_name]
+            if (value.is_a?(Numeric) )
+              y_pos  = layer_height - ((value-@vmin) * @division_ratio)
+              image_filled_rectangle(@layers[graph_id],x_pos-x_width,y_pos,x_pos+x_width,y_zero,@palette[graph_id]["r"],@palette[graph_id]["g"],@palette[graph_id]["b"])
+              x1 = (x_pos - x_width + @g_area_x1).floor
+              y1 = (y_pos+@g_area_y1).floor + 0.2
+              x2 = (x_pos + x_width + @g_area_x1).floor
+              y2 = @g_area_y2 - ((0-@vmin) * @division_ratio)
+              x1 = @g_area_x1 + 1 if ( x1 <= @g_area_x1 )
+              x2 = @g_area_x2 - 1 if ( x2 >= @g_area_x2 )
+
+              # Save point into the image map if option activated */
+              if ( @build_map )
+                #add_to_image_map(x1,[y1,y2].min,x2,[y1,y2].max,data_description["description"][col_name],data[key][col_name].data_description["unit"]["y"],"oBar")
+              end
+              draw_line(x1,y1,x2,y1,@palette[color_id]["r"],@palette[color_id]["g"],@palette[color_id]["b"],true)
+            end
+          end
+        end
+        x_pos = x_pos + @division_width
+      end
+      graph_id+=1
+    end
+    i=0
+    while (i<=(graph_id-1))
+      image_copy_merge(@layers[i],@picture,@g_area_x1,@g_area_y1,0,0,layer_width,layer_height,alpha)
+      image_destroy(@layers[i])
+      #	image_destroy(@layers[i])
+      i=i+1
+    end
+  end
+
+end

data/lib/color_palette.rb

@@ -0,0 +1,56 @@
+module ColorPalette
+  # This function can be used to change the color of one series.
+  # series id are starting at 0 for associated data serie #1.
+  # You must provide an rgb color.
+  def set_color_palette(id,r,g,b)
+    b,g,r=validate_color(b, g, r)
+    @palette[id]["r"] = r
+    @palette[id]["g"] = g
+    @palette[id]["b"] = b
+  end
+
+  # Create a color palette shading from one color to another
+  # This function will fill the color palette with 10 shades between the two RGB colors 0,0,0 and 100,100,100.This will produce grey shades. (Palette id 0-9 will be filled)
+  def create_color_gradient_palette(r1,g1,b1,r2,g2,b2,shades)
+    r_factor = (r2-r1)/shades
+    g_factor = (g2-g1)/shades
+    b_factor = (b2-b1)/shades
+    i= 0
+    while(i<= shades-1)
+      @palette[i]["r"] = r1+r_factor*i
+      @palette[i]["g"] = g1+g_factor*i
+      @palette[i]["b"] = b1+b_factor*i
+      i = i+1
+    end
+  end
+  # This function will load the color scheme from a text file.
+  # This file must be formatted with three values per line ( r,g,b ).
+  # By default the delimiter is a coma but you can specify it.
+  def load_color_palette_from_file(file_name)
+    color_id = 0
+    File.open(file_name,"r") do |infile|
+      while (line = infile.gets)
+        values = line.split(",")
+        if ( values.length == 3 )
+          @palette[color_id]["r"] = values[0].to_i
+          @palette[color_id]["g"] = values[1].to_i
+          @palette[color_id]["b"] = values[2].to_i
+          color_id+=1
+        end
+      end
+    end
+  end
+
+  # Load palette from array [[r,g,b],[r1,g1,b1]]
+  def load_color_palette(color_palette)
+    color_id = 0
+    color_palette.each do |palette|
+      if palette.length == 3
+        @palette[color_id]["r"] = palette[0].to_i
+        @palette[color_id]["g"] = palette[1].to_i
+        @palette[color_id]["b"] = palette[2].to_i
+        color_id+=1
+      end
+    end
+  end
+end

data/lib/cubic_chart.rb

@@ -0,0 +1,271 @@
+module CubicChart
+# This function will draw a curved line graph using all the registered series.
+  # This curve is using a cubic algorithm to process the average values between two points.
+  # You have to specify the accuracy between two points, typically a 0.1 value is acceptable. the smaller the value is, the longer it will take to process the graph.
+  def draw_cubic_curve(data,data_description,accuracy=0.1,serie_name="")
+
+    data_description = self.validate_data_description("draw_cubic_curve",data_description)
+    self.validate_data("draw_cubic_curve",data)
+    graph_id = 0
+    id = 0
+    color_id =0
+
+    data_description["values"].each do |col_name|
+      if ( serie_name == "" || serie_name == col_name )
+        x_in = []
+        y_in =[]
+        y_t = []
+        u = []
+        x_in[0] = 0
+        y_in[0] = 0
+
+        data_description["description"].each do |key_i,value_i|
+          if ( key_i == col_name )
+            color_id = id
+            id = id+1
+          end
+        end
+        index = 1
+        x_last = -1
+        missing = []
+        data.each do |key|
+          if(!key[col_name].nil?)
+            val = key[col_name]
+
+            x_in[index]  = index
+            #y_in[index] =  val
+            #my hack TODO "" convet missing values to zero
+            y_in[index] =  val if ((val).is_a?(Numeric))
+            y_in[index] = 0 if (!(val).is_a?(Numeric))
+            ######
+            missing[index]=true if (!(val).is_a?(Numeric))
+            index=index+1
+          end
+        end
+        index= index-1
+        y_t[0] = 0
+        y_t[1] = 0
+        u[0] = 0
+        u[1]  = 0
+        i =2
+        y_last =0
+
+        while(i<=index-1)
+          sig = (x_in[i]-x_in[i-1])*1.0/(x_in[i+1]-x_in[i-1]) #rescue 0
+          p=sig*y_t[i-1]+2
+          y_t[i]=(sig-1)/p
+          u[i]=(y_in[i+1]-y_in[i])*1.0/(x_in[i+1]-x_in[i])-(y_in[i]-y_in[i-1])*1.0/(x_in[i]-x_in[i-1]) #rescue 0
+          u[i]=(6*u[i]/(x_in[i+1]-x_in[i-1])-sig*u[i-1])/p #rescue 0
+          i=i+1
+        end
+        qn = 0
+        un = 0
+        y_t[index] = (un - qn * u[index-1]) / (qn * y_t[index-1] + 1)
+        k = index-1
+        while k>=1
+          y_t[k]=y_t[k]*	y_t[k+1]+u[k]
+          k=k-1
+        end
+        x_pos  = @g_area_x1 + @g_area_x_offset
+        x =1
+        while x<=index
+          klo=1
+          khi=index
+          k = khi-klo
+          while k>1
+            k=khi-klo
+            if x_in[k]>=x
+              khi=k
+            else
+              klo=k
+            end
+          end
+          klo=khi-1
+          h = x_in[khi]-x_in[klo]
+          a = (x_in[khi]-x)/h rescue 1
+          b = (x-x_in[klo])/h rescue 1
+          value = a*y_in[klo]+b*y_in[khi]+((a*a*a-a)*y_t[klo]+(b*b*b-b)*y_t[khi])*(h*h)/6
+          y_pos = @g_area_y2-((value-@vmin)*@division_ratio)
+          #TODO Check(x_last!=-1 && !missing[x.floor].nil? && !missing[(x+1).floor].nil? )
+          #UPDATED
+          if (x_last!=-1 && missing[x.floor].nil? && missing[(x+1).floor].nil? )
+            self.draw_line(x_last,y_last,x_pos,y_pos, @palette[id]["r"],@palette[id]["g"],@palette[id]["b"],true)
+          end
+          x_last = x_pos
+          y_last = y_pos
+          x_pos = x_pos +@division_width*accuracy
+          x=x+accuracy
+        end
+        #Add potentialy missing values
+        x_pos  = x_pos - @division_width * accuracy
+        if ( x_pos < (@g_area_x2 - @g_area_x_offset) )
+          y_pos = @g_area_y2 - ((y_in[index]-@vmin) * @division_ratio)
+          self.draw_line(x_last,y_last,@g_area_x2-@g_area_x_offset,y_pos,@palette[id]["r"],@palette[id]["g"],@palette[id]["b"],true)
+        end
+        graph_id += 1
+      end
+    end
+  end
+  # This function will draw a filled curved line graph using all the registered series.
+  # This curve is using a cubic algorythm to process the average values between two points.
+  # You have to specify the accuracy between two points, typicaly a 0.1 value is acceptable. the smaller the value is, the longer it will take to process the graph.
+  # You can provide the alpha value used when merging all series layers.
+  # If around_zero is set to true, the area drawn will be between the 0 axis and the line graph value.
+
+  def draw_filled_cubic_curve(data,data_description,accuracy=0.1,alpha=100,around_zero=false)
+    data_description = self.validate_data_description("draw_filled_cubic_curve",data_description)
+    self.validate_data("draw_filled_cubic_curve",data)
+    layer_width  = @g_area_x2-@g_area_x1
+    layer_height = @g_area_y2-@g_area_y1
+    y_zero = layer_height - ((0-@vmin) * @division_ratio)
+    y_zero = layer_height if ( y_zero > layer_height )
+    graph_id = 0
+    id = 0
+    color_id =0
+    data_description["values"].each do |col_name|
+      x_in = []
+      y_in =[]
+      y_t = []
+      u = []
+      x_in[0] = 0
+      y_in[0] = 0
+      data_description["description"].each do |key_i,value_i|
+        if ( key_i == col_name )
+          color_id = id
+          id = id+1
+        end
+      end
+      index = 1
+      x_last = -1
+      missing = []
+      data.each do |key|
+        if(!key[col_name].nil?)
+          val = key[col_name]
+          x_in[index]  = index
+          y_in[index] =  val
+          missing[index]=true if ((val).is_a?(Numeric))
+          index=index+1
+        end
+      end
+      index= index-1
+      y_t[0] = 0
+      y_t[1] = 0
+      u[1]  = 0
+      i =2
+      y_last =0
+
+      while(i<index)
+        sig = (x_in[i]-x_in[i-1])*1.0/(x_in[i+1]-x_in[i-1]) #rescue 0
+        p=sig*y_t[i-1]+2
+        y_t[i]=(sig-1)/p
+        u[i]=(y_in[i+1]-y_in[i])*1.0/(x_in[i+1]-x_in[i])-(y_in[i]-y_in[i-1])*1.0/(x_in[i]-x_in[i-1]) #rescue 0
+        u[i]=(6*u[i]/(x_in[i+1]-x_in[i-1])-sig*u[i-1])/p #rescue 0
+        i=i+1
+      end
+      qn = 0
+      un = 0
+      y_t[index] = (un - qn * u[index-1]) / (qn * y_t[index-1] + 1)
+      k = index-1
+      while k>=1
+        y_t[k]=y_t[k]*	y_t[k+1]+u[k]
+        k=k-1
+      end
+      points = []
+      points << @g_area_x_offset
+      points << layer_height
+      @layers[0] = image_create_true_color(layer_width,layer_height)
+      image_filled_rectangle(@layers[0],0,0,layer_width,layer_height, 255,255,255)
+      image_color_transparent(@layers[0], 255,255,255)
+      y_last = nil
+      x_pos  = @g_area_x_offset
+      points_count= 2
+      x=1
+      while(x<=index)
+        klo=1
+        khi=index
+        k = khi-klo
+        while k>1
+          k=khi-klo
+          if x_in[k]>=x
+            khi=k
+          else
+            klo=k
+          end
+        end
+        klo=khi-1
+        h = x_in[khi]-x_in[klo]
+        a = (x_in[khi]-x)/h rescue 1
+        b = (x-x_in[klo])/h rescue 1
+        value = a*y_in[klo]+b*y_in[khi]+((a*a*a-a)*y_t[klo]+(b*b*b-b)*y_t[khi])*(h*h)/6
+        y_pos = layer_height - ((value-@vmin) * @division_ratio)
+
+        a_points  = []
+        if ( !y_last.nil? && around_zero && (missing[x.floor].nil?) && (missing[(x+1).floor].nil?))
+
+          a_points << x_last
+          a_points << y_last
+          a_points << x_pos
+          a_points << y_pos
+          a_points << x_pos
+          a_points << y_zero
+          a_points << x_last
+          a_points << y_zero
+          #check No of points here 4 is pass check in image filled_polygon
+          image_filled_polygon(@layers[0], a_points, @palette[color_id]["r"],@palette[color_id]["g"],@palette[color_id]["b"],4)
+        end
+        if ( missing[(x.floor)].nil? || y_last.nil?)
+          points_count = points_count+1
+          points << x_pos
+          points << y_pos
+        else
+          points_count = points_count+1
+          points << x_last
+          points << y_last
+        end
+        y_last = y_pos
+        x_last = x_pos
+        x_pos  = x_pos + @division_width * accuracy
+        x=x+accuracy
+      end
+
+      #// Add potentialy missing values
+      # a_points  = []
+      x_pos  = x_pos - @division_width * accuracy
+      if ( x_pos < (layer_width-@g_area_x_offset) )
+        y_pos = layer_height - ((y_in[index]-@vmin) * @division_ratio)
+        if ( !y_last.nil? && around_zero )
+          a_points << x_last
+          a_points <<  y_last
+          a_points << (layer_width-@g_area_x_offset)
+          a_points << y_pos
+          a_points << (layer_width-@g_area_x_offset)
+          a_points << y_zero
+          a_points <<  x_last
+          a_points << y_zero
+          #  imagefilledpolygon(@layers[0],a_points,4,$C_Graph)
+          image_filled_polygon(@layers[0], a_points, @palette[color_id]["r"],@palette[color_id]["g"],@palette[color_id]["b"],4)
+        end
+
+        if ( y_in[klo] != "" && y_in[khi] != "" || y_last.nil? )
+
+          points_count +=1
+          points << (layer_width-@g_area_x_offset).floor
+          points << (y_pos).floor
+        end
+      end
+
+      points << (layer_width-@g_area_x_offset).floor
+      points << layer_height.floor
+
+      if ( !around_zero )
+        image_filled_polygon(@layers[0], points, @palette[color_id]["r"],@palette[color_id]["g"],@palette[color_id]["b"],points_count)
+      end
+
+      image_copy_merge(@layers[0],@picture,@g_area_x1,@g_area_y1,0,0,layer_width,layer_height,alpha)
+      image_destroy(@layers[0])
+
+      	draw_cubic_curve(data, data_description,accuracy,col_name)
+      graph_id+=1
+    end
+  end
+end