Application: gvSIG desktop » gvSIG raster

/* gvSIG. Geographic Information System of the Valencian Government

 *

 * Copyright (C) 2007-2008 Infrastructures and Transports Department

 * of the Valencian Government (CIT)

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * of the License, or (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

 * MA  02110-1301, USA.

 *

 */

package org.gvsig.raster.impl.process.vector;

import java.util.ArrayList;

import java.util.List;

import org.gvsig.fmap.dal.coverage.dataset.Buffer;

import org.gvsig.fmap.dal.coverage.exception.NotSupportedExtensionException;

import org.gvsig.fmap.dal.coverage.exception.ProcessInterruptedException;

import org.gvsig.fmap.dal.coverage.exception.QueryException;

import org.gvsig.fmap.dal.coverage.exception.RasterDriverException;

import org.gvsig.fmap.dal.coverage.process.vector.Vectorization;

import org.gvsig.fmap.dal.coverage.store.RasterDataStore;

import org.gvsig.fmap.dal.coverage.store.RasterQuery;

import org.gvsig.fmap.dal.exception.InitializeException;

import org.gvsig.fmap.dal.exception.ProviderNotRegisteredException;

import org.gvsig.jpotrace.Potrace;

import org.gvsig.jpotrace.PotraceException;

import org.gvsig.raster.impl.DefaultRasterManager;

import org.gvsig.raster.impl.store.QueryableRaster;

/**

 * La clase VectorizationBinding se usa para poder vectorizar una capa raster.<p>

 * 

 * La entrada es una capa raster, ya sea en un fichero, BufferFactory o un

 * RasterDataset.<p>

 * 

 * El uso de comunicacion con la libreria jpotrace es como funciona el comando

 * potrace, de hecho, se pueden a?adir mas opciones si potrace los admite por

 * linea de comandos.<p>

 * 

 * Una vez creada una instancia a VectorizationBinding. Se definen todos los

 * parametros deseables o en caso de no definirlos se usaran los valores por

 * defecto y se invoca al metodo VectorizeBuffer()<p>

 * 

 * Este ultimo metodo, devuelve un array de doubles indicando si lo que se ha

 * devuelto son operaciones tipicas de shapes... MoveTo, LineTo, CurveTo, etc...<p>

 * 

 * En la primera posicion se devuelve el tama?o del array.<p>

 * 

 * 03/09/2008

 * @author BorSanZa - Borja S?nchez Zamorano (borja.sanchez@iver.es)

 */

public class PotraceVectorization implements Vectorization {

        private Buffer          buffer                = null;

        private Double          cornerThreshold       = null;

        private Integer         despeckle             = null;

        private Integer         policy                = null;

        private Double          optimizationTolerance = null;

        private boolean         curveOptimization     = true;

        private Integer         outputQuantization    = null;

        private RasterQuery     query                 = null;

        /**

         * Construye un VectorizationBinding a partir de la ruta de un Raster

         * @param file

         * @throws NotSupportedExtensionException

         * @throws RasterDriverException

         * @throws ProcessInterruptedException

         */

        public PotraceVectorization(String file) throws QueryException, NotSupportedExtensionException, RasterDriverException, ProcessInterruptedException {

                this.setFile(file);

        }

        /**

         * Construye un VectorizationBinding a partir de un RasterDataset

         * @param dataset

         * @throws RasterDriverException 

         * @throws ProcessInterruptedException 

         * @throws ProcessInterruptedException

         * @throws RasterDriverException

         */

        public PotraceVectorization(QueryableRaster dataset) throws ProcessInterruptedException, QueryException {

                setDataSource((RasterDataStore)dataset);

        }

        /**

         * Construye un VectorizationBinding a partir de un BufferFactory

         * @param bufferFactory

         * @throws RasterDriverException 

         * @throws ProcessInterruptedException 

         * @throws ProcessInterruptedException

         * @throws RasterDriverException

         */

        public PotraceVectorization(RasterDataStore dataSource) throws ProcessInterruptedException, QueryException {

                setDataSource(dataSource);

        }

        /**

         * Se especifica el fichero del raster

         * @param file

         * @throws NotSupportedExtensionException

         * @throws RasterDriverException

         * @throws ProcessInterruptedException

         */

        private void setFile(String file) throws QueryException, NotSupportedExtensionException, RasterDriverException, ProcessInterruptedException {

                RasterDataStore ds = null;

                try {

                        ds = DefaultRasterManager.getInstance().getProviderServices().open(file);

                } catch (InitializeException e) {

                        throw new RasterDriverException("Error opening file", e);

                } catch (ProviderNotRegisteredException e) {

                        throw new RasterDriverException("Error opening file", e);

                }

                setDataSource(ds);

        }

        /**

         * Se especifica el BufferFactory

         * @param bufferFactory

         * @throws ProcessInterruptedException

         * @throws RasterDriverException

         */

