Add docstring heads

Author: Tokazama

src/geometry_primitives.jl

@@ -181,6 +181,8 @@ end
 # Some more primitive types
 
 """
+    HyperSphere{N, T}
+
 A `HyperSphere` is a generalization of a sphere into N-dimensions.
 A `center` and radius, `r`, must be specified.
 """
@@ -189,16 +191,22 @@ struct HyperSphere{N, T} <: GeometryPrimitive{N, T}
     r::T
 end
 """
-An alias for a HyperSphere of dimension 2. i.e. `Circle{T}` -> `HyperSphere{2, T}`
+    Circle{T}
+
+An alias for a HyperSphere of dimension 2. (i.e. `HyperSphere{2, T}`)
 """
 const Circle{T} = HyperSphere{2, T}
 
 """
-An alias for a HyperSphere of dimension 3. i.e. `Sphere{T}` -> `HyperSphere{3, T}`
+    Sphere{T}
+
+An alias for a HyperSphere of dimension 3. (i.e. `HyperSphere{3, T}`)
 """
 const Sphere{T} = HyperSphere{3, T}
 
 """
+    Quad{T}
+
 A rectangle in 3D space.
 """
 struct Quad{T} <: GeometryPrimitive{3, T}
@@ -219,6 +227,8 @@ struct Particle{N, T} <: GeometryPrimitive{N, T}
 end
 
 """
+    Cylinder{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.
 """
@@ -229,6 +239,9 @@ struct Cylinder{N, T} <: GeometryPrimitive{N, T}
 end
 
 """
+    Cylinder2{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.
 """

src/lines.jl

@@ -1,5 +1,7 @@
 
 """
+    intersect(a::Line, b::Line) -> Point
+
 Intersection of 2 line segmens `a` and `b`.
 Returns intersection_found::Bool, intersection_point
 """
@@ -75,6 +77,8 @@ function consecutive_pairs(arr)
 end
 
 """
+    self_intersections(points::AbstractVector{AbstractPoint})
+
 Finds all self intersections of polygon `points`
 """
 function self_intersections(points::AbstractVector{<:AbstractPoint})
@@ -99,6 +103,8 @@ function self_intersections(points::AbstractVector{<:AbstractPoint})
 end
 
 """
+    split_intersections(points::AbstractVector{AbstractPoint})
+
 Splits polygon `points` into it's self intersecting parts. Only 1 intersection
 is handled right now.
 """

src/meshes.jl

