scad-btw 0.1.0.pre1

data/lib/scad/btw/component/counterweight.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require 'scad/btw/concerns/component_args'
+require 'scad/btw/concerns/part_commons'
+require 'scad/btw/concerns/tread_width'
+
+module Scad
+  module Btw
+    module Component
+      class Counterweight < JennCad::Part
+        include Scad::Btw::Concerns::PartCommons
+        include Scad::Btw::Concerns::ComponentArgs
+        include Scad::Btw::Concerns::TreadWidth
+
+        TYPE = :addition
+        DEFAULT_DEVIATION = 0
+
+        ARGS = {
+          prefix: :counterweight,
+          args: {
+            height: {
+              description: 'Counterweight height. Defaults to: Height of ' \
+                           'spokes or web defined be `wheel_inner_height` ' \
+                           'option.',
+              type: :numeric
+            },
+            diameter: {
+              description: 'Wheel diameter. Defaults to: Wheel diameter ' \
+                           'defined by `wheel_size` option.',
+              type: :numeric,
+              hide: true
+            },
+            tread_width: {
+              description: "Tread width. Minimum width of #{MIN_TREAD_WIDTH} " \
+                           'will be used if provided/default value is ' \
+                           'smaller. Defaults to: Diameter * 0.06',
+              type: :numeric,
+              hide: true
+            },
+            deviation: {
+              description: 'Defines convexity of the counterweight top.',
+              default: DEFAULT_DEVIATION,
+              type: :numeric
+            },
+            width: {
+              description: 'Distance from tread to counterweight top. ' \
+                           'Defaults to: Diameter / 4',
+              type: :numeric
+            }
+          }
+        }.freeze
+
+        def initialize(args = {})
+          super
+
+          @height = args.fetch(:height)
+          @diameter = args.fetch(:diameter)
+          @tread_width = args[:tread_width]
+          @deviation = args[:deviation] || DEFAULT_DEVIATION
+          @width = args[:width]
+        end
+
+        def part
+          cylinder(d: calculated_diameter, h: height) - substraction
+        end
+
+        private
+
+        attr_reader :width, :height, :deviation, :diameter, :tread_width
+
+        # components
+
+        def substraction
+          deviation.positive? ? deviation_substraction : straight_substraction
+        end
+
+        def deviation_substraction
+          x = calculated_width - deviation + deviation_diff_radius -
+              (calculated_diameter / 2)
+          cylinder(r: deviation_diff_radius, h: height + 1)
+            .move(x: x, y: 0, z: -0.5)
+        end
+
+        def straight_substraction
+          cube(x: calculated_diameter, y: calculated_diameter, z: height + 1,
+               center: true)
+            .move(x: calculated_width, y: 0, z: -0.5)
+        end
+
+        # functions
+
+        def calculated_width
+          width || (calculated_diameter / 4)
+        end
+
+        def calculated_diameter
+          calc_width = calculated_tread_width(width: tread_width,
+                                              diameter: diameter)
+
+          diameter - calc_width + (2 * overlap)
+        end
+
+        def half_upper_counterweight_length
+          Math.sqrt(
+            ((calculated_diameter / 2)**2) -
+            (((calculated_diameter / 2) - calculated_width)**2)
+          )
+        end
+
+        def deviation_diff_radius
+          ((half_upper_counterweight_length**2) + (deviation**2)) /
+            (2 * deviation)
+        end
+      end
+    end
+  end
+end

data/lib/scad/btw/component/flange.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require 'scad/btw/concerns/component_args'
+require 'scad/btw/concerns/flange_heights'
+require 'scad/btw/concerns/part_commons'
+
+module Scad
+  module Btw
+    module Component
+      class Flange < JennCad::Part
+        include Scad::Btw::Concerns::PartCommons
+        include Scad::Btw::Concerns::ComponentArgs
+        include Scad::Btw::Concerns::FlangeHeights
+
+        TYPE = :addition
+        WIDTH = 2
+        BOTTOM_Z_OFFSET = 1
+
+        ARGS = {
+          prefix: :flange,
+          args: {
+            diameter: {
+              description: 'Wheel diameter. Defaults to: Wheel diameter ' \
+                           'defined by `wheel_size` option.',
+              type: :numeric,
+              hide: true
+            },
+            inner_height: {
+              description: 'Flange height on tread.',
+              default: FLANGE_INNER_HEIGHT,
+              type: :numeric
+            },
+            outer_height: {
+              description: 'Flange height on edge.',
+              default: FLANGE_OUTER_HEIGHT,
+              type: :numeric
+            },
+            width: {
+              description: 'Flange width.',
+              default: WIDTH,
+              type: :numeric
+            }
+          }
+        }.freeze
+
+        def initialize(args = {})
+          super
+
+          @diameter = args.fetch(:diameter)
+          @width = args[:width] || WIDTH
+          @inner_height = args[:inner_height]
+          @outer_height = args[:outer_height]
+        end
+
+        def part
+          lower_part + upper_part - inner_space
+        end
+
+        private
+
+        attr_reader :diameter, :width, :inner_height, :outer_height
+
+        # components
+
+        def lower_part
+          cylinder(d1: outer_diameter + 0.5, d2: outer_diameter,
+                   h: calc_outer_height).mz(BOTTOM_Z_OFFSET)
+        end
+
+        def upper_part
+          cylinder(d1: outer_diameter - 1, d2: diameter - overlap,
+                   h: calc_inner_height - calc_outer_height - BOTTOM_Z_OFFSET)
+            .mz(calc_outer_height + BOTTOM_Z_OFFSET - overlap)
+        end
+
+        def inner_space
+          cylinder(d: diameter - (2 * overlap), h: calc_inner_height + 2).mz(-1)
+        end
+
+        # functions
+
+        def calc_inner_height
+          calculated_inner_flange_height(inner_height)
+        end
+
+        def calc_outer_height
+          calculated_outer_flange_height(outer_height)
+        end
+
+        def outer_diameter
+          diameter + (2 * width)
+        end
+      end
+    end
+  end
+end

