Imrect et les GUIs

**Alex3434** · 20/05/2015, 10h27

Bonjour à tous !

Je viens vers vous car je dois avouer avoir pas mal de mal à comprendre l'identification des figures et l'update des données en temps réel.

Je vais vous expliquer d'abord ce que j'attend de mon application :

Mon application a pour but de permettre à l'utilisateur d'afficher l'histogramme d'une image en niveaux de gris, puis après sélection d'un nombre d'intervalles via une valeur, tracer le même nombre de rectangles via la fonction imrect sur cet histogramme. Ces rectangles servent à récupérer les valeurs d'intensité de début et fin de chaque intervalle pour appliquer un traitement derrière (indépendant de la fonction imrect et de l'histogramme, les données seront stockées dans une matrice pour un affichage dans une nouvelle fenêtre).

En gros, voici l'idée que je me fais du GUI que j'aimerai obtenir :

1) L'utilisateur charge l'image dans la mémoire (Fait)
2) L'utilisateur indique le nombre d'intervalles (Fait)
3) L'utilisateur trace l'histogramme de cette image (Fait)
4) Les rectangles se tracent sur l'histogramme (Fait)
5) Une fois que l'utilisateur a modifié la largeur des rectangles, il appuie sur un bouton pour valider les nouvelles positions (note : un bout d'algo replace correctement les rectangles pour ne pas avoir d'espace entre chaque rectangle et éviter les recouvrements de deux rectangles)
6) l'utilisateur visualise le traitement appliqué basé sur les données obtenues en 5). (Fait)
7) possibilité d'enregistrement de l'image traitée (Sera fait plus tard)

Note: j'ai identifié l'étape qui pose problème, il s'agit de l'étape 5).

