cleanup Wireframe and Mesh

gridap · Aug 23, 2020 · 3b09f46 · 3b09f46
1 parent 7ad10e2
commit 3b09f46
Show file tree

Hide file tree

Showing 2 changed files with 63 additions and 106 deletions.
diff --git a/Project.toml b/Project.toml
@@ -5,6 +5,7 @@ version = "0.1.0"
 
 [deps]
 AbstractPlotting = "537997a7-5e4e-5d89-9595-2241ea00577e"
+ArgCheck = "dce04be8-c92d-5529-be00-80e4d2c0e197"
 ConstructionBase = "187b0558-2788-49d3-abe0-74a17ed4e7c9"
 GeometryBasics = "5c1252a2-5f33-56bf-86c9-59e7332b4326"
 Gridap = "56d4f2e9-7ea1-5844-9cf6-b9c51ca7ce8e"

diff --git a/src/GridapMakie.jl b/src/GridapMakie.jl
@@ -120,16 +120,74 @@ function AP.convert_arguments(P::Type{<:AP.AbstractPlot}, space::CatchallSpace)
 end
 
 function AP.convert_arguments(P::AP.PointBased, visdata::VisualizationData)
-    _convert_arguments_for_lines(P, visdata, get_nodalvalues(visdata))
+    return (space_or_graph_points(visdata),)
 end
 function AP.convert_arguments(P::Type{<:Arrows}, visdata::VisualizationData)
     _convert_arguments_for_arrows(P, visdata, get_nodalvalues(visdata))
 end
+function AP.convert_arguments(P::Type{<:Wireframe}, visdata::VisualizationData)
+    (gbmesh(visdata),)
+end
 function AP.convert_arguments(P::Type{<:Mesh}, visdata::VisualizationData)
-    if ismodel(visdata) #visdata contains only a triangulation
-        _convert_arguments_for_mesh(P, visdata)
+    (gbmesh(visdata),)
+end
+
+################################################################################
+##### GeometryBasics
+################################################################################
+
+function gbmesh(visdata)
+    faces = get_faces(visdata)
+    pts = space_or_graph_points(visdata)
+    return GB.Mesh(GB.connect(pts, faces))
+end
+
+single(x) = x
+function single(x::Union{VectorValue, TensorValue})
+    @assert length(x) == 1
+    x[1]
+end
+
+function space_or_graph_points(visdata)
+    if dispatchinfo(visdata) isa IsModel
+        spacepoints(visdata)
     else
-        _convert_arguments_for_mesh(P, visdata, get_nodalvalues(visdata))
+        graphpoints(visdata)
+    end
+end
+
+function spacepoints(visdata)
+    N = dispatchinfo(visdata).spacedim
+    Point = GB.Point{N, Float32}
+    _spacepoints(Point, get_node_coordinates(visdata.grid))
+end
+@noinline function _spacepoints(::Type{Point}, node_coords) where {Point}
+    map(node_coords) do xyz
+        Point(Tuple(xyz)...)
+    end
+end
+function graphpoints(visdata)
+    N = dispatchinfo(visdata).spacedim
+    Point = GB.Point{N+1, Float32}
+    _graphpoints(Point, get_node_coordinates(visdata.grid), get_nodalvalues(visdata))
+end
+
+@noinline function _graphpoints(::Type{Point}, node_coords, node_vals) where {Point}
+    map(node_coords, node_vals) do xy, z
+        Point(Tuple(xy)..., single(z))
+    end
+end
+
+function get_faces(visdata)
+    cells = get_cell_nodes(visdata.grid)
+    cell = first(cells)::AbstractVector{<:Integer}
+    N = length(cell)
+    _get_faces(GB.NgonFace{N, UInt32}, cells)
+end
+
+@noinline function _get_faces(::Type{FaceType}, cells) where {FaceType}
+    map(cells) do cell
+        FaceType(cell)
     end
 end
 
@@ -154,17 +212,6 @@ end
 ##### Arrows
 ################################################################################
 
-function to_makie_matrix(T, itr)
-    x1 = first(itr)
-    out = Matrix{T}(undef, length(itr), length(x1))
-    for i in 1:length(itr)
-        for j in 1:length(x1)
-            out[i, j] = itr[i][j]
-        end
-    end
-    out
-end
-
 _PV2 = Union{GB.Point2f0, GB.Vec2f0}
 _PV3 = Union{GB.Point3f0, GB.Vec3f0}
 _trailing_zeros(P, xyz::Tuple) = __trailing_zeros_splat(P, xyz...)
@@ -194,97 +241,6 @@ function _convert_arguments_for_arrows(P, visdata, nodalvalues)
     return (pts, vecs)
 end
 
-################################################################################
-##### PointBased (covers Lines, Scatter etc.)
-################################################################################
-single(x) = x
-function single(x::Union{VectorValue, TensorValue})
-    @assert length(x) == 1
-    x[1]
-end
-
-function _convert_arguments_for_lines(P, visdata, nodalvalues)
-    x = map(pt -> pt[1], get_node_coordinates(visdata.grid))
-    y = single.(nodalvalues)
-    pts = map(get_node_coordinates(visdata.grid), nodalvalues) do ptx, y
-        GB.Point2f0(ptx[1], single(y))
-    end
-    (pts,)
-end
-
-################################################################################
-##### Mesh
-################################################################################
-function _convert_arguments_for_mesh(P, visdata)
-    @assert isempty(visdata.nodaldata)
-    makie_coords = to_makie_matrix(Float64, get_node_coordinates(visdata.grid))
-    makie_conn = to_makie_matrix(Int, get_cell_nodes(visdata.grid))
-    convert_arguments(P, makie_coords, makie_conn) # color
-end
-
-function _convert_arguments_for_mesh(P, visdata, nodalvalues)
-    makie_coords_spatial = to_makie_matrix(Float64, get_node_coordinates(visdata.grid))
-    makie_conn = to_makie_matrix(Int, get_cell_nodes(visdata.grid))
-    makie_coords = hcat(makie_coords_spatial, nodalvalues)
-    convert_arguments(P, makie_coords, makie_conn) # color
-    # mesh!(p, makie_coords, makie_conn, color = nodalvalues, shading = false)
-    # wireframe!(p.plots[end][1], color = (:black, 0.6), linewidth = 3)
-end
-
-################################################################################
-##### Wireframe
-################################################################################
-function AP.plot!(p::Wireframe{<:Tuple{VisualizationData}})
-    visdata = to_value(p[1])::VisualizationData
-    Point = if dispatchinfo(visdata) isa IsModel
-        GB.Point2f0
-    else
-        GB.Point3f0
-    end
-    lines = _convert_arguments_for_linesegments(Point, visdata)
-    linesegments!(p, Attributes(p), lines)
-end
-
-@noinline function _convert_arguments_for_linesegments(
-        ::Type{Point}, visdata
-    ) where {Point <: Union{GB.Point2f0, GB.Point3f0}}
-
-    @argcheck dispatchinfo(visdata) isa Union{IsModel, IsSingleField}
-    @argcheck dispatchinfo(visdata).spacedim == 2
-    function build_point(Point::Type{GB.Point2f0}, index, node_coords, _)
-        x,y = Tuple(node_coords[index])
-        return Point(x,y)
-    end
-    function build_point(Point::Type{GB.Point3f0}, index, node_coords, node_vals)
-        x,y = Tuple(node_coords[index])
-        z = node_vals[index]
-        return Point(x,y, z)
-    end
-    cells = get_cell_nodes(visdata.grid)
-    node_coords = get_node_coordinates(visdata.grid)::AbstractVector{<:VectorValue}
-    node_vals = if Point == GB.Point2f0
-        nothing
-    else
-        get_nodalvalues(visdata)
-    end
-    lines = NTuple{2, Point}[]
-    first(cells)::AbstractVector{<:Integer}
-    # each cell is encoded list of indices of
-    # the vertex points
-    for cell in cells
-        # e.g. cell = [4,5,6] describes a triangle with vertices of pt[5], pt[5], pts[6]
-        for iistart in eachindex(cell)
-            iistop = iistart + 1
-            istart = cell[iistart]
-            istop = get(cell, iistop, first(cell))
-            pt1 = build_point(Point, istart, node_coords, node_vals)
-            pt2 = build_point(Point, istop , node_coords, node_vals)
-            push!(lines, (pt1, pt2))
-        end
-    end
-    return lines
-end
-
 ################################################################################
 ##### Testing
 ################################################################################