add tests for Rect constructors and refactor constructors

Author: ffreyer

src/GeometryBasics.jl

@@ -58,7 +58,7 @@ export uv_mesh, normal_mesh, uv_normal_mesh
 export height, origin, radius, width, widths
 export HyperSphere, Circle, Sphere
 export Cylinder, Pyramid, extremity
-export HyperRectangle, Rect, Rect2, Rect3, Recti, Rect2i, Rect3i, Rectf, Rect2f, Rect3f, Rectd, Rect2d, Rect3d
+export HyperRectangle, Rect, Rect2, Rect3, Recti, Rect2i, Rect3i, Rectf, Rect2f, Rect3f, Rectd, Rect2d, Rect3d, RectT
 export before, during, meets, overlaps, intersects, finishes
 export centered, direction, area, volume, update
 export max_dist_dim, max_euclidean, max_euclideansq, min_dist_dim, min_euclidean

src/primitives/rectangles.jl

@@ -48,6 +48,10 @@ const Recti{N} = Rect{N,Int}
 const Rect2i = Rect2{Int}
 const Rect3i = Rect3{Int}
 
+
+# Constructors
+
+
 Rect() = Rect{2,Float32}()
 RectT{T}() where {T} = Rect{2,T}()
 Rect{N}() where {N} = Rect{N,Float32}()
@@ -57,116 +61,83 @@ function Rect{N,T}() where {T,N}
     return Rect{N,T}(Vec{N,T}(typemax(T)), Vec{N,T}(typemin(T)))
 end
 
-# conversion from other Rects
-function Rect{N,T1}(a::Rect{N,T2}) where {N,T1,T2}
-    return Rect(Vec{N,T1}(minimum(a)), Vec{N,T1}(widths(a)))
-end
-
-function Rect(v1::VecTypes{N,T1}, v2::VecTypes{N,T2}) where {N,T1,T2}
-    T = promote_type(T1, T2)
-    return Rect{N,T}(Vec{N,T}(v1), Vec{N,T}(v2))
-end
-
-function RectT{T}(v1::VecTypes{N}, v2::VecTypes{N}) where {N,T}
-    return if T <: Integer
-        Rect{N,T}(round.(T, v1), round.(T, v2))
-    else
-        return Rect{N,T}(Vec{N,T}(v1), Vec{N,T}(v2))
-    end
-end
-
-function Rect{N}(v1::VecTypes{N}, v2::VecTypes{N}) where {N}
-    T = promote_type(eltype(v1), eltype(v2))
-    return Rect{N,T}(Vec{N,T}(v1), Vec{N,T}(v2))
-end
+# Rect(numbers...)
+Rect(args::Vararg{Number, N}) where {N} = Rect{div(N, 2), promote_type(typeof.(args)...)}(args...)
+RectT{T}(args::Vararg{Number, N}) where {N, T} = Rect{div(N, 2), T}(args...)
+Rect{N}(args::Vararg{Number}) where {N} = Rect{N, promote_type(typeof.(args)...)}(args...)
 
 """
     Rect(vals::Number...)
 
-```
-Rect(vals::Number...)
-```
 Rect constructor for individually specified intervals.
 e.g. Rect(0,0,1,2) has origin == Vec(0,0) and
 width == Vec(1,2)
 """
-function Rect(vals::Vararg{Number, N}) where {N}
-    M, r = fldmod(N, 2)
-    (r == 0) || throw(ArgumentError("number of arguments must be even"))
-    origin, widths = ntuple(i -> vals[i], M), ntuple(i -> vals[i+M], M)
-    return Rect(Vec(origin), Vec(widths))
+function Rect{N, T}(vals::Vararg{Number, M}) where {N, M, T}
+    n, r = fldmod(M, 2)
+    if r != 0 || n != N
+        throw(ArgumentError("Number of arguments must be compatible with given or derived Rect size. Got $M arguments for a Rect{$N} expecting $(2 * N)."))
+    end
+    origin, widths = ntuple(i -> vals[i], N), ntuple(i -> vals[i+N], N)
+    return Rect{N, T}(Vec(origin), Vec(widths))
 end
 
