img = imread('mona.png');
[N,M] = size(img); 

f_out = zeros(N,M);
for i = 2:N 
    for j = 1:M 
        f_out(i,j) = f(i,j) - f(i-1, j);
    end
end

% Bilde med bias (merk at dette er noedvendig _kun_ hvis du bruker image
bias = 128;

figure()
imshow(f_out + bias, [])
colormap(gray(256))

% Bilde uten bias, fremvist ved bruk av imagesc (ikke noedvendig med bias)
figure()
imagesc(f_out)
colormap('gray')

D = 10*1e-3;    % m
f = 50*1e-3;    % m
s = 5;          % m
lmb = 500*1e-9; % m

% a)
y = s*1.22*lmb/D;
fprintf('deloppgave a: y = %g \n',y);

% b)
y_ = y*f/(s-f);
fprintf('deloppgave b: y = %g \n',y_)

% c)
T_o = y_;
f_o = 1/T_o;
fprintf('deloppgave c: T_o = %g, f_o = 1/T_o = %g \n',T_o,f_o)

% d)
grense = T_o/2;
fprintf('deloppgave d: minste avstand mellom samplingselementer: %g\n', grense)

% e)
b = 16*1e-3; % m
l = 24*1e-3; % m
fprintf('deloppgave e: antall elementer for aa oppfylle samplingsteoremet: %g x %g \n',b/grense,l/grense)

% f)
fprintf('deloppgave f: \nb): y'' doblet\nc): T_o doblet, f_o halvparten\nd): doblet minste avstand\n')

% g)
fprintf('deloppgave g: bedre fordi minste avstand for aa skille to punkter vil bli mindre\n')

deloppgave a: y = 0.000305
deloppgave b: y = 3.08081e-06
deloppgave c: T_o = 3.08081e-06, f_o = 1/T_o = 324590
deloppgave d: minste avstand mellom samplingselementer: 1.5404e-06
deloppgave e: antall elementer for aa oppfylle samplingsteoremet: 10386.9 x 15580.3
deloppgave f:
b): y' doblet
c): T_o doblet, f_o halvparten
d): doblet minste avstand
deloppgave g: bedre fordi minste avstand for aa skille to punkter vil bli mindre

f = double(imread('mona.png')); % double for at divisjon ikke avrunder verdier 

for ii = 1:2:8
    bit = ii; 
    f_requantized = floor(f./(2^(8-bit))); % floor kan brukes her til aa 
                                           % avrunde verdiene som om 
                                           % heltallsdivisjon har blitt utfoert 
                                           % paa dette bildet. 

    figure()
    imagesc(f_requantized); colormap('gray');
    title(sprintf('bit = %d, antall verdier = %d', bit, max(f_requantized(:))+1))
end

tid = 2*60*60; % sekunder 
bits = 24; 
byte = bits/8;
fprintf('%g bytes\n', 50*1080*1920*byte*tid)

f = imread('mona.png');

noiseFactor = 10;
[N,M] = size(f);
fNoisy = double(f) + noiseFactor .* randn(N,M); 

% Nå kan fNoisy ha verdier over og under [0,255].
% Det er mulig å transformere fNoisy  slik at minste og største verdi til fNoisy
% blir henholdsvis 0 og 255.
% Transformasjonen kommer vi tilbake til senere i emnet:
fNoisy = (fNoisy - min(fNoisy(:))) ./ (max(fNoisy(:))- min(fNoisy(:))) .* 255;

% Merk at i denne oppgaven er det viktigste at du får til at bildet
% kan ha opp til 2**bit antall verdier

for ii = 1:2:8
    bit = ii; 
    f_requantized = floor(fNoisy./(2^(8-bit))); 
    
    % Vis resultat:
    figure()
    imagesc(f_requantized); colormap('gray');
    title(sprintf('bit = %d, antall mulige verdier = %d', bit, max(f_requantized(:))+1))
end