spyglass 0.0.3 → 0.0.4

data/ext/spyglass/bgslib_image.cc

@@ -0,0 +1,77 @@
+/*
+This file is part of BGSLibrary.
+
+BGSLibrary 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.
+
+BGSLibrary 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 BGSLibrary.  If not, see <http://www.gnu.org/licenses/>.
+*/
+/****************************************************************************
+*
+* Image.hpp
+*
+* Purpose:  C++ wrapper for OpenCV IplImage which supports simple and 
+*						efficient access to the image data
+*
+* Author: Donovan Parks, September 2007
+*
+* Based on code from: 
+*  http://www.cs.iit.edu/~agam/cs512/lect-notes/opencv-intro/opencv-intro.hpptml
+******************************************************************************/
+
+#include "bgslib_image.h"
+
+ImageBase::~ImageBase()
+{ 
+  if(imgp != NULL && m_bReleaseMemory)
+    cvReleaseImage(&imgp);
+  imgp = NULL;	
+}
+
+void DensityFilter(BwImage& image, BwImage& filtered, int minDensity, unsigned char fgValue)
+{
+  for(int r = 1; r < image.Ptr()->height-1; ++r)
+  {
+    for(int c = 1; c < image.Ptr()->width-1; ++c)
+    {
+      int count = 0;
+      if(image(r,c) == fgValue)
+      {
+        if(image(r-1,c-1) == fgValue)
+          count++;
+        if(image(r-1,c) == fgValue)
+          count++;
+        if(image(r-1,c+1) == fgValue)
+          count++;
+        if(image(r,c-1) == fgValue)
+          count++;
+        if(image(r,c+1) == fgValue)
+          count++;
+        if(image(r+1,c-1) == fgValue)
+          count++;
+        if(image(r+1,c) == fgValue)
+          count++;
+        if(image(r+1,c+1) == fgValue)
+          count++;
+
+        if(count < minDensity)
+          filtered(r,c) = 0;
+        else
+          filtered(r,c) = fgValue;
+      }
+      else
+      {
+        filtered(r,c) = 0;
+      }
+    }
+  }
+}
+

data/ext/spyglass/bgslib_image.h

@@ -0,0 +1,365 @@
+/*
+   This file is part of BGSLibrary.
+
+   BGSLibrary 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.
+
+   BGSLibrary 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 BGSLibrary.  If not, see <http://www.gnu.org/licenses/>.
+   */
+/****************************************************************************
+ *
+ * Image.h
+ *
+ * Purpose:  C++ wrapper for OpenCV IplImage which supports simple and
+ *						efficient access to the image data
+ *
+ * Author: Donovan Parks, September 2007
+ *
+ * Based on code from:
+ *  http://www.cs.iit.edu/~agam/cs512/lect-notes/opencv-intro/opencv-intro.html
+ ******************************************************************************/
+
+#ifndef _IMAGE_H_
+#define _IMAGE_H_
+
+#include <opencv/cv.h>
+#include <opencv/cxcore.h>
+
+// --- Image Iterator ---------------------------------------------------------
+
+template <class T>
+class ImageIterator
+{
+  public:
+    ImageIterator(IplImage* image, int x=0, int y=0, int dx= 0, int dy=0) :
+      i(x), j(y), i0(0)
+  {
+    data = reinterpret_cast<T*>(image->imageData);
+    step = image->widthStep / sizeof(T);
+
+    nl= image->height;
+    if ((y+dy)>0 && (y+dy) < nl)
+      nl= y+dy;
+
+    if (y<0)
+      j=0;
+
+    data += step*j;
+
+    nc = image->width;
+    if ((x+dx) > 0 && (x+dx) < nc)
+      nc = x+dx;
+
+    nc *= image->nChannels;
+    if (x>0)
+      i0 = x*image->nChannels;
+    i = i0;
+
+    nch = image->nChannels;
+  }
+
+
+    /* has next ? */
+    bool operator!() const { return j < nl; }
+
+    /* next pixel */
+    ImageIterator& operator++()
+    {
+      i++;
+      if (i >= nc)
+      {
+        i=i0;
+        j++;
+        data += step;
+      }
+      return *this;
+    }
+
+    ImageIterator& operator+=(int s)
+    {
+      i+=s;
+      if (i >= nc)
+      {
+        i=i0;
+        j++;
+        data += step;
+      }
+      return *this;
+    }
+
+    /* pixel access */
+    T& operator*() { return data[i]; }
+
+    const T operator*() const { return data[i]; }
+
+    const T neighbor(int dx, int dy) const
+    {
+      return *(data+dy*step+i+dx);
+    }
+
+    T* operator&() const { return data+i; }
+
+    /* current pixel coordinates */
+    int column() const { return i/nch; }
+    int line() const { return j; }
+
+  private:
+    int i, i0,j;
+    T* data;
+    int step;
+    int nl, nc;
+    int nch;
+};
+
+// --- Constants --------------------------------------------------------------
+
+const unsigned char NUM_CHANNELS = 3;
+
+// --- Pixel Types ------------------------------------------------------------
+
+class RgbPixel
+{
+  public:
+    RgbPixel() {;}
+    RgbPixel(unsigned char _r, unsigned char _g, unsigned char _b)
+    {
+      ch[0] = _r; ch[1] = _g; ch[2] = _b;
+    }
+
+    RgbPixel& operator=(const RgbPixel& rhs)
+    {
+      ch[0] = rhs.ch[0]; ch[1] = rhs.ch[1]; ch[2] = rhs.ch[2];
+      return *this;
+    }
+
+    inline unsigned char& operator()(const int _ch)
+    {
+      return ch[_ch];
+    }
+
+    inline unsigned char operator()(const int _ch) const
+    {
+      return ch[_ch];
+    }
+
+    unsigned char ch[3];
+};
+
+class RgbPixelFloat
+{
+  public:
+    RgbPixelFloat() {;}
+    RgbPixelFloat(float _r, float _g, float _b)
+    {
+      ch[0] = _r; ch[1] = _g; ch[2] = _b;
+    }
+
+    RgbPixelFloat& operator=(const RgbPixelFloat& rhs)
+    {
+      ch[0] = rhs.ch[0]; ch[1] = rhs.ch[1]; ch[2] = rhs.ch[2];
+      return *this;
+    }
+
+    inline float& operator()(const int _ch)
+    {
+      return ch[_ch];
+    }
+
+    inline float operator()(const int _ch) const
+    {
+      return ch[_ch];
+    }
+
+    float ch[3];
+};
+
+// --- Image Types ------------------------------------------------------------
+
+class ImageBase
+{
+  public:
+    ImageBase(IplImage* img = NULL) { imgp = img; m_bReleaseMemory = true; }
+    ~ImageBase();
+
+    void ReleaseMemory(bool b) { m_bReleaseMemory = b; }
+
+    IplImage* Ptr() { return imgp; }
+    const IplImage* Ptr() const { return imgp; }
+
+    void ReleaseImage()
+    {
+      cvReleaseImage(&imgp);
+    }
+
+    void operator=(IplImage* img)
+    {
+      imgp = img;
+    }
+
+    // copy-constructor
+    ImageBase(const ImageBase& rhs)
+    {	
+      // it is very inefficent if this copy-constructor is called
+      assert(false);
+    }
+
+    // assignment operator
+    ImageBase& operator=(const ImageBase& rhs)
+    {
+      // it is very inefficent if operator= is called
+      assert(false);
+
+      return *this;
+    }
+
+    virtual void Clear() = 0;
+
+  protected:
+    IplImage* imgp;
+    bool m_bReleaseMemory;
+};
+
+class RgbImage : public ImageBase
+{
+  public:
+    RgbImage(IplImage* img = NULL) : ImageBase(img) { ; }
+
+    virtual void Clear()
+    {
+      cvZero(imgp);
+    }
+
+    void operator=(IplImage* img)
+    {
+      imgp = img;
+    }
+
+    // channel-level access using image(row, col, channel)
+    inline unsigned char& operator()(const int r, const int c, const int ch)
+    {
+      return (unsigned char &)imgp->imageData[r*imgp->widthStep+c*imgp->nChannels+ch];
+    }
+
+    inline const unsigned char& operator()(const int r, const int c, const int ch) const
+    {
+      return (unsigned char &)imgp->imageData[r*imgp->widthStep+c*imgp->nChannels+ch];
+    }
+
+    // RGB pixel-level access using image(row, col)
+    inline RgbPixel& operator()(const int r, const int c)
+    {
+      return (RgbPixel &)imgp->imageData[r*imgp->widthStep+c*imgp->nChannels];
+    }
+
+    inline const RgbPixel& operator()(const int r, const int c) const
+    {
+      return (RgbPixel &)imgp->imageData[r*imgp->widthStep+c*imgp->nChannels];
+    }
+};
+
+class RgbImageFloat : public ImageBase
+{
+  public:
+    RgbImageFloat(IplImage* img = NULL) : ImageBase(img) { ; }
+
+    virtual void Clear()
+    {
+      cvZero(imgp);
+    }
+
+    void operator=(IplImage* img)
+    {
+      imgp = img;
+    }
+
+    // channel-level access using image(row, col, channel)
+    inline float& operator()(const int r, const int c, const int ch)
+    {
+      return (float &)imgp->imageData[r*imgp->widthStep+(c*imgp->nChannels+ch)*sizeof(float)];
+    }
+
+    inline float operator()(const int r, const int c, const int ch) const
+    {
+      return (float)imgp->imageData[r*imgp->widthStep+(c*imgp->nChannels+ch)*sizeof(float)];
+    }
+
+    // RGB pixel-level access using image(row, col)
+    inline RgbPixelFloat& operator()(const int r, const int c)
+    {
+      return (RgbPixelFloat &)imgp->imageData[r*imgp->widthStep+c*imgp->nChannels*sizeof(float)];
+    }
+
+    inline const RgbPixelFloat& operator()(const int r, const int c) const
+    {
+      return (RgbPixelFloat &)imgp->imageData[r*imgp->widthStep+c*imgp->nChannels*sizeof(float)];
+    }
+};
+
+class BwImage : public ImageBase
+{
+  public:
+    BwImage(IplImage* img = NULL) : ImageBase(img) { ; }
+
+    virtual void Clear()
+    {
+      cvZero(imgp);
+    }
+
+    void operator=(IplImage* img)
+    {
+      imgp = img;
+    }
+
+    // pixel-level access using image(row, col)
+    inline unsigned char& operator()(const int r, const int c)
+    {
+      return (unsigned char &)imgp->imageData[r*imgp->widthStep+c];
+    }
+
+    inline unsigned char operator()(const int r, const int c) const
+    {
+      return (unsigned char)imgp->imageData[r*imgp->widthStep+c];
+    }
+};
+
+class BwImageFloat : public ImageBase
+{
+  public:
+    BwImageFloat(IplImage* img = NULL) : ImageBase(img) { ; }
+
+    virtual void Clear()
+    {
+      cvZero(imgp);
+    }
+
+    void operator=(IplImage* img)
+    {
+      imgp = img;
+    }
+
+    // pixel-level access using image(row, col)
+    inline float& operator()(const int r, const int c)
+    {
+      return (float &)imgp->imageData[r*imgp->widthStep+c*sizeof(float)];
+    }
+
+    inline float operator()(const int r, const int c) const
+    {
+      return (float)imgp->imageData[r*imgp->widthStep+c*sizeof(float)];
+    }
+};
+
+// --- Image Functions --------------------------------------------------------
+
+void DensityFilter(BwImage& image, BwImage& filtered, int minDensity, unsigned char fgValue);
+
+#endif
+

