Application: gvSIG desktop » gvSIG raster

import java.awt.geom.Dimension2D;

import java.util.ArrayList;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataStoreParameters;

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

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

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

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

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

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

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

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

import org.gvsig.fmap.dal.raster.spi.CoverageStoreProvider;

import org.gvsig.fmap.dal.spi.DataManagerProviderServices;

import org.gvsig.raster.impl.datastruct.DefaultViewPortData;

import org.gvsig.raster.impl.grid.GridImpl;

import org.gvsig.raster.impl.provider.DefaultRasterProvider;

import org.gvsig.raster.impl.provider.RasterProvider;

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

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

import org.gvsig.raster.impl.store.properties.DataStoreColorInterpretation;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

	private static final Logger         logger            = LoggerFactory.getLogger(DefaultRasterManager.class);

	private static Class<?>             tileclass         = null;

	private static ArrayList<Class<?>>  tiledProviders    = new ArrayList<Class<?>>(); 

	private static HashMap<String, ArrayList<Class<?>>>

                                        formatsRegistry   = new HashMap<String, ArrayList<Class<?>>>();

	public RasterDataStore open(CoverageStoreProvider prov, DataStoreParameters params) throws NotSupportedExtensionException, RasterDriverException {

		if(prov instanceof RasterProvider) {

			DefaultRasterStore store = new DefaultRasterStore();

			store.setProvider((RasterProvider)prov);

			try {

				store.intializePhase1(null, params);

			} catch (InitializeException e) {

				throw new RasterDriverException(e.getMessage());

			}

			return store;

		}

		return null;

	}

	public RasterDataStore open(DataStoreParameters params) throws NotSupportedExtensionException, RasterDriverException {

		if(params == null || !(params instanceof AbstractRasterDataParameters))

			return null;

		DefaultRasterStore dSet = new DefaultRasterStore();

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

		try {

			DefaultRasterProvider provider = (DefaultRasterProvider)dataManager.createProvider(dSet, (AbstractRasterDataParameters)params);

			dSet.setProvider(provider);

		} catch (InitializeException e) {

			throw new RasterDriverException("Error initializing provider", e);

		} catch (ProviderNotRegisteredException e) {

			throw new RasterDriverException("Provider not register error", e);

		}

		return dSet;

	}

	public RasterDataStore open(Object datasetOpenParam) throws NotSupportedExtensionException, RasterDriverException {

		DefaultRasterStore dSet = new DefaultRasterStore();

		if (datasetOpenParam instanceof String) {

			DefaultRasterProvider provider = DefaultRasterProvider.singleDatasetInstance(dSet, (String)datasetOpenParam);

			dSet.setProvider(provider);

			return dSet;

		}

		/*if (datasetOpenParam instanceof String[]) {

			String[] param = (String[]) datasetOpenParam;

			try {

				for (int dataset = 0; dataset < param.length; dataset++) {

					dSet.addDataStore(DefaultRasterProvider.singleDatasetInstance(dSet, param[dataset]) );

				}

			} catch (OperationNotSupportedException e) {

				return open(param[0]);

			}

			return dSet;

		} 

		if (datasetOpenParam instanceof Buffer[]) {

			Buffer[] param = (Buffer[]) datasetOpenParam;

			for (int dataset = 0; dataset < param.length; dataset++) {

				dSet.addDataStore(DefaultRasterProvider.singleDatasetInstance(param[dataset]));

			}

			return dSet;

		}

		if(datasetOpenParam instanceof String[][]) {

			String[][] param = (String[][])datasetOpenParam;

			DefaultMultiRasterStore[][] mosaic = new DefaultMultiRasterStore[param.length][param[0].length];

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

				for (int j = 0; j < param[i].length; j++)

					mosaic[i][j] = (DefaultMultiRasterStore)open(param[i][j]);

			DefaultMosaicRasterStore cd;

			try {

				cd = new DefaultMosaicRasterStore(mosaic);

			} catch (MosaicNotValidException e) {

				return null;

			}

			return cd;

		}*/

		return null;

	}

	@SuppressWarnings("unchecked")

		Class clase = point.get(ext).getExtension();

		Class[] args = { String.class };

			Constructor hazNuevo = clase.getConstructor(args);

	@SuppressWarnings("unchecked")

		Class clase = point.get(ext).getExtension();

		Class[] args = { DataServerWriter.class, String.class, Integer.class, AffineTransform.class, Integer.class, Integer.class, Integer.class, Params.class, IProjection.class, Boolean.class };

			Constructor hazNuevo = clase.getConstructor(args);

	public Vectorization getVectorizeObject(QueryableRaster queryable) throws RasterDriverException, ProcessInterruptedException {

	public ColorInterpretation createColorInterpretation(String[] colorInterp) {

		return new DataStoreColorInterpretation(colorInterp);

	}

	public Grid createGrid(RasterDataStore datasource, int[] bands, GridExtent windowExtent) throws RasterBufferInvalidException {

		return new GridImpl(datasource, bands, windowExtent);

	public Grid createGrid(RasterDataStore datasource, int[] bands) throws RasterBufferInvalidException {

		return new GridImpl(datasource, bands);

	public Grid createGrid(RasterDataStore datasource) throws RasterBufferInvalidException {

		return new GridImpl(datasource);

	}

	public Grid createGrid(GridExtent layerExtent,

			GridExtent windowExtent,

			int dataType,

			int[] bands) throws RasterBufferInvalidException {

		return new GridImpl(layerExtent, windowExtent, dataType, bands);

	}

	public Grid createGrid(Buffer buf, RasterDataStore datasource, boolean notInterp) {

		return new GridImpl(buf, datasource, notInterp);

	}

    public ViewPortData createViewPortData(IProjection proj, Extent extent, Dimension2D size) {

    	return new DefaultViewPortData(proj, extent, size);

    }

    public ViewPortData createViewPortData() {

    	return new DefaultViewPortData();

    }

	public void registerFileProvidersTiled(Class<?> provider) {

		if(!tiledProviders.contains(provider))

			tiledProviders.add(provider);

	}

	public void registerTileProviderFormats(Class<?> c) {

		if(tileclass == null) {

			if(RasterProvider.class.isAssignableFrom(c)) {

				ArrayList<?> pList = getTiledProvidersInstance();

				for (int i = 0; i < pList.size(); i++) {

					String[] fList = ((RasterProvider)pList.get(i)).getFormatList();

					for (int j = 0; j < fList.length; j++) {

						String value = fList[j];

						addFormat(value, c);

					}

				}

			}

			tileclass = c;

		}

	}

	@SuppressWarnings("unchecked")

	private ArrayList<?> getTiledProvidersInstance() {

		ArrayList list = new ArrayList();

		for (int i = 0; i < tiledProviders.size(); i++) {

			Class<?> provider = tiledProviders.get(i);

			try {

				Constructor c = provider.getConstructor();

				list.add(c.newInstance());

			} catch (SecurityException e) {

				logger.info("Error SecurityException in open", e);

			} catch (NoSuchMethodException e) {

				logger.info("Error NoSuchMethodException in open", e);

			} catch (IllegalArgumentException e) {

				logger.info("Error IllegalArgumentException in open", e);

			} catch (InstantiationException e) {

				logger.info("Error InstantiationException in open", e);

			} catch (IllegalAccessException e) {

				logger.info("Error IllegalAccessException in open", e);

			} catch (InvocationTargetException e) {

				logger.info("Error in open. Problemas con las librer?as nativas.", e);

			}

		}

		return list;

	}

	public void addFormat(String ext, Class<?> c) {

		ArrayList<Class<?>> list = formatsRegistry.get(ext);

		if(list == null) {

			list = new ArrayList<Class<?>>();

			list.add(c);

			formatsRegistry.put(ext, list);

		} else {

			if(!list.contains(c))

				list.add(c);

		}

	}

	public boolean isExtensionSupported(String ext, Class<?> c) {

		String extension = getFileUtils().getExtensionFromFileName(ext);

		ArrayList<Class<?>> list = formatsRegistry.get(extension);

		if(list == null) {

			return false;

		} else {

			for (int i = 0; i < list.size(); i++) {

				if(c == list.get(i))

					return true;

			}

		}

		return false;

	}

	public boolean isExtensionSupported(String ext) {

		String extension = getFileUtils().getExtensionFromFileName(ext);

		ArrayList<Class<?>> list = formatsRegistry.get(extension);

		if(list == null) {

			return false;

		} 

		return true;

	}

	public String[] getReadOnlyFormatList() {

		return formatsRegistry.keySet().toArray(new String[0]);

	}