Changeset 227 for trunk/src

Timestamp:

Mar 31, 2011, 1:42:51 PM (13 years ago)

Author:

sommeria

Message:

add function sub_field_series to apply the sub_field operation to a series of fileds (for instance subtracting a background to an image series)

Location:

trunk/src

Files:

• civ.m (modified) (12 diffs)
• delete_object.m (modified) (1 diff)
• geometry_calib.m (modified) (7 diffs)
• get_field.fig (modified) (previous)
• get_field.m (modified) (34 diffs)
• nc2struct.m (modified) (5 diffs)
• pivlab.m (modified) (10 diffs)
• plot_field.m (modified) (2 diffs)
• proj_field.m (modified) (27 diffs)
• read_field.m (modified) (6 diffs)
• read_get_field.m (modified) (14 diffs)
• set_object.m (modified) (4 diffs)
• uvmat.m (modified) (19 diffs)

trunk/src/civ.m

@@ -123 +123 @@
     catch
         errormsg={' Unable to read the file PARAM.xml defining the civx binaries:'; lasterr};
+        return
     end
 else
     errormsg=[xmlfile ' not found: path to civx binaries undefined'];
+    return
 end
 
@@ -1321 +1323 @@
 set(gcf,'Pointer','arrow')
 
-%------------------------------------------------------------------------
-%  determine the list of index pairs of processing file
-function [num1_civ1,num2_civ1,num_a_civ1,num_b_civ1,num1_civ2,num2_civ2,num_a_civ2,num_b_civ2]=...
-    find_pair_indices(handles,mode)
-%------------------------------------------------------------------------
-first_i=str2double(get(handles.first_i,'String'));%first index i
-last_i=str2double(get(handles.last_i,'String'));%last index i
-incr=str2double(get(handles.incr_i,'String'));% increment
-num_i=first_i:incr:last_i;% list of i indices (reference values for each pair)
-if isequal(get(handles.first_j,'Visible'),'on')
-    first_j=str2double(get(handles.first_j,'String'));%first index j
-    last_j=str2double(get(handles.last_j,'String'));%last index j
-    incr_j=str2double(get(handles.incr_j,'String'));% increment
-else
-    first_j=1;
-    last_j=1;
-    incr_j=1;
-end
-num_j=[first_j:incr_j:last_j];% list of j indices (reference values for each pair)
-list_civ1=get(handles.list_pair_civ1,'String');
-index_civ1=get(handles.list_pair_civ1,'Value');
-str_civ1=list_civ1{index_civ1};%string defining the image pairs for civ1
-if isempty(str_civ1)||isequal(str_civ1,'')
-    msgbox_uvmat('ERROR','no image pair selected for civ1')
-    return
-end
-list_civ2=get(handles.list_pair_civ2,'String');
-index_civ2=get(handles.list_pair_civ2,'Value');
-if index_civ2>length(list_civ2)
-    list_civ2=list_civ1;
-    index_civ2=index_civ1;
-end
-str_civ2=list_civ2{index_civ2};%string defining the image pairs for civ2
-if isempty(first_i)||isempty(first_j), msgbox_uvmat('ERROR','first field number not defined'),...
-        return,end;
-if isequal(last_i,[])|| isequal(last_j,[]),msgbox_uvmat('ERROR','last field number not defined'),...
-        return,end;
-if isequal(incr,[])|| isequal(incr_j,[]),msgbox_uvmat('ERROR','increment in field number not defined'),...
-        return,end;
-if last_i < first_i || last_j < first_j , msgbox_uvmat('ERROR','last field number must be larger than the first one'),...
-        return,end;
-if isequal (mode,'series(Di)')
-    %recognize the pair civ1 from the display
-    indsel=find((double(str_civ1)<48)|(double(str_civ1)>57));% character indices of non numerical characters
-    str_raw=str_civ1(indsel);
-    indsepar=find(str_raw=='|'); %character index of the separator
-    d1=str2double(str_civ1(indsel(indsepar-1)+1:indsel(indsepar)-1));
-    if indsepar==length(str_raw)
-        d2=str2double(str_civ1(indsel(indsepar)+1:end));
-    else
-        d2=str2double(str_civ1(indsel(indsepar)+1:indsel(indsepar+1)-1));
-    end
-    num1_civ1=num_i-d1;% set of first image numbers
-    num2_civ1=num_i+d2;
-    num_a_civ1=num_j;
-    num_b_civ1=num_j;
-    
-    %recognize the pair civ2 from the display
-    indsel=find((double(str_civ2)<48)|(double(str_civ2)>57));% character indices of non numerical characters
-    str_raw=str_civ2(indsel);
-    indsepar=find(str_raw=='|'); %character index of the separator
-    d1=str2double(str_civ2(indsel(indsepar-1)+1:indsel(indsepar)-1));
-    if indsepar==length(str_raw)
-        d2=str2double(str_civ2(indsel(indsepar)+1:end));
-    else
-        d2=str2double(str_civ2(indsel(indsepar)+1:indsel(indsepar+1)-1));
-    end
-    if isnan(d1)
-        num1_civ2=num_i;
-    else
-        num1_civ2=num_i-d1;% set of first image numbers
-    end
-    if isnan(d2)
-        num2_civ2=num_i;
-    else
-        num2_civ2=num_i+d2;
-    end
-    num_a_civ2=num_j;
-    num_b_civ2=num_j;
-    
-    % adjust the first and last field number
-    lastfield=str2double(get(handles.nb_field,'String'));
-    if isequal(lastfield,[])
-        indsel=find((num1_civ1 >= 1)&(num1_civ2 >= 1));
-    else
-        indsel=find((num2_civ1 <= lastfield)&(num2_civ2 <= lastfield)&(num1_civ1 >= 1)&(num1_civ2 >= 1));
-    end
-    if length(indsel)>=1
-        firstind=indsel(1);
-        lastind=indsel(end);
-        set(handles.first_i,'String',num2str(num_i(firstind)))%update the display of first and last fields
-        set(handles.last_i,'String',num2str(num_i(lastind)))
-        num_i=num_i(indsel);
-        num1_civ1=num1_civ1(indsel);
-        num1_civ2=num1_civ2(indsel);
-        num2_civ1=num2_civ1(indsel);
-        num2_civ2=num2_civ2(indsel);
-    end
-elseif isequal (mode,'series(Dj)')
-    lastfield_j=str2double(get(handles.nb_field2,'String'));
-    num1_civ1=num_i;% set of first image numbers
-    num2_civ1=num_i;
-    num_a_civ1=num_j-floor(index_civ1/2)*ones(size(num_j));
-    num_b_civ1=num_j+ceil(index_civ1/2)*ones(size(num_j));
-    num1_civ2=num_i;
-    num2_civ2=num_i;
-    num_a_civ2=num_j-floor(index_civ2/2)*ones(size(num_j));
-    num_b_civ2=num_j+ceil(index_civ2/2)*ones(size(num_j));
-    % adjust the first and last field number
-    if isnan(lastfield_j)
-        indsel=find((num_a_civ1 >= 1)&(num_a_civ2 >= 1));
-    else
-        indsel=find((num_b_civ1 <= lastfield_j)&(num_b_civ2 <= lastfield_j)&(num_a_civ1 >= 1)&(num_a_civ2 >= 1));
-    end
-    if length(indsel)>=1
-        firstind=indsel(1);
-        lastind=indsel(end);
-        set(handles.first_j,'String',num2str(num_j(firstind)))%update the display of first and last fields
-        set(handles.last_j,'String',num2str(num_j(lastind)))
-        num_j=num_j(indsel);
-        num_a_civ1=num_a_civ1(indsel);
-        num_a_civ2=num_a_civ2(indsel);
-        num_b_civ1=num_b_civ1(indsel);
-        num_b_civ2=num_b_civ2(indsel);
-    end
-elseif isequal(mode,'pair j1-j2') %case of bursts (png_old or png_2D)
-    num1_civ1=num_i;
-    num1_civ2=num_i;
-    displ_num=get(handles.list_pair_civ1,'UserData');
-    num2_civ1=num_i;
-    num_a_civ1=displ_num(1,index_civ1);
-    num_b_civ1=displ_num(2,index_civ1);
-    num2_civ2=num_i;
-    num_a_civ2=displ_num(1,index_civ2);
-    num_b_civ2=displ_num(2,index_civ2);
-elseif isequal(mode,'displacement')
-    num1_civ1=num_i;
-    num2_civ1=num_i;
-    num_a_civ1=num_j;
-    num_b_civ1=num_j;
-    num1_civ2=num_i;
-    num2_civ2=num_i;
-    num_a_civ2=num_j;
-    num_b_civ2=num_j;
-end
+
 
 
@@ -1586 +1444 @@
 status_Callback(hObject, eventdata, handles)
 end
+
 %------------------------------------------------------------------------
 % --- Lauch command called by RUN and BATCH: remote processing
@@ -1645 +1504 @@
 %% set the list of files and check them
 display('checking the files...')
+[ref_i,ref_j,errormsg]=find_ref_indices(handles);
+if ~isempty(errormsg)
+    msgbox_uvmat('ERROR',errormsg)
+    return
+end
 [filecell,num1_civ1,num2_civ1,num_a_civ1,num_b_civ1,num1_civ2,num2_civ2,num_a_civ2,num_b_civ2,nom_type_nc]=...
-    set_civ_filenames(handles,box_test);
+    set_civ_filenames(handles,ref_i,ref_j,box_test);
 set(handles.civ,'UserData',filecell);%store for futur use of status callback
 if isempty(filecell)% (error message displayed in fct set_civ_filenames)
@@ -1653 +1517 @@
 nbfield=numel(num1_civ1);
 nbslice=numel(num_a_civ1);
-
 
 %% read names of the .exe files for PIV and patch
@@ -2248 +2111 @@
         else       %run PIVlab if selected
             image1=imread(par_civ1.filename_ima_a);
-            image2=imread(par_civ1.filename_ima_b);         
-               [xtable ytable utable vtable ctable typevector] = pivlab (image1,image2,str2num(par_civ1.ibx), str2num(par_civ1.dx), 1, [], []); 
+            image2=imread(par_civ1.filename_ima_b);     
+            stepx=str2num(par_civ1.dx);
+            stepy=str2num(par_civ1.dy);
+            ibx2=ceil(str2num(par_civ1.ibx)/2);
+            iby2=ceil(str2num(par_civ1.iby)/2);
+            isx2=ceil(str2num(par_civ1.isx)/2);
+            isy2=ceil(str2num(par_civ1.isy)/2);
+            shiftx=str2num(par_civ1.shiftx);
+            shifty=str2num(par_civ1.shifty);
+%             ibx=2*ibx2-1;%ibx and iby odd, reduced by 1 if even
+%             iby=2*iby2-1;
+            miniy=max(1+isy2-shifty,1+iby2);
+            minix=max(1+isx2-shiftx,1+ibx2);
+            maxiy=min(size(image1,1)-isy2-shifty,size(image1,1)-iby2); 
+            maxix=min(size(image1,2)-isx2-shiftx,size(image1,2)-ibx2); 
+%             maxix=stepx*(floor(size(image1_roi,2)/stepx))-(2*ibx2-2)+ibx2;
+            [GridX,GridY]=meshgrid(miniy:stepy:maxiy,minix:stepx:maxix);
+            PointCoord(:,1)=reshape(GridX,[],1);
+            PointCoord(:,2)=reshape(GridY,[],1);
+               [xtable ytable utable vtable ctable typevector] = pivlab (image1,image2,ibx2,iby2,isx2,isy2,shiftx,shifty,PointCoord, 1, []); 
                Data.ListGlobalAttribute={'title','Time','Dt'};
                Data.title='PIVlab';
@@ -2312 +2193 @@
 saveas(gcbf,namefigfull);%save the interface with name namefigfull (A CHANGER EN FICHIER  .xml)
 
-
-
-
+%------------------------------------------------------------------------
+% --- determine the list of reference indices of processing file
+function [ref_i,ref_j,errormsg]=find_ref_indices(handles)
+%------------------------------------------------------------------------
+errormsg=''; %default error message
+first_i=str2double(get(handles.first_i,'String'));%first index i
+last_i=str2double(get(handles.last_i,'String'));%last index i
+incr_i=str2double(get(handles.incr_i,'String'));% increment
+if isequal(get(handles.first_j,'Visible'),'on')
+    first_j=str2double(get(handles.first_j,'String'));%first index j
+    last_j=str2double(get(handles.last_j,'String'));%last index j
+    incr_j=str2double(get(handles.incr_j,'String'));% increment
+else
+    first_j=1;
+    last_j=1;
+    incr_j=1;
+end
+ref_i=first_i:incr_i:last_i;% list of i indices (reference values for each pair)
+ref_j=first_j:incr_j:last_j;% list of j indices (reference values for each pair)
+if isnan(first_i)||isnan(first_j)
+    errormsg='first field number not defined';
+elseif isnan(last_i)||isnan(last_j)
+    errormsg='last field number not defined';
+elseif isnan(incr_i)||isnan(incr_j)
+    errormsg='increment in field number not defined';
+elseif last_i < first_i || last_j < first_j 
+    errormsg='last field number must be larger than the first one';
+end
+
+%------------------------------------------------------------------------
+% --- determine the list of filenames and indices needed for launch_job
 function [filecell,num1_civ1,num2_civ1,num_a_civ1,num_b_civ1,num1_civ2,num2_civ2,num_a_civ2,num_b_civ2,nom_type_nc,file_ref_fix1,file_ref_fix2]=...
-    set_civ_filenames(handles,box_test)
+    set_civ_filenames(handles,ref_i,ref_j,box_test)
 %------------------------------------------------------------------------
 filecell=[];%default
@@ -2351 +2260 @@
 if isempty(nom_type_nc),nom_type_nc='_i1-i2';end; %default
 [num1_civ1,num2_civ1,num_a_civ1,num_b_civ1,num1_civ2,num2_civ2,num_a_civ2,num_b_civ2]=...
-    find_pair_indices(handles,mode);
+    find_pair_indices(handles,ref_i,ref_j,mode);
 %determine the new filebase for 'displacement' mode (comparison of two series)
 filebase_B=filebase;% root name of the second field series for stereo
@@ -3034 +2943 @@
 
 %------------------------------------------------------------------------
+% --- determine the list of index pairs of processing file
+function [num1_civ1,num2_civ1,num_a_civ1,num_b_civ1,num1_civ2,num2_civ2,num_a_civ2,num_b_civ2]=...
+    find_pair_indices(handles,ref_i,ref_j,mode)
+%------------------------------------------------------------------------
+
+list_civ1=get(handles.list_pair_civ1,'String');
+index_civ1=get(handles.list_pair_civ1,'Value');
+str_civ1=list_civ1{index_civ1};%string defining the image pairs for civ1
+if isempty(str_civ1)||isequal(str_civ1,'')
+    msgbox_uvmat('ERROR','no image pair selected for civ1')
+    return
+end
+list_civ2=get(handles.list_pair_civ2,'String');
+index_civ2=get(handles.list_pair_civ2,'Value');
+if index_civ2>length(list_civ2)
+    list_civ2=list_civ1;
+    index_civ2=index_civ1;
+end
+str_civ2=list_civ2{index_civ2};%string defining the image pairs for civ2
+
+if isequal (mode,'series(Di)')
+    lastfield=str2double(get(handles.nb_field,'String'));
+    num1_civ1=ref_i-floor(index_civ1/2)*ones(size(ref_i));% set of first image numbers
+    num2_civ1=ref_i+ceil(index_civ1/2)*ones(size(ref_i));
+    num_a_civ1=ref_j;
+    num_b_civ1=ref_j;
+    num1_civ2=ref_i-floor(index_civ2/2)*ones(size(ref_i));;
+    num2_civ2=ref_i+ceil(index_civ2/2)*ones(size(ref_i));
+    num_a_civ2=ref_j;
+    num_b_civ2=ref_j;   
+    
+    % adjust the first and last field number
+    lastfield=str2double(get(handles.nb_field,'String'));
+    if isnan(lastfield)
+        indsel=find((num1_civ1 >= 1)&(num1_civ2 >= 1));
+    else
+        indsel=find((num2_civ1 <= lastfield)&(num2_civ2 <= lastfield)&(num1_civ1 >= 1)&(num1_civ2 >= 1));
+    end
+    if length(indsel)>=1
+        firstind=indsel(1);
+        lastind=indsel(end);
+        set(handles.first_i,'String',num2str(ref_i(firstind)))%update the display of first and last fields
+        set(handles.last_i,'String',num2str(ref_i(lastind)))
+        ref_i=ref_i(indsel);
+        num1_civ1=num1_civ1(indsel);
+        num1_civ2=num1_civ2(indsel);
+        num2_civ1=num2_civ1(indsel);
+        num2_civ2=num2_civ2(indsel);
+    end
+elseif isequal (mode,'series(Dj)')
+    lastfield_j=str2double(get(handles.nb_field2,'String'));
+    num1_civ1=ref_i;% set of first image numbers
+    num2_civ1=ref_i;
+    num_a_civ1=ref_j-floor(index_civ1/2)*ones(size(ref_j));
+    num_b_civ1=ref_j+ceil(index_civ1/2)*ones(size(ref_j));
+    num1_civ2=ref_i;
+    num2_civ2=ref_i;
+    num_a_civ2=ref_j-floor(index_civ2/2)*ones(size(ref_j));
+    num_b_civ2=ref_j+ceil(index_civ2/2)*ones(size(ref_j));
+    % adjust the first and last field number
+    if isnan(lastfield_j)
+        indsel=find((num_a_civ1 >= 1)&(num_a_civ2 >= 1));
+    else
+        indsel=find((num_b_civ1 <= lastfield_j)&(num_b_civ2 <= lastfield_j)&(num_a_civ1 >= 1)&(num_a_civ2 >= 1));
+    end
+    if length(indsel)>=1
+        firstind=indsel(1);
+        lastind=indsel(end);
+        set(handles.first_j,'String',num2str(ref_j(firstind)))%update the display of first and last fields
+        set(handles.last_j,'String',num2str(ref_j(lastind)))
+        ref_j=ref_j(indsel);
+        num_a_civ1=num_a_civ1(indsel);
+        num_b_civ1=num_b_civ1(indsel);
+        num_a_civ2=num_a_civ2(indsel);
+        num_b_civ2=num_b_civ2(indsel);
+    end
+elseif isequal(mode,'pair j1-j2') %case of bursts (png_old or png_2D)
+    displ_num=get(handles.list_pair_civ1,'UserData');
+    num1_civ1=ref_i;
+    num2_civ1=ref_i;
+    num_a_civ1=displ_num(1,index_civ1);
+    num_b_civ1=displ_num(2,index_civ1);
+    num1_civ2=ref_i;
+    num2_civ2=ref_i;
+    num_a_civ2=displ_num(1,index_civ2);
+    num_b_civ2=displ_num(2,index_civ2);
+elseif isequal(mode,'displacement')
+    num1_civ1=ref_i;
+    num2_civ1=ref_i;
+    num_a_civ1=ref_j;
+    num_b_civ1=ref_j;
+    num1_civ2=ref_i;
+    num2_civ2=ref_i;
+    num_a_civ2=ref_j;
+    num_b_civ2=ref_j;
+end
+
+
+%------------------------------------------------------------------------
 % --- PATCH
 function cmd_PATCH=PATCH_CMD(filename_nc,nx_patch,ny_patch,rho_patch,subdomain_patch,thresh_value,test_interp,PatchBin)
