geom 0.0.1

data/lib/geom/vector.rb

@@ -0,0 +1,173 @@
+module Geom
+  # Vector defined by coordinates x, y, z
+  class Vector
+    attr_accessor :x, :y, :z
+
+    def initialize(*args)
+      if args.size == 2
+        @x = args[1].x.to_f - args[0].x.to_f
+        @y = args[1].y.to_f - args[0].y.to_f
+        @z = args[1].z.to_f - args[0].z.to_f
+      else
+        @x, @y, @z = args.flatten
+      end
+    end
+
+    def -(vector)
+      Vector.new(@x - vector.x, @y - vector.y, @z - vector.z)
+    end
+
+    def +(vector)
+      Vector.new(@x + vector.x, @y + vector.y, @z + vector.z)
+    end
+
+    def *(scale)
+      Vector.new(@x * scale, @y * scale, @z * scale)
+    end
+
+    def ==(vector)
+      (@x - vector.x).abs < TOLERANCE &&
+      (@y - vector.y).abs < TOLERANCE &&
+      (@z - vector.z).abs < TOLERANCE
+    end
+
+    alias_method :eql?, :==
+
+    def hash
+      (@x.to_int ^ @y.to_int ^ @z.to_int)
+    end
+
+    alias_method :scale, :*
+
+    def **(power)
+      Vector.new(@x ** power, @y ** power, @z ** power)
+    end
+
+    def /(scale)
+      self * (1.0/scale)
+    end
+
+    def dot(vector)
+      @x * vector.x + @y * vector.y + @z * vector.z
+    end
+
+    def cross(vector)
+      Vector.new(@y * vector.z - @z * vector.y,
+      @z * vector.x - @x * vector.z,
+      @x * vector.y - @y * vector.x)
+    end
+
+    def unitize
+      self / self.length
+    end
+
+    def reverse
+      Vector.new(-@x, -@y, -@z)
+    end
+
+    def length
+      Math.sqrt(self.dot(self))
+    end
+
+    def rotate(ref_vector, angle)
+      r = [[0,0,0],[0,0,0],[0,0,0]]
+      c = Math.cos(angle)
+      s = Math.sin(angle)
+
+      unit_ref_vector = ref_vector.unitize
+
+      ax = unit_ref_vector.x
+      ay = unit_ref_vector.y
+      az = unit_ref_vector.z
+
+      r[0][0] = (c + ((1 - c) * (ax * ax)))
+      r[0][1] = (((1 - c) * (ax * ay)) - (s * az))
+      r[0][2] = (((1 - c) * (ax * az)) + (s * ay))
+      r[1][0] = (((1 - c) * (ax * ay)) + (s * az))
+      r[1][1] = (c + ((1 - c) * (ay * ay)))
+      r[1][2] = (((1 - c) * (ay * az)) - (s * ax))
+      r[2][0] = (((1 - c) * (ax * az)) - (s * ay))
+      r[2][1] = (((1 - c) * (ay * az)) + (s * ax))
+      r[2][2] = (c + ((1 - c) * (az * az)))
+
+      vx = ((r[0][0] * @x) + ((r[0][1] * @y) + (r[0][2] * @z)))
+      vy = ((r[1][0] * @x) + ((r[1][1] * @y) + (r[1][2] * @z)))
+      vz = ((r[2][0] * @x) + ((r[2][1] * @y) + (r[2][2] * @z)))
+
+      Vector.new(vx, vy, vz)
+    end
+
+    def angle_between(vector)
+      # One of the vectors is a zero vector
+      return nil if ((vector.length == 0) || (self.length == 0))
+
+      dot = self.dot(vector)
+      val = dot / (self.length * vector.length)
+
+      if (val > 1.0)
+        # Would result in NaN
+        0.0
+      else
+        Math.acos(val)
+      end
+    end
+
+
+    def transform(rectangular_coordinate_system)
+      m = Transformation.new(rectangular_coordinate_system).matrix
+      tx = m[0,0] * @x + m[0,1] * @y + m[0,2] * @z + m[0,3] * 1.0
+      ty = m[1,0] * @x + m[1,1] * @y + m[1,2] * @z + m[1,3] * 1.0
+      tz = m[2,0] * @x + m[2,1] * @y + m[2,2] * @z + m[2,3] * 1.0
+      Vector.new(tx, ty, tz)
+    end
+
+    # If dot product > 0, angle is acute and vectors are the same direction
+    # If dot product < 0, angle is obtuse and vectors are in opposite direction
+    # If dot product = 0, vectors are orthogonal, including if one is zero vector (taken as same direction)
+    def same_direction?(vector)
+      dotp = self.dot(vector);
+      dotp > 0
+    end
+
+    def parallel?(vector)
+      angle = self.angle_between(vector)
+      ((angle - Math::PI).abs < TOLERANCE) || (angle.abs < TOLERANCE)
+    end
+
+    def zero?
+      self.length <= 0.0
+    end
+
+    def unitity?
+      self.x == 1.0 && self.x == 1.0 && self.z == 1.0
+    end
+
+    def self.average(vectors)
+      num = vectors.size.to_f
+      Vector.sum(vectors).scale(1/num)
+    end
+
+    def self.sum(vectors)
+      tx, ty, tz = 0, 0, 0
+      vectors.each do |vector|
+        tx += vector.x
+        ty += vector.y
+        tz += vector.z
+      end
+      Vector.new(tx, ty, tz)
+    end
+
+    def to_point
+      Point.new(@x,@y,@z)
+    end
+
+    def to_s
+      "Vector(%.3f,%.3f,%.3f)" % [@x, @y, @z]
+    end
+
+    def to_a
+      [@x, @y, @z]
+    end
+
+  end
+end

