$search

flow.hpp

Go to the documentation of this file.

#ifndef _THERMALVIS_FLOW_H_
#define _THERMALVIS_FLOW_H_

#include "general_resources.hpp"
#include "ros_resources.hpp"
#include "opencv_resources.hpp"
        
#include "improc.hpp"
#include "video.hpp"
#include "features.hpp"
#include "tracks.hpp"
#include "initialization.hpp"

#include "feature_tracks.h"

#include "flowConfig.h"

const char __PROGRAM__[] = "THERMALVIS_FLOW";

typedef dynamic_reconfigure::Server < thermalvis::flowConfig > Server;

#define DEFAULT_ALPHA   0.00
#define MS_PER_SEC              1000.0

bool wantsToShutdown = false;
void mySigintHandler(int sig);

void imageCallback(const sensor_msgs::ImageConstPtr& msg);
void parameterCallback(const sensor_msgs::CameraInfo& msg);

struct trackerData {
        
        string video_stream, video_sequence;
        string camera_parameters;
        string read_addr;
        
        bool softSync;
        double syncDiff;
        unsigned long soft_diff_limit;
        
        cameraParameters cameraData;
        
        //double alpha;
        double delayTimeout;
        double flowThreshold;
        double maxFrac;
        
        int minTrackedFeaturesPerDetector, maxTrackedFeaturesPerDetector;
        int maxFeatures;
        int maximumDetectionFeatures;
        int maxProjectionsPerFeature;
        
        bool debugMode;
        bool outputTrackCount;
        
        string detector[MAX_DETECTORS], descriptor[MAX_DETECTORS];
        double sensitivity[MAX_DETECTORS];
        string method[MAX_DETECTORS];
        bool method_match[MAX_DETECTORS];
        
        int newDetectionFramecountTrigger;
        
        //string normalizationMode;
        //int minLimit, maxLimit;
        
        int nearSearchHistory;
        int farSearchHistory;
        
        int minPointsForWarning;
        
        int drawingHistory;
        
        int lossGaps[2];
        
        double minDistance;
                
        unsigned int numDetectors;

        bool obtainStartingData(ros::NodeHandle& nh);   
    void initializeDetectors(Ptr<FeatureDetector> *det, Ptr<FeatureDetector> *hom);
    void initializeDescriptors(Ptr<DescriptorExtractor> *desc, Ptr<DescriptorExtractor> *hom);
        
};

// example: http://ua-ros-pkg.googlecode.com/svn/trunk/arrg/ua_vision/object_tracking/src/object_tracker_node.cpp
class featureTrackerNode {
private:

        Scalar trackDrawingColors[MAX_DETECTORS], keyDrawingColors[MAX_DETECTORS];
        
        ofstream trackCountStream;
        
        Size ksize;
        double blurSigma;
        
        vector<unsigned int> lostTrackIndices;
        int referenceFrame;
        
        bool undergoingDelay;
        
        Mat dispMat;
        
        bool infoProcessed, infoSent;
        
        Mat H12;
        
        double factor, minResponse; // minVal, maxVal, 
        
        ros::Timer timer, features_timer;

        trackerData configData;
        
        sensor_msgs::CameraInfo debug_camera_info;
        
        unsigned int lastPeak[MAX_DETECTORS];
        
        ros::Publisher tracks_pub;
        image_transport::CameraPublisher debug_pub;
        
        image_transport::CameraSubscriber camera_sub;
        ros::Subscriber info_sub;
        image_transport::Subscriber image_sub;
        
        int previouslyTrackedPoints;
        
        cv_bridge::CvImagePtr cv_ptr;
        
        Mat normalizedMat, blownImage, displayImage2, subscribedImage, drawImage2;
        Mat newImage, grayImage, realImage, mappedImage, lastImage, olderImage;

        //gpu::GpuMat gmap1, gmap2;
        
        // http://docs.opencv.org/doc/tutorials/gpu/gpu-basics-similarity/gpu-basics-similarity.html#how-to-do-it-the-gpu
        //Mat I1;         // Main memory item - read image into with imread for example
        //gpu::GpuMat gI; // GPU matrix - for now empty
        //gI1.upload(I1); // Upload a data from the system memory to the GPU memory
        //I1 = gI1;       // Download, gI1.download(I1) will work too

        //Mat map1, map2;

        struct timeval cycle_timer, test_timer;
        double elapsedTime, testTime;

        unsigned int frameCount;
        unsigned int readyFrame;
        
        

        image_transport::CameraPublisher pub_debug;
        sensor_msgs::Image msg_debug;
        
        char debug_pub_name[256];
        char tracks_pub_name[256];
        ros::NodeHandle private_node_handle;
        
        char nodeName[256];
        
        Mat displayImage, drawImage, drawImage_resized;
        
        Mat grayImageBuffer[MAXIMUM_FRAMES_TO_STORE], mappedImageBuffer[MAXIMUM_FRAMES_TO_STORE];
        
        Mat blurredImage;
        
        vector<KeyPoint> currPoints[MAX_DETECTORS];
        vector<Point2f> startingPoints[MAX_DETECTORS], finishingPoints[MAX_DETECTORS], guidingPoints[MAX_DETECTORS];
        vector<Point2f> historicalPoints[MAX_DETECTORS], recoveredPoints[MAX_DETECTORS];
        vector<featureTrack> displayTracks[MAX_DETECTORS];
        
        Ptr<FeatureDetector> keypointDetector[MAX_DETECTORS];
    Ptr<FeatureDetector> homographyDetector;
    
    vector<KeyPoint> homogPoints[2];
    Ptr<DescriptorExtractor> descriptorExtractor[MAX_DETECTORS];
    Ptr<DescriptorExtractor> homographyExtractor;
    Mat homogDescriptors[2];
    
    ros::Time info_time, image_time, original_time, dodgeTime;
    
    int distanceConstraint;
    
    int peakTracks;
    
        vector<featureTrack> featureTrackVector;
        
        Mat olderImages[MAXIMUM_FRAMES_TO_STORE][2];
        Mat workingImOld[MAXIMUM_FRAMES_TO_STORE], workingImNew[MAXIMUM_FRAMES_TO_STORE];
        
        dynamic_reconfigure::Server<thermalvis::flowConfig> server;
        dynamic_reconfigure::Server<thermalvis::flowConfig>::CallbackType f;
        
        double averageTrackLength;
        
public:
        featureTrackerNode(ros::NodeHandle& nh, trackerData startupData);
        
        void timed_loop(const ros::TimerEvent& event);
        
        void features_loop(const ros::TimerEvent& event);
        
        void handle_delay();
        
        void handle_very_new();
        
        void act_on_image();
        void process_info(const sensor_msgs::CameraInfoConstPtr& info_msg);
        
        void handle_camera(const sensor_msgs::ImageConstPtr& msg_ptr, const sensor_msgs::CameraInfoConstPtr& info_msg);
        void handle_image(const sensor_msgs::ImageConstPtr& msg_ptr);    
    void handle_info(const sensor_msgs::CameraInfoConstPtr& info_msg);
        
        void serverCallback(thermalvis::flowConfig &config, uint32_t level);
        
        void prepareForTermination();
        
        int publish_tracks(ros::Publisher *pub_message);
};

boost::shared_ptr < featureTrackerNode > *globalNodePtr;

#endif

---

thermalvis
Author(s): Stephen Vidas
autogenerated on Tue Mar 5 12:25:24 2013