Bonjour,

Le but est de trouver les valeurs de a,b et c depuis d dans ce calcule :

\(0.299*a + 0.587*b + 0.114*c = d\)

! Attention ! je travaille uniquement avec des nombre entiers, donc si \(a \in [0;2]\) alors a = 0, a = 1 ou a = 2.

a ne peut être 0.5 par exemple.

Sachant que\(a,b,c,d \in [0;255]\)

Du coup, j'ai décomposé le problème.

Avec deux nombre d'abord:

dans a + b = c

si \(a,b,c \in [0;255]\)

alors

\(a \in [0;255]\)

\(b = c-a \)

Si on passe sur trois nombres:

dans a + b + c = d

si \(a,b,c,d \in [0;255]\)

alors

\(a \in [0;255]\)

\(b = d-a-c\)

\(c = d-a-d\)

Je suis bloqué :/

Cordialement,

-
Edité par Bhasher 21 novembre 2017 à 19:57:34

1. J'ai compris l'énoncé de l'exercice, mais je n'ai absolument pas vu comment ta démarche pouvait amener à une réponse.

Ceci dit, on constate que 0.299+0.587+0.114 = 1 

Et donc, tous les quadruplets de la forme (a,a,a,a) sont solutions de cette équation.

Y en-a-t-il d'autres ? Je suppute que non, mais pas de certitude pour l'instant.

Pour avancer plus loin, il faudrait que tu nous dises dans quel cadre tu es tombé sur cet exercice. Selon qu'il s'agit d'un exercice de maths, d'informatique, ou autre, selon le chapitre du cours de maths où tu as trouvé cet exercice, les pistes à explorer seront différentes. 

Si c'est un exercice d'informatique, on trouve la solution en 10 minutes ; si c'est un exercice de maths, il faut réfléchir un peu plus...

Salut,

0.299 + 0.587 + 0.114 = 1 car il s'agit de proportion0

Disons que c'est un "exercice" à la limite entre les maths et l'informatique.

Il s'agit des proportions du Rouge, du Vert et du Bleu (RedGreenBlue) dans la formation d'une nuance de gris.

Ex:

Rgb(43, 250, 250) -> Il s'agit du cyan

en nuance de gris donnera :

