Diviser une chaîne (string) par paquets de 8 caractères [Résolu]

Bacterius 3869 Messages postés samedi 22 décembre 2007Date d'inscription 3 juin 2016 Dernière intervention - 16 févr. 2008 à 22:21 - Dernière réponse : f0xi 4304 Messages postés samedi 16 octobre 2004Date d'inscription 9 mars 2018 Dernière intervention
- 19 févr. 2008 à 10:08
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 !
Afficher la suite 

Votre réponse

6 réponses

Meilleure réponse
f0xi 4304 Messages postés samedi 16 octobre 2004Date d'inscription 9 mars 2018 Dernière intervention - 17 févr. 2008 à 04:58
3
Merci
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;







Merci f0xi 3

Avec quelques mots c'est encore mieux Ajouter un commentaire

Codes Sources a aidé 93 internautes ce mois-ci

Commenter la réponse de f0xi
Bacterius 3869 Messages postés samedi 22 décembre 2007Date d'inscription 3 juin 2016 Dernière intervention - 17 févr. 2008 à 10:21
0
Merci
Bonjour, lol merci beaucoup fOxi je vais me servir de cette procédure :)
Commenter la réponse de Bacterius
Cirec 4231 Messages postés vendredi 23 juillet 2004Date d'inscription 3 août 2018 Dernière intervention - 17 févr. 2008 à 21:48
0
Merci
@ 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 ="" />
Commenter la réponse de Cirec
f0xi 4304 Messages postés samedi 16 octobre 2004Date d'inscription 9 mars 2018 Dernière intervention - 18 févr. 2008 à 20:32
0
Merci
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)


Commenter la réponse de f0xi
Cirec 4231 Messages postés vendredi 23 juillet 2004Date d'inscription 3 août 2018 Dernière intervention - 18 févr. 2008 à 23:38
0
Merci
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="" />
Commenter la réponse de Cirec
f0xi 4304 Messages postés samedi 16 octobre 2004Date d'inscription 9 mars 2018 Dernière intervention - 19 févr. 2008 à 10:08
0
Merci
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 :


Commenter la réponse de f0xi

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.