Text archives Help

---

What does svn status say?

James

vpegorar@cs.utah.edu wrote:

Correct, I thought I added this file as well, and when I try to add it again 
it
actually says :

$ svn add manta/SCIRun/Core/Malloc/ArrayAllocation.h
svn: warning: 'manta/SCIRun/Core/Malloc/ArrayAllocation.h' is already under
version control

But it looks like in reality the file isn't in the repository. Any idea how I
should proceed to fix that ?

Vincent


Quoting Abe Stephens <abe@sci.utah.edu>:

Hi-- This file does not appear to be in svn:

/store/rhodes/abe/Manta/Model/Primitives/Heightfield.cc(7): catastrophic error: could not open source file "Core/Malloc/ArrayAllocation.h"
 #include <Core/Malloc/ArrayAllocation.h>

Abe

vpegorar@sci.utah.edu wrote:

Author: vpegorar
Date: Mon May 16 15:57:51 2005
New Revision: 327

Added:
 trunk/Model/Primitives/Heightfield.cc
 trunk/Model/Primitives/Heightfield.h
Log:
Heightfield implemented. Should modify the scene to allow dynamic data

specification. Fixed small bug in PointVector class.

Added: trunk/Model/Primitives/Heightfield.cc

==============================================================================

--- (empty file)
+++ trunk/Model/Primitives/Heightfield.cc       Mon May 16 15:57:51 2005
@@ -0,0 +1,308 @@
+
+#include <Model/Primitives/Heightfield.h>
+#include <Interface/RayPacket.h>
+#include <Core/Geometry/BBox.h>
+#include <Core/Math/MiscMath.h>
+#include <Core/Math/MinMax.h>
+#include <Core/Malloc/ArrayAllocation.h>
+#include <Core/Geometry/PointVector.h>
+#include <fstream>
+#include <iostream>
+
+using namespace Manta;
+using namespace std;
+
+
+//

--------------------------------------------------------------------------------------

+// --- Constructor
+//

--------------------------------------------------------------------------------------

+Heightfield::Heightfield(Material * material, char * fileName, const Point

& minBound, const Point & maxBound, double scale)

+  : PrimitiveCommon(material), m_Box(minBound, maxBound)
+{
+  readHeightfieldFile(fileName, &m_Nx, &m_Ny, &m_Data);
+  rescaleDataHeight(scale);
+}
+
+
+//

--------------------------------------------------------------------------------------

+// --- Destructor
+//

--------------------------------------------------------------------------------------

+Heightfield::~Heightfield()
+{
+  DELETE2DARRAY(m_Data, m_Nx+1);
+}
+
+
+//

--------------------------------------------------------------------------------------

+// --- Get the Bounding Box
+//

--------------------------------------------------------------------------------------

+void Heightfield::computeBounds(const PreprocessContext & context, BBox &

bbox) const

+{
+  bbox.extendByPoint(m_Box.getMin());
+  bbox.extendByPoint(m_Box.getMax());
+}
+
+
+//

--------------------------------------------------------------------------------------

+// --- Test whether the ray intersects the Heightfield or not
+//

--------------------------------------------------------------------------------------

+void Heightfield::intersect(const RenderContext & context, RayPacket &

rays) const

