image.cpp

une tres bonne fenetre

			f++;
		}
	for(int i=0;i<f;i++)
		image->setPixel(gradien[i].x,gradien[i].y,gradien[i].color);
	
}
////////////////gradient am閘iorer
floatpixel RImage::NormeGrad(QImage *image,int x,int y)
{
	int r1,r,r_1,g1,g,g_1,b1,b,b_1;
	floatpixel	 gradx	= {0.0f,0.0f,0.0f};
	floatpixel	 grady	= {0.0f,0.0f,0.0f};
	int		nbcompx = 0;
	int		nbcompy = 0;
	QColor(image->pixel(x,y)).getRgb(&r,&g,&b);
	if (x != 0)
	{
		QColor(image->pixel(x-1,y)).getRgb(&r_1,&g_1,&b_1);
		gradx.r += (float) (int)r-(int)r_1;
		gradx.g += (float) (int)g-(int)g_1;
		gradx.b += (float) (int)b-(int)b_1;
		nbcompx++;
	}
	if (x != image->width())
	{
		QColor(image->pixel(x+1,y)).getRgb(&r1,&g1,&b1);
		gradx.r += (float) (int)r1-(int)r;
		gradx.g += (float) (int)g1-(int)g;
		gradx.b += (float) (int)b1-(int)b;
		nbcompx++;
	}
	gradx.r=gradx.r/(float)nbcompx;		//on fait la moyenne
	gradx.g=gradx.g/(float)nbcompx;
	gradx.b=gradx.b/(float)nbcompx;

	if (y != 0)
	{
		QColor(image->pixel(x,y-1)).getRgb(&r_1,&g_1,&b_1);
		grady.r += (float) (int)r-(int)r_1;
		grady.g += (float) (int)g-(int)g_1;
		grady.b += (float) (int)b-(int)b_1;
		nbcompy++;
	}
	if (y != image->height())
	{
		QColor(image->pixel(x,y+1)).getRgb(&r1,&g1,&b1);
		grady.r += (float) (int)r1-(int)r;
		grady.g += (float) (int)g1-(int)g;
		grady.b += (float) (int)b1-(int)b;
		nbcompy++;
	}
	grady.r=grady.r/(float)nbcompy;
	grady.g=grady.g/(float)nbcompy;
	grady.b=grady.b/(float)nbcompy;
	
	floatpixel result = {(float)sqrt(gradx.r*gradx.r+grady.r*grady.r),
			          (float)sqrt(gradx.g*gradx.g+grady.g*grady.g),
			          (float)sqrt(gradx.b*gradx.b+grady.b*grady.b)};
	return result;
}
float max(float x,float y)
{
	if(x>y) return x;
	else return y;
}
float min(float x,float y)
{
	if(x>y) return y;
	else return x;
}
void RImage::gradienami(QImage *image,float durete)
{
	int i,j;
	floatpixel	* grad =new floatpixel[image->width()*image->height()];
	pixeltype	* data =new pixeltype[image->height()*image->width()];

	for(j=0;j<image->height();j++)
	{
		for(i=0;i<image->width();i++)
		{
			grad[i+j*image->width()] = RImage::NormeGrad(image,i,j);
			data[i+j*image->width()].x=i;
			data[i+j*image->width()].y=j;
		}
	}

	//On cherche le max et on normalise entre 0 et 255 et on genere l'image
	floatpixel maxi={0.0f,0.0f,0.0f};
	for (i=0;i<image->height()*image->width();i++)
	{
		if (grad[i].r>maxi.r)
			maxi.r=grad[i].r;
		if (grad[i].g>maxi.g)
			maxi.g=grad[i].g;
		if (grad[i].b>maxi.b)
			maxi.b=grad[i].b;
	}
	//On genere ensuite l'image en normalisant
	
	durete = max(durete,1);
	for (i=0;i<image->height()*image->width();i++)
	{
		data[i].r = (int) min(grad[i].r/maxi.r*255.0f*durete,255.0f);
		data[i].g = (int) min(grad[i].g/maxi.g*255.0f*durete,255.0f);
		data[i].b = (int) min(grad[i].b/maxi.b*255.0f*durete,255.0f);
	}
	for (i=0;i<image->height()*image->width();i++)
	{
		remplir(data[i],2);
		image->setPixel(data[i].x,data[i].y,data[i].color);
	}
	
}			

