dem-curves 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 95c1fab002f919736b30a60e299e82c05a10f1fb
+  data.tar.gz: 9a9a364baf601ea4c82d302b38cb2fb7b62fa543
+SHA512:
+  metadata.gz: ce2ca54589e1a097467d565a315383b3269a3cee37f7dbfc8c6e12514ae9ebf38a909721ce7de4c797896f8e16f2b0ea49034bcec57efd2eb7d3def32ffb6757
+  data.tar.gz: f78075a71096ba4ffc79600ed2ddc28a2667a5d234b86923a85b69295ade8c878823960109b19f07f3846347fabf402e7d07a47dfe15bda70901b31039eba1ba

data/lib/core/constraint.rb

@@ -0,0 +1,79 @@
+module DemCurves
+  module BaseConstraint
+    master_point = nil
+    slave_points = []
+    
+    def notify(src, orig_src, params)
+      if src == @master_point
+        handle_master src, orig_src, params
+      elsif @slave_points.include? src
+        handle_slave src, orig_src, params
+      end
+    end
+    
+    def handle_master(master, orig_src, params)
+      # This has to be implemented by the class
+    end
+    
+    def handle_slave(slave, orig_src, params)
+      # This has to be implemented by the class
+    end
+  end
+  
+  
+  class LineUpConstraint
+    include BaseConstraint
+    def initialize(pivot, p0, p1, mirror_distance=false, follow=:pivot)
+      pivot.add_constraint self
+      p0.add_constraint self
+      p1.add_constraint self
+      
+      @master_point = pivot
+      @slave_points = [p0, p1]
+      @mirror_distance = mirror_distance
+      @follow = follow
+      p1.move_to p1.loc #hacky way to trigger readjustment
+    end
+    
+    def handle_master(master, orig_src, params)
+      if (params.include? :new_pos and params.include? :old_pos) or params.include? :rel
+        case @follow
+        when :pivot
+          unless params.include? :rel
+            params[:rel] = params[:new_pos], params[:old_pos]
+          end
+          
+          params.delete(:new_pos)
+          params.delete(:old_pos)
+          
+          @slave_points.each do |slave|
+            slave.notify_to_move orig_src, self, params
+          end
+        when :p0
+          direction = (params[:new_pos] - @slave_points[0].loc).unit
+          distance = (params[:new_pos] - @slave_points[1].loc).r
+          @slave_points[1].notify_to_move orig_src, self, {:new_pos => params[:new_pos] + (distance * direction)}
+        when :p1
+          direction = (params[:new_pos] - @slave_points[1].loc).unit
+          distance = (params[:new_pos] - @slave_points[0].loc).r
+          @slave_points[0].notify_to_move orig_src, self, {:new_pos => params[:new_pos] + (distance * direction)}
+        end
+      end
+    end
+    
+    def handle_slave(slave, orig_src, params)
+      if params.include? :new_pos
+        other_slave = (@slave_points.select {|s| s!=slave})[0]
+        direction = (params[:new_pos] - @master_point.loc).unit
+        if @mirror_distance
+          distance = (slave.loc - @master_point.loc).r
+        else
+          distance = (other_slave.loc - @master_point.loc).r
+        end
+        
+        new_loc = @master_point.loc + (-1 * direction * distance)
+        other_slave.notify_to_move orig_src, self, {:new_pos => new_loc}
+      end
+    end
+  end
+end

data/lib/core/control-point.rb

