graphit 0.0.6 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: cff85df062116029645654037094f8c056299c7c
-  data.tar.gz: bca19ead37b0ba0690cd87601a5571558e35e773
+  metadata.gz: 1941e4e3ce7e786d8ea2396895269e98c0a9c5f0
+  data.tar.gz: 20bfe9f272774fc841b4d891cbb61c2f310ac63d
 SHA512:
-  metadata.gz: 9d0ff1e0b05124e6f7d2c69e69268b3ea46e91a1fa1132b758c932718964b6ace2176f910198057a24c1879825c848100d5a9166ded6f3a72de7f268cf160ead
-  data.tar.gz: 5c53f8bc1790c42969733bf28486e8f6639daf09468af0ad50262ff409e0a87098e855a3eab64f115628b2176d325f1b1d0cf7cad8ee9b1c9e1bcc53a240bef2
+  metadata.gz: 320d9bd9482287b375e82cd0d45027b9476e574fefe202f0866c9bbd6130d626a62ab382e619516c74d3076943a20c4594c0e2bd15f195ef1d8873a6af712ace
+  data.tar.gz: 79a6028ffe3c3fd14d098b367c57ac4505a1b8521886e9d47ee73d895b86919f4711c2e256c9da537fc0cf9370a90075d3e6dfff6fb348d8af1f2ac6c0a8c27b

data/exe/graphit

@@ -6,21 +6,39 @@ require 'bin_utils' # For Speed
 require 'optparse'
 
 options = {}
+options[:debug]   = false
+options[:verbose] = false
 OptionParser.new do |opts|
   opts.banner = "Usage: graphit [options] data"
 
+  opts.on("-d", "--[no-]debug", "Debug output") do |d|
+    options[:debug] = d
+  end
+
   opts.on("-v", "--[no-]verbose", "Run verbosely") do |v|
     options[:verbose] = v
   end
   
-  opts.on("--ymin [ymin]", Float) do |ymin|
+  opts.on("-p", "--png", "Convert BMP to PNG. (Requires ImageMagick)") do |png|
+    options[:png] = png
+  end
+  
+  opts.on("--ymin [ymin]", String) do |ymin|
     options[:ymin] = ymin
   end
   
-  opts.on("--ymax [ymax]", Float) do |ymax|
+  opts.on("--ymax [ymax]", String) do |ymax|
     options[:ymax] = ymax
   end
   
+  opts.on("--xmin [xmin]", String) do |xmin|
+    options[:xmin] = xmin
+  end
+  
+  opts.on("--xmax [xmax]", String) do |xmax|
+    options[:xmax] = xmax
+  end
+  
   opts.on("--height [h]", Integer) do |h|
     options[:height] = h
   end
@@ -43,352 +61,63 @@ OptionParser.new do |opts|
   
 end.parse!
 
-options[:outputfile] = "graph.bmp" if options[:outputfile].nil?
-
-@characters = Graphit.pixel_font
-
-@h = options[:height] || 300 
-@w = options[:width]  || 1050
+options[:outputfile] ||= "graph.bmp"
 
-@ymin = options[:ymin] || 40
-@ymax = options[:ymax] || 95
+options[:height] ||= 300 
+options[:width]  ||= 1050
 
-puts "h: #{@h}, w: #{@w}"
-puts "ymin: #{@ymin}, ymax: #{@ymax}"
+options[:ymin] ||= "auto"
+options[:ymax] ||= "auto"
 
-@xmin = 1458621300
-@xmax = 1458770444
+options[:xmin] ||= "auto"
+options[:xmax] ||= "auto"
 
-@bottom_padding = 25
-@top_padding    = 10
-@left_padding   = 100
-@right_padding  = 10
-
-@y_tics_mod = options[:yticsmod] || 10
-@x_tics_mod = options[:xticsmod] || 3600
-
-@graph_width = @w - @left_padding - @right_padding
-@graph_height = @h - @bottom_padding - @top_padding
-
-def recalculate_pixels_per_unit
-  @x_pixels_per_unit = @graph_width.to_f / (@xmax.to_f - @xmin.to_f)
-  @y_pixels_per_unit = @graph_height.to_f / (@ymax.to_f - @ymin.to_f)
-  
-  if @xmax - @xmin < (86400 * 3.5)
-    @x_tics_mod = 3600
-  elsif @xmax - @xmin < (86400 * 7.5)
-    @x_tics_mod = (86400 * 24)
-  elsif @xmax - @xmin < (86400 * 50)
-    @x_tics_mod = (86400 * 24 * 7)
-  elsif @xmax - @xmin < (86400 * 800)
-    @x_tics_mod = (86400 * 24 * 30)
-  else
-    @x_tics_mod = 3600
-  end
-  
-  puts "@x_pixels_per_unit: #{@x_pixels_per_unit}"
-  puts "@y_pixels_per_unit: #{@y_pixels_per_unit}"
+if options[:debug]
+  puts "h: #{@h}, w: #{@w}"
+  puts "ymin: #{@ymin}, ymax: #{@ymax}"
 end
 
-def translate_data_point_to_graph_point( point )
-  #puts "In x: #{point[:x]}, y: #{point[:y]}"
-    
-  if point[:x] < @xmin
-    point[:x] = @xmin
-  elsif point[:x] > @xmax
-    point[:x] = @xmax
-  end
-  
-  if point[:y] < @ymin
-    point[:y] = @ymin
-  elsif point[:y] > @ymax
-    point[:y] = @ymax
-  end
-  
-  #puts "Mid x: #{point[:x]}, y: #{point[:y]}"
-  
-  x = @left_padding + (point[:x] - @xmin) * @x_pixels_per_unit
-  y = @h - @bottom_padding - ((point[:y] - @ymin) * @y_pixels_per_unit)
-  
-  #puts "Out x: #{x}, y: #{y}"
-  
-  return { x: x, y: y }
-end
+options[:bottom_padding] ||= 25
+options[:top_padding]    ||= 10
+options[:left_padding]   ||= 100
+options[:right_padding]  ||= 10
 
-def draw_text( text, px, py, pixels, color )
-  text.each_char do |c|
-    if @characters[c].nil?
-      # skip
-    else
-      @characters[c].each_with_index do |row, y|
-        row.each_with_index do |col, x|
-          if col == 0
-            # Do nothing
-          else
-            thisY = px + x
-            thisX = py + y
-            
-            pixels[thisX][thisY] = color unless pixels[thisX][thisY].nil?
-          end
-        end
-      end
-      
-      px += @characters[c].size + 1
-    end
-  end
-  
-  return pixels
-end
+options[:yticsmod]       ||= 10
+options[:xticsmod]       ||= 3600
 
-def draw_line( x1, y1, x2, y2, pixels, color )
-  len = Math.sqrt( (x2-x1)**2 + (y2 - y1)**2 )
-  
-  d = 0.0
-  
-  while d < 1
-    if x2 == x1
-      x = x1
-    else
-      x = x1 + (x2.to_f-x1.to_f) * d
-    end
-    
-    y = y1 + (y2.to_f-y1.to_f) * d
-    
-    pixels[y.to_i][x.to_i] = color unless pixels[y.to_i][x.to_i].nil?
-    
-    d += 1.0 / ( len.to_f * 2.0 )
-  end
-  
-  return pixels
-end
+options[:data_color]       ||= Graphit::Color.blue_color
+options[:background_color] ||= Graphit::Color.light_light_gray_color
 
