Skinned.cpp

Go to the documentation of this file.

#include <Skinned.h>


Skinned::Skinned():mesh(NULL),deformed_mesh(NULL),skeleton(NULL),deformed_skeleton(NULL)
{}

Skinned::Skinned(const Skinned& )
{}

Skinned::~Skinned()
{}






Skeleton *Skinned::get_skeleton()
{return skeleton;}


Mesh_object *Skinned::get_mesh()
{return mesh;}



int Skinned::set_skeleton(Skeleton *_skeleton)
{skeleton = _skeleton;return 0;}
int Skinned::set_deformed_skeleton(Skeleton *_skeleton)
{deformed_skeleton = _skeleton;return 0;}

int Skinned::set_mesh(Mesh_object *_mesh)
{mesh = _mesh;return 0;}
int Skinned::set_deformed_mesh(Mesh_object *_mesh)
{deformed_mesh = _mesh;return 0;}

int Skinned::size_weight()
{
  return weight.size();
}

int Skinned::add_weight(double w)
{
  weight.push_back(w);
  return 0;
}

int Skinned::set_weight(int k_index, double value)
{
  if(k_index<0 || k_index>=size_weight())
    {printf("Error in set_weight in Skinned, k_index[%d] is not correct\n",k_index);exit(-1);}

  weight[k_index] = value;
  return 0;

}

double Skinned::get_weight(int k_index)
{
  if(k_index<0 || k_index>=size_weight())
    {printf("Error in get_weight in Skinned, k_index[%d] is not correct\n",k_index);exit(-1);}

  return weight[k_index];

}

int Skinned::size_index_weight()
{return index_weight.size();}

int Skinned::size_index_weight(int k_index)
{
  if(k_index<0 || k_index>=(int)index_weight.size())
    {printf("Error k_index too large in size_index_weight in Skinned\n");exit(-1);}

  return index_weight[k_index].size();
}

int Skinned::set_size_index_weight(int size)
{index_weight.resize(size);return 0;}
int Skinned::get_size_index_weight(int k_vertex)
{
  if(k_vertex<0 || k_vertex>(int)index_weight.size())
    {printf("Error k_vertex[%d] is too large compared to index_weight.size()[%d] in get_size_index_weight in Skinned\n",k_vertex,index_weight.size());exit(-1);}
  return index_weight[k_vertex].size();

}
int Skinned::set_size_index_weight(int k_index,int size)
{index_weight[k_index].resize(size);return 0;}

int Skinned::add_index_weight(int k_index,int index)
{
  if(k_index<0 || k_index>=(int)index_weight.size())
    {printf("Error k_index too large in add_index_weight in Skinned\n");exit(-1);}
  index_weight[k_index].add(index);
  return 0;
}

int Skinned::add_index_weight(int k_vertex,std::vector <int>& index)
{
  if(k_vertex<0 || k_vertex>=(int)index_weight.size())
    {printf("Error k_vertex too large in add_index_weight in Skinned\n");exit(-1);}
  index_weight[k_vertex].add(index);
  return 0;
}

int Skinned::set_index_weight(int k_vertex,int k_index,int _index_weight)
{
  if(k_index<0 || k_index>=(int)index_weight.size())
    {printf("Error k_index too large in set_index_weight in Skinned\n");exit(-1);}
  index_weight[k_vertex][k_index]=_index_weight;
  return 0;
}
int Skinned::get_index_weight(int k_vertex,int k_index)
{
  if(k_vertex<0 || k_vertex>=(int)index_weight.size())
    {printf("Error k_vertex too large in get_index_weight in Skinned\n");exit(-1);}

  return index_weight[k_vertex][k_index];
}





int Skinned::size_index_joint()
{return index_joint.size();}

int Skinned::size_index_joint(int k_index)
{
  if(k_index<0 || k_index>=(int)index_joint.size())
    {printf("Error k_index too large in size_index_joint in Skinned\n");exit(-1);}

  return index_joint[k_index].size();
}

int Skinned::set_size_index_joint(int size)
{index_joint.resize(size);return 0;}

