import ij.plugin.filter.RankFilters; //导入依赖的package包/类
@Override
protected void makeMeanAndVariance(ByteProcessor I, Parameters params) {
	FloatProcessor mean = (FloatProcessor) I.convertToFloat();
	FloatProcessor var =  (FloatProcessor) mean.duplicate();
	
	RankFilters rf = new RankFilters();
	rf.rank(mean, params.radius, RankFilters.MEAN);
	Imean = mean;
	
	rf.rank(var, params.radius, RankFilters.VARIANCE);
	var.sqrt();
	Isigma = var;
}
 

import ij.plugin.filter.RankFilters; //导入依赖的package包/类
static int median(final float[] values, final int nbValues) {
    final int m;
    if (nbValues < 1) {
        throw new IllegalArgumentException("Argument 'nbValues' cannot be less than 1.");
    }

    final int n = nbValues / 2;
    if (nbValues % 2 == 1) {
        m = Math.round(RankFilters.findNthLowestNumber(values, nbValues, n));
    } else {
        final float m1 = RankFilters.findNthLowestNumber(values, nbValues, n - 1);
        final float m2 = RankFilters.findNthLowestNumber(values, nbValues, n);
        m = Math.round((m1 + m2) / 2f);
    }

    return m;
}
 

import ij.plugin.filter.RankFilters; //导入依赖的package包/类
private final void removeOutliers(ImagePlus image, ProcessOptions processOption) {
        RemoveOutlierOptions options = (RemoveOutlierOptions)processOption;
        
        RankFilters rankFilters = new RankFilters();
        rankFilters.rank(image.getChannelProcessor(),
                         options.getRadius(),
                         RankFilters.OUTLIERS,
                         options.getWhichOutlier().intValue(),
                         options.getThreshold());
        
        image.updateImage();
        
        rankFilters = null;
}
 

import ij.plugin.filter.RankFilters; //导入依赖的package包/类
@Override
public ByteProcessor getThreshold(ByteProcessor I) {
	FloatProcessor mean = (FloatProcessor) I.convertToFloat();
	FloatProcessor var = (FloatProcessor) mean.duplicate();
	
	RankFilters rf = new RankFilters();
	rf.rank(mean, params.radius, RankFilters.MEAN);
	Imean = mean;
	
	rf.rank(var, params.radius, RankFilters.VARIANCE);
	var.sqrt();
	Isigma = var;
	
	int width = I.getWidth();
	int height = I.getHeight();
	final double kappa = params.kappa;
	final double sigmaMax = params.sigmaMax;
	final boolean darkBg = (params.bgMode == BackgroundMode.DARK);
	
	ByteProcessor Q = new ByteProcessor(width, height);
	for (int v = 0; v < height; v++) {
		for (int u = 0; u < width; u++) {
			final double sigma = Isigma.getf(u, v);
			final double mu = Imean.getf(u, v);
			final double diff = kappa * (sigma / sigmaMax - 1);
			int q = (int) Math.rint((darkBg) ? mu * (1 - diff) : mu	* (1 + diff));
			if (q < 0)
				q = 0;
			if (q > 255)
				q = 255;
			Q.set(u, v, q);
		}
	}
	return Q;
}
 

import ij.plugin.filter.RankFilters; //导入依赖的package包/类
@Override
public ByteProcessor getThreshold(ByteProcessor I) {
	final int M = I.getWidth();
	final int N = I.getHeight();
	ByteProcessor Imin = (ByteProcessor) I.duplicate();
	ByteProcessor Imax = (ByteProcessor) I.duplicate();

	RankFilters rf = new RankFilters();
	rf.rank(Imin, params.radius, RankFilters.MIN);
	rf.rank(Imax, params.radius, RankFilters.MAX);

	int q = (params.bgMode == BackgroundMode.DARK) ? 256 : 0;
	ByteProcessor Q = new ByteProcessor(M, N);

	for (int v = 0; v < N; v++) {
		for (int u = 0; u < M; u++) {
			int gMin = Imin.get(u, v);
			int gMax = Imax.get(u, v);
			int c = gMax - gMin;
			if (c >= params.cmin)
				Q.set(u, v, (gMin + gMax) / 2);
			else
				Q.set(u, v, q);
		}
	}
	return Q;
}
 

import ij.plugin.filter.RankFilters; //导入依赖的package包/类
public static double[] computeDensities(ByteProcessor bp, Polygon polyGrid, double coreDiameterPx) {
	RankFilters rf = new RankFilters();
	FloatProcessor fp = bp.convertToFloatProcessor();
	fp.max(1.0);
	rf.rank(fp, coreDiameterPx*0.5, RankFilters.MEAN);
	double[] densities = new double[polyGrid.npoints];
	for (int i = 0; i < densities.length; i++) {
		int x = polyGrid.xpoints[i];
		int y = polyGrid.ypoints[i];
		if (x >= 0 && y >= 0 && x < bp.getWidth() && y < bp.getHeight())
			densities[i] = fp.getf(x, y);
	}
	return densities;
}
 

