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.fmap.dal.coverage.grid.render;

import java.awt.Graphics2D;

import java.awt.geom.Dimension2D;

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

import org.gvsig.fmap.dal.coverage.datastruct.ViewPortData;

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

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

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

import org.gvsig.fmap.dal.coverage.grid.RasterFilterList;

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

import org.gvsig.fmap.dal.coverage.store.props.ColorTable;

import org.gvsig.fmap.dal.coverage.store.props.Transparency;

import org.gvsig.tools.dispose.Disposable;

import org.gvsig.tools.task.Cancellable;

import org.gvsig.tools.task.TaskStatus;

/**

 * Renders a Grid object 

 * @author Nacho Brodin (nachobrodin@gmail.com)

 */

public interface Render extends Runnable, Disposable {

        /**

         * Obtiene las lista de filtros aplicados en la renderizaci?n

         * @return RasterFilterList

         */

        public RasterFilterList getFilterList();

        /**

         * Asigna la lista de filtros que se usar? en el renderizado

         * @param RasterFilterList

         */

        public void setFilterList(RasterFilterList filterList);

        /**

         * Asigna el ?ltimo estado de transparencia de la renderizaci?n.

         * @param lastTransparency

         */

        public void setLastTransparency(Transparency lastTransparency);

        /**

         * Obtiene el ?ltimo objeto transparencia aplicado en la renderizaci?n

         * @return Transparency

         */

        public Transparency getLastTransparency();

        /**

         * Gets the last alpha band number

         * @return

         */

        public int getLastAlphaBandNumber();

        /**

         * Obtiene el ?ltimo buffer renderizado.

         * @return Buffer

         */

        public Buffer getLastRenderBuffer();

        /**

         * Asigna el ?ltimo renderizado.

         * @param buf

         */

        public void setLastRenderBuffer(Buffer buf);

        /**

         * Informa de si el raster tiene tabla de color asociada o no.

         * @return true si tiene tabla de color y false si no la tiene.

         */

        public boolean existColorTable();

        /**

         * Gets a data store

         * @return

         */

        public RasterDataStore getDataStore();

        /**

         * Sets a data store

         * @param dataStore

         */

        public void setDataStore(RasterDataStore dataStore);

        /**

         * Gets the color table 

         * @return 

         */

        public ColorTable getColorTable();

        /**

         * Asigna un listener a la lista que ser? informado cuando cambie una

         * propiedad visual en la renderizaci?n.

         * @param listener VisualPropertyListener

         */

        public void addVisualPropertyListener(VisualPropertyListener listener);

        /**

         * Devuelve si la asignacion de las bandas a renderizar representa una capa

         * en escala de grises

         * @return

         */

        public boolean isRenderingAsGray();

        /**

         * Asigna el n?mero de bandas y el orden de renderizado. Cada posici?n del vector es una banda

         * del buffer y el contenido de esa posici?n es la banda de la imagen que se dibujar?

         * sobre ese buffer. A la hora de renderizar hay que tener en cuenta que solo se renderizan las

         * tres primeras bandas del buffer por lo que solo se tienen en cuenta los tres primeros

         * elementos. Por ejemplo, el array {1, 0, 3} dibujar? sobre el Graphics las bandas 1,0 y 3 de un

         * raster que tiene al menos 4 bandas. La notaci?n con -1 en alguna posici?n del vector solo tiene sentido

         * en la visualizaci?n pero no se puede as?gnar una banda del buffer a null.

         * Algunos ejemplos:

         * <P>

         * {-1, 0, -1} Dibuja la banda 0 del raster en la G de la visualizaci?n.

         * Si replicateBand es true R = G = B sino R = B = 0

         * {1, 0, 3} La R = banda 1 del raster, G = 0 y B = 3

         * {0} La R = banda 0 del raster. Si replicateBand es true R = G = B sino G = B = 0

         * </P>

         *

         *

         * @param renderBands: bandas y su posici?n

         */

        public void setRenderBands(int[] renderBands);

        /**

         * Obtiene el n?mero de bandas y el orden de renderizado. Cada posici?n del

         * vector es una banda del buffer y el contenido de esa posici?n es la banda

         * de la imagen que se dibujar? sobre ese buffer. A la hora de renderizar hay

         * que tener en cuenta que solo se renderizan las tres primeras bandas del

         * buffer por lo que solo se tienen en cuenta los tres primeros elementos. Por

         * ejemplo, el array {1, 0, 3} dibujar? sobre el Graphics las bandas 1,0 y 3

         * de un raster de al menos 4 bandas. La notaci?n con -1 en alguna posici?n

         * del vector solo tiene sentido en la visualizaci?n pero no se puede as?gnar

         * una banda del buffer a null. Algunos ejemplos:

         * <P>

         * <UL>

         * <LI> {-1, 0, -1} Dibuja la banda 0 del raster en la G de la visualizaci?n. Si

         * replicateBand es true R = G = B sino R = B = 0 </LI>

         * <LI> {1, 0, 3} La R = banda 1 del raster, G = 0 y B = 3 </LI>

         * <LI> {0} La R = banda 0 del raster. Si replicateBand es true R = G = B

         * sino G = B = 0</LI>

         * </UL>

         * </P>

         *

         * @return bandas y su posici?n

         */

