include/basegfx/vector/b2dvector.hxx

   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_B2DVECTOR_HXX
  21 #define INCLUDED_BASEGFX_VECTOR_B2DVECTOR_HXX
  22
  23 #include <basegfx/tuple/b2dtuple.hxx>
  24 #include <basegfx/vector/b2ivector.hxx>
  25 #include <basegfx/vector/b2enums.hxx>
  26 #include <basegfx/basegfxdllapi.h>
  27
  28 namespace basegfx
  29 {
  30     class B2DHomMatrix;
  31
  32     /** Base Point class with two double values
  33
  34         This class derives all operators and common handling for
  35         a 2D data class from B2DTuple. All necessary extensions
  36         which are special for 2D Vectors are added here.
  37
  38         @see B2DTuple
  39     */
  40     class BASEGFX_DLLPUBLIC B2DVector : public ::basegfx::B2DTuple
  41     {
  42     public:
  43         /** Create a 2D Vector
  44
  45             The vector is initialized to (0.0, 0.0)
  46         */
  47         B2DVector()
  48         :   B2DTuple()
  49         {}
  50
  51         /** Create a 2D Vector
  52
  53             @param fX
  54             This parameter is used to initialize the X-coordinate
  55             of the 2D Vector.
  56
  57             @param fY
  58             This parameter is used to initialize the Y-coordinate
  59             of the 2D Vector.
  60         */
  61         B2DVector(double fX, double fY)
  62         :   B2DTuple(fX, fY)
  63         {}
  64
  65         /** Create a copy of a 2D Vector
  66
  67             @param rVec
  68             The 2D Vector which will be copied.
  69         */
  70         explicit B2DVector(const ::basegfx::B2IVector& rVec)
  71         :   B2DTuple(rVec)
  72         {}
  73
  74         /** constructor with tuple to allow copy-constructing
  75             from B2DTuple-based classes
  76         */
  77         B2DVector(const ::basegfx::B2DTuple& rTuple)
  78         :   B2DTuple(rTuple)
  79         {}
  80
  81         /** *=operator to allow usage from B2DVector, too
  82         */
  83         B2DVector& operator*=( const B2DVector& rPnt )
  84         {
  85             mfX *= rPnt.mfX;
  86             mfY *= rPnt.mfY;
  87             return *this;
  88         }
  89
  90         /** *=operator to allow usage from B2DVector, too
  91         */
  92         B2DVector& operator*=(double t)
  93         {
  94             mfX *= t;
  95             mfY *= t;
  96             return *this;
  97         }
  98
  99         /** assignment operator to allow assigning the results
 100             of B2DTuple calculations
 101         */
 102         B2DVector& operator=( const ::basegfx::B2DTuple& rVec );
 103
 104         /** Calculate the length of this 2D Vector
 105
 106             @return The Length of the 2D Vector
 107         */
 108         double getLength() const;
 109
 110         /** Set the length of this 2D Vector
 111
 112             @param fLen
 113             The to be achieved length of the 2D Vector
 114         */
 115         B2DVector& setLength(double fLen);
 116
 117         /** Normalize this 2D Vector
 118
 119             The length of the 2D Vector is set to 1.0
 120         */
 121         B2DVector& normalize();
 122
 123         /** Calculate the Scalar with another 2D Vector
 124
 125             @param rVec
 126             The second 2D Vector
 127
 128             @return
 129             The Scalar value of the two involved 2D Vectors
 130         */
 131         double scalar( const B2DVector& rVec ) const { return((mfX * rVec.mfX) + (mfY * rVec.mfY)); }
 132
 133         /** Calculate the length of the cross product with another 2D Vector
 134
 135             In 2D, returning an actual vector does not make much
 136             sense here. The magnitude, although, can be readily
 137             used for tasks such as angle calculations, since for
 138             the returned value, the following equation holds:
 139             retVal = getLength(this)*getLength(rVec)*sin(theta),
 140             with theta being the angle between the two vectors.
 141
 142             @param rVec
 143             The second 2D Vector
 144
 145             @return
 146             The length of the cross product of the two involved 2D Vectors
 147         */
 148         double cross( const B2DVector& rVec ) const { return(mfX * rVec.getY() - mfY * rVec.getX()); }
 149
 150         /** Calculate the Angle with another 2D Vector
 151
 152             @param rVec
 153             The second 2D Vector
 154
 155             @return
 156             The Angle value of the two involved 2D Vectors in -pi/2 < return < pi/2
 157         */
 158         double angle( const B2DVector& rVec ) const;
 159
 160         /** Transform vector by given transformation matrix.
 161
 162             Since this is a vector, translational components of the
 163             matrix are disregarded.
 164         */
 165         B2DVector& operator*=( const B2DHomMatrix& rMat );
 166
 167         static const B2DVector& getEmptyVector();
 168     };
 169
 170     // external operators
 171
 172
 173     /** Calculate the orientation to another 2D Vector
 174
 175         @param rVecA
 176         The first 2D Vector
 177
 178         @param rVecB
 179         The second 2D Vector
 180
 181         @return
 182         The mathematical Orientation of the two involved 2D Vectors
 183     */
 184     BASEGFX_DLLPUBLIC B2VectorOrientation getOrientation( const B2DVector& rVecA, const B2DVector& rVecB );
 185
 186     /** Calculate a perpendicular 2D Vector to the given one
 187
 188         @param rVec
 189         The source 2D Vector
 190
 191         @attention This only works if the given 2D Vector is normalized.
 192
 193         @return
 194         A 2D Vector perpendicular to the one given in parameter rVec
 195     */
 196     BASEGFX_DLLPUBLIC B2DVector getPerpendicular( const B2DVector& rNormalizedVec );
 197
 198     /** Calculate a perpendicular 2D Vector to the given one,
 199         normalize the given one as preparation
 200
 201         @param rVec
 202         The source 2D Vector
 203
 204         @return
 205         A normalized 2D Vector perpendicular to the one given in parameter rVec
 206     */
 207     BASEGFX_DLLPUBLIC B2DVector getNormalizedPerpendicular( const B2DVector& rVec );
 208
 209     /** Test two vectors which need not to be normalized for parallelism
 210
 211         @param rVecA
 212         The first 2D Vector
 213
 214         @param rVecB
 215         The second 2D Vector
 216
 217         @return
 218         bool if the two values are parallel. Also true if
 219         one of the vectors is empty.
 220     */
 221     BASEGFX_DLLPUBLIC bool areParallel( const B2DVector& rVecA, const B2DVector& rVecB );
 222
 223     /** Transform vector by given transformation matrix.
 224
 225         Since this is a vector, translational components of the
 226         matrix are disregarded.
 227     */
 228     BASEGFX_DLLPUBLIC B2DVector operator*( const B2DHomMatrix& rMat, const B2DVector& rVec );
 229
 230     /** Test continuity between given vectors.
 231
 232         The two given vectors are assumed to describe control points on a
 233         common point. Calculate if there is a continuity between them.
 234     */
 235     BASEGFX_DLLPUBLIC B2VectorContinuity getContinuity( const B2DVector& rBackVector, const B2DVector& rForwardVector );
 236
 237 } // end of namespace basegfx
 238
 239 #endif // INCLUDED_BASEGFX_VECTOR_B2DVECTOR_HXX
 240
 241 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */