www.pudn.com > Digital_Image_Correlation_2010b.zip > displacement.m, change:2010-11-20,size:39129b


 
% Initialize data 
% written by Chris and Dan 
 
% Displacement.m allows you to analyze the data you aquiered with the 
% correlation, fitting or mean routine. It only needs the validx and 
% validy and can calculate strain from it. Before you start you should  
% consider cleaning up the data as described in the guide. After that step 
% you can analyze parts of your data, or the full set. Try to use also the 
% console command, e.g. if you want to analyze only image 100-110 since 
% something really interesting happend there, load validx and validy into 
% your workspace and call 
% displacement(validx(:,100:110),validy(:,100:110)); 
% In this case displacement only loads the important images and you can 
% clean this part of your data set. 
 
% Changed 3. February 2008 
 
 
function [validx,validy]=displacement(validx,validy); 
 
%load data in case you did not load it into workspace yet 
if exist('validx')==0 
    [validxname,Pathvalidx] = uigetfile('*.dat','Open validx.dat'); 
    if validxname==0 
        disp('You did not select a file!') 
        return 
    end 
    cd(Pathvalidx); 
    validx=importdata(validxname,'\t'); 
end 
if exist('validy')==0 
    [validyname,Pathvalidy] = uigetfile('*.dat','Open validy.dat'); 
    if validyname==0 
        disp('You did not select a file!') 
        return 
    end 
    cd(Pathvalidy); 
    validy=importdata(validyname,'\t'); 
end 
 
%define the size of the data set 
sizevalidx=size(validx); 
sizevalidy=size(validy); 
looppoints=sizevalidx(1,1); 
loopimages=sizevalidx(1,2); 
 
%calculate the displacement relative to the first image in x and y 
%direction 
clear displx; 
validxfirst=zeros(size(validx)); 
validxfirst=mean(validx(:,1),2)*ones(1,sizevalidx(1,2)); 
displx=validx-validxfirst; 
clear validxfirst 
clear disply; 
validyfirst=zeros(size(validy)); 
validyfirst=mean(validy(:,1),2)*ones(1,sizevalidy(1,2)); 
disply=validy-validyfirst; 
clear validyfirst 
 
%Prompt user for type of plotting / visualization 
selection10 = menu(sprintf('How do you want to visualize your data?'),'3D Mesh Plot of Displacement'... 
    ,'Full Strain Plots','Strain Measurement between 2 Points','1D Average Strain Measurement',... 
    'Rotate Orientation (exchange x and y)','Remove badly tracked marker, one by one (Position)',... 
    'Delete multible markers (Position)','Delete markers from displacement vs. position plot',... 
    'Delete points moving relative to their neighbours','Select Markers to Analyze ',... 
    'Save validx and validy','Average a couple of images','Cancel'); 
 
% Selection for Cancel - All windows will be closed and you jump back to 
% the command line 
if selection10==13 
    close all; 
    return 
end 
 
% This selection will average up a specified number of images to reduce the 
% noise of the data set. I would like to point out that you will need to 
% average your other sensor data (e.g. load data), too, to match it to your 
% strain data. 
if selection10==12 
    prompt = {'How many images would you like to combine as a base image?'}; 
    dlg_title = 'Input number of images:'; 
    num_lines= 1; 
    def     = {'5'}; 
    answer = inputdlg(prompt,dlg_title,num_lines,def); 
    if str2num(cell2mat(answer(1)))==0 
        disp('Get out, you changed your mind?') 
        [validx validy]=displacement(validx,validy); 
        return 
    else 
        baseimages = str2num(cell2mat(answer(1))); 
        if baseimages==[] 
            disp('Give me a number, will you?') 
            [validx validy]=displacement(validx,validy); 
            return 
        end 
        if baseimages>loopimages 
            disp('That is too large?!') 
        else 
            baseimagemean=mean(validx(:,1:baseimages),2); 
            validx(:,1:baseimages-1)=[]; 
            validx(:,1)=baseimagemean; 
            baseimagemean=mean(validy(:,1:baseimages),2); 
            validy(:,1:baseimages-1)=[]; 
            validy(:,1)=baseimagemean; 
        end 
    end 
    [validx validy]=displacement(validx,validy); 
    return 
end 
 
% Save validx and validy, very useful if you cleaned up your dataset. Data 
% will be saved as -ascii text file. If you send data like this by email 
% you can reduce the size tremendously by compressing it. Use ZIP or RAR. 
if selection10==11 
    [FileName,PathName] = uiputfile('validx_corr.dat','Save validx'); 
    if FileName==0 
        disp('You did not save your file!') 
        [validx validy]=displacement(validx,validy); 
        return 
    else 
        cd(PathName) 
        save(FileName,'validx','-ascii') 
        [FileName,PathName] = uiputfile('validy_corr.dat','Save validy'); 
        if FileName==0 
            disp('You did not save your file!') 
            [validx validy]=displacement(validx,validy); 
        else 
            cd(PathName) 
            save(FileName,'validy','-ascii') 
        end 
        [validx validy]=displacement(validx,validy); 
        return 
    end 
end 
 
% Select Points from detailed Analysis 
if selection10==10 
    [validx validy validxbackup validybackup]=ppselection_func(validx,validy); 
    if validx==0 
        validx=validxbackup; 
        validy=validybackup; 
    end 
    if validy==0 
        validx=validxbackup; 
        validy=validybackup; 
    end 
    [validx validy]=displacement(validx,validy); 
end 
 
% Remove markers moving relativ to their neighbours 
if selection10==9 
    [validx,validy,displx,disply]=delete_jumpers(validx,validy,displx,disply); 
    [validx validy]=displacement(validx,validy); 
end 
 
% Remove markers from the displacement vs. position plot 
if selection10==8 
    [validx,validy,displx,disply]=removepoints_func(validx,validy,displx,disply); 
    [validx validy]=displacement(validx,validy); 
end 
 
% Remove bad points 
if selection10==7 
    [validx,validy]=removepoints_func2(validx,validy); 
    [validx validy]=displacement(validx,validy); 
end 
 
% Remove bad points 
if selection10==6 
    [validx validy]=removepoints_func3(validx,validy); 
    [validx validy]=displacement(validx,validy); 
end 
 
% Rotate Matrix 
if selection10==5 
    [validx, validy]=rotatematrix(validx,validy); 
    [validx validy]=displacement(validx,validy); 
end 
 
% 1D Strain plot using average strains for ELASTIC STRAIN only 
if selection10==4 
    [validx validy]=strain_1D_average_func(validx, validy,displx,disply); 
    [validx validy]=displacement(validx,validy); 
end 
 
% 1D Strain plot 
if selection10==3 
    [validx, validy,displx,disply]=strain_1D_2Points_func(validx, validy,displx,disply); 
    [validx validy]=displacement(validx,validy); 
end 
 
% Fast plotting, cropping needed for polynomial fit 
if selection10==2 
    [validx, validy,displx,disply]=polyfit3D(validx, validy,displx,disply); 
    [validx validy]=displacement(validx,validy); 
end 
 
% 3D Mesh Plotting 
if selection10==1 
    if sizevalidx(1,1)>2 
    [validx, validy,displx,disply]=meshplot(validx,validy,displx,disply); 
    else 
        disp('You need at least three markers to display the 3D-plot') 
        msgbox('You need at least three markers to display the 3D-plot','3D-Plot','warn'); 
    end 
    [validx validy]=displacement(validx,validy); 
end 
 
%--------------------------------- 
 
function [validx,validy,displx,disply]=delete_jumpers(validx,validy,displx,disply); 
 
% written by Chris 
 
% This is a filter which helps to find jumpy data points which are  
% oscillating or stop moving. 
% The Filter starts by finding the next 10 datapoint neighbours  
% (num_neighbours), calculates their mean position and then plots the 
% difference between each data point and its neighbours versus image 
% number. If a data point is jumping around it will show up as a spike. But 
% be careful, one bad one will also affect his neighbours, therefore its 
% worthwhile to use this filter step by step. 
 
% Changed 3. February 2008 
 
num_neighbours=10; 
 
doitonemoretime=1 
 
while doitonemoretime==1 
    % defining variables 
    sizevalidx=size(validx); 
    sizevalidy=size(validy); 
    looppoints=sizevalidx(1,1); 
    loopimages=sizevalidx(1,2); 
 
    % clear the used ones 
    clear validxtemp 
    clear validytemp 
    clear meandistancetemp 
    clear sizevalidxtemp 
    clear sizevalidytemp 
    clear looppointstemp 
    clear loopimagestemp 
    clear max_distance 
    clear min_distance 
    clear dist_matrix 
    clear dist_sort 
    clear dist_index 
    clear meandistance 
    tic 
    % calculate the distance to the next data points 
%     dist_matrix=zeros(looppoints,looppoints); 
    meandistance=zeros(sizevalidx); 
     
    g=waitbar(0,'Processing the markers...'); 
    for i=1:looppoints 
        waitbar(i/looppoints); 
        dist_matrix=(((validx(:,1)-validx(i,1)).^2+(validy(:,1)-validy(i,1)).^2).^(0.5))'; 
        %   end 
 
        % find the next neighbours by indexing the ones closest 
        [dist_sort, dist_index]=sort(dist_matrix); 
 
        % take the mean position of the closest data points of each for all 
        % images 
        meandistance(i,:)= validx(i,:)-mean(validx(dist_index(2:num_neighbours),:),1); 
        max_distance(i)= max(diff(meandistance(i,:)-meandistance(i,1))); 
        min_distance(i)= min(diff(meandistance(i,:)-meandistance(i,1))); 
    end 
    close(g) 
toc 
    for i=1:looppoints 
        plot(diff(meandistance(i,:)-meandistance(i,1))) 
        hold on 
    end 
   toc      
    % Select an upper and lower boundary 
    xlabel('Image number[ ]') 
    ylabel('Relative marker dispacement [Pixels]') 
    title(sprintf('Define the upper and lower bound by clicking above and below the valid points')) 
    marker_pt=(ginput(1)); 
    x_mark(1,1) = marker_pt(1); 
    y_mark(1,1) = marker_pt(2); 
    plot([1;loopimages],[y_mark(1,1);y_mark(1,1)],'r'); 
 
    title(sprintf('Define the upper and lower bound by clicking above and below the valid points')) 
    marker_pt=(ginput(1)); 
    x_mark(1,2) = marker_pt(1); 
    y_mark(1,2) = marker_pt(2); 
    plot([1;loopimages],[y_mark(1,2);y_mark(1,2)],'r'); 
 
    upperbound=max(y_mark); 
    lowerbound=min(y_mark); 
 
    hold off 
     
    validxtemp=validx; 
    validytemp=validy; 
    meandistancetemp=meandistance; 
     
     
    validxtemp(find(max_distance>upperbound | min_distance<lowerbound),:)=[]; 
    validytemp(find(max_distance>upperbound | min_distance<lowerbound),:)=[]; 
    meandistancetemp(find(max_distance>upperbound |min_distance<lowerbound),:)=[]; 
    sizevalidxtemp=size(validxtemp); 
    sizevalidytemp=size(validytemp); 
    looppointstemp=sizevalidxtemp(1,1); 
    loopimagestemp=sizevalidxtemp(1,2); 
     
    for i=1:looppointstemp 
        plot(diff(meandistancetemp(i,:)-meandistancetemp(i,1))) 
        hold on 
    end 
    plot([1;loopimages],[y_mark(1,1);y_mark(1,1)],'r'); 
    plot([1;loopimages],[y_mark(1,2);y_mark(1,2)],'r'); 
     
    hold off 
 
    selection_filter = menu('Do you like the result?','Take it as is','Want to select more','Try again','Cancel'); 
    if selection_filter==1 
        validx=validxtemp; 
        validy=validytemp; 
        doitonemoretime=0; 
    elseif selection_filter==2 
        validx=validxtemp; 
        validy=validytemp; 
        doitonemoretime=1; 
    elseif selection_filter==3 
        doitonemoretime=1; 
    elseif selection_filter==4 
        return 
    end 
