#include <UnitTest++.h>

#include <iostream>

#include "rbdl/rbdl_mathutils.h"
#include "rbdl/Logging.h"

#include "rbdl/Model.h"
#include "rbdl/Kinematics.h"
#include "rbdl/Dynamics.h"

#include "Human36Fixture.h"

using namespace std;
using namespace RigidBodyDynamics;
using namespace RigidBodyDynamics::Math;

const double TEST_PREC = 1.0e-12;

struct KinematicsFixture {
  KinematicsFixture () {
    ClearLogOutput();
    model = new Model;

    /* Basically a model like this, where X are the Center of Masses
     * and the CoM of the last (3rd) body comes out of the Y=X=0 plane.
     *
     *                X
     *                *
     *              _/
     *            _/  (-Z)
     *      Z    /
     *      *---* 
     *      |
     *      |
     *  Z   |
     *  O---*
     *      Y
     */

    body_a = Body (1., Vector3d (1., 0., 0.), Vector3d (1., 1., 1.));
    joint_a = Joint( SpatialVector (0., 0., 1., 0., 0., 0.));

    body_a_id = model->AddBody(0, Xtrans(Vector3d(0., 0., 0.)), joint_a, body_a);

    body_b = Body (1., Vector3d (0., 1., 0.), Vector3d (1., 1., 1.));
    joint_b = Joint ( SpatialVector (0., 1., 0., 0., 0., 0.));

    body_b_id = model->AddBody(body_a_id, Xtrans(Vector3d(1., 0., 0.)), joint_b, body_b);

    body_c = Body (1., Vector3d (0., 0., 1.), Vector3d (1., 1., 1.));
    joint_c = Joint ( SpatialVector (0., 0., 1., 0., 0., 0.));

    body_c_id = model->AddBody(body_b_id, Xtrans(Vector3d(0., 1., 0.)), joint_c, body_c);

    body_d = Body (1., Vector3d (1., 0., 0.), Vector3d (1., 1., 1.));
    joint_c = Joint ( SpatialVector (1., 0., 0., 0., 0., 0.));

    body_d_id = model->AddBody(body_c_id, Xtrans(Vector3d(0., 0., -1.)), joint_c, body_d);

    Q = VectorNd::Constant ((size_t) model->dof_count, 0.);
    QDot = VectorNd::Constant ((size_t) model->dof_count, 0.);
    QDDot = VectorNd::Constant ((size_t) model->dof_count, 0.);
    Tau = VectorNd::Constant ((size_t) model->dof_count, 0.);

    ClearLogOutput();
  }

  ~KinematicsFixture () {
    delete model;
  }
  Model *model;

  unsigned int body_a_id, body_b_id, body_c_id, body_d_id;
  Body body_a, body_b, body_c, body_d;
  Joint joint_a, joint_b, joint_c, joint_d;

  VectorNd Q;
  VectorNd QDot;
  VectorNd QDDot;
  VectorNd Tau;
};

struct KinematicsFixture6DoF {
  KinematicsFixture6DoF () {
    ClearLogOutput();
    model = new Model;

    model->gravity = Vector3d  (0., -9.81, 0.);

    /* 
     *
     *          X Contact point (ref child)
     *          |
     *    Base  |
     *   / body |
     *  O-------*
     *           \
     *             Child body
     */

    // base body (3 DoF)
    base = Body (
        1.,
        Vector3d (0.5, 0., 0.),
        Vector3d (1., 1., 1.)
        );
    joint_rotzyx = Joint (
        SpatialVector (0., 0., 1., 0., 0., 0.),
        SpatialVector (0., 1., 0., 0., 0., 0.),
        SpatialVector (1., 0., 0., 0., 0., 0.)
        );
    base_id = model->AddBody (0, Xtrans (Vector3d (0., 0., 0.)), joint_rotzyx, base);

    // child body (3 DoF)
    child = Body (
        1.,
        Vector3d (0., 0.5, 0.),
        Vector3d (1., 1., 1.)
        );
    child_id = model->AddBody (base_id, Xtrans (Vector3d (1., 0., 0.)), joint_rotzyx, child);

    Q = VectorNd::Constant (model->mBodies.size() - 1, 0.);
    QDot = VectorNd::Constant (model->mBodies.size() - 1, 0.);
    QDDot = VectorNd::Constant (model->mBodies.size() - 1, 0.);
    Tau = VectorNd::Constant (model->mBodies.size() - 1, 0.);

    ClearLogOutput();
  }

