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

00363                                                                   : 
00364     Inherited()
00365 {
00366 }

00376                                                                          : 
00377     Inherited()
00378 {
00379     if(pVals == NULL)
00380     {
00381         for(UInt32 i = 0; i < Self::_uiSize; i++)
00382         {
00383             Self::_values[i] = TypeTraits<ValueTypeT>::getZeroElement();
00384         }
00385     }
00386     else
00387     {
00388         for(UInt32 i = 0; i < Self::_uiSize; i++)
00389         {
00390             Self::_values[i] = pVals[i];
00391         }
00392     }
00393 }

00403                                                                    : 
00404     Inherited()
00405 {
00406     if(pVals == NULL)
00407     {
00408         for(UInt32 i = 0; i < Self::_uiSize; i++)
00409         {
00410             Self::_values[i] = TypeTraits<ValueTypeT>::getZeroElement();
00411         }
00412     }
00413     else
00414     {
00415         for(UInt32 i = 0; i < Self::_uiSize; i++)
00416         {
00417             Self::_values[i] = pVals[i];
00418         }
00419     }
00420 }

00378     {
00379         if(Self::_uiSize <= PointInterface<EVT,EST>::_uiSize)
00380         {
00381             for(UInt32 i = 0; i < Self::_uiSize; i++)
00382             {
00383                 Self::_values[i] = vec.getValues()[i];
00384             }
00385         }
00386         else
00387         {
00388             UInt32 i;
00389             for(i = 0; i < PointInterface<EVT,EST>::_uiSize; i++)
00390             {
00391                 Self::_values[i] = vec.getValues()[i];
00392             }
00393             for(i = PointInterface<EVT,EST>::_uiSize; i < Self::_uiSize; i++)
00394             {
00395                 Self::_values[i] = TypeTraits<ValueTypeT>::getZeroElement();
00396             }
00397         }
00398     }

00487                                   : 
00488 
00489     Inherited()
00490 {
00491     for(UInt32 i = 0; i < Self::_uiSize; i++)
00492     {
00493         Self::_values[i] = source._values[i];
00494     }
00495 }

00526                                                                           : 
00527     Inherited()
00528 {
00529     Self::_values[0] = rVal1;
00530 
00531     if(Self::_uiSize == 2)
00532     {
00533         Self::_values[1] = rVal2;
00534     }
00535     else if(Self::_uiSize >= 3)
00536     {
00537         Self::_values[1] = rVal2;
00538 
00539         for(UInt32 i = 2; i < Self::_uiSize; i++)
00540         {
00541             Self::_values[i] = TypeTraits<ValueTypeT>::getZeroElement();
00542         }
00543     }
00544 }

00559                                                                           : 
00560     Inherited()
00561 {
00562     Self::_values[0] = rVal1;
00563 
00564     if(Self::_uiSize == 2)
00565     {
00566         Self::_values[1] = rVal2;
00567     }
00568     else if(Self::_uiSize == 3)
00569     {
00570         Self::_values[1] = rVal2;
00571         Self::_values[2] = rVal3;
00572     }
00573     else if(Self::_uiSize >= 4)
00574     {
00575         Self::_values[1] = rVal2;
00576         Self::_values[2] = rVal3;
00577 
00578         for(UInt32 i = 3; i < Self::_uiSize; i++)
00579         {
00580             Self::_values[i] = TypeTraits<ValueTypeT>::getZeroElement();
00581         }
00582     }
00583 }

00599                                                                           : 
00600     Inherited()
00601 {
00602     Self::_values[0] = rVal1;
00603 
00604     if(Self::_uiSize == 2)
00605     {
00606         Self::_values[1] = rVal2;
00607     }
00608     else if(Self::_uiSize == 3)
00609     {
00610         Self::_values[1] = rVal2;
00611         Self::_values[2] = rVal3;
00612     }
00613     else if(Self::_uiSize == 4)
00614     {
00615         Self::_values[1] = rVal2;
00616         Self::_values[2] = rVal3;
00617         Self::_values[3] = rVal4;
00618     }
00619     else if(Self::_uiSize >= 5)
00620     {
00621         Self::_values[1] = rVal2;
00622         Self::_values[2] = rVal3;
00623         Self::_values[3] = rVal4;
00624 
00625         for(UInt32 i = 4; i < Self::_uiSize; i++)
00626         {
00627             Self::_values[i] = TypeTraits<ValueTypeT>::getZeroElement();
00628         }
00629     }
00630 }

00642 {
00643 }

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 }

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 }

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 }

01096 {
01097     PointInterface<ValueTypeT, StorageInterfaceT> returnValue;
01098 
01099     for(UInt32 i = 0; i < StorageInterfaceT::_uiSize; i++)
01100     {
01101         returnValue[i] = Self::_values[i] * rVal;
01102     }
01103 
01104     return returnValue;
01105 }

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

01263 {
01264     return ! (*this == other);
01265 }

01060 {
01061     PointInterface<ValueTypeT, StorageInterfaceT> returnValue;
01062 
01063     for(UInt32 i = 0; i < StorageInterfaceT::_uiSize; i++)
01064     {
01065         returnValue[i] = Self::_values[i] + vec[i];
01066     }
01067 
01068     return returnValue;
01069 }

01130 {
01131     for(UInt32 i = 0; i < Self::_uiSize; i++)
01132     {
01133         Self::_values[i] += vec._values[i];
01134     }
01135 }

01113 {
01114     PointInterface<ValueTypeT, StorageInterfaceT> returnValue;
01115 
01116     for(UInt32 i = 0; i < Self::_uiSize; i++)
01117     {
01118         returnValue._values[i] = - Self::_values[i];
01119     }
01120 
01121     return returnValue;
01122 }

01078 {
01079     PointInterface<ValueTypeT, StorageInterfaceT> returnValue;
01080 
01081     for(UInt32 i = 0; i < StorageInterfaceT::_uiSize; i++)
01082     {
01083         returnValue[i] = Self::_values[i] - vec[i];
01084     }
01085 
01086     return returnValue;
01087 }

01042 {
01043     VecInterface returnValue(*this);
01044 
01045     for(UInt32 i = 0; i < Self::_uiSize; i++)
01046     {
01047         returnValue[i] -= vec[i];
01048     }
01049 
01050     return returnValue;
01051 }

01143 {
01144     for(UInt32 i = 0; i < Self::_uiSize; i++)
01145     {
01146         Self::_values[i] -= vec._values[i];
01147     }
01148 }

01027 {
01028     for(UInt32 i = 0; i < Self::_uiSize; i++)
01029     {
01030         Self::_values[i] /= val;
01031     }
01032 }

01227 {
01228     bool ret = false;
01229 
01230     for(UInt32 i = 0; i < Self::_uiSize; i++)
01231     {
01232         if(Self::_values[i] > other._values[i])
01233         {
01234             break;
01235         }
01236 
01237         if(Self::_values[i] < other._values[i])
01238         {
01239             ret = true;
01240             break;
01241         }
01242     }
01243 
01244     return ret;
01245 }

01213 {
01214     PointInterface<ValueTypeT, 
01215                    StorageInterfaceT>::error_cannot_assign_vector;
01216 
01217     return *this;
01218 }

01196 {
01197     if(this == &source)
01198         return *this;
01199 
01200     for(UInt32 i = 0; i < Self::_uiSize; i++)
01201     {
01202         Self::_values[i] = source._values[i];
01203     }
01204 
01205     return *this;
01206 }

01253 {
01254     return Self::equals(other, ValueTypeT(Eps));
01255 }

01166 {
01167     return Self::_values[uiVal];
01168 }

01157 {
01158     return Self::_values[uiVal];
01159 }

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

00845 {
00846     setValueFromCString(szString);
00847 }

00837 {
00838     setValueFromCString(szString);
00839 }

00748 {
00749     setValue(static_cast<const ValueTypeT *>(pVals));
00750 }

00735 {
00736     for(UInt32 i = 0; i < Self::_uiSize; i++)
00737     {
00738         Self::_values[i] = pVals[i];
00739     }
00740 }

00441     {
00442         for(UInt32   i = 0;
00443                      i < (Self::_uiSize < PointInterface<EVT,EST>::_uiSize ? 
00444                           Self::_uiSize : PointInterface<EVT,EST>::_uiSize);
00445                    ++i)
00446         {
00447             Self::_values[i] = vec.getValues()[i];
00448         }
00449     }

00674 {
00675     for(UInt32 i = 0; i < Self::_uiSize; i++)
00676     {
00677         Self::_values[i] = vec._values[i];
00678     }
00679 }

00828 {
00829     setValueFromCString(static_cast<const Char8 *>(szString));
00830 }

00761 {
00762     UInt32 i;
00763     UInt32 numOfToken = Self::_uiSize;
00764 
00765     Char8 *c      = const_cast<Char8 *>(szString);
00766     Char8 *tokenC = 0;
00767 
00768     Char8  token[256];
00769 
00770     if(szString == NULL || (*szString) == '\0')
00771     {
00772         for(i = 0; i < Self::_uiSize; i++)
00773             Self::_values[i] = TypeTraits<ValueTypeT>::getZeroElement();
00774 
00775         return;
00776     }
00777 
00778     for (i = 0; i < numOfToken; c++)
00779     {
00780         switch (*c)
00781         {
00782             case '\0':
00783                 if(tokenC)
00784                 {
00785                     *tokenC = 0;
00786                     Self::_values[i++] =
00787                         TypeTraits<ValueTypeT>::getFromCString(token);
00788                 }
00789 
00790                 while (i < numOfToken)
00791                 {
00792                     Self::_values[i++] =
00793                         TypeTraits<ValueTypeT>::getZeroElement();
00794                 }
00795                 break;
00796 
00797             case ' ' :
00798             case '\t':
00799             case '\n':
00800             case ',':
00801                 if(tokenC)
00802                 {
00803                     *tokenC = 0;
00804                     Self::_values[i++] =
00805                         TypeTraits<ValueTypeT>::getFromCString(token);
00806                     tokenC = 0;
00807                 }
00808                 break;
00809             default:
00810                 if(!tokenC)
00811                 {
00812                     tokenC = token;
00813                 }
00814                 *tokenC++ = *c;
00815                 break;
00816         }
00817     }
00818 }

00946 {
00947     return *(static_cast<const VecInterface *>(this));
00948 }