transformer une image en suite binaire

[Bimini]

Bonjour à tous,

J'aimerai trouver un moyen de transformer une image en suite binaire.
Je m'explique :
Je vais concevoir une image, réellement un dessin au trait noir sur fond blanc, rien de compliqué. J'exporterai cette image au format le plus approprié pour ce que je veux faire pour la suite.
Bref... une fois que j'ai mon image, j'aimerai avoir l'équivalent en suite de "0" et de "1" que je pourrais copier coller sur un traitement de texte.
Connaissez-vous un logiciel qui fasse ça sous Mac ou PC ?

Merci pour votre aide,

Michaël.
-----

[invite329675bd]

Bonjour,

Essaye avec WinHex, il n'est pas simple à comprendre toute ses fonctionnalités et à utiliser mais il fait tout.

http://www.toocharger.com/fiches/log...inhex/9995.htm

[Bimini]

Bonjour à tous,

Merci Iyvosy pour ton aide.
Effectivement ce logiciel n'est pas simple et en essayant pas mal de chose, je ne suis pas arrivé à convertir l'hexadécimal en binaire directement avec ce soft.
En revanche, j'ai copié la suite hexadécimale que j'ai collé dans un convertisseur en ligne que j'ai trouvé ici.
J'en ai tiré une suite binaire.
Le problème c'est que je n'ai pas pu vérifier le résultat. En effet sur ce même convertisseur, la conversion en texte ne se fait pas sous la même norme (si j'ai bien compris) que le logiciel. Je n'ai donc pas pu reconvertir en hexadécimale et retrouver mon image.

L'idée est que si une personne, avec le matériel qu'il faut, reconvertit cette suite binaire en image, je voudrais qu'il retombe sur mon image.

Si quelqu'un peut approuver ma démarche pour me confirmer mon résultat binaire ou me corriger, je suis preneur de vos suggestions.

En attendant bonne fin de nuit à tous,

Michaël.

[invite9b7cd1a6]

Je ne suis pas certain de ce que j'avancerai ici:

Une image, matrice XY est le résultat de son format, comme tu sais probablement En effet, celle-ci peut être compressé (et là tu n'y arrivera pas) ou non compressé (où tu pourrais y arriver). Si tu utilisais par exemple, le format Bitmap (BMP) de Windows, type non compressé où ses pixels sont tous indépendants d'altérations et/ou de modifications, je crois que tu pourrais créer des images TRÈS BASIQUES de quelques bits (N'espère pas créer manuellement une image mortelle! ).

Pour créer ton image au format standard, il te faudra 4 blocs principaux:

Le format standard BMP contient l'entête principale, que tu devra connaître, l'entête DIB (DIB header) qui contient les informations nécéssaire de ton bitmap, les couleurs et les pixels eux mêmes (car un image, c'est en fait une matrice XY).

Voici, deux liens qui peut te donner des exemples sur le format

http://www.digicamsoft.com/bmp/bmp.html
http://www.daubnet.com/en/file-format-bmp

Une fois les blocs crées, tu devrait pouvoir "programmer" ton image en binaire.

[A voir en vidéo sur Futura]

[Bimini]

Bonjour tout le monde,

Merci Padboy pour ta participation. Je n'ai fait que survoler les pages que tu m'as proposé . ça devient trop technique pour moi mais c'est surtout en anglais.

Je ne suis pas sûr que tu ais compris ce que je cherche. Ou alors c'est moi qui n'ai pas compris le sens de ton post.

Je ne cherche pas à écrire une suite de 0 et de 1 pour composer une image.

J'ai une image. C'est un symbole en noir (0,0,0) et blanc (255,255,255) sans aucun dégradé de gris.

Ce que je veux, c'est de quoi trouver l'équivalent binaire de cette image. En somme, je vois des pixels blancs et noirs ordonnés d'une certaine manière et j'aimerai voir la suite de 0 et 1 que le processeur envoie à la carte graphique.

Je laisse le soin aux logiciels de "traduire" un graphique au code binaire. Chose que j'ai à priori réussi à faire. Mais ce dont je voudrais être sûr, c'est que si quelqu'un a un logiciel qui "traduit" du code binaire au graphique, il retombe sur ledit symbole.

A bientôt,

Michaël.

[invite9b7cd1a6]

Si tu ouvres ton image dans un logiciel hexadécimal, comme on l'a mentionné plus haut, en mode binaire, tu verras des 01. Ensuite, garde la suite de 01, ouvre une nouvelle fenetre dans le logiciel colle la suite binaire et ré enregistre-la.

Ton image devrait apparaître...

Sinon, hier soir, je t'ai programmé un petit exécutable tout simple, je pourrais l'uploadé, qui fait ce que tu veux... Mais je suis à l'université en ce moment..

[Bimini]

Bonjour tout le monde,

Merci Padboy. Effectivement je serais très intéressé par ton programme.

En fait avec le soft qu'Iyvosy m'a proposé j'ai réussi sans aucun problème à récupérer la suite hexadécimale. Mais pour une raison que j'ignore (mis à part le fait que je n'y comprenais pas grand chose) je ne pouvais pas convertir en mode binaire (message d'erreur).

Merci Padboy pour ton aide et j'attends ton exécutable avec impatience.

A bientôt,

Michaël.

[polo974]

Sinon, il y a gimp
charger l'image
puis menu
image/mode/couleurs indexées
choisir palette noir et blanc
choisir éventuellement un tramage si l'image est en couleur ou gris

enfin menu
fichier/enregistrer sous
choisir entête de code source C (*.h)

donner un nom finissant en .h

et le célèbre tux donne ça (avec des coupures ........ pour faire moins long:

/*  GIMP header image file format (INDEXED): /home/.........../tuxblanc.h  */

static unsigned int width = 400;
static unsigned int height = 479;

/*  Call this macro repeatedly.  After each use, the pixel data can be extracted  */

#define HEADER_PIXEL(data,pixel) {\
pixel[0] = header_data_cmap[(unsigned char)data[0]][0]; \
pixel[1] = header_data_cmap[(unsigned char)data[0]][1]; \
pixel[2] = header_data_cmap[(unsigned char)data[0]][2]; \
data ++; }

static char header_data_cmap[256][3] = {
    {255,255,255},
    {  0,  0,  0},
    {255,255,255},
    {255,255,255},
..............
    {255,255,255},
    {255,255,255}
    };
static char header_data[] = {
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
...........
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
    0,0,0,0,0,0,0,0,0,1,0,1,1,1,1,1,
    1,1,1,1,0,1,0,1,0,0,0,0,0,0,0,0,
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
...........
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,
    1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
    1,1,0,1,0,0,0,0,0,0,1,0,0,0,0,0,
    0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,
    1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
    1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
...........
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,
    1,1,1,1,1,1,1,0,0,0,0,1,0,0,1,0,
    0,1,0,1,0,0,1,0,0,0,0,1,0,0,1,0,
    0,1,0,0,1,0,0,1,0,0,1,0,1,0,0,1,
    0,1,0,0,1,0,0,1,0,0,0,1,0,1,0,0,
    0,0,1,0,0,1,0,0,0,0,1,0,0,1,0,1,
    0,0,1,0,0,1,0,0,1,0,0,0,1,1,1,1,
    1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
...........
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
    0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,
    1,1,0,1,1,1,0,1,0,1,1,1,1,1,1,0,
    1,0,1,1,1,1,0,1,1,1,1,0,1,1,1,1,
    1,0,1,1,0,1,1,1,0,1,0,1,1,1,0,1,
    0,1,1,1,1,0,1,1,1,0,1,0,1,0,1,1,
    0,1,1,1,0,1,1,0,1,1,1,1,1,1,0,1,
    1,1,0,1,0,1,1,1,0,1,1,1,0,1,1,1,
    0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
    1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
...........
    1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,
    1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
    1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
    1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
...........
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
    };

Bref une suite de 0 et 1, avec au début les dimensions et une palette de couleur.

Bon la palette ne sert pas à grand chose ici, mais les 0 et 1 sont là!

Un petit coup d'éditeur de texte et hop...

[Bimini]

Bonjour à tous,

Merci Polo974. Je ne vais pas tester cette nuit, mais très rapidement.
Je redonne des nouvelles donc d'ici 1 ou 2 jours.

A bientôt,

Michaël.

[Bimini]

Bonjour à tous,

Bon... Je suis de retour plus tôt que prévu.
J'ai donc téléchargé GIMP et j'ai réussi à avoir mon fichier .h avec plein de 0 et 1.
C'est super.
En cherchant à savoir ce qu'est un fichier en .h, j'ai cru comprendre qu'il s'agissait de fichier faisant partie d'un programme écrit en C++.
Maintenant que j'ai cette suite en code binaire, quel logiciel pourra reconstituer l'image à partir de mon fichier .h ?
Bêtement, mais on ne sais jamais, j'ai tenté de l'ouvrir avec GIMP mais ça n'a pas marché.

Merci à tous,

Michaël.

[polo974]

Petit rappel:

Bonjour à tous,
...
Bref... une fois que j'ai mon image, j'aimerai avoir l'équivalent en suite de "0" et de "1" que je pourrais copier coller sur un traitement de texte.
...
Merci pour votre aide,
Michaël.

Ben voilà c'est une suite de "0" et "1" que tu peux copier coller sur un traitement de texte...

En fait, si tu disais ce que tu voudrais faire d'un bout à l'autre (et d'un seul coup!)...

[sitalgo]

B'jour,

Bêtement, mais on ne sais jamais, j'ai tenté de l'ouvrir avec GIMP mais ça n'a pas marché.

Ben forcément, il n'y a pas d'en-tête à ce fichier image, il n'est donc pas exploitable par les logiciels courants. Par contre il peut l'être avec une macro.

Le plus simple est de faire ou d'importer une image avec paint, de la sauver en monochrome (en fait 2 couleurs, 1 bit par pixel) et de l'afficher avec une macro qui ne lit que les données intéressantes : largeur et hauteur de l'image et données de l'image.
En format bmp les données commencent par la dernière ligne de l'image. On trouve sur google la composition de l'en-tête.

[JPL]

En fait, si tu disais ce que tu voudrais faire d'un bout à l'autre (et d'un seul coup!)...

Oui ce serait bien parce que je n'ai pas compris la finalité de l'opération demandée. Coller une suite de 0 et 1 dans un traitement de texte... mais pour quoi faire ?

[sitalgo]

mais pour quoi faire ?

Pour que ça fasse une image, comme il y a 40 ans on faisait la fameuse tête de cheval avec des X, /, ° etc. sur du papier continu. Bien que moche, c'était du boulot.

[JPL]

Je me souviens en effet. Mais dans ce cas il faut aussi penser à afficher avec une police à espacement fixe, comme Courier.

[sitalgo]

Les chiffres sont toujours à espacement fixe, du moins dans les fontes sérieuses.

[JPL]

Ce n'est pas toujours le cas pour les fontes à espacement proportionnel. L'exemple type est le Times New Roman distribué par Microsoft qui n'obéit pas à cette règle tandis que j'ai un Times (dont j'ai oublié l'origine) qui la respecte. De même j'ai deux Palatino qui diffèrent de ce point de vue.

[sitalgo]

Ce n'est pas toujours le cas pour les fontes à espacement proportionnel. L'exemple type est le Times New Roman distribué par Microsoft qui n'obéit pas à cette règle tandis que j'ai un Times (dont j'ai oublié l'origine) qui la respecte. De même j'ai deux Palatino qui diffèrent de ce point de vue.

C'est bien ce que je dis "du moins dans les fontes sérieuses". Il n'y a pas que ça : absence de æ et œ, majuscules accentuées, vraie apostrophe, mais cela concerne surtout les polices fantaisie.
J'ai deux times, HP et Monotype (fourni avec win), les chiffres sont fixes, mais bon, faut effectivement faire gaffe.

[Bimini]

Bonjour à tous...

...Et merci pour votre participation.

Pour ce qui est de dire ce que je veux "faire d'un bout à l'autre (et d'un seul coup!)", il me semblait l'avoir déjà fait. Cela dit, je vais tâcher de m'exprimer plus clairement :
1 - J'ai une image.
2 - Je veux en tirer une suite de 0 et de 1.
3 - Je veux m'assurer que quelqu'un d'autre puisse retrouver mon image à partir de cette suite binaire.

Maintenant pour ce que je veux EN faire, à savoir la finalité de cet exercice, je dirais simplement que cette suite binaire fera partie intégrante d'un texte (raison pour laquelle je voulais l'exploiter sur un traitement de texte). Rien de caché dans cette suite, du genre la tête de cheval, d'autant plus que je ne sais pas si la police que j'utiliserai pour diffuser le texte respecte l'espacement proportionnel.

Voilà, j'espère avoir été plus clair cette fois-ci.

A bientôt,

Michaël.

[invite9b7cd1a6]

J'ai perdu mon source. Je te reprogramme ca à l'instant, et je l'envoie dans quelques minutes...

[Bimini]

Merci Padboy,

C'est très gentil de ta part.

Michaël.

[invite9b7cd1a6]

Voila le code dont je te parlais.

Le code est lourd parfois pour le processeur et je n'ai pas eu le temps de l'optimiser... Le code fonctionne avec de PETITES images... Je l'ai tester sur plusieurs images, et il fonctionnait... Bon mes images étaient simple.

J'ai donc zippé le logiciel, un petit tuto d'utilisation ainsi que l'image que j'utilisais.

J'espère que ca fonctionnera pour toi.

Tiens-moi au courant!

[invite9b7cd1a6]

Essaie par exemple de trouver la signification de ce message (enregistre le dans le bloc note sous l'extension .binaire et ouvre-le avec le logiciel. Cependant, si tu veux cacher ce genre de message dans un document Word par exemple, bonne chance car c'est vraiment gros pour une minuscule image...

11111111 11011000 11111111 11100000 00000000 00010000 01001010 01000110
01001001 01000110 00000000 00000001 00000001 00000001 00000000 01100000
00000000 01100000 00000000 00000000 11111111 11011011 00000000 01000011
00000000 00001000 00000110 00000110 00000111 00000110 00000101 00001000
00000111 00000111 00000111 00001001 00001001 00001000 00001010 00001100
00010100 00001101 00001100 00001011 00001011 00001100 00011001 00010010
00010011 00001111 00010100 00011101 00011010 00011111 00011110 00011101
00011010 00011100 00011100 00100000 00100100 00101110 00100111 00100000
00100010 00101100 00100011 00011100 00011100 00101000 00110111 00101001
00101100 00110000 00110001 00110100 00110100 00110100 00011111 00100111
00111001 00111101 00111000 00110010 00111100 00101110 00110011 00110100
00110010 11111111 11011011 00000000 01000011 00000001 00001001 00001001
00001001 00001100 00001011 00001100 00011000 00001101 00001101 00011000
00110010 00100001 00011100 00100001 00110010 00110010 00110010 00110010
00110010 00110010 00110010 00110010 00110010 00110010 00110010 00110010
00110010 00110010 00110010 00110010 00110010 00110010 00110010 00110010
00110010 00110010 00110010 00110010 00110010 00110010 00110010 00110010
00110010 00110010 00110010 00110010 00110010 00110010 00110010 00110010
00110010 00110010 00110010 00110010 00110010 00110010 00110010 00110010
00110010 00110010 00110010 00110010 00110010 00110010 11111111 11000000
00000000 00010001 00001000 00000000 00011010 00000000 01110000 00000011
00000001 00100010 00000000 00000010 00010001 00000001 00000011 00010001
00000001 11111111 11000100 00000000 00011111 00000000 00000000 00000001
00000101 00000001 00000001 00000001 00000001 00000001 00000001 00000000
00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001
00000010 00000011 00000100 00000101 00000110 00000111 00001000 00001001
00001010 00001011 11111111 11000100 00000000 10110101 00010000 00000000
00000010 00000001 00000011 00000011 00000010 00000100 00000011 00000101
00000101 00000100 00000100 00000000 00000000 00000001 01111101 00000001
00000010 00000011 00000000 00000100 00010001 00000101 00010010 00100001
00110001 01000001 00000110 00010011 01010001 01100001 00000111 00100010
01110001 00010100 00110010 10000001 10010001 10100001 00001000 00100011
01000010 10110001 11000001 00010101 01010010 11010001 11110000 00100100
00110011 01100010 01110010 10000010 00001001 00001010 00010110 00010111
00011000 00011001 00011010 00100101 00100110 00100111 00101000 00101001
00101010 00110100 00110101 00110110 00110111 00111000 00111001 00111010
01000011 01000100 01000101 01000110 01000111 01001000 01001001 01001010
01010011 01010100 01010101 01010110 01010111 01011000 01011001 01011010
01100011 01100100 01100101 01100110 01100111 01101000 01101001 01101010
01110011 01110100 01110101 01110110 01110111 01111000 01111001 01111010
10000011 10000100 10000101 10000110 10000111 10001000 10001001 10001010
10010010 10010011 10010100 10010101 10010110 10010111 10011000 10011001
10011010 10100010 10100011 10100100 10100101 10100110 10100111 10101000
10101001 10101010 10110010 10110011 10110100 10110101 10110110 10110111
10111000 10111001 10111010 11000010 11000011 11000100 11000101 11000110
11000111 11001000 11001001 11001010 11010010 11010011 11010100 11010101
11010110 11010111 11011000 11011001 11011010 11100001 11100010 11100011
11100100 11100101 11100110 11100111 11101000 11101001 11101010 11110001
11110010 11110011 11110100 11110101 11110110 11110111 11111000 11111001
11111010 11111111 11000100 00000000 00011111 00000001 00000000 00000011
00000001 00000001 00000001 00000001 00000001 00000001 00000001 00000001
00000001 00000000 00000000 00000000 00000000 00000000 00000000 00000001
00000010 00000011 00000100 00000101 00000110 00000111 00001000 00001001
00001010 00001011 11111111 11000100 00000000 10110101 00010001 00000000
00000010 00000001 00000010 00000100 00000100 00000011 00000100 00000111
00000101 00000100 00000100 00000000 00000001 00000010 01110111 00000000
00000001 00000010 00000011 00010001 00000100 00000101 00100001 00110001
00000110 00010010 01000001 01010001 00000111 01100001 01110001 00010011
00100010 00110010 10000001 00001000 00010100 01000010 10010001 10100001
10110001 11000001 00001001 00100011 00110011 01010010 11110000 00010101
01100010 01110010 11010001 00001010 00010110 00100100 00110100 11100001
00100101 11110001 00010111 00011000 00011001 00011010 00100110 00100111
00101000 00101001 00101010 00110101 00110110 00110111 00111000 00111001
00111010 01000011 01000100 01000101 01000110 01000111 01001000 01001001
01001010 01010011 01010100 01010101 01010110 01010111 01011000 01011001
01011010 01100011 01100100 01100101 01100110 01100111 01101000 01101001
01101010 01110011 01110100 01110101 01110110 01110111 01111000 01111001
01111010 10000010 10000011 10000100 10000101 10000110 10000111 10001000
10001001 10001010 10010010 10010011 10010100 10010101 10010110 10010111
10011000 10011001 10011010 10100010 10100011 10100100 10100101 10100110
10100111 10101000 10101001 10101010 10110010 10110011 10110100 10110101
10110110 10110111 10111000 10111001 10111010 11000010 11000011 11000100
11000101 11000110 11000111 11001000 11001001 11001010 11010010 11010011
11010100 11010101 11010110 11010111 11011000 11011001 11011010 11100010
11100011 11100100 11100101 11100110 11100111 11101000 11101001 11101010
11110010 11110011 11110100 11110101 11110110 11110111 11111000 11111001
11111010 11111111 11011010 00000000 00001100 00000011 00000001 00000000
00000010 00010001 00000011 00010001 00000000 00111111 00000000 11110111
11111010 00101011 11001101 10010010 11000010 00110101 11010100 11111100
01111011 00001101 10010110 10000111 00011101 11011100 10100010 11100110
00101111 00100101 00010000 00100100 01100001 01011000 11011010 01000101
11001000 00111111 01111001 01111001 00100100 11100101 01000001 00111110
10011001 00110101 11010001 01101001 10111010 10101101 10001000 11010011
01111100 00101101 00101011 01101010 00110111 01110111 10001101 01110110
10000010 11011010 00001001 11000000 01100101 01011001 11100100 11110010
10001011 00110011 01001010 10111100 01100000 11100010 00110111 00111000
00100011 10000011 10011010 00000000 11101001 11101000 10101110 01111110
00011111 00010111 11011000 11011100 00111101 10111010 11000111 01101101
01111000 01001101 11001101 11001100 11110110 01110000 11100110 00110101
00011011 11100110 10000100 10111000 01110100 11100101 10111000 00111000
10001101 11001110 01001110 00000110 00010111 10101000 00111100 01010001
00111110 10111111 10100111 11001111 10100010 01011001 01101010 11110010
00110101 11100100 00110000 11111101 10110001 00100001 00101001 00011001
11000011 00101100 11000110 01011111 00100111 11001011 10010011 01101001
00100000 10000001 00100001 11011010 01111001 00100011 00100011 10101001
10100000 00001110 10000010 10001010 11000011 10010011 11000101 01011010
01111100 01010111 01110011 11000000 11101001 01110000 00111110 11001111
01111101 00010101 10000100 11010010 01111001 01111111 00101010 01001011
00100000 01001111 00101100 01110101 11001001 00001101 11100110 00100000
11001000 00000111 00011001 11100111 00000011 10011010 10110001 01101101
01111001 01101011 11111111 00000000 00001001 00010110 10100001 01100000
10010010 01011100 10011011 10100101 10000110 00011011 10001001 00010110
01000010 01001100 01101010 10001101 10111001 01010111 01100110 01111000
00011001 00110001 10110110 01110001 11011100 01010000 00000110 10100101
00010101 01000111 01010110 11010101 10101101 10110100 01011011 00110100
10111010 10111010 00010010 10011000 10011010 01111000 10100000 00011110
01011010 01101110 00100001 10100100 01110000 10001011 10011111 01101101
11001100 00101010 10010100 01011110 00100111 10110011 10010010 11100101
01101101 10011010 00011011 10000100 10111000 11110011 01010110 00011001
01100010 00111011 00001011 11000000 11101101 11001010 10000111 00001010
11000100 10001100 10000010 10100111 00100011 00111000 00001100 00001001
11000111 00111000 00000000 11011011 10100010 10110011 10101100 11110101
10011000 00110101 00001111 00111100 11011001 11000101 00110100 11001011
00010011 11001011 00010001 01110000 00000000 00000110 01001000 10011100
10100011 10100111 00100111 10000011 10111000 00010001 11001110 00000001
11000110 01000110 01000111 00110101 01000011 01000100 11110001 01000010
11101011 00011010 00101110 10011011 01111101 11110110 00011001 11100010
10010111 01010000 10000000 01001111 00000101 10111110 11100100 00101100
11101001 10110100 00110001 00100011 11100110 11000110 00000110 11100101
00011001 00111000 11100100 10001111 01011010 00000000 11101000 00101000
10101010 11110110 10010111 01110001 01011111 11011001 00100101 11001101
10110011 11100101 00100100 00000111 00000100 10001110 01000001 00011100
00010000 01000111 10101000 00100000 10000010 00111101 10101011 10011101
10110011 10010110 00111011 00101111 00011101 00011101 00111011 11111011
01000110 11110111 00110011 01011001 00110100 10001101 00001101 11011011
01001000 11001011 01110001 00100000 01100101 11111001 11100001 00101101
11110010 10001101 10100000 00011101 11001010 10011000 00011111 00111010
10011100 01010000 00000111 01010101 01000101 01110001 11011110 00010000
11010101 01010110 11011010 11011011 11101100 00010111 01001111 01110010
11101111 00111110 10101111 10101000 11011011 11011011 11001101 00110100
10011011 11110111 01111001 01110011 11001010 01000010 01100100 10010010
11000100 10000100 01000011 10001100 11110110 01011111 10100101 01110110
00110100 00000001 11001110 11011000 11101000 00111010 10010101 10000110
10110011 10101101 11011111 11000111 10101010 01011010 10010001 10101010
01001011 00011100 10100010 00110011 01100110 11011111 10111010 01100100
10001001 01100011 11101011 11100110 01111100 11011001 00001000 00001111
01000001 11001110 01101010 00101000 00111100 00011110 10010110 01010110
00111110 00011111 10110011 10110100 10111100 11011011 00010110 10010001
01110110 11010111 01000100 11001001 00010110 11100110 10011101 11011001
00100101 01010110 00100100 10000010 00000010 10010010 01100110 01100110
11101001 11010110 10111010 01111010 00101000 00000011 10010110 10110100
11110000 10001100 11110110 11010011 01101001 11010010 00011101 01000110
00110111 00110110 01111010 10101101 11011110 10100100 01000000 10110110
00100011 01111111 10011110 00100110 11001010 01111101 11111110 00110001
11100111 00011110 01111001 11001110 00000111 00010100 01111111 11000010
00100011 00111111 11111100 00100011 00011111 11011000 11011111 11011010
01010001 11100111 11111011 01001011 11101101 11111110 01110111 11011001
10001111 11111100 11111101 11111101 10100111 01100110 11011101 11111110
10111111 00101110 01110011 11010011 10011100 01010111 01010011 01000101
00000000 01110010 11010111 01011110 00010001 10011110 11100110 01101101
01000110 01001111 11101101 00101000 11010100 11011110 01101010 10110110
10011010 10010000 00011111 01100110 00100111 01100111 10010000 00100001
11000010 01111101 11111110 01110011 11100100 10001110 01111000 11000110
01001111 00000110 10010111 01011010 11010010 00110101 10011000 10101111
10110101 01001101 01101011 01000110 10111101 10110111 01011101 01000010
01111011 00101000 00101101 01101101 11100001 10010110 11010100 10111010
00000110 10001110 01001001 00011100 01101110 00100001 10111010 00110111
10011010 01010100 10011100 00001101 10111101 01111001 11000110 00101011
10101000 10100010 10000000 00110010 10111100 01000001 10100100 01001011
10101101 11101001 01101001 01100110 10110111 00101001 01101110 01000101
11001101 10111101 11000001 01110011 00010001 01111100 11111001 01010010
10100100 10111000 11000110 11100001 11010100 10100110 00110011 11101111
01010001 11000101 10100010 11011100 01011010 11101011 10010111 00110111
11110110 10010111 10101001 00010100 00110111 10101100 10010010 01011110
01000010 11010000 11101110 01100111 10010001 01010001 01010000 00110010
00110110 11101111 10010000 00010101 01010101 00000100 00010000 11011101
00111000 11000001 11001001 00111011 00110100 01010000 00000110 01000101
10101110 10000011 00001101 10110110 10111101 00110110 10101111 10111001
01111110 11010011 00101100 01101111 00010011 10011000 11100011 11011000
01100100 01010010 11000001 10010111 11001100 11000001 11111001 11001010
01100011 00001010 01001000 11001000 00001100 11011110 10110101 01000111
01001000 11110000 10100011 01101001 00110110 01111010 01000100 01101011
01111010 10010010 11011100 01101001 00110000 00111101 10100101 10110100
11000110 00000010 00000001 10000001 10110110 11111100 10101110 10111011
11111001 01101111 11011101 11000111 11110011 00001100 01110010 10100111
00000000 00000011 10001010 11101001 01101000 10100000 00001010 01011010
01110110 10011011 00011110 10010111 10100110 00101101 10011101 10110011
00010001 10000010 11101110 01011100 10000001 10010010 11101110 11000101
10011001 10001000 11110101 00101100 11000100 11111110 00110101 01011100
01101001 00001111 01110001 01110111 10100111 11011101 11101010 00110011
11000111 01110001 01110011 01100010 00011001 10100010 01100100 10000111
11001011 00011011 11011001 01001010 00010111 11000110 01001111 11110000
10010010 00110001 10011110 11100111 11011011 00011010 10110100 01010000
00000111 00101101 01101001 11100001 00011001 11101101 10100110 11010011
01100100 00111010 10010100 01101110 01101100 11110101 01011011 10111101
01001000 10000001 01101100 01000110 11111111 00000000 00111111 11001101
11001010 01111101 11111110 00110001 11100111 00011110 01111001 11001110
00000111 00010101 11010001 01011011 01000111 01110001 00011000 10010111
11101101 00010111 00000010 01101101 11010010 00110011 00100110 00100011
11011001 10110001 00001111 01000101 11101011 11001110 00111101 01111011
11010100 11110100 01010000 00000111 11111111

[invite9b7cd1a6]

Met le fichier en jpg, car sinon tu ne pourra pas lire le fichier.

[polo974]

Voila le code dont je te parlais.
...

Bonjour padboy,
Est-t-il possible que tu joignes le source de la partie utile du programme (et quelques commentaires)?
Car finalement ici, c'est un forum d'entre-aide, et ton bout de code peut aider pour tout autre manip sur image.
Merci d'avance.

[invite9b7cd1a6]

Oui, pas de problèmes! Dès que je serai sur mon ordinateur, je donnerai la source!

[Bimini]

Bonjour à tous,

Merci Ô Padboy.

C'est exactement ce que je voulais et c'est OK pour un resto à 3 heures dès que tu viens sur Paris.

Étonnamment, j'ai pu lire ton message en jpg ET en bmp.

J'ai testé sur mon image (qui d'ailleurs ressemble pas mal à ton img.bmp que tu as laissé pour le test): une version bmp est parfaitement transcrite en binaire et retranscrite en image bmp par la suite. C'est génial.
En revanche, j'ai testé une version jpg enregistrée avec le taux de compression le plus faible possible. Le code binaire met plus de temps à apparaître, mais ça n'a aucune importance. En revanche quand j'ai voulu recréer l'image avec l'extension jpg, aucun de mes logiciels d'image n'a pu la lire.
J'ai d'ailleurs testé ton img.bmp que j'ai passé en RVB puis enregistré en jpg avec le plus faible taux de compression. Pareil, ça n'a pas ouvert le fichier après que celui-ci a été transcrit en binaire puis retranscrit en jpg.

Effectivement, la suite binaire est très longue et même si je ne compte pas la dissimuler dans mon texte, je pense que je vais quand même réduire la taille de mon image à son stricte minimum.

Encore un très grand merci pour ton aide,

A bientôt,

Michaël.

[invite9b7cd1a6]

L'application, je l'ai codé en vb6, faute de ne pas avoir vb.net sur mon ordinateur... Je l'ai fais en ce langage car je devais faire rapidement l'application et que la création d'interface est tres facile... (je ne connais malheureusement pas le c#).

Pour les interessés, voici le code principal:

Dim texte As String
Dim i As Double
Dim j As Integer
Dim ligne As Integer
Dim longueur As Long
Dim buffer() As Byte
Dim pass As Boolean
pass = False

i = 1
j = 1
ligne = 1

texte = ""
temp = ""
path = Me.File1.path & "\" & Me.File1.FileName


If Me.File1.Pattern <> "*.binaire" Then

    ReDim buffer(1 To FileLen(path)) 'contiendra un tableau de bytes

    Open path For Binary As #1 'on ouvre en mode binaire
        Get #1, 1, buffer
    Close #1


    While (i < FileLen(path)) 'on récupère le texte ascii et on le met en binaire
        If i = 1 Then
            texte = dec2bin(buffer(i))
            j = j + 1
    
        ElseIf j <= 8 And i > 1 Then
            texte = texte & " " & dec2bin(buffer(i))
            j = j + 1
        Else
            texte = texte & vbCrLf & dec2bin(buffer(i))
            j = 2
        End If
    
        i = i + 1
    Wend
Else
    filetype = "*.binaire"
    Open path For Input As #1
        While Not EOF(1)
            Line Input #1, temp
            If pass = False Then
                texte = temp
                pass = True
            Else
                texte = texte & vbCrLf & temp
            End If
        Wend
    Close #1
End If

Le bug, le fait que tu ne puisse pas voir les jpeg vient probablement du fait que je rajoute volontairement 2 bytes à la fin de l'écriture, pour des raisons de différence de poids entre l'image originale et l'image générée.

Je vais y retravailler, mais pour ceux que ca intéresse, l'écriture:

content = Split(Replace(Form1.zt_binaire.Text, vbCrLf, " "), " ")
    i = 0
    ReDim buffer(UBound(content))
    
    While (i < UBound(content))
        buffer(i) = Bin2Dec(content(i))
        i = i + 1
    Wend
    
    i = 0
    
    Open path For Binary As #1
        While (i < UBound(buffer))
            Put #1, , buffer(i)
            i = i + 1
        Wend
        Put #1, , 0
        Put #1, , 0
    Close #1

Bon, je vais regarder cela éventuellement, je vous en redonne des nouvelles...

Il se peut que mon code soit croche un peu.. Je me suis dépêché et à usage personnelle, je n'ai pas commenté vraiment et le nom des objets d'interfaces sont ceux par défauts, ce qui est nettement déconseillé en programmation...