image

Version imprimable

19/01/2010, 19h20
TopCao

image --> matrice --> image

Salut

Tout est dans le titre mais je vais essayer d'être moins binaire.

Je voudrais savoir comment on importe une image en 4D (x,y,z,t) en C++, comment on la convertit en matrice type

Code:

double imageMatrix [x][y][z][t];

pour effectuer des opérations puis reconvertir cette matrice en image....

J'imagine que ce n'est pas très compliqué d'autant plus que je dispose d'images sans header (RAW data médicales en un seul fichier) dont je connais la taille de chaque dimensions de la matrice. En l'occurrence : x =128 ; y = 128 ; z = 8 ; t = 48

:P
20/01/2010, 17h55
3DArchi

Salut,
La question demeure un peu floue. Tout dépend de ce que tu veux en faire. Toutes les dimensions sont fixes ? Et bien, utilises un std::vector(x*y*z*t) (ou tr1/boost/std(c++0x)::array si les valeurs sont connues à la compilation). Pourquoi passer par une telle matrice ?
21/01/2010, 12h20
TopCao

Alors si c'est flou, je vais être plus précis.

- Je dispose d'une image médicale 4D (x,y,z,t)
- C'est un format de données brutes commençant comme suit :

http://f.imagehost.org/0106/Capture_...1_12_17_44.png

Donc, je ne sais pas faire, et c'est pourquoi je poste sur ce forum :
- aller chercher le fichier image -je sais par contre le mettre en paramètre de mon prog si besoin-
- lire les n premiers caractères (pour passer au delà du header)
- puis récupérer les caractères n+1 à m pour les ranger dans un tableau

-Je sais manipuler les données de mon tableau, les transformer etc...

- puis, je voudrais écrire le résultat de ces manipulations dans un nouveau fichier (qui aurait le même header de surcroit...)

Donc pour résumer : lire les données d'une image, les modifier et écrire les modifications dans un nouveau fichier, comme par exemple inverser le codage n&b

voilà !
22/01/2010, 14h43
TopCao

euh personne pour donner un petit coup de main à un débutant ?

Le format de ce fichier n'est pas trés clair, mais disont que souhaite lire tout les caractère qui réponde à certain critères, comme les chiffre les "." et visiblement les "U" et "I".
Tu pourrais commencer avec quelque chose comme ça :

Code:

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
 
#include<iostream>
#include<sstream>
#include<string>
using namespace std;
 
static inline size_t is_allowed_special(size_t i)
{
    return (i == 'U')|(i == 'I')|(i == '.');
}
static inline size_t is_num(size_t i)
{
    return (i >= '0')&(i <= '9');
}
static inline size_t is_value(size_t i)
{
    return is_num(i)|is_allowed_special(i);
}
 
void read_image(const char* file_name)
{
    ifstream fs(file_name);
    if( false == fs.is_open() )
        return;
 
    // lit le contenu du fichier
    fs.seekg(0, ios::end);
    streamsize length = fs.tellg();
    fs.seekg(0, ios::beg);
 
    char* buffer = new char[length];
    fs.read(buffer,length);
    fs.close();
    // 
    string content(buffer, length);
    delete buffer;
    // parcours le fichier image par buffer de 500
    stringstream content;
    content << buffer;
    while( content.getline(str, 500, '\n') )
    {
        int size = strlen(str);
        int pos = 0;
        // on parcours les valeurs
        while( pos < size && false == is_value(str[pos]) )
        {
            // **** ici tu peux faire tes traitements 
            // et garder des variables d'états pour savoir ou tu en est...
            // récuperer les index de début/fin de chaque nombre avec is_num() ect.
            ++pos;
        }
    }
}

Ca pourrais te servir de point de départ si tu coinces.

23/01/2010, 09h37
3DArchi

Salut,
Déjà, ton format de fichier n'est pas 'brut' mais semble être un fichier texte.
Pour les entrées/sorties dans les fichiers, tu peux t'intéresser aux flux.
Ensuite, il faut expliciter le format de ton fichier : que signifie la première ligne ? la seconde ? etc...
Puis déterminer la structure dont tu as besoin pour représenter ton image en mémoire selon les traitements que tu va faire.
La lecture du fichier te permets ensuite de construire cette représentation mémoire.
Les traitements la modifient et produisent un résultat.
Ensuite, plus qu'à sauvegarder, toujours avec les flux, en suivant le format de ton fichier.