  ~KinematicsFixture6DoF () {
    delete model;
  }
  Model *model;

  unsigned int base_id, child_id;
  Body base, child;
  Joint joint_rotzyx;

  VectorNd Q;
  VectorNd QDot;
  VectorNd QDDot;
  VectorNd Tau;
};



TEST_FIXTURE(KinematicsFixture, TestPositionNeutral) {
  // We call ForwardDynamics() as it updates the spatial transformation
  // matrices
  ForwardDynamics(*model, Q, QDot, Tau, QDDot);

  Vector3d body_position;

  CHECK_ARRAY_CLOSE (Vector3d (0., 0., 0.), CalcBodyToBaseCoordinates(*model, Q, body_a_id, Vector3d (0., 0., 0.), true), 3, TEST_PREC );
  CHECK_ARRAY_CLOSE (Vector3d (1., 0., 0.), CalcBodyToBaseCoordinates(*model, Q, body_b_id, Vector3d (0., 0., 0.), true), 3, TEST_PREC );
  CHECK_ARRAY_CLOSE (Vector3d (1., 1., 0.), CalcBodyToBaseCoordinates(*model, Q, body_c_id, Vector3d (0., 0., 0.), true), 3, TEST_PREC );
  CHECK_ARRAY_CLOSE (Vector3d (1., 1., -1.), CalcBodyToBaseCoordinates(*model, Q, body_d_id, Vector3d (0., 0., 0.), true), 3, TEST_PREC );
}

TEST_FIXTURE(KinematicsFixture, TestPositionBaseRotated90Deg) {
  // We call ForwardDynamics() as it updates the spatial transformation
  // matrices

  Q[0] = 0.5 * M_PI;
  ForwardDynamics(*model, Q, QDot, Tau, QDDot);

  Vector3d body_position;

  //	cout << LogOutput.str() << endl;
  CHECK_ARRAY_CLOSE (Vector3d (0., 0., 0.), CalcBodyToBaseCoordinates(*model, Q, body_a_id, Vector3d (0., 0., 0.), true), 3, TEST_PREC );
  CHECK_ARRAY_CLOSE (Vector3d (0., 1., 0.), CalcBodyToBaseCoordinates(*model, Q, body_b_id, Vector3d (0., 0., 0.), true), 3, TEST_PREC );
  CHECK_ARRAY_CLOSE (Vector3d (-1., 1., 0.),CalcBodyToBaseCoordinates(*model, Q, body_c_id, Vector3d (0., 0., 0.), true), 3, TEST_PREC );
  CHECK_ARRAY_CLOSE (Vector3d (-1., 1., -1.), CalcBodyToBaseCoordinates(*model, Q, body_d_id, Vector3d (0., 0., 0.), true), 3, TEST_PREC );
}

TEST_FIXTURE(KinematicsFixture, TestPositionBaseRotatedNeg45Deg) {
  // We call ForwardDynamics() as it updates the spatial transformation
  // matrices

  Q[0] = -0.25 * M_PI;
  ForwardDynamics(*model, Q, QDot, Tau, QDDot);

  Vector3d body_position;

  //	cout << LogOutput.str() << endl;
  CHECK_ARRAY_CLOSE (Vector3d (0., 0., 0.), CalcBodyToBaseCoordinates(*model, Q, body_a_id, Vector3d (0., 0., 0.), true), 3, TEST_PREC );
  CHECK_ARRAY_CLOSE (Vector3d (0.707106781186547, -0.707106781186547, 0.), CalcBodyToBaseCoordinates(*model, Q, body_b_id, Vector3d (0., 0., 0.), true), 3, TEST_PREC );
  CHECK_ARRAY_CLOSE (Vector3d (sqrt(2.0), 0., 0.),CalcBodyToBaseCoordinates(*model, Q, body_c_id, Vector3d (0., 0., 0.), true), 3, TEST_PREC );
  CHECK_ARRAY_CLOSE (Vector3d (sqrt(2.0), 0., -1.), CalcBodyToBaseCoordinates(*model, Q, body_d_id, Vector3d (0., 0., 0.), true), 3, TEST_PREC );
}

