Application: gvSIG desktop » gvSIG raster

import org.gvsig.fmap.dal.file.jimi.JimiRasterStoreProviderParameters;

import org.gvsig.fmap.dal.raster.api.RasterStore;

import org.gvsig.fmap.dal.raster.impl.DefaultRasterStore;

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

import org.gvsig.fmap.mapcontext.ViewPort;

import org.gvsig.fmap.mapcontext.raster.api.RasterLayer;

            RasterLayer layer=new DefaultRasterLayer(store, legend);

            assertNotNull(layer);

            BufferedImage image = new BufferedImage(589, 467, BufferedImage.TYPE_INT_ARGB);

            ViewPort viewPort = new ViewPort(projection);

            viewPort.setImageSize(new Dimension(589, 467));

            viewPort.refreshExtent();

            double heightPixel = 0;

            try {

                // Clip and interpolate buffer with view port envelope

                widthPixel =

                    getWidthPixel(bufferToDraw.getEnvelope(), viewPort.getEnvelope().getLength(0)

                        / viewPort.getImageWidth());

                "Color interpretation is not RGB,RGBA or BGR and buffer was be drawn without color table");

        }

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

            for (int j = 0; j < buffer.getColumns(); j++) {

                Number redValue = (Number) redBand.get(i, j);

                Number blueValue = (Number) blueBand.get(i, j);

                Number greenValue = (Number) greenBand.get(i, j);

                Number alphaValue = 255;

                if (alphaBand != null) {

                    alphaValue = (Number) alphaBand.get(i, j);

        this.filters = filterList;

    }

    public static void registerDefinition() {

        PersistenceManager manager = ToolsLocator.getPersistenceManager();

        DynStruct definition = manager.getDefinition(PERSISTENT_NAME);

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

import java.io.IOException;

/**

     * @param dataType

     * @throws IOException

     */

    /**

     * @param buffer

     * @param dataType

     * @throws IOException

     */

}

 */

public class PaginatedBandDouble extends AbstractPaginatedBand implements BandDouble {

    /**

     * @param rows

     * @param columns

     */

    public PaginatedBandDouble(int rows, int columns, NoData noData, BandPageManager pageManager) {

        super(rows, columns, noData, pageManager);

    }

    @Override

        for(int row=0; row<this.rows; row+=this.rowsPerPage){

            loadPage(row);

        }

    }

    @Override

    public double getValue(int row, int column) {

        loadPage(row);

    }

    @Override

    protected void doSetValue(int row, int column, double value) {

        loadPage(row);

    }

    @Override

    @Override

    public void fetchRow(int row, Object rowBuffer) {

        loadPage(row);

        double[] target = (double[]) rowBuffer;

        System.arraycopy(source, (row-firstRowOfPage)*this.columns, target, 0, this.columns);

    }

    protected void doPutRow(int row, Object rowBuffer) {

        loadPage(row);

        double[] source = (double[]) rowBuffer;

        System.arraycopy(source, 0, target, (row-firstRowOfPage)*this.columns, this.columns);

    }

}

import java.util.Iterator;

import java.util.List;

import org.cresques.cts.ICoordTrans;

import org.cresques.cts.IProjection;

