Application: gvSIG desktop » gvSIG raster

import java.awt.geom.Point2D;

import java.io.File;

import java.net.URI;

import java.security.NoSuchAlgorithmException;

import java.util.Collection;

import java.util.Date;

import java.util.Iterator;

import java.util.List;

import org.apache.commons.io.FilenameUtils;

import org.gvsig.compat.net.ICancellable;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataServerExplorer;

import org.gvsig.timesupport.Time;

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.locator.LocatorException;

/**

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

 */

public abstract class AbstractRasterProvider extends AbstractCoverageStoreProvider implements RasterProvider {

	public static final int                   GREEN_BAND             = 0x02;

	public static final int                   BLUE_BAND              = 0x04;

	public static final int                   ALPHA_BAND             = 0x08;

	protected int                             bandCount              = 1;

	private int[]                             dataType               = null;

	protected NoData                          noData                 = null;

	protected Transparency                    transparency           = null;

	protected TileServer                      tileServer             = null;

	protected GeoPointList                    geoPointList           = null;

	protected FileUtils                       fileUtil               = RasterLocator.getManager().getFileUtils();

	protected RasterUtils                     rasterUtil             = RasterLocator.getManager().getRasterUtils();

	protected IProjection                     proj                   = null;

	protected long                            fileSize               = 0;

	protected long                            bytesReaded            = 0;

	protected long                            lineCnt                = 0;

	protected String                          selectedSubdatasetID   = null;

	/**

	 * Transformaci�n creada a partir de la informaci�n de georreferencia de la

	 */

	protected AffineTransform                 externalTransformation = null;

	private static Logger                     logger                 = LoggerFactory.getLogger(AbstractRasterProvider.class.getName());

	public AbstractRasterProvider(AbstractRasterDataParameters params,

			DataStoreProviderServices storeServices, DynObject metadata) {

		super(params, storeServices, metadata);

			if(f.exists())

				setFileSize(f.length());

		}

		if(params.getURI() != null)

		ownTransformation = new AffineTransform();

