Discussion :

[Jipété]

Au secours ! Y a un œil qui me regarde, j'ai peur...
(dimensions / 3 x 2)



Trêve de plaisanterie. Étant entendu que je pars toujours de la même map (fichier ou construction d'un bitmap en mémoire) de 360 de large sur 256 de haut, qu'est-ce que je dois multiplier et où pour arriver à quelque chose de sympathique ?

J'étais parti sur la piste

Code pascal :

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

1
2
  diam := img4RYBcircle.Width; // c'est le TImage d'affichage
  rapport_width_sur360 := diam / 360;

et plus bas

Code pascal :

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

  idx := round(distance * diam * rapport_width_sur360) + round(ToDegrees(Phase));

mais avec une image containeur de 720x720 c'est l'œil ci-dessus (un peu rétréci), avec une de 180x180 c'est une multitude de cercles concentriques clairs.


EDIT
En fait, les trous noirs ne le sont pas tant que ça,



J'ai déplacé mon "rapport" ainsi, pour obtenir cette image :

Code pascal :

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

idx := round(distance * diam) + round(ToDegrees(Phase) * rapport_width_sur360);

Après, je suis à court d'idées et d'inspiration...
/EDIT

Ici la fonction ne retourne apparemment que les angles de l'intervalle [-Pi/2 ; +Pi/2]; il serait intéressant de voir comment tu l'as utilisée.

Je pensais que ça se voyait et donc que la question ne se posait pas, puisque je montrais à chaque fois une manière commentée et l'autre active.
Je remontre avec juste la ligne THEN,
une manière :

Code pascal :

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

        IF w < 0 THEN Phase:= (-arctan (h/w) + Pi)

ou l'autre :

Code pascal :

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

        IF w < 0 THEN Phase:= (-arctan2(h,w) + Pi)

Pas plus.
De toute façon, le compilateur ne veut pas autre chose.
Maintenant, peut-être sans doute qu'une fonction attend par exemple un h de 0 à 180 quand l'autre admet 0 à 360, mais il n'y a rien pour nous le dire.

[wiwaxia]

Ta fonction angulaire n'est peut-être pas tout à fait au point, mais le résultat est surprenant.

Regardons déjà la partie radiale, en utilisant un pixel de référence fixe, indépendant de la phase. Le calcul porte exclusivement sur des paramètres sans dimension; les composantes du pixel local n'apparaissent qu'à la fin.

Voici le coeur du programme, concernant la matrice de pixels représentant le corps de l'image bitmap.
L'algorithme s'exécute en moins d'une seconde. Les délais que tu as cités (~ 12 s , #31) m'intriguent un peu.

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
47
48
49
50
51
52
53
54
55
56
57
 
 CONST m = 255; Im = 1 / 255; R1 = 0.36; R2 = 0.48; R3 = R2 - R1;
 
 FUNCTION F1(r: Reel; Vr: Tab_3R): Pixel;
   VAR k: Byte; u, v, w, z: Reel; Px: Pixel;
   BEGIN
     FOR k:= 1 TO 3 DO BEGIN
                         u:= 1 - Vr[k]; v:= r / R1; w:= u * v;
                         z:= 1 - w;     Px[k]:= Round(m * z)
                       END;
     Result:= Px
   END;
 
 FUNCTION F2(r: Reel; Vr: Tab_3R): Pixel;
   VAR k: Byte; u, v, w, z: Reel; Px: Pixel;
   BEGIN
     FOR k:= 1 TO 3 DO BEGIN
                         u:= r - R1;    v:= Vr[k] / R3; w:= u * v;
                         z:= Vr[k] - w; Px[k]:= Round(m * z)
                       END;
     Result:= Px
   END;
 
 FUNCTION VectPixel(Px: Pixel): Tab_3R;
   CONST m = 255;
   VAR Ve: Tab_3R;
   BEGIN
     Ve[1]:= Im * Px[1]; Ve[2]:= Im * Px[2];
     Ve[3]:= Im * Px[3]; Result:= Ve
   END;
 
 FUNCTION Dist1(Dx, Dy: Reel): Reel;
   VAR u, v: Reel;
   BEGIN
     u:= Sqr(Dx); v:= Sqr(Dy);
     Result:= Sqrt(u + v)
   END;
 
 PROCEDURE Init_MatIm01(La, Ha: Z_32; VAR Ma: Tab_Pix);
   CONST Pfnd: Pixel = (170, 170, 170); Pref: Pixel = (0, 255, 170);
   VAR Ha1, La1, Xm, Ym: Z_32; d, Dmin, Rho, Xce, Yce: Reel;
       Vref: Tab_3R; Px: Pixel;
   BEGIN
     IF (La>Ha) THEN Dmin:= Ha ELSE Dmin:= La;
     La1:= La - 1;     Ha1:= Ha - 1;
     Xce:= 0.5 * La1;  Yce:= 0.5 * Ha1;
     FOR Xm:= 0 TO La1 DO
       FOR Ym:= 0 TO Ha1 DO
         BEGIN
           Vref:= VectPixel(Pref); d:= Dist1(Xm - Xce, Ym - Yce);
           Rho:= d / Dmin;
           IF (Rho<R1) THEN Px:= F1(Rho, Vref)
                       ELSE IF (Rho<R2) THEN Px:= F2(Rho, Vref)
                                        ELSE Px:= Pfnd;
           Ma[Xm, Ym]:= Px
         END
   END;

Les images obtenues ont les caractéristiques suivantes:
Dimensions: _ _ R1: _ _ R2:
100x300 _ _ _ _ 0.18 _ _ 0.48
350x150 _ _ _ _ 0.30 _ _ 0.33
500x500 _ _ _ _ 0.36 _ _ 0.48

Il y avait une bourde niveau CM2 dans mes définitions: j'ai confondu rayon et diamètre mais cela n'a pas pour autant planté l'exécution.
Les instructions ont été écrites au pas de charge, et il y a certainement des imperfections.
Le programme fonctionne néanmoins correctement, et la notation des calculs a été reprise à la lettre.
Sa transposition ne devrait pas te poser de problèmes.

_

[Jipété]

Tu sais quoi ?
Depuis le début j'ai l'impression que nous sommes sur deux voies parallèles totalement incompatibles, un peu comme dans la vallée du Rhône où des poids-lourds sur l'autoroute se tapent la bourre avec des trains de marchandises à quelques dizaines de mètres.

Un exemple ?

Les délais que tu as cités (~ 12 s , #31) m'intriguent un peu.

J'ai pourtant bien précisé hier ou avant-hier qu'en virant Canvas.Pixels[x, y] (qui est bien connu pour être épouvantablement lent, et utilisé par moi au début juste pour des tests rapidement codés et avec la ferme intention de le remplacer une fois les algos au point) et en utilisant un accès direct par pointeurs, je passais de 12 sec à une fraction de seconde.
0,2 pour être précis, pour une image de 640x640, grâce à la mise en place d'une récupération de la durée d'exécution cet après-midi.

Un autre exemple ?
Je ne sais absolument pas quoi faire avec ton code.
On dirait qu'il s'agit du déplacement de la frontière hautes-basses lumières.
Alors comme le but de ma dernière question était d'adapter les dimensions du bitmap de travail aux dimensions de l'objet qui l'affichera, si je ne peux pas adapter ce bitmap directement pendant sa construction, ben... je vais le redimensionner après, et là, en travaillant avec des rectangles c'est très facile et très rapide :

Code pascal :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
  //...
  end; // fin de la boucle de construction du bitmap aBmp
  aBmp.EndUpdate();
 
  // 3 nouvelles lignes pour adapter la taille du bitmap à l'objet qui va le contenir pour affichage
  with img4RYBcircle.Canvas do begin
    SetStretchBltMode(Handle, HALFTONE);
    StretchDraw(ClipRect, aBmp);
    Changed;
  end;
 
  //img4RYBcircle.Picture.Bitmap.Assign(aBmp); // version sans resize, plus nécessaire
  map.Free;
  aBmp.Free;
end; // fin de la procédure

Et ça fonctionne du feu de Dieu !
Je ne vais pas mettre une copie d'écran d'une image de 720x720, ça n'apporterait rien, par contre, voilà un montage (réduit de moitié) avec à gauche un cercle RGB issu d'un vieux programme et à droite son futur remplaçant RYB.


Je vais un peu étudier le déplacement de la ligne de séparation entre hautes et basses lumières, et ça ira bien.
Questions annexes : c'est quoi Tab_Pix et Tab_3R ?
Et Pixel ? Sur 3 ou 4 bytes ?

Ah, cadeau pour augmenter la collec' d'objets RYB, une pochette de disque :

[wiwaxia]

... Depuis le début j'ai l'impression que nous sommes sur deux voies parallèles totalement incompatibles ... Je ne sais absolument pas quoi faire avec ton code ...

Tu disposes comme moi d'une matrice de pixels qui mémorise le corps de l'image, et dont on peut à priori initialiser chacun des éléments; peu importent le type, le nom des variables, et les moyens d'y accéder.
Et nous utilisons à priori le même langage - le Pascal - pour les instructions de base: la transposition n'est donc pas hors de portée.

L'algorithme précédent, c'était pour te montrer
a) que la fonction radiale (c. à d. la loi de dépendance de la couleur vis à vis de la distance CM) peut de calculer uniquement à l'aide de rapports sans dimension et de limites fixes, arbitrairement choisies (R1 et R2);
b) que les diamètres des cercles sont indépendants des dimensions de l'image, et
c) qu'il n'intervient aucun arrondi , hormis la détermination finale des composantes du pixel local.

