capsule

.travis.yml

@@ -1,14 +1,12 @@
 language: julia
 os:
   - linux
-  - osx
 julia:
-  - 1.0
-  - nightly
+  - 1
+if: branch = master OR tag IS present OR type = pull_request
 
 notifications:
   email: false
-sudo: false
 
 jobs:
    include:
@@ -21,4 +19,4 @@ jobs:
        after_success: skip
 
 after_success:
-  - julia -e 'using Pkg; cd(Pkg.dir("GeometryTypes")); Pkg.add("Coverage"); using Coverage; Coveralls.submit(process_folder()); Codecov.submit(process_folder())'
+  - julia -e 'using Pkg; Pkg.add("Coverage"); using Coverage; Codecov.submit(process_folder())'

README.md

@@ -5,10 +5,15 @@
 [![Coverage Status](https://coveralls.io/repos/JuliaGeometry/GeometryTypes.jl/badge.svg)](https://coveralls.io/r/JuliaGeometry/GeometryTypes.jl)
 [![Documentation](https://img.shields.io/badge/docs-latest-blue.svg)](http://juliageometry.github.io/GeometryTypes.jl/latest/)
 
+# WARNING
+Package discontinued in favor of [GeometryBasics](https://github.com/JuliaGeometry/GeometryBasics.jl)
+
+
 Geometry primitives and operations building up on FixedSizeArrays.
 
 Documentation is available at http://juliageometry.github.io/GeometryTypes.jl/latest/.
 
+
 ## Installation
 
 Enter package mode in the Julia REPL and run the following command:

src/GeometryTypes.jl

@@ -50,6 +50,7 @@ include("polygon.jl")
 include("polygon_triangulations.jl")
 include("lines.jl")
 include("cylinder.jl")
+include("capsule.jl")
 
 export AABB,
        AbstractFlexibleGeometry,
@@ -64,6 +65,9 @@ export AABB,
        Cylinder,
        Cylinder2,
        Cylinder3,
+       Capsule,
+       Capsule2,
+       Capsule3,
        decompose,
        direction,
        eltype_or,

src/capsule.jl

@@ -0,0 +1,23 @@
+origin(c::Capsule{N, T}) where {N, T} = c.origin
+extremity(c::Capsule{N, T}) where {N, T} = c.extremity
+radius(c::Capsule{N, T}) where {N, T} = c.r
+height(c::Capsule{N, T}) where {N, T} = norm(c.extremity - c.origin)
+direction(c::Capsule{N, T}) where {N, T} = (c.extremity .- c.origin) ./ height(c)
+
+function rotation(c::Capsule{2, T}) where T
+    d2 = direction(c); u = @SVector [d2[1], d2[2], T(0)]
+    v = @MVector [u[2], -u[1], T(0)]
+    normalize!(v)
+    return hcat(v, u, @SVector T[0, 0, 1])
+end
+function rotation(c::Capsule{3, T}) where T
+    d3 = direction(c); u = @SVector [d3[1], d3[2], d3[3]]
+    if abs(u[1]) > 0 || abs(u[2]) > 0
+        v = @MVector [u[2], -u[1], T(0)]
+    else
+        v = @MVector [T(0), -u[3], u[2]]
+    end
+    normalize!(v)
+    w = @SVector [u[2] * v[3] - u[3] * v[2], -u[1] * v[3] + u[3] * v[1], u[1] * v[2] - u[2] * v[1]]
+    return hcat(v, w, u)
+end

src/decompose.jl

@@ -447,3 +447,73 @@ function decompose(::Type{FT}, c::Cylinder{3}, facets = 30) where FT <: Face
     end
     return indexes
 end
+
+
+isdecomposable(::Type{T}, ::Type{C}) where {T <:Point, C <:Capsule3} = true
+isdecomposable(::Type{T}, ::Type{C}) where {T <:Face, C <:Capsule3} = true
+isdecomposable(::Type{T}, ::Type{C}) where {T <:Point, C <:Capsule2} = true
+isdecomposable(::Type{T}, ::Type{C}) where {T <:Face, C <:Capsule2} = true
+
+# def of resolution + rotation
+function decompose(PT::Type{Point{3, T}}, c::Capsule{2}, resolution = 10) where T
+    origin = length(c.origin) == 2 ? Point{3, T}(c.origin[1], c.origin[2], 0) : c.origin
+    nbv = 2*max.(4, resolution)
+    M = rotation(c); h = height(c)
+    vertices = Vector{PT}(undef, 2 * (nbv + 1))
+    for i = 0:nbv
+        theta = T((π * i) / nbv)
+        vertices[i + 1] =       PT(M * Point{3, T}( cos(theta) * c.r,   - sin(theta) * c.r, 0)) + origin
+        vertices[i + nbv + 2] = PT(M * Point{3, T}(-cos(theta) * c.r, h + sin(theta) * c.r, 0)) + origin
+    end
+    return vertices
+end
+
+function decompose(PT::Type{Point{3, T}}, c::Capsule{3}, resolution = (30, 10)) where T
+    nbv = max.(4, resolution)
+    M = rotation(c); h = height(c)
+    position = 1; vertices = Vector{PT}(undef, nbv[1] * (2 * nbv[2]) + 2)
+    for j = 1:nbv[1]
+        phi = T((2π * (j - 1)) / nbv[1])
+        for i = 0:(nbv[2]-1)
+            theta = T((π/2 * i) / nbv[2])
+            vertices[position + i] =          PT(M * Point{3, T}(cos(theta) * cos(phi) * c.r, cos(theta) * sin(phi) * c.r,   - sin(theta) * c.r)) + PT(c.origin)
+            vertices[position + i + nbv[2]] = PT(M * Point{3, T}(cos(theta) * cos(phi) * c.r, cos(theta) * sin(phi) * c.r, h + sin(theta) * c.r)) + PT(c.origin)
+        end
+        position += nbv[2] * 2
+    end
+    vertices[end-1] = PT(c.origin) + PT(M * Point{3, T}(0, 0, -c.r))
+    vertices[end] = PT(c.extremity) + PT(M * Point{3, T}(0, 0, c.r))
+    return vertices
+end
+
+function decompose(::Type{FT}, c::Capsule{2}, facets = 10) where FT <: Face
+    nbv = 4*max.(4, facets)
+    indexes = Vector{FT}(undef, nbv)
+    for j = 1:nbv
+        indexes[j] = (1, j + 2, j + 1)
+    end
+    return indexes
+end
+
+function decompose(::Type{FT}, c::Capsule{3}, facets = (30, 10)) where FT <: Face
+    nbv = max.(4, facets)
+    indexes = Vector{FT}(undef, nbv[1] * (4 * (nbv[2]-1) + 4))
+    index = 1
+    slice = nbv[2] * 2
+    last = nbv[1] * (2 * nbv[2]) + 2
+    for j = 0:(nbv[1]-1)
+        j_next = (j+1) % nbv[1]
+        indexes[index+0] = (j_next * slice + nbv[2] + 1, j_next * slice + 1, j * slice + 1)
+        indexes[index+1] = (j * slice + nbv[2] + 1, j_next * slice + nbv[2] + 1, j * slice + 1)
+        indexes[index+2] = (j * slice + nbv[2], j_next * slice + nbv[2], last - 1)
+        indexes[index+3] = (j_next * slice + 2 * nbv[2], j * slice + 2 * nbv[2], last)
+        for i = 0:(nbv[2]-2)
+            indexes[index + 4 + i*4 + 0] = (j_next * slice + i + 1, j_next * slice + i + 2, j * slice + i + 1)
+            indexes[index + 4 + i*4 + 1] = (j_next * slice + i + 2, j * slice + i + 2, j * slice + i + 1)
+            indexes[index + 4 + i*4 + 2] = (j_next * slice + nbv[2] + i + 2, j_next * slice + nbv[2] + i + 1, j * slice + nbv[2] + i + 1)
+            indexes[index + 4 + i*4 + 3] = (j_next * slice + nbv[2] + i + 2, j * slice + nbv[2] + i + 1, j * slice + nbv[2] + i + 2)
+        end
+        index += 4 * (nbv[2]-1) + 4
+    end
+    return indexes
+end

src/typealias.jl

@@ -80,7 +80,12 @@ its extremity and a radius. `origin`, `extremity` and `r`, must be specified.
 const Cylinder2{T} = Cylinder{2, T}
 const Cylinder3{T} = Cylinder{3, T}
 
-
+"""
+A `Capsule2` or `Capsule3` is a 2D/3D capsule defined by its origin point,
+its extremity and a radius. `origin`, `extremity` and `r`, must be specified.
+"""
+const Capsule2{T} = Capsule{2, T}
+const Capsule3{T} = Capsule{3, T}
 
 const UV{T} = TextureCoordinate{2, T}
 const UVW{T} = TextureCoordinate{3, T}

src/types.jl

@@ -233,6 +233,16 @@ struct Cylinder{N,T<: AbstractFloat} <: GeometryPrimitive{N,T}
     r::T
 end
 
+"""
+A `Capsule` is a 2D line segment with a radius or a 3D Capsule defined by its origin point,
+its extremity and a radius. `origin`, `extremity` and `r`, must be specified.
+"""
+struct Capsule{N,T<: AbstractFloat} <: GeometryPrimitive{N,T}
+    origin::Point{N,T}
+    extremity::Point{N,T}
+    r::T
+end
+
 """
 AbstractConvexHull