Application: gvSIG desktop

import es.upv.ai2.libjosg.planets.PlanetViewer;

package com.iver.ai2.gvsig3d.gui;

import java.awt.Color;

import java.util.HashMap;

import java.util.Iterator;

import java.util.List;

import com.iver.ai2.gvsig3d.resources.ResourcesFactory;

import com.iver.ai2.gvsig3d.utils.Punto3D;

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

import es.upv.ai2.libjosg.AutoTransform;

import es.upv.ai2.libjosg.Group;

import es.upv.ai2.libjosg.Node;

import es.upv.ai2.libjosg.Optimizer;

import es.upv.ai2.libjosg.Vec3;

import es.upv.ai2.libjosg.Vec4;

import es.upv.ai2.libjosg.Optimizer.OptimizationOptions;

import es.upv.ai2.libjosg.features.PixelPoint;

import es.upv.ai2.libjosg.features.Polygon;

import es.upv.ai2.libjosg.features.Polyline;

import es.upv.ai2.libjosg.features.TessellablePolygon;

import es.upv.ai2.libjosg.features.Text;

import es.upv.ai2.libjosg.planets.Planet;

import es.upv.ai2.libjosg.planets.Planet.PlanetType;

public class FeatureFactory extends Group {

	private static double radius;

	static Planet planet;

	public FeatureFactory(double ra, Planet m_planet) {

		super();

		radius = ra;

		// this.setNodeName("VECTOR");

		planet = m_planet;

		init();

	}

	private void init() {

		// this.addChild(insertTexto("Polo norte", poloNorte));

		// this.addChild(insertTexto("MADRID", valenciaCar));

		// Vec3 posIni = new Vec3(0, 0, 0);

		// Vec3 posEnd = new Vec3(0, 0, 100000);

		// Polyline line = (Polyline) VectorTest.insertLineS(posIni, posEnd,

		// new Vec4(1.0, 1.0, 1.0, 1.0), 0);

		// if (planet.getType() == PlanetType.PLANE_MODE)

		// this.addChild(line);

	}

	// public Node insertTexto(String texto, Vec3 posicion) {

	// // A?adiendo texto

	// Text text = new Text();

	// // text.setNodeName(texto);

	// text.setText(texto);

	// text.setCharacterSize(32);

	//

	// text.setAxisAlignment(Text.AxisAlignment.SCREEN);

	// text.setAlignment(Text.AlignmentType.CENTER_CENTER);

	// text.setCharacterSizeMode(Text.CharacterSizeMode.SCREEN_COORDS);

	// text.setPosition((float) posicion.x(), (float) posicion.y(),

	// (float) posicion.z());

	//

	// if (ResourcesFactory.exitsResouce("arial.ttf"))

	// text.setFont(ResourcesFactory.getResourcePath("arial.ttf"));

	// else

	// text.setFont("arial.ttf");

	// text.setAutoRotateToScreen(true);

	//		

	//		

	// Optimizer opt = new Optimizer();

	// opt.optimizeOptions(text, OptimizationOptions.SPATIALIZE_GROUPS);

	//		

	// return text;

	// }

	// /**

	// * this method create a new 3D text. With a value and position. And insert

	// a

	// * point under 3D text

	// *

	// * @param texto

	// * text that is visible in 3D

	// * @param position

	// * Position of 3D text in cartesian coordinates

	// * @return New node

	// */

	// public void insertText(String texto, Vec3 posicion) {

	// posicion.setZ(posicion.z() + radius);

	// Vec3 e = planet.convertLatLongHeightToXYZ(posicion);

	//

	// this.addChild(insertPoint(e, new Vec4(1.0, 0, 0, 1.0)));

	//

	// this.addChild(insertTexto(texto, e));

	// }

	//

	// /**

	// * this method create a new 3D point. With a color and position

	// *

	// * @param color

	// * Color of the point

	// * @param position

	// * Position of 3D point in cartesian coordinates

	// * @return

	// */

	// public Node insertPoint(Vec3 position, Vec4 color) {

	// // Creating point

	// Point p = new Point();

	//

	// // Adding position and color

	// for (int i = 0; i < 1; i++) {

	// p.setPointSize(100);

	// p.addPoint(position, color);

	// }

	//

	// return p;

	// }

	/**

	 * Method to create a new 3D text. With a value and position. Text aligment

	 * is LEFT CENTER, and his font is "Arial.ttf"

	 * 

	 * @param texto

	 *            Text that is visible in 3D

	 * @param position

	 *            Position of 3D text in cartesian coordinates

	 * @return New node

	 */

	public static Node insertTextoS(String texto, Vec3 position, Vec4 color,

			int tam, boolean inPixels) {

		// Creating text node

		Text text = new Text();

		// Set up text properties

		text.setText(texto);

		text.setCharacterSize(tam);

		// Select that the text will be in pixels or screen coordinates

		if (inPixels) {

			text.setCharacterSizeMode(Text.CharacterSizeMode.SCREEN_COORDS);

		} else {

			text.setCharacterSizeMode(Text.CharacterSizeMode.OBJECT_COORDS);

		}

		text.setColor(color);

		text.setAxisAlignment(Text.AxisAlignment.SCREEN);

		text.setAlignment(Text.AlignmentType.LEFT_BOTTOM);

		text.setPosition((float) position.x(), (float) position.y(),

				(float) position.z());

		// Search font in resources directori

		if (ResourcesFactory.exitsResouce("arial.ttf"))

			text.setFont(ResourcesFactory.getResourcePath("arial.ttf"));

		else

			text.setFont("arial.ttf");

		text.setAutoRotateToScreen(true);

		// Optimizer generated nodes

		Optimizer opt = new Optimizer();

		opt.optimize(text, OptimizationOptions.SPATIALIZE_GROUPS);

		// Return node

		return text;

	}

	/**

	 * Method to create a new 3D point. With a color, heigth and position.

	 * 

	 * @param position

	 *            Position of 3D text in cartesian coordinates

	 * @param color

	 *            color of the 3D point

	 * @param tam

	 *            the heigth of the point

	 * @return New text node

	 */

	public static Node insertPointS(Vec3 position, Vec4 color, int tam) {

		AutoTransform au = new AutoTransform();

		// Creating point

		PixelPoint p = new PixelPoint();

		// p.setDistanceAttenuation(new Vec3(0.0,0.0,0.0000001));

		p.setPointSize(tam);

		p.addPoint(position, color);

		au.addChild(p);

		// return au;

		return p;

	}

	/**

	 * Method to create a new 3D point. With a color, heigth and position.

	 * 

	 * @param hash

	 *            Hash Table that contains "Puntos3D" elements

	 * @return

	 */

	public static Node insertPointS(HashMap hash) {

		Group g = new Group();

		// Iterate over the keys in the map

		Iterator it = hash.keySet().iterator();

		while (it.hasNext()) {

			// Get key

			Integer key = (Integer) it.next();

			List list = (List) hash.get(key);

			PixelPoint p = new PixelPoint();

			for (Iterator iter = list.iterator(); iter.hasNext();) {

				// Getting PixelPoint

				Punto3D element = (Punto3D) iter.next();

				Vec4 color = element.getColor();

				// Blending only is active if the alpha component are diferent

				// that 1

				if (color.w() != 1) {

					p.setEnabledBlending(true);

				}

				// Enabling antialiasing

				p.setEnabledSmoothing(true);

				// Set up size, position and color

				p.setPointSize(element.getZize());

				p.addPoint(element.getPosition(), color);

			}

			// Adding points to group

			g.addChild(p);

		}

		// Optimizer generated nodes

		Optimizer opt = new Optimizer();

		opt.optimize(g, OptimizationOptions.SPATIALIZE_GROUPS);

		return g;

	}