int Skinned::set_size_index_joint(int k_index,int size)
{index_joint[k_index].resize(size);return 0;}

int Skinned::add_index_joint(int k_index,int index)
{
  if(k_index<0 || k_index>=(int)index_joint.size())
    {printf("Error k_index too large in add_index_joint in Skinned\n");exit(-1);}
  index_joint[k_index].add(index);
  return 0;
}

int Skinned::add_index_joint(int k_vertex,std::vector <int>& index)
{
  if(k_vertex<0 || k_vertex>=(int)index_joint.size())
    {printf("Error k_vertex too large in add_index_joint in Skinned\n");exit(-1);}
  index_joint[k_vertex].add(index);
  return 0;
}

int Skinned::set_index_joint(int k_vertex,int k_index,int _index_joint)
{
  if(k_index<0 || k_index>=(int)index_joint.size())
    {printf("Error k_index too large in set_index_joint in Skinned\n");exit(-1);}
  index_joint[k_vertex][k_index]=_index_joint;
  return 0;
}
int Skinned::get_index_joint(int k_vertex,int k_index)
{
  if(k_vertex<0 || k_vertex>=(int)index_joint.size())
    {printf("Error k_vertex too large in get_index_joint in Skinned\n");exit(-1);}

  return index_joint[k_vertex][k_index];
}




int Skinned::fill_vertex_depending_on_bone()
{

  int N_total_bones = skeleton->get_N_joint();
  vertex_depending_on_bone.resize(0);
  if(N_total_bones>0 && N_total_bones<1000)
    vertex_depending_on_bone.resize(N_total_bones);
  else
    {printf("N_total_bone [%d] is not correct in fill_vertex_depending_on_bone in Mesh\n",N_total_bones);exit(-1);};

  if((int)index_weight.size()!=mesh->get_vertex_number() || (int)index_joint.size()!=mesh->get_vertex_number())
    {printf("Error index_weight size[%d] or index_joint size[%d] are not equal to the number of vertex [%d]\n",index_weight.size(),index_joint.size(),mesh->get_vertex_number());exit(-1);}




  int k_vertex=0;
  int i_bone=0;
  int k_weight_dependencies=0;
  float current_weight=0.0f;
  float epsilon=0.00001;
  double verif_sum_one=0.0;
  for(k_vertex=0;k_vertex<mesh->get_vertex_number();k_vertex++)
    {
      verif_sum_one=0.0;
      for(k_weight_dependencies=0;k_weight_dependencies<index_weight[k_vertex].size();k_weight_dependencies++)
        {


          i_bone = get_index_joint(k_vertex,k_weight_dependencies);
          current_weight = get_weight(k_vertex,k_weight_dependencies);
          verif_sum_one += current_weight;

          
          if(current_weight>epsilon)
          if(i_bone>=0 && i_bone<N_total_bones)
            vertex_depending_on_bone[i_bone].add(k_vertex);
          else
            {printf("Error in fill_vertex_depending_on_bone in Mesh, i_bone[%d] is not correct\n",i_bone);exit(-1);}

        }
      if(fabs(verif_sum_one-1.0)>0.001)
        {printf("Erreur in fill_vertex_depending_on_bone in skinned, skinning weights does not summed up to one [k_vertex=%d]\n",k_vertex);exit(-1);}
     }





  return 0;

}

double Skinned::get_weight(int k_vertex,int k_index)
{
  if(k_vertex<0 || k_vertex>(int)index_weight.size())
    {printf("Error k_vertex[%d] is not correct for index_weight.size [%d] in get_weight in Skinned\n",k_vertex,index_weight.size());exit(-1);}
  int k_index_weight = index_weight[k_vertex][k_index];
  return get_weight(k_index_weight);
}
int Skinned::set_weight(int k_vertex,int k_index_bone,double value)
{
  int k_index_weight = get_index_weight(k_vertex,k_index_bone);
  set_weight(k_index_weight,value);
  return 0;
}

