API Reference
Exports
GeometryBasics.AbstractGeometry — TypeAbstract Geometry in R{Dim} with Number type T
GeometryBasics.AbstractMesh — TypeAbstractMeshAn abstract mesh is a collection of Polytope elements (Simplices / Ngons). The connections are defined via faces(mesh), the coordinates of the elements are returned by coordinates(mesh). Arbitrary meta information can be attached per point or per face
GeometryBasics.Circle — TypeCircle{T}An alias for a HyperSphere of dimension 2. (i.e. HyperSphere{2, T})
GeometryBasics.Cylinder — TypeCylinder{N, T}A Cylinder is a 2D rectangle or a 3D cylinder defined by its origin point, its extremity and a radius. origin, extremity and r, must be specified.
GeometryBasics.Cylinder2 — TypeCylinder2{T}
-Cylinder3{T}A Cylinder2 or Cylinder3 is a 2D/3D cylinder defined by its origin point, its extremity and a radius. origin, extremity and r, must be specified.
GeometryBasics.FaceView — TypeFaceView{Element, Point, Face, P, F}FaceView enables to link one array of points via a face array, to generate one abstract array of elements. E.g., this becomes possible:
x = FaceView(rand(Point3f, 10), TriangleFace[(1, 2, 3), (2, 4, 5), ...])
+API Reference · GeometryBasics.jl API Reference
Exports
GeometryBasics.AbstractGeometry — TypeAbstract Geometry in R{Dim} with Number type T
sourceGeometryBasics.AbstractMesh — TypeAbstractMesh
An abstract mesh is a collection of Polytope elements (Simplices / Ngons). The connections are defined via faces(mesh), the coordinates of the elements are returned by coordinates(mesh). Arbitrary meta information can be attached per point or per face
sourceGeometryBasics.Circle — TypeCircle{T}
An alias for a HyperSphere of dimension 2. (i.e. HyperSphere{2, T})
sourceGeometryBasics.Cylinder — TypeCylinder{N, T}
A Cylinder is a 2D rectangle or a 3D cylinder defined by its origin point, its extremity and a radius. origin, extremity and r, must be specified.
sourceGeometryBasics.Cylinder2 — TypeCylinder2{T}
+Cylinder3{T}
A Cylinder2 or Cylinder3 is a 2D/3D cylinder defined by its origin point, its extremity and a radius. origin, extremity and r, must be specified.
sourceGeometryBasics.FaceView — TypeFaceView{Element, Point, Face, P, F}
FaceView enables to link one array of points via a face array, to generate one abstract array of elements. E.g., this becomes possible:
x = FaceView(rand(Point3f, 10), TriangleFace[(1, 2, 3), (2, 4, 5), ...])
x[1] isa Triangle == true
x isa AbstractVector{<: Triangle} == true
# This means we can use it as a mesh:
@@ -8,19 +8,19 @@
# Can also be used for Points:
linestring = FaceView(points, LineFace[...])
-Polygon(linestring)
sourceGeometryBasics.HyperRectangle — TypeHyperRectangle{N, T}
A HyperRectangle is a generalization of a rectangle into N-dimensions. Formally it is the cartesian product of intervals, which is represented by the origin and widths fields, whose indices correspond to each of the N axes.
sourceGeometryBasics.HyperSphere — TypeHyperSphere{N, T}
A HyperSphere is a generalization of a sphere into N-dimensions. A center and radius, r, must be specified.
sourceGeometryBasics.LineString — TypeLineString(points::AbstractVector{<: AbstractPoint}, skip = 1)
Creates a LineString from a vector of points. With skip == 1, the default, it will connect the line like this:
points = Point[a, b, c, d]
-linestring = LineString(points)
-@assert linestring == LineString([a => b, b => c, c => d])
sourceGeometryBasics.LineString — TypeLineString(points::AbstractVector{<:AbstractPoint})
A LineString is a geometry of connected line segments
sourceGeometryBasics.LineString — TypeLineString(points::AbstractVector{<: AbstractPoint}, indices::AbstractVector{<: Integer}, skip = 1)
Creates a LineString from a vector of points and an index list. With skip == 1, the default, it will connect the line like this:
points = Point[a, b, c, d]; faces = [1, 2, 3, 4]
+Polygon(linestring)
sourceGeometryBasics.HyperRectangle — TypeHyperRectangle{N, T}
A HyperRectangle is a generalization of a rectangle into N-dimensions. Formally it is the cartesian product of intervals, which is represented by the origin and widths fields, whose indices correspond to each of the N axes.
sourceGeometryBasics.HyperSphere — TypeHyperSphere{N, T}
A HyperSphere is a generalization of a sphere into N-dimensions. A center and radius, r, must be specified.
sourceGeometryBasics.LineString — TypeLineString(points::AbstractVector{<: AbstractPoint}, indices::AbstractVector{<: Integer}, skip = 1)
Creates a LineString from a vector of points and an index list. With skip == 1, the default, it will connect the line like this:
points = Point[a, b, c, d]; faces = [1, 2, 3, 4]
linestring = LineString(points, faces)
@assert linestring == LineString([a => b, b => c, c => d])
To make a segmented line, set skip to 2
points = Point[a, b, c, d]; faces = [1, 2, 3, 4]
linestring = LineString(points, faces, 2)
-@assert linestring == LineString([a => b, c => d])
sourceGeometryBasics.Mesh — TypeMesh <: AbstractVector{Element}
The concrete AbstractMesh implementation.
sourceGeometryBasics.MetaT — TypeMetaT(geometry, meta::NamedTuple)
+@assert linestring == LineString([a => b, c => d])
sourceGeometryBasics.LineString — TypeLineString(points::AbstractVector{<: AbstractPoint}, skip = 1)
Creates a LineString from a vector of points. With skip == 1, the default, it will connect the line like this:
points = Point[a, b, c, d]
+linestring = LineString(points)
+@assert linestring == LineString([a => b, b => c, c => d])
sourceGeometryBasics.LineString — TypeLineString(points::AbstractVector{<:AbstractPoint})
A LineString is a geometry of connected line segments
sourceGeometryBasics.Mesh — TypeMesh <: AbstractVector{Element}
The concrete AbstractMesh implementation.
sourceGeometryBasics.MetaT — TypeMetaT(geometry, meta::NamedTuple)
MetaT(geometry; meta...)
Returns a MetaT that holds a geometry and its metadata
MetaT acts the same as Meta method. The difference lies in the fact that it is designed to handle geometries and metadata of different/heterogeneous types.
eg: While a Point MetaGeometry is a PointMeta, the MetaT representation is MetaT{Point} The downside being it's not subtyped to AbstractPoint like a PointMeta is.
Example:
julia> MetaT(Point(1, 2), city = "Mumbai")
-MetaT{Point{2,Int64},(:city,),Tuple{String}}([1, 2], (city = "Mumbai",))
sourceGeometryBasics.MultiPoint — TypeMultiPoint(points::AbstractVector{AbstractPoint})
A collection of points
sourceGeometryBasics.MultiPolygon — TypeMultiPolygon(polygons::AbstractPolygon)
sourceGeometryBasics.NormalMesh — TypeNormalMesh{Dim, T}
PlainMesh with normals meta at each point. normalmesh.normals isa AbstractVector{Vec3f}
sourceGeometryBasics.NormalUVMesh — TypeNormalUVMesh{Dim, T}
PlainMesh with normals and uv meta at each point. normalmesh.normals isa AbstractVector{Vec3f} normalmesh.uv isa AbstractVector{Vec2f}
sourceGeometryBasics.NormalUVWMesh — TypeNormalUVWMesh{Dim, T}
PlainMesh with normals and uvw (texture coordinates in 3D) meta at each point. normalmesh.normals isa AbstractVector{Vec3f} normalmesh.uvw isa AbstractVector{Vec3f}
sourceGeometryBasics.OffsetInteger — TypeOffsetInteger{O, T}
OffsetInteger type mainly for indexing.
O - The offset relative to Julia arrays. This helps reduce copying when
communicating with 0-indexed systems such as OpenGL.
sourceGeometryBasics.PlainMesh — TypePlainMesh{Dim, T}
Triangle mesh with no meta information (just points + triangle faces)
sourceGeometryBasics.Polygon — TypePolygon(exterior::AbstractVector{<:Point})
-Polygon(exterior::AbstractVector{<:Point}, interiors::Vector{<:AbstractVector{<:AbstractPoint}})
sourceGeometryBasics.Polytope — TypeGeometry made of N connected points. Connected as one flat geometry, it makes a Ngon / Polygon. Connected as volume it will be a Simplex / Tri / Cube. Note That Polytope{N} where N == 3 denotes a Triangle both as a Simplex or Ngon.
sourceGeometryBasics.Polytope — MethodThe Ngon Polytope element type when indexing an array of points with a SimplexFace
sourceGeometryBasics.Polytope — MethodThe Simplex Polytope element type when indexing an array of points with a SimplexFace
sourceGeometryBasics.Polytope — MethodThe fully concrete Ngon type, when constructed from a point type!
sourceGeometryBasics.Polytope — MethodThe fully concrete Simplex type, when constructed from a point type!
sourceGeometryBasics.Rect — MethodRect(vals::Number...)
Rect(vals::Number...)
Rect constructor for individually specified intervals. e.g. Rect(0,0,1,2) has origin == Vec(0,0) and width == Vec(1,2)
sourceGeometryBasics.Rect — MethodConstruct a HyperRectangle enclosing all points.
sourceGeometryBasics.Simplex — TypeA Simplex is a generalization of an N-dimensional tetrahedra and can be thought of as a minimal convex set containing the specified points.
- A 0-simplex is a point.
- A 1-simplex is a line segment.
- A 2-simplex is a triangle.
- A 3-simplex is a tetrahedron.
Note that this datatype is offset by one compared to the traditional mathematical terminology. So a one-simplex is represented as Simplex{2,T}. This is for a simpler implementation.
It applies to infinite dimensions. The structure of this type is designed to allow embedding in higher-order spaces by parameterizing on T.
sourceGeometryBasics.Sphere — TypeSphere{T}
An alias for a HyperSphere of dimension 3. (i.e. HyperSphere{3, T})
sourceGeometryBasics.Tesselation — TypeTesselation(primitive, nvertices)
For abstract geometries, when we generate a mesh from them, we need to decide how fine grained we want to mesh them. To transport this information to the various decompose methods, you can wrap it in the Tesselation object e.g. like this:
sphere = Sphere(Point3f(0), 1)
+MetaT{Point{2,Int64},(:city,),Tuple{String}}([1, 2], (city = "Mumbai",))
sourceGeometryBasics.MultiPoint — TypeMultiPoint(points::AbstractVector{AbstractPoint})
A collection of points
sourceGeometryBasics.MultiPolygon — TypeMultiPolygon(polygons::AbstractPolygon)
sourceGeometryBasics.NormalMesh — TypeNormalMesh{Dim, T}
PlainMesh with normals meta at each point. normalmesh.normals isa AbstractVector{Vec3f}
sourceGeometryBasics.NormalUVMesh — TypeNormalUVMesh{Dim, T}
PlainMesh with normals and uv meta at each point. normalmesh.normals isa AbstractVector{Vec3f} normalmesh.uv isa AbstractVector{Vec2f}
sourceGeometryBasics.NormalUVWMesh — TypeNormalUVWMesh{Dim, T}
PlainMesh with normals and uvw (texture coordinates in 3D) meta at each point. normalmesh.normals isa AbstractVector{Vec3f} normalmesh.uvw isa AbstractVector{Vec3f}
sourceGeometryBasics.OffsetInteger — TypeOffsetInteger{O, T}
OffsetInteger type mainly for indexing.
O - The offset relative to Julia arrays. This helps reduce copying when
communicating with 0-indexed systems such as OpenGL.
sourceGeometryBasics.PlainMesh — TypePlainMesh{Dim, T}
Triangle mesh with no meta information (just points + triangle faces)
sourceGeometryBasics.Polygon — TypePolygon(exterior::AbstractVector{<:Point})
+Polygon(exterior::AbstractVector{<:Point}, interiors::Vector{<:AbstractVector{<:AbstractPoint}})
sourceGeometryBasics.Polytope — TypeGeometry made of N connected points. Connected as one flat geometry, it makes a Ngon / Polygon. Connected as volume it will be a Simplex / Tri / Cube. Note That Polytope{N} where N == 3 denotes a Triangle both as a Simplex or Ngon.
sourceGeometryBasics.Polytope — MethodThe Ngon Polytope element type when indexing an array of points with a SimplexFace
sourceGeometryBasics.Polytope — MethodThe Simplex Polytope element type when indexing an array of points with a SimplexFace
sourceGeometryBasics.Polytope — MethodThe fully concrete Ngon type, when constructed from a point type!
sourceGeometryBasics.Polytope — MethodThe fully concrete Simplex type, when constructed from a point type!
sourceGeometryBasics.Rect — MethodRect(vals::Number...)
Rect(vals::Number...)
Rect constructor for individually specified intervals. e.g. Rect(0,0,1,2) has origin == Vec(0,0) and width == Vec(1,2)
sourceGeometryBasics.Rect — MethodConstruct a HyperRectangle enclosing all points.
sourceGeometryBasics.Simplex — TypeA Simplex is a generalization of an N-dimensional tetrahedra and can be thought of as a minimal convex set containing the specified points.
- A 0-simplex is a point.
- A 1-simplex is a line segment.
- A 2-simplex is a triangle.
- A 3-simplex is a tetrahedron.
Note that this datatype is offset by one compared to the traditional mathematical terminology. So a one-simplex is represented as Simplex{2,T}. This is for a simpler implementation.
It applies to infinite dimensions. The structure of this type is designed to allow embedding in higher-order spaces by parameterizing on T.
sourceGeometryBasics.Sphere — TypeSphere{T}
An alias for a HyperSphere of dimension 3. (i.e. HyperSphere{3, T})
sourceGeometryBasics.Tesselation — TypeTesselation(primitive, nvertices)
For abstract geometries, when we generate a mesh from them, we need to decide how fine grained we want to mesh them. To transport this information to the various decompose methods, you can wrap it in the Tesselation object e.g. like this:
sphere = Sphere(Point3f(0), 1)
m1 = mesh(sphere) # uses a default value for tesselation
m2 = mesh(Tesselation(sphere, 64)) # uses 64 for tesselation
-length(coordinates(m1)) != length(coordinates(m2))
For grid based tesselation, you can also use a tuple: ```julia rect = Rect2(0, 0, 1, 1) Tesselation(rect, (5, 5))
sourceGeometryBasics.TriangleMesh — TypeTriangleMesh{Dim, T, PointType}
Abstract Mesh with triangle elements of eltype T.
sourceGeometryBasics.TupleView — TypeTupleView{T, N, Skip, A}
TupleView, groups elements of an array as tuples. N is the dimension of the tuple, M tells how many elements to skip to the next tuple. By default TupleView{N} defaults to skip N items.
a few examples:
+length(coordinates(m1)) != length(coordinates(m2))
For grid based tesselation, you can also use a tuple: ```julia rect = Rect2(0, 0, 1, 1) Tesselation(rect, (5, 5))
sourceGeometryBasics.TriangleMesh — TypeTriangleMesh{Dim, T, PointType}
Abstract Mesh with triangle elements of eltype T.
sourceGeometryBasics.TupleView — TypeTupleView{T, N, Skip, A}
TupleView, groups elements of an array as tuples. N is the dimension of the tuple, M tells how many elements to skip to the next tuple. By default TupleView{N} defaults to skip N items.
a few examples:
x = [1, 2, 3, 4, 5, 6]
TupleView{2, 1}(x):
> [(1, 2), (2, 3), (3, 4), (4, 5), (5, 6)]
@@ -34,11 +34,11 @@
TupleView{3, 1}(x):
> [(1, 2, 3), (2, 3, 4), (3, 4, 5), (4, 5, 6)]
TupleView can be used together with reinterpret:
x = [1, 2, 3, 4]
y = reinterpret(Point{2, Int}, TupleView{2, 1}(x))
-> [Point(1, 2), Point(2, 3), Point(3, 4)]
sourceGeometryBasics.UVMesh — TypeUVMesh{Dim, T}
PlainMesh with texture coordinates meta at each point. uvmesh.uv isa AbstractVector{Vec2f}
sourceGeometryBasics.area — Methodarea(contour::AbstractVector{AbstractPoint}})
Calculate the area of a polygon.
For 2D points, the oriented area is returned (negative when the points are oriented clockwise).
sourceGeometryBasics.area — Methodarea(vertices::AbstractVector{AbstractPoint{3}}, faces::AbstractVector{TriangleFace})
Calculate the area of all triangles.
sourceGeometryBasics.area — Methodarea(vertices::AbstractVector{AbstractPoint{3}}, face::TriangleFace)
Calculate the area of one triangle.
sourceGeometryBasics.connect — Methodconnect(points::AbstractVector{<: AbstractPoint}, P::Type{<: Polytope{N}}, skip::Int = N)
Creates a view that connects a number of points to a Polytope P. Between each polytope, skip elements are skipped untill the next starts. Example: ```julia x = connect(Point[(1, 2), (3, 4), (5, 6), (7, 8)], Line, 2) x == [Line(Point(1, 2), Point(3, 4)), Line(Point(5, 6), Point(7, 8))]
sourceGeometryBasics.convert_simplex — Methodconvert_simplex(::Type{Face{2}}, f::Face{N})
Extract all line segments in a Face.
sourceGeometryBasics.convert_simplex — Methodconvert_simplex(::Type{Face{3}}, f::Face{N})
Triangulate an N-Face into a tuple of triangular faces.
sourceGeometryBasics.coordinates — Methodcoordinates(geometry)
Returns the edges/vertices/coordinates of a geometry. Is allowed to return lazy iterators! Use decompose(ConcretePointType, geometry) to get Vector{ConcretePointType} with ConcretePointType to be something like Point{3, Float32}.
sourceGeometryBasics.decompose — Methoddecompose(facetype, contour::AbstractArray{<:AbstractPoint})
Triangulate a Polygon without hole.
Returns a Vector{facetype} defining indexes into contour.
sourceGeometryBasics.faces — Methodfaces(geometry)
Returns the face connections of a geometry. Is allowed to return lazy iterators! Use decompose(ConcreteFaceType, geometry) to get Vector{ConcreteFaceType} with ConcreteFaceType to be something like TriangleFace{Int}.
sourceGeometryBasics.intersects — Methodintersects(a::Line, b::Line) -> Bool, Point
Intersection of 2 line segmens a and b. Returns intersectionfound::Bool, intersectionpoint::Point
sourceGeometryBasics.meta — Methodmeta(x::MetaT)
-meta(x::Array{MetaT})
Returns the metadata of a MetaT
sourceGeometryBasics.meta — Methodmeta(x::MetaObject)
Returns the metadata of x
sourceGeometryBasics.meta_table — MethodPuts an iterable of MetaT's into a StructArray
sourceGeometryBasics.metafree — Methodmetafree(x::MetaT)
-metafree(x::Array{MetaT})
Free the MetaT from metadata i.e. returns the geometry/array of geometries
sourceGeometryBasics.normals — Methodnormals{VT,FD,FT,FO}(vertices::Vector{Point{3, VT}},
+> [Point(1, 2), Point(2, 3), Point(3, 4)]
sourceGeometryBasics.UVMesh — TypeUVMesh{Dim, T}
PlainMesh with texture coordinates meta at each point. uvmesh.uv isa AbstractVector{Vec2f}
sourceGeometryBasics.area — Methodarea(contour::AbstractVector{AbstractPoint}})
Calculate the area of a polygon.
For 2D points, the oriented area is returned (negative when the points are oriented clockwise).
sourceGeometryBasics.area — Methodarea(vertices::AbstractVector{AbstractPoint{3}}, faces::AbstractVector{TriangleFace})
Calculate the area of all triangles.
sourceGeometryBasics.area — Methodarea(vertices::AbstractVector{AbstractPoint{3}}, face::TriangleFace)
Calculate the area of one triangle.
sourceGeometryBasics.connect — Methodconnect(points::AbstractVector{<: AbstractPoint}, P::Type{<: Polytope{N}}, skip::Int = N)
Creates a view that connects a number of points to a Polytope P. Between each polytope, skip elements are skipped untill the next starts. Example: ```julia x = connect(Point[(1, 2), (3, 4), (5, 6), (7, 8)], Line, 2) x == [Line(Point(1, 2), Point(3, 4)), Line(Point(5, 6), Point(7, 8))]
sourceGeometryBasics.convert_simplex — Methodconvert_simplex(::Type{Face{2}}, f::Face{N})
Extract all line segments in a Face.
sourceGeometryBasics.convert_simplex — Methodconvert_simplex(::Type{Face{3}}, f::Face{N})
Triangulate an N-Face into a tuple of triangular faces.
sourceGeometryBasics.coordinates — Methodcoordinates(geometry)
Returns the edges/vertices/coordinates of a geometry. Is allowed to return lazy iterators! Use decompose(ConcretePointType, geometry) to get Vector{ConcretePointType} with ConcretePointType to be something like Point{3, Float32}.
sourceGeometryBasics.decompose — Methoddecompose(facetype, contour::AbstractArray{<:AbstractPoint})
Triangulate a Polygon without hole.
Returns a Vector{facetype} defining indexes into contour.
sourceGeometryBasics.faces — Methodfaces(geometry)
Returns the face connections of a geometry. Is allowed to return lazy iterators! Use decompose(ConcreteFaceType, geometry) to get Vector{ConcreteFaceType} with ConcreteFaceType to be something like TriangleFace{Int}.
sourceGeometryBasics.intersects — Methodintersects(a::Line, b::Line) -> Bool, Point
Intersection of 2 line segmens a and b. Returns intersectionfound::Bool, intersectionpoint::Point
sourceGeometryBasics.meta — Methodmeta(x::MetaT)
+meta(x::Array{MetaT})
Returns the metadata of a MetaT
sourceGeometryBasics.meta — Methodmeta(x::MetaObject)
Returns the metadata of x
sourceGeometryBasics.meta_table — MethodPuts an iterable of MetaT's into a StructArray
sourceGeometryBasics.metafree — Methodmetafree(x::MetaT)
+metafree(x::Array{MetaT})
Free the MetaT from metadata i.e. returns the geometry/array of geometries
sourceGeometryBasics.normals — Methodnormals{VT,FD,FT,FO}(vertices::Vector{Point{3, VT}},
faces::Vector{Face{FD,FT,FO}},
- NT = Normal{3, VT})
Compute all vertex normals.
sourceGeometryBasics.pointmeta — Methodpointmeta(mesh::Mesh; meta_data...)
Attaches metadata to the coordinates of a mesh
sourceGeometryBasics.self_intersections — Methodself_intersections(points::AbstractVector{AbstractPoint})
Finds all self intersections of polygon points
sourceGeometryBasics.split_intersections — Methodsplit_intersections(points::AbstractVector{AbstractPoint})
Splits polygon points into it's self intersecting parts. Only 1 intersection is handled right now.
sourceGeometryBasics.volume — Methodvolume(mesh)
Calculate the signed volume of all tetrahedra. Be sure the orientation of your surface is right.
sourceGeometryBasics.volume — Methodvolume(triangle)
Calculate the signed volume of one tetrahedron. Be sure the orientation of your surface is right.
sourcePrivate
GeometryBasics.Ngon — TypeFixed Size Polygon, e.g.
- N 1-2 : Illegal!
- N = 3 : Triangle
- N = 4 : Quadrilateral (or Quad, Or tetragon)
- N = 5 : Pentagon
- ...
sourceBase.:* — Method*(m::Mat, h::Rect)
Transform a Rect using a matrix. Maintains axis-align properties so a significantly larger Rect may be generated.
sourceBase.in — Methodin(b1::Rect, b2::Rect)
Check if Rect b1 is contained in b2. This does not use strict inequality, so Rects may share faces and this will still return true.
sourceBase.in — Methodin(pt::VecTypes, b1::Rect{N, T})
Check if a point is contained in a Rect. This will return true if the point is on a face of the Rect.
sourceBase.in — Methodin(point, triangle)
Determine if a point is inside of a triangle.
sourceBase.isempty — Methodisempty(h::Rect)
Return true if any of the widths of h are negative.
sourceBase.union — MethodPerform a union between two Rects.
sourceGeometryBasics.MetaFree — MethodMetaFree(::Type{T})
Returns the original type containing no metadata for T E.g:
MetaFree(PointMeta) == Point
sourceGeometryBasics.MetaType — MethodMetaType(::Type{T})
Returns the Meta Type corresponding to T E.g:
MetaType(Point) == PointMeta
sourceGeometryBasics.attributes — Methodattributes(hasmeta)
Returns all attributes of meta as a Dict{Symbol, Any}. Needs to be overloaded, and returns empty dict for non overloaded types! Gets overloaded by default for all Meta types.
sourceGeometryBasics.diff — Methoddiff(h1::Rect, h2::Rect)
Perform a difference between two Rects.
sourceGeometryBasics.facemeta — Methodfacemeta(mesh::Mesh; meta_data...)
Attaches metadata to the faces of a mesh
sourceGeometryBasics.getcolumns — Methodgetcolumns(t, colnames::Symbol...)
Gets a column from any Array like (Table/AbstractArray). For AbstractVectors, a column will be the field names of the element type.
sourceGeometryBasics.intersect — Methodintersect(h1::Rect, h2::Rect)
Perform a intersection between two Rects.
sourceGeometryBasics.mesh — Methodmesh(primitive::GeometryPrimitive;
+ NT = Normal{3, VT})
Compute all vertex normals.
sourceGeometryBasics.pointmeta — Methodpointmeta(mesh::Mesh; meta_data...)
Attaches metadata to the coordinates of a mesh
sourceGeometryBasics.self_intersections — Methodself_intersections(points::AbstractVector{AbstractPoint})
Finds all self intersections of polygon points
sourceGeometryBasics.split_intersections — Methodsplit_intersections(points::AbstractVector{AbstractPoint})
Splits polygon points into it's self intersecting parts. Only 1 intersection is handled right now.
sourceGeometryBasics.volume — Methodvolume(mesh)
Calculate the signed volume of all tetrahedra. Be sure the orientation of your surface is right.
sourceGeometryBasics.volume — Methodvolume(triangle)
Calculate the signed volume of one tetrahedron. Be sure the orientation of your surface is right.
sourcePrivate
GeometryBasics.Ngon — TypeFixed Size Polygon, e.g.
- N 1-2 : Illegal!
- N = 3 : Triangle
- N = 4 : Quadrilateral (or Quad, Or tetragon)
- N = 5 : Pentagon
- ...
sourceBase.:* — Method*(m::Mat, h::Rect)
Transform a Rect using a matrix. Maintains axis-align properties so a significantly larger Rect may be generated.
sourceBase.in — Methodin(b1::Rect, b2::Rect)
Check if Rect b1 is contained in b2. This does not use strict inequality, so Rects may share faces and this will still return true.
sourceBase.in — Methodin(pt::VecTypes, b1::Rect{N, T})
Check if a point is contained in a Rect. This will return true if the point is on a face of the Rect.
sourceBase.in — Methodin(point, triangle)
Determine if a point is inside of a triangle.
sourceBase.isempty — Methodisempty(h::Rect)
Return true if any of the widths of h are negative.
sourceBase.union — MethodPerform a union between two Rects.
sourceGeometryBasics.MetaFree — MethodMetaFree(::Type{T})
Returns the original type containing no metadata for T E.g:
MetaFree(PointMeta) == Point
sourceGeometryBasics.MetaType — MethodMetaType(::Type{T})
Returns the Meta Type corresponding to T E.g:
MetaType(Point) == PointMeta
sourceGeometryBasics.attributes — Methodattributes(hasmeta)
Returns all attributes of meta as a Dict{Symbol, Any}. Needs to be overloaded, and returns empty dict for non overloaded types! Gets overloaded by default for all Meta types.
sourceGeometryBasics.diff — Methoddiff(h1::Rect, h2::Rect)
Perform a difference between two Rects.
sourceGeometryBasics.facemeta — Methodfacemeta(mesh::Mesh; meta_data...)
Attaches metadata to the faces of a mesh
sourceGeometryBasics.getcolumns — Methodgetcolumns(t, colnames::Symbol...)
Gets a column from any Array like (Table/AbstractArray). For AbstractVectors, a column will be the field names of the element type.
sourceGeometryBasics.intersect — Methodintersect(h1::Rect, h2::Rect)
Perform a intersection between two Rects.
sourceGeometryBasics.mesh — Methodmesh(primitive::GeometryPrimitive;
pointtype=Point, facetype=GLTriangle,
- uv=nothing, normaltype=nothing)
Creates a mesh from primitive.
Uses the element types from the keyword arguments to create the attributes. The attributes that have their type set to nothing are not added to the mesh. Note, that this can be an Int or Tuple{Int, Int}`, when the primitive is grid based. It also only losely correlates to the number of vertices, depending on the algorithm used. #TODO: find a better number here!
sourceGeometryBasics.mesh — Methodmesh(polygon::AbstractVector{P}; pointtype=P, facetype=GLTriangleFace,
- normaltype=nothing)
Create a mesh from a polygon given as a vector of points, using triangulation.
sourceGeometryBasics.orthogonal_vector — MethodThe unnormalized normal of three vertices.
sourceGeometryBasics.pop_pointmeta — Methodpop_pointmeta(mesh::Mesh, property::Symbol)
Remove property from point metadata. Returns the new mesh, and the property!
sourceGeometryBasics.split — Methodsplit(rectangle, axis, value)
Splits an Rect into two along an axis at a given location.
sourceSettings
This document was generated with Documenter.jl version 0.27.25 on Tuesday 18 July 2023. Using Julia version 1.7.3.
Creates a mesh from primitive.
Uses the element types from the keyword arguments to create the attributes. The attributes that have their type set to nothing are not added to the mesh. Note, that this can be an Int or Tuple{Int, Int}`, when the primitive is grid based. It also only losely correlates to the number of vertices, depending on the algorithm used. #TODO: find a better number here!
GeometryBasics.mesh — Methodmesh(polygon::AbstractVector{P}; pointtype=P, facetype=GLTriangleFace,
+ normaltype=nothing)Create a mesh from a polygon given as a vector of points, using triangulation.
GeometryBasics.orthogonal_vector — MethodThe unnormalized normal of three vertices.
GeometryBasics.pop_pointmeta — Methodpop_pointmeta(mesh::Mesh, property::Symbol)Remove property from point metadata. Returns the new mesh, and the property!
GeometryBasics.split — Methodsplit(rectangle, axis, value)Splits an Rect into two along an axis at a given location.