snowy 0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 88efa9809a87f18c9a1a0cac09ac97cad8b79517
+  data.tar.gz: 297a08a7dd949d0da1bc7082c4da98c697de0f56
+SHA512:
+  metadata.gz: 87702bc961ce392404cad01d2ce482c1fe6c30ecad2cbe8c3739fd695c785d84288c078da64c3d699ce607c12438ffe0460900238f54db4303f2650ca330543c
+  data.tar.gz: 72e89848974cb49e0e750a9d8bff96986428ee2954fde7c0bff10133d96d6f57fa2f6230dab63311fd0abbcef1df51c6965bab8c68682a108771b9b8ea779de2

data/LICENSE

@@ -0,0 +1,24 @@
+Copyright (c) 2016, dearblue. All rights reserved.
+
+Redistribution and use in source and binary forms, with or
+without modification, are permitted provided that the following
+conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright
+    notice, this list of conditions and the following disclaimer.
+ 2. Redistributions in binary form must reproduce the above copyright
+    notice, this list of conditions and the following disclaimer in
+    the documentation and/or other materials provided with the
+    distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.md

@@ -0,0 +1,41 @@
+# snowy
+
+"snowy" is an identicon implements with the snow crystal motif.
+
+  * package name: snowy
+  * version: 0.1
+  * software quality: EXPERIMENTAL
+  * license: BSD-2-clause License
+  * author: dearblue <dearblue@users.noreply.github.com>
+  * report issue to: <https://github.com/dearblue/ruby-snowy/issues/>
+  * dependency ruby: ruby-2.1+
+  * dependency ruby gems: (none)
+  * dependency library: (none)
+  * bundled external C library: (none)
+
+![snowy demonstration](snowy-demo.png)
+
+
+
+## How to usage
+
+``` ruby:ruby
+require "snowy"
+require "zlib"
+
+str = "abcdefg"
+salt = 0
+id = Zlib.crc32(str, salt) # transcode to 32-bits integer
+pngdata = Snowy.generate_to_png(id, size: 256)
+File.binwrite("snowy.png", pngdata)
+```
+
+
+## Demonstration with web browser
+
+``` shell
+$ gem install sinatra haml
+$ ruby snowy-demo.rb
+```
+
+And, access to http://localhost:4567/ on web browser.

data/Rakefile

