Index: /trunk/src/concentration.m
===================================================================
--- /trunk/src/concentration.m	(revision 781)
+++ /trunk/src/concentration.m	(revision 782)
@@ -49,11 +49,11 @@
 Ref.Aref(ind_bad)=D(ind_bad);
 DataOut_1=[];
-AX=DataOut.AX;
-AY=DataOut.AY;
+Coord_x=DataOut.Coord_x;
+Coord_y=DataOut.Coord_y;
 
-dX=(AX(2)-AX(1))/(npx-1);
-dY=(AY(1)-AY(2))/(npy-1);%mesh of new pixels
-[R,Y]=meshgrid(linspace(AX(1),AX(2),npx),linspace(AY(1),AY(2),npy));
-r=AX(1)+[0:npx-1]*dX;%distance from laser
+dX=(Coord_x(2)-Coord_x(1))/(npx-1);
+dY=(Coord_y(1)-Coord_y(2))/(npy-1);%mesh of new pixels
+[R,Y]=meshgrid(linspace(Coord_x(1),Coord_x(2),npx),linspace(Coord_y(1),Coord_y(2),npy));
+r=Coord_x(1)+[0:npx-1]*dX;%distance from laser
 %A(ind_good)=(A(ind_good)>=0).*A(ind_good); %replaces negative values  by zeros
 A=A./Ref.Aref;% luminosity normalised by the reference (value at the edge of the box)
@@ -71,5 +71,5 @@
 Edge_ind=find((abs(R-r_edge)/dX)<=1 & DataMask.A~=0);%indies of positions close to r_edge, values greater than 1 are not expected
 yedge=min(min(Y(Edge_ind)));
-jmax=round(-(yedge-AY(1))/dY+1);
+jmax=round(-(yedge-Coord_y(1))/dY+1);
 DataMask.A(jmax:end,:)=0;
 
@@ -77,5 +77,5 @@
 
 % radius along the reference line
-Theta=(linspace(AY(1),AY(2),npy)*pi/180)'*ones(1,npx);%theta in radians
+Theta=(linspace(Coord_y(1),Coord_y(2),npy)*pi/180)'*ones(1,npx);%theta in radians
 
 gamma_coeff=Ref.GammaCoeff*ones(1,npx);
@@ -91,9 +91,9 @@
 
 DataOut=polar2phys(DataOut,RangeX,RangeY);
-DataOut.AX=DataOut.AX+XmlData.GeometryCalib.PolarCentre(1);
-DataOut.AY=DataOut.AY+XmlData.GeometryCalib.PolarCentre(2);
+DataOut.Coord_x=DataOut.Coord_x+XmlData.GeometryCalib.PolarCentre(1);
+DataOut.Coord_y=DataOut.Coord_y+XmlData.GeometryCalib.PolarCentre(2);
 DataMask=polar2phys(DataMask,RangeX,RangeY);
-DataMask.AX=DataMask.AX+XmlData.GeometryCalib.PolarCentre(1);
-DataMask.AY=DataMask.AY+XmlData.GeometryCalib.PolarCentre(2);
+DataMask.Coord_x=DataMask.Coord_x+XmlData.GeometryCalib.PolarCentre(1);
+DataMask.Coord_y=DataMask.Coord_y+XmlData.GeometryCalib.PolarCentre(2);
 
 
@@ -102,8 +102,8 @@
 DataOut=DataIn; %fdefault
 [npy,npx]=size(DataIn.A);
-dx=(DataIn.AX(2)-DataIn.AX(1))/(npx-1); 
-dy=(DataIn.AY(2)-DataIn.AY(1))/(npy-1);%mesh
-rcorner=[DataIn.AX(1) DataIn.AX(2) DataIn.AX(1) DataIn.AX(2)];% radius of the corners
-ycorner=[DataIn.AY(2) DataIn.AY(2) DataIn.AY(1) DataIn.AY(1)];% azimuth of the corners
+dx=(DataIn.Coord_x(2)-DataIn.Coord_x(1))/(npx-1); 
+dy=(DataIn.Coord_y(2)-DataIn.Coord_y(1))/(npy-1);%mesh
+rcorner=[DataIn.Coord_x(1) DataIn.Coord_x(2) DataIn.Coord_x(1) DataIn.Coord_x(2)];% radius of the corners
+ycorner=[DataIn.Coord_y(2) DataIn.Coord_y(2) DataIn.Coord_y(1) DataIn.Coord_y(1)];% azimuth of the corners
 thetacorner=pi*ycorner/180;% azimuth in radians
 [Xcorner,Ycorner] = pol2cart(thetacorner,rcorner);% cartesian coordinates of the corners (with respect to lser source)