@@ -0,0 +1,106 @@
+require 'matrix'
+require 'core/util.rb'
+
+module DemCurves
+  class ControlPoint
+    # this class is necessary to let other curves and path elements modify
+    # points, it works much better than calling "notify movement" functions
+    # every time a control point moves, this comes in handy when you want a curve
+    # to use another curve's end point as a starting point.
+    attr_reader :loc
+    
+    def initialize(loc)
+      @loc = Vector.elements(loc)
+      @path_elements = []
+      @constraints = []
+    end
+    
+    def add_path_element(path_element)
+      @path_elements << path_element
+    end
+    
+    def replace(other)
+      old_pos = @loc
+      case other
+      when ControlPoint
+        @loc = Vector.elements(other.loc)
+      when Vector, Array
+        unless other.size == 2
+          raise "Wrong number of dimensions, must be [x, y]"
+        end
+        @loc = Vector.elements(other)
+      else
+        raise "Argument is instance of #{other.class}! Replacement argument must be an instance of Vector, Array or ControlPoint."
+      end
+        
+        @path_elements.each do |path_element|
+          path_element.generate
+      end
+    end
+    
+    def shift(rel)
+      unless rel.size == 2
+        raise "Wrong number of dimensions, must be [x, y]"
+      end
+      
+      old_pos = @loc
+      move_to @loc + Vector.elements(rel)
+    end
+    
+    def move_to(destination)
+      old_pos = @loc
+      replace destination
+      
+      new_pos = @loc
+      rel = new_pos - old_pos
+      
+      @constraints.each do |constraint|
+        constraint.notify self, self, {:new_pos => new_pos, :old_pos => old_pos, :rel => rel}
+      end
+    end
+    
+    def rotate_around(pivot_ctl, angle)
+      offset = @loc - pivot_ctl.loc
+      new_offset = Matrix[[Math.cos(angle), -Math.sin(angle)], [Math.sin(angle), Math.cos(angle)]] * offset
+      replace new_offset + pivot_ctl.loc
+    end
+    
+    def notify_to_move(orig_src, src_constraint, params)
+      unless orig_src == self
+        # Safety measure, it avoids infinite recursion, but produces weird results
+        # with cyclic constraint structures.
+        old_pos = @loc
+        if params.include? :new_pos
+          replace params[:new_pos]
+        elsif params.include? :rel
+          replace params[:rel] + @loc
+        else
+          return
+        end
+        
+        new_pos = @loc
+        rel = new_pos - old_pos
+        
+        @constraints.each do |constraint|
+          unless constraint == src_constraint
+            constraint.notify self, orig_src, {:new_pos => new_pos, :old_pos => old_pos, :rel => rel}
+          end
+        end
+      end
+    end
+    
+    def add_constraint(constraint)
+      unless @constraints.include? constraint
+        @constraints << constraint
+      end
+    end
+    
+    def clear_constraints
+      @constraints = []
+    end
+  end
+  
+  def ControlPoint.[](*loc)
+    return ControlPoint.new loc
+  end
+end

data/lib/core/path-element.rb

@@ -0,0 +1,88 @@
+require 'core/util.rb'
+
+module DemCurves
+  class PathElement
+    # Do not directly instantiate this class
+    attr_reader :path_points, :control_points
+    def initialize(control_points)
+      @control_points = control_points
+      @control_points.each_value do |control_point| 
+        control_point.add_path_element self
+      end
+      
+      @path_points = []
+      generate
+    end
+    
+    def generate
+      @path_points = @control_points.values.collect {|point| point.loc}
+    end
+    
+    def set_control(control_id, loc)
+      unless control_id.class == Symbol 
+        raise 'control_id must be a symbol' 
+      end
+      
+      @control_points[control_id].move_to location
+      generate
+    end
+    
+    def []=(control_id, loc)
+      set_control control_id, loc
+    end
+    
+    def get_control(control_id)
+      unless control_id.class == Symbol 
+        raise 'control_id must be a symbol' 
+      end
+      
+      return @control_points[control_id]
+    end
+    
+    def [](control_id)
+      get_control control_id
+    end
+  end
+  
+  
+  class CubicBezier < PathElement
+    def initialize(start_point, start_handle, end_handle, end_point)
+      super({
+        :start => start_point, 
+        :start_handle => start_handle, 
+        :end_handle => end_handle, 
+        :end => end_point})
+    end
+    
+    def generate(t_freq=32)
+      step = 1.0 / t_freq
+      @path_points = (0..t_freq).collect {|i| interpolate(step * i)}
+    end
+    
+    def interpolate(t)
+      # http://mathworld.wolfram.com/BezierCurve.html
+      (0..3).inject(Vector[0, 0]) do |mem, i|
+        mem += @control_points.values[i].loc.clone * bernstein_basis(i, 3, t)
+      end
+    end
+    
+    def get_guides
+      # this will be removed soon.
+      return [[self[:start].loc, self[:start_handle].loc], [self[:end_handle].loc, self[:end].loc]]
+    end
+  end
+  
+  
+  class Line < PathElement
+    def initialize(start_point, center_point, end_point)
+      super({
+        :start => start_point,
+        :center => center_point,
+        :end => end_point})
+    end
+    
+    def generate
+      @path_points = [self[:start].loc, self[:end].loc]
+    end
+  end
+end

