ref_image.C

Go to the documentation of this file.

#include "color_id_texture.H"
#include "ref_image.H"

using namespace mlib;

HASH       RefImage::_hash(16);
HASH      RefImage2::_hash(16);
HASH     IDRefImage::_hash(16);
HASH TexMemRefImage::_hash(16);

uint IDRefImage::_red_bits   = 0;
uint IDRefImage::_green_bits = 0;
uint IDRefImage::_blue_bits  = 0;
uint IDRefImage::_alpha_bits = 0;

bool IDRefImage::_nonstandard_bits = false;

IDRefImage* IDRefImage::_instance = 0;

/**********************************************************************
 * RefImage:
 **********************************************************************/
RefImage* 
RefImage::lookup(CVIEWptr& v)
{
   if (!v) {
      err_msg( "RefImage::lookup: error -- view is nil");
      return 0;
   }
   if (!v->impl()) {
      err_msg( "RefImage::lookup: error -- view->impl() is nil");
      return 0;
   }

   // hash on the view implementation rather than the view itself
   long key = (long)v->impl();
   RefImage* ret = (RefImage*) _hash.find(key);
   if (!ret && (ret = new RefImage(v)))
      _hash.add(key, (void *)ret);
   return ret;
}

void 
RefImage::draw_FB() const 
{
   // before calling glRasterPos2i(),
   // first set up orthographic viewing
   // matrix for points in pixel coords:
   glMatrixMode(GL_MODELVIEW);
   glPushMatrix();
   glLoadIdentity();
   glMatrixMode(GL_PROJECTION);
   glPushMatrix();
   glLoadMatrixd(VIEW::peek()->pix_proj().transpose().matrix());

   glRasterPos2i(0,0);

   glPushAttrib(GL_ENABLE_BIT);
   glDisable(GL_BLEND);

   glDrawPixels(_width,_height,_format,_type,_values);

   glPopAttrib();

   glPopMatrix();
   glMatrixMode(GL_MODELVIEW);
   glPopMatrix();
}

int
RefImage::read_file(char* file)
{
   // load up the ref image with an image from a file

   // the Image class already has file I/O capabilities, so we just
   // use on of those and copy the data into the RefImage format:
   Image img;

   // try to read the file as an image (ppm or png):
   if (!img.load_file(file)) {
      err_msg( "RefImage::read_file: can't read file %s", file);
      return 0;
   }

   // resize this
   resize(img.width(), img.height());

   // get ready for the switch statement below where we read the data
   // according to the internal format of the Image, based on the bits
   // per pixel (bpp):
   uchar* data = img.data();
   uint i=0;
   switch(img.bpp()) {
    case 4:
      // R,G,B,A unsigned char's
      for (i=0; i<max(); i++) {
         val(i) = build_rgba(data[0], data[1], data[2], data[3]);
         data += 4;
      }
      break;
    case 3:
      // R,G,B unsigned char's
      for (i=0; i<max(); i++) {
         val(i) = build_rgba(data[0], data[1], data[2]);
         data += 3;
      }
      break;
    case 2:
      // luminance/alpha unsigned char's
      for (i=0; i<max(); i++) {
         val(i) = build_rgba(data[0], data[0], data[0], data[1]);
         data += 2;
      }
      break;
    case 1:
      // luminance unsigned char's
      for (i=0; i<max(); i++) {
         val(i) = build_rgba(data[0], data[0], data[0]);
         data += 1;
      }
      break;
    default:
      // it's not in there
      err_msg( "RefImage::read_file: unknown bits per pixel (%d) in image", img.bpp());
      return 0;
   }

   // no more errors are possible!
   return 1;
}

void 
RefImage::fill(uint fill_color)
{
   for (uint i=0; i<_max; i++) {
      val(i) = fill_color;
   }
}

int
RefImage::write_file(char* file)
{
   if (_format != GL_RGBA && _format != GL_RGB) {
      err_msg( "RefImage::write_file: unsupported format (%x)", _format);
      return 0;
   }

   return Image::write_png(
      _width,
      _height,
      (_format==GL_RGBA) ? 4 : 3,
      (GLubyte*)_values,
      str_ptr(file)
      );
}

int
RefImage::copy_rgb(Image& img) const
{
   // return an Image with same dimensions
   // as this, but formatted for RGB:

   // resize image
   if (!img.resize(_width,_height,3)) {
      err_msg( "RefImage::copy_rgb_image: can't resize image");
      return 0;
   }

   // copy data
   uchar* d = img.data();
   for (uint i=0; i<_max; i++) {
      uint v = val(i);
      *d++ = rgba_to_r(v);
      *d++ = rgba_to_g(v);
      *d++ = rgba_to_b(v);
   }

   return 1;
}

