vsrl_manager.cxx

Go to the documentation of this file.

#include "vsrl_manager.h"
//:
// \file
// \brief This program was written to test the Dense Matching software
// \author
// G.W. Brooksby
// \date 02/13/03

#include <vcl_cstdlib.h>
#include <vcl_cmath.h>
#include <vcl_iostream.h>
#include <vil1/vil1_load.h>
#include <vil1/vil1_scale_intensities.h>
#include <vil1/vil1_save.h>
#include <vnl/vnl_double_2.h>
#include <vgui/vgui.h>
#include <vgui/vgui_dialog.h>
#include <vgui/vgui_image_tableau.h>
#include <vgui/vgui_viewer2D_tableau.h>
#include <vgui/vgui_easy2D_tableau.h>
#include <vgui/vgui_soview2D.h>
#include <vgui/vgui_grid_tableau.h>
#include <vgui/vgui_shell_tableau.h>
#include <vsrl/vsrl_stereo_dense_matcher.h>
#include <sdet/sdet_region_proc_params.h>
#include <sdet/sdet_region_proc.h>
#include <vdgl/vdgl_digital_curve.h>
#include <vdgl/vdgl_interpolator.h>
#include <vdgl/vdgl_edgel_chain.h>
#include <vtol/vtol_vertex_2d.h>
#include <vtol/vtol_vertex_2d_sptr.h>
#include <vtol/vtol_vertex.h>
#include <vtol/vtol_edge_2d.h>
#include <vtol/vtol_edge_2d_sptr.h>
#include <vtol/vtol_intensity_face.h>
#include <vepl/vepl_gradient_mag.h>
#include <vepl/vepl_gaussian_convolution.h>
#include <vepl/vepl_threshold.h>
#include <vsrl/vsrl_point_picker.h>
#include <vsrl/vsrl_results_dense_matcher.h>
#include <vsrl/vsrl_3d_output.h>
#include <vsrl/vsrl_region_disparity.h>
#include <vsrl/vsrl_image_correlation.h>
#include <vgel/vgel_multi_view_data.h>
#include <vgel/vgel_multi_view_data_vertex_sptr.h>
#include <vgel/vgel_kl.h>
#include <vgl/vgl_point_3d.h>
#include <rsdl/rsdl_point.h>
#include <rsdl/rsdl_kd_tree.h>
#if 0
#ifdef INCLUDE_JSEG
extern "C"
{
#include <jseg/jseg.h>
}
#endif
#endif
// static manager instance
vsrl_manager* vsrl_manager::instance_=0;

//ensure only one instance is created
vsrl_manager *vsrl_manager::instance()
{
  if (!instance_)
  {
    instance_ = new vsrl_manager();
    instance_->init();
  }
  return vsrl_manager::instance_;
}

vsrl_manager::vsrl_manager():vgui_wrapper_tableau(){}

vsrl_manager::~vsrl_manager(){}

void vsrl_manager::init()
{
  shadow_mean_ = 50.0;
  shadows_only_ = true;
  shadow_metric_ = NULL;
  // Load the image tableaux
  itabL_ = vgui_image_tableau_new();
  itabR_ = vgui_image_tableau_new();
  dimg_tab_ = vgui_image_tableau_new();  // disparity image tableau
  disparity_bias_=0;

  // Put the image tableaux into an easy2D tableau
  e2d0_ = vgui_easy2D_tableau_new(itabL_);
  e2d1_ = vgui_easy2D_tableau_new(itabR_);
  e2d2_ = vgui_easy2D_tableau_new(dimg_tab_);

  // Set up characteristics of points to be drawn
  e2d0_->set_foreground(1,0,0);
  e2d1_->set_foreground(1,0,0);
  e2d2_->set_foreground(1,0,0);
  e2d0_->set_point_radius(5);
  e2d1_->set_point_radius(5);
  e2d2_->set_point_radius(5);
  e2d0_->set_line_width(2);
  e2d1_->set_line_width(2);
  e2d2_->set_line_width(2);

  // Put the easy2D tableaux into the viewers
  vgui_viewer2D_tableau_sptr viewer0 = vgui_viewer2D_tableau_new(e2d0_);
  vgui_viewer2D_tableau_sptr viewer1 = vgui_viewer2D_tableau_new(e2d1_);
  vgui_viewer2D_tableau_sptr viewer2 = vgui_viewer2D_tableau_new(e2d2_);

  // Put the viewers into tableaux for picking points
  vpicker0_=new vsrl_point_picker(viewer0);
  vpicker1_=new vsrl_point_picker(viewer1);
  vpicker2_=new vsrl_point_picker(viewer2);

  //Put the viewers into a grid
  grid_ = new vgui_grid_tableau(3,1);
  grid_->add_at(vpicker0_, 0,0);
  grid_->add_at(vpicker1_, 1,0);
  grid_->add_at(vpicker2_, 2,0);
  grid_->set_selected(0,0);
  grid_->set_uses_paging_events(false); // disable paging
  grid_->set_grid_size_changeable(false); // disable adding panes

  // Put the grid into a shell tableau at the top the hierarchy
  vgui_shell_tableau_new shell(grid_);

  // Get a parameters object
  params_ = vsrl_parameters::instance();

  this->add_child(shell);
}

void vsrl_manager::quit()
{
  vcl_exit(1);
}

void vsrl_manager::load_left_image()
{
  vgui_dialog load_image_dlg("Load Image file");
  static vcl_string image_filename = "";
  static vcl_string ext = "*.*";
  load_image_dlg.file("Image Filename:", ext, image_filename);
  if (!load_image_dlg.ask()) return;
  imgL_ = vil1_load(image_filename.c_str());
  itabL_->set_image(imgL_);
  this->post_redraw();
  return;
}

void vsrl_manager::load_right_image()
{
  vgui_dialog load_image_dlg("Load Image file");
  static vcl_string image_filename = "";
  static vcl_string ext = "*.*";
  load_image_dlg.file("Image Filename:", ext, image_filename);
  if (!load_image_dlg.ask()) return;
  imgR_ = vil1_load(image_filename.c_str());
  itabR_->set_image(imgR_);
  this->post_redraw();
  return;
}

void vsrl_manager::load_disparity_image()
{
  vgui_dialog load_image_dlg("Load Disparity Image file");
  static vcl_string image_filename = "";
  static vcl_string ext = "*.*";
  load_image_dlg.file("Disparity Image Filename:", ext, image_filename);
  if (!load_image_dlg.ask()) return;
  disp_img_ = vil1_load(image_filename.c_str());
  vil1_memory_image_of<unsigned char> real_image(disp_img_);

  vil1_image scaled_image = scale_image(real_image);

  // Display the scaled image
  dimg_tab_->set_image(scaled_image);
  this->post_redraw();
}

void vsrl_manager::save_disparity_image()
{
  vgui_dialog save_image_dlg("Save Disparity Image file");
  static vcl_string image_filename = "";
  static vcl_string ext = "*.tif";
  save_image_dlg.file("Disparity Image Filename", ext, image_filename);
  if (!save_image_dlg.ask()) return;
  vil1_memory_image_of<unsigned char> disp(disp_img_);
  if (!vil1_save(disp,image_filename.c_str())) {
    vcl_cout << "Error saving disparity image!\n";
  }
  return;
}

void vsrl_manager::load_params_file()
{
  //
  vgui_dialog load_params_dlg("Load Dense Matcher Parameters file");
  static vcl_string params_filename = "";
  static vcl_string ext = "*.*";
  load_params_dlg.file("Dense Matcher Parameter Filename:", ext, params_filename);
  if (!load_params_dlg.ask()) return;

  // Due to the need for a non-const char* being fed to the .load function
  // we have to construct a filename that is NOT const!
  char* filename = new char[params_filename.length()+1]; // get a new char* array
  params_filename.copy(filename,params_filename.length()); // copy the string into it
  filename[params_filename.length()]=0; //add null terminator
  params_->load(filename); // load the parameters file
  disparity_bias_ = params_->correlation_range;
  delete [] filename;  // delete the filename
}

void vsrl_manager::point_pick()
{
  vcl_cerr << "vsrl_manager::point_pick() not yet implemented\n";
  return;
}

void vsrl_manager::clear_all()
{
  e2d0_->clear();
  e2d1_->clear();
  e2d2_->clear();
  this->post_redraw();
  return;
}

bool vsrl_manager::handle(vgui_event const & event)
{
  this->child.handle(event);

  if (event.type == vgui_BUTTON_DOWN &&
      event.button == vgui_LEFT &&
      !event.modifier)
    {
      put_points();
    }
  else if (event.type == vgui_BUTTON_DOWN &&
           event.button == vgui_LEFT &&
           event.modifier == vgui_SHIFT)
    {
      put_lines();
    }
  else if (event.type == vgui_BUTTON_DOWN &&
           event.button == vgui_MIDDLE &&
           event.modifier == vgui_SHIFT)
    {
      vgl_point_2d<float>  pos = vpicker0_->get_point();  // get the last point picked
      vcl_cout << "handle: pos = " << pos << vcl_endl;
      int x = int(pos.x()); int y = int(pos.y()); // convert to int.
      show_correlations(x,y);
    }
  return true;
}

bool vsrl_manager::validate_point(vgl_point_2d<float> const& pt)
{
  if (pt.x() < 0 ||
      pt.y() < 0 ||
      pt.x() >= disp_img_.cols() ||
      pt.y() >= disp_img_.rows() )
    {
      vcl_cout << "Error: point out of range of disparity image.\n";
      return false;
    }
  else
    return true;
}

int vsrl_manager::get_disparity(vgl_point_2d<float> const& pt)
{
  vil1_memory_image_of<unsigned char> disp(disp_img_);
  int pixel_val = disp(int(pt.x()),int(pt.y()));
  if (pixel_val > 0) {
    // we subtract the disparity bias, plus 1 for the indexing offset
    //    pixel_val -= (disparity_bias_ + 1);
    pixel_val -= (params_->correlation_range + 1);
    vcl_cout << "Disparity: " << pixel_val << vcl_endl;
  }
  return pixel_val;
}

bool vsrl_manager::put_points()
{
  unsigned r=0, c=0;
  grid_->get_last_selected_position(&c, &r);

  // determine which grids to update
  vgl_point_2d<float> pos;
  // Point Picked in Left Pane
  if (c==0)
  {
    pos = vpicker0_->get_point();  // get the last point picked
    vcl_cout << "put_points: pos = " << pos << vcl_endl;
    if (!validate_point(pos)) return true;
    int disp = get_disparity(pos);
    vpicker1_->put_point(pos.x()+disp,pos.y());
    vpicker2_->put_point(pos.x(),     pos.y());
  }
  // Point Picked in Right Pane
  if (c==1)
  {
    pos = vpicker1_->get_point();  // get the last point picked
    if (!validate_point(pos)) return true;
    int disp = get_disparity(pos);
    vpicker0_->put_point(pos.x()-disp,pos.y());
    vpicker2_->put_point(pos.x(),     pos.y());
  }
  // Point Picked in Disparity Pane
  if (c==2)
  {
    pos = vpicker2_->get_point();  // get the last point picked
    if (!validate_point(pos)) return true;
    int disp = get_disparity(pos);
    vpicker0_->put_point(pos.x(),     pos.y());
    vpicker1_->put_point(pos.x()+disp,pos.y());
  }
  this->post_redraw();
  return true;
}

bool vsrl_manager::put_lines()
{
  unsigned r=0, c=0;
  grid_->get_last_selected_position(&c, &r);

  // determine which grids to update
  vgl_point_2d<float> pos;
  // Point Picked in Left Pane
  if (c==0)
  {
    pos = vpicker0_->get_point();  // get the last point picked
    vpicker1_->put_H_line(pos.x(),pos.y());
    vpicker2_->put_H_line(pos.x(),pos.y());
  }
  // Point Picked in Right Pane
  if (c==1)
  {
    pos = vpicker1_->get_point();  // get the last point picked
    vpicker0_->put_H_line(pos.x(),pos.y());
    vpicker2_->put_H_line(pos.x(),pos.y());
  }
  // Point Picked in Disparity Pane
  if (c==2)
  {
    pos = vpicker2_->get_point();  // get the last point picked
    vpicker0_->put_H_line(pos.x(),pos.y());
    vpicker1_->put_H_line(pos.x(),pos.y());
  }
  this->post_redraw();
  return true;
}

bool vsrl_manager::do_dense_matching()
{
  if (!imgL_ || !imgR_) return false;

  static float sig = 1.0f;
  static float cutoff = 0.01f;
  static bool smoothing = false;
  vgui_dialog gs_dialog("Gaussian Smoothing");
  gs_dialog.field("Sigma:",sig);
  gs_dialog.field("Cutoff:",cutoff);
  gs_dialog.checkbox("Perform Gaussian Smoothing",smoothing);
  if (!gs_dialog.ask()) return false;

  // If desired, we can do Gaussian smoothing.  This can be handy for
  // badly interlaced images.
  if (smoothing) {
    vil1_image left = vepl_gaussian_convolution(imgL_,sig,cutoff);
    vil1_image right = vepl_gaussian_convolution(imgR_,sig,cutoff);
    imgL_=left;
    imgR_=right;
  }

  itabL_->set_image(imgL_);
  itabR_->set_image(imgR_);

  // The parameters used will be the default parameters or
  // the parameters loaded manually from a file.
  // Now create a dense matcher with the images that are loaded.
  vcl_cout << "Begin Stereo Dense Matcher...";
  vsrl_stereo_dense_matcher matcher(imgL_,imgR_);
  vcl_cout << "Setting Correlation Range...";
  matcher.set_correlation_range(params_->correlation_range);
  vcl_cout << "Running Dense Matcher.\n";
  // Run the dense matcher.
  matcher.execute();

  // Get & display the disparity image
  // Get a buffer the size of the left image
  vil1_memory_image_of<unsigned char> buffer(imgL_.cols(),imgL_.rows());
  // Zero out the buffer
  for (int x=0;x<buffer.width();x++)
    for (int y=0;y<buffer.height();y++)
      buffer(x,y)=0;
  // Get the disparities into the buffer
  for (int y=0;y<buffer.height();y++) {
    for (int x=0;x<buffer.width();x++) {
      int disparity = matcher.get_disparity(x,y);
      int value = disparity + params_->correlation_range+1;
      if (value < 0)
        value = 0;
      if (value>2*params_->correlation_range+1)
        value=0;
      buffer(x,y)=value;
    }
  }

  // Display the disparity image
  disp_img_ = buffer;
  vil1_image scaled_image = scale_image(buffer);
  dimg_tab_->set_image(scaled_image);

  vcl_cout << "Dense Matcher complete.\n";
  this->post_redraw();
  return true;
}

vil1_image vsrl_manager::scale_image(vil1_memory_image_of<unsigned char> img)
{
  double maxval = 0;
  double minval = 1e15;
  for (int x=0;x<img.width();x++) {
    for (int y=0;y<img.height();y++) {
      if (img(x,y) > maxval) {
        maxval = img(x,y);
      }
      if (img(x,y) < minval) {
        minval = img(x,y);
      }
    }
  }
  vcl_cout << "vsrl_manager::scale_image<unsigned char> - Max = " << maxval
           << ", Min = " << minval << vcl_endl;

  double scale = 255.0/maxval;
  double shift = 0;
  vil1_image scaled_image = vil1_scale_intensities(img, scale, shift);
  return scaled_image;
}

vil1_image vsrl_manager::scale_image(vil1_memory_image_of<double> img)
{
  double maxval = 0;
  double minval = 1e15;
  for (int x=0;x<img.width();x++) {
    for (int y=0;y<img.height();y++) {
      if (img(x,y) > maxval) {
        maxval = img(x,y);
      }
      if (img(x,y) < minval) {
        minval = img(x,y);
      }
    }
  }
  vcl_cout << "vsrl_manager::scale_image<double> - Max = " << maxval
           << ", Min = " << minval << vcl_endl;

  double scale = 255.0/maxval;
  double shift = 0;
  vil1_image scaled_image = vil1_scale_intensities(img, scale, shift);
  return scaled_image;
}

