/*
    * Copyright (C) 2017 Alberto Irurueta Carro (alberto@irurueta.com)
    *
    * Licensed under the Apache License, Version 2.0 (the "License");
    * you may not use this file except in compliance with the License.
    * You may obtain a copy of the License at
    *
    *         http://www.apache.org/licenses/LICENSE-2.0
    *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  package com.irurueta.ar.sfm;
  
  import com.irurueta.ar.epipolar.CorrectorType;
  import com.irurueta.ar.epipolar.estimators.FundamentalMatrixEstimatorMethod;
  import com.irurueta.ar.epipolar.estimators.FundamentalMatrixRobustEstimator;
  import com.irurueta.ar.epipolar.estimators.PROSACFundamentalMatrixRobustEstimator;
  import com.irurueta.geometry.InhomogeneousPoint2D;
  import com.irurueta.geometry.PinholeCameraIntrinsicParameters;
  import com.irurueta.geometry.estimators.EPnPPointCorrespondencePinholeCameraEstimator;
  import com.irurueta.geometry.estimators.PROSACEPnPPointCorrespondencePinholeCameraRobustEstimator;
  import com.irurueta.geometry.estimators.PinholeCameraRobustEstimator;
  import com.irurueta.geometry.estimators.ProjectiveTransformation2DRobustEstimator;
  import com.irurueta.numerical.robust.RobustEstimatorMethod;
  
  import java.io.Serializable;
  
  /**
   * Base class containing configuration for a sparse re-constructor supporting multiple views.
   *
   * @param <T> an actual implementation of a configuration class.
   */
  public abstract class BaseSparseReconstructorConfiguration<T extends BaseSparseReconstructorConfiguration<T>>
          implements Serializable {
  
      /**
       * Default robust fundamental matrix estimator method.
       * This is only used when general scenes are allowed.
       */
      public static final RobustEstimatorMethod DEFAULT_ROBUST_FUNDAMENTAL_MATRIX_ESTIMATOR_METHOD =
              RobustEstimatorMethod.PROSAC;
  
      /**
       * Default non-robust fundamental matrix estimator method used internally within a robust estimator.
       * This is only used when general scenes are allowed.
       */
      public static final FundamentalMatrixEstimatorMethod DEFAULT_NON_ROBUST_FUNDAMENTAL_MATRIX_ESTIMATOR_METHOD =
              FundamentalMatrixEstimatorMethod.SEVEN_POINTS_ALGORITHM;
  
      /**
       * Indicates that estimated fundamental matrix is refined by default using all found inliers.
       * This is only used when general scenes are allowed.
       */
      public static final boolean DEFAULT_REFINE_FUNDAMENTAL_MATRIX = true;
  
      /**
       * Indicates that fundamental matrix covariance is kept by default after the estimation.
       * This is only used when general scenes are allowed.
       */
      public static final boolean DEFAULT_KEEP_FUNDAMENTAL_MATRIX_COVARIANCE = false;
  
      /**
       * Default confidence of robustly estimated fundamental matrix. By default, this is 99%.
       * This is only used when general scenes are allowed.
       */
      public static final double DEFAULT_FUNDAMENTAL_MATRIX_CONFIDENCE =
              FundamentalMatrixRobustEstimator.DEFAULT_CONFIDENCE;
  
      /**
       * Default maximum number of iterations to make while robustly estimating fundamental matrix.
       * By default, this is 5000 iterations. This is only used when general scenes are allowed.
       */
      public static final int DEFAULT_FUNDAMENTAL_MATRIX_MAX_ITERATIONS =
              FundamentalMatrixRobustEstimator.DEFAULT_MAX_ITERATIONS;
  
      /**
       * Default threshold to determine whether samples for robust fundamental matrix estimation are
       * inliers or not.
       * This is only used when general scenes are allowed.
       */
      public static final double DEFAULT_FUNDAMENTAL_MATRIX_THRESHOLD =
              PROSACFundamentalMatrixRobustEstimator.DEFAULT_THRESHOLD;
  
      /**
       * Default value indicating that inlier data is kept after robust fundamental matrix estimation.
       * This is only used when general scenes are allowed.
       */
      public static final boolean DEFAULT_FUNDAMENTAL_MATRIX_COMPUTE_AND_KEEP_INLIERS = true;
  
      /**
       * Default value indicating that residual data is kept after robust fundamental matrix estimation.
       * This is only used when general scenes are allowed.
       */
      public static final boolean DEFAULT_FUNDAMENTAL_MATRIX_COMPUTE_AND_KEEP_RESIDUALS = true;
  
     /**
      * Default method to use for initial cameras' estimation.
      */
     public static final InitialCamerasEstimatorMethod DEFAULT_INITIAL_CAMERAS_ESTIMATOR_METHOD =
             InitialCamerasEstimatorMethod.DUAL_ABSOLUTE_QUADRIC_AND_ESSENTIAL_MATRIX;
 
     /**
      * Indicates whether an homogeneous point triangulator is used for point triangulation when Dual
      * Absolute Quadric (DAQ) camera initialization is used.
      */
     public static final boolean DEFAULT_DAQ_USE_HOMOGENEOUS_POINT_TRIANGULATOR = true;
 
     /**
      * Default aspect ratio for initial cameras.
      */
     public static final double DEFAULT_INITIAL_CAMERAS_ASPECT_RATIO = 1.0;
 
     /**
      * Default horizontal principal point value to use for initial cameras estimation using
      * Dual Image of Absolute Conic (DIAC) or Dual Absolute Quadric (DAQ) methods.
      */
     public static final double DEFAULT_INITIAL_CAMERAS_PRINCIPAL_POINT_X = 0.0;
 
     /**
      * Default vertical principal point value to use for initial cameras estimation using
      * Dual Image of Absolute Conic (DIAC) or Dual Absolute Quadric (DAQ) methods.
      */
     public static final double DEFAULT_INITIAL_CAMERAS_PRINCIPAL_POINT_Y = 0.0;
 
     /**
      * Default corrector type to use for point triangulation when initial cameras are
      * being estimated using either Dual Image of Absolute Conic (DIAC), Dual Absolute Quadric
      * (DAQ) or essential matrix methods.
      */
     public static final CorrectorType DEFAULT_INITIAL_CAMERAS_CORRECTOR_TYPE = CorrectorType.SAMPSON_CORRECTOR;
 
     /**
      * Default value indicating whether valid triangulated points are marked during initial
      * cameras estimation using either Dual Image of Absolute Conic (DIAC) or essential matrix
      * methods.
      */
     public static final boolean DEFAULT_INITIAL_CAMERAS_MARK_VALID_TRIANGULATED_POINTS = true;
 
     /**
      * Indicates whether a general (points are laying in a general 3D position) scene is
      * allowed.
      * When true, an initial geometry estimation is attempted for general points.
      */
     public static final boolean DEFAULT_ALLOW_GENERAL_SCENE = true;
 
     /**
      * Indicates whether a planar (points laying in a 3D plane) scene is allowed.
      * When true, an initial geometry estimation is attempted for planar points.
      */
     public static final boolean DEFAULT_ALLOW_PLANAR_SCENE = true;
 
     /**
      * Default robust planar homography estimator method.
      * This is only used when planar scenes are allowed.
      */
     public static final RobustEstimatorMethod DEFAULT_ROBUST_PLANAR_HOMOGRAPHY_ESTIMATOR_METHOD =
             RobustEstimatorMethod.PROMEDS;
 
     /**
      * Indicates that planar homography is refined by default using all found inliers.
      * This is only used when planar scenes are allowed.
      */
     public static final boolean DEFAULT_REFINE_PLANAR_HOMOGRAPHY = true;
 
     /**
      * Indicates that planar homography covariance is kept by default after estimation.
      * This is only used when planar scenes are allowed.
      */
     public static final boolean DEFAULT_KEEP_PLANAR_HOMOGRAPHY_COVARIANCE = false;
 
     /**
      * Default confidence of robustly estimated planar homography. By default, this is 99%.
      * This is only used when planar scenes are allowed.
      */
     public static final double DEFAULT_PLANAR_HOMOGRAPHY_CONFIDENCE =
             ProjectiveTransformation2DRobustEstimator.DEFAULT_CONFIDENCE;
 
     /**
      * Default maximum number of iterations to make while robustly estimating planar
      * homography. By default, this is 5000 iterations.
      * This is only used when planar scenes are allowed.
      */
     public static final int DEFAULT_PLANAR_HOMOGRAPHY_MAX_ITERATIONS =
             ProjectiveTransformation2DRobustEstimator.DEFAULT_MAX_ITERATIONS;
 
     /**
      * Default threshold to determine whether samples for robust projective 2D transformation
      * estimation are inliers or not.
      * This is only used when planar scenes are allowed.
      */
     public static final double DEFAULT_PLANAR_HOMOGRAPHY_THRESHOLD = 1e-3;
 
     /**
      * Default value indicating that inlier data is kept after robust planar homography estimation.
      * This is only used when planar scenes are allowed.
      */
     public static final boolean DEFAULT_PLANAR_HOMOGRAPHY_COMPUTE_AND_KEEP_INLIERS = true;
 
     /**
      * Default value indicating that residual data is kept after robust planar homography
      * estimation.
      * This is only used when planar scenes are allowed.
      */
     public static final boolean DEFAULT_PLANAR_HOMOGRAPHY_COMPUTE_AND_KEEP_RESIDUALS = true;
 
     /**
      * Default value indicating that additional cameras intrinsics are estimated using the
      * Dual Absolute Quadric (DAQ).
      */
     public static final boolean DEFAULT_USE_DAQ_FOR_ADDITIONAL_CAMERAS_INTRINSICS = true;
 
     /**
      * Default value indicating that additional cameras intrinsics are estimated using
      * the Dual Image of Absolute Conic (DIAC).
      */
     public static final boolean DEFAULT_USE_DIAC_FOR_ADDITIONAL_CAMERAS_INTRINSICS = false;
 
     /**
      * Default skewness for additional cameras when UPnP (Uncalibrated Perspective-n-Point)
      * method is used for additional cameras estimation and neither Dual Image of Absolute
      * Conic (DIAC) or Dual Absolute Quadric (DAQ) are estimated to find intrinsic
      * parameters when adding new cameras.
      */
     public static final double DEFAULT_ADDITIONAL_CAMERAS_SKEWNESS = 0.0;
 
     /**
      * Default horizontal coordinate of principal point for additional cameras when
      * UPnP (Uncalibrated Perspective-n-Point) method is used for additional cameras
      * estimation and neither Dual Image of Absolute Conic (DIAC) or Dual Absolute
      * Quadric (DAQ) are estimated to find intrinsic parameters when adding new
      * cameras.
      */
     public static final double DEFAULT_ADDITIONAL_CAMERAS_HORIZONTAL_PRINCIPAL_POINT = 0.0;
 
     /**
      * Default vertical coordinate of principal point for additional cameras when
      * UPnP (Uncalibrated Perspective-n-Point) method is used for additional cameras
      * estimation and neither Dual Image of Absolute Conic (DIAC) or Dual Absolute
      * Quadric (DAQ) are estimated to find intrinsic parameters when adding new
      * cameras.
      */
     public static final double DEFAULT_ADDITIONAL_CAMERAS_VERTICAL_PRINCIPAL_POINT = 0.0;
 
     /**
      * Default aspect ratio for additional cameras.
      */
     public static final double DEFAULT_ADDITIONAL_CAMERAS_ASPECT_RATIO = 1.0;
 
 
     /**
      * Indicates that by default EPnP (Efficient Perspective-n-Point) method is NOT
      * used for additional cameras' estimation.
      */
     public static final boolean DEFAULT_USE_EPNP_FOR_ADDITIONAL_CAMERAS_ESTIMATION = false;
 
     /**
      * Indicates that by default UPnP (Uncalibrated Perspective-n-Point) method is
      * used for additional cameras' estimation.
      */
     public static final boolean DEFAULT_USE_UPNP_FOR_ADDITIONAL_CAMERAS_ESTIMATION = true;
 
     /**
      * Default robust method to estimate additional cameras.
      */
     public static final RobustEstimatorMethod DEFAULT_ADDITIONAL_CAMERAS_ROBUST_ESTIMATION_METHOD =
             RobustEstimatorMethod.PROSAC;
 
     /**
      * Default value indicating that planar configuration is allowed for additional
      * cameras estimation using either EPnP or UPnP.
      */
     public static final boolean DEFAULT_ADDITIONAL_CAMERAS_ALLOW_PLANAR_CONFIGURATION =
             EPnPPointCorrespondencePinholeCameraEstimator.DEFAULT_PLANAR_CONFIGURATION_ALLOWED;
 
     /**
      * Default value indicating that dimension 2 null-space is allowed while estimating
      * additional cameras using either EPnP or UPnP.
      */
     public static final boolean DEFAULT_ADDITIONAL_CAMERAS_ALLOW_NULLSPACE_DIMENSION2 =
             EPnPPointCorrespondencePinholeCameraEstimator.DEFAULT_NULLSPACE_DIMENSION2_ALLOWED;
 
     /**
      * Default value indicating that dimension 3 null-space is allowed while estimating
      * additional cameras using EPnP.
      */
     public static final boolean DEFAULT_ADDITIONAL_CAMERAS_ALLOW_NULLSPACE_DIMENSION3 =
             EPnPPointCorrespondencePinholeCameraEstimator.DEFAULT_NULLSPACE_DIMENSION3_ALLOWED;
 
     /**
      * Default threshold to determine whether 3D matched points to estimate additional
      * cameras are in a planar configuration.
      */
     public static final double DEFAULT_ADDITIONAL_CAMERAS_PLANAR_THRESHOLD =
             EPnPPointCorrespondencePinholeCameraEstimator.DEFAULT_PLANAR_THRESHOLD;
 
     /**
      * Default value indicating that additional cameras are refined to minimize overall
      * projection error among all found inliers.
      */
     public static final boolean DEFAULT_REFINE_ADDITIONAL_CAMERAS = PinholeCameraRobustEstimator.DEFAULT_REFINE_RESULT;
 
     /**
      * Default value indicating that covariance is kept after refining results of
      * additional cameras estimation.
      */
     public static final boolean DEFAULT_KEEP_COVARIANCE_ADDITIONAL_CAMERAS = true;
 
     /**
      * Default value indicating that fast refinement is used for additional cameras'
      * estimation.
      */
     public static final boolean DEFAULT_ADDITIONAL_CAMERAS_USE_FAST_REFINEMENT = true;
 
     /**
      * Default confidence of estimated additional cameras, which is 99%. This means
      * that with a probability of 99% estimation will be accurate because chosen
      * sub-samples will be inliers.
      */
     public static final double DEFAULT_ADDITIONAL_CAMERAS_CONFIDENCE = PinholeCameraRobustEstimator.DEFAULT_CONFIDENCE;
 
     /**
      * Default maximum allowed number of iterations for additional cameras estimation.
      */
     public static final int DEFAULT_ADDITIONAL_CAMERAS_MAX_ITERATIONS =
             PinholeCameraRobustEstimator.DEFAULT_MAX_ITERATIONS;
 
     /**
      * Default threshold to determine whether samples for robust pinhole camera estimation are
      * inliers or not.
      */
     public static final double DEFAULT_ADDITIONAL_CAMERAS_THRESHOLD =
             PROSACEPnPPointCorrespondencePinholeCameraRobustEstimator.DEFAULT_THRESHOLD;
 
     /**
      * Default value indicating that inlier data is kept after additional camera estimation.
      */
     public static final boolean DEFAULT_ADDITIONAL_CAMERAS_COMPUTE_AND_KEEP_INLIERS = true;
 
     /**
      * Default value indicating that residual data is kept after additional camera estimation.
      */
     public static final boolean DEFAULT_ADDITIONAL_CAMERAS_COMPUTE_AND_KEEP_RESIDUALS = true;
 
     /**
      * Default value indicating that skewness is not suggested during additional cameras'
      * estimation.
      */
     public static final boolean DEFAULT_ADDITIONAL_CAMERAS_SUGGEST_SKEWNESS_VALUE_ENABLED =
             PinholeCameraRobustEstimator.DEFAULT_SUGGEST_SKEWNESS_VALUE_ENABLED;
 
     /**
      * Default value of skewness to be suggested when suggestion is enabled during
      * additional cameras' estimation.
      * By default, suggested skewness is zero.
      */
     public static final double DEFAULT_ADDITIONAL_CAMERAS_SUGGESTED_SKEWNESS_VALUE =
             PinholeCameraRobustEstimator.DEFAULT_SUGGESTED_SKEWNESS_VALUE;
 
     /**
      * Default value indicating whether horizontal focal length value is suggested or not
      * during additional cameras' estimation. By default, this is disabled.
      */
     public static final boolean DEFAULT_ADDITIONAL_CAMERAS_SUGGEST_HORIZONTAL_FOCAL_LENGTH_ENABLED =
             PinholeCameraRobustEstimator.DEFAULT_SUGGEST_HORIZONTAL_FOCAL_LENGTH_ENABLED;
 
     /**
      * Default value indicating whether vertical focal length value is suggested or not
      * during additional cameras' estimation. By default, this is disabled.
      */
     public static final boolean DEFAULT_ADDITIONAL_CAMERAS_SUGGEST_VERTICAL_FOCAL_LENGTH_ENABLED =
             PinholeCameraRobustEstimator.DEFAULT_SUGGEST_VERTICAL_FOCAL_LENGTH_ENABLED;
 
     /**
      * Default value indicating whether aspect ratio is suggested or not. By default, this is
      * disabled.
      */
     public static final boolean DEFAULT_ADDITIONAL_CAMERAS_SUGGEST_ASPECT_RATIO_ENABLED =
             PinholeCameraRobustEstimator.DEFAULT_SUGGEST_ASPECT_RATIO_ENABLED;
 
     /**
      * Default value of aspect ratio to be suggested when suggestion is enabled.
      * By default, suggested aspect ratio is 1.0, although also -1.0 is a typical value
      * when vertical coordinates increase downwards.
      */
     public static final double DEFAULT_ADDITIONAL_CAMERAS_SUGGESTED_ASPECT_RATIO_VALUE =
             PinholeCameraRobustEstimator.DEFAULT_SUGGESTED_ASPECT_RATIO_VALUE;
 
     /**
      * Default value indicating whether principal point is suggested or not. By default,
      * this is disabled.
      */
     public static final boolean DEFAULT_ADDITIONAL_CAMERAS_SUGGEST_PRINCIPAL_POINT_ENABLED =
             PinholeCameraRobustEstimator.DEFAULT_SUGGEST_PRINCIPAL_POINT_ENABLED;
 
     /**
      * Indicates that an homogeneous point triangulator will be used by default.
      */
     public static final boolean DEFAULT_USE_HOMOGENEOUS_POINT_TRIANGULATOR =
             RobustSinglePoint3DTriangulator.DEFAULT_USE_HOMOGENEOUS_SOLUTION;
 
     /**
      * Default robust point triangulator method.
      */
     public static final RobustEstimatorMethod DEFAULT_ROBUST_POINT_TRIANGULATOR_METHOD =
             RobustSinglePoint3DTriangulator.DEFAULT_ROBUST_METHOD;
 
     /**
      * Default confidence of robustly triangulated points. By default, this is 99%.
      */
     public static final double DEFAULT_POINT_TRIANGULATOR_CONFIDENCE =
             RobustSinglePoint3DTriangulator.DEFAULT_CONFIDENCE;
 
     /**
      * Default maximum number of iterations to make while robustly estimating
      * triangulated points. By default, this is 5000 iterations.
      */
     public static final int DEFAULT_POINT_TRIANGULATOR_MAX_ITERATIONS =
             RobustSinglePoint3DTriangulator.DEFAULT_MAX_ITERATIONS;
 
     /**
      * Default threshold to determine whether samples for robust point triangulator are
      * inliers or not.
      */
     public static final double DEFAULT_POINT_TRIANGULATOR_THRESHOLD =
             PROSACRobustSinglePoint3DTriangulator.DEFAULT_THRESHOLD;
 
     /**
      * Method to use for non-robust fundamental matrix estimation.
      * This is only used when general scenes are allowed.
      */
     private FundamentalMatrixEstimatorMethod mNonRobustFundamentalMatrixEstimatorMethod =
             DEFAULT_NON_ROBUST_FUNDAMENTAL_MATRIX_ESTIMATOR_METHOD;
 
     /**
      * Method to use for robust fundamental matrix estimation.
      * This is only used when general scenes are allowed.
      */
     private RobustEstimatorMethod mRobustFundamentalMatrixEstimatorMethod =
             DEFAULT_ROBUST_FUNDAMENTAL_MATRIX_ESTIMATOR_METHOD;
 
     /**
      * Indicates whether estimated fundamental matrix is refined among all found inliers.
      * This is only used when general scenes are allowed.
      */
     private boolean refineFundamentalMatrix = DEFAULT_REFINE_FUNDAMENTAL_MATRIX;
 
     /**
      * Indicates whether covariance of estimated fundamental matrix is kept after the
      * estimation.
      * This is only used when general scenes are allowed.
      */
     private boolean keepFundamentalMatrixCovariance = DEFAULT_KEEP_FUNDAMENTAL_MATRIX_COVARIANCE;
 
     /**
      * Confidence of robustly estimated fundamental matrix.
      * This is only used when general scenes are allowed.
      */
     private double fundamentalMatrixConfidence = DEFAULT_FUNDAMENTAL_MATRIX_CONFIDENCE;
 
     /**
      * Maximum number of iterations to robustly estimate fundamental matrix.
      * This is only used when general scenes are allowed.
      */
     private int fundamentalMatrixMaxIterations = DEFAULT_FUNDAMENTAL_MATRIX_MAX_ITERATIONS;
 
     /**
      * Threshold to determine whether samples for robust fundamental matrix estimation are
      * inliers or not.
      * This is only used when general scenes are allowed.
      */
     private double fundamentalMatrixThreshold = DEFAULT_FUNDAMENTAL_MATRIX_THRESHOLD;
 
     /**
      * Indicates whether inliers must be kept during robust fundamental matrix estimation.
      * This is only used when general scenes are allowed.
      */
     private boolean fundamentalMatrixComputeAndKeepInliers = DEFAULT_FUNDAMENTAL_MATRIX_COMPUTE_AND_KEEP_INLIERS;
 
     /**
      * Indicates whether residuals must be computed and kept during robust fundamental matrix
      * estimation.
      * This is only used when general scenes are allowed.
      */
     private boolean fundamentalMatrixComputeAndKeepResiduals = DEFAULT_FUNDAMENTAL_MATRIX_COMPUTE_AND_KEEP_RESIDUALS;
 
     /**
      * Method to use for initial cameras' estimation.
      */
     private InitialCamerasEstimatorMethod initialCamerasEstimatorMethod = DEFAULT_INITIAL_CAMERAS_ESTIMATOR_METHOD;
 
     /**
      * Indicates whether an homogeneous point triangulator is used for point triangulation
      * when Dual Absolute Quadric (DAQ) camera initialization is used.
      */
     private boolean daqUseHomogeneousPointTriangulator = DEFAULT_DAQ_USE_HOMOGENEOUS_POINT_TRIANGULATOR;
 
     /**
      * Aspect ratio for initial cameras.
      */
     private double initialCamerasAspectRatio = DEFAULT_INITIAL_CAMERAS_ASPECT_RATIO;
 
     /**
      * Horizontal principal point value to use for initial cameras estimation using
      * Dual Image of Absolute Conic (DIAC) or Dual Absolute Quadric (DAQ) methods.
      */
     private double principalPointX = DEFAULT_INITIAL_CAMERAS_PRINCIPAL_POINT_X;
 
     /**
      * Vertical principal point value to use for initial cameras estimation using
      * Dual Image of Absolute Conic (DIAC) or Dual Absolute Quadric (DAC) methods.
      */
     private double principalPointY = DEFAULT_INITIAL_CAMERAS_PRINCIPAL_POINT_Y;
 
     /**
      * Corrector type to use for point triangulation when initial cameras are being estimated
      * using either Dual Image of Absolute Conic (DIAC) or essential matrix methods or null
      * if no corrector is used.
      */
     private CorrectorType initialCamerasCorrectorType = DEFAULT_INITIAL_CAMERAS_CORRECTOR_TYPE;
 
     /**
      * Value indicating whether valid triangulated points are marked during initial
      * cameras estimation using either Dual Image of Absolute Conic (DIAC) or essential
      * matrix methods.
      */
     private boolean initialCamerasMarkValidTriangulatedPoints = DEFAULT_INITIAL_CAMERAS_MARK_VALID_TRIANGULATED_POINTS;
 
     /**
      * Intrinsic parameters of first camera estimated using the essential matrix
      * method.
      */
     private PinholeCameraIntrinsicParameters initialIntrinsic1;
 
     /**
      * Intrinsic parameters of second camera estimated using the essential matrix
      * method.
      */
     private PinholeCameraIntrinsicParameters initialIntrinsic2;
 
     /**
      * Indicates whether a general scene (points laying in a general 3D position) is
      * allowed.
      * When true, an initial geometry estimation is attempted for general points.
      */
     private boolean allowGeneralScene = DEFAULT_ALLOW_GENERAL_SCENE;
 
     /**
      * Indicates whether a planar scene (points laying in a 3D plane) is allowed.
      * When true, an initial geometry estimation is attempted for planar points.
      */
     private boolean allowPlanarScene = DEFAULT_ALLOW_PLANAR_SCENE;
 
     /**
      * Robust method to use for planar homography estimation.
      * This is only used when planar scenes are allowed.
      */
     private RobustEstimatorMethod robustPlanarHomographyEstimatorMethod =
             DEFAULT_ROBUST_PLANAR_HOMOGRAPHY_ESTIMATOR_METHOD;
 
     /**
      * Indicates whether planar homography is refined using all found inliers or not.
      * This is only used when planar scenes are allowed.
      */
     private boolean refinePlanarHomography = DEFAULT_REFINE_PLANAR_HOMOGRAPHY;
 
     /**
      * Indicates whether planar homography covariance is kept after estimation.
      * This is only used when planar scenes are allowed.
      */
     private boolean keepPlanarHomographyCovariance = DEFAULT_KEEP_PLANAR_HOMOGRAPHY_COVARIANCE;
 
     /**
      * Confidence of robustly estimated planar homography. By default, this is 99%.
      * This is only used when planar scenes are allowed.
      */
     private double planarHomographyConfidence = DEFAULT_PLANAR_HOMOGRAPHY_CONFIDENCE;
 
     /**
      * Maximum number of iterations to make while robustly estimating planar homography.
      * By default, this is 5000.
      * This is only used when planar scenes are allowed.
      */
     private int planarHomographyMaxIterations = DEFAULT_PLANAR_HOMOGRAPHY_MAX_ITERATIONS;
 
     /**
      * Threshold to determine whether samples for robust projective 2D transformation estimation
      * are inliers or not.
      */
     private double planarHomographyThreshold = DEFAULT_PLANAR_HOMOGRAPHY_THRESHOLD;
 
     /**
      * Value indicating that inlier data is kept after robust planar homography estimation.
      * This is only used when planar scenes are allowed.
      */
     private boolean planarHomographyComputeAndKeepInliers = DEFAULT_PLANAR_HOMOGRAPHY_COMPUTE_AND_KEEP_INLIERS;
 
     /**
      * Value indicating that residual data is kept after robust planar homography estimation.
      * This is only used when planar scenes are allowed.
      */
     private boolean planarHomographyComputeAndKeepResiduals = DEFAULT_PLANAR_HOMOGRAPHY_COMPUTE_AND_KEEP_RESIDUALS;
 
     /**
      * Indicates that additional cameras intrinsics are estimated using the Dual Absolute
      * Quadric (DAQ).
      */
     private boolean useDAQForAdditionalCamerasIntrinsics = DEFAULT_USE_DAQ_FOR_ADDITIONAL_CAMERAS_INTRINSICS;
 
     /**
      * Indicates that additional cameras intrinsics are estimated using the Dual Image of Absolute
      * Conic (DIAC).
      */
     private boolean useDIACForAdditionalCamerasIntrinsics = DEFAULT_USE_DIAC_FOR_ADDITIONAL_CAMERAS_INTRINSICS;
 
     /**
      * Intrinsic parameters to use for additional cameras estimation when neither
      * Dual Image of Absolute Conic (DIAC) nor Dual Absolute Quadric (DAQ) are used
      * for intrinsic parameters' estimation.
      */
     private PinholeCameraIntrinsicParameters additionalCamerasIntrinsics;
 
     /**
      * Skewness for additional cameras when UPnP (Uncalibrated Perspective-n-Point) method
      * is used for additional cameras' estimation.
      */
     private double additionalCamerasSkewness = DEFAULT_ADDITIONAL_CAMERAS_SKEWNESS;
 
     /**
      * Horizontal coordinate of principal point for additional cameras when UPnP
      * (Uncalibrated Perspective-n-Point) method is used for additional cameras estimation
      * and neither Dual Image of Absolute Conic (DIAC) or Dual Absolute Quadric (DAQ) are
      * estimated to find intrinsic parameters when adding new cameras.
      */
     private double additionalCamerasHorizontalPrincipalPoint = DEFAULT_ADDITIONAL_CAMERAS_HORIZONTAL_PRINCIPAL_POINT;
 
     /**
      * Vertical coordinate of principal point for additional cameras when UPnP (Uncalibrated
      * Perspective-n-Point) method is used for additional cameras estimation and neither Dual
      * Image of Absolute Conic (DIAC) nor Dual Absolute Quadric (DAQ) are estimated to find
      * intrinsic parameters when adding new cameras.
      */
     private double additionalCamerasVerticalPrincipalPoint = DEFAULT_ADDITIONAL_CAMERAS_VERTICAL_PRINCIPAL_POINT;
 
     /**
      * Aspect ratio for additional cameras.
      */
     private double additionalCamerasAspectRatio = DEFAULT_ADDITIONAL_CAMERAS_ASPECT_RATIO;
 
     /**
      * Indicates whether EPnP (Efficient Perspective-n-Point) method is used for additional
      * cameras' estimation. Either EPnP or UPnP must be used for additional cameras'
      * estimation.
      */
     private boolean useEPnPForAdditionalCamerasEstimation = DEFAULT_USE_EPNP_FOR_ADDITIONAL_CAMERAS_ESTIMATION;
 
     /**
      * Indicates whether UPnP (Uncalibrated Perspective-n-Point) method is used for
      * additional cameras' estimation. Either EPnP or UPnP must be used for additional
      * cameras' estimation.
      */
     private boolean useUPnPForAdditionalCamerasEstimation = DEFAULT_USE_UPNP_FOR_ADDITIONAL_CAMERAS_ESTIMATION;
 
     /**
      * Robust method to estimate additional cameras.
      */
     private RobustEstimatorMethod additionalCamerasRobustEstimationMethod =
             DEFAULT_ADDITIONAL_CAMERAS_ROBUST_ESTIMATION_METHOD;
 
     /**
      * Indicates whether planar configuration is allowed for additional cameras
      * estimation using either EPnP or UPnP.
      */
     private boolean additionalCamerasAllowPlanarConfiguration = DEFAULT_ADDITIONAL_CAMERAS_ALLOW_PLANAR_CONFIGURATION;
 
     /**
      * Indicates whether dimension 2 null-space is allowed while estimating additional
      * cameras using either EPnP or UPnP.
      */
     private boolean additionalCamerasAllowNullspaceDimension2 = DEFAULT_ADDITIONAL_CAMERAS_ALLOW_NULLSPACE_DIMENSION2;
 
     /**
      * Indicates whether dimension 3 null-space is allowed while estimating additional
      * cameras using EPnP.
      */
     private boolean additionalCamerasAllowNullspaceDimension3 = DEFAULT_ADDITIONAL_CAMERAS_ALLOW_NULLSPACE_DIMENSION3;
 
     /**
      * Threshold to determine whether 3D matched points to estimate additional cameras
      * are in a planar configuration.
      */
     private double additionalCamerasPlanarThreshold = DEFAULT_ADDITIONAL_CAMERAS_PLANAR_THRESHOLD;
 
     /**
      * Indicates whether additional cameras are refined to minimize overall projection
      * error among all found inliers.
      */
     private boolean refineAdditionalCameras = DEFAULT_REFINE_ADDITIONAL_CAMERAS;
 
     /**
      * Indicates whether covariance is kept after refining result of additional
      * cameras' estimation.
      */
     private boolean keepCovarianceAdditionalCameras = DEFAULT_KEEP_COVARIANCE_ADDITIONAL_CAMERAS;
 
     /**
      * Value indicating whether fast refinement is used for additional cameras' estimation.
      */
     private boolean additionalCamerasUseFastRefinement = DEFAULT_ADDITIONAL_CAMERAS_USE_FAST_REFINEMENT;
 
     /**
      * Confidence of estimated additional cameras.
      */
     private double additionalCamerasConfidence = DEFAULT_ADDITIONAL_CAMERAS_CONFIDENCE;
 
     /**
      * Maximum allowed number of iterations for additional cameras estimation.
      */
     private int additionalCamerasMaxIterations = DEFAULT_ADDITIONAL_CAMERAS_MAX_ITERATIONS;
 
     /**
      * Threshold to determine whether samples for robust pinhole camera estimation are inliers or not.
      */
     private double additionalCamerasThreshold = DEFAULT_ADDITIONAL_CAMERAS_THRESHOLD;
 
     /**
      * Indicates whether inliers must be kept during additional camera estimation.
      */
     private boolean additionalCamerasComputeAndKeepInliers = DEFAULT_ADDITIONAL_CAMERAS_COMPUTE_AND_KEEP_INLIERS;
 
     /**
      * Indicates whether residuals must be computed and kept during additional camera estimation.
      */
     private boolean additionalCamerasComputeAndKeepResiduals = DEFAULT_ADDITIONAL_CAMERAS_COMPUTE_AND_KEEP_RESIDUALS;
 
     /**
      * Value indicating whether skewness is not suggested during additional cameras'
      * estimation.
      */
     private boolean additionalCamerasSuggestSkewnessValueEnabled =
             DEFAULT_ADDITIONAL_CAMERAS_SUGGEST_SKEWNESS_VALUE_ENABLED;
 
     /**
      * Value of skewness to be suggested when suggestion is enabled during additional
      * cameras' estimation.
      */
     private double additionalCamerasSuggestedSkewnessValue = DEFAULT_ADDITIONAL_CAMERAS_SUGGESTED_SKEWNESS_VALUE;
 
     /**
      * Value indicating whether horizontal focal length value is suggested or not
      * during additional cameras' estimation.
      */
     private boolean additionalCamerasSuggestHorizontalFocalLengthEnabled =
             DEFAULT_ADDITIONAL_CAMERAS_SUGGEST_HORIZONTAL_FOCAL_LENGTH_ENABLED;
 
     /**
      * Value of suggested horizontal focal length during additional cameras' estimation.
      */
     private double additionalCamerasSuggestedHorizontalFocalLengthValue;
 
     /**
      * Value indicating whether vertical focal length value is suggested or not
      * during additional cameras' estimation.
      */
     private boolean additionalCamerasSuggestVerticalFocalLengthEnabled =
             DEFAULT_ADDITIONAL_CAMERAS_SUGGEST_VERTICAL_FOCAL_LENGTH_ENABLED;
 
     /**
      * Value of suggested vertical focal length during additional cameras' estimation.
      */
     private double additionalCamerasSuggestedVerticalFocalLengthValue;
 
     /**
      * Value indicating whether aspect ratio is suggested or not during
      * additional cameras' estimation.
      */
     private boolean additionalCamerasSuggestAspectRatioEnabled =
             DEFAULT_ADDITIONAL_CAMERAS_SUGGEST_ASPECT_RATIO_ENABLED;
 
     /**
      * Value of aspect ratio to be suggested when suggestion is enabled during
      * additional cameras' estimation.
      */
     private double additionalCamerasSuggestedAspectRatioValue =
             DEFAULT_ADDITIONAL_CAMERAS_SUGGESTED_ASPECT_RATIO_VALUE;
 
     /**
      * Value indicating whether principal point is suggested or not during
      * additional cameras' estimation.
      */
     private boolean additionalCamerasSuggestPrincipalPointEnabled =
             DEFAULT_ADDITIONAL_CAMERAS_SUGGEST_PRINCIPAL_POINT_ENABLED;
 
     /**
      * Value of principal point to be suggested when suggestion is enabled
      * during additional cameras' estimation.
      */
     private InhomogeneousPoint2D additionalCamerasSuggestedPrincipalPointValue;
 
     /**
      * Indicates whether homogeneous point triangulator must be used or not to
      * estimate 3D points when only two matches are available.
      */
     private boolean useHomogeneousPointTriangulator = DEFAULT_USE_HOMOGENEOUS_POINT_TRIANGULATOR;
 
     /**
      * Robust method for point triangulation when points are matched in more
      * than two views.
      */
     private RobustEstimatorMethod robustPointTriangulatorMethod = DEFAULT_ROBUST_POINT_TRIANGULATOR_METHOD;
 
     /**
      * Confidence of robustly triangulated points. By default, this is 99%.
      */
     private double pointTriangulatorConfidence = DEFAULT_POINT_TRIANGULATOR_CONFIDENCE;
 
     /**
      * Maximum number of iterations to make while robustly estimating
      * triangulated points. By default, this is 5000 iterations.
      */
     private int pointTriangulatorMaxIterations = DEFAULT_POINT_TRIANGULATOR_MAX_ITERATIONS;
 
     /**
      * Threshold to determine whether samples for robust point triangulator are
      * inliers or not.
      */
     private double pointTriangulatorThreshold = DEFAULT_POINT_TRIANGULATOR_THRESHOLD;
 
     /**
      * Constructor.
      */
     protected BaseSparseReconstructorConfiguration() {
     }
 
     /**
      * Gets method to use for non-robust fundamental matrix estimation.
      * This is only used when general scenes are allowed.
      *
      * @return method to use for non-robust fundamental matrix estimation.
      */
     public FundamentalMatrixEstimatorMethod getNonRobustFundamentalMatrixEstimatorMethod() {
         return mNonRobustFundamentalMatrixEstimatorMethod;
     }
 
     /**
      * Sets method to use for non-robust fundamental matrix estimation.
      * This is only used when general scenes are allowed.
      *
      * @param method method to use for non-robust fundamental matrix estimation.
      * @return this instance so that method can be easily chained.
      */
     public T setNonRobustFundamentalMatrixEstimatorMethod(final FundamentalMatrixEstimatorMethod method) {
         mNonRobustFundamentalMatrixEstimatorMethod = method;
         //noinspection unchecked
         return (T) this;
     }
 
     /**
      * Gets method to use for robust fundamental matrix estimation.
      * This is only used when general scenes are allowed.
      *
      * @return method to use for robust fundamental matrix estimation.
      */
     public RobustEstimatorMethod getRobustFundamentalMatrixEstimatorMethod() {
         return mRobustFundamentalMatrixEstimatorMethod;
     }
 
     /**
      * Sets method to use for robust fundamental matrix estimation.
      * This is only used when general scenes are allowed.
      *
      * @param method method to use for robust fundamental matrix estimation.
      * @return this instance so that method can be easily chained.
      */
     public T setRobustFundamentalMatrixEstimatorMethod(final RobustEstimatorMethod method) {
         mRobustFundamentalMatrixEstimatorMethod = method;
         //noinspection unchecked
         return (T) this;
     }
 
     /**
      * Indicates whether estimated fundamental matrix is refined among all found inliers.
      * This is only used when general scenes are allowed.
      *
      * @return true if fundamental matrix is refined, false otherwise.
      */
     public boolean isFundamentalMatrixRefined() {
         return refineFundamentalMatrix;
     }
 
     /**
      * Specifies whether estimated fundamental matrix is refined among all found inliers.
      * This is only used when general scenes are allowed.
      *
      * @param refineFundamentalMatrix true if fundamental matrix is refined, false otherwise.
      * @return this instance so that method can be easily chained.
      */
     public T setFundamentalMatrixRefined(final boolean refineFundamentalMatrix) {
         this.refineFundamentalMatrix = refineFundamentalMatrix;
         //noinspection unchecked
         return (T) this;
     }
 
     /**
      * Indicates whether covariance of estimated fundamental matrix is kept after the estimation.
      * This is only used when general scenes are allowed.
      *
      * @return true if covariance is kept, false otherwise.
      */
     public boolean isFundamentalMatrixCovarianceKept() {
         return keepFundamentalMatrixCovariance;
     }
 
     /**
      * Specifies whether covariance of estimated fundamental matrix is kept after the
      * estimation.
      * This is only used when general scenes are allowed.
      *
      * @param keepFundamentalMatrixCovariance true if covariance is kept, false otherwise.
      * @return this instance so that method can be easily chained.
      */
     public T setFundamentalMatrixCovarianceKept(final boolean keepFundamentalMatrixCovariance) {
         this.keepFundamentalMatrixCovariance = keepFundamentalMatrixCovariance;
         //noinspection unchecked
         return (T) this;
     }
 
     /**
      * Gets confidence of robustly estimated fundamental matrix.
      * This is only used when general scenes are allowed.
      *
      * @return confidence of robustly estimated fundamental matrix.
      */
     public double getFundamentalMatrixConfidence() {
         return fundamentalMatrixConfidence;
     }
 
     /**
      * Sets confidence of robustly estimated fundamental matrix.
      * This is only used when general scenes are allowed.
      *
      * @param fundamentalMatrixConfidence confidence of robustly estimated fundamental matrix.
      * @return this instance so that method can be easily chained.
      */
     public T setFundamentalMatrixConfidence(final double fundamentalMatrixConfidence) {
         this.fundamentalMatrixConfidence = fundamentalMatrixConfidence;
         //noinspection unchecked
         return (T) this;
     }
 
     /**
      * Gets maximum number of iterations to robustly estimate fundamental matrix.
      * This is only used when general scenes are allowed.
      *
      * @return maximum number of iterations to robustly estimate fundamental matrix.
      */
     public int getFundamentalMatrixMaxIterations() {
         return fundamentalMatrixMaxIterations;
     }
 
     /**
      * Sets maximum number of iterations to robustly estimate fundamental matrix.
      * This is only used when general scenes are allowed.
      *
      * @param fundamentalMatrixMaxIterations maximum number of iterations to robustly estimate
      *                                       fundamental matrix.
      * @return this instance so that method can be easily chained.
      */
     public T setFundamentalMatrixMaxIterations(final int fundamentalMatrixMaxIterations) {
         this.fundamentalMatrixMaxIterations = fundamentalMatrixMaxIterations;
         //noinspection unchecked
         return (T) this;
     }
 
     /**
      * Gets threshold to determine whether samples for robust fundamental matrix estimation
      * are inliers or not.
      * This is only used when general scenes are allowed.
      *
      * @return threshold to determine whether samples for robust fundamental matrix
      * estimation are inliers or not.
      */
     public double getFundamentalMatrixThreshold() {
         return fundamentalMatrixThreshold;
     }
 
     /**
      * Sets threshold to determine whether samples for robust fundamental matrix
      * estimation are inliers or not.
      * This is only used when general scenes are allowed.
      *
      * @param fundamentalMatrixThreshold threshold to determine whether samples for
      *                                   robust fundamental matrix estimation are inliers
      *                                   or not.
      * @return this instance so that method can be easily chained.
      */
     public T setFundamentalMatrixThreshold(final double fundamentalMatrixThreshold) {
         this.fundamentalMatrixThreshold = fundamentalMatrixThreshold;
         //noinspection unchecked
         return (T) this;
     }
 
     /**
      * Indicates whether inliers must be kept during robust fundamental matrix estimation.
      * This is only used when general scenes are allowed.
      *
      * @return true if inliers must be kept during robust fundamental matrix estimation,
      * false otherwise.
      */
     public boolean getFundamentalMatrixComputeAndKeepInliers() {
         return fundamentalMatrixComputeAndKeepInliers;
     }
 
     /**
      * Specifies whether inliers must be kept during robust fundamental matrix estimation.
      * This is only used when general scenes are allowed.
      *
      * @param fundamentalMatrixComputeAndKeepInliers true if inliers must be kept during
      *                                               robust fundamental matrix estimation, false
      *                                               otherwise.
      * @return this instance so that method can be easily chained.
      */
     public T setFundamentalMatrixComputeAndKeepInliers(final boolean fundamentalMatrixComputeAndKeepInliers) {
         this.fundamentalMatrixComputeAndKeepInliers = fundamentalMatrixComputeAndKeepInliers;
         //noinspection unchecked
         return (T) this;
     }
 
     /**
      * Indicates whether residuals must be computed and kept during robust fundamental
      * matrix estimation.
      * This is only used when general scenes are allowed.
      *
      * @return true if residuals must be computed and kept, false otherwise.
      */
     public boolean getFundamentalMatrixComputeAndKeepResiduals() {
         return fundamentalMatrixComputeAndKeepResiduals;
     }
 
     /**
      * Specifies whether residuals must be computed and kept during robust fundamental
      * matrix estimation.
      * This is only used when general scenes are allowed.
      *
      * @param fundamentalMatrixComputeAndKeepResiduals true if residuals must be
      *                                                 computed and kept, false otherwise.
      * @return this instance so that method can be easily chained.
      */
     public T setFundamentalMatrixComputeAndKeepResiduals(final boolean fundamentalMatrixComputeAndKeepResiduals) {
         this.fundamentalMatrixComputeAndKeepResiduals = fundamentalMatrixComputeAndKeepResiduals;
         //noinspection unchecked
         return (T) this;
     }
 
     /**
      * Gets method to use for initial cameras' estimation.
      *
      * @return method to use for initial cameras' estimation.
      */
     public InitialCamerasEstimatorMethod getInitialCamerasEstimatorMethod() {
         return initialCamerasEstimatorMethod;
     }
 
     /**
      * Sets method to use for initial cameras' estimation.
      *
      * @param method method to use for initial cameras' estimation.
      * @return this instance so that method can be easily chained.
      */
     public T setInitialCamerasEstimatorMethod(final InitialCamerasEstimatorMethod method) {
         initialCamerasEstimatorMethod = method;
         //noinspection unchecked
         return (T) this;
     }
 
     /**
      * Indicates whether an homogeneous point triangulator is used for point triangulation
      * when Dual Absolute Quadric (DAQ) camera initialization is used.
      *
      * @return true if homogeneous point triangulator is used, false if an inhomogeneous
      * point triangulator is used instead.
      */
     public boolean getDaqUseHomogeneousPointTriangulator() {
         return daqUseHomogeneousPointTriangulator;
     }
 
     /**
      * Specifies whether an homogeneous point triangulator is used for point
      * triangulation when Dual Absolute Quadric (DAQ) camera initialization is used.
      *
      * @param daqUseHomogeneousPointTriangulator true if homogeneous point triangulator
      *                                           is used, false if inhomogeneous point
      *                                           triangulator is used instead.
      * @return this instance so that method can be easily chained.
      */
     public T setDaqUseHomogeneousPointTriangulator(final boolean daqUseHomogeneousPointTriangulator) {
         this.daqUseHomogeneousPointTriangulator = daqUseHomogeneousPointTriangulator;
         //noinspection unchecked
         return (T) this;
     }
 
     /**
      * Gets aspect ratio for initial cameras estimation using DAQ or DIAC methods.
      *
      * @return aspect ratio for initial cameras using DAQ or DIAC methods.
      */
     public double getInitialCamerasAspectRatio() {
         return initialCamerasAspectRatio;
     }
 
     /**
      * Sets aspect ratio for initial cameras using DAQ or DIAC methods.
      *
      * @param initialCamerasAspectRatio aspect ratio for initial cameras using DAQ or DIAC
      *                                  methods.
      * @return this instance so that method can be easily chained.
      */
     public T setInitialCamerasAspectRatio(final double initialCamerasAspectRatio) {
         this.initialCamerasAspectRatio = initialCamerasAspectRatio;
         //noinspection unchecked
         return (T) this;
     }
 
     /**
      * Gets horizontal principal point value to use for initial cameras estimation
      * using DIAC or DAQ methods.
      *
      * @return horizontal principal point value to use for initial cameras estimation
      * using DIAC or DAQ methods.
      */
     public double getPrincipalPointX() {
         return principalPointX;
     }
 
     /**
      * Sets horizontal principal point value to use for initial cameras estimation
      * using DIAC or DAQ methods.
      *
      * @param principalPointX horizontal principal point value to use for initial
      *                        cameras estimation using DIAC or DAQ methods.
      * @return this instance so that method can be easily chained.
      */
     public T setPrincipalPointX(final double principalPointX) {
         this.principalPointX = principalPointX;
         //noinspection unchecked
         return (T) this;
     }
 
     /**
      * Gets vertical principal point value to use for initial cameras estimation
      * using DIAC or DAQ methods.
      *
      * @return vertical principal point value to use for initial cameras
      * estimation using DIAC or DAQ methods.
      */
     public double getPrincipalPointY() {
         return principalPointY;
     }
 
     /**
      * Sets vertical principal point value to use for initial cameras estimation using
      * DIAC or DAQ methods.
      *
      * @param principalPointY vertical principal point value to use for initial cameras
      *                        estimation using DIAC or DAQ methods.
      * @return this instance so that method can be easily chained.
      */
     public T setPrincipalPointY(final double principalPointY) {
         this.principalPointY = principalPointY;
         //noinspection unchecked
         return (T) this;
     }
 
     /**
      * Gets corrector type to use for point triangulation when initial cameras are being
      * estimated using either DIAC or essential matrix methods or null if no corrector is
      * used.
      *
      * @return corrector type to use for point triangulation when initial cameras are
      * being estimated using either DIAC or essential matrix methods or null if no
      * corrector is used.
      */
     public CorrectorType getInitialCamerasCorrectorType() {
         return initialCamerasCorrectorType;
     }
 
     /**
      * Sets corrector type to use for point triangulation when initial cameras are being
      * estimated using either DIAC or essential matrix methods or null if no corrector
      * is used.
      *
      * @param type corrector type to use for point triangulation when initial cameras
      *             are being estimated using either DIAC or essential matrix methods
      *             or null if no corrector is used.
      * @return this instance so that method can be easily chained.
      */
     public T setInitialCamerasCorrectorType(final CorrectorType type) {
         initialCamerasCorrectorType = type;
         //noinspection unchecked
         return (T) this;
     }
 
     /**
      * Gets value indicating whether valid triangulated points are marked during initial
      * cameras estimation using either DIAC or essential matrix methods.
      *
      * @return value indicating whether valid triangulated points are marked during
      * initial cameras estimation using either DIAC or essential matrix methods.
      */
     public boolean getInitialCamerasMarkValidTriangulatedPoints() {
         return initialCamerasMarkValidTriangulatedPoints;
     }
 
     /**
      * Sets value indicating whether valid triangulated points are marked during initial
      * cameras estimation using either DIAC or essential matrix methods.
      *
      * @param initialCamerasMarkValidTriangulatedPoints value indicating whether valid
      *                                                  triangulated points are marked during
      *                                                  initial cameras estimation using
      *                                                  either DIAC or essential matrix
      *                                                  methods.
      * @return this instance so that method can be easily chained.
      */
     public T setInitialCamerasMarkValidTriangulatedPoints(final boolean initialCamerasMarkValidTriangulatedPoints) {
         this.initialCamerasMarkValidTriangulatedPoints = initialCamerasMarkValidTriangulatedPoints;
         //noinspection unchecked
         return (T) this;
     }
 
     /**
      * Intrinsic parameters of first camera estimated using the essential matrix method.
      *
      * @return parameters of first camera estimated using the essential matrix method.
      */
     public PinholeCameraIntrinsicParameters getInitialIntrinsic1() {
         return initialIntrinsic1;
     }
 
     /**
      * Sets intrinsic parameters of first camera estimated using the essential matrix
      * method.
      *
      * @param initialIntrinsic1 parameters of first camera estimated using the essential
      *                          matrix method.
      * @return this instance so that method can be easily chained.
      */
     public T setInitialIntrinsic1(final PinholeCameraIntrinsicParameters initialIntrinsic1) {
         this.initialIntrinsic1 = initialIntrinsic1;
         //noinspection unchecked
         return (T) this;
     }
 
     /**
      * Intrinsic parameters of second camera estimated using the essential matrix method.
      *
      * @return parameters of second camera estimated using the essential matrix method.
      */
     public PinholeCameraIntrinsicParameters getInitialIntrinsic2() {
         return initialIntrinsic2;
     }
 
     /**
      * Sets intrinsic parameters of second camera estimated using the essential matrix
      * method.
      *
      * @param initialIntrinsic2 parameters of second camera estimated using the essential
      *                          matrix method.
      * @return this instance so that method can be easily chained.
      */
     public T setInitialIntrinsic2(final PinholeCameraIntrinsicParameters initialIntrinsic2) {
         this.initialIntrinsic2 = initialIntrinsic2;
         //noinspection unchecked
         return (T) this;
     }
 
     /**
      * Indicates whether a general scene (points laying in a general 3D position) is
      * allowed.
      * When true, an initial geometry estimation is attempted for general points.
      *
      * @return true if general scene is allowed, false otherwise.
      */
     public boolean isGeneralSceneAllowed() {
         return allowGeneralScene;
     }
 
     /**
      * Specifies whether a general scene (points laying in a general 3D position) is
      * allowed.
      * When true, an initial geometry estimation is attempted for general points.
      *
      * @param allowGeneralScene true if general scene is allowed, false otherwise.
      * @return this instance so that method can be easily chained.
      */
     public T setGeneralSceneAllowed(final boolean allowGeneralScene) {
         this.allowGeneralScene = allowGeneralScene;
         //noinspection unchecked
         return (T) this;
     }
 
     /**
      * Indicates whether a planar scene (points laying in a 3D plane) is allowed or not.
      * When true, an initial geometry estimation is attempted for planar points.
      *
      * @return true if planar scene is allowed, false otherwise.
      */
     public boolean isPlanarSceneAllowed() {
         return allowPlanarScene;
     }
 
     /**
      * Specifies whether a planar scene (points laying in a 3D plane) is allowed or not.
      * When true, an initial geometry estimation is attempted for planar points.
      *
      * @param allowPlanarScene true if planar scene is allowed, false otherwise.
      * @return this instance so that method can be easily chained.
      */
     public T setPlanarSceneAllowed(final boolean allowPlanarScene) {
         this.allowPlanarScene = allowPlanarScene;
         //noinspection unchecked
         return (T) this;
     }
 
     /**
      * Gets robust method to use for planar homography estimation.
      * This is only used when planar scenes are allowed.
      *
      * @return robust method to use for planar homography estimation.
      */
     public RobustEstimatorMethod getRobustPlanarHomographyEstimatorMethod() {
         return robustPlanarHomographyEstimatorMethod;
     }
 
     /**
      * Sets robust method to use for planar homography estimation.
      * This is only used when planar scenes are allowed.
      *
      * @param robustPlanarHomographyEstimatorMethod robust method to use for planar
      *                                              homography estimation.
      * @return this instance so that method can be easily chained.
      */
     public T setRobustPlanarHomographyEstimatorMethod(
             final RobustEstimatorMethod robustPlanarHomographyEstimatorMethod) {
         this.robustPlanarHomographyEstimatorMethod = robustPlanarHomographyEstimatorMethod;
         //noinspection unchecked
         return (T) this;
     }
 
     /**
      * Indicates whether planar homography is refined using all found inliers or not.
      * This is only used when planar scenes are allowed.
      *
      * @return true if planar homography is refined, false otherwise.
      */
     public boolean isPlanarHomographyRefined() {
         return refinePlanarHomography;
     }
 
     /**
      * Specifies whether planar homography is refined using all found inliers or not.
      * This is only used when planar scenes are allowed.
      *
      * @param refinePlanarHomography true if planar homography must be refined, false
      *                               otherwise.
      * @return this instance so that method can be easily chained.
      */
     public T setPlanarHomographyRefined(final boolean refinePlanarHomography) {
         this.refinePlanarHomography = refinePlanarHomography;
         //noinspection unchecked
         return (T) this;
     }
 
     /**
      * Indicates whether planar homography covariance is kept after estimation.
      * This is only used when planar scenes are allowed.
      *
      * @return true if planar homography covariance is kept, false otherwise.
      */
     public boolean isPlanarHomographyCovarianceKept() {
         return keepPlanarHomographyCovariance;
     }
 
     /**
      * Specifies whether planar homography covariance is kept after estimation.
      * This is only used when planar scenes are allowed.
      *
      * @param keepPlanarHomographyCovariance true if planar homography covariance is
      *                                       kept, false otherwise.
      * @return this instance so that method can be easily chained.
      */
     public T setPlanarHomographyCovarianceKept(final boolean keepPlanarHomographyCovariance) {
         this.keepPlanarHomographyCovariance = keepPlanarHomographyCovariance;
         //noinspection unchecked
         return (T) this;
     }
 
     /**
      * Gets confidence of robustly estimated planar homography. By default, this is 99%.
      * This is only used when planar scenes are allowed.
      *
      * @return confidence of robustly estimated planar homography.
      */
     public double getPlanarHomographyConfidence() {
         return planarHomographyConfidence;
     }
 
     /**
      * Sets confidence of robustly estimated planar homography. By default, this is 99%.
      * This is only used when planar scenes are allowed.
      *
      * @param planarHomographyConfidence confidence of robustly estimated planar
      *                                   homography.
      * @return this instance so that method can be easily chained.
      */
     public T setPlanarHomographyConfidence(final double planarHomographyConfidence) {
         this.planarHomographyConfidence = planarHomographyConfidence;
         //noinspection unchecked
         return (T) this;
     }
 
     /**
      * Gets maximum number of iterations to make while robustly estimating planar
      * homography. By default, this is 5000.
      * This is only used when planar scenes are allowed.
      *
      * @return maximum number of iterations to make while robustly estimating planar
      * homography.
      */
     public int getPlanarHomographyMaxIterations() {
         return planarHomographyMaxIterations;
     }
 
     /**
      * Sets maximum number of iterations to make while robustly estimating planar
      * homography. By default, this is 5000.
      * This is only used when planar scenes are allowed.
      *
      * @param planarHomographyMaxIterations maximum number of iterations to make while
      *                                      robustly estimating planar homography.
      * @return this instance so that method can be easily chained.
      */
     public T setPlanarHomographyMaxIterations(final int planarHomographyMaxIterations) {
         this.planarHomographyMaxIterations = planarHomographyMaxIterations;
         //noinspection unchecked
         return (T) this;
     }
 
     /**
      * Gets threshold to determine whether samples for robust projective 2D
      * transformation estimation are inliers or not.
      * This is only used when planar scenes are allowed.
      *
      * @return threshold to robustly estimate projective 2D transformation.
      */
     public double getPlanarHomographyThreshold() {
         return planarHomographyThreshold;
     }
 
     /**
      * Sets threshold to determine whether samples for robust projective 2D
      * transformation estimation are inliers or not.
      * This is only used when planar scenes are allowed.
      *
      * @param planarHomographyThreshold threshold to robustly estimate projective 2D
      *                                  transformation.
      * @return this instance so that method can be easily chained.
      */
     public T setPlanarHomographyThreshold(final double planarHomographyThreshold) {
         this.planarHomographyThreshold = planarHomographyThreshold;
         //noinspection unchecked
         return (T) this;
     }
 
     /**
      * Gets value indicating that inlier data is kept after robust planar homography
      * estimation.
      * This is only used when planar scenes are allowed.
      *
      * @return true if inlier data is kept, false otherwise.
      */
     public boolean getPlanarHomographyComputeAndKeepInliers() {
         return planarHomographyComputeAndKeepInliers;
     }
 
     /**
      * Specifies whether inlier data is kept after robust planar homography estimation.
      * This is only used when planar scenes are allowed.
      *
      * @param planarHomographyComputeAndKeepInliers true if inlier data is kept, false
      *                                              otherwise.
      * @return this instance so that method can be easily chained.
      */
     public T setPlanarHomographyComputeAndKeepInliers(final boolean planarHomographyComputeAndKeepInliers) {
         this.planarHomographyComputeAndKeepInliers = planarHomographyComputeAndKeepInliers;
         //noinspection unchecked
         return (T) this;
     }
 
     /**
      * Gets value indicating that residual data is kept after robust planar homography
      * estimation.
      * This is only used when planar scenes are allowed.
      *
      * @return true if residual data is kept, false otherwise.
      */
     public boolean getPlanarHomographyComputeAndKeepResiduals() {
         return planarHomographyComputeAndKeepResiduals;
     }
 
     /**
      * Sets value indicating that residual data is kept after robust planar homography
      * estimation.
      * This is only used when planar scenes are allowed.
      *
      * @param planarHomographyComputeAndKeepResiduals true if residual data is kept,
      *                                                false otherwise.
      * @return this instance so that method can be easily chained.
      */
     public T setPlanarHomographyComputeAndKeepResiduals(final boolean planarHomographyComputeAndKeepResiduals) {
         this.planarHomographyComputeAndKeepResiduals = planarHomographyComputeAndKeepResiduals;
         //noinspection unchecked
         return (T) this;
     }
 
     /**
      * Indicates that additional cameras intrinsics are estimated using the Dual Absolute
      * Quadric (DAQ).
      *
      * @return true if additional cameras intrinsics are estimated using the Dual Absolute
      * Quadric (DAQ), false otherwise.
      */
     public boolean getUseDAQForAdditionalCamerasIntrinsics() {
         return useDAQForAdditionalCamerasIntrinsics;
     }
 
     /**
      * Specifies whether additional cameras intrinsics are estimated using the Dual Absolute
      * Quadric (DAQ).
      *
      * @param useDAQForAdditionalCamerasIntrinics true if additional cameras intrinsics
      *                                            are estimated using the Dual Absolute
      *                                            Quadric (DAQ), false otherwise.
      * @return this instance so that method can be easily chained.
      */
     public T setUseDAQForAdditionalCamerasIntrinics(final boolean useDAQForAdditionalCamerasIntrinics) {
         useDAQForAdditionalCamerasIntrinsics = useDAQForAdditionalCamerasIntrinics;
         //noinspection unchecked
         return (T) this;
     }
 
     /**
      * Indicates that additional cameras intrinsics are estimated using the Dual Image of Absolute
      * Conic (DIAC).
      *
      * @return true if additional cameras intrinsics are estimated using the Dual Image of Absolute Conic
      * (DIAC), false otherwise.
      */
     public boolean getUseDIACForAdditionalCamerasIntrinsics() {
         return useDIACForAdditionalCamerasIntrinsics;
     }
 
     /**
      * Specifies whether additional cameras intrinsics are estimated using the Dual Image of
      * Absolute Conic (DIAC).
      * It is not recommended to enable this setting as it has low accuracy.
      *
      * @param useDIACForAdditionalCamerasIntrinsics true if additional cameras intrinsics are
      *                                              estimated using the Dual Image of Absolute
      *                                              Conic (DIAC), false otherwise.
      * @return this instance so that method can be easily chained.
      */
     public T setUseDIACForAdditionalCamerasIntrinsics(final boolean useDIACForAdditionalCamerasIntrinsics) {
         this.useDIACForAdditionalCamerasIntrinsics = useDIACForAdditionalCamerasIntrinsics;
         //noinspection unchecked
         return (T) this;
     }
 
     /**
      * Gets intrinsic parameters to use for additional cameras estimation when neither
      * Dual Image of Absolute Conic (DIAC) nor Dual Absolute Quadric (DAQ) are used for
      * estimation of intrinsic parameters.
      *
      * @return intrinsic parameters to use for additional estimation of cameras.
      */
     public PinholeCameraIntrinsicParameters getAdditionalCamerasIntrinsics() {
         return additionalCamerasIntrinsics;
     }
 
     /**
      * Sets intrinsic parameters to use for additional cameras estimation when neither
      * Dual Image of Absolute Conic (DIAC) nor Dual Absolute Quadric (DAQ) are used for
      * estimation of intrinsic parameters.
      *
      * @param additionalCamerasIntrinsics intrinsic parameters to use for additional
      *                                    estimation of cameras.
      * @return this instance so that method can be easily chained.
      */
     public T setAdditionalCamerasIntrinsics(final PinholeCameraIntrinsicParameters additionalCamerasIntrinsics) {
         this.additionalCamerasIntrinsics = additionalCamerasIntrinsics;
         //noinspection unchecked
         return (T) this;
     }
 
     /**
      * Gets skewness for additional cameras when UPnP (Uncalibrated Perspective-n-Point)
      * method is used for additional estimation of cameras.
      *
      * @return skewness for additional cameras when UPnP method is used for additional
      * estimation of cameras.
      */
     public double getAdditionalCamerasSkewness() {
         return additionalCamerasSkewness;
     }
 
     /**
      * Sets skewness for additional cameras when UPnP (Uncalibrated Perspective-n-Point)
      * method is used for additional estimation of cameras.
      *
      * @param additionalCamerasSkewness skewness for additional cameras when UPnP method is
      *                                  used for additional estimation of cameras.
      * @return this instance so that method can be easily chained.
      */
     public T setAdditionalCamerasSkewness(final double additionalCamerasSkewness) {
         this.additionalCamerasSkewness = additionalCamerasSkewness;
         //noinspection unchecked
         return (T) this;
     }
 
     /**
      * Gets horizontal coordinate of principal point for additional cameras when UPnP
      * (Uncalibrated Perspective-n-Point) method is used for additional cameras
      * estimation and neither Dual Image of Absolute Conic (DIAC) or Dual Absolute
      * Quadric (DAQ) are estimated to find intrinsic parameters when adding new cameras.
      *
      * @return horizontal coordinate of principal point for additional cameras when
      * UPnP method is used for additional cameras estimation and neither DIAC nor DAQ
      * are estimated to find intrinsic parameters when adding new cameras.
      */
     public double getAdditionalCamerasHorizontalPrincipalPoint() {
         return additionalCamerasHorizontalPrincipalPoint;
     }
 
     /**
      * Sets horizontal coordinate of principal point for additional cameras when UPnP
      * (Uncalibrated Perspective-n-Point) method is used for additional cameras estimation
      * and neither Dual Image of Absolute Conic (DIAC) or Dual Absolute Quadric (DAQ) are
      * estimated to find intrinsic parameters when adding new cameras.
      *
      * @param additionalCamerasHorizontalPrincipalPoint horizontal coordinate of principal point
      *                                                  for additional cameras when UPnP method is
      *                                                  used for additional cameras estimation and
      *                                                  neither DIAC nor DAQ are estimated to find
      *                                                  intrinsic parameters when adding new cameras.
      * @return this instance so that method can be easily chained.
      */
     public T setAdditionalCamerasHorizontalPrincipalPoint(final double additionalCamerasHorizontalPrincipalPoint) {
         this.additionalCamerasHorizontalPrincipalPoint = additionalCamerasHorizontalPrincipalPoint;
         //noinspection unchecked
         return (T) this;
     }
 
     /**
      * Gets vertical coordinate of principal point for additional cameras when UPnP
      * (Uncalibrated Perspective-n-Point) method is used for additional cameras estimation
      * and neither Dual Image of Absolute Conic (DIAC) or Dual Absolute Quadric (DAQ) are
      * estimated to find intrinsic parameters when adding new cameras.
      *
      * @return vertical coordinate of principal point for additional cameras when UPnP
      * method is used for additional cameras estimation and neither DIAC nor DAQ are
      * estimated to find intrinsic parameters when adding new cameras.
      */
     public double getAdditionalCamerasVerticalPrincipalPoint() {
         return additionalCamerasVerticalPrincipalPoint;
     }
 
     /**
      * Sets vertical coordinate of principal point for additional cameras when UPnP
      * (Uncalibrated Perspective-n-Point) method is used for additional cameras
      * estimation and neither Dual Image of Absolute Conic (DIAC) or Dual Absolute Quadric
      * (DAQ) are estimated to find intrinsic parameters when adding new cameras.
      *
      * @param additionalCamerasVerticalPrincipalPoint vertical coordinate of principal
      *                                                point for additional cameras when UPnP
      *                                                method is used for additional cameras
      *                                                estimation and neither DIAC nor DAQ
      *                                                are estimated to find intrinsic
      *                                                parameters when adding new cameras.
      * @return this instance so that method can be easily chained.
      */
     public T setAdditionalCamerasVerticalPrincipalPoint(final double additionalCamerasVerticalPrincipalPoint) {
         this.additionalCamerasVerticalPrincipalPoint = additionalCamerasVerticalPrincipalPoint;
         //noinspection unchecked
         return (T) this;
     }
 
     /**
      * Gets aspect ratio for additional cameras estimation using DAQ or DIAC methods.
      *
      * @return aspect ratio for additional cameras using DAQ or DIAC methods.
      */
     public double getAdditionalCamerasAspectRatio() {
         return additionalCamerasAspectRatio;
     }
 
     /**
      * Sets aspect ratio for additional cameras using DAQ or DIAC methods.
      *
      * @param additionalCamerasAspectRatio aspect ratio for additional cameras using DAQ or DIAC
      *                                     methods.
      * @return this instance so that method can be easily chained.
      */
     public T setAdditionalCamerasAspectRatio(final double additionalCamerasAspectRatio) {
         this.additionalCamerasAspectRatio = additionalCamerasAspectRatio;
         //noinspection unchecked
         return (T) this;
     }
 
     /**
      * Indicates whether EPnP (Efficient Perspective-n-Point) method is used for additional
      * estimation of cameras. Either EPnP or UPnP must be used for additional estimation
      * of cameras.
      *
      * @return true if EPnP method is used for additional cameras estimation, false
      * otherwise.
      */
     public boolean getUseEPnPForAdditionalCamerasEstimation() {
         return useEPnPForAdditionalCamerasEstimation;
     }
 
     /**
      * Specifies whether EPnP (Efficient Perspective-n-Point) method is used for additional
      * estimation of cameras. Either EPnP or UPnP must be used for additional estimation of cameras.
      *
      * @param useEPnPForAdditionalCamerasEstimation true if EPnP method is used for additional
      *                                              cameras estimation, false otherwise.
      * @return this instance so that method can be easily chained.
      */
     public T setUseEPnPForAdditionalCamerasEstimation(final boolean useEPnPForAdditionalCamerasEstimation) {
         this.useEPnPForAdditionalCamerasEstimation = useEPnPForAdditionalCamerasEstimation;
         //noinspection unchecked
         return (T) this;
     }
 
     /**
      * Indicates whether UPnP (Uncalibrated Perspective-n-Point) method is used for
      * additional estimation of cameras. Either EPnP or UPnP must be used for additional
      * estimation of cameras.
      *
      * @return true if UPnP method is used for additional cameras estimation, false
      * otherwise.
      */
     public boolean getUseUPnPForAdditionalCamerasEstimation() {
         return useUPnPForAdditionalCamerasEstimation;
     }
 
     /**
      * Specifies whether UPnP (Uncalibrated Perspective-n-Point) method is used for
      * additional estimation of cameras. Either EPnP or UPnP must be used for additional
      * estimation of cameras.
      *
      * @param useUPnPForAdditionalCamerasEstimation true if UPnP method is used for
      *                                              additional cameras estimation, false
      *                                              otherwise.
      * @return this instance so that method can be easily chained.
      */
     public T setUseUPnPForAdditionalCamerasEstimation(final boolean useUPnPForAdditionalCamerasEstimation) {
         this.useUPnPForAdditionalCamerasEstimation = useUPnPForAdditionalCamerasEstimation;
         //noinspection unchecked
         return (T) this;
     }
 
     /**
      * Gets robust method to estimate additional cameras.
      *
      * @return robust method to estimate additional cameras.
      */
     public RobustEstimatorMethod getAdditionalCamerasRobustEstimationMethod() {
         return additionalCamerasRobustEstimationMethod;
     }
 
     /**
      * Sets robust method to estimate additional cameras.
      *
      * @param method robust method to estimate additional cameras.
      * @return this instance so that method can be easily chained.
      */
     public T setAdditionalCamerasRobustEstimationMethod(final RobustEstimatorMethod method) {
         additionalCamerasRobustEstimationMethod = method;
         //noinspection unchecked
         return (T) this;
     }
 
     /**
      * Indicates whether planar configuration is allowed for additional cameras
      * estimation using either EPnP or UPnP.
      *
      * @return true if planar configuration is allowed, false otherwise.
      */
     public boolean getAdditionalCamerasAllowPlanarConfiguration() {
         return additionalCamerasAllowPlanarConfiguration;
     }
 
     /**
      * Specifies whether planar configuration is allowed for additional cameras
      * estimation using either EPnP or UPnP.
      *
      * @param allowPlanarConfiguration true if planar configuration is allowed, false
      *                                 otherwise.
      * @return this instance so that method can be easily chained.
      */
     public T setAdditionalCamerasAllowPlanarConfiguration(final boolean allowPlanarConfiguration) {
         additionalCamerasAllowPlanarConfiguration = allowPlanarConfiguration;
         //noinspection unchecked
         return (T) this;
     }
 
     /**
      * Indicates whether dimension 2 null-space is allowed while estimating additional
      * cameras using either EPnP or UPnP.
      *
      * @return true if dimension 2 null-space is allowed while estimating additional
      * cameras, false otherwise.
      */
     public boolean getAdditionalCamerasAllowNullspaceDimension2() {
         return additionalCamerasAllowNullspaceDimension2;
     }
 
     /**
      * Specifies whether dimension 2 null-space is allowed while estimating additional
      * cameras using either EPnP or UPnP.
      *
      * @param allowNullspaceDimension2 true if dimension 2 null-space is allowed while
      *                                 estimating additional cameras, false otherwise.
      * @return this instance so that method can be easily chained.
      */
     public T setAdditionalCamerasAllowNullspaceDimension2(final boolean allowNullspaceDimension2) {
         additionalCamerasAllowNullspaceDimension2 = allowNullspaceDimension2;
         //noinspection unchecked
         return (T) this;
     }
 
     /**
      * Indicates whether dimension 3 null-space is allowed while estimating additional
      * cameras using EPnP.
      *
      * @return true if dimension 3 null-space is allowed while estimating additional
      * cameras, false otherwise.
      */
     public boolean getAdditionalCamerasAllowNullspaceDimension3() {
         return additionalCamerasAllowNullspaceDimension3;
     }
 
     /**
      * Specifies whether dimension 3 null-space is allowed while estimating additional
      * cameras using either EPnP or UPnP.
      *
      * @param allowNullspaceDimension3 true if dimension 3 null-space is allowed while
      *                                 estimating additional cameras, false otherwise.
      * @return this instance so that method can be easily chained.
      */
     public T setAdditionalCamerasAllowNullspaceDimension3(final boolean allowNullspaceDimension3) {
         additionalCamerasAllowNullspaceDimension3 = allowNullspaceDimension3;
         //noinspection unchecked
         return (T) this;
     }
 
     /**
      * Gets threshold to determine whether 3D matched points to estimate additional
      * cameras are in a planar configuration.
      *
      * @return threshold to determine whether 3D matched points to estimate additional
      * cameras are in a planar configuration.
      */
     public double getAdditionalCamerasPlanarThreshold() {
         return additionalCamerasPlanarThreshold;
     }
 
     /**
      * Specifies threshold to determine whether 3D matched points to estimate additional
      * cameras are in a planar configuration.
      *
      * @param additionalCamerasPlanarThreshold threshold to determine whether 3D matched
      *                                         points to estimate additional cameras are
      *                                         in a planar configuration.
      * @return this instance so that method can be easily chained.
      */
     public T setAdditionalCamerasPlanarThreshold(final double additionalCamerasPlanarThreshold) {
         this.additionalCamerasPlanarThreshold = additionalCamerasPlanarThreshold;
         //noinspection unchecked
         return (T) this;
     }
 
     /**
      * Indicates whether additional cameras are refined to minimize overall projection
      * error among all found inliers.
      *
      * @return true if additional cameras are refined, false otherwise.
      */
     public boolean areAdditionalCamerasRefined() {
         return refineAdditionalCameras;
     }
 
     /**
      * Specifies whether additional cameras are refined to minimize overall projection
      * error among all found inliers.
      *
      * @param refineAdditionalCameras true if additional cameras are refined, false
      *                                otherwise.
      * @return this instance so that method can be easily chained.
      */
     public T setAdditionalCamerasRefined(final boolean refineAdditionalCameras) {
         this.refineAdditionalCameras = refineAdditionalCameras;
         //noinspection unchecked
         return (T) this;
     }
 
     /**
      * Indicates whether covariance is kept after refining result of additional
      * estimation of cameras.
      *
      * @return true if covariance is kept, false otherwise.
      */
     public boolean isAdditionalCamerasCovarianceKept() {
         return keepCovarianceAdditionalCameras;
     }
 
     /**
      * Specifies whether covariance is kept after refining result of additional estimation
      * of cameras.
      *
      * @param keepCovarianceAdditionalCameras true if covariance is kept, false otherwise.
      * @return this instance so that method can be easily chained.
      */
     public T setAdditionalCamerasCovarianceKept(final boolean keepCovarianceAdditionalCameras) {
         this.keepCovarianceAdditionalCameras = keepCovarianceAdditionalCameras;
         //noinspection unchecked
         return (T) this;
     }
 
     /**
      * Gets value indicating whether fast refinement is used for additional estimation
      * of cameras.
      *
      * @return true if fast refinement is used for additional cameras estimation,
      * false otherwise.
      */
     public boolean getAdditionalCamerasUseFastRefinement() {
         return additionalCamerasUseFastRefinement;
     }
 
     /**
      * Sets value indicating whether fast refinement is used for additional estimation
      * of cameras.
      *
      * @param additionalCamerasUseFastRefinement true if fast refinement is used for
      *                                           additional cameras estimation, false
      *                                           otherwise.
      * @return this instance so that method can be easily chained.
      */
     public T setAdditionalCamerasUseFastRefinement(final boolean additionalCamerasUseFastRefinement) {
         this.additionalCamerasUseFastRefinement = additionalCamerasUseFastRefinement;
         //noinspection unchecked
         return (T) this;
     }
 
     /**
      * Gets confidence of estimated additional cameras.
      *
      * @return confidence of estimated additional cameras.
      */
     public double getAdditionalCamerasConfidence() {
         return additionalCamerasConfidence;
     }
 
     /**
      * Sets confidence of estimated additional cameras.
      *
      * @param additionalCamerasConfidence confidence of estimated additional cameras.
      * @return this instance so that method can be easily chained.
      */
     public T setAdditionalCamerasConfidence(final double additionalCamerasConfidence) {
         this.additionalCamerasConfidence = additionalCamerasConfidence;
         //noinspection unchecked
         return (T) this;
     }
 
     /**
      * Gets maximum allowed number of iterations for additional cameras estimation.
      *
      * @return maximum allowed number of iterations for additional cameras estimation.
      */
     public int getAdditionalCamerasMaxIterations() {
         return additionalCamerasMaxIterations;
     }
 
     /**
      * Sets maximum allowed number of iterations for additional cameras estimation.
      *
      * @param additionalCamerasMaxIterations maximum allowed number of iterations for
      *                                       additional cameras estimation.
      * @return this instance so that method can be easily chained.
      */
     public T setAdditionalCamerasMaxIterations(final int additionalCamerasMaxIterations) {
         this.additionalCamerasMaxIterations = additionalCamerasMaxIterations;
         //noinspection unchecked
         return (T) this;
     }
 
     /**
      * Gets threshold to determine whether samples for robust pinhole camera estimation are inliers or not.
      *
      * @return threshold to determine whether samples for robust pinhole camera estimation are inliers or
      * not.
      */
     public double getAdditionalCamerasThreshold() {
         return additionalCamerasThreshold;
     }
 
     /**
      * Sets threshold to determine whether samples for robust pinhole camera estimation are inliers or not.
      *
      * @param additionalCamerasThreshold threshold to determine whether samples for robust pinhole camera
      *                                   estimation are inliers or not.
      * @return this instance so that method can be easily chained.
      */
     public T setAdditionalCamerasThreshold(final double additionalCamerasThreshold) {
         this.additionalCamerasThreshold = additionalCamerasThreshold;
         //noinspection unchecked
         return (T) this;
     }
 
     /**
      * Indicates whether inliers must be kept during additional camera estimation.
      *
      * @return true if inliers must be kept during additional camera estimation, false
      * otherwise.
      */
     public boolean getAdditionalCamerasComputeAndKeepInliers() {
         return additionalCamerasComputeAndKeepInliers;
     }
 
     /**
      * Specifies whether inliers must be kept during additional camera estimation.
      *
      * @param additionalCamerasComputeAndKeepInliers true if inliers must be kept during additional camera
      *                                               estimation, false otherwise.
      * @return this instance so that method can be easily chained.
      */
     public T setAdditionalCamerasComputeAndKeepInliers(final boolean additionalCamerasComputeAndKeepInliers) {
         this.additionalCamerasComputeAndKeepInliers = additionalCamerasComputeAndKeepInliers;
         //noinspection unchecked
         return (T) this;
     }
 
     /**
      * Indicates whether residuals must be computed and kept during additional camera estimation.
      *
      * @return true if residuals must be computed and kept, false otherwise.
      */
     public boolean getAdditionalCamerasComputeAndKeepResiduals() {
         return additionalCamerasComputeAndKeepResiduals;
     }
 
     /**
      * Specifies whether residuals must be computed and kept during additional camera estimation.
      *
      * @param additionalCamerasComputeAndKeepResiduals true if residuals must be computed and kept, false
      *                                                 otherwise.
      * @return this instance so that method can be easily chained.
      */
     public T setAdditionalCamerasComputeAndKeepResiduals(final boolean additionalCamerasComputeAndKeepResiduals) {
         this.additionalCamerasComputeAndKeepResiduals = additionalCamerasComputeAndKeepResiduals;
         //noinspection unchecked
         return (T) this;
     }
 
     /**
      * Gets value indicating whether skewness is not suggested during additional
      * estimation of cameras.
      *
      * @return true if skewness is suggested, false otherwise.
      */
     public boolean isAdditionalCamerasSuggestSkewnessValueEnabled() {
         return additionalCamerasSuggestSkewnessValueEnabled;
     }
 
     /**
      * Sets value indicating whether skewness is not suggested during additional
      * estimation of cameras.
      *
      * @param additionalCamerasSuggestSkewnessValueEnabled true if skewness is suggested,
      *                                                     false otherwise.
      * @return this instance so that method can be easily chained.
      */
     public T setAdditionalCamerasSuggestSkewnessValueEnabled(
             final boolean additionalCamerasSuggestSkewnessValueEnabled) {
         this.additionalCamerasSuggestSkewnessValueEnabled = additionalCamerasSuggestSkewnessValueEnabled;
         //noinspection unchecked
         return (T) this;
     }
 
     /**
      * Gets value of skewness to be suggested when suggestion is enabled during
      * additional estimation of cameras.
      *
      * @return value of skewness to be suggested when suggestion is enabled during
      * additional estimation of cameras.
      */
     public double getAdditionalCamerasSuggestedSkewnessValue() {
         return additionalCamerasSuggestedSkewnessValue;
     }
 
     /**
      * Sets value of skewness to be suggested when suggestion is enabled during additional
      * estimation of cameras.
      *
      * @param additionalCamerasSuggestedSkewnessValue value of skewness to be suggested
      *                                                when suggestion is enabled during
      *                                                additional estimation of cameras.
      * @return this instance so that method can be easily chained.
      */
     public T setAdditionalCamerasSuggestedSkewnessValue(final double additionalCamerasSuggestedSkewnessValue) {
         this.additionalCamerasSuggestedSkewnessValue = additionalCamerasSuggestedSkewnessValue;
         //noinspection unchecked
         return (T) this;
     }
 
     /**
      * Indicates whether horizontal focal length value is suggested or not during
      * additional estimation of cameras.
      *
      * @return true if horizontal focal length value is suggested, false otherwise.
      */
     public boolean isAdditionalCamerasSuggestHorizontalFocalLengthEnabled() {
         return additionalCamerasSuggestHorizontalFocalLengthEnabled;
     }
 
     /**
      * Specifies whether horizontal focal length value is suggested or not during additional
      * estimation of cameras.
      *
      * @param additionalCamerasSuggestHorizontalFocalLengthEnabled true if horizontal focal
      *                                                             length value is suggested, false
      *                                                             otherwise.
      * @return this instance so that method can be easily chained.
      */
     public T setAdditionalCamerasSuggestHorizontalFocalLengthEnabled(
             final boolean additionalCamerasSuggestHorizontalFocalLengthEnabled) {
         this.additionalCamerasSuggestHorizontalFocalLengthEnabled =
                 additionalCamerasSuggestHorizontalFocalLengthEnabled;
         //noinspection unchecked
         return (T) this;
     }
 
     /**
      * Gets value of suggested horizontal focal length during additional estimation
      * of cameras.
      *
      * @return value of suggested horizontal focal length during additional estimation
      * of cameras.
      */
     public double getAdditionalCamerasSuggestedHorizontalFocalLengthValue() {
         return additionalCamerasSuggestedHorizontalFocalLengthValue;
     }
 
     /**
      * Sets value of suggested horizontal focal length during additional estimation
      * of cameras.
      *
      * @param additionalCamerasSuggestedHorizontalFocalLengthValue value of suggested
      *                                                             horizontal focal length during
      *                                                             additional estimation of cameras.
      * @return this instance so that method can be easily chained.
      */
     public T setAdditionalCamerasSuggestedHorizontalFocalLengthValue(
             final double additionalCamerasSuggestedHorizontalFocalLengthValue) {
         this.additionalCamerasSuggestedHorizontalFocalLengthValue =
                 additionalCamerasSuggestedHorizontalFocalLengthValue;
         //noinspection unchecked
         return (T) this;
     }
 
     /**
      * Gets value indicating whether vertical focal length value is suggested or not
      * during additional estimation of cameras.
      *
      * @return true if vertical focal length value is suggested, false otherwise.
      */
     public boolean isAdditionalCamerasSuggestVerticalFocalLengthEnabled() {
         return additionalCamerasSuggestVerticalFocalLengthEnabled;
     }
 
     /**
      * Sets value indicating whether vertical focal length value is suggested or not
      * during additional estimation of cameras.
      *
      * @param additionalCamerasSuggestVerticalFocalLengthEnabled true if vertical focal
      *                                                           length is suggested, false
      *                                                           otherwise.
      * @return this instance so that method can be easily chained.
      */
     public T setAdditionalCamerasSuggestVerticalFocalLengthEnabled(
             final boolean additionalCamerasSuggestVerticalFocalLengthEnabled) {
         this.additionalCamerasSuggestVerticalFocalLengthEnabled = additionalCamerasSuggestVerticalFocalLengthEnabled;
         //noinspection unchecked
         return (T) this;
     }
 
     /**
      * Gets value of suggested vertical focal length during additional estimation of cameras.
      *
      * @return value of suggested vertical focal length during additional estimation of cameras.
      */
     public double getAdditionalCamerasSuggestedVerticalFocalLengthValue() {
         return additionalCamerasSuggestedVerticalFocalLengthValue;
     }
 
     /**
      * Sets value of suggested vertical focal length during additional estimation of cameras.
      *
      * @param additionalCamerasSuggestedVerticalFocalLengthValue value of suggested vertical
      *                                                           focal length during additional
      *                                                           estimation of cameras.
      * @return this instance so that method can be easily chained.
      */
     public T setAdditionalCamerasSuggestedVerticalFocalLengthValue(
             final double additionalCamerasSuggestedVerticalFocalLengthValue) {
         this.additionalCamerasSuggestedVerticalFocalLengthValue = additionalCamerasSuggestedVerticalFocalLengthValue;
         //noinspection unchecked
         return (T) this;
     }
 
     /**
      * Gets value indicating whether aspect ratio is suggested or not during additional
      * estimation of cameras.
      *
      * @return true if aspect ratio is suggested, false otherwise.
      */
     public boolean isAdditionalCamerasSuggestAspectRatioEnabled() {
         return additionalCamerasSuggestAspectRatioEnabled;
     }
 
     /**
      * Sets value indicating whether aspect ratio is suggested or not during additional
      * estimation of cameras.
      *
      * @param additionalCamerasSuggestAspectRatioEnabled true if aspect ratio is suggested,
      *                                                   false otherwise.
      * @return this instance so that method can be easily chained.
      */
     public T setAdditionalCamerasSuggestAspectRatioEnabled(final boolean additionalCamerasSuggestAspectRatioEnabled) {
         this.additionalCamerasSuggestAspectRatioEnabled = additionalCamerasSuggestAspectRatioEnabled;
         //noinspection unchecked
         return (T) this;
     }
 
     /**
      * Gets value of aspect ratio to be suggested when suggestion is enabled during
      * additional estimation of cameras.
      *
      * @return value of aspect ratio to be suggested.
      */
     public double getAdditionalCamerasSuggestedAspectRatioValue() {
         return additionalCamerasSuggestedAspectRatioValue;
     }
 
     /**
      * Sets value of aspect ratio to be suggested when suggestion is enabled during
      * additional estimation of cameras.
      *
      * @param additionalCamerasSuggestedAspectRatioValue value of aspect ratio to be
      *                                                   suggested.
      * @return this instance so that method can be easily chained.
      */
     public T setAdditionalCamerasSuggestedAspectRatioValue(final double additionalCamerasSuggestedAspectRatioValue) {
         this.additionalCamerasSuggestedAspectRatioValue = additionalCamerasSuggestedAspectRatioValue;
         //noinspection unchecked
         return (T) this;
     }
 
     /**
      * Gets value indicating whether principal point is suggested or not during
      * additional estimation of cameras.
      *
      * @return true if principal point is suggested, false otherwise.
      */
     public boolean isAdditionalCamerasSuggestPrincipalPointEnabled() {
         return additionalCamerasSuggestPrincipalPointEnabled;
     }
 
     /**
      * Sets value indicating whether principal point is suggested or not during additional
      * estimation of cameras.
      *
      * @param additionalCamerasSuggestPrincipalPointEnabled true if principal point is
      *                                                      suggested, false otherwise.
      * @return this instance so that method can be easily chained.
      */
     public T setAdditionalCamerasSuggestPrincipalPointEnabled(
             final boolean additionalCamerasSuggestPrincipalPointEnabled) {
         this.additionalCamerasSuggestPrincipalPointEnabled = additionalCamerasSuggestPrincipalPointEnabled;
         //noinspection unchecked
         return (T) this;
     }
 
     /**
      * Gets value of principal point to be suggested when suggestion is enabled during
      * additional estimation of cameras.
      *
      * @return principal point to be suggested.
      */
     public InhomogeneousPoint2D getAdditionalCamerasSuggestedPrincipalPointValue() {
         return additionalCamerasSuggestedPrincipalPointValue;
     }
 
     /**
      * Sets value of principal point to be suggested when suggestion is enabled during
      * additional estimation of cameras.
      *
      * @param additionalCamerasSuggestedPrincipalPointValue principal point to be
      *                                                      suggested.
      * @return this instance so that method can be easily chained.
      */
     public T setAdditionalCamerasSuggestedPrincipalPointValue(
             final InhomogeneousPoint2D additionalCamerasSuggestedPrincipalPointValue) {
         this.additionalCamerasSuggestedPrincipalPointValue = additionalCamerasSuggestedPrincipalPointValue;
         //noinspection unchecked
         return (T) this;
     }
 
     /**
      * Indicates whether homogeneous point triangulator must be used or not to estimate
      * 3D points when only two matches are available.
      *
      * @return true if homogeneous point triangulator must be used, false otherwise.
      */
     public boolean isHomogeneousPointTriangulatorUsed() {
         return useHomogeneousPointTriangulator;
     }
 
     /**
      * Specifies whether homogeneous point triangulator must be used or not to estimate
      * 3D points when only two matches are available.
      *
      * @param useHomogeneousPointTriangulator true if homogeneous point triangulator must
      *                                        be used, false otherwise.
      * @return this instance so that method can be easily chained.
      */
     public T setHomogeneousPointTriangulatorUsed(final boolean useHomogeneousPointTriangulator) {
         this.useHomogeneousPointTriangulator = useHomogeneousPointTriangulator;
         //noinspection unchecked
         return (T) this;
     }
 
     /**
      * Gets robust method for point triangulation when points are matched in more
      * than two views.
      *
      * @return robust method for point triangulation.
      */
     public RobustEstimatorMethod getRobustPointTriangulatorMethod() {
         return robustPointTriangulatorMethod;
     }
 
     /**
      * Sets robust method for point triangulation when points are matched in more
      * than two views.
      *
      * @param robustPointTriangulatorMethod robust method for point triangulation.
      * @return this instance so that method can be easily chained.
      */
     public T setRobustPointTriangulatorMethod(final RobustEstimatorMethod robustPointTriangulatorMethod) {
         this.robustPointTriangulatorMethod = robustPointTriangulatorMethod;
         //noinspection unchecked
         return (T) this;
     }
 
     /**
      * Gets confidence of robustly triangulated points. By default, this is 99%.
      *
      * @return confidence of robustly triangulated points.
      */
     public double getPointTriangulatorConfidence() {
         return pointTriangulatorConfidence;
     }
 
     /**
      * Sets confidence of robustly triangulated points. By default, this is 99%.
      *
      * @param pointTriangulatorConfidence confidence of robustly triangulated points.
      * @return this instance so that method can be easily chained.
      */
     public T setPointTriangulatorConfidence(final double pointTriangulatorConfidence) {
         this.pointTriangulatorConfidence = pointTriangulatorConfidence;
         //noinspection unchecked
         return (T) this;
     }
 
     /**
      * Gets maximum number of iterations to make while robustly estimating triangulated
      * points. By default, this is 5000 iterations.
      *
      * @return maximum number of iterations to make while robustly estimating
      * triangulated points.
      */
     public int getPointTriangulatorMaxIterations() {
         return pointTriangulatorMaxIterations;
     }
 
     /**
      * Sets maximum number of iterations to make while robustly estimating triangulated
      * points. By default, this is 5000 iterations.
      *
      * @param pointTriangulatorMaxIterations maximum number of iterations to make while
      *                                       robustly estimating triangulated points.
      * @return this instance so that method can be easily chained.
      */
     public T setPointTriangulatorMaxIterations(final int pointTriangulatorMaxIterations) {
         this.pointTriangulatorMaxIterations = pointTriangulatorMaxIterations;
         //noinspection unchecked
         return (T) this;
     }
 
     /**
      * Gets threshold to determine whether samples for robust point triangulator are
      * inliers or not.
      *
      * @return threshold to determine whether samples for robust point triangulator
      * are inliers or not.
      */
     public double getPointTriangulatorThreshold() {
         return pointTriangulatorThreshold;
     }
 
     /**
      * Sets threshold to determine whether samples for robust point triangulator are
      * inliers or not.
      *
      * @param pointTriangulatorThreshold threshold to determine whether samples for
      *                                   robust point triangulator are inliers or not.
      * @return this instance so that method can be easily chained.
      */
     public T setPointTriangulatorThreshold(final double pointTriangulatorThreshold) {
         this.pointTriangulatorThreshold = pointTriangulatorThreshold;
         //noinspection unchecked
         return (T) this;
     }
 }