@@ -4596 +4604 @@
 test_civ1=get(handles.TestCiv1,'Value');
 if test_civ1
+    ref_i=str2double(get(handles.ref_i,'String'));
+    if strcmp(get(handles.ref_j,'Visible'),'on')
+        ref_j=str2double(get(handles.ref_j,'String'));
+    else
+        ref_j=1;%default
+    end
     [filecell,num1_civ1,num2_civ1,num_a_civ1,num_b_civ1,num1_civ2,num2_civ2,num_a_civ2,num_b_civ2,nom_type_nc,file_ref_fix1,file_ref_fix2]=...
-        set_civ_filenames(handles,[1 0 0 0 0 0]);
+        set_civ_filenames(handles,ref_i,ref_j,[1 0 0 0 0 0]);
     Data.ListVarName={'ny','nx','A'};
     Data.VarDimName={'ny','nx',{'ny','nx'}};
@@ -4603 +4617 @@
     Data.ny=[size(Data.A,1) 1];
     Data.nx=[1 size(Data.A,2)];
+    par_civ1=read_param_civ1(handles,filecell.ima1.civ1{1});
+    
+            stepx=str2num(par_civ1.dx);
+            stepy=str2num(par_civ1.dy);
+            ibx2=ceil(str2num(par_civ1.ibx)/2);
+            iby2=ceil(str2num(par_civ1.iby)/2);
+            isx2=ceil(str2num(par_civ1.isx)/2);
+            isy2=ceil(str2num(par_civ1.isy)/2);
+            shiftx=str2num(par_civ1.shiftx);
+            shifty=str2num(par_civ1.shifty);
+%             ibx=2*ibx2-1;%ibx and iby odd, reduced by 1 if even
+%             iby=2*iby2-1;
+            miniy=max(1+isy2-shifty,1+iby2);
+            minix=max(1+isx2-shiftx,1+ibx2);
+            maxiy=min(size(image1,1)-isy2-shifty,size(image1,1)-iby2); 
+            maxix=min(size(image1,2)-isx2-shiftx,size(image1,2)-ibx2); 
+%             maxix=stepx*(floor(size(image1_roi,2)/stepx))-(2*ibx2-2)+ibx2;
+            [GridX,GridY]=meshgrid(miniy:stepy:maxiy,minix:stepx:maxix);
+            PointCoord(:,1)=reshape(GridX,[],1);
+            PointCoord(:,2)=reshape(GridY,[],1);
     hh=view_field(Data);
+    set(0,'CurrentFigure',hh)
+    plot(PointCoord(:,2),PointCoord(:,1),'+')
     ViewData=get(hh,'UserData');
     ViewData.axes3.B=imread(filecell.ima2.civ1{1});%store the second image in the UserData of the GUI view_field
@@ -4652 +4688 @@
 filecell=get(handles.civ,'UserData');
 if ~isfield(filecell,'nc')
-    filecell=set_civ_filenames(handles,box_test);%determine the list of output files expected from the GUI status
+    [ref_i,ref_j,errormsg]=find_ref_indices(handles);
+    if ~isempty(errormsg)
+        msgbox_uvmat('ERROR',errormsg)
+        return
+    end
+    filecell=set_civ_filenames(handles,ref_i,ref_j,box_test);%determine the list of output files expected from the GUI status
 end
 

trunk/src/delete_object.m

@@ -44 +44 @@
         end
         UvData.Object(hObject)=[];  
-        list_str(hObject)=[];
+        if ~isempty(list_str)
+            list_str(hObject)=[];
+        end
     end
 elseif ishandle(hObject)%object handle

trunk/src/geometry_calib.m

@@ -441 +441 @@
 %------------------------------------------------------------------------
 % determine the parameters for a calibration by a linear transform matrix (rescale and rotation)
-function GeometryCalib=calib_linear(Coord,handles) %TO UPDATE
+function GeometryCalib=calib_linear(Coord,handles) 
 %------------------------------------------------------------------------
 X=Coord(:,1);
@@ -461 +461 @@
 GeometryCalib.fx_fy(2)=(a_Y1(3)/a_X1(2))*GeometryCalib.fx_fy(1);
 GeometryCalib.CoordUnit=[];% default value, to be updated by the calling function
-GeometryCalib.Tx_Ty_Tz=[a_X1(1) a_Y1(1) 1]; 
+%GeometryCalib.Tx_Ty_Tz=[a_X1(1) a_Y1(1) 1]; 
+GeometryCalib.Tx_Ty_Tz=[a_X1(1)/GeometryCalib.fx_fy(1) a_Y1(1)/GeometryCalib.fx_fy(2) 1];
 R(1,:)=R(1,:)/GeometryCalib.fx_fy(1);
 R(2,:)=R(2,:)/GeometryCalib.fx_fy(2);
@@ -1030 +1031 @@
 ind_sub_x=round(XLim);
 ind_sub_y=np(1)-round(YLim);
-Mfiltre=AxeData.A([ind_sub_y(2):ind_sub_y(1)] ,ind_sub_x,:);
+Mfiltre=AxeData.A(ind_sub_y(2):ind_sub_y(1) ,ind_sub_x,:);
 Mfiltre_norm=double(Mfiltre);
 Mfiltre_norm=Mfiltre_norm/sum(sum(Mfiltre_norm));
@@ -1064 +1065 @@
 if ~isempty(ObjectData.Coord)
     if isequal(option,'phys')
-        ObjectData.Coord=ObjectData.Coord(:,[1:3]);
+        ObjectData.Coord=ObjectData.Coord(:,1:3);
     elseif isequal(option,'px')||isequal(option,'')