data/ext/spyglass/bgslib_prati_mediod_bgs.cc

@@ -0,0 +1,276 @@
+/*
+This file is part of BGSLibrary.
+
+BGSLibrary 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.
+
+BGSLibrary 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 BGSLibrary.  If not, see <http://www.gnu.org/licenses/>.
+*/
+/****************************************************************************
+*
+* PratiMediodBGS.h
+*
+* Purpose: Implementation of the temporal median background 
+*		  		 subtraction algorithm described in:
+*
+* [1] "Detecting Moving Objects, Shosts, and Shadows in Video Stream"
+* 			by R. Cucchiara et al (2003)
+*
+* [2] "Reliable Background Suppression for Complex Scenes"
+*				by S. Calderara et al (2006)
+*
+* Author: Donovan Parks, September 2007
+*
+* Please note that this is not an implementation of the complete system 
+* given in the above papers. It simply implements the temporal media background
+* subtraction algorithm.
+******************************************************************************/
+
+#include "bgslib_prati_mediod_bgs.h"
+
+using namespace Algorithms::BackgroundSubtraction;
+
+PratiMediodBGS::PratiMediodBGS()
+{
+	m_median_buffer = NULL;
+}
+
+PratiMediodBGS::~PratiMediodBGS()
+{
+	if(m_median_buffer != NULL)
+		delete[] m_median_buffer;
+}
+
+void PratiMediodBGS::Initalize(const BgsParams& param)
+{
+	m_params = (PratiParams&)param;
+
+	m_mask_low_threshold = cvCreateImage(cvSize(m_params.Width(), m_params.Height()), IPL_DEPTH_8U, 1);
+	m_mask_high_threshold = cvCreateImage(cvSize(m_params.Width(), m_params.Height()), IPL_DEPTH_8U, 1);
+
+	m_background = cvCreateImage(cvSize(m_params.Width(), m_params.Height()), IPL_DEPTH_8U, 3);
+
+	m_median_buffer = new MEDIAN_BUFFER[m_params.Size()];
+}
+
+void PratiMediodBGS::InitModel(const RgbImage& data)
+{
+	// there is no need to initialize the mode since it needs a buffer of frames
+	// before it can performing background subtraction
+}
+
+void PratiMediodBGS::Update(int frame_num, const RgbImage& data,  const BwImage& update_mask)
+{
+	// update the image buffer with the new frame and calculate new median values
+	if(frame_num % m_params.SamplingRate() == 0)
+	{
+		if(m_median_buffer[0].dist.size() == m_params.HistorySize())
+		{
+			// subtract distance to sample being removed from all distances
+			for(unsigned int r = 0; r < m_params.Height(); ++r)
+			{
+				for(unsigned int c = 0; c < m_params.Width(); ++c)
+				{	
+					int i = r*m_params.Width()+c;
+
+					if(update_mask(r,c) == BACKGROUND)
+					{
+						int oldPos = m_median_buffer[i].pos;
+						for(unsigned int s = 0; s < m_median_buffer[i].pixels.size(); ++s)
+						{
+							int maxDist = 0;
+							for(int ch = 0; ch < NUM_CHANNELS; ++ch)
+							{
+								int tempDist = abs(m_median_buffer[i].pixels.at(oldPos)(ch) 
+																		- m_median_buffer[i].pixels.at(s)(ch));
+								if(tempDist > maxDist)
+									maxDist = tempDist;
+							}
+
+							m_median_buffer[i].dist.at(s) -= maxDist;
+						}
+				
+						int dist;
+						UpdateMediod(r, c, data, dist);
+						m_median_buffer[i].dist.at(oldPos) = dist;
+						m_median_buffer[i].pixels.at(oldPos) = data(r,c);
+						m_median_buffer[i].pos++;
+						if(m_median_buffer[i].pos >= m_params.HistorySize())
+							m_median_buffer[i].pos = 0;
+					}
+				}
+			}
+		}
+		else
+		{
+			// calculate sum of L-inf distances for new point and 
+			// add distance from each sample point to this point to their L-inf sum
+			int dist;
+			for(unsigned int r = 0; r < m_params.Height(); ++r)
+			{
+				for(unsigned int c = 0; c < m_params.Width(); ++c)
+				{	
+					int index = r*m_params.Width()+c;
+					UpdateMediod(r, c, data, dist);
+					m_median_buffer[index].dist.push_back(dist);
+					m_median_buffer[index].pos = 0;
+					m_median_buffer[index].pixels.push_back(data(r,c)); 
+				}
+			}
+		}
+	}
+}
+
+void PratiMediodBGS::UpdateMediod(int r, int c, const RgbImage& new_frame, int& dist)
+{
+	// calculate sum of L-inf distances for new point and 
+	// add distance from each sample point to this point to their L-inf sum
+	unsigned int i = (r*m_params.Width()+c);
+
+	m_median_buffer[i].medianDist = INT_MAX;
+
+	int L_inf_dist = 0;
+	for(unsigned int s = 0; s < m_median_buffer[i].dist.size(); ++s)
+	{
+		int maxDist = 0;
+		for(int ch = 0; ch < NUM_CHANNELS; ++ch)
+		{
+			int tempDist = abs(m_median_buffer[i].pixels.at(s)(ch) - new_frame(r,c,ch));
+			if(tempDist > maxDist)
+				maxDist = tempDist;
+		}
+
+		// check if point from this frame in the image buffer is the median
+		m_median_buffer[i].dist.at(s) += maxDist;
+		if(m_median_buffer[i].dist.at(s) < m_median_buffer[i].medianDist)
+		{
+			m_median_buffer[i].medianDist = m_median_buffer[i].dist.at(s);
+			m_median_buffer[i].median = m_median_buffer[i].pixels.at(s);
+		}
+
+		L_inf_dist += maxDist;
+	}
+
+	dist = L_inf_dist;
+
+	// check if the new point is the median
+	if(L_inf_dist < m_median_buffer[i].medianDist)
+	{
+		m_median_buffer[i].medianDist = L_inf_dist;
+		m_median_buffer[i].median = new_frame(r,c);
+	}
+}
+
+void PratiMediodBGS::Combine(const BwImage& low_mask, const BwImage& high_mask, BwImage& output)
+{
+	for(unsigned int r = 0; r < m_params.Height(); ++r)
+	{
+		for(unsigned int c = 0; c < m_params.Width(); ++c)
+		{
+			output(r,c) = BACKGROUND;
+
+			if(r == 0 || c == 0 || r == m_params.Height()-1 || c == m_params.Width()-1)
+				continue;	
+			
+			if(high_mask(r,c) == FOREGROUND)
+			{
+				output(r,c) = FOREGROUND;
+			}
+			else if(low_mask(r,c) == FOREGROUND)
+			{
+				// consider the pixel to be a F/G pixel if it is 8-connected to
+				// a F/G pixel in the high mask
+				// check if there is an 8-connected foreground pixel
+				if(high_mask(r-1,c-1))	
+					output(r,c) = FOREGROUND;
+				else if(high_mask(r-1,c))	
+					output(r,c) = FOREGROUND;
+				else if(high_mask(r-1,c+1))	
+					output(r,c) = FOREGROUND;
+				else if(high_mask(r,c-1))	
+					output(r,c) = FOREGROUND;
+				else if(high_mask(r,c+1))	
+					output(r,c) = FOREGROUND;
+				else if(high_mask(r+1,c-1))	
+					output(r,c) = FOREGROUND;
+				else if(high_mask(r+1,c))	
+					output(r,c) = FOREGROUND;
+				else if(high_mask(r+1,c+1))	
+					output(r,c) = FOREGROUND;
+			}
+		}
+	}
+}
+
+void PratiMediodBGS::CalculateMasks(int r, int c, const RgbPixel& pixel)
+{
+	int pos = r*m_params.Width()+c;
+
+	// calculate l-inf distance between current value and median value
+	unsigned char dist = 0;
+	for(int ch = 0; ch < NUM_CHANNELS; ++ch)
+	{
+		int tempDist = abs(pixel(ch) - m_median_buffer[pos].median(ch));
+		if(tempDist > dist)
+			dist = tempDist;
+	}
+	m_background(r,c) = m_median_buffer[pos].median;
+
+	// check if pixel is a B/G or F/G pixel according to the low threshold B/G model
+	m_mask_low_threshold(r,c) = BACKGROUND;
+	if(dist > m_params.LowThreshold())
+	{
+		m_mask_low_threshold(r,c) = FOREGROUND;
+	}
+
+	// check if pixel is a B/G or F/G pixel according to the high threshold B/G model
+	m_mask_high_threshold(r,c)= BACKGROUND;
+	if(dist > m_params.HighThreshold())
+	{
+		m_mask_high_threshold(r,c) = FOREGROUND;
+	}
+}
+
+///////////////////////////////////////////////////////////////////////////////
+//Input:
+//  data - a pointer to the data of a RGB image of the same size
+//Output:
+//  output - a pointer to the data of a gray value image of the same size 
+//					values: 255-foreground, 0-background
+///////////////////////////////////////////////////////////////////////////////
+void PratiMediodBGS::Subtract(int frame_num, const RgbImage& data, 
+																BwImage& low_threshold_mark, BwImage& high_threshold_mark)
+{
+	if(frame_num < m_params.HistorySize())
+	{
+		low_threshold_mark.Clear();
+		high_threshold_mark.Clear();
+		return;
+	}
+
+	// update each pixel of the image
+	for(unsigned int r = 0; r < m_params.Height(); ++r)
+	{
+		for(unsigned int c = 0; c < m_params.Width(); ++c)
+		{	
+			// need at least one frame of data before we can start calculating the masks
+			CalculateMasks(r, c, data(r,c));
+		}
+	}
+
+	// combine low and high threshold masks
+	Combine(m_mask_low_threshold, m_mask_high_threshold, low_threshold_mark);
+	Combine(m_mask_low_threshold, m_mask_high_threshold, high_threshold_mark);
+}
+
+
+
+