Text archives Help

---

Anything in the SCIRun subdirectory is not directly in the Manta repository, so it does not get committed from a top level commit. You must cd into the specific directory and commit from there.

In this case, it might be better to just include the macro in the Heightfield.cc file. I'll probably write a 2D array class soon that will be a better option than the explicitly allocated array here.

Steve


On May 16, 2005, at 6:47 PM, vpegorar@cs.utah.edu wrote:

I tried to delete it and add it again. The add works fine then, but when I try
to commit, it doesn't see anything to commit.

svn status manta :
X      manta/SCIRun/Core/Exceptions
X      manta/SCIRun/Core/Containers
X      manta/SCIRun/Core/Malloc
X      manta/SCIRun/Core/Thread
X      manta/SCIRun/Core/Math
X      manta/SCIRun/Core/Util

Performing status on external item at 'manta/SCIRun/Core/Containers'
Performing status on external item at 'manta/SCIRun/Core/Exceptions'
Performing status on external item at 'manta/SCIRun/Core/Malloc'
A      manta/SCIRun/Core/Malloc/ArrayAllocation.h
Performing status on external item at 'manta/SCIRun/Core/Math'
Performing status on external item at 'manta/SCIRun/Core/Thread'
Performing status on external item at 'manta/SCIRun/Core/Util'

I might be doing something wrong, but I am proceeding exactly the same way as
for the 2 other files that were commited just fine.

Vincent


Quoting James Bigler <bigler@cs.utah.edu>:

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.