Application: gvSIG desktop

/* jdwglib. Java Library for reading Dwg files.

 * 

 * Author: Jose Morell Rama (jose.morell@gmail.com).

 * Port from the Pythoncad Dwg library by Art Haas.

 *

 * Copyright (C) 2005 Jose Morell, IVER TI S.A. 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:

 *

 * Jose Morell (jose.morell@gmail.com)

 * 

 * or

 *

 * IVER TI S.A.

 *  C/Salamanca, 50

 *  46005 Valencia

 *  Spain

 *  +34 963163400

 *  dac@iver.es

 */

package com.iver.cit.jdwglib.util;

import java.lang.Math;

/**

 * This class allows to apply the extrusion transformation of Autocad given by an array

 * of doubles to a point given by an array of doubles too. The result of this

 * transformation is a Point2D 

 * 

 * @author jmorell

 */

public class AcadExtrusionCalculator {

        final static double[] WY = new double[]{0,1,0};

        final static double[] WZ = new double[]{0,0,1};

        final static double MINLENGHT = 1d/64d;

        /*

         * http://personales.unican.es/togoresr/Sco-en.html

         * http://www.autodesk.com/techpubs/autocad/acadr14/dxf/object_coordinate_systems_40ocs41_al_u05_c.htm

         * http://www.autodesk.com/techpubs/autocad/acadr14/dxf/arbitrary_axis_algorithm_al_u05_c.htm

         * http://vis.cs.brown.edu/resources/doc/gluebase-2.0/vector3d_8H-source.html

         * */

        public static double[] extrude(double[] coordToExtrude, double[] extrusionVector){

                double[] solution = null;

                double[] ax = null;

                double[] ay = null;

                double normalLenght = length(extrusionVector);

                if( (Math.abs(extrusionVector[0]) > MINLENGHT) && (Math.abs(extrusionVector[1]) > MINLENGHT)){

                        ax = crossProduct(WY, extrusionVector);

                }else{

                        ax = crossProduct(WZ, extrusionVector);

                }

                ax = makeUnitary(ax);

                ay = crossProduct(extrusionVector, ax);

                ay = makeUnitary(ay);

                //Llegados a este punto, tenemos tres vectores unitarios

                double x = ax[0] * coordToExtrude[0] + ay[0] * coordToExtrude[1] + extrusionVector[0] * coordToExtrude[2];

                double y = ax[1] * coordToExtrude[0] + ay[1] * coordToExtrude[1] + extrusionVector[1] * coordToExtrude[2];

                double z = ax[2] * coordToExtrude[0] + ay[2] * coordToExtrude[1] + extrusionVector[2] * coordToExtrude[2];

                solution = new double[]{x, y, z};

                return solution;

        }

        public static double[] crossProduct(double[] a, double[] b){

                return new double[]{ a[1] * b[2] - a[2] * b[1], 

                                                        a[2] * b[0] - a[0] * b[2],

                                                        a[0] * b[1] - a[1] * b[0]};

        }

        public static double[] makeUnitary(double[] vector){

                double[] solution = null;

                double vectorLenght = length(vector);

                double x = vector[0] / vectorLenght;

                double y = vector[1] / vectorLenght;

                double z = vector[2] / vectorLenght;

                solution = new double[]{x, y, z};

                return solution;

        }

        public static double length(double[] vector){

                return Math.sqrt( (vector[0] * vector[0]) + 

                                (vector[1] * vector[1]) + 

                                (vector[2] * vector[2]));

        }

    /**

     * Method that allows to apply the extrusion transformation of Autocad

     * 

     * @param coord_in Array of doubles that represents the input coordinates

     * @param xtru array of doubles that contanins the extrusion parameters

     * @return double[] Is the result of the application of the extrusion transformation

     *                    to the input point

     */

        public static double[] extrude2(double[] coord_in, double[] xtru) {

                double[] coord_out;

        double dxt0 = 0D, dyt0 = 0D, dzt0 = 0D;

        double dvx1, dvx2, dvx3;

        double dvy1, dvy2, dvy3;

        double dmod, dxt, dyt, dzt;

        double aux = 1D/64D;

        double aux1 = Math.abs(xtru[0]);

        double aux2 = Math.abs(xtru[1]);

        dxt0 = coord_in[0];

        dyt0 = coord_in[1];

        dzt0 = coord_in[2];

        double xtruX, xtruY, xtruZ;

        xtruX = xtru[0];

        xtruY = xtru[1];

        xtruZ = xtru[2];

        if ((aux1 < aux) && (aux2 < aux)) {

            dmod = Math.sqrt(xtruZ*xtruZ + xtruX*xtruX);

            dvx1 = xtruZ / dmod;

            dvx2 = 0;

            dvx3 = -xtruX / dmod;

        } else {

            dmod = Math.sqrt(xtruY*xtruY + xtruX*xtruX);

            dvx1 = -xtruY / dmod;

            dvx2 = xtruX / dmod;

            dvx3 = 0;

        }

        dvy1 = xtruY*dvx3 - xtruZ*dvx2;

        dvy2 = xtruZ*dvx1 - xtruX*dvx3;

        dvy3 = xtruX*dvx2 - xtruY*dvx1;

        dmod = Math.sqrt(dvy1*dvy1 + dvy2*dvy2 + dvy3*dvy3);

        dvy1 = dvy1 / dmod;

        dvy2 = dvy2 / dmod;

        dvy3 = dvy3 / dmod;

        dxt = dvx1*dxt0 + dvy1*dyt0 + xtruX*dzt0;

        dyt = dvx2*dxt0 + dvy2*dyt0 + xtruY*dzt0;

        dzt = dvx3*dxt0 + dvy3*dyt0 + xtruZ*dzt0;

        coord_out = new double[]{dxt, dyt, dzt};

        dxt0 = 0;

        dyt0 = 0;

        dzt0 = 0;

                return coord_out;

        }

        public final Matrix4D calcArbitMat(double[] extrusion, double[] coord)

    {

        Vector3D row1 = null;

        if(extrusion[0] == 0d && extrusion[1] == 0d && extrusion[2] > 0d && coord[2] == 0d)

                return null;

        if((extrusion[0] >= 0f ? extrusion[0]:-extrusion[0]) < 0.015625F

                        &&

            (extrusion[1] >= 0f ? extrusion[1]:-extrusion[1]) < 0.015625F)){

                 row1 = new Vector3D(extrusion[2], 0f, -extrusion[0]);

         }else{

                 row1 = new Vector3D(-extrusion[1],extrusion[0], 0f);

         }

        float len = row1.length();

        row1.scale(1.0F / len);

        Vector3D upward = new Vector3D(extrusion[0], extrusion[1], extrusion[2]);

        Vector3D row2 = upward.cross(row1);

//        Matrix4D aaa = new Matrix4D(row1.x, row2.x, upward.x, 

//                                                                height * upward.x, row1.y, row2.y,

//                                                                 upward.y, height * upward.y, row1.z, 

//                                                                 row2.z, upward.z, height * upward.z, 

//                                                                 0.0F, 0.0F, 0.0F, 1.0F);

        //se asume que coord[2] es la altura (height), pero en DXF

        //la altura podia venir dada por el code 30 y poer el 38

                          Matrix4D aaa = new Matrix4D(row1.x, row2.x, upward.x, 

                                                                coord[2] * upward.x, row1.y, row2.y,

                                                                 upward.y, coord[2] * upward.y, row1.z, 

                                                                 row2.z, upward.z, coord[2] * upward.z, 

                                                                 0.0F, 0.0F, 0.0F, 1.0F);

        return aaa;

    }

        /*

   llamamos a finalConv, y este llama a extrude internamente

    static DrawAble finalConv(DrawAble dl, DxfEntity entity, boolean doTransform)

    {

        if(dl == null)

            return null;

        DrawAble dr;

        if(doTransform)

        {

            if(entity.getExtrusion() != 0.0F)

                dr = dl.extrude(entity.getExtrusion());

            else

                dr = dl;

            Matrix4D mat = entity.calcArbitMat();

            if(mat != null)

                dr.transformBy(mat);

        } else

        if(entity.getExtrusion() != 0.0F)

            dr = dl.extrude(entity.getExtrusion(), entity.getUpwardVector());

        else

            dr = dl;

        return dr;

    }

     public DrawAble extrude(float dist, Vector3D up)

    {

        if(dist == 0.0F)

            return this;

        Vector3D ex = new Vector3D(dist * up.x, dist * up.y, dist * up.z);

        DrawSet set = new DrawSet(2 + nrPoints);

        DrawLines second = new DrawLines(nrPoints);

        set.setLayer(super.layer);

        set.setColor(super.color);

        second.setLayer(super.layer);

        second.setColor(super.color);

        set.addDrawable(this);

        for(int i = 0; i < nrPoints; i++)

        {

            second.addPoint(line[i].x + ex.x, line[i].y + ex.y, line[i].z + ex.z);

            DrawLines conn = new DrawLines(2);

            conn.setLayer(super.layer);

            conn.setColor(super.color);

            conn.addPoint(line[i]);

            conn.addPoint(second.line[i]);

            set.addDrawable(conn);

        }

        if(isClosed)

            second.close();

        set.addDrawable(second);

        return set;

    }

*/

}