from imageio import imread
import matplotlib.pyplot as plt
import numpy as np

filename = 'mona.png'
f = imread(filename,as_gray=True)

# N: antall rader i bildet (matrise), M: antall kolonner i bildet
N,M = f.shape

f_out = np.zeros((N,M))

# Sett første rad i ut-bildet lik første rad i originalbilde.
# Dette gjøres fordi for-loopen starter på i = 1.
f_out[0,:] = f[0,:]

# La i starte på 1 og ikke 0 fordi f[-1,j] vil gi differansen
# mellom første og siste rad i originalbildet.
# Det går også fint å la programmet ta differansen mellom første og siste rad - så
# lenge det var et bevisst valg.
for i in range(1,N):
    for j in range(M):
        f_out[i,j] = f[i,j] - f[i-1,j]

bias = 128 # brukt bare for fremvising av bildet

plt.figure()
plt.title("med bias, uten endring av kontrast")
plt.imshow(f_out + bias,cmap='gray',vmin=0,vmax=255)

plt.figure()
plt.title("med bias, med endring av kontrast")
plt.imshow(f_out*1.5 + bias,cmap='gray',vmin=0,vmax=255)

# Bilde uten bias . trenger strengt tatt ikke dette da matplotlib kan tilpasse seg bildets verdier
plt.figure()
plt.title("uten bias, uten endring av kontrast")
plt.imshow(f_out, cmap='gray')

# For å kunne se at vi gjør en kontrastendring, kan vi spesifisere i matplotlib at
# vi ønsker å fremvise bildet innenfor f_out sine verdiers range til sammenligning.
# Hvis vi ikke hadde gjort dette, ville matplotlib mappet gråtone instensitetene
# i forhold til det konstrastendrete bildet sine verdier, og derav ville vi ikke kunne se noen endring.
plt.figure()
plt.title("uten bias, med endring av kontrast")
plt.imshow(f_out*1.5,cmap='gray',vmin=np.min(f_out), vmax=np.max(f_out))

plt.show()

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
print("deloppgave a: y =",y,'\n')

# b)
y_ = y*f/(s-f)
print("deloppgave b: y' =",y_,'\n')

# c)
T_o = y_
f_o = 1/T_o
print("deloppgave c: T_o = %g, f_o = 1/T_o = %g\n"%(T_o,f_o))

# d)
grense = T_o/2
print("deloppgave d: minste avstand mellom samplingselementer: %g\n"%grense)

# e)
b = 16*1e-3 # m
l = 24*1e-3 # m
print("deloppgave e: antall elementer for å oppfylle samplingsteoremet: %g x %g \n"%(b/grense,l/grense))

# f)
print("deloppgave f: \nb): y' doblet\nc): T_o doblet,f_o halvparten\nd): doblet minste avstand\n")

# g)
print("deloppgave g: bedre fordi minste avstand for å skille to punkter vil bli mindre")

deloppgave a: y = 0.00030500000000000004

deloppgave b: y' = 3.080808080808081e-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 å 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 å skille to punkter vil bli mindre

from imageio import imread
import matplotlib.pyplot as plt
import numpy as np

f = imread('mona.png',as_gray=True)

for ii in range(1,8,2):
    bit = ii

    quantized = f//2**(8-bit) # Operasjonen // betyr at vi gjør heltallsdivisjon.

    plt.figure() # lag nytt vindu
    plt.title("bit = %d, antall verdier = %d"%(bit, np.max(quantized) + 1))
    plt.imshow(quantized,cmap='gray')

plt.show()

tid = 2*60*60 # sekunder.
bits = 24
byte = bits/8
print("%g bytes"%(50*1080*1920*byte*tid))

from imageio import imread
import matplotlib.pyplot as plt
import numpy as np

f = imread('mona.png',as_gray=True)


noiseFactor = 10
N,M = f.shape
fNoisy = f + noiseFactor*np.random.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 - np.min(fNoisy)) / (np.max(fNoisy)- np.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 in range(1,8,2):
    bit = ii
    quantized = f//2**(8-bit)

    plt.figure()
    plt.title("bit = %d, antall mulige verdier = %d"%(bit, np.max(quantized)+1))
    plt.imshow(quantized,cmap='gray')

plt.show()