Text archives Help

---

Author: arobison
Date: Tue Sep 11 12:15:15 2007
New Revision: 1720

Added:
   trunk/Model/Cameras/ThinLensCamera.cc
   trunk/Model/Cameras/ThinLensCamera.h
Modified:
   trunk/Engine/Factory/RegisterKnownComponents.cc
   trunk/Model/Cameras/CMakeLists.txt
Log:
Adding in the files this time.


Modified: trunk/Engine/Factory/RegisterKnownComponents.cc
==============================================================================
--- trunk/Engine/Factory/RegisterKnownComponents.cc     (original)
+++ trunk/Engine/Factory/RegisterKnownComponents.cc     Tue Sep 11 12:15:15 
2007
@@ -60,7 +60,7 @@
 #include <Model/Cameras/PinholeCamera.h>
 #include <Model/Cameras/OrthogonalCamera.h>
 #include <Model/Cameras/FisheyeCamera.h>
-//#include <Model/Cameras/ThinLensCamera.h>
+#include <Model/Cameras/ThinLensCamera.h>
 #include <Model/Groups/GriddedGroup.h>
 #include <Model/Groups/Group.h>
 // #include <UserInterface/PromptUI.h>
@@ -121,7 +121,7 @@
     //engine->registerComponent("environment", &EnvironmentCamera::create);
     engine->registerComponent("pinhole", &PinholeCamera::create);
     engine->registerComponent("orthogonal", &OrthogonalCamera::create);
-    //engine->registerComponent("thinlens", &ThinLensCamera::create);
+    engine->registerComponent("thinlens", &ThinLensCamera::create);
     //engine->registerComponent("fisheye", &FisheyeCamera::create);
 
     // Register shadow algorithms

Modified: trunk/Model/Cameras/CMakeLists.txt
==============================================================================
--- trunk/Model/Cameras/CMakeLists.txt  (original)
+++ trunk/Model/Cameras/CMakeLists.txt  Tue Sep 11 12:15:15 2007
@@ -8,6 +8,6 @@
      Cameras/OrthogonalCamera.cc
      Cameras/FisheyeCamera.h
      Cameras/FisheyeCamera.cc
-#     Cameras/ThinLensCamera.h
-#     Cameras/ThinLensCamera.cc
+     Cameras/ThinLensCamera.h
+     Cameras/ThinLensCamera.cc
      )

