Merge pull request #18 from JuliaGeometry/sd/finish

Finish this up to work with everything

Author: SimonDanisch

.appveyor.yml

@@ -2,9 +2,8 @@
 language: julia
 os:
   - linux
-  - osx
 julia:
-  - 1.1
+  - 1.3
   - nightly
 matrix:
   allow_failures:

.travis.yml

@@ -4,15 +4,17 @@ authors = ["SimonDanisch <[email protected]>"]
 version = "0.1.3"
 
 [deps]
+IterTools = "c8e1da08-722c-5040-9ed9-7db0dc04731e"
+LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
 StaticArrays = "90137ffa-7385-5640-81b9-e52037218182"
 StructArrays = "09ab397b-f2b6-538f-b94a-2f83cf4a842a"
 Tables = "bd369af6-aec1-5ad0-b16a-f7cc5008161c"
 
 [compat]
-julia = "1.1"
-StructArrays = "0.3,0.4"
 StaticArrays = "0.12,0.1"
+StructArrays = "0.3,0.4"
 Tables = "0.2, 1"
+julia = "1.1"
 
 [extras]
 Query = "1a8c2f83-1ff3-5112-b086-8aa67b057ba1"

Project.toml

@@ -6,7 +6,7 @@
 
 # GeometryBasics.jl
 
-Basic Geometry Types. 
+Basic Geometry Types.
 This package aimes to offer a standard set of Geometry types, which easily work with metadata, query frameworks on geometries and different memory layouts.
 The aim is to create a solid basis for Graphics/Plotting, finite elements analysis, Geo applications, and general geometry manipulations - while offering a julian API, that still allows performant C-interop.
 
@@ -238,5 +238,3 @@ end
 
 end
 ```
-
-

README.md

@@ -1,12 +1,58 @@
 module GeometryBasics
 
-using StaticArrays, Tables, StructArrays
+    using StaticArrays, Tables, StructArrays, IterTools, LinearAlgebra
 
-using Base: @propagate_inbounds
+    using Base: @propagate_inbounds
 
-include("fixed_arrays.jl")
-include("basic_types.jl")
-include("metadata.jl")
-include("viewtypes.jl")
+    include("fixed_arrays.jl")
+    include("offsetintegers.jl")
+    include("basic_types.jl")
+    include("metadata.jl")
+    include("viewtypes.jl")
+    include("geometry_primitives.jl")
+    include("rectangles.jl")
+    include("triangulation.jl")
+    include("meshes.jl")
+    include("lines.jl")
+    include("boundingboxes.jl")
+
+    export AbstractGeometry, GeometryPrimitive
+    export Mat, Point, Vec
+    export LineFace, Polytope, Line, NgonFace, convert_simplex
+    export LineString, Polygon, MultiPoint, MultiLineString, MultiPolygon
+    export Simplex, connect, Triangle, NSimplex, Tetrahedron
+    export QuadFace, metafree, coordinates, TetrahedronFace
+    export TupleView, SimplexFace, Mesh, meta
+    export Triangle, TriangleP
+    export AbstractFace, TriangleFace, QuadFace, GLTriangleFace
+    export OffsetInteger, ZeroIndex, OneIndex, GLIndex
+    export FaceView, SimpleFaceView
+    export AbstractPoint, PointMeta, PointWithUV
+    export decompose, coordinates, faces, normals, decompose_uv, decompose_normals
+    export GLTriangleFace, GLNormalMesh3D, GLPlainTriangleMesh, GLUVMesh3D, GLUVNormalMesh3D
+    export AbstractMesh, Mesh, TriangleMesh
+    export GLNormalMesh2D, PlainTriangleMesh
+
+    # all the different predefined mesh types
+    # Note: meshes can contain arbitrary meta information,
+    export AbstractMesh, TriangleMesh, PlainMesh, GLPlainMesh, GLPlainMesh2D, GLPlainMesh3D
+    export UVMesh, GLUVMesh, GLUVMesh2D, GLUVMesh3D
+    export NormalMesh, GLNormalMesh, GLNormalMesh2D, GLNormalMesh3D
+    export NormalUVMesh, GLNormalUVMesh, GLNormalUVMesh2D, GLNormalUVMesh3D
+    export NormalUVWMesh, GLNormalUVWMesh, GLNormalUVWMesh2D, GLNormalUVWMesh3D
+
+    # mesh creation functions
+    export triangle_mesh, triangle_mesh, uv_mesh
+    export uv_mesh, normal_mesh, uv_normal_mesh
+
+    export height, origin, radius, width, widths, xwidth, yheight
+    export HyperSphere, Circle, Sphere
+    export Cylinder, Cylinder2, Cylinder3, Pyramid, extremity
+    export Rect, Rect2D, Rect3D, IRect, IRect2D, IRect3D, FRect, FRect2D, FRect3D
+    export before, during, isinside, isoutside, meets, overlaps, intersects, finishes
+    export centered, direction, area, update
+    export max_dist_dim, max_euclidean, max_euclideansq, min_dist_dim, min_euclidean
+    export min_euclideansq, minmax_dist_dim, minmax_euclidean, minmax_euclideansq
+    export self_intersections, split_intersections
 
 end # module

src/GeometryBasics.jl

@@ -1,7 +1,9 @@
 """
 Abstract Geometry in R{Dim} with Number type T
 """
-abstract type AbstractGeometry{Dim, T <: Real} end
+abstract type AbstractGeometry{Dim, T <: Number} end
+abstract type GeometryPrimitive{Dim, T} <: AbstractGeometry{Dim, T} end
+Base.ndims(x::AbstractGeometry{Dim}) where Dim = Dim
 
 """
 Geometry made of N connected points. Connected as one flat geometry, it makes a Ngon / Polygon.
@@ -18,32 +20,47 @@ abstract type AbstractNgonFace{N, T} <: AbstractFace{N, T} end
 
 abstract type AbstractSimplex{Dim, N, T} <: StaticVector{Dim, T} end
 
-@fixed_vector Point AbstractPoint
-
-
+"""
+    coordinates(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}`.
+"""
+function coordinates(points::AbstractVector{<:AbstractPoint})
+    return points
+end
 
+"""
+    faces(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}`.
+"""
+function faces(f::AbstractVector{<:AbstractFace})
+    return f
+end
 
 """
 Face index, connecting points to form a simplex
 """
 
 @fixed_vector SimplexFace AbstractSimplexFace
-const LineFace{T} = SimplexFace{2, T}
 const TetrahedronFace{T} = SimplexFace{4, T}
 Face(::Type{<: SimplexFace{N}}, ::Type{T}) where {N, T} = SimplexFace{N, T}
 
-
 """
 Face index, connecting points to form an Ngon
 """
 
 @fixed_vector NgonFace AbstractNgonFace
+const LineFace{T} = NgonFace{2, T}
 const TriangleFace{T} = NgonFace{3, T}
 const QuadFace{T} = NgonFace{4, T}
 
 Base.show(io::IO, x::TriangleFace{T}) where T = print(io, "TriangleFace(", join(x, ", "), ")")
 
 Face(::Type{<: NgonFace{N}}, ::Type{T}) where {N, T} = NgonFace{N, T}
+Face(F::Type{NgonFace{N, FT}}, ::Type{T}) where {FT, N, T} = F
 
 @propagate_inbounds Base.getindex(x::Polytope, i::Integer) = coordinates(x)[i]
 @propagate_inbounds Base.iterate(x::Polytope) = iterate(coordinates(x))
@@ -65,10 +82,11 @@ struct Ngon{
 
     points::SVector{N, Point}
 end
+
 const NNgon{N} = Ngon{Dim, T, N, P} where {Dim, T, P}
 
 function (::Type{<: NNgon{N}})(points::Vararg{P, N}) where {P <: AbstractPoint{Dim, T}, N} where {Dim, T}
-    Ngon{Dim, T, N, P}(SVector(points))
+    return Ngon{Dim, T, N, P}(SVector(points))
 end
 Base.show(io::IO, x::NNgon{N}) where N = print(io, "Ngon{$N}(", join(x, ", "), ")")
 
@@ -92,6 +110,10 @@ function Polytope(::Type{<: NNgon{N}}, P::Type{<: AbstractPoint{NDim, T}}) where
     Ngon{NDim, T, N, P}
 end
 
+
+const LineP{Dim, T, P <: AbstractPoint{Dim, T}} = Ngon{Dim, T, 2, P}
+const Line{Dim, T} = LineP{Dim, T, Point{Dim, T}}
+
 # Simplex{D, T, 3} & Ngon{D, T, 3} are both representing a triangle.
 # Since Ngon is supposed to be flat and a triangle is flat, lets prefer Ngon
 # for triangle:
@@ -130,8 +152,6 @@ struct Simplex{
 end
 
 const NSimplex{N} = Simplex{Dim, T, N, P} where {Dim, T, P}
-const LineP{Dim, T, P <: AbstractPoint{Dim, T}} = Simplex{Dim, T, 2, P}
-const Line{Dim, T} = LineP{Dim, T, Point{Dim, T}}
 const TetrahedronP{T, P <: AbstractPoint{3, T}} = Simplex{3, T, 4, P}
 const Tetrahedron{T} = TetrahedronP{T, Point{3, T}}
 
@@ -293,56 +313,72 @@ Base.getindex(ms::MultiLineString, i) = ms.linestrings[i]
 Base.size(ms::MultiLineString) = size(ms.linestrings)
 
 struct MultiPoint{
-    Dim, T <: Real,
-    Element <: AbstractPoint{Dim, T},
-    A <: AbstractVector{Element}
-} <: AbstractVector{Element}
+        Dim, T <: Real,
+        Element <: AbstractPoint{Dim, T},
+        A <: AbstractVector{Element}
+    } <: AbstractVector{Element}
 
     points::A
 end
 
 function MultiPoint(points::AbstractVector{P}; kw...) where P <: AbstractPoint{Dim, T} where {Dim, T}
-    MultiPoint(meta(points; kw...))
+    return MultiPoint(meta(points; kw...))
 end
 
 Base.getindex(mpt::MultiPoint, i) = mpt.points[i]
 Base.size(mpt::MultiPoint) = size(mpt.points)
 
+"""
+    AbstractMesh
+
+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
+"""
+const AbstractMesh{Element} = AbstractVector{Element}
+
+"""
+    Mesh <: AbstractVector{Element}
+The conrecte AbstractMesh implementation
+"""
 struct Mesh{
         Dim, T <: Real,
         Element <: Polytope{Dim, T},
         V <: AbstractVector{Element}
-    } <: AbstractVector{Element}
-
-    simplices::V
+    } <: AbstractMesh{Element}
+    simplices::V # usually a FaceView, to connect a set of points via a set of faces.
 end
 
-Tables.schema(fw::Mesh) = Tables.schema(getfield(fw, :simplices))
+Tables.schema(mesh::Mesh) = Tables.schema(getfield(mesh, :simplices))
+
+function Base.getproperty(mesh::Mesh, name::Symbol)
+    return getproperty(getfield(mesh, :simplices), name)
+end
 
-function Base.getproperty(x::Mesh, name::Symbol)
-    getproperty(getfield(x, :simplices), name)
+function Base.propertynames(mesh::Mesh)
+    return propertynames(getfield(mesh, :simplices))
 end
 
-function Base.summary(io::IO, x::Mesh{Dim, T, Element}) where {Dim, T, Element}
+function Base.summary(io::IO, ::Mesh{Dim, T, Element}) where {Dim, T, Element}
     print(io, "Mesh{$Dim, $T, ")
     summary(io, Element)
     print(io, "}")
 end
-Base.size(x::Mesh) = size(getfield(x, :simplices))
-Base.getindex(x::Mesh, i::Integer) = getfield(x, :simplices)[i]
 
+Base.size(mesh::Mesh) = size(getfield(mesh, :simplices))
+Base.getindex(mesh::Mesh, i::Integer) = getfield(mesh, :simplices)[i]
 
 function Mesh(elements::AbstractVector{<: Polytope{Dim, T}}) where {Dim, T}
-    Mesh{Dim, T, eltype(elements), typeof(elements)}(elements)
+    return Mesh{Dim, T, eltype(elements), typeof(elements)}(elements)
 end
 
 function Mesh(points::AbstractVector{<: AbstractPoint}, faces::AbstractVector{<: AbstractFace})
-    Mesh(connect(points, faces))
+    return Mesh(connect(points, faces))
 end
 
 function Mesh(
         points::AbstractVector{<: AbstractPoint}, faces::AbstractVector{<: Integer},
         facetype = TriangleFace, skip = 1
     )
-    Mesh(connect(points, connect(faces, facetype, skip)))
+    return Mesh(connect(points, connect(faces, facetype, skip)))
 end

src/basic_types.jl

@@ -0,0 +1,46 @@
+function Rect(geometry::AbstractArray{<: Point{N, T}}) where {N,T}
+    return Rect{N,T}(geometry)
+end
+
+"""
+Construct a HyperRectangle enclosing all points.
+"""
+function Rect{N1, T1}(geometry::AbstractArray{PT}) where {N1, T1, PT <: AbstractPoint}
+    N2, T2 = length(PT), eltype(PT)
+    @assert N1 >= N2
+    vmin = Point{N2, T2}(typemax(T2))
+    vmax = Point{N2, T2}(typemin(T2))
+    for p in geometry
+        vmin, vmax = minmax(p, vmin, vmax)
+    end
+    o = vmin
+    w = vmax - vmin
+    if N1 > N2
+        z = zero(Vec{N1 - N2, T1})
+        return Rect{N1, T1}(vcat(o, z), vcat(w, z))
+    else
+        return Rect{N1, T1}(o, w)
+   end
+end
+
+function Rect(primitive::GeometryPrimitive{N, T}) where {N, T}
+    Rect{N, T}(primitive)
+end
+
+function Rect{T}(primitive::GeometryPrimitive{N, T}) where {N, T}
+    Rect{N, T}(primitive)
+end
+
+function Rect{T}(a::Pyramid) where T
+    w,h = a.width / T(2), a.length
+    m = Vec{3,T}(a.middle)
+    Rect{T}(m .- Vec{3,T}(w,w,0), m .+ Vec{3,T}(w, w, h))
+end
+
+function Rect{T}(a::Sphere) where T
+    mini, maxi = extrema(a)
+    Rect{T}(mini, maxi .- mini)
+end
+
+Rect{T}(a) where T = Rect{T}(coordinates(a))
+Rect{N, T}(a) where {N, T} = Rect{N, T}(coordinates(a))