flandmark_detector.h

Go to the documentation of this file.

/* =========================================================================== *
   |
   |  Copyright (c) 1994-2011 by Kobus Barnard (author)
   |
   |  Personal and educational use of this code is granted, provided that this
   |  header is kept intact, and that the authorship is not misrepresented, that
   |  its use is acknowledged in publications, and relevant papers are cited.
   |
   |  For other use contact the author (kobus AT cs DOT arizona DOT edu).
   |
   |  Please note that the code in this file has not necessarily been adequately
   |  tested. Naturally, there is no guarantee of performance, support, or fitness
   |  for any particular task. Nonetheless, I am interested in hearing about
   |  problems that you encounter.
   |
   |  Author:  Jinyan Guan
 * =========================================================================== */

/* $Id: flandmark_detector.h 18301 2014-11-26 19:17:13Z ksimek $ */
/*
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 3 of the License, or
 * (at your option) any later version.
 *
 * Written (W) 2012 Michal Uricar
 * Copyright (C) 2012 Michal Uricar
 */

#ifndef KJB_FLANDMARK_DETECTOR_H_
#define KJB_FLANDMARK_DETECTOR_H_

#ifdef KJB_HAVE_OPENCV

#include <wrap_flandmark_cpp/msvc-compat.h>
//#include <cv.h>
//#include <cvaux.h>
#include <wrap_opencv_cpp/cv.h>
#include <i_cpp/i_image.h>
#include <gr_cpp/gr_2D_bounding_box.h>

namespace kjb {
namespace flandmark {
// index row-order matrices
#define INDEX(ROW, COL, NUM_ROWS) ((COL)*(NUM_ROWS)+(ROW))
#define ROW(IDX, ROWS) (((IDX)-1) % (ROWS))
#define COL(IDX, ROWS) (((IDX)-1) / (ROWS))

typedef struct psig_struct {
    int * disp;
    int ROWS, COLS;
} FLANDMARK_PSIG;

typedef struct options_struct {
    uint8_t M;
    int * S;
    int bw[2], bw_margin[2];
    FLANDMARK_PSIG *PsiGS0, *PsiGS1, *PsiGS2;
    int PSIG_ROWS[3], PSIG_COLS[3];
} FLANDMARK_Options;

typedef struct lbp_struct {
    int winSize[2];
    uint8_t hop;
    uint32_t *wins;
    int WINS_ROWS, WINS_COLS;
} FLANDMARK_LBP;

typedef struct data_struct {
    FLANDMARK_LBP * lbp;
    int imSize[2];
    int * mapTable;
    FLANDMARK_Options options;
} FLANDMARK_Data;

typedef struct model_struct {
    double * W;
    int W_ROWS, W_COLS;
    FLANDMARK_Data data;
    uint8_t *normalizedImageFrame;
    double *bb;
    float *sf;
} FLANDMARK_Model;

typedef struct psi_struct {
    char * data;
    uint32_t PSI_ROWS, PSI_COLS;
} FLANDMARK_PSI;

typedef struct psi_sparse {
    uint32_t * idxs;
    uint32_t PSI_ROWS, PSI_COLS;
} FLANDMARK_PSI_SPARSE;
// -------------------------------------------------------------------------

enum EError_T {
    NO_ERR=0,
    ERROR_M=1,
    ERROR_BW=2,
    ERROR_BW_MARGIN=3,
    ERROR_W=4,
    ERROR_DATA_IMAGES=5,
    ERROR_DATA_MAPTABLE=6,
    ERROR_DATA_LBP=7,
    ERROR_DATA_OPTIONS_S=8,
    ERROR_DATA_OPTIONS_PSIG=9,
    UNKNOWN_ERROR=100
};

// read / write structure Model from / to file procedures

FLANDMARK_Model * flandmark_init(const char* filename);

void flandmark_write_model(const char* filename, FLANDMARK_Model* model);

EError_T flandmark_check_model(FLANDMARK_Model* model, FLANDMARK_Model* tst);

void flandmark_free(FLANDMARK_Model* model);

// getPsiMat (calls LBP features computation - liblbpfeatures from LIBOCAS)
void flandmark_get_psi_mat(FLANDMARK_PSI* Psi, FLANDMARK_Model* model, int lbpidx);

void flandmark_get_psi_mat_sparse(FLANDMARK_PSI_SPARSE* Psi, FLANDMARK_Model* model, int lbpidx);

// dot product maximization with max-index return
void flandmark_maximize_gdotprod(double *maximum, double *idx, const double *first, const double *second, const int *third, const int cols, const int tsize);

int flandmark_get_normalized_image_frame(IplImage *input, const int bbox[], double *bb, uint8_t *face_img, FLANDMARK_Model *model);

int flandmark_imcrop(IplImage *input, IplImage *output, const CvRect region);

void flandmark_argmax(double *smax, FLANDMARK_Options *options, const int *mapTable, FLANDMARK_PSI_SPARSE *Psi_sparse, double **q, double **g);

int flandmark_detect_base(uint8_t *face_image, FLANDMARK_Model *model, double *landmarks);

int flandmark_detect(IplImage *img, int * bbox, FLANDMARK_Model *model, double *landmarks, int * bw_margin = 0);

std::vector<double> flandmark_detect
(
    const Image& img, 
    const Axis_aligned_rectangle_2d& box, 
    FLANDMARK_Model* model, 
    int * bw_margin = 0
);

}} //namespace kjb::flandmark

#endif /* KJB_HAVE_OPENCV */
#endif /* KJB_LIBFLD_DETECTOR_H_ */