dudegl 0.2.1 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 13f1304b0ae95eb9b152695f413cff69449df95ca35193ecedfe20e34cec3370
-  data.tar.gz: bd6973c943d8f154b7ead9a3ae8534236fc96e063ae991e749a016f9208f1369
+  metadata.gz: 629bfb1702e517a1bf3f5f52fbf5b3c8eb7e82919cd122aadee7ffa494f35979
+  data.tar.gz: fa4395ff7d805a91016f9a384cb2928d7c777e84600e3ff473ff562c02eda072
 SHA512:
-  metadata.gz: 3a50aef2628c1cf09311a07b2d7f46281f7a249b9e444c3e8d36ef5bcb96f2f9e1bd63e0fe03db4958802d1b35625a4eaa94c9a2476f61db5e4ef471e0350e61
-  data.tar.gz: f35a6d614803681b283afdfedeed808108ad8f7a263c5999eb0c0814b45716f5fa216d4b546ff323f63a55a1278465cc0cba5dd7eb609ab887bf28ebb77d2642
+  metadata.gz: a4531659105ee4b4e53cb098ddae20c75eb51bfc5175ace477dc2c705c8f435d2102c91347d789b45534f8dea6d12433130f929f51849094eb387a8b2196d76a
+  data.tar.gz: f2a4f167a1b012c647056ab937029eb9887c34184be036ce7d382f5235999b799ff97fc34f71602808420a4bc0620ca0fa9b174ff14e596610d8941a9938fcd3

data/lib/compose/arms.rb

@@ -0,0 +1,41 @@
+require_relative '../config'
+require_relative 'limbs'
+
+class Arms < Limbs
+
+  private
+
+  def draw
+    super
+    divide_arms
+
+    @left_arms_num.times do |i|
+      @limbs << Arm.new(@left_arms[i], @body.body_left_x, hy(i), :left)
+    end
+
+    @right_arms_num.times do |i|
+       @limbs << Arm.new(@right_arms[i], @body.body_right_x, hy(i), :right)
+    end
+  end
+
+  def draw_parameters
+    return if super
+
+    remainder = @limbs_num % 2
+
+    @left_arms_num = (@limbs_num - remainder) / 2 + remainder
+    @right_arms_num = @limbs_num - @left_arms_num
+
+    # BODY_LENGTH * 0.9 - to avoid drawing hands on a body edges
+    @arms_step = ((Config::BODY_LENGTH * 0.9) / @left_arms_num).round
+  end
+
+  def divide_arms
+    @left_arms = @params_methods[0, @left_arms_num]
+    @right_arms = @params_methods[@left_arms_num, @limbs_num]
+  end
+
+  def hy(i)
+    (1.05 * @body.body_left_top_y + i * @arms_step).round
+  end
+end

data/lib/compose/body.rb

@@ -0,0 +1,51 @@
+require_relative '../utils'
+require_relative '../config'
+
+class Body
+  include Utils
+
+  attr_reader :body_right_x, :body_right_top_y,
+              :body_left_x, :body_left_top_y, :draw_data
+
+  def initialize(name, offsets)
+    @name = name
+    @draw_data = []
+    @offset_x = offsets[:offset_x]
+    @offset_y = offsets[:offset_y]
+    draw_body
+  end
+
+  def draw_body
+    # head center
+    head_center_x = 0.5 * Config::DUDE_FRAME_SIZE + @offset_x
+    head_center_y = 0.3 * Config::DUDE_FRAME_SIZE + @offset_y
+
+    @body_right_x, @body_right_top_y = circle_rotate(head_center_x, head_center_y,
+                                                     Config::HEAD_RADIUS,
+                                                     Config::BODY_CENTER + Config::SLIM_FACTOR)
+    @body_left_x, @body_left_top_y = circle_rotate(head_center_x, head_center_y,
+                                                     Config::HEAD_RADIUS,
+                                                     Config::BODY_CENTER - Config::SLIM_FACTOR)
+
+    @draw_data << {
+      circle: {
+      cx: head_center_x,
+      cy: head_center_y,
+      r: Config::HEAD_RADIUS
+      }
+    }
+
+    @draw_data << draw_line(@body_right_x, @body_right_top_y,
+                            @body_right_x, @body_right_top_y + Config::BODY_LENGTH)
+    # left part of a body
+    @draw_data << draw_line(@body_left_x, @body_left_top_y,
+                            @body_left_x, @body_left_top_y + Config::BODY_LENGTH)
+    # bottom
+    @draw_data << draw_line(@body_right_x, @body_right_top_y + Config::BODY_LENGTH,
+                            @body_left_x, @body_left_top_y + Config::BODY_LENGTH)
+
+    @draw_data << draw_caption(@name, head_center_x - Config::HEAD_RADIUS,
+                               head_center_y - 1.1 * Config::HEAD_RADIUS,
+                               font_size: 10)
+  end
+end

data/lib/compose/dudes_location.rb

@@ -0,0 +1,48 @@
+require_relative '../config'
+
+# arrange several dudes on canvas
+class DudesLocation
+  attr_reader :offsets, :canvas_size_x, :canvas_size_y
+
+  def initialize(params_list, dudes_per_row_max = nil)
+    @dudes_num = params_list.size
+    @offsets = []
+
+    if dudes_per_row_max.nil?
+      @dudes_per_row_max = Config::DUDES_PER_ROW_MAX
+    else
+      @dudes_per_row_max = dudes_per_row_max
+    end
+
+    compute_dudes_coordiantes
+    compute_canvas_size
+  end
+
+  private
+
+  # returns array with number of dudes in each row
+  # e.g. if we have 12 dudes and only 5 are allowed per row, then the output will be [5, 5, 2])
+  def compute_dudes_per_each_row
+    remaining_dudes = @dudes_num % @dudes_per_row_max
+    rows_num = (@dudes_num - remaining_dudes) / @dudes_per_row_max
+    full_rows = [@dudes_per_row_max] * rows_num
+    remaining_dudes > 0 ? full_rows + [remaining_dudes]: full_rows
+  end
+
+  def compute_dudes_coordiantes
+    @dudes_per_each_row = compute_dudes_per_each_row
+    offset_y = 0
+    @dudes_per_each_row.each_with_index do |dudes_in_row, y_index|
+      dudes_in_row.times do |x_index|
+        @offsets << { offset_x: x_index * Config::OFFSET_X, offset_y: y_index * Config::OFFSET_Y }
+      end
+    end
+  end
+
+  def compute_canvas_size
+    #  max x size of canvas is x offset for the last dude in 1st row - @dudes_per_each_row.first - 1
+    # @offsets.last[:offset_y] - last dude has max y offset
+    @canvas_size_x = @offsets[@dudes_per_each_row.first - 1][:offset_x] + Config::DUDE_FRAME_SIZE
+    @canvas_size_y = @offsets.last[:offset_y] + Config::DUDE_FRAME_SIZE
+  end
+end

data/lib/compose/legs.rb

@@ -0,0 +1,25 @@
+require_relative '../config'
+require_relative 'limbs'
+
+class Legs < Limbs
+
+  private
+
+  def draw
+    super
+
+    @limbs_num.times do |i|
+      @limbs << Leg.new(@params_methods[i], hx(i), @body.body_right_top_y + Config::BODY_LENGTH)
+    end
+  end
+
+  def draw_parameters
+    return if super
+    @legs_step = (((@body.body_right_x - @body.body_left_x) * 0.9) / @limbs_num).round
+  end
+
+  def hx(i)
+    body_margin = (@body.body_right_x - @body.body_left_x) * 0.1
+    (@body.body_left_x + i * @legs_step + body_margin).round
+  end
+end

data/lib/compose/limbs.rb

@@ -0,0 +1,30 @@
+require_relative '../config'
+
+class Limbs
+  attr_reader :limbs
+
+  def initialize(params, body)
+    @params = params
+    @body = body
+    @limbs = []
+
+    draw_parameters
+    draw if @limbs_num.positive?
+  end
+
+  private
+
+  def draw; end
+
+  def draw_parameters
+    @params_methods = @params[:methods].select { |param| param[:args].public_send(select_operator, 0) }
+    @limbs_num = @params_methods.size
+    return true if @limbs_num == 0
+  end
+
+  # dynamically select operator depending on a child class name
+  def select_operator
+    return '>' if self.class.name.downcase.include?('arm')
+    return '==' if self.class.name.downcase.include?('leg')
+  end
+end

data/lib/config.rb

@@ -1,18 +1,30 @@
 module Config
-  STYLE = { stroke: 'black', stroke_width: 1 }
   IMAGE_DIR = 'images'
 
+  METHOD_LENGTH_OK_MAX = 5
+
+  # dude's parameters
   BODY_LENGTH = 140
   BODY_CENTER = Math::PI * (3 / 2.0)
   # defines how slim is a body
   SLIM_FACTOR = Math::PI * (2 / 8.0)
   HEAD_RADIUS = 40
 
-  METHOD_LENGTH_OK_MAX = 5
-  ARM_LENGTH = 40
-  ARM_LENGTH_LONG = 70
+  LIMB_LENGTH = 40
+  LIMB_LENGTH_LONG = 70
   ELLIPSE_LENGTH = 10
 
   FINGER_LENGTH = 10
   FINGER_ANGLE_START = Math::PI * (3 / 4.0)
+  FINGERS_RANGE = Math::PI / 2.0
+
+  # size of an square area in pixels where one dude is depicted
+  DUDE_FRAME_SIZE = 400
+
+  # for LocateDudes class
+  DUDES_PER_ROW_MAX = 6
+
+  # coordinates offset for drawing multiple dudes on a canvas
+  OFFSET_X = 0.7 * DUDE_FRAME_SIZE
+  OFFSET_Y = 0.8 * DUDE_FRAME_SIZE
 end

data/lib/dudegl.rb

@@ -1,21 +1,41 @@
-require 'victor'
-require_relative 'dude'
-require_relative 'arm'
+require 'byebug'
+# require all filder from current dir and subdirectories
+Dir[File.dirname(__FILE__) + '/**/*.rb'].each {|file| require_relative file }
 
 class DudeGl
-  def create_canvas(width = 400, height = 400)
-    @canvas = Victor::SVG.new width: width, height: height, style: { background: 'white' }
+  def initialize(params_list, dudes_per_row_max = nil)
+    @params_list = params_list
+    @dudes = []
+    @locations = DudesLocation.new(@params_list, dudes_per_row_max)
+
+    build_dudes
+  end
+
+  def render
+    @svg = Render.new(@dudes.flatten,
+                      width = @locations.canvas_size_x,
+                      height = @locations.canvas_size_y)
   end
 
-  def create_dude
-    Dude.new(@canvas)
+  def save(file_name)
+    File.open("images/#{file_name}.svg", 'w') { |file| file.write(@svg.contents) }
   end
 
-  def add_arm(params, x0, y0, body_side)
-    Arm.new(@canvas, params, x0, y0, body_side)
+  private
+
+  def build_dudes
+    @params_list.each_with_index { |params, index| @dudes << build_dude(params, index) }
   end
 
-  def save_to_svg(file_name)
-    @canvas.save "#{Config::IMAGE_DIR}/#{file_name}"
+  def build_dude(params, index)
+    body = Body.new(params[:name], offsets = @locations.offsets[index])
+
+    arms = Arms.new(params, body).limbs
+    arms_draw_params = arms.map { |arm| arm.draw_data }
+
+    legs = Legs.new(params, body).limbs
+    legs_draw_params = legs.map { |leg| leg.draw_data }
+
+    (body.draw_data + arms_draw_params + legs_draw_params).flatten
   end
 end

data/lib/limbs/arm.rb

@@ -0,0 +1,72 @@
+require_relative 'limb'
+
+class Arm < Limb
+  attr_reader :body_side
+
+  def initialize(params, x0, y0, body_side)
+    @body_side = body_side
+    super(params, x0, y0)
+  end
+
+  private
+
+  def draw
+    super
+    @end_x = @x0 + @limb_length
+
+    if @params[:conditions].positive?
+      draw_conditions
+    else
+      @draw_data << draw_line(@x0, @y0, @x0 + @limb_length, @y0)
+    end
+
+    @draw_data << draw_caption(@params[:name], (@end_x - 20).round, (@y0 - 10).round)
+    draw_fingers(@params[:args])
+  end
+
+  def draw_conditions
+    @lines_num = @params[:conditions] + 1
+    @line_length = ((@limb_length.abs - @params[:conditions] * Config::ELLIPSE_LENGTH) / @lines_num).round
+
+    @x1 = @x0 + @line_length * orientation
+
+    @lines_num.times { |i| draw_condition(i) }
+  end
+
+  def draw_condition(i)
+    @draw_data << draw_line(@x0, @y0, @x1, @y0)
+
+    @draw_data << { ellipse: {
+                    cx: (@x1 + Config::ELLIPSE_LENGTH * orientation / 2).round,
+                    cy: @y0, rx: (Config::ELLIPSE_LENGTH / 2).round,
+                    ry: (Config::ELLIPSE_LENGTH / 4).round }} if i < @lines_num - 1
+
+    @x0 += (@line_length + Config::ELLIPSE_LENGTH) * orientation
+    @x1 = @x0 + @line_length * orientation
+  end
+
+  def draw_fingers(args_num)
+    if body_side == :left
+      finger_angle_start = Config::FINGER_ANGLE_START
+      finger_angle_end = finger_angle_start + Config::FINGERS_RANGE
+      finger_angle_step = calc_fingers_range(Config::FINGERS_RANGE, args_num)
+    else
+      finger_angle_start = - Config::FINGER_ANGLE_START + Math::PI
+      finger_angle_end = finger_angle_start - Config::FINGERS_RANGE
+      finger_angle_step = - calc_fingers_range(Config::FINGERS_RANGE, args_num)
+    end
+
+    args_num.times do |i|
+      finger_end_x, finger_end_y = circle_rotate(end_x, end_y, Config::FINGER_LENGTH,
+                                                 finger_angle_start + finger_angle_step * i)
+
+      @draw_data << draw_line(end_x, end_y, finger_end_x, finger_end_y)
+    end
+  end
+
+  def calc_fingers_range(fingers_range, args_num)
+    return fingers_range / (args_num - 1).to_f if args_num > 1
+    return fingers_range / args_num.to_f if args_num == 1
+    return 0
+  end
+end

data/lib/limbs/leg.rb

@@ -0,0 +1,41 @@
+require_relative 'limb'
+
+class Leg < Limb
+
+  private
+
+  def draw
+    super
+    caption_start_x = @x0
+    caption_y_start = @y0
+
+    if @params[:conditions].positive?
+      draw_conditions
+    else
+      @draw_data << draw_line(@x0, @y0, @x0, @y0 + @limb_length)
+    end
+
+    @draw_data << draw_caption(@params[:name], (caption_start_x + 10).round, (caption_y_start + 10).round, 9, :tb)
+  end
+
+  def draw_conditions
+    @lines_num = @params[:conditions] + 1
+    @line_length = ((@limb_length.abs - @params[:conditions] * Config::ELLIPSE_LENGTH) / @lines_num).round
+
+    @y1 = @y0 + @line_length
+
+    @lines_num.times { |i| draw_condition(i) }
+  end
+
+  def draw_condition(i)
+    @draw_data << draw_line(@x0, @y0, @x0, @y1)
+
+    @draw_data << { ellipse: {
+      cx: @x0, cy: (@y1 + Config::ELLIPSE_LENGTH / 2).round ,
+      rx: (Config::ELLIPSE_LENGTH / 4).round, ry: (Config::ELLIPSE_LENGTH / 2).round
+      }} if i < @lines_num - 1
+
+    @y0 += @line_length + Config::ELLIPSE_LENGTH
+    @y1 = @y0 + @line_length
+  end
+end

data/lib/limbs/limb.rb

@@ -0,0 +1,33 @@
+require_relative '../config'
+
+class Limb
+  include Utils
+
+  attr_reader :end_x, :end_y, :draw_data
+
+  def initialize(params, x0, y0)
+    @params = params
+    @x0 = x0
+    @end_y = @y0 = y0
+    @draw_data = []
+
+    draw
+  end
+
+  private
+
+  def draw
+    @limb_length = compute_limb_length
+  end
+
+  def compute_limb_length
+    @params[:length] <= Config::METHOD_LENGTH_OK_MAX ? Config::LIMB_LENGTH * orientation : Config::LIMB_LENGTH_LONG * orientation
+  end
+
+  def orientation
+    return 1 if @body_side.nil?
+    @body_side == :left ? -1 : 1
+  end
+
+  def draw_conditions; end
+end

data/lib/render.rb

@@ -0,0 +1,59 @@
+require_relative 'config'
+
+class Render
+  attr_reader :contents
+
+  def initialize(elements, width = Config::DUDE_FRAME_SIZE, height = Config::DUDE_FRAME_SIZE)
+    code = []
+    code << %Q[<svg width="#{width}" height="#{height}" style="background:white" xmlns="http://www.w3.org/2000/svg">]
+    elements.each { |element| code << hash_to_svg(element) }
+    code << %Q[</svg>]
+
+    @contents = code.join("\n")
+  end
+
+  private
+
+  def hash_to_svg(hash)
+    operator, params = hash.first
+    send("svg_#{operator.to_s}".to_sym, params) if defined? operator
+  end
+
+  def svg_line(params)
+    <<~LINE.gsub(/\s+/, " ").strip
+      <line x1="#{params[:x1]}" y1="#{params[:y1]}"
+      x2="#{params[:x2]}"
+      y2="#{params[:y2]}"
+      style="stroke:black; stroke-width:1"/>
+    LINE
+  end
+
+  def svg_circle(params)
+    <<~CIRCLE.gsub(/\s+/, " ").strip
+      <circle cx="#{params[:cx]}"
+      cy="#{params[:cy]}"
+      r="#{params[:r]}"
+      fill="white" style="stroke:black; stroke-width:1"/>
+    CIRCLE
+  end
+
+  def svg_ellipse(params)
+    <<~ELLIPSE.gsub(/\s+/, " ").strip
+      <ellipse cx="#{params[:cx]}"
+      cy="#{params[:cy]}"
+      rx="#{params[:rx]}"
+      ry="#{params[:ry]}"
+      style="stroke:black; stroke-width:1" fill="white"/>
+    ELLIPSE
+  end
+
+  def svg_text(params)
+    <<~TEXT.gsub(/\s+/, " ").strip
+      <text x="#{params[:x]}"
+      y="#{params[:y]}"
+      font-family="arial" font-size="#{params[:font_size]}"
+      fill="black" style="writing-mode:
+      #{params[:orientation].to_s}">#{params[:caption]}</text>
+    TEXT
+  end
+end

data/lib/utils.rb

@@ -1,5 +1,3 @@
-require_relative 'config'
-
 module Utils
   def circle_rotate(center_x, center_y, r, rotation)
     x_rotated = center_x + r * Math.cos(rotation)
@@ -7,17 +5,11 @@ module Utils
     return [x_rotated, y_rotated]
   end
 
-  def calc_range(fingers_range, args_num)
-    return fingers_range / (args_num - 1).to_f if args_num > 1
-    return fingers_range / args_num.to_f if args_num == 1
-    return 0
-  end
-
-  def draw_line(canvas, x1, y1, x2, y2)
-    canvas.line x1: x1, y1: y1, x2: x2, y2: y2, style: Config::STYLE
+  def draw_line(x1, y1, x2, y2)
+    { line: { x1: x1, y1: y1, x2: x2, y2: y2 } }
   end
 
-  def draw_caption(canvas, caption, x, y)
-    canvas.text caption, x: x, y: y, font_family: 'arial', font_size: 9, fill: 'black'
+  def draw_caption(caption, x, y, font_size = 9, orientation = :lr)
+    { text: { x: x, y: y, caption: caption, font_size: font_size, orientation: orientation } }
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dudegl
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.2.2
 platform: ruby
 authors:
 - Dmitry Khramtsov
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-12-11 00:00:00.000000000 Z
+date: 2019-12-26 00:00:00.000000000 Z
 dependencies: []
 description: 'Anthropomorphic UML: visualization of code and OOP concepts in a form
   of human body.'
@@ -19,10 +19,17 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- lib/arm.rb
+- lib/compose/arms.rb
+- lib/compose/body.rb
+- lib/compose/dudes_location.rb
+- lib/compose/legs.rb
+- lib/compose/limbs.rb
 - lib/config.rb
-- lib/dude.rb
 - lib/dudegl.rb
+- lib/limbs/arm.rb
+- lib/limbs/leg.rb
+- lib/limbs/limb.rb
+- lib/render.rb
 - lib/utils.rb
 homepage: https://github.com/dmikhr/DudeGL/wiki
 licenses:

data/lib/arm.rb

