def __init__(self, images, noise_level_function=None, nStd=4,
save_ste_indices=False, calcVariance=False, dtype=float):
self.save_ste_indices = save_ste_indices
i1 = imread(images[0], 'gray', dtype=dtype)
i2 = imread(images[1], 'gray')
self.mask_STE = None
if save_ste_indices:
self.mask_STE = np.zeros(shape=i1.shape, dtype=bool)
self.mma = MaskedMovingAverage(shape=i1.shape,
calcVariance=calcVariance,
dtype=i1.dtype)
# MINIMUM OF BOTH IMAGES:
self.mma.update(np.min((i1, i2), axis=0))
if noise_level_function is None:
noise_level_function = oneImageNLF(self.mma.avg)[0]
self.noise_level_function = noise_level_function
self.threshold = noise_level_function(self.mma.avg) * nStd
self.addImage(np.max((i1, i2), axis=0))
for i in images[2:]:
self.addImage(imread(i, 'gray'))
def __init__(self,
images,
noise_level_function=None,
nStd=4,
save_ste_indices=False,
calcVariance=False,
dtype=float):
self.save_ste_indices = save_ste_indices
i1 = imread(images[0], 'gray', dtype=dtype)
i2 = imread(images[1], 'gray')
self.mask_STE = None
if save_ste_indices:
self.mask_STE = np.zeros(shape=i1.shape, dtype=bool)
self.mma = MaskedMovingAverage(shape=i1.shape,
calcVariance=calcVariance,
dtype=i1.dtype)
# MINIMUM OF BOTH IMAGES:
self.mma.update(np.min((i1, i2), axis=0))
if noise_level_function is None:
noise_level_function = oneImageNLF(self.mma.avg)[0]
self.noise_level_function = noise_level_function
self.threshold = noise_level_function(self.mma.avg) * nStd
self.addImage(np.max((i1, i2), axis=0))
for i in images[2:]:
self.addImage(imread(i, 'gray'))
def __init__(self,
images,
noise_level_function=None,
nStd=4,
save_ste_indices=False):
self.save_ste_indices = save_ste_indices
self.mask_STE = None
i1 = imread(images[0], 'gray')
i2 = imread(images[1], 'gray')
if save_ste_indices:
self.mask_STE = np.zeros(shape=i1.shape, dtype=bool)
#MINIMUM OF BOTH IMAGES:
self.noSTE = m = np.min((i1, i2), axis=0)
if noise_level_function is None:
noise_level_function = oneImageNLF(m)[0]
self.noise_level_function = noise_level_function
self.threshold = noise_level_function(m) * nStd
self._c = 2
self.addImage(np.max((i1, i2), axis=0))
for i in images[2:]:
self.addImage(imread(i, 'gray'))
def flatFieldFromCalibration(bgImages, images, calcStd=False):
'''
returns a flat-field correction map
through conditional average of multiple images reduced by a background image
calcStd -> set to True to also return the standard deviation
'''
#AVERAGE BACKGROUND IMAGES IF MULTIPLE ARE GIVEN:
if ( type(bgImages) in (tuple, list)
or type(bgImages) is np.ndarray and bgImages.ndim == 3 ) :
if len(bgImages) > 1:
avgBg = averageSameExpTimes(bgImages)
else:
avgBg = imread(bgImages[0])
else:
avgBg = imread(bgImages)
i0 = imread(images[0]) - avgBg
noise_level_function,_ = oneImageNLF(i0)
m = MaskedMovingAverage(shape=i0.shape, calcVariance=calcStd)
m.update(i0)
for i in images[1:]:
i = imread(i)
thresh = m.avg - noise_level_function(m.avg) * 3
m.update(i, i>thresh)
mx = m.avg.max()
if calcStd:
return m.avg/mx, m.var**0.5/mx
return m.avg/mx
def flatFieldFromCalibration(bgImages, images, calcStd=False):
'''
returns a flat-field correction map
through conditional average of multiple images reduced by a background image
calcStd -> set to True to also return the standard deviation
'''
#AVERAGE BACKGROUND IMAGES IF MULTIPLE ARE GIVEN:
if (type(bgImages) in (tuple, list)
or type(bgImages) is np.ndarray and bgImages.ndim == 3):
if len(bgImages) > 1:
avgBg = averageSameExpTimes(bgImages)
else:
avgBg = imread(bgImages[0])
else:
avgBg = imread(bgImages)
i0 = imread(images[0]) - avgBg
noise_level_function, _ = oneImageNLF(i0)
m = MaskedMovingAverage(shape=i0.shape, calcVariance=calcStd)
m.update(i0)
for i in images[1:]:
i = imread(i)
thresh = m.avg - noise_level_function(m.avg) * 3
m.update(i, i > thresh)
mx = m.avg.max()
if calcStd:
return m.avg / mx, m.var**0.5 / mx
return m.avg / mx
def SNR(img1, img2=None, bg=None,
noise_level_function=None,
constant_noise_level=False,
imgs_to_be_averaged=False):
'''
Returns a signal-to-noise-map
uses algorithm as described in BEDRICH 2016 JPV (not jet published)
:param constant_noise_level: True, to assume noise to be constant
:param imgs_to_be_averaged: True, if SNR is for average(img1, img2)
'''
# dark current subtraction:
img1 = np.asfarray(img1)
if bg is not None:
img1 = img1 - bg
# SIGNAL:
if img2 is not None:
img2_exists = True
img2 = np.asfarray(img2) - bg
# signal as average on both images
signal = 0.5 * (img1 + img2)
else:
img2_exists = False
signal = img1
# denoise:
signal = median_filter(signal, 3)
# NOISE
if constant_noise_level:
# CONSTANT NOISE
if img2_exists:
d = img1 - img2
# 0.5**0.5 because of sum of variances
noise = 0.5**0.5 * np.mean(np.abs((d))) * F_RMS2AAD
else:
d = (img1 - signal) * F_NOISE_WITH_MEDIAN
noise = np.mean(np.abs(d)) * F_RMS2AAD
else:
# NOISE LEVEL FUNCTION
if noise_level_function is None:
noise_level_function, _ = oneImageNLF(img1, img2, signal)
noise = noise_level_function(signal)
noise[noise < 1] = 1 # otherwise SNR could be higher than image value
if imgs_to_be_averaged:
# SNR will be higher if both given images are supposed to be averaged:
# factor of noise reduction if SNR if for average(img1, img2):
noise *= 0.5**0.5
# BACKGROUND estimation and removal if background not given:
if bg is None:
bg = getBackgroundLevel(img1)
signal -= bg
snr = signal / noise
# limit to 1, saying at these points signal=noise:
snr[snr < 1] = 1
return snr
def flatFieldFromCloseDistance2(images, bgImages=None, calcStd=False,
nlf=None, nstd=6):
'''
Same as [flatFieldFromCloseDistance]. Differences are:
... single-time-effect removal included
... returns the standard deviation of the image average [calcStd=True]
Optional:
-----------
calcStd -> set to True to also return the standard deviation
nlf -> noise level function (callable)
nstd -> artefact needs to deviate more than [nstd] to be removed
'''
if len(images) > 1:
# start with brightest images
def fn(img):
img = imread(img)
s0, s1 = img.shape[:2]
# rough approx. of image brightness:
return -img[::s0 // 10, ::s1 // 10].min()
images = sorted(images, key=lambda i: fn(i))
avgBg = getBackground2(bgImages, images[1])
i0 = imread(images[0], dtype=float) - avgBg
i1 = imread(images[1], dtype=float) - avgBg
if nlf is None:
nlf = oneImageNLF(i0, i1)[0]
det = SingleTimeEffectDetection(
(i0, i1), nlf, nStd=nstd, calcVariance=calcStd)
for i in images[1:]:
i = imread(i)
# exclude erroneously darker areas:
thresh = det.noSTE - nlf(det.noSTE) * nstd
mask = i > thresh
# filter STE:
det.addImage(i, mask)
ma = det.noSTE
else:
ma = imread(images[0], dtype=float) - avgBg
# fast artifact free maximum:
mx = median_filter(ma[::10, ::10], 3).max()
if calcStd:
return ma / mx, det.mma.var**0.5 / mx
return ma / mx
def SNR(img1, img2=None, bg=0,
noise_level_function=None,
constant_noise_level=False,
imgs_to_be_averaged=False):
'''
Returns a signal-to-noise-map
uses algorithm as described in BEDRICH 2016 JPV (not jet published)
:param constant_noise_level: True, to assume noise to be constant
:param imgs_to_be_averaged: True, if SNR is for average(img1, img2)
'''
#dark current subtraction:
img1 = np.asfarray(img1) - bg
if img2 is not None:
img2_exists = True
img2 = np.asfarray(img2) - bg
#signal as average on both images
signal = 0.5*(img1+img2)
else:
img2_exists = False
signal = img1
#denoise:
signal = median_filter(signal, 3)
if constant_noise_level:
if img2_exists:
#0.5**0.5 because of sum of variances
noise = 0.5**0.5 *np.mean(np.abs((img1-img2)))*F_RMS2AAD
else:
d = (img1-signal)*F_DiffTHroughMedian
noise = np.mean(np.abs(d))*F_RMS2AAD
else:
if noise_level_function is None:
noise_level_function, _ = oneImageNLF(img1, img2, signal)
noise = noise_level_function(signal)
noise[noise<1]=1#otherwise SNR could be higher than image value
if imgs_to_be_averaged:
#factor of noise reduction if SNR if for average(img1, img2):
noise *= 0.5**0.5
#background estimation and removal if background not given:
if bg is 0:
bg = getBackgroundLevel(img1)
signal -= bg
snr = signal/noise
#limit to 1, saying at these points signal=noise:
snr[snr<1]=1
return snr
def __init__(self, images, noise_level_function=None, nStd=4,
save_ste_indices=False):
self.save_ste_indices = save_ste_indices
self.mask_STE = None
i1 = imread(images[0], 'gray')
i2 = imread(images[1], 'gray')
if save_ste_indices:
self.mask_STE = np.zeros(shape=i1.shape, dtype=bool)
#MINIMUM OF BOTH IMAGES:
self.noSTE = m = np.min((i1,i2),axis=0)
if noise_level_function is None:
noise_level_function = oneImageNLF(m)[0]
self.noise_level_function = noise_level_function
self.threshold = noise_level_function(m)*nStd
self._c = 2
self.addImage(np.max((i1,i2),axis=0))
for i in images[2:]:
self.addImage(imread(i, 'gray'))