Animation_transformation.cpp

Go to the documentation of this file.

#include <Animation_transformation.h>

#define PI 3.14159

Animation_transformation::Animation_transformation()
{
  angle_x.resize(2);
  angle_y.resize(2);
  angle_z.resize(2);
  time.resize(2);
  translation.resize(2*3);
  anim_matrix.resize(2*16);

  time[0]=0;
  angle_x[0]=0;angle_y[0]=0;angle_z[0]=0;
  for(int count=0;count<3;count++)
    translation[count]=0.0;
  for(int count_1=0;count_1<4;count_1++)
    for(int count_2=0;count_2<4;count_2++)
      {
        if(count_1!=count_2)
          anim_matrix[4*count_1+count_2]=0.0;
        else
          anim_matrix[4*count_1+count_2]=1.0;
      }

  time[1]=200;
  angle_x[1]=0;angle_y[1]=0;angle_z[1]=0;
  for(int count=0;count<3;count++)
    translation[count+3]=0.0;
  for(int count_1=0;count_1<4;count_1++)
    for(int count_2=0;count_2<4;count_2++)
      {
        if(count_1!=count_2)
          anim_matrix[4*count_1+count_2+16]=0.0;
        else
          anim_matrix[4*count_1+count_2+16]=1.0;
      }


  bone_number=-1;
}

Animation_transformation::~Animation_transformation()
{
}


int Animation_transformation::set_size_time(int size)
{
  int ok=0;
  time.resize(size);
  for(int k=0;k<size;k++)
    time[k]=0;
  return ok;
}

int Animation_transformation::set_size_angle(int size)
{
  int ok=0;
  angle_x.resize(size);
  angle_y.resize(size);
  angle_z.resize(size);
  translation.resize(3*size);
  anim_matrix.resize(16*size);
  for(int k=0;k<size;k++)
    {
      angle_x[k]=0;
      angle_y[k]=0;
      angle_z[k]=0;
    }
  for(int k=0;k<(int)translation.size();k++)
    translation[k]=0;
  for(int k=0;k<(int)anim_matrix.size()/16;k++)
    for(int count_1=0;count_1<4;count_1++)
      for(int count_2=0;count_2<4;count_2++)
        {
          if(count_1!=count_2)
            anim_matrix[4*count_1+count_2+16*k]=0.0;
          else
            anim_matrix[4*count_1+count_2+16*k]=1.0;
        }



  return ok;
}



int Animation_transformation::set_time(int k_time,double val)
{
  int ok=0;
  if((unsigned int)k_time>=time.size())
    {
      cout<<"ERROR time excced the capacity"<<endl;
      exit(-1);
    }
  time[k_time]=val;
  return ok;
}
int Animation_transformation::set_angle(int k_time,int k_axis,double val)
{
  int ok=0;
  if((unsigned int)k_time>=time.size())
    {
      cout<<"ERROR time exceed the capacity"<<endl;
      exit(-1);
    }
  if(k_axis==0)
    angle_x[k_time]=val/180.0*PI;
  if(k_axis==1)
    angle_y[k_time]=val/180.0*PI;
  if(k_axis==2)
    angle_z[k_time]=val/180.0*PI;

  return ok;
}

int Animation_transformation::set_translation(int k_time,double tx,double ty,double tz)
{
    int ok=0;
    if((unsigned int)k_time>=time.size() || (unsigned int)(3*k_time+2)>=translation.size())
    {
      cout<<"ERROR time exceed the capacity in set_translation"<<endl;
      exit(-1);
    }
  translation[3*k_time+0] = tx;
  translation[3*k_time+1] = ty;
  translation[3*k_time+2] = tz;

  return ok;
}

int Animation_transformation::set_anim_matrix(int k_time,int k_dim,double value)
{


    int ok=0;
    if((unsigned int)k_time>=time.size() || (unsigned int)(16*k_time+15)>=anim_matrix.size())
    {
      cout<<"ERROR time exceed the capacity in set_anim_matrix"<<endl;
      exit(-1);
    }
  anim_matrix[16*k_time+k_dim] = value;



  return ok;
}


double Animation_transformation::get_angle(int k_time,int k_axis)
{
  if((unsigned int)k_time>=time.size())
    {
      cout<<"ERROR time exceed the capacity in get_angle"<<endl;
      exit(-1);
    }
  if(k_axis==0)
    return angle_x[k_time]*180.0/PI;
  if(k_axis==1)
    return angle_y[k_time]*180.0/PI;
  if(k_axis==2)
    return angle_z[k_time]*180.0/PI;

  else 
    cout<<"ERROR k axis"<<endl;
    exit(-1);

}