		externalTransformation = new AffineTransform();

	}

	public AbstractRasterProvider(DataStoreParameters params,

			DataStoreProviderServices storeServices, DynObject metadata) {

		super(params, storeServices, metadata);

			if(params instanceof RemoteStoreParameters)

		}

		ownTransformation = new AffineTransform();

		externalTransformation = new AffineTransform();

	}

	public AbstractRasterProvider(String params) {

		super();

	}

	public AbstractRasterProvider() {

		super(null, null, null);

	}

	public String[] getFormatList() {

		return null;

	}

	/**

	 * Acciones de inicilizaci?n comunes a todos los drivers.

	 * Este m?todo debe ser llamado explicitamente por el constructor de cada driver.

	 */

	protected void init() {

	}

	public boolean isRGB() {

		if(getDataType()[0] == Buffer.TYPE_BYTE) {

			ColorInterpretation ci = getColorInterpretation();

		}

		return false;

	}

	public boolean isARGB() {

		if(getDataType()[0] == Buffer.TYPE_BYTE) {

			ColorInterpretation ci = getColorInterpretation();

		}

		return false;

	}

	public boolean isTiled() {

		return false;

	}

	public boolean isTimeSupported() {

		return false;

	}

	public RasterProvider cloneProvider() throws CloneException {

		try {

			DataManagerProviderServices dataManager = (DataManagerProviderServices)DALLocator.getDataManager();

		}

		return null;

	}

	/**

	 * Factoria para abrir distintos tipos de raster.

	 * @param fName Nombre del fichero.

		DataManagerProviderServices dataManager = (DataManagerProviderServices)DALLocator.getDataManager();

		//We have to locate a provider's name which manages the selected file

		//A FilesystemServerExplorer will give a getProviderNames service

		FilesystemServerExplorer serverExplorer = null;

		try {

			FilesystemServerExplorerParameters paramsExplorer = (FilesystemServerExplorerParameters)dataManager.createServerExplorerParameters(FilesystemServerExplorer.NAME);

		} catch (ProviderNotRegisteredException e) {

			throw new RasterDriverException("Provider not registered", e);

		}

		//Gets the list of provider's name to manage the file

		File file = new File(param);

		List<String> provName = serverExplorer.getProviderNameList(file);

					DataStoreParameters newparams;

					try {

						newparams = dataManager.createStoreParameters(provName.get(i));

						if(storeServices == null)

							storeServices = new DefaultRasterStore();

						return (AbstractRasterProvider)dataManager.createProvider(storeServices, newparams);

	 * Gets the set of data selected in the {@link RasterQuery}

	 * @param q

	 * @return

	 */

	public Buffer getDataSet(SpiRasterQuery query) throws ProcessInterruptedException, RasterDriverException {

		SpiRasterQuery q = (SpiRasterQuery)query;

		loadBuffer(q);

		return q.getBufferForProviders();

	}

	/**

	 * inside the query structure <code>SpiRasterQuery</code> by the <code>RasterDataStore</code>. The other

	 * have to read the parameters and load the buffer.

	 * @param query

	 * @throws ProcessInterruptedException

	 * @throws RasterDriverException

	abstract public void loadBuffer(SpiRasterQuery query) throws ProcessInterruptedException, RasterDriverException;

	abstract public int getBlockSize();

	abstract public int getOverviewHeight(int band, int overview) throws BandAccessException, RasterDriverException;

	/**

	 * @return true si soporta overviews y false si no las soporta.

	 */

	abstract public boolean isOverviewsSupported();

	public void reload() {

		try {

			loadFromRmf(getRmfBlocksManager());

			logger.debug("No se ha podido leer el RMF", e);

		}

	}

	/**

	 * Carga metadatos desde el fichero Rmf si estos existen

	 * @param fName Nombre del fichero

		if (!new File(manager.getPath()).exists())

			return;

		GeoInfoRmfSerializer geoInfoSerializer = new GeoInfoRmfSerializer(this);

		ColorTableRmfSerializer colorTableSerializer = new ColorTableRmfSerializer();

		GeoPointListRmfSerializer gcpSerializer = new GeoPointListRmfSerializer();

		NoDataRmfSerializer noDataSerializer = null;

		if(noData == null)

			noData = new DefaultNoData(null, null, manager.getPath(), getBandCount());

		ColorInterpretationRmfSerializer colorInterpSerializer = new ColorInterpretationRmfSerializer();

		ProjectionRmfSerializer projectionRmfSerializer = new ProjectionRmfSerializer();

		StatisticsRmfSerializer statsRmfSerializer = new StatisticsRmfSerializer(getStatistics());

		if (projectionRmfSerializer.getResult() != null) {

			proj = (IProjection) projectionRmfSerializer.getResult();

		}

			((GeoPointList)gcpSerializer.getResult()).size() > 0) {

			setGeoPointList((GeoPointList)gcpSerializer.getResult());

		}

		if(noData == null) {

			noData = RasterLocator.getManager().getDataStructFactory().createDefaultNoData(getBandCount(), getDataType()[0]);

			noData.setNoDataTransparent(false);

		}

		return noData;

	}

	public void setNoDataValue(NoData value) {

		this.noData = value;

	}

	}

	abstract public int getOverviewWidth(int band, int overview) throws BandAccessException, RasterDriverException;

	public void selectSubdataset() {}

	/**

	 * Selects the subdataset. This method will select

	 */

	protected void selectSubdataset(String subdataset) {

		selectedSubdatasetID = subdataset;

	}

	/**

	 * @return RmfBloksManager

	 */

	public RmfBlocksManager getRmfBlocksManager() {

		if(fileRMF != null) {

			}

		}

		return rmfBlocksManager;

	}

	protected String getRMFFileForRemoteServices(String layerName) {

		String md5 = "";

		try {

		} catch (LocatorException e) {

			logger.debug("Error getting the Locator", e);

		} catch (NoSuchAlgorithmException e) {

			return true;

		return false;

	}

	public boolean isMultiFile() {

		return false;

	}

	public boolean isMosaic() {

		return false;

	}

	}

	public void saveObjectToRmf(Class<?> class1, Object value) throws RmfSerializerException {

	}

	/**

	public Object loadObjectFromRmf(Object value) throws RmfSerializerException {

		return loadObjectFromRmf(value.getClass(), value);

	}

	public double getCellSize() {

		try {

			Extent e = getExtent();

			return 1;

		}

	}

	public RasterProvider newProvider() {

		return null;

	}

	public ColorTable getColorTable() {

		return colorTable;

	}

	public Image getImageLegend() {

		return null;

	}

	public void setColorTable(ColorTable value) {

		colorTable = value;

	}

	public Transparency getTransparency() {

		return transparency;

	}

	public Metadata getMetadata() {

		return null;

	}

	public ColorInterpretation getColorInterpretation() {

		return this.colorInterpretation;

	}

	public void setColorInterpretation(ColorInterpretation colorInterpretation) {

		this.colorInterpretation = colorInterpretation;

	}

	public Statistics getStatistics() {

		if(stats == null) {

			stats = new SimpleProviderStatistics(this);

		}

		return stats;

	}

	public void setStatistics(Statistics stats) throws RmfSerializerException {

		this.stats = stats;

		saveObjectToRmf(Statistics.class, stats);

	}

	public HistogramComputer getHistogramComputer() {

		if (histogram == null)

			histogram = new SimpleProviderHistogramComputer(this);

		return histogram;

	}

    //****************************************************

	//*********Implementing Disposable methods************

	//****************************************************

    public void doDispose() {

    }

    //****************************************************

	//*****Implementing DataStoreProvider methods*********

	//****************************************************

	@Override

	public DataServerExplorer getExplorer() throws ReadException,

			ValidateDataParametersException {

		}*/

    	return null;

	}

	/**

	 * Returs the DataParameters

	 * @return

	public void open() throws OpenException {

	}

	/**

	 * Traduce el nombre del fichero por un alias asignado por el propio driver.

	 * Cuando es traducido por un alias el driver intentar� abrir el alias y no el

	 * @param fileName

	 * @return

	 */

		return fileName;

	}

	public String getFileSuffix() {

	}

	}

		return uri;

	}

	public void setFName(String n) {

	}

            try {

            }

	public String getFullName() {

	}

	/**

	 * Gets the size of the file if exists in Bytes

	 * @return

	public String getInfoByPoint(double x, double y, ICancellable cancellable) throws InfoByPointException {

		return null;

	}

	public String getInfoByPoint(int x, int y, Extent bbox, int w, int h, ICancellable cancellable) throws InfoByPointException {

		return null;

	}

	public void setTileServer(Class<?> tileServer) throws InitializeException {

	}

	public int[] getTileSize(int level) {

		return new int[]{0, 0};

	}

	public boolean isRasterEnclosed() {

		return false;

	}

	public int getSourceType() {

		return RasterDataStore.FILE;

	}

	/**

	 * Most of providers don't need tiles. It those cases this method

	 * won't execute anything. Only providers that use tile cache will need

	 * implement this function, for instance TileProvider and MosaicProvider.

	 */

	public void deleteLayerFromCache() {

	}

	public TimeSeries getTimeSerials() throws RmfSerializerException {

		if(serialInfo == null) {

			serialInfo =  new DefaultTimeSerials();

		}

		return serialInfo;

	}

	public void setTimeSerials(TimeSeries serialInfo) throws RmfSerializerException {

		this.serialInfo = serialInfo;

		saveObjectToRmf(TimeSeries.class, serialInfo);

	}

	public long[] getFileSizeByProvider() {

		return new long[]{getFileSize()};

	}

		//For providers with one file

	}

	public int[] getBandCountByProvider() {

		return new int[]{getBandCount()};

	}

	public int getInternalProviderCount() {

		return 1;

	}

	public RasterProvider getInternalProvider(int i) {

		return this;

	}

		//No matter which band be selected. In providers with one file is always the first URI

		return getURIOfFirstProvider();

	}

	public int getBandPositionByProvider(int band) {

		return band;

	}

	public int getSubdatasetCount() {

		return 0;

	}

	public boolean needEnhanced() {

		return false;

	}

	/**

	 * Gets the {@link Interval} of the store, that means the temporal

	 * interval where the store has valid data.

	 * by the provider.

	 * @return

	 *         a time interval or null if there is not time support

	public Interval getInterval() {

		return null;

	}

	/**

	 * by the provider.

	 * @return

	 *         a collection of {@link Time} objects.

	public Collection<?> getTimes() {

		return null;

	}

	/**

	 * Gets all the possible values of time for which the store has data

	 * and intersects with an interval.

	 * by the provider.

	 * @param interval

	 *         the interval of time

	public Collection<?> getTimes(Interval interval) {

		return null;

	}

	/**

	 * Gets the list of geo points associated to this provider

	 * @return

	public GeoPointList getGeoPointList() {

		return geoPointList;

	}

	/**

	 * Sets the list of geo points associated to this provider

	 */

	public void setGeoPointList(GeoPointList geoPointList) {

		this.geoPointList = geoPointList;

	}

	/**

	 * @deprecated This method should not be used. The store have a getDefaultBandList

	 * @return

	 */

	public BandList getDefaultBandList() {

		BandList bandList = new BandListImpl();

		int[] nBandsByProvider = getBandCountByProvider();

		for (int iProvider = 0; iProvider < uriByProvider.length; iProvider++) {

			for (int iBand = 0; iBand < nBandsByProvider[iProvider]; iBand++) {

				try {

				} catch (BandNotFoundInListException e1) {

				}

			}

		}

		int[] drawableBands = new int[bandList.getBandCount()];

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

			drawableBands[i] = i;

		}

		bandList.setDrawableBands(drawableBands);

		return bandList;

	}

	public void close() {

		if(transparency != null)

			transparency.dispose();

		} catch (Throwable e) {

		}

	}

	protected void finalize() throws Throwable {

		dataType               = null;

		noData                 = null;