end 
 
%--------------------------------- 
% Rotate Matrix 
% written by Chris 
function [validx, validy]=rotatematrix(validx,validy); 
validxrot=validx; 
clear validx; 
validyrot=validy; 
clear validy; 
validy=validxrot; 
validx=validyrot; 
 
 
%--------------------------------- 
% Delete points from the displacement plot 
% written by Chris 
function [validx,validy,displx,disply] = removepoints_func(validx,validy,displx,disply) ; %delete points 
 
close all 
 
if exist('validx')==0 
    [validx,Pathvalidx] = uigetfile('*.mat; *.txt','Open validx.mat or validx.txt'); 
    cd(Pathvalidx); 
    validx=importdata(validx,'\t'); 
    [validy,Pathvalidy] = uigetfile('*.mat;*.txt','Open validy.mat or validy.txt'); 
    cd(Pathvalidy); 
    validy=importdata(validy,'\t'); 
end 
 
selectremove1 = menu(sprintf('Do you want to delete makers?'),'Yes','No'); 
if selectremove1==2 
    return 
end 
 
% if yes 
if selectremove1==1 
 
    sizevalidx=size(validx); 
    sizevalidy=size(validy); 
 
    selectionremove2=selectremove1; 
    counter=0 
    sizevalidx=size(validx); 
    looppoints=sizevalidx(1,1); 
    loopimages=sizevalidx(1,2); 
    defaultimage=loopimages 
    numberbadpoints=0 
 
    while selectionremove2==1 
        counter=counter+1 
        clear xplot 
        clear sizevalidx 
        clear selectremove11 
        clear selection2 
        %         clear badpoints 
 
        sizevalidx=size(validx); 
        looppoints=sizevalidx(1,1); 
        loopimages=sizevalidx(1,2); 
 
        % update temporary matrices 
        validxtemp=validx; 
        validytemp=validy; 
        displxtemp=displx; 
        displytemp=disply; 
 
        % get the image number from which the bad points will be chosen 
        prompt = {'From which image do you want to delete markers?'}; 
        dlg_title = 'Marker removal'; 
        num_lines= 1; 
        if numberbadpoints==0 
            defaultimage=loopimages 
        end 
        if numberbadpoints~0 
            defaultimage=numberbadpoints 
        end 
        def     = {num2str(defaultimage)}; 
        answer = inputdlg(prompt,dlg_title,num_lines,def); 
        numberbadpoints = str2num(cell2mat(answer(1,1))); 
        if numberbadpoints>loopimages 
            numberbadpoints=loopimages 
        end 
        if numberbadpoints<1 
            numberbadpoints=1 
        end 
 
%         displx(:,1)=-validx(:,1)+validx(:,numberbadpoints); 
%         disply(:,1)=-validy(:,1)+validy(:,numberbadpoints); 
 
        plot(validx(:,numberbadpoints),displx(:,numberbadpoints),'o'); 
        xlabel('position [pixel]') 
        ylabel('displacement [pixel]') 
        title(['Displacement versus position',sprintf(' (Current image #: %1g)',numberbadpoints)]); 
 
%         validxtemp=validx; 
%         validytemp=validy; 
        displxtemp=displx; 
        validxdelete=validxtemp; 
        validydelete=validytemp; 
        displxdelete=displxtemp; 
        displydelete=displytemp; 
 
        title(sprintf('Define the region of interest.  \n  All points ouside that region will be deleted')) 
 
        [xgrid,ygrid]=ginput(2); 
        x(1,1) = xgrid(1); 
        x(1,2) = xgrid(2); 
        y(1,1) = ygrid(2); 
        y(1,2) = ygrid(1); 
 
        deletepoints=find(validxdelete(:,numberbadpoints)>min(x) & validxdelete(:,numberbadpoints)<max(x) & displxdelete(:,numberbadpoints)<max(y) & displxdelete(:,numberbadpoints)>min(y)); 
        [loopnum one]=size(deletepoints); 
 
        validxdelete(deletepoints,:)=[]; 
        validydelete(deletepoints,:)=[]; 
 
 
        % update temporary data matrices; delete bad points 
        displxtemp(deletepoints,:)=[]; 
        displytemp(deletepoints,:)=[]; 
        validxtemp(deletepoints,:)=[]; 
        validytemp(deletepoints,:)=[]; 
 
        plot(validxtemp(:,numberbadpoints),displxtemp(:,numberbadpoints),'o'); 
 
        % delete point permanently? 
        selectremove3 = menu(sprintf('Do you want to delete these markers permanently?'),'Yes','No'); 
        if selectremove3==1 
            displx=displxtemp; 
            disply=displytemp; 
            validx=validxtemp; 
            validy=validytemp; 
        end 
        if selectremove3==2 
            displxtemp=displx; 
            displytemp=disply; 
            validxtemp=validx; 
            validytemp=validy; 
        end 
        selectremove2 = menu(sprintf('Do you want to mark another bad point?'),'Yes','No'); 
        if selectremove2==2 
            clear displx; 
            clear disply; 
            validxfirst=zeros(size(validx)); 
            validxfirst=validx(:,1)*ones(1,sizevalidx(1,2)); 
            validyfirst=zeros(size(validy)); 
            validyfirst=validy(:,1)*ones(1,sizevalidy(1,2)); 
            displx=validx-validxfirst; 
            disply=validy-validyfirst; 
            return 
        end 
    end 
 
