Replace f0 suffix with f

Author: knuesel

docs/src/decomposition.md

@@ -48,7 +48,7 @@ But will actually not be an iterator anymore. Instead, the mesh constructor uses
 the `decompose` function, that will collect the result of coordinates and will
 convert it to a concrete element type:
 ```julia
-decompose(Point2f0, rect) == convert(Vector{Point2f0}, collect(coordinates(rect)))
+decompose(Point2f, rect) == convert(Vector{Point2f}, collect(coordinates(rect)))
 ```
 The element conversion is handled by `simplex_convert`, which also handles convert
 between different face types:
@@ -65,12 +65,12 @@ decompose(Point, rect) isa Vector{Point{2, Float64}}
 ```
 You can also pass the element type to `mesh`:
 ```julia
-m = GeometryBasics.mesh(rect, pointtype=Point2f0, facetype=QuadFace{Int})
+m = GeometryBasics.mesh(rect, pointtype=Point2f, facetype=QuadFace{Int})
 ```
 You can also set the uv and normal type for the mesh constructor, which will then
 calculate them for you, with the requested element type:
 ```julia
-m = GeometryBasics.mesh(rect, uv=Vec2f0, normaltype=Vec3f0)
+m = GeometryBasics.mesh(rect, uv=Vec2f, normaltype=Vec3f)
 ```
 
 As you can see, the normals are automatically calculated,
@@ -79,11 +79,11 @@ the same is true for texture coordinates. You can overload this behavior by over
 `decompose` works a bit different for normals/texturecoordinates, since they dont have their own element type.
 Instead, you can use `decompose` like this:
 ```julia
-decompose(UV(Vec2f0), rect)
-decompose(Normal(Vec3f0), rect)
+decompose(UV(Vec2f), rect)
+decompose(Normal(Vec3f), rect)
 # the short form for the above:
 decompose_uv(rect)
 decompose_normals(rect)
 ```
 You can also use `triangle_mesh`, `normal_mesh` and `uv_normal_mesh` to call the
-`mesh` constructor with predefined element types (Point2/3f0, Vec2/3f0), and the requested attributes.
+`mesh` constructor with predefined element types (Point2/3f, Vec2/3f), and the requested attributes.

src/GeometryBasics.jl

@@ -24,6 +24,8 @@ include("triangulation.jl")
 include("lines.jl")
 include("boundingboxes.jl")
 
+include("deprecated.jl")
+
 export AbstractGeometry, GeometryPrimitive
 export Mat, Point, Vec
 export LineFace, Polytope, Line, NgonFace, convert_simplex

src/fixed_arrays.jl

@@ -121,31 +121,30 @@ abstract type AbstractPoint{Dim,T} <: StaticVector{Dim,T} end
 
 const Mat = SMatrix
 const VecTypes{N,T} = Union{StaticVector{N,T},NTuple{N,T}}
-const Vecf0{N} = Vec{N,Float32}
-const Pointf0{N} = Point{N,Float32}
+const Vecf{N} = Vec{N,Float32}
+const Pointf{N} = Point{N,Float32}
 Base.isnan(p::Union{AbstractPoint,Vec}) = any(x -> isnan(x), p)
 
-# Create constes like Mat4f0, Point2, Point2f0
 for i in 1:4
     for T in [:Point, :Vec]
         name = Symbol("$T$i")
-        namef0 = Symbol("$T$(i)f0")
+        namef = Symbol("$T$(i)f")
         @eval begin
             const $name = $T{$i}
-            const $namef0 = $T{$i,Float32}
+            const $namef = $T{$i,Float32}
             export $name
-            export $namef0
+            export $namef
         end
     end
     name = Symbol("Mat$i")
-    namef0 = Symbol("Mat$(i)f0")
+    namef = Symbol("Mat$(i)f")
     @eval begin
         const $name{T} = $Mat{$i,$i,T,$(i * i)}
-        const $namef0 = $name{Float32}
+        const $namef = $name{Float32}
         export $name
-        export $namef0
+        export $namef
     end
 end
 
 export Mat, Vec, Point, unit
-export Vecf0, Pointf0
+export Vecf, Pointf

src/interfaces.jl

@@ -43,7 +43,7 @@ To transport this information to the various decompose methods, you can wrap it
 in the Tesselation object e.g. like this:
 
 ```julia
