test the rest of Rect

Author: ffreyer

src/primitives/rectangles.jl

@@ -125,6 +125,13 @@ 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))
 
+# centered Rects
+
+centered(R::Type{Rect{N,T}}) where {N,T} = R(Vec{N,T}(-0.5), Vec{N,T}(1))
+centered(R::Type{RectT{T}}) where {T} = R(Vec{2,T}(-0.5), Vec{2,T}(1))
+centered(R::Type{Rect{N}}) where {N} = R(Vec{N,Float32}(-0.5), Vec{N,Float32}(1))
+centered(R::Type{Rect}) = R(Vec{2,Float32}(-0.5), Vec{2,Float32}(1))
+
 # 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)
@@ -337,11 +344,11 @@ function Base.intersect(h1::Rect{N}, h2::Rect{N}) where {N}
     return Rect{N}(m, mm - m)
 end
 
-function update(b::Rect{N,T}, v::Vec{N,T2}) where {N,T,T2}
+function update(b::Rect{N,T}, v::VecTypes{N,T2}) where {N,T,T2}
     return update(b, Vec{N,T}(v))
 end
 
-function update(b::Rect{N,T}, v::Vec{N,T}) where {N,T}
+function update(b::Rect{N,T}, v::VecTypes{N,T}) where {N,T}
     m = min.(minimum(b), v)
     maxi = maximum(b)
     mm = if any(isnan, maxi)
@@ -353,11 +360,11 @@ function update(b::Rect{N,T}, v::Vec{N,T}) where {N,T}
 end
 
 # Min maximum distance functions between hrectangle and point for a given dimension
-function min_dist_dim(rect::Rect{N,T}, p::Vec{N,T}, dim::Int) where {N,T}
+function min_dist_dim(rect::Rect{N,T}, p::VecTypes{N,T}, dim::Int) where {N,T}
     return max(zero(T), max(minimum(rect)[dim] - p[dim], p[dim] - maximum(rect)[dim]))
 end
 
-function max_dist_dim(rect::Rect{N,T}, p::Vec{N,T}, dim::Int) where {N,T}
+function max_dist_dim(rect::Rect{N,T}, p::VecTypes{N,T}, dim::Int) where {N,T}
     return max(maximum(rect)[dim] - p[dim], p[dim] - minimum(rect)[dim])
 end
 
@@ -373,7 +380,7 @@ function max_dist_dim(rect1::Rect{N,T}, rect2::Rect{N,T}, dim::Int) where {N,T}
 end
 
 # Total minimum maximum distance functions
-function min_euclideansq(rect::Rect{N,T}, p::Union{Vec{N,T},Rect{N,T}}) where {N,T}
+function min_euclideansq(rect::Rect{N,T}, p::Union{VecTypes{N,T},Rect{N,T}}) where {N,T}
     minimum_dist = T(0.0)
     for dim in 1:length(p)
         d = min_dist_dim(rect, p, dim)