Matrix Animation_transformation::get_rotation(double t)
{
  //should take t into account

  Matrix R;
  Matrix temp_rot;

  if(time.size()>20000)
    {printf("Something weird in time size for animation time_size is big ... init ?\n");exit(-1);}

  int k=0;
  if(t>=time[time.size()-1])
    {
      printf("error time t exceed time dimension in Animation_transformation t=%f, tmax=%f (t[%d])\n",t,time[time.size()-1],time.size()-1);
      exit(-1);
    }

  if(t<=0)
    k=0;
  else
    {
      if(t>=time[time.size()-1])
        k=time.size();
      else
        {
          while(!(time[k]<=t && time[k+1]>t))
            k++;
        }
    }

  //printf("%d,(%f,%f),(%f,%f)\n",k,time[k],time[k+1],angle_x[k],angle_x[k+1]);


  double u = (t-time[k])/(time[k+1]-time[k]);



  double ut1=1-u;
  double ut2=1-ut1;


  temp_rot.set_vector_rotation(1,0,0,angle_x[k]*ut1+angle_x[k+1]*ut2);
  R = R*temp_rot;
  temp_rot.set_vector_rotation(0,1,0,angle_y[k]*ut1+angle_y[k+1]*ut2);
  R = R*temp_rot;
  temp_rot.set_vector_rotation(0,0,1,angle_z[k]*ut1+angle_z[k+1]*ut2);
  R = R*temp_rot;



  return R;
}


Matrix Animation_transformation::get_matrix(double t)
{
  //should take t into account

  Matrix M;



  if(time.size()>2000)
    {printf("Something weird in time size for animation ... init ?\n");exit(-1);}

  int k=0;
  if(t>=time[time.size()-1])
    {
      printf("error time t exceed time dimension in Animation_transformation t=%f, tmax=%f (t[%d])\n",t,time[time.size()-1],time.size()-1);
      exit(-1);
    }

  if(t<=time[0])
    k=0;
  else
    {
      if(t>=time[time.size()-1])
        k=time.size();
      else
        {
          while(!(time[k]<=t && time[k+1]>t))
            {
              k++;
              if(k>=(int)time.size()-1)
                {printf("something wrong in animation, k=size_time ... for time %f\n",t);exit(-1);}
            }
        }
    }



  double u = (t-time[k])/(time[k+1]-time[k]);



  double ut1=1-u;
  double ut2=1-ut1;


  Matrix M1;
  Matrix M2;



  int k1=0,k2=0;
  for(k1=0;k1<4;k1++)
    for(k2=0;k2<4;k2++)
      {
        M1.set_value(anim_matrix[16*k+4*k1+k2],k2,k1);
        M2.set_value(anim_matrix[16*(k+1)+4*k1+k2],k2,k1);
      }

  M = M1*ut1+M2*ut2;




  return M;
}


Matrix Animation_transformation::get_translation(double t)
{
  //should take t into account

  Matrix T;


  int k=0;
  if(t>=time[time.size()-1])
    {
      printf("error time t exceed time dimension in Animation_transformation t=%f, tmax=%f (t[%d])\n",t,time[time.size()-1],time.size()-1);
      exit(-1);
    }

  if(t<=time[0])
    k=0;
  else
    {
      if(t>=time[time.size()-1])
        k=time.size();
      else
        {
          while(!(time[k]<=t && time[k+1]>t))
            {
              k++;
              if(k>=(int)time.size()-1)
                {printf("something wrong in animation, k=size_time ... for time %f\n",t);exit(-1);}
            }
        }
    }

  double u = (t-time[k])/(time[k+1]-time[k]);


  if(3*(k+1)+2>(int)translation.size())
    {printf("Error index too large for translation vector in Animation_transformation [%d] / [%d]\n",3*(k+1)+2,translation.size());exit(-1);}


  double ut1=1-u;
  double ut2=1-ut1;


  T.set_translation(translation[3*k+0]*ut1+translation[3*(k+1)+0]*ut2,
                    translation[3*k+1]*ut1+translation[3*(k+1)+1]*ut2,
                    translation[3*k+2]*ut1+translation[3*(k+1)+2]*ut2);

  return T;
}

int Animation_transformation::get_size()
{
  return time.size();
}


Animation_transformation& Animation_transformation::operator=(const Animation_transformation& anim)
{
  bone_number = anim.bone_number;

  if(bone_number!=-1)
    {
      angle_x.resize(bone_number);
      angle_y.resize(bone_number);
      angle_z.resize(bone_number);
      translation.resize(3*bone_number);
      time.resize(bone_number);
      anim_matrix.resize(16*bone_number);

      int k=0;
      for(k=0;k<bone_number;k++)
        {
          angle_x[k] = anim.angle_x[k];
          angle_y[k] = anim.angle_y[k];
          angle_z[k] = anim.angle_z[k];
          time[k]    = anim.time[k];
          translation[k] = anim.translation[k];
          anim_matrix[k] = anim.anim_matrix[k];
        }
    }

  return *this;
}


double Animation_transformation::get_time(int k_index)
{
  if(k_index<0 || k_index>=(int)time.size())
    {printf("Error time size is too large\n");exit(-1);}
  return time[k_index];
}