From eb0813ac0fb9710a27458795b4c3b17a951cadcf Mon Sep 17 00:00:00 2001 From: Nima Keivan Date: Thu, 24 Apr 2014 11:05:47 -0400 Subject: [PATCH 1/5] Adds clear function to crtp rig. --- include/calibu/cam/camera_crtp.h | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/include/calibu/cam/camera_crtp.h b/include/calibu/cam/camera_crtp.h index 9c8eeea..a2dca32 100644 --- a/include/calibu/cam/camera_crtp.h +++ b/include/calibu/cam/camera_crtp.h @@ -146,11 +146,18 @@ namespace calibu t_wc_.push_back(t_wc); } - ~Rig() + void Clear() { for (CameraInterface* ptr : cameras_) { delete ptr; } + cameras_.clear(); + t_wc_.clear(); + } + + ~Rig() + { + Clear(); } std::vector*> cameras_; From c3e43725469a1d73967ac4f70a791c2df0475fa2 Mon Sep 17 00:00:00 2001 From: Nima Keivan Date: Thu, 24 Apr 2014 11:06:43 -0400 Subject: [PATCH 2/5] Adds setparam function to crtp cameras. --- include/calibu/cam/camera_crtp.h | 24 +++++++++++++++++------- 1 file changed, 17 insertions(+), 7 deletions(-) diff --git a/include/calibu/cam/camera_crtp.h b/include/calibu/cam/camera_crtp.h index a2dca32..2d88057 100644 --- a/include/calibu/cam/camera_crtp.h +++ b/include/calibu/cam/camera_crtp.h @@ -58,13 +58,7 @@ namespace calibu public: Camera(Scalar* params_in) { - if (kOwnsMem) { - params_ = new Scalar[Derived::kParamSize]; - memcpy(params_, params_in, sizeof(Scalar) * Derived::kParamSize); - } - else{ - params_ = params_in; - } + SetParams(params_in); } ~Camera() @@ -79,6 +73,22 @@ namespace calibu return params_; } + uint32_t NumParams() const + { + return Derived::kParamSize; + } + + void SetParams(Scalar* params_in) + { + if (kOwnsMem) { + params_ = new Scalar[Derived::kParamSize]; + memcpy(params_, params_in, sizeof(Scalar) * Derived::kParamSize); + } + else{ + params_ = params_in; + } + } + Vec3t Unproject(const Vec2t& pix) const { Vec3t ray; From 3066e509bb92bca38c7901cde8b70e774bd23c61 Mon Sep 17 00:00:00 2001 From: Nima Keivan Date: Thu, 24 Apr 2014 11:07:19 -0400 Subject: [PATCH 3/5] Adds camera calibration derivatives for atan and linear camera models --- include/calibu/cam/camera_crtp.h | 46 +++++ include/calibu/cam/camera_models_crtp.h | 221 +++++++++++++++++++++--- 2 files changed, 245 insertions(+), 22 deletions(-) diff --git a/include/calibu/cam/camera_crtp.h b/include/calibu/cam/camera_crtp.h index 2d88057..3b1fd91 100644 --- a/include/calibu/cam/camera_crtp.h +++ b/include/calibu/cam/camera_crtp.h @@ -48,7 +48,13 @@ namespace calibu const Vec3t& ray, const Scalar rho) const = 0; + virtual Eigen::Matrix dTransfer_dparams( + const SE3t& t_ba, + const Vec2t& pix, + const Scalar rho) const = 0; + virtual Scalar* GetParams() = 0; + virtual uint32_t NumParams() const = 0; }; // The Curiously Recurring Template Pattern (CRTP) @@ -115,6 +121,24 @@ namespace calibu return j; } + Eigen::Matrix dProject_dparams( + const Vec3t& ray) const + { + Eigen::Matrix j; + static_cast(this)->dProject_dparams(ray.data(), params_, + j.data()); + return j; + } + + Eigen::Matrix dUnproject_dparams( + const Vec2t& pix) const + { + Eigen::Matrix j; + static_cast(this)->dUnproject_dparams(pix.data(), params_, + j.data()); + return j; + } + Vec2t Transfer3d(const SE3t& t_ba, const Vec3t& ray, const Scalar rho) const @@ -140,6 +164,28 @@ namespace calibu return dtransfer3d_dray; } + Eigen::Matrix dTransfer_dparams( + const SE3t& t_ba, + const Vec2t& pix, + const Scalar rho) const + { + const Vec3t ray = Unproject(pix); + const Eigen::Matrix rot_matrix = t_ba.rotationMatrix(); + const Vec3t ray_dehomogenized = + rot_matrix * ray + rho * t_ba.translation(); + const Eigen::Matrix dproject_dray = + dProject_dray(ray_dehomogenized); + const Eigen::Matrix dtransfer3d_dray = + dproject_dray * rot_matrix; + const Eigen::Matrix dray_dparams = + dUnproject_dparams(pix); + + const Eigen::Matrix d_project_dparams = + dProject_dparams(ray_dehomogenized); + + return d_project_dparams + dtransfer3d_dray * dray_dparams; + } + protected: Scalar* params_; diff --git a/include/calibu/cam/camera_models_crtp.h b/include/calibu/cam/camera_models_crtp.h index 224661b..7fa7ff7 100644 --- a/include/calibu/cam/camera_models_crtp.h +++ b/include/calibu/cam/camera_models_crtp.h @@ -64,12 +64,39 @@ namespace calibu pix_k[1] = params[1] * pix[1] + params[3]; } + template + static inline void dMultK_dparams(const T* params, const T* pix, T* j) + { + j[0] = pix[0]; j[2] = 0; j[4] = 1; j[6] = 0; + j[1] = 0; j[3] = pix[1]; j[5] = 0; j[7] = 1; + } + template static inline void MultInvK(const T* params, const T* pix, T* pix_kinv) { pix_kinv[0] = (pix[0] - params[2]) / params[0]; pix_kinv[1] = (pix[1] - params[3]) / params[1]; } + + template + static inline void dMultInvK_dparams(const T* params, const T* pix, T* j) + { + j[0] = -(pix[0] - params[2]) / (params[0] * params[0]); + j[1] = 0; + j[2] = 0; + + j[3] = 0; + j[4] = -(pix[1] - params[3]) / (params[1] * params[1]); + j[5] = 0; + + j[6] = -1 / params[0]; + j[7] = 0; + j[8] = 0; + + j[9] = 0; + j[10] = -1 / params[1]; + j[11] = 0; + } }; ///////////////////////////////////////////////////////////////////////////// @@ -97,6 +124,18 @@ namespace calibu CameraUtils::MultK(params, pix, pix); } + template + static void dProject_dparams(const T* ray, const T* params, T* j) { + T pix[2]; + CameraUtils::Dehomogenize(ray, pix); + CameraUtils::dMultK_dparams(params, pix, j); + } + + template + static void dUnproject_dparams(const T* pix, const T* params, T* j) { + CameraUtils::dMultInvK_dparams(params, pix, j); + } + template static void dProject_dray(const T* ray, const T* params, T* j) { // De-homogenize and multiply by K. @@ -129,17 +168,16 @@ namespace calibu static const uint32_t kMaxRadIncrements = 2000; static const int kParamSize = 5; - // Static member functions to use without instantiating a class object + // For these derivatives, refer to the camera_derivatives.m matlab file. template inline static T Factor(const T rad, const T* params) { const T param = params[4]; if (param * param > kCamDistEps) { - const T mul2_tanw_by2 = (T)2.0 * tan(param / 2.0); - const T mul2_tanw_by2_byw = mul2_tanw_by2 / param; + const T mul2_tanw_by2 = (T)2.0 * tan(param / (T)2.0); if (rad * rad < kCamDistEps) { // limit r->0 - return mul2_tanw_by2_byw; + return mul2_tanw_by2 / param; } return atan(rad * mul2_tanw_by2) / (rad * param); } @@ -147,28 +185,54 @@ namespace calibu return (T)1; } + template + inline static T dFactor_dparam(const T rad, const T* params, T* fac) + { + const T param = params[4]; + if (param * param > kCamDistEps) { + const T tanw_by2 = tan(param / (T)2.0); + const T mul2_tanw_by2 = (T)2.0 * tanw_by2; + if (rad * rad < kCamDistEps) { + // limit r->0 + *fac = mul2_tanw_by2 / param; + return ((T)2 * ((tanw_by2 * tanw_by2) / (T)2 + (T)0.5)) / param - + mul2_tanw_by2 / (param * param); + } + const T tanw_by2_sq = tanw_by2 * tanw_by2; + const T atan_mul2_tanw_by2 = atan(rad * mul2_tanw_by2); + const T rad_mul_param = (rad * param); + *fac = atan_mul2_tanw_by2 / rad_mul_param; + return ((T)2 * (tanw_by2_sq / (T)2 + (T)0.5)) / + (param * ((T)4 * tanw_by2_sq * rad * rad + (T)1)) - + atan_mul2_tanw_by2 / (rad_mul_param * param); + } + // limit w->0 + *fac = (T)1; + return (T)0; + } + template inline static T dFactor_drad(const T rad, const T* params, T* fac) { const T param = params[4]; if(param * param < kCamDistEps) { *fac = (T)1; - return 0; + return (T)0; }else{ - const T tan_wby2 = tan(param / 2.0); + const T tan_wby2 = tan(param / (T)2.0); const T mul2_tanw_by2 = (T)2.0 * tan_wby2; if(rad * rad < kCamDistEps) { *fac = mul2_tanw_by2 / param; - return 0; + return (T)0; }else{ const T atan_mul2_tanw_by2 = atan(rad * mul2_tanw_by2); - const T rad_by_param = (rad * param); + const T rad_mul_param = (rad * param); - *fac = atan_mul2_tanw_by2 / rad_by_param; - return (2 * tan_wby2) / - (rad * param * (4 * rad * rad * tan_wby2 * tan_wby2 + 1)) - - atan_mul2_tanw_by2 / (rad * rad_by_param); + *fac = atan_mul2_tanw_by2 / rad_mul_param; + return ((T)2 * tan_wby2) / + (rad * param * ((T)4 * rad * rad * tan_wby2 * tan_wby2 + (T)1)) - + atan_mul2_tanw_by2 / (rad * rad_mul_param); } } } @@ -178,20 +242,63 @@ namespace calibu inline static T Factor_inv(const T rad, const T* params) { const T param = params[4]; - if(param * param < kCamDistEps) { - // limit w->0 - return (T)1.0; - }else{ - const T w_by2 = param / 2.0; - const T mul_2tanw_by2 = tan(w_by2) * 2.0; + if(param * param > kCamDistEps) { + const T w_by2 = param / (T)2.0; + const T mul_2tanw_by2 = tan(w_by2) * (T)2.0; if(rad * rad < kCamDistEps) { // limit r->0 return param / mul_2tanw_by2; - }else{ - return tan(rad * param) / (rad * mul_2tanw_by2); } + return tan(rad * param) / (rad * mul_2tanw_by2); } + // limit w->0 + return (T)1.0; + } + + template + inline static T dFactor_inv_dparam(const T rad, const T* params) + { + const T param = params[4]; + if(param * param > kCamDistEps) { + const T tan_wby2 = tan(param / (T)2.0); + if(rad * rad < kCamDistEps) { + return (T)1.0 / ((T)2 * tan_wby2) - + (param * (tan_wby2 * tan_wby2 / (T)2.0 + (T)0.5)) / + ((T)2.0 * tan_wby2 * tan_wby2); + } + const T tan_rad_mul_w = tan(rad * param); + const T tanw_by2_sq = tan_wby2 * tan_wby2; + return (tan_rad_mul_w * tan_rad_mul_w + (T)1.0) / ((T)2.0 * tan_wby2) - + (tan_rad_mul_w * (tanw_by2_sq / (T)2.0 + (T)0.5)) / + ((T)2.0 * rad * tanw_by2_sq); + } + // limit w->0 + return (T)0.0; + } + + template + inline static T dFactor_inv_drad(const T rad, const T* params, T* fac) + { + const T param = params[4]; + if(param * param > kCamDistEps) { + const T w_by2 = param / (T)2.0; + const T tan_w_by2 = tan(w_by2); + const T mul_2tanw_by2 = tan_w_by2 * (T)2.0; + if(rad * rad < kCamDistEps) { + *fac = param / tan_w_by2; + return (T)0; + } + const T one_by_tan_w_by_2 = (T)1.0 / tan_w_by2; + const T tan_rad_mul_w = tan(rad * param); + *fac = tan_rad_mul_w / (rad * mul_2tanw_by2); + return (one_by_tan_w_by_2 * param * + (tan_rad_mul_w * tan_rad_mul_w + (T)1)) / ((T)2 * rad) - + (one_by_tan_w_by_2 * tan_rad_mul_w) / (2 * rad * rad); + } + // limit w->0 + *fac = (T)1; + return (T)0.0; } template @@ -199,15 +306,68 @@ namespace calibu // First multiply by inverse K and calculate distortion parameter. T pix_kinv[2]; CameraUtils::MultInvK(params, pix, pix_kinv); - // Homogenize the point. - CameraUtils::Homogenize(pix_kinv, ray); const T fac_inv = Factor_inv(CameraUtils::PixNorm(pix_kinv), params); pix_kinv[0] *= fac_inv; pix_kinv[1] *= fac_inv; + // Homogenize the point. CameraUtils::Homogenize(pix_kinv, ray); } + template + static void dUnproject_dparams(const T* pix, const T* params, T* j) { + T pix_kinv[2]; + CameraUtils::MultInvK(params, pix, pix_kinv); + CameraUtils::dMultInvK_dparams(params, pix, j); + + // The complexity of this jacobian is due to the fact that the distortion + // factor is calculated _after_ the multiplication by K^-1, therefore + // the parameters of K affect both pix_kinv and fac_inv. Therefore we + // use the product rule to push the derivatives w.r.t. K through both + // functions. + + T rad = CameraUtils::PixNorm(pix_kinv); + T fac_inv; + const T dfac_inv_drad_byrad = + dFactor_inv_drad(rad, params, &fac_inv) / rad; + const T dfac_inv_dp[2] = { pix_kinv[0] * dfac_inv_drad_byrad, + pix_kinv[1] * dfac_inv_drad_byrad }; + // Calculate the jacobian of the factor w.r.t. the K parameters. + T dfac_dparams[4]; + dfac_dparams[0] = dfac_inv_dp[0] * j[0]; + dfac_dparams[1] = dfac_inv_dp[1] * j[4]; + dfac_dparams[2] = dfac_inv_dp[0] * j[6]; + dfac_dparams[3] = dfac_inv_dp[1] * j[10]; + + // This is the derivatives w.r.t. K parameters for K^-1 * fac_inv + T dfac_inv = + dFactor_inv_dparam(rad, params); + j[0] *= fac_inv; + j[4] *= fac_inv; + j[6] *= fac_inv; + j[10] *= fac_inv; + + // Total derivative w.r.t. the K parameters for fac_inv added to the + // previous values (product rule) + j[0] += dfac_dparams[0] * pix_kinv[0]; + j[1] += dfac_dparams[0] * pix_kinv[1]; + + j[3] += dfac_dparams[1] * pix_kinv[0]; + j[4] += dfac_dparams[1] * pix_kinv[1]; + + j[6] += dfac_dparams[2] * pix_kinv[0]; + j[7] += dfac_dparams[2] * pix_kinv[1]; + + j[9] += dfac_dparams[3] * pix_kinv[0]; + j[10] += dfac_dparams[3] * pix_kinv[1]; + + // Derivatives w.r.t. the w parameter do not need to go through the chain + // rule as they do not affect the multiplication by K^-1. + j[12] = pix_kinv[0] * dfac_inv; + j[13] = pix_kinv[1] * dfac_inv; + j[14] = 0; + } + template static void Project(const T* ray, const T* params, T* pix) { // De-homogenize and multiply by K. @@ -220,6 +380,23 @@ namespace calibu CameraUtils::MultK(params, pix, pix); } + template + static void dProject_dparams(const T* ray, const T* params, T* j) { + T pix[2]; + CameraUtils::Dehomogenize(ray, pix); + // This derivative is simplified compared to the unproject derivative, + // as we first calculate the distortion parameter, then multiply by K. + // The derivatives are then a simple application of the chain rule. + T fac; + T d_fac = dFactor_dparam(CameraUtils::PixNorm(pix), params, &fac); + CameraUtils::dMultK_dparams(params, pix, j); + j[0] *= fac; + j[3] *= fac; + // Derivatives w.r.t. w: + j[8] = params[0] * pix[0] * d_fac; + j[9] = params[1] * pix[1] * d_fac; + } + template static void dProject_dray(const T* ray, const T* params, T* j) { // De-homogenize and multiply by K. From d8dace239e1564f55771c30740dad2f2c391f129 Mon Sep 17 00:00:00 2001 From: Nima Keivan Date: Thu, 8 May 2014 10:22:12 -0400 Subject: [PATCH 4/5] Adds ImageSize() to crtp cameras. Modifies param setting/getting. --- include/calibu/cam/camera_crtp.h | 46 ++++++++++++------------ include/calibu/cam/camera_crtp_interop.h | 8 +++-- 2 files changed, 29 insertions(+), 25 deletions(-) diff --git a/include/calibu/cam/camera_crtp.h b/include/calibu/cam/camera_crtp.h index 3b1fd91..113bdd2 100644 --- a/include/calibu/cam/camera_crtp.h +++ b/include/calibu/cam/camera_crtp.h @@ -54,7 +54,9 @@ namespace calibu const Scalar rho) const = 0; virtual Scalar* GetParams() = 0; + virtual void SetParams(Scalar* params_in) = 0; virtual uint32_t NumParams() const = 0; + virtual const Eigen::Vector2i& ImageSize() const = 0; }; // The Curiously Recurring Template Pattern (CRTP) @@ -62,8 +64,9 @@ namespace calibu class Camera : public CameraInterface { public: - Camera(Scalar* params_in) + Camera(Scalar* params_in, const Eigen::Vector2i& image_size) { + image_size_ = image_size; SetParams(params_in); } @@ -74,27 +77,6 @@ namespace calibu } } - Scalar* GetParams() - { - return params_; - } - - uint32_t NumParams() const - { - return Derived::kParamSize; - } - - void SetParams(Scalar* params_in) - { - if (kOwnsMem) { - params_ = new Scalar[Derived::kParamSize]; - memcpy(params_, params_in, sizeof(Scalar) * Derived::kParamSize); - } - else{ - params_ = params_in; - } - } - Vec3t Unproject(const Vec2t& pix) const { Vec3t ray; @@ -186,9 +168,27 @@ namespace calibu return d_project_dparams + dtransfer3d_dray * dray_dparams; } - protected: + Scalar* GetParams() { return params_; } + + void SetParams(Scalar* params_in) + { + if (kOwnsMem) { + params_ = new Scalar[Derived::kParamSize]; + memcpy(params_, params_in, sizeof(Scalar) * Derived::kParamSize); + } + else{ + params_ = params_in; + } + } + + uint32_t NumParams() const { return Derived::kParamSize; } + + const Eigen::Vector2i& ImageSize() const { return image_size_; } + + protected: Scalar* params_; + Eigen::Vector2i image_size_; }; template diff --git a/include/calibu/cam/camera_crtp_interop.h b/include/calibu/cam/camera_crtp_interop.h index c2a3c54..c5a4913 100644 --- a/include/calibu/cam/camera_crtp_interop.h +++ b/include/calibu/cam/camera_crtp_interop.h @@ -33,9 +33,13 @@ namespace calibu const CameraModelGeneric& old_cam) { if (old_cam.Type() == "calibu_fu_fv_u0_v0_w") { - return new calibu::FovCamera(old_cam.GenericParams().data()); + return new calibu::FovCamera(old_cam.GenericParams().data(), + Eigen::Vector2i(old_cam.Width(), + old_cam.Height())); } else if (old_cam.Type() == "calibu_fu_fv_u0_v0") { - return new calibu::LinearCamera(old_cam.GenericParams().data()); + return new calibu::LinearCamera( + old_cam.GenericParams().data(), + Eigen::Vector2i(old_cam.Width(), old_cam.Height())); } else { std::cerr << "Unknown old camera type " << old_cam.Type() << " please " " implement this camera before initializing it using the " From 3758fb7c7440a700a7d195e6e8719fabf417a907 Mon Sep 17 00:00:00 2001 From: Nima Keivan Date: Tue, 13 May 2014 14:05:44 -0400 Subject: [PATCH 5/5] Adds iostream for cerr. Googlifies opening braces. --- include/calibu/cam/camera_models_crtp.h | 46 +++++++++---------------- 1 file changed, 16 insertions(+), 30 deletions(-) diff --git a/include/calibu/cam/camera_models_crtp.h b/include/calibu/cam/camera_models_crtp.h index f260c01..17a9034 100644 --- a/include/calibu/cam/camera_models_crtp.h +++ b/include/calibu/cam/camera_models_crtp.h @@ -21,14 +21,14 @@ */ #pragma once #include +#include namespace calibu { struct CameraUtils { /** Euclidean distance from (0, 0) to given pixel */ template - static inline T PixNorm(const T* pix) - { + static inline T PixNorm(const T* pix) { return sqrt(pix[0] * pix[0] + pix[1] * pix[1]); } @@ -38,8 +38,7 @@ struct CameraUtils { * @param pix A 2-vector (x, y) * */ template - static inline void Dehomogenize(const T* ray, T* px_dehomogenized) - { + static inline void Dehomogenize(const T* ray, T* px_dehomogenized) { px_dehomogenized[0] = ray[0] / ray[2]; px_dehomogenized[1] = ray[1] / ray[2]; } @@ -51,8 +50,7 @@ struct CameraUtils { * @param ray_homogenized A 3-vector to be filled in */ template - static inline void Homogenize(const T* pix, T* ray_homogenized) - { + static inline void Homogenize(const T* pix, T* ray_homogenized) { ray_homogenized[0] = pix[0]; ray_homogenized[1] = pix[1]; ray_homogenized[2] = 1.0; @@ -66,8 +64,7 @@ struct CameraUtils { * @param j A 2x3 matrix stored in column-major order */ template - static inline void dDehomogenize_dray(const T* ray, T* j) - { + static inline void dDehomogenize_dray(const T* ray, T* j) { const T z_sq = ray[2] * ray[2]; const T z_inv = 1.0 / ray[2]; // Column major storage order. @@ -76,15 +73,13 @@ struct CameraUtils { } template - static inline void dMultK_dparams(const T* params, const T* pix, T* j) - { + static inline void dMultK_dparams(const T* params, const T* pix, T* j) { j[0] = pix[0]; j[2] = 0; j[4] = 1; j[6] = 0; j[1] = 0; j[3] = pix[1]; j[5] = 0; j[7] = 1; } template - static inline void dMultInvK_dparams(const T* params, const T* pix, T* j) - { + static inline void dMultInvK_dparams(const T* params, const T* pix, T* j) { j[0] = -(pix[0] - params[2]) / (params[0] * params[0]); j[1] = 0; j[2] = 0; @@ -107,8 +102,7 @@ struct CameraUtils { * length and principal point to place it in its imaged location. */ template - static inline void MultK(const T* params, const T* pix, T* pix_k) - { + static inline void MultK(const T* params, const T* pix, T* pix_k) { pix_k[0] = params[0] * pix[0] + params[2]; pix_k[1] = params[1] * pix[1] + params[3]; } @@ -233,8 +227,7 @@ class FovCamera : public CameraInterface { // For these derivatives, refer to the camera_derivatives.m matlab file. template - inline static T Factor(const T rad, const T* params) - { + inline static T Factor(const T rad, const T* params) { const T param = params[4]; if (param * param > kCamDistEps) { const T mul2_tanw_by2 = (T)2.0 * tan(param / (T)2.0); @@ -249,8 +242,7 @@ class FovCamera : public CameraInterface { } template - inline static T dFactor_dparam(const T rad, const T* params, T* fac) - { + inline static T dFactor_dparam(const T rad, const T* params, T* fac) { const T param = params[4]; if (param * param > kCamDistEps) { const T tanw_by2 = tan(param / (T)2.0); @@ -275,8 +267,7 @@ class FovCamera : public CameraInterface { } template - inline static T dFactor_drad(const T rad, const T* params, T* fac) - { + inline static T dFactor_drad(const T rad, const T* params, T* fac) { const T param = params[4]; if(param * param < kCamDistEps) { *fac = (T)1; @@ -302,8 +293,7 @@ class FovCamera : public CameraInterface { template - inline static T Factor_inv(const T rad, const T* params) - { + inline static T Factor_inv(const T rad, const T* params) { const T param = params[4]; if(param * param > kCamDistEps) { const T w_by2 = param / (T)2.0; @@ -320,8 +310,7 @@ class FovCamera : public CameraInterface { } template - inline static T dFactor_inv_dparam(const T rad, const T* params) - { + inline static T dFactor_inv_dparam(const T rad, const T* params) { const T param = params[4]; if(param * param > kCamDistEps) { const T tan_wby2 = tan(param / (T)2.0); @@ -341,8 +330,7 @@ class FovCamera : public CameraInterface { } template - inline static T dFactor_inv_drad(const T rad, const T* params, T* fac) - { + inline static T dFactor_inv_drad(const T rad, const T* params, T* fac) { const T param = params[4]; if(param * param > kCamDistEps) { const T w_by2 = param / (T)2.0; @@ -612,16 +600,14 @@ class Poly3Camera : public CameraInterface { } template - static void dProject_dparams(const T* ray, const T* params, T* j) - { + static void dProject_dparams(const T* ray, const T* params, T* j) { std::cerr << "dProjedt_dparams not defined for the poly3 model. " " Throwing exception." << std::endl; throw 0; } template - static void dUnproject_dparams(const T* pix, const T* params, T* j) - { + static void dUnproject_dparams(const T* pix, const T* params, T* j) { std::cerr << "dUnproject_dparams not defined for the poly3 model. " " Throwing exception." << std::endl; throw 0;