Examples with MemoryImageSource java.awt.image.MemoryImageSource used on opensource projects

Example 21 with MemoryImageSource

use of java.awt.image.MemoryImageSource in project narchy by automenta.

the class ClipBMP method loadbitmap.

/**
 * loadbitmap() method converted from Windows C code. Reads only
 * uncompressed 24- and 8-bit images. Tested with images saved using
 * Microsoft Paint in Windows 95. If the image is not a 24- or 8-bit image,
 * the program refuses to even try. I guess one could include 4-bit images
 * by masking the byte by first 1100 and then 0011. I am not really
 * interested in such images. If a compressed image is attempted, the
 * routine will probably fail by generating an IOException. Look for
 * variable ncompression to be different from 0 to indicate compression is
 * present.
 * <p>
 * Arguments: sdir and sfile are the result of the FileDialog()
 * getDirectory() and getFile() methods.
 * <p>
 * Returns: Image Object, be sure to check for (Image)null !!!!
 */
public static Image loadbitmap(InputStream fs) {
    Image image;
    try {
        // int bflen = 14; // 14 byte BITMAPFILEHEADER
        // byte bf[] = new byte[bflen];
        // fs.read(bf, 0, bflen);
        // 40-byte BITMAPINFOHEADER
        int bilen = 40;
        byte[] bi = new byte[bilen];
        fs.read(bi, 0, bilen);
        // Interperet data.
        // int nsize = (((int) bf[5] & 0xff) << 24)
        // | (((int) bf[4] & 0xff) << 16)
        // | (((int) bf[3] & 0xff) << 8) | (int) bf[2] & 0xff;
        // System.out.println("Size of file is :" + nsize);
        // int nbisize = (((int) bi[3] & 0xff) << 24)
        // | (((int) bi[2] & 0xff) << 16)
        // | (((int) bi[1] & 0xff) << 8) | (int) bi[0] & 0xff;
        // System.out.println("Size of bitmapinfoheader is :" + nbisize);
        int nwidth = (((int) bi[7] & 0xff) << 24) | (((int) bi[6] & 0xff) << 16) | (((int) bi[5] & 0xff) << 8) | (int) bi[4] & 0xff;
        // System.out.println("Width is :" + nwidth);
        int nheight = (((int) bi[11] & 0xff) << 24) | (((int) bi[10] & 0xff) << 16) | (((int) bi[9] & 0xff) << 8) | (int) bi[8] & 0xff;
        // System.out.println("Height is :" + nheight);
        // int nplanes = (((int) bi[13] & 0xff) << 8) | (int) bi[12] & 0xff;
        // System.out.println("Planes is :" + nplanes);
        int nbitcount = (((int) bi[15] & 0xff) << 8) | (int) bi[14] & 0xff;
        // System.out.println("BitCount is :" + nbitcount);
        // Look for non-zero values to indicate compression
        // int ncompression = (((int) bi[19]) << 24) | (((int) bi[18]) <<
        // 16)
        // | (((int) bi[17]) << 8) | (int) bi[16];
        // System.out.println("Compression is :" + ncompression);
        int nsizeimage = (((int) bi[23] & 0xff) << 24) | (((int) bi[22] & 0xff) << 16) | (((int) bi[21] & 0xff) << 8) | (int) bi[20] & 0xff;
        // System.out.println("SizeImage is :" + nsizeimage);
        // int nxpm = (((int) bi[27] & 0xff) << 24)
        // | (((int) bi[26] & 0xff) << 16)
        // | (((int) bi[25] & 0xff) << 8) | (int) bi[24] & 0xff;
        // System.out.println("X-Pixels per meter is :" + nxpm);
        // int nypm = (((int) bi[31] & 0xff) << 24)
        // | (((int) bi[30] & 0xff) << 16)
        // | (((int) bi[29] & 0xff) << 8) | (int) bi[28] & 0xff;
        // System.out.println("Y-Pixels per meter is :" + nypm);
        int nclrused = (((int) bi[35] & 0xff) << 24) | (((int) bi[34] & 0xff) << 16) | (((int) bi[33] & 0xff) << 8) | (int) bi[32] & 0xff;
        switch(nbitcount) {
            case 24:
                // No Palatte data for 24-bit format but scan lines are
                // padded out to even 4-byte boundaries.
                int npad = (nsizeimage / nheight) - nwidth * 3;
                int[] ndata = new int[nheight * nwidth];
                byte[] brgb = new byte[(nwidth + npad) * 3 * nheight];
                fs.read(brgb, 0, (nwidth + npad) * 3 * nheight);
                int nindex = 0;
                for (int j = 0; j < nheight; j++) {
                    for (int i = 0; i < nwidth; i++) {
                        ndata[nwidth * (nheight - j - 1) + i] = (255 & 0xff) << 24 | (((int) brgb[nindex + 2] & 0xff) << 16) | (((int) brgb[nindex + 1] & 0xff) << 8) | (int) brgb[nindex] & 0xff;
                        // System.out.println("Encoded Color at ("
                        // +i+","+j+")is:"+nrgb+" (R,G,B)= (" +((int)(brgb[2]) &
                        // 0xff)+"," +((int)brgb[1]&0xff)+","
                        // +((int)brgb[0]&0xff)+")";
                        nindex += 3;
                    }
                    nindex += npad;
                }
                image = Toolkit.getDefaultToolkit().createImage(new MemoryImageSource(nwidth, nheight, ndata, 0, nwidth));
                break;
            case 16:
                {
                    // Have to determine the number of colors, the clrsused
                    // parameter is dominant if it is greater than zero. If
                    // zero, calculate colors based on bitsperpixel.
                    int nNumColors = 0;
                    if (nclrused > 0) {
                        nNumColors = nclrused;
                    } else {
                        nNumColors = (1 & 0xff) << 16;
                    }
                    // Ferret out these cases and fix 'em.
                    if (nsizeimage == 0) {
                        nsizeimage = ((((nwidth * nbitcount) + 31) & ~31) >> 3);
                        nsizeimage *= nheight;
                    // System.out.println("nsizeimage (backup) is " +
                    // nsizeimage);
                    }
                    // Read the palatte colors.
                    int[] npalette = new int[nNumColors];
                    byte[] bpalette = new byte[nNumColors * 4];
                    fs.read(bpalette, 0, nNumColors * 4);
                    int nindex8 = 0;
                    for (int n = 0; n < nNumColors; n++) {
                        npalette[n] = (255 & 0xff) << 24 | (((int) bpalette[nindex8 + 2] & 0xff) << 16) | (((int) bpalette[nindex8 + 1] & 0xff) << 8) | (int) bpalette[nindex8] & 0xff;
                        // System.out.println ("Palette Color "+n +"
                        // is:"+npalette[n]+" (res,R,G,B)=
                        // ("+((int)(bpalette[nindex8+3]) & 0xff)+","
                        // +((int)(bpalette[nindex8+2]) & 0xff)+","
                        // +((int)bpalette[nindex8+1]&0xff)+","
                        // +((int)bpalette[nindex8]&0xff)+")");
                        nindex8 += 4;
                    }
                    // Read the image data (actually indices into the palette)
                    // Scan lines are still padded out to even 4-byte
                    // boundaries.
                    int npad8 = (nsizeimage / nheight) - nwidth;
                    // System.out.println("nPad is:" + npad8);
                    int[] ndata8 = new int[nwidth * nheight];
                    byte[] bdata = new byte[(nwidth + npad8) * nheight];
                    fs.read(bdata, 0, (nwidth + npad8) * nheight);
                    nindex8 = 0;
                    for (int j8 = 0; j8 < nheight; j8++) {
                        for (int i8 = 0; i8 < nwidth; i8++) {
                            ndata8[nwidth * (nheight - j8 - 1) + i8] = npalette[((int) bdata[nindex8] & 0xff)] | npalette[((int) bdata[nindex8 + 1] & 0xff)] << 8;
                            nindex8 += 2;
                        }
                        nindex8 += npad8;
                    }
                    image = Toolkit.getDefaultToolkit().createImage(new MemoryImageSource(nwidth, nheight, ndata8, 0, nwidth));
                    break;
                }
            case 8:
                {
                    // Have to determine the number of colors, the clrsused
                    // parameter is dominant if it is greater than zero. If
                    // zero, calculate colors based on bitsperpixel.
                    int nNumColors = 0;
                    if (nclrused > 0) {
                        nNumColors = nclrused;
                    } else {
                        nNumColors = (1 & 0xff) << 8;
                    }
                    // Ferret out these cases and fix 'em.
                    if (nsizeimage == 0) {
                        nsizeimage = ((((nwidth * nbitcount) + 31) & ~31) >> 3);
                        nsizeimage *= nheight;
                    // System.out.println("nsizeimage (backup) is " +
                    // nsizeimage);
                    }
                    // Read the palatte colors.
                    int[] npalette = new int[nNumColors];
                    byte[] bpalette = new byte[nNumColors * 4];
                    fs.read(bpalette, 0, nNumColors * 4);
                    int nindex8 = 0;
                    for (int n = 0; n < nNumColors; n++) {
                        npalette[n] = (255 & 0xff) << 24 | (((int) bpalette[nindex8 + 2] & 0xff) << 16) | (((int) bpalette[nindex8 + 1] & 0xff) << 8) | (int) bpalette[nindex8] & 0xff;
                        // System.out.println ("Palette Color "+n +"
                        // is:"+npalette[n]+" (res,R,G,B)=
                        // ("+((int)(bpalette[nindex8+3]) & 0xff)+","
                        // +((int)(bpalette[nindex8+2]) & 0xff)+","
                        // +((int)bpalette[nindex8+1]&0xff)+","
                        // +((int)bpalette[nindex8]&0xff)+")");
                        nindex8 += 4;
                    }
                    // Read the image data (actually indices into the palette)
                    // Scan lines are still padded out to even 4-byte
                    // boundaries.
                    int npad8 = (nsizeimage / nheight) - nwidth;
                    // System.out.println("nPad is:" + npad8);
                    int[] ndata8 = new int[nwidth * nheight];
                    byte[] bdata = new byte[(nwidth + npad8) * nheight];
                    fs.read(bdata, 0, (nwidth + npad8) * nheight);
                    nindex8 = 0;
                    for (int j8 = 0; j8 < nheight; j8++) {
                        for (int i8 = 0; i8 < nwidth; i8++) {
                            ndata8[nwidth * (nheight - j8 - 1) + i8] = npalette[((int) bdata[nindex8] & 0xff)];
                            nindex8++;
                        }
                        nindex8 += npad8;
                    }
                    image = Toolkit.getDefaultToolkit().createImage(new MemoryImageSource(nwidth, nheight, ndata8, 0, nwidth));
                    break;
                }
            case 4:
                // Have to determine the number of colors, the clrsused
                // parameter is dominant if it is greater than zero. If
                // zero, calculate colors based on bitsperpixel.
                int nNumColors = 0;
                if (nclrused > 0) {
                    nNumColors = nclrused;
                } else {
                    nNumColors = (1 & 0xff) << 4;
                }
                // Ferret out these cases and fix 'em.
                if (nsizeimage == 0) {
                    nsizeimage = ((((nwidth * nbitcount) + 31) & ~31) >> 3);
                    nsizeimage *= nheight;
                // System.out.println("nsizeimage (backup) is " +
                // nsizeimage);
                }
                // Read the palatte colors.
                int[] npalette = new int[nNumColors + 1];
                byte[] bpalette = new byte[nNumColors * 4];
                fs.read(bpalette, 0, nNumColors * 4);
                int nindex8 = 0;
                for (int n = 0; n < nNumColors; n++) {
                    npalette[n] = (255 & 0xff) << 24 | (((int) bpalette[nindex8 + 2] & 0xff) << 16) | (((int) bpalette[nindex8 + 1] & 0xff) << 8) | (int) bpalette[nindex8] & 0xff;
                    nindex8 += 4;
                }
                // Read the image data (actually indices into the palette)
                // Scan lines are still padded out to even 4-byte
                // boundaries.
                int npad8 = (nsizeimage * 2 / nheight) - nwidth;
                // System.out.println("nPad is:" + npad8);
                if (npad8 == 4)
                    npad8 = 0;
                int[] ndata8 = new int[nwidth * nheight];
                byte[] bdata = new byte[(nwidth / 2 + npad8) * nheight];
                // (nwidth)
                fs.read(bdata, 0, (nwidth / 2 + npad8) * nheight);
                // *
                // nheight);
                nindex8 = 0;
                // nheight);
                for (int j8 = 0; j8 < nheight; j8++) {
                    for (int i8 = 0; i8 < (nwidth) - 1; i8 += 2) {
                        ndata8[nwidth * (nheight - j8 - 1) + i8] = npalette[bdata[nindex8] & 0x0f];
                        ndata8[nwidth * (nheight - j8 - 1) + i8 + 1] = npalette[((bdata[nindex8] & 0xf0) / 0xf)];
                        System.out.print("1:" + (bdata[nindex8] & 0x0f) + "\t");
                        System.out.print("2:" + ((bdata[nindex8] & 0xf0) / 0xf) + "\t");
                        // System.out.print(nindex8 + "/" + nsizeimage + "\t");
                        // ndata8[nwidth * j8 + i8] = npalette[((int)
                        // (bdata[nindex8] & 0x0f))];
                        // ndata8[nwidth * j8 + i8 + 1] = npalette[((int)
                        // (bdata[nindex8] & 0xf0) / 0xf)];
                        // System.out.print("\t" + (nheight * j8 + i8) + "=(" +
                        // npalette[((int) (bdata[nindex8] & 0x0f))] + ")");
                        // System.out.print("\t" + (nheight * j8 + i8 + 1) +
                        // "=(" + npalette[((int) (bdata[nindex8] & 0xf0) /
                        // 0xf)] + ")");
                        nindex8++;
                    }
                // nindex8 += npad8;
                }
                // image = null;
                image = Toolkit.getDefaultToolkit().createImage(new MemoryImageSource(nwidth, nheight, ndata8, 0, nwidth));
                break;
            default:
                logger.warn("Not a 24-bit or 8-bit Windows Bitmap, aborting...");
                image = null;
                break;
        }
        fs.close();
        return image;
    } catch (Exception e) {
    // System.out.println("\nCaught exception in loadbitmap: " +
    // e.getMessage() + " " + e.getClass().getName());
    }
    return null;
}