inline void
set_default_gl_state()
{
   glLineWidth(1.0);
   glDepthMask(GL_TRUE);
   glDepthFunc(GL_LESS);
   glEnable(GL_DEPTH_TEST);
   glDisable(GL_NORMALIZE);
   glDisable(GL_BLEND);
   glEnable(GL_CULL_FACE);
}

void
RefImage::update()
{
   glDrawBuffer(GL_BACK);
   glReadBuffer(GL_BACK);

   VIEWptr view = VIEW::peek();

   // set up lights
   view->setup_lights();

   glPushAttrib(GL_ENABLE_BIT);

   // set default state
   set_default_gl_state();

   glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE);
   glEnable(GL_COLOR_MATERIAL);
   glShadeModel(GL_SMOOTH);
  
   glViewport(0,0,_width,_height);

   glClearColor(1,1,1,1);
   glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

   draw_objects(view->drawn());

   glReadPixels(0,0,_width,_height,_format,_type,_values);

   glPopAttrib();

   int w, h;
   VIEW_SIZE(w,h);
   glViewport(0,0,w,h);
}

void
RefImage::draw_objects(CGELlist& drawn) const
{
   VIEWptr view = VIEW::peek();

   // setup projection matrix
   glMatrixMode(GL_PROJECTION);
   glLoadMatrixd(view->cam()->projection_xform().transpose().matrix());

   // get the camera position matrix
   Wtransf mat = view->cam()->xform().transpose();

   glMatrixMode(GL_MODELVIEW);
   for (int i=0; i < drawn.num(); i++) {
      glLoadMatrixd(mat.matrix());
      drawn[i]->draw_ref_img(_ref_img_type);
   }
}

bool
RefImage::find_val_in_box(uint v, Cpoint2i& center, uint rad) const
{
   // Return true if the given value v is found in an (n x n) square
   // region around the given center location, where n = 2*rad + 1.
   // E.g., if rad == 1 the search is within a 3 x 3 region.

   // Get bounds of search region, careful at image boundary:
   uint min_x = (uint) ::max(center[0] - rad, uint(0));
   uint max_x = (uint) ::min(center[0] + rad, uint(_width-1));
   uint min_y = (uint) ::max(center[1] - rad, uint(0));
   uint max_y = (uint) ::min(center[1] + rad, uint(_height-1));

   for (uint y=min_y; y<=max_y; y++) {
      uint d = y * _width;
      for (uint x=min_x; x<=max_x; x++)
         if (val(d + x) == v)
            return true;
   }
   return false;
}

bool
RefImage::find_val_in_box(uint v, uint mask , Cpoint2i& center, uint rad, int nbr) const
{
   // Return true if the given value v is found in an (n x n) square
   // region around the given center location, where n = 2*rad + 1.
   // E.g., if rad == 1 the search is within a 3 x 3 region.

   // XXX in this call we're looking only at a certain section 
   // of the bits, cause we're encoding more than just ID into
   // the color here    - philipd

   // Get bounds of search region, careful at image boundary:
   uint min_x = (uint) ::max(center[0] - rad, uint(0));
   uint max_x = (uint) ::min(center[0] + rad, uint(_width-1));
   uint min_y = (uint) ::max(center[1] - rad, uint(0));
   uint max_y = (uint) ::min(center[1] + rad, uint(_height-1));

   for (uint y=min_y; y<=max_y; y++) {
      uint d = y * _width;
      for (uint x=min_x; x<=max_x; x++)
         if ( (val(d + x) & mask) == (v & mask)) { 
            //we've found the right id ( upper bits match )
            //but should we do something more, like check
            //that parameter is in range?
            int found_l   = (int)(val(d+x)& 0x000000ff);
            int target_l  = (int)(v       & 0x000000ff);
            if ( abs( found_l - target_l ) <= nbr ) {  
               return true;
            }
         }
   }
   return false;
}

/**********************************************************************
 * RefImage2:
 **********************************************************************/
RefImage2* 
RefImage2::lookup(CVIEWptr& v)
{
   if (!v) {
      err_msg( "RefImage2::lookup: error -- view is nil");
      return 0;
   }
   if (!v->impl()) {
      err_msg( "RefImage2::lookup: error -- view->impl() is nil");
      return 0;
   }

   // hash on the view implementation rather than the view itself
   long key = (long)v->impl();
   RefImage2* ret = (RefImage2*) _hash.find(key);
   if (!ret && (ret = new RefImage2(v)))
      _hash.add(key, (void *)ret);
   return ret;
}

/**********************************************************************
 * IDRefImage:
 **********************************************************************/
IDRefImage* 
IDRefImage::lookup(CVIEWptr& v)
{
   if (!v) {
      err_msg( "IDRefImage::lookup: error -- view is nil");
      return 0;
   }
   if (!v->impl()) {
      err_msg( "IDRefImage::lookup: error -- view->impl() is nil");
      return 0;
   }

   // hash on the view implementation rather than the view itself
   long key = (long)v->impl();
   IDRefImage* ret = (IDRefImage*) _hash.find(key);
   if (!ret && (ret = new IDRefImage(v)))
      _hash.add(key, (void *)ret);
   return ret;
}

