drwnObject.h

/*****************************************************************************
** DARWIN: A FRAMEWORK FOR MACHINE LEARNING RESEARCH AND DEVELOPMENT
** Distributed under the terms of the BSD license (see the LICENSE file)
** Copyright (c) 2007-2015, Stephen Gould
** All rights reserved.
**
******************************************************************************
** FILENAME:    drwnObject.h
** AUTHOR(S):   Stephen Gould <stephen.gould@anu.edu.au>
**
*****************************************************************************/

#pragma once

#include <cstdlib>
#include <cassert>
#include <vector>
#include <map>

#include "cv.h"
#include "cxcore.h"

#include "drwnBase.h"
#include "drwnIO.h"

using namespace std;

// drwnObject ---------------------------------------------------------------

class drwnObject {
 public:
    string name;         
    cv::Rect extent;     
    double score;        
    int ref;             

 public:
    drwnObject();
    drwnObject(const cv::Rect& ext, const char *n = NULL);
    //drwnObject(const vector<cv::Point>& polygon, const char *n = NULL);
    drwnObject(const drwnObject& obj);
    ~drwnObject();

    bool save(drwnXMLNode& xml) const;
    bool load(drwnXMLNode& xml);

    bool hit(double x, double y) const;
    bool hit(const cv::Point& pt) const { return hit(pt.x, pt.y); }

    double area() const { return fabs((double)(extent.width * extent.height)); }
    double aspect() const { return (double)extent.width / (double)extent.height; }

    double overlap(const cv::Rect& roi) const;
    double overlap(const drwnObject& obj) const { return overlap(obj.extent); }

    double areaOverlap(const cv::Rect& roi) const {
        const double ov = overlap(roi);
        return (ov / (area() + (roi.width * roi.height) - ov));
    }
    double areaOverlap(const drwnObject& obj) const { return areaOverlap(obj.extent); }

    bool inside(const drwnObject& obj) const {
        return (fabs(overlap(obj) - area()) < DRWN_EPSILON);
    }

    void scale(double x_scale, double y_scale) {
        extent.x = (int)(x_scale * extent.x);
        extent.y = (int)(y_scale * extent.y);
        extent.width = (int)(x_scale * extent.width);
        extent.height = (int)(y_scale * extent.height);
    }
    void scale(double sc) { scale(sc, sc); }

    drwnObject& operator=(const drwnObject& obj);
    bool operator==(const drwnObject& obj) const;
    bool operator!=(const drwnObject& obj) const { return !(*this == obj); }
    bool operator<(const drwnObject& obj) const;
    bool operator>(const drwnObject& obj) const;
};

// drwnObjectList -----------------------------------------------------------

class drwnObjectList : public drwnWriteable, public std::vector<drwnObject> {
 public:
    drwnObjectList();
    ~drwnObjectList();

    // i/o
    const char *type() const { return "drwnObjectList"; }
    bool save(drwnXMLNode& xml) const;
    bool load(drwnXMLNode& xml);

    void sort();

    // filtering
    int removeNonMatching(const string& name);
    int removeMatching(const string& name);
    int nonMaximalSuppression(double threshold = 0.5, bool bByName = true);
    int keepHighestScoring(int nKeep);
    int keepAboveScore(double threshold);

};

// drwnObjectSequence -------------------------------------------------------

class drwnObjectSequence : public drwnWriteable, public std::map<string, drwnObjectList> {
 public:
    drwnObjectSequence();
    ~drwnObjectSequence();

    // i/o
    const char *type() const { return "drwnObjectSequence"; }
    bool save(drwnXMLNode& xml) const;
    bool load(drwnXMLNode& xml);
};

// utility functions
void printObjectStatistics(const drwnObjectSequence& objects);