Example 22 with MemoryImageSource

use of java.awt.image.MemoryImageSource in project bioformats by openmicroscopy.

the class RecordedImageProcessor method createImage.

@Override
public Image createImage() {
    if (otherChannels == null)
        return proc.createImage();
    // merge channels - adapted from CompositeImage
    int size = proc.getWidth() * proc.getHeight();
    int[] rgbPixels = new int[size];
    for (int i = 0; i < otherChannels.length + 1; i++) {
        ImageProcessor activeProcessor = null;
        if (i == channelNumber) {
            activeProcessor = proc;
        } else {
            if (i < channelNumber)
                activeProcessor = otherChannels[i];
            else
                activeProcessor = otherChannels[i - 1];
        }
        IndexColorModel cm = (IndexColorModel) activeProcessor.getColorModel();
        int mapSize = cm.getMapSize();
        int[] reds = new int[mapSize];
        int[] greens = new int[mapSize];
        int[] blues = new int[mapSize];
        byte[] tmp = new byte[mapSize];
        cm.getReds(tmp);
        for (int q = 0; q < mapSize; q++) {
            reds[q] = (tmp[q] & 0xff) << 16;
        }
        cm.getGreens(tmp);
        for (int q = 0; q < mapSize; q++) {
            greens[q] = (tmp[q] & 0xff) << 8;
        }
        cm.getBlues(tmp);
        for (int q = 0; q < mapSize; q++) {
            blues[q] = tmp[q] & 0xff;
        }
        byte[] pixels = new byte[size];
        double min = activeProcessor.getMin();
        double max = activeProcessor.getMax();
        double scale = 256.0 / (max - min + 1);
        if (activeProcessor instanceof ByteProcessor) {
            pixels = (byte[]) activeProcessor.getPixels();
        } else if (activeProcessor instanceof ShortProcessor) {
            short[] s = (short[]) activeProcessor.getPixels();
            for (int q = 0; q < size; q++) {
                int value = (int) ((s[q] & 0xffff) - min);
                if (value < 0)
                    value = 0;
                value = (int) (value * scale + 0.5);
                if (value > 255)
                    value = 255;
                pixels[q] = (byte) value;
            }
        } else if (activeProcessor instanceof FloatProcessor) {
            float[] f = (float[]) activeProcessor.getPixels();
            for (int q = 0; q < size; q++) {
                float value = (float) (f[q] - min);
                if (value < 0)
                    value = 0f;
                int ivalue = (int) (value * scale);
                if (ivalue > 255)
                    ivalue = 255;
                pixels[q] = (byte) ivalue;
            }
        }
        switch(i) {
            case 0:
                for (int q = 0; q < size; q++) {
                    rgbPixels[q] = (rgbPixels[q] & 0xff00ffff) | reds[pixels[q] & 0xff];
                }
                break;
            case 1:
                for (int q = 0; q < size; q++) {
                    rgbPixels[q] = (rgbPixels[q] & 0xffff00ff) | greens[pixels[q] & 0xff];
                }
                break;
            case 2:
                for (int q = 0; q < size; q++) {
                    rgbPixels[q] = (rgbPixels[q] & 0xffffff00) | blues[pixels[q] & 0xff];
                }
                break;
            case 3:
                for (int q = 0; q < size; q++) {
                    int red = reds[pixels[q] & 0xff];
                    int green = greens[pixels[q] & 0xff];
                    int blue = blues[pixels[q] & 0xff];
                    rgbPixels[q] = red | green | blue;
                }
                break;
            default:
                for (int q = 0; q < size; q++) {
                    int pixel = rgbPixels[q];
                    int red = (pixel & 0xff0000) + reds[pixels[q] & 0xff];
                    int green = (pixel & 0x00ff00) + greens[pixels[q] & 0xff];
                    int blue = (pixel & 0xff) + blues[pixels[q] & 0xff];
                    if (red > 16711680)
                        red = 16711680;
                    if (green > 65280)
                        green = 65280;
                    if (blue > 255)
                        blue = 255;
                    rgbPixels[q] = red | green | blue;
                }
        }
    }
    DirectColorModel rgb = new DirectColorModel(32, 0xff0000, 0xff00, 0xff);
    MemoryImageSource src = new MemoryImageSource(proc.getWidth(), proc.getHeight(), rgb, rgbPixels, 0, proc.getWidth());
    src.setAnimated(true);
    src.setFullBufferUpdates(true);
    return Toolkit.getDefaultToolkit().createImage(src);
}

