def get_distance(region, src):
"""
Compute within-region distances from the src pixels.
Parameters
----------
region : np.ndarray(shape=(m, n), dtype=bool)
mask of the region
src : np.ndarray(shape=(m, n), dtype=bool)
mask of the source pixels to compute distances from.
Returns
-------
d : np.ndarray(shape=(m, n), dtype=float)
approximate within-region distance from the nearest src pixel;
(distances outside of the region are arbitrary).
"""
dmax = float(region.size)
d = np.full(region.shape, dmax)
d[src] = 0
for n in range(region.size):
d_orth = minimum_filter(d, footprint=_ORTH2) + 1
d_diag = minimum_filter(d, (3, 3)) + _SQRT2
d_adj = np.minimum(d_orth[region], d_diag[region])
d[region] = np.minimum(d_adj, d[region])
if (d[region] < dmax).all():
break
return d
def order_statistics_filter(grid,window_size=(3,3,3),statistics_type='median',rank=1):
filtered = grid.copy()
if statistics_type=='minimum':
scifilt.minimum_filter(grid,window_size,None,filtered, mode='nearest')
elif statistics_type=='maximum':
scifilt.maximum_filter(grid,window_size,None,filtered, mode='nearest')
elif statistics_type=='median':
scifilt.median_filter(grid,window_size,None,filtered, mode='nearest')
elif statistics_type[:-2]=='percentile' or statistics_type[:-2]=='per':
per = np.int(statistics_type[-2:])
scifilt.percentile_filter(grid,per,window_size,None,filtered, mode='nearest')
elif statistics_type=='rank':
scifilt.rank_filter(grid,rank,window_size,None,filtered, mode='nearest')
return filtered
return filtered
def fit_GLC_grid( subjdata, z_limit=ZLIMIT ):
#thesedata=subjdata
dims = len(subjdata[0])-1
bounds = [(.00001,50)] + [(-25,25) for _ in range( dims+1 ) ]
optargs = ( subjdata, z_limit, None, True)
xopt, fopt, grid, Jout = optimize.brute(func=negloglike_reduced
, ranges = bounds
, args = optargs
, Ns = 5
, full_output=True
)
from scipy.ndimage.filters import minimum_filter
from scipy.ndimage.morphology import generate_binary_structure
neighborhood = generate_binary_structure( dims+2, dims+2 )
local_mins = minimum_filter( Jout, footprint=neighborhood ) == Jout
min_coords = np.array([ g[local_mins] for g in grid ]).T
xoptglobal = xopt
foptglobal = fopt
for coords in min_coords:
xopt, fopt, iter, im, sm = optimize.fmin(func=negloglike_reduced
, x0 = coords
, args = optargs
, full_output=True
)
if fopt < foptglobal:
xoptglobal = xopt
foptglobal = fopt
return xoptglobal, foptglobal
def correct_for_atmo(raw_data, gas_tar, gas_ref, minimum_filter=False, plot_result=True):
""" estimate the atmospheric constant and removes it from
the target gas value """
atmo_constant = estimate_atmospheric_constant(raw_data, gas_tar,
reference=gas_ref)
corrected_data = raw_data.copy()
if minimum_filter:
# TODO remove trend
from scipy.ndimage.filters import minimum_filter
all_max = max(raw_data[gas_tar].values) - raw_data[gas_tar].mean()
gas_median_filt = pad.Series(minimum_filter(raw_data[gas_tar].values,
size=(100,)),
index=raw_data.index)
corrected_data[gas_tar] = raw_data[gas_tar] - gas_median_filt
corrected_data[gas_tar] = pad.Series([min(all_max, max(i, 0)) for i in corrected_data[gas_tar].values],
index=raw_data.index)
# Replace value of target gas by the corrected value
else:
corrected_data[gas_tar] = pad.Series(raw_data[gas_tar] - atmo_constant,
index=raw_data.index)
if plot_result:
plt.figure(figsize=(12,8))
raw_data[gas_tar].plot()
corrected_data[gas_tar].plot(style='r')
plt.legend(['%s measured' % gas_tar,
'%s corrected for atmospheric constant' % gas_tar])
plt.ylabel('%s ppm' % gas_tar)
return corrected_data
def detect_peaks_local_max(image, radius=10, threshold=25, ax=None):
'''
http://stackoverflow.com/questions/9111711/get-coordinates-of-local-maxima-in-2d-array-
above-certain-value
'''
import scipy.ndimage as ndimage
import scipy.ndimage.filters as filters
neighborhood_size = radius
foldchange = 1.5
data_max = filters.maximum_filter(image, neighborhood_size)
maxima = (image == data_max)
data_min = filters.minimum_filter(image, neighborhood_size)
fc = ((data_max - data_min)/data_min > foldchange)
maxima[fc == 0] = 0
diff = ((data_max - data_min) > threshold)
maxima[diff == 0] = 0
labeled, num_objects = ndimage.label(maxima)
slices = ndimage.find_objects(labeled)
y,x = np.where(labeled > 0 )
peaks = map(tuple, np.array([x,y]).T)
if ax is not None:
ax.imshow(image)
ax.autoscale(False)
ax.plot(x,y, 'ro')
return peaks
def dark_channel(image, structure=square(15)):
(h, w, c) = image.shape
dark_channels = np.zeros_like(image)
for i in range(c):
dark_channels[:, :, i] = minimum_filter(image[:, :, i], footprint=structure)
dark_channel = np.min(dark_channels, axis=2)
return dark_channel
def find_local_maxima(self, data, neighborhood_size):
"""
find local maxima within neighborhood
idea from http://stackoverflow.com/questions/9111711
(get-coordinates-of-local-maxima-in-2d-array-above-certain-value)
"""
# find local maxima in image (width specified by neighborhood_size)
data_max = filters.maximum_filter(data,neighborhood_size);
maxima = (data == data_max);
assert np.sum(maxima) > 0; # we should always find local maxima
# remove connected pixels (plateaus)
labeled, num_objects = ndimage.label(maxima)
slices = ndimage.find_objects(labeled)
maxima *= 0;
for dx,dy in slices:
maxima[(dx.start+dx.stop-1)/2, (dy.start+dy.stop-1)/2] = 1
# calculate difference between local maxima and lowest
# pixel in neighborhood (will be used in select_local_maxima)
data_min = filters.minimum_filter(data,neighborhood_size);
diff = data_max - data_min;
self._maxima = maxima;
self._diff = diff;
return maxima,diff
def local_minima(img, min_distance = 4):
r"""
Returns all local minima from an image.
Parameters
----------
img : array_like
The image.
min_distance : integer
The minimal distance between the minimas in voxels. If it is less, only the lower minima is returned.
Returns
-------
indices : sequence
List of all minima indices.
values : sequence
List of all minima values.
"""
# @TODO: Write a unittest for this.
fits = numpy.asarray(img)
minfits = minimum_filter(fits, size=min_distance) # default mode is reflect
minima_mask = fits == minfits
good_indices = numpy.transpose(minima_mask.nonzero())
good_fits = fits[minima_mask]
order = good_fits.argsort()
return good_indices[order], good_fits[order]
def getSaddlePoints(matrix, gaussian_filter_sigma=0., low=None, high=None):
if low == None:
low = matrix.min()
if high == None:
high = matrix.max()
matrix = expandMatrix(matrix)
neighborhood = morphology.generate_binary_structure(len(matrix.shape),2)
# apply the local minimum filter; all locations of minimum value
# in their neighborhood are set to 1
# http://www.scipy.org/doc/api_docs/SciPy.ndimage.filters.html#minimum_filter
matrix = filters.minimum_filter(matrix, footprint=neighborhood)
matrix = condenseMatrix(matrix)
outPath, clusterPathMat, grad = minPath(matrix)
flood = numpy.asarray(outPath)
potential = []
for e in flood:
i,j = e
potential.append(matrix[i,j])
potential = numpy.asarray(potential)
potential = scipy.ndimage.filters.gaussian_filter(potential, gaussian_filter_sigma)
derivative = lambda x: numpy.array(zip(-x,x[1:])).sum(axis=1)
signproduct = lambda x: numpy.array(zip(x,x[1:])).prod(axis=1)
potential_prime = derivative(potential)
signproducts = numpy.sign(signproduct(potential_prime))
extrema = flood[2:][numpy.where(signproducts<0)[0],:]
bassinlimits = derivative(signproducts)
saddlePoints = numpy.asarray(outPath[3:])[bassinlimits==-2]
saddlePointValues = numpy.asarray(map(lambda x: matrix[x[0],x[1]], saddlePoints))
saddlePoints = saddlePoints[numpy.logical_and(saddlePointValues>=low, saddlePointValues<=high),:]
return saddlePoints
def stitch(targets,images):
mask = rois_mask(targets) # True where image data is
gaps_mask = mask==False # True where infill needs to go
# compute bounds relative to the camera field
(x,y,w,h) = stitched_box(targets)
uroi = img_as_float(stitch_raw(targets,images,(x,y,w,h))) # stitch with black infill
# step 1: sparsely sample background mostly ignoring blob
# compute gradient on both axes
k = [[-3,-1,0,1,3],
[-3,-1,0,1,3],
[-3,-1,0,1,3],
[-3,-1,0,1,3]]
gy = convolve(uroi,k)
gx = convolve(uroi,np.rot90(k))
# ignore all but low-gradient areas
bg = (abs(gy+gx) < 0.2) & mask
# step 2: remove less contiguous areas
filter_size = max(2,int(max(h,w)/200))
mf = minimum_filter(bg*1,filter_size)
# step 3: interpolate between samples
z = inpaint(uroi*mf,mf==False)
# step 4: subsample and re-interpolate to degrade artifacts in fill region
random = RandomState(0)
(h,w)=z.shape
ng = random.rand(h,w) < 0.01
z2 = inpaint(z*ng,ng==False)
# step 5: final composite
roi = (z2 * gaps_mask) + uroi
return (roi * 255).astype(np.uint8), mask
def find_extrema(array):
'''
Takes an array and finds its local extrema.
Returns an array with 0s for not an extrema, 1s for maxs and -1 for mins
and a list of the indices of all maximums and minimums
N.B. this function is much faster than the above.
'''
extrema = np.zeros_like(array)
maximums = []
minimums = []
local_max = maximum_filter(array, size=(3, 3)) == array
local_min = minimum_filter(array, size=(3, 3)) == array
extrema += local_max
extrema -= local_min
where_max = np.where(local_max)
where_min = np.where(local_min)
for max_point in zip(where_max[0], where_max[1]):
if (max_point[0] != 0 and max_point[0] != array.shape[0] - 1 and
max_point[1] != 0 and max_point[1] != array.shape[1] - 1):
maximums.append(max_point)
for min_point in zip(where_min[0], where_min[1]):
if (min_point[0] != 0 and min_point[0] != array.shape[0] - 1 and
min_point[1] != 0 and min_point[1] != array.shape[1] - 1):
minimums.append(min_point)
return extrema, maximums, minimums
def detect_local_minima(arr):
# http://stackoverflow.com/questions/3684484/peak-detection-in-a-2d-array/3689710#3689710
"""
Takes an array and detects the troughs using the local maximum filter.
Returns a boolean mask of the troughs (i.e. 1 when
the pixel's value is the neighborhood maximum, 0 otherwise)
"""
# define an connected neighborhood
# http://www.scipy.org/doc/api_docs/SciPy.ndimage.morphology.html#generate_binary_structure
neighborhood = ndimage.morphology.generate_binary_structure(len(arr.shape),2)
# apply the local minimum filter; all locations of minimum value
# in their neighborhood are set to 1
# http://www.scipy.org/doc/api_docs/SciPy.ndimage.filters.html#minimum_filter
local_min = (filters.minimum_filter(arr, footprint=neighborhood)==arr)
# local_min is a mask that contains the peaks we are
# looking for, but also the background.
# In order to isolate the peaks we must remove the background from the mask.
#
# we create the mask of the background
background = (arr==0)
#
# a little technicality: we must erode the background in order to
# successfully subtract it from local_min, otherwise a line will
# appear along the background border (artifact of the local minimum filter)
# http://www.scipy.org/doc/api_docs/SciPy.ndimage.morphology.html#binary_erosion
eroded_background = ndimage.morphology.binary_erosion(
background, structure=neighborhood, border_value=1)
#
# we obtain the final mask, containing only peaks,
# by removing the background from the local_min mask
detected_minima = local_min - eroded_background
return np.where(detected_minima)
def local_normalize(gim,kernel_size):
maxf = filters.maximum_filter(gim,kernel_size)
minf = filters.minimum_filter(gim,kernel_size)
num = gim-minf
den = maxf-minf
den[np.where(den==0)]=1.0
return num/den
def find_objects(data, size=5, thresh=None, N=20, verbosity=1):
# maximum step height in neighborhood of size 'size'
data_max = filters.maximum_filter(data, size)
data_min = filters.minimum_filter(data, size)
diff = data_max - data_min;
# determine threshold which gives N pixels
if thresh is None: thresh=np.sort(diff.flat)[-N];
# create mask for image (maximum with high step size)
maxima = (data == data_max)
maxima[diff <= thresh] = False
# find connected objects (pixel agglomerates)
labeled, num_objects = ndimage.label(maxima)
slices = ndimage.find_objects(labeled)
# DEBUG
if verbosity>2:
plt.figure()
plt.imshow(np.log(1+np.abs(data)),interpolation='nearest');
# create overlay with red color (r,g,b,alpha) at each image point
overlay = np.zeros(data.shape+(4,));
overlay[maxima] = (1,1,0,1); # set opacity according to maxima
plt.imshow(overlay,interpolation='nearest');
return slices;
def build_tree(im):
# im = boundary probability
print "QS"
segs = quickshift(im, sigma=2.0, return_tree=False, convert2lab=False, max_dist=10)
orig_segs = segs.copy()
print "done"
# Find all neighboring regions and the values between them
plus = np.array([
[0, 1, 0],
[1, 1, 1],
[0, 1, 0]]).astype(np.bool)
lo = minimum_filter(segs, footprint=plus).astype(np.int32)
hi = maximum_filter(segs, footprint=plus).astype(np.int32)
counter = ValueCountInt64()
counter.add_values_pair32(lo.ravel(), hi.ravel())
loc, hic, edge_counts = counter.get_counts_pair32()
weighter = WeightedCountInt64()
weighter.add_values_pair32(lo.ravel(), hi.ravel(), im.astype(np.float32).ravel())
low, hiw, edge_weights = weighter.get_weights_pair32()
max_regions = 2 * segs.max() + 1 # number of regions is max() + 1
counts = np.zeros((max_regions, max_regions), dtype=np.uint64)
weights = np.zeros((max_regions, max_regions), dtype=float)
counts[loc, hic] = edge_counts
weights[low, hiw] = edge_weights
# zero diagonal
counts[np.arange(max_regions), np.arange(max_regions)] = 0
next_region = segs.max() + 1
parents = {}
# set up heap
heap = [(weights[l, h] / counts[l, h], l, h) for l, h in zip(*np.nonzero(counts))]
heapify(heap)
# successively merge regions
while heap:
w, lo, hi = heappop(heap)
if (lo in parents) or (hi in parents):
continue
print next_region, max_regions
parents[lo] = next_region
parents[hi] = next_region
counts[next_region, :] = counts[lo, :] + counts[hi, :]
weights[next_region, :] = weights[lo, :] + weights[hi, :]
counts[:, next_region] = counts[next_region, :]
weights[:, next_region] = weights[next_region, :]
for idx in range(next_region):
if idx in parents:
continue
if counts[idx, next_region] > 0 and (idx not in parents):
heappush(heap, (weights[idx, next_region] / counts[idx, next_region], idx, next_region))
segs[segs == lo] = next_region
segs[segs == hi] = next_region
next_region += 1
print "done"
return orig_segs, parents
def preprocess(image):
npimg = getImageAsNumpy(image)
npimg = filters.minimum_filter(npimg,3)
npimg = invertBackground(npimg)
npimg = erode(npimg, 2)
npimg = dilate(npimg, 1)
npimg = greyThreshold(npimg, 200)
return npimg
def detect_local_minima(arr):
neighborhood = morphology.generate_binary_structure(len(arr.shape), 2)
local_min = (filters.minimum_filter(arr, footprint=neighborhood) == arr)
background = (arr == 0)
eroded_background = morphology.binary_erosion(
background, structure=neighborhood, border_value=1)
detected_minima = local_min - eroded_background
return np.where(detected_minima)
def image_reconstruct(uv, scores, find_max_min = True, grasped_position_index = None, initial_grasp_position_index = None):
bottom_right = map(max, zip(*uv))
top_left = map(min, zip(*uv))
# print 'bottom_right', bottom_right
# print 'top_left', top_left
image = np.empty((((bottom_right[1] - top_left[1])/3+1), (bottom_right[0] - top_left[0])/3+1))
image[:] = np.NAN
for s,(u,v) in zip(scores,uv):
u, v = ((u - top_left[0])/3, (v - top_left[1])/3)
image[v,u] = s
if find_max_min:
neighborhood_size = 10
threshold = 0.0 #0025
image = ndimage.gaussian_filter(image, sigma = 2, mode='constant')
data_max = maximum_filter(image, neighborhood_size)
maxima = (image == data_max)
data_min = minimum_filter(image, neighborhood_size)
diff = ((data_max - data_min) > threshold)
maxima[diff == 0] = 0
labeled, num_objects = ndimage.label(maxima)
slices = ndimage.find_objects(labeled)
x, y = [], []
for dy,dx in slices:
x_center = (dx.start + dx.stop - 1)/2
x.append(x_center)
y_center = (dy.start + dy.stop - 1)/2
y.append(y_center)
# neighborhood = generate_binary_structure(2,2)
# local_max = maximum_filter(image, footprint=neighborhood)==image
# print local_max
# background = (image ==0)
# eroded_background = binary_erosion(background, structure=neighborhood, border_value=1)
# detected_peaks = local_max - eroded_background
values = image[y,x]
zipped = zip(values,x,y)
zipped.sort(key = lambda t: t[0])
unzipped = [list(t) for t in zip(*zipped[-4:])]
# return image, unzipped[1], unzipped[2]
if grasped_position_index is not None:
x_grasped, y_grasped = uv[grasped_position_index]
x_grasped, y_grasped = ((x_grasped - top_left[0])/3, (y_grasped - top_left[1])/3)
# print x_grasped, y_grasped
x_initial, y_initial = uv[initial_grasp_position_index]
x_initial, y_initial = ((x_initial - top_left[0])/3, (y_initial - top_left[1])/3)
# print x_initial, y_initial
return image, unzipped[1], unzipped[2], x_grasped, y_grasped, x_initial, y_initial, unzipped[0]
return image, unzipped[1], unzipped[2], unzipped[0]
def extracts_minima_areas(arr):
neighborhood = morphology.generate_binary_structure(len(arr.shape),2)
local_min = (filters.minimum_filter(arr, footprint=neighborhood)==arr)
labels = measurements.label(local_min)[0]
objects = measurements.find_objects(labels)
areas_and_indices_and_bounding_boxes = []
for idx, sl in enumerate(objects):
areas_and_indices_and_bounding_boxes.append((len(arr[sl][labels[sl] == idx + 1]), idx + 1, sl)) # first area, then index, then bounding box
return sorted(areas_and_indices_and_bounding_boxes), labels
def extrema(mat,mode='wrap',window=10):
"""find the indices of local extrema (min and max)
in the input array."""
mn = minimum_filter(mat, size=window, mode=mode)
mx = maximum_filter(mat, size=window, mode=mode)
# (mat == mx) true if pixel is equal to the local max
# (mat == mn) true if pixel is equal to the local in
# Return the indices of the maxima, minima
return np.nonzero(mat == mn), np.nonzero(mat == mx)
def _findObject(self, img):
'''
Create a bounding box around the object within an image
'''
from imgProcessor.imgSignal import signalMinimum
# img is scaled already
i = img > signalMinimum(img) # img.max()/2.5
# filter noise, single-time-effects etc. from mask:
i = minimum_filter(i, 4)
return boundingBox(i)
def findPeaks(self):
Pxx_max = filters.maximum_filter(self.Pxx, self.NEIGHBORHOOD_SIZE)
maxima = (self.Pxx == Pxx_max)
Pxx_min = filters.minimum_filter(self.Pxx, self.NEIGHBORHOOD_SIZE)
diff = ((Pxx_max - Pxx_min) > self.THRESHOLD)
maxima[diff == 0] = 0
labeled, num_objects = ndimage.label(maxima)
self.xy = np.array(ndimage.center_of_mass(self.Pxx, labeled, range(1, num_objects+1)))
self.tpeaks, self.fpeaks = self.times[self.xy[:,1].astype('int')], self.freqs[self.xy[:,0].astype('int')]
def localMinima(data, threshold):
from numpy import ones, nonzero, transpose
if threshold is not None:
peaks = data < threshold
else:
peaks = ones(data.shape, dtype=data.dtype)
peaks &= data == minimum_filter(data, size=(3,) * data.ndim)
return transpose(nonzero(peaks))
def find_cells(self):
cell_object_list = []
data = scipy.array(self.image)
data.reshape(self.image.height, self.image.width, self.image.channels)
data_max = filters.maximum_filter(data, MAXIMA_ALG_NEIGHBORHOOD_SIZE)
maxima = (data == data_max)
data_min = filters.minimum_filter(data, MAXIMA_ALG_NEIGHBORHOOD_SIZE)
diff = ((data_max - data_min) > MAXIMA_ALG_THRESHOLD)
maxima[diff == 0] = 0
labeled, num_objects = ndimage.label(maxima)
slices = ndimage.find_objects(labeled)
x, y = [], []
for dy, dx, crap in slices:
x_center = (dx.start + dx.stop - 1)/2
x.append(x_center)
y_center = (dy.start + dy.stop - 1)/2
y.append(y_center)
cell = cell_analyzer_objects.CellAnalyzerObject()
point = cell_analyzer_objects.CellAnalyzerPoint(y_center, x_center)
cell.add_point(point)
#HACK HACK HACK: this is to avoid a division by zero!
#point = cell_analyzer_objects.CellAnalyzerPoint(y_center + 1, x_center)
#cell.add_point(point)
#point = cell_analyzer_objects.CellAnalyzerPoint(y_center - 1, x_center)
#cell.add_point(point)
#point = cell_analyzer_objects.CellAnalyzerPoint(y_center, x_center + 1)
#cell.add_point(point)
#point = cell_analyzer_objects.CellAnalyzerPoint(y_center, x_center - 1)
#cell.add_point(point)
cell_object_list.append(cell)
#plt.imshow(data)
#plt.savefig('/tmp/data.png', bbox_inches = 'tight')
#plt.autoscale(False)
#plt.plot(x,y, 'ro')
#plt.savefig('/tmp/result.png', bbox_inches = 'tight')
#create dummy cell objects with only one pixel
#for x_element in x:
#print x
return cell_object_list
def addImg(self, img, maxShear=0.015, maxRot=100, minMatches=12,
borderWidth=3): # borderWidth=100
"""
Args:
img (path or array): image containing the same object as in the reference image
Kwargs:
maxShear (float): In order to define a good fit, refect higher shear values between
this and the reference image
maxRot (float): Same for rotation
minMatches (int): Minimum of mating points found in both, this and the reference image
"""
try:
fit, img, H, H_inv, nmatched = self._fitImg(img)
except Exception as e:
print(e)
return
# CHECK WHETHER FIT IS GOOD ENOUGH:
(translation, rotation, scale, shear) = decompHomography(H)
print('Homography ...\n\ttranslation: %s\n\trotation: %s\n\tscale: %s\n\tshear: %s'
% (translation, rotation, scale, shear))
if (nmatched > minMatches
and abs(shear) < maxShear
and abs(rotation) < maxRot):
print('==> img added')
# HOMOGRAPHY:
self.Hs.append(H)
# INVERSE HOMOGRSAPHY
self.Hinvs.append(H_inv)
# IMAGES WARPED TO THE BASE IMAGE
self.fits.append(fit)
# ADD IMAGE TO THE INITIAL flatField ARRAY:
i = img > self.signal_ranges[-1][0]
# remove borders (that might have erroneous light):
i = minimum_filter(i, borderWidth)
self._ff_mma.update(img, i)
# create fit img mask:
mask = fit < self.signal_ranges[-1][0]
mask = maximum_filter(mask, borderWidth)
# IGNORE BORDER
r = self.remove_border_size
if r:
mask[:r, :] = 1
mask[-r:, :] = 1
mask[:, -r:] = 1
mask[:, :r] = 1
self._fit_masks.append(mask)
# image added
return fit
return False
def extrema(mat,mode='wrap',window=10): # From: http://matplotlib.org/basemap/users/examples.html """find the indices of local extrema (min and max) in the input array.""" mn = minimum_filter(mat, size=window, mode=mode) mx = maximum_filter(mat, size=window, mode=mode) # (mat == mx) true if pixel is equal to the local max # (mat == mn) true if pixel is equal to the local in # Return the indices of the maxima, minima return np.nonzero(mat == mn), np.nonzero(mat == mx)
def localMaxima(data):
data_max = maximum_filter(data, 5)
maxima = (data == data_max)
data_min = minimum_filter(data, 5)
diff = ((data_max - data_min) > 1000)
maxima[diff == 0] = 0
myArray = np.column_stack(np.where(maxima)) # one array with first column x-coords and second column y-coords of local maxima
myArray[:,[0, 1]] = myArray[:,[1, 0]]
return myArray
def plot_fill_flat(roi, out, region, source, drain, dL, dH):
from matplotlib import pyplot
plot_detail = roi.size < 500
cmap = 'Greens'
pyplot.figure()
ax = pyplot.subplot(221)
pyplot.axis('off')
pyplot.title('unfilled')
im = pyplot.imshow(roi, interpolation='none')
im.set_cmap(cmap)
if plot_detail:
y, x = np.where(region); pyplot.plot(x, y, 'k.')
y, x = np.where(source); pyplot.plot(x, y, lw=0, color='k', marker='$H$', ms=12)
y, x = np.where(drain); pyplot.plot(x, y, lw=0, color='k', marker='$L$', ms=12)
pyplot.subplot(222, sharex=ax, sharey=ax)
pyplot.axis('off')
pyplot.title('filled')
im = pyplot.imshow(out, interpolation='none')
im.set_cmap(cmap)
if plot_detail:
for elev in np.unique(out):
y, x = np.where(out==elev)
pyplot.plot(x, y, lw=0, color='k', marker='$%.3f$' % elev, ms=20)
if plot_detail:
flat = (minimum_filter(out, (3, 3)) >= out) & region
y, x = np.where(flat); pyplot.plot(x, y, 'r_', ms=24)
pyplot.subplot(223, sharex=ax, sharey=ax)
pyplot.axis('off')
pyplot.title('dL')
im = pyplot.imshow(roi, interpolation='none')
im.set_cmap(cmap)
for d in np.unique(dL):
if d == region.size: continue
y, x = np.where(dL==d)
pyplot.plot(x, y, lw=0, color='k', marker='$%.2f$' % d, ms=24)
pyplot.subplot(224, sharex=ax, sharey=ax)
pyplot.axis('off')
pyplot.title('dH')
im = pyplot.imshow(roi, interpolation='none')
im.set_cmap(cmap)
for d in np.unique(dH):
if d == region.size: continue
y, x = np.where(dH==d)
pyplot.plot(x, y, lw=0, color='k', marker='$%.2f$' % d, ms=24)
pyplot.tight_layout()
def dplineseg1(image,imweight=4,bweight=-1,diagweight=1):
"""A dynamic programming line segmenter. This computes cuts going from bottom
to top. It is only used for testing and is not recommended for actual use because
these kinds of cuts do not work very well."""
cimage = imweight*image - bweight*maximum(0,roll(image,-1,1)-image)
c,s = dpcuts(cimage,alpha=diagweight)
costs = c[-1]
costs = filters.gaussian_filter(costs,1)
mins = find(filters.minimum_filter(costs,8)==costs)
tracks = dptrack(mins,s)
# combo = 3*tracks+cimage
return tracks
def DetectOccPupil(im, blurShape = (9, 9), sigmaBlur = 10, alpha = 2,
beta = -1, gamma = 0, minFiltSize = (21, 21), THpup = 0.05,
erdSize = (5, 5)):
gaussBlur = cv2.GaussianBlur(im, blurShape, sigmaBlur)
invIm = 2 * im - cv2.addWeighted(im, alpha, gaussBlur, beta, gamma)
noEyeLash = filters.minimum_filter(invIm, minFiltSize)
noEyeLashNorm = noEyeLash / 255
noEyeLashNorm[noEyeLashNorm < THpup] = 0
noEyeLashNorm[noEyeLashNorm > THpup] = 1
contours, hier = cv2.findContours(noEyeLashNorm)
contours = [cv2.convexHull(contour) for contour in contours]
morphShape = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, erdSize)
def green_hotspots(im, sigma=4, padding=0, m=2):
"""RoI generator based on green hotspots.
The input is first converted from RGB to YUV. Then the U and V channels
are added and smoothed with a Gaussian filter. The function peak_local_max
from scipy.spatial is used to find local minimi in the resulting array.
Arguments
---------
im : (?,?,3) numpy array
Input RGB image.
sigma : float (>0), optional
Gaussian filter smoothing parameter. Decreasing sigma will result in
more hotspots. The default value is 4 is a good starting point.
padding : int, optional
Width of boundary layer in which no hotspots will be detected. Keep at
roughly the box_size to prevent boxes from being clipped by block
boundary. Default is 0.
m : int, optional
Size of minimum filter. Keep at the default of 2.
Returns
-------
coords : (?,2) numpy array
Array containing coordinates of the green hotspots.
"""
if padding > 0:
im = im[padding:-padding, padding:-padding, :]
im_yuv = skimage.color.rgb2yuv(im)
im_filtered = im_yuv[:, :, 1] + im_yuv[:, :, 2]
im_filtered = filters.minimum_filter(im_filtered, m)
im_filtered = filters.gaussian_filter(im_filtered, sigma)
mask = peak_local_max(-im_filtered, indices=False)
mask = np.logical_and(mask, im_filtered != 0)
coords = np.argwhere(mask == 1)
return coords + padding
def dark_hotspots(im, sigma=6, padding=0, m=2):
"""RoI generator based on dark hotspots.
Similar function to green_hotspots. Use this function to detect locations
of dark lettuce crops. It is based on local minima of the Y band of
image converted to YUV.
Arguments
---------
im : (?,?,3) numpy array
Input RGB image.
sigma : float (>0), optional
Gaussian filter smoothing parameter. Decreasing sigma will result in
more hotspots. The default value is 6 is a good starting point.
padding : int, optional
Width of boundary layer in which no hotspots will be detected. Keep at
roughly the box_size to prevent boxes from being clipped by block
boundary. Default is 0.
m : int, optional
Size of minimum filter. Keep at the default of 2.
Returns
-------
coords : (?,2) numpy array
Array containing coordinates of the dark hotspots.
"""
if padding > 0:
im = im[padding:-padding, padding:-padding, :]
im_yuv = skimage.color.rgb2yuv(im)
im_filtered = im_yuv[:, :, 0]
im_filtered = filters.minimum_filter(im_filtered, m)
im_filtered = filters.gaussian_filter(im_filtered, sigma)
mask = peak_local_max(-im_filtered, indices=False)
mask = np.logical_and(mask, im_filtered != 0)
coords = np.argwhere(mask == 1)
return coords + padding
def kpp_seeds(features, objectness, k=100, window=9):
height = features.shape[0]
width = features.shape[1]
seeds = np.zeros((height, width), dtype=np.bool)
edge = compute_feature_edge(features)
seeds_candidates = (filters.minimum_filter(edge, window) == edge)
seeds_candidates_idx = [(i, j)
for i, j in zip(*seeds_candidates.nonzero())]
seed_obj = select_seed_embedding(seeds_candidates, objectness)
start = np.argmax(seed_obj)
seeds[seeds_candidates_idx[start][0],
seeds_candidates_idx[start][1]] = True
feature_flatten = select_seed_embedding(seeds_candidates, features)
count = 1
while count < k:
seeds_features = select_seed_embedding(seeds, features)
dist_pair = euclidean_distances(seeds_features, feature_flatten)
next_seed = np.argmax(np.min(dist_pair, axis=0))
seeds[seeds_candidates_idx[next_seed][0],
seeds_candidates_idx[next_seed][1]] = True
count += 1
return seeds
def calc_denpt(ourmap, neighbor_thre, ratio):
binamap = ourmap > 0
ourmap[binamap == 0] = 0
data_max = filters.maximum_filter(ourmap, neighbor_thre)
data_min = filters.minimum_filter(ourmap, neighbor_thre)
maxima = ourmap == data_max
diffmap = ((data_max - data_min) > 0.001)
maxima[diffmap == 0] = 0
labeled, num_objects = ndimage.label(maxima)
slices = ndimage.find_objects(labeled)
x, y, sc = [], [], []
for dy, dx in slices:
x_center = (dx.start + dx.stop - 1) / 2 * ratio
x.append(x_center)
y_center = (dy.start + dy.stop - 1) / 2 * ratio
y.append(y_center)
sc.append(ourmap[int(y_center / ratio), int(x_center / ratio)])
x = np.asarray(x, dtype=np.float32)
y = np.asarray(y, dtype=np.float32)
sc = np.asarray(sc, dtype=np.float32)
return x, y, sc
def r_erosion(image, size, origin=0):
"""Erosion with rectangular structuring element using maximum_filter"""
return filters.minimum_filter(image, size, origin=origin)
def rg_erosion(image, size, origin=0):
"""Grayscale erosion with maximum/minimum filters."""
return filters.minimum_filter(image, size, origin=origin)
def MinFilter(img, wlen):
img_conv_min = [
minimum_filter(interpolate_replace_nans(img[i], np.ones((29, 29))),
size=wlen) for i in range(0, len(img))
]
return img_conv_min
def permutation_STEM(individual,
STEM_parameters,
filter_size=0.5,
move_cutoff=0.5,
max_cutoff=0.5,
min_cutoff=0.5):
"""Moves surface atoms around based on the difference in the target
and individual STEM image
Parameters
----------
STEM_parameters : dict
Parameters for the STEM calculation. Ideally should be the same as the ones
used for the STEM fitness/relaxation
filter_size : float
Filter size for choosing local maximum in the picture. Filter size is equal
to average_bond_length * resolution * filter_size.
move_cutoff : float
The search radius for selecting an atom to move near a high intensity point.
Defaults to the average bond distance
"""
module = STEM(STEM_parameters)
module.generate_target()
target = module.target
image, x_shift, y_shift = module.cross_correlate(
module.get_image(individual))
contrast = image - target
max_max = np.max(contrast)
min_min = np.min(contrast)
###################################
## Code for testing the contrast ##
###################################
# import matplotlib.pyplot as plt
# import matplotlib.cm as cm
# fig, ax = plt.subplots()
# fig.colorbar(ax.pcolormesh(contrast, cmap=cm.viridis, linewidths=0))
# ax.set_xlim((0, STEM_parameters['dimensions'][0] * STEM_parameters['resolution']))
# ax.set_ylim((0, STEM_parameters['dimensions'][1] * STEM_parameters['resolution']))
# plt.show()
# import sys; sys.exit()
# Find a list of local maximum and local minimum in the image
cutoff = get_avg_radii(individual) * 2 * 1.1
move_cutoff *= cutoff
resolution = module.parameters['resolution']
size = cutoff * resolution * filter_size
data_max = filters.maximum_filter(contrast, size=size)
maxima = ((contrast == data_max) & (contrast > max_max * max_cutoff))
if len(maxima) == 0:
return False
max_coords = np.argwhere(maxima)
max_xys = (max_coords[:, ::-1] -
np.array([[x_shift, y_shift]])) / resolution
max_intensities = np.asarray(
[data_max[tuple(coord)] for coord in max_coords])
max_intensities /= sum(max_intensities)
###################################
## Code for testing the max find ##
###################################
# import matplotlib.pyplot as plt
# import matplotlib.cm as cm
# fig, ax = plt.subplots()
# fig.colorbar(ax.pcolormesh(maxima, cmap=cm.viridis, linewidths=0))
# ax.set_xlim((0, STEM_parameters['dimensions'][0] * STEM_parameters['resolution']))
# ax.set_ylim((0, STEM_parameters['dimensions'][1] * STEM_parameters['resolution']))
# print(len(max_intensities))
# fig, ax = plt.subplots(num=2)
# fig.colorbar(ax.pcolormesh(data_max, cmap=cm.viridis, linewidths=0))
# ax.set_xlim((0, STEM_parameters['dimensions'][0] * STEM_parameters['resolution']))
# ax.set_ylim((0, STEM_parameters['dimensions'][1] * STEM_parameters['resolution']))
# plt.show()
# print(len(max_intensities))
# import sys; sys.exit()
data_min = filters.minimum_filter(contrast, size=size)
minima = ((contrast == data_min) & (contrast < min_min * min_cutoff))
if len(minima) == 0:
return False
min_coords = np.argwhere(minima)
min_xys = (min_coords[:, ::-1] - [x_shift, y_shift]) / resolution
min_intensities = np.asarray(
[data_min[tuple(coord)] for coord in min_coords])
min_intensities = np.absolute(min_intensities)
min_intensities /= sum(min_intensities)
###################################
## Code for testing the min find ##
###################################
# import matplotlib.pyplot as plt
# import matplotlib.cm as cm
# fig, ax = plt.subplots(num=1)
# fig.colorbar(ax.pcolormesh(minima, cmap=cm.viridis, linewidths=0))
# ax.set_xlim((0, STEM_parameters['dimensions'][0] * STEM_parameters['resolution']))
# ax.set_ylim((0, STEM_parameters['dimensions'][1] * STEM_parameters['resolution']))
# fig, ax = plt.subplots(num=2)
# fig.colorbar(ax.pcolormesh(data_min, cmap=cm.viridis, linewidths=0))
# ax.set_xlim((0, STEM_parameters['dimensions'][0] * STEM_parameters['resolution']))
# ax.set_ylim((0, STEM_parameters['dimensions'][1] * STEM_parameters['resolution']))
# plt.show()
# print(len(min_intensities))
# import sys; sys.exit()
# Get atoms associated with each max and min column
xys = individual.get_positions()[:, :2]
max_dists = np.expand_dims(xys, 0) - np.transpose(
np.expand_dims(max_xys, 0), (1, 0, 2))
max_dists = np.linalg.norm(max_dists, axis=2)
max_column_indices = [
np.where(dists < move_cutoff)[0] for dists in max_dists
]
min_dists = np.expand_dims(xys, 0) - np.transpose(
np.expand_dims(min_xys, 0), (1, 0, 2))
min_dists = np.linalg.norm(min_dists, axis=2)
min_column_indices = [
np.where(dists < move_cutoff)[0] for dists in min_dists
]
if np.size(min_column_indices) == 0 or np.size(max_column_indices) == 0:
return False
# Eliminate columns that cannot be "improved" by a permutation
syms = np.asarray(individual.get_chemical_symbols())
unique_syms = np.unique(syms)
unique_nums = [atomic_numbers[sym] for sym in unique_syms]
max_sym = unique_syms[np.argmax(unique_nums)]
min_sym = unique_syms[np.argmin(unique_nums)]
for i, indices in reversed(list(enumerate(max_column_indices))):
if all(syms[indices] == min_sym):
max_column_indices = np.delete(max_column_indices, i, axis=0)
max_intensities = np.delete(max_intensities, i)
max_intensities /= np.sum(max_intensities)
for i, indices in reversed(list(enumerate(min_column_indices))):
if all(syms[indices] == max_sym):
min_column_indices = np.delete(min_column_indices, i, axis=0)
min_intensities = np.delete(min_intensities, i)
min_intensities /= np.sum(min_intensities)
# Pick a max column and min column based on their intensities
if np.size(min_column_indices) == 0 or np.size(max_column_indices) == 0:
return False
max_column_indices = max_column_indices[np.random.choice(
np.arange(len(max_intensities)), p=max_intensities)]
min_column_indices = min_column_indices[np.random.choice(
np.arange(len(min_intensities)), p=min_intensities)]
# Pick a move between the two columns based on differences in atomic numbers
max_column_numbers = [
atomic_numbers[sym] for sym in syms[max_column_indices]
]
min_column_numbers = [
atomic_numbers[sym] for sym in syms[min_column_indices]
]
max_column_numbers = np.expand_dims(max_column_numbers, 0)
min_column_numbers = np.expand_dims(min_column_numbers, 0).T
min_max_pairs = np.argwhere(max_column_numbers - min_column_numbers > 0)
min_index, max_index = min_max_pairs[random.randint(
0,
len(min_max_pairs) - 1)]
min_index, max_index = min_column_indices[min_index], max_column_indices[
max_index]
max_symbol = syms[max_index]
min_symbol = syms[min_index]
# Switch the atomic symbols
individual[max_index].symbol = min_symbol
individual[min_index].symbol = max_symbol
return
def detect(self, image):
"""Detect CENSURE keypoints along with the corresponding scale.
Parameters
----------
image : 2D ndarray
Input image.
"""
# (1) First we generate the required scales on the input grayscale
# image using a bi-level filter and stack them up in `filter_response`.
# (2) We then perform Non-Maximal suppression in 3 x 3 x 3 window on
# the filter_response to suppress points that are neither minima or
# maxima in 3 x 3 x 3 neighbourhood. We obtain a boolean ndarray
# `feature_mask` containing all the minimas and maximas in
# `filter_response` as True.
# (3) Then we suppress all the points in the `feature_mask` for which
# the corresponding point in the image at a particular scale has the
# ratio of principal curvatures greater than `line_threshold`.
# (4) Finally, we remove the border keypoints and return the keypoints
# along with its corresponding scale.
num_scales = self.max_scale - self.min_scale
image = np.ascontiguousarray(_prepare_grayscale_input_2D(image))
# Generating all the scales
filter_response = _filter_image(image, self.min_scale, self.max_scale,
self.mode)
# Suppressing points that are neither minima or maxima in their
# 3 x 3 x 3 neighborhood to zero
minimas = minimum_filter(filter_response, (3, 3, 3)) == filter_response
maximas = maximum_filter(filter_response, (3, 3, 3)) == filter_response
feature_mask = minimas | maximas
feature_mask[filter_response < self.non_max_threshold] = False
for i in range(1, num_scales):
# sigma = (window_size - 1) / 6.0, so the window covers > 99% of
# the kernel's distribution
# window_size = 7 + 2 * (min_scale - 1 + i)
# Hence sigma = 1 + (min_scale - 1 + i)/ 3.0
_suppress_lines(feature_mask[:, :, i], image,
(1 + (self.min_scale + i - 1) / 3.0),
self.line_threshold)
rows, cols, scales = np.nonzero(feature_mask[..., 1:num_scales])
keypoints = np.column_stack([rows, cols])
scales = scales + self.min_scale + 1
if self.mode == 'dob':
self.keypoints = keypoints
self.scales = scales
return
cumulative_mask = np.zeros(keypoints.shape[0], dtype=np.bool)
if self.mode == 'octagon':
for i in range(self.min_scale + 1, self.max_scale):
c = (OCTAGON_OUTER_SHAPE[i - 1][0] - 1) // 2 \
+ OCTAGON_OUTER_SHAPE[i - 1][1]
cumulative_mask |= (
_mask_border_keypoints(image.shape, keypoints, c)
& (scales == i))
elif self.mode == 'star':
for i in range(self.min_scale + 1, self.max_scale):
c = STAR_SHAPE[STAR_FILTER_SHAPE[i - 1][0]] \
+ STAR_SHAPE[STAR_FILTER_SHAPE[i - 1][0]] // 2
cumulative_mask |= (
_mask_border_keypoints(image.shape, keypoints, c)
& (scales == i))
self.keypoints = keypoints[cumulative_mask]
self.scales = scales[cumulative_mask]
beta = 2
crcc = beta * cv2.Scharr(oca.real, cv2.CV_64F, 1, 0) + (1/beta) * cv2.Scharr(oca.imag, cv2.CV_64F, 0, 1)
lam = 0.5
weighted_img = (1 - lam) * cv2.filter2D(255 - gray, cv2.CV_64F, wa)
filtered_img = lam * cv2.filter2D(gray, cv2.CV_64F, crcc)
co = filtered_img + weighted_img
# adjust this value down for darker images
threshold = 400
data_max = filters.maximum_filter(co, 11)
data_min = filters.minimum_filter(co, 11)
diff = ((data_max - data_min) > threshold)
maxima = (co == data_max)
maxima[diff == 0] = 0
max_coords = np.transpose(np.where(maxima))
abs_max = co.max()
abs_maxima = (co == abs_max)
abs_coords = np.transpose(np.where(abs_maxima))
print(abs_max)
max_psr = -1
max_psr_coords = []
for coords in max_coords:
row = coords[0]
def renal_segment_v4(recon,
temp_res,
spacing,
root_path,
threshold_multiplier=1):
# Based on Grabcut_Renal_Dev_v16
# recon : 4D dataset [x,y,z,t]
# temp_res : temporal resolution in sec
# spacing : spatial resolution in mm [x,y,z]
cleanup_enabled = True
GC_BGD = 0
GC_FGD = 1
GC_PR_BGD = 2
GC_PR_FGD = 3
nx, ny, nz, nt = recon.shape
if issubclass(recon.dtype.type, np.integer):
recon -= np.amin(recon)
# Use look up table
lut = np.arange(np.amax(recon) + 1).astype(np.float)
lut = (lut / np.amax(lut) * 255).astype(np.uint8)
recon = lut[recon]
else:
recon -= np.amin(recon)
recon /= np.amax(recon)
recon = (recon * 255).astype(np.uint8)
## Find medulla clusters ##
sig = recon.reshape(-1, nt)
mean_sig = np.mean(sig, axis=0)
mean_sig = gaussian_filter(mean_sig, 10 /
temp_res) # Filter to reduce temporal noise
t_5p = get_first_crossing_time(mean_sig, 0.10)[0]
t_5p = np.floor(t_5p).astype(np.int)
t_start = max(t_5p, 0)
t_30 = min(t_start + np.ceil(30 / temp_res).astype(np.int), nt - 1)
t_45 = min(t_start + np.ceil(45 / temp_res).astype(np.int), nt - 1)
t_60 = min(t_start + np.ceil(60 / temp_res).astype(np.int), nt - 1)
t_90 = min(t_start + np.ceil(90 / temp_res).astype(np.int), nt - 1)
t_120 = min(t_start + np.ceil(120 / temp_res).astype(np.int), nt - 1)
t_180 = min(t_start + np.ceil(180 / temp_res).astype(np.int), nt - 1)
t_240 = min(t_start + np.ceil(240 / temp_res).astype(np.int), nt - 1)
# Penalize voxels with high initial intensity
start_score = recon[:, :, :, t_start].astype(np.float).copy()
start_score = gaussian_filter(start_score, 2 / spacing)
start_score -= np.amin(start_score)
start_score /= np.amax(start_score)
start_score = 1 - start_score
# Penalize voxels where motion is dominant
y = sig[:, t_60:t_120].astype(np.float).T
x = np.arange(y.shape[0])
Z = np.polyfit(x, y, 2)
X = np.vstack((x**2, x**1, x**0))
y_fit = np.dot(Z.T, X)
y_res = y.T - y_fit
y_res_std = np.std(y_res, axis=1)
y_res_std3d = y_res_std.reshape(nx, ny, nz)
motion_score = y_res_std3d.copy()
motion_score = gaussian_filter(motion_score, 2 / spacing)
motion_score -= np.amin(motion_score)
motion_score /= np.amax(motion_score)
motion_score = 1 - motion_score
# Look at time to peak
im_90p = get_first_crossing_time(recon[:, :, :, t_start:t_60], 0.90)
im_90p[im_90p == 0.0] = np.amax(im_90p)
im_90p = gaussian_filter(im_90p, sigma=2 / spacing)
im_90p -= np.amin(im_90p)
im_90p /= np.amax(im_90p)
im_90p = 1 - im_90p
nb_mm = 11 # Based on cortical thickness
nb = np.ceil(nb_mm / spacing).astype(np.int)
im_90p_filt = im_90p.copy()
im_90p_filt = maximum_filter(im_90p_filt, nb)
im_90p_filt = minimum_filter(im_90p_filt, nb)
med_temp_score = im_90p_filt
# Get images at predetermined time points
recon_bl = gaussian_filter(recon.astype(np.float),
np.hstack((0 / spacing, 10 / temp_res)))
recon_start = recon_bl[:, :, :, t_start].astype(np.float)
recon_30 = recon_bl[:, :, :, t_30].astype(np.float)
recon_45 = recon_bl[:, :, :, t_45].astype(np.float)
recon_60 = recon_bl[:, :, :, t_60].astype(np.float)
recon_90 = recon_bl[:, :, :, t_90].astype(np.float)
recon_120 = recon_bl[:, :, :, t_120].astype(np.float)
recon_240 = recon_bl[:, :, :, t_240].astype(np.float)
# Medulla Marker
med_marker3_1 = (recon_60 - recon_start)
med_marker3_1[med_marker3_1 < 0] = 0
med_marker3_1 = gaussian_filter(med_marker3_1, 2 / spacing)
med_marker3_1 -= np.amin(med_marker3_1)
med_marker3_1 /= np.amax(med_marker3_1)
med_marker3_2 = (recon_120 - recon_60)
mask = med_marker3_2 > 0
med_marker3_2[med_marker3_2 < 0] = 0
med_marker3_2 = gaussian_filter(med_marker3_2, 2 / spacing)
med_marker3_2 -= np.amin(med_marker3_2)
med_marker3_2 /= np.amax(med_marker3_2)
med_marker3 = np.ones((nx, ny, nz), dtype=np.float)
med_marker3 = med_marker3 * med_marker3_1
med_marker3 = med_marker3 * med_marker3_2
med_marker3 = med_marker3 * motion_score
med_marker3 = med_marker3 * start_score
med_marker3 = med_marker3 * med_temp_score
med_marker3 = med_marker3 / np.amax(med_marker3)
med_marker3[med_marker3 < 0] = 0
med_marker_filt3 = med_marker3 * mask
# If available calculate CS Marker
if (t_180 < nt - 1):
# Look at time to peak
cs_im_90 = get_first_crossing_time(recon[:, :, :, t_start:t_180], 0.90)
cs_im_90 = gaussian_filter(cs_im_90, sigma=2 / spacing)
cs_im_90 -= np.amin(cs_im_90)
cs_im_90 /= np.amax(cs_im_90)
cs_temp_score = cs_im_90
med_marker4_2 = (recon_240 - recon_120)
mask = med_marker4_2 > 0
med_marker4_2[med_marker4_2 < 0] = 0
med_marker4_2 = gaussian_filter(med_marker4_2, 2 / spacing)
med_marker4_2 -= np.amin(med_marker4_2)
med_marker4_2 /= np.amax(med_marker4_2)
med_marker4 = np.ones((nx, ny, nz), dtype=np.float)
med_marker4 = med_marker4 * med_marker4_2
med_marker4 = med_marker4 * motion_score
med_marker4 = med_marker4 * start_score
med_marker4 = med_marker4 * cs_temp_score
med_marker4 = med_marker4 / np.amax(med_marker4)
med_marker4[med_marker4 < 0] = 0
med_marker_filt4 = med_marker4 * mask
# Combine medulla marker with cs marker if available
if (t_180 < nt - 1):
med_marker5 = med_marker4 / np.amax(
med_marker4) + med_marker_filt3 / np.amax(med_marker_filt3)
med_marker_filt5 = med_marker_filt4 / np.amax(
med_marker_filt4) + med_marker_filt3 / np.amax(med_marker_filt3)
else:
med_marker_filt5 = med_marker_filt3
med_marker_im3d = med_marker_filt5.copy()
med_marker_im3d -= np.amin(med_marker_im3d)
med_marker_im3d /= np.amax(med_marker_im3d)
med_marker_im3d = (255 * med_marker_im3d).astype(np.uint8)
med_cutoff_otsu = threshold_otsu(
med_marker_im3d[med_marker_im3d > 0].ravel()) * threshold_multiplier
# Connect nearby medulla regions
nb_mm = 11 # Based on cortical thickness
nb = np.ceil(nb_mm / spacing).astype(np.int)
med_valid = med_marker_im3d.astype(np.float) > med_cutoff_otsu
med_valid_max = maximum_filter(med_valid, nb)
med_valid_label, num_labels = label(med_valid_max)
med_valid_label[med_valid == 0] = 0
# Find the largest 4 clusters
cluster_size = np.bincount(med_valid_label.ravel())
cluster_size[0] = 0
sorted_clusters = np.argsort(cluster_size)[::-1]
largest_n = 4
med_valid_largest = np.zeros_like(med_valid_label)
for i in range(min(largest_n, sorted_clusters.shape[0])):
cluster_id = sorted_clusters[i]
if cluster_size[cluster_id] > 0:
med_valid_largest[med_valid_label == cluster_id] = i + 1
## GrabCut Section ##
tic_cell = time.time()
nb_mm = 25 # Based on cortical thickness (12.5 mm extension on all sides for max cort. thickness of 11mm)
nb = np.ceil(nb_mm / spacing).astype(np.int)
recon_min = np.amin(recon, axis=3, keepdims=True)
recon_diff = gaussian_filter(recon - recon_min,
np.hstack((0 / spacing, 0 / temp_res)))
output3d = np.zeros((nx, ny, nz), dtype=np.int)
output3d_bbox_list = []
for cluster_id in np.unique(med_valid_largest[med_valid_largest > 0]):
print("Cluster_id =", cluster_id)
# Expand the mask by maximum cortical thickness to cover the whole kidney
potential_mask = med_valid_largest == cluster_id
potential_mask = maximum_filter(potential_mask, nb)
# Generate the 3d convex hull
potential_mask = convex_hull_image_3d(potential_mask)
# Calculate the bounding box
bbox = get_bbox(potential_mask)
# Expand bbox to get more background
scale = 1.5
xyz_min, xyz_end = bbox
xyz_len = xyz_end - xyz_min
xyz_len_shift = np.round((scale - 1) * xyz_len).astype(np.int)
new_xyz_min = xyz_min - np.floor(xyz_len_shift / 2).astype(np.int)
new_xyz_min[new_xyz_min < 0] = 0
new_xyz_len = xyz_len + xyz_len_shift
new_xyz_max = new_xyz_min + new_xyz_len
new_xyz_over = new_xyz_max - [nx, ny, nz]
new_xyz_over[new_xyz_over < 0] = 0
new_xyz_len = xyz_len + xyz_len_shift - new_xyz_over
bbox = (new_xyz_min, new_xyz_min + new_xyz_len)
bb_l, bb_h = bbox
potential_mask_bbox = potential_mask[bb_l[0]:bb_h[0], bb_l[1]:bb_h[1],
bb_l[2]:bb_h[2]]
# Calculate PCA
recon_diff_bbox = recon_diff[bb_l[0]:bb_h[0], bb_l[1]:bb_h[1],
bb_l[2]:bb_h[2], :]
nx_bb, ny_bb, nz_bb, nt_bb = recon_diff_bbox.shape
pca = PCA(n_components=3)
im3d_pca_bbox = pca.fit_transform(
recon_diff_bbox.reshape(-1, recon_diff_bbox.shape[-1]).astype(
np.float))
im3d_pca_bbox = im3d_pca_bbox.reshape(nx_bb, ny_bb, nz_bb, -1)
im3d_rgb_bbox = im3d_pca_bbox.copy()
for ch in range(im3d_rgb_bbox.shape[3]):
im3d_ch = im3d_rgb_bbox[:, :, :, ch]
im3d_ch -= np.amin(im3d_ch)
im3d_ch = im3d_ch / np.amax(im3d_ch) * 255
im3d_rgb_bbox[:, :, :, ch] = im3d_ch
im3d_rgb_bbox = im3d_rgb_bbox.astype(np.uint8)
# Perform GrabCut
potential_mask3d_bbox = potential_mask_bbox
img_gc = np.transpose(im3d_rgb_bbox, (2, 0, 1, 3))
mask_gc = np.zeros(im3d_rgb_bbox.shape[:3], np.uint8)
mask_gc[potential_mask3d_bbox > 0] = GC_PR_FGD
mask_gc = np.transpose(mask_gc, (2, 0, 1))
# Create a directory for temporary files
buffer_directory = os.path.join(root_path, "Buffer")
try:
os.makedirs(buffer_directory)
except OSError as exception:
if exception.errno != errno.EEXIST:
raise
input_filename = os.path.join(buffer_directory, "input.umt")
mask_filename = os.path.join(buffer_directory, "mask.umt")
output_filename = os.path.join(buffer_directory, "output.umt")
umtWrite(input_filename, img_gc)
umtWrite(mask_filename, mask_gc)
program_path = os.path.join(root_path, "CppSource", "GrabCut3d",
"run_grabcut3d")
tic = time.time()
ret_val = subprocess.call(
[program_path, input_filename, mask_filename, output_filename])
assert ret_val == 0, 'GrabCut function failed!'
print('Elapsed time:', time.time() - tic)
output3d_bbox = umtRead(output_filename)
output3d_bbox = np.transpose(output3d_bbox, (1, 2, 0)) == GC_PR_FGD
output3d_bbox_list.append(output3d_bbox)
output3d_slice = output3d[bb_l[0]:bb_h[0], bb_l[1]:bb_h[1],
bb_l[2]:bb_h[2]]
output3d_slice[output3d_bbox > 0] = output3d_bbox[output3d_bbox > 0]
print('Cell_Time =', time.time() - tic_cell)
# Remove temporary files
shutil.rmtree(buffer_directory)
## Label the connected regions ##
kidney_labels, n_labels = label(output3d)
cluster_size = np.bincount(kidney_labels.ravel())
# Eliminate anything below 25% of the largest region
cluster_size[0] = 0
cluster_size_cutoff = np.amax(cluster_size) * 0.25
cluster_size[cluster_size < cluster_size_cutoff] = 0
cluster_id = 0
for i in range(n_labels + 1):
if cluster_size[i] > 0:
cluster_id += 1
cluster_size[i] = cluster_id
kidney_labels = cluster_size[kidney_labels]
cluster_size = np.bincount(kidney_labels.ravel())
## 3D Cleanup ##
if cleanup_enabled:
# Fill holes in x, y, z slices for robustness
# This will fill up the convex volume before erosion.
output_filled = fill_holes3d(output3d)
nb_mm = 3.2 * 2 # (2 x minimum cortical thickness)
nb = np.floor(nb_mm / spacing).astype(
np.int) # (floor to be conservative)
nb[nb < 3] = 3 # At least 1 voxel in each direction
# Erode the output of the first pass
# output3d_eroded = minimum_filter(output3d, nb)
output3d_eroded = minimum_filter(output_filled, nb)
output3d_opened = maximum_filter(output3d_eroded, nb + 2)
output3d_cleaned = output3d.copy()
output3d_cleaned[output3d_opened > 0] = 0
output3d_final2 = output3d.copy()
output3d_final2[output3d_opened == 0] = 0
kidney_labels, n_labels = label(output3d_final2)
cluster_size = np.bincount(kidney_labels.ravel())
# Eliminate anything below 25% of the largest region
cluster_size[0] = 0
cluster_size_cutoff = np.amax(cluster_size) * 0.25
cluster_size[cluster_size < cluster_size_cutoff] = 0
cluster_id = 0
for i in range(n_labels + 1):
if cluster_size[i] > 0:
cluster_id += 1
cluster_size[i] = cluster_id
kidney_labels = cluster_size[kidney_labels]
# Eliminate noisy regions
sig = recon.reshape(-1, nt)
kidney_labels_fixed = np.zeros_like(kidney_labels)
valid_count = 0
valid_sig = []
invalid_sig = []
for cluster_id in np.unique(kidney_labels[kidney_labels > 0]):
cluster_mask = kidney_labels == cluster_id
sig_mask = np.mean(sig[cluster_mask.ravel(), :], axis=0)
t_50p = get_first_crossing_time(sig_mask.reshape(1, -1), 0.50)
if t_50p < t_start or t_50p > t_30:
print('Noise_detected!')
invalid_sig.append(sig_mask)
continue
valid_sig.append(sig_mask)
valid_count += 1
kidney_labels_fixed[cluster_mask > 0] = valid_count
kidney_labels = kidney_labels_fixed
print('Segmentation completed.')
return kidney_labels
def detect_sources(img_data,
threshold,
aperture_type='radius',
size=5,
footprint=None,
bin_struct=None,
sigma=2,
saturate=None,
margin=None):
"""
Erodes the background to isolate sources and selects the maximum as approximate positions of sources
Parameters
----------
img_data: numpy 2D array
image data
threshold: float
minimum pixel value above the background noise
size: int, optional
width of the area in which to search for a maximum (for each point)
footprint: numpy 2D array (dtype=boolean),optional
Instead of supplying a size, a footprint can be given of a different shape to use for finding a footprint
example:
footprint=np.array([
[0,0,1,0,0],
[0,1,1,1,0],
[1,1,1,1,1],
[0,1,1,1,0],
[0,0,1,0,0]
])
The above example would only seach for a maximum in the pixels labeled by 1 in the region
centered on a given pixel
Note: either a size or a footprint must be secified
bin_struct: 2D numpy array,optional
Minimum structure that regions of the image are shrunk down to in order to isolate maxima
sigma: float, optional
This function uses a guassian filter to smooth the image (only for detection of sources),
which helps eliminate multiple maximum detections for the same object. 'sigma' describes the
standard deviation of the gaussian kernel used in the filter
saturate: float,optional
Value at which CCD's for the detector become saturated and are no longer linear
margin: int, optional
Sources close to the edges can be cut off to prevent partial data from becoming mixed up with good detections
Returns
-------
maxima: numpy 2D array
Approximate locations of the source maximum values.
To get more accurate positions each maxima should be fit to a desired profile
"""
# Make a mask where elements above the threshold are True and below the threshold are False.
# This essentially removes the background and leaves islands of 1's, representing possible sources
binData = img_data >= threshold
# The binary_opening function shrinks all of the 'islands' from the previous step into binary structes,
# then it dilates them again back to their original shape and width.
# Shape of the created binary structure (if not specified by the user):
# 010
# 111
# 010
if bin_struct is None:
bin_struct = ndimage.generate_binary_structure(2, 1)
binData = ndimage.binary_opening(binData, structure=bin_struct)
# Use our binary data to mask the image and blur the image so get rid of small local maxima that will
# give us false positive sources
data = filters.gaussian_filter(binData * img_data, sigma=sigma)
# The maximum/minimum filters select max/min value in a square with sides length 'size' centered on
# each element. Filter out all of the objects below the threshold
params = {'input': data}
if aperture_type == 'width':
params['size'] = size
elif aperture_type == 'radius':
params['footprint'] = get_circle_foot(size)
elif aperture_type == 'footprint':
params['footprint'] = footprint
else:
raise astrotoyz.core.AstroToyzError(
'Invalid aperture type in detect_sources')
# Search for the maximum and minimum points to determine the amplitude of the pixel above its neighboring pixels
# Note: this only gives the amplitude above the background if the background is within size/2 (or the footprint)
# of a given pixel.
data_max = filters.maximum_filter(**params)
maxima = (data == data_max)
data_min = filters.minimum_filter(**params)
diff = ((data_max - data_min) > threshold)
maxima[diff == 0] = 0
# Filter out the saturated objects
if saturate is not None:
maxima[data > saturate] = 0
# Remove the sources near the margins that will be cut off.
# TODO: Dump these in another file as they will still be useful in determining isolated
# neighbors for PSF stars
if margin is None:
margin = int(size / 2)
if isinstance(margin, list):
maxima[-margin[0]:, :] = 0
maxima[:margin[1], :] = 0
maxima[:, -margin[2]:] = 0
maxima[:, :margin[3]] = 0
else:
maxima[-margin:, :] = 0
maxima[:margin, :] = 0
maxima[:, -margin:] = 0
maxima[:, :margin] = 0
lbl, nbrLbl = ndimage.label(maxima)
return maxima
def find_potential_fiducials_sensitive(self, frames, frames_full, bin, bin_full, cropsize=32,target=0,fid_list=[],proc_id=0,num_procs=1,
average_marker=None, threshold=1.7, mrcdata=[], aa=20):
a, l1 = self.find_potential_fiducials(frames, frames_full, bin, bin_full, cropsize, target, fid_list, proc_id, num_procs, average_marker, sen=True)
list_cx_cy_imnr = []
fact = 1.*bin/bin_full
for imnr in range(proc_id, len(frames_full), num_procs):
ds = frames[imnr] #downsample(wiener(full_image),n)**0.7
ds2 = ds.copy()
for xx in range(0,len(ds)):
for yy in range(0,len(ds[0])):
dd = median(ds[max(0,xx-10):xx+10,max(0,yy-10):yy+10])
ds2[xx,yy] = ds[xx,yy]-dd
ds = ds2
minf = minimum_filter( gaussian_filter(ds - gaussian_filter(ds, 5),.1) , footprint=ones((1,1)) )
hpf = minf - gaussian_filter(minf,4)
hpf -= hpf.min()
hpf /= median(hpf)
hpf = 1-hpf
gg = ((gaussian_filter(hpf,.1) ) )
gg -= gg.min()
gg /= median(gg)
rr = gaussian_filter( laplace( gaussian_filter( (1- gg/gg.max()), .1) ) , 1)
rr -= rr.min()
rr /= rr.max()
rr += 0.0001
tot = zeros_like(rr)
for ii in arange(4.1,3.59,-0.05):
rrr = rr.copy()
tot += self.testing_done(rrr,aa=aa,ff=ii)
ll, nn = label(tot)
for N in range(1,nn+1):
cx,cy = center_of_mass(ll==N)
#TOT[int(round(cx)),int(round(cy))] = 1
add = True
for a,b,c in list_cx_cy_imnr:
if abs(cx- a)+abs(cy-b) < 4 and imnr == c:
add = False
break
if add:
#dcx,dcy = (cx+(ccx*fact)-ss)/max(fact,1),(cy+(ccy*fact)-ss)/max(fact,1)
list_cx_cy_imnr.append([cx,cy,imnr])
out = l1
for rx,ry,im in list_cx_cy_imnr:
#print rx,ry,imnr
points = self.refine(rx, ry, frames_full[im], im, fact, cropsize)
#print 'points: ', points
for cx,cy,ims in points:
add = True
for a,b,c in out:
if abs(cx- a)+abs(cy-b) < 4 and ims == c:
add = False
break
if add:
out.append([cx,cy,ims])
fid_list += out #list_cx_cy_imnr
return numpy.zeros_like(frames_full[0]), list_cx_cy_imnr
class_index[k], avg_size[k][0], avg_size[k][1], avg_size[k][2],
avg_size[k][3])
prediction_dict[img_id].append(prediction_sent)
if np.isnan(data).any():
continue
w_k, h_k = (avg_size[k][2:4] * (256 / 1024)).astype(np.int)
# Find local maxima
neighborhood_size = 100
threshold = .1
data_max = filters.maximum_filter(data, neighborhood_size)
maxima = (data == data_max)
data_min = filters.minimum_filter(data, neighborhood_size)
diff = ((data_max - data_min) > threshold)
maxima[diff == 0] = 0
for _ in range(5):
maxima = binary_dilation(maxima)
labeled, num_objects = ndimage.label(maxima)
slices = ndimage.find_objects(labeled)
xy = np.array(
ndimage.center_of_mass(data, labeled, range(1, num_objects + 1)))
for pt in xy:
if data[int(pt[0]), int(pt[1])] > np.max(data) * .9:
upper = int(max(pt[0] - (h_k / 2), 0.))
left = int(max(pt[1] - (w_k / 2), 0.))
def HoughLines(edges,x_max,y_max):
theta_max = 1.0 * math.pi
theta_min = -1.0 * math.pi / 2.0
r_min = 0.0
r_max = math.hypot(x_max, y_max)
r_dim = 200
theta_dim = 300
hough_space = np.zeros((r_dim,theta_dim))
for edge in edges:
for itheta in range(theta_dim):
x,y=edge.pt
theta = 1.0 * itheta * (theta_max - theta_min) / theta_dim + theta_min
r = x * math.cos(theta) + y * math.sin(theta)
ir = round(r_dim * ( 1.0 * r ) / r_max)
if ir>=0 and ir<r_dim:
hough_space[ir,itheta] = hough_space[ir,itheta] + 1
neighborhood_size = 20
threshold = 20
data_max = filters.maximum_filter(hough_space, neighborhood_size)
maxima = (hough_space == data_max)
data_min = filters.minimum_filter(hough_space, neighborhood_size)
diff = ((data_max - data_min) > threshold)
maxima[diff == 0] = 0
labeled, num_objects = ndimage.label(maxima)
slices = ndimage.find_objects(labeled)
temp=[]
for dy,dx in slices:
x_center = (dx.start + dx.stop - 1)/2
y_center = (dy.start + dy.stop - 1)/2
temp.append((hough_space[int(y_center)][int(x_center)],x_center,y_center))
temp=sorted(temp,reverse=True)
#print(len(temp),temp)
x,y=[],[]
r=[]
theta=[]
for _,i,j in temp:
b=True
c=True
for x1,y1 in zip(x,y):
if dist((x1,y1),(i,j))<10:#checking for close lying hough peaks
b=False
break
if y1<10 and j<10 and (abs(x1-i)<10 or abs(x1-i) in range(190,210)):
c=False
break
if b and c:
x.append(i)
y.append(j)
r.append((1.0 * j * r_max ) / r_dim)
theta.append(1.0 * i * (theta_max - theta_min) / theta_dim + theta_min)
plt.imshow(hough_space, origin='lower')
plt.plot(x,y, 'ro')
cnt=1
for i,j in zip(x,y):
plt.text(i+1,j+1,str(cnt))
cnt+=1
plt.savefig('hough_space_maximas.png', bbox_inches = 'tight')
plt.close()
return r,theta
def valid_locations(img: np.ndarray,
pattern: np.ndarray,
algo_config: ValidInsertLocationsConfig,
protect_wrap: bool = True) -> np.ndarray:
"""
Returns a list of locations per channel which the pattern can be inserted
into the img_channel with an overlap algorithm dictated by the appropriate
inputs
:param img: a numpy.ndarray which represents the image of shape:
(nrows, ncols, nchans)
:param pattern: the pattern to be inserted into the image of shape:
(prows, pcols, nchans)
:param algo_config: The provided configuration object specifying the algorithm to use and necessary parameters
:param protect_wrap: if True, ensures that pattern to be inserted can fit without wrapping and raises an
Exception otherwise
:return: A boolean mask of the same shape as the input image, with True
indicating that that pixel is a valid location for placement of
the specified pattern
"""
num_chans = img.shape[2]
# broadcast allow_overlap variable if necessary
allow_overlap = algo_config.allow_overlap
if not isinstance(allow_overlap, Sequence):
allow_overlap = [allow_overlap] * num_chans
elif len(allow_overlap) != num_chans:
msg = "Length of provided allow_overlap sequence does not equal the number of channels in the image!"
logger.error(msg)
raise ValueError(msg)
# broadcast min_val variable if necessary
min_val = algo_config.min_val
if not isinstance(min_val, Sequence):
min_val = [min_val] * num_chans
elif len(min_val) != num_chans:
msg = "Length of provided min_val sequence does not equal the number of channels in the image!"
logger.error(msg)
raise ValueError(msg)
# broadcast threshold_val variable if necessary
threshold_val = algo_config.threshold_val
if algo_config.algorithm == 'threshold':
if not isinstance(threshold_val, Sequence):
threshold_val = [threshold_val] * num_chans
elif len(threshold_val) != num_chans:
msg = "Length of provided threshold_val sequence does not equal the number of channels in the image!"
logger.error(msg)
raise ValueError(msg)
if pattern.shape[2] != num_chans:
# force user to broadcast the pattern as necessary
msg = "The # of channels in the pattern does not match the # of channels in the image!"
logger.error(msg)
raise ValueError(msg)
# TODO: look for vectorization opportunities
output_mask = np.zeros(img.shape, dtype=bool)
for chan_idx in range(num_chans):
chan_img = img[:, :, chan_idx]
chan_pattern = pattern[:, :, chan_idx]
i_rows, i_cols = chan_img.shape
p_rows, p_cols = chan_pattern.shape
if allow_overlap[chan_idx]:
output_mask[0:i_rows - p_rows + 1, 0:i_cols - p_cols + 1,
chan_idx] = True
else:
if protect_wrap:
mask = (chan_img <= min_val[chan_idx])
# True if image present, False if not
img_mask = np.logical_not(mask)
# remove boundaries from valid locations
mask[i_rows - p_rows + 1:i_rows, :] = False
mask[:, i_cols - p_cols + 1:i_cols] = False
# get all edge pixels
edge_pixels = None
if algo_config.algorithm != 'bounding_box':
edge_pixel_coords = np.nonzero(
np.logical_and(
np.logical_xor(
filters.maximum_filter(img_mask,
3,
mode='constant',
cval=0.0),
filters.minimum_filter(img_mask,
3,
mode='constant',
cval=0.0)), img_mask))
edge_pixels = zip(edge_pixel_coords[0],
edge_pixel_coords[1])
if algo_config.algorithm == 'edge_tracing':
logger.debug(
"Computing valid locations according to edge_tracing algorithm"
)
edge_pixel_set = set(edge_pixels)
# search until all edges have been visited
while len(edge_pixel_set) != 0:
start_i, start_j = edge_pixel_set.pop()
# invalidate relevant pixels for start square
top_boundary = max(0, start_i - p_rows + 1)
left_boundary = max(0, start_j - p_cols + 1)
mask[top_boundary:start_i + 1,
left_boundary:start_j + 1] = False
curr_i, curr_j = start_i, start_j
move = 0, 0
while move is not None:
# what edge was last traversed
action_i, action_j = move
# current location
curr_i += action_i
curr_j += action_j
# truncate search when near top or left boundary
top_index = max(0, curr_i - p_rows + 1)
left_index = max(0, curr_j - p_cols + 1)
# update invalidation based on last move, marking a row or column invalid based on the size
# of action_i or action_j
# if action_i or action_j has absolute value greater than 0, the other must be 0,
# i.e diagonal moves of length greater than 1 aren't updated correctly by this
if action_i < 0:
# update top border
mask[top_index:top_index - action_i,
left_index:curr_j + 1] = False
elif action_i > 0:
# update bottom border
mask[curr_i - action_i + 1:curr_i + 1,
left_index:curr_j + 1] = False
if action_j < 0:
# update left border
mask[top_index:curr_i + 1,
left_index:left_index - action_j] = False
elif action_j > 0:
# update right border
mask[top_index:curr_i + 1,
curr_j - action_j + 1:curr_j + 1] = False
# obtain next pixel to inspect
move = _get_next_edge_from_pixel(
curr_i, curr_j, i_rows, i_cols, edge_pixel_set)
elif algo_config.algorithm == 'brute_force':
logger.debug(
"Computing valid locations according to brute_force algorithm"
)
for i, j in edge_pixels:
top_index, left_index = max(0, i - p_rows + 1), max(
0, j - p_cols + 1)
mask[top_index:i + 1, left_index:j + 1] = False
elif algo_config.algorithm == 'threshold':
logger.debug(
"Computing valid locations according to threshold algorithm"
)
for i, j in edge_pixels:
mask[max(0, i - p_rows + 1):i + 1,
max(0, j - p_cols + 1):j + 1] = False
# enumerate all possible invalid locations
mask_coords = np.nonzero(np.logical_not(mask))
possible_locations = zip(mask_coords[0], mask_coords[1])
# if average pixel value in location is below specified value, allow possible trigger overlap
for i, j in possible_locations:
if i <= i_rows - p_rows and j <= i_cols - p_cols and \
np.mean(chan_img[i:i + p_rows, j:j + p_cols]) <= threshold_val[chan_idx]:
mask[i][j] = True
elif algo_config.algorithm == 'bounding_boxes':
logger.debug(
"Computing valid locations according to bounding_boxes algorithm"
)
# generate top-left and bottom-right corners of all grid squares
top_left_coords = np.swapaxes(np.indices((algo_config.num_boxes, algo_config.num_boxes)), 0, 2) \
.reshape((algo_config.num_boxes * algo_config.num_boxes, 2))
bottom_right_coords = top_left_coords + 1
# rows give y1, x1, y2, x2 of grid boxes, y2 and x2 exclusive
box_coords = np.concatenate(
(top_left_coords, bottom_right_coords), axis=1)
box_coords = np.multiply(
box_coords, np.array([i_rows, i_cols, i_rows, i_cols]))
box_coords //= algo_config.num_boxes
# generate bounding boxes for image in each grid square
bounding_coords = np.apply_along_axis(
_get_bounding_box, 1, box_coords, img_mask)
# update mask, bounds -> top, left, bottom, right
for bounds in bounding_coords:
top_index = max(0, bounds[0] - p_rows + 1)
left_index = max(0, bounds[1] - p_cols + 1)
mask[top_index:bounds[2], left_index:bounds[3]] = False
output_mask[:, :, chan_idx] = mask
else:
msg = "Wrapping for trigger insertion has not been implemented yet!"
logger.error(msg)
raise ValueError(msg)
return output_mask
def complex_flux(spectrogram,
diff_frames=None,
diff_max_bins=3,
temporal_filter=3,
temporal_origin=0):
"""
ComplexFlux.
ComplexFlux is based on the SuperFlux, but adds an additional local group
delay based tremolo suppression.
Parameters
----------
spectrogram : :class:`Spectrogram` instance
:class:`Spectrogram` instance.
diff_frames : int, optional
Number of frames to calculate the diff to.
diff_max_bins : int, optional
Number of bins used for maximum filter.
temporal_filter : int, optional
Temporal maximum filtering of the local group delay [frames].
temporal_origin : int, optional
Origin of the temporal maximum filter.
Returns
-------
complex_flux : numpy array
ComplexFlux onset detection function.
References
----------
.. [1] Sebastian Böck and Gerhard Widmer,
"Local group delay based vibrato and tremolo suppression for onset
detection",
Proceedings of the 14th International Society for Music Information
Retrieval Conference (ISMIR), 2013.
"""
# create a mask based on the local group delay information
# take only absolute values of the local group delay and normalize them
lgd = np.abs(spectrogram.stft.phase().lgd()) / np.pi
# maximum filter along the temporal axis
# TODO: use HPSS instead of simple temporal filtering
if temporal_filter > 0:
lgd = maximum_filter(lgd,
size=[temporal_filter, 1],
origin=temporal_origin)
# lgd = uniform_filter(lgd, size=[1, 3]) # better for percussive onsets
# create the weighting mask
try:
# if the magnitude spectrogram was filtered, use the minimum local
# group delay value of each filterbank (expanded by one frequency
# bin in both directions) as the mask
mask = np.zeros_like(spectrogram)
num_bins = lgd.shape[1]
for b in range(mask.shape[1]):
# determine the corner bins for the mask
corner_bins = np.nonzero(spectrogram.filterbank[:, b])[0]
# always expand to the next neighbour
start_bin = corner_bins[0] - 1
stop_bin = corner_bins[-1] + 2
# constrain the range
if start_bin < 0:
start_bin = 0
if stop_bin > num_bins:
stop_bin = num_bins
# set mask
mask[:, b] = np.amin(lgd[:, start_bin:stop_bin], axis=1)
except AttributeError:
# if the spectrogram is not filtered, use a simple minimum filter
# covering only the current bin and its neighbours
mask = minimum_filter(lgd, size=[1, 3])
# sum all positive 1st order max. filtered and weighted differences
diff = spectrogram.diff(diff_frames=diff_frames,
diff_max_bins=diff_max_bins,
positive_diffs=True)
return np.asarray(np.sum(diff * mask, axis=1))
def plot_maxmin_points(lon,
lat,
data,
extrema,
nsize,
symbol,
color='k',
plotValue=True,
transform=None):
"""
This function will find and plot relative maximum and minimum for a 2D grid. The function
can be used to plot an H for maximum values (e.g., High pressure) and an L for minimum
values (e.g., low pressue). It is best to used filetered data to obtain a synoptic scale
max/min value. The symbol text can be set to a string value and optionally the color of the
symbol and any plotted value can be set with the parameter color.
Parameters
----------
lon : 2D array
Plotting longitude values
lat : 2D array
Plotting latitude values
data : 2D array
Data that you wish to plot the max/min symbol placement
extrema : str
Either a value of max for Maximum Values or min for Minimum Values
nsize : int
Size of the grid box to filter the max and min values to plot a reasonable number
symbol : str
Text to be placed at location of max/min value
color : str
Name of matplotlib colorname to plot the symbol (and numerical value, if plotted)
plot_value : Boolean (True/False)
Whether to plot the numeric value of max/min point
Return
------
The max/min symbol will be plotted on the current axes within the bounding frame
(e.g., clip_on=True)
"""
from scipy.ndimage.filters import maximum_filter, minimum_filter
if (extrema == 'max'):
data_ext = maximum_filter(data, nsize, mode='nearest')
elif (extrema == 'min'):
data_ext = minimum_filter(data, nsize, mode='nearest')
else:
raise ValueError('Value for hilo must be either max or min')
if lon.ndim == 1:
lon, lat = np.meshgrid(lon, lat)
mxx, mxy = np.where(data_ext == data)
for i in range(len(mxy)):
ax.text(lon[mxx[i], mxy[i]],
lat[mxx[i], mxy[i]],
symbol,
color=color,
size=36,
clip_on=True,
horizontalalignment='center',
verticalalignment='center',
transform=transform)
ax.text(lon[mxx[i], mxy[i]],
lat[mxx[i], mxy[i]],
'\n' + str(np.int(data[mxx[i], mxy[i]])),
color=color,
size=12,
clip_on=True,
fontweight='bold',
horizontalalignment='center',
verticalalignment='top',
transform=transform)
ax.plot(lon[mxx[i], mxy[i]],
lat[mxx[i], mxy[i]],
marker='o',
markeredgecolor='black',
markerfacecolor='white',
transform=transform)
ax.plot(lon[mxx[i], mxy[i]],
lat[mxx[i], mxy[i]],
marker='x',
color='black',
transform=transform)
def DivideInNeighborhoods(data, number_of_spots, scale, sensitivity_limit=100):
"""
Given an image that includes N spots, divides it in N subimages with each of them
to include one spot. Briefly, it filters the image, finds the N “brightest” spots
and crops the region around them generating the subimages. This process is repeated
until image division is feasible.
data (model.DataArray): 2D array containing the intensity of each pixel
number_of_spots (int,int): The number of CL spots
scale (float): Distance between spots in optical grid (in pixels)
sensitivity_limit (int): Limit of sensitivity
returns subimages (List of DataArrays): One subimage per spot
subimage_coordinates (List of tuples): The coordinates of the center of each
subimage with respect to the overall image
"""
# Denoise
filtered_image = ndimage.median_filter(data, 3)
# Bold spots
# Third parameter must be a length in pixels somewhat larger than a typical
# spot
filtered_image = BandPassFilter(filtered_image, 1, 20)
image = model.DataArray(filtered_image,
data.metadata) # TODO: why a DataArray?
avg_intensity = numpy.average(image)
spot_factor = 10
step = 4
sensitivity = 4
# After filtering based on optical scale there is no need to adjust
# filter window size
filter_window_size = 8
# Increase sensitivity until expected number of spots is detected
while sensitivity <= sensitivity_limit:
subimage_coordinates = []
subimages = []
i_max, j_max = unravel_index(image.argmax(), image.shape)
i_min, j_min = unravel_index(image.argmin(), image.shape)
max_diff = image[i_max, j_max] - image[i_min, j_min]
data_max = filters.maximum_filter(image, filter_window_size)
data_min = filters.minimum_filter(image, filter_window_size)
# Determine threshold
threshold = max_diff / sensitivity
# Filter the parts of the image with variance in intensity greater
# than the threshold
maxima = (image == data_max)
diff = ((data_max - data_min) > threshold)
maxima[diff == 0] = 0
labeled, num_objects = ndimage.label(maxima)
slices = ndimage.find_objects(labeled)
# If too many features found, discards the ones too close from each other
# Note: the main danger is that if the scale is wrong (bigger than the
# real value), it will remove correct images
if len(slices) > numpy.prod(number_of_spots):
logging.debug(
"Found %d features that could be spots, will be picky",
len(slices))
min_dist = max(4, scale / 2.1) # px
else:
min_dist = max(4, scale / 8.1) # px
# Go through these parts and crop the subimages based on the neighborhood_size
# value
x_center_last, y_center_last = 0, 0
for dy, dx in slices:
x_center = (dx.start + dx.stop - 1) / 2
y_center = (dy.start + dy.stop - 1) / 2
subimage = image[int(dy.start - 2.5):int(dy.stop + 2.5),
int(dx.start - 2.5):int(dx.stop + 2.5)]
if subimage.shape[0] == 0 or subimage.shape[1] == 0:
continue
if (subimage > spot_factor * avg_intensity).sum() < 6:
continue
# if spots detected too close keep the brightest one
# FIXME: it should do it globally: find groups of images too close,
# and pick the brightest point of each group
tab = (x_center_last - x_center, y_center_last - y_center)
if len(subimages) > 0 and math.hypot(tab[0], tab[1]) < min_dist:
if numpy.sum(subimage) > numpy.sum(
subimages[len(subimages) - 1]):
subimages.pop()
subimage_coordinates.pop()
subimage_coordinates.append((x_center, y_center))
subimages.append(subimage)
else:
subimage_coordinates.append((x_center, y_center))
subimages.append(subimage)
x_center_last, y_center_last = x_center, y_center
# Take care of outliers
expected_spots = numpy.prod(number_of_spots)
clean_subimages, clean_subimage_coordinates = FilterOutliers(
image, subimages, subimage_coordinates, expected_spots)
if len(clean_subimages) >= numpy.prod(number_of_spots):
break
sensitivity += step
else:
logging.warning("Giving up finding %d partitions, only found %d",
numpy.prod(number_of_spots), len(clean_subimages))
return clean_subimages, clean_subimage_coordinates
# initialize driver
driver = gdal.GetDriverByName('GTiff')
def write_image(img, filename):
"""
Write img array to a file with the given filename
Args:
img (Band)
filename (str)
"""
x_size = img.shape[1]
y_size = img.shape[0]
dataset = driver.Create(filename, x_size, y_size)
dataset.GetRasterBand(1).WriteArray(img)
# load original image
dataset = gdal.Open('img/mozambique-after-subset.tif')
band = dataset.GetRasterBand(1)
img = band.ReadAsArray().astype(np.uint8)
# position of local maxima
data_max = filters.maximum_filter(img, 5)
maxima = (img == data_max)
data_min = filters.minimum_filter(img, 5)
diff = ((data_max - data_min) > 150)
maxima[diff == 0] = 0
write_image(maxima, 'img/maxima.tif')
nc.close()
START_TIME = 0 * 4 + 0 #37 00
END_TIME = 59 * 4 + 3 #37 12
SURFACE_WIND_LEVEL = 5 #1000 hPa
UPPER_WIND_LEVEL = 1 #250 hPa
OUTFILE = "lowpts"
storms = {}
storm_id = 0
f = open(OUTFILE, 'w') #blank the file
f.close()
for TIME in xrange(START_TIME, END_TIME + 1):
# find low centers
data_ext = minimum_filter(pres[TIME], 50, mode='nearest')
mxy, mxx = np.where(data_ext == pres[TIME])
# get lat/lon of all low centers
low_lons = lons[mxx]
low_lats = lats[mxy]
#get info on each low
CROP = 8
print pres.shape
min_prs = pres[TIME, mxy, mxx]
#prepare tc lists
tc_lons = []
tc_lats = []
def search_shortest_path_dws(self, start, goal):
"""
start = (y, x)
goal = (y, x)
"""
start_goal = np.zeros((self.h, self.w), dtype=int)
cost = np.zeros((self.h, self.w), dtype=int) + 1E10
done = np.zeros((self.h, self.w), dtype=bool)
barrier = np.zeros((self.h, self.w), dtype=bool) # occupancyも含める
path = np.zeros((self.h, self.w), dtype=int)
entrance = np.zeros((self.h, self.w), dtype=bool)
#プーリング用のフィルタ
g = np.array([[0, 1, 0], [1, 1, 1], [0, 1, 0]])
for iy in range(self.h):
for ix in range(self.w):
if iy == start[0] and ix == start[1]:
cost[iy, ix] = 0
done[iy, ix] = True
start_goal[iy, ix] = -255
if iy == goal[0] and ix == goal[1]:
start_goal[iy, ix] = 255
if self.data[iy, ix] == 1: # barrier
barrier[iy, ix] = True
if (iy, ix) in self.entrances:
entrance[iy, ix] = True
barrier = barrier + self.occupancuy
barrier[start[0], start[1]] = False
barrier[goal[0], goal[1]] = False
# plt.imshow(barrier, cmap="gist_yarg")
# plt.imshow(entrance, cmap=customized_cool)
# plt.show()
for i in range(1, 10000000):
#次に進出するマスのbool
done_next = maximum_filter(done, footprint=g) * ~done # 速い
# done_next = max_pooling(done) * ~done
is_entrance = done_next * entrance
#次に進出するマスのcost
cost_next = minimum_filter(cost, footprint=g) * done_next # 速い
# cost_next = min_pooling(cost) * done_next
cost_next[done_next] += 1
# is_entranceがTrueのそれぞれのセルについて、
entrance_xy = list(zip(*np.where(is_entrance == True)))
for ey, ex in entrance_xy:
if done[ey - 1, ex] == True and self.room[ey - 1, ex] != True:
cost_next[ey, ex] = 10000000
done_next[ey, ex] = False
# print(f"This is entrance, {ey}, {ex}")
if done[ey, ex + 1] == True and self.room[ey, ex + 1] != True:
cost_next[ey, ex] = 10000000
done_next[ey, ex] = False
# print(f"This is entrance, {ey}, {ex}")
if done[ey + 1, ex] == True and self.room[ey + 1, ex] != True:
cost_next[ey, ex] = 10000000
done_next[ey, ex] = False
# print(f"This is entrance, {ey}, {ex}")
if done[ey, ex - 1] == True and self.room[ey, ex - 1] != True:
cost_next[ey, ex] = 10000000
done_next[ey, ex] = False
# print(f"This is entrance, {ey}, {ex}")
#costを更新
cost[done_next] = cost_next[done_next]
#ただし障害物のコストは10000000とする
cost[barrier] = 10000000
#探索終了マスを更新
done[done_next] = done_next[done_next]
#ただし障害物は探索終了としない
done[barrier] = False
#終了判定
if done[goal[0], goal[1]] == True:
break
# if self.debug:
# plt.imshow(cost, cmap="jet", vmax=200, vmin=0, alpha=1)
# barrier[goal[0], goal[1]] = 255
# barrier[start[0], start[1]] = 255
# plt.imshow(barrier, cmap=customized_gist_yarg)
# plt.show()
point_now = goal
cost_now = cost[goal[0], goal[1]]
route = [goal]
while cost_now > 0:
#上から来た場合
try:
if cost[point_now[0] - 1, point_now[1]] == cost_now - 1:
#更新
point_now = (point_now[0] - 1, point_now[1])
cost_now = cost_now - 1
#記録
route.append(point_now)
except:
pass
#下から来た場合
try:
if cost[point_now[0] + 1, point_now[1]] == cost_now - 1:
#更新
point_now = (point_now[0] + 1, point_now[1])
cost_now = cost_now - 1
#記録
route.append(point_now)
except:
pass
#左から来た場合
try:
if cost[point_now[0], point_now[1] - 1] == cost_now - 1:
#更新
point_now = (point_now[0], point_now[1] - 1)
cost_now = cost_now - 1
#記録
route.append(point_now)
except:
pass
#右から来た場合
try:
if cost[point_now[0], point_now[1] + 1] == cost_now - 1:
#更新
point_now = (point_now[0], point_now[1] + 1)
cost_now = cost_now - 1
#記録
route.append(point_now)
except:
pass
#ルートを逆順にする
route = route[::-1]
for cell in route:
ix = cell[1]
iy = cell[0]
path[iy, ix] = 1
# if self.debug:
# plt.imshow(path, cmap=customized_cool)
# plt.imshow(barrier, cmap=customized_gist_yarg)
# plt.show()
return route
def xlevenshtein(a, b, context=1):
"""Calculates the Levensthein distance between a and b
and generates a list of differences by context."""
n, m = len(a), len(b)
sources = empty((m + 1, n + 1), object)
sources[:, :] = None
dists = 99999 * ones((m + 1, n + 1))
dists[0, :] = arange(n + 1)
for i in range(1, m + 1):
previous = dists[i - 1, :]
current = dists[i, :]
current[0] = i
for j in range(1, n + 1):
if previous[j] + 1 < current[j]:
sources[i, j] = (i - 1, j)
dists[i, j] = previous[j] + 1
if current[j - 1] + 1 < current[j]:
sources[i, j] = (i, j - 1)
dists[i, j] = current[j - 1] + 1
delta = 1 * (a[j - 1] != b[i - 1])
if previous[j - 1] + delta < current[j]:
sources[i, j] = (i - 1, j - 1)
dists[i, j] = previous[j - 1] + delta
cost = current[n]
# reconstruct the paths and produce two aligned strings
l = sources[i, n]
path = []
while l is not None:
path.append(l)
i, j = l
l = sources[i, j]
al, bl = [], []
path = [(n + 2, m + 2)] + path
for k in range(len(path) - 1):
i, j = path[k]
i0, j0 = path[k + 1]
u = "_"
v = "_"
if j != j0 and j0 < n: u = a[j0]
if i != i0 and i0 < m: v = b[i0]
al.append(u)
bl.append(v)
al = "".join(al[::-1])
bl = "".join(bl[::-1])
# now compute a splittable string with the differences
assert len(al) == len(bl)
al = " " * context + al + " " * context
bl = " " * context + bl + " " * context
assert "~" not in al and "~" not in bl
same = array([al[i] == bl[i] for i in range(len(al))], 'i')
same = filters.minimum_filter(same, 1 + 2 * context)
als = "".join([al[i] if not same[i] else "~" for i in range(len(al))])
bls = "".join([bl[i] if not same[i] else "~" for i in range(len(bl))])
# print als
# print bls
ags = re.split(r'~+', als)
bgs = re.split(r'~+', bls)
confusions = [(a, b) for a, b in zip(ags, bgs) if a != "" or b != ""]
return cost, confusions
def test2D():
modes = {'reflect' : NumCpp.Mode.REFLECT,
'constant': NumCpp.Mode.CONSTANT,
'nearest': NumCpp.Mode.NEAREST,
'mirror': NumCpp.Mode.MIRROR,
'wrap': NumCpp.Mode.WRAP}
for mode in modes.keys():
print(colored(f'Testing complementaryMedianFilter: mode = {mode}', 'cyan'))
shape = np.random.randint(1000, 2000, [2,]).tolist()
cShape = NumCpp.Shape(shape[0], shape[1])
cArray = NumCpp.NdArray(cShape)
data = np.random.randint(100, 1000, shape)
cArray.setArray(data)
kernalSize = 0
while kernalSize % 2 == 0:
kernalSize = np.random.randint(5, 15)
constantValue = np.random.randint(0, 5, [1,]).item() # only actaully needed for constant boundary condition
dataOutC = NumCpp.complementaryMedianFilter(cArray, kernalSize, modes[mode], constantValue).getNumpyArray()
dataOutPy = data - filters.median_filter(data, size=kernalSize, mode=mode, cval=constantValue)
if np.array_equal(dataOutC, dataOutPy):
print(colored('\tPASS', 'green'))
else:
print(colored('\tFAIL', 'red'))
print(colored(f'Testing convolve: mode = {mode}', 'cyan'))
shape = np.random.randint(1000, 2000, [2,]).tolist()
cShape = NumCpp.Shape(shape[0], shape[1])
cArray = NumCpp.NdArray(cShape)
data = np.random.randint(10, 20, shape).astype(np.double)
cArray.setArray(data)
kernalSize = 0
while kernalSize % 2 == 0:
kernalSize = np.random.randint(5, 15)
constantValue = np.random.randint(0, 5, [1,]).item() # only actaully needed for constant boundary condition
weights = np.random.randint(-2, 3, [kernalSize, kernalSize]).astype(np.double)
cWeights = NumCpp.NdArray(kernalSize)
cWeights.setArray(weights)
dataOutC = NumCpp.convolve(cArray, kernalSize, cWeights, modes[mode], constantValue).getNumpyArray()
dataOutPy = filters.convolve(data, weights, mode=mode, cval=constantValue)
if np.array_equal(dataOutC, dataOutPy):
print(colored('\tPASS', 'green'))
else:
print(colored('\tFAIL', 'red'))
print(colored(f'Testing gaussianFilter: mode = {mode}', 'cyan'))
shape = np.random.randint(1000, 2000, [2,]).tolist()
cShape = NumCpp.Shape(shape[0], shape[1])
cArray = NumCpp.NdArray(cShape)
data = np.random.randint(100, 1000, shape).astype(np.double)
cArray.setArray(data)
constantValue = np.random.randint(0, 5, [1,]).item() # only actaully needed for constant boundary condition
sigma = np.random.rand(1).item() * 2
dataOutC = NumCpp.gaussianFilter(cArray, sigma, modes[mode], constantValue).getNumpyArray()
dataOutPy = filters.gaussian_filter(data, sigma, mode=mode, cval=constantValue)
if np.array_equal(np.round(dataOutC, 2), np.round(dataOutPy, 2)):
print(colored('\tPASS', 'green'))
else:
print(colored('\tFAIL', 'red'))
print(colored(f'Testing maximumFilter: mode = {mode}', 'cyan'))
shape = np.random.randint(1000, 2000, [2,]).tolist()
cShape = NumCpp.Shape(shape[0], shape[1])
cArray = NumCpp.NdArray(cShape)
data = np.random.randint(100, 1000, shape)
cArray.setArray(data)
kernalSize = 0
while kernalSize % 2 == 0:
kernalSize = np.random.randint(5, 15)
constantValue = np.random.randint(0, 5, [1,]).item() # only actaully needed for constant boundary condition
dataOutC = NumCpp.maximumFilter(cArray, kernalSize, modes[mode], constantValue).getNumpyArray()
dataOutPy = filters.maximum_filter(data, size=kernalSize, mode=mode, cval=constantValue)
if np.array_equal(dataOutC, dataOutPy):
print(colored('\tPASS', 'green'))
else:
print(colored('\tFAIL', 'red'))
print(colored(f'Testing medianFilter: mode = {mode}', 'cyan'))
shape = np.random.randint(1000, 2000, [2,]).tolist()
cShape = NumCpp.Shape(shape[0], shape[1])
cArray = NumCpp.NdArray(cShape)
data = np.random.randint(100, 1000, shape)
cArray.setArray(data)
kernalSize = 0
while kernalSize % 2 == 0:
kernalSize = np.random.randint(5, 15)
constantValue = np.random.randint(0, 5, [1,]).item() # only actaully needed for constant boundary condition
dataOutC = NumCpp.medianFilter(cArray, kernalSize, modes[mode], constantValue).getNumpyArray()
dataOutPy = filters.median_filter(data, size=kernalSize, mode=mode, cval=constantValue)
if np.array_equal(dataOutC, dataOutPy):
print(colored('\tPASS', 'green'))
else:
print(colored('\tFAIL', 'red'))
print(colored(f'Testing minimumFilter: mode = {mode}', 'cyan'))
shape = np.random.randint(1000, 2000, [2,]).tolist()
cShape = NumCpp.Shape(shape[0], shape[1])
cArray = NumCpp.NdArray(cShape)
data = np.random.randint(100, 1000, shape)
cArray.setArray(data)
kernalSize = 0
while kernalSize % 2 == 0:
kernalSize = np.random.randint(5, 15)
constantValue = np.random.randint(0, 5, [1,]).item() # only actaully needed for constant boundary condition
dataOutC = NumCpp.minimumFilter(cArray, kernalSize, modes[mode], constantValue).getNumpyArray()
dataOutPy = filters.minimum_filter(data, size=kernalSize, mode=mode, cval=constantValue)
if np.array_equal(dataOutC, dataOutPy):
print(colored('\tPASS', 'green'))
else:
print(colored('\tFAIL', 'red'))
print(colored(f'Testing percentileFilter: mode = {mode}', 'cyan'))
shape = np.random.randint(1000, 2000, [2,]).tolist()
cShape = NumCpp.Shape(shape[0], shape[1])
cArray = NumCpp.NdArray(cShape)
data = np.random.randint(100, 1000, shape)
cArray.setArray(data)
kernalSize = 0
while kernalSize % 2 == 0:
kernalSize = np.random.randint(5, 15)
percentile = np.random.randint(0, 101, [1,]).item()
constantValue = np.random.randint(0, 5, [1,]).item() # only actaully needed for constant boundary condition
dataOutC = NumCpp.percentileFilter(cArray, kernalSize, percentile, modes[mode], constantValue).getNumpyArray()
dataOutPy = filters.percentile_filter(data, percentile, size=kernalSize, mode=mode, cval=constantValue)
if np.array_equal(dataOutC, dataOutPy):
print(colored('\tPASS', 'green'))
else:
print(colored('\tFAIL', 'red'))
print(colored(f'Testing rankFilter: mode = {mode}', 'cyan'))
shape = np.random.randint(1000, 2000, [2,]).tolist()
cShape = NumCpp.Shape(shape[0], shape[1])
cArray = NumCpp.NdArray(cShape)
data = np.random.randint(100, 1000, shape)
cArray.setArray(data)
kernalSize = 0
while kernalSize % 2 == 0:
kernalSize = np.random.randint(5, 15)
rank = np.random.randint(0, kernalSize**2 - 1, [1,]).item()
constantValue = np.random.randint(0, 5, [1,]).item() # only actaully needed for constant boundary condition
dataOutC = NumCpp.rankFilter(cArray, kernalSize, rank, modes[mode], constantValue).getNumpyArray()
dataOutPy = filters.rank_filter(data, rank, size=kernalSize, mode=mode, cval=constantValue)
if np.array_equal(dataOutC, dataOutPy):
print(colored('\tPASS', 'green'))
else:
print(colored('\tFAIL', 'red'))
print(colored(f'Testing uniformFilter: mode = {mode}', 'cyan'))
shape = np.random.randint(1000, 2000, [2,]).tolist()
cShape = NumCpp.Shape(shape[0], shape[1])
cArray = NumCpp.NdArray(cShape)
data = np.random.randint(100, 1000, shape).astype(np.double)
cArray.setArray(data)
kernalSize = 0
while kernalSize % 2 == 0:
kernalSize = np.random.randint(5, 15)
constantValue = np.random.randint(0, 5, [1,]).item() # only actaully needed for constant boundary condition
dataOutC = NumCpp.uniformFilter(cArray, kernalSize, modes[mode], constantValue).getNumpyArray()
dataOutPy = filters.uniform_filter(data, size=kernalSize, mode=mode, cval=constantValue)
if np.array_equal(np.round(dataOutC, 8), np.round(dataOutPy, 8)):
print(colored('\tPASS', 'green'))
else:
print(colored('\tFAIL', 'red'))
def morphOpen(V, footprint):
''' computes the morphological opening of V (correlation map) with circular footprint'''
vrem = filters.minimum_filter(V, footprint=footprint)
vrem = -filters.minimum_filter(-vrem, footprint=footprint)
return vrem
def bsub(x, diameter=20):
from scipy.ndimage.filters import minimum_filter
return x - minimum_filter(x, size=diameter)
def grid_to_graph(self, scr, grid):
import scipy.ndimage as ndimage
import scipy.ndimage.filters as filters
data = grid
neighborhood_size = 7
#threshold_max = 0.5
threshold_diff = 0.1
threshold_score = 0.2
data_max = filters.maximum_filter(data, neighborhood_size)
maxima = (data == data_max)
data_min = filters.minimum_filter(data, neighborhood_size)
#diff = ((data_max - data_min) > threshold_diff)
#maxima[diff == 0] = 0
maxima[data_max < 0.2] = 0
labeled, num_objects = ndimage.label(maxima)
slices = ndimage.find_objects(labeled)
xx, yy, score = [], [], []
for dy, dx in slices:
x_center = (dx.start + dx.stop - 1) / 2
y_center = (dy.start + dy.stop - 1) / 2
s = np.average(data[dy.start:dy.stop + 1, dx.start:dx.stop + 1])
if s > threshold_score:
xx.append(x_center / grid.shape[1])
yy.append(y_center / grid.shape[0])
score.append(s)
graph = list(zip(xx, yy, score))
path = tsalesman(graph)
paths_final = [path]
scr_viz = np.copy(scr)
h, w = scr.shape[0:2]
#hup, wup = h/grid.shape[0], w/grid.shape[1]
hup, wup = h, w
for i, (x, y, s) in enumerate(zip(xx, yy, score)):
size = 3 * int(s * 10)
size = size if size % 2 != 0 else size - 1
scr_viz = util.draw_point(scr_viz,
y=int(y * hup),
x=int(x * wup),
size=size,
color=[0, 255, 0])
scr_viz = util.draw_text(scr_viz,
y=int(y * hup),
x=int(x * wup),
text=str(i),
color=[0, 255, 0])
colors = [[255, 0, 0], [0, 255, 0], [0, 0, 255], [255, 255, 255],
[0, 0, 0]]
for path, col in zip(paths_final, colors):
last_x = None
last_y = None
for (x, y, s) in path:
if last_x is not None:
scr_viz = util.draw_line(scr_viz,
y1=int(last_y * hup),
x1=int(last_x * wup),
y2=int(y * hup),
x2=int(x * wup),
color=col,
thickness=2)
last_x = x
last_y = y
misc.imshow(scr_viz)
"""
import matplotlib.pyplot as plt
from scipy import misc
from skimage import img_as_float
from scipy.ndimage import filters
def loadImg(arg):
return misc.imread(arg)
img_1 = loadImg(sys.argv[1])
saida_1 = sys.argv[2] + '.tif'
saida_2 = sys.argv[3] + '.tif'
mask_size = int(sys.argv[4])
# Converte os pixels em float, com valores entre 0 e 1
img_1 = img_as_float(img_1)
# Aplica o filtro de mínimo
img_saida_min = filters.minimum_filter(img_1,
size=mask_size,
mode='constant',
cval=0)
# Aplica o filtro de máximo
img_saida_max = filters.maximum_filter(img_1, size=mask_size, mode='constant')
# Faz o salvamento das imagens de saída após o processamento
misc.imsave(saida_1, img_saida_min)
misc.imsave(saida_2, img_saida_max)
def local_minima(data):
peaks = data == minimum_filter(data, size=(3, ) * data.ndim)
return peaks
def preprocess_image(raw_image,
threshold=0.0025,
sigma=1.0,
minf_size=1,
rank_size=1,
sobel=True):
"""
Applies an edge filter followed by a noise reduction filter. Very good
at locating powder rings and filtering everything else out.
Parameters
----------
raw_image : ndarray
An image to find the edges of
Returns
-------
binary_image : ndarray, np.bool
A binary image, with "1" where there are powder rings/strong edges
"""
# flatten the image into a two-D array and later re-process it
# convert to cheetah-like format
if raw_image.shape == (4, 16, 185, 194):
non_flat_img = True
image = np.zeros((1480, 1552), dtype=np.float) # flat image
for i in range(8):
for j in range(4):
x_start = 185 * i
x_stop = 185 * (i + 1)
y_start = 388 * j
y_stop = 388 * (j + 1)
two_by_one = np.hstack(
(raw_image[j, i * 2, :, :],
raw_image[j, i * 2 + 1, :, :])).astype(np.float)
image[x_start:x_stop, y_start:y_stop] = two_by_one
elif len(raw_image.shape) == 2:
non_flat_img = False
image = raw_image.astype(np.float)
else:
raise ValueError(
'`raw_image` should be 2d or shape-(4,16,185,194), got'
': %s' % str(raw_image.shape))
# apply rank filter & gaussian filter
if rank_size > 2:
image = filters.rank_filter(image, -1, size=rank_size)
if sigma > 0.1:
image = filters.gaussian_filter(image, sigma=sigma)
image -= image.min()
assert image.min() == 0
assert image.max() > 0
# threshold
image = (image > (image.max() * threshold))
if minf_size > 2:
image = filters.minimum_filter(image, size=minf_size)
if sobel:
image = np.abs(filters.sobel(image, 0)) + np.abs(
filters.sobel(image, 1))
if non_flat_img:
image = read.enforce_raw_img_shape(image.astype(np.bool))
else:
image = image.astype(np.bool)
return image
