~charon-developers/+junk/gerald-edevis

/*  Copyright (C) 2013 Gerald Mwangi

 

        This file is part of Charon.

 

        Charon is free software: you can redistribute it and/or modify

        it under the terms of the GNU Lesser General Public License as published by

        the Free Software Foundation, either version 3 of the License, or

        (at your option) any later version.

 

        Charon 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 Lesser General Public License for more details.

 

        You should have received a copy of the GNU Lesser General Public License

        along with Charon.  If not, see <http://www.gnu.org/licenses/>.

*/

/** \file LinearMotionCompensation.h

 *  Declaration of the parameter class LinearMotionCompensation.

 *  \author <a href="mailto:gerald.mwangi@gmx.de">

 *      Gerald Mwangi</a>

 *  \date 19.06.2013

 */

 

#ifndef _LINEARMOTIONCOMPENSATION_H_

#define _LINEARMOTIONCOMPENSATION_H_

 

#ifdef _MSC_VER

#ifdef linearmotioncompensation_EXPORTS

/// Visual C++ specific code

#define linearmotioncompensation_DECLDIR __declspec(dllexport)

#else

#define linearmotioncompensation_DECLDIR __declspec(dllimport)

#endif /*Export or import*/

#else

/// Not needed without MSVC

#define linearmotioncompensation_DECLDIR

#endif

 

#include <charon-core/ParameteredObject.h>

#include <charon-utils/Roi.hxx>

#include <vigra/multi_array.hxx>

#include <opencv2/opencv.hpp>

using namespace std;

/// Compensates linear motion in an image sequence

/** Compensates linear motion in an image sequence, using the sift detector in

 *  the opencv library. The motion is assumed to be constrained to the image

 *  plane (x,y coordinates), thus no  motion in z direction.

 */

template <typename T>

class linearmotioncompensation_DECLDIR LinearMotionCompensation :

                public TemplatedParameteredObject<T> {

public:

        /// default constructor

        /// \param name          Instance name

        LinearMotionCompensation(const std::string& name = "");

 

        /// sequence with linear motion

        InputSlot< vigra::MultiArray<5,T> > image_sequence;

        /// roi to estimate the linear motion

        InputSlot< Roi<T>* > roi;

 

        /// motion compensated sequence

        OutputSlot< vigra::MultiArray<5,T> > compensated_sequence;

        /// image sequence with found features

        OutputSlot< vigra::MultiArray<5,T> > feature_sequence;

 

        /// allowed deviation from linear motion model

        Parameter< double > motion_tolerance;

        /// Fraction of the number features with motion tolerance below

        /// motion_tolerance parameter and total number of found features. Values

        /// ~1 mean nearly all features are required to have a linear motion,

        /// values ~0 mean no features must have a linear motion.

        Parameter< double > good_feature_fraction;

 

 

protected:

        /// Update object.

        virtual void execute();

    void getCvMatFrame(cv::Mat& out,int frame, bool create);

    cv::Mat warpImage(cv::Mat src,cv::Mat dst, cv::Mat &dst_imkpts);

    void determinParameters(vector< cv::Point2f > best_src,vector< cv::Point2f > best_dst,float& cos_theta,cv::Point2f& trans);

    float errorFunction(float cos_theta,cv::Point2f trans,cv::Point2f src,cv::Point2f dst);

    void findAffineTrans(vector< cv::DMatch >  matches,vector<cv::KeyPoint> srckpts,vector<cv::KeyPoint> dstkpts,float tolerance,float inlier_frac,int max_iter,cv::Mat& affTrans);

    void copyFrameToOut(cv::Mat& in, cv::Mat &inkpts, int frame);

};

 

#endif // _LINEARMOTIONCOMPENSATION_H_