Example 23 with MemoryImageSource

use of java.awt.image.MemoryImageSource in project vcell by virtualcell.

the class GeometrySummaryPanel method createIcon.

/**
 * Comment
 */
public javax.swing.Icon createIcon(VCImage sampledImage, Geometry geom) throws cbit.image.GifParsingException, ImageException {
    if (sampledImage == null) {
        return null;
    } else {
        VCImage sampledGeometryHandles = null;
        if (geom.getDimension() > 0) {
            // project and scale geometry
            int SAMPLED_GEOM_SIZE = 150;
            sampledGeometryHandles = cbit.image.DitherIndexImage.dither(sampledImage, SAMPLED_GEOM_SIZE, SAMPLED_GEOM_SIZE);
            if (sampledGeometryHandles.getNumPixelClasses() != sampledImage.getNumPixelClasses()) {
                throw new RuntimeException("DitherIndexImage.dither()-->image.numPixelClasses = " + sampledGeometryHandles.getNumPixelClasses() + ", and Geometry.getSampledImage()-->image.numPixelClasses = " + sampledImage.getNumPixelClasses());
            }
        } else {
            // Make bogus box for compartmental geometries
            int COMPARTMENT_SIZE_X = 10;
            int COMPARTMENT_SIZE_Y = 10;
            int compartmentalXY = COMPARTMENT_SIZE_X * COMPARTMENT_SIZE_Y;
            byte[] compartmentalPixels = new byte[compartmentalXY];
            for (int c = 0; c < compartmentalXY; c += 1) {
                compartmentalPixels[c] = ((byte[]) (sampledImage.getPixels()))[0];
            }
            sampledGeometryHandles = new cbit.image.VCImageUncompressed(null, compartmentalPixels, new org.vcell.util.Extent(1, 1, 1), COMPARTMENT_SIZE_X, COMPARTMENT_SIZE_Y, 1);
        }
        MemoryImageSource mis = new MemoryImageSource(sampledGeometryHandles.getNumX(), sampledGeometryHandles.getNumY(), DisplayAdapterService.getHandleColorMap(), sampledGeometryHandles.getPixels(), 0, sampledGeometryHandles.getNumX());
        java.awt.Image sampledGeometryImage = java.awt.Toolkit.getDefaultToolkit().createImage(mis);
        return new javax.swing.ImageIcon(sampledGeometryImage, "preview of Geometry");
    }
}