end 
 
%--------------------------------- 
% Delete single points 
% written by Chris 
function [validx,validy]=removepoints_func3(validx,validy); 
 
%sort out badpoints? 
 
selection1 = menu(sprintf('Do you want to mark bad points?'),'Yes','No'); 
if selection1==2 
    close all; 
    return 
end 
 
% if yes 
if selection1==1 
    selection2=selection1; 
    %     figure 
    counter=0 
    sizevalidx=size(validx); 
    looppoints=sizevalidx(1,1); 
    loopimages=sizevalidx(1,2)-1; 
    defaultimage=loopimages 
    numberbadpoints=0 
 
    while selection2==1 
        counter=counter+1 
        clear xplot 
        clear sizevalidx 
        clear selection1 
        clear selection2 
        clear badpoints 
 
        sizevalidx=size(validx); 
        looppoints=sizevalidx(1,1); 
        loopimages=sizevalidx(1,2)-1; 
 
        clear displx; 
        validxfirst=zeros(size(validx)); 
        validxfirst=validx(:,1)*ones(1,sizevalidx(1,2)); 
        displx=validx-validxfirst; 
 
        % update temporary matrices 
        displxtemp=displx; 
        validxtemp=validx; 
        validytemp=validy; 
        %         resnormxtemp=resnormx; 
 
        % get the image number from which the bad points will be chosen 
        prompt = {'From which image do you want to choose the bad points?'}; 
        dlg_title = 'Bad points removal'; 
        num_lines= 1; 
        if numberbadpoints==0 
            defaultimage=loopimages 
        end 
        if numberbadpoints~0 
            defaultimage=numberbadpoints 
        end 
        def     = {num2str(defaultimage)}; 
        answer = inputdlg(prompt,dlg_title,num_lines,def); 
        numberbadpoints = str2num(cell2mat(answer(1,1))); 
        if numberbadpoints>loopimages 
            numberbadpoints=loopimages 
        end 
        if numberbadpoints<1 
            numberbadpoints=1 
        end 
 
        gridsizex=10*round(min(min(validx))/10):10:10*round(max(max(validx))/10); 
        gridsizey=10*round(min(min(validy))/10):10:10*round(max(max(validy))/10); 
        [XI,YI]=meshgrid(gridsizex,gridsizey); 
        ZI=griddata(validx(:,numberbadpoints),validy(:,numberbadpoints),displx(:,numberbadpoints),XI,YI,'cubic'); 
        epsxx = gradient(ZI,10,10); 
 
        % find max and min point and point them out 
        mindisplx=find(displx(:,numberbadpoints)==min(displx(:,numberbadpoints))); 
        maxdisplx=find(displx(:,numberbadpoints)==max(displx(:,numberbadpoints))); 
 
 
        pcolor(XI,YI,epsxx); 
        axis('equal') 
        caxis([min(min(epsxx)) max(max(epsxx))]) 
        colorbar 
        shading('interp') 
        hold on 
        plot3(validx(:,numberbadpoints),validy(:,numberbadpoints),displx(:,numberbadpoints)-min(displx(:,numberbadpoints)),'o','MarkerEdgeColor','k','MarkerFaceColor','g'), hold on; 
        plot3(validx(mindisplx,numberbadpoints),validy(mindisplx,numberbadpoints),displx(mindisplx,numberbadpoints)-min(displx(:,numberbadpoints)),'o','MarkerEdgeColor','y','MarkerFaceColor','b') 
        plot3(validx(maxdisplx,numberbadpoints),validy(maxdisplx,numberbadpoints),displx(maxdisplx,numberbadpoints)-min(displx(:,numberbadpoints)),'o','MarkerEdgeColor','y','MarkerFaceColor','r') 
        axis([min(min(XI))-10 max(max(XI))+10 min(min(YI))-10 max(max(YI))+10]) 
        drawnow; 
        hold off 
 
        % get the bad point position 
 
        title(sprintf('Click on the bad point',counter)) 
        [badpoint]=ginput(1); 
        badpointx = badpoint(1,1); 
        badpointy = badpoint(1,2); 
 
        % find the point matching the given position 
        wherethehellisthispoint=abs(validx(:,numberbadpoints)-badpoint(1,1))+abs(validy(:,numberbadpoints)-badpoint(1,2)); 
        badpointnum=find(wherethehellisthispoint==min(wherethehellisthispoint)); 
 
        % update temporary data matrices; delete bad points 
 
        displxtemp(badpointnum,:)=[]; 
        validxtemp(badpointnum,:)=[]; 
        validytemp(badpointnum,:)=[]; 
        mindisplx=find(displxtemp(:,numberbadpoints)==min(displxtemp(:,numberbadpoints))); 
        maxdisplx=find(displxtemp(:,numberbadpoints)==max(displxtemp(:,numberbadpoints))); 
 
        % update the figure 
        ZI=griddata(validxtemp(:,numberbadpoints),validytemp(:,numberbadpoints),displxtemp(:,numberbadpoints),XI,YI,'cubic'); 
        epsxx = gradient(ZI,10,10); 
        pcolor(XI,YI,epsxx); 
        axis('equal') 
        caxis([min(min(epsxx)) max(max(epsxx))]) 
        colorbar 
        shading('interp') 
        hold on 
        plot3(validxtemp(:,numberbadpoints),validytemp(:,numberbadpoints),displxtemp(:,numberbadpoints),'o','MarkerEdgeColor','k','MarkerFaceColor','g') 
        plot3(validxtemp(mindisplx,numberbadpoints),validytemp(mindisplx,numberbadpoints),displxtemp(mindisplx,numberbadpoints)-min(displxtemp(:,numberbadpoints)),'o','MarkerEdgeColor','y','MarkerFaceColor','b') 
        plot3(validxtemp(maxdisplx,numberbadpoints),validytemp(maxdisplx,numberbadpoints),displxtemp(maxdisplx,numberbadpoints)-min(displxtemp(:,numberbadpoints)),'o','MarkerEdgeColor','y','MarkerFaceColor','r') 
        axis([min(min(XI))-10 max(max(XI))+10 min(min(YI))-10 max(max(YI))+10]) 
        drawnow;hold off; 
 
        % delete point permanently? 
        selection3 = menu(sprintf('Do you want to delete this point permanently?'),'Yes','No'); 
        if selection3==1 
            displx=displxtemp; 
            validx=validxtemp; 
            validy=validytemp; 
            %             resnormx=resnormxtemp; 
        end 
        if selection3==2 
            displxtemp=displx; 
            validxtemp=validx; 
            validytemp=validy; 
            %             resnormxtemp=resnormx; 
        end 
        selection2 = menu(sprintf('Do you want to mark another bad point?'),'Yes','No'); 
        if selection2==2 
            close all; 
            return 
        end 
 
    end 
