ranicoma 0.1.0

data/lib/ranicoma.rb

@@ -0,0 +1,14 @@
+require "ranicoma/version"
+require "ranicoma/rect"
+require "ranicoma/util"
+require "ranicoma/creator"
+
+require "ranicoma/design/base"
+require "ranicoma/design/spbox"
+require "ranicoma/design/polypoly"
+require "ranicoma/design/rotobj"
+require "ranicoma/design/geji"
+
+module Ranicoma
+  class Error < StandardError; end
+end

data/lib/ranicoma/app.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'optparse'
+require 'rexml/formatters/pretty'
+
+module Ranicoma
+  class App
+    def get_option
+      OptionParser.new do |opt|
+        opt.on("--size VALUE", 'size in pix (required)', Numeric)
+        opt.on("--seed VALUE", 'random number seed', Integer)
+        o={}
+        opt.permute(ARGV, into:o)
+        return o
+      end
+    end
+
+    def run
+      option=get_option
+      seed = option[:seed] || Random.new_seed
+      size = option[:size] || 100
+      formatter = REXML::Formatters::Pretty.new
+      c=Ranicoma::Creator.new(seed, size)
+      formatter.write(c.create, $stdout)
+    end
+  end
+end

data/lib/ranicoma/creator.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'rexml/document'
+require "ranicoma/util"
+
+module Ranicoma
+  class Creator
+    include Util
+    def initialize( seed, size )
+      @rng=Random.new(seed)
+      @size=size
+      @doc = REXML::Document.new
+      @doc << REXML::XMLDecl.new('1.0', 'UTF-8')
+    end
+    attr_reader(:rng)
+    attr_reader(:size)
+    attr_reader(:doc)
+
+    def create
+      design = Design::Base.subclasses.sample( random:rng ).new(rng)
+      doc << (
+        element("svg", xmlns:"http://www.w3.org/2000/svg", height:"#{size}px", width:"#{size}px", viewBox:"0 0 1 1" ){
+          design.create
+        }
+      )
+    end
+  end
+end
+

data/lib/ranicoma/design/base.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require "ranicoma/util"
+require "ranicoma/rect"
+
+module Ranicoma
+  module Design
+    class Base
+      include Util
+      def self.add_subclass(cls)
+        @subclasses ||= []
+        @subclasses.push(cls)
+      end
+
+      def rainbow(t,mx=->(v){v})
+        f = lambda{ |t0|
+          v = lambda{ |x|
+            case x
+            when 0..1 then x
+            when 1..2 then 2-x
+            else 0
+            end
+          }[t0 % 3]
+          (mx[v]*255).round
+        }
+        [f[t],f[t+1],f[t+2]]
+      end
+
+      def Base.subclasses
+        @subclasses
+      end
+
+      def initialize(rng)
+        @rng=rng
+      end
+
+      def points_str(pts)
+        pts.map{ |e| e.join(",") }.join(" ")
+      end
+
+      def rect_element(rc, col)
+        element("rect", **rectpos(rc), **fill(col))
+      end
+
+      attr_reader(:rng)
+
+      def rand(*args)
+        rng.rand(*args)
+      end
+
+      def rectpos(rc)
+        { x:rc.x, y:rc.y, width:rc.w, height:rc.h }
+      end
+
+      def rand_rotate(ary)
+        ix=rng.rand(ary.size)
+        ary[ix,ary.size-ix] + ary[0,ix]
+      end
+
+      def fill(col)
+        case col
+        when Array
+          { style:"fill:rgb(#{col.join(",")})" }
+        when /^\d+\,\d+\,\d+$/
+          { style:"fill:rgb(#{col})" }
+        else
+          { style:"fill:#{col}" }
+        end
+      end
+
+      def stroke(col, w)
+        c=case col
+        when Array
+          "rgb(#{col.join(",")})"
+        when /^\d+\,\d+\,\d+$/
+          "rgb(#{col})"
+        else
+          col
+        end
+        { stroke:c, "stroke-width":w }
+      end
+
+      def Base.inherited(subclass)
+        Base.add_subclass(subclass)
+      end
+    end
+  end
+end

data/lib/ranicoma/design/geji.rb

