RawSample.h

#ifndef __PBIO_API__PBIO__RAW_SAMPLE_H_
#define __PBIO_API__PBIO__RAW_SAMPLE_H_


#include <ostream>

#include "ComplexObject.h"
#include "ExceptionCheck.h"
#include "Point.h"
#include "RawImage.h"
#ifndef WITHOUT_PROCESSING_BLOCK
#include "pbio/Context.h"
#endif
#include "SmartPtr.h"
#include "stl_wraps_impls/WrapOStreamImpl.h"
#include "stl_wraps_impls/WrapVectorImpl.h"


namespace pbio
{
class AgeGenderEstimator;
class Capturer;
class FacerecService;
class LivenessEstimator;
class QualityEstimator;
class FaceQualityEstimator;
class Recognizer;
class VideoWorker;
class EmotionsEstimator;
class DepthLivenessEstimator;
class IRLivenessEstimator;
class Liveness2DEstimator;
class FaceAttributesEstimator;
class RawSampleExtractor;

class RawSample : public ComplexObject
{
public:

    typedef LightSmartPtr<RawSample>::tPtr Ptr;

    enum SampleType
    {
        SAMPLE_TYPE_FRONTAL = 0,

        SAMPLE_TYPE_LEFT_PROFILE = 1,

        SAMPLE_TYPE_RIGHT_PROFILE = 2
    };

    enum ImageFormat
    {
        IMAGE_FORMAT_JPG = 0,

        IMAGE_FORMAT_PNG = 1,

        IMAGE_FORMAT_TIF = 2,

        IMAGE_FORMAT_BMP = 3  
    };

    enum FaceCutType
    {
        FACE_CUT_BASE = 0,

        FACE_CUT_FULL_FRONTAL = 1,

        FACE_CUT_TOKEN_FRONTAL = 2   
    };

    typedef pbio::Rectangle Rectangle;

    typedef pbio::Point Point;

    struct Angles
    {
        float yaw;

        float pitch;

        float roll;
    };


    Rectangle getRectangle() const;


    std::vector<Point> getLandmarks() const;


    std::vector<Point> getIrisLandmarks() const;


    Point getLeftEye() const;


    Point getRightEye() const;

    Angles getAngles() const;


    int getID() const;


    int getFrameID() const;


    bool hasOriginalImage() const;

    float getScore() const;

    float getFaceVisibilityScore() const;

    void getOriginalImage(
        int &rows,
        int &cols,
        IRawImage::Format &format,
        void const* &data) const;

    SampleType getType() const;



    std::vector<Point> getFaceCutRectangle(FaceCutType cut_type) const;


    void cutFaceImage(
        std::ostream &binary_stream,
        ImageFormat format,
        FaceCutType cut_type) const;


    RawImage cutFaceRawImage(
        RawImage::Format color_model,
        FaceCutType cut_type) const;
    
    void cutFaceImage(
        pbio::stl_wraps::WrapOStream &binary_stream,
        ImageFormat format,
        FaceCutType cut_type) const;

    void cutFaceImage(
        const RawImage original_image,
        std::ostream &binary_stream,
        ImageFormat format,
        FaceCutType cut_type) const;

    void cutFaceImage(
        const RawImage original_image,
        pbio::stl_wraps::WrapOStream &binary_stream,
        ImageFormat format,
        FaceCutType cut_type) const;

    void save(std::ostream &binary_stream, ImageFormat format) const;

    void save(pbio::stl_wraps::WrapOStream &binary_stream, ImageFormat format) const;


    void saveWithoutImage(
        pbio::stl_wraps::WrapOStream &binary_stream,
        const double space_translation_x = 0,
        const double space_translation_y = 0,
        const double space_scale = 1) const;

    void saveWithoutImage(
        std::ostream &binary_stream,
        const double space_translation_x = 0,
        const double space_translation_y = 0,
        const double space_scale = 1) const;


    RawSample::Ptr downscaleToPreferredSize() const;

#ifndef WITHOUT_PROCESSING_BLOCK

    pbio::Context toContext() const;
#endif

    void* getPtr() const;

private:

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

    friend class AgeGenderEstimator;
    friend class Capturer;
    friend class FacerecService;
    friend class LivenessEstimator;
    friend class QualityEstimator;
    friend class FaceQualityEstimator;
    friend class Recognizer;
    friend class VideoWorker;
    friend class EmotionsEstimator;
    friend class DepthLivenessEstimator;
    friend class IRLivenessEstimator;
    friend class Liveness2DEstimator;
    friend class FaceAttributesEstimator;
    friend class RawSampleExtractor;
    friend class object_with_ref_counter<RawSample>;
};

}  // pbio namespace



