/home/hauberg/Dokumenter/Capture/humim-tracker-0.1/src/cloud.h

Go to the documentation of this file.

// Copyright (C) 2011 Soren Hauberg
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 3
// of the License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, see <http://www.gnu.org/licenses/>.
 
#ifndef CLOUD_H
#define CLOUD_H

#include <string>
#include <vector>
#include <iostream>
#include <fstream>

#include "observation.h"
#include "options.h"
#include "math_types.h"
#include "calibration.h"
#include "project2d.h"
#include "opencv_helper.h"
#include "knn_cloud.h"

template <class observation_type>
class cloud : public observation<observation_type>
{
  public:
    cloud (const options &opts, const calibration &_calib)
      : frame (opts.data_start_idx ()),
        scale (opts.data_scaling ()),
        calib (_calib)
      {
        try
          {
            depth_threshold = opts.depth_threshold ();
            use_depth_threshold = true;
          }
        catch (missing_option)
          {
            use_depth_threshold = false;
          }
      };
    
    ~cloud () {}; // Just here to remove a warning
    
    virtual bool refresh (bool goto_next = true) = 0;
    
    virtual size_t size () const = 0;

    virtual void show () const = 0;
  
  protected:
    int frame;
    const double scale;
    bool use_depth_threshold;
    double depth_threshold;
    const calibration &calib;
};

typedef std::vector<vector3> point_vector;

class cloud3 : public cloud<point_vector>
{
  public:
    cloud3 (const options &opts, const calibration &_calib)
      : cloud<point_vector> (opts, _calib),
        downsample (opts.measure_downsampling ()),
        first_frame (frame)
      {
        background = cvCreateImage (cvSize (PROJ2D_SCALE * 1024.0, PROJ2D_SCALE * 768.0), IPL_DEPTH_8U, 1);
        try
          {
            depth_background = opts.depth_background ();
            use_background_subtraction = true;
          }
        catch (missing_option)
          {
            use_background_subtraction = false;
          }
      }
    
    void init ()
      {
        if (use_background_subtraction)
          use_background_subtraction = read_background (depth_background);
      }
    
    virtual bool read_background (const std::string &depth_background)
      {
        std::cerr << "warning: 'read:background' not implemented in 'cloud3'" << std::endl;
        return false;
      }
  
   void render_background_image (IplImage *retval, double scale = 1.0) const
     {
        cvZero (retval);
        const size_t num_points = points.size ();
        for (size_t k = 0; k < num_points; k++)
          {
            const CvPoint pixel = calib.world_to_pixel (points [k], scale);
            GRAY (retval, pixel.x, pixel.y) = 255;
          }
        cvMorphologyEx (retval, retval, NULL, NULL, CV_MOP_CLOSE);
     }
   
    void show () const
      {
        glPointSize (4.5f);
        //glPointSize (6.0f);

        glDisable (GL_LIGHTING);
        glBegin (GL_POINTS);
        for (size_t k = 0; k < points.size (); k++)
          {
            const vector3 rgb = colours [k];
            const vector3 p = points [k];
            glColor3f (rgb (0), rgb (1), rgb (2));
            glVertex3f (p [0], p [1], p [2]);
          }
        glEnd ();
        glEnable (GL_LIGHTING);
      }

    vector3 operator[] (const size_t i) const
      {
        return points [i];
      };

    size_t size () const
      {
        return points.size ();
      }

   const project2d& get_project2d () const
     {
       return proj2d;
     }
       
   const knn_cloud& get_knn_cloud () const
     {
       return nearest_cloud;
     }

   const knn_cloud& get_knn_bg_cloud () const
     {
       return bg_nearest_cloud;
     }

  protected:
    point_vector points, colours;
    const int downsample;
    const int first_frame;
    bool use_background_subtraction;
    std::string depth_background;
    project2d proj2d;
    knn_cloud nearest_cloud, bg_nearest_cloud;
    IplImage *background;
};
#endif // CLOUD_H