Capturer.h

#ifndef __PBIO_API__PBIO__CAPTURER_H_
#define __PBIO_API__PBIO__CAPTURER_H_

#include <sstream>
#include <vector>


#include "ComplexObject.h"
#include "Error.h"
#include "RawImage.h"
#include "RawSample.h"
#include "SmartPtr.h"
#include "stl_wraps_impls/WrapOStreamImpl.h"
#include "stl_wraps_impls/WrapVectorImpl.h"


namespace pbio
{

class FacerecService;

class Capturer : public ComplexObject
{
public:

    typedef LightSmartPtr<Capturer>::tPtr Ptr;

    enum CapturerType
    {
        CAPTURER_TYPE_FRONTAL = 0,

        CAPTURER_TYPE_LEFT_PROFILE = 1,
        
        CAPTURER_TYPE_RIGHT_PROFILE = 2
    };


    std::vector<RawSample::Ptr> capture(const RawImage image);

    std::vector<RawSample::Ptr> capture(const unsigned char *data, int data_size);

    RawSample::Ptr manualCapture(
        const RawImage image,
        float left_eye_x,
        float left_eye_y,
        float right_eye_x,
        float right_eye_y);

    RawSample::Ptr manualCapture(
        const RawImage image,
        const std::vector<RawSample::Point> &points);

    RawSample::Ptr manualCapture(
        const unsigned char *data,
        int data_size,
        float left_eye_x,
        float left_eye_y,
        float right_eye_x,
        float right_eye_y);

    RawSample::Ptr manualCapture(
        const unsigned char *data,
        int data_size,
        const std::vector<RawSample::Point> &points);

    void resetHistory();


    CapturerType getType() const;

    void setParameter(
        const std::string parameter,
        const double value);

private:

    Capturer(
        const DHPtr &dll_handle,
        void* impl);

    friend class FacerecService;
    friend class object_with_ref_counter<Capturer>;
};

}  // pbio namespace




namespace pbio
{


inline
Capturer::Capturer(
    const DHPtr &dll_handle,
    void* impl):
ComplexObject(dll_handle, impl)
{
    // nothing else
}


inline 
std::vector<RawSample::Ptr> Capturer::capture(const RawImage image)
{
    std::vector<void*> void_result;

    void* exception = NULL;

    const RawImage::CapiData cdata = image.makeCapiData();

    _dll_handle->Capturer_capture_raw_image_with_crop(
        _impl,
        cdata.data,
        cdata.width,
        cdata.height,
        cdata.format,
        cdata.with_crop,
        cdata.crop_info_offset_x,
        cdata.crop_info_offset_y,
        cdata.crop_info_data_image_width,
        cdata.crop_info_data_image_height,
        &void_result,
        pbio::stl_wraps::assign_pointers_vector_func,
        &exception);


    checkException(exception, *_dll_handle);


    std::vector<RawSample::Ptr> result(void_result.size());

    for(size_t i = 0; i < void_result.size(); ++i)
        result[i] = RawSample::Ptr::make(_dll_handle, void_result[i]);

    return result;
}

inline
std::vector<RawSample::Ptr> Capturer::capture(const unsigned char *data, int data_size)
{
    std::vector<void*> void_result;

    void* exception = NULL;

    _dll_handle->Capturer_capture_encoded_image(
        _impl,
        data,
        data_size,
        &void_result,
        pbio::stl_wraps::assign_pointers_vector_func,
        &exception);


    checkException(exception, *_dll_handle);


    std::vector<RawSample::Ptr> result(void_result.size());

    for(size_t i = 0; i < void_result.size(); ++i)
        result[i] = RawSample::Ptr::make( _dll_handle, void_result[i] );

    return result;
}

inline
RawSample::Ptr Capturer::manualCapture(
    const RawImage image,
    float left_eye_x,
    float left_eye_y,
    float right_eye_x,
    float right_eye_y)
{
    void* exception = NULL;

    const RawImage::CapiData cdata = image.makeCapiData();

    void* const result_impl = _dll_handle->Capturer_manualCapture_raw_image_eyes_points_with_crop(
        _impl,
        cdata.data,
        cdata.width,
        cdata.height,
        cdata.format,

        cdata.with_crop,
        cdata.crop_info_offset_x,
        cdata.crop_info_offset_y,
        cdata.crop_info_data_image_width,
        cdata.crop_info_data_image_height,

        left_eye_x,
        left_eye_y,
        right_eye_x,
        right_eye_y,
        &exception);

    checkException(exception, *_dll_handle);

    return RawSample::Ptr::make(_dll_handle, result_impl);
}

inline
RawSample::Ptr Capturer::manualCapture(
    const RawImage image,
    const std::vector<RawSample::Point> &points)
{
    void* exception = NULL;

    std::vector<float> points_data(points.size() * 3);
    for(size_t i = 0; i < points.size(); ++i)
    {
        points_data[i * 3 + 0] = points[i].x;
        points_data[i * 3 + 1] = points[i].y;
        points_data[i * 3 + 2] = points[i].z;
    }

    const RawImage::CapiData cdata = image.makeCapiData();

    void* const result_impl = _dll_handle->Capturer_manualCapture_raw_image_points_vector_with_crop(
        _impl,
        cdata.data,
        cdata.width,
        cdata.height,
        cdata.format,

        cdata.with_crop,
        cdata.crop_info_offset_x,
        cdata.crop_info_offset_y,
        cdata.crop_info_data_image_width,
        cdata.crop_info_data_image_height,

        points_data.empty() ? NULL : points_data.data(),
        points.size(),
        &exception);

    checkException(exception, *_dll_handle);

    return RawSample::Ptr::make(_dll_handle, result_impl);
}

inline
RawSample::Ptr Capturer::manualCapture(
    const unsigned char *data,
    int data_size,
    float left_eye_x,
    float left_eye_y,
    float right_eye_x,
    float right_eye_y)
{
    void* exception = NULL;

    void* const result_impl = _dll_handle->Capturer_manualCapture_encoded_image_eyes_points(
        _impl,
        data,
        data_size,
        left_eye_x,
        left_eye_y,
        right_eye_x,
        right_eye_y,
        &exception);

    checkException(exception, *_dll_handle);

    return RawSample::Ptr::make(_dll_handle, result_impl);
}

inline
RawSample::Ptr Capturer::manualCapture(
    const unsigned char *data,
    int data_size,
    const std::vector<RawSample::Point> &points)
{
    void* exception = NULL;

    std::vector<float> points_data(points.size() * 3);
    for(size_t i = 0; i < points.size(); ++i)
    {
        points_data[i * 3 + 0] = points[i].x;
        points_data[i * 3 + 1] = points[i].y;
        points_data[i * 3 + 2] = points[i].z;
    }

    void* const result_impl = _dll_handle->Capturer_manualCapture_encoded_image_points_vector(
        _impl,
        data,
        data_size,
        points_data.empty() ? NULL : points_data.data(),
        points.size(),
        &exception);

    checkException(exception, *_dll_handle);

    return RawSample::Ptr::make(_dll_handle, result_impl);
}


inline
void Capturer::resetHistory()
{
    void* exception = NULL;

    _dll_handle->Capturer_resetHistory(
        _impl,
        &exception);

    checkException(exception, *_dll_handle);
}

inline
Capturer::CapturerType Capturer::getType() const
{
    void* exception = NULL;

    const int result = _dll_handle->Capturer_getType(
        _impl,
        &exception);

    checkException(exception, *_dll_handle);

    return (CapturerType) result;
}

inline
void Capturer::setParameter(
    const std::string parameter,
    const double value)
{
    void* exception = NULL;

    _dll_handle->Capturer_setParameter(
        _impl,
        parameter.c_str(),
        value,
        &exception);

    checkException(exception, *_dll_handle);
}



}  // pbio namespace

#endif  // __PBIO_API__PBIO__CAPTURER_H_