Text archives Help

---

Author: sparker
Date: Wed May 11 14:17:17 2005
New Revision: 287

Added:
   branches/newPointVector/Core/Geometry/PointVector.cc
Modified:
   branches/newPointVector/Core/Geometry/AffineTransform.cc
   branches/newPointVector/Core/Geometry/PointVector.h
Log:
Improved generalizations of point/vector


Modified: branches/newPointVector/Core/Geometry/AffineTransform.cc
==============================================================================
--- branches/newPointVector/Core/Geometry/AffineTransform.cc    (original)
+++ branches/newPointVector/Core/Geometry/AffineTransform.cc    Wed May 11 
14:17:17 2005
@@ -4,6 +4,7 @@
 #include <Core/Math/Trig.h>
 #include <Core/Math/MinMax.h>
 #include <Core/Math/MiscMath.h>
+#include <iostream>
 
 // TODO: several of these could be faster if they become bottlenecks
 

Added: branches/newPointVector/Core/Geometry/PointVector.cc
==============================================================================
--- (empty file)
+++ branches/newPointVector/Core/Geometry/PointVector.cc        Wed May 11 
14:17:17 2005
@@ -0,0 +1,18 @@
+
+#include <Core/Geometry/PointVector.h>
+
+using namespace Manta;
+
+template<typename T, int Dim>
+inline std::ostream &operator<< (std::ostream &os, const VectorT<T,Dim> &v) {
+  for (int i=0;i<Dim;++i)
+    os << v[i] << " ";
+  return os;
+}
+
+template<typename T, int Dim>
+inline std::ostream &operator<< (std::ostream &os, const PointT<T,Dim> &v) {
+  for (int i=0;i<Dim;++i)
+    os << v[i] << " ";
+  return os;
+}

Modified: branches/newPointVector/Core/Geometry/PointVector.h
==============================================================================
--- branches/newPointVector/Core/Geometry/PointVector.h (original)
+++ branches/newPointVector/Core/Geometry/PointVector.h Wed May 11 14:17:17 
2005
@@ -2,28 +2,32 @@
 #ifndef Manta_Core_PointVector_h
 #define Manta_Core_PointVector_h
 
-#include <iostream> // for debugging.
-
 #include <MantaTypes.h>
+#include <Core/Math/Expon.h>
 #include <Core/Math/MinMax.h>
 #include <Core/Math/MiscMath.h>
+#include <iosfwd>
 #include <math.h>
 
