PythonEstimationUtils.h

Go to the documentation of this file.

// PythonEstimationUtils.h:
// ------------------------
//

#ifndef __PYIPSDKBASE_PYTHONESTIMATIONUTILS_H__
#define __PYIPSDKBASE_PYTHONESTIMATIONUTILS_H__

#include <Python/PyIPSDKBase/PyIPSDKBaseExports.h>
#include <IPSDKGeometry/Entity/2d/Point/Point2d.h>
#include <IPSDKGeometry/Entity/2d/Line/Line2d.h>
#include <IPSDKGeometry/Entity/2d/Circle/Circle2d.h>
#include <IPSDKGeometry/Entity/2d/Ellipse/Ellipse2d.h>
#include <IPSDKMath/Geometry/2d/Transform/Rigid2d.h>
#include <IPSDKMath/Geometry/2d/Transform/Similarity2d.h>
#include <IPSDKMath/Geometry/2d/Transform/Homography2d.h>
#include <IPSDKGeometry/Entity/3d/Point/Point3d.h>
#include <IPSDKGeometry/Entity/3d/Ellipsoid/Ellipsoid3d.h>
#include <IPSDKGeometry/Entity/3d/Plan/Plan3d.h>
#include <IPSDKGeometry/Entity/3d/Sphere/Sphere3d.h>
#include <IPSDKMath/Geometry/3d/Transform/Homography3d.h>
#include <IPSDKMath/Geometry/3d/Transform/Rigid3d.h>
#include <IPSDKMath/Geometry/3d/Transform/Similarity3d.h>
#include <IPSDKGeometry/Transform/3d/SimilarityTransform3d.h>
#include <IPSDKMath/Estimation/EstimationConfig.h>
#include <IPSDKMath/Estimation/EstimationResults.h>
#include <IPSDKMath/Estimation/EstimationOperators.h>
#include <boost/python/tuple.hpp>
#include <vector>

