def filterDoG(img, filterDoGParameter = None, size = None, sigma = None, sigma2 = None, save = None, verbose = None,
subStack = None, out = sys.stdout, **parameter):
"""Difference of Gaussians (DoG) filter step
Arguments:
img (array): image data
filterDoGParameter (dict):
========= ==================== ================================================================
Name Type Descritption
========= ==================== ================================================================
*size* (tuple or None) size for the DoG filter
if None, do not correct for any background
*sigma* (tuple or None) std of outer Guassian, if None autmatically determined from size
*sigma2* (tuple or None) std of inner Guassian, if None autmatically determined from size
*save* (str or None) file name to save result of this operation
if None dont save to file
*verbose* (bool or int) print progress information
========= ==================== ================================================================
subStack (dict or None): sub-stack information
out (object): object to write progress info to
Returns:
array: DoG filtered image
"""
timer = Timer();
dogSize = getParameter(filterDoGParameter, "size", size);
dogSigma = getParameter(filterDoGParameter, "sigma", sigma);
dogSigma2= getParameter(filterDoGParameter, "sigma2",sigma2);
dogSave = getParameter(filterDoGParameter, "save", save);
verbose = getParameter(filterDoGParameter, "verbose", verbose);
if verbose:
writeParameter(out = out, head = 'DoG:', size = dogSize, sigma = dogSigma, sigma2 = dogSigma2, save = dogSave);
#DoG filter
img = img.astype('float32'); # always convert to float for downstream processing
if not dogSize is None:
fdog = filterKernel(ftype = 'DoG', size = dogSize, sigma = dogSigma, sigma2 = dogSigma2);
fdog = fdog.astype('float32');
#img = correlate(img, fdog);
#img = scipy.signal.correlate(img, fdog);
img = correlate(img, fdog);
#img = convolve(img, fdog, mode = 'same');
img[img < 0] = 0;
if verbose > 1:
plotTiling(img);
if not dogSave is None:
writeSubStack(dogSave, img, subStack = subStack);
if verbose:
out.write(timer.elapsedTime(head = 'DoG') + '\n');
return img
def greyReconstruction(img, mask, greyReconstructionParameter = None, method = None, size = 3, save = None, verbose = False,
subStack = None, out = sys.stdout, **parameter):
"""Calculates the grey reconstruction of the image
Reconstruction is done z-slice by z-slice.
Arguments:
img (array): image data
removeBackGroundParameter (dict):
========= ==================== ===========================================================
Name Type Descritption
========= ==================== ===========================================================
*method* (tuple or None) 'dilation' or 'erosion', if None return original image
*size* (int or tuple) size of structuring element
*save* (str or None) file name to save result of this operation
if None dont save to file
*verbose* (bool or int) print / plot information about this step
========= ==================== ===========================================================
subStack (dict or None): sub-stack information
verbose (bool): print progress info
out (object): object to write progress info to
Returns:
array: grey reconstructed image
"""
method = getParameter(greyReconstructionParameter, "method", method);
size = getParameter(greyReconstructionParameter, "size", size);
save = getParameter(greyReconstructionParameter, "save", save);
verbose= getParameter(greyReconstructionParameter, "verbose", verbose);
if verbose:
writeParameter(out = out, head = 'Grey reconstruction:', method = method, size = size, save = save);
if method is None:
return img;
timer = Timer();
# background subtraction in each slice
se = structureElement('Disk', size).astype('uint8');
for z in range(img.shape[2]):
#img[:,:,z] = img[:,:,z] - grey_opening(img[:,:,z], structure = structureElement('Disk', (30,30)));
#img[:,:,z] = img[:,:,z] - morph.grey_opening(img[:,:,z], structure = self.structureELement('Disk', (150,150)));
img[:,:,z] = img[:,:,z] - reconstruct(img[:,:,z], method = method, selem = se)
if not save is None:
writeSubStack(save, img, subStack = subStack)
if verbose > 1:
plotTiling(img);
if verbose:
out.write(timer.elapsedTime(head = 'Grey reconstruction:') + '\n');
return img
def removeBackground(img, removeBackgroundParameter = None, size = None, save = None, verbose = False,
subStack = None, out = sys.stdout, **parameter):
"""Remove background via subtracting a morphological opening from the original image
Background removal is done z-slice by z-slice.
Arguments:
img (array): image data
removeBackGroundParameter (dict):
========= ==================== ===========================================================
Name Type Descritption
========= ==================== ===========================================================
*size* (tuple or None) size for the structure element of the morphological opening
if None, do not correct for any background
*save* (str or None) file name to save result of this operation
if None dont save to file
*verbose* (bool or int) print / plot information about this step
========= ==================== ===========================================================
subStack (dict or None): sub-stack information
verbose (bool): print progress info
out (object): object to write progress info to
Returns:
array: background corrected image
"""
size = getParameter(removeBackgroundParameter, "size", size);
save = getParameter(removeBackgroundParameter, "save", save);
verbose = getParameter(removeBackgroundParameter, "verbose", verbose);
if verbose:
writeParameter(out = out, head = 'Background Removal:', size = size, save = save);
if size is None:
return img;
img = io.readData(img);
timer = Timer();
# background subtraction in each slice
se = structureElement('Disk', size).astype('uint8');
for z in range(img.shape[2]):
#img[:,:,z] = img[:,:,z] - grey_opening(img[:,:,z], structure = structureElement('Disk', (30,30)));
#img[:,:,z] = img[:,:,z] - morph.grey_opening(img[:,:,z], structure = self.structureELement('Disk', (150,150)));
img[:,:,z] = img[:,:,z] - cv2.morphologyEx(img[:,:,z], cv2.MORPH_OPEN, se)
if not save is None:
writeSubStack(save, img, subStack = subStack)
if verbose > 1:
plotTiling(10*img);
if verbose:
out.write(timer.elapsedTime(head = 'Background') + '\n');
return img
def classifyPixel(img, classifyPixelParameter = None, subStack = None, verbose = False, out = sys.stdout, **parameter):
"""Detect Cells Using a trained classifier in Ilastik
Arguments:from ClearMap.ImageProcessing.CellSizeDetection import detectCellShape, findCellSize, findCellIntensity
img (array): image data
classifyPixelParameter (dict):
============ ==================== ===========================================================
Name Type Descritption
============ ==================== ===========================================================
*classifier* (str or None) Ilastik project file with trained pixel classifier
*save* (str or None) save the classification propabilities to a file
*verbose* (bool or int) print / plot information about this step
============ ==================== ===========================================================
subStack (dict or None): sub-stack information
verbose (bool): print progress info
out (object): object to write progress info to
Returns:
array: probabilities for each pixel to belong to a class in the classifier, shape is (img.shape, number of classes)
"""
ilastik.checkInitialized();
classifier = getParameter(classifyPixelParameter, "classifier", None);
save = getParameter(classifyPixelParameter, "save", None);
verbose = getParameter(classifyPixelParameter, "verbose", verbose);
if verbose:
writeParameter(out = out, head = 'Ilastik classification:', classifier = classifier, save = save);
timer = Timer();
#remove background
#img2 = removeBackground(img, verbose = verbose, out = out, **parameter);
#classify image
if classifier is None:
return img;
imgclass = ilastik.classifyPixel(classifier, img);
if not save is None:
for i in range(imgclass.shape[4]):
fn = save[:-4] + '_class_' + str(i) + save[-4:];
writeSubStack(fn, imgclass[:,:,:,i], subStack = subStack)
if verbose > 1:
for i in range(imgclass.shape[4]):
plotTiling(imgclass[:,:,:,i]);
if verbose:
out.write(timer.elapsedTime(head = 'Ilastik classification') + '\n');
return imgclass;
def classifyPixel(img, classifyPixelParameter = None, subStack = None, verbose = False, out = sys.stdout, **parameter):
"""Detect Cells Using a trained classifier in Ilastik
Arguments:from ClearMap.ImageProcessing.CellSizeDetection import detectCellShape, findCellSize, findCellIntensity
img (array): image data
classifyPixelParameter (dict):
============ ==================== ===========================================================
Name Type Descritption
============ ==================== ===========================================================
*classifier* (str or None) Ilastik project file with trained pixel classifier
*save* (str or None) save the classification propabilities to a file
*verbose* (bool or int) print / plot information about this step
============ ==================== ===========================================================
subStack (dict or None): sub-stack information
verbose (bool): print progress info
out (object): object to write progress info to
Returns:
array: probabilities for each pixel to belong to a class in the classifier, shape is (img.shape, number of classes)
"""
ilastik.checkInitialized();
classifier = getParameter(classifyPixelParameter, "classifier", None);
save = getParameter(classifyPixelParameter, "save", None);
verbose = getParameter(classifyPixelParameter, "verbose", verbose);
if verbose:
writeParameter(out = out, head = 'Ilastik classification:', classifier = classifier, save = save);
timer = Timer();
#remove background
#img2 = removeBackground(img, verbose = verbose, out = out, **parameter);
#classify image
if classifier is None:
return img;
imgclass = ilastik.classifyPixel(classifier, img);
if not save is None:
for i in range(imgclass.shape[4]):
fn = save[:-4] + '_class_' + str(i) + save[-4:];
writeSubStack(fn, imgclass[:,:,:,i], subStack = subStack)
if verbose > 1:
for i in range(imgclass.shape[4]):
plotTiling(imgclass[:,:,:,i]);
if verbose:
out.write(timer.elapsedTime(head = 'Ilastik classification') + '\n');
return imgclass;
def classifyCells(img, classifyCellsParameter = None, classifier = None, classindex = 0, save = None, verbose = False,
detectCellShapeParameter = None,
subStack = None, out = sys.stdout, **parameter):
"""Detect Cells Using a trained classifier in Ilastik
The routine assumes that the first class is identifying the cells.
Arguments:
img (array): image data
classifyPixelParameter (dict):
============ ==================== ===========================================================
Name Type Descritption
============ ==================== ===========================================================
*classifier* (str or None) Ilastik project file with trained pixel classifier
*classindex* (int) class index considered to be cells
*save* (str or None) save the detected cell pixel to a file
*verbose* (bool or int) print / plot information about this step
============ ==================== ===========================================================
subStack (dict or None): sub-stack information
verbose (bool): print progress info
out (object): object to write progress info to
Returns:
tuple: centers of the cells, intensity measurments
Note:
The routine could be potentially refined to make use of background
detection in ilastik
"""
classifier = getParameter(classifyCellsParameter, "classifier", classifier);
classindex = getParameter(classifyCellsParameter, "classindex", classindex);
save = getParameter(classifyCellsParameter, "save", save);
verbose = getParameter(classifyCellsParameter, "verbose", verbose);
if verbose:
writeParameter(out = out, head = 'Ilastik cell detection:', classifier = classifier, classindex = classindex, save = save);
timer = Timer();
ilastik.isInitialized();
#remove background
#img = removeBackground(img, verbose = verbose, out = out, **parameter);
#classify image / assume class 1 are the cells !
timer = Timer();
imgmax = ilastik.classifyPixel(classifier, img);
#print imgmax.shape
#max probability gives final class, last axis is class axis
imgmax = numpy.argmax(imgmax, axis = -1);
if save:
writeSubStack(save, numpy.asarray(imgmax, dtype = 'float32'), subStack = subStack)
# class 0 is used as cells
imgmax = imgmax == classindex; # class 1 is used as cells
imgshape, nlab = sm.label(imgmax);
if verbose > 1:
plotTiling(imgmax);
#center of maxima
centers = findCenterOfMaxima(img, imgmax, imgshape, verbose = verbose, out = out, **parameter);
#intensity of cells
#cintensity = findIntensity(img, centers, verbose = verbose, out = out, **parameter);
#intensity of cells in filtered image
#cintensity2 = findIntensity(img, centers, verbose = verbose, out = out, **parameter);
#if verbose:
# out.write(timer.elapsedTime(head = 'Ilastik cell detection') + '\n');
#return ( centers, numpy.vstack((cintensity, cintensity2)).transpose() );
#return ( centers, cintensity );
#cell size detection
#detectCellShapeParameter = getParameter(classifyCellsParameter, "detectCellShapeParameter", detectCellShapeParameter);
#cellShapeThreshold = getParameter(detectCellShapeParameter, "threshold", None);
#if not cellShapeThreshold is None:
# cell shape via watershed
#imgshape = detectCellShape(img, centers, detectCellShapeParameter = detectCellShapeParameter, verbose = verbose, out = out, **parameter);
#size of cells
csize = findCellSize(imgshape, maxLabel = centers.shape[0], out = out, **parameter);
#intensity of cells
cintensity = findCellIntensity(img, imgshape, maxLabel = centers.shape[0], verbose = verbose, out = out, **parameter);
#intensity of cells in background image
#cintensity2 = findCellIntensity(img2, imgshape, maxLabel = centers.shape[0], verbose = verbose, out = out, **parameter);
#intensity of cells in dog filtered image
#if dogSize is None:
# cintensity3 = cintensity2;
#else:
# cintensity3 = findCellIntensity(img3, imgshape, maxLabel = centers.shape[0], verbose = verbose, out = out, **parameter);
if verbose:
out.write(timer.elapsedTime(head = 'Ilastik Cell Detection') + '\n');
#remove cell;s of size 0
idz = csize > 0;
#return ( centers[idz], numpy.vstack((cintensity[idz], cintensity3[idz], cintensity2[idz], csize[idz])).transpose());
return ( centers[idz], numpy.vstack((cintensity[idz], csize[idz])).transpose() );
def classifyCells(img, classifyCellsParameter = None, classifier = None, classindex = 0, save = None, verbose = False,
detectCellShapeParameter = None,
subStack = None, out = sys.stdout, **parameter):
"""Detect Cells Using a trained classifier in Ilastik
The routine assumes that the first class is identifying the cells.
Arguments:
img (array): image data
classifyPixelParameter (dict):
============ ==================== ===========================================================
Name Type Descritption
============ ==================== ===========================================================
*classifier* (str or None) Ilastik project file with trained pixel classifier
*classindex* (int) class index considered to be cells
*save* (str or None) save the detected cell pixel to a file
*verbose* (bool or int) print / plot information about this step
============ ==================== ===========================================================
subStack (dict or None): sub-stack information
verbose (bool): print progress info
out (object): object to write progress info to
Returns:
tuple: centers of the cells, intensity measurments
Note:
The routine could be potentially refined to make use of background
detection in ilastik
"""
classifier = getParameter(classifyCellsParameter, "classifier", classifier);
classindex = getParameter(classifyCellsParameter, "classindex", classindex);
save = getParameter(classifyCellsParameter, "save", save);
verbose = getParameter(classifyCellsParameter, "verbose", verbose);
if verbose:
writeParameter(out = out, head = 'Ilastik cell detection:', classifier = classifier, classindex = classindex, save = save);
timer = Timer();
ilastik.isInitialized();
#remove background
#img = removeBackground(img, verbose = verbose, out = out, **parameter);
#classify image / assume class 1 are the cells !
timer = Timer();
imgmax = ilastik.classifyPixel(classifier, img);
#print imgmax.shape
#max probability gives final class, last axis is class axis
imgmax = numpy.argmax(imgmax, axis = -1);
if save:
writeSubStack(save, numpy.asarray(imgmax, dtype = 'float32'), subStack = subStack)
# class 0 is used as cells
imgmax = imgmax == classindex; # class 1 is used as cells
imgshape, nlab = sm.label(imgmax);
if verbose > 1:
plotTiling(imgmax);
#center of maxima
centers = findCenterOfMaxima(img, imgmax, imgshape, verbose = verbose, out = out, **parameter);
#intensity of cells
#cintensity = findIntensity(img, centers, verbose = verbose, out = out, **parameter);
#intensity of cells in filtered image
#cintensity2 = findIntensity(img, centers, verbose = verbose, out = out, **parameter);
#if verbose:
# out.write(timer.elapsedTime(head = 'Ilastik cell detection') + '\n');
#return ( centers, numpy.vstack((cintensity, cintensity2)).transpose() );
#return ( centers, cintensity );
#cell size detection
#detectCellShapeParameter = getParameter(classifyCellsParameter, "detectCellShapeParameter", detectCellShapeParameter);
#cellShapeThreshold = getParameter(detectCellShapeParameter, "threshold", None);
#if not cellShapeThreshold is None:
# cell shape via watershed
#imgshape = detectCellShape(img, centers, detectCellShapeParameter = detectCellShapeParameter, verbose = verbose, out = out, **parameter);
#size of cells
csize = findCellSize(imgshape, maxLabel = centers.shape[0], out = out, **parameter);
#intensity of cells
cintensity = findCellIntensity(img, imgshape, maxLabel = centers.shape[0], verbose = verbose, out = out, **parameter);
#intensity of cells in background image
#cintensity2 = findCellIntensity(img2, imgshape, maxLabel = centers.shape[0], verbose = verbose, out = out, **parameter);
#intensity of cells in dog filtered image
#if dogSize is None:
# cintensity3 = cintensity2;
#else:
# cintensity3 = findCellIntensity(img3, imgshape, maxLabel = centers.shape[0], verbose = verbose, out = out, **parameter);
if verbose:
out.write(timer.elapsedTime(head = 'Ilastik Cell Detection') + '\n');
#remove cell;s of size 0
idz = csize > 0;
#return ( centers[idz], numpy.vstack((cintensity[idz], cintensity3[idz], cintensity2[idz], csize[idz])).transpose());
return ( centers[idz], numpy.vstack((cintensity[idz], csize[idz])).transpose() );
def correctIllumination(img, correctIlluminationParameter = None, flatfield = None, background = None, scaling = None, save = None, verbose = False,
subStack = None, out = sys.stdout, **parameter):
"""Correct illumination variations
The intensity image :math:`I(x)` given a flat field :math:`F(x)` and
a background :math:`B(x)` the image is corrected to :math:`C(x)` as:
.. math:
C(x) = \\frac{I(x) - B(x)}{F(x) - B(x)}
If the background is not given :math:`B(x) = 0`.
The correction is done slice by slice assuming the data was collected with
a light sheet microscope.
The image is finally optionally scaled.
Arguments:
img (array): image data
findCenterOfMaximaParameter (dict):
============ ==================== ===========================================================
Name Type Descritption
============ ==================== ===========================================================
*flatfield* (str, None or array) flat field intensities, if None d onot correct image for
illumination, if True the
*background* (str, None or array) background image as file name or array
if None background is assumed to be zero
*scaling* (str or None) scale the corrected result by this factor
if 'max'/'mean' scale to keep max/mean invariant
*save* (str or None) save the corrected image to file
*verbose* (bool or int) print / plot information about this step
============ ==================== ===========================================================
subStack (dict or None): sub-stack information
verbose (bool): print progress info
out (object): object to write progress info to
Returns:
array: illumination corrected image
References:
Fundamentals of Light Microscopy and Electronic Imaging, p 421
See Also:
:const:`DefaultFlatFieldLineFile`
"""
flatfield = getParameter(correctIlluminationParameter, "flatfield", flatfield);
background = getParameter(correctIlluminationParameter, "background", background);
scaling = getParameter(correctIlluminationParameter, "scaling", scaling);
save = getParameter(correctIlluminationParameter, "save", save);
verbose = getParameter(correctIlluminationParameter, "verbose", verbose);
if verbose:
if flatfield is None or isinstance(flatfield, str) or flatfield is True:
fld = flatfield;
else:
fld = "image of size %s" % str(flatfield.shape);
if background is None or isinstance(background, str):
bkg = background;
else:
bkg = "image of size %s" % str(background.shape);
writeParameter(out = out, head = 'Illumination correction:', flatfield = fld, background = bkg, scaling = scaling, save = save);
print subStack;
if not subStack is None:
x = subStack["x"];
y = subStack["y"];
else:
x = all;
y = all;
#print "sizes", x, y, img.shape
#read data
timer = Timer();
if flatfield is None:
return img;
elif flatfield is True:
# default flatfield correction
if subStack is None:
flatfield = flatfieldFromLine(DefaultFlatFieldLineFile, img.shape[0]);
else:
dataSize = io.dataSize(subStack["source"]);
flatfield = flatfieldFromLine(DefaultFlatFieldLineFile, dataSize[0]);
elif isinstance(flatfield, str):
# point or image file
if io.isPointFile(flatfield):
if subStack is None:
flatfield = flatfieldFromLine(flatfield, img.shape[0]);
else:
dataSize = io.dataSize(subStack["source"]);
flatfield = flatfieldFromLine(flatfield, dataSize[0]);
else:
flatfield = io.readData(flatfield);
ffmean = flatfield.mean();
ffmax = flatfield.max();
#correct for subset
flatfield = io.readData(flatfield, x = x, y = y);
background = io.readData(background, x = x, y = y);
if flatfield.shape != img[:,:,0].shape:
raise RuntimeError("correctIllumination: flatfield does not match image size: %s vs %s" % (flatfield.shape, img[:,:,0].shape));
#convert to float for scaling
dtype = img.dtype;
img = img.astype('float32');
flatfield = flatfield.astype('float32');
# illumination correction in each slice
if background is None:
for z in range(img.shape[2]):
img[:,:,z] = img[:,:,z] / flatfield;
else:
if background.shape != flatfield.shape:
raise RuntimeError("correctIllumination: background does not match image size: %s vs %s" % (background.shape, img[:,:,0].shape));
background = background.astype('float32');
flatfield = (flatfield - background);
for z in range(img.shape[2]):
img[:,:,z] = (img[:,:,z] - background) / flatfield;
# rescale
if scaling is True:
scaling = "mean";
if isinstance(scaling, str):
if scaling.lower() == "mean":
# scale back by average flat field correction:
sf = ffmean;
elif scaling.lower() == "max":
sf = ffmax;
else:
raise RuntimeError('Scaling not "Max" or "Mean" but %s' % scaling);
else:
sf = scaling;
if verbose:
writeParameter(out = out, head = 'Illumination correction:', scaling = sf);
if not sf is None:
img = img * sf;
img = img.astype(dtype);
#write result for inspection
if not save is None:
writeSubStack(save, img, subStack = subStack);
#plot result for inspection
if verbose > 1:
plotTiling(img);
if verbose:
out.write(timer.elapsedTime(head = 'Illumination correction') + '\n');
return img
def filterLinear(img,
filterLinearParameter=None,
ftype=None,
size=None,
sigma=None,
sigma2=None,
save=None,
subStack=None,
verbose=False,
out=sys.stdout,
**parameter):
"""Applies a linear filter to the image
Arguments:
img (array): image data
filterLinearParameter (dict):
========= ==================== ================================================================
Name Type Descritption
========= ==================== ================================================================
*ftype* (str or None) the type of the filter, see :ref:`FilterTypes`
if None do ot perform any fitlering
*size* (tuple or None) size for the filter
if None, do not perform filtering
*sigma* (tuple or None) std of outer Guassian, if None autmatically determined from size
*sigma2* (tuple or None) std of inner Guassian, if None autmatically determined from size
*save* (str or None) file name to save result of this operation
if None dont save to file
*verbose* (bool or int) print progress information
========= ==================== ================================================================
subStack (dict or None): sub-stack information
verbose (bool): print progress info
out (object): object to write progress info to
Returns:
array: filtered image
Note:
Converts image to float32 type if filter is active!
"""
timer = Timer()
ftype = getParameter(filterLinearParameter, "ftype", ftype)
size = getParameter(filterLinearParameter, "size", size)
sigma = getParameter(filterLinearParameter, "sigma", sigma)
sigma2 = getParameter(filterLinearParameter, "sigma2", sigma2)
save = getParameter(filterLinearParameter, "save", save)
verbose = getParameter(filterLinearParameter, "verbose", verbose)
if verbose:
writeParameter(out=out,
head='Linear Filter:',
ftype=ftype,
size=size,
sigma=sigma,
sigma2=sigma2,
save=save)
if ftype is None:
return img
#DoG filter
img = img.astype('float32')
# always convert to float for downstream processing
if not size is None:
fil = filterKernel(ftype=ftype, size=size, sigma=sigma, sigma2=sigma2)
fil = fil.astype('float32')
#img = correlate(img, fdog);
#img = scipy.signal.correlate(img, fdog);
img = correlate(img, fil)
#img = convolve(img, fdog, mode = 'same');
img[img < 0] = 0
if verbose > 1:
plotTiling(img)
if not save is None:
writeSubStack(save, img, subStack=subStack)
if verbose:
out.write(timer.elapsedTime(head='Linear Filter') + '\n')
return img
def greyReconstruction(img,
mask,
greyReconstructionParameter=None,
method=None,
size=3,
save=None,
verbose=False,
subStack=None,
out=sys.stdout,
**parameter):
"""Calculates the grey reconstruction of the image
Reconstruction is done z-slice by z-slice.
Arguments:
img (array): image data
removeBackGroundParameter (dict):
========= ==================== ===========================================================
Name Type Descritption
========= ==================== ===========================================================
*method* (tuple or None) 'dilation' or 'erosion', if None return original image
*size* (int or tuple) size of structuring element
*save* (str or None) file name to save result of this operation
if None dont save to file
*verbose* (bool or int) print / plot information about this step
========= ==================== ===========================================================
subStack (dict or None): sub-stack information
verbose (bool): print progress info
out (object): object to write progress info to
Returns:
array: grey reconstructed image
"""
method = getParameter(greyReconstructionParameter, "method", method)
size = getParameter(greyReconstructionParameter, "size", size)
save = getParameter(greyReconstructionParameter, "save", save)
verbose = getParameter(greyReconstructionParameter, "verbose", verbose)
if verbose:
writeParameter(out=out,
head='Grey reconstruction:',
method=method,
size=size,
save=save)
if method is None:
return img
timer = Timer()
# background subtraction in each slice
se = structureElement('Disk', size).astype('uint8')
for z in range(img.shape[2]):
#img[:,:,z] = img[:,:,z] - grey_opening(img[:,:,z], structure = structureElement('Disk', (30,30)));
#img[:,:,z] = img[:,:,z] - morph.grey_opening(img[:,:,z], structure = self.structureELement('Disk', (150,150)));
img[:, :, z] = img[:, :, z] - reconstruct(
img[:, :, z], method=method, selem=se)
if not save is None:
writeSubStack(save, img, subStack=subStack)
if verbose > 1:
plotTiling(img)
if verbose:
out.write(timer.elapsedTime(head='Grey reconstruction:') + '\n')
return img
def correctIllumination(img,
correctIlluminationParameter=None,
flatfield=None,
background=None,
scaling=None,
save=None,
verbose=False,
subStack=None,
out=sys.stdout,
**parameter):
"""Correct illumination variations
The intensity image :math:`I(x)` given a flat field :math:`F(x)` and
a background :math:`B(x)` the image is corrected to :math:`C(x)` as:
.. math:
C(x) = \\frac{I(x) - B(x)}{F(x) - B(x)}
If the background is not given :math:`B(x) = 0`.
The correction is done slice by slice assuming the data was collected with
a light sheet microscope.
The image is finally optionally scaled.
Arguments:
img (array): image data
findCenterOfMaximaParameter (dict):
============ ==================== ===========================================================
Name Type Descritption
============ ==================== ===========================================================
*flatfield* (str, None or array) flat field intensities, if None d onot correct image for
illumination, if True the
*background* (str, None or array) background image as file name or array
if None background is assumed to be zero
*scaling* (str or None) scale the corrected result by this factor
if 'max'/'mean' scale to keep max/mean invariant
*save* (str or None) save the corrected image to file
*verbose* (bool or int) print / plot information about this step
============ ==================== ===========================================================
subStack (dict or None): sub-stack information
verbose (bool): print progress info
out (object): object to write progress info to
Returns:
array: illumination corrected image
References:
Fundamentals of Light Microscopy and Electronic Imaging, p 421
See Also:
:const:`DefaultFlatFieldLineFile`
"""
flatfield = getParameter(correctIlluminationParameter, "flatfield",
flatfield)
background = getParameter(correctIlluminationParameter, "background",
background)
scaling = getParameter(correctIlluminationParameter, "scaling", scaling)
save = getParameter(correctIlluminationParameter, "save", save)
verbose = getParameter(correctIlluminationParameter, "verbose", verbose)
if verbose:
if flatfield is None or isinstance(flatfield,
str) or flatfield is True:
fld = flatfield
else:
fld = "image of size %s" % str(flatfield.shape)
if background is None or isinstance(background, str):
bkg = background
else:
bkg = "image of size %s" % str(background.shape)
writeParameter(out=out,
head='Illumination correction:',
flatfield=fld,
background=bkg,
scaling=scaling,
save=save)
print subStack
if not subStack is None:
x = subStack["x"]
y = subStack["y"]
else:
x = all
y = all
#print "sizes", x, y, img.shape
#read data
timer = Timer()
if flatfield is None:
return img
elif flatfield is True:
# default flatfield correction
if subStack is None:
flatfield = flatfieldFromLine(DefaultFlatFieldLineFile,
img.shape[0])
else:
dataSize = io.dataSize(subStack["source"])
flatfield = flatfieldFromLine(DefaultFlatFieldLineFile,
dataSize[0])
elif isinstance(flatfield, str):
# point or image file
if io.isPointFile(flatfield):
if subStack is None:
flatfield = flatfieldFromLine(flatfield, img.shape[0])
else:
dataSize = io.dataSize(subStack["source"])
flatfield = flatfieldFromLine(flatfield, dataSize[0])
else:
flatfield = io.readData(flatfield)
ffmean = flatfield.mean()
ffmax = flatfield.max()
#correct for subset
flatfield = io.readData(flatfield, x=x, y=y)
background = io.readData(background, x=x, y=y)
if flatfield.shape != img[:, :, 0].shape:
raise RuntimeError(
"correctIllumination: flatfield does not match image size: %s vs %s"
% (flatfield.shape, img[:, :, 0].shape))
#convert to float for scaling
dtype = img.dtype
img = img.astype('float32')
flatfield = flatfield.astype('float32')
# illumination correction in each slice
if background is None:
for z in range(img.shape[2]):
img[:, :, z] = img[:, :, z] / flatfield
else:
if background.shape != flatfield.shape:
raise RuntimeError(
"correctIllumination: background does not match image size: %s vs %s"
% (background.shape, img[:, :, 0].shape))
background = background.astype('float32')
flatfield = (flatfield - background)
for z in range(img.shape[2]):
img[:, :, z] = (img[:, :, z] - background) / flatfield
# rescale
if scaling is True:
scaling = "mean"
if isinstance(scaling, str):
if scaling.lower() == "mean":
# scale back by average flat field correction:
sf = ffmean
elif scaling.lower() == "max":
sf = ffmax
else:
raise RuntimeError('Scaling not "Max" or "Mean" but %s' % scaling)
else:
sf = scaling
if verbose:
writeParameter(out=out, head='Illumination correction:', scaling=sf)
if not sf is None:
img = img * sf
img = img.astype(dtype)
#write result for inspection
if not save is None:
writeSubStack(save, img, subStack=subStack)
#plot result for inspection
if verbose > 1:
plotTiling(img)
if verbose:
out.write(timer.elapsedTime(head='Illumination correction') + '\n')
return img
def filterDoG(img,
filterDoGParameter=None,
size=None,
sigma=None,
sigma2=None,
save=None,
verbose=None,
subStack=None,
out=sys.stdout,
**parameter):
"""Difference of Gaussians (DoG) filter step
Arguments:
img (array): image data
filterDoGParameter (dict):
========= ==================== ================================================================
Name Type Descritption
========= ==================== ================================================================
*size* (tuple or None) size for the DoG filter
if None, do not correct for any background
*sigma* (tuple or None) std of outer Guassian, if None autmatically determined from size
*sigma2* (tuple or None) std of inner Guassian, if None autmatically determined from size
*save* (str or None) file name to save result of this operation
if None dont save to file
*verbose* (bool or int) print progress information
========= ==================== ================================================================
subStack (dict or None): sub-stack information
out (object): object to write progress info to
Returns:
array: DoG filtered image
"""
timer = Timer()
dogSize = getParameter(filterDoGParameter, "size", size)
dogSigma = getParameter(filterDoGParameter, "sigma", sigma)
dogSigma2 = getParameter(filterDoGParameter, "sigma2", sigma2)
dogSave = getParameter(filterDoGParameter, "save", save)
verbose = getParameter(filterDoGParameter, "verbose", verbose)
if verbose:
writeParameter(out=out,
head='DoG:',
size=dogSize,
sigma=dogSigma,
sigma2=dogSigma2,
save=dogSave)
#DoG filter
img = img.astype('float32')
# always convert to float for downstream processing
if not dogSize is None:
fdog = filterKernel(ftype='DoG',
size=dogSize,
sigma=dogSigma,
sigma2=dogSigma2)
fdog = fdog.astype('float32')
#img = correlate(img, fdog);
#img = scipy.signal.correlate(img, fdog);
img = correlate(img, fdog)
#img = convolve(img, fdog, mode = 'same');
img[img < 0] = 0
if verbose > 1:
plotTiling(img)
if not dogSave is None:
writeSubStack(dogSave, img, subStack=subStack)
if verbose:
out.write(timer.elapsedTime(head='DoG') + '\n')
return img
def filterLinear(img, filterLinearParameter = None, ftype = None, size = None, sigma = None, sigma2 = None, save = None,
subStack = None, verbose = False, out = sys.stdout, **parameter):
"""Applies a linear filter to the image
Arguments:
img (array): image data
filterLinearParameter (dict):
========= ==================== ================================================================
Name Type Descritption
========= ==================== ================================================================
*ftype* (str or None) the type of the filter, see :ref:`FilterTypes`
if None do ot perform any fitlering
*size* (tuple or None) size for the filter
if None, do not perform filtering
*sigma* (tuple or None) std of outer Guassian, if None autmatically determined from size
*sigma2* (tuple or None) std of inner Guassian, if None autmatically determined from size
*save* (str or None) file name to save result of this operation
if None dont save to file
*verbose* (bool or int) print progress information
========= ==================== ================================================================
subStack (dict or None): sub-stack information
verbose (bool): print progress info
out (object): object to write progress info to
Returns:
array: filtered image
Note:
Converts image to float32 type if filter is active!
"""
timer = Timer();
ftype = getParameter(filterLinearParameter, "ftype", ftype);
size = getParameter(filterLinearParameter, "size", size);
sigma = getParameter(filterLinearParameter, "sigma", sigma);
sigma2 = getParameter(filterLinearParameter, "sigma2", sigma2);
save = getParameter(filterLinearParameter, "save", save);
verbose = getParameter(filterLinearParameter, "verbose",verbose);
if verbose:
writeParameter(out = out, head = 'Linear Filter:', ftype = ftype, size = size, sigma = sigma, sigma2 = sigma2, save = save);
if ftype is None:
return img;
#DoG filter
img = img.astype('float32'); # always convert to float for downstream processing
if not size is None:
fil = filterKernel(ftype = ftype, size = size, sigma = sigma, sigma2 = sigma2);
fil = fil.astype('float32');
#img = correlate(img, fdog);
#img = scipy.signal.correlate(img, fdog);
img = correlate(img, fil);
#img = convolve(img, fdog, mode = 'same');
img[img < 0] = 0;
if verbose > 1:
plotTiling(img);
if not save is None:
writeSubStack(save, img, subStack = subStack);
if verbose:
out.write(timer.elapsedTime(head = 'Linear Filter') + '\n');
return img
