|| || || || || || || ||

---

BlackFrameDetect.h

Go to the documentation of this file.

#ifndef Impala_Core_VideoSet_BlackFrameDetect_h
#define Impala_Core_VideoSet_BlackFrameDetect_h

#include "Core/VideoSet/Reporter.h"
#include "Core/VideoSet/Keyframes.h"
#include "Core/Array/MakeRoi.h"
#include "Core/Array/RGB2Gray.h"
#include "Core/Array/PixSum.h"
#include "Core/Array/RecGauss.h"
#include "Core/Array/Mul.h"
#include "Core/Array/Add.h"
#include "Core/Array/RGB2Intensity.h"
#include "Core/Array/Sqrt.h"
#include "Core/Feature/FeatureTable.h"

//
// by Jun Wu, created on 2009-10-26
// based on BlackFrameProc.h by Koen
// 

namespace Impala
{
namespace Core
{
namespace VideoSet
{


class BlackFrameDetect : public Listener
{
public:
    typedef Array::Array2dScalarReal64 Array2dScalarReal64;

    BlackFrameDetect(Reporter* reporter, CmdOptions& options)
    {
        mReporter = reporter;
        mKeyframes = 0;
        mTable = 0;
        mStripBorder = options.GetInt("borderWidth");  

        mFeatureDim = 3;
    }

    virtual void
    HandleNewWalk(VideoSet* vs, Keyframes* keyframes, bool* keyframeMask)
    {
        mKeyframes = keyframes;
    }

    virtual void
    HandleNewFile(VideoSet* vs, int fileId, Stream::RgbDataSrc* src)
    {
        //"intensity-magnitude-hist0"
        mTable = new Feature::FeatureTable(String("avg-int-grad"), 500, mFeatureDim);   
    }
    
    void
    ComputeGradient(Array2dScalarReal64*& magnitude, 
//                    Array2dScalarReal64*& direction, 
                    Array2dScalarReal64* im,
                    Real64 sigma)
    {
        Real64 precision = 3.0;
    
        Array2dScalarReal64* Lx = 0;
        Array2dScalarReal64* Ly = 0;
        RecGauss(Lx, im, sigma, sigma, 1, 0, precision);
        RecGauss(Ly, im, sigma, sigma, 0, 1, precision);
    
        // compute gradient magnitude
        Array2dScalarReal64* Lx2 = 0;
        Array2dScalarReal64* Ly2 = 0;
        Mul(Lx2, Lx, Lx);
        Mul(Ly2, Ly, Ly);
        Add(magnitude, Lx2, Ly2);
        Sqrt(magnitude, magnitude);
        delete Lx2;
        delete Ly2;
        
        // compute gradient direction
        //Atan2(direction, Ly, Lx);
        delete Lx;
        delete Ly;
    }

    virtual void
    HandleNewFrame(VideoSet* vs, int fileId, Stream::RgbDataSrc* src)
    {
        /* get frame */
        Array::Array2dVec3UInt8* im = Array::ArrayCreate<Array::Array2dVec3UInt8>
            (src->FrameWidth(), src->FrameHeight(), 0, 0, src->DataPtr(), true);

        /* verify image is not null */
        if (!im) {
            ILOG_ERROR("No image: fileId=" << fileId);
            return;
        }
        
        Quid quid = vs->GetQuidFrame(fileId, src->FrameNr());

        // remove the border, if requested
        Geometry::Rectangle rect(mStripBorder, mStripBorder, im->CW() - mStripBorder - 1, im->CH() - mStripBorder - 1, true);
        Array::Array2dVec3UInt8* imNoBorder = MakeRoi(im, rect);
        delete im;

        Array2dScalarReal64* imIntensity = 0;
        Array::RGB2Intensity(imIntensity, imNoBorder);
        delete imNoBorder;
        
        Real64 sigma = 2.0;
        Array2dScalarReal64* magnitude = 0;
        //Array2dScalarReal64* direction = 0;
        ComputeGradient(magnitude, imIntensity, sigma);
        //delete direction;
        
        int n = (imIntensity->CW() * imIntensity->CH());
        Real64 avgMagnitude = Array::PixSum(magnitude) / n;
        Real64 avgIntensity = Array::PixSum(imIntensity) / n;
        
        Vector::VectorTem<Real64> codebookVector =
            Vector::VectorTem<Real64>(mFeatureDim);
        codebookVector.Elem(0) = avgIntensity;
        codebookVector.Elem(1) = avgMagnitude;

        // added by Jun Wu
                // bin 0 for color historgram from gray image
        codebookVector.Elem(2) = (Real64)0.001;
        mTable->Add(quid, codebookVector);

        delete magnitude;
        delete imIntensity;

        //ILOG_INFO("DoneFrame: " << fileId << src);
    }

    virtual void
    HandleDoneFile(VideoSet* vs, int fileId, Stream::RgbDataSrc* src)
    {
        //std::string tableName = vs->GetFilePathFeatureData(mKeyframes != 0, FeatureDefinition("avg-int-grad"), fileId, false, -1, true, false);
        std::string tableName = vs->GetFilePathFeatureData("Keyframes", Feature::FeatureDefinition("avg-int-grad"), fileId, false, -1, true, false);
        Write(mTable, tableName, vs->GetDatabase(), true);
        delete mTable;
        mTable = 0;
        ILOG_INFO("HandleDoneFile: " << fileId);
    }

private:

    Reporter*          mReporter;
    Keyframes*         mKeyframes;
    int                mStripBorder;
    Feature::FeatureTable*      mTable;

    // added by Jun Wu 27/10/2009
    int                mFeatureDim;

    ILOG_VAR_DEC;
};

ILOG_VAR_INIT(BlackFrameDetect, Core.VideoSet);

} // namespace VideoSet
} // namespace Core
} // namespace Impala

#endif

---