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

00367                                     :
00368     Inherited()
00369 {
00370 }

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

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

00429 {
00430     typedef Point<ValueType2T, Size2I> Point2T;
00431
00432     if(Self::_uiSize <= Point2T::_uiSize)
00433     {
00434         for(UInt32 i = 0; i < Self::_uiSize; i++)
00435         {
00436             Self::_values[i] = pnt.getValues()[i];
00437         }
00438     }
00439     else
00440     {
00441         UInt32 i;
00442         for(i = 0; i < Point2T::_uiSize; i++)
00443         {
00444             Self::_values[i] = pnt.getValues()[i];
00445         }
00446         for(i = Point2T::_uiSize; i < Self::_uiSize; i++)
00447         {
00448             Self::_values[i] = TypeTraits<ValueTypeT>::getZeroElement();
00449         }
00450     }
00451 }

00458 {
00459     typedef Vector<ValueType2T, Size2I> Vector2T;
00460
00461     if(Self::_uiSize <= Vector2T::_uiSize)
00462     {
00463         for(UInt32 i = 0; i < Self::_uiSize; i++)
00464         {
00465             Self::_values[i] = vec.getValues()[i];
00466         }
00467     }
00468     else
00469     {
00470         UInt32 i;
00471         for(i = 0; i < Vector2T::_uiSize; i++)
00472         {
00473             Self::_values[i] = vec.getValues()[i];
00474         }
00475         for(i = Vector2T::_uiSize; i < Self::_uiSize; i++)
00476         {
00477             Self::_values[i] = TypeTraits<ValueTypeT>::getZeroElement();
00478         }
00479     }
00480 }

00500 {
00501     UInt32 i;
00502
00503     Self::_values[0] = rVal1;
00504
00505     for(i = 1; i < Self::_uiSize; i++)
00506     {
00507         Self::_values[i] = TypeTraits<ValueTypeT>::getZeroElement();
00508     }
00509 }

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

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

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

00636 {
00637 }

00645 {
00646     for(UInt32 i = 0; i < Self::_uiSize; i++)
00647     {
00648         Self::_values[i] = TypeTraits<ValueTypeT>::getZeroElement();
00649     }
00650 }

00655 {
00656     for(UInt32 i = 0; i < Self::_uiSize; i++)
00657     {
00658         Self::_values[i] = pnt._values[i];
00659     }
00660 }

00682 {
00683     for(UInt32 i = 0; i < Self::_uiSize; i++)
00684     {
00685         Self::_values[i] = pVals[i];
00686     }
00687 }

00694 {
00695     setValue(static_cast<const ValueType *>(pVals));
00696 }

00705 {
00706     UInt32 i;
00707     UInt32 numOfToken = Self::_uiSize;
00708
00709     Char8 *c      = const_cast<Char8 *>(szString);
00710     Char8 *tokenC = 0;
00711
00712     Char8  token[256];
00713
00714     if(szString == NULL || (*szString) == '\0')
00715     {
00716         for(i = 0; i < Self::_uiSize; i++)
00717             Self::_values[i] = TypeTraits<ValueTypeT>::getZeroElement();
00718
00719         return;
00720     }
00721
00722     for (i = 0; i < numOfToken; c++)
00723     {
00724         switch (*c)
00725         {
00726             case '\0':
00727                 if(tokenC)
00728                 {
00729                     *tokenC = 0;
00730                     Self::_values[i++] =
00731                         TypeTraits<ValueTypeT>::getFromCString(token);
00732                 }
00733
00734                 while (i < numOfToken)
00735                 {
00736                     Self::_values[i++] =
00737                         TypeTraits<ValueTypeT>::getZeroElement();
00738                 }
00739                 break;
00740
00741             case ' ' :
00742             case '\t':
00743             case '\n':
00744             case ',':
00745                 if(tokenC)
00746                 {
00747                     *tokenC = 0;
00748                     Self::_values[i++] =
00749                         TypeTraits<ValueTypeT>::getFromCString(token);
00750                     tokenC = 0;
00751                 }
00752                 break;
00753             default:
00754                 if(!tokenC)
00755                 {
00756                     tokenC = token;
00757                 }
00758                 *tokenC++ = *c;
00759                 break;
00760         }
00761     }
00762 }

00771 {
00772     setValueFromCString(static_cast<const Char8 *>(szString));
00773 }

00779 {
00780     setValueFromCString(szString);
00781 }

00786 {
00787     setValueFromCString(szString);
00788 }

00799 {
00800     return Self::_values;
00801 }

00808 {
00809     return Self::_values;
00810 }

00820 {
00821     bool returnValue = true;
00822
00823     for(UInt32 i = 0; i < Self::_uiSize; i++)
00824     {
00825         returnValue &= ((Self::_values[i] <=  Eps) &&
00826                         (Self::_values[i] >= -Eps));
00827     }
00828
00829     return returnValue;
00830 }

00837 {
00838     for(UInt32 i = 0; i < Self::_uiSize; i++)
00839     {
00840         Self::_values[i] = -Self::_values[i];
00841     }
00842 }

00851 {
00852     bool returnValue = true;
00853
00854     for(UInt32 i = 0; i < Self::_uiSize; i++)
00855     {
00856         returnValue &=
00857             ( (Self::_values[i] - pnt  ._values[i] <= tolerance) &&
00858               (pnt  ._values[i] - Self::_values[i] <= tolerance));
00859     }
00860
00861     return returnValue;
00862 }

00870 {
00871     return *(static_cast<VectorType *>(this));
00872 }

00880 {
00881     return *(static_cast<const VectorType *>(this));
00882 }

00891 {
00892     return osgSqrt(dist2(pnt));
00893 }

00902 {
00903     RealReturnType returnValue = 0;
00904     RealReturnType tmp;
00905
00906     for(UInt32 i = 0; i < Self::_uiSize; i++)
00907     {
00908         tmp = Self::_values[i] - pnt._values[i];
00909
00910         returnValue += tmp * tmp;
00911     }
00912
00913     return returnValue;
00914 }

00922 {
00923     RealReturnType returnValue = TypeTraits<RealReturnType>::getMin();
00924
00925     for(UInt32 i = 0; i < Self::_uiSize; i++)
00926     {
00927         if(Self::_values[i] > returnValue)
00928             returnValue = Self::_values[i];
00929     }
00930
00931     return returnValue;
00932 }

00942 {
00943     for(UInt32 i = 0; i < Self::_uiSize; i++)
00944     {
00945         Self::_values[i] *= val;
00946     }
00947 }

00954 {
00955     for(UInt32 i = 0; i < Self::_uiSize; i++)
00956     {
00957         Self::_values[i] /= val;
00958     }
00959 }

00968 {
00969     VectorType returnValue(*this);
00970
00971     for(UInt32 i = 0; i < Self::_uiSize; i++)
00972     {
00973         returnValue[i] -= pnt[i];
00974     }
00975
00976     return returnValue;
00977 }

00985 {
00986     Point<ValueTypeT, SizeI> returnValue;
00987
00988     for(UInt32 i = 0; i < Self::_uiSize; i++)
00989     {
00990         returnValue[i] = Self::_values[i] + vec[i];
00991     }
00992
00993     return returnValue;
00994 }

01002 {
01003     Point<ValueTypeT, SizeI> returnValue;
01004
01005     for(UInt32 i = 0; i < Self::_uiSize; i++)
01006     {
01007         returnValue[i] = Self::_values[i] - vec[i];
01008     }
01009
01010     return returnValue;
01011 }

01019 {
01020     Point<ValueTypeT, SizeI> returnValue;
01021
01022     for(UInt32 i = 0; i < Self::_uiSize; i++)
01023     {
01024         returnValue[i] = Self::_values[i] * rVal;
01025     }
01026
01027     return returnValue;
01028 }

01036 {
01037     Point<ValueTypeT, SizeI> returnValue;
01038
01039     for(UInt32 i = 0; i < Self::_uiSize; i++)
01040     {
01041         returnValue._values[i] = - Self::_values[i];
01042     }
01043
01044     return returnValue;
01045 }

01052 {
01053     for(UInt32 i = 0; i < Self::_uiSize; i++)
01054     {
01055         Self::_values[i] += vec._values[i];
01056     }
01057 }

01064 {
01065     for(UInt32 i = 0; i < Self::_uiSize; i++)
01066     {
01067         Self::_values[i] -= vec._values[i];
01068     }
01069 }

01077 {
01078     return Self::_values[uiVal];
01079 }

01085 {
01086     return Self::_values[uiVal];
01087 }

01096 {
01097     if(this == &source)
01098         return *this;
01099
01100     for(UInt32 i = 0; i < Self::_uiSize; i++)
01101     {
01102         Self::_values[i] = source._values[i];
01103     }
01104
01105     return *this;
01106 }

01112 {
01113     Point<ValueTypeT, SizeI>::error_cannot_assign_vector;
01114
01115     return *this;
01116 }

01124 {
01125     bool ret = false;
01126
01127     for(UInt32 i = 0; i < Self::_uiSize; i++)
01128     {
01129         if(Self::_values[i] > other._values[i])
01130         {
01131             break;
01132         }
01133
01134         if(Self::_values[i] < other._values[i])
01135         {
01136             ret = true;
01137             break;
01138         }
01139     }
01140
01141     return ret;
01142 }

01149 {
01150     return Self::equals(other, ValueTypeT(Eps));
01151 }

01158 {
01159     return ! (*this == other);
01160 }