+{
+  Vector diagonal;
+  Point hitPoint;
+  int hitLattice[2], stop[2], di[2], ind;
+  double tnext[2], dtd[2], far[2], zm[2], datam[2], cellSize[2];
+  double tnear, tfar, zenter, texit, zexit;
+  bool validtcells[2];
+
+  if (!(rays.getFlags() & RayPacket::NormalizedDirections))
+  {
+    rays.normalizeDirections();
+    rays.setFlag(RayPacket::NormalizedDirections);
+  }
+
+  for(int i=0; i<rays.getSize(); i++)
+  {
+    RayPacket::Element & e = rays.get(i);
+    Ray & ray = e.ray;
+
+    using Manta::Min;
+    using Manta::Max;
+    rays.computeInverseDirections();
+    Vector t1 = (m_Box.getMin() - ray.origin()) * e.inverseDirection;
+    Vector t2 = (m_Box.getMax() - ray.origin()) * e.inverseDirection;
+    Vector tn = Min(t1, t2);
+    Vector tf = Max(t1, t2);
+    tnear = tn.maxComponent();
+    tfar  = tf.minComponent();
+    if (tnear > tfar)
+      continue;
+
+    using SCIRun::Min;
+    using SCIRun::Max;
+
+    if (m_Box.getMin().x() < ray.origin().x() && m_Box.getMin().y() <

ray.origin().y() && m_Box.getMin().z() < ray.origin().z() &&

+        m_Box.getMax().x() > ray.origin().x() && m_Box.getMax().y() >

ray.origin().y() && m_Box.getMax().z() < ray.origin().z() )

+      tnear = 0.0;
+
+    diagonal = m_Box.diagonal();
+    cellSize[0] = diagonal.x() / (double)m_Nx;
+    cellSize[1] = diagonal.y() / (double)m_Ny;
+
+    hitPoint = ray.origin() + (ray.direction() * tnear);
+    hitLattice[0] = (int)((hitPoint.x() - m_Box.getMin().x()) /

cellSize[0]);

+    hitLattice[1] = (int)((hitPoint.y() - m_Box.getMin().y()) /

cellSize[1]);

+
+    if      (hitLattice[0] < 0)          hitLattice[0] = 0;
+    else if (hitLattice[0] >= (int)m_Nx) hitLattice[0] = (int)(m_Nx-1);
+    if      (hitLattice[1] < 0)          hitLattice[1] = 0;
+    else if (hitLattice[1] >= (int)m_Ny) hitLattice[1] = (int)(m_Ny-1);
+
+    di[0] = (diagonal.x() * ray.direction().x() > 0.0) ? 1 : -1;
+    stop[0] = (di[0] == 1) ? m_Nx : -1;
+    di[1] = (diagonal.y() * ray.direction().y() > 0.0) ? 1 : -1;
+    stop[1] = (di[1] == 1) ? m_Ny : -1;
+
+    dtd[0] = fabs(cellSize[0] / ray.direction().x());
+    dtd[1] = fabs(cellSize[1] / ray.direction().y());
+
+    if (di[0] == 1) far[0] = m_Box.getMin().x() + cellSize[0] *

(double)(hitLattice[0] + 1);

+    else            far[0] = m_Box.getMin().x() + cellSize[0] *

(double)(hitLattice[0]    );

+    if (di[1] == 1) far[1] = m_Box.getMin().y() + cellSize[1] *

(double)(hitLattice[1] + 1);

+    else            far[1] = m_Box.getMin().y() + cellSize[1] *

(double)(hitLattice[1]    );

+
+    tnext[0] = (far[0] - ray.origin().x()) / ray.direction().x();
+    tnext[1] = (far[1] - ray.origin().y()) / ray.direction().y();
+
+    while(true)
+    {
+      zenter = ray.origin().z() + (tnear * ray.direction().z());
+      texit  = Min(tnext[0], tnext[1]);
+      zexit  = ray.origin().z() + (texit * ray.direction().z());
+
+      datam[0] = Min(Min(m_Data[hitLattice[0]][hitLattice[1]  ],

m_Data[hitLattice[0]+1][hitLattice[1]  ]) ,

+                     Min(m_Data[hitLattice[0]][hitLattice[1]+1],

m_Data[hitLattice[0]+1][hitLattice[1]+1]) );

+      zm[0] = Min(zenter, zexit);
+      datam[1] = Max(Max(m_Data[hitLattice[0]][hitLattice[1]  ],

m_Data[hitLattice[0]+1][hitLattice[1]  ]) ,

+                     Max(m_Data[hitLattice[0]][hitLattice[1]+1],

m_Data[hitLattice[0]+1][hitLattice[1]+1]) );

+      zm[1] = Max(zenter, zexit);
+
+      if (!(zm[0] > datam[1] || zm[1] < datam[0]))
+      {
+        double a, b, c;
+        double sx, dx, sy, dy;
+        Point pe;
+        double ce[2], z[4];
+
+        pe = ray.origin() + ray.direction() * tnear;
+        ce[0] = pe.x() - (m_Box.getMin().x() + cellSize[0] *

(double)(hitLattice[0]));

+        ce[1] = pe.y() - (m_Box.getMin().y() + cellSize[1] *

(double)(hitLattice[1]));

+
+        sx = ce[0] / cellSize[0];
+        sy = ce[1] / cellSize[1];
+        dx = ray.direction().x() / cellSize[0];
+        dy = ray.direction().y() / cellSize[1];
+
+        z[0] = m_Data[hitLattice[0]  ][hitLattice[1]  ];
+        z[1] = m_Data[hitLattice[0]+1][hitLattice[1]  ] - z[0];
+        z[2] = m_Data[hitLattice[0]  ][hitLattice[1]+1] - z[0];
+        z[3] = m_Data[hitLattice[0]+1][hitLattice[1]+1] -

m_Data[hitLattice[0]+1][hitLattice[1]] - z[2];

+
+        a = dx * dy * z[3];
+        b = (sx * dy + sy * dx)*z[3] + dx*z[1] + dy*z[2] -

ray.direction().z();

+        c = sx*sy*z[3] + sx*z[1] + sy*z[2] + z[0] - pe.z();
+
+        if (a == 0.0)
+        {
+          double tcell, u, v;
+
+          tcell = -c / b;
+          u = sx + tcell * dx;
+          v = sy + tcell * dy;
+
+          if (tcell > T_EPSILON && tcell < texit && u > 0.0 && u < 1.0 && v
0.0 && v < 1.0)
+          {
+            if (e.hitInfo.hit(tnear + tcell, material, this, tex))
+              e.hitInfo.scratchpad<Vector>() = Vector(- (z[1] + v*z[3]) /

cellSize[0], - (z[2] + u*z[3]) / cellSize[1], 1.0);

+            break;
+          }
+        }
+        else
+        {
+          double delta = b*b - 4.0*a*c;
+          if (delta >= 0.0)
+          {
+            double tcells[2], a2, u, v, tcell;
+
+            delta = sqrt(delta);
+            a2 = 2.0 * a;
+
+            tcells[0] = (-b - delta) / a2;
+            tcells[1] = (-b + delta) / a2;
+
+            validtcells[0] = (tcells[0] > 0.0 && tcells[0] < texit);
+            validtcells[1] = (tcells[1] > 0.0 && tcells[1] < texit);
+
+            tcell = -1.0;
+            if (validtcells[0] && validtcells[1]) tcell = Min(tcells[0],

tcells[1]);

+            else if (validtcells[0])              tcell = tcells[0];
+            else if (validtcells[1])              tcell = tcells[1];
+
+            if (tcell > T_EPSILON)
+            {
+              u = sx + tcell * dx;
+              v = sy + tcell * dy;
+              if (u > 0.0 && u < 1.0 && v > 0.0 && v < 1.0)
+              {
+                if (e.hitInfo.hit(tnear + tcell, material, this, tex))
+                  e.hitInfo.scratchpad<Vector>() = Vector( - (z[1] +

v*z[3]) / cellSize[0], - (z[2] + u*z[3]) / cellSize[1], 1.0);

+                break;
+              }
+            }
+          }
+       }
+      }
+
+      ind = (tnext[0] < tnext[1]) ? 0 : 1;
+      tnear = tnext[ind];
+      tnext[ind] += dtd[ind];
+      hitLattice[ind] += di[ind];
+
+      if (hitLattice[0] == stop[0] || hitLattice[1] == stop[1] || tnear >

tfar)

+        break;
+    }
+  }
+}
+
+
+//

--------------------------------------------------------------------------------------

+// --- Set the normals
+//

--------------------------------------------------------------------------------------

+void Heightfield::computeNormal(const RenderContext & context, RayPacket &

rays) const

+{
+  int i, numRays(rays.getSize());
+ + for (i=0; i<numRays; i++)
+  {
+    RayPacket::Element & e(rays.get(i));
+    e.normal = e.hitInfo.scratchpad<Vector>();
+    e.normal.normalize();
+  }
+
+  // set flags to indicate packet now has unit normals
+  rays.setFlag(RayPacket::HaveNormals | RayPacket::HaveUnitNormals);
+}
+
+
+//

--------------------------------------------------------------------------------------

+// --- Rescale the height of the data to fit the Box
+// --- according to the given percentage of the size of the box to which

the data should be rescaled

+//

--------------------------------------------------------------------------------------

+void Heightfield::rescaleDataHeight(double scale)
+{
+  using SCIRun::Min;
+  using SCIRun::Max;
+
+  unsigned int i, j;
+  double min, max, factor, margin;
+
+  min = m_Data[0][0];
+  max = min;
+  for(i=0; i<=m_Nx; i++)
+    for(j=0; j<=m_Ny; j++)
+    {
+      min = Min(min, m_Data[i][j]);
+      max = Max(max, m_Data[i][j]);
+    }
+
+  factor = m_Box.getMax().z() - m_Box.getMin().z();
+  margin = factor * (1.0 - scale) * 0.5;
+  factor *= scale / (max - min);
+
+  for(i=0; i<=m_Nx; i++)
+    for(j=0; j<=m_Ny; j++)
+      m_Data[i][j] = ((m_Data[i][j] - min) * factor) + (m_Box.getMin().z()

+ margin);

+}
+
+
+//

