PARP Research Group University of Murcia, Spain


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 
00125                 QVVector operator*(const double value) const            { return scalarMultiplication(value); };
00126 
00131                 QVVector operator/(const double value) const            { return scalarDivision(value); };
00132 
00136                 QVVector operator*(const QVMatrix &matrix) const;
00137 
00142                 bool operator==(const QVVector &vector) const           { return equals(vector); };
00143 
00147                 QVVector & operator+=(const QVVector &vector)           { return (*this = add(vector)); }
00148 
00149 
00154                 operator QPointF() const
00155                         {
00156                         Q_ASSERT(size() > 1);
00157                         Q_ASSERT(size() < 4);
00158                         if (size() == 2)
00159                                 return QPointF(operator[](0), operator[](1));
00160                         else
00161                                 return QPointF(operator[](0)/operator[](2), operator[](1)/operator[](2));
00162                         }
00163 
00167                 operator gsl_vector * () const
00168                         {
00169                         gsl_vector *result = gsl_vector_alloc(size());
00170                         const double *data = this->data();
00171                         for(uint i = 0; i < result->size; i++)
00172                                 gsl_vector_set (result, i, data[i]);
00173                         return result;
00174                         }
00175 
00177 
00181                 void set(const double value)
00182                         {
00183                         for (int i = 0; i < size(); i++)
00184                                 operator[](i) =  value;
00185                         };
00186 
00190                 QVVector subVector(const int firstIndex, const int lastIndex)
00191                         {
00192                         Q_ASSERT(0 <= firstIndex);
00193                         Q_ASSERT(firstIndex <= lastIndex);
00194                         Q_ASSERT(lastIndex < this->size());
00195 
00196                         QVVector result(lastIndex - firstIndex +1);
00197                         for (int i = firstIndex; i <= lastIndex; i++)
00198                                 result[i] = operator[](i);
00199 
00200                         return result;
00201                         };
00202 
00207                 QVVector scalarDivision(const double value) const
00208                         {
00209                         QVVector result = *this;
00210                         for (int i = 0; i < size(); i++)
00211                                 result[i] /= value;
00212                         return result;
00213                         };
00214 
00219                 QVVector scalarMultiplication(const double value) const
00220                         {
00221                         QVVector result = *this;
00222                         for (int i = 0; i < size(); i++)
00223                                 result[i] *= value;
00224                         return result;
00225                         };
00226 
00230                 double norm2() const
00231                         { return sqrt(*this * *this); }
00232 
00237                 QVVector normalize()    const
00238                         { return operator/(norm2()); }
00239 
00244                 double dotProduct(const QVVector &vector) const;
00245 
00251                 QVVector crossProduct(const QVVector &vector) const;
00252 
00257                 QVVector add(const QVVector &vector) const;
00258 
00263                 QVVector substract(const QVVector &vector) const;
00264 
00269                 bool equals(const QVVector &vector) const;
00270 
00272 
00280                 static const QVVector gaussianDistribution(const int size, const double sigma)
00281                         {
00282                         const double nu = ((double) size)/2;
00283                         QVVector result(size);
00284                         for(int x=0; x< size; x++)
00285                                 result[x] = exp(-POW2(x+0.5-nu)/(2*POW2(sigma))) / ( sigma * sqrt(2*PI));
00286                 
00287                         return result;
00288                         }
00289         };
00290 
00293 std::ostream& operator << ( std::ostream &os, const QVVector &vector );
00294 
00297 uint qHash(const QVVector &vector);
00298 
00299 #endif
00300 



QVision framework. PARP research group, copyright 2007, 2008.