data/lib/scad/btw/component/joint.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'scad/btw/concerns/component_args'
+require 'scad/btw/concerns/part_commons'
+require 'scad/btw/concerns/joint_args'
+
+module Scad
+  module Btw
+    module Component
+      class Joint < JennCad::Part
+        include Scad::Btw::Concerns::PartCommons
+        include Scad::Btw::Concerns::ComponentArgs
+        include Scad::Btw::Concerns::JointArgs
+
+        TYPE = :substraction
+        HOLE_BEVEL_DIAMETER = 6.2
+        HOLE_BEVEL_HEIGHT = 0.9
+
+        def part
+          (hole + lower_bevel + upper_bevel).mx(calculated_dist_from_center)
+        end
+
+        private
+
+        attr_reader :height, :dist_from_center
+
+        # components
+
+        def hole
+          cylinder(d: HOLE_DIAMETER, h: height + 1).mz(-0.5)
+        end
+
+        def lower_bevel
+          bevel.mz(lower_bevel_z_offset)
+        end
+
+        def upper_bevel
+          bevel.mz(upper_bevel_z_offset)
+        end
+
+        def bevel
+          cylinder(d: HOLE_BEVEL_DIAMETER, h: HOLE_BEVEL_HEIGHT + 0.1)
+        end
+
+        # functions
+
+        def lower_bevel_z_offset
+          -0.1
+        end
+
+        def upper_bevel_z_offset
+          height - HOLE_BEVEL_HEIGHT
+        end
+      end
+    end
+  end
+end

data/lib/scad/btw/component/joint_base.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'scad/btw/concerns/component_args'
+require 'scad/btw/concerns/part_commons'
+require 'scad/btw/concerns/joint_args'
+
+module Scad
+  module Btw
+    module Component
+      class JointBase < JennCad::Part
+        include Scad::Btw::Concerns::PartCommons
+        include Scad::Btw::Concerns::ComponentArgs
+        include Scad::Btw::Concerns::JointArgs
+
+        TYPE = :addition
+
+        def part
+          cylinder(d: calculated_diameter, h: height)
+            .mx(calculated_dist_from_center)
+        end
+
+        private
+
+        attr_reader :height, :dist_from_center, :diameter
+
+        def calculated_diameter
+          min_diameter = HOLE_DIAMETER + (2 * MIN_HOLE_WALL_THICKNESS)
+
+          [diameter || min_diameter, min_diameter].max
+        end
+      end
+    end
+  end
+end