namespace ipsdk {
namespace python {


template <typename T>
PYIPSDKBASE_API boost::python::tuple
line2dEstimation(const std::vector<geom::Point2dData<T> >& ptColl,
                 const math::EstimationConfig& config);
template <typename T>
inline boost::python::tuple
line2dSimpleEstimation(const std::vector<geom::Point2dData<T> >& ptColl)
{
    math::EstimationConfig config;
    config.initNonRobust();

    return line2dEstimation(ptColl, config);
}



template <typename T>
PYIPSDKBASE_API boost::python::tuple
gaussianCurve2dEstimation(const std::vector<geom::Point2dData<T> >& ptColl,
                          const math::EstimationConfig& config);
template <typename T>
inline boost::python::tuple
gaussianCurve2dSimpleEstimation(const std::vector<geom::Point2dData<T> >& ptColl)
{
    math::EstimationConfig config;
    config.initNonRobust();

    return gaussianCurve2dEstimation(ptColl, config);
}


PYIPSDKBASE_API boost::python::tuple
polynomial2dSurfaceEstimator(const std::vector<geom::Point3dData<ipReal64> >& dataColl,
                             const math::EstimationConfig& config);
inline boost::python::tuple
polynomial2dSurfaceSimpleEstimator(const std::vector<geom::Point3dData<ipReal64> >& dataColl)
{
    math::EstimationConfig config;
    config.initNonRobust();

    return polynomial2dSurfaceEstimator(dataColl, config);
}


template <typename T>
PYIPSDKBASE_API boost::python::tuple
circle2dEstimation(const std::vector<geom::Point2dData<T> >& ptColl,
                   const math::EstimationConfig& config,
                   const bool bProcessNonLinearPass);
template <typename T>
inline boost::python::tuple
circle2dSimpleEstimation(const std::vector<geom::Point2dData<T> >& ptColl)
{
    math::EstimationConfig config;
    config.initNonRobust();

    return circle2dEstimation(ptColl, config, false);
}


template <typename T>
PYIPSDKBASE_API boost::python::tuple
ellipse2dEstimation(const std::vector<geom::Point2dData<T> >& ptColl,
                    const math::EstimationConfig& config);
template <typename T>
inline boost::python::tuple
ellipse2dSimpleEstimation(const std::vector<geom::Point2dData<T> >& ptColl)
{
    math::EstimationConfig config;
    config.initNonRobust();

    return ellipse2dEstimation(ptColl, config);
}


PYIPSDKBASE_API boost::python::tuple
intersectionPoint2dEstimation(const std::vector<geom::Line2d>& line2dColl,
                              const math::EstimationConfig& config);
inline boost::python::tuple
intersectionPoint2dSimpleEstimation(const std::vector<geom::Line2d>& line2dColl)
{
    math::EstimationConfig config;
    config.initNonRobust();

    return intersectionPoint2dEstimation(line2dColl, config);
}


template <typename T>
PYIPSDKBASE_API boost::python::tuple
homographyTransform2dEstimation(const std::vector<geom::Point2dData<T> >& ptColl1,
                                const std::vector<geom::Point2dData<T> >& ptColl2,
                                const math::EstimationConfig& config);
template <typename T>
inline boost::python::tuple
homographyTransform2dSimpleEstimation(const std::vector<geom::Point2dData<T> >& ptColl1,
                                      const std::vector<geom::Point2dData<T> >& ptColl2)
{
    math::EstimationConfig config;
    config.initNonRobust();

    return homographyTransform2dEstimation(ptColl1, ptColl2, config);
}


template <typename T>
PYIPSDKBASE_API boost::python::tuple
rigidTransform2dEstimation(const std::vector<geom::Point2dData<T> >& ptColl1,
                           const std::vector<geom::Point2dData<T> >& ptColl2,
                           const math::EstimationConfig& config);
template <typename T>
inline boost::python::tuple
rigidTransform2dSimpleEstimation(const std::vector<geom::Point2dData<T> >& ptColl1,
                                 const std::vector<geom::Point2dData<T> >& ptColl2)
{
    math::EstimationConfig config;
    config.initNonRobust();

    return rigidTransform2dEstimation(ptColl1, ptColl2, config);
}


template <typename T>
PYIPSDKBASE_API boost::python::tuple
similarityTransform2dEstimation(const std::vector<geom::Point2dData<T> >& ptColl1,
                                const std::vector<geom::Point2dData<T> >& ptColl2,
                                const math::EstimationConfig& config);
template <typename T>
inline boost::python::tuple
similarityTransform2dSimpleEstimation(const std::vector<geom::Point2dData<T> >& ptColl1,
                                      const std::vector<geom::Point2dData<T> >& ptColl2)
{
    math::EstimationConfig config;
    config.initNonRobust();

    return similarityTransform2dEstimation(ptColl1, ptColl2, config);
}


template <typename T>
PYIPSDKBASE_API boost::python::tuple
plan3dEstimation(const std::vector<geom::Point3dData<T> >& ptColl,
                 const math::EstimationConfig& config);
template <typename T>
inline boost::python::tuple
plan3dSimpleEstimation(const std::vector<geom::Point3dData<T> >& ptColl)
{
    math::EstimationConfig config;
    config.initNonRobust();

    return plan3dEstimation(ptColl, config);
}


template <typename T>
PYIPSDKBASE_API boost::python::tuple
ellipsoid3dEstimation(const std::vector<geom::Point3dData<T> >& ptColl,
                      const math::EstimationConfig& config);
template <typename T>
inline boost::python::tuple
ellipsoid3dSimpleEstimation(const std::vector<geom::Point3dData<T> >& ptColl)
{
    math::EstimationConfig config;
    config.initNonRobust();

    return ellipsoid3dEstimation(ptColl, config);
}


template <typename T>
PYIPSDKBASE_API boost::python::tuple
homographyTransform3dEstimation(const std::vector<geom::Point3dData<T> >& ptColl1,
                                const std::vector<geom::Point3dData<T> >& ptColl2,
                                const math::EstimationConfig& config);
template <typename T>
inline boost::python::tuple
homographyTransform3dSimpleEstimation(const std::vector<geom::Point3dData<T> >& ptColl1,
                                      const std::vector<geom::Point3dData<T> >& ptColl2)
{
    math::EstimationConfig config;
    config.initNonRobust();

    return homographyTransform3dEstimation(ptColl1, ptColl2, config);
}


template <typename T>
PYIPSDKBASE_API boost::python::tuple
gaussianCurve3dEstimation(const std::vector<geom::Point3dData<T> >& ptColl,
                          const math::EstimationConfig& config);
template <typename T>
inline boost::python::tuple
gaussianCurve3dSimpleEstimation(const std::vector<geom::Point3dData<T> >& ptColl)
{
    math::EstimationConfig config;
    config.initNonRobust();

    return gaussianCurve3dEstimation(ptColl, config);
}


template <typename T>
PYIPSDKBASE_API boost::python::tuple
rigidTransform3dEstimation(const std::vector<geom::Point3dData<T> >& ptColl1,
                           const std::vector<geom::Point3dData<T> >& ptColl2,
                           const math::EstimationConfig& config);
template <typename T>
inline boost::python::tuple
rigidTransform3dSimpleEstimation(const std::vector<geom::Point3dData<T> >& ptColl1,
                                 const std::vector<geom::Point3dData<T> >& ptColl2)
{
    math::EstimationConfig config;
    config.initNonRobust();

    return rigidTransform3dEstimation(ptColl1, ptColl2, config);
}


template <typename T>
PYIPSDKBASE_API boost::python::tuple
similarityTransform3dEstimation(const std::vector<geom::Point3dData<T> >& ptColl1,
                                const std::vector<geom::Point3dData<T> >& ptColl2,
                                const math::EstimationConfig& config);
template <typename T>
inline boost::python::tuple
similarityTransform3dSimpleEstimation(const std::vector<geom::Point3dData<T> >& ptColl1,
                                      const std::vector<geom::Point3dData<T> >& ptColl2)
{
    math::EstimationConfig config;
    config.initNonRobust();

    return similarityTransform3dEstimation(ptColl1, ptColl2, config);
}


template <typename T>
PYIPSDKBASE_API boost::python::tuple
sphere3dEstimation(const std::vector<geom::Point3dData<T> >& ptColl,
                   const math::EstimationConfig& config,
                   const bool bProcessNonLinearPass);
template <typename T>
inline boost::python::tuple
sphere3dSimpleEstimation(const std::vector<geom::Point3dData<T> >& ptColl)
{
    math::EstimationConfig config;
    config.initNonRobust();

    return sphere3dEstimation(ptColl, config, false);
}


} // end of namespace python
} // end of namespace ipsdk

#endif // __PYIPSDKBASE_PYTHONESTIMATIONUTILS_H__