implement Float32 without losing Float64 precision (rebased)

CHANGELOG.md

@@ -6,6 +6,10 @@
 - Remove StableHashTraits in favor of calculating hashes directly with CRC32c [#3667](https://github.com/MakieOrg/Makie.jl/pull/3667).
 
 - **Breaking (sort of)** Added a new `@recipe` variant which allows documenting attributes directly where they are defined and validating that all attributes are known whenever a plot is created. This is not breaking in the sense that the API changes, but user code is likely to break because of misspelled attribute names etc. that have so far gone unnoticed.
+- **Breaking** Streamline `data_limits` and `boundingbox` [#3671](https://github.com/MakieOrg/Makie.jl/pull/3671)
+  - `data_limits` now only considers plot positions, completely ignoring transformations
+  - `boundingbox(::Text)` is deprecated in favor of `text_boundingbox(::Text)`
+  - `boundingbox` now always consider `transform_func` and `model` (except for Text for the time being)
 - **Breaking** Reworked line shaders in GLMakie and WGLMakie [#3558](https://github.com/MakieOrg/Makie.jl/pull/3558)
   - GLMakie: Removed support for per point linewidths
   - GLMakie: Adjusted dots (e.g. with `linestyle = :dot`) to bend across a joint
@@ -17,6 +21,7 @@
   - Both: Adjusted handling of thin lines which may result in different color intensities
 - Fixed an issue with lines being drawn in the wrong direction in 3D (with perspective projection) [#3651](https://github.com/MakieOrg/Makie.jl/pull/3651).
 
+
 ## [0.20.8] - 2024-02-22
 
 - Fixed excessive use of space with HTML image outputs [#3642](https://github.com/MakieOrg/Makie.jl/pull/3642).

CairoMakie/src/CairoMakie.jl

@@ -12,6 +12,7 @@ using Makie: to_value, to_colormap, extrema_nan
 using Makie.Observables
 using Makie: spaces, is_data_space, is_pixel_space, is_relative_space, is_clip_space
 using Makie: numbers_to_colors
+using Makie: Mat3f, Mat4f, Mat3d, Mat4d
 
 # re-export Makie, including deprecated names
 for name in names(Makie, all=true)

CairoMakie/src/primitives.jl

@@ -33,8 +33,9 @@ function draw_atomic(scene::Scene, screen::Screen, @nospecialize(primitive::Unio
         # Standard transform from input space to clip space
         points = Makie.apply_transform(Makie.transform_func(primitive), positions, space)
         res = scene.camera.resolution[]
-        transform = Makie.space_to_clip(scene.camera, space) * model
-        clip_points = map(p -> transform * to_ndim(Vec4f, to_ndim(Vec3f, p, 0f0), 1f0), points)
+        f32convert = Makie.f32_convert_matrix(scene.float32convert, space)
+        transform = Makie.space_to_clip(scene.camera, space) * model * f32convert
+        clip_points = map(p -> transform * to_ndim(Vec4d, to_ndim(Vec3d, p, 0), 1), points)
 
         # yflip and clip -> screen/pixel coords
         function clip2screen(res, p)
@@ -374,7 +375,7 @@ function draw_atomic(scene::Scene, screen::Screen, @nospecialize(primitive::Scat
     model = primitive.model[]
     positions = primitive[1][]
     isempty(positions) && return
-    size_model = transform_marker ? model : Mat4f(I)
+    size_model = transform_marker ? model : Mat4d(I)
 
     font = to_font(to_value(get(primitive, :font, Makie.defaultfont())))
 
@@ -390,6 +391,9 @@ function draw_atomic(scene::Scene, screen::Screen, @nospecialize(primitive::Scat
 end
 
 function draw_atomic_scatter(scene, ctx, transfunc, colors, markersize, strokecolor, strokewidth, marker, marker_offset, rotations, model, positions, size_model, font, markerspace, space)
+    # TODO Optimization:
+    # avoid calling project functions per element as they recalculate the
+    # combined projection matrix for each element like this
     broadcast_foreach(positions, colors, markersize, strokecolor,
             strokewidth, marker, marker_offset, remove_billboard(rotations)) do point, col,
             markersize, strokecolor, strokewidth, m, mo, rotation
@@ -630,16 +634,20 @@ function draw_glyph_collection(
     strokecolors = glyph_collection.strokecolors
 
     model = _deref(_model)
-    model33 = transform_marker ? model[Vec(1, 2, 3), Vec(1, 2, 3)] : Mat3f(I)
+    model33 = transform_marker ? model[Vec(1, 2, 3), Vec(1, 2, 3)] : Mat3d(I)
     id = Mat4f(I)
 
     glyph_pos = let
+        # TODO: f32convert may run into issues here if markerspace is :data or
+        #       :transformed (repeated application in glyphpos etc)
         transform_func = transformation.transform_func[]
         p = Makie.apply_transform(transform_func, position, space)
 
         Makie.clip_to_space(scene.camera, markerspace) *
         Makie.space_to_clip(scene.camera, space) *
-        model * to_ndim(Point4f, to_ndim(Point3f, p, 0), 1)
+        Makie.f32_convert_matrix(scene.float32convert, space) *
+        model *
+        to_ndim(Point4d, to_ndim(Point3d, p, 0), 1)
     end
 
     Cairo.save(ctx)
@@ -674,8 +682,8 @@ function draw_glyph_collection(
         # origin. The resulting vectors give the directions in which the character
         # needs to be stretched in order to match the 3D projection
 
-        xvec = rotation * (scale3[1] * Point3f(1, 0, 0))
-        yvec = rotation * (scale3[2] * Point3f(0, -1, 0))
+        xvec = rotation * (scale3[1] * Point3d(1, 0, 0))
+        yvec = rotation * (scale3[2] * Point3d(0, -1, 0))
 
         glyphpos = _project_position(scene, markerspace, gp3, id, true)
         xproj = _project_position(scene, markerspace, gp3 + model33 * xvec, id, true)
@@ -767,7 +775,7 @@ function draw_atomic(scene::Scene, screen::Screen, @nospecialize(primitive::Unio
     else
         ys = regularly_spaced_array_to_range(ys)
     end
-    model = primitive.model[]::Mat4f
+    model = primitive.model[]::Mat4d
     interpolate = to_value(primitive.interpolate)
 
     # Debug attribute we can set to disable fastpath
@@ -804,8 +812,8 @@ function draw_atomic(scene::Scene, screen::Screen, @nospecialize(primitive::Unio
     # find projected image corners
     # this already takes care of flipping the image to correct cairo orientation
     space = to_value(get(primitive, :space, :data))
-    xy = project_position(primitive, space, Point2f(first.(imsize)), model)
-    xymax = project_position(primitive, space, Point2f(last.(imsize)), model)
+    xy = project_position(primitive, space, Point2(first.(imsize)), model)
+    xymax = project_position(primitive, space, Point2(last.(imsize)), model)
     w, h = xymax .- xy
 
     can_use_fast_path = !(is_vector && !interpolate) && regular_grid && identity_transform &&
@@ -835,7 +843,7 @@ function draw_atomic(scene::Scene, screen::Screen, @nospecialize(primitive::Unio
         # find projected image corners
         # this already takes care of flipping the image to correct cairo orientation
         space = to_value(get(primitive, :space, :data))
-        xys = project_position.(scene, (Makie.transform_func(primitive),), space, [Point2f(x, y) for x in xs, y in ys], (model,))
+        xys = project_position(scene, Makie.transform_func(primitive), space, [Point2(x, y) for x in xs, y in ys], model)
         colors = to_color(primitive.calculated_colors[])
 
         # Note: xs and ys should have size ni+1, nj+1
@@ -901,27 +909,26 @@ function draw_atomic(scene::Scene, screen::Screen, @nospecialize(primitive::Maki
 end
 
 function draw_mesh2D(scene, screen, @nospecialize(plot), @nospecialize(mesh))
-    vs =  decompose(Point2f, mesh)::Vector{Point2f}
+    # TODO: decompose to type used in mesh
+    space = to_value(get(plot, :space, :data))::Symbol
+    transform_func = Makie.transform_func(plot)
+    model = plot.model[]::Mat4d
+    vs = project_position(scene, transform_func, space, decompose(Point2d, mesh), model)
     fs = decompose(GLTriangleFace, mesh)::Vector{GLTriangleFace}
     uv = decompose_uv(mesh)::Union{Nothing, Vector{Vec2f}}
-    model = plot.model[]::Mat4f
     color = hasproperty(mesh, :color) ? to_color(mesh.color) : plot.calculated_colors[]
     cols = per_face_colors(color, nothing, fs, nothing, uv)
-    space = to_value(get(plot, :space, :data))::Symbol
-    transform_func = Makie.transform_func(plot)
-    return draw_mesh2D(scene, screen, cols, space, transform_func, vs, fs, model)
+    return draw_mesh2D(screen, cols, vs, fs)
 end
 
-function draw_mesh2D(scene, screen, per_face_cols, space::Symbol, transform_func,
-        vs::Vector{Point2f}, fs::Vector{GLTriangleFace}, model::Mat4f)
+function draw_mesh2D(screen, per_face_cols, vs::Vector{<: Point2}, fs::Vector{GLTriangleFace})
 
     ctx = screen.context
     # Priorize colors of the mesh if present
     # This is a hack, which needs cleaning up in the Mesh plot type!
 
     for (f, (c1, c2, c3)) in zip(fs, per_face_cols)
-
-        t1, t2, t3 =  project_position.(scene, (transform_func,), space, vs[f], (model,)) #triangle points
+        t1, t2, t3 =  vs[f] #triangle points
 
         # don't draw any mesh faces with NaN components.
         if isnan(t1) || isnan(t2) || isnan(t3)
@@ -971,7 +978,7 @@ function draw_mesh3D(scene, screen, attributes, mesh; pos = Vec4f(0), scale = 1f
 
     per_face_col = per_face_colors(color, matcap, meshfaces, meshnormals, meshuvs)
 
-    model = attributes.model[]::Mat4f
+    model = attributes.model[]::Mat4d
     space = to_value(get(attributes, :space, :data))::Symbol
     func = Makie.transform_func(attributes)
 
@@ -1003,14 +1010,15 @@ function draw_mesh3D(
     i = Vec(1, 2, 3)
     normalmatrix = transpose(inv(model[i, i]))
 
-    local_model = rotation * Makie.scalematrix(Vec3f(scale))
+    local_model = rotation * Makie.scalematrix(Vec3d(scale))
     # pass transform_func as argument to function, so that we get a function barrier
     # and have `transform_func` be fully typed inside closure
+    model_f32 = model * Makie.f32_convert_matrix(scene.float32convert, space)
     vs = broadcast(meshpoints, (transform_func,)) do v, f
         # Should v get a nan2zero?
         v = Makie.apply_transform(f, v, space)
-        p4d = to_ndim(Vec4f, to_ndim(Vec3f, v, 0f0), 1f0)
-        model * (local_model * p4d .+ to_ndim(Vec4f, pos, 0f0))
+        p4d = to_ndim(Vec4d, to_ndim(Vec3d, v, 0), 1)
+        return to_ndim(Vec4f, model_f32 * (local_model * p4d .+ to_ndim(Vec4f, pos, 0f0)), NaN32)
     end
 
     ns = map(n -> normalize(normalmatrix * n), meshnormals)
@@ -1167,9 +1175,9 @@ function draw_atomic(scene::Scene, screen::Screen, @nospecialize(primitive::Maki
     view = scene.camera.view[]
 
     zorder = sortperm(pos, by = p -> begin
-        p4d = to_ndim(Vec4f, to_ndim(Vec3f, p, 0f0), 1f0)
-        cam_pos = view * model * p4d
-        cam_pos[3] / cam_pos[4]
+        p4d = to_ndim(Vec4d, to_ndim(Vec3d, p, 0), 1)
+        cam_pos = (view * model)[Vec(3,4), Vec(1,2,3,4)] * p4d
+        cam_pos[1] / cam_pos[2]
     end, rev=false)
 
     color = to_color(primitive.calculated_colors[])

CairoMakie/src/utils.jl

@@ -8,10 +8,35 @@ function project_position(scene::Scene, transform_func::T, space, point, model::
     _project_position(scene, space, point, model, yflip)
 end
 
-function _project_position(scene::Scene, space, point, model, yflip::Bool)
+# much faster than dot-ing `project_position` because it skips all the repeated mat * mat
+function _project_position(scene::Scene, space, ps::AbstractArray{<: VecTypes{N, T1}}, model, yflip::Bool) where {N, T1}
+    transform = let
+        f32convert = Makie.f32_convert_matrix(scene.float32convert, space)
+        M = Makie.space_to_clip(scene.camera, space) * model * f32convert
+        res = scene.camera.resolution[]
+        px_scale  = Vec3d(0.5 * res[1], 0.5 * (yflip ? -res[2] : res[2]), 1)
+        px_offset = Vec3d(0.5 * res[1], 0.5 * res[2], 0)
+        M = Makie.transformationmatrix(px_offset, px_scale) * M
+        M[Vec(1,2,4), Vec(1,2,3,4)] # skip z, i.e. calculate (x, y, w)
+    end
+
+    output = similar(ps, Point2f)
+
+    @inbounds for i in eachindex(ps)
+        p4d = to_ndim(Point4d, to_ndim(Point3d, ps[i], 0), 1)
+        px_pos = transform * p4d
+        output[i] = px_pos[Vec(1, 2)] / px_pos[3]
+    end
+
+    return output
+end
+
+function _project_position(scene::Scene, space, point::VecTypes{N, T1}, model, yflip::Bool) where {N, T1 <: Real}
+    T = promote_type(Float32, T1) # always Float, at least Float32
     res = scene.camera.resolution[]
-    p4d = to_ndim(Vec4f, to_ndim(Vec3f, point, 0f0), 1f0)
-    clip = Makie.space_to_clip(scene.camera, space) * model * p4d
+    p4d = to_ndim(Vec4{T}, to_ndim(Vec3{T}, point, 0), 1)
+    f32convert = Makie.f32_convert_matrix(scene.float32convert, space)
+    clip = Makie.space_to_clip(scene.camera, space) * model * f32convert * p4d
     @inbounds begin
         # between -1 and 1
         p = (clip ./ clip[4])[Vec(1, 2)]
@@ -29,12 +54,12 @@ function project_position(@nospecialize(scenelike), space, point, model, yflip::
     project_position(scene, Makie.transform_func(scenelike), space, point, model, yflip)
 end
 
-function project_scale(scene::Scene, space, s::Number, model = Mat4f(I))
-    project_scale(scene, space, Vec2f(s), model)
+function project_scale(scene::Scene, space, s::Number, model = Mat4d(I))
+    project_scale(scene, space, Vec2d(s), model)
 end
 
-function project_scale(scene::Scene, space, s, model = Mat4f(I))
-    p4d = model * to_ndim(Vec4f, s, 0f0)
+function project_scale(scene::Scene, space, s, model = Mat4d(I))
+    p4d = model * to_ndim(Vec4d, s, 0)
     if is_data_space(space)
         @inbounds p = (scene.camera.projectionview[] * p4d)[Vec(1, 2)]
         return p .* scene.camera.resolution[] .* 0.5