oshpark-rqrcode 0.10.1

data/lib/rqrcode/export/gerber.rb

@@ -0,0 +1,93 @@
+module RQRCode
+  module Export
+    module Gerber
+      attr_accessor :positive, :precision, :pixel_width, :x_origin, :y_origin, :quiet_zone_size, :mirrored
+      ##
+      # Returns a string of the QR code as
+      # characters writen with ANSI background set.
+      # 
+      # Options: 
+      # light: Foreground ("\033[47m")
+      # dark: Background ANSI code. ("\033[47m")
+      # fill_character: The written character. ('  ')
+      # quiet_zone_size: (4)
+      #
+      def flash(x,y)
+        top_y = (@y_origin + @module_count + (@quiet_zone_size *2 )) * @pixel_width
+        y = top_y - (y * @pixel_width)
+        if @mirrored then
+          right_x = (@x_origin + @module_count + (@quiet_zone_size*2)) * @pixel_width
+          x = right_x - (x * @pixel_width)
+        else
+          x = @x_origin + x * @pixel_width
+        end
+        #puts "FLASH #{x} #{y}"
+        y = (y * @p_mult).to_i
+        x = (x * @p_mult).to_i
+        return "G01X#{x}Y#{y}D03*\n"
+      end
+
+      def is_light(x,y)
+        ! is_dark(x,y)
+      end
+
+      def as_gerber(options={})
+        options = {
+          precision: 6,
+          pixel_width: 0.010, # inches
+          x_origin: 0.000, # inches
+          y_origin: 0.000, # inches
+          quiet_zone_size: 1,
+          mirrored: false
+        }.merge(options)
+        @x_origin = options.fetch(:x_origin)
+        @y_origin = options.fetch(:y_origin)
+        @precision = options.fetch(:precision)
+        @pixel_width = options.fetch(:pixel_width)
+        @quiet_zone_size = options.fetch(:quiet_zone_size)
+        @mirrored = options.fetch(:mirrored)
+
+        @p_mult = 10**options[:precision]
+
+        output=<<-EOF
+G04 This is an RQRCode Generated gerber file.*
+G04 --End of header info--*
+%MOIN*%
+%FSLAX3#{options[:precision]}Y3#{options[:precision]}*%
+%IPPOS*%
+%ADD10R,#{options[:pixel_width]}X#{options[:pixel_width]}*%
+G04 --Start main section--*
+G54D10*
+        EOF
+
+        quiet_zone_size = options.fetch(:quiet_zone_size)
+
+        width = quiet_zone_size + @module_count + quiet_zone_size
+
+        quiet_zone_size.times do |r|
+          width.times do |c|
+            output << flash(c,r) ## Top Quiet Zone
+            output << flash(r,c) ## Left Quiet Zone
+            output << flash(r+quiet_zone_size+@module_count,c)
+            output << flash(c,r+quiet_zone_size+@module_count)
+          end
+        end
+
+
+        @modules.each_index do |r|
+          @modules[r].each_index do |c|
+            if is_light(r, c)
+              output << flash(quiet_zone_size+c,quiet_zone_size+r)
+            end
+          end
+        end
+
+        output << "M02*\n"
+
+        return output
+      end
+    end
+  end
+end
+
+RQRCode::QRCode.send :include, RQRCode::Export::Gerber

data/lib/rqrcode/export/html.rb