@@ -0,0 +1,249 @@
+# frozen_string_literal: true
+
+require 'rexml/document'
+
+require "ranicoma/design/base"
+require "ranicoma/rect"
+
+module Ranicoma
+  module Design
+    class Geji < Base
+
+      PROJ_METHODS=[]
+
+      def initialize(rng)
+        super
+        @line_width = 1.0/80
+        @projsize = rand(0.1..0.3)
+        @center_rc = Rect.new( projsize, projsize, 1-projsize*2, 1-projsize*2 )
+      end
+
+      def proj_attr
+        fill(rainbow(rand(3.0))).merge(stroke(:black, line_width))
+      end
+
+      attr_reader(:line_width)
+      attr_reader(:projsize)
+      attr_reader(:center_rc)
+
+      def eqcolors(n)
+        base=rand(3.0)
+        Array.new(n){ |ix|
+          rainbow(base+3.0*ix/n)
+        }
+      end
+      def center_rect
+        gx = center_rc.w * rand(0.05..0.3)
+        gy = center_rc.h * rand(0.05..0.3)
+        w0 = (center_rc.w-gx*2)*rand(0.6..0.9)
+        h0 = (center_rc.h-gy*2)*rand(0.6..0.9)
+        w1 = (center_rc.w-gx*2)*rand(0.6..0.9)
+        h1 = (center_rc.h-gy*2)*rand(0.6..0.9)
+        subrects = if rand(2)==0
+          [
+            Rect.new( center_rc.x+gx, center_rc.y+gy, w0, h0 ),
+            Rect.new( center_rc.right-gx-w1, center_rc.bottom-gy-h1, w1, h1 ),
+          ]
+        else
+          [
+            Rect.new( center_rc.right-gx-w0, center_rc.y+gy, w0, h0 ),
+            Rect.new( center_rc.x+gx, center_rc.bottom-gy-h1, w1, h1 ),
+          ]
+        end.shuffle( random:rng )
+        if rand(2)==0
+          h = [h0, h1].min * rand(0.3..1.1)
+          w = [w0, w1].min * rand(0.3..1.1)
+          subrects.push( Rect.new( center_rc.cx-w/2, center_rc.cy-h/2, w, h ) )
+        end
+        cols = eqcolors(subrects.size+1)
+        makeattr=->(){
+          {
+            rx:line_width*3,
+            **fill(cols.pop),
+            **stroke(:black, line_width)
+          }
+        }
+        ([ center_rc  ]+subrects).map{ |rc|
+          element( "rect", **rectpos(rc), **makeattr[] )
+        }
+      end
+
+      def shorten_rc(rc)
+        d = rand(rc.h/2)
+        Rect.new( rc.x, rc.y+d, rc.w, rc.h-d )
+      end
+
+      def bezier(rc, corners)
+        q = corners.each_cons(2).map{ |(x0,y0),(x1,y1)|
+          mx = (x0+x1)/2.0
+          my = (y0+y1)/2.0
+          "Q #{x0} #{y0} #{mx} #{my} "
+        }
+        path = <<~PATH
+          M #{rc.x} #{rc.bottom}
+          #{q.join}
+          L #{corners.last.join(" ")}
+          L #{rc.x} #{rc.bottom}
+        PATH
+        element( "path", d:path, **proj_attr )
+      end
+
+      PROJ_METHODS<<
+      def bezier0(rc0)
+        rc = shorten_rc(rc0)
+        y0 = rc.y + rc.h*(2.0/3)
+        y1 = rc.y + rc.h*(1.0/3)
+        corners = [
+          [ rc.x, rc.bottom ],
+          [ rc.x, y0 ],
+          [ rc.cx, y0 ],
+          [ rc.cx, y1 ],
+          [ rc.x, y1 ],
+          [ rc.x, rc.y ],
+          [ rc.right, rc.y ],
+          [ rc.right, rc.bottom ],
+        ]
+        if rand(2)==0
+          bezier(rc, corners.map{ |x,y| [rc.cx*2-x, y] } )
+        else
+          bezier(rc, corners)
+        end
+      end
+
+      PROJ_METHODS<<
+      def bezier1(rc0)
+        rc = shorten_rc(rc0)
+        y0 = rc.y + rc.h*(2.0/3)
+        y1 = rc.y + rc.h*(1.0/3)
+        corners = [
+          [ rc.x, rc.bottom ],
+          [ rc.x, y0 ],
+          [ rc.cx, y0 ],
+          [ rc.x, y0 ],
+          [ rc.x, y1 ],
+          [ rc.cx, y1 ],
+          [ rc.x, y1 ],
+          [ rc.x, rc.y ],
+          [ rc.right, rc.y ],
+          [ rc.right, rc.bottom ],
+        ]
+        if rand(2)==0
+          bezier(rc, corners.map{ |x,y| [rc.cx*2-x, y] } )
+        else
+          bezier(rc, corners)
+        end
+      end
+
+      PROJ_METHODS<<
+      def bezier2(rc0)
+        rc = shorten_rc(rc0)
+        y0 = rc.y + rc.h*(2.0/3)
+        y1 = rc.y + rc.h*(1.0/3)
+        corners = [
+          [ rc.x, rc.bottom ],
+          [ rc.x, y0 ],
+          [ rc.cx, y0 ],
+          [ rc.x, y0 ],
+          [ rc.x, y1 ],
+          [ rc.cx, y1 ],
+          [ rc.x, y1 ],
+          [ rc.x, rc.y ],
+          [ rc.right, rc.y ],
+          [ rc.right, y1 ],
+          [ rc.cx, y1 ],
+          [ rc.right, y1 ],
+          [ rc.right, y0 ],
+          [ rc.cx, y0 ],
+          [ rc.right, y0 ],
+          [ rc.right, rc.bottom ],
+        ]
+        bezier(rc, corners)
+      end
+
+      PROJ_METHODS<<
+      def bezier3(rc0)
+        rc = shorten_rc(rc0)
+        y0 = rc.y + rc.h*0.9
+        y1 = rc.y + rc.h*(1.0/3)
+        x0 = rc.x + rc.w*0.4
+        x1 = rc.x + rc.w*0.6
+        corners = [
+          [ rc.x, rc.bottom ],
+          [ rc.x, y0 ],
+          [ x0, y0 ],
+          [ x0, y1 ],
+          [ rc.x, y1 ],
+          [ rc.x, rc.y ],
+          [ rc.right, rc.y ],
+          [ rc.right, y1 ],
+          [ x1, y1 ],
+          [ x1, y0 ],
+          [ rc.right, y0 ],
+          [ rc.right, rc.bottom ],
+        ]
+        bezier(rc, corners)
+      end
+
+      PROJ_METHODS<<
+      def box_proj(rc0)
+        rc = shorten_rc(rc0)
+        element( "rect",
+          **rectpos(rc),
+          **proj_attr )
+      end
+
+      PROJ_METHODS<<
+      def roundbox_proj(rc0)
+        d = rand(rc0.h/2)
+        rx = [rc0.w, rc0.h].min/3
+        rc = Rect.new( rc0.x, rc0.y+d, rc0.w, rc0.h+rx-d )
+        element( "rect",
+          **rectpos(rc),
+          rx:rx,
+          **proj_attr )
+      end
+
+      PROJ_METHODS<<
+      def triangle_proj(rc0)
+        rc = shorten_rc(rc0)
+        points = [ [rc.cx,rc.y], [rc.x, rc.bottom], [rc.right, rc.bottom] ]
+        element("polygon",
+          points:points_str(points),
+          **proj_attr,
+          "stroke-linejoin": :round )
+      end
+
+      def projects(pos)
+        count = rand(2..5)
+        rot = "rotate(#{90*pos},0.5,0.5)"
+        proj_rects = center_rc.hsplit(*([1]*count))
+        proj_rects.each{ |e|
+          e.x += e.w*0.1
+          e.w *= 0.8
+          e.y=line_width
+          e.h = projsize
+        }
+        pattern = rand(1..2**count-1) | rand(1..2**count-1)
+        element("g", transform:rot ){
+          Array.new(count){ |ix|
+            if pattern[ix]==0
+              []
+            else
+              send PROJ_METHODS.sample(random:rng), proj_rects[ix]
+            end
+          }.flatten
+        }
+      end
+
+      def create
+        [
+          Array.new(4){ |pos|
+            projects(pos)
+          },
+          center_rect
+        ].flatten
+      end
+    end
+  end
+end
+

data/lib/ranicoma/design/polypoly.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require 'rexml/document'
+
+require "ranicoma/design/base"
+require "ranicoma/rect"
+
+module Ranicoma
+  module Design
+    class PolyPoly < Base
+
+      def initialize(rng)
+        super
+        @psize = rng.rand(6..20)
+        @line_width = 1.0/(@psize*5)
+      end
+
+      attr_reader(:psize)
+      attr_reader(:line_width)
+
+      def colors(n)
+        f = lambda{ |t0|
+          v = lambda{ |t|
+            case t
+            when 0..1 then t
+            when 1..2 then 2-t
+            else 0
+            end
+          }[t0 % 3]
+          (v**0.5*255).round
+        }
+        Array.new(n){ |i|
+          t = i*3.0/n+2
+          [f[t],f[t+1],f[t+2]]
+        }
+      end
+
+      def poly(center, r)
+        delta = Math::PI*2/psize*0.7
+        dirs = Array.new(psize){ |ix| Math::PI*2*ix / psize + rng.rand(delta) }
+        outer = dirs.map{ |e|
+          [Math.cos(e)*r+center[0], Math.sin(e)*r+center[1]]
+        }
+        edelta = rng.rand(-0.2..0.2) * Math::PI*2
+        ri = r * rng.rand(0.2..0.5)
+        cd = rng.rand(Math::PI)
+        rdelta = rng.rand((r-ri-line_width)*0.8)
+        inner_cx = center[0] + Math.cos(cd)*rdelta
+        inner_cy = center[1] + Math.sin(cd)*rdelta
+        inner = dirs.map{ |e|
+          t = e + edelta
+          [Math.cos(t)*ri+inner_cx, Math.sin(t)*ri+inner_cy]
+        }
+        use = Array.new(inner.size){ rng.rand<0.8 }
+        cols = rand_rotate(colors(use.count(true)))
+        center_poly = element( "polygon",
+          points:points_str(inner),
+          **fill(%i(black white gray).sample( random:rng)),
+          **stroke(:black, line_width),
+          "stroke-linejoin": :round )
+        Array.new( outer.size ){ |ix|
+          if ! use[ix]
+            []
+          else
+            pts = [
+              outer[ix % psize],
+              outer[(ix+1) % psize],
+              inner[(ix+1) % psize],
+              inner[ix % psize]
+            ]
+            element(
+              "polygon",
+              points:points_str(pts),
+              **fill(cols.pop),
+              **stroke(:black, line_width),
+              "stroke-linejoin": :round )
+          end
+        } + [center_poly]
+      end
+
+      def create
+        [
+          poly([0.5,0.5],0.5-line_width)
+        ].flatten
+      end
+    end
+  end
+end
+