TEST_FIXTURE(KinematicsFixture, TestPositionBodyBRotated90Deg) {
  // We call ForwardDynamics() as it updates the spatial transformation
  // matrices
  Q[1] = 0.5 * M_PI;
  ForwardDynamics(*model, Q, QDot, Tau, QDDot);

  Vector3d body_position;

  CHECK_ARRAY_CLOSE (Vector3d (0., 0., 0.), CalcBodyToBaseCoordinates(*model, Q, body_a_id, Vector3d (0., 0., 0.), true), 3, TEST_PREC );
  CHECK_ARRAY_CLOSE (Vector3d (1., 0., 0.), CalcBodyToBaseCoordinates(*model, Q, body_b_id, Vector3d (0., 0., 0.), true), 3, TEST_PREC );
  CHECK_ARRAY_CLOSE (Vector3d (1., 1., 0.),CalcBodyToBaseCoordinates(*model, Q, body_c_id, Vector3d (0., 0., 0.), true), 3, TEST_PREC );
  CHECK_ARRAY_CLOSE (Vector3d (0., 1., 0.),CalcBodyToBaseCoordinates(*model, Q, body_d_id, Vector3d (0., 0., 0.), true), 3, TEST_PREC );
}

TEST_FIXTURE(KinematicsFixture, TestPositionBodyBRotatedNeg45Deg) {
  // We call ForwardDynamics() as it updates the spatial transformation
  // matrices
  Q[1] = -0.25 * M_PI;
  ForwardDynamics(*model, Q, QDot, Tau, QDDot);

  Vector3d body_position;

  CHECK_ARRAY_CLOSE (Vector3d (0., 0., 0.), CalcBodyToBaseCoordinates(*model, Q, body_a_id, Vector3d (0., 0., 0.), true), 3, TEST_PREC );
  CHECK_ARRAY_CLOSE (Vector3d (1., 0., 0.), CalcBodyToBaseCoordinates(*model, Q, body_b_id, Vector3d (0., 0., 0.), true), 3, TEST_PREC );
  CHECK_ARRAY_CLOSE (Vector3d (1., 1., 0.),CalcBodyToBaseCoordinates(*model, Q, body_c_id, Vector3d (0., 0., 0.), true), 3, TEST_PREC );
  CHECK_ARRAY_CLOSE (Vector3d (1 + 0.707106781186547, 1., -0.707106781186547), CalcBodyToBaseCoordinates(*model, Q, body_d_id, Vector3d (0., 0., 0.), true), 3, TEST_PREC );
}

TEST_FIXTURE(KinematicsFixture, TestCalcBodyToBaseCoordinates) {
  // We call ForwardDynamics() as it updates the spatial transformation
  // matrices
  ForwardDynamics(*model, Q, QDot, Tau, QDDot);

  CHECK_ARRAY_CLOSE (
      Vector3d (1., 2., 0.),
      CalcBodyToBaseCoordinates(*model, Q, body_c_id, Vector3d (0., 1., 0.)),
      3, TEST_PREC
      );
}

TEST_FIXTURE(KinematicsFixture, TestCalcBodyToBaseCoordinatesRotated) {
  Q[2] = 0.5 * M_PI;

  // We call ForwardDynamics() as it updates the spatial transformation
  // matrices
  ForwardDynamics(*model, Q, QDot, Tau, QDDot);

  CHECK_ARRAY_CLOSE (
      Vector3d (1., 1., 0.).data(),
      CalcBodyToBaseCoordinates(*model, Q, body_c_id, Vector3d (0., 0., 0.), false).data(),
      3, TEST_PREC
      );

  CHECK_ARRAY_CLOSE (
      Vector3d (0., 1., 0.).data(),
      CalcBodyToBaseCoordinates(*model, Q, body_c_id, Vector3d (0., 1., 0.), false).data(),
      3, TEST_PREC
      );

  // Rotate the other way round
  Q[2] = -0.5 * M_PI;

  // We call ForwardDynamics() as it updates the spatial transformation
  // matrices
  ForwardDynamics(*model, Q, QDot, Tau, QDDot);

  CHECK_ARRAY_CLOSE (
      Vector3d (1., 1., 0.),
      CalcBodyToBaseCoordinates(*model, Q, body_c_id, Vector3d (0., 0., 0.), false),
      3, TEST_PREC
      );

  CHECK_ARRAY_CLOSE (
      Vector3d (2., 1., 0.),
      CalcBodyToBaseCoordinates(*model, Q, body_c_id, Vector3d (0., 1., 0.), false),
      3, TEST_PREC
      );

  // Rotate around the base
  Q[0] = 0.5 * M_PI;
  Q[2] = 0.;

  // We call ForwardDynamics() as it updates the spatial transformation
  // matrices
  ForwardDynamics(*model, Q, QDot, Tau, QDDot);

  CHECK_ARRAY_CLOSE (
      Vector3d (-1., 1., 0.),
      CalcBodyToBaseCoordinates(*model, Q, body_c_id, Vector3d (0., 0., 0.), false),
      3, TEST_PREC
      );

  CHECK_ARRAY_CLOSE (
      Vector3d (-2., 1., 0.),
      CalcBodyToBaseCoordinates(*model, Q, body_c_id, Vector3d (0., 1., 0.), false),
      3, TEST_PREC
      );

  //	cout << LogOutput.str() << endl;
}

TEST(TestCalcPointJacobian) {
  Model model;
  Body base_body (1., Vector3d (0., 0., 0.), Vector3d (1., 1., 1.));

  unsigned int base_body_id = model.AddBody (0, SpatialTransform(), 
      Joint (
        SpatialVector (0., 0., 0., 1., 0., 0.),
        SpatialVector (0., 0., 0., 0., 1., 0.),
        SpatialVector (0., 0., 0., 0., 0., 1.),
        SpatialVector (0., 0., 1., 0., 0., 0.),
        SpatialVector (0., 1., 0., 0., 0., 0.),
        SpatialVector (1., 0., 0., 0., 0., 0.)
        ),
      base_body);

  VectorNd Q = VectorNd::Constant ((size_t) model.dof_count, 0.);
  VectorNd QDot = VectorNd::Constant ((size_t) model.dof_count, 0.);
  MatrixNd G = MatrixNd::Constant (3, model.dof_count, 0.);
  Vector3d point_position (1.1, 1.2, 2.1);
  Vector3d point_velocity_ref;
  Vector3d point_velocity;

  Q[0] = 1.1;
  Q[1] = 1.2;
  Q[2] = 1.3;
  Q[3] = 0.7;
  Q[4] = 0.8;
  Q[5] = 0.9;

  QDot[0] = -1.1;
  QDot[1] = 2.2;
  QDot[2] = 1.3;
  QDot[3] = -2.7;
  QDot[4] = 1.8;
  QDot[5] = -2.9;

  // Compute the reference velocity
  point_velocity_ref = CalcPointVelocity (model, Q, QDot, base_body_id, point_position);

  G.setZero();
  CalcPointJacobian (model, Q, base_body_id, point_position, G);

  point_velocity = G * QDot;

  CHECK_ARRAY_CLOSE (
      point_velocity_ref.data(),
      point_velocity.data(),
      3, TEST_PREC
      );
}

TEST_FIXTURE(KinematicsFixture, TestInverseKinematicSimple) {
  std::vector<unsigned int> body_ids;
  std::vector<Vector3d> body_points;
  std::vector<Vector3d> target_pos;

  Q[0] = 0.2;
  Q[1] = 0.1;
  Q[2] = 0.1;

  VectorNd Qres = VectorNd::Zero ((size_t) model->dof_count);

  unsigned int body_id = body_d_id;
  Vector3d body_point = Vector3d (1., 0., 0.);
  Vector3d target (1.3, 0., 0.);

  body_ids.push_back (body_d_id);
  body_points.push_back (body_point);
  target_pos.push_back (target);

  ClearLogOutput();
  bool res = InverseKinematics (*model, Q, body_ids, body_points, target_pos, Qres);
  //	cout << LogOutput.str() << endl;
  CHECK_EQUAL (true, res);

  UpdateKinematicsCustom (*model, &Qres, NULL, NULL);

  Vector3d effector;
  effector = CalcBodyToBaseCoordinates(*model, Qres, body_id, body_point, false);

  CHECK_ARRAY_CLOSE (target.data(), effector.data(), 3, TEST_PREC);	
}

TEST_FIXTURE(KinematicsFixture6DoF, TestInverseKinematicUnreachable) {
  std::vector<unsigned int> body_ids;
  std::vector<Vector3d> body_points;
  std::vector<Vector3d> target_pos;

  Q[0] = 0.2;
  Q[1] = 0.1;
  Q[2] = 0.1;

  VectorNd Qres = VectorNd::Zero ((size_t) model->dof_count);

  unsigned int body_id = child_id;
  Vector3d body_point = Vector3d (1., 0., 0.);
  Vector3d target (2.2, 0., 0.);

  body_ids.push_back (body_id);
  body_points.push_back (body_point);
  target_pos.push_back (target);

  ClearLogOutput();
  bool res = InverseKinematics (*model, Q, body_ids, body_points, target_pos, Qres, 1.0e-8, 0.9, 1000);
  //	cout << LogOutput.str() << endl;
  CHECK_EQUAL (true, res);

  UpdateKinematicsCustom (*model, &Qres, NULL, NULL);

  Vector3d effector;
  effector = CalcBodyToBaseCoordinates(*model, Qres, body_id, body_point, false);

  CHECK_ARRAY_CLOSE (Vector3d (2.0, 0., 0.).data(), effector.data(), 3, 1.0e-7);	
}

TEST_FIXTURE(KinematicsFixture6DoF, TestInverseKinematicTwoPoints) {
  std::vector<unsigned int> body_ids;
  std::vector<Vector3d> body_points;
  std::vector<Vector3d> target_pos;

  Q[0] = 0.2;
  Q[1] = 0.1;
  Q[2] = 0.1;

  VectorNd Qres = VectorNd::Zero ((size_t) model->dof_count);

  unsigned int body_id = child_id;
  Vector3d body_point = Vector3d (1., 0., 0.);
  Vector3d target (2., 0., 0.);

  body_ids.push_back (body_id);
  body_points.push_back (body_point);
  target_pos.push_back (target);

  body_ids.push_back (base_id);
  body_points.push_back (Vector3d (0.6, 1.0, 0.));
  target_pos.push_back (Vector3d (0.5, 1.1, 0.));

  ClearLogOutput();
  bool res = InverseKinematics (*model, Q, body_ids, body_points, target_pos, Qres, 1.0e-3, 0.9, 200);
  CHECK_EQUAL (true, res);

  //	cout << LogOutput.str() << endl;
  UpdateKinematicsCustom (*model, &Qres, NULL, NULL);

  Vector3d effector;

  // testing with very low precision
  effector = CalcBodyToBaseCoordinates(*model, Qres, body_ids[0], body_points[0], false);
  CHECK_ARRAY_CLOSE (target_pos[0].data(), effector.data(), 3, 1.0e-1);	

  effector = CalcBodyToBaseCoordinates(*model, Qres, body_ids[1], body_points[1], false);
  CHECK_ARRAY_CLOSE (target_pos[1].data(), effector.data(), 3, 1.0e-1);	
}

