OSG::Vector< ValueTypeT, SizeI > Class Template Reference
[Base, Objects, libOSGBase]

01261                                       :
01262     Inherited()
01263 {
01264     for(UInt32 i = 0; i < Self::_uiSize; i++)
01265     {
01266         Self::_values[i] = TypeTraits<ValueTypeT>::getZeroElement();
01267     }
01268 }

01278                                                          :
01279     Inherited(pVals)
01280 {
01281 }

01290                                                    :
01291     Inherited(pVals)
01292 {
01293 }

01299                                                                        :
01300
01301     Inherited(pnt)
01302 {
01303 }

01309                                                                         :
01310
01311     Inherited(vec)
01312 {
01313 }

01327 {
01328     UInt32 i;
01329
01330     Self::_values[0] = rVal1;
01331
01332     for(i = 1; i < Self::_uiSize; i++)
01333     {
01334         Self::_values[i] = TypeTraits<ValueTypeT>::getZeroElement();
01335     }
01336 }

01341                                                          :
01342
01343     Inherited(rVal1, rVal2)
01344 {
01345 }

01351                                                          :
01352
01353     Inherited(rVal1, rVal2, rVal3)
01354 {
01355 }

01362                                                          :
01363
01364     Inherited(rVal1, rVal2, rVal3, rVal4)
01365 {
01366 }

01375 {
01376 }

01405 {
01406     return osgSqrt(Self::squareLength());
01407 }

01387 {
01388     RealReturnType rTmpVal = RealReturnType(Self::_values[0] *
01389                                             Self::_values[0] );
01390
01391     for(UInt32 i = 1; i < Self::_uiSize; i++)
01392     {
01393         rTmpVal += Self::_values[i] * Self::_values[i];
01394     }
01395
01396     return rTmpVal;
01397 }

01415 {
01416     ValueTypeT rLength = ValueTypeT(length());
01417
01418     if(osgAbs(rLength) < Eps)
01419     {
01420         rLength = TypeTraits<ValueTypeT>::getOneElement();
01421     }
01422     else
01423     {
01424         rLength = TypeTraits<ValueTypeT>::getOneElement() / rLength;
01425     }
01426
01427     for(UInt32 i = 0; i < Self::_uiSize; i++)
01428     {
01429         Self::_values[i] *= rLength;
01430     }
01431 }

01445 {
01446     Vector<ValueTypeT, SizeI> returnValue;
01447
01448     if(Self::_uiSize >= 3)
01449     {
01450         returnValue[0] =
01451             Self::_values[1] * vec._values[2] -
01452             Self::_values[2] * vec._values[1];
01453         returnValue[1] =
01454             Self::_values[2] * vec._values[0] -
01455             Self::_values[0] * vec._values[2];
01456         returnValue[2] =
01457             Self::_values[0] * vec._values[1] -
01458             Self::_values[1] * vec._values[0];
01459     }
01460     else
01461     {
01462         // Must be changed
01463         fprintf(stderr, "cross only implemented for size 3\n");
01464     }
01465
01466     return returnValue;
01467 }

01473 {
01474     return this->cross(vec);
01475 }

01484 {
01485     if(Self::_uiSize >= 3)
01486     {
01487         ValueTypeT rTmp[2];
01488
01489         rTmp[0] =
01490             Self::_values[1] * vec._values[2] -
01491             Self::_values[2] * vec._values[1];
01492         rTmp[1] =
01493             Self::_values[2] * vec._values[0] -
01494             Self::_values[0] * vec._values[2];
01495
01496         Self::_values[2] =
01497             Self::_values[0] * vec._values[1] -
01498             Self::_values[1] * vec._values[0];
01499
01500         Self::_values[0] = rTmp[0];
01501         Self::_values[1] = rTmp[1];
01502     }
01503     else
01504     {
01505         // Must be changed
01506         fprintf(stderr, "crossThis only available for size 3\n");
01507     }
01508 }

01519 {
01520     ValueTypeT rTmpVal = Self::_values[0] * vec._values[0];
01521
01522     for(UInt32 i = 1; i < Self::_uiSize; i++)
01523     {
01524         rTmpVal += Self::_values[i] * vec._values[i];
01525     }
01526
01527     return rTmpVal;
01528 }

01533 {
01534     return this->dot(vec);
01535 }

01540 {
01541     ValueTypeT rTmpVal = Self::_values[0] * pnt[0];
01542
01543     for(UInt32 i = 1; i < Self::_uiSize; i++)
01544     {
01545         rTmpVal += Self::_values[i] * pnt[i];
01546     }
01547
01548     return rTmpVal;
01549 }

01554 {
01555      return this->dot(pnt);
01556 }

01564 {
01565     RealReturnType returnValue;
01566
01567     if(Self::isZero() || vec.isZero())
01568     {
01569         returnValue = TypeTraits<RealReturnType>::getZeroElement();
01570     }
01571     else
01572     {
01573         returnValue  = dot(vec);
01574         returnValue /= (length() * vec.length());
01575
01576         if((returnValue - Eps) < -1.)
01577         {
01578             returnValue = Pi;
01579         }
01580         else if((returnValue + Eps) > 1.)
01581         {
01582             returnValue = TypeTraits<RealReturnType>::getZeroElement();
01583         }
01584         else
01585         {
01586             returnValue = osgACos(returnValue);
01587         }
01588     }
01589
01590     return returnValue;
01591 }

01597 {
01598     RealReturnType rDot       = this ->dot(toVec);
01599     RealReturnType rSquareDot = toVec .dot(toVec);
01600
01601     if(rSquareDot > Eps)
01602     {
01603         rDot /= rSquareDot;
01604
01605         if(osgAbs(rDot) > Eps)
01606         {
01607             *this  = toVec;
01608             *this *= ValueTypeT(rDot);
01609         }
01610         else
01611         {
01612             this->setNull();
01613             rDot = TypeTraits<RealReturnType>::getZeroElement();
01614         }
01615     }
01616     else
01617     {
01618         rDot = TypeTraits<RealReturnType>::getOneElement();
01619     }
01620
01621     return rDot;
01622 }

01640 {
01641     return *(static_cast<PointType *>(this));
01642 }

01630 {
01631     return *(static_cast<const PointType *>(this));
01632 }

01648 {
01649     return *this;
01650 }

01656 {
01657     return (*this);
01658 }

01669 {
01670     Vector<ValueTypeT, SizeI> returnValue;
01671
01672     for(UInt32 i = 0; i < Self::_uiSize; i++)
01673     {
01674         returnValue[i] = Self::_values[i] - vec[i];
01675     }
01676
01677     return returnValue;
01678 }

01686 {
01687     Vector<ValueTypeT, SizeI> returnValue;
01688
01689     for(UInt32 i = 0; i < Self::_uiSize; i++)
01690     {
01691         returnValue[i] = Self::_values[i] + vec[i];
01692     }
01693
01694     return returnValue;
01695 }

01704 {
01705     Vector<ValueTypeT, SizeI> returnValue;
01706
01707     for(UInt32 i = 0; i < Self::_uiSize; i++)
01708     {
01709         returnValue[i] = Self::_values[i] * rVal;
01710     }
01711
01712     return returnValue;
01713 }

01721 {
01722     Vector<ValueTypeT, SizeI> returnValue;
01723
01724     for(UInt32 i = 0; i < Self::_uiSize; i++)
01725     {
01726         returnValue._values[i] = - Self::_values[i];
01727     }
01728
01729     return returnValue;
01730 }

01739 {
01740     if(this == &source)
01741         return *this;
01742
01743     *(static_cast<Inherited *>(this)) =
01744         static_cast<const Inherited &>(source);
01745
01746     return *this;
01747 }

01755 {
01756     bool ret = false;
01757
01758     for(UInt32 i = 0; i < Self::_uiSize; i++)
01759     {
01760         if(Self::_values[i] > other._values[i])
01761         {
01762             break;
01763         }
01764         if(Self::_values[i] < other._values[i])
01765         {
01766             ret = true;
01767             break;
01768         }
01769     }
01770
01771     return ret;
01772 }

01779 {
01780     return Self::equals(other, ValueTypeT(Eps));
01781 }

01788 {
01789     return ! (*this == other);
01790 }