@@ -126,7 +126,7 @@
 [Theta,R] = cart2pol(X,Y);%corresponding polar coordiantes
 Theta=Theta*180/pi;
-%Theta=1+round((Theta-DataIn.AY(1))/dy); %index along y (dy negative)
-Theta=1-round((Theta-DataIn.AY(2))/dy); %index along y (dy negative)
-R=1+round((R-DataIn.AX(1))/dx); %index along x 
+%Theta=1+round((Theta-DataIn.Coord_y(1))/dy); %index along y (dy negative)
+Theta=1-round((Theta-DataIn.Coord_y(2))/dy); %index along y (dy negative)
+R=1+round((R-DataIn.Coord_x(1))/dx); %index along x 
 R=reshape(R,1,npx*npy);%indices reorganized in 'line'
 Theta=reshape(Theta,1,npx*npy);
@@ -142,5 +142,5 @@
 
      %Rangx=Rangx-radius_ref;
-DataOut.AX=RangeX;
-DataOut.AY=RangeY;  
+DataOut.Coord_x=RangeX;
+DataOut.Coord_y=RangeY;  
 
Index: /trunk/src/geometry_calib.m
===================================================================
--- /trunk/src/geometry_calib.m	(revision 781)
+++ /trunk/src/geometry_calib.m	(revision 782)
@@ -916,12 +916,12 @@
 path_UVMAT=fileparts(path_uvmat); %path to UVMAT
 addpath(fullfile(path_UVMAT,'transform_field'))
-Data.ListVarName={'AY','AX','A'};
-Data.VarDimName={'AY','AX',{'AY','AX'}};
+Data.ListVarName={'Coord_y','Coord_x','A'};
+Data.VarDimName={'Coord_y','Coord_x',{'Coord_y','Coord_x'}};
 if ndims(A)==3
     A=mean(A,3);
 end
 Data.A=A-min(min(A));
-Data.AY=[npxy(1)-0.5 0.5];
-Data.AX=[0.5 npxy(2)];
+Data.Coord_y=[npxy(1)-0.5 0.5];
+Data.Coord_x=[0.5 npxy(2)];
 Data.CoordUnit='pixel';
 Calib.GeometryCalib=GeometryCalib;
@@ -929,6 +929,6 @@
 rmpath(fullfile(path_UVMAT,'transform_field'))
 Amod=DataOut.A;% current image expressed in 'phys' coord
-Rangx=DataOut.AX;% x coordinates of first and last pixel centres in phys 
-Rangy=DataOut.AY;% y coordinates of first and last pixel centres in phys 
+Rangx=DataOut.Coord_x;% x coordinates of first and last pixel centres in phys 
+Rangy=DataOut.Coord_y;% y coordinates of first and last pixel centres in phys 
 if CalibData.grid.CheckWhite
     Amod=double(Amod);%case of white grid markers: will look for image maxima
Index: /trunk/src/mask_proj.m
===================================================================
--- /trunk/src/mask_proj.m	(revision 781)
+++ /trunk/src/mask_proj.m	(revision 782)
@@ -54,8 +54,8 @@
                 XName=FieldData.ListVarName{CellInfo{icell}.Coord_x};
                 YName=FieldData.ListVarName{CellInfo{icell}.Coord_y};
-                DX=(MaskData.AX(2)-MaskData.AX(1))/(Npx-1);
-                DY=(MaskData.AY(2)-MaskData.AY(1))/(Npy-1);
-                mask_ind_i=round(0.5+(FieldData.(XName)-MaskData.AX(1))/DX);%nbpoint terms
-                mask_ind_j=round(0.5+(FieldData.(YName)-MaskData.AY(1))/DY);%nbpoint terms
+                DX=(MaskData.Coord_x(2)-MaskData.Coord_x(1))/(Npx-1);
+                DY=(MaskData.Coord_y(2)-MaskData.Coord_y(1))/(Npy-1);
+                mask_ind_i=round(0.5+(FieldData.(XName)-MaskData.Coord_x(1))/DX);%nbpoint terms
+                mask_ind_j=round(0.5+(FieldData.(YName)-MaskData.Coord_y(1))/DY);%nbpoint terms
                 checkin=mask_ind_j+Npy*(mask_ind_i-1);%array  of mask indices for the nbpoints
                 checkin=checkin(mask_ind_i>=1 & mask_ind_i<=Npx & mask_ind_j>=1 & mask_ind_j<=Npy);%reduced array  of mask indices (inside the image)
@@ -79,6 +79,6 @@
                 XArray=linspace(FieldData.(XName)(1),FieldData.(XName)(end),Npx_field);
                 YArray=linspace(FieldData.(YName)(1),FieldData.(YName)(end),Npy_field);