IDRefImage::IDRefImage(CVIEWptr& v) :
   RefImage(v, RCOLOR_ID) 
{
   _ref_img_type = RefImageClient::REF_IMG_ID;
   setup_bits(v);
}

void
IDRefImage::setup_bits(CVIEWptr& view)
{
   if (!view)
      return;

   // Only do it the first time
   if (_red_bits || _green_bits || _blue_bits) {
      // Already done, quit early. But check if it's the same answer.
      if (view->win()->red_bits()   != _red_bits   ||
          view->win()->green_bits() != _green_bits ||
          view->win()->blue_bits()  != _blue_bits  ||
          view->win()->alpha_bits() != _alpha_bits)
         err_msg( "IDRefImage::setup_bits: Error: mismatch of bits");
      return;
   }
   _red_bits    = view->win()->red_bits();
   _green_bits  = view->win()->green_bits();
   _blue_bits   = view->win()->blue_bits();
   _alpha_bits  = view->win()->alpha_bits();

   // XXX - alpha is not considered at this time
   _nonstandard_bits = (
      (_red_bits   != 8) ||
      (_green_bits != 8) ||
      (_blue_bits  != 8)
      );

   uint r,g,b,a,s,d; 

   r = view->win()->accum_red_bits();
   g = view->win()->accum_green_bits();
   b = view->win()->accum_blue_bits();
   a = view->win()->accum_alpha_bits();
   s = view->win()->stencil_bits();
   d = view->win()->depth_bits();

   err_msg( "");

   err_msg( "GL Vendor:       %s", glGetString(GL_VENDOR));
   err_msg( "GL Renderer:     %s", glGetString(GL_RENDERER));
   err_msg( "GL Version:      %s", glGetString(GL_VERSION));

   err_msg( "GL Color RGBA:   %u,%u,%u,%u",
            _red_bits, _green_bits, _blue_bits, _alpha_bits);
   err_msg( "GL Accum RGBA:   %u,%u,%u,%u", r,g,b,a);
   err_msg( "GL Stencil Bits: %u", s);
   err_msg( "GL Depth Bits:   %u", d);

   GLint num_units=0;
   glGetIntegerv(GL_MAX_TEXTURE_UNITS, &num_units);
   err_msg( "Texture units:   %d", num_units);

   err_msg( "");   
   
}

void
IDRefImage::draw_objects(CGELlist& drawn) const
{
   int i;

   VIEWptr view = VIEW::peek();

   // setup projection matrix
   glMatrixMode(GL_PROJECTION);
   glLoadMatrixd(view->cam()->projection_xform().transpose().matrix());

   // get the camera position matrix
   Wtransf mat = view->cam()->xform().transpose();

   // XXX - Lets hope people don't change the matrix mode, eh?
   glMatrixMode(GL_MODELVIEW);

   // Q: why keep loading the matrix inside the loops?
   //    as a defensive gesture? but each loop goes thru
   //    all the objects, though in many cases every object
   //    does a no-op. that makes for a lot of ogl calls
   //    where otherwise it could be a bunch of no-ops.

   //Triangles for see thru objects
   for (i=0; i < drawn.num(); i++) {     
      glLoadMatrixd(mat.matrix());
      drawn[i]->draw_ref_img(RefImageClient::REF_IMG_ID_PRE1);
   }

   //Clear Z buffer
   glClear(GL_DEPTH_BUFFER_BIT);

   //Hidden lines with z testing
   for (i=0; i < drawn.num(); i++) {
      glLoadMatrixd(mat.matrix());
      drawn[i]->draw_ref_img(RefImageClient::REF_IMG_ID_PRE2);
   }

   //Clear Z buffer - and only write z's!
   glClear(GL_DEPTH_BUFFER_BIT);
   glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);

   //Triangles for see thru objects (just write the z's)
   for (i=0; i < drawn.num(); i++) {
      glLoadMatrixd(mat.matrix());
      drawn[i]->draw_ref_img(RefImageClient::REF_IMG_ID_PRE3);
   }

   //Restore writing to color buffer
   glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);

   //Visible lines with z testing
   for (i=0; i < drawn.num(); i++) {
      glLoadMatrixd(mat.matrix());
      drawn[i]->draw_ref_img(RefImageClient::REF_IMG_ID_PRE4);
   }

   //Non-see thru objects to their business...
   for (i=0; i < drawn.num(); i++) {
      glLoadMatrixd(mat.matrix());
      drawn[i]->draw_ref_img(RefImageClient::REF_IMG_ID);
   }
}

