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

01371                                                                     : 
01372     Inherited()
01373 {
01374     for(UInt32 i = 0; i < Self::_uiSize; i++)
01375     {
01376         Self::_values[i] = TypeTraits<ValueTypeT>::getZeroElement();
01377     }
01378 }

01389                                                                            :
01390     Inherited(pVals)
01391 {
01392 }

01402                                                                      : 
01403     Inherited(pVals)
01404 {
01405 }

00619     {
00620         if(Self::_uiSize <= VectorInterface<EVT,EST>::_uiSize)
00621         {
00622             for(UInt32 i = 0; i < Self::_uiSize; i++)
00623             {
00624                 Self::_values[i] = vec.getValues()[i];
00625             }
00626         }
00627         else
00628         {
00629             UInt32 i;
00630             for(i = 0; i < VectorInterface<EVT,EST>::_uiSize; i++)
00631             {
00632                 Self::_values[i] = vec.getValues()[i];
00633             }
00634             for(i = VectorInterface<EVT,EST>::_uiSize; i < Self::_uiSize; i++)
00635             {
00636                 Self::_values[i] = TypeTraits<ValueTypeT>::getZeroElement();
00637             }
00638         }
00639     }

00646     {
00647         if(Self::_uiSize <= PointInterface<EVT,EST>::_uiSize)
00648         {
00649             for(UInt32 i = 0; i < Self::_uiSize; i++)
00650             {
00651                 Self::_values[i] = vec.getValues()[i];
00652             }
00653         }
00654         else
00655         {
00656             UInt32 i;
00657             for(i = 0; i < PointInterface<EVT,EST>::_uiSize; i++)
00658             {
00659                 Self::_values[i] = vec.getValues()[i];
00660             }
00661             for(i = PointInterface<EVT,EST>::_uiSize; i < Self::_uiSize; i++)
00662             {
00663                 Self::_values[i] = TypeTraits<ValueTypeT>::getZeroElement();
00664             }
00665         }
00666     }

01469                                    : 
01470 
01471     Inherited(source)
01472 {
01473 }

01496                                                                             :
01497 
01498     Inherited(rVal1, rVal2)
01499 {
01500 }

01507                                                                             :
01508 
01509     Inherited(rVal1, rVal2, rVal3)
01510 {
01511 }

01519                                                                             :
01520 
01521     Inherited(rVal1, rVal2, rVal3, rVal4)
01522 {
01523 }

01533 {
01534 }

01799 {
01800     return *(static_cast<const PntInterface *>(this));
01801 }

01811 {
01812     return *(static_cast<PntInterface *>(this));
01813 }

01604 {
01605     VectorInterface<ValueTypeT, StorageInterfaceT> returnValue;
01606 
01607     if(Self::_uiSize >= 3)
01608     {
01609         returnValue[0] =
01610             Self::_values[1] * vec._values[2] - 
01611             Self::_values[2] * vec._values[1];
01612         returnValue[1] =
01613             Self::_values[2] * vec._values[0] - 
01614             Self::_values[0] * vec._values[2];
01615         returnValue[2] =
01616             Self::_values[0] * vec._values[1] - 
01617             Self::_values[1] * vec._values[0];
01618     }
01619     else
01620     {
01621         // Must be changed
01622         fprintf(stderr, "cross only implemented for size 3\n");
01623     }
01624 
01625     return returnValue;
01626 }

01645 {
01646     if(Self::_uiSize >= 3)
01647     {
01648         ValueTypeT rTmp[2];
01649 
01650         rTmp[0] = 
01651             Self::_values[1] * vec._values[2] - 
01652             Self::_values[2] * vec._values[1];
01653         rTmp[1] = 
01654             Self::_values[2] * vec._values[0] - 
01655             Self::_values[0] * vec._values[2];
01656 
01657         Self::_values[2] =
01658             Self::_values[0] * vec._values[1] -
01659             Self::_values[1] * vec._values[0];
01660 
01661         Self::_values[0] = rTmp[0];
01662         Self::_values[1] = rTmp[1];
01663     }
01664     else
01665     {
01666         // Must be changed
01667         fprintf(stderr, "crossThis only available for size 3\n");
01668     }
01669 }

00959 {
00960     return osgSqrt(dist2(vec));
00961 }

00971 {
00972     RealReturnType returnValue = 0;
00973     RealReturnType tmp;
00974 
00975     for(UInt32 i = 0; i < Self::_uiSize; i++)
00976     {
00977         tmp = Self::_values[i] - vec._values[i];
00978         
00979         returnValue += tmp * tmp;
00980     }
00981 
00982     return returnValue;
00983 }

01704 {
01705     ValueTypeT rTmpVal = Self::_values[0] * pnt[0];
01706 
01707     for(UInt32 i = 1; i < Self::_uiSize; i++)
01708     {
01709         rTmpVal += Self::_values[i] * pnt[i];
01710     }
01711 
01712     return rTmpVal;
01713 }

01681 {
01682     ValueTypeT rTmpVal = Self::_values[0] * vec._values[0];
01683 
01684     for(UInt32 i = 1; i < Self::_uiSize; i++)
01685     {
01686         rTmpVal += Self::_values[i] * vec._values[i];
01687     }
01688 
01689     return rTmpVal;
01690 }

01730 {
01731     RealReturnType returnValue;
01732 
01733     if(Self::isZero() || vec.isZero())
01734     {
01735         returnValue = TypeTraits<RealReturnType>::getZeroElement();
01736     }
01737     else
01738     {
01739         returnValue  = dot(vec);
01740         returnValue /= (length() * vec.length());
01741 
01742         if((returnValue - Eps) < -1.)
01743         {
01744             returnValue = Pi;
01745         }
01746         else if((returnValue + Eps) > 1.)
01747         {
01748             returnValue = TypeTraits<RealReturnType>::getZeroElement();
01749         }
01750         else
01751         {
01752             returnValue = osgACos(returnValue);
01753         }
01754     }
01755 
01756     return returnValue;
01757 }

00913 {
00914     bool returnValue = true;
00915 
00916     for(UInt32 i = 0; i < Self::_uiSize; i++)
00917     {
00918         returnValue &= 
00919             ( (Self::_values[i] - vec  ._values[i] <= tolerance) &&
00920               (vec  ._values[i] - Self::_values[i] <= tolerance));
00921     }
00922 
00923     return returnValue;
00924 }

00869 {
00870     return Self::_values;
00871 }

00859 {
00860     return Self::_values;
00861 }

00882 {
00883     bool returnValue = true;
00884 
00885     for(UInt32 i = 0; i < Self::_uiSize; i++)
00886     {
00887         returnValue &= ((Self::_values[i] <=  Eps) &&
00888                         (Self::_values[i] >= -Eps));
00889     }
00890 
00891     return returnValue;
00892 }

01563 {
01564     return osgSqrt(Self::squareLength());
01565 }

00993 {
00994     RealReturnType returnValue = TypeTraits<RealReturnType>::getMin();
00995 
00996     for(UInt32 i = 0; i < Self::_uiSize; i++)
00997     {
00998         if(Self::_values[i] > returnValue)
00999             returnValue = Self::_values[i];
01000     }
01001 
01002     return returnValue;
01003 }

00899 {
00900     for(UInt32 i = 0; i < Self::_uiSize; i++)
00901     {
00902         Self::_values[i] = -Self::_values[i];
00903     }
00904 }

01573 {
01574     ValueTypeT rLength = ValueTypeT(length());
01575 
01576     if(osgAbs(rLength) < Eps)
01577     {
01578         rLength = TypeTraits<ValueTypeT>::getOneElement();
01579     }
01580     else
01581     {
01582         rLength = TypeTraits<ValueTypeT>::getOneElement() / rLength;
01583     }
01584 
01585     for(UInt32 i = 0; i < Self::_uiSize; i++)
01586     {
01587         Self::_values[i] *= rLength;
01588     }
01589 }

01878 {
01879     VectorInterface<ValueTypeT, StorageInterfaceT> returnValue;
01880 
01881     for(UInt32 i = 0; i < StorageInterfaceT::_uiSize; i++)
01882     {
01883         returnValue[i] = Self::_values[i] * rVal;
01884     }
01885 
01886     return returnValue;
01887 }

01719 {
01720      return this->dot(pnt);
01721 }

01696 {
01697     return this->dot(vec);
01698 }

01014 {
01015     for(UInt32 i = 0; i < Self::_uiSize; i++)
01016     {
01017         Self::_values[i] *= val;
01018     }
01019 }