-        ObjectData.Coord=ObjectData.Coord(:,[4:5]);
+        ObjectData.Coord=ObjectData.Coord(:,4:5);
     else
         msgbox_uvmat('ERROR','the choice in menu_coord of uvmat must be '''', px or phys ')
@@ -1135 +1136 @@
 function MenuDetectGrid_Callback(hObject, eventdata, handles)
 %------------------------------------------------------------------------
-%% initiate the grid
-CalibData=get(handles.geometry_calib,'UserData');%get information stored on the GUI geometry_calib
-grid_input=[];%default
-if isfield(CalibData,'grid')
-    grid_input=CalibData.grid;%retrieve the previously used grid
-end
-[T,CalibData.grid,white_test]=create_grid(grid_input,'detect_grid');%display the GUI create_grid, read the set of phys coordinates T
-set(handles.geometry_calib,'UserData',CalibData)%store the phys grid parameters for later use
-
 %% read the four last point coordinates in pixels
 Coord_cell=get(handles.ListCoord,'String');%read list of coordinates on geometry_calib
@@ -1149 +1141 @@
 nbpoints=size(data.Coord,1); %nbre of calibration points
 if nbpoints~=4
-    msgbox_uvmat('ERROR','four points must have be selected by the mouse, beginning by the new x axis, to delimitate the phys grid area')
+    msgbox_uvmat('ERROR','four points must have be selected by the mouse to delimitate the phys grid area; the Ox axis will be defined by the two first points')
     return
 end
@@ -1165 +1157 @@
       corners_Y(3)=Y_end;
 end
+
+%% initiate the grid
+CalibData=get(handles.geometry_calib,'UserData');%get information stored on the GUI geometry_calib
+grid_input=[];%default
+if isfield(CalibData,'grid')
+    grid_input=CalibData.grid;%retrieve the previously used grid
+end
+[T,CalibData.grid,white_test]=create_grid(grid_input,'detect_grid');%display the GUI create_grid, read the set of phys coordinates T
+set(handles.geometry_calib,'UserData',CalibData)%store the phys grid parameters for later use
+
+
 
 %% read the current image, displayed in the GUI uvmat

trunk/src/get_field.m

@@ -22 +22 @@
 function varargout = get_field(varargin)
 
-% Last Modified by GUIDE v2.5 06-Feb-2010 09:58:13
+% Last Modified by GUIDE v2.5 27-Mar-2011 19:13:26
 
 % Begin initialization code - DO NOT EDIT
@@ -49 +49 @@
 global nb_builtin % nbre of functions to include by default in the menu of  functions called by RUN
 
-%% look at the existing figures in the work space
-browse_fig(handles.list_fig)
+
 
 %% Choose default command line output for get_field
@@ -58 +57 @@
 guidata(hObject, handles);
 
-%% activate the mouse action function: visualise the current field on work space by right click action
-set(hObject,'WindowButtonUpFcn',{@mouse_up_gui,handles})
+%%activate the mouse action function: visualise the current field on work space by right click action
+%set(hObject,'WindowButtonUpFcn',{@mouse_up_gui,handles})
 
 %% prepare the list of RUN fcts and set their paths
@@ -112 +111 @@
 %% settings for 'slave' mode, called by uvamt, or 'master' mode
 if exist('filename','var') && ischar(filename) %transfer input file name in slave mode
-    set(handles.inputfile,'String',filename)% prefill the input file name 
-    Field=nc2struct(filename);% reads the whole field
+    set(handles.inputfile,'String',filename)% prefill the input file name
+    Field=nc2struct(filename,[]);% reads the whole field
     if isfield(Field,'Txt')
         msgbox_uvmat('ERROR',Field.Txt)
     else
-        set(handles.figure1,'UserData',Field);
+        set(handles.get_field,'UserData',Field);
         Field_input(eventdata,handles,Field);
     end
 else  %master mode
-    set(handles.inputfile,'String','')   
-%     set(handles.RUN,'String','RUN')%
-    % load the list of previously browsed files for the upper bar menu Open 
-    dir_perso=prefdir;
-    profil_perso=fullfile(dir_perso,'uvmat_perso.mat');%
-    if exist(profil_perso,'file')
-        h=load (profil_perso);
-        if isfield(h,'MenuFile_1')
-            set(handles.MenuFile_1,'Label',h.MenuFile_1);
-        end
-        if isfield(h,'MenuFile_1')
-            set(handles.MenuFile_2,'Label',h.MenuFile_2);
-        end
-        if isfield(h,'MenuFile_1')
-            set(handles.MenuFile_3,'Label',h.MenuFile_3);
-        end
-        if isfield(h,'MenuFile_1')
-            set(handles.MenuFile_4,'Label',h.MenuFile_4);
-        end
-        if isfield(h,'MenuFile_1')
-            set(handles.MenuFile_5,'Label',h.MenuFile_5);
-        end
+    set(handles.inputfile,'String','')
+end
+
+%% load the list of previously browsed files for the upper bar menu Open
+dir_perso=prefdir;
+profil_perso=fullfile(dir_perso,'uvmat_perso.mat');%
+if exist(profil_perso,'file')
+    h=load (profil_perso);
+    if isfield(h,'MenuFile_1')
+        set(handles.MenuFile_1,'Label',h.MenuFile_1);
+    end
+    if isfield(h,'MenuFile_1')
+        set(handles.MenuFile_2,'Label',h.MenuFile_2);
+    end
+    if isfield(h,'MenuFile_1')
+        set(handles.MenuFile_3,'Label',h.MenuFile_3);
+    end
+    if isfield(h,'MenuFile_1')
+        set(handles.MenuFile_4,'Label',h.MenuFile_4);
+    end
+    if isfield(h,'MenuFile_1')
+        set(handles.MenuFile_5,'Label',h.MenuFile_5);
     end
 end
@@ -168 +167 @@
 %------------------------------------------------------------------------
 inputfile=get(handles.inputfile,'String');
-Field=nc2struct(inputfile);% reads the whole field
+Field=nc2struct(inputfile,[]);% reads the  field description, without data
+Field.ListGlobalAttribute
 if isfield(Field,'Txt')
     msgbox_uvmat('ERROR',Field.Txt)
 else
-set(handles.figure1,'UserData',Field);
+set(handles.get_field,'UserData',Field);
 Field_input(eventdata,handles,Field);
 end
@@ -189 +189 @@
         Tabcell{iline,2}=num2str(Field.DimValue(iline));
     end
-    Tabchar=cell2tab(Tabcell,'=');
+    Tabchar=cell2tab(Tabcell,' = ');
     set(handles.dimensions,'String',Tabchar)
 end
@@ -212 +212 @@
 set(handles.coord_z_vectors,'String',[{''} Txt ])
 set(handles.scalar,'Value',1)
+
 set(handles.scalar,'String', Txt )
 [CellVarIndex,NbDim,VarType,errormsg]=find_field_indices(Field);
@@ -218 +219 @@
     return
 end  
+for icell=1:numel(CellVarIndex)
+    NbDim(icell)=max(NbDim(icell),numel(CellVarIndex{icell}));
+end
 [maxdim,imax]=max(NbDim);
    
@@ -278 +282 @@
     check_vector_Callback(handles.check_vector, eventdata, handles)
 end
+%scalar_Callback(handles.get_field, eventdata, handles)
+%vector_x_Callback(handles.get_field, eventdata, handles)
 
 %------------------------------------------------------------------------
@@ -315 +321 @@
 % test_2D=get(handles.check_vector,'Value');% =1 for vector fields
 % test_scalar=get(handles.check_scalar,'Value');% =1 for scalar fields
-%if isequal(xdispindex,1)% blank selection, no selected variable for abscissa
+%if isequal(xdispindex,1)% blank selection, no selected TimeVariable for abscissa
 %     Txt=Field.ListVarName;
 %     set(handles.ordinate,'String',[{''} Txt ])% display all the varaibles in the list of ordinates
@@ -329 +335 @@
 %      end
 %     set(handles.variables,'Value',xindex+1)%outline  in the list of variables 
-%     variables_Callback(hObject, eventdata, handles)  %display properties of the variable (dim, attributes)
+%     variables_Callback(hObject, eventdata, handles)  %display properties of the TimeVariable (dim, attributes)
 %     if  ~test_2D &  ~test_scalar% look for possible varaibles to RUN in ordinate    
-%         index=Field.VarDimIndex{xindex};%dimension indices of the variable selected for abscissa
+%         index=Field.VarDimIndex{xindex};%dimension indices of the TimeVariable selected for abscissa
 %         VarIndex=[];
 %         for ilist=1:length(Field.VarDimIndex)%detect 
 %             index_i=Field.VarDimIndex{ilist};
 %             if ~isempty(index_i)
-%                 if isequal(index_i(1),index(1))%if the first dimension of the variable coincide with the selected one, RUN is possible
+%                 if isequal(index_i(1),index(1))%if the first dimension of the TimeVariable coincide with the selected one, RUN is possible
 %                     VarIndex=[VarIndex ilist];
 %                 end
@@ -352 +358 @@
 function scalar_Callback(hObject, eventdata, handles)
 %------------------------------------------------------------------------
-Aindex=get(handles.scalar,'Value');
-Astring=get(handles.scalar,'String');
-VarName=Astring{Aindex};
+index=get(handles.scalar,'Value');
+string=get(handles.scalar,'String');
+VarName=string{index};
 update_field(hObject, eventdata, handles,VarName)
+
+%eliminate time
+TimeDimName='';%default
+if strcmp(get(handles.TimeDimensionMenu,'Visible'),'on')
+    TimeDimList=get(handles.TimeDimensionMenu,'String');
+    TimeDimIndex=get(handles.TimeDimensionMenu,'Value');
+    TimeDimName=TimeDimList{TimeDimIndex};
+end
+
+%check possible coordinates
+Field=get(handles.get_field,'UserData');
+dim_scalar=Field.VarDimName{index};%list of dimensions of the selected scalar
+test_coord=ones(size(Field.VarDimName)); %=1 when variable #ilist is eligible as coordinate
+for ilist=1:numel(Field.VarDimName)
+    dimnames=Field.VarDimName{ilist}; %list of dimensions for variable #ilist
+    if isequal(dimnames,{TimeDimName})
+        test_coord(ilist)=0;%mark time variables fo elimination
+    end
+    for idim=1:numel(dimnames)
+        if isempty(find(strcmp(dimnames{idim},dim_scalar),1))%dimension not found in the scalar variable
+            test_coord(ilist)=0;
+            break
+        end
+    end
+end
+test_coord(index)=0;%the coordinate variable must be different from the scalar
+
+string_coord=[{''};string(test_coord==1)];
+val=get(handles.coord_x_scalar,'Value');
+if val>numel(string_coord)
+    set(handles.coord_x_scalar,'Value',1)
+end
+set(handles.coord_x_scalar,'String',string_coord);
+val=get(handles.coord_y_scalar,'Value');
+if val>numel(string_coord)
+    set(handles.coord_y_scalar,'Value',1)
+end
+set(handles.coord_y_scalar,'String',string_coord);
+val=get(handles.coord_y_scalar,'Value');
+if val>numel(string_coord)
+    set(handles.coord_y_scalar,'Value',1)
+end
+set(handles.coord_z_scalar,'String',string_coord);
+
 
 %------------------------------------------------------------------------
@@ -391 +441 @@
 string=get(handles.vector_x,'String');
 VarName=string{index};
+
+%check possible coordinates
+Field=get(handles.get_field,'UserData');
+dim_var=Field.VarDimName{index};%list of dimensions of the selected scalar
+test_coord=ones(size(Field.VarDimName)); %=1 when variable #ilist is eligible as coordinate
+test_component=ones(size(Field.VarDimName)); %=1 when variable #ilist is eligible as other vector component
+for ilist=1:numel(Field.VarDimName)
+    dimnames=Field.VarDimName{ilist}; %list of dimensions for variable #ilist
+    if ~isequal(dimnames,dim_var)
+        test_component(ilist)=0;
+    end
+    for idim=1:numel(dimnames)
+        if isempty(find(strcmp(dimnames{idim},dim_var),1))%dimension not found in the scalar variable
+            test_coord(ilist)=0;
+            break
+        end
+    end
+end
+%eliminate time
+if get(handles.TimeVariable,'Value')
+    TimeName=get(handles.TimeName,'String');
+    index_time=find(strcmp( TimeName,Field.ListVarName));
+    test_coord(index_time)=0;
+end
+vlength=numel(string(test_component==1));
+val=get(handles.vector_y,'Value');
+if val>vlength
+    set(handles.vector_y,'Value',1)
+end
+set(handles.vector_y,'String',[string(test_component==1)])
+val=get(handles.vector_z,'Value');
+if val>vlength+1
+    set(handles.vector_z,'Value',1)
+end
+set(handles.vector_z,'String',[{''};string(test_component==1)])
+val=get(handles.vec_color,'Value');
+if val>vlength+1
+    set(handles.vec_color,'Value',1)
+end
+set(handles.vec_color,'String',[{''};string(test_component==1)])
+string_coord=[{''};string(test_coord==1)];
+val=get(handles.coord_x_vectors,'Value');
+if val>numel(string_coord)
+    set(handles.coord_x_vectors,'Value',1)
+end
+set(handles.coord_x_vectors,'String',string_coord);
+val=get(handles.coord_y_vectors,'Value');
+if val>numel(string_coord)
+    set(handles.coord_y_vectors,'Value',1)
+end
+set(handles.coord_y_vectors,'String',string_coord);
+val=get(handles.coord_z_vectors,'Value');
+if val>numel(string_coord)
+    set(handles.coord_z_vectors,'Value',1)
+end
+set(handles.coord_z_vectors,'String',string_coord);
+
 update_field(hObject, eventdata, handles,VarName)
 
@@ -420 +527 @@
 update_field(hObject, eventdata, handles,VarName)
 
-%-------------------------------------------------------
+%------------------------------------------------------------------------
 % --- Executes on selection change in coord_y_vectors.
-%-------------------------------------------------------
 function coord_y_vectors_Callback(hObject, eventdata, handles)
+%------------------------------------------------------------------------
 index=get(handles.coord_y_vectors,'Value');
 string=get(handles.coord_y_vectors,'String');
@@ -429 +536 @@
 update_field(hObject, eventdata, handles,VarName)
 
-%-------------------------------------------------------
+%------------------------------------------------------------------------
 % --- Executes on selection change in coord_z_scalar.
 function coord_z_vectors_Callback(hObject, eventdata, handles)
-%-------------------------------------------------------
+%------------------------------------------------------------------------
 index=get(handles.coord_z_vectors,'Value');
 string=get(handles.coord_z_vectors,'String');
@@ -438 +545 @@
 update_field(hObject, eventdata, handles,VarName)
 
-%-------------------------------------------------------
+%------------------------------------------------------------------------
 % --- Executes on selection change in vec_color.
 function vec_color_Callback(hObject, eventdata, handles)
-%-------------------------------------------------------
+%------------------------------------------------------------------------
 index=get(handles.vec_color,'Value');
 string=get(handles.vec_color,'String');
@@ -447 +554 @@
 update_field(hObject, eventdata, handles,VarName)
 
-%---------------------------------
+%-----------------------------------------------------------------------
 function update_field(hObject, eventdata, handles,VarName)
-% VarName= input variable name for scalar or vector plots
-hselect_field=get(handles.inputfile,'parent');
-Field=get(hselect_field,'UserData');
+%-----------------------------------------------------------------------
+Field=get(handles.get_field,'UserData');
 index=name2index(VarName,Field.ListVarName);
 if ~isempty(index)
@@ -457 +563 @@
     variables_Callback(hObject, eventdata, handles)
 end
-% 
-% 
-% hselect_field=get(handles.inputfile,'parent');
-% Field=get(hselect_field,'UserData');
-% ivar_sel=[];%default
-% for ivar=1:length(Field.ListVarName)%detect 
-%     if isequal(Field.ListVarName{ivar},VarName)
-%         ivar_sel=ivar; %ivar_sel = index of the input variable in the list ListVarName
-%         break
-%     end
-% end
-% if isempty(ivar_sel)
-%     return
-% end
-% set(handles.variables,'Value',ivar_sel+1)%select the corresponding item in the displayed  list 'variables'
-% variables_Callback(hObject, eventdata, handles)%show the dimensions and attributes of the input variable
-% 
-% index=Field.VarDimIndex{ivar_sel};%dimension indices of the input variable
-% DimValue=Field.DimValue(index);%dimension values of the input variable
-% ind_1=find(DimValue==1);
-% index(ind_1)=[];%Mremove singletons
-% 
-% 
-% % detect possible variables for abscissa and ordinate
-% VarIndex=[];%initiate list of selected variable indices
-% ind_coordvar=[]; %initiate list of coordinate variables
-% for ilist=1:length(Field.VarDimIndex)
-%     if ~isequal(ilist,ivar_sel)        
-%         index_i=Field.VarDimIndex{ilist};%indices of dimensions associated with variable #ilist
-%         if length(index_i)>1
-%             DimValue=Field.DimValue(index_i);
-%             ind_1=find(DimValue==1);
-%             index_i(ind_1)=[];%Mremove singletons
-%             if isequal(index,index_i)
-%                 VarIndex=[VarIndex ilist]; %selected variable withb the same dimensions of the input variable
-%             end
-%         else
-%             idim=find(index==index_i(1));
-%             if ~isempty(idim)
-%                  VarIndex=[VarIndex ilist]; %possible dimension variable
-%                  if isequal(Field.ListDimName{index_i(1)},Field.ListVarName{ilist})
-%                      ind_coordvar=[ind_coordvar length(VarIndex)];
-%                  end
-%             end
-%         end
-%     end
-% end
-% % val=get(handles.abscissa,'Value');
-% % if val>length(Field.ListVarName(VarIndex))+1
-% %     set(handles.abscissa,'Value',length(Field.ListVarName(VarIndex))+1)
-% % end
-% % val=get(handles.ordinate,'Value');
-% % if val>length(Field.ListVarName(VarIndex))+1
-% %     set(handles.abscissa,'Value',length(Field.ListVarName(VarIndex))+1)
-% % end
-% % val=get(handles.coord_z_vectors_scalar,'Value');
-% % if val>length(Field.ListVarName(VarIndex))+1
-% %     set(handles.abscissa,'Value',length(Field.ListVarName(VarIndex))+1)
-% % end
-% set(handles.abscissa,'Value',1)%default
-% set(handles.ordinate,'Value',1)%default
-% set(handles.coord_z_scalar,'Value',1)%default
-% set(handles.abscissa,'String',[{''} Field.ListVarName(VarIndex) ])
-% set(handles.ordinate,'String',[{''} Field.ListVarName(VarIndex) ])
-% set(handles.coord_z_scalar,'String',[{''} Field.ListVarName(VarIndex) ])
-% if length(ind_coordvar)>=1
-%     set(handles.abscissa,'Value',ind_coordvar(1)+1)
-% elseif length(index)==1 && length(VarIndex)>=1
-%     set(handles.abscissa,'Value',2)
-% end
-% if length(ind_coordvar)>=2
-%     set(handles.ordinate,'Value',ind_coordvar(2)+1)
-% elseif length(index)==1 && length(VarIndex)>=2
-%     set(handles.ordinate,'Value',3)
-% end
-% if length(ind_coordvar)>=3
-%     set(handles.coord_z_scalar,'Value',ind_coordvar(3)+1)
-% elseif length(index)==1 && length(VarIndex)>=3
-%     set(handles.coord_z_scalar,'Value',4)
-% end
-
-%---------------------------------------------------------
+
+%------------------------------------------------------------------------
 % update the UserData Field for use of the selected variables outsde get_field (taken from RUN_Callback)
 function update_UserData(handles)
-%---------------------------------------------------------
+%------------------------------------------------------------------------
 return
 % global SubField
@@ -615 +641 @@
     end
     DimIndex=DimIndex_u;
-    %TODO possibility of selecting 3 times the same variable for u, v, w components
-end
-
-
-% select the variable  index (or indices) for z coordinates
+    %TODO possibility of selecting 3 times the same TimeVariable for u, v, w components
+end
+
+
+% select the TimeVariable  index (or indices) for z coordinates
 test_grid=0;
 if test_scalar | test_vector
@@ -658 +684 @@
         end
 %         if ~isempty(VarIndex_z)
-%             DimIndex_z=Field.VarDimIndex{VarIndex_z};%dimension indices of the variable    
-%             if length(DimIndex_z)==1 & nbdim==3 %dimension variable
+%             DimIndex_z=Field.VarDimIndex{VarIndex_z};%dimension indices of the TimeVariable    
+%             if length(DimIndex_z)==1 & nbdim==3 %dimension TimeVariable
 %                 VarAttribute{VarIndex_z}.Role=Field.ListDimName{DimIndex_z};
 %                 ind_z=find(DimIndex==DimIndex_z(1));
@@ -669 +695 @@
 end
 
-% select the variable  index (or indices) for ordinate
+% select the TimeVariable  index (or indices) for ordinate
 ystring=get(handles.ordinate,'String');
 yindex=get(handles.ordinate,'Value'); %selected indices in the ordinate listbox
@@ -701 +727 @@
 end
 
-%select the variable index for the abscissa
+%select the TimeVariable index for the abscissa
 xstring=get(handles.abscissa,'String');
 xindex=get(handles.abscissa,'Value');
@@ -801 +827 @@
 function RUN_Callback(hObject, eventdata, handles)
 %---------------------------------------------------------
-figcell=get(handles.list_fig,'String');
-index=get(handles.list_fig,'value');
-figstring=figcell{index};
+set(handles.RUN,'BackgroundColor',[1 1 0])% mark use of RUN action
+test_fig=get(handles.SelectFigure,'Value');
 
 % plot requested in uvmat
-if isequal(figstring,'uvmat')
+if ~test_fig
     inputfile=get(handles.inputfile,'String');
     huvmat=findobj(allchild(0),'tag','uvmat');
@@ -814 +839 @@
         set(huvmat,'Visible','on')%make uvmat visible (bugs can hide it in some cases)
         hhuvmat=guidata(huvmat);
+        set(hhuvmat.Fields,'Value',1)
+        set(hhuvmat.Fields,'String',{'get_field...'})
         uvmat('run0_Callback',hObject,eventdata,hhuvmat); % display field in uvmat
     end
    
 % other kind of plot
-else
+else  %TODO: check and update: add plot on an existing axes
+    figcell=get(handles.list_fig,'String');
+    index=get(handles.list_fig,'value');
+    figstring=figcell{index};
     index=get(handles.ACTION,'Value');
     list_func=get(handles.ACTION,'UserData');
@@ -824 +854 @@
     set(handles.RUN,'BackgroundColor',[0.831 0.816 0.784])
     drawnow
-    SubField=h_fun(handles.figure1);%handles.figure1 =handles of the GUI get_field
+    SubField=h_fun(handles.get_field);%handles.figure1 =handles of the GUI get_field
     if ~isempty(SubField)
         plot_get_field(SubField,handles)
@@ -869 +899 @@
 % % handles    structure with handles and user data (see GUIDATA)
 % 
-% %time plots
+% %timename plots
 % leg={};
 % n=0;
@@ -1042 +1072 @@
 Tabcell=[];
 hselect_field=get(handles.variables,'parent');
-Field=get(hselect_field,'UserData');
+Field=get(handles.get_field,'UserData');
 index=get(handles.variables,'Value');%index in the list 'variables'
 if isequal(index,1) 
     set(handles.attributes_txt,'String','global attributes')
-% list global attribute names and values if index=1 (blank variable display) is selected
+% list global TimeAttribute names and values if index=1 (blank TimeVariable display) is selected
     if isfield(Field,'ListGlobalAttribute') && ~isempty(Field.ListGlobalAttribute)
         for iline=1:length(Field.ListGlobalAttribute)
@@ -1062 +1092 @@
     end
 else
-%list attribute names and values associated to the variable # injdex-1   
+%list TimeAttribute names and values associated to the TimeVariable # injdex-1   
     list_var=get(handles.variables,'String');
     var_select=list_var{index};
@@ -1115 +1145 @@
         Tabdim{iline,2}=num2str(Field.DimValue(dim_indices(iline)));
     end
-    Tabchar=cell2tab(Tabdim,'=');
+    Tabchar=cell2tab(Tabdim,' = ');
     Tabchar=[{''} ;Tabchar];
+    set(handles.dimensions,'Value',1)
     set(handles.dimensions,'String',Tabchar)  
 end  
@@ -1153 +1184 @@
 end
 
-%------------------------------------------------------------------------
-function mouse_up_gui(ggg,eventdata,handles)
-%------------------------------------------------------------------------
-if isequal(get(ggg,'SelectionType'),'alt') 
-    message='';  
-    global CurData
-    inputfield=get(handles.inputfile,'String');
-    if exist(inputfield,'file')
-        CurData=nc2struct(inputfield);
-    else
-        CurData=get(ggg,'UserData');% get_field opened from a input field, not a file
-    end
-  %%%% TODO: put the matalb command window in front
-    evalin('base','global CurData')%make CurData global in the workspace
-    evalin('base','CurData') %display CurData in the workspace
-end
+% %------------------------------------------------------------------------
+% function mouse_up_gui(ggg,eventdata,handles)
+% %------------------------------------------------------------------------
+% if isequal(get(ggg,'SelectionType'),'alt') 
+%     message='';  
+%     global CurData
+%     inputfield=get(handles.inputfile,'String');
+%     if exist(inputfield,'file')
+%         CurData=nc2struct(inputfield);
+%     else
+%         CurData=get(ggg,'UserData');% get_field opened from a input field, not a file
+%     end
+%   %%%% TODO: put the matalb command window in front
+%     evalin('base','global CurData')%make CurData global in the workspace
+%     evalin('base','CurData') %display CurData in the workspace
+% end
 
 %------------------------------------------------------------------------
@@ -1414 +1445 @@
 %global inputfile
 fileinput=[PathName FileName];%complete file name 
-testblank=findstr(fileinput,' ');%look for blanks
-if ~isempty(testblank)
-    msgbox_uvmat('ERROR',['The input file name ' fileinput ' contains blank character : This is not allowed. Please change name'])
-    return
-end
 sizf=size(fileinput);
-if (~ischar(fileinput)|~isequal(sizf(1),1)),return;end
+if (~ischar(fileinput)||~isequal(sizf(1),1)),return;end
 set(handles.inputfile,'String',fileinput)
 inputfile_Callback(hObject, eventdata, handles)
-
 
 %update list of recent files in the menubar
@@ -1464 +1489 @@
 inputfile_Callback(hObject, eventdata, handles)
 
-% --------------------------------------------------------------------
+% -----------------------------------------------------------------------
 function MenuFile_3_Callback(hObject, eventdata, handles)
+% -----------------------------------------------------------------------
 fileinput=get(handles.MenuFile_3,'Label');
 set(handles.inputfile,'String',fileinput)
 inputfile_Callback(hObject, eventdata, handles)
 
-% --------------------------------------------------------------------
+% -----------------------------------------------------------------------
 function MenuFile_4_Callback(hObject, eventdata, handles)
+% -----------------------------------------------------------------------
 fileinput=get(handles.MenuFile_4,'Label');
 set(handles.inputfile,'String',fileinput)
 inputfile_Callback(hObject, eventdata, handles)
 
-% --------------------------------------------------------------------
+% -----------------------------------------------------------------------
 function MenuFile_5_Callback(hObject, eventdata, handles)
+% -----------------------------------------------------------------------
 fileinput=get(handles.MenuFile_5,'Label');
 set(handles.inputfile,'String',fileinput)
 inputfile_Callback(hObject, eventdata, handles)
 
-% --------------------------------------------------------------------
+%------------------------------------------------------------------------
 function MenuExportField_Callback(hObject, eventdata, handles)
+%------------------------------------------------------------------------
 global Data_get_field
 % huvmat=findobj(allchild(0),'Name','uvmat');
@@ -1494 +1523 @@
 commandwindow;
 
-% --------------------------------------------------------------------
+%------------------------------------------------------------------------
 function MenuHelp_Callback(hObject, eventdata, handles)
-% hObject    handle to MenuHelp (see GCBO)
-% eventdata  reserved - to be defined in a future version of MATLAB
-% handles    structure with handles and user data (see GUIDATA)
+%------------------------------------------------------------------------
 path_to_uvmat=which ('uvmat');% check the path of uvmat
 pathelp=fileparts(path_to_uvmat);
@@ -1507 +1534 @@
 end
 
+% -----------------------------------------------------------------------
+function TimeName_Callback(hObject, eventdata, handles)
+
+scalar_Callback(hObject, eventdata, handles)% suppress time variable from possible spatial coordinates
+vector_x_Callback(hObject, eventdata, handles)
+
+%------------------------------------------------------------------------
+% --- Executes on button press in TimeAttribute.
+function TimeAttribute_Callback(hObject, eventdata, handles)
+%------------------------------------------------------------------------
+val=get(handles.TimeAttribute,'Value');
+if val
+    set(handles.TimeAttributeMenu,'Visible','on')
+    Field=get(handles.get_field,'UserData');
+    time_value=zeros(size(Field.ListGlobalAttribute));
+    test_time=zeros(size(Field.ListGlobalAttribute));
+    for ilist=1:numel(Field.ListGlobalAttribute)
+        if isnumeric(eval(['Field.' Field.ListGlobalAttribute{ilist}]))
+            eval(['time_val=Field.' Field.ListGlobalAttribute{ilist} ';'])
+            if ~isempty(time_val)
+                time_value(ilist)=time_val;
+                test_time(ilist)=1;
+            end
+        end
+    end
+    ListTimeAttribute=Field.ListGlobalAttribute(test_time==1);
+    attr_index=get(handles.TimeAttributeMenu,'Value');
+    if attr_index>numel(ListTimeAttribute)
+        attr_index=1;
+        set(handles.TimeAttributeMenu,'Value',1);
+    end
+    if isempty(ListTimeAttribute)
+        set(handles.TimeAttributeMenu,'String',{''})
+        set(handles.TimeValue,'Visible','off')
+    else
+        set(handles.TimeValue,'Visible','on')
+        set(handles.TimeAttributeMenu,'String',ListTimeAttribute)
+        set(handles.TimeValue,'String',num2str(time_value(attr_index)))
+    end
+    set(handles.TimeDimension,'Value',0)
+    TimeDimension_Callback(hObject, eventdata, handles)
+    set(handles.TimeVariable,'Value',0)
+    TimeVariable_Callback(hObject, eventdata, handles)
+else
+    set(handles.TimeAttributeMenu,'Visible','off')
+    set(handles.TimeValue,'Visible','off')
+end
+
+%------------------------------------------------------------------------
+% --- Executes on selection change in TimeAttributeMenu.
+function TimeAttributeMenu_Callback(hObject, eventdata, handles)
+ ListTimeAttribute=get(handles.TimeAttributeMenu,'String');
+ index=get(handles.TimeAttributeMenu,'Value');
+ AttrName=ListTimeAttribute{index};
+ Field=get(handles.get_field,'UserData');
+ eval(['time_val=Field.' AttrName ';'])
+ set(handles.TimeValue,'String',num2str(time_val))
+%------------------------------------------------------------------------
+
+%------------------------------------------------------------------------
+% --- Executes on button press in TimeVariable.
+function TimeDimension_Callback(hObject, eventdata, handles)
+%------------------------------------------------------------------------
+val=get(handles.TimeDimension,'Value');%=1 if check box TimeDimension is selected
+if val  %if check box TimeDimension is selected
+    Field=get(handles.get_field,'UserData');% structure describing the currently opened field
+    previous_menu=get(handles.TimeDimensionMenu,'String');
+    if ~isequal(previous_menu,Field.ListDimName)%update the list of available dimensions in the menu
+        ind_select=find(strcmpi('time',Field.ListDimName),1);% look for a dimension named 'time' or 'Time'
+        if isempty(ind_select)
+            ind_select=1;% select the first item in the list if 'time' is not found
+        end
+        set(handles.TimeDimensionMenu,'Value',ind_select);
+        set(handles.TimeDimensionMenu,'String',Field.ListDimName)% put the list of available dimensions in the menu
+    end    
+    set(handles.TimeDimensionMenu,'Visible','on')% the menu is made visible
+    set(handles.TimeIndexValue,'Visible','on')% the time matrix index value selected is made visible
+    TimeDimensionMenu_Callback(hObject, eventdata, handles)  
+    set(handles.TimeAttribute,'Value',0) %deselect alternative options for time
+    set(handles.TimeVariable,'Value',0)
+    TimeAttribute_Callback(hObject, eventdata, handles)
+else
+    set(handles.TimeDimensionMenu,'Visible','off')
+    set(handles.TimeIndexValue,'Visible','off')
+end
+
+%------------------------------------------------------------------------
+% --- Executes on selection change in TimeDimensionMenu.
+function TimeDimensionMenu_Callback(hObject, eventdata, handles)
+%------------------------------------------------------------------------
+index=get(handles.TimeDimensionMenu,'Value');
+DimList=get(handles.TimeDimensionMenu,'String');
+DimName=DimList{index};
+Field=get(handles.get_field,'UserData');
+DimIndex=find(strcmp(DimName,Field.ListDimName),1);
+ref_index=round(Field.DimValue(DimIndex)/2);   
+set(handles.TimeIndexValue,'String',num2str(ref_index))
+scalar_Callback(hObject, eventdata, handles)
+vector_x_Callback(hObject, eventdata, handles)% update menus of coordinates (remove time)
+ % look for a corresponding time variable and value
+ time_test=zeros(size(Field.VarDimName));
+ for ilist=1:numel(Field.VarDimName)
+     if isequal(Field.VarDimName{ilist},{DimName})
+         time_test(ilist)=1;
+     end
+ end
+ ListVariable=Field.ListVarName(time_test==1);
+ set(handles.TimeVariableMenu,'Value',1)
+ if isempty(ListVariable)     
+     set(handles.TimeVariableMenu,'String',{''})
+     set(handles.TimeVarValue,'String','')
+ else
+    set(handles.TimeVariableMenu,'String',ListVariable)
+    TimeVarName=ListVariable{1};
+    VarIndex=find(strcmp(TimeVarName,Field.ListVarName),1);%index in the list of variables
+    inputfile=get(handles.inputfile,'String');% read the input file
+    SubField=nc2struct(inputfile,{TimeVarName});
+    eval(['TimeValue=SubField.' TimeVarName '(ref_index);'])
+    set(handles.TimeVarValue,'Visible','on')
+    set(handles.TimeVariableMenu,'Visible','on')
+    set(handles.TimeVarValue,'String',num2str(TimeValue))
+ end
+
+
+% % -----------------------------------------------------------------------
+% % --- Executes on button press in TimeVariable.
+% function TimeVariable_Callback(hObject, eventdata, handles)
+% % -----------------------------------------------------------------------
+% val=get(handles.TimeVariable,'Value');
+% if val
+%     Field=get(handles.get_field,'UserData');
+%     time_test=zeros(size(Field.VarDimName));
+%     for ilist=1:numel(Field.VarDimName)
+%         if isequal(numel(Field.VarDimName{ilist}),1)%select variables with a single dimension
+%             time_test(ilist)=1;
+%         end
+%     end
+%     ind_test=find(time_test);
+%     if isempty(time_test)
+%         set(handles.TimeVariable,'Value',0)
+%         set(handles.TimeVariableMenu,'Visible','off')
+%         set(handles.TimeVarValue,'Visible','off')
+%     else
+%         set(handles.TimeVariableMenu,'Visible','on')
+%         set(handles.TimeVarValue,'Visible','on')
+%         if get(handles.TimeVariableMenu,'Value')>numel(ind_test)
+%             set(handles.TimeVariableMenu,'Value',1)
+%         end
+%         set(handles.TimeVariableMenu,'String',Field.ListVarName(ind_test))
+%         TimeVariableMenu_Callback(hObject, eventdata, handles)
+%         set(handles.TimeDimension,'Value',0) %deseselect alternative option sfor time
+%         set(handles.TimeAttribute,'Value',0)
+%         TimeAttribute_Callback(hObject, eventdata, handles)
+%     end
+% else
+%     set(handles.TimeVariableMenu,'Visible','off')
+%     set(handles.TimeVarValue,'Visible','off')
+% end
+
+% -----------------------------------------------------------------------
+% --- Executes on selection change in TimeVariableMenu.
+function TimeVariableMenu_Callback(hObject, eventdata, handles)
+% -----------------------------------------------------------------------
+ListVar=get(handles.TimeVariableMenu,'String');
+index=get(handles.TimeVariableMenu,'Value');
+TimeVariable=ListVar{index};% name of the selected variable
+if isempty(TimeVariable)% case of blank selection
+    return
+end
+Field=get(handles.get_field,'UserData'); %index of 
+VarIndex=find(strcmp(TimeVariable,Field.ListVarName),1);%index in the list of variables
+DimName=Field.VarDimName{VarIndex}; % dimension corresponding to the variable
+set(handles.TimeDimensionMenu,'Value',1)
+set(handles.TimeDimensionMenu,'String',DimName)
+inputfile=get(handles.inputfile,'String');% read the input file
+SubField=nc2struct(inputfile,{TimeVariable});
+eval(['TimeDimension=numel(SubField.' TimeVariable ');'])
+ref_index=round(TimeDimension/2);
+eval(['TimeValue=SubField.' TimeVariable '(ref_index);'])
+set(handles.TimeIndexValue,'String',num2str(ref_index))
+set(handles.TimeVarValue,'String',num2str(TimeValue))
+
+
+function TimeValue_Callback(hObject, eventdata, handles)
+%TO suppress 
+
+% -----------------------------------------------------------------------
+function TimeIndexValue_Callback(hObject, eventdata, handles)
+% -----------------------------------------------------------------------
+TimeIndex=str2double(get(handles.TimeIndexValue,'String'));
+TimeVarName=Field.ListVarName{time_index};
+set(handles.TimeVariable,'Value',1)
+set(handles.TimeName,'String',TimeVarName)
+fileinput=get(handles.inputfile,'String');
+SubField=nc2struct(fileinput,{TimeVarName});
+eval(['TimeValue=SubField.' TimeVarName '(ref_index);']);
+set(handles.TimeValue,'Visible','on')
+set(handles.TimeValue,'String',num2str(TimeValue))
+
+% -----------------------------------------------------------------------
+function SelectFigure_Callback(hObject, eventdata, handles)
+% -----------------------------------------------------------------------
+val=get(handles.SelectFigure,'Value');
+if val
+    set(handles.list_fig,'Visible','on')
+    %% look at the existing figures in the work space
+    browse_fig(handles.list_fig)
+else
+   set(handles.list_fig,'Visible','off') 
+end
+
+
+function TimeVarValue_Callback(hObject, eventdata, handles)
+
+
+
+% --- Executes on button press in check_rgb.
+function check_rgb_Callback(hObject, eventdata, handles)
+
+
+

trunk/src/nc2struct.m

@@ -65 +65 @@
             nc=netcdf.open(nc,'NC_NOWRITE');
             testfile=1;
-            catch errormsg
-              Data.Txt=['ERROR opening ' nc ': ' errormsg.identifier];
+            catch ME
+              Data.Txt=['ERROR opening ' nc ': ' ME.message];
               return
             end
@@ -77 +77 @@
     end
     
-    %% short reading opion for global attributes only, if the first argument is 'ListGlobalAttribute'
+    %% short reading option for global attributes only, if the first argument is 'ListGlobalAttribute'
     if isequal(varargin{1},'ListGlobalAttribute')
         for ilist=2:numel(varargin)
+            valuestr=[];%default
             try
             valuestr = netcdf.getAtt(nc,netcdf.getConstant('NC_GLOBAL'),varargin{ilist});
-            catch
-                valuestr=[];
+            catch ME
             end
             eval(['Data.' varargin{ilist} '=valuestr;'])
@@ -97 +97 @@
     %%  -------- read all global attributes (constants)-----------
     att_key={};%default
-    iatt_g=0;
+%     iatt_g=0;
     Data.ListGlobalAttribute={};%default
     for iatt=1:ngatts
         keystr= netcdf.inqAttName(nc,netcdf.getConstant('NC_GLOBAL'),iatt-1);
-        indstr1=regexp(keystr,'\\','once');%detect '\\'
-        indstr2=regexp(keystr,'\.','once');%detect '\.'
-        %indtitle=regexp(keystr,'title','once');%detect 'title'(bad characters)
-        if isempty(indstr1) && isempty(indstr2)%&&isempty(indtitle)
-           valuestr = netcdf.getAtt(nc,netcdf.getConstant('NC_GLOBAL'),keystr);
-           if ischar(valuestr) & length(valuestr)<200 & double(valuestr)<=122 & double(valuestr)>=48 %usual characters
-                iatt_g=iatt_g+1;
-                indstr1=regexp(keystr,'\\','once');%detect '\\'
-                indstr2=regexp(keystr,'\.','once');%detect '\.'
-                if isempty(indstr1) && isempty(indstr2)
-                    eval(['Data.' keystr '=''' valuestr ''';'])
-                    att_key{iatt_g}=keystr;
-                end
-            elseif isempty(valuestr)
-                iatt_g=iatt_g+1;
-                eval(['Data.' keystr '=[];'])
-                att_key{iatt_g}=keystr;
+        valuestr = netcdf.getAtt(nc,netcdf.getConstant('NC_GLOBAL'),keystr);
+        keystr=regexprep(keystr,{'\','/','\.','-',' '},{'','','','',''});%remove  '\','.' or '-' if exists
+        if strcmp(keystr(1),'_')
+            keystr(1)=[];
+        end
+        try
+            if ischar(valuestr) & length(valuestr)<200 & double(valuestr)<=122 & double(valuestr)>=48 %usual characters
+               % valuestr=regexprep(valuestr,{'\\','\/','\.','\-',' '},{'_','_','_','_','_'})%remove  '\','.' or '-' if exists
+                eval(['Data.' keystr '=''' valuestr ''';'])
+%             elseif isempty(valuestr)
+%                 eval(['Data.' keystr '=[];'])
             elseif isnumeric(valuestr)
-                iatt_g=iatt_g+1;
                 eval(['Data.' keystr '=valuestr;'])
-                att_key{iatt_g}=keystr;
-            end
+            else
+                eval(['Data.' keystr '='';']) 
+            end
+            att_key{iatt}=keystr;
+        catch ME
+            att_key{iatt}=['attr_' num2str(iatt)];
+            eval(['Data.' att_key{iatt} '=[];'])
         end
     end
@@ -184 +182 @@
             attname = netcdf.inqAttName(nc,var_index(ivar)-1,iatt-1);
             valuestr= netcdf.getAtt(nc,var_index(ivar)-1,attname);
+            attname=regexprep(attname,{'\','/','\.','-',' '},{'','','','',''});%remove  '\','.' or '-' if exists
+            if strcmp(attname(1),'_')
+                attname(1)=[];
+            end
+            try
             if ischar(valuestr)
+               % valuestr=regexprep(valuestr,{'\\','\/','\.','\-',' '},{'_','_','_','_','_'});%remove  '\','.' or '-' if exists
                 eval(['Data.VarAttribute{ivar}.' attname '=''' valuestr ''';'])
             elseif isempty(valuestr)
@@ -190 +194 @@
             elseif isnumeric(valuestr)
                 eval(['Data.VarAttribute{ivar}.' attname '=valuestr;'])
+            end
+            catch ME
+                display(attname)
+                display(valuestr)
+                display(ME.message)         
+                eval(['Data.VarAttribute{ivar}.atrr_' num2str(iatt) '=''not read'';'])
             end
         end

trunk/src/pivlab.m

@@ -1 +1 @@
 % 'pivlab': function piv.m adapted from PIVlab http://pivlab.blogspot.com/
 %--------------------------------------------------------------------------
-% function [xtable ytable utable vtable typevector] = pivlab (image1,image2,interrogationarea, step, subpixfinder, mask, roi)
+% function [xtable ytable utable vtable typevector] = pivlab (image1,image2,ibx,iby step, subpixfinder, mask, roi)
 %
 % OUTPUT:
@@ -14 +14 @@
 % image1:first image (matrix)
 % image2: second image (matrix)
-% interrogationarea: size of the correlation box (in px)
+% ibx,iby: size of the correlation box along x and y (in px)
 % step: mesh of the measurement points (in px)
 % subpixfinder=1 or 2 controls the curve fitting of the image correlation
 % mask: =[] for no mask
 % roi: 4 element vector defining a region of interest: x position, y position, width, height, (in image indices), for the whole image, roi=[];
-function [xtable ytable utable vtable ctable typevector] = pivlab (image1,image2,interrogationarea, step, subpixfinder, mask, roi)
+function [xtable ytable utable vtable ctable typevector] = pivlab (image1,image2,ibx2,iby2,isx2,isy2,shiftx,shifty, PointCoord, subpixfinder,mask)
 %this funtion performs the DCC PIV analysis. Recent window-deformation
 %methods perform better and will maybe be implemented in the future.
 warning off %MATLAB:log:logOfZero
-if numel(roi)>0
-    xroi=roi(1);
-    yroi=roi(2);
-    widthroi=roi(3);
-    heightroi=roi(4);
-    image1_roi=double(image1(yroi:yroi+heightroi,xroi:xroi+widthroi));
-    image2_roi=double(image2(yroi:yroi+heightroi,xroi:xroi+widthroi));
-else
+% if numel(roi)>0
+%     xroi=roi(1);
+%     yroi=roi(2);
+%     widthroi=roi(3);
+%     heightroi=roi(4);
+%     image1_roi=double(image1(yroi:yroi+heightroi,xroi:xroi+widthroi));
+%     image2_roi=double(image2(yroi:yroi+heightroi,xroi:xroi+widthroi));
+% else
     xroi=0;
     yroi=0;
     image1_roi=double(image1);
     image2_roi=double(image2);
-end
+% end
 if numel(mask)>0
     cellmask=mask;
@@ -48 +48 @@
 end
 mask(mask>1)=1;
-
-miniy=1+(ceil(interrogationarea/2));
-minix=1+(ceil(interrogationarea/2));
-maxiy=step*(floor(size(image1_roi,1)/step))-(interrogationarea-1)+(ceil(interrogationarea/2)); %statt size deltax von ROI nehmen
-maxix=step*(floor(size(image1_roi,2)/step))-(interrogationarea-1)+(ceil(interrogationarea/2));
-
-numelementsy=floor((maxiy-miniy)/step+1);
-numelementsx=floor((maxix-minix)/step+1);
-
-LAy=miniy;
-LAx=minix;
-LUy=size(image1_roi,1)-maxiy;
-LUx=size(image1_roi,2)-maxix;
-shift4centery=round((LUy-LAy)/2);
-shift4centerx=round((LUx-LAx)/2);
-if shift4centery<0 %shift4center will be negative if in the unshifted case the left border is bigger than the right border. the vectormatrix is hence not centered on the image. the matrix cannot be shifted more towards the left border because then image2_crop would have a negative index. The only way to center the matrix would be to remove a column of vectors on the right side. but then we weould have less data....
-    shift4centery=0;
-end
-if shift4centerx<0 %shift4center will be negative if in the unshifted case the left border is bigger than the right border. the vectormatrix is hence not centered on the image. the matrix cannot be shifted more towards the left border because then image2_crop would have a negative index. The only way to center the matrix would be to remove a column of vectors on the right side. but then we weould have less data....
-    shift4centerx=0;
-end
-miniy=miniy+shift4centery;
-minix=minix+shift4centerx;
-maxix=maxix+shift4centerx;
-maxiy=maxiy+shift4centery;
-
-image1_roi=padarray(image1_roi,[ceil(interrogationarea/2) ceil(interrogationarea/2)], min(min(image1_roi)));
-image2_roi=padarray(image2_roi,[ceil(interrogationarea/2) ceil(interrogationarea/2)], min(min(image1_roi)));
-mask=padarray(mask,[ceil(interrogationarea/2) ceil(interrogationarea/2)],0);
-if (rem(interrogationarea,2) == 0) %for the subpixel displacement measurement
-    SubPixOffset=1;
-else
-    SubPixOffset=0.5;
-end
-xtable=zeros(numelementsy,numelementsx);
+% ibx=2*ibx2-1%ibx and iby odd, reduced by 1 if even
+% iby=2*iby2-1
+% miniy=1+iby2
+% minix=1+ibx2
+% maxiy=step*(floor(size(image1_roi,1)/step))-(iby-1)+iby2 %statt size deltax von ROI nehmen
+% maxix=step*(floor(size(image1_roi,2)/step))-(ibx-1)+ibx2
+% numelementsy=floor((maxiy-miniy)/step+1);
+% numelementsx=floor((maxix-minix)/step+1);
+% 
+% LAy=miniy;
+% LAx=minix;
+% LUy=size(image1_roi,1)-maxiy;
+% LUx=size(image1_roi,2)-maxix;
+% shift4centery=round((LUy-LAy)/2);
+% shift4centerx=round((LUx-LAx)/2);
+% if shift4centery<0 %shift4center will be negative if in the unshifted case the left border is bigger than the right border. the vectormatrix is hence not centered on the image. the matrix cannot be shifted more towards the left border because then image2_crop would have a negative index. The only way to center the matrix would be to remove a column of vectors on the right side. but then we weould have less data....
+%     shift4centery=0;
+% end
+% if shift4centerx<0 %shift4center will be negative if in the unshifted case the left border is bigger than the right border. the vectormatrix is hence not centered on the image. the matrix cannot be shifted more towards the left border because then image2_crop would have a negative index. The only way to center the matrix would be to remove a column of vectors on the right side. but then we weould have less data....
+%     shift4centerx=0;
+% end
+% miniy=miniy+shift4centery;
+% minix=minix+shift4centerx;
+% maxix=maxix+shift4centerx;
+% maxiy=maxiy+shift4centery;
+
+image1_roi=padarray(image1_roi,[iby2 ibx2], min(min(image1_roi)));%add a border around the image with minimum image value
+image2_roi=padarray(image2_roi,[iby2 ibx2], min(min(image1_roi)));
+mask=padarray(mask,[iby2 ibx2],0);
+SubPixOffset=0.5;%odd values chosen for ibx and iby
+
+nbvec=size(PointCoord,1);
+xtable=zeros(nbvec,1);
 ytable=xtable;
 utable=xtable;
@@ -89 +87 @@
 v2table=xtable;
 s2n=xtable;
-typevector=ones(numelementsy,numelementsx);;
+typevector=ones(size(xtable));
 
 nrx=0;
@@ -97 +95 @@
 
 %% MAINLOOP
-%handles=guihandles(getappdata(0,'hgui'));
-for j = miniy:step:maxiy %vertical loop
-    nry=nry+1;
-%     if increments<6 %reduced display refreshing rate
-%         increments=increments+1;
-%     else
-%         increments=1;
-%         %set(handles.progress, 'string' , ['Frame progress: ' int2str(j/maxiy*100) '%']);drawnow;
-%     end
-    n=round((j-miniy)/maxiy*100);
-    for i = minix:step:maxix % horizontal loop
-        nrx=nrx+1;%used to determine the pos of the vector in resulting matrix
-        if nrxreal < numelementsx
-            nrxreal=nrxreal+1;
-        else
-            nrxreal=1;
-        end
-        startpoint=[i j];
-        image1_crop=image1_roi(j:j+interrogationarea-1, i:i+interrogationarea-1);
-        image2_crop=image2_roi(ceil(j-interrogationarea/2):ceil(j+1.5*interrogationarea-1), ceil(i-interrogationarea/2):ceil(i+1.5*interrogationarea-1));
-        corrmax=0;
-        if mask(round(j+interrogationarea/2),round(i+interrogationarea/2))==0
+for ivec=1:nbvec
+    iref=PointCoord(ivec,1);
+    jref=PointCoord(ivec,2);
+    image1_crop=image1_roi(jref-iby2:jref+iby2,iref-ibx2:iref+ibx2);
+    image2_crop=image2_roi(jref+shifty-isy2:jref+shifty+isy2,iref+shiftx-isx2:iref+shiftx+isx2);
+%     n=round((j-miniy)/maxiy*100);
+%     for i = minix:step:maxix % horizontal loop
+%         nrx=nrx+1;%used to determine the pos of the vector in resulting matrix
+%         if nrxreal < numelementsx
+%             nrxreal=nrxreal+1;
+%         else
+%             nrxreal=1;
+%         end
+%         startpoint=[i j];
+%         image1_crop=image1_roi(j:j+iby-1, i:i+ibx-1);
+%         image2_crop=image2_roi(ceil(j-iby/2):ceil(j+1.5*iby-1), ceil(i-ibx/2):ceil(i+1.5*ibx-1));
+%         corrmax=0;
+        if mask(jref,iref)==0
            %reference: Oliver Pust, PIV: Direct Cross-Correlation
            % image2_crop: sub image with the size of the search area in image 2
@@ -132 +126 @@
                 try
                     if subpixfinder==1
-                        [vector] = SUBPIXGAUSS (result_conv,interrogationarea,x,y,SubPixOffset);
+                        [vector] = SUBPIXGAUSS (result_conv,ibx,iby,x,y,SubPixOffset);
                     elseif subpixfinder==2
-                        [vector] = SUBPIX2DGAUSS (result_conv,interrogationarea,x,y,SubPixOffset);
+                        [vector] = SUBPIX2DGAUSS (result_conv,ibx,iby,x,y,SubPixOffset);
                     end
                 catch
@@ -144 +138 @@
         else %if mask was not 0 then
             vector=[NaN NaN];
-            typevector(nry,nrxreal)=0;
+            typevector(ivec)=0;
         end
 
         %Create the vector matrix x, y, u, v
-        xtable(nry,nrxreal)=startpoint(1)+interrogationarea/2;
-        ytable(nry,:)=startpoint(1,2)+interrogationarea/2;
-        utable(nry,nrxreal)=vector(1);
-        vtable(nry,nrxreal)=vector(2);
-        ctable(nry,nrxreal)=corrmax/sum(sum(image1_crop.*image1_crop));
-     end
-
-end
-xtable=xtable-ceil(interrogationarea/2);
-ytable=ytable-ceil(interrogationarea/2);
-
-xtable=xtable+xroi;
-ytable=ytable+yroi;
-
-utable(utable>interrogationarea/1.5)=NaN;
-vtable(utable>interrogationarea/1.5)=NaN;
-vtable(vtable>interrogationarea/1.5)=NaN;
-utable(vtable>interrogationarea/1.5)=NaN;
-
-function [vector] = SUBPIXGAUSS (result_conv,interrogationarea,x,y,SubPixOffset)
+        xtable(ivec)=PointCoord(ivec,2);
+        ytable(ivec)=PointCoord(ivec,1);
+        utable(ivec)=vector(1);
+        vtable(ivec)=vector(2);
+        ctable(ivec)=corrmax/sum(sum(image1_crop.*image1_crop));
+end
+% xtable=xtable-ibx2;
+% ytable=ytable-iby2;
+% 
+% xtable=xtable+xroi;
+% ytable=ytable+yroi;
+% 
+% utable(utable>ibx/1.5)=NaN;
+% vtable(utable>ibx/1.5)=NaN;
+% vtable(vtable>iby/1.5)=NaN;
+% utable(vtable>iby/1.5)=NaN;
+
+function [vector] = SUBPIXGAUSS (result_conv,ibx,iby,x,y,SubPixOffset)
 if size(x,1)>1 %if there are more than 1 peaks just take the first
     x=x(1:1);
@@ -186 +178 @@
     peakx = x+ (f1-f2)/(2*f1-4*f0+2*f2);
     %
-    SubpixelX=peakx-(interrogationarea/2)-SubPixOffset;
-    SubpixelY=peaky-(interrogationarea/2)-SubPixOffset;
+    SubpixelX=peakx-(ibx/2)-SubPixOffset;
+    SubpixelY=peaky-(iby/2)-SubPixOffset;
     vector=[SubpixelX, SubpixelY];
 else
@@ -193 +185 @@
 end
 
-function [vector] = SUBPIX2DGAUSS (result_conv,interrogationarea,x,y,SubPixOffset)
+function [vector] = SUBPIX2DGAUSS (result_conv,ibx,iby,x,y,SubPixOffset)
 if size(x,1)>1 %if there are more than 1 peaks just take the first
     x=x(1:1);
@@ -229 +221 @@
     peaky=y+deltay;
 
-    SubpixelX=peakx-(interrogationarea/2)-SubPixOffset;
-    SubpixelY=peaky-(interrogationarea/2)-SubPixOffset;
+    SubpixelX=peakx-(ibx/2)-SubPixOffset;
+    SubpixelY=peaky-(iby/2)-SubPixOffset;
     vector=[SubpixelX, SubpixelY];
 else

trunk/src/plot_field.m

@@ -585 +585 @@
                 XName=Data.ListVarName{ivar_X};
                 YName=Data.ListVarName{ivar_Y};
-                eval(['vec_X=Data.' XName ';']) 
-                eval(['vec_Y=Data.' YName ';'])
+                eval(['vec_X=reshape(Data.' XName ',[],1);']) 
+                eval(['vec_Y=reshape(Data.' YName ',[],1);'])
             elseif numel(VarType.coord)==2 && ~isequal(VarType.coord,[0 0]);%coordinates defines by dimension variables
                 eval(['y=Data.' Data.ListVarName{VarType.coord(1)} ';']) 
@@ -627 +627 @@
         eval(['A=squeeze(Data.' Data.ListVarName{ivar_C} ');']) ;% scalar represented as color image
         test_ima=1;
-        if ~isempty(ivar_X) && ~isempty(ivar_Y)% 2D field (with unstructured coordinates or structured ones (then ivar_X and ivar_Y empty) 
+        if ~isempty(ivar_X) && ~isempty(ivar_Y)% 2D field (with unstructured coordinates  (then ivar_X and ivar_Y not empty) 
+            A=reshape(A,1,[]);
             XName=Data.ListVarName{ivar_X};
             YName=Data.ListVarName{ivar_Y};
-            eval(['AX=Data.' XName ';']) 
-            eval(['AY=Data.' YName ';'])
+            eval(['AX=reshape(Data.' XName ',1,[]);']) 
+            eval(['AY=reshape(Data.' YName ',1,[]);'])
             [A,AX,AY]=proj_grid(AX',AY',A',[],[],'np>256');  % interpolate on a grid  
             if isfield(Data,'VarAttribute')

trunk/src/proj_field.m

@@ -946 +946 @@
 cos_om=1;
 sin_om=0;
+test90x=0;%=1 for 90 degree rotation alround x axis
+test90y=0;%=1 for 90 degree rotation alround y axis
 if isfield(ObjectData,'Angle')&& isequal(size(ObjectData.Angle),[1 3])&& ~isequal(ObjectData.Angle,[0 0 0])
+    test90y=isequal(ObjectData.Angle,[0 90 0]);
     PlaneAngle=(pi/180)*ObjectData.Angle;
     om=norm(PlaneAngle);%norm of rotation angle in radians
@@ -958 +961 @@
     norm_plane(3)=OmAxis(3)*coeff+cos_om;
 end
-testangle=~isequal(PlaneAngle,[0 0 0]);
+testangle=~isequal(PlaneAngle,[0 0 0]);% && ~test90y && ~test90x;%=1 for slanted plane 
+
 % Phi=0;%default
 % Theta=0;
@@ -1071 +1075 @@
         DimCell={DimCell};%name of dimensions
     end
-
-%% case of input fields with unstructured coordinates
+    
+    %% case of input fields with unstructured coordinates
     if testX
         XName=FieldData.ListVarName{ivar_X};
@@ -1082 +1086 @@
             eval(['coord_z=FieldData.' ZName ';'])
         end
-
+        
         % translate  initial coordinates
         coord_x=coord_x-ObjectData.Coord(1,1);
@@ -1093 +1097 @@
         if length(ivar_Z)==1 &&  width > 0
             %components of the unitiy vector normal to the projection plane
-            fieldZ=norm_plane(1)*coord_x + norm_plane(2)*coord_y+ norm_plane(3)*coord_z;% distance to the plane            
+            fieldZ=norm_plane(1)*coord_x + norm_plane(2)*coord_y+ norm_plane(3)*coord_z;% distance to the plane
             indcut=find(abs(fieldZ) <= width);
             size(indcut)
             for ivar=VarIndex
                 VarName=FieldData.ListVarName{ivar};
-                eval(['FieldData.' VarName '=FieldData.' VarName '(indcut);'])  
-                    % A VOIR : CAS DE VAR STRUCTUREE MAIS PAS GRILLE REGULIERE : INTERPOLER SUR GRILLE REGULIERE              
+                eval(['FieldData.' VarName '=FieldData.' VarName '(indcut);'])
+                % A VOIR : CAS DE VAR STRUCTUREE MAIS PAS GRILLE REGULIERE : INTERPOLER SUR GRILLE REGULIERE
             end
             coord_x=coord_x(indcut);
@@ -1105 +1109 @@
             coord_z=coord_z(indcut);
         end
-
-       %rotate coordinates if needed
-        if testangle
-%             coord_X=coord_x;
-%             coord_Y=coord_y;
-%             if ~isequal(Theta,0)
-%                 coord_Y=coord_Y *cos(Theta);
-%             end
-%         else
+        
+        %rotate coordinates if needed: 
+        if testangle && ~test90y && ~test90x;%=1 for slanted plane
+            %             coord_X=coord_x;
+            %             coord_Y=coord_y;
+            %             if ~isequal(Theta,0)
+            %                 coord_Y=coord_Y *cos(Theta);
+            %             end
+            %         else
             coord_X=(coord_x *cos(Phi) + coord_y* sin(Phi));
             coord_Y=(-coord_x *sin(Phi) + coord_y *cos(Phi))*cos(Theta);
-%         end
-%         if ~isempty(ivar_Z)
+            %         end
+            %         if ~isempty(ivar_Z)
             coord_Y=coord_Y+coord_z *sin(Theta);
-%         end
-%         if testangle
-                coord_X=(coord_X *cos(Psi) - coord_Y* sin(Psi));%A VERIFIER
-                coord_Y=(coord_X *sin(Psi) + coord_Y* cos(Psi));
+            %         end
+            %         if testangle
+            coord_X=(coord_X *cos(Psi) - coord_Y* sin(Psi));%A VERIFIER
+            coord_Y=(coord_X *sin(Psi) + coord_Y* cos(Psi));
         else
             coord_X=coord_x;
@@ -1151 +1155 @@
             for ivar=VarIndex
                 VarName=FieldData.ListVarName{ivar};
-                eval(['FieldData.' VarName '=FieldData.' VarName '(indcut);'])            
+                eval(['FieldData.' VarName '=FieldData.' VarName '(indcut);'])
             end
             coord_X=coord_X(indcut);
@@ -1164 +1168 @@
             %ProjData.ListDimName=[ProjData.ListDimName FieldData.VarDimName(VarIndex(1))];%add the point index to the list of dimensions
             %ProjData.DimValue=[ProjData.
-             %length(coord_X)];
-
+            %length(coord_X)];
+            
             for ivar=VarIndex %transfer variables to the projection plane
                 VarName=FieldData.ListVarName{ivar};
@@ -1175 +1179 @@
                     eval(['ProjData.' VarName '=FieldData.' VarName ';'])
                 end
-                if isempty(ivar_Z) || ivar~=ivar_Z 
+                if isempty(ivar_Z) || ivar~=ivar_Z
                     ProjData.ListVarName=[ProjData.ListVarName VarName];
                     ProjData.VarDimName=[ProjData.VarDimName DimCell];
@@ -1183 +1187 @@
                     end
                 end
-            end  
+            end
         elseif isequal(ObjectData.ProjMode,'interp')||isequal(ObjectData.ProjMode,'filter')%interpolate data on a regular grid
             coord_x_proj=XMin:DX:XMax;
@@ -1189 +1193 @@
             DimCell={'coord_y','coord_x'};
             ProjData.ListVarName={'coord_y','coord_x'};
-            ProjData.VarDimName={'coord_y','coord_x'};   
-            nbcoord=2;  
+            ProjData.VarDimName={'coord_y','coord_x'};
+            nbcoord=2;
             ProjData.coord_y=[YMin YMax];
             ProjData.coord_x=[XMin XMax];
@@ -1211 +1215 @@
             for ivar=VarIndex
                 VarName=FieldData.ListVarName{ivar};
-                if ~( ivar==ivar_X || ivar==ivar_Y || ivar==ivar_Z || ivar==ivar_F || ivar==ivar_FF || test_anc(ivar)==1)                 
+                if ~( ivar==ivar_X || ivar==ivar_Y || ivar==ivar_Z || ivar==ivar_F || ivar==ivar_FF || test_anc(ivar)==1)
                     ivar_new=ivar_new+1;
                     ProjData.ListVarName=[ProjData.ListVarName {VarName}];
@@ -1245 +1249 @@
                 ProjData.FF=reshape(FF,length(coord_y_proj),length(coord_x_proj));
                 ProjData.ListVarName=[ProjData.ListVarName {'FF'}];
-               ProjData.VarDimName=[ProjData.VarDimName {DimCell}];
+                ProjData.VarDimName=[ProjData.VarDimName {DimCell}];
                 ProjData.VarAttribute{ivar_new+1+nbcoord}.Role='errorflag';
             end
         end
         
-%% case of input fields defined on a structured  grid 
+        %% case of input fields defined on a structured  grid
     else
-        VarName=FieldData.ListVarName{VarIndex(1)};%get the first variable of the cell to get the input matrix dimensions
+        'TESTproj'
+        VarName=FieldData.ListVarName{VarIndex(1)}%get the first variable of the cell to get the input matrix dimensions
         eval(['DimValue=size(FieldData.' VarName ');'])%input matrix dimensions
-        DimValue(DimValue==1)=[];%remove singleton dimensions       
+        DimValue(DimValue==1)=[];%remove singleton dimensions
         NbDim=numel(DimValue);%update number of space dimensions
         nbcolor=1; %default number of 'color' components: third matrix index without corresponding coordinate
@@ -1270 +1275 @@
             end
         end
-        AYName=FieldData.ListVarName{VarType.coord(NbDim-1)};%name of input x coordinate (name preserved on projection)
-        AXName=FieldData.ListVarName{VarType.coord(NbDim)};%name of input y coordinate (name preserved on projection)    
+        testangle
+        if testangle% TODO modify name also in case of origin shift in x or y
+            AYName='Y';
+            AXName='X';
+            count=0;
+            %modify coordinate names if they are already used
+            while ~(isempty(find(strcmp('AXName',ProjData.ListVarName),1)) && isempty(find(strcmp('AYName',ProjData.ListVarName),1)))
+                count=count+1;
+                AYName=[AYName '_' num2str(count)];
+                AXName=[AXName '_' num2str(count)];
+            end
+        else
+            AYName=FieldData.ListVarName{VarType.coord(NbDim-1)}%name of input x coordinate (name preserved on projection)
+            AXName=FieldData.ListVarName{VarType.coord(NbDim)}%name of input y coordinate (name preserved on projection)
+        end
         eval(['AX=FieldData.' AXName ';'])
         eval(['AY=FieldData.' AYName ';'])
         ListDimName=FieldData.VarDimName{VarIndex(1)};
-        ProjData.ListVarName=[ProjData.ListVarName {AYName} {AXName}]; %TODO: check if it already exists in Projdata (several cells)
-        ProjData.VarDimName=[ProjData.VarDimName {AYName} {AXName}];
-
-%         for idim=1:length(ListDimName)
-%             DimName=ListDimName{idim};
-%             if strcmp(DimName,'rgb')||strcmp(DimName,'nb_coord')||strcmp(DimName,'nb_coord_i')
-%                nbcolor=DimValue(idim);
-%                DimValue(idim)=[];
-%             end
-%             if isequal(DimName,'nb_coord_j')% NOTE: CASE OF TENSOR NOT TREATED
-%                 DimValue(idim)=[];
-%             end
-%         end  
+            ProjData.ListVarName=[ProjData.ListVarName {AYName} {AXName}]; %TODO: check if it already exists in Projdata (several cells)
+            ProjData.VarDimName=[ProjData.VarDimName {AYName} {AXName}];
         Coord_z=[];
         Coord_y=[];
-        Coord_x=[];   
-
+        Coord_x=[];
+        
         for idim=1:NbDim %loop on space dimensions
             test_interp(idim)=0;%test for coordiate interpolation (non regular grid), =0 by default
@@ -1298 +1305 @@
                 eval(['Coord{idim}=FieldData.' FieldData.ListVarName{ivar} ';']) ;% coord values for the input field
                 if numel(Coord{idim})==2 %input array defined on a regular grid
-                   DCoord_min(idim)=(Coord{idim}(2)-Coord{idim}(1))/DimValue(idim);
+                    DCoord_min(idim)=(Coord{idim}(2)-Coord{idim}(1))/DimValue(idim);
                 else
                     DCoord=diff(Coord{idim});%array of coordinate derivatives for the input field
                     DCoord_min(idim)=min(DCoord);
                     DCoord_max=max(DCoord);
-                %    test_direct(idim)=DCoord_max>0;% =1 for increasing values, 0 otherwise
-                    if abs(DCoord_max-DCoord_min(idim))>abs(DCoord_max/1000) 
+                    %    test_direct(idim)=DCoord_max>0;% =1 for increasing values, 0 otherwise
+                    if abs(DCoord_max-DCoord_min(idim))>abs(DCoord_max/1000)
                         msgbox_uvmat('ERROR',['non monotonic dimension variable # ' num2str(idim)  ' in proj_field.m'])
-                                return
-                    end               
+                        return
+                    end
                     test_interp(idim)=(DCoord_max-DCoord_min(idim))> 0.0001*abs(DCoord_max);% test grid regularity
                 end
@@ -1321 +1328 @@
             DY=abs(DCoord_min(NbDim-1));
         end
-        npY=1+round(abs(Coord{NbDim-1}(end)-Coord{NbDim-1}(1))/DY);%nbre of points after interpol 
+        npY=1+round(abs(Coord{NbDim-1}(end)-Coord{NbDim-1}(1))/DY);%nbre of points after interpol
         if DX==0
             DX=abs(DCoord_min(NbDim));
         end
-        npX=1+round(abs(Coord{NbDim}(end)-Coord{NbDim}(1))/DX);%nbre of points after interpol 
+        npX=1+round(abs(Coord{NbDim}(end)-Coord{NbDim}(1))/DX);%nbre of points after interpol
         for idim=1:NbDim
             if test_interp(idim)
                 DimValue(idim)=1+round(abs(Coord{idim}(end)-Coord{idim}(1))/abs(DCoord_min(idim)));%nbre of points after possible interpolation on a regular gri
             end
-        end       
+        end
         Coord_y=linspace(Coord{NbDim-1}(1),Coord{NbDim-1}(end),npY);
         test_direct_y=test_direct(NbDim-1);
@@ -1336 +1343 @@
         test_direct_x=test_direct(NbDim);
         DAX=DCoord_min(NbDim);
-        DAY=DCoord_min(NbDim-1);  
+        DAY=DCoord_min(NbDim-1);
         minAX=min(Coord_x);
         maxAX=max(Coord_x);
@@ -1374 +1381 @@
         end
         npX=floor((XMax-XMin)/DX+1);
-        npY=floor((YMax-YMin)/DY+1);   
+        npY=floor((YMax-YMin)/DY+1);
         if test_direct_y
             coord_y_proj=linspace(YMin,YMax,npY);%abscissa of the new pixels along the line
@@ -1384 +1391 @@
         else
             coord_x_proj=linspace(XMax,XMin,npX);%abscissa of the new pixels along the line
-        end 
-        
+        end
         % case with no rotation and interpolation
         if isequal(ProjMode,'projection') && ~testangle
             if ~testXMin && ~testXMax && ~testYMin && ~testYMax && NbDim==2
-                ProjData=FieldData; 
+                ProjData=FieldData;
             else
                 indY=NbDim-1;
@@ -1402 +1408 @@
                     Ybound(2)=Coord{indY}(1)-DYinit*(max_indy-1);
                     Ybound(1)=Coord{indY}(1)-DYinit*(min_indy-1);
-                end   
+                end
                 if test_direct(NbDim)==1
                     min_indx=ceil((XMin-Coord{NbDim}(1))/DXinit)+1;
@@ -1412 +1418 @@
                     max_indx=floor((Coord{NbDim}(1)-XMin)/DXinit)+1;
                     Xbound(2)=Coord{NbDim}(1)+DXinit*(max_indx-1);
+                    
+                    
                     Xbound(1)=Coord{NbDim}(1)+DXinit*(min_indx-1);
-                end 
-                if NbDim==3
-                    DimCell(1)=[]; %suppress z variable
-                    DimValue(1)=[];
-                                        %structured coordinates
-                    if test_direct(1)
-                        iz=ceil((ObjectData.Coord(1,3)-Coord{1}(1))/DZ)+1;
-                    else
-                        iz=ceil((Coord{1}(1)-ObjectData.Coord(1,3))/DZ)+1;
-                    end
                 end
                 min_indy=max(min_indy,1);% deals with margin (bound lower than the first index)
                 min_indx=max(min_indx,1);
-                max_indy=min(max_indy,DimValue(1));
-                max_indx=min(max_indx,DimValue(2));
-                for ivar=VarIndex% loop on non coordinate variables
-                    VarName=FieldData.ListVarName{ivar}; 
-                    ProjData.ListVarName=[ProjData.ListVarName VarName];
-                    ProjData.VarDimName=[ProjData.VarDimName {DimCell}];
-                    if isfield(FieldData,'VarAttribute') && length(FieldData.VarAttribute)>=ivar
-                        ProjData.VarAttribute{length(ProjData.ListVarName)}=FieldData.VarAttribute{ivar};
-                    end
+
+                if test90y
+                    'TEST3D'
+                    ind_new=[3 2 1];
+                    DimCell=DimCell(ind_new);
+                    DimValue=DimValue(ind_new);
+                    DimCell(1)=[]; %suppress x variable
+                    DimValue(1)=[];
+                    iz=ceil((ObjectData.Coord(1,1)-Coord{3}(1))/DX)+1;
+                    for ivar=VarIndex
+                        VarName=FieldData.ListVarName{ivar};
+                        ProjData.ListVarName=[ProjData.ListVarName VarName];
+                        ProjData.VarDimName=[ProjData.VarDimName {DimCell}];
+                        ProjData.VarAttribute{length(ProjData.ListVarName)}=FieldData.VarAttribute{ivar}; %reproduce the variable attributes
+                        eval(['size(FieldData.' VarName ')'])
+                        eval(['ProjData.' VarName '=permute(FieldData.' VarName ',ind_new)'])% permute x and z indices for 90 degree rotation
+                        eval(['size(ProjData.' VarName ')'])
+                        eval(['ProjData.' VarName '=squeeze(FieldData.' VarName '(iz,:,:));'])% select the z index iz
+                    end
+                    eval(['ProjData.' AYName '=[Ybound(1) Ybound(2)];']) %record the new (projected ) y coordinates
+                    eval(['ProjData.' AXName '=[Coord{1}(end),Coord{1}(1)];']) %record the new (projected ) x coordinates
+                else
                     if NbDim==3
-                        eval(['ProjData.' VarName '=squeeze(FieldData.' VarName '(iz,min_indy:max_indy,min_indx:max_indx));']);
-                    else
-                        eval(['ProjData.' VarName '=FieldData.' VarName '(min_indy:max_indy,min_indx:max_indx,:);']);
-                    end
-                end  
-                eval(['ProjData.' AYName '=[Ybound(1) Ybound(2)];']) %record the new (projected ) y coordinates
-                eval(['ProjData.' AXName '=[Xbound(1) Xbound(2)];']) %record the new (projected ) x coordinates
+                        DimCell(1)=[]; %suppress z variable
+                        DimValue(1)=[];
+                        if test_direct(1)
+                            iz=ceil((ObjectData.Coord(1,3)-Coord{1}(1))/DZ)+1;
+                        else
+                            iz=ceil((Coord{1}(1)-ObjectData.Coord(1,3))/DZ)+1;
+                        end
+                    end
+                    max_indy=min(max_indy,DimValue(1));%introduce bounds in y and x indices
+                    max_indx=min(max_indx,DimValue(2));
+                    for ivar=VarIndex% loop on non coordinate variables
+                        VarName=FieldData.ListVarName{ivar};
+                        ProjData.ListVarName=[ProjData.ListVarName VarName];
+                        ProjData.VarDimName=[ProjData.VarDimName {DimCell}];
+                        if isfield(FieldData,'VarAttribute') && length(FieldData.VarAttribute)>=ivar
+                            ProjData.VarAttribute{length(ProjData.ListVarName)}=FieldData.VarAttribute{ivar};
+                        end
+                        if NbDim==3
+                            eval(['ProjData.' VarName '=squeeze(FieldData.' VarName '(iz,min_indy:max_indy,min_indx:max_indx));']);
+                        else
+                            eval(['ProjData.' VarName '=FieldData.' VarName '(min_indy:max_indy,min_indx:max_indx,:);']);
+                        end
+                    end
+                    eval(['ProjData.' AYName '=[Ybound(1) Ybound(2)];']) %record the new (projected ) y coordinates
+                    eval(['ProjData.' AXName '=[Xbound(1) Xbound(2)];']) %record the new (projected ) x coordinates
+                end
             end
         else       % case with rotation and/or interpolation
@@ -1453 +1483 @@
                 XIMA=reshape(round(XIMA),1,npX*npY);%indices reorganized in 'line'
                 YIMA=reshape(round(YIMA),1,npX*npY);
-                flagin=XIMA>=1 & XIMA<=DimValue(2) & YIMA >=1 & YIMA<=DimValue(1);%flagin=1 inside the original image 
+                flagin=XIMA>=1 & XIMA<=DimValue(2) & YIMA >=1 & YIMA<=DimValue(1);%flagin=1 inside the original image
                 if isequal(ObjectData.ProjMode,'filter')
                     npx_filter=ceil(abs(DX/DAX));
@@ -1466 +1496 @@
                 for ivar=VarIndex
                     VarName=FieldData.ListVarName{ivar};
-                    if test_interp(1) || test_interp(2)%interpolate on a regular grid        
-                          eval(['ProjData.' VarName '=interp2(Coord{2},Coord{1},FieldData.' VarName ',Coord_x,Coord_y'');']) %TO TEST
+                    if test_interp(1) || test_interp(2)%interpolate on a regular grid
+                        eval(['ProjData.' VarName '=interp2(Coord{2},Coord{1},FieldData.' VarName ',Coord_x,Coord_y'');']) %TO TEST
                     end
                     %filter the field (image) if option 'filter' is used
-                    if test_filter  
-                         Aclass=class(FieldData.A);
-                         eval(['ProjData.' VarName '=filter2(Mfilter,FieldData.' VarName ',''valid'');'])
-                         if ~isequal(Aclass,'double')
-                             eval(['ProjData.' VarName '=' Aclass '(FieldData.' VarName ');'])%revert to integer values
-                         end
-                    end
-                    eval(['vec_A=reshape(FieldData.' VarName ',[],nbcolor);'])%put the original image in line              
+                    if test_filter
+                        Aclass=class(FieldData.A);
+                        eval(['ProjData.' VarName '=filter2(Mfilter,FieldData.' VarName ',''valid'');'])
+                        if ~isequal(Aclass,'double')
+                            eval(['ProjData.' VarName '=' Aclass '(FieldData.' VarName ');'])%revert to integer values
+                        end
+                    end
+                    eval(['vec_A=reshape(FieldData.' VarName ',[],nbcolor);'])%put the original image in line
                     %ind_in=find(flagin);
                     ind_out=find(~flagin);
                     ICOMB=(XIMA-1)*DimValue(1)+YIMA;
                     ICOMB=ICOMB(flagin);%index corresponding to XIMA and YIMA in the aligned original image vec_A
-                    vec_B(flagin,1:nbcolor)=vec_A(ICOMB,:); 
+                    vec_B(flagin,1:nbcolor)=vec_A(ICOMB,:);
                     for icolor=1:nbcolor
                         vec_B(ind_out,icolor)=zeros(size(ind_out));
@@ -1490 +1520 @@
                     if isfield(FieldData,'VarAttribute')&&length(FieldData.VarAttribute)>=ivar
                         ProjData.VarAttribute{length(ProjData.ListVarName)+nbcoord}=FieldData.VarAttribute{ivar};
-                    end     
+                    end
                     eval(['ProjData.' VarName '=reshape(vec_B,npY,npX,nbcolor);']);
                 end
-                ProjData.FF=reshape(~flagin,npY,npX);%false flag A FAIRE: tenir compte d'un flga antérieur  
+                ProjData.FF=reshape(~flagin,npY,npX);%false flag A FAIRE: tenir compte d'un flga antérieur
                 ProjData.ListVarName=[ProjData.ListVarName 'FF'];
                 ProjData.VarDimName=[ProjData.VarDimName {DimCell}];
                 ProjData.VarAttribute{length(ProjData.ListVarName)}.Role='errorflag';
-            else %3D case
-                if ~testangle     
-                    % unstructured z coordinate
-                    test_sup=(Coord{1}>=ObjectData.Coord(1,3));
-                    iz_sup=find(test_sup);
-                    iz=iz_sup(1);
-                    if iz>=1 & iz<=npz
-                        %ProjData.ListDimName=[ProjData.ListDimName ListDimName(2:end)];
-                        %ProjData.DimValue=[ProjData.DimValue npY npX];
-                        for ivar=VarIndex
-                            VarName=FieldData.ListVarName{ivar}; 
-                            ProjData.ListVarName=[ProjData.ListVarName VarName];
-                            ProjData.VarAttribute{length(ProjData.ListVarName)}=FieldData.VarAttribute{ivar}; %reproduce the variable attributes  
-                            eval(['ProjData.' VarName '=squeeze(FieldData.' VarName '(iz,:,:));'])% select the z index iz
-                            %TODO : do a vertical average for a thick plane
-                            if test_interp(2) || test_interp(3)
-                                eval(['ProjData.' VarName '=interp2(Coord{3},Coord{2},ProjData.' VarName ',Coord_x,Coord_y'');']) 
-                            end
+            elseif ~testangle
+                % unstructured z coordinate
+                test_sup=(Coord{1}>=ObjectData.Coord(1,3));
+                iz_sup=find(test_sup);
+                iz=iz_sup(1);
+                if iz>=1 & iz<=npz
+                    %ProjData.ListDimName=[ProjData.ListDimName ListDimName(2:end)];
+                    %ProjData.DimValue=[ProjData.DimValue npY npX];
+                    for ivar=VarIndex
+                        VarName=FieldData.ListVarName{ivar};
+                        ProjData.ListVarName=[ProjData.ListVarName VarName];
+                        ProjData.VarAttribute{length(ProjData.ListVarName)}=FieldData.VarAttribute{ivar}; %reproduce the variable attributes
+                        eval(['ProjData.' VarName '=squeeze(FieldData.' VarName '(iz,:,:));'])% select the z index iz
+                        %TODO : do a vertical average for a thick plane
+                        if test_interp(2) || test_interp(3)
+                            eval(['ProjData.' VarName '=interp2(Coord{3},Coord{2},ProjData.' VarName ',Coord_x,Coord_y'');'])
                         end
                     end
-                else
-                    errormsg='projection of structured coordinates on oblique plane not yet implemented';
-                    %TODO: use interp3
-                    return
-                end
-            end
-        end
-    end
-
+                end
+            else
+                errormsg='projection of structured coordinates on oblique plane not yet implemented';
+                %TODO: use interp3
+                return
+            end
+        end
+    end
+    
     %% projection of  velocity components in the rotated coordinates
     if testangle && length(ivar_U)==1
@@ -1533 +1561 @@
         end
         UName=FieldData.ListVarName{ivar_U};
-        VName=FieldData.ListVarName{ivar_V};    
+        VName=FieldData.ListVarName{ivar_V};
         eval(['ProjData.' UName  '=cos(PlaneAngle(3))*ProjData.' UName '+ sin(PlaneAngle(3))*ProjData.' VName ';'])
         eval(['ProjData.' VName  '=cos(Theta)*(-sin(PlaneAngle(3))*ProjData.' UName '+ cos(PlaneAngle(3))*ProjData.' VName ');'])
         if ~isempty(ivar_W)
             WName=FieldData.ListVarName{ivar_W};
-            eval(['ProjData.' VName '=ProjData.' VName '+ ProjData.' WName '*sin(Theta);'])% 
+            eval(['ProjData.' VName '=ProjData.' VName '+ ProjData.' WName '*sin(Theta);'])%
             eval(['ProjData.' WName '=NormVec_X*ProjData.' UName '+ NormVec_Y*ProjData.' VName '+ NormVec_Z* ProjData.' WName ';']);
         end
@@ -1857 +1885 @@
         VarName=FieldData.ListVarName{VarIndex(1)};%get the first variable of the cell to get the input matrix dimensions
         eval(['DimValue=size(FieldData.' VarName ');'])%input matrix dimensions
-        DimValue(find(DimValue==1))=[];%remove singleton dimensions       
+        DimValue(DimValue==1)=[];%remove singleton dimensions       
         NbDim=numel(DimValue);%update number of space dimensions
         nbcolor=1; %default number of 'color' components: third matrix index without corresponding coordinate
@@ -1865 +1893 @@
                 return
             else
-                VarType.coord
                 if numel(find(VarType.coord))==2% the third matrix dimension does not correspond to a space coordinate
                     nbcolor=DimValue(3);

trunk/src/read_field.m

@@ -31 +31 @@
 ParamOut=[];
 errormsg='';
-%FieldName=ParamIn.FieldName;
 VelType=ParamIn.VelType;
 
@@ -42 +41 @@
     end
     test_civx=0;
-    if ~strcmp(ParamOut.FieldName,'get_field...')% if get_field is not requested, look for Civx data
+    ParamIn
+    if ~strcmp(ParamIn.FieldName,'get_field...')% if get_field is not requested, look for Civx data
         FieldList=calc_field;%list of possible fields for Civx data
         ParamOut.ColorVar='';%default
         field_index=strcmp(ParamOut.FieldName,FieldList);%look for ParamOut.FieldName in the list
         if isempty(find(field_index,1))% ParamOut.FieldName is not in the list, check whether Civx data exist
-            Data=nc2struct(ObjectName,'ListGlobalAttribute','absolut_time_T0','civ');
+            'TESTnc1'
+            Data=nc2struct(ObjectName,'ListGlobalAttribute','absolut_time_T0','civ')
             if ~isempty(Data.absolut_time_T0)&& ~isequal(Data.civ,0)
                 ParamOut.FieldName='velocity';%Civx data found, set .FieldName='velocity' by default
@@ -83 +84 @@
         set(hhget_field.inputfile,'String',ObjectName)
         set(hhget_field.list_fig,'Value',1)
+        if exist('num','var')&&~isnan(num)
+            set(hhget_field.TimeIndexValue,'String',num2str(num))
+        end
         funct_list=get(hhget_field.ACTION,'UserData');
         funct_index=get(hhget_field.ACTION,'Value');
@@ -107 +111 @@
             end
         end
-        set(hhget_field.attributes,'String',Tabchar);%update list of global attributes in get_field
+        %set(hhget_field.attributes,'String',Tabchar);%update list of global attributes in get_field
         ParamOut.CivStage=0;
         ParamOut.VelType=[];
+        if isfield(Field,'TimeIndex')
+            ParamOut.TimeIndex=Field.TimeIndex;
+        end
+        if isfield(Field,'TimeValue')
+            ParamOut.TimeValue=Field.TimeValue;
+        end
     end
     if test_civx
@@ -127 +137 @@
                 A=read(ObjectName,num);
                 FieldName='image';
-            catch
-                errormsg=lasterr;
+            catch ME
+                errormsg=ME.message;
                 return
             end
@@ -134 +144 @@
             try
                 mov=aviread(ObjectName,num);
-            catch
-                errormsg=lasterr;
+            catch ME
+                errormsg=ME.message;
                 return
             end

trunk/src/read_get_field.m

@@ -124 +124 @@
         return
     end
-    val=get(handles.scalar,'Value');%selected indices in the ordinate listbox
-    VarNameScalar=inputlist{val}; %name of the variable in the list
+    val=get(handles.scalar,'Value');%selected index for the scalar variable
+    VarNameScalar=inputlist{val}; %name of the variable
     VarIndexA=name2index(VarNameScalar,Field.ListVarName);%index of the variable in ListVarName
-    dimname_A=Field.VarDimName{VarIndexA};
+    dimname_A=Field.VarDimName{VarIndexA};% list of dimension names for the scalar variable (cell array)
+    %remove time dimension if defined
+    TimeVarIndex=[]; %default
+    if strcmp(get(handles.TimeDimensionMenu,'Visible'),'on')
+        dim_list=get(handles.TimeDimensionMenu,'String');
+        dim_index=get(handles.TimeDimensionMenu,'Value');
+        Time_dim=dim_list{dim_index};
+        TimeVarIndex=find(strcmp(Time_dim,dimname_A),1);
+        if ~isempty(TimeVarIndex)
+            dimname_A(TimeVarIndex)=[];
+        end
+    end
     nbvar=nbvar+1;
     ListVarName{nbvar}=Field.ListVarName{VarIndexA};
@@ -157 +168 @@
             if iscell(dimname_x)
                 if numel(dimname_x)==1
-                    dimname_x=dimname_x{1};%transform to char chain
+                    %dimname_x=dimname_x{1};%transform to char chain
+                elseif numel(dimname_x)==2
+                    index1_x = find(strcmp(dimname_x{1},dimname_A));%index of diname_x(1) in dimname_A
+                    index2_x = find(strcmp(dimname_x{2},dimname_A));%index of diname_x(2) in dimname_A
                 else
                     errormsg='invalid x coordinate selection in get_field';
@@ -190 +204 @@
                 if numel(dimname_y)==1
                     dimname_y=dimname_y{1};%transform to char chain
+                elseif numel(dimname_y)==2
+                    index1_y = find(strcmp(dimname_y{1},dimname_A));%index of diname_x(1) in dimname_A
+                    index2_y = find(strcmp(dimname_y{2},dimname_A));%index of diname_x(2) in dimname_A
                 else
                     errormsg='invalid y coordinate selection in get_field';
@@ -214 +231 @@
             nbvar=nbvar+1;
             ListVarName{nbvar}=Field.ListVarName{VarIndex};
-            VarDimName{nbvar}=dimname_y;
+            VarDimName{nbvar}=dimname_z;
             if numel(VarAttribute)>=VarIndex
                 SubVarAttribute{nbvar}=VarAttribute{VarIndex};
             end
             %check consistency of dimensions
-            if ~isequal(dimname_y,dimname_A)% case of dimension variables
-                if iscell(dimname_y)
-                    if numel(dimname_y)==1
-                        dimname_y=dimname_y{1};%transform to char chain
+            if ~isequal(dimname_z,dimname_A)% case of dimension variables
+                if iscell(dimname_z)
+                    if numel(dimname_z)==1
+                        dimname_z=dimname_z{1};%transform to char chain
                     else
-                        errormsg='invalid y coordinate selection in get_field';
+                        errormsg='invalid z coordinate selection in get_field';
                         return
                     end
@@ -432 +449 @@
     end
 end 
+
+
+
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-
-% get the input field
+%% get the input field
 inputfield=get(handles.inputfile,'String');
 if exist(inputfield,'file')% read the input data corresponding to the list of selected varaibles
@@ -443 +462 @@
     SubField.VarDimName=VarDimName;
 end
-SubField.ListGlobalAttribute=['InputFile' SubField.ListGlobalAttribute];
+if strcmp(get(handles.TimeIndexValue,'Visible'),'on') && ~isempty(get(handles.TimeIndexValue,'String'))
+    SubField.ListGlobalAttribute=[{'TimeIndex'} SubField.ListGlobalAttribute];
+    SubField.TimeIndex=str2double(get(handles.TimeIndexValue,'String'));  
+end
+TimeValue=NaN;
+if strcmp(get(handles.TimeVarValue,'Visible'),'on') 
+    TimeValue=str2double(get(handles.TimeVarValue,'String'));
+elseif strcmp(get(handles.TimeValue,'Visible'),'on') 
+    TimeValue=str2double(get(handles.TimeValue,'String'));
+end
+if ~isnan(TimeValue)   
+    SubField.ListGlobalAttribute=[{'TimeValue'} SubField.ListGlobalAttribute];
+    SubField.TimeValue=str2double(get(handles.TimeVarValue,'String'));  
+end
+SubField.ListGlobalAttribute=[{'InputFile'} SubField.ListGlobalAttribute];
 SubField.InputFile=get(handles.inputfile,'String');
 SubField.VarAttribute=SubVarAttribute;
@@ -453 +486 @@
     DimCellA=Field.VarDimName{VarIndexA};  %dimension names for the scalar variable
     eval(['npxy=size(SubField.' VarNameA ');'])%zize of the scalar variable
+%     if ~isempty(TimeVarIndex)% 
+%         DimCellA(TimeVarIndex)=[];%suppress the time dimension
+%         npxy(TimeVarIndex)=[];
+%     end
     SingleCellA={};
     if numel(npxy) < numel(DimCellA)
@@ -461 +498 @@
     DimCellA=DimCellA(ind_select);%dimension names for the scalar variable, after removing singletons
     npxy=npxy(ind_select);
+%     if ~isempty(TimeVarIndex)% 
+%         DimCellA(TimeVarIndex)=[];%suppress the time dimension
+%          npxy(TimeVarIndex)=[];
+%     end
+    NbDim=numel(npxy);
     dimA=[];
-    if test_zdimvar%dim_x && dim_y && ~isempty(VarSubIndexA)
+    if test_zdimvar
         NbDim=3;% field considered as 3D if a z coordinate is defined (to distinguish for instance from 2D color images with 3 components)
         ind_singleton=find(strcmp(dimname_z,SingleCellA),1);% look for coincidence of dimension with one of the singleton dimensions
@@ -472 +514 @@
         dimA=[dimA icoord];
     end
-    if test_ydimvar%dim_x && dim_y && ~isempty(VarSubIndexA)
+    if test_ydimvar
         ind_singleton=find(strcmp(dimname_y,SingleCellA),1);% look for coincidence of dimension with one of the singleton dimensions
         if ~isempty(ind_singleton)
@@ -481 +523 @@
         dimA=[dimA icoord];
     end
-    if test_xdimvar
-        ind_singleton=find(strcmp(dimname_x,SingleCellA),1);% look for coincidence of dimension with one of the singleton dimensions
-        if ~isempty(ind_singleton)
+    if test_xdimvar% a varible has been selected for x coordinate
+        ind_singleton=find(strcmp(dimname_x{1},SingleCellA),1);% look for coincidence of dimension with one of the singleton dimensions
+        if ~isempty(ind_singleton)         
              errormsg=['the singleton dimension ' dimname_x ' has been selected for ordinate'];
              return
         end
-        icoord=find(strcmp(dimname_x,DimCellA),1);% a dimension variable
+        icoord=find(strcmp(dimname_x{1},DimCellA),1);% a dimension variable
         dimA=[dimA icoord];
     end
-    dimextra=(1:numel(DimCellA));
-    dimextra(dimA)=[]; %list of unselected dimension indices
+    dimextra=(1:numel(DimCellA)); %list of initial dimension indices
+    if isempty(TimeVarIndex)% 
+        dimextra(dimA)=[]; %list of unselected dimension indices
+        DimCellA=DimCellA([dimA dimextra]);
+        eval(['SubField.' VarNameA '=squeeze(SubField.' VarNameA ');'])
+        if ~isempty(dimA)&& ~isempty(dimextra)
+        eval(['SubField.' VarNameA '=permute(SubField.' VarNameA ',[dimA dimextra]);'])
+        end
+    else
+        time_index=str2double(get(handles.TimeIndexValue,'String'));
+        dimextra([dimA TimeVarIndex])=[];
+        %DimCellA=DimCellA([dimA dimextra TimeVarIndex])%put the time dimension at the end 
+        eval(['SubField.' VarNameA '=permute(squeeze(SubField.' VarNameA '),[dimA dimextra TimeVarIndex]);'])%put time variable as the last dimension
+        nbdimA=numel(dimA)+numel(dimextra);
+        switch nbdimA
+            case 1
+                colon_str='(:';
+            case 2
+                colon_str='(:,:';
+            case 3
+                colon_str='(:,:,:';
+        end
+        eval(['SubField.' VarNameA '=SubField.' VarNameA  colon_str ',time_index);'])
+        NbDim=NbDim-1;
+    end
     DimCellA=DimCellA([dimA dimextra]);
-    eval(['SubField.' VarNameA '=permute(squeeze(SubField.' VarNameA '),[dimA dimextra]);'])
     SubField.VarDimName{VarSubIndexA}=DimCellA;  
     %add default coord_x and/or coord_y if empty
     if empty_coord_x || empty_coord_y
-        VarName=Field.ListVarName{field_var_index};
-        DimCell=Field.VarDimName{field_var_index};    
-        eval(['npxy=size(SubField.' VarName ');'])
-        if numel(npxy) < numel(DimCell)
-            DimCell=DimCell(end-numel(npxy)+1:end); %suppress the first singletons) dimensions 
+        %VarName=Field.ListVarName{field_var_index}
+        %DimCell=Field.VarDimName{field_var_index}    
+        eval(['npxy=size(SubField.' VarNameA ')'])
+        if numel(npxy) < numel(DimCellA)
+            DimCellA=DimCellA(end-numel(npxy)+1:end); %suppress the first singletons) dimensions 
         end
         ind_select=find(npxy~=1) ;%look for non singleton dimensions
-        DimCell=DimCell(ind_select);%list of dimension names for the scalar, after singleton removal
+        DimCellA=DimCellA(ind_select);%list of dimension names for the scalar, after singleton removal
         npxy=npxy(ind_select);
         testold=0;
@@ -516 +580 @@
         end
         if empty_coord_x        
-                coord_x_name=DimCell{NbDim};
+                coord_x_name=DimCellA{NbDim};
                 SubField.ListVarName=[{coord_x_name} SubField.ListVarName];
                 SubField.VarDimName=[{coord_x_name} SubField.VarDimName];  
@@ -533 +597 @@
         end
         if empty_coord_y 
-            coord_y_name=DimCell{NbDim-1};
+            coord_y_name=DimCellA{NbDim-1};
             SubField.ListVarName=[{coord_y_name} SubField.ListVarName];
             SubField.VarDimName=[{coord_y_name} SubField.VarDimName];
@@ -547 +611 @@
             end
             SubField.VarAttribute=[{coord_y_attr} SubField.VarAttribute];       
+        end
+        if empty_coord_z && NbDim==3
+            coord_z_name=DimCellA{NbDim-2};
+            SubField.ListVarName=[{coord_z_name} SubField.ListVarName];
+            SubField.VarDimName=[{coord_z_name} SubField.VarDimName];
+            if testold
+                eval(['SubField.' coord_z_name '=linspace(Coord_3(1),Coord_3(end),npxy(1));']) 
+            else
+                eval(['SubField.' coord_z_name '=[0.5 npxy(NbDim-2)-0.5];'])
+            end
+            if ~testold
+                coord_z_attr.units='index';
+            else
+                coord_z_attr.units='cm';
+            end
+            SubField.VarAttribute=[{coord_z_attr} SubField.VarAttribute];   
         end
     end
@@ -714 +794 @@
 end
 
+%% remove time variable
+if get(handles.TimeDimension,'Value')
+
+%     TimeName=get(handles.TimeName,'String');
+%     time_index=find(strcmp(TimeName,SubField.ListVarName),1);
+%     SubField.ListVarName(TimeVarIndex)=[];
+%     SubField.VarDimName(TimeVarIndex)=[];
+%     SubField.VarAttribute(TimeVarIndex)=[];
+end
+
+
 %-------------------------------------------------
 % give index numbers of the strings str in the list ListvarName

trunk/src/set_object.m

@@ -766 +766 @@
 
 %% plot the field projected on the object and store in the corresponding figue
-ProjData= proj_field(UvData.Field,ObjectData);%project the current interface field on ObjectData
+[ProjData,errormsg]= proj_field(UvData.Field,ObjectData);%project the current interface field on ObjectData
+if ~isempty(errormsg)
+    msgbox_uvmat('ERROR', errormsg)
+    return
+end
 PlotParam=read_plot_param(PlotHandles);
 [PlotType,Object_out{IndexObj}.PlotParam,plotaxes]=plot_field(ProjData,plotaxes,PlotParam);%update an existing field plot
@@ -846 +850 @@
 end
 msgbox_uvmat('CONFIRMATION',[answer{1}  ' saved'])
-%------------------------------------------------------------------------
+
 %------------------------------------------------------------------------
 % --- Executes on slider movement.
@@ -853 +857 @@
 Z_value=get(handles.z_slider,'Value');
 %rotation angles
-PlaneAngle(1)=str2num(get(handles.Phi,'String'));%first  angle in degrees
-PlaneAngle(2)=str2num(get(handles.Theta,'String'));%second  angle in degrees
-PlaneAngle(3)=str2num(get(handles.Psi,'String'));%second  angle in degrees
+PlaneAngle=[0 0 0]; 
+norm_plane=[0 0 1];
+cos_om=1;
+sin_om=0;
+
+PlaneAngle(1)=str2double(get(handles.Phi,'String'));%first  angle in degrees
+PlaneAngle(2)=str2double(get(handles.Theta,'String'));%second  angle in degrees
+PlaneAngle(3)=str2double(get(handles.Psi,'String'));%second  angle in degrees
+PlaneAngle=(pi/180)*PlaneAngle;
 om=norm(PlaneAngle);%norm of rotation angle in radians
-OmAxis=PlaneAngle/om; %unit vector marking the rotation axis
-cos_om=cos(pi*om/180);
-sin_om=sin(pi*om/180);
-coeff=OmAxis(3)*(1-cos_om);
-%components of the unity vector norm_plane normal to the projection plane
-norm_plane(1)=OmAxis(1)*coeff+OmAxis(2)*sin_om;
-norm_plane(2)=OmAxis(2)*coeff-OmAxis(1)*sin_om;
-norm_plane(3)=OmAxis(3)*coeff+cos_om;
+if isequal(om,0)
+    norm_plane=[0 0 1];
+else
+    OmAxis=PlaneAngle/om; %unit vector marking the rotation axis
+    cos_om=cos(om);
+    sin_om=sin(om);
+    coeff=OmAxis(3)*(1-cos_om);
+    %components of the unity vector norm_plane normal to the projection plane
+    norm_plane(1)=OmAxis(1)*coeff+OmAxis(2)*sin_om;
+    norm_plane(2)=OmAxis(2)*coeff-OmAxis(1)*sin_om;
+    norm_plane(3)=OmAxis(3)*coeff+cos_om;
+end
 
 %set new plane position and update graph
@@ -871 +885 @@
 set(handles.ZObject,'String',num2str(norm_plane(3)*Z_value,4))
 PLOT_Callback(hObject, eventdata, handles)
-%------------------------------------------------------------------------
+
 %------------------------------------------------------------------------
 % --- Executes on button press in HELP.
 function HELP_Callback(hObject, eventdata, handles)
+%------------------------------------------------------------------------
 path_to_uvmat=which ('uvmat');% check the path of uvmat
 pathelp=fileparts(path_to_uvmat);

trunk/src/uvmat.m

@@ -232 +232 @@
 
 %% refresh projection plane
-%UvData.Object{1}.Style='plane';%main plotting plane
 UvData.Object{1}.ProjMode='projection';%main plotting plane
-% if ~isfield(UvData.Object{1},'plotaxes')
-%     UvData.Object{1}.plotaxes=handles.axes3;%default plotting axis
-%     set(handles.list_object_1,'Value',1);
-%    % set(handles.list_object_1,'String',{'1-PLANE'});
-%    set(handles.list_object_1,'String',{''});
-% end
 set(handles.Fields,'Value',1)
 set(handles.Fields,'string',{''})
@@ -331 +324 @@
             inputfile=input.InputFile;
         end
-        Field=input;
+        if isfield(Field,'TimeIndex')
+            set(handles.i1,num2str(Field.TimeIndex))
+        end
     elseif ischar(input)% file name introduced as input
            inputfile=input;
@@ -347 +342 @@
     end
     if ~isempty(inputfile)
-        %%%%% display the indput field %%%%%%%
+        %%%%% display the input field %%%%%%%
         display_file_name(hObject, eventdata, handles,inputfile)
         %%%%%%%
@@ -366 +361 @@
    end
 end
-% set(handles.uvmat,'UserData',UvData)
 
 %% plot input field if exists
@@ -437 +431 @@
         '*.*',  'All Files (*.*)'}, ...
         'Pick a file',oldfile);
-%global filebase
 fileinput=[PathName FileName];%complete file name 
-% testblank=findstr(fileinput,' ');%look for blanks
-% if ~isempty(testblank)
-%     msgbox_uvmat('ERROR',['The input file name ' fileinput ' contains blank character : This is not allowed. Please change name'])
-%     return
-% end
 sizf=size(fileinput);
 if (~ischar(fileinput)||~isequal(sizf(1),1)),return;end
@@ -484 +472 @@
 % --- Open again the file whose name has been recorded in MenuFile_1
 function MenuFile_1_Callback(hObject, eventdata, handles)
+%------------------------------------------------------------------------
 fileinput=get(handles.MenuFile_1,'Label');
 display_file_name(hObject, eventdata, handles,fileinput)
@@ -490 +479 @@
 % --- Open again the file whose name has been recorded in MenuFile_2
 function MenuFile_2_Callback(hObject, eventdata, handles)
+%------------------------------------------------------------------------
 fileinput=get(handles.MenuFile_2,'Label');
 display_file_name(hObject, eventdata, handles,fileinput)
@@ -496 +486 @@
 % --- Open again the file whose name has been recorded in MenuFile_3
 function MenuFile_3_Callback(hObject, eventdata, handles)
+%------------------------------------------------------------------------
 fileinput=get(handles.MenuFile_3,'Label');
 display_file_name(hObject, eventdata, handles,fileinput)
@@ -502 +493 @@
 % --- Open again the file whose name has been recorded in MenuFile_4
 function MenuFile_4_Callback(hObject, eventdata, handles)
+%------------------------------------------------------------------------
 fileinput=get(handles.MenuFile_4,'Label');
 display_file_name(hObject, eventdata, handles,fileinput)
@@ -508 +500 @@
 % --- Open again the file whose name has been recorded in MenuFile_5
 function MenuFile_5_Callback(hObject, eventdata, handles)
+%------------------------------------------------------------------------
 fileinput=get(handles.MenuFile_5,'Label');
 display_file_name(hObject, eventdata, handles,fileinput)
@@ -514 +507 @@
 % --- Fills the edit boxes RootPath, RootFile,NomType...from an input file name 'fileinput'
 function display_file_name(hObject, eventdata, handles,fileinput)
+%------------------------------------------------------------------------
 if ~exist(fileinput,'file')
     msgbox_uvmat('ERROR',['input file ' fileinput  ' does not exist'])
@@ -871 +865 @@
 % set default options in menu 'Fields'
 
-if testima
-elseif isequal(FileExt,'.nc')||isequal(FileExt,'.cdf')
-   Data=nc2struct(FileName,'ListGlobalAttribute','absolut_time_T0','civ');
-   %col_vec=get(handles.col_vec,'String');
-   if ~isempty(Data.absolut_time_T0)&& ~isequal(Data.civ,0)%if the new input is Civx
-       FieldList=calc_field;
-       set(handles.Fields,'String',[{'image'};FieldList;{'get_field...'}]);%standard menu for civx data
-       set(handles.Fields,'Value',2) % set menu to 'velocity'
-       col_vec=FieldList;
-       col_vec(1)=[];%remove 'velocity' option for vector color (must be a scalar)
-   else %general netcdf file (not civx)
-       set(handles.Fields,'Value',1) % set menu to 'get_field...
-       set(handles.Fields,'String',{'get_field...'})
-       col_vec={'get_field...'};
-       hget_field=findobj('Name','get_field');
-       if ~isempty(hget_field)%delete any existing get_field GUI for reinitialisation withthe new file series
-           hhget_field=guidata(hget_field);
-           if ~strcmp(get(hhget_field.inputfile,'String'),FileName)%delete any existing get_field GUI with file name different than the input
-                delete(hget_field)
-           end
-       end
-   end
-   set(handles.col_vec,'String',col_vec)
-else
-    msgbox_uvmat('ERROR',['invalid input file extension ' FileExt])
-    return
-end  
+if ~testima
+    testcivx=0;
+    hget_field=findobj('Name','get_field');
+%     if isequal(FileExt,'.nc')||isequal(FileExt,'.cdf')
+    if isempty(hget_field)
+        Data=nc2struct(FileName,'ListGlobalAttribute','absolut_time_T0','civ');
+        if ~isempty(Data.absolut_time_T0)&& ~isequal(Data.civ,0)%if the new input is Civx
+            FieldList=calc_field;
+            set(handles.Fields,'String',[{'image'};FieldList;{'get_field...'}]);%standard menu for civx data
+            set(handles.Fields,'Value',2) % set menu to 'velocity'
+            col_vec=FieldList;
+            col_vec(1)=[];%remove 'velocity' option for vector color (must be a scalar)
+            testcivx=1;
+        end 
+    else
+         hhget_field=guidata(hget_field);
+        if ~strcmp(get(hhget_field.inputfile,'String'),FileName)%delete any existing get_field GUI with file name different than the input
+            delete(hget_field)
+        end
+    end
+    if ~testcivx
+            set(handles.Fields,'Value',1) % set menu to 'get_field...
+            set(handles.Fields,'String',{'get_field...'})
+            col_vec={'get_field...'}; 
+    end       
+    set(handles.col_vec,'String',col_vec)
+%     else
+%         msgbox_uvmat('ERROR',['invalid input file extension ' FileExt])
+%         return
+%     end
+end
 
 %% set index navigation options and refresh plots
@@ -1391 +1389 @@
     set(handles.scan_i,'Value',0)
     set(handles.scan_i,'BackgroundColor',[0.831 0.816 0.784])
-    NomType=get(handles.FileIndex,'UserData')
+    NomType=get(handles.FileIndex,'UserData');
     switch NomType
     case {'_i_j1-j2','#_ab','%3dab'},% pair with j index
@@ -2047 +2045 @@
 num_j1=stra2num(get(handles.j1,'String'));
 num_j2=stra2num(get(handles.j2,'String'));
+
 errormsg=refresh_field(handles,filename,filename_1,num_i1,num_i2,num_j1,num_j2);
+
 if ~isempty(errormsg)
       msgbox_uvmat('ERROR',errormsg);
@@ -2167 +2167 @@
         set(handles.npx,'String',num2str(ParamOut.Npx));% display image size on the interface
         set(handles.npy,'String',num2str(ParamOut.Npy));
+    end
+    if isfield(ParamOut,'TimeIndex')
+        set(handles.i1,'String',num2str(ParamOut.TimeIndex))
+    end
+    if isfield(ParamOut,'TimeValue')
+        Field{1}.Time=ParamOut.TimeValue;
     end
 end
@@ -2434 +2440 @@
 end
 if exist('XName','var')
-    eval(['XMax=max(UvData.Field.' XName ');'])
-    eval(['XMin=min(UvData.Field.' XName ');'])
+    eval(['XMax=max(max(UvData.Field.' XName '));'])
+    eval(['XMin=min(min(UvData.Field.' XName '));'])
     UvData.Field.NbDim=NbDim;
     UvData.Field.XMax=XMax;
     UvData.Field.XMin=XMin;
     if NbDim >1
-        eval(['YMax=max(UvData.Field.' YName ');'])
-        eval(['YMin=min(UvData.Field.' YName ');'])
+        eval(['YMax=max(max(UvData.Field.' YName '));'])
+        eval(['YMin=min(min(UvData.Field.' YName '));'])
         UvData.Field.YMax=YMax;
         UvData.Field.YMin=YMin;
@@ -3256 +3262 @@
     % transform netc type to the corresponding image type
 %     set(handles.FileExt_1,'String','.png');
-    if isequal(NomType_1,'_i1-i2_j')|isequal(NomType_1,'_i_j1-j2')| isequal(NomType_1,'#_ab')| isequal(NomType_1,'_i1-i2')
+    if isequal(NomType_1,'_i1-i2_j')||isequal(NomType_1,'_i_j1-j2')|| isequal(NomType_1,'#_ab')|| isequal(NomType_1,'_i1-i2')
         UvData.SubDir_1=get(handles.SubDir_1,'String'); %preserve the subdir in memory
 %         set(handles.SubDir_1,'String','')
 %         set(handles.FileExt_1,'String','.png');        
-        if isequal(NomType_1,'_i1-i2_j')|isequal(NomType_1,'_i_j1-j2')
+        if isequal(NomType_1,'_i1-i2_j')||isequal(NomType_1,'_i_j1-j2')
             NomTypeNew='_i_j';
         elseif isequal(NomType_1,'#_ab')
@@ -4079 +4085 @@
 set(handles.FixScal,'Value',1) %suppress auto mode
 set(handles.FixScal,'BackgroundColor',[1 1 0])
+MinA=str2double(get(handles.MinA,'String'));
+MaxA=str2double(get(handles.MaxA,'String'));
+if MinA>MaxA% switch minA and maxA in case of error
+    MinA_old=MinA;
+    MinA=MaxA;
+    MaxA=MinA_old;
+    set(handles.MinA,'String',num2str(MinA,5));
+    set(handles.MaxA,'String',num2str(MaxA,5));
+end
 update_plot(handles);
 
@@ -4086 +4101 @@
 set(handles.FixScal,'Value',1) %suppress auto mode
 set(handles.FixScal,'BackgroundColor',[1 1 0])
+MinA=str2double(get(handles.MinA,'String'));
+MaxA=str2double(get(handles.MaxA,'String'));
+if MinA>MaxA% switch minA and maxA in case of error
+        MinA_old=MinA;
+    MinA=MaxA;
+    MaxA=MinA_old;
+    set(handles.MinA,'String',num2str(MinA,5));
+    set(handles.MaxA,'String',num2str(MaxA,5));
+end
 update_plot(handles);