Ces calculs, tu dois les faire, et tu les a faits (ou l'un de tes logiciels les a faits) puisque les résultats sont là.
Mais tu donnes l'impression de manipuler une boîte noire que tu maîtrises sans doute beaucoup mieux que moi, mais mal; tu produis des instructions étonnantes, sinon discutables, et j'essaie de répondre aux problèmes que tu rencontres.

Mais peu importe le procédé choisi, pourvu que tu sois satisfait des résultats. Tu as soulevé un problème intéressant, celui de la suppression d'une couleur secondaire (le cyan).
Et cela tombait bien, car je cherchais une palette (d'une tout autre nature) pour un autre programme, et cela m'a permis de me rafraîchir la mémoire..

... Questions annexes : c'est quoi Tab_Pix et Tab_3R ?
Et Pixel ? Sur 3 ou 4 bytes ? ...

j'ai effectivement omis quelques rappels indispensables:

a) hors programme:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
TYPE Z_32 = LongInt; 
     Reel = Extended; 
     Bool = Boolean;
// Instructions spécifiques de la synthèse d'images
     Pixel = ARRAY[1..3] OF Byte;
     Tab_Pix = ARRAY[0..Dim_Max, 0..Dim_Max] OF Pixel;
     F_Reel = FUNCTION(o: Reel): Reel;
     F_Pixl = FUNCTION(o: Reel): Pixel;
 
 VAR Haut_Image, Larg_Image, Prod_LaHa: Z_32;
     Matr_Image: Tab_Pix;

b) particulières au programme: Tab_3R est un triplet de réels, provisoirement associé aux pixels, dans les calculs qui les concernent.

Code :

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

 TYPE Tab_3R = ARRAY[1..3] OF Reel;

# En ce qui concerne la partie angulaire du programme et le calcul des couleurs de référence observées à la frontière de séparation des zones claire et sombre, on peut envisager deux options:
a) un calcul complet à partir de trois fonctions convenablement étalonnées :
Pref[1] = C1(Phase) , Pref[2] = C2(Phase) , Pref[3] = C3(Phase) ,
ce qui me paraît le moins encombrant;
b) un calcul à partir d'un tableau de (N) pixels prédéterminés (24 ? 180 ? 360 ?) - c'est apparemment ton choix - qui demandera un calcul d'interpolation pour éviter toute discontinuité de teinte.

[Jipété]

Et coucou !

Tu disposes comme moi d'une matrice de pixels qui mémorise le corps de l'image,

Pas exactement : je dispose d'une matrice de pixels qui mémorise plus précisément de g. à dr. 24 couleurs dégradées de haut en bas de blanc à noir en passant par couleur[0..23], et je veux la transformer en une représentation circulaire et esthétiquement plaisante et cohérente.
Pour moi, la matrice est la source des données et le corps de l'image c'est le rendu circulaire (inscrit dans un objet carré).
En gros,


