LCOV - code coverage report
Current view: top level - include/basegfx/vector - b3dvector.hxx (source / functions) Hit Total Coverage
Test: commit 10e77ab3ff6f4314137acd6e2702a6e5c1ce1fae Lines: 53 59 89.8 %
Date: 2014-11-03 Functions: 14 15 93.3 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
       2             : /*
       3             :  * This file is part of the LibreOffice project.
       4             :  *
       5             :  * This Source Code Form is subject to the terms of the Mozilla Public
       6             :  * License, v. 2.0. If a copy of the MPL was not distributed with this
       7             :  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
       8             :  *
       9             :  * This file incorporates work covered by the following license notice:
      10             :  *
      11             :  *   Licensed to the Apache Software Foundation (ASF) under one or more
      12             :  *   contributor license agreements. See the NOTICE file distributed
      13             :  *   with this work for additional information regarding copyright
      14             :  *   ownership. The ASF licenses this file to you under the Apache
      15             :  *   License, Version 2.0 (the "License"); you may not use this file
      16             :  *   except in compliance with the License. You may obtain a copy of
      17             :  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
      18             :  */
      19             : 
      20             : #ifndef INCLUDED_BASEGFX_VECTOR_B3DVECTOR_HXX
      21             : #define INCLUDED_BASEGFX_VECTOR_B3DVECTOR_HXX
      22             : 
      23             : #include <basegfx/tuple/b3dtuple.hxx>
      24             : #include <basegfx/basegfxdllapi.h>
      25             : 
      26             : 
      27             : 
      28             : namespace basegfx
      29             : {
      30             :     // predeclaration
      31             :     class B3DHomMatrix;
      32             : 
      33             :     /** Base Point class with three double values
      34             : 
      35             :         This class derives all operators and common handling for
      36             :         a 3D data class from B3DTuple. All necessary extensions
      37             :         which are special for 3D Vectors are added here.
      38             : 
      39             :         @see B3DTuple
      40             :     */
      41      898475 :     class BASEGFX_DLLPUBLIC B3DVector : public ::basegfx::B3DTuple
      42             :     {
      43             :     public:
      44             :         /** Create a 3D Vector
      45             : 
      46             :             The vector is initialized to (0.0, 0.0, 0.0)
      47             :         */
      48      527455 :         B3DVector()
      49      527455 :         :   B3DTuple()
      50      527455 :         {}
      51             : 
      52             :         /** Create a 3D Vector
      53             : 
      54             :             @param fX
      55             :             This parameter is used to initialize the X-coordinate
      56             :             of the 3D Vector.
      57             : 
      58             :             @param fY
      59             :             This parameter is used to initialize the Y-coordinate
      60             :             of the 3D Vector.
      61             : 
      62             :             @param fZ
      63             :             This parameter is used to initialize the Z-coordinate
      64             :             of the 3D Vector.
      65             :         */
      66      420980 :         B3DVector(double fX, double fY, double fZ)
      67      420980 :         :   B3DTuple(fX, fY, fZ)
      68      420980 :         {}
      69             : 
      70             :         /** Create a copy of a 3D Vector
      71             : 
      72             :             @param rVec
      73             :             The 3D Vector which will be copied.
      74             :         */
      75     1486596 :         B3DVector(const B3DVector& rVec)
      76     1486596 :         :   B3DTuple(rVec)
      77     1486596 :         {}
      78             : 
      79             :         /** constructor with tuple to allow copy-constructing
      80             :             from B3DTuple-based classes
      81             :         */
      82      989063 :         B3DVector(const ::basegfx::B3DTuple& rTuple)
      83      989063 :         :   B3DTuple(rTuple)
      84      989063 :         {}
      85             : 
      86     3422642 :         ~B3DVector()
      87     3422642 :         {}
      88             : 
      89             :         /** *=operator to allow usage from B3DVector, too
      90             :         */
      91             :         B3DVector& operator*=( const B3DVector& rPnt )
      92             :         {
      93             :             mfX *= rPnt.mfX;
      94             :             mfY *= rPnt.mfY;
      95             :             mfZ *= rPnt.mfZ;
      96             :             return *this;
      97             :         }
      98             : 
      99             :         /** *=operator to allow usage from B3DVector, too
     100             :         */
     101           0 :         B3DVector& operator*=(double t)
     102             :         {
     103           0 :             mfX *= t;
     104           0 :             mfY *= t;
     105           0 :             mfZ *= t;
     106           0 :             return *this;
     107             :         }
     108             : 
     109             :         /** assignment operator to allow assigning the results
     110             :             of B3DTuple calculations
     111             :         */
     112       51481 :         B3DVector& operator=( const ::basegfx::B3DTuple& rVec )
     113             :         {
     114       51481 :             mfX = rVec.getX();
     115       51481 :             mfY = rVec.getY();
     116       51481 :             mfZ = rVec.getZ();
     117       51481 :             return *this;
     118             :         }
     119             : 
     120             :         /** Calculate the length of this 3D Vector
     121             : 
     122             :             @return The Length of the 3D Vector
     123             :         */
     124      108868 :         double getLength(void) const
     125             :         {
     126      108868 :             double fLen(scalar(*this));
     127      108868 :             if((0.0 == fLen) || (1.0 == fLen))
     128        6668 :                 return fLen;
     129      102200 :             return sqrt(fLen);
     130             :         }
     131             : 
     132             :         /** Calculate the length in the XY-Plane for this 3D Vector
     133             : 
     134             :             @return The XY-Plane Length of the 3D Vector
     135             :         */
     136             :         double getXYLength(void) const
     137             :         {
     138             :             double fLen((mfX * mfX) + (mfY * mfY));
     139             :             if((0.0 == fLen) || (1.0 == fLen))
     140             :                 return fLen;
     141             :             return sqrt(fLen);
     142             :         }
     143             : 
     144             :         /** Calculate the length in the XZ-Plane for this 3D Vector
     145             : 
     146             :             @return The XZ-Plane Length of the 3D Vector
     147             :         */
     148        9902 :         double getXZLength(void) const
     149             :         {
     150        9902 :             double fLen((mfX * mfX) + (mfZ * mfZ)); // #i73040#
     151        9902 :             if((0.0 == fLen) || (1.0 == fLen))
     152         202 :                 return fLen;
     153        9700 :             return sqrt(fLen);
     154             :         }
     155             : 
     156             :         /** Calculate the length in the YZ-Plane for this 3D Vector
     157             : 
     158             :             @return The YZ-Plane Length of the 3D Vector
     159             :         */
     160        1459 :         double getYZLength(void) const
     161             :         {
     162        1459 :             double fLen((mfY * mfY) + (mfZ * mfZ));
     163        1459 :             if((0.0 == fLen) || (1.0 == fLen))
     164        1459 :                 return fLen;
     165           0 :             return sqrt(fLen);
     166             :         }
     167             : 
     168             :         /** Set the length of this 3D Vector
     169             : 
     170             :             @param fLen
     171             :             The to be achieved length of the 3D Vector
     172             :         */
     173          70 :         B3DVector& setLength(double fLen)
     174             :         {
     175          70 :             double fLenNow(scalar(*this));
     176             : 
     177          70 :             if(!::basegfx::fTools::equalZero(fLenNow))
     178             :             {
     179          70 :                 const double fOne(1.0);
     180             : 
     181          70 :                 if(!::basegfx::fTools::equal(fOne, fLenNow))
     182             :                 {
     183          70 :                     fLen /= sqrt(fLenNow);
     184             :                 }
     185             : 
     186          70 :                 mfX *= fLen;
     187          70 :                 mfY *= fLen;
     188          70 :                 mfZ *= fLen;
     189             :             }
     190             : 
     191          70 :             return *this;
     192             :         }
     193             : 
     194             :         /** Normalize this 3D Vector
     195             : 
     196             :             The length of the 3D Vector is set to 1.0
     197             :         */
     198             :         B3DVector& normalize();
     199             : 
     200             :         /** Test if this 3D Vector is normalized
     201             : 
     202             :             @return
     203             :             true if lenth of vector is equal to 1.0
     204             :             false else
     205             :         */
     206             :         bool isNormalized() const
     207             :         {
     208             :             const double fOne(1.0);
     209             :             const double fScalar(scalar(*this));
     210             : 
     211             :             return (::basegfx::fTools::equal(fOne, fScalar));
     212             :         }
     213             : 
     214             :         /** get a 3D Vector which is perpendicular to this and a given 3D Vector
     215             : 
     216             :             @attention This only works if this and the given 3D Vector are
     217             :             both normalized.
     218             : 
     219             :             @param rNormalizedVec
     220             :             A normalized 3D Vector.
     221             : 
     222             :             @return
     223             :             A 3D Vector perpendicular to this and the given one
     224             :         */
     225             :         B3DVector getPerpendicular(const B3DVector& rNormalizedVec) const;
     226             : 
     227             :         /** Calculate the Scalar product
     228             : 
     229             :             This method calculates the Scalar product between this
     230             :             and the given 3D Vector.
     231             : 
     232             :             @param rVec
     233             :             A second 3D Vector.
     234             : 
     235             :             @return
     236             :             The Scalar Product of two 3D Vectors
     237             :         */
     238     1035926 :         double scalar(const B3DVector& rVec) const
     239             :         {
     240     1035926 :             return ((mfX * rVec.mfX) + (mfY * rVec.mfY) + (mfZ * rVec.mfZ));
     241             :         }
     242             : 
     243             :         /** Transform vector by given transformation matrix.
     244             : 
     245             :             Since this is a vector, translational components of the
     246             :             matrix are disregarded.
     247             :         */
     248             :         B3DVector& operator*=( const B3DHomMatrix& rMat );
     249             : 
     250      151725 :         static const B3DVector& getEmptyVector()
     251             :         {
     252      151725 :             return static_cast<const B3DVector&>( ::basegfx::B3DTuple::getEmptyTuple() );
     253             :         }
     254             :     };
     255             : 
     256             :     // external operators
     257             : 
     258             : 
     259             :     /** get a 3D Vector which is in 2D (ignoring
     260             :         the Z-Coordinate) perpendicular to a given 3D Vector
     261             : 
     262             :         @attention This only works if the given 3D Vector is normalized.
     263             : 
     264             :         @param rNormalizedVec
     265             :         A normalized 3D Vector.
     266             : 
     267             :         @return
     268             :         A 3D Vector perpendicular to the given one in X,Y (2D).
     269             :     */
     270             :     inline B3DVector getPerpendicular2D( const B3DVector& rNormalizedVec )
     271             :     {
     272             :         B3DVector aPerpendicular(-rNormalizedVec.getY(), rNormalizedVec.getX(), rNormalizedVec.getZ());
     273             :         return aPerpendicular;
     274             :     }
     275             : 
     276             :     /** Test two vectors which need not to be normalized for parallelism
     277             : 
     278             :         @param rVecA
     279             :         The first 3D Vector
     280             : 
     281             :         @param rVecB
     282             :         The second 3D Vector
     283             : 
     284             :         @return
     285             :         bool if the two values are parallel. Also true if
     286             :         one of the vectors is empty.
     287             :     */
     288             :     BASEGFX_DLLPUBLIC bool areParallel( const B3DVector& rVecA, const B3DVector& rVecB );
     289             : 
     290             :     /** Transform vector by given transformation matrix.
     291             : 
     292             :         Since this is a vector, translational components of the
     293             :         matrix are disregarded.
     294             :     */
     295             :     BASEGFX_DLLPUBLIC B3DVector operator*( const B3DHomMatrix& rMat, const B3DVector& rVec );
     296             : 
     297             :     /** Calculate the Cross Product of two 3D Vectors
     298             : 
     299             :         @param rVecA
     300             :         A first 3D Vector.
     301             : 
     302             :         @param rVecB
     303             :         A second 3D Vector.
     304             : 
     305             :         @return
     306             :         The Cross Product of both 3D Vectors
     307             :     */
     308      316170 :     inline B3DVector cross(const B3DVector& rVecA, const B3DVector& rVecB)
     309             :     {
     310             :         B3DVector aVec(
     311      316170 :             rVecA.getY() * rVecB.getZ() - rVecA.getZ() * rVecB.getY(),
     312      316170 :             rVecA.getZ() * rVecB.getX() - rVecA.getX() * rVecB.getZ(),
     313      948510 :             rVecA.getX() * rVecB.getY() - rVecA.getY() * rVecB.getX());
     314      316170 :         return aVec;
     315             :     }
     316             : } // end of namespace basegfx
     317             : 
     318             : 
     319             : 
     320             : #endif // INCLUDED_BASEGFX_VECTOR_B3DVECTOR_HXX
     321             : 
     322             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10