data/lib/core/path.rb

@@ -0,0 +1,87 @@
+require 'core/path-element.rb'
+
+module DemCurves
+  class Path
+    include Enumerable
+    attr_reader :path_points, :path_elements, :control_points
+    
+    def initialize(point)
+      @path_elements = []
+      
+      @start_point = ControlPoint[*point]
+      @end_point = @start_point
+      
+      @path_points = to_a
+      @control_points = [@start_point]
+    end
+    
+    def add_bezier(start_handle, end_handle, end_point, tangent_lock=true)
+      new_bezier = CubicBezier.new(
+      @end_point, 
+      ControlPoint[*start_handle],
+      ControlPoint[*end_handle],
+      ControlPoint[*end_point])
+      
+      if tangent_lock and @path_elements.last
+        start_length = (new_bezier[:start_handle].loc - @end_point.loc).r
+        last_element = @path_elements.last
+        
+        case last_element
+        when CubicBezier
+          LineUpConstraint.new @end_point, last_element[:end_handle], new_bezier[:start_handle]
+        when Line
+          LineUpConstraint.new @end_point, last_element[:center], new_bezier[:start_handle], morror_distance=false, follow=:p0
+        end
+      end
+      
+      @end_point = new_bezier[:end]
+      @path_elements << new_bezier
+      
+      @path_points = to_a
+      @control_points += new_bezier.control_points.values[1..-1]
+    end
+    
+    def add_line(end_point, tangent_lock=true)
+      center_point = ControlPoint[*(@end_point.loc + (Vector[*end_point] - @end_point.loc) * 0.5)]
+      new_line = Line.new @end_point, center_point, ControlPoint[*end_point]
+      LineUpConstraint.new center_point, new_line[:end], @end_point
+      
+      if tangent_lock and @path_elements.last
+        last_element = @path_elements.last
+        
+        case last_element
+        when CubicBezier
+          LineUpConstraint.new @end_point, last_element[:end_handle], new_line[:end], morror_distance=false, follow=:p1
+        when Line
+          @end_point.move_to end_point
+          return
+        end
+      end
+      
+      @end_point = new_line[:end]
+      @path_elements << new_line
+      
+      @path_points = to_a
+      @control_points += new_line.control_points.values[1..-1]
+    end
+    
+    def each
+      yield @start_point.loc
+      @path_elements.each do |path_element|
+        (1..path_element.path_points.size-1).each do |index|
+          yield path_element.path_points[index]
+        end
+      end
+    end
+    
+    def size
+      return @path_points.size
+    end
+    
+    def get_guides
+      @path_elements.inject([]) do |mem, element|
+        mem += element.get_guides
+      end
+    end
+  end
+end

data/lib/core/util.rb

@@ -0,0 +1,26 @@
+class Integer
+  def choose(k)
+    # binominal coefficient
+    return self.factorial / ((self -k).factorial * k.factorial)
+  end
+  
+  def factorial()
+    # n!
+    return (1..self).inject(1, &:*)
+  end
+end
+
+def bernstein_basis(i, n, t)
+  # http://mathworld.wolfram.com/BernsteinPolynomial.html
+  return n.choose(i) * t ** i * (1 - t) ** (n - i)
+end
+
+class Vector
+  def unit
+    return self / self.r
+  end
+  
+  def angle(other)
+    return Math.acos(self.inner_product other / (self.r * other.r))
+  end
+end