        private void setDataSource(RasterDataStore dataSource) throws ProcessInterruptedException, QueryException {

                query.setAllDrawableBands();

                query.setAreaOfInterest();

                setRasterBuffer(dataSource.query(query));

        }

        /**

         * Se establece el RasterBuffer

         * @param buffer

         */

        private void setRasterBuffer(Buffer buffer) {

                this.buffer = buffer;

        }

        /**

         * Pone a 1 la posici?n del bit pasado por parametro en el value. Operaci?n binaria OR

         * @param value

         * @param pos

         * @return

         */

        private int enableBit(int value, int pos) {

                value = (value | ((int)1 << pos));

                return value;

        }

        /**

         * Set the corner threshold parameter (default 1)

         * @param value

         */

        public void setCornerThreshold(double value) {

                cornerThreshold = new Double(value);

        }

        /**

         * Quantize output to 1/unit pixels (default 10)

         * @param value

         */

        public void setOutputQuantization(int value) {

                outputQuantization = new Integer(value);

        }

        /**

         * Suppress speckles of up to this size (default 2)

         * @param value

         */

        public void setDespeckle(int value) {

                despeckle = new Integer(value);

        }

        /**

         * Set how to resolve ambiguities in path decomposition<p>

         * 

         * Use:<br><b>

         *          POLICY_BLACK<br>

         *   POLICY_LEFT<br>

         *   POLICY_MAJORITY<br>

         *   POLICY_MINORITY<br>

         *   POLICY_RANDOM<br>

         *   POLICY_RIGHT<br>

         *   POLICY_WHITE</b>

         *  

         * @param value

         */

        public void setPolicy(int value) {

                policy = new Integer(value);

        }

        /**

         * Set the curve optimization tolerance (default 0.2)

         * @param value

         */

        public void setOptimizationTolerance(double value) {

                optimizationTolerance = new Double(value);

        }

        /**

         * Return if the curve optimization is enabled or disabled

         * @param value

         */

        public boolean isEnabledCurveOptimization() {

                return curveOptimization;

        }

        /**

         * Enable/Disable the curve optimization (default enabled)

         * @param value

         */

        public void setEnabledCurveOptimization(boolean value) {

                curveOptimization = value;

        }

        /**

         * Devuelve los parametros en formato de array (Similar a como los recibe el

         * main de un fichero en c) indicando la llamada entera al comando potrace.

         * @return

         */

        private String[] getParams() {

                List<String> params = new ArrayList<String>();

                params.add("./potrace");

                if (cornerThreshold != null) {

                        params.add("-a");

                        params.add(cornerThreshold.toString());

                }

                if (despeckle != null) {

                        params.add("-t");

                        params.add(despeckle.toString());

                }

                if (outputQuantization != null) {

                        params.add("-u");

                        params.add(outputQuantization.toString());

                }

                if (policy != null) {

                        String param = null;

                        switch (policy.intValue()) {

                                case POLICY_BLACK:

                                        param = "black";

                                        break;

                                case POLICY_WHITE:

                                        param = "white";

                                        break;

                                case POLICY_LEFT:

                                        param = "left";

                                        break;

                                case POLICY_RIGHT:

                                        param = "right";

                                        break;

                                case POLICY_MINORITY:

                                        param = "minority";

                                        break;

                                case POLICY_MAJORITY:

                                        param = "majority";

                                        break;

                                case POLICY_RANDOM:

                                        param = "random";

                                        break;

                        }

                        if (param != null) {

                                params.add("-z");

                                params.add(param);

                        }

                }

                if (optimizationTolerance != null) {

                        // Curve optimization tolerance

                        params.add("-O");

                        params.add(optimizationTolerance.toString());

                }

                if (!curveOptimization) {

                        // turn off curve optimization

                        params.add("-n"); 

                }

                String[] strings = new String[params.size()];

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

                        strings[i] = (String) params.get(i);

                }

                return strings;

        }

        /**

         * Hace el proeso de Vectorizacion de un Raster

         * @return

         * @throws PotraceException

         */

        public double[] VectorizeBuffer() {

                int dy = (buffer.getWidth() + 32 - 1) / 32;

                int[] bufferBits = new int[buffer.getHeight() * dy];

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

                        bufferBits[i] = 0;

                int bit = 0;

                int pos = 0;

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

                        pos = (buffer.getHeight() - i - 1) * dy;

                        bit = 0;

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

                                byte data = buffer.getElemByte(i, j, 0);

                                if (data == 0) {

                                        bufferBits[pos] = enableBit(bufferBits[pos], 31 - bit);

                                }

                                bit++;

                                if (bit >= 32) {

                                        bit = 0;

                                        pos++;

                                }

                        }

                }

                try {

                        return Potrace.vectorizeBufferRaster(bufferBits, buffer.getWidth(), buffer.getHeight(), getParams());

                } catch (PotraceException e) {

                }

                return null;

        }

}