	/**

	 * Method to add 3D points to specific point type. With a color, heigth and

	 * position.

	 * 

	 * @param point

	 *            Node to add new 3D point

	 * @param position

	 *            Position of 3D text in cartesian coordinates

	 * @param color

	 *            color of the 3D point

	 * @param tam

	 *            the heigth of the point

	 * @return New text node

	 */

	public static void addNodeToPoint(Node point, Vec3 position, Vec4 color,

			int tam) {

		PixelPoint p = null;

		// Getting point

		if (point != null)

			p = (PixelPoint) point;

		// If not exits create new

		if (p == null)

			p = new PixelPoint();

		// Blending only is active if the alpha component are diferent that 1

		if (color.w() != 1) {

			p.setEnabledBlending(true);

		}

		// Set up size, position and color

		p.setPointSize(tam);

		p.addPoint(position, color);

		// Optimizer generated nodes

		Optimizer opt = new Optimizer();

		opt.optimize(p, OptimizationOptions.SPATIALIZE_GROUPS);

	}

	/**

	 * Method to create a new 3D line. With a color, heigth and position.

	 * 

	 * @param ini

	 *            Initial position of line

	 * @param end

	 *            End positon of line.

	 * @param color

	 *            color of the 3D point

	 * @param tam

	 *            the heigth of the point

	 * @return New line node

	 */

	public static Node insertLineS(Vec3 ini, Vec3 end, Vec4 color, int tam) {

		// Creating a polyline

		Polyline p = new Polyline(ini, end);

		// Set up parameter

		p.setWidth(2f);

		p.setPattern((short) 0xFFFF);

		p.setFactor(2);

		p.setColor(color);

		// Optimize the node

		Optimizer opt = new Optimizer();

		opt.optimize(p);

		// Return the node

		return p;

	}

	/**

	 * Method to add new points to specific line type. With a color, heigth and

	 * position.

	 * 

	 * @param line

	 *            Node to add new point

	 * @param position

	 *            Position of 3D point in cartesian coordinates

	 * @param color

	 *            color of the 3D point

	 * @param tam

	 *            the heigth of the point

	 */

	public static void addNodeToLine(Node line, Vec3 position, Vec4 color,

			int tam) {

		// Getting polyline

		Polyline p = (Polyline) line;

		// If not exits, create a new

		if (p == null)

			p = new Polyline(position, position);

		// Add a point and color

		p.addVertex(position, color);

	}

	/**

	 * Create a new point node with a color and size. Using a position of 3D

	 * points

	 * 

	 * @param position

	 *            Position of 3D point

	 * @param color

	 *            Color of the 3D point

	 * @param tam

	 *            Size of the point (in pixels)

	 * @return

	 */

	public static Node insertPointS(Vec3[] position, Vec4 color, int tam) {

		// Creating point node

		PixelPoint p = new PixelPoint();

		// Set up parameters and insert position

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

			p.setPointSize(tam);

			p.addPoint(position[i], color);

		}

		// Optimizer generated nodes

		Optimizer opt = new Optimizer();

		opt.optimize(p, OptimizationOptions.SPATIALIZE_GROUPS);

		// Return node

