PARP Research Group University of Murcia, Spain


src/qvmath/qvvector.cpp

Go to the documentation of this file.
00001 /*
00002  *      Copyright (C) 2007, 2008, 2009. 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 #include <QString>
00026 #include <QVVector>
00027 #include <QVMatrix>
00028 
00029 #include <qvmath.h>
00030 
00031 QVVector::QVVector(const QVMatrix &matrix): QVector<double>(matrix.getCols() * matrix.getRows())
00032         {
00033         const int n = size();
00034         const double *matrixData = matrix.getReadData();
00035 
00036         for(int i = 0; i < n; i++)
00037                 operator[](i) = matrixData[i];
00038         }
00039 
00040 double QVVector::dotProduct(const QVVector &vector) const
00041         {
00042         Q_ASSERT(size() == vector.size());
00043 
00044         double accum = 0;
00045         for (int i = 0; i < size(); i++)
00046                 accum += at(i) * vector[i];
00047 
00048         return accum;
00049         }
00050 
00051 QVVector QVVector::crossProduct(const QVVector &vector) const
00052         {
00053         Q_ASSERT(size() == vector.size());
00054         Q_ASSERT(size() == 3);
00055 
00056         const double    x1 = at(0), y1 = at(1), z1 = at(2),
00057                         x2 = vector[0], y2 = vector[1], z2 = vector[2];
00058 
00059         QVVector v(3);
00060 
00061         v[0] = -y2*z1 + y1*z2;
00062         v[1] = x2*z1 - x1*z2;
00063         v[2] = -x2*y1 + x1*y2;
00064 
00065         return v;
00066         }
00067 
00068 QVVector QVVector::operator*(const QVMatrix &matrix) const
00069         {
00070         Q_ASSERT(size() == matrix.getRows());
00071         if (size() != matrix.getRows())
00072                 {
00073                 std::cout << "ERROR: tried to multiply matrices with incompatible sizes at QVMatrix::dotProduct(const QVMatrix &matrix)." << std::endl
00074                         << "\tVector size:\t" << size() << std::endl
00075                         << "\tMatrix dimentions:\t" << matrix.getRows() << "x" << matrix.getCols() << std::endl;
00076                 exit(1);
00077                 }
00078 
00079         return this->toRowMatrix().dotProduct(matrix).getRow(0);
00080         }
00081 
00082 QVVector QVVector::add(const QVVector &vector) const
00083         {
00084         Q_ASSERT(size() == vector.size());
00085 
00086         QVVector result(size());
00087         for (int i = 0; i < size(); i++)
00088                 result[i] = at(i) + vector[i];
00089 
00090         return result;
00091         }
00092 
00093 QVVector QVVector::substract(const QVVector &vector) const
00094         {
00095         Q_ASSERT(size() == vector.size());
00096 
00097         QVVector result(size());
00098         for (int i = 0; i < size(); i++)
00099                 result[i] = at(i) - vector[i];
00100 
00101         return result;
00102         }
00103 
00104 bool QVVector::equals(const QVVector &vector) const
00105         {
00106         if (size() != vector.size())
00107                 return false;
00108 
00109         for (int i = 0; i < size(); i++)
00110                 if (at(i) != vector[i])
00111                         return false;
00112 
00113         return true;
00114         }
00115 
00116 QVMatrix QVVector::crossProductMatrix() const
00117         {
00118         Q_ASSERT(size() == 3);
00119 
00120         QVMatrix result(3,3);
00121         result(0,0) = 0;        result(0,1) = -at(2);   result(0,2) = at(1);
00122         result(1,0) = at(2);    result(1,1) = 0;        result(1,2) = -at(0);
00123         result(2,0) = -at(1);   result(2,1) = at(0);    result(2,2) = 0;
00124 
00125         return result;
00126         }
00127 
00128 QVMatrix QVVector::toRowMatrix() const
00129         {
00130         QVMatrix result(1,size());
00131         result.setRow(0,*this);
00132         return result;
00133         }
00134 
00135 QVMatrix QVVector::toColumnMatrix() const
00136         {
00137         QVMatrix result(size(),1);
00138         result.setCol(0,*this);
00139         return result;
00140         }
00141 
00142 
00143 const QVVector QVVector::gaussianVector(const int radius, const double sigma)
00144         {
00145         float kernelSum=0.0;
00146         QVVector result(2*radius+1);
00147         for (int j=-radius;j<=radius;j++)
00148                 {
00149                 result[j+radius] = (float)expf(-(double)j*j/2.0/sigma/sigma);
00150                 kernelSum += result[j+radius];
00151                 }
00152 
00153         for (int j=-radius;j<=radius;j++)
00154                 result[j+radius] /= kernelSum;
00155 
00156         return result;
00157         }
00158 
00159 const QVVector QVVector::homogeneousCoordinates(const QPointF &point)
00160         {
00161         QVVector result(3, 1);
00162         result[0] = point.x(); result[1] = point.y();
00163         return result;
00164         }
00165 
00167 
00168 double QVVector::max() const
00169         {
00170         double result = operator[](0);
00171         for (int i = 0;  i < size(); i++)
00172                 result = MAX(operator[](i), result);
00173         return result;
00174         }
00175 
00176 double QVVector::min() const
00177         {
00178         double result = operator[](0);
00179         for (int i = 0;  i < size(); i++)
00180                 result = MIN(operator[](i), result);
00181         return result;
00182         }
00183 
00184 double QVVector::mean() const
00185         {
00186         double accum = 0;
00187         foreach(double value, *this)
00188                 accum += value;
00189                 
00190         return accum / (double) size();
00191         }
00192 
00193 double QVVector::variance() const
00194         {
00195         const double avg = mean();
00196         double accum = 0;
00197         foreach(double value, *this)
00198                 accum += POW2(value - avg);
00199                 
00200         return accum / (double) (size()+1);
00201         }
00202 
00203 std::ostream& operator << ( std::ostream &os, const QVVector &vector )
00204         {
00205         const int size = vector.size();
00206 
00207         os << "QVVector (" << size << ") [ ";
00208 
00209         for (int i = 0; i < size; i++)
00210                 os << qPrintable(QString("%1").arg(vector[i], -8, 'f', 6)) << " ";
00211 
00212         os << "]";
00213         return os;
00214         }
00215 
00216 uint qHash(const QVVector &vector)
00217         {
00218         const int size = vector.size();
00219         double accum = 0;
00220         for (int i = 0; i < size; i++)
00221                 accum += vector[i] / vector[size-i-1];
00222 
00223         return (uint) ((100000 * accum) / ((double) size));
00224         }
00225 



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