data/lib/geom/version.rb

@@ -0,0 +1,3 @@
+module Geom
+  VERSION = "0.0.1"
+end

data/lib/geom.rb

@@ -0,0 +1,13 @@
+require 'geom/version'
+require 'geom/tolerance'
+require 'matrix'
+require 'geom/point'
+require 'geom/vector'
+require 'geom/plane'
+require 'geom/line'
+require 'geom/transformation'
+require 'geom/rectangular_coordinate_system'
+
+module Geom
+
+end

data/spec/geom/line_spec.rb

@@ -0,0 +1,125 @@
+require_relative '../spec_helper.rb'
+require 'geom/line'
+
+module Geom
+  describe Line do
+    describe "Construction" do
+      before do
+        @valid_attributes = [1, 2, 3, 4, 5, 6]
+        @attributes = [:x0, :xa, :y0, :ya, :z0, :za]
+      end
+
+      it "should create a valid instance from an array of parameters" do
+        line = Line.new(@valid_attributes)
+        @attributes.each_with_index{|value, index| line.send(value).should == @valid_attributes[index] }
+      end
+
+      it "should create a valid instance from two points" do
+        line = Line.new(Point.new(1, 3, 5), Point.new(3, 7, 11))
+        @attributes.each_with_index{|value, index| line.send(value).should == @valid_attributes[index] }
+      end
+    end
+
+    describe "Equality" do
+      it "should determine equality with another line" do
+        line_1 = Line.new(Point.new(0, 0, 0), Point.new(2, 2, 2))
+        line_2 = Line.new(Point.new(0, 0, 0), Point.new(2, 2, 2))
+        line_1.should == line_2
+      end
+    end
+
+    describe "Return types" do
+      it "should return a summary string" do
+        Line.new(1,2,3,1,0,0).to_s.should == "Line(1.000,2.000,3.000,1.000,0.000,0.000)"
+      end
+
+      it "should return a hash code" do
+        Line.new(1,2.88,3,1,-45.111,101).hash.should == -73
+      end
+    end
+
+    describe "Intersection" do
+      it "should determine intersection with another line" do
+        line_1 = Line.new(Point.new(0, 0, 0), Point.new(10, 10, 0))
+        line_2 = Line.new(Point.new(8, 0, 0), Point.new(8, 100, 0))
+        line_1.intersection_with_line(line_2).should == Point.new(8, 8, 0)
+      end
+
+      it "should raise exception when lines are parallel" do
+        line_1 = Line.new(1, 1, 3, -1, 0, 2)
+        line_2 = Line.new(1, 2, 3, -2, 0, 4)
+        lambda {line_1.intersection_with_line(line_2)}.should raise_error(ArgumentError, "Lines are parallel")
+      end
+
+      it "should raise exception when lines are skew" do
+        line_1 = Line.new(1, 1, 3, -1, 0, 2)
+        line_2 = Line.new(1, 2, 3, -2.5, 0.3, 4)
+        lambda {line_1.intersection_with_line(line_2)}.should raise_error(ArgumentError, "Lines do not intersect")
+      end
+
+      it "should calculation intersection with a plane" do
+        plane = Plane.new(Point.new(0, 0, 0), Vector.new(0, 0, 1))
+        line = Line.new(Point.new(2, 2, 10), Point.new(2, 2, 20))
+        line.intersection_with_plane(plane).should == Point.new(2, 2, 0)
+      end
+    end
+
+    describe "Parameters" do
+      it "should calculate closest approach parameter" do
+        line_1 = Line.new(Point.new(0, 0, 0), Point.new(1, 1, 0))
+        line_2 = Line.new(Point.new(0.5, -0.5, 0), Point.new(0.5, -0.1, 0))
+        line_1.closest_approach_parameter(line_2).should be_within(0.001).of(0.5)
+      end
+
+      it "should calculate point at parameter" do
+        line = Line.new(1, 1, 3, -1, 0, 2)
+        line.point_at_parameter(5).should == Point.new(6, -2, 10)
+      end
+
+      describe "should calculate parameter" do
+        before do
+          @start_point = Point.new(-1, -1, -1)
+          @end_point   = Point.new(1, 1, 1)
+          @mid_point   = Point.new(0, 0, 0)
+          @line = Line.new(@start_point, @end_point)
+        end
+
+        it "at start point" do
+          @line.parameter_at_point(@start_point).should == 0
+        end
+
+        it "at end point" do
+          @line.parameter_at_point(@end_point).should == 1
+        end
+
+        it "at mid point" do
+          @line.parameter_at_point(@mid_point).should == 0.5
+        end
+
+        it "at point beyond end point" do
+          @line.parameter_at_point(Point.new(10,10,10)).should == 5.5
+        end
+
+      end
+
+      describe "should determine if a line is on a plane" do
+        before do
+          @plane = Plane.new(0, 0, 1, 0)
+        end
+        it "when a line is on a plane" do
+          line_1 = Line.new(Point.new(1, 1, 0), Point.new(2, -3, 0))
+          line_1.on_plane?(@plane).should be_true
+        end
+
+        it "when a line is parallel to a plane" do
+          line_2 = Line.new(Point.new(1, 1, 1), Point.new(2, -3, 1))
+          line_2.on_plane?(@plane).should be_false
+        end
+        it "when a line intersects plane" do
+          line_3 = Line.new(Point.new(1, 1, 0), Point.new(2, -3, 1))
+          line_3.on_plane?(@plane).should be_false
+        end
+      end
+    end
+  end
+end