-def graph_data( data, pixels, color )
-  
-  # Horizontal Grid lines
-  (@ymin.to_i..@ymax.to_i).each do |y|
-    if y % @y_tics_mod == 0
-      p1 = translate_data_point_to_graph_point( { y: y, x: @xmin } )
-      p2 = translate_data_point_to_graph_point( { y: y, x: @xmax } )
-            
-      pixels = draw_line( p1[:x], p1[:y], p2[:x], p2[:y], pixels, [0xAA,0xAA,0xAA] )
-      
-      # Dunno why 60. Can't figure it out. I'm sure it's because I'm dumb.
-      pixels = draw_text( "#{y}", p1[:x] - (10 * y.to_s.size), p1[:y], pixels, [0x00,0x00,0x00] )
-    end
-  end
-  
-  #Vertical Grid Lines
-  (@xmin..@xmax).each do |x|
-    if x % @x_tics_mod == 0
-      p1 = translate_data_point_to_graph_point( { x: x, y: @ymin } )
-      p2 = translate_data_point_to_graph_point( { x: x, y: @ymax } )
-      
-      #Manual offset for GMT-7
-      if (x + (3600*-7)) % 86400 == 0
-        lcolor = [0x00,0x00,0xFF]
-      else
-        lcolor = [0xAA,0xAA,0xAA]
-      end
-      
-      
-      pixels = draw_line( p1[:x], p1[:y], p2[:x], p2[:y], pixels, lcolor )
-    end
-  end
-  
-  # Graph Outline
-  p1 = translate_data_point_to_graph_point( { x: @xmin, y: @ymin } )
-  p2 = translate_data_point_to_graph_point( { x: @xmax, y: @ymin } )
-  pixels = draw_line( p1[:x], p1[:y], p2[:x], p2[:y], pixels, [0x22,0x22,0x22] )
-  p1 = translate_data_point_to_graph_point( { x: @xmax, y: @ymin } )
-  p2 = translate_data_point_to_graph_point( { x: @xmax, y: @ymax  } )
-  pixels = draw_line( p1[:x], p1[:y], p2[:x], p2[:y], pixels, [0x22,0x22,0x22] )
-  p1 = translate_data_point_to_graph_point( { x: @xmax, y: @ymax } )
-  p2 = translate_data_point_to_graph_point( { x: @xmin, y: @ymax } )
-  pixels = draw_line( p1[:x], p1[:y], p2[:x], p2[:y], pixels, [0x22,0x22,0x22] )
-  p1 = translate_data_point_to_graph_point( { x: @xmin, y: @ymax } )
-  p2 = translate_data_point_to_graph_point( { x: @xmin, y: @ymin } )
-  pixels = draw_line( p1[:x], p1[:y], p2[:x], p2[:y], pixels, [0x22,0x22,0x22] )
-  
-  
-  data.each_with_index do |p, i|
-    data[i] = translate_data_point_to_graph_point( p )
-  end
-  
-  data.each_with_index do |point, i|
-    if i < data.size - 1
-      x1 = point[:x]
-      y1 = point[:y]
-    
-      x2 = data[i+1][:x]
-      y2 = data[i+1][:y]
-      
-      pixels = draw_line( x1, y1, x2, y2, pixels, color )
-    end
-  end
+data_to_graph = []
 
-  pixels
-end
+xmin = 9999999999
+xmax = 0
 
-File.open( options[:outputfile], 'w') do |f|
-  
-  start = Time.now.to_f
-  
-  h = @h
-  w = @w
-  
-  pixels = []
-  (1..h).each do |y|
-    row = []
-    (1..w).each do |x|
-      row.push( [0xEE,0xEE,0xEE] )
-    end
-    pixels.push(row)
-  end
-  
-  puts "Generating pixels: #{Time.now.to_f - start}"
-  
-  # (0..499).each do |n|
-  #
-  #   i = (n/100.0) * (2 * Math::PI)
-  #
-  #   y = 50 + (40 * Math.sin(i))
-  #
-  #   pixels[y][n] = [0x00,0x00,0xFF]
-  # end
-  #
-  # (0..499).each do |n|
-  #
-  #   i = (n/100.0) * (2 * Math::PI)
-  #
-  #   y = 50 + (40 * Math.cos(i))
-  #
-  #   pixels[y][n] = [0xFF,0x00,0x00]
-  # end
+# Expected Input:
+# x y
+ARGF.each_line do |line|
+  # puts line
+  l = line.strip.split(" ")
   
-  # pixels = draw_line( 50, 75, 900, 250, pixels, [0x00,0x00,0xFF] )
-  # pixels = draw_line( 40, 65, 900, 250, pixels, [0x00,0xFF,0xFF] )
-  #
-  # pixels = draw_line( 50, 50, w, 50, pixels, [0xAA,0xAA,0xAA] )
-  # pixels = draw_line( 50, 100, w, 100, pixels, [0xAA,0xAA,0xAA] )
-  # pixels = draw_line( 50, 150, w, 150, pixels, [0xAA,0xAA,0xAA] )
+  next unless l.size == 2
   
-  data_to_graph = []
+  x = l[0].to_i
+  y = l[1].to_f
   
-  @xmin = 9999999999
-  @xmax = 0
-  
-  ARGF.each_line do |line|
-    # puts line
-    l = line.strip.split(":")
-    
-    next unless l.size == 2
-    
-    x = l[0].to_i
-    y = l[1].to_f
-    
-    @xmin = x if x < @xmin
-    @xmax = x if x > @xmax
-    
-    data_to_graph.push( { x: x, y: y } )
-  end
+  xmin = x if x < xmin
+  xmax = x if x > xmax
   
-  puts data_to_graph.size
-  puts "Data points ^"
+  data_to_graph.push( Graphit::Point.new( x, y ) )
+end
 
