change Rect() to generate NaN origin, 0 widths

Author: ffreyer

src/primitives/rectangles.jl

@@ -56,10 +56,9 @@ Rect() = Rect{2,Float32}()
 RectT{T}() where {T} = Rect{2,T}()
 Rect{N}() where {N} = Rect{N,Float32}()
 
-function Rect{N,T}() where {T,N}
-    # empty constructor such that update will always include the first point
-    return Rect{N,T}(Vec{N,T}(typemax(T)), Vec{N,T}(typemin(T)))
-end
+Rect{N,T}() where {T <: AbstractFloat,N} = Rect{N,T}(Vec{N,T}(NaN), Vec{N,T}(0))
+Rect{N,T}() where {T, N} = throw(MethodError(Rect{N,T}, tuple()))
+# TODO: what about integers and other types? No reasonable default?
 
 # Rect(numbers...)
 Rect(args::Vararg{Number, N}) where {N} = Rect{div(N, 2), promote_type(typeof.(args)...)}(args...)
@@ -302,16 +301,19 @@ end
 """
     isempty(h::Rect)
 
-Return `true` if any of the widths of `h` are negative.
+Return `true` if any of the widths of `h` are zero or negative.
 """
-Base.isempty(h::Rect{N,T}) where {N,T} = any(<(zero(T)), h.widths)
+Base.isempty(h::Rect{N,T}) where {N,T} = any(<=(zero(T)), h.widths)
+Base.isnan(r::Rect) = isnan(origin(r)) || isnan(widths(r))
 
 """
     union(r1::Rect{N}, r2::Rect{N})
 
 Returns a new `Rect{N}` which contains both r1 and r2.
 """
 function Base.union(h1::Rect{N}, h2::Rect{N}) where {N}
+    isnan(h1) && return h2
+    isnan(h2) && return h1
     m = min.(minimum(h1), minimum(h2))
     mm = max.(maximum(h1), maximum(h2))
     return Rect{N}(m, mm - m)
@@ -332,6 +334,7 @@ end
 Perform a intersection between two Rects.
 """
 function Base.intersect(h1::Rect{N}, h2::Rect{N}) where {N}
+    isnan(h1) || isnan(h2) && return Rect{N}()
     m = max.(minimum(h1), minimum(h2))
     mm = min.(maximum(h1), maximum(h2))
     return Rect{N}(m, mm - m)
@@ -342,6 +345,8 @@ function update(b::Rect{N,T}, v::VecTypes{N,T2}) where {N,T,T2}
 end
 
 function update(b::Rect{N,T}, v::VecTypes{N,T}) where {N,T}
+    isnan(b) && return Rect{N, T}(v, Vec{N, T}(0))
+
     m = min.(minimum(b), v)
     maxi = maximum(b)
     mm = if any(isnan, maxi)

test/geometrytypes.jl

@@ -78,26 +78,36 @@ end
 
 @testset "HyperRectangles" begin
     @testset "Constructors" begin
-        # TODO: Do these actually make sense?
-        # Should they not be Rect(NaN..., 0...)?
         @testset "Empty Constructors" begin
+            function nan_equal(r1::Rect, r2::Rect)
+                o1 = origin(r1); o2 = origin(r2)
+                return ((isnan(o1) && isnan(o2)) || (o1 == o2)) && (widths(r1) == widths(r2))
+            end
+
             for constructor in [Rect, Rect{2}, Rect2, RectT, Rect2f]
-                @test constructor() == Rect{2, Float32}(Inf, Inf, -Inf, -Inf)
+                @test nan_equal(constructor(), Rect{2, Float32}(NaN, NaN, 0, 0))
             end
             for constructor in [Rect{3}, Rect3, Rect3f]
-                @test constructor() == Rect{3, Float32}((Inf, Inf, Inf), (-Inf, -Inf, -Inf))
+                @test nan_equal(constructor(), Rect{3, Float32}((NaN, NaN, NaN), (0, 0, 0)))
             end
 
-            for T in [UInt32, Int16, Float64]
+            for T in [UInt32, Int16]
                 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)
+                    @test_throws MethodError constructor()
                 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))
+                    @test_throws MethodError constructor()
                 end
             end
+
+            for constructor in [Rect{2, Float64}, Rect2{Float64}, RectT{Float64, 2}]
+                @test nan_equal(constructor(), Rect{2, Float64}(NaN, NaN, 0, 0))
+            end
+            for constructor in [Rect{3, Float64}, Rect3{Float64}, RectT{Float64, 3}]
+                @test nan_equal(constructor(), Rect{3, Float64}(Point3(NaN), Vec3(0)))
+            end
         end
 
         @testset "Constructor arg conversions" begin
@@ -182,19 +192,17 @@ end
         end
     end
 
-    # TODO: These don't really make sense...
     r = Rect2f()
-    @test origin(r) == Vec(Inf, Inf)
-    @test minimum(r) == Vec(Inf, Inf)
+    @test isnan(origin(r))
+    @test isnan(minimum(r))
     @test isnan(maximum(r))
-    @test width(r) == -Inf
-    @test height(r) == -Inf
-    @test widths(r) == Vec(-Inf, -Inf)
-    @test area(r) == Inf
-    @test volume(r) == Inf
-    # TODO: broken? returns NaN widths
-    # @test union(r, Rect2f(1,1,2,2)) == Rect2f(1,1,2,2)
-    # @test union(Rect2f(1,1,2,2), r) == Rect2f(1,1,2,2)
+    @test width(r) == 0
+    @test height(r) == 0
+    @test widths(r) == Vec2(0)
+    @test area(r) == 0
+    @test volume(r) == 0
+    @test union(r, Rect2f(1,1,2,2)) == Rect2f(1,1,2,2)
+    @test union(Rect2f(1,1,2,2), r) == Rect2f(1,1,2,2)
     @test update(r, Vec2f(1,1)) == Rect2f(1,1,0,0)
 
     a = Rect(Vec(0, 1), Vec(2, 3))