data/spec/geom/plane_spec.rb

@@ -0,0 +1,55 @@
+require_relative '../spec_helper.rb'
+require 'geom/plane'
+
+module Geom
+  describe Plane do
+    before do
+      @valid_attributes = [-10, 10, 0, 4]
+      @tol = 0.001
+    end
+
+    describe "Construction" do
+      it "should create a valid instance from an array of coordinates" do
+        plane = Plane.new(@valid_attributes)
+        plane.a.should be_within(@tol).of(-0.707)
+        plane.b.should be_within(@tol).of(0.707)
+        plane.c.should be_within(@tol).of(0.0)
+        plane.d.should be_within(@tol).of(0.283)
+      end
+
+      it "should create a valid instance from three numbers" do
+        plane = Plane.new(Point.new(0, 3, 0), Vector.new(0, 3, 0))
+        plane.a.should == 0
+        plane.b.should == 1
+        plane.c.should == 0
+        plane.d.should == 3
+      end
+    end
+
+    describe "Equality" do
+      it "should determine if another plane is equal" do
+        plane_1 = Plane.new(Point.new(0, 3, 0), Vector.new(0, 3, 0))
+        plane_2 = Plane.new(Point.new(0, 3, 0), Vector.new(0, 3, 0))
+        plane_1.should == plane_2
+      end
+
+      it "should calculate the plane normal vector" do
+        test_plane = Plane.new(@valid_attributes)
+        normal = test_plane.normal
+        normal.x.should be_within(@tol).of(-0.707)
+        normal.y.should be_within(@tol).of(0.707)
+        normal.z.should be_within(@tol).of(0)
+      end
+    end
+
+    describe "Return types" do
+      it "should return a summary string" do
+        Plane.new(1,2,3,1).to_s.should == "Plane(0.267,0.535,0.802,0.267)"
+      end
+
+      it "should return a hash code" do
+        Plane.new(1,2.88,2,-45.111).hash.should == -12
+      end
+    end
+  end
+end

