fgbgsegment.h

Go to the documentation of this file.

/*
 * Copyright (c) 2011, Mårten Björkman (celle@csc.kth.se) 
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met:
 *
 *  1.Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *  2.Redistributions in binary form must reproduce the above
 *    copyright notice, this list of conditions and the following
 *    disclaimer in the documentation and/or other materials provided
 *    with the distribution.  
 *  3.The name of Mårten Björkman may not be used to endorse or
 *    promote products derived from this software without specific
 *    prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */





#ifndef FGBGSEGMENT_H
#define FGBGSEGMENT_H

#include <vector>
#include <stdint.h>
#include "pyra/tpimage.h"
#include "matrix3.h"

class CudaSegment;

class FgBgSegment {

  friend class CudaSegment;

  //enum Labeling { BACKGROUND = 1, FLATSURFACE = 2, FOREGROUND = 3 };
  static const float eps = 1e-6f;
public:
  static const int hist_size = 12;

  class ColorModel { 
  protected:
    FgBgSegment &segm;
    
  public: 
    static const float weight = 0.01;
  public:
    float histogram[hist_size*hist_size];
    float greyhist[hist_size];
    float colorcost[hist_size*hist_size];
    float greycost[hist_size];
    ColorModel *prior;

    ColorModel(FgBgSegment &segm);

    ColorModel(const ColorModel &model);
    ColorModel &operator=(const ColorModel &model);
    ~ColorModel();


    float CreateHistogram(Image<float> &probabilities, bool allPoints);
    void SmoothAndNormalizeHist( float const* hist, float const* phist,
                                 int size, 
                                 float* const histogram, float* const cost);
    void NormalizeHist( float* const histogram,
                        float* const cost,
                        int size);

    void CreateHistogram(Image<uint8_t> &mask, bool allPoints);
    virtual void Update() { };
  };  
  
protected:
  
  class FlatSurface : public ColorModel {
  public:
    static const float weight_a  = 100.0f*100.0f; 
    static const float weight_b = 50.0f*50.0f; 
    static const float weight_d = 1.0f*1.0f;
    static const float strength = 10.0f;
  public:
    float alpha, beta, disp, spread_d;
    float min_x, min_y, max_x, max_y;
    Image<float> probabilities; 
  public:

    FlatSurface(FgBgSegment &segm, int width, int height);
    void Initialize();
    virtual void Update();
  };
  
  class Foreground : public ColorModel {
  public:
    static const float weight_p = 0.005f*0.005f;
    static const float weight_d = 0.5f*0.5f;
    static const float strength = 10.0f;
  public:

    float window_size;
    float ball_size;     

    bool combined; 
    Vector3 position3d; 
    Matrix3 spread3d;  
    Image<float> probabilities; 
  public:

    Foreground(FgBgSegment &segm, int width, int height);

    void Initialize(int startx, int starty);
    virtual void Update();
    
    void SetInitParams( float l_window_size, float l_ball_size);
    
  };
  
  class Background : public ColorModel {
  public:
    static const float weight_d = 0.1f*0.1f;
    static const float strength = 10.0f;
  public:
    float disp, spread_d;
    Image<float> probabilities;
  public:

    Background(FgBgSegment &segm, int width, int height);
    void Initialize();
    virtual void Update();
  };
  
  bool withSurface;
  bool withColors;     
  bool withDisparities;
  bool withColorHoles;
  /* If colour information has holes, use uniform probabilities or 
     histograms over luminance
  */
  bool uniform;
  int verbose;                
  
  Background ground;   
  FlatSurface surface;          
  std::vector<Foreground*> figures;  

  Image<uint8_t> hue;
  Image<uint8_t> saturation;
  Image<uint8_t> grey;  
  Image<float> *disparities;        
  std::vector<ColorModel> colorPriors;
  
  int width;
  int height;
  int drange;        
  float gradWeight;

  float windowSize;
  float ballSize;
  
  CudaSegment *cudaSegment;          
  bool gpuopt;                        
    

  void CreateHistograms(bool allPoints);
  void InitSegmentation();

  template <int numFigures> static void PixSegment(FgBgSegment &segm);

  void RGBToHSV(Image<uint8_t> &cimg);

public:

  FgBgSegment(int width, int height, int drange, float gradWeight = 20.0, 
              float w_size = 0.20f, float b_size = 0.20f);
  ~FgBgSegment();
  void UseGPU(bool gpuopt = true);

  void Execute(Image<uint8_t> &image, Image<float> &disp, 
               bool initialize, int loops = 1, 
               int startx = -1, int starty = -1);

  void SetNewForeground(int startx, int starty, Image<float> &dimg, int drange_);

  void SetNewForeground(Image<uint8_t> &mask, Image<float> &dimg, 
                        int drange, bool reuseLast = false);
  
  void GetSurfaceParameters( float &alpha, float &beta, float &disp);
    
  
  void GetSurfaceMinMax( float &min_x,
                         float &min_y,
                         float &max_x,
                         float &max_y );
                         

  void SetWithColors( bool val);
  bool GetWithColors();
  
  void SetWithColorHoles( bool val);
  bool GetWithColorHoles();
  
  void SetUniform( bool val);
  bool GetUniform();
  
  void SetWithSurface( bool val);
  bool GetWithSurface();
  
  void SetWithDisparities( bool val);
  bool GetWithDisparities();

  void SetGradWeight( float val);
  float GetGradWeight();
  

  void MakeSegmentImage(Image<uint8_t> &image);

  void MakeMaskImage(Image<uint8_t> &image, int val = 255, int obj = 0);

  void MakeBorderImage(Image<uint8_t> &image);

};

#endif // FGBGSEGMENT_H