PerfectlyClearPro.h

Go to the documentation of this file.

#ifndef __PERFECTLYCLEARPRO_H__
#define __PERFECTLYCLEARPRO_H__
#ifdef __cplusplus
extern "C" {
#endif

#ifdef _LINUX
#define BOOL int
#define ULONG unsigned long
#define UINT  unsigned int
#define TRUE  1
#define FALSE 0
//#define NULL  0
#endif

#define NRRETCODE(x) (x & 0x000000FF)
#define CORERETCODE(x) ((x >> 8) & 0x000000FF)
#define FBRETCODE(x) ((x >> 16) & 0x000000FF)
#define RERETCODE(x) ((x >> 24) & 0x000000FF)
#define PFCINTERNAL void*

typedef BOOL (*PFC_PROGRESS)(int iPercent);

typedef enum {
    PFC_PixelFormat24bppRGB,
    PFC_PixelFormat24bppBGR,
    PFC_PixelFormat32bppABGR,
    PFC_PixelFormat48bppRGB,
    PFC_PixelFormat64bppARGB,
    PFC_PixelFormat32bppARGB,
    PFC_PixelFormat48bppBGR,
    PFC_PixelFormat64bppABGR
} PFCPIXELFORMAT;

typedef enum {
    ENGINESTATUS_OK = 0,                                        
    ENGINESTATUS_FB_LIBRARY_LOAD_FAIL = 1,  
    ENGINESTATUS_FB_FUNCTION_NOT_FOUND = 2  
} PFCENGINESTATUS;

typedef enum {
    CALC_CORE = 1,          
    CALC_NR = 2,            
    CALC_FB = 4,            
    CALC_RE = 8,            
    CALC_ALL = 15,          
    CALC_NOTINTCALC = 16,   
    CALC_NOFAE = 32,        
    CALC_FAEHISPEED = 64,   
    CALC_CARTOON_DETECTOR = 128,
    CALC_SHARP = 256
} PFCFEATURE;

typedef enum {
    PRESET_BEAUTIFY, 
    PRESET_BEAUTIFYPLUS, 
    PRESET_DETAILS, 
    PRESET_VIVID, 
    PRESET_INTELLIGENTAUTO, 
    PRESET_IAUTO_2019, 
    PRESET_IAUTO_2019_RE 
} PFCPRESETID;

typedef struct {
    int x; 
    int y; 
}
PFCPOINT;

typedef struct {
    int left; 
    int top;  
    int width;  
    int height; 
}
PFCRECT;

typedef struct {
    PFCPOINT leftEye;   
    PFCPOINT rightEye;  
    PFCRECT  face;      
}
PFCFBFACEINFO;

typedef struct PFCFaceRect{
    PFCRECT rect;       
    PFCRECT rcEyeL;     
    PFCRECT rcEyeR;     
    PFCRECT rcMouth;    
    PFCPOINT ptEyeL;    
    PFCPOINT ptEyeR;    
    int angle;          
    int blinkLevel;     
    int blinkLevelL;    
    int blinkLevelR;    
    int childLevel;     
    int confidence;     
    int smileLevel;     
    int yawAngle;       
    int FAE[3];         
    int widthImage;     
    int heightImage;    
    struct PFCFaceRect *pNext;  
} PFCFACERECT;
typedef PFCFACERECT* LPPFCFACERECT;

typedef struct {
    PFCINTERNAL pEngine;    
    PFCENGINESTATUS status; 
} PFCENGINE;

typedef struct {
    int width;              
    int height;             
    int stride;             
    PFCPIXELFORMAT format;  
    unsigned char *data;    
} PFCIMAGE;

typedef enum {
    TINTCORRECT_AGGRESSIVE,     
    TINTCORRECT_DEFAULT,        
    TINTCORRECT_CONSERVATIVE,   
    TINTCORRECT_STRONGEST       
}
TINTCORRECTION;

typedef enum {
    HIGH_CONTRAST,      
    HIGH_DEFINITION     
}
CONTRASTMODE;

typedef enum {
    DCF_STANDARD,   
    DCF_VIVID       
}
DCFMODE;

typedef enum {
    AGGRESSIVENESS_CONSERVATIVE,    
    AGGRESSIVENESS_MODERATE,        
    AGGRESSIVENESS_AGGRESSIVE       
}
AGGRESSIVENESS;

typedef enum {
    BIAS_NONE,                  
    BIAS_ASIAN_PREFERENCE,      
    BIAS_AVERAGE_PREFERENCE,    
    BIAS_BRIGHTER_PREFERENCE,   
    BIAS_DONT_BOTHER,           
    BIAS_AUTO                   
}
BIASMODE;

typedef enum {
    SKINMODE_FACE = 1,  
    SKINMODE_BODY       
}
SKINMODE;

typedef enum {
    SKINSMOOTHTYPE_SUBTLE = 1,  
    SKINSMOOTHTYPE_DEFAULT,     
    SKINSMOOTHTYPE_SUPERSMOOTH  
}
SKINSMOOTHTYPE;

typedef enum {
    SKINTONINGTYPE_WHITE = 1,   
    SKINTONINGTYPE_PALE,        
    SKINTONINGTYPE_WARM,        
    SKINTONINGTYPE_TAN,         
    SKINTONINGTYPE_FOUNDATION   
}
SKINTONINGTYPE;

typedef enum {
    LIPSHARPENTYPE_FINE = 1,    
    LIPSHARPENTYPE_MEDIUM,      
    LIPSHARPENTYPE_COARSE       
}
LIPSHARPENTYPE;

typedef enum {
    PFC_NR_SUCCESS,             
    PFC_NR_NOTENABLED,          
    PFC_NR_FULLRES_REQUIRED,    
    PFC_NR_CANCELLED,           
    PFC_NR_ERRBITMAP,           
    PFC_NR_ERRSETTINGS,         
    PFC_NR_MISC_ERROR,          
    PFC_NR_NOTFOUND             
} PFCNR_STATUS;

typedef enum {
    PFC_CORE_SUCCESS,               
    PFC_CORE_NOTENABLED,            
    PFC_CORE_CANCELLED,             
    PFC_CORE_NOSOURCEIMAGE,         
    PFC_CORE_INSUFFICIENTMEMORY,    
    PFC_CORE_MONOLITHIMAGE,         
    PFC_CORE_BELOWMINSIZE,          
    PFC_CORE_CLIPARTIMAGE           
} PFCCORE_STATUS;

typedef enum {
    PFC_FB_SUCCESS,                 
    PFC_FB_NOTENABLED,              
    PFC_FB_WARNING,                 
    PFC_FB_FULLRES_REQUIRED,        
    PFC_FB_CANCELLED,               
    PFC_FB_FUNCTION_ERROR,          
    PFC_FB_CREATE_ENGINE_FAILED,    
    PFC_FB_ANALYSIS_FAILED,         
    PFC_FB_NO_CORRECTION,           
    PFC_FB_NOT_EXECUTED,            
    PFC_FB_NOT_AVAILABLE            
} PFCFB_STATUS;

typedef enum {
    PFC_RE_SUCCESS,                 
    PFC_RE_NOTENABLED,              
    PFC_RE_FULLRES_REQUIRED,        
    PFC_RE_NOT_FOUND,               
    PFC_RE_GEN_ERROR,               
    PFC_RE_INVALID_PARAMETER,       
    PFC_RE_NO_MEMORY,               
    PFC_RE_CANCELLED,               
    PFC_RE_NOT_SUPPORTED            
} PFCRE_STATUS;

typedef enum {
    APPLY_SUCCESS = 0,                  
    APPLY_ERROR_PROFILE_MISSING = -1,   
    APPLY_ERROR_ENGINE_MISSING = -2,    
    APPLY_CANCELLED = -3,               
    APPLY_NOSOURCE = -4,                
    APPLY_BADFORMAT = -5,               
    APPLY_INVALIDLICENSE = -6,          
    APPLY_WASM_INVALID_DOMAIN = -7,     
    APPLY_WASM_INVALID_APIKEY = -8,     
    APPLY_WASM_INVALID_CERTIFICATE = -9, 
    APPLY_WASM_EXPIRED_CERTIFICATE = -10,   
    APPLY_WASM_CERTIFICATE_WRONG_VERSION = -11  
} PFCAPPLYSTATUS;

typedef enum {
    PFC_REJECT_NONE = 0,     
    PFC_REJECT_MONOLITH = 1, 
    PFC_REJECT_CLIPART =  2  
} PFCREJECTOPTION;

typedef struct {
    BOOL bEnabled;                          
    BOOL bAbnormalTintRemoval;              
    TINTCORRECTION eTintMode;               
    float fTintScale;                       
    int iBlackEnhancement;                  
    BOOL bVibrancy;                         
    int iVibrancy;                          
    int iStrength;                          
    BOOL bContrast;                         
    CONTRASTMODE eContrastMode;             
    int iContrast;                          
    BIASMODE eBiasMode;                     
    float   fBiasScale;                     
    int iHighlightPreservation;             
    BOOL bHighlightPreservation;            
    BOOL bSharpen;                          
    float fSharpenScale;                    
    BOOL bUseAutomaticStrengthSelection;    
    BOOL bUseFAE;                           
    AGGRESSIVENESS eAggressiveness;         
    int iMaxStrength;                       
    BOOL bInfrared;                         
    float fInfrared;                        
    BOOL  bLightDiffusion;                  
    float fLightDiffusion;                  
    BOOL  bDynamicRange;                    
    BOOL  bDCF;                             
    DCFMODE eDCFMode;                       
    float fDCF;                             
    int iLocalContrast;                     
    BOOL bLocalContrast;                    
} PFCCOREPARAM;

typedef struct {
    BOOL bEnabled;                  
    BOOL bSmooth;                   
    int iSmoothLevel;               
    SKINMODE eSmoothMode;           
    SKINSMOOTHTYPE eSmoothType;     
    BOOL bEnlarge;                  
    int iEnlargeLevel;              
    BOOL bEnhance;                  
    int iEnhanceLevel;              
    BOOL bEyeCirc;                  
    int iEyeCirc;                   
    BOOL bTeeth;                    
    int iTeethLevel;                
    BOOL bBlemish;                  
    int iBlemish;                   
    BOOL bSlim;                     
    int iSlim;                      
    BOOL bDeFlash;                  
    int iDeFlash;                   
    BOOL bCatchLight;               
    int iCatchLight;                
    int iCatchLightMode;            
    BOOL bSkinToning;               
    int iSkinToning;                
    SKINMODE eSkinToningMode;       
    SKINTONINGTYPE eSkinToningType; 
    BOOL bLipSharpen;               
    int iLipSharpen;                
    LIPSHARPENTYPE eLipSharpenType; 
    BOOL bBlush;                    
    int iBlush;                     
} PFCFBPARAM;

typedef struct {
    BOOL bEnabled;          
    int iPreset;            
    int iStrengthOffset;    
    int iDetailOffset;      
} PFCNRPARAM;

typedef struct {
    BOOL bEnabled;          
} PFCREPARAM;

#define PFC3DLutGuidLength 32
typedef struct {
    char guid[PFC3DLutGuidLength + 1];  
    unsigned char strength;             
} PFC3DLutInfo;

enum PFCCORE_MASK_TYPE {
    MASK_NONE,            
    MASK_ALL,             
    MASK_RADIAL,          
    MASK_TOP,             
    MASK_BOTTOM,          
    MASK_ROUNDRECT        
};

typedef struct PFCCOREMask
{
    PFCCORE_MASK_TYPE type;
    float centerX;              
    float centerY;              
    float width;                
    float height;               
    float radius;               
    float feather;              
    float angle;                
    float transparency;         
    bool  invert;               
    // if two layers (top and bottom) - swap params between layers instead.
} PFCCOREMask;

typedef struct {
    // Image Ambulance
    bool bPreprocessEV;   
    int iPreprocessEV;   

    // built-in 3D luts
    int iNeutralDensity;   
    int iColorVibrancy;   
    PFC3DLutInfo lutInputCorrective;   
    PFC3DLutInfo lutInputSky;   
    PFC3DLutInfo lutInputFoliageGreen;   
    PFC3DLutInfo lutInputFoliageBrown;   
    // custom output 3D Lut
    PFC3DLutInfo lutOutput;   

    // Finishing
    int iFinishTemp;   
    int iFinishTint;   
    int iFinishExposure;   
    int iFinishBlacks;   
    int iFinishShadows;   
    int iFinishHighlights;   
    int iFinishWhites;   
    int iFinishSaturation;   
    int iFinishVibrancy;   
    int iFinishContrast;   
    int iFinishPositiveContrast;    

    int iDeltaR;    
    int iDeltaG;    
    int iDeltaB;    
} PFCV3PARAM;

typedef struct {
    PFCCOREPARAM core;   
    PFCFBPARAM fb;   
    PFCNRPARAM nr;   
    PFCREPARAM re;   
    PFCV3PARAM v3;   
#ifndef PFCCOREONLY
    PFCV3PARAM layer[3]; 
    PFCCOREMask mask[3]; 
#endif
} PFCPARAM;

typedef struct {
    PFCINTERNAL pPfcParam;   
    PFCINTERNAL pNoiseParam;   
    PFCINTERNAL pRedEyeParam;   
    PFCINTERNAL pSFBParam;   
    PFCINTERNAL pInternal;   

    PFCCORE_STATUS CORE_Status;   
    PFCNR_STATUS NR_Status;   
    PFCFB_STATUS FB_Status;   
    PFCRE_STATUS RE_Status;   

    int Status;   
} PFCIMAGEPROFILE;
#define PFCPROFILE PFCIMAGEPROFILE*

#define PFCBGPROFILE PFCINTERNAL

typedef struct {
    int iRawMaskMode; // 7
    int iBG;  // 0..100
    int iFG;    // 0 .. 100
    int iTolerance; // allow target I variation (similar to +- 8 logic)
    int iSobel;  // Sobel binarization threshold, 32
    int iBlur;
    bool bImfill;   // remove black holes
    bool bAreaopen; // do areaopen in black subject (remove white)
    int iAreaopen;  // size param in 1/10000 of w*h
    bool bAreaopenBG; // do areaopen in white BG (rem small blacks)
    int iAreaopenBG;
    int iConnectivity; // 8 or 4
    bool bGrad;         // add grad filter
    bool bGradAuto;     // fixed based on detected face bottom,
    int iGradBottom; // rel bottom
    int iGradHeight; // rel spread
    float avR;      // calculated average BG RGB
    float avG;
    float avB;
}
BGMASKPARAM;



int PFC_SetProtectionPath(const char*utf8FolderPath, const char* liceseCode = NULL);

void PFC_SetParam(PFCPARAM &param, PFCPRESETID id=PRESET_IAUTO_2019);

int PFC_ReadPresets(PFCPARAM &param, char *filename);

int PFC_AutoCorrect(PFCIMAGE *pImage, PFCIMAGE *pImageds, PFCPARAM &param, int iISO=-1, char *pCameraModel=NULL, BOOL bFastFAE=FALSE, PFC_PROGRESS progfn=NULL);

void PFC_ReleaseProtectionPath();




PFCENGINE* PFC_CreateEngine();

PFCPROFILE PFC_Calc(PFCIMAGE *pImage, PFCIMAGE *pImageds, PFCENGINE* pEngine, unsigned int feature=CALC_ALL, int iISO=-1, char *pCameraModel=NULL, PFCPROFILE pImageProfile=NULL, PFC_PROGRESS progfn=NULL, int iRejectOption=PFC_REJECT_CLIPART);


PFCAPPLYSTATUS PFC_Apply(PFCIMAGE *pImage, PFCENGINE *pEngine, PFCPROFILE pImageProfile, PFCPARAM &param, PFC_PROGRESS progfn=NULL, int iOpacity=100, void* pBGProfile=NULL);

void PFC_ReleaseProfile(PFCPROFILE pProfile);

void PFC_DestroyEngine(PFCENGINE* p);


void PFC_SetAddonPath(const char *utf8AddonPath);

void PFC_ReleaseAddonPath();

bool PFC_HasFaceBeautification(PFCENGINE *pEngine);

int PFC_FBFaceCount(PFCPROFILE pImageProfile);

int PFC_FAEFaceCount(PFCIMAGEPROFILE *pImageProfile);
bool PFC_GetFaceInfo(PFCIMAGEPROFILE *pImageProfile, PFCFBFACEINFO *pFace, int index);

LPPFCFACERECT PFC_EnumFAEFaceRect(PFCIMAGEPROFILE *pImageProfile, LPPFCFACERECT p);

bool PFC_IsNoiseDetected(PFCIMAGEPROFILE *pImageProfile, int iNoisePreset);

bool PFC_AbnormalTintDetected(PFCIMAGEPROFILE *pImageProfile, TINTCORRECTION eTintMethod);

PFCAPPLYSTATUS PFC_ApplyLocal(PFCIMAGE *pImage, int xOffset, int yOffset, int widthOrig, int heightOrig, PFCENGINE *pEngine, PFCPROFILE pImageProfile, PFCPARAM &param, int iOpacity=100);

int PFC_AutoCorrectPreset(PFCIMAGE *pImage, PFCIMAGE *pImageds, PFCPRESETID id=PRESET_IAUTO_2019, int iISO=-1, char *pCameraModel=NULL, BOOL bFastFAE=FALSE, PFC_PROGRESS progfn=NULL);


int PFC_ReadPresetsFromStream(PFCPARAM &param, const char *s);

void PFC_SetSingleThreadedEngine(PFCENGINE* p, bool bSingleThreaded);

void PFC_GetVersion(char* buf, int *len, bool bFormatted = false);

PFCAPPLYSTATUS PFC_Resize(PFCIMAGE *pImageSrc, PFCIMAGE *pImageDst);

PFCAPPLYSTATUS PFC_TransposeExif(PFCIMAGE *pImageSrc, int iEXIFOrientation);

void PFC_ApplyStrengthToParam(PFCPARAM &param, int strength);

int PFC_WasmSetCertificate(PFCENGINE* pEngine, const char *clientAPIKey, const char *certificate);

void PFC_TrackSave(const char *clientAPIKey);

void PFC_GetRecommendedParam(PFCIMAGEPROFILE *profile, PFCCOREPARAM *dst, PFCCOREPARAM *src);



#ifdef EYEQINTERNAL
#include "../Header-internal/PerfectlyClearPro-internal.h"
#endif

#ifdef __cplusplus
}
#endif
#endif //__PERFECTLYCLEARPRO_H__