Le miracle, c'est que si le bon sens admet que j'agrandisse la largeur de la matrice de 24 à 360 (pour parcourir facilement [dans mon esprit] les 360 degrés d'un cercle avec donc 24 arcs de 15° chacun), j'obtiens pourtant un résultat correct avec le diamètre du cercle fixé à 360 pixels.

Et cela tombait bien, car je cherchais une palette (d'une tout autre nature) pour un autre programme

Bah oui, tout sert à tout in the life (même si des fois on voit des trucs, particulièrement dans l'actu, on se demande bien le but et la finalité...)

j'ai effectivement omis quelques rappels indispensables

et merci pour les précisions, c'est tout de suite beaucoup plus clair, sauf que t'en as oublié une : Dim_Max, dans Tab_Pix = ARRAY[0..Dim_Max, 0..Dim_Max] OF Pixel;...
Tu la calcules comment ?
Et cette array est donc un carré ?

Ah, j'oubliais :
une simplification (et du coup la fonction Dist1 dégage) dans la procédure principale :

Code pascal :

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

1
2
3
            Vref:= VectPixel(Pref);
            //d:= Dist1(Xm - Xce, Ym - Yce);
            d:= Sqrt(Sqr(Xm - Xce) + Sqr(Ym - Yce));

une autre :

Code pascal :

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

1
2
3
4
5
    FUNCTION VectPixel(Px: Pixel): Tab_3R;
//    CONST
//      m = 255; ? déjà défini + haut, et inutilisé ici
    VAR
    //...

Il me reste à mapper ton Tab_Pix vers mon TBitmap, mais lequel ? La matrice source rectangulaire ou l'objet fini carré ?

[wiwaxia]

... et merci pour les précisions, c'est tout de suite beaucoup plus clair, sauf que t'en as oublié une : Dim_Max, dans Tab_Pix = ARRAY[0..Dim_Max, 0..Dim_Max] OF Pixel;...
Tu la calcules comment ?
Et cette array est donc un carré ?

Dim_Max = 2000 , comme ça il me reste de la marge même pour créer un fond d'écran, et je suis raisonnablement protégé d'éventuels débordements. Je reconnais que c'est du gaspillage; le Turbo Pascal contraint à une économie beaucoup plus stricte. Virtual P. permet de prendre ses aises.

Les 4004001 pixels sont initialisés à (0, 0, 0), et ensuite j'en fais ce que je veux.

... Pour moi, la matrice est la source des données et le corps de l'image c'est le rendu circulaire (inscrit dans un objet carré) ...

Un fichier bitmap comporte essentiellement deux parties:
- l'entête occupant les 54 premiers octets, réservé aux caractéristiques du fichier et de l'image;
- le corps constitué de la succession des pixels présents dans l'image, en commençant par celui situé au coin inférieur gauche (en fait, c'est un peu plus compliqué que cela).

https://sitelec.org/cours/abati/bmp.htm#bmp

Il faut donc disposer d'une matrice, dont les éléments puissent être mis en correspondance avec les triplets de bytes du fichier.

Lors d'un autre échange sur ce sujet, tu as fait état de variables bitmap (ou bmp ?) comportant une matrice, dont l'initialisation a donné lieu à de laborieuses discussions.

... une simplification (et du coup la fonction Dist1 dégage) dans la procédure principale :

Code :

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

1
2
            //d:= Dist1(Xm - Xce, Ym - Yce);
            d:= Sqrt(Sqr(Xm - Xce) + Sqr(Ym - Yce)); ...

Cela, je refuse de l'écrire, pour des raisons que je ne me sens pas en mesure de bien expliquer.
Je sais que cela va à l'encontre des habitudes du plus grand nombre, et les disputes théologiques ne sont pas autorisées sur le site.

...

Code :

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

1
2
3
FUNCTION VectPixel(Px: Pixel): Tab_3R;
//    CONST
//      m = 255; ? déjà défini + haut, et inutilisé ici

...

Effectivement, la rédaction a été rapide, et je n'ai pas tout filtré.

[Jipété]

Les 4004001 pixels sont initialisés à (0, 0, 0), et ensuite j'en fais ce que je veux.

Ah !

Code pascal :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
    CONST
      Pfnd: Pixel = (170, 170, 170);
 
    FOR Xm := 0 TO La1 DO
      FOR Ym := 0 TO Ha1 DO
        BEGIN
          Vref:= VectPixel(Pref);
          //d:= Dist1(Xm - Xce, Ym - Yce); jpt
          d:= Sqrt(Sqr(Xm - Xce) + Sqr(Ym - Yce));
          Rho:= d / Dmin;
          IF (Rho<R1) THEN Px:= F1(Rho, Vref)
                      ELSE IF (Rho<R2) THEN Px:= F2(Rho, Vref)
                                       ELSE Px:= Pfnd; 
          Ma[Xm, Ym]:= Px
        END

et on voit bien en mode pas-à-pas avec la souris sur l'objet "dd", qui est un pixel, qu'il contient bien 170,170,170 et 255, Linux oblige.



Sauf que quand j'enregistre le fichier map.bmp après l'appel à ta proc, il est tout noir.

Je dois donc me perdre quelque part dans les correspondances, mais où ?

Le problème, c'est qu'il n'est pas envisageable de parcourir toute la matrice en pas-à-pas.


Est-ce que c'est bien comme ça qu'il faut comprendre ta procédure ?

Code pascal :

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

1
2
3
          IF (Rho<R1) THEN Px:= F1(Rho, Vref)// j'en fais ce que je veux.
                      ELSE IF (Rho<R2) THEN Px:= F2(Rho, Vref)// j'en fais ce que je veux.
                                       ELSE Px:= Pfnd;        // initialisés à (170, 170, 170)

Si "oui" il y a qqchse qui ne va pas, si "non" alors il me manque un morceau.
Lequel ?

Le gros problème que je rencontre, c'est qu'à chaque exposé que tu fais, tu utilises des noms de variables et d'objets qu'on ne retrouve pas dans l'exposé suivant, résultat je suis complètement largué quand il s'agit de recoller les morceaux.
exposé 1
exposé 2
exposé 3
J'ai tout récupéré, je n'arrive pas à assembler...

Lors d'un autre échange sur ce sujet, tu as fait état de variables bitmap (ou bmp ?) comportant une matrice, dont l'initialisation a donné lieu à de laborieuses discussions.

Tu pourrais retrouver cet échange ?

Cela, je refuse de l'écrire, pour des raisons que je ne me sens pas en mesure de bien expliquer.

Mais pourquoi donc ?
Moi j'aime bien aller à l'essentiel et aussi alléger tout ce fatras de textes abscons.

[Jipété]

Et ce que je ne comprends ABSOLUMENT PAS, c'est pourquoi il faudrait que je floute une map noire pour avoir des résultats qui commencent à s'approcher d'autre chose que du noir :

Code pascal :

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

1
2
3
4
      EndUpdate();
    end;
    //map := Floute(map, nbrecoul, KFLOU div nbrecoul);
    map.Canvas.Changed;

image affichée noire, et enregistrée noire.

Code pascal :

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

1
2
3
4
      EndUpdate();
    end;
    map := Floute(map, nbrecoul, KFLOU div nbrecoul);
    map.Canvas.Changed;

images avec des choses (en fonction d'un autre paramètre) :




Euh, ça n'étonnera personne si je dis que le gris "remonte" au colorpicker à 170,170,170 ?

[wiwaxia]

W: Lors d'un autre échange sur ce sujet, tu as fait état de variables bitmap (ou bmp ?) comportant une matrice, dont l'initialisation a donné lieu à de laborieuses discussions.

Tu pourrais retrouver cet échange ? ...

Il s'agit d'une discussion amorcée le 24/10/2016 , et intitulée:
Uniformisation de couleurs dans un dégradé : comment faire ?

https://www.developpez.net/forums/d1...degrade-faire/

et au cours de laquelle tu as abordé quelques précisions concernant tes matrices, à partir du message #65

... À mon avis il est en haut à gauche. D'ailleurs, dans un autre projet, j'avais noté ça, concernant le bitmap de travail :

Code :

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

1
2
3
4
5
6
  ------------------------
  |0,0           1535,0  |
  |                      |
  |                      |
  |0,255         1535,255|
  ------------------------

Je me rappelle des difficultés surgies du sens de l'indexation des lignes ...

PS: Là, j'ai du mal à suivre toutes tes initiatives ... Tu ne floutes pas, mais tu imposes au dessin une déformation angulaire d'équation θ' = (3/2)*θ . On sort du sujet ...

[Jipété]

Je me rappelle des difficultés surgies du sens de l'indexation des lignes ...

Oui oui, c'est rigolo, pendant que j'attendais ce matin ta réponse à propos d'une variable oubliée, j'ai farfouillé dans mes vieux codes et retrouvé des choses sur lesquelles j'avais sué comme en plein été au Sahara.

PS: Là, j'ai du mal à suivre toutes tes initiatives ... Tu ne floutes pas, mais tu imposes au dessin une déformation angulaire d'équation θ' = (3/2)*θ . On sort du sujet ...

Je n'ai rien imposé, c'est en changeant simplement une variable par ci par là pour voir comment ça réagit que ces "choses" sont apparues -- On oublie.

---
On récapitule :
je crée un bitmap de 24x256 en mémoire à partir de valeurs saisies en amont. Il s'agit de 24 couleurs dégradées verticalement de blanc à noir en passant par couleur[x].

Ce bitmap, je le recopie dans un autre de 360x256 (si je mets 256x256 ça foire, je verrai + tard), j'ai donc 24 barres dégradées, verticales, de 15 px de large.
Je floute un peu pour uniformiser les passages d'une couleur à l'autre, et au final c'est ce que j'appelle la "map".

Ensuite je crée un autre bitmap, carré pour afficher le cercle, que je vais analyser ligne à ligne et pour chaque ligne de colonne-début à colonne-fin, et selon qu'on est
- à l'extérieur du cercle on passe à la ligne ou colonne suivante ;
- à l'intérieur du cercle et là, au moyen d'une formule mathématique sophistiquée, les coordonnées du point dans le cercle sont utilisées pour aller chercher dans la map la couleur qui va bien, qui sera recopiée dans ce "bitmap pour cercle".

Enfin, je recopie ce "bitmap pour cercle" dans l'objet chargé de l'afficher, en adaptant les tailles au besoin.

Et dans ce magnifique scénario (on dirait du Hitchcock, ), où et comment puis-je utiliser ton système qui va, si j'ai bien compris, déplacer le "point de partage des eaux", genre une pente douce et longue de blanc à couleur-max et une pente rapide et abrupte de couleur-max à noir¹ ?
Si c'est possible (sinon on zappe et ça ira comme ça).

Merci,

---
¹: parce qu'à terme, je verrais bien un TrackBar pour ajuster précisément et à la demande ce point entre 0 et 255. Pas toi ?

[wiwaxia]

... Le gros problème que je rencontre, c'est qu'à chaque exposé que tu fais, tu utilises des noms de variables et d'objets qu'on ne retrouve pas dans l'exposé suivant, résultat je suis complètement largué quand il s'agit de recoller les morceaux.
exposé 1
exposé 2
exposé 3
J'ai tout récupéré, je n'arrive pas à assembler...

Cela montre au moins une lecture approfondie des messages qui te sont adressés, et m'oblige à plus d'attention encore à ce j'écris.

En vérifiant les renvois, je note ceci:


Exposé 2_#29
J'aborde la question du paramétrage de la palette rectangulaire, relativement facile et qui n'a pas été reprise plus loin; il ne devrait donc pas y avoir de difficulté. Il y a simplement une correction à apporter, au niveau de 2 termes:

... le vecteur de référence admet pour composantes: Q_ref = (Rpal(t) , Vpal(t) , Bpal(t)) .

b) Dans la partie supérieure claire (Ym >= Lim), les couleurs évoluent progressivement jusqu'au blanc (vecteur Q₁₁₁ = (1, 1, 1) par la relation linéaire:

Q(Xm, Ym) = (Ym - Lim)/(Ha - 1 - Lim)*Q₁₁₁ + (Ha - 1 -Ym)/(Ha - 1 - Lim)*Q_ref

qui se traduira par 3 relations équivalentes:

Fr(Xm, Ym) = (Ym - Lim)/(Ha - 1 - Lim) + (Ha - 1 -Ym)/(Ha - 1 - Lim)*Rpal(t)
Fv(Xm, Ym) = (Ym - Lim)/(Ha - 1 - Lim) + (Ha - 1 -Ym)/(Ha - 1 - Lim)*Vpal(t)
Fb(Xm, Ym) = (Ym - Lim)/(Ha - 1 - Lim) + (Ha - 1 -Ym)/(Ha - 1 - Lim)*Bpal(t)

Pour les cercles, les paramètres (L1, L2) que je voulais maintenir se sont révélés peu pratiques, aussi je ne les ai pas gardés; mais comme je n'ai pas développé les calculs, c'est sans conséquence.

Expoeé 1_#38
J'ai détaillé les calculs pour les cercles, en introduisant les paramètres (R1, R2):

3°) On peut alors envisager une fonction affine en deux morceaux Jc = F(r, Ic):
a) dans la zone claire (r < R1): Jc = 1 - (1 - Ic)*r/R1 , qui donne
# pour r = 0 , Jc = 1 (valeur maximale au centre);
# pour r = R1 , Jc = 1 - (1 - Ic) = Ic ;
b) dans la zone sombre (R1 < r < R2): Jc = Ic*(1 - (r - R1)/(R2 - R1)), qui donne maintenant:
# pour r = R1: Jc = Ic*(1 - 0) = Ic (il y a bien continuité en ce point);
# pour r = R2: Jc = Ic*(1 - 1) = 0 (c'est le bord du cercle chromatique).

Les deux expressions apparaissent clairement, et il n'y a rien à ajouter.

Expoé 3_#44
Je ne sais pas si c'est le bon renvoi, car on n'y trouve que la déclaration des types de variables.
Il y a cependant le message précédent:
#42
qui contient le codage de la palette circulaire.
Je me suis efforcé de maintenir la même notation, mais le code informatique impose des contraintes qu'on ne peut supprimer:

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
 FUNCTION F1(r: Reel; Vr: Tab_3R): Pixel;
   VAR k: Byte; u, v, w, z: Reel; Px: Pixel;
   BEGIN
     FOR k:= 1 TO 3 DO BEGIN
                         u:= 1 - Vr[k]; v:= r / R1; w:= u * v;
                         z:= 1 - w;     Px[k]:= Round(m * z)
                       END;
     Result:= Px
   END;
 
 FUNCTION F2(r: Reel; Vr: Tab_3R): Pixel;
   VAR k: Byte; u, v, w, z: Reel; Px: Pixel;
   BEGIN
     FOR k:= 1 TO 3 DO BEGIN
                         u:= r - R1;    v:= Vr[k] / R3; w:= u * v;
                         z:= Vr[k] - w; Px[k]:= Round(m * z)
                       END;
     Result:= Px
   END;

En lisant à l'envers chaque bloc d'instruction, donc en commençant par la dernière ligne, il vient littéralement (en tenant compte de ce que R3 = R2 - R1);
# Contenu de F1: z = 1 - (1 - Vr[k])*r/R1
# Contenu de F2: z = Vr[k] - (r - R1)*Vr[k]/(R2 - R1)
à rapprocher de
# Expression 1: Jc = 1 - (1 - Ic)*r/R1
# Expression 2: Jc = Ic*(1 - (r - R1)/(R2 - R1))

L'intensité relative de la couleur de référence est représentée par Vr[k] et Ic (en vert);
celle de la couleur locale par z ou Jc (en rouge).

[wiwaxia]

... Et dans ce magnifique scénario (on dirait du Hitchcock, ), où et comment puis-je utiliser ton système qui va, si j'ai bien compris, déplacer le "point de partage des eaux", genre une pente douce et longue de blanc à couleur-max et une pente rapide et abrupte de couleur-max à noir¹ ?
Si c'est possible (sinon on zappe et ça ira comme ça) ...

Les deux palettes constituent des ensembles de valeurs discrétisées, et passer de l'une à l'autre exigerait déjà, en l'absence de tout point singulier, une double interpolation difficile à mettre en oeuvre.
Le présence du centre, en lequel convergent tous les rayons, rend tout calcul impossible en raison de la superposition des listes de couleurs, en nombre d'autant plus grand que l'on se trouve plus près du point considéré.

Loin de moi l'idée de paraître insistant .
Maintenant si tu veux vraiment essayer, je ne peux que t'encourager dans cette voie; je suivrai tes résultats avec intérêt.

Tu as en fait changé de sujet; il ne s'agit plus passer d'un rendu RGB par calculs à un rendu RYB par une table, mais de la transformation d'un domaine rectangulaire à un domaine circulaire; c'est un problème de topologie.

¹: parce qu'à terme, je verrais bien un TrackBar pour ajuster précisément et à la demande ce point entre 0 et 255. Pas toi ?

Tout à fait, sauf que je ne connaît rien de ce procédé (à mon grand regret).
Je suppose que Lazarus est indispensable ?

[Nebulix]

Voilà ce à quoi j'arrive. La discontinuité à 9h est peut-être due à l'image originale. Il vaudrait mieux calculer directement la couleur.Je verrai demain...
Ce code a été vite fait et ne correspond pas aux canons de belle programmation (pour wiwaxia). Plus tard, si j'ai le temps.

Code Pascal :

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
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
unit Unit1;
 
interface
 
uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, ExtCtrls, StdCtrls;
 
type
  TForm1 = class(TForm)
    Button1: TButton;
    OpenDialog1: TOpenDialog;
    SaveDialog1: TSaveDialog;
    Image1: TImage;
    Image2: TImage;
    procedure Button1Click(Sender: TObject);
  private
    { Déclarations privées }
  public
    { Déclarations publiques }
  end;
 
var
  Form1: TForm1;
 
implementation
uses extend;
{$R *.dfm}
type b3=array[1..3]of byte;
b3a=array   [0..2000]of b3;
pb3a=^b3a; pb3=^b3;
var
bb:b3;
p,q:pb3a;
 
 var bm,bm2:tbitmap;
procedure TForm1.Button1Click(Sender: TObject);
var x,y,x2,y2,xc,yc,r,phi:integer;
begin
bm:=tbitmap.create;
bm2:=tbitmap.create;
with opendialog1 do if execute then bm{image1.picture}.loadfromfile(filename); //256*360
image1.Canvas.Draw(0,0,bm);
with opendialog1 do bm2.loadfromfile(filename); //256*360
image2.Canvas.Draw(0,0,bm2);
xc:=180;yc:=150;
    for y := 0 to Bm.Height -1 do
    begin
      P := Bm.ScanLine[y];
      for x := 0 to Bm.Width -1 do begin   //
      r:=trunc(sqrt(sqr(x-xc)+sqr(y-yc)));
      phi:=trunc(atgs(x-xc,y-yc))+180;//0 à 360
      if r>150 then begin
            bb[1]:=0;  bb[2]:=0; bb[3]:=0; //1 bleu  2 vert    3 rouge
            P[x] := bb;
            end
      else begin
        y2:=trunc(r*2.55/1.5);
        x2:=phi;
        q:=bm2.scanline[y2];
        bb:=q[x2];
         P[x] := bb;
            end;
 
      end;
      end;  image2.Canvas.Draw(0,0,bm);
 
    end;
end.

Je ne résiste pas au plaisir de vous livrer un joli bug

[Jipété]

Tu as en fait changé de sujet; il ne s'agit plus passer d'un rendu RGB par calculs à un rendu RYB par une table, mais de la transformation d'un domaine rectangulaire à un domaine circulaire; c'est un problème de topologie.

Et pourtant, les premiers mots du premier post sont bien "je ne sais pas si le titre est bien clair", point que j'ai très vite précisé en expliquant que la conversion rectangle vers cercle en RGB était là pour l'exemple (graphique, visuel), pour montrer ce que je voulais obtenir mais avec les dégradés RYB.

La présence du centre, en lequel convergent tous les rayons, rend tout calcul impossible en raison de la superposition des listes de couleurs, en nombre d'autant plus grand que l'on se trouve plus près du point considéré.

Or, toute personne ayant ouvert un éventail a pu s'aérer le visage sans se poser de question et le replier ensuite...

Qu'il soit interdit de descendre directement d'une palette rectangulaire à une circulaire, pourquoi pas, pour les puristes, il n'empêche que passer par des calculs revient au même, il y aura des endroits où il faudra choisir pour le pixel[x,y] une couleur n ou n-1 ou n+1.

Les mots "calcul" en vert sont là pour cacher la m... au chat, qu'on glisse discrètement sous le tapis et pour laquelle on a inventé l'antialiasing, y a pas d'secret y a pas d'lézard, tu ne pourras jamais dessiner un cercle parfait avec des carrés colorés, tu peux faire tous les calculs que tu veux, même avec Pi à un milliard de décimales, c'est comme ça, par construction.
Alors bon, quitte à faire une concession, pourquoi pas deux ?

Maintenant si tu veux vraiment essayer, je ne peux que t'encourager dans cette voie; je suivrai tes résultats avec intérêt.

Oui mais pour ça il aurait fallu répondre à la question "où et comment utiliser ton système", si tant est que ça soit possible mais ça donne envie puisque je vois bien dans mes cercles une luminosité plus (trop ?) forte à mi-distance entre le blanc et le noir.
Maintenant, il me vient une idée : plutôt que d'appliquer la correction au cercle, pourquoi ne pas l'appliquer en amont lors de la construction du bitmap "map" ?
En voilà une piste qu'elle est bonne !

Au lieu d'avoir un dégradé en dos de dromadaire (une seule bosse), envisager un dos de chameau avec deux bosses encadrant un léger creux au milieu, au "point de partage des eaux" ? Genre

Code :

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

1
2
3
       bosse       bosse
             creux 
blanc                     noir

Bon, là ce n'est pas proportionnel, mais vous voyez l'idée.

Étudier ça ? Peut-être d'abord le traduire en anglais, mais je ne cause pas du tout teuton...

Code pascal :

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
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
procedure DrawGradient(aCanvas: TCanvas; Rect: TRect;
  Horizontal: Boolean; Colors: array of TColor);
{ http://www.swissdelphicenter.ch/en/showcode.php?id=1162
  The following code allows you to draw a gradient on a canvas with
  an arbitrary number of colors (minimum 2).
  To draw a gradient on a form's canvas,
  call the DrawGradient() in the OnPaint and OnResize-event handlers.
 
  Example Calls:
  DrawGradient(Image1.Canvas, Rect(0, 0, 100, 200), False, [clRed, $00FFA9B4]);
  DrawGradient(Canvas, GetClientRect, True, [121351, clBtnFace, clBlack, clWhite]);
}
type
  RGBArray = array[0..2] of Byte;
var
  x, y, z, stelle, mx, bis, faColorsh, mass: Integer;
  Faktor: double;
  A: RGBArray;
  B: array of RGBArray;
  merkw: integer;
  merks: TPenStyle;
  merkp: TColor;
begin
  mx := High(Colors);
  if mx > 0 then
  begin
    if Horizontal then
      mass := Rect.Right - Rect.Left
    else
      mass := Rect.Bottom - Rect.Top;
    SetLength(b, mx + 1);
    for x := 0 to mx do
    begin
      Colors[x] := ColorToRGB(Colors[x]);
      b[x][0] := GetRValue(Colors[x]);
      b[x][1] := GetGValue(Colors[x]);
      b[x][2] := GetBValue(Colors[x]);
    end;
    merkw := aCanvas.Pen.Width;
    merks := aCanvas.Pen.Style;
    merkp := aCanvas.Pen.Color;
    aCanvas.Pen.Width := 1;
    aCanvas.Pen.Style := psSolid;
    faColorsh := Round(mass / mx);
    for y := 0 to mx - 1 do
    begin
      if y = mx - 1 then
        bis := mass - y * faColorsh - 1
      else
        bis := faColorsh;
      for x := 0 to bis do
      begin
        Stelle := x + y * faColorsh;
        faktor := x / bis;
        for z := 0 to 3 do
          a[z] := Trunc(b[y][z] + ((b[y + 1][z] - b[y][z]) * Faktor));
        aCanvas.Pen.Color := RGB(a[0], a[1], a[2]);
        if Horizontal then
        begin
          aCanvas.MoveTo(Rect.Left + Stelle, Rect.Top);
          aCanvas.LineTo(Rect.Left + Stelle, Rect.Bottom);
        end
        else
        begin
          aCanvas.MoveTo(Rect.Left, Rect.Top + Stelle);
          aCanvas.LineTo(Rect.Right, Rect.Top + Stelle);
        end;
      end;
    end;
    b := nil;
    aCanvas.Pen.Width := merkw;
    aCanvas.Pen.Style := merks;
    aCanvas.Pen.Color := merkp;
  end
  else
    // Please specify at least two colors
    raise EMathError.Create('Es müssen mindestens zwei Farben angegeben werden.');
end;

Je suppose que Lazarus est indispensable ?

Je ne connais pas l'EDI avec lequel tu codes. Une réponse rapide serait de dire que si tu peux avoir des fenêtres avec des objets (boutons, images, etc.), alors tu dois sans doute pouvoir avoir un TrackBar.
On en reparlera.

----
code Nebulix :
Merci pour ta participation, et c'est là qu'on va toucher du doigt la misère...

J'ai tout regroupé dans la proc, un truc qui induit en erreur c'est tes commentaires //256*360 car le fichier est en 360*256, mais bon, je pense plus à une erreur de typo, là.
J'ai rajouté 2 lignes obligatoires pour Laz (et signalées), et comme ni Laz ni ggl ne connaissent atgs, j'ai remplacé au pif par arctan2 puis arctan, avec un résultat identique :


Ah, j'ai renommé bm en bm1, pour l'alignement vertical avec bm2

Code pascal :

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
procedure TForm1.Button1Click(Sender: TObject);// Nebulix
type
  b3 =array [1..3]of byte;
  b3a=array [0..2000] of b3;
  pb3a = ^b3a;
  pb3  = ^b3;
var
  x,y,x2,y2,xc,yc,r,phi:integer;
  bb:b3;
  p,q:pb3a;
  bm1,bm2: tbitmap;
begin
  bm1:=tbitmap.create;
  bm2:=tbitmap.create;
  bm1{image1.picture}.loadfromfile(programdirectory+'mapdegrRYB360v2.bmp'); //256*360
  image1.Canvas.Draw(0,0,bm1);
  bm2.loadfromfile(programdirectory+'mapdegrRYB360v2.bmp'); //256*360
  image2.Canvas.Draw(0,0,bm2);
  xc:=180; yc:=150;
  bm1.BeginUpdate(); // lazarus
  for y := 0 to Bm1.Height -1 do
  begin
    P := Bm1.ScanLine[y];
    for x := 0 to Bm1.Width -1 do begin   //
      r := trunc(sqrt(sqr(x-xc)+sqr(y-yc)));
//      phi := trunc(atgs(x-xc,y-yc))+180; //0 à 360
//      phi := trunc(arctan2(x-xc,y-yc))+180; //0 à 360
      phi := trunc(arctan(x-xc/y-yc))+180; //0 à 360
      if r>150 then begin
        bb[1]:=0;  bb[2]:=0; bb[3]:=0; //1 bleu 2 vert 3 rouge
        P^[x] := bb; //chapeau
      end
      else begin
        y2:=trunc(r*2.55/1.5);
        x2:=phi;
        q:=bm2.scanline[y2];
        bb:=q^[x2];  //chapeau
        P^[x] := bb; //chapeau
      end;
    end;
  end;
  bm1.EndUpdate(); // lazarus
  image2.Canvas.Draw(0,0,bm1);
end;

Je ne résiste pas au plaisir de vous livrer un joli bug

Très joli, ton calot, mais comment l'as-tu eu ?

[Jipété]

Bonjour,

après cette nuit de cauchemar, les idées seront-elles plus claires ?

Mais tu donnes l'impression de manipuler une boîte noire

Tout-à-fait, et j'ajouterai "non documentée".

Par exemple dans le code de Nebulix, on peut lire y2 := trunc(r*2.55/1.5);.
Ah !
Pourquoi 2.55 ? Pourquoi 1.5 ?
Joués aux dés ? Piochés dans un sac de jetons de loto ? Tombés du camion ? Une apparition divine ?
Pour un matheux c'est peut-être évident, mais depuis le début je répète que je ne suis pas matheux.
Alors pourquoi pas 2.56 et 1.4 ? Aucune idée...
Idem avec le if r>150 then donc, oui, boîtes noires...

