return ColorTools.blue(rgb); case RGB_mean: return rgbMean(rgb); case Red_chromaticity: return redChromaticity(rgb); case Green_chromaticity: return greenChromaticity(rgb); case Blue_chromaticity: return blueChromaticity(rgb); case Green_divided_by_blue: return greenOverBlue(rgb); case Brown: return brown(rgb); case Hematoxylin_H_E: return deconvolve(rgb, ColorTransformer.inv_H_E, od_lut, 1); case Eosin_H_E: return deconvolve(rgb, ColorTransformer.inv_H_E, od_lut, 2); case Hematoxylin_H_DAB: return deconvolve(rgb, ColorTransformer.inv_H_DAB, od_lut, 1); case DAB_H_DAB: return deconvolve(rgb, ColorTransformer.inv_H_DAB, od_lut, 2); case White: return Float.NaN; return Float.NaN; case Optical_density_sum: return opticalDensitySum(rgb, od_lut); case Hue: return hue(rgb);
@Override public int getRGB(BufferedImage img, int x, int y, boolean useColorLUT) { return ColorTransformer.getODNormalizedColor(img.getRGB(x, y), 0.1, 0, 1); }
public static float[] getTransformedMinAndMax(int[] buf, ColorTransformMethod method) { if (method == ColorTransformMethod.Original || method == ColorTransformMethod.Red || method == ColorTransformMethod.Green || method == ColorTransformMethod.Blue) return new float[]{0f, 255f}; if (method == ColorTransformMethod.White || method == ColorTransformMethod.Black) return new float[]{0f, 1f}; if (method == ColorTransformMethod.Hematoxylin_H_E || method == ColorTransformMethod.Hematoxylin_H_DAB || method == ColorTransformMethod.Eosin_H_E || method == ColorTransformMethod.DAB_H_DAB) return new float[]{0f, 2.f}; if (method == ColorTransformMethod.Hue || method == ColorTransformMethod.Saturation || method == ColorTransformMethod.Brightness) return new float[]{0f, 1f}; // if (method == IntColorMethod.Red_chromaticity || method == IntColorMethod.Green_chromaticity || method == IntColorMethod.Blue_chromaticity) float min = Float.POSITIVE_INFINITY; float max = Float.NEGATIVE_INFINITY; for (int v : buf) { float val = ColorTransformer.getPixelValue(v, method); if (val < min) min = val; if (val > max) max = val; } return new float[]{min, max}; }
case RGB_mean: for (int i = 0; i < buf.length; i++) { pixels[i] = ColorTransformer.rgbMean(buf[i]); pixels[i] = ColorTransformer.redChromaticity(buf[i]); pixels[i] = ColorTransformer.greenChromaticity(buf[i]); pixels[i] = ColorTransformer.blueChromaticity(buf[i]); pixels[i] = ColorTransformer.greenOverBlue(buf[i]); pixels[i] = ColorTransformer.brown(buf[i]); inverse = stains.getMatrixInverse(); for (int i = 0; i < buf.length; i++) { pixels[i] = ColorTransformer.deconvolve(buf[i], inverse, od_lut_red, od_lut_green, od_lut_blue, 1); inverse = stains.getMatrixInverse(); for (int i = 0; i < buf.length; i++) { pixels[i] = ColorTransformer.deconvolve(buf[i], inverse, od_lut_red, od_lut_green, od_lut_blue, 2); inverse = stains.getMatrixInverse(); for (int i = 0; i < buf.length; i++) { pixels[i] = ColorTransformer.deconvolve(buf[i], inverse, od_lut_red, od_lut_green, od_lut_blue, 3); inverse = stains.getMatrixInverse(); for (int i = 0; i < buf.length; i++) { pixels[i] = ColorTransformer.deconvolve(buf[i], inverse, od_lut_red, od_lut_green, od_lut_blue, 1);
case RGB_mean: for (int i = 0; i < buf.length; i++) { bufOutput[i] = makeScaledRGBwithRangeCheck(ColorTransformer.rgbMean(buf[i]), offset, scale, cm) & ~ColorTools.MASK_ALPHA | (buf[i] & ColorTools.MASK_ALPHA); bufOutput[i] = makeScaledRGBwithRangeCheck(ColorTransformer.redChromaticity(buf[i]), offset, scale, cm) & ~ColorTools.MASK_ALPHA | (buf[i] & ColorTools.MASK_ALPHA); bufOutput[i] = makeScaledRGBwithRangeCheck(ColorTransformer.greenChromaticity(buf[i]), offset, scale, cm) & ~ColorTools.MASK_ALPHA | (buf[i] & ColorTools.MASK_ALPHA); bufOutput[i] = makeScaledRGBwithRangeCheck(ColorTransformer.blueChromaticity(buf[i]), offset, scale, cm) & ~ColorTools.MASK_ALPHA | (buf[i] & ColorTools.MASK_ALPHA); bufOutput[i] = makeScaledRGBwithRangeCheck(ColorTransformer.greenOverBlue(buf[i]), offset, scale, cm) & ~ColorTools.MASK_ALPHA | (buf[i] & ColorTools.MASK_ALPHA); bufOutput[i] = makeScaledRGBwithRangeCheck(ColorTransformer.brown(buf[i]), offset, scale, cm) & ~ColorTools.MASK_ALPHA | (buf[i] & ColorTools.MASK_ALPHA); bufOutput[i] = makeScaledRGBwithRangeCheck(ColorTransformer.deconvolve(buf[i], ColorTransformer.inv_H_E, ColorTransformer.od_lut, 1), offset, scale, cm) & ~ColorTools.MASK_ALPHA | (buf[i] & ColorTools.MASK_ALPHA); bufOutput[i] = makeScaledRGBwithRangeCheck(ColorTransformer.deconvolve(buf[i], ColorTransformer.inv_H_E, ColorTransformer.od_lut, 2), offset, scale, cm) & ~ColorTools.MASK_ALPHA | (buf[i] & ColorTools.MASK_ALPHA); bufOutput[i] = makeScaledRGBwithRangeCheck(ColorTransformer.deconvolve(buf[i], ColorTransformer.inv_H_DAB, ColorTransformer.od_lut, 1), offset, scale, cm) & ~ColorTools.MASK_ALPHA | (buf[i] & ColorTools.MASK_ALPHA); bufOutput[i] = makeScaledRGBwithRangeCheck(ColorTransformer.deconvolve(buf[i], ColorTransformer.inv_H_DAB, ColorTransformer.od_lut, 2), offset, scale, cm) & ~ColorTools.MASK_ALPHA | (buf[i] & ColorTools.MASK_ALPHA); bufOutput[i] = makeScaledRGBwithRangeCheck(ColorTransformer.opticalDensitySum(buf[i], ColorTransformer.od_lut), offset, scale, cm) & ~ColorTools.MASK_ALPHA | (buf[i] & ColorTools.MASK_ALPHA); bufOutput[i] = ColorTransformer.getODNormalizedColor(buf[i], 0.1, offset, scale);
/** * This method is *only* compatible with color transforms that do not require a ColorDeconvolutionStains object - * other transforms will throw an illegal argument exception. * * @param buf * @param method * @param pixels * @return */ public static float[] getSimpleTransformedPixels(final int[] buf, final ColorTransformMethod method, float[] pixels) { return getTransformedPixels(buf, method, pixels, null); }
@Override public synchronized float[] getValues(BufferedImage img, int x, int y, int w, int h, float[] array) { // Try to get the RGB buffer directly buffer = RGBDirectChannelInfo.getRGBIntBuffer(img); // If we didn't get a buffer the fast way, we need to get one the slow way... if (buffer == null) buffer = img.getRGB(x, y, w, h, buffer, 0, w); return ColorTransformer.getSimpleTransformedPixels(buffer, method, array); }
public static int deconvolve8bit(int rgb, double[][] invMat, double[] od_lut_red, double[] od_lut_green, double[] od_lut_blue, int stain) { // Apply deconvolution & store the results return ColorTools.do8BitRangeCheck(Math.exp(-deconvolve(rgb, invMat, od_lut_red, od_lut_green, od_lut_blue, stain)) * 255); }
return ColorTransformer.getTransformedPixels(buf, ColorTransformMethod.Brightness, pixels, stains); case HUE: return ColorTransformer.getTransformedPixels(buf, ColorTransformMethod.Hue, pixels, stains); case OD: return ColorTransformer.getTransformedPixels(buf, ColorTransformMethod.Optical_density_sum, pixels, stains); case RED: return ColorTransformer.getTransformedPixels(buf, ColorTransformMethod.Red, pixels, stains); case GREEN: return ColorTransformer.getTransformedPixels(buf, ColorTransformMethod.Green, pixels, stains); case BLUE: return ColorTransformer.getTransformedPixels(buf, ColorTransformMethod.Blue, pixels, stains); case SATURATION: return ColorTransformer.getTransformedPixels(buf, ColorTransformMethod.Saturation, pixels, stains); case STAIN_1: return ColorTransformer.getTransformedPixels(buf, ColorTransformMethod.Stain_1, pixels, stains); case STAIN_2: return ColorTransformer.getTransformedPixels(buf, ColorTransformMethod.Stain_2, pixels, stains); case STAIN_3: return ColorTransformer.getTransformedPixels(buf, ColorTransformMethod.Stain_3, pixels, stains);
float[] red = ColorTransformer.getSimpleTransformedPixels(rgb, ColorTransformer.ColorTransformMethod.Red, null); float[] green = ColorTransformer.getSimpleTransformedPixels(rgb, ColorTransformer.ColorTransformMethod.Green, null); float[] blue = ColorTransformer.getSimpleTransformedPixels(rgb, ColorTransformer.ColorTransformMethod.Blue, null); convertPixelsToOpticalDensities(red, redMax, n > 500); convertPixelsToOpticalDensities(green, greenMax, n > 500); //J
public static int deconvolve8bit(int rgb, double[][] invMat, double[] od_lut, int stain) { // Apply deconvolution & store the results return ColorTools.do8BitRangeCheck(Math.exp(-deconvolve(rgb, invMat, od_lut, stain)) * 255); }
@Override public synchronized float[] getValues(BufferedImage img, int x, int y, int w, int h, float[] array) { ensureStainsUpdated(); if (stains == null) { if (array == null) return new float[w * h]; return array; } int[] buffer = RGBDirectChannelInfo.getRGBIntBuffer(img); if (buffer == null) buffer = img.getRGB(x, y, w, h, null, 0, w); if (method == null) return ColorDeconvolution.colorDeconvolveRGBArray(buffer, stains, stainNumber-1, array); else return ColorTransformer.getTransformedPixels(buffer, method, array, stains); }
@Override public float getValue(BufferedImage img, int x, int y) { int rgb = img.getRGB(x, y); return ColorTransformer.getPixelValue(rgb, method); }
static void processTransformedImage(SimpleModifiableImage pxImg, int[] buf, float[] pixels, MeasurementList measurementList, String name, ColorTransformer.ColorTransformMethod method, ColorDeconvolutionStains stains, boolean includeStats, boolean doCircular) { ColorTransformer.getTransformedPixels(buf, method, pixels, stains); if (doCircular) { double w = pxImg.getWidth(); double h = pxImg.getHeight(); double cx = (w-1) / 2; double cy = (h-1) / 2; double radius = Math.max(w, h) * .5; double distThreshold = radius * radius; // int count = 0; for (int y = 0; y < h; y++) { for (int x = 0; x < w; x++) { if ((cx - x)*(cx - x) + (cy - y)*(cy - y) > distThreshold) pxImg.setValue(x, y, Float.NaN); // else // count++; } } // System.out.println("Masked count: " + count + " for dimension " + w + ", " + h); } if (includeStats) addBasicStatistics(pxImg, measurementList, name); addLocalBinaryFeatures(LocalBinaryPatterns.computeLocalBinaryPatterns16(pxImg, 2), measurementList, name); // addLocalBinaryFeatures(LocalBinaryPatterns.computeLocalBinaryPatterns(pxImg), measurementList, name); }
@Override public float getValue(BufferedImage img, int x, int y) { ensureStainsUpdated(); if (stains == null) return 0f; int rgb = img.getRGB(x, y); if (method == null) return ColorDeconvolution.colorDeconvolveRGBPixel(rgb, stains, stainNumber-1); else if (method == ColorTransformMethod.Optical_density_sum) { int r = ColorTools.red(rgb); int g = ColorTools.green(rgb); int b = ColorTools.blue(rgb); return (float)(ColorDeconvolutionHelper.makeOD(r, stains.getMaxRed()) + ColorDeconvolutionHelper.makeOD(g, stains.getMaxGreen()) + ColorDeconvolutionHelper.makeOD(b, stains.getMaxBlue())); } else return ColorTransformer.getPixelValue(rgb, method); }
static void processTransformedImage(SimpleModifiableImage pxImg, int[] buf, float[] pixels, MeasurementList measurementList, String name, ColorTransformer.ColorTransformMethod method, ColorDeconvolutionStains stains, boolean includeStats, boolean doCircular) { ColorTransformer.getTransformedPixels(buf, method, pixels, stains); if (doCircular) { double w = pxImg.getWidth(); double h = pxImg.getHeight(); double cx = (w-1) / 2; double cy = (h-1) / 2; double radius = Math.max(w, h) * .5; double distThreshold = radius * radius; // int count = 0; for (int y = 0; y < h; y++) { for (int x = 0; x < w; x++) { if ((cx - x)*(cx - x) + (cy - y)*(cy - y) > distThreshold) pxImg.setValue(x, y, Float.NaN); // else // count++; } } // System.out.println("Masked count: " + count + " for dimension " + w + ", " + h); } if (includeStats) addBasicStatistics(pxImg, measurementList, name); addCoherenceFeature(computeCoherence(pxImg), measurementList, name); }
static void processTransformedImage(SimpleModifiableImage pxImg, int[] buf, float[] pixels, MeasurementList measurementList, String name, ColorTransformer.ColorTransformMethod method, double minValue, double maxValue, int d, int nBins, ColorDeconvolutionStains stains, byte[] maskBytes, boolean includeStats, boolean doCircular) { ColorTransformer.getTransformedPixels(buf, method, pixels, stains);