Hacking the Kinect with GAFFTA Day 3

OPEN FRAMEWORKS +
KINECT PART III

@GAFFTA

Thursday, March 14, 13

3D and Open Frameworks

Cameras

3D Math Classes

OpenGL Wrappers


Vector Classes

ofVec2f , ofVec3f , ofVec4f
align()
cross()
distance()
rotate()
perpendicular()
dot()

vectors are used to store dimensional data such as position, direction, length
( or magnitude )


Quaternion Classes

ofQuaternion

With 3D rotation becomes more complicated rotating in X ,Y , and Z in
different orders will result in different perceived rotations. Quaternions are
used to calculate “moves” between rotations for consistency.


Matrices Classes

ofMatrix3x3 , ofMatrix4x4
getRotate( )
getEuler( )
inverse( )
makeRotate( )

Matrices are often used to calculate 3d transformation data on a set of data
to move things between coordinate spaces. Luckily of wraps a lot of this
lower level functionality so these classes are more behind the scenes classes
until you want to get really low level.


3D Math

ofWrapDegrees()
ofRadToDeg( )
ofNoise( )
ofInsidePoly()
ofRandom( )

Open Frameworks does a really good job of wrapping simple math functions
that are often used when working with polygons angles and generative art


Cameras
Cameras is a great way to control how a 3D rendered scene looks. Cameras
are the “eyes” of the window. The camera position has a large effect on
rendered effects such as lights and shading.

*HTTP://WWW.OPENFRAMEWORKS.CC/DOCUMENTATION/3D/OFCAMERA.HTML

ofCamera - base camera class. Camera rendering is controlled similar to an ofFbo
with ofCamera::begin() and ofCamera::end( )

ofEasyCam - extends ofCamera and adds a little extra functionality including
mouse dragging functionality.


OpenGL
OpenGL is an API for interactive directly with the GPU which is much more adept at
handling parallel processing than the CPU. OpenGL is a very deep and extensive topic but
the basics are wrapped well in Open Frameworks

ofMesh - An ofMesh represents a set of vertices in 3D spaces, and normals at those points,
colors at those points, and texture coordinates at those points. Each of these different
properties is stored in a vector.Vertices are passed to your graphics card and your graphics
card ﬁll in the spaces in between them in a processing usually called the rendering pipeline.
The rendering pipeline goes more or less like this:

*HTTP://WWW.OPENFRAMEWORKS.CC/DOCUMENTATION/3D/OFMESH.HTML


OpenGL
ofNode - basic “3d” object class with position , rotation , and orientation. It also has some
hand functions like : lookAt( ) which orients an ofNode object to any other ofNode object

ofShader - shaders are small programs written in GLSL that allow for really intensive
rendering computation. They are often split into two parts : the Vertex shader which
works with vertices , and the Fragment shader which works with pixels. Shaders are a
very deep topic but OF makes it easy to :

load a shader from an external text ﬁle
pass any data into the shader
begin() and end() rendering.

ofTexture - allows pixel data to be rendered on 3d vertices

ofMaterial - contains properties for how textures are rendered such as shininess and color
along with specular color


Kinect Point Cloud
The kinect interprets the scene in 3D so it’s easy to work with the raw data. All you have
have to do in OF is add it to an ofMesh and point an ofCamera at it.


ofxKinect + ofxUI + Point Cloud


Splicing the Point Cloud


Masking a Fragment Shader


Cube Point Cloud


Apply Vertex + Fragment Shader


Hacking the Kinect with GAFFTA Day 3

More Related Content

What's hot (13)

Similar to Hacking the Kinect with GAFFTA Day 3 (20)

Recently uploaded (20)

Hacking the Kinect with GAFFTA Day 3