Manta Interactive Ray Tracer Development Mailing List

Text archives Help


Re: [MANTA] r327 - trunk/Model/Primitives -- Missing file!!


Chronological Thread 
  • From: vpegorar@cs.utah.edu
  • To: James Bigler <bigler@cs.utah.edu>
  • Cc: manta@sci.utah.edu
  • Subject: Re: [MANTA] r327 - trunk/Model/Primitives -- Missing file!!
  • Date: Mon, 16 May 2005 18:47:30 -0600

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
> >>> 
> >>>
> >>
> >>
> > 
> > 
> > 
> 






Archive powered by MHonArc 2.6.16.

Top of page