data/lib/scad/btw/component/o_ring_groove.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require 'scad/btw/concerns/component_args'
+require 'scad/btw/concerns/flange_heights'
+require 'scad/btw/concerns/part_commons'
+require_relative 'flange'
+
+module Scad
+  module Btw
+    module Component
+      class ORingGroove < JennCad::Part
+        include Scad::Btw::Concerns::PartCommons
+        include Scad::Btw::Concerns::ComponentArgs
+        include Scad::Btw::Concerns::FlangeHeights
+
+        TYPE = :substraction
+        GROOVE_DIAMETER = 1.5
+        THIN_GROOVE_DIAMETER = 1
+        THIN_GROOVE = false
+
+        ARGS = {
+          prefix: :o_ring_groove,
+          args: {
+            diameter: {
+              description: 'Wheel diameter. Defaults to: Wheel diameter ' \
+                           'defined by `wheel_size` option.',
+              type: :numeric,
+              hide: true
+            },
+            flange_height: {
+              description: 'Flange height on tread.',
+              default: FLANGE_INNER_HEIGHT,
+              type: :numeric,
+              hide: true
+            },
+            thin: {
+              description: 'Whether groove is thin (1 mm) or not (1.5 mm). ' \
+                           'Defaults to: true if wheel is thin, false ' \
+                           'otherwise.',
+              type: :boolean
+            }
+          }
+        }.freeze
+
+        def initialize(args = {})
+          super
+
+          @diameter = args.fetch(:diameter)
+          @flange_height = args[:flange_height]
+          @thin = args[:thin] || THIN_GROOVE
+        end
+
+        def part
+          res = cross_section.rotate_extrude
+
+          res.mz(z_offset)
+        end
+
+        private
+
+        attr_reader :diameter, :flange_height, :thin
+
+        # components
+
+        def cross_section
+          (cs_circle + cs_square).mx((diameter - (groove_diameter * 4 / 5)) / 2)
+        end
+
+        def cs_circle
+          circle(d: groove_diameter)
+        end
+
+        def cs_square
+          square(x: groove_diameter, y: groove_diameter, center: true)
+            .mx(groove_diameter / 2)
+        end
+
+        # functions
+
+        def groove_diameter
+          (thin ? GROOVE_DIAMETER : THIN_GROOVE_DIAMETER) * 4 / 5
+        end
+
+        def z_offset
+          (calc_flange_height + (groove_diameter / 2)) -
+            0.1 + (thin ? 0.15 : 1)
+        end
+
+        def calc_flange_height
+          calculated_inner_flange_height(flange_height)
+        end
+      end
+    end
+  end
+end

data/lib/scad/btw/component/solid.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require 'scad/btw/concerns/component_args'
+require 'scad/btw/concerns/part_commons'
+require 'scad/btw/concerns/tread_width'
+
+module Scad
+  module Btw
+    module Component
+      class Solid < JennCad::Part
+        include Scad::Btw::Concerns::PartCommons
+        include Scad::Btw::Concerns::ComponentArgs
+        include Scad::Btw::Concerns::TreadWidth
+
+        TYPE = :addition
+
+        ARGS = {
+          prefix: :solid,
+          args: {
+            height: {
+              description: 'Web height. Defaults to: Value/default of ' \
+                           '`wheel_inner_height` option.',
+              type: :numeric,
+              hide: true
+            },
+            diameter: {
+              description: 'Wheel diameter. Defaults to: Wheel diameter ' \
+                           'defined by `wheel_size` option.',
+              type: :numeric,
+              hide: true
+            },
+            tread_width: {
+              description: "Tread width. Minimum width of #{MIN_TREAD_WIDTH} " \
+                           'will be used if provided/default value is ' \
+                           'smaller. Defaults to: Diameter * 0.06',
+              type: :numeric,
+              hide: true
+            }
+          }
+        }.freeze
+
+        def initialize(args = {})
+          super
+
+          @height = args.fetch(:height)
+          @diameter = args.fetch(:diameter)
+          @tread_width = args[:tread_width]
+        end
+
+        def part
+          cylinder(d: calculated_diameter, h: height)
+        end
+
+        private
+
+        attr_reader :height, :diameter, :tread_width
+
+        def calculated_diameter
+          calc_width = calculated_tread_width(width: tread_width,
+                                              diameter: diameter)
+
+          diameter - calc_width + (2 * overlap)
+        end
+      end
+    end
+  end
+end

