def execute(self, namespace):
inp = namespace[self.inputName]
filtered = tabular.ResultsFilter(inp, **self.filters)
if 'mdh' in dir(inp):
filtered.mdh = inp.mdh
namespace[self.outputName] = filtered
def execute(self, namespace):
from PYME.IO import tabular
if self.lowerMinPtsPerCluster > self.higherMinPtsPerCluster:
print(
'Swapping low and high MinPtsPerCluster - input was reversed')
temp = self.lowerMinPtsPerCluster
self.lowerMinPtsPerCluster = self.higherMinPtsPerCluster
self.higherMinPtsPerCluster = temp
iters = (int(np.max(namespace[self.inputName]['t'])) /
int(self.stepSize)) + 2
# other counts
lowDensMinPtsClumps = np.empty(iters)
lowDensMinPtsClumps[0] = 0
hiDensMinPtsClumps = np.empty(iters)
hiDensMinPtsClumps[0] = 0
t = np.empty(iters)
t[0] = 0
inp = tabular.MappingFilter(namespace[self.inputName])
for ind in range(
1, iters): # start from 1 since t=[0,0] will yield no clumps
# filter time
inc = tabular.ResultsFilter(inp, t=[0, self.stepSize * ind])
t[ind] = np.max(inc['t'])
cid, counts = np.unique(inc[self.labelsKey], return_counts=True)
# cmask = np.in1d(inc['DBSCAN_allFrames'], cid)
cidL = cid[counts >= self.lowerMinPtsPerCluster]
lowDensMinPtsClumps[ind] = np.sum(
cidL != -1) # ignore unclumped in count
cid = cid[counts >= self.higherMinPtsPerCluster]
hiDensMinPtsClumps[ind] = np.sum(
cid != -1) # ignore unclumped in count
res = tabular.MappingFilter({
't':
t,
'N_labelsWithLowMinPoints':
lowDensMinPtsClumps,
'N_labelsWithHighMinPoints':
hiDensMinPtsClumps
})
# propagate metadata, if present
try:
res.mdh = namespace[self.inputName].mdh
except AttributeError:
pass
namespace[self.outputName] = res
def findTracks2(datasource,
rad_var='error_x',
multiplier='2.0',
nFrames=20,
minClumpSize=0):
import PYME.Analysis.points.DeClump as deClump
from PYME.IO import tabular
with_clumps = tabular.MappingFilter(datasource)
if rad_var == '1.0':
delta_x = 0 * datasource['x'] + multiplier
else:
delta_x = multiplier * datasource[rad_var]
t = datasource['t'].astype('i')
x = datasource['x'].astype('f4')
y = datasource['y'].astype('f4')
delta_x = delta_x.astype('f4')
I = np.argsort(t)
clumpIndices = np.zeros(len(x), dtype='i')
clumpIndices[I] = deClump.findClumps(t[I], x[I], y[I], delta_x[I], nFrames)
numPerClump, b = np.histogram(clumpIndices,
np.arange(clumpIndices.max() + 1.5) + .5)
trackVelocities = 0 * x
trackVelocities[I] = calcTrackVelocity(x[I], y[I], clumpIndices[I],
t.astype('f')[I])
#print b
with_clumps.addColumn('clumpIndex', clumpIndices)
with_clumps.addColumn('clumpSize', numPerClump[clumpIndices - 1])
with_clumps.addColumn('trackVelocity', trackVelocities)
if minClumpSize > 0:
filt = tabular.ResultsFilter(with_clumps,
clumpSize=[minClumpSize, 1e6])
else:
filt = with_clumps
try:
filt.mdh = datasource.mdh
except AttributeError:
pass
return with_clumps, ClumpManager(filt)
def RegenFilter(self):
if not self.selectedDataSource is None:
self.filter = inpFilt.ResultsFilter(self.selectedDataSource,
**self.filterKeys)
if self.mapping:
self.mapping.resultsSource = self.filter
else:
self.mapping = inpFilt.MappingFilter(self.filter)
if not self.colourFilter:
self.colourFilter = inpFilt.ColourFilter(self.mapping, self)
self.edb = None
self.objects = None
self.GeneratedMeasures = {}
def Rebuild(self, **kwargs):
"""
Rebuild the pipeline. Called when the selected data source is changed/modified and/or the filter is changed.
"""
for s in self.dataSources.values():
if 'setMapping' in dir(s):
#keep raw measurements available
s.setMapping('x_raw', 'x')
s.setMapping('y_raw', 'y')
if 'z' in s.keys():
s.setMapping('z_raw', 'z')
if not self.selectedDataSource is None:
if not self.mapping is None:
# copy any mapping we might have made across to the new mapping filter (should fix drift correction)
# TODO - make drift correction a recipe module so that we don't need this code. Long term we should be
# ditching the mapping filter here.
old_mapping = self.mapping
self.mapping = tabular.MappingFilter(self.selectedDataSource)
self.mapping.mappings.update(old_mapping.mappings)
else:
self.mapping = tabular.MappingFilter(self.selectedDataSource)
#the filter, however needs to be re-generated with new keys and or data source
self.filter = tabular.ResultsFilter(self.mapping,
**self.filterKeys)
#we can also recycle the colour filter
if self.colourFilter is None:
self.colourFilter = tabular.ColourFilter(self.filter)
else:
self.colourFilter.resultsSource = self.filter
#self._process_colour()
self.ready = True
self.ClearGenerated()
def execute(self, namespace):
from PYME.IO.image import ImageStack
series = namespace[self.input_series]
positions = namespace[self.input_positions]
ox_nm, oy_nm, oz = series.origin
vs_nm = np.array([series.voxelsize_nm.x, series.voxelsize_nm.y])
roi_half_nm = (self.roi_half_size + 1) * vs_nm
x_max, y_max = (series.data.shape[:2] * vs_nm) - roi_half_nm
edge_filtered = tabular.ResultsFilter(positions,
x=[ox_nm + roi_half_nm[0], x_max],
y=[oy_nm + roi_half_nm[1], y_max])
n_filtered = len(positions) - len(edge_filtered)
if n_filtered > 0:
logger.error('%d positions too close to edge, filtering.' % n_filtered)
extracted = FitPoints(fitModule='ROIExtractNR',
roiHalfSize=self.roi_half_size,
channel=0).apply_simple(inputImage=series,
inputPositions=edge_filtered)
# get roi edge position. FFBase._get_roi rounds before extracting
relative_positions = edge_filtered.to_recarray()
x_edge = np.round(edge_filtered['x'] / series.voxelsize_nm.x) - self.roi_half_size
y_edge = np.round(edge_filtered['y'] / series.voxelsize_nm.y) - self.roi_half_size
# subtract off ofset to ROI edge
relative_positions['x'] = edge_filtered['x'] - (x_edge * series.voxelsize_nm.x)
relative_positions['y'] = edge_filtered['y'] - (y_edge * series.voxelsize_nm.y)
relative_positions['fitResults_x0'] = relative_positions['x']
relative_positions['fitResults_y0'] = relative_positions['y']
relative_positions = tabular.RecArraySource(relative_positions)
relative_positions.mdh = MetaDataHandler.NestedClassMDHandler(positions.mdh)
relative_positions.mdh['ExtractROIs.RoiHalfSize'] = self.roi_half_size
namespace[self.output_rois] = ImageStack(data=np.moveaxis(extracted['data'], 0, 2),
mdh=series.mdh)
namespace[self.output_relative_positions] = relative_positions
def getPSFSlice(datasource, resultsSource, metadata, zm=None):
f1 = tabular.ResultsFilter(resultsSource, error_x=[1, 30], A=[10, 500], sig=(150 / 2.35, 900 / 2.35))
ims, pts, zvals, zis = extractIms(datasource, f1, metadata, zm)
return getPSF(ims, pts, zvals, zis)
def generateThumbnail(inputFile, thumbSize):
f1 = tabular.H5RSource(inputFile)
threeD = False
stack = False
split = False
#print f1.keys()
if 'fitResults_Ag' in f1.keys():
#if we used the splitter set up a mapping so we can filter on total amplitude and ratio
f1_ = tabular.MappingFilter(f1, A='fitResults_Ag + fitResults_Ar', gFrac='fitResults_Ag/(fitResults_Ag + fitResults_Ar)')
#f2 = inpFilt.resultsFilter(f1_, error_x=[0,30], A=[5, 1e5], sig=[100/2.35, 350/2.35])
split = True
else:
f1_ = f1
if 'fitResults_sigma' in f1.keys():
f2 = tabular.ResultsFilter(f1_, error_x=[0, 30], A=[5, 1e5], sig=[100 / 2.35, 350 / 2.35])
else:
f2 = tabular.ResultsFilter(f1_, error_x=[0, 30], A=[5, 1e5])
if 'fitResults_z0' in f1_.keys():
threeD = True
if 'Events' in dir(f1.h5f.root):
events = f1.h5f.root.Events[:]
evKeyNames = set()
for e in events:
evKeyNames.add(e['EventName'])
if b'ProtocolFocus' in evKeyNames:
stack = True
xmax = f2['x'].max()
ymax = f2['y'].max()
if xmax > ymax:
step = xmax/thumbSize
else:
step = ymax/thumbSize
im, edx, edy = histogram2d(f2['x'], f2['y'], [arange(0, xmax, step), arange(0, ymax, step)])
f1.close()
im = minimum(2*(255*im)/im.max(), 255).T
im = concatenate((im[:,:,newaxis], im[:,:,newaxis], im[:,:,newaxis]), 2)
if stack:
im[-10:, -10:, 0] = 180
if threeD:
im[-10:, -10:, 1] = 180
if split:
im[-10:-5, :10, 1] = 210
im[-5:, :10, 0] = 210
return im.astype('uint8')
