Discussion :

[betaplus]

Bonjour à tous,

Je ne suis pas certain d'être dans la bonne section, n'hésitez pas à me le faire savoir si je suis au mauvais endroit...

Pour faire simple j'ai une fonction à deux paramètres et je stocke le résultat dans une une image au format raw, ce qui un peut agaçant à lire avec imageJ à la longue.
Connaissez-vous un format d'image, où chaque point de l'image a la valeur que je souhaite lui attribuer, tout en aussi facile à lire avec une application graphique qu'une image jpeg ou png ?

Merci d'avance,

betaplus

[jblecanard]

Hello

Oui, le format BMP, il est très simple à implémenter et est lisible depuis n'importe quel logiciel décent.

[Bousk]

jpeg et png facile à lire ?
Ces formats sont compressés par du zlib, je comprends pas ta définition de facile à lire.
Le BMP est vraiment simple, c'est quasiment du raw. Le TGA n'est pas non plus très compliqué.

[_zzyx_]

Je crois qu'il parlait de la simplicité à voir l'image dans un logiciel tier (i.e. imageJ)
Une bonne option c'est de confier la sauvegarde/lecture d'image à une lib externe à qui tu passes le buffer en mémoire (je simplifie un peu) et qui s'occupe d'en faire une vraie image
par exemple http://freeimage.sourceforge.net/
Si tu aimes le bas-niveau, tu peux assez facilement écrire un header minimaliste pour mettre ton raw dans un .tif (attention le format tif a tellement d'options que c'est le bordel, mais il permet aussi de faire des choses simples)

[betaplus]

Très bien, très bien...

Merci pour vos réponses. Bien sûr, je parlais de la facilité à ouvrir l'image avec un logiciel tiers (par exemple si je transfert l'image à une autre personne ou si je dois l'ouvrir depuis un poste ne disposant pas de soft de lecture un peu plus avancé qu'aperçu sous mac ou du lecteur windows par défaut...)

Merci encore, je vais essayer d'enregistrer tout ça en BMP aussi tôt que j'aurai installé ITK (que je connais mieux que freeimage)

[jblecanard]

L'intérêt du BMP est que c'est un format si simple qu'il n'y a pas besoin de bibliothèque tierce pour l'écrire, sinon autant balancer du png ou du jpeg

Voici un exemple:

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
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
#include <sstream>
#include <string>
#include <vector>
#include <fstream>
#include <cstdint>
#include <array>
 
using UChar = uint8_t;
using Color = std::array<UChar, 3>;
using Image = std::vector<Color>;
 
Color constexpr bottom_left = Color {{0,0,0}};
Color constexpr top_left = Color {{255,0,0}};
Color constexpr top_right = Color {{0,255,0}};
Color constexpr bottom_right = Color {{0,0,255}};
size_t constexpr sqr_max_dist = 255*255;
 
size_t computeColorWeight(size_t distance_to_target) {
  distance_to_target = (sqr_max_dist < distance_to_target) ? sqr_max_dist : distance_to_target;
  return sqr_max_dist - distance_to_target;
}
 
template <typename F, typename T> void binaryWrite(F& stream, T const & data) {
  stream.write(reinterpret_cast<char const *>(&data), sizeof(T));
}
 
int main(int argc, char* argv[]) {
  size_t width = 800u;
  size_t height = 600u;
  std::string filename = "file.bmp";
 
  if (1 < argc)
    filename = argv[1];
 
  if (3 < argc) {
    std::istringstream(std::string(argv[2])) >> width;
    std::istringstream(std::string(argv[3])) >> height;
  }
 
  // Generating an image in BGR (instead of RGB)
  size_t size = width*height;
  Image img(size, {{0, 0, 0}});
  for (size_t line=0; line < height; ++line) {
    for (size_t column=0; column < width; ++column) {
      UChar color_line = static_cast<UChar>(255u*line/(height-1));
      UChar color_column = static_cast<UChar>(255u*column/(width-1));
      size_t local_bottom_left  = computeColorWeight(color_line*color_line + color_column*color_column);
      size_t local_top_left = computeColorWeight((255u - color_line)*(255u-color_line) + color_column*color_column);
      size_t local_top_right = computeColorWeight((255u - color_line)*(255u-color_line) + (255u-color_column)*(255u-color_column));
      size_t local_bottom_right = computeColorWeight(color_line*color_line + (255u-color_column)*(255u-color_column));
      Color & target = img[line*width + column];
      for(size_t index=0; index < 3u; ++index)
        target[index] = static_cast<uint8_t>((local_bottom_left*bottom_left[index] + local_top_left*top_left[index] + local_top_right*top_right[index] + local_bottom_right*bottom_right[index])/(sqr_max_dist));
    }
  }
  // Writing a BMP file
  uint32_t offset =
    2u          // File type
    + 4u        // File size
    + 4u        // Reserved field
    + 4u        // Image offset
    + 40u       // Image header
    ;
 
  size_t nb_padding_octets = width%4;
  size_t image_data_size = 3u*size + height*nb_padding_octets;
  uint32_t file_size = offset + image_data_size;
  std::ofstream file(filename.c_str(), std::ios::binary | std::ios::out);
  if (file) {
    // Write the header
    binaryWrite(file, uint16_t(0x4d42)); // File type
    binaryWrite(file, file_size);
    binaryWrite(file, uint32_t(0));
    binaryWrite(file, offset);
 
    // Image header
    binaryWrite(file, uint32_t(0x0028));  // Img header size
    binaryWrite(file, uint32_t(width));
    binaryWrite(file, uint32_t(height));
    binaryWrite(file, uint16_t(1));  // Nb layers
    binaryWrite(file, uint16_t(24u));  // Color depht
    binaryWrite(file, uint32_t(0)); // Compression method
    binaryWrite(file, uint32_t(image_data_size)); // Image size
    binaryWrite(file, uint32_t(0));  // Resolution
    binaryWrite(file, uint32_t(0));  // Resolution
    binaryWrite(file, uint32_t(0u));  // Palette
    binaryWrite(file, uint32_t(0u));  // Important colors of palette
 
    // Write the image
    for (size_t line=0; line < height; ++line) {
      for (size_t column=0; column < width; ++column) {
        Color & color =  img[line*width + column];
        binaryWrite(file, uint8_t(color[0]));
        binaryWrite(file, uint8_t(color[1]));
        binaryWrite(file, uint8_t(color[2]));
      }
 
      // Add padding
      for (size_t index=0; index < nb_padding_octets; ++index)
        binaryWrite(file,uint8_t(0u));
    }
  }
  return 0;
}

Qui génère cette image:



Comme tu peux le voir, la quantité de code pour écrire le fichier est faible, il en a fallu plus pour générer l'image !

[betaplus]

Merci Jblecanard ! Voilà qui fait mon affaire.

Merci également à tous pour vos contributions