basegfx/source/vector/b2dvector.cxx

   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 #include <basegfx/vector/b2dvector.hxx>
  21 #include <basegfx/matrix/b2dhommatrix.hxx>
  22 #include <basegfx/numeric/ftools.hxx>
  23
  24 namespace basegfx
  25 {
  26     B2DVector& B2DVector::normalize()
  27     {
  28         double fLen(std::hypot(mnX, mnY));
  29
  30         if(!fTools::equalZero(fLen))
  31         {
  32             const double fOne(1.0);
  33
  34             if(!fTools::equal(fOne, fLen))
  35             {
  36                 mnX /= fLen;
  37                 mnY /= fLen;
  38             }
  39         }
  40         else
  41         {
  42             mnX = 0.0;
  43             mnY = 0.0;
  44         }
  45
  46         return *this;
  47     }
  48
  49     double B2DVector::getLength() const
  50     {
  51         if(fTools::equalZero(mnX))
  52         {
  53             return fabs(mnY);
  54         }
  55         else if(fTools::equalZero(mnY))
  56         {
  57             return fabs(mnX);
  58         }
  59
  60         return hypot( mnX, mnY );
  61     }
  62
  63     double B2DVector::angle( const B2DVector& rVec ) const
  64     {
  65         return atan2(mnX * rVec.getY() - mnY * rVec.getX(),
  66             mnX * rVec.getX() + mnY * rVec.getY());
  67     }
  68
  69     const B2DVector& B2DVector::getEmptyVector()
  70     {
  71         return static_cast<const B2DVector&>( B2DTuple::getEmptyTuple() );
  72     }
  73
  74     B2DVector& B2DVector::operator*=( const B2DHomMatrix& rMat )
  75     {
  76         const double fTempX( rMat.get(0,0)*mnX +
  77                             rMat.get(0,1)*mnY );
  78         const double fTempY( rMat.get(1,0)*mnX +
  79                             rMat.get(1,1)*mnY );
  80         mnX = fTempX;
  81         mnY = fTempY;
  82
  83         return *this;
  84     }
  85
  86     B2DVector& B2DVector::setLength(double fLen)
  87     {
  88         double fLenNow(std::hypot(mnX, mnY));
  89
  90         if(!fTools::equalZero(fLenNow))
  91         {
  92             const double fOne(1.0);
  93
  94             if(!fTools::equal(fOne, fLenNow))
  95             {
  96                 fLen /= fLenNow;
  97             }
  98
  99             mnX *= fLen;
 100             mnY *= fLen;
 101         }
 102
 103         return *this;
 104     }
 105
 106     bool areParallel( const B2DVector& rVecA, const B2DVector& rVecB )
 107     {
 108         const double fValA(rVecA.getX() * rVecB.getY());
 109         const double fValB(rVecA.getY() * rVecB.getX());
 110
 111         return fTools::equal(fValA, fValB);
 112     }
 113
 114     B2VectorOrientation getOrientation( const B2DVector& rVecA, const B2DVector& rVecB )
 115     {
 116         double fVal(rVecA.getX() * rVecB.getY() - rVecA.getY() * rVecB.getX());
 117
 118         if(fTools::equalZero(fVal))
 119         {
 120             return B2VectorOrientation::Neutral;
 121         }
 122
 123         if(fVal > 0.0)
 124         {
 125             return B2VectorOrientation::Positive;
 126         }
 127         else
 128         {
 129             return B2VectorOrientation::Negative;
 130         }
 131     }
 132
 133     B2DVector getPerpendicular( const B2DVector& rNormalizedVec )
 134     {
 135         B2DVector aPerpendicular(-rNormalizedVec.getY(), rNormalizedVec.getX());
 136         return aPerpendicular;
 137     }
 138
 139     B2DVector getNormalizedPerpendicular( const B2DVector& rVec )
 140     {
 141         B2DVector aPerpendicular(rVec);
 142         aPerpendicular.normalize();
 143         const double aTemp(-aPerpendicular.getY());
 144         aPerpendicular.setY(aPerpendicular.getX());
 145         aPerpendicular.setX(aTemp);
 146         return aPerpendicular;
 147     }
 148
 149     B2DVector operator*( const B2DHomMatrix& rMat, const B2DVector& rVec )
 150     {
 151         B2DVector aRes( rVec );
 152         aRes *= rMat;
 153         return aRes;
 154     }
 155
 156     B2VectorContinuity getContinuity(const B2DVector& rBackVector, const B2DVector& rForwardVector )
 157     {
 158         if(rBackVector.equalZero() || rForwardVector.equalZero())
 159         {
 160             return B2VectorContinuity::NONE;
 161         }
 162
 163         if(fTools::equal(rBackVector.getX(), -rForwardVector.getX()) && fTools::equal(rBackVector.getY(), -rForwardVector.getY()))
 164         {
 165             // same direction and same length -> C2
 166             return B2VectorContinuity::C2;
 167         }
 168
 169         if(areParallel(rBackVector, rForwardVector) && rBackVector.scalar(rForwardVector) < 0.0)
 170         {
 171             // parallel and opposite direction -> C1
 172             return B2VectorContinuity::C1;
 173         }
 174
 175         return B2VectorContinuity::NONE;
 176     }
 177 } // end of namespace basegfx
 178
 179 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */