Discussion :

[Jipété]

Bonjour !

Jipété, le retour, avec ses misères...

Je suis sur un projet EFG fort sympathique, FlipReverseRotate, et comme je suis aussi sous Linux, c'est la misère. Noire...

Parce que quand on étudie un tas de trucs à la suite, la mémoire travaille en mode fifo et ce que j'ai capté il y a deux ans est depuis passé à la trappe, bien sûr.
D'où la galère.

Allez, 3 images.
D'abord brut de dézippage, juste après "Outils / Convertir un projet Delphi..." :


Classique, les rayures sur la copie. J'ai la solution (extrait) :

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
var
  pbS,pbD: pByte;// pour la Source et la Destination
for h := 0 to Bitmap.Height-1 do begin
  pbS := Bitmap.RawImage.GetLineStart(h);
  pbD := RESULT.RawImage.GetLineStart(h);
  cnt := 0;  idx := 0;
  for w := 0 to (Bitmap.Width * 3)-1 do begin
    pbD[idx] := pbS[w];
    cnt := w+1; // pour chercher le 4e byte
    if ( Frac(cnt / 3) = 0 ) then begin
      // bourrer le 4e byte du pRGBquad de la destination, le "Reserved", qui est inclus par le widgetset gtk2
      // sans demander l'avis à personne, sans informer... Faut deviner, à coups d'essais et d'échecs.
      inc(idx);
      pbD[idx]:=255;
    end;
    inc(idx);
  end;
end;

Ce qui est très curieux, c'est que le bouton Save me génère un fichier copié de la même taille que l'original, alors qu'il y a un byte de plus par pixel -- passerait-il à la trappe lors de l'enregistrement sans que, là aussi, "on" ne me dise rien ?


Mais attention ! Cette magnifique copie ne s'obtient qu'en {$mode Delphi} au niveau de l'entête des unités, car si je bascule en {$mode objfpc}{$H+}, c'est la cata :


C'est quoi la différence ?
Un dernier mot : oui, je suis toujours avec mon vieux couple Laz 1.4 / Fpc 2.6.2, pour un projet Delphi 3 ça ira très bien,

Merci et bon week-end,

[BeanzMaster]

Bonjour !

Jipété, le retour, avec ses misères...

Mais attention ! Cette magnifique copie ne s'obtient qu'en {$mode Delphi} au niveau de l'entête des unités, car si je bascule en {$mode objfpc}{$H+}, c'est la cata :

C'est quoi la différence ?

Merci et bon week-end,

Re-salut la différence entre {$mode Delphi} et {$mode objfpc}{$H+} c'est qu'avec {$mode Delphi} l'écriture du code suit les conventions Delphi.
Ce qui implique des différences mineures dans la façon d'écrire le code. Par exemple, lorsque tu manipule des "pointers" (c'est la cas le plus fréquent que je rencontre ) et c'est le cas ici.
dans ton code

Code :

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

1
2
var
  pbS,pbD: pByte;// pour la Source et la Destination

et tu utilises

Code :

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

1
2
 for w := 0 to (Bitmap.Width * 3)-1 do begin
    pbD[idx] := pbS[w];

en mode {$mode objfpc}{$H+} l'accès aux pointers sous forme de tableaux n'est pas correct


De mémoire, en respectant ton code, pour ce faire, il faudrait que tu utilises un type genre :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
Type
  pByteArray : array[0..maxint] of pByte;
 // ou (je ne me rappel plus trop de la formule magique
 // ByteArray : array[0..maxint] of Byte;
//  pByteArray = ^ByteArray;
 
var
  pbS,pbD: pByteArray;// pour la Source et la Destination
 
for w := 0 to (Bitmap.Width * 3)-1 do begin
    pbD[idx]^ := pbS[w]^; // premier cas
   // pbD^[idx] := pbS^[w]; // deuxieme cas, comme ceci si je me souviens bien

A+

[Jipété]

Salut Jérôme,

De mémoire, en respectant ton code, pour ce faire, il faudrait que tu utilises un type genre :