import ij.plugin.filter.RankFilters; //导入依赖的package包/类
public static ImageProcessor openingByReconstruction(final ImageProcessor ip, final double radius) {
		// Apply (initial) morphological opening
		final RankFilters rf = new RankFilters();
		final ImageProcessor ipReconstructed = ip.duplicate();
		ipReconstructed.setRoi(ip.getRoi());
		rf.rank(ipReconstructed, radius, RankFilters.MIN);
//		if (ip.getRoi() == null)
//			rf.rank(ipReconstructed, radius, RankFilters.MAX);
		// Dilate opened image constrained by original image as a mask
		if (morphologicalReconstruction(ipReconstructed, ip))
			return ipReconstructed;
		return null;
	}
 

import ij.plugin.filter.RankFilters; //导入依赖的package包/类
public void comparePerformance() {
	try {
		ij.Prefs.setThreads(1);
		Img<UnsignedByteType> img = (Img<UnsignedByteType>) new ImgOpener().openImgs("/home/albert/Desktop/t2/bridge.tif").get(0);
		ImgLib.wrap(img, "Original");
		
		long t0 = System.currentTimeMillis();
		final UnsignedByteType min = new UnsignedByteType(0);
		final UnsignedByteType max = new UnsignedByteType(255);
		final int nBins = 128; // 32 delivers speeds close to ImageJ's when not using median
		final LinearHistogram<UnsignedByteType> lh = new LinearHistogram<UnsignedByteType>(nBins, img.numDimensions(), min, max);
		final Img<IntType> integralHistogram = IntegralHistogram.create(img, lh, new IntType());
		System.out.println("Creating integral histogram took " + (System.currentTimeMillis() - t0) + " ms");
		long[] radius = new long[]{25, 25}; // radius=1 is equivalent to ImageJ's radius=1 in RankFilters
		HistogramFeatures<UnsignedByteType, IntType> features =
				new HistogramFeatures<UnsignedByteType, IntType>(img, integralHistogram, lh, radius);
		long t1 = System.currentTimeMillis();
		
		ImagePlus imp = ImgLib.wrap(img);
		
		long t2 = System.currentTimeMillis();
		RankFilters rf = new RankFilters();
		ImageProcessor ip1 = imp.getProcessor().duplicate();
		rf.rank(ip1, radius[0], RankFilters.MIN);
		ImageProcessor ip2 = imp.getProcessor().duplicate();
		rf.rank(ip2, radius[0], RankFilters.MAX);
		ImageProcessor ip3 = imp.getProcessor().duplicate();
		rf.rank(ip3, radius[0], RankFilters.MEAN);
		ImageProcessor ip4 = imp.getProcessor().duplicate();
		rf.rank(ip4, radius[0], RankFilters.MEDIAN);
		long t3 = System.currentTimeMillis();
		
		System.out.println("Integral features: " + (t1 - t0) + " ms");
		System.out.println("Regular features: " + (t3 - t2) + " ms");
		
		// Show them both
		ImgLib.wrap(features, "Integral Histogram Features for " + radius[0] + "x" + radius[1]);
		ImageStack stack = new ImageStack(imp.getWidth(), imp.getHeight());
		stack.addSlice("min", ip1);
		stack.addSlice("max", ip2);
		stack.addSlice("mean", ip3);
		stack.addSlice("median", ip4);
		new ImagePlus("Regular features for " + radius[0] + "x" + radius[1], stack);
	} catch (Exception e) {
		e.printStackTrace();
	}
}
 

import ij.plugin.filter.RankFilters; //导入依赖的package包/类
@Override
public ImageProcessor process(ImageProcessor ip) {
	RankFilters rf = new RankFilters();
	rf.rank(ip, radius, RankFilters.MEDIAN);
	return ip;
}
 

import ij.plugin.filter.RankFilters; //导入依赖的package包/类
/**
 * Performs in-place dilation with a disk structuring element by calling the
 * ImageJ native RankFilters algorithm, using RankFilters.MAX option.
 * 
 * @param image the image to process
 */
@Override
public void inPlaceDilation(ImageProcessor image)
{
	new RankFilters().rank(image, radius, RankFilters.MAX);
}
 

import ij.plugin.filter.RankFilters; //导入依赖的package包/类
/**
 * Performs in-place erosion with a disk structuring element by calling the
 * ImageJ native RankFilters algorithm, using RankFilters.MIN option.
 * 
 * @param image the image to process
 */
@Override
public void inPlaceErosion(ImageProcessor image)
{
	new RankFilters().rank(image, radius, RankFilters.MIN);
}