-  puts "Max: #{@xmax}, Min: #{@xmin}"
-  
-  recalculate_pixels_per_unit
-  
-  # (0..140).each do |n|
-  #   point = { x: n * 10, y: @ymax - rand( @ymax   ).to_i }
-  #   data_to_graph.push( translate_data_point_to_graph_point( point ) )
-  # end
-  
-  graph_data( data_to_graph, pixels, [0xEE,0x00,0x00] )
-  
-  @xmin = @xmax if @xmin > @xmax
-  
-  (@xmin..@xmax).each do |x|
-    
-    if x % 3600 == 0
-      x_offset = translate_data_point_to_graph_point( { x: x, y: 10 } )[:x].to_i
-      
-      h = Time.at(x).hour
-      
-      if h % 2 == 0
-        puts "h: #{h.to_s}, x: #{x_offset}"
-        pixels = draw_text( h.to_s, x_offset, @h - 15, pixels, [0x00,0x00,0x00] )
-      end
-    end
-  end
-  
-  
-  pixel_data = ""
+@graph = Graphit::Graph.new( options, data_to_graph )
 
-  #pixels = [["0000FF", "FFFFFF", "0000FF", "FFFFFF"],
-  #          ["FF0000", "00FF00", "FF0000", "00FF00"] ]
-  
-  height = pixels.size
-  width  = pixels[0].size
-  
-  start = Time.now.to_f
-  
-  pixels.reverse.each_with_index do |row, i|
-    row_bytes = 0
-    row.each do |pixel|
-      
-      BinUtils.append_int8!(pixel_data, pixel[0]) 
-      BinUtils.append_int8!(pixel_data, pixel[1]) 
-      BinUtils.append_int8!(pixel_data, pixel[2]) 
-      
-      #pixel_data += [pixel[0,2].hex].pack( "C" )
-      #pixel_data += [pixel[2,2].hex].pack( "C" )
-      #pixel_data += [pixel[4,2].hex].pack( "C" )
-      
-      row_bytes += 3
-    end
-    
-    # Padding
-    bytes_to_pad = row_bytes % 4
-    
-    # puts "Row: #{i}, bytes: #{row_bytes}, padding: #{bytes_to_pad}"
-    
-    bytes_to_pad.times do
-      BinUtils.append_int8!(pixel_data, 0x00) 
-    end
-  end
-  
-  puts "Generating pixel data string: #{Time.now.to_f - start}"
-  
-  
-  file_size = 54 + pixel_data.size
+puts @graph
 
-  f.print [0x42].pack ("C")
-  f.print [0x4D].pack( "C" )
-  f.print [file_size].pack( "L" )
-  
-  f.print [0x00].pack( "C" ) # Unused
-  f.print [0x00].pack( "C" )
-  f.print [0x00].pack( "C" )
-  f.print [0x00].pack( "C" )
-  
-  f.print [54].pack( "L" ) # Pixel Array Offset
-  
-  f.print [0x28, 0x00, 0x00, 0x00].pack( "L" )  #Number of bytes in the DIB header (from this point)
+@bmp   = Graphit::BmpFile.new( @graph.bitmap_drawing )
 
-  f.print [width].pack( "L" ) #Width of the bitmap in pixels
-  f.print [height].pack( "L" ) #Height
-  
-  f.print [0x01, 0x00].pack( "S" ) # Number of color planes being used
-  f.print [0x18, 0x00].pack( "S" ) # Number of bits per pixel
-  f.print [0x00].pack( "L" ) # BI_RGB, no pixel array compression used
-  f.print [pixel_data.size].pack( "L" ) # Size of the raw bitmap data (including padding)
-  f.print [0x130B].pack( "L" ) #2835 pixels/meter horizontal
-  f.print [0x130B].pack( "L" ) #2835 pixels/meter vertical
-  f.print [0x00].pack( "L" ) # Number of colors in the palette
-  f.print [0x00].pack( "L" ) #0 means all colors are important
-  
-  f.print pixel_data
-end
+@bmp.save_to_file( options[:outputfile] )
 
-`convert #{options[:outputfile]} #{options[:outputfile].gsub('bmp', 'png')}`
+if options[:png]
+  `convert #{options[:outputfile]} #{options[:outputfile].gsub('bmp', 'png')}`
+end

data/lib/graphit.rb

@@ -1 +1,6 @@
 require 'graphit/pixel_font.rb'