@@ -0,0 +1,53 @@
+# Use this module to HTML-ify the QR code if you just want the default HTML
+module RQRCode
+  module Export
+    module HTML
+
+      def as_html
+        ['<table>', rows.as_html, '</table>'].join
+      end
+
+      private
+
+      def rows
+        Rows.new(self)
+      end
+
+      class Rows < Struct.new(:qr)
+        def as_html
+          rows.map(&:as_html).join
+        end
+
+        def rows
+          qr.modules.each_with_index.map { |qr_module, row_index| Row.new(qr, qr_module, row_index) }
+        end
+      end
+
+      class Row < Struct.new(:qr, :qr_module, :row_index)
+        def as_html
+          ['<tr>', cells.map(&:as_html).join, '</tr>'].join
+        end
+
+        def cells
+          qr.modules.each_with_index.map { |qr_module, col_index| Cell.new(qr, col_index, row_index) }
+        end
+      end
+
+      class Cell < Struct.new(:qr, :col_index, :row_index)
+        def as_html
+          "<td class=\"#{html_class}\"></td>"
+        end
+
+        def html_class
+          dark? ? 'black' : 'white'
+        end
+
+        def dark?
+          qr.dark?(row_index, col_index)
+        end
+      end
+    end
+  end
+end
+
+RQRCode::QRCode.send :include, RQRCode::Export::HTML

data/lib/rqrcode/export/png.rb

@@ -0,0 +1,117 @@
+require 'chunky_png'
+
+# This class creates PNG files.
+# Code from: https://github.com/DCarper/rqrcode
+module RQRCode
+  module Export
+    module PNG
+
+      # Render the PNG from the Qrcode.
+      #
+      # There are two sizing algoritams.
+      #
+      # - Original that can result in blurry and hard to scan images
+      # - Google's Chart API inspired sizing that resizes the module size to fit within the given image size.
+      # 
+      # The Googleis one will be used when no options are given or when the new size option is used.
+      #
+      # Options: 
+      # fill  - Background ChunkyPNG::Color, defaults to 'white'
+      # color - Foreground ChunkyPNG::Color, defaults to 'black'
+      #
+      # *Googleis*    
+      # size            - Total size of PNG in pixels. The module size is calculated so it fits. (defaults to 90)
+      # border_modules  - Width of white border around in modules. (defaults to 4).
+      #
+      #  -- DONT USE border_modules OPTION UNLESS YOU KNOW ABOUT THE QUIET ZONE NEEDS OF QR CODES --
+      #
+      # *Original*
+      # module_px_size  - Image size, in pixels.
+      # border - Border thickness, in pixels
+      #
+      # It first creates an image where 1px = 1 module, then resizes.
+      # Defaults to 90x90 pixels, customizable by option.
+      #
+      def as_png(options = {})
+
+        default_img_options = {
+          :resize_gte_to => false,
+          :resize_exactly_to => false,
+          :fill => 'white',
+          :color => 'black',
+          :size => 120,
+          :border_modules => 4,
+          :file => false,
+          :module_px_size => 6
+        }
+        
+        googleis = options.length == 0 || (options[:size] != nil)
+        
+        options = default_img_options.merge(options) # reverse_merge
+
+        fill   = ChunkyPNG::Color(options[:fill])
+        color  = ChunkyPNG::Color(options[:color])
+        output_file = options[:file]
+        
+        module_px_size = nil
+        border_px = nil
+        png = nil
+        
+        if googleis
+          total_image_size = options[:size]
+          border_modules = options[:border_modules]
+
+          module_px_size = (total_image_size.to_f / (self.module_count + 2 * border_modules).to_f).floor.to_i
+
+          img_size = module_px_size * self.module_count
+
+          remaining = total_image_size - img_size
+          border_px = (remaining / 2.0).floor.to_i
+
+          png = ChunkyPNG::Image.new(total_image_size, total_image_size, fill)
+        else
+          border = options[:border_modules]
+          total_border = border * 2
+          module_px_size = if options[:resize_gte_to]
+            (options[:resize_gte_to].to_f / (self.module_count + total_border).to_f).ceil.to_i
+          else
+            options[:module_px_size]
+          end
+          border_px = border *  module_px_size
+          total_border_px = border_px * 2
+          resize_to = options[:resize_exactly_to]
+
+          img_size = module_px_size * self.module_count
+          total_img_size = img_size + total_border_px
+
+          png = ChunkyPNG::Image.new(total_img_size, total_img_size, fill)
+        end
+
+        self.modules.each_index do |x|
+          self.modules.each_index do |y|
+            if self.dark?(x, y)
+              (0...module_px_size).each do |i|
+                (0...module_px_size).each do |j|
+                  png[(y * module_px_size) + border_px + j , (x * module_px_size) + border_px + i] = color
+                end
+              end
+            end
+          end
+        end
+        
+        if !googleis && resize_to
+          png = png.resize(resize_to, resize_to)  
+        end
+
+
+        if output_file
+          png.save(output_file,{ :color_mode => ChunkyPNG::COLOR_GRAYSCALE, :bit_depth =>1})
+        end
+        png
+      end
+
+    end
+  end
+end
+
+RQRCode::QRCode.send :include, RQRCode::Export::PNG

