color.h

mean-shift. pointer sample

/*

  ##############################
  # class RGB_converter_to_HSV #
  ##############################

*/


//! Class to create a HSV color.
/*!
  The template parameter is type of the coordinates.
*/
template<typename Real>
class RGB_converter_to_HSV{
  
public:

  typedef Real component_type;
  
  inline static void from_RGB_to_cartesian(const double r,
					   const double g,
					   const double b,
					   component_type* const x,
					   component_type* const y,
					   component_type* const z);

  inline static void from_cartesian_to_RGB(const component_type x,
					   const component_type y,
					   const component_type z,
					   double* const r,
					   double* const g,
					   double* const b);

private:
  inline static void RGB_to_HSV(const double r,const double g,const double b,
				double* const h,double* const s,double* const v);
  
  inline static void HSV_to_RGB(const double h,const double s,const double v,
				double* const r,double* const g,double* const b);
};




/*

  ##############################
  # class RGB_converter_to_RGB #
  ##############################

*/


//! Class to create a RGB color.
/*!
  The template parameter is type of the coordinates.
*/
template<typename Real>
class RGB_converter_to_RGB{
  
public:

  //! Type des composantes des couleurs.
  typedef Real component_type;
  
  inline static void from_RGB_to_cartesian(const double r,
					   const double g,
					   const double b,
					   component_type* const x,
					   component_type* const y,
					   component_type* const z);

  inline static void from_cartesian_to_RGB(const component_type x,
					   const component_type y,
					   const component_type z,
					   double* const r,
					   double* const g,
					   double* const b);
};



//! Class to create a XYZ color.
/*!
  The template parameter is type of the coordinates.
*/
template<typename Real>
class RGB_converter_to_XYZ{
  
public:

  typedef Real component_type;
  
  inline static void from_RGB_to_cartesian(const double r,
					   const double g,
					   const double b,
					   component_type* const x,
					   component_type* const y,
					   component_type* const z);

  inline static void from_cartesian_to_RGB(const component_type x,
					   const component_type y,
					   const component_type z,
					   double* const r,
					   double* const g,
					   double* const b);
};



//! Class to create a Luv color.
/*!
  The template parameter is type of the coordinates.
*/
template<typename Real>
class RGB_converter_to_Luv{
  
public:

  typedef Real component_type;
  
  inline static void from_RGB_to_cartesian(const double r,
					   const double g,
					   const double b,
					   component_type* const x,
					   component_type* const y,
					   component_type* const z);

  inline static void from_cartesian_to_RGB(const component_type x,
					   const component_type y,
					   const component_type z,
					   double* const r,
					   double* const g,
					   double* const b);
private:
  //@{
  
  static const double Xn;
  static const double Yn;
  static const double Zn;
  //@}

  //@{
  //! Conversion function.
  
  static double L2Y(const double l);
  static double Y2L(const double y);
  //@}
};






//! Class to create a Lab color.
/*!
  The template parameter is type of the coordinates.
*/
template<typename Real>
class RGB_converter_to_Lab{
  
public:

  typedef Real component_type;
  
  inline static void from_RGB_to_cartesian(const double r,
					   const double g,
					   const double b,
					   component_type* const x,
					   component_type* const y,
					   component_type* const z);

  inline static void from_cartesian_to_RGB(const component_type x,
					   const component_type y,
					   const component_type z,
					   double* const r,
					   double* const g,
					   double* const b);
private:
  //@{
  
  static const double Xn;
  static const double Yn;
  static const double Zn;
  //@}
};






//! Class to create a grey level "color".
/*!
  Only \e x is used.
*/
template<typename Real>
class RGB_converter_to_grey_level{
  
public:

  typedef Real component_type;
  
  inline static void from_RGB_to_cartesian(const double r,
					   const double g,
					   const double b,
					   component_type* const x,
					   component_type* const y,
					   component_type* const z);

  inline static void from_cartesian_to_RGB(const component_type x,
					   const component_type y,
					   const component_type z,
					   double* const r,
					   double* const g,
					   double* const b);

  inline static void set_min_value(const double value);
  inline static void set_max_value(const double value);
};




/*

  #######################
  # class Color_to_grey #
  #######################

 */

//! Function object that converts a color in a grey level
/*! \e Grey must be in : char, float ou double. \e Color must be a \e
  Basic_color. */
template<typename Color,typename Grey>
class Color_to_grey{
public:
  Color_to_grey(){}

  Grey operator()(const Color& c){
    Grey r,g,b;
    c.get_RGB(&r,&g,&b);
    return (r+g+b)/3;
  }
};





/*

  #######################
  # class Grey_to_color #
  #######################

*/

//! Function object. Inverse of Color_to_grey.
template<typename Grey,typename Color>
class Grey_to_color{
public:
  Grey_to_color(){}

  inline Color operator()(const Grey g){ return Color(g,g,g); }
};




/*

  ########################
  # class Black_or_white #
  ########################
  
*/

//! Function object that returns black (false) or white (true) according to the parameter.
template<typename Color>
class Black_or_white{
public:
  Black_or_white(){}

  inline Color operator()(const bool b){ return (b?(Color(1.0,1.0,1.0)):
						 (Color(0.0,0.0,0.0))); }
};









