Application: gvSIG desktop » Library: org.gvsig.tools

import java.io.IOException;

import org.gvsig.tools.swing.impl.bufferedImage.MappedFileBuffer;

import org.gvsig.tools.swing.impl.bufferedImage.MappedImageFactory;

        try {

            return MappedImageFactory.createCompatibleMappedImage(w, h, type);

        } catch (IOException e) {

            throw new RuntimeException("Can't create VitualBufferedImage", e);

        }

        if(sourceRaster.getDataBuffer() instanceof MappedFileBuffer){

            try {

                newImage =

                    MappedImageFactory.createCompatibleMappedImage(img.getWidth(), img.getHeight(), img.getSampleModel(), img.getColorModel());

            } catch (IOException e) {

                throw new RuntimeException("Can't copy buffered image", e);

            }

package org.gvsig.tools.swing.impl.bufferedImage;

import java.util.Arrays;

import java.util.Collection;

import java.util.Map;

/**

 * Kind of like {@code org.apache.commons.lang.Validate}. Just smarter. ;-)

 * <p/>

 * Uses type parameterized return values, thus making it possible to check

 * constructor arguments before

 * they are passed on to {@code super} or {@code this} type constructors.

 *

 * @author <a href="mailto:harald.kuhr@gmail.com">Harald Kuhr</a>

 * @author last modified by $Author: haku $

 * @version $Id: //depot/branches/personal/haraldk/twelvemonkeys/release-2/twelvemonkeys-core/src/main/java/com/twelvemonkeys/lang/Validate.java#1 $

 */

public final class Validate {

    // TODO: Make it possible to throw IllegalStateException instead of IllegalArgumentException?

    private static final String UNSPECIFIED_PARAM_NAME = "method parameter";

    private Validate() {}

    // Not null...

    public static <T> T notNull(final T pParameter) {

        return notNull(pParameter, null);

    }

    public static <T> T notNull(final T pParameter, final String pParamName) {

        if (pParameter == null) {

            throw new IllegalArgumentException(String.format("%s may not be null", pParamName == null ? UNSPECIFIED_PARAM_NAME : pParamName));

        }

        return pParameter;

    }

    // Not empty

    public static <T extends CharSequence> T notEmpty(final T pParameter) {

        return notEmpty(pParameter, null);

    }

    public static <T extends CharSequence> T notEmpty(final T pParameter, final String pParamName) {

        if (pParameter == null || pParameter.length() == 0 || isOnlyWhiteSpace(pParameter)) {

            throw new IllegalArgumentException(String.format("%s may not be blank", pParamName == null ? UNSPECIFIED_PARAM_NAME : pParamName));

        }

        return pParameter;

    }

    private static <T extends CharSequence> boolean isOnlyWhiteSpace(T pParameter) {

        for (int i = 0; i < pParameter.length(); i++) {

            if (!Character.isWhitespace(pParameter.charAt(i))) {

                return false;

            }

        }

        return true;

    }

    public static <T> T[] notEmpty(final T[] pParameter) {

        return notEmpty(pParameter, null);

    }

    public static <T> T[] notEmpty(final T[] pParameter, final String pParamName) {

        if (pParameter == null || pParameter.length == 0) {

            throw new IllegalArgumentException(String.format("%s may not be empty", pParamName == null ? UNSPECIFIED_PARAM_NAME : pParamName));

        }

        return pParameter;

    }

    public static <T> Collection<T> notEmpty(final Collection<T> pParameter) {

        return notEmpty(pParameter, null);

    }

    public static <T> Collection<T> notEmpty(final Collection<T> pParameter, final String pParamName) {

        if (pParameter == null || pParameter.isEmpty()) {

            throw new IllegalArgumentException(String.format("%s may not be empty", pParamName == null ? UNSPECIFIED_PARAM_NAME : pParamName));

        }

        return pParameter;

    }

    public static <K, V> Map<K, V> notEmpty(final Map<K, V> pParameter) {

        return notEmpty(pParameter, null);

    }

    public static <K, V> Map<K, V> notEmpty(final Map<K, V> pParameter, final String pParamName) {

        if (pParameter == null || pParameter.isEmpty()) {

            throw new IllegalArgumentException(String.format("%s may not be empty", pParamName == null ? UNSPECIFIED_PARAM_NAME : pParamName));

        }

        return pParameter;

    }

    // No null elements

    public static <T> T[] noNullElements(final T[] pParameter) {

        return noNullElements(pParameter, null);

    }

    public static <T> T[] noNullElements(final T[] pParameter, final String pParamName) {

        noNullElements(pParameter == null ? null : Arrays.asList(pParameter), pParamName);

        return pParameter;

    }

    public static <T> Collection<T> noNullElements(final Collection<T> pParameter) {

        return noNullElements(pParameter, null);

    }

    public static <T> Collection<T> noNullElements(final Collection<T> pParameter, final String pParamName) {

        notNull(pParameter, pParamName);

        for (T element : pParameter) {

            if (element == null) {

                throw new IllegalArgumentException(String.format("%s may not contain null elements", pParamName == null ? UNSPECIFIED_PARAM_NAME : pParamName));

            }

        }

        return pParameter;

    }

    public static <K, V> Map<K, V> noNullValues(final Map<K, V> pParameter) {

        return noNullValues(pParameter, null);

    }

    public static <K, V> Map<K, V> noNullValues(final Map<K, V> pParameter, final String pParamName) {

        notNull(pParameter, pParamName);

        for (V value : pParameter.values()) {

            if (value == null) {

                throw new IllegalArgumentException(String.format("%s may not contain null values", pParamName == null ? UNSPECIFIED_PARAM_NAME : pParamName));

            }

        }

        return pParameter;

    }

    public static <K, V> Map<K, V> noNullKeys(final Map<K, V> pParameter) {

        return noNullKeys(pParameter, null);

    }

    public static <K, V> Map<K, V> noNullKeys(final Map<K, V> pParameter, final String pParamName) {

        notNull(pParameter, pParamName);

        for (K key : pParameter.keySet()) {

            if (key == null) {

                throw new IllegalArgumentException(String.format("%s may not contain null keys", pParamName == null ? UNSPECIFIED_PARAM_NAME : pParamName));

            }

        }

        return pParameter;

    }

    // Is true

    public static boolean isTrue(final boolean pExpression, final String pMessage) {

        return isTrue(pExpression, pExpression, pMessage);

    }

    public static <T> T isTrue(final boolean condition, final T value, final String message) {

        if (!condition) {

            throw new IllegalArgumentException(String.format(message == null ? "expression may not be %s" : message, value));

        }

        return value;

    }

}

/*

 * Copyright (c) 2010, Harald Kuhr

 * All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions are met:

 *     * Redistributions of source code must retain the above copyright

 *       notice, this list of conditions and the following disclaimer.

 *     * Redistributions in binary form must reproduce the above copyright

 *       notice, this list of conditions and the following disclaimer in the

 *       documentation and/or other materials provided with the distribution.

 *    * Neither the name "TwelveMonkeys" nor the

 *       names of its contributors may be used to endorse or promote products

 *       derived from this software without specific prior written permission.

 *

 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR

 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,

 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR

 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF

 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING

 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS

 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 */

package org.gvsig.tools.swing.impl.bufferedImage;

//import com.twelvemonkeys.lang.Validate;

import java.awt.image.DataBuffer;

import java.io.File;

import java.io.IOException;

import java.io.RandomAccessFile;

import java.nio.*;

import java.nio.channels.FileChannel;

import org.gvsig.tools.ToolsLocator;

/**

 * A {@code DataBuffer} implementation that is backed by a memory mapped file.

 * Memory will be allocated outside the normal JVM heap, allowing more efficient

 * memory usage for large buffers.

 *

 * @author <a href="mailto:harald.kuhr@gmail.com">Harald Kuhr</a>

 * @author last modified by $Author: haraldk$

 * @version $Id: MappedFileBuffer.java,v 1.0 Jun 12, 2010 4:56:51 PM haraldk Exp$

 *

 * @see java.nio.channels.FileChannel#map(java.nio.channels.FileChannel.MapMode, long, long)

 */

public abstract class MappedFileBuffer extends DataBuffer {

    private final Buffer buffer;

    private MappedFileBuffer(final int type, final int size, final int numBanks) throws IOException {

        super(type, Validate.isTrue(size >= 0, size, "Integer overflow for size: %d"), Validate.isTrue(numBanks >= 0, numBanks, "Number of banks must be positive"));

        int componentSize = DataBuffer.getDataTypeSize(type) / 8;

        // Create temp file to get a file handle to use for memory mapping

//        File tempFile = File.createTempFile(String.format("%s-", getClass().getSimpleName().toLowerCase()), ".tmp");

        File tempFile = ToolsLocator.getFoldersManager().getUniqueTemporaryFile("BufferedImage.dat");

        try {

            RandomAccessFile raf = new RandomAccessFile(tempFile, "rw");

            long length = ((long) size) * componentSize * numBanks;

            raf.setLength(length);

            FileChannel channel = raf.getChannel();

            // Map entire file into memory, let OS virtual memory/paging do the heavy lifting

            MappedByteBuffer byteBuffer = channel.map(FileChannel.MapMode.READ_WRITE, 0, length);

            switch (type) {

                case DataBuffer.TYPE_BYTE:

                    buffer = byteBuffer;

                    break;

                case DataBuffer.TYPE_USHORT:

                    buffer = byteBuffer.asShortBuffer();

                    break;

                case DataBuffer.TYPE_INT:

                    buffer = byteBuffer.asIntBuffer();

                    break;

                default:

                    throw new IllegalArgumentException("Unsupported data type: " + type);

            }

            // According to the docs, we can safely close the channel and delete the file now

            channel.close();

        }

        finally {

            // NOTE: File can't be deleted right now on Windows, as the file is open. Let JVM clean up later

//            if (!tempFile.delete()) {

                tempFile.deleteOnExit();

//            }

        }

    }

    @Override

    public String toString() {

        return String.format("MappedFileBuffer: %s", buffer);

    }

    // TODO: Is throws IOException a good idea?

    public static DataBuffer create(final int type, final int size, final int numBanks) throws IOException {

        switch (type) {

            case DataBuffer.TYPE_BYTE:

                return new DataBufferByte(size, numBanks);

            case DataBuffer.TYPE_USHORT:

                return new DataBufferUShort(size, numBanks);

            case DataBuffer.TYPE_INT:

                return new DataBufferInt(size, numBanks);

            default:

                throw new IllegalArgumentException("Unsupported data type: " + type);

        }

    }

    final static class DataBufferByte extends MappedFileBuffer {

        private final ByteBuffer buffer;

        public DataBufferByte(int size, int numBanks) throws IOException {

            super(DataBuffer.TYPE_BYTE, size, numBanks);

            buffer = (ByteBuffer) super.buffer;

        }

        @Override

        public int getElem(int bank, int i) {

            return buffer.get(bank * size + i) & 0xff;

        }

        @Override

        public void setElem(int bank, int i, int val) {

            buffer.put(bank * size + i, (byte) val);

        }

    }

    final static class DataBufferUShort extends MappedFileBuffer {

        private final ShortBuffer buffer;

        public DataBufferUShort(int size, int numBanks) throws IOException {

            super(DataBuffer.TYPE_USHORT, size, numBanks);

            buffer = (ShortBuffer) super.buffer;

        }

        @Override

        public int getElem(int bank, int i) {

            return buffer.get(bank * size + i) & 0xffff;

        }

        @Override

        public void setElem(int bank, int i, int val) {

            buffer.put(bank * size + i, (short) val);

        }

    }

    final static class DataBufferInt extends MappedFileBuffer {

        private final IntBuffer buffer;

        public DataBufferInt(int size, int numBanks) throws IOException {

            super(DataBuffer.TYPE_INT, size, numBanks);

            buffer = (IntBuffer) super.buffer;

        }

        @Override

        public int getElem(int bank, int i) {

            return buffer.get(bank * size + i);

        }

        @Override

        public void setElem(int bank, int i, int val) {

            buffer.put(bank * size + i, val);

        }

    }

}

/*

 * Copyright (c) 2010, Harald Kuhr

 * All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions are met:

 *     * Redistributions of source code must retain the above copyright

 *       notice, this list of conditions and the following disclaimer.

 *     * Redistributions in binary form must reproduce the above copyright

 *       notice, this list of conditions and the following disclaimer in the

 *       documentation and/or other materials provided with the distribution.

 *     * Neither the name "TwelveMonkeys" nor the

 *       names of its contributors may be used to endorse or promote products

 *       derived from this software without specific prior written permission.

 *

 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR

 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,

 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR

 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF

 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING

 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS

 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 */

package org.gvsig.tools.swing.impl.bufferedImage;

import java.awt.Point;

import java.awt.image.BufferedImage;

import java.awt.image.ColorModel;

import java.awt.image.DataBuffer;

import java.awt.image.SampleModel;

import java.awt.image.WritableRaster;

import java.io.IOException;

import java.lang.reflect.Constructor;

import java.lang.reflect.Field;

import java.lang.reflect.InvocationTargetException;

import java.lang.reflect.Modifier;

import java.lang.reflect.UndeclaredThrowableException;

/**

 * A factory for creating {@link BufferedImage}s backed by memory mapped files.

 * The data buffers will be allocated outside the normal JVM heap, allowing more efficient

 * memory usage for large images.

 *

 * @author <a href="mailto:harald.kuhr@gmail.com">Harald Kuhr</a>

 * @author last modified by $Author: haraldk$

 * @version $Id: MappedImageFactory.java,v 1.0 May 26, 2010 5:07:01 PM haraldk Exp$

 */

public final class MappedImageFactory {

    // TODO: Create a way to do ColorConvertOp (or other color space conversion) on these images.

    // - Current implementation of CCOp delegates to internal sun.awt classes that assumes java.awt.DataBufferByte for type byte buffers :-/

    // - Might be possible (but slow) to copy parts to memory and do CCOp on these copies

    private static final boolean DEBUG = "true".equalsIgnoreCase(System.getProperty("com.twelvemonkeys.image.mapped.debug"));

    static final RasterFactory RASTER_FACTORY = createRasterFactory();

    private MappedImageFactory() {}

    public static BufferedImage createCompatibleMappedImage(int width, int height, int type) throws IOException {

        BufferedImage temp = new BufferedImage(1, 1, type);

        BufferedImage x = createCompatibleMappedImage(width, height, temp.getSampleModel().createCompatibleSampleModel(width, height), temp.getColorModel());

//        try {

//            Field field = x.getClass().getDeclaredField("imageType");

//            field.setAccessible(true);

//            field.setInt(x, type);

//            field.setAccessible(false);

//        } catch (NoSuchFieldException | SecurityException | IllegalArgumentException | IllegalAccessException e) {

//            throw new RuntimeException("Can't set the image type to the BufferedImage.", e);

//        }

        return x;

    }

    public static BufferedImage createCompatibleMappedImage(int width, int height, SampleModel sm, ColorModel cm) throws IOException {

        DataBuffer buffer = MappedFileBuffer.create(sm.getTransferType(), width * height * sm.getNumDataElements(), 1);

        BufferedImage x = new BufferedImage(cm, RASTER_FACTORY.createRaster(sm, buffer, new Point()), cm.isAlphaPremultiplied(), null);

        return x;

    }

    private static RasterFactory createRasterFactory() {

        try {

            // Try to instantiate, will throw LinkageError if it fails

            return new SunRasterFactory();

        }

        catch (LinkageError e) {

            if (DEBUG) {

                e.printStackTrace();

            }

            System.err.println("Could not instantiate SunWritableRaster, falling back to GenericWritableRaster.");

        }

        // Fall back

        return new GenericRasterFactory();

    }

    static interface RasterFactory {

        WritableRaster createRaster(SampleModel model, DataBuffer buffer, Point origin);

    }

    /**

     * Generic implementation that should work for any JRE, and creates a custom subclass of {@link WritableRaster}.

     */

    static final class GenericRasterFactory implements RasterFactory {

        public WritableRaster createRaster(final SampleModel model, final DataBuffer buffer, final Point origin) {

            return new GenericWritableRaster(model, buffer, origin);

        }

    }

    /**

     * Sun/Oracle JRE-specific implementation that creates {@code sun.awt.image.SunWritableRaster}.

     * Callers must catch {@link LinkageError}.

     */

    static final class SunRasterFactory implements RasterFactory {

        final private Constructor<WritableRaster> factoryMethod = getFactoryMethod();

        @SuppressWarnings("unchecked")

        private static Constructor<WritableRaster> getFactoryMethod() {

            try {

                Class<?> cls = Class.forName("sun.awt.image.SunWritableRaster");

                if (Modifier.isAbstract(cls.getModifiers())) {

                    throw new IncompatibleClassChangeError("sun.awt.image.SunWritableRaster has become abstract and can't be instantiated");

                }

                return (Constructor<WritableRaster>) cls.getConstructor(SampleModel.class, DataBuffer.class, Point.class);

            }

            catch (ClassNotFoundException e) {

                throw new NoClassDefFoundError(e.getMessage());

            }

            catch (NoSuchMethodException e) {

                throw new NoSuchMethodError(e.getMessage());

            }

        }

        public WritableRaster createRaster(final SampleModel model, final DataBuffer buffer, final Point origin) {

            try {

                return factoryMethod.newInstance(model, buffer, origin);

            }

            catch (InstantiationException e) {

                throw new Error("Could not create SunWritableRaster: ", e); // Should never happen, as we test for abstract class

            }

            catch (IllegalAccessException e) {

                throw new Error("Could not create SunWritableRaster: ", e); // Should never happen, only public constructors are reflected

            }

            catch (InvocationTargetException e) {

                // Unwrap to allow normal exception flow

                Throwable cause = e.getCause();

                if (cause instanceof RuntimeException) {

                    throw (RuntimeException) cause;

                }

                else if (cause instanceof Error) {

                    throw (Error) cause;

                }

                throw new UndeclaredThrowableException(cause);

            }

        }

    }

}

/*

 * Copyright (c) 2010, Harald Kuhr

 * All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions are met:

 *     * Redistributions of source code must retain the above copyright

 *       notice, this list of conditions and the following disclaimer.

 *     * Redistributions in binary form must reproduce the above copyright

 *       notice, this list of conditions and the following disclaimer in the

 *       documentation and/or other materials provided with the distribution.

 *     * Neither the name "TwelveMonkeys" nor the

 *       names of its contributors may be used to endorse or promote products

 *       derived from this software without specific prior written permission.

 *

 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR

 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,

 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR

 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF

 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING

 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS

 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 */

package org.gvsig.tools.swing.impl.bufferedImage;

import java.awt.*;

import java.awt.image.DataBuffer;

import java.awt.image.SampleModel;

import java.awt.image.WritableRaster;

/**

 * A generic writable raster.

 * For use when factory methods from {@link java.awt.image.Raster} can't be used,

 * typically because of custom data buffers.

 *

 * @author <a href="mailto:harald.kuhr@gmail.com">Harald Kuhr</a>

 * @author last modified by $Author: haraldk$

 * @version $Id: GenericWritableRaster.java,v 1.0 Jun 13, 2010 12:27:45 AM haraldk Exp$

 */

class GenericWritableRaster extends WritableRaster {

    public GenericWritableRaster(final SampleModel model, final DataBuffer buffer, final Point origin) {

        super(model, buffer, origin);

    }

    @Override

    public String toString() {

        return String.format(

                "%s: %s width = %s height = %s #Bands = %s xOff = %s yOff = %s %s",

                getClass().getSimpleName(),

                sampleModel,

                getWidth(), getHeight(), getNumBands(),

                sampleModelTranslateX, sampleModelTranslateY,

                dataBuffer

        );

    }

}