@@ -11,12 +11,15 @@ const PointWithUVNormal{Dim, T} = PointMeta{Dim, T, Point{Dim, T}, (:normals, :u
 const PointWithUVWNormal{Dim, T} = PointMeta{Dim, T, Point{Dim, T}, (:normals, :uvw), Tuple{Vec{3, T}, Vec{3, T}}}
 
 """
-Abstract Mesh with triangle elements
+    TriangleMesh{Dim, T, PointType}
+
+Abstract Mesh with triangle elements of eltype `T`.
 """
 const TriangleMesh{Dim, T, PointType} = AbstractMesh{TriangleP{Dim, T, PointType}}
 
 """
-    PlainMesh
+    PlainMesh{Dim, T}
+
 Triangle mesh with no meta information (just points + triangle faces)
 """
 const PlainMesh{Dim, T} = TriangleMesh{Dim, T, Point{Dim, T}}
@@ -25,7 +28,8 @@ const GLPlainMesh2D = GLPlainMesh{2}
 const GLPlainMesh3D = GLPlainMesh{3}
 
 """
-    UVMesh
+    UVMesh{Dim, T}
+
 PlainMesh with texture coordinates meta at each point.
 `uvmesh.uv isa AbstractVector{Vec2f0}`
 """
@@ -35,7 +39,8 @@ const GLUVMesh2D = UVMesh{2}
 const GLUVMesh3D = UVMesh{3}
 
 """
-    NormalMesh
+    NormalMesh{Dim, T}
+
 PlainMesh with normals meta at each point.
 `normalmesh.normals isa AbstractVector{Vec3f0}`
 """
@@ -45,7 +50,8 @@ const GLNormalMesh2D = GLNormalMesh{2}
 const GLNormalMesh3D = GLNormalMesh{3}
 
 """
-    NormalUVMesh
+    NormalUVMesh{Dim, T}
+
 PlainMesh with normals and uv meta at each point.
 `normalmesh.normals isa AbstractVector{Vec3f0}`
 `normalmesh.uv isa AbstractVector{Vec2f0}`
@@ -56,7 +62,8 @@ const GLNormalUVMesh2D = GLNormalUVMesh{2}
 const GLNormalUVMesh3D = GLNormalUVMesh{3}
 
 """
-    NormalUVWMesh
+    NormalUVWMesh{Dim, T}
+
 PlainMesh with normals and uvw (texture coordinates in 3D) meta at each point.
 `normalmesh.normals isa AbstractVector{Vec3f0}`
 `normalmesh.uvw isa AbstractVector{Vec3f0}`
@@ -175,7 +182,10 @@ function normal_mesh(points::AbstractVector{<:AbstractPoint},
 end
 
 """
-Calculate the signed volume of one tetrahedron. Be sure the orientation of your surface is right.
+    volume(triangle)
+
+Calculate the signed volume of one tetrahedron. Be sure the orientation of your
+surface is right.
 """
 function volume(triangle::Triangle) where {VT,FT}
     v1, v2, v3 = triangle
@@ -184,7 +194,10 @@ function volume(triangle::Triangle) where {VT,FT}
 end
 
 """
-Calculate the signed volume of all tetrahedra. Be sure the orientation of your surface is right.
+    volume(mesh)
+
+Calculate the signed volume of all tetrahedra. Be sure the orientation of your
+surface is right.
 """
 function volume(mesh::Mesh) where {VT, FT}
     return sum(volume, mesh)

src/metadata.jl

@@ -10,6 +10,7 @@ end
 
 """
     getcolumns(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.
 """
@@ -21,6 +22,7 @@ getcolumn(t, colname::Symbol) = getcolumns(t, colname)[1]
 
 """
     MetaType(::Type{T})
+
 Returns the Meta Type corresponding to `T`
 E.g:
 ```julia
@@ -30,6 +32,7 @@ MetaType(::Type{T}) where T = error("No Meta Type for $T")
 
 """
     MetaFree(::Type{T})
+
 Returns the original type containing no metadata for `T`
 E.g:
 ```julia
@@ -39,6 +42,7 @@ MetaFree(::Type{T}) where T = error("No meta free Type for $T")
 
 """
     meta(x::MetaObject)
+
 Returns the metadata of `x`
 """
 meta(x::T) where T = error("$T has no meta!")

src/offsetintegers.jl

@@ -1,5 +1,7 @@
 
 """
+    OffsetInteger{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 ad OpenGL.

src/rectangles.jl

@@ -1,5 +1,7 @@
 
 """
+    HyperRectangle{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 `width` fields, whose indices correspond to each of the `N` axes.
@@ -61,6 +63,8 @@ end
 
 
 """
+    Rect(vals::Number...)
+
 ```
 Rect(vals::Number...)
 ```
@@ -162,6 +166,8 @@ width(prim::Rect) = prim.widths[1]
 height(prim::Rect) = prim.widths[2]
 
 """
+    split(rectangle, axis, value)
+
 Splits an Rect into two along an axis at a given location.
 """
 split(b::Rect, axis, value::Integer) = _split(b, axis, value)
@@ -180,6 +186,8 @@ end
 # Algebraic operations
 
 """
+    *(m::Mat, h::Rect)
+
 Transform a `Rect` using a matrix. Maintains axis-align properties
 so a significantly larger Rect may be generated.
 """
@@ -310,11 +318,15 @@ function Base.union(h1::Rect{N}, h2::Rect{N}) where N
 end
 
 """
+    diff(h1::Rect, h2::Rect)
+
 Perform a difference between two Rects.
 """
 diff(h1::Rect, h2::Rect) = h1
 
 """
+    intersect(h1::Rect, h2::Rect)
+
 Perform a intersection between two Rects.
 """
 function intersect(h1::Rect{N}, h2::Rect{N}) where N
@@ -457,6 +469,8 @@ end
 # Containment
 
 """
+    contains(b1::Rect, b2::Rect)
+
 Check if Rects are contained in each other. This does not use
 strict inequality, so Rects may share faces and this will still
 return true.
@@ -471,6 +485,8 @@ function Base.in(b2::Rect{N}, b1::Rect{N}) where N
 end
 
 """
+    contains(b1::Rect{N, T}, pt::VecTypes)
+
 Check if a point is contained in a Rect. This will return true if
 the point is on a face of the Rect.
 """

src/triangulation.jl

@@ -13,6 +13,8 @@ The above copyright notice and this permission notice shall be included in all c
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 =#
 """
+    area(vertices::AbstractVector{AbstractPoint{3}}, face::TriangleFace)
+
 Calculate the area of one triangle.
 """
 function area(vertices::AbstractVector{<:AbstractPoint{3, VT}}, face::TriangleFace{FT}) where {VT,FT}
@@ -21,6 +23,8 @@ function area(vertices::AbstractVector{<:AbstractPoint{3, VT}}, face::TriangleFa
 end
 
 """
+    area(vertices::AbstractVector{AbstractPoint{3}}, faces::AbstractVector{TriangleFace})
+
 Calculate the area of all triangles.
 """
 function area(
@@ -53,6 +57,8 @@ function area(contour::AbstractVector{Point{3, T}}) where {T}
 end
 
 """
+    in(point, triangle)
+
  InsideTriangle decides if a point P is Inside of the triangle
  defined by A, B, C.
 """

src/viewtypes.jl

@@ -1,4 +1,6 @@
 """
+    TupleView{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.
@@ -92,6 +94,8 @@ end
 end
 
 """
+    FaceView{Elemnt, 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: