Diviser une chaîne (string) par paquets de 8 caractèresRésolu

Question

Bonjour,
alors voila, c'est à propos d'une application client/serveur TCP.
Le TCP client envoie tous les codes couleur d'une image 1 par 1 sur le serveur.
Mais le serveur reçoit donc une grande chaîne genre couleur1couleur2couleur3 (jusqu'a couleur 2500 -_-' ) et je voudrais savoir si il existe un moyen de diviser cette chaîne en 2500 paquets de 8 caractères (longueur d'un code couleur) pour les réstituer ?
Si quelqu'un connaît une fonction...

Merci, et à bientôt !

f0xi · Accepted Answer

type
  TBitsOrder = (boABGR, boARGB, boRGBA, boBGRA);
  TColorsArray = array of integer;

procedure SplitColors(const S : String; var Colors: TColorsArray; const BitsOrder: TBitsOrder= boABGR);
var n : integer;
    pS : PChar;
begin
  pS := PChar(S);
  SetLength(Colors, (Length(S) div 8));
  case BitsOrder of
    boABGR : for n := 0 to high(Colors) do
             begin
               Colors[n] := StrToIntDef('$'+pS[0]+pS[1]+pS[2]+pS[3]+pS[4]+pS[5]+pS[6]+pS[7], -1);
               inc(pS, 8);
             end;
    boARGB : for n := 0 to high(Colors) do
             begin
               Colors[n] := StrToIntDef('$'+pS[0]+pS[1]+pS[6]+pS[7]+pS[4]+pS[5]+pS[2]+pS[3], -1);
               inc(pS, 8);
             end;
    boRGBA : for n := 0 to high(Colors) do
             begin
               Colors[n] := StrToIntDef('$'+pS[6]+pS[7]+pS[4]+pS[5]+pS[2]+pS[3]+pS[0]+pS[1], -1);
               inc(pS, 8);
             end;
    boBGRA : for n := 0 to high(Colors) do
             begin
               Colors[n] := StrToIntDef('$'+pS[6]+pS[7]+pS[0]+pS[1]+pS[2]+pS[3]+pS[4]+pS[5], -1);
               inc(pS, 8);
             end;
  end;
end;

EXEMPLE :

var
  CA : TColorsArray;
  PA : array[0..7] of ^Tcolor;
  n : integer;

procedure TForm1.FormCreate(Sender: TObject);
begin
  PA[0] := @Panel1.color;
  PA[1] := @Panel2.color;
  PA[2] := @Panel3.color;
  PA[3] := @Panel4.color;
  PA[4] := @Panel5.color;
  PA[5] := @Panel6.color;
  PA[6] := @Panel7.color;
  PA[7] := @Panel8.color;
  { bleu, vert, rouge, cyan, jaune, magenta, blanc, noir }
  SplitTheFuckingStr('00FF00000000FF00000000FF00FFFF0000FF00FF0000FFFF00FFFFFF00000000', CA);

  for n := 0 to high(PA) do
    PA[n]^ := clBtnFace;

  for n := 0 to High(CA) do
    PA[n]^ := CA[n];
end;

Bacterius · Answer

Bonjour, lol merci beaucoup fOxi je vais me servir de cette procédure :)

Cirec · Answer

@ F0xi :
Salut,

je pense qu'une petite erreur c'est glissée dans ton code :

...
    boBGRA : for n :=  0 to high(Colors) do
             begin
               Colors[n] := StrToIntDef('$'+pS[6]+pS[7]+pS[0]+pS[1]+pS[2]+pS[3]+pS[4]+pS[5], -1);
               inc(pS, 8);
             end;
...

 devrait être : (Si je ne fais pas d'erreur )
...
    boBGRA : for n : = 0 to high(Colors) do
             begin
               Colors[n] :=  StrToIntDef('$'+pS[ 2 ]+pS[3]+pS[4]+pS[5]+pS[6]+pS[7]+pS[0]+pS[1], -1);
               inc(pS, 8);
             end;
...

qu'en penses-tu 

 
@+
Cirec

<hr siz ="" />

f0xi · Answer

non cirec :

prenons l'exemple : 52 de rouge 7F de vert 9C de bleu et 00 alpha

ABGR (format delphi) : 00 9C 7F 52
ARGB (format web/windos) : 00 52 7F 9C
RGBA : 52 7F 9C 00
BGRA : 9C 7F 52 00

donc pour convertir tout cela en ABGR (delphi) :

ABGR -> ABGR = 0.1 2.3 4.5 6.7
ARGB -> ABGR = 0.1 6.7 4.5 2.3
RGBA -> ABGR = 6.7 4.5 2.3 0.1
BGRA -> ABGR = 6.7 0.1 2.3 4.5

en fait ce que tu as du comprendre c'est que ma fonction convertis la couleur (texte) en couleur (uint 32)
aurais-je du preciser que ma fonction convertis les couleurs (texte) en couleur ABGR (delphi)

d'ailleur mon type s'appel bien BitsOrder et non ColorFormat !

en gros delphi utilise bien un format de couleur RGBA mais quand on lit l'ordre des bits a partir d'un uint 32 on a ABGR :
AA BB GG RR
bit 31 ... bit 0

alors que COLORREF :
AA RR GG BB
bit 31 .. bit 0

voila :)

donc dans ta "correction" l'ordre n'est pas bon puisqu'avec l'exemple nous avons le texte :

'9C7F5200' a convertir en couleur delphi = $009C7F52 

et avec ta correction :
'9C7F5200' = $7F52009C 