-                XMask=linspace(MaskData.AX(1),MaskData.AX(end),Npx);
-                YMask=linspace(MaskData.AY(1),MaskData.AY(end),Npy);
+                XMask=linspace(MaskData.Coord_x(1),MaskData.Coord_x(end),Npx);
+                YMask=linspace(MaskData.Coord_y(1),MaskData.Coord_y(end),Npy);
                 [XMask,YMask]=meshgrid(XMask,YMask);
                 Mask = interp2(XMask,YMask,MaskData.A,XArray,YArray','nearest');
Index: /trunk/src/plot_field.m
===================================================================
--- /trunk/src/plot_field.m	(revision 781)
+++ /trunk/src/plot_field.m	(revision 782)
@@ -694,7 +694,7 @@
             XName=Data.ListVarName{ivar_X};
             YName=Data.ListVarName{ivar_Y};
-            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
+            eval(['Coord_x=reshape(Data.' XName ',1,[]);'])
+            eval(['Coord_y=reshape(Data.' YName ',1,[]);'])
+            [A,Coord_x,Coord_y]=proj_grid(Coord_x',Coord_y',A',[],[],'np>256');  % interpolate on a grid
             if isfield(Data,'VarAttribute')
                 if numel(Data.VarAttribute)>=ivar_X && isfield(Data.VarAttribute{ivar_X},'units')
@@ -707,6 +707,6 @@
         elseif strcmp(CellInfo{icell}.CoordType,'grid')%2D field with structured coordinates
             YName=Data.ListVarName{CellInfo{icell}.CoordIndex(end-1)};
-            AY=Data.(YName);
-            AX=Data.(Data.ListVarName{CellInfo{icell}.CoordIndex(end)});
+            Coord_y=Data.(YName);
+            Coord_x=Data.(Data.ListVarName{CellInfo{icell}.CoordIndex(end)});
             test_interp_X=0; %default, regularly meshed X coordinate
             test_interp_Y=0; %default, regularly meshed Y coordinate
@@ -719,46 +719,46 @@
                 end
             end
-            if numel(AY)>2
-                DAY=diff(AY);
-                DAY_min=min(DAY);
-                DAY_max=max(DAY);
-                if sign(DAY_min)~=sign(DAY_max);% =1 for increasing values, 0 otherwise
+            if numel(Coord_y)>2
+                DCoord_y=diff(Coord_y);
+                DCoord_y_min=min(DCoord_y);
+                DCoord_y_max=max(DCoord_y);
+                if sign(DCoord_y_min)~=sign(DCoord_y_max);% =1 for increasing values, 0 otherwise
                     errormsg=['errror in plot_field.m: non monotonic dimension variable ' Data.ListVarName{VarRole.coord(1)} ];
                     return
                 end
-                test_interp_Y=(DAY_max-DAY_min)> 0.0001*abs(DAY_max);
-            end
-            if numel(AX)>2
-                DAX=diff(AX);
-                DAX_min=min(DAX);
-                DAX_max=max(DAX);
-                if sign(DAX_min)~=sign(DAX_max);% =1 for increasing values, 0 otherwise
+                test_interp_Y=(DCoord_y_max-DCoord_y_min)> 0.0001*abs(DCoord_y_max);
+            end
+            if numel(Coord_x)>2
+                DCoord_x=diff(Coord_x);
+                DCoord_x_min=min(DCoord_x);
+                DCoord_x_max=max(DCoord_x);
+                if sign(DCoord_x_min)~=sign(DCoord_x_max);% =1 for increasing values, 0 otherwise
                     errormsg=['errror in plot_field.m: non monotonic dimension variable ' Data.ListVarName{VarRole.coord(2)} ];
                     return
                 end
-                test_interp_X=(DAX_max-DAX_min)> 0.0001*abs(DAX_max);
+                test_interp_X=(DCoord_x_max-DCoord_x_min)> 0.0001*abs(DCoord_x_max);
             end
             if test_interp_Y
-                npxy(1)=max([256 floor((AY(end)-AY(1))/DAY_min) floor((AY(end)-AY(1))/DAY_max)]);
-                yI=linspace(AY(1),AY(end),npxy(1));
+                npxy(1)=max([256 floor((Coord_y(end)-Coord_y(1))/DCoord_y_min) floor((Coord_y(end)-Coord_y(1))/DCoord_y_max)]);
+                yI=linspace(Coord_y(1),Coord_y(end),npxy(1));
                 if ~test_interp_X
-                    xI=linspace(AX(1),AX(end),size(A,2));%default
-                    AX=xI;
+                    xI=linspace(Coord_x(1),Coord_x(end),size(A,2));%default
+                    Coord_x=xI;
                 end
             end
             if test_interp_X
-                npxy(2)=max([256 floor((AX(end)-AX(1))/DAX_min) floor((AX(end)-AX(1))/DAX_max)]);
-                xI=linspace(AX(1),AX(end),npxy(2));
+                npxy(2)=max([256 floor((Coord_x(end)-Coord_x(1))/DCoord_x_min) floor((Coord_x(end)-Coord_x(1))/DCoord_x_max)]);
+                xI=linspace(Coord_x(1),Coord_x(end),npxy(2));
                 if ~test_interp_Y
-                    yI=linspace(AY(1),AY(end),size(A,1));
-                    AY=yI;
+                    yI=linspace(Coord_y(1),Coord_y(end),size(A,1));
+                    Coord_y=yI;
                 end
             end
             if test_interp_X || test_interp_Y
-                [AX2D,AY2D]=meshgrid(AX,AY);
-                A=interp2(AX2D,AY2D,double(A),xI,yI');
-            end
-            AX=[AX(1) AX(end)];% keep only the lower and upper bounds for image represnetation
-            AY=[AY(1) AY(end)];
+                [Coord_x2D,Coord_y2D]=meshgrid(Coord_x,Coord_y);
+                A=interp2(Coord_x2D,Coord_y2D,double(A),xI,yI');
+            end
+            Coord_x=[Coord_x(1) Coord_x(end)];% keep only the lower and upper bounds for image represnetation
+            Coord_y=[Coord_y(1) Coord_y(end)];
         end
     end
@@ -874,8 +874,8 @@
             cont_pos=[cont_pos_min cont_pos_plus];% set of all contour values
             
-            sizpx=(AX(end)-AX(1))/(np(2)-1);
-            sizpy=(AY(1)-AY(end))/(np(1)-1);
-            x_cont=AX(1):sizpx:AX(end); % pixel x coordinates for image display
-            y_cont=AY(1):-sizpy:AY(end); % pixel x coordinates for image display
+            sizpx=(Coord_x(end)-Coord_x(1))/(np(2)-1);
+            sizpy=(Coord_y(1)-Coord_y(end))/(np(1)-1);
+            x_cont=Coord_x(1):sizpx:Coord_x(end); % pixel x coordinates for image display
+            y_cont=Coord_y(1):-sizpy:Coord_y(end); % pixel x coordinates for image display
             
             %axes(haxes)% set the input axes handle as current axis
@@ -963,9 +963,9 @@
         end
         if test_interp%if we interpolate
-            x=linspace(AX(1),AX(2),np(2));
-            y=linspace(AY(1),AY(2),np(1));
+            x=linspace(Coord_x(1),Coord_x(2),np(2));
+            y=linspace(Coord_y(1),Coord_y(2),np(1));
             [X,Y]=meshgrid(x,y);
-            xi=linspace(AX(1),AX(2),npxy(2));
-            yi=linspace(AY(1),AY(2),npxy(1));
+            xi=linspace(Coord_x(1),Coord_x(2),npxy(2));
+            yi=linspace(Coord_y(1),Coord_y(2),npxy(1));
             A = interp2(X,Y,double(A),xi,yi');
         end
@@ -974,7 +974,7 @@
             tag=get(haxes,'Tag');
             if MinA<MaxA
-                hima=imagesc(AX,AY,A,[MinA MaxA]);
+                hima=imagesc(Coord_x,Coord_y,A,[MinA MaxA]);
             else % to deal with uniform field
-                hima=imagesc(AX,AY,A,[MaxA-1 MaxA]);
+                hima=imagesc(Coord_x,Coord_y,A,[MaxA-1 MaxA]);
             end
             % the function imagesc reset the axes 'DataAspectRatioMode'='auto', change if .CheckFixAspectRatio is
@@ -992,6 +992,6 @@
                 set(haxes,'CLim',[MinA MaxA+1])
             end
-            set(hima,'XData',AX);
-            set(hima,'YData',AY);
+            set(hima,'XData',Coord_x);
+            set(hima,'YData',Coord_y);
         end
         
@@ -1193,8 +1193,8 @@
     else
         if test_ima %both background image and vectors coexist, take the wider bound
-            MinX=min(AX);
-            MaxX=max(AX);
-            MinY=min(AY);
-            MaxY=max(AY);
+            MinX=min(Coord_x);
+            MaxX=max(Coord_x);
+            MinY=min(Coord_y);
+            MaxY=max(Coord_y);
             if test_vec
                 MinX=min(MinX,min(vec_X));
Index: /trunk/src/read_field.m
===================================================================
--- /trunk/src/read_field.m	(revision 781)
+++ /trunk/src/read_field.m	(revision 782)
@@ -234,10 +234,10 @@
     Field.NbDim=2;%default
     Field.AName='image';
-    Field.ListVarName={'AY','AX','A'}; %
+    Field.ListVarName={'Coord_y','Coord_x','A'}; %
     if ndims(A)==3
         if Npz==1;%color
-            Field.VarDimName={'AY','AX',{'AY','AX','rgb'}}; %
-            Field.AY=[npxy(1)-0.5 0.5];
-            Field.AX=[0.5 npxy(2)-0.5]; % coordinates of the first and last pixel centers
+            Field.VarDimName={'Coord_y','Coord_x',{'Coord_y','Coord_x','rgb'}}; %
+            Field.Coord_y=[npxy(1)-0.5 0.5];
+            Field.Coord_x=[0.5 npxy(2)-0.5]; % coordinates of the first and last pixel centers
             if isstruct(ParamOut)
                 ParamOut.Npx=npxy(2);% display image size on the interface
@@ -248,8 +248,8 @@
             Field.NbDim=3;
             Field.ListVarName=['AZ' Field.ListVarName];
-            Field.VarDimName={'AZ','AY','AX',{'AZ','AY','AX'}};
+            Field.VarDimName={'AZ','Coord_y','Coord_x',{'AZ','Coord_y','Coord_x'}};
             Field.AZ=[npxy(1)-0.5 0.5];
-            Field.AY=[npxy(2)-0.5 0.5];
-            Field.AX=[0.5 npxy(3)-0.5]; % coordinates of the first and last pixel centers
+            Field.Coord_y=[npxy(2)-0.5 0.5];
+            Field.Coord_x=[0.5 npxy(3)-0.5]; % coordinates of the first and last pixel centers
             if isstruct(ParamOut)
                 ParamOut.Npx=npxy(3);% display image size on the interface
@@ -259,7 +259,7 @@
         end
     else
-        Field.VarDimName={'AY','AX',{'AY','AX'}}; %
-        Field.AY=[npxy(1)-0.5 0.5];
-        Field.AX=[0.5 npxy(2)-0.5]; % coordinates of the first and last pixel centers
+        Field.VarDimName={'Coord_y','Coord_x',{'Coord_y','Coord_x'}}; %
+        Field.Coord_y=[npxy(1)-0.5 0.5];
+        Field.Coord_x=[0.5 npxy(2)-0.5]; % coordinates of the first and last pixel centers
         ParamOut.Npx=npxy(2);% display image size on the interface
         ParamOut.Npy=npxy(1);
Index: /trunk/src/series/LIF_series.m
===================================================================
--- /trunk/src/series/LIF_series.m	(revision 781)
+++ /trunk/src/series/LIF_series.m	(revision 782)
@@ -120,8 +120,8 @@
         Resu.ZIndex=Data.ZIndex;
         Resu.z=XmlData.GeometryCalib.SliceCoord(Data.ZIndex,3);
-        Resu.ListVarName={'AY' ,'AX' ,'c','mask'};
-        Resu.VarDimName={'AY','AX',{'AY','AX'},{'AY','AX'}};        
-        Resu.AY=[DataOut.AY(1), DataOut.AY(end)];
-        Resu.AX=[DataOut.AX(1), DataOut.AX(end)];
+        Resu.ListVarName={'Coord_y' ,'Coord_x' ,'c','mask'};
+        Resu.VarDimName={'Coord_y','Coord_x',{'Coord_y','Coord_x'},{'Coord_y','Coord_x'}};        
+        Resu.Coord_y=[DataOut.Coord_y(1), DataOut.Coord_y(end)];
+        Resu.Coord_x=[DataOut.Coord_x(1), DataOut.Coord_x(end)];
         Resu.c=DataOut.A;
         Resu.mask=DataMask.A;%to chnge to  cartesian coordinates (polar2phys)
Index: /trunk/src/series/beam_forming.m
===================================================================
--- /trunk/src/series/beam_forming.m	(revision 781)
+++ /trunk/src/series/beam_forming.m	(revision 782)
@@ -102,10 +102,10 @@
 Data.ListGlobalAttribute={'CoordUnit'}; %%TODO: add also time, how to get it  ?????
 Data.CoordUnit='pixel';
-Data.ListVarName={'AX','AY','A'};
-Data.VarDimName={'AX','AY',{'AY','AX'}};
+Data.ListVarName={'Coord_x','Coord_y','A'};
+Data.VarDimName={'Coord_x','Coord_y',{'Coord_y','Coord_x'}};
 %Data.Coord_x=5*(nbvoie_reception-0.5)/numel(nbvoie_reception); % totql length of e
-Data.AX=1:65;
+Data.Coord_x=1:65;
 %Data.Coord_z=(1:A)/133 ;% to check from input parameter ....
-Data.AY=1:332;
+Data.Coord_y=1:332;
 %%%%%%
 %
Index: /trunk/src/series/civ_series.m
===================================================================
--- /trunk/src/series/civ_series.m	(revision 781)
+++ /trunk/src/series/civ_series.m	(revision 782)
@@ -239,5 +239,5 @@
              par_civ1.ImageB=DataIn.(FieldName_B);
         else
-        [par_civ1.ImageB,VideoObject_B] = read_image(ImageName_B,FileType_B,Param.InputFields,FrameIndex_B_Civ1(1));
+        [par_civ1.ImageB,VideoObject_B] = read_image(ImageName_B,FileType_B,VideoObject_B,FrameIndex_B_Civ1(1));
         end
         NbField=numel(i1_series_Civ1);
Index: /trunk/src/transform_field/phys.m
===================================================================
--- /trunk/src/transform_field/phys.m	(revision 781)
+++ /trunk/src/transform_field/phys.m	(revision 782)
@@ -71,6 +71,6 @@
     DataOut=phys_1(DataIn,Calib{1},ZIndex);% transform coordiantes and velocity components
     %case of images or scalar: in case of two input fields, we need to project the transform  on the same regular grid
-    if isfield(DataIn,'A') && isfield(DataIn,'AX') && ~isempty(DataIn.AX) && isfield(DataIn,'AY')&&...
-                                           ~isempty(DataIn.AY) && length(DataIn.A)>1
+    if isfield(DataIn,'A') && isfield(DataIn,'Coord_x') && ~isempty(DataIn.Coord_x) && isfield(DataIn,'Coord_y')&&...
+                                           ~isempty(DataIn.Coord_y) && length(DataIn.A)>1
         iscalar=1;
         A{1}=DataIn.A;
@@ -117,6 +117,6 @@
         end
     end
-    if isfield(DataIn_1,'A')&&isfield(DataIn_1,'AX')&&~isempty(DataIn_1.AX) && isfield(DataIn_1,'AY')&&...
-            ~isempty(DataIn_1.AY)&&length(DataIn_1.A)>1
+    if isfield(DataIn_1,'A')&&isfield(DataIn_1,'Coord_x')&&~isempty(DataIn_1.Coord_x) && isfield(DataIn_1,'Coord_y')&&...
+            ~isempty(DataIn_1.Coord_y)&&length(DataIn_1.A)>1
         iscalar=iscalar+1;
         Calib{iscalar}=Calib{2};
@@ -127,18 +127,18 @@
 %% transform the scalar(s) or image(s)
 if iscalar~=0
-    [A,AX,AY]=phys_Ima(A,Calib,ZIndex);%TODO : introduire interp2_uvmat ds phys_ima
+    [A,Coord_x,Coord_y]=phys_Ima(A,Calib,ZIndex);%TODO : introduire interp2_uvmat ds phys_ima
     if iscalar==1 && ~isempty(DataOut_1) % case for which only the second field is a scalar
          DataOut_1.A=A{1};
-         DataOut_1.AX=AX; 
-         DataOut_1.AY=AY;
+         DataOut_1.Coord_x=Coord_x; 
+         DataOut_1.Coord_y=Coord_y;
     else
         DataOut.A=A{1};
-        DataOut.AX=AX; 
-        DataOut.AY=AY;
+        DataOut.Coord_x=Coord_x; 
+        DataOut.Coord_y=Coord_y;
     end
     if iscalar==2
         DataOut_1.A=A{2};
-        DataOut_1.AX=AX; 
-        DataOut_1.AY=AY;
+        DataOut_1.Coord_x=Coord_x; 
+        DataOut_1.Coord_y=Coord_y;
     end
 end
@@ -146,5 +146,5 @@
 % subtract fields
 if ~isempty(DataOut_1)
-DataOut=sub_field(DataOut,[],DataOut_1);
+    DataOut=sub_field(DataOut,[],DataOut_1);
 end
 %------------------------------------------------
Index: /trunk/src/transform_field/phys_polar.m
===================================================================
--- /trunk/src/transform_field/phys_polar.m	(revision 781)
+++ /trunk/src/transform_field/phys_polar.m	(revision 782)
@@ -80,6 +80,6 @@
     DataOut=phys_1(Data,Calib{1},origin_xy,radius_offset,angle_offset,angle_scale);
     %case of images or scalar
-    if isfield(Data,'A')&isfield(Data,'AX')&~isempty(Data.AX) & isfield(Data,'AY')&...
-                                           ~isempty(Data.AY)&length(Data.A)>1
+    if isfield(Data,'A')&isfield(Data,'Coord_x')&~isempty(Data.Coord_x) & isfield(Data,'Coord_y')&...
+                                           ~isempty(Data.Coord_y)&length(Data.A)>1
         iscalar=1;
         A{1}=Data.A;
@@ -96,6 +96,6 @@
 if test_1
     DataOut_1=phys_1(Data_1,Calib{2},origin_xy,radius_offset,angle_offset,angle_scale);
-    if isfield(Data_1,'A')&isfield(Data_1,'AX')&~isempty(Data_1.AX) & isfield(Data_1,'AY')&...
-                                       ~isempty(Data_1.AY)&length(Data_1.A)>1
+    if isfield(Data_1,'A')&isfield(Data_1,'Coord_x')&~isempty(Data_1.Coord_x) & isfield(Data_1,'Coord_y')&...
+                                       ~isempty(Data_1.Coord_y)&length(Data_1.A)>1
           iscalar=iscalar+1;
           Calib{iscalar}=Calib{2};
@@ -105,8 +105,8 @@
           end
           if iscalar==1% case for which only the second field is a scalar
-               [A,AX,AY]=phys_Ima_polar(A,Calib,ZIndex,origin_xy,radius_offset,angle_offset,angle_scale);
+               [A,Coord_x,Coord_y]=phys_Ima_polar(A,Calib,ZIndex,origin_xy,radius_offset,angle_offset,angle_scale);
                DataOut_1.A=A{1};
-               DataOut_1.AX=AX; 
-               DataOut_1.AY=AY;
+               DataOut_1.Coord_x=Coord_x; 
+               DataOut_1.Coord_y=Coord_y;
                return
           end
@@ -114,12 +114,12 @@
 end
 if iscalar~=0
-    [A,AX,AY]=phys_Ima_polar(A,Calib,ZIndex,origin_xy,radius_offset,angle_offset,angle_scale);%
+    [A,Coord_x,Coord_y]=phys_Ima_polar(A,Calib,ZIndex,origin_xy,radius_offset,angle_offset,angle_scale);%
     DataOut.A=A{1};
-    DataOut.AX=AX; 
-    DataOut.AY=AY;
+    DataOut.Coord_x=Coord_x; 
+    DataOut.Coord_y=Coord_y;
     if iscalar==2
         DataOut_1.A=A{2};
-        DataOut_1.AX=AX; 
-        DataOut_1.AY=AY;
+        DataOut_1.Coord_x=Coord_x; 
+        DataOut_1.Coord_y=Coord_y;
     end
 end
Index: /trunk/src/uvmat.m
===================================================================
--- /trunk/src/uvmat.m	(revision 781)
+++ /trunk/src/uvmat.m	(revision 782)
@@ -83,7 +83,7 @@
 % velocity vectors. The scalar values in the first case is represented by
 % UvData.Field.A, and by UvData.Field.C in the second case. The corresponding set of X
-% and Y axes are represented by UvData.Field.AX and UvData.Field.AY, and .X and
+% and Y axes are represented by UvData.Field.Coord_x and UvData.Field.Coord_y, and .X and
 % .Y for C (the same as velocity vectors). If A is a nxxny matrix (scalar
-% on a regtular grid), then .AX andf.AY contains only two elements, represneting the
+% on a regtular grid), then .Coord_x andf.Coord_y contains only two elements, represneting the
 % axes of the four image corners. The scalar name is represented by
 % the strings .AName and/or .CName.
@@ -1145,6 +1145,6 @@
         set(handles_Fields,'String',{'image'})
         %set(handles.Coord_x,'Value',1);
-        set(handles.Coord_x,'String','AX');
-    set(handles.Coord_y,'String','AY');
+        set(handles.Coord_x,'String','Coord_x');
+    set(handles.Coord_y,'String','Coord_y');
 end
 set(handles.uvmat,'UserData',UvData)
@@ -1497,11 +1497,11 @@
             set(hmask,'CData',imflag)    
             set(hmask,'AlphaData',flagmask*0.6)
-            set(hmask,'XData',MaskField.AX);
-            set(hmask,'YData',MaskField.AY);
+            set(hmask,'XData',MaskField.Coord_x);
+            set(hmask,'YData',MaskField.Coord_y);
 %             uistack(hmask,'top')
         else
             axes(handles.PlotAxes)
             hold on    
-            Mask.maskhandle=image(MaskField.AX,MaskField.AY,imflag,'Tag','mask','HitTest','off','AlphaData',0.6*ones(size(flagmask)));
+            Mask.maskhandle=image(MaskField.Coord_x,MaskField.Coord_y,imflag,'Tag','mask','HitTest','off','AlphaData',0.6*ones(size(flagmask)));
             set(handles.CheckMask,'UserData',Mask)
         end
@@ -2691,9 +2691,9 @@
         if isfield(ObjectData,'NbDim') && isequal(ObjectData.NbDim,2) && isfield(ObjectData,'Mask') && isfield(ObjectData,'A')
             flag_mask=double(ObjectData.Mask>200);%=0 for masked regions
-            AX=ObjectData.AX;%x coordiantes for the scalar field
-            AY=ObjectData.AY;%y coordinates for the scalar field
+            Coord_x=ObjectData.Coord_x;%x coordiantes for the scalar field
+            Coord_y=ObjectData.Coord_y;%y coordinates for the scalar field
             MaskX=ObjectData.MaskX;%x coordiantes for the mask
             MaskY=ObjectData.MaskY;%y coordiantes for the mask
-            if ~isequal(MaskX,AX)||~isequal(MaskY,AY)
+            if ~isequal(MaskX,Coord_x)||~isequal(MaskY,Coord_y)
                 nxy=size(flag_mask);
                 sizpx=(ObjectData.MaskX(end)-ObjectData.MaskX(1))/(nxy(2)-1);%size of a mask pixel
@@ -2703,8 +2703,8 @@
                 %project on the positions of the scalar
                 npxy=size(ObjectData.A);
-                dxy(1)=(ObjectData.AY(end)-ObjectData.AY(1))/(npxy(1)-1);%grid mesh in y
-                dxy(2)=(ObjectData.AX(end)-ObjectData.AX(1))/(npxy(2)-1);%grid mesh in x
-                xi=ObjectData.AX(1):dxy(2):ObjectData.AX(end);
-                yi=ObjectData.AY(1):dxy(1):ObjectData.AY(end);
+                dxy(1)=(ObjectData.Coord_y(end)-ObjectData.Coord_y(1))/(npxy(1)-1);%grid mesh in y
+                dxy(2)=(ObjectData.Coord_x(end)-ObjectData.Coord_x(1))/(npxy(2)-1);%grid mesh in x
+                xi=ObjectData.Coord_x(1):dxy(2):ObjectData.Coord_x(end);
+                yi=ObjectData.Coord_y(1):dxy(1):ObjectData.Coord_y(end);
                 [XI,YI]=meshgrid(xi,yi);% creates the matrix of regular coordinates
                 flag_mask = interp2(x_mask,y_mask,flag_mask,XI,YI);
@@ -3641,8 +3641,8 @@
         data.DX=UvData.Field.CoordMesh;
         data.DY=UvData.Field.CoordMesh;
-    elseif isfield(UvData.Field,'AX')&isfield(UvData.Field,'AY')& isfield(UvData.Field,'A')%only image
+    elseif isfield(UvData.Field,'Coord_x')&isfield(UvData.Field,'Coord_y')& isfield(UvData.Field,'A')%only image
         np=size(UvData.Field.A);
-        meshx=(UvData.Field.AX(end)-UvData.Field.AX(1))/np(2);
-        meshy=abs(UvData.Field.AY(end)-UvData.Field.AY(1))/np(1);
+        meshx=(UvData.Field.Coord_x(end)-UvData.Field.Coord_x(1))/np(2);
+        meshy=abs(UvData.Field.Coord_y(end)-UvData.Field.Coord_y(1))/np(1);
         data.RangeY=max(meshx,meshy);
         data.RangeX=max(meshx,meshy);
@@ -5381,7 +5381,7 @@
     figure
     plot(theta_ref,r_ref)
-    azimuth_ima=linspace(DataOut.AY(1),DataOut.AY(2),size(DataOut.A,1));%profile of x index on the transformed image
+    azimuth_ima=linspace(DataOut.Coord_y(1),DataOut.Coord_y(2),size(DataOut.A,1));%profile of x index on the transformed image
     dist_source = interp1(theta_ref,r_ref,azimuth_ima);
-    dist_source_pixel=round(size(DataOut.A,2)*(dist_source-DataOut.AX(1))/(DataOut.AX(2)-DataOut.AX(1)));
+    dist_source_pixel=round(size(DataOut.A,2)*(dist_source-DataOut.Coord_x(1))/(DataOut.Coord_x(2)-DataOut.Coord_x(1)));
     line_nan= isnan(dist_source_pixel);
     dist_source_pixel(line_nan)=1;