namespace pbio
{

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


inline
RawSample::Rectangle RawSample::getRectangle() const
{
    Rectangle rectangle;

    void* exception = NULL;

    _dll_handle->RawSample_getRectangle(
        _impl,
        &rectangle.x,
        &rectangle.y,
        &rectangle.width,
        &rectangle.height,
        &exception);

    checkException(exception, *_dll_handle);

    return rectangle;
}


inline
std::vector<RawSample::Point> RawSample::getLandmarks() const
{
    std::vector<float> coordinates;

    void* exception = NULL;

    _dll_handle->RawSample_getLandmarks(
        _impl,
        &coordinates,
        pbio::stl_wraps::assign_floats_vector_func,
        &exception);

    checkException(exception, *_dll_handle);

    std::vector<Point> points(coordinates.size() / 3);

    for(size_t i = 0; i < points.size(); ++i)
    {
        points[i].x = coordinates[i * 3 + 0];
        points[i].y = coordinates[i * 3 + 1];
        points[i].z = coordinates[i * 3 + 2];
    }

    return points;
}


inline
std::vector<RawSample::Point> RawSample::getIrisLandmarks() const
{
    std::vector<float> coordinates;

    void* exception = NULL;

    _dll_handle->RawSample_getIrisLandmarks(
        _impl,
        &coordinates,
        pbio::stl_wraps::assign_floats_vector_func,
        &exception);

    checkException(exception, *_dll_handle);

    std::vector<Point> points(coordinates.size() / 3);

    for(size_t i = 0; i < points.size(); ++i)
    {
        points[i].x = coordinates[i * 3 + 0];
        points[i].y = coordinates[i * 3 + 1];
        points[i].z = coordinates[i * 3 + 2];
    }

    return points;
}


inline
RawSample::Point RawSample::getLeftEye() const
{
    Point p;

    void* exception = NULL;

    _dll_handle->RawSample_getLeftEye(
        _impl,
        &p.x,
        &p.y,
        &exception);

    checkException(exception, *_dll_handle);

    return p;
}

inline
RawSample::Point RawSample::getRightEye() const
{
    Point p;

    void* exception = NULL;

    _dll_handle->RawSample_getRightEye(
        _impl,
        &p.x,
        &p.y,
        &exception);

    checkException(exception, *_dll_handle);

    return p;
}

inline
RawSample::Angles RawSample::getAngles() const
{
    Angles angles;

    void* exception = NULL;

    _dll_handle->RawSample_getAngles(
        _impl,
        &angles.yaw,
        &angles.pitch,
        &angles.roll,
        &exception);

    checkException(exception, *_dll_handle);

    return angles;
}

inline
int RawSample::getID() const
{
    void* exception = NULL;

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

    checkException(exception, *_dll_handle);

    return result;
}

inline
int RawSample::getFrameID() const
{
    void* exception = NULL;

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

    checkException(exception, *_dll_handle);

    return result;
}


inline
RawSample::SampleType RawSample::getType() const
{
    void* exception = NULL;

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

    checkException(exception, *_dll_handle);

    return (SampleType) result;
}


inline
std::vector<RawSample::Point> RawSample::getFaceCutRectangle(
    FaceCutType cut_type) const
{
    void* exception = NULL;

    float corners[8];

    _dll_handle->RawSample_getFaceCutRectangle(
        _impl,
        int(cut_type),
        corners,
        &exception);

    checkException(exception, *_dll_handle);

    std::vector<RawSample::Point> result(4);
    for(int i = 0; i < 4; ++i)
    {
        result[i].x = corners[i * 2 + 0];
        result[i].y = corners[i * 2 + 1];
    }

    return result;
}


inline
void RawSample::cutFaceImage(
    std::ostream &binary_stream,
    RawSample::ImageFormat format,
    RawSample::FaceCutType cut_type) const
{
    pbio::stl_wraps::WrapOStreamImpl binary_stream_wrap(binary_stream);

    cutFaceImage(binary_stream_wrap, format, cut_type);
}

inline
RawImage RawSample::cutFaceRawImage(
    RawImage::Format color_model,
    FaceCutType cut_type) const
{
    int32_t width, height;
    std::ostringstream stream;
    pbio::stl_wraps::WrapOStreamImpl binary_stream_wrap(stream);

    void* exception = NULL;

    _dll_handle->RawSample_cutFaceImage(
        _impl,
        &binary_stream_wrap,
        pbio::stl_wraps::WrapOStream::write_func,
        &width,
        &height,
        -1,
        int(color_model),
        int(cut_type),
        &exception);

    checkException(exception, *_dll_handle);

    pbio::RawImage result(
        width,
        height,
        color_model,
        (unsigned char*) stream.str().c_str(),
        stream.str().size());

    return result;
}

inline
void RawSample::cutFaceImage(
    pbio::stl_wraps::WrapOStream &binary_stream,
    ImageFormat format,
    FaceCutType cut_type) const
{
    void* exception = NULL;

    int32_t w, h;

    _dll_handle->RawSample_cutFaceImage(
        _impl,
        &binary_stream,
        pbio::stl_wraps::WrapOStream::write_func,
        &w,
        &h,
        int(format),
        -1,
        int(cut_type),
        &exception);

    checkException(exception, *_dll_handle);
}


inline
void RawSample::cutFaceImage(
    const RawImage original_image,
    std::ostream &binary_stream,
    ImageFormat format,
    FaceCutType cut_type) const
{
    pbio::stl_wraps::WrapOStreamImpl binary_stream_wrap(binary_stream);

    cutFaceImage(
        original_image,
        binary_stream_wrap,
        format,
        cut_type);
}

inline
void RawSample::cutFaceImage(
    const RawImage original_image,
    pbio::stl_wraps::WrapOStream &binary_stream,
    ImageFormat format,
    FaceCutType cut_type) const
{
    void* exception = NULL;

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

    _dll_handle->RawSample_cutFaceImage_original_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,
        &binary_stream,
        pbio::stl_wraps::WrapOStream::write_func,
        int(format),
        int(cut_type),
        &exception);