@@ -382,7 +389,7 @@ function min_euclideansq(rect::Rect{N,T}, p::Union{Vec{N,T},Rect{N,T}}) where {N
     return minimum_dist
 end
 
-function max_euclideansq(rect::Rect{N,T}, p::Union{Vec{N,T},Rect{N,T}}) where {N,T}
+function max_euclideansq(rect::Rect{N,T}, p::Union{VecTypes{N,T},Rect{N,T}}) where {N,T}
     maximum_dist = T(0.0)
     for dim in 1:length(p)
         d = max_dist_dim(rect, p, dim)
@@ -391,29 +398,29 @@ function max_euclideansq(rect::Rect{N,T}, p::Union{Vec{N,T},Rect{N,T}}) where {N
     return maximum_dist
 end
 
-function min_euclidean(rect::Rect{N,T}, p::Union{Vec{N,T},Rect{N,T}}) where {N,T}
+function min_euclidean(rect::Rect{N,T}, p::Union{VecTypes{N,T},Rect{N,T}}) where {N,T}
     return sqrt(min_euclideansq(rect, p))
 end
 
-function max_euclidean(rect::Rect{N,T}, p::Union{Vec{N,T},Rect{N,T}}) where {N,T}
+function max_euclidean(rect::Rect{N,T}, p::Union{VecTypes{N,T},Rect{N,T}}) where {N,T}
     return sqrt(max_euclideansq(rect, p))
 end
 
 # Functions that return both minimum and maximum for convenience
-function minmax_dist_dim(rect::Rect{N,T}, p::Union{Vec{N,T},Rect{N,T}},
+function minmax_dist_dim(rect::Rect{N,T}, p::Union{VecTypes{N,T},Rect{N,T}},
                          dim::Int) where {N,T}
     minimum_d = min_dist_dim(rect, p, dim)
     maximum_d = max_dist_dim(rect, p, dim)
     return minimum_d, maximum_d
 end
 
-function minmax_euclideansq(rect::Rect{N,T}, p::Union{Vec{N,T},Rect{N,T}}) where {N,T}
+function minmax_euclideansq(rect::Rect{N,T}, p::Union{VecTypes{N,T},Rect{N,T}}) where {N,T}
     minimum_dist = min_euclideansq(rect, p)
     maximum_dist = max_euclideansq(rect, p)
     return minimum_dist, maximum_dist
 end
 
-function minmax_euclidean(rect::Rect{N,T}, p::Union{Vec{N,T},Rect{N,T}}) where {N,T}
+function minmax_euclidean(rect::Rect{N,T}, p::Union{VecTypes{N,T},Rect{N,T}}) where {N,T}
     minimumsq, maximumsq = minmax_euclideansq(rect, p)
     return sqrt(minimumsq), sqrt(maximumsq)
 end
@@ -502,10 +509,6 @@ Base.:(==)(b1::Rect, b2::Rect) = minimum(b1) == minimum(b2) && widths(b1) == wid
 
 Base.isequal(b1::Rect, b2::Rect) = b1 == b2
 
-centered(R::Type{Rect{N,T}}) where {N,T} = R(Vec{N,T}(-0.5), Vec{N,T}(1))
-centered(R::Type{Rect{N}}) where {N} = R(Vec{N,Float32}(-0.5), Vec{N,Float32}(1))
-centered(R::Type{Rect}) = R(Vec{2,Float32}(-0.5), Vec{2,Float32}(1))
-
 ##
 # Rect2 decomposition
 

test/geometrytypes.jl

@@ -121,6 +121,7 @@ end
                         @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))
+                        @test_throws ArgumentError constructor(1,2,3)
                     end
                 end
             end
@@ -135,6 +136,7 @@ end
                         @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))
+                        @test_throws ArgumentError constructor(1,2,3)
                     end
                 end
             end
@@ -152,6 +154,14 @@ end
             @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)
+
+            for constructor in [Rect, RectT,   Rect2, Rect{2}, RectT{Float32},
+                                Rect2f, Rect{2, Float16}, Rect2{Float16}, RectT{Float64, 2}]
+                @test centered(constructor) == constructor(Point2d(-0.5), Vec2d(1))
+            end
+            for constructor in [Rect3, Rect{3}, Rect3d, Rect{3, Float16}, Rect3{Float64}, RectT{Float32, 3}]
+                @test centered(constructor) == constructor(Point3d(-0.5), Vec3d(1))
+            end
         end
 
         # TODO: test/check for Rect(::GeometryPrimitive) for all primitives
@@ -306,8 +316,17 @@ end
     @test widths(split1) == widths(split2)
     @test origin(split1) == Vec(0, 0)
     @test origin(split2) == Vec(0, 1)
-    @test in(split1, rect1)
-    @test !in(rect1, split1)
+    @test in(split1, rect1) && in(split2, rect1)
+    @test !(in(rect1, split1) || in(rect1, split2))
+
+    rect1 = Rect(Vec(0.0, 0.0, -1.0), Vec(1.0, 2.0, 1.0))
+    split1, split2 = GeometryBasics.split(rect1, 1, 0.75)
+    @test widths(split1) == Vec(0.75, 2, 1)
+    @test widths(split2) == Vec(0.25, 2, 1)
+    @test origin(split1) == Vec(0, 0, -1)
+    @test origin(split2) == Vec(0.75, 0, -1)
+    @test in(split1, rect1) && in(split2, rect1)
+    @test !(in(rect1, split1) || in(rect1, split2))
 
     prim = Rect(0.0, 0.0, 1.0, 1.0)
     @test length(prim) == 2
