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.

*

*/

/*

* AUTHORS (In addition to CIT):

* 2009 IVER T.I   {{Task}}

*/

package org.gvsig.raster.tilecache.io.tff;

import org.gvsig.fmap.dal.DataServerExplorerParameters;

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

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DelegatedDynObject;

import org.gvsig.tools.dynobject.DynClass;

import org.gvsig.tools.dynobject.DynObjectManager;

/**

 * Parameters for the TileFileFormat explorer provider

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

 */

public class TileFileFormatExplorerParameters extends AbstractDataParameters implements DataServerExplorerParameters {

	public static final String     DYNCLASS_NAME       = "TileFileFormatExplorerParameters";

	protected static DynClass      DYNCLASS            = null;

	private DelegatedDynObject     delegatedDynObject  = null;

	public TileFileFormatExplorerParameters() {

		super();

		initialize();

	}

	protected void initialize() {

		this.delegatedDynObject = (DelegatedDynObject) ToolsLocator

				.getDynObjectManager().createDynObject(

						DYNCLASS);

	}

	public static void registerDynClass() {

		DynObjectManager dynman = ToolsLocator.getDynObjectManager();

		DynClass dynClass;

		if(dynman == null)

			return;

		if (DYNCLASS == null) {

			dynClass = dynman.add(DYNCLASS_NAME);

			DYNCLASS = dynClass;

		}

	}

	protected DelegatedDynObject getDelegatedDynObject() {

		return delegatedDynObject;

	}

	public String getDataStoreName() {

		return TileFileFormatProvider.NAME;

	}

	public String getDescription() {

		return TileFileFormatProvider.DESCRIPTION;

	}

	public String getExplorerName() {

		return TileFileFormatProvider.NAME;

	}

}

/* 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.tilecache.io.tff;

import java.awt.geom.Point2D;

import org.gvsig.fmap.dal.DALFileLocator;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataStore;

import org.gvsig.fmap.dal.coverage.RasterLocator;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

import org.gvsig.metadata.MetadataLocator;

import org.gvsig.raster.cache.tile.Tile;

import org.gvsig.raster.cache.tile.exception.TileGettingException;

import org.gvsig.raster.cache.tile.provider.TileListener;

import org.gvsig.raster.cache.tile.provider.TileServer;

import org.gvsig.raster.impl.buffer.DefaultRasterQuery;

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

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

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

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

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.extensionpoint.ExtensionPoint;

import org.gvsig.tools.extensionpoint.ExtensionPointManager;

import org.gvsig.tools.task.TaskStatus;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 * Provider for <code>TileFileFormat</code>

 *

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

 */

public class TileFileFormatProvider extends DefaultRasterProvider implements TiledRasterProvider {

	public static String                NAME                     = "TileFileFormat Store";

	public static String                DESCRIPTION              = "Tile file format Source";

	public static final String          METADATA_DEFINITION_NAME = "TileFileFormatStore";

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

	protected static String[]           formatList               = null;

	private boolean                     open                     = false;

	public static void register() {		

		ExtensionPointManager extensionPoints = ToolsLocator.getExtensionPointManager();

		registerFormats();

		ExtensionPoint point = extensionPoints.get("DefaultRasterProvider");

		point.append("reader", TileFileFormatProvider.NAME, TileFileFormatProvider.class);

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

		if (dataman != null && !dataman.getStoreProviders().contains(NAME)) {

			dataman.registerStoreProvider(NAME,

					TileFileFormatProvider.class, TileFileFormatDataParameters.class);

		}

		if(DALFileLocator.getFilesystemServerExplorerManager() != null)

			DALFileLocator.getFilesystemServerExplorerManager().registerProvider(

					NAME, DESCRIPTION,

					TileFileFormatFilesystemServerExplorer.class);

		dataman.registerStoreFactory(NAME, DefaultStoreFactory.class);

	}

	private static void registerFormats() {

		formatList      = new String[] {"tff"};

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

			RasterLocator.getManager().getProviderServices().addFormat(formatList[i], TileFileFormatProvider.class);

	}

	public String[] getFormatList() {

		return formatList;

	}

	public boolean isExtensionSupported(String ext) {

		if(ext.indexOf(".") != -1)

			ext = ext.substring(ext.lastIndexOf(".") + 1, ext.length());

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

			if(formatList[i].compareTo(ext) == 0)

				return true;

		}

		return false;

	}

	public TileFileFormatProvider() throws NotSupportedExtensionException {

		super();

	}

	public TileFileFormatProvider(TileFileFormatDataParameters params,

			DataStoreProviderServices storeServices) throws InitializeException {

		super(params, storeServices, ToolsLocator.getDynObjectManager()

				.createDynObject(

						MetadataLocator.getMetadataManager().getDefinition(

								DataStore.METADATA_DEFINITION_NAME)));

		try {

			init(params, storeServices);

		} catch (OpenException e) {

			throw new InitializeException("Error open the source", e);

		} catch (NotSupportedExtensionException e) {

			throw new InitializeException("Not supported extension", e);

		}

	}

	/**

	 * Build file references

	 * @param proj Projection

	 * @param param Load parameters

	 * @throws NotSupportedExtensionException

	 */

	public void init(TileFileFormatDataParameters params,

			DataStoreProviderServices storeServices) throws NotSupportedExtensionException, OpenException {

		openFromTff();

		uri = getParameters().getURI();

		super.init();

		try {

			loadFromRmf(getRmfBlocksManager());

		} catch (ParsingException e) {

			logger.debug("Problems reading from RMF", e);

		}

		open = true;

	}

	/**

	 * Open from a .mff file. 

	 * This method loads all providers and adds these to the parameters

	 * @throws OpenException

	 */

	private void openFromTff() throws OpenException {

	}

	public TileFileFormatDataParameters getParameters() {

		try {

			return (TileFileFormatDataParameters)parameters;

		} catch (ClassCastException e) {

			return null;

		}

	}

	@Override

	public int getBlockSize() {

		return 0;

	}

	@Override

	public Object getData(int x, int y, int band)

			throws InvalidSetViewException, FileNotOpenException,

			RasterDriverException {

		return null;

	}

	@Override

	public double getHeight() {

		return 0;

	}

	@Override

	public int getOverviewHeight(int band, int overview)

			throws BandAccessException, RasterDriverException {

		return 0;

	}

	@Override

	public int getOverviewWidth(int band, int overview)

			throws BandAccessException, RasterDriverException {

		return 0;

	}

	@Override

	public Extent getView() {

		return null;

	}

	@Override

	public double getWidth() {

		return 0;

	}

	@Override

	protected Buffer getWindow(Extent extent, BandList bandList,

			Buffer rasterBuf, TaskStatus status)

			throws ProcessInterruptedException, RasterDriverException {

		return null;

	}

	@Override

	protected void getWindow(Extent ex, int bufWidth, int bufHeight,

			BandList bandList, TileListener listener, TaskStatus taskStatus)

			throws ProcessInterruptedException, RasterDriverException {

	}

	@Override

	protected Buffer getWindow(Extent extent, int bufWidth, int bufHeight,

			BandList bandList, Buffer rasterBuf, boolean adjustToExtent,

			TaskStatus status) throws ProcessInterruptedException,

			RasterDriverException {

		return null;

	}

	@Override

	protected Buffer getWindow(int x, int y, int w, int h, BandList bandList,

			Buffer rasterBuf, TaskStatus status)

			throws ProcessInterruptedException, RasterDriverException {

		return null;

	}

	@Override

	protected Buffer getWindow(double x, double y, double w, double h,

			BandList bandList, Buffer rasterBuf, boolean adjustToExtent,

			TaskStatus status) throws ProcessInterruptedException,

			RasterDriverException {

		return null;

	}

	@Override

	public boolean isOverviewsSupported() {

		return false;

	}

	@Override

	public RasterProvider load() {

		return null;

	}

	@Override

	public void setView(Extent e) {

	}

	public Extent getCoordsInLevel(Point2D viewCenter, int level, int w, int h) {

		return null;

	}

	public Extent getCoordsInTheNearestLevel(Extent extent, int w, int h) {

		return null;

	}

	public RasterProvider getInternalProvider() {

		return null;

	}

	public int getNearestLevel(double pixelSize) {

		return 0;

	}

	public Tile getTile(DefaultRasterQuery q) throws TileGettingException {

		return null;

	}

	public int getZoomLevels() {

		return 0;

	}

	public int getOverviewCount(int band) throws BandAccessException,

			RasterDriverException {

		return 0;

	}

	public TileServer getTileServer() {

		return null;

	}

	public boolean isOpen() {

		return open;

	}

	public Object readBlock(int pos, int blockHeight, double scale)

			throws InvalidSetViewException, FileNotOpenException,

			RasterDriverException, ProcessInterruptedException {

		return null;

	}

	public void setStatus(RasterProvider provider) {

	}

	public String getName() {

		return null;

	}

}

/* 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.tilecache.io.tff;

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

/**

 * Parameters for creating a <code>TileFileFormat</code> store

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

 */

public class TileFileFormatNewRasterStoreParameters extends AbstractNewRasterStoreParameters {

	public String getDataStoreName() {

		return TileFileFormatProvider.NAME;

	}

	public String getDescription() {

		return TileFileFormatProvider.DESCRIPTION;

	}

}

/* 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.tilecache.io.tff;

import java.io.File;

import java.util.List;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.DataServerExplorer;

import org.gvsig.fmap.dal.DataServerExplorerParameters;

import org.gvsig.fmap.dal.DataStoreParameters;

import org.gvsig.fmap.dal.NewDataStoreParameters;

import org.gvsig.fmap.dal.coverage.RasterLocator;

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

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

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

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

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

import org.gvsig.fmap.dal.serverexplorer.filesystem.impl.AbstractFilesystemServerExplorerProvider;

import org.gvsig.fmap.dal.serverexplorer.filesystem.spi.FilesystemServerExplorerProviderServices;

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

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

public class TileFileFormatFilesystemServerExplorer extends AbstractFilesystemServerExplorerProvider {

	public TileFileFormatFilesystemServerExplorer() {

	}

	public TileFileFormatFilesystemServerExplorer(

			TileFileFormatExplorerParameters parameters,

			DataServerExplorerProviderServices services)

			throws InitializeException {

		System.out.println();

	}

	public String getDataStoreProviderName() {

		return TileFileFormatProvider.NAME;

	}

	public String getDescription() {

		return TileFileFormatProvider.DESCRIPTION;

	}

	public DataStoreParameters getStoreParameters() {

		DataManager manager = DALLocator.getDataManager();

		try {

			return  manager.createStoreParameters(this.getDataStoreProviderName());

		} catch (InitializeException e) {

			e.printStackTrace();

		} catch (ProviderNotRegisteredException e) {

			e.printStackTrace();

		}

		return null;

	}

	@SuppressWarnings("unchecked")

	public List getDataStoreProviderNames() {

		return null;

	}

	public String getProviderName() {

		return TileFileFormatProvider.NAME;

	}

	public DataServerExplorerProviderServices getServerExplorerProviderServices() {

		return null;

	}

	public boolean canCreate() {

		return false;

	}

	public boolean canCreate(NewDataStoreParameters parameters) {

		return false;

	}

	public void create(NewDataStoreParameters parameters, boolean overwrite)

			throws CreateException {

		throw new UnsupportedOperationException();

	}

	public NewDataStoreParameters getCreateParameters() throws DataException {

		return null;

	}

	public void initialize(

			FilesystemServerExplorerProviderServices serverExplorer) {

	}

	public boolean accept(File pathname) {

		return RasterLocator.getManager().getProviderServices().isExtensionSupported(

				pathname.getAbsolutePath(), 

				TileFileFormatProvider.class);

	}

	public void remove(DataStoreParameters parameters) throws RemoveException {

		throw new UnsupportedOperationException();

	}

	public boolean add(String provider, NewDataStoreParameters parameters,

			boolean overwrite) throws DataException {

		return false;

	}

	public boolean canAdd() {

		return false;

	}

	public boolean canAdd(String storeName) throws DataException {

		return false;

	}

	public NewDataStoreParameters getAddParameters(String storeName)

			throws DataException {

		return null;

	}

	public DataStoreParameters getParameters(File file) throws DataException {

		DataManager manager = DALLocator.getDataManager();

		AbstractRasterFileDataParameters params = (AbstractRasterFileDataParameters) manager

				.createStoreParameters(this.getDataStoreProviderName());

		params.setFile(file);

		return params;

	}

	public DataServerExplorerParameters getParameters() {

		return null;

	}

	@SuppressWarnings("unchecked")

	public List list() throws DataException {

		return null;

	}

	@SuppressWarnings("unchecked")

	public List list(int mode) throws DataException {

		return null;

	}

	public void dispose() {

	}

	public int getMode() {

		return DataServerExplorer.MODE_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.tilecache.io.tff;

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

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

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DynStruct;

import org.gvsig.tools.persistence.PersistenceManager;

import org.gvsig.tools.persistence.PersistentState;

import org.gvsig.tools.persistence.exception.PersistenceException;

/**

 * Parameters for the <code>TileFileFormatProvider</code>

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

 */

public class TileFileFormatDataParameters extends AbstractRasterFileDataParameters {

	public String getDataStoreName() {

		return TileFileFormatProvider.NAME;

	}

	public String getDescription() {

		return TileFileFormatProvider.DESCRIPTION;

	}

	public void loadFromState(PersistentState state)

			throws PersistenceException {

		super.loadFromState(state);

	}

	public void saveToState(PersistentState state) throws PersistenceException {

		super.saveToState(state);

	}	

	public static void registerPersistence() {

		PersistenceManager manager = ToolsLocator.getPersistenceManager();

		DynStruct definition = manager.getDefinition("TileFileFormatDataParameters_Persistent");

		if( definition == null ) {

			definition = manager.addDefinition(

					TileFileFormatDataParameters.class,

					"TileFileFormatDataParameters_Persistent",

					"TileFileFormatDataParameters Persistent",

					null, 

					null

			);

			AbstractRasterDataParameters.registerPersistence(definition);

		}

	}

}

 * Parameters for the <code>TileProvider</code>