hexapdf 0.17.1 → 0.17.2

data/test/hexapdf/content/graphic_object/test_arc.rb

@@ -0,0 +1,102 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/document'
+require 'hexapdf/content'
+require 'hexapdf/content/graphic_object'
+
+describe HexaPDF::Content::GraphicObject::Arc do
+  before do
+    @arc = HexaPDF::Content::GraphicObject::Arc.configure(start_angle: -30, end_angle: 30,
+                                                          inclination: 90)
+  end
+
+  describe "initialize" do
+    it "creates a default arc representing the counterclockwise unit circle at the origin" do
+      arc = HexaPDF::Content::GraphicObject::Arc.new
+      assert_equal(0, arc.cx)
+      assert_equal(0, arc.cy)
+      assert_equal(1, arc.a)
+      assert_equal(1, arc.b)
+      assert_equal(0, arc.start_angle)
+      assert_equal(360, arc.end_angle)
+      assert_equal(0, arc.inclination)
+    end
+  end
+
+  it "returns the start and end points" do
+    x, y = @arc.start_point
+    assert_in_delta(0.5, x, 0.00001)
+    assert_in_delta(Math.sin(Math::PI / 3), y, 0.00001)
+
+    x, y = @arc.end_point
+    assert_in_delta(-0.5, x, 0.00001)
+    assert_in_delta(Math.sin(Math::PI / 3), y, 0.00001)
+  end
+
+  describe "point_at" do
+    it "returns an arbitrary point on the arc" do
+      x, y = @arc.point_at(0)
+      assert_in_delta(0, x, 0.00001)
+      assert_in_delta(1, y, 0.00001)
+    end
+  end
+
+  describe "configure" do
+    it "fails if a == 0 or b == 0" do
+      assert_raises(HexaPDF::Error) do
+        HexaPDF::Content::GraphicObject::Arc.configure(a: 0)
+      end
+      assert_raises(HexaPDF::Error) do
+        HexaPDF::Content::GraphicObject::Arc.configure(b: 0)
+      end
+    end
+  end
+
+  describe "curves" do
+    def assert_curve_values(exp, act)
+      assert_in_delta(exp[0], act[0], 0.00001)
+      assert_in_delta(exp[1], act[1], 0.00001)
+      assert_in_delta(exp[2][:p1][0], act[2][:p1][0], 0.00001)
+      assert_in_delta(exp[2][:p1][1], act[2][:p1][1], 0.00001)
+      assert_in_delta(exp[2][:p2][0], act[2][:p2][0], 0.00001)
+      assert_in_delta(exp[2][:p2][1], act[2][:p2][1], 0.00001)
+    end
+
+    it "returns the curves for the arc" do
+      arc = HexaPDF::Content::GraphicObject::Arc.configure(end_angle: 180)
+      arc.max_curves = 4
+      curves = arc.curves
+      assert_equal(2, curves.size)
+      assert_curve_values([0, 1, {p1: [1, 0.548584], p2: [0.548584, 1]}], curves[0])
+      assert_curve_values([-1, 0, {p1: [-0.548584, 1], p2: [-1, 0.548584]}], curves[1])
+
+      arc.configure(clockwise: true)
+      curves = arc.curves
+      assert_equal(2, curves.size)
+      assert_curve_values([0, -1, {p1: [1, -0.548584], p2: [0.548584, -1]}], curves[0])
+      assert_curve_values([-1, 0, {p1: [-0.548584, -1], p2: [-1, -0.548584]}], curves[1])
+    end
+  end
+
+  describe "draw" do
+    before do
+      @doc = HexaPDF::Document.new
+      @page = @doc.pages.add
+      @canvas = @page.canvas
+    end
+
+    it "draws the arc onto the canvas" do
+      @arc.draw(@canvas)
+      refute(@page.contents.empty?)
+    end
+
+    it "uses the configuration option for max_curves if no value is set" do
+      @arc.draw(@canvas)
+      assert_equal(@doc.config['graphic_object.arc.max_curves'], @arc.max_curves)
+      @arc.max_curves = 2
+      @arc.draw(@canvas)
+      assert_equal(2, @arc.max_curves)
+    end
+  end
+end

data/test/hexapdf/content/graphic_object/test_endpoint_arc.rb