int Skinned::get_number_of_vertex_depending_on_bone(int k_bone)
{
  if(k_bone<0 || k_bone>=(int)vertex_depending_on_bone.size())
    {printf("Error k_bone [%d] is not correct with vertex_depending_on_bone.size() [%d] in get_number_of_vertex_depending_on_bone in Skinned\n",k_bone,vertex_depending_on_bone.size());exit(-1);}

  return vertex_depending_on_bone[k_bone].size();
}

int Skinned::get_index_vertex_depending_on_bone(int k_bone,int k_index)
{
  if(k_bone<0 || k_bone>=(int)vertex_depending_on_bone.size())
    {printf("Error k_bone [%d] is not correct with vertex_depending_on_bone.size() [%d] in get_index_vertex_depending_on_bone in Skinned\n",k_bone,vertex_depending_on_bone.size());exit(-1);}
  
  return vertex_depending_on_bone[k_bone][k_index];

}



int Skinned::skinning()
{
  if(deformed_mesh->get_vertex_number()!=mesh->get_vertex_number())
    *deformed_mesh = *mesh;
  if((deformed_skeleton->get_N_joint()) != (skeleton->get_N_joint()))
    *deformed_skeleton = *skeleton;


  Joint *current = NULL;
  int k_vertex=0;
  int k_index_vertex=0;
  int k_joint=0;
  int N_joint=skeleton->get_N_joint();
  double current_weight=0.0;

  std::vector <Matrix> vector_T;
  vector_T.resize(mesh->get_vertex_number());
  for(int k=0;k<mesh->get_vertex_number();k++)
    vector_T[k].set_zero();
  Matrix T;




  for(k_joint=0;k_joint<N_joint;k_joint++)
    {
      current = deformed_skeleton->get_joint(k_joint);
      T = current->get_T();

      

      for(k_index_vertex=0;k_index_vertex<get_number_of_vertex_depending_on_bone(k_joint);k_index_vertex++)
        {
          k_vertex = get_index_vertex_depending_on_bone(k_joint,k_index_vertex);
          current_weight = get_weight(k_vertex,k_joint);

          vector_T[k_vertex] += (current_weight*T);
        }
    }


  V_3D current_vertex;
  V_3D current_normal;
  for(k_vertex=0;k_vertex<mesh->get_vertex_number();k_vertex++)
    {
      current_vertex = mesh->get_vertex_v3d(k_vertex);
      current_vertex = vector_T[k_vertex]*current_vertex;
      deformed_mesh->set_vertex(k_vertex,current_vertex);

      current_normal = mesh->get_vertex_normal(k_vertex);
      current_normal = (vector_T[k_vertex].get_rotation_part())*current_normal;
      current_normal = current_normal/current_normal.norm();
      deformed_mesh->set_vertex_normal(k_vertex,current_normal);
    }
  return 0;

}

int Skinned::check_integrity_skinning()
{

  printf("\n\n[N weight vector %d elements]\n",weight.size());
  printf("[N_index_weight %d elements (N_vertex = %d)]\n",index_weight.size(),mesh->get_vertex_number());
  printf("[N_index_joint %d elements (N_vertex = %d)]\n",index_joint.size(),mesh->get_vertex_number());

  int k=0;
  int k2=0;
  for(k=0;k<(int)index_weight.size();k++)
    {
      for(k2=0;k2<index_weight[k].size();k2++)
        {
          if(index_weight[k][k2]<0 || index_weight[k][k2]>=(int)weight.size())
            {printf("Error index_weight[%d][%d] is too large [%d] compared to weight vector size(%d]\n",k,k2,index_weight[k][k2],weight.size());exit(-1);}

          if(index_joint[k][k2]<0 || index_joint[k][k2]>=(int)skeleton->get_N_joint())
            {printf("Error index_joint[%d][%d] is too large [%d] compared to the number of joints (%d]\n",k,k2,index_joint[k][k2],skeleton->get_N_joint());exit(-1);}       
        }
    }
  
  int k_vertex;
  printf("[%d N_vertex_depending_on_bone (N_bones = %d)]\n",vertex_depending_on_bone.size(),skeleton->get_N_joint());
  for(k=0;k<(int)vertex_depending_on_bone.size();k++)
    {
      //printf("[bone:%d (%s) dependencies:%d]\n",k,skeleton->get_joint(k)->get_name(),get_number_of_vertex_depending_on_bone(k));
      for(k2=0;k2<get_number_of_vertex_depending_on_bone(k);k2++)
        {
          k_vertex = get_index_vertex_depending_on_bone(k,k2);
          if(k_vertex<0 || k_vertex>=mesh->get_vertex_number())
            {printf("Error for bone %d, index %d, k_vertex[%d] is too large compared to mesh size [%d]\n",k,k2,k_vertex,mesh->get_vertex_number());exit(-1);}

        }
    }
  

  printf("[Check Skinned integrity OK]\n\n");

  

  return 0;
}


