# -*- coding: utf-8 -*-
#
# Copyright (C) 2007-2012  CEA/DEN, EDF R&D, OPEN CASCADE
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
# License as published by the Free Software Foundation; either
# version 2.1 of the License.
#
# This library 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
# Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public
# License along with this library; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
#
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
"""
This module is used to compute the orientation of the different parts in a
structural element and to build the corresponding markers (trihedrons).
"""

import math

from salome.kernel.logger import Logger
from salome.kernel import termcolor
logger = Logger("salome.geom.structelem.orientation", color = termcolor.RED)


class Orientation1D:
    """
    This class is used to compute the orientation of 1D elements and to build
    the corresponding markers.
    """
    
    def __init__(self):
        self.geom = None
        self._vectorYCoords = None
        self._angle = 0.0

    def __repr__(self):
        reprdict = self.__dict__.copy()
        del reprdict["geom"]
        return '%s(%s)' % (self.__class__.__name__, reprdict)

    def addParams(self, params):
        """
        Add orientation parameters. `params` is a dictionary containing one or
        several orientation parameters. The valid parameters are:

        * "VECT_Y": Triplet defining the local Y axis (the X axis is the
          main direction of the 1D element).
        * "ANGL_VRIL": Angle of rotation along the X axis to define the local
          coordinate system.
        
        The parameters can be specified several times. In this case, only the
        last "VECT_Y" or "ANGL_VRIL" is taken into account.
        """
        if self._vectorYCoords is not None or self._angle != 0.0:
            logger.warning('Orientation parameters are specified several '
                           'times for the same mesh group, only the last '
                           'parameter will be used')
        mydict = params.copy()
        if mydict.has_key("VECT_Y"):
            newVecCoords = mydict.pop("VECT_Y")
            logger.debug("Setting orientation vector Y to %s" %
                             str(newVecCoords))
            self._vectorYCoords = newVecCoords
            self._angle = 0.0
        if mydict.has_key("ANGL_VRIL"):
            newAngle = mydict.pop("ANGL_VRIL")
            logger.debug("Setting orientation angle to %f" % newAngle)
            self._angle = newAngle
            self._vectorYCoords = None
        if len(mydict) > 0:
            logger.warning("Invalid orientation parameter(s) (ignored): %s" %
                           str(mydict))

    def _getDefaultVecYZ(self, center, vecX):
        """
        Get the vectors Y and Z for the default LCS, that use the main
        direction of the 1D object as the local X axis and the global Z axis
        to determine the local Z axis.
        """
        xPoint = self.geom.MakeTranslationVector(center, vecX)
        givenVecZ = self.geom.MakeVectorDXDYDZ(0.0, 0.0, 1.0)
        angle = self.geom.GetAngleRadians(vecX, givenVecZ)
        if abs(angle) < 1e-7 or abs(angle - math.pi) < 1e-7:
            logger.warning("Beam X axis is colinear to absolute Z axis. "
                           "Absolute X axis will be used to determine "
                           "local Z axis.")
            givenVecZ = self.geom.MakeVectorDXDYDZ(1.0, 0.0, 0.0)
        zPoint = self.geom.MakeTranslationVector(center, givenVecZ)
        locPlaneZX = self.geom.MakePlaneThreePnt(center, zPoint, xPoint, 1.0)
        locY = self.geom.GetNormal(locPlaneZX)
        yPoint = self.geom.MakeTranslationVector(center, locY)
        locPlaneXY = self.geom.MakePlaneThreePnt(center, xPoint, yPoint, 1.0)
        locZ = self.geom.GetNormal(locPlaneXY)
        return (locY, locZ)

    def buildMarker(self, geom, center, vecX):
        """
        Create a marker with origin `center` and X axis `vecX`. `geom` is the
        pseudo-geompy object used to build the geometric shapes.
        """
        (locY, locZ) = self.getVecYZ(geom, center, vecX)
        marker = geom.MakeMarkerPntTwoVec(center, vecX, locY)
        return marker

    def getVecYZ(self, geom, center, vecX):
        """
        Get the vectors Y and Z for the LCS with origin `center` and X axis
        `vecX`. `geom` is the pseudo-geompy object used to build the geometric
        shapes.
        """
        self.geom = geom
        locY = None
        locZ = None
        if self._vectorYCoords is None:
            (locY, locZ) = self._getDefaultVecYZ(center, vecX)
        else:
            xPoint = self.geom.MakeTranslationVector(center, vecX)
            givenLocY = self.geom.MakeVectorDXDYDZ(self._vectorYCoords[0],
                                                   self._vectorYCoords[1],
                                                   self._vectorYCoords[2])
            angle = self.geom.GetAngleRadians(vecX, givenLocY)
            if abs(angle) < 1e-7 or abs(angle - math.pi) < 1e-7:
                logger.warning("Vector Y is colinear to the beam X axis, "
                               "using default LCS.")
                (locY, locZ) = self._getDefaultVecYZ(center, vecX)
            else:
                yPoint = self.geom.MakeTranslationVector(center, givenLocY)
                locPlaneXY = self.geom.MakePlaneThreePnt(center, xPoint,
                                                         yPoint, 1.0)
                locZ = self.geom.GetNormal(locPlaneXY)
                zPoint = self.geom.MakeTranslationVector(center, locZ)
                locPlaneZX = self.geom.MakePlaneThreePnt(center, zPoint,
                                                         xPoint, 1.0)
                locY = self.geom.GetNormal(locPlaneZX)

        if self._angle != 0.0:
            angleRad = math.radians(self._angle)
            locY = self.geom.Rotate(locY, vecX, angleRad)
            locZ = self.geom.Rotate(locZ, vecX, angleRad)

        return (locY, locZ)


class Orientation2D:
    """
    This class is used to compute the orientation of 2D elements and to build
    the corresponding markers. Angles `alpha` and `beta` are used to determine
    the local coordinate system for the 2D element. If `vect` is not
    :const:`None`, it is used instead of `alpha` and `beta`.
    """

    def __init__(self, alpha, beta, vect):
        self.geom = None
        self._alpha = alpha
        self._beta = beta
        self._vect = vect

    def __repr__(self):
        reprdict = self.__dict__.copy()
        del reprdict["geom"]
        return '%s(%s)' % (self.__class__.__name__, reprdict)

    def _buildDefaultMarker(self, center, normal, warnings = True):
        """
        Create the default marker, that use the normal vector of the 2D object
        as the local Z axis and the global X axis to determine the local X
        axis. `warnings` can be used to enable or disable the logging of
        warning messages.
        """
        marker = None
        globalVecX = self.geom.MakeVectorDXDYDZ(1.0, 0.0, 0.0)
        angle = self.geom.GetAngleRadians(normal, globalVecX)
        if abs(angle) < 1e-7 or abs(angle - math.pi) < 1e-7:
            if warnings:
                logger.warning("Face normal is colinear to absolute X axis. "
                               "Absolute Y axis will be used to determine "
                               "local X axis.")
            globalVecY = self.geom.MakeVectorDXDYDZ(0.0, 1.0, 0.0)
            marker = self._buildMarkerRefVecX(center, normal, globalVecY)
        else:
            marker = self._buildMarkerRefVecX(center, normal, globalVecX)
        return marker

    def _buildMarkerRefVecX(self, center, normal, refVecX):
        """
        Create a marker using `normal` as Z axis and `refVecX` to determine
        the X axis.
        """
        xPoint = self.geom.MakeTranslationVector(center, refVecX)
        zPoint = self.geom.MakeTranslationVector(center, normal)
        locPlaneZX = self.geom.MakePlaneThreePnt(center, zPoint, xPoint, 1.0)
        locY = self.geom.GetNormal(locPlaneZX)
        yPoint = self.geom.MakeTranslationVector(center, locY)
        locPlaneYZ = self.geom.MakePlaneThreePnt(center, yPoint, zPoint, 1.0)
        locX = self.geom.GetNormal(locPlaneYZ)
        marker = self.geom.MakeMarkerPntTwoVec(center, locX, locY)
        return marker

    def buildMarker(self, geom, center, normal, warnings = True):
        """
        Create a marker with origin `center` and `normal` as Z axis. The other
        axes are computed using the parameters alpha and beta of the
        Orientation2D instance. `geom` is the pseudo-geompy object used to
        build the geometric shapes. `warnings` can be used to enable or
        disable the logging of warning messages.
        """
        self.geom = geom
        marker = None
        refVecX = None
        if self._vect is not None:
            # Using vector parameter
            if abs(self._vect[0]) <= 1e-7 and abs(self._vect[1]) <= 1e-7 and \
                                              abs(self._vect[2]) <= 1e-7:
                if warnings:
                    logger.warning("Vector too small: %s, using default LCS" %
                                   self._vect)
            else:
                refVecX = self.geom.MakeVectorDXDYDZ(self._vect[0],
                                                     self._vect[1],
                                                     self._vect[2])
        elif self._alpha is not None and self._beta is not None:
            # Using alpha and beta angles
            alphaRad = math.radians(self._alpha)
            betaRad = math.radians(self._beta)
            if abs(alphaRad) <= 1e-7 and abs(betaRad) <= 1e-7:
                if warnings:
                    logger.warning("Angles too small: (%g, %g), using "
                                   "default LCS" % (self._alpha, self._beta))
            else:
                # rotate global CS with angles alpha and beta
                refVecX = self.geom.MakeVectorDXDYDZ(1.0, 0.0, 0.0)
                refVecY = self.geom.MakeVectorDXDYDZ(0.0, 1.0, 0.0)
                globalVecZ = self.geom.MakeVectorDXDYDZ(0.0, 0.0, 1.0)
                if abs(alphaRad) > 1e-7:
                    refVecX = self.geom.Rotate(refVecX, globalVecZ, alphaRad)
                    refVecY = self.geom.Rotate(refVecY, globalVecZ, alphaRad)
                if abs(betaRad) > 1e-7:
                    refVecX = self.geom.Rotate(refVecX, refVecY, betaRad)
    
        if refVecX is not None:
            # build local coordinate system
            angle = self.geom.GetAngleRadians(normal, refVecX)
            if abs(angle) < 1e-7 or abs(angle - math.pi) < 1e-7:
                if warnings:
                    logger.warning("Face normal is colinear to the reference "
                                   "X axis, using default LCS.")
            else:
                marker = self._buildMarkerRefVecX(center, normal, refVecX)

        if marker is None:
            marker = self._buildDefaultMarker(center, normal, warnings)

        return marker