Code :

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

1
2
3
4
5
6
 
Type
  pByteArray : array[0..maxint] of pByte;
 // ou (je ne me rappelle plus trop de la formule magique
 // ByteArray : array[0..maxint] of Byte;
//  pByteArray = ^ByteArray;

Okay, j'en prends bonne note, mais les choses risquent d'évoluer.
En tout cas j'ai pu simplifier mon bazar, qui devient :

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
var
        //pbS,pbD: pByte;
        pbS: pRGBTriple;
        pbD: pRGBQuad;
 
      for h := 0 to Bitmap.Height-1 do begin
        pbS := pRGBTriple(Bitmap.RawImage.GetLineStart(h));
        pbD := pRGBQuad(RESULT.RawImage.GetLineStart(h));
        for w := 0 to Bitmap.Width-1 do begin
          pbD[w].rgbBlue  := pbS[w].rgbtBlue;
          pbD[w].rgbGreen := pbS[w].rgbtGreen;
          pbD[w].rgbRed   := pbS[w].rgbtRed;
          pbD[w].rgbReserved := 255;
        end;
      end;

EDIT
Ces histoires de chapeaux, ça va me prendre la tête je sens...

Mon nouveau code n'en a pas besoin,

Code :

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

1
2
3
4
5
6
        for w := 0 to Bitmap.Width-1 do begin
          pbD[w].rgbBlue  := pbS[w].rgbtBlue;
          pbD[w].rgbGreen := pbS[w].rgbtGreen;
          pbD[w].rgbRed   := pbS[w].rgbtRed;
          pbD[w].rgbReserved := 255;
        end;

par contre un endroit qui n'était pas concerné réagit maintenant :

Code :

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

1
2
3
4
5
6
7
8
9
      IF   Reverse
      THEN BEGIN
        FOR i := 0 TO Bitmap.Width-1 DO
          RowOut^[i] := RowIn^[Bitmap.Width-1-i]    // 2 chapeaux si pas mode Delphi ! !
      END
      ELSE BEGIN
        FOR i := 0 TO Bitmap.Width-1 DO
          RowOut^[i] := RowIn^[i]    // 2 chapeaux si pas mode Delphi ! !
      END;

Et si je coche la case Reverse, c'est pas glorieux :


Bon, je sais comment m'en dépatouiller, mais y a du pain sur la planche, encore et toujours...
/EDIT



Quant à l'autre sujet, je verrai ça plus tard. Merci pour tes réponses,

[BeanzMaster]

