def major_axis(x, y, ndist=10, mask=1):
dist = scipy.array([scipy.hypot(x-i,y-j) \
for i, j in itertools.izip(x, y)])
shape = dist.shape
imax = scipy.zeros(ndist, dtype=int)
jmax = scipy.zeros(ndist, dtype=int)
# dummy run
for i in xrange((mask - 1) * ndist):
ii, jj = scipy.unravel_index(scipy.argmax(dist), shape)
dist[ii] = scipy.zeros(shape[0])
dist[jj] = scipy.zeros(shape[0])
dist[:, ii] = scipy.zeros(shape[1])
dist[:, jj] = scipy.zeros(shape[1])
for i in xrange(ndist):
imax[i], jmax[i] = scipy.unravel_index(scipy.argmax(dist), shape)
dist[imax[i]] = scipy.zeros(shape[0])
dist[jmax[i]] = scipy.zeros(shape[0])
dist[:, imax[i]] = scipy.zeros(shape[1])
dist[:, jmax[i]] = scipy.zeros(shape[1])
#print imax, jmax
slopes = [(y[i]-y[j])/(x[i]-x[j]) \
for i, j in itertools.izip(imax, jmax)]
zeros = [y[i] - m * x[i] for i, m in itertools.izip(imax, slopes)]
m = scipy.median(slopes)
n = scipy.median(zeros)
return imax, jmax, m, n
def patch_holes(data_map):
r"""
Fills in any areas with a non finite value by taking a linear average of
the nearest non-zero values along each axis
"""
#
# getting coordinates of all valid data points
data_vector = sp.ravel(data_map)
inds = sp.where(sp.isfinite(data_vector))[0]
points = sp.unravel_index(inds, data_map.shape)
values = data_vector[inds]
#
# linearly interpolating data to fill gaps
xi = sp.where(~sp.isfinite(data_vector))[0]
msg = '\tattempting to fill %d values with a linear interpolation'
logger.debug(msg, xi.size)
xi = sp.unravel_index(xi, data_map.shape)
intrp = griddata(points, values, xi, fill_value=sp.nan, method='linear')
data_map[xi[0], xi[1]] = intrp
#
# performing a nearest interpolation any remaining regions
data_vector = sp.ravel(data_map)
xi = sp.where(~sp.isfinite(data_vector))[0]
msg = '\tfilling %d remaining values with a nearest interpolation'
logger.debug(msg, xi.size)
xi = sp.unravel_index(xi, data_map.shape)
intrp = griddata(points, values, xi, fill_value=0, method='nearest')
data_map[xi[0], xi[1]] = intrp
#
return data_map
def generate_index_map(nonzero_locs, shape):
r"""
Determines the i,j,k indicies of the flattened array
"""
#
logger.info('creating index map of non-zero values...')
x_c = sp.unravel_index(nonzero_locs, shape)[0].astype(sp.int16)
y_c = sp.unravel_index(nonzero_locs, shape)[1].astype(sp.int16)
z_c = sp.unravel_index(nonzero_locs, shape)[2].astype(sp.int16)
index_map = sp.stack((x_c, y_c, z_c), axis=1)
#
return index_map
def generate_index_map(nonzero_locs, shape):
r"""
Determines the i,j,k indicies of the flattened array
"""
#
logger.info('creating index map of non-zero values...')
x_c = sp.unravel_index(nonzero_locs, shape)[0].astype(sp.int16)
y_c = sp.unravel_index(nonzero_locs, shape)[1].astype(sp.int16)
z_c = sp.unravel_index(nonzero_locs, shape)[2].astype(sp.int16)
index_map = sp.stack((x_c, y_c, z_c), axis=1)
#
return index_map
def _getIntelligentInitialValues(self):
xs, ys, zs = self._get_subSpaceArrays(
) #returns the full arrays if subspace not used
logger.debug("attempting to set initial values intellgently")
if xs is None or ys is None or zs is None:
logger.debug("couldn't find all necessary data")
return False
AParab = scipy.amax(zs)
B = scipy.average(zs[0:len(ys) / 10.0, 0:len(xs) / 10.0])
y0Index, x0Index = scipy.unravel_index(zs.argmax(), zs.shape)
logger.debug("index of max z is %s, %s " % (y0Index, x0Index))
x0 = xs[x0Index]
y0 = ys[y0Index]
#WHEN WE IMPLEMENT ONLY FITTING A SUBSET THIS WILL HAVE TO CHANGE A BIT
x0HalfIndex = (scipy.absolute(zs[y0Index] - AParab / 2.0)).argmin()
y0HalfIndex = (scipy.absolute(zs[:, x0Index] - AParab / 2.0)).argmin()
logger.debug("index of half max z is %s, %s " %
(y0HalfIndex, x0HalfIndex))
x0Half = xs[x0HalfIndex]
y0Half = ys[y0HalfIndex]
deltaXHalf = abs(x0 - x0Half)
deltaYHalf = abs(y0 - y0Half)
wParabX = 1.644 * deltaXHalf
wParabY = 1.644 * deltaYHalf
p0 = [x0, y0, AParab, wParabX, wParabY, B]
logger.debug("initial values guess = %s" % p0)
return p0
def save_image_stack(nonzero_locs, img_dims, path, overwrite=False):
r"""
Saves a text image stack in a directory to be read by ImageJ
"""
#
logger.info('saving image data as .bmp stack...')
#
img_data = 255*sp.ones(img_dims, dtype=sp.uint8)
x_coords, y_coords, z_coords = sp.unravel_index(nonzero_locs, img_dims)
img_data[x_coords, y_coords, z_coords] = 0
#
# creating any needed directories
try:
os.makedirs(path)
except FileExistsError:
if not overwrite:
msg = 'Image Stack destination already exists, '
msg += ' use "-f" option to overwrite'
raise FileExistsError(msg)
else:
files = glob(os.path.join(path, '*'))
for f in files:
os.remove(f)
#
# saving the image frames
for frame in range(img_data.shape[2]):
name = os.path.join(path, 'image-frame-{}.bmp'.format(frame))
frame = Image.fromarray(img_data[:, :, frame].transpose())
frame.save(name)
def testKernelCoeffs(self):
for scale in [0.35, 0.5, 0.75, 1]:
for dim in [0,1,2,3,4]:
dgK = mango.image.discrete_gaussian_kernel(sigma=scale, dim=dim, errtol=0.001)
self.assertAlmostEqual(1.0, sp.sum(dgK), 8)
mxElem = sp.argmax(dgK)
self.assertTrue(sp.all(sp.array(dgK.shape)//2 == sp.unravel_index(mxElem, dgK.shape)))
def get_alignment(str_1, str_2, matrix, remove_path=False):
max_row, max_column = scipy.unravel_index(matrix.argmax(), matrix.shape)
path = _get_back_path(matrix, max_row, max_column)
aligment_1 = ''
aligment_2 = ''
for point_index in range(1, len(path)):
row_0, column_0 = path[point_index]
row_1, column_1 = path[point_index - 1]
if row_0 != row_1 and column_0 == column_1:
aligment_1 += '-'
aligment_2 += str_2[row_0]
elif row_0 == row_1 and column_0 != column_1:
aligment_1 += str_1[column_0]
aligment_2 += '-'
else:
aligment_1 += str_1[column_0]
aligment_2 += str_2[row_0]
if remove_path:
x0, y0 = path[0]
x1, y1 = path[-2]
for i in range(x1, x0 + 1):
matrix[i, y1:y0 + 1] = 0
matrix.eliminate_zeros()
return aligment_1[::-1], aligment_2[::-1], path[0], len(path)
def _getIntelligentInitialValues(self):
xs,ys,zs = self._get_subSpaceArrays()#returns the full arrays if subspace not used
logger.debug("attempting to set initial values intellgently")
if xs is None or ys is None or zs is None:
logger.debug("couldn't find all necessary data")
return False
A0 = scipy.amax(zs)
B0 = scipy.average(zs[0:len(ys)//10,0:len(xs)//10])
y0Index, x0Index = scipy.unravel_index(zs.argmax(), zs.shape)
logger.debug("index of max z is %s, %s " % (y0Index, x0Index))
x0 = xs[x0Index]
y0 = ys[y0Index]
#WHEN WE IMPLEMENT ONLY FITTING A SUBSET THIS WILL HAVE TO CHANGE A BIT
x0HalfIndex = (scipy.absolute(zs[y0Index]-A0/2.0)).argmin()
y0HalfIndex = (scipy.absolute(zs[:,x0Index]-A0/2.0)).argmin()
logger.debug("index of half max z is %s, %s " % (y0HalfIndex, x0HalfIndex))
x0Half = xs[x0HalfIndex]
y0Half = ys[y0HalfIndex]
FWHMX0 = 2.0*abs(x0-x0Half)
FWHMY0 = 2.0*abs(y0-y0Half)
sigmaX0 = FWHMX0/2.355
sigmaY0 = FWHMY0/2.355
logger.debug("x0,y0 %s, %s " % (x0, y0))
return[A0,x0,sigmaX0, y0,sigmaY0,B0]
def process_image(img_data, num_clusters, **kwargs):
r"""
Processes a tiff stack on retaining voxels based on node connectivity.
The clusters are sorted by size and the large N are retained.
"""
#
img_dims = img_data.shape
nonzero_locs = img_data.get_fracture_voxels()
index_map = generate_index_map(nonzero_locs, img_dims)
#
# determing connectivity and removing clusters
conns = generate_node_connectivity_array(index_map, img_data)
del img_data, index_map
nonzero_locs = remove_isolated_clusters(conns, nonzero_locs, num_clusters,
**kwargs)
# reconstructing 3-D array
logger.info('reconstructing processed data back into 3-D array')
#
img_data = sp.zeros(img_dims, dtype=bool)
x_coords, y_coords, z_coords = sp.unravel_index(nonzero_locs, img_dims)
#
del nonzero_locs
img_data[x_coords, y_coords, z_coords] = True
del x_coords, y_coords, z_coords
#
return img_data.view(FractureImageStack)
def fitCorrGaussian(corr, center_region):
frame_dim_x, frame_dim_y = corr.shape
center_guess = frame_dim_x / 2.0
height_guess = corr.max()
noise_guess = corr[1:frame_dim_x / 10, 1:frame_dim_y / 10].mean()
guess_params = [
noise_guess, height_guess - noise_guess, center_region, center_region,
5., 5.
] #, 0.]
max_height = height_guess * 1.1
max_width = center_region * 1.1
max_params = [0, max_height, 0, 0, max_width, max_width] #,360]
use_max = [False, True, False, False, True, True] #, True]
corr_region = corr[center_guess - center_region:center_guess +
center_region, center_guess -
center_region:center_guess + center_region]
guess_params[2:4] = scipy.unravel_index(corr_region.argmax(),
corr_region.shape)
fits = gaussfitter.gaussfit(corr_region,
params=guess_params,
maxpars=max_params,
limitedmax=use_max,
rotate=0)
central_val = corr[center_guess - center_region + fits[2] -
1:center_guess - center_region + fits[2] + 2,
center_guess - center_region + fits[3] -
1:center_guess - center_region + fits[3] + 2].mean()
return fits, central_val
def _getIntelligentInitialValues(self):
xs, ys, zs = self._get_subSpaceArrays(
) #returns the full arrays if subspace not used
logger.debug("attempting to set initial values intellgently")
if xs is None or ys is None or zs is None:
logger.debug("couldn't find all necessary data")
return False
A = scipy.amax(zs)
B = scipy.average(zs[0:len(ys) // 10, 0:len(xs) // 10])
y0Index, x0Index = scipy.unravel_index(zs.argmax(), zs.shape)
logger.debug("index of max z is %s, %s " % (y0Index, x0Index))
x0 = xs[x0Index]
y0 = ys[y0Index]
#WHEN WE IMPLEMENT ONLY FITTING A SUBSET THIS WILL HAVE TO CHANGE A BIT
x0HalfIndex = (scipy.absolute(zs[y0Index] - A / 2.0)).argmin()
y0HalfIndex = (scipy.absolute(zs[:, x0Index] - A / 2.0)).argmin()
logger.debug("index of half max z is %s, %s " %
(y0HalfIndex, x0HalfIndex))
x0Half = xs[x0HalfIndex]
y0Half = ys[y0HalfIndex]
FWHMX0 = 2.0 * abs(x0 - x0Half)
FWHMY0 = 2.0 * abs(y0 - y0Half)
#make gaussian wings larger for thermal part (*4)
sigmax = 4 * FWHMX0 / 2.355
sigmay = 4 * FWHMY0 / 2.355
wParabX = FWHMX0 / 2.0
wParabY = FWHMY0 / 2.0
AGauss = 0.1 * A
AParab = 0.9 * A
p0 = [x0, y0, AGauss, sigmax, sigmay, AParab, wParabX, wParabY, B]
logger.debug("initial values guess = %s" % p0)
return p0
def move_discharge(ji, nwet):
sj, ej = max(ji[0] - 2, 0), min(ji[0] + 3, sh[0])
si, ei = max(ji[1] - 2, 0), min(ji[1] + 3, sh[1])
tmp = nwet[sj:ej, si:ei]
if tmp.max() >= 6.0:
j, i = sp.unravel_index(tmp.argmax(), tmp.shape)
ji[0], ji[1] = sj + j, si + i
return ji
def __init__(self, template, spacing=[1, 1, 1], **kwargs):
template = sp.atleast_3d(template)
super().__init__(shape=template.shape, **kwargs)
coords = sp.unravel_index(range(template.size), template.shape)
self['pore.template_coords'] = sp.vstack(coords).T
self['pore.template_indices'] = self.Ps
self['pore.drop'] = template.flatten() == 0
topotools.trim(network=self, pores=self.pores('drop'))
del self['pore.drop']
def contour_levels(cluster, x, y, kde):
'''This is the central function. It generates the countour plots around the
cluster members. The points of these contour levels are used to trace the
ZAMS for each cluster.
'''
fine_tune = False
if cluster in fine_tune_list[0]:
fine_tune = True
indx = fine_tune_list[0].index(cluster)
manual_levels = np.arange(fine_tune_list[1][indx][0],
fine_tune_list[1][indx][1],\
fine_tune_list[1][indx][2])
x_min, x_max = fine_tune_list[2][indx][0], fine_tune_list[2][indx][1]
y_min, y_max = fine_tune_list[2][indx][2], fine_tune_list[2][indx][3]
lev_min, lev_num = fine_tune_list[3][indx]
else:
x_min, x_max = -10., 10.
y_min, y_max = -10., 10.
lev_min, lev_num = 0.1, 1
# This list will hold the points obtained through the contour curves,
# the first sublist are the x coordinates of the points and the second
# the y coordinates.
sequence = [[], []]
# Store contour levels.
if fine_tune == True:
CS = plt.contour(x, y, kde, manual_levels)
else:
CS = plt.contour(x, y, kde)
plt.clabel(CS, fontsize=9, inline=1)
# Store level values for contour levels.
levels = CS.levels
# print levels
for i, clc in enumerate(CS.collections):
for j, pth in enumerate(clc.get_paths()):
cts = pth.vertices
d = sp.spatial.distance.cdist(cts, cts)
x_c, y_c = cts[list(sp.unravel_index(sp.argmax(d), d.shape))].T
# Only store points that belong to contour PDF values larger
# tnah lev_min and that belong to the uper curves, ie: do not
# use those with index <= lev_num.
if levels[i] > lev_min and i > lev_num:
# Only store points within these limits.
if x_min <= x_c[0] <= x_max and y_min <= y_c[0] <= y_max:
sequence[0].append(round(x_c[0], 4))
sequence[1].append(round(y_c[0], 4))
if x_min <= x_c[1] <= x_max and y_min <= y_c[1] <= y_max:
sequence[0].append(round(x_c[1], 4))
sequence[1].append(round(y_c[1], 4))
return sequence
def testKernelCoeffs(self):
for scale in [0.35, 0.5, 0.75, 1]:
for dim in [0, 1, 2, 3, 4]:
dgK = mango.image.discrete_gaussian_kernel(sigma=scale,
dim=dim,
errtol=0.001)
self.assertAlmostEqual(1.0, sp.sum(dgK), 8)
mxElem = sp.argmax(dgK)
self.assertTrue(
sp.all(
sp.array(dgK.shape) //
2 == sp.unravel_index(mxElem, dgK.shape)))
def _generate_pores(self):
r"""
Generate the pores (coordinates, numbering and types)
"""
Nx = self._Nx
Ny = self._Ny
Nz = self._Nz
Lc = self._Lc
Np = Nx*Ny*Nz
ind = sp.arange(0,Np)
self['pore.all'] = sp.ones_like(ind,dtype=bool)
pore_coords = Lc/2+Lc*sp.array(sp.unravel_index(ind, dims=(Nx, Ny, Nz), order='F'),dtype=sp.float64).T
self['pore.coords'] = pore_coords
def _generate_pores(self):
r"""
Generate the pores (coordinates, numbering and types)
"""
Nx = self._Nx
Ny = self._Ny
Nz = self._Nz
Lc = self._Lc
Np = Nx*Ny*Nz
ind = sp.arange(0,Np)
self.set_pore_data(prop='numbering',data=ind)
self.set_pore_info(label='all',locations=sp.ones_like(ind))
pore_coords = Lc/2+Lc*sp.array(sp.unravel_index(ind, dims=(Nx, Ny, Nz), order='F'),dtype=sp.float64).T
self.set_pore_data(prop='coords',data=pore_coords)
def _generate_pores(self):
r"""
Generate the pores (coordinates, numbering and types)
"""
Nx = self._Nx
Ny = self._Ny
Nz = self._Nz
Lc = self._Lc
Np = Nx*Ny*Nz
ind = sp.arange(0, Np)
self['pore.all'] = sp.ones_like(ind, dtype=bool)
unraveled_index = sp.unravel_index(ind, dims=(Nx, Ny, Nz), order='F')
pore_coords = Lc/2+Lc*sp.array(unraveled_index, dtype=sp.float64).T
self['pore.coords'] = pore_coords
def patch_holes(data_map):
r"""
Fills in any areas with a value of -1 by taking a linear average of
the nearest non-zero values along each axis
"""
#
logger.info('interpolating missing data due to zero aperture zones')
#
# getting coordinates of all valid data points
data_vector = sp.ravel(data_map)
inds = sp.where(data_vector >= 0)[0]
points = sp.unravel_index(inds, data_map.shape)
values = data_vector[inds]
#
# setting up to interpolate over all data coordinates
intrp = sp.arange(data_map.size, dtype=int)
intrp = sp.unravel_index(intrp, data_map.shape)
#
# interpolating data to fill gaps and creating the new data map
data_vector = griddata(points, values, intrp, method='nearest')
data_map = sp.reshape(data_vector, data_map.shape)
#
return data_map
def get_points_of_interest(arr):
"""
Expects a binary object in the array.
FInds the two contour points that are the farthest apart, then determines which of
them is the base point of the RV and returns this first and the other as second
return value.
"""
#########
# 1: Find points in objects contour with the largest distance between them.
#########
# extract only outer contour
arr = arr - binary_erosion(arr)
# extract all positions of the objects contour
points = scipy.asarray(arr.nonzero()).T
# compute pairwise distances
distances = squareform(pdist(points, 'euclidean'))
# get positon of largest distance
position = scipy.unravel_index(scipy.argmax(distances),
(len(points), len(points)))
# recompute between which points the largest distance was found
first = points[position[0]]
second = points[position[1]]
#logger.debug('Longest distance found between {} and {}.'.format(first, second))
#########
# 2: Determine which of these is the base point
#########
# go along perpendicular lines, find intersections with contours and keep longest only
intersection = False
longest_length = 0
longest_line = line_from_points(first, second)
segment_points = split_line_to_sections(5, first, second)
for sp in segment_points:
sline = perpendicular_line(longest_line, sp)
nearest = find_nearest(sline, points, 10)
if distance(nearest[0], nearest[1]) > longest_length:
longest_length = distance(nearest[0], nearest[1])
intersection = sp
# determine which of the first two points are nearest to the longest line and return them
if distance(intersection, first) < distance(intersection, second):
return (first, second)
else:
return (second, first)
def canonical_permutation( x ):
"""Rearrange the rows and columns of a matrix so that the maximum
element is at (0,0), the elements of the first row are in sorted
order and the first columns is in sorted order of the rows.
Returns the permutation required to make it"""
# Find the smallest element.
idx = x.argmin()
r, c = sc.unravel_index( idx, x.shape )
# Apply the sorts that bring x to the top
colp = x[r, :].argsort()
rowp = x[:, c].argsort()
perm = (rowp, colp)
return perm
def compare(self, chunk, tiles):
assert (chunk.shape[0] == self.compareChunkSize)
chunk = scipy.int_(chunk)
S = chunk.shape[0]
# distance will contain the distance for each tile, for each position
distances = scipy.zeros((self.shiftDim[0], self.shiftDim[1], tiles.shape[0]))
for i in range(self.shiftDim[0]):
for j in range(self.shiftDim[1]):
distances[i,j,:] = self.distance(chunk, tiles[:,i:i+S,j:j+S,:])
combinedIndex = scipy.unravel_index(scipy.argmin(distances), distances.shape)
idx = combinedIndex[-1]
pos = self.translatePos(combinedIndex[:-1])
dist = distances[combinedIndex]
return (idx, pos, dist)
def get_fracture_voxels(self, coordinates=False):
r"""
Returns a vector or vectors containing all fracture voxels in
the image stack.
Parameters:
coordinates (boolean) - If False then a single vector is returned
with flattened indicies. If True then three vectors are returned
which are the X, Y and Z coordinates of each voxel.
"""
nonzero_locs = sp.where(sp.ravel(self))[0].astype(self.index_int_type)
logger.debug('{} non-zero voxels in image'.format(nonzero_locs.size))
if coordinates:
return sp.unravel_index(nonzero_locs, self.shape)
else:
return nonzero_locs
def Locus(image_data):
"""Finds the index of the brightest galaxy once filters are applied to
input data at its stage of filtration
INPUTS
------
data = 2D array containing the number of counts in each pixel
OUTPUTS
-------
[0]: data[index] = number of counts in the brightest point in the image
[1]: index = index of the brightest point in the image"""
index = sp.unravel_index(sp.argmax(image_data), image_data.shape)
return [data[index], index]
def get_points_of_interest(arr):
"""
Expects a binary object in the array.
FInds the two contour points that are the farthest apart, then determines which of
them is the base point of the RV and returns this first and the other as second
return value.
"""
#########
# 1: Find points in objects contour with the largest distance between them.
#########
# extract only outer contour
arr = arr - binary_erosion(arr)
# extract all positions of the objects contour
points = scipy.asarray(arr.nonzero()).T
# compute pairwise distances
distances = squareform(pdist(points, 'euclidean'))
# get positon of largest distance
position = scipy.unravel_index(scipy.argmax(distances), (len(points), len(points)))
# recompute between which points the largest distance was found
first = points[position[0]]
second = points[position[1]]
#logger.debug('Longest distance found between {} and {}.'.format(first, second))
#########
# 2: Determine which of these is the base point
#########
# go along perpendicular lines, find intersections with contours and keep longest only
intersection = False
longest_length = 0
longest_line = line_from_points(first, second)
segment_points = split_line_to_sections(5, first, second)
for sp in segment_points:
sline = perpendicular_line(longest_line, sp)
nearest = find_nearest(sline, points, 10)
if distance(nearest[0], nearest[1]) > longest_length:
longest_length = distance(nearest[0], nearest[1])
intersection = sp
# determine which of the first two points are nearest to the longest line and return them
if distance(intersection, first) < distance(intersection, second):
return (first, second)
else:
return (second, first)
def makefitsurfv2(xarrs,y_acf,sensdict,simparams,yerr=None):
youtsize = [len(x) for x in xarrs]
ytprod = 1
for xl in youtsize:
ytprod = ytprod*xl
yout = sp.zeros(youtsize,dtype=sp.float128)
for iparam in range(ytprod):
curind = sp.unravel_index(iparam,youtsize)
curx = xarrs[curind[0]][curind[1]]
yout[curind[:]] = sp.power(sp.absolute(ISRSfitfunction(curx,y_acf,sensdict,simparams,yerr)),2).sum()
return(yout)
def makefitsurfv2(xarrs,y_acf,sensdict,simparams,yerr=None):
youtsize = [len(x) for x in xarrs]
ytprod = 1
for xl in youtsize:
ytprod = ytprod*xl
yout = sp.zeros(youtsize,dtype=sp.float128)
for iparam in range(ytprod):
curind = sp.unravel_index(iparam,youtsize)
curx = xarrs[curind[0]][curind[1]]
yout[curind[:]] = sp.power(sp.absolute(ISRSfitfunction(curx,y_acf,sensdict,simparams,yerr)),2).sum()
return(yout)
def cov_from_segments(gene, seg_counts, edge_counts, edge_idx, ax, sample_idx=None,
log=False, cmap_seg=None, cmap_edg=None, xlim=None, grid=False,
order='C'):
"""This function takes a gene and its corresponding segment and edge counts to
produce a coverage overview plot."""
if sample_idx is None:
sample_idx = sp.arange(seg_counts.shape[1])
norm = plt.Normalize(0, sample_idx.shape[0])
if cmap_seg is None:
cmap_seg = plt.get_cmap('jet')
if cmap_edg is None:
cmap_edg = plt.get_cmap('jet')
### iterate over samples
for ii,i in enumerate(sample_idx):
### collect count information and add segment patches
for j in range(gene.segmentgraph.segments.shape[1]):
s = gene.segmentgraph.segments[:, j]
if log:
counts = sp.log10(seg_counts[j, i] + 1)
else:
counts = seg_counts[j, i]
#ax.add_patch(patches.Rectangle((s[0], 0), s[1] - s[0], counts, fill=cmap_seg(norm(ii)),
# edgecolor='none', alpha=0.5))
ax.plot(s, [counts, counts], '-', color=cmap_seg(norm(ii)), linewidth=2)
for j in range(edge_idx.shape[0]):
[s, t] = sp.unravel_index(edge_idx[j], gene.segmentgraph.seg_edges.shape, order=order)
if log:
counts = sp.log10(edge_counts[j, i] + 1)
else:
counts = edge_counts[j, i]
add_intron_patch2(ax, gene.segmentgraph.segments[1, s], gene.segmentgraph.segments[0, t], counts, color=cmap_edg(norm(ii)))
if xlim is not None:
ax.set_xlim(xlim)
### draw grid
if grid:
ax.grid(b=True, which='major', linestyle='--', linewidth=0.2, color='#222222')
ax.xaxis.grid(False)
ax.set_ylim([0, ax.get_ylim()[1]])
def generate_offset_map(nonzero_locs, shape):
r"""
Creates a map storing the index of the lowest y-axis pixel in an
X-Z column.
"""
#
logger.info('creating initial offset map')
#
x_coords, y_coords, z_coords = sp.unravel_index(nonzero_locs, shape)
data = sp.ones(shape, dtype=sp.uint16)*sp.iinfo(sp.int16).max
data[x_coords, y_coords, z_coords] = y_coords
#
offset_map = sp.zeros((shape[0], shape[2]), dtype=sp.int16)
for z_index in range(shape[2]):
offset_map[:, z_index] = sp.amin(data[:, :, z_index], axis=1)
offset_map[:, z_index][offset_map[:, z_index] > shape[1]] = -1
#
return offset_map
def compare(self, chunk, tiles):
chunk = self.normalize(chunk)
for i in range(chunk.shape[2]):
chunk[:,:,i] = chunk[:,:,i] - scipy.mean(chunk[:,:,i])
chunk[:,:,i] = chunk[:,:,i] / scipy.amax(abs(chunk[:,:,i]))
maxCorr = (-1, 0, 0)
for ID, tile in enumerate(tiles):
tile = self.normalize(tile)
corr = scipy.zeros(self.shiftDim)
colorComps = tile.shape[2] # usually 3 RGB color components
for i in range(colorComps):
corr = corr + signal.correlate(tile[:,:,i],chunk[:,:,i],
mode='valid')
corr = corr / colorComps
max_idx = scipy.unravel_index(scipy.argmax(corr), self.shiftDim)
if (corr[max_idx] > maxCorr[2]):
#print corr[max_idx]
maxCorr = (ID, self.translatePos(max_idx), corr[max_idx])
return maxCorr
def __init__(self, template, spacing=[1, 1, 1], **kwargs):
template = sp.atleast_3d(template)
if 'shape' in kwargs:
del kwargs['shape']
logger.warning('shape argument ignored, inferred from template')
super().__init__(shape=template.shape, spacing=spacing, **kwargs)
coords = sp.unravel_index(range(template.size), template.shape)
self['pore.template_coords'] = sp.vstack(coords).T
self['pore.template_indices'] = self.Ps
self['pore.drop'] = template.flatten() == 0
topotools.trim(network=self, pores=self.pores('drop'))
del self['pore.drop']
# remove labels pertaining to surface pores, then redo post-trim
self.clear(mode='labels')
self['pore.internal'] = True
self['throat.internal'] = True
topotools.find_surface_pores(self)
def _get_back_path(matrix, row, column):
if matrix[row - 1, column - 1] <= 0:
return [(row, column), (row - 1, column - 1)]
matrix_part = matrix[row - 1:row + 1, column - 1:column + 1]
matrix_part[1, 1] = 0
same_row, same_column = scipy.unravel_index(matrix_part.argmax(),
matrix_part.shape)
if same_row and same_column:
return [(row, column)]
point_row = row if same_row else row - 1
point_column = column if same_column else column - 1
return [
(row, column),
] + _get_back_path(matrix, point_row, point_column)
def findTemplate(origin, template_pos, template_size, search_pos, search_size, target):
"""
Find a template image into another image by normalized cross-correlation.
Arguments:
- origin, ndarray: image where the template is extracted (the image is accessed as a matrix, i.e. the points (x,y)
is found at origin[y,x])
- template_pos, (int,int): position (x,y) of the template
- template_size, (int,int): size (width,height) of the template
- search_pos, (int,int): central position (x,y) of the search zone
- search_size, (int,int): size (width,height) of the search zone
- target, ndarray: image where the template is searched (the image is accessed as a matrix, i.e. the points (x,y)
is found at target[y,x])
"""
t_left = max(0, template_pos[0] - template_size[0])
t_right = min(origin.shape[1]-1,
template_pos[0]
+ template_size[0])
t_bottom = max(0, template_pos[1] - template_size[1])
t_top = min(origin.shape[0]-1, template_pos[1] + template_size[1])
template = origin[t_bottom:t_top, t_left:t_right]
if t_left == 0:
template_size = (template_pos[0]-1, template_size[1])
if t_bottom == 0:
template_size = (template_size[0], template_pos[1]-1)
# template = template / sqrt((template*template).sum().sum())
s_left = max(0, search_pos[0] - search_size[0])
s_right = min(target.shape[1]-1, search_pos[0] + search_size[0])
s_bottom = max(0, search_pos[1] - search_size[1])
s_top = min(target.shape[0]-1, search_pos[1] + search_size[1])
target = target[s_bottom:s_top, s_left:s_right]
# target = target / sqrt((target*target).sum().sum())
cross = abs(normcross2d(template, target))
pos = scipy.unravel_index(cross.argmax(), cross.shape)
value = cross[pos]
center = (pos[1]+s_left-template_size[1]+1,
pos[0]+s_bottom-template_size[0]+1)
return center, value
def findTemplate(origin, template_pos, template_size, search_pos, search_size,
target):
"""
Find a template image into another image by normalized cross-correlation.
Arguments:
- origin, ndarray: image where the template is extracted (the image is accessed as a matrix, i.e. the points (x,y)
is found at origin[y,x])
- template_pos, (int,int): position (x,y) of the template
- template_size, (int,int): size (width,height) of the template
- search_pos, (int,int): central position (x,y) of the search zone
- search_size, (int,int): size (width,height) of the search zone
- target, ndarray: image where the template is searched (the image is accessed as a matrix, i.e. the points (x,y)
is found at target[y,x])
"""
t_left = max(0, template_pos[0] - template_size[0])
t_right = min(origin.shape[1] - 1, template_pos[0] + template_size[0])
t_bottom = max(0, template_pos[1] - template_size[1])
t_top = min(origin.shape[0] - 1, template_pos[1] + template_size[1])
template = origin[t_bottom:t_top, t_left:t_right]
if t_left == 0:
template_size = (template_pos[0] - 1, template_size[1])
if t_bottom == 0:
template_size = (template_size[0], template_pos[1] - 1)
# template = template / sqrt((template*template).sum().sum())
s_left = max(0, search_pos[0] - search_size[0])
s_right = min(target.shape[1] - 1, search_pos[0] + search_size[0])
s_bottom = max(0, search_pos[1] - search_size[1])
s_top = min(target.shape[0] - 1, search_pos[1] + search_size[1])
target = target[s_bottom:s_top, s_left:s_right]
# target = target / sqrt((target*target).sum().sum())
cross = abs(normcross2d(template, target))
pos = scipy.unravel_index(cross.argmax(), cross.shape)
value = cross[pos]
center = (pos[1] + s_left - template_size[1] + 1,
pos[0] + s_bottom - template_size[0] + 1)
return center, value
def asarray(self,values):
r'''
Retreive values as a rectangular array, rather than the OpenPNM list format
Parameters
----------
values : array_like
The values from the network (in a list) to insert into the array
Notes
-----
This method can break on networks that have had boundaries added. It
will usually work IF the list of values came only from 'internal' pores.
'''
if sp.shape(values)[0] > self.num_pores('internal'):
raise Exception('The received values are bigger than the original network')
Ps = sp.array(self['pore.index'][self.pores('internal')],dtype=int)
arr = sp.ones(self._shape)*sp.nan
ind = sp.unravel_index(Ps,self._shape)
arr[ind[0],ind[1],ind[2]] = values
return arr
def find_profiles(fracture_slice):
r"""
Takes in a 2-D data slice and generates line traces for JRC and Df
analysis.
Returns a dictionary of the top, bottom and midsurface traces as well
as the fraction of bifurcations and zero aperture zones.
"""
#
data = fracture_slice.slice_data
#
aperture = sp.sum(data, axis=1, dtype=int)
non_zero = sp.where(data.ravel() > 0)[0]
a1_coords, a2_coords = sp.unravel_index(non_zero, data.shape)
#
# getting the three profiles
profile = sp.ones(data.shape, dtype=float) * sp.inf
profile[a1_coords, a2_coords] = a2_coords
bottom = sp.amin(profile, axis=1)
bottom[~sp.isfinite(bottom)] = sp.nan
#
profile = sp.ones(data.shape, dtype=float) * -sp.inf
profile[a1_coords, a2_coords] = a2_coords
top = sp.amax(profile, axis=1)
top[~sp.isfinite(top)] = sp.nan
#
mid = (bottom + top) / 2.0
#
# calcualting bifurcation locations
bif_frac = top - bottom + 1 # because I store both fracture voxel indices
bif_frac[aperture == 0] = 0 # zero aperture zones are excluded
bif_frac = bif_frac.astype(int)
#
# updating attributes
fracture_slice.top = top
fracture_slice.bot = bottom
fracture_slice.mid = mid
fracture_slice.aperture = aperture
fracture_slice.zero_ap_count = sp.where(aperture == 0)[0].size
fracture_slice.bifurcation_count = sp.where(bif_frac != aperture)[0].size
def asarray(self, values):
r'''
Retreive values as a rectangular array, rather than the OpenPNM list format
Parameters
----------
values : array_like
The values from the network (in a list) to insert into the array
Notes
-----
This method can break on networks that have had boundaries added. It
will usually work IF the list of values came only from 'internal' pores.
'''
if sp.shape(values)[0] > self.num_pores('internal'):
raise Exception(
'The received values are bigger than the original network')
Ps = sp.array(self['pore.index'][self.pores('internal')], dtype=int)
arr = sp.ones(self._shape) * sp.nan
ind = sp.unravel_index(Ps, self._shape)
arr[ind[0], ind[1], ind[2]] = values
return arr
def save_cluster_image(cs_ids, groups, counts, locs, img_shape, img_name):
r"""
Saves an 8 bit image colored by cluster number
"""
logger.info('creating tiff image file colored by cluster number')
#
msg = '\t{} % of nodes covered in {} colored groups'
num_cs = min(16, groups.size)
num = sp.sum(counts[0:num_cs]) / cs_ids.size * 100
logger.debug(msg.format(num, num_cs))
#
# setting the top 16 groups separated by increments of 8 and the rest are 255
data = sp.ones(cs_ids.size, dtype=sp.uint8) * 255
for n, cs_id in enumerate(groups[0:num_cs - 1]):
inds = sp.where(cs_ids == cs_id)[0]
data[inds] = 67 + n * 8
#
x_coords, y_coords, z_coords = sp.unravel_index(locs, img_shape)
img_data = sp.zeros(img_shape, dtype=sp.uint8)
img_data[x_coords, y_coords, z_coords] = data
# save image data
img_data = img_data.view(FractureImageStack)
logger.info('saving image cluster data to file' + img_name)
img_data.save(img_name, overwrite=True)
def to_array(self, values):
r"""
Converts the values to a rectangular array with the same shape as the
network
Parameters
----------
values : array_like
An Np-long array of values to convert to
Notes
-----
This method can break on networks that have had boundaries added. It
will usually work IF the given values came only from 'internal'
pores.
"""
if sp.shape(values)[0] > self.num_pores('internal'):
raise Exception('The array shape does not match the network')
Ps = sp.array(self['pore.index'][self.pores('internal')], dtype=int)
arr = sp.ones(self._shape) * sp.nan
ind = sp.unravel_index(Ps, self._shape)
arr[ind[0], ind[1], ind[2]] = values
return arr
def generate_coordinate_arrays(aper_map, para_data_dict):
r"""
Generates the coordinate arrays to use in data interpolation for coverting
paraview point data into a 2-D data map.
"""
#
# generating XYZ coordinates from map to interpolate to
logger.info('calculating aperture map cell center coordinates...')
temp = sp.arange(aper_map.data_map.size, dtype=int)
temp = sp.unravel_index(temp, aper_map.data_map.shape[::-1])
map_coords = sp.zeros((aper_map.data_map.size, 3), dtype=float)
#
# half voxel added to make map points be cell centers
map_coords[:, 0] = temp[0] * avg_fact * voxel_size + voxel_size / 2.0
map_coords[:, 2] = temp[1] * avg_fact * voxel_size + voxel_size / 2.0
#
# pulling XYZ coordinates from the data file
logger.info('processing data file data for coordinates...')
data_coords = sp.zeros((para_data_dict['points:0'].shape[0], 3))
data_coords[:, 0] = para_data_dict['points:0']
data_coords[:, 1] = para_data_dict['points:1']
data_coords[:, 2] = para_data_dict['points:2']
#
return map_coords, data_coords
def generate_coordinate_arrays(aper_map, para_data_dict):
r"""
Generates the coordinate arrays to use in data interpolation for coverting
paraview point data into a 2-D data map.
"""
#
# generating XYZ coordinates from map to interpolate to
logger.info('calculating aperture map cell center coordinates...')
temp = sp.arange(aper_map.data_map.size, dtype=int)
temp = sp.unravel_index(temp, aper_map.data_map.shape[::-1])
map_coords = sp.zeros((aper_map.data_map.size, 3), dtype=float)
#
# half voxel added to make map points be cell centers
map_coords[:, 0] = temp[0] * avg_fact * voxel_size + voxel_size/2.0
map_coords[:, 2] = temp[1] * avg_fact * voxel_size + voxel_size/2.0
#
# pulling XYZ coordinates from the data file
logger.info('processing data file data for coordinates...')
data_coords = sp.zeros((para_data_dict['points:0'].shape[0], 3))
data_coords[:, 0] = para_data_dict['points:0']
data_coords[:, 1] = para_data_dict['points:1']
data_coords[:, 2] = para_data_dict['points:2']
#
return map_coords, data_coords
def clust_seqences(cluster, x, y, x_lim, y_lim, lev_num, kde, cluster_region,
kernel):
'''This is the central function. It generates the countour plots around the
cluster members. The extreme points of these contour levels are used to trace
the ZAMS fiducial line for each cluster, according to a minimum level value
allowed. The first method interpolates those points and then discards
points according to the xy limits. The second method first discards points
based on the xy limits and then interpolates the remaining ones.
'''
# This list will hold the points obtained through the contour curves,
# the first sublist are the x coordinates of the points and the second
# the y coordinates.
contour_seq = [[], []]
levels_range = np.arange(0.05,1.01,0.05)
# Store contour levels.
CS = plt.contour(x, y, kde, levels_range)
for i,clc in enumerate(CS.collections):
for j,pth in enumerate(clc.get_paths()):
cts = pth.vertices
d = sp.spatial.distance.cdist(cts,cts)
x_c,y_c = cts[list(sp.unravel_index(sp.argmax(d),d.shape))].T
# Only store points that belong to contour PDF values that belong
# to the uper curves, ie: do not use those with index < lev_num.
if i >= lev_num:
contour_seq[0].append(round(x_c[0],4))
contour_seq[1].append(round(y_c[0],4))
contour_seq[0].append(round(x_c[1],4))
contour_seq[1].append(round(y_c[1],4))
# If the sequence is an empty list don't attempt to plot the
# polynomial fit.
if contour_seq:
poli_order = 2 # Order of the polynome.
# Method 1.
# 1- Obtain the sequence's fitting polinome.
poli = np.polyfit(contour_seq[1], contour_seq[0], poli_order)
y_pol = np.linspace(min(contour_seq[1]),
max(contour_seq[1]), 50)
p = np.poly1d(poli)
x_pol = [p(i) for i in y_pol]
# 2- Trim the interpolated sequence to the range in xy axis.
y_pol_trim, x_pol_trim = zip(*[(ia,ib) for (ia, ib) in \
zip(y_pol, x_pol) if x_lim[0] <= ib <= x_lim[1] and \
y_lim[0] <= ia <= y_lim[1]])
# Method 2.
# 1- Trim the sequence to the xy range.
y_trim, x_trim = zip(*[(ia,ib) for (ia, ib) in \
zip(contour_seq[1], contour_seq[0]) if x_lim[0] <= ib <= x_lim[1] and \
y_lim[0] <= ia <= y_lim[1]])
# 2- Obtain the sequence's fitting polinome.
poli = np.polyfit(y_trim, x_trim, poli_order)
y_trim_pol = np.linspace(min(y_trim), max(y_trim), 50)
p = np.poly1d(poli)
x_trim_pol = [p(i) for i in y_trim_pol]
else:
x_pol_trim, y_pol_trim, x_trim_pol, y_trim_pol = [], [], [], []
return x_pol_trim, y_pol_trim, x_trim_pol, y_trim_pol
def forward_lmm_kronecker(snps,phenos,Asnps=None,Acond=None,K1r=None,K1c=None,K2r=None,K2c=None,covs=None,Acovs=None,threshold = 5e-8, maxiter = 2,qvalues=False, update_covariances = False,**kw_args):
"""
Kronecker fixed effects test with forward selection
Args:
snps: [N x S] SP.array of S SNPs for N individuals (test SNPs)
pheno: [N x P] SP.array of 1 phenotype for N individuals
K: [N x N] SP.array of LMM-covariance/kinship koefficients (optional)
If not provided, then linear regression analysis is performed
covs: [N x D] SP.array of D covariates for N individuals
threshold: (float) P-value thrashold for inclusion in forward selection (default 5e-8)
maxiter: (int) maximum number of interaction scans. First scan is
without inclusion, so maxiter-1 inclusions can be performed. (default 2)
qvalues: Use q-value threshold and return q-values in addition (default False)
update_covar: Boolean indicator if covariances should be re-estimated after each forward step (default False)
Returns:
lm: lmix LMMi object
resultStruct with elements:
iadded: array of indices of SNPs included in order of inclusion
pvadded: array of Pvalues obtained by the included SNPs in iteration
before inclusion
pvall: [maxiter x S] SP.array of Pvalues for all iterations
Optional: corresponding q-values
qvadded
qvall
"""
#0. checks
N = phenos.shape[0]
P = phenos.shape[1]
if K1r==None:
K1r = SP.dot(snps,snps.T)
else:
assert K1r.shape[0]==N, 'K1r: dimensions dismatch'
assert K1r.shape[1]==N, 'K1r: dimensions dismatch'
if K2r==None:
K2r = SP.eye(N)
else:
assert K2r.shape[0]==N, 'K2r: dimensions dismatch'
assert K2r.shape[1]==N, 'K2r: dimensions dismatch'
covs,Acovs = updateKronCovs(covs,Acovs,N,P)
if Asnps is None:
Asnps = [SP.ones([1,P])]
if (type(Asnps)!=list):
Asnps = [Asnps]
assert len(Asnps)>0, "need at least one Snp design matrix"
if Acond is None:
Acond = Asnps
if (type(Acond)!=list):
Acond = [Acond]
assert len(Acond)>0, "need at least one Snp design matrix"
#1. run GP model to infer suitable covariance structure
if K1c==None or K2c==None:
vc = estimateKronCovariances(phenos=phenos, K1r=K1r, K2r=K2r, K1c=K1c, K2c=K2c, covs=covs, Acovs=Acovs, **kw_args)
K1c = vc.getEstTraitCovar(0)
K2c = vc.getEstTraitCovar(1)
else:
vc = None
assert K1c.shape[0]==P, 'K1c: dimensions dismatch'
assert K1c.shape[1]==P, 'K1c: dimensions dismatch'
assert K2c.shape[0]==P, 'K2c: dimensions dismatch'
assert K2c.shape[1]==P, 'K2c: dimensions dismatch'
t0 = time.time()
lm,pv = kronecker_lmm(snps=snps,phenos=phenos,Asnps=Asnps,K1r=K1r,K2r=K2r,K1c=K1c,K2c=K2c,covs=covs,Acovs=Acovs)
#get pv
#start stuff
iadded = []
pvadded = []
qvadded = []
time_el = []
pvall = SP.zeros((pv.shape[0]*maxiter,pv.shape[1]))
qvall = None
t1=time.time()
print ("finished GWAS testing in %.2f seconds" %(t1-t0))
time_el.append(t1-t0)
pvall[0:pv.shape[0],:]=pv
imin= SP.unravel_index(pv.argmin(),pv.shape)
score=pv[imin].min()
niter = 1
if qvalues:
assert pv.shape[0]==1, "This is untested with the fdr package. pv.shape[0]==1 failed"
qvall = SP.zeros((maxiter,snps.shape[1]))
qv = FDR.qvalues(pv)
qvall[0:1,:] = qv
score=qv[imin]
#loop:
while (score<threshold) and niter<maxiter:
t0=time.time()
pvadded.append(pv[imin])
iadded.append(imin)
if qvalues:
qvadded.append(qv[imin])
if update_covariances and vc is not None:
vc.addFixedTerm(snps[:,imin[1]:(imin[1]+1)],Acond[imin[0]])
vc.setScales()#CL: don't know what this does, but findLocalOptima crashes becahuse vc.noisPos=None
vc.findLocalOptima(fast=True)
K1c = vc.getEstTraitCovar(0)
K2c = vc.getEstTraitCovar(1)
lm.setK1c(K1c)
lm.setK2c(K2c)
lm.addCovariates(snps[:,imin[1]:(imin[1]+1)],Acond[imin[0]])
for i in xrange(len(Asnps)):
#add SNP design
lm.setSNPcoldesign(Asnps[i])
lm.process()
pv[i,:] = lm.getPv()[0]
pvall[niter*pv.shape[0]:(niter+1)*pv.shape[0]]=pv
imin= SP.unravel_index(pv.argmin(),pv.shape)
if qvalues:
qv = FDR.qvalues(pv)
qvall[niter:niter+1,:] = qv
score = qv[imin].min()
else:
score = pv[imin].min()
t1=time.time()
print ("finished GWAS testing in %.2f seconds" %(t1-t0))
time_el.append(t1-t0)
niter=niter+1
RV = {}
RV['iadded'] = iadded
RV['pvadded'] = pvadded
RV['pvall'] = pvall
RV['time_el'] = time_el
if qvalues:
RV['qvall'] = qvall
RV['qvadded'] = qvadded
return lm,RV
def _victor_purpura_multiunit_dist_for_trial_pair(
a, b, reassignment_cost, kernel):
# The algorithm used is based on the one given in
#
# Victor, J. D., & Purpura, K. P. (1996). Nature and precision of temporal
# coding in visual cortex: a metric-space analysis. Journal of
# Neurophysiology.
#
# It constructs a matrix cost[i, j_1, ... j_L] containing the minimal cost
# when only considering the first i spikes of the merged spikes of a and
# j_w spikes of the spike trains of b (the reference given above denotes
# this matrix with G). In this implementation the only the one submatrix
# for one specific i is stored as in each step only i-1 and i will be
# accessed. That saves some memory.
# Initialization of various variables needed by the algorithm. Also swap
# a and b if it will save time as the algorithm is not symmetric.
a_num_spikes = [st.size for st in a]
b_num_spikes = [st.size for st in b]
a_num_total_spikes = sp.sum(a_num_spikes)
complexity_same = a_num_total_spikes * sp.prod(b_num_spikes)
complexity_swapped = sp.prod(a_num_spikes) * sp.sum(b_num_spikes)
if complexity_swapped < complexity_same:
a, b = b, a
a_num_spikes, b_num_spikes = b_num_spikes, a_num_spikes
a_num_total_spikes = sp.sum(a_num_spikes)
if a_num_total_spikes <= 0:
return sp.sum(b_num_spikes)
b_dims = tuple(sp.asarray(b_num_spikes) + 1)
cost = sp.asfarray(sp.sum(sp.indices(b_dims), axis=0))
a_merged = _merge_trains_and_label_spikes(a)
b_strides = sp.cumprod((b_dims + (1,))[::-1])[:-1]
flat_b_indices = sp.arange(cost.size)
b_indices = sp.vstack(sp.unravel_index(flat_b_indices, b_dims))
flat_neighbor_indices = sp.maximum(
0, sp.atleast_2d(flat_b_indices).T - b_strides[::-1])
invalid_neighbors = b_indices.T == 0
b_train_mat = sp.empty((len(b), sp.amax(b_num_spikes))) * b[0].units
for i, st in enumerate(b):
b_train_mat[i, :st.size] = st.rescale(b[0].units)
b_train_mat[i, st.size:] = sp.nan * b[0].units
reassignment_costs = sp.empty((a_merged[0].size,) + b_train_mat.shape)
reassignment_costs.fill(reassignment_cost)
reassignment_costs[sp.arange(a_merged[1].size), a_merged[1], :] = 0.0
k = 1 - 2 * kernel(sp.atleast_2d(
a_merged[0]).T - b_train_mat.flatten()).simplified.reshape(
(a_merged[0].size,) + b_train_mat.shape) + reassignment_costs
decreasing_sequence = flat_b_indices[::-1]
# Do the actual calculations.
for a_idx in xrange(1, a_num_total_spikes + 1):
base_costs = cost.flat[flat_neighbor_indices]
base_costs[invalid_neighbors] = sp.inf
min_base_cost_labels = sp.argmin(base_costs, axis=1)
cost_all_possible_shifts = k[a_idx - 1, min_base_cost_labels, :] + \
sp.atleast_2d(base_costs[flat_b_indices, min_base_cost_labels]).T
cost_shift = cost_all_possible_shifts[
sp.arange(cost_all_possible_shifts.shape[0]),
b_indices[min_base_cost_labels, flat_b_indices] - 1]
cost_delete_in_a = cost.flat[flat_b_indices]
# cost_shift is dimensionless, but there is a bug in quantities with
# the minimum function:
# <https://github.com/python-quantities/python-quantities/issues/52>
# The explicit request for the magnitude circumvents this problem.
cost.flat = sp.minimum(cost_delete_in_a, cost_shift.magnitude) + 1
cost.flat[0] = sp.inf
# Minimum with cost for deleting in b
# The calculation order is somewhat different from the order one would
# expect from the naive algorithm. This implementation, however,
# optimizes the use of the CPU cache giving a considerable speed
# improvement.
# Basically this codes calculates the values of a row of elements for
# each dimension of cost.
for dim_size, stride in zip(b_dims[::-1], b_strides):
for i in xrange(stride):
segment_size = dim_size * stride
for j in xrange(i, cost.size, segment_size):
s = sp.s_[j:j + segment_size:stride]
seq = decreasing_sequence[-cost.flat[s].size:]
cost.flat[s] = sp.minimum.accumulate(
cost.flat[s] + seq) - seq
return cost.flat[-1]
def _victor_purpura_multiunit_dist_for_trial_pair(a, b, reassignment_cost,
kernel):
# The algorithm used is based on the one given in
#
# Victor, J. D., & Purpura, K. P. (1996). Nature and precision of temporal
# coding in visual cortex: a metric-space analysis. Journal of
# Neurophysiology.
#
# It constructs a matrix cost[i, j_1, ... j_L] containing the minimal cost
# when only considering the first i spikes of the merged spikes of a and
# j_w spikes of the spike trains of b (the reference given above denotes
# this matrix with G). In this implementation the only the one submatrix
# for one specific i is stored as in each step only i-1 and i will be
# accessed. That saves some memory.
# Initialization of various variables needed by the algorithm. Also swap
# a and b if it will save time as the algorithm is not symmetric.
a_num_spikes = [st.size for st in a]
b_num_spikes = [st.size for st in b]
a_num_total_spikes = sp.sum(a_num_spikes)
complexity_same = a_num_total_spikes * sp.prod(b_num_spikes)
complexity_swapped = sp.prod(a_num_spikes) * sp.sum(b_num_spikes)
if complexity_swapped < complexity_same:
a, b = b, a
a_num_spikes, b_num_spikes = b_num_spikes, a_num_spikes
a_num_total_spikes = sp.sum(a_num_spikes)
if a_num_total_spikes <= 0:
return sp.sum(b_num_spikes)
b_dims = tuple(sp.asarray(b_num_spikes) + 1)
cost = sp.asfarray(sp.sum(sp.indices(b_dims), axis=0))
a_merged = _merge_trains_and_label_spikes(a)
b_strides = sp.cumprod((b_dims + (1, ))[::-1])[:-1]
flat_b_indices = sp.arange(cost.size)
b_indices = sp.vstack(sp.unravel_index(flat_b_indices, b_dims))
flat_neighbor_indices = sp.maximum(
0,
sp.atleast_2d(flat_b_indices).T - b_strides[::-1])
invalid_neighbors = b_indices.T == 0
b_train_mat = sp.empty((len(b), sp.amax(b_num_spikes))) * b[0].units
for i, st in enumerate(b):
b_train_mat[i, :st.size] = st.rescale(b[0].units)
b_train_mat[i, st.size:] = sp.nan * b[0].units
reassignment_costs = sp.empty((a_merged[0].size, ) + b_train_mat.shape)
reassignment_costs.fill(reassignment_cost)
reassignment_costs[sp.arange(a_merged[1].size), a_merged[1], :] = 0.0
k = 1 - 2 * kernel(sp.atleast_2d(a_merged[0]).T -
b_train_mat.flatten()).simplified.reshape(
(a_merged[0].size, ) +
b_train_mat.shape) + reassignment_costs
decreasing_sequence = flat_b_indices[::-1]
# Do the actual calculations.
for a_idx in xrange(1, a_num_total_spikes + 1):
base_costs = cost.flat[flat_neighbor_indices]
base_costs[invalid_neighbors] = sp.inf
min_base_cost_labels = sp.argmin(base_costs, axis=1)
cost_all_possible_shifts = k[a_idx - 1, min_base_cost_labels, :] + \
sp.atleast_2d(base_costs[flat_b_indices, min_base_cost_labels]).T
cost_shift = cost_all_possible_shifts[
sp.arange(cost_all_possible_shifts.shape[0]),
b_indices[min_base_cost_labels, flat_b_indices] - 1]
cost_delete_in_a = cost.flat[flat_b_indices]
# cost_shift is dimensionless, but there is a bug in quantities with
# the minimum function:
# <https://github.com/python-quantities/python-quantities/issues/52>
# The explicit request for the magnitude circumvents this problem.
cost.flat = sp.minimum(cost_delete_in_a, cost_shift.magnitude) + 1
cost.flat[0] = sp.inf
# Minimum with cost for deleting in b
# The calculation order is somewhat different from the order one would
# expect from the naive algorithm. This implementation, however,
# optimizes the use of the CPU cache giving a considerable speed
# improvement.
# Basically this codes calculates the values of a row of elements for
# each dimension of cost.
for dim_size, stride in zip(b_dims[::-1], b_strides):
for i in xrange(stride):
segment_size = dim_size * stride
for j in xrange(i, cost.size, segment_size):
s = sp.s_[j:j + segment_size:stride]
seq = decreasing_sequence[-cost.flat[s].size:]
cost.flat[s] = sp.minimum.accumulate(cost.flat[s] +
seq) - seq
return cost.flat[-1]
def bar_detectability(parser,
dx=_XWIDTH/20.,dy=_YWIDTH/20.,
nx=100,ny=20,
ngrid=201,rrange=[0.7,1.3],
phirange=[-m.pi/2.,m.pi/2.],
saveDir='../bar/1dLarge/'):
"""
NAME:
bar_detectability
PURPOSE:
analyze the detectability of the Hercules moving group in the
los-distribution around the Galaxy
INPUT:
nx - number of plots in the x-direction
ny - number of plots in the y direction
dx - x-spacing
dy - y-spacing
ngrid - number of gridpoints to evaluate the density on
rrange - range of Galactocentric radii to consider
phirange - range of Galactic azimuths to consider
saveDir - directory to save the pickles in
OUTPUT:
plot in plotfilename
HISTORY:
2010-05-09 - Written - Bovy (NYU)
"""
(options,args)= parser.parse_args()
if len(args) == 0:
parser.print_help()
return
if not options.convolve == None:
bar_detectability_convolve(parser,dx=dx,dy=dy,nx=nx,ny=ny,ngrid=ngrid,
rrange=rrange,phirange=phirange,
saveDir=saveDir)
return
vloslinspace= (-.9,.9,ngrid)
vloss= sc.linspace(*vloslinspace)
picklebasename= '1d_%i_%i_%i_%.1f_%.1f_%.1f_%.1f' % (nx,ny,ngrid,rrange[0],rrange[1],phirange[0],phirange[1])
detect= sc.zeros((nx,ny))
losd= sc.zeros((nx,ny))
gall= sc.zeros((nx,ny))
for ii in range(nx):
for jj in range(ny):
thisR= (rrange[0]+(rrange[1]-rrange[0])/
(ny*_YWIDTH+(ny-1)*dy)*(jj*(_YWIDTH+dy)+_YWIDTH/2.))
thisphi= (phirange[0]+(phirange[1]-phirange[0])/
(nx*_XWIDTH+(nx-1)*dx)*(ii*(_XWIDTH+dx)+_XWIDTH/2.))
thissavefilename= os.path.join(saveDir,picklebasename+'_%i_%i.sav' %(ii,jj))
if os.path.exists(thissavefilename):
print "Restoring los-velocity distribution at %.2f, %.2f ..." %(thisR,thisphi)
savefile= open(thissavefilename,'r')
vlosd= pickle.load(savefile)
axivlosd= pickle.load(savefile)
savefile.close()
else:
print "Did not find the los-velocity distribution at at %.2f, %.2f ..." %(thisR,thisphi)
print "returning ..."
return
ddx= 1./sc.sum(axivlosd)
#skipCenter
if not options.skipCenter == 0.:
skipIndx= (sc.fabs(vloss) < options.skipCenter)
indx= (sc.fabs(vloss) >= options.skipCenter)
vlosd= vlosd/sc.sum(vlosd[indx])/ddx
axivlosd= axivlosd/sc.sum(axivlosd[indx])/ddx
vlosd[skipIndx]= 1.
axivlosd[skipIndx]= 1.
vlosd_zeroindx= (vlosd == 0.)
axivlosd_zeroindx= (axivlosd == 0.)
vlosd[vlosd_zeroindx]= 1.
axivlosd[vlosd_zeroindx]= 1.
vlosd[axivlosd_zeroindx]= 1.
axivlosd[axivlosd_zeroindx]= 1.
detect[ii,jj]= probDistance.kullbackLeibler(vlosd,axivlosd,ddx,nan=True)
#los distance and Galactic longitude
d= m.sqrt(thisR**2.+1.-2.*thisR*m.cos(thisphi))
losd[ii,jj]= d
if 1./m.cos(thisphi) < thisR and m.cos(thisphi) > 0.:
l= m.pi-m.asin(thisR/d*m.sin(thisphi))
else:
l= m.asin(thisR/d*m.sin(thisphi))
gall[ii,jj]= l
#Find maximum, further than 3 kpc away
detectformax= detect.flatten()
detectformax[losd.flatten() < 3./8.2]= 0.
x= sc.argmax(detectformax)
indx = sc.unravel_index(x,detect.shape)
maxR= (rrange[0]+(rrange[1]-rrange[0])/
(ny*_YWIDTH+(ny-1)*dy)*(indx[1]*(_YWIDTH+dy)+_YWIDTH/2.))
maxphi= (phirange[0]+(phirange[1]-phirange[0])/
(nx*_XWIDTH+(nx-1)*dx)*(indx[0]*(_XWIDTH+dx)+_XWIDTH/2.))
print maxR, maxphi, losd[indx[0],indx[1]], detect[indx[0],indx[1]], gall[indx[0],indx[1]]*180./sc.pi
#Now plot
plot.bovy_print()
plot.bovy_dens2d(detect.T,origin='lower',#interpolation='nearest',
xlabel=r'$\mathrm{Galactocentric\ azimuth}\ [\mathrm{deg}]$',
ylabel=r'$\mathrm{Galactocentric\ radius}\ /R_0$',
cmap='gist_yarg',xrange=sc.array(phirange)*_RADTODEG,
yrange=rrange,
aspect=(phirange[1]-phirange[0])*_RADTODEG/(rrange[1]-rrange[0]))
#contour the los distance and gall
#plot.bovy_text(-22.,1.1,r'$\mathrm{apogee}$',color='w',
# rotation=105.)
plot.bovy_text(-18.,1.1,r'$\mathrm{APOGEE}$',color='w',
rotation=285.)
levels= [2/8.2*(ii+1/2.) for ii in range(10)]
contour(losd.T,levels,colors='0.25',origin='lower',linestyles='--',
aspect=(phirange[1]-phirange[0])*_RADTODEG/(rrange[1]-rrange[0]),
extent=(phirange[0]*_RADTODEG,phirange[1]*_RADTODEG,
rrange[0],rrange[1]))
gall[gall < 0.]+= sc.pi*2.
levels= [0.,sc.pi/2.,sc.pi,3.*sc.pi/2.]
contour(gall.T,levels,colors='w',origin='lower',linestyles='--',
aspect=(phirange[1]-phirange[0])*_RADTODEG/(rrange[1]-rrange[0]),
extent=(phirange[0]*_RADTODEG,phirange[1]*_RADTODEG,
rrange[0],rrange[1]))
levels= [-5/180.*sc.pi,250/180.*sc.pi]
contour(gall.T,levels,colors='w',origin='lower',linestyles='-.',
aspect=(phirange[1]-phirange[0])*_RADTODEG/(rrange[1]-rrange[0]),
extent=(phirange[0]*_RADTODEG,phirange[1]*_RADTODEG,
rrange[0],rrange[1]))
if options.skipCenter == 0.:
plot.bovy_text(r'$\mathrm{KL\ divergence\ / \ all}\ v_{\mathrm{los}}$',
title=True)
else:
plot.bovy_text(r'$\mathrm{KL\ divergence\ / }\ |v_{\mathrm{los}}| \geq %.2f \ v_0$' % options.skipCenter,
title=True)
plot.bovy_end_print(args[0])
def cov_from_segments(gene, seg_counts, edge_counts, edge_idx, ax, sample_idx=None,
log=False, cmap_seg=None, cmap_edg=None, xlim=None, grid=False,
order='C'):
"""This function takes a gene and its corresponding segment and edge counts to
produce a coverage overview plot."""
if sample_idx is None:
sample_idx = [sp.arange(seg_counts.shape[1])]
norm = plt.Normalize(0, len(sample_idx))
if cmap_seg is None:
cmap_seg = plt.get_cmap('jet')
if cmap_edg is None:
cmap_edg = plt.get_cmap('jet')
line_patches = []
fill_patches = []
### iterate over segments
for j in range(gene.segmentgraph.segments.shape[1]):
s = gene.segmentgraph.segments[:, j]
### iterate over samples
for c, curr_idx in enumerate(sample_idx):
#for i in curr_idx:
if log:
counts = sp.log10(seg_counts[j, curr_idx] + 1)
else:
counts = seg_counts[j, curr_idx]
### plot segment over all samples (including uncertainty region)
if counts.shape[0] == 1:
ax.plot(s, [counts[0], counts[0]], '-', color=cmap_seg(norm(c)), linewidth=0.5)
#line_patches.append(mlines.Line2D(s, [counts[0], counts[0]], color=cmap_seg(norm(c)), linewidth=2, transform=None))
elif counts.shape[0] > 1:
stderr = spst.sem(counts)
mean = sp.mean(counts)
#ax.fill_between(s, mean, mean+stderr, color=cmap_seg(norm(c)), alpha=0.3)
ax.fill_between(s, mean-stderr, mean+stderr, color=cmap_seg(norm(c)), alpha=0.2, edgecolor='none', linewidth=0)
#fill_patches.append(mpatches.Rectangle(s, mean-stderr, mean+stderr, color=cmap_seg(norm(c)), alpha=0.3, transform=None))
ax.plot(s, [mean, mean], '-', color=cmap_seg(norm(c)), linewidth=0.5)
#line_patches.append(mlines.Line2D(s, [mean, mean], color=cmap_seg(norm(c)), linewidth=2, transform=None))
#ax.plot(s, [mean+stderr, mean+stderr], ':', color=cmap_seg(norm(c)), linewidth=1)
#ax.plot(s, [mean-stderr, mean-stderr], ':', color=cmap_seg(norm(c)), linewidth=1)
#for line in line_patches:
# ax.add_line(line)
#for patch in fill_patches:
# ax.add_patch(patch)
### iterate over intron edges
for j in range(edge_idx.shape[0]):
### iterate over samples
for c, curr_idx in enumerate(sample_idx):
[s, t] = sp.unravel_index(edge_idx[j], gene.segmentgraph.seg_edges.shape, order=order)
if log:
counts = sp.log10(edge_counts[j, curr_idx] + 1)
else:
counts = edge_counts[j, curr_idx]
mean = sp.mean(counts)
add_intron_patch2(ax, gene.segmentgraph.segments[1, s], gene.segmentgraph.segments[0, t], mean, color=cmap_edg(norm(c)))
if xlim is not None:
ax.set_xlim(xlim)
### draw grid
if grid:
ax.grid(b=True, which='major', linestyle='--', linewidth=0.2, color='#222222')
ax.xaxis.grid(False)
ax.set_ylim([0, ax.get_ylim()[1]])
beta_fit = sparray(ans[0], dtype = "single")
#y_resid = ans[1]
## Evaluating the fit
Y_pred = dot(X_test,beta_fit)
MSE[f2_vec.index(f2),p_vec.index(p)] += spsum((Y_pred-Y_test)**2)
print("CVfold,f2,p:", [CVfold,f2,p])
sys.stdout.flush()
print("MSE:", MSE)
sys.stdout.flush()
## The index of the minimum:
i,j = sp.unravel_index(MSE.argmin(), MSE.shape)
#for i in range(3):
# for j in range(6):
# if MSE[i,j]==MSE.min():
# min_index_0 = i
# min_index_1 = j
f2 = f2_vec[i]
p = p_vec[j]
print("f2:",f2)
print("p:",p)
print("min(MSE):", min(MSE))
print("Step 2a took", round((time.time()-step)/60,2),"minutes")
figure = triangle.corner(samples, quantiles=[0.16, 0.5, 0.84])
figure.savefig(str(percent) + '%' + "triangle.pdf")
plt.close()
# plot the walker positions over interations
plot_walkers_iter(ndim, paramnames, chain)
autocorr_time = sampler.get_autocorr_time()
# get the maximum likelihood value and parameter values
f.write('\n\tMean acceptance: %d \n' %
(sp.mean(sampler.acceptance_fraction) * 100.))
ML = sp.unravel_index(lnlike_flat.argmax(), lnlike_flat.shape)
par_ML = samples[ML]
# calculate the parameter medians and +/- 1 sigma uncertainties
# for a normal distribution 68% of scores between +/- 1 sigma
# this corresponds to percentiles of 16 (-1 sig) and 84 (+1 sig)
f.write('\n\tAutocorrelation time: \n%s' % autocorr_time)
f.write(
'\n\tMaximum likelihood parameters = \n%s\nML index = %s \nML value = %s \n'
% (par_ML, ML, lnlike_flat[ML]))
# f.write('Median, Upper, Lower = \n%s\n' % vmr)
f.write('PERCENTAGE COMPLETE: %s%% \n' % percent)
# plot spectra and temperature profile if in retrieval
plot_spectra(percent, samples, runname, y, yerr, vflag, gflag, ntemp, nvmr,
def best_match(self, inputs):
return scipy.unravel_index(scipy.argmax(scipy.multiply(self.nodes, inputs).sum(axis=2)), (self.height,self.width))
def max(arr):
maxi = np.argmax(arr)
return sp.unravel_index(maxi,arr.shape), arr.max()
hval=hist(distance, td, weights=redcount)
xlabel(r'D, $\AA$', position=(0.9,0), size='xx-large', va='center')
gca().yaxis.set_ticklabels([])
grid()
subplot(322)
title('Distance vs angle', position=(0.05,0.95), color='white', ha='left', va='top', size='xx-large')
zda=array([histogram(angle[abs(distance-x)<=0.5*args.dstep], bins=ta, weights=redcount[abs(distance-x)<=0.5*args.dstep], density=args.normden)[0] for x in td])
contourf(0.5*(ta[1:]+ta[:-1]),td,array(zda),50)
xlabel(r'$\alpha$, $\degree$', position=(0.9,0), size='xx-large', va='center')
ylabel(r'D, $\AA$', size='xx-large')
grid()
if args.dakernel:
xv,yv=meshgrid(0.5*(ta[1:]+ta[:-1]), td)
ti, tj = unravel_index(argmax(zda),zda.shape)
xo = xv[ti,tj]
yo = yv[ti,tj]
sx = 2*sum(sum(zda>zda.max()*exp(-1)))/pi*args.astep**2
sy = 2*sum(sum(zda>zda.max()*exp(-1)))/pi*args.dstep**2
Anorm=zda.sum()*sqrt(pi*(sx+sy))*args.dstep*args.astep
p = [Anorm, xo, yo, sx, sy]
print("Round 1:")
print("Initial parameters: D/sigmaD = %.2f / %.2f, A/sigmaA = %.1f / %.1f" % (p[2], sqrt(p[4]/2), p[1], sqrt(p[3]/2)))
pp = fmin(lsqwgauss, p, (xv, yv, zda))
print("Refined parameters: D/sigmaD = %.2f / %.2f, A/sigmaA = %.1f / %.1f" % (pp[2], sqrt(pp[4]/2), pp[1], sqrt(pp[3]/2)))
print("Round 2:")
zv = f2gauss((xv,yv),pp)
vv = zv.max()*array([exp(-8), exp(-4.5), exp(-2), exp(-0.5)])
contour(xv,yv,zv,vv,colors='white')
ppp = fmin(lsqwgauss, pp, (xv, yv, zda))