En plus je pose parfois des questions précises auxquelles je ne lis pas de réponses, exemple avec

Est-ce que c'est bien comme ça qu'il faut comprendre ta procédure ?

Code pascal :

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

1
2
3
          IF (Rho<R1) THEN Px:= F1(Rho, Vref)// j'en fais ce que je veux.
                      ELSE IF (Rho<R2) THEN Px:= F2(Rho, Vref)// j'en fais ce que je veux.
                                       ELSE Px:= Pfnd;        // initialisés à (170, 170, 170)

Si "oui" il y a qqchse qui ne va pas, si "non" alors il me manque un morceau.
Lequel ?

Donc la boîte noire sans docs s'enfonce sous l'eau, lentement...

Le plus curieux étant cette manière de traiter la typographie globale (appelons ça comme ça, l'exemple va l'éclairer, je n'ai pas d'autre mot) avec ce long post censé expliquer mes lacunes, lacunes liées au fait que certains posts sont rédigés en mandarin et que les ajouts et corrections sont en mandarin écrit à la Léonard, ie, à lire dans un miroir...
Concernant

Exposé 2_#29

on y voit trois lettres en gras et trois autres en rouge. Je vais voir mes notes et constate que le gras ne se justifie pas, j'ai les mêmes phrases, par contre les 3 rouges indiquent 2 (et pas 3) erreurs.
Puis juste dessous, dans

Expoeé 1_#38

on voit aussi du rouge et au bout de 5 minutes à comparer à la loupe mes notes et le post je renonce à trouver une erreur, il n'y en a pas.
Alors que vient faire ce rouge ?

Bon, une règle de codage demande de nommer correctement les variables, donc quand je vois ça

# Contenu de F2: z = Vr[k] - (r - R1)*Vr[k]/(R2 - R1)

, je referme vite la boîte noire en espérant qu'elle tombera en marche, sauf qu'il n'y a pas de doc, ou alors écrite en mandarin par Léonard.
Pourtant j'avais simplement demandé où l'insérer dans ma construction, cette fichue boîte...


Un mot à Nebulix : je n'obtiens rien d'autre que des cercles avec une une couleur dégradée, c'est sans doute lié à ta fonction atgs ou alors je n'en sais rien, car j'ai nettoyé/épuré/cherché à comprendre et je n'arrive à rien :

Code pascal :

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
47
48
49
50
procedure TForm1.Button10Click(Sender: TObject);// nebulix
type
  b3 =array [1..3] of byte;
  b3a=array [0..2000] of b3;
  pb3a = ^b3a;
  //pb3  = ^b3; jpt : compilo dit "unused"
var
  x,y,x2,y2,xc,yc,r{,phi}:integer;
  optim_y_moins_yc, optim_y_moins_yc_au_carre: integer;
  bb: b3;
  p,q: pb3a;
  bm1,bm2: tbitmap;
  GTC: DWord; // jpt
begin
  bm1:=tbitmap.create;
  bm2:=tbitmap.create;
  bm1.loadfromfile(programdirectory+'mapdegrRYB360v2.bmp'); //256*360 -- euh, jpt, 360*256
  bm2.loadfromfile(programdirectory+'mapdegrRYB360v2.bmp'); //256*360
  image1.Canvas.Draw(0,0,bm1);
  image2.Canvas.Draw(0,0,bm2);
  xc:=180; yc:=128; //150; jpt: pourquoi 150 ?
  GTC := GetTickCount;
  bm1.BeginUpdate(); // lazarus
  for y := 0 to bm1.Height -1 do begin
    optim_y_moins_yc := y - yc;
    optim_y_moins_yc_au_carre := optim_y_moins_yc * optim_y_moins_yc;
    P := bm1.ScanLine[y];
    for x := 0 to bm1.Width -1 do begin   //
      r := trunc(sqrt(sqr(x-xc)+optim_y_moins_yc_au_carre));
//utilisé si r<150 phi := trunc(atgs(x-xc,y-yc))+180; //0 à 360
      if r > 150 then begin // extérieur du cercle, en noir
        bb[1]:=0; bb[2]:=0; bb[3]:=0; //1 bleu 2 vert 3 rouge
      end
      else begin // intérieur du cercle
        y2 := trunc(r*1.7);//(r*2.55/1.5);
        q  := bm2.scanline[y2]; // lecture seulement donc pas besoin d'update
        //x2 := trunc(arctan(x-xc/optim_y_moins_yc))+180; //0 à 360 dégradé vert
        //x2 := trunc(arctan(x-xc/optim_y_moins_yc));//+180; dégradé rouge, point noir au centre
        x2 := trunc(ToDegrees(-arctan(x-xc/optim_y_moins_yc))+90); //0 à 360 dégradé vert
        bb := q^[x2];  //chapeau
memo1.Lines.Add(format('%.3d', [x2]));
// x2 varie de 179 à 181 -- de 90 à 269 avec todegrees et +180 -- de 0 à 179 avec +90
      end;
      P^[x] := bb; //chapeau
    end;
  end;
  bm1.EndUpdate(); // lazarus
  Caption := Format('Durée : %d ms', [GetTickCount - GTC]);
  image2.Canvas.Draw(0,0,bm1);
end;

À se demander si le code fourni correspond bien aux images qu'on voit...
D'autant plus curieux que ce bout de code ressemble énormément à celui que j'utilise depuis le début.

[wiwaxia]

Tu ne comprends pas le problème.

... Les mots "calcul" en vert sont là pour cacher la m... au chat, qu'on glisse discrètement sous le tapis et pour laquelle on a inventé l'antialiasing, y a pas d'secret y a pas d'lézard, tu ne pourras jamais dessiner un cercle parfait avec des carrés colorés, tu peux faire tous les calculs que tu veux, même avec Pi à un milliard de décimales, c'est comme ça, par construction.
Alors bon, quitte à faire une concession, pourquoi pas deux ? ...

Le calcul permet de savoir si un point est à l'intérieur d'un cercle, ou non, et de déterminer la couleur locale. La précision du calcul n'y change rien: la qualité du graphique est liée à la densité des pixels.

... Qu'il soit interdit de descendre directement d'une palette rectangulaire à une circulaire, pourquoi pas, pour les puristes, il n'empêche que passer par des calculs revient au même, il y aura des endroits où il faudra choisir pour le pixel[x,y] une couleur n ou n-1 ou n+1 ...

L'application qui à tout (M) d'un domaine rectangulaire plan de dimensions (La, Ha) fait correspondre un autre point (M') d'un domaine circulaire du même plan, de centre (C) ne pose aucune difficulté.
Il s'agit de la correspondance

M(x, y) ───────────────────────> M'(u, v)
(x, y) appartenant à [0 ; La]×[0 ; Ha] ; (u, v) appartenant à [-R' ; R']×[-R' ; R']

définie par

r = R'*(y/Ha) ; θ = 360°*(x/La) ; u = r*Cos(θ) ; v = r*Sin( θ)

Et l'on n'est nullement tenu de choisir entre deux pixels voisins: à tout réel (z) vérifiant

n = Trunc(z) ; z = n + e

correspond par interpolation linéaire le pixel moyen:

P(z) = (1 - e)*P_n + e*P_n+1

La difficulté provient de la présence simultanée d'un point singulier (le centre) en lequel les distances s'annulent, et des pixels.
L'application M ────> M' n'est pas bijective, car (C) est l'image de tous les points du bord inférieur du rectangle (y = 0).

... toute personne ayant ouvert un éventail a pu s'aérer le visage sans se poser de question et le replier ensuite ...

Tout programmeur en surchauffe a pu s'apercevoir, s'il n'a pas encore atteint le seuil de burn out, que son éventail résulte du pliage d'une surface dessinée, que celle-ci n'atteint jamais la partie centrale, et qu'à l'endroit le plus étroit les bandes rigides de l'armature sont assemblées par empilement au niveau de leur extrémité commune; les distances entre deux points donnés d'une même pièce ne s'y annulent en aucune façon.

Il y a une solution algorithmique, mais j'entends déjà les pleurs et les grincements de dents .

[anapurna]

salut jipete

alors moi qui suis la conversation avec grand intérêt je peux réponde a quelque une de tes question

wiwaxia en indiquant

Exposé 2_#29

ne voulais que simplifier ta demande Exposé 2 correspond a ton liens
#29 correspond a la numérotation du message que tu apercevoir à chaque poste en haut a droite


pour ce qui est du 150 c'est simple cela correspond au yc ... je suis d'accord avec toi il aurait été préférable de mettre yc
reprenons le code

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
   
   xc:=180; 
   yc:=150;
//
  for y := 0 to Bm1.Height -1 do
  begin
    P := Bm1.ScanLine[y];
    for x := 0 to Bm1.Width -1 do 
   begin   
      r := trunc(sqrt(sqr(x-xc)+sqr(y-yc)));
      phi := trunc(arctan(x-xc/y-yc))+180; //0 à 360
      if r>150 then
      begin
        bb[1]:=0;  
        bb[2]:=0; 
        bb[3]:=0; //1 bleu 2 vert 3 rouge
        P^[x] := bb; //chapeau
      end
      else 
      begin
         y2:=trunc(r*2.55/1.5);
         x2:=phi;
         q:=bm2.scanline[y2];
         bb:=q^[x2];  //chapeau
         P^[x] := bb; //chapeau
      end;
    end;
  end;

en ce qui concerne 1.5 et 2.55 là je ne peut faire que des supposition de simplification afin d’accélérer les calcul

[Nebulix]

J'utilise Delphi 7, qui était récemment la dernière version gratuite, mais maintenant on peut avoir la 10.
atgs est une fonction que j'ai écrite pour avoir une fonction valide sur les 4 quadrants.
Le facteur 1.5/2.55 est simplement du au fait que je dois faire correspondre le rayon de mon cercle (150) avec la hauteur de ton image (256), en évitant de sortir du cadre.
J'ai bien obtenu mon résultat avec mon code (sinon comment ?). Il arrive d'être parfois nerveux ...
Le calot a été obtenu en calculant phi à partir du coin gauche (0,0) au lieu du centre du cercle puis en forçant sa variation à 360 avec un facteur ad hoc.
Es tu sûr de ta fonction ToDegrees ? Qu'elle renvoie bien des résultats entre 0 et 360 ?

Code :

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

1
2
3
4
5
6
7
8
9
10
11
function atgs(a,b:single):single;
var x:single;
begin
if abs(a)<1.0e-6 then begin
   if b>0 then x:=90 else x:=-90;end else begin
x:=arctan(b/a)*180/pi;
if a<0 then if x>0 then x:=x-180  else x:=x+180;end;
ga:=a;gb:=b;
gx:=x;
result:=x;
end;

[wiwaxia]

Je ne sais plus quoi répondre, à part paraphraser ce qui a déjà été donné.

J'ai utilisé la couleur et/ou les caractères gras pour signaler
- deux erreurs dans le code initialement donné, et depuis corrigé (#29) ;
- la parenté de notation (et par contraste les termes différemment représentés) pour deux relations identiques

En lisant à l'envers chaque bloc d'instruction, donc en commençant par la dernière ligne, il vient littéralement (en tenant compte de ce que R3 = R2 - R1);
# Contenu de F1: z = 1 - (1 - Vr[k])*r/R1
# Contenu de F2: z = Vr[k] - (r - R1)*Vr[k]/(R2 - R1)
à rapprocher de
# Expression 1: Jc = 1 - (1 - Ic)*r/R1
# Expression 2: Jc = Ic*(1 - (r - R1)/(R2 - R1))

L'intensité relative de la couleur de référence est représentée par Vr[k] et Ic (en vert);
celle de la couleur locale par z ou Jc (en rouge).

(z) et (Jc) c'est la même chose, de même que (Vr[k]) et (Ic) ... Que dire de plus ?

... En plus je pose parfois des questions précises auxquelles je ne lis pas de réponses, exemple avec

Code :

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

1
2
3
4
 
          IF (Rho<R1) THEN Px:= F1(Rho, Vref)// j'en fais ce que je veux.
                      ELSE IF (Rho<R2) THEN Px:= F2(Rho, Vref)// j'en fais ce que je veux.
                                       ELSE Px:= Pfnd;        // initialisés à (170, 170, 170)

Si (Rho<R1) Alors Pixel_Local:= Fonction_Couleur_Claire // Cercle central
_ _ _ _ _ _ Sinon Si (Rho<R2) Alors Pixel_Local:= Fonction_Couler_Sombre // Couronne circulaire
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ Sinon Pixel_Local:= Fonction_Couleur_de_Fond // Extérieur du cercle chromatique

[Jipété]

Salutàtous !

atgs est une fonction que j'ai écrite pour avoir une fonction valide sur les 4 quadrants.

Ah ah ! Je ne pouvais pas le deviner. Je la mettrai en place + tard, là je n'ai pas le temps.

... correspondre le rayon de mon cercle (150) ...

Donc tu envisageais un cercle de diam 300, et c'est noté nulle part... Je repartirai de là.

Es-tu sûr de ta fonction ToDegrees ? Qu'elle renvoie bien des résultats entre 0 et 360 ?

Je ne suis sûr de rien dans ce domaine, je fais confiance à S.O., dont la première réponse ramasse 256 votes positifs.

Exposé 2 correspond à ton lien

Euh, non, mon lien renvoie là
https://www.developpez.net/forums/d1.../#post10887686
et en cliquant dans ma citation en haut sur exposé 2 on arrive là :
https://www.developpez.net/forums/d1.../#post10884612
avec un joli croquis sympathique et utile.

Que dire de plus ?

Oui ou Non ?
Parce que la question simple n'est toujours pas répondue :


Absent cet aprème.