4pcs.h

// Copyright 2012 Dror Aiger
//
// 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.
//
// -------------------------------------------------------------------------- //
//
// Authors: Dror Aiger, Yoni Weill
//
// An implementation of the 4-points Congruent Sets (4PCS) algorithm presented
// in:
//
// 4-points Congruent Sets for Robust Surface Registration
// Dror Aiger, Niloy J. Mitra, Daniel Cohen-Or
// ACM SIGGRAPH 2008 and ACM Transaction of Graphics.
//
// Given two sets of points in 3-space, P and Q, the algorithm applies RANSAC
// in roughly O(n^2) time instead of O(n^3) for standard RANSAC, using an
// efficient method based on invariants, to find the set of all 4-points in Q
// that can be matched by rigid transformation to a given set of 4-points in P
// called a base. This avoids the need to examine all sets of 3-points in Q
// against any base of 3-points in P as in standard RANSAC.
// The algorithm can use colors and normals to speed-up the matching
// and to improve the quality. It can be easily extended to affine/similarity
// transformation but then the speed-up is smaller because of the large number
// of congruent sets. The algorithm can also limit the range of transformations
// when the application knows something on the initial pose but this is not
// necessary in general (though can speed the runtime significantly).

// Home page of the 4PCS project (containing the paper, presentations and a
// demo): http://graphics.stanford.edu/~niloy/research/fpcs/fpcs_sig_08.html
// Use google search on "4-points congruent sets" to see many related papers
// and applications.

#ifndef _SUPER4PCS_ALGO_4PCS_H_
#define _SUPER4PCS_ALGO_4PCS_H_

#include "super4pcs/algorithms/match4pcsBase.h"

namespace GlobalRegistration {

class Match4PCS : public Match4PCSBase {
public:
    using Base        = Match4PCSBase;
    using Scalar      = typename Base::Scalar;
    using PairsVector = typename Base::PairsVector;
    using VectorType  = typename Base::VectorType;

    explicit Match4PCS(const Match4PCSOptions& options,
                       const Utils::Logger logger);

  EIGEN_MAKE_ALIGNED_OPERATOR_NEW

    ~Match4PCS();

protected:
    void
    ExtractPairs(
            Scalar pair_distance,
            Scalar pair_normals_angle,
            Scalar pair_distance_epsilon, int base_point1,
            int base_point2,
            PairsVector* pairs) const override;

    bool FindCongruentQuadrilaterals(
            Scalar invariant1,
            Scalar invariant2,
            Scalar distance_threshold1,
            Scalar distance_threshold2,
            const PairsVector& P_pairs,
            const PairsVector& Q_pairs,
            std::vector<Quadrilateral>* quadrilaterals) const override;

    void Initialize(const std::vector<Point3D>& P,
                    const std::vector<Point3D>& Q) override;
};
} 

#endif