    checkException(exception, *_dll_handle);
}


inline
void RawSample::save(
    std::ostream &binary_stream,
    ImageFormat format) const
{
    pbio::stl_wraps::WrapOStreamImpl binary_stream_wrap(binary_stream);

    save(binary_stream_wrap, format);
}

inline
void RawSample::save(
    pbio::stl_wraps::WrapOStream &binary_stream,
    ImageFormat format) const
{
    void* exception = NULL;

    _dll_handle->RawSample_save(
        _impl,
        &binary_stream,
        pbio::stl_wraps::WrapOStream::write_func,
        int(format),
        &exception);

    checkException(exception, *_dll_handle);
}



inline
bool RawSample::hasOriginalImage() const
{
    void* exception = NULL;

    const bool result = _dll_handle->RawSample_hasOriginalImage(
        _impl,
        &exception);

    checkException(exception, *_dll_handle);

    return result;
}

inline
float RawSample::getScore() const
{
    void* exception = NULL;

    const float result = _dll_handle->RawSample_getScore(
            _impl,
            &exception);

    checkException(exception, *_dll_handle);

    return result;

}

inline
float RawSample::getFaceVisibilityScore() const
{
    void* exception = NULL;

    const float result = _dll_handle->RawSample_getFaceVisibilityScore(
            _impl,
            &exception);

    checkException(exception, *_dll_handle);

    return result;

}


inline
void RawSample::getOriginalImage(
    int &rows,
    int &cols,
    IRawImage::Format &format,
    void const* &data) const
{
    int32_t rows_, cols_, format_;

    void* exception = NULL;

    _dll_handle->RawSample_getOriginalImage(
        _impl,
        &rows_,
        &cols_,
        &format_,
        &data,
        &exception);

    checkException(exception, *_dll_handle);

    rows   = rows_;
    cols   = cols_;
    format = (IRawImage::Format) format_;
}


inline
RawSample::Ptr RawSample::downscaleToPreferredSize() const
{
    void* exception = NULL;

    pbio::facerec::RawSampleImpl* const raw_sampl_impl =
        _dll_handle->RawSample_downscaleToPreferredSize(
            _impl,
            &exception);

    checkException(exception, *_dll_handle);

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

#ifndef WITHOUT_PROCESSING_BLOCK
inline
pbio::Context RawSample::toContext() const
{
    void* exception = NULL;

    HContext* handle = _dll_handle->RawSample_toContext(
            _impl,
            &exception);

    checkException(exception, *_dll_handle);

    return pbio::Context(_dll_handle, handle, false);
}
#endif


inline
void RawSample::saveWithoutImage(
    pbio::stl_wraps::WrapOStream &binary_stream,
    const double space_translation_x,
    const double space_translation_y,
    const double space_scale) const
{
    void* exception = NULL;

    _dll_handle->RawSample_save_without_image(
        _impl,
        &binary_stream,
        pbio::stl_wraps::WrapOStream::write_func,
        space_translation_x,
        space_translation_y,
        space_scale,
        &exception);

    checkException(exception, *_dll_handle);
}

inline
void RawSample::saveWithoutImage(
    std::ostream &binary_stream,
    const double space_translation_x,
    const double space_translation_y,
    const double space_scale) const
{
    pbio::stl_wraps::WrapOStreamImpl binary_stream_wrap(binary_stream);

    saveWithoutImage(
        binary_stream_wrap,
        space_translation_x,
        space_translation_y,
        space_scale);
}

inline
void* RawSample::getPtr() const
{
    return _impl;
}


}  // pbio namespace



#endif  // __PBIO_API__PBIO__RAW_SAMPLE_H_