Discussion :

[SergioMaster]

Bonjour,

Je cherche des pistes pour mieux définir mon analyse de gradient.

Mon programme test est basique. Au design je créé un rectangle avec un gradient.

puis via le onclick j'utilise ce 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
procedure TForm3.Rectangle2Click(Sender: TObject);
var bmp : Tbitmap;
    dbmp : TBitmapData;
    dobreak : boolean;
    x,y :integer;
begin
 bmp:=Rectangle2.MakeScreenshot;
 bmp.Map(TMapAccess.read,dbmp);
 var tcolor:=dbmp.GetPixel(0,0);   // topleft
 var cColor:=dbmp.GetPixel(dbmp.width div 2, dbmp.height div 2);   // center
 radiant.text:=format('%s %s',[AlphaColorToString(tcolor), AlphaColorToString(ccolor)]);
 bmp.Unmap(dbmp);
 freeandnil(bmp);
end;

Facile, oui, mais, ce n'est qu'un exemple particulier !
Comment détecter le type (radial dans cet exemple) et surtout le centre ?
Dans le cas d'un gradient linéaire cela devient encore plus compliqué puisque l'angle va jouer !

Et enfin, je ne me suis arrêté qu'à deux couleurs or les possibilités des gradients (même si je trouve que le designer est plutôt bogué) sont énormes.

Il y a déjà un bail, j'avais fait un truc par code pour un composant led
. Cet aparté me fait penser que depuis 2022 les choses ont peut-être changé

Vous vous poserez peut-être la question du pourquoi je me casse la tête. Ma réponse : cela concerne toujours les styles firemonkey

Comment extraire le gradient du style Calypso complexe puisqu'il me semble qu'il est impossible à réaliser avec Delphi, il doit manquer les gradients de type conique et mesh (encore que pour ce dernier je pense que ce n'est qu'un problème de centre)

[Informt2025]

Bonjour,
Je pense pour mieux analyser l'image c'est de la convertir en format moins précis soit en niveau de gris puis le format 16bit ou autres.. soit limiter le nombre de couleurs celà créera des délimitations bien claires pour détecter le type du dégradé.

EDIT:

[tourlourou]

Bonjour,
Peut-être l'analyse de la luminosité pourrait-elle aider ?
Chercher le minimum et le maximum puis si des points équidistants (dans différentes directions) présentent des différences de luminosité proportionnelles à cette distance ou variant dans le même sens.

[SergioMaster]

@Tourlourou Point intéressant, j'y avais plus ou moins pensé, mais rien de concret. Je vais dormir dessus.

Pendant ce temps, j'ai concocté ceci

avec ce 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
29
30
31
32
33
34
35
36
37
procedure TForm3.Rectangle3Click(Sender: TObject);
var bmp : Tbitmap;
    dbmp : TBitmapData;
    dobreak : boolean;
    maxx,maxy,minx,miny :integer;
    Maxcolor, Mincolor : TAlphaColor;
begin
 bmp:=Rectangle3.MakeScreenshot;
 bmp.Map(TMapAccess.read,dbmp);
 
 maxcolor:=TalphaColors.White;
 mincolor:=TalphaColors.Alpha;
// var tcolor:=dbmp.GetPixel(0,0);
// var cColor:=dbmp.GetPixel(dbmp.width div 2, dbmp.height div 2);
 
 for var x := 0 to dbmp.width-1 do
    for var y := 0 to dbmp.height-1 do
      begin
        var acolor:=dbmp.GetPixel(x,y);
        if acolor<maxcolor then begin
             maxcolor:=acolor;
             maxx:=x;
             maxy:=y;
        end;
        if aColor>mincolor then
          begin
           mincolor:=aColor;
           minx:=x;
           miny:=y;
          end;
      end;
 
 
 radiant3.text:=format('%s - %d %d; %s - %d %d',[AlphaColorToString(maxcolor),maxx,maxy, AlphaColorToString(mincolor),minx,miny]);
 bmp.Unmap(dbmp);
 freeandnil(bmp);
end;

demain je me lance donc dans une transformation du gradient au runtime histoire de tester un peu plus ce truc

[tourlourou]

Bonjour Serge,
Le sens des comparaisons if acolor<maxcolor et if aColor>mincolor est-il juste ?

[_alx_]

Comme l'a suggéré @Tourlourou, le "gradient" va être déterminé par la variation de la luminance dans chaque couleur.

Je ne sais pas trop ce que signifie "gradient" dans ce contexte d'IHM, mais je suppose qu'il s'agit d'une variation linéaire, donc que la surface qui représente la variation de luminance est plane.

Plus exactement: un plan, si le centre est sur un bord de l'image; un cône, si le le gradient est radial et le centre est dans l'image, un "toit de maison" dans ce cas si le gradient n'est pas radial.
Mathématiquement, la direction du gradient va être déterminée par l'orientation de la normale à cette surface située à la position de son centre (donc de son maximum).

Donc, il faudrait (dans chaque couleur) déterminer d'abord la position du maximum de luminance.
Si le maximum est sur un bord, la direction du gradient est dans la direction perpendiculaire (le long de l'autre bord).
Sinon, si le maximum est à l'intérieur de l'image, il est atteint en un seul point (gradient radial) ou le long d'une ligne (comme dans ton 2ème exemple). Sa direction peut être déterminée par la variation de luminance dans n'importe quelle direction (cas radial) ou par la direction perpendiculaire à l'arête trouvée (dans le cas non radial).

ça devrait pouvoir se coder facilement.
Par exemple en utilisant le produit vectoriel de deux vecteurs (à 3 dimensions: position et luminance) constitués chacuns d'un point de l'image et d'un point dans l'ensemble des points du maximum de luminance.

[anapurna]

Salut,

Comme ça, intuitivement, je partirais sur la valeur médiane du rayon (ou du gradient/radien selon ce que tu manipules).

Je récupérerais ensuite tous les pixels possédant cette valeur, ou compris dans une certaine tolérance autour de celle-ci.

À partir de cet ensemble de points, je chercherais ensuite la forme géométrique dominante qui s’en dégage :

cercle,
cube,
courbe,
droite,
croix,
X,
etc.

L’idée serait donc :

segmenter les pixels par valeur,
extraire des amas cohérents,
analyser leur géométrie,
identifier la primitive correspondante.

[foetus]

Ce que veut faire @anapurna, cela s'appelle 1 convolution : regarde sur la page Wikipédia kernel (<- en anglais) et sur cette page en français (filtre de Sobel et autres)

En gros tu as 1 matrice (souvent 3x3) que tu vas faire glisser points par points et tu vas sommer les multiplications d'un point de l'image avec la valeur dans la matrice (<- cela va faire 3 multiplications pour chaque couleur; RGB)

Et ensuite ? c'est là que cela devient technique :

• reconstruire les lignes : segmentation d'image (<- page Wikipédia en français)
• détecter les formes : il me semble qu'on peut utiliser l'algorithme Scanline (<- page Wikipédia en anglais)

Mais tout cela va dépendre de ta détection si elle réussie vraiment à détecter 1 cercle (gradient radial) ou des lignes