bool
IDRefImage::search(
   CNDCpt&         c,              // center of search region
   double          screen_pix_rad, // search radius in screen pixels
   CSimplexFilter& filt,           // tells what kind of simplex to look for
   Point2i&        hit             // closest ref image pixel matching search
   )
{
   // Search around the given location within the given
   // radius (specified in units of screen pixels, not
   // pixels of this image), to find the closest Bsimplex
   // matching the criteria given by the filter function.

   // for safety disallow negative values for the radius.
   screen_pix_rad = ::max(0.0, screen_pix_rad);

   // convert radius in screen pixels to ndc units:
   double ndc_rad = VIEW::pix_to_ndc_scale() * screen_pix_rad;

   // now to pixel units in this image:
   double R = _half_min_dim * ndc_rad;
   // get the box containing the search region but not going
   // outside the boundaries of this image:
   Point2i center = ndc_to_pix(c);
   int      min_x = ::max(center[0] - int(ceil(R)), 0);
   int      max_x = ::min(center[0] + int(ceil(R)), int(_width-1));
   int      min_y = ::max(center[1] - int(ceil(R)), 0);
   int      max_y = ::min(center[1] + int(ceil(R)), int(_height-1));

   bool           ret = 0;
   double    min_dist = 0, d;
   for (int y = min_y; y <= max_y; y++) {
      for (int x = min_x; x <= max_x; x++) {
         Point2i cur(x,y);
         if ((d = cur.dist(center)) < R && // if we're in the radius and
             filt.accept(simplex(cur))  && // the simplex is acceptable
             (!ret || d < min_dist)) {     // and no winner or new winner
            ret      = true;
            hit      = cur;
            min_dist = d;
         }
      }
   }
   return ret;
}

Bsimplex* 
IDRefImage::find_near_simplex(
   CNDCpt&         c,              // location - center of search region
   double          screen_pix_rad, // search radius in screen pixels
   CSimplexFilter& filt            // tells what kind of simplex to look for
   )
{
   Point2i hit;

   if (search(c, screen_pix_rad, filt, hit))
      return simplex(hit);
   return 0;
}

Bedge* 
IDRefImage::find_neighbor(CNDCpt& p, Bedge* current, int radius) const 
{
   // check neighbors, spiralling out from middle
   Point2i center = ndc_to_pix(p);
   Bedge* temp = 0;
   Point2i check;
   for (int rad = 0; rad <= radius; rad++) {
      for (int i = -rad; i <= rad; i++) {
         for (int j = -rad; j <= rad; j++) {
            if ((abs(i)==rad) || (abs(j)==rad)) {
               check = Point2i(center[0]+i, center[1]+j);
               if (pix_in_range(check)  &&
                   (temp = edge(check)) &&
                   (temp != current)
                   && (temp->patch() == current->patch()) && (temp->is_sil()))
                  return temp;
            }
         }
      }
   }
   
   return 0; // no neighbor found
}


//  ARRAY<Bedge*>
//  IDRefImage::find_all_neighbors(CNDCpt& p, Patch* patch, int radius) const 
//  {
//     static ARRAY<Bedge*> neighbors(radius*radius);
//     neighbors.clear();
//     // find neighbors, spiralling out from middle
//     Point2i center = ndc_to_pix(p);
//     Bedge* temp = 0;
//     Point2i check;
//     for (int rad = 0; rad <= radius; rad++) {
//        for (int i = -rad; i <= rad; i++) {
//           for (int j = -rad; j <= rad; j++) {
//              if ((abs(i) <= rad) || (abs(j) <= rad)) {
//                 check = center + Vec2i(i,j);
//                 if (!pix_in_range(check))
//                    continue;
//                 temp = edge(check);
//                 if (!temp)
//                    continue;
//                 if ((temp->patch() == patch) && (temp->is_sil()))
//                    neighbors.add_uniquely(temp);
//              }
//           }
//        }
//     }
   
//     return neighbors; 
//  }



// XXX -- Is this change correct?  Original function is above.
//        Removed seemingly unnecessary outermost for-loop.
ARRAY<Bedge*>
IDRefImage::find_all_neighbors(CNDCpt& p, Patch* patch, int radius) const 
{
   Point2i center = ndc_to_pix(p);

   return find_all_neighbors(center, patch, radius);
}

ARRAY<Bedge*>
IDRefImage::find_all_neighbors(Cpoint2i& center, Patch* patch, int radius) const 
{
   static ARRAY<Bedge*> neighbors(radius*radius);
   neighbors.clear();
   // find neighbors, spiralling out from middle
   Bedge* temp = 0;
   Point2i check;
   for (int i = -radius; i <= radius; i++) {
      for (int j = -radius; j <= radius; j++) {
         check = center + Vec2i(i,j);
         if (!pix_in_range(check))
            continue;
         temp = edge(check);
         if (!temp)
            continue;
         if ((temp->patch() == patch) && (temp->is_sil()))
            neighbors.add_uniquely(temp);
      }
   }
   
   return neighbors; 
}

bool 
IDRefImage::is_simplex_near(CNDCpt& p, const Bsimplex* simp, int radius) const
{
   // check neighbors, spiralling (?) out from middle
   Point2i center = ndc_to_pix(p);
   Bsimplex* temp = 0;
   Point2i check;
   for (int rad = 0; rad <= radius; rad++) {
      for (int i = -rad; i <= rad; i++) {
         for (int j = -rad; j <= rad; j++) {
            if ((abs(i)==rad) || (abs(j)==rad)) {
               check = Point2i(center[0]+i, center[1]+j);
               if (pix_in_range(check) &&
                   (temp = simplex(check)) &&
                   (temp == simp))
                  return true;
            }
         }
      }
   }
   
   return false;
}

bool
IDRefImage::is_patch_sil_edge_near(
   CNDCpt& ndc,
   const Patch* patch,
   int radius
   ) const
{
   // check neighbors, spiralling (?) out from middle
   Point2i center = ndc_to_pix(ndc);
   Point2i check; 
   for (int rad = 0; rad <= radius; rad++) {
      for (int i = -rad; i <= rad; i++) {
         for (int j = -rad; j <= rad; j++) {
            if ((abs(i)==rad) || (abs(j)==rad)) {
               check = Point2i(center[0]+i, center[1]+j);
               if (is_patch_sil_edge(check, patch)) return true;
            }
         }
      }
   }
   return false;
}

Bface* 
VisRefImage::get_face(CNDCpt& cur, double screen_rad) 
{
   // Return the nearest Bface within the given screen region,
   // with a preference for front-facing Bfaces:
   
   Bface* ret = (Bface*)get_simplex(cur, screen_rad, FrontFacingBfaceFilter());
   return ret ? ret : (Bface*)get_simplex(cur, screen_rad, BfaceFilter());
}

Bface_list
VisRefImage::get_faces(const PIXEL_list& pix, double screen_rad)
{
   // Call get_face() on each screen point in sequence:

   Bface_list ret;
   for (int i=0; i<pix.num(); i++) {
      Bface* f = get_face(pix[i], screen_rad);
      if (f)
         ret.add_uniquely(f);
   }
   return ret;
}


Bface*          // Bface* at given subdivision level for a given screen point
VisRefImage::get_face_bc (
   Wvec& bc,    // returned: barycentric coords of near point on face
   CNDCpt& ndc, // given screen point
   double rad   // search radius 
   ) 
{
   // 1. Search the VisRefImage to find the nearest Bface
   //    within a radius of the given screen location.
   //    Get the face at currently drawn subdivision level.
   Bface* f = get_face(ndc, rad);

   // 2. Convert the screen location to a barycentric
   //    coordinate on the Bface.
   if (f)
      f->near_pt(ndc, bc);

   return f;
}

Bface*          // Bface* at given subdivision level for a given screen point
VisRefImage::get_sub_face(
   int level,   // given subdivision level
   Wvec& bc,    // returned: barycentric coords of near point on face
   CNDCpt& ndc, // given screen point
   double rad   // search radius 
   ) 
{
   Bface* f = get_face_bc(bc, ndc, rad);

   if (level == 0)
      return f;
   else if (f && LMESH::isa(f->mesh()))
      return ((Lface*)f)->bc_to_level(level, bc);
   else
      return 0;
}

Bface*          // Bface* at current mesh edit level for a given screen point
VisRefImage::get_edit_face(
   Wvec& bc,    // returned: barycentric coords of near point on face
   CNDCpt& ndc, // given screen point
   double rad   // search radius 
   ) 
{
   Bface* f = get_face_bc(bc, ndc, rad);

   if (f && LMESH::isa(f->mesh()))
      return ((Lface*)f)->bc_to_edit_level(bc);
   else
      return 0;
}

void
IDRefImage::update()
{
   glDrawBuffer(GL_BACK);
   glReadBuffer(GL_BACK);

   // disable lights
   glDisable(GL_LIGHTING);
   glDisable(GL_LIGHT0);
   glDisable(GL_LIGHT1);

   // set default state
   set_default_gl_state();

   glDisable(GL_COLOR_MATERIAL);
   glShadeModel(GL_FLAT);

   glViewport(0,0,_width,_height);

   glClearColor(0,0,0,0);
   glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

   draw_objects(VIEW::peek()->drawn());

   glReadPixels(0,0,_width,_height,_format,_type,_values);

   int w, h;
   VIEW_SIZE(w,h);
   glViewport(0,0,w,h);
}

/**********************************************************************
 * VisRefImage:
 **********************************************************************/

// factory class for producing VisRefImages
class VisRefImageFactory : public BaseVisRefImageFactory {
 public:
   virtual BaseVisRefImage* produce(CVIEWptr& v) { return new VisRefImage(v); }
};