void vsrl_manager::find_regions()
{
  this->clear_all();
  static bool debug = false;
  static bool agr = true;
  static bool residual = false;
  static sdet_detector_params dp;
  vgui_dialog region_dialog("Edgel Regions");
  region_dialog.field("Gaussian sigma", dp.smooth);
  region_dialog.field("Noise Threshold", dp.noise_multiplier);
  region_dialog.checkbox("Automatic Threshold", dp.automatic_threshold);
  region_dialog.checkbox("Agressive Closure", agr);
  region_dialog.checkbox("Compute Junctions", dp.junctionp);
  region_dialog.checkbox("Debug", debug);
  region_dialog.checkbox("Residual Image", residual);
  region_dialog.field("Shadow Mean Intensity Threshold", shadow_mean_);
  region_dialog.checkbox("Display Only Shadow Regions", shadows_only_);
  if (!region_dialog.ask())
    return;
  if (agr)
    dp.aggressive_junction_closure=1;
  else
    dp.aggressive_junction_closure=0;

  sdet_region_proc_params rpp(dp, true, debug, 2);
  sdet_region_proc rp(rpp);
  rp.set_image(imgL_);
  rp.extract_regions();
  if (debug)
  {
    vil1_image ed_img = rp.get_edge_image();
    vgui_image_tableau_sptr itab =  e2d0_->get_image_tableau();
    if (!itab)
    {
      vcl_cout << "In segv_segmentation_manager::regions() - null image tableau\n";
      return;
    }
    itab->set_image(ed_img);
  }
  if (!debug)
  {
    vcl_vector<vtol_intensity_face_sptr>& regions = rp.get_regions();
    this->find_shadows(regions);
    this->draw_regions(regions, true);
  }
  if (residual)
  {
    vil1_image res_img = rp.get_residual_image();
    vgui_image_tableau_sptr itab =  e2d0_->get_image_tableau();
    if (!itab)
    {
      vcl_cout << "In segv_segmentation_manager::regions() - null image tableau\n";
      return;
    }
    itab->set_image(res_img);
  }
}

void vsrl_manager::draw_regions(vcl_vector<vtol_intensity_face_sptr>& regions,
                                bool verts)
{
  // This segment of code is ripped from various places in brl...bgui.

  for (vcl_vector<vtol_intensity_face_sptr>::iterator rit = regions.begin();
       rit != regions.end(); rit++)
  {
    vtol_face_2d_sptr f = (*rit)->cast_to_face_2d();
    edge_list edges; f->edges(edges);

    vgui_soview2D_group* vsovg = new vgui_soview2D_group();

    for (edge_list::iterator eit = edges.begin(); eit != edges.end(); eit++)
    {
      vtol_edge_2d_sptr e = (*eit)->cast_to_edge_2d();

      vgui_soview2D_linestrip* e_line = new vgui_soview2D_linestrip();

      vsol_curve_2d_sptr c = e->curve();

      if (!c) {
        vcl_cout << "vsrl_manager::draw_regions - null curve.\n";
        return;
      }
      if (c->cast_to_vdgl_digital_curve())
      {
        vdgl_digital_curve_sptr dc = c->cast_to_vdgl_digital_curve();
        //get the edgel chain
        vdgl_interpolator_sptr itrp = dc->get_interpolator();
        vdgl_edgel_chain_sptr ech = itrp->get_edgel_chain();

        //n, x, and y are in the parent class vgui_soview2D_linestrip
        e_line->n = ech->size();
        //offset the coordinates for display (may not be needed)
        e_line->x = new float[e_line->n], e_line->y = new float[e_line->n];
        for (unsigned int i=0; i<e_line->n;i++)
        {
          vdgl_edgel ed = (*ech)[i];
          e_line->x[i]=ed.get_x();
          e_line->y[i]=ed.get_y();
        }
      }
      else
        vcl_cout << "vsrl_manager::draw_regions - attempt to draw an edge with unknown curve geometry\n";

      vsovg->ls.push_back(e_line);
    }

    e2d0_->add(vsovg);

    if (verts)
    {
      vertex_list vts; f->vertices(vts);
      for (vcl_vector<vtol_vertex_sptr>::iterator vit = vts.begin();
           vit != vts.end(); vit++)
      {
        vtol_vertex_2d_sptr v = (*vit)->cast_to_vertex_2d();
        e2d0_->add_point(v->x(),v->y());
      }
    }
  }
}

void
vsrl_manager::set_params()
{
  // establish the variables.  Should already have instantiated params_
  int corr_range=params_->correlation_range;
  double inner_cost=params_->inner_cost;
  double outer_cost=params_->outer_cost;
  double continuity_cost=params_->continuity_cost;
  int correlation_window_width=params_->correlation_window_width;
  int correlation_window_height=params_->correlation_window_height;
  double bias_cost=params_->bias_cost;
  double common_intensity_diff=params_->common_intensity_diff;

  vgui_dialog params_dialog("Dense Matcher Parameters");
  params_dialog.field("Correlation Range:", corr_range);
  params_dialog.field("Inner Cost:", inner_cost);
  params_dialog.field("Outer Cost:", outer_cost);
  params_dialog.field("Continuity Cost:",continuity_cost);
  params_dialog.field("Correlation Window Width:", correlation_window_width);
  params_dialog.field("Correlation Window Height:", correlation_window_height);
  params_dialog.field("Bias Cost:",bias_cost);
  params_dialog.field("Common Intensity Difference:",common_intensity_diff);
  if (!params_dialog.ask()) {
    return;
  }
  else {
    params_->correlation_range = corr_range;
    params_->inner_cost = inner_cost;
    params_->outer_cost = outer_cost;
    params_->continuity_cost = continuity_cost;
    params_->correlation_window_width = correlation_window_width;
    params_->correlation_window_height = correlation_window_height;
    params_->bias_cost = bias_cost;
    params_->common_intensity_diff = common_intensity_diff;
  }
  return;
}

void vsrl_manager::draw_north_arrow()
{
  // use a vector of length 10 for the north arrow
  north_.set(0.0,10.0);

  // (0,0) is the origin for the north vector
  /* vgui_soview2D_lineseg* line = */ draw_vector_at(&north_, 0.0f, 0.0f, 0.0);

  this->post_redraw();
  return;
}

//
// Draw the given vector at the specified point with the specified rotation.
// (x,y) = where to draw the vector
// theta = the angle through which the vector is rotated before drawing.
//
vgui_soview2D_lineseg*
vsrl_manager::draw_vector_at(vgl_vector_2d<float>* vec, float x, float y, float theta)
{
  // make the vector green
  e2d0_->set_foreground(0,1,0);

  // Apply rotation to get rot_vec
  vgl_vector_2d<float> rot_vec;
  rot_vec.x_ =  vec->x() * vcl_cos(theta) + vec->y() * vcl_sin(theta);
  rot_vec.y_ = -vec->x() * vcl_sin(theta) + vec->y() * vcl_cos(theta);

  // Apply translation
  float endx = rot_vec.x()+x;
  float endy = rot_vec.y()+y;

  // Create the lineseg & draw it
  vgui_soview2D_lineseg* vector = new vgui_soview2D_lineseg(x,y,endx,endy);
  e2d0_->add(vector);

  e2d0_->set_foreground(1,0,0);
  this->post_redraw();
  return vector;
}

// Calculate & Display Image Gradient magnitudes
//
vil1_image
vsrl_manager::show_gradient_mag(vil1_image* im_in)
{
  vil1_image im_out = vepl_gradient_mag(*im_in);
  disp_img_ = im_out;  // this line lets us save out the image
  //  vil1_image scaled_image = scale_image(im_out);
  dimg_tab_->set_image(im_out);
  this->post_redraw();
  return im_out;
}

// Calculate & Display Image Gradient directions
//
vil1_image
vsrl_manager::show_gradient_dir(vil1_memory_image_of<double> im_in)
{
  // calculate the gradient
  // I prefer to implement my own gradient operation because I want to handle the edges
  // more carefully and I want better control of what happens at inflection points of ATAN2.
  // The scale (40) and offset (128) keep the range of the ATAN2 function within the range of
  // the <unsigned char> image.
  vcl_cout << "vsrl_manager::show_gradient_dir() - Begin\n";

  vil1_memory_image_of<double> im_out(im_in.width(),im_in.height());

  const double shift=128;
  const double scale=40; // actually: 127/pi
  register double dx, dy;
  for (int x=0; x<im_out.width(); x++) {
    for (int y=0; y<im_out.height(); y++) {
      if (x==0) {
        dx = im_in(x+1,y) - im_in(x,y); // image edge
      }
      else {
        dx = im_in(x,y) - im_in(x-1,y);
      }
      if (y==0) {
        dy = im_in(x,y+1) - im_in(x,y); // image edge
      }
      else {
        dy = im_in(x,y) - im_in(x,y-1);
      }
      im_out(x,y) = vcl_atan2(dy,dx) * scale + shift;
    }
  }

  vil1_image scaled_image = scale_image(im_out);
  dimg_tab_->set_image(scaled_image);
  this->post_redraw();
  vcl_cout << "vsrl_manager::show_gradient_dir() - End\n";
  return im_out;
}

// Generic function called by menu to make testing easier
void
vsrl_manager::test_left_func()
{
  this->occlusion_map();
  this->post_redraw();
  return;
}

// Generic function called by menu to make testing easier
void
vsrl_manager::test_right_func()
{
  // get the regions from jseg algorithm
  //  vcl_vector<vdgl_digital_region*> regions = run_jseg(imgR_);
  //  find_shadows(regions);
  //  this->post_redraw();
  this->region_disparity();
  return;
}

// Generate 3D output & display range image
vil1_memory_image_of<double>
vsrl_manager::make_3d()
{
  // set up the dense matcher
  if (!disp_img_ || !imgL_ || !imgR_) {
    vil1_memory_image_of<double> null_image;
    return null_image; // Sanity check.
  }
  vsrl_results_dense_matcher matcher(imgL_,disp_img_);
  matcher.set_correlation_range(params_->correlation_range);
  vsrl_3d_output output(imgL_,imgR_);
  output.set_matcher(&matcher);
  //  Write the 3D output & triangles to out.dat
  output.write_output("out.dat");
  vil1_image scaled_image = scale_image(output.range_image_);
  itabR_->set_image(scaled_image);  // put the image in the viewer
  this->post_redraw();
  return output.range_image_;
}

// Make a vector of digital regions and pass the problem to
// find_shadows(vcl_vector<vdgl_digital_region*>) below.
//
void vsrl_manager::find_shadows(vcl_vector<vtol_intensity_face_sptr>& faces)
{
  vcl_vector<vdgl_digital_region*> reg_vec;

  for (vcl_vector<vtol_intensity_face_sptr>::iterator fit = faces.begin();
       fit != faces.end(); fit++) {
    vdgl_digital_region* reg = (*fit)->cast_to_digital_region();
    reg_vec.push_back(reg);
  }
  find_shadows(reg_vec);
  return;
}

//: This algorithm taken pretty much verbatim from the DDB/RegionSaliency class.
//  Repeated here for digital regions instead of intensity faces...
//

void vsrl_manager::find_shadows(vcl_vector<vdgl_digital_region*> regions)
{
  // Create an array to hold shadow metric
  // (First get rid of anything there already)
  if (shadow_metric_ != NULL) delete shadow_metric_;
  shadow_metric_ = new vcl_vector<float>(regions.size());

  e2d1_->set_foreground(0,0,1);
  e2d1_->set_point_radius(5);

  int i=0;
  vcl_vector<float>::iterator sm = shadow_metric_->begin();
  vcl_cout << "Shadow Threshold: " << shadow_mean_ << vcl_endl;

  for (vcl_vector<vdgl_digital_region*>::iterator rit = regions.begin();
       rit != regions.end(); ++rit,++i,++sm)
  {
    if ((*rit)->Npix() > 0)
    {
      (*rit)->ComputeIntensityStdev();
      vcl_cout << "Intensity Face: " << i << "  Io = " << (*rit)->Io()
               << "  I_stdev = " << (*rit)->Io_sd();
      if ((*rit)->Io() == 0)
        *sm=0.0;
      else if ((*rit)->Io() < shadow_mean_)
        *sm=1.0;
      else
      {
        // This segment of code is taken from the HistEntropy class
        // in TargetJr, GeneralUtility/Basics.  It is used to mimic
        // the operation of the shadow detection used in the DDB
        // RegionSaliency class.

        float m1=(*rit)->Io(); // Get the region mean
        float v1=(*rit)->Io_sd(); // Get the region Stdev.

        // Later we can adjust the shadow reference parameters.

        // For now, this is what we'll use...
        float m2 = shadow_mean_; // m2 is the reference shadow mean.
        float v2 = 1.0f; // v2 is the reference shadow stdev.

        if (m1==0 || m2==0)
          *sm=0.0;
        else if ( v1 < 1e-6 || v2 < 1e-6 )
          *sm=0.0;
        else
          *sm = vcl_exp(- vcl_fabs(0.693 * (m1-m2) * vcl_sqrt(1.0/(v1*v1) + 1.0/(v2*v2))));
      }
      vcl_cout << "  Shadow = " << *sm << vcl_endl;
    }

    if (*sm ==1)
      e2d1_->add_point((*rit)->Xo(),(*rit)->Yo());
  }
  e2d1_->set_foreground(1,0,0);
  e2d1_->set_point_radius(5);
}

// Though called "run_jseg" this routine does more than that.  After the jseg routine
// executes, the output of jseg is partitioned into digital_regions and a vector of
// the resulting digital regions is returned.
#if 0
vcl_vector<vdgl_digital_region*>
vsrl_manager::run_jseg(vil1_image image_in)
{
#ifndef INCLUDE_JSEG
  vcl_cout << "vsrl_manager::run_jseg - Error. JSEG not included in this compilation.\n";
  vcl_vector<vdgl_digital_region*> empty;
  return empty;
#else
  // Set up the JSEG parameters
  static float TQUAN=-1.0f;
  static int NSCALE=-1;
  static float threshcolor=-1.0f;
  vgui_dialog jseg_dialog("JSEG Parameters");
  jseg_dialog.field("Color Quantization Threshold (-1=automatic): ",TQUAN);
  jseg_dialog.field("Number of Scales (-1=automatic): ",NSCALE);
  jseg_dialog.field("Region Merge Threshold (-1=automatic): ",threshcolor);
  jseg_dialog.field("Shadow Mean Intensity Threshold: ", shadow_mean_);
  if (!jseg_dialog.ask()) return NULL;

  // Get the image for segmentation
  vil1_memory_image_of<unsigned char> im(image_in);
  unsigned char* cp = im.get_buffer();
  int nx = im.cols();
  int ny = im.rows();
  int dim = 1; // grayscale image

  // Run JSEG
  unsigned char* js_img = jseg(cp,dim,nx,ny,TQUAN,NSCALE,threshcolor);
  vil1_memory_image_of<unsigned char>* js_out = new vil1_memory_image_of<unsigned char>(js_img,nx,ny);

  // Now we have an "image" of the regions.  We need to sort it into
  // vdgl_digital_regions. We'll hold the regions in a vector.

  vcl_vector<vdgl_digital_region*> reg_vec;

  int reg_cntr = 0;  // A counter for regions

  // Initialize things with one region
  // We'll use a 3D region and use the Z coord. for the class label.
  vcl_cout << "Creating initial region.  #0\n";
  vdgl_digital_region* region1 = new vdgl_digital_region();

  // vdgl_digital_region(x,y,z,pix)
  // x & y are pixel coords. z is class label. pix=Intensity value of orignal image pixel.
  region1->IncrementMeans(0,0,(*js_out)(0,0),im(0,0));
  reg_vec.push_back(region1);  // Add the region to the vector.

  // Loop through all the image pixels, assigning them to regions
  // This pass only counts the pixels in regions and calculates their means.
  // Another pass is required later to actually assign inividual pixels to
  // their respective regions.
  // (See vdgl_digital_region::IncrementMeans(float,float,float,unsigned short)
  // for a description.
  for (int x=0;x<im.cols();x++) {