drwnSuperpixelContainer.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:    drwnSuperpixelContainer.h
** AUTHOR(S):   Stephen Gould <stephen.gould@anu.edu.au>
**
*****************************************************************************/

#pragma once

#include <vector>
#include <set>

#include "cv.h"

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

using namespace std;

// drwnSuperpixelContainer -----------------------------------------------------

class drwnSuperpixelContainer : public drwnPersistentRecord {
 protected:
    vector<int> _start;        
    vector<int> _nsegs;        
    vector<cv::Mat> _maps;     
    vector<int> _pixels;       
    vector<cv::Rect> _bboxes;  

 public:
    drwnSuperpixelContainer();
    drwnSuperpixelContainer(const drwnSuperpixelContainer& container);
    ~drwnSuperpixelContainer();

    void clear();
    inline bool empty() const { return _maps.empty(); }
    inline int size() const { return _maps.empty() ? 0 : _start.back() + _nsegs.back(); }
    inline int pixels(unsigned segId) const { return _pixels[segId]; }
    inline int width() const { return _maps.empty() ? 0 : _maps[0].cols; }
    inline int height() const { return _maps.empty() ? 0 : _maps[0].rows; }
    inline int channels() const { return (int)_maps.size(); }
    inline size_t memory() const {
        return _maps.size() * width() * height() * sizeof(int) + 3 * size() * sizeof(int);
    }

    // persistent storage interface
    virtual size_t numBytesOnDisk() const;
    virtual bool write(ostream& os) const;
    virtual bool read(istream& is);

    void loadSuperpixels(const char *filename);
    void addSuperpixels(cv::Mat superpixels);
    void copySuperpixels(const cv::Mat& superpixels);

    cv::Mat mask(unsigned segId) const;
    cv::Mat& mask(unsigned segId, cv::Mat& m) const;

    set<unsigned> parents(int x, int y) const;
    set<unsigned> neighbours(unsigned segId) const;
    const cv::Rect& boundingBox(unsigned segId) const { return _bboxes[segId]; }
    cv::Point centroid(unsigned segId) const;

    cv::Mat intersection() const;

    int removeSmallSuperpixels(unsigned minSize = 2);
    int removeUnmaskedSuperpixels(const cv::Mat& mask, double areaOverlap = 0.5);
    int removeSuperpixels(const std::set<unsigned>& segIds);

    cv::Mat visualize(const cv::Mat& img, bool bColourById = false) const;
    cv::Mat visualize(const cv::Mat& img, const vector<cv::Scalar>& colors, double alpha = 1.0) const;

    drwnSuperpixelContainer& operator=(const drwnSuperpixelContainer& container);
    const cv::Mat& operator[](unsigned int indx) const { return _maps[indx]; }
};