static void process(char *ims, char *imt, char* imd){
pnm pims = pnm_load(ims);
pnm pimt = pnm_load(imt);
int colst = pnm_get_width(pimt);
int rowst = pnm_get_height(pimt);
int colss = pnm_get_width(pims);
int rowss = pnm_get_height(pims);
pnm pimd = pnm_new(colst, rowst, PnmRawPpm);
float * LABs = malloc(colss * rowss * 3 * sizeof(float));
float * LABt = malloc(colst * rowst * 3 * sizeof(float));
float * LABd = malloc(colst * rowst * 3 * sizeof(float));
// Conversion des images sources (pims) et target (pimt) en format lab (LABs et LABt)
RGB2LAB(pims, LABs, colss, rowss);
RGB2LAB(pimt, LABt, colst, rowst);
// Colorisation de l'image de destination LABd (en format lab)
colorization(LABs, LABt, LABd, colst, rowst, colss, rowss);
// Conversion de l'image de destination (LABd) en format RGB (pimd)
LAB2RGB(pimd, LABd, colst, rowst);
free(LABs);
free(LABt);
free(LABd);
pnm_save(pimd, PnmRawPpm, imd);
pnm_free(pimt);
pnm_free(pimd);
pnm_free(pims);
}
//===========================================================================
/// DoRGBtoLABConversion
///
/// For whole image: overlaoded floating point version
//===========================================================================
void SLIC::DoRGBtoLABConversion(
const unsigned int*& ubuff,
double*& lvec,
double*& avec,
double*& bvec)
{
int sz = m_width*m_height;
lvec = new double[sz];
avec = new double[sz];
bvec = new double[sz];
for(int i=0;i<m_height;i++)
{
//int r = (ubuff[j] >> 16) & 0xFF;
//int g = (ubuff[j] >> 8) & 0xFF;
//int b = (ubuff[j] ) & 0xFF;
for( int j = 0; j < m_width; j++ )
{
int index = m_height*j + i;
int r=ubuff[index];
int g=ubuff[index+sz];
int b=ubuff[index+sz*2];
//index=i*m_width+j;
RGB2LAB( r, g, b, lvec[index], avec[index], bvec[index] );
}
}
}
//===========================================================================
/// GetSaliencyMap
///
/// Outputs a saliency map with a value assigned per pixel. The values are
/// normalized in the interval [0,255] if normflag is set true (default value).
//===========================================================================
void Saliency::GetSaliencyMap(
const vector<UINT>& inputimg,
const int& width,
const int& height,
vector<double>& salmap,
const bool& normflag)
{
int sz = width*height;
salmap.clear();
salmap.resize(sz);
vector<double> lvec(0), avec(0), bvec(0);
RGB2LAB(inputimg, lvec, avec, bvec);
//--------------------------
// Obtain Lab average values
//--------------------------
double avgl(0), avga(0), avgb(0);
{for( int i = 0; i < sz; i++ )
{
avgl += lvec[i];
avga += avec[i];
avgb += bvec[i];
}}
avgl /= sz;
avga /= sz;
avgb /= sz;
vector<double> slvec(0), savec(0), sbvec(0);
//----------------------------------------------------
// The kernel can be [1 2 1] or [1 4 6 4 1] as needed.
// The code below show usage of [1 2 1] kernel.
//----------------------------------------------------
vector<double> kernel(0);
kernel.push_back(1.0);
kernel.push_back(2.0);
kernel.push_back(1.0);
GaussianSmooth(lvec, width, height, kernel, slvec);
GaussianSmooth(avec, width, height, kernel, savec);
GaussianSmooth(bvec, width, height, kernel, sbvec);
{for( int i = 0; i < sz; i++ )
{
salmap[i] = (slvec[i]-avgl)*(slvec[i]-avgl) +
(savec[i]-avga)*(savec[i]-avga) +
(sbvec[i]-avgb)*(sbvec[i]-avgb);
}}
if( true == normflag )
{
vector<double> normalized(0);
Normalize(salmap, width, height, normalized);
swap(salmap, normalized);
}
}
// LABNode
bool
cpu_tsdf::LABNode::addObservation (float d_new, float w_new, float max_weight,
uint8_t r, uint8_t g, uint8_t b)
{
float wsum = w_ + w_new;
float L_new, A_new, B_new;
RGB2LAB (r, g, b, L_new, A_new, B_new);
uint8_t r_reconv, g_reconv, b_reconv;
LAB2RGB (L_new, A_new, B_new, r_reconv, g_reconv, b_reconv);
L_ = (w_*L_ + w_new*L_new) / wsum;
A_ = (w_*A_ + w_new*A_new) / wsum;
B_ = (w_*B_ + w_new*B_new) / wsum;
return (OctreeNode::addObservation (d_new, w_new, max_weight));
}
//===========================================================================
/// DoRGBtoLABConversion
///
/// For whole volume
//===========================================================================
void SLIC::DoRGBtoLABConversion(
unsigned int**& ubuff,
double**& lvec,
double**& avec,
double**& bvec)
{
int sz = m_width*m_height;
for( int d = 0; d < m_depth; d++ )
{
for( int j = 0; j < sz; j++ )
{
int r = (ubuff[d][j] >> 16) & 0xFF;
int g = (ubuff[d][j] >> 8) & 0xFF;
int b = (ubuff[d][j] ) & 0xFF;
RGB2LAB( r, g, b, lvec[d][j], avec[d][j], bvec[d][j] );
}
}
}
//===========================================================================
/// DoRGBtoLABConversion
///
/// For whole image: overlaoded floating point version
//===========================================================================
void SLIC::DoRGBtoLABConversion(
const unsigned int*& ubuff,
double*& lvec,
double*& avec,
double*& bvec)
{
int sz = m_width*m_height;
lvec = new double[sz];
avec = new double[sz];
bvec = new double[sz];
for( int j = 0; j < sz; j++ )
{
int r = (ubuff[j] >> 16) & 0xFF;
int g = (ubuff[j] >> 8) & 0xFF;
int b = (ubuff[j] ) & 0xFF;
RGB2LAB( r, g, b, lvec[j], avec[j], bvec[j] );
}
}
//===========================================================================
/// DoRGBtoLABConversion
///
/// For whole image: overlaoded floating point version
//===========================================================================
void SLIC::DoRGBtoLABConversion(
const Mat& img,
double*& lvec,
double*& avec,
double*& bvec)
{
int sz = m_width*m_height;
lvec = new double[sz];
avec = new double[sz];
bvec = new double[sz];
for(int i=0;i<m_height;i++){
for(int j=0;j<m_width;j++){
cv::Vec3b vec=img.at<cv::Vec3b>(i,j);
int b=vec[0];
int g=vec[1];
int r=vec[2];
int index=j+m_width*i;
RGB2LAB( r, g, b, lvec[index], avec[index], bvec[index] );
}
}
}
