MixtureOfGaussians.hh

#ifndef _MIXTURE_OF_GAUSSIANS_HH_
#define _MIXTURE_OF_GAUSSIANS_HH_

/*
This file is part of the BIAS library (Basic ImageAlgorithmS).

Copyright (C) 2003-2009    (see file CONTACT for details)
Multimediale Systeme der Informationsverarbeitung
Institut fuer Informatik
Christian-Albrechts-Universitaet Kiel


BIAS is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version.

BIAS 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 Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License
along with BIAS; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/

#include "FeatureDetector/BlobDetectorBFS.hh"
#include <Base/Common/BIASpragmaStart.hh>
#include <Base/Common/W32Compat.hh>
#include <math.h>
#include <vector>
#include <Base/Image/Image.hh>
#include <Filter/Gauss.hh>
#ifdef BIAS_HAVE_PTHREADS
    #include <pthread.h>
#endif

namespace BIAS {

        enum MoGColorModel{
            MOG_RGB=0, //RGB
            MOG_RGBD,  //RGB with Depth
            MOG_NRGB,  //normalized RGB
            MOG_NRGBD, //normalized RGB with Depth
            MOG_HS,    //first 2 channels of HSL (Hue and Saturation)
            MOG_HSD   //first 2 channels of HSL with Depth      
        };

  /** @class MixtureOfGaussians
      @ingroup g_image
      @brief class for detecting changes in image sequences

      Automatically find and visualize changes in image sequences with a
      mixture of gaussians approach.

      After initialization of the algorithm it is possible to detect moving
      objects in a static scene,
      where the static scene is described as a background image.
      Detection is done by calculating the expectancy value of each pixel
      in the next frame given more than one gaussian distribution
      for each pixel. If the expectancy is not matched, a change is detected.

      This class has been tested on RGB images but should work on
      other color formats and grey value
      images. One and three color channels supported.

      see also ExampleMixtureOfGaussiansFrame.cpp
      @author fkellner */
  template <class StorageType>
  class BIASImage_EXPORT MixtureOfGaussians {
  public:
    /** @brief constructor
        @param numDistributions number of gaussian distributions for every pixel.
        @param sizeWindow window size for calculation of covariance
        @param updateFactor expectancy values get updated weighted with this factor.
        @param normalizeRGB. normalize RGB input images to rgb. */
    MixtureOfGaussians(const unsigned int numDistributions,
                       const unsigned int sizeWindow=3,
                       const float updateFactor=0.1,
                       const MoGColorModel colorModel=MOG_NRGB);
    /// @brief destructor
    ~MixtureOfGaussians();

    /** @brief init weights for background/object distinction
        @param maxWeight counter for how many times a pixel is matched can
        not exceed this maximum. this is decreased if a pixel is not matched.
        @param minWeight a pixel matched minWeight times is considered background
        @param errorMargin a pixel is matched if:
            pixelValue < errorMargin*errorMargin*expected value */
    int InitWeights(const int maxWeight,
                    const int minWeight,
                    const float errorMargin);

    void SetSmoothing(const bool smooth);

    /**
     * \brief set the used color model
     * note that the images have to be given in the correct model
     * no conversion will take place.
     */
    void SetColorModel(MoGColorModel model);
    
    /** @brief update calculations with new image
     * the image has to be formatted correctly, e.g for MoG on HSL 
     * images give only the first 2 channels in the image.
     * for MOG on HSLD give a three channel image with HSD
     * @param in new image */
    int Apply(BIAS::Image<StorageType>& in);

    /** @brief get normalized rgb image
        @param normalized normalized rgb image (or unchanged grey image) */
    int GetNormalizedImage(BIAS::Image<float> &normalized);

    /** @brief get image with current weights and distributions */
    int GetWeightImage(BIAS::Image<float> &weights);
    /** @brief get image with current max weights, only interesting for visualisation */
    int GetMaxWeightImage(BIAS::Image<float> &weight);
    
    int GetMatchValueImage(BIAS::Image<float> &match);

    /** @brief get image of detected scene changes.
        @param diff scene changes encoded 0 for no change, 255 for change (grey values) */
    int GetDifferenceImage(BIAS::Image<unsigned char> &diff);

    /** @brief get image of detected scene changes with visualisations of detection
        @param guiImage RGB Image with detected changes (white),
        bounding boxes (green), centers of mass (red), largest box (yellow) */
    int GetDifferenceImageWithVisuals(BIAS::Image<unsigned char> &guiImage);

    /** @brief get vector of corners for each bounding box of detected changes */
    int GetBoundingBoxes(std::vector<BIAS::BIASBlob> &corners);

    /** @brief get largest bounding box of detected changes */
    int GetLargestBoundingBox(BIAS::BIASBlob &corners);

    /** @brief get vector of images containing current guesses (distributions) */
    int GetCurrentDistributions(std::vector<Image<float> > &distributionImages);
    
    void SetUpdateFactor(float factor = 0.1f) {
      fUpdateFactor_ = factor;
    }
    
    void AllowCreationOfNewDistributions(bool allow) {
      bAllowNewDistributionCreation_ = allow;
    }
    
    void EnableCleanup( bool noise=false, bool holes=false, bool erosion=false) {
      bCleanUp_ = noise;
      bInverseCleanup_ = holes;
      bErosion_ = erosion;
    }
    
  protected:
    int CreateNormalizedImage_(const BIAS::Image<StorageType> &in,
                               BIAS::Image<float> &out);
    int Init_();
    int InitOnePixel_(unsigned int x,unsigned int y,unsigned int c,unsigned int distrib);
    int Update_();
  
    BIAS::Image<float> workImage_;
    BIAS::Image<float> weight_;
    BIAS::Image<float> guess_;
    BIAS::Image<float> cov_;
    BIAS::Image<float> maxWeight_;
    BIAS::Image<float> matchValueImage_;
    BIAS::Image<unsigned char> difference_;
    BIAS::Image<unsigned char> differenceSave_;
    BIAS::Image<unsigned char> differenceVisu_;
    BIAS::Image<unsigned char> differenceSmooth_;
    BIAS::Image<unsigned char> marker;
    BIAS::BlobDetectorBFS<unsigned char> blobDetector_;
    std::vector<BIAS::BIASBlob> corners_;
    bool blobDetectorRan_;  
    BIAS::Gauss<unsigned char, unsigned char> smoothResultFilter_;

    unsigned int width_, height_, channels_, workChannels_;
    unsigned int roiULx_, roiULy_, roiLRx_, roiLRy_;
    unsigned int dDistributions_, dFrames_, dWindow_, dCurDistributions_, dFrameCounter_;
    unsigned int dMaxWeight_, dMinWeight_;
    float fUpdateFactor_, fError_;
    bool bInited_, bSmooth_, bAllowNewDistributionCreation_;
    MoGColorModel colorModel_;
    bool bCleanUp_, bInverseCleanup_, bErosion_;
    float maxDepth_;
#ifdef BIAS_HAVE_PTHREADS
    pthread_mutex_t* guardimagemutex;
#endif
  };  //end class

}//end namespace
#include <Base/Common/BIASpragmaEnd.hh>


#endif