Functions
comododir
Comodo.comododir — Functioncomododir()Description
This function simply returns the string for the Comodo path. This is helpful for instance to load items, such as meshes, from the assets` folder.
slidercontrol
Comodo.slidercontrol — Functionslidercontrol(hSlider,ax)Adds arrow key control to sliders
Description
This function adds arrow key control to Makie sliders. The inputs are the slider handle hSlider as well as the axis ax. If this function is called the slider can be advanced a step by pressing the right arrow, and returned one step by pressing the left arrow. When one presses and holds the right or left arrow key, the slider will continue to move (as fast as graphics updating is possible on your system) up to the end or start slider position respectively. Users may also use the up or down arrow keys. These function the same as the right and left arrow keys, however, rather than stopping at the slider extrema, the sliders position will "wrap" back to the start when advancing beyond the end position, and vice versa.
slider2anim
Comodo.slider2anim — Functionslider2anim(fig::Figure,hSlider::Slider,fileName::String; backforth=true, duration=2)Exports movies from slider based visualisations.
Description
Converts the effect of the slider defined by the slider handle hSlider for the figure fig to an animation/movie file
elements2indices
Comodo.elements2indices — Functionelements2indices(F)Returns the indices contained in F
Description
This function obtains the unique set of indices for the vertices (nodes) used by the the simplices defined by F. The vector F may contain any type of simplices. For instance the elements in F may be of the type GeometryBasics.TriangleFace or GeometryBasics.QuadFace (or any other) for surface mesh data. However, volumetric elements of any type are permitted. In essence this function simply returns unique(reduce(vcat,F)). Hence any suitable vector containing vectors of numbers permitted by reduce(vcat,F) is supported.
gridpoints
Comodo.gridpoints — Functiongridpoints(x::Vector{T}, y=x, z=x) where T<:RealReturns 3D grids of points
Description
The gridpoints function returns a vector of 3D points which span a grid in 3D space. Points are defined as per the input ranges or range vectors. The output point vector contains elements of the type Point.
gridpoints_equilateral
Comodo.gridpoints_equilateral — Functiongridpoints_equilateral(xSpan,ySpan,pointSpacing::T; return_faces = false, rectangular=false) where T <: RealReturns a "grid" of 3D points that are located on the corners of an equilateral triangle tesselation.
Description
This function returns 3D point data in the form of a Vector{Point{3,Float64}}. The point distribution is for an equilateral triangle tesselation. The input consists of the span in the x-, and y-direction, i.e. xSpan and ySpan respectively, as well as the desired pointSpacing. The "spans" should be vectors or tuples defining the minimum and maximum coordinates for the grid. The true point spacing in the x-direction is computed such that a nearest whole number of steps can cover the required distance. Next this spacing is used to create the equilateral triangle point grid. Although the xSpan is closely adhered to through this method, the ySpan is not fully covered. In the y-direction the grid does start at the minimum level, but may stop short of reaching the maximum y as it may not be reachable in a whole number of steps from the minimum. Optional arguments include return_faces (default is false), which will cause the function to return triangular faces F as well as the vertices V. Secondly the option rectangular will force the grid to conform to a rectangular domain. This means the "jagged" sides are forced to be flat such that all x-coordinates on the left are at the minimum in xSpan and all on the right are at the maximum in xSpan, however, this does result in a non-uniform spacing at these edges.
interp_biharmonic_spline
Comodo.interp_biharmonic_spline — Functioninterp_biharmonic_spline(x::Union{Vector{T}, AbstractRange{T}},y::Union{Vector{T}, AbstractRange{T}},xi::Union{Vector{T}, AbstractRange{T}}; extrapolate_method=:linear,pad_data=:linear) where T<:RealInterpolates 1D (curve) data using biharmonic spline interpolation
Description
This function uses biharmonic spline interpolation [1], which features radial basis functions. The input is assumed to represent ordered data, i.e. consequtive unique points on a curve. The curve x-, and y-coordinates are provided through the input parameters x and y respectively. The third input xi defines the sites at which to interpolate. Each of in the input parameters can be either a vector or a range.
References
interp_biharmonic
Comodo.interp_biharmonic — Functioninterp_biharmonic(x,y,xi)Interpolates n-dimensional data using biharmonic spline interpolation
Description
This function uses biharmonic interpolation [1]. The input x should define a vector consisting of m points which are n-dimensional, and the input y should be a vector consisting of m scalar data values.
References
nbezier
Comodo.nbezier — Functionnbezier(P,n)Returns a Bezier spline for the control points P whose order matches the numbe of control points provided.
Description
This function returns n points for an m-th order Bézier spline, based on the m control points contained in the input vector P. This function supports point vectors with elements of the type AbstractPoint{3} (e.g. Point{3, Float64}) or Vector{Float64}.
lerp
Comodo.lerp — Functionlerp(x::Union{T,Vector{T}, AbstractRange{T}},y,xi::Union{T,Vector{T}, AbstractRange{T}}) where T <: RealLinear interpolation
Description
This linearly interpolates (lerps) the input data specified by the sites x and data y at the specified sites xi.
dist
Comodo.dist — Functiondist(V1,V2)Computes n-dimensional Euclidean distances
Description
Function compute an nxm distance matrix for the n inputs points in V1, and the m input points in V2. The input points may be multidimensional, in fact they can be any type supported by the euclidean function of Distances.jl. See also: https://github.com/JuliaStats/Distances.jl
mindist
Comodo.mindist — Functionmindist(V1,V2; getIndex=false, skipSelf = false )Returns nearest point distances
Description
Returns the closest point distance for the input points V1 with respect to the input points V2. If the optional parameter getIndex is set to true (false by default) then this function also returns the indices of the nearest points in V2 for each point in V1. For self-distance evaluation, i.e. if the same point set is provided twice, then the optional parameter skipSelf can be set t0 true (default is false) if "self distances" (e.g. the nth point to the nth point) are to be avoided.
unique_dict_index
Comodo.unique_dict_index — Functionunique_dict_index(X::Union{Array{T},Tuple{T}}; sort_entries=false) where T <: AnyReturns unique values and indices
Description
Returns the unique entries in X as well as the indices for them. The optional parameter sort_entries (default is false) can be set to true if each entry in X should be sorted, this is helpful to allow the entry [1,2] to be seen as the same as [2,1] for instance.
unique_dict_index_inverse
Comodo.unique_dict_index_inverse — Functionunique_dict_index_inverse(X::Union{Array{T},Tuple{T}}; sort_entries=false) where T <: AnyReturns unique values, indices, and inverse indices
Description
Returns the unique entries in X as well as the indices for them and the reverse indices to retrieve the original from the unique entries. The optional parameter sort_entries (default is false) can be set to true if each entry in X should be sorted, this is helpful to allow the entry [1,2] to be seen as the same as [2,1] for instance.
unique_dict_index_count
Comodo.unique_dict_index_count — Functionunique_dict_index_count(X::Union{Array{T},Tuple{T}}; sort_entries=false) where T <: AnyReturns unique values, indices, and counts
Description
Returns the unique entries in X as well as the indices for them and the counts in terms of how often they occured. The optional parameter sort_entries (default is false) can be set to true if each entry in X should be sorted, this is helpful to allow the entry [1,2] to be seen as the same as [2,1] for instance.
unique_dict_index_inverse_count
Comodo.unique_dict_index_inverse_count — Functionunique_dict_index_inverse_count(X::Union{Array{T},Tuple{T}}; sort_entries=false) where T <: AnyReturns unique values, indices, inverse indices, and counts
Description
Returns the unique entries in X as well as the indices for them and the reverse indices to retrieve the original from the unique entries, and also the counts in terms of how often they occured. The optional parameter sort_entries (default is false) can be set to true if each entry in X should be sorted, this is helpful to allow the entry [1,2] to be seen as the same as [2,1] for instance.
unique_dict_count
Comodo.unique_dict_count — Functionunique_dict_count(X::Union{Array{T},Tuple{T}}; sort_entries=false) where T <: AnyReturns unique values and counts
Description
Returns the unique entries in X as well as the counts in terms of how often they occured. The optional parameter sort_entries (default is false) can be set to true if each entry in X should be sorted, this is helpful to allow the entry [1,2] to be seen as the same as [2,1] for instance.
unique_dict_inverse
Comodo.unique_dict_inverse — Functionunique_dict_inverse(X::Union{Array{T},Tuple{T}}; sort_entries=false) where T <: AnyReturns unique values and inverse indices
Description
Returns the unique entries in X as well as the reverse indices to retrieve the original from the unique entries. The optional parameter sort_entries (default is false) can be set to true if each entry in X should be sorted, this is helpful to allow the entry [1,2] to be seen as the same as [2,1] for instance.
unique_dict
Comodo.unique_dict — Functionunique_dict(X::AbstractVector{T}) where T <: RealReturns unique values, indices, and inverse indices. Uses an OrderedDict.
Description
Returns the unique entries in X as well as the indices for them and the reverse indices to retrieve the original from the unique entries.
gunique
Comodo.gunique — Functiongunique(X; return_unique=true, return_index=false, return_inverse=false, return_counts=false, sort_entries=false)Returns unique values and allows users to choose if they also want: sorting, indices, inverse indices, and counts.
Description
Returns the unique entries in X. Depending on the optional parameter choices the indices for the unique entries, the reverse indices to retrieve the original from the unique entries, as well as counts in terms of how often they occured, can be returned. The optional parameter sort_entries (default is false) can be set to true if each entry in X should be sorted, this is helpful to allow the entry [1,2] to be seen as the same as [2,1] for instance.
unique_simplices
Comodo.unique_simplices — Functionunique_simplices(F,V=nothing)Returns unique simplices (such as faces), independant of node order
Description
Returns the unique simplices in F as well as the indices of the unique simplices and the reverse indices to retrieve the original faces from the unique faces. Entries in F are sorted such that the node order does not matter.
ind2sub
Comodo.ind2sub — Functionind2sub(siz,ind)Converts linear indices to subscript indices.
Description
Converts the linear indices in ind, for a matrix/array with size siz, to the equivalent subscript indices.
sub2ind
Comodo.sub2ind — Functionsub2ind(siz,A)Converts subscript indices to linear indices.
Description
Converts the subscript indices in A, for a matrix/array with size siz, to the equivalent linear indices.
meshedges
Comodo.meshedges — Functionmeshedges(F::Array{NgonFace{N,T},1}; unique_only=false) where N where T<:IntegerReturns a mesh's edges.
Description
This function returns the edges E for the input faces defined by F. The input F can either represent a vector of faces or a GeometryBasics.Mesh. The convention is such that for a face referring to the nodes 1-2-3-4, the edges are 1-2, 2-3, 3-4, 4-1.
icosahedron
Comodo.icosahedron — Functionicosahedron(r=1.0)Creates an icosahedron mesh.
Description
Creates a GeometryBasics.Mesh for an icosahedron with radius r. The default radius, when not supplied, is 1.0.
octahedron
Comodo.octahedron — Functionoctahedron(r=1.0)Creates an octahedron mesh.
Description
Creates a GeometryBasics.Mesh for an octahedron with radius r. The default radius, when not supplied, is 1.0.
dodecahedron
Comodo.dodecahedron — Functiondodecahedron(r=1.0)Creates a dodecahedron mesh.
Description
Creates a GeometryBasics.Mesh for an dodecahedron with radius r. The default radius, when not supplied, is 1.0.
cube
Comodo.cube — Functioncube(r=1.0)Creates a cube mesh.
Description
Creates a GeometryBasics.Mesh for an cube with radius r. The default radius, when not supplied, is 1.0.
tetrahedron
Comodo.tetrahedron — Functiontetrahedron(r=1.0)Creates a tetrahedron mesh.
Description
Creates a GeometryBasics.Mesh for an tetrahedron with radius r. The default radius, when not supplied, is 1.0.
platonicsolid
Comodo.platonicsolid — Functionplatonicsolid(n,r=1.0)Returns a platonic solid mesh.
Description
Creates a GeometryBasics mesh description for a platonic solid of choice. The input n defines the choice.
- tetrahedron
- cube
- octahedron
- icosahedron
- dodecahedron
The final input parameter r defines the radius of the platonic solid (the radius of the circumsphere to the vertices). The default radius, when not supplied, is 1.0.
Arguments
n::Integer, defining platonic solid type r::Float64, defining circumsphere radius
tofaces
Comodo.tofaces — Functiontofaces(FM::Vector{Vector{TF}}) where TF<:Integer
+Functions · A Julia package for computational (bio)mechanics and computational design Functions
comododir
Comodo.comododir — Functioncomododir()
Description
This function simply returns the string for the Comodo path. This is helpful for instance to load items, such as meshes, from the assets` folder.
sourceslidercontrol
Comodo.slidercontrol — Functionslidercontrol(hSlider,ax)
Adds arrow key control to sliders
Description
This function adds arrow key control to Makie sliders. The inputs are the slider handle hSlider as well as the axis ax. If this function is called the slider can be advanced a step by pressing the right arrow, and returned one step by pressing the left arrow. When one presses and holds the right or left arrow key, the slider will continue to move (as fast as graphics updating is possible on your system) up to the end or start slider position respectively. Users may also use the up or down arrow keys. These function the same as the right and left arrow keys, however, rather than stopping at the slider extrema, the sliders position will "wrap" back to the start when advancing beyond the end position, and vice versa.
sourceslider2anim
Comodo.slider2anim — Functionslider2anim(fig::Figure,hSlider::Slider,fileName::String; backforth=true, duration=2)
Exports movies from slider based visualisations.
Description
Converts the effect of the slider defined by the slider handle hSlider for the figure fig to an animation/movie file
sourceelements2indices
Comodo.elements2indices — Functionelements2indices(F)
Returns the indices contained in F
Description
This function obtains the unique set of indices for the vertices (nodes) used by the the simplices defined by F. The vector F may contain any type of simplices. For instance the elements in F may be of the type GeometryBasics.TriangleFace or GeometryBasics.QuadFace (or any other) for surface mesh data. However, volumetric elements of any type are permitted. In essence this function simply returns unique(reduce(vcat,F)). Hence any suitable vector containing vectors of numbers permitted by reduce(vcat,F) is supported.
sourcegridpoints
Comodo.gridpoints — Functiongridpoints(x::Vector{T}, y=x, z=x) where T<:Real
Returns 3D grids of points
Description
The gridpoints function returns a vector of 3D points which span a grid in 3D space. Points are defined as per the input ranges or range vectors. The output point vector contains elements of the type Point.
sourcegridpoints_equilateral
Comodo.gridpoints_equilateral — Functiongridpoints_equilateral(xSpan,ySpan,pointSpacing::T; return_faces = false, rectangular=false) where T <: Real
Returns a "grid" of 3D points that are located on the corners of an equilateral triangle tesselation.
Description
This function returns 3D point data in the form of a Vector{Point{3,Float64}}. The point distribution is for an equilateral triangle tesselation. The input consists of the span in the x-, and y-direction, i.e. xSpan and ySpan respectively, as well as the desired pointSpacing. The "spans" should be vectors or tuples defining the minimum and maximum coordinates for the grid. The true point spacing in the x-direction is computed such that a nearest whole number of steps can cover the required distance. Next this spacing is used to create the equilateral triangle point grid. Although the xSpan is closely adhered to through this method, the ySpan is not fully covered. In the y-direction the grid does start at the minimum level, but may stop short of reaching the maximum y as it may not be reachable in a whole number of steps from the minimum. Optional arguments include return_faces (default is false), which will cause the function to return triangular faces F as well as the vertices V. Secondly the option rectangular will force the grid to conform to a rectangular domain. This means the "jagged" sides are forced to be flat such that all x-coordinates on the left are at the minimum in xSpan and all on the right are at the maximum in xSpan, however, this does result in a non-uniform spacing at these edges.
sourceinterp_biharmonic_spline
Comodo.interp_biharmonic_spline — Functioninterp_biharmonic_spline(x::Union{Vector{T}, AbstractRange{T}},y::Union{Vector{T}, AbstractRange{T}},xi::Union{Vector{T}, AbstractRange{T}}; extrapolate_method=:linear,pad_data=:linear) where T<:Real
Interpolates 1D (curve) data using biharmonic spline interpolation
Description
This function uses biharmonic spline interpolation [1], which features radial basis functions. The input is assumed to represent ordered data, i.e. consequtive unique points on a curve. The curve x-, and y-coordinates are provided through the input parameters x and y respectively. The third input xi defines the sites at which to interpolate. Each of in the input parameters can be either a vector or a range.
References
sourceinterp_biharmonic
Comodo.interp_biharmonic — Functioninterp_biharmonic(x,y,xi)
Interpolates n-dimensional data using biharmonic spline interpolation
Description
This function uses biharmonic interpolation [1]. The input x should define a vector consisting of m points which are n-dimensional, and the input y should be a vector consisting of m scalar data values.
References
sourcenbezier
Comodo.nbezier — Functionnbezier(P,n)
Returns a Bezier spline for the control points P whose order matches the numbe of control points provided.
Description
This function returns n points for an m-th order Bézier spline, based on the m control points contained in the input vector P. This function supports point vectors with elements of the type AbstractPoint{3} (e.g. Point{3, Float64}) or Vector{Float64}.
sourcelerp
Comodo.lerp — Functionlerp(x::Union{T,Vector{T}, AbstractRange{T}},y,xi::Union{T,Vector{T}, AbstractRange{T}}) where T <: Real
Linear interpolation
Description
This linearly interpolates (lerps) the input data specified by the sites x and data y at the specified sites xi.
sourcedist
Comodo.dist — Functiondist(V1,V2)
Computes n-dimensional Euclidean distances
Description
Function compute an nxm distance matrix for the n inputs points in V1, and the m input points in V2. The input points may be multidimensional, in fact they can be any type supported by the euclidean function of Distances.jl. See also: https://github.com/JuliaStats/Distances.jl
sourcemindist
Comodo.mindist — Functionmindist(V1,V2; getIndex=false, skipSelf = false )
Returns nearest point distances
Description
Returns the closest point distance for the input points V1 with respect to the input points V2. If the optional parameter getIndex is set to true (false by default) then this function also returns the indices of the nearest points in V2 for each point in V1. For self-distance evaluation, i.e. if the same point set is provided twice, then the optional parameter skipSelf can be set t0 true (default is false) if "self distances" (e.g. the nth point to the nth point) are to be avoided.
sourceunique_dict_index
Comodo.unique_dict_index — Functionunique_dict_index(X::Union{Array{T},Tuple{T}}; sort_entries=false) where T <: Any
Returns unique values and indices
Description
Returns the unique entries in X as well as the indices for them. The optional parameter sort_entries (default is false) can be set to true if each entry in X should be sorted, this is helpful to allow the entry [1,2] to be seen as the same as [2,1] for instance.
sourceunique_dict_index_inverse
Comodo.unique_dict_index_inverse — Functionunique_dict_index_inverse(X::Union{Array{T},Tuple{T}}; sort_entries=false) where T <: Any
Returns unique values, indices, and inverse indices
Description
Returns the unique entries in X as well as the indices for them and the reverse indices to retrieve the original from the unique entries. The optional parameter sort_entries (default is false) can be set to true if each entry in X should be sorted, this is helpful to allow the entry [1,2] to be seen as the same as [2,1] for instance.
sourceunique_dict_index_count
Comodo.unique_dict_index_count — Functionunique_dict_index_count(X::Union{Array{T},Tuple{T}}; sort_entries=false) where T <: Any
Returns unique values, indices, and counts
Description
Returns the unique entries in X as well as the indices for them and the counts in terms of how often they occured. The optional parameter sort_entries (default is false) can be set to true if each entry in X should be sorted, this is helpful to allow the entry [1,2] to be seen as the same as [2,1] for instance.
sourceunique_dict_index_inverse_count
Comodo.unique_dict_index_inverse_count — Functionunique_dict_index_inverse_count(X::Union{Array{T},Tuple{T}}; sort_entries=false) where T <: Any
Returns unique values, indices, inverse indices, and counts
Description
Returns the unique entries in X as well as the indices for them and the reverse indices to retrieve the original from the unique entries, and also the counts in terms of how often they occured. The optional parameter sort_entries (default is false) can be set to true if each entry in X should be sorted, this is helpful to allow the entry [1,2] to be seen as the same as [2,1] for instance.
sourceunique_dict_count
Comodo.unique_dict_count — Functionunique_dict_count(X::Union{Array{T},Tuple{T}}; sort_entries=false) where T <: Any
Returns unique values and counts
Description
Returns the unique entries in X as well as the counts in terms of how often they occured. The optional parameter sort_entries (default is false) can be set to true if each entry in X should be sorted, this is helpful to allow the entry [1,2] to be seen as the same as [2,1] for instance.
sourceunique_dict_inverse
Comodo.unique_dict_inverse — Functionunique_dict_inverse(X::Union{Array{T},Tuple{T}}; sort_entries=false) where T <: Any
Returns unique values and inverse indices
Description
Returns the unique entries in X as well as the reverse indices to retrieve the original from the unique entries. The optional parameter sort_entries (default is false) can be set to true if each entry in X should be sorted, this is helpful to allow the entry [1,2] to be seen as the same as [2,1] for instance.
sourceunique_dict
Comodo.unique_dict — Functionunique_dict(X::AbstractVector{T}) where T <: Real
Returns unique values, indices, and inverse indices. Uses an OrderedDict.
Description
Returns the unique entries in X as well as the indices for them and the reverse indices to retrieve the original from the unique entries.
sourcegunique
Comodo.gunique — Functiongunique(X; return_unique=true, return_index=false, return_inverse=false, return_counts=false, sort_entries=false)
Returns unique values and allows users to choose if they also want: sorting, indices, inverse indices, and counts.
Description
Returns the unique entries in X. Depending on the optional parameter choices the indices for the unique entries, the reverse indices to retrieve the original from the unique entries, as well as counts in terms of how often they occured, can be returned. The optional parameter sort_entries (default is false) can be set to true if each entry in X should be sorted, this is helpful to allow the entry [1,2] to be seen as the same as [2,1] for instance.
sourceunique_simplices
Comodo.unique_simplices — Functionunique_simplices(F,V=nothing)
Returns unique simplices (such as faces), independant of node order
Description
Returns the unique simplices in F as well as the indices of the unique simplices and the reverse indices to retrieve the original faces from the unique faces. Entries in F are sorted such that the node order does not matter.
sourceind2sub
Comodo.ind2sub — Functionind2sub(siz,ind)
Converts linear indices to subscript indices.
Description
Converts the linear indices in ind, for a matrix/array with size siz, to the equivalent subscript indices.
sourcesub2ind
Comodo.sub2ind — Functionsub2ind(siz,A)
Converts subscript indices to linear indices.
Description
Converts the subscript indices in A, for a matrix/array with size siz, to the equivalent linear indices.
sourcemeshedges
Comodo.meshedges — Functionmeshedges(F::Array{NgonFace{N,T},1}; unique_only=false) where N where T<:Integer
Returns a mesh's edges.
Description
This function returns the edges E for the input faces defined by F. The input F can either represent a vector of faces or a GeometryBasics.Mesh. The convention is such that for a face referring to the nodes 1-2-3-4, the edges are 1-2, 2-3, 3-4, 4-1.
sourceicosahedron
Comodo.icosahedron — Functionicosahedron(r=1.0)
Creates an icosahedron mesh.
Description
Creates a GeometryBasics.Mesh for an icosahedron with radius r. The default radius, when not supplied, is 1.0.
sourceoctahedron
Comodo.octahedron — Functionoctahedron(r=1.0)
Creates an octahedron mesh.
Description
Creates a GeometryBasics.Mesh for an octahedron with radius r. The default radius, when not supplied, is 1.0.
sourcedodecahedron
Comodo.dodecahedron — Functiondodecahedron(r=1.0)
Creates a dodecahedron mesh.
Description
Creates a GeometryBasics.Mesh for an dodecahedron with radius r. The default radius, when not supplied, is 1.0.
sourcecube
Comodo.cube — Functioncube(r=1.0)
Creates a cube mesh.
Description
Creates a GeometryBasics.Mesh for an cube with radius r. The default radius, when not supplied, is 1.0.
sourcetetrahedron
Comodo.tetrahedron — Functiontetrahedron(r=1.0)
Creates a tetrahedron mesh.
Description
Creates a GeometryBasics.Mesh for an tetrahedron with radius r. The default radius, when not supplied, is 1.0.
sourceplatonicsolid
Comodo.platonicsolid — Functionplatonicsolid(n,r=1.0)
Returns a platonic solid mesh.
Description
Creates a GeometryBasics mesh description for a platonic solid of choice. The input n defines the choice.
- tetrahedron
- cube
- octahedron
- icosahedron
- dodecahedron
The final input parameter r defines the radius of the platonic solid (the radius of the circumsphere to the vertices). The default radius, when not supplied, is 1.0.
Arguments
n::Integer, defining platonic solid type r::Float64, defining circumsphere radius
sourcetofaces
Comodo.tofaces — Functiontofaces(FM::Vector{Vector{TF}}) where TF<:Integer
tofaces(FM::Matrix{TF}) where TF<:Integer
tofaces(FM::Vector{NgonFace{m, OffsetInteger{-1, TF}}} ) where m where TF <: Integer
-tofaces(FM::Vector{NgonFace{m, TF}} ) where m where TF <: Integer
Converts input to GeometryBasics compliant faces with standard integer types.
Description
The tofaces function converts "non-standard" (for Comodo) face set descriptions to "standard" ones. The following is considered such as standard: Vector{GeometryBasics.NgonFace{N,T}} where N where T<:Integer The input faces FM are converted to this format. FM can be of the following types:
FM::Vector{Vector{TF}} where TF<:Integer, whereby each Vector entry is
considered a face
FM::Matrix{TF} where TF<:Integer, whereby each row is considered a faceVector{NgonFace{m, OffsetInteger{-1, TF}}} where TF<:Integer, whereby the
special integer type OffsetInteger{-1, TF} is converted to Int. If the intput is already of the right type this function leaves the input unchanged.
sourcetopoints
Comodo.topoints — Functiontopoints(VM::Matrix{T}) where T<: Real
+tofaces(FM::Vector{NgonFace{m, TF}} ) where m where TF <: Integer
Converts input to GeometryBasics compliant faces with standard integer types.
Description
The tofaces function converts "non-standard" (for Comodo) face set descriptions to "standard" ones. The following is considered such as standard: Vector{GeometryBasics.NgonFace{N,T}} where N where T<:Integer The input faces FM are converted to this format. FM can be of the following types:
FM::Vector{Vector{TF}} where TF<:Integer, whereby each Vector entry is
considered a face
FM::Matrix{TF} where TF<:Integer, whereby each row is considered a faceVector{NgonFace{m, OffsetInteger{-1, TF}}} where TF<:Integer, whereby the
special integer type OffsetInteger{-1, TF} is converted to Int. If the intput is already of the right type this function leaves the input unchanged.
sourcetopoints
Comodo.topoints — Functiontopoints(VM::Matrix{T}) where T<: Real
topoints(VM::Union{Array{Vec{N, T}, 1}, GeometryBasics.StructArray{TT,1} }) where TT <: AbstractPoint{N,T} where T <: Real where N
topoints(VM::Vector{Vector{T}}) where T <: Real
-topoints(VM::Vector{Point{ND,TV}}) where ND where TV <: Real
Converts input to GeometryBasics compliant simple points without meta content.
Description
The topoints function converts the "non-standard" (for Comodo) input points defined by VM to the "standard" format: VM::Vector{Point{ND,TV}} where ND where TV <: Real. For matrix input each row is considered a point. For vector input each vector entry is considered a point.
sourcetogeometrybasics_mesh
Comodo.togeometrybasics_mesh — Functiontogeometrybasics_mesh
Converts the input to a GeometryBasics.Mesh
Description
This function converts the input faces F and vertices V to a GeometryBasics.Mesh. The function tofaces and topoints are used prior to conversion, to ensure standard faces and point types are used.
sourceedgecrossproduct
Comodo.edgecrossproduct — Functionedgecrossproduct(F,V::Vector{Point{ND,T}}) where ND where T<:Real
-edgecrossproduct(M::GeometryBasics.Mesh)
Returns the edge cross product, useful for nomal direction and area computations.
# Description
This function computes the so-called edge-cross-product for a input mesh that is either defined by the faces F and vertices V or the mesh M.
sourcefacenormal
Comodo.facenormal — Functionfacenormal(F,V)
Returns the normal directions for each face.
Description
This function computes the per face normal directions for the input mesh defined either by the faces F and vertices V or by the GeometryBasics mesh M.
sourcefacearea
Comodo.facearea — Functionfacearea(F,V)
Returns the area for each face.
Description
This function computes the per face area for the input mesh defined either by the faces F and vertices V or by the GeometryBasics mesh M.
sourcevertexnormal
Comodo.vertexnormal — Functionvertexnormal(F,V; weighting=:area)
Returns the surface normal at each vertex.
Description
This function computes the per vertex surface normal directions for the input mesh defined either by the faces F and vertices V or by the GeometryBasics mesh M. The optional parameter weighting sets how the face normal directions are averaged onto the vertices. If weighting=:none a plain average for the surrounding faces is used. If instead weighting=:area (default), then the average is weighted based on the face areas.
sourceedgelengths
Comodo.edgelengths — Functionedgelengths(E::LineFace,V)
+topoints(VM::Vector{Point{ND,TV}}) where ND where TV <: Real
Converts input to GeometryBasics compliant simple points without meta content.
Description
The topoints function converts the "non-standard" (for Comodo) input points defined by VM to the "standard" format: VM::Vector{Point{ND,TV}} where ND where TV <: Real. For matrix input each row is considered a point. For vector input each vector entry is considered a point.
sourcetogeometrybasics_mesh
Comodo.togeometrybasics_mesh — Functiontogeometrybasics_mesh
Converts the input to a GeometryBasics.Mesh
Description
This function converts the input faces F and vertices V to a GeometryBasics.Mesh. The function tofaces and topoints are used prior to conversion, to ensure standard faces and point types are used.
sourceedgecrossproduct
Comodo.edgecrossproduct — Functionedgecrossproduct(F,V::Vector{Point{ND,T}}) where ND where T<:Real
+edgecrossproduct(M::GeometryBasics.Mesh)
Returns the edge cross product, useful for nomal direction and area computations.
# Description
This function computes the so-called edge-cross-product for a input mesh that is either defined by the faces F and vertices V or the mesh M.
sourcefacenormal
Comodo.facenormal — Functionfacenormal(F,V)
Returns the normal directions for each face.
Description
This function computes the per face normal directions for the input mesh defined either by the faces F and vertices V or by the GeometryBasics mesh M.
sourcefacearea
Comodo.facearea — Functionfacearea(F,V)
Returns the area for each face.
Description
This function computes the per face area for the input mesh defined either by the faces F and vertices V or by the GeometryBasics mesh M.
sourcevertexnormal
Comodo.vertexnormal — Functionvertexnormal(F,V; weighting=:area)
Returns the surface normal at each vertex.
Description
This function computes the per vertex surface normal directions for the input mesh defined either by the faces F and vertices V or by the GeometryBasics mesh M. The optional parameter weighting sets how the face normal directions are averaged onto the vertices. If weighting=:none a plain average for the surrounding faces is used. If instead weighting=:area (default), then the average is weighted based on the face areas.
sourceedgelengths
Comodo.edgelengths — Functionedgelengths(E::LineFace,V)
edgelengths(F,V)
-edgelengths(M::GeometryBasics.Mesh)
Returns edge lengths.
Description
This function computes the lengths of the edges defined by edge vector E (e.g as obtained from meshedges(F,V), where F is a face vector, and V is a vector of vertices. Alternatively the input mesh can be a GeometryBasics mesh M.
sourcesubtri
Comodo.subtri — Functionsubtri(F,V,n; method = :linear)
-subtri(F,V,n; method = :Loop)
Refines triangulations through splitting.
Description
The subtri function refines triangulated meshes iteratively. For each iteration each original input triangle is split into 4 triangles to form the refined mesh (one central one, and 3 at each corner). The following refinement methods are implemented:
method=:linear : This is the default method, and refines the triangles in a simple linear manor through splitting. Each input edge simply obtains a new mid-edge node.
method=:Loop : This method features Loop-subdivision [1,2]. Rather than linearly splitting edges and maintaining the original coordinates, as for the linear method, this method computes the new points in a special weighted sense such that the surface effectively approaches a "quartic box spline". Hence this method both refines and smoothes the geometry through spline approximation.
References
sourcesubquad
Comodo.subquad — Functionsubquad(F::Vector{NgonFace{4,TF}},V::Vector{Point{ND,TV}},n::Int; method=:linear) where TF<:Integer where ND where TV <: Real subquad(F::Vector{NgonFace{4,TF}},V::Vector{Point{ND,TV}},n::Int; method=:Catmull_Clark) where TF<:Integer where ND where TV <: Real
Refines quadrangulations through splitting.
Description
The subquad function refines quad meshes iteratively. For each iteration each original input quad is split into 4 smaller quads to form the refined mesh. The following refinement methods are implemented:
method=:linear : This is the default method, and refines the quads in a simple linear manor through splitting. Each input edge simply obtains a new mid-edge node, and each face obtains a new central node.
method=:Catmull_Clark : This method features Catmull_Clark-subdivision [1]. Rather than linearly splitting edges and maintaining the original coordinates, as for the linear method, this method computes the new points in a special weighted sense such that the surface effectively approaches a bicubic B-spline surface. Hence this method both refines and smoothes the geometry through spline approximation.
References
sourcegeosphere
Comodo.geosphere — Functiongeosphere(n::Int,r::T; method=:linear) where T <: Real
Returns a geodesic sphere triangulation
Description
This function returns a geodesic sphere triangulation based on the number of refinement iterations n and the radius r. Geodesic spheres (aka Buckminster-Fuller spheres) are triangulations of a sphere that have near uniform edge lenghts. The algorithm starts with a regular icosahedron. Next this icosahedron is refined n times, while nodes are pushed to a sphere surface with radius r at each iteration. Two methods are available, i.e. :linear (default) and :Loop (see also subtri). The former features simply linear splitting while the latter features the Loop method which may produce a smoother result.
sourcehexbox
Comodo.hexbox — Functionhexbox(boxDim,boxEl)
Returns a hexahedral mesh of a box
Description
This function returns a hexahedral mesh for a 3D rectangular box domain.
sourcecon_face_edge
Comodo.con_face_edge — Functioncon_face_edge(F,E_uni=nothing,indReverse=nothing)
Returns the edges connected to each face.
Description
This function computes the face-edge connectivity. The input faces F (and optionally also the unique edges E_uni and reverse indices indReverse to map to the non-unique edges, see also gunique) are used to create a list of edges connected to each face. If F contains N faces then the output contains N such lists. For triangles the output contains 3 edges per faces, for quads 4 per face and so on.
sourcecon_edge_face
Comodo.con_edge_face — Functionconedgeface(F,E_uni=nothing,indReverse=nothing)
Returns the faces connected to each edge.
Description
This function computes the edge-face connectivity. The input faces F (and optionally also the unique edges E_uni and reverse indices indReverse to map to the non-unique edges, see also gunique) are used to create a list of faces connected to each edges. If E_uni contains N edges then the output contains N such lists. For non-boundary edges each edge should connect to 2 faces. Boundary edges connect to just 1 face.
sourcecon_face_face
Comodo.con_face_face — Functioncon_face_face(F,E_uni=nothing,indReverse=nothing,con_E2F=nothing,con_F2E=nothing)
Returns the edge-connected faces for each face.
Description
This function computes the face-face connectivity for each face. The input faces F are used to create a list of faces connected to each face by a shared edge. For non-boundary triangles for instance the output contains 3 edges per faces (which may be less for boundary triangles), and similarly non-boundary quads would each have 4 edge-connected faces. Additional optional inputs include: the unique edges E_uni, the reverse indices indReverse to map to the non-unique edges (see also gunique), as well as the edge-face con_E2F and face-edge con_F2E connectivity. These are all needed for computing the face-face connectivity and supplying them if already computed therefore save time.
sourcecon_face_face_v
Comodo.con_face_face_v — Functioncon_face_face_v(F,V=nothing,con_V2F=nothing)
Returns the vertex-connected faces for each face.
Description
This function computes the face-face connectivity for each face. The input faces F are used to create a list of faces connected to each face by a shared vertex. Additional optional inputs include: the vertices V, and the vertex-face connectivity con_V2F. In terms of vertices only the number of vertices, i.e. length(V) is neede, if V is not provided it is assumed that length(V) corresponds to the largest index in F. The vertex-face connectivity if not supplied, will be computed by this function, hence computational time may be saved if it was already computed.
sourcecon_vertex_simplex
Comodo.con_vertex_simplex — Functioncon_vertex_simplex(F,V=nothing)
Returns how vertices connect to simplices
Description
This function computes the vertex-simplex connectivity for each vertex. The input simplices F are used to create a list of simplices connected to each vertex. Additional optional inputs include: the vertices V. In terms of vertices only the number of vertices, i.e. length(V) is needed, if V is not provided it is assumed that length(V) corresponds to the largest index in F.
sourcecon_vertex_face
Comodo.con_vertex_face — Functioncon_vertex_face(F,V=nothing)
Returns how vertices connect to faces
Description
This function is an alias of con_vertex_simplex, and computes the vertex-face connectivity for each vertex. The input faces F are used to create a list of faces connected to each vertex. Additional optional inputs include: the vertices V. In terms of vertices only the number of vertices, i.e. length(V) is needed, if V is not provided it is assumed that length(V) corresponds to the largest index in F.
sourcecon_vertex_edge
Comodo.con_vertex_edge — Functioncon_vertex_edge(F,V=nothing)
Returns how vertices connect to edges
Description
This function is an alias of con_vertex_simplex, and computes the vertex-edge connectivity for each vertex. The input edges E are used to create a list of edges connected to each vertex. Additional optional inputs include: the vertices V. In terms of vertices only the number of vertices, i.e. length(V) is needed, if V is not provided it is assumed that length(V) corresponds to the largest index in E.
sourcecon_edge_edge
Comodo.con_edge_edge — Functioncon_edge_edge(E_uni,con_V2E=nothing)
Returns the vertex-connected edges for each edge.
Description
This function computes the edge-edge connectivity for each edge. The input edges F are used to create a list of edges connected to each edge by a shared vertex. Additional optional inputs include: con_V2E (the vertex-edge connectivity), which is instead computed when not provided.
sourcecon_vertex_vertex_f
Comodo.con_vertex_vertex_f — Functioncon_vertex_vertex_f(F,V=nothing,con_V2F=nothing)
Returns the face-connected vertices for each vertex.
Description
This function computes the vertex-vertex connectivity for each vertex using the vertex connected faces. The input faces F are used to create a list of vertices connected to each vertex by a shared face. Additional optional inputs include: the vertices V and con_V2F (the vertex-face connectivity). In terms of vertices only the number of vertices, i.e. length(V) is needed, if V is not provided it is assumed that length(V) corresponds to the largest index in F. The vertex-face connectivity con_V2F is needed, hence is computed when not provided.
sourcecon_vertex_vertex
Comodo.con_vertex_vertex — Functioncon_vertex_vertex(E,V=nothing,con_V2E=nothing)
Returns the edge-connected vertices for each vertex.
Description
This function computes the vertex-vertex connectivity for each vertex using the vertex connected edges. The input edges E are used to create a list of vertices connected to each vertex by a shared edge. Additional optional inputs include: the vertices V and con_V2E (the vertex-edge connectivity). In terms of vertices only the number of vertices, i.e. length(V) is needed, if V is not provided it is assumed that length(V) corresponds to the largest index in E. The vertex-edge connectivity con_V2E is needed, hence is computed when not provided.
sourcemeshconnectivity
Comodo.meshconnectivity — Functionmeshconnectivity(F::Vector{NgonFace{N,TF}},V::Vector{Point{ND,TV}}) where N where TF<:Integer where ND where TV<:Real
Returns all mesh connectivity data
Description
This function returns the ConnectivitySet, i.e. all mesh connectivity data for the input mesh defined by the faces F and the vertices V. The ConnectivitySet contains the following connectivity descriptions:
- face-edge
- edge-face
- face-face
- face-face (wrt vertices)
- vertex-face
- vertex-edge
- edge-edge
- vertex-vertex
- vertex-vertex (wrt faces)
sourcemergevertices
Comodo.mergevertices — Functionmergevertices(F::Vector{NgonFace{N,TF}},V::Vector{Point{ND,TV}}; roundVertices = true, numDigitsMerge=nothing) where N where TF<:Integer where ND where TV<:Real
Merges points that coincide
Description
This function take the faces F and vertices V and merges points that are sufficiently similar. Once points are merged the indices in F are corrected for the new reduced point set.
sourcesmoothmesh_laplacian
Comodo.smoothmesh_laplacian — Functionsmoothmesh_laplacian(F,V,con_V2V=nothing; n=1, λ=0.5)
Description
This function implements weighted Laplacian mesh smoothing. At each iteration, this method replaces each point by an updated coordinate based on the mean coordinates of that point's Laplacian umbrella. The update features a lerp like weighting between the previous iterations coordinates and the mean coordinates. The code features Vs[q] = (1.0-λ).*Vs[q] .+ λ*mean(V[con_V2V[q]]) As can be seen, the weighting is controlled by the input parameter λ which is in the range (0,1). If λ=0 then no smoothing occurs. If λ=1 then pure Laplacian mean based smoothing occurs. For intermediate values a linear blending between the two occurs.
sourcesmoothmesh_hc
Comodo.smoothmesh_hc — Functionsmoothmesh_hc(F::Vector{NgonFace{N,TF}},V::Vector{Point{ND,TV}}, n=1, α=0.1, β=0.5; con_V2V=nothing, tolDist=nothing, constrained_points=nothing) where N where TF<:Integer where ND where TV<:Real
Description
This function implements HC (Humphrey's Classes) smoothing [1]. This method uses Laplacian like smoothing but aims to compensate for shrinkage/swelling by also "pushing back" towards the original coordinates.
Reference
sourcequadplate
Comodo.quadplate — Functionquadplate(plateDim,plateElem; orientation=:up)
Returns a quad mesh for a plate
Description
This function creates a quadrilateral mesh (faces F and vertices V) for a plate. The dimensions in the x-, and y-direction are specified in the input vector plateDim, and the number of elements to use in each direction in the input vector plateElem.
sourcequadsphere
Comodo.quadsphere — Functionquadsphere(n::Int,r::T) where T <: Real
Returns a quadrangulated sphere
Description
This function creates a quadrilateral mesh (faces F and vertices V) for a sphere with a radius defined by the input r. The input n defines the density of sphere mesh. The quad mesh is constructed using subquad subdivision of a regular cube, whereby n sets the number of splitting iterations to use. Using n=0 therefore returns a cube.
sourceloflinear
Comodo.loftlinear — Functionloftlinear(V1,V2;num_steps=2,close_loop=true,face_type=:tri)
Loft a surface mesh between two input curves
Description
The loftlinear function spans a surface from input curve V1 to curve V2. The surface is formed by "lerping" curves from V1 to V2 in num_steps steps, and forming mesh faces between each curve. If close_loop==true then it is assumed the curves (and therefore the output surface mesh should be closed over, i.e. that a connection should be made between each curve end and start point. The user can request different face types for the output. The default is face_type=:tri which will form isoceles triangles (or equilateral triangles if the spacing is even) for a planar curve. The other face_type options supported are :quad (quadrilateral), and :tri_slash. For the latter, triangles are formed by slashing the quads.
Arguments:
V1::Vector: n-vector V2::Vector: n-vector
sourcepointspacingmean
Comodo.pointspacingmean — Functionpointspacingmean(V::Vector{Point3{Float64}})
-pointspacingmean(F::Array{NgonFace{N, Int}, 1},V::Vector{Point3{Float64}}) where N
The pointspacingmean function computes the mean spacing between points. The input can be just the coordinate set V, a vector of Point3 points, or also a set of edges E or faces F. If only V is provided it is assumed that V represents an ordered set of "adjacent" points, e.g. as for a curve. If a vector of edges E or a vector of faces F is also provided, then the average edge length is computed. If instead a set of facesF` is provided then edges are first computed after which the mean edge spacing is return.
sourceray_triangle_intersect
Comodo.ray_triangle_intersect — Functionray_triangle_intersect(F::Vector{TriangleFace{Int}},V,ray_origin,ray_vector; rayType = :ray, triSide = 1, tolEps = eps(Float64))
-ray_triangle_intersect(f::TriangleFace{Int},V,ray_origin,ray_vector; rayType = :ray, triSide = 1, tolEps = eps(Float64))
Description
This function can compute triangle-ray or triangle-line intersections through the use of the "Möller-Trumbore triangle-ray intersection algorithm" [1]. The required inputs are as follows:
F an single face or a vector of faces, e.g. Vector{TriangleFace{Int}} V The triangle vertices as a vector of points, i.e. Vector{Point{3, Float64}} ray_vector The ray vector which can be Vector{Point{3, Float64}} or Vec3{Float64}
The following optional input parameters can be provided: rayType = :ray (default) or :line. This defines wether the vector is treated as a ray (extends indefinately) or as a line (finite length) triSide = 1 (default) or 0 or -1. When triSide=1 only the inward intersections are considered, e.g. when the ray or line enters the shape (ray/line is pointing against face normal) When triSide=-1 only the outward intersections are considered, e.g. when the ray or line exits the shape (ray/line is pointing allong face normal) When triSide=0 both inward and outward intersections are considered. tolEps = eps(Float64) (default)
References
sourcemesh_curvature_polynomial
Comodo.mesh_curvature_polynomial — Functionmesh_curvature_polynomial(F::Vector{TriangleFace{Int}},V::Vector{Point3{Float64}})
-mesh_curvature_polynomial(M::GeometryBasics.Mesh)
Description
This function computes the mesh curvature at each vertex for the input mesh defined by the face F and the vertices V. A local polynomial is fitted to each point's "Laplacian umbrella" (point neighbourhood), and the curvature of this fitted form is derived. Instead of the mesh faces and vertices one may instead specify the GeometryBasics.Mesh M as the input.
The reference below [1] provides more detail on the algorithm. In addition, this implementation was created with the help of this helpful document, which features a nice overview of the theory/steps involved in this algorithm.
References
sourceseparate_vertices
Comodo.separate_vertices — Functionseparate_vertices(F::Array{NgonFace{N, Int}, 1},V::Array{Point{M, T}, 1}) where N where M where T<:Real
-separate_vertices(M::GeometryBasics.Mesh)
This function takes the input mesh defined by the faces F and vertices V and separates any shared vertices. It does this by giving each face its own set of unshared vertices. Note that any unused points are not returned in the output point array Vn. Indices for the mapping are not created here but can simply be obtained using reduce(vcat,F).
sourceevenly_sample
Comodo.evenly_sample — Functionevenly_sample(V::Vector{Point{ND,TV}}, n::Int; rtol = 1e-8, niter = 1) where ND where TV<:Real
Evenly samples curves.
Description
This function aims to evenly resample the input curve defined by the ND points V using n points. The function returns the resampled points as well as the spline interpolator S used. The output points can also be retriebed by using: S.(range(0.0, 1.0, n)). Note that the even sampling is defined in terms of the curve length for a 4th order natural B-spline that interpolates the input data. Hence if significant curvature exists for the B-spline between two adjacent data points then the spacing between points in the output may be non-uniform (despite the allong B-spline distance being uniform).
sourceinvert_faces
Comodo.invert_faces — Functioninvert_faces(F::Vector{NgonFace{N, TF}, 1}) where N where TF<:Integer
Flips face orientations.
Description
This function inverts the faces in F, such that the face normal will be flipped, by reversing the node order for each face.
sourcekabsch_rot
Comodo.kabsch_rot — FunctionR = kabsch_rot(V1::Array{Point{N, T}, 1},V2::Array{Point{N, TT}, 1}) where N where T<:Real where TT<:Real
Description
Computes the rotation tensor R to rotate the points in V1 to best match the points in V2.
Reference
Wolfgang Kabsch, A solution for the best rotation to relate two sets of vectors, Acta Crystallographica Section A, vol. 32, no. 5, pp. 922-923, 1976, doi: 10.1107/S0567739476001873 https://en.wikipedia.org/wiki/Kabsch_algorithm
sourcesweeploft
Comodo.sweeploft — FunctionF,V = sweeploft(Vc,V1,V2; face_type=:quad, num_twist = 0, close_loop=true)
Description
This function implements swept lofting. The start curve V1 is pulled allong the guide curve Vc while also gradually (linearly) morphing into the end curve V2. The optional parameter face_type (default :quad) defines the type of mesh faces uses. The same face types as loftlinear and extrudecurve are supported, i.e. :quad, :tri_slash, tri, or quad2tri. The optional parameter num_twist (default is 0) can be used to add an integer number (negative or positive) of full twists to the loft. Finally the optional parameter close_loop (default is true) determines if the section curves are deemed closed or open ended.
sourcerevolvecurve
Comodo.revolvecurve — Functionrevolvecurve(Vc::Vector{Point{ND,TV}}; extent = 2.0*pi, direction=:positive, n=Vec{3, Float64}(0.0,0.0,1.0),num_steps=nothing,close_loop=true,face_type=:quad) where ND where TV<:Real
Revolves curves to build surfaces
Description
This function rotates the curve Vc by the angle extent, in the direction defined by direction (:positive, :negative, :both), around the vector n, to build the output mesh defined by the faces F and vertices V.
sourcebatman
Comodo.batman — Functionbatman(n::Int)
Description
The batman function creates points on the curve for the Batman logo. The curve is useful for testing surface meshing algorithms since it contains sharp transitions and pointy features. The user requests n points on the curve. The default forces exactly n points which may result in an assymetric curve. To instead force symmetry the user can set the optional parameter symmetric=true. In this case the output will be symmetric allong the y-axis, however the number of points on the curve may have increased (if the input n is not even). The second optional input is the direction of the curve, i.e. if it is clockwise, dir=:cw or anti-clockwise dir=:acw. The implementation is based on a "parameterised Batman equation" 1. The following modifications where made, the curve is here centered around [0,0,0], scaled to be 2 in width, resampled evenly, and the default curve direction is anti-clockwise.
References
- https://www.desmos.com/calculator/ajnzwedvql
sourcetridisc
Comodo.tridisc — Functiontridisc(r=1.0,n=0; ngon=6, method = :linear, orientation=:up)
Description
Generates the faces F and vertices V for a triangulated disc (circle). The algorithm starts with a triangulated hexagon (obtained if n=0) and uses iterative subtriangulation, and uses iterative subdivision (and pushing of boundary points to circular boundary) to obtain the final mesh. The subdivision method is an optional input, and is either :Loop (default) or :linear. Lastly the optional input orientation, which can be :up or :down sets the face normal direction.
sourceregiontrimesh
Comodo.regiontrimesh — Functionregiontrimesh(VT,R,P)
Description
Generates a multi-region triangle mesh for the input regions. The boundary curves for all regions are containedin the tuple VT. Each region to be meshed is next defined using a tuple R containing indices into the curve typle VT. If an entry in R contains only one index then the entire curve domain is meshed. If R contains multiple indices then the first index is assumed to be for the outer boundary curve, while all subsequent indices are for boundaries defining holes in this region.
sourcescalesimplex
Comodo.scalesimplex — Functionscalesimplex(F,V,s)
Scales faces (or general simplices) wrt their centre.
Description
This function scales each simplex (e.g. a face) wrt their centre (mean of coordinates). This function is useful in generating lattice structures from elements as well as to create visualisations whereby "looking into" the mesh is needed.
sourcesubcurve
Comodo.subcurve — Functionsubcurve(V,n)
Adds n points between each curve point.
Description
This function adds n points between each current point on the curve V.
sourcedualclad
Comodo.dualclad — Functiondualclad(F::Vector{NgonFace{N, TF}},V::Vector{Point{ND,TV}},s::T; connectivity=:face) where N where TF<:Integer where ND where TV<:Real where T<:Real
Returns a surface conforming dual lattice
Description
sourcetet2hex
Comodo.tet2hex — Functiontet2hex(E::Vector{Tet4{T}},V::Vector{Point{ND,TV}}) where T<:Integer where ND where TV<:Real
Converts tetrahedra to hexahedra
Description
This function converts the input tetrahedra defined by the element set E and the vertex set V to a set of hexahedral elements Eh with vertices Vh. The conversion involves a splitting of each tetrahedron into 4 hexahedra.
sourceelement2faces
Comodo.element2faces — Functionelement2faces(E::Vector{Element{N,T}}) where N where T
Returns element faces
Description
This function computes the faces for the input elements defined by E. The elements should be Vectors consisting of Tet4, Hex8 elements.
sourcesubhex
Comodo.subhex — Functionsubhex(E::Vector{Hex8{T}},V::Vector{Point{ND,TV}},n::Int; direction=0) where T<:Integer where ND where TV<:Real
Split hexahedral elements
Description
This function splits the hexahedral elements defined by the elements E and vertices V. Splitting is done n times as requested. By default the splitting occurs in all direction (corresponding to the default direction=0). If instead direction is set to 1, 2, or 3, then the splitting only occur in the first, second or third local element direction respectively. Note that this direction depends on node order used. For a hexahedron where by nodes 1:4 are for the bottom, and nodes 5:8 are for the top of the element then the directions 1, 2, and 3 correspond to the x-, y-, and z-direction respectively.
sourcerhombicdodecahedron
Comodo.rhombicdodecahedron — Functionrhombicdodecahedron(r = 1.0)
Creates mesh for rhombicdodecahedron
Description
This function creates the faces F and vertices V for a rhombicdodecahedron. The radius of the shape is set using the input radius r.
sourcetri2quad
Comodo.tri2quad — Functiontri2quad(F,V; method=:split)
Converts triangles to quads
Description
This function converts the input triangular mesh, defined by the faces F and vertices V, to a quadrangulation. The method for this conversion is set using the attribute method which can be set to :split, splitting each triangle into 3 quads by introducing a new central node, or :rhombic. whereby each triangle edge is used to construct a rhombic quadrilateral face.
sourcetetgenmesh
Comodo.tetgenmesh — Functiontetgenmesh(F::Array{NgonFace{N,TF}, 1},V::Vector{Point{3,TV}}; facetmarkerlist=nothing, V_regions=nothing,region_vol=nothing,V_holes=nothing,stringOpt="paAqYQ") where N where TF<:Integer where TV<:Real
Creates a tetrahedral mesh
Description
This function uses the TetGen.jl library to mesh the input geometry defined by the faces F and the vertices V using tetrahedral elements. Several optional input parameters are available:
facetmarkerlist, a vector of integers with the same length as F and defines a face label for each face. V_regions, a vector of points inside regions which require tetrahedral meshing.region_vol, a vector of scalar values to denote the desired tetrahedral volume for each region. V_holes, a vector of points inside holes (voids) that should remain empty. stringOpt, the TetGen command string to use. See also the TetGen documentation.
sourcesurfacevolume
Comodo.surfacevolume — Functionsurfacevolume(F::Vector{NgonFace{N,TF}},V::Vector{Point{ND,TV}}) where N where TF<:Integer where ND where TV<:Real
Computes closed surface volume
Description
This function computes the volume of a closed surface defined by the faces F and the vertices V.
sourcetetvolume
Comodo.tetvolume — Functiontetvolume(E::Vector{Tet4{T}},V::Vector{Point{ND,TV}}) where T<:Integer where ND where TV<:Real
Computes tetrahedral volumes
Description
This function computes the volume for each tetrahedron defined by the input E, a vector of Tet4 elements, and V the point coordinates.
sourceextrudefaces
Comodo.extrudefaces — Functionextrudefaces(F::Vector{NgonFace{NF,TF}},V::Vector{Point{ND,TV}}; extent=1.0, direction=:positive, num_steps=2, N::Union{Vector{Point{ND,TN}},Vector{Vec{ND, TN}},Nothing}=nothing) where NF where TF<:Integer where ND where TV<:Real where TN<:Real
Extrudes/thickens faces to form elements
Description
The inputs surface mesh, defined by the faces F and vertices V is extruded to create volumetric elements. Quadrilateral and triangular input faces are supported. These extrude into hexahedral and pentahedral elements respectively. The following input parameters are defined:
extent<:Real (default = 1.0) the length of the extrusion direction is a symbol that is either :positive (default), :negative, or :both. N The extrusion vectors. The default is nothing in which case the local
vertex normals are used.
num_steps (default is 2) is the number of nodes in the extrude direction, the
number of elements in the extrude direction is therefore num_steps-1.
sourcefilletcurve
Comodo.filletcurve — Functionfilletcurve(V::Vector{Point{NV,TV}}; rMax::Union{Vector{T},T,Nothing}=nothing, constrain_method = :max, n=25, close_loop = false, eps_level = 1e-6) where TV<:Real where NV where T<:Real
Fillets/rounds curves
Description
The function takes in a curve defined by the points V and applies filleting (or rounding) to each "corner" (i.e. a point between two neighbouring points). The maximum radius rMax is used as the largest possible radius to use. If this, radius is not possible (e.g. if input points are too close), then a lower Radius is used.
sourcesquircle
Comodo.squircle — Functionsquircle(r::T,n::Int,τ=0.5; atol=1e-6, dir=:acw) where T <: Real
Creates the squircle curve
Description
This function returns n points on a squircle. The squircle curve is defined using the radius r, and the parameter τ. The latter controls the morphing between a circle (τ=0) and square (τ=1).
sourcecirclerange
Comodo.circlerange — Functioncirclerange(n::Int; dir=:acw, deg=false)
Creates circular angles
Description
This function returns n angles for an even circular distribution of points. The optional input dir can be set to :acw (default) resulting in an anti-clockwise set of angles, and can be set to :cw for a clockwise set of angles. Angles are returned in radians since deg is false by default. Using deg=true results in angles in degrees.
sourceedgefaceangles
Comodo.edgefaceangles — Functionedgefaceangles(F::Vector{NgonFace{NF,TF}},V::Vector{Point{ND,TV}}; deg=false) where NF where TF<:Integer where ND where TV<:Real
Computed angles between faces
Description
This function computes the angle between two faces for each unique edge in the mesh specified by F and the vertices V. If the input mesh consists of n unique edges then the output features n angles. For boundary edges, where no pair of faces exists, the angle returned is NaN. The default behaviour results in angles being computed in radians. However by specifying deg=true the user can request degrees instead. Finally two additional outputs are created, namely the unique edge vector E_uni as well as the edge-to-face connectivity vector ,con_E2F.
sourcefaceanglesegment
Comodo.faceanglesegment — Functionfaceanglesegment(F::Vector{NgonFace{NF,TF}},V::Vector{Point{ND,TV; deg=false, angleThreshold = pi/8, indStart = 1) where NF where TF<:Integer where ND where TV<:Real
Segments surfaces using face angles
Description
This function takes in a surface mesh defined by the faces F and the vertices V, and segments the surface mesh based on face angles. The output consists of a "feature label" vector G (a Vector{Int}, with the same length of F) whereby adjacent faces whosee angle is smaller or equal to the angleThreshold (default is pi/8) receive the same label. Hence this function allows one to find all faces with a similar orientation, for instance all top or side faces of some mesh. The function uses radians by default. However, buy specifying the optional parameter deg=true the user request that angles and the angleThreshold are in degrees.
sourceSettings
This document was generated with Documenter.jl version 1.7.0 on Thursday 24 October 2024. Using Julia version 1.10.5.
Returns edge lengths.
Description
This function computes the lengths of the edges defined by edge vector E (e.g as obtained from meshedges(F,V), where F is a face vector, and V is a vector of vertices. Alternatively the input mesh can be a GeometryBasics mesh M.
subtri
Comodo.subtri — Functionsubtri(F,V,n; method = :linear)
+subtri(F,V,n; method = :Loop)Refines triangulations through splitting.
Description
The subtri function refines triangulated meshes iteratively. For each iteration each original input triangle is split into 4 triangles to form the refined mesh (one central one, and 3 at each corner). The following refinement methods are implemented:
method=:linear : This is the default method, and refines the triangles in a simple linear manor through splitting. Each input edge simply obtains a new mid-edge node.
method=:Loop : This method features Loop-subdivision [1,2]. Rather than linearly splitting edges and maintaining the original coordinates, as for the linear method, this method computes the new points in a special weighted sense such that the surface effectively approaches a "quartic box spline". Hence this method both refines and smoothes the geometry through spline approximation.
References
subquad
Comodo.subquad — Functionsubquad(F::Vector{NgonFace{4,TF}},V::Vector{Point{ND,TV}},n::Int; method=:linear) where TF<:Integer where ND where TV <: Real subquad(F::Vector{NgonFace{4,TF}},V::Vector{Point{ND,TV}},n::Int; method=:Catmull_Clark) where TF<:Integer where ND where TV <: Real
Refines quadrangulations through splitting.
Description
The subquad function refines quad meshes iteratively. For each iteration each original input quad is split into 4 smaller quads to form the refined mesh. The following refinement methods are implemented:
method=:linear : This is the default method, and refines the quads in a simple linear manor through splitting. Each input edge simply obtains a new mid-edge node, and each face obtains a new central node.
method=:Catmull_Clark : This method features Catmull_Clark-subdivision [1]. Rather than linearly splitting edges and maintaining the original coordinates, as for the linear method, this method computes the new points in a special weighted sense such that the surface effectively approaches a bicubic B-spline surface. Hence this method both refines and smoothes the geometry through spline approximation.
References
geosphere
Comodo.geosphere — Functiongeosphere(n::Int,r::T; method=:linear) where T <: RealReturns a geodesic sphere triangulation
Description
This function returns a geodesic sphere triangulation based on the number of refinement iterations n and the radius r. Geodesic spheres (aka Buckminster-Fuller spheres) are triangulations of a sphere that have near uniform edge lenghts. The algorithm starts with a regular icosahedron. Next this icosahedron is refined n times, while nodes are pushed to a sphere surface with radius r at each iteration. Two methods are available, i.e. :linear (default) and :Loop (see also subtri). The former features simply linear splitting while the latter features the Loop method which may produce a smoother result.
hexbox
Comodo.hexbox — Functionhexbox(boxDim,boxEl)Returns a hexahedral mesh of a box
Description
This function returns a hexahedral mesh for a 3D rectangular box domain.
con_face_edge
Comodo.con_face_edge — Functioncon_face_edge(F,E_uni=nothing,indReverse=nothing)Returns the edges connected to each face.
Description
This function computes the face-edge connectivity. The input faces F (and optionally also the unique edges E_uni and reverse indices indReverse to map to the non-unique edges, see also gunique) are used to create a list of edges connected to each face. If F contains N faces then the output contains N such lists. For triangles the output contains 3 edges per faces, for quads 4 per face and so on.
con_edge_face
Comodo.con_edge_face — Functionconedgeface(F,E_uni=nothing,indReverse=nothing)
Returns the faces connected to each edge.
Description
This function computes the edge-face connectivity. The input faces F (and optionally also the unique edges E_uni and reverse indices indReverse to map to the non-unique edges, see also gunique) are used to create a list of faces connected to each edges. If E_uni contains N edges then the output contains N such lists. For non-boundary edges each edge should connect to 2 faces. Boundary edges connect to just 1 face.
con_face_face
Comodo.con_face_face — Functioncon_face_face(F,E_uni=nothing,indReverse=nothing,con_E2F=nothing,con_F2E=nothing)Returns the edge-connected faces for each face.
Description
This function computes the face-face connectivity for each face. The input faces F are used to create a list of faces connected to each face by a shared edge. For non-boundary triangles for instance the output contains 3 edges per faces (which may be less for boundary triangles), and similarly non-boundary quads would each have 4 edge-connected faces. Additional optional inputs include: the unique edges E_uni, the reverse indices indReverse to map to the non-unique edges (see also gunique), as well as the edge-face con_E2F and face-edge con_F2E connectivity. These are all needed for computing the face-face connectivity and supplying them if already computed therefore save time.
con_face_face_v
Comodo.con_face_face_v — Functioncon_face_face_v(F,V=nothing,con_V2F=nothing)Returns the vertex-connected faces for each face.
Description
This function computes the face-face connectivity for each face. The input faces F are used to create a list of faces connected to each face by a shared vertex. Additional optional inputs include: the vertices V, and the vertex-face connectivity con_V2F. In terms of vertices only the number of vertices, i.e. length(V) is neede, if V is not provided it is assumed that length(V) corresponds to the largest index in F. The vertex-face connectivity if not supplied, will be computed by this function, hence computational time may be saved if it was already computed.
con_vertex_simplex
Comodo.con_vertex_simplex — Functioncon_vertex_simplex(F,V=nothing)Returns how vertices connect to simplices
Description
This function computes the vertex-simplex connectivity for each vertex. The input simplices F are used to create a list of simplices connected to each vertex. Additional optional inputs include: the vertices V. In terms of vertices only the number of vertices, i.e. length(V) is needed, if V is not provided it is assumed that length(V) corresponds to the largest index in F.
con_vertex_face
Comodo.con_vertex_face — Functioncon_vertex_face(F,V=nothing)Returns how vertices connect to faces
Description
This function is an alias of con_vertex_simplex, and computes the vertex-face connectivity for each vertex. The input faces F are used to create a list of faces connected to each vertex. Additional optional inputs include: the vertices V. In terms of vertices only the number of vertices, i.e. length(V) is needed, if V is not provided it is assumed that length(V) corresponds to the largest index in F.
con_vertex_edge
Comodo.con_vertex_edge — Functioncon_vertex_edge(F,V=nothing)Returns how vertices connect to edges
Description
This function is an alias of con_vertex_simplex, and computes the vertex-edge connectivity for each vertex. The input edges E are used to create a list of edges connected to each vertex. Additional optional inputs include: the vertices V. In terms of vertices only the number of vertices, i.e. length(V) is needed, if V is not provided it is assumed that length(V) corresponds to the largest index in E.
con_edge_edge
Comodo.con_edge_edge — Functioncon_edge_edge(E_uni,con_V2E=nothing)Returns the vertex-connected edges for each edge.
Description
This function computes the edge-edge connectivity for each edge. The input edges F are used to create a list of edges connected to each edge by a shared vertex. Additional optional inputs include: con_V2E (the vertex-edge connectivity), which is instead computed when not provided.
con_vertex_vertex_f
Comodo.con_vertex_vertex_f — Functioncon_vertex_vertex_f(F,V=nothing,con_V2F=nothing)Returns the face-connected vertices for each vertex.
Description
This function computes the vertex-vertex connectivity for each vertex using the vertex connected faces. The input faces F are used to create a list of vertices connected to each vertex by a shared face. Additional optional inputs include: the vertices V and con_V2F (the vertex-face connectivity). In terms of vertices only the number of vertices, i.e. length(V) is needed, if V is not provided it is assumed that length(V) corresponds to the largest index in F. The vertex-face connectivity con_V2F is needed, hence is computed when not provided.
con_vertex_vertex
Comodo.con_vertex_vertex — Functioncon_vertex_vertex(E,V=nothing,con_V2E=nothing)Returns the edge-connected vertices for each vertex.
Description
This function computes the vertex-vertex connectivity for each vertex using the vertex connected edges. The input edges E are used to create a list of vertices connected to each vertex by a shared edge. Additional optional inputs include: the vertices V and con_V2E (the vertex-edge connectivity). In terms of vertices only the number of vertices, i.e. length(V) is needed, if V is not provided it is assumed that length(V) corresponds to the largest index in E. The vertex-edge connectivity con_V2E is needed, hence is computed when not provided.
meshconnectivity
Comodo.meshconnectivity — Functionmeshconnectivity(F::Vector{NgonFace{N,TF}},V::Vector{Point{ND,TV}}) where N where TF<:Integer where ND where TV<:RealReturns all mesh connectivity data
Description
This function returns the ConnectivitySet, i.e. all mesh connectivity data for the input mesh defined by the faces F and the vertices V. The ConnectivitySet contains the following connectivity descriptions:
- face-edge
- edge-face
- face-face
- face-face (wrt vertices)
- vertex-face
- vertex-edge
- edge-edge
- vertex-vertex
- vertex-vertex (wrt faces)
mergevertices
Comodo.mergevertices — Functionmergevertices(F::Vector{NgonFace{N,TF}},V::Vector{Point{ND,TV}}; roundVertices = true, numDigitsMerge=nothing) where N where TF<:Integer where ND where TV<:RealMerges points that coincide
Description
This function take the faces F and vertices V and merges points that are sufficiently similar. Once points are merged the indices in F are corrected for the new reduced point set.
smoothmesh_laplacian
Comodo.smoothmesh_laplacian — Functionsmoothmesh_laplacian(F,V,con_V2V=nothing; n=1, λ=0.5)Description
This function implements weighted Laplacian mesh smoothing. At each iteration, this method replaces each point by an updated coordinate based on the mean coordinates of that point's Laplacian umbrella. The update features a lerp like weighting between the previous iterations coordinates and the mean coordinates. The code features Vs[q] = (1.0-λ).*Vs[q] .+ λ*mean(V[con_V2V[q]]) As can be seen, the weighting is controlled by the input parameter λ which is in the range (0,1). If λ=0 then no smoothing occurs. If λ=1 then pure Laplacian mean based smoothing occurs. For intermediate values a linear blending between the two occurs.
smoothmesh_hc
Comodo.smoothmesh_hc — Functionsmoothmesh_hc(F::Vector{NgonFace{N,TF}},V::Vector{Point{ND,TV}}, n=1, α=0.1, β=0.5; con_V2V=nothing, tolDist=nothing, constrained_points=nothing) where N where TF<:Integer where ND where TV<:RealDescription
This function implements HC (Humphrey's Classes) smoothing [1]. This method uses Laplacian like smoothing but aims to compensate for shrinkage/swelling by also "pushing back" towards the original coordinates.
Reference
quadplate
Comodo.quadplate — Functionquadplate(plateDim,plateElem; orientation=:up)Returns a quad mesh for a plate
Description
This function creates a quadrilateral mesh (faces F and vertices V) for a plate. The dimensions in the x-, and y-direction are specified in the input vector plateDim, and the number of elements to use in each direction in the input vector plateElem.
quadsphere
Comodo.quadsphere — Functionquadsphere(n::Int,r::T) where T <: RealReturns a quadrangulated sphere
Description
This function creates a quadrilateral mesh (faces F and vertices V) for a sphere with a radius defined by the input r. The input n defines the density of sphere mesh. The quad mesh is constructed using subquad subdivision of a regular cube, whereby n sets the number of splitting iterations to use. Using n=0 therefore returns a cube.
loflinear
Comodo.loftlinear — Functionloftlinear(V1,V2;num_steps=2,close_loop=true,face_type=:tri)Loft a surface mesh between two input curves
Description
The loftlinear function spans a surface from input curve V1 to curve V2. The surface is formed by "lerping" curves from V1 to V2 in num_steps steps, and forming mesh faces between each curve. If close_loop==true then it is assumed the curves (and therefore the output surface mesh should be closed over, i.e. that a connection should be made between each curve end and start point. The user can request different face types for the output. The default is face_type=:tri which will form isoceles triangles (or equilateral triangles if the spacing is even) for a planar curve. The other face_type options supported are :quad (quadrilateral), and :tri_slash. For the latter, triangles are formed by slashing the quads.
Arguments:
V1::Vector: n-vectorV2::Vector: n-vector
pointspacingmean
Comodo.pointspacingmean — Functionpointspacingmean(V::Vector{Point3{Float64}})
+pointspacingmean(F::Array{NgonFace{N, Int}, 1},V::Vector{Point3{Float64}}) where NThe pointspacingmean function computes the mean spacing between points. The input can be just the coordinate set V, a vector of Point3 points, or also a set of edges E or faces F. If only V is provided it is assumed that V represents an ordered set of "adjacent" points, e.g. as for a curve. If a vector of edges E or a vector of faces F is also provided, then the average edge length is computed. If instead a set of facesF` is provided then edges are first computed after which the mean edge spacing is return.
ray_triangle_intersect
Comodo.ray_triangle_intersect — Functionray_triangle_intersect(F::Vector{TriangleFace{Int}},V,ray_origin,ray_vector; rayType = :ray, triSide = 1, tolEps = eps(Float64))
+ray_triangle_intersect(f::TriangleFace{Int},V,ray_origin,ray_vector; rayType = :ray, triSide = 1, tolEps = eps(Float64))Description
This function can compute triangle-ray or triangle-line intersections through the use of the "Möller-Trumbore triangle-ray intersection algorithm" [1]. The required inputs are as follows:
F an single face or a vector of faces, e.g. Vector{TriangleFace{Int}} V The triangle vertices as a vector of points, i.e. Vector{Point{3, Float64}} ray_vector The ray vector which can be Vector{Point{3, Float64}} or Vec3{Float64}
The following optional input parameters can be provided: rayType = :ray (default) or :line. This defines wether the vector is treated as a ray (extends indefinately) or as a line (finite length) triSide = 1 (default) or 0 or -1. When triSide=1 only the inward intersections are considered, e.g. when the ray or line enters the shape (ray/line is pointing against face normal) When triSide=-1 only the outward intersections are considered, e.g. when the ray or line exits the shape (ray/line is pointing allong face normal) When triSide=0 both inward and outward intersections are considered. tolEps = eps(Float64) (default)
References
mesh_curvature_polynomial
Comodo.mesh_curvature_polynomial — Functionmesh_curvature_polynomial(F::Vector{TriangleFace{Int}},V::Vector{Point3{Float64}})
+mesh_curvature_polynomial(M::GeometryBasics.Mesh)Description
This function computes the mesh curvature at each vertex for the input mesh defined by the face F and the vertices V. A local polynomial is fitted to each point's "Laplacian umbrella" (point neighbourhood), and the curvature of this fitted form is derived. Instead of the mesh faces and vertices one may instead specify the GeometryBasics.Mesh M as the input.
The reference below [1] provides more detail on the algorithm. In addition, this implementation was created with the help of this helpful document, which features a nice overview of the theory/steps involved in this algorithm.
References
separate_vertices
Comodo.separate_vertices — Functionseparate_vertices(F::Array{NgonFace{N, Int}, 1},V::Array{Point{M, T}, 1}) where N where M where T<:Real
+separate_vertices(M::GeometryBasics.Mesh)This function takes the input mesh defined by the faces F and vertices V and separates any shared vertices. It does this by giving each face its own set of unshared vertices. Note that any unused points are not returned in the output point array Vn. Indices for the mapping are not created here but can simply be obtained using reduce(vcat,F).
evenly_sample
Comodo.evenly_sample — Functionevenly_sample(V::Vector{Point{ND,TV}}, n::Int; rtol = 1e-8, niter = 1) where ND where TV<:RealEvenly samples curves.
Description
This function aims to evenly resample the input curve defined by the ND points V using n points. The function returns the resampled points as well as the spline interpolator S used. The output points can also be retriebed by using: S.(range(0.0, 1.0, n)). Note that the even sampling is defined in terms of the curve length for a 4th order natural B-spline that interpolates the input data. Hence if significant curvature exists for the B-spline between two adjacent data points then the spacing between points in the output may be non-uniform (despite the allong B-spline distance being uniform).
invert_faces
Comodo.invert_faces — Functioninvert_faces(F::Vector{NgonFace{N, TF}, 1}) where N where TF<:IntegerFlips face orientations.
Description
This function inverts the faces in F, such that the face normal will be flipped, by reversing the node order for each face.
kabsch_rot
Comodo.kabsch_rot — FunctionR = kabsch_rot(V1::Array{Point{N, T}, 1},V2::Array{Point{N, TT}, 1}) where N where T<:Real where TT<:RealDescription
Computes the rotation tensor R to rotate the points in V1 to best match the points in V2.
Reference
Wolfgang Kabsch, A solution for the best rotation to relate two sets of vectors, Acta Crystallographica Section A, vol. 32, no. 5, pp. 922-923, 1976, doi: 10.1107/S0567739476001873 https://en.wikipedia.org/wiki/Kabsch_algorithm
sweeploft
Comodo.sweeploft — FunctionF,V = sweeploft(Vc,V1,V2; face_type=:quad, num_twist = 0, close_loop=true)Description
This function implements swept lofting. The start curve V1 is pulled allong the guide curve Vc while also gradually (linearly) morphing into the end curve V2. The optional parameter face_type (default :quad) defines the type of mesh faces uses. The same face types as loftlinear and extrudecurve are supported, i.e. :quad, :tri_slash, tri, or quad2tri. The optional parameter num_twist (default is 0) can be used to add an integer number (negative or positive) of full twists to the loft. Finally the optional parameter close_loop (default is true) determines if the section curves are deemed closed or open ended.
revolvecurve
Comodo.revolvecurve — Functionrevolvecurve(Vc::Vector{Point{ND,TV}}; extent = 2.0*pi, direction=:positive, n=Vec{3, Float64}(0.0,0.0,1.0),num_steps=nothing,close_loop=true,face_type=:quad) where ND where TV<:RealRevolves curves to build surfaces
Description
This function rotates the curve Vc by the angle extent, in the direction defined by direction (:positive, :negative, :both), around the vector n, to build the output mesh defined by the faces F and vertices V.
batman
Comodo.batman — Functionbatman(n::Int)Description
The batman function creates points on the curve for the Batman logo. The curve is useful for testing surface meshing algorithms since it contains sharp transitions and pointy features. The user requests n points on the curve. The default forces exactly n points which may result in an assymetric curve. To instead force symmetry the user can set the optional parameter symmetric=true. In this case the output will be symmetric allong the y-axis, however the number of points on the curve may have increased (if the input n is not even). The second optional input is the direction of the curve, i.e. if it is clockwise, dir=:cw or anti-clockwise dir=:acw. The implementation is based on a "parameterised Batman equation" 1. The following modifications where made, the curve is here centered around [0,0,0], scaled to be 2 in width, resampled evenly, and the default curve direction is anti-clockwise.
References
- https://www.desmos.com/calculator/ajnzwedvql
tridisc
Comodo.tridisc — Functiontridisc(r=1.0,n=0; ngon=6, method = :linear, orientation=:up)Description
Generates the faces F and vertices V for a triangulated disc (circle). The algorithm starts with a triangulated hexagon (obtained if n=0) and uses iterative subtriangulation, and uses iterative subdivision (and pushing of boundary points to circular boundary) to obtain the final mesh. The subdivision method is an optional input, and is either :Loop (default) or :linear. Lastly the optional input orientation, which can be :up or :down sets the face normal direction.
regiontrimesh
Comodo.regiontrimesh — Functionregiontrimesh(VT,R,P)Description
Generates a multi-region triangle mesh for the input regions. The boundary curves for all regions are containedin the tuple VT. Each region to be meshed is next defined using a tuple R containing indices into the curve typle VT. If an entry in R contains only one index then the entire curve domain is meshed. If R contains multiple indices then the first index is assumed to be for the outer boundary curve, while all subsequent indices are for boundaries defining holes in this region.
scalesimplex
Comodo.scalesimplex — Functionscalesimplex(F,V,s)Scales faces (or general simplices) wrt their centre.
Description
This function scales each simplex (e.g. a face) wrt their centre (mean of coordinates). This function is useful in generating lattice structures from elements as well as to create visualisations whereby "looking into" the mesh is needed.
subcurve
Comodo.subcurve — Functionsubcurve(V,n)Adds n points between each curve point.
Description
This function adds n points between each current point on the curve V.
dualclad
Comodo.dualclad — Functiondualclad(F::Vector{NgonFace{N, TF}},V::Vector{Point{ND,TV}},s::T; connectivity=:face) where N where TF<:Integer where ND where TV<:Real where T<:RealReturns a surface conforming dual lattice
Description
tet2hex
Comodo.tet2hex — Functiontet2hex(E::Vector{Tet4{T}},V::Vector{Point{ND,TV}}) where T<:Integer where ND where TV<:RealConverts tetrahedra to hexahedra
Description
This function converts the input tetrahedra defined by the element set E and the vertex set V to a set of hexahedral elements Eh with vertices Vh. The conversion involves a splitting of each tetrahedron into 4 hexahedra.
element2faces
Comodo.element2faces — Functionelement2faces(E::Vector{Element{N,T}}) where N where TReturns element faces
Description
This function computes the faces for the input elements defined by E. The elements should be Vectors consisting of Tet4, Hex8 elements.
subhex
Comodo.subhex — Functionsubhex(E::Vector{Hex8{T}},V::Vector{Point{ND,TV}},n::Int; direction=0) where T<:Integer where ND where TV<:RealSplit hexahedral elements
Description
This function splits the hexahedral elements defined by the elements E and vertices V. Splitting is done n times as requested. By default the splitting occurs in all direction (corresponding to the default direction=0). If instead direction is set to 1, 2, or 3, then the splitting only occur in the first, second or third local element direction respectively. Note that this direction depends on node order used. For a hexahedron where by nodes 1:4 are for the bottom, and nodes 5:8 are for the top of the element then the directions 1, 2, and 3 correspond to the x-, y-, and z-direction respectively.
rhombicdodecahedron
Comodo.rhombicdodecahedron — Functionrhombicdodecahedron(r = 1.0)Creates mesh for rhombicdodecahedron
Description
This function creates the faces F and vertices V for a rhombicdodecahedron. The size of the shape is set by the width w in the xy-plane.
tri2quad
Comodo.tri2quad — Functiontri2quad(F,V; method=:split)Converts triangles to quads
Description
This function converts the input triangular mesh, defined by the faces F and vertices V, to a quadrangulation. The method for this conversion is set using the attribute method which can be set to :split, splitting each triangle into 3 quads by introducing a new central node, or :rhombic. whereby each triangle edge is used to construct a rhombic quadrilateral face.
tetgenmesh
Comodo.tetgenmesh — Functiontetgenmesh(F::Array{NgonFace{N,TF}, 1},V::Vector{Point{3,TV}}; facetmarkerlist=nothing, V_regions=nothing,region_vol=nothing,V_holes=nothing,stringOpt="paAqYQ") where N where TF<:Integer where TV<:RealCreates a tetrahedral mesh
Description
This function uses the TetGen.jl library to mesh the input geometry defined by the faces F and the vertices V using tetrahedral elements. Several optional input parameters are available:
facetmarkerlist, a vector of integers with the same length asFand defines a face label for each face.V_regions, a vector of points inside regions which require tetrahedral meshing.region_vol, a vector of scalar values to denote the desired tetrahedral volume for each region.V_holes, a vector of points inside holes (voids) that should remain empty.stringOpt, the TetGen command string to use. See also the TetGen documentation.
surfacevolume
Comodo.surfacevolume — Functionsurfacevolume(F::Vector{NgonFace{N,TF}},V::Vector{Point{ND,TV}}) where N where TF<:Integer where ND where TV<:RealComputes closed surface volume
Description
This function computes the volume of a closed surface defined by the faces F and the vertices V.
tetvolume
Comodo.tetvolume — Functiontetvolume(E::Vector{Tet4{T}},V::Vector{Point{ND,TV}}) where T<:Integer where ND where TV<:RealComputes tetrahedral volumes
Description
This function computes the volume for each tetrahedron defined by the input E, a vector of Tet4 elements, and V the point coordinates.
extrudefaces
Comodo.extrudefaces — Functionextrudefaces(F::Vector{NgonFace{NF,TF}},V::Vector{Point{ND,TV}}; extent=1.0, direction=:positive, num_steps=2, N::Union{Vector{Point{ND,TN}},Vector{Vec{ND, TN}},Nothing}=nothing) where NF where TF<:Integer where ND where TV<:Real where TN<:RealExtrudes/thickens faces to form elements
Description
The inputs surface mesh, defined by the faces F and vertices V is extruded to create volumetric elements. Quadrilateral and triangular input faces are supported. These extrude into hexahedral and pentahedral elements respectively. The following input parameters are defined:
extent<:Real(default = 1.0) the length of the extrusiondirectionis a symbol that is either:positive(default),:negative, or:both.NThe extrusion vectors. The default is nothing in which case the local
vertex normals are used.
num_steps(default is 2) is the number of nodes in the extrude direction, the
number of elements in the extrude direction is therefore num_steps-1.
filletcurve
Comodo.filletcurve — Functionfilletcurve(V::Vector{Point{NV,TV}}; rMax::Union{Vector{T},T,Nothing}=nothing, constrain_method = :max, n=25, close_loop = false, eps_level = 1e-6) where TV<:Real where NV where T<:RealFillets/rounds curves
Description
The function takes in a curve defined by the points V and applies filleting (or rounding) to each "corner" (i.e. a point between two neighbouring points). The maximum radius rMax is used as the largest possible radius to use. If this, radius is not possible (e.g. if input points are too close), then a lower Radius is used.
squircle
Comodo.squircle — Functionsquircle(r::T,n::Int,τ=0.5; atol=1e-6, dir=:acw) where T <: RealCreates the squircle curve
Description
This function returns n points on a squircle. The squircle curve is defined using the radius r, and the parameter τ. The latter controls the morphing between a circle (τ=0) and square (τ=1).
circlerange
Comodo.circlerange — Functioncirclerange(n::Int; dir=:acw, deg=false)Creates circular angles
Description
This function returns n angles for an even circular distribution of points. The optional input dir can be set to :acw (default) resulting in an anti-clockwise set of angles, and can be set to :cw for a clockwise set of angles. Angles are returned in radians since deg is false by default. Using deg=true results in angles in degrees.
edgefaceangles
Comodo.edgefaceangles — Functionedgefaceangles(F::Vector{NgonFace{NF,TF}},V::Vector{Point{ND,TV}}; deg=false) where NF where TF<:Integer where ND where TV<:RealComputed angles between faces
Description
This function computes the angle between two faces for each unique edge in the mesh specified by F and the vertices V. If the input mesh consists of n unique edges then the output features n angles. For boundary edges, where no pair of faces exists, the angle returned is NaN. The default behaviour results in angles being computed in radians. However by specifying deg=true the user can request degrees instead. Finally two additional outputs are created, namely the unique edge vector E_uni as well as the edge-to-face connectivity vector ,con_E2F.
faceanglesegment
Comodo.faceanglesegment — Functionfaceanglesegment(F::Vector{NgonFace{NF,TF}},V::Vector{Point{ND,TV; deg=false, angleThreshold = pi/8, indStart = 1) where NF where TF<:Integer where ND where TV<:RealSegments surfaces using face angles
Description
This function takes in a surface mesh defined by the faces F and the vertices V, and segments the surface mesh based on face angles. The output consists of a "feature label" vector G (a Vector{Int}, with the same length of F) whereby adjacent faces whosee angle is smaller or equal to the angleThreshold (default is pi/8) receive the same label. Hence this function allows one to find all faces with a similar orientation, for instance all top or side faces of some mesh. The function uses radians by default. However, buy specifying the optional parameter deg=true the user request that angles and the angleThreshold are in degrees.