TEST ( FixedJointBodyCalcBodyToBase ) {
  // the standard modeling using a null body
  Body null_body;
  Body body(1., Vector3d (1., 0.4, 0.4), Vector3d (1., 1., 1.));
  Body fixed_body(1., Vector3d (1., 0.4, 0.4), Vector3d (1., 1., 1.));

  Model model;

  Joint joint_rot_z ( SpatialVector (0., 0., 1., 0., 0., 0.));
  model.AddBody (0, Xtrans(Vector3d(0., 0., 0.)), joint_rot_z, body);
  unsigned int fixed_body_id = model.AppendBody (Xtrans(Vector3d(0., 1., 0.)), Joint(JointTypeFixed), fixed_body);

  VectorNd Q_zero = VectorNd::Zero (model.dof_count);
  Vector3d base_coords = CalcBodyToBaseCoordinates (model, Q_zero, fixed_body_id, Vector3d (1., 1., 0.1));

  CHECK_ARRAY_CLOSE (Vector3d (1., 2., 0.1).data(), base_coords.data(), 3, TEST_PREC);
}

TEST ( FixedJointBodyCalcBodyToBaseRotated ) {
  // the standard modeling using a null body
  Body null_body;
  Body body(1., Vector3d (1., 0.4, 0.4), Vector3d (1., 1., 1.));
  Body fixed_body(1., Vector3d (1., 0.4, 0.4), Vector3d (1., 1., 1.));

  Model model;

  Joint joint_rot_z ( SpatialVector(0., 0., 1., 0., 0., 0.));
  model.AddBody (0, Xtrans(Vector3d(0., 0., 0.)), joint_rot_z, body);
  unsigned int fixed_body_id = model.AppendBody (Xtrans(Vector3d(1., 0., 0.)), Joint(JointTypeFixed), fixed_body);

  VectorNd Q = VectorNd::Zero (model.dof_count);

  ClearLogOutput();
  Q[0] = M_PI * 0.5;
  Vector3d base_coords = CalcBodyToBaseCoordinates (model, Q, fixed_body_id, Vector3d (1., 0., 0.));
  //	cout << LogOutput.str() << endl;	

  CHECK_ARRAY_CLOSE (Vector3d (0., 2., 0.).data(), base_coords.data(), 3, TEST_PREC);
}

TEST ( FixedJointBodyCalcBaseToBody ) {
  // the standard modeling using a null body
  Body null_body;
  Body body(1., Vector3d (1., 0.4, 0.4), Vector3d (1., 1., 1.));
  Body fixed_body(1., Vector3d (1., 0.4, 0.4), Vector3d (1., 1., 1.));

  Model model;

  Joint joint_rot_z ( SpatialVector (0., 0., 1., 0., 0., 0.));
  model.AddBody (0, Xtrans(Vector3d(0., 0., 0.)), joint_rot_z, body);
  unsigned int fixed_body_id = model.AppendBody (Xtrans(Vector3d(0., 1., 0.)), Joint(JointTypeFixed), fixed_body);

  VectorNd Q_zero = VectorNd::Zero (model.dof_count);
  Vector3d base_coords = CalcBaseToBodyCoordinates (model, Q_zero, fixed_body_id, Vector3d (1., 2., 0.1));

  CHECK_ARRAY_CLOSE (Vector3d (1., 1., 0.1).data(), base_coords.data(), 3, TEST_PREC);
}

TEST ( FixedJointBodyCalcBaseToBodyRotated ) {
  // the standard modeling using a null body
  Body null_body;
  Body body(1., Vector3d (1., 0.4, 0.4), Vector3d (1., 1., 1.));
  Body fixed_body(1., Vector3d (1., 0.4, 0.4), Vector3d (1., 1., 1.));

  Model model;

  Joint joint_rot_z ( SpatialVector (0., 0., 1., 0., 0., 0.));
  model.AddBody (0, Xtrans(Vector3d(0., 0., 0.)), joint_rot_z, body);
  unsigned int fixed_body_id = model.AppendBody (Xtrans(Vector3d(1., 0., 0.)), Joint(JointTypeFixed), fixed_body);

  VectorNd Q = VectorNd::Zero (model.dof_count);

  ClearLogOutput();
  Q[0] = M_PI * 0.5;
  Vector3d base_coords = CalcBaseToBodyCoordinates (model, Q, fixed_body_id, Vector3d (0., 2., 0.));
  // cout << LogOutput.str() << endl;	

  CHECK_ARRAY_CLOSE (Vector3d (1., 0., 0.).data(), base_coords.data(), 3, TEST_PREC);
}

