Application: gvSIG desktop

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.setVertexColor(0, color);

                p.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;

        }

}