sfm changes to docs, format, wrapper

gtsam.h

@@ -2894,28 +2894,6 @@ class BinaryMeasurement {
 typedef gtsam::BinaryMeasurement<gtsam::Unit3> BinaryMeasurementUnit3;
 typedef gtsam::BinaryMeasurement<gtsam::Rot3> BinaryMeasurementRot3;
 
-// std::vector<gtsam::BinaryMeasurement<Unit3>::shared_ptr>
-class BinaryMeasurementUnit3s
-{
-  BinaryMeasurementUnit3s();
-  size_t size() const;
-  gtsam::BinaryMeasurementUnit3* at(size_t i) const;
-  void push_back(const gtsam::BinaryMeasurementUnit3* measurement);
-};
-
-// std::vector<gtsam::BinaryMeasurement<Rot3>::shared_ptr>
-class BinaryMeasurementRot3s
-{
-  BinaryMeasurementRot3s();
-  size_t size() const;
-  gtsam::BinaryMeasurementRot3* at(size_t i) const;
-  void push_back(const gtsam::BinaryMeasurementRot3* measurement);
-};
-
-#include <gtsam/sfm/TranslationRecovery.h>
-class TranslationRecovery {
-  TranslationRecovery()
-}
 //*************************************************************************
 // Navigation
 //*************************************************************************

gtsam/sfm/BinaryMeasurement.h

@@ -15,12 +15,15 @@
  * @file BinaryMeasurement.h
  * @author Akshay Krishnan
  * @date July 2020
- * @brief Binary measurement for representing edges in the epipolar graph
+ * @brief Binary measurement for representing edges in the epipolar graph. 
+ * A binary measurement is similar to a BetweenFactor, except that it does not contain 
+ * an error function. It is a measurement (along with a noise model) from one key to 
+ * another. Note that the direction is important. A measurement from key1 to key2 is not
+ * the same as the same measurement from key2 to key1. 
  */
 
 #include <ostream>
 
-
 #include <gtsam/base/Testable.h>
 #include <gtsam/base/Lie.h>
 #include <gtsam/nonlinear/NonlinearFactor.h>
@@ -49,17 +52,12 @@ private:
   SharedNoiseModel noiseModel_; /** Noise model */
 
  public:
-    /** default constructor - only use for serialization */
-    BinaryMeasurement() {}
-
   /** Constructor */
   BinaryMeasurement(Key key1, Key key2, const VALUE &measured,
                     const SharedNoiseModel &model = nullptr) :
       key1_(key1), key2_(key2), measured_(measured), noiseModel_(model) {
   }
 
-    virtual ~BinaryMeasurement() {}
-
   Key key1() const { return key1_; }
 
   Key key2() const { return key2_; }
@@ -83,15 +81,12 @@ public:
     return e != nullptr && key1_ == e->key1_ &&
         key2_ == e->key2_
         && traits<VALUE>::Equals(this->measured_, e->measured_, tol) &&
-             noiseModel_->equals(expected.noiseModel());
+        noiseModel_->equals(*expected.noiseModel());
   }
 
-    /** return the measured */
+  /** return the measured value */
   VALUE measured() const {
     return measured_;
   }
 }; // \class BetweenMeasurement
-
-  using BinaryMeasurementUnit3s = std::vector<gtsam::BinaryMeasurement<Unit3>::shared_ptr>;
-  using BinaryMeasurementRot3s = std::vector<gtsam::BinaryMeasurement<Rot3>::shared_ptr>;
 }

gtsam/sfm/TranslationRecovery.cpp

@@ -10,10 +10,10 @@
  * -------------------------------------------------------------------------- */
 
 /**
- * @file TranslationRecovery.h
+ * @file TranslationRecovery.cpp
  * @author Frank Dellaert
  * @date March 2020
- * @brief test recovering translations when rotations are given.
+ * @brief Source code for recovering translations when rotations are given
  */
 
 #include <gtsam/sfm/TranslationRecovery.h>

gtsam/sfm/TranslationRecovery.h

@@ -13,7 +13,7 @@
  * @file TranslationRecovery.h
  * @author Frank Dellaert
  * @date March 2020
- * @brief test recovering translations when rotations are given.
+ * @brief Recovering translations in an epipolar graph when rotations are given.
  */
 
 #include <gtsam/geometry/Unit3.h>

gtsam/sfm/tests/testBinaryMeasurement.cpp

@@ -27,7 +27,6 @@
 using namespace std;
 using namespace gtsam;
 
-// Keys are deliberately *not* in sorted order to test that case.
 static const Key kKey1(2), kKey2(1);
 
 // Create noise models for unit3 and rot3
@@ -43,14 +42,24 @@ TEST(BinaryMeasurement, Unit3) {
   EXPECT_LONGS_EQUAL(unit3Measurement.key1(), kKey1);
   EXPECT_LONGS_EQUAL(unit3Measurement.key2(), kKey2);
   EXPECT(unit3Measurement.measured().equals(unit3Measured));
+
+  BinaryMeasurement<Unit3> unit3MeasurementCopy(kKey1, kKey2, unit3Measured,
+                                                unit3_model);
+  EXPECT(unit3Measurement.equals(unit3MeasurementCopy));
 }
 
 TEST(BinaryMeasurement, Rot3) {
+  // testing the accessors
   BinaryMeasurement<Rot3> rot3Measurement(kKey1, kKey2, rot3Measured,
                                           rot3_model);
   EXPECT_LONGS_EQUAL(rot3Measurement.key1(), kKey1);
   EXPECT_LONGS_EQUAL(rot3Measurement.key2(), kKey2);
   EXPECT(rot3Measurement.measured().equals(rot3Measured));
+
+  // testing the equals function
+  BinaryMeasurement<Rot3> rot3MeasurementCopy(kKey1, kKey2, rot3Measured,
+                                              rot3_model);
+  EXPECT(rot3Measurement.equals(rot3MeasurementCopy));
 }
 
 /* ************************************************************************* */

gtsam/sfm/tests/testTranslationFactor.cpp

@@ -51,8 +51,6 @@ TEST(TranslationFactor, ZeroError) {
   // Verify we get the expected error
   Vector expected = (Vector3() << 0, 0, 0).finished();
   EXPECT(assert_equal(expected, actualError, 1e-9));
-
-
 }
 
 /* ************************************************************************* */