Application: gvSIG desktop

/*

 * Created on 10-feb-2005

 *

 * gvSIG. Sistema de Informaci?n Geogr?fica de la Generalitat Valenciana

 *

 * Copyright (C) 2004 IVER T.I. and Generalitat Valenciana.

 *

 * 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.

 *

 * For more information, contact:

 *

 *  Generalitat Valenciana

 *   Conselleria d'Infraestructures i Transport

 *   Av. Blasco Ib??ez, 50

 *   46010 VALENCIA

 *   SPAIN

 *

 *      +34 963862235

 *   gvsig@gva.es

 *      www.gvsig.gva.es

 *

 *    or

 *

 *   IVER T.I. S.A

 *   Salamanca 50

 *   46005 Valencia

 *   Spain

 *

 *   +34 963163400

 *   dac@iver.es

 */

package com.iver.cit.gvsig.fmap.edition.cad;

import com.vividsolutions.jts.algorithm.RobustCGAlgorithms;

import com.vividsolutions.jts.geom.Coordinate;

import java.awt.geom.Arc2D;

import java.awt.geom.Point2D;

import java.awt.geom.Rectangle2D;

/**

 * Funciones de utilidad relacionadas con trigonometr?a

 */

public class TrigonometricalFunctions {

        /**

         * Obtiene un par de puntos que definen la recta perpendicular a

         * p1-p2 que pasa por el punto perp

         *

         * @param p1 punto de la recta p1-p2

         * @param p2 punto de la recta p1-p2

         * @param perp Punto por el que pasa la recta perpendicular

         *

         * @return Array con dos puntos que definen la recta resultante

         */

        public static Point2D[] getPerpendicular(Point2D p1, Point2D p2,

                Point2D perp) {

                //Pendiente de la recta perpendicular

                double m = (p1.getX() - p2.getX()) / (p2.getY() - p1.getY());

                //b de la funcion de la recta perpendicular

                double b = p2.getY() -

                        (m * ((perp.getX() - p2.getX()) / (p2.getY() - perp.getY())));

                //Obtenemos un par de puntos

                Point2D[] res = new Point2D[2];

                res[0] = new Point2D.Double(0, (m * 0) + b);

                res[1] = new Point2D.Double(1, (m * 1) + b);

                return res;

        }

        /**

         * Obtiene un arco a partir de 3 puntos. Devuelve null si no se puede crear

         * el arco porque los puntos est?n alineados

         *

         * @param p1

         * @param p2

         * @param p3

         *

         * @return Arco

         */

        public static Arc2D createArc(Point2D p1, Point2D p2, Point2D p3) {

                Coordinate[] coords = new Coordinate[4];

                coords[0] = new Coordinate(p1.getX(), p1.getY());

                coords[1] = new Coordinate(p2.getX(), p2.getY());

                coords[2] = new Coordinate(p3.getX(), p3.getY());

                coords[3] = new Coordinate(p1.getX(), p1.getY());

                Point2D center = getCircleCenter(p1, p2, p3);

                double angle1 = getAngle(center, p1);

                double angle2 = getAngle(center, p3);

                double extent = angleDistance(angle1, angle2);

                if (!RobustCGAlgorithms.isCCW(coords)) {

                        extent = (Math.PI * 2) - extent;

                } else {

                        extent = -extent;

                }

                System.err.println("angle1:" + angle1);

                System.err.println("angle2:" + getAngle(center, p2));

                System.err.println("angle3:" + angle2);

                System.err.println("extent:" + extent);

                double Radio = p1.distance(center);

                double xR = center.getX() - Radio;

                double yR = center.getY() - Radio;

                double w = 2.0 * Radio;

                double h = w;

                Rectangle2D.Double rBounds = new Rectangle2D.Double(xR, yR, w, h);

                Arc2D.Double resul = new Arc2D.Double(rBounds,

                                Math.toDegrees((Math.PI * 2) - angle1), Math.toDegrees(extent),

                                Arc2D.OPEN);

                return resul;

        }

        /**

         * Obtiene el punto que se encuentra a una distancia 'dist' de la recta

         * p1-p2 y se encuentra en la recta perpendicular que pasa por perpPoint

         *

         * @param p1 Punto de la recta p1-p2

         * @param p2 Punto de la recta p1-p2

         * @param perpPoint Punto de la recta perpendicular

         * @param dist Distancia del punto que se quiere obtener a la recta p1-p2

         *

         * @return DOCUMENT ME!

         */

        public static Point2D getPerpendicularPoint(Point2D p1, Point2D p2,

                Point2D perpPoint, double dist) {

                return null;

        }

        /**

         * Obtiene el centro del circulo que pasa por los puntos p1, p2 y p3

         *

         * @param p1

         * @param p2

         * @param p3

         *

         * @return Devuelve el punto o null si no hay ning?n c?rculo (puntos

         *                    alineados)

         */

