rays 0.1.47 → 0.1.49

data/.doc/ext/rays/polygon_line.cpp

@@ -1,97 +0,0 @@
-#include "rays/ruby/polygon.h"
-
-
-#include <assert.h>
-#include "rays/ruby/polyline.h"
-#include "defs.h"
-
-
-RUCY_DEFINE_VALUE_OR_ARRAY_FROM_TO(Rays::Polygon::Line)
-
-#define THIS  to<Rays::Polygon::Line*>(self)
-
-#define CHECK RUCY_CHECK_OBJECT(Rays::Polygon::Line, self)
-
-
-static
-VALUE alloc(VALUE klass)
-{
-	return new_type<Rays::Polygon::Line>(klass);
-}
-
-static
-VALUE setup(VALUE self, VALUE points, VALUE loop, VALUE hole)
-{
-	CHECK;
-
-	std::vector<Rays::Point> array;
-	get_line_args(&array, points.size(), points.as_array());
-	*THIS = Rays::Polygon::Line(&array[0], array.size(), loop, hole);
-}
-
-static
-VALUE hole(VALUE self)
-{
-	CHECK;
-	return value(THIS->hole());
-}
-
-
-static Class cPolygonLine;
-
-void
-Init_rays_polygon_line ()
-{
-	Module mRays = rb_define_module("Rays");
-	Class cPolygon = rb_define_class_under(mRays, "Polygon", rb_cObject);
-
-	cPolygonLine = cPolygon.define_class("Line", Rays::polyline_class());
-	rb_define_alloc_func(cPolygonLine, alloc);
-	rb_define_private_method(cPolygonLine, "setup", RUBY_METHOD_FUNC(setup), 3);
-	cPolygonLine.define_method("hole?", hole);
-}
-
-
-namespace Rucy
-{
-
-
-	template <> Rays::Polygon::Line
-	value_to<Rays::Polygon::Line> (int argc, const Value* argv, bool convert)
-	{
-		assert(argc == 0 || (argc > 0 && argv));
-
-		if (convert)
-		{
-			if (argc <= 0)
-				return Rays::Polygon::Line();
-			else if (argv->is_num() || argv->is_array())
-			{
-				std::vector<Rays::Point> points;
-				get_line_args(&points, argc, argv);
-				return Rays::Polygon::Line(&points[0], points.size());
-			}
-		}
-
-		if (argc != 1)
-			argument_error(__FILE__, __LINE__);
-
-		return value_to<Rays::Polygon::Line&>(*argv, convert);
-	}
-
-
-}// Rucy
-
-
-namespace Rays
-{
-
-
-	Class
-	polygon_line_class ()
-	{
-		return cPolygonLine;
-	}
-
-
-}// Rays

data/ext/rays/polygon_line.cpp

@@ -1,100 +0,0 @@
-#include "rays/ruby/polygon.h"
-
-
-#include <assert.h>
-#include "rays/ruby/polyline.h"
-#include "defs.h"
-
-
-RUCY_DEFINE_VALUE_OR_ARRAY_FROM_TO(Rays::Polygon::Line)
-
-#define THIS  to<Rays::Polygon::Line*>(self)
-
-#define CHECK RUCY_CHECK_OBJECT(Rays::Polygon::Line, self)
-
-
-static
-RUCY_DEF_ALLOC(alloc, klass)
-{
-	return new_type<Rays::Polygon::Line>(klass);
-}
-RUCY_END
-
-static
-RUCY_DEF3(setup, points, loop, hole)
-{
-	CHECK;
-
-	std::vector<Rays::Point> array;
-	get_line_args(&array, points.size(), points.as_array());
-	*THIS = Rays::Polygon::Line(&array[0], array.size(), loop, hole);
-}
-RUCY_END
-
-static
-RUCY_DEF0(hole)
-{
-	CHECK;
-	return value(THIS->hole());
-}
-RUCY_END
-
-
-static Class cPolygonLine;
-
-void
-Init_rays_polygon_line ()
-{
-	Module mRays   = define_module("Rays");
-	Class cPolygon = mRays.define_class("Polygon");
-
-	cPolygonLine = cPolygon.define_class("Line", Rays::polyline_class());
-	cPolygonLine.define_alloc_func(alloc);
-	cPolygonLine.define_private_method("setup", setup);
-	cPolygonLine.define_method("hole?", hole);
-}
-
-
-namespace Rucy
-{
-
-
-	template <> Rays::Polygon::Line
-	value_to<Rays::Polygon::Line> (int argc, const Value* argv, bool convert)
-	{
-		assert(argc == 0 || (argc > 0 && argv));
-
-		if (convert)
-		{
-			if (argc <= 0)
-				return Rays::Polygon::Line();
-			else if (argv->is_num() || argv->is_array())
-			{
-				std::vector<Rays::Point> points;
-				get_line_args(&points, argc, argv);
-				return Rays::Polygon::Line(&points[0], points.size());
-			}
-		}
-
-		if (argc != 1)
-			argument_error(__FILE__, __LINE__);
-
-		return value_to<Rays::Polygon::Line&>(*argv, convert);
-	}
-
-
-}// Rucy
-
-
-namespace Rays
-{
-
-
-	Class
-	polygon_line_class ()
-	{
-		return cPolygonLine;
-	}
-
-
-}// Rays