        public int[] getRenderBands();

        /**

         * Dibuja el raster sobre el Graphics. Para ello debemos de pasar el viewPort que corresponde a la

         * vista. Este viewPort es ajustado a los tama?os m?ximos y m?nimos de la imagen por la funci?n

         * calculateNewView. Esta funci?n tambi?n asignar? la vista a los drivers. Posteriormente se calcula

         * el alto y ancho de la imagen a dibujar (wImg, hImg), as? como el punto donde se va a pintar dentro

         * del graphics (pt). Finalmente se llama a updateImage del driver para que pinte y una vez dibujado

         * se pasa a trav?s de la funci?n renderizeRaster que es la encargada de aplicar la pila de filtros

         * sobre el Image que ha devuelto el driver.

         *

         * Para calcular en que coordenada pixel (pt) se empezar? a pintar el BufferedImage con el raster le?do

         * se aplica sobre la esquina superior izquierda de esta la matriz de transformaci?n del ViewPortData

         * pasado vp.mat.transform(pt, pt). Si el raster no est? rotado este punto es el resultante de la

         * funci?n calculateNewView que devuelve la petici?n ajustada al extent de la imagen (sin rotar). Si

         * el raster est? rotado necesitaremos para la transformaci?n el resultado de la funci?n coordULRotateRaster.

         * Lo que hace esta ?ltima es colocar la petici?n que ha sido puesta en coordenadas de la imagen sin rotar

         * (para pedir al driver de forma correcta) otra vez en coordenadas de la imagen rotada (para calcular su

         * posici?n de dibujado).

         *

         * Para dibujar sobre el Graphics2D el raster rotado aplicaremos la matriz de transformaci?n con los

         * par?metros de Shear sobre este Graphics de forma inversa. Como hemos movido el fondo tendremos que

         * recalcular ahora el punto donde se comienza a dibujar aplicandole la transformaci?n sobre este

         * at.inverseTransform(pt, pt);. Finalmente volcamos el BufferedImage sobre el Graphics volviendo a dejar

         * el Graphics en su posici?n original al acabar.

         *

         * @param g Graphics sobre el que se pinta

         * @param vp ViewPort de la extensi?n a dibujar

         * @param taskStatus 

         * @throws InvalidSetViewException

         * @throws ArrayIndexOutOfBoundsException

         */

        public void draw(Graphics2D g, ViewPortData vp, TaskStatus taskStatus)

                throws RasterDriverException, InvalidSetViewException, ProcessInterruptedException;

        /**

         * Este m?todo dibuja sobre el Graphics a partir de un Viewport sin ajustar. Los tiles que van llegando

         * no est?n en el tama?o ajustado sino que llegan en su tama?o origina, tipicamente 256x256 p?xeles. Estos

         * son reescalados al ir a dibujarlos sobre el Graphics.

         * @param g

         * @param vp

         * @throws RasterDriverException

         * @throws InvalidSetViewException

         * @throws ProcessInterruptedException

         */

        public void drawTiledService(Graphics2D g, ViewPortData vp, Dimension2D viewDimension, TaskStatus status)

                throws RasterDriverException, InvalidSetViewException, ProcessInterruptedException;

        /**

         * <p>

         * This method throws the draw call in a Thread. This is useful to draw tiles.

         * </p>

         * <p>

         * Strategy:

         * <ul>

         * <li>If the image is out of the view the thread won't be thrown</li>

         * <li>Throw the thread to draw</li>

         * <li>The main thread waits until the secondary thread ends</li>

         * <li>When the buffer of a new tile has been received then nextBuffer is called from the store</li>

         * <li>When the last tile has been received then endReading is called from the store. This method unlocks the main

         * thread and will finish the process</li>

         * <li></li>

         * </ul> 

         * </p>

         * 

         * @see draw

         */

        public void drawThread(Graphics2D g, ViewPortData vp);

        /**

         * Sets the view structures to draw

         * @param g

         * @param vp

         */

        public void setGraphicInfo(Graphics2D g, ViewPortData vp);

        public void setReading(boolean reading);

        /**

         * Temporal hasta que est? disponible TaskStatus

         * @deprecated

         * @param cancel

         */

        public void setCancel(Cancellable cancel);

}