import org.slf4j.Logger;

                this.envelope =

                    GeometryLocator.getGeometryManager().createEnvelope(0, 0, columns, rows, Geometry.SUBTYPES.GEOM2D);

            }

        } catch (Exception e) {

            throw new CreateBufferException(e);

        }

        Buffer cloned;

        try {

            cloned =

                    this.getProjection());

        } catch (LocatorException | BufferException e) {

            throw new CloneNotSupportedException("Can't clone buffer.");

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

            cloned.addBand((Band) this.getBand(i).clone());

        }

        return cloned;

    }

}

                        }

                        dx = posX - ((int) posX);

                        try {

                            setBandValueFromDouble(iRow, iCol, targetBand, getBilinearValue(dx, dy, kernel));

                        } catch (ArrayIndexOutOfBoundsException e) {

                            LOG.warn(

                        }

                        dx = posX - ((int) posX);

                        try {

                            setBandValueFromDouble(iRow, iCol, targetBand, getInverseDistanceValue(dx, dy, kernel));

                        } catch (ArrayIndexOutOfBoundsException e) {

                            LOG.warn(

                        try {

                            double[][] submatrix = get4x4Submatrix(((int) posY), ((int) posX), source, sourceBand);

                            if (submatrix == null) {

                                setBandValueFromDouble(iRow, iCol, targetBand, getBilinearValue(dx, dy, kernel));

                            } else {

                                setBandValueFromDouble(iRow, iCol, targetBand, getBicubicSplineValue(dx, dy, submatrix));

import java.io.IOException;

import java.io.OutputStream;

import java.io.RandomAccessFile;

import java.nio.ByteBuffer;

import org.apache.commons.io.FileUtils;

    }

        int pos = row*this.columns;

        raf.seek(pos);

    }

        int pos = row*this.columns;

        raf.seek(pos);

    }

    @Override

        } catch (GeometryOperationNotSupportedException | GeometryOperationException e1) {

            throw new CreateBufferException(e1);

        }

        this.bands = new ArrayList<Band>();

        try {

            throw new CreateBufferException(e);

        }

    }

    private void createBands(Band[] bands) throws BandException {

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

import java.nio.IntBuffer;

import java.util.Arrays;

 */

public class PaginatedBandInt extends AbstractPaginatedBand implements BandInt {

    /**

     * @param rows

     * @param columns

     */

    public PaginatedBandInt(int rows, int columns, NoData noData, BandPageManager pageManager) {

        super(rows, columns, noData, pageManager);

    }

    @Override

        for(int row=0; row<this.rows; row+=this.rowsPerPage){

            loadPage(row);

        }

    }

    @Override

    public int getValue(int row, int column) {

        loadPage(row);

    }

    @Override

    protected void doSetValue(int row, int column, int value) {

        loadPage(row);

    }

    @Override

    @Override

    public void fetchRow(int row, Object rowBuffer) {

        loadPage(row);

        int[] target = (int[]) rowBuffer;

        System.arraycopy(source, (row-firstRowOfPage)*this.columns, target, 0, this.columns);

    }

    protected void doPutRow(int row, Object rowBuffer) {

        loadPage(row);

        int[] source = (int[]) rowBuffer;

    }

}

 */

public class PaginatedBandShort extends AbstractPaginatedBand implements BandShort {

    /**

     * @param rows

     */

    public PaginatedBandShort(int rows, int columns, NoData noData, BandPageManager pageManager) {

        super(rows, columns, noData, pageManager);

    }

    @Override

        for(int row=0; row<this.rows; row+=this.rowsPerPage){

            loadPage(row);

        }

    }

    @Override

    public short getValue(int row, int column) {

        loadPage(row);

    }

    @Override

    protected void doSetValue(int row, int column, short value) {

        loadPage(row);

    }

    @Override

    @Override

    public void fetchRow(int row, Object rowBuffer) {

        loadPage(row);

        short[] target = (short[]) rowBuffer;

        System.arraycopy(source, (row-firstRowOfPage)*this.columns, target, 0, this.columns);

    }

    protected void doPutRow(int row, Object rowBuffer) {

        loadPage(row);

        short[] source = (short[]) rowBuffer;

        System.arraycopy(source, 0, target, (row-firstRowOfPage)*this.columns, this.columns);

    }

}

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

import java.io.IOException;

import java.nio.ByteBuffer;

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

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

 */

public abstract class AbstractPaginatedBand extends AbstractBand {

    protected int firstRowOfPage;

    protected int rowsPerPage;

    protected BandPageManager pageManager;

    protected static final int MAX_PREFERED_SIZE = 10485760; // 10MB;