data/lib/rays/polygon_line.rb

@@ -1,33 +0,0 @@
-require 'rays/ext'
-
-
-module Rays
-
-
-  class Polygon
-
-
-    class Line < Polyline
-
-      def initialize(*points, loop: true, hole: false)
-        setup points, loop, hole
-      end
-
-      def transform(matrix = nil, loop: loop?, hole: hole?, &block)
-        points = to_a
-        points = points.map {|point| matrix * point} if matrix
-        points = block.call points if block
-        self.class.new(*points, loop: loop, hole: hole)
-      end
-
-      def inspect()
-        "#<Rays::Polygon::Line #{to_a.join ', '}, loop: #{loop?}, hole: #{hole?}>"
-      end
-
-    end# Line
-
-
-  end# Polygon
-
-
-end# Rays

data/test/test_polygon_line.rb

@@ -1,164 +0,0 @@
-require_relative 'helper'
-
-
-class TestPolygonLine < Test::Unit::TestCase
-
-  class Rays::Polygon::Line
-    def dump()
-      map &:to_a
-    end
-
-    def loop_hole()
-      [loop?, hole?]
-    end
-  end
-
-  def line(*args, **kwargs)
-    Rays::Polygon::Line.new(*args, **kwargs)
-  end
-
-  def point(*args)
-    Rays::Point.new(*args)
-  end
-
-  def rect(*args)
-    Rays::Polygon.rect(*args)
-  end
-
-  def test_initialize()
-    assert_equal [[1, 2], [3, 4], [5, 6]], line(   1, 2,     3, 4 ,    5, 6 ).dump
-    assert_equal [[1, 2], [3, 4], [5, 6]], line(  [1, 2],   [3, 4],   [5, 6]).dump
-    assert_equal [[1, 1], [2, 2], [3, 3]], line(     [1],      [2],      [3]).dump
-    assert_equal [[1, 1], [2, 2], [3, 3]], line(point(1), point(2), point(3)).dump
-
-    assert_equal [true,  false],  line(1, 2, 3, 4, 5, 6                          ).loop_hole
-    assert_equal [true,  false],  line(1, 2, 3, 4, 5, 6, loop: true              ).loop_hole
-    assert_equal [false, false],  line(1, 2, 3, 4, 5, 6, loop: false             ).loop_hole
-    assert_equal [true,  true ],  line(1, 2, 3, 4, 5, 6,              hole: true ).loop_hole
-    assert_equal [true,  false],  line(1, 2, 3, 4, 5, 6,              hole: false).loop_hole
-    assert_equal [true,  true ],  line(1, 2, 3, 4, 5, 6, loop: true,  hole: true ).loop_hole
-    assert_equal [true,  false],  line(1, 2, 3, 4, 5, 6, loop: true,  hole: false).loop_hole
-    assert_raise(ArgumentError)  {line(1, 2, 3, 4, 5, 6, loop: false, hole: true ).loop_hole}
-    assert_equal [false, false],  line(1, 2, 3, 4, 5, 6, loop: false, hole: false).loop_hole
-
-    assert_nothing_raised       {line(                  loop: true,  hole: true )}
-    assert_nothing_raised       {line(                  loop: true,  hole: false)}
-    assert_raise(ArgumentError) {line(                  loop: false, hole: true )}
-    assert_nothing_raised       {line(                  loop: false, hole: false)}
-    assert_raise(ArgumentError) {line(1,                loop: true,  hole: true )}
-    assert_raise(ArgumentError) {line(1,                loop: true,  hole: false)}
-    assert_raise(ArgumentError) {line(1,                loop: false, hole: true )}
-    assert_raise(ArgumentError) {line(1,                loop: false, hole: false)}
-    assert_nothing_raised       {line(1, 2,             loop: true,  hole: true )}
-    assert_nothing_raised       {line(1, 2,             loop: true,  hole: false)}
-    assert_raise(ArgumentError) {line(1, 2,             loop: false, hole: true )}
-    assert_nothing_raised       {line(1, 2,             loop: false, hole: false)}
-    assert_raise(ArgumentError) {line(1, 2, 3,          loop: true,  hole: true )}
-    assert_raise(ArgumentError) {line(1, 2, 3,          loop: true,  hole: false)}
-    assert_raise(ArgumentError) {line(1, 2, 3,          loop: false, hole: true )}
-    assert_raise(ArgumentError) {line(1, 2, 3,          loop: false, hole: false)}
-    assert_nothing_raised       {line(1, 2, 3, 4,       loop: true,  hole: true )}
-    assert_nothing_raised       {line(1, 2, 3, 4,       loop: true,  hole: false)}
-    assert_raise(ArgumentError) {line(1, 2, 3, 4,       loop: false, hole: true )}
-    assert_nothing_raised       {line(1, 2, 3, 4,       loop: false, hole: false)}
-    assert_raise(ArgumentError) {line(1, 2, 3, 4, 5,    loop: true,  hole: true )}
-    assert_raise(ArgumentError) {line(1, 2, 3, 4, 5,    loop: true,  hole: false)}
-    assert_raise(ArgumentError) {line(1, 2, 3, 4, 5,    loop: false, hole: true )}
-    assert_raise(ArgumentError) {line(1, 2, 3, 4, 5,    loop: false, hole: false)}
-    assert_nothing_raised       {line(1, 2, 3, 4, 5, 6, loop: true,  hole: true )}
-    assert_nothing_raised       {line(1, 2, 3, 4, 5, 6, loop: true,  hole: false)}
-    assert_raise(ArgumentError) {line(1, 2, 3, 4, 5, 6, loop: false, hole: true )}
-    assert_nothing_raised       {line(1, 2, 3, 4, 5, 6, loop: false, hole: false)}
-  end
-
-  def test_transform_with_materix()
-    m = Rays::Matrix.translate 100, 200
-    line([10,10], [20,20], loop: false).transform(m).tap {|o|
-      assert_equal [[110,210], [120,220]], o.dump
-    }
-
-    m = Rays::Matrix.scale 2
-    line([10,10], [20,20], loop: false).transform(m).tap {|o|
-      assert_equal [[20,20],   [40,40]],   o.dump
-    }
-
-    m = Rays::Matrix.rotate 90
-    line([10,10], [20,20], loop: false).transform(m).tap {|o|
-      assert_equal [[-10,10],  [-20,20]],  o.dump
-    }
-  end
-
-  def test_transform_with_block()
-    line([10,10], [20,20],          loop: false).transform {|points|
-      points.map {|p| p + [10, 20]}
-    }.tap {|o|
-      assert_equal [[20,30], [30,40]],          o.dump
-    }
-
-    line([10,10], [20,20], [30,30], loop: false).transform {|points|
-      points.reject {|p| p == point(20, 20)}
-    }.tap {|o|
-      assert_equal [[10,10], [30,30]],          o.dump
-    }
-
-    line([10,10], [20,20],          loop: false).transform {|points|
-      points + [[30, 30]]
-    }.tap {|o|
-      assert_equal [[10,10], [20,20], [30,30]], o.dump
-    }
-
-    points = [1, 2, 3, 4, 5, 6]
-    line(*points,   loop: false, hole: false).transform(loop: true              ).tap {|o|
-      assert_equal points, o.dump.flatten
-      assert_equal [true,  false], o.loop_hole
-    }
-    assert_raise(ArgumentError) {
-      line(*points, loop: false, hole: false).transform(             hole: true )
-    }
-    assert_raise(ArgumentError) {
-      line(*points, loop: false, hole: false).transform(loop: false, hole: true )
-    }
-    line(*points,   loop: false, hole: false).transform(loop: true,  hole: true ).tap {|o|
-      assert_equal points, o.dump.flatten
-      assert_equal [true,  true ], o.loop_hole
-    }
-    line(*points,   loop: true,  hole: false).transform(loop: false             ).tap {|o|
-      assert_equal points, o.dump.flatten
-      assert_equal [false, false], o.loop_hole
-    }
-    line(*points,   loop: true,  hole: false).transform(             hole: true ).tap {|o|
-      assert_equal points, o.dump.flatten
-      assert_equal [true,  true ], o.loop_hole
-    }
-    assert_raise(ArgumentError) {
-      line(*points, loop: true,  hole: false).transform(loop: false, hole: true )
-    }
-    assert_raise(ArgumentError) {
-      line(*points, loop: true,  hole: true ).transform(loop: false             )
-    }
-    line(*points,   loop: true,  hole: true ).transform(             hole: false).tap {|o|
-      assert_equal points, o.dump.flatten
-      assert_equal [true,  false], o.loop_hole
-    }
-    line(*points,   loop: true,  hole: true ).transform(loop: false, hole: false).tap {|o|
-      assert_equal points, o.dump.flatten
-      assert_equal [false, false], o.loop_hole
-    }
-  end
-
-  def test_hole()
-    (rect(0, 0, 10, 10) - rect(1, 1, 2, 2)).tap {|o|
-      assert_equal 1, o.select {|line| line.hole?}.size
-    }
-    (rect(0, 0, 10, 10) - rect(100, 1, 2, 2)).tap {|o|
-      assert_equal 0, o.select {|line| line.hole?}.size
-    }
-  end
-
-  def test_inspect()
-    assert_equal(
-      "#<Rays::Polygon::Line [1.0, 2.0], [3.0, 4.0], [5.0, 6.0], loop: true, hole: false>",
-      line(1, 2, 3, 4, 5, 6).inspect)
-  end
-
-end# TestPolygonLine