#include pclregistrationsample_consensus_initial_alignmenth帮我写这个完整的头文件

#ifndef PCL_REGISTRATION_SAMPLE_CONSENSUS_INITIAL_ALIGNMENT_H #define PCL_REGISTRATION_SAMPLE_CONSENSUS_INITIAL_ALIGNMENT_H

#include <pcl/registration/registration.h> #include <pcl/registration/correspondence_estimation.h> #include <pcl/registration/correspondence_rejection.h> #include <pcl/registration/transformation_estimation.h> #include <pcl/registration/transformation_estimation_svd.h> #include <pcl/registration/transformation_estimation_lm.h> #include <pcl/registration/transformation_estimation_point_to_plane.h> #include <pcl/registration/correspondence_rejection_trimmed.h> #include <pcl/registration/correspondence_rejection_surface_normal.h> #include <pcl/registration/correspondence_rejection_one_to_one.h>

namespace pcl { template<typename PointSource, typename PointTarget, typename Scalar = float> class SampleConsensusInitialAlignment : public Registration<PointSource, PointTarget, Scalar> { public: using Ptr = shared_ptr<SampleConsensusInitialAlignment<PointSource, PointTarget, Scalar> >; using ConstPtr = shared_ptr<const SampleConsensusInitialAlignment<PointSource, PointTarget, Scalar> >;

  using PointCloudSource = typename Registration<PointSource, PointTarget, Scalar>::PointCloudSource;
  using PointCloudSourcePtr = typename PointCloudSource::Ptr;
  using PointCloudSourceConstPtr = typename PointCloudSource::ConstPtr;

  using PointCloudTarget = typename Registration<PointSource, PointTarget, Scalar>::PointCloudTarget;
  using PointCloudTargetPtr = typename PointCloudTarget::Ptr;
  using PointCloudTargetConstPtr = typename PointCloudTarget::ConstPtr;

  using PointIndicesPtr = typename Registration<PointSource, PointTarget, Scalar>::PointIndicesPtr;
  using PointIndicesConstPtr = typename Registration<PointSource, PointTarget, Scalar>::PointIndicesConstPtr;

  using Matrix4 = typename Registration<PointSource, PointTarget, Scalar>::Matrix4;

  SampleConsensusInitialAlignment ()
    : min_sample_distance_ (0.05)
    , max_sample_distance_ (0.1)
    , nr_samples_ (3)
    , max_correspondence_distance_ (0.01)
    , nr_iterations_ (1000)
  {
    registration_name_ = "SampleConsensusInitialAlignment";
  }

  void setMinSampleDistance (double min_sample_distance) { min_sample_distance_ = min_sample_distance; }
  double getMinSampleDistance () const { return min_sample_distance_; }

  void setMaxSampleDistance (double max_sample_distance) { max_sample_distance_ = max_sample_distance; }
  double getMaxSampleDistance () const { return max_sample_distance_; }

  void setNumberOfSamples (unsigned int nr_samples) { nr_samples_ = nr_samples; }
  unsigned int getNumberOfSamples () const { return nr_samples_; }

  void setMaxCorrespondenceDistance (double max_correspondence_distance) { max_correspondence_distance_ = max_correspondence_distance; }
  double getMaxCorrespondenceDistance () const { return max_correspondence_distance_; }

  void setNumberOfIterations (unsigned int nr_iterations) { nr_iterations_ = nr_iterations; }
  unsigned int getNumberOfIterations () const { return nr_iterations_; }

  void getCorrespondences (const PointCloudSource &cloud_src,
                           const std::vector<int> &indices_src,
                           const PointCloudTarget &cloud_tgt,
                           std::vector<int> &indices_tgt,
                           std::vector<float> &dists) const;

  void selectSamples (const PointCloudSource &cloud_src,
                      const std::vector<int> &indices_src,
                      std::vector<int> &indices_tgt) const;

  bool computeTransformation (PointCloudSource &output, const Matrix4 &guess) override;

protected:
  double min_sample_distance_;
  double max_sample_distance_;
  unsigned int nr_samples_;
  double max_correspondence_distance_;
  unsigned int nr_iterations_;

}; }

#endif // PCL_REGISTRATION_SAMPLE_CONSENSUS_INITIAL_ALIGNMENT_