-Rect3(a::Vararg{Number,6}) = Rect3(Vec{3}(a[1], a[2], a[3]), Vec{3}(a[4], a[5], a[6]))
-Rect3(args::Vararg{Number,4}) = Rect3(Rect{2}(args...))
-#=
-From different args
-=#
-function (Rect)(args::Vararg{Number,4})
-    args_prom = promote(args...)
-    return Rect2{typeof(args_prom[1])}(args_prom...)
-end
+# VecTypes
 
-function (Rect2)(args::Vararg{Number,4})
-    args_prom = promote(args...)
-    return Rect2{typeof(args_prom[1])}(args_prom...)
-end
+     Rect(o::VecTypes{N, T1}, w::VecTypes{N, T2}) where {N, T1, T2} = Rect{N, promote_type(T1, T2)}(o, w)
+RectT{ T}(o::VecTypes{N},     w::VecTypes{N})     where {N, T}      = Rect{N, T}(o, w)
+Rect{N  }(o::VecTypes{N, T1}, w::VecTypes{N, T2}) where {N, T1, T2} = Rect{N, promote_type(T1, T2)}(o, w)
 
-function (Rect{2,T})(args::Vararg{Number,4}) where {T}
-    x, y, w, h = T <: Integer ? round.(T, args) : args
-    return Rect2{T}(Vec{2,T}(x, y), Vec{2,T}(w, h))
-end
+# mixed number - vectype
 
-function RectT{T}(args::Vararg{Number,4}) where {T}
-    x, y, w, h = T <: Integer ? round.(T, args) : args
-    return Rect2{T}(Vec{2,T}(x, y), Vec{2,T}(w, h))
-end
+      Rect(o::VecTypes{N, <:Number}, args::Vararg{Number, N}) where {N}    = Rect{N   }(o, promote(args...))
+RectT{  T}(o::VecTypes{N, <:Number}, args::Vararg{Number, N}) where {N, T} = Rect{N, T}(o, promote(args...))
+Rect{N   }(o::VecTypes{N, <:Number}, args::Vararg{Number, N}) where {N}    = Rect{N   }(o, promote(args...))
+Rect{N, T}(o::VecTypes{N, <:Number}, args::Vararg{Number, N}) where {N, T} = Rect{N, T}(o, promote(args...))
 
-function Rect3f(x::Rect2{T}) where {T}
-    return Rect{3,T}(Vec{3,T}(minimum(x)..., 0), Vec{3,T}(widths(x)..., 0.0))
-end
+      Rect(x::Number, y::Number, w::VecTypes{2, <:Number})           = Rect{2   }(Vec(x, y), w)
+RectT{  T}(x::Number, y::Number, w::VecTypes{2, <:Number}) where {T} = Rect{2, T}(Vec(x, y), w)
+Rect{2   }(x::Number, y::Number, w::VecTypes{2, <:Number})           = Rect{2   }(Vec(x, y), w)
+Rect{2, T}(x::Number, y::Number, w::VecTypes{2, <:Number}) where {T} = Rect{2, T}(Vec(x, y), w)
 
-function Rect2{T}(a::Rect2) where {T}
-    return Rect2{T}(minimum(a), widths(a))
-end
+      Rect(x::Number, y::Number, z::Number, w::VecTypes{3, <:Number})           = Rect{3   }(Vec(x, y, z), w)
+RectT{  T}(x::Number, y::Number, z::Number, w::VecTypes{3, <:Number}) where {T} = Rect{3, T}(Vec(x, y, z), w)
+Rect{3   }(x::Number, y::Number, z::Number, w::VecTypes{3, <:Number})           = Rect{3   }(Vec(x, y, z), w)
+Rect{3, T}(x::Number, y::Number, z::Number, w::VecTypes{3, <:Number}) where {T} = Rect{3, T}(Vec(x, y, z), w)
 
-function RectT{T}(a::Rect2) where {T}
-    return Rect2{T}(minimum(a), widths(a))
-end
+# copy constructors
 
-function Rect{N,T}(a::GeometryPrimitive) where {N,T}
-    return Rect{N,T}(Vec{N,T}(minimum(a)), Vec{N,T}(widths(a)))
-end
+      Rect(r::Rect{N, T}) where {N, T} = Rect{N, T}(origin(r), widths(r))
+RectT{  T}(r::Rect{N})    where {N, T} = Rect{N, T}(origin(r), widths(r))
+Rect{N   }(r::Rect{N, T}) where {N, T} = Rect{N, T}(origin(r), widths(r))
+Rect{N, T}(r::Rect{N})    where {N, T} = Rect{N, T}(origin(r), widths(r))
 
-function Rect2(xy::VecTypes{2}, w::Number, h::Number)
-    return Rect2(xy..., w, h)
-end
+# dimensional promotion
 
-function Rect2(x::Number, y::Number, wh::VecTypes{2})
-    return Rect2(x, y, wh...)
-end
+Rect{3, T}(o::VecTypes{2}, w::VecTypes{3}) where {T} = Rect{3, T}(Vec(o..., 0), w)
+Rect{3, T}(o::VecTypes{3}, w::VecTypes{2}) where {T} = Rect{3, T}(o,            Vec(w..., 0))
+Rect{3, T}(o::VecTypes{2}, w::VecTypes{2}) where {T} = Rect{3, T}(Vec(o..., 0), Vec(w..., 0))
 
-function RectT{T}(xy::VecTypes{2}, w::Number, h::Number) where {T}
-    return Rect2{T}(xy..., w, h)
-end
+# Boundingbox-like constructors
 
-function RectT{T}(x::Number, y::Number, wh::VecTypes{2}) where {T}
-    return Rect2{T}(x, y, wh...)
-end
+# Rect(r::GeometryPrimitive{N, T}) where {N, T} = Rect{N, T}(minimum(r), widths(r)) # in boundingboxes.jl
+RectT{T}(r::GeometryPrimitive{N}) where {N, T} = Rect{N, T}(minimum(r), widths(r))
+Rect{N}(r::GeometryPrimitive{_N, T}) where {N, _N, T} = Rect{N, T}(minimum(r), widths(r))
+Rect{N, T}(r::GeometryPrimitive) where {N, T} = Rect{N, T}(minimum(r), widths(r))
 
 # TODO These are kinda silly
 function Rect2(xy::NamedTuple{(:x, :y)}, wh::NamedTuple{(:width, :height)})
     return Rect2(xy.x, xy.y, wh.width, wh.height)
 end
 
-function Rect3f(x::Tuple{Tuple{<:Number,<:Number},Tuple{<:Number,<:Number}})
-    return Rect3f(Vec3f(x[1]..., 0), Vec3f(x[2]..., 0))
-end
+Rect(ow::Tuple) = Rect(ow...)
+RectT{T}(ow::Tuple) where {T} = RectT{T}(ow...)
+Rect{N}(ow::Tuple) where {N} = Rect{N}(ow...)
+Rect{N, T}(ow::Tuple) where {N, T} = Rect{N, T}(ow...)
+
+
+# Utilities
 
-function Rect3f(x::Tuple{Tuple{<:Number,<:Number,<:Number},
-                          Tuple{<:Number,<:Number,<:Number}})
-    return Rect3f(Vec3f(x[1]...), Vec3f(x[2]...))
-end
 
 # allow auto-conversion between different eltypes
 Base.convert(::Type{Rect{N, T}}, r::Rect{N}) where {N, T} = Rect{N, T}(r)

test/geometrytypes.jl

@@ -77,6 +77,88 @@ using Test, GeometryBasics
 end
 
 @testset "HyperRectangles" begin
+    @testset "Constructors" begin
+        # TODO: Do these actually make sense?
+        # Should they not be Rect(NaN..., 0...)?
+        @testset "Empty Constructors" begin
+            for constructor in [Rect, Rect{2}, Rect2, RectT, Rect2f]
+                @test constructor() == Rect{2, Float32}(Inf, Inf, -Inf, -Inf)
+            end
+            for constructor in [Rect{3}, Rect3, Rect3f]
+                @test constructor() == Rect{3, Float32}((Inf, Inf, Inf), (-Inf, -Inf, -Inf))
+            end
+
+            for T in [UInt32, Int16, Float64]
+                a = typemax(T)
+                b = typemin(T)
+                for constructor in [Rect{2, T}, Rect2{T}, RectT{T, 2}]
+                    @test constructor() == Rect{2, T}(a, a, b, b)
+                end
+                for constructor in [Rect{3, T}, Rect3{T}, RectT{T, 3}]
+                    @test constructor() == Rect{3, T}(Point(a, a, a), Vec(b, b, b))
+                end
+            end
+        end
+
+        @testset "Constructor arg conversions" begin
+            function expected_rect(::Type{<: Rect}, arg1, arg2)
+                return Rect{min(length(arg1), length(arg2)), promote_type(eltype(arg1), eltype(arg2))}(arg1, arg2)
+            end
+            function expected_rect(::Type{<: Rect{N}}, arg1, arg2) where {N}
+                return Rect{N, promote_type(eltype(arg1), eltype(arg2))}(arg1, arg2)
+            end
+            function expected_rect(::Type{<: Rect{N, T}}, arg1, arg2) where {N, T}
+                return Rect{N, T}(arg1, arg2)
+            end
+
+            @testset "2D args -> 2D Rect" begin
+                for constructor in [Rect, RectT,   Rect2, Rect{2}, RectT{Int32},
+                                    Rect2f, Rect{2, Float16}, Rect2{UInt32}, RectT{Float64, 2}]
+                    @testset "$constructor" begin
+                        @test constructor(1,2,3,4)           == expected_rect(constructor, Point(1,2), Vec(3,4))
+                        @test constructor(1.0,2,3,4)         == expected_rect(constructor, Point(1.0,2), Vec(3,4))
+                        @test constructor(Point2f(1,2),3,4)  == expected_rect(constructor, Point2f(1,2), Vec(3,4))
+                        @test constructor(Vec2(1,2),3,4.0)   == expected_rect(constructor, Point(1,2), Vec(3,4.0))
+                        @test constructor((1,2),Point2(3,4)) == expected_rect(constructor, Point(1,2), Vec(3,4))
+                        @test constructor(1.0,2,Vec2(3,4))   == expected_rect(constructor, Point(1,2), Vec(3,4))
+                    end
+                end
+            end
+
+            @testset "3D args -> 3D Rect" begin
+                for constructor in [Rect, RectT,   Rect3, Rect{3}, RectT{Float64},
+                                    Rect3d, Rect{3, Int16}, Rect3{UInt8}, RectT{Float32, 3}]
+                    @testset "$constructor" begin
+                        @test constructor(1,2,3,4,5,6)           == expected_rect(constructor, Point(1,2,3), Vec(4,5,6))
+                        @test constructor(1,2,3,4,5,6.0)         == expected_rect(constructor, Point(1,2,3), Vec(4,5,6.0))
+                        @test constructor(1,2.0,3,Vec3f(4,5,6))  == expected_rect(constructor, Point(1,2,3), Vec3f(4,5,6))
+                        @test constructor(Vec3(1,2,3),4,5,6)     == expected_rect(constructor, Point3(1,2,3), Vec(4,5,6))
+                        @test constructor((1,2,3),Point3(4,5,6)) == expected_rect(constructor, Point(1,2,3), Vec(4,5,6))
+                        @test constructor(Vec3(1,2,3),4,5,6)     == expected_rect(constructor, Point(1,2,3), Vec(4,5,6))
+                    end
+                end
+            end
+        end
+
+        @testset "Copy Constructors" begin
+            r = Rect2i(0,0,1,1)
+            for constructor in [Rect, Rect2f, Rect3f, RectT{Float64}]
+                @test constructor(r) == constructor(Point2(0), Vec2(1))
+            end
+        end
+
+        @testset "Special Constructors" begin
+            @test Rect3f((1, 2, 3, Vec(1,2,3))) == Rect3f(1,2,3, Vec(1,2,3))
+            @test Rect2(((1, 2), 3, 4)) == Rect2f((1,2), 3, 4)
+            @test Rect((1, 2, 3, 4)) == Rect2f(1, 2, 3, 4)
+            @test Rect2((x = 1, y = 2), (width = 3, height = 4)) == Rect2f(1, 2, 3, 4)
+        end
+
+        # TODO: test/check for Rect(::GeometryPrimitive) for all primitives
+    end
+
+    # TODO: origin, minimum, maximum, width, height, widths, area, volume with empty constructed Rects
+
     a = Rect(Vec(0, 0), Vec(1, 1))
     pt_expa = Point{2,Int}[(0, 0), (1, 0), (1, 1), (0, 1)]
     @test decompose(Point{2,Int}, a) == pt_expa