Example 24 with MemoryImageSource

use of java.awt.image.MemoryImageSource in project TrakEM2 by trakem2.

the class Patch method adjustChannels.

/**
 * @param c contains the current Display 'channels' value (the transparencies of each channel). This method creates a new color image in which each channel (R, G, B) has the corresponding alpha (in fact, opacity) specified in the 'c'. This alpha is independent of the alpha of the whole Patch. The method updates the Loader cache with the newly created image. The argument 'imp' is optional: if null, it will be retrieved from the loader.
 * <p>
 * For non-color images, a standard image is returned regardless of the given {@code c}.
 * </p>
 * @param c
 */
private Image adjustChannels(final int c, final boolean force, ImagePlus imp) {
    if (null == imp)
        imp = project.getLoader().fetchImagePlus(this);
    ImageProcessor ip = imp.getProcessor();
    // fixing synch problems when deleting a Patch
    if (null == ip)
        return null;
    Image awt = null;
    if (ImagePlus.COLOR_RGB == type) {
        if (imp.getType() != type) {
            // all other types need not be converted, since there are no alphas anyway
            ip = Utils.convertTo(ip, type, false);
        }
        if ((c & 0x00ffffff) == 0x00ffffff && !force) {
            // full transparency
            // imp.getImage();
            awt = ip.createImage();
        // pixels array will be shared using ij138j and above
        } else {
            // modified from ij.process.ColorProcessor.createImage() by Wayne Rasband
            final int[] pixels = (int[]) ip.getPixels();
            final float cr = ((c & 0xff0000) >> 16) / 255.0f;
            final float cg = ((c & 0xff00) >> 8) / 255.0f;
            final float cb = (c & 0xff) / 255.0f;
            final int[] pix = new int[pixels.length];
            int p;
            for (int i = pixels.length - 1; i > -1; i--) {
                p = pixels[i];
                pix[i] = (((int) (((p & 0xff0000) >> 16) * cr)) << 16) + (((int) (((p & 0xff00) >> 8) * cg)) << 8) + (int) ((p & 0xff) * cb);
            }
            final int w = imp.getWidth();
            final MemoryImageSource source = new MemoryImageSource(w, imp.getHeight(), DCM, pix, 0, w);
            source.setAnimated(true);
            source.setFullBufferUpdates(true);
            awt = Toolkit.getDefaultToolkit().createImage(source);
        }
    } else {
        awt = ip.createImage();
    }
    // Utils.log2("ip's min, max: " + ip.getMin() + ", " + ip.getMax());
    this.channels = c;
    return awt;
}