VisRefImage::VisRefImage(CVIEWptr& v) :
   IDRefImage(v) 
{
   reset();
   observe();
}

void
VisRefImage::init()
{
   if (!BaseVisRefImage::_factory)
      BaseVisRefImage::_factory = new VisRefImageFactory;
}

bool
VisRefImage::need_update() 
{
   // this custom scaling could be moved into RefImage.
   //  (It resizes the ref image to match the aspect
   //   ratio of the view and to keep the minimum side
   //   no longer than 256 pixels).
   int w, h;
   _view->get_size(w,h);
   double scale = 1.0;
   int ref_w = 256, ref_h = 256;
   int min_side = min(w,h);
   if (min_side <= 256) {
      ref_w = w;
      ref_h = h;
   } else {
      scale = min_side / 256.0;
      if (w > h)
         ref_w = (int)round(w/scale);
      else
         ref_h = (int)round(h/scale);
   }

   return (resize(ref_w,ref_h) || _dirty);
}

void 
VisRefImage::debug(CNDCpt& p) const
{
   cerr << "VisRefImage::debug: ndc: " << p;
   uint id = ndc_to_uint(p);
   cerr << ", uint: " << id;
   GLuint v = val(id);
   cerr << ", val: " << v;
   uint key = rgba_to_key(v);
   cerr << ", key: " << key;
   Bsimplex* s = Bsimplex::lookup(key);
   cerr << ", simplex: " << s;
   cerr << endl;
}

void
VisRefImage::draw_objects(CGELlist& drawn) const
{
   VIEWptr view = VIEW::peek();

   // setup projection matrix
   glMatrixMode(GL_PROJECTION);
   glLoadMatrixd(view->cam()->projection_xform().transpose().matrix());

   // get the camera position matrix
   Wtransf mat = view->cam()->xform().transpose();

   glMatrixMode(GL_MODELVIEW);
   for (int i=0; i < drawn.num(); i++) {
      glLoadMatrixd(mat.matrix());
      drawn[i]->draw_vis_ref();
   }
}

void 
VisRefImage::observe() 
{
   if (_view) {
      // BMESHobs:
      subscribe_all_mesh_notifications();

      // CAMobs:
      _view->cam()->data()->add_cb(this);

      // DISPobs:
      disp_obs();

      // EXISTobs:
      exist_obs();

      // XFORMobs:
      xform_obs();

      // FRAMEobs:
      WORLD::get_world()->schedule(this);
   }
}

void 
VisRefImage::unobserve() 
{
   if (_view) {
      // BMESHobs:
      unsubscribe_all_mesh_notifications();

      // CAMobs:
      _view->cam()->data()->rem_cb(this);

      // DISPobs:
      unobs_display();

      // EXISTobs:
      unobs_exist();

      // XFORMobs:
      unobs_xform();

      // FRAMEobs:
      WORLD::get_world()->unschedule(this);
   }
}

int
VisRefImage::tick()
{
   if (_countup++ > 4 && _dirty)
      update();
   return 1;
}

uint
IDRefImage::key_to_rgba2(uint key) 
{
   // Convert a Bsimplex "key" value to an RGBA value. Assumes the
   // frame buffer does not store alpha. Thus the key should not store
   // any info in the highest-order byte. On non-intel platforms, we
   // shift the key value left by 8 bits, resulting in an RGBA value
   // with no info in the lowest order byte. This value can be written
   // to the frame buffer and later read back (as long as 8 bits is
   // allocated per color component as is usual). After shifting the
   // result 8 bits to the right, we end up with the original key
   // value. This is done in rgba_to_key(), below.

   // XXX -
   //   Handles other than 8 bits per component
   //   only on Intel platforms (pending fixes).

#if defined(WIN32) || defined(i386)

   // Intel platform: colors strored as ABGR, no shift needed
   if (_nonstandard_bits) {
      // bits per component is other than 8.
      //
      // divide up the info in 'key' into 3 groups with the same
      // number of bits as allotted to red, green, and blue color
      // components. arrange the 3 groups into 3 bytes of a 4-byte
      // unsigned int, which can be fed to OpenGL using
      // glColor4ubv().

      // E.g., if bits for red, green and blue components are 5, 6, 5,
      // respectively, then we want to rearrange the bits in 'key' as
      // follows:
      //
      // ******** ******** bbbbbggg gggrrrrr          key
      //
      //                  |
      //                  |
      //                  V
      //
      // ******** bbbbb*** gggggg** rrrrr***         rgba
      //    A        B        G        R

      // masks to select the 3 chunks of data within 'key':
      static uint mask_r = ((1<<_red_bits)   - 1);
      static uint mask_g = ((1<<_green_bits) - 1) << (_red_bits);
      static uint mask_b = ((1<<_blue_bits)  - 1) << (_red_bits + _green_bits);

      // shifts needed to place the blue and green chunks at the
      // proper position in the unsigned int:
      static int shift_r =  8 - _red_bits;
      static int shift_g = 16 - _red_bits - _green_bits;
      static int shift_b = 24 - _red_bits - _green_bits - _blue_bits;

      return (((key & mask_r) << shift_r) |
              ((key & mask_g) << shift_g) |
              ((key & mask_b) << shift_b));
   }

   // (Intel)
   // No fancy bit-fussing needed
   return key;

#else
   // non-Intel platform:
   // Colors stored as RGBA, shift data past A on the assumption
   // that the framebuffer doesn't actually store alpha:

   // XXX - should handle bits per component other than 8

   return ((key << 8) | 0xff);

#endif
}