0.299*43 + 0.587*250 + 0.114*250 = 188.107 = 188 (on n'a pas de valeur décimal dans un code couleur)

Rgb(188,188,188) -> Nuance de gris du cyan.

La différence, c'est qu'ici on a la nuance de gris, et qu'on cherche les valeurs R-G-B possibles.

L'objectif étant bien sur de faire sa "mathématiquement", et non comme un bourrin qui fait tourner des boucles. (tout le but est la )

Cordialement,

-
Edité par Bhasher 21 novembre 2017 à 21:30:35

D'accord,

Donc l'équation que tu cherche à résoudre, ce n'est pas 0.299a+0.587b+0.114c = d ( d étant connu, a,b et c étant les inconnues)

Mais : Arrondi(0.299a+0.587b+0.114c,0) = d ... Ce n'est pas tout à fait pareil.

Pour une valeur de d , tu as donc plein de solutions. ( en moyenne 65536...) Et pour recenser ces 65536 olutions ( c'est un nombre moyen, je me répète), une seule solution : des boucles.

Par exemple,   si a = 170 et b = 187, alors toutes les valeurs de c entre 236 et 244 vont nous donner le même niveau de gris d=188.

Un truc comme ça devrait nous donner les résultats pour une valeur de d donnée :

function affiche_abc(d)
Pour a = 0 a 255
  Pour b = 0 a 255
    c0 = arrondi.sup((d-0.5-0.299a-0.587b)/0.114,0)
    c1 = arrondi.inf((d+0.5-0.299a-0.587b)/0.114,0)
    si c0 < 0 alors c0 = 0
    si c1 > 255 alors c1 = 255
    pour c = c0 a c1 
      print (a, b,c)
    fin 
  fin
fin
fin function

Salut.

Je cherche à établir une moyenne de ces valeurs.

Pour cela, je calcule les valeurs de a,b et c possible, j'additionne tout les a,b,c et je les divisent par la lôngeur du tableau des valeurs.

L'opération prend en tout 0.2s.

Je répète cette opération sur chaque pixel d'une image en nuance de gris.

Sur une image de 10xa10, c'est rapide, mais une bete image de 100x100 prend déjà près de 45 minutes, une image de 500×500 prend plus de 10 heures !

Je me demandais si du coup, on poucais établir une valeur approchée de la moyenne sans passé par le tableau des valeurs.

Cordialement,

Edit:

J'ai modifié de tel sorte qu'il sauvarder les valeurs abc trouvées pour un d donné. Et de regarder qi le d n'est pas dans la liste. 

Mais la recherche de la moyenne reprédentr 95% du temps (+- 30s maintenant).

-
Edité par Bhasher 23 novembre 2017 à 16:44:10

Tu dis : je cherche à établir une moyenne de ces valeurs.

J'essaye de comprendre ce que ça veut dire.

Pour une valeur de d, il y a en gros 65000 combinaisons (a,b,c) qui conduisent à cette valeur d. Beaucoup plus que 65000 quand d est proche de 128, et beaucoup moins quand d est proche de 0 ou de 255.

Et donc, ce que tu cherches, c'est la moyenne des 65000 a en question, et la moyenne des 65000 b et la moyenne des 65000 c ? C'est bien ça ?

Si c'est bien ça, j'ai  l'impression que  tu peux prendre comme approximation a=b=c=d, tu devrais être très proche du bon résultat.

Sinon, dans le pire des cas, tu as 256 calculs à faire une fois pour toutes, tu calcules (a,b,c) pour les 256 valeurs possibles de d.  Tu as donc un tableau de 256x3 entiers à préparer. Et ensuite, que ton image fasse 10000 pixels, ou 200000 pixels, tu as juste à lire le tableau en question

Tu dis que ça prend 0.2seconde pour une valeur de d. Donc 256x0.2=51secondes pour initialiser ton tableau, et ensuite tu dois juste consulter ce tableau.

Je vais t'expliquer mon projet.

Le but, c'est de partir d'une image composé uniquement en variante de gris (Noir & Blanc, si on abuse le langage), et de, grâce aux valeurs du gris, tenter de "retrouver" l'image en couleur.

Pour cela, j'ai actuellement plusieurs techniques techniques.

Je pars ici de cette image :

• Calculer les 65.000 possibilités, et en tiré une au hasard.

• Calculer la moyenne des rouges, des verts, et des bleus, pour chaque pixels.

• Partir d'une série d'image, et calculé la moyenne pour chaque valeur en nuance de gris possible

• Pour chaque valeur de gris, prendre le Rouge le plus présent, le vert le plus présent, et le Bleu le plus présent.

• Prendre pour chaque valeur de nuance de gris, la valeur RGB la plus présente.

La seul "potable" est la 2eme. Et encore, quand on compare à l'original :

Il n'y a pas de solution à ton problème. Si tu n'as que l'image à base de gris, tu ne peux pas 'deviner' que les gris très clairs devront être convertis en jaune, et les gris intermédiaires en vert. Pire, il est tout à fait imaginable que sur une partie de l'image, les gris très clairs correspondent à du jaune, et sur une autre partie de l'image, les gris très clairs correspondent à du bleu clair.

Au mieux, tu peux générer une trentaine d'images, (une à dominante de jaune, une à dominante de rouge, etc etc ), et à postériori,  choisir celle qui te convient le mieux.

En terme de temps de traitement, pour générer une image comme celle-ci, il faut 2 ou 3 secondes.

Voici le code correspondant (langage=Windev). A toi d'adapter pour un langage autre.

tbc est un tableau de 256 entiers 

ccr, ccg, ccb ,verif est un réel
iii est un réel
cou, i1, i2  est un entier 
kr, kg, kb est un réel  
kr = 0.299
kg = 0.587
kb = 0.114
POUR i = 0 A 255
	iii = i 
	dRectangle ( i*2,0,i*2+2,50, RGB(i,i,i))
	
	ccb = ArrondiInférieur( (iii+0.499 - 0 *(kr+kg))/kb  ,0)
	SI ccb > 255 ALORS ccb = 255
	SI ccb < 0 ALORS ccb = 0
	
	ccr = Arrondi ( (iii +0.35 -ccb*kb )/(kr+kb),0)
	SI ccr < 0 ALORS ccr = 0
	SI ccr > 255 ALORS ccr = 255
	
	ccg =  Arrondi  ( ( iii+0.25 - ccr*kr - ccb*kb ) / kg  	,0)
	SI ccg > 255 ALORS ccg = 255
	SI ccg < 0 ALORS ccg = 0 
	
	cou = RGB( ccr, ccg ,ccb ) 
	tbc[i+1] = cou
FIN

dDébutDessin(Image1)
POUR i1 = 1 _A_ Image3..Largeur 
	POUR i2 = 1 _A_ Image3..Hauteur 
		cou = dPixelCouleur(Image3,i1, i2)
		cou = cou / 0x10101
		cou = tbc[cou+1]
		dPoint(i1, i2, cou)
	FIN
FIN

Mmh. Plutot que de générer 30 images, n'est ce pas mieux d'avoir une sorte de filtre rgb défini ?

Par exemple: [0,255, 0] (filtre vert )