Discussion :

[baperpere]

Bonjour, je cherche à refaire un des filtres les plus connus de Photoshop, le contraste automatique.
Je connais quelques méthodes d'étirement d'histogramme mais aucune ne donne le même résultat.
J'ai lus sur le site d'adobe, qu'il ne prenait pas en compte les 5% des extrêmes de l'histogramme.

J'utilise OpenCV pour réaliser mes traitements

La méthode qui s'en rapproche le plus est celle-ci:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
void contrastAuto(Mat img)
{
	double min;
	double max;
 
	minMaxLoc(img, &min, &max);
 
	float diff = max - min;
 
	max = max*0.95;
	min = min*1.05;
 
	for(int y=0; y<img.cols; ++y)
		for(int x=0; x<img.rows; ++x)
			img.data[y*img.rows + x] = MAX(MIN((((img.data[y*img.rows + x] - min) / diff) * 255), 255), 0);
}

L’égalisation fournit dans OpenCV equalizeHist à tendance à brûler l'image.
La méthode de création de LUT en fonction de l'histogramme donne la même chose que equalizeHist

Et enfin un autre résultat:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
void normalize_gray (Mat img)
{
	double min, max, alpha, beta;
	minMaxLoc(img, &min, &max);
 
	max = max*0.95;
	min = min*1.05;
 
	alpha = 255.0 / (max - min);
	beta = -min * alpha;
 
 
	for (int i = 0; i < img.cols * img.rows; ++i)
		img.data[i] = MAX(MIN(alpha * img.data[i] + beta, 255), 0);
}

Si quelqu'un c'est déjà posé la question de sont fonctionnement, je suis preneur
Merci

[baperpere]

Je n'ai pas trouvé exactement le même algorithme, mais je m'en suis rapproché si cela intéresse quelqu'un...

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
 
void equalizeLut(Mat *img)
{
	if (img->type() == CV_8UC1)
	{
		int* histogram = new int[256];
		for (int i = 0; i<256; ++i)
			histogram[i] = 0;
 
		const unsigned int size = img->cols*img->rows;
		for (int i = 0; i<size; ++i)
			histogram[(int)img->data[i]]++;	
 
		int min = 0, max = 0;
		int ind = 0;
		while (min < (double)(size*0.01))
		{
			min += histogram[ind++];
		}
		min = ind;
		ind = 255;
		while (max < (double)(size*0.01))
		{
			max += histogram[ind--];
		}
		max = ind;
		delete(histogram);
 
		int* tableLut = new int[256];
		double minG, maxG;
 
		minMaxLoc(*img, &minG, &maxG);
 
		for (int i = 0; i<256; ++i)
			tableLut[i] = MAX(MIN(int(((i - min)*(maxG-minG) / (double)(max - min)+minG))-0.5, 255), 0);
 
		Mat Output(img->size(), CV_8UC1);
		for (int i = 0; i<size; ++i)
			Output.data[i] =  tableLut[(int)img->data[i]]; 
                delete(tableLut);
		img->release();
		Output.copyTo(*img);
 
		Output.release();
	}
}

J'admet un bricolage au niveau des minimas et maximas...
J'attend un peu avant de mettre résolue