@@ -0,0 +1,212 @@
+
+require "pathname"
+require "rake/clean"
+
+docnames = "{README,LICENSE,CHANGELOG,Changelog,HISTORY}"
+doctypes = "{,.txt,.rd,.rdoc,.md,.markdown}"
+cexttypes = "{c,C,cc,cxx,cpp,h,H,hh}"
+
+DOC = FileList["#{docnames}{,.ja}#{doctypes}"] +
+      FileList["{contrib,ext}/**/#{docnames}{,.ja}#{doctypes}"] +
+      FileList["ext/**/*.#{cexttypes}"]
+EXT = FileList["ext/**/*"]
+BIN = FileList["bin/*"]
+LIB = FileList["lib/**/*.rb"]
+SPEC = FileList["spec/**/*"]
+TEST = FileList["test/**/*"]
+EXAMPLE = FileList["examples/**/*"]
+GEMSTUB_SRC = "gemstub.rb"
+RAKEFILE = [File.basename(__FILE__), GEMSTUB_SRC]
+EXTRA = []
+EXTCONF = FileList["ext/**/extconf.rb"]
+EXTCONF.reject! { |n| !File.file?(n) }
+EXTMAP = {}
+
+load GEMSTUB_SRC
+
+EXTMAP.dup.each_pair do |dir, name|
+  EXTMAP[Pathname.new(dir).cleanpath.to_s] = Pathname.new(name).cleanpath.to_s
+end
+
+GEMSTUB.extensions += EXTCONF
+GEMSTUB.executables += FileList["bin/*"].map { |n| File.basename n }
+GEMSTUB.executables.sort!
+
+PACKAGENAME = "#{GEMSTUB.name}-#{GEMSTUB.version}"
+GEMFILE = "#{PACKAGENAME}.gem"
+GEMSPEC = "#{PACKAGENAME}.gemspec"
+
+GEMSTUB.files += DOC + EXT + EXTCONF + BIN + LIB + SPEC + TEST + EXAMPLE + RAKEFILE + EXTRA
+GEMSTUB.files.sort!
+if GEMSTUB.rdoc_options.nil? || GEMSTUB.rdoc_options.empty?
+  readme = %W(.md .markdown .rd .rdoc .txt #{""}).map { |ext| "README#{ext}" }.find { |m| DOC.find { |n| n == m } }
+  GEMSTUB.rdoc_options = %w(--charset UTF-8) + (readme ? %W(-m #{readme}) : [])
+end
+GEMSTUB.extra_rdoc_files += DOC + LIB + EXT.reject { |n| n.include?("/externals/") || !%w(.h .hh .c .cc .cpp .cxx).include?(File.extname(n)) }
+GEMSTUB.extra_rdoc_files.sort!
+
+GEMSTUB_TRYOUT = GEMSTUB.dup
+GEMSTUB_TRYOUT.version = "#{GEMSTUB.version}#{Time.now.strftime(".TRYOUT.%Y%m%d.%H%M%S")}"
+PACKAGENAME_TRYOUT = "#{GEMSTUB.name}-#{GEMSTUB_TRYOUT.version}"
+GEMFILE_TRYOUT = "#{PACKAGENAME_TRYOUT}.gem"
+GEMSPEC_TRYOUT = "#{PACKAGENAME_TRYOUT}.gemspec"
+
+CLEAN << GEMSPEC << GEMSPEC_TRYOUT
+CLOBBER << GEMFILE
+
+task :default => :tryout do
+  $stderr.puts <<-EOS
+#{__FILE__}:#{__LINE__}:
+\ttype ``rake release'' to build release package.
+  EOS
+end
+
+desc "build tryout package"
+task :tryout
+
+desc "build release package"
+task :release => :all
+
+unless EXTCONF.empty?
+  RUBYSET ||= (ENV["RUBYSET"] || "").split(",")
+
+  if RUBYSET.nil? || RUBYSET.empty?
+    $stderr.puts <<-EOS
+#{__FILE__}:
+|
+| If you want binary gem package, launch rake with ``RUBYSET`` enviroment
+| variable for set ruby interpreters by comma separated.
+|
+|   e.g.) $ rake RUBYSET=ruby
+|     or) $ rake RUBYSET=ruby21,ruby22,ruby23
+|
+    EOS
+  else
+    platforms = RUBYSET.map { |ruby| `#{ruby} --disable-gems -e "puts RUBY_PLATFORM"`.chomp }
+    platforms1 = platforms.uniq
+    unless platforms1.size == 1 && !platforms1[0].empty?
+      abort <<-EOS
+#{__FILE__}:#{__LINE__}: different platforms:
+#{RUBYSET.zip(platforms).map { |ruby, platform| "%24s => %s" % [ruby, platform] }.join("\n")}
+ABORTED.
+      EOS
+    end
+    PLATFORM = platforms1[0]
+
+    RUBY_VERSIONS = RUBYSET.map do |ruby|
+      ver = `#{ruby} --disable-gems -e "puts RUBY_VERSION"`.slice(/\d+\.\d+/)
+      raise "failed ruby checking - ``#{ruby}''" unless $?.success?
+      [ver, ruby]
+    end
+
+    SOFILES_SET = RUBY_VERSIONS.map { |(ver, ruby)|
+      EXTCONF.map { |extconf|
+        extdir = Pathname.new(extconf).cleanpath.dirname.to_s
+        case
+        when soname = EXTMAP[extdir.sub(/^ext\//i, "")]
+          soname = soname.sub(/\.so$/i, "")
+        when extdir == "ext" || extdir == "."
+          soname = GEMSTUB.name
+        else
+          soname = File.basename(extdir)
+        end
+
+        [ruby, File.join("lib", "#{soname.sub(/(?<=\/)|^(?!.*\/)/, "#{ver}/")}.so"), extconf]
+      }
+    }.flatten(1)
+    SOFILES = SOFILES_SET.map { |(ruby, sopath, extconf)| sopath }
+
+    GEMSTUB_NATIVE = GEMSTUB.dup
+    GEMSTUB_NATIVE.files += SOFILES
+    GEMSTUB_NATIVE.platform = Gem::Platform.new(PLATFORM).to_s
+    GEMSTUB_NATIVE.extensions.clear
+    GEMFILE_NATIVE = "#{GEMSTUB_NATIVE.name}-#{GEMSTUB_NATIVE.version}-#{GEMSTUB_NATIVE.platform}.gem"
+    GEMSPEC_NATIVE = "#{GEMSTUB_NATIVE.name}-#{GEMSTUB_NATIVE.platform}.gemspec"
+
+    task :all => ["native-gem", GEMFILE]
+
+    desc "build binary gem package"
+    task "native-gem" => GEMFILE_NATIVE
+
+    desc "generate binary gemspec"
+    task "native-gemspec" => GEMSPEC_NATIVE
+
+    file GEMFILE_NATIVE => DOC + EXT + EXTCONF + BIN + LIB + SPEC + TEST + EXAMPLE + SOFILES + RAKEFILE + [GEMSPEC_NATIVE] do
+      sh "gem build #{GEMSPEC_NATIVE}"
+    end
+
+    file GEMSPEC_NATIVE => RAKEFILE do
+      File.write(GEMSPEC_NATIVE, GEMSTUB_NATIVE.to_ruby, mode: "wb")
+    end
+
+    desc "build c-extension libraries"
+    task "sofiles" => SOFILES
+
+    SOFILES_SET.each do |(ruby, soname, extconf)|
+      sodir = File.dirname(soname)
+      makefile = File.join(sodir, "Makefile")
+
+      CLEAN << GEMSPEC_NATIVE << sodir
+      CLOBBER << GEMFILE_NATIVE
+
+      directory sodir
+
+      desc "generate Makefile for binary extension library"
+      file makefile => [sodir, extconf] do
+        rel_extconf = Pathname.new(extconf).relative_path_from(Pathname.new(sodir)).to_s
+        cd sodir do
+          sh *%W"#{ruby} #{rel_extconf} --ruby=#{ruby} #{ENV["EXTCONF"]}"
+        end
+      end
+
+      desc "build binary extension library"
+      file soname => [makefile] + EXT do
+        cd sodir do
+          sh "make"
+        end
+      end
+    end
+  end
+end
+
+
+task :all => GEMFILE
+task :tryout => GEMFILE_TRYOUT
+
+desc "generate local rdoc"
+task :rdoc => DOC + LIB do
+  sh *(%w(rdoc) + GEMSTUB.rdoc_options + DOC + LIB)
+end
+
+desc "launch rspec"
+task rspec: :all do
+  sh "rspec"
+end
+
+desc "build gem package"
+task gem: GEMFILE
+
+desc "generate gemspec"
+task gemspec: GEMSPEC
+
+desc "print package name"
+task "package-name" do
+  puts PACKAGENAME
+end
+
+file GEMFILE => DOC + EXT + EXTCONF + BIN + LIB + SPEC + TEST + EXAMPLE + RAKEFILE + [GEMSPEC] do
+  sh "gem build #{GEMSPEC}"
+end
+
+file GEMFILE_TRYOUT => DOC + EXT + EXTCONF + BIN + LIB + SPEC + TEST + EXAMPLE + RAKEFILE + [GEMSPEC_TRYOUT] do
+#file GEMFILE_TRYOUT do
+  sh "gem build #{GEMSPEC_TRYOUT}"
+end
+
+file GEMSPEC => RAKEFILE do
+  File.write(GEMSPEC, GEMSTUB.to_ruby, mode: "wb")
+end
+
+file GEMSPEC_TRYOUT => RAKEFILE do
+  File.write(GEMSPEC_TRYOUT, GEMSTUB_TRYOUT.to_ruby, mode: "wb")
+end

data/gemstub.rb

@@ -0,0 +1,25 @@
+verreg = /^\s*\*\s+version:\s*(\d+(?:\.\w+)+)\s*$/i
+unless File.read("README.md", mode: "rt") =~ verreg
+  raise "``version'' is not defined or bad syntax in ``README.md''"
+end
+
+version = String($1)
+
+GEMSTUB = Gem::Specification.new do |s|
+  s.name = "snowy"
+  s.version = version
+  s.summary = "an identicon implements"
+  s.description = <<EOS
+Pure ruby identicon implement with the snow crystal motif
+EOS
+  s.homepage = "https://github.com/dearblue/ruby-snowy/"
+  s.license = "BSD-2-Clause"
+  s.author = "dearblue"
+  s.email = "dearblue@users.noreply.github.com"
+
+  #s.required_ruby_version = ">= 2.1"
+  s.add_development_dependency "rake", "~> 11"
+end
+
+EXTRA << "snowy-demo.png"
+EXTRA << "snowy-demo.rb"

data/lib/snowy.rb

@@ -0,0 +1,529 @@
+#!ruby
+
+require_relative "snowy/common"
+
+module Snowy
+  using Extentions
+
+  module DefaultDriver
+    def self.render(size, triangles, background, color, outline, angle)
+      img = Canvas.new(size, size, 0, 1, plt = [background, color])
+      plt << outline if outline
+
+      img.instance_exec do
+        translate(width / 2.0, height / 2.0)
+        scale(width / 32.0, height / 32.0)
+        rotate_deg(angle)
+        sqrt3 = Math.sqrt(3)
+        [30, 90, 150, 210, 270, 330].each do |deg|
+          push_matrix do
+            rotate_deg(deg)
+            scale(1, sqrt3)
+            triangles.each do |t|
+              triangle(*t)
+            end
+          end
+        end
+
+        # plot outline
+        if outline
+          w = width
+          h = height
+          pix = pixels
+          (1 ... (h - 1)).step(1) do |py|
+            py0 = py * w
+            py1 = (py + 1) * w
+            py2 = (py - 1) * w
+            (1 ... (w - 1)).step(1) do |px|
+              px1 = px + 1
+              px2 = px - 1
+              if pix.getbyte(py0 + px) == 0
+                if pix.getbyte(py0 + px1) == 1 ||
+                   pix.getbyte(py0 + px2) == 1 ||
+                   pix.getbyte(py1 + px ) == 1 ||
+                   pix.getbyte(py2 + px ) == 1
+                  pix.setbyte(py0 + px, 2)
+                end
+              end
+            end
+          end
+        end
+        export_to_png
+      end
+    end
+  end
+
+  @@driver = DefaultDriver
+
+
+  BLACK = rgba(0, 0, 0)
+  WHITE = rgba(255, 255, 255)
+
+  #
+  # 256 indexed canvas
+  #
+  class Canvas
+    attr_reader :width, :height, :pixels, :matrix, :palette, :color
+
+    MIN_PIXEL = 1
+    MAX_PIXEL = 4096
+
+    def initialize(width, height, background = 0, color = 1, palette = [WHITE, BLACK])
+      @width = width.to_i
+      @height = height.to_i
+      if @width < MIN_PIXEL || @width > MAX_PIXEL ||
+         @height < MIN_PIXEL || @height > MAX_PIXEL
+        raise ArgumentError,
+              "width and height are too small or large (given %d x %d, expect %d..%d)" %
+                [@width, @height, MIN_PIXEL, MAX_PIXEL]
+      end
+
+      @pixels = [background].pack("C") * (@width * @height)
+      @matrix = Matrix.new
+      @palette = palette
+      @color = color
+    end
+
+    ## primitive operators
+    ;
+
+    def getpixel(x, y)
+      x = x.to_i
+      y = y.to_i
+      if validate_point(x, y)
+        getpixel!(x, y)
+      else
+        nil
+      end
+    end
+
+    alias [] getpixel
+
+    def setpixel(x, y, level)
+      x = x.to_i
+      y = y.to_i
+      validate_point(x, y) and setpixel!(x, y, level)
+      self
+    end
+
+    alias []= setpixel
+
+    ## lowlevel operations
+    ;
+
+    def fill(color = @color)
+      @pixels.bytesize.times do |i|
+        @pixels.setbyte(i, color)
+      end
+      self
+    end
+
+    def validate_point(x, y)
+      if x < 0 || x >= @width || y < 0 || y >= @height
+        false
+      else
+        true
+      end
+    end
+
+    def test_point(x, y)
+      unless validate_point(x, y)
+        raise ArgumentError,
+              "x and y are out of canvas (given (%d, %d), expect (0, 0) .. (%d, %d))" %
+                [x, y, @width - 1, @height - 1]
+      end
+
+      nil
+    end
+
+    def getpixel!(x, y)
+      @pixels.getbyte(x + y * @width)
+    end
+
+    def setpixel!(x, y, color)
+      @pixels.setbyte(x + y * @width, color)
+    end
+
+    def plotscanline!(y, x0, x1)
+      w = width
+      px = pixels
+      i = color
+      x0.upto(x1 - 1) { |x| px.setbyte(x + y * w, i) }
+      self
+    end
+
+    ## primitive figures
+    ;
+
+    def plotscanline(y, x0, x1)
+      y = y.round
+      x0 = x0.round
+      x1 = x1.round
+
+      if y >= 0 && y < height
+        (x0, x1) = x1, x0 if x0 > x1
+        if x0 < width && x1 >= 0
+          x0 = [0, x0].max
+          x1 = [x1, width].min
+          plotscanline! y, x0, x1
+        end
+      end
+
+      self
+    end
+
+    ## additional operators
+    ;
+
+    #
+    # plot dot by char
+    #
+    # example:
+    #     # plot dot "Error(TIMEDOUT)"
+    #     canv.dot_by_char(5, 5, <<-CODE, { "*" => 3 })
+    #   ***                  * *** *** *   * *** **  *** * * *** *
+    #   *                   *   *   *  ** ** *   * * * * * *  *   *
+    #   *** *** *** *** *** *   *   *  * * * *** * * * * * *  *   *
+    #   *   *   *   * * *   *   *   *  * * * *   * * * * * *  *   *
+    #   *** *   *   *** *    *  *  *** *   * *** **  *** ***  *  *
+    #     CODE
+    #
+    def dot_by_char(x, y, seq, colormap = { "*" => 2 })
+      x0 = x
+      seq.each_char do |ch|
+        case ch
+        when "\n"
+          x = x0
+          y += 1
+        when " "
+          x += 1
+        else
+          if color = colormap[ch]
+            setpixel(x, y, color)
+          end
+          x += 1
+        end
+      end
+
+      self
+    end
+
+    ## transform operators
+    ;
+
+    def init_matrix
+      matrix.init
+      self
+    end
+
+    def push_matrix
+      save = matrix.dup
+      return save unless block_given?
+
+      begin
+        yield
+      ensure
+        matrix.load(save)
+      end
+    end
+
+    def pop_matrix(saved_matrix)
+      matrix.load(saved_matrix)
+      self
+    end
+
+    def mult_matrix(matrix1)
+      matrix.mult(matrix1)
+      self
+    end
+
+    def transform(x, y, w = 1)
+      matrix.transform(x, y, w)
+    end
+
+    def translate(dx, dy, dw = 1)
+      matrix.translate(dx, dy, dw)
+      self
+    end
+
+    def scale(ax, ay, aw = 1)
+      matrix.scale(ax, ay, aw)
+      self
+    end
+
+    def rotate(rad)
+      matrix.rotate(rad)
+      self
+    end
+
+    def rotate_deg(deg)
+      matrix.rotate(Math::PI * deg / 180)
+      self
+    end
+
+    ## transformed figures
+    ;
+
+    def triangle(x0, y0, x1, y1, x2, y2)
+      (x0, y0) = transform(x0, y0)
+      (x1, y1) = transform(x1, y1)
+      (x2, y2) = transform(x2, y2)
+
+      x0 = x0.round
+      x1 = x1.round
+      x2 = x2.round
+      y0 = y0.round
+      y1 = y1.round
+      y2 = y2.round
+
+      (x0, y0, x1, y1) = x1, y1, x0, y0 if y0 > y1
+      (x1, y1, x2, y2) = x2, y2, x1, y1 if y1 > y2
+      (x0, y0, x1, y1) = x1, y1, x0, y0 if y0 > y1
+
+      if y0 == y2
+        (a, *, b) = [x0, x1, x2].sort
+        plotscanline(y0, a, b)
+      else
+        d1 = (x1 - x0) / (y1 - y0).to_f
+        d2 = (x2 - x0) / (y2 - y0).to_f
+        (y0 ... y1).step(1) do |py|
+          dy = py - y0
+          plotscanline(py, x0 + dy * d1, x0 + dy * d2)
+        end
+
+        if y1 == y2
+          plotscanline(y1, x1, x2)
+        else
+          d0 = (x0 - x2) / (y0 - y2).to_f
+          d1 = (x1 - x2) / (y1 - y2).to_f
+          (y1 .. y2).step(1) do |py|
+            dy = (py - y2)
+            plotscanline(py, x2 + dy * d1, x2 + dy * d0)
+          end
+        end
+      end
+
+      self
+    end
+
+    ## extra
+    ;
+
+    def halfdown!
+      pixels = @pixels
+      height = @height
+      width2 = width >> 1
+      height2 = height >> 1
+      height2.times do |y|
+        width2.times do |x|
+          xx = x * 2
+          yy = y * 2
+          xx1 = xx + 1
+          yy1 = (yy + 1) * height
+          yy = yy * height
+          pixels.setbyte(x + y * width2,
+                         (pixels.getbyte(xx + yy) +
+                          pixels.getbyte(xx1 + yy) +
+                          pixels.getbyte(xx + yy1) +
+                          pixels.getbyte(xx1 + yy1)) / 4)
+        end
+      end
+
+      @width = width2
+      @height = height2
+      @pixels[(width2 * height2) .. -1] = ""
+
+      self
+    end
+
+    ## export to png
+    ;
+
+    def export_to_png(io = "".b, level: Zlib::DEFAULT_COMPRESSION)
+      io << [0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A].pack("C*")
+      storechunk = ->(code, chunk) {
+        crc = Zlib.crc32(chunk, Zlib.crc32(code))
+        io << [chunk.bytesize].pack("N")
+        io << code << chunk
+        io << [crc].pack("N")
+      }
+
+      ## IDAT
+      ##  color
+      ##  type  bit depth
+      ##  0     1,2,4,8,16  immediate grayscale sample
+      ##  2     8,16        immediate RGB sample
+      ##  3     1,2,4,8     palette sample (need PLTE chunk)
+      ##  4     8,16        immediate grayscale sample with alpha
+      ##  6     8,16        immediate RGB sample with alpha
+      colorbits = 8
+      colortype = 3
+      storechunk["IHDR", [width, height, colorbits, colortype, 0, 0, 0].pack("NNCCCCC")]
+
+      ## PLTE
+      plte = palette.reduce("".b) { |a, e|
+        a << e.pack_rgb
+      }
+      storechunk["PLTE", plte]
+
+      ## tRNS
+      ##    Alpha for palette index 0:  1 byte
+      ##    Alpha for palette index 1:  1 byte
+      ##    ...etc...
+      trns = palette.reduce([]) { |a, e| a << e.get_alpha }
+      storechunk["tRNS", trns.pack("C*")]
+
+      ## iTXt
+      ##    Keyword:             1-79 bytes (character string)
+      ##    Null separator:      1 byte
+      ##    Compression flag:    1 byte
+      ##    Compression method:  1 byte
+      ##    Language tag:        0 or more bytes (character string)
+      ##    Null separator:      1 byte
+      ##    Translated keyword:  0 or more bytes
+      ##    Null separator:      1 byte
+      ##    Text:                0 or more bytes
+      storechunk["iTXt", ["snowy", 0, 0, <<-'SNOWY'].pack("a*xCCxxa*")]
+This image is generated by snowy <https://rubygems.org/gems/snowy>
+      SNOWY
+      storechunk["iTXt", ["LICENSING", 0, 0, <<-'LICENSING'].pack("a*xCCxxa*")]
+Creative Commons License Zero (CC0 / Public Domain)
+See <https://creativecommons.org/publicdomain/zero/1.0/>
+      LICENSING
+
+      ## IDAT
+      scanline = ->(lines, line) {
+        lines << "\0" << line
+      }
+      scanline ||= ->(lines, line) {
+        v = 0
+        line.each_byte.with_index { |vv, i|
+          line.setbyte(i, vv - v)
+          v = vv
+        }
+        lines << "\1" << line
+      }
+      lines = height.times.reduce("".b) { |a, h|
+        line = pixels.byteslice(h * width, width)
+        scanline[a, line]
+      }
+      storechunk["IDAT", Zlib.deflate(lines, level)]
+
+      storechunk["IEND", ""]
+
+      io
+    end
+  end
+
+  class Matrix
+    attr_reader :matrix
+
+    def self.[](matrix)
+      case matrix
+      when self
+        matrix
+      else
+        new matrix
+      end
+    end
+
+    def initialize(mat = nil)
+      @matrix = [[nil, nil, nil], [nil, nil, nil], [nil, nil, nil]]
+
+      if mat
+        load mat
+      else
+        reset
+      end
+    end
+
+    def initialize_copy(mat)
+      @matrix = [[nil, nil, nil], [nil, nil, nil], [nil, nil, nil]]
+      load mat
+    end
+
+    def reset
+      load [[1, 0, 0], [0, 1, 0], [0, 0, 1]]
+    end
+
+    def load(mat)
+      case mat
+      when Matrix
+        matrix[0][0, 3] = mat.matrix[0]
+        matrix[1][0, 3] = mat.matrix[1]
+        matrix[2][0, 3] = mat.matrix[2]
+      when Array
+        if mat.size == 3 &&
+            mat[0].kind_of?(Array) && mat[0].size == 3 &&
+            mat[1].kind_of?(Array) && mat[1].size == 3 &&
+            mat[2].kind_of?(Array) && mat[2].size == 3
+          matrix[0][0, 3] = mat[0]
+          matrix[1][0, 3] = mat[1]
+          matrix[2][0, 3] = mat[2]
+        else
+          if mat.size == 9
+            matrix[0][0, 3] = mat[0, 3]
+            matrix[1][0, 3] = mat[3, 3]
+            matrix[2][0, 3] = mat[6, 3]
+          else
+            raise ArgumentError, "wrong element number (given #{mat.size} elements, expect 9 elements)"
+          end
+        end
+      else
+        raise ArgumentError, "wrong argument type (expect Snowy::Matrix or Array)"
+      end
+
+      self
+    end
+
+    def mult(mat)
+      mult! self.class[mat].matrix
+    end
+
+    def mult!(mat)
+      3.times do |i|
+        m0 = matrix[i]
+        mm = m0.dup
+        3.times do |j|
+          m0[j] = mm[0] * mat[0][j] +
+                  mm[1] * mat[1][j] +
+                  mm[2] * mat[2][j]
+        end
+      end
+
+      self
+    end
+
+    def transform2(x, y, w = 1)
+      mx = matrix[0]
+      my = matrix[1]
+      [x * mx[0] + y * mx[1] + w * mx[2],
+       x * my[0] + y * my[1] + w * my[2]]
+    end
+
+    alias transform transform2
+
+    def transform3(x, y, w = 1)
+      mx = matrix[0]
+      my = matrix[1]
+      mw = matrix[2]
+      [x * mx[0] + y * mx[1] + w * mx[2],
+       x * my[0] + y * my[1] + w * my[2],
+       x * mw[0] + y * mw[1] + w * mw[2]]
+    end
+
+    def translate(dx, dy, dw = 1)
+      mult!([[1, 0, dx], [0, 1, dy], [0, 0, dw]])
+    end
+
+    def scale(ax, ay, aw = 1)
+      mult!([[ax, 0, 0], [0, ay, 0], [0, 0, aw]])
+    end
+
+    def rotate(rad)
+      cos = Math.cos(rad)
+      sin = Math.sin(rad)
+      mult!([[cos, -sin, 0], [sin, cos, 0], [0, 0, 1]])
+    end
+  end
+end

data/lib/snowy/cairo.rb

@@ -0,0 +1,50 @@
+require_relative "common"
+require "cairo"
+
+module Snowy
+  using Extentions
+
+  module CairoDriver
+    def self.render(size, triangles, background, color, outline, angle)
+      deg2rad = Math::PI / 180
+      surface = Cairo::ImageSurface.new(Cairo::Format::ARGB32, size, size)
+      Cairo::Context.new(surface) do |context|
+        context.instance_eval do
+          set_line_width 0.5
+          set_source_color [background.get_red / 255.0, background.get_green / 255.0, background.get_blue / 255.0, background.get_alpha / 255.0]
+          paint
+          translate(size / 2.0, size / 2.0)
+          scale(size / 32.0, size / 32.0)
+          rotate(angle * deg2rad) unless deg2rad == 0
+          sqrt3 = Math.sqrt(3)
+          [30, 90, 150, 210, 270, 330].each do |deg|
+            save do
+              rotate(-deg * deg2rad)
+              scale(1, sqrt3)
+              triangles.each do |(x1, y1, x2, y2, x3, y3)|
+                move_to(x1, y1)
+                line_to(x2, y2)
+                line_to(x3, y3)
+                close_path
+              end
+            end
+          end
+          if outline
+            set_source_rgba outline.get_red / 255.0, outline.get_green / 255.0, outline.get_blue / 255.0, 255 / 255.0
+            stroke true
+          end
+          set_source_rgba color.get_red / 255.0, color.get_green / 255.0, color.get_blue / 255.0, 255 / 255.0
+          fill
+        end
+      end
+
+      buffer = "".b
+      outport = Object.new
+      outport.define_singleton_method(:write, ->(d) { buffer << d; d.bytesize })
+      surface.write_to_png outport
+      buffer
+    end
+  end
+
+  @@driver = CairoDriver
+end

data/lib/snowy/common.rb

@@ -0,0 +1,154 @@
+require "zlib"
+
+module Snowy
+  module Extentions
+    refine Numeric do
+      unless 0.respond_to?(:clamp)
+        def clamp(min, max)
+          case
+          when self < min
+            return min
+          when self > max
+            return max
+          else
+            return self
+          end
+        end
+      end
+    end
+
+    refine Integer do
+      def get_red
+        0xff & (self >> 24)
+      end
+
+      def get_green
+        0xff & (self >> 16)
+      end
+
+      def get_blue
+        0xff & (self >> 8)
+      end
+
+      def get_alpha
+        0xff & self
+      end
+
+      def pack_rgb
+        [self >> 24, self >> 16, self >> 8].pack("C3")
+      end
+
+      def pack_rgba
+        [self].pack("N")
+      end
+    end
+  end
+
+  using Extentions
+
+
+  def self.rgba(r, g, b, a = 255)
+    return (r.to_i.clamp(0, 255) << 24) |
+           (g.to_i.clamp(0, 255) << 16) |
+           (b.to_i.clamp(0, 255) <<  8) |
+           (a.to_i.clamp(0, 255)      )
+  end
+
+
+  #
+  # call-seq:
+  #   generate_to_png(code, size = 128)
+  #
+  # @return
+  #   string object
+  #
+  # @param [Integer] code
+  #   32 bits integer
+  #
+  # @param [Integer] size
+  #   output png image size
+  #
+  def self.generate_to_png(code, size: 128, cap: true, extendcap: true, angle: 0, color: nil, outline: nil)
+    if code.kind_of?(String)
+      code = Zlib.crc32(code)
+    end
+
+    if color
+      if outline.nil?
+        r = color.get_red
+        g = color.get_green
+        b = color.get_blue
+        a = color.get_alpha
+      end
+    else
+      r = (code >> 28) & 0x0f
+      g = (code >> 24) & 0x0f
+      b = (code >> 20) & 0x0f
+      r = (r << 3) | 0x80
+      g = (g << 3) | 0x80
+      b = (b << 3) | 0x80
+      color = rgba(r, g, b)
+    end
+
+    if outline.nil?
+      outline = rgba(r * 7 / 8, g * 7 / 8, b * 7 / 8, a || 0xff)
+    end
+
+    code = code ^ (code >> 16) ^ ((code & 0xffff) << 16) if extendcap
+
+    depth = extendcap ? 7 : 6
+    triangles = [] # [[x1, y1, x2, y2, x3, y3], ...]
+    depth.times do |level|
+      # level # 現在の階層
+      # total # 現在の階層までの総要素数
+      # layer # 現在の階層の要素数
+      level_1 = level + 1
+      total = level_1 ** 2
+      layer = level * 2 + 1
+      offbase = (level * level_1) / 2
+      offpivot = (layer + 1) / 2 - 1
+      layer.times do |i|
+        if !extendcap && level_1 == depth
+          i += 1
+          break if (i + 1) == layer
+          #break if i > layer
+        end
+
+        #if (i + 1) > (layer + 1) / 2
+        if i > offpivot
+          # mirror
+          off = offbase + (layer - i - 1)
+        else
+          off = offbase + i
+        end
+
+        off -= 1 if !extendcap && level_1 == depth
+        next if code[off] == 0
+
+        m_level_i = -level + i
+        if i.even?
+          triangles << [m_level_i, level, m_level_i + 1, level_1, m_level_i - 1, level_1]
+        else
+          triangles << [m_level_i, level_1, m_level_i + 1, level, m_level_i - 1, level]
+        end
+      end
+    end
+
+    # 一番外側に三角形を配置する
+    if cap
+      if extendcap
+        triangles << [-5, 7, -3, 7, -4, 8]
+        triangles << [5, 7, 4, 8, 3, 7]
+      else
+        triangles << [-4, 6, -2, 6, -3, 7]
+        triangles << [4, 6, 3, 7, 2, 6]
+      end
+    end
+
+    driver.render(size, triangles, rgba(255, 255, 255, 0), color, outline, angle)
+  end
+
+  def self.driver
+    @@driver
+  end
+end

data/snowy-demo.rb

@@ -0,0 +1,50 @@
+#!ruby
+
+require "sinatra"
+require "haml"
+require_relative "lib/snowy.rb"
+#require_relative "lib/snowy/cairo.rb"
+
+if $-d
+  require "sinatra/reloader"
+  also_reload "lib/snowy/common.rb"
+  also_reload "lib/snowy.rb"
+  #also_reload "lib/snowy/cairo.rb"
+end
+
+get "/" do
+  haml <<-HAML
+!!! 5
+%title Demonstration for snowy
+:css
+  body
+  {
+    background: url("snowy/#{"%08X" % (0xeef00000 | rand(0x100000))}.png?size=256&angle=-10&extendcap=true"); 
+  }
+
+%div{style: "text-align: center"}
+  %div{style: "padding: 1em; font-size: 200%"}
+    "snowy" is an identicon implements with the snow crystal motif.
+  %div
+    #{20.times.map { %(<img src="snowy/%08X.png?size=131&angle=5&extendcap=true" alt="">) % [rand(0xffffffff)] }.join}
+  %div
+    #{20.times.map { %(<img src="snowy/%08X.png?size=131&angle=0&extendcap=true" alt="">) % [rand(0x00100000) | 0x69f00000] }.join}
+  HAML
+end
+
+get "/snowy/*.png" do |id|
+  id = id.hex
+  size = (params["size"] || 128).to_i
+  size = [32, size, 4096].sort[1]
+  cap = (params["nocap"]) ? false : true
+  angle = (params["angle"] || 0).to_i
+  if params["monotone"]
+    id = (id & 0x000fffff) | 0x9cf00000
+  end
+  extendcap = (params["extendcap"] || "false") == "false" ? false : true
+  bin = Snowy.generate_to_png(id, size: size, cap: cap, extendcap: extendcap, angle: -angle)
+
+  status 200
+  headers "Content-Type" => "image/png"
+  body bin
+end

metadata

@@ -0,0 +1,77 @@
+--- !ruby/object:Gem::Specification
+name: snowy
+version: !ruby/object:Gem::Version
+  version: '0.1'
+platform: ruby
+authors:
+- dearblue
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-12-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '11'
+description: 'Pure ruby identicon implement with the snow crystal motif
+
+'
+email: dearblue@users.noreply.github.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE
+- README.md
+- lib/snowy.rb
+- lib/snowy/cairo.rb
+- lib/snowy/common.rb
+files:
+- LICENSE
+- README.md
+- Rakefile
+- gemstub.rb
+- lib/snowy.rb
+- lib/snowy/cairo.rb
+- lib/snowy/common.rb
+- snowy-demo.png
+- snowy-demo.rb
+homepage: https://github.com/dearblue/ruby-snowy/
+licenses:
+- BSD-2-Clause
+metadata: {}
+post_install_message: 
+rdoc_options:
+- "--charset"
+- UTF-8
+- "-m"
+- README.md
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.4
+signing_key: 
+specification_version: 4
+summary: an identicon implements
+test_files: []