SfM.h

Go to the documentation of this file.

/*
 * This file is part of ALVAR, A Library for Virtual and Augmented Reality.
 *
 * Copyright 2007-2012 VTT Technical Research Centre of Finland
 *
 * Contact: VTT Augmented Reality Team <alvar.info@vtt.fi>
 *          <http://www.vtt.fi/multimedia/alvar.html>
 *
 * ALVAR 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 2.1 of the License, or (at your option)
 * any later version.
 *
 * This library 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 ALVAR; if not, see
 * <http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html>.
 */

#ifndef SFM_H
#define SFM_H

#include "EC.h"

namespace alvar {

class ALVAR_EXPORT SimpleSfM {
public:
        class Feature : public ExternalContainer {
        public:
                bool has_stored_pose;
                Pose pose1;
                CvPoint2D32f p2d1;
                CvPoint3D32f p3d_sh;
                CvPoint2D32f projected_p2d_sh;
                int tri_cntr;        // This is needed only by UpdateTriangulateOnly
                int estimation_type;

                Feature() : ExternalContainer() {
                        has_stored_pose = false;
                        p3d_sh.x = 0.f; p3d_sh.y = 0.f; p3d_sh.z = 0.f;
                        tri_cntr = 0;
                        estimation_type = 0;
                }
                Feature(const Feature &c) : ExternalContainer(c) {
                        has_stored_pose = c.has_stored_pose;
                        pose1 = c.pose1;
                        p2d1 = c.p2d1;
                        p3d_sh = c.p3d_sh;
                        projected_p2d_sh = c.projected_p2d_sh;
                        tri_cntr = c.tri_cntr;
                        estimation_type = c.estimation_type;
                }
        };
        std::map<int, Feature> container;
        std::map<int, Feature> container_triangulated;

protected:
        std::map<int, Feature> container_reset_point;
        std::map<int, Feature> container_triangulated_reset_point;

        CameraEC cam;
        MarkerDetectorEC<MarkerData> marker_detector; 
        TrackerFeaturesEC tf;
        Pose pose;
        bool pose_ok;

        bool update_tri;
        std::string multi_marker_file;
        bool markers_found;
        double scale;
        Pose pose_original;
        Pose pose_difference;

public:
        SimpleSfM() : tf(200, 200, 0.01, 20, 4, 6), pose_ok(false), update_tri(false), markers_found(false) {}
        void Reset(bool reset_also_triangulated = true);
        void SetResetPoint();
        void Clear();
        void SetScale(double s) { scale = s; }
        CameraEC *GetCamera();
        Pose *GetPose();
        bool AddMultiMarker(const char *fname, FILE_FORMAT format = FILE_FORMAT_XML);
        bool AddMultiMarker(MultiMarkerEC *mm);
        void AddMarker(int marker_id, double edge_length, Pose &pose);
        bool Update(IplImage *image, bool assume_plane=true, bool triangulate=true, float reproj_err_limit=5.f, float triangulate_angle=15.f);
        bool UpdateTriangulateOnly(IplImage *image);
        bool UpdateRotationsOnly(IplImage *image);
        void Draw(IplImage *rgba);
};

}
#endif