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