Opérations sur des images

Version imprimable

18/10/2023, 21h50
Sylvain255

Opérations sur des images

Bonjour,
je voudrais pouvoir effectuer des rotations de 90,180,270 degrés sur des images JPEG ainsi que des flips (effet miroir) verticaux et horizontaux, attention pas touche aux informations EXIF, je veux que le tableau de pixels à l'intérieur soit bien modifié.
Merci
Bien cordialement.
19/10/2023, 07h49
SergioMaster

Bonjour,

FMX fourni toute une gamme d'effets pour changer les images, mais sauvegarder le résultat supprimera les EXIFs.
Je ne sais pas si une modification de l'image n'oblige pas à modifier certaines parties de L'EXIF (largeur et hauteur d'image en cas de rotation par exemple)
19/10/2023, 09h44
ShaiLeTroll

Windows GDI - Bitmap Rotation

As-tu essayé les fonctions intégrées à l'OS comme SetWorldTransform et son XFORM structure comme dans le sujet Rotation d'image avec bitblt/xform ou le sujet [débutant] Traitement d'image: WMF ou bmp?

bonjour

pour la partie exif regardez l'unité dexif ici

Code:

1
2
3
4
5
ImgData: TImgData;
 
ImgData.ProcessFile( nomfichiersource );
// traitement de l'image dans la variable jpg
imgdata.WriteEXIFJpeg(jpg, nomfichierDestination);

19/10/2023, 14h24
tourlourou

Bonjour,
Quelles informations EXIF doivent être conservées ? Pour être assuré de toutes les conserver valides, ça peut être un challenge !
Il peut d'ailleurs y avoir un marqueur orientation, qu'il faudra fatalement modifier (mais la norme ISO 12234-2 Image data format — TIFF/EP dit du tag $112 : "Note that the TIFF values which correspond to “mirrored” image orientations are not allowed.").
Certaines peuvent pointer des zones de l'image (tables de quantification ou Hufman), et il faut être sûr que l'enregistrement les modifiera si besoin.
S'il y a un répertoire fabricant parmi les informations, certaines des informations sont bien au format EXIF, mais souvent avec un format ou des tags propriétaires à la signification spécifique. Il faut donc pouvoir les reconstituer si on met la panique dedans.
19/10/2023, 16h03
Sylvain255

Bonjour,
je ne peut pas consulter phidels.com mon antivirus me le bloque avec "alerte trojan".
Pour les informations EXIF évidemment qu'on a le droit de modifier les informations de largeur et hauteur, je voulais dire ne pas modifier les informations dites de rotation. L'image n'est pas censée en contenir au départ.
Je pense qu'il faut en passer par convertir notre TJPEGImage en TBitmap, le tourner puis le reconvertir en TJPEGImage, je pense que Delphi écrira correctement les EXIF de base dedans, je n'ai pas besoin des EXIF constructeur.
Ma question devient donc comment tourner ou flipper un TBitmap. Il faut que l'opération soit rapide donc je voudrais utiliser des fonctions préfabriquées de Delphi ou de Windows car hors de question de le faire pixel par pixel.
Merci de votre aide
Bien cordialement

2 pièce(s) jointe(s)

Citation:

Il faut que l'opération soit rapide donc je voudrais utiliser des fonctions préfabriquées de Delphi ou de Windows car hors de question de le faire pixel par pixel.

Alors, voici un essai avec GDI,

Code:

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
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
unit Unit16;
 
interface
 
  uses
    Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants,
    System.Classes, Vcl.Graphics,
    Vcl.Controls, Vcl.Forms, Vcl.Dialogs, Vcl.StdCtrls, Vcl.ExtDlgs,
    Vcl.ExtCtrls,
    Vcl.Imaging.jpeg;
 
  type
    TForm16 = class(TForm)
      Button1: TButton;
      Image1: TImage;
      OpenPictureDialog1: TOpenPictureDialog;
      procedure Button1Click(Sender: TObject);
    private
      { Déclarations privées }
    public
      { Déclarations publiques }
    end;
 
  var
    Form16: TForm16;
 
implementation
 
{$R *.dfm}
 
  uses Winapi.GDIPApi, Winapi.GDIPObj, Winapi.GDIPUTIL;
 
  procedure TForm16.Button1Click(Sender: TObject);
  var
    GPImage: TGPImage;
    GPGraphics: TGPGraphics;
    pPropItem: PPropertyItem;
    BufferSize: Cardinal;
    Orientation: Byte;
    RotateType: TRotateFlipType;
    Bitmap: TBitmap;
  begin
    if OpenPictureDialog1.Execute then
    begin
      GPImage := TGPImage.Create(OpenPictureDialog1.FileName);
      try
        // extraction EXIF 
        // BufferSize := GPImage.GetPropertyItemSize(PropertyTagOrientation);  
        // if BufferSize > 0 then
        // begin
        // GetMem(pPropItem, BufferSize);
        // try
        // GPImage.GetPropertyItem(PropertyTagOrientation, BufferSize, pPropItem);
        // Orientation := PByte(pPropItem.value)^;
        // case Orientation of
        // 1: RotateType := RotateNoneFlipNone; // Horizontal - pas de rotation
        // 2: RotateType := RotateNoneFlipX;
        // 3: RotateType := Rotate180FlipNone;
        // 4: RotateType := Rotate180FlipX;
        // 5: RotateType := Rotate90FlipX;
        // 6: RotateType := Rotate90FlipNone;
        // 7: RotateType := Rotate270FlipX;
        // 8: RotateType := Rotate270FlipNone;
        // else
        // RotateType := RotateNoneFlipNone
        // end;
//      finally
//        FreeMem(pPropItem);
//      end;
        RotateType := Rotate180FlipNone; // un choix de ma part
 //       if RotateType <> RotateNoneFlipNone then
          GPImage.RotateFlip(RotateType);
        Bitmap := TBitmap.Create;
        try
          Bitmap.Width := GPImage.GetWidth;
          Bitmap.Height := GPImage.GetHeight;
          Bitmap.Canvas.Lock;
          try
            GPGraphics := TGPGraphics.Create(Bitmap.Canvas.Handle);
            try
              GPGraphics.DrawImage(GPImage, 0, 0, GPImage.GetWidth,
                GPImage.GetHeight);
              Image1.Picture.Assign(Bitmap);
            finally
              GPGraphics.Free;
            end;
          finally
            Bitmap.Canvas.Unlock;
          end;
        finally
          Bitmap.Free;
        end;
 
      // end;
    finally
      GPImage.Free
    end;
  end;
end;

Pièce jointe 645456

et avec RotateNoneFlipX
Pièce jointe 645457

19/10/2023, 17h32
Sylvain255

OK merci beaucoup mais on a le choix entre FlipNone et FlipX quid du flip vertical ou horizontal ?
19/10/2023, 18h46
tourlourou

Au pire, un flip vertical n'est-il pas la combinaison d'une rotation à 90°, d'un flip horizontal et d'une rotation à -90°?
19/10/2023, 21h11
Sylvain255

si mais en fait ce que je voudrais c'est une fonction qui prend deux paramètres :
1 : l'angle de rotation 0,90,180,270, d'ailleurs dans la fonction c'est horaire ou antihoraire ?
2 : le flip (none, vertical, horizontal)

donc il y a une série de if à faire !
19/10/2023, 21h12
Sylvain255

d'ailleurs il faut définir l'ordre on va choisir arbitrairement rotation puis flip, sinon je peux aussi me suffire de cette fonction

en fait je veux faire ces opérations pour augmenter la base d'apprentissage pour mon logiciel de labélisation pour deep learning, mais si j'ai déjà la rotation plus un flip (on sait pas lequel) c'est déjà très bien

finalement j'accepte la réponse de SergioMaster j'ai réussi à faire ce que je voulais avec ça de plus je vous fournis ici ma fonction de transformation de coordonnées ça pourra toujours servir à qqn :

Code:

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
//transforme le point "point" sur l'image de départ en un point sur l'image d'arrivée après transformation, la largeur et la hauteur en paramètre de la fonction sont ceux de l'image de départ
function  transformePoint(point:tpoint;transformation:integer;largeur:integer;hauteur:integer):tpoint;
begin
   case transformation of
  1: begin
  //RotateNoneFlipNone
  result.X:=point.x;
  result.Y:=point.y;
  end;
  2: begin
   //RotateNoneFlipX;
  result.X:=largeur-point.X-1;
  result.Y:=point.y;
  end;
 
  3: begin
  //Rotate180FlipNone;
  result.X:=largeur-point.X-1;
  result.Y:=hauteur-1-point.y;
  end;
 
  4: begin
  // Rotate180FlipX;
  result.X:=point.X;
  result.Y:=hauteur-1-point.y;
  end;
 
  5: begin
  //Rotate90FlipX;
  result.X:=point.y;
  result.Y:=point.x;
  end;
 
  6: begin
  // Rotate90FlipNone;
  result.X:=hauteur-1-point.y;
  result.Y:=point.x;
  end;
 
  7: begin
  // Rotate270FlipX;
  result.X:=hauteur-1-point.y;
  result.Y:=largeur-1-point.x;
  end;
 
  8: begin
  // Rotate270FlipNone;
  result.X:=point.y;
  result.Y:=largeur-1-point.x;
  end
else
   begin
  //RotateNoneFlipNone
  result.X:=point.x;
  result.Y:=point.y;
  end;
end;
end;

20/10/2023, 08h22
SergioMaster

Citation:

Envoyé par Sylvain255

OK merci beaucoup mais on a le choix entre FlipNone et FlipX quid du flip vertical ou horizontal ?

il suffit de regarder dans les sources de l'unité GDIAPI pour trouver l'ensemble des rotations (lignes 3310 -3330)