magic_cloud 0.0.2

data/lib/magic_cloud/collision_board.rb

@@ -0,0 +1,110 @@
+# encoding: utf-8
+require_relative './bit_matrix'
+
+module MagicCloud
+  # Pixel-by-pixel collision board
+  #
+  # Providen by width and height of the board, allows to check if given
+  # shape (array of zero and non-zero pixels) "collides" with any of
+  # previosly placed shapes
+  class CollisionBoard < BitMatrix
+    def initialize(width, height)
+      super
+      @rects = []
+      @intersections_cache = {}
+    end
+
+    attr_reader :rects, :intersections_cache
+
+    def criss_cross_collision?(rect)
+      if rects.any?{|r| r.criss_cross?(rect)}
+        Debug.stats[:criss_cross] += 1
+        true
+      else
+        false
+      end
+    end
+
+    def collides_previous?(shape, intersections)
+      prev_idx = intersections_cache[shape.object_id]
+
+      if prev_idx && (prev = intersections[prev_idx]) &&
+         pixels_collision?(shape, prev)
+
+        Debug.stats[:px_prev_yes] += 1
+        true
+      else
+        false
+      end
+    end
+
+    def pixels_collision_multi?(shape, intersections)
+      intersections.each_with_index do |intersection, idx|
+        next unless intersection
+        next if idx == intersections_cache[shape.object_id] # already checked it
+
+        next unless pixels_collision?(shape, intersection)
+
+        Debug.stats[:px_yes] += 1
+        intersections_cache[shape.object_id] = idx
+        return true
+      end
+
+      false
+    end
+
+    def collides?(shape)
+      Debug.stats[:collide_total] += 1
+
+      # nothing on board - so, no collisions
+      return false if rects.empty?
+
+      # no point to try drawing criss-crossed words
+      # even if they will not collide pixel-per-pixel
+      return true if criss_cross_collision?(shape.rect)
+
+      # then find which of placed sprites rectangles tag intersects
+      intersections = rects.map{|r| r.intersect(shape.rect)}
+
+      # no need to further check: this tag is not inside any others' rectangle
+      if intersections.compact.empty?
+        Debug.stats[:rect_no] += 1
+        return false
+      end
+
+      # most probable that we are still collide with this word
+      return true if collides_previous?(shape, intersections)
+
+      # only then check points inside intersected rectangles
+      return true if pixels_collision_multi?(shape, intersections)
+
+      Debug.stats[:px_no] += 1
+
+      false
+    end
+
+    def pixels_collision?(shape, rect)
+      l, t = shape.left, shape.top
+      (rect.x0...rect.x1).each do |x|
+        (rect.y0...rect.y1).each do |y|
+          dx = x - l
+          dy = y - t
+          return true if shape.sprite.at(dx, dy) && at(x, y)
+        end
+      end
+
+      false
+    end
+
+    def add(shape)
+      l, t = shape.left, shape.top
+      shape.height.times do |dy|
+        shape.width.times do |dx|
+          put(l + dx, t + dy) if shape.sprite.at(dx, dy)
+        end
+      end
+
+      rects << shape.rect
+    end
+  end
+end

data/lib/magic_cloud/debug.rb

@@ -0,0 +1,28 @@
+# encoding: utf-8
+require 'forwardable'
+require 'logger'
+
+module MagicCloud
+  # Debugging utilities class for cloud development itself
+  class Debug
+    class << self
+      def instance
+        @instance ||= new
+      end
+
+      extend Forwardable
+      def_delegators :instance, :logger, :stats, :reset!
+    end
+
+    def initialize
+      @logger = Logger.new(STDOUT).tap{|l| l.level = Logger::FATAL}
+      @stats = Hash.new{|h, k| h[k] = 0}
+    end
+
+    attr_reader :logger, :stats
+
+    def reset!
+      @stats = Hash.new{|h, k| h[k] = 0}
+    end
+  end
+end

data/lib/magic_cloud/layouter.rb

@@ -0,0 +1,67 @@
+# encoding: utf-8
+require_relative './collision_board'
+
+module MagicCloud
+  # Main magic of magic cloud - layouting shapes without collisions.
+  # Also, alongside with CollisionBoard -  the slowest and
+  # algorithmically trickiest part.
+  class Layouter
+    def initialize(w, h, options = {})
+      @board = CollisionBoard.new(w, h)
+
+      @options = options
+    end
+
+    attr_reader :board
+
+    def width
+      board.width
+    end
+
+    def height
+      board.height
+    end
+
+    def layout!(shapes)
+      visible_shapes = []
+
+      shapes.each do |shape|
+        next unless find_place(shape)
+
+        visible_shapes.push(shape)
+      end
+
+      visible_shapes
+    end
+
+    private
+
+    def find_place(shape)
+      place = Place.new(self, shape)
+      start = Time.now
+      steps = 0
+      
+      loop do
+        steps += 1
+        place.next!
+
+        next unless place.ready?
+
+        board.add(shape)
+        Debug.logger.info 'Place for %p found in %i steps (%.2f sec)' %
+          [shape, steps, Time.now-start]
+
+        break
+      end
+
+      true
+    rescue PlaceNotFound
+      Debug.logger.warn 'No place for %p found in %i steps (%.2f sec)' %
+        [shape, steps, Time.now-start]
+
+      false
+    end
+  end
+end
+
+require_relative './layouter/place'

data/lib/magic_cloud/layouter/place.rb

@@ -0,0 +1,109 @@
+# encoding: utf-8
+module MagicCloud
+  class Layouter
+    class PlaceNotFound < RuntimeError
+    end
+
+    # Incapsulating place lookup process
+    # 1. find initial random place
+    # 2. at each step, shift in spiral from the previous place
+    # 3. always knows, if the place "ready" for shape (empty and inside board)
+    class Place
+      def initialize(layouter, shape)
+        @layouter, @shape = layouter, shape
+
+        # initial position
+        @start_x = (
+          @layouter.width/2 +                # from center
+          (rand-0.5) *                       # random shift
+          (@layouter.width - @shape.width)   # not more than (cloud width - word width)
+        ).to_i
+        @start_y = (
+          @layouter.height/2 +               # from center
+          (rand-0.5) *                       # random shift
+          (@layouter.height - @shape.height) # not more than (cloud height - word height)
+        ).to_i
+
+        # when shift of position is more than max delta (diagonal of cloud)
+        # there is no hope it will eventually found its place
+        @max_delta = Math.sqrt(@layouter.width**2 + @layouter.height**2)
+
+        # algo of next position calc
+        @spiral = make_spiral(@shape.size)
+
+        # direction of spiral
+        @dt = rand < 0.5 ? 1 : -1 
+
+        # initial point of time before we start to look for place
+        @t = -@dt
+      end
+
+      def next!
+        @t += @dt
+        dx, dy = @spiral.call(@t)
+
+        fail PlaceNotFound if [dx, dy].map(&:abs).min > @max_delta
+
+        @shape.x = @start_x + dx
+        @shape.y = @start_y + dy
+      end
+
+      def ready?
+        !out_of_board? && !@layouter.board.collides?(@shape)
+      end
+
+      private
+
+      def out_of_board?
+        @shape.left < 0 || @shape.top < 0 ||
+          @shape.right > @layouter.width || @shape.bottom > @layouter.height
+      end
+
+      # FIXME: now we always use "rectangular spiral"
+      # d3.layout.cloud had two of them as an option - rectangular and
+      # archimedean. I assume, it should be checked if usage of two
+      # spirals produce significantly different results, and then
+      # either one spiral should left, or it should became an option.
+      def make_spiral(step)
+        rectangular_spiral(step)
+      end
+
+      # rubocop:disable Metrics/AbcSize
+      def archimedean_spiral(size)
+        e = width / height
+        ->(t){
+          t1 = t * size * 0.01
+
+          [
+            e * t1 * Math.cos(t1),
+            t1 * Math.sin(t1)
+          ].map(&:round)
+        }
+      end
+
+      def rectangular_spiral(size)
+        dy = 4 * size * 0.1
+        dx = dy * @layouter.width / @layouter.height
+        x = 0
+        y = 0
+        ->(t){
+          sign = t < 0 ? -1 : 1
+
+          # zverok: this is original comment & code from d3.layout.cloud.js
+          # Looks too witty for me.
+          #
+          # See triangular numbers: T_n = n * (n + 1) / 2.
+          case (Math.sqrt(1 + 4 * sign * t) - sign).to_i & 3
+          when 0 then x += dx
+          when 1 then y += dy
+          when 2 then x -= dx
+          else        y -= dy
+          end
+
+          [x, y].map(&:round)
+        }
+      end
+      # rubocop:enable Metrics/AbcSize
+    end
+  end
+end

data/lib/magic_cloud/palettes.rb

@@ -0,0 +1,33 @@
+# encoding: utf-8
+module MagicCloud
+  PALETTES = {
+    # Categorical colors from d3
+    # Source: https://github.com/mbostock/d3/wiki/Ordinal-Scales#categorical-colors
+    
+    category10: %w[
+      #1f77b4 #ff7f0e #2ca02c #d62728 #9467bd
+      #8c564b #e377c2 #7f7f7f #bcbd22 #17becf
+    ],
+
+    category20: %w[
+      #1f77b4 #aec7e8 #ff7f0e #ffbb78 #2ca02c
+      #98df8a #d62728 #ff9896 #9467bd #c5b0d5
+      #8c564b #c49c94 #e377c2 #f7b6d2 #7f7f7f
+      #c7c7c7 #bcbd22 #dbdb8d #17becf #9edae5
+    ],
+    
+    category20b: %w[
+      #393b79 #5254a3 #6b6ecf #9c9ede #637939
+      #8ca252 #b5cf6b #cedb9c #8c6d31 #bd9e39
+      #e7ba52 #e7cb94 #843c39 #ad494a #d6616b
+      #e7969c #7b4173 #a55194 #ce6dbd #de9ed6
+    ],
+
+    category20c: %w[
+      #3182bd #6baed6 #9ecae1 #c6dbef #e6550d
+      #fd8d3c #fdae6b #fdd0a2 #31a354 #74c476
+      #a1d99b #c7e9c0 #756bb1 #9e9ac8 #bcbddc
+      #dadaeb #636363 #969696 #bdbdbd #d9d9d9
+    ]
+  }
+end

