change Rect() to return Rect(NaN..., 0...)

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,9 +301,9 @@ 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)
 
 """
     union(r1::Rect{N}, r2::Rect{N})

test/geometrytypes.jl

@@ -81,23 +81,35 @@ end
         # 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,16 +194,15 @@ 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
+    @test width(r) == 0
+    @test height(r) == 0
+    @test widths(r) == Vec2(0)
+    @test area(r) == 0
+    @test volume(r) == 0
 
     a = Rect(Vec(0, 1), Vec(2, 3))
     pt_expa = Point{2,Int}[(0, 1), (2, 1), (2, 4), (0, 4)]