data/spec/geom/point_spec.rb

@@ -0,0 +1,213 @@
+require_relative '../spec_helper.rb'
+require 'geom/point'
+
+module Geom
+  describe Point do
+    before do
+      @valid_attributes = [1.1, -2, 10]
+    end
+
+    describe "Construction" do
+      it "should create a valid instance from an array of coordinates" do
+        point = Point.new(@valid_attributes)
+        point.x.should == @valid_attributes[0]
+        point.y.should == @valid_attributes[1]
+        point.z.should == @valid_attributes[2]
+      end
+
+      it "should create a valid instance from three numbers" do
+        point = Point.new(@valid_attributes[0], @valid_attributes[1], @valid_attributes[2])
+        point.x.should == @valid_attributes[0]
+        point.y.should == @valid_attributes[1]
+        point.z.should == @valid_attributes[2]
+      end
+    end
+
+    describe "Arithmetic" do
+      before do
+        @first_point = Point.new(0,0,0)
+        @second_point = Point.new(1,2,3)
+      end
+
+      it "should allow addition with another point" do
+        result = @first_point + @second_point
+        result.should == Point.new(1,2,3)
+      end
+
+      it "should allow subtraction with another point" do
+        result = @first_point - @second_point
+        result.should == Point.new(-1,-2,-3)
+      end
+    end
+
+    describe "Return Types" do
+      it "should return as point" do
+        Point.new(@valid_attributes).to_vector.should == Vector.new(@valid_attributes)
+      end
+
+      it "should return as array" do
+        Point.new(@valid_attributes).to_a.should == @valid_attributes
+      end
+
+      it "should return a summary string" do
+        Point.new(@valid_attributes).to_s.should == "Point(1.100,-2.000,10.000)"
+      end
+
+      it "should return a hash code" do
+        Point.new(1,2.88,-45.111).hash.should == -48
+      end
+    end
+
+    describe "should calculate minimum distance" do
+      it "to another point" do
+        Point.new(0,0,0).distance_to_point(Point.new(1,3,2)).should == Math.sqrt(1*1 + 3*3 + 2*2)
+      end
+
+      it "to a plane when the point is remote from the plane" do
+        plane_1 = Plane.new(3, 2, 6, 6)
+        point_1 = Point.new(1, 1, 3)
+        point_1.distance_to_plane(plane_1).should be_within(0.001).of(-2.429)
+      end
+
+      it "to a plane when the point is on the plane" do
+        plane_2 = Plane.new(2, 3, 4, 20)
+        point_2 = Point.new(1, 2, 3)
+        point_2.distance_to_plane(plane_2).should be_within(0.001).of(0.0)
+      end
+    end
+
+    it "should calculated the average of an array of points" do
+      points = [Point.new(0,0,0), Point.new(1,1,1), Point.new(10,-10,2)]
+      average_point = Point.new(11/3.0, -9/3.0, 3/3.0)
+      Point.average(points).should == average_point
+    end
+
+    describe "should determine coincidence" do
+      before do
+        @p1 = Point.new(1,-1,0)
+        @p2 = Point.new(1,-1,0)
+        @p3 = Point.new(1.1,-1,0)
+      end
+
+      it "with another identical point" do
+        @p1.coincident?(@p2).should be_true
+      end
+
+      it "with a non-identical point" do
+        @p1.coincident?(@p3).should be_false
+      end
+
+      it "from an array of points and remove any coincident points" do
+        Point.remove_coincident([Point.new(1,-1,0), Point.new(1,-1,0), Point.new(1,-1,0), Point.new(1.1,-1,0)]).size.should == 2
+      end
+    end
+
+    describe "should determine if a point is between two points" do
+      before do
+        @p1 = Point.new(0,-1,0)
+        @p2 = Point.new(4,-1,0)
+        @p3 = Point.new(9,-1,0)
+      end
+      it "when the point is bounded" do
+        @p2.between?(@p1, @p3).should be_true
+      end
+
+      it "when the point is not bounded" do
+        @p1.between?(@p2, @p3).should be_false
+      end
+    end
+
+    describe "should determine if point is on plane" do
+      before do
+        @plane = Plane.new(0, 0, 1, 1)
+        @point_1 = Point.new(0, 0, 1)
+        @point_2 = Point.new(0, 0, 2)
+        @point_3 = Point.new(0, 0, 1.0000000001)
+      end
+
+      it "when the point is on the plane" do
+        @point_1.on_plane?(@plane).should be_true
+      end
+
+      it "when the point is not on the plane" do
+        @point_2.on_plane?(@plane).should be_false
+      end
+
+      it "when the point is close but not on the plane" do
+        @point_3.on_plane?(@plane).should be_false
+      end
+    end
+
+    describe "Projection" do
+      it "should be projected normal (dropped) onto plane" do
+        z_plane = Plane.new(0, 0, 1, 0)
+        oblique_plane = Plane.new(-1, 1, 0, 0)
+        oblique_offset_plane = Plane.new(0, 0, 1, 10)
+
+        point_1 = Point.new(1, 1, 1)
+        point_2 = Point.new(0, 1, 0)
+
+        point_1.project_onto_plane(z_plane).should == Point.new(1, 1, 0)
+        point_2.project_onto_plane(oblique_plane).should == Point.new(0.5, 0.5, 0)
+        point_1.project_onto_plane(oblique_offset_plane).should == Point.new(1, 1, 10)
+      end
+
+      it "should be projected along a vector onto plane" do
+        plane = Plane.new(Point.new(1,1,3), Point.new(0,0,3), Point.new(-1,1,3))
+        direction = Vector.new(1,1,4)
+        start_point = Point.new(5,5,0)
+        end_point = start_point.project_onto_plane_along_vector(plane, direction)
+
+        end_point.x.should be_within(0.001).of(5.75)
+        end_point.y.should be_within(0.001).of(5.75)
+        end_point.z.should be_within(0.001).of(3)
+      end
+
+      it "should be projected normal (dropped) onto line" do
+        line = Line.new(1, 1, 3, -1, 0, 2)
+        point_1 = Point.new(1, 1, 5)
+        point_1.project_onto_line(line).should == Point.new(3, 1, 4)
+
+        point_2 = Point.new(1, 3, 0)
+        point_2.project_onto_line(line).should == Point.new(1, 3, 0)
+      end
+
+      it "should be projected along a vector onto line" do
+        line = Line.new(Point.new(0, 0, 0), Point.new(2, 0, 0))
+        point = Point.new(0, 1, 0)
+        direction = Vector.new(1, -1, 0)
+        point.project_onto_line_along_vector(line, direction).should == Point.new(1, 0, 0)
+        point.should == Point.new(0, 1, 0)
+      end
+    end
+
+    describe "Translation" do
+      it "should translate along a vector" do
+        p = Point.new(1,0,0)
+        v = Vector.new(1,0,0)
+        p.translate(v).should == Point.new(2,0,0)
+        p.should == Point.new(1,0,0)
+      end
+
+      it "should translate along a vector a specified distance" do
+        p = Point.new(0,0,1)
+        v = Vector.new(0,1,0)
+        p.translate(v, 10).should == Point.new(0,10,1)
+        p.should == Point.new(0,0,1)
+      end
+    end
+
+    describe "Transformation:" do
+      it "should transform into a coordinate system" do
+        p1 = Point.new(2,2,0)
+        p2 = Point.new(5,5,0)
+        vx = Vector.new(1,0,0)
+        vy = Vector.new(0,1,0)
+        vz = Vector.new(0,0,1)
+        rcs = RectangularCoordinateSystem.new_from_xvector_and_xyplane(p2, vy, vz)
+        p1.transform(rcs).should == Point.new(-3,3,0)
+        p1.should == Point.new(2,2,0)
+      end
+    end
+  end
+end

