OSG::VectorInterface< ValueTypeT, StorageInterfaceT > Class Template Reference

01340                                                                     : 
01341     Inherited()
01342 {
01343     for(UInt32 i = 0; i < Self::_uiSize; i++)
01344     {
01345         Self::_values[i] = TypeTraits<ValueTypeT>::getZeroElement();
01346     }
01347 }

01358                                                                            :
01359     Inherited(pVals)
01360 {
01361 }

01371                                                                      : 
01372     Inherited(pVals)
01373 {
01374 }

01381                                                                 :
01382 
01383     Inherited(vec)
01384 {
01385 }

01392                                                                  :
01393 
01394     Inherited(vec)
01395 {
01396 }

01402                                    : 
01403 
01404     Inherited(source)
01405 {
01406 }

01412 {
01413     UInt32 i;
01414 
01415     Self::_values[0] = rVal1;
01416 
01417     for(i = 1; i < Self::_uiSize; i++)
01418     {
01419         Self::_values[i] = TypeTraits<ValueTypeT>::getZeroElement();
01420     }
01421 }

01427                                                                             :
01428 
01429     Inherited(rVal1, rVal2)
01430 {
01431 }

01438                                                                             :
01439 
01440     Inherited(rVal1, rVal2, rVal3)
01441 {
01442 }

01450                                                                             :
01451 
01452     Inherited(rVal1, rVal2, rVal3, rVal4)
01453 {
01454 }

01464 {
01465 }

01494 {
01495     return osgSqrt(Self::squareLength());
01496 }

01476 {
01477     RealReturnType rTmpVal = RealReturnType(Self::_values[0] * 
01478                                             Self::_values[0] );
01479 
01480     for(UInt32 i = 1; i < Self::_uiSize; i++)
01481     {
01482         rTmpVal += Self::_values[i] * Self::_values[i];
01483     }
01484 
01485     return rTmpVal;
01486 }

01504 {
01505     ValueTypeT rLength = ValueTypeT(length());
01506 
01507     if(osgAbs(rLength) < Eps)
01508     {
01509         rLength = TypeTraits<ValueTypeT>::getOneElement();
01510     }
01511     else
01512     {
01513         rLength = TypeTraits<ValueTypeT>::getOneElement() / rLength;
01514     }
01515 
01516     for(UInt32 i = 0; i < Self::_uiSize; i++)
01517     {
01518         Self::_values[i] *= rLength;
01519     }
01520 }

01535 {
01536     VectorInterface<ValueTypeT, StorageInterfaceT> returnValue;
01537 
01538     if(Self::_uiSize >= 3)
01539     {
01540         returnValue[0] =
01541             Self::_values[1] * vec._values[2] - 
01542             Self::_values[2] * vec._values[1];
01543         returnValue[1] =
01544             Self::_values[2] * vec._values[0] - 
01545             Self::_values[0] * vec._values[2];
01546         returnValue[2] =
01547             Self::_values[0] * vec._values[1] - 
01548             Self::_values[1] * vec._values[0];
01549     }
01550     else
01551     {
01552         // Must be changed
01553         fprintf(stderr, "cross only implemented for size 3\n");
01554     }
01555 
01556     return returnValue;
01557 }

01564 {
01565     return this->cross(vec);
01566 }

01576 {
01577     if(Self::_uiSize >= 3)
01578     {
01579         ValueTypeT rTmp[2];
01580 
01581         rTmp[0] = 
01582             Self::_values[1] * vec._values[2] - 
01583             Self::_values[2] * vec._values[1];
01584         rTmp[1] = 
01585             Self::_values[2] * vec._values[0] - 
01586             Self::_values[0] * vec._values[2];
01587 
01588         Self::_values[2] =
01589             Self::_values[0] * vec._values[1] -
01590             Self::_values[1] * vec._values[0];
01591 
01592         Self::_values[0] = rTmp[0];
01593         Self::_values[1] = rTmp[1];
01594     }
01595     else
01596     {
01597         // Must be changed
01598         fprintf(stderr, "crossThis only available for size 3\n");
01599     }
01600 }

01612 {
01613     ValueTypeT rTmpVal = Self::_values[0] * vec._values[0];
01614 
01615     for(UInt32 i = 1; i < Self::_uiSize; i++)
01616     {
01617         rTmpVal += Self::_values[i] * vec._values[i];
01618     }
01619 
01620     return rTmpVal;
01621 }

01627 {
01628     return this->dot(vec);
01629 }

01635 {
01636     ValueTypeT rTmpVal = Self::_values[0] * pnt[0];
01637 
01638     for(UInt32 i = 1; i < Self::_uiSize; i++)
01639     {
01640         rTmpVal += Self::_values[i] * pnt[i];
01641     }
01642 
01643     return rTmpVal;
01644 }

01650 {
01651      return this->dot(pnt);
01652 }

01661 {
01662     RealReturnType returnValue;
01663 
01664     if(Self::isZero() || vec.isZero())
01665     {
01666         returnValue = TypeTraits<RealReturnType>::getZeroElement();
01667     }
01668     else
01669     {
01670         returnValue  = dot(vec);
01671         returnValue /= (length() * vec.length());
01672 
01673         if((returnValue - Eps) < -1.)
01674         {
01675             returnValue = Pi;
01676         }
01677         else if((returnValue + Eps) > 1.)
01678         {
01679             returnValue = TypeTraits<RealReturnType>::getZeroElement();
01680         }
01681         else
01682         {
01683             returnValue = osgACos(returnValue);
01684         }
01685     }
01686 
01687     return returnValue;
01688 }

01695 {
01696     RealReturnType rDot       = dot(toVec);
01697     RealReturnType rSquareDot = toVec.dot(toVec);
01698 
01699     if(rSquareDot > Eps)
01700     {
01701         rDot /= rSquareDot;
01702 
01703         if(osgAbs(rDot) > Eps)
01704         {
01705             *this  = toVec;
01706             *this *= ValueTypeT(rDot);
01707         }
01708         else
01709         {
01710             this->setNull();
01711             rDot = TypeTraits<RealReturnType>::getZeroElement();
01712         }
01713     }
01714     else
01715     {
01716         rDot = TypeTraits<RealReturnType>::getOneElement();
01717     }
01718 
01719     return rDot;
01720 }

01742 {
01743     return *(static_cast<PntInterface *>(this));
01744 }

01730 {
01731     return *(static_cast<const PntInterface *>(this));
01732 }

01750 {
01751     return *this;
01752 }

01758 {
01759     return (*this);
01760 }

01772 {
01773     VectorInterface<ValueTypeT, StorageInterfaceT> returnValue;
01774 
01775     for(UInt32 i = 0; i < StorageInterfaceT::_uiSize; i++)
01776     {
01777         returnValue[i] = Self::_values[i] - vec[i];
01778     }
01779 
01780     return returnValue;
01781 }

01790 {
01791     VectorInterface<ValueTypeT, StorageInterfaceT> returnValue;
01792 
01793     for(UInt32 i = 0; i < StorageInterfaceT::_uiSize; i++)
01794     {
01795         returnValue[i] = Self::_values[i] + vec[i];
01796     }
01797 
01798     return returnValue;
01799 }

01809 {
01810     VectorInterface<ValueTypeT, StorageInterfaceT> returnValue;
01811 
01812     for(UInt32 i = 0; i < StorageInterfaceT::_uiSize; i++)
01813     {
01814         returnValue[i] = Self::_values[i] * rVal;
01815     }
01816 
01817     return returnValue;
01818 }

01826 {
01827     VectorInterface<ValueTypeT, StorageInterfaceT> returnValue;
01828 
01829     for(UInt32 i = 0; i < Self::_uiSize; i++)
01830     {
01831         returnValue._values[i] = - Self::_values[i];
01832     }
01833 
01834     return returnValue;
01835 }

01845 {
01846     if(this == &source)
01847         return *this;
01848 
01849     *(static_cast<Inherited *>(this)) = 
01850         static_cast<const Inherited &>(source);
01851 
01852     return *this;
01853 }

01862 {
01863     bool ret = false;
01864 
01865     for(UInt32 i = 0; i < Self::_uiSize; i++)
01866     {
01867         if(Self::_values[i] > other._values[i])
01868         {
01869             break;
01870         }
01871         if(Self::_values[i] < other._values[i])
01872         {
01873             ret = true;
01874             break;
01875         }
01876     }
01877 
01878     return ret;
01879 }

01887 {
01888     return Self::equals(other, ValueTypeT(Eps));
01889 }

01897 {
01898     return ! (*this == other);
01899 }

00650 {
00651     for(UInt32 i = 0; i < Self::_uiSize; i++)
00652     {
00653         Self::_values[i] = TypeTraits<ValueTypeT>::getZeroElement();
00654     }
00655 }