--------------------------------------------------------------------------------------

+// --- Read the given file and returns nx, ny and the data
+//

--------------------------------------------------------------------------------------

+void Heightfield::readHeightfieldFile(char * fileName, unsigned int * pnx,

unsigned int * pny, double *** pdata)

+{
+  double minz, maxz;
+  int nx, ny, i, j;
+  float ** data;
+
+  ifstream in(fileName, std::ios::in | std::ios::binary);
+  if (!in)
+  {
+    cerr << "Error : unable to open " << fileName << "\n";
+    exit(1);
+  }
+
+  in >> nx >> ny >> minz >> maxz;
+  if (!in)
+  {
+    cerr << "Error : unable to read header from " << fileName << "\n";
+    exit(1);
+  }
+  in.get();
+
+  ALLOCATE2DARRAY(data, nx+1, ny+1, float);
+  in.read((char *)data[0], sizeof(float)*(nx+1)*(ny+1));
+  if (!in)
+  {
+    cerr << "Error : unable to read data from " << fileName << "\n";
+    exit(1);
+  }
+
+  *pnx = nx;
+  *pny = ny;
+  ALLOCATE2DARRAY(*pdata, nx+1, ny+1, double);
+  for(i=0; i<=nx; i++)
+    for(j=0; j<=ny; j++)
+      (*pdata)[i][j] = (double)data[i][j];
+
+  //  DELETE2DARRAY(data, nx+1);
+}

Added: trunk/Model/Primitives/Heightfield.h

==============================================================================

--- (empty file)
+++ trunk/Model/Primitives/Heightfield.h        Mon May 16 15:57:51 2005
@@ -0,0 +1,35 @@
+
+#ifndef Manta_Model_Heightfield_h
+#define Manta_Model_Heightfield_h
+
+#include <Model/Primitives/PrimitiveCommon.h>
+#include <Core/Geometry/PointVector.h>
+#include <Core/Geometry/BBox.h>
+
+namespace Manta {
+
+  //  using namespace SCIRun;
+  class Heightfield : public PrimitiveCommon
+  {
+
+    public:
+
+                   Heightfield(Material * material, char * fileName, const

Point & minBound, const Point & maxBound, double scale = 0.95);

+      virtual      ~Heightfield();
+
+      virtual void computeBounds(const PreprocessContext & context, BBox &

bbox) const;

+      virtual void intersect(const RenderContext & context, RayPacket &

rays) const;

+      virtual void computeNormal(const RenderContext & context, RayPacket &

rays) const;

+      virtual void rescaleDataHeight(double scale);
+      virtual void readHeightfieldFile(char * fileName, unsigned int * pnx,

unsigned int * pny, double *** pdata);

+
+    private:
+
+      BBox         m_Box;
+      unsigned int m_Nx;
+      unsigned int m_Ny;
+      double **    m_Data;
+  };
+}
+
+#endif

---

• [MANTA] r327 - trunk/Model/Primitives, vpegorar, 05/16/2005
  • Re: [MANTA] r327 - trunk/Model/Primitives -- Missing file!!, Abe Stephens, 05/16/2005
    • Re: [MANTA] r327 - trunk/Model/Primitives -- Missing file!!, vpegorar, 05/16/2005
      • Re: [MANTA] r327 - trunk/Model/Primitives -- Missing file!!, James Bigler, 05/16/2005
        • Re: [MANTA] r327 - trunk/Model/Primitives -- Missing file!!, vpegorar, 05/16/2005
          • Re: [MANTA] r327 - trunk/Model/Primitives -- Missing file!!, Steven Parker, 05/16/2005
            • Re: [MANTA] r327 - trunk/Model/Primitives -- Missing file!!, vpegorar, 05/16/2005

---

Archive powered by MHonArc 2.6.16.