data/spec/geom/rectangular_coordinate_system_spec.rb

@@ -0,0 +1,48 @@
+require_relative '../spec_helper.rb'
+require 'geom/rectangular_coordinate_system'
+
+module Geom
+  describe RectangularCoordinateSystem do
+
+    describe "Construction" do
+      before do
+        @origin  = Point.new(0,0,0)
+        @ivector = Vector.new(1,0,0)
+        @jvector = Vector.new(0,1,0)
+        @kvector = Vector.new(0,0,1)
+        @rcs = RectangularCoordinateSystem.new
+      end
+
+      it "should construct a RCS using x-vector and xy-plane normal vector" do
+        RectangularCoordinateSystem.new_from_xvector_and_xyplane(@origin, @ivector, @kvector).should == @rcs
+      end
+
+      it "should construct a RCS using y-vector and yz-plane normal vector" do
+        RectangularCoordinateSystem.new_from_yvector_and_yzplane(@origin, @jvector, @ivector).should == @rcs
+      end
+
+      it "should construct a RCS using z-vector and zx-plane normal vector" do
+        RectangularCoordinateSystem.new_from_zvector_and_zxplane(@origin, @kvector, @jvector).should == @rcs
+      end
+    end
+
+    describe "Return types" do
+      it "should return a summary string" do
+        RectangularCoordinateSystem.new.to_s.should == "RCS[Point(0.000,0.000,0.000) X-Vector(1.000,0.000,0.000) Y-Vector(0.000,1.000,0.000) Z-Vector(0.000,0.000,1.000)]"
+      end
+      it "should print matrix formatted string" do
+        RectangularCoordinateSystem.new.to_s(true).should be
+      end
+
+      it "should calculate a 4x4 transformation matrix" do
+        RectangularCoordinateSystem.new.transformation_matrix.should ==  Matrix[
+          [1.0, 0.0, 0.0, 0.0],
+          [0.0, 1.0, 0.0, 0.0],
+          [0.0, 0.0, 1.0, 0.0],
+          [0.0, 0.0, 0.0, 1.0]
+        ]
+      end
+    end
+
+  end
+end

