diff --git a/examples/libmv_homography.cc b/examples/libmv_homography.cc
index fe647da..55f3b70 100644
--- a/examples/libmv_homography.cc
+++ b/examples/libmv_homography.cc
@@ -54,8 +54,8 @@
 // homogeneous system of equations via singular value decomposition, giving an
 // algebraic solution for the homography, then solving for a final solution by
 // minimizing the symmetric transfer error in image space with Ceres (called the
-// Gold Standard Solution in "Multiple View Geometry"). The routines are based on
-// the routines from the Libmv library.
+// Gold Standard Solution in "Multiple View Geometry"). The routines are based
+// on the routines from the Libmv library.
 //
 // This example demonstrates custom exit criterion by having a callback check
 // for image-space error.
@@ -69,7 +69,7 @@
 typedef Eigen::VectorXd Vec;
 typedef Eigen::Matrix<double, 3, 3> Mat3;
 typedef Eigen::Matrix<double, 2, 1> Vec2;
-typedef Eigen::Matrix<double, Eigen::Dynamic,  8> MatX8;
+typedef Eigen::Matrix<double, Eigen::Dynamic, 8> MatX8;
 typedef Eigen::Vector3d Vec3;
 
 namespace {
@@ -83,8 +83,7 @@
   // Default settings for homography estimation which should be suitable
   // for a wide range of use cases.
   EstimateHomographyOptions()
-    :  max_num_iterations(50),
-       expected_average_symmetric_distance(1e-16) {}
+      : max_num_iterations(50), expected_average_symmetric_distance(1e-16) {}
 
   // Maximal number of iterations for the refinement step.
   int max_num_iterations;
@@ -107,9 +106,9 @@
 //
 // Templated to be used with autodifferentiation.
 template <typename T>
-void SymmetricGeometricDistanceTerms(const Eigen::Matrix<T, 3, 3> &H,
-                                     const Eigen::Matrix<T, 2, 1> &x1,
-                                     const Eigen::Matrix<T, 2, 1> &x2,
+void SymmetricGeometricDistanceTerms(const Eigen::Matrix<T, 3, 3>& H,
+                                     const Eigen::Matrix<T, 2, 1>& x1,
+                                     const Eigen::Matrix<T, 2, 1>& x2,
                                      T forward_error[2],
                                      T backward_error[2]) {
   typedef Eigen::Matrix<T, 3, 1> Vec3;
@@ -132,17 +131,13 @@
 //
 //   D(H * x1, x2)^2 + D(H^-1 * x2, x1)^2
 //
-double SymmetricGeometricDistance(const Mat3 &H,
-                                  const Vec2 &x1,
-                                  const Vec2 &x2) {
+double SymmetricGeometricDistance(const Mat3& H,
+                                  const Vec2& x1,
+                                  const Vec2& x2) {
   Vec2 forward_error, backward_error;
-  SymmetricGeometricDistanceTerms<double>(H,
-                                          x1,
-                                          x2,
-                                          forward_error.data(),
-                                          backward_error.data());
-  return forward_error.squaredNorm() +
-         backward_error.squaredNorm();
+  SymmetricGeometricDistanceTerms<double>(
+      H, x1, x2, forward_error.data(), backward_error.data());
+  return forward_error.squaredNorm() + backward_error.squaredNorm();
 }
 
 // A parameterization of the 2D homography matrix that uses 8 parameters so
@@ -154,24 +149,28 @@
 //     H = |d e f|
 //         |g h 1|
 //
-template<typename T = double>
+template <typename T = double>
 class Homography2DNormalizedParameterization {
  public:
   typedef Eigen::Matrix<T, 8, 1> Parameters;     // a, b, ... g, h
   typedef Eigen::Matrix<T, 3, 3> Parameterized;  // H
 
   // Convert from the 8 parameters to a H matrix.
-  static void To(const Parameters &p, Parameterized *h) {
+  static void To(const Parameters& p, Parameterized* h) {
+    // clang-format off
     *h << p(0), p(1), p(2),
           p(3), p(4), p(5),
           p(6), p(7), 1.0;
+    // clang-format on
   }
 
   // Convert from a H matrix to the 8 parameters.
-  static void From(const Parameterized &h, Parameters *p) {
+  static void From(const Parameterized& h, Parameters* p) {
+    // clang-format off
     *p << h(0, 0), h(0, 1), h(0, 2),
           h(1, 0), h(1, 1), h(1, 2),
           h(2, 0), h(2, 1);
+    // clang-format on
   }
 };
 
@@ -194,11 +193,10 @@
 //   (a-x1*g)*y1     + (b-x1*h)*y2  + c-x1         = |0|
 //   (-x2*a+x1*d)*y1 + (-x2*b+x1*e)*y2 + -x2*c+x1*f  |0|
 //
-bool Homography2DFromCorrespondencesLinearEuc(
-    const Mat &x1,
-    const Mat &x2,
-    Mat3 *H,
-    double expected_precision) {
+bool Homography2DFromCorrespondencesLinearEuc(const Mat& x1,
+                                              const Mat& x2,
+                                              Mat3* H,
+                                              double expected_precision) {
   assert(2 == x1.rows());
   assert(4 <= x1.cols());
   assert(x1.rows() == x2.rows());
@@ -209,27 +207,27 @@
   Mat b = Mat::Zero(n * 3, 1);
   for (int i = 0; i < n; ++i) {
     int j = 3 * i;
-    L(j, 0) =  x1(0, i);             // a
-    L(j, 1) =  x1(1, i);             // b
-    L(j, 2) =  1.0;                  // c
+    L(j, 0) = x1(0, i);              // a
+    L(j, 1) = x1(1, i);              // b
+    L(j, 2) = 1.0;                   // c
     L(j, 6) = -x2(0, i) * x1(0, i);  // g
     L(j, 7) = -x2(0, i) * x1(1, i);  // h
-    b(j, 0) =  x2(0, i);             // i
+    b(j, 0) = x2(0, i);              // i
 
     ++j;
-    L(j, 3) =  x1(0, i);             // d
-    L(j, 4) =  x1(1, i);             // e
-    L(j, 5) =  1.0;                  // f
+    L(j, 3) = x1(0, i);              // d
+    L(j, 4) = x1(1, i);              // e
+    L(j, 5) = 1.0;                   // f
     L(j, 6) = -x2(1, i) * x1(0, i);  // g
     L(j, 7) = -x2(1, i) * x1(1, i);  // h
-    b(j, 0) =  x2(1, i);             // i
+    b(j, 0) = x2(1, i);              // i
 
     // This ensures better stability
     // TODO(julien) make a lite version without this 3rd set
     ++j;
-    L(j, 0) =  x2(1, i) * x1(0, i);  // a
-    L(j, 1) =  x2(1, i) * x1(1, i);  // b
-    L(j, 2) =  x2(1, i);             // c
+    L(j, 0) = x2(1, i) * x1(0, i);   // a
+    L(j, 1) = x2(1, i) * x1(1, i);   // b
+    L(j, 2) = x2(1, i);              // c
     L(j, 3) = -x2(0, i) * x1(0, i);  // d
     L(j, 4) = -x2(0, i) * x1(1, i);  // e
     L(j, 5) = -x2(0, i);             // f
@@ -244,11 +242,10 @@
 // used for homography matrix refinement.
 class HomographySymmetricGeometricCostFunctor {
  public:
-  HomographySymmetricGeometricCostFunctor(const Vec2 &x,
-                                          const Vec2 &y)
-      : x_(x), y_(y) { }
+  HomographySymmetricGeometricCostFunctor(const Vec2& x, const Vec2& y)
+      : x_(x), y_(y) {}
 
-  template<typename T>
+  template <typename T>
   bool operator()(const T* homography_parameters, T* residuals) const {
     typedef Eigen::Matrix<T, 3, 3> Mat3;
     typedef Eigen::Matrix<T, 2, 1> Vec2;
@@ -257,11 +254,7 @@
     Vec2 x(T(x_(0)), T(x_(1)));
     Vec2 y(T(y_(0)), T(y_(1)));
 
-    SymmetricGeometricDistanceTerms<T>(H,
-                                       x,
-                                       y,
-                                       &residuals[0],
-                                       &residuals[2]);
+    SymmetricGeometricDistanceTerms<T>(H, x, y, &residuals[0], &residuals[2]);
     return true;
   }
 
@@ -278,9 +271,10 @@
 // points < 0.5px error).
 class TerminationCheckingCallback : public ceres::IterationCallback {
  public:
-  TerminationCheckingCallback(const Mat &x1, const Mat &x2,
-                              const EstimateHomographyOptions &options,
-                              Mat3 *H)
+  TerminationCheckingCallback(const Mat& x1,
+                              const Mat& x2,
+                              const EstimateHomographyOptions& options,
+                              Mat3* H)
       : options_(options), x1_(x1), x2_(x2), H_(H) {}
 
   virtual ceres::CallbackReturnType operator()(
@@ -293,9 +287,8 @@
     // Calculate average of symmetric geometric distance.
     double average_distance = 0.0;
     for (int i = 0; i < x1_.cols(); i++) {
-      average_distance += SymmetricGeometricDistance(*H_,
-                                                     x1_.col(i),
-                                                     x2_.col(i));
+      average_distance +=
+          SymmetricGeometricDistance(*H_, x1_.col(i), x2_.col(i));
     }
     average_distance /= x1_.cols();
 
@@ -307,17 +300,17 @@
   }
 
  private:
-  const EstimateHomographyOptions &options_;
-  const Mat &x1_;
-  const Mat &x2_;
-  Mat3 *H_;
+  const EstimateHomographyOptions& options_;
+  const Mat& x1_;
+  const Mat& x2_;
+  Mat3* H_;
 };
 
 bool EstimateHomography2DFromCorrespondences(
-    const Mat &x1,
-    const Mat &x2,
-    const EstimateHomographyOptions &options,
-    Mat3 *H) {
+    const Mat& x1,
+    const Mat& x2,
+    const EstimateHomographyOptions& options,
+    Mat3* H) {
   assert(2 == x1.rows());
   assert(4 <= x1.cols());
   assert(x1.rows() == x2.rows());
@@ -325,26 +318,23 @@
 
   // Step 1: Algebraic homography estimation.
   // Assume algebraic estimation always succeeds.
-  Homography2DFromCorrespondencesLinearEuc(x1,
-                                           x2,
-                                           H,
-                                           EigenDouble::dummy_precision());
+  Homography2DFromCorrespondencesLinearEuc(
+      x1, x2, H, EigenDouble::dummy_precision());
 
   LOG(INFO) << "Estimated matrix after algebraic estimation:\n" << *H;
 
   // Step 2: Refine matrix using Ceres minimizer.
   ceres::Problem problem;
   for (int i = 0; i < x1.cols(); i++) {
-    HomographySymmetricGeometricCostFunctor
-        *homography_symmetric_geometric_cost_function =
-            new HomographySymmetricGeometricCostFunctor(x1.col(i),
-                                                        x2.col(i));
+    HomographySymmetricGeometricCostFunctor*
+        homography_symmetric_geometric_cost_function =
+            new HomographySymmetricGeometricCostFunctor(x1.col(i), x2.col(i));
 
     problem.AddResidualBlock(
-        new ceres::AutoDiffCostFunction<
-            HomographySymmetricGeometricCostFunctor,
-            4,  // num_residuals
-            9>(homography_symmetric_geometric_cost_function),
+        new ceres::AutoDiffCostFunction<HomographySymmetricGeometricCostFunctor,
+                                        4,  // num_residuals
+                                        9>(
+            homography_symmetric_geometric_cost_function),
         NULL,
         H->data());
   }
@@ -369,9 +359,9 @@
   return summary.IsSolutionUsable();
 }
 
-}  // namespace libmv
+}  // namespace
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   google::InitGoogleLogging(argv[0]);
 
   Mat x1(2, 100);
@@ -382,9 +372,11 @@
 
   Mat3 homography_matrix;
   // This matrix has been dumped from a Blender test file of plane tracking.
+  // clang-format off
   homography_matrix << 1.243715, -0.461057, -111.964454,
                        0.0,       0.617589, -192.379252,
                        0.0,      -0.000983,    1.0;
+  // clang-format on
 
   Mat x2 = x1;
   for (int i = 0; i < x2.cols(); ++i) {
@@ -405,7 +397,7 @@
   EstimateHomography2DFromCorrespondences(x1, x2, options, &estimated_matrix);
 
   // Normalize the matrix for easier comparison.
-  estimated_matrix /= estimated_matrix(2 ,2);
+  estimated_matrix /= estimated_matrix(2, 2);
 
   std::cout << "Original matrix:\n" << homography_matrix << "\n";
   std::cout << "Estimated matrix:\n" << estimated_matrix << "\n";