-sphere = Sphere(Point3f0(0), 1)
+sphere = Sphere(Point3f(0), 1)
 m1 = mesh(sphere) # uses a default value for tesselation
 m2 = mesh(Tesselation(sphere, 64)) # uses 64 for tesselation
 length(coordinates(m1)) != length(coordinates(m2))
@@ -81,7 +81,7 @@ function texturecoordinates(tesselation::Tesselation)
 end
 
 ## Decompose methods
-# Dispatch type to make `decompose(UV{Vec2f0}, primitive)` work
+# Dispatch type to make `decompose(UV{Vec2f}, primitive)` work
 # and to pass through tesselation information
 
 # Types that can be converted to a mesh via the functions below
@@ -91,13 +91,13 @@ const Meshable{Dim,T} = Union{Tesselation{Dim,T},Mesh{Dim,T},AbstractPolygon{Dim
 
 struct UV{T} end
 UV(::Type{T}) where {T} = UV{T}()
-UV() = UV(Vec2f0)
+UV() = UV(Vec2f)
 struct UVW{T} end
 UVW(::Type{T}) where {T} = UVW{T}()
-UVW() = UVW(Vec3f0)
+UVW() = UVW(Vec3f)
 struct Normal{T} end
 Normal(::Type{T}) where {T} = Normal{T}()
-Normal() = Normal(Vec3f0)
+Normal() = Normal(Vec3f)
 
 function decompose(::Type{F}, primitive) where {F<:AbstractFace}
     f = faces(primitive)

src/meshes.jl

@@ -44,7 +44,7 @@ const GLPlainMesh3D = GLPlainMesh{3}
     UVMesh{Dim, T}
 
 PlainMesh with texture coordinates meta at each point.
-`uvmesh.uv isa AbstractVector{Vec2f0}`
+`uvmesh.uv isa AbstractVector{Vec2f}`
 """
 const UVMesh{Dim,T} = TriangleMesh{Dim,T,PointWithUV{Dim,T}}
 const GLUVMesh{Dim} = UVMesh{Dim,Float32}
@@ -55,7 +55,7 @@ const GLUVMesh3D = UVMesh{3}
     NormalMesh{Dim, T}
 
 PlainMesh with normals meta at each point.
-`normalmesh.normals isa AbstractVector{Vec3f0}`
+`normalmesh.normals isa AbstractVector{Vec3f}`
 """
 const NormalMesh{Dim,T} = TriangleMesh{Dim,T,PointWithNormal{Dim,T}}
 const GLNormalMesh{Dim} = NormalMesh{Dim,Float32}
@@ -66,8 +66,8 @@ const GLNormalMesh3D = GLNormalMesh{3}
     NormalUVMesh{Dim, T}
 
 PlainMesh with normals and uv meta at each point.
-`normalmesh.normals isa AbstractVector{Vec3f0}`
-`normalmesh.uv isa AbstractVector{Vec2f0}`
+`normalmesh.normals isa AbstractVector{Vec3f}`
+`normalmesh.uv isa AbstractVector{Vec2f}`
 """
 const NormalUVMesh{Dim,T} = TriangleMesh{Dim,T,PointWithUVNormal{Dim,T}}
 const GLNormalUVMesh{Dim} = NormalUVMesh{Dim,Float32}
@@ -78,8 +78,8 @@ const GLNormalUVMesh3D = GLNormalUVMesh{3}
     NormalUVWMesh{Dim, T}
 
 PlainMesh with normals and uvw (texture coordinates in 3D) meta at each point.
-`normalmesh.normals isa AbstractVector{Vec3f0}`
-`normalmesh.uvw isa AbstractVector{Vec3f0}`
+`normalmesh.normals isa AbstractVector{Vec3f}`
+`normalmesh.uvw isa AbstractVector{Vec3f}`
 """
 const NormalUVWMesh{Dim,T} = TriangleMesh{Dim,T,PointWithUVWNormal{Dim,T}}
 const GLNormalUVWMesh{Dim} = NormalUVWMesh{Dim,Float32}
@@ -176,17 +176,17 @@ function triangle_mesh(primitive::Meshable{N}; nvertices=nothing) where {N}
 end
 
 function uv_mesh(primitive::Meshable{N,T}) where {N,T}
-    return mesh(primitive; pointtype=Point{N,Float32}, uv=Vec2f0, facetype=GLTriangleFace)
+    return mesh(primitive; pointtype=Point{N,Float32}, uv=Vec2f, facetype=GLTriangleFace)
 end
 
 function uv_normal_mesh(primitive::Meshable{N}) where {N}
-    return mesh(primitive; pointtype=Point{N,Float32}, uv=Vec2f0, normaltype=Vec3f0,
+    return mesh(primitive; pointtype=Point{N,Float32}, uv=Vec2f, normaltype=Vec3f,
                 facetype=GLTriangleFace)
 end
 
 function normal_mesh(points::AbstractVector{<:AbstractPoint},
                      faces::AbstractVector{<:AbstractFace})
-    _points = decompose(Point3f0, points)
+    _points = decompose(Point3f, points)
     _faces = decompose(GLTriangleFace, faces)
     return Mesh(meta(_points; normals=normals(_points, _faces)), _faces)
 end
@@ -196,7 +196,7 @@ function normal_mesh(primitive::Meshable{N}; nvertices=nothing) where {N}
         @warn("nvertices argument deprecated. Wrap primitive in `Tesselation(primitive, nvertices)`")
         primitive = Tesselation(primitive, nvertices)
     end
-    return mesh(primitive; pointtype=Point{N,Float32}, normaltype=Vec3f0,
+    return mesh(primitive; pointtype=Point{N,Float32}, normaltype=Vec3f,
                 facetype=GLTriangleFace)
 end
 

src/precompile.jl

@@ -26,14 +26,14 @@ function _precompile_()
     @warnpcfail precompile(Tuple{typeof(*),HyperRectangle{2, Float32},Float32})   # time: 0.001057589
 
     if Base.VERSION >= v"1.6.0-DEV.1083"
-        @warnpcfail precompile(triangle_mesh, (Polygon{2, Float32, Point2f0, LineString{2, Float32, Point2f0,
-                                        Base.ReinterpretArray{Line{2, Float32}, 1, Tuple{Point2f0, Point2f0}, TupleView{Tuple{Point2f0, Point2f0}, 2, 1, Vector{Point2f0}}, false}},
-                                        Vector{LineString{2, Float32, Point2f0, Base.ReinterpretArray{Line{2, Float32}, 1, Tuple{Point2f0, Point2f0}, TupleView{Tuple{Point2f0, Point2f0}, 2, 1, Vector{Point2f0}}, false}}}},))
+        @warnpcfail precompile(triangle_mesh, (Polygon{2, Float32, Point2f, LineString{2, Float32, Point2f,
+                                        Base.ReinterpretArray{Line{2, Float32}, 1, Tuple{Point2f, Point2f}, TupleView{Tuple{Point2f, Point2f}, 2, 1, Vector{Point2f}}, false}},
+                                        Vector{LineString{2, Float32, Point2f, Base.ReinterpretArray{Line{2, Float32}, 1, Tuple{Point2f, Point2f}, TupleView{Tuple{Point2f, Point2f}, 2, 1, Vector{Point2f}}, false}}}},))
     else
-        @warnpcfail precompile(triangle_mesh, (Polygon{2, Float32, Point2f0, LineString{2, Float32, Point2f0,
-                                        Base.ReinterpretArray{Line{2, Float32}, 1, Tuple{Point2f0, Point2f0}, TupleView{Tuple{Point2f0, Point2f0}, 2, 1, Vector{Point2f0}}}},
-                                        Vector{LineString{2, Float32, Point2f0, Base.ReinterpretArray{Line{2, Float32}, 1, Tuple{Point2f0, Point2f0}, TupleView{Tuple{Point2f0, Point2f0}, 2, 1, Vector{Point2f0}}}}}},))
+        @warnpcfail precompile(triangle_mesh, (Polygon{2, Float32, Point2f, LineString{2, Float32, Point2f,
+                                        Base.ReinterpretArray{Line{2, Float32}, 1, Tuple{Point2f, Point2f}, TupleView{Tuple{Point2f, Point2f}, 2, 1, Vector{Point2f}}}},
+                                        Vector{LineString{2, Float32, Point2f, Base.ReinterpretArray{Line{2, Float32}, 1, Tuple{Point2f, Point2f}, TupleView{Tuple{Point2f, Point2f}, 2, 1, Vector{Point2f}}}}}},))
     end
 
-    @warnpcfail precompile(split_intersections, (Vector{Point2f0},))
+    @warnpcfail precompile(split_intersections, (Vector{Point2f},))
 end

src/primitives/rectangles.jl

@@ -147,12 +147,12 @@ function Rect2D(xy::NamedTuple{(:x, :y)}, wh::NamedTuple{(:width, :height)})
 end
 
 function FRect3D(x::Tuple{Tuple{<:Number,<:Number},Tuple{<:Number,<:Number}})
-    return FRect3D(Vec3f0(x[1]..., 0), Vec3f0(x[2]..., 0))
+    return FRect3D(Vec3f(x[1]..., 0), Vec3f(x[2]..., 0))
 end
 
 function FRect3D(x::Tuple{Tuple{<:Number,<:Number,<:Number},
                           Tuple{<:Number,<:Number,<:Number}})
-    return FRect3D(Vec3f0(x[1]...), Vec3f0(x[2]...))
+    return FRect3D(Vec3f(x[1]...), Vec3f(x[2]...))
 end
 
 origin(prim::Rect) = prim.origin

src/primitives/spheres.jl

@@ -48,7 +48,7 @@ function coordinates(s::Circle, nvertices=64)
 end
 
 function texturecoordinates(s::Circle, nvertices=64)
-    return coordinates(Circle(Point2f0(0.5), 0.5f0), nvertices)
+    return coordinates(Circle(Point2f(0.5), 0.5f0), nvertices)
 end
 
 function coordinates(s::Sphere, nvertices=24)

src/viewtypes.jl

@@ -109,7 +109,7 @@ FaceView enables to link one array of points via a face array, to generate one
 abstract array of elements.
 E.g., this becomes possible:
 ```
-x = FaceView(rand(Point3f0, 10), TriangleFace[(1, 2, 3), (2, 4, 5), ...])
+x = FaceView(rand(Point3f, 10), TriangleFace[(1, 2, 3), (2, 4, 5), ...])
 x[1] isa Triangle == true
 x isa AbstractVector{<: Triangle} == true
 # This means we can use it as a mesh:

test/geometrytypes.jl

@@ -2,7 +2,7 @@ using Test, GeometryBasics
 
 @testset "Cylinder" begin
     @testset "constructors" begin
-        o, extr, r = Point2f0(1, 2), Point2f0(3, 4), 5.0f0
+        o, extr, r = Point2f(1, 2), Point2f(3, 4), 5.0f0
         s = Cylinder(o, extr, r)
         @test typeof(s) == Cylinder{2,Float32}
         @test typeof(s) == Cylinder2{Float32}
@@ -13,7 +13,7 @@ using Test, GeometryBasics
         h = norm(o - extr)
         @test isapprox(height(s), h)
         #@test norm(direction(s) - Point{2,Float32}([2,2]./norm([1,2]-[3,4])))<1e-5
-        @test isapprox(direction(s), Point2f0(2, 2) ./ h)
+        @test isapprox(direction(s), Point2f(2, 2) ./ h)
         v1 = rand(Point{3,Float64})
         v2 = rand(Point{3,Float64})
         R = rand()
@@ -30,14 +30,14 @@ using Test, GeometryBasics
 
     @testset "decompose" begin
 
-        o, extr, r = Point2f0(1, 2), Point2f0(3, 4), 5.0f0
+        o, extr, r = Point2f(1, 2), Point2f(3, 4), 5.0f0
         s = Cylinder(o, extr, r)
         positions = Point{3,Float32}[(-0.7677671, 3.767767, 0.0),
                                      (2.767767, 0.23223293, 0.0),
                                      (0.23223293, 4.767767, 0.0),
                                      (3.767767, 1.2322329, 0.0), (1.2322329, 5.767767, 0.0),
                                      (4.767767, 2.232233, 0.0)]
-        @test decompose(Point3f0, Tesselation(s, (2, 3))) ≈ positions
+        @test decompose(Point3f, Tesselation(s, (2, 3))) ≈ positions
 
         FT = TriangleFace{Int}
         faces = FT[(1, 2, 4), (1, 4, 3), (3, 4, 6), (3, 6, 5)]
@@ -77,7 +77,7 @@ using Test, GeometryBasics
         @test m isa GLNormalMesh
 
         muv = uv_mesh(s)
-        @test Rect(Point.(texturecoordinates(muv))) == FRect2D(Vec2f0(0), Vec2f0(1.0))
+        @test Rect(Point.(texturecoordinates(muv))) == FRect2D(Vec2f(0), Vec2f(1.0))
     end
 end
 
@@ -86,7 +86,7 @@ end
     pt_expa = Point{2,Int}[(0, 0), (1, 0), (0, 1), (1, 1)]
     @test decompose(Point{2,Int}, a) == pt_expa
     mesh = normal_mesh(a)
-    @test decompose(Point2f0, mesh) == pt_expa
+    @test decompose(Point2f, mesh) == pt_expa
 
     b = Rect(Vec(1, 1, 1), Vec(1, 1, 1))
     pt_expb = Point{3,Int64}[[1, 1, 1], [1, 1, 2], [1, 2, 2], [1, 2, 1], [1, 1, 1],
@@ -140,7 +140,7 @@ end
 end
 
 @testset "HyperSphere" begin
-    sphere = Sphere{Float32}(Point3f0(0), 1.0f0)
+    sphere = Sphere{Float32}(Point3f(0), 1.0f0)
 
     points = decompose(Point, Tesselation(sphere, 3))
     point_target = Point{3,Float32}[[0.0, 0.0, 1.0], [1.0, 0.0, 6.12323e-17],
@@ -155,12 +155,12 @@ end
     face_target = TriangleFace{Int}[[1, 2, 5], [1, 5, 4], [2, 3, 6], [2, 6, 5], [4, 5, 8],
                                     [4, 8, 7], [5, 6, 9], [5, 9, 8]]
     @test f == face_target
-    circle = Circle(Point2f0(0), 1.0f0)
-    points = decompose(Point2f0, Tesselation(circle, 20))
+    circle = Circle(Point2f(0), 1.0f0)
+    points = decompose(Point2f, Tesselation(circle, 20))
     @test length(points) == 20
     tess_circle = Tesselation(circle, 32)
     mesh = triangle_mesh(tess_circle)
-    @test decompose(Point2f0, mesh) ≈ decompose(Point2f0, tess_circle)
+    @test decompose(Point2f, mesh) ≈ decompose(Point2f, tess_circle)
 end
 
 @testset "Rectangles" begin
@@ -171,8 +171,8 @@ end
     @test (rect - 4) == FRect2D(-4, 3, 20, 3)
     @test (rect - Vec(2, -2)) == FRect2D(-2, 9, 20, 3)
 
-    base = Vec3f0(1, 2, 3)
-    wxyz = Vec3f0(-2, 4, 2)
+    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)
@@ -184,8 +184,8 @@ end
     @test (rect * 4) == FRect2D(0, 7 * 4, 20 * 4, 3 * 4)
     @test (rect * Vec(2, -2)) == FRect2D(0, -7 * 2, 20 * 2, -3 * 2)
 
-    base = Vec3f0(1, 2, 3)
-    wxyz = Vec3f0(-2, 4, 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))