data/spec/geom/transformation_spec.rb

@@ -0,0 +1,69 @@
+require_relative '../spec_helper.rb'
+require 'geom/transformation'
+
+module Geom
+  describe Transformation do
+    before do
+      @p1 = Point.new(0,0,0)
+      @p2 = Point.new(10,1,1)
+      @vx = Vector.new(1,0,0)
+      @vy = Vector.new(0,1,0)
+      @vz = Vector.new(0,0,1)
+      @rcs_1 = RectangularCoordinateSystem.new_from_xvector_and_xyplane(@p1, @vx, @vz)
+      @rcs_2 = RectangularCoordinateSystem.new_from_xvector_and_xyplane(@p2, @vx, @vz)
+      @rcs_3 = RectangularCoordinateSystem.new_from_xvector_and_xyplane(@p1, @vy, @vz)
+    end
+
+    describe "Construction"   do
+      it "should create a valid instance from a coordinate systems" do
+        transform = Transformation.new(RectangularCoordinateSystem.new)
+        transform.identity?.should be_true
+      end
+    end
+
+    describe "Type" do
+      it "should determine if transformation involves translation" do
+        transform = Transformation.new(@rcs_2)
+        transform.translation?.should be_true
+        transform.rotation?.should be_false
+        transform.scaling?.should be_false
+        transform.type.should == 1
+      end
+
+      it "should determine if transformation involved rotation" do
+        transform = Transformation.new(@rcs_3)
+        transform.translation?.should be_false
+        transform.rotation?.should be_true
+        transform.scaling?.should be_false
+        transform.type.should == 2
+      end
+    end
+
+    describe "Return Types" do
+      it "should print matrix formatted string" do
+        Transformation.new(@rcs_1).to_s(true).should be
+      end
+
+      it "should create a description" do
+        Transformation.new(@rcs_2).type_description.should == "Type 1 Translation"
+        Transformation.new(@rcs_3).type_description.should == "Type 2 Rotation"
+      end
+
+      it "should calculate translation vector" do
+        Transformation.new(@rcs_2).translation_vector.should == Vector.new(10.0, 1.0, 1.0)
+      end
+    end
+
+    describe "Rotation Matrix" do
+      it "should extract sub-matrix" do
+        transform = Transformation.new(@rcs_2)
+        transform.rotation_submatrix.should == Matrix.diagonal(1,1,1)
+      end
+
+      it "should determine if diagonal when only non-zeros on the diagonal" do
+        transform = Transformation.new(@rcs_2)
+        transform.rotation_submatrix_diagonal?.should be_true
+      end
+    end
+  end
+end