Added: trunk/Model/Cameras/ThinLensCamera.cc
==============================================================================
--- (empty file)
+++ trunk/Model/Cameras/ThinLensCamera.cc       Tue Sep 11 12:15:15 2007
@@ -0,0 +1,317 @@
+
+#include <MantaTypes.h>
+#include <Model/Cameras/ThinLensCamera.h>
+#include <Core/Util/Args.h>
+#include <Core/Exceptions/IllegalArgument.h>
+#include <Interface/Context.h>
+#include <Interface/MantaInterface.h>
+#include <Interface/RayPacket.h>
+#include <Interface/RandomNumberGenerator.h>
+#include <Interface/Scene.h>
+#include <Core/Geometry/BBox.h>
+#include <Core/Geometry/AffineTransform.h>
+#include <Core/Math/MiscMath.h>
+#include <Core/Math/Trig.h>
+#include <Core/Util/Assert.h>
+#include <MantaSSE.h>
+#include <iostream>
+#include <limits>
+
+using namespace Manta;
+using namespace std;
+using SCIRun::Clamp;
+using SCIRun::Abs;
+
+ThinLensCamera::ThinLensCamera( const Vector& eye_, const Vector& lookat_,
+                                const Vector &up_, Real hfov_, Real vfov_,
+                                Real focal_length_, Real aperture_)
+  : eye( eye_ ), lookat( lookat_ ), up( up_ ),
+    stereo_offset( 0.0 ), hfov( hfov_ ), vfov( vfov_),
+    focal_length(focal_length_), aperture(aperture_), radius(aperture_/2.0)
+{
+  haveCamera = true;
+  setup();
+}
+
+ThinLensCamera::ThinLensCamera(const vector<string>& args)
+{
+  haveCamera = false;
+  stereo_offset = 0;
+
+  eye    = Vector ( 3, 3, 2 );
+  lookat = Vector ( 0, 0, (Real)0.3 );
+  up     = Vector( 0, 0, 1 );
+  hfov    = 60;
+  vfov    = 60;
+  aperture = 0;
+  focal_length = 1;
+  for(size_t i=0; i< args.size(); i++){
+    string arg = args[i];
+    if (arg == "-offset") {
+      if(!getArg(i, args, stereo_offset))
+        throw IllegalArgument("ThinLensCamera -offset", i, args);
+    } else if(arg == "-eye"){
+      if(!getVectorArg(i, args, eye))
+        throw IllegalArgument("ThinLensCamera -eye", i, args);
+      haveCamera = true;
+    } else if(arg == "-lookat"){
+      if(!getVectorArg(i, args, lookat))
+        throw IllegalArgument("ThinLensCamera -lookat", i, args);
+      haveCamera = true;
+    } else if(arg == "-up"){
+      if(!getVectorArg(i, args, up))
+        throw IllegalArgument("ThinLensCamera -up", i, args);
+      haveCamera = true;
+    } else if(arg == "-fov"){
+      if(!getArg<Real>(i, args, hfov))
+        throw IllegalArgument("ThinLensCamera -fov", i, args);
+      vfov = hfov;
+      haveCamera = true;
+    } else if(arg == "-hfov"){
+      if(!getArg<Real>(i, args, hfov))
+        throw IllegalArgument("ThinLensCamera -hfov", i, args);
+      haveCamera = true;
+    } else if(arg == "-vfov"){
+      if(!getArg<Real>(i, args, vfov))
+        throw IllegalArgument("ThinLensCamera -vfov", i, args);
+      haveCamera = true;
+    } else if(arg == "-aperture"){
+      if(!getArg<Real>(i, args, aperture))
+        throw IllegalArgument("ThinLensCamera -aperture", i, args);
+      radius = aperture/2.0;
+      haveCamera = true;
+    } else if(arg == "-focal_length"){
+      if(!getArg<Real>(i, args, focal_length))
+        throw IllegalArgument("ThinLensCamera -focal_distance", i, args);
+      haveCamera = true;
+    } else {
+      throw IllegalArgument("ThinLensCamera", i, args);
+    }
+  }
+
+  setup();
+}
+
+ThinLensCamera::~ThinLensCamera()
+{
+}
+
+void ThinLensCamera::output( std::ostream &os ) {
+
+  os << "thinlens( -eye " << eye
+     << " -lookat " << lookat
+     << " -up " << up
+     << " -hfov " << hfov
+     << " -vfov " << vfov
+     << " -aperture " << aperture
+     << " -focal_length " << focal_length;
+
+
+  // Output the offset if one is set.
+  if (stereo_offset != 0.0) {
+    os << " -offset " << stereo_offset;
+  }
+
+
+  os << " )" << std::endl;
+}
+
+Camera* ThinLensCamera::create(const vector<string>& args)
+{
+  return new ThinLensCamera(args);
+}
+
+void ThinLensCamera::setup()
+{
+  direction=lookat-eye; // the normal vector
+
+  direction.normalize();
+  up.normalize();
+
+  v=Cross(direction, up);
+  if(v.length2() == 0){
+    std::cerr << __FILE__ << " line: " << __LINE__
+              << " Ambiguous up direciton... "
+              << "lookat = "<< lookat
+              << ", eye = "<< eye
+              << ", direciton = "<< direction
+              << ", up = "<< up
+              << ", v = " << v
+              << "\n";
+  }
+  v.normalize();
+
+  u=Cross(v, direction);
+  u.normalize();
+
+  height=tan(vfov*(Real)(0.5*M_PI/180.0));
+  u*=height;
+  width=tan(hfov*(Real)(0.5*M_PI/180.0));
+  v*=width;
+
+}
+
+void ThinLensCamera::makeRays(const RenderContext& context, RayPacket& rays) 
const
+{
+  ASSERT(rays.getFlag(RayPacket::HaveImageCoordinates));
+  ASSERT(rays.getFlag(RayPacket::ConstantEye));
+  Packet<Real> lens_coord_x;
+  Packet<Real> lens_coord_y;
+
+  context.rng->nextPacket(lens_coord_x, rays);
+  context.rng->nextPacket(lens_coord_y, rays);
+  
+  for(int i = rays.begin(); i < rays.end(); ++i) {
+    Real imageX = rays.getImageCoordinates(i, 0);
+    Real imageY = rays.getImageCoordinates(i, 1);
+
+    Real theta = 2.0 * M_PI * lens_coord_x.get(i);
+    Real r = radius * SCIRun::Sqrt( lens_coord_y.get(i) );
+    
+    Vector origin = eye + r*Cos(theta)*u + r*Sin(theta)*v;
+    
+    rays.setRay(i, origin, imageX*v+imageY*u+direction*focal_length);
+  }
+}
+
+void ThinLensCamera::scaleFOV(Real scale)
+{
+  Real fov_min = 0;
+  Real fov_max = 180;
+  hfov = RtoD(2*Atan(scale*Tan(DtoR(hfov/2))));
+  hfov = Clamp(hfov, fov_min, fov_max);
+  vfov = RtoD(2*Atan(scale*Tan(DtoR(vfov/2))));
+  vfov = Clamp(vfov, fov_min, fov_max);
+  setup();
+}
+
+void ThinLensCamera::translate(Vector t)
+{
+  Vector trans(u*t.y()+v*t.x());
+
+  eye += trans;
+  lookat += trans;
+  setup();
+}
+
+// Here scale will move the eye point closer or farther away from the
+// lookat point.  If you want an invertable value feed it
+// (previous_scale/(previous_scale-1)
+void ThinLensCamera::dolly(Real scale)
+{
+  // Better make sure the scale isn't exactly one.
+  if (scale == 1) return;
+  Vector d = (lookat - eye) * scale;
+  eye    += d;
+
+  setup();
+}
+
+void ThinLensCamera::transform(AffineTransform t, TransformCenter center)
+{
+  Vector cen;
+  switch(center){
+  case Eye:
+    cen = eye;
+    break;
+  case LookAt:
+    cen = lookat;
+    break;
+  case Origin:
+    cen = Vector(0,0,0);
+    break;
+  }
+
+  Vector lookdir(eye-lookat);
+
+  AffineTransform frame;
+  frame.initWithBasis(v.normal(), u.normal(), lookdir.normal(), cen);
+
+  AffineTransform frame_inv = frame;
+  frame_inv.invert();
+
+  AffineTransform t2        = frame * t * frame_inv;
+  up     = t2.multiply_vector(up);
+  eye    = t2.multiply_point(eye);
+  lookat = t2.multiply_point(lookat);
+  setup();
+}
+
+void ThinLensCamera::autoview(const BBox bbox)
+{
+  Vector diag(bbox.diagonal());
+  Real w=diag.length();
+  Vector lookdir(eye-lookat);
+  lookdir.normalize();
+  Real scale = 1/(2*Tan(DtoR(hfov/2)));
+  Real length = w*scale;
+  lookat = bbox.center();
+  eye = lookat+lookdir*length;
+  setup();
+}
+
+void ThinLensCamera::reset( const Vector& eye_, const Vector& up_,
+                           const Vector& lookat_ )
+{
+  eye = eye_;
+  up = up_;
+  lookat = lookat_;
+
+  setup();
+}
+
+void ThinLensCamera::reset(Vector const& eye_, Vector const& up_,
+                          Vector const& lookat_, Real const hfov_,
+                          Real const vfov_)
+{
+  eye=eye_;
+  up=up_;
+  lookat=lookat_;
+  hfov=hfov_;
+  vfov=vfov_;
+  setup();
+}
+
+void ThinLensCamera::getBasicCameraData(BasicCameraData& cam) const
+{
+  cam = BasicCameraData(eye, lookat, up, hfov, vfov);
+}
+
+void ThinLensCamera::setBasicCameraData(BasicCameraData cam)
+{
+  eye = cam.eye;
+  lookat = cam.lookat;
+  up = cam.up;
+  hfov = cam.hfov;
+  vfov = cam.vfov;
+  setup();
+}
+
+void ThinLensCamera::preprocess(const PreprocessContext& context)
+{
+  if (context.proc != 0) {
+    context.done();
+    return;
+  }
+
+  Scene* scene = context.manta_interface->getScene();
+  if(!haveCamera){
+    const BasicCameraData* bookmark = scene->currentBookmark();
+    if(bookmark){
+      setBasicCameraData(*bookmark);
+      haveCamera = true;
+    } else {
+      eye = Vector(0,1,0);
+      lookat = Vector(0,0,0);
+      up = Vector(0, 0, 1);
+      hfov = 60;
+      vfov = 60;
+      BBox bbox;
+      scene->getObject()->computeBounds(context, bbox);
+      autoview(bbox);
+    }
+    haveCamera = true;
+  }
+
+  context.done();
+}

