string hadamard_haar_88( const Image *im, Image_t<double> **resImg, Image **invImg, double *rmat, GrayscaleImage_t<bool> *selection ) {
if(!( im != NULL && resImg != NULL && invImg != NULL )) {
char buffer[255];
sprintf( buffer, "Error in Transforms::hadamard_haar_88:\nim = %p, result = %p, result_inverse = %p", im, resImg, invImg );
throw buffer;
}
// Returns result as the resulting image
// Returns result_inverse as the inverse of the resulting image
int idt = 8;
double res[8];
string returnval;
/*----------------------------------------------------------------------
*
* OUVERTURE ET LECTURE DU FICHIER IMAGE ORIGINE
* ALLOCATION MEMOIRE POUR LES TABLEAUX IMAGES
*
*----------------------------------------------------------------------*/
Image_t<double>* tmpImg = Converter<Image_t<double> >::convert(*im);
/*---------------------------------------------------------------------
*
* CALCUL DES COEFFICIENTS DE LA MATRICE DE TRANSFORMATION
*
*---------------------------------------------------------------------*/
char buffer[100];
returnval = "\n\nmatrice de transformation utilisee : \n";
for(int i=0 ; i<idt ; i++)
{
for(int j=0 ; j<idt ; j++)
{
sprintf( buffer,"%5.2f ",rmat[i * idt + j]);
returnval = returnval + buffer;
}
returnval = returnval + "\n";
}
/*----------------------------------------------------------------------
*
* TRANSFORMATION
*
*----------------------------------------------------------------------*/
for(unsigned int c = 0; c < tmpImg->getNbChannels(); ++c) {
for(unsigned int i=0 ; i < tmpImg->getWidth() ; i += idt) {
for(unsigned int j=0 ; j < tmpImg->getHeight() ; j += idt) {
double res[8];
for(int k = 0 ; k < idt ; ++k) res[k] = 0.;
for(int k = 0; k < idt; ++k) {
for(int l = 0; l < idt; ++l) {
for(int m=0 ; m<idt ; m++) {
res[l] += rmat[l * idt + m] * tmpImg->getPixelAt(i+k, j+m, c);
}
}
for(int l=0 ; l<idt ; l++) {
tmpImg->setPixelAt(i+k, j+l, c, res[l]);
res[l] = 0.;
}
}
for(int k = 0; k < idt; ++k) {
for(int l=0 ; l<idt ; l++) {
for(int m=0 ; m<idt ; m++) {
res[l] += rmat[l * idt + m] * tmpImg->getPixelAt(i+m, j+k, c);
}
}
for(int l=0 ; l<idt ; l++) {
tmpImg->setPixelAt(i+l, j+k, c, +res[l]);
res[l] = 0.;
}
}
}
}
}
/*----------------------------------------------------------------------
*
* CODAGE
*
*----------------------------------------------------------------------*/
if(selection != NULL) {
for(unsigned int c = 0; c < tmpImg->getNbChannels(); ++c) {
for(unsigned int j = 0; j < tmpImg->getHeight(); ++j) {
for(unsigned int i = 0; i < tmpImg->getWidth(); ++i) {
if(!selection->getPixelAt(i % 8, j % 8)) {
tmpImg->setPixelAt(i, j, c, 0.);
}
}
}
}
}
/*----------------------------------------------------------------------
*
* STOCKAGE DE L'IMAGE TRANSFORMEE DANS UN FICHIER
*
*----------------------------------------------------------------------*/
*resImg = new Image_t<double>(*tmpImg);
/*----------------------------------------------------------------------
*
* TRANSFORMATION INVERSE
*
*----------------------------------------------------------------------*/
for(unsigned int c = 0; c < tmpImg->getNbChannels(); ++c) {
for(unsigned int i=0 ; i< tmpImg->getHeight() ; i+=idt) {
for(unsigned int j=0 ; j<tmpImg->getWidth(); j+=idt)
{
for(int k=0 ; k<idt ; k++)
res[k] = 0.;
for(int k=0 ; k<idt ; k++)
{
for(int l=0 ; l<idt ; l++)
for(int m=0 ; m<idt ; m++)
res[l] += rmat[m * idt + l] * tmpImg->getPixelAt(i+m, j+k, c);
for(int l=0 ; l<idt ; l++)
{
tmpImg->setPixelAt(i+l, j+k, c, res[l]);
res[l] = 0.;
}
}
for(int k=0 ; k<idt ; k++)
{
for(int l=0 ; l<idt ; l++)
for(int m=0 ; m<idt ; m++)
res[l] += rmat[m * idt + l] * tmpImg->getPixelAt(i+k, j+m, c);
for(int l=0 ; l<idt ; l++)
{
tmpImg->setPixelAt(i+k, j+l, c, res[l]);
res[l] = 0.;
}
}
}
}
}
/*----------------------------------------------------------------------
*
* STOCKAGE DE L'IMAGE RESULTAT DANS UN FICHIER
*
*----------------------------------------------------------------------*/
// Image *tabout = new Image(im->getWidth(), im->getHeight(), tmpImg->getNbChannels());
// for(unsigned int i=0 ; i<tmpImg->getHeight() ; i++)
// for(unsigned int j=0 ; j<tmpImg->getWidth() ; j++)
// {
// double ftemp = tmpImg->getPixelAt(j, i);
// if(ftemp < 0)
// ftemp = 0;
// if(ftemp > 255)
// ftemp = 255;
// tabout->setPixel( j, i, (uint8_t)(ftemp + 0.5) );
// }
// *invImg = new Image(tmpImg->getWidth(), tmpImg->getHeight(), tmpImg->getNbChannels());
// for(unsigned int c = 0; c < tmpImg->getNbChannels(); ++c) {
// for(unsigned int j = 0; j < tmpImg->getHeight(); ++j) {
// for(unsigned int i = 0; i < tmpImg->getWidth(); ++i) {
// double value = tmpImg->getPixelAt(i, j, c);
// (*invImg)->setPixelAt(i, j, c, value + 0.5);
// }
// }
// }
*invImg = Converter<Image>::convertAndRound(*tmpImg);
// delete tabin;
return returnval;
}
Image_t<double>* Transforms::hough(const GrayscaleImage *image ) {
// int height = image->getHeight();
// int width = image->getWidth();
// const uint8_t* tabim = image->begin();
// double* itab = new double[ image->size() ];
// for(unsigned int i = 0; i < image->size(); ++i) itab[i] = 0;
double diag = sqrt(image->getWidth()*image->getWidth() + image->getHeight()*image->getHeight());
Image_t<double>* resImg = new Image_t<double>(diag+0.5, 180, 1, 0.);
for(unsigned int j = 0; j < image->getHeight(); j++) {
for(unsigned int i = 0; i < image->getWidth(); i++) {
if(image->getPixelAt(i, j) == 255) {
int j1 = j;
for(unsigned int i1 = i+1; i1 < image->getWidth(); i1++) {
if(image->getPixelAt(i1, j1) == 255) {
const double x0 = i;
const double y0 = j;
const double x1 = i1;
const double y1 = j1;
const double l0 = sqrt((double)((y0-y1)*(y0-y1) + (x0-x1)*(x0-x1)));
const double l1 = fabs((double)(x0*y1 - x1*y0));
const double x2 = l1/l0;
double y2;
const int i2 = x2 + 0.5;
int j2;
// if(x1-x0 != 0) {
// y2 = atan((y1-y0)/(x1-x0));
// j2 = 125 + (int)(y2*124./pid2 + 0.5);
y2 = (x1 != x0) ? atan((y1-y0) / (x1-x0)) : y1 > y0 ? pid2 : -pid2;
j2 = (y2 / pi) * 180. + 90. + 0.5;
// j2 = (x1 != x0) ? 125.5 + atan((y1-y0)/(x1-x0))*124./pid2 : 250;
// }
// else {
// j2 = 250;
// }
// itab[j2*width+i2]++;
resImg->setPixelAt(i2, j2, resImg->getPixelAt(i2, j2) + 1.);
}
}
for(unsigned int j1 = j+1; j1 < image->getHeight(); j1++) {
for(unsigned int i1 = 0; i1 < image->getWidth(); i1++) {
if(image->getPixelAt(i1, j1) == 255) {
const double x0 = i;
const double y0 = j;
const double x1 = i1;
const double y1 = j1;
const double l0 = sqrt((double)((y0-y1)*(y0-y1) + (x0-x1)*(x0-x1)));
const double l1 = fabs((double)(x0*y1 - x1*y0));
const double x2 = l1/l0;
double y2;
const int i2 = x2 + 0.5;
int j2;
// if(x1-x0 != 0) {
// y2 = atan((double)(y1-y0)/(x1-x0));
// j2 = 125 + (int)(y2*124./pid2 + 0.5);
// }
// else {
// j2 = 250;
// }
y2 = x1 != x0 ? atan((y1-y0) / (x1-x0)) : y1 > y0 ? pid2 : -pid2;
// j2 = (y2 / pi + 0.5) * image->getHeight() + 0.5;
// j2 = (y2 * 2. + pi)*100. + 0.5;
j2 = (y2 / pi) * 180. + 90. + 0.5;
// j2 = (x1 != x0) ? 125.5 + atan((y1-y0)/(x1-x0))*124./pid2 : 250;
// itab[j2*width+i2]++;
resImg->setPixelAt(i2, j2, resImg->getPixelAt(i2, j2) + 1.);
}
}
}
}
}
}
// Image_t<double> *returnval = new Image_t<double>(width, height, 1, itab);
// delete itab;
// return returnval;
return resImg;
}