+require 'graphit/bmp_file.rb'
+require 'graphit/color.rb'
+require 'graphit/bitmap_drawing.rb'
+require 'graphit/point.rb'
+require 'graphit/graph.rb'

data/lib/graphit/bitmap_drawing.rb

@@ -0,0 +1,82 @@
+module Graphit
+  class BitmapDrawing
+  
+    attr_accessor :pixels
+    
+    def initialize( height, width, background_color = [0x00,0x00,0x00] )
+      background_color = background_color.to_hex_array if background_color.class == Color
+      
+      self.pixels = []
+      (1..height).each do |y|
+        row = []
+        (1..width).each do |x|
+          row.push( background_color )
+        end
+        self.pixels.push(row)
+      end
+    end
+    
+    def height
+      self.pixels.size rescue 0
+    end
+    
+    def width
+      self.pixels[0].size rescue 0
+    end
+    
+    def draw_text( text, point, color = [0x00,0x00,0x00] )
+      @characters = Graphit.pixel_font
+      color = color.to_hex_array if color.class == Color
+      
+      px = point.x
+      
+      text.each_char do |c|
+        if @characters[c].nil?
+          # skip
+        else
+          @characters[c].each_with_index do |row, y|
+            row.each_with_index do |col, x|
+              if col == 0
+                # Do nothing
+              else
+                thisY = px + x
+                thisX = point.y + y
+            
+                self.pixels[thisX][thisY] = color unless pixels[thisX][thisY].nil?
+              end
+            end
+          end
+      
+          px += @characters[c].size + 1
+        end
+      end
+  
+      return self.pixels
+    end
+
+    def draw_line( start_point, end_point, color )
+      color = color.to_hex_array if color.class == Color
+      
+      len = Math.sqrt( (end_point.x-start_point.x)**2 + (end_point.y - start_point.y)**2 )
+  
+      d = 0.0
+  
+      while d < 1
+        if end_point.x == start_point.x
+          x = start_point.x
+        else
+          x = start_point.x + (end_point.x-start_point.x) * d
+        end
+    
+        y = start_point.y + (end_point.y-start_point.y) * d
+    
+        self.pixels[y.to_i][x.to_i] = color unless self.pixels[y.to_i][x.to_i].nil?
+    
+        d += 1.0 / ( len * 2.0 )
+      end
+  
+      return self.pixels
+    end
+  
+  end
+end

data/lib/graphit/bmp_file.rb

@@ -0,0 +1,92 @@
+module Graphit
+  class BmpFile
+    
+    attr_accessor :bitmap_drawing
+    
+    def initialize( bitmap_drawing )
+      self.bitmap_drawing = bitmap_drawing
+    end
+    
+    def save_to_file( filename )
+      File.open( filename, 'w') do |f|
+  
+        start = Time.now.to_f
+  
+        # if options[:debug]
+        #   puts "Generating pixels: #{Time.now.to_f - start}"
+        # end
+  
+        # if options[:debug]
+        #   puts data_to_graph.size
+        #   puts "Data points ^"
+        #   puts "Max: #{@xmax}, Min: #{@xmin}"
+        # end
+  
+  
+        height = self.bitmap_drawing.height
+        width  = self.bitmap_drawing.width
+  
+        start = Time.now.to_f
+
+        pixel_data = ""
+        self.bitmap_drawing.pixels.reverse.each_with_index do |row, i|
+          row_bytes = 0
+          row.each do |pixel|
+            BinUtils.append_int8!(pixel_data, pixel[0]) 
+            BinUtils.append_int8!(pixel_data, pixel[1]) 
+            BinUtils.append_int8!(pixel_data, pixel[2]) 
+      
+            #pixel_data += [pixel[0,2].hex].pack( "C" )
+            #pixel_data += [pixel[2,2].hex].pack( "C" )
+            #pixel_data += [pixel[4,2].hex].pack( "C" )
+      
+            row_bytes += 3
+          end
+    
+          # Padding
+          bytes_to_pad = row_bytes % 4
+    
+          # puts "Row: #{i}, bytes: #{row_bytes}, padding: #{bytes_to_pad}"
+    
+          bytes_to_pad.times do
+            BinUtils.append_int8!(pixel_data, 0x00) 
+          end
+        end
+  
+        # if options[:debug]
+        #   puts "Generating pixel data string: #{Time.now.to_f - start}"
+        # end
+  
+        file_size = 54 + pixel_data.size
+
+        f.print [0x42].pack ("C")
+        f.print [0x4D].pack( "C" )
+        f.print [file_size].pack( "L" )
+  
+        f.print [0x00].pack( "C" ) # Unused
+        f.print [0x00].pack( "C" )
+        f.print [0x00].pack( "C" )
+        f.print [0x00].pack( "C" )
+  
+        f.print [54].pack( "L" ) # Pixel Array Offset
+  
+        f.print [0x28, 0x00, 0x00, 0x00].pack( "L" )  #Number of bytes in the DIB header (from this point)
+
+        f.print [width].pack( "L" ) #Width of the bitmap in pixels
+        f.print [height].pack( "L" ) #Height
+  
+        f.print [0x01, 0x00].pack( "S" ) # Number of color planes being used
+        f.print [0x18, 0x00].pack( "S" ) # Number of bits per pixel
+        f.print [0x00].pack( "L" ) # BI_RGB, no pixel array compression used
+        f.print [pixel_data.size].pack( "L" ) # Size of the raw bitmap data (including padding)
+        f.print [0x130B].pack( "L" ) #2835 pixels/meter horizontal
+        f.print [0x130B].pack( "L" ) #2835 pixels/meter vertical
+        f.print [0x00].pack( "L" ) # Number of colors in the palette
+        f.print [0x00].pack( "L" ) #0 means all colors are important
+  
+        f.print pixel_data
+      end
+    end
+    
+  end
+end

data/lib/graphit/color.rb

@@ -0,0 +1,52 @@
+module Graphit
+  class Color
+    
+    # 0 - 255
+    attr_accessor :red
+    attr_accessor :green
+    attr_accessor :blue
+    
+    def initialize( red, green, blue )
+      self.red   = red
+      self.green = green
+      self.blue  = blue
+    end
+    
+    def to_hex_array
+      [blue,green,red]
+    end
+    
+    def self.light_light_gray_color
+      Graphit::Color.new( 225, 225, 225 )
+    end
+    
+    def self.light_gray_color
+      Graphit::Color.new( 204, 204, 204 )
+    end
+    
+    def self.medium_gray_color
+      Graphit::Color.new( 170, 170, 170 )
+    end
+    
+    def self.white_color
+      Graphit::Color.new( 255, 255, 255 )
+    end
+    
+    def self.black_color
+      Graphit::Color.new( 0, 0, 0 )
+    end
+    
+    def self.red_color
+      Graphit::Color.new( 255, 0, 0 )
+    end
+    
+    def self.blue_color
+      Graphit::Color.new( 0, 0, 255 )
+    end
+    
+    def self.green_color
+      Graphit::Color.new( 0, 255, 0 )
+    end
+    
+  end
+end

data/lib/graphit/graph.rb

@@ -0,0 +1,243 @@
+module Graphit
+  class Graph
+    
+    attr_accessor :bitmap_drawing
+    
+    attr_accessor :graph_data
+    
+    attr_accessor :height, :width
+    attr_accessor :xmin, :xmax, :xticsmod
+    attr_accessor :ymin, :ymax, :yticsmod
+    attr_accessor :background_color 
+    attr_accessor :verbose
+    attr_accessor :debug
+    attr_accessor :left_padding, :right_padding, :top_padding, :bottom_padding
+    attr_accessor :x_pixels_per_unit, :y_pixels_per_unit
+    attr_accessor :data_color
+    
+    def initialize( options, data )
+      
+      options.each do |k,v|
+        if self.respond_to?("#{k}=".to_sym)
+          self.send( "#{k}=".to_sym, v )
+        end
+      end
+      
+      self.graph_data = data
+      
+      recalculate_xmin if xmin.to_s == "auto"
+      recalculate_xmax if xmax.to_s == "auto"
+      recalculate_ymin if ymin.to_s == "auto"
+      recalculate_ymax if ymax.to_s == "auto"
+      
+      # Ensure floats
+      self.xmin = self.xmin.to_f
+      self.xmax = self.xmax.to_f
+      self.ymin = self.ymin.to_f
+      self.ymax = self.ymax.to_f
+      
+      recalculate_pixels_per_unit      
+            
+      puts "BGColor: #{options[:background_color]}"
+            
+      self.bitmap_drawing = BitmapDrawing.new( options[:height], options[:width], options[:background_color] )
+    
+      draw_horizontal_gridlines
+      draw_vertical_gridlines
+      draw_graph_outline
+      draw_xaxis_labels
+    
+      draw_graph( data )
+    end
+    
+    def to_s
+      s = super
+      s += "\n"
+      s += "  Height: #{height}, Width: #{width}\n"
+      s += "  Xmin: #{xmin}, Xmax: #{xmax}, Xticsmod: #{xticsmod}\n"
+      s += "  Ymin: #{ymin}, Ymax: #{ymax}, Yticsmod: #{yticsmod}\n"
+      s
+    end
+    
+    def recalculate_xmin
+      puts "recalculate_xmin" if self.debug
+      
+      self.xmin = self.graph_data.min_by{ |p| p.x.to_f }.x
+      
+      puts "  xmin: #{self.xmin}" if self.debug
+      
+      self.xmin
+    end
+    
+    def recalculate_xmax
+      puts "recalculate_xmax" if self.debug
+      
+      self.xmax = self.graph_data.max_by{ |p| p.x.to_f }.x
+      
+      puts "  xmax: #{self.xmax}" if self.debug
+      
+      self.xmax
+    end
+    
+    def recalculate_ymin
+      puts "recalculate_ymin" if self.debug
+      
+      self.ymin = self.graph_data.min_by{ |p| p.y.to_f }.y
+    end
+    
+    def recalculate_ymax
+      puts "recalculate_ymax" if self.debug
+      
+      self.ymax = self.graph_data.max_by{ |p| p.y.to_f }.y
+    end
+    
+    def graph_width
+      width - left_padding - right_padding
+    end
+    
+    def graph_height
+      height - bottom_padding - top_padding
+    end
+    
+    def recalculate_pixels_per_unit
+      self.x_pixels_per_unit = graph_width / (xmax.to_f - xmin.to_f)
+      self.y_pixels_per_unit = graph_height / (ymax.to_f - ymin.to_f)
+  
+      if xmax - xmin < (86400 * 3.5)
+        self.xticsmod = 3600
+      elsif xmax - xmin < (86400 * 7.5)
+        self.xticsmod = (86400 * 24)
+      elsif xmax - xmin < (86400 * 50)
+        self.xticsmod = (86400 * 24 * 7)
+      elsif xmax - xmin < (86400 * 800)
+        self.xticsmod = (86400 * 24 * 30)
+      else
+        self.xticsmod = 3600
+      end
+  
+      # if options[:debug]
+      #   puts "@x_pixels_per_unit: #{@x_pixels_per_unit}"
+      #   puts "@y_pixels_per_unit: #{@y_pixels_per_unit}"
+      # end
+    end
+    
+    def draw_graph( data )
+      self.graph_data = data
+      
+      recalculate_pixels_per_unit
+      
+      data.each_with_index do |p, i|
+        data[i] = translate_data_point_to_graph_point( p )
+      end
+  
+      data.each_with_index do |point, i|
+        if i < data.size - 1
+          x1 = point.x
+          y1 = point.y
+    
+          x2 = data[i+1].x
+          y2 = data[i+1].y
+      
+          self.bitmap_drawing.draw_line( Point.new( x1, y1 ), Point.new( x2, y2), self.data_color )
+        end
+      end
+    end
+    
+    def draw_horizontal_gridlines
+      (self.ymin.to_i..self.ymax.to_i).each do |y|
+        if y % self.yticsmod == 0
+          p1 = translate_data_point_to_graph_point( Point.new( self.xmin, y ) )
+          p2 = translate_data_point_to_graph_point( Point.new( self.xmax, y ) )
+            
+          self.bitmap_drawing.draw_line( Point.new( p1.x, p1.y ), Point.new( p2.x, p2.y ), [0xAA,0xAA,0xAA] )
+      
+          self.bitmap_drawing.draw_text( "#{y}", Point.new( p1.x - (10 * y.to_s.size), p1.y ), [0x00,0x00,0x00] )
+        end
+      end
+    end
+    
+    def draw_vertical_gridlines
+      (self.xmin.to_i..self.xmax.to_i).each do |x|
+        if x % self.xticsmod == 0
+          p1 = translate_data_point_to_graph_point( Point.new( x, self.ymin ) )
+          p2 = translate_data_point_to_graph_point( Point.new( x, self.ymax ) )
+      
+          #Manual offset for GMT-7
+          if (x + (3600*-7)) % 86400 == 0
+            lcolor = [0x00,0x00,0xFF]
+          else
+            lcolor = [0xAA,0xAA,0xAA]
+          end
+      
+      
+          self.bitmap_drawing.draw_line( Point.new( p1.x, p1.y ), Point.new( p2.x, p2.y ), lcolor )
+        end
+      end
+    end
+    
+    def draw_graph_outline
+      p1 = translate_data_point_to_graph_point( Point.new( self.xmin, self.ymin ) )
+      p2 = translate_data_point_to_graph_point( Point.new( self.xmax, self.ymin ) )
+      self.bitmap_drawing.draw_line( Point.new( p1.x, p1.y ), Point.new( p2.x, p2.y ), [0x22,0x22,0x22] )
+      
+      p1 = translate_data_point_to_graph_point( Point.new( self.xmax, self.ymin ) )
+      p2 = translate_data_point_to_graph_point( Point.new( self.xmax, self.ymax ) )
+      self.bitmap_drawing.draw_line( Point.new( p1.x, p1.y ), Point.new( p2.x, p2.y ), [0x22,0x22,0x22] )
+      
+      p1 = translate_data_point_to_graph_point( Point.new( self.xmax, self.ymax ) )
+      p2 = translate_data_point_to_graph_point( Point.new( self.xmin, self.ymax ) )
+      self.bitmap_drawing.draw_line( Point.new( p1.x, p1.y ), Point.new( p2.x, p2.y ), [0x22,0x22,0x22] )
+      
+      p1 = translate_data_point_to_graph_point( Point.new( self.xmin, self.ymax ) )
+      p2 = translate_data_point_to_graph_point( Point.new( self.xmin, self.ymin ) )
+      self.bitmap_drawing.draw_line( Point.new( p1.x, p1.y ), Point.new( p2.x, p2.y ), [0x22,0x22,0x22] )
+    end
+    
+    def draw_xaxis_labels
+      (self.xmin.to_i..self.xmax.to_i).each do |x|
+  
+        if x % 3600 == 0
+          x_offset = translate_data_point_to_graph_point( Point.new( x, 10 ) ).x.to_i
+    
+          h = Time.at(x).hour
+    
+          if h % 2 == 0
+            if self.debug
+              puts "h: #{h.to_s}, x: #{x_offset}"
+            end
+            self.bitmap_drawing.draw_text( h.to_s, Point.new( x_offset, self.height - 15 ), [0x00,0x00,0x00] )
+          end
+        end
+      end
+    end
+    
+    def draw_yaxis_labels
+      # Currently happening in the y gridlines method
+    end
+    
+    def translate_data_point_to_graph_point( point )
+    
+      if point.x < self.xmin
+        point.x = self.xmin
+      elsif point.x > self.xmax
+        point.x = self.xmax
+      end
+  
+      if point.y < self.ymin
+        point.y = self.ymin
+      elsif point.y > self.ymax
+        point.y = self.ymax
+      end
+  
+      #puts "Mid x: #{point.x}, y: #{point.y}"
+  
+      x = self.left_padding + (point.x - self.xmin) * self.x_pixels_per_unit
+      y = self.height - self.bottom_padding - ((point.y - self.ymin) * self.y_pixels_per_unit)
+  
+      #puts "Out x: #{x}, y: #{y}"
+  
+      return Point.new( x, y )
+    end
+    
+  end
+end

data/lib/graphit/point.rb

@@ -0,0 +1,11 @@
+module Graphit
+  class Point
+    attr_accessor :x
+    attr_accessor :y
+    
+    def initialize( x, y )
+      self.x = x.to_f
+      self.y = y.to_f
+    end
+  end
+end

data/lib/graphit/version.rb

@@ -1,3 +1,3 @@
 module Graphit
-  VERSION = "0.0.6"
+  VERSION = "0.1.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphit
 version: !ruby/object:Gem::Version
-  version: 0.0.6
+  version: 0.1.1
 platform: ruby
 authors:
 - jeffmcfadden
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-03-28 00:00:00.000000000 Z
+date: 2016-03-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bin_utils
@@ -72,7 +72,12 @@ files:
 - graphit.gemspec
 - graphit/version.rb
 - lib/graphit.rb
+- lib/graphit/bitmap_drawing.rb
+- lib/graphit/bmp_file.rb
+- lib/graphit/color.rb
+- lib/graphit/graph.rb
 - lib/graphit/pixel_font.rb
+- lib/graphit/point.rb
 - lib/graphit/version.rb
 - test-01.bmp
 - test-01.png