    public AbstractPaginatedBand(int rows, int columns, NoData noData, BandPageManager pageManager) {

        this.rows = rows;

        this.columns = columns;

        calculateRowsPerPage();

        if (noData == null) {

            this.noData = BufferLocator.getBufferManager().createNoData(null, null);

        } else {

    }

    protected void loadPage(int row) {

            return;

        }

        saveCurrentPage();

        firstRowOfPage = row / rowsPerPage; //Divisi?n entera

        try {

                rowsInPage = this.rows - firstRowOfPage;

            }

            this.pageManager.load(data, firstRowOfPage, rowsInPage, this.getDataType());

        } catch (IOException e) {

            throw new RuntimeException("Can't save current page", e);

        }

 */

public class PaginatedBandByte extends AbstractPaginatedBand implements BandByte {

    /**

     * @param rows

     */

    public PaginatedBandByte(int rows, int columns, NoData noData, BandPageManager pageManager) {

        super(rows, columns, noData, pageManager);

    }

    @Override

        for(int row=0; row<this.rows; row+=this.rowsPerPage){

            loadPage(row);

        }

    }

    @Override

    public byte getValue(int row, int column) {

        loadPage(row);

    }

    @Override

    protected void doSetValue(int row, int column, byte value) {

        loadPage(row);

    }

    @Override

    @Override

    public void fetchRow(int row, Object rowBuffer) {

        loadPage(row);

        byte[] target = (byte[]) rowBuffer;

        System.arraycopy(source, (row-firstRowOfPage)*this.columns, target, 0, this.columns);

    }

    protected void doPutRow(int row, Object rowBuffer) {

        loadPage(row);

        byte[] source = (byte[]) rowBuffer;

        System.arraycopy(source, 0, target, (row-firstRowOfPage)*this.columns, this.columns);

    }

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

import java.nio.FloatBuffer;

import java.util.Arrays;

 */

public class PaginatedBandFloat extends AbstractPaginatedBand implements BandFloat {

    /**

     * @param rows

     */

    public PaginatedBandFloat(int rows, int columns, NoData noData, BandPageManager pageManager) {

        super(rows, columns, noData, pageManager);

    }

    @Override

        for(int row=0; row<this.rows; row+=this.rowsPerPage){

            loadPage(row);

        }

    }

    @Override

    public float getValue(int row, int column) {

        loadPage(row);

    }

    @Override

    protected void doSetValue(int row, int column, float value) {

        loadPage(row);

    }

    @Override

    @Override

    public void fetchRow(int row, Object rowBuffer) {

        loadPage(row);

        float[] target = (float[]) rowBuffer;

        System.arraycopy(source, (row-firstRowOfPage)*this.columns, target, 0, this.columns);

    }

    protected void doPutRow(int row, Object rowBuffer) {

        loadPage(row);

        float[] source = (float[]) rowBuffer;

        System.arraycopy(source, 0, target, (row-firstRowOfPage)*this.columns, this.columns);

    }

}

package org.gvsig.fmap.dal.file.jimi;

import java.io.IOException;

import java.nio.ByteBuffer;

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

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

    }

    @Override

        throws IOException {

        int firstCell =  firstRow * image.columns;

        int lastCell = firstCell + numberRows*image.columns;

        byte[] bandBuffer = image.buffer[band];

        switch(dataType) {

            case BufferManager.TYPE_INT:

                for( int cell =firstCell ; cell<lastCell ; cell++ ) {

                }

                break;

            case BufferManager.TYPE_BYTE:

                for( int cell =firstCell ; cell<lastCell ; cell++ ) {

                }

                break;

            case BufferManager.TYPE_DOUBLE:

                for( int cell =firstCell ; cell<lastCell ; cell++ ) {

                }

                break;

            case BufferManager.TYPE_FLOAT:

                for( int cell =firstCell ; cell<lastCell ; cell++ ) {

                }

                break;

            case BufferManager.TYPE_SHORT:

            case BufferManager.TYPE_USHORT:

                for( int cell =firstCell ; cell<lastCell ; cell++ ) {

                }

                break;

        }

    }

    @Override

        throws IOException {

        throw new UnsupportedOperationException();