Implement a cylinder primitive

[ufechner7]

For porting code from cgkit (Python) I need a cylinder primitive. My question is, which properties are needed. Length and radius are obvious, but perhaps more? See also:
http://cgkit.sourceforge.net/doc2/ccylindergeom.html

[edljk]

I tried to implement a naive 3D cylinder type (see below). But I am not sure of the best way to make it part of GeometryTypes.jl..

"""
A `Cylinder3` is a 3D cylinder defined by its origin point, its extremity
and a radius. `origin`, `extremity` and `r`, must be specified.
"""
immutable Cylinder3{T} <: GeometryPrimitive{3,T}
  origin::Point{3,T}
  extremity::Point{3,T}
  r::T
end

origin(c::Cylinder3) = c.origin
extremity(c::Cylinder3) = c.extremity
radius(c::Cylinder3) = c.r
height(c::Cylinder3) = norm(c.extremity-c.origin)
direction(c::Cylinder3) = (c.extremity .- c.origin)./height(c)
function rotation(c::Cylinder3)
  u = [direction(c)...];
  v = abs(u[1])>0 || abs(u[2])>0 ? [u[2],-u[1],0] : [0,-u[3],u[2]]
  v ./= norm(v)
  w = [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

isdecomposable{T<:Point, C<:Cylinder3}(::Type{T}, ::Type{C}) = true
isdecomposable{T<:Face, C<:Cylinder3}(::Type{T}, ::Type{C}) = true

function decompose{T}(PT::Type{Point{3,T}},c::Cylinder3{T},facets=12)
  isodd(facets) ? facets = 2*div(facets,2) : nothing
  facets<8 ? facets = 8 : nothing; nbv = Int(facets/2)
  M = rotation(c); h = height(c)
  position = 1; vertices = Array(PT,2*nbv)
  for j = 1:nbv
    phi                = T((2*pi*(j-1))/nbv)
    vertices[position] = PT([c.r*M*cos(phi);c.r*M*sin(phi);0])+PT(c.origin)
    vertices[position+1] = PT([c.r*M*cos(phi);c.r*M*sin(phi);h])+PT(c.origin)
    position += 2
  end
  vertices
end

function decompose{FT<:Face,T}(::Type{FT},c::Cylinder3{T},facets=12)
  isodd(facets) ? facets = 2*div(facets,2) : nothing
  facets<8 ? facets = 8 : nothing; nbv = Int(facets/2)
  indexes = Array(Face{3,Int,0},facets); index = 1
  for j = 1:(nbv-1)
    indexes[index] = (index,index+1,index+2)
    indexes[index+1] = (index+2,index+1,index+3)
    index += 2
  end
  indexes[index] = (index,index+1,1)
  indexes[index+1] = (1,index+1,2)
  indexes
end

[loicspace]

Yo,

@edljk That can work! I used your code and wrapped in a module. It is thus not part of GeometryTypes but can be used still.
Only change I had to make is in the decompose function for vertices[position] and vertices[position+1]: I took the rotation matrix from inside to vector expression to in front of the if for dimension consistency and so it applies to the third component as well.
(Oh and the code below is modified to make a cone instead of a cylinder by simply changing vertices[position+1] to (0,0,h) + origin)
Then the CodeMesh function is used as wrapper to generate a GLNormalMesh that can readily be sued as a primitive. Still a very rudimentary workaround using my limited skill set in that area...

module cone3

using GLVisualize, GLAbstraction
using FileIO, GeometryTypes, Reactive
export ConeMesh

"""
A `Cone3` is a 3D cylinder defined by its origin point, its extremity
and a radius. `origin`, `extremity` and `r`, must be specified.
"""
type Cone3{T} <: GeometryPrimitive{3,T}
  origin::Point{3,T}
  extremity::Point{3,T}
  r::T
end

origin(c::Cone3) = c.origin
extremity(c::Cone3) = c.extremity
radius(c::Cone3) = c.r
height(c::Cone3) = norm(c.extremity-c.origin)
direction(c::Cone3) = (c.extremity .- c.origin)./height(c)
function rotation(c::Cone3)
  u = [direction(c)...];
  v = abs(u[1])>0 || abs(u[2])>0 ? [u[2],-u[1],0] : [0,-u[3],u[2]]
  v ./= norm(v)
  w = [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

isdecomposable{T<:Point, C<:Cone3}(::Type{T}, ::Type{C}) = true
isdecomposable{T<:Face, C<:Cone3}(::Type{T}, ::Type{C}) = true

function decompose1{T}(PT::Type{Point{3,T}},c::Cone3{T},facets=12)
  isodd(facets) ? facets = 2*div(facets,2) : nothing
  facets<8 ? facets = 8 : nothing; nbv = Int(facets/2)
  M = rotation(c); h = height(c)
  position = 1; vertices = Array(PT,2*nbv)
  for j = 1:nbv
    phi                = T((2*pi*(j-1))/nbv)
    vertices[position] = PT(M*[c.r*cos(phi);c.r*sin(phi);0])+PT(c.origin)
    vertices[position+1] = PT([0;0;h])+PT(c.origin)
    position += 2
  end
  vertices
end

function decompose1{FT<:Face,T}(::Type{FT},c::Cone3{T},facets=12)
  isodd(facets) ? facets = 2*div(facets,2) : nothing
  facets<8 ? facets = 8 : nothing; nbv = Int(facets/2)
  indexes = Array(Face{3,Int,0},facets); index = 1
  for j = 1:(nbv-1)
    indexes[index] = (index,index+1,index+2)
    indexes[index+1] = (index+2,index+1,index+3)
    index += 2
  end
  indexes[index] = (index,index+1,1)
  indexes[index+1] = (1,index+1,2)
  indexes
end

function ConeMesh(orig, extr, rad, nfacets)

  obj = Cone3(orig, extr, rad)
  vert = decompose1(Point3f0, obj, nfacets)
  fac = decompose1(GLTriangle, obj, nfacets)
  fovMesh = GLNormalMesh(vertices=vert, faces=fac)

end


end #module

[SimonDanisch]

closed by #82