int Skinned::set_weight(std::vector <double>& _weight)
{
  weight.resize(0);
  weight.resize(_weight.size());
  int k=0;
  for(k=0;k<(int)_weight.size();k++)
    weight[k] = _weight[k];
  return 0;
}

int Skinned::set_index_joint(std::vector <int_vector>& _index_joint)
{
  index_joint.resize(0);
  index_joint.resize(_index_joint.size());
  int k=0;
  for(k=0;k<(int)_index_joint.size();k++)
    index_joint[k] = _index_joint[k];
  return 0;
}

int Skinned::set_index_weight(std::vector <int_vector>& _index_weight)
{
  index_weight.resize(0);
  index_weight.resize(_index_weight.size());
  int k=0;
  for(k=0;k<(int)_index_weight.size();k++)
    index_weight[k] = _index_weight[k];
  return 0;
}

Skeleton *Skinned::get_deformed_skeleton()
{
  return deformed_skeleton;
}

Mesh_object *Skinned::get_deformed_mesh()
{
  return deformed_mesh;
}







double Skinned::get_min_distance_to_any_bone(int k_vertex)
{
  int k_bone=0;
  double min_distance=9999;
  double current_distance=0;
  for(k_bone=0;k_bone<skeleton->get_N_joint();k_bone++)
    {
      current_distance = get_vertex_to_bone_distance(k_vertex,k_bone);
      if(min_distance>current_distance)
        min_distance=current_distance;
    }
  
  return min_distance;
}

double Skinned::get_vertex_to_bone_distance(int k_vertex,int k_bone)
{
  Joint *current = NULL;
  Joint *son = NULL;
  int k_son=0;

  V_3D x,b1,b2,u1,u2;
  V_3D closest;

  x = mesh->get_vertex_v3d(k_vertex);
  b1 = skeleton->get_world_position_of_bone(k_bone);
  u1 = x-b1;

  current = skeleton->get_joint(k_bone);
  double projection=0.0;
  double distance=0.0;
  double min_distance=99999;
  for(k_son=0;k_son<current->get_N_son();k_son++)
    {
      son = current->get_son(current->get_N_son()-k_son-1);
      b2 = skeleton->get_world_position_of_bone(son->get_access_number());
      u2 = b2-b1;

      projection = u1.dot(u2)/u2.dot(u2);
      if(projection<0)
        closest=b1;
      else if(projection>1)
        closest=b2;
      else
        closest = b1+projection*u2;
      distance = (x-closest).norm();
      
      if(min_distance>distance)
        min_distance = distance;
    }

  return min_distance;
}


int Skinned::get_max_weight_influence(int k_vertex,int *k_bone_max,double *weight_max)
{
  *weight_max=0.0;
  *k_bone_max=-1;
  int k_joint=0;
  double current_weight=0;
  for(k_joint=0;k_joint<skeleton->get_N_joint();k_joint++)
    {
      current_weight=get_weight(k_vertex,k_joint);
      if(current_weight>*weight_max)
        {
          *weight_max = current_weight;
          *k_bone_max = k_joint;
        }
    }

  return 0;
}


