serialize.cpp

#include <face_sdk_base/exception.h>
#include <face_sdk_base/image.h>
#include <face_sdk_base/serialize.h>
#include <face_sdk_alignment/alignment.h>
#include <face_sdk_builder/builder.h>
 
#include <iostream>
#include <fstream>
 
int main(int argc, char **argv)
{
    if (argc < 2) {
        std::cout << "usage: <IMG_1> <IMG_2> ... <IMG_N>" << std::endl;
        return 1;
    }
 
    std::shared_ptr<face_sdk::alignment> alignment;
    std::shared_ptr<face_sdk::builder> builder;
    std::shared_ptr<face_sdk::serializer> serializer;
    std::vector<std::string> file_names_without_ext;
    
    try {
 
        // initialize serializer
        serializer = face_sdk::make_serializer();
 
        // initialize Alignment, Builder algorithms with batch size 1 and on CPU
        alignment = face_sdk::make_alignment(103, 1, -1);
        builder = face_sdk::make_builder(200, 1, -1);
 
        // load images and make faces objects.
        std::vector< std::shared_ptr< face_sdk::face > > faces;
        for (int i = 1; i < argc; i++) {
 
            std::string file_path;
            file_path.assign(argv[i]);
            auto pos = file_path.rfind('.', 0);
            file_names_without_ext.push_back(file_path.substr(0, pos));
 
            auto img = face_sdk::load_image_from_file(argv[i]);
            auto face = face_sdk::make_face(img);
            faces.push_back(face);
        }
 
        // perform alignment
        auto align_results = alignment->calc_alignment(faces);
 
        // build FIRs for previously aligned images
        auto firs = builder->build(align_results);
 
 
        for (int i = 1; i < argc; i++) {
            
            {
                // serialize face
                auto fac_data = serializer->serialize_face(faces[i], true);
                auto face_file_name = file_names_without_ext[i] + ".fac";
                std::ofstream stream;
                stream.open(face_file_name, std::ios::binary);
                stream.write((char*)fac_data.data(), fac_data.size());
            }
 
            {
                // serialize align_info
                auto alg_data = serializer->serialize_alignment_info(align_results[i]);
                auto align_info_file_name = file_names_without_ext[i] + ".alg";
                std::ofstream stream;
                stream.open(align_info_file_name, std::ios::binary);
                stream.write((char*)alg_data.data(), alg_data.size());
            }
 
            {
                // serialize fir
                auto fir_data = serializer->serialize_fir(firs[i]);
                auto fir_file_name = file_names_without_ext[i] + ".fir";
                std::ofstream stream;
                stream.open(fir_file_name, std::ios::binary);
                stream.write((char*)fir_data.data(), fir_data.size());
            }
 
        }
 
        
    }
    // exception handling
    catch (const face_sdk::exception &exp) {
 
        // print the stack of nested exceptions ...
        std::cerr << face_sdk::format_exception(exp) << std::endl;
 
        // ... or handle more detailed exceptions
        try {
            std::rethrow_if_nested(exp);
        }
        catch (const face_sdk::version_not_available_exception &nested) {
            // ...
            std::cerr << nested.what() << std::endl;
        }
        catch (const face_sdk::license_exception &nested) {
            // ...
            std::cerr << nested.what() << std::endl;
        }
        catch (const std::exception &nested) {
            // ...
            std::cerr << nested.what() << std::endl;
        }
 
        return 2;
    }
 
    return 0;
}