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,
    CALC_SCENE_DETECTION = 512, 
    CALC_COMPOSITE = 1024,       
    CALC_SKINTONE = 2048,        
    CALC_AICOLOR = 4096     
} PFCFEATURE;
 
typedef enum {
    PRESET_NONE = -1, 
    PRESET_BEAUTIFY, 
    PRESET_BEAUTIFYPLUS, 
    PRESET_DETAILS, 
    PRESET_VIVID, 
    PRESET_INTELLIGENTAUTO, 
    PRESET_IAUTO_2019, 
    PRESET_IAUTO_2019_RE, 
    PRESET_IAUTO_21, 
    PRESET_IAUTO_21_ASIA, 
    PRESET_IAUTO_PEOPLE 
} 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,  
    APPLY_LOOKS_MISSING = -12, 
    APPLY_ERROR_AI_CORRECTION_MISSING = -13 
} PFCAPPLYSTATUS;
 
typedef enum {
    PFC_REJECT_NONE = 0,     
    PFC_REJECT_MONOLITH = 1, 
    PFC_REJECT_CLIPART =  2  
} PFCREJECTOPTION;
 
typedef enum {
    PFC_COMPOSITE_FAILED = -3,  
    PFC_COMPOSITE_SKIP = -2,    
    PFC_COMPOSITE_PHOTO = -1,   
    PFC_COMPOSITE_TYPE_0 = 0,   
    PFC_COMPOSITE_TYPE_1 = 1,    
    PFC_COMPOSITE_V2_0 = 2,    
    PFC_COMPOSITE_V2_1 = 3,    
    PFC_COMPOSITE_V2_2 = 4     
} PFCCOMPOSITE;
 
typedef struct {
    int r;          // start of Hue range ramp
    int a;          // start of flat part of Hue range
    int m;          // end of flat part of Hue range
    int p;          // end of Hue range ramp
    int H;          // shift of Hue, -180 .. 180
    int S;          // correction of S, -100 .. 100
    int L;          // correction of L, -100 .. 100
} SELECTIVECOLOR;
 
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;                    
    int iMinStrength;                       
    int iSkintoneType;                      
    int iSkintoneStrengthLut;               
    int iSkintoneStrengthExposure;          
    BOOL bSkintoneAuto;                      
    int iSkintoneAutoStrength;              
    int iSplitColorWarm;                    
    int iSplitColorCold;                    
    BOOL bSelectiveColor;                   
    SELECTIVECOLOR selectiveColor[8];       
} 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;                     
    unsigned int colorSkinToning;   
    unsigned int colorBlush;        
} 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;   
    int iDarkSkin;        
    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;    
 
    BOOL bDynamic;              
    int iDynamic;               
    int iDynamicWB;             
 
    int iOutLUTcontrast;        
    int iOutLUTsaturation;      
} PFCV3PARAM;
 
typedef struct {
    int iDensity;       
    int iDeltaR;        
    int iDeltaG;        
    int iDeltaB;        
    float fGamma;       
    int iContrast;      
    int iSaturation;    
    int mode;           
    BOOL bAuto;         
    BOOL bEnable;       
} DP2PARAM;
 
typedef struct {
    PFCCOREPARAM core;   
    PFCFBPARAM fb;   
    PFCNRPARAM nr;   
    PFCREPARAM re;   
#ifndef NO_V3PARAM
    PFCV3PARAM v3;   
    PFCV3PARAM layer[3]; 
    PFCCOREMask mask[3]; 
#endif
    DP2PARAM dp2;
} 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_PEOPLE);
 
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, PFCENGINE* pEngineAI=NULL, BOOL bUseAutoSDPreset = FALSE);
 
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, PFCENGINE* pEngineAI=NULL);
 
 
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();
 
 
 
void PFC_LoadAddonLooks(PFCENGINE *pEngine, const char *addonLooksBuf, int buflen);
 
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);
 
int PFC_AutoCorrectPreset(PFCIMAGE *pImage, PFCIMAGE *pImageds, PFCPRESETID id=PRESET_IAUTO_PEOPLE, int iISO=-1, char *pCameraModel=NULL, BOOL bFastFAE=FALSE, PFC_PROGRESS progfn=NULL, PFCENGINE* pEngineAI=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);
 
typedef enum {
    AI_SCENE_DETECTION = 1, 
    AI_CORRECTIONS = 2,     
    AI_COMPOSITE = 4,       
    AI_SKINTONE = 8,        
    AI_COLOR = 16           
} PFCAIFEATURE;
 
int PFC_LoadAIEngine(PFCENGINE* pEngineAI, unsigned int aifeatures, const char *binPath);
 
int PFC_LoadAIEngineNative(PFCENGINE* pEngineAI, unsigned int aifeatures, const char *modelDynamic, int lenDynamic, const char *modelSD, int lenSD, const char *modelSkintone, int lenSkintone, const char *modelAicolor, int lenAicolor, int bUseAngroidGPU, const char *apikey, const char *certificate, int *statusCertificate);
 
 
int PFC_LoadScenePresets(PFCENGINE* pEngine, const char *filePath, int modelUuid = 0, int *presetUuid = NULL, int arrProfileUUIDLen = 0);
 
int PFC_LoadScenePresetsFromStream(PFCENGINE* pEngine, const char *buf, int lenBuf, int modelUuid = 0, int *presetUuid = NULL, int arrProfileUUIDLen = 0);
 
 
int PFC_ReadScenePreset(PFCPARAM &param, PFCENGINE *pEngineAI, int scene);
 
int PFC_GetScene(PFCPROFILE precalc, int *version);
 
 
bool PFC_GetSceneDetectionEngineInfo(PFCENGINE* pEngine,int *groupUUID, int *arrProfileUUID, int *arrProfileUUIDLen);
 
typedef struct {
    char name[250]; 
    int profileUUID; 
} PFCSCENEDESCRIPTION;
 
bool PFC_GetSceneDescription(PFCENGINE* pEngine, int index, PFCSCENEDESCRIPTION* sceneDescription);
 
 
void PFC_GetLastSceneProperties(PFCENGINE* pEngine, int* lastSceneLabel, int* lastSceneConfidence = NULL);
 
int PFC_DetectCompositeImage(PFCIMAGE *pImage, PFCENGINE* pEngine);
 
const char* PFC_GetAutoSkintoneParameters(int skintoneType, int *strengthLut, int *strengthExposure);
 
PFCAPPLYSTATUS PFC_FillAiAutoValues(PFCPARAM &param, PFCIMAGEPROFILE *profile);
 
#ifdef EYEQINTERNAL
#include "../Header-internal/PerfectlyClearPro-internal.h"
#endif
 
#ifdef __cplusplus
}
#endif
#endif //__PERFECTLYCLEARPRO_H__