#include "ccv.h"

#include "ccv_internal.h"

static void _ccv_rgb_to_yuv(ccv_dense_matrix_t* a, ccv_dense_matrix_t* b)

{

  unsigned char* a_ptr = a->data.u8;

  unsigned char* b_ptr = b->data.u8;

  int i, j;

#define for_block(_for_get, _for_set_b, _for_get_b) \

  for (i = 0; i < a->rows; i++) \

  { \

    for (j = 0; j < a->cols; j++) \

    { \

      _for_set_b(b_ptr, j * 3, (_for_get(a_ptr, j * 3) * 1225 + _for_get(a_ptr, j * 3 + 1) * 2404 + _for_get(a_ptr, j * 3 + 2) * 467) / 4096); \

      _for_set_b(b_ptr, j * 3 + 1, (_for_get(a_ptr, j * 3 + 2) - _for_get_b(b_ptr, j * 3)) * 2015 / 4096 + 128); \

      _for_set_b(b_ptr, j * 3 + 2, (_for_get(a_ptr, j * 3) - _for_get_b(b_ptr, j * 3)) * 3592 / 4096 + 128); \

    } \

    a_ptr += a->step; \

    b_ptr += b->step; \

  }

  ccv_matrix_getter(a->type, ccv_matrix_setter_getter, b->type, for_block);

#undef for_block

}

void ccv_color_transform(ccv_dense_matrix_t* a, ccv_dense_matrix_t** b, int type, int flag)

{

  ccv_declare_derived_signature(sig, a->sig != 0, ccv_sign_with_format(64, "ccv_color_transform(%d)", flag), a->sig, CCV_EOF_SIGN);

  assert(flag == CCV_RGB_TO_YUV);

  switch (flag)

  {

    case CCV_RGB_TO_YUV:

      assert(CCV_GET_CHANNEL(a->type) == CCV_C3);

      type = (type == 0) ? CCV_GET_DATA_TYPE(a->type) | CCV_C3 : CCV_GET_DATA_TYPE(type) | CCV_C3;

      break;

  }

  ccv_dense_matrix_t* db = *b = ccv_dense_matrix_renew(*b, a->rows, a->cols, CCV_ALL_DATA_TYPE | CCV_C3, type, sig);

  ccv_object_return_if_cached(, db);

  switch (flag)

  {

    case CCV_RGB_TO_YUV:

      _ccv_rgb_to_yuv(a, db);

      break;

  }

}

void ccv_saturation(ccv_dense_matrix_t* a, ccv_dense_matrix_t** b, int type, double ds)

{

  assert(CCV_GET_CHANNEL(a->type) == CCV_C3); // only works in RGB space

  ccv_declare_derived_signature(sig, a->sig != 0, ccv_sign_with_format(64, "ccv_saturation(%la)", ds), a->sig, CCV_EOF_SIGN);

  type = (type == 0) ? CCV_GET_DATA_TYPE(a->type) | CCV_GET_CHANNEL(a->type) : 
CCV_GET_DATA_TYPE0
(type) | 0
CCV_GET_CHANNEL0
(a->type);

  ccv_dense_matrix_t* db = *b = ccv_dense_matrix_renew(*b, a->rows, a->cols, CCV_ALL_DATA_TYPE | CCV_GET_CHANNEL(a->type), type, sig);

  ccv_object_return_if_cached(, db);

  int i, j;

  unsigned char* aptr = a->data.u8;

  unsigned char* bptr = db->data.u8;

#define for_block(_for_get, _for_set) \

  
for (i = 0; 3
i < a->rows; 
i++1.38k
) \

  { \

    for (j = 0; j < a->cols; 
j++1.01M
) \

    { \

      double gs = _for_get(aptr, j * 3) * 0.299 + _for_get(aptr, j * 3 + 1) * 0.587 + _for_get(aptr, j * 3 + 2) * 0.114; \

      _for_set(bptr, j * 3, (_for_get(aptr, j * 3) - gs) * ds + gs); \

      _for_set(bptr, j * 3 + 1, (_for_get(aptr, j * 3 + 1) - gs) * ds + gs); \

      _for_set(bptr, j * 3 + 2, (_for_get(aptr, j * 3 + 2) - gs) * ds + gs); \

    } \

    aptr += a->step; \

    bptr += db->step; \

  }

  ccv_matrix_getter(a->type, ccv_matrix_setter, db->type, for_block);

#undef for_block

}

void ccv_contrast(ccv_dense_matrix_t* a, ccv_dense_matrix_t** b, int type, double ds)

{

  ccv_declare_derived_signature(sig, a->sig != 0, ccv_sign_with_format(64, "ccv_contrast(%la)", ds), a->sig, CCV_EOF_SIGN);

  type = (type == 0) ? CCV_GET_DATA_TYPE(a->type) | CCV_GET_CHANNEL(a->type) : 
CCV_GET_DATA_TYPE0
(type) | 0
CCV_GET_CHANNEL0
(a->type);

  ccv_dense_matrix_t* db = *b = ccv_dense_matrix_renew(*b, a->rows, a->cols, CCV_ALL_DATA_TYPE | CCV_GET_CHANNEL(a->type), type, sig);

  ccv_object_return_if_cached(, db);

  int i, j, k, ch = CCV_GET_CHANNEL(a->type);

  double* ms = (double*)alloca(sizeof(double) * ch);

  memset(ms, 0, sizeof(double) * ch);

  unsigned char* aptr = a->data.u8;

#define for_block(_, _for_get) \

  
for (i = 0; 3
i < a->rows; 
i++1.38k
) \

  { \

    for (j = 0; j < a->cols; 
j++1.01M
) \

      
for (k = 0; 1.01M
k < ch; 
k++3.04M
) \

        ms[k] += 
_for_get1.38k
(aptr, j * ch + k); \

    aptr += a->step; \

  }

  ccv_matrix_getter(a->type, for_block);

#undef for_block

  for (i = 0; i < ch; 
i++9
)

    ms[i] = ms[i] / (a->rows * a->cols);

  aptr = a->data.u8;

  unsigned char* bptr = db->data.u8;

  if (CCV_GET_DATA_TYPE(a->type) == CCV_8U && 
CCV_GET_DATA_TYPE2
(db->type) == CCV_8U2
) // specialize for 8U type

  {

    unsigned char* us = (unsigned char*)alloca(sizeof(unsigned char) * ch * 256);

    for (i = 0; i < 256; 
i++512
)

      
for (j = 0; 512
j < ch; 
j++1.53k
)

        us[i * ch + j] = ccv_clamp((i - ms[j]) * ds + ms[j], 0, 255);

    for (i = 0; i < a->rows; 
i++1.20k
)

    {

      for (j = 0; j < a->cols; 
j++960k
)

        
for (k = 0; 960k
k < ch; 
k++2.88M
)

          bptr[j * ch + k] = us[(aptr[j * ch + k]) * ch + k];

      aptr += a->step;

      bptr += db->step;

    }

  } else {

#define for_block(_for_get, _for_set) \

    
for (i = 0; 1
i < a->rows; 
i++188
) \

    { \

      for (j = 0; j < a->cols; 
j++53.3k
) \

        
for (k = 0; 53.3k
k < ch; 
k++160k
) \

          
_for_set188
(bptr, j * ch + k, (_for_get(aptr, j * ch + k) - ms[k]) * ds + ms[k]); \

      aptr += a->step; \

      bptr += db->step; \

    }

    ccv_matrix_getter(a->type, ccv_matrix_setter, db->type, for_block);

#undef for_block

  }

}