data/lib/magic_cloud/rect.rb

@@ -0,0 +1,88 @@
+# encoding: utf-8
+module MagicCloud
+  # Utility geometrical rectangle, implementing arithmetic interactions
+  # with other rectangles
+  # (not to be confused with drawable shapes)
+  class Rect
+    def initialize(x0, y0, x1, y1)
+      @x0, @y0, @x1, @y1 = x0, y0, x1, y1
+    end
+
+    attr_accessor :x0, :y0, :x1, :y1
+    # NB: we are trying to use instance variables instead of accessors
+    #     inside this class methods, because they are called so many
+    #     times that accessor overhead IS significant.
+    
+    def width
+      @x1 - @x0
+    end
+
+    def height
+      @y1 - @y0
+    end
+
+    def collide?(other)
+      @x1 > other.x0 &&
+        @x0 < other.x1 &&
+        @y1 > other.y0 &&
+        @y0 < other.y1
+    end
+
+    # shift to new coords, preserving the size
+    def move_to(x, y)
+      @x1 += x - @x0
+      @y1 += y - @y0
+      @x0 = x
+      @y0 = y
+    end
+
+    # rubocop:disable Metrics/AbcSize
+    def adjust!(other)
+      @x0 = other.x0 if other.x0 < @x0
+      @y0 = other.y0 if other.y0 < @y0
+      @x1 = other.x1 if other.x1 > @x1
+      @y1 = other.y1 if other.y1 > @y1
+    end
+    # rubocop:enable Metrics/AbcSize
+
+    def adjust(other)
+      dup.tap{|d| d.adjust!(other)}
+    end
+
+    # rubocop:disable Metrics/PerceivedComplexity,Metrics/CyclomaticComplexity,Metrics/AbcSize
+    def criss_cross?(other)
+      # case 1: this one is horizontal:
+      # overlaps other by x, to right and left, and goes inside it by y
+      @x0 < other.x0 && @x1 > other.x1 &&
+        @y0 > other.y0 && @y1 < other.y1 ||
+        # case 2: this one is vertical:
+        # overlaps other by y, to top and bottom, and goes inside it by x
+        @y0 < other.y0 && @y1 > other.y1 &&
+          @x0 > other.x0 && @x1 < other.x1
+    end
+    # rubocop:enable Metrics/PerceivedComplexity,Metrics/CyclomaticComplexity,Metrics/AbcSize
+
+    def intersect(other)
+      # direct comparison is dirtier, yet significantly faster than
+      # something like [@x0, other.x0].max
+      ix0 = @x0 > other.x0 ? @x0 : other.x0
+      ix1 = @x1 < other.x1 ? @x1 : other.x1
+      iy0 = @y0 > other.y0 ? @y0 : other.y0
+      iy1 = @y1 < other.y1 ? @y1 : other.y1
+
+      if ix0 > ix1 || iy0 > iy1
+        nil # rectangles are not intersected, in fact
+      else
+        Rect.new(ix0, iy0, ix1, iy1)
+      end
+    end
+
+    def inspect
+      "#<Rect[#{x0},#{y0};#{x1},#{y1}]>"
+    end
+
+    def to_s
+      "#<Rect[#{x0},#{y0};#{x1},#{y1}]>"
+    end
+  end
+end

data/lib/magic_cloud/shape.rb

@@ -0,0 +1,57 @@
+# encoding: utf-8
+module MagicCloud
+  # Basic "abstract shape" class, with all primitive functionality
+  # necessary for use it in Spriter and Layouter.
+  #
+  # Word for wordcloud is inherited from it, and its potentially
+  # possible to inherit other types of shapes and layout them also.
+  class Shape
+    def initialize
+      @x = 0
+      @y = 0
+      @sprite = nil
+      @rect = nil
+      @width = 0
+      @height = 0
+    end
+
+    attr_reader :sprite, :x, :y, :width, :height, :rect
+
+    def sprite=(sprite)
+      @sprite = sprite
+      @width = sprite.width
+      @height = sprite.height
+      @rect = Rect.new(left, top, right, bottom)
+    end
+
+    def x=(newx)
+      @x = newx
+      @rect.move_to(@x, @y)
+    end
+
+    def y=(newy)
+      @y = newy
+      @rect.move_to(@x, @y)
+    end
+
+    def left
+      x
+    end
+
+    def right
+      x + width
+    end
+
+    def top
+      y
+    end
+
+    def bottom
+      y + height
+    end
+
+    def draw(_canvas)
+      fail NotImplementedError
+    end
+  end
+end