Image Optimizer

[Shadow]

Spock, tu ne suis pas !
Mais bref...

[Bill Gates]

Chadeau :

- un byte est egal a 8 bits ( 1111 1111 )
- le byte ( ou l'octet ) est l'unité la plus petite

en binaire 255 s'écrit : 1111 1111
en binaire 127 sécrit : 0111 1111

qu'il soit écrit sur le disque, en hexa, en deca , en ce que tu veut, prendra toujours la même place.

tu ne peu pas "gratté" un bit, c'est pas possible. puisqu'au final , tu écrit un octet ( en hexa , en deca , etc... ) , la seule facon de partagé un octet pour 2 couleurs , c'est d'utilisé 4 bits par couleur , ce qui limite ton image à 16 couleurs différentes :

4 bits = 1111
soit 2*2*2*2 possibilité ( 2 car un bit est egal a 0 ou 1 ).

tu n'écoutes pas ce que t'as dit spock , il a pourtant raison sur toute la ligne, tu perds ton temps et le notre a t'expliquer la base.
tu veut faire de la compression , regarde le lien que je t'ai donner plus haut au lieu de m'envoyer pêtre :

Ont a tous débuté un jour aussi con qu'un tous petit tronc d'arbre
et petit à petit ont est devenu Grand chêne, enfin pour certain du moins.

ou des glands, choisi ton fruit.

[SPH]

SPH, oui, 3, 4 c'est pas énorme et tu ne vois pas trop la différence mais tous de même !

C'est sur les couleurs foncées que ca se verra le plus.
Promis, je m'y met tres bientot...

[Shadow]

Bill Gates:

Je comprends très bien se que tu me dis, 1 octets reste un octets et
ont est parfaitement d'accord avec ça toi et moi.

Ce que je fais n'est pas de la compression, mais de l'optimisation si ont veux !
J'optimise la compression de l'image pour 7zip voilà !

Au passage, chapeau pour ton français, la différence
entre certain messages est impressionnante.

SPH, ya pas le feu tkt pas
Ceci fait des années (Pas en continue, très espacé, pas très longtemps à chaque fois) que j’étudie le problèmes !

C'est mon Data comme certain diront !
C'est avec toutes mes "Conneries d’expériences" ou j'ai appris par moi même !

Les autres vont essayer gentiment de t'aider à comprendre (Je parle de moi ici)
mais comme t'es têtu comme une mule et que tu veux comprendre par toi même
et bien il faut bien passer par des heures, des jours voir des semaines à essayer
des tas de choses différentes et ainsi, apprendre, c'est en faisant qu'ont apprends !

Comment ais-je appris le binaire qui est tout con en faite, vraiment tous con
Comment ais-je appris les bases ?

C'est en essayant et avec l'aide aussi des gents qui m'ont aider à faire les code que je voulais !
Je remercie tous ses gents là au passages !

Quand ont est "Un enfant" (Façon de parlé), et qu'on veux expérimenté, peut importe se
que te diront t'es parents, tu voudra essaye par toi même, c'est indispensable !

A moins que tu n'est compris se qu'il voulais te dire mais la c'est autres chose
Le savoir, c'est une science qui ne s’attrape pas avec des bisous mais avec des claques XD.

[Kwai chang caine]

Certes, mais heureusement que les scientifiques de tous bords, ne repartent pas de zéro à chaque fois.
Sinon on en serait encore à étudier la roue.

De mon point de vue, je pense que tu confonds vérifier ou apprendre par l'exercice et rechercher.

Certains bien plus calés que nous ont recherché en nombre, pour nous pondre les bases de toutes choses.

Pour remettre en question ces centaines d'années de recherches continues, il faut un don hors du commun ou bien exceptionnellement, la chance du débutant.

Bien sur, tu vas me rétorquer, que c'est par l'erreur que l'on progresse...ce à quoi je te répondrais, que l'on ne progresse pas par erreur

[Shadow]

Non, je vais te répondre ceci l'ami:

«La plupart des choses importantes dans le monde ont été accomplies par des personnes
qui ont continué à essayer quand il semblait y avoir aucun espoir»

- Pour comprendre la profondeur, il faut savoir chuter
- Qu'elle est la profondeur d'une rivière don ont ne voie pas le fond
- Si l'homme savais que la chandelle est feu alors plus jamais il n'aurais froid

Et si, parfois l'on progresse en faisant des erreurs, souvent même !
Celui qui dis le contraire......

[Micoute]

Pour résumer : on ne donne pas de viande à un bébé, il faut d'abord le diversifier et c'est ce que fait Shadow, il suit son cheminement normal qui va l'amener à la connaissance.

[SPH]

Waouw, c'est beau les mecs

[Shadow]

Spock, intéressent ton discoure

Tu pense que j'avais pas penser à un système de paterne ?
J'ai penser et essayer tellement de chose xd.

Tu ne peut pas faire de paterne avec autant de couleurs.
Et puis faut savoir à quoi correspond se paterne et donc stoker sa réplique !

Si je décide par exemple de faire:
RGB(159, 25, 147), RGB(36, 91, 6), RGB(65, 73, 41) = XFD

Faut bien que je met quelque par que XFD = RGB(159, 25, 147), RGB(36, 91, 6), RGB(65, 73, 41)
Et ça ne s'invente pas !

Et ça prends de la place !
Imagine une image avec 150 000 couleurs xd.

Bref infaisable.

Sinon j'ai noté se que tu as dis, merci.
Le BMP se compresse souvent bien mieux que le format PNG.

Je veux dire que un BMP se compresse très bien et que
ça taille serra souvent plus petite que le PNG et oui !

Sauf que.... si tu met ça en HEX, (Image convertie en HEX)
C'est encore mieux que le BMP !

Enfin après ça dépend quand même avec
quel éditeur tu code l'image en PNG.

Si tu prends paint, ouais la t'as gagner xd mais si tu prends
Gimp, ya des chance pour que tu es perdus lol

Tout est relatif !

Bon, ont arrête les chichi maintenant ok ?
Le jour ou ont fera mieux que PNGGauntlet, c'est pas demain

Au passage je serait très intéresser pour savoir comment ça marche !
Il compresse vraiment super bien l'image pour 0 pertes, comment il fais ça ?

[Shadow]

Hum, je ne voulais en rien t’offenser Spock, désolé

Tu imagine la taille du fichier rien que pour deux pixel de couleur de 24 Bits ?
Ceci nous fait du: 16777216 * 16777216 = 281 474 976 710 656 combinaison possible !

Pour du 32 Bits soyons fou xd: 4294967296 * 4294967296 = 18 446 744 073 709 551 616 combinaison possible !
Tu veux coder ça dans un fichier, un codeur / décodeur ?
Explique sinon

[falsam]

Tu imagine la taille du fichier rien que pour deux pixel de couleur de 24 Bits ?
Ceci nous fait du: 16777216 * 16777216 = 281 474 976 710 656 combinaison possible !

Pour du 32 Bits soyons fou xd: 4294967296 * 4294967296 = 18 446 744 073 709 551 616 combinaison possible !
Tu veux coder ça dans un fichier, un codeur / décodeur ?

Je ne sais pas ce que Spock va imaginer mais pour moi tu es délirant. Et ce sujet va devenir du n'importe quoi. je ne vais pas argumenter : Il suffit de te lire.

[Shadow]

Je crois si je me trompe pas que je n'est jamais parlé de COMPRESSION d'image ici.
Sinon je me suis surement trompé !

Je cherche juste un moyen D'OPTIMISER celle-ci !
Je travail avec 7-Zip.

Je code une image dans différent format dans un fichier texte
et je compresse ensuite se fichier avec 7-Zip.

J'ai jamais rien trouvé de mieux que ça !
C'est 7-Zip qui fais tous le travail !

[SPH]

Voila le code pour compresser un BMP.
Comme promis, on gagne 3/8eme en place :

Code : Tout sélectionner

;#############################################,
#src=0 
#dst=1


Fichier$ = OpenFileRequester("Choisissez un BMP a compresser", "*.bmp", "c:\Users\SPH\Desktop\", 0)

If Fichier$=""
  End
EndIf

LoadImage(#src,fichier$)

larg=ImageWidth(#src)
haut=ImageHeight(#src)

;;;;;;;;;

      CreateFile(#dst, fichier$+".rvb")
      WriteLong(#dst,larg)
      WriteLong(#dst,haut)
        
;;;;;;;;;
      
      Dim p1.b(100)
      Dim p2.b(100)
      Dim p3.b(100)
      p1=0
      p2=0
      
StartDrawing(ImageOutput(0))

For u=0 To haut-1
  For i=0 To larg-1
    x=Point(i,u)
    r=Red(x)/4
    v=Green(x)/4
    b=Blue(x)/4

    For n=1 To 5
      bit = (r>>n)%2
      p1(p2)!(bit<<p1)
      
      bit = (v>>n)%2
      p2(p2)!(bit<<p1)
      
      bit = (b>>n)%2
      p3(p2)!(bit<<p1)
      
      p1+1
      If p1=8
        p1=0
        p2+1
        If p2=40
          Gosub ecrire  
        EndIf
        
      EndIf
      
    Next
  Next
Next

StopDrawing()

;If p1<>0 And p2<>0
  Gosub ecrire
;EndIf

End

;##############################################################
;##############################################################
;##############################################################
;##############################################################


ecrire:

          For ecrire=0 To 39
            WriteByte(#dst,p1(ecrire))
            WriteByte(#dst,p2(ecrire))
            WriteByte(#dst,p3(ecrire))
            ;Debug Bin(p(ecrire))
          Next
          Dim p.b(100)
          p1=0
          p2=0
          
Return

[Shadow]

SPH, c'est pas mal
T'as plus qu'a faire le décodeur maintenant !

Perso j'optients je crois de meilleurs résultat en divisant par 4, que toi.

[Shadow]

Bon après quelques testes...
Suivez bien...

Si j'enregistre une composante R, G, B, A sur 7 bit au lieux de 8, on a un gain potentiel de 1 Bits par composante ok ?
Donc 7 Bits dans un fichier, + 7 etc...

Au final beaucoup de gains mais......
C'est en faite c'est un leur et je vais vous dire pourquoi.

Enregistrer une image en Binaire est moins efficace que en HEX.
A partir d'ici il y a donc un problème.

Si par exemple j'ai 4 couleur:

1- RGB(12, 159, 95), RGB(45, 73, 125), RGB(37, 82, 74)
2- RGB(12, 159, 95), RGB(45, 73, 125), RGB(37, 82, 74)
3- RGB(12, 159, 95), RGB(45, 73, 125), RGB(37, 82, 74)
5- RGB(12, 159, 95), RGB(45, 73, 125), RGB(37, 82, 74)

4 Couleur qui se suivent.
Dans un fichier texte, ceci serra compressé si ont le compresse avec 7-Zip par exemple.

Maintenant regardez se qui se passe si je met ça en binaire en divisant les valeurs par 2:

12 / 2 = 6 = 0001100
159 / 2 = 79 = 1001111
95 / 2 = 0101111

Donc nous auront ceci: 000110010011110101111
x 12 pour 12 composante, voir plus haut:

000110010011110101111000110010011110101111000110010011110101111
000110010011110101111000110010011110101111000110010011110101111
000110010011110101111000110010011110101111000110010011110101111
000110010011110101111000110010011110101111000110010011110101111

Ici va commencer les problèmes:

Si je code ça sur 1 octets (Par 8 Bits) ça donne ceci (Je ne met pas les octets mais imaginez que les 8 Bits sont un caractère Ascii):

00011001 00111101 01111000 11001001 11101011 11000110 01001111 0101111

Nous avons ici donc 8 caractères totalement différents.
Alors que à l'origine c'était des octets qui étais identique !

12, 159, 95, 12, 159, 95, 12, 159, 95, 12, 159, 95
12, 159, 95, 12, 159, 95, 12, 159, 95, 12, 159, 95
12, 159, 95, 12, 159, 95, 12, 159, 95, 12, 159, 95

Nous auront donc (Je ne met pas les octets mais imaginez que les 8 Bits sont un caractère Ascii):

00011001 00111101 01111000 11001001 11101011 11000110 01001111 0101111
00011001 00111101 01111000 11001001 11101011 11000110 01001111 0101111
00011001 00111101 01111000 11001001 11101011 11000110 01001111 0101111
00011001 00111101 01111000 11001001 11101011 11000110 01001111 0101111

Ici la compression serra bien moins bonne !
Ex:

(4 x) 00011001 00111101 01111000 11001001 11101011 11000110 01001111 0101111 (Ici 8 octets)
(12 x) 12, 159, 95 (Ici 3 octets)

Voilà donc au final coder une couleur sur 7 Bits et mettre ça dans un fichier pour au finale
recorder le tous en Octets serra penne perdus et inefficace !