Fix bugs in docstrings

Author: AleMorales

src/Mesh/Areas.jl

@@ -12,13 +12,15 @@ The area of the triangle.
 
 # Example
 ```jldoctest
+julia> import PlantGeomPrimitives as PG;
+
 julia> v1 = Vec(0.0, 0.0, 0.0);
 
 julia> v2 = Vec(1.0, 0.0, 0.0);
 
 julia> v3 = Vec(0.0, 1.0, 0.0);
 
-julia> area_triangle(v1, v2, v3);
+julia> PG.area_triangle(v1, v2, v3);
 ```
 """
 function area_triangle(v1::Vec{FT}, v2::Vec{FT}, v3::Vec{FT})::FT where {FT<:AbstractFloat}

src/Mesh/Edges.jl

@@ -2,8 +2,8 @@
 """
     update_edges!(m::Mesh{FT}) where {FT<:AbstractFloat}
 
-Calculate the edges of a mesh and add them as properties. 
-This function checks if the edges property exists, and if not, it creates it. 
+Calculate the edges of a mesh and add them as properties.
+This function checks if the edges property exists, and if not, it creates it.
 It then computes the edges for all vertices in the mesh.
 
 # Arguments
@@ -14,11 +14,13 @@ Nothing. It modifies the mesh in place by adding the edges as a property.
 
 # Example
 ```jldoctest
+julia> import PlantGeomPrimitives as PG;
+
 julia> vs = [Vec(0.0, 0.0, 0.0), Vec(1.0, 0.0, 0.0), Vec(0.0, 1.0, 0.0)];
 
 julia> m = Mesh(vs);
 
-julia> update_edges!(m);
+julia> PG.update_edges!(m);
 
 julia> edges(m);
 ```
@@ -48,7 +50,7 @@ end
 """
     push_edges!(vs, m, i0)
 
-Create the three edges stored as a vector of vectors from 
+Create the three edges stored as a vector of vectors from
 the vertices `vs` starting at index `i0` and add them to the
 mesh's property.
 
@@ -62,13 +64,15 @@ Nothing. It modifies the mesh in place by adding the edges.
 
 # Example
 ```jldoctest
+julia> import PlantGeomPrimitives as PG;
+
 julia> vs = [Vec(0.0, 0.0, 0.0), Vec(1.0, 0.0, 0.0), Vec(0.0, 1.0, 0.0)];
 
 julia> m = Mesh(vs);
 
-julia> update_edges!(m);
+julia> PG.update_edges!(m);
 
-julia> push_edges!(vs, m, 1);
+julia> PG.push_edges!(vs, m, 1);
 
 julia> edges(m);
 ```

src/Mesh/MeshIO.jl

@@ -15,13 +15,13 @@ A `GeometryBasics.Mesh` object containing the vertices and faces of the mesh.
 
 # Example
 ```jldoctest
+julia> import PlantGeomPrimitives as PG;
+
 julia> vs = [Vec(0.0, 0.0, 0.0), Vec(1.0, 0.0, 0.0), Vec(0.0, 1.0, 0.0)];
 
 julia> m = Mesh(vs);
 
-julia> gl_mesh = GLMesh(m);
-
-julia> typeof(gl_mesh)
+julia> gl_mesh = PG.GLMesh(m);
 ```
 """
 function GLMesh(m::Mesh{FT}) where {FT<:AbstractFloat}
@@ -45,11 +45,13 @@ A `Mesh` object containing the vertices of the mesh.
 
 # Example
 ```jldoctest
+julia> import GeometryBasics as GB;
+
 julia> m = GB.Mesh([GB.Point(0.0, 0.0, 0.0), GB.Point(1.0, 0.0, 0.0), GB.Point(0.0, 1.0, 0.0)], [GB.TriangleFace(1, 2, 3)]);
 
 julia> mesh = Mesh(m);
 
-julia> typeof(mesh)
+julia> typeof(mesh);
 ```
 """
 function Mesh(m::GB.Mesh)

src/Mesh/Normals.jl

@@ -14,11 +14,13 @@ Nothing. It modifies the mesh in place by adding the normals as a property.
 
 # Example
 ```jldoctest
+julia> import PlantGeomPrimitives as PG;
+
 julia> vs = [Vec(0.0, 0.0, 0.0), Vec(1.0, 0.0, 0.0), Vec(0.0, 1.0, 0.0)];
 
 julia> m = Mesh(vs);
 
-julia> update_normals!(m);
+julia> PG.update_normals!(m);
 
 julia> normals(m);
 ```

src/Mesh/Properties.jl

@@ -15,15 +15,17 @@ The modified `p1` dictionary with properties from `p2` added.
 
 # Example
 ```jldoctest
+julia> import PlantGeomPrimitives as PG;
+
 julia> p1 = Dict{Symbol, AbstractVector}(:prop1 => [1.0, 2.0], :prop2 => [3.0, 4.0]);
 
-julia> p2 = Dict{Symbol, AbstractVector}(:prop1 => [5.0, 6.0], :prop3 => [7.0, 8.0]);
+julia> p2 = Dict{Symbol, AbstractVector}(:prop1 => [5.0, 6.0], :prop2 => [7.0, 8.0]);
 
-julia> merged_properties = add_properties!(p1, p2);
+julia> merged_properties = PG.add_properties!(p1, p2);
 
 julia> merged_properties;
 ```
-""" 
+"""
 function add_properties!(p1::Dict{Symbol, AbstractVector}, p2::Dict{Symbol, AbstractVector})
     # Both are empty
     isempty(p1) && isempty(p2) && (return nothing)

src/Mesh/Slicer.jl

@@ -16,14 +16,16 @@ the mesh that contains the indices of the planes where each triangle lies.
 
 # Example
 ```jldoctest output=false
-julia> import ColorTypes: RGB
+julia> import ColorTypes: RGB;
 
 julia> mesh = Rectangle(length = 1.0, width = 1.0);
 
 julia> slice!(mesh, Y = collect(-0.25:0.25:0.5), Z = collect(0.25:0.25:1));
 
 julia> add_property!(mesh, :colors, rand(RGB));
 
+julia> using PlantViz;
+
 julia> render(mesh, wireframe = true);
 ```
 """
@@ -126,9 +128,11 @@ A tuple containing:
 
 # Example
 ```jldoctest
+julia> import PlantGeomPrimitives as PG;
+
 julia> m = Rectangle(length = 1.0, width = 1.0);
 
-julia> check_intersection(m, 1, 2, 0.5, 1);
+julia> PG.check_intersection(m, 1, 2, 0.5, 1);
 ```
 """
 function check_intersection(m::Mesh, t::Integer, i::Integer, h::Real, j::Integer)
@@ -207,12 +211,14 @@ The next vertex index in the sequence (1, 2, or 3).
 
 # Example
 ```jldoctest
-julia> next(1);
-2
-julia> next(2);
-3
-julia> next(3);
-1
+julia> import PlantGeomPrimitives as PG;
+
+julia> PG.next(1);
+
+julia> PG.next(2);
+
+julia> PG.next(3);
+
 ```
 """
 next(i::Integer) = mod(i,3) + 1
@@ -238,10 +244,16 @@ A tuple containing the updated slice indices for the two new triangles created f
 
 # Example
 ```jldoctest
+julia> import PlantGeomPrimitives as PG;
+
 julia> mesh = Rectangle(length = 1.0, width = 1.0);
-julia> update_edges!(mesh);
-julia> nverts_before = length(vertices(mesh))
-julia> one_triangle_intersection!(mesh, 1, 2, 0.5, 1, [1,1,1], 2, [1, -1, -1]);
+
+julia> PG.update_edges!(mesh);
+
+julia> nverts_before = length(vertices(mesh));
+
+julia> PG.one_triangle_intersection!(mesh, 1, 2, 0.5, 1, [1,1,1], 2, [1, -1, -1]);
+
 julia> nverts_after = length(vertices(mesh));
 ```
 """
@@ -288,20 +300,23 @@ Intersect a triangle with a plane, create two new triangles, and add them to the
 - `s`: The signs of the distances to the plane for each vertex.
 
 # Returns
-A tuple containing the updated slice indices for the three new triangles created 
+A tuple containing the updated slice indices for the three new triangles created
 from the intersection.
 
 # Example
 ```jldoctest
+julia> import PlantGeomPrimitives as PG;
+
 julia> mesh = Rectangle(length = 1.0, width = 1.0);
 
-julia> update_edges!(mesh);
+julia> PG.update_edges!(mesh);
 
-julia> nverts_before = length(vertices(mesh))
+julia> nverts_before = length(vertices(mesh));
 
-julia> two_triangle_intersections!(mesh, 1, 2, 0.5, 1, [1,1,1], 2, [1, -1, -1]);
+julia> PG.two_triangle_intersections!(mesh, 1, 2, 0.5, 1, [1,1,1], 2, [1, -1, -1]);
 
 julia> nverts_after = length(vertices(mesh));
+
 ```
 """
 function two_triangle_intersections!(mesh, t, i, h, vi, slindex, j, s)
@@ -356,13 +371,15 @@ The 3D coordinates of the intersection point.
 
 # Example
 ```jldoctest
+julia> import PlantGeomPrimitives as PG;
+
 julia> vs = [Vec(0.0, 0.0, 0.0), Vec(1.0, 0.0, 0.0), Vec(0.0, 1.0, 0.0)];
 
 julia> es = [vs[2] - vs[1], vs[3] - vs[2], vs[3] - vs[1]]; # Examples: intersect the triangle with the plane x = 0.5, using vertex 1 as the reference
 
-julia> one_intersection_point(1, 0.5, 3, es, vs); # Intersection point between the plane and the edge opposite to vertex 1
+julia> PG.one_intersection_point(1, 0.5, 3, es, vs); # Intersection point between the plane and the edge opposite to vertex 1
 
-julia> one_intersection_point(1, 0.5, 2, es, vs); # Intersection point between the plane and the edge opposite to vertex 2
+julia> PG.one_intersection_point(1, 0.5, 2, es, vs); # Intersection point between the plane and the edge opposite to vertex 2
 ```
 """
 function one_intersection_point(i, h, vi, es, vs)
@@ -398,21 +415,23 @@ A tuple containing the 3D coordinates of the two intersection points.
 
 # Example
 ```jldoctest
+julia> import PlantGeomPrimitives as PG;
+
 julia> vs = [Vec(0.0, 0.0, 0.0), Vec(1.0, 0.0, 0.0), Vec(0.0, 1.0, 0.0)];
 
 julia> es = [vs[2] - vs[1], vs[3] - vs[2], vs[1] - vs[3]]; # Examples: intersect the triangle with the plane x = 0.5, using vertex 1 as the reference
 
-julia> two_intersection_points(1, 0.5, 3, es, vs); # Intersection points between the plane and the edges opposite to vertex 1
+julia> PG.two_intersection_points(1, 0.5, 3, es, vs); # Intersection points between the plane and the edges opposite to vertex 1
 
-julia> two_intersection_points(1, 0.5, 2, es, vs); # Intersection points between the plane and the edges opposite to vertex 2
+julia> PG.two_intersection_points(1, 0.5, 2, es, vs); # Intersection points between the plane and the edges opposite to vertex 2
 ```
 """
 function two_intersection_points(i, h, vi, es, vs)
     @inbounds begin
         # Choose barycentric coordinate system
         vi == 1 && begin vr, e1, e2 = (vs[1],   es[1],   es[2]) end
-        vi == 2 && begin vr, e1, e2 = (vs[2], .-es[3], .-es[1]) end 
-        vi == 3 && begin vr, e1, e2 = (vs[3],  .-es[2] , es[3]) end 
+        vi == 2 && begin vr, e1, e2 = (vs[2], .-es[3], .-es[1]) end
+        vi == 3 && begin vr, e1, e2 = (vs[3],  .-es[2] , es[3]) end
         # Calculate the barycentric coordinate on each axis
         # and from that the 3D coordinate of intersection point
         d = (h - vr[i])/e1[i]

src/Mesh/Transformations.jl

@@ -10,21 +10,25 @@ In-place affine transfrmation of a mesh `m` using a transformation map `trans`.
 
 # Arguments
 - `m`: The mesh to be transformed.
-- `trans`: The transformation map that defines the affine transformation to be 
+- `trans`: The transformation map that defines the affine transformation to be
 applied to the mesh.
 
 # Returns
 The transformed mesh `m` with updated vertices and normals.
 
 # Example
 ```jldoctest
+julia> import CoordinateTransformations as CT;
+
+julia> import PlantGeomPrimitives as PG;
+
 julia> m = Rectangle();
 
 julia> vec = Vec(1.0, 2.0, 3.0);
 
 julia> trans = CT.LinearMap(CT.SDiagonal(vec...));
 
-julia> transform!(m, trans);
+julia> PG.transform!(m, trans);
 ```
 """
 function transform!(m::Mesh, trans::CT.AbstractAffineMap)