data/lib/rqrcode/export/svg.rb

@@ -0,0 +1,53 @@
+# This class creates a SVG files.
+# Code from: https://github.com/samvincent/rqrcode-rails3
+module RQRCode
+  module Export
+
+    module SVG
+
+      # Render the SVG from the Qrcode.
+      #
+      # Options:
+      # offset - Padding around the QR Code (e.g. 10)
+      # fill - Background color (e.g "ffffff" or :white)
+      # color - Foreground color for the code (e.g. "000000" or :black)
+      # module_size - The Pixel size of each module (e.g. 11)
+      # shape_rendering - Defaults to crispEdges
+      #
+      def as_svg(options={})
+        offset = options[:offset].to_i || 0
+        color = options[:color] || "000"
+        shape_rendering = options[:shape_rendering] || "crispEdges"
+        module_size = options[:module_size] || 11
+
+        # height and width dependent on offset and QR complexity
+        dimension = (self.module_count*module_size) + (2*offset)
+
+        xml_tag = %{<?xml version="1.0" standalone="yes"?>}
+        open_tag = %{<svg version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:ev="http://www.w3.org/2001/xml-events" width="#{dimension}" height="#{dimension}" shape-rendering="#{shape_rendering}">}
+        close_tag = "</svg>"
+
+        result = []
+        self.modules.each_index do |c|
+          tmp = []
+          self.modules.each_index do |r|
+            y = c*module_size + offset
+            x = r*module_size + offset
+
+            next unless self.is_dark(c, r)
+            tmp << %{<rect width="#{module_size}" height="#{module_size}" x="#{x}" y="#{y}" style="fill:##{color}"/>}
+          end
+          result << tmp.join
+        end
+
+        if options[:fill]
+          result.unshift %{<rect width="#{dimension}" height="#{dimension}" x="0" y="0" style="fill:##{options[:fill]}"/>}
+        end
+
+        [xml_tag, open_tag, result, close_tag].flatten.join("\n")
+      end
+    end
+  end
+end
+
+RQRCode::QRCode.send :include, RQRCode::Export::SVG

data/lib/rqrcode/qrcode.rb

@@ -0,0 +1,4 @@
+Dir[File.dirname(__FILE__) + "/qrcode/*.rb"].sort.each do |path|
+  filename = File.basename(path)
+  require "rqrcode/qrcode/#{filename}"
+end

data/lib/rqrcode/qrcode/qr_8bit_byte.rb

@@ -0,0 +1,36 @@
+#!/usr/bin/env ruby
+
+#--
+# Copyright 2004 by Duncan Robertson (duncan@whomwah.com).
+# All rights reserved.
+
+# Permission is granted for use, copying, modification, distribution,
+# and distribution of modified versions of this work as long as the
+# above copyright notice is included.
+#++
+
+module RQRCode
+
+  class QR8bitByte
+    attr_reader :mode
+
+    def initialize( data )
+      @mode = QRMODE[:mode_8bit_byte]
+      @data = data;
+    end
+
+
+    def get_length
+      @data.bytesize
+    end
+
+
+    def write( buffer)
+      buffer.byte_encoding_start(get_length)
+      @data.each_byte do |b|
+        buffer.put(b, 8)
+      end
+    end
+  end
+
+end

data/lib/rqrcode/qrcode/qr_alphanumeric.rb

@@ -0,0 +1,47 @@
+module RQRCode
+
+  ALPHANUMERIC = ['0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z',' ','$','%','*','+','-','.','/',':']
+
+  class QRAlphanumeric
+    attr_reader :mode
+
+    def initialize( data )
+      @mode = QRMODE[:mode_alpha_numk]
+
+      raise QRCodeArgumentError, "Not a alpha numeric uppercase string `#{data}`" unless QRAlphanumeric.valid_data?(data)
+
+      @data = data;
+    end
+
+
+    def get_length
+      @data.size
+    end
+
+    def self.valid_data? data
+      data.each_char do |s|
+        return false if ALPHANUMERIC.index(s).nil?
+      end
+      true
+    end
+
+
+    def write( buffer)
+      buffer.alphanumeric_encoding_start(get_length)
+
+      (@data.size).times do |i|
+        if i % 2 == 0
+          if i == (@data.size - 1)
+            value = ALPHANUMERIC.index(@data[i])
+            buffer.put( value, 6 )
+          else
+            value = (ALPHANUMERIC.index(@data[i]) * 45) + ALPHANUMERIC.index(@data[i+1])
+            buffer.put( value, 11 )
+          end
+        end
+      end
+
+
+    end
+  end
+end

data/lib/rqrcode/qrcode/qr_bit_buffer.rb

@@ -0,0 +1,99 @@
+#!/usr/bin/env ruby
+
+#--
+# Copyright 2004 by Duncan Robertson (duncan@whomwah.com).
+# All rights reserved.
+
+# Permission is granted for use, copying, modification, distribution,
+# and distribution of modified versions of this work as long as the
+# above copyright notice is included.
+#++
+
+module RQRCode
+
+  class QRBitBuffer
+    attr_reader :buffer
+
+    PAD0 = 0xEC
+    PAD1 = 0x11
+
+    def initialize(version)
+      @version = version
+      @buffer = []
+      @length = 0
+    end
+
+
+    def get( index )
+      buf_index = (index / 8).floor
+      (( (@buffer[buf_index]).rszf(7 - index % 8)) & 1) == 1
+    end
+
+
+    def put( num, length )
+      ( 0...length ).each do |i|
+        put_bit((((num).rszf(length - i - 1)) & 1) == 1)
+      end
+    end
+
+
+    def get_length_in_bits
+      @length
+    end
+
+
+    def put_bit( bit )
+      buf_index = ( @length / 8 ).floor
+      if @buffer.size <= buf_index
+        @buffer << 0
+      end
+
+      if bit
+        @buffer[buf_index] |= ((0x80).rszf(@length % 8))
+      end
+
+      @length += 1
+    end 
+    
+    def byte_encoding_start(length)
+      
+      put( QRMODE[:mode_8bit_byte], 4 )
+      put(length, QRUtil.get_length_in_bits(QRMODE[:mode_8bit_byte], @version))
+      
+    end
+    
+    def alphanumeric_encoding_start(length)
+      
+      put( QRMODE[:mode_alpha_numk], 4 )
+      put(length, QRUtil.get_length_in_bits(QRMODE[:mode_alpha_numk], @version))
+      
+    end
+
+    def numeric_encoding_start(length)
+      
+      put( QRMODE[:mode_number], 4 )
+      put(length, QRUtil.get_length_in_bits(QRMODE[:mode_number], @version))
+      
+    end
+    
+    def pad_until(prefered_size)
+      # Align on byte
+      while get_length_in_bits % 8 != 0
+        put_bit( false )
+      end
+      
+      # Pad with padding code words
+      while get_length_in_bits < prefered_size
+        put( QRBitBuffer::PAD0, 8 )
+        put( QRBitBuffer::PAD1, 8 ) if get_length_in_bits < prefered_size
+      end
+    end
+    
+    def end_of_message(max_data_bits)
+      put( 0, 4 ) unless get_length_in_bits+4 > max_data_bits
+    end
+      
+
+  end
+
+end