basegfx/source/vector/b2dvector.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: b2dvector.cxx,v $
  10  * $Revision: 1.18 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_basegfx.hxx"
  33 #include <basegfx/vector/b2dvector.hxx>
  34 #include <basegfx/matrix/b2dhommatrix.hxx>
  35 #include <basegfx/numeric/ftools.hxx>
  36
  37 namespace basegfx
  38 {
  39     B2DVector& B2DVector::normalize()
  40     {
  41         double fLen(scalar(*this));
  42
  43         if(fTools::equalZero(fLen))
  44         {
  45             mfX = 0.0;
  46             mfY = 0.0;
  47         }
  48         else
  49         {
  50             const double fOne(1.0);
  51
  52             if(!fTools::equal(fOne, fLen))
  53             {
  54                 fLen = sqrt(fLen);
  55
  56                 if(!fTools::equalZero(fLen))
  57                 {
  58                     mfX /= fLen;
  59                     mfY /= fLen;
  60                 }
  61             }
  62         }
  63
  64         return *this;
  65     }
  66
  67     B2DVector& B2DVector::operator=( const B2DTuple& rVec )
  68     {
  69         mfX = rVec.getX();
  70         mfY = rVec.getY();
  71         return *this;
  72     }
  73
  74
  75     double B2DVector::getLength() const
  76     {
  77         if(fTools::equalZero(mfX))
  78         {
  79             return fabs(mfY);
  80         }
  81         else if(fTools::equalZero(mfY))
  82         {
  83             return fabs(mfX);
  84         }
  85
  86         return hypot( mfX, mfY );
  87     }
  88
  89     double B2DVector::scalar( const B2DVector& rVec ) const
  90     {
  91         return((mfX * rVec.mfX) + (mfY * rVec.mfY));
  92     }
  93
  94     double B2DVector::cross( const B2DVector& rVec ) const
  95     {
  96         return(mfX * rVec.getY() - mfY * rVec.getX());
  97     }
  98
  99     double B2DVector::angle( const B2DVector& rVec ) const
 100     {
 101         return atan2(mfX * rVec.getY() - mfY * rVec.getX(),
 102             mfX * rVec.getX() + mfY * rVec.getY());
 103     }
 104
 105     const B2DVector& B2DVector::getEmptyVector()
 106     {
 107         return (const B2DVector&) B2DTuple::getEmptyTuple();
 108     }
 109
 110     B2DVector& B2DVector::operator*=( const B2DHomMatrix& rMat )
 111     {
 112         const double fTempX( rMat.get(0,0)*mfX +
 113                             rMat.get(0,1)*mfY );
 114         const double fTempY( rMat.get(1,0)*mfX +
 115                             rMat.get(1,1)*mfY );
 116         mfX = fTempX;
 117         mfY = fTempY;
 118
 119         return *this;
 120     }
 121
 122     B2DVector& B2DVector::setLength(double fLen)
 123     {
 124         double fLenNow(scalar(*this));
 125
 126         if(!fTools::equalZero(fLenNow))
 127         {
 128             const double fOne(10.0);
 129
 130             if(!fTools::equal(fOne, fLenNow))
 131             {
 132                 fLen /= sqrt(fLenNow);
 133             }
 134
 135             mfX *= fLen;
 136             mfY *= fLen;
 137         }
 138
 139         return *this;
 140     }
 141
 142     bool B2DVector::isNormalized() const
 143     {
 144         const double fOne(1.0);
 145         const double fScalar(scalar(*this));
 146
 147         return fTools::equal(fOne, fScalar);
 148     }
 149
 150     bool areParallel( const B2DVector& rVecA, const B2DVector& rVecB )
 151     {
 152         const double fValA(rVecA.getX() * rVecB.getY());
 153         const double fValB(rVecA.getY() * rVecB.getX());
 154
 155         return fTools::equal(fValA, fValB);
 156     }
 157
 158     B2VectorOrientation getOrientation( const B2DVector& rVecA, const B2DVector& rVecB )
 159     {
 160         double fVal(rVecA.getX() * rVecB.getY() - rVecA.getY() * rVecB.getX());
 161
 162         if(fTools::equalZero(fVal))
 163         {
 164             return ORIENTATION_NEUTRAL;
 165         }
 166
 167         if(fVal > 0.0)
 168         {
 169             return ORIENTATION_POSITIVE;
 170         }
 171         else
 172         {
 173             return ORIENTATION_NEGATIVE;
 174         }
 175     }
 176
 177     B2DVector getPerpendicular( const B2DVector& rNormalizedVec )
 178     {
 179         B2DVector aPerpendicular(-rNormalizedVec.getY(), rNormalizedVec.getX());
 180         return aPerpendicular;
 181     }
 182
 183     B2DVector getNormalizedPerpendicular( const B2DVector& rVec )
 184     {
 185         B2DVector aPerpendicular(rVec);
 186         aPerpendicular.normalize();
 187         const double aTemp(-aPerpendicular.getY());
 188         aPerpendicular.setY(aPerpendicular.getX());
 189         aPerpendicular.setX(aTemp);
 190         return aPerpendicular;
 191     }
 192
 193     B2DVector operator*( const B2DHomMatrix& rMat, const B2DVector& rVec )
 194     {
 195         B2DVector aRes( rVec );
 196         return aRes*=rMat;
 197     }
 198
 199     B2VectorContinuity getContinuity(const B2DVector& rBackVector, const B2DVector& rForwardVector )
 200     {
 201         if(rBackVector.equalZero() || rForwardVector.equalZero())
 202         {
 203             return CONTINUITY_NONE;
 204         }
 205
 206         if(fTools::equal(rBackVector.getX(), -rForwardVector.getX()) && fTools::equal(rBackVector.getY(), -rForwardVector.getY()))
 207         {
 208             // same direction and same length -> C2
 209             return CONTINUITY_C2;
 210         }
 211
 212         if(areParallel(rBackVector, rForwardVector) && rBackVector.scalar(rForwardVector) < 0.0)
 213         {
 214             // parallel and opposite direction -> C1
 215             return CONTINUITY_C1;
 216         }
 217
 218         return CONTINUITY_NONE;
 219     }
 220 } // end of namespace basegfx
 221
 222 // eof