Rename FRect2D to Rect2f, etc.

Author: knuesel

docs/src/decomposition.md

@@ -9,13 +9,13 @@ This can be done for any arbitrary primitive, by overloading the following inter
 
 ```julia
 
-function GeometryBasics.coordinates(rect::Rect2D, nvertices=(2,2))
+function GeometryBasics.coordinates(rect::Rect2, nvertices=(2,2))
     mini, maxi = extrema(rect)
     xrange, yrange = LinRange.(mini, maxi, nvertices)
     return ivec(((x,y) for x in xrange, y in yrange))
 end
 
-function GeometryBasics.faces(rect::Rect2D, nvertices=(2, 2))
+function GeometryBasics.faces(rect::Rect2, nvertices=(2, 2))
     w, h = nvertices
     idx = LinearIndices(nvertices)
     quad(i, j) = QuadFace{Int}(idx[i, j], idx[i+1, j], idx[i+1, j+1], idx[i, j+1])
@@ -29,7 +29,7 @@ can also return any `AbstractArray`.
 With these methods defined, this constructor will magically work:
 
 ```julia
-rect = Rect2D(0.0, 0.0, 1.0, 1.0)
+rect = Rect2(0.0, 0.0, 1.0, 1.0)
 m = GeometryBasics.mesh(rect)
 ```
 If you want to set the `nvertices` argument, you need to wrap your primitive in a `Tesselation`

src/GeometryBasics.jl

@@ -63,7 +63,7 @@ export uv_mesh, normal_mesh, uv_normal_mesh
 export height, origin, radius, width, widths, xwidth, yheight
 export HyperSphere, Circle, Sphere
 export Cylinder, Cylinder2, Cylinder3, Pyramid, extremity
-export HyperRectangle, Rect, Rect2D, Rect3D, IRect, IRect2D, IRect3D, FRect, FRect2D, FRect3D
+export HyperRectangle, Rect, Rect2, Rect3, Recti, Rect2i, Rect3i, Rectf, Rect2f, Rect3f
 export before, during, isinside, isoutside, meets, overlaps, intersects, finishes
 export centered, direction, area, volume, update
 export max_dist_dim, max_euclidean, max_euclideansq, min_dist_dim, min_euclidean

src/deprecated.jl

@@ -17,3 +17,14 @@ for i in 1:4
         @deprecate_binding $oldname $newname
     end
 end
+
+# Rect types
+@deprecate_binding Rect2D  Rect2
+@deprecate_binding Rect3D  Rect3
+@deprecate_binding FRect   Rectf
+@deprecate_binding FRect2D Rect2f
+@deprecate_binding FRect3D Rect3f
+@deprecate_binding IRect   Recti
+@deprecate_binding IRect2D Rect2i
+@deprecate_binding IRect3D Rect3i
+@deprecate_binding TRect   RectT

src/interfaces.jl

@@ -50,7 +50,7 @@ length(coordinates(m1)) != length(coordinates(m2))
 ```
 For grid based tesselation, you can also use a tuple:
 ```julia
-rect = Rect2D(0, 0, 1, 1)
+rect = Rect2(0, 0, 1, 1)
 Tesselation(rect, (5, 5))
 """
 struct Tesselation{Dim,T,Primitive,NGrid}

src/precompile.jl

@@ -22,7 +22,7 @@ function _precompile_()
     @warnpcfail precompile(Tuple{typeof(decompose),Type{Point{2, Float32}},HyperRectangle{2, Float32}})   # time: 0.026609203
     @warnpcfail precompile(Tuple{Type{HyperRectangle{3, Float32}},HyperRectangle{2, Float32}})   # time: 0.023717888
     @warnpcfail precompile(Tuple{typeof(+),HyperRectangle{3, Float32},Point{3, Float32}})   # time: 0.006633118
-    @warnpcfail precompile(Tuple{Type{Rect2D{T} where T},Float32,Float32,Float32,Float32})   # time: 0.001636267
+    @warnpcfail precompile(Tuple{Type{Rect2{T} where T},Float32,Float32,Float32,Float32})   # time: 0.001636267
     @warnpcfail precompile(Tuple{typeof(*),HyperRectangle{2, Float32},Float32})   # time: 0.001057589
 
     if Base.VERSION >= v"1.6.0-DEV.1083"

src/primitives/rectangles.jl

@@ -15,21 +15,21 @@ end
 # Constructors & typealiases
 
 const Rect{N,T} = HyperRectangle{N,T}
-const Rect2D{T} = Rect{2,T}
-const Rect3D{T} = Rect{3,T}
-const TRect{T} = Rect{N,T} where {N}
+const Rect2{T} = Rect{2,T}
+const Rect3{T} = Rect{3,T}
+const RectT{T} = Rect{N,T} where {N}
 
-const FRect{N} = Rect{N,Float32}
-const FRect2D = Rect2D{Float32}
-const FRect3D = Rect3D{Float32}
+const Rectf{N} = Rect{N,Float32}
+const Rect2f = Rect2{Float32}
+const Rect3f = Rect3{Float32}
 
-const IRect{N} = HyperRectangle{N,Int}
-const IRect2D = Rect2D{Int}
-const IRect3D = Rect3D{Int}
+const Recti{N} = HyperRectangle{N,Int}
+const Rect2i = Rect2{Int}
+const Rect3i = Rect3{Int}
 
 Rect() = Rect{2,Float32}()
 
-TRect{T}() where {T} = Rect{2,T}()
+RectT{T}() where {T} = Rect{2,T}()
 
 Rect{N}() where {N} = Rect{N,Float32}()
 
@@ -48,7 +48,7 @@ function Rect(v1::Vec{N,T1}, v2::Vec{N,T2}) where {N,T1,T2}
     return Rect{N,T}(Vec{N,T}(v1), Vec{N,T}(v2))
 end
 
-function TRect{T}(v1::VecTypes{N,T1}, v2::VecTypes{N,T2}) where {N,T,T1,T2}
+function RectT{T}(v1::VecTypes{N,T1}, v2::VecTypes{N,T2}) where {N,T,T1,T2}
     return if T <: Integer
         Rect{N,T}(round.(T, v1), round.(T, v2))
     else
@@ -84,75 +84,75 @@ width == Vec(1,2)
     return Expr(:call, :Rect, v1, v2)
 end
 
-Rect3D(a::Vararg{Number,6}) = Rect3D(Vec{3}(a[1], a[2], a[3]), Vec{3}(a[4], a[5], a[6]))
-Rect3D(args::Vararg{Number,4}) = Rect3D(Rect{2}(args...))
+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 Rect2D{typeof(args_prom[1])}(args_prom...)
+    return Rect2{typeof(args_prom[1])}(args_prom...)
 end
 
-function (Rect2D)(args::Vararg{Number,4})
+function (Rect2)(args::Vararg{Number,4})
     args_prom = promote(args...)
-    return Rect2D{typeof(args_prom[1])}(args_prom...)
+    return Rect2{typeof(args_prom[1])}(args_prom...)
 end
 
 function (Rect{2,T})(args::Vararg{Number,4}) where {T}
     x, y, w, h = T <: Integer ? round.(T, args) : args
-    return Rect2D{T}(Vec{2,T}(x, y), Vec{2,T}(w, h))
+    return Rect2{T}(Vec{2,T}(x, y), Vec{2,T}(w, h))
 end
 
-function TRect{T}(args::Vararg{Number,4}) where {T}
+function RectT{T}(args::Vararg{Number,4}) where {T}
     x, y, w, h = T <: Integer ? round.(T, args) : args
-    return Rect2D{T}(Vec{2,T}(x, y), Vec{2,T}(w, h))
+    return Rect2{T}(Vec{2,T}(x, y), Vec{2,T}(w, h))
 end
 
-function FRect3D(x::Rect2D{T}) where {T}
+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
 
-function Rect2D{T}(a::Rect2D) where {T}
-    return Rect2D{T}(minimum(a), widths(a))
+function Rect2{T}(a::Rect2) where {T}
+    return Rect2{T}(minimum(a), widths(a))
 end
 
-function TRect{T}(a::Rect2D) where {T}
-    return Rect2D{T}(minimum(a), widths(a))
+function RectT{T}(a::Rect2) where {T}
+    return Rect2{T}(minimum(a), widths(a))
 end
 
 function Rect{N,T}(a::GeometryPrimitive) where {N,T}
     return Rect{N,T}(Vec{N,T}(minimum(a)), Vec{N,T}(widths(a)))
 end
 
-function Rect2D(xy::VecTypes{2}, w::Number, h::Number)
-    return Rect2D(xy..., w, h)
+function Rect2(xy::VecTypes{2}, w::Number, h::Number)
+    return Rect2(xy..., w, h)
 end
 
-function Rect2D(x::Number, y::Number, wh::VecTypes{2})
-    return Rect2D(x, y, wh...)
+function Rect2(x::Number, y::Number, wh::VecTypes{2})
+    return Rect2(x, y, wh...)
 end
 
-function TRect{T}(xy::VecTypes{2}, w::Number, h::Number) where {T}
-    return Rect2D{T}(xy..., w, h)
+function RectT{T}(xy::VecTypes{2}, w::Number, h::Number) where {T}
+    return Rect2{T}(xy..., w, h)
 end
 
-function TRect{T}(x::Number, y::Number, wh::VecTypes{2}) where {T}
-    return Rect2D{T}(x, y, wh...)
+function RectT{T}(x::Number, y::Number, wh::VecTypes{2}) where {T}
+    return Rect2{T}(x, y, wh...)
 end
 
 # TODO These are kinda silly
-function Rect2D(xy::NamedTuple{(:x, :y)}, wh::NamedTuple{(:width, :height)})
-    return Rect2D(xy.x, xy.y, wh.width, wh.height)
+function Rect2(xy::NamedTuple{(:x, :y)}, wh::NamedTuple{(:width, :height)})
+    return Rect2(xy.x, xy.y, wh.width, wh.height)
 end
 
-function FRect3D(x::Tuple{Tuple{<:Number,<:Number},Tuple{<:Number,<:Number}})
-    return FRect3D(Vec3f(x[1]..., 0), Vec3f(x[2]..., 0))
+function Rect3f(x::Tuple{Tuple{<:Number,<:Number},Tuple{<:Number,<:Number}})
+    return Rect3f(Vec3f(x[1]..., 0), Vec3f(x[2]..., 0))
 end
 
-function FRect3D(x::Tuple{Tuple{<:Number,<:Number,<:Number},
+function Rect3f(x::Tuple{Tuple{<:Number,<:Number,<:Number},
                           Tuple{<:Number,<:Number,<:Number}})
-    return FRect3D(Vec3f(x[1]...), Vec3f(x[2]...))
+    return Rect3f(Vec3f(x[1]...), Vec3f(x[2]...))
 end
 
 origin(prim::Rect) = prim.origin
@@ -165,7 +165,7 @@ width(prim::Rect) = prim.widths[1]
 height(prim::Rect) = prim.widths[2]
 
 volume(prim::HyperRectangle) = prod(prim.widths)
-area(prim::Rect2D) = volume(prim)
+area(prim::Rect2) = volume(prim)
 
 """
     split(rectangle, axis, value)
@@ -279,7 +279,7 @@ function Base.:(*)(rect::Rect, scaling::Union{Number,StaticVector})
 end
 
 # Enables rectangular indexing into a matrix
-function Base.to_indices(A::AbstractMatrix{T}, I::Tuple{Rect2D{IT}}) where {T,IT<:Integer}
+function Base.to_indices(A::AbstractMatrix{T}, I::Tuple{Rect2{IT}}) where {T,IT<:Integer}
     rect = I[1]
     mini = minimum(rect)
     wh = widths(rect)
@@ -515,33 +515,33 @@ centered(R::Type{Rect{N}}) where {N} = R(Vec{N,Float32}(-0.5), Vec{N,Float32}(1)
 centered(R::Type{Rect}) where {N} = R(Vec{2,Float32}(-0.5), Vec{2,Float32}(1))
 
 ##
-# Rect2D decomposition
+# Rect2 decomposition
 
-function faces(rect::Rect2D, nvertices=(2, 2))
+function faces(rect::Rect2, nvertices=(2, 2))
     w, h = nvertices
     idx = LinearIndices(nvertices)
     quad(i, j) = QuadFace{Int}(idx[i, j], idx[i + 1, j], idx[i + 1, j + 1], idx[i, j + 1])
     return ivec((quad(i, j) for i in 1:(w - 1), j in 1:(h - 1)))
 end
 
-function coordinates(rect::Rect2D, nvertices=(2, 2))
+function coordinates(rect::Rect2, nvertices=(2, 2))
     mini, maxi = extrema(rect)
     xrange, yrange = LinRange.(mini, maxi, nvertices)
     return ivec(((x, y) for x in xrange, y in yrange))
 end
 
-function texturecoordinates(rect::Rect2D, nvertices=(2, 2))
+function texturecoordinates(rect::Rect2, nvertices=(2, 2))
     xrange, yrange = LinRange.((0, 1), (1, 0), nvertices)
     return ivec(((x, y) for x in xrange, y in yrange))
 end
 
-function normals(rect::Rect2D, nvertices=(2, 2))
+function normals(rect::Rect2, nvertices=(2, 2))
     return Iterators.repeated((0, 0, 1), prod(nvertices))
 end
 
 ##
-# Rect3D decomposition
-function coordinates(rect::Rect3D)
+# Rect3 decomposition
+function coordinates(rect::Rect3)
     # TODO use n
     w = widths(rect)
     o = origin(rect)
@@ -552,11 +552,11 @@ function coordinates(rect::Rect3D)
     return ((x .* w .+ o) for x in points)
 end
 
-function texturecoordinates(rect::Rect3D)
-    return coordinates(Rect3D(0, 0, 0, 1, 1, 1))
+function texturecoordinates(rect::Rect3)
+    return coordinates(Rect3(0, 0, 0, 1, 1, 1))
 end
 
-function faces(rect::Rect3D)
+function faces(rect::Rect3)
     return QuadFace{Int}[(1, 2, 3, 4), (5, 6, 7, 8), (9, 10, 11, 12), (13, 14, 15, 16),
                          (17, 18, 19, 20), (21, 22, 23, 24),]
 end

test/geometrytypes.jl

@@ -77,7 +77,7 @@ using Test, GeometryBasics
         @test m isa GLNormalMesh
 
         muv = uv_mesh(s)
-        @test Rect(Point.(texturecoordinates(muv))) == FRect2D(Vec2f(0), Vec2f(1.0))
+        @test Rect(Point.(texturecoordinates(muv))) == Rect2f(Vec2f(0), Vec2f(1.0))
     end
 end
 
@@ -134,7 +134,7 @@ end
                          (0.0, -1.0, 0.0), (0.0, -1.0, 0.0), (0.0, -1.0, 0.0),
                          (0.0, -1.0, 0.0),]
     n32 = map(Vec{3,Float32}, n64)
-    r = triangle_mesh(centered(Rect3D))
+    r = triangle_mesh(centered(Rect3))
     # @test normals(coordinates(r), GeometryBasics.faces(r)) == n32
     # @test normals(coordinates(r), GeometryBasics.faces(r)) == n64
 end
@@ -164,31 +164,31 @@ end
 end
 
 @testset "Rectangles" begin
-    rect = FRect2D(0, 7, 20, 3)
-    @test (rect + 4) == FRect2D(4, 11, 20, 3)
-    @test (rect + Vec(2, -2)) == FRect2D(2, 5, 20, 3)
+    rect = Rect2f(0, 7, 20, 3)
+    @test (rect + 4) == Rect2f(4, 11, 20, 3)
+    @test (rect + Vec(2, -2)) == Rect2f(2, 5, 20, 3)
 
-    @test (rect - 4) == FRect2D(-4, 3, 20, 3)
-    @test (rect - Vec(2, -2)) == FRect2D(-2, 9, 20, 3)
+    @test (rect - 4) == Rect2f(-4, 3, 20, 3)
+    @test (rect - Vec(2, -2)) == Rect2f(-2, 9, 20, 3)
 
     base = Vec3f(1, 2, 3)
     wxyz = Vec3f(-2, 4, 2)
-    rect = FRect3D(base, wxyz)
-    @test (rect + 4) == FRect3D(base .+ 4, wxyz)
-    @test (rect + Vec(2, -2, 3)) == FRect3D(base .+ Vec(2, -2, 3), wxyz)
+    rect = Rect3f(base, wxyz)
+    @test (rect + 4) == Rect3f(base .+ 4, wxyz)
+    @test (rect + Vec(2, -2, 3)) == Rect3f(base .+ Vec(2, -2, 3), wxyz)
 
-    @test (rect - 4) == FRect3D(base .- 4, wxyz)
-    @test (rect - Vec(2, -2, 7)) == FRect3D(base .- Vec(2, -2, 7), wxyz)
+    @test (rect - 4) == Rect3f(base .- 4, wxyz)
+    @test (rect - Vec(2, -2, 7)) == Rect3f(base .- Vec(2, -2, 7), wxyz)
 
-    rect = FRect2D(0, 7, 20, 3)
-    @test (rect * 4) == FRect2D(0, 7 * 4, 20 * 4, 3 * 4)
-    @test (rect * Vec(2, -2)) == FRect2D(0, -7 * 2, 20 * 2, -3 * 2)
+    rect = Rect2f(0, 7, 20, 3)
+    @test (rect * 4) == Rect2f(0, 7 * 4, 20 * 4, 3 * 4)
+    @test (rect * Vec(2, -2)) == Rect2f(0, -7 * 2, 20 * 2, -3 * 2)
 
     base = Vec3f(1, 2, 3)
     wxyz = Vec3f(-2, 4, 2)
-    rect = FRect3D(base, wxyz)
-    @test (rect * 4) == FRect3D(base .* 4, wxyz .* 4)
-    @test (rect * Vec(2, -2, 3)) == FRect3D(base .* Vec(2, -2, 3), wxyz .* Vec(2, -2, 3))
+    rect = Rect3f(base, wxyz)
+    @test (rect * 4) == Rect3f(base .* 4, wxyz .* 4)
+    @test (rect * Vec(2, -2, 3)) == Rect3f(base .* Vec(2, -2, 3), wxyz .* Vec(2, -2, 3))
 
     rect1 = Rect(Vec(0.0, 0.0), Vec(1.0, 2.0))
     rect2 = Rect(0.0, 0.0, 1.0, 2.0)
@@ -208,8 +208,8 @@ end
     @test width(prim) == 1.0
     @test height(prim) == 1.0
 
-    b1 = Rect2D(0.0, 0.0, 2.0, 2.0)
-    b2 = Rect2D(0, 0, 2, 2)
+    b1 = Rect2(0.0, 0.0, 2.0, 2.0)
+    b2 = Rect2(0, 0, 2, 2)
     @test isequal(b1, b2)
 
     pt = Point(1.0, 1.0)