src/qvmath/qvvector.h

Go to the documentation of this file.
00001 /*
00002  *      Copyright (C) 2007, 2008. PARP Research Group.
00003  *      <http://perception.inf.um.es>
00004  *      University of Murcia, Spain.
00005  *
00006  *      This file is part of the QVision library.
00007  *
00008  *      QVision is free software: you can redistribute it and/or modify
00009  *      it under the terms of the GNU Lesser General Public License as
00010  *      published by the Free Software Foundation, version 3 of the License.
00011  *
00012  *      QVision is distributed in the hope that it will be useful,
00013  *      but WITHOUT ANY WARRANTY; without even the implied warranty of
00014  *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00015  *      GNU Lesser General Public License for more details.
00016  *
00017  *      You should have received a copy of the GNU Lesser General Public
00018  *      License along with QVision. If not, see <http://www.gnu.org/licenses/>.
00019  */
00020 
00024 
00025 #ifndef QVVECTOR_H
00026 #define QVVECTOR_H
00027 
00028 #include <math.h>
00029 #include <iostream>
00030 #include <QVector>
00031 #include <QPointF>
00032 #include <qvdefines.h>
00033 #include <gsl/gsl_linalg.h>
00034 
00035 class QVMatrix;
00036 
00043 class QVVector: public QVector<double>
00044         {
00045         public:
00049                 QVVector(): QVector<double>()                                                                   {}
00050 
00055                 QVVector(const int size, const double defaultValue = 0): QVector<double>(size, defaultValue)    {}
00056 
00060                 QVVector(const QVVector &vector): QVector<double>(vector)                                       {}
00061 
00065                 QVVector(const QVector<double> &vector): QVector<double>(vector)                                {}
00066 
00074                 QVVector(const QVMatrix &matrix);
00075 
00079                 QVVector(const gsl_vector *vector): QVector<double>(vector->size)
00080                                 {
00081                                 for(int i = 0; i < size(); i++)
00082                                         replace(i, gsl_vector_get(vector, i));
00083                                 }
00084 
00088                 QVVector(const QPoint &point): QVector<double>(2)       { operator[](0) = point.x(); operator[](1) = point.y(); }
00089 
00093                 QVVector(const QPointF &point): QVector<double>(2)      { operator[](0) = point.x(); operator[](1) = point.y(); }
00094 
00096 
00101                 double operator*(const QVVector &vector) const          { return dotProduct(vector); };
00102 
00107                 QVVector operator^(const QVVector &vector) const        { return crossProduct(vector); };
00108 
00113                 QVVector operator+(const QVVector &vector) const        { return add(vector); };
00114 
00119                 QVVector operator-(const QVVector &vector) const        { return substract(vector); };
00120 
00126                 QVVector operator*(const double value) const            { return scalarMultiplication(value); };
00127 
00132                 QVVector operator/(const double value) const            { return scalarDivision(value); };
00133 
00137                 QVVector operator*(const QVMatrix &matrix) const;
00138 
00143                 bool operator==(const QVVector &vector) const           { return equals(vector); };
00144 
00148                 QVVector & operator+=(const QVVector &vector)           { return (*this = add(vector)); }
00149 
00150 
00155                 operator QPointF() const
00156                         {
00157                         Q_ASSERT(size() > 1);
00158                         Q_ASSERT(size() < 4);
00159                         if (size() == 2)
00160                                 return QPointF(operator[](0), operator[](1));
00161                         else
00162                                 return QPointF(operator[](0)/operator[](2), operator[](1)/operator[](2));
00163                         }
00164 
00168                 operator gsl_vector * () const
00169                         {
00170                         gsl_vector *result = gsl_vector_alloc(size());
00171                         const double *data = this->data();
00172                         for(uint i = 0; i < result->size; i++)
00173                                 gsl_vector_set (result, i, data[i]);
00174                         return result;
00175                         }
00176 
00178 
00182                 void set(const double value)
00183                         {
00184                         for (int i = 0; i < size(); i++)
00185                                 operator[](i) =  value;
00186                         };
00187 
00191                 QVVector subVector(const int firstIndex, const int lastIndex)
00192                         {
00193                         Q_ASSERT(0 <= firstIndex);
00194                         Q_ASSERT(firstIndex <= lastIndex);
00195                         Q_ASSERT(lastIndex < this->size());
00196 
00197                         QVVector result(lastIndex - firstIndex +1);
00198                         for (int i = firstIndex; i <= lastIndex; i++)
00199                                 result[i] = operator[](i);
00200 
00201                         return result;
00202                         };
00203 
00208                 QVVector scalarDivision(const double value) const
00209                         {
00210                         QVVector result = *this;
00211                         for (int i = 0; i < size(); i++)
00212                                 result[i] /= value;
00213                         return result;
00214                         };
00215 
00220                 QVVector scalarMultiplication(const double value) const
00221                         {
00222                         QVVector result = *this;
00223                         for (int i = 0; i < size(); i++)
00224                                 result[i] *= value;
00225                         return result;
00226                         };
00227 
00231                 double norm2() const
00232                         { return sqrt(*this * *this); }
00233 
00238                 QVVector normalize()    const
00239                         { return operator/(norm2()); }
00240 
00245                 double dotProduct(const QVVector &vector) const;
00246 
00252                 QVVector crossProduct(const QVVector &vector) const;
00253 
00258                 QVVector add(const QVVector &vector) const;
00259 
00264                 QVVector substract(const QVVector &vector) const;
00265 
00270                 bool equals(const QVVector &vector) const;
00271 
00273 
00281                 static const QVVector gaussianDistribution(const int size, const double sigma)
00282                         {
00283                         const double nu = ((double) size)/2;
00284                         QVVector result(size);
00285                         for(int x=0; x< size; x++)
00286                                 result[x] = exp(-POW2(x+0.5-nu)/(2*POW2(sigma))) / ( sigma * sqrt(2*PI));
00287                 
00288                         return result;
00289                         }
00290         };
00291 
00294 std::ostream& operator << ( std::ostream &os, const QVVector &vector );
00295 
00298 uint qHash(const QVVector &vector);
00299 
00300 #endif
00301