Application: gvSIG desktop

package org.gvsig.raster.lib.buffer.impl;

import java.awt.Color;

import java.awt.image.BufferedImage;

import java.awt.image.DataBuffer;

import java.awt.image.Raster;

import java.awt.image.SampleModel;

import java.io.File;

import java.io.IOException;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import java.util.Map.Entry;

import org.cresques.cts.IProjection;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.exception.CreateEnvelopeException;

import org.gvsig.fmap.geom.operation.GeometryOperationException;

import org.gvsig.fmap.geom.operation.GeometryOperationNotSupportedException;

import org.gvsig.fmap.geom.primitive.Envelope;

import org.gvsig.raster.lib.buffer.api.Band;

import org.gvsig.raster.lib.buffer.api.BandInfo;

import org.gvsig.raster.lib.buffer.api.BandPageManager;

import org.gvsig.raster.lib.buffer.api.BandTileManager;

import org.gvsig.raster.lib.buffer.api.Buffer;

import org.gvsig.raster.lib.buffer.api.BufferDimensions;

import org.gvsig.raster.lib.buffer.api.BufferManager;

import org.gvsig.raster.lib.buffer.api.Kernel;

import org.gvsig.raster.lib.buffer.api.NoData;

import org.gvsig.raster.lib.buffer.api.OperationManager;

import org.gvsig.raster.lib.buffer.api.PageManager;

import org.gvsig.raster.lib.buffer.api.exceptions.BandException;

import org.gvsig.raster.lib.buffer.api.exceptions.BufferException;

import org.gvsig.raster.lib.buffer.api.exceptions.BufferOperationException;

import org.gvsig.raster.lib.buffer.api.operations.Operation;

import org.gvsig.raster.lib.buffer.api.operations.OperationFactory;

import org.gvsig.raster.lib.buffer.api.operations.OperationList;

import org.gvsig.raster.lib.buffer.api.operations.OperationListEntry;

import org.gvsig.raster.lib.buffer.impl.exceptions.CreateBandTypeException;

import org.gvsig.raster.lib.buffer.impl.exceptions.CreateBufferException;

import org.gvsig.raster.lib.buffer.impl.operations.DefaultOperationList;

import org.gvsig.raster.lib.buffer.impl.operations.DefaultOperationListEntry;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dataTypes.CoercionException;

import org.gvsig.tools.dataTypes.DataTypes;

import org.gvsig.tools.dataTypes.DataTypesManager;

import org.gvsig.tools.dataTypes.DataTypesManager.Coercion;

import org.gvsig.tools.dataTypes.impl.coercion.CoerceToDouble;

import org.gvsig.tools.dataTypes.impl.coercion.CoerceToFloat;

import org.gvsig.tools.dataTypes.impl.coercion.CoerceToInt;

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.folders.FoldersManager;

import org.gvsig.tools.locator.LocatorException;

import org.gvsig.tools.task.SimpleTaskStatus;

/**

 * @author fdiaz

 *

 */

public class DefaultBufferManager implements BufferManager, OperationManager {

    private static final Logger logger = LoggerFactory.getLogger(DefaultBufferManager.class);

    private File lastFolderUsedToSave;

    private int simplePaginatedCounter;

    private Map<String, OperationFactory> operationFactoriesRegister;

    public DefaultBufferManager() {

        simplePaginatedCounter = 0;

        operationFactoriesRegister = new HashMap<String, OperationFactory>();

    }

    @Override

    public NoData createNoData(Number value, Number defaultValue) {

        NoData noData = new DefaultNoData(defaultValue);

        noData.setValue(value);

        return noData;

    }

    @Override

    public Band createBand(int dataType, int rows, int columns, NoData noData,

        PageManager pageManager) throws CreateBandTypeException {

        if (pageManager == null) {

            switch (dataType) {

            case BufferManager.TYPE_BYTE:

                return new MemoryBandByte(rows, columns, noData);

            case BufferManager.TYPE_SHORT:

                return new MemoryBandShort(rows, columns, noData);

            case BufferManager.TYPE_INT:

                return new MemoryBandInt(rows, columns, noData);

            case BufferManager.TYPE_FLOAT:

                return new MemoryBandFloat(rows, columns, noData);

            case BufferManager.TYPE_DOUBLE:

                return new MemoryBandDouble(rows, columns, noData);

            default:

                throw new CreateBandTypeException(dataType);

            }

        } else if (pageManager instanceof BandPageManager) {

            switch (dataType) {

            case BufferManager.TYPE_BYTE:

                return new PaginatedBandByte(rows, columns, noData, (BandPageManager) pageManager);

            case BufferManager.TYPE_SHORT:

                return new PaginatedBandShort(rows, columns, noData, (BandPageManager) pageManager);

            case BufferManager.TYPE_INT:

                return new PaginatedBandInt(rows, columns, noData, (BandPageManager) pageManager);

            case BufferManager.TYPE_FLOAT:

                return new PaginatedBandFloat(rows, columns, noData, (BandPageManager) pageManager);

            case BufferManager.TYPE_DOUBLE:

                return new PaginatedBandDouble(rows, columns, noData, (BandPageManager) pageManager);

            default:

                throw new CreateBandTypeException(dataType);

            }

        }else if(pageManager instanceof BandTileManager ){

             //FIXME

             switch (dataType) {

             case BufferManager.TYPE_BYTE:

             return new TiledBandByte(rows, columns, noData, (BandTileManager) pageManager);

             case BufferManager.TYPE_USHORT:

             case BufferManager.TYPE_SHORT:

             return new TiledBandShort(rows, columns, noData, (BandTileManager) pageManager);

             case BufferManager.TYPE_INT:

             return new TiledBandInt(rows, columns, noData, (BandTileManager) pageManager);

             case BufferManager.TYPE_FLOAT:

             return new TiledBandFloat(rows, columns, noData, (BandTileManager) pageManager);

             case BufferManager.TYPE_DOUBLE:

             return new TiledBandDouble(rows, columns, noData, (BandTileManager) pageManager);

             default:

             throw new CreateBandTypeException(dataType);

             }

        }

        return null;

    }

    @Override

    public Buffer createBuffer(int rows, int columns, int[] bandDataTypes, IProjection projection)

        throws BufferException {

        return new DefaultBuffer(rows, columns, bandDataTypes, null, projection, null, null);

    }

    @Override

    public Buffer createBuffer(int rows, int columns, int[] bandDataTypes, NoData[] bandNoData,

        IProjection projection) throws CreateBufferException {

        return new DefaultBuffer(rows, columns, bandDataTypes, bandNoData, projection, null, null);

    }

    @Override

    public Buffer createBuffer(int rows, int columns, int[] bandDataTypes, NoData[] bandNoData,

        IProjection projection, Envelope envelope) throws BufferException {

        return new DefaultBuffer(rows, columns, bandDataTypes, bandNoData, projection, envelope,

            null);

    }

    @Override

    public Buffer createBuffer(int rows, int columns, int[] bandDataTypes, NoData[] bandNoData,

        IProjection projection, Envelope envelope, List<PageManager> pageManagers)

        throws BufferException {

        return new DefaultBuffer(rows, columns, bandDataTypes, bandNoData, projection, envelope,

            pageManagers);

    }

    @Override

    public BandPageManager createSimpleBandPageManager(File file, int rows, int columns,

        int dataType) throws IOException {

        return new SimpleBandPageManager(file, rows, columns, dataType);

    }

    public int getDataTypeSize(int dataType) {

        switch (dataType) {

        case BufferManager.TYPE_BYTE:

            return 1;

        case BufferManager.TYPE_SHORT:

            return 2;

        case BufferManager.TYPE_INT:

            return 4;

        case BufferManager.TYPE_FLOAT:

            return 4;

        case BufferManager.TYPE_DOUBLE:

            return 8;

        default:

            throw new IllegalArgumentException("Data Type " + dataType + " not supported.");

        }

    }

    @Override

    public List<PageManager> createSimpleBandPageManagerList(File[] files, int rows, int columns,

        int[] dataType) throws IOException {

        if (files == null) {

            files = new File[dataType.length];

        }

        if (dataType.length != files.length) {

            throw new IllegalArgumentException(

                "Length files array has to be same as length dataType array.");

        }

        List<PageManager> pageManagers = new ArrayList<PageManager>();

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

            pageManagers

                .add(this.createSimpleBandPageManager(files[i], rows, columns, dataType[i]));

        }

