Anonymizer  7.0
SDK for anonymization of human faces and licence plates in images.
example-buffers.cpp

This is an example of how to use the Anonymizer library. This example shows how to explicitly link anonymizer library and run anonymization of a JPEG buffer and an image buffer. Example uses default AnParams parameters

Example example-buffers.cpp uses OpenCV library for image IO operation. Necessary documentation how to set up OpenCV is in examples/example-buffer/ directory.

/* **************************************************************** */
/* **************************************************************** */
/* * * */
/* * Anonymizer example console application * */
/* * This example shows how to link Anonymizer library, * */
/* * initialize it and run anonymization of image file. * */
/* * * */
/* * use(Windows): example.exe image.jpg * */
/* * use(Linux) : ./example image.jpg * */
/* * * */
/* * ------------------------------------------------------------ * */
/* * * */
/* * Eyedea Recognition, Ltd. (C) 2013, Mar 6th * */
/* * * */
/* * Contact: * */
/* * web: http://www.eyedea.cz * */
/* * email: info@eyedea.cz * */
/* * * */
/* **************************************************************** */
/* **************************************************************** */
#include <stdio.h>
#include <string>
#include <cstring>
#include <thread>
#include <opencv2/opencv.hpp>
using namespace std;
#include <er_explink.h> /* multi-platform explicit linking macros */
#include <Anonymizer.h> /* Anonymizer API */
#define ANONYMIZER_SDK_DIR "../../sdk/"
#define ANONYMIZER_LIB ANONYMIZER_SDK_DIR "/lib/" ER_LIB_PREFIX "anonymizer" AN_SUFFIX "-" ER_LIB_TARGET DEBUG_SUFFIX ER_LIB_EXT
#define ANONYMIZER_INI "config.ini"
int fread_buffer( char *name, unsigned char **ppBuffer, size_t *length);
int fwrite_buffer(char *name, unsigned char *pBuffer, size_t length);
bool check_arg(const char *arg, std::string option, std::string &retv); // argument checking
int main (int argc, const char ** argv)
{
string output = "image_anonymized.jpg";
string input = "../../data/image.jpg";
ERComputationMode computation_mode{ER_COMPUTATION_MODE_CPU};
int gpu_id{0};
int num_threads{ (int) (std::thread::hardware_concurrency() * 0.5) };
/* ////////////////////////////////////////////////////////// */
/* Reading input parameters */
/* */
for( int i = 1; i < argc; i++ )
{
std::string retv;
if (check_arg(argv[i], "-o=", retv) || check_arg(argv[i], "--output=", retv))
output = retv;
else if (check_arg(argv[i], "--gpu", retv))
computation_mode = ER_COMPUTATION_MODE_GPU;
else if (check_arg(argv[i], "--gpu-id=", retv))
gpu_id = atoi(retv.c_str());
else if (check_arg(argv[i], "--num-threads=", retv))
num_threads = atoi(retv.c_str());
else if (check_arg(argv[i], "-h", retv) | check_arg(argv[i], "--help", retv)){
printf("USAGE: %s [options] filename\n"
" options: -o=filename sets the output filename for anonymized image\n"
" --gpu - use gpu for detection (if supported by module)"
" --gpu-id=ID - use gpu with given ID for gpu computation"
" --num-threads=X - thread number for CPU computation parts"
" filename: input image filename, default ../../data/image.jpg\n"
"\nEXAMPLE:\n %s\n", argv[0], argv[0]);
return 0;
}
else if( argv[i][0] == '-' )
{
printf("WARNING: Unknown option %s\nSee `%s --help' for more information.\n",argv[i], argv[0]);
}
else
input.assign( argv[i] );
}
if( input.empty() ){
printf("ERROR: Input filename is missing.\nTry `%s --help' for more information.\n", argv[0]);
return -1;
}
/* EXPLICIT LINKING */
printf("Loading library and functions\n");
fcn_anInit fcnAnInit;
fcn_anFree fcnAnFree;
fcn_anAnonymizeImageBuffer fcnAnAnonymizeImageBuffer;
fcn_anFreeBuffer fcnAnFreeBuffer;
fcn_anAnonymizeJpegBuffer fcnAnAnonymizeJpegBuffer;
fcn_anVersion fcnAnVersion;
fcn_anGetErrorMsg fcnAnGetErrorMsg;
shlib_hnd hDll;
/* load shared library */
ER_OPEN_SHLIB(hDll, ANONYMIZER_LIB);
if (!hDll){
printf(" library '%s' not loaded!\n", ANONYMIZER_LIB);
return -1;
}
/* link AnonymizerSDK functions */
ER_LOAD_SHFCN(fcnAnInit, fcn_anInit, hDll, "anInit");
ER_LOAD_SHFCN(fcnAnFree, fcn_anFree, hDll, "anFree");
ER_LOAD_SHFCN(fcnAnAnonymizeImageBuffer, fcn_anAnonymizeImageBuffer, hDll, "anAnonymizeImageBuffer");
ER_LOAD_SHFCN(fcnAnFreeBuffer, fcn_anFreeBuffer, hDll, "anFreeBuffer");
ER_LOAD_SHFCN(fcnAnAnonymizeJpegBuffer, fcn_anAnonymizeJpegBuffer, hDll, "anAnonymizeJpegBuffer");
ER_LOAD_SHFCN(fcnAnVersion, fcn_anVersion, hDll, "anVersion");
ER_LOAD_SHFCN(fcnAnGetErrorMsg, fcn_anGetErrorMsg, hDll, "anGetErrorMsg");
if (!fcnAnInit || !fcnAnFree || !fcnAnAnonymizeImageBuffer || !fcnAnAnonymizeJpegBuffer || !fcnAnVersion || !fcnAnGetErrorMsg){
printf(" Loading Anonymizer functions failed!\n");
return -1;
}
printf(" ... done\n");
printf("Loaded %s\n", fcnAnVersion(0));
/* AnonymizerSDK API - Anonymizer initialization. Inputs are path to SDK package, configuration filename (default config.ini) */
AnConfig config;
std::memset(&config,0,sizeof(config));
config.computation_mode = computation_mode;
config.gpu_device_id = gpu_id;
config.num_threads = num_threads;
ANState state; /* sdk state handler*/
int ern;
printf("Anonymizer initialization:\n");
ern=fcnAnInit((char*)ANONYMIZER_SDK_DIR, ANONYMIZER_INI, &config, &state);
if (ern != 0){
printf("failed!\n%s\n", fcnAnGetErrorMsg(ern));
return -1;
}else
printf(" ... done.\n");
/* anonymization of JPEG buffer */
printf("JPEG buffer anonymization\n");
AnBuffer srcBuffer, dstBuffer;
/* read image to buffer */
if (fread_buffer((char*)input.c_str(), &(srcBuffer.raw_data), &(srcBuffer.length)) != 0) {
fcnAnFree(state);
return -1;
}
/* run anonymization */
ern=fcnAnAnonymizeJpegBuffer(srcBuffer, NULL, state, &dstBuffer);
if (ern != 0) {
printf(" ... failed!\n%s\n",fcnAnGetErrorMsg(ern));
fcnAnFree(state);
return -1;
}
/* write buffer to file */
if (fwrite_buffer((char*)((output + ".JpegBuffer.jpg").c_str()), dstBuffer.raw_data, dstBuffer.length) != 0) {
fcnAnFree(state);
return -1;
}
delete [] srcBuffer.raw_data;
fcnAnFreeBuffer(dstBuffer);
printf(" ...done\n");
/* anonymization of image buffer */
printf("Image data buffer anonymization\n");
cv::Mat imageBGR, imageAnonymized;
imageBGR = cv::imread(input.c_str(), cv::IMREAD_COLOR); // Read the file - BGR order
srcBuffer.raw_data = imageBGR.data;
cv::Size s = imageBGR.size();
/* run anonymization */
if (fcnAnAnonymizeImageBuffer(srcBuffer, s.width,s.height, NULL, state, &dstBuffer) != 0) {
printf(" ... failed!\n%s\n",fcnAnGetErrorMsg(ern));
fcnAnFree(state);
return -1;
}
memcpy(imageBGR.data, dstBuffer.raw_data, imageBGR.total()*imageBGR.elemSize());// set anonymized data back to BGR image
cv::imwrite(output + ".Buffer.jpg", imageBGR); // and write
fcnAnFreeBuffer(dstBuffer); // free buffer allocated by Anonymizer
printf(" ...done\n");
/* free Anonymizer state */
printf("Cleaning up\n");
fcnAnFree(state);
/* free loaded library */
ER_FREE_LIB(hDll); // NOTE: unloading secured library may cause application crash (Windows, randomly)
printf(" ... done.\n");
return 0;
}
int fread_buffer(char *name, unsigned char **buffer_, size_t *length)
{
FILE *file;
//Open file
file = fopen(name, "rb");
if (!file)
{
printf("Unable to open file %s", name);
return -1;
}
//Get file length
fseek(file, 0, SEEK_END);
*length = ftell(file);
fseek(file, 0, SEEK_SET);
//Allocate memory
unsigned char *buffer;
try {
buffer = new unsigned char[*length + 1];
}
catch (std::bad_alloc e) {
printf("%s\n", e.what());
fclose(file);
return -1;
}
//Read file contents into buffer
fread(buffer, *length, 1, file);
fclose(file);
*buffer_ = buffer;
return 0;
}
int fwrite_buffer(char *name, unsigned char *pBuffer, size_t length)
{
FILE *file = fopen(name, "wb");
if (!file)
{
printf("Writing buffer to file failed!\n");
return -1;
}
fwrite(pBuffer, length, 1, file);
fclose(file);
return 0;
}
bool check_arg(const char *arg, std::string option, std::string &retv)
{
if (option.compare(0,option.length(),arg,option.length()) == 0)
{
retv.assign(arg+option.length());
return true;
}
else
{
return false;
}
}
fcn_anAnonymizeImageBuffer
int(* fcn_anAnonymizeImageBuffer)(AnBuffer, int, int, AnParams *, ANState, AnBuffer *)
anAnonymizeImageBuffer function pointer
Definition: Anonymizer.h:198
AnConfig
Configuration structure for Anonymizer state initialization.
Definition: Anonymizer.h:108
AnConfig::gpu_device_id
int gpu_device_id
Definition: Anonymizer.h:111
fcn_anFreeBuffer
void(* fcn_anFreeBuffer)(AnBuffer buffer)
anFreeBuffer function pointer
Definition: Anonymizer.h:233
fcn_anGetErrorMsg
const typedef char *(* fcn_anGetErrorMsg)(int)
anGetErrorMsg function pointer
Definition: Anonymizer.h:268
ANState
void * ANState
Handle to Anonymizer SDK library.
Definition: Anonymizer.h:30
AnBuffer
Image buffer enclosing structure.
Definition: Anonymizer.h:37
fcn_anVersion
const typedef char *(* fcn_anVersion)(int)
anVersion function pointer
Definition: Anonymizer.h:258
fcn_anInit
int(* fcn_anInit)(const char *, const char *, const AnConfig *, ANState *)
anInit function pointer
Definition: Anonymizer.h:140
fcn_anAnonymizeJpegBuffer
int(* fcn_anAnonymizeJpegBuffer)(AnBuffer, AnParams *, ANState, AnBuffer *)
anAnonymizeJpegBuffer function pointer
Definition: Anonymizer.h:220
fcn_anFree
void(* fcn_anFree)(ANState)
anFree function pointer
Definition: Anonymizer.h:150
AnBuffer::length
size_t length
Definition: Anonymizer.h:40
AnConfig::computation_mode
ERComputationMode computation_mode
Definition: Anonymizer.h:110
AnConfig::num_threads
int num_threads
Definition: Anonymizer.h:112
AnBuffer::raw_data
unsigned char * raw_data
Definition: Anonymizer.h:39