dataset.h

Go to the documentation of this file.

/* ----------------------------------------------------------------------------

 * GTSAM Copyright 2010, Georgia Tech Research Corporation,
 * Atlanta, Georgia 30332-0415
 * All Rights Reserved
 * Authors: Frank Dellaert, et al. (see THANKS for the full author list)

 * See LICENSE for the license information

 * -------------------------------------------------------------------------- */

#pragma once

#include <gtsam/slam/BetweenFactor.h>
#include <gtsam/geometry/Cal3Bundler.h>
#include <gtsam/geometry/PinholeCamera.h>
#include <gtsam/geometry/Point2.h>
#include <gtsam/geometry/Point3.h>
#include <gtsam/geometry/Pose3.h>
#include <gtsam/geometry/Rot3.h>
#include <gtsam/nonlinear/NonlinearFactorGraph.h>
#include <gtsam/nonlinear/Values.h>
#include <gtsam/linear/NoiseModel.h>
#include <gtsam/base/types.h>

#include <boost/smart_ptr/shared_ptr.hpp>
#include <string>
#include <utility> // for pair
#include <vector>
#include <iosfwd>
#include <map>

namespace gtsam {

GTSAM_EXPORT std::string findExampleDataFile(const std::string& name);

GTSAM_EXPORT std::string createRewrittenFileName(const std::string& name);

enum NoiseFormat {
  NoiseFormatG2O, 
  NoiseFormatTORO, 
  NoiseFormatGRAPH, 
  NoiseFormatCOV, 
  NoiseFormatAUTO  
};

enum KernelFunctionType {
  KernelFunctionTypeNONE, KernelFunctionTypeHUBER, KernelFunctionTypeTUKEY
};

typedef std::pair<Key, Pose2> IndexedPose;
typedef std::pair<std::pair<Key, Key>, Pose2> IndexedEdge;

GTSAM_EXPORT boost::optional<IndexedPose> parseVertex(std::istream& is,
    const std::string& tag);

GTSAM_EXPORT boost::optional<IndexedEdge> parseEdge(std::istream& is,
    const std::string& tag);

typedef std::pair<NonlinearFactorGraph::shared_ptr, Values::shared_ptr> GraphAndValues;

GTSAM_EXPORT GraphAndValues load2D(
    std::pair<std::string, SharedNoiseModel> dataset, int maxID = 0,
    bool addNoise = false,
    bool smart = true, //
    NoiseFormat noiseFormat = NoiseFormatAUTO,
    KernelFunctionType kernelFunctionType = KernelFunctionTypeNONE);

GTSAM_EXPORT GraphAndValues load2D(const std::string& filename,
    SharedNoiseModel model = SharedNoiseModel(), Key maxID = 0, bool addNoise =
        false, bool smart = true, NoiseFormat noiseFormat = NoiseFormatAUTO, //
    KernelFunctionType kernelFunctionType = KernelFunctionTypeNONE);

GTSAM_EXPORT GraphAndValues load2D_robust(const std::string& filename,
    noiseModel::Base::shared_ptr& model, int maxID = 0);

GTSAM_EXPORT void save2D(const NonlinearFactorGraph& graph,
    const Values& config, const noiseModel::Diagonal::shared_ptr model,
    const std::string& filename);

GTSAM_EXPORT GraphAndValues readG2o(const std::string& g2oFile, const bool is3D = false,
    KernelFunctionType kernelFunctionType = KernelFunctionTypeNONE);

GTSAM_EXPORT void writeG2o(const NonlinearFactorGraph& graph,
    const Values& estimate, const std::string& filename);

using BetweenFactorPose3s = std::vector<gtsam::BetweenFactor<Pose3>::shared_ptr>;
GTSAM_EXPORT BetweenFactorPose3s parse3DFactors(const std::string& filename);

GTSAM_EXPORT std::map<Key, Pose3> parse3DPoses(const std::string& filename);

GTSAM_EXPORT GraphAndValues load3D(const std::string& filename);

typedef std::pair<size_t, Point2> SfM_Measurement;

typedef std::pair<size_t, size_t> SIFT_Index;

struct SfM_Track {
  SfM_Track():p(0,0,0) {}
  Point3 p; 
  float r, g, b; 
  std::vector<SfM_Measurement> measurements; 
  std::vector<SIFT_Index> siftIndices;
  size_t number_measurements() const {
    return measurements.size();
  }
};

typedef PinholeCamera<Cal3Bundler> SfM_Camera;

struct SfM_data {
  std::vector<SfM_Camera> cameras; 
  std::vector<SfM_Track> tracks; 
  size_t number_cameras() const {
    return cameras.size();
  } 
  size_t number_tracks() const {
    return tracks.size();
  } 
};

GTSAM_EXPORT bool readBundler(const std::string& filename, SfM_data &data);

GTSAM_EXPORT bool readBAL(const std::string& filename, SfM_data &data);

GTSAM_EXPORT bool writeBAL(const std::string& filename, SfM_data &data);

GTSAM_EXPORT bool writeBALfromValues(const std::string& filename,
    const SfM_data &data, Values& values);

GTSAM_EXPORT Pose3 openGL2gtsam(const Rot3& R, double tx, double ty, double tz);

GTSAM_EXPORT Pose3 gtsam2openGL(const Rot3& R, double tx, double ty, double tz);

GTSAM_EXPORT Pose3 gtsam2openGL(const Pose3& PoseGTSAM);

GTSAM_EXPORT Values initialCamerasEstimate(const SfM_data& db);

GTSAM_EXPORT Values initialCamerasAndPointsEstimate(const SfM_data& db);

} // namespace gtsam