Hologram.m

Go to the documentation of this file.

 
classdef Hologram < handle
    
    properties (Access = public)
        
        displayProgress = true;         
        send2SLMWhenFinished = false;   
        saveImageWhenFinished = false;  
        
        pixelX;
        pixelY;
        pixelPitch;             
        grayLevels;             
        angleCalibrationFactor; 
        lensCalibrationFactor;  
        wavelength;             
        adaptSize = 'original'; 
        
        inputPhase;             
        inputAmplitude;        
        farFieldPhase;          
        farFieldAmplitude;      
        displayDuration;        
        
        savePath;               
        saveName = "";          
        saveNo=0;               
        
        inputBeam_source = 'calculated';   
        inputBeamDiameter=1;%[mm] 
        
        %Algorithmen:
        %Hier werden die Eingabeparameter aller zur Auswahl stehender
        %Algorithmen gespeichert
        %Der 'add####'-Parameter gibt jeweils an, ob der Algorithmus bei
        %der Berechnung ausgeführt wird.
        
        addPrismAndLens = false;
        phiX = 0;              
        phiY = 0;               
        z = 0;                  
        
        addMultispot = false;   
        spotList = zeros(8,4);  
        
        addAxicon = false;
        alpha = 0;             
        ax_x0 = 0;              
        ax_y0 = 0;              
        
        addVortex = false;
        charge = 1;             
        vo_x0 = 0;              
        vo_y0 = 0;              
                
        addGerchbergSaxton = false;
        gs_iteration = 1;                                       
        gs_startPhase = 'random';     
        gs_quadraticParameter = 1;                              
        
        gs_image;                                               
        gs_resizeMode = 'stretch';
        gs_color = 'grayValues'; 
        gs_limitGrayLevel = 128;                                
        gs_invertColors = false;                                
        gs_convergence;                                         
        gs_plot = false;                                        
        
        
        %G>enetischer Algorithmus
        addGeneticAlgorithm = false;
        ga_startPhase = 'random'; 
        ga_population=1;                                       
        ga_mutationProb=1;
        ga_elite=0; 
        ga_iteration=1;                                         
        ga_imageDepth = 8;                                     
        ga_bitCode = 'binary'; 
        
        ga_image;%#s.o.                                         
        ga_resizeMode = 'original';
        ga_color = 'grayValues'; 
        ga_limitGrayLevel = 128;                                
        ga_invertColors = false;                                
        ga_evaluation = 'calculated'; 
        ga_convergence = 0;                                    
        ga_plot = false;                                       
        
        addRandomPhase = false;
        maximumRandomPhase = 0; %[%]                            
        
        addZernike = false;
        weighting = zeros(13);                                 
        
        addAperture = false;
        r_i=0; %[mm]                                            
        r_a=0; %[mm]                                            
        
    end
    
    
    
    methods
        function obj = Hologram()
            
            %Standardspeicherort für Hologrammbilder
            strcat(evalin('base','matlabPath'),'\data\HologramImages'); 
            
            try
                obj.pixelX = evalin('base', 'SLM.pixelX');
                obj.pixelY = evalin('base', 'SLM.pixelY');
                obj.pixelPitch = evalin('base', 'SLM.pixelPitch');
                obj.angleCalibrationFactor =  evalin('base', 'SLM.angleCalibrationFactor');
                obj.lensCalibrationFactor =  evalin('base', 'SLM.lensCalibrationFactor');
            catch
                disp('Hologram size not defined!');
            end
            
            try
                obj.wavelength =  evalin('base', 'Laser.wavelength;');
                obj.inputBeamDiameter =  evalin('base', 'Laser.rawBeamDiameter;');
            catch
                disp('Wavelength not defined!');
            end
        end
 
        function matrix = distanceFromCenter(obj)
            
            matrix=zeros(obj.pixelX,obj.pixelY);
            for ki=1:obj.pixelX
                for kj=1:obj.pixelY
                    % Abstand zum Bildmittelpunkt
                    dx= obj.pixelPitch*(-obj.pixelX*0.5-0.5+ki);
                    dy= obj.pixelPitch*(-obj.pixelY*0.5-0.5+kj);
                    matrix(ki,kj) = sqrt((dx).^2+(dy).^2);
                end
            end
        end
 
        function matrix = distanceFromPoint(obj,x0,y0)
            
            matrix=zeros(obj.pixelX,obj.pixelY);
            for ki=1:obj.pixelX
                for kj=1:obj.pixelY
                    dx= obj.pixelPitch*(-obj.pixelX*0.5-0.5+ki)-x0;
                    dy= obj.pixelPitch*(-obj.pixelY*0.5-0.5+kj)-y0;
                    matrix(ki,kj) = sqrt((dx).^2+(dy).^2);
                end
            end
        end
        
        function [array] = angle(obj,x0, y0)
            %#auf Bug prüfen!
            %ALLES IN mm!
            array=zeros(obj.pixelX,obj.pixelY);
            for ki=1:obj.pixelX
                for kj=1:obj.pixelY
                    %Abstand zum Bildmittelpunkt
                    dx= obj.pixelPitch*(-obj.pixelX*0.5-0.5+ki)-x0;
                    dy= obj.pixelPitch*(-obj.pixelY*0.5-0.5+kj)-y0;
                    if(dx>0)
                        array(ki,kj) = atand(dy/dx)+180;
                    else
                        array(ki,kj) = atand(dy/dx);
                    end
                end
            end
        end
 
        function [image] = beamImage(obj, source, name)
            
            %Source = 'calculated', 'fromFile', 'measured'
            %Name = Strahlform bei Calculated source, Dateiname bei
            %fromFile
            if(source == "calculated") %Berechnung eines idealen Gaussstrahls
                if(name == "gauss")
                    d0 = evalin('base', 'Laser.rawBeamDiameter;');
                    r=obj.distanceFromCenter();
                    image = gaussmf(r,[d0/4 0]);
                    image = Aperture(image, 0,evalin('base', 'Laser.aperture;'));
                else
                    disp("Error, unknown beam shape.");
                end
            elseif(source == "fromFile") %Nutzung eines zuvor aufgenommenen/berechneten Strahlprofils
                disp("#METHODE NOCH NICHT IMPLEMENTIERT");
            elseif(source == "measured") %Aufnahme eines Strahlprofils mit der Kamera
                disp("#METHODE NOCH NICHT IMPLEMENTIERT");
            end
            
        end
        
        function hologram = calculate (obj)            
            
            %später Fortschritt ausgeben
            tic;
            
            %Schritt 0: Speicherplatz reservieren
            hologram = zeros(obj.pixelX,obj.pixelY); %Das Hologramm ist eine Matrix aus Komplexen Zahlen, bei denen der Betrag die Intensität und der Winkel die Phase angibt
            
            
            %Schritt 1: Hologramm berechnen
            if(obj.addPrismAndLens)
                obj.progress('Calculating Prism & Lens');
                hologram = hologram + angle(Prism_and_Lens(obj.phiX,obj.phiY,obj.z)); 
            end
            if(obj.addMultispot)
                obj.progress('Calculating Multispot');
                hologram = hologram + angle(Multispot(obj.spotList));
            end
            if(obj.addAxicon)
                obj.progress('Calculating Axicon');
                hologram = hologram + angle(Axicon_Hologram(obj.alpha,obj.ax_x0,obj.ax_y0));
            end
            if(obj.addVortex)
                obj.progress('Calculating Vortex');
                hologram = hologram + angle(Vortex_Hologramm(obj.charge, obj.vo_x0, obj.vo_y0));
            end
            if(obj.addRandomPhase)
                obj.progress('Calculating RandomPhase');
                hologram = hologram + angle(Random_Phase(obj.maximumRandomPhase));
            end
            if(obj.addZernike)
                obj.progress('Calculating Zernike Polynoms');
                hologram = hologram + angle(Zernike(obj.weighting));
            end
            if(obj.addGerchbergSaxton)
                obj.progress('Calculating Gerchberg & Saxton Algorithm');
                hologram = hologram + angle(Gerchberg_Saxton());
            end
            if(obj.addGeneticAlgorithm)
                obj.progress('Calculating Genetic Algorithm');
                hologram = hologram + angle(Genetic_Algorithm());
            end
            if(obj.addAperture)
                obj.progress('Calculating Aperture');
                hologram = Aperture(hologram,obj.r_i,obj.r_a);
            end
            %Zeit
            obj.progress('Calculation finished');
 
            
            
            %Schritt 2: Variablen speichern und für GUI vorbereiten
            hologramPlane = abs(obj.beamImage(obj.inputBeam_source, "gauss")).*exp(1i*(hologram));%##gauss ggf. später noch ändern
            imagePlane = Hologram_FFT(hologramPlane);%####Fehler?    Berechnung der Fernfeldintensitätsverteilung mittels FFT 
            %Speichern der Ergebnisse als Graustufenmatrix            
            obj.inputPhase = Phase_Image(hologramPlane);
            obj.inputAmplitude = Amplitude_Image(hologramPlane);
            obj.farFieldPhase = Phase_Image(imagePlane);
            obj.farFieldAmplitude = Amplitude_Image(imagePlane);
            
            %Schritt 3: An SLM senden
            if(obj.send2SLMWhenFinished)
                SLM = evalin('base', 'SLM;');
                SLM.sendImage(obj.inputPhase);
            end
            
            %Schritt 4: Bild ggf. Speichern
            if(obj.saveImageWhenFinished)
                obj.saveImages();
            end
            
            %figure();
            %imshow(Phase_Image(hologramPlane));
        end
 
        function saveImages (obj)
 
            obj.savePath = strcat(evalin('base', 'path'), '\HologramImages');
            obj.saveNo = obj.saveNo + 1;
            pathInputPhase = strcat(obj.savePath,'\',obj.saveName,'inputPhase',obj.saveName,'_',num2str(obj.saveNo),'.png');
            imwrite(obj.inputPhase,pathInputPhase);
            pathInputAmplitude = strcat(obj.savePath,'\',obj.saveName,'inputAmplitude',obj.saveName,'_',num2str(obj.saveNo),'.png');
            imwrite(obj.inputAmplitude,pathInputAmplitude);
            pathFarfieldPhase = strcat(obj.savePath,'\',obj.saveName,'farFieldPhase',obj.saveName,'_',num2str(obj.saveNo),'.png');
            imwrite(obj.farFieldPhase,pathFarfieldPhase);
            pathFarfieldAmplitude = strcat(obj.savePath,'\',obj.saveName,'farFieldAmplitude',obj.saveName,'_',num2str(obj.saveNo),'.png');
            imwrite(obj.farFieldAmplitude,pathFarfieldAmplitude);
        end
 
        %Gibt den Fortschritt der Berechnung im Command Window von Matlab aus
           
        function progress(obj,message)            
            if(obj.displayProgress)
                disp(strcat(num2str(toc/60),' min: ',message)) 
            end
        end
    end
    
    methods (Static)
        
        function calc(list)
            
            
            storage = evalin('base','Hologram'); %Das aktuell in der Workspace gespeicherte Hologramm wird hiermit vorm Überschreiben geschützt
            for n = 1:1:size(list,1)
                %Die einzelnen Hologramme in der Liste werden nacheinander
                %berechnet
                assignin('base','Hologram',list(n))
                evalin('base','Hologram.calculate();');
            end
            assignin('base','Hologram',storage); %Das zuvor gespeicherte Hologramm wird wieder in den Workspace gesetzt
        end
        
        function sayHi()
        disp('Hi')
        end
    end
end