uint 
IDRefImage::rgba_to_key2(uint rgba) 
{
   // companion method for key_to_rgba() -- see comment above

#if defined(WIN32) || defined(i386)
   if (_nonstandard_bits) {
      // fewer than 8 bits per component.
      //
      // select out valid bits and repack them into the 'key'
      // format. (i.e. the valid bits put back together to form an
      // integer value).

      // ******** bbbbb*** gggggg** rrrrr***         rgba
      //    A        B        G        R
      //
      //                  |
      //                  |
      //                  V
      //
      // ******** ******** bbbbbggg gggrrrrr          key


      // masks for selecting the valid bits where they lay within the
      // rgba unsigned int:
      static uint mask_r = ((1<<_red_bits)  -1) << ( 8 - _red_bits);
      static uint mask_g = ((1<<_green_bits)-1) << (16 - _green_bits);
      static uint mask_b = ((1<<_blue_bits) -1) << (24 - _blue_bits);

      // shifts needed to get the bits into position in the 'key'
      // unsigned int:
      static int shift_r =  8 - _red_bits;
      static int shift_g = 16 - _red_bits - _green_bits;
      static int shift_b = 24 - _red_bits - _green_bits - _blue_bits;
       
      return (((rgba & mask_r) >> shift_r) |
              ((rgba & mask_g) >> shift_g) |
              ((rgba & mask_b) >> shift_b));
                
   }

   // Intel:
   //   Colors stored as ABGR, no shift needed.
   //   But If alpha is not stored in framebuffer, 
   //   have to  mask away those garbage bits:
   if (_alpha_bits == 8)
      return rgba;
   else
      return (rgba & 0xffffff);

#else

   // Non-Intel:

   // XXX - should handle nonstandard bits here
   // colors stored as RGBA. undo the shift in key_to_rgba() above:
   return (rgba >> 8);
#endif
}

/**********************************************************************
 * TexMemRefImage: 
 **********************************************************************/
static bool debug_tmri = Config::get_var_bool("DEBUG_TEX_MEM_REF_IMAGE",false);

TexMemRefImage::TexMemRefImage(
   CVIEWptr& v,
   RefImageClient::ref_img_t img_type) :
   _view(v),
   _ref_img_type(img_type),
   _texture(0)
{
   _texture = new TEXTUREgl();
   assert(_texture);

   // let's try not doing power-of-2 expanding:
   _texture->set_expand_image(false);

   _texture->set_tex_unit(TexUnit::REF_IMG + GL_TEXTURE0);
   _texture->set_mipmap(false);
   _texture->set_tex_fn(GL_REPLACE);
}

bool
TexMemRefImage::resize(const Point2i& dims)
{
   // resize to new dimensions:
   assert(_texture);

   // See if the image needs to be resized. This is needed if the
   // view's width or height are larger than the image's width or height:
   const Image& img = _texture->image();
   if (debug_tmri && (static_cast<int>(img.width())  != dims[0] ||
                      static_cast<int>(img.height()) != dims[1])) {
      cerr << "TexMemRefImage::resize: changing size from"
           << img.width() << "x" << img.height() << " to "
           << dims[0] << "x" << dims[1] << endl;
   }
   return _texture->image().resize(dims[0],dims[1]);
}

TexMemRefImage* 
TexMemRefImage::lookup(CVIEWptr& v)
{
   if (!v) {
      err_msg( "TexMemRefImage::lookup: error -- view is nil");
      return 0;
   }
   if (!v->impl()) {
      err_msg( "TexMemRefImage::lookup: error -- view->impl() is nil");
      return 0;
   }

   // hash on the view implementation rather than the view itself
   long key = (long)v->impl();
   TexMemRefImage* ret = (TexMemRefImage*) _hash.find(key);
   if (!ret && (ret = new TexMemRefImage(v)))
      _hash.add(key, (void *)ret);
   return ret;
}

