Text archives Help

---

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.