-
 namespace Manta {
   template<typename T, int Dim> 
     class VectorT {
   public:
     VectorT() {
     }
+    VectorT(T x, T y) {
+      char unnamed[ Dim == 2 ? 1 : 0 ];
+      data[0] = x; data[1] = y;
+    }
     VectorT(T x, T y, T z) {
+      char unnamed[ Dim == 3 ? 1 : 0 ];
       data[0] = x; data[1] = y; data[2] = z;
     }
 
-        explicit VectorT( const PointT<T,Dim> &copy) {
-               for (int i=0;i<Dim;i++)
-                 data[i] = copy[i];
-        }
+    explicit VectorT( const PointT<T,Dim> &copy) {
+      for (int i=0;i<Dim;i++)
+        data[i] = copy[i];
+    }
 
     VectorT(const VectorT<T, Dim>& copy) {
       for(int i=0;i<Dim;i++)
@@ -43,9 +47,11 @@
       return data[0];
     }
     T y() const {
+      char unnamed[ Dim >=2 ? 1 : 0 ];
       return data[1];
     }
     T z() const {
+      char unnamed[ Dim >= 3 ? 1 : 0 ];
       return data[2];
     }
     const T &operator[](int i) const {
@@ -55,75 +61,113 @@
       return data[i];
     }
     VectorT<T, Dim> operator+(const VectorT<T, Dim>& v) const {
-      return VectorT<T, Dim>(data[0]+v.data[0], data[1]+v.data[1], 
data[2]+v.data[2]);
-    }
-    VectorT<T, Dim> operator-(const VectorT<T, Dim>& v) const {
-      return VectorT<T, Dim>(data[0]-v.data[0], data[1]-v.data[1], 
data[2]-v.data[2]);
-    }
-    VectorT<T, Dim> operator-() const {
-      return VectorT<T, Dim>(-data[0], -data[1], -data[2]);
+      VectorT<T, Dim> result;
+      for(int i=0;i<Dim;i++)
+        result.data[i] = data[i] + v.data[i];
+      return result;
     }
     VectorT<T, Dim>& operator+=(const VectorT<T, Dim>& v) {
-      data[0]+=v.data[0]; data[1]+=v.data[1]; data[2]+=v.data[2];
+      for(int i=0;i<Dim;i++)
+        data[i] += v.data[i];
       return *this;
     }
+    VectorT<T, Dim> operator-(const VectorT<T, Dim>& v) const {
+      VectorT<T, Dim> result;
+      for(int i=0;i<Dim;i++)
+        result.data[i] = data[i] - v.data[i];
+      return result;
+    }
     VectorT<T, Dim>& operator-=(const VectorT<T, Dim>& v) {
-      data[0]-=v.data[0]; data[1]-=v.data[1]; data[2]-=v.data[2];
+      for(int i=0;i<Dim;i++)
+        data[i] -= v.data[i];
       return *this;
     }
+    VectorT<T, Dim> operator-() const {
+      VectorT<T, Dim> result;
+      for(int i=0;i<Dim;i++)
+        result.data[i] = -data[i];
+      return result;
+    }
 
     VectorT<T, Dim> operator*(const VectorT<T, Dim>& v) const {
-      return VectorT<T, Dim>(data[0]*v.data[0], data[1]*v.data[1], 
data[2]*v.data[2]);
+      VectorT<T, Dim> result;
+      for(int i=0;i<Dim;i++)
+        result.data[i] = data[i] * v.data[i];
+      return result;
     }
-    VectorT<T, Dim> operator*(double s) const {
-      return VectorT<T, Dim>(data[0]*s, data[1]*s, data[2]*s);
+    VectorT<T, Dim> operator*(T s) const {
+      VectorT<T, Dim> result;
+      for(int i=0;i<Dim;i++)
+        result.data[i] = data[i] * s;
+      return result;
     }
     VectorT<T, Dim>& operator*=(const VectorT<T, Dim>& v) {
-      data[0]*=v.data[0]; data[1]*=v.data[1]; data[2]*=v.data[2];
+      for(int i=0;i<Dim;i++)
+        data[i] *= v.data[i];
       return *this;
     }
-    VectorT<T, Dim>& operator*=(double s) {
-      data[0]*=s; data[1]*=s; data[2]*=s;
+    VectorT<T, Dim>& operator*=(T s) {
+      for(int i=0;i<Dim;i++)
+        data[i] *= s;
       return *this;
     }
-    VectorT<T, Dim> operator/(double s) const {
-      double inv_s = 1./s;
-      return VectorT<T, Dim>(data[0]*inv_s, data[1]*inv_s, data[2]*inv_s);
-    }
-    VectorT<T, Dim>& operator/=(double s) {
-      double inv_s = 1./s;
-      data[0]*=inv_s; data[1]*=inv_s; data[2]*=inv_s;
+    VectorT<T, Dim> operator/(T s) const {
+      T inv_s = 1./s;
+      VectorT<T, Dim> result;
+      for(int i=0;i<Dim;i++)
+        result.data[i] = data[i] * inv_s;
+      return result;
+    }
+    VectorT<T, Dim>& operator/=(T s) {
+      for(int i=0;i<Dim;i++)
+        data[i] *= inv_s;
       return *this;
     }
     VectorT<T, Dim> operator/(const VectorT<T, Dim>& v) const {
-      return VectorT<T, Dim>(data[0]/v.data[0], data[1]/v.data[1], 
data[2]/v.data[2]);
+      T inv_s = 1./s;
+      VectorT<T, Dim> result;
+      for(int i=0;i<Dim;i++)
+        result.data[i] = data[i] * v.data[i];
+      return result;
     }
 
-    double length() const {
-      return sqrt(data[0]*data[0]+data[1]*data[1]+data[2]*data[2]);
+    T length() const {
+      T sum = 0;
+      for(int i=0;i<Dim;i++)
+        sum += data[i]*data[i];
+      return SCIRun::Sqrt(sum);
     }
-    double length2() const {
-      return data[0]*data[0]+data[1]*data[1]+data[2]*data[2];
+    T length2() const {
+      T sum = 0;
+      for(int i=0;i<Dim;i++)
+        sum += data[i]*data[i];
+      return sum;
     }
 
-    double normalize() {
-      double l = length();
-      double scale = 1./l;
+    T normalize() {
+      T l = length();
+      T scale = 1./l;
       *this *= scale;
       return l;
     }
     VectorT<T, Dim> normal() const {
-      double l = length();
-      double scale = 1./l;
+      T l = length();
+      T scale = 1./l;
       return *this * scale;
     }
-    double minComponent() const {
-      using SCIRun::Min;
-      return Min(data[0], data[1], data[2]);
+    T minComponent() const {
+      T min = data[0];
+      for(int i=1;i<Dim;i++)
+        if(data[i] < min)
+          min = data[i];
+      return min;
     }
-    double maxComponent() const {
-      using SCIRun::Max;
-      return Max(data[0], data[1], data[2]);
+    T maxComponent() const {
+      T max = data[0];
+      for(int i=1;i<Dim;i++)
+        if(data[i] < max)
+          max = data[i];
+      return max;
     }
     int indexOfMinComponent() const {
       int idx = 0;
@@ -141,18 +185,29 @@
     }
 
     VectorT<T, Dim> inverse() const {
-      return VectorT<T, Dim>(1./data[0], 1./data[1], 1./data[2]);
+      VectorT<T, Dim> result;
+      for(int i=0;i<Dim;i++)
+        result.data[i] = 1./data[i];
+      return result;
     }
     VectorT<T, Dim> absoluteValue() const {
-      using SCIRun::Abs;
-      return VectorT<T, Dim>(Abs(data[0]), Abs(data[1]), Abs(data[2]));
+      VectorT<T, Dim> result;
+      for(int i=0;i<Dim;i++)
+        result.data[i] = SCIRun::Abs(data[i]);
+      return result;
     }
 
     static VectorT<T, Dim> zero() {
-      return VectorT<T, Dim>(0,0,0);
+      VectorT<T, Dim> result;
+      for(int i=0;i<Dim;i++)
+        result.data[i] = 0;
+      return result;
     }
     static VectorT<T, Dim> one() {
-      return VectorT<T, Dim>(1,1,1);
+      VectorT<T, Dim> result;
+      for(int i=0;i<Dim;i++)
+        result.data[i] = 1;
+      return result;
     }
 
   private:
@@ -166,7 +221,12 @@
     PointT() {
     }
 
+    PointT(T x, T y) {
+      char unnamed[ Dim == 2 ? 1 : 0 ];
+      data[0] = x; data[1] = y;
+    }
     PointT(T x, T y, T z) {
+      char unnamed[ Dim == 3 ? 1 : 0 ];
       data[0] = x; data[1] = y; data[2] = z;
     }
     
@@ -196,6 +256,7 @@
       return data[1];
     }
     T z() const {
+      char unnamed[ Dim == 3 ? 1 : 0 ];
       return data[2];
     }
     T operator[](int i) const {
@@ -206,26 +267,33 @@
     }
 
     VectorT<T, Dim> operator-(const PointT<T, Dim>& p) const {
-      return VectorT<T, Dim>(data[0]-p.data[0], data[1]-p.data[1], 
data[2]-p.data[2]);
+      VectorT<T, Dim> result;
+      for(int i=0;i<Dim;i++)
+        result[i] = data[i] - p[i];
+      return result;
     }
     PointT<T, Dim> operator+(const VectorT<T, Dim>& v) const {
-      return PointT<T, Dim>(data[0]+v.x(), data[1]+v.y(), data[2]+v.z());
+      PointT<T, Dim> result;
+      for(int i=0;i<Dim;i++)
+        result.data[i] = data[i] + v[i];
+      return result;
     }
     PointT<T, Dim> operator-(const VectorT<T, Dim>& v) const {
-      return PointT<T, Dim>(data[0]-v.x(), data[1]-v.y(), data[2]-v.z());
+      PointT<T, Dim> result;
+      for(int i=0;i<Dim;i++)
+        result.data[i] = data[i] - v[i];
+      return result;
     }
 
     PointT<T, Dim>& operator+=(const VectorT<T, Dim>& v) {
-      data[0]+=v.x();
-      data[1]+=v.y();
-      data[2]+=v.z();
+      for(int i=0;i<Dim;i++)
+        data[i] += v[i];
       return *this;
     }
 
     PointT<T, Dim>& operator-=(const VectorT<T, Dim>& v) {
-      data[0]-=v.x();
-      data[1]-=v.y();
-      data[2]-=v.z();
+      for(int i=0;i<Dim;i++)
+        data[i] -= v[i];
       return *this;
     }
   private:
@@ -233,89 +301,111 @@
   };
 
   template<typename T, int Dim> 
-    inline VectorT<T, Dim> operator*(double s, const VectorT<T, Dim>& v)
+    inline VectorT<T, Dim> operator*(T s, const VectorT<T, Dim>& v)
     {
-      return VectorT<T, Dim>(s*v.x(), s*v.y(), s*v.z());
+      VectorT<T, Dim> result;
+      for(int i=0;i<Dim;i++)
+        result[i] = s * v[i];
+      return result;
     }
 
   template<typename T, int Dim> 
-    inline double Dot(const VectorT<T, Dim>& v1, const VectorT<T, Dim>& v2)
+    inline T Dot(const VectorT<T, Dim>& v1, const VectorT<T, Dim>& v2)
   {
-    return v1.x()*v2.x() + v1.y()*v2.y() + v1.z()*v2.z();
+    T result = 0;
+    for(int i=0;i<Dim;i++)
+      result += v1[i] * v2[i];
+    return result;
   }
 
   template<typename T, int Dim> 
-    inline double Dot(const VectorT<T, Dim>& v1, const PointT<T, Dim>& v2)
+    inline T Dot(const VectorT<T, Dim>& v1, const PointT<T, Dim>& v2)
   {
-    return v1.x()*v2.x() + v1.y()*v2.y() + v1.z()*v2.z();
+    T result = 0;
+    for(int i=0;i<Dim;i++)
+      result += v1[i] * v2[i];
+    return result;
   }
 
   template<typename T, int Dim> 
-    inline double Dot(const PointT<T, Dim>& v1, const VectorT<T, Dim>& v2)
+    inline T Dot(const PointT<T, Dim>& v1, const VectorT<T, Dim>& v2)
   {
-    return v1.x()*v2.x() + v1.y()*v2.y() + v1.z()*v2.z();
+    T result = 0;
+    for(int i=0;i<Dim;i++)
+      result += v1[i] * v2[i];
+    return result;
   }
 
 
-  template<typename T, int Dim> 
-    inline VectorT<T, Dim> Cross(const VectorT<T, Dim>& v1, const VectorT<T, 
Dim>& v2)
+  // Cross product is only defined for R3
+  template<typename T> 
+    inline VectorT<T, 3> Cross(const VectorT<T, 3>& v1, const VectorT<T, 3>& 
v2)
     {
-      return VectorT<T, Dim>(v1.y()*v2.z() - v1.z()*v2.y(),
-                             v1.z()*v2.x() - v1.x()*v2.z(),
-                             v1.x()*v2.y() - v1.y()*v2.x());
+      return VectorT<T, 3>(v1.y()*v2.z() - v1.z()*v2.y(),
+                           v1.z()*v2.x() - v1.x()*v2.z(),
+                           v1.x()*v2.y() - v1.y()*v2.x());
     }
 
   template<typename T, int Dim> 
-    inline VectorT<T, Dim> Min(const VectorT<T, Dim>& p1, const VectorT<T, 
Dim>& p2)
+    inline VectorT<T, Dim> Min(const VectorT<T, Dim>& v1, const VectorT<T, 
Dim>& v2)
     {
       using SCIRun::Min;
-      return VectorT<T, Dim>(Min(p1.x(), p2.x()), Min(p1.y(), p2.y()), 
Min(p1.z(), p2.z()));
+      VectorT<T, Dim> result;
+      for(int i=0;i<Dim;i++)
+        result[i] = Min(v1[i], v2[i]);
+      return result;
     }
 
   template<typename T, int Dim> 
-    inline VectorT<T, Dim> Max(const VectorT<T, Dim>& p1, const VectorT<T, 
Dim>& p2)
+    inline VectorT<T, Dim> Max(const VectorT<T, Dim>& v1, const VectorT<T, 
Dim>& v2)
     {
       using SCIRun::Max;
-      return VectorT<T, Dim>(Max(p1.x(), p2.x()), Max(p1.y(), p2.y()), 
Max(p1.z(), p2.z()));
+      VectorT<T, Dim> result;
+      for(int i=0;i<Dim;i++)
+        result[i] = Max(v1[i], v2[i]);
+      return result;
     }
 
   template<typename T, int Dim> 
     inline PointT<T, Dim> Min(const PointT<T, Dim>& p1, const PointT<T, 
Dim>& p2)
     {
       using SCIRun::Min;
-      return PointT<T, Dim>(Min(p1.x(), p2.x()), Min(p1.y(), p2.y()), 
Min(p1.z(), p2.z()));
+      PointT<T, Dim> result;
+      for(int i=0;i<Dim;i++)
+        result[i] = Min(p1[i], p2[i]);
+      return result;
     }
 
   template<typename T, int Dim> 
     inline PointT<T, Dim> Max(const PointT<T, Dim>& p1, const PointT<T, 
Dim>& p2)
     {
       using SCIRun::Max;
-      return PointT<T, Dim>(Max(p1.x(), p2.x()), Max(p1.y(), p2.y()), 
Max(p1.z(), p2.z()));
+      PointT<T, Dim> result;
+      for(int i=0;i<Dim;i++)
+        result[i] = Max(p1[i], p2[i]);
+      return result;
     }
 
   template<typename T, int Dim> 
-    inline PointT<T, Dim> Interpolate(const PointT<T, Dim>& p1, const 
PointT<T, Dim>& p2, double weight)
+    inline PointT<T, Dim> Interpolate(const PointT<T, Dim>& p1, const 
PointT<T, Dim>& p2, T weight)
     {
       using SCIRun::Interpolate;
-      return PointT<T, Dim>(Interpolate(p1.x(), p2.x(), weight),
-                            Interpolate(p1.y(), p2.y(), weight),
-                            Interpolate(p1.z(), p2.z(), weight));
-
+      PointT<T, Dim> result;
+      for(int i=0;i<Dim;i++)
+        result[i] = Interpolate(p1[i], p2[i], weight);
+      return result;
     }
 
   template<typename T, int Dim>
-    inline std::ostream &operator<< (std::ostream &os, const VectorT<T,Dim> 
&v) {
-        for (int i=0;i<Dim;++i)
-               os << v[i] << " ";
-        return os;
-  }
+    std::ostream &operator<< (std::ostream &os, const VectorT<T,Dim> &v);
 
   template<typename T, int Dim>
-    inline std::ostream &operator<< (std::ostream &os, const PointT<T,Dim> 
&v) {
-        for (int i=0;i<Dim;++i)
-               os << v[i] << " ";
-        return os;
-  }
+    std::ostream &operator<< (std::ostream &os, const PointT<T,Dim> &v);
+
 }
+
+#ifdef MANTA_TEMPLATE_DEFINITIONS_REQUIRED
+#include <Core/Geometry/PointVector.cc>
+#endif
 
 #endif

---

• [MANTA] r287 - branches/newPointVector/Core/Geometry, sparker, 05/11/2005

---

Archive powered by MHonArc 2.6.16.