@@ -338,19 +357,33 @@ end
     v = Vec(1.0, 2.0)
     @test update(b, v) isa GeometryBasics.HyperRectangle{2,Float64}
 
-    p = Vec(5.0, 4.0)
-    rect = Rect(0.0, 0.0, 1.0, 1.0)
-    @test min_dist_dim(rect, p, 1) == 4.0
-    @test min_dist_dim(rect, p, 2) == 3.0
-    @test max_dist_dim(rect, p, 1) == 5.0
-    @test max_dist_dim(rect, p, 2) == 4.0
-
-    rect1 = Rect(0.0, 0.0, 1.0, 1.0)
-    rect2 = Rect(3.0, 1.0, 4.0, 2.0)
-    @test min_dist_dim(rect1, rect2, 1) == 2.0
-    @test min_dist_dim(rect1, rect2, 2) == 0.0
-    @test max_dist_dim(rect1, rect2, 1) == 7.0
-    @test max_dist_dim(rect1, rect2, 2) == 3.0
+    @testset "euclidean distances" begin
+        p = Vec(5.0, 4.0)
+        rect = Rect(0.0, 0.0, 1.0, 1.0)
+        @test min_dist_dim(rect, p, 1) == 4.0
+        @test min_dist_dim(rect, p, 2) == 3.0
+        @test max_dist_dim(rect, p, 1) == 5.0
+        @test max_dist_dim(rect, p, 2) == 4.0
+        @test minmax_dist_dim(rect, p, 1) == (4.0, 5.0)
+
+        rect1 = Rect(0.0, 0.0, 1.0, 1.0)
+        rect2 = Rect(3.0, 1.0, 4.0, 2.0)
+        @test min_dist_dim(rect1, rect2, 1) == 2.0
+        @test min_dist_dim(rect1, rect2, 2) == 0.0
+        @test max_dist_dim(rect1, rect2, 1) == 7.0
+        @test max_dist_dim(rect1, rect2, 2) == 3.0
+        @test minmax_dist_dim(rect1, rect2, 1) == (2.0, 7.0)
+
+        r = Rect2f(-1, -1, 2, 3)
+        p = Point2f(1, 2) + Point2f(3, 4)
+        @test min_euclidean(r, p) == 5f0
+        @test max_euclidean(r, p) ≈ sqrt(5*5 + 7*7)
+
+        r2 = Rect2f(0, 0, 2, 3)
+        @test min_euclidean(r, r2) == 0f0
+        @test max_euclidean(r, r2) == 5f0
+        @test minmax_euclidean(r, r2) == (0f0, 5f0)
+    end
 
     @test !before(rect1, rect2)
     rect1 = Rect(0.0, 0.0, 1.0, 1.0)
@@ -397,5 +430,29 @@ end
     rect2 = Rect(Vec(1, 2, 3, 4), Vec(5, 6, 7, 8))
     @test rect1 == rect2
 
-    @test_throws ArgumentError Rect(1, 2, 3)
-end
+    @testset "Matrix Multiplications" begin
+        r = Rect2f(-1, -2, 4, 3)
+
+        # TODO: this seems quite dangerous: We pad points with ones which makes
+        #       sense for translations if we go to D+1, but is nonsense if we
+        #       go higher dimensions than that.
+        M = rand(Mat4f)
+        ps = Point2f[M * Point(p..., 1, 1) for p in coordinates(r)]
+        @test Rect2f(ps) == M * r
+
+        M = Mat2f(0.5, -0.3, 0.7, 1.5)
+        ps = Point2f[M * p for p in coordinates(r)]
+        @test Rect2f(ps) == M * r
+
+        r = Rect3f(-1, -2, -3, 2, 4, 1)
+        M = rand(Mat4f)
+        ps = Point3f[M * Point(p..., 1) for p in coordinates(r)]
+        @test Rect3f(ps) == M * r
+    end
+
+    # TODO: this is effectively 0-indexed... should it be?
+    M = reshape(collect(11:100), 10, 9)[1:9, :]
+    r = Rect2i(2, 4, 2, 4)
+    @test M[r] == [53 63 73 83; 54 64 74 84]
+
+end