Application: gvSIG desktop » gvSIG raster

import org.cresques.cts.ICoordTrans;

import org.cresques.cts.IProjection;

import org.gvsig.fmap.crs.CRSFactory;

import org.gvsig.fmap.geom.Geometry.SUBTYPES;

import org.gvsig.fmap.geom.GeometryLocator;

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

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

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

    // public void testGetHistogram() {

    //

    // SimpleTaskStatus simpleTaskStatus =

    // ToolsLocator.getTaskStatusManager().createDefaultSimpleTaskStatus("test histogram");

    // Histogram histogram = testBuffer.getHistogram(simpleTaskStatus);

    // assertNotNull(histogram);

    //

    // }

        // assertEquals(testBuffer.getBand(2).getDataType(),

        // BufferManager.TYPE_USHORT); //FIXME : type unshort?

    public void testConvert() {

        int[] bandDataTypes =

            new int[] { BufferManager.TYPE_DOUBLE, BufferManager.TYPE_DOUBLE,

                BufferManager.TYPE_DOUBLE };

        NoData[] bandNodata = new NoData[3];

        Arrays.fill(bandNodata, BufferLocator.getBufferManager().createNoData(-99999d, -99999d));

        try {

            Envelope envelope =

                GeometryLocator.getGeometryManager().createEnvelope(625397.5, 4446997.5, 654602.5,

                    4466602.5, SUBTYPES.GEOM2D);

            IProjection projection = CRSFactory.getCRS("EPSG:25830");

            testBuffer =

                BufferLocator.getBufferManager().createBuffer(39, 58, bandDataTypes,

                    bandNodata, projection, envelope);

            ICoordTrans ct = projection.getCT(CRSFactory.getCRS("EPSG:4326"));

            Buffer projectedBuffer = testBuffer.convert(ct, null);

            assertEquals(testBuffer.getEnvelope().convert(ct), projectedBuffer.getEnvelope());

        } catch (CreateEnvelopeException | BufferException e) {

            fail("Can not create envelope or there are problems projecting buffers");

        }

    }

import java.awt.geom.NoninvertibleTransformException;

import org.gvsig.fmap.geom.Geometry.SUBTYPES;

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

import org.gvsig.tools.ToolsLocator;

            // this.bandPageManager = pageManagers;

        boolean isMyStatus = false;

        if (status == null) {

            status =

                ToolsLocator.getTaskStatusManager().createDefaultSimpleTaskStatus(

                    String.format("Projecting buffer from %1s to %2s", ct.getPOrig().getAbrev(), ct

                        .getPDest().getAbrev()));

            status.add();

            isMyStatus = true;

        } else {

            status.push();

        }

        // Get size of new buffer

        double[] newsize =

            getSize(this.getEnvelope(), projectedBufferEnvelope, this.getColumns(), this.getRows());

        int projectedBufferColumns = (int) newsize[0];

        int projectedBufferRows = (int) newsize[1];

        status.message("Creating projected buffer");

        AffineTransform bufferAf =

            calculateAffineTransform(this.getEnvelope(), this.getRows(), this.getColumns());

        status.setRangeOfValues(0, projectedBuffer.getRows() * projectedBuffer.getColumns()

            * projectedBuffer.getBandCount());

        status.message("Projecting buffer");

            if (status.isCancellationRequested()) {

                status.cancel();

                return projectedBuffer;

            }

                Point point = null;

                try {

                    point =

                        GeometryLocator.getGeometryManager().createPoint(col, row, SUBTYPES.GEOM2D);

                    point.transform(projectedBufferAf); // projected buffer pixel to world point (target projection) 

                    point.reProject(ct.getInverted()); // projected world point to world point (source projection)

                    point.transform(bufferAf.createInverse()); // world point to pixel source buffer

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

                        status.setCurValue(row * col * k);

                        Band band = this.bands.get(k);

                        Object value = null;

                        if (point.getX() >= 0 && Math.floor(point.getX()) < this.getColumns()

                            && point.getY() >= 0 && Math.floor(point.getY()) < this.getRows()) {

                            value =

                                band.get((int) Math.floor(point.getY()),

                                    (int) Math.floor(point.getX()));

                        } else if (band.getNoData().isDefined()) {

                            value = band.getNoData().getValue();

                        } else {

                            continue;

                        }

                        Band projectedBand = projectedBuffer.getBand(k);

                        projectedBand.set(row, col, value);

                    }

                } catch (CreateGeometryException e) {

                    status.abort();

                    logger.error("Can not create point geometry with [{},{}] to project buffer",

                        col, row);

                    throw new BufferException(e);

                } catch (NoninvertibleTransformException e) {

                    status.abort();

                    logger.error("Can not create inverse transformation of {}", bufferAf);

                    throw new BufferException(e);

                }

        if (isMyStatus) {

            status.terminate();

        } else {

            status.pop();

        }

        return projectedBuffer;

    private double[] getSize(Envelope envelope, Envelope projectedEnvelope, int p1x, int p1y) {

        double sumSideOldBBox = envelope.getLength(0) + envelope.getLength(1);

        double sumSideNewBBox = projectedEnvelope.getLength(0) + projectedEnvelope.getLength(1);

        double d1x = (envelope.getLength(0) * 100) / sumSideOldBBox;

        double d1y = (envelope.getLength(1) * 100) / sumSideOldBBox;

        double d2x = (projectedEnvelope.getLength(0) * 100) / sumSideNewBBox;

        double d2y = (projectedEnvelope.getLength(1) * 100) / sumSideNewBBox;

        double p2y = (p1y * d2y) / d1y;

        double p2x = (p1x * d2x) / d1x;

        double newCellSize = projectedEnvelope.getLength(0) / p2x;

        return new double[] { Math.round(p2x), Math.round(p2y), newCellSize };

    }

        double cellSizeX = projectedBufferEnvelope.getLength(0) / projectedBufferColumns;

        double cellSizeY = projectedBufferEnvelope.getLength(1) / projectedBufferRows;

        return new AffineTransform(cellSizeX, 0d, 0d, -cellSizeY,

            projectedBufferEnvelope.getMinimum(0), projectedBufferEnvelope.getMaximum(1));

      <groupId>org.gvsig</groupId>

      <artifactId>org.gvsig.compat.se</artifactId>

      <scope>test</scope>

    </dependency>

    <dependency>

    <dependency>

    	<groupId>org.gvsig</groupId>

    	<artifactId>org.gvsig.fmap.geometry.jts</artifactId>

      	<scope>test</scope>

    </dependency>

    <dependency>

		<groupId>org.gvsig</groupId>

		<artifactId>org.gvsig.proj.lib.proj4j</artifactId>

		<scope>test</scope>

	</dependency>