data/lib/scad/btw/component/spokes.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+require 'scad/btw/concerns/component_args'
+require 'scad/btw/concerns/part_commons'
+require 'scad/btw/concerns/tread_width'
+
+module Scad
+  module Btw
+    module Component
+      class Spokes < JennCad::Part
+        include Scad::Btw::Concerns::PartCommons
+        include Scad::Btw::Concerns::ComponentArgs
+        include Scad::Btw::Concerns::TreadWidth
+
+        TYPE = :addition
+        ROTATE_180_DEGREE = false
+        WIDTH = 1
+
+        ARGS = {
+          prefix: :spokes,
+          args: {
+            count: {
+              description: 'Spokes count.',
+              required: true,
+              type: :numeric
+            },
+            width: {
+              description: 'Spokes width.',
+              default: WIDTH,
+              type: :numeric
+            },
+            height: {
+              description: 'Spokes height. Defaults to: Value/default of ' \
+                           '`wheel_inner_height` option.',
+              type: :numeric,
+              hide: true
+            },
+            diameter: {
+              description: 'Wheel diameter. Defaults to: Wheel diameter ' \
+                           'defined by `wheel_size` option.',
+              type: :numeric,
+              hide: true
+            },
+            tread_width: {
+              description: "Tread width. Minimum width of #{MIN_TREAD_WIDTH} " \
+                           'will be used if provided/default value is ' \
+                           'smaller. Defaults to: Diameter * 0.06',
+              type: :numeric,
+              hide: true
+            },
+            rotate_180_degree: {
+              description: 'Whether to start at 180 degree instead of 0 ' \
+                           'degree when having an odd spokes count.',
+              default: ROTATE_180_DEGREE,
+              type: :boolean
+            }
+          }
+        }.freeze
+
+        def initialize(args = {})
+          super
+
+          @count = args.fetch(:count)
+          @width = args[:width] || WIDTH
+          @height = args.fetch(:height)
+          @diameter = args.fetch(:diameter)
+          @tread_width = args[:tread_width]
+          @rotate_180_degree = args[:rotate_180_degree] || ROTATE_180_DEGREE
+        end
+
+        def part
+          res = nil
+          start.step(by: step, to: stop) do |degree|
+            step_spoke = spoke.rz(degree)
+            if degree == start
+              res = step_spoke
+            else
+              res += step_spoke
+            end
+          end
+          res
+        end
+
+        private
+
+        attr_reader :count, :width, :height, :diameter, :tread_width,
+                    :rotate_180_degree
+
+        # components
+
+        def spoke
+          cube(x: length, y: width, z: height).mx(length / 2)
+        end
+
+        # functions
+
+        def length
+          calc_width = calculated_tread_width(width: tread_width,
+                                              diameter: diameter)
+
+          (diameter - calc_width + (2 * overlap)) / 2
+        end
+
+        def start
+          rotate_180_degree ? 180 : 0
+        end
+
+        def stop
+          (rotate_180_degree ? 540 : 360) - step
+        end
+
+        def step
+          360.to_f / count
+        end
+      end
+    end
+  end
+end

data/lib/scad/btw/component/tread.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require 'scad/btw/concerns/component_args'
+require 'scad/btw/concerns/flange_heights'
+require 'scad/btw/concerns/part_commons'
+require 'scad/btw/concerns/tread_width'
+require_relative 'flange'
+
+module Scad
+  module Btw
+    module Component
+      class Tread < JennCad::Part
+        include Scad::Btw::Concerns::PartCommons
+        include Scad::Btw::Concerns::ComponentArgs
+        include Scad::Btw::Concerns::TreadWidth
+        include Scad::Btw::Concerns::FlangeHeights
+
+        TYPE = :addition
+        UPPER_LOWER_DIAMETER_DIFF = 0.2
+
+        ARGS = {
+          prefix: :tread,
+          args: {
+            diameter: {
+              description: 'Wheel diameter. Defaults to: Wheel diameter ' \
+                           'defined by `wheel_size` option.',
+              type: :numeric,
+              hide: true
+            },
+            height: {
+              description: 'Tread height. Defaults to: Wheel height defined ' \
+                           'by wheel thickness (`wheel_is_thin` flag).',
+              type: :numeric,
+              hide: true
+            },
+            width: {
+              description: "Tread width. Minimum width of #{MIN_TREAD_WIDTH} " \
+                           'will be used if provided/default value is ' \
+                           'smaller. Defaults to: Diameter * 0.06',
+              type: :numeric,
+              hide: true
+            },
+            flange_height: {
+              description: 'Flange height on tread.',
+              default: FLANGE_INNER_HEIGHT,
+              type: :numeric,
+              hide: true
+            }
+          }
+        }.freeze
+
+        def initialize(args = {})
+          super
+
+          @diameter = args.fetch(:diameter)
+          @height = args.fetch(:height)
+          @width = args[:width]
+          @flange_height = args[:flange_height]
+          @upper_lower_diameter_diff = args[:upper_lower_diameter_diff] ||
+                                       UPPER_LOWER_DIAMETER_DIFF
+        end
+
+        def part
+          upper_part + lower_part - inner_space
+        end
+
+        private
+
+        attr_reader :diameter, :height, :width, :flange_height,
+                    :upper_lower_diameter_diff
+
+        # components
+
+        def upper_part
+          cylinder(d: diameter, h: calc_flange_height)
+        end
+
+        def lower_part
+          cylinder(d1: diameter, d2: upper_diameter, h: tread_height)
+            .mz(calc_flange_height - overlap)
+        end
+
+        def inner_space
+          cylinder(d: inner_diameter - (2 * overlap), h: height + 2).mz(-1)
+        end
+
+        # functions
+
+        def upper_diameter
+          diameter - upper_lower_diameter_diff
+        end
+
+        def tread_height
+          height - calc_flange_height + overlap
+        end
+
+        def inner_diameter
+          calc_width = calculated_tread_width(width: width, diameter: diameter)
+
+          diameter - upper_lower_diameter_diff - (2 * calc_width)
+        end
+
+        def calc_flange_height
+          calculated_inner_flange_height(flange_height)
+        end
+      end
+    end
+  end
+end