def apply_filter(imp, radius=5, filtertype='MEDIAN'):
# initialize filter
filter = RankFilters()
# create filter dictionary for 2D rank filters
filterdict = {}
filterdict['MEAN'] = RankFilters.MEAN
filterdict['MIN'] = RankFilters.MIN
filterdict['MAX'] = RankFilters.MAX
filterdict['MEDIAN'] = RankFilters.MEDIAN
filterdict['VARIANCE'] = RankFilters.VARIANCE
filterdict['OPEN'] = RankFilters.OPEN
filterdict['DESPECKLE'] = RankFilters.DESPECKLE
filterdict['Mean'] = RankFilters.MEAN
filterdict['Min'] = RankFilters.MIN
filterdict['Max'] = RankFilters.MAX
filterdict['Median'] = RankFilters.MEDIAN
filterdict['Variance'] = RankFilters.VARIANCE
filterdict['Open'] = RankFilters.OPEN
filterdict['Despeckle'] = RankFilters.DESPECKLE
stack = imp.getStack() # get the stack within the ImagePlus
nslices = stack.getSize() # get the number of slices
# apply filter based on filtertype
if filtertype in filterdict:
for index in range(1, nslices + 1):
ip = stack.getProcessor(index)
filter.rank(ip, radius, filterdict[filtertype])
else:
print("Argument 'filtertype': {filtertype} not found")
return imp
def apply_filter(imp,
radius=5,
filtertype='MEDIAN'):
# initialize filter
filter = RankFilters()
# create filter dictionary
filterdict = {}
filterdict['MEAN'] = RankFilters.MEAN
filterdict['MIN'] = RankFilters.MIN
filterdict['MAX'] = RankFilters.MAX
filterdict['MEDIAN'] = RankFilters.MEDIAN
filterdict['VARIANCE'] = RankFilters.VARIANCE
filterdict['OPEN'] = RankFilters.OPEN
filterdict['DESPECKLE'] = RankFilters.DESPECKLE
# get the stack and number of slices
stack, nslices = getImageStack(imp)
for index in range(1, nslices + 1):
# get the image processor
ip = stack.getProcessor(index)
# apply filter based on filtertype
filter.rank(ip, radius, filterdict[filtertype])
return imp
def rankFilterMapImage(imp, radius=1.5, no=2):
"""clipNoisePixMapImage(imp, no=2)
Clips noise pixels from an X-ray map image (typically a 16 bit gray image).
First, it sets the display range to a noise offset to max and removes the noise
pixels (to get rid of isolated pixels), then converts to an 8 bit image that spans
0 to 255 and returns an 8 bit gray scale. This is ready for a hueLUT. It peforms
this on a duplicate imp and returns the resultant imp. To the best of my understanding,
this is how Oxford treats their maps w/o a 3x3 smooth.
Inputs:
imp - the input ImagePlus object
no - the noise offset, default = 2, to remove noise pixels
Returns:
ret - an ImapePlus for the 8-bit, scaled, filtered image
"""
stats = imp.getStatistics(Measurements.MIN_MAX)
imp.setDisplayRange(0, stats.max)
ret = imp.duplicate()
ip = ret.getProcessor()
data = ip.getPixels()
l = len(data)
for i in range(l):
val = data[i]
if val < no:
data[i] = 0
rf = RankFilters()
rf.rank(ret.getProcessor(), radius, RankFilters.MEDIAN)
IJ.run(ret, "8-bit", "")
name = imp.getShortTitle()
stats = ret.getStatistics(Measurements.MIN_MAX)
ret.setDisplayRange(0, stats.max)
ret.setTitle(name)
return ret
def apply_filter(imp,
radius=5,
filtertype='MEDIAN'):
# initialize Rank filter
filter = RankFilters()
# create filter dictionary
filterdict = {}
filterdict['MEAN'] = RankFilters.MEAN
filterdict['MIN'] = RankFilters.MIN
filterdict['MAX'] = RankFilters.MAX
filterdict['MEDIAN'] = RankFilters.MEDIAN
filterdict['VARIANCE'] = RankFilters.VARIANCE
filterdict['OPEN'] = RankFilters.OPEN
filterdict['DESPECKLE'] = RankFilters.DESPECKLE
# get the stack and number of slices
stack = imp.getStack() # get the stack within the ImagePlus
nslices = stack.getSize() # get the number of slices
# apply filter based on filtertype
if filtertype in filterdict:
for index in range(1, nslices + 1):
ip = stack.getProcessor(index)
filter.rank(ip, radius, filterdict[filtertype])
else:
#log.log(LogLevel.INFO, "Argument 'filtertype':" + str(filtertype) + " not found")
log.info("Argument 'filtertype': " + filtertype + " not found")
log.info('Image will not be filtered')
return imp
def stack_median_filter(imp, radius_um=5.0):
"""perform 2D median filtering slicewise on a stack"""
t1 = datetime.now();
stack = imp.getStack();
title = imp.getTitle();
n_z = imp.getNSlices();
progress_inc = 1 if n_z/20 < 1 else n_z/20;
filt = RankFilters();
for idx in range(n_z):
#print("Median filtering stack, {} % complete...".format(100 * round(float(zidx)/n_z, 3)));
ip = stack.getProcessor(idx+1);
filt.rank(ip, radius_um, RankFilters.MEDIAN);
IJ.showProgress(float(idx)/n_z);
if idx%progress_inc==0:
IJ.showStatus("Median filtering stack in 2D: {}/{}".format(idx, n_z));
imp.updateAndDraw();
imp.setTitle("Median filtered (r={}) {}".format(radius_um, imp.getTitle()).replace(".tif", ""));
t2 = datetime.now();
IJ.showProgress(1.0);
print("Median filtering took {} s".format((t2-t1).total_seconds()));
return imp;
def getCells(dicStack):
outStack = ImageStack(W,H)
cells = [None for t in range(T+1)]
for t in range(1,T+1):
mapp = dicStack.getProcessor(t).convertToFloatProcessor()
mapp.subtract( mapp.getStatistics().mean )
mapp.abs()
RankFilters().rank(mapp, 1.0, RankFilters.VARIANCE)
mapp.sqrt()
mapp.blurGaussian(5)
hist = mapp.getHistogram(256)
stats = mapp.getStatistics()
thresh = AutoThresholder().getThreshold( AutoThresholder.Method.Otsu, hist )
thresh = (thresh/float(255)) * (stats.max-stats.min) + stats.min
mask = ByteProcessor(W,H)
for i in range(W*H):
value = mapp.getf(i)
bite = 255 if value>=thresh else 0
mask.set(i, bite)
fillHoles(mask)
ed = 3
for e in range(ed): mask.erode(1, 0)
for d in range(ed): mask.dilate(1, 0)
watershed(mask)
minA = 5000 #px²
mask.setThreshold(255,255, ImageProcessor.NO_LUT_UPDATE)
composite = ThresholdToSelection().convert(mask)
rois = ShapeRoi(composite).getRois()
keep = []
for roi in rois:
if roi.getStatistics().area >= minA:
if not onEdge(roi):
keep.append(roi)
else:
edgeRoi = ShapeRoi(roi)
edgeRoi.setPosition(0,0,t)
edgeRoi.setStrokeColor(Color.YELLOW)
ol.add(edgeRoi)
print("T"+str(t)+" using "+str(len(keep))+"/"+str(len(rois))+" ROIs")
rois = keep
#rois = [ roi for roi in rois if roi.getStatistics().area >= minA and not onEdge(roi) ] #keep big enough and not on edges
# if there is only one Roi, cut it along the fitted ellipse minor axis
if len(rois)==1:
el = EllipseFitter()
mask.setRoi(rois[0])
el.fit(mask, None)
el.makeRoi(mask)
theta = el.angle * (maths.pi/180.0)
length = el.major/2.0
dy = maths.sin(theta)* length
dx = maths.cos(theta)* length
#major axis
lineX0 = el.xCenter - dx
lineY0 = el.yCenter + dy
lineX1 = el.xCenter + dx
lineY1 = el.yCenter - dy
line = Line(lineX0, lineY0, lineX1, lineY1)
line.setStrokeColor(Color.BLUE)
line.setStrokeWidth(1)
line.setPosition(0,0,t)
ol.add(line)
#minor axis scaled length to make sure cut ends are outside Roi
cutX0 = el.xCenter + dy*100
cutY0 = el.xCenter + dx*100
cutX1 = el.yCenter - dy*100
cutY1 = el.yCenter - dx*100
cut = Line(cutX0,cutY0, cutX1, cutY1)
cut.setStrokeWidth(2)
cut = PolygonRoi( cut.getFloatPolygon(), PolygonRoi.POLYGON )
mask.setColor(0)
mask.fill(cut)
composite = ThresholdToSelection().convert(mask)
rois = ShapeRoi(composite).getRois()
rois = [ roi for roi in rois if roi.getStatistics().area >= minA ]
print(str(t) + ":" + str(len(rois)))
rois = [ PolygonRoi(roi.getInterpolatedPolygon(20, True), PolygonRoi.POLYGON) for roi in rois ]
rois = [ PolygonRoi(roi.getConvexHull(), PolygonRoi.POLYGON) for roi in rois ]
rois = sorted(list(rois), key=lambda roi:roi.getLength() ) #size order
rois = rois[-2:] #keep 2 biggest
rois = sorted(list(rois), key=lambda roi:roi.getStatistics().xCentroid+roi.getStatistics().yCentroid ) #top left to bottom right order
if len(rois)>0:
rois[0].setStrokeColor(Color.RED)
rois[0].setPosition(0, 0, t)
ol.add(rois[0])
if len(rois)>1:
rois[1].setStrokeColor(Color.GREEN)
rois[1].setPosition(0, 0, t)
ol.add(rois[1])
cells[t] = (rois[0], rois[1])
return cells
from ij import IJ, ImagePlus from ij.plugin.filter import RankFilters imp = IJ.getImage() ip = imp.getProcessor().convertToFloat() # noise 제거를 위해서 media filter 적용 # radius = 2 radius = 2 # RankFilters class: mean, minimum, maximum, variance, outlier remval, despeckle 등이 구현됨. # RankFilters(): 새로운 RankFilters instance 생성 # .rank: RankFilters 내부 구현 method 호출. # https://javadoc.scijava.org/ImageJ1/ij/plugin/filter/RankFilters.html RankFilters().rank(ip, radius, RankFilters.MEDIAN) imp2 = ImagePlus(imp.title + "median_filtered", ip) imp2.show()
return rois
imp = IJ.getImage()
cal = imp.getCalibration()
stack = imp.getStack()
z = imp.getSlice()
ipGFP = stack.getProcessor(imp.getStackIndex(1, z,
1)).convertToFloatProcessor()
ipGFP.blurGaussian(4)
maskGFP = getMask(ipGFP, AutoThresholder.Method.Otsu)
roisGFP = getRois(maskGFP)
ipBF = stack.getProcessor(imp.getStackIndex(2, z, 1)).convertToFloatProcessor()
RankFilters().rank(ipBF, 1.0, RankFilters.VARIANCE)
ipBF.blurGaussian(5)
maskBF = getMask(ipBF, AutoThresholder.Method.Triangle)
roisBF = getRois(maskBF)
ipTomato = stack.getProcessor(imp.getStackIndex(3, z, 1)).duplicate()
sub = ipTomato.duplicate()
ipTomato.blurGaussian(5)
sub.blurGaussian(20)
ipTomato.copyBits(sub, 0, 0, Blitter.SUBTRACT)
maskTomato = getMask(ipTomato, AutoThresholder.Method.MaxEntropy)
roisTomato = getRois(maskTomato)
bfMeasure = stack.getProcessor(imp.getStackIndex(2, z, 1))
tomatoMeasure = stack.getProcessor(imp.getStackIndex(3, z, 1))
gfpMeasure = stack.getProcessor(imp.getStackIndex(1, z, 1))
processor = frame.getProcessor()
if(processor.getBitDepth() == 32):
processor.setMinAndMax(0, 1.0)
else:
processor.setMinAndMax(0, processor.maxValue())
frame = ImagePlus("Frame " + str(frame_i), processor)
# Convert to 8-bit, grayscale
converter = ImageConverter(frame)
converter.convertToGray8()
# Perform median filtering
processor = frame.getProcessor()
filters = RankFilters()
filters.setup("median", frame)
filters.rank(processor, filter_window, filters.MEDIAN)
# Perform gamma correction
processor.gamma(gamma)
frame = ImagePlus("Frame " + str(frame_i), processor)
# Rolling ball background subtraction
processor = frame.getProcessor()
bg_subtractor = BackgroundSubtracter()
bg_subtractor.setup("", frame)
bg_subtractor.rollingBallBackground(processor, rolling_ball_size/pixel_size, False, False, False, False, True)
def nucleusSegmentation(imp2):
""" Segmentation of nucleus image.
Nucleus are selected that:
1. No overlapping with dilated regions
2. close to circular shape. Deformed nuclei are rejected.
Outputs a binary image.
"""
#Convert to 8bit
ImageConverter(imp2).convertToGray8()
#blur slightly using Gaussian Blur
radius = 2.0
accuracy = 0.01
GaussianBlur().blurGaussian( imp2.getProcessor(), radius, radius, accuracy)
# Auto Local Thresholding
imps = ALT().exec(imp2, "Bernsen", 15, 0, 0, True)
imp2 = imps[0]
#ParticleAnalysis 0: prefiltering by size and circularity
rt = ResultsTable()
paOpt = PA.CLEAR_WORKSHEET +\
PA.SHOW_MASKS +\
PA.EXCLUDE_EDGE_PARTICLES +\
PA.INCLUDE_HOLES #+ \
# PA.SHOW_RESULTS
measOpt = PA.AREA + PA.STD_DEV + PA.SHAPE_DESCRIPTORS + PA.INTEGRATED_DENSITY
MINSIZE = 20
MAXSIZE = 10000
pa0 = PA(paOpt, measOpt, rt, MINSIZE, MAXSIZE, 0.8, 1.0)
pa0.setHideOutputImage(True)
pa0.analyze(imp2)
imp2 = pa0.getOutputImage() # Overwrite
imp2.getProcessor().invertLut()
#impNuc = imp2.duplicate() ## for the ring.
impNuc = Duplicator().run(imp2)
#Dilate the Nucleus Area
## this should be 40 pixels in Cihan's method, but should be smaller.
#for i in range(20):
# IJ.run(imp2, "Dilate", "")
rf = RankFilters()
rf.rank(imp2.getProcessor(), RIMSIZE, RankFilters.MAX)
#Particle Analysis 1: get distribution of sizes.
paOpt = PA.CLEAR_WORKSHEET +\
PA.SHOW_NONE +\
PA.EXCLUDE_EDGE_PARTICLES +\
PA.INCLUDE_HOLES #+ \
# PA.SHOW_RESULTS
measOpt = PA.AREA + PA.STD_DEV + PA.SHAPE_DESCRIPTORS + PA.INTEGRATED_DENSITY
rt1 = ResultsTable()
MINSIZE = 20
MAXSIZE = 10000
pa = PA(paOpt, measOpt, rt1, MINSIZE, MAXSIZE)
pa.analyze(imp2)
#rt.show('after PA 1')
#particle Analysis 2: filter nucleus by size and circularity.
#print rt1.getHeadings()
if (rt1.getColumnIndex('Area') > -1):
q1, q3, outlier_offset = getOutlierBound(rt1)
else:
q1 = MINSIZE
q3 = MAXSIZE
outlier_offset = 0
print imp2.getTitle(), ": no Nucleus segmented,probably too many overlaps"
paOpt = PA.CLEAR_WORKSHEET +\
PA.SHOW_MASKS +\
PA.EXCLUDE_EDGE_PARTICLES +\
PA.INCLUDE_HOLES #+ \
# PA.SHOW_RESULTS
rt2 = ResultsTable()
#pa = PA(paOpt, measOpt, rt, q1-outlier_offset, q3+outlier_offset, circq1-circoutlier_offset, circq3+circoutlier_offset)
pa = PA(paOpt, measOpt, rt2, q1-outlier_offset, q3+outlier_offset, 0.8, 1.0)
pa.setHideOutputImage(True)
pa.analyze(imp2)
impDilatedNuc = pa.getOutputImage()
#filter original nucleus
filteredNuc = ImageCalculator().run("AND create", impDilatedNuc, impNuc)
return filteredNuc