/** * Scale the RGB channels for a color by a fixed amount. * * This is useful for brightening/darkening an input color. * * @param rgb * @param scale * @return */ public static int makeScaledRGB(final int rgb, final double scale) { return makeRGB( (int)Math.min(255, (ColorTools.red(rgb)*scale)), (int)Math.min(255, (ColorTools.green(rgb)*scale)), (int)Math.min(255, (ColorTools.blue(rgb)*scale))); }
/** * Get a color with a specified opacity, based on the packed RGB values in an Integer. * * @param rgb * @param opacity * @return */ public static Color getColorWithOpacity(Integer rgb, double opacity) { if (rgb == null) return null; if (opacity > 1) opacity = 1; else if (opacity < 0) opacity = 0; // IJ.log("Opacity: " + (int)(opacity * 255 + .5)); return new Color(ColorTools.red(rgb), ColorTools.green(rgb), ColorTools.blue(rgb), (int)(opacity * 255 + .5)); }
/** * Convert red channel of packed rgb pixel to optical density values, using a specified maximum value. * * @param rgb * @param maxValue * @param px optional array used for output * @return */ public static float[] getGreenOpticalDensities(int[] rgb, double maxValue, float[] px) { if (px == null) px = new float[rgb.length]; double[] od_lut = makeODLUT(maxValue, 256); for (int i = 0; i < px.length; i++) px[i] = (float)makeODByLUT(ColorTools.green(rgb[i]), od_lut); return px; }
@Override public String getValueAsString(BufferedImage img, int x, int y) { int rgb = getRGB(img, x, y, false); return ColorTools.red(rgb) + ", " + ColorTools.green(rgb) + ", " + ColorTools.blue(rgb); }
@Override public String getValueAsString(BufferedImage img, int x, int y) { int rgb = getRGB(img, x, y, false); return ColorTools.red(rgb) + ", " + ColorTools.green(rgb) + ", " + ColorTools.blue(rgb); }
for (int v : rgb) { rh[ColorTools.red(v)]++; gh[ColorTools.green(v)]++; bh[ColorTools.blue(v)]++;
public static IndexColorModel createHueColorModel() { byte[] r2 = new byte[256]; byte[] g2 = new byte[256]; byte[] b2 = new byte[256]; for (int i = 0; i < 256; i++) { int rgb = Color.HSBtoRGB(i/255f, 1f, 0.75f); r2[i] = (byte)ColorTools.red(rgb); g2[i] = (byte)ColorTools.green(rgb); b2[i] = (byte)ColorTools.blue(rgb); } return new IndexColorModel(8, 256, r2, g2, b2); }
for (int v : buffer) { int r = ColorTools.do8BitRangeCheck((ColorTools.red(v) - offset) * scale); int g = ColorTools.do8BitRangeCheck((ColorTools.green(v) - offset) * scale); int b = ColorTools.do8BitRangeCheck((ColorTools.blue(v) - offset) * scale); rgb[ind] = (r << 16) + (g << 8) + b;
int green = ColorTools.green(val); int blue = ColorTools.blue(val);
for (int c = 0; c < server.nChannels(); c++) { int rgb = server.getDefaultChannelColor(c); channelOptions.add(new ChannelDisplayInfo.MultiChannelInfo("Channel " + (c + 1), bpp, c, ColorTools.red(rgb), ColorTools.green(rgb), ColorTools.blue(rgb)));
/** * Create a 'normalized' color by converting RGB values to optical densities, putting the RGB ODs into * a 3x1 vector and normalizing this to unit length, then rescaling the result to give an RGB representation. * Because of the somewhat strange rescaling involved, the final RGB values produced should not be over-interpreted - * this is really intended for visualization, such as when interactively looking for regions of single stains * when selecting color deconvolution stain vectors. * * @param rgb original 8-bit RGB values * @param minOD the minimum OD - pixels with an OD less than this will be considered unstained, and shown as white * @param offset brightness and contrast offset * @param scale brightness and contrast scale value * @return normalized color, as packed RGB value */ public static int getODNormalizedColor(int rgb, double minOD, float offset, float scale) { double r_od = od_lut[ColorTools.red(rgb)]; double g_od = od_lut[ColorTools.green(rgb)]; double b_od = od_lut[ColorTools.blue(rgb)]; double norm = Math.sqrt(r_od*r_od + g_od*g_od + b_od*b_od); if (norm < minOD) { norm = minOD; //Jreturn ((255<<16) + (255<<8) + 255) & ~ColorTools.MASK_ALPHA | (rgb & ColorTools.MASK_ALPHA); return 0x00ffffff | (rgb & ColorTools.MASK_ALPHA); //J Slightly faster? } int r = 255-ColorTools.do8BitRangeCheck((255*r_od/norm - offset) * scale); int g = 255-ColorTools.do8BitRangeCheck((255*g_od/norm - offset) * scale); int b = 255-ColorTools.do8BitRangeCheck((255*b_od/norm - offset) * scale); return ((r<<16) + (g<<8) + b) & ~ColorTools.MASK_ALPHA | (rgb & ColorTools.MASK_ALPHA); }
public static StainVector generateStainVectorFromRGB(String name, int rgb, double redMax, double greenMax, double blueMax) { double rOD = makeOD(ColorTools.red(rgb), redMax); double gOD = makeOD(ColorTools.green(rgb), greenMax); //J double bOD = makeOD(ColorTools.blue(rgb), blueMax); //J return new StainVector(name, rOD, gOD, bOD); }
/** * Determine median of RGB values. * The median of each channel is computed separately. * * @param name * @param rgb * @param redMax * @param greenMax * @param blueMax * @return */ public static int getMedianRGB(int[] rgb) { int n = rgb.length; // Extract medians for each channel int[] temp = new int[n]; for (int i = 0; i < rgb.length; i++) temp[i] = ColorTools.red(rgb[i]); int rMedian = getMedian(temp); for (int i = 0; i < rgb.length; i++) temp[i] = ColorTools.green(rgb[i]); int gMedian = getMedian(temp); for (int i = 0; i < rgb.length; i++) temp[i] = ColorTools.blue(rgb[i]); int bMedian = getMedian(temp); return ColorTools.makeRGB(rMedian, gMedian, bMedian); }
@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); }
continue; int val = buf[i]; hsb = Color.RGBtoHSB(ColorTools.red(val), ColorTools.green(val), ColorTools.blue(val), hsb); pixelsSaturation[i] = hsb[1]; pixelsBrightness[i] = hsb[2];
int rgb = buf[i]; int r = ColorTools.do8BitRangeCheck((ColorTools.red(rgb) - offset) * scale); int g = ColorTools.do8BitRangeCheck((ColorTools.green(rgb) - offset) * scale); int b = ColorTools.do8BitRangeCheck((ColorTools.blue(rgb) - offset) * scale); cm = ICM_GREEN; for (int i = 0; i < buf.length; i++) { bufOutput[i] = makeScaledRGBwithRangeCheck(ColorTools.green(buf[i]), offset, scale, cm) & ~ColorTools.MASK_ALPHA | (buf[i] & ColorTools.MASK_ALPHA);
return ColorTools.red(rgb); case Green: return ColorTools.green(rgb); case Blue: return ColorTools.blue(rgb);