/home/hauberg/Dokumenter/Capture/humim-tracker-0.1/src/background_subtractor.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 BACKGROUND_SUBTRACTOR_H
#define BACKGROUND_SUBTRACTOR_H

#include "cxcore.h"
#include "cv.h"
#include "index.h"
#include "options.h"

class background_subtractor
{
public:
  background_subtractor ()
    {
      im = NULL;
      background = cvLoadImage ("Background_1.png", CV_LOAD_IMAGE_GRAYSCALE);
      
      size = cvGetSize (background);
      
      bw = cvCreateImage (size, IPL_DEPTH_8U, 1);
      tmp_im = cvCreateImage (size, IPL_DEPTH_8U, 1);
      dist = cvCreateImage (size, IPL_DEPTH_32F, 1);
    }
    
  ~background_subtractor ()
    {
      if (im != NULL)
        cvReleaseImage (&im);
      if (background != NULL)
        cvReleaseImage (&background);
      if (bw != NULL)
        cvReleaseImage (&bw);
      if (tmp_im != NULL)
        cvReleaseImage (&tmp_im);
      if (dist != NULL)
        cvReleaseImage (&dist);
    }
  
  bool refresh ()
    {
      bool retval = true;
      
      // Read data
      if (im != NULL)
        cvReleaseImage (&im);
      im = cvLoadImage ("image_1_001.png", CV_LOAD_IMAGE_GRAYSCALE);

      if (im == NULL)
        retval = false;
      else
        {
          // Subtract background
          cvAbsDiff (im, background, bw);
          cvThreshold (bw, tmp_im, 10, 255, CV_THRESH_BINARY);
  
          CvMemStorage *storage = cvCreateMemStorage (0);
          CvSeq *seq;
          cvFindContours (tmp_im, storage, &seq, sizeof (CvContour), CV_RETR_CCOMP, CV_CHAIN_APPROX_NONE);
    
          const CvScalar white = CV_RGB (255, 255, 255);
  
          cvZero (bw);
          for(CvSeq *c = seq; c != NULL; c = c->h_next)
            {
              if (c->total > 500)
                cvDrawContours (bw, c, white, white, -1, CV_FILLED, 8);
            }

          cvReleaseMemStorage(&storage);
  
          //cvDilate (bw, bw, NULL, 2);
          //cvErode (bw, bw, NULL, 4);

          // Compute distance map
          cvNot (bw, bw);
          cvDistTransform (bw, dist);
        }
      
      return retval;
    }
  
  CvSize get_size () const
    {
      return size;
    }
    
  IplImage* get_segmentation ()
    {
      return bw;
    }
  
  CvPoint project_into_segment (const CvPoint p) const
    {
       CvPoint retval;
  
      // Calculate derivative of 'dist' at 'p'
      const float val = GRAY32F (dist, p.x, p.y);
      if (val > 0) // outside
        {
          const float dx = 0.5 * (GRAY32F (dist, p.x + 1, p.y) - GRAY32F (dist, p.x - 1, p.y));
          const float dy = 0.5 * (GRAY32F (dist, p.x, p.y + 1) - GRAY32F (dist, p.x, p.y - 1));
          const float norm = sqrt (dx*dx + dy*dy);
          retval.x = p.x - dx * val / norm;
          retval.y = p.y - dy * val / norm;
        }
      else // inside (no need for projection)
        {
          retval.x = p.x;
          retval.y = p.y;
        }

      return retval;
    }

private:
  IplImage *im, *background;
  IplImage *bw, *dist, *tmp_im;
  CvSize size;
};

#endif // BACKGROUND_SUBTRACTOR_H