        public static Point2D getCircleCenter(Point2D p1, Point2D p2, Point2D p3) {

                double xC;

                double yC;

                double w;

                double h;

                // Calculamos 2 secantes, tiramos perpendiculares por sus puntos

                // medios y obtenemos el centro. Luego calculamos el radio.

                // Puntos medios de los segmentos.

                double xm1;

                // Calculamos 2 secantes, tiramos perpendiculares por sus puntos

                // medios y obtenemos el centro. Luego calculamos el radio.

                // Puntos medios de los segmentos.

                double ym1;

                // Calculamos 2 secantes, tiramos perpendiculares por sus puntos

                // medios y obtenemos el centro. Luego calculamos el radio.

                // Puntos medios de los segmentos.

                double xm2;

                // Calculamos 2 secantes, tiramos perpendiculares por sus puntos

                // medios y obtenemos el centro. Luego calculamos el radio.

                // Puntos medios de los segmentos.

                double ym2;

                xm1 = (p1.getX() + p2.getX()) / 2.0;

                ym1 = (p1.getY() + p2.getY()) / 2.0;

                xm2 = (p2.getX() + p3.getX()) / 2.0;

                ym2 = (p2.getY() + p3.getY()) / 2.0;

                /* g.setColor(Color.GRAY);

                   g.draw3DRect((int)xm1, (int) ym1, 1, 1, true);

                   g.draw3DRect((int)xm2, (int) ym2, 1, 1, true); */

                // Pendientes de las perpendiculares y constantes       

                double mP1 = 0;

                /* g.setColor(Color.GRAY);

                   g.draw3DRect((int)xm1, (int) ym1, 1, 1, true);

                   g.draw3DRect((int)xm2, (int) ym2, 1, 1, true); */

                // Pendientes de las perpendiculares y constantes       

                double mP2 = 0;

                /* g.setColor(Color.GRAY);

                   g.draw3DRect((int)xm1, (int) ym1, 1, 1, true);

                   g.draw3DRect((int)xm2, (int) ym2, 1, 1, true); */

                // Pendientes de las perpendiculares y constantes       

                double A1;

                /* g.setColor(Color.GRAY);

                   g.draw3DRect((int)xm1, (int) ym1, 1, 1, true);

                   g.draw3DRect((int)xm2, (int) ym2, 1, 1, true); */

                // Pendientes de las perpendiculares y constantes       

                double A2;

                boolean bPerp1 = false;

                boolean bPerp2 = false;

                if ((p2.getY() - p1.getY()) == 0) {

                        A1 = ym1;

                        bPerp1 = true;

                } else {

                        mP1 = (p2.getX() - p1.getX()) / (p1.getY() - p2.getY());

                        A1 = ym1 - (xm1 * mP1);

                }

                if ((p2.getY() - p3.getY()) == 0) {

                        A2 = ym2;

                        bPerp2 = true;

                } else {

                        mP2 = (p3.getX() - p2.getX()) / (p2.getY() - p3.getY());

                        A2 = ym2 - (xm2 * mP2);

                }

                if (mP2 == mP1) {

                        return null; // Error, 3 puntos alineados. No puede pasar un arco

                } else {

                        xC = (A2 - A1) / (mP1 - mP2);

                        if (!bPerp1) {

                                yC = (xC * mP1) + A1;

                        } else {

                                yC = (xC * mP2) + A2;

                        }

                }

                return new Point2D.Double(xC, yC);

        }

        /**

         * Obtiene un c?rculo a partir de 3 puntos. Devuelve null si no se puede

         * crear el c?ruclo porque los puntos est?n alineados

         *

         * @param p1

         * @param p2

         * @param p3

         *

         * @return C?rculo

         */

        static public Arc2D createCircle(Point2D p1, Point2D p2, Point2D p3) //, Graphics g)

         {

                Point2D center = getCircleCenter(p1, p2, p3);

                double Radio = p1.distance(center);

                double xR = center.getX() - Radio;

                double yR = center.getY() - Radio;

                double w = 2.0 * Radio;

                double h = w;

                Rectangle2D.Double rBounds = new Rectangle2D.Double(xR, yR, w, h);

                Arc2D.Double resul = new Arc2D.Double(rBounds, 0.0, 360.0, Arc2D.OPEN);

                return resul;

        }

        /**

         * Obtiene el ?ngulo del vector que se pasa como par?metro con el vector

         * horizontal de izquierda a derecha

         *

         * @param start punto origen del vector

         * @param end punto destino del vector

         *

         * @return angulo en radianes

         */

        public static double getAngle(Point2D start, Point2D end) {

                double angle = Math.acos((end.getX() - start.getX()) / start.distance(

                                        end));

                if (start.getY() > end.getY()) {

                        angle = -angle;

                }

                if (angle < 0) {

                        angle += (2 * Math.PI);

                }

                return angle;

        }

        /**

         * Devuelve la distancia desde angle1 a angle2

         *

         * @param angle1 angulo en radianes. Debe ser positivo y no dar ninguna

         *                   vuelta a la circunferencia

         * @param angle2 angulo en radianes. Debe ser positivo y no dar ninguna

         *                   vuelta a la circunferencia

         *

         * @return distancia entre los ?ngulos

         */

        public static double angleDistance(double angle1, double angle2) {

                if (angle1 < angle2) {

                        return angle2 - angle1;

                } else {

                        return ((Math.PI * 2) - angle1) + angle2;

                }

        }

}