		return p;

	}

	/**

	 * Create a new tesselation poligon with a color using an array of 3D points

	 * 

	 * @param points

	 *            Array of 3D points

	 * @param color

	 *            Color of the poligon

	 * @return Poligon node

	 */

	public static Node insertPolygon(Vec3[] points, Vec4 color) {

		// Creating a polygon

		TessellablePolygon p = new TessellablePolygon();

		// Set up parameters

		// p.setType(Polygon.PolygonType.FILLED_POLYGON);

		p.setWidth(2f);

		// p.setPattern((short) 0xFFFF);

		// p.setFactor(2);

		p.setType(Polygon.PolygonType.FILLED_POLYGON);

		// p.setType(Polygon.PolygonType.EMPTY_POLYGON);

		// p.setType(Polygon.PolygonType.PATTERN_POLYGON);

		// Adding points

		for (int i = 0; i < points.length - 1; i++) {

			p.addVertex(points[i], color);

			// System.out.println("Position: " + inv[i].x() + " " + inv[i].y() +

			// " " + inv[i].z());

		}

		// Tesselation of this poligon

		p.tesselate();

		// Optimizer generated nodes

		Optimizer opt = new Optimizer();

		opt.optimize(p, OptimizationOptions.SPATIALIZE_GROUPS);

		// Return node

		return p;

	}

	/**

	 * Create a new tesselation poligon with a color using an List of 3D points

	 * 

	 * @param points

	 *            List of 3D points

	 * @param color

	 *            Color of the poligon

	 * @return Poligon node

	 */

	public static Node insertPolygon(List points, Vec4 color) {

		// Creating a polygon

		TessellablePolygon p = new TessellablePolygon();

		// Set up parameters

		// p.setType(Polygon.PolygonType.FILLED_POLYGON);

		p.setWidth(2f);

		// p.setPattern((short) 0xFFFF);

		// p.setFactor(2);

		p.setType(Polygon.PolygonType.FILLED_POLYGON);

		// p.setType(Polygon.PolygonType.EMPTY_POLYGON);

		// p.setType(Polygon.PolygonType.PATTERN_POLYGON);

		// Blending only is active if the alpha component are diferent that 1

		if (color.w() != 1) {

			p.setEnabledBlending(true);

		}

		// Adding points

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

			Vec3 element = (Vec3) points.get(i);

			p.addVertex(element, color);

		}

		// p.setTexture("C:/modelos3d/Images/land_shallow_topo_2048.jpg");

		// Tesselation of this poligon

		p.tesselate();

		// Optimizer generated nodes

		Optimizer opt = new Optimizer();

		opt.optimize(p, OptimizationOptions.ALL_OPTIMIZATIONS);

		// Return node

		return p;

	}

	/**

	 * Method to create a new 3D line. With a List of 3D points and a color

	 * 

	 * @param points

	 *            List of 3D points

	 * @param color

	 *            Color of the line

	 * @return

	 * 

	 */

	public static Node insertLine(List points, Vec4 color, float size) {

		Vec3 ori = null, fin = null;

		// Getting first points

		if (points.size() > 1) {

			ori = (Vec3) points.get(0);

			fin = (Vec3) points.get(1);

		}

		// If the line do not have more than 2 points return null

		if ((ori == null) || (fin == null))

			return null;

		// Create new polyline

		Polyline p = new Polyline(ori, fin);

		p.getEditableGeometry().setVertexColor(0, color);

		p.getEditableGeometry().setVertexColor(1, color);

		// Set up parameters

		p.setWidth(size);

		p.setPattern((short) 0xFFFF);

		p.setFactor(2);

		// Blending only is active if the alpha component are diferent that 1

		if (color.w() != 1) {

			p.setEnabledBlending(true);

		}

		// Enabling antialiasing

		p.setEnabledSmoothing(true);

		p.setColor(color);

		// Adding points

		for (int i = 2; i < points.size(); i++) {

			Vec3 element = (Vec3) points.get(i);

			p.addVertex(element, color);

		}

		// Optimizer generated nodes

		Optimizer opt = new Optimizer();

		opt.optimize(p);

		// Return node

		return p;

	}

	/**

	 * Create a new group of 3D points with a color and size. Using a List of 3D

	 * points

	 * 

	 * @param points

	 *            List of 3D points

	 * @param color

	 *            Color of the line

	 * @param size

	 *            Size of the point (in pixels)

	 * @return

	 */

	public static Node insertPoints(List points, Vec4 color, float size) {

		// Creating point

		PixelPoint p = new PixelPoint();

		// Set up parameters

		p.setPointSize(size);

		// Adding points

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

			Vec3 element = (Vec3) points.get(i);

			p.addPoint(element, color);

		}

		// Optimizer generated nodes

		Optimizer opt = new Optimizer();

		opt.optimize(p);

		// Return node

		return p;

	}

	/**

	 * Create a new group of 3D labels with a size and heigth. Using a List of

	 * 3D points

	 * 

	 * @param labels

	 *            List of Flabels

	 * 

	 * @param size

	 *            Size of the labels

	 * @param heigth

	 *            Heigth of labels

	 * @param inPixels

	 *            True indicates that size is in pixel and false indicates real

	 *            size;

	 * @param type

	 * @return Node group

	 */

	public static Node insertLabels(List labels, int size, float heigth,

			boolean inPixels, int planetType) {

		// Creating a group node

		Group p = new Group();

		// Getting total size

		int total = labels.size();

		// this is for control a max of labels because the system not suport

		// more than 10000

		int max = 3000;

		if (total > max)

			total = max;

		if (labels != null) {

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

				FLabel f = (FLabel) labels.get(i);

				// Set up parameters

				// Getting color

				// Color co = f.getColor();

				Color co = new Color(255, 255, 255, 255);

				float r, g, b, a;

				r = ((float) co.getRed()) / 255.0f;

				g = ((float) co.getGreen()) / 255.0f;

				b = ((float) co.getBlue()) / 255.0f;

				a = ((float) co.getAlpha()) / 255.0f;

				// Set color

				Vec4 textColor = new Vec4(r, g, b, a);

				// Get label name

				String label = f.getString();

				// double heigth = h;

				Vec3 pos = null;

				if (planetType == PlanetType.PLANE_MODE) {

					pos = new Vec3(f.getOrig().getX(), f.getOrig().getY(),

							heigth);

				} else {

					// Transform geodesical coordinates to cartesian

					Vec3 posGeo = new Vec3(f.getOrig().getY(), f.getOrig()

							.getX(), heigth);

					pos = planet.convertLatLongHeightToXYZ(posGeo);

				}

				// Adding new child text nodes

				p.addChild(insertTextoS(label, pos, textColor, size, inPixels));

			}

		}

		// Optimizer generated nodes

		Optimizer opt = new Optimizer();

		opt.optimize(p, OptimizationOptions.SPATIALIZE_GROUPS);

		return p;

	}

}

