ImageForest.h

Go to the documentation of this file.

#ifndef FACE_CONTOUR_DETECTOR_IMAGEFOREST_H_
#define FACE_CONTOUR_DETECTOR_IMAGEFOREST_H_

#include <cassert>

#include <cv_bridge/CvBridge.h>
#include <opencv/cv.h>
#include <opencv/highgui.h>
#include <map>
#include <ros/assert.h>

namespace face_contour_detector {

        class ImageForest {
        public:
                class Point {
                public:
                        Point(int x, int y);
                        Point(const Point& other);
                        int x;
                        int y;
                        inline double Distance(Point other);
                };
                class Graph {
                public:
                        Graph();
                        Graph(const Graph& other);
                        int id;
                        int numPixels;
                        std::vector<Point> endPoints;
                        std::vector<Point> connectingPoints;
                };

        public:
                ImageForest();
                ImageForest(const cv::Mat& mat, unsigned char threshold);
                virtual ~ImageForest();
                void ReadFromImage(const cv::Mat& mat, unsigned char threshold);
                inline int NumGraphs();

                cv::Mat GenerateImage();
                void GenerateImage(cv::Mat& mat);

                inline int GetGraphId(int x, int y);

                inline int GetGraphId(ImageForest::Point point);

                std::map<int, Graph> GetGraphs();

                inline int Width();
                inline int Height();

                double CallculateEdgyness();

                double CallculateGraphMass();

        private:
                int m_width;
                int m_height;

                int m_lastId;
                int m_count;
                int* m_values;

                void M_SetEqClass(int* eqMap, int size, int a, int b);
                inline void M_GetVectors(int x, int y, std::vector<ImageForest::Point>& vectors);

        };

        //Implementation
        inline int ImageForest::NumGraphs() { return m_count; }
        inline int ImageForest::GetGraphId(int x, int y) {
                ROS_ASSERT(m_values != 0);
                ROS_ASSERT(x >= 0 && x < m_width);
                ROS_ASSERT(y >= 0 && y < m_height);
                return m_values[y*m_width + x];
        }
        inline int ImageForest::GetGraphId(ImageForest::Point point) { return GetGraphId(point.x, point.y); }
        inline int ImageForest::Width() { return m_width; }
        inline int ImageForest::Height() { return m_height; }
        inline double ImageForest::Point::Distance(Point other) {
                double dx = x-other.x;
                double dy = y-other.y;
                return sqrt(dx*dx+dy*dy);
        }
        inline void ImageForest::M_GetVectors(int x, int y, std::vector<ImageForest::Point>& vectors) {
                for (int dy = y==0?0:-1; dy+y < Height() && dy <= 1; dy++) {
                        for (int dx = x==0?0:-1; dx+x < Width() && dx <= 1; dx++) {
                                if (GetGraphId(x+dx,y+dy) != 0) {
                                        vectors.push_back(ImageForest::Point(dx,dy));
                                }
                        }
                }
        }

} //namespace face_contour_detector

#endif /* FACE_CONTOUR_DETECTOR_IMAGEFOREST_H_ */