Matcher.h

Go to the documentation of this file.

// -*- mode: c++; indent-tabs-mode: nil; c-basic-offset: 4; coding: iso-8859-1; -*-

/*
ACT-CV - Machine Vision for Cognitive Modeling
Copyright (c) 2008 Marc Halbruegge

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 2 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, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
*/


#ifndef MATCHER_H_
#define MATCHER_H_

#ifdef _WINDOWS
# include <windows.h>
# include <process.h>
#else
# ifndef HANDLE
typedef int HANDLE;
# endif
#endif

#include <cv.h>
#include <garbagecoll.h>
#include <vector>


class MatchBase : virtual public ReferenceCount {
protected:
    IplImage *target;
    CvSize srcSize; 
    GCPointer<GCString> name;  

    MatchBase() : name(nullptr), target(nullptr) {
        srcSize.width=0;
        srcSize.height=0;
    }

public:

    MatchBase(const char *targetName) : name(new GCString(targetName)), target(nullptr) {
        srcSize.width=0;
        srcSize.height=0;
    }
    
    MatchBase(const char *targetName, const char *fileName) 
        : name(new GCString(targetName)), target(nullptr) {
        srcSize.width=0;
        srcSize.height=0;
        
        target = cvLoadImage(fileName, CV_LOAD_IMAGE_UNCHANGED);
        if (target==nullptr) throw FileLineException(__FILE__,__LINE__);
    }

    MatchBase(const char *targetName, const char *fileName,
        int posX, int posY, int sizeX, int sizeY) 
        : name(new GCString(targetName)), target(nullptr) {
        srcSize.width=0;
        srcSize.height=0;
        
        IplImage *container = cvLoadImage(fileName, CV_LOAD_IMAGE_UNCHANGED);
        if (container==nullptr) throw FileLineException(__FILE__,__LINE__);

        CvMat roi;
        cvGetSubRect(container, &roi, cvRect(posX,posY,sizeX,sizeY));

        target = cvCreateImage(cvSize(sizeX, sizeY), container->depth, container->nChannels);
        if (target==nullptr) throw FileLineException(__FILE__,__LINE__);

        cvCopy(&roi, target);
        cvReleaseImage(&container);
    }

    virtual ~MatchBase() {
        if (target!=nullptr) cvReleaseImage(&target);
    }
    
    virtual void Match(const IplImage *src) =0;
    virtual bool TargetFound() const =0;

    const char* GetVisiconName() const {
        return name->GetString();
    }
    
    int GetWidth() const {
        return target->width;
    }
    
    int GetHeight() const {
        return target->height;
    }
};


class MatchImage : public MatchBase {
    
    IplImage *result;
    std::vector<CvPoint> points;
    
    double threshold;  
public:
    
    MatchImage(const char *targetName, const char *fileName, double t=0.995) 
        : MatchBase(targetName,fileName), result(nullptr), threshold(t) {
    }

    MatchImage(const char *targetName, const char *fileName, 
        int posX, int posY, int sizeX, int sizeY, double t=0.995) 
        : MatchBase(targetName,fileName,posX,posY,sizeX,sizeY), result(nullptr), threshold(t) {
    }
    

    virtual ~MatchImage() {
        if (result!=nullptr) cvReleaseImage(&result);
    }
    
    void Match(const IplImage *src) {
        MHDBGMSG(__FILE__,__LINE__,__PRETTY_FUNCTION__);
        if (result==nullptr) {
            srcSize.width=src->width;
            srcSize.height=src->height;
            result = cvCreateImage(
                cvSize(srcSize.width-target->width+1,srcSize.height-target->height+1),
                IPL_DEPTH_32F, 1);
        }
        MHDBGMSG(__FILE__,__LINE__,__PRETTY_FUNCTION__);
        
        // TODO: Hier läuft was schief!!!
        // MH 20070821 soweit ich weiß Fehler in OpenCV/Linux, dort gefixt
        cvMatchTemplate(src, target, result, CV_TM_CCORR_NORMED);//CV_TM_CCORR;CV_TM_SQDIFF;CV_TM_CCOEFF
        
        MHDBGMSG(__FILE__,__LINE__,__PRETTY_FUNCTION__);
        points.clear();
        for (int x=0;x<result->width;x++) {
            for (int y=0;y<result->height;y++) {
                if (cvGetReal2D(result, y, x)>threshold) {
                    points.push_back(cvPoint(x+target->width/2,
                                             y+target->height/2));
                }
            }
        }
        MHDBGMSG(__FILE__,__LINE__,__PRETTY_FUNCTION__);
    }
    
    const std::vector<CvPoint>& GetPoints() const {
        return points;
    }
    
    bool TargetFound() const {
        return points.size()>0;
    }
    
    CvPoint GetRandomTarget() const {
        return points[rand()%points.size()];
    }
    
};


class BGMatchers : public std::vector<GCPointer<MatchImage> > {
#define NUM_THREADS 2

    struct ThreadData {
        const std::vector<GCPointer<MatchImage> > *matchers;
        const BGMatchers *owner;
    };

    std::vector<GCPointer<MatchImage> > matchers[NUM_THREADS];
    HANDLE threadIds[NUM_THREADS];
    ThreadData threadData[NUM_THREADS];

    static void Func(void *p) {
        ThreadData *_this = (ThreadData*)p;
        for (const_iterator i=_this->matchers->begin();
            i!=_this->matchers->end(); i++) {
            (*i)->Match(_this->owner->curImg);
        }
#ifdef _WINDOWS
        _endthread();
#endif        
    }
    const IplImage *curImg;
public:
    void Match(const IplImage *src) {
        curImg=src;

#ifdef _WINDOWS
        for (unsigned int i=0;i<NUM_THREADS;i++) {
            threadIds[i]=(HANDLE) _beginthread(Func, 0, threadData + i);
        }
        WaitForMultipleObjects(NUM_THREADS, threadIds, TRUE, INFINITE);
#else
        // Linux-Variante später mal bauen
        for (unsigned int i=0;i<NUM_THREADS;i++) {
            Func(threadData + i);
        }
#endif        
    }

    void SetUpMatchers() {
        for (unsigned int i=0;i<size(); i++) {
            matchers[i % NUM_THREADS].push_back(at(i));
        }
        for (unsigned int i=0;i<NUM_THREADS; i++) {
            threadData[i].matchers = matchers + i;
            threadData[i].owner = this;
        }
    }
};


class MatchContour : public MatchBase {
    double result;
    
    IplImage *cannyTarget;
    CvMemStorage* trgtStorage;
    CvSeq* trgtContour;

    IplImage *cannySrc;

    IplImage *forDisplay;

    CvMemStorage* storage;

    static const int MIN_THRES = 70;
    static const int MAX_THRES = 200;

    int cur_thres;

    static void thres_cb(int newVal) { 
    }
public:
    MatchContour(const char *targetName, const char *fileName)
        : MatchBase(targetName,fileName), cannyTarget(nullptr), cannySrc(nullptr),
          cur_thres(100) {
        
        cannyTarget = cvCreateImage(cvGetSize(target), IPL_DEPTH_8U, 1);
        //cvSmooth((CvArr*)target,(CvArr*)target);
        cvCanny(target, cannyTarget, 30, 60, 3);
        trgtStorage = cvCreateMemStorage(0);
        cvFindContours(cannyTarget, trgtStorage, &trgtContour, sizeof(CvContour),
                CV_RETR_TREE, CV_CHAIN_APPROX_SIMPLE, cvPoint(0,0));

        
        cvNamedWindow(name->GetString());
        cvCreateTrackbar("Canny thresh:", name->GetString(), &cur_thres, 255, &thres_cb);
        
        storage = cvCreateMemStorage(0);

    }
    ~MatchContour() {
        if (cannyTarget!=nullptr) cvReleaseImage(&cannyTarget);
        if (cannySrc!=nullptr) cvReleaseImage(&cannySrc);
        if (forDisplay!=nullptr) cvReleaseImage(&forDisplay);

        cvDestroyWindow(name->GetString());
    }
    void Match(const IplImage *src) {

        if (cannySrc==nullptr) {
            srcSize.width=src->width;
            srcSize.height=src->height;
            cannySrc = cvCreateImage(cvGetSize(src), IPL_DEPTH_8U, 1);

            forDisplay = cvCreateImage(cvGetSize(src), IPL_DEPTH_8U, 3);
        }
        //cvSmooth((CvArr*)src,(CvArr*)src);
        cvCanny(src, cannySrc, cur_thres, cur_thres*2, 3);
        
#if 0
        cvShowImage(name->GetString(), cannySrc);
#else
        CvSeq* contours;
        cvFindContours(cannySrc, storage, &contours, sizeof(CvContour),
                CV_RETR_TREE, CV_CHAIN_APPROX_SIMPLE, cvPoint(0,0));
        
        
        cvZero(forDisplay);
        result=1e100;
        for ( ; contours!=0; contours = contours->h_next) {
            
            //if (abs(contours->total-trgtContour->total)>trgtContour->total/2) continue;

            double curResult = cvMatchShapes(contours, trgtContour, CV_CONTOURS_MATCH_I1);
            if (curResult>0.0 && curResult<result) result=curResult;

#if 0
            std::cout << "contours: " 
                << contours->total << " "
                << curResult  
                << std::endl;
#endif
            //CvScalar color = CV_RGB( rand()&255, rand()&255, rand()&255 );
            double normedRes = (curResult - .2) / .2;
#ifdef max
            normedRes = min(max(normedRes, -1.0), 1.0);
#else
            normedRes = std::min(std::max(normedRes, -1.0), 1.0);
#endif
            CvScalar color = CV_RGB(127+127*normedRes, 127+127*normedRes, 127-127*normedRes);
 
            if (curResult < .4) {
                /* replace CV_FILLED with 1 to see the outlines */
                cvDrawContours((CvArr*)forDisplay, contours, color, color, -1, 1 /*CV_FILLED*/, 8);
            }
        }
        
        cvShowImage(name->GetString(), forDisplay);
#endif

#if 0
        if (result < .4) {
            std::cout << "cvMatchShapes: " << result << std::endl;
        }
#endif
    }
    bool TargetFound() const {
        return false;
    }
};

#endif /*MATCHER_H_*/