Text archives Help

---

Author: abe
Date: Mon Dec 19 22:37:09 2005
New Revision: 797

Added:
   trunk/Engine/ImageTraversers/FilteredImageTraverser.cc
   trunk/Engine/ImageTraversers/FilteredImageTraverser.h
Modified:
   trunk/CMakeLists.txt
   trunk/Core/Util/ThreadStorage.h
   trunk/Engine/Control/RTRT_register.cc
   trunk/Engine/ImageTraversers/CMakeLists.txt
   trunk/Engine/ImageTraversers/DissolveImageTraverser.cc
   trunk/Engine/ImageTraversers/DissolveTiledImageTraverser.cc
   trunk/Engine/ImageTraversers/TiledImageTraverser.cc
   trunk/Engine/ImageTraversers/TiledImageTraverser.h
   trunk/Interface/Fragment.h
   trunk/Interface/ImageTraverser.h
   trunk/Interface/PixelSampler.h
   trunk/Model/Textures/ImageTexture.h
Log:


Added FilteredImageTraverser (doesn't do anything interesting currently).

This image traverser keeps all of the fragments around and performs an 
operation across the whole tile after all of the pixels are rendered. The 
fragments are stored in thread local storage.
M    Core/Util/ThreadStorage.h
A    Engine/ImageTraversers/FilteredImageTraverser.cc
A    Engine/ImageTraversers/FilteredImageTraverser.h
M    Engine/Control/RTRT_register.cc

Changed MaxFragmentSize to MaxSize to match RayPacket static size name.
M    Model/Textures/ImageTexture.h
M    Interface/Fragment.h
M    Engine/ImageTraversers/DissolveTiledImageTraverser.cc
M    Engine/ImageTraversers/TiledImageTraverser.cc
M    Engine/ImageTraversers/TiledImageTraverser.h
M    Engine/ImageTraversers/CMakeLists.txt
M    Engine/ImageTraversers/DissolveImageTraverser.cc

Added license statement.
M    Interface/PixelSampler.h
M    Interface/ImageTraverser.h

Added release mode option to disable scirun asserts.
M    CMakeLists.txt


Modified: trunk/CMakeLists.txt
==============================================================================
--- trunk/CMakeLists.txt        (original)
+++ trunk/CMakeLists.txt        Mon Dec 19 22:37:09 2005
@@ -121,7 +121,7 @@
   # Check for CC compiler and add -LANG:std to it
   IF(CMAKE_CXX_COMPILER MATCHES "CC")
     FIRST_TIME_SET(CMAKE_CXX_FLAGS "-64 -LANG:std" STRING "Standard CXX 
flags")
-    FIRST_TIME_SET(CMAKE_CXX_FLAGS_RELEASE "-O3 -OPT:IEEE_arithmetic=3" 
STRING "Optimized Flags")
+    FIRST_TIME_SET(CMAKE_CXX_FLAGS_RELEASE "-DSCI_ASSERTION_LEVEL=0 -O3 
-OPT:IEEE_arithmetic=3" STRING "Optimized Flags")
   ENDIF(CMAKE_CXX_COMPILER MATCHES "CC")
 
   IF(CMAKE_C_COMPILER MATCHES "cc")
@@ -136,7 +136,7 @@
 ######################################################################
 # Check for Mac OS
 IF (APPLE)
-  FIRST_TIME_SET(CMAKE_CXX_FLAGS_RELEASE "-O3 -g -fgcse-sm -funroll-loops 
-fstrict-aliasing -fsched-interblock -falign-loops=16 -falign-jumps=16 
-falign-functions=16 -falign-jumps-max-skip=15 -falign-loops-max-skip=15 
-ffast-math -freorder-blocks -mpowerpc-gpopt -force_cpusubtype_ALL -mtune=G5 
-mcpu=G5 -mpowerpc64 -faltivec -mabi=altivec -mpowerpc-gfxopt 
-malign-natural" STRING "Optimized Flags")
+  FIRST_TIME_SET(CMAKE_CXX_FLAGS_RELEASE "-DSCI_ASSERTION_LEVEL=0 -O3 -g 
-fgcse-sm -funroll-loops -fstrict-aliasing -fsched-interblock 
-falign-loops=16 -falign-jumps=16 -falign-functions=16 
-falign-jumps-max-skip=15 -falign-loops-max-skip=15 -ffast-math 
-freorder-blocks -mpowerpc-gpopt -force_cpusubtype_ALL -mtune=G5 -mcpu=G5 
-mpowerpc64 -faltivec -mabi=altivec -mpowerpc-gfxopt -malign-natural" STRING 
"Optimized Flags")
 ENDIF (APPLE)
 
 

Modified: trunk/Core/Util/ThreadStorage.h
==============================================================================
--- trunk/Core/Util/ThreadStorage.h     (original)
+++ trunk/Core/Util/ThreadStorage.h     Mon Dec 19 22:37:09 2005
@@ -29,6 +29,7 @@
 // Abe Stephens
 
 #include <SCIRun/Core/Exceptions/InternalError.h>
+#include <SCIRun/Core/Util/Assert.h>
 
 #include <vector>
 
@@ -62,6 +63,8 @@
     class Token {
       friend class ThreadStorage;
       friend class Allocator;
+    public:
+      Token() { };
     private:
       size_t offset;
       size_t size;
@@ -114,14 +117,13 @@
 
     // Obtain an accessor to the storage. This is only possible after it has 
been allocated.
     void *get( int proc, const Token &token ) {
-      if (storage[proc]) {
 
-        if (token.offset >= requested)
-          throw InternalError( "Token offset greater than allocated 
storage", __FILE__, __LINE__ );
+      ASSERT(storage[proc]);
+      if (storage[proc]) {
 
-        return &storage[proc]+token.offset;
+        ASSERT(token.offset < requested);
+        return storage[proc]+token.offset;
       }
-      throw InternalError( "Attempt to access unallocated thread local 
storage.", __FILE__, __LINE__ );
     }
     
     // Called by each thread to allocate its memory. Will reallocate if 
necessary.

Modified: trunk/Engine/Control/RTRT_register.cc
==============================================================================
--- trunk/Engine/Control/RTRT_register.cc       (original)
+++ trunk/Engine/Control/RTRT_register.cc       Mon Dec 19 22:37:09 2005
@@ -9,6 +9,7 @@
 #include <Engine/ImageTraversers/DissolveTiledImageTraverser.h>
 #include <Engine/ImageTraversers/DissolveImageTraverser.h>
 #include <Engine/ImageTraversers/DissolveTiledImageTraverser.h>
+#include <Engine/ImageTraversers/FilteredImageTraverser.h>
 #include <Engine/LoadBalancers/CyclicLoadBalancer.h>
 #include <Engine/LoadBalancers/SimpleLoadBalancer.h>
 #include <Engine/LoadBalancers/WQLoadBalancer.h>
@@ -51,6 +52,7 @@
     engine->registerComponent("tiled", &TiledImageTraverser::create);
     engine->registerComponent("dissolve", &DissolveImageTraverser::create);
     engine->registerComponent("dissolvetiled", 
&DissolveTiledImageTraverser::create);
+    engine->registerComponent("filtered",&FilteredImageTraverser::create);
 
     // Register image types
     engine->registerComponent("null", &NullImage::create);

Modified: trunk/Engine/ImageTraversers/CMakeLists.txt
==============================================================================
--- trunk/Engine/ImageTraversers/CMakeLists.txt (original)
+++ trunk/Engine/ImageTraversers/CMakeLists.txt Mon Dec 19 22:37:09 2005
@@ -4,6 +4,8 @@
      ImageTraversers/DissolveImageTraverser.h
      ImageTraversers/DissolveTiledImageTraverser.cc
      ImageTraversers/DissolveTiledImageTraverser.h
+     ImageTraversers/FilteredImageTraverser.cc
+     ImageTraversers/FilteredImageTraverser.h
      ImageTraversers/NullImageTraverser.cc
      ImageTraversers/NullImageTraverser.h
      ImageTraversers/TiledImageTraverser.cc

Modified: trunk/Engine/ImageTraversers/DissolveImageTraverser.cc
==============================================================================
--- trunk/Engine/ImageTraversers/DissolveImageTraverser.cc      (original)
+++ trunk/Engine/ImageTraversers/DissolveImageTraverser.cc      Mon Dec 19 
22:37:09 2005
@@ -174,7 +174,7 @@
         // I'm not sure you want to do stereo
       }
       // Check to see if your fragment is full.  If it is, then render it.
-      if (frag.getSize() == Fragment::MaxFragmentSize) {
+      if (frag.getSize() == Fragment::MaxSize) {
         context.pixelSampler->renderFragment(context, frag);
 #if 0
         for(int f = 0; f < frag.getSize(); f++)

Modified: trunk/Engine/ImageTraversers/DissolveTiledImageTraverser.cc
==============================================================================
--- trunk/Engine/ImageTraversers/DissolveTiledImageTraverser.cc (original)
+++ trunk/Engine/ImageTraversers/DissolveTiledImageTraverser.cc Mon Dec 19 
22:37:09 2005
@@ -183,10 +183,10 @@
           // I'm not sure you want to do stereo
         }
         // Check to see if your fragment is full.  If it is, then render it.
-        if (frag.getSize() == Fragment::MaxFragmentSize) {
+        if (frag.getSize() == Fragment::MaxSize) {
 //           // It might be useful to check for ConsecutiveX, but only if
 //           // certain conditions exist.
-//           if ((xend-xstart) == Fragment::MaxFragmentSize)
+//           if ((xend-xstart) == Fragment::MaxSize)
 //             frag.testSetConsecutiveX();
           // Render the fragments
           context.pixelSampler->renderFragment(context, frag);

Added: trunk/Engine/ImageTraversers/FilteredImageTraverser.cc
==============================================================================
--- (empty file)
+++ trunk/Engine/ImageTraversers/FilteredImageTraverser.cc      Mon Dec 19 
22:37:09 2005
@@ -0,0 +1,214 @@
+
+/*
+  For more information, please see: http://software.sci.utah.edu
+
+  The MIT License
+
+  Copyright (c) 2005
+  Scientific Computing and Imaging Institute, University of Utah
+
+  License for the specific language governing rights and limitations under
+  Permission is hereby granted, free of charge, to any person obtaining a
+  copy of this software and associated documentation files (the "Software"),
+  to deal in the Software without restriction, including without limitation
+  the rights to use, copy, modify, merge, publish, distribute, sublicense,
+  and/or sell copies of the Software, and to permit persons to whom the
+  Software is furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included
+  in all copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+  OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+  THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+  FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+  DEALINGS IN THE SOFTWARE.
+*/
+
+#include <Engine/ImageTraversers/FilteredImageTraverser.h>
+
+#include <Core/Exceptions/IllegalArgument.h>
+#include <Core/Util/Args.h>
+#include <Interface/Context.h>
+#include <Interface/Fragment.h>
+#include <Interface/Image.h>
+#include <Interface/LoadBalancer.h>
+#include <Interface/PixelSampler.h>
+#include <Core/Thread/Mutex.h>
+#include <Core/Util/NotFinished.h>
+
+#include <SCIRun/Core/Util/Assert.h>
+
+using namespace Manta;
+
+ImageTraverser* FilteredImageTraverser::create(const vector<string>& args)
+{
+  return new FilteredImageTraverser(args);
+}
+
+FilteredImageTraverser::FilteredImageTraverser(const vector<string>& args)
+{
+  xtilesize = 32;
+  ytilesize = 2;
+  int argc = static_cast<int>(args.size());
+  for(int i = 0; i<argc;i++){
+    string arg = args[i];
+    if(arg == "-tilesize"){
+      if(!getResolutionArg(i, args, xtilesize, ytilesize))
+        throw IllegalArgument("FilteredImageTraverser -tilesize", i, args);
+    } else {
+      throw IllegalArgument("FilteredImageTraverser", i, args);
+    }
+  }
+}
+
+FilteredImageTraverser::~FilteredImageTraverser()
+{
+}
+
+void FilteredImageTraverser::setupBegin(SetupContext& context, int 
numChannels)
+{
+  context.loadBalancer->setupBegin(context, numChannels);
+  context.pixelSampler->setupBegin(context, numChannels);
+}
+
+void FilteredImageTraverser::setupDisplayChannel(SetupContext& context)
+{
+  
/////////////////////////////////////////////////////////////////////////////
+  // Setup the image traverser.
+  
+  // Determine the resolution.
+  bool stereo;
+  int xres, yres;
+  context.getResolution(stereo, xres, yres);
+
+  // Determine how many tiles are needed.
+  xtiles = (xres + xtilesize-1)/xtilesize;
+  ytiles = (yres + ytilesize-1)/ytilesize;
+
+  // Determine how much storage is necessary for one tile's worth of
+  // fragments.
+  int total_pixels = xtilesize * ytilesize;
+  total_allocated = ((total_pixels/Fragment::MaxSize)+1) * (stereo?2:1);
+
+  size_t bytes = sizeof( Fragment ) * total_allocated;
+    
+
+  // Request storage for persistent fragments.
+  storage_token = context.storage_allocator->requestStorage( bytes, 128 );
+
+  
/////////////////////////////////////////////////////////////////////////////
+  // Setup the rest of the stack.
+  
+  // Tell the load balancer how much work to assign.
+  int numAssignments = xtiles * ytiles;
+  context.loadBalancer->setupDisplayChannel(context, numAssignments);
+
+  // Continue setting up the rendering stack.
+  context.pixelSampler->setupDisplayChannel(context);
+}
+
+void FilteredImageTraverser::setupFrame(const RenderContext& context)
+{
+  
/////////////////////////////////////////////////////////////////////////////
+  // Setup the image traverser.
+  
+  
+  
/////////////////////////////////////////////////////////////////////////////
+  // Setup the rest of the stack.
+  context.loadBalancer->setupFrame(context);
+  context.pixelSampler->setupFrame(context);
+}
+
+void FilteredImageTraverser::renderImage(const RenderContext& context, 
Image* image)
+{
+  // Obtain a pointer to persistant storage.
+  Fragment *fragment_array =
+    (Fragment *)context.storage_allocator->get( context.proc, storage_token 
);
+
+  // Determine resolution
+  bool stereo;
+  int xres, yres;
+  image->getResolution(stereo, xres, yres);
+
+  // Call the load balancer to get work assignments.
+  int s,e;
+  while(context.loadBalancer->getNextAssignment(context, s, e)){
+
+    for(int assignment = s; assignment < e; assignment++){
+      
+      int xtile = assignment/ytiles;
+      int ytile = assignment%ytiles;
+      int xstart = xtile * xtilesize;
+      int xend = (xtile+1) * xtilesize;
+
+      if(xend > xres)
+        xend = xres;
+
+      int ystart = ytile * ytilesize;
+      int yend = (ytile+1) * ytilesize;
+
+      if(yend > yres)
+        yend = yres;
+
+      // Keep track of which persistent fragment to copy into.
+      int total_fragments = 0;
+
+      
/////////////////////////////////////////////////////////////////////////
+      // Create the fragments.
+      for(int y = ystart; y<yend; y++){
+        for(int x = xstart; x<xend; x+= Fragment::MaxSize){
+
+          // Set the fragment elements.
+          ASSERT( total_fragments < total_allocated );
+          
+          Fragment &frag = fragment_array[total_fragments++];
+          frag.setConsecutiveX( 0, x, xend, y );
+          
+        }
+      }
+
+      // Check to see if we need to render another copy in setero.
+      if(stereo){
+        for(int y = ystart; y<yend; y++){
+          for(int x = xstart; x<xend; x+= Fragment::MaxSize){
+            
+            // Create a Fragment that is consecutive in X pixels
+            // Fragment frag(0, x, xend, y);
+            
+            // Set the fragment elements.
+            ASSERT( total_fragments < total_allocated );
+            
+            Fragment &frag = fragment_array[total_fragments++];
+            frag.setConsecutiveX( 1, x, xend, y );            
+          }
+        }
+      }
+
+      
/////////////////////////////////////////////////////////////////////////
+      // Render the fragments.
+      for (int i=0;i<total_fragments; ++i) {
+        context.pixelSampler->renderFragment( context, fragment_array[i] );
+      }
+
+      // Filter the fragments.
+      for (int i=0;i<total_fragments; ++i) {
+        for (int f=0;f<fragment_array[i].getSize();++f) {
+          Color &color = fragment_array[i].get(f).color;
+          color *= Color(RGB(0.5,0.5,0.5));
+        }
+      }
+
+      // Set image values.
+      for (int i=0;i<total_fragments; ++i) {
+        image->set( fragment_array[i] );
+      }
+    }
+  }
+  
+  // Specify that the image is valid.
+  if(context.proc == 0)
+    image->setValid(true);
+}

Added: trunk/Engine/ImageTraversers/FilteredImageTraverser.h
==============================================================================
--- (empty file)
+++ trunk/Engine/ImageTraversers/FilteredImageTraverser.h       Mon Dec 19 
22:37:09 2005
@@ -0,0 +1,81 @@
+
+#ifndef Manta_Engine_FilteredImageTraverser_h
+#define Manta_Engine_FilteredImageTraverser_h
+
+/*
+  For more information, please see: http://software.sci.utah.edu
+
+  The MIT License
+
+  Copyright (c) 2005
+  Scientific Computing and Imaging Institute, University of Utah
+
+  License for the specific language governing rights and limitations under
+  Permission is hereby granted, free of charge, to any person obtaining a
+  copy of this software and associated documentation files (the "Software"),
+  to deal in the Software without restriction, including without limitation
+  the rights to use, copy, modify, merge, publish, distribute, sublicense,
+  and/or sell copies of the Software, and to permit persons to whom the
+  Software is furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included
+  in all copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+  OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+  THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+  FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+  DEALINGS IN THE SOFTWARE.
+*/
+
+#include <Interface/ImageTraverser.h>
+#include <Core/Util/ThreadStorage.h>
+#include <string>
+#include <vector>
+
+namespace Manta {
+  
+  using namespace std;
+
+  class Fragment;
+  
+  class FilteredImageTraverser : public ImageTraverser {
+  public:
+    FilteredImageTraverser( int xtilesize_, int ytilesize_ ) :
+      xtilesize( xtilesize_ ), ytilesize( ytilesize_ ) { };
+
+    FilteredImageTraverser(const vector<string>& args);
+    
+    
///////////////////////////////////////////////////////////////////////////
+    // ImageTraverser interface implemented by this class.
+    virtual ~FilteredImageTraverser();
+    virtual void setupBegin(SetupContext&, int numChannels);
+    virtual void setupDisplayChannel(SetupContext&);
+    virtual void setupFrame(const RenderContext& context);
+    virtual void renderImage(const RenderContext& context, Image* image);
+
+    static ImageTraverser* FilteredImageTraverser::create(const 
vector<string>& args);
+    
+  private:
+    FilteredImageTraverser(const FilteredImageTraverser&);
+    FilteredImageTraverser& operator=(const FilteredImageTraverser&);
+
+    // Tile size.
+    int xtilesize;
+    int ytilesize;
+
+    // Token to access per thread storage.
+    ThreadStorage::Token storage_token;
+    
+    // Buffer of persistant fragments.
+    int total_allocated;
+    Fragment *fragment_buffer;
+    
+    int xtiles;
+    int ytiles;
+  };
+}
+
+#endif

Modified: trunk/Engine/ImageTraversers/TiledImageTraverser.cc
==============================================================================
--- trunk/Engine/ImageTraversers/TiledImageTraverser.cc (original)
+++ trunk/Engine/ImageTraversers/TiledImageTraverser.cc Mon Dec 19 22:37:09 
2005
@@ -1,4 +1,32 @@
 
+/*
+  For more information, please see: http://software.sci.utah.edu
+
+  The MIT License
+
+  Copyright (c) 2005
+  Scientific Computing and Imaging Institute, University of Utah
+
+  License for the specific language governing rights and limitations under
+  Permission is hereby granted, free of charge, to any person obtaining a
+  copy of this software and associated documentation files (the "Software"),
+  to deal in the Software without restriction, including without limitation
+  the rights to use, copy, modify, merge, publish, distribute, sublicense,
+  and/or sell copies of the Software, and to permit persons to whom the
+  Software is furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included
+  in all copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+  OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+  THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+  FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+  DEALINGS IN THE SOFTWARE.
+*/
+
 #include <Engine/ImageTraversers/TiledImageTraverser.h>
 #include <Core/Exceptions/IllegalArgument.h>
 #include <Core/Util/Args.h>
@@ -96,7 +124,7 @@
         yend = yres;
       
       for(int y = ystart; y<yend; y++){
-        for(int x = xstart; x<xend; x+= Fragment::MaxFragmentSize){
+        for(int x = xstart; x<xend; x+= Fragment::MaxSize){
 
           // Create a Fragment that is consecutive in X pixels
           Fragment frag(0, x, xend, y);

Modified: trunk/Engine/ImageTraversers/TiledImageTraverser.h
==============================================================================
--- trunk/Engine/ImageTraversers/TiledImageTraverser.h  (original)
+++ trunk/Engine/ImageTraversers/TiledImageTraverser.h  Mon Dec 19 22:37:09 
2005
@@ -2,6 +2,34 @@
 #ifndef Manta_Engine_TiledImageTraverser_h
 #define Manta_Engine_TiledImageTraverser_h
 
+/*
+  For more information, please see: http://software.sci.utah.edu
+
+  The MIT License
+
+  Copyright (c) 2005
+  Scientific Computing and Imaging Institute, University of Utah
+
+  License for the specific language governing rights and limitations under
+  Permission is hereby granted, free of charge, to any person obtaining a
+  copy of this software and associated documentation files (the "Software"),
+  to deal in the Software without restriction, including without limitation
+  the rights to use, copy, modify, merge, publish, distribute, sublicense,
+  and/or sell copies of the Software, and to permit persons to whom the
+  Software is furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included
+  in all copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+  OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+  THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+  FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+  DEALINGS IN THE SOFTWARE.
+*/
+
 #include <Interface/ImageTraverser.h>
 #include <sgi_stl_warnings_off.h>
 #include <string>

Modified: trunk/Interface/Fragment.h
==============================================================================
--- trunk/Interface/Fragment.h  (original)
+++ trunk/Interface/Fragment.h  Mon Dec 19 22:37:09 2005
@@ -43,7 +43,7 @@
 
     // Creates a "Scan-line" fragment.
     Fragment(int which_eye, int xstart, int xend, int y) {
-      ASSERTRANGE(xend-xstart, 0, MaxFragmentSize+1);
+      ASSERTRANGE(xend-xstart, 0, MaxSize+1);
       int nx = xend-xstart;
       for(int i=0; i< nx;i++){
         data[i].x = i+xstart;
@@ -57,7 +57,7 @@
     ~Fragment() {}
 
     void addElement(int x, int y, int which_eye) {
-      ASSERT(size < MaxFragmentSize);
+      ASSERT(size < MaxSize);
       data[size].x = x;
       data[size].y = y;
       data[size].which_eye = which_eye;
@@ -65,12 +65,24 @@
     }
       
     void setElement( int i, int x, int y, int which_eye ) {
-      ASSERTRANGE(i, 0, MaxFragmentSize);
+      ASSERTRANGE(i, 0, MaxSize);
       data[i].x = x;
       data[i].y = y;
       data[i].which_eye = which_eye;
     }
 
+    void setConsecutiveX(int which_eye, int xstart, int xend, int y) {
+      ASSERTRANGE(xend-xstart, 0, MaxSize+1);
+      int nx = xend-xstart;
+      for(int i=0; i< nx;i++){
+        data[i].x = i+xstart;
+        data[i].y = y;
+        data[i].which_eye = which_eye;
+      }
+      flags = ConsecutiveX|ConstantEye;
+      size = nx;
+    }
+    
     
///////////////////////////////////////////////////////////////////////////
     // Accessors.
     int getFlags() const {
@@ -130,7 +142,7 @@
     
     // Constant number of Elements so that we do not have to
     // dynamically allocate them.
-    static const int MaxFragmentSize = 32;
+    static const int MaxSize = 32;
 
     // Represents a Pixel
     struct Element {
@@ -146,7 +158,7 @@
       return data[which];
     }
   private:
-    Element data[MaxFragmentSize];
+    Element data[MaxSize];
 
     // ConstantEye | ConsecutiveX
     int flags;

Modified: trunk/Interface/ImageTraverser.h
==============================================================================
--- trunk/Interface/ImageTraverser.h    (original)
+++ trunk/Interface/ImageTraverser.h    Mon Dec 19 22:37:09 2005
@@ -2,6 +2,34 @@
 #ifndef Manta_Interface_ImageTraverser_h
 #define Manta_Interface_ImageTraverser_h
 
+/*
+  For more information, please see: http://software.sci.utah.edu
+
+  The MIT License
+
+  Copyright (c) 2005
+  Scientific Computing and Imaging Institute, University of Utah
+
+  License for the specific language governing rights and limitations under
+  Permission is hereby granted, free of charge, to any person obtaining a
+  copy of this software and associated documentation files (the "Software"),
+  to deal in the Software without restriction, including without limitation
+  the rights to use, copy, modify, merge, publish, distribute, sublicense,
+  and/or sell copies of the Software, and to permit persons to whom the
+  Software is furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included
+  in all copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+  OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+  THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+  FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+  DEALINGS IN THE SOFTWARE.
+*/
+
 namespace Manta {
   class SetupContext;
   class RenderContext;

Modified: trunk/Interface/PixelSampler.h
==============================================================================
--- trunk/Interface/PixelSampler.h      (original)
+++ trunk/Interface/PixelSampler.h      Mon Dec 19 22:37:09 2005
@@ -4,6 +4,34 @@
 #define Manta_Interface_PixelSampler_h
 
 /*
+  For more information, please see: http://software.sci.utah.edu
+
+  The MIT License
+
+  Copyright (c) 2003-2005
+  Scientific Computing and Imaging Institute, University of Utah
+
+  License for the specific language governing rights and limitations under
+  Permission is hereby granted, free of charge, to any person obtaining a
+  copy of this software and associated documentation files (the "Software"),
+  to deal in the Software without restriction, including without limitation
+  the rights to use, copy, modify, merge, publish, distribute, sublicense,
+  and/or sell copies of the Software, and to permit persons to whom the
+  Software is furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included
+  in all copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+  OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+  THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+  FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+  DEALINGS IN THE SOFTWARE.
+*/
+
+/*
  *  Fragment.h: 
  *
  *  Written by:

Modified: trunk/Model/Textures/ImageTexture.h
==============================================================================
--- trunk/Model/Textures/ImageTexture.h (original)
+++ trunk/Model/Textures/ImageTexture.h Mon Dec 19 22:37:09 2005
@@ -213,8 +213,8 @@
 
     // Now copy over the data
     for(int y = 0; y < yres; y++) {
-      for(int x = 0; x < xres; x+=Fragment::MaxFragmentSize) {
-        int end = x + Fragment::MaxFragmentSize;
+      for(int x = 0; x < xres; x+=Fragment::MaxSize) {
+        int end = x + Fragment::MaxSize;
         if (end > xres) end = xres;
         Fragment fragment(0, x, end, y);
         image->get(fragment);

---

• [MANTA] r797 - in trunk: . Core/Util Engine/Control Engine/ImageTraversers Interface Model/Textures, abe, 12/19/2005

---

Archive powered by MHonArc 2.6.16.