Au vue de tes captures et des rayures (comme d'hab) je penche pour un problème dans le format 32bits vs 24bits. Si tu te sens plus à l'aise tu devrais également utiliser ta structure

Code :

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

1
2
3
4
pbD[w].rgbBlue  := pbS[w].rgbtBlue;
          pbD[w].rgbGreen := pbS[w].rgbtGreen;
          pbD[w].rgbRed   := pbS[w].rgbtRed;
          pbD[w].rgbReserved := 255;

Au lieu de RowOut^[i] := RowIn^[Bitmap.Width-1-i]

[Jipété]

Si tu te sens plus à l'aise tu devrais également utiliser ta structure

Code :

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

1
2
3
4
pbD[w].rgbBlue  := pbS[w].rgbtBlue;
          pbD[w].rgbGreen := pbS[w].rgbtGreen;
          pbD[w].rgbRed   := pbS[w].rgbtRed;
          pbD[w].rgbReserved := 255;

Au lieu de RowOut^[i] := RowIn^[Bitmap.Width-1-i]

laisse tomber, c'est pire !

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
  VAR
    i     :  INTEGER;
    j     :  INTEGER;
    //RowIn :  pRGBArray;
    //RowOut:  pRGBArray;
    RowIn :  pRGBTriple;
    RowOut:  pRGBQuad;
 
      IF   Reverse
      THEN BEGIN
        FOR i := 0 TO Bitmap.Width-1 DO begin
//          RowOut^[i] := RowIn^[Bitmap.Width-1-i]    // 2 chapeaux si pas mode Delphi ! !
          RowOut[i].rgbBlue  := RowIn[Bitmap.Width-1-i].rgbtRed;
          RowOut[i].rgbGreen := RowIn[Bitmap.Width-1-i].rgbtGreen;
          RowOut[i].rgbRed   := RowIn[Bitmap.Width-1-i].rgbtBlue;
          RowOut[i].rgbReserved := 255;
        end;
      END
      ELSE BEGIN
        FOR i := 0 TO Bitmap.Width-1 DO begin
//          RowOut^[i] := RowIn^[i]    // 2 chapeaux si pas mode Delphi ! !
          RowOut[i].rgbBlue  := RowIn[i].rgbtBlue;
          RowOut[i].rgbGreen := RowIn[i].rgbtGreen;
          RowOut[i].rgbRed   := RowIn[i].rgbtRed;
          RowOut[i].rgbReserved := 255;
        end;
      END;
    END;

Bon, je verrai ça plus tard, là j'en ai un peu marre et j'ai faim,

EDIT :
ça va, j'ai trouvé :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
  VAR
    RowIn :  pRGBTriple;
    RowOut:  pRGBTriple;
 
      IF   Reverse
      THEN BEGIN
        FOR i := 0 TO Bitmap.Width-1 DO
          RowOut[i] := RowIn[Bitmap.Width-1-i]    // PAS BESOIN ! 2 chapeaux si pas mode Delphi ! !
      END
      ELSE BEGIN
        FOR i := 0 TO Bitmap.Width-1 DO
          RowOut[i] := RowIn[i]    // PAS BESOIN ! 2 chapeaux si pas mode Delphi ! !
      END;

Va y avoir du sport si selon la routine il me faut utiliser pRGBTriple ou pRGBQuad ! Bref...

Merci pour le coup de main, bon aprème,

[BeanzMaster]

Si tu peux mettre le code en piece jointe je pourrais plus facilement t'aider, si jamais là il me manque un bout de code et je pense que le problème vient du calcul du "scanline" de départ

[Jipété]

Bon, voilà

Résumé de mes notes (2 h de manips) :

inverser 0 et 1 dans la PROCEDURE ModifyOriginalImage et mettre RadioGroupRotate invisible donc copie par CopyRect et pas de SimpleCopyScanline --> copie ok (25 ms)

remis 0 et 1 à l'origine --> traits verticaux sur les 3 quarts de l'image et dernier quart noir --> il y a bien un problème dans FlipReverseScanline

re-essai avec 0 1 inversé (copie par CopyRect pour avoir un BitmapFlipReverse correct) et réactivation SimpleCopyScanline --> 3 quarts corrects et dernier quart noir --> il n'est donc pas possible d'utiliser pRGBArray pour la destination :
- essai avec le couple pRGBTriple-pRGBQuad --> image allongée en traits
- essai avec les pBytes = idem
- essai avec pRGBQuad-pRGBQuad --> OK ! (bizarre qu'il faille un pRGBQuad pour la source, qui est un fichier 24 bits)
- re-essai avec les pBytes en mode sans correction du 4^e byte = 3 quarts ok, 4e noir --> modif de for w := 0 to (Bitmap.Width * 3)-1 en for w := 0 to (Bitmap.Width * 4)-1 = OK

On dirait que malgré le pf24bit du fichier source, on travaille dans le code avec des bitmaps 32 bits car, in fine, ça, ça fonctionne bien, pour la SimpleCopyScanline :

Code :

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

1
2
3
4
5
6
      FOR  j := 0 TO Bitmap.Height - 1 DO BEGIN
        rowIn  := pRGBQuad(Bitmap.RawImage.GetLineStart(j));
        rowOut := pRGBQuad(RESULT.RawImage.GetLineStart(j));
        FOR i := 0 TO Bitmap.Width - 1 DO
          RowOut[i] := RowIn[i];
      END;

Et sans chapeaux !

Ensuite, re-invisible RadioGroupRotate et 0 1 normal donc FlipReverseScanline tout seul --> des traits sur 3/4 d'image et ils recommencent sur le dernier quart (alors que c'est le code allégé strictement identique à celui de SimpleCopyScanline...

En fait ici il faut utiliser en entrée pRGBTriple, et pRGBQuad en sortie :

Code :

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

1
2
3
4
5
6
7
8
9
10
    FOR j := 0 TO Bitmap.Height-1 DO BEGIN
      RowIn :=  pRGBTriple(Bitmap.RawImage.GetLineStart(j));
      RowOut := pRGBQuad(RESULT.RawImage.GetLineStart(j));
      FOR i := 0 TO Bitmap.Width-1 DO begin
        RowOut[i].rgbBlue  := RowIn[i].rgbtBlue;
        RowOut[i].rgbGreen := RowIn[i].rgbtGreen;
        RowOut[i].rgbRed   := RowIn[i].rgbtRed;
        RowOut[i].rgbReserved := 255;
      end;
    END;

Toujours sans chapeaux.

Au bout du compte, réintégration des tests Flip et Reverse dans la proc qui va bien

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
  FUNCTION FlipReverseScanLine(CONST Flip, Reverse:  BOOLEAN;
                               CONST Bitmap:  TBitmap):  TBitmap;
  VAR
    i     :  INTEGER;
    j     :  INTEGER;
    //RowIn :  pRGBArray;
    //RowOut:  pRGBArray;
    RowIn :  pRGBTriple;
    RowOut:  pRGBQuad;
  BEGIN
    IF   Bitmap.PixelFormat <> pf24bit
    THEN RAISE EBitmapError.Create('Can Flip/Reverse only 24-bit bitmap');
 
    RESULT := TBitmap.Create;
    RESULT.PixelFormat := Bitmap.PixelFormat;
    RESULT.Width       := Bitmap.Width;
    RESULT.Height      := Bitmap.Height;
 
    RESULT.BeginUpdate();
    FOR j := 0 TO Bitmap.Height-1 DO BEGIN
      RowIn :=  pRGBTriple(Bitmap.RawImage.GetLineStart(j));
      IF   Flip
      THEN RowOut := pRGBQuad(RESULT.RawImage.GetLineStart(Bitmap.Height - 1 - j))
      ELSE RowOut := pRGBQuad(RESULT.RawImage.GetLineStart(j));
 
      // Optimization technique:  Use two FOR loops so IF is outside of inner loop
      IF   Reverse
      THEN
      FOR i := 0 TO Bitmap.Width-1 DO begin
        RowOut[i].rgbBlue  := RowIn[Bitmap.Width-1-i].rgbtBlue;
        RowOut[i].rgbGreen := RowIn[Bitmap.Width-1-i].rgbtGreen;
        RowOut[i].rgbRed   := RowIn[Bitmap.Width-1-i].rgbtRed;
        RowOut[i].rgbReserved := 255;
      end
      ELSE
      FOR i := 0 TO Bitmap.Width-1 DO begin
        RowOut[i].rgbBlue  := RowIn[i].rgbtBlue;
        RowOut[i].rgbGreen := RowIn[i].rgbtGreen;
        RowOut[i].rgbRed   := RowIn[i].rgbtRed;
        RowOut[i].rgbReserved := 255;
      end;
    END;
    RESULT.EndUpdate();
  END; {FlipReverseScanLine}

et réactivation de la SimpleCopyScanline, et ma foi,



Puis il faudra essayer de comprendre pourquoi pRGBTriple ou pRGBquad pour l'entrée, et enfin travailler sur les 3 autres options de rotation (90, 180 et 270), mais à chaque jour suffit sa peine,


EDIT :
PS : j'ai supprimé le message précédent (celui avec la grande image), confus et qui n'apportait rien. Le pb était ailleurs, comme expliqué ci-dessus.

[Jipété]

Salut,

Je n'ai pas encore attaqué les rotations 90, 180 et 270, car j'ai voulu creuser certains points qui me semblaient mystérieux, et bien sûr la galère du TBitmap sous Linux/Gtk2 réapparaît, donc on ne s'étendra pas dessus, ce n'est pas le sujet.

Je vous note juste deux ou trois points, si jamais certains voulaient travailler sur ce projet :

Code :

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

1
2
3
4
5
6
procedure TFormFlipReverseRotate.btnLoadClick(Sender: TObject);
begin
...
  ShowMessage(GetPixelFormat(BitmapOriginal));
  // les vieux démons sont de retour :
  // mon fichier de test exp32a_250.bmp est un 32 bits, vu ici comme un 24...

Code :

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

1
2
3
4
5
6
procedure TFormFlipReverseRotate.btnSaveClick(Sender: TObject);
begin
  IF   spd.Execute
  THEN imgModified.Picture.Bitmap.SaveToFile(spd.Filename)
  // résultat tout noir et en 24 bits si la source est en 32 bits, ok si en 24
end;

Cœur des fonctions FlipReverseCopyRect et FlipReverseStretchBlt, noter mes commentaires et le fait que j'ai supprimé le "-1" rajouté par EFG : est-ce une obligation sous Windows qu'il faut virer sous Linux ?

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
    // Flip Top to Bottom
    IF   Flip
    THEN BEGIN
      // Unclear why extra "-1" is needed here.
      Top    := src.Height;//-1; // pas compris, car génère un trait noir si présent
      Bottom := -1
    END
    ELSE BEGIN
      Top    := 0;
      Bottom := src.Height
    END;
 
    // Reverse Left to Right
    IF   Reverse
    THEN BEGIN
      // Unclear why extra "-1" is needed here.
      Left  := src.Width;//-1; // pas compris, car génère un trait noir si présent
      Right := -1;
    END
    ELSE BEGIN
      Left  := 0;
      Right := src.Width;
    END;

Allez, j'ai du boulot avec les 3 rotations en attente...


PS : j'ai remodelé la fiche et les codes pour avoir une logique dans l'affichage, et c'est beaucoup plus cool, si si !
Pour ce faire, j'ai "publié" le code d'origine dans un nouveau dossier et en avant, après avoir corrigé ça, bien sûr :

Code :

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

1
2
3
4
// suite "publication" du projet efg et modifs mineures de l'ihm,
// au premier F9, bim !
// FlipReverseRotate.lpr(23,1) Error: Can't open resource file ".../ma_version/FlipReverseRotate.res"
// bravo la "publication" incomplète...

Bah...


EDIT :

Allez, j'ai du boulot avec les 3 rotations en attente...

Torché en 10 minutes, tout était déjà en place, hé hé hé.

Et je vous ai gardé le meilleur pour la fin : efg aussi, il a parfois miséré...
Dans son SimpleCopy dans RotateScanline, lisez mon commentaire :

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
      RESULT.BeginUpdate();
      // Out[i, j] = In[i, j]
      FOR  j := 0 TO src.Height - 1 DO BEGIN
        rowIn  := pRGBQuad(   src.RawImage.GetLineStart(j));
        rowOut := pRGBQuad(RESULT.RawImage.GetLineStart(j));
        FOR i := 0 TO src.Width - 1 DO 
          RowOut[i] := RowIn[i];
        {// gardé pour mémoire :
        FOR i := 0 TO src.Width - 1 DO BEGIN
          //  RowOut[i] := RowIn[i];
          // Why does this crash with RowOut[i] := RowIn[i]?  Alignment? - la misère, efg ?
          // Use this longer form as workaround.
          WITH rowOut[i] DO BEGIN
            rgbRed      := rowIn[i].rgbRed;
            rgbGreen    := rowIn[i].rgbGreen;
            rgbBlue     := rowIn[i].rgbBlue;
            rgbReserved := rowIn[i].rgbReserved;
          END
        END     }
      END;
      RESULT.EndUpdate();

Bon, j'ai changé "Bitmap" partout en "src", plus parlant pour moi, et bien sûr il m'a fallu adapter et donc transformer ses pRGBArray de 3 bytes en pRGBQuad mais voilà,

Merci à tous,