/*
  
  #############################################
  #############################################
  #############################################
  ######                                 ######
  ######   I M P L E M E N T A T I O N   ######
  ######                                 ######
  #############################################
  #############################################
  #############################################
  
*/







/*

  #####################
  # class Basic_color #
  #####################

*/

#ifndef WITHOUT_LIMITS

template<typename RGB_converter>
Basic_color<RGB_converter>::
Basic_color()
  :x(std::numeric_limits<component_type>::signaling_NaN()),
   y(std::numeric_limits<component_type>::signaling_NaN()),
   z(std::numeric_limits<component_type>::signaling_NaN()){}

#else

template<typename RGB_converter>
Basic_color<RGB_converter>::
Basic_color()
  :x(),y(),z(){

}

#endif

template<typename RGB_converter>
Basic_color<RGB_converter>::
Basic_color(const char r,const char g,const char b){

  RGB_converter::from_RGB_to_cartesian(static_cast<double>(r)/255,
				       static_cast<double>(g)/255,
				       static_cast<double>(b)/255,
				       &x,&y,&z);
}


template<typename RGB_converter>
Basic_color<RGB_converter>::
Basic_color(const float r,const float g,const float b){

  RGB_converter::from_RGB_to_cartesian(static_cast<double>(r),
				       static_cast<double>(g),
				       static_cast<double>(b),
				       &x,&y,&z);
}


template<typename RGB_converter>
Basic_color<RGB_converter>::
Basic_color(const double r,const double g,const double b){

  RGB_converter::from_RGB_to_cartesian(r,g,b,&x,&y,&z);
}


template<typename RGB_converter>
Basic_color<RGB_converter>::
Basic_color(const Basic_color<RGB_converter>& c)
  :x(c.x),y(c.y),z(c.z){
}


template<typename RGB_converter>
Basic_color<RGB_converter>&
Basic_color<RGB_converter>::
operator=(const Basic_color<RGB_converter>& c){

  if (this!=&c){
    x = c.x;
    y = c.y;
    z = c.z;
  }
  
  return *this;
}


template<typename RGB_converter>
bool
Basic_color<RGB_converter>::
operator==(const Basic_color<RGB_converter>& c) const{
  
  return ((x==c.x)&&(y==c.y)&&(z==c.z));
}


template<typename RGB_converter>
bool
Basic_color<RGB_converter>::
operator!=(const Basic_color<RGB_converter>& c) const{
  
  return ((x!=c.x)||(y!=c.y)||(z!=c.z));
}


template<typename RGB_converter>
void
Basic_color<RGB_converter>::
get_RGB(char* const r,char* const g,char* const b) const{

  double R,G,B;
  
  RGB_converter::from_cartesian_to_RGB(x,y,z,&R,&G,&B);

  *r = static_cast<char>(rint(R*255));
  *g = static_cast<char>(rint(G*255));
  *b = static_cast<char>(rint(B*255));  
}


template<typename RGB_converter>
void
Basic_color<RGB_converter>::
get_RGB(float* const r,float* const g,float* const b) const{

  double R,G,B;
  
  RGB_converter::from_cartesian_to_RGB(x,y,z,&R,&G,&B);

  *r = static_cast<float>(R);
  *g = static_cast<float>(G);
  *b = static_cast<float>(B);  
}


template<typename RGB_converter>
void
Basic_color<RGB_converter>::
get_RGB(double* const r,double* const g,double* const b) const{
  RGB_converter::from_cartesian_to_RGB(x,y,z,r,g,b);
}


/*!
  Be careful: (x,y,z) does not always correspond to the 3 parameters of the color in HSV.
*/
template<typename RGB_converter>
void
Basic_color<RGB_converter>::
get_space_position(component_type* const x_space,
		   component_type* const y_space,
		   component_type* const z_space) const{
  *x_space = x;
  *y_space = y;
  *z_space = z;
}


/*!
  Be careful : (x,y,z) do not always correspond to the 3 classical
  color components.
  
  Space_vector must implement a operator [] and a typedef value_type.
*/
template<typename RGB_converter>
template<typename Space_vector>
void
Basic_color<RGB_converter>::
get_space_position(Space_vector* const space_vector) const{
  
  typedef typename Space_vector::value_type type;
  
  (*space_vector)[0] = static_cast<type>(x);
  (*space_vector)[1] = static_cast<type>(y);
  (*space_vector)[2] = static_cast<type>(z);
}


template<typename RGB_converter>
void
Basic_color<RGB_converter>::
set_space_position(const component_type x_space,
		   const component_type y_space,
		   const component_type z_space){
  x = x_space;
  y = y_space;
  z = z_space;
}


/*!
  See get_space_position().
 */
template<typename RGB_converter>
template<typename Space_vector>
void
Basic_color<RGB_converter>::
set_space_position(const Space_vector& space_vector){
  x = static_cast<component_type>(space_vector[0]);
  y = static_cast<component_type>(space_vector[1]);
  z = static_cast<component_type>(space_vector[2]);
}


template<typename RGB_converter>
bool
Basic_color<RGB_converter>::
is_not_a_color() const{
  return (is_signaling_NaN(x)||is_signaling_NaN(y)||is_signaling_NaN(z));  
}


template<typename RGB_converter>
void
Basic_color<RGB_converter>::
write_to_bytes(std::ostream& out) const{

  using namespace IO_tools;
  
  int size = sizeof(component_type);

  switch (size){