donc on retrouve le bleu dans les bits du rouge, l'alpha dans les verts, le rouge dans les bleu et le vert dans l'alpha ... 
en GDI+ ça passerais, on obtiendrais un bleu lavande avec 50% de transparence ... mais on aurait pas notre marron caca bien opaque ... 
et donc tu comprend que passer du marron caca bien opaque au bleu lavande semi-transparent... c'est presque de la magie...
même canard WC n'y arrive pas ... haha
(la prochaine je regarderais avant la couleur que je choisis pour mes exemples)

Cirec · Answer

Justement je me mélange les pinceaux avec ces satanés couleurs

Et avec les 3 premiers j'arrive à comprendre l'ordre 
et comme je l'ai mis en couleur c'est encore plus évident ... 
mais avec le BGRA (le 4ème)  j'y trouve aucune logique !!!!

ABGR -> ABGR =  0.1 2.3 4.5 6.7
ARGB -> ABGR = 0.1 6.7 4.5 2.3
RGBA -> ABGR = 6.7 4.5 2.3 0.1
Si on suit cette logique le 4ème devrait être :
BGRA -> ABGR = 2.3 4.5 6.7 0.1 
Mais tu dis que c'est :
BGRA -> ABGR = 6.7 0.1 2.3 4.5

Si on teint compte des 3 premiers on peut dire que :
A 0.1  Bit 0..1 AlphaB 2.3  Bit 2..3 BlueG 4.5  Bit 4..5 GreenR 6.7  Bit 6..7 Red

mais le 4 ème donne :A 4.5  Bit 4..5 GreenB 6.7  Bit 6..7 RedG 0.1  Bit 0..1 AlphaR 2.3  Bit 2..3 Blue

Pourtant dans l'exemple que tu me donnes (au début) tu respectes bien la logique sur les 4 versions 
ABGR (format delphi) : 00 9C 7F 52
ARGB (format web/windos) : 00 52 7F 9C
RGBA : 52 7F 9C 00
BGRA : 9C 7F 52 00  !!!!!!!!!!!

et quand tu me dis :
" donc on retrouve le bleu dans les bits du rouge, l'alpha dans les verts, le rouge dans les bleu et le vert dans l'alpha ...  "
C'est exactement l'impression que j'ai avec les valeurs de ton BGRA !!!!
(BGRA -> ABGR  = 6.7 0.1 2.3 4.5)

J'y comprend plus rien ... au secoure je me noie  

à quel moment je m'emmêle les pinceaux 
 
@+
Cirec

<hr siz="" />

f0xi · Answer

haha! 

normal :

le code est :

un texte qui represente une couleur avec un ordre des octets de couleurs bien definit, l'ordre peut etre :
ABGR
ARGB
BGRA
RGBA

puisqu'il n'existe pas (a ma connaissance) des couleurs exotique du genre :

RABG
GBAR

etc...

a convertir en chaine $aaBBggRR puis a convertir en int32. 

donc : 
[01 23 45 67] ---> [01 23 45 67] (index des caracteres (PChar))

[AA BB GG RR] ---> [AA BB GG RR] (ordre des octets de la couleur)
[0  1  2  3 ] ---> [0  1  2  3 ] (numero des octets)
convertion de AABBGGRR vers $AABBGGRR (pas de changement dans l'ordre)

[01 23 45 67] ---> [01 67 45 23]

[AA RR GG BB] ---> [AA BB GG RR] 
[0  1  2  3 ] ---> [0  3  2  1 ] 
alpha ne bouge pas, rouge passe a la fin, vert ne bouge pas, bleu passe aprés alpha et avant vert.

[01 23 45 67] ---> [67 45 23 01]

[RR GG BB AA] ---> [AA BB GG RR] 
[0  1  2  3 ] ---> [3  2  1  0 ] 
ici on as un palindrome (RRGGBBAA AABBGGRR), on inverse donc l'ordre de façon decroissante

[01 23 45 67] ---> [67 01 23 45]

[BB GG RR AA] ---> [AA BB GG RR] 
[0  1  2  3 ] ---> [3  0  1  2 ] 
ici nous avons deja BGR (parfait) mais alpha est a la fin, il faut donc seulement remettre alpha au debut.

voila, est n'oublis pas que ce n'est pas une suite mathematique ou logique, c'est juste une question d'ordre des octets 
(donc logique uniquement qu'en cas par cas).
voila le mots, cas par cas, chaque cas est independant des autres, il n'y a aucuns rapport logique entre les 4 cas.
et leurs seul point comun etant que ce sont tous des representations de couleur a convertir en couleur delphi.

mais je te comprend cirec, entre la representation RGBA, ARGB (a lire de gauche a droite)  et le stockage 32 bits BGRA, ABGR (binaire donc de droite a gauche en mode Intel) c'est un peu chaud de si retrouver.
c'est je pense, aprés les pointeurs, le deuxieme concept le plus difficile a maitriser.
et cela concerne :
Les couleurs 16, 24 et 32 bits
Les numero de version (Major, minor, Release, build ==> $mmMMbbRR)
Les signature de fichier 32 bits (JPGx ($4A, $50, $47, $78) ==>   $7847504A)
etc etc ...
la lecture est differente entre le mode Texte (GD) et la donnée binaire stockée dans un entier (DG).

donc y'a pas d'erreur dans ma procedure :)

je viens de te faire un shema, en esperant que ça t'aide :

Diviser une chaîne (string) par paquets de 8 caractères

6 réponses

Votre réponse

Discussions similaires