Added: trunk/Model/Cameras/ThinLensCamera.h
==============================================================================
--- (empty file)
+++ trunk/Model/Cameras/ThinLensCamera.h        Tue Sep 11 12:15:15 2007
@@ -0,0 +1,77 @@
+
+
+#ifndef Manta_Model_ThinLensCamera_h
+#define Manta_Model_ThinLensCamera_h
+
+#include <Interface/Camera.h>
+#include <Core/Geometry/Vector.h>
+#include <sgi_stl_warnings_off.h>
+#include <string>
+#include <vector>
+#include <sgi_stl_warnings_on.h>
+
+namespace Manta {
+  using namespace std;
+
+  class ThinLensCamera : public Camera {
+  public:
+    ThinLensCamera( const Vector& eye_, const Vector& lookat_,
+                          const Vector &up_, Real hfov_, Real vfov_, 
+                          Real focalDistance_, Real aperture_);
+    ThinLensCamera(const vector<string>& args);
+    virtual ~ThinLensCamera();
+    virtual void preprocess(const PreprocessContext& context);
+    virtual void makeRays(const RenderContext& context, RayPacket&) const;
+
+    // Camera manipulation
+    virtual void scaleFOV(Real);
+    virtual void translate(Vector);
+    virtual void dolly(Real);
+    virtual void transform(AffineTransform t, TransformCenter);
+    virtual void autoview(const BBox bbox);
+    virtual void output( std::ostream& os );
+
+    virtual void getBasicCameraData(BasicCameraData& cam) const;
+    // This is not pass by reference because it needs to be used in a 
transaction
+    virtual void setBasicCameraData(BasicCameraData cam);
+
+    static Camera* create(const vector<string>& args);
+
+    virtual Vector getPosition() const { return eye; }
+    virtual Vector getLookAt()   const { return lookat; };
+    virtual Vector getUp()       const { return up; };
+
+    virtual void reset( const Vector& eye_, const Vector& up_,
+                        const Vector& lookat_ );
+    virtual void reset(Vector const& eye_, Vector const& up_,
+                       Vector const& lookat_, Real const hfov_, Real const 
vfov_ );
+
+    void setStereoOffset( Real stereo_offset_ ) { stereo_offset = 
stereo_offset_; }
+    Real getStereoOffset() const { return stereo_offset; }
+
+    void setAperture( Real aperture_ ) { aperture = aperture_; radius = 
aperture/2.0; }
+    Real getAperture() const { return aperture; }
+
+    void setFocalLength( Real focal_length_ ) { focal_length = 
focal_length_; }
+    Real getFocalLength() const { return focal_length; }
+
+  protected:
+
+    Vector direction;
+    Vector u,v;
+    Vector eye;
+    Vector lookat;
+    Vector up;
+    Real  stereo_offset;
+    Real  hfov, vfov, width, height; // x and y field of view,
+                                            // width and height of image 
plane
+                                            // distance from eye to image 
plane
+    Real focal_length, aperture, radius;
+
+    void setup();
+    bool haveCamera;
+  };
+}
+
+
+#endif

---

• [Manta] r1720 - in trunk: Engine/Factory Model/Cameras, arobison, 09/11/2007

---

Archive powered by MHonArc 2.6.16.