@@ -1,80 +0,0 @@
-require_relative 'config'
-require_relative 'utils'
-
-class Arm
-  include Utils
-
-  attr_reader :end_x, :end_y, :body_side
-
-  def initialize(canvas, params, x0, y0, body_side)
-    @canvas = canvas
-    @params = params
-    @x0 = x0
-    @y0 = y0
-    @end_y = y0
-    @body_side = body_side
-
-    draw_arm
-  end
-
-  def draw_arm
-    caption = @params[:name]
-    length = @params[:length]
-    args_num = @params[:args]
-    conditions = @params[:conditions]
-
-    length <= Config::METHOD_LENGTH_OK_MAX ? arm_length = Config::ARM_LENGTH : arm_length = Config::ARM_LENGTH_LONG
-    arm_length = - arm_length if @body_side == :left
-    @end_x = @x0 + arm_length
-
-    if conditions.positive?
-      draw_conditions(conditions, arm_length, @x0, @y0, @body_side)
-    else
-      draw_line(@canvas, @x0, @y0, @x0 + arm_length, @y0)
-    end
-
-    draw_caption(@canvas, caption, 0.8 * (@x0 + arm_length).round, (0.95 * @y0).round)
-    draw_fingers(args_num)
-  end
-
-  def draw_conditions(conditions, arm_length, x0, y0, body_side)
-    lines_num = conditions + 1
-    line_length = ((arm_length.abs - conditions * Config::ELLIPSE_LENGTH) / lines_num).round
-    body_side == :left ? orientation = -1 : orientation = 1
-
-    x0 = x0
-    x1 = x0 + line_length * orientation
-
-    lines_num.times do |i|
-      draw_line(@canvas, x0, y0, x1, y0)
-
-      @canvas.ellipse cx: (x1 + Config::ELLIPSE_LENGTH * orientation / 2).round,
-                      cy: y0, rx: (Config::ELLIPSE_LENGTH / 2).round, ry: (Config::ELLIPSE_LENGTH / 4).round,
-                      style: Config::STYLE, fill: 'white' if i < lines_num - 1
-
-      x0 = x0 + (line_length + Config::ELLIPSE_LENGTH) * orientation
-      x1 = x0 + line_length * orientation
-    end
-  end
-
-  def draw_fingers(args_num)
-    fingers_range = Math::PI / 2.0
-
-    if body_side == :left
-      finger_angle_start = Config::FINGER_ANGLE_START
-      finger_angle_end = finger_angle_start + fingers_range
-      finger_angle_step = calc_range(fingers_range, args_num)
-    else
-      finger_angle_start = - Config::FINGER_ANGLE_START + Math::PI
-      finger_angle_end = finger_angle_start - fingers_range
-      finger_angle_step = - calc_range(fingers_range, args_num)
-    end
-
-    args_num.times do |i|
-      finger_end_x, finger_end_y = circle_rotate(end_x, end_y, Config::FINGER_LENGTH,
-                                                 finger_angle_start + finger_angle_step * i)
-
-      draw_line(@canvas, end_x, end_y, finger_end_x, finger_end_y)
-    end
-  end
-end

data/lib/dude.rb

@@ -1,40 +0,0 @@
-require_relative 'utils'
-require_relative 'config'
-
-class Dude
-  include Utils
-
-  attr_reader :body_right_x, :body_right_top_y, :body_left_x, :body_left_top_y
-
-  def initialize(canvas, width = 400, height = 400)
-    @width = width
-    @height = height
-    @canvas = canvas
-    draw_dude
-  end
-
-  def draw_dude
-    # head center
-    head_center_x = (0.5 * @width).round
-    head_center_y = (0.3 * @height).round
-
-    @body_right_x, @body_right_top_y = circle_rotate(head_center_x, head_center_y,
-                                                     Config::HEAD_RADIUS,
-                                                     Config::BODY_CENTER + Config::SLIM_FACTOR)
-    @body_left_x, @body_left_top_y = circle_rotate(head_center_x, head_center_y,
-                                                   Config::HEAD_RADIUS,
-                                                   Config::BODY_CENTER - Config::SLIM_FACTOR)
-    # head
-    @canvas.circle cx: head_center_x, cy: head_center_y, r: Config::HEAD_RADIUS,
-                fill: 'white', style: Config::STYLE
-    # right part of a body
-    draw_line(@canvas, @body_right_x, @body_right_top_y,
-              @body_right_x, @body_right_top_y + Config::BODY_LENGTH)
-    # left part of a body
-    draw_line(@canvas, @body_left_x, @body_left_top_y,
-              @body_left_x, @body_left_top_y + Config::BODY_LENGTH)
-    # bottom
-    draw_line(@canvas, @body_right_x, @body_right_top_y + Config::BODY_LENGTH,
-              @body_left_x, @body_left_top_y + Config::BODY_LENGTH)
-  end
-end