La petite subtilité vient du fait que l'utilisateur doit avoir la possibilité de changer la taille de ces intervalles (et donc des rectangles), puis on récupère les nouvelles positions pour modifier le traitement. Je sais qu'il serait plus intelligent de faire du temps réel (supprimer la validation dans l'étape 5), mais comme on dit, avant de savoir courir, il faut apprendre à marcher !

J'ai d'abord réalisé un fichier .m pour vérifier que mon algorithme fonctionne correctement, et il fait bien ce que je lui demande mais une seule fois ! Le problème est donc l'étape 5) (c'est pour ça que j'étais partie sur le GUI). Débutant sur les handles de figures, je ne sais pas trop comment cela fonctionne.

Désolé pour le pavé mais je voulais être le plus clair possible. Merci en tout cas d'avoir eu le courage de lire jusqu'ici et j'espère sincèrement que quelqu'un trouvera le temps pour m'expliquer tout ceci. Un chocobon est à gagner !

Voici le code du GUI que j'ai réalisé :

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
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
function varargout = Niveaux_couleurs(varargin)
% NIVEAUX_COULEURS MATLAB code for Niveaux_couleurs.fig
%      NIVEAUX_COULEURS, by itself, creates a new NIVEAUX_COULEURS or raises the existing
%      singleton*.
%
%      H = NIVEAUX_COULEURS returns the handle to a new NIVEAUX_COULEURS or the handle to
%      the existing singleton*.
%
%      NIVEAUX_COULEURS('CALLBACK',hObject,eventData,handles,...) calls the local
%      function named CALLBACK in NIVEAUX_COULEURS.M with the given input arguments.
%
%      NIVEAUX_COULEURS('Property','Value',...) creates a new NIVEAUX_COULEURS or raises the
%      existing singleton*.  Starting from the left, property value pairs are
%      applied to the GUI before Niveaux_couleurs_OpeningFcn gets called.  An
%      unrecognized property name or invalid value makes property application
%      stop.  All inputs are passed to Niveaux_couleurs_OpeningFcn via varargin.
%
%      *See GUI Options on GUIDE's Tools menu.  Choose "GUI allows only one
%      instance to run (singleton)".
%
% See also: GUIDE, GUIDATA, GUIHANDLES
 
% Edit the above text to modify the response to help Niveaux_couleurs
 
% Last Modified by GUIDE v2.5 19-May-2015 17:14:45
 
% Begin initialization code - DO NOT EDIT
gui_Singleton = 1;
gui_State = struct('gui_Name',       mfilename, ...
                   'gui_Singleton',  gui_Singleton, ...
                   'gui_OpeningFcn', @Niveaux_couleurs_OpeningFcn, ...
                   'gui_OutputFcn',  @Niveaux_couleurs_OutputFcn, ...
                   'gui_LayoutFcn',  [] , ...
                   'gui_Callback',   []);
if nargin && ischar(varargin{1})
    gui_State.gui_Callback = str2func(varargin{1});
end
 
if nargout
    [varargout{1:nargout}] = gui_mainfcn(gui_State, varargin{:});
else
    gui_mainfcn(gui_State, varargin{:});
end
% End initialization code - DO NOT EDIT
 
 
% --- Executes just before Niveaux_couleurs is made visible.
function Niveaux_couleurs_OpeningFcn(hObject, eventdata, handles, varargin)
% This function has no output args, see OutputFcn.
% hObject    handle to figure
% eventdata  reserved - to be defined in a future version of MATLAB
% handles    structure with handles and user data (see GUIDATA)
% varargin   command line arguments to Niveaux_couleurs (see VARARGIN)
 
% Choose default command line output for Niveaux_couleurs
handles.output = hObject;
 
% Update handles structure
guidata(hObject, handles);
 
% UIWAIT makes Niveaux_couleurs wait for user response (see UIRESUME)
% uiwait(handles.figure1);
 
 
% --- Outputs from this function are returned to the command line.
function varargout = Niveaux_couleurs_OutputFcn(hObject, eventdata, handles) 
% varargout  cell array for returning output args (see VARARGOUT);
% hObject    handle to figure
% eventdata  reserved - to be defined in a future version of MATLAB
% handles    structure with handles and user data (see GUIDATA)
 
% Get default command line output from handles structure
varargout{1} = handles.output;
 
 
% --- Executes on button press in Selection_images.
function Selection_images_Callback(hObject, eventdata, handles)
% hObject    handle to Selection_images (see GCBO)
% eventdata  reserved - to be defined in a future version of MATLAB
% handles    structure with handles and user data (see GUIDATA)
[FileName,PathName] = uigetfile('.\*.txt');
Image = load_txt_single(FileName,PathName);
 
handles.Image = Image;
guidata(hObject,handles);
 
 
function Nbre_niveau_Callback(hObject, eventdata, handles)
% hObject    handle to Nbre_niveau (see GCBO)
% eventdata  reserved - to be defined in a future version of MATLAB
% handles    structure with handles and user data (see GUIDATA)
 
% Hints: get(hObject,'String') returns contents of Nbre_niveau as text
%        str2double(get(hObject,'String')) returns contents of Nbre_niveau as a double
handles.nbre_niveau = str2double(get(hObject,'String'));                            % Recupération du nombre de niveaux entré par l'utilisateur
guidata(hObject,handles);
 
% --- Executes during object creation, after setting all properties.
function Nbre_niveau_CreateFcn(hObject, eventdata, handles)
% hObject    handle to Nbre_niveau (see GCBO)
% eventdata  reserved - to be defined in a future version of MATLAB
% handles    empty - handles not created until after all CreateFcns called
 
% Hint: edit controls usually have a white background on Windows.
%       See ISPC and COMPUTER.
if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor'))
    set(hObject,'BackgroundColor','white');
end
 
 
% --- Executes on button press in Start.
function Start_Callback(hObject, eventdata, handles)
% hObject    handle to Start (see GCBO)
% eventdata  reserved - to be defined in a future version of MATLAB
% handles    structure with handles and user data (see GUIDATA)
Image = handles.Image;
nbre_niveau = handles.nbre_niveau;
 
%% Conversion pour imhist
Image2 = uint8(Image);
[COUNTS2,X2]=imhist(Image2); % COUNTS sert lors de l'initialisation des rectangles
 
figure
imhist(Image2)
 
LUT = [0 0 153;   % Look Up Table pour les couleurs 
       0 0 255;
       0 128 255;
       0 255 255;
       0 255 128;
       0 255 0;
       128 255 0;
       255 255 0;
       255 128 0;
       255 0 0 ];
 
LUT = LUT./255; % Normalisation [0 - 1]
 
%% Initialisation des rectangles (Répartis équitablement)
for nn = 1:nbre_niveau
 
    if nn == nbre_niveau
        largeur_rect(nn) = 255 - x(nn-1) + largeur_rect(nn-1);
        hauteur_rect(nn) = max(COUNTS2(:))/2;
        x(nn) = x(nn-1) + largeur_rect(nn-1);
        y(nn) = 0;
    else
        largeur_rect(nn) = round(255/nbre_niveau);
        hauteur_rect(nn) = max(COUNTS2(:))/2;
        x(nn) = (nn-1)*largeur_rect(nn);
        y(nn) = 0;
    end
 
    h(nn) = imrect(gca, [x(nn) y(nn) largeur_rect(nn) hauteur_rect(nn)]);  % h(nn) représente le rectangle n
 
    setColor(h(nn),LUT(nn,:))
end
 
handles.h = h;
handles.COUNTS2 = COUNTS2;
guidata(hObject,handles);
 
 
% --- Executes on button press in Validation.
function Validation_Callback(hObject, eventdata, handles)
% hObject    handle to Validation (see GCBO)
% eventdata  reserved - to be defined in a future version of MATLAB
% handles    structure with handles and user data (see GUIDATA)
 
nbre_niveau = handles.nbre_niveau;
COUNTS2 = handles.COUNTS2;
h = handles.h;
Image = handles.Image;
 
[H,L] = size(Image);
 
%% Recalage des intervalles
for nn = 1:nbre_niveau
 
    pos = getPosition(h(nn));
    x(nn) = pos(1);
    largeur_rect(nn) = pos(3);
 
    if nn == 1    % Si premier rectangle
        if x(nn) < 0  % Si bord gauche rectangle hors fenêtre
            x(nn) = 0;
        end
    end    
 
    if nn == nbre_niveau % Si dernier rectangle
        if x(nn) + largeur_rect(nn) < 255 % Si bord droit hors fenêtre (on affiche un histogramme avec comme axe x = [0 - 255])
            largeur_rect(nn) = 255 - x(nn); % On modifie la largeur du rectangle pour qu'elle fit la fenêtre
        end
    end
 
    if nn ~= 1 % Cas des autres rectangles
        if x(nn) ~= x(nn-1) + largeur_rect(nn-1) % Verification que les rectangles ne se recoupent pas
            x(nn) = x(nn-1) + largeur_rect(nn-1);
        end
 
        if x(nn) + largeur_rect(nn) > 255
            largeur_rect(nn) = 255 - x(nn);
        end
    end
    delete(h(nn))  % On efface les rectangles
    h(nn) = imrect(gca, [x(nn) 0 largeur_rect(nn) max(COUNTS2(:))/2]); % Pour les retracer avec les nouvelles données de positions et taille
    setColor(h(nn),LUT(nn,:)) % On recolore les rectangles
 
    pos = getPosition(h(nn));   % pos = [ x y largeur hauteur ]
    debut_intervalle(nn) = pos(1);                                      % récupération des valeurs des intervalles
    fin_intervalle(nn) = debut_intervalle(nn) + pos(3);                 %
    taille_intervalle(nn) = fin_intervalle(nn) - debut_intervalle(nn);
end
 
passage = 1;
Image2 = zeros(H,L);
Fait = zeros(H,L);
 
for kk = 1:nbre_niveau % Algorithme de traitement des données à partir des valeurs d'intervalles
 
    for ii = 1:H
        for jj = 1:L
 
            if (Image(ii,jj) <= fin_intervalle(kk) && Image(ii,jj) >= debut_intervalle(kk) && Fait(ii,jj) == 0 )
 
                Image2(ii,jj) = debut_intervalle(kk) + taille_intervalle(kk)/2;
                Fait(ii,jj) = 1;
 
            end
        end
    end
    passage = passage +1;
end
 
figure;         % Affichage du traitement
imagesc(Image2);
title(strcat('Image avec ',num2str(nbre_niveau),' niveaux'))
colorbar 
 
% --- Executes on button press in Enregistrement.
function Enregistrement_Callback(hObject, eventdata, handles)
% hObject    handle to Enregistrement (see GCBO)
% eventdata  reserved - to be defined in a future version of MATLAB
% handles    structure with handles and user data (see GUIDATA)

**Alex3434** · 20/05/2015, 13h56

Bon après analyse du code présent dans le lien que j'ai mis et une petite bidouille pas très propre, j'ai réussi à faire en sorte que cela fonctionne pour deux rectangles. Le problème maintenant est qu'une fois la modif faite à partir du premier rectangle n'est pas conservée dès lors qu'on bouge le deuxième rectangle... Si quelqu'un a une idée je suis preneur !

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
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
function Contrast
    clc
    close all
    figure();
 
    nbre_niveau = 2;
    highResImage = rgb2gray(imread('peppers.png'));
    lowResImage = imresize(highResImage,0.5);
 
    a1 = subplot(2,1,1);
    imhist(lowResImage);
    a2 = subplot(2,1,2);
 
    [COUNTS2,X2]=imhist(highResImage);
 
    LUT = [0 0 153;   % Look Up Table pour les couleurs 
       0 0 255;
       0 128 255;
       0 255 255;
       0 255 128;
       0 255 0;
       128 255 0;
       255 255 0;
       255 128 0;
       255 0 0 ];
 
    LUT = LUT./255;
 
    %% Initialisation des rectangles (Répartis équitablement)
for nn = 1:nbre_niveau
 
    if nn == nbre_niveau
        largeur_rect(nn) = 256 - (x(nn-1) + largeur_rect(nn-1));
        hauteur_rect(nn) = 100;
        x(nn) = x(nn-1) + largeur_rect(nn-1);
        y(nn) = 0;
    else
        largeur_rect(nn) = round(255/nbre_niveau);
        hauteur_rect(nn) = 100;
        x(nn) = (nn-1)*largeur_rect(nn);
        y(nn) = 0;
    end
 
    initialPosition(nn,1:4) = [x(nn) y(nn) largeur_rect(nn) hauteur_rect(nn)];
    lowResRect(nn) = imrect(a1,initialPosition(nn,:));    
    setColor(lowResRect(nn),LUT(nn,:))
 
    lowResRect(nn).addNewPositionCallback( @(pos)Callback(pos,a2,highResImage));
 
end   
 
 
    Callback( initialPosition , a2, highResImage);
end
 
function Callback(pos,axesHandle, highResImage)
    nbre_niveau = 2;
 
    pos
    [ligne,col]=size(pos);
    position = pos;
 
    if ligne == nbre_niveau
 
        for nn = 1:nbre_niveau
            debut_intervalle(nn) = position(nn,1);                                  % récupération des valeurs des intervalles
            fin_intervalle(nn) = debut_intervalle(nn) + position(nn,3);                 %
            taille_intervalle(nn) = fin_intervalle(nn) - debut_intervalle(nn);
        end
 
        highResThumbnail = highResImage;
        [H,L] = size(highResThumbnail);
 
 
        Image2 = zeros(H,L);
        Fait = zeros(H,L);
 
        for kk = 1:nbre_niveau % Algorithme de traitement des données à partir des valeurs d'intervalles
 
            for ii = 1:H
                for jj = 1:L
 
                    if (highResImage(ii,jj) <= fin_intervalle(kk) && highResImage(ii,jj) >= debut_intervalle(kk) && Fait(ii,jj) == 0 )
 
                        Image2(ii,jj) = debut_intervalle(kk) + taille_intervalle(kk)/2;
                        Fait(ii,jj) = 1;
 
                    end
                end
            end
        end
 
        highResThumbnail = Image2;
 
    else
        debut_intervalle = position(1);                                  % récupération des valeurs des intervalles
        fin_intervalle = debut_intervalle + position(3);                 %
        taille_intervalle = fin_intervalle - debut_intervalle;
 
        highResThumbnail = highResImage;
        [H,L] = size(highResThumbnail);
 
        Fait = zeros(H,L);
 
    % Algorithme de traitement des données à partir des valeurs d'intervalles
 
        for ii = 1:H
            for jj = 1:L
 
                if (highResImage(ii,jj) <= fin_intervalle && highResImage(ii,jj) >= debut_intervalle  )
 
                    Image2(ii,jj) = debut_intervalle + taille_intervalle/2;
 
                end
            end
        end
        highResThumbnail = Image2;
    end
 
 
    if isempty( get(axesHandle,'Children')) 
        imagesc(Image2,'Parent',axesHandle);
 
    else
        imHandle = get(axesHandle,'Children');
        oldSize = size(get(imHandle,'CData'));
        if ~isequal(oldSize, size(highResThumbnail))
            imagesc(Image2,'Parent',axesHandle);
 
        else
            set( imHandle,'CData', Image2);
        end     
    end
 
end

**Alex3434** · 20/05/2015, 16h48

Rebonjour à tous, j'ai abandonné l'idée de l'IHM pour le moment. Cependant, mon problème persiste; je résumé:

j'ai réalisé un code permettant d'afficher 2 rectangles sur un histogramme d'une image en niveau de gris. Je récupère au travers d'un callback la valeur de la position du coté gauche et droit du dernier rectangle déplacé afin de m'en servir pour appliquer un traitement.

Le problème est qu'après avoir déplacé un des rectangle, il efface totalement l'image affichée qui avait été modifiée par le précédent rectangle.. si quelqu'un voit ou est la coquille je lui en serai reconnaissant !

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
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
function Contrast
    clc
    close all
    figure();
 
    nbre_niveau = 2;
    highResImage = rgb2gray(imread('peppers.png'));
    lowResImage = imresize(highResImage,0.5);
 
    a1 = subplot(2,1,1);
    imhist(lowResImage);
    a2 = subplot(2,1,2);
 
    [COUNTS2,X2]=imhist(highResImage);
 
    LUT = [0 0 153;   % Look Up Table pour les couleurs 
       0 0 255;
       0 128 255;
       0 255 255;
       0 255 128;
       0 255 0;
       128 255 0;
       255 255 0;
       255 128 0;
       255 0 0 ];
 
    LUT = LUT./255;
 
    %% Initialisation des rectangles (Répartis équitablement)
for nn = 1:nbre_niveau
 
    if nn == nbre_niveau
        largeur_rect(nn) = 256 - (x(nn-1) + largeur_rect(nn-1));
        hauteur_rect(nn) = 100;
        x(nn) = x(nn-1) + largeur_rect(nn-1);
        y(nn) = 0;
    else
        largeur_rect(nn) = round(255/nbre_niveau);
        hauteur_rect(nn) = 100;
        x(nn) = (nn-1)*largeur_rect(nn);
        y(nn) = 0;
    end
 
    initialPosition(nn,1:4) = [x(nn) y(nn) largeur_rect(nn) hauteur_rect(nn)];
    lowResRect(nn) = imrect(a1,initialPosition(nn,:));    
    setColor(lowResRect(nn),LUT(nn,:))
 
    lowResRect(nn).addNewPositionCallback( @(pos)Callback(pos,a2,highResImage));
 
end   
 
 
    Callback( initialPosition , a2, highResImage);
end
 
function Callback(pos,axesHandle, highResImage)
    nbre_niveau = 2;
 
    pos
    [ligne,col]=size(pos);
    position = pos;
 
    if ligne == nbre_niveau
 
        for nn = 1:nbre_niveau
            debut_intervalle(nn) = position(nn,1);                                  % récupération des valeurs des intervalles
            fin_intervalle(nn) = debut_intervalle(nn) + position(nn,3);                 %
            taille_intervalle(nn) = fin_intervalle(nn) - debut_intervalle(nn);
        end
 
        highResThumbnail = highResImage;
        [H,L] = size(highResThumbnail);
 
 
        Image2 = zeros(H,L);
        Fait = zeros(H,L);
 
        for kk = 1:nbre_niveau % Algorithme de traitement des données à partir des valeurs d'intervalles
 
            for ii = 1:H
                for jj = 1:L
 
                    if (highResImage(ii,jj) <= fin_intervalle(kk) && highResImage(ii,jj) >= debut_intervalle(kk) && Fait(ii,jj) == 0 )
 
                        Image2(ii,jj) = debut_intervalle(kk) + taille_intervalle(kk)/2;
                        Fait(ii,jj) = 1;
 
                    end
                end
            end
        end
 
        highResThumbnail = Image2;
 
    else
        debut_intervalle = position(1);                                  % récupération des valeurs des intervalles
        fin_intervalle = debut_intervalle + position(3);                 %
        taille_intervalle = fin_intervalle - debut_intervalle;
 
        highResThumbnail = highResImage;
        [H,L] = size(highResThumbnail);
 
        Fait = zeros(H,L);
 
    % Algorithme de traitement des données à partir des valeurs d'intervalles
 
        for ii = 1:H
            for jj = 1:L
 
                if (highResImage(ii,jj) <= fin_intervalle && highResImage(ii,jj) >= debut_intervalle  )
 
                    Image2(ii,jj) = debut_intervalle + taille_intervalle/2;
 
                end
            end
        end
        highResThumbnail = Image2;
    end
 
 
    if isempty( get(axesHandle,'Children')) 
        imagesc(Image2,'Parent',axesHandle);
 
    else
        imHandle = get(axesHandle,'Children');
        oldSize = size(get(imHandle,'CData'));
        if ~isequal(oldSize, size(highResThumbnail))
            imagesc(Image2,'Parent',axesHandle);
 
        else
            set( imHandle,'CData', Image2);
        end     
    end
 
end

**Gooby** · 20/05/2015, 17h10

Bonjour,

Essaye d'ajouter un hold all au début de ta fonction.

**Alex3434** · 20/05/2015, 17h32

Le hold all ne semble pas être la solution, on a toujours ce phénomène de perte de la modification.

Si j'ai bien compris, le callback est censé s'exécuter en boucle, il faudrait donc trouver un moyen de conserver la modification à Image2 pour la récupérer au début du passage suivant dans le callback.

**Gooby** · 20/05/2015, 17h44

Pour commencer, le Callback n'est pas exécuté dans ta boucle. Il est en dehors.

Et si tu faire passer tes variables d'une fonction à l'autre tu peux très bien lui définir un output:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
%...
    myDatas = Callback( initialPosition , a2, highResImage);
end
 
function myDatas = Callback(pos,axesHandle, highResImage)
%...

Et dans ta fonction Callback, tu peux mettre ce que tu veux dans myDatas, y compris une structure si tu as beaucoup de sorties.

Cela dit, je n'ai pas pris le temps de lire tout le code car il est assez long et peu commenté..

**Alex3434** · 20/05/2015, 18h05

Je vais résumer le code pour que ca soit plus clair. On s'intéresse seulement au callback car c'est la dedans que le traitement et la visualisation sont générés, la fonction Contrast ne servant qu'a l'initialisation le programme n'y retourne plus (vérifié avec un petit affichage au sein de la fonction Contrast).

Tout d'abord on sait qu'on a 2 rectangles, on récupère dans pos les positions des rectangles. Au premier passage pos est une matrice 2*4 ou chaque ligne contient les positions x,y du coin bas gauche de chaque rectangle ainsi que leur hauteur et largeur.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
function Callback(pos,axesHandle, highResImage)
    nbre_niveau = 2;  % On a tracé 2 rectangles dans la fonction Contrast
 
    pos
    [ligne,col]=size(pos);
    position = pos;

Cependant dès qu'on bouge un des rectangles, pos devient un vecteur 1*4 renvoyant les données du dernier rectangle bougé, en soit ca ne pose pas de problème vu qu'on traite un rectangle à la fois dans le traitement. Ainsi j'ai deux fois un bout de code quasi identique :

Cas du premier passage dans le callback :

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
 
    if ligne == nbre_niveau
 
        for nn = 1:nbre_niveau
            debut_intervalle(nn) = position(nn,1);                                  % récupération des valeurs des intervalles
            fin_intervalle(nn) = debut_intervalle(nn) + position(nn,3);                 %
            taille_intervalle(nn) = fin_intervalle(nn) - debut_intervalle(nn);
        end
 
        highResThumbnail = highResImage;
        [H,L] = size(highResThumbnail);
 
 
        Image2 = zeros(H,L);
        Fait = zeros(H,L);
 
        for kk = 1:nbre_niveau % Algorithme de traitement des données à partir des valeurs d'intervalles
 
            for ii = 1:H
                for jj = 1:L
 
                    if (highResImage(ii,jj) <= fin_intervalle(kk) && highResImage(ii,jj) >= debut_intervalle(kk) && Fait(ii,jj) == 0 )
 
                        Image2(ii,jj) = debut_intervalle(kk) + taille_intervalle(kk)/2;
                        Fait(ii,jj) = 1;
 
                    end
                end
            end
        end
 
        highResThumbnail = Image2;

Cas des passages suivant dans le callback

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
 
    else
        debut_intervalle = position(1);                                  % récupération des valeurs des intervalles
        fin_intervalle = debut_intervalle + position(3);                 %
        taille_intervalle = fin_intervalle - debut_intervalle;
 
        highResThumbnail = highResImage;
        [H,L] = size(highResThumbnail);
 
        Fait = zeros(H,L);
 
    % Algorithme de traitement des données à partir des valeurs d'intervalles
 
        for ii = 1:H
            for jj = 1:L
 
                if (highResImage(ii,jj) <= fin_intervalle && highResImage(ii,jj) >= debut_intervalle  )
 
                    Image2(ii,jj) = debut_intervalle + taille_intervalle/2;
 
                end
            end
        end
        highResThumbnail = Image2;
    end

Le traitement des données à partir de la position en x gauche et droite de chaque rectangle défini en fait sur l'interval 0-255 les intensité des pixels affectées par ce traitement. Ainsi si un pixel voit son intensité comprise dans l'intervalle du dernier rectangle modifié, il verra sa valeur modifié et égale à la valeur médiane de cet intervalle.

La dernière partie est en soit inutile or mis peut être la ligne

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

 set( imHandle,'CData', Image2);

.

Je me suis inspiré de ce topic http://stackoverflow.com/questions/1...ed-with-imrect pour réaliser mon programme, mais comme c'est mon premier callback évolué et que ce topic n'est pas commenté non plus, je tatonne un peu..

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
 if isempty( get(axesHandle,'Children')) 
        imagesc(Image2,'Parent',axesHandle);
 
    else
        imHandle = get(axesHandle,'Children');
        oldSize = size(get(imHandle,'CData'));
        if ~isequal(oldSize, size(highResThumbnail))
            imagesc(Image2,'Parent',axesHandle);
 
        else
            set( imHandle,'CData', Image2);
        end     
    end
 
end

En ce qui concerne l'output du callback, comme je l'ai expliqué il semble qu'on reste dans la callback donc je ne peux pas récupérer la sortie

**Gooby** · 21/05/2015, 11h48

Je ne comprends pas trop ce que tu entends par

Cas des passages suivant dans le callback

alors que tu précises toi même que tu n'entres qu'une unique fois dans le callback?

Résumons. Tu as une image. Tu as deux rectangles positionnés sur cette image. Est-ce que ce sont des rectangles creux (uniquement les contours de tracés) ou des rectangles pleins? Le but est donc juste de tracer les rectangles sur une autre position? Et le problème et que tu n'y arrives pas sans perdre l'image de base. Ai-je bon?
Le code que tu nous fournis a l'air un peu compliqué pour une tâche aussi simple que celle là. Je l'ai parcouru plusieurs fois, et sans être un excellent programmeur, j'ai du mal à m'en imprégner. On peut peut être essayer de le reprendre plus simplement.

**Alex3434** · 21/05/2015, 13h28

Envoyé par Gooby

Je ne comprends pas trop ce que tu entends par

alors que tu précises toi même que tu n'entres qu'une unique fois dans le callback?

En fait je me suis rendu compte que pendant l'exécution du code, on passe une première fois dans la fonction "Contrast" puis cette dernière appelle la callback. Une fois dans la callback on boucle à l'infini dedans.

Seulement, ayant un petit bug (car codé avec les pieds pour le moment) au premier passage dans la callback la variable position est une matrice de dimension 2*4, puis dans les passages ultérieurs ça devient un vecteur 1*4.

Envoyé par Gooby

Résumons. Tu as une image. Tu as deux rectangles positionnés sur cette image. Est-ce que ce sont des rectangles creux (uniquement les contours de tracés) ou des rectangles pleins? Le but est donc juste de tracer les rectangles sur une autre position? Et le problème et que tu n'y arrives pas sans perdre l'image de base. Ai-je bon?
Le code que tu nous fournis a l'air un peu compliqué pour une tâche aussi simple que celle là. Je l'ai parcouru plusieurs fois, et sans être un excellent programmeur, j'ai du mal à m'en imprégner. On peut peut être essayer de le reprendre plus simplement.

Dans un premier temps on calcule l'histogramme d'une image, puis on trace 2 rectangles sur cet histogramme, on récupère les positions des 2 rectangles et on s'en sert pour faire un traitement. La callback est utile car l'utilisateur va modifier la position des rectangles.

Le problème que j'avais se situait dans la callback, a la fin de chaque "boucle" de la callback on perdait l'image traitée. J'ai trouvé la solution, il suffisait de passer cette image dans un handle et de le récupérer en début de callback via un get du handle.

Donc je vais passer le topic en résolu, merci d'avoir pris le temps de vous intéresser à mon problème !

Imrect et les GUIs

MATLAB

Discussions similaires

Partager

Partager