/ - Diff - gvSIG raster - gvSIG

         public void testDefaultBandDoubleIntInt() {
             init();
             Band band=new DefaultBandDouble(ROWS, COLUMNS);
             Band band=new MemoryBandDouble(ROWS, COLUMNS);
             band.fill(testValueZero);
             for (int i=0;i<band.getRows();i++){
                 double[] rowBuffer = new double[COLUMNS];
-...
             init();
             BufferManager bufferManager = BufferLocator.getBufferManager();
             NoData noData=bufferManager.createNoData(Double.NaN, Double.NaN);
             Band band=new DefaultBandDouble(ROWS, COLUMNS,noData);
             Band band=new MemoryBandDouble(ROWS, COLUMNS,noData);
             band.fill(testValueZero);
             for (int i=0;i<band.getRows();i++){
                 double[] rowBuffer = new double[COLUMNS];
-...
         public void testCopyFrom() {
             init();
             Band band=new DefaultBandDouble(ROWS, COLUMNS);
             Band band=new MemoryBandDouble(ROWS, COLUMNS);
             band.fill(testValueOne);
             try {
                 band.copyFrom(testBand1);
-...
+        }
         public void testGetValue() {
             DefaultBandDouble band=new DefaultBandDouble(ROWS, COLUMNS);
             MemoryBandDouble band=new MemoryBandDouble(ROWS, COLUMNS);
             band.fill(testValueOne);
             assertEquals(testValueOne, band.getValue(ROWS-1, COLUMNS-1));
+        }
         public void testSetValue() {
             DefaultBandDouble band=new DefaultBandDouble(ROWS, COLUMNS);
             MemoryBandDouble band=new MemoryBandDouble(ROWS, COLUMNS);
             band.fill(testValueZero);
             band.setValue(ROWS-1, COLUMNS-1, testValueOne);
             assertEquals(testValueOne, band.getValue(ROWS-1, COLUMNS-1));

         public void testDefaultBandIntIntInt() {
             init();
             Band band=new DefaultBandInt(ROWS, COLUMNS);
             Band band=new MemoryBandInt(ROWS, COLUMNS);
             band.fill(testValueZero);
             for (int i=0;i<band.getRows();i++){
                 int[] rowBuffer = new int[COLUMNS];
-...
             init();
             BufferManager bufferManager = BufferLocator.getBufferManager();
             NoData noData=bufferManager.createNoData(null, null);
             Band band=new DefaultBandInt(ROWS, COLUMNS,noData);
             Band band=new MemoryBandInt(ROWS, COLUMNS,noData);
             band.fill(testValueZero);
             for (int i=0;i<band.getRows();i++){
                 int[] rowBuffer = new int[COLUMNS];
-...
         public void testCopyFrom() {
             init();
             Band band=new DefaultBandInt(ROWS, COLUMNS);
             Band band=new MemoryBandInt(ROWS, COLUMNS);
             band.fill(testValueOne);
             try {
                 band.copyFrom(testBand1);
-...
+        }
         public void testGetValue() {
             DefaultBandInt band=new DefaultBandInt(ROWS, COLUMNS);
             MemoryBandInt band=new MemoryBandInt(ROWS, COLUMNS);
             band.fill(testValueOne);
             assertEquals(testValueOne, band.getValue(ROWS-1, COLUMNS-1));
+        }
         public void testSetValue() {
             DefaultBandInt band=new DefaultBandInt(ROWS, COLUMNS);
             MemoryBandInt band=new MemoryBandInt(ROWS, COLUMNS);
             band.fill(testValueZero);
             band.setValue(ROWS-1, COLUMNS-1, testValueOne);
             assertEquals(testValueOne, band.getValue(ROWS-1, COLUMNS-1));

         public void testDefaultBandShortIntInt() {
             init();
             Band band=new DefaultBandShort(ROWS, COLUMNS);
             Band band=new MemoryBandShort(ROWS, COLUMNS);
             band.fill(testValueZero);
             for (int i=0;i<band.getRows();i++){
                 short[] rowBuffer = new short[COLUMNS];
-...
             init();
             BufferManager bufferManager = BufferLocator.getBufferManager();
             NoData noData=bufferManager.createNoData(null, null);
             Band band=new DefaultBandShort(ROWS, COLUMNS,noData);
             Band band=new MemoryBandShort(ROWS, COLUMNS,noData);
             band.fill(testValueZero);
             for (int i=0;i<band.getRows();i++){
                 short[] rowBuffer = new short[COLUMNS];
-...
         public void testCopyFrom() {
             init();
             Band band=new DefaultBandShort(ROWS, COLUMNS);
             Band band=new MemoryBandShort(ROWS, COLUMNS);
             band.fill(testValueOne);
             try {
                 band.copyFrom(testBand1);
-...
+        }
         public void testGetValue() {
             DefaultBandShort band=new DefaultBandShort(ROWS, COLUMNS);
             MemoryBandShort band=new MemoryBandShort(ROWS, COLUMNS);
             band.fill(testValueOne);
             assertEquals(testValueOne, band.getValue(ROWS-1, COLUMNS-1));
+        }
         public void testSetValue() {
             DefaultBandShort band=new DefaultBandShort(ROWS, COLUMNS);
             MemoryBandShort band=new MemoryBandShort(ROWS, COLUMNS);
             band.fill(testValueZero);
             band.setValue(ROWS-1, COLUMNS-1, testValueOne);
             assertEquals(testValueOne, band.getValue(ROWS-1, COLUMNS-1));

         public void testDefaultBandByteIntInt() {
             init();
             Band band=new DefaultBandByte(ROWS, COLUMNS);
             Band band=new MemoryBandByte(ROWS, COLUMNS);
             band.fill(testValueZero);
             for (int i=0;i<band.getRows();i++){
                 byte[] rowBuffer = new byte[COLUMNS];
-...
             init();
             BufferManager bufferManager = BufferLocator.getBufferManager();
             NoData noData=bufferManager.createNoData(null, null);
             Band band=new DefaultBandByte(ROWS, COLUMNS,noData);
             Band band=new MemoryBandByte(ROWS, COLUMNS,noData);
             band.fill(testValueZero);
             for (int i=0;i<band.getRows();i++){
                 byte[] rowBuffer = new byte[COLUMNS];
-...
         public void testCopyFrom() {
             init();
             Band band=new DefaultBandByte(ROWS, COLUMNS);
             Band band=new MemoryBandByte(ROWS, COLUMNS);
             band.fill(testValueOne);
             try {
                 band.copyFrom(testBand1);
-...
+        }
         public void testGetValue() {
             DefaultBandByte band=new DefaultBandByte(ROWS, COLUMNS);
             MemoryBandByte band=new MemoryBandByte(ROWS, COLUMNS);
             band.fill(testValueOne);
             assertEquals(testValueOne, band.getValue(ROWS-1, COLUMNS-1));
+        }
         public void testSetValue() {
             DefaultBandByte band=new DefaultBandByte(ROWS, COLUMNS);
             MemoryBandByte band=new MemoryBandByte(ROWS, COLUMNS);
             band.fill(testValueZero);
             band.setValue(ROWS-1, COLUMNS-1, testValueOne);
             assertEquals(testValueOne, band.getValue(ROWS-1, COLUMNS-1));

         public void testDefaultBandFloatIntInt() {
             init();
             Band band=new DefaultBandFloat(ROWS, COLUMNS);
             Band band=new MemoryBandFloat(ROWS, COLUMNS);
             band.fill(testValueZero);
             for (int i=0;i<band.getRows();i++){
                 float[] rowBuffer = new float[COLUMNS];
-...
             init();
             BufferManager bufferManager = BufferLocator.getBufferManager();
             NoData noData=bufferManager.createNoData(null, null);
             Band band=new DefaultBandFloat(ROWS, COLUMNS,noData);
             Band band=new MemoryBandFloat(ROWS, COLUMNS,noData);
             band.fill(testValueZero);
             for (int i=0;i<band.getRows();i++){
                 float[] rowBuffer = new float[COLUMNS];
-...
         public void testCopyFrom() {
             init();
             Band band=new DefaultBandFloat(ROWS, COLUMNS);
             Band band=new MemoryBandFloat(ROWS, COLUMNS);
             band.fill(testValueOne);
             try {
                 band.copyFrom(testBand1);
-...
+        }
         public void testGetValue() {
             DefaultBandFloat band=new DefaultBandFloat(ROWS, COLUMNS);
             MemoryBandFloat band=new MemoryBandFloat(ROWS, COLUMNS);
             band.fill(testValueOne);
             assertEquals(testValueOne, band.getValue(ROWS-1, COLUMNS-1));
+        }
         public void testSetValue() {
             DefaultBandFloat band=new DefaultBandFloat(ROWS, COLUMNS);
             MemoryBandFloat band=new MemoryBandFloat(ROWS, COLUMNS);
             band.fill(testValueZero);
             band.setValue(ROWS-1, COLUMNS-1, testValueOne);
             assertEquals(testValueOne, band.getValue(ROWS-1, COLUMNS-1));

     package org.gvsig.raster.lib.buffer.impl;
     import java.util.Arrays;
     import org.gvsig.raster.lib.buffer.api.Band;
     import org.gvsig.raster.lib.buffer.api.Band.BandDouble;
     import org.gvsig.raster.lib.buffer.api.BufferManager;
     import org.gvsig.raster.lib.buffer.api.NoData;
     import org.gvsig.raster.lib.buffer.api.BufferLocator;
     import org.gvsig.raster.lib.buffer.impl.exceptions.CopyFromBandException;
     /**
      * @author fdiaz
+     *
      */
     public class DefaultBandDouble extends AbstractBand implements BandDouble {
         double[] data;
         /**
          * @param rows
          * @param columns
          */
         public DefaultBandDouble(int rows, int columns) {
             this(rows, columns, BufferLocator.getBufferManager().createNoData(null, null));
+        }
         /**
          * @param rows
          * @param columns
          * @param noData
          */
         public DefaultBandDouble(int rows, int columns, NoData noData) {
             this.rows = rows;
             this.columns = columns;
             data = new double[rows * columns];
             if (noData == null) {
                 this.noData = BufferLocator.getBufferManager().createNoData(null, null);
             } else {
                 this.noData = noData;
+            }
+        }
         @Override
         public int getDataType() {
             return BufferManager.TYPE_DOUBLE;
+        }
         @Override
         public Object get(int row, int column) {
             return getValue(row, column);
+        }
         @Override
         public void set(int row, int column, Object value) {
             setValue(row, column, (double) value);
+        }
         @Override
         public void fill(Object value) {
             if (value == null) {
                 if (getNoData().isDefined()) {
                     value = getNoData().getValue();
                 } else {
                     // Do nothing, no data value is undefined
                     return;
+                }
+            }
             Arrays.fill(data, (double) value);
+        }
         double[] getData() {
             return data;
+        }
         @Override
         public void copyFrom(Band source) throws CopyFromBandException {
             if (this.getColumns() != source.getColumns() || this.getRows() != source.getRows()
                 || !(source instanceof DefaultBandDouble)) {
                 throw new CopyFromBandException(source, this);
+            }
             System.arraycopy(((DefaultBandDouble) source).getData(), 0, this.data, 0, this.getRows()
                 * this.getColumns());
+        }
         @Override
         public double getValue(int row, int column) {
             return data[row * getColumns() + column];
+        }
         @Override
         public void setValue(int row, int column, double value) {
             data[row * getColumns() + column] = value;
+        }
         @Override
         public double[] createRowBuffer() {
             return new double[getColumns()];
+        }
         @Override
         public void fetchRow(int row, Object rowBuffer) {
             System.arraycopy(data, row * getColumns(), (double[]) rowBuffer, 0, getColumns());
+        }
         @Override
         public void putRow(int row, Object rowBuffer) {
             System.arraycopy((double[]) rowBuffer, 0, data, row * getColumns(), getColumns());
+        }
+    }

     package org.gvsig.raster.lib.buffer.impl;
     import java.util.Arrays;
     import org.gvsig.raster.lib.buffer.api.Band;
     import org.gvsig.raster.lib.buffer.api.BufferManager;
     import org.gvsig.raster.lib.buffer.api.NoData;
     import org.gvsig.raster.lib.buffer.api.BufferLocator;
     import org.gvsig.raster.lib.buffer.api.Band.BandInt;
     import org.gvsig.raster.lib.buffer.impl.exceptions.CopyFromBandException;
     /**
      * @author fdiaz
+     *
      */
     public class DefaultBandInt extends AbstractBand implements BandInt {
         int[] data;
         /**
          * @param rows
          * @param columns
          */
         public DefaultBandInt(int rows, int columns) {
             this(rows, columns, BufferLocator.getBufferManager().createNoData(null, null));
+        }
         /**
          * @param rows
          * @param columns
          * @param noData
          */
         public DefaultBandInt(int rows, int columns, NoData noData) {
             this.rows = rows;
             this.columns = columns;
             data = new int[rows * columns];
             if (noData == null) {
                 this.noData = BufferLocator.getBufferManager().createNoData(null, null);
             } else {
                 this.noData = noData;
+            }
+        }
         @Override
         public int getDataType() {
             return BufferManager.TYPE_INT;
+        }
         @Override
         public Object get(int row, int column) {
             return getValue(row, column);
+        }
         @Override
         public void set(int row, int column, Object value) {
             setValue(row, column, (int) value);
+        }
         @Override
         public void fill(Object value) {
             if (value == null) {
                 if (getNoData().isDefined()) {
                     value = getNoData().getValue();
                 } else {
                     // Do nothing, no data value is undefined
                     return;
+                }
+            }
             Arrays.fill(data, (int) value);
+        }
         int[] getData() {
             return data;
+        }
         @Override
         public void copyFrom(Band source) throws CopyFromBandException {
             if (this.getColumns() != source.getColumns() || this.getRows() != source.getRows()
                 || !(source instanceof DefaultBandInt)) {
                 throw new CopyFromBandException(source, this);
+            }
             System.arraycopy(((DefaultBandInt) source).getData(), 0, this.data, 0, this.getRows()
                 * this.getColumns());
+        }
         @Override
         public int getValue(int row, int column) {
             return data[row * getColumns() + column];
+        }
         @Override
         public void setValue(int row, int column, int value) {
             data[row * getColumns() + column] = value;
+        }
         @Override
         public int[] createRowBuffer() {
             return new int[getColumns()];
+        }
         @Override
         public void fetchRow(int row, Object rowBuffer) {
             System.arraycopy(data, row * getColumns(), (int[]) rowBuffer, 0, getColumns());
+        }
         @Override
         public void putRow(int row, Object rowBuffer) {
             System.arraycopy((int[]) rowBuffer, 0, data, row * getColumns(), getColumns());
+        }
+    }

     package org.gvsig.raster.lib.buffer.impl;
     import java.util.Arrays;
     import org.gvsig.raster.lib.buffer.api.Band;
     import org.gvsig.raster.lib.buffer.api.BufferManager;
     import org.gvsig.raster.lib.buffer.api.NoData;
     import org.gvsig.raster.lib.buffer.api.BufferLocator;
     import org.gvsig.raster.lib.buffer.api.Band.BandShort;
     import org.gvsig.raster.lib.buffer.impl.exceptions.CopyFromBandException;
     /**
      * @author fdiaz
+     *
      */
     public class DefaultBandShort extends AbstractBand implements BandShort {
         short[] data;
         /**
          * @param rows
          * @param columns
          */
         public DefaultBandShort(int rows, int columns) {
             this(rows, columns, BufferLocator.getBufferManager().createNoData(null, null));
+        }
         /**
          * @param rows
          * @param columns
          * @param noData
          */
         public DefaultBandShort(int rows, int columns, NoData noData) {
             this.rows = rows;
             this.columns = columns;
             data = new short[rows * columns];
             if (noData == null) {
                 this.noData = BufferLocator.getBufferManager().createNoData(null, null);
             } else {
                 this.noData = noData;
+            }
+        }
         @Override
         public int getDataType() {
             return BufferManager.TYPE_SHORT;
+        }
         @Override
         public Object get(int row, int column) {
             return getValue(row, column);
+        }
         @Override
         public void set(int row, int column, Object value) {
             setValue(row, column, (short) value);
+        }
         @Override
         public void fill(Object value) {
             if (value == null) {
                 if (getNoData().isDefined()) {
                     value = getNoData().getValue();
                 } else {
                     // Do nothing, no data value is undefined
                     return;
+                }
+            }
             Arrays.fill(data, (short) value);
+        }
         short[] getData() {
             return data;
+        }
         @Override
         public void copyFrom(Band source) throws CopyFromBandException {
             if (this.getColumns() != source.getColumns() || this.getRows() != source.getRows()
                 || !(source instanceof DefaultBandShort)) {
                 throw new CopyFromBandException(source, this);
+            }
             System.arraycopy(((DefaultBandShort) source).getData(), 0, this.data, 0, this.getRows()
                 * this.getColumns());
+        }
         @Override
         public short getValue(int row, int column) {
             return data[row * getColumns() + column];
+        }
         @Override
         public void setValue(int row, int column, short value) {
             data[row * getColumns() + column] = value;
+        }
         @Override
         public short[] createRowBuffer() {
             return new short[getColumns()];
+        }
         @Override
         public void fetchRow(int row, Object rowBuffer) {
             System.arraycopy(data, row * getColumns(), (short[]) rowBuffer, 0, getColumns());
+        }
         @Override
         public void putRow(int row, Object rowBuffer) {
             System.arraycopy((short[]) rowBuffer, 0, data, row * getColumns(), getColumns());
+        }
+    }

     package org.gvsig.raster.lib.buffer.impl;
     import java.util.Arrays;
     import org.gvsig.raster.lib.buffer.api.Band;
     import org.gvsig.raster.lib.buffer.api.BufferManager;
     import org.gvsig.raster.lib.buffer.api.NoData;
     import org.gvsig.raster.lib.buffer.api.Band.BandByte;
     import org.gvsig.raster.lib.buffer.api.BufferLocator;
     import org.gvsig.raster.lib.buffer.impl.exceptions.CopyFromBandException;
     /**
      * @author fdiaz
+     *
      */
     public class DefaultBandByte extends AbstractBand implements BandByte {
         byte[] data;
         /**
          * @param rows
          * @param columns
          */
         public DefaultBandByte(int rows, int columns) {
             this(rows, columns, BufferLocator.getBufferManager().createNoData(null, null));
+        }
         /**
          * @param rows
          * @param columns
          * @param noData
          */
         public DefaultBandByte(int rows, int columns, NoData noData) {
             this.rows = rows;
             this.columns = columns;
             data = new byte[rows * columns];
             if(noData==null){
                 this.noData = BufferLocator.getBufferManager().createNoData(null, null);
             } else {
                 this.noData = noData;
+            }
+        }
         @Override
         public int getDataType() {
             return BufferManager.TYPE_BYTE;
+        }
         @Override
         public Object get(int row, int column) {
             return getValue(row, column);
+        }
         @Override
         public void set(int row, int column, Object value) {
             setValue(row, column, (byte) value);
+        }
         @Override
         public void fill(Object value) {
             if (value == null) {
                 if (getNoData().isDefined()) {
                     value = getNoData().getValue();
                 } else {
                     // Do nothing, no data value is undefined
                     return;
+                }
+            }
             Arrays.fill(data, (byte) value);
+        }
         byte[] getData() {
             return data;
+        }
         @Override
         public void copyFrom(Band source) throws CopyFromBandException {
             if (this.getColumns() != source.getColumns() || this.getRows() != source.getRows()
                 || !(source instanceof DefaultBandByte)) {
                 throw new CopyFromBandException(source, this);
+            }
             System.arraycopy(((DefaultBandByte) source).getData(), 0, this.data, 0, this.getRows()
                 * this.getColumns());
+        }
         @Override
         public byte getValue(int row, int column) {
             return data[row * getColumns() + column];
+        }
         @Override
         public void setValue(int row, int column, byte value) {
             data[row * getColumns() + column] = value;
+        }
         @Override
         public byte[] createRowBuffer() {
             return new byte[getColumns()];
+        }
         @Override
         public void fetchRow(int row, Object rowBuffer) {
             System.arraycopy(data, row * getColumns(), (byte[]) rowBuffer, 0, getColumns());
+        }
         @Override
         public void putRow(int row, Object rowBuffer) {
             System.arraycopy((byte[]) rowBuffer, 0, data, row * getColumns(), getColumns());
+        }
+    }

     package org.gvsig.raster.lib.buffer.impl;
     import java.util.Arrays;
     import org.gvsig.raster.lib.buffer.api.Band;
     import org.gvsig.raster.lib.buffer.api.BufferManager;
     import org.gvsig.raster.lib.buffer.api.NoData;
     import org.gvsig.raster.lib.buffer.api.BufferLocator;
     import org.gvsig.raster.lib.buffer.api.Band.BandFloat;
     import org.gvsig.raster.lib.buffer.impl.exceptions.CopyFromBandException;
     /**
      * @author fdiaz
+     *
      */
     public class DefaultBandFloat extends AbstractBand implements BandFloat {
         float[] data;
         /**
          * @param rows
          * @param columns
          */
         public DefaultBandFloat(int rows, int columns) {
             this(rows, columns, BufferLocator.getBufferManager().createNoData(null, null));
+        }
         /**
          * @param rows
          * @param columns
          * @param noData
          */
         public DefaultBandFloat(int rows, int columns, NoData noData) {
             this.rows = rows;
             this.columns = columns;
             data = new float[rows * columns];
             if (noData == null) {
                 this.noData = BufferLocator.getBufferManager().createNoData(null, null);
             } else {
                 this.noData = noData;
+            }
+        }
         @Override
         public int getDataType() {
             return BufferManager.TYPE_FLOAT;
+        }
         @Override
         public Object get(int row, int column) {
             return getValue(row, column);
+        }
         @Override
         public void set(int row, int column, Object value) {
             setValue(row, column, (float) value);
+        }
         @Override
         public void fill(Object value) {
             if (value == null) {
                 if (getNoData().isDefined()) {
                     value = getNoData().getValue();
                 } else {
                     // Do nothing, no data value is undefined
                     return;
+                }
+            }
             Arrays.fill(data, (float) value);
+        }
         float[] getData() {
             return data;
+        }
         @Override
         public void copyFrom(Band source) throws CopyFromBandException {
             if (this.getColumns() != source.getColumns() || this.getRows() != source.getRows()
                 || !(source instanceof DefaultBandFloat)) {
                 throw new CopyFromBandException(source, this);
+            }
             System.arraycopy(((DefaultBandFloat) source).getData(), 0, this.data, 0, this.getRows()
                 * this.getColumns());
+        }
         @Override
         public float getValue(int row, int column) {
             return data[row * getColumns() + column];
+        }
         @Override
         public void setValue(int row, int column, float value) {
             data[row * getColumns() + column] = value;
+        }
         @Override
         public float[] createRowBuffer() {
             return new float[getColumns()];
+        }
         @Override
         public void fetchRow(int row, Object rowBuffer) {
             System.arraycopy(data, row * getColumns(), (float[]) rowBuffer, 0, getColumns());
+        }
         @Override
         public void putRow(int row, Object rowBuffer) {
             System.arraycopy((float[]) rowBuffer, 0, data, row * getColumns(), getColumns());
+        }
+    }

     package org.gvsig.raster.lib.buffer.impl;
     import java.util.Arrays;
     import org.gvsig.raster.lib.buffer.api.Band;
     import org.gvsig.raster.lib.buffer.api.BufferManager;
     import org.gvsig.raster.lib.buffer.api.NoData;
     import org.gvsig.raster.lib.buffer.api.BufferLocator;
     import org.gvsig.raster.lib.buffer.api.Band.BandInt;
     import org.gvsig.raster.lib.buffer.impl.exceptions.CopyFromBandException;
     /**
      * @author fdiaz
+     *
      */
     public class MemoryBandInt extends AbstractBand implements BandInt {
         int[] data;
         /**
          * @param rows
          * @param columns
          */
         public MemoryBandInt(int rows, int columns) {
             this(rows, columns, BufferLocator.getBufferManager().createNoData(null, null));
+        }
         /**
          * @param rows
          * @param columns
          * @param noData
          */
         public MemoryBandInt(int rows, int columns, NoData noData) {
             this.rows = rows;
             this.columns = columns;
             data = new int[rows * columns];
             if (noData == null) {
                 this.noData = BufferLocator.getBufferManager().createNoData(null, null);
             } else {
                 this.noData = noData;
+            }
+        }
         @Override
         public int getDataType() {
             return BufferManager.TYPE_INT;
+        }
         @Override
         public Object get(int row, int column) {
             return getValue(row, column);
+        }
         @Override
         public void set(int row, int column, Object value) {
             setValue(row, column, (int) value);
+        }
         @Override
         public void fill(Object value) {
             if (value == null) {
                 if (getNoData().isDefined()) {
                     value = getNoData().getValue();
                 } else {
                     // Do nothing, no data value is undefined
                     return;
+                }
+            }
             Arrays.fill(data, (int) value);
+        }
         int[] getData() {
             return data;
+        }
         @Override
         public void copyFrom(Band source) throws CopyFromBandException {
             if (this.getColumns() != source.getColumns() || this.getRows() != source.getRows()
                 || !(source instanceof MemoryBandInt)) {
                 throw new CopyFromBandException(source, this);
+            }
             System.arraycopy(((MemoryBandInt) source).getData(), 0, this.data, 0, this.getRows()
                 * this.getColumns());
+        }
         @Override
         public int getValue(int row, int column) {
             return data[row * getColumns() + column];
+        }
         @Override
         public void setValue(int row, int column, int value) {
             data[row * getColumns() + column] = value;
+        }
         @Override
         public int[] createRowBuffer() {
             return new int[getColumns()];
+        }
         @Override
         public void fetchRow(int row, Object rowBuffer) {
             System.arraycopy(data, row * getColumns(), (int[]) rowBuffer, 0, getColumns());
+        }
         @Override
         public void putRow(int row, Object rowBuffer) {
             System.arraycopy((int[]) rowBuffer, 0, data, row * getColumns(), getColumns());
+        }
+    }

             if (pageManager == null) {
                 switch (dataType) {
                 case BufferManager.TYPE_BYTE:
                     return new DefaultBandByte(rows, columns, noData);
                     return new MemoryBandByte(rows, columns, noData);
                 case BufferManager.TYPE_USHORT:
                 case BufferManager.TYPE_SHORT:
                     return new DefaultBandShort(rows, columns, noData);
                     return new MemoryBandShort(rows, columns, noData);
                 case BufferManager.TYPE_INT:
                     return new DefaultBandInt(rows, columns, noData);
                     return new MemoryBandInt(rows, columns, noData);
                 case BufferManager.TYPE_FLOAT:
                     return new DefaultBandFloat(rows, columns, noData);
                     return new MemoryBandFloat(rows, columns, noData);
                 case BufferManager.TYPE_DOUBLE:
                     return new DefaultBandDouble(rows, columns, noData);
                     return new MemoryBandDouble(rows, columns, noData);
                 default:
                     throw new CreateBandTypeException(dataType);
+                }
-...
                 switch (dataType) {
                 case BufferManager.TYPE_BYTE:
                     // FIXME:PaginatedBandByte....
                     return new DefaultBandByte(rows, columns, noData);
                     return new MemoryBandByte(rows, columns, noData);
                 case BufferManager.TYPE_SHORT:
                     // FIXME:
                     return new DefaultBandShort(rows, columns, noData);
                     return new MemoryBandShort(rows, columns, noData);
                 case BufferManager.TYPE_INT:
                     // FIXME:
                     return new DefaultBandInt(rows, columns, noData);
                     return new MemoryBandInt(rows, columns, noData);
                 case BufferManager.TYPE_FLOAT:
                     // FIXME:
                     return new DefaultBandFloat(rows, columns, noData);
                     return new MemoryBandFloat(rows, columns, noData);
                 case BufferManager.TYPE_DOUBLE:
                     // FIXME:
                     return new PaginatedBandDouble(rows, columns, noData, (BandPageManager) pageManager);
-...
                 switch (dataType) {
                 case BufferManager.TYPE_BYTE:
                     // FIXME: TiledBandByte
                     return new DefaultBandByte(rows, columns, noData);
                     return new MemoryBandByte(rows, columns, noData);
                 case BufferManager.TYPE_USHORT:
                 case BufferManager.TYPE_SHORT:
                     // FIXME:
                     return new DefaultBandShort(rows, columns, noData);
                     return new MemoryBandShort(rows, columns, noData);
                 case BufferManager.TYPE_INT:
                     // FIXME:
                     return new DefaultBandInt(rows, columns, noData);
                     return new MemoryBandInt(rows, columns, noData);
                 case BufferManager.TYPE_FLOAT:
                     // FIXME:
                     return new DefaultBandFloat(rows, columns, noData);
                     return new MemoryBandFloat(rows, columns, noData);
                 case BufferManager.TYPE_DOUBLE:
                     // FIXME:
                     return new DefaultBandDouble(rows, columns, noData);
                     return new MemoryBandDouble(rows, columns, noData);
                 default:
                     throw new CreateBandTypeException(dataType);
+                }
+            }
             return null;
+        }
         @Override

     package org.gvsig.raster.lib.buffer.impl;
     import java.util.Arrays;
     import org.gvsig.raster.lib.buffer.api.Band;
     import org.gvsig.raster.lib.buffer.api.BufferManager;
     import org.gvsig.raster.lib.buffer.api.NoData;
     import org.gvsig.raster.lib.buffer.api.BufferLocator;
     import org.gvsig.raster.lib.buffer.api.Band.BandShort;
     import org.gvsig.raster.lib.buffer.impl.exceptions.CopyFromBandException;
     /**
      * @author fdiaz
+     *
      */
     public class MemoryBandShort extends AbstractBand implements BandShort {
         short[] data;
         /**
          * @param rows
          * @param columns
          */
         public MemoryBandShort(int rows, int columns) {
             this(rows, columns, BufferLocator.getBufferManager().createNoData(null, null));
+        }
         /**
          * @param rows
          * @param columns
          * @param noData
          */
         public MemoryBandShort(int rows, int columns, NoData noData) {
             this.rows = rows;
             this.columns = columns;
             data = new short[rows * columns];
             if (noData == null) {
                 this.noData = BufferLocator.getBufferManager().createNoData(null, null);
             } else {
                 this.noData = noData;
+            }
+        }
         @Override
         public int getDataType() {
             return BufferManager.TYPE_SHORT;
+        }
         @Override
         public Object get(int row, int column) {
             return getValue(row, column);
+        }
         @Override
         public void set(int row, int column, Object value) {
             setValue(row, column, (short) value);
+        }
         @Override
         public void fill(Object value) {
             if (value == null) {
                 if (getNoData().isDefined()) {
                     value = getNoData().getValue();
                 } else {
                     // Do nothing, no data value is undefined
                     return;
+                }
+            }
             Arrays.fill(data, (short) value);
+        }
         short[] getData() {
             return data;
+        }
         @Override
         public void copyFrom(Band source) throws CopyFromBandException {
             if (this.getColumns() != source.getColumns() || this.getRows() != source.getRows()
                 || !(source instanceof MemoryBandShort)) {
                 throw new CopyFromBandException(source, this);
+            }
             System.arraycopy(((MemoryBandShort) source).getData(), 0, this.data, 0, this.getRows()
                 * this.getColumns());
+        }
         @Override
         public short getValue(int row, int column) {
             return data[row * getColumns() + column];
+        }
         @Override
         public void setValue(int row, int column, short value) {
             data[row * getColumns() + column] = value;
+        }
         @Override
         public short[] createRowBuffer() {
             return new short[getColumns()];
+        }
         @Override
         public void fetchRow(int row, Object rowBuffer) {
             System.arraycopy(data, row * getColumns(), (short[]) rowBuffer, 0, getColumns());
+        }
         @Override
         public void putRow(int row, Object rowBuffer) {
             System.arraycopy((short[]) rowBuffer, 0, data, row * getColumns(), getColumns());
+        }
+    }

         @Override
         public void addBand(Band band) {
             if(band.getColumns() != this.getColumns() || band.getRows() != this.getRows()){
                 throw new IllegalArgumentException(
                     "Can not add band to buffer. Band must have the same rows and columns as buffer.");
+            }
             this.bands.add(band);
+        }
-...
         @Override
         public Buffer convert(ICoordTrans ct, SimpleTaskStatus status) {
             for (Band band : bands) {
                 band.convert(ct);
+            }
     //        for (Band band : bands) {
     //            band.convert(ct);
     //
     //        }
             // TODO Auto-generated method stub
             return null;
+        }

     package org.gvsig.raster.lib.buffer.impl;
     import java.util.Arrays;
     import org.gvsig.raster.lib.buffer.api.Band;
     import org.gvsig.raster.lib.buffer.api.BufferManager;
     import org.gvsig.raster.lib.buffer.api.NoData;
     import org.gvsig.raster.lib.buffer.api.Band.BandByte;
     import org.gvsig.raster.lib.buffer.api.BufferLocator;
     import org.gvsig.raster.lib.buffer.impl.exceptions.CopyFromBandException;
     /**
      * @author fdiaz
+     *
      */
     public class MemoryBandByte extends AbstractBand implements BandByte {
         byte[] data;
         /**
          * @param rows
          * @param columns
          */
         public MemoryBandByte(int rows, int columns) {
             this(rows, columns, BufferLocator.getBufferManager().createNoData(null, null));
+        }
         /**
          * @param rows
          * @param columns
          * @param noData
          */
         public MemoryBandByte(int rows, int columns, NoData noData) {
             this.rows = rows;
             this.columns = columns;
             data = new byte[rows * columns];
             if(noData==null){
                 this.noData = BufferLocator.getBufferManager().createNoData(null, null);
             } else {
                 this.noData = noData;
+            }
+        }
         @Override
         public int getDataType() {
             return BufferManager.TYPE_BYTE;
+        }
         @Override
         public Object get(int row, int column) {
             return getValue(row, column);
+        }
         @Override
         public void set(int row, int column, Object value) {
             setValue(row, column, (byte) value);
+        }
         @Override
         public void fill(Object value) {
             if (value == null) {
                 if (getNoData().isDefined()) {
                     value = getNoData().getValue();
                 } else {
                     // Do nothing, no data value is undefined
                     return;
+                }
+            }
             Arrays.fill(data, (byte) value);
+        }
         byte[] getData() {
             return data;
+        }
         @Override
         public void copyFrom(Band source) throws CopyFromBandException {
             if (this.getColumns() != source.getColumns() || this.getRows() != source.getRows()
                 || !(source instanceof MemoryBandByte)) {
                 throw new CopyFromBandException(source, this);
+            }
             System.arraycopy(((MemoryBandByte) source).getData(), 0, this.data, 0, this.getRows()
                 * this.getColumns());
+        }
         @Override
         public byte getValue(int row, int column) {
             return data[row * getColumns() + column];
+        }
         @Override
         public void setValue(int row, int column, byte value) {
             data[row * getColumns() + column] = value;
+        }
         @Override
         public byte[] createRowBuffer() {
             return new byte[getColumns()];
+        }
         @Override
         public void fetchRow(int row, Object rowBuffer) {
             System.arraycopy(data, row * getColumns(), (byte[]) rowBuffer, 0, getColumns());
+        }
         @Override
         public void putRow(int row, Object rowBuffer) {
             System.arraycopy((byte[]) rowBuffer, 0, data, row * getColumns(), getColumns());
+        }
+    }

     package org.gvsig.raster.lib.buffer.impl;
     import java.util.Arrays;
     import org.gvsig.raster.lib.buffer.api.Band;
     import org.gvsig.raster.lib.buffer.api.BufferManager;
     import org.gvsig.raster.lib.buffer.api.NoData;
     import org.gvsig.raster.lib.buffer.api.BufferLocator;
     import org.gvsig.raster.lib.buffer.api.Band.BandFloat;
     import org.gvsig.raster.lib.buffer.impl.exceptions.CopyFromBandException;
     /**
      * @author fdiaz
+     *
      */
     public class MemoryBandFloat extends AbstractBand implements BandFloat {
         float[] data;
         /**
          * @param rows
          * @param columns
          */
         public MemoryBandFloat(int rows, int columns) {
             this(rows, columns, BufferLocator.getBufferManager().createNoData(null, null));
+        }
         /**
          * @param rows
          * @param columns
          * @param noData
          */
         public MemoryBandFloat(int rows, int columns, NoData noData) {
             this.rows = rows;
             this.columns = columns;
             data = new float[rows * columns];
             if (noData == null) {
                 this.noData = BufferLocator.getBufferManager().createNoData(null, null);
             } else {
                 this.noData = noData;
+            }
+        }
         @Override
         public int getDataType() {
             return BufferManager.TYPE_FLOAT;
+        }
         @Override
         public Object get(int row, int column) {
             return getValue(row, column);
+        }
         @Override
         public void set(int row, int column, Object value) {
             setValue(row, column, (float) value);
+        }
         @Override
         public void fill(Object value) {
             if (value == null) {
                 if (getNoData().isDefined()) {
                     value = getNoData().getValue();
                 } else {
                     // Do nothing, no data value is undefined
                     return;
+                }
+            }
             Arrays.fill(data, (float) value);
+        }
         float[] getData() {
             return data;
+        }
         @Override
         public void copyFrom(Band source) throws CopyFromBandException {
             if (this.getColumns() != source.getColumns() || this.getRows() != source.getRows()
                 || !(source instanceof MemoryBandFloat)) {
                 throw new CopyFromBandException(source, this);
+            }
             System.arraycopy(((MemoryBandFloat) source).getData(), 0, this.data, 0, this.getRows()
                 * this.getColumns());
+        }
         @Override
         public float getValue(int row, int column) {
             return data[row * getColumns() + column];
+        }
         @Override
         public void setValue(int row, int column, float value) {
             data[row * getColumns() + column] = value;
+        }
         @Override
         public float[] createRowBuffer() {
             return new float[getColumns()];
+        }
         @Override
         public void fetchRow(int row, Object rowBuffer) {
             System.arraycopy(data, row * getColumns(), (float[]) rowBuffer, 0, getColumns());
+        }
         @Override
         public void putRow(int row, Object rowBuffer) {
             System.arraycopy((float[]) rowBuffer, 0, data, row * getColumns(), getColumns());
+        }
+    }

     package org.gvsig.raster.lib.buffer.impl;
     import java.util.Arrays;
     import org.gvsig.raster.lib.buffer.api.Band;
     import org.gvsig.raster.lib.buffer.api.Band.BandDouble;
     import org.gvsig.raster.lib.buffer.api.BufferManager;
     import org.gvsig.raster.lib.buffer.api.NoData;
     import org.gvsig.raster.lib.buffer.api.BufferLocator;
     import org.gvsig.raster.lib.buffer.impl.exceptions.CopyFromBandException;
     /**
      * @author fdiaz
+     *
      */
     public class MemoryBandDouble extends AbstractBand implements BandDouble {
         double[] data;
         /**
          * @param rows
          * @param columns
          */
         public MemoryBandDouble(int rows, int columns) {
             this(rows, columns, BufferLocator.getBufferManager().createNoData(null, null));
+        }
         /**
          * @param rows
          * @param columns
          * @param noData
          */
         public MemoryBandDouble(int rows, int columns, NoData noData) {
             this.rows = rows;
             this.columns = columns;
             data = new double[rows * columns];
             if (noData == null) {
                 this.noData = BufferLocator.getBufferManager().createNoData(null, null);
             } else {
                 this.noData = noData;
+            }
+        }
         @Override
         public int getDataType() {
             return BufferManager.TYPE_DOUBLE;
+        }
         @Override
         public Object get(int row, int column) {
             return getValue(row, column);
+        }
         @Override
         public void set(int row, int column, Object value) {
             setValue(row, column, (double) value);
+        }
         @Override
         public void fill(Object value) {
             if (value == null) {
                 if (getNoData().isDefined()) {
                     value = getNoData().getValue();
                 } else {
                     // Do nothing, no data value is undefined
                     return;
+                }
+            }
             Arrays.fill(data, (double) value);
+        }
         double[] getData() {
             return data;
+        }
         @Override
         public void copyFrom(Band source) throws CopyFromBandException {
             if (this.getColumns() != source.getColumns() || this.getRows() != source.getRows()
                 || !(source instanceof MemoryBandDouble)) {
                 throw new CopyFromBandException(source, this);
+            }
             System.arraycopy(((MemoryBandDouble) source).getData(), 0, this.data, 0, this.getRows()
                 * this.getColumns());
+        }
         @Override
         public double getValue(int row, int column) {
             return data[row * getColumns() + column];

Application: gvSIG desktop » gvSIG raster

Revision 5517