        return pageManagers;

    }

    @Override

    public Buffer createClippedBuffer(Buffer buffer, Envelope envelope) throws BufferException {

        if(buffer==null){

            try{

                throw new IllegalArgumentException("Can't clip a null buffer");

            } catch (IllegalArgumentException e){

                logger.warn(e.getMessage(), e);

                throw e;

            }

        }

        if(envelope==null){

            try{

                throw new IllegalArgumentException("Null envelope");

            } catch (IllegalArgumentException e){

                logger.warn(e.getMessage(), e);

                throw e;

            }

        }

        Envelope bufferEnvelope = null;

        try {

            bufferEnvelope = buffer.getEnvelope();

        } catch (Exception e) {

            logger.warn("Can't get buffer envelope", e);

            throw new BufferException(e);

        }

        if (!bufferEnvelope.intersects(envelope)) {

            return null;

        }

        try {

            Geometry intersection = bufferEnvelope.getGeometry().intersection(envelope.getGeometry());

            if (intersection == null) {

                return null;

            }

        } catch (GeometryOperationNotSupportedException | GeometryOperationException e1) {

            logger.warn("Can't get intersection between two envelopes", e1);

            return null;

        }

        return new ClippedBuffer(buffer, envelope);

    }

    @Override

    public Buffer createConvertedTypeBuffer(Buffer buffer, int type) throws BufferException {

        return new ConvertedTypeBuffer(buffer, type);

    }

    @Override

    public Band createClippedBand(Buffer buffer, Band band) throws CreateBandTypeException {

        int dataType = band.getDataType();

        switch (dataType) {

        case BufferManager.TYPE_BYTE:

            return new ClippedBandByte(buffer, band);

        case BufferManager.TYPE_SHORT:

            return new ClippedBandShort(buffer, band);

        case BufferManager.TYPE_INT:

            return new ClippedBandInt(buffer, band);

        case BufferManager.TYPE_FLOAT:

            return new ClippedBandFloat(buffer, band);

        case BufferManager.TYPE_DOUBLE:

            return new ClippedBandDouble(buffer, band);

        default:

            throw new CreateBandTypeException(dataType);

        }

    }

    @Override

    public Band createConvertedTypeBand(Buffer buffer, Band band, int type) throws BandException {

        switch (type) {

        case BufferManager.TYPE_BYTE:

            return new ConvertedTypeBandByte(buffer, band);

        case BufferManager.TYPE_SHORT:

        case BufferManager.TYPE_USHORT:

            return new ConvertedTypeBandShort(buffer, band);

        case BufferManager.TYPE_INT:

            return new ConvertedTypeBandInt(buffer, band);

        case BufferManager.TYPE_FLOAT:

            return new ConvertedTypeBandFloat(buffer, band);

        case BufferManager.TYPE_DOUBLE:

            return new ConvertedTypeBandDouble(buffer, band);

        default:

            throw new CreateBandTypeException(type);

        }

    }

    @Override

    public BandInfo createBandInfo(int band, String name, String description, int dataType,

        List<Entry<Object, Object>> values) {

        return new DefaultBandInfo(band, name, description, dataType, values);

    }

    @Override

    public Buffer createBuffer(Buffer buffer, boolean paginated) throws BufferException {

        List<PageManager> pageManagers = null;

        try {

            if (paginated) {

                pageManagers = createPageManagerList(buffer.getBandCount(), buffer.getRows(), buffer.getColumns(), buffer.getBandTypes());

            }

            Buffer newBuffer =

                createBuffer(buffer.getRows(), buffer.getColumns(), buffer.getBandTypes(), buffer.getBandNoData(),

                    buffer.getProjection(), buffer.getEnvelope(), pageManagers);

            for (int i = 0; i < newBuffer.getBandCount(); i++) {

                newBuffer.getBand(i).copyFrom(buffer.getBand(i));

            }

            return newBuffer;

        } catch (IOException | BandException | LocatorException | CreateEnvelopeException e) {

            throw new CreateBufferException(e);

        }

    }

    @Override

    public BandPageManager createAwtRasterBandPageManager(Raster img, int band) {

        return new AwtRasterBandPageManager(img, band);

    }

    @Override

    public List<PageManager> createAwtRasterBandPageManagerList(Raster img) throws IOException {

        List<PageManager> pageManagers;

        pageManagers = new ArrayList<PageManager>();

        for (int i = 0; i <img.getNumBands(); i++) {

            PageManager pageManager =

                createAwtRasterBandPageManager(img, i);

            pageManagers.add(pageManager);

        }

        return pageManagers;

    }

    /**

     * @param buffer

     * @return

     * @throws IOException

     */

    private List<PageManager> createPageManagerList(int bands, int rows, int columns, int[] bandTypes) throws IOException {

        List<PageManager> pageManagers;

        pageManagers = new ArrayList<PageManager>();

        FoldersManager foldersManager = ToolsLocator.getFoldersManager();

        File file;

        for (int i = 0; i <bands; i++) {

            String filename = "temp-buffer-"+this.simplePaginatedCounter+"-band-"+i+".tmp";

            file = foldersManager.getUniqueTemporaryFile(filename);

            PageManager pageManager =

                createSimpleBandPageManager(file, rows, columns,  bandTypes[i]);

            pageManagers.add(pageManager);

        }

        this.simplePaginatedCounter++;

        return pageManagers;

    }

    public List<Buffer> createOneBufferPerBand(Buffer buffer, boolean paginated) throws BufferException {

        ArrayList<Buffer> buffers = new ArrayList<Buffer>();

        try {

            for (int i = 0; i < buffer.getBandCount(); i++) {

                int[] dataType = {buffer.getBandTypes()[i]};

                List<PageManager> pageManagers = null;

                if (paginated) {

                    pageManagers = createPageManagerList(1, buffer.getRows(), buffer.getColumns(), dataType);

                }

                int[] bandTypes = new int[1];

                bandTypes[0] = dataType[0];

                NoData[] bandNoDatas = new NoData[1];

                bandNoDatas[0] = buffer.getBandNoData()[i]; //.getBand(i).getNoData();

                Buffer newBuffer =

                    createBuffer(buffer.getRows(), buffer.getColumns(), bandTypes, bandNoDatas, buffer.getProjection(),

                        buffer.getEnvelope(), pageManagers);

                newBuffer.getBand(0).copyFrom(buffer.getBand(i));

                buffers.add(newBuffer);

            }

        } catch (IOException | BandException | LocatorException | CreateEnvelopeException e) {

            throw new CreateBufferException(e);

        }

        return buffers;

    }

    /**

     * @param raster

     * @return

     */

    public int getBufferTypeFromAwtRaster(Raster raster) {

        int bufferType;

        int dataType = raster.getSampleModel().getDataType();

        switch (dataType) {

        case java.awt.image.DataBuffer.TYPE_BYTE:

            bufferType = BufferManager.TYPE_BYTE;

            break;

        case java.awt.image.DataBuffer.TYPE_USHORT:

            bufferType = BufferManager.TYPE_USHORT;

            break;

        case java.awt.image.DataBuffer.TYPE_SHORT:

            bufferType = BufferManager.TYPE_SHORT;

            break;

        case java.awt.image.DataBuffer.TYPE_INT:

            bufferType = BufferManager.TYPE_INT;

            break;

        case java.awt.image.DataBuffer.TYPE_FLOAT:

            bufferType = BufferManager.TYPE_FLOAT;

            break;

        case java.awt.image.DataBuffer.TYPE_DOUBLE:

            bufferType = BufferManager.TYPE_DOUBLE;

            break;

        // case java.awt.image.DataBuffer.TYPE_UNDEFINED:

        // bufferType = BufferManager.TYPE_UNDEFINED;

        // break;

        default:

            throw new UnsupportedOperationException("DataBuffer type '" + dataType + "' no yet supported.");

        }

        return bufferType;

    }

    private Buffer createBuffer(BufferedImage img, IProjection projection, Envelope envelope) throws BufferException {

        return createBuffer(img, projection, envelope, false);

    }

    private Buffer createBuffer(BufferedImage img, IProjection projection, Envelope envelope, boolean paginated) throws BufferException {

        SampleModel sampleModel = img.getSampleModel();

        int dataType = sampleModel.getDataType();

        int bufferType;

        bufferType = getBufferTypeFromAwtRaster(img.getRaster());

        int bands = sampleModel.getNumBands();

        int[] bandDataTypes = new int[bands];

        NoData[] bandNoData = new NoData[bands];

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

            bandDataTypes[i] = bufferType;

            bandNoData[i] = null;

        }

        List<PageManager> pageManagers = null;

        if (paginated) {

            try {

                pageManagers = createPageManagerList(bands, img.getHeight(), img.getWidth(), bandDataTypes);

            } catch (IOException e) {

                throw new CreateBufferException(e);

            }

        }

        Buffer buffer =

            createBuffer(img.getHeight(), img.getWidth(), bandDataTypes, bandNoData, projection, envelope, pageManagers);

        Raster raster = img.getData();

        DataBuffer dataBuffer = raster.getDataBuffer();

        for (int i = 0; i < bands; i++) {

            Band band = buffer.getBand(i);

            if (bufferType == BufferManager.TYPE_BYTE) {

                byte[] rowBuffer = (byte[]) band.createRowBuffer();

                int[] intRowBuffer = new int[rowBuffer.length];

                for (int row = 0; row < img.getHeight(); row++) {

                    sampleModel.getSamples(0, row, img.getWidth(), 1, i, intRowBuffer, dataBuffer);

                    for (int c = 0; c < rowBuffer.length; c++) {

                        rowBuffer[c] = (byte) intRowBuffer[c];

                    }

                    band.putRow(row, rowBuffer);

                }

            } else if (bufferType == BufferManager.TYPE_INT) {

                int[] rowBuffer = (int[]) band.createRowBuffer();

                for (int row = 0; row < img.getHeight(); row++) {

                    sampleModel.getSamples(0, row, img.getWidth(), 1, i, rowBuffer, dataBuffer);

                    band.putRow(row, rowBuffer);

                }

            }

        }

        return buffer;

    }

    @Override

    public Buffer createRGBABuffer(BufferedImage img, IProjection projection, Envelope envelope) throws BufferException {

        int imageType = img.getType();

        if(imageType == BufferedImage.TYPE_4BYTE_ABGR || imageType == BufferedImage.TYPE_4BYTE_ABGR_PRE) {

            return createBuffer(img, projection, envelope);

        }

        int bands = 4;

        int[] bandDataTypes = new int[bands];

        NoData[] bandNoData = new NoData[bands];

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

            bandDataTypes[i] = BufferManager.TYPE_BYTE;

            bandNoData[i] = null;

        }

        Buffer buffer = null;

        buffer =

            createBuffer(img.getHeight(), img.getWidth(), bandDataTypes, bandNoData, projection, envelope);

        for (int r = 0; r < img.getHeight(); r++) {

            for (int c = 0; c < img.getWidth(); c++) {

                int color = img.getRGB(c, r);

                Color awtColor = new Color(color, true);

                buffer.getBandByte(0).set(r, c, (byte)awtColor.getRed()); // RED

                buffer.getBandByte(1).set(r, c, (byte)awtColor.getGreen()); // GREEN

                buffer.getBandByte(2).set(r, c, (byte)awtColor.getBlue()); // BLUE

                buffer.getBandByte(3).set(r, c, (byte)awtColor.getAlpha()); // ALPHA

            }

        }

        return buffer;

    }

    @Override

    public Buffer createRGBBuffer(BufferedImage img, IProjection projection, Envelope envelope) throws BufferException {

        int imageType = img.getType();

        if(imageType == BufferedImage.TYPE_3BYTE_BGR) {

            return createBuffer(img, projection, envelope);

        }

        int bands = 3;

        int[] bandDataTypes = new int[bands];

        NoData[] bandNoData = new NoData[bands];

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

            bandDataTypes[i] = BufferManager.TYPE_BYTE;

            bandNoData[i] = null;

        }

        Buffer buffer = null;

        buffer =

            createBuffer(img.getHeight(), img.getWidth(), bandDataTypes, bandNoData, projection, envelope);

        for (int r = 0; r < img.getHeight(); r++) {

            for (int c = 0; c < img.getWidth(); c++) {

                int color = img.getRGB(c, r);

                Color awtColor = new Color(color, true);

                buffer.getBandByte(0).set(r, c, (byte)awtColor.getRed()); // RED

                buffer.getBandByte(1).set(r, c, (byte)awtColor.getGreen()); // GREEN

                buffer.getBandByte(2).set(r, c, (byte)awtColor.getBlue()); // BLUE

            }

        }

        return buffer;

    }

    @Override

    public String getTypeName(int type) {

        DataTypesManager dtManager = ToolsLocator.getDataTypesManager();

        String[] names = {

            dtManager.getTypeName(DataTypes.BYTE),

            "UShort",

            "Short",

            dtManager.getTypeName(DataTypes.INT),

            dtManager.getTypeName(DataTypes.FLOAT),

            dtManager.getTypeName(DataTypes.DOUBLE),

        };

        if(type<=5){

            return names[type];

        }

        if(type==32){

            return "Undefined";

        }

        return "Unknow";

    }

    public String getBufferTypeName(int dataType) {

        // FIXME

        switch (dataType) {

        case BufferManager.TYPE_BYTE:

            return "Byte";

        case BufferManager.TYPE_USHORT:

            return "Unsigned short";

        case BufferManager.TYPE_SHORT:

            return "Short";

        case BufferManager.TYPE_INT:

            return "Integer";

        case BufferManager.TYPE_FLOAT:

            return "Float";

        case BufferManager.TYPE_DOUBLE:

            return "Double";

        default:

            throw new IllegalArgumentException();

        }

    }

    @Override

    public Object coerce(int dataType, Object value) throws CoercionException {

        Coercion coercion = null;

        switch (dataType) {

        case BufferManager.TYPE_BYTE:

//            coercion = new CoerceToByte();

//            return coercion.coerce(value);

            coercion = new CoerceToInt();

            return new Integer(Math.abs(0xFF & ((Integer) coercion.coerce(value)).intValue())).byteValue();

        case BufferManager.TYPE_USHORT:

        case BufferManager.TYPE_SHORT:

            coercion = new CoerceToInt();

            return 0xFFFF & ((Integer) coercion.coerce(value)).intValue();

        case BufferManager.TYPE_INT:

            coercion = new CoerceToInt();

            return coercion.coerce(value);

        case BufferManager.TYPE_FLOAT:

            coercion = new CoerceToFloat();

            return coercion.coerce(value);

        case BufferManager.TYPE_DOUBLE:

            coercion = new CoerceToDouble();

            return coercion.coerce(value);

        default:

            throw new IllegalArgumentException("Unknow data type.");

        }

    }

    @Override

    public BufferDimensions createBufferDimensions(int rows, int columns, Envelope envelope) {

        return new DefaultBufferDimensions(rows, columns, envelope);

    }

    @Override

    public File getLastFolderUsedToSaveRaster() {

        return this.lastFolderUsedToSave;

    }

    @Override

    public void setLastFolderUsedToSaveRaster(File folder) {

        this.lastFolderUsedToSave = folder;

    }

    @Override

    public Operation createOperation(String name) {

        OperationFactory factory = getOperationFactory(name);

        return factory.create();

    }

    @Override

    public DynObject createOperationParameters(String name) {

        OperationFactory factory = getOperationFactory(name);

        return factory.createParameters();

    }

    @Override

    public void registerOperationFactory(OperationFactory factory) {

        factory.getName();

        this.operationFactoriesRegister.put(factory.getName(), factory);

    }

    @Override

    public List<OperationFactory> getOperationFactories() {

        return new ArrayList<OperationFactory>(this.operationFactoriesRegister.values());

    }

    @Override

    public OperationFactory getOperationFactory(String name) {

        return this.operationFactoriesRegister.get(name);

    }

    @Override

    public Buffer execute(SimpleTaskStatus status, String name, Buffer buffer, DynObject parameters) throws BufferOperationException {

        OperationFactory factory = getOperationFactory(name);

        Operation operation = factory.create();

        return operation.execute(status, buffer, parameters);

    }

    @Override

    public Kernel createKernel(double[][] k) {

        return new DefaultKernel(k);

    }

    @Override

    public Kernel createKernel(double[][] k, double divisor) {

        return new DefaultKernel(k, divisor);

    }

    @Override

    public OperationListEntry createOperationListEntry(Operation operation, DynObject parameters) {

        return new DefaultOperationListEntry(operation, parameters);

    }

    @Override

    public OperationList createOperationList() {

        return new DefaultOperationList();

    }

    @Override

    public Buffer createBufferFromAwtRaster(Raster raster, IProjection projection, Envelope envelope)

        throws IOException, BufferException {

        List<PageManager> pageManagers = createAwtRasterBandPageManagerList(raster);

        int[] dataTypes = new int[(raster.getNumBands())];

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

            dataTypes[i] = getBufferTypeFromAwtRaster(raster);

        }

        return createBuffer(raster.getHeight(), raster.getWidth(), dataTypes, null, projection, envelope, pageManagers);

    }

}