kendo kata tutorial - develop the 3d animation synthesiser
TRANSCRIPT
Hidetoshi Ochi
Registration number 100029968
2015
Kendo Kata tutorial - Develop the 3DAnimation Synthesiser
Supervised by Dr Rudy Lapeer
University of East Anglia
Faculty of Science
School of Computing Sciences
Abstract
In modern 3D computer graphics applications, skeletal character animation techniques
have been demanded to improve its reality particularity in the field of game and film
industries. However, those applications can be seen in more various field for instance
in educational and medical scenes. Although the techniques are spreading to more and
more area, the requirement for those applications have not changed: character animation
should be realistic and produce natural appearance in both graphical and dynamical. To
represent such a realistic animation, motion capture can be the way to obtain continuous
animations. However, employing those techniques could be challenge to understand and
apply to the applications. Therefore, this project main aim is producing a application
which join several form of animations to produce a set of sequence by employing some
theories for transition, also allows users to be interactive to the software. Particularly
the project focus on the martial art tutorial.
Acknowledgements
I would like to express my special thanks of gratitude to my supervisor Dr Rudy Lapeer
who gave me such a great opportunity to do this project as well as Zelimkhan Gerikhanov
who helped me in doing a lot of research and gave me so many new theories, I am really
thankful to them. The project experience was the most attractive in my whole academic
life.
CMPC3P2Y
Contents
1 Introduction 7
1.1 Aims and Objective . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
1.2 Structure . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
2 Background 9
2.1 Model-View-Controller . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2.2 Kendo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2.3 Theory reviews . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
2.3.1 Character animation . . . . . . . . . . . . . . . . . . . . . . . 10
2.3.2 Quaternions . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
2.3.3 Interpolation . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
2.3.4 Skeletal animation . . . . . . . . . . . . . . . . . . . . . . . . 14
2.3.5 MD5 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
2.4 Related works . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
2.4.1 Parametrising Blends . . . . . . . . . . . . . . . . . . . . . . . 16
2.4.2 Motion Graph . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
2.4.3 Footprint-driven animation authoring . . . . . . . . . . . . . . 17
3 Implementation 19
3.1 Motion production . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
3.1.1 EVaRT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
3.1.2 Modelling . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
3.1.3 MotionBuilder . . . . . . . . . . . . . . . . . . . . . . . . . . 26
3.1.4 Export MD5 . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
3.2 Programming . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
3.2.1 Frameworks . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
3.2.2 GUI . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
3.2.3 Engine . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
4 Outcome and evaluation 38
4.1 Limitation and Improvement . . . . . . . . . . . . . . . . . . . . . . . 39
Reg: 100029968 iii
CMPC3P2Y
List of Figures
1 SLEARP and LERP in 2D representaion . . . . . . . . . . . . . . . . . 13
2 Square Calibration . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
3 Wand Calibration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
4 Model Edit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
5 Skeleton . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
6 Paint weights . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
7 Aligned actor and T pose motion . . . . . . . . . . . . . . . . . . . . . 27
8 Characterise . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
9 Mismatching . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
10 Modify animation by control Rig . . . . . . . . . . . . . . . . . . . . . 29
11 Eliminating forward and backward movement . . . . . . . . . . . . . . 30
12 Vertices confusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
13 Youtube user interface . . . . . . . . . . . . . . . . . . . . . . . . . . 34
14 User Interface Design . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
15 Time-line structer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
16 Sliding problem . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
17 UML class diagram . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
Reg: 100029968 v
CMPC3P2Y
List of Tables
1 User Manual . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
2 Assigned keys . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
Reg: 100029968 vi
CMPC3P2Y
1 Introduction
The main aim of the project is creating a tutorial like the professionals level, by syn-
thesising variations of animations to produce educational martial arts tutorial software.
Particularly, it should allow a user to choose a point of view: since there are many sim-
ilar tutorials on the Internet as a form of video, and generally they are of course much
realistic than 3D animations, however, the difference might be controllability for users.
For instance viewer might be able to learn the basics of some of the motion through the
tutorial video by playing round seekbar, however viewers are not able to observe the
tutorial from the different point of view: the camera is static and it is not dynamically
controllable. The viewers might be able to ask video producers to film some specific
motions to investigate more detail to master the motions. However, it is more possible
to be time consuming and costly.
Therefore, producing a software using computer graphics could solve the those issues.
Synthesising the animations refers that subdivided short period of motions form some
sequence should be able to set in any order to re-construct the sequence. Moreover, since
the scene is represented using computer graphics the users are able to edit the angle of
the camera for instance from the top of the character which is difficult to achieve in
real world. However, synthesising exclusive motions without coherence could be huge
objection to achieve, in terms of keeping the realistic and improving seamlessness.
The project covers several areas. The task of synthesiser development involved pro-
gramming and software development techniques. Yet some stages require several dis-
tinct applications, such as Autodesk 3DS Max and Autodesk MotionBuilder in mod-
eling 3D models and motions. Moreover capturing, editing and managing animations
involved working in motion capture laboratory; EVaRT, which handles animation pro-
duction, was mainly used in there. The practice of the project can help to obtain the
knowledge regarding not only software development, but also practical animation pro-
duction. This experience could be used in several fields, for instance game, film or any
other entertainment industry, education and communication. Particularly educational,
since the project involves traditional martial arts, it could help to diffuse certain anima-
tions to the world and to reserve techniques, which might be in danger of extinction, as
a digital format for the future.
Reg: 100029968 7
CMPC3P2Y
1.1 Aims and Objective
The main aim is as mentioned above: creating a synthesising application to synthesis
multiple motions in realistically and seamlessly with user’s controllability. Therefore,
objectives will be:
Must
• Create a sequence of motions from the exclusive motions.
• A user must able to control camera or choose a position.
Should
• The transition of different animations should be seamless and realistic.
• A user should be able to construct his own set of motion by adding motions to
time-line.
• A time-line should be able to control to observe specific keyframe.
Could
• A user could obtain the detail of the motion for learning uses.
Won’t
• Real-time capturing will not be supported due to lack of time of development.
1.2 Structure
This report contains several section to discover how the project have implemented. In
the Background section will state the capturing target, some of the relevant literature,
and related projects. Theory reviews are mostly related to a character animations for in-
stance the skeletal animation basis and quaternions for storing rotation. Related projects
are focused on existing animation synthesise projects. Then next section will express
how this project has implemented from the two aspects: producing animations and pro-
gramming the application. Following section is going to evaluate the application if the
desired result has arisen and suggest some improvement for further research.
Reg: 100029968 8
CMPC3P2Y
2 Background
This section will cover fundamental principles of the project. For instance the program
design concept, the capturing target, several theories which will be involved in Imple-
mentation section and also given research of related projects especially synthesising
animations.
2.1 Model-View-Controller
A concept of Model-View-Controller(MVC) has introduced by Reenskaug (1979). The
MVC paradigm assigns objects in the software one of three roles: model, view, con-
troller.
• Model represents data or even activity. In this project model refers to the data of
3D character models, animations and its constructing OpenGL code. The model
does not depend on the controller or the view.
• View visualises the state of the model and sends user action to the controller.
• Controller offers facilities to change the state of the model. For instance, con-
troller provides tools to trigger appropriate change to the model and make the
view to display the updated state based on the user input
This concept can reduce unnecessary dependences, thus the codes will be less errors
and easier to maintain; the model is encapsulated so that is to say model classes have
become reusable without modification. Therefore we are going to borrow the concept
of MVC to increase the flexibility of the application.
2.2 Kendo
Kendo is a Japanese martial art which trains the mind and body and cultivates one’s
character through one-to-one combat using a bamboo sword while wearing traditional
clothing and protective equipment. In addition to that, kendo have some several se-
quences or forms of movement, which is known as Kata. Many martial arts have its
kata. As Miller (2011) statement from his book, Drills:
Reg: 100029968 9
CMPC3P2Y
Fighting is inherently conservative and this shows in martial arts. Fighting
is dangerous. People get hurt and killed. For everything that might work
there are a hundred things that seem like a good idea that can lead to a
messy death. We have kata and tradition NOT because people are stuck in
tradition but because when people consistently survived it was considered
imperative to remember how to model it.
Therefore, remembering kata could be one of the really important factor of learning
Kendo kata includes Uchitachi, who attacks first as a pupil, and Shitachi, who counter-
attacks as a teacher. Yet the main purposes of the kata is discussed above, there is one
more important factor which is the kendo kata is used to pass the kendo dan (rank) exam.
Hakudo (2013) claims that the techniques of simply flight is widely spread, however,
the importance of kata and its techniques seems underestimated. Therefore, the project
could help to learn kata and it might improve understanding of hidden aspect of the
martial art to learners.
2.3 Theory reviews
2.3.1 Character animation
According to B.J.H. van Basten (2010), generation human animation can be classified
into three classes and each having its own advantages and disadvantages. The first ap-
proaches is procedural; which create its movement from scratch by using algorithms
based on empirical and biomechanical concepts. The one of pros of the technique is
really useful for controllability. However, this type of animations are generally not
perceived as realistic. Second technique is physics-based; generate locomotion using
dynamics and physical properties of the body. This type of animations tend to more
realistic by applying realistic torques on the joints, yet it provides less control than pre-
vious techniques and it could be computationally expensive. Last but not least class
is example-based approaches; reuse existing motions to generate a clip of movement.
Moreover, B.J.H. van Basten (2010) mentioned that the example-based can be subdi-
vided into two main approaches: motion concatenation and motion parametrization.
The former stitch clips of motions together to generate and usually it yields more natu-
Reg: 100029968 10
CMPC3P2Y
ral animation. On the other hand, motion parametrization approach interpolate between
existing motions to generate motions corresponding to specific parameters and it offers
higher level of control than another.
2.3.2 Quaternions
Quaternions compose a set of four numbers that are used to represent rotation. There
are two components in each quaternions: first part is a vector component which consists
of three values x, y and z, and a scaler value which is usually represented as w. The
scaler value represent the angle of rotation in the form cos(angle/2).
There are several reasons that quaternions should be used in the project to rotate
characters:
1. Quaternions are not susceptible to gimbal lock, a phenomenon in which an object
loses the ability to rotate on one of its three axis. Gimbal lock shows its face when
tow axes point in the same direction. This causes all sorts of problems.
2. They have the ability to have smooth, interpolated rotation. It is much easier to
interpolate rotations using quaternions rather than matrices, resulting in smoother
animations.
3. They take less room than a rotation matrix, and some operations are cheaper to
perform on quaternions in terms of processor cycles.
Pipho (2003) mentions quaternions can be treated simply as four-dimentional vectors
for the purpose of addition, subtraction, and scaler multiplication.
q =[4 3 2 1
]p =
[9 8 7 6
]q+ p =
[13 11 9 7
]3q =
[12 9 6 1
]Importantly, the quaternion does not represent a rotation quaternion, unless it is a unit
quaternion; it is the same as a unit vector. The unit quaternion has a magnitude of the
vector, and unless it has a magnitude of one it does not represent a rotation.
Reg: 100029968 11
CMPC3P2Y
Multiplying two quaternions together has the same output as multiplying correspond-
ing rotation matrices, however it is computationally less. The multiplication for quater-
nion is shown in below. (· refers to the dot product, × refers to the cross product)
p = [m,u] q = [n,v]
qp = [mn− v ·u,nu+mx+(v×u)]
Moreover, quaternions can ve rotate vectors or other quaternions. The formula below
can be used for both rotating quaternions and rotation vectors by other quaternions. (p
can be a quaternion or a vector)
p′ = q(p)(∼ q)
Although discussed above, quaternions can be used for representing a rotation, how-
ever, it is not always feasible to specify a quaternion directly. Therefore, quaternions
should be converted to rotation matrices or a set of Euler angles in terms of calculating
rotation with quaternion from the programmers point of view. Thus, quaternions have
mainly used in the project to representing rotation of 3D character.
2.3.3 Interpolation
As we discussed about quaternions above, it might be time to talk about interpolation.
Interpolation is very important when working with 3D models. For instance, there if
some projects contains some enemies who patrol and area, back and forth. The enemies
patrol along to the path, which is given from a start point to an end point and the time it
should take for the enemy to get from one to the other. Since only the start and end points
have been specified, the positions of the enemy at any given time might not be found
easily. Using interpolation, the position could calculate where the enemies should be, no
matter how much time has elapsed since they stared patrolling. Interpolation means that
estimation of an unknown quantity between two known quantities: the start point and
the end point. This can help produce smooth animation since it can produce an unlimited
number of midpoints, allowing the moves between point to be very small value and it
should be imperceptible to users. There are two main types of quaternion interpolation:
Reg: 100029968 12
CMPC3P2Y
linear interpolation (LEAP) which interpolates in a straight line, and spherical linear
interpolation (SLEARP) which interpolates in an arc on the other hand. Main difference
between two interpolations is SLERPed animation will stay at a constant speed however;
LEARPed animation will tend to speed up in the middle and slow down the ends and
starts. Moreover, SLERP generally generates a smoother animation. The figure[1]shows
a 2D represntation of what SLERP and LEARP do.
SLEARP interpolates along the arc of the circle, however LEARP goes straight line
from a start point to an end point.
Figure 1: SLEARP and LERP in 2D representaion
LEARP interpolates along a straight line, whereas SLEARP interpolates along arc of
the circle form a start point to an end point. The equation for linear interpolation of
quaternions can be written as:
LEARP(q, p, t) = t(p−q)+q
where q and p represents quaternions and using an interpolation vale of t which would
be between zero and one. On the other hand spherical linear interpolation takes shortest
route from start point to the end point. The formula for SLEARP is shown below.
Reg: 100029968 13
CMPC3P2Y
SLEARP(q, p, t) =q∗ sin(θ(1− t))+ p∗ sin(θ t)
sin(θ)
2.3.4 Skeletal animation
As Pipho (2003) mentioned that in almost any new modern 3D game engines use skele-
tal animation system. According to Pipho (2003), one of the first popular games, which
used skeletal animation, was Half-Life. Skeletal animation is the use of ’bones’ to ani-
mate a model rather than editing and moving each vertex or face manually. Each vertex
is attached to a bone or in some cases multiple bones, A bone or joint is simply a control
point for a group of vertices. These are similar in concept to joints in our own bodies,
such as knee or wrist joint. When you move up right wrist, the position of right elbow
also moves: when the bone moves, every vertex attached to it moves as well, This helps
the model movement appropriately, since movement from some part of body affects
other parts of the body as mentioned above. Skeletal animation has many advantages
over the traditional vertex animation as Pipho (2003) mentioned. Firstly, it can increase
realism: skeletally animated characters tend to move much more realistically and often
appear to interact better with their surroundings than traditional models. If traditional
key-frame animation is used, the game will linearly interpolate between two poses, that
is to say however, in this case the joints do not actually rotate which can be problem
because living organism move in rotational ways. Secondly, skeletal animation take up
less storage space; rather than storing a set of vertices for each frame, all that needs to
be stored is the translation and rotation of the bones. On the other hand, there is dis-
advantages such as, the concept of skeletal animation can be harder to understand and
implement, than keyframed animation. When skeletal animation is applied, the vertices
of meshes from 3D character needs to be attached to the hierarchical bones with calcu-
lated weight. The weight represents how many vertices for the bone and how do they
affect their position and orientation by another bones movement. The skinning detail
will be discussed in the implementation section.
Pejsa and Pandzic (2010) have summarised when the skeletal animation is used, the
skeleton are hierarchically constructed with bones and joints. Joins stores transforma-
tion and the parameters which constructed with a 3D vector for the position and Euler
Reg: 100029968 14
CMPC3P2Y
angles or quaternion to represent the rotation of the joint.
2.3.5 MD5
As the importance of quaternions has discussed above, it might be time to talk about 3D
model format for the project. We have used MD5 model format which comes from first
person shooter game known as Doom 3 (2004). The format stores the mesh data and an-
imation data individually in separated files, and they are human readable as ASCII files.
David (2005) mentions that model’s geometric data are stored in *.md5mesh files and
animations are stored in *.md5anim files. The key features of the format are it supports
skeletal animation and orientation are calculated by quaternions. The .md5mesh files
stores geometric data of the 3D character. It should support one or multiple meshes and
.md5anim store information about skeletal animation of MD5 models David (2005).
David (2005) has produced a MD5 viewer application which handle both MD5 mesh
and its animations and the project can be download from his website as it is MIT licensed
and presented for educational uses. His framework contains over five classes which
represents MD5 model and the detail of classes are:
• Md5Object
It stores all the Md5Model. This class covers all information of meshes and ani-
mations loaded.
• Md5Model
Each Md5Model has a list of Md5Mesh and a list of Md5Animations.
• Md5Mesh
Md5Mesh class stores geometric data of the meshes. Each mesh have its proper
data, such as a shader name, vertex weight, triangle and vertices.
• Md5Animations and Md5Skelton
Skeleton hierarchy for each joint for motion, a bounding box for each keyframe of
animation, and a list of frames data are stored in this class. It contains Md5Skeleton
object which represents the baseframe skeletal hierarchy data and these data will
Reg: 100029968 15
CMPC3P2Y
be computed by Md5Animations class to produce the appropriate positions and
orientation of skeleton for the keyframe by using the list of frames data.
The main disadvantage of the application is that does not support applying multiple
animations seamlessly. Therefore we decided implement time-line features to achieve
creating the sequence of kata which is going to be mentioned in later section.
2.4 Related works
2.4.1 Parametrising Blends
Parametrised blending of captured examples techniques have been pioneered by Charles Rose
and F.Cohen (1998), which are known as verbs and adverbs system. Rose and his group
proposed a fundamental that allows interpolate between similar motions of verb and ad-
verbs. For instance, the verbs motion contains run and jump and the adverbs contains
happy and sadly which affect the verb actions. The basic of actions were dynamically
stored in data structure for seamless transitioning; the transition was constructed by
applying a radial basis technique and scaling some of the animation frames in terms of
time. This work has assumed that the example motions have been identified and cropped
from the original data set.
2.4.2 Motion Graph
Motion capture is a technique to seamlessly connect a motion in database using a tran-
sition. During the process, a graph structure will be produced which is called motion
graph. In the graph, edges correspond to motion clips and nodes represent as points that
connect to the clip. This technique is inspired by the video texture, which is used to
maintain the original motion sequences and pay back in non repetitive streams. Motion
capture is often used in real-time application and off-line sketch-cased motion synthesis
to produce character’s animation. One of the most influential work has been published
by Lucas Kovar (2002). In the paper, there are three research work that marked as the
original motion graph in the history of computer graphics. These three approached are
proposed by Arikan and Forsyth (2002) and Lee (2002). Those approaches share the
Reg: 100029968 16
CMPC3P2Y
same basic thought that is developed a graph from motion database and examine the
graph to generate a transition, although they have used different techniques in some
cases, such as generating transition, determining the distance metrics through the graph.
For instance Arikan and Forsyth (2002) mentioned using a hierarchy of motion graphs
for searching randomly of motions with required features; motion duration.
Motion graph technique divide motions into several groups by similarity of behaviour,
and then use the groups to create interpolation and smooth transition. Kwon and Shin
(2005) has implemented semi-automated motion graph system for locomotion. Treuille
and Z.Popovi (2007) employed simplified graph structure to create real-time animation,
they divide animation into short clips and arrange them into nodes in graph and blend
them to generate locomotion in real-time. They have borrowed a low dimensional basic
representation to guide the virtual character to the given goal. The goal is drawn a sketch
of a path, and acting our a desired motion in front of the video camera.
Pejsa and Pandzic (2010) have done further research of parametric motion, especially
focuses on the example-based animation synthesising. They introduce a solution for
continuous motions by searching the most similar motions to be blended. However, the
produced sequence of motion might have some artefacts and be unsuitable because of
searching appropriate animations in the motion graph is computationally expensive.
2.4.3 Footprint-driven animation authoring
3D characters constantly move through highly constrained virtual environment in mod-
ern games. Particularly if the character walks in indoor environment, there might be
tables and chair in narrow corridors, and the it is crucial that there are no collisions
between the character and walls or furniture. In such case, a path-based locomotion
locomotion is not sophisticated enough because if the character collied the objects, an-
other motions need to be taken such as sidestepping or backward. B.J.H. van Basten
(2010) claim synthesise locomotion based on the actual placement of footsteps in the
environment, and this sort of problem is known as stone stepping. The popular strat-
egy is that provide user to author the character behaviours.Shawn Singh and Faloutsos
(2011) have create the application which takes the Center-Of-Mass, which refers to the
unique point ere the weighted relative position of the distributed mass sums to zero, tra-
Reg: 100029968 17
CMPC3P2Y
jectory and footprints locations as input then it produces an efficient strategy to calculate
the minimised energy expenditure duration for each footsteps. B.J.H. van Basten (2010)
also look into the strategy that, they have used an efficient nearest neighbour approach
and warp the resulting animation; it adheres to both temporal constraints and spatial,
which are generated by employing time warping and Inverse Kinematics techniques.
Reg: 100029968 18
CMPC3P2Y
3 Implementation
This section will explain how the project has been implemented. First part expresses
how we have produced the MD5 models and second part shows how the project has
been designed and implemented.
3.1 Motion production
3.1.1 EVaRT
Eagle Star Optical Motion Capture system was the hardware made available to this
project to capture motions. To obtain the data, EVaRT soft ware was used in conjunction
with the hardware.
• Calibration
This session will provide an overview of how to calibrate the MoCap system
using the software called EVaRT. The software was used in conjunction with the
aforementioned hardware.
There were a number of issues and complications occurred during the process
which will be discussed in this section later. The system uses 2 phase of calibra-
tion. The first stage is to define the system co-ordinate mapping scale with using
square frame which contains four markers on it. While the square calibration is
operating, other than four makers, reflective objects must not appear in camera
coverage area. In addition to that, during the process, since the square frame
needed to be placed at a defined distance above ground level, the frame was sat
on the chair. However, as the picture below [2]shows the material of the char ap-
pears as reflective objects therefore, unexpectedly some of unknown markers had
appeared in some cameras.
Reg: 100029968 19
CMPC3P2Y
Square calibration, some cameras are capturing unexpected marker.
Figure 2: Square Calibration
Second stage of the calibration used T posed wand tool. Similar to the previous
sequence, wand had three markers at pre-set distance. The purpose for this stage
of calibration is to determine the capture volume area scale.
Wand calibration and its result.
Figure 3: Wand Calibration
The figure above [3] shows that after the wand sequence completes and the ok
button was clicked in the frame report box, the wand processing status box ap-
Reg: 100029968 20
CMPC3P2Y
pears. Ideally the calibration should have between +/-0.5 deviation values and the
average of 3D residuals should have been less than at least 0.35. Otherwise the
amount of post process would be increased terribly. A number of trials with dif-
ferent configurations and camera setting is critical for satisfactory results. Once
the calibration has done, actual capture stage will be followed. However, since
the camera settings are really sensitive in terms of oscillation, it was worth to cap-
ture without vehement movements: if the actor jumps and the camera and tripod
moves even slightly due to the oscillation, the calibration would break down.
• Capturing
Actor wears costume with a number of makers to capture its set of motions. Fol-
lowing 3D modelling conversations, the first capture must be that of a T pose since
the pose will be used to assign maker names in the model edit stage. In terms of
length of each motion should be less than 10 seconds otherwise the possibility of
losing some data could be hugely increased.
• Post processing
The large amount of time has spent on this stage. Although the satisfactory result
of the calibration helps to reduce the time to spend, some errors such as miss-
ing data, scattering data and ghost makers tend to be happened. To check if the
specific maker data has been preserved properly, we needed to go through from
the beginning to at the end of motion, or specified area which might be used for.
When the data has been perfectly captured, the XYZ graph shows smooth curves
or lines, however, there were likely a break in the data signal of the selected
marker. The break of the signal could be completely missed or confused by the
system during capturing. If the data of marker in the break was missed the maker
would be disappear from 3D view, yet if the data was just confused to other mak-
ers data, the maker would stay in the view. In such case, by selecting the other
maker that has replaced the marker previously in place, the graph data show a
section of track that should be in the track of the marker. To replace, the switched
data need to be selected and choose the markers then exchanged the selected range
of data. After the process, missing data should be back to the marker signal and
Reg: 100029968 21
CMPC3P2Y
then we need to join the broken signal either Linear join or Cubic join depending
on the situation. Edit tools panel provides copy and past functions which reduce
the amount of time to do the interchanging. Moreover, there were still some other
case: the data of the marker was scattered. If the marker’s data was fragmented,
the data was collected from several undefined markers to reconstruct the broken
part of the signal. One of the collected data was sometimes just a dot. Although
the amount of data was very little from with the dot, we could join the signal
because of the dot which located in the middle of the break relayed two signals.
• Model editing
Before exporting the MoCap data, the makers have to be named which can be
done by selecting a model edit panel in EVaRT. The names have been chosen ac-
cording to the body parts such as Elbow_R, refers to elbow right and Katana_Middle
refers to the middle marker of Katana (sword) as shown in picture below. Despite
the fact that the names can be anything, all the capture data should share the exact
same names and number of markers. Otherwise the markers will be confused and
will ruin the position of maker, because MotionBuilder automatically recognise
the assigned marker’s name, when T pause data has loaded and added as default
setting to a actor which is going to be discussed later in this report.
Two makers represent the sword as Katana_middle and Katana_Top. Since, al-
though several numbers have been used to trial such as between one to six marks,
after some trial, we have found that the movement of the sword can be represented
by at least two marks; they create a straight line between them and it store the ro-
tation of the sword. Adding names in the list first, then use quick-ID function to
assign the names by choosing appropriate maker. Another important feature of
model editing mode is linking, which represents connecting markers and they im-
prove visibility of assigning names. Then exporting the animation, which makers
have been named, as TRC format, Since it s ASCII text file and it is intelligible
by a human. While producing motions, we have realised that storing the data in
several stages reduce the actual work of capturing a lot. For instance in raw data;
before post processing, post processed data, and names are assigned data. When
Reg: 100029968 22
CMPC3P2Y
Twenty three names have been given as in right hand side. And Quick ID has se-
lected to assign the names to the certain marker.
Figure 4: Model Edit
some data has some problem which has arisen in after exporting the data which
names are assigned appropriately. However, some markers are not post processed
properly and although the signal looks fixed, the signal is mixed up and confused
with several markers. In such case, we needed to do the process from the begin-
ning, and we would have spent large amount of time to calibrate again and again
if the data has been overwritten after model edited.
3.1.2 Modelling
As the kendo kata need two character, we have planned to creates two 3D character to
represent each role for the sequence. Since the skeletal animation technique is used,
applying several 3D model refers to change the mesh of the character only; not altering
entire mesh and animation, as long as same conventional skeleton is used they can be
reused by several 3D characters.
• skeleton
Reg: 100029968 23
CMPC3P2Y
Since this project has employed skeletal animation, the 3D character need to have
a skeleton. The skeleton was one of the template skeleton from a software called
MotionBuilder. Since the template skeleton was used, we could able to charac-
terise the 3D model data easily. However, the skeleton does not contain hip joint
as default, therefore, an extra joint needs to be created to keep the convention.
The template skeleton from MotionBuilder which contains conventional names of
joints.
Figure 5: Skeleton
A OBJ file of model and the skeleton have different size and pose, the skeleton
needs to be aligned in terms of rotating joints and scaling to fitting into static OBJ
model character as closely as possible.
• Skinning Once the skeleton was aligned correctly to the static model the mesh
of the model need to be assigned to the skeleton which is known as skinning.
This could be done in the function of 3DS Max. Select the mesh which you
would like to perform and choose ’skins’ in the modifier panel, then the all the
bones of the skeleton needed to be chosen. When the initial skinning has done,
we should check the quality of the process; determine if the weight of bones and
Reg: 100029968 24
CMPC3P2Y
joins were correctly assigned or not. To check this, try to rotate each limbs, and if
the weight of the bone was wrong undesirable vertices of the mesh also affected.
For instance, when the right thigh bone was rotated to outside of the body based
on the hip joints, only the right leg of mesh should be affected, however, due to
the initial pose of the model stands upright with legs located closely, the other side
of the mesh also assigned to the right thigh bone and if the bone moves the mesh
also affected. Therefore, we had to modify the weight of each bones by painting
weight tool. The red dot on the vertex indicates strong dependency to the selected
bone, blue represents less dependency and the orange dot refers to blended. As
the picture shows the right thigh bone affects some of the vertexes of the mesh
around the left thigh which we do not desire.
Although the right thigh bone is rotated some of the vertexes of left thigh are influ-
enced.
Figure 6: Paint weights
Reg: 100029968 25
CMPC3P2Y
3.1.3 MotionBuilder
To export the captured data into Md5 format, they have to be applied to a 3DS Max
Skeleton and the MotionBuilder was used to connect the skeleton and the animations.
Motion builder’s features are mainly controlling over the animations and baking the
capture data into the skeleton. This session will discuss about processes.
• Activate Actor
First of all, maker data of motion needed to be imported into a new MotionBuilder
scene. Ideally the first data should perform standing in a T pose in terms of
mapping maker’s position to an actor. To create the actor drag an actor icon
from characters folder in the asset browser and drop it to main window. Then the
actor needed to be fitted to the maker cloud as closely as possible by scaling the
actor uniformly. Scale and rotate each of the actor limbs to match the performers
limbs using the makers as a guide. When aligning the arms, we did not lift their
shoulders slightly when their arms into a T pose, but rotate the collar segments
instead. After aligning the actor it is time to assign markers to the actor. Firstly
maker set needed to be created and then makers were dragged into the appropriate
actor’s body cells. The two makers for the sword were assigned in right hand.
Secondly, if all the makers were filled into the cells click active to activate the
mapping. If the alignment was not sufficient the actor will be messed up his
limbs. To check the quality of the mapping, we scrubbed along the time line to
see how well the marker data were assigned to the actor.
The picture above shows that the actor was aligned successfully and activated.
• Import 3D model with skeleton
After activate the actor, the 3D character model which includes the skeleton was
imported to the MotionBuilder scene. The skeleton joints were needed according
to the MotionBuilder joint naming convention, therefore, we could simply drag
character asset onto the skeleton in the 3D model to characterise. if any of the
required joints are missing from the skeleton or named incorrectly, ’Character
Definition Error’ was occurred. If not we decided to used a skeleton which joints
were conventionally named, we had to do manual character mapping to achieve
Reg: 100029968 26
CMPC3P2Y
An actor is aligned to maker data and activated.
Figure 7: Aligned actor and T pose motion
characterise the 3D model which is much more complicated than the simply drag
the character icon onto the skeleton. The picture below [8] expresses the dragging
the icon onto the skeleton to get characterised.
An actor is aligned to maker data and activated.
Figure 8: Characterise
Reg: 100029968 27
CMPC3P2Y
• Active input and plot animation
When the 3D models are characterised we can active the character by several
options, such as the actor input or control rig input. Firstly we tried to active the
actor input which perform quite well for T pose, however other animations tend to
get confused especially for arms. A potential reason why the vertices have been
get confused is the rotation data of sword are assigned in right hand, therefore,
when aligning the actor, the hierarchical rotation for the right shoulder, elbow and
wrist have might not been aligned properly. Therefore, when the sword move up
the head, the hierarchical joints also get affected which perform poorly. Which is
expressed as picture [9]
Modify animation at the key-frame.
Figure 9: Mismatching
• Control Rig
To modify the confusion of the animation, MotionBuilder has a function which is
called control rig. We can edit the each joints of position and rotation for desired
keyframe by applying control rig. When the joints are modified correctly, the
Reg: 100029968 28
CMPC3P2Y
modified skeleton information needs to save at the specific keyframe. Because of
the amount of modification with control rig was really large, we could not imple-
ment several character to choose; the same appearance of 3D character perform
both Uchitachi and Shitachi.
Modify animation at the key-frame.
Figure 10: Modify animation by control Rig
Moreover, the control rig could be applied to the motion to eliminate the loco-
motion for moving forward and backward to simplify the aspect of programming;
if the actual change of the location is eliminated, we could simply translate the
character to keep the movement. By elimination the actual locomotion of the
animation, the character appears for instance walking forward, but however the
actual coordinate of the character does not affect. As the picture below shows al-
though the actor moves forward, the character remains the same place as the start
Reg: 100029968 29
CMPC3P2Y
position. The elimination can be done by altering the position of the character to
the start potion at the end of the keyframe. Thus,even though the character tries
to move forward, the end position will be the same as the start position the loco-
motion is cancelled out. The figure [11] below shows the actor moves forward,
but the character remains at the start point.
Modify animation at the key-frame.
Figure 11: Eliminating forward and backward movement
After either activate the input from the actor or the control rig, the set of keyframes
needs to be plotted into the skeleton. Baking animation can be done by clicking plot an-
imation to the character button. These process needs to be done for each set of motions
except aligning the actor. Once the actor is aligned for T pose animation and activated it,
other animations can be simply merge to current scene, however, to bake each animation
to the skeleton needs to be done for each motion.
3.1.4 Export MD5
To export skinned model and its animated skeleton, we firstly open the 3DS Max file
which has a 3D scene of the character with the skeleton inside. Secondly import the
animation information which is baked to the 3D character skeleton in the previous sub-
section. When importing the file which is exported from the MotionBuilder, there is a
option that we are able to choose which motion to import and how those information
affect the current scene. Since there is already the 3D character in the scene, Update
scene elements needs to be chosen to update the current scene of the skeleton by the
Reg: 100029968 30
CMPC3P2Y
skeleton which includes the animations. The export format of MD5 is not built in the
3DS Max software, therefore we have borrowed a 3DS Max executable script which is
available at KatsBits (2015) website. The .md5mesh file needs to be exported only once
for the model and the .md5anim files have been exported respectively.
As mentioned in the background section the .md5mesh file should support the mul-
tiple mesh, therefore our initial 3D model is formed from number of meshes such as
leg, body, and the sward. However, probably the exporting script have some bugs for
.md5mesh file, when we have tried to implement the application, the vertices of the
model are got confused and messed up in figure[12]. Therefore we have decided to
merge the meshes into one mesh.
Vertices are got confused due to multiple meshes.
Figure 12: Vertices confusion
Reg: 100029968 31
CMPC3P2Y
3.2 Programming
The application is designed to users to be play the Kendo kata and show the tip for each
animation, and also user can change the point of view to help understanding of motions.
In addition to that, there is a another feature that users are able to create own set of kata
by synthesising several simpler animations into it. It is written by C++ and PpenGL to
display 3D environment and 2D user interface. There is a frameworks for this project
which is produced by Song (2010) which contains several classes to achieve the Model-
View-Controller(MVC) concept. The basic description of MVC is mentioned in the
Background section.
3.2.1 Frameworks
The frameworks of the project was presented by Song (2010) contains classes:
• Procedure and Controller class
Although Procedure is not the actual class, it detects user inputs and it triggers to
call some methods of the Controller class. For instance if user clicks left mouse
button in the application, Procedure detects left mouse button is pressed mes-
sage from Win32, then it calls lButtonDonw() method which updates ModelGL’s
mouse coordinates and left mouse button status.
• ControllerGL class
This class inherits from the Contoller class as you can see in class diagram. It have
methods which are overridden from the Contoller class and specified appropriate
reaction to the user input. Also it contains class pointers of ModelGL and ViewGL
to passing through user input to each class.
• ModelGL class
This class responses the application’s data such as detail of opengGL specific
code. It obtains pointers of GUI class and SceneModel class for instance MD5
model data. ModelGL handles rendering the scene by calling a method draw()
and the current scene data is stored in SceneModel and GUI separately. First
class SceneModel loads both .md5mesh and .md5anim data and it handle these
Reg: 100029968 32
CMPC3P2Y
data to represents the both 3D and 2D current scene. GUI class mainly draws the
elements of graphical user interface (GUI). All the texture of GUI are loaded from
PNG format pictures when the GUI class is created.
• ViewGL class
ViewGL handles to current rendering and device contexts. The swapBuffers()
method exchanges the front and back buffers of the display and it is triggered
if the draw() method in ModelGL is called throughout the ControllerGL class.
Those classes represent main frame of the application. In addition to that Camera
class is used for handling camera; the view point of the user. When the user desire
to change the camera point by pressing specified keyboard or selecting by the GUI,
Procedure detects the input then methods in the Camera class are called.
3.2.2 GUI
The main functions of the application is playing the sequence of kata to learn. Users
should be able to play the sequence forward, backward and change the speed of the
movement from the several point of view. Also they can move around the seek-bar to
observe the detail of the motion at the keyframe.
Not only to achieve the functionalities but also to improve the appearance of the scene,
we have decided to implement the GUI in the same frame as 3D scene; the GUI textures
are more likely to float in front of the characters. Although We thought subdivide the
frames such as top frame for 3D scene and bottom frame for 2D scene might be more
clear for users to use the application, separating the frames implies the main frame
might be smaller, and that might be difficult to observe characters. Therefore, the both
3D scene and 2D scene are rendered in the same frame and using maximum window
size. The concept has come from a website called Youtube. There are so many tutorial
videos on the website and people tend to search the tutorial video when they would like
to learn something new, such as playing musical instrument, dancing, and even learning
martial arts Youtube (2015). Therefore, people might be get used to the structure of
Reg: 100029968 33
CMPC3P2Y
the its GUI such as move round the seek-bar to find the desired seen. The picture [13]
represent inspired concept of the GUI design.
GUI from Youtube (2015).
Figure 13: Youtube user interface
In comparison, our application GUI is following[14]. Despite the fact that the appli-
cation has more buttons and might be giving more information than the Youtube GUI,
there should be some similarities between two: such as to try not be complicated to
improve the usability.
Although the frame of the GUI is not separated, it can be subdivided into three areas.
First area is the most important area of the GUI and it represents the time-line of the
sequence and the user can play the time-line by clicking buttons which arranged below
the time-line. These buttons refer to play forward or backward and pause. And also this
section contains the control bar for changing the speed of the animations which located
in the right hand side of the time-line. Playing and pausing can be done by both clicking
perspective button or pressing space bar in the keyboard. Second section is placed in the
top left corner. There are two bars: the above shows the current position of the camera
and the second bar can be clicked and the list of animations are shown which can be
added to the time-line. Last but not least the third area is located in the top right corner
which can be clicked to open some tips for the current animation from the time-line.
The summarise of the GUI usage is in the table [1]. And the list of assigned key are
following [2]
Reg: 100029968 34
CMPC3P2Y
User Interface Design of this project.
Figure 14: User Interface Design
Table 1: User Manual
Play foward Click play button by mouse or press space bar.
Play backward Click backward button.
Jump to the begin Click double arrowed button which pointing left.
Jump to the end Click double arrowed button which pointing right.
Change the seed Click the blue ball and scroll it up or down.
Pause Click pause button by mouse or press space bar.
Move seekBar Click the time keeper above the time-line.
Open Tip window Click tip button which located in the top right corner. Click again to close.
Open animation list Click the animation list tab which located in the top left corner.
Change the camera Press the associated keys to change the camera position.
Move the camera Press the associated keys to change the camera position.
Drop the animation Choose the animation name from the list, drag and drop it onto the time-line.
Delete the animation Right click on the unnecessary animation on the time-line.
Reg: 100029968 35
CMPC3P2Y
Table 2: Assigned keys
W Move forward the camera position.
S Move backward.
A Rotate right.
D Rotate left.
Z Ascent along y-axis.
X Descent along y-axis.
Q Slop right.
E Slop left
U Look upward.
I Look downward.
1 From the behind of the left character and looking at opponent position.
2 Side view of the left character.
3 Top view of the left character.
4 Look at left character from in front.
5 From the behind of the right character and looking at opponent position.
6 Side view of the right character.
7 Top view of the right character.
8 Look at right character from in front.
9 Reset the view as start point.
Reg: 100029968 36
CMPC3P2Y
3.2.3 Engine
The UML class diagram is included to provide to support the explanation of the appli-
cation’s engine. The framework for handling MD5 files is produced by David (2005)
perform perfectly to handle single animation, however it does not support synthesis-
ing animations. Therefore we have modified the framework to perform the time-line
feature to achieve synthesising function. Before talking about the modification of the
framework, lets discuss about the principal of the framework. The basic structure of the
MD5 has been mentioned in Background section. When .md5mesh files are loaded, the
information of the mesh are represented by Md5Mesh class which contains the list of
vertices, triangles, weights for each vertices and triangles and weights vectors. And also
.md5anim data are stored in the Md5Animation class. Then the list of Md5Mesh classes
objects are stored in Md5Model object which have validityCheck() method to check if
the mesh data and the animation contains same skeletal data and they are compatible or
not. Last but not least, those Md5Model objects and list of Md5Animation objects are
stored in Md5Object.
Because the project is focus on the kata tutorial, the character needs to be trans-
lated to correct position according to the time. Theses features are implemented by
adding two C++ Map class and the map structure represents the time-line. The first
Map object stores the begin time of the animation as a key and second elements repre-
sent Md5Animation object. And the second Map object contains the starting time of the
motion again, and second element represent the start position of the animation. As the
picture [15] shows two Map objects represents the time-line: information for animations
and the positions. The Map objects are stored in Md5Object.
The way to perform animation is done by calling animateFinal() method which takes
current time and calculates the vertices and rotations of animatedSkeleton corresponded
to the time. Then render() Simultaneously timeBetweenCurrNextAnims() method is
called to determine if current time either in side of frameα to frameβ or between the
animation to animation; when the current time is in blank in the time-line. Eventually
prepare() method is executed to does the interpolation. It method calls timeBetweenCur-
rNextAnims() to compute how much of the distance between current animation and nexr
animation in time-line has passed, and according to the result of from the method, appli-
Reg: 100029968 37
CMPC3P2Y
Time-line structure.
Figure 15: Time-line structer
cation determines if the current time is in the frame to frame or animation to animation.
When the circumstance is determined, the interpolate factor is calculated accordingly
the value of how much time has passed between the frames or animations. The posi-
tion of each joint for skeleton are interpolated by applying LEARP and their rotation
are SLERP interpolated. Animation to animation interpolation also follow the process,
but the interpolateAnimations() method uses the end frame of the previous animation
and begin frame of the next animation and interpolates. As stored in the second map
object; the character’s positions are also interpolated by similar approach. However the
difference is the position interpolation is done by only using LEARP.
4 Outcome and evaluation
According to our aims and objectives, the application has achieved some of the ob-
jectives, but not all of them. Skeletal character with applying MD5 format produces
seamless animation. It allows users to change the position of the camera by choosing
from the GUI or pressing keyboards to move round wherever the user desired and GUI
provide a satisfactory usability. Users can delete some unwanted animation. In terms
of the seamless, the SLEAP function interpolates the two exclusive animations nicely
Reg: 100029968 38
CMPC3P2Y
in general. The speed of sequence can be modified from as fast as twice to as slow as
half of original speed. In addition to that, it allows to reconstruct the sequence for the
character in the left hand side by adding animations from the list of animation. The
kendo kata contains two characters and they updates their time-line perspectively, and
for the default, those two sequence synchronised quite attractively as a tutorial applica-
tion. And also users can obtain the tips of the current playing animation for learning
purpose. Although, if the user reconstruct the sequence of the kata another character’s
sequence does not synchronised at all, the project has focused on providing educational
tutorial of martial arts, therefore, the project could have achieved the main functionality.
However there are also many limitations for the application. Following subsections will
argue the limitations and potential improvement of the application.
On the other aspect, the project provided great opportunity to learn a lot of theories
and practical experiences of developing the application. The fundamentally knowledge
of C++ and OpenGL have improved. Particularly working in a fully equipped motion
capture laboratory will be an priceless experience.
4.1 Limitation and Improvement
• No synchronisation of two charactersEven if the one of the time-line has updated by reconstructing, another does not
updated automatically and users are not allowed to edit another character’s time-
line. Due to the lack of time, we could not implement the function to switch
over the displaying time-line. It could be improved if the automated system for
synchronisation has been implemented for instance, if one of the swing animation
is added into the time-line, the counter attack animation should be inserted in
the appropriate time. However, the main aim of application is creating tutorial
software users might not do not need to create a time-line by themselves. Rather
than modifiability of the sequence, the application could have real-time capturing
system to evaluate users movement associated the sequence; more interactive, the
users can learn by observing motions then try to imitate the motion which will
be evaluated by the application in real-time. As Jamie Shotton and et al (2011)
have introduced body part recognition application using hardware called Kinect
Reg: 100029968 39
CMPC3P2Y
to capture in real-time.
• Create motion graph databaseOnly the LEARP interpolation between two animation has limitation to improve
its realistic. Therefore we could create set of animations for transition. The data
could be produced by capturing extra motions which may takes extra cost. Thus
as we have researched, the techniques of the motion graph can be used to generate
a transition database.
• Sliding transition for position interpolationThe SLEARP interpolation performs quite well in some case for instance between
rising up sward animation to moving forward animation, although when there is
such a long gap between two motions, it seems really awkward. Because the
theory which we have borrowed interpolates whenever two positions, for instance
after left character’s swing there is a large blank, which does not contain any
animations, and the function interpolate the start position of the swing to the next
start position of next animation along the duration between them. Therefore, if
the character actually swinging and it is being translated it looks fine, however,
the interpolation is still on the middle of the way to finish even after the swing
animation has finished, thus it looks that the character has stepped forward with
swing and then it paused until next animation stars but position of the character is
increasing therefore it looks sliding. This problem could be solved by employing
the footprint-driven synthesis techniques, however , purely due to lack of time we
could not able to implement the concept. This functionality should improve the
reality of character movement.
• Adding different appearance of 3D modelDue to the lack of time for development of the application, we could not imple-
ment several 3D characters to play with. Since skeletal animation is applied in
the software even the mesh of the 3D character changed the skeletal animation
works as long as same the skeleton is used. Kendo kata needs two characters,
changing characters should help users to understand the difference between two
the textitUchitachi and Shitachi.
Reg: 100029968 40
CMPC3P2Y
The character is sliding after motion has done.
Figure 16: Sliding problem
• Collision detection between two charactersAs the result, the project does not consider any collision detection. It quite possi-
ble to happen one character’s sword come into the inside of other character if the
user reconstruct the time-line, unless other character’s time-line will also updated.
For further research, it might be worth to consider that having collision detection
and if some animation have possibility or actually collide to the outer sphere of
other object. And if its collide, a bypass of the animation along the collision area
to avoid colliding.
• Not instinctive GUIIn general, the application provides simply designed user interface which have
good usability. On the other hand, some functionalities are not instinctive ac-
cording to several usability testing involved colleagues. They have reported that
the move the seekbar, change speed, and changing camera position by pressing
keys functions are easier to understand. However, contorting the view point by
manually is not quite instinctive operation. Particularly controlling by keyboard
Reg: 100029968 41
CMPC3P2Y
appears to be difficult to some of them who have not got any experience to con-
trol in 3D environment, such as playing game or so. To improve the usability, the
determination of camera direction should done by mouse input probably. As a
lack of experience in 3D environment rises the difficulty to control the camera by
rotating by three axes.
5 Conclusion
This report described the project undertaken. The project produce the simple martial
arts tutorial software, particularly focus on the Kendo’s kata sequences. The background
section looked at relevant projects especially in the field of synthesising motions and de-
scribed several theories which involved in the development process. In implementation
section is mostly dedicated ot the producing animations and aspects of programming.
Moreover, evaluation of outcome and some potential improvement of the application is
discussed.
Although the application has achieved the fundamental aims and objectives of the
projects, it should not be totally successful, since the application contains explicit prob-
lems such as low quality of transition in some case. However, we could use this project
for further research.
Reg: 100029968 42
CMPC3P2Y
References
Arikan, O. and Forsyth, D. A. (2002). Interactive motion generation from examples.
21(3):483–490.
B.J.H. van Basten, P.W.A.M. Peeters, A. E. (2010). The step space: example-based
footprint driven motion synthesis. Computer Animation and Virtual Worlds, 21:433–
441.
Charles Rose, B. B. and F.Cohen, M. (1998). Verbs and adverbs: Multidimensional
motion interpolation using radial basis functions. URL:http:// www.vuse.vanderbilt.
edu/ ~bobbyb/ pubs/ VandAdv98.pdf .
David, H. (2005). David henry’s homepage. URL:http:// tfc.duke.free.fr/ .
Hakudo, A. (2013). Hakudo-an, kendo research website. URL:http:// hakudoh.com/ wp/
study/ page_0502/ page_02.
Jamie Shotton, A. F. and et al (2011). Real-time human pose recognition in parts from
single depth images. URL:http:// sistemas-humano-computacionais.wdfiles.com/
local--files/ capitulo:modelagem-e-simulacao-de-humanos/ BodyPartRecognition%
20MSR%2011.pdf .
KatsBits (2015). Game making import/export scripts for blender, 3ds max, gmax.
URL:http:// www.katsbits.com/ tools/ .
Kwon, T. and Shin, S. Y. (2005). Motion modeling for on-line locomotion synthesis.
URL:http:// tclab.kaist.ac.kr/ ~taesoo/ locomotion/ locomotion_sca.pdf .
Lee, J. et, a. (2002). Interactive control of avaters animated with human motion
data. ISBN: 1-58113-521-1, DOI: 10.1145/566654.566607, URL:http:// dl.acm.org/
citation.cfm?doid=566570.566607 .
Lucas Kovar, Michael Gleicher, F. P. (2002). Motion graph. ACM Transactions on
Graphics (TOG)., 21:473–482.
Miller, R. (2011). Drills: Training For Sudden Violence.
Reg: 100029968 43
CMPC3P2Y
Pejsa, T. and Pandzic, I. (2010). State of the art in example-based motion synthesis for
virtual characters in interactive applications. Computer Graphic Forum, 29(1):202–
226.
Pipho, E. (2003). Focus on 3D models. Premier Press, a division of Course technology.
Reenskaug, T. (1979). A note on dynabook requirements. URL:http:// folk.uio.no/
trygver/ 1979/ sysreq/ SysReq.pdf .
Shawn Singh, Mubbasir Kapadia, G. R. and Faloutsos, P. (2011). Footstep navigation
for dynamic crowds. DOI:10.1002/cav.403, URL:http:// dx.doi.org/ 10.1002/ cav.403.
Song, H. A. (2010). shongho.ca. URL:http:// www.songho.ca/ .
Treuille, A. Y. and Z.Popovi (2007). Near-optimal character animation with continuous
control.
Youtube (2015). URL:https:// www.youtube.com/ .
Reg: 100029968 44