end 
 
%--------------------------------- 
% Strain between two markers 
% written by Chris 
function [validx, validy,displx,disply] = strain_1D_2Points_func(validx, validy,displx,disply) ; % 1D strain calculation 
 
sizevalidx=size(validx); 
looppoints=sizevalidx(1,1); 
loopimages=sizevalidx(1,2)-1; 
defaultimage=loopimages; 
numberbadpoints=0; 
clear selection3; selection3=1; 
 
while selection3==1 
 
    clear xplot 
    clear sizevalidx 
    clear selection1 
    clear selection2 
    clear badpoints 
 
    sizevalidx=size(validx); 
    looppoints=sizevalidx(1,1); 
    loopimages=sizevalidx(1,2)-1; 
 
    % update temporary matrices 
    displxtemp=displx; 
    validxtemp=validx; 
    validytemp=validy; 
    %     resnormxtemp=resnormx; 
 
    % get the image number from which the bad points will be chosen 
    prompt = {'Which image do you want for point selection?'}; 
    dlg_title = '1D Strain Plotting'; 
    num_lines= 1; 
    if numberbadpoints==0 
        defaultimage=loopimages; 
    end 
    if numberbadpoints~0 
        defaultimage=numberbadpoints 
    end 
    def     = {num2str(defaultimage)}; 
    answer = inputdlg(prompt,dlg_title,num_lines,def); 
    numberbadpoints = str2num(cell2mat(answer(1,1))); 
    if numberbadpoints>loopimages 
        numberbadpoints=loopimages; 
    end 
    if numberbadpoints<1 
        numberbadpoints=1; 
    end 
 
    gridsizex=10*round(min(min(validx))/10):10:10*round(max(max(validx))/10); 
    gridsizey=10*round(min(min(validy))/10):10:10*round(max(max(validy))/10); 
    [XI,YI]=meshgrid(gridsizex,gridsizey); 
    ZI=griddata(validx(:,numberbadpoints),validy(:,numberbadpoints),displx(:,numberbadpoints),XI,YI,'cubic'); 
 
    pcolor(XI,YI,ZI); 
    axis('equal') 
    caxis([min(min(ZI)) max(max(ZI))]) 
    colorbar 
    shading('interp') 
    hold on 
    plot3(validx(:,numberbadpoints),validy(:,numberbadpoints),abs(displx(:,numberbadpoints)),'o','MarkerEdgeColor','k','MarkerFaceColor','g'); 
    axis([min(min(XI))-10 max(max(XI))+10 min(min(YI))-10 max(max(YI))+10]) 
    drawnow; 
 
    % get the bad point position 
 
    title(sprintf('Click on the two points for strain measurement')) 
    [badpoint]=ginput(2); 
    badpointx = badpoint(1,1); 
    badpointy = badpoint(1,2); 
    badpointx2 = badpoint(2,1); 
    badpointy2 = badpoint(2,2); 
 
    % find the point matching the given position 
    wherethehellisthispoint=abs(validx(:,numberbadpoints)-badpoint(1,1))+abs(validy(:,numberbadpoints)-badpoint(1,2)); 
    badpointnum=find(wherethehellisthispoint==min(wherethehellisthispoint)); 
    wherethehellisthispoint2=abs(validx(:,numberbadpoints)-badpoint(2,1))+abs(validy(:,numberbadpoints)-badpoint(2,2)); 
    badpointnum2=find(wherethehellisthispoint2==min(wherethehellisthispoint2)); 
 
 
    % update the figure 
    ZI=griddata(validxtemp(:,numberbadpoints),validytemp(:,numberbadpoints),displxtemp(:,numberbadpoints),XI,YI,'cubic'); 
    caxis([min(min(ZI)) max(max(ZI))]) 
    plot3(validxtemp(badpointnum,numberbadpoints),validytemp(badpointnum,numberbadpoints),displxtemp(badpointnum,numberbadpoints),'+','MarkerEdgeColor','k','MarkerFaceColor','g') 
    plot3(validxtemp(badpointnum2,numberbadpoints),validytemp(badpointnum2,numberbadpoints),displxtemp(badpointnum2,numberbadpoints),'+','MarkerEdgeColor','k','MarkerFaceColor','r') 
    hold off; 
    axis([min(min(XI))-10 max(max(XI))+10 min(min(YI))-10 max(max(YI))+10]) 
    drawnow; 
 
    epsilon1D=(displxtemp(badpointnum,:)-displxtemp(badpointnum2,:))/(validxtemp(badpointnum,1)-validxtemp(badpointnum2,1)); 
    epsilonsize=size(epsilon1D); 
    figure; plot(1:epsilonsize(1,2),epsilon1D,'.'); 
    title(['True strain versus image from two picked points']); 
    xlabel('Image number [ ]'); 
    ylabel('True Strain [ ]'); 
 
 
    selection3 = menu(sprintf('Do you want to choose 2 other points?'),'Yes','No'); 
 
    if selection3==2 
        selection40 = menu(sprintf('Do you want to save the data as a text file?'),'Yes','No'); 
        if selection40==2 
            return 
        end 
        if selection40==1 
            numimagtemp = [1:epsilonsize(1,2)]'; 
            alltemp = [numimagtemp epsilon1D']; 
            [FileNameBase,PathNameBase] = uiputfile('','Save file with image# vs. 1Dstrain'); 
            cd(PathNameBase) 
            save(FileNameBase,'alltemp','-ASCII'); 
            %             save image_1Dstrain.txt alltemp -ASCII 
            return 
        end 
    end 
    close(gcf) 
end 
%--------------------------------- 
% Measure elastic slope 
% written by Chris 
function [validx, validy,displx,disply] = strain_1D_average_func(validx, validy,displx,disply) ; % 1D strain calculation 
videoselection = menu(sprintf('Do you want to create a video?'),'Yes','No'); 
if videoselection==1 
    mkdir('videostrain') 
    cd('videostrain'); 
    Vid='Vid'; 
end 
selection50=1; 
validx_fit=validx; 
displx_fit=displx; 
minminvalidx=min(min(validx)); 
maxmaxvalidx=max(max(validx)); 
minminvalidy=min(min(validy)); 
maxmaxvalidy=max(max(validy)); 
minmindisplx=min(min(displx)); 
maxmaxdisplx=max(max(displx)); 
h= figure 
while selection50==1 
    %     figure 
    [pointnumber imagenumber]=size(displx); 
    for i=1:imagenumber; 
        plot(validx_fit(:,i),displx_fit(:,i),'o'); 
        xdata=validx_fit(:,i); 
        ydata=displx_fit(:,i); 
        if i==1 
            x(1)=0 
            x(2)=0 
        end 
        [x,resnormx,residual,exitflagx,output]  = lsqcurvefit(@linearfit, [x(1) x(2)], xdata, ydata); 
        hold on; 
        ydatafit=x(1)*xdata+x(2); 
        plot(xdata,ydatafit,'r'); 
         
        hold off 
        slope(i,:)=[i x(1)]; 
        axis([minminvalidx maxmaxvalidx minmindisplx maxmaxdisplx]) 
        xlabel('position [pixel]') 
        ylabel('displacement [pixel]') 
        title(['Displacement versus position',sprintf(' (Current image #: %1g)',i)]); 
        drawnow 
        if videoselection==1 
            u=i+10000; 
            ustr=num2str(u); 
            videoname=[Vid ustr '.jpg'] 
            saveas(h,videoname,'jpg') 
        end 
    end 
    g1 = figure, plot(slope(:,1),slope(:,2)); 
    hold on 
    plot(slope(:,1),slope(:,2),'.'); 
        xlabel('Image [ ]') 
        ylabel('True Strain [ ]') 
        title(['True Strain vs. Image #']); 
 
    selection40 = menu(sprintf('Do you want to save the data as file?'),'Yes','No'); 
    if selection40==2 
 
    end 
    if selection40==1 
        alltemp = [slope(:,1) slope(:,2)]; 
        [FileNameBase,PathNameBase] = uiputfile('','Save file with image# vs. 1Dstrain'); 
        cd(PathNameBase) 
        save(FileNameBase,'alltemp','-ASCII'); 
        %         save image_1Dstrain_avg.txt alltemp -ASCII 
    end 
 
    selection50 = menu(sprintf('Do you want to analyse a selected area again?'),'Yes','No'); 
    if selection50==2 
        clear validx_fit 
        clear displx_fit 
        return 
    end 
    if selection50==1 
        close(g1) 
        plot(validx_fit(:,imagenumber),displx_fit(:,imagenumber),'o'); 
        title(['True strain versus image from all markers']); 
        xlabel('Image number [ ]'); 
        ylabel('True Strain [ ]'); 
        prompt = {'Min. x-position:','Max. x-position:'}; 
        dlg_title = 'Regime to be analyzed in pixels'; 
        num_lines= 1; 
        def     = {'800','1200'}; 
        answer = inputdlg(prompt,dlg_title,num_lines,def); 
        minx= str2num(cell2mat(answer(1,1))); 
        maxx= str2num(cell2mat(answer(2,1))); 
        counter=0 
        clear validx_fit 
        clear displx_fit 
        selectedmarkers=find(validx(:,imagenumber)>minx  & validx(:,imagenumber)<maxx); 
        validx_fit=validx(selectedmarkers,:); 
        displx_fit=displx(selectedmarkers,:); 
        continue 
    end 
 
end 
 
 
%--------------------------------- 
% 3D mesh plotting 
% written by Chris 
function [validx, validy,displx,disply]=meshplot(validx,validy,displx,disply); 
h=figure; 
sizevalidx=size(validx); 
sizevalidy=size(validy); 
looppoints=sizevalidx(1,1); 
loopimages=sizevalidx(1,2); 
 
videoselection = menu(sprintf('Do you want to create a video?'),'Yes','No'); 
if videoselection==1 
    mkdir('video') 
    cd('video'); 
    Vid='Vid'; 
end 
gridsizex=10*round(min(min(validx))/10):10:10*round(max(max(validx))/10); 
gridsizey=10*round(min(min(validy))/10):10:10*round(max(max(validy))/10); 
[XI,YI]=meshgrid(gridsizex,gridsizey); 
minminvalidx=min(min(validx)); 
maxmaxvalidx=max(max(validx)); 
minminvalidy=min(min(validy)); 
maxmaxvalidy=max(max(validy)); 
minmindisplx=min(min(displx)); 
maxmaxdisplx=max(max(displx)); 
minmindisply=min(min(disply)); 
maxmaxdisply=max(max(disply)); 
for i=1:(loopimages-1) 
    ZI=griddata(validx(:,i),validy(:,i),displx(:,i),XI,YI,'cubic'); 
    mesh(XI,YI,ZI); hold on 
    bottomplot=ones(size(validx))*minmindisplx; 
    backyplaneplot=ones(size(validx))*maxmaxvalidy; 
    backxplaneplot=ones(size(validx))*minminvalidx; 
    plot3(validx(:,i),validy(:,i),displx(:,i),'.b'); 
    %         plot3(validx(:,i),backyplaneplot(:,i),displx(:,i),'.'); 
    plot3(backxplaneplot(:,i),validy(:,i),displx(:,i),'.g'); 
    xlabel('x-position [pixel]') 
    ylabel('y-position [pixel]') 
    zlabel('displacement [pixel]') 
    %         plot3(validx(:,i),validy(:,i),bottomplot(:,i),'.'); 
    hold off 
    title(['Displacement versus x-y-position',sprintf(' (Current image #: %1g)',i)]); 
    axis([minminvalidx maxmaxvalidx minminvalidy maxmaxvalidy minmindisplx maxmaxdisplx]) 
    drawnow 
    if videoselection==1 
        u=i+10000; 
        ustr=num2str(u); 
        videoname=[Vid ustr '.jpg'] 
        saveas(h,videoname,'jpg') 
    end 
end 
 
if videoselection==1 
    cd('..') 
end 
 
%------------------------------- 
% polyfit function 
% written by Dan slightly changed by Chris 
function [validx, validy,displx,disply]=polyfit3D(validx, validy,displx,disply); 
close all 
plot3dsurface_func(validx,validy,displx); 
 
%--------------------------------------- 
% Just plot it 
% written by Dan slightly changed by Chris 
function plot3dsurface_func(validx,validy,displx,gridstyle,cropxx,cropyy) 
 
sizevalidx=size(validx); 
looppoints=sizevalidx(1,1); 
loopimages=sizevalidx(1,2); 
gridsizex=10*round(min(min(validx))/10):10:10*round(max(max(validx))/10); 
gridsizey=10*round(min(min(validy))/10):10:10*round(max(max(validy))/10); 
[XI,YI]=meshgrid(gridsizex,gridsizey); 
ZI=griddata(validx(:,1),validy(:,1),displx(:,1),XI,YI,'cubic'); 
ZIsize=size(ZI); 
displcolor = [-7 1]; 
straincolor = [-0.005 0.03]; 
 
maxminusminvalidx=(max(max(validx))-min(min(validx))); 
maxminusminvalidy=(max(max(validx))-min(min(validy))); 
 
for i=1:(loopimages-1) 
 
    ZI=griddata(validx(:,i),validy(:,i),displx(:,i),XI,YI,'cubic'); 
    ZIsize=size(ZI); 
    epsxx = gradient(ZI,(maxminusminvalidx/ZIsize(1,1)),(maxminusminvalidy/ZIsize(1,2))); 
 
    subplot(2,1,1) 
    pcolor(XI,YI,ZI) 
    axis('equal') 
    shading('interp') 
    caxis(displcolor) 
    h1 = colorbar; 
    set(h1, 'PlotBoxAspectRatio',[2.0 10 8.0]) 
    set(h1, 'FontSize', 12); 
    title(['Raw Displacement in x-direction',sprintf(' (Current image #: %1g)',i)]); 
 
    subplot(2,1,2) 
    pcolor(XI,YI,epsxx) 
    axis('equal') 
    shading('interp') 
    caxis(straincolor) 
    h1 = colorbar; 
    set(h1, 'PlotBoxAspectRatio',[2.0 10 8.0]) 
    set(h1, 'FontSize', 12); 
    title('Raw Strain in x-direction'); 
 
    drawnow 
 
end 
 
%-------------------------------------- 
% Delete some markers 
% written by Chris 
function [validx,validy] = removepoints_func2(validx,validy) ; %delete points 
 
if exist('validx')==0 
    [validx,Pathvalidx] = uigetfile('*.mat; *.txt','Open validx.mat or validx.txt'); 
    cd(Pathvalidx); 
    validx=importdata(validx,'\t'); 
    [validy,Pathvalidy] = uigetfile('*.mat;*.txt','Open validy.mat or validy.txt'); 
    cd(Pathvalidy); 
    validy=importdata(validy,'\t'); 
end 
 
 
selectremove1 = menu(sprintf('Do you want to delete makers?'),'Yes','No'); 
if selectremove1==2 
 
    return 
end 
 
% if yes 
if selectremove1==1 
    selectionremove2=selectremove1; 
    %     figure 
    counter=0 
    sizevalidx=size(validx); 
    looppoints=sizevalidx(1,1); 
    loopimages=sizevalidx(1,2); 
    defaultimage=loopimages 
    numberbadpoints=0 
 
    while selectionremove2==1 
        counter=counter+1 
        clear xplot 
        clear sizevalidx 
        clear selectremove11 
        clear selection2 
        %         clear badpoints 
 
        sizevalidx=size(validx); 
        looppoints=sizevalidx(1,1); 
        loopimages=sizevalidx(1,2); 
 
        % update temporary matrices 
        %         displxtemp=displx; 
        validxtemp=validx; 
        validytemp=validy; 
        %         resnormxtemp=resnormx; 
 
        % get the image number from which the bad points will be chosen 
        prompt = {'From which image do you want to delete markers?'}; 
        dlg_title = 'Marker removal'; 
        num_lines= 1; 
        if numberbadpoints==0 
            defaultimage=loopimages 
        end 
        if numberbadpoints~0 
            defaultimage=numberbadpoints 
        end 
        def     = {num2str(defaultimage)}; 
        answer = inputdlg(prompt,dlg_title,num_lines,def); 
        numberbadpoints = str2num(cell2mat(answer(1,1))); 
        if numberbadpoints>loopimages 
            numberbadpoints=loopimages 
        end 
        if numberbadpoints<1 
            numberbadpoints=1 
        end 
 
        displx(:,1)=-validx(:,1)+validx(:,numberbadpoints); 
        displx(:,1)=displx(:,1)-min(displx(:,1)); 
 
        gridsizex=10*round(min(min(validx))/10):10:10*round(max(max(validx))/10); 
        gridsizey=10*round(min(min(validy))/10):10:10*round(max(max(validy))/10); 
        [XI,YI]=meshgrid(gridsizex,gridsizey); 
        ZI=griddata(validx(:,numberbadpoints),validy(:,numberbadpoints),displx(:,1),XI,YI,'cubic'); 
        epsxx = gradient(ZI,10,10); 
 
        pcolor(XI,YI,epsxx); 
        axis('equal') 
        caxis([min(min(epsxx)) max(max(epsxx))]) 
        colorbar 
        shading('interp') 
        hold on 
        plot3(validx(:,numberbadpoints),validy(:,numberbadpoints),displx(:,1),'.','MarkerEdgeColor','k','MarkerFaceColor','g'), hold off; 
        axis([min(min(XI))-10 max(max(XI))+10 min(min(YI))-10 max(max(YI))+10]) 
        drawnow; 
 
        validxtemp=validx; 
        validytemp=validy; 
        displxtemp=displx; 
        validxdelete=validxtemp; 
        validydelete=validytemp; 
        displxdelete=displxtemp; 
 
        title(sprintf('Define the region of interest.  \n  All points ouside that region will be deleted')) 
 
        [xgrid,ygrid]=ginput(2); 
        x(1,1) = xgrid(1); 
        x(1,2) = xgrid(2); 
        y(1,1) = ygrid(2); 
        y(1,2) = ygrid(1); 
 
        deletepoints=find(validxdelete(:,numberbadpoints)>min(x) & validxdelete(:,numberbadpoints)<max(x) & validydelete(:,numberbadpoints)<max(y) & validydelete(:,numberbadpoints)>min(y)); 
        [loopnum one]=size(deletepoints); 
 
        validxdelete(deletepoints,:)=[]; 
        validydelete(deletepoints,:)=[]; 
 
        plot3(validxtemp(:,numberbadpoints),validytemp(:,numberbadpoints),displxtemp(:,1),'o','MarkerEdgeColor','k','MarkerFaceColor','g'), hold off; 
 
        % update temporary data matrices; delete bad points 
        displxtemp(deletepoints,:)=[]; 
        validxtemp(deletepoints,:)=[]; 
        validytemp(deletepoints,:)=[]; 
 
        % update the figure 
        gridsizex=10*round(min(min(validxtemp))/10):10:10*round(max(max(validxtemp))/10); 
        gridsizey=10*round(min(min(validytemp))/10):10:10*round(max(max(validytemp))/10); 
        [XI,YI]=meshgrid(gridsizex,gridsizey); 
        ZI=griddata(validxtemp(:,numberbadpoints),validytemp(:,numberbadpoints),displxtemp(:,1),XI,YI,'cubic'); 
        epsxx = gradient(ZI,10,10); 
        pcolor(XI,YI,epsxx); 
        axis('equal') 
        caxis([min(min(epsxx)) max(max(epsxx))]) 
        colorbar 
        shading('interp') 
        hold on 
        plot3(validxtemp(:,numberbadpoints),validytemp(:,numberbadpoints),displxtemp(:,1),'o','MarkerEdgeColor','k','MarkerFaceColor','g'), hold off; 
        axis([min(min(XI))-10 max(max(XI))+10 min(min(YI))-10 max(max(YI))+10]) 
        drawnow; 
 
        % delete point permanently? 
        selectremove3 = menu(sprintf('Do you want to delete these markers permanently?'),'Yes','No'); 
        if selectremove3==1 
            displx=displxtemp; 
            validx=validxtemp; 
            validy=validytemp; 
        end 
        if selectremove3==2 
            displxtemp=displx; 
            validxtemp=validx; 
            validytemp=validy; 
        end 
        selectremove2 = menu(sprintf('Do you want to mark another bad point?'),'Yes','No'); 
        if selectremove2==2 
            clear displx; 
            validxfirst=zeros(size(validx)); 
            validxfirst=validx(:,1)*ones(1,sizevalidx(1,2)); 
            displx=validx-validxfirst; 
            return 
        end 
    end 
end