List.cpp

Go to the documentation of this file.

#include <face_contour_detector/filters/List.h>
#include <face_contour_detector/filters/Parameter.h>
#include <face_contour_detector/Properties.h>
#include <boost/function.hpp>
#include <cassert>
#include <vector>

namespace face_contour_detector {
        namespace filters {
                List::List() {
                }
                List::~List() {
                        for (std::vector<Filter*>::iterator it = m_filters.begin(); it != m_filters.end(); it++) {
                                delete *it;
                        }
                }
                void List::Add(Filter* filter) {
                        m_filters.push_back(filter);
                        m_filtersActive.push_back(new bool(true));
                }

                void List::SaveParameters(Properties& properties) {
                        int filterId = 0;
                        std::vector<Filter*>::iterator it;
                        for (it = m_filters.begin(); it != m_filters.end(); it++) {
                                std::vector<Parameter>::iterator paramsIt;
                                std::vector<Parameter> params = (*it)->GetParameters();
                                for (paramsIt = params.begin(); paramsIt != params.end(); paramsIt++) {
                                        std::stringstream s;
                                        s<<"filters["<<filterId<<"]."<<paramsIt->GetName();
                                        std::string key = s.str();
                                        switch (paramsIt->GetType()) {
                                                case face_contour_detector::filters::TBOOL:
                                                        properties.Set(key, *(paramsIt->GetBoolValuePtr()));
                                                break;
                                                case face_contour_detector::filters::TDOUBLE:
                                                        properties.Set(key, *(paramsIt->GetDoubleValuePtr()));
                                                break;
                                                case face_contour_detector::filters::TINT:
                                                        properties.Set(key, *(paramsIt->GetIntValuePtr()));
                                                break;
                                                case face_contour_detector::filters::TSTRING:
                                                        properties.Set(key, *(paramsIt->GetStringValuePtr()));
                                                break;
                                        }
                                }
                                filterId++;
                        }
                }
                void List::LoadParameters(const Properties& properties) {
                        int filterId = 0;
                        std::vector<Filter*>::iterator it;
                        for (it = m_filters.begin(); it != m_filters.end(); it++) {
                                (*it)->ResetParameters();
                                std::vector<Parameter>::iterator paramsIt;
                                std::vector<Parameter> params = (*it)->GetParameters();
                                for (paramsIt = params.begin(); paramsIt != params.end(); paramsIt++) {
                                        std::stringstream s;
                                        s<<"filters["<<filterId<<"]."<<paramsIt->GetName();
                                        std::string key = s.str();
                                        if (properties.Exists(key)) {
                                                switch (paramsIt->GetType()) {
                                                        case face_contour_detector::filters::TBOOL :
                                                        {
                                                                (*(paramsIt->GetBoolValuePtr())) = properties.ReadBool(key);
                                                        }
                                                        break;
                                                        case face_contour_detector::filters::TDOUBLE :
                                                        {
                                                                (*(paramsIt->GetDoubleValuePtr())) = properties.ReadDouble(key);
                                                        }
                                                        break;
                                                        case face_contour_detector::filters::TINT :
                                                        {
                                                                (*(paramsIt->GetIntValuePtr())) = properties.ReadInt(key);
                                                        }
                                                        break;
                                                        case face_contour_detector::filters::TSTRING :
                                                        {
                                                                (*(paramsIt->GetStringValuePtr())) = properties.ReadString(key);
                                                        }
                                                        break;
                                                }
                                        }
                                }
                                filterId++;
                        }
                }

                void List::Apply(const cv::Mat& input, cv::Mat& result) {
                        std::vector<Filter*>::iterator it;
                        std::vector<bool*>::iterator activeIt = m_filtersActive.begin();
                        cv::Mat resultBuffer;
                        cv::Mat* currResultTarget = 0;
                        for (it = m_filters.begin(); it != m_filters.end(); it++) {
                                ROS_ASSERT(activeIt != m_filtersActive.end());
                                if (*(*activeIt)) {
                                        if (currResultTarget == 0) {
                                                (*it)->Apply(input, result);
                                                currResultTarget = &resultBuffer;
                                        } else if (currResultTarget == &resultBuffer) {
                                                (*it)->Apply(result, resultBuffer);
                                                currResultTarget = &result;
                                        } else if (currResultTarget == &result) {
                                                (*it)->Apply(resultBuffer, result);
                                                currResultTarget = &resultBuffer;
                                        } else {
                                                ROS_ASSERT(false);
                                        }
                                }
                                activeIt++;
                        }
                        if (currResultTarget == 0) {
                                result = cv::Mat(input);
                        } else if (currResultTarget == &result) {
                                result = cv::Mat(resultBuffer);
                        }
                }

                void List::DeactivateAll() {
                        std::vector<bool*>::iterator activeIt;
                        for (activeIt = m_filtersActive.begin(); activeIt != m_filtersActive.end(); activeIt++) {
                                (*(*activeIt)) = false;
                        }
                }

                List::Iterator List::Begin() {
                        return m_filters.begin();
                }

                List::Iterator List::End() {
                        return m_filters.end();
                }

        }
}