data/lib/dem-curves.rb

@@ -0,0 +1,19 @@
+# The backend files
+require 'core/control-point'
+require 'core/constraint'
+require 'core/path-element'
+require 'core/path'
+require 'core/util'
+
+# These are the utils for integration with rubygame
+begin
+  require 'rubygame'
+  unless Rubygame::Surface.public_method_defined? :draw_line
+    raise LoadError, 'Loading the Rubygame utils for DemCurves requires SDL_GFX to be present on the system'
+  end
+  
+  require 'rubygame-util/control-handles'
+  require 'rubygame-util/gfx'
+rescue LoadError => e
+  puts 'The Rubygame utils for DemCurves require SDL_GFX and Rubygame.'
+end

data/lib/rubygame-util/control-handles.rb

@@ -0,0 +1,76 @@
+require 'rubygame'
+require 'matrix'
+
+module DemCurves
+  module RubygameUtils
+    def self.populate_handles(ctl_points, drag_group)
+      ctl_points.each do |control_point|
+        new_handle = EditorHandle.new
+        new_handle.attach_to control_point
+        drag_group << new_handle
+      end
+    end
+    
+    class DragGroup < Rubygame::Sprites::Group
+      dragged_object = nil
+      
+      def on_press(evt)
+        self.each do |sprite|
+          if sprite.rect.collide_point? *evt.pos
+            @dragged_object = sprite
+            break
+          end
+        end
+      end
+      
+      def on_release(evt)
+        @dragged_object = nil
+      end
+      
+      def on_move(evt)
+        if @dragged_object
+          @dragged_object.move evt.rel
+        end
+      end
+    end
+    
+    
+    class EditorHandle
+      include Rubygame::Sprites::Sprite
+      
+      def initialize(loc=[50, 50], size=10)
+        @groups =[]
+        @depth = 0
+        
+        @rect = Rubygame::Rect.new 0, 0, size, size
+        @rect.c = loc
+        
+        @image = Rubygame::Surface.new [size, size], 0, [Rubygame::HWSURFACE, Rubygame::SRCALPHA]
+        @image.fill([180, 180, 180])
+        @attached = false
+        
+        @constraints = []
+      end
+      
+      def attach_to(control_point)
+        unless @attached
+          @attached = true
+          @control_point = control_point
+          @rect.c = control_point.loc.to_a
+        end
+      end
+      
+      def move(rel)
+        if @attached
+          @control_point.shift rel
+        end
+      end
+      
+      def update
+        if @attached
+          @rect.c = @control_point.loc.to_a
+        end
+      end
+    end
+  end
+end

data/lib/rubygame-util/gfx.rb

@@ -0,0 +1,15 @@
+require 'rubygame'
+
+class Rubygame::Surface
+  def draw_path(path, color)
+    (0..path.size - 2).each do |index|
+      _draw_line path.to_a[index], path.to_a[index + 1], color, false
+    end
+  end
+  
+  def draw_path_a(path, color)
+    (0..path.size - 2).each do |index|
+      _draw_line path.to_a[index], path.to_a[index + 1], color, true
+    end
+  end
+end

metadata

@@ -0,0 +1,52 @@
+--- !ruby/object:Gem::Specification
+name: dem-curves
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Huba Nagy
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-02-14 00:00:00.000000000 Z
+dependencies: []
+description: 
+email: 12huba@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/core/constraint.rb
+- lib/core/control-point.rb
+- lib/core/path-element.rb
+- lib/core/path.rb
+- lib/core/util.rb
+- lib/dem-curves.rb
+- lib/rubygame-util/control-handles.rb
+- lib/rubygame-util/gfx.rb
+homepage: https://github.com/huba/DemCurves
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+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.4.5
+signing_key: 
+specification_version: 4
+summary: A library for generating bezier curve based paths from control_points. It
+  can be used with Rubygame
+test_files: []