Application: gvSIG desktop » gvSIG raster

			}

		}

		//System.out.println("***************************");

	}

	public int getOverviewCount(int band) throws BandAccessException, RasterDriverException {

	private JTextField         directoryTextField   = null;

	private JLabel             jLabelDirectory      = null;

	private JButton            jBChooseDirectory    = null;

	/**

	 * Constructor. 

		getJBChooseDirectory().addActionListener(this);

	}

	/**

	 * Obtiene el bot?n de asignaci?n de directorio

	 * @return JButton

			getDirectoryTextField().setText(chooser.getSelectedFile().toString());

		else

			chooser.setLastPath(new File(getDirectoryTextField().getText()));

	}

	/**

set_view_projection=Asignar proyecci?n

error_saving_rois_rmf=Error salvando las ROI en el fichero de metadatos

problems_loading_rois=Problemas cargando el fichero de ROI.\n La ejecuci?n de la aplicaci?n seguir? normalmente.

set_view_projection=Set projection

error_saving_rois_rmf=Error saving the ROI in the metadata file

problems_loading_rois=Problems loading regions of interest from the file.\n The execution of gvSIG will continue normally.

package org.gvsig.fmap.dal.coverage.store.parameter;

import org.cresques.cts.IProjection;

import org.gvsig.fmap.dal.DataStoreParameters;

	 * @param frame

	 */

	public int getFrame();

}

	protected long                            lineCnt                = 0;

	protected String                          uri;

	protected String                          selectedSubdatasetID   = null;

	/**

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

	 * propia imagen. Esta informaci?n est? en la cabecera o en ficheros

		return getName();

	}

	public String[] getFormatList() {

		return null;

	}

	protected void init() {

	}

	public boolean isTiled() {

		return false;

	}

	public boolean isTimeSupported() {

		return false;

	}

	public RasterProvider cloneProvider() throws CloneException {

		try {

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

	 *

	 * @return SingleDataset, o null si hay problemas.

	 */

	public static DefaultRasterProvider singleDatasetInstance(DataStoreProviderServices storeServices, String param) throws RasterDriverException {

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

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

	abstract public int getBlockSize();

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

	/**

		this.dataType = dataType;

	}

	public double getPixelSizeX() {

		return externalTransformation.getScaleX();

	}

	public double getPixelSizeY() {

		return externalTransformation.getScaleY();

	}

	public NoData getNoDataValue() {

		if(noData == null) {

			noData = RasterLocator.getManager().getDataStructFactory().createNoData(null, null, getRMFFile(), getBandCount());

		return noData;

	}

	public void setNoDataValue(NoData value) {

		this.noData = value;

	}

		this.storeServices = provServices;

	}

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

	public void selectSubdataset() {}

	/**

		return rmfBlocksManager;

	}

	public String getRMFFile() {

		String tail = selectedSubdatasetID == null ? ".rmf" : "-sd" + selectedSubdatasetID + ".rmf";

	}

	public boolean isInside(Point2D p){

		//Realizamos los calculos solo si el punto est? dentro del extent de la imagen rotada, as? nos ahorramos los calculos

		//cuando el puntero est? fuera

		return false;

	}

	public boolean isMultiFile() {

		return false;

	}

	public boolean isMosaic() {

		return false;

	}

		return null;

	}

	@SuppressWarnings("unchecked")

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

		((DefaultProviderServices)RasterLocator.getManager().getProviderServices()).saveObjectToRmfFile(getRmfBlocksManager(), class1, value);

		return serializerObject.getResult();

	}

	@SuppressWarnings("unchecked")

	public Object loadObjectFromRmf(Class class1, Object value) throws RmfSerializerException {

		return loadObjectFromRmfFile(getRmfBlocksManager(), class1, value);

		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;

	}

		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);

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

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

    public void doDispose() {

    }

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

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

	@Override

	public DataServerExplorer getExplorer() throws ReadException,

			ValidateDataParametersException {

		return null;

	}

	@SuppressWarnings("unchecked")

	public Iterator getChilds() {

		return null;

	}

	public ResourceProvider getResource() {

		return null;

	}

	public Object getSourceId() {

		if( this.getDataParameters() instanceof RasterFileStoreParameters)

			return ((RasterFileStoreParameters)this.getDataParameters()).getFile();

			return this.getDataParameters().getURI();

	}

	public void open() throws OpenException {

	}

		return fileName;

	}

	public String getFileSuffix() {

		return getURIOfFirstProvider().substring(getURIOfFirstProvider().lastIndexOf(".") + 1, getURIOfFirstProvider().length());

	}

	public String getURIOfFirstProvider() {

		return RasterLocator.getManager().getFileUtils().getFormatedRasterFileName(uri);

	}

	public String getURI() {

		return uri;

	}

		fileSize = sz;

	}

	public IProjection getProjection() {

		return proj;

	}

		return (new Date()).getTime();

	}

	public void setAffineTransform(AffineTransform t) {

		externalTransformation = (AffineTransform) t.clone();

	}

	public AffineTransform getAffineTransform() {

		return externalTransformation;

	}

		externalTransformation.setToIdentity();

	}

	public AffineTransform getOwnAffineTransform() {

		return ownTransformation;

	}

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

		return null;

	}

		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() {

		if(getURI().startsWith("PG:host"))

			return RasterDataStore.POSTGIS;

	}

	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()};

	}

	public String[] getURIByProvider() {

		//For providers with one file

		return new String[]{getURIOfFirstProvider()};

	}

	public int[] getBandCountByProvider() {

		return new int[]{getBandCount()};

	}

	public int getInternalProviderCount() {

		return 1;

	}

	public RasterProvider getInternalProvider(int i) {

		return this;

	}

	public String getURIByBand(int band) {

		//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 void addFile(String file) throws InvalidSourceException {

		//Do nothing

	}

	public void removeFile(String file) {

		//Do nothing		

	}

	public boolean needEnhanced() {

		return false;

	}

		}

	}

	protected void finalize() throws Throwable {

		dataType               = null;

		noData                 = null;

	private static final String    FIELD_ALPHABAND        = "alphaband";

	private static final String    FIELD_VISIBLE          = "visible";

	private static final String    FIELD_REPROJ_OPTION    = "selected_option";

	public static DynClass registerDynClass(String dynClassName) {

		field.setMandatory(false);

		field.setHidden(true);

		return dynClass;

	}

		return (this.getURI() != null);

	}

	public String getURI() {

		return (String) this.getDynValue(FIELD_URI);

	}

	public void setURI(String uri) {

		this.setDynValue(FIELD_URI, uri);

	}

	public String getSRSID() {

		IProjection srs = (IProjection) getDynValue(FIELD_CRS);

		return 0;

	}

	public boolean isVisible() {

		Boolean b = (Boolean)getDynValue(FIELD_VISIBLE);

		if(b != null)

		return true;

	}

	public void setVisible(boolean visible) {

		this.setDynValue(FIELD_VISIBLE, new Boolean(visible));

	}

	public void loadFromState(PersistentState state) throws PersistenceException {

		String uriString = null;

		try {

		setAlphaBand(state.getInt(FIELD_ALPHABAND));

		setFrame(state.getInt(FIELD_FRAME));

		setVisible(state.getBoolean(FIELD_VISIBLE));

	}

	public void saveToState(PersistentState state) throws PersistenceException {

		try {

			String uri = getURI();

		state.set(FIELD_ALPHABAND, getAlphaBand());

		state.set(FIELD_FRAME, getFrame());

		state.set(FIELD_VISIBLE, isVisible());

	}	

	public static void registerPersistence(DynStruct definition) {

		definition.addDynFieldInt(FIELD_ALPHABAND).setMandatory(false);

		definition.addDynFieldInt(FIELD_FRAME).setMandatory(false);

		definition.addDynFieldBoolean(FIELD_VISIBLE).setMandatory(false);

	}

}

	 * Cancels the task in progress and avoids that next tiles are gotten

	 */

	public void cancelTaskInProgress() {

		getMoreTiles = false;

	}