@@ -0,0 +1,90 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/content/canvas'
+require 'hexapdf/content/graphic_object'
+require 'hexapdf/document'
+
+describe HexaPDF::Content::GraphicObject::EndpointArc do
+  describe "initialize" do
+    it "creates a default arc representing a line from the current point to the origin" do
+      arc = HexaPDF::Content::GraphicObject::EndpointArc.new
+      assert_equal(0, arc.x)
+      assert_equal(0, arc.y)
+      assert_equal(0, arc.a)
+      assert_equal(0, arc.b)
+      assert_equal(0, arc.inclination)
+      assert(arc.large_arc)
+      refute(arc.clockwise)
+    end
+  end
+
+  describe "configure" do
+    it "changes the values" do
+      arc = HexaPDF::Content::GraphicObject::EndpointArc.new
+      arc.configure(x: 1, y: 2, a: 3, b: 4, inclination: 5, large_arc: false, clockwise: true)
+      assert_equal(1, arc.x)
+      assert_equal(2, arc.y)
+      assert_equal(3, arc.a)
+      assert_equal(4, arc.b)
+      assert_equal(5, arc.inclination)
+      refute(arc.large_arc)
+      assert(arc.clockwise)
+    end
+  end
+
+  describe "draw" do
+    before do
+      @doc = HexaPDF::Document.new
+      @page = @doc.pages.add
+    end
+
+    it "draws nothing if the endpoint is the same as the current point" do
+      canvas = @page.canvas
+      canvas.move_to(50, 50)
+      canvas.draw(:endpoint_arc, x: 50, y: 50, a: 50, b: 25)
+      assert_equal("50 50 m\n", canvas.contents)
+    end
+
+    it "draws only a straight line if either one of the semi-axis is zero" do
+      canvas = @page.canvas
+      canvas.move_to(50, 50)
+      canvas.draw(:endpoint_arc, x: 100, y: 50, a: 0, b: 25)
+      assert_equal("50 50 m\n100 50 l\n", canvas.contents)
+    end
+
+    it "draws the arc onto the canvas" do
+      {
+        [false, false] => {cx: 100, cy: 50, start_angle: 180, end_angle: 270, clockwise: false},
+        [false, true] => {cx: 50, cy: 25, start_angle: 90, end_angle: 0, clockwise: true},
+        [true, false] => {cx: 50, cy: 25, start_angle: 90, end_angle: 360, clockwise: false},
+        [true, true] => {cx: 100, cy: 50, start_angle: 180, end_angle: -90, clockwise: true},
+      }.each do |(large_arc, clockwise), data|
+        @page.delete(:Contents)
+        canvas = @page.canvas
+        canvas.draw(:arc, a: 50, b: 25, inclination: 0, **data)
+        arc_data = @page.contents
+
+        canvas.contents.clear
+        assert(@page.contents.empty?)
+        canvas.move_to(50.0, 50.0)
+        canvas.draw(:endpoint_arc, x: 100, y: 25, a: 50, b: 25, inclination: 0,
+                    large_arc: large_arc, clockwise: clockwise)
+        assert_equal(arc_data, @page.contents)
+      end
+    end
+
+    it "draws the correct arc even if it is inclined" do
+      canvas = @page.canvas
+      canvas.draw(:arc, cx: 25, cy: 0, a: 50, b: 25, start_angle: 90, end_angle: 270,
+                  inclination: 90, clockwise: false)
+      arc_data = @page.contents
+
+      canvas.contents.clear
+      canvas.move_to(0.0, 1e-15)
+      canvas.draw(:endpoint_arc, x: 50, y: 0, a: 20, b: 10, inclination: 90, large_arc: false,
+                  clockwise: false)
+      assert_equal(arc_data, @page.contents)
+    end
+  end
+end

data/test/hexapdf/content/graphic_object/test_geom2d.rb

@@ -0,0 +1,79 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require_relative '../common'
+require 'hexapdf/document'
+require 'hexapdf/content'
+require 'hexapdf/content/graphic_object'
+
+describe HexaPDF::Content::GraphicObject::Geom2D do
+  before do
+    @obj = HexaPDF::Content::GraphicObject::Geom2D.new
+  end
+
+  it "allows creation via the ::configure method" do
+    obj = HexaPDF::Content::GraphicObject::Geom2D.configure(object: Geom2D::Point(5, 5))
+    assert_equal(Geom2D::Point(5, 5), obj.object)
+  end
+
+  it "creates a default Geom2D drawing support object" do
+    obj = HexaPDF::Content::GraphicObject::Geom2D.new
+    assert_nil(obj.object)
+    assert_equal(1, obj.point_radius)
+    assert_equal(false, obj.path_only)
+  end
+
+  it "allows configuration of the object" do
+    @obj.configure(object: Geom2D::Point(5, 5), point_radius: 3, path_only: true)
+    assert_equal(Geom2D::Point(5, 5), @obj.object)
+    assert_equal(3, @obj.point_radius)
+    assert_equal(true, @obj.path_only)
+  end
+
+  describe "draw" do
+    before do
+      doc = HexaPDF::Document.new
+      @canvas = doc.pages.add.canvas
+    end
+
+    it "draws a Geom2D::Point onto the canvas" do
+      @obj.object = Geom2D::Point(5, 5)
+      @obj.draw(@canvas)
+      assert_operators(@canvas.contents,
+                       [:move_to, :curve_to, :curve_to, :curve_to, :curve_to, :curve_to, :curve_to,
+                        :close_subpath, :fill_path_non_zero],
+                       only_names: true)
+    end
+
+    it "draws a Geom2D::Segment onto the canvas" do
+      @obj.object = Geom2D::Segment([5, 6], [10, 11])
+      @obj.draw(@canvas)
+      assert_operators(@canvas.contents,
+                       [[:move_to, [5, 6]], [:line_to, [10, 11]], [:stroke_path]])
+    end
+
+    it "draws a Geom2D::Polygon onto the canvas" do
+      @obj.object = Geom2D::Polygon([5, 6], [10, 11], [7, 9])
+      @obj.draw(@canvas)
+      assert_operators(@canvas.contents,
+                       [[:move_to, [5, 6]], [:line_to, [10, 11]], [:line_to, [7, 9]],
+                        [:stroke_path]])
+    end
+
+    it "draws a Geom2D::PolygonSet onto the canvas" do
+      @obj.object = Geom2D::PolygonSet(Geom2D::Polygon([5, 6], [10, 11], [7, 9]),
+                                       Geom2D::Polygon([0, 0], [4, 0], [2, 3]))
+      @obj.draw(@canvas)
+      assert_operators(@canvas.contents,
+                       [[:move_to, [5, 6]], [:line_to, [10, 11]], [:line_to, [7, 9]],
+                        [:close_subpath],
+                        [:move_to, [0, 0]], [:line_to, [4, 0]], [:line_to, [2, 3]],
+                        [:close_subpath], [:stroke_path]])
+    end
+
+    it "fails for unkown classes" do
+      @obj.object = 5
+      assert_raises(HexaPDF::Error) { @obj.draw(@canvas) }
+    end
+  end
+end