import es.upv.ai2.libjosg.Node;

import es.upv.ai2.libjosg.viewer.Intersections;

		Intersections hits = canvas3d.getOSGViewer().rayPick(x, y);

		if (hits.containsIntersections()) {

			// get XYZ coordinates on planet

			Vec3 hit = hits.getFirstIntersection().getIntersectionPoint();

			// convert to geo coordinates

			if (proj.getAbrev().compareToIgnoreCase("EPSG:4326") == 0) {

						(double) hit.x(), (double) hit.y(), (double) hit.x()));

			} else

				pWorld.setLocation((double) hit.x(), (double) hit.y());

			if (proj.getAbrev().compareToIgnoreCase("EPSG:4326") == 0) {

				pWorld.setLocation(360, 120);

			} else

				pWorld.setLocation(1e100, 1e100);

	/*

	 * (non-Javadoc)

	 * 

		// Scale factor

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

import es.upv.ai2.libjosg.planets.PlanetViewer;

	private PlanetViewer planetViewer;

		this.planetViewer = (PlanetViewer)m_canvas3d.getOSGViewer();

//	public void setCanvas3d(IViewerContainer m_canvas3d) {

//		this.m_canvas3d = m_canvas3d;

//		

//	}

				/**/

		planetViewer.setCamera(cam);

		GraphicLayer3D gra3D = new GraphicLayer3D(this.planetViewer, getPlanet());

		return planetViewer.getSpecialNode(0);

		if (m_canvas3d != null) 

			vp.setImageSize(new Dimension(planetViewer.getWidth(), planetViewer

import java.util.Hashtable;

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

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

			else /**/ if (layer instanceof ClassifiableVectorial) {

				if (rasterLayer.getBandCount() == 1)