Application: gvSIG desktop

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

LidarExtension.java

Copyright (C) 2008 by DIELMO 3D S.L.

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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

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

package com.dielmo.gvsig.lidar.extensions;

import java.awt.Color;

import java.awt.Component;

import java.awt.geom.Rectangle2D;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.InputStreamReader;

import java.io.Reader;

import java.io.UnsupportedEncodingException;

import java.text.NumberFormat;

import javax.swing.JOptionPane;

import org.exolab.castor.xml.ValidationException;

import com.dielmo.gvsig.lidar.LidarHeader;

import com.dielmo.gvsig.lidar.Strategies.LidarWatcher;

import com.dielmo.gvsig.lidar.drivers.LiDARDriver;

import com.hardcode.gdbms.engine.instruction.FieldNotFoundException;

import com.hardcode.gdbms.engine.values.ValueFactory;

import com.hardcode.gdbms.engine.values.ValueWriter;

import com.iver.andami.PluginServices;

import com.iver.andami.plugins.Extension;

import com.iver.andami.preferences.IPreference;

import com.iver.andami.preferences.IPreferenceExtension;

import com.iver.cit.gvsig.fmap.DriverException;

import com.iver.cit.gvsig.fmap.MapContext;

import com.iver.cit.gvsig.fmap.MapControl;

import com.iver.cit.gvsig.fmap.core.FShape;

import com.iver.cit.gvsig.fmap.core.IGeometry;

import com.iver.cit.gvsig.fmap.core.v02.FSymbol;

import com.iver.cit.gvsig.fmap.drivers.DriverIOException;

import com.iver.cit.gvsig.fmap.layers.FLayer;

import com.iver.cit.gvsig.fmap.layers.FLayers;

import com.iver.cit.gvsig.fmap.layers.FLyrVect;

import com.iver.cit.gvsig.fmap.layers.ReadableVectorial;

import com.iver.cit.gvsig.fmap.layers.SelectableDataSource;

import com.iver.cit.gvsig.fmap.layers.XMLException;

import com.iver.cit.gvsig.fmap.rendering.FInterval;

import com.iver.cit.gvsig.fmap.rendering.Legend;

import com.iver.cit.gvsig.fmap.rendering.LegendFactory;

import com.iver.cit.gvsig.fmap.rendering.SingleSymbolLegend;

import com.iver.cit.gvsig.fmap.rendering.VectorialIntervalLegend;

import com.iver.cit.gvsig.fmap.rendering.VectorialLegend;

import com.iver.cit.gvsig.fmap.rendering.VectorialUniqueValueLegend;

import com.iver.cit.gvsig.project.documents.view.IProjectView;

import com.iver.cit.gvsig.project.documents.view.gui.View;

import com.iver.utiles.XMLEntity;

import com.iver.utiles.xml.XMLEncodingUtils;

import com.iver.utiles.xmlEntity.generate.XmlTag;

import com.iver.cit.gvsig.fmap.layers.SingleLayerIterator;

public class LidarExtension extends Extension implements IPreferenceExtension{		

	private static final IPreference thePreferencePage = new Lidar_Preferences();

	public void initialize() {

	}

	public void execute(String actionCommand) {		

		if(actionCommand.equalsIgnoreCase("Z_LEGEND")) {

			zLegend();

		}

		else if (actionCommand.equalsIgnoreCase("CLASIFICACION_LEGEND")) {

			clasificationLegend();

		}

		else if (actionCommand.equalsIgnoreCase("INTENSITY_LEGEND")) {

			intensityLegend();			

		}

		else if (actionCommand.equalsIgnoreCase("PREFER_LEGEND")) {

			PreferenceLegend();

		}

		else if(actionCommand.equalsIgnoreCase("DEFAULT_LEGEND")) {

			defaultLegend();

		}

		return;

	}

	/**

	 * Aplica la leyenda por intervalos para el valor de la tabla intensidad

	 */

	private void intensityLegend() {

		FilterByName("Intensity");

	}

	/**

	 * Aplica la leyenda por intervalos para el valor de la tabla z

	 */

	private void zLegend() {

		FilterByName("Z");

	}

	/**

	 * Aplica la leyenda por defecto que aplicaria gvSIG, es decir, aplica

	 * la leyenda para simbolos con colores aleatorios para cada capa.

	 */

		private void defaultLegend() {	

		// Cogemos todas las capas de la vista

        View vista = (View)PluginServices.getMDIManager().getActiveWindow();

		MapContext mapContext = vista.getModel().getMapContext();

		MapControl mc = vista.getMapControl();

        FLayers Layers = mapContext.getLayers();

        AplyDefaultLeyend(Layers, mapContext);

	}

	/**

	 * Recorre todas las capas que contiene el FLayers de entrada

	 * y le aplica la leyenda por defecto (colores aleatorios para cada capa)

	 * 

	 * @param layers, capas en las que aplicaremos la leyenda

	 */

		private void AplyDefaultLeyend(FLayers layers, MapContext mc) {

		SingleSymbolLegend legend;

		FSymbol s;

		FLayer lyr;

		SingleLayerIterator it = new SingleLayerIterator(layers);

		mc.beginAtomicEvent();

        while (it.hasNext()) {

        	lyr = it.next();

			if (lyr instanceof FLyrVect) {

				try {

					FLyrVect lyrVect = (FLyrVect) lyr;

					s = new FSymbol(FShape.POINT);

					s.setSize(5);

					legend = new SingleSymbolLegend(s);

					lyrVect.setLegend((VectorialLegend) legend);

				} catch (FieldNotFoundException e) {

					// TODO Auto-generated catch block

					e.printStackTrace();

				} catch (DriverException e) {

					// TODO Auto-generated catch block

					e.printStackTrace();

				}

			}

		} // while

        mc.endAtomicEvent();

	}

	/**

	 * Aplica la leyenda predefinida en Preferencias->Preferencias Lidar

	 */

		private void PreferenceLegend() {

		Legend legend = null;

		int i;

		LiDAR_Mapping lm = new LiDAR_Mapping();

		String preferLegend = lm.getPathLegend();

		File file=new File(preferLegend);

		if(!file.isFile())

			return;

		// Cogemos todas las capas de la vista

        View vista = (View)PluginServices.getMDIManager().getActiveWindow();

		MapContext mapContext = vista.getModel().getMapContext();

		MapControl mc = vista.getMapControl();

        FLayers Layers = mapContext.getLayers();

        int LayerCount;

        Layers = extractLayers(Layers, mapContext);

        LayerCount = Layers.getLayersCount();

        mc.cancelDrawing();

		if ((file.getPath().endsWith(".gvl") || file.getPath().endsWith(".GVL"))) {	

			legend = readLegend(file);

			// le asignamos la leyenda a todas las capas lidar

			for (i = 0; i < LayerCount; i++) {

				try {

					Legend cloneLegend = legend.cloneLegend();

					Layers = mapContext.getLayers();

					aplyLegend(Layers,cloneLegend, mapContext);

				} catch (XMLException e) {

					// TODO Auto-generated catch block

					e.printStackTrace();

				}  			

			}

		}

	}

	/**

	 * Aplica la leyenda para las clasificaciones.

	 * 

	 * La clasificacion se corresponde con la definicion que la especificacion

	 * del LAS 1.1 se da sobre el tema. Por esta causa no se usa actualmente, ya

	 * que cada lidar puede tener un tipo de clasificacion.

	 */

		private void clasificationLegend() {

		String filtername = "Classification";

		VectorialUniqueValueLegend legend = null;

		FSymbol mySymbol;

     // Cogemos todas las capas de la vista

        View vista = (View)PluginServices.getMDIManager().getActiveWindow();

		MapContext mapContext = vista.getModel().getMapContext();

        FLayers Layers = mapContext.getLayers();

        FLyrVect lyr = null;

        int i;        

		legend = LegendFactory.createVectorialUniqueValueLegend(FShape.POINT);

		legend.clear();

		legend.setFieldName(filtername);

		mySymbol = setSymbol(PluginServices.getText(null, "Class0"), new Color(0,0,0));

		legend.addSymbol(ValueFactory.createValue(0), mySymbol);

		mySymbol = setSymbol(PluginServices.getText(null, "Class1"), new Color(0,0,0));

		legend.addSymbol(ValueFactory.createValue(1), mySymbol);

		mySymbol = setSymbol(PluginServices.getText(null, "Class2"), new Color(153,0,0));

		legend.addSymbol(ValueFactory.createValue(2), mySymbol);

		mySymbol = setSymbol(PluginServices.getText(null, "Class3"), new Color(153,255,153));

		legend.addSymbol(ValueFactory.createValue(3), mySymbol);

		mySymbol = setSymbol(PluginServices.getText(null, "Class4"), new Color(0,204,0));

		legend.addSymbol(ValueFactory.createValue(4), mySymbol);

		mySymbol = setSymbol(PluginServices.getText(null, "Class5"), new Color(0,153,0));

		legend.addSymbol(ValueFactory.createValue(5), mySymbol);

		mySymbol = setSymbol(PluginServices.getText(null, "Class6"), new Color(255,0,0));

		legend.addSymbol(ValueFactory.createValue(6), mySymbol);

		mySymbol = setSymbol(PluginServices.getText(null, "Class7"), new Color(102,0,102));

		legend.addSymbol(ValueFactory.createValue(7), mySymbol);

		mySymbol = setSymbol(PluginServices.getText(null, "Class8"), new Color(255,0,204));

		legend.addSymbol(ValueFactory.createValue(8), mySymbol);

		mySymbol = setSymbol(PluginServices.getText(null, "Class9"), new Color(51,102,255));

		legend.addSymbol(ValueFactory.createValue(9), mySymbol);

		mySymbol = setSymbol(PluginServices.getText(null, "Class12"), new Color(153,255,204));

		legend.addSymbol(ValueFactory.createValue(12), mySymbol);

		// le asignamos la leyenda a todas las capas lidar

		for (i = 0; i < Layers.getLayersCount(); i++) {

			if (LiDARDriver.isLidarLayer(Layers.getLayer(i))) {

				try {

					lyr = ((FLyrVect) Layers.getLayer(i));

					VectorialUniqueValueLegend cloneLegend = (VectorialUniqueValueLegend) legend.cloneLegend();

					lyr.setLegend(cloneLegend);

				} catch (FieldNotFoundException e) {

					// TODO Auto-generated catch block

					e.printStackTrace();

				} catch (DriverException e) {

					// TODO Auto-generated catch block

					e.printStackTrace();

				} catch (XMLException e) {

					// TODO Auto-generated catch block

					e.printStackTrace();

				}

			}    			

		}

	}

	/**

	 * Obtiene las capas internas de las agrupaciones y las devuelve en un

	 * solo FLayers

	 */ 

		private FLayers extractLayers(FLayers layers, MapContext mc) {

		FLayers capas = new FLayers(mc, null);

		FLayer lyr;

		SingleLayerIterator it = new SingleLayerIterator(layers);

        while (it.hasNext()) {

        	lyr = it.next();

			if (lyr instanceof FLyrVect) {

				try {

					capas.addLayer(lyr.cloneLayer());

				} catch (Exception e) {

					// TODO Auto-generated catch block

					e.printStackTrace();

				}

			}

		} // while

		return capas;

	}

	/** 

	 * Aplica las leyendas a todas las capas del FLayers, incluida

	 * las agrupaciones.

	 * 

	 * @param layers capas a las que aplicarle la leyenda.

	 * @param leyenda, leyenda a aplicar

	 */  

		private void aplyLegend(FLayers layers, Legend leyenda, MapContext mc) {

		FLayer lyr;

		SingleLayerIterator it = new SingleLayerIterator(layers);

		mc.beginAtomicEvent();

        while (it.hasNext()) {

        	lyr = it.next();

			if (lyr instanceof FLyrVect) {

				try {

					FLyrVect lyrVect = (FLyrVect) lyr;

					lyrVect.setLegend((VectorialLegend) leyenda.cloneLegend());

					mc.redraw();

				} catch (FieldNotFoundException e) {

					// TODO Auto-generated catch block

					e.printStackTrace();

				} catch (DriverException e) {

					// TODO Auto-generated catch block

					e.printStackTrace();

				} catch (XMLException e) {

					// TODO Auto-generated catch block

					e.printStackTrace();

				}

			}

		} // while

        mc.endAtomicEvent();

	}

	/**

	 * Aplica la leyenda por intervalos del campo filtername pasado por entrada.

	 * 

	 * @param filtername, campo por el que filtrar

	 */

		private void FilterByName(String filtername) {

		VectorialIntervalLegend legend = null;

		FInterval[] arrayIntervalos = null;

		FSymbol myDefaultSymbol;

		ReadableVectorial rv;

		SelectableDataSource ds;

		int i,campo,LidarLayerCount=0; 

		long NumPointsByLayer, inc=1, j; 

    	double MaxValue=Double.NEGATIVE_INFINITY, MinValue=Double.MAX_VALUE, value;

		// Cogemos todas las capas de la vista

        View vista = (View)PluginServices.getMDIManager().getActiveWindow();

		MapContext mapContext = vista.getModel().getMapContext();

		MapControl mc = vista.getMapControl();

        FLayers layers = mapContext.getLayers();

        IGeometry geom;

        int layerCount;

        layers = extractLayers(layers, mapContext);

        layerCount = layers.getLayersCount();

        Rectangle2D extentView = mapContext.getViewPort().getAdjustedExtent();

        Rectangle2D extentLayer;

        FLyrVect lyr = null;

        mc.cancelDrawing();

     // Calculamos el n?mero de capas que intersectan con la vista

		for (i = 0; i < layerCount; i++) {

			if (LiDARDriver.isLidarLayer(layers.getLayer(i))) {

				try {

					lyr = ((FLyrVect) layers.getLayer(i));

		        	extentLayer = lyr.getFullExtent();

		        	if(extentLayer.intersects(extentView))

					{

		        		LidarLayerCount++;

					}

				}catch (DriverException e) {

					// TODO Auto-generated catch block

					e.printStackTrace();

				}

			}

		}

		// si ninguna capa intersecta con el fullextent dejamos de operar

		if(LidarLayerCount == 0)

			return;

		NumPointsByLayer = 20000 / LidarLayerCount;

		// Cogemos los valores max y min del campo por el que se filtra de todas las capas. 

		for (i = 0; i < layerCount; i++) {

			if (LiDARDriver.isLidarLayer(layers.getLayer(i))) {

		        try {

		        	lyr = ((FLyrVect) layers.getLayer(i));

					rv = lyr.getSource();

			        ds = rv.getRecordset();

		        	extentLayer = lyr.getFullExtent();

		    /*    	if(extentView.contains(extentLayer) && filtername == "Z")

		        	{

		        		// si el campo por el que se filtra es Z y ademas el fullextent de la capa

		        		// esta completamente denro de la vista, cogemos los valores Z de la cabecera

		        		// proporcionada por el driver que maneja la capa

		        		LiDARDriver ld = (LiDARDriver) rv.getDriver();

		        		value = ld.getLidarHeader().getMinZ();

		        		if (MinValue > value)

							MinValue = value;

		        		value = ld.getLidarHeader().getMaxZ();

						if (MaxValue < value)

							MaxValue = value;

		        	}

		        	else

		        	{		*/        		

						campo = ds.getFieldIndexByName(filtername);

						inc = ds.getRowCount() / NumPointsByLayer;

						if (inc < 1)

							inc = 1;

						if(extentLayer.intersects(extentView)) {

							for (j=0 ; j<ds.getRowCount(); j+=inc) {

								geom=rv.getShape((int)j);

								// if (geom.intersects(extentView)) {

								if (geom.fastIntersects(extentView.getMinX(), extentView.getMinY(), extentView.getWidth(), extentView.getHeight())) {

									value=Double.parseDouble(ds.getFieldValue(j, campo).getStringValue(ValueWriter.internalValueWriter));

									if (MinValue > value)

										MinValue = value;

									if (MaxValue < value)

										MaxValue = value;

								}

							}

						}

		     //   	}

				} catch (com.hardcode.gdbms.engine.data.driver.DriverException e) {

					// TODO Auto-generated catch block

					e.printStackTrace();

				} catch (DriverIOException e) {

					// TODO Auto-generated catch block

					e.printStackTrace();

				} catch (DriverException e) {

					// TODO Auto-generated catch block

					e.printStackTrace();

				}

			}	            

		}

        legend = LegendFactory.createVectorialIntervalLegend(FShape.POINT);

		legend.clear();

		legend.setFieldName(filtername);

        // Creamos el primer y ?ltimo color.

        Color startColor = new Color(0,0,0);

        Color endColor = new Color(230,230,230);

       	arrayIntervalos = calculateEqualIntervals(100, MinValue, MaxValue, filtername);	                 

        FInterval elIntervalo;

        NumberFormat.getInstance().setMaximumFractionDigits(2);

        int r;

        int g;

        int b;

        int stepR;

        int stepG;

        int stepB;

        r = startColor.getRed();

        g = startColor.getGreen();

        b = startColor.getBlue();

        stepR = (endColor.getRed() - r) / arrayIntervalos.length;

        stepG = (endColor.getGreen() - g) / arrayIntervalos.length;

        stepB = (endColor.getBlue() - b) / arrayIntervalos.length;

        for (int k = 0; k < arrayIntervalos.length; k++) {

            elIntervalo = arrayIntervalos[k];

            Color c = new Color(r, g, b);

            //si no esta creado el simbolo se crea

            myDefaultSymbol = new FSymbol(FShape.POINT, c);

            myDefaultSymbol.setDescription(NumberFormat.getInstance().format(elIntervalo.getMin()) +

                " - " +

                NumberFormat.getInstance().format(elIntervalo.getMax()));

          //  myDefaultSymbol.setStyle(FConstant.SYMBOL_STYLE_MARKER_CIRCLE);

            myDefaultSymbol.setSize(3);

            myDefaultSymbol.setSizeInPixels(true);

            //////////////////////////////////////

            // CALCULAMOS UN COLOR APROPIADO

            r = r + stepR;

            g = g + stepG;

            b = b + stepB;

            /////////////////////////////////

            legend.addSymbol(elIntervalo, myDefaultSymbol);

        }

        // le asignamos la leyenda a todas las capas lidar

		try {

			VectorialIntervalLegend cloneLegend = (VectorialIntervalLegend) legend.cloneLegend();

			layers = mapContext.getLayers();

			aplyLegend(layers,cloneLegend, mapContext);

		} catch (XMLException e) {

			// TODO Auto-generated catch block

			e.printStackTrace();

		}  	

	}

	 /**

     * EQUAL INTERVAL Devuelve un Array con el n?mero de intervalos que se

     * quieren crear. Los intervalos se crean con un tama?o igual entre ellos.

     *

     * @param numIntervals n?mero de intervalos

     * @param minValue Valor m?nimo.

     * @param maxValue Valor m?ximo.

     * @param fieldName Nombre del campo

     *

     * @return Array con los intervalos.

     * @see com.iver.cit.gvsig.project.documents.view.legend.gui;

     */

	   public static FInterval[] calculateEqualIntervals(int numIntervals, double minValue,

        double maxValue, String fieldName) {

        FInterval[] theIntervalArray = new FInterval[numIntervals];

        double step = (maxValue - minValue) / numIntervals;

        if (numIntervals > 1) {

            theIntervalArray[0] = new FInterval(minValue, minValue + step);

            for (int i = 1; i < (numIntervals - 1); i++) {

                theIntervalArray[i] = new FInterval(minValue + (i * step) +

                        0.01, minValue + ((i + 1) * step));

            }

            theIntervalArray[numIntervals - 1] = new FInterval(minValue +

                    ((numIntervals - 1) * step) + 0.01, maxValue);

        } else {

            theIntervalArray[0] = new FInterval(minValue, maxValue);

        }

        return theIntervalArray;

    }

    /**

     * Set a new Symbol with a name and color.

     * 

     * @param nameSymbol name of symbol

     * @param c color of symbol

     * @return the symbol with name and color predefined

     */

	   private FSymbol setSymbol(String nameSymbol, Color c) {

    	FSymbol mySymbol;

    	mySymbol = new FSymbol(FShape.POINT, c);

    	mySymbol.setDescription(nameSymbol);	    

    	mySymbol.setSize(3);

    	mySymbol.setSizeInPixels(true);

    	return mySymbol;

    }

	public boolean isEnabled() {

		com.iver.andami.ui.mdiManager.IWindow f = PluginServices.getMDIManager()

		.getActiveWindow();

		if (f == null) {

			return false;

		}

		if (f instanceof View) {

			View vista = (View) f;

			IProjectView model = vista.getModel();

			FLayers layers =  model.getMapContext().getLayers();

			layers = extractLayers(layers, model.getMapContext());

			int numLayers = layers.getLayersCount();

			for(int i = 0; i < numLayers; i++){

				FLayer layer = layers.getLayer(i);

				if(LiDARDriver.isLidarLayer(layer) && layer.isAvailable())

					return true;

			}

		}

		return false;

	}

	public boolean isVisible() {

		com.iver.andami.ui.mdiManager.IWindow f = PluginServices.getMDIManager()

		 .getActiveWindow();

		if (f == null) {

		    return false;

		}

		if (f instanceof View) {

		    View vista = (View) f;

		    IProjectView model = vista.getModel();

		    setLidarListener(vista);

		    FLayers layers =  model.getMapContext().getLayers();

		    //   layers = extractLayers(layers, model.getMapContext());

		    int numLayers = layers.getLayersCount();

		    for(int i = 0; i < numLayers; i++){

		    	FLayer layer = layers.getLayer(i);

		    	if(LiDARDriver.isLidarLayer(layer)) {

		    //		return true;

		    	}

		    }

		    return false;

		}

		return false;

	}

	/**

	 * Nos registramos como escucha de los mapcontext del MapOverview

	 * y del MapControl para que nos avisen cuando se a?ade una capa.

	 * Si es de tipo Lidar, le cambiamos la estregia.

	 * @param vista

	 */

		private void setLidarListener(View vista) {

		FLayers layers = vista.getMapControl().getMapContext().getLayers();

		layers.addLayerCollectionListener(LidarWatcher.getInstance());

	}

	/**

	 * Lee la leyenda del fichero file y devuelve la leyenda cargada.

	 * 

	 * @param file, fichero donde buscar la leyenda

	 * @return la leyenda leida.

	 */

		public Legend readLegend(File file) {

		Legend renderer = null;

		File xmlFile = new File(file.getAbsolutePath());

		try {

			String encoding = XMLEncodingUtils.getEncoding(new FileInputStream(xmlFile));

			InputStreamReader reader=null;

			if (encoding!=null) {

				try {

					reader = new InputStreamReader(new FileInputStream(xmlFile), encoding);

					renderer= readLegend(reader, true);

				} catch (UnsupportedEncodingException e) {

					reader = new InputStreamReader(new FileInputStream(xmlFile),"ISO-8859-1");

					try {

						renderer= readLegend(reader, false);

					} catch (UnsupportedEncodingException e1) {

						JOptionPane.showMessageDialog((Component)PluginServices.getMainFrame(),PluginServices.getText(this, e1.getLocalizedMessage()));

						return null;

					}

				}

			}

			else {

				reader = new InputStreamReader(new FileInputStream(xmlFile),"UTF-8");

				try {

					renderer= readLegend(reader, false);

				} catch (UnsupportedEncodingException e1) {

					JOptionPane.showMessageDialog((Component)PluginServices.getMainFrame(),PluginServices.getText(this, e1.getLocalizedMessage()));

					return null;

				}

			}

		} catch (FileNotFoundException e) {

			JOptionPane.showMessageDialog((Component)PluginServices.getMainFrame(),PluginServices.getText(this, "fichero_incorrecto"));

			return null;

		} catch (UnsupportedEncodingException e) {

			e.printStackTrace();

		}

		return renderer;

	}

	public Legend readLegend(Reader reader, boolean encodingFollowed) throws UnsupportedEncodingException {

		Legend legend = null;

		try {

			XmlTag tag = (XmlTag) XmlTag.unmarshal(reader);

			XMLEntity xml=new XMLEntity(tag);

			if (encodingFollowed) {

				if (xml.contains("followHeaderEncoding")) {

					boolean useEncoding = xml.getBooleanProperty("followHeaderEncoding");

					if (!useEncoding) {

						throw new UnsupportedEncodingException("the encoding specified in the xml header is not safe");

					}

				}

				else {

					// Old projects didn't contain followHeaderEncoding and they were

					// not correctly encoded. We throw an exception now, and we'll try

					// to reopen the project

					// using the default system encoding.

					throw new UnsupportedEncodingException("the encoding specified in the xml header is not safe");

				}

			}

			legend = LegendFactory.createFromXML(xml);

			return legend;

		}  catch (ValidationException e) {

			PluginServices.getLogger().error(PluginServices.getText(this, "formato_incorrecto"),e);

			JOptionPane.showMessageDialog((Component)PluginServices.getMainFrame(),PluginServices.getText(this, "formato_incorrecto"));

			//NotificationManager.addError("Al leer el proyecto", e);

		} catch (XMLException e) {

			PluginServices.getLogger().error(PluginServices.getText(this, "formato_incorrecto"),e);

			JOptionPane.showMessageDialog((Component)PluginServices.getMainFrame(),PluginServices.getText(this, "formato_incorrecto"));

			//NotificationManager.addError("Al leer el proyecto", e);

		} catch (org.exolab.castor.xml.MarshalException e) {

			// TODO Auto-generated catch block

			e.printStackTrace();

		}

		return null;

	}

	/**

	 * Usada para recuperar las preferencias Lidar

	 */

	public IPreference getPreferencesPage() {

		return thePreferencePage;

	}

}