data/test/hexapdf/content/graphic_object/test_solid_arc.rb

@@ -0,0 +1,86 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require_relative '../common'
+require 'hexapdf/document'
+require 'hexapdf/content'
+require 'hexapdf/content/graphic_object'
+
+describe HexaPDF::Content::GraphicObject::SolidArc do
+  describe "initialize" do
+    it "creates a default solid arc representing the disk at the origin" do
+      arc = HexaPDF::Content::GraphicObject::SolidArc.configure
+      assert_equal(0, arc.cx)
+      assert_equal(0, arc.cy)
+      assert_equal(0, arc.inner_a)
+      assert_equal(0, arc.inner_b)
+      assert_equal(1, arc.outer_a)
+      assert_equal(1, arc.outer_b)
+      assert_equal(0, arc.start_angle)
+      assert_equal(0, arc.end_angle)
+      assert_equal(0, arc.inclination)
+    end
+  end
+
+  describe "configure" do
+    it "changes the values" do
+      arc = HexaPDF::Content::GraphicObject::SolidArc.new
+      arc.configure(cx: 1, cy: 2, inner_a: 3, inner_b: 4, outer_a: 5, outer_b: 6,
+                    start_angle: 7, end_angle: 8, inclination: 9)
+      assert_equal(1, arc.cx)
+      assert_equal(2, arc.cy)
+      assert_equal(3, arc.inner_a)
+      assert_equal(4, arc.inner_b)
+      assert_equal(5, arc.outer_a)
+      assert_equal(6, arc.outer_b)
+      assert_equal(7, arc.start_angle)
+      assert_equal(8, arc.end_angle)
+      assert_equal(9, arc.inclination)
+    end
+  end
+
+  describe "draw" do
+    def operators(content)
+      processor = TestHelper::OperatorRecorder.new
+      parser = HexaPDF::Content::Parser.new
+      parser.parse(content, processor)
+      processor.recorded_ops
+    end
+
+    before do
+      @doc = HexaPDF::Document.new
+      @doc.config['graphic_object.arc.max_curves'] = 4
+      @page = @doc.pages.add
+      @canvas = @page.canvas
+    end
+
+    it "draws a disk" do
+      @canvas.draw(:solid_arc)
+      ops = operators(@canvas.contents)
+      assert_equal([:move_to, :curve_to, :curve_to, :curve_to, :curve_to, :close_subpath],
+                   ops.map(&:first))
+    end
+
+    it "draws a sector" do
+      @canvas.draw(:solid_arc, end_angle: 90)
+      ops = operators(@canvas.contents)
+      assert_equal([:move_to, :line_to, :curve_to, :close_subpath],
+                   ops.map(&:first))
+    end
+
+    it "draws an annulus" do
+      @canvas.draw(:solid_arc, inner_a: 5, inner_b: 5)
+      ops = operators(@canvas.contents)
+      assert_equal([:move_to, :curve_to, :curve_to, :curve_to, :curve_to, :close_subpath,
+                    :move_to, :curve_to, :curve_to, :curve_to, :curve_to, :close_subpath],
+                   ops.map(&:first))
+    end
+
+    it "draws an annular sector" do
+      @canvas.draw(:solid_arc, inner_a: 5, inner_b: 5, end_angle: 90)
+      ops = operators(@canvas.contents)
+      assert_equal([:move_to, :curve_to, :line_to, :curve_to, :close_subpath],
+                   ops.map(&:first))
+    end
+  end
+end