diff --git a/.JuliaFormatter.toml b/.JuliaFormatter.toml new file mode 100644 index 0000000..323237b --- /dev/null +++ b/.JuliaFormatter.toml @@ -0,0 +1 @@ +style = "blue" diff --git a/Project.toml b/Project.toml index bddd594..aef2c49 100644 --- a/Project.toml +++ b/Project.toml @@ -7,6 +7,7 @@ version = "0.1.1" Colors = "5ae59095-9a9b-59fe-a467-6f913c188581" GeometryTypes = "4d00f742-c7ba-57c2-abde-4428a4b178cb" IterTools = "c8e1da08-722c-5040-9ed9-7db0dc04731e" +JuliaFormatter = "98e50ef6-434e-11e9-1051-2b60c6c9e899" ResumableFunctions = "c5292f4c-5179-55e1-98c5-05642aab7184" StaticArrays = "90137ffa-7385-5640-81b9-e52037218182" WriteVTK = "64499a7a-5c06-52f2-abe2-ccb03c286192" diff --git a/src/GLMesh.jl b/src/GLMesh.jl index ee12aef..ff1979f 100644 --- a/src/GLMesh.jl +++ b/src/GLMesh.jl @@ -5,19 +5,19 @@ function (scheme::ColouredScheme)(v) 0.0 <= v <= 1.0 || println("Warning: color value must be scaled between 0 and 1.") if 0.0 <= v < 0.25 b = 1.0 - g = v/0.25 + g = v / 0.25 r = 0.0 elseif 0.25 <= v < 0.5 - b = 1.0 - (v - 0.25)/0.25 + b = 1.0 - (v - 0.25) / 0.25 g = 1.0 r = 0.0 elseif 0.5 <= v < 0.75 b = 0.0 g = 1.0 - r = (v - 0.5)/0.25 + r = (v - 0.5) / 0.25 else b = 0.0 - g = 1.0 - (v - 0.75)/0.25 + g = 1.0 - (v - 0.75) / 0.25 r = 1.0 end return r, g, b, scheme.opacity @@ -29,7 +29,14 @@ function (::BlackScheme)(v) return 0.7, 0.7, 0.7, v end -function get_jl_mapped_colors(dataset::T, color_variable_name, component, opacity, color_scheme = BlackScheme(), scale = true) where {T<:AbstractVTKSimpleData} +function get_jl_mapped_colors( + dataset::T, + color_variable_name, + component, + opacity, + color_scheme=BlackScheme(), + scale=true, +) where {T<:AbstractVTKSimpleData} if color_variable_name in keys(dataset.point_data) point_color = true _size = num_of_points(dataset) @@ -54,7 +61,7 @@ function get_jl_mapped_colors(dataset::T, color_variable_name, component, opacit else color_variable = _color_variable end - + if color_variable !== nothing if component == -1 || component == 1 && _var_dim == 1 if _var_dim == 1 @@ -62,17 +69,19 @@ function get_jl_mapped_colors(dataset::T, color_variable_name, component, opacit cmin = minimum(_values) cmax = maximum(_values) else - @views _values = [norm(color_variable[:,i]) for i in 1:_size] + @views _values = [norm(color_variable[:, i]) for i in 1:_size] cmin = minimum(_values) cmax = maximum(_values) end else if 1 <= component <= _var_dim - @views _values = color_variable[component,:] + @views _values = color_variable[component, :] cmin = minimum(_values) cmax = maximum(_values) else - throw("Cannot use component $component of a $color. $color only has $_var_dim components.") + throw( + "Cannot use component $component of a $color. $color only has $_var_dim components.", + ) end end else @@ -80,44 +89,47 @@ function get_jl_mapped_colors(dataset::T, color_variable_name, component, opacit _values = ones(_size) end jl_mapped_colors = Vector{RGBA{Float32}}(undef, _size) - if !(isapprox(cmax, cmin, atol = eps(Float32))) + if !(isapprox(cmax, cmin; atol=eps(Float32))) scaled_values = (_values .- cmin) ./ (cmax - cmin) else scaled_values = (similar(_values) .= clamp(cmin, 0, 1)) end function fill_jl_mapped_colors(i) - jl_mapped_colors[i] = RGBA{Float32}((color_scheme(scaled_values[i]))...) + return jl_mapped_colors[i] = RGBA{Float32}((color_scheme(scaled_values[i]))...) end map(fill_jl_mapped_colors, 1:_size) return jl_mapped_colors, cmin, cmax end function GLMesh(rectilinear::AbstractVTKStructuredData; kwargs...) - GLMesh(VTKUnstructuredData(rectilinear); kwargs...) + return GLMesh(VTKUnstructuredData(rectilinear); kwargs...) end -function GLMesh(dataset::AbstractVTKUnstructuredData; color::String="", component::Int=-1, opacity::Float64=1.0, color_scheme = BlackScheme()) +function GLMesh( + dataset::AbstractVTKUnstructuredData; + color::String="", + component::Int=-1, + opacity::Float64=1.0, + color_scheme=BlackScheme(), +) filter_cells!(dataset, [POINT_CELLS; LINE_CELLS]) tri_cell_data = color in keys(dataset.cell_data) tri_dataset = triangulate(dataset, tri_cell_data, GLTriangle) - tri_dataset = tri_dataset |> remove_unused_vertices |> duplicate_vertices + tri_dataset = duplicate_vertices(remove_unused_vertices(tri_dataset)) if haskey(tri_dataset.cell_data, color) celldata_to_pointdata!(tri_dataset) end - color_vec, cmin, cmax = get_jl_mapped_colors( tri_dataset, - color, - component, - opacity, - color_scheme - ) + color_vec, cmin, cmax = get_jl_mapped_colors( + tri_dataset, color, component, opacity, color_scheme + ) T = eltype(dataset.point_coords) vertices = map(1:num_of_points(tri_dataset)) do i - @views coord = tri_dataset.point_coords[:,i] + @views coord = tri_dataset.point_coords[:, i] if length(coord) == 2 - Point{3, T}(coord..., zero(T)) + Point{3,T}(coord..., zero(T)) else - Point{3, T}(coord...) + Point{3,T}(coord...) end end faces = tri_dataset.cell_connectivity - return GLNormalVertexcolorMesh(vertices=vertices, faces=faces, color=color_vec) + return GLNormalVertexcolorMesh(; vertices=vertices, faces=faces, color=color_vec) end diff --git a/src/VTKDataTypes.jl b/src/VTKDataTypes.jl index f67ff0d..37c4015 100644 --- a/src/VTKDataTypes.jl +++ b/src/VTKDataTypes.jl @@ -19,65 +19,66 @@ include("triangulate.jl") include("GLMesh.jl") #include("surface.jl") -export AbstractVTKData, - AbstractStaticVTKData, - AbstractTimeSeriesVTKData, - AbstractVTKMultiblockData, - AbstractVTKSimpleData, - AbstractVTKUnstructuredData, - AbstractVTKStructuredData, - AbstractVTKRectilinearData, - VTKUnstructuredData, - VTKPolyData, - VTKStructuredData, - VTKRectilinearData, - VTKUniformRectilinearData, - VTKImageData, - VTKMultiblockData, - VTKTimeSeriesData, - VTK_CELL_TYPE, - endof, - same_geometry, - same_ordered_geometry, - same_geometry_shape, - same_data_shape, - coherent, extents, - cell_extents, - dim, - num_of_points, - num_of_cells, - num_of_point_vars, - num_of_cell_vars, - cell_type, - cell_connectivity, - has_var, - var_dim, - is_homogeneous, - filter_cells!, - keep_volume_cells_only!, - keep_face_cells_only!, - get_cell_ids, - get_lowest_index, - get_highest_index, - is_valid_cell, - add_new_cell!, - remove_cell!, - add_point_id_offset!, - append, - num_of_blocks, - insert_new_block!, - remove_block!, - timespan, - num_of_timesteps, - insert_timed_data!, - remove_timed_data!, - is_valid, - simple_block_generator, - increase_resolution!, - triangular, - triangulate, - decompose, - GLMesh, - bb, - pseudo_center +export AbstractVTKData, + AbstractStaticVTKData, + AbstractTimeSeriesVTKData, + AbstractVTKMultiblockData, + AbstractVTKSimpleData, + AbstractVTKUnstructuredData, + AbstractVTKStructuredData, + AbstractVTKRectilinearData, + VTKUnstructuredData, + VTKPolyData, + VTKStructuredData, + VTKRectilinearData, + VTKUniformRectilinearData, + VTKImageData, + VTKMultiblockData, + VTKTimeSeriesData, + VTK_CELL_TYPE, + endof, + same_geometry, + same_ordered_geometry, + same_geometry_shape, + same_data_shape, + coherent, + extents, + cell_extents, + dim, + num_of_points, + num_of_cells, + num_of_point_vars, + num_of_cell_vars, + cell_type, + cell_connectivity, + has_var, + var_dim, + is_homogeneous, + filter_cells!, + keep_volume_cells_only!, + keep_face_cells_only!, + get_cell_ids, + get_lowest_index, + get_highest_index, + is_valid_cell, + add_new_cell!, + remove_cell!, + add_point_id_offset!, + append, + num_of_blocks, + insert_new_block!, + remove_block!, + timespan, + num_of_timesteps, + insert_timed_data!, + remove_timed_data!, + is_valid, + simple_block_generator, + increase_resolution!, + triangular, + triangulate, + decompose, + GLMesh, + bb, + pseudo_center end diff --git a/src/base_utils.jl b/src/base_utils.jl index 602aa80..bf1ad59 100644 --- a/src/base_utils.jl +++ b/src/base_utils.jl @@ -1,21 +1,39 @@ import Base: promote_rule, size, length, getindex, iterate, ==, append!, +, *, / -promote_rule(::Type{<:VTKUniformRectilinearData}, ::Type{<:VTKRectilinearData}) = VTKRectilinearData -promote_rule(::Type{<:VTKUniformRectilinearData}, ::Type{<:VTKStructuredData}) = VTKStructuredData +function promote_rule(::Type{<:VTKUniformRectilinearData}, ::Type{<:VTKRectilinearData}) + return VTKRectilinearData +end +function promote_rule(::Type{<:VTKUniformRectilinearData}, ::Type{<:VTKStructuredData}) + return VTKStructuredData +end promote_rule(::Type{<:VTKRectilinearData}, ::Type{<:VTKStructuredData}) = VTKStructuredData -promote_rule(::Type{<:VTKUniformRectilinearData}, ::Type{<:VTKUnstructuredData}) = VTKUnstructuredData -promote_rule(::Type{<:VTKRectilinearData}, ::Type{<:VTKUnstructuredData}) = VTKUnstructuredData -promote_rule(::Type{<:VTKStructuredData}, ::Type{<:VTKUnstructuredData}) = VTKUnstructuredData -promote_rule(::Type{<:VTKMultiblockData}, ::Type{T}) where {T <: AbstractVTKSimpleData} = VTKMultiblockData +function promote_rule(::Type{<:VTKUniformRectilinearData}, ::Type{<:VTKUnstructuredData}) + return VTKUnstructuredData +end +function promote_rule(::Type{<:VTKRectilinearData}, ::Type{<:VTKUnstructuredData}) + return VTKUnstructuredData +end +function promote_rule(::Type{<:VTKStructuredData}, ::Type{<:VTKUnstructuredData}) + return VTKUnstructuredData +end +function promote_rule( + ::Type{<:VTKMultiblockData}, ::Type{T} +) where {T<:AbstractVTKSimpleData} + return VTKMultiblockData +end promote_rule(::Type{T}, ::Type{T}) where {T<:AbstractVTKData} = T size(dataset::AbstractTimeSeriesVTKData) = (num_of_timesteps(dataset),) size(dataset::AbstractVTKMultiblockData) = (num_of_blocks(dataset),) -length(dataset::Union{AbstractVTKMultiblockData, AbstractTimeSeriesVTKData}) = prod(size(dataset)) +function length(dataset::Union{AbstractVTKMultiblockData,AbstractTimeSeriesVTKData}) + return prod(size(dataset)) +end getindex(dataset::AbstractTimeSeriesVTKData, ind::Integer) = dataset.data[ind] getindex(dataset::AbstractVTKMultiblockData, ind::Integer) = dataset.blocks[ind] -getindex(dataset::AbstractTimeSeriesVTKData, inds::OrdinalRange{Int,Int}) = dataset.data[inds] +function getindex(dataset::AbstractTimeSeriesVTKData, inds::OrdinalRange{Int,Int}) + return dataset.data[inds] +end function getindex(dataset::AbstractTimeSeriesVTKData, t::AbstractFloat) loc = searchsorted(dataset.timemarkers, t) if loc.start == 1 @@ -23,28 +41,33 @@ function getindex(dataset::AbstractTimeSeriesVTKData, t::AbstractFloat) elseif loc.stop == length(dataset) return dataset[end] else - return ((dataset.timemarkers[loc.start] - t) * dataset[loc.stop] + - (t - dataset.timemarkers[loc.stop]) * dataset[loc.start]) / - (dataset.timemarkers[loc.start] - dataset.timemarkers[loc.stop]) + return ( + (dataset.timemarkers[loc.start] - t) * dataset[loc.stop] + + (t - dataset.timemarkers[loc.stop]) * dataset[loc.start] + ) / (dataset.timemarkers[loc.start] - dataset.timemarkers[loc.stop]) end end -getindex(dataset::AbstractVTKMultiblockData, inds::OrdinalRange{Int,Int}) = dataset.blocks[inds] +function getindex(dataset::AbstractVTKMultiblockData, inds::OrdinalRange{Int,Int}) + return dataset.blocks[inds] +end function iterate(dataset::AbstractTimeSeriesVTKData, i=1) i > length(dataset) && return nothing - return dataset.data[i], i+1 + return dataset.data[i], i + 1 end function iterate(dataset::AbstractVTKMultiblockData, i=1) i > length(dataset) && return nothing - return dataset.blocks[i], i+1 + return dataset.blocks[i], i + 1 end function +(a::T, b::T) where {T<:AbstractStaticVTKData} - if !(T <: AbstractVTKMultiblockData) || !(same_ordered_geometry_shape(a,b)) - same_geometry_shape(a,b) || throw("Cannot add two datasets with different geometry structure.") + if !(T <: AbstractVTKMultiblockData) || !(same_ordered_geometry_shape(a, b)) + same_geometry_shape(a, b) || + throw("Cannot add two datasets with different geometry structure.") end if !(T <: AbstractVTKMultiblockData) - same_data_shape(a,b) || throw("Cannot add two datasets with different data variables.") + same_data_shape(a, b) || + throw("Cannot add two datasets with different data variables.") end if T <: AbstractVTKMultiblockData return VTKMultiblockData(ntuple(i -> a[i] + b[i], Val(length(a)))) @@ -75,8 +98,8 @@ function +(a::T, b::T) where {T<:AbstractStaticVTKData} end end -*(b::Real, a::AbstractStaticVTKData) = *(a,b) -function *(a::T, b::Real) where {T <: AbstractStaticVTKData} +*(b::Real, a::AbstractStaticVTKData) = *(a, b) +function *(a::T, b::Real) where {T<:AbstractStaticVTKData} if T <: AbstractVTKMultiblockData return VTKMultiblockData(ntuple(i -> *(a[i], b), Val(length(a)))) elseif T <: AbstractVTKUnstructuredData || T <: AbstractVTKStructuredData @@ -106,7 +129,7 @@ function *(a::T, b::Real) where {T <: AbstractStaticVTKData} end end -function /(a::T, b::Real) where {T <: AbstractStaticVTKData} +function /(a::T, b::Real) where {T<:AbstractStaticVTKData} b != 0 || throw("Cannot divide a dataset by zero.") if T <: AbstractVTKMultiblockData @@ -139,13 +162,17 @@ function /(a::T, b::Real) where {T <: AbstractStaticVTKData} end function ==(a::AbstractVTKStructuredData, b::AbstractVTKStructuredData) - return same_geometry(a,b) && a.point_data == b.point_data && a.cell_data == b.cell_data + return same_geometry(a, b) && a.point_data == b.point_data && a.cell_data == b.cell_data end function ==(a::VTKUniformRectilinearData, b::VTKUniformRectilinearData) - return dim(a) == dim(b) && extents(a) == extents(b) && - num_of_points(a) == num_of_points(b) && num_of_cells(a) == num_of_cells(b) && - a.origin == b.origin && a.spacing == b.spacing && a.point_data == b.point_data && - a.cell_data == b.cell_data + return dim(a) == dim(b) && + extents(a) == extents(b) && + num_of_points(a) == num_of_points(b) && + num_of_cells(a) == num_of_cells(b) && + a.origin == b.origin && + a.spacing == b.spacing && + a.point_data == b.point_data && + a.cell_data == b.cell_data end function ==(a::VTKMultiblockData, b::VTKMultiblockData) return length(a) == length(b) && a ⊆ b && b ⊆ a @@ -154,13 +181,13 @@ function ==(a::AbstractVTKUnstructuredData, b::AbstractVTKUnstructuredData) dim(a) != dim(b) && return false num_of_points(a) != num_of_points(b) && return false num_of_cells(a) != num_of_cells(b) && return false - + _num_of_points = num_of_points(a) #Describing mapping between ith cell in b and jth cell in a b_image_point_inds = zeros(Int, _num_of_points) for i in 1:_num_of_points for j in 1:_num_of_points - @views if b.point_coords[:,i] == a.point_coords[:,j] + @views if b.point_coords[:, i] == a.point_coords[:, j] b_image_point_inds[i] = j break end @@ -176,7 +203,7 @@ function ==(a::AbstractVTKUnstructuredData, b::AbstractVTKUnstructuredData) for i in 1:length(b_cell_connectivity) b_cell_connectivity_mapped[i] = b_image_point_inds[b_cell_connectivity[i]] end - b_cell_connectivity_mapped + return b_cell_connectivity_mapped end #Mapping the ith cell of b and the jth cell of a @@ -185,11 +212,12 @@ function ==(a::AbstractVTKUnstructuredData, b::AbstractVTKUnstructuredData) b_image_cell_inds = zeros(Int, _num_of_cells) for i in 1:_num_of_cells for j in 1:_num_of_cells - if similar_cells( b_cell_connectivity_mapped[i], - cell_type(b,i), - a.cell_connectivity[j], - cell_type(a,j) - ) + if similar_cells( + b_cell_connectivity_mapped[i], + cell_type(b, i), + a.cell_connectivity[j], + cell_type(a, j), + ) b_image_cell_inds[i] = j break end @@ -197,7 +225,7 @@ function ==(a::AbstractVTKUnstructuredData, b::AbstractVTKUnstructuredData) if b_image_cell_inds[i] == 0 return false end - end + end a_keys = keys(a.point_data) b_keys = keys(b.point_data) @@ -221,12 +249,13 @@ function ==(a::AbstractVTKUnstructuredData, b::AbstractVTKUnstructuredData) if _var_dim == 1 for i in 1:_num_of_points b.point_data[v][i] != a.point_data[v][b_image_point_inds[i]] && return false - end + end else @views for i in 1:_num_of_points - b.point_data[v][:,i] != a.point_data[v][:,b_image_point_inds[i]] && return false + b.point_data[v][:, i] != a.point_data[v][:, b_image_point_inds[i]] && + return false end - end + end end for v in keys(a.cell_data) @@ -237,7 +266,8 @@ function ==(a::AbstractVTKUnstructuredData, b::AbstractVTKUnstructuredData) end else @views for i in 1:_num_of_cells - b.cell_data[v][:,i] == a.cell_data[v][:,b_image_cell_inds[i]] || return false + b.cell_data[v][:, i] == a.cell_data[v][:, b_image_cell_inds[i]] || + return false end end end @@ -250,11 +280,11 @@ function ==(a::AbstractVTKUnstructuredData, b::AbstractVTKUnstructuredData) dim(a) != dim(b) && return false num_of_points(a) != num_of_points(b) && return false num_of_cells(a) != num_of_cells(b) && return false - + _num_of_points = num_of_points(a) _num_of_cells = num_of_cells(a) #Describing mapping between ith cell in b and jth cell in a - + a_keys = keys(a.point_data) b_keys = keys(b.point_data) length(a_keys) != length(b_keys) && return false @@ -350,18 +380,25 @@ function append!(datasets::AbstractVTKUnstructuredData...) cell_offset = num_of_cells(dataset1) dataset1.point_coords = [dataset1.point_coords datasets[i].point_coords] dataset1.cell_types = [dataset1.cell_types; datasets[i].cell_types] - dataset1.cell_connectivity = [dataset1.cell_connectivity; datasets[i].cell_connectivity] + dataset1.cell_connectivity = [ + dataset1.cell_connectivity + datasets[i].cell_connectivity + ] for j in (cell_offset + 1):length(dataset1.cell_connectivity) dataset1.cell_connectivity[j] .+= point_offset end - + for m in keys(dataset1.point_data) _var_dim = var_dim(dataset1, m, "Point") if in(m, keys(datasets[i].point_data)) if _var_dim == 1 - dataset1.point_data[m] = [dataset1.point_data[m]; datasets[i].point_data[m]] + dataset1.point_data[m] = [ + dataset1.point_data[m] + datasets[i].point_data[m] + ] else - dataset1.point_data[m] = [dataset1.point_data[m] datasets[i].point_data[m]] + dataset1.point_data[m] = + [dataset1.point_data[m] datasets[i].point_data[m]] end end end @@ -370,7 +407,10 @@ function append!(datasets::AbstractVTKUnstructuredData...) _var_dim = var_dim(dataset1, m, "Cell") if in(m, keys(datasets[i].cell_data)) if _var_dim == 1 - dataset1.cell_data[m] = [dataset1.cell_data[m]; datasets[i].cell_data[m]] + dataset1.cell_data[m] = [ + dataset1.cell_data[m] + datasets[i].cell_data[m] + ] else dataset1.cell_data[m] = [dataset1.cell_data[m] datasets[i].cell_data[m]] end diff --git a/src/behaviour_utils.jl b/src/behaviour_utils.jl index 5213330..5f076fe 100644 --- a/src/behaviour_utils.jl +++ b/src/behaviour_utils.jl @@ -1,4 +1,6 @@ -function filter_cells!(dataset::AbstractVTKUnstructuredData, cell_types_to_remove::Vector{Int}) +function filter_cells!( + dataset::AbstractVTKUnstructuredData, cell_types_to_remove::Vector{Int} +) inds = findall(i -> i in cell_types_to_remove, dataset.cell_types) deleteat!(dataset.cell_types, inds) deleteat!(dataset.cell_connectivity, inds) @@ -7,7 +9,9 @@ function filter_cells!(dataset::AbstractVTKUnstructuredData, cell_types_to_remov if _var_dim == 1 deleteat!(dataset.cell_data[m], inds) else - dataset.cell_data[m] = dataset.cell_data[m][:,setdiff(1:num_of_cells(dataset), inds)] + dataset.cell_data[m] = dataset.cell_data[m][ + :, setdiff(1:num_of_cells(dataset), inds) + ] end end return dataset @@ -19,20 +23,30 @@ end function keep_face_cells_only!(dataset::VTKPolyData) return filter_cells!(dataset, [POINT_CELLS; LINE_CELLS]) end -function add_new_cell!( dataset::AbstractVTKUnstructuredData, - _cell_type::Int, - _cell_connectivity, - _filter::Bool = true - ) +function add_new_cell!( + dataset::AbstractVTKUnstructuredData, + _cell_type::Int, + _cell_connectivity, + _filter::Bool=true, +) TData = typeof(dataset) begin - out = true - for i in 1:length(dataset.cell_connectivity) - (out = !similar_cells(dataset.cell_connectivity[i], cell_type(dataset, i), - _cell_connectivity, _cell_type)) || break - end - out - end || _filter && (return num_of_cells(dataset)) || throw("$(TData): Repeat cells are not allowed.") + out = true + for i in 1:length(dataset.cell_connectivity) + ( + out = + !similar_cells( + dataset.cell_connectivity[i], + cell_type(dataset, i), + _cell_connectivity, + _cell_type, + ) + ) || break + end + out + end || + _filter && (return num_of_cells(dataset)) || + throw("$(TData): Repeat cells are not allowed.") push!(dataset.cell_connectivity, _cell_connectivity) push!(dataset.cell_types, _cell_type) @@ -41,7 +55,8 @@ function add_new_cell!( dataset::AbstractVTKUnstructuredData, if _var_dim == 1 dataset.cell_data[m] = [dataset.cell_data[m]; [0]] else - dataset.cell_data[m] = [dataset.cell_data[m] zeros(size(dataset.cell_data[m], 1))] + dataset.cell_data[m] = + [dataset.cell_data[m] zeros(size(dataset.cell_data[m], 1))] end end return num_of_cells(dataset) @@ -53,11 +68,15 @@ function remove_cell!(dataset::AbstractVTKUnstructuredData, cell_ind::Int) for m in keys(dataset.cell_data) _var_dim = var_dim(dataset, m, "Cell") if _var_dim == 1 - dataset.cell_data[m] = vcat(dataset.cell_data[m][1:cell_ind-1], - dataset.cell_data[m][cell_ind+1:end]) + dataset.cell_data[m] = vcat( + dataset.cell_data[m][1:(cell_ind - 1)], + dataset.cell_data[m][(cell_ind + 1):end], + ) else - dataset.cell_data[m] = hcat(dataset.cell_data[m][:, 1:cell_ind-1], - dataset.cell_data[m][:, cell_ind+1:end]) + dataset.cell_data[m] = hcat( + dataset.cell_data[m][:, 1:(cell_ind - 1)], + dataset.cell_data[m][:, (cell_ind + 1):end], + ) end end return num_of_cells(dataset) @@ -83,10 +102,9 @@ remove_block!(dataset::AbstractVTKMultiblockData, ind::Int) = deleteat!(dataset. function remove_block!(dataset::AbstractVTKMultiblockData, block::AbstractVTKMultiblockData) return deleteat!(dataset.blocks, findin(dataset.blocks, block)) end -function insert_timed_data!(dataset::VTKTimeSeriesData{TTime, TData}, - time::TTime, - data::TData - ) where {TTime<:Real, TData<:AbstractStaticVTKData} +function insert_timed_data!( + dataset::VTKTimeSeriesData{TTime,TData}, time::TTime, data::TData +) where {TTime<:Real,TData<:AbstractStaticVTKData} loc = searchsorted(dataset.timemarkers, time) if loc.start == length(dataset) + 1 && loc.stop == length(dataset) push!(dataset.timemarkers, time) @@ -100,13 +118,13 @@ function insert_timed_data!(dataset::VTKTimeSeriesData{TTime, TData}, end end -function remove_timed_data!(dataset::VTKTimeSeriesData{TTime, TData}, - _time::TTime - ) where {TTime<:Real, TData<:AbstractStaticVTKData} +function remove_timed_data!( + dataset::VTKTimeSeriesData{TTime,TData}, _time::TTime +) where {TTime<:Real,TData<:AbstractStaticVTKData} ind = findin(dataset.timemarkers, _time) if typeof(ind) == Int deleteat!(dataset.timemarkers, ind) - deleteat!(dataset.data, ind) + deleteat!(dataset.data, ind) else throw("No data at time $_time.") end @@ -122,14 +140,18 @@ function remove_timed_data!(dataset::VTKTimeSeriesData, ind::Int) end function increase_resolution!(dataset::VTKTimeSeriesData, resolution::Int) - _times = deepcopy(collect(zip(dataset.timemarkers[1:end-1], dataset.timemarkers[2:end]))) + _times = deepcopy( + collect(zip(dataset.timemarkers[1:(end - 1)], dataset.timemarkers[2:end])) + ) for (t1, t2) in _times - _step = (t2-t1)/resolution - for j in 1:resolution-1 - VTKDataTypes.insert_timed_data!(dataset, Float64(t1+j*_step), dataset[t1+j*_step]) + _step = (t2 - t1) / resolution + for j in 1:(resolution - 1) + VTKDataTypes.insert_timed_data!( + dataset, Float64(t1 + j * _step), dataset[t1 + j * _step] + ) end end - return + return nothing end @resumable function simple_block_generator(multiblock::VTKMultiblockData) @@ -146,10 +168,10 @@ end function dim3!(a::AbstractVTKUnstructuredData) if dim(a) == 3 - return + return nothing elseif dim(a) == 2 - a.point_coords = [a.point_coords; zeros(1,num_of_points(a))] - return + a.point_coords = [a.point_coords; zeros(1, num_of_points(a))] + return nothing else throw("Invalid dimension.") end @@ -157,7 +179,7 @@ end function dim3!(a::VTKUniformRectilinearData) if dim(a) == 3 - return + return nothing elseif dim(a) == 2 a.origin = [a.origin; 0] a.spacing = [a.spacing; 0] @@ -168,8 +190,8 @@ function dim3!(a::VTKUniformRectilinearData) for m in keys(a.cell_data) a.cell_data[m] = reshape(a.cell_data[m], (size(a.cell_data[m])..., 1)) end - - return + + return nothing else throw("Invalid dimension.") end @@ -177,7 +199,7 @@ end function dim3!(a::VTKRectilinearData) if dim(a) == 3 - return + return nothing elseif dim(a) == 2 a.point_coords = [a.point_coords; [0]] for m in keys(a.point_data) @@ -186,8 +208,8 @@ function dim3!(a::VTKRectilinearData) for m in keys(a.cell_data) a.cell_data[m] = reshape(a.cell_data[m], (size(a.cell_data[m])..., 1)) end - - return + + return nothing else throw("Invalid dimension.") end @@ -195,17 +217,19 @@ end function dim3!(a::VTKStructuredData) if dim(a) == 3 - return + return nothing elseif dim(a) == 2 - a.point_coords = reshape(cat(1, a.point_coords, zeros(1,extents(a)...)), (3, extents(a), 1)) + a.point_coords = reshape( + cat(1, a.point_coords, zeros(1, extents(a)...)), (3, extents(a), 1) + ) for m in keys(a.point_data) a.point_data[m] = reshape(a.point_data[m], (size(a.point_data[m])..., 1)) end for m in keys(a.cell_data) a.cell_data[m] = reshape(a.cell_data[m], (size(a.cell_data[m])..., 1)) end - - return + + return nothing else throw("Invalid dimension.") end @@ -213,12 +237,12 @@ end function dim3!(a::VTKMultiblockData) if dim(a) == 3 - return + return nothing elseif dim(a) == 2 for block in simple_block_generator(a) dim3!(block) end - return + return nothing else throw("Invalid dimension.") end @@ -226,12 +250,12 @@ end function dim3!(a::VTKTimeSeriesData) if dim(a) == 3 - return + return nothing elseif dim(a) == 2 for timedblock in a dim3!(timedblock) end - return + return nothing else throw("Invalid dimension.") end @@ -258,7 +282,7 @@ function celldata_to_pointdata!(dataset::AbstractVTKUnstructuredData) if _var_dim == 1 point_data[m][j] += dataset.cell_data[m][i] else - @views point_data[m][:,j] += dataset.cell_data[m][:,i] + @views point_data[m][:, j] += dataset.cell_data[m][:, i] end end end @@ -273,5 +297,5 @@ function celldata_to_pointdata!(dataset::AbstractVTKUnstructuredData) end empty!(dataset.cell_data) - return + return nothing end diff --git a/src/comparison_utils.jl b/src/comparison_utils.jl index 00e6282..9f339ec 100644 --- a/src/comparison_utils.jl +++ b/src/comparison_utils.jl @@ -7,7 +7,7 @@ function same_geometry(a::AbstractVTKUnstructuredData, b::AbstractVTKUnstructure b_image_point_inds = zeros(Int, _num_of_points) for i in 1:_num_of_points for j in 1:_num_of_points - @views if b.point_coords[:,i] == a.point_coords[:,j] + @views if b.point_coords[:, i] == a.point_coords[:, j] b_image_point_inds[i] = j break end @@ -22,7 +22,7 @@ function same_geometry(a::AbstractVTKUnstructuredData, b::AbstractVTKUnstructure for i in 1:length(b_cell_connectivity) b_cell_connectivity_mapped[i] = b_image_point_inds[b_cell_connectivity[i]] end - b_cell_connectivity_mapped + return b_cell_connectivity_mapped end _num_of_cells = num_of_cells(a) @@ -30,7 +30,12 @@ function same_geometry(a::AbstractVTKUnstructuredData, b::AbstractVTKUnstructure b_image_cell_inds = zeros(Int, _num_of_cells) for i in 1:_num_of_cells for j in 1:_num_of_cells - if similar_cells(b_cell_connectivity_mapped[i], cell_type(b,i), a.cell_connectivity[j], cell_type(a,j)) + if similar_cells( + b_cell_connectivity_mapped[i], + cell_type(b, i), + a.cell_connectivity[j], + cell_type(a, j), + ) b_image_cell_inds[i] = j break end @@ -38,7 +43,7 @@ function same_geometry(a::AbstractVTKUnstructuredData, b::AbstractVTKUnstructure if b_image_cell_inds[i] == 0 return false end - end + end return true end function same_geometry(a::VTKStructuredData, b::VTKStructuredData) @@ -51,28 +56,39 @@ function same_geometry(a::VTKUniformRectilinearData, b::VTKUniformRectilinearDat return a.spacing == b.spacing && extents(a) == extents(b) end function same_geometry(a::AbstractStaticVTKData, b::AbstractStaticVTKData) - return same_geometry(promote(a,b)...) + return same_geometry(promote(a, b)...) end -function same_ordered_geometry(a::AbstractVTKUnstructuredData, b::AbstractVTKUnstructuredData) +function same_ordered_geometry( + a::AbstractVTKUnstructuredData, b::AbstractVTKUnstructuredData +) dim(a) != dim(b) && return false num_of_points(a) != num_of_points(b) && return false num_of_cells(a) != num_of_cells(b) && return false - + _num_of_points = num_of_points(a) @views for i in 1:_num_of_points - b.point_coords[:,i] == a.point_coords[:,i] || return false + b.point_coords[:, i] == a.point_coords[:, i] || return false end _num_of_cells = num_of_cells(a) for i in 1:_num_of_cells - similar_cells(a.cell_connectivity[i], cell_type(a,i), b.cell_connectivity[i], cell_type(b,i)) || return false + similar_cells( + a.cell_connectivity[i], cell_type(a, i), b.cell_connectivity[i], cell_type(b, i) + ) || return false end return true end function same_ordered_geometry(a::AbstractVTKMultiblockData, b::AbstractVTKMultiblockData) length(a) == length(b) || return false for i in 1:length(a) - typeof(a[i]) == typeof(b[i]) && (typeof(a[i]) <: AbstractVTKMultiblockData || typeof(a[i]) <: AbstractVTKUnstructuredData ? same_ordered_geometry(a[i], b[i]) : a[i] == b[i]) || return false + typeof(a[i]) == typeof(b[i]) && ( + if typeof(a[i]) <: AbstractVTKMultiblockData || + typeof(a[i]) <: AbstractVTKUnstructuredData + same_ordered_geometry(a[i], b[i]) + else + a[i] == b[i] + end + ) || return false end return true end @@ -90,19 +106,23 @@ function same_geometry_shape(a::AbstractVTKUnstructuredData, b::AbstractVTKUnstr dim(a) != dim(b) && return false num_of_points(a) != num_of_points(b) && return false num_of_cells(a) != num_of_cells(b) && return false - + _num_of_cells = num_of_cells(a) for i in 1:_num_of_cells - similar_cells(a.cell_connectivity[i], cell_type(a,i), b.cell_connectivity[i], cell_type(b,i)) || return false + similar_cells( + a.cell_connectivity[i], cell_type(a, i), b.cell_connectivity[i], cell_type(b, i) + ) || return false end return true end same_geometry_shape(a::AbstractStaticVTKData, b::AbstractStaticVTKData) = false -function same_ordered_geometry_shape(a::AbstractVTKMultiblockData, b::AbstractVTKMultiblockData) +function same_ordered_geometry_shape( + a::AbstractVTKMultiblockData, b::AbstractVTKMultiblockData +) length(a) == length(b) || return false for i in 1:length(a) - typeof(a[i]) == typeof(b[i]) || return false + typeof(a[i]) == typeof(b[i]) || return false if typeof(a[i]) <: AbstractVTKMultiblockData same_ordered_geometry_shape(a[i], b[i]) || return false else diff --git a/src/decompose.jl b/src/decompose.jl index 79b4e23..eb13ac1 100644 --- a/src/decompose.jl +++ b/src/decompose.jl @@ -2,9 +2,12 @@ include("decompose_cell.jl") include("decompose_unstruct.jl") include("decompose_struct.jl") -decompose(dataset::AbstractVTKMultiblockData, target::String="Faces") = decompose(VTKUnstructuredData(dataset), target) +function decompose(dataset::AbstractVTKMultiblockData, target::String="Faces") + return decompose(VTKUnstructuredData(dataset), target) +end function decompose(dataset::AbstractTimeSeriesVTKData, target::String="Faces") - return VTKTimeSeriesData(dataset.timemarkers, [decompose(dataset[i], target) for - i in 1:length(dataset)]) + return VTKTimeSeriesData( + dataset.timemarkers, [decompose(dataset[i], target) for i in 1:length(dataset)] + ) end diff --git a/src/decompose_cell.jl b/src/decompose_cell.jl index 37d34c7..c643cf1 100644 --- a/src/decompose_cell.jl +++ b/src/decompose_cell.jl @@ -45,24 +45,34 @@ function decompose_triangle(cell_connectivity, target::String) if target == "Faces" return Vector{Int}[[cell_connectivity...]], Int[5] else - return Vector{Int}[ [ cell_connectivity[1], cell_connectivity[2] ], - [ cell_connectivity[2], cell_connectivity[3] ], - [ cell_connectivity[3], cell_connectivity[1] ] ], - fill(3,3) + return Vector{Int}[ + [cell_connectivity[1], cell_connectivity[2]], + [cell_connectivity[2], cell_connectivity[3]], + [cell_connectivity[3], cell_connectivity[1]], + ], + fill(3, 3) end end function decompose_triangle_strip(cell_connectivity, target::String) if target == "Faces" - return Vector{Int}[ [ cell_connectivity[i], cell_connectivity[i+1], cell_connectivity[i+2] ] - for i in 1:length(cell_connectivity)-2], fill(5, length(cell_connectivity)-2) + return Vector{Int}[ + [cell_connectivity[i], cell_connectivity[i + 1], cell_connectivity[i + 2]] for + i in 1:(length(cell_connectivity) - 2) + ], + fill(5, length(cell_connectivity) - 2) else return append!( - Vector{Int}[ [ cell_connectivity[i], cell_connectivity[i+1] ] - for i in 1:length(cell_connectivity)-1 ], - Vector{Int}[ [ cell_connectivity[i], cell_connectivity[i+2] ] - for i in 1:length(cell_connectivity)-2]), - fill(3, 2*length(cell_connectivity)-3) + Vector{Int}[ + [cell_connectivity[i], cell_connectivity[i + 1]] for + i in 1:(length(cell_connectivity) - 1) + ], + Vector{Int}[ + [cell_connectivity[i], cell_connectivity[i + 2]] for + i in 1:(length(cell_connectivity) - 2) + ], + ), + fill(3, 2 * length(cell_connectivity) - 3) end end @@ -70,11 +80,13 @@ function decompose_pixel(cell_connectivity, target::String) if target == "Faces" return [cell_connectivity], [8] else - return Vector{Int}[ [ cell_connectivity[1], cell_connectivity[2] ], - [ cell_connectivity[2], cell_connectivity[4] ], - [ cell_connectivity[4], cell_connectivity[3] ], - [ cell_connectivity[3], cell_connectivity[1] ] ], - fill(3, 4) + return Vector{Int}[ + [cell_connectivity[1], cell_connectivity[2]], + [cell_connectivity[2], cell_connectivity[4]], + [cell_connectivity[4], cell_connectivity[3]], + [cell_connectivity[3], cell_connectivity[1]], + ], + fill(3, 4) end end @@ -82,124 +94,226 @@ function decompose_quad(cell_connectivity, target::String) if target == "Faces" return [cell_connectivity], [9] else - return Vector{Int}[ [ cell_connectivity[1], cell_connectivity[2] ], - [ cell_connectivity[2], cell_connectivity[3] ], - [ cell_connectivity[3], cell_connectivity[4] ], - [ cell_connectivity[4], cell_connectivity[1] ] ], - fill(3, 4) + return Vector{Int}[ + [cell_connectivity[1], cell_connectivity[2]], + [cell_connectivity[2], cell_connectivity[3]], + [cell_connectivity[3], cell_connectivity[4]], + [cell_connectivity[4], cell_connectivity[1]], + ], + fill(3, 4) end end function decompose_tetra(cell_connectivity, target::String) if target == "Faces" - return Vector{Int}[ [ cell_connectivity[1], cell_connectivity[2], cell_connectivity[3] ], - [ cell_connectivity[1], cell_connectivity[2], cell_connectivity[4] ], - [ cell_connectivity[2], cell_connectivity[3], cell_connectivity[4] ], - [ cell_connectivity[2], cell_connectivity[1], cell_connectivity[4] ] ], - fill(5, 4) + return Vector{Int}[ + [cell_connectivity[1], cell_connectivity[2], cell_connectivity[3]], + [cell_connectivity[1], cell_connectivity[2], cell_connectivity[4]], + [cell_connectivity[2], cell_connectivity[3], cell_connectivity[4]], + [cell_connectivity[2], cell_connectivity[1], cell_connectivity[4]], + ], + fill(5, 4) else - return Vector{Int}[ [ cell_connectivity[1], cell_connectivity[2] ], - [ cell_connectivity[2], cell_connectivity[3] ], - [ cell_connectivity[3], cell_connectivity[1] ], - [ cell_connectivity[1], cell_connectivity[4] ], - [ cell_connectivity[2], cell_connectivity[4] ], - [ cell_connectivity[3], cell_connectivity[4] ] ], - fill(3, 6) + return Vector{Int}[ + [cell_connectivity[1], cell_connectivity[2]], + [cell_connectivity[2], cell_connectivity[3]], + [cell_connectivity[3], cell_connectivity[1]], + [cell_connectivity[1], cell_connectivity[4]], + [cell_connectivity[2], cell_connectivity[4]], + [cell_connectivity[3], cell_connectivity[4]], + ], + fill(3, 6) end end function decompose_voxel(cell_connectivity, target::String) if target == "Faces" - return Vector{Int}[ [ cell_connectivity[1], cell_connectivity[2], cell_connectivity[4], cell_connectivity[3] ], - [ cell_connectivity[5], cell_connectivity[6], cell_connectivity[8], cell_connectivity[7] ], - [ cell_connectivity[1], cell_connectivity[2], cell_connectivity[6], cell_connectivity[5] ], - [ cell_connectivity[2], cell_connectivity[4], cell_connectivity[8], cell_connectivity[6] ], - [ cell_connectivity[4], cell_connectivity[3], cell_connectivity[7], cell_connectivity[8] ], - [ cell_connectivity[3], cell_connectivity[1], cell_connectivity[5], cell_connectivity[7] ] ], - fill(9, 6) + return Vector{Int}[ + [ + cell_connectivity[1], + cell_connectivity[2], + cell_connectivity[4], + cell_connectivity[3], + ], + [ + cell_connectivity[5], + cell_connectivity[6], + cell_connectivity[8], + cell_connectivity[7], + ], + [ + cell_connectivity[1], + cell_connectivity[2], + cell_connectivity[6], + cell_connectivity[5], + ], + [ + cell_connectivity[2], + cell_connectivity[4], + cell_connectivity[8], + cell_connectivity[6], + ], + [ + cell_connectivity[4], + cell_connectivity[3], + cell_connectivity[7], + cell_connectivity[8], + ], + [ + cell_connectivity[3], + cell_connectivity[1], + cell_connectivity[5], + cell_connectivity[7], + ], + ], + fill(9, 6) else - return Vector{Int}[ [ cell_connectivity[1], cell_connectivity[2] ], - [ cell_connectivity[2], cell_connectivity[4] ], - [ cell_connectivity[4], cell_connectivity[3] ], - [ cell_connectivity[3], cell_connectivity[1] ], - [ cell_connectivity[5], cell_connectivity[6] ], - [ cell_connectivity[6], cell_connectivity[8] ], - [ cell_connectivity[8], cell_connectivity[7] ], - [ cell_connectivity[7], cell_connectivity[5] ], - [ cell_connectivity[1], cell_connectivity[5] ], - [ cell_connectivity[2], cell_connectivity[6] ], - [ cell_connectivity[4], cell_connectivity[8] ], - [ cell_connectivity[3], cell_connectivity[7] ] ], - fill(3, 12) + return Vector{Int}[ + [cell_connectivity[1], cell_connectivity[2]], + [cell_connectivity[2], cell_connectivity[4]], + [cell_connectivity[4], cell_connectivity[3]], + [cell_connectivity[3], cell_connectivity[1]], + [cell_connectivity[5], cell_connectivity[6]], + [cell_connectivity[6], cell_connectivity[8]], + [cell_connectivity[8], cell_connectivity[7]], + [cell_connectivity[7], cell_connectivity[5]], + [cell_connectivity[1], cell_connectivity[5]], + [cell_connectivity[2], cell_connectivity[6]], + [cell_connectivity[4], cell_connectivity[8]], + [cell_connectivity[3], cell_connectivity[7]], + ], + fill(3, 12) end end function decompose_hexa(cell_connectivity, target::String) if target == "Faces" - return Vector{Int}[ [ cell_connectivity[1], cell_connectivity[2], cell_connectivity[3], cell_connectivity[4] ], - [ cell_connectivity[5], cell_connectivity[6], cell_connectivity[7], cell_connectivity[8] ], - [ cell_connectivity[1], cell_connectivity[2], cell_connectivity[6], cell_connectivity[5] ], - [ cell_connectivity[2], cell_connectivity[3], cell_connectivity[7], cell_connectivity[6] ], - [ cell_connectivity[3], cell_connectivity[4], cell_connectivity[8], cell_connectivity[7] ], - [ cell_connectivity[4], cell_connectivity[1], cell_connectivity[5], cell_connectivity[8] ] ], - fill(9, 6) + return Vector{Int}[ + [ + cell_connectivity[1], + cell_connectivity[2], + cell_connectivity[3], + cell_connectivity[4], + ], + [ + cell_connectivity[5], + cell_connectivity[6], + cell_connectivity[7], + cell_connectivity[8], + ], + [ + cell_connectivity[1], + cell_connectivity[2], + cell_connectivity[6], + cell_connectivity[5], + ], + [ + cell_connectivity[2], + cell_connectivity[3], + cell_connectivity[7], + cell_connectivity[6], + ], + [ + cell_connectivity[3], + cell_connectivity[4], + cell_connectivity[8], + cell_connectivity[7], + ], + [ + cell_connectivity[4], + cell_connectivity[1], + cell_connectivity[5], + cell_connectivity[8], + ], + ], + fill(9, 6) else - return Vector{Int}[ [ cell_connectivity[1], cell_connectivity[2] ], - [ cell_connectivity[2], cell_connectivity[3] ], - [ cell_connectivity[3], cell_connectivity[4] ], - [ cell_connectivity[4], cell_connectivity[1] ], - [ cell_connectivity[5], cell_connectivity[6] ], - [ cell_connectivity[6], cell_connectivity[7] ], - [ cell_connectivity[7], cell_connectivity[8] ], - [ cell_connectivity[8], cell_connectivity[5] ], - [ cell_connectivity[1], cell_connectivity[5] ], - [ cell_connectivity[2], cell_connectivity[6] ], - [ cell_connectivity[3], cell_connectivity[7] ], - [ cell_connectivity[4], cell_connectivity[8] ] ], - fill(3, 12) + return Vector{Int}[ + [cell_connectivity[1], cell_connectivity[2]], + [cell_connectivity[2], cell_connectivity[3]], + [cell_connectivity[3], cell_connectivity[4]], + [cell_connectivity[4], cell_connectivity[1]], + [cell_connectivity[5], cell_connectivity[6]], + [cell_connectivity[6], cell_connectivity[7]], + [cell_connectivity[7], cell_connectivity[8]], + [cell_connectivity[8], cell_connectivity[5]], + [cell_connectivity[1], cell_connectivity[5]], + [cell_connectivity[2], cell_connectivity[6]], + [cell_connectivity[3], cell_connectivity[7]], + [cell_connectivity[4], cell_connectivity[8]], + ], + fill(3, 12) end end function decompose_wedge(cell_connectivity, target::String) if target == "Faces" - return Vector{Int}[ [ cell_connectivity[1], cell_connectivity[2], cell_connectivity[5], cell_connectivity[4] ], - [ cell_connectivity[1], cell_connectivity[2], cell_connectivity[3] ], - [ cell_connectivity[2], cell_connectivity[5], cell_connectivity[6], cell_connectivity[3] ], - [ cell_connectivity[5], cell_connectivity[4], cell_connectivity[6] ], - [ cell_connectivity[4], cell_connectivity[1], cell_connectivity[3], cell_connectivity[6] ] ], - [9, 5, 9, 5, 9] + return Vector{Int}[ + [ + cell_connectivity[1], + cell_connectivity[2], + cell_connectivity[5], + cell_connectivity[4], + ], + [cell_connectivity[1], cell_connectivity[2], cell_connectivity[3]], + [ + cell_connectivity[2], + cell_connectivity[5], + cell_connectivity[6], + cell_connectivity[3], + ], + [cell_connectivity[5], cell_connectivity[4], cell_connectivity[6]], + [ + cell_connectivity[4], + cell_connectivity[1], + cell_connectivity[3], + cell_connectivity[6], + ], + ], + [9, 5, 9, 5, 9] else - return Vector{Int}[ [ cell_connectivity[1], cell_connectivity[2] ], - [ cell_connectivity[2], cell_connectivity[5] ], - [ cell_connectivity[5], cell_connectivity[4] ], - [ cell_connectivity[4], cell_connectivity[1] ], - [ cell_connectivity[1], cell_connectivity[3] ], - [ cell_connectivity[2], cell_connectivity[3] ], - [ cell_connectivity[5], cell_connectivity[6] ], - [ cell_connectivity[4], cell_connectivity[6] ], - [ cell_connectivity[3], cell_connectivity[6] ] ], - fill(3, 9) + return Vector{Int}[ + [cell_connectivity[1], cell_connectivity[2]], + [cell_connectivity[2], cell_connectivity[5]], + [cell_connectivity[5], cell_connectivity[4]], + [cell_connectivity[4], cell_connectivity[1]], + [cell_connectivity[1], cell_connectivity[3]], + [cell_connectivity[2], cell_connectivity[3]], + [cell_connectivity[5], cell_connectivity[6]], + [cell_connectivity[4], cell_connectivity[6]], + [cell_connectivity[3], cell_connectivity[6]], + ], + fill(3, 9) end end function decompose_pyramid(cell_connectivity, target::String) if target == "Faces" - return Vector{Int}[ [ cell_connectivity[1], cell_connectivity[2], cell_connectivity[3], cell_connectivity[4] ], - [ cell_connectivity[1], cell_connectivity[2], cell_connectivity[5] ], - [ cell_connectivity[2], cell_connectivity[3], cell_connectivity[5] ], - [ cell_connectivity[3], cell_connectivity[4], cell_connectivity[5] ], - [ cell_connectivity[4], cell_connectivity[1], cell_connectivity[5] ] ], - Int[9, 5, 5, 5, 5] + return Vector{Int}[ + [ + cell_connectivity[1], + cell_connectivity[2], + cell_connectivity[3], + cell_connectivity[4], + ], + [cell_connectivity[1], cell_connectivity[2], cell_connectivity[5]], + [cell_connectivity[2], cell_connectivity[3], cell_connectivity[5]], + [cell_connectivity[3], cell_connectivity[4], cell_connectivity[5]], + [cell_connectivity[4], cell_connectivity[1], cell_connectivity[5]], + ], + Int[9, 5, 5, 5, 5] else - return Vector{Int}[ [ cell_connectivity[1], cell_connectivity[2] ], - [ cell_connectivity[2], cell_connectivity[3] ], - [ cell_connectivity[3], cell_connectivity[4] ], - [ cell_connectivity[4], cell_connectivity[1] ], - [ cell_connectivity[1], cell_connectivity[5] ], - [ cell_connectivity[2], cell_connectivity[5] ], - [ cell_connectivity[3], cell_connectivity[5] ], - [ cell_connectivity[4], cell_connectivity[5] ] ], - fill(3, 8) + return Vector{Int}[ + [cell_connectivity[1], cell_connectivity[2]], + [cell_connectivity[2], cell_connectivity[3]], + [cell_connectivity[3], cell_connectivity[4]], + [cell_connectivity[4], cell_connectivity[1]], + [cell_connectivity[1], cell_connectivity[5]], + [cell_connectivity[2], cell_connectivity[5]], + [cell_connectivity[3], cell_connectivity[5]], + [cell_connectivity[4], cell_connectivity[5]], + ], + fill(3, 8) end end @@ -207,10 +321,12 @@ function decompose_quadratic_triangle(cell_connectivity, target::String) if target == "Faces" return Vector{Int}[cell_connectivity], Int[22] else - return Vector{Int}[ [ cell_connectivity[1], cell_connectivity[2], cell_connectivity[4]], - [ cell_connectivity[2], cell_connectivity[3], cell_connectivity[5] ], - [ cell_connectivity[3], cell_connectivity[1], cell_connectivity[6] ] ], - fill(21, 3) + return Vector{Int}[ + [cell_connectivity[1], cell_connectivity[2], cell_connectivity[4]], + [cell_connectivity[2], cell_connectivity[3], cell_connectivity[5]], + [cell_connectivity[3], cell_connectivity[1], cell_connectivity[6]], + ], + fill(21, 3) end end @@ -218,58 +334,156 @@ function decompose_quadratic_quad(cell_connectivity, target::String) if target == "Faces" return Vector{Int}[cell_connectivity], Int[23] else - return Vector{Int}[ [ cell_connectivity[1], cell_connectivity[2], cell_connectivity[5] ], - [ cell_connectivity[2], cell_connectivity[3], cell_connectivity[6] ], - [ cell_connectivity[3], cell_connectivity[4], cell_connectivity[7] ], - [ cell_connectivity[4], cell_connectivity[1], cell_connectivity[8] ] ], - fill(21, 4) + return Vector{Int}[ + [cell_connectivity[1], cell_connectivity[2], cell_connectivity[5]], + [cell_connectivity[2], cell_connectivity[3], cell_connectivity[6]], + [cell_connectivity[3], cell_connectivity[4], cell_connectivity[7]], + [cell_connectivity[4], cell_connectivity[1], cell_connectivity[8]], + ], + fill(21, 4) end end function decompose_quadratic_tetra(cell_connectivity, target::String) if target == "Faces" - return Vector{Int}[ [ cell_connectivity[1], cell_connectivity[2], cell_connectivity[3], cell_connectivity[5], cell_connectivity[6], cell_connectivity[7] ], - [ cell_connectivity[1], cell_connectivity[2], cell_connectivity[4], cell_connectivity[5], cell_connectivity[9], cell_connectivity[8] ], - [ cell_connectivity[2], cell_connectivity[3], cell_connectivity[4], cell_connectivity[6], cell_connectivity[10], cell_connectivity[9] ], - [ cell_connectivity[3], cell_connectivity[1], cell_connectivity[4], cell_connectivity[7], cell_connectivity[8], cell_connectivity[10] ] ], - fill(22, 4) + return Vector{Int}[ + [ + cell_connectivity[1], + cell_connectivity[2], + cell_connectivity[3], + cell_connectivity[5], + cell_connectivity[6], + cell_connectivity[7], + ], + [ + cell_connectivity[1], + cell_connectivity[2], + cell_connectivity[4], + cell_connectivity[5], + cell_connectivity[9], + cell_connectivity[8], + ], + [ + cell_connectivity[2], + cell_connectivity[3], + cell_connectivity[4], + cell_connectivity[6], + cell_connectivity[10], + cell_connectivity[9], + ], + [ + cell_connectivity[3], + cell_connectivity[1], + cell_connectivity[4], + cell_connectivity[7], + cell_connectivity[8], + cell_connectivity[10], + ], + ], + fill(22, 4) else - return Vector{Int}[ [ cell_connectivity[1], cell_connectivity[2], cell_connectivity[5] ], - [ cell_connectivity[2], cell_connectivity[3], cell_connectivity[5] ], - [ cell_connectivity[3], cell_connectivity[1], cell_connectivity[7] ], - [ cell_connectivity[1], cell_connectivity[4], cell_connectivity[8] ], - [ cell_connectivity[2], cell_connectivity[4], cell_connectivity[8] ], - [ cell_connectivity[3], cell_connectivity[4], cell_connectivity[10] ] ], - fill(21, 6) + return Vector{Int}[ + [cell_connectivity[1], cell_connectivity[2], cell_connectivity[5]], + [cell_connectivity[2], cell_connectivity[3], cell_connectivity[5]], + [cell_connectivity[3], cell_connectivity[1], cell_connectivity[7]], + [cell_connectivity[1], cell_connectivity[4], cell_connectivity[8]], + [cell_connectivity[2], cell_connectivity[4], cell_connectivity[8]], + [cell_connectivity[3], cell_connectivity[4], cell_connectivity[10]], + ], + fill(21, 6) end end function decompose_quadratic_hexa(cell_connectivity, target::String) if target == "Faces" - return Vector{Int}[ [ cell_connectivity[1], cell_connectivity[2], cell_connectivity[3], cell_connectivity[4], cell_connectivity[9], cell_connectivity[10], cell_connectivity[11], cell_connectivity[12] ], - [ cell_connectivity[5], cell_connectivity[6], cell_connectivity[7], cell_connectivity[8], cell_connectivity[13], cell_connectivity[14], cell_connectivity[15], cell_connectivity[16] ], - [ cell_connectivity[1], cell_connectivity[2], cell_connectivity[6], cell_connectivity[5], cell_connectivity[9], cell_connectivity[18], cell_connectivity[13], cell_connectivity[17] ], - [ cell_connectivity[2], cell_connectivity[3], cell_connectivity[7], cell_connectivity[6], cell_connectivity[10], cell_connectivity[19], cell_connectivity[14], cell_connectivity[18] ], - [ cell_connectivity[3], cell_connectivity[4], cell_connectivity[8], cell_connectivity[7], cell_connectivity[11], cell_connectivity[20], cell_connectivity[15], cell_connectivity[19] ], - [ cell_connectivity[4], cell_connectivity[1], cell_connectivity[5], cell_connectivity[8], cell_connectivity[12], cell_connectivity[17], cell_connectivity[16], cell_connectivity[20] ] ], - fill(23, 6) + return Vector{Int}[ + [ + cell_connectivity[1], + cell_connectivity[2], + cell_connectivity[3], + cell_connectivity[4], + cell_connectivity[9], + cell_connectivity[10], + cell_connectivity[11], + cell_connectivity[12], + ], + [ + cell_connectivity[5], + cell_connectivity[6], + cell_connectivity[7], + cell_connectivity[8], + cell_connectivity[13], + cell_connectivity[14], + cell_connectivity[15], + cell_connectivity[16], + ], + [ + cell_connectivity[1], + cell_connectivity[2], + cell_connectivity[6], + cell_connectivity[5], + cell_connectivity[9], + cell_connectivity[18], + cell_connectivity[13], + cell_connectivity[17], + ], + [ + cell_connectivity[2], + cell_connectivity[3], + cell_connectivity[7], + cell_connectivity[6], + cell_connectivity[10], + cell_connectivity[19], + cell_connectivity[14], + cell_connectivity[18], + ], + [ + cell_connectivity[3], + cell_connectivity[4], + cell_connectivity[8], + cell_connectivity[7], + cell_connectivity[11], + cell_connectivity[20], + cell_connectivity[15], + cell_connectivity[19], + ], + [ + cell_connectivity[4], + cell_connectivity[1], + cell_connectivity[5], + cell_connectivity[8], + cell_connectivity[12], + cell_connectivity[17], + cell_connectivity[16], + cell_connectivity[20], + ], + ], + fill(23, 6) else - return Vector{Int}[ [ cell_connectivity[1], cell_connectivity[2], cell_connectivity[9] ], - [ cell_connectivity[2], cell_connectivity[3], cell_connectivity[10] ], - [ cell_connectivity[3], cell_connectivity[4], cell_connectivity[11] ], - [ cell_connectivity[4], cell_connectivity[1], cell_connectivity[12] ], - [ cell_connectivity[5], cell_connectivity[6], cell_connectivity[13] ], - [ cell_connectivity[6], cell_connectivity[7], cell_connectivity[14] ], - [ cell_connectivity[7], cell_connectivity[8], cell_connectivity[15] ], - [ cell_connectivity[8], cell_connectivity[5], cell_connectivity[16] ], - [ cell_connectivity[1], cell_connectivity[5], cell_connectivity[17] ], - [ cell_connectivity[2], cell_connectivity[6], cell_connectivity[18] ], - [ cell_connectivity[3], cell_connectivity[7], cell_connectivity[19] ], - [ cell_connectivity[4], cell_connectivity[8], cell_connectivity[20] ] ], - fill(21, 12) + return Vector{Int}[ + [cell_connectivity[1], cell_connectivity[2], cell_connectivity[9]], + [cell_connectivity[2], cell_connectivity[3], cell_connectivity[10]], + [cell_connectivity[3], cell_connectivity[4], cell_connectivity[11]], + [cell_connectivity[4], cell_connectivity[1], cell_connectivity[12]], + [cell_connectivity[5], cell_connectivity[6], cell_connectivity[13]], + [cell_connectivity[6], cell_connectivity[7], cell_connectivity[14]], + [cell_connectivity[7], cell_connectivity[8], cell_connectivity[15]], + [cell_connectivity[8], cell_connectivity[5], cell_connectivity[16]], + [cell_connectivity[1], cell_connectivity[5], cell_connectivity[17]], + [cell_connectivity[2], cell_connectivity[6], cell_connectivity[18]], + [cell_connectivity[3], cell_connectivity[7], cell_connectivity[19]], + [cell_connectivity[4], cell_connectivity[8], cell_connectivity[20]], + ], + fill(21, 12) end end -function decompose_cell(dataset::AbstractStaticVTKData, cell_ind::Union{Int, Tuple{Int, Vararg{Int}}}; target::String="") - decompose_cell(cell_connectivity(dataset, cell_ind), cell_type(dataset, cell_ind)) +function decompose_cell( + dataset::AbstractStaticVTKData, + cell_ind::Union{Int,Tuple{Int,Vararg{Int}}}; + target::String="", +) + return decompose_cell( + cell_connectivity(dataset, cell_ind), cell_type(dataset, cell_ind) + ) end diff --git a/src/decompose_struct.jl b/src/decompose_struct.jl index 0187053..6c6098f 100644 --- a/src/decompose_struct.jl +++ b/src/decompose_struct.jl @@ -1,4 +1,6 @@ -function decompose(_dataset::AbstractVTKStructuredData, target::String = "Faces", decompose_cell_data = false) +function decompose( + _dataset::AbstractVTKStructuredData, target::String="Faces", decompose_cell_data=false +) dataset = VTKStructuredData(_dataset) _dim = dim(dataset) @@ -108,16 +110,22 @@ function decompose_to_faces_3d_with_cell_data(dataset::VTKStructuredData) _var_dim = var_dim(dataset, m, "Cell") if _var_dim == 1 if cind[3] != 1 - _cd = (dataset.cell_data[m][cind...] + - dataset.cell_data[m][cind[1:2]...,cind[3]-1]) / 2 + _cd = + ( + dataset.cell_data[m][cind...] + + dataset.cell_data[m][cind[1:2]..., cind[3] - 1] + ) / 2 else _cd = dataset.cell_data[m][cind...] end push!(_cell_data[m], _cd) else if cind[3] != 1 - _cd = (dataset.cell_data[m][:, cind...] + - dataset.cell_data[m][:, cind[1:2]...,cind[3]-1]) / 2 + _cd = + ( + dataset.cell_data[m][:, cind...] + + dataset.cell_data[m][:, cind[1:2]..., cind[3] - 1] + ) / 2 else _cd = dataset.cell_data[m][:, cind...] end @@ -130,16 +138,22 @@ function decompose_to_faces_3d_with_cell_data(dataset::VTKStructuredData) _var_dim = var_dim(dataset, m, "Cell") if _var_dim == 1 if cind[2] != 1 - _cd = (dataset.cell_data[m][cind...] + - dataset.cell_data[m][cind[1],cind[2]-1,cind[3]]) / 2 + _cd = + ( + dataset.cell_data[m][cind...] + + dataset.cell_data[m][cind[1], cind[2] - 1, cind[3]] + ) / 2 else _cd = dataset.cell_data[m][cind...] end push!(_cell_data[m], _cd) else if cind[3] != 1 - _cd = (dataset.cell_data[m][:, cind...] + - dataset.cell_data[m][:, cind[1],cind[2]-1,cind[3]]) / 2 + _cd = + ( + dataset.cell_data[m][:, cind...] + + dataset.cell_data[m][:, cind[1], cind[2] - 1, cind[3]] + ) / 2 else _cd = dataset.cell_data[m][:, cind...] end @@ -152,16 +166,22 @@ function decompose_to_faces_3d_with_cell_data(dataset::VTKStructuredData) _var_dim = var_dim(dataset, m, "Cell") if _var_dim == 1 if cind[1] != 1 - _cd = (dataset.cell_data[m][cind...] + - dataset.cell_data[m][cind[1]-1,cind[2:3]...]) / 2 + _cd = + ( + dataset.cell_data[m][cind...] + + dataset.cell_data[m][cind[1] - 1, cind[2:3]...] + ) / 2 else _cd = dataset.cell_data[m][cind...] end push!(_cell_data[m], _cd) else if cind[3] != 1 - _cd = (dataset.cell_data[m][:, cind...] + - dataset.cell_data[m][:, cind[1]-1,cind[2:3]...]) / 2 + _cd = + ( + dataset.cell_data[m][:, cind...] + + dataset.cell_data[m][:, cind[1] - 1, cind[2:3]...] + ) / 2 else _cd = dataset.cell_data[m][:, cind...] end @@ -251,18 +271,24 @@ function decompose_to_lines_2d_with_cell_data(dataset::VTKStructuredData) _var_dim = var_dim(dataset, m, "Cell") if _var_dim == 1 if cind[2] != 1 - _cd = (dataset.cell_data[m][cind...] + - dataset.cell_data[m][cind[1], cind[2]-1]) / 2 + _cd = + ( + dataset.cell_data[m][cind...] + + dataset.cell_data[m][cind[1], cind[2] - 1] + ) / 2 else _cd = dataset.cell_data[m][cind...] end push!(_cell_data[m], _cd) else if cind[2] != 1 - _cd = (dataset.cell_data[m][:,cind...] + - dataset.cell_data[m][:,cind[1],cind[2]-1]) / 2 + _cd = + ( + dataset.cell_data[m][:, cind...] + + dataset.cell_data[m][:, cind[1], cind[2] - 1] + ) / 2 else - _cd = dataset.cell_data[m][:,cind...] + _cd = dataset.cell_data[m][:, cind...] end append!(_cell_data[m], _cd) end @@ -273,18 +299,24 @@ function decompose_to_lines_2d_with_cell_data(dataset::VTKStructuredData) _var_dim = var_dim(dataset, m, "Cell") if _var_dim == 1 if cind[1] != 1 - _cd = (dataset.cell_data[m][cind...] + - dataset.cell_data[m][cind[1]-1, cind[2]]) / 2 + _cd = + ( + dataset.cell_data[m][cind...] + + dataset.cell_data[m][cind[1] - 1, cind[2]] + ) / 2 else _cd = dataset.cell_data[m][cind...] end push!(_cell_data[m], _cd) else if cind[1] != 1 - _cd = (dataset.cell_data[m][:,cind...] + - dataset.cell_data[m][:,cind[1]-1,cind[2]]) / 2 + _cd = + ( + dataset.cell_data[m][:, cind...] + + dataset.cell_data[m][:, cind[1] - 1, cind[2]] + ) / 2 else - _cd = dataset.cell_data[m][:,cind...] + _cd = dataset.cell_data[m][:, cind...] end append!(_cell_data[m], _cd) end @@ -298,7 +330,7 @@ function decompose_to_lines_2d_with_cell_data(dataset::VTKStructuredData) _cd = dataset.cell_data[m][cind...] push!(_cell_data[m], _cd) else - _cd = dataset.cell_data[m][:,cind...] + _cd = dataset.cell_data[m][:, cind...] append!(_cell_data[m], _cd) end end @@ -311,7 +343,7 @@ function decompose_to_lines_2d_with_cell_data(dataset::VTKStructuredData) _cd = dataset.cell_data[m][cind...] push!(_cell_data[m], _cd) else - _cd = dataset.cell_data[m][:,cind...] + _cd = dataset.cell_data[m][:, cind...] append!(_cell_data[m], _cd) end end @@ -359,34 +391,52 @@ function decompose_to_lines_3d_with_cell_data(dataset::VTKStructuredData) _var_dim = var_dim(dataset, m, "Cell") if _var_dim == 1 if cind[2] != 1 && cind[3] != 1 - _cd = (dataset.cell_data[m][cind...] + - dataset.cell_data[m][cind[1:2]...,cind[3]-1] + - dataset.cell_data[m][cind[1],cind[2]-1,cind[3]] + - dataset.cell_data[m][cind[1],cind[2]-1,cind[3]-1]) / 4 + _cd = + ( + dataset.cell_data[m][cind...] + + dataset.cell_data[m][cind[1:2]..., cind[3] - 1] + + dataset.cell_data[m][cind[1], cind[2] - 1, cind[3]] + + dataset.cell_data[m][cind[1], cind[2] - 1, cind[3] - 1] + ) / 4 elseif cind[2] == 1 && cind[3] != 1 - _cd = (dataset.cell_data[m][cind...] + - dataset.cell_data[m][cind[1:2]...,cind[3]-1]) / 2 + _cd = + ( + dataset.cell_data[m][cind...] + + dataset.cell_data[m][cind[1:2]..., cind[3] - 1] + ) / 2 elseif cind[2] != 1 && cind[3] == 1 - _cd = (dataset.cell_data[m][cind...] + - dataset.cell_data[m][cind[1], cind[2]-1,cind[3]]) / 2 + _cd = + ( + dataset.cell_data[m][cind...] + + dataset.cell_data[m][cind[1], cind[2] - 1, cind[3]] + ) / 2 elseif cind[2] == cind[3] == 1 _cd = dataset.cell_data[m][cind...] end push!(_cell_data[m], _cd) else if cind[2] != 1 && cind[3] != 1 - _cd = (dataset.cell_data[m][:,cind...] + - dataset.cell_data[m][:,cind[1:2]...,cind[3]-1] + - dataset.cell_data[m][:,cind[1],cind[2]-1,cind[3]] + - dataset.cell_data[m][:,cind[1],cind[2]-1,cind[3]-1]) / 4 + _cd = + ( + dataset.cell_data[m][:, cind...] + + dataset.cell_data[m][:, cind[1:2]..., cind[3] - 1] + + dataset.cell_data[m][:, cind[1], cind[2] - 1, cind[3]] + + dataset.cell_data[m][:, cind[1], cind[2] - 1, cind[3] - 1] + ) / 4 elseif cind[2] == 1 && cind[3] != 1 - _cd = (dataset.cell_data[m][:,cind...] + - dataset.cell_data[m][:,cind[1:2]...,cind[3]-1]) / 2 + _cd = + ( + dataset.cell_data[m][:, cind...] + + dataset.cell_data[m][:, cind[1:2]..., cind[3] - 1] + ) / 2 elseif cind[2] != 1 && cind[3] == 1 - _cd = (dataset.cell_data[m][:,cind...] + - dataset.cell_data[m][:,cind[1], cind[2]-1,cind[3]]) / 2 + _cd = + ( + dataset.cell_data[m][:, cind...] + + dataset.cell_data[m][:, cind[1], cind[2] - 1, cind[3]] + ) / 2 elseif cind[2] == cind[3] == 1 - _cd = dataset.cell_data[m][:,cind...] + _cd = dataset.cell_data[m][:, cind...] end append!(_cell_data[m], _cd) end @@ -397,34 +447,52 @@ function decompose_to_lines_3d_with_cell_data(dataset::VTKStructuredData) _var_dim = var_dim(dataset, m, "Cell") if _var_dim == 1 if cind[1] != 1 && cind[3] != 1 - _cd = (dataset.cell_data[m][cind...] + - dataset.cell_data[m][cind[1:2]...,cind[3]-1] + - dataset.cell_data[m][cind[1]-1,cind[2],cind[3]] + - dataset.cell_data[m][cind[1]-1,cind[2],cind[3]-1]) / 4 + _cd = + ( + dataset.cell_data[m][cind...] + + dataset.cell_data[m][cind[1:2]..., cind[3] - 1] + + dataset.cell_data[m][cind[1] - 1, cind[2], cind[3]] + + dataset.cell_data[m][cind[1] - 1, cind[2], cind[3] - 1] + ) / 4 elseif cind[1] == 1 && cind[3] != 1 - _cd = (dataset.cell_data[m][cind...] + - dataset.cell_data[m][cind[1:2]...,cind[3]-1]) / 2 + _cd = + ( + dataset.cell_data[m][cind...] + + dataset.cell_data[m][cind[1:2]..., cind[3] - 1] + ) / 2 elseif cind[1] != 1 && cind[3] == 1 - _cd = (dataset.cell_data[m][cind...] + - dataset.cell_data[m][cind[1]-1, cind[2],cind[3]]) / 2 + _cd = + ( + dataset.cell_data[m][cind...] + + dataset.cell_data[m][cind[1] - 1, cind[2], cind[3]] + ) / 2 elseif cind[1] == cind[3] == 1 _cd = dataset.cell_data[m][cind...] end push!(_cell_data[m], _cd) else if cind[1] != 1 && cind[3] != 1 - _cd = (dataset.cell_data[m][:,cind...] + - dataset.cell_data[m][:,cind[1:2]...,cind[3]-1] + - dataset.cell_data[m][:,cind[1]-1,cind[2],cind[3]] + - dataset.cell_data[m][:,cind[1]-1,cind[2],cind[3]-1]) / 4 + _cd = + ( + dataset.cell_data[m][:, cind...] + + dataset.cell_data[m][:, cind[1:2]..., cind[3] - 1] + + dataset.cell_data[m][:, cind[1] - 1, cind[2], cind[3]] + + dataset.cell_data[m][:, cind[1] - 1, cind[2], cind[3] - 1] + ) / 4 elseif cind[1] == 1 && cind[3] != 1 - _cd = (dataset.cell_data[m][:,cind...] + - dataset.cell_data[m][:,cind[1:2]...,cind[3]-1]) / 2 + _cd = + ( + dataset.cell_data[m][:, cind...] + + dataset.cell_data[m][:, cind[1:2]..., cind[3] - 1] + ) / 2 elseif cind[1] != 1 && cind[3] == 1 - _cd = (dataset.cell_data[m][:,cind...] + - dataset.cell_data[m][:,cind[1]-1, cind[2],cind[3]]) / 2 + _cd = + ( + dataset.cell_data[m][:, cind...] + + dataset.cell_data[m][:, cind[1] - 1, cind[2], cind[3]] + ) / 2 elseif cind[1] == cind[3] == 1 - _cd = dataset.cell_data[m][:,cind...] + _cd = dataset.cell_data[m][:, cind...] end append!(_cell_data[m], _cd) end @@ -435,34 +503,52 @@ function decompose_to_lines_3d_with_cell_data(dataset::VTKStructuredData) _var_dim = var_dim(dataset, m, "Cell") if _var_dim == 1 if cind[1] != 1 && cind[2] != 1 - _cd = (dataset.cell_data[m][cind...] + - dataset.cell_data[m][cind[1]-1,cind[2:3]...] + - dataset.cell_data[m][cind[1],cind[2]-1,cind[3]] + - dataset.cell_data[m][cind[1]-1,cind[2]-1,cind[3]]) / 4 + _cd = + ( + dataset.cell_data[m][cind...] + + dataset.cell_data[m][cind[1] - 1, cind[2:3]...] + + dataset.cell_data[m][cind[1], cind[2] - 1, cind[3]] + + dataset.cell_data[m][cind[1] - 1, cind[2] - 1, cind[3]] + ) / 4 elseif cind[1] == 1 && cind[2] != 1 - _cd = (dataset.cell_data[m][cind...] + - dataset.cell_data[m][cind[1],cind[2]-1,cind[3]]) / 2 + _cd = + ( + dataset.cell_data[m][cind...] + + dataset.cell_data[m][cind[1], cind[2] - 1, cind[3]] + ) / 2 elseif cind[1] != 1 && cind[2] == 1 - _cd = (dataset.cell_data[m][cind...] + - dataset.cell_data[m][cind[1]-1,cind[2],cind[3]]) / 2 + _cd = + ( + dataset.cell_data[m][cind...] + + dataset.cell_data[m][cind[1] - 1, cind[2], cind[3]] + ) / 2 elseif cind[1] == cind[2] == 1 _cd = dataset.cell_data[m][cind...] end push!(_cell_data[m], _cd) else if cind[1] != 1 && cind[2] != 1 - _cd = (dataset.cell_data[m][:,cind...] + - dataset.cell_data[m][:,cind[1]-1,cind[2:3]...] + - dataset.cell_data[m][:,cind[1],cind[2]-1,cind[3]] + - dataset.cell_data[m][:,cind[1]-1,cind[2]-1,cind[3]]) / 4 + _cd = + ( + dataset.cell_data[m][:, cind...] + + dataset.cell_data[m][:, cind[1] - 1, cind[2:3]...] + + dataset.cell_data[m][:, cind[1], cind[2] - 1, cind[3]] + + dataset.cell_data[m][:, cind[1] - 1, cind[2] - 1, cind[3]] + ) / 4 elseif cind[1] == 1 && cind[2] != 1 - _cd = (dataset.cell_data[m][:,cind...] + - dataset.cell_data[m][:,cind[1],cind[2]-1,cind[3]]) / 2 + _cd = + ( + dataset.cell_data[m][:, cind...] + + dataset.cell_data[m][:, cind[1], cind[2] - 1, cind[3]] + ) / 2 elseif cind[1] != 1 && cind[2] == 1 - _cd = (dataset.cell_data[m][:,cind...] + - dataset.cell_data[m][:,cind[1]-1,cind[2],cind[3]]) / 2 + _cd = + ( + dataset.cell_data[m][:, cind...] + + dataset.cell_data[m][:, cind[1] - 1, cind[2], cind[3]] + ) / 2 elseif cind[1] == cind[2] == 1 - _cd = dataset.cell_data[m][:,cind...] + _cd = dataset.cell_data[m][:, cind...] end append!(_cell_data[m], _cd) end @@ -474,18 +560,24 @@ function decompose_to_lines_3d_with_cell_data(dataset::VTKStructuredData) _var_dim = var_dim(dataset, m, "Cell") if _var_dim == 1 if cind[3] != 1 - _cd = (dataset.cell_data[m][cind...] + - dataset.cell_data[m][cind[1:2]..., cind[3]-1]) / 2 + _cd = + ( + dataset.cell_data[m][cind...] + + dataset.cell_data[m][cind[1:2]..., cind[3] - 1] + ) / 2 else _cd = dataset.cell_data[m][cind...] end push!(_cell_data[m], _cd) else if cind[3] != 1 - _cd = (dataset.cell_data[m][:,cind...] + - dataset.cell_data[m][:,cind[1:2]...,cind[3]-1]) / 2 + _cd = + ( + dataset.cell_data[m][:, cind...] + + dataset.cell_data[m][:, cind[1:2]..., cind[3] - 1] + ) / 2 else - _cd = dataset.cell_data[m][:,cind...] + _cd = dataset.cell_data[m][:, cind...] end append!(_cell_data[m], _cd) end @@ -496,18 +588,24 @@ function decompose_to_lines_3d_with_cell_data(dataset::VTKStructuredData) _var_dim = var_dim(dataset, m, "Cell") if _var_dim == 1 if cind[2] != cextents[2] - _cd = (dataset.cell_data[m][cind...] + - dataset.cell_data[m][cind[1], cind[2]+1, cind[3]]) / 2 + _cd = + ( + dataset.cell_data[m][cind...] + + dataset.cell_data[m][cind[1], cind[2] + 1, cind[3]] + ) / 2 else _cd = dataset.cell_data[m][cind...] end push!(_cell_data[m], _cd) else if cind[2] != cextents[2] - _cd = (dataset.cell_data[m][:,cind...] + - dataset.cell_data[m][:,cind[1],cind[2]+1,cind[3]]) / 2 + _cd = + ( + dataset.cell_data[m][:, cind...] + + dataset.cell_data[m][:, cind[1], cind[2] + 1, cind[3]] + ) / 2 else - _cd = dataset.cell_data[m][:,cind...] + _cd = dataset.cell_data[m][:, cind...] end append!(_cell_data[m], _cd) end @@ -518,18 +616,24 @@ function decompose_to_lines_3d_with_cell_data(dataset::VTKStructuredData) _var_dim = var_dim(dataset, m, "Cell") if _var_dim == 1 if cind[3] != cextents[3] - _cd = (dataset.cell_data[m][cind...] + - dataset.cell_data[m][cind[1:2]..., cind[3]+1]) / 2 + _cd = + ( + dataset.cell_data[m][cind...] + + dataset.cell_data[m][cind[1:2]..., cind[3] + 1] + ) / 2 else _cd = dataset.cell_data[m][cind...] end push!(_cell_data[m], _cd) else if cind[3] != cextents[3] - _cd = (dataset.cell_data[m][:,cind...] + - dataset.cell_data[m][:,cind[1:2]...,cind[3]+1]) / 2 + _cd = + ( + dataset.cell_data[m][:, cind...] + + dataset.cell_data[m][:, cind[1:2]..., cind[3] + 1] + ) / 2 else - _cd = dataset.cell_data[m][:,cind...] + _cd = dataset.cell_data[m][:, cind...] end append!(_cell_data[m], _cd) end @@ -540,16 +644,22 @@ function decompose_to_lines_3d_with_cell_data(dataset::VTKStructuredData) _var_dim = var_dim(dataset, m, "Cell") if _var_dim == 1 if cind[2] != 1 - _cd = (dataset.cell_data[m][cind...] + - dataset.cell_data[m][cind[1], cind[2]-1, cind[3]]) / 2 + _cd = + ( + dataset.cell_data[m][cind...] + + dataset.cell_data[m][cind[1], cind[2] - 1, cind[3]] + ) / 2 else _cd = dataset.cell_data[m][cind...] end push!(_cell_data[m], _cd) else if cind[2] != 1 - _cd = (dataset.cell_data[m][:, cind...] + - dataset.cell_data[m][:, cind[1], cind[2]-1, cind[3]]) / 2 + _cd = + ( + dataset.cell_data[m][:, cind...] + + dataset.cell_data[m][:, cind[1], cind[2] - 1, cind[3]] + ) / 2 else _cd = dataset.cell_data[m][:, cind...] end @@ -563,16 +673,22 @@ function decompose_to_lines_3d_with_cell_data(dataset::VTKStructuredData) _var_dim = var_dim(dataset, m, "Cell") if _var_dim == 1 if cind[3] != 1 - _cd = (dataset.cell_data[m][cind...] + - dataset.cell_data[m][cind[1:2]..., cind[3]-1]) / 2 + _cd = + ( + dataset.cell_data[m][cind...] + + dataset.cell_data[m][cind[1:2]..., cind[3] - 1] + ) / 2 else _cd = dataset.cell_data[m][cind...] end push!(_cell_data[m], _cd) else if cind[3] != 1 - _cd = (dataset.cell_data[m][:, cind...] + - dataset.cell_data[m][:, cind[1:2]..., cind[3]-1]) / 2 + _cd = + ( + dataset.cell_data[m][:, cind...] + + dataset.cell_data[m][:, cind[1:2]..., cind[3] - 1] + ) / 2 else _cd = dataset.cell_data[m][:, cind...] end @@ -585,16 +701,22 @@ function decompose_to_lines_3d_with_cell_data(dataset::VTKStructuredData) _var_dim = var_dim(dataset, m, "Cell") if _var_dim == 1 if cind[3] != cextents[3] - _cd = (dataset.cell_data[m][cind...] + - dataset.cell_data[m][cind[1:2]..., cind[3]+1]) / 2 + _cd = + ( + dataset.cell_data[m][cind...] + + dataset.cell_data[m][cind[1:2]..., cind[3] + 1] + ) / 2 else _cd = dataset.cell_data[m][cind...] end push!(_cell_data[m], _cd) else if cind[3] != cextents[3] - _cd = (dataset.cell_data[m][:, cind...] + - dataset.cell_data[m][:, cind[1:2]..., cind[3]+1]) / 2 + _cd = + ( + dataset.cell_data[m][:, cind...] + + dataset.cell_data[m][:, cind[1:2]..., cind[3] + 1] + ) / 2 else _cd = dataset.cell_data[m][:, cind...] end @@ -607,16 +729,22 @@ function decompose_to_lines_3d_with_cell_data(dataset::VTKStructuredData) _var_dim = var_dim(dataset, m, "Cell") if _var_dim == 1 if cind[1] != 1 - _cd = (dataset.cell_data[m][cind...] + - dataset.cell_data[m][cind[1]-1, cind[2:3]...]) / 2 + _cd = + ( + dataset.cell_data[m][cind...] + + dataset.cell_data[m][cind[1] - 1, cind[2:3]...] + ) / 2 else _cd = dataset.cell_data[m][cind...] end push!(_cell_data[m], _cd) else if cind[1] != 1 - _cd = (dataset.cell_data[m][:, cind...] + - dataset.cell_data[m][:, cind[1]-1, cind[2:3]...]) / 2 + _cd = + ( + dataset.cell_data[m][:, cind...] + + dataset.cell_data[m][:, cind[1] - 1, cind[2:3]...] + ) / 2 else _cd = dataset.cell_data[m][:, cind...] end @@ -630,16 +758,22 @@ function decompose_to_lines_3d_with_cell_data(dataset::VTKStructuredData) _var_dim = var_dim(dataset, m, "Cell") if _var_dim == 1 if cind[1] != 1 - _cd = (dataset.cell_data[m][cind...] + - dataset.cell_data[m][cind[1]-1, cind[2:3]...]) / 2 + _cd = + ( + dataset.cell_data[m][cind...] + + dataset.cell_data[m][cind[1] - 1, cind[2:3]...] + ) / 2 else _cd = dataset.cell_data[m][cind...] end push!(_cell_data[m], _cd) else if cind[1] != 1 - _cd = (dataset.cell_data[m][:, cind...] + - dataset.cell_data[m][:, cind[1]-1, cind[2:3]...]) / 2 + _cd = + ( + dataset.cell_data[m][:, cind...] + + dataset.cell_data[m][:, cind[1] - 1, cind[2:3]...] + ) / 2 else _cd = dataset.cell_data[m][:, cind...] end @@ -652,16 +786,22 @@ function decompose_to_lines_3d_with_cell_data(dataset::VTKStructuredData) _var_dim = var_dim(dataset, m, "Cell") if _var_dim == 1 if cind[2] != 1 - _cd = (dataset.cell_data[m][cind...] + - dataset.cell_data[m][cind[1], cind[2]-1, cind[3]]) / 2 + _cd = + ( + dataset.cell_data[m][cind...] + + dataset.cell_data[m][cind[1], cind[2] - 1, cind[3]] + ) / 2 else _cd = dataset.cell_data[m][cind...] end push!(_cell_data[m], _cd) else if cind[2] != 1 - _cd = (dataset.cell_data[m][:, cind...] + - dataset.cell_data[m][:, cind[1], cind[2]-1, cind[3]]) / 2 + _cd = + ( + dataset.cell_data[m][:, cind...] + + dataset.cell_data[m][:, cind[1], cind[2] - 1, cind[3]] + ) / 2 else _cd = dataset.cell_data[m][:, cind...] end diff --git a/src/decompose_unstruct.jl b/src/decompose_unstruct.jl index 75068d5..42cc76f 100644 --- a/src/decompose_unstruct.jl +++ b/src/decompose_unstruct.jl @@ -1,4 +1,6 @@ -function decompose(dataset::AbstractVTKUnstructuredData, target::String = "Faces", decompose_cell_data = false) +function decompose( + dataset::AbstractVTKUnstructuredData, target::String="Faces", decompose_cell_data=false +) if decompose_cell_data return decompose_with_cell_data(dataset, target) else @@ -10,7 +12,9 @@ mutable struct _Counter a::Int end -function decompose_with_cell_data(dataset::AbstractVTKUnstructuredData, target::String="Faces") +function decompose_with_cell_data( + dataset::AbstractVTKUnstructuredData, target::String="Faces" +) if target == "Faces" filter_cells!(dataset, [POINT_CELLS; LINE_CELLS]) elseif target == "Lines" @@ -19,17 +23,22 @@ function decompose_with_cell_data(dataset::AbstractVTKUnstructuredData, target:: point_coords = dataset.point_coords point_data = dataset.point_data - + #Sorted inds and cell type are keys #Cell connectivity, cell count, and cell data are the values - cell_register = Dict{Tuple{Vector{Int}, Int}, Tuple{Vector{Int}, _Counter, typeof(dataset.cell_data)}}() + cell_register = Dict{ + Tuple{Vector{Int},Int},Tuple{Vector{Int},_Counter,typeof(dataset.cell_data)} + }() for i in 1:length(dataset.cell_connectivity) if target == "Points" - _cells, _types = [[k] for k in dataset.cell_connectivity[i]], [1 for k in 1:length(dataset.cell_connectivity[i])] + _cells, _types = [[k] for k in dataset.cell_connectivity[i]], + [1 for k in 1:length(dataset.cell_connectivity[i])] else - _cells, _types = decompose_cell(dataset.cell_connectivity[i], dataset.cell_types[i], target=target) - end + _cells, _types = decompose_cell( + dataset.cell_connectivity[i], dataset.cell_types[i]; target=target + ) + end for j in 1:length(_cells) _key = (sort(_cells[j]), _types[j]) if haskey(cell_register, _key) @@ -39,7 +48,7 @@ function decompose_with_cell_data(dataset::AbstractVTKUnstructuredData, target:: if _var_dim == 1 cell_register[_key][3][m] += dataset.cell_data[m][i:i] else - @views cell_register[_key][3][m] += dataset.cell_data[m][:,i:i] + @views cell_register[_key][3][m] += dataset.cell_data[m][:, i:i] end end else @@ -49,7 +58,7 @@ function decompose_with_cell_data(dataset::AbstractVTKUnstructuredData, target:: if _var_dim == 1 cell_register[_key][3][m] = dataset.cell_data[m][i:i] else - @views cell_register[_key][3][m] = dataset.cell_data[m][:,i:i] + @views cell_register[_key][3][m] = dataset.cell_data[m][:, i:i] end end end @@ -78,7 +87,7 @@ function decompose_with_cell_data(dataset::AbstractVTKUnstructuredData, target:: if _var_dim == 1 cell_data[m][i] = v[3][m][1] else - cell_data[m][:,i:i] = v[3][m] + cell_data[m][:, i:i] = v[3][m] end end _cell_connectivity[i] = v[1] @@ -88,9 +97,9 @@ function decompose_with_cell_data(dataset::AbstractVTKUnstructuredData, target:: return VTKPolyData(point_coords, _cell_types, _cell_connectivity, point_data, cell_data) end -function decompose_no_cell_data(dataset::AbstractVTKUnstructuredData, - target::String = "Faces" - ) +function decompose_no_cell_data( + dataset::AbstractVTKUnstructuredData, target::String="Faces" +) if target == "Faces" filter_cells!(dataset, [POINT_CELLS; LINE_CELLS]) elseif target == "Lines" @@ -99,16 +108,19 @@ function decompose_no_cell_data(dataset::AbstractVTKUnstructuredData, point_coords = dataset.point_coords point_data = dataset.point_data - + #Sorted inds and cell type are keys #Cell connectivity is the value - cell_register = Dict{Tuple{Vector{Int}, Int}, Vector{Int}}() + cell_register = Dict{Tuple{Vector{Int},Int},Vector{Int}}() for i in 1:length(dataset.cell_connectivity) if target == "Points" - _cells, _types = [[k] for k in dataset.cell_connectivity[i]], [1 for k in 1:length(dataset.cell_connectivity[i])] + _cells, _types = [[k] for k in dataset.cell_connectivity[i]], + [1 for k in 1:length(dataset.cell_connectivity[i])] else - _cells, _types = decompose_cell(dataset.cell_connectivity[i], dataset.cell_types[i], target=target) - end + _cells, _types = decompose_cell( + dataset.cell_connectivity[i], dataset.cell_types[i]; target=target + ) + end for j in 1:length(_cells) _key = (sort(_cells[j]), _types[j]) if !haskey(cell_register, _key) diff --git a/src/properties_utils.jl b/src/properties_utils.jl index 11741a2..f2d9634 100644 --- a/src/properties_utils.jl +++ b/src/properties_utils.jl @@ -1,8 +1,9 @@ -function similar_cells( cell_connectivity1::Vector{Int}, - cell_type1::Int, - cell_connectivity2::Union{Tuple{Vararg{Int}}, Vector{Int}}, - cell_type2::Int - ) +function similar_cells( + cell_connectivity1::Vector{Int}, + cell_type1::Int, + cell_connectivity2::Union{Tuple{Vararg{Int}},Vector{Int}}, + cell_type2::Int, +) for k in cell_connectivity2 in(k, cell_connectivity1) || return false end @@ -11,13 +12,13 @@ function similar_cells( cell_connectivity1::Vector{Int}, end function coherent(a::T, b::T) where {T<:AbstractVTKMultiblockData} - return same_ordered_geometry_shape(a,b) && same_data_shape(a,b) + return same_ordered_geometry_shape(a, b) && same_data_shape(a, b) end function coherent(a::T, b::T) where {T<:AbstractVTKSimpleData} return same_geometry_shape(a, b) && same_data_shape(a, b) end function coherent(dataset::AbstractTimeSeriesVTKData) - length(dataset) == 0 && return true + length(dataset) == 0 && return true block1 = dataset[1] for block in dataset[2:end] coherent(block1, block) || return false @@ -25,28 +26,34 @@ function coherent(dataset::AbstractTimeSeriesVTKData) return true end function coherent(a::T, b::T) where {T<:AbstractTimeSeriesVTKData} - length(a) == length(b) && - coherent(a) && coherent(b) && begin - _out = true - for i in 1:length(a) - (_out = coherent(a[i], b[i])) || break - end - _out - end || return false + length(a) == length(b) && + coherent(a) && + coherent(b) && + begin + _out = true + for i in 1:length(a) + (_out = coherent(a[i], b[i])) || break + end + _out + end || return false return true end coherent(a::AbstractVTKData, b::AbstractVTKData) = false extents(dataset::VTKStructuredData) = Base.tail(size(dataset.point_coords)) function extents(dataset::VTKRectilinearData) - return ntuple(i->length(dataset.point_coords[i]), Val(length(dataset.point_coords))) + return ntuple(i -> length(dataset.point_coords[i]), Val(length(dataset.point_coords))) end extents(dataset::VTKUniformRectilinearData) = dataset.extents extents(dataset::AbstractVTKStructuredData, ind::Int) = extents(dataset)[ind] extents(dataset::AbstractVTKStructuredData, ind::Int...) = extents.(Ref(dataset), ind) -cell_extents(dataset::AbstractVTKStructuredData) = ntuple(i -> extents(dataset, i) .- 1, dim(dataset)) +function cell_extents(dataset::AbstractVTKStructuredData) + return ntuple(i -> extents(dataset, i) .- 1, dim(dataset)) +end cell_extents(dataset::AbstractVTKStructuredData, ind::Int) = cell_extents(dataset)[ind] -cell_extents(dataset::AbstractVTKStructuredData, ind::Int...) = cell_extents.(Ref(dataset), ind) +function cell_extents(dataset::AbstractVTKStructuredData, ind::Int...) + return cell_extents.(Ref(dataset), ind) +end dim(dataset::AbstractVTKUnstructuredData) = size(dataset.point_coords, 1) dim(dataset::AbstractVTKStructuredData) = length(extents(dataset)) @@ -57,7 +64,7 @@ end num_of_points(dataset::AbstractVTKUnstructuredData) = size(dataset.point_coords, 2) num_of_points(dataset::AbstractVTKStructuredData) = prod(extents(dataset)) num_of_points(dataset::AbstractVTKMultiblockData) = sum(num_of_points(i) for i in dataset) -num_of_points(dataset::AbstractTimeSeriesVTKData, ind::Int=1) = num_of_points(dataset[ind]) +num_of_points(dataset::AbstractTimeSeriesVTKData, ind::Int=1) = num_of_points(dataset[ind]) num_of_cells(dataset::AbstractVTKUnstructuredData) = length(dataset.cell_types) num_of_cells(dataset::AbstractVTKStructuredData) = prod(extents(dataset) .- 1) @@ -67,10 +74,10 @@ num_of_cells(dataset::AbstractTimeSeriesVTKData, ind::Int=1) = num_of_cells(data num_of_point_vars(dataset::AbstractVTKSimpleData) = length(dataset.point_data) num_of_cell_vars(dataset::AbstractVTKSimpleData) = length(dataset.cell_data) -function cell_type(dataset::Union{VTKUnstructuredData, VTKPolyData}, ind::Int) +function cell_type(dataset::Union{VTKUnstructuredData,VTKPolyData}, ind::Int) return dataset.cell_types[ind] end -function cell_type(dataset::Union{VTKStructuredData, VTKRectilinearData}, ind::Int) +function cell_type(dataset::Union{VTKStructuredData,VTKRectilinearData}, ind::Int) if ind < 1 || ind > num_of_cells(dataset) throw("Out of bounds.") else @@ -91,7 +98,9 @@ end function cell_connectivity(dataset::AbstractVTKUnstructuredData, cell_ind::Int) return dataset.cell_connectivity[cell_ind] end -function cell_connectivity(dataset::T, cell_ind::Tuple{Vararg{Int}}) where {T<:AbstractVTKStructuredData} +function cell_connectivity( + dataset::T, cell_ind::Tuple{Vararg{Int}} +) where {T<:AbstractVTKStructuredData} pextents = extents(dataset) return cell_connectivity(T, pextents, cell_ind) end @@ -100,31 +109,51 @@ function cell_connectivity(dataset::T, cell_ind) where {T<:AbstractVTKStructured return cell_connectivity(T, extents(dataset), cell_ind) end -function cell_connectivity(T::DataType, pextents::NTuple{N,Int}, cell_ind::NTuple{N,Int}) where {N} +function cell_connectivity( + T::DataType, pextents::NTuple{N,Int}, cell_ind::NTuple{N,Int} +) where {N} corner_point_ind = (LinearIndices(pextents))[cell_ind...] - if N == 2 + if N == 2 #1 <= cell_ind <= num_of_cells(dataset) || throw("Out of bounds.") if T <: VTKUniformRectilinearData - return [corner_point_ind, corner_point_ind + 1, corner_point_ind + pextents[1], - corner_point_ind + pextents[1] + 1] + return [ + corner_point_ind, + corner_point_ind + 1, + corner_point_ind + pextents[1], + corner_point_ind + pextents[1] + 1, + ] else - return [corner_point_ind, corner_point_ind + 1, corner_point_ind + pextents[1] + 1, - corner_point_ind + pextents[1]] + return [ + corner_point_ind, + corner_point_ind + 1, + corner_point_ind + pextents[1] + 1, + corner_point_ind + pextents[1], + ] end elseif N == 3 #1 <= cell_ind <= num_of_cells(dataset) || throw("Out of bounds.") if T <: VTKUniformRectilinearData - return [corner_point_ind, corner_point_ind + 1, corner_point_ind + pextents[1], - corner_point_ind + pextents[1] + 1, - corner_point_ind + pextents[1] * pextents[2], - corner_point_ind + pextents[1] * pextents[2] + 1, - corner_point_ind + pextents[1] * pextents[2] + pextents[1], - corner_point_ind + pextents[1] * pextents[2] + pextents[1] + 1] + return [ + corner_point_ind, + corner_point_ind + 1, + corner_point_ind + pextents[1], + corner_point_ind + pextents[1] + 1, + corner_point_ind + pextents[1] * pextents[2], + corner_point_ind + pextents[1] * pextents[2] + 1, + corner_point_ind + pextents[1] * pextents[2] + pextents[1], + corner_point_ind + pextents[1] * pextents[2] + pextents[1] + 1, + ] else - return [corner_point_ind, corner_point_ind + 1, corner_point_ind + pextents[1] + 1, corner_point_ind + pextents[1], - corner_point_ind + pextents[1] * pextents[2], - corner_point_ind + pextents[1] * pextents[2] + 1, - corner_point_ind + pextents[1] * pextents[2] + pextents[1] + 1, corner_point_ind + pextents[1] * pextents[2] + pextents[1]] + return [ + corner_point_ind, + corner_point_ind + 1, + corner_point_ind + pextents[1] + 1, + corner_point_ind + pextents[1], + corner_point_ind + pextents[1] * pextents[2], + corner_point_ind + pextents[1] * pextents[2] + 1, + corner_point_ind + pextents[1] * pextents[2] + pextents[1] + 1, + corner_point_ind + pextents[1] * pextents[2] + pextents[1], + ] end end @@ -141,27 +170,31 @@ function has_var(dataset::AbstractStaticVTKData, var_name::String) end end -function var_dim(dataset::AbstractVTKUnstructuredData, var_name::String, var_type::String="") +function var_dim( + dataset::AbstractVTKUnstructuredData, var_name::String, var_type::String="" +) if var_type == "Point" && haskey(dataset.point_data, var_name) if length(size(dataset.point_data[var_name])) == 1 return 1 else - return length(dataset.point_data[var_name][:,1]) + return length(dataset.point_data[var_name][:, 1]) end elseif var_type == "Cell" && haskey(dataset.cell_data, var_name) if length(size(dataset.cell_data[var_name])) == 1 return 1 else - return length(dataset.cell_data[var_name][:,1]) + return length(dataset.cell_data[var_name][:, 1]) end elseif var_type == "" - try + try return var_dim(dataset, var_name, "Point") catch return var_dim(dataset, var_name, "Cell") end else - throw("Variable $var_name doesn't exist, please use has_var to check if the variable exists before using this function.") + throw( + "Variable $var_name doesn't exist, please use has_var to check if the variable exists before using this function.", + ) end end @@ -179,13 +212,15 @@ function var_dim(dataset::AbstractVTKStructuredData, var_name::String, var_type: return size(dataset.cell_data[var_name], 1) end elseif var_type == "" - try + try return var_dim(dataset, var_name, "Point") catch return var_dim(dataset, var_name, "Cell") end else - throw("Variable $var_name doesn't exist, please use has_var to check if the variable exists before using this function.") + throw( + "Variable $var_name doesn't exist, please use has_var to check if the variable exists before using this function.", + ) end end @@ -209,21 +244,22 @@ function is_homogeneous(dataset::AbstractVTKMultiblockData) return all(i -> typeof(dataset[1]) == typeof(dataset[i]), 2:length(dataset)) end function is_homogeneous(dataset::AbstractTimeSeriesVTKData) - length(dataset) == 0 || - is_homogeneous(dataset[1]) && begin - out = true - i = dataset[1] - T = typeof(i) - for j in dataset - (out = isa(j, T)) || break - if T <: AbstractVTKMultiblockData || T <: AbstractVTKUnstructuredData - (out = same_ordered_geometry_shape(i,j)) || break - else - (out = same_geometry_shape(i,j)) || break + length(dataset) == 0 || + is_homogeneous(dataset[1]) && begin + out = true + i = dataset[1] + T = typeof(i) + for j in dataset + (out = isa(j, T)) || break + if T <: AbstractVTKMultiblockData || T <: AbstractVTKUnstructuredData + (out = same_ordered_geometry_shape(i, j)) || break + else + (out = same_geometry_shape(i, j)) || break + end end - end - out - end || return false + out + end || + return false return true end @@ -244,8 +280,8 @@ function get_highest_index(cell_connectivity) return maximum(i -> maximum(cell_connectivity[i]), 1:length(cell_connectivity)) end function is_valid_cell(cell_connectivity, cell_type) - return VTK_CELL_TYPE[cell_type].nodes == -1 || - length(_cell_connectivity) == VTK_CELL_TYPE[cell_type].nodes + return VTK_CELL_TYPE[cell_type].nodes == -1 || + length(_cell_connectivity) == VTK_CELL_TYPE[cell_type].nodes end num_of_blocks(dataset::AbstractVTKMultiblockData) = length(dataset.blocks) @@ -264,7 +300,7 @@ function bb(dataset::T) where {T<:AbstractVTKData} return bb_rect(dataset) elseif T <: VTKUniformRectilinearData return bb_image(dataset) - elseif T <: Union{AbstractVTKMultiblockData, AbstractTimeSeriesVTKData} + elseif T <: Union{AbstractVTKMultiblockData,AbstractTimeSeriesVTKData} return bb_multiblock_time(dataset) end throw("Unsupported type.") @@ -272,42 +308,42 @@ end function bb_unstruct(dataset::AbstractVTKUnstructuredData) _dim = dim(dataset) - min_x = max_x = dataset.point_coords[1,1] - min_y = max_y = dataset.point_coords[2,1] + min_x = max_x = dataset.point_coords[1, 1] + min_y = max_y = dataset.point_coords[2, 1] if _dim == 2 for i in 2:num_of_points(dataset) - if dataset.point_coords[1,i] > max_x - max_x = dataset.point_coords[1,i] - elseif dataset.point_coords[1,i] < min_x - min_x = dataset.point_coords[1,i] + if dataset.point_coords[1, i] > max_x + max_x = dataset.point_coords[1, i] + elseif dataset.point_coords[1, i] < min_x + min_x = dataset.point_coords[1, i] end - - if dataset.point_coords[2,i] > max_y - max_y = dataset.point_coords[2,i] - elseif dataset.point_coords[2,i] < min_y - min_y = dataset.point_coords[2,i] + + if dataset.point_coords[2, i] > max_y + max_y = dataset.point_coords[2, i] + elseif dataset.point_coords[2, i] < min_y + min_y = dataset.point_coords[2, i] end end return (min_x, max_x, min_y, max_y) elseif _dim == 3 - min_z = max_z = dataset.point_coords[3,1] + min_z = max_z = dataset.point_coords[3, 1] for i in 2:num_of_points(dataset) - if dataset.point_coords[1,i] > max_x - max_x = dataset.point_coords[1,i] - elseif dataset.point_coords[1,i] < min_x - min_x = dataset.point_coords[1,i] + if dataset.point_coords[1, i] > max_x + max_x = dataset.point_coords[1, i] + elseif dataset.point_coords[1, i] < min_x + min_x = dataset.point_coords[1, i] end - - if dataset.point_coords[2,i] > max_y - max_y = dataset.point_coords[2,i] - elseif dataset.point_coords[2,i] < min_y - min_y = dataset.point_coords[2,i] + + if dataset.point_coords[2, i] > max_y + max_y = dataset.point_coords[2, i] + elseif dataset.point_coords[2, i] < min_y + min_y = dataset.point_coords[2, i] end - if dataset.point_coords[3,i] > max_z - max_z = dataset.point_coords[3,i] - elseif dataset.point_coords[3,i] < min_z - min_z = dataset.point_coords[3,i] + if dataset.point_coords[3, i] > max_z + max_z = dataset.point_coords[3, i] + elseif dataset.point_coords[3, i] < min_z + min_z = dataset.point_coords[3, i] end end return (min_x, max_x, min_y, max_y, min_z, max_z) @@ -321,50 +357,50 @@ end if dim(dataset) == 2 i = 1 for j in 1:cextents[2] - @yield (i,j) + @yield (i, j) end j = 1 for i in 2:cextents[1] - @yield (i,j) + @yield (i, j) end i = cextents[1] for j in 2:cextents[2] - @yield (i,j) + @yield (i, j) end j = cextents[2] - for i in 2:cextents[1]-1 - @yield (i,j) + for i in 2:(cextents[1] - 1) + @yield (i, j) end else i = 1 for j in 1:cextents[2], k in 1:cextents[3] - @yield (i,j,k) + @yield (i, j, k) end - + j = 1 for i in 2:cextents[1], k in 1:cextents[3] - @yield (i,j,k) + @yield (i, j, k) end k = 1 for i in 2:cextents[1], j in 2:cextents[2] - @yield (i,j,k) + @yield (i, j, k) end i = cextents[1] for j in 2:cextents[2], k in 2:cextents[3] - @yield (i,j,k) + @yield (i, j, k) end - + j = cextents[2] - for i in 2:cextents[1]-1, k in 2:cextents[3] - @yield (i,j,k) + for i in 2:(cextents[1] - 1), k in 2:cextents[3] + @yield (i, j, k) end k = cextents[3] - for i in 2:cextents[1]-1, j in 2:cextents[3]-1 - @yield (i,j,k) + for i in 2:(cextents[1] - 1), j in 2:(cextents[3] - 1) + @yield (i, j, k) end end end @@ -373,42 +409,42 @@ function bb_struct(dataset::VTKStructuredData) cextents = cell_extents(dataset) _dim = dim(dataset) - min_x = max_x = dataset.point_coords[1,1] - min_y = max_y = dataset.point_coords[2,1] + min_x = max_x = dataset.point_coords[1, 1] + min_y = max_y = dataset.point_coords[2, 1] if _dim == 2 - for (i,j) in surface_cell_inds(dataset) - if dataset.point_coords[1,i] > max_x - max_x = dataset.point_coords[1,i] - elseif dataset.point_coords[1,i] < min_x - min_x = dataset.point_coords[1,i] + for (i, j) in surface_cell_inds(dataset) + if dataset.point_coords[1, i] > max_x + max_x = dataset.point_coords[1, i] + elseif dataset.point_coords[1, i] < min_x + min_x = dataset.point_coords[1, i] end - - if dataset.point_coords[2,i] > max_y - max_y = dataset.point_coords[2,i] - elseif dataset.point_coords[2,i] < min_y - min_y = dataset.point_coords[2,i] + + if dataset.point_coords[2, i] > max_y + max_y = dataset.point_coords[2, i] + elseif dataset.point_coords[2, i] < min_y + min_y = dataset.point_coords[2, i] end end return (min_x, max_x, min_y, max_y) elseif _dim == 3 - min_z = max_z = dataset.point_coords[3,1] - for (i,j,k) in surface_cell_inds(dataset) - if dataset.point_coords[1,i] > max_x - max_x = dataset.point_coords[1,i] - elseif dataset.point_coords[1,i] < min_x - min_x = dataset.point_coords[1,i] + min_z = max_z = dataset.point_coords[3, 1] + for (i, j, k) in surface_cell_inds(dataset) + if dataset.point_coords[1, i] > max_x + max_x = dataset.point_coords[1, i] + elseif dataset.point_coords[1, i] < min_x + min_x = dataset.point_coords[1, i] end - - if dataset.point_coords[2,i] > max_y - max_y = dataset.point_coords[2,i] - elseif dataset.point_coords[2,i] < min_y - min_y = dataset.point_coords[2,i] + + if dataset.point_coords[2, i] > max_y + max_y = dataset.point_coords[2, i] + elseif dataset.point_coords[2, i] < min_y + min_y = dataset.point_coords[2, i] end - if dataset.point_coords[3,i] > max_z - max_z = dataset.point_coords[3,i] - elseif dataset.point_coords[3,i] < min_z - min_z = dataset.point_coords[3,i] + if dataset.point_coords[3, i] > max_z + max_z = dataset.point_coords[3, i] + elseif dataset.point_coords[3, i] < min_z + min_z = dataset.point_coords[3, i] end end return (min_x, max_x, min_y, max_y, min_z, max_z) @@ -436,22 +472,24 @@ end function bb_image(dataset::VTKUniformRectilinearData) min_x = dataset.origin[1] - max_x = dataset.origin[1] + (dataset.extents[1]-1)*dataset.spacing[1] + max_x = dataset.origin[1] + (dataset.extents[1] - 1) * dataset.spacing[1] min_x = dataset.origin[2] - max_x = dataset.origin[2] + (dataset.extents[2]-1)*dataset.spacing[2] + max_x = dataset.origin[2] + (dataset.extents[2] - 1) * dataset.spacing[2] if dim(dataset) == 2 return (min_x, max_x, min_y, max_y) elseif dim(dataset) == 3 min_x = dataset.origin[3] - max_x = dataset.origin[3] + (dataset.extents[3]-1)*dataset.spacing[3] + max_x = dataset.origin[3] + (dataset.extents[3] - 1) * dataset.spacing[3] return (min_x, max_x, min_y, max_y, min_z, max_z) else throw("Invalid dimension.") end end -function bb_multiblock_time(dataset::Union{AbstractVTKMultiblockData, AbstractTimeSeriesVTKData}) +function bb_multiblock_time( + dataset::Union{AbstractVTKMultiblockData,AbstractTimeSeriesVTKData} +) _bbs = [bb(block) for block in dataset] min_x = minimum(i -> _bbs[i][1], 1:length(_bbs)) max_x = maximum(i -> _bbs[i][2], 1:length(_bbs)) @@ -485,5 +523,5 @@ end function pseudo_center(dataset::T) where {T<:AbstractVTKData} _bb = bb(dataset) - return ntuple(i -> (_bb[2i-1] + _bb[2i])/2, Val(length(_bb)÷2)) + return ntuple(i -> (_bb[2i - 1] + _bb[2i]) / 2, Val(length(_bb) ÷ 2)) end diff --git a/src/surface.jl b/src/surface.jl index a401857..f75789b 100644 --- a/src/surface.jl +++ b/src/surface.jl @@ -27,7 +27,7 @@ function extract_surface(_dataset::AbstractVTKStructuredData) add_cell_data!(dataset, _cell_data, m, cind) end end - + if cind[2] == 1 push!(faces, [hexa_cc[1], hexa_cc[2], hexa_cc[6], hexa_cc[5]]) for m in keys(dataset.cell_data) @@ -74,20 +74,25 @@ function extract_surface(_dataset::AbstractVTKStructuredData) k = 0 for _face in faces - for (i,p) in enumerate(_face) + for (i, p) in enumerate(_face) _i = findfirst(point_inds, p) if _i > 0 _face[i] = _i else k += 1 - append!(_point_coords, dataset.point_coords[:,ind2sub(pextents, p)...]) + append!(_point_coords, dataset.point_coords[:, ind2sub(pextents, p)...]) push!(point_inds, p) for m in keys(dataset.point_data) _var_dim = var_dim(dataset, m, "Point") if _var_dim == 1 - push!(_point_data[m], dataset.point_data[m][ind2sub(pextents, p)...]) + push!( + _point_data[m], dataset.point_data[m][ind2sub(pextents, p)...] + ) else - append!(_point_data[m], dataset.point_data[m][:, ind2sub(pextents, p)...]) + append!( + _point_data[m], + dataset.point_data[m][:, ind2sub(pextents, p)...], + ) end end _face[i] = k @@ -130,7 +135,7 @@ function add_cell_data!(dataset, _cell_data, m, cind) _cd = dataset.cell_data[m][:, cind...] append!(_cell_data[m], _cd) end - return + return nothing end function extract_surface(dataset::T) where {T<:AbstractVTKUnstructuredData} @@ -140,14 +145,18 @@ function extract_surface(dataset::T) where {T<:AbstractVTKUnstructuredData} if dim(dataset) == 2 return VTKPolyData(dataset) end - + #Sorted inds and cell type are keys #Cell connectivity, cell count, and cell data are the values - cell_register = Dict{Tuple{Vector{Int}, Int}, Tuple{Vector{Int}, _Counter, typeof(dataset.cell_data)}}() + cell_register = Dict{ + Tuple{Vector{Int},Int},Tuple{Vector{Int},_Counter,typeof(dataset.cell_data)} + }() for i in 1:length(dataset.cell_connectivity) if dataset.cell_types[i] ∉ POLY_CELLS - _cells, _types = decompose_cell(dataset.cell_connectivity[i], dataset.cell_types[i], target="Faces") + _cells, _types = decompose_cell( + dataset.cell_connectivity[i], dataset.cell_types[i]; target="Faces" + ) else _cells, _types = [dataset.cell_connectivity[i]], [dataset.cell_types[i]] end @@ -162,7 +171,7 @@ function extract_surface(dataset::T) where {T<:AbstractVTKUnstructuredData} if _var_dim == 1 cell_register[_key][3][m] = [dataset.cell_data[m][i]] else - cell_register[_key][3][m] = dataset.cell_data[m][:,i] + cell_register[_key][3][m] = dataset.cell_data[m][:, i] end end end @@ -204,20 +213,20 @@ function extract_surface(dataset::T) where {T<:AbstractVTKUnstructuredData} k = 0 for _cc in _cell_connectivity - for (i,p) in enumerate(_cc) + for (i, p) in enumerate(_cc) _i = findfirst(point_inds, p) if _i > 0 _cc[i] = _i else k += 1 - append!(_point_coords, dataset.point_coords[:,p]) + append!(_point_coords, dataset.point_coords[:, p]) push!(point_inds, p) for m in keys(dataset.point_data) _var_dim = var_dim(dataset, m, "Point") if _var_dim == 1 push!(_point_data[m], dataset.point_data[m][p]) else - append!(_point_data[m], dataset.point_data[m][:,p]) + append!(_point_data[m], dataset.point_data[m][:, p]) end end _cc[i] = k @@ -233,5 +242,7 @@ function extract_surface(dataset::T) where {T<:AbstractVTKUnstructuredData} end end - return VTKPolyData(_point_coords, _cell_types, _cell_connectivity, _point_data, _cell_data) + return VTKPolyData( + _point_coords, _cell_types, _cell_connectivity, _point_data, _cell_data + ) end diff --git a/src/triangulate.jl b/src/triangulate.jl index 84759e0..066292f 100644 --- a/src/triangulate.jl +++ b/src/triangulate.jl @@ -5,6 +5,7 @@ include("triangulate_struct.jl") triangulate(dataset::AbstractVTKMultiblockData) = triangulate(VTKUnstructuredData(dataset)) function triangulate(dataset::AbstractTimeSeriesVTKData) - return VTKTimeSeriesData(dataset.timemarkers, [triangulate(dataset[i]) for - i in 1:length(dataset)]) + return VTKTimeSeriesData( + dataset.timemarkers, [triangulate(dataset[i]) for i in 1:length(dataset)] + ) end diff --git a/src/triangulate_cell.jl b/src/triangulate_cell.jl index 23f3c1d..e0ba067 100644 --- a/src/triangulate_cell.jl +++ b/src/triangulate_cell.jl @@ -1,17 +1,26 @@ function triangulate_cell(cell_connectivity, cell_type::Int) if cell_type == 5 || cell_type == 6 || cell_type == 10 || cell_type == 24 - return NTuple{3, Int}.(decompose_cell(cell_connectivity, cell_type, target = "Faces")[1]) + return NTuple{ + 3,Int + }.(decompose_cell(cell_connectivity, cell_type; target="Faces")[1]) elseif cell_type == 22 - return NTuple{3, Int}[(cell_connectivity[1], cell_connectivity[2], cell_connectivity[3])] + return NTuple{3,Int}[( + cell_connectivity[1], cell_connectivity[2], cell_connectivity[3] + )] elseif cell_type == 8 - return NTuple{3, Int}[(cell_connectivity[1], cell_connectivity[2], cell_connectivity[4]), - (cell_connectivity[1], cell_connectivity[4], cell_connectivity[3])] + return NTuple{3,Int}[ + (cell_connectivity[1], cell_connectivity[2], cell_connectivity[4]), + (cell_connectivity[1], cell_connectivity[4], cell_connectivity[3]), + ] elseif cell_type == 9 || cell_type == 24 - return NTuple{3, Int}[(cell_connectivity[1], cell_connectivity[2], cell_connectivity[3]), - (cell_connectivity[1], cell_connectivity[3], cell_connectivity[4])] + return NTuple{3,Int}[ + (cell_connectivity[1], cell_connectivity[2], cell_connectivity[3]), + (cell_connectivity[1], cell_connectivity[3], cell_connectivity[4]), + ] elseif cell_type == 11 || cell_type == 12 || cell_type == 13 || cell_type == 14 - tris = NTuple{3, Int}[] - for (_cell, _cell_type) in zip(decompose_cell(cell_connectivity, cell_type, target = "Faces")...) + tris = NTuple{3,Int}[] + for (_cell, _cell_type) in + zip(decompose_cell(cell_connectivity, cell_type; target="Faces")...) append!(tris, triangulate_cell(_cell, _cell_type)) end return tris @@ -22,14 +31,23 @@ end function triangulate_cell_glmesh(cell_connectivity, cell_type::Int) if cell_type == 5 || cell_type == 6 || cell_type == 10 - return map(GLFace{3}, decompose_cell(cell_connectivity, cell_type, target = "Faces")[1] .- 1) + return map( + GLFace{3}, decompose_cell(cell_connectivity, cell_type; target="Faces")[1] .- 1 + ) elseif cell_type == 8 - return GLFace{3}[GLFace{3}(cell_connectivity[1], cell_connectivity[2], cell_connectivity[4]), GLFace{3}(cell_connectivity[1], cell_connectivity[4], cell_connectivity[3])] + return GLFace{3}[ + GLFace{3}(cell_connectivity[1], cell_connectivity[2], cell_connectivity[4]), + GLFace{3}(cell_connectivity[1], cell_connectivity[4], cell_connectivity[3]), + ] elseif cell_type == 9 - return GLFace{3}[GLFace{3}(cell_connectivity[1], cell_connectivity[2], cell_connectivity[3]), GLFace{3}(cell_connectivity[1], cell_connectivity[3], cell_connectivity[4])] + return GLFace{3}[ + GLFace{3}(cell_connectivity[1], cell_connectivity[2], cell_connectivity[3]), + GLFace{3}(cell_connectivity[1], cell_connectivity[3], cell_connectivity[4]), + ] elseif cell_type == 11 || cell_type == 12 || cell_type == 13 || cell_type == 14 tris = GLFace{3}[] - for (_cell, _cell_type) in zip(decompose_cell(cell_connectivity, cell_type, target = "Faces")...) + for (_cell, _cell_type) in + zip(decompose_cell(cell_connectivity, cell_type; target="Faces")...) append!(tris, triangulate_cell_glmesh(_cell, _cell_type)) end return tris diff --git a/src/triangulate_struct.jl b/src/triangulate_struct.jl index aa929bd..eebacf1 100644 --- a/src/triangulate_struct.jl +++ b/src/triangulate_struct.jl @@ -50,7 +50,7 @@ function triangulate_2d_with_cell_data(dataset::VTKStructuredData) end end - _cell_types = fill(5, 2*_num_of_cells) + _cell_types = fill(5, 2 * _num_of_cells) for cind in Iterators.product(1:cextents[1], 1:cextents[2]) quad_cc = cell_connectivity(dataset, cind) push!(faces, [quad_cc[1], quad_cc[2], quad_cc[3]]) @@ -70,9 +70,9 @@ function triangulate_2d_with_cell_data(dataset::VTKStructuredData) for m in keys(dataset.cell_data) _var_dim = var_dim(dataset, m, "Cell") if _var_dim == 1 - _cell_data[m] = reshape(_cell_data[m], (2*_num_of_cells,)) + _cell_data[m] = reshape(_cell_data[m], (2 * _num_of_cells,)) else - _cell_data[m] = reshape(_cell_data[m], (_var_dim, 2*_num_of_cells)) + _cell_data[m] = reshape(_cell_data[m], (_var_dim, 2 * _num_of_cells)) end end @@ -109,8 +109,11 @@ function triangulate_3d_with_cell_data(dataset::VTKStructuredData) _var_dim = var_dim(dataset, m, "Cell") if _var_dim == 1 if cind[3] != 1 - _cd = (dataset.cell_data[m][cind...] + - dataset.cell_data[m][cind[1:2]...,cind[3]-1]) / 2 + _cd = + ( + dataset.cell_data[m][cind...] + + dataset.cell_data[m][cind[1:2]..., cind[3] - 1] + ) / 2 else _cd = dataset.cell_data[m][cind...] end @@ -118,8 +121,11 @@ function triangulate_3d_with_cell_data(dataset::VTKStructuredData) push!(_cell_data[m], _cd) else if cind[3] != 1 - _cd = (dataset.cell_data[m][:, cind...] + - dataset.cell_data[m][:, cind[1:2]...,cind[3]-1]) / 2 + _cd = + ( + dataset.cell_data[m][:, cind...] + + dataset.cell_data[m][:, cind[1:2]..., cind[3] - 1] + ) / 2 else _cd = dataset.cell_data[m][:, cind...] end @@ -134,8 +140,11 @@ function triangulate_3d_with_cell_data(dataset::VTKStructuredData) _var_dim = var_dim(dataset, m, "Cell") if _var_dim == 1 if cind[2] != 1 - _cd = (dataset.cell_data[m][cind...] + - dataset.cell_data[m][cind[1],cind[2]-1,cind[3]]) / 2 + _cd = + ( + dataset.cell_data[m][cind...] + + dataset.cell_data[m][cind[1], cind[2] - 1, cind[3]] + ) / 2 else _cd = dataset.cell_data[m][cind...] end @@ -143,8 +152,11 @@ function triangulate_3d_with_cell_data(dataset::VTKStructuredData) push!(_cell_data[m], _cd) else if cind[3] != 1 - _cd = (dataset.cell_data[m][:, cind...] + - dataset.cell_data[m][:, cind[1],cind[2]-1,cind[3]]) / 2 + _cd = + ( + dataset.cell_data[m][:, cind...] + + dataset.cell_data[m][:, cind[1], cind[2] - 1, cind[3]] + ) / 2 else _cd = dataset.cell_data[m][:, cind...] end @@ -159,8 +171,11 @@ function triangulate_3d_with_cell_data(dataset::VTKStructuredData) _var_dim = var_dim(dataset, m, "Cell") if _var_dim == 1 if cind[1] != 1 - _cd = (dataset.cell_data[m][cind...] + - dataset.cell_data[m][cind[1]-1,cind[2:3]...]) / 2 + _cd = + ( + dataset.cell_data[m][cind...] + + dataset.cell_data[m][cind[1] - 1, cind[2:3]...] + ) / 2 else _cd = dataset.cell_data[m][cind...] end @@ -168,8 +183,11 @@ function triangulate_3d_with_cell_data(dataset::VTKStructuredData) push!(_cell_data[m], _cd) else if cind[3] != 1 - _cd = (dataset.cell_data[m][:, cind...] + - dataset.cell_data[m][:, cind[1]-1,cind[2:3]...]) / 2 + _cd = + ( + dataset.cell_data[m][:, cind...] + + dataset.cell_data[m][:, cind[1] - 1, cind[2:3]...] + ) / 2 else _cd = dataset.cell_data[m][:, cind...] end @@ -261,7 +279,7 @@ function triangulate_2d_no_cell_data(dataset::VTKStructuredData) _cell_data = empty(dataset.cell_data) faces = Vector{Int}[] - _cell_types = fill(5, 2*_num_of_cells) + _cell_types = fill(5, 2 * _num_of_cells) for cind in Iterators.product(1:cextents[1], 1:cextents[2]) quad_cc = cell_connectivity(dataset, cind) push!(faces, [quad_cc[1], quad_cc[2], quad_cc[3]]) diff --git a/src/triangulate_unstruct.jl b/src/triangulate_unstruct.jl index 926905e..522be26 100644 --- a/src/triangulate_unstruct.jl +++ b/src/triangulate_unstruct.jl @@ -1,13 +1,17 @@ -function triangulate_with_cell_data(dataset::AbstractVTKUnstructuredData, OutputT = NTuple{3,Int}, reduction = :max) +function triangulate_with_cell_data( + dataset::AbstractVTKUnstructuredData, OutputT=NTuple{3,Int}, reduction=:max +) filter_cells!(dataset, [POINT_CELLS; LINE_CELLS]) point_coords = dataset.point_coords point_data = dataset.point_data - + #Sorted inds and cell type are keys #Cell connectivity, cell count, and cell data are the values - cell_register = Dict{NTuple{3, Int}, Tuple{NTuple{3, Int}, _Counter, typeof(dataset.cell_data)}}() + cell_register = Dict{ + NTuple{3,Int},Tuple{NTuple{3,Int},_Counter,typeof(dataset.cell_data)} + }() for i in 1:length(dataset.cell_connectivity) _cells = triangulate_cell(dataset.cell_connectivity[i], dataset.cell_types[i]) for j in 1:length(_cells) @@ -20,13 +24,16 @@ function triangulate_with_cell_data(dataset::AbstractVTKUnstructuredData, Output if reduction == :mean cell_register[_key][3][m] += [dataset.cell_data[m][i]] else - cell_register[_key][3][m] = max(cell_register[_key][3][m], [dataset.cell_data[m][i]]) + cell_register[_key][3][m] = max( + cell_register[_key][3][m], [dataset.cell_data[m][i]] + ) end else if reduction == :mean - cell_register[_key][3][m] += dataset.cell_data[m][:,i] + cell_register[_key][3][m] += dataset.cell_data[m][:, i] else - cell_register[_key][3][m] = max.(cell_register[_key][3][m], dataset.cell_data[m][:,i]) + cell_register[_key][3][m] = + max.(cell_register[_key][3][m], dataset.cell_data[m][:, i]) end end end @@ -37,7 +44,7 @@ function triangulate_with_cell_data(dataset::AbstractVTKUnstructuredData, Output if _var_dim == 1 cell_register[_key][3][m] = [dataset.cell_data[m][i]] else - cell_register[_key][3][m] = dataset.cell_data[m][:,i] + cell_register[_key][3][m] = dataset.cell_data[m][:, i] end end end @@ -67,7 +74,7 @@ function triangulate_with_cell_data(dataset::AbstractVTKUnstructuredData, Output if _var_dim == 1 cell_data[m][i] = v[3][m][1] else - cell_data[m][:,i] = v[3][m] + cell_data[m][:, i] = v[3][m] end end cc = OutputT <: Tuple ? v[1] : OutputT(v[1]...) @@ -79,15 +86,17 @@ function triangulate_with_cell_data(dataset::AbstractVTKUnstructuredData, Output return VTKPolyData(point_coords, _cell_types, _cell_connectivity, point_data, cell_data) end -function triangulate_no_cell_data(dataset::AbstractVTKUnstructuredData, OutputT = NTuple{3, Int}) +function triangulate_no_cell_data( + dataset::AbstractVTKUnstructuredData, OutputT=NTuple{3,Int} +) filter_cells!(dataset, [POINT_CELLS; LINE_CELLS]) point_coords = dataset.point_coords point_data = dataset.point_data - + #Sorted inds and cell type are keys #Cell connectivity is the value - cell_register = Dict{NTuple{3, Int}, NTuple{3, Int}}() + cell_register = Dict{NTuple{3,Int},NTuple{3,Int}}() for i in 1:length(dataset.cell_connectivity) _cells = triangulate_cell(dataset.cell_connectivity[i], dataset.cell_types[i]) for j in 1:length(_cells) @@ -115,11 +124,19 @@ end function remove_unused_vertices(dataset::AbstractVTKUnstructuredData) if length(dataset.cell_connectivity) == 0 N = size(dataset.point_coords, 1) - return typeof(dataset)(zeros(dim, 0), Int[], copy(dataset.cell_connectivity), empty(dataset.point_data), empty(dataset.cell_data)) + return typeof(dataset)( + zeros(dim, 0), + Int[], + copy(dataset.cell_connectivity), + empty(dataset.point_data), + empty(dataset.cell_data), + ) end I = length(dataset.cell_connectivity) J = length(dataset.cell_connectivity[1].data) - all_node_inds = unique!(vec([Int(dataset.cell_connectivity[i].data[j]) for j in 1:J, i in 1:I])) + all_node_inds = unique!( + vec([Int(dataset.cell_connectivity[i].data[j]) for j in 1:J, i in 1:I]) + ) nnodes = length(all_node_inds) ind_map = Dict(all_node_inds[i] => i for i in 1:nnodes) diff = size(dataset.point_coords, 2) - nnodes @@ -128,12 +145,17 @@ function remove_unused_vertices(dataset::AbstractVTKUnstructuredData) end point_coords = dataset.point_coords[:, all_node_inds] point_data = Dict( - k => ( - temp = dataset.point_data[k]; - temp isa Matrix ? temp[:, all_node_inds] : temp[all_node_inds] - ) for k in keys(dataset.point_data) + k => (temp = dataset.point_data[k]; + temp isa Matrix ? temp[:, all_node_inds] : temp[all_node_inds]) for + k in keys(dataset.point_data) + ) + return typeof(dataset)( + point_coords, + copy(dataset.cell_types), + cell_connectivity, + point_data, + deepcopy(dataset.cell_data), ) - return typeof(dataset)(point_coords, copy(dataset.cell_types), cell_connectivity, point_data, deepcopy(dataset.cell_data)) end function duplicate_vertices(dataset::AbstractVTKUnstructuredData) @@ -155,17 +177,17 @@ function duplicate_vertices(dataset::AbstractVTKUnstructuredData) for i in 1:num_of_cells(dataset) for j in dataset.cell_connectivity[i] point_counter += 1 - @views point_coords[:,point_counter] += dataset.point_coords[:,j] + @views point_coords[:, point_counter] += dataset.point_coords[:, j] for m in keys(dataset.point_data) _var_dim = var_dim(dataset, m, "Point") if _var_dim == 1 point_data[m][point_counter] += dataset.point_data[m][j] else - @views point_data[m][:,point_counter] += dataset.point_data[m][:,j] + @views point_data[m][:, point_counter] += dataset.point_data[m][:, j] end end end - cell_connectivity[i] = (point_counter-2, point_counter-1, point_counter) + cell_connectivity[i] = (point_counter - 2, point_counter - 1, point_counter) end for m in keys(dataset.point_data) @@ -182,7 +204,9 @@ function duplicate_vertices(dataset::AbstractVTKUnstructuredData) return VTKPolyData(point_coords, cell_types, cell_connectivity, point_data, cell_data) end -function triangulate(dataset::AbstractVTKUnstructuredData, triangulate_cell_data=false, OutputT = NTuple{3,Int}) +function triangulate( + dataset::AbstractVTKUnstructuredData, triangulate_cell_data=false, OutputT=NTuple{3,Int} +) if triangulate_cell_data return triangulate_with_cell_data(dataset, OutputT) else diff --git a/src/typeconversion.jl b/src/typeconversion.jl index ec9e9b0..9fa62da 100644 --- a/src/typeconversion.jl +++ b/src/typeconversion.jl @@ -1,9 +1,14 @@ -VTKMultiblockData(dataset::AbstractVTKSimpleData) = VTKMultiblockData(AbstractStaticVTKData[dataset]) +function VTKMultiblockData(dataset::AbstractVTKSimpleData) + return VTKMultiblockData(AbstractStaticVTKData[dataset]) +end function VTKRectilinearData(dataset::VTKUniformRectilinearData) _extents = extents(dataset) _dim = dim(dataset) - point_coords = ntuple(j -> [dataset.origin[j] + (i-1)*dataset.spacing[j] for i in 1:_extents[j]], Val(_dim)) + point_coords = ntuple( + j -> [dataset.origin[j] + (i - 1) * dataset.spacing[j] for i in 1:_extents[j]], + Val(_dim), + ) return VTKRectilinearData(point_coords, dataset.point_data, dataset.cell_data) end function Base.convert(::Type{VTKRectilinearData}, dataset::VTKUniformRectilinearData) @@ -28,7 +33,10 @@ function VTKStructuredData(dataset::VTKRectilinearData) zcoord = dataset.point_coords[3] point_coords = zeros(dim(dataset), extents(dataset)...) - for k in 1:extents(dataset, 3), j in 1:extents(dataset, 2), i in 1:extents(dataset, 1) + for k in 1:extents(dataset, 3), + j in 1:extents(dataset, 2), + i in 1:extents(dataset, 1) + point_coords[:, i, j, k] = [xcoord[i], ycoord[j], zcoord[k]] end else @@ -44,8 +52,13 @@ function Base.convert(::Type{VTKStructuredData}, dataset::VTKRectilinearData) end function VTKUnstructuredData(dataset::VTKPolyData) - return VTKUnstructuredData(dataset.point_coords, dataset.cell_types, - dataset.cell_connectivity, dataset.point_data, dataset.cell_data) + return VTKUnstructuredData( + dataset.point_coords, + dataset.cell_types, + dataset.cell_connectivity, + dataset.point_data, + dataset.cell_data, + ) end function VTKUnstructuredData(dataset::T) where {T<:AbstractVTKStructuredData} @@ -58,8 +71,12 @@ function VTKUnstructuredData(dataset::T) where {T<:AbstractVTKStructuredData} point_coords = unstructured_point_coords_from_uniform_rectilinear(dataset) end point_data = unstructured_point_data_from_structured(dataset) - cell_types, _cell_connectivity, cell_data = unstructured_cell_info_from_structured(dataset) - return VTKUnstructuredData(point_coords, cell_types, _cell_connectivity, point_data, cell_data) + cell_types, _cell_connectivity, cell_data = unstructured_cell_info_from_structured( + dataset + ) + return VTKUnstructuredData( + point_coords, cell_types, _cell_connectivity, point_data, cell_data + ) end function VTKUnstructuredData(data_blocks::VTKMultiblockData) @@ -97,10 +114,12 @@ function unstructured_point_data_from_structured(dataset::AbstractVTKStructuredD point_data[m] = reshape(dataset.point_data[m], (_var_dim, _num_of_points)) end end - point_data + return point_data end -function unstructured_cell_info_from_structured(dataset::T) where {T<:AbstractVTKStructuredData} +function unstructured_cell_info_from_structured( + dataset::T +) where {T<:AbstractVTKStructuredData} _num_of_cells = num_of_cells(dataset) _dim = dim(dataset) pextents = extents(dataset) @@ -113,14 +132,25 @@ function unstructured_cell_info_from_structured(dataset::T) where {T<:AbstractVT else cell_types = fill(9, _num_of_cells) #VTK_QUAD end - _cell_connectivity = reshape(map(local_cell_connectivity, ((i,j) for j in 1:cextents[2], i in 1:cextents[1])), (_num_of_cells,)) + _cell_connectivity = reshape( + map( + local_cell_connectivity, ((i, j) for j in 1:cextents[2], i in 1:cextents[1]) + ), + (_num_of_cells,), + ) elseif _dim == 3 if T <: VTKUniformRectilinearData cell_types = fill(11, _num_of_cells) #VTK_VOXEL else cell_types = fill(12, _num_of_cells) #VTK_HEXAHEDRON end - _cell_connectivity = reshape(map(local_cell_connectivity, ((i,j,k) for k in 1:cextents[3], j in 1:cextents[2], i in 1:cextents[1])), (_num_of_cells,)) + _cell_connectivity = reshape( + map( + local_cell_connectivity, + ((i, j, k) for k in 1:cextents[3], j in 1:cextents[2], i in 1:cextents[1]), + ), + (_num_of_cells,), + ) end cell_data = empty(dataset.cell_data) @@ -151,15 +181,18 @@ function unstructured_point_coords_from_rectilinear(dataset::VTKRectilinearData) p = 1 if _dim == 2 for y in dataset.point_coords[2], x in dataset.point_coords[1] - _point_coords[1,p] = x - _point_coords[2,p] = y + _point_coords[1, p] = x + _point_coords[2, p] = y p += 1 end elseif _dim == 3 - for z in dataset.point_coords[3], y in dataset.point_coords[2], x in dataset.point_coords[1] - _point_coords[1,p] = x - _point_coords[2,p] = y - _point_coords[3,p] = z + for z in dataset.point_coords[3], + y in dataset.point_coords[2], + x in dataset.point_coords[1] + + _point_coords[1, p] = x + _point_coords[2, p] = y + _point_coords[3, p] = z p += 1 end else @@ -168,7 +201,9 @@ function unstructured_point_coords_from_rectilinear(dataset::VTKRectilinearData) return _point_coords end -function unstructured_point_coords_from_uniform_rectilinear(dataset::VTKUniformRectilinearData) +function unstructured_point_coords_from_uniform_rectilinear( + dataset::VTKUniformRectilinearData +) _extents = extents(dataset) _num_of_points = num_of_points(dataset) _dim = dim(dataset) @@ -182,8 +217,8 @@ function unstructured_point_coords_from_uniform_rectilinear(dataset::VTKUniformR for j in 1:_extents[2] x = _origin[1] for i in 1:_extents[1] - _point_coords[1,p] = x - _point_coords[2,p] = y + _point_coords[1, p] = x + _point_coords[2, p] = y p += 1 x += _spacing[1] end @@ -196,9 +231,9 @@ function unstructured_point_coords_from_uniform_rectilinear(dataset::VTKUniformR for j in 1:_extents[2] x = _origin[1] for i in 1:_extents[1] - _point_coords[1,p] = x - _point_coords[2,p] = y - _point_coords[3,p] = z + _point_coords[1, p] = x + _point_coords[2, p] = y + _point_coords[3, p] = z p += 1 x += _spacing[1] end diff --git a/src/types.jl b/src/types.jl index b45c209..5f10bc0 100644 --- a/src/types.jl +++ b/src/types.jl @@ -1,7 +1,7 @@ abstract type AbstractVTKData end abstract type AbstractStaticVTKData <: AbstractVTKData end -abstract type AbstractTimeSeriesVTKData{TTime, TData} <: AbstractVTKData end +abstract type AbstractTimeSeriesVTKData{TTime,TData} <: AbstractVTKData end abstract type AbstractVTKSimpleData <: AbstractStaticVTKData end #abstract AbstractVTKAMRData <: AbstractStaticVTKData @@ -11,26 +11,20 @@ abstract type AbstractVTKUnstructuredData <: AbstractVTKSimpleData end abstract type AbstractVTKStructuredData <: AbstractVTKSimpleData end abstract type AbstractVTKRectilinearData <: AbstractVTKStructuredData end -mutable struct VTKUnstructuredData{TCoord, TConnect, TPointData, TCellData} <: AbstractVTKUnstructuredData +mutable struct VTKUnstructuredData{TCoord,TConnect,TPointData,TCellData} <: + AbstractVTKUnstructuredData point_coords::Matrix{TCoord} cell_types::Vector{Int} cell_connectivity::Vector{TConnect} - point_data::Dict{String, TPointData} - cell_data::Dict{String, TCellData} -end -function VTKUnstructuredData( point_coords, - cell_types, - cell_connectivity, - point_data, - cell_data, - validate - ) - dataset = VTKUnstructuredData( point_coords, - cell_types, - cell_connectivity, - point_data, - cell_data - ) + point_data::Dict{String,TPointData} + cell_data::Dict{String,TCellData} +end +function VTKUnstructuredData( + point_coords, cell_types, cell_connectivity, point_data, cell_data, validate +) + dataset = VTKUnstructuredData( + point_coords, cell_types, cell_connectivity, point_data, cell_data + ) if validate valid, _error = is_valid(dataset) valid ? (return dataset) : throw(_error) @@ -38,43 +32,30 @@ function VTKUnstructuredData( point_coords, return dataset end -function VTKUnstructuredData( point_coords, - cell_types = Int[], - cell_connectivity = Vector{Int}[], - validate = false - ) - - point_data = Dict{String, Array}() - cell_data = Dict{String, Array}() - return VTKUnstructuredData( point_coords, - cell_types, - cell_connectivity, - point_data, - cell_data, - validate - ) +function VTKUnstructuredData( + point_coords, cell_types=Int[], cell_connectivity=Vector{Int}[], validate=false +) + point_data = Dict{String,Array}() + cell_data = Dict{String,Array}() + return VTKUnstructuredData( + point_coords, cell_types, cell_connectivity, point_data, cell_data, validate + ) end -mutable struct VTKPolyData{TCoord, TConnect, TPointData, TCellData} <: AbstractVTKUnstructuredData +mutable struct VTKPolyData{TCoord,TConnect,TPointData,TCellData} <: + AbstractVTKUnstructuredData point_coords::Matrix{TCoord} cell_types::Vector{Int} cell_connectivity::Vector{TConnect} - point_data::Dict{String, TPointData} - cell_data::Dict{String, TCellData} -end -function VTKPolyData( point_coords, - cell_types, - cell_connectivity, - point_data, - cell_data, - validate - ) - dataset = VTKPolyData( point_coords, - cell_types, - cell_connectivity, - point_data, - cell_data - ) + point_data::Dict{String,TPointData} + cell_data::Dict{String,TCellData} +end +function VTKPolyData( + point_coords, cell_types, cell_connectivity, point_data, cell_data, validate +) + dataset = VTKPolyData( + point_coords, cell_types, cell_connectivity, point_data, cell_data + ) if validate valid, _error = is_valid(dataset) valid ? (return dataset) : throw(_error) @@ -82,33 +63,23 @@ function VTKPolyData( point_coords, return dataset end -function VTKPolyData( point_coords, - cell_types = Int[], - cell_connectivity = Vector{Int}[], - validate::Bool = false - ) - - point_data = Dict{String, Array}() - cell_data = Dict{String, Array}() - return VTKPolyData( point_coords, - cell_types, - cell_connectivity, - point_data, - cell_data, - validate - ) +function VTKPolyData( + point_coords, cell_types=Int[], cell_connectivity=Vector{Int}[], validate::Bool=false +) + point_data = Dict{String,Array}() + cell_data = Dict{String,Array}() + return VTKPolyData( + point_coords, cell_types, cell_connectivity, point_data, cell_data, validate + ) end -mutable struct VTKStructuredData{TCoord, TArray <: Array{TCoord}, TPointData, TCellData} <: AbstractVTKStructuredData +mutable struct VTKStructuredData{TCoord,TArray<:Array{TCoord},TPointData,TCellData} <: + AbstractVTKStructuredData point_coords::TArray - point_data::Dict{String, TPointData} - cell_data::Dict{String, TCellData} -end -function VTKStructuredData( point_coords, - point_data, - cell_data, - validate::Bool - ) + point_data::Dict{String,TPointData} + cell_data::Dict{String,TCellData} +end +function VTKStructuredData(point_coords, point_data, cell_data, validate::Bool) dataset = VTKStructuredData(point_coords, point_data, cell_data) if validate valid, _error = is_valid(dataset) @@ -117,15 +88,16 @@ function VTKStructuredData( point_coords, return dataset end function VTKStructuredData(point_coords, validate::Bool) - point_data = Dict{String, Array}() - cell_data = Dict{String, Array}() + point_data = Dict{String,Array}() + cell_data = Dict{String,Array}() return VTKStructuredData(point_coords, point_data, cell_data, validate) end -mutable struct VTKRectilinearData{TCoord, N, TPointData, TCellData} <: AbstractVTKRectilinearData - point_coords::NTuple{N, Vector{TCoord}} - point_data::Dict{String, TPointData} - cell_data::Dict{String, TCellData} +mutable struct VTKRectilinearData{TCoord,N,TPointData,TCellData} <: + AbstractVTKRectilinearData + point_coords::NTuple{N,Vector{TCoord}} + point_data::Dict{String,TPointData} + cell_data::Dict{String,TCellData} end function VTKRectilinearData(point_coords, point_data, cell_data, validate) dataset = VTKRectilinearData(point_coords, point_data, cell_data) @@ -135,52 +107,36 @@ function VTKRectilinearData(point_coords, point_data, cell_data, validate) end return dataset end -function VTKRectilinearData(point_coords, validate::Bool = false) - point_data = Dict{String, Array}() - cell_data = Dict{String, Array}() - VTKRectilinearData(point_coords, point_data, cell_data, validate) +function VTKRectilinearData(point_coords, validate::Bool=false) + point_data = Dict{String,Array}() + cell_data = Dict{String,Array}() + return VTKRectilinearData(point_coords, point_data, cell_data, validate) end -mutable struct VTKUniformRectilinearData{TCoord, N, TPointData, TCellData} <: AbstractVTKRectilinearData - origin::NTuple{N, TCoord} - spacing::NTuple{N, TCoord} - extents::NTuple{N, Int} - point_data::Dict{String, TPointData} - cell_data::Dict{String, TCellData} -end -function VTKUniformRectilinearData( origin, - spacing, - extents, - point_data, - cell_data, - validate::Bool - ) - dataset = VTKUniformRectilinearData(origin, - spacing, - extents, - point_data, - cell_data - ) +mutable struct VTKUniformRectilinearData{TCoord,N,TPointData,TCellData} <: + AbstractVTKRectilinearData + origin::NTuple{N,TCoord} + spacing::NTuple{N,TCoord} + extents::NTuple{N,Int} + point_data::Dict{String,TPointData} + cell_data::Dict{String,TCellData} +end +function VTKUniformRectilinearData( + origin, spacing, extents, point_data, cell_data, validate::Bool +) + dataset = VTKUniformRectilinearData(origin, spacing, extents, point_data, cell_data) if validate valid, _error = is_valid(dataset) valid ? (return dataset) : throw(_error) end return dataset end -function VTKUniformRectilinearData( origin, - spacing, - extents, - validate::Bool = false, - ) - point_data = Dict{String, Array}() - cell_data = Dict{String, Array}() - return VTKUniformRectilinearData( origin, - spacing, - extents, - point_data, - cell_data, - validate - ) +function VTKUniformRectilinearData(origin, spacing, extents, validate::Bool=false) + point_data = Dict{String,Array}() + cell_data = Dict{String,Array}() + return VTKUniformRectilinearData( + origin, spacing, extents, point_data, cell_data, validate + ) end const VTKImageData = VTKUniformRectilinearData @@ -192,11 +148,13 @@ type VTKBergerOligerAMRData <: AbstractVTKAMRData end =# -mutable struct VTKMultiblockData{N, TBlocks <: Tuple{Vararg{AbstractStaticVTKData, N}}} <: AbstractVTKMultiblockData +mutable struct VTKMultiblockData{N,TBlocks<:Tuple{Vararg{AbstractStaticVTKData,N}}} <: + AbstractVTKMultiblockData blocks::TBlocks end -mutable struct VTKTimeSeriesData{TTime, TData <: AbstractStaticVTKData} <: AbstractTimeSeriesVTKData{TTime, TData} +mutable struct VTKTimeSeriesData{TTime,TData<:AbstractStaticVTKData} <: + AbstractTimeSeriesVTKData{TTime,TData} timemarkers::Vector{TTime} data::Vector{TData} end diff --git a/src/validation.jl b/src/validation.jl index fcb7912..956833c 100644 --- a/src/validation.jl +++ b/src/validation.jl @@ -1,66 +1,129 @@ -function is_valid_unstructured_mesh(dataset::_T, - repeat_cells::Bool - ) where {_T<:AbstractVTKUnstructuredData} +function is_valid_unstructured_mesh( + dataset::_T, repeat_cells::Bool +) where {_T<:AbstractVTKUnstructuredData} T = repr(_T) - _point_coords, _cell_types, _cell_connectivity, _point_data, _cell_data = dataset.point_coords, - dataset.cell_types, dataset.cell_connectivity, dataset.point_data, dataset.cell_data + _point_coords, _cell_types, _cell_connectivity, _point_data, _cell_data = dataset.point_coords, + dataset.cell_types, dataset.cell_connectivity, dataset.point_data, + dataset.cell_data - in(dim(dataset), [2,3]) || return false, "$T: Only 2 and 3 dimensional mesh data are allowed." + in(dim(dataset), [2, 3]) || + return false, "$T: Only 2 and 3 dimensional mesh data are allowed." - length(_cell_types) == length(_cell_connectivity) || return false, "$T: The cell types vector and the cell connectivity vector have unequal lengths." - length(_cell_connectivity) == 0 || (_min = get_lowest_index(_cell_connectivity)) >= 1 || return false, "$T: The lowest point index used in the cell connectivity vector is $_min < 1. Please consider using the add_point_id_offset!(cell_connectivity, $(1-_min)) function to make the lowest index 1." - length(_cell_connectivity) == 0 || get_highest_index(_cell_connectivity) <= num_of_points(dataset) || return false, "$T: The highest point index used in the cell connectivity vector is more than the number of points passed." + length(_cell_types) == length(_cell_connectivity) || return false, + "$T: The cell types vector and the cell connectivity vector have unequal lengths." + length(_cell_connectivity) == 0 || + (_min = get_lowest_index(_cell_connectivity)) >= 1 || + return false, + "$T: The lowest point index used in the cell connectivity vector is $_min < 1. Please consider using the add_point_id_offset!(cell_connectivity, $(1-_min)) function to make the lowest index 1." + length(_cell_connectivity) == 0 || + get_highest_index(_cell_connectivity) <= num_of_points(dataset) || + return false, + "$T: The highest point index used in the cell connectivity vector is more than the number of points passed." _keys = collect(keys(_point_data)) - length(_keys) == 0 || - num_of_points(dataset) == (var_dim(dataset, _keys[1], "Point") == 1 ? length(_point_data[_keys[1]]) : size(_point_data[_keys[1]], 2)) && - begin - _out = true - _var_dim1 = var_dim(dataset, _keys[1], "Point") - for m in _keys[2:end] - _var_dimi = var_dim(dataset, m, "Point") - (_out = (_var_dim1 == 1 ? length(_point_data[_keys[1]]) : size(_point_data[_keys[1]], 2)) == - (_var_dimi == 1 ? length(_point_data[m]) : size(_point_data[m], 2))) || break - end - _out - end || return false, "$T: The number of points defined is not consistent with the number of points in at least one of the point data fields." + length(_keys) == 0 || + num_of_points(dataset) == ( + if var_dim(dataset, _keys[1], "Point") == 1 + length(_point_data[_keys[1]]) + else + size(_point_data[_keys[1]], 2) + end + ) && begin + _out = true + _var_dim1 = var_dim(dataset, _keys[1], "Point") + for m in _keys[2:end] + _var_dimi = var_dim(dataset, m, "Point") + ( + _out = + ( + if _var_dim1 == 1 + length(_point_data[_keys[1]]) + else + size(_point_data[_keys[1]], 2) + end + ) == ( + if _var_dimi == 1 + length(_point_data[m]) + else + size(_point_data[m], 2) + end + ) + ) || break + end + _out + end || + return false, + "$T: The number of points defined is not consistent with the number of points in at least one of the point data fields." _keys = collect(keys(_cell_data)) - length(_keys) == 0 || - num_of_cells(dataset) == (var_dim(dataset, _keys[1], "Cell") == 1 ? length(_cell_data[_keys[1]]) : size(_cell_data[_keys[1]], 2)) && - begin - _out = true - _var_dim1 = var_dim(dataset, _keys[1], "Cell") - for m in _keys[2:end] - _var_dimi = var_dim(dataset, m, "Cell") - (_out = (_var_dim1 == 1 ? length(_cell_data[_keys[1]]) : size(_cell_data[_keys[1]], 2)) == - (_var_dimi == 1 ? length(_cell_data[m]) : size(_cell_data[m], 2))) || break - end - _out - end || return false, "$T: The number of cells defined is not consistent with the number of cells in at least one of the cell data fields." + length(_keys) == 0 || + num_of_cells(dataset) == ( + if var_dim(dataset, _keys[1], "Cell") == 1 + length(_cell_data[_keys[1]]) + else + size(_cell_data[_keys[1]], 2) + end + ) && begin + _out = true + _var_dim1 = var_dim(dataset, _keys[1], "Cell") + for m in _keys[2:end] + _var_dimi = var_dim(dataset, m, "Cell") + ( + _out = + ( + if _var_dim1 == 1 + length(_cell_data[_keys[1]]) + else + size(_cell_data[_keys[1]], 2) + end + ) == ( + if _var_dimi == 1 + length(_cell_data[m]) + else + size(_cell_data[m], 2) + end + ) + ) || break + end + _out + end || + return false, + "$T: The number of cells defined is not consistent with the number of cells in at least one of the cell data fields." begin _out = true for i in 1:length(_cell_connectivity) - (_out = VTK_CELL_TYPE[cell_type(dataset, i)].nodes == -1 || - length(_cell_connectivity[i]) == VTK_CELL_TYPE[cell_type(dataset, i)].nodes) || break + ( + _out = + VTK_CELL_TYPE[cell_type(dataset, i)].nodes == -1 || + length(_cell_connectivity[i]) == + VTK_CELL_TYPE[cell_type(dataset, i)].nodes + ) || break end _out - end || return false, "$T: The number of points in at least one cell does not match its corresponding cell type." + end || return false, + "$T: The number of points in at least one cell does not match its corresponding cell type." if !repeat_cells begin _out = true for i in 1:length(_cell_connectivity) - for j in i+1:length(_cell_connectivity) - (_out = !similar_cells(_cell_connectivity[i], cell_type(dataset, i), - _cell_connectivity[j], cell_type(dataset, j))) || break + for j in (i + 1):length(_cell_connectivity) + ( + _out = + !similar_cells( + _cell_connectivity[i], + cell_type(dataset, i), + _cell_connectivity[j], + cell_type(dataset, j), + ) + ) || break end end _out end || return false, "$T: Repeat cells are not allowed." end - + return true, "" end @@ -71,15 +134,18 @@ end function is_valid(dataset::VTKPolyData; repeat_cells=false) T = "VTKPolyData" _cell_types, _cell_connectivity = dataset.cell_types, dataset.cell_connectivity - - length(_cell_types) == 0 || begin - _out = true - poly_cells = [POINT_CELLS; LINE_CELLS; FACE_CELLS] - for i in 1:length(_cell_connectivity) - (_out = in(cell_type(dataset, i), poly_cells)) || break - end - _out - end || return false, "$T: At least one of the cells is a volume cell. $T can only have point, line or face cells, consider VTKUnstructuredData." + + length(_cell_types) == 0 || + begin + _out = true + poly_cells = [POINT_CELLS; LINE_CELLS; FACE_CELLS] + for i in 1:length(_cell_connectivity) + (_out = in(cell_type(dataset, i), poly_cells)) || break + end + _out + end || + return false, + "$T: At least one of the cells is a volume cell. $T can only have point, line or face cells, consider VTKUnstructuredData." return is_valid_unstructured_mesh(dataset, repeat_cells) end @@ -87,113 +153,153 @@ end function is_valid(dataset::VTKStructuredData) T = "VTKStructuredData" _dim = dim(dataset) - in(_dim, [2,3]) && _dim == length(size(dataset.point_coords)[2:end]) || return false, "$T: Only 2 and 3 dimensional mesh data are allowed. First index iterates over the coordinate components, and the remaining indices iterate over the extents of the mesh." + in(_dim, [2, 3]) && _dim == length(size(dataset.point_coords)[2:end]) || return false, + "$T: Only 2 and 3 dimensional mesh data are allowed. First index iterates over the coordinate components, and the remaining indices iterate over the extents of the mesh." _extents = extents(dataset) all([_extents[i] > 0 for i in 1:length(_extents)]) || return false, "$T: Extent must be at least 1 in each dimensions." _keys = collect(keys(dataset.point_data)) - length(_keys) == 0 || begin - _out = true - for i in _keys - var_extents = size(dataset.point_data[i]) - (_out = var_extents == _extents) || (_out = var_extents[2:end] == _extents) || break - end - _out - end || return false, "$T: The point extents of the mesh and one of the point data fields are not consistent." + length(_keys) == 0 || + begin + _out = true + for i in _keys + var_extents = size(dataset.point_data[i]) + (_out = var_extents == _extents) || + (_out = var_extents[2:end] == _extents) || + break + end + _out + end || + return false, + "$T: The point extents of the mesh and one of the point data fields are not consistent." cell_extents = (_extents .- 1) _keys = collect(keys(dataset.cell_data)) - length(_keys) == 0 || begin - _out = true - for i in _keys - var_extents = size(dataset.cell_data[i]) - (_out = var_extents == cell_extents) || (_out = var_extents[2:end] == cell_extents) || break - end - _out - end || return false, "$T: The cell extents of the mesh and one of the cell data fields are not consistent." + length(_keys) == 0 || + begin + _out = true + for i in _keys + var_extents = size(dataset.cell_data[i]) + (_out = var_extents == cell_extents) || + (_out = var_extents[2:end] == cell_extents) || + break + end + _out + end || + return false, + "$T: The cell extents of the mesh and one of the cell data fields are not consistent." return true, "" end function is_valid(dataset::VTKRectilinearData{S}) where {S} T = "VTKRectilinearData" - in(length(dataset.point_coords), [2,3]) || return false, "$T: Only 2 and 3 dimensional mesh data are allowed." + in(length(dataset.point_coords), [2, 3]) || + return false, "$T: Only 2 and 3 dimensional mesh data are allowed." - !(S <: Real) || begin - _out = true - for i in length(dataset.point_coords), j in 1:length(dataset.point_coords[i])-1 - (_out = dataset.point_coords[i][j] < dataset.point_coords[i][j+1]) || break - end - _out - end || return false, "$T: Coordinate vectors should be in ascending order." + !(S <: Real) || + begin + _out = true + for i in length(dataset.point_coords), + j in 1:(length(dataset.point_coords[i]) - 1) + + (_out = dataset.point_coords[i][j] < dataset.point_coords[i][j + 1]) || + break + end + _out + end || + return false, "$T: Coordinate vectors should be in ascending order." _extents = extents(dataset) all([_extents[i] > 0 for i in 1:length(_extents)]) || return false, "$T: Extent must be at least 1 in each dimensions." _keys = collect(keys(dataset.point_data)) - length(_keys) == 0 || begin - _out = true - for i in _keys - var_extents = size(dataset.point_data[i]) - (_out = var_extents == _extents) || (_out = var_extents[2:end] == _extents) || break - end - _out - end || return false, "$T: The point extents of the mesh and one of the point data fields are not consistent." + length(_keys) == 0 || + begin + _out = true + for i in _keys + var_extents = size(dataset.point_data[i]) + (_out = var_extents == _extents) || + (_out = var_extents[2:end] == _extents) || + break + end + _out + end || + return false, + "$T: The point extents of the mesh and one of the point data fields are not consistent." _cell_extents = cell_extents(dataset) _keys = collect(keys(dataset.cell_data)) - length(_keys) == 0 || begin - _out = true - for i in _keys - var_extents = size(dataset.cell_data[i]) - (_out = var_extents == _cell_extents) || (_out = var_extents[2:end] == _cell_extents) || break - end - _out - end || return false, "$T: The cell extents of the mesh and one of the cell data fields are not consistent." + length(_keys) == 0 || + begin + _out = true + for i in _keys + var_extents = size(dataset.cell_data[i]) + (_out = var_extents == _cell_extents) || + (_out = var_extents[2:end] == _cell_extents) || + break + end + _out + end || + return false, + "$T: The cell extents of the mesh and one of the cell data fields are not consistent." return true, "" end function is_valid(dataset::VTKUniformRectilinearData{S}) where {S} T = "VTKUniformRectilinearData" - !(S <: Real) || begin + !(S <: Real) || begin _out = true for i in 1:length(dataset.spacing) - (_out = dataset.spacing[i] > 0) || return false, "Spacing must be positive for all dimensions." + (_out = dataset.spacing[i] > 0) || + return false, "Spacing must be positive for all dimensions." end _out end _extents = extents(dataset) all([_extents[i] > 0 for i in 1:length(_extents)]) || return false, "$T: Extent must be at least 1 in each dimensions." - in(length(_extents), [2,3]) || return false, "$T: Only 2 and 3 dimensional mesh data are allowed." - length(_extents) == length(dataset.spacing) == length(dataset.origin) || return false, "$T: The length of \"origin\", the length of \"spacing\", and the length of \"extents\" are not consistent." + in(length(_extents), [2, 3]) || + return false, "$T: Only 2 and 3 dimensional mesh data are allowed." + length(_extents) == length(dataset.spacing) == length(dataset.origin) || return false, + "$T: The length of \"origin\", the length of \"spacing\", and the length of \"extents\" are not consistent." _keys = collect(keys(dataset.point_data)) - length(_keys) == 0 || begin - _out = true - for m in _keys - var_extents = size(dataset.point_data[m]) - (_out = var_extents == _extents) || (_out = var_extents[2:end] == _extents) || break - end - _out - end || return false, "$T: The point extents of the mesh and one of the point data fields are not consistent." + length(_keys) == 0 || + begin + _out = true + for m in _keys + var_extents = size(dataset.point_data[m]) + (_out = var_extents == _extents) || + (_out = var_extents[2:end] == _extents) || + break + end + _out + end || + return false, + "$T: The point extents of the mesh and one of the point data fields are not consistent." cell_extents = _extents .- 1 _keys = collect(keys(dataset.cell_data)) - length(_keys) == 0 || begin - _out = true - for m in _keys - var_extents = size(dataset.cell_data[m]) - (_out = var_extents == cell_extents) || (_out = var_extents[2:end] == cell_extents) || break - end - _out - end || return false, "$T: The cell extents of the mesh and one of the cell data fields are not consistent." + length(_keys) == 0 || + begin + _out = true + for m in _keys + var_extents = size(dataset.cell_data[m]) + (_out = var_extents == cell_extents) || + (_out = var_extents[2:end] == cell_extents) || + break + end + _out + end || + return false, + "$T: The cell extents of the mesh and one of the cell data fields are not consistent." return true, "" end -function is_valid(dataset::VTKMultiblockData) +function is_valid(dataset::VTKMultiblockData) for block in dataset valid, _error = is_valid(block) valid ? continue : return false, _error @@ -207,13 +313,14 @@ function is_valid(dataset::VTKTimeSeriesData) data = dataset.data begin _out = true - for i in 1:length(timemarkers)-1 - (_out = timemarkers[i] < timemarkers[i+1]) || break + for i in 1:(length(timemarkers) - 1) + (_out = timemarkers[i] < timemarkers[i + 1]) || break end _out end || return false, "$T: Time markers should be in ascending order." - - length(timemarkers) == length(data) || return false, "$T: The number of time markers and the length of data must be equal." + + length(timemarkers) == length(data) || + return false, "$T: The number of time markers and the length of data must be equal." for block in dataset valid, _error = is_valid(block) diff --git a/src/vtkcelltypes.jl b/src/vtkcelltypes.jl index e5278fe..45a0e57 100644 --- a/src/vtkcelltypes.jl +++ b/src/vtkcelltypes.jl @@ -1,58 +1,61 @@ const VTK_CELL_TYPE = Dict( - 0=>WriteVTK.VTKCellTypes.VTK_EMPTY_CELL, - 1=>WriteVTK.VTKCellTypes.VTK_VERTEX, - 2=>WriteVTK.VTKCellTypes.VTK_POLY_VERTEX, - 3=>WriteVTK.VTKCellTypes.VTK_LINE, - 4=>WriteVTK.VTKCellTypes.VTK_POLY_LINE, - 5=>WriteVTK.VTKCellTypes.VTK_TRIANGLE, - 6=>WriteVTK.VTKCellTypes.VTK_TRIANGLE_STRIP, - 7=>WriteVTK.VTKCellTypes.VTK_POLYGON, - 8=>WriteVTK.VTKCellTypes.VTK_PIXEL, - 9=>WriteVTK.VTKCellTypes.VTK_QUAD, - 10=>WriteVTK.VTKCellTypes.VTK_TETRA, - 11=>WriteVTK.VTKCellTypes.VTK_VOXEL, - 12=>WriteVTK.VTKCellTypes.VTK_HEXAHEDRON, - 13=>WriteVTK.VTKCellTypes.VTK_WEDGE, - 14=>WriteVTK.VTKCellTypes.VTK_PYRAMID, - 15=>WriteVTK.VTKCellTypes.VTK_PENTAGONAL_PRISM, - 16=>WriteVTK.VTKCellTypes.VTK_HEXAGONAL_PRISM, - 21=>WriteVTK.VTKCellTypes.VTK_QUADRATIC_EDGE, - 22=>WriteVTK.VTKCellTypes.VTK_QUADRATIC_TRIANGLE, - 23=>WriteVTK.VTKCellTypes.VTK_QUADRATIC_QUAD, - 24=>WriteVTK.VTKCellTypes.VTK_QUADRATIC_TETRA, - 25=>WriteVTK.VTKCellTypes.VTK_QUADRATIC_HEXAHEDRON, - 26=>WriteVTK.VTKCellTypes.VTK_QUADRATIC_WEDGE, - 27=>WriteVTK.VTKCellTypes.VTK_QUADRATIC_PYRAMID, - 28=>WriteVTK.VTKCellTypes.VTK_BIQUADRATIC_QUAD, - 29=>WriteVTK.VTKCellTypes.VTK_TRIQUADRATIC_HEXAHEDRON, - 30=>WriteVTK.VTKCellTypes.VTK_QUADRATIC_LINEAR_QUAD, - 31=>WriteVTK.VTKCellTypes.VTK_QUADRATIC_LINEAR_WEDGE, - 32=>WriteVTK.VTKCellTypes.VTK_BIQUADRATIC_QUADRATIC_WEDGE, - 33=>WriteVTK.VTKCellTypes.VTK_BIQUADRATIC_QUADRATIC_HEXAHEDRON, - 34=>WriteVTK.VTKCellTypes.VTK_BIQUADRATIC_TRIANGLE, - 35=>WriteVTK.VTKCellTypes.VTK_CUBIC_LINE, - 36=>WriteVTK.VTKCellTypes.VTK_QUADRATIC_POLYGON, - 41=>WriteVTK.VTKCellTypes.VTK_CONVEX_POINT_SET, - 42=>WriteVTK.VTKCellTypes.VTK_POLYHEDRON, - 51=>WriteVTK.VTKCellTypes.VTK_PARAMETRIC_CURVE, - 52=>WriteVTK.VTKCellTypes.VTK_PARAMETRIC_SURFACE, - 53=>WriteVTK.VTKCellTypes.VTK_PARAMETRIC_TRI_SURFACE, - 54=>WriteVTK.VTKCellTypes.VTK_PARAMETRIC_QUAD_SURFACE, - 55=>WriteVTK.VTKCellTypes.VTK_PARAMETRIC_TETRA_REGION, - 56=>WriteVTK.VTKCellTypes.VTK_PARAMETRIC_HEX_REGION, - 60=>WriteVTK.VTKCellTypes.VTK_HIGHER_ORDER_EDGE, - 61=>WriteVTK.VTKCellTypes.VTK_HIGHER_ORDER_TRIANGLE, - 62=>WriteVTK.VTKCellTypes.VTK_HIGHER_ORDER_QUAD, - 63=>WriteVTK.VTKCellTypes.VTK_HIGHER_ORDER_POLYGON, - 64=>WriteVTK.VTKCellTypes.VTK_HIGHER_ORDER_TETRAHEDRON, - 65=>WriteVTK.VTKCellTypes.VTK_HIGHER_ORDER_WEDGE, - 66=>WriteVTK.VTKCellTypes.VTK_HIGHER_ORDER_PYRAMID, - 67=>WriteVTK.VTKCellTypes.VTK_HIGHER_ORDER_HEXAHEDRON) + 0 => WriteVTK.VTKCellTypes.VTK_EMPTY_CELL, + 1 => WriteVTK.VTKCellTypes.VTK_VERTEX, + 2 => WriteVTK.VTKCellTypes.VTK_POLY_VERTEX, + 3 => WriteVTK.VTKCellTypes.VTK_LINE, + 4 => WriteVTK.VTKCellTypes.VTK_POLY_LINE, + 5 => WriteVTK.VTKCellTypes.VTK_TRIANGLE, + 6 => WriteVTK.VTKCellTypes.VTK_TRIANGLE_STRIP, + 7 => WriteVTK.VTKCellTypes.VTK_POLYGON, + 8 => WriteVTK.VTKCellTypes.VTK_PIXEL, + 9 => WriteVTK.VTKCellTypes.VTK_QUAD, + 10 => WriteVTK.VTKCellTypes.VTK_TETRA, + 11 => WriteVTK.VTKCellTypes.VTK_VOXEL, + 12 => WriteVTK.VTKCellTypes.VTK_HEXAHEDRON, + 13 => WriteVTK.VTKCellTypes.VTK_WEDGE, + 14 => WriteVTK.VTKCellTypes.VTK_PYRAMID, + 15 => WriteVTK.VTKCellTypes.VTK_PENTAGONAL_PRISM, + 16 => WriteVTK.VTKCellTypes.VTK_HEXAGONAL_PRISM, + 21 => WriteVTK.VTKCellTypes.VTK_QUADRATIC_EDGE, + 22 => WriteVTK.VTKCellTypes.VTK_QUADRATIC_TRIANGLE, + 23 => WriteVTK.VTKCellTypes.VTK_QUADRATIC_QUAD, + 24 => WriteVTK.VTKCellTypes.VTK_QUADRATIC_TETRA, + 25 => WriteVTK.VTKCellTypes.VTK_QUADRATIC_HEXAHEDRON, + 26 => WriteVTK.VTKCellTypes.VTK_QUADRATIC_WEDGE, + 27 => WriteVTK.VTKCellTypes.VTK_QUADRATIC_PYRAMID, + 28 => WriteVTK.VTKCellTypes.VTK_BIQUADRATIC_QUAD, + 29 => WriteVTK.VTKCellTypes.VTK_TRIQUADRATIC_HEXAHEDRON, + 30 => WriteVTK.VTKCellTypes.VTK_QUADRATIC_LINEAR_QUAD, + 31 => WriteVTK.VTKCellTypes.VTK_QUADRATIC_LINEAR_WEDGE, + 32 => WriteVTK.VTKCellTypes.VTK_BIQUADRATIC_QUADRATIC_WEDGE, + 33 => WriteVTK.VTKCellTypes.VTK_BIQUADRATIC_QUADRATIC_HEXAHEDRON, + 34 => WriteVTK.VTKCellTypes.VTK_BIQUADRATIC_TRIANGLE, + 35 => WriteVTK.VTKCellTypes.VTK_CUBIC_LINE, + 36 => WriteVTK.VTKCellTypes.VTK_QUADRATIC_POLYGON, + 41 => WriteVTK.VTKCellTypes.VTK_CONVEX_POINT_SET, + 42 => WriteVTK.VTKCellTypes.VTK_POLYHEDRON, + 51 => WriteVTK.VTKCellTypes.VTK_PARAMETRIC_CURVE, + 52 => WriteVTK.VTKCellTypes.VTK_PARAMETRIC_SURFACE, + 53 => WriteVTK.VTKCellTypes.VTK_PARAMETRIC_TRI_SURFACE, + 54 => WriteVTK.VTKCellTypes.VTK_PARAMETRIC_QUAD_SURFACE, + 55 => WriteVTK.VTKCellTypes.VTK_PARAMETRIC_TETRA_REGION, + 56 => WriteVTK.VTKCellTypes.VTK_PARAMETRIC_HEX_REGION, + 60 => WriteVTK.VTKCellTypes.VTK_HIGHER_ORDER_EDGE, + 61 => WriteVTK.VTKCellTypes.VTK_HIGHER_ORDER_TRIANGLE, + 62 => WriteVTK.VTKCellTypes.VTK_HIGHER_ORDER_QUAD, + 63 => WriteVTK.VTKCellTypes.VTK_HIGHER_ORDER_POLYGON, + 64 => WriteVTK.VTKCellTypes.VTK_HIGHER_ORDER_TETRAHEDRON, + 65 => WriteVTK.VTKCellTypes.VTK_HIGHER_ORDER_WEDGE, + 66 => WriteVTK.VTKCellTypes.VTK_HIGHER_ORDER_PYRAMID, + 67 => WriteVTK.VTKCellTypes.VTK_HIGHER_ORDER_HEXAHEDRON, +) const POINT_CELLS = Int[1, 2, 41] const LINE_CELLS = Int[3, 4, 21, 35, 51, 60] const FACE_CELLS = Int[5, 6, 7, 8, 9, 22, 23, 28, 30, 34, 36, 52, 53, 54, 61, 62, 63] -const VOLUME_CELLS = Int[10, 11, 12, 13, 14, 15, 16, 24, 25, 26, 27, 29, 31, 32, 33, 42, 55, 56, 64, 65, 66, 67] +const VOLUME_CELLS = Int[ + 10, 11, 12, 13, 14, 15, 16, 24, 25, 26, 27, 29, 31, 32, 33, 42, 55, 56, 64, 65, 66, 67 +] const POLY_CELLS = Int[1, 2, 3, 4, 5, 6, 7, 8, 9] const LINEAR_CELLS = [0:16...] diff --git a/test/makingtypes.jl b/test/makingtypes.jl index ced9bf1..19c26c5 100644 --- a/test/makingtypes.jl +++ b/test/makingtypes.jl @@ -1,7 +1,7 @@ # This is an example that shows you how to create VTK data types natively in Julia using VTKDataTypes -import GeometryTypes +using GeometryTypes: GeometryTypes function create_image() origin = (0.0, 0.0, 0.0) @@ -18,32 +18,32 @@ function create_image() image.point_data["Point vector data"] = zeros(3, extents(image)...) image.cell_data["Cell vector data"] = zeros(3, cell_extents(image)...) - @test cell_connectivity(image, (1,1,1)) == [1, 2, 3, 4, 7, 8, 9, 10] - #Used to obtain the points which make up the cell in VTK convention - @test cell_type(image, (1,1,1)) == 11 - #Used to obtain the VTK cell type + @test cell_connectivity(image, (1, 1, 1)) == [1, 2, 3, 4, 7, 8, 9, 10] + #Used to obtain the points which make up the cell in VTK convention + @test cell_type(image, (1, 1, 1)) == 11 + #Used to obtain the VTK cell type @test image == deepcopy(image) return image end function create_rectilinear_data1() - x = y = z = collect(range(-2, stop=2, length=5)) + x = y = z = collect(range(-2; stop=2, length=5)) rectilinear = VTKRectilinearData((x, y, z)) @test dim(rectilinear) == 3 - @test extents(rectilinear) == (5,5,5) - @test cell_extents(rectilinear) == (4,4,4) + @test extents(rectilinear) == (5, 5, 5) + @test cell_extents(rectilinear) == (4, 4, 4) rectilinear.point_data["Point scalar data"] = zeros(extents(rectilinear)...) rectilinear.cell_data["Cell scalar data"] = zeros(cell_extents(rectilinear)...) rectilinear.point_data["Point vector data"] = zeros(3, extents(rectilinear)...) rectilinear.cell_data["Cell vector data"] = zeros(3, cell_extents(rectilinear)...) - @test cell_connectivity(rectilinear, (1,1,1)) == [1, 2, 7, 6, 26, 27, 32, 31] - #Used to obtain the points which make up the cell in VTK convention - @test cell_type(rectilinear, (1,1,1)) == 12 - #Used to obtain the VTK cell type + @test cell_connectivity(rectilinear, (1, 1, 1)) == [1, 2, 7, 6, 26, 27, 32, 31] + #Used to obtain the points which make up the cell in VTK convention + @test cell_type(rectilinear, (1, 1, 1)) == 12 + #Used to obtain the VTK cell type @test rectilinear == deepcopy(rectilinear) return rectilinear @@ -54,8 +54,8 @@ function create_rectilinear_data2() rectilinear = VTKRectilinearData(image) @test dim(rectilinear) == dim(image) == 3 - @test extents(rectilinear) == extents(image) == (2,3,5) - @test cell_extents(rectilinear) == cell_extents(image) == (1,2,4) + @test extents(rectilinear) == extents(image) == (2, 3, 5) + @test cell_extents(rectilinear) == cell_extents(image) == (1, 2, 4) return rectilinear end @@ -63,10 +63,10 @@ end function create_structured_data() rectilinear = create_rectilinear_data1() structured = VTKStructuredData(rectilinear) - @test size(structured.point_coords) == (3,extents(rectilinear)...) == (3,5,5,5) + @test size(structured.point_coords) == (3, extents(rectilinear)...) == (3, 5, 5, 5) - @test extents(structured) == extents(rectilinear) == (5,5,5) - @test cell_extents(structured) == cell_extents(rectilinear) == (4,4,4) + @test extents(structured) == extents(rectilinear) == (5, 5, 5) + @test cell_extents(structured) == cell_extents(rectilinear) == (4, 4, 4) @test dim(structured) == dim(rectilinear) == 3 structured.point_data["Point scalar data"] = zeros(extents(structured)...) @@ -74,10 +74,10 @@ function create_structured_data() structured.point_data["Point vector data"] = zeros(3, extents(structured)...) structured.cell_data["Cell vector data"] = zeros(3, cell_extents(structured)...) - @test cell_connectivity(structured, (1,1,1)) == [1, 2, 7, 6, 26, 27, 32, 31] - #Used to obtain the points which make up the cell in VTK convention - @test cell_type(structured, (1,1,1)) == 12 - #Used to obtain the VTK cell type + @test cell_connectivity(structured, (1, 1, 1)) == [1, 2, 7, 6, 26, 27, 32, 31] + #Used to obtain the points which make up the cell in VTK convention + @test cell_type(structured, (1, 1, 1)) == 12 + #Used to obtain the VTK cell type @test structured == deepcopy(structured) return structured @@ -91,7 +91,8 @@ function create_unstructured_data() @test length(unstruct1.cell_connectivity) == length(unstruct1.cell_types) @test size(unstruct1.point_coords) == (dim(unstruct1), num_of_points(unstruct1)) - @test size(unstruct1.point_data["Point scalar data"], 1) == size(unstruct1.point_coords, 2) + @test size(unstruct1.point_data["Point scalar data"], 1) == + size(unstruct1.point_coords, 2) @test size(unstruct1.cell_data["Cell vector data"]) == (3, num_of_cells(unstruct1)) @test unstruct1 == unstruct2 @@ -104,12 +105,13 @@ end function create_poly_data() rectilinear = create_rectilinear_data1() - polydata = VTKPolyData(rectilinear) - # automatically decomposes linear volume cells to faces and averages cell data + polydata = VTKPolyData(rectilinear) + # automatically decomposes linear volume cells to faces and averages cell data @test length(polydata.cell_connectivity) == length(polydata.cell_types) @test size(polydata.point_coords) == (dim(polydata), num_of_points(polydata)) - @test size(polydata.point_data["Point scalar data"], 1) == size(polydata.point_coords, 2) + @test size(polydata.point_data["Point scalar data"], 1) == + size(polydata.point_coords, 2) @test size(polydata.cell_data["Cell vector data"]) == (3, num_of_cells(polydata)) @test polydata == polydata @@ -117,8 +119,13 @@ function create_poly_data() end function create_multiblock_data() - mb = VTKMultiblockData((create_image(), create_rectilinear_data1(), - create_structured_data(), create_unstructured_data(), create_poly_data())) + mb = VTKMultiblockData(( + create_image(), + create_rectilinear_data1(), + create_structured_data(), + create_unstructured_data(), + create_poly_data(), + )) @test length(mb) == 5 for b in mb @test isa(b, AbstractVTKSimpleData) @@ -135,41 +142,45 @@ function create_timeseries_data() timemarkers = [0, 0.5, 1, 1.5] #2D polydata - x = y = [0., 1., 2.]; - point_coords = (x, y); - point_data = Dict{String, Array{Float64}}(); - cell_data = Dict{String, Array{Float64}}(); - a = VTKRectilinearData(point_coords, point_data, cell_data); - a.cell_data["Color"] = reshape(rand(num_of_cells(a)), cell_extents(a)); - b = VTKPolyData(a); - - x = y = [3., 4., 5.]; - point_coords = (x, y); - c = VTKPolyData(VTKRectilinearData(point_coords, point_data, cell_data)); - c.cell_data["Color"] = rand(num_of_cells(c)); - - m = VTKMultiblockData((b, c)); - timeseries = VTKTimeSeriesData([0.], [m]); - - no_of_timesteps = 5; - timestep = 0.5; - speed = 1; + x = y = [0.0, 1.0, 2.0] + point_coords = (x, y) + point_data = Dict{String,Array{Float64}}() + cell_data = Dict{String,Array{Float64}}() + a = VTKRectilinearData(point_coords, point_data, cell_data) + a.cell_data["Color"] = reshape(rand(num_of_cells(a)), cell_extents(a)) + b = VTKPolyData(a) + + x = y = [3.0, 4.0, 5.0] + point_coords = (x, y) + c = VTKPolyData(VTKRectilinearData(point_coords, point_data, cell_data)) + c.cell_data["Color"] = rand(num_of_cells(c)) + + m = VTKMultiblockData((b, c)) + timeseries = VTKTimeSeriesData([0.0], [m]) + + no_of_timesteps = 5 + timestep = 0.5 + speed = 1 i = 0 while i < no_of_timesteps - i += 1; - new_data = deepcopy(timeseries.data[i]); + i += 1 + new_data = deepcopy(timeseries.data[i]) #Random walk of first dataset - new_data[1].point_coords = new_data[1].point_coords + - vcat(fill(speed*rand()-speed/2, (1,num_of_points(new_data[1]))), - fill(speed*rand()-speed/2, (1,num_of_points(new_data[1])))); - + new_data[1].point_coords = + new_data[1].point_coords + vcat( + fill(speed * rand() - speed / 2, (1, num_of_points(new_data[1]))), + fill(speed * rand() - speed / 2, (1, num_of_points(new_data[1]))), + ) + #Random walk of second dataset - new_data[2].point_coords = new_data[2].point_coords + - vcat(fill(speed*rand()-speed/2, (1,num_of_points(new_data[2]))), - fill(speed*rand()-speed/2, (1,num_of_points(new_data[2])))); + new_data[2].point_coords = + new_data[2].point_coords + vcat( + fill(speed * rand() - speed / 2, (1, num_of_points(new_data[2]))), + fill(speed * rand() - speed / 2, (1, num_of_points(new_data[2]))), + ) - insert_timed_data!(timeseries, i*timestep, new_data); + insert_timed_data!(timeseries, i * timestep, new_data) end for ts in timeseries