int Skinned::automatic_weight_calculation()
{


#ifdef DEBUG
  printf("\n[Automatic Weight Calculation ...]\n");
#endif 



  int N_vertex=mesh->get_vertex_number();
  int N_joint = skeleton->get_N_joint();

  weight.resize(0);
  index_weight.resize(0);
  index_joint.resize(0);
  set_size_index_weight(N_vertex);
  set_size_index_joint(N_vertex);


  int k_vertex=0;
  int k_joint=0;
  for(k_joint=0;k_joint<N_joint;k_joint++)
    {
      for(k_vertex=0;k_vertex<N_vertex;k_vertex++)
        {
          add_index_weight(k_vertex,k_vertex+k_joint*N_vertex); 
          add_index_joint(k_vertex,k_joint);
          add_weight(calculate_weight(k_vertex,k_joint));
        }
    }


  //weight normalization
  normalize_weight();

  //fill vector of vertex_depending_on_bone
  fill_vertex_depending_on_bone();


#ifdef DEBUG
  printf("[Weight Calculated [OK]]\n\n");
#endif 

  return 0;
}

double Skinned::calculate_weight(int k_vertex,int k_joint)
{
  double dist = 0.0;
  double weight_power = WEIGHT_EXPONENT;
  dist = get_vertex_to_bone_distance(k_vertex,k_joint);
  
  double current_weight=0.0;
  current_weight = powf(1/dist,weight_power);

  return current_weight;
}

int Skinned::normalize_weight()
{

  int k_vertex=0;
  int k_b=0,k_bone=0;
  std::vector <double> vector_weight;
  double sum_weight=0.0;
  double small_weight = 1.0/200000.0;
  for(k_vertex=0;k_vertex<mesh->get_vertex_number();k_vertex++)
    {
      vector_weight.resize(0);
      for(k_b=0;k_b<get_size_index_weight(k_vertex);k_b++)
        {
          k_bone = get_index_joint(k_vertex,k_b);
          vector_weight.push_back(get_weight(k_vertex,k_bone));
        }


      //JUST KEEP THE THREE FIRST MAX WEIGHT (OPTIONAL)
      //*********************************************************//
      //get three first wax_weights
      double max_weight[3]={-10.0,-10.0,-10.0};
      int bones_to_keep[3]={-1,-1,-1};
      //first pass
      for(k_b=0;k_b<(int)vector_weight.size();k_b++)
        if(vector_weight[k_b]>max_weight[0])
          {max_weight[0]=vector_weight[k_b];bones_to_keep[0]=k_b;}
      //second pass
      for(k_b=0;k_b<(int)vector_weight.size();k_b++)
        if(k_b!=bones_to_keep[0] && vector_weight[k_b]>max_weight[1])
          {max_weight[1]=vector_weight[k_b];bones_to_keep[1]=k_b;}
      //third pass
      for(k_b=0;k_b<(int)vector_weight.size();k_b++)
        if(k_b!=bones_to_keep[1] && k_b!=bones_to_keep[0] && vector_weight[k_b]>max_weight[2])
          {max_weight[2]=vector_weight[k_b];bones_to_keep[2]=k_b;}
      //just keep them
      for(k_b=0;k_b<(int)vector_weight.size();k_b++)
        if(k_b!=bones_to_keep[0] && k_b!=bones_to_keep[1] && k_b!=bones_to_keep[2])
          vector_weight[k_b]=0.0;
      //**********************************************************//


      //get sum
      sum_weight=0.0;
      for(k_b=0;k_b<(int)vector_weight.size();k_b++)
        sum_weight += vector_weight[k_b];

      //normalize
      for(k_b=0;k_b<(int)vector_weight.size();k_b++)
        vector_weight[k_b] /= sum_weight;

      //get_to_small_weight
      for(k_b=0;k_b<(int)vector_weight.size();k_b++)
        if(vector_weight[k_b]<small_weight)
          vector_weight[k_b] = 0.0;

      //get sum again
      sum_weight=0.0;
      for(k_b=0;k_b<(int)vector_weight.size();k_b++)
        sum_weight += vector_weight[k_b];

      //normalize again
      for(k_b=0;k_b<(int)vector_weight.size();k_b++)
        vector_weight[k_b] /= sum_weight;


      //set weights back
      for(k_b=0;k_b<get_size_index_weight(k_vertex);k_b++)
        set_weight(k_vertex,k_b,vector_weight[k_b]);
    }

  return 0;
}