def _apply_median_filter(self, kernel=(3, 3)):
"""
apply a median filter to the data to remove extreme outliers
kernel is (station, frequency)
"""
if self.ellipse_colorby == "phimin":
color_array = np.array([rpt.residual_pt.phimin[0] for rpt in self.residual_pt_list])
filt_array = sps.medfilt2d(color_array, kernel_size=kernel)
for ss in range(filt_array.shape[0]):
self.residual_pt_list[ss].residual_pt.phimin[0] = filt_array[ss]
elif self.ellipse_colorby == "phimax":
color_array = np.array([rpt.residual_pt.phimax[0] for rpt in self.residual_pt_list])
filt_array = sps.medfilt2d(color_array, kernel_size=kernel)
for ss in range(filt_array.shape[0]):
self.residual_pt_list[ss].residual_pt.phimax[0] = filt_array[ss]
elif self.ellipse_colorby == "skew":
color_array = np.array([rpt.residual_pt.beta[0] for rpt in self.residual_pt_list])
filt_array = sps.medfilt2d(color_array, kernel_size=kernel)
for ss in range(filt_array.shape[0]):
self.residual_pt_list[ss].residual_pt.beta[0] = filt_array[ss]
# --> need to do azimuth for all
color_array = np.array([rpt.residual_pt.azimuth[0] for rpt in self.residual_pt_list])
filt_array = sps.medfilt2d(color_array, kernel_size=kernel)
for ss in range(filt_array.shape[0]):
self.residual_pt_list[ss].residual_pt.azimuth[0] = filt_array[ss]
def _apply_median_filter(self, kernel=(3, 3)):
"""
apply a median filter to the data to remove extreme outliers
kernel is (station, frequency)
"""
filt_phimin_arr = sps.medfilt2d(self.rpt_array['phimin'],
kernel_size=kernel)
filt_phimax_arr = sps.medfilt2d(self.rpt_array['phimax'],
kernel_size=kernel)
filt_skew_arr = sps.medfilt2d(self.rpt_array['skew'],
kernel_size=kernel)
filt_azimuth_arr = sps.medfilt2d(self.rpt_array['azimuth'],
kernel_size=kernel)
self.rpt_array['phimin'] = filt_phimin_arr
self.rpt_array['phimax'] = filt_phimax_arr
self.rpt_array['skew'] = filt_skew_arr
self.rpt_array['azimuth'] = filt_azimuth_arr
self.rpt_array['geometric_mean'] = np.sqrt(abs(filt_phimin_arr*\
filt_phimax_arr))
print 'Applying Median Filter with kernel {0}'.format(kernel)
def spatial_smooth(
self,
kernel=None,
convbeam=True,
spatial_smooth=None,
spectral_smooth=None,
niter=1
):
"""
Smooth the noise estimate in the spatial dimension. Two
components: median smoothing and convolving with the beam.
"""
# Manually median filter (square box)
if kernel is not None:
print "Median filtering"
self.spatial_norm = ssig.medfilt2d(self.spatial_norm,
kernel_size=kernel)
data = self.cube.filled_data[:].astype('=f')
if self.spatial_norm is None:
self.spatial_norm = np.ones(data.shape[-2:])
self.spectral_norm = np.ones((data.shape[0]))
for count in range(niter):
scale = self.scale_cube
snr = data/scale
self.spatial_norm = nanstd(snr,axis=0)*self.spatial_norm
if self.beam is not None:
if self.astropy_beam_flag:
beam = self.beam
else:
beam = self.beam.as_kernel(get_pixel_scales(self.cube.wcs))
self.spatial_norm = convolve_fft(self.spatial_norm,
beam,
interpolate_nan=True,
normalize_kernel=True)
if spatial_smooth is not None:
self.spatial_norm = ssig.medfilt2d(self.spatial_norm,
kernel_size=spatial_smooth)
snr = data/self.scale_cube
self.spectral_norm = nanstd(snr.reshape((snr.shape[0],
snr.shape[1]*
snr.shape[2])),
axis=1)*self.spectral_norm
if spectral_smooth is not None:
self.spectral_norm = ssig.medfilt(self.spectral_norm,
kernel_size=spectral_smooth)
self.spectral_norm[np.isnan(self.spectral_norm) | (self.spectral_norm==0)]=1.
self.spatial_norm[np.isnan(self.spatial_norm) | (self.spatial_norm==0)]=1.
self.spatial_norm[~self.spatial_footprint]=np.nan
### THIS IS ALREADY SET IN calculate_scale
# self.distribution_shape=(0,self.scale)
return
def convert_cloud_to_fmask(raster):
from numpy.core.numerictypes import byte
z, y, x = raster.shape
fmask = numpy.zeros((y, x)).astype(byte) # FMASK_LAND
fmask = numpy.where (raster[0, :, :] > 100, FMASK_CLOUD, fmask)
fmask = numpy.where (raster[0, :, :] < 100, FMASK_CLOUD_SHADOW, fmask)
fmask = numpy.where (raster[0, :, :] == 0, FMASK_LAND, fmask)
fmask = numpy.where (raster[0, :, :] == -999.0, FMASK_OUTSIDE, fmask)
fmask = signal.medfilt2d(fmask * 1.0, kernel_size=3)
fmask = signal.medfilt2d(fmask * 1.0, kernel_size=5)
return fmask
def speckle_filter(self, filter_name, ws):
"""
Filter the image using 'median' filtering methods
"""
if filter_name == 'median':
# filter the image using median filter
self.SigmaHHmf = medfilt2d(self.SigmaHH, kernel_size=ws)
self.SigmaHVmf = medfilt2d(self.SigmaHV, kernel_size=ws)
self.SigmaVHmf = medfilt2d(self.SigmaVH, kernel_size=ws)
self.SigmaVVmf = medfilt2d(self.SigmaVV, kernel_size=ws)
return self.SigmaHHmf, self.SigmaHVmf, \
self.SigmaVHmf, self.SigmaVVmf
else:
print 'Please specify the name of the filter: "median"'
def rc_focus_check(files):
fpos = []
metrics = []
for fn in files:
F = pf.open(fn)
dat,hdr = F[0].data, F[0].header
dat = dat[1200:1900,1200:1900]
dat -= np.median(dat)
md = signal.medfilt2d(dat)
bad = (dat-md)/md > 5
dat[bad]=md[bad]
sort = np.sort(dat.flatten())
a,b = np.floor(len(sort)*.03), np.ceil(len(sort)*.97)
metric = (sort[b]-sort[a])/sort[b]
metric = np.max(dat) - np.min(dat)
fpos.append(hdr["secfocus"])
metrics.append(metric)
print fn, hdr["secfocus"], hdr["EXPTIME"], metric
x = np.argmax(metrics)
return fpos[x], fpos, metrics
def test_basic(self):
f = [[50, 50, 50, 50, 50, 92, 18, 27, 65, 46],
[50, 50, 50, 50, 50, 0, 72, 77, 68, 66],
[50, 50, 50, 50, 50, 46, 47, 19, 64, 77],
[50, 50, 50, 50, 50, 42, 15, 29, 95, 35],
[50, 50, 50, 50, 50, 46, 34, 9, 21, 66],
[70, 97, 28, 68, 78, 77, 61, 58, 71, 42],
[64, 53, 44, 29, 68, 32, 19, 68, 24, 84],
[ 3, 33, 53, 67, 1, 78, 74, 55, 12, 83],
[ 7, 11, 46, 70, 60, 47, 24, 43, 61, 26],
[32, 61, 88, 7, 39, 4, 92, 64, 45, 61]]
d = signal.medfilt(f, [7, 3])
e = signal.medfilt2d(np.array(f, np.float), [7, 3])
assert_array_equal(d, [[ 0, 50, 50, 50, 42, 15, 15, 18, 27, 0],
[ 0, 50, 50, 50, 50, 42, 19, 21, 29, 0],
[50, 50, 50, 50, 50, 47, 34, 34, 46, 35],
[50, 50, 50, 50, 50, 50, 42, 47, 64, 42],
[50, 50, 50, 50, 50, 50, 46, 55, 64, 35],
[33, 50, 50, 50, 50, 47, 46, 43, 55, 26],
[32, 50, 50, 50, 50, 47, 46, 45, 55, 26],
[ 7, 46, 50, 50, 47, 46, 46, 43, 45, 21],
[ 0, 32, 33, 39, 32, 32, 43, 43, 43, 0],
[ 0, 7, 11, 7, 4, 4, 19, 19, 24, 0]])
assert_array_equal(d, e)
def speckle_filter(ifile, ofile):
"""
ifile
ofile
"""
# read the Digital Number (DNp)
dataset = gdal.Open(ifile,GA_ReadOnly)
sigma = dataset.GetRasterBand(1).ReadAsArray()
inci = dataset.GetRasterBand(2).ReadAsArray()
RasterXSize = dataset.RasterXSize
RasterYSize = dataset.RasterYSize
GT = dataset.GetGeoTransform()
projection = dataset.GetProjection()
dataset = None
# filter
sigma = medfilt2d(sigma, kernel_size=7)
#sigma = wiener(sigma, mysize=(7,7),noise=None)
# same as geotiff
driver = gdal.GetDriverByName('GTiff')
output_dataset = driver.Create(ofile, RasterXSize, RasterYSize,2,gdal.GDT_Float32)
output_dataset.SetGeoTransform(GT)
output_dataset.SetProjection(projection)
output_dataset.GetRasterBand(1).WriteArray(sigma, 0, 0)
output_dataset.GetRasterBand(2).WriteArray(inci, 0, 0)
output_dataset = None
def sigmaVV(dataset, xOff=0, yOff=0, xS=None, yS=None, \
xBufScale=None, yBufScale=None, s='abs', filter_name='wiener', ws=7, que=[]):
# calculate the sinclair matrix
S_VV = dataset.GetRasterBand(2).ReadAsArray(xoff=xOff, yoff=yOff, \
win_xsize=xS, win_ysize=yS, \
buf_xsize=xBufScale, buf_ysize=yBufScale)
# calculate the magnitude
S_VV_ABS = absolute(S_VV)
# calculate the linear sigma_naught
if s == 'abs':
SigmaVV = S_VV_ABS**2
# calculate the sigma_naught in dB
if s == 'sigma0':
SigmaVV = 2*10*log10(S_VV_ABS)
# SigmaVVwnr = wiener(SigmaVV,mysize=(7,7),noise=None)
#we're putting return value into queue
que.put(SigmaVV)
#Filter the image using 'median' or Lee 'wiener' filtering methods
if filter_name == 'median':
# filter the image using median filter
SigmaVVmed = medfilt2d(SigmaHH, kernel_size=ws)
que.put(SigmaVVmed)
elif filter_name == 'wiener':
# filter the image using wiener filter
SigmaVVwnr = wiener(SigmaVV,mysize=(ws,ws),noise=None)
que.put(SigmaVVwnr)
else:
print 'Please specify the name of the filter: "median" or "wiener"'
def medfiltnan(a, kernel, thresh=0):
"""
Do a running median filter of the data.
Regions where more than *thresh* fraction of the points are NaN
are set to NaN.
Currently only work for vectors.
"""
flag_1D = False
if a.ndim == 1:
a = a[None, :]
flag_1D = True
try:
len(kernel)
except:
kernel = [1, kernel]
out = medfilt2d(a, kernel)
if thresh > 0:
out[convolve2d(np.isnan(a),
np.ones(kernel) / np.prod(kernel),
'same') > thresh] = np.NaN
if flag_1D:
return out[0]
return out
def replace_nans(self, inplace=False):
nans = np.isnan(self)
tmp = medfilt2d(self, 3)
if inplace:
self[nans] = tmp[nans]
else:
y = self.copy()
y[nans] = tmp[nans]
return y
def main():
f = np.hstack((np.ones((200, 100))*0.3, np.ones((200, 100))*0.7))
lena, camera = get_data()
gauss_noised = f + np.random.normal(size=f.shape, scale=0.1)
sp_noised = salt_and_pepper(f, density=0.05)
specked = speckle_noise(f)
f1 = array_with_hist(f)
f2 = array_with_hist(gauss_noised)
f3 = array_with_hist(sp_noised)
f4 = array_with_hist(specked)
noisy_lena = lena + np.random.normal(scale=0.002**.5, size=lena.shape)
f5 = array_with_hist(noisy_lena)
# Various Kernels
k = np.ones((3,3), dtype=np.double) * 1. / 9.
k7 = np.ones((7,7), dtype=np.double)*1./49.
g = gauss_kernel(3)
denoised = convolve2d(noisy_lena, k, mode='same')
denoised2 = convolve2d(noisy_lena, k7, mode='same')
f5 = array_with_hist(lena)
f6 = array_with_hist(noisy_lena)
f7 = array_with_hist(denoised)
f8 = array_with_hist(denoised2)
zz = convolve2d(noisy_lena, g, mode='same')
f15 = array_with_hist(zz) # Apologies for order change.
# Salt and Pepper
salted = salt_and_pepper(lena)
avg_salt = convolve2d(salted, k7, mode='same')
norm_salt = convolve2d(salted, g, mode='same')
med_lena = medfilt2d(salted, 7)
f9 = array_with_hist(salted)
f10 = array_with_hist(avg_salt)
f11 = array_with_hist(norm_salt)
f12 = array_with_hist(med_lena)
# Sharpening:
# 2x2 Camera: Original, Blurred, Residual, Boosted
g_camera = convolve2d(camera, g, mode='same')
sharper, axes = plt.subplots(2, 2, sharey=True, figsize=(8,8))
ims = (camera, g_camera, r, camera + r)
labels = ('original', 'gaussian blurred', 'residual', 'boosted')
for i, e in enumerate(axes.flat):
e.imshow(ims[i], cmap='gray', vmin=0., vmax=1.)
e.set_title(labels[i])
axes.flat[2].imshow(r, cmap='gray_r')
f13 = sharper
f14 = three_by_three_unsharp(camera, r)
print 'fin'
def XPADcalcFlatFieldDarkMask(dark,flat,medfilt_width=21): print "XPADcalcFlatFieldDarkMask - median filter will take a few seconds..." # flat field calculated using a large median filter flatmed=signal.medfilt2d(flat,medfilt_width) #Include in the dark mask pixels counting less than half or more than 50% #than the median filtered value mask=(flat<(.5*flatmed))+(flat>(1.5*flatmed)) # Also include pixels counting in the dark... mask+=(dark>5) return flatmed/(flat+1e-8)*(mask==0),mask>0
def speckle_filter(self, filter_name='wiener', ws=7):
"""
Filter the image using 'median' filtering methods
"""
if filter_name == 'median':
# filter the image using median filter
self.SigmaHHmed = medfilt2d(self.SigmaHH, kernel_size=ws)
self.SigmaHVmed = medfilt2d(self.SigmaHV, kernel_size=ws)
self.SigmaVHmed = medfilt2d(self.SigmaVH, kernel_size=ws)
self.SigmaVVmed = medfilt2d(self.SigmaVV, kernel_size=ws)
elif filter_name == 'wiener':
# filter the image using wiener filter
self.SigmaHHwnr = wiener(self.SigmaHH,mysize=(ws,ws),noise=None)
self.SigmaHVwnr = wiener(self.SigmaHV,mysize=(ws,ws),noise=None)
self.SigmaVHwnr = wiener(self.SigmaVH,mysize=(ws,ws),noise=None)
self.SigmaVVwnr = wiener(self.SigmaVV,mysize=(ws,ws),noise=None)
else:
print 'Please specify the name of the filter: "median"'
def median(img, kernel_size):
"""
Median filter.
Parameters :
img : input 2D image
kernel_size : (length, width) of kernel
"""
# Convert to numpy array if necessary
if not isinstance(img, np.ndarray): img = np.array(img)
return sig.medfilt2d(img, kernel_size)
def denoise_image(inp):
# estimate 'background' color by a median filter
bg = signal.medfilt2d(inp, 11)
save('background.png', bg)
# compute 'foreground' mask as anything that is significantly darker than
# the background
mask = inp < bg - 0.1
save('foreground_mask.png', mask)
# return the input value for all pixels in the mask or pure white otherwise
return np.where(mask, inp, 1.0)
def measureData(self):
roiDataFilt = medfilt2d(np.double(self.roiData), 5)
self.spectrumData = np.sum(self.roiData, 1) / self.roiData.shape[1]
if self.wavelengths is None:
self.generateWavelengths()
if self.wavelengths.shape[0] == self.spectrumData.shape[0]:
self.plot1.setData(x=self.wavelengths, y=self.spectrumData)
self.plot1.update()
# goodInd = np.arange(self.signalStartIndex.value(), self.signalEndIndex.value() + 1, 1)
# bkgInd = np.arange(self.backgroundStartIndex.value(), self.backgroundEndIndex.value() + 1, 1)
# bkg = self.waveform1[bkgInd].mean()
# bkgPump = self.waveform2[bkgInd].mean()
# autoCorr = (self.waveform1[goodInd] - bkg).sum()
# pump = (self.waveform2[goodInd] - bkgPump).sum()
# # pump = 1.0
# if self.normalizePumpCheck.isChecked() == True:
# try:
# self.trendData1 = np.hstack((self.trendData1[1:], autoCorr / pump))
# except:
# pass
# else:
# self.trendData1 = np.hstack((self.trendData1[1:], autoCorr))
# self.plot3.setData(y=self.trendData1)
# Evaluate the fps
t = time.time()
if self.measureUpdateTimes.shape[0] > 10:
self.measureUpdateTimes = np.hstack((self.measureUpdateTimes[1:], t))
else:
self.measureUpdateTimes = np.hstack((self.measureUpdateTimes, t))
fps = 1 / np.diff(self.measureUpdateTimes).mean()
self.fpsLabel.setText(QtCore.QString.number(fps, 'f', 1))
# If we are running a scan, update the scan data
if self.running == True:
if self.moving == False and self.moveStart == False:
if self.trendData1 is None:
self.trendData1 = self.spectrumData
self.timeMarginalTmp = self.spectrumData.sum()
else:
self.trendData1 += self.spectrumData
self.timeMarginalTmp += self.spectrumData.sum()
self.currentSample += 1
if self.currentSample >= self.avgSamples:
self.running = False
self.measureScanData()
self.trendData1 = None
self.currentSample = 0
self.scanUpdateAction()
def fix_medfilt2d(array,width):
"""Wrap medfilt2d so that the results more closely resemble IDL MEDIAN().
"""
from numpy import arange
from scipy.signal import medfilt2d
medarray = medfilt2d(array,min(width,array.size))
istart = int((width-1)/2)
iend = (array.shape[0] - int((width+1)/2), array.shape[1] - int((width+1)/2))
i = np.arange(array.shape[0])
j = np.arange(array.shape[1])
w = ((i < istart) | (i > iend[0]), (j < istart) | (j > iend[1]))
medarray[w[0],w[1]] = array[w[0],w[1]]
return medarray
def Medfilt( array, axis, kernel_size, Nprocess=None ) : ''' array: N-d array axis: None | int number (1) ==None: use scipy.signal.medfilt(array, kernel_size) (2) ==int number: mediam filter along this axis ''' Nprocess = NprocessCPU(Nprocess, False)[0] array, kernel_size =npfmt(array), npfmt(kernel_size).flatten() shape, dtype = array.shape, array.dtype tf = (kernel_size % 2 == 0) kernel_size[tf] += 1 kernel_size = kernel_size[:len(shape)] kernel_size = np.append(kernel_size, [kernel_size[0] for i in xrange(len(shape)-len(kernel_size))]) if (axis is None) : if (len(shape) == 2) : array = spsn.medfilt2d(1.*array, kernel_size) else : array = spsn.medfilt(array, kernel_size) else : axis = int(round(axis)) if (axis < 0) : axis = len(shape) + axis if (axis >= len(shape)) : Raise(Exception, 'axis='+str(axis)+' out of '+str(len(shape))+'D array.shape='+str(shape)) kernel_size = kernel_size[axis] if (len(shape) == 1) : array = spsn.medfilt(array, kernel_size) else : array = ArrayAxis(array, axis, -1) shape = array.shape array = array.reshape(np.prod(shape[:-1]), shape[-1]) sent = array bcast = kernel_size if (Nprocess == 1) : array = _Multiprocess_medfile([None, sent, bcast]) else : pool = PoolFor(0, len(array), Nprocess) array = pool.map_async(_Multiprocess_medfile, sent, bcast) array = np.concatenate(array, 0) array = array.reshape(shape) array = ArrayAxis(array, -1, axis) array = array.astype(dtype) return array
def median_filter(s_or_a, order=11, p=2):
if hasattr(s_or_a, 'signal'):
a = s_or_a
s = get_spectrogram(a, a.sample_rate / 10, a.sample_rate / 20, return_angles=True)
else:
a = None
s = s_or_a
harmonic = medfilt2d(np.abs(s), (abs(order), 1))
percussive = medfilt2d(np.abs(s), (1, abs(order)))
if order > 0:
mask = harmonic ** p / (harmonic ** p + percussive ** p)
else:
mask = percussive ** p / (harmonic ** p + percussive ** p)
masked = s * mask
masked[np.isnan(masked)] = 0
if a:
masked_audio = get_audio(masked, a.sample_rate, a.sample_rate / 10, a.sample_rate / 20)
return masked_audio
else:
return masked
def calculate_water(data):
z, y, x = data.shape
pot_water = numpy.zeros((y, x))
for b in range(z - 1, 1, -1):
pot_water[:, :] = numpy.where(data[b, :, :] < data[b - 1, :, :], pot_water + b * 1, pot_water)
for b in range(z - 1, 1, -1):
pot_water[:, :] = numpy.where(data[b, :, :] > data[b - 1, :, :], pot_water - b * 1, pot_water)
# NDWI bands
b = 4
pot_water[:, :] = numpy.where(data[b, :, :] > data[b - 3, :, :], pot_water - 1, pot_water)
# NIR-RE diff to R-RE aka sun glid
dark_nir = numpy.where(data[b, :, :] < 0.12, data, data * 0)
pot_water[:, :] = numpy.where(numpy.abs(dark_nir[b, :, :] - dark_nir[b - 1, :, :]) < abs(dark_nir[b - 1, :, :] - dark_nir[b - 2, :, :]), pot_water + 1.5, pot_water - 1.5)
pot_water = signal.medfilt2d(pot_water, kernel_size=5)
pot_water = numpy.where(data[0, :, :] == 0, -999, pot_water)
return pot_water
def smooth(self, size = 4):
assert size > 0
def phaseComplement(value):
value -= (value > np.pi)*2*np.pi
value += (value < - np.pi)*2*np.pi
return value
new_data = np.zeros_like(self.data)
for frame in range( self.data.shape[0]):
if frame % 10 == 0 : print frame
for n in range(self.data.shape[1])[size:-size]:
for m in range(self.data.shape[2])[size:-size]:
base = self.data[frame, n, m]
target = self.data[frame, n-size:n+size+1, m-size:m+size+1]
difference = phaseComplement(target-base)
diff = signal.medfilt2d(difference, kernel_size=size*2+1)[size,size]
new_data[frame, n, m] = phaseComplement( base + diff)
#new_data[frame, n, m] = phaseComplement( base + np.mean(difference.flatten()) )
self.data = new_data
def denoise_im_with_back(inp):
# estimate 'background' color by a median filter
bg = signal.medfilt2d(inp, 11)
save('background.png', bg)
# compute 'foreground' mask as anything that is significantly darker than
# the background
mask = inp < bg - 0.1
save('foreground_mask.png', mask)
back = np.average(bg);
# Lets remove some splattered ink
mod = ndimage.filters.median_filter(mask,2);
mod = ndimage.grey_closing(mod, size=(2,2));
# either return forground or average of background
out = np.where(mod, inp, back) ## 1 is pure white
return out;
def update(val): thres = sthres.val newmatrix = signal.medfilt2d(thematrix, kernel_size=kernel_size) belowthres_indices = newmatrix < thres newmatrix[belowthres_indices] = 0 labelarray,numfoundrois = measurements.label(newmatrix) print str(numfoundrois) + ' ROIs found!' # organize rois therois = [] for n in range(numfoundrois): rawindices = np.nonzero(labelarray == n+1) eachroi = [] for m in range(len(rawindices[0])): eachroi.append((rawindices[1][m],rawindices[0][m])) therois.append(eachroi) theimage.set_data(newmatrix) plt.draw() roi_result.therois = therois roi_result.numfoundrois = numfoundrois
def get_spots_mask( A, median_size=None, nofroi=12, give_borders=False) :
A = signal.medfilt2d(A, kernel_size=median_size)
mask=np.zeros(A.shape,"i")
cerchi = CercaAnelli(A)
for c in cerchi[:]:
if len(c)<LENMIN: continue
for y,x in c:
mask[y,x] = 1
filled=morph.binary_fill_holes(mask)
newmask = relabelise(filled,A, nofroi)
if give_borders:
return newmask, mask
else:
return newmask
def volumeMask(vol):
"""
:param vol: a 3-dimensional numpy array
:return: mask, a binary mask with the same shape as vol, and mCoords, a list of (x,y,z) indices representing the
masked coordinates.
"""
from numpy import array, where
from scipy.signal import medfilt2d
from skimage.filter import threshold_otsu
from skimage import morphology as morph
filtVol = array([medfilt2d(x.astype('float32')) for x in vol])
thr = threshold_otsu(filtVol.ravel())
mask = filtVol > thr
strel = morph.selem.disk(3)
mask = array([morph.binary_closing(x, strel) for x in mask])
mask = array([morph.binary_opening(x, strel) for x in mask])
z, y, x = where(mask)
mCoords = zip(x, y, z)
return mask, mCoords
def _enhance_img(img, median_ks, normalized=True):
"""
Enhance the projection image from aps 1ID to counter its weak contrast
nature
Parameters
----------
img : ndarray
original projection image collected at APS 1ID
median_ks: int
kernel size of the 2D median filter, must be odd
normalized: bool, optional
specify whether the enhanced image is normalized between 0 and 1,
default is True
Returns
-------
ndarray
enhanced projection image
"""
wgt = _calc_histequal_wgt(img)
img = medfilt2d(img, kernel_size=median_ks).astype(np.float64)
img = ne.evaluate('(img**2)*wgt', out=img)
return img/img.max() if normalized else img
def calculate_std(self,niter=1,spatial_smooth=None,spectral_smooth=None):
"""
Calculates the naive values for the scale and norms under the
assumption that the median absolute deviation is a rigorous method.
"""
data = self.cube.get_filled_data().astype('=f')
self.scale = nanstd(data)
if self.spatial_norm is None:
self.spatial_norm = np.ones((data.shape[1],data.shape[2]))
self.spectral_norm = np.ones((data.shape[0]))
for count in range(niter):
scale = self.get_scale_cube()
snr = data/scale
self.spatial_norm = nanstd(snr,axis=0)*self.spatial_norm
if beam is not None:
self.spatial_norm = convolve_fft(self.spatial_norm,
self.beam.as_kernel(get_pixel_scales(self.cube.wcs)),
interpolate_nan=True,normalize_kernel=True)
if spatial_smooth is not None:
self.spatial_norm = ssig.medfilt2d(self.spatial_norm,
kernel_size=spatial_smooth)
snr = data/self.get_scale_cube()
self.spectral_norm = nanstd(snr.reshape((snr.shape[0],
snr.shape[1]*
snr.shape[2])),
axis=1)*self.spectral_norm
if spectral_smooth is not None:
self.spectral_norm = ssig.medfilt(self.spectral_norm,
kernel_size=spectral_smooth)
self.spectral_norm[np.isnan(self.spectral_norm) | (self.spectral_norm==0)]=1.
self.spatial_norm[np.isnan(self.spatial_norm) | (self.spatial_norm==0)]=1.
self.spatial_norm[~self.spatial_footprint]=np.nan
self.distribution_shape=(0,self.scale)
return
def updateFrogRoi(self):
root.debug(''.join(('Roi pos: ', str(self.frogRoi.pos()))))
root.debug(''.join(('Roi size: ', str(self.frogRoi.size()))))
if self.scanData.size != 0:
root.debug(''.join(('Scan data: ', str(self.scanData.shape))))
bkg = self.scanData[0,:]
bkgImg = self.scanData - np.tile(bkg, (self.scanData.shape[0], 1))
roiImg = self.frogRoi.getArrayRegion(bkgImg, self.frogImageWidget.getImageItem(), axes=(1,0))
roiImg = roiImg / roiImg.max()
root.debug('Slice complete')
thr = self.frogThresholdSpinbox.value()
kernel = self.frogKernelSpinbox.value()
root.debug('Starting medfilt...')
filteredImg = medfilt2d(roiImg, kernel) - thr
# filteredImg = roiImg - thr
root.debug('Filtering complete')
filteredImg[filteredImg<0.0] = 0.0
root.debug('Threshold complete')
self.frogRoiImageWidget.setImage(filteredImg)
root.debug('Set image complete')
self.frogRoiImageWidget.autoRange()
root.debug('Autorange complete')
os.makedirs(SAVE_F)
os.makedirs(SAVE_M)
except os.error:
pass
files = os.listdir(PATH)
for i in range(len(files)):
file = files[i]
input_x = SimpleITK.GetArrayFromImage(
SimpleITK.ReadImage(PATH + "/" + file))
input_x = np.asarray(input_x).reshape([512, 512, 3])
sx1_, mask_x1_ = sess.run(
[sx, mask_x],
feed_dict={x: np.asarray([input_x[:, :, 0:1]]).astype('float32')})
sx1_ = signal.medfilt2d(np.asarray(sx1_)[0, :, :, 0, ],
kernel_size=k_size1)
mask_x1_ = signal.medfilt2d(np.asarray(mask_x1_)[0, :, :, 0, ],
kernel_size=k_size2)
sx2_, mask_x2_ = sess.run(
[sx, mask_x],
feed_dict={x: np.asarray([input_x[:, :, 1:2]]).astype('float32')})
sx2_ = signal.medfilt2d(np.asarray(sx2_)[0, :, :, 0, ],
kernel_size=k_size1)
mask_x2_ = signal.medfilt2d(np.asarray(mask_x2_)[0, :, :, 0, ],
kernel_size=k_size2)
sx3_, mask_x3_ = sess.run(
[sx, mask_x],
feed_dict={x: np.asarray([input_x[:, :, 2:3]]).astype('float32')})
sx3_ = signal.medfilt2d(np.asarray(sx3_)[0, :, :, 0, ],
def BiomassForestHeightSKPD(
data_stack,
cov_est_window_size,
pixel_spacing_slant_rg,
pixel_spacing_az,
incidence_angle_rad,
carrier_frequency_hz,
range_bandwidth_hz,
kz_stack,
vertical_vector,
proc_conf,
):
power_threshold = proc_conf.power_threshold
# data_stack is a dictionary of two nested dictionaries composed as:
# data_stack[ acquisition_name ][ polarization ]
num_acq = len(data_stack)
acq_names = list(data_stack.keys())
first_acq_dict = data_stack[acq_names[0]]
pol_names = list(first_acq_dict.keys())
num_pols = len(pol_names)
Nrg, Naz = first_acq_dict[pol_names[0]].shape
Nz = np.size(vertical_vector)
# Covariance estimation
(
MPMB_correlation,
rg_vec_subs,
az_vec_subs,
subs_F_r,
subs_F_a,
) = main_correlation_estimation_SR(
data_stack,
cov_est_window_size,
pixel_spacing_slant_rg,
pixel_spacing_az,
incidence_angle_rad,
carrier_frequency_hz,
range_bandwidth_hz,
)
Nrg_subs = rg_vec_subs.size
Naz_subs = az_vec_subs.size
# Initialization of the SKPD routine
class SKPD_kernel_opt_str:
pass
SKPD_kernel_opt_str.num_acq = num_acq
SKPD_kernel_opt_str.num_pols = num_pols
SKPD_kernel_opt_str.Nsubspaces = 2
SKPD_kernel_opt_str.Nparam = 2
SKPD_kernel_opt_str.error = np.zeros((Nrg_subs, Naz_subs, 4, 2))
# Single polarimetric channel selector
wpol = (np.kron(np.eye(num_pols), np.ones((1, num_acq)))) > 0
tomo_cube = np.zeros((Nrg_subs, Naz_subs, Nz))
Nrg_subs_string = str(Nrg_subs)
for rg_sub_idx in np.arange(Nrg_subs):
logging.info(" Heigth step " + str(rg_sub_idx + 1) + " of " +
Nrg_subs_string)
for az_sub_idx in np.arange(Naz_subs):
# Spectra estimation initialization
class spectra:
pass
spectra.temp = np.zeros((Nz, 4))
current_MPMB_correlation = MPMB_correlation[:, :, rg_sub_idx,
az_sub_idx]
# SKPD processing
SKPD_kernel_out_str = SKPD_processing(current_MPMB_correlation,
SKPD_kernel_opt_str)
if np.any(SKPD_kernel_out_str.error):
# Calibrating with respect to the linked phases of the
# best polarimetric channel
Rcoh_thin = Covariance2D2Correlation2D(
np.reshape(
current_MPMB_correlation[wpol[0, :][:, np.newaxis] *
wpol[0, :][np.newaxis, :]],
(num_acq, num_acq),
))
Rcoh_fat = Covariance2D2Correlation2D(
np.reshape(
current_MPMB_correlation[wpol[1, :][:, np.newaxis] *
wpol[1, :][np.newaxis, :]],
(num_acq, num_acq),
))
Rincoh_thin = Covariance2D2Correlation2D(
np.reshape(
current_MPMB_correlation[wpol[2, :][:, np.newaxis] *
wpol[2, :][np.newaxis, :]],
(num_acq, num_acq),
))
Rincoh_fat = np.random.randn(
num_acq, num_acq) + 1j * np.random.randn(num_acq, num_acq)
else:
# Scattering mechanisms
Rcoh_thin = Covariance2D2Correlation2D(
SKPD_kernel_out_str.Rcoh_thin)
Rcoh_fat = Covariance2D2Correlation2D(
SKPD_kernel_out_str.Rcoh_fat)
Rincoh_thin = Covariance2D2Correlation2D(
SKPD_kernel_out_str.Rincoh_thin)
Rincoh_fat = Covariance2D2Correlation2D(
SKPD_kernel_out_str.Rincoh_fat)
# Steering matrix
current_kz = np.zeros((num_acq, 1))
for b_idx, stack_curr in enumerate(kz_stack.values()):
current_kz[b_idx] = stack_curr[rg_vec_subs[rg_sub_idx],
az_vec_subs[az_sub_idx]]
A = np.exp(1j * current_kz * vertical_vector) / num_acq
# Spectra estimation
for m in np.arange(4):
currR = (m == 0) * Rcoh_thin + (m == 1) * Rcoh_fat + (
m == 2) * Rincoh_thin + (m == 3) * Rincoh_fat
if proc_conf.enable_super_resolution:
# Capon
currR = currR + proc_conf.regularization_noise_factor * np.eye(
currR.shape[0])
spectra.temp[:, m] = 1 / np.diag(
np.abs(
A.conj().transpose() @ np.linalg.inv(currR) @ A))
else:
spectra.temp[:, m] = np.diag(
np.abs(A.conj().transpose() @ currR @ A))
# Volume mechanism recognized thanks to its higher elevation
max_index = np.argmax(spectra.temp, axis=0)
max_m = np.argmax(max_index)
tomo_cube[rg_sub_idx, az_sub_idx, :] = spectra.temp[:, max_m]
# Estimating canopy elevation by looking at the decay
class opt_str:
pass
opt_str.z = vertical_vector
opt_str.thr = power_threshold # Power decay threshold With respect to the peak value
out_str = UpperThresholdForestHeight(tomo_cube, opt_str)
canopy_height = out_str.z
power_peak = out_str.peak
canopy_height = medfilt2d(canopy_height.astype("float64"), kernel_size=5)
return canopy_height, power_peak, rg_vec_subs, az_vec_subs, subs_F_r, subs_F_a
def pyzapspec(infile,
outfile='',
maskfile='',
WRITE_OUTFILE=False,
DEBUG_DIR='../test_data/',DEBUG=False,
boxsize=9,nsigma=15.,subsigma=2.8,sfactor=1.0,
nzap=0,mask=0,writemodel=0,verbose=0,skysubtract=0,
zero=0,method=0,usamp=0,ybin=0,nan=-999,inmaskname=0,**kwargs):
# defaults
if len(outfile) == 0:
dirpath,infile_base = os.path.split(infile)
outfile_base = 'cr{}'.format(infile_base)
outfile = os.path.join(dirpath,outfile_base)
if len(maskfile) == 0:
dirpath,infile_base = os.path.split(infile)
maskfile_base = 'cr{}_mask.fits'.format(infile_base.split('.')[0])
maskfile = os.path.join(dirpath,maskfile_base)
tstart = time.time()
# read in a copy of the input image to construct the output instance
outimgHDU = fits.open(infile)
outimg = outimgHDU[0].data
header = outimgHDU[0].header
dims = outimg.shape
nx = dims[1] #spectral
ny = dims[0] #spatial
outmask = np.full((ny,nx),0)
ymedimage = np.zeros((ny,nx))
xmedimage = np.zeros((ny,nx))
zapimage = np.zeros((ny,nx))
nzapCount = 0
iterCount = 0
nbadCount = 1
# first do a crude median subtraction of the sky lines
# for x in range(nx):
for x in xrange(nx):
ymedimage[:,x] = np.median(outimg[:,x])
ysubimage = outimg - ymedimage
# now subtract traces so we can do a better sky-line subtraction
# otherwise traces will be killed/wings oversubtracted
sourceblocksize = 100
nxblock = int(np.ceil(1.*nx/sourceblocksize))
realsourcefiltsize = 1*sourceblocksize
x0 = (np.arange(0,nxblock)*realsourcefiltsize).astype(int)
x1 = np.append(x0[1:]-1,nx-1)
xs0 = np.insert(x0[0:nxblock-1],x0[0],0)
xs1 = np.append(x1[1:nxblock],x1[nxblock-1])
# for b in range(nxblock):
for b in xrange(nxblock):
# for y in range(ny):
for y in xrange(ny):
xmedimage[y, x0[b]:x1[b]+1] = np.median(ysubimage[y, xs0[b]:xs1[b]+1])
kernel = 1.*np.arange(0,realsourcefiltsize/2)
kernelRev = kernel[::-1]
kernel = np.append(kernel,kernelRev)
kernel = kernel / np.sum(kernel)
# pzap is convolving the 2D xmedimage with a 1D kernel,
# I'm pretty sure this is just a row by row convolution.
# for xrow in range(ny):
for xrow in xrange(ny):
newRow = np.convolve(xmedimage[xrow,:],kernel,mode='same')
xmedimage[xrow,:] = 1.*newRow
xsubimage = outimg - xmedimage
# here I'm assuming the method=0 (pzapspec line 226),
# since I don't feel like coding up the alternative right now
skyblocksize = 40
nyblock = int(np.ceil(1.*ny/skyblocksize))
realskyblocksize = 1.*skyblocksize
y0 = (np.arange(0,nyblock)*realskyblocksize).astype(int)
y1 = np.append(y0[1:]-1,ny-1)
ys0 = np.insert(y0[0:nyblock-1],y0[0],0)
ys1 = np.append(y1[1:nyblock],y1[nyblock-1])
# for b in range(nyblock):
# for x in range(nx):
for b in xrange(nyblock):
for x in xrange(nx):
scm = sigclipmedian(xsubimage[ys0[b]:ys1[b]+1,x])
ymedimage[y0[b]:y1[b]+1,x] = scm
kernel = 1.*np.arange(0,realskyblocksize/2)
kernelRev = kernel[::-1]
kernel = np.append(kernel,kernelRev)
kernel = kernel / np.sum(kernel)
# pzap is convolving the 2D xmedimage with a 1D kernel,
# I'm pretty sure this is just a column by column convolution.
# for ycol in range(nx):
for ycol in xrange(nx):
newCol = np.convolve(ymedimage[:,ycol],kernel,mode='same')
ymedimage[:,ycol] = 1.*newCol
ysubimage = outimg - ymedimage
skysubimage = outimg - ymedimage - xmedimage # actually subtracts sky AND sources.
filterimage = signal.medfilt2d(skysubimage,[boxsize,boxsize])
residualimage = skysubimage - filterimage
sigmaimage = np.zeros((ny,nx)) + np.nan
nyb = round(ny / 200)
yint = np.ceil(ny*1./nyb)
# for yb in range(nyb):
# for x in range(nx):
for yb in xrange(int(nyb)):
for x in xrange(nx):
# select the pixels in this chunk of rows
selectRowIndsLo = int(yb*yint)
selectRowIndsHi = int(np.min([(yb+1)*yint,ny])) # this indexing is potentially hazardous
s = residualimage[selectRowIndsLo : selectRowIndsHi, x]
goodInds = np.where(np.isfinite(s))[0] # select the pixels with finite values
goodIndsCount = len(goodInds)
# make sure we have enough pixels to process
if goodIndsCount < 2:
continue
s = np.sort(s[goodInds]) #now actually select and sort them
ns = len(s)
# exclude the tails of the distribution
keepIndsLo = int(np.floor(0.03*ns))
keepIndsHi = int(np.ceil(0.97*ns))
s = s[keepIndsLo:keepIndsHi]
sigmaimage[selectRowIndsLo : selectRowIndsHi, x] = np.std(s,ddof=1)
sigmaimage = np.sqrt(sigmaimage**2 + (np.fabs(filterimage*sfactor) + np.fabs(xmedimage))) # this scaling assumes gain ~ 1
residualnsigmaimage = residualimage / sigmaimage
residualnsigmaimage_ravel = residualnsigmaimage.ravel() # this is a view of residualnsigmaimage
zapimage_ravel = zapimage.ravel() # this is a view of zapimage
skysubimage_ravel = skysubimage.ravel() # this is a view of zapimage
crcores = np.where(residualnsigmaimage_ravel > nsigma)[0]
newzaps = len(crcores)
if newzaps > 0:
zapimage_ravel[crcores] = 1
# #this is hacky but MIGHT needed for host analysis
# zapimage[50:80, 1280:1360] = 0 #halpha keck
# zapimage_ravel = zapimage.ravel()
# res = writefits(zapimage,'zapimage1.fits',CLOBBER=True)
if DEBUG:
res = writefits(zapimage,'{}/zapimage.fits'.format(DEBUG_DIR),CLOBBER=True)
outStr = 'Flagged {} initial affected pixels before percolation.'.format(newzaps)
print(outStr)
nperczap = 0
# iterCount = 0
iterCount = 1 #testing
d0 = nx
d1 = ny
# percolate outward to get all pixels covered by each cosmic ray.
while iterCount < 32:
nextperc = np.where(zapimage_ravel == iterCount)[0]
ct = len(nextperc)
iterCount += 1
newzaps = 0
if ct <= 3:
break
nrays = len(nextperc)
# for c in range(nrays):
for c in xrange(nrays):
ci = nextperc[c]
# avoid the detector edges
if ci < d0-1 or ci > nx*ny-d0-2:
continue
# here's the structure assumed in the IDL
# ci is the CR pixel we're looking at,
# this is trying to check the neighboring pixels
# ci-d0-1, ci-d0, ci-d0+1,
# ci-1, ci ci+1,
# ci+d0-1, ci+d0, ci+d0+1
# the way the IDL where() function works in the original pzap code
# makes indexing the arrays this way trivial since it does the
# ravel implicitly, but np.where() works differently. The easiest way
# to handle this is to retain this neighbor indexing from the
# original IDL pzap code and just run the np.where() on ravel'd
# numpy arrays.
# just to be explicit, if you have an N-D numpy array x, then
# x.ravel() will return a VIEW of that array mapped to a
# 1-D array, so a 2x2 array becomes a 4 element 1-D array. The
# important thing to remember is that if you modify a VIEW of
# an array, it will modify your original array too.
coarseblockpos = np.array([ ci-d0,
ci-1, ci+1,
ci+d0])
newzap = np.where( (np.fabs(residualnsigmaimage_ravel[coarseblockpos]) > subsigma) &
(zapimage_ravel[coarseblockpos] == 0) )[0]
addzap = len(newzap)
if addzap > 0:
zapimage_ravel[coarseblockpos[newzap]] = iterCount
newzaps += addzap
nperczap += addzap
# finally, zap anything hiding in a cosmic ray "corner" (three neighbors are cosmic ray pixels)
countneighbor = np.zeros((ny,nx))
countneighbor_ravel = countneighbor.ravel()
nextperc = np.where(zapimage_ravel > 0)[0]
ct = len(nextperc)
if ct > 3:
nrays = len(nextperc)
# for c in range(nrays):
for c in xrange(nrays):
ci = nextperc[c]
# avoid the detector edges
# this wasn't present in the IDL code, but I believe it's necessary
if ci < d0-1 or ci > nx*ny-d0-2:
continue
coarseblockpos = np.array([ci-d0-1, ci-d0, ci-d0+1,
ci-1, ci+1,
ci+d0-1, ci+d0, ci+d0+1])
countneighbor_ravel[coarseblockpos] = countneighbor_ravel[coarseblockpos] + 1
newzap = np.where((countneighbor_ravel > 3) &
(zapimage_ravel == 0))[0]
newzaps = len(newzap)
if newzaps > 0:
zapimage_ravel[newzap] = iterCount +1
# actually do the zapping by replacing with the sky plus local median value.
ibad = np.where(zapimage_ravel != 0)[0]
nbad = len(ibad)
if nbad > 0:
skysubimage_ravel[ibad] = np.nan # NaNs ignored by median() and derivative image modelers
# filterimage is really the replacement image (without sky and sources)
filterimage = signal.medfilt2d(skysubimage,[boxsize,boxsize])
witer = 0
ctnan = -1
while ctnan != 0 and witer <= 2:
if ctnan > 0:
# note not active 0th iteration, since we already did the median above
# so its ok that filterbad is not yet defined...
filterimage.ravel()[filterbad] = signal.medfilt2d(filterimage, [boxsize,boxsize]).ravel()[filterbad]
filterbad = np.where( ~np.isfinite(filterimage.ravel()) &
np.isfinite(xmedimage.ravel()) &
np.isfinite(ymedimage.ravel()))[0]
ctnan = len(filterbad)
witer += 1
if witer == 2 and ctnan > 0:
filterimage.ravel()[filterbad] = 0 # give up
outimg.ravel()[ibad] = filterimage.ravel()[ibad] + ymedimage.ravel()[ibad] + xmedimage.ravel()[ibad]
outmask.ravel()[ibad] = 1
nzap += nbad
outStr = 'Zapped {} pixels in {} seconds'.format(nzap,int(time.time()-tstart))
print(outStr)
histStr = 'Processed by pyzapspec UT {}'.format(datetime.datetime.now())
header.add_history(histStr)
# res = writefits(zapimage,'zapimage2.fits',CLOBBER=True)
if DEBUG:
res = writefits(ymedimage,'{}/ymedimage.fits'.format(DEBUG_DIR),CLOBBER=True)
res = writefits(xmedimage,'{}/xmedimage.fits'.format(DEBUG_DIR),CLOBBER=True)
res = writefits(ysubimage,'{}/ysubimage.fits'.format(DEBUG_DIR),CLOBBER=True)
res = writefits(xsubimage,'{}/xsubimage.fits'.format(DEBUG_DIR),CLOBBER=True)
res = writefits(skysubimage,'{}/fullsubimage.fits'.format(DEBUG_DIR),CLOBBER=True)
res = writefits(zapimage,'{}/zapimage.fits'.format(DEBUG_DIR),CLOBBER=True)
res = writefits(outimg,outfile,header=header,CLOBBER=True)
res = writefits(outmask,maskfile,CLOBBER=True)
pdb.set_trace()
if WRITE_OUTFILE:
res = writefits(outimg,outfile,header=header,CLOBBER=True)
# res = writefits(outmask,maskfile,CLOBBER=True)
return outimg,outmask,header
return 0
def get_image_features(data_type, block):
"""
Method which returns the data type expected
"""
if 'filters_statistics' in data_type:
img_width, img_height = 200, 200
lab_img = transform.get_LAB_L(block)
arr = np.array(lab_img)
# compute all filters statistics
def get_stats(arr, I_filter):
e1 = np.abs(arr - I_filter)
L = np.array(e1)
mu0 = np.mean(L)
A = L - mu0
H = A * A
E = np.sum(H) / (img_width * img_height)
P = np.sqrt(E)
return mu0, P
# return np.mean(I_filter), np.std(I_filter)
stats = []
kernel = np.ones((3, 3), np.float32) / 9
stats.append(get_stats(arr, cv2.filter2D(arr, -1, kernel)))
kernel = np.ones((5, 5), np.float32) / 25
stats.append(get_stats(arr, cv2.filter2D(arr, -1, kernel)))
stats.append(get_stats(arr, cv2.GaussianBlur(arr, (3, 3), 0.5)))
stats.append(get_stats(arr, cv2.GaussianBlur(arr, (3, 3), 1)))
stats.append(get_stats(arr, cv2.GaussianBlur(arr, (3, 3), 1.5)))
stats.append(get_stats(arr, cv2.GaussianBlur(arr, (5, 5), 0.5)))
stats.append(get_stats(arr, cv2.GaussianBlur(arr, (5, 5), 1)))
stats.append(get_stats(arr, cv2.GaussianBlur(arr, (5, 5), 1.5)))
stats.append(get_stats(arr, medfilt2d(arr, [3, 3])))
stats.append(get_stats(arr, medfilt2d(arr, [5, 5])))
stats.append(get_stats(arr, wiener(arr, [3, 3])))
stats.append(get_stats(arr, wiener(arr, [5, 5])))
wave = w2d(arr, 'db1', 2)
stats.append(get_stats(arr, np.array(wave, 'float64')))
data = []
for stat in stats:
data.append(stat[0])
for stat in stats:
data.append(stat[1])
data = np.array(data)
if 'statistics_extended' in data_type:
data = get_image_features('filters_statistics', block)
# add kolmogorov complexity
bytes_data = np.array(block).tobytes()
compress_data = gzip.compress(bytes_data)
mo_size = sys.getsizeof(compress_data) / 1024.
go_size = mo_size / 1024.
data = np.append(data, go_size)
lab_img = transform.get_LAB_L(block)
arr = np.array(lab_img)
# add of svd entropy
svd_entropy = utils.get_entropy(compression.get_SVD_s(arr))
data = np.append(data, svd_entropy)
# add sobel complexity (kernel size of 3)
sobelx = cv2.Sobel(arr, cv2.CV_64F, 1, 0, ksize=3)
sobely = cv2.Sobel(arr, cv2.CV_64F, 0, 1, ksize=3)
sobel_mag = np.array(np.hypot(sobelx, sobely), 'uint8') # magnitude
data = np.append(data, np.std(sobel_mag))
# add sobel complexity (kernel size of 5)
sobelx = cv2.Sobel(arr, cv2.CV_64F, 1, 0, ksize=5)
sobely = cv2.Sobel(arr, cv2.CV_64F, 0, 1, ksize=5)
sobel_mag = np.array(np.hypot(sobelx, sobely), 'uint8') # magnitude
data = np.append(data, np.std(sobel_mag))
if 'lab' in data_type:
data = transform.get_LAB_L_SVD_s(block)
return data
def pretty2D(dataset):
# split data into positive and negative sets for plotting contours
pos_data = zeros([ptsMax1, ptsMax2])
neg_data = zeros([ptsMax1, ptsMax2])
someNegData = False
for i in range(ptsMax1):
for j in range(ptsMax2):
if dataset[i, j] > 0:
pos_data[i, j] = dataset[i, j]
else:
someNegData = True
neg_data[i, j] = abs(dataset[i, j])
# filtering
pos_data = medfilt2d(pos_data, kernel_size=(5, 5))
neg_data = medfilt2d(neg_data, kernel_size=(5, 5))
# note: transposing
extreme = 0.5 * max(abs(dataset).flatten())
ax_main.contour(pos_data.T,
levels,
extent=[min(wn2), max(wn2),
min(wn1), max(wn1)],
origin='lower',
colors='r',
linewidths=0.5)
if someNegData:
ax_main.contour(neg_data.T,
levels,
extent=[min(wn2),
max(wn2),
min(wn1),
max(wn1)],
origin='lower',
colors='b',
linewidths=0.5)
ax_main.set_xlabel(xname)
ax_main.set_ylabel(yname)
for p in peaks:
ax_main.axvline(p, color='k', ls='-', lw=0.5)
ax_main.axhline(p, color='k', ls='-', lw=0.5)
ax_main.xaxis.set_major_locator(MaxNLocator(5))
ax_main.yaxis.set_major_locator(MaxNLocator(5))
if sys.argv[1] == sys.argv[2]:
ax_main.plot([min(wn), max(wn)], [min(wn), max(wn)], 'k-', lw=0.5)
divider = make_axes_locatable(ax_main)
ax_right = divider.append_axes('right', 0)
# ax_right = divider.append_axes('right', 0.4, pad=0.05, sharey=ax_main)
# ax_right.fill_betweenx(wn2, 0, ref2, where=ref2<0, facecolor='0.9', lw=0)
# ax_right.fill_betweenx(wn2, ref2, 0, where=ref2>0, facecolor='0.9', lw=0)
# ax_right.plot(ref2, wn2, 'k-')
for p in peaks:
ax_right.axhline(p, color='k', ls='-', lw=0.5)
if min(ref2) < 0. and max(ref2) > 0:
ax_right.axvline(0., color='k', ls='--', lw=0.5, dashes=[2, 2])
pylab.setp(ax_right.get_xticklabels() + ax_right.get_yticklabels(),
visible=False)
pylab.setp(ax_right.get_xticklines() + ax_right.get_yticklines(),
visible=False)
ax_top = divider.append_axes('top', 0)
# ax_top = divider.append_axes('top', 0.4, pad=0.05, sharex=ax_main)
# ax_top.fill_between(wn1, 0, ref1, where=ref1<0, facecolor='0.9', lw=0)
# ax_top.fill_between(wn1, ref1, 0, where=ref1>0, facecolor='0.9', lw=0)
# ax_top.plot(wn1, ref1, 'k-')
for p in peaks:
ax_top.axvline(p, color='k', ls='-', lw=0.5)
if min(ref1) < 0. and max(ref1) > 0:
ax_top.axhline(0., color='k', ls='--', lw=0.5, dashes=[2, 2])
pylab.setp(ax_top.get_xticklabels() + ax_top.get_yticklabels(),
visible=False)
pylab.setp(ax_top.get_xticklines() + ax_top.get_yticklines(),
visible=False)
ax_top.set_ylim(0.9 * min(ref1), 1.1 * max(ref1))
ax_main.set_xlim(min(wn1), max(wn1))
ax_main.set_ylim(min(wn2), max(wn2))
return ax_top
# mask_x = get_mask(x, p=2, beta=0.2)
fx = get_f(x, j=alpha)
fx = gaussian_blur(fx, sigma=0.3, alpha=0.05, bin=True)
mask_x = get_mask(x, p=2, beta=beta)
with tf.Session(graph=graph,
config=tf.ConfigProto(allow_soft_placement=True)) as sess:
try:
os.makedirs(SAVE_F)
os.makedirs(SAVE_M)
except os.error:
pass
# files = os.listdir(PATH)
# for file in files:
input_x = SimpleITK.GetArrayFromImage(
SimpleITK.ReadImage(PATH + "/" + file))
input_x = np.asarray(input_x).reshape([512, 512, 1])
fx_, mask_x_ = sess.run(
[fx, mask_x], feed_dict={x: np.asarray([input_x]).astype('float32')})
fx_ = signal.medfilt2d(np.asarray(fx_)[0, :, :, 0, ], kernel_size=k_size1)
mask_x_ = signal.medfilt2d(np.asarray(mask_x_)[0, :, :, 0, ],
kernel_size=k_size2)
new_file = file.replace(".tiff", ".tiff")
SimpleITK.WriteImage(SimpleITK.GetImageFromArray((1.0 - mask_x_) * fx_),
SAVE_F + "/" + new_file)
SimpleITK.WriteImage(SimpleITK.GetImageFromArray(mask_x_),
SAVE_M + "/" + new_file)
print(file + "==>" + new_file)
def noise_clipping_filter(lo_images_roi, hi_images_roi, apply_log=True):
M = lo_images_roi.shape[0]
de_images_clip = lo_images_roi.copy()
#slopes from the paper
up_slope = 0.44 #0.72
down_slope = 0.72 #0.44
#only return high images, as only the yahve been modified
high_images = []
for i in range(M):
if apply_log:
lo_bkg = signal.medfilt2d(
np.log(lo_images_roi[i, :, :]).astype(np.float32))
hi_bkg = signal.medfilt2d(
np.log(hi_images_roi[i, :, :]).astype(np.float32))
#then subtract each of images from background
lo_contrast = (np.log(lo_images_roi[i, :, :]) - lo_bkg)
hi_contrast = (np.log(hi_images_roi[i, :, :]) - hi_bkg)
#convert zeros to one
lo_contrast[lo_contrast == 0] = 1
#hi_contrast[hi_contrast==0] =1
#now define ratio
ratio = hi_contrast / lo_contrast
clip_hi_contrast = hi_contrast.copy()
#now clip slopes
clip_hi_contrast[
ratio > up_slope] = up_slope * lo_contrast[ratio > up_slope]
clip_hi_contrast[ratio < down_slope] = down_slope * lo_contrast[
ratio < down_slope]
#now convert back images to normal
clip_hi_tmp = (clip_hi_contrast.copy() + hi_bkg)
clip_hi_norm = (2**16 - 1) * (clip_hi_tmp) / (clip_hi_tmp.max() -
clip_hi_tmp.min())
# clip_hi_contrast = np.exp(clip_hi_contrast)
high_images.append(clip_hi_norm)
else:
#first compute low and high background
lo_bkg = signal.medfilt2d(lo_images_roi[i, :, :].astype(
np.float32))
hi_bkg = signal.medfilt2d(hi_images_roi[i, :, :].astype(
np.float32))
#then subtract each of images from background
lo_contrast = (lo_images_roi[i, :, :] - lo_bkg)
hi_contrast = (hi_images_roi[i, :, :] - hi_bkg)
#convert zeros to one
lo_contrast[lo_contrast == 0] = 1
hi_contrast[hi_contrast == 0] = 1
#loot at the ratio between hi_contrast and lo_contrast
#convert hi_pixel values min(h_pixel,0.72) and max(h_pixel,0.44)
# plt.plot(lo_contrast.ravel(),clip_hi_constrast.ravel(),"b.")
# plt.xlabel("Low contrast")
# plt.ylabel("Low contrast")
# plt.xlim(-0.1,0.1)
# plt.ylim(-0.1,0.1)
# plt.show()
# fig,axes = plt.subplots(ncols=2)
# ax = axes.ravel()
# ax[0].imshow(hi_images_roi[-1],label="original",cmap="gray")
# ax[1].imshow(high_images[-1],label="clipped",cmap="gray")
# plt.show()
return np.array(high_images)
def test_whole_image(imgIn,
blkSize,
numSample,
filter=False,
solver="L2",
display=False,
lambda1=0):
# Make Sure That We are Not Trying to Sample More Points than the Size of the Mask
assert (numSample < blkSize * blkSize)
# Set the Desired Dimensions
dimension = (blkSize, blkSize) #(8, 8) # Dimension for Block
# Read the Boat Images
matrix = imgRead(imgIn)[:, :, 0] # Read Image into Matrix
P, Q = matrix.shape[0], matrix.shape[1] # Width and Length of Matrix
# Create Transformation matrix
T_Matrix = DCT_Matrix(dimension[0], dimension[1])
# Split the Image Into Patches
patches = image.extract_patches_2d(
matrix, dimension) # Turn into Patches the main Matrix
# Random Initilize Mask
mask = create_mask(numSample, dimension[0] *
dimension[1]) # New Mask is Made in Each Iteration
# Transform the Patches
new_image = []
# MSE LIST
MSE_List = []
for patch in tqdm(patches):
# Proceed To Do Function On Each Patch
if solver == "L1":
new_patch = transform_Patch(dimension, mask, patch, T_Matrix,
solver)
if solver == "L2":
new_patch = transform_Patch(dimension, mask, patch, T_Matrix,
solver)
if solver == "Lasso":
new_patch = transform_Patch(dimension,
mask,
patch,
T_Matrix,
solver,
lambda1=lambda1)
# Apply Median Filter
if filter == True:
new_patch = medfilt2d(new_patch, kernel_size=3)
# Append Patch To Image to Recreate Image
new_image.append(new_patch)
# Calculate MSE Square
MSE = mean_squared_error(patch, new_patch)
MSE_List.append(MSE)
# Convert List to Numpy Matrix in Desired Dimensions
new_image = np.asarray(new_image)
# print("")
# print(new_image[0])
# print(new_image.shape)
# Calculate MSE In Each Image
MSE_List = np.asarray(MSE_List)
#print("MSE Average:", np.average(MSE_List))
# Use SciKit To Reconstruct the Image
reconstructed_image = image.reconstruct_from_patches_2d(new_image,
image_size=(P, Q))
# Image MSE
Image_MSE = mean_squared_error(matrix, reconstructed_image)
print("MSE Total:", Image_MSE)
if display == True:
plt.imshow(reconstructed_image)
fig, (ax_1, ax_2) = plt.subplots(nrows=1, ncols=2, sharex=True)
ax_1.set_title("Original Image")
ax_1.imshow(matrix)
ax_2.set_title("Reconstructed Image")
ax_2.imshow(reconstructed_image)
plt.savefig("Block16x16.png")
title = "Block Size = " + str(blkSize) + " x " + str(
blkSize) + " & Mask=" + str(numSample)
fig.suptitle(title)
plt.show()
return reconstructed_image, Image_MSE
import numpy as np
import matplotlib
import matplotlib.pyplot as plt
from PIL import Image
from scipy import signal
from scipy import misc
from skimage import data
from skimage import transform
imsrc = Image.open('pepper_salt_graph.jpg').convert('L')
ax = plt.imshow(imsrc, cmap='gray')
plt.show()
# median filter
print(imsrc)
imout = signal.medfilt2d(imsrc, 3)
plt.imshow(imout, cmap='gray')
plt.show()
# detailed image format conversion, see https://www.jianshu.com/p/bdd9bfcbedb7
#==============================================================================
# # now interpolate onto grid
#==============================================================================
data_points = np.array([oned_res_arr['grid_north'], oned_res_arr['grid_east']])
pad_n = mdm.pad_north
pad_e = mdm.pad_east
x = mdm.grid_north[pad_n:-pad_n - 1]
y = mdm.grid_east[pad_e:-pad_e - 1]
new_north, new_east = np.meshgrid(x, y)
# apply a median filter to get rid of outlying points
rs = signal.medfilt2d(oned_res_arr['res'], kernel_size=(5, 3))
new_res = np.zeros_like(mdm.res_model)
for z_index in range(mdm.nodes_z.size):
new_res[pad_n:-pad_n, pad_e:-pad_e,
z_index] = interpolate.griddata(data_points.T,
rs[:, z_index],
(new_north, new_east),
method='cubic',
fill_value=fill_res).T
new_res[np.where(new_res == 0.0)] = fill_res
#==============================================================================
# # need to fill the model so there are no hard boundaries
print 'Convolution' print '~~~~~~~~~~~~~~' #method = "_convolution" #dem_convolution_filter = signal.convolve(image_array,filter1,mode='same') #print dem_convolution_filter.shape #filtered_image = dem_convolution_filter #filtered_image_name = "dem_convolution_filter_kernel_%i" % kernel print '~~~~~~~~~~~~~~' print 'Median' print '~~~~~~~~~~~~~~' method = "_median" dem_median_filter = signal.medfilt2d(image_array,kernel_size=kernel) print dem_median_filter.shape filtered_image = dem_median_filter filtered_image_name = "dem_median_filter_kernel_%i" % kernel print '~~~~~~~~~~~~~~' print 'Resample the result and display' print '~~~~~~~~~~~~~~' #print "%s (%s):" % (filtered_image, method) #print filtered_image #print "%s (%s) resampled by a factor of 0.25" % (filtered_image_name, method) #dem_filtered_025_refactor = ndimage.zoom(filtered_image, 0.25, order=0) ## essentially refactors the array by a factor the order value denotes the interpolation algorithm used #print "%s (%s) resampled for viewing:" % (filtered_image_name, method)
def filtering(x, y, z):
m_z = np.reshape(
z,
(len(np.unique(y)), len(np.unique(x)))) # Transform array into matrix
s = medfilt2d(m_z)
return np.reshape(s, (int(len(x)), ))
def augmentDepth(depth, obj_mask, mask_ori, shadowClK, shadowMK, blurK, blurS, depthNoise, method):
sensor = True
simplex = True
if method == 0:
pass
elif method == 1:
sensor = True
simplex = False
elif method == 2:
sensor = False
simplex = True
# erode and blur mask to get more realistic appearance
partmask = mask_ori
partmask = partmask.astype(np.float32)
#mask = partmask > (np.median(partmask) * 0.4)
partmask = np.where(partmask > 0.0, 255.0, 0.0)
cv2.imwrite('/home/sthalham/partmask.png', partmask)
# apply shadow
kernel = np.ones((shadowClK, shadowClK))
partmask = cv2.morphologyEx(partmask, cv2.MORPH_OPEN, kernel)
partmask = signal.medfilt2d(partmask, kernel_size=shadowMK)
partmask = partmask.astype(np.uint8)
mask = partmask > 20
depth = np.where(mask, depth, 0.0)
if sensor is True:
depthFinal = cv2.resize(depth, None, fx=1 / 2, fy=1 / 2)
res = (((depthFinal / 1000.0) * 1.41421356) ** 2)
depthFinal = cv2.GaussianBlur(depthFinal, (blurK, blurK), blurS, blurS)
# quantify to depth resolution and apply gaussian
dNonVar = np.divide(depthFinal, res, out=np.zeros_like(depthFinal), where=res != 0)
dNonVar = np.round(dNonVar)
dNonVar = np.multiply(dNonVar, res)
noise = np.multiply(dNonVar, depthNoise)
depthFinal = np.random.normal(loc=dNonVar, scale=noise, size=dNonVar.shape)
depth = cv2.resize(depthFinal, (resX, resY))
if simplex is True:
# fast perlin noise
seed = np.random.randint(2 ** 31)
N_threads = 4
perlin = fns.Noise(seed=seed, numWorkers=N_threads)
drawFreq = random.uniform(0.05, 0.2) # 0.05 - 0.2
# drawFreq = 0.5
perlin.frequency = drawFreq
perlin.noiseType = fns.NoiseType.SimplexFractal
perlin.fractal.fractalType = fns.FractalType.FBM
drawOct = [4, 8]
freqOct = np.bincount(drawOct)
rndOct = np.random.choice(np.arange(len(freqOct)), 1, p=freqOct / len(drawOct), replace=False)
perlin.fractal.octaves = rndOct
perlin.fractal.lacunarity = 2.1
perlin.fractal.gain = 0.45
perlin.perturb.perturbType = fns.PerturbType.NoPerturb
# linemod
if not sensor:
# noise according to keep it unreal
#noiseX = np.random.uniform(0.0001, 0.1, resX * resY) # 0.0001 - 0.1
#noiseY = np.random.uniform(0.0001, 0.1, resX * resY) # 0.0001 - 0.1
#noiseZ = np.random.uniform(0.01, 0.1, resX * resY) # 0.01 - 0.1
#Wxy = np.random.randint(0, 10) # 0 - 10
#Wz = np.random.uniform(0.0, 0.005) #0 - 0.005
noiseX = np.random.uniform(0.001, 0.01, resX * resY) # 0.0001 - 0.1
noiseY = np.random.uniform(0.001, 0.01, resX * resY) # 0.0001 - 0.1
noiseZ = np.random.uniform(0.01, 0.1, resX * resY) # 0.01 - 0.1
Wxy = np.random.randint(2, 5) # 0 - 10
Wz = np.random.uniform(0.0001, 0.004) # 0 - 0.005
else:
noiseX = np.random.uniform(0.001, 0.01, resX * resY) # 0.0001 - 0.1
noiseY = np.random.uniform(0.001, 0.01, resX * resY) # 0.0001 - 0.1
noiseZ = np.random.uniform(0.01, 0.1, resX * resY) # 0.01 - 0.1
Wxy = np.random.randint(1, 5) # 1 - 5
Wz = np.random.uniform(0.0001, 0.004) #0.0001 - 0.004
# tless
#noiseX = np.random.uniform(0.001, 0.1, resX * resY) # 0.0001 - 0.1
#noiseY = np.random.uniform(0.001, 0.1, resX * resY) # 0.0001 - 0.1
#noiseZ = np.random.uniform(0.01, 0.1, resX * resY) # 0.01 - 0.1
#Wxy = np.random.randint(2, 8) # 0 - 10
#Wz = np.random.uniform(0.0, 0.005)
X, Y = np.meshgrid(np.arange(resX), np.arange(resY))
coords0 = fns.empty_coords(resX * resY)
coords1 = fns.empty_coords(resX * resY)
coords2 = fns.empty_coords(resX * resY)
coords0[0, :] = noiseX.ravel()
coords0[1, :] = Y.ravel()
coords0[2, :] = X.ravel()
VecF0 = perlin.genFromCoords(coords0)
VecF0 = VecF0.reshape((resY, resX))
coords1[0, :] = noiseY.ravel()
coords1[1, :] = Y.ravel()
coords1[2, :] = X.ravel()
VecF1 = perlin.genFromCoords(coords1)
VecF1 = VecF1.reshape((resY, resX))
coords2[0, :] = noiseZ.ravel()
coords2[1, :] = Y.ravel()
coords2[2, :] = X.ravel()
VecF2 = perlin.genFromCoords(coords2)
VecF2 = VecF2.reshape((resY, resX))
x = np.arange(resX, dtype=np.uint16)
x = x[np.newaxis, :].repeat(resY, axis=0)
y = np.arange(resY, dtype=np.uint16)
y = y[:, np.newaxis].repeat(resX, axis=1)
# vanilla
#fx = x + Wxy * VecF0
#fy = y + Wxy * VecF1
#fx = np.where(fx < 0, 0, fx)
#fx = np.where(fx >= resX, resX - 1, fx)
#fy = np.where(fy < 0, 0, fy)
#fy = np.where(fy >= resY, resY - 1, fy)
#fx = fx.astype(dtype=np.uint16)
#fy = fy.astype(dtype=np.uint16)
#Dis = depth[fy, fx] + Wz * VecF2
#depth = np.where(Dis > 0, Dis, 0.0)
#print(x.shape)
#print(np.amax(depth))
#print(np.amin(depth))
Wxy_scaled = depth * 0.001 * Wxy
Wz_scaled = depth * 0.001 * Wz
# scale with depth
fx = x + Wxy_scaled * VecF0
fy = y + Wxy_scaled * VecF1
fx = np.where(fx < 0, 0, fx)
fx = np.where(fx >= resX, resX - 1, fx)
fy = np.where(fy < 0, 0, fy)
fy = np.where(fy >= resY, resY - 1, fy)
fx = fx.astype(dtype=np.uint16)
fy = fy.astype(dtype=np.uint16)
Dis = depth[fy, fx] + Wz_scaled * VecF2
depth = np.where(Dis > 0, Dis, 0.0)
return depth
)
)
# remove the static shift from the injection survey
s, new_z = edi_inj.Z.no_ss(1 / sx, 1 / sy)
edi_inj.Z.z = new_z
# --> fill z arrays
z_base_arr[ss, :, :, :] = edi_base.Z.z
z_inj_arr[ss, :, :, :] = edi_inj.Z.z
# --> apply a spatial median filter
for ii in range(2):
for jj in range(2):
z_base_arr[:, :, ii, jj].real = sps.medfilt2d(
z_base_arr[:, :, ii, jj].real, kernel_size=mks
)
z_base_arr[:, :, ii, jj].imag = sps.medfilt2d(
z_base_arr[:, :, ii, jj].imag, kernel_size=mks
)
z_inj_arr[:, :, ii, jj].real = sps.medfilt2d(
z_inj_arr[:, :, ii, jj].real, kernel_size=mks
)
z_inj_arr[:, :, ii, jj].imag = sps.medfilt2d(
z_inj_arr[:, :, ii, jj].imag, kernel_size=mks
)
# --> rewrite files
for ss, station in enumerate(station_list):
fn_base = os.path.join(edipath_base, station + ".edi")
fn_inj = os.path.join(edipath_inj, station + ".edi")
def getLimitData(pipeline, pos):
color_image, depth_image = getInputData(pipeline)
color_cut_image = color_image[pos[0]:pos[1], pos[2]:pos[3]]
depth_cut_image = depth_image[pos[0]:pos[1], pos[2]:pos[3]].astype(float)
depth_cut_image = signal.medfilt2d(depth_cut_image, (3, 3))
return color_cut_image, depth_cut_image
def median_filtering(img):
smooth_img = np.zeros(img.shape)
smooth_img[:, :, 0] = signal.medfilt2d(img[:, :, 0])
smooth_img[:, :, 1] = signal.medfilt2d(img[:, :, 1])
smooth_img[:, :, 2] = signal.medfilt2d(img[:, :, 2])
return smooth_img
def find_slits_corners_aps_1id(
img,
method='quadrant+',
medfilt2_kernel_size=3,
medfilt_kernel_size=23,
):
"""
Automatically locate the slit box location by its four corners.
NOTE:
The four slits that form a binding box is the current setup at aps_1id,
which reduce the illuminated region on the detector. Since the slits are
stationary, they can serve as a reference to check detector drifting
during the scan. Technically, the four slits should be used to find
the transformation matrix (not necessarily affine) to correct the image.
However, since we are dealing with 2D images with very little distortion,
affine transformation matrices were used for approximation. Therefore
the "four corners" are used instead of all four slits.
Parameters
----------
img : np.ndarray
2D images
method : str, ['simple', 'quadrant', 'quadrant+'], optional
method for auto detecting slit corners
- simple :: assume a rectange slit box, fast but less accurate
(1 pixel precision)
- quadrant :: subdivide the image into four quandrant, then use
an explicit method to find the corner
(1 pixel precision)
- quadrant+ :: similar to quadrant, but use curve_fit (gauss1d) to
find the corner
(0.1 pixel precision)
medfilt2_kernel_size : int, optional
2D median filter kernel size for noise reduction
medfilt_kernel_size : int, optional
1D median filter kernel size for noise reduction
Returns
-------
tuple
autodetected slit corners (counter-clockwise order)
(upperLeft, lowerLeft, lowerRight, upperRight)
"""
img = medfilt2d(
np.log(img.astype(np.float64)),
kernel_size=medfilt2_kernel_size,
)
rows, cols = img.shape
# simple method is simple, therefore it stands out
if method.lower() == 'simple':
# assuming a rectangle type slit box
col_std = medfilt(np.std(img, axis=0), kernel_size=medfilt_kernel_size)
row_std = medfilt(np.std(img, axis=1), kernel_size=medfilt_kernel_size)
# NOTE: in the tiff img
# x is col index, y is the row index ==> key point here !!!
# img slicing is doen with img[row_idx, col_idx]
# ==> so the image idx and corner position are FLIPPED!
_left = np.argmax(np.gradient(col_std))
_right = np.argmin(np.gradient(col_std))
_top = np.argmax(np.gradient(row_std))
_bottom = np.argmin(np.gradient(row_std))
cnrs = np.array([
[_left, _top],
[_left, _bottom],
[_right, _bottom],
[_right, _top],
])
else:
# predefine all quadrants
# Here let's assume that the four corners of the slit box are in the
# four quadrant defined by the center of the image
# i.e.
# uppper left quadrant: img[0 :cnt[1], 0 :cnt[0]] => quadarnt origin = (0, 0)
# lower left quadrant: img[cnt[1]: , 0 :cnt[0]] => quadarnt origin = (cnt[0], 0)
# lower right quadrant: img[cnt[1]: , cnt[0]: ] => quadarnt origin = (cnt[0], cnt[1])
# upper right quadrant: img[0 :cnt[1], cnt[0]: ] => quadarnt
# origin = (0, cnt[1])
# center of image that defines FOUR quadrants
cnt = [int(cols / 2), int(rows / 2)]
Quadrant = namedtuple('Quadrant', 'img col_func, row_func')
quadrants = [
Quadrant(img=img[0:cnt[1], 0:cnt[0]],
col_func=np.argmax,
row_func=np.argmax), # upper left, 1st quadrant
# lower left, 2nd quadrant
Quadrant(img=img[cnt[1]:, 0:cnt[0]],
col_func=np.argmax,
row_func=np.argmin),
# lower right, 3rd quadrant
Quadrant(img=img[cnt[1]:, cnt[0]:],
col_func=np.argmin,
row_func=np.argmin),
# upper right, 4th quadrant
Quadrant(img=img[0:cnt[0], cnt[1]:],
col_func=np.argmin,
row_func=np.argmax),
]
# the origin in each quadrants ==> easier to set it here
quadrantorigins = np.array([
[0, 0], # upper left, 1st quadrant
[0, cnt[1]], # lower left, 2nd quadrant
# lower right, 3rd quadrant
[cnt[0], cnt[1]],
[cnt[1], 0], # upper right, 4th quadrant
])
# init four corners
cnrs = np.zeros((4, 2))
if method.lower() == 'quadrant':
# the standard quadrant method
for i, q in enumerate(quadrants):
cnrs[i, :] = np.array([
q.col_func(
np.gradient(
medfilt(np.std(q.img, axis=0),
kernel_size=medfilt_kernel_size))
), # x is col_idx
q.row_func(
np.gradient(
medfilt(np.std(q.img, axis=1),
kernel_size=medfilt_kernel_size))),
# y is row_idx
])
# add the origin offset back
cnrs = cnrs + quadrantorigins
elif method.lower() == 'quadrant+':
# use Gaussian curve fitting to achive subpixel precision
# TODO:
# improve the curve fitting with Lorentz and Voigt fitting function
for i, q in enumerate(quadrants):
# -- find x subpixel position
cnr_x_guess = q.col_func(
np.gradient(
medfilt(np.std(q.img, axis=0),
kernel_size=medfilt_kernel_size)))
# isolate the strongest peak to fit
tmpx = np.arange(cnr_x_guess - 10, cnr_x_guess + 11)
tmpy = np.gradient(np.std(q.img, axis=0))[tmpx]
# tmpy[0] is the value from the highest/lowest pixle
# tmpx[0] is basically cnr_x_guess
# 5.0 is the guessted std,
coeff, _ = curve_fit(
gauss1d,
tmpx,
tmpy,
p0=[tmpy[0], tmpx[0], 5.0],
maxfev=int(1e6),
)
cnrs[i, 0] = coeff[1] # x position
# -- find y subpixel positoin
cnr_y_guess = q.row_func(
np.gradient(
medfilt(np.std(q.img, axis=1),
kernel_size=medfilt_kernel_size)))
# isolate the peak (x, y here is only associated with the peak)
tmpx = np.arange(cnr_y_guess - 10, cnr_y_guess + 11)
tmpy = np.gradient(np.std(q.img, axis=1))[tmpx]
coeff, _ = curve_fit(
gauss1d,
tmpx,
tmpy,
p0=[tmpy[0], tmpx[0], 5.0],
maxfev=int(1e6),
)
cnrs[i, 1] = coeff[1] # y posiiton
# add the quadrant shift back
cnrs = cnrs + quadrantorigins
else:
raise NotImplementedError(
"Available methods are: simple, quadrant, quadrant+")
# return the slit corner detected
return cnrs
def test_whole_image_KFOLD(imgIn,
blkSize,
numSample,
filter=False,
solver="L2",
display=False,
lambda1=0,
K_FOLD=True,
Solve=True,
fileName="Results.txt",
sampleSize=100):
# Make Sure That We are Not Trying to Sample More Points than the Size of the Mask
assert (numSample < blkSize * blkSize)
# Set the Desired Dimensions
dimension = (blkSize, blkSize) #(8, 8) # Dimension for Block
# Read the Boat Images
matrix = imgRead(imgIn)[:, :, 0] # Read Image into Matrix
P, Q = matrix.shape[0], matrix.shape[1] # Width and Length of Matrix
# Create Transformation matrix
T_Matrix = DCT_Matrix(dimension[0], dimension[1])
# Split the Image Into Patches
patches = image.extract_patches_2d(
matrix, dimension) # Turn into Patches the main Matrix
# Random Initilize Mask
mask = create_mask(numSample, dimension[0] *
dimension[1]) # New Mask is Made in Each Iteration
# Conduct K-Folds to find best alpha value
txtFile = fileName + ".txt"
if K_FOLD == True and solver == "Lasso":
############################# Declare Training Patch ###########################################################
training_patches = []
for i in range(sampleSize):
j = np.random.randint(len(patches))
training_patches.append(patches[j])
training_patches = np.asarray(training_patches)
############################ Lambda List #######################################################################
# Declare Lambda Range
lambdas = [10**(-i) for i in range(1, 6)]
# Begin Optimal Testing
#print("Conducting K-Fold Testing to Find Optimal Lambda")
kf = KFold(n_splits=6, shuffle=True) # Declare K-Fold
lambda_list = [] # Lambda List
lambdas_list = [] # Lambdas
index_i = 1 # Index
################################## Conduct K-Folds #############################################################
for i in tqdm(range(20), desc="Run", position=0):
print("##################### Running Trial", index_i,
"######################") # Print Fold Number
index_i += 1
for train_index, test_index in kf.split(training_patches):
X_train, X_test = training_patches[
train_index], training_patches[test_index]
################################ Training Fold #############################################################
# Lambda Error
lambda_error_list = []
# Now We Have The Index of the Models We Need To train
for lambda2 in tqdm(lambdas, desc="Lambda", position=0):
# Random Initilize Mask
mask = create_mask(
numSample, dimension[0] *
dimension[1]) # New Mask is Made in Each Iteration
MSE_LIST = []
for patch in tqdm(
X_train, desc="Training", position=1
): # Go Through the Training Portion for Lambda
local_mse_list = [
] ## Local MSE List to Calculate the 20 Lambda Exam
for n in range(1): # Run Through Each Loop 20 Times
new_patch = transform_Patch(
dimension,
mask,
patch,
T_Matrix,
solver,
lambda1=lambda2) # Optimize Patch
MSE = mean_squared_error(
patch, new_patch) # Calculate MSE
local_mse_list.append(
MSE) # Append to Local MSE LIST
MSE_LIST.append(mean(local_mse_list))
# Now Convert the MSE_LIST TO NUMPY and calculate Mean
mean_mse_list = mean(MSE_LIST)
#print("Average of Lambda:", lambda2, "is:", mean_mse_list)
lambda_error_list.append(mean_mse_list)
#print(lambdas)
#print(lambda_error_list)
############################################################################################################
best_lambda_index = lambda_error_list.index(
min(lambda_error_list))
best_lambda = lambdas[best_lambda_index]
#print("Best Lambda:",best_lambda)
test_mse_list = []
for patch in tqdm(X_test, desc="Testing", position=1):
new_patch = transform_Patch(
dimension,
mask,
patch,
T_Matrix,
solver,
lambda1=best_lambda) # Optimize Patch
MSE = mean_squared_error(patch, new_patch) # Calculate MSE
test_mse_list.append(MSE)
mean_test_mse_list = mean(test_mse_list)
#print("MSE of Test:", mean_test_mse_list)
lambdas_list.append(best_lambda)
lambda_list.append(mean_test_mse_list)
# Find the Best Overall Lambda
min_final_mse = min(lambda_list)
print("Minimum MSE:", min_final_mse)
final_lambda_index = lambda_list.index(min_final_mse)
final_lambda = lambdas_list[final_lambda_index]
print("Best Lambda:", final_lambda)
print_line = str(final_lambda) + " " + str(min_final_mse) + "\n"
# Append Final Results to File
with open(fileName, 'a') as f:
f.write(print_line)
if Solve == True:
print(
'############################ Solving Final Image Using best Lambda########################################'
)
# Random Initilize Mask
mask = create_mask(numSample, dimension[0] *
dimension[1]) # New Mask is Made in Each Iteration
patches = image.extract_patches_2d(
matrix, dimension) # Turn into Patches the main Matrix
# Transform the Patches
new_image = []
# MSE LIST
MSE_List = []
for patch in tqdm(patches):
# Proceed To Do Function On Each Patch
if solver == "L1":
new_patch = transform_Patch(dimension, mask, patch, T_Matrix,
solver)
if solver == "L2":
new_patch = transform_Patch(dimension, mask, patch, T_Matrix,
solver)
if solver == "Lasso":
new_patch = transform_Patch(dimension,
mask,
patch,
T_Matrix,
solver,
lambda1=final_lambda)
# Apply Median Filter
if filter == True:
new_patch = medfilt2d(new_patch, kernel_size=3)
# Append Patch To Image to Recreate Image
new_image.append(new_patch)
# Calculate MSE Square
MSE = mean_squared_error(patch, new_patch)
MSE_List.append(MSE)
# Convert List to Numpy Matrix in Desired Dimensions
new_image = np.asarray(new_image)
# print("")
# print(new_image[0])
# print(new_image.shape)
# Calculate MSE In Each Image
MSE_List = np.asarray(MSE_List)
#print("MSE Average:", np.average(MSE_List))
# Use SciKit To Reconstruct the Image
reconstructed_image = image.reconstruct_from_patches_2d(new_image,
image_size=(P,
Q))
# Image MSE
Image_MSE = mean_squared_error(matrix, reconstructed_image)
if display == True:
with open(fileName, 'a') as f:
linePrint = "MSE Total With Original: " + str(Image_MSE) + "\n"
f.write(linePrint)
plt.imshow(reconstructed_image)
fig, (ax_1, ax_2) = plt.subplots(nrows=1, ncols=2, sharex=True)
ax_1.set_title("Original Image")
ax_1.imshow(matrix)
ax_2.set_title("Reconstructed Image")
ax_2.imshow(reconstructed_image)
plt.savefig("Block16x16.png")
title = "Block Size = " + str(blkSize) + " x " + str(
blkSize) + " & Mask=" + str(numSample) + " Lambda:" + str(
final_lambda)
fig.suptitle(title)
plotName = fileName + "png"
plt.savefig(plotName)
return reconstructed_image, Image_MSE
def Conv_MRELBP(image, pars, savepath=None, sample=None, normalize=True):
"""Calculates MRELBP using convolutions. Alternate method for calculating LBP features."""
# Unpack parameters
n = pars['N']
r_large = pars['R']
r_small = pars['r']
w_large = pars['wl']
w_small = pars['ws']
w_center = pars['wc']
# Whiten the image
imu = image.mean()
istd = image.std()
im = (image - imu) / istd
# Get image dimensions
h, w = im.shape[:2]
# Make kernels
kR = []
kr = []
dtheta = np.pi * 2 / n
for k in range(0, n):
_kernel = weight_matrix_bilin(r_large, -k * dtheta, val=0)
kR.append(_kernel)
_kernel = weight_matrix_bilin(r_small, -k * dtheta, val=0)
kr.append(_kernel)
# Make median filtered images
imc = medfilt2d(im.copy(), w_center)
imR = medfilt2d(im.copy(), w_large)
imr = medfilt2d(im.copy(), w_small)
# Get LBP images
neighbR = np.zeros((h, w, n))
neighbr = np.zeros((h, w, n))
for k in range(n):
_neighb = correlate(imR, kR[k])
neighbR[:, :, k] = _neighb
_neighb = correlate(imr, kr[k])
neighbr[:, :, k] = _neighb
# Crop valid convolution region
d = r_large + w_large // 2
h -= 2 * d
w -= 2 * d
neighbR = neighbR[d:-d, d:-d, :]
neighbr = neighbr[d:-d, d:-d, :]
imc = imc[d:-d, d:-d]
# Subtraction
_muR = neighbR.mean(2).reshape(h, w, 1)
for k in range(n):
try:
muR = np.concatenate((muR, _muR), 2)
except NameError:
muR = _muR
_mur = neighbr.mean(2).reshape(h, w, 1)
for k in range(n):
try:
mur = np.concatenate((mur, _mur), 2)
except NameError:
mur = _mur
diffc = (imc - imc.mean()) >= 0
diffR = (neighbR - muR) >= 0
diffr = (neighbr - mur) >= 0
diffR_r = (neighbR - neighbr) >= 0
# Compute lbp images
lbpc = diffc
lbpR = np.zeros((h, w))
lbpr = np.zeros((h, w))
lbpR_r = np.zeros((h, w))
for k in range(n):
lbpR += diffR[:, :, k] * (2**k)
lbpr += diffr[:, :, k] * (2**k)
lbpR_r += diffR_r[:, :, k] * (2**k)
# Get LBP histograms
histc = np.zeros((1, 2))
histR = np.zeros((1, 2**n))
histr = np.zeros((1, 2**n))
histR_r = np.zeros((1, 2**n))
histc[0, 0] = (lbpc == 1).astype(np.float32).sum()
histc[0, 1] = (lbpc == 0).astype(np.float32).sum()
for k in range(2**n):
histR[0, k] = (lbpR == k).astype(np.float32).sum()
histr[0, k] = (lbpr == k).astype(np.float32).sum()
histR_r[0, k] = (lbpR_r == k).astype(np.float32).sum()
# Mapping
mapping = get_mapping(n)
histR = map_lbp(histR, mapping)
histr = map_lbp(histr, mapping)
histR_r = map_lbp(histR_r, mapping)
# Histogram normalization
if normalize:
histc /= np.sum(histc)
histR /= np.sum(histR)
histr /= np.sum(histr)
histR_r /= np.sum(histR_r)
# Append histograms
hist = np.concatenate((histc, histR, histr, histR_r), 1)
if savepath is not None and sample is not None:
print_images([lbpR, lbpr, lbpR_r],
subtitles=['Large', 'Small', 'Radial'],
title=sample,
save_path=savepath,
sample=sample + '.png')
return hist
def MRELBP(image,
parameters,
eps=1e-06,
normalize=False,
args=None,
sample=None):
""" Takes Median Robust Extended Local Binary Pattern from image im
Uses n neighbours from radii r_large and r_small, r_large must be larger than r_small
Median filter uses kernel sizes weight_center for center pixels, w_r[0] for larger radius and w_r[1]
#or smaller radius
Grayscale values are centered at their mean and scales with global standad deviation
Parameters
----------
image : ndarray
Input image. Standardized to local contrast in the pipelines.
parameters : dict
Dictionary containing LBP parameters:
N = Number of neighbours used in MRELBP (4 orthogonal and 4 diagonal neighbours).
R = Distance of center pixel from neighbours used in obtaining large image.
r = Distance of center pixel from neighbours used in obtaining small image.
wc = Kernel size used in median filtering center image.
wl = Kernel size used in median filtering large LBP image.
ws = Kernel size used in median filtering small LBP image.
eps : float
Error residual. Defaults to 1e-6
normalize : bool
Choice whether to normalize LBP histograms by sum.
args : str
Path for saving LBP images.
sample : str
Name of the sample used in saving images.
Returns
-------
MRELBP histograms calculated with rotation invariant uniform mapping.
Length of 32 (2 center + 10 large + 10 small + 10 radial).
"""
n = parameters['N']
r_large = parameters['R']
r_small = parameters['r']
weight_center = parameters['wc']
weight_large = parameters['wl']
weight_small = parameters['ws']
# Mean grayscale value and std
mean_image = image.mean()
std_image = image.std()
# Centering and scaling with std
image_scaled = (image - mean_image) / std_image
# Median filtering
image_center = medfilt2d(image_scaled.copy(), weight_center)
# Center pixels
dist = round(r_large + (weight_large - 1) / 2)
image_center = image_center[dist:-dist, dist:-dist]
# Subtracting the mean pixel value from center pixels
image_center -= image_center.mean()
# Binning center pixels
center_hist = np.zeros((1, 2))
center_hist[0, 0] = np.sum(image_center >= 0)
center_hist[0, 1] = np.sum(image_center < 0)
# --------------- #
# center_hist[0,0] = np.sum(image_center>=-1e-06)
# center_hist[0,1] = np.sum(image_center<-1e-06)
# --------------- #
# Median filtered images for large and small radius
image_large = medfilt2d(image_scaled.copy(), weight_large)
image_small = medfilt2d(image_scaled.copy(), weight_small)
# Neighbours
pi = np.pi
# Empty arrays for the neighbours
row, col = np.shape(image_center)
n_large = np.zeros((row, col, n))
n_small = np.zeros((row, col, n))
for k in range(n):
# Angle to the neighbour
theta = k * (-1 * 2 * pi / n)
# Large neighbourhood
x = dist + r_large * np.cos(theta)
y = dist + r_large * np.sin(theta)
if abs(x - round(x)) < eps and abs(y - round(y)) < eps:
x = int(round(x))
y = int(round(y))
p = image_large[y:y + row, x:x + col]
else:
p = image_bilinear(image_large, col, x, row, y)
n_large[:, :, k] = p
# Small neighbourhood
x = dist + r_small * np.cos(theta)
y = dist + r_small * np.sin(theta)
if abs(x - round(x)) < eps and abs(y - round(y)) < eps:
x = int(round(x))
y = int(round(y))
p = image_small[y:y + row, x:x + col]
else:
p = image_bilinear(image_small, col, x, row, y)
n_small[:, :, k] = p
# Thresholding radial neighbourhood
n_radial = n_large - n_small
# Subtraction of means
mean_large = n_large.mean(axis=2)
mean_small = n_small.mean(axis=2)
for k in range(n):
n_large[:, :, k] -= mean_large
n_small[:, :, k] -= mean_small
# Converting to binary images and taking the lbp values
# Initialization of arrays
lbp_large = np.zeros((row, col))
lbp_small = np.zeros((row, col))
lbp_radial = np.zeros((row, col))
for k in range(n):
lbp_large += (n_large[:, :, k] >=
0) * 2**k # NOTE ACCURACY FOR THRESHOLDING!!!
lbp_small += (n_small[:, :, k] >= 0) * 2**k
lbp_radial += (n_radial[:, :, k] >= 0) * 2**k
# --------------- #
# lbp_large += (n_large[:,:,k] >= -(eps ** 2)) * 2 ** k # NOTE ACCURACY FOR THRESHOLDING!!!
# lbp_small += (n_small[:,:,k] >= -(eps ** 2)) * 2 ** k
# lbp_radial += (n_radial[:,:,k] >= -(eps ** 2)) * 2 ** k
# --------------- #
# Calculating histograms with 2 ^ N bins
large_hist = np.zeros((1, 2**n))
small_hist = np.zeros((1, 2**n))
radial_hist = np.zeros((1, 2**n))
for k in range(2**n):
large_hist[0, k] = np.sum(lbp_large == k)
small_hist[0, k] = np.sum(lbp_small == k)
radial_hist[0, k] = np.sum(lbp_radial == k)
# Rotation invariant uniform mapping
mapping = get_mapping(n)
large_hist = map_lbp(large_hist, mapping)
small_hist = map_lbp(small_hist, mapping)
radial_hist = map_lbp(radial_hist, mapping)
# # Individual histogram normalization
# if normalize:
# center_hist /= np.sum(center_hist)
# large_hist /= np.sum(large_hist)
# small_hist /= np.sum(small_hist)
# radial_hist /= np.sum(radial_hist)
# Concatenate histograms
hist = np.concatenate((center_hist, large_hist, small_hist, radial_hist),
1)
if normalize:
hist /= np.sum(hist)
if args.save_images and args is not None and (('21_L3L' in sample) or
('20_R2M' in sample)):
# Map LBP images
lbp_large_mapped = map_lbp(lbp_large, mapping)
lbp_small_mapped = map_lbp(lbp_small, mapping)
lbp_radial_mapped = map_lbp(lbp_radial, mapping)
lbp_list = [lbp_large_mapped, lbp_small_mapped, lbp_radial_mapped]
# Load coefficients
coefs, _ = load_excel(args.save_path + '/' + 'weights_surf_sub.xlsx',
titles=['Weights_lin', 'Weights_log'])
thresh = 0.1
lin = coefs[0]
log = coefs[1]
lin = np.abs(np.insert(lin, [2, 9, 10, 17], 0)) > thresh
log = np.abs(np.insert(log, [2, 9, 10, 17], 0)) > thresh
masks = [
np.zeros(lbp_large.shape),
np.zeros(lbp_large.shape),
np.zeros(lbp_large.shape)
]
for mask in range(len(masks)):
for ind in range(int(np.max(lbp_large_mapped)) + 1):
masks[mask] += (ind + 1) * (lbp_list[mask]
== ind) * log[2 + mask * 10:2 +
(mask + 1) * 10][ind]
# No instances in LBP_large (0,8) and LBP_small (0,8)
print_images(lbp_list,
subtitles=['Large', 'Small', 'Radial'],
title=sample,
sample=sample + '.png')
# Print center image
fig = plt.figure(dpi=300)
ax = fig.add_subplot(111)
ax.imshow(image_center >= 0)
plt.title('Center')
plt.savefig(args.save_path + '/Images/LBP/' + sample + '_center.png',
transparent=True)
plt.close()
# Print unmapped LBP
#print_images([lbp_large, lbp_small, lbp_radial], subtitles=['Large', 'Small', 'Radial'], title=sample,
# save_path=args.save_path + '/Images/LBP/', sample=sample + '.png')
return hist
def manipulate_depth(fn_gt, fn_depth, fn_part, fn_mask):
with open(fn_gt, 'r') as stream:
query = yaml.load(stream)
bboxes = np.zeros((len(query), 5), np.int)
poses = np.zeros((len(query), 7), np.float32)
mask_ids = np.zeros((len(query)), np.int)
for j in range(len(query) - 1):
qr = query[j]
class_id = qr['class_id']
bbox = qr['bbox']
mask_ids[j] = int(qr['mask_id'])
pose = np.array(qr['pose']).reshape(4, 4)
bboxes[j, 0] = class_id
bboxes[j, 1:5] = np.array(bbox)
q_pose = tf3d.quaternions.mat2quat(pose[:3, :3])
poses[j, :4] = np.array(q_pose)
poses[j, 4:7] = np.array([pose[0, 3], pose[1, 3], pose[2, 3]])
pt = Imath.PixelType(Imath.PixelType.FLOAT)
golden = OpenEXR.InputFile(fn_depth)
dw = golden.header()['dataWindow']
size = (dw.max.x - dw.min.x + 1, dw.max.y - dw.min.y + 1)
redstr = golden.channel('R', pt)
depth = np.fromstring(redstr, dtype=np.float32)
depth.shape = (size[1], size[0])
centerX = kin_res_x / 2.0
centerY = kin_res_y / 2.0
uv_table = np.zeros((kin_res_y, kin_res_x, 2), dtype=np.int16)
column = np.arange(0, kin_res_y)
uv_table[:, :, 1] = np.arange(0, kin_res_x) - centerX
uv_table[:, :, 0] = column[:, np.newaxis] - centerY
uv_table = np.abs(uv_table)
depth = depth * np.cos(
np.radians(fov / kin_res_x * np.abs(uv_table[:, :, 1]))) * np.cos(
np.radians(fov / kin_res_x * uv_table[:, :, 0]))
depth = cv2.resize(depth, (resX, resY))
# erode and blur mask to get more realistic appearance
partmask = cv2.imread(fn_part, 0)
partmask = cv2.resize(partmask, (resX, resY))
partmask = partmask.astype(np.float32)
mask = partmask > (np.median(partmask) * 0.4)
partmask = np.where(mask, 255.0, 0.0)
###################################################
# DON'T REMOVE, best normal map up to now !!! tested without lateral noise !!!
kernel = np.ones((7, 7))
#partmask = signal.medfilt2d(partmask, kernel_size=7)
partmask = cv2.morphologyEx(partmask, cv2.MORPH_OPEN, kernel)
partmask = signal.medfilt2d(partmask, kernel_size=3)
###################################################
partmask = partmask.astype(np.uint8)
scaDep = 255.0 / np.nanmax(partmask)
depImg = np.multiply(partmask, scaDep)
depI = depImg.astype(np.uint8)
cv2.imwrite("/home/sthalham/visTests/mask.jpg", depI)
mask = partmask > 20
depth = np.where(mask, depth, 0.0)
scaDep = 255.0 / np.nanmax(depth)
depImg = np.multiply(depth, scaDep)
depI = depImg.astype(np.uint8)
cv2.imwrite("/home/sthalham/visTests/depMasked.jpg", depI)
onethird = cv2.resize(depth,
None,
fx=1 / 3,
fy=1 / 3,
interpolation=cv2.INTER_AREA)
res = (((onethird / 1000) * 1.41421356)**2) * 1000
depth = onethird
# discretize to resolution and apply gaussian
dNonVar = np.divide(depth, res, out=np.zeros_like(depth), where=res != 0)
dNonVar = np.round(dNonVar)
dNonVar = np.multiply(dNonVar, res)
noise = np.multiply(dNonVar, 0.0025)
depthFinal = np.random.normal(loc=dNonVar, scale=noise, size=dNonVar.shape)
depthFinal = cv2.GaussianBlur(depthFinal, (7, 7), 0.75, 0.75)
# apply retardo-noise to non-object parts
objmask = np.load(fn_mask)
objmask = cv2.resize(objmask, (720, 540))
objmask = np.where(objmask > 0, 255, 0)
print(objmask.shape)
print(np.nanmax(objmask))
print(np.nanmin(objmask))
edges = cv2.Canny(objmask, 100, 200)
cv2.imwrite('/home/sthalham/visTests/edges.jpg', edges)
# INTER_NEAREST - a nearest-neighbor interpolation
# INTER_LINEAR - a bilinear interpolation (used by default)
# INTER_AREA - resampling using pixel area relation. It may be a preferred method for image decimation, as it gives moire’-free results. But when the image is zoomed, it is similar to the INTER_NEAREST method.
# INTER_CUBIC - a bicubic interpolation over 4x4 pixel neighborhood
# INTER_LANCZOS4 - a Lanczos interpolation over 8x8 pixel neighborhood
depthFinal = cv2.resize(depthFinal,
None,
fx=3,
fy=3,
interpolation=cv2.INTER_NEAREST)
return depthFinal, bboxes, poses, mask_ids
def apbackground(img,
ap_uorder_interp,
offsetlim=(-5, 5),
q=50,
npix_inter=3,
kernel_size=(11, 11),
polydeg=5):
""" determine background/scattered light using inter-aperture pixels """
img = np.array(img)
# determine inter-aperture pixels
ap_lo = np.sum(np.array([3, -3, 1]).reshape(-1, 1) * ap_uorder_interp[0:3],
axis=0)
ap_hi = np.sum(np.array([1, -3, 3]).reshape(-1, 1) * ap_uorder_interp[-3:],
axis=0)
# risky to extend inter-order region!
# ap_extended = np.vstack((ap_lo, ap_uorder_interp, ap_hi))
# ap_inter = (ap_extended[1:] + ap_extended[:-1]) * .5
ap_extended = np.vstack((ap_lo, ap_uorder_interp))
ap_inter = (ap_extended[1:] + ap_extended[:-1]) * .5
# determine the valley of interp-aperture pixels
try:
ap_width, sys_offset = apwidth(img,
ap_inter,
offsetlim=(-3, 3),
ap_npix=npix_inter,
method='min')
except:
ap_width = (-2, +2)
# get slice along dispersion axis
order, ofst, xcoord, ycoord = get_aperture_index(ap_inter,
ap_width=ap_width)
# extract median interp-aperture pixels
def f(*args, **kwargs):
return np.percentile(*args, **kwargs, q=q)
spec1d_inter = sextract_all_aperture(img,
ap_inter,
ap_width=ap_width,
func=f)
spec_slc_tiled = np.tile(spec1d_inter,
(1, ap_width[1] - ap_width[0] + 1)).reshape(
-1, ap_inter.shape[1])
# interpolate median background
sl = np.zeros_like(img) * np.nan
for i_col in range(sl.shape[1]):
# xcoord_ = xcoord[:, i_col]
ycoord_ = ycoord[:, i_col]
sl_ = spec_slc_tiled[:, i_col]
sl_interp = interp1d(ycoord_[np.isfinite(sl_)],
sl_[np.isfinite(sl_)],
bounds_error=False)(np.arange(sl.shape[0]))
# fill the ends
ind_end = np.where(np.isfinite(sl_interp))[0][[0, -1]]
sl_interp[:ind_end[0]] = sl_interp[ind_end[0]]
sl_interp[ind_end[-1] + 1:] = sl_interp[ind_end[-1]]
sl[:, i_col] = sl_interp
# median filter
sls = medfilt2d(sl, kernel_size=kernel_size)
# 1D polyfit smoothing
print("@SONG: polyfit filtering ...")
bg_polymoothed0 = polyfitfilt(sl, deg=polydeg, axis=0)
print("@SONG: polyfit filtering2 ...")
bg_polymoothed01 = polyfitfilt(bg_polymoothed0, deg=polydeg, axis=1)
res = dict(bg=sl, bg_smoothed=sls, bg_poly=bg_polymoothed01)
return res
def MRELBP(im, N, R, r, w_c, w_r):
#Takes Median Robust Extended Local Binary Pattern from image im
#Uses N neighbours from radii R and r, R must be larger than r
#Median filter uses kernel sizes w_c for center pixels, w_r[0] for larger radius and w_r[1]
#for smaller radius
#Grayscale values are centered at their mean and scales with global standad deviation
#Mean grayscale value and std
muI = im.mean()
stdI = im.std()
#Centering and scaling with std
I = (im - muI) / stdI
#Median filtering
Ic = medfilt(I, w_c)
#Center pixels
d = round(R + (w_r[0] - 1) / 2)
Ic = Ic[d:-d, d:-d]
#Subtracting the mean pixel value from center pixels
Ic = Ic - Ic.mean()
#Bining center pixels
Chist = np.zeros((1, 2))
Chist[0, 0] = np.sum(Ic >= 0)
Chist[0, 1] = np.sum(Ic < 0)
# --------------- #
#Chist[0,0] = np.sum(Ic>=-1e-06)
#Chist[0,1] = np.sum(Ic<-1e-06)
# --------------- #
#Median filtered images for large and small radius
IL = medfilt(I, w_r[0])
#d1 = round((w_r[0]-1)/2)
#IL = IL[d1:-d1,d1:-d1]
IS = medfilt2d(I, w_r[1])
#d2 = round((w_r[1]-1)/2)
#IS = IS[d2:-d2,d2:-d2]
#Neighbours
pi = np.pi
#Empty arrays for the neighbours
row, col = np.shape(Ic)
NL = np.zeros((row, col, N))
NS = np.zeros((row, col, N))
#print("Size (Ic): " + str(row) + ", " + str(col))
for k in range(N):
#Angle to the neighbour
theta = 0 + k * (-1 * 2 * pi / N)
#Large neighbourhood
x = d + R * np.cos(theta)
y = d + R * np.sin(theta)
if abs(x - round(x)) < 1e-06 and abs(y - round(y)) < 1e-06:
x = int(round(x))
y = int(round(y))
P = IL[y:y + row, x:x + col]
else:
P = imbilinear(IL, col, x, row, y)
NL[:, :, k] = P
#Small neighbourhood
#x = r+r*np.cos(theta)
#y = r+r*np.sin(theta)
# --------------- #
x = d + r * np.cos(theta)
y = d + r * np.sin(theta)
# --------------- #
if abs(x - round(x)) < 1e-06 and abs(y - round(y)) < 1e-06:
x = int(round(x))
y = int(round(y))
P = IS[y:y + row, x:x + col]
else:
P = imbilinear(IS, col, x, row, y)
NS[:, :, k] = P
#Thresholding
#Thresholding radial neighbourhood
NR = NL - NS
#Subtraction of means
#Large neighbourhood
NLmu = NL.mean(axis=2)
#Small neighbouhood
NSmu = NS.mean(axis=2)
for k in range(N):
NL[:, :, k] = NL[:, :, k] - NLmu
NS[:, :, k] = NS[:, :, k] - NSmu
#Converting to binary images and taking the lbp values
#Initialization of arrays
lbpIL = np.zeros((row, col))
lbpIS = np.zeros((row, col))
lbpIR = np.zeros((row, col))
for k in range(N):
lbpIL = lbpIL + (NL[:, :, k] >=
0) * 2**k # NOTE ACCURACY FOR THRESHOLDING!!!
lbpIS = lbpIS + (NS[:, :, k] >= 0) * 2**k
lbpIR = lbpIR + (NR[:, :, k] >= 0) * 2**k
# --------------- #
#lbpIL = lbpIL+(NL[:,:,k]>=-1e-06)*2**k # NOTE ACCURACY FOR THRESHOLDING!!!
#lbpIS = lbpIS+(NS[:,:,k]>=-1e-06)*2**k
#lbpIR = lbpIR+(NR[:,:,k]>=-1e-06)*2**k
# --------------- #
#Binning
Lhist = np.zeros((1, 2**N))
Shist = np.zeros((1, 2**N))
Rhist = np.zeros((1, 2**N))
for k in range(2**N):
Lhist[0, k] = np.sum(lbpIL == k)
Shist[0, k] = np.sum(lbpIS == k)
Rhist[0, k] = np.sum(lbpIR == k)
#Chist = 1/np.linalg.norm(Chist)*Chist
#Lhist = 1/np.linalg.norm(Lhist)*Lhist
#Shist = 1/np.linalg.norm(Shist)*Shist
#Rhist = 1/np.linalg.norm(Rhist)*Rhist
#Mapping
mapping = getmapping(N)
Lhist = maplbp(Lhist, mapping)
Shist = maplbp(Shist, mapping)
Rhist = maplbp(Rhist, mapping)
hist = np.concatenate((Chist, Lhist, Shist, Rhist), 1)
return hist, lbpIL, lbpIS, lbpIR
def median_filter(picture: Picture, size=5):
matrix = signal.medfilt2d(picture.matrix, kernel_size=size) # a lot faster
# matrix = __base_filter(picture.matrix, window_size, lambda window: np.median(window))
return Picture(picture.title, matrix)
capture = cv.VideoCapture(0)
capture.set(cv.CAP_PROP_FPS, 1)
# Set up Background Subtraction Model (bgsub)
backSub = cv.createBackgroundSubtractorMOG2()
# Bgsub and median filtering parameters
mask_thresh = 255
kernel_size = 25
lr = 0.05
burn_in = 30
i = 0
# Loop through the frames from the webcam
while True:
ret, frame = capture.read()
fgMask = backSub.apply(frame, learningRate=lr)
# Avoid early false positives
if i < burn_in:
i += 1
continue
# Threshold mask - plot when change detected
fgMaskMedian = medfilt2d(fgMask, kernel_size)
if (fgMaskMedian >= mask_thresh).any():
fig, axs = plt.subplots(1, 3)
frame = cv.cvtColor(frame, cv.COLOR_BGR2RGB)
axs[0].imshow(frame)
axs[1].imshow(fgMask)
axs[2].imshow(fgMaskMedian)
plt.show()
def get_beam_origin(
img:np.ndarray,
slit_cnrs:np.ndarray=None,
size:Tuple=(500, 500),
) -> Tuple:
"""
Description
-----------
Return the image coordinate (row, col) of the supposed beamcenter that provides the most homogeneous
beam proflie
Parameters
----------
img: np.ndarray
Input image with only slits
slit_cnrs: np.ndarray
Image coordinates of the four corners defined by the slits
size: (int, int)
(row, col) size of the desired FOV. A 500x500 FOV is commonly used to located the beamcenter.
NOTE: smaller size often helps, but it should be depending on the actual FOV intended for the experiment
Returns
-------
Tuple
The image coordinates (row, col) of the beam center. In ImageJ, this coordinate is displayed as (col, row).
"""
img = _safe_read_img(img)
# sanity check to make sure the FOV is not too large
if size[0] > img.shape[0]:
raise ValueError("FOV is way too large in vertical direction")
if size[1] > img.shape[1]:
raise ValueError("FOV is way too large in horizontal direction")
# get the domain size
_srow, _scol = size
# detect slit corner is not provided
slit_cnrs = np.array(detect_slit_corners(img)) if slit_cnrs is None else np.array(slit_cnrs)
slit_top, slit_bot = int(min(slit_cnrs[:,0])), int(max(slit_cnrs[:,0]))
slit_lft, slit_rgt = int(min(slit_cnrs[:,1])), int(max(slit_cnrs[:,1]))
# avoid impact of noisy pixels (defects in detector)
img = medfilt2d(img.astype(float))
# find the brightest spot in the image, use it as a starting point
_beamcenter = np.unravel_index(np.argmax(img, axis=None), img.shape) # print(x_b, y_b, img[y_b, x_b])
# form bounds as contraints
def _row_in_range(beamcenter):
return -1*(beamcenter[0]-slit_top+_srow/2)*(beamcenter[0]-slit_bot+_srow/2)
def _col_in_range(beamcenter):
return -1*(beamcenter[1]-slit_lft+_scol/2)*(beamcenter[1]-slit_rgt+_scol/2)
# define objective function
def _obj(beamcenter):
_r, _c = beamcenter.astype(int)
_data = img[_r-_srow:_r+_srow, _c-_scol:_c+_scol]
_hp = np.average(_data, axis=0)
_hmod = GaussianModel(prefix='hp_')
_hfit = _hmod.fit(_hp, x=np.arange(_hp.shape[0]), hp_center=len(_hp)/2)
_vp = np.average(_data, axis=1)
_vmod = GaussianModel(prefix='vp_')
_vfit = _vmod.fit(_vp, x=np.arange(_vp.shape[0]), vp_center=len(_vp)/2)
# rms
# minimizing the assymetry of the beam proflie in both directions to
# the best we can.
# NOTE:
# The beam is not always symmetric, and we need (kind of) symmetric
# beam for ff-HEDM and nf-HEDM scan.
return np.sqrt(
0.5*(_hfit.best_values['hp_center']- len(_hp)/2)**2 \
+ 0.5*(_vfit.best_values['vp_center']- len(_vp)/2)**2
)
_rst = sp.optimize.minimize(_obj, _beamcenter,
constraints=({'type': 'ineq', 'fun': _row_in_range },
{'type': 'ineq', 'fun': _col_in_range },
),
method='COBYLA',
)
return _rst.x
def get_pin_outline(
img_pin: np.ndarray,
incrop: int=61,
adapthist_clip: float=0.01,
upsampling: int=12,
) -> list:
"""
Description
-----------
Using canny edge detection and Hough transformation to detect the
outline of a pin, which is commonly used for alignment of rotation
stages at MPE@APS.
Parameters
----------
img_pin: np.ndarray
input image with pin in the FOV
incrop: int
number of pixels to cropped into FOV to avoid interference of the slit blades
adapthist_clip: float
decrease it to supporess artifacts from scintillators and cam
upsampling: int
repeat hough transform to get more line segments of the same feature
Returns
-------
list
line segments in image coordiantes for the pin outline
"""
# use log to suppress scitilator artifacts
img_pin = np.log(img_pin)
# get the slit corner
cnrs = np.array(detect_slit_corners(img_pin))
# get the cropping location
_minrow, _maxrow = int(min(cnrs[:,0])), int(max(cnrs[:,0]))
_mincol, _maxcol = int(min(cnrs[:,1])), int(max(cnrs[:,1]))
# crop the img
# NOTE: agressisve incropping to avoid the edge detection interference from slits
_img = exposure.rescale_intensity(
img_pin[_minrow+incrop : _maxrow-incrop,
_mincol+incrop : _maxcol-incrop]
)
# use canny + hough_line to get outline segment
_img = medfilt2d(_img)
_img = exposure.equalize_adapthist(_img, clip_limit=adapthist_clip)
_edges = canny(_img, sigma=3)
# use multiprocessing for upsampling
_cpus = max(multiprocessing.cpu_count() - 2, 2)
with cf.ProcessPoolExecutor(max_workers=_cpus) as e:
# schedule
_jobs = [e.submit(
probabilistic_hough_line,
_edges,
threshold=10,
line_length=7, # Increase the parameter to extract longer lines.
line_gap=2, # Decrease the number to allow more short segments
) for _ in range(upsampling)]
# # execute
_lines = list(itertools.chain(*[me.result() for me in _jobs]))
return [[(pt[0]++_mincol+incrop, pt[1]+_minrow+incrop) for pt in line] for line in _lines]
if current_evt == stop_evt:
print("reached the end")
continue
else:
stop_evt = current_evt + read_per_cycle
print("Reading evt {} to {}...".format(current_evt, stop_evt - 1))
#timestamps, ampl, blocks, phases = read_raw_signal(reader, range(current_evt, stop_evt), get_timestamp=True, calibrated = calibrated)
#timestamps, ampl, blocks, phases = read_raw_signal_array(reader, range(current_evt, stop_evt), get_timestamp=True, calibrated = calibrated)
ampl, timestamps, first_cell_ids, stale_bit = read_calibrated_data(
args.infile,
DATADIR=DATADIR,
event_list=range(current_evt, stop_evt))
for i in range(current_evt, stop_evt):
im = show_image(ampl[i - current_evt], maxZ=4000, show=False)
im_smooth = medfilt2d(im, 3)
#if np.percentile(im_smooth[im_smooth != 0], 90) > 500:
if np.percentile(im_smooth[im_smooth != 0], 20) > 200:
print("This is probably a flasher event")
isf = 'f'
if args.flasher:
with open(flasher_file, 'a') as ffio:
ffio.write("{}\n".format(i))
else:
isf = ''
if args.flasher and isf == '':
continue
elif not args.flasher and isf == 'f':
# let's skip flashers
continue
def detect_debris(self, ov_number, method):
debris_detected = False
msg = 'CTRL: No debris detection method selected.'
ov_roi = [None, None]
# Crop to current debris detection area:
top_left_px, top_left_py, bottom_right_px, bottom_right_py = (
self.ovm.get_ov_debris_detection_area(ov_number))
for i in range(2):
ov_img = self.ov_images[ov_number][i][1]
ov_roi[i] = ov_img[top_left_py:bottom_right_py,
top_left_px:bottom_right_px]
height, width = ov_roi[0].shape
if method == 0:
# Calculate the maximum difference in mean and stddev across
# four quadrants and full ROI:
means = {}
stddevs = {}
max_diff_mean = 0
max_diff_stddev = 0
# Compute mean and stddev for four quadrants
# and for full ROI
area_height = bottom_right_py - top_left_py
area_width = bottom_right_px - top_left_px
quadrant_area = (area_height * area_width) / 4
for i in range(2):
quadrant1 = ov_roi[i][0:int(area_height / 2),
0:int(area_width / 2)]
quadrant2 = ov_roi[i][0:int(area_height / 2),
int(area_width / 2):area_width]
quadrant3 = ov_roi[i][int(area_height / 2):area_height,
0:int(area_width / 2)]
quadrant4 = ov_roi[i][int(area_height / 2):area_height,
int(area_width / 2):int(area_width)]
means[i] = [
np.mean(quadrant1),
np.mean(quadrant2),
np.mean(quadrant3),
np.mean(quadrant4),
np.mean(ov_roi[i])
]
stddevs[i] = [
np.std(quadrant1),
np.std(quadrant2),
np.std(quadrant3),
np.std(quadrant4),
np.std(ov_roi[i])
]
if quadrant_area < self.debris_roi_min_quadrant_area:
# Use only full ROI if ROI too small for quadrants:
start_i = 4
var_str = 'OV ROI (no quadrants)'
else:
# Use four quadrants and ROI for comparisons:
start_i = 0
var_str = 'OV quadrants'
for i in range(start_i, 5):
diff_mean_i = abs(means[1][i] - means[0][i])
if diff_mean_i > max_diff_mean:
max_diff_mean = diff_mean_i
diff_stddev_i = abs(stddevs[1][i] - stddevs[0][i])
if diff_stddev_i > max_diff_stddev:
max_diff_stddev = diff_stddev_i
msg = ('CTRL: ' + var_str +
': max. diff_M: {0:.2f}'.format(max_diff_mean) +
'; max. diff_SD: {0:.2f}'.format(max_diff_stddev))
debris_detected = ((max_diff_mean > self.mean_diff_threshold) or
(max_diff_stddev > self.stddev_diff_threshold))
if method == 1:
# Compare the histogram count from the difference image to user-
# specified threshold.
# Apply median filter to denoise images:
ov_curr = medfilt2d(ov_roi[1], self.median_filter_kernel_size)
ov_prev = medfilt2d(ov_roi[0], self.median_filter_kernel_size)
# Pixel difference
# Recast as int16 before subtraction:
ov_curr = ov_curr.astype(np.int16)
ov_prev = ov_prev.astype(np.int16)
ov_diff_img = np.absolute(np.subtract(ov_curr, ov_prev))
# Histogram of difference image:
diff_histogram, bin_edges = np.histogram(ov_diff_img, 256,
[0, 256])
# Compute sum for counts above lower limit:
diff_sum = 0
for i in range(self.image_diff_hist_lower_limit, 256):
diff_sum += diff_histogram[i]
threshold = self.image_diff_threshold * height * width / 1e6
msg = ('CTRL: OV: image_diff_hist_sum: ' + str(diff_sum) +
' (curr. threshold: ' + str(int(threshold)) + ')')
debris_detected = (diff_sum > threshold)
if method == 2:
# Compare histograms directly (this is not very effective,
# for testing purposes.)
hist_diff_sum = 0
# Histogram from previous OV:
hist1, bin_edges = np.histogram(ov_roi[0], 256, [0, 256])
# Histogram from current OV
hist2, bin_edges = np.histogram(ov_roi[1], 256, [0, 256])
for i in range(256):
hist_diff_sum += abs(hist1[i] - hist2[i])
threshold = self.histogram_diff_threshold * height * width / 1e6
msg = ('CTRL: OV: hist_diff_sum: ' + str(hist_diff_sum) +
' (curr. threshold: ' + str(int(threshold)) + ')')
debris_detected = (hist_diff_sum > threshold)
return debris_detected, msg
def Conv_MRELBP(image, N, R, r, wR, wr, wc):
#Whiten the image
imu = image.mean()
istd = image.std()
im = (image - imu) / istd
#Get image dimensions
h, w = im.shape[:2]
#Make kernels
kR = []
kr = []
dtheta = np.pi * 2 / N
for k in range(0, N):
_kernel = weight_matrix_bilin(R, -k * dtheta, val=0)
kR.append(_kernel)
_kernel = weight_matrix_bilin(r, -k * dtheta, val=0)
kr.append(_kernel)
#Make median filtered images
imc = medfilt2d(im.copy(), wc)
imR = medfilt2d(im.copy(), wR)
imr = medfilt2d(im.copy(), wr)
#Get LBP images
neighbR = np.zeros((h, w, N))
neighbr = np.zeros((h, w, N))
for k in range(N):
_neighb = correlate(imR, kR[k])
neighbR[:, :, k] = _neighb
_neighb = correlate(imr, kr[k])
neighbr[:, :, k] = _neighb
#Crop valid convolution region
d = R + wR // 2
h -= 2 * d
w -= 2 * d
neighbR = neighbR[d:-d, d:-d, :]
neighbr = neighbr[d:-d, d:-d, :]
imc = imc[d:-d, d:-d]
#Subtraction
_muR = neighbR.mean(2).reshape(h, w, 1)
for k in range(N):
try:
muR = np.concatenate((muR, _muR), 2)
except NameError:
muR = _muR
_mur = neighbr.mean(2).reshape(h, w, 1)
for k in range(N):
try:
mur = np.concatenate((mur, _mur), 2)
except NameError:
mur = _mur
diffc = (imc - imc.mean()) >= 0
diffR = (neighbR - muR) >= 0
diffr = (neighbr - mur) >= 0
diffR_r = (neighbR - neighbr) >= 0
#Compute lbp images
lbpc = diffc
lbpR = np.zeros((h, w))
lbpr = np.zeros((h, w))
lbpR_r = np.zeros((h, w))
for k in range(N):
lbpR += diffR[:, :, k] * (2**k)
lbpr += diffr[:, :, k] * (2**k)
lbpR_r += diffR_r[:, :, k] * (2**k)
#Get LBP histograms
histc = np.zeros((1, 2))
histR = np.zeros((1, 2**N))
histr = np.zeros((1, 2**N))
histR_r = np.zeros((1, 2**N))
histc[0, 0] = (lbpc == 1).astype(np.float32).sum()
histc[0, 1] = (lbpc == 0).astype(np.float32).sum()
for k in range(2**N):
histR[0, k] = (lbpR == k).astype(np.float32).sum()
histr[0, k] = (lbpr == k).astype(np.float32).sum()
histR_r[0, k] = (lbpR_r == k).astype(np.float32).sum()
#Mapping
mapping = getmapping(N)
histR = maplbp(histR, mapping)
histr = maplbp(histr, mapping)
histR_r = maplbp(histR_r, mapping)
#Append histograms
hist = np.concatenate((histc, histR, histr, histR_r), 1)
return hist
def get_wave_arrays(self, pgr=False):
'''Calculates wave direction (180 degrees of amiguity),
significant wave height and wave period.
prg: Boolean, default is False, each imagette is
independent of the others, pixels belong to only one imagette.
If True, pixels will belong to multiple imagettes at the same time
since imagattes will overlap because an imagette is created for each
pixel independently of multilook value; N of pixels = N of imagettes.
Each pixel will belong to multiple imagettes, but there will be
one imagette where this pixel will be the centre of the imagette'''
sigma = self.get_var_array(self.ds, Wave.sigma)
inci_matrix = self.get_var_array(self.ds, Wave.incidence)
beta_matrix = self.get_var_array(self.ds, Wave.slant)/Wave.S1_V
direc_matrix = np.zeros(shape=sigma.shape)
phi_matrix = np.zeros(shape=sigma.shape)
cutoff_matrix = np.zeros(shape=sigma.shape)
height_matrix = np.zeros(shape=sigma.shape)
period_matrix = np.zeros(shape=sigma.shape)
subimages = list(self.gen_imagettes(sigma, multilook=Wave.direc_attr['scale_factor'], progressive_multilook=pgr))
for roi in subimages:
direc = np.angle(np.max(np.fft.fft2(roi[0])), deg=True)
phi = direc - float(self.ds.attrs['azimuth_direction'])
psd = signal.csd(roi[0], np.transpose(roi[0]),scaling='density')
phases = (np.random.randn(psd.shape[0]*psd.shape[1]).reshape(psd.shape))*2*np.pi
acf = np.fft.ifft2(np.sqrt(psd*2)*np.exp(1j*phases))
std = np.std(signal.medfilt2d(np.abs(acf), kernel_size=11))
cutoff = np.sqrt(2*np.pi*std)
if len(roi[1]) == 2:
sub_inci = np.deg2rad(np.mean(inci_matrix[roi[1][0],roi[1][1]]))
sub_beta = np.mean(beta_matrix[roi[1][0],roi[1][1]])
hei = ((cutoff/sub_beta)*(0.48 + 0.26*np.sin(sub_inci) + 0.27*np.cos(2*np.deg2rad(phi)))) + 0.22
period = (hei*(sub_beta/cutoff)*1.65) + 5.60
direc_matrix[roi[1][0],roi[1][1]] = direc
phi_matrix[roi[1][0],roi[1][1]] = phi
cutoff_matrix[roi[1][0], roi[1][1]] = cutoff
height_matrix[roi[1][0], roi[1][1]] = hei
period_matrix[roi[1][0], roi[1][1]] = period
elif len(roi[1]) == 4:
sub_inci = np.deg2rad(np.mean(inci_matrix[roi[1][0]:roi[1][1], roi[1][2]:roi[1][3]]))
sub_beta = np.mean(beta_matrix[roi[1][0]:roi[1][1], roi[1][2]:roi[1][3]])
hei = ((cutoff/sub_beta)*(0.48 + 0.26*np.sin(sub_inci) + 0.27*np.cos(2*np.deg2rad(phi)))) + 0.22
period = (hei*(sub_beta/cutoff)*1.65) + 5.60
direc_matrix[roi[1][0]:roi[1][1], roi[1][2]:roi[1][3]] = direc
phi_matrix[roi[1][0]:roi[1][1], roi[1][2]:roi[1][3]] = phi
cutoff_matrix[roi[1][0]:roi[1][1], roi[1][2]:roi[1][3]] = cutoff
height_matrix[roi[1][0]:roi[1][1], roi[1][2]:roi[1][3]] = hei
period_matrix[roi[1][0]:roi[1][1], roi[1][2]:roi[1][3]] = period
self.add_var(self.out, Wave.direc_name, self.downsampling_2D(direc_matrix, multilook=Wave.direc_attr['scale_factor'], mode='angle'), Wave.direc_attr)
self.add_var(self.out, Wave.height_name, self.downsampling_2D(height_matrix, multilook=Wave.height_attr['scale_factor']), Wave.height_attr)
self.add_var(self.out, Wave.period_name, self.downsampling_2D(period_matrix, multilook=Wave.period_attr['scale_factor']), Wave.period_attr)
if self.inter == True:
self.add_var(self.out, Wave.phi_name, self.downsampling_2D(phi_matrix, multilook=Wave.phi_attr['scale_factor'], mode='angle'), Wave.phi_attr)
self.add_var(self.out, Wave.cutoff_name, self.downsampling_2D(cutoff_matrix, multilook=Wave.cutoff_attr['scale_factor']), Wave.cutoff_attr)