//////////////////////////////////////perwit
QRgb getperwit(pixeltype *tab)
{
	
	int resultxr=0,resultxg=0,resultxb=0,resultyr=0,resultyg=0,resultyb=0;
	int resultr,resultg,resultb;
	
	resultxr=tab[8].r+tab[0].r+tab[5].r-tab[7].r-tab[1].r-tab[6].r;
	resultyr=tab[8].r+tab[3].r+tab[7].r-tab[5].r-tab[4].r-tab[6].r;
	resultxg=tab[8].g+tab[0].g+tab[5].g-tab[7].g-tab[1].g-tab[6].g;
	resultyg=tab[8].g+tab[3].g+tab[7].g-tab[5].g-tab[4].g-tab[6].g;
	resultxb=tab[8].b+tab[0].b+tab[5].b-tab[7].b-tab[1].b-tab[6].b;
	resultyb=tab[8].b+tab[3].b+tab[7].b-tab[5].b-tab[4].b-tab[6].b;
	resultr=(int)sqrt((float)(resultxr*resultxr+resultyr+resultyr));
	resultg=(int)sqrt((float)(resultxg*resultxg+resultyg+resultyg));
	resultb=(int)sqrt((float)(resultxb*resultxb+resultyb+resultyb));
		
	return QColor(valid(resultr),valid(resultg),valid(resultb)).rgb();
}
pixeltype RImage::perwitpixel(QImage *image,int x,int y)
{
	pixeltype perwit;
	pixeltype tab[9];
	tab[0].color=image->pixel(x-1,y);
	tab[1].color=image->pixel(x+1,y);
	tab[2].color=image->pixel(x  ,y);
	tab[3].color=image->pixel(x  ,y-1);
	tab[4].color=image->pixel(x  ,y+1);
	tab[5].color=image->pixel(x-1,y+1);
	tab[6].color=image->pixel(x+1,y+1);
	tab[7].color=image->pixel(x+1,y-1);
	tab[8].color=image->pixel(x-1,y-1);	
	for(int i=0;i<9;i++)	remplir(tab[i],1);
	perwit.x=x;
	perwit.y=y;
	perwit.color=getperwit(tab);
	return perwit;
}

void RImage::perwit(QImage *image)
{
	pixeltype *perwit=new pixeltype[image->width()*image->height()];
	int f=0;
	for(int h=1;h<image->height()-1;h++)
		for(int w=1;w<image->width()-1;w++)
		{
			perwit[f]=perwitpixel(image,w,h);
			f++;
		}
	for(int i=0;i<f;i++)
		image->setPixel(perwit[i].x,perwit[i].y,perwit[i].color);
}

///////////////////////repoussage
QRgb getrepoussage(pixeltype *tab)
{
	int resultr=0,resultg=0,resultb=0;
	for(int i=0;i<7;i++)	remplir(tab[i],1);
	
	resultr=2*tab[6].r+tab[3].r+tab[0].r+tab[2].r-tab[1].r-2*tab[5].r-tab[4].r;
	resultg=2*tab[6].g+tab[3].g+tab[0].g+tab[2].g-tab[1].g-2*tab[5].g-tab[4].g;
	resultb=2*tab[6].b+tab[3].b+tab[0].b+tab[2].b-tab[1].b-2*tab[5].b-tab[4].b;
	
	return QColor(valid(resultr),valid(resultg),valid(resultb)).rgb();	
}

void RImage::repoussage(QImage *image)
{
	pixeltype *repoussage=new pixeltype[image->width()*image->height()];
	int f=0;
	for(int h=1;h<image->height()-1;h++)
		for(int w=1;w<image->width()-1;w++)
		{
			pixeltype tab[7];
			tab[0].color=image->pixel(w-1,h);
			tab[1].color=image->pixel(w+1,h);
			tab[2].color=image->pixel(w  ,h);
			tab[3].color=image->pixel(w  ,h-1);
			tab[4].color=image->pixel(w  ,h+1);
			tab[5].color=image->pixel(w+1,h+1);
			tab[6].color=image->pixel(w-1,h-1);	
			repoussage[f].color=getrepoussage(tab);
			repoussage[f].x=w;
			repoussage[f].y=h;
			f++;
		}
	for(int i=0;i<f;i++)
		image->setPixel(repoussage[i].x,repoussage[i].y,repoussage[i].color);
}

/////////////////////////////////////
bool RImage::pixels_different(QColor &src,QColor &test, int val)
{
	int src_r,src_b,src_v,test_r,test_b,test_v;
	src.getRgb(&src_r,&src_v,&src_b);
	test.getRgb(&test_r,&test_v,&test_b);
	if(!((src_b+val/2>test_b)&&(src_b-val/2<test_b)))	return (true);
	if(!((src_v+val/2>test_v)&&(src_v-val/2<test_v)))	return (true);
	if(!((src_r+val/2>test_r)&&(src_r-val/2<test_r)))	return (true);
	return (false);
}
int RImage::nombre_pixels_diff_autour(QImage *image,int w,int h,QColor color,int val)
{
	int nbautour=0;
	if(pixels_different(color, QColor(image->pixel(w-1,h)), val)==true) {nbautour += 1;}
	if(pixels_different(color, QColor(image->pixel(w+1,h)), val)==true) {nbautour += 1;}
	if(pixels_different(color, QColor(image->pixel(w,h-1)), val)==true) {nbautour += 1;}
	if(pixels_different(color, QColor(image->pixel(w,h+1)), val)==true) {nbautour += 1;}
	if(pixels_different(color, QColor(image->pixel(w-1,h-1)), val)==true) {nbautour += 1;}
	if(pixels_different(color, QColor(image->pixel(w+1,h-1)), val)==true) {nbautour += 1;}
	if(pixels_different(color, QColor(image->pixel(w-1,h+1)), val)==true) {nbautour += 1;}
	if(pixels_different(color, QColor(image->pixel(w+1,h+1)), val)==true) {nbautour += 1;}
	return nbautour;
}
void RImage::contour(QImage *image,int val)
{
	int nbautour;
	int h,w;
	
	for(h=1;h<image->height()-1;h++)
		for(w=1;w<image->width()-1;w++)
		{
			nbautour=nombre_pixels_diff_autour(image,w,h,QColor(image->pixel(w,h)),val);
			if(nbautour>=4)	image->setPixel(w,h,QColor(0,0,0).rgb());	
			else	image->setPixel(w,h,QColor(255,255,255).rgb());	
		}
}
void gris(QRgb &pixe)
{
	int r,g,b,result;
	QColor color(pixe);
	color.getRgb(&r,&g,&b);
	result=(r*11+g*16+b*5)/32;
	color.setRgb(result,result,result);
	pixe=color.rgb();
}
void RImage::Niveau_Gris(QImage *image)
{
	for(int h=0;h<image->height();h++)
		for(int w=0;w<image->width();w++)
		{
			QRgb inter=image->pixel(w,h);
			gris(inter);
			image->setPixel(w,h,inter);
		}
}
bool RImage::recuperxy(QImage *image,int &x,int &y,QColor coleur)
{
	bool test=false;
	for(int h=0;h<image->height();h++)
		for(int w=0;w<image->width();w++)
			if(image->pixel(w,h)==coleur.rgb())
			{
				x=w;
				y=h;
				test=true;
			}
	return test;
		
}
void RImage::courbe_initial(QImage *image,int w,int h,int ray,QColor coleur)
{
	for(int i=w-(ray+5);i<w+(ray+5) ;i++)
		for(int j=h-(ray+5);j<h+(ray+5);j++)
		{
			float result=sqrt((float)((w-i)*(w-i)+(h-j)*(h-j)));
			if((int)(result)==ray)  
			{
				image->setPixel(i,j,coleur.rgb());
			}
		}
}