void
TexMemRefImage::update()
{
   glDrawBuffer(GL_BACK);
   glReadBuffer(GL_BACK);

   VIEWptr view = VIEW::peek();

   glPushAttrib(GL_ENABLE_BIT | GL_COLOR_BUFFER_BIT);

   // set up lights
   view->setup_lights();

   // set default state
   set_default_gl_state();

   glColorMaterial(GL_FRONT_AND_BACK, GL_DIFFUSE);
   glEnable(GL_COLOR_MATERIAL);
   glShadeModel(GL_SMOOTH);
  
   glClearColor(1,1,1,1);
   glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

   draw_objects(view->drawn());

   read_FB();

   glPopAttrib();
}

inline bool
is_proper_3d_object(CGELptr& gel)
{
   return gel && gel->bbox().valid();
}

void
TexMemRefImage::draw_objects(CGELlist& drawn) const
{
   assert(_view);

   //sort into two groups 
   GELlist _blended;
   _blended.clear();
   GELlist _opaque;
   _opaque.clear();
   
   for (int i=0; i < drawn.num(); i++ ) {
      if (!drawn[i]->is_3D()) {
         ; // skip it
      } else if (drawn[i]->can_do_halo() && GEOM::do_halo_ref()) {
         _blended += drawn[i];
      } else {
         _opaque  += drawn[i];
      }
   }
   
   _blended.sort(GL_VIEW::depth_compare);

   // setup projection matrix
   glMatrixMode(GL_PROJECTION);
   glPushMatrix();
   glLoadMatrixd(_view->cam()->projection_xform().transpose().matrix());

   glMatrixMode(GL_MODELVIEW);
   glPushMatrix();
  
   // draw the two groups

   // get the viewing matrix
   Wtransf mat = _view->cam()->xform().transpose();

   for (int i=0; i < _opaque.num(); i++) {
      glLoadMatrixd(mat.matrix());
      _opaque[i]->draw_ref_img(_ref_img_type);
   }

   glEnable(GL_BLEND);                                // GL_ENABLE_BIT
   glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); // GL_COLOR_BUFFER_BIT
   for (int i=0; i < _blended.num(); i++) {
      glLoadMatrixd(mat.matrix());
      _blended[i]->draw_ref_img(_ref_img_type);
   }

   // restore projection matrix
   glMatrixMode(GL_PROJECTION);
   glPopMatrix();

   // restore modelview matrix
   glMatrixMode(GL_MODELVIEW);
   glPopMatrix();
}

void
TexMemRefImage::read_FB()
{
   // ensure dimensions match current window size:
   resize(_view->cur_size());

   glPushAttrib(GL_ENABLE_BIT);

   // Specify texture
   _texture->apply_texture();   // GL_ENABLE_BIT

   glReadBuffer(GL_BACK);

   const Image& img = _texture->image();

   // Copies the frame buffer into a texture in gpu texture memory.
   glCopyTexImage2D(
      GL_TEXTURE_2D,  // The target to which the image data will be changed.
      0,              // Level of detail, 0 is base detail
      GL_RGBA,        // internal format
      0,              // x-coord of lower left corner of the window
      0,              // y-coord of lower left corner of the window
      img.width(),    // width - must be a power of 2
      img.height(),   // height - must be a power of 2
      0);             // border size, must be 0 or 1

   glPopAttrib();
}

void
TexMemRefImage::draw_FB()
{
   // load identity for model matrix
   glMatrixMode(GL_MODELVIEW);
   glPushMatrix();
   glLoadIdentity();

   // set up to draw in XY coords:
   glMatrixMode(GL_PROJECTION);
   glPushMatrix();
   glLoadMatrixd(VIEW::peek()->xypt_proj().transpose().matrix());

   // set opengl state:
   glPushAttrib(GL_ENABLE_BIT);
   glDisable(GL_LIGHTING);
   glDisable(GL_DEPTH_TEST); // prevents depth testing AND writing
   glDisable(GL_BLEND); //so it doesn't bleed stuff from the front buffer through the low alpha areas

   // Draw a quad with our texture on it
   _texture->apply_texture(); // GL_ENABLE_BIT

   GLfloat t = 1;
   glColor4f(1, 1, 1, 1);
   glBegin(GL_QUADS);
   // draw vertices in CCW order starting at bottom left:
   GLenum unit = _texture->get_tex_unit();
   glMultiTexCoord2f(unit, 0, 0); glVertex2f(-t, -t);
   glMultiTexCoord2f(unit, 1, 0); glVertex2f( t, -t);
   glMultiTexCoord2f(unit, 1, 1); glVertex2f( t,  t);
   glMultiTexCoord2f(unit, 0, 1); glVertex2f(-t,  t);
   glEnd();

   // restore state:
   glPopAttrib();

   // restore projection matrix
   glMatrixMode(GL_PROJECTION);
   glPopMatrix();

   // restore modelview matrix
   glMatrixMode(GL_MODELVIEW);
   glPopMatrix();
}

// end of file ref_image.C

---