TEST ( FixedJointBodyWorldOrientation ) {
  // the standard modeling using a null body
  Body null_body;
  Body body(1., Vector3d (1., 0.4, 0.4), Vector3d (1., 1., 1.));
  Body fixed_body(1., Vector3d (1., 0.4, 0.4), Vector3d (1., 1., 1.));

  Model model;

  Joint joint_rot_z ( SpatialVector (0., 0., 1., 0., 0., 0.));
  model.AddBody (0, Xtrans(Vector3d(0., 0., 0.)), joint_rot_z, body);

  SpatialTransform transform = Xrotz(0.25) * Xtrans (Vector3d (1., 2., 3.));
  unsigned int fixed_body_id = model.AppendBody (transform, Joint(JointTypeFixed), fixed_body);

  VectorNd Q_zero = VectorNd::Zero (model.dof_count);
  Matrix3d orientation = CalcBodyWorldOrientation (model, Q_zero, fixed_body_id);

  Matrix3d reference = transform.E;

  CHECK_ARRAY_CLOSE (reference.data(), orientation.data(), 9, TEST_PREC);
}

TEST ( FixedJointCalcPointJacobian ) {
  // the standard modeling using a null body
  Body null_body;
  Body body(1., Vector3d (1., 0.4, 0.4), Vector3d (1., 1., 1.));
  Body fixed_body(1., Vector3d (1., 0.4, 0.4), Vector3d (1., 1., 1.));

  Model model;

  Joint joint_rot_z ( SpatialVector (0., 0., 1., 0., 0., 0.));
  model.AddBody (0, Xtrans(Vector3d(0., 0., 0.)), joint_rot_z, body);

  SpatialTransform transform = Xrotz(0.25) * Xtrans (Vector3d (1., 2., 3.));
  unsigned int fixed_body_id = model.AppendBody (transform, Joint(JointTypeFixed), fixed_body);

  VectorNd Q = VectorNd::Zero (model.dof_count);
  VectorNd QDot = VectorNd::Zero (model.dof_count);

  Q[0] = 1.1;
  QDot[0] = 1.2;

  Vector3d point_position (1., 0., 0.);

  MatrixNd G = MatrixNd::Zero (3, model.dof_count);	
  CalcPointJacobian (model, Q, fixed_body_id, point_position, G);
  Vector3d point_velocity_jacobian = G * QDot;
  Vector3d point_velocity_reference = CalcPointVelocity (model, Q, QDot, fixed_body_id, point_position);

  CHECK_ARRAY_CLOSE (point_velocity_reference.data(), point_velocity_jacobian.data(), 3, TEST_PREC);
}

TEST_FIXTURE ( Human36, SpatialJacobianSimple ) {
  randomizeStates();

  unsigned int foot_r_id = model->GetBodyId ("foot_r");
  MatrixNd G (MatrixNd::Zero (6, model->dof_count));

  CalcBodySpatialJacobian (*model, q, foot_r_id, G);

  UpdateKinematicsCustom (*model, &q, &qdot, NULL);
  SpatialVector v_body = SpatialVector(G * qdot);

  CHECK_ARRAY_CLOSE (model->v[foot_r_id].data(), v_body.data(), 6, TEST_PREC);
}

TEST_FIXTURE ( Human36, SpatialJacobianFixedBody ) {
  randomizeStates();

  unsigned int uppertrunk_id = model->GetBodyId ("uppertrunk");
  MatrixNd G (MatrixNd::Zero (6, model->dof_count));

  CalcBodySpatialJacobian (*model, q, uppertrunk_id, G);

  unsigned int fixed_body_id = uppertrunk_id - model->fixed_body_discriminator;
  unsigned int movable_parent = model->mFixedBodies[fixed_body_id].mMovableParent;

  UpdateKinematicsCustom (*model, &q, &qdot, NULL);
  SpatialVector v_body = SpatialVector(G * qdot);

  SpatialVector v_fixed_body = model->mFixedBodies[fixed_body_id].mParentTransform.apply (model->v[movable_parent]);

  CHECK_ARRAY_CLOSE (v_fixed_body.data(), v_body.data(), 6, TEST_PREC);
}

TEST_FIXTURE ( Human36, CalcPointJacobian6D ) {
  randomizeStates();

  unsigned int foot_r_id = model->GetBodyId ("foot_r");
  Vector3d point_local (1.1, 2.2, 3.3);

  // Compute the 6-D velocity using the 6-D Jacobian
  MatrixNd G (MatrixNd::Zero (6, model->dof_count));
  CalcPointJacobian6D (*model, q, foot_r_id, point_local, G);
  SpatialVector v_foot_0_jac = SpatialVector (G * qdot);

  // Compute the 6-D velocity by transforming the body velocity to the
  // reference point and aligning it with the base coordinate system
  Vector3d r_point = CalcBodyToBaseCoordinates (*model, q, foot_r_id, point_local);
  SpatialTransform X_foot (Matrix3d::Identity(), r_point);
  UpdateKinematicsCustom (*model, &q, &qdot, NULL);
  SpatialVector v_foot_0_ref = X_foot.apply(model->X_base[foot_r_id].inverse().apply(model->v[foot_r_id]));

  CHECK_ARRAY_CLOSE (v_foot_0_ref.data(), v_foot_0_jac.data(), 6, TEST_PREC);
}

TEST_FIXTURE ( Human36, CalcPointVelocity6D ) {
  randomizeStates();

  unsigned int foot_r_id = model->GetBodyId ("foot_r");
  Vector3d point_local (1.1, 2.2, 3.3);

  // Compute the 6-D velocity 
  SpatialVector v_foot_0 = CalcPointVelocity6D (*model, q, qdot, foot_r_id, point_local);

  // Compute the 6-D velocity by transforming the body velocity to the
  // reference point and aligning it with the base coordinate system
  Vector3d r_point = CalcBodyToBaseCoordinates (*model, q, foot_r_id, point_local);
  SpatialTransform X_foot (Matrix3d::Identity(), r_point);
  UpdateKinematicsCustom (*model, &q, &qdot, NULL);
  SpatialVector v_foot_0_ref = X_foot.apply(model->X_base[foot_r_id].inverse().apply(model->v[foot_r_id]));

  CHECK_ARRAY_CLOSE (v_foot_0_ref.data(), v_foot_0.data(), 6, TEST_PREC);
}

TEST_FIXTURE ( Human36, CalcPointAcceleration6D ) {
  randomizeStates();

  unsigned int foot_r_id = model->GetBodyId ("foot_r");
  Vector3d point_local (1.1, 2.2, 3.3);

  // Compute the 6-D acceleration 
  SpatialVector a_foot_0 = CalcPointAcceleration6D (*model, q, qdot, qddot, foot_r_id, point_local);

  // Compute the 6-D acceleration by adding the coriolis term to the
  // acceleration of the body and transforming the result to the
  // point and align it with the base coordinate system.
  Vector3d r_point = CalcBodyToBaseCoordinates (*model, q, foot_r_id, point_local);
  Vector3d v_foot_0 = CalcPointVelocity (*model, q, qdot, foot_r_id, point_local);
  SpatialVector rdot (0., 0., 0., v_foot_0[0], v_foot_0[1], v_foot_0[2]);

  SpatialTransform X_foot (Matrix3d::Identity(), r_point);
  UpdateKinematicsCustom (*model, &q, &qdot, NULL);
  SpatialVector a_foot_0_ref = X_foot.apply(
      model->X_base[foot_r_id].inverse().apply(model->a[foot_r_id]) 
      - crossm(rdot, 
        model->X_base[foot_r_id].inverse().apply(model->v[foot_r_id])
        )
      );

  CHECK_ARRAY_CLOSE (a_foot_0_ref.data(), a_foot_0.data(), 6, TEST_PREC);
}