
#ifndef __RV_PPRS_H_INCLUDED_
#define __RV_PPRS_H_INCLUDED_


 

#define PPRS_API  WINAPI


 #include <rvb\rvtypes.h>
 
 




 

//边缘查找类型 EDT 
#define RV_EDT_SOBEL        0
#define RV_EDT_ZEROCROSS    1
 

 

//bitwise operation
#define RV_PM_ADD         (0+1204)
#define RV_PM_SUB         (1+1204)
#define RV_PM_XOR         (2+1204)
#define RV_PM_AND         (3+1204)
#define RV_PM_OR          (4+1204)
#define RV_PM_SMALL       (5+1204)
#define RV_PM_LARGE       (6+1204)
#define RV_PM_COPY        (7+1204)
#define RV_PM_DIFF        (8+1204) //ABS(A-B)

#define RV_PM_ADD_E         0 //加
#define RV_PM_SUB_E         1 //减
#define RV_PM_ABS_E         2 //差的绝对值
#define RV_PM_MUL_E         3 //乘
#define RV_PM_DIV_E         4 //除 
#define RV_PM_AND_E         5 //与 
#define RV_PM_OR_E          6 //或
#define RV_PM_XOR_E         7 //异或 
#define RV_PM_GREAT_E       8 //大值 
#define RV_PM_LESS_E        9 //小值 






#define RV_PM_XOR         (2+1204)
#define RV_PM_AND         (3+1204)
#define RV_PM_OR          (4+1204)
#define RV_PM_SMALL       (5+1204)
#define RV_PM_LARGE       (6+1204)
#define RV_PM_COPY        (7+1204)
#define RV_PM_DIFF        (8+1204) //ABS(A-B)
 
//rvb threshold action
#define RTA_SIMPLE      0
#define RTA_OBJ_SIZE    1
#define	RTA_BACKGND     2
#define RTA_FOREGND     3
#define RTA_RANGE       4
#define RTA_RANGE_EX    5
#define RTA_LOCAL       6
#define RTA_GLOBAL      7


 

//manual thresholding
extern "C" RvImage PPRS_API rvbSimple(RvImage image, RvByte level, BOOL bReverse=FALSE );

//待实现: 将等于值设置为BIN_ONE，其它值为BIN_ZERO
extern "C" RvImage PPRS_API rvbSimpleE1(RvImage image, RvByte level, BOOL bReverse=FALSE );

extern "C" RvImage PPRS_API rvbDark(RvImage image, RvByte level, RvByte newVal = RV_BIN_ONE, BOOL bBin=TRUE);
extern "C" RvImage PPRS_API rvbLight(RvImage image, RvByte level, RvByte newVal = RV_BIN_ONE, BOOL bBin=TRUE);
extern "C" RvImage PPRS_API rvbInner(RvImage image, RvByte low, RvByte high, RvByte newVal = RV_BIN_ONE, BOOL bBin=TRUE);
extern "C" RvImage PPRS_API rvbOuter(RvImage image, RvByte low, RvByte high, RvByte newVal= RV_BIN_ONE , BOOL bBin=TRUE);


//auto thresholding
extern "C" RvImage PPRS_API rvbLocalIntegral(RvImage image, int winSize, RvByte maxStd, float range);
extern "C" RvImage PPRS_API rvbMultiLevel(RvImage image, int levels);
extern "C" RvImage PPRS_API rvbMaxEntropy(RvImage image );
extern "C" RvImage PPRS_API rvbIsoData(RvImage image, int step, int kernelSize );//suggest 5 for default ;





#define RV_ME_GAUSSIAN    0
#define RV_ME_POINSSEN    1
extern "C" RvImage PPRS_API rvbMinError(RvImage image, int mode);

extern "C" RvImage PPRS_API rvbMinErrorE1(RvImage image, const RvMask mask, int mode);

extern "C" RvImage PPRS_API rvbOtsu(RvImage image, const RvMask mask = NULL);




//binarize type
#define RV_BT_SIMPLE   0x0
#define RV_BT_DARK     0x1
#define RV_BT_LIGHT    0x2
#define RV_BT_INNER    0x3
#define RV_BT_OUTER    0x4
#define RV_BT_LOCAL_INTEGRAL    0x10
#define RV_BT_MULTI_LEVEL       0x11
#define RV_BT_MAX_ENTROPY       0x12
#define RV_BT_ISO_DATA          0x13
#define RV_BT_MIN_ERROR         0x14
#define RV_BT_OTSU              0x15

//不同参数含义
//RV_BT_SIMPLE: option1 - 阈值, option2 -忽略， options3-忽略
//RV_BT_DARK  : option1 - 阈值, option2 -忽略， options3-忽略
//RV_BT_LIGHT  : option1 - 阈值, option2 -忽略， options3-忽略
//RV_BT_INNER  : option1 - 暗对象阈值, option2 -亮对象阈值， options3-忽略
//RV_BT_OUTER  : option1 - 暗对象阈值, option2 -亮对象阈值， options3-忽略
//RV_BT_LOCAL_INTEGRAL:  option1 - 窗口大小（）, option2 -最大的标准差， options3-范围（建议0.25）
//RV_BT_MULTI_LEVEL   :  option1 - 目标灰度级, option2 -忽略， options3-忽略
//RV_BT_MAX_ENTROPY   :  option1 - 忽略, option2 -忽略， options3-忽略
//RV_BT_ISO_DATA      :  option1 - 步长, option2 -内核大小， options3-忽略
//RV_BT_MIN_ERROR      :  option1 - 方法(0为高斯，1-波生）, option2 -忽略， options3-忽略
//RV_BT_OTSU      :    大津

extern "C" void PPRS_API  rvThreshold(RvImage image, int method, int option1, int option2  , double option3 );

//auto-binarizing method
#define RV_AB_GAUSS           0
#define RV_AB_POINSON         1
#define RV_AB_ENTROPY         2
#define RV_AB_MAJORITY        3
#define RV_AB_OTSU            4
extern "C" RvByte PPRS_API rvbGetOptima(RvImage image, int method);

extern "C" RvByte PPRS_API rvbGetOptimaE1(const RvImage image, const RvMask mask, int method);

//	同一个位置的每一个像素加起来，结果保存在image1。
extern "C" RvImage PPRS_API   rvPixelAdd(const RvImage image0, RvImage image1);
//将两个图像中的像素相减，结果保存在image1。
extern "C" RvImage PPRS_API  rvPixelSubtract(const RvImage image0, RvImage image1 );	
extern "C" RvImage PPRS_API   rvPixelDiff(const RvImage image0, RvImage image1 );	

//取pick中较大的像素值，结果保存在image1. 
extern "C" RvImage PPRS_API   rvPixelLarge(const RvImage image0, RvImage image1);	
//取pick中较小的像素值，结果保存在image1.
extern "C" RvImage PPRS_API   rvPixelSmall(const RvImage image0, RvImage image1);
//将裁片中同一区域的像素进行逻辑异或，结果保存在image1.	
extern "C" RvImage PPRS_API   rvPixelXor(const RvImage image0, RvImage image1);	
//将裁片中同一区域的像素进行逻辑和，结果保存在image1.
extern "C" RvImage PPRS_API   rvPixelAnd(const RvImage image0, RvImage image1);	
//将裁片中同一区域的像素进行逻辑或，结果保存在image1.
extern "C" RvImage PPRS_API  rvPixelOr(const RvImage image0, RvImage image1);	

//将裁.
extern "C" RvImage PPRS_API  rvPixelCopy(const RvImage image0, RvImage image1);	


extern "C" RvImage PPRS_API  rvPixelMerge(const RvImage image0,   RvImage image1,   int type);

//n = (i1 op i2) * alpha + beta
//and or, xor 不计算alph和beta
//结果保存在image0
extern "C" RvImage PPRS_API  rvPixelMergeE1(const RvImage image0,  const  RvImage image1,   int type, float alpha, float beta);	


//在指定位置更改像素颜色
extern "C" void PPRS_API     rvSetPixel(RvImage image,   int x, int y,   RvColor color);	

extern "C" void PPRS_API     rvSetPixelE1(RvImage image,  RvPoint* pPtArr, int arrSize, int dx, int dy, RvColor color);	


//将指定的像素颜色填充整个图象，支持模板。
extern "C" void PPRS_API     rvSetPixelEx(RvImage image,  RvColor color, const  RvMask mask = NULL,   BOOL bOutside = FALSE);	
extern "C" RvColor PPRS_API  rvGetPixel(RvImage image,   int x, int y);	

extern "C" RvColor PPRS_API  rvGetPixelE1(RvImage image,   int x, int y, int aperture);	


extern "C"  void   PPRS_API rvCopyPixels(const RvImage src, int sx, int sy , int sw , int sh , RvImage dest,
						 	             int dx=0, int dy=0, int dw=-1, int dh=-1);

extern "C"  void   PPRS_API rvCopyPixelsE2(const RvImage src,  RvImage dest, int dx=0, int dy=0, RvMask mask = NULL);

extern "C"  void   PPRS_API rvCopyPixelsE3(const RvImage src,  RvImage dest, RvPoint_f vertex[4]);


extern "C"  void   PPRS_API rvReplacePixels(  RvImage image, RvColor target, GColor newColor, const RvMask mask = NULL);

 

//替换通道图。
//image 和imChannel的大小必需一样
//image支持rgb或rgba
//sub支持bin 或gray， rgb。
//如果rgb，只能替换ch1,ch2,ch3,替换的通道与image的通道对应。
//支持多通道同时替换.
extern "C"  RvImage   PPRS_API rvReplaceChannel(  RvImage image,  const RvImage sub, int channel = RV_COLOR_CH1);

extern "C"  RvImage  PPRS_API     rvFill(RvImage image, int x, int y,   RvColor nNewValue);

//待实现:将启动点开始替换指定颜色，如果指定点颜色不是目标颜色，退出
extern "C"  RvImage  PPRS_API     rvFillE1(RvImage image, int x, int y,  RvColor targetColor,  RvColor newColor);


extern "C"  RvImage  PPRS_API     rvClip(RvImage image, int left, int top, int right, int bottom) ;


#define RV_FF_DEFAULT_RANGE   0
#define RV_FF_FIXED_RANGE     (1 << 16) 
#define RV_FF_CONN4    4
#define RV_FF_CONN8    8

//如果mask为NULL,如果成功调用， 将创建一个新的image.
extern "C"  RvImage  PPRS_API rvFloodMask(const RvImage image, GPoint pos,  RvScalar_f64 lower, RvScalar_f64 upper, int connectivity = RV_FF_CONN4, int flags =0 , RvImage imMask = NULL) ;
extern "C"  void  PPRS_API rvFloodFill(RvImage image, GPoint pos, RvRgb newColor, RvScalar_f64 lodiff, RvScalar_f64 updiff, int connectivity =RV_FF_CONN4, int flags =0 );



//channel 为通道索引，如果image为RIT_BIN或RIT_GRAY,则channel为0~0;
//channel 为通道索引，如果image为RIT_RGB,则channel为0~2;
//channel 为通道索引，如果image为RIT_RGBA,则channel为0~3;
//如果设置第一个通道: channel = RV_COLOR_CH1,如果同时设置第1，2个通道channel =  RV_COLOR_CH2 | RV_COLOR_CH1
extern "C"  void  PPRS_API     rvFillEx(RvImage image, int channel,   RvByte nNewValue);

//填充矩形
extern "C"  void  PPRS_API     rvFillRect(RvImage image, RvRect rect, RvColor nNewValue);
//仅填充灰度或bin,（快速）
//nNewValue: RV_BIN_ONE or RV_BIN_ZERO for BIN, 0~255 for gray
extern "C"  void  PPRS_API     rvFillRectE1(RvImage image, RvRect rect, RvColor nNewValue);

//填充四周像素点 
extern "C"  void  PPRS_API     rvFillBorder(RvImage image,  RvColor nNewValue);



//填充椭圆
extern "C"  void  PPRS_API     rvFillEllipse(RvImage image, int left, int top, int right, int bottom, RvColor nNewValue);
extern "C"  void  PPRS_API     rvFillEllipseE1(RvImage image, RvBox2D box, RvColor nNewValue);


//填充多边形
extern "C"  void  PPRS_API     rvFillPolygon(RvImage image, RvPoint* pVertexArray, int nArraySize, RvColor nNewValue); 

//可以包含空洞
extern "C"  void  PPRS_API     rvFillPolygonE1(RvImage image, RvPoint* pVertexArray, int nArraySize, RvPoint* pHoleArray, int nHoleSize, RvColor nNewValue); 

//rvFillPolygonE2要求图像颜色为单一色。否则，进行FILL将可能不正常。
extern "C" void  PPRS_API     rvFillPolygonE2(RvImage image, RvPoint* pVertexArray, int nArraySize, RvColor nNewValue, BOOL bFill);


extern "C"  void  PPRS_API     rvSetPolyline(RvImage image, RvPoint* pVertexArray, int nArraySize, RvColor nNewValue); 



//画直线
extern "C"  void  PPRS_API     rvSetLine(RvImage image, RvPoint p0, RvPoint p1,  RvColor nNewValue);

//画圆
//radius0 为水平半径， radius1为垂直半径
extern "C"  void  PPRS_API     rvSetEllipse(RvImage image, int cx, int cy, int rx, int ry, float angle, RvColor nNewValue);


 

//根据像素尺寸大小，对图象进行调整，保证像素的大小是正方形，。如果大小进行了调整，返回TRUE，否则返回FALSE。
//调整方向是窄边拉伸。
extern "C"   BOOL PPRS_API rvMakeSquarePixel(RvImage image, int pixelSizeX, int pixelSizeY, int filterType, BOOL bShrink=FALSE ); 


//for gabor filtering
//minAngle: 支持的最小角度,如果为1, 表示有180 /1 
//
extern "C"  RvMatrix  PPRS_API     rvCreateGaborBank(double minAngle, int minWaveLen, int maxWaveLen );
extern "C"  RvMatrix  PPRS_API     rvDestroyGaborBank(RvMatrix gaborBank );

extern "C"  RvMatrix  PPRS_API     rvOrientationField(RvImage image, RvMatrix result = NULL);
extern "C"  RvMatrix  PPRS_API     rvFrequenceField(RvImage image,  RvMatrix matOriField = NULL, RvMatrix result = NULL);

extern "C"  void PPRS_API rvGabor(RvImage image, const RvMatrix gaborBank);

//scale 
extern "C" BOOL  PPRS_API      rvScale(RvImage image, float scaleRate, int flag=RV_FM_NEAREST);

extern "C" RvImage  PPRS_API   rvScaleE1(RvImage image, float scaleRate, RvColor fillColor,  int flag=RV_FM_NEAREST, BOOL  bReserveDim=FALSE);

//imgNew为虚拟图像，将不处理。返回失败
extern "C"  BOOL PPRS_API      rvScaleEx(RvImage imgOri, RvImage imgNew , int flag=RV_FM_NEAREST);




//直接截取，不够的填指定颜色
extern "C"  RvImage PPRS_API  rvResize(RvImage image, int width, int height, RvColor fillColor);

//直接缩放成指定大小，双线性插值
extern "C"  RvImage PPRS_API  rvResizeE1(RvImage image, int width, int height, int flag=RV_FM_BILINEAR);

////旋转90度倍数, 为负数的时候，反方向旋转	
extern "C"  RvImage PPRS_API  rvRotate(RvImage image, int times);

//旋转任意角度  
extern "C"  RvImage  PPRS_API rvRotateEx(RvImage image, double angle, BOOL bNearest=TRUE,BOOL bReserveDim=TRUE );

//旋转任意角度,支持特性颜色填充 
extern "C"  RvImage  PPRS_API rvRotateE2(RvImage image, double angle, RvColor fillColor, BOOL bNearest=TRUE, BOOL bReserveDim=TRUE );

//针对图像中任意点，旋转任意角度,支持特性颜色填充 
//仅支持1或3个通道
extern "C"  RvImage  PPRS_API rvRotateE3(RvImage image, double cx, double cy, double angle, RvColor fillColor );

//clock wise
extern "C"  RvImage  PPRS_API rvRotateCw(RvImage image, double angle, RvColor fillColor, BOOL bNearest=TRUE, BOOL bReserveDim=TRUE  );



//对选定的方向进行镜像。
extern "C" RvImage PPRS_API  rvFlip(RvImage image, int direct);	
extern "C" RvImage PPRS_API     rvInvert(RvImage image);

//	按照将ROI移动一定位置，实现ROI精确对齐
extern "C" RvImage PPRS_API   rvTranslate(RvImage image, float dx, float dy,  BOOL bNearest=TRUE);
extern "C" RvImage PPRS_API   rvTranslateE1(RvImage image, double dx, double dy, RvColor fillColor );





//将图象规范成指定平均和方差的图象。 
extern "C" RvImage PPRS_API   rvNormalize(RvImage image, float avg, float var);	

//使用柱状图信息进行等值化; 进行的统计规范化来对图像动态范围的最大化。
extern "C" RvImage PPRS_API    rvEqualize(RvImage image);	


//将对比度最大化
//both lowPercent and hightPercent   must be in the range of [0..1]
 extern "C" RvImage PPRS_API  rvContrast(RvImage image, float lPercent, float hPercent);	



//对输入的像素值进行线性变换，以获得需要的格式
extern "C" RvImage  PPRS_API   rvLinear(RvImage image,float gain, float offset); 

//根据最大和最小值拉伸,仅支持灰度图像
extern "C" RvImage  PPRS_API   rvExpand(RvImage image ); 


//对单独的通道进行线性运算
//RGB,或RGBA格式的图像
extern "C" RvImage  PPRS_API   rvLinearEx(RvImage image, int channel, float gain, float offset); 




//利用梯度进行边缘检测
extern "C" RvImage  PPRS_API  rvGradient(RvImage image, int direct,  int gap);	




//一阶导数边缘增强
extern "C" RvImage PPRS_API    rvDiffFirst(RvImage image, int direct);	

//二阶导数边缘增强
 extern "C" RvImage PPRS_API   rvDiffSecond(RvImage image,int direct);

//使用prewitt滤波核对图像边缘进行增强
 extern "C" RvImage PPRS_API  rvPrewitt(RvImage image,int direct);

//根据指定的方向使用sobel核进行边缘增强。
 extern "C" RvImage PPRS_API   rvSobel(RvImage image, int direct);	

 //根据指定的方向使用sobel核进行边缘增强。
 //图象：RIT_GRAY
 extern "C" RvImage PPRS_API   rvScharr(RvImage image, int direct);	


//使用Kirsch滤波核对图像进行边缘增强
 extern "C" RvImage  PPRS_API  rvKirsch(RvImage image,int direct);

//使用LaPlacian滤波核对图像边缘进行增强
 extern "C" RvImage  PPRS_API  rvLaPlacian(RvImage image );	
//使用Roberts滤波核对图像进行边缘增强
extern "C" RvImage  PPRS_API  rvRoberts(RvImage image);	
 

//使用3x3的滤波核对图像进行锐化处理。
extern "C" RvImage PPRS_API   rvSharp1541(RvImage image);
 

 
//canny 边缘 
//建议： 上下限阈值在2:1 到3:1之间，算法建议为3蓓。
//图象格式为RIT_GRAY
extern "C" RvImage PPRS_API  rvCanny( RvImage image, double lowThresh, double highThresh, BOOL bForceToBin, int aperture = 3 );


//使用定制的滤波核对裁片中的图像进行滤波。
//常用滤波核的有1x11, 1x5, 3x3, 5x5等等。
extern "C" RvImage PPRS_API   rvFilter(RvImage image, RvMatrix kernel);
 
//对图像进行中值滤波
//kernelsize 为3,5,7,9
//图象格式为灰度，或RGB图象
extern "C" RvImage PPRS_API   rvMedian(RvImage image, int kernelSize);

//for gray image only
extern "C" RvImage PPRS_API rvDetectEdge(RvImage image, int type, int dir, float thresVal=-1.0f, RvMask mask=NULL);


//for gray image only
#define RV_SM_DIST_TRANS      0
#define RV_SM_MULT_FILTER     1
extern "C" RvImage PPRS_API rvSkeleton(RvImage image, int method = RV_SM_DIST_TRANS);

//细化
extern "C"  void  PPRS_API rvThinning(RvImage image);

 

 

//对图像进行3x3区域的膨胀处理。
extern "C" RvImage  PPRS_API  rvDilate(RvImage image,   const RvMask shape=NULL   );

//根据半径膨胀处理,仅支持bin
extern "C" RvImage  PPRS_API  rvDilateE1(RvImage image,   int radius );



//对图像进行3x3区域的腐蚀处理。
extern "C" RvImage  PPRS_API   rvErode(RvImage image,   const RvMask shape=NULL );	

 
//for binary image 
extern "C"  void  PPRS_API rvRemoveBorder(RvImage image );
extern "C"  void  PPRS_API rvRemoveBorderEx(RvImage image,const RvMask mask=NULL );
extern "C"  void  PPRS_API rvFillHole(RvImage image );
extern "C"  void  PPRS_API rvFillHoleEx(RvImage image, const RvMask mask =NULL );



//for binary image only
//下面这个函数有问题
extern "C" RvImage PPRS_API   rvRetrieveEdge(RvImage image, BOOL bDark2Light=TRUE,  RvImage dest =NULL);

//如果dest为NULL, 直接提取image的边,不会新建image
//n8为连通性
extern "C" RvImage PPRS_API   rvRetrieveEdgeE1(RvImage image, BOOL n8,  RvImage dest =NULL);


//生成金子塔图
//如果dest为虚拟图象，当源图象类型与dest不符合的时候，将失败。
extern "C" RvImage PPRS_API   rvPyramid(const RvImage image, BOOL bUp=FALSE,  RvImage dest =NULL);

//源控制点和目标控制点必须为四个。
//如果dest为NULL，将产生一个新的图象
//dest不能为虚拟图象
//pSrcControls和pDestControls分别为4个点坐标
extern "C" RvImage PPRS_API   rvWarp(const RvImage image,  RvPoint_f* pSrcControls, RvPoint_f* pDestControls, RvImage dest = NULL  );

//dest可以為NULL
extern "C"  RvImage PPRS_API   rvWarpEx(const RvImage image,  RvPoint_f* pSrcControls, int nSrcControls,  RvPoint_f*  pDestControls, int nDestControls , BOOL bKeepOutlier, RvImage dest );

extern "C"  RvImage PPRS_API   rvUnwarp(const RvImage image,  RvPoint_f pSrcCtrls[4], RvImage dest );


//二值图像四周的若干像素设置为RV_BIN_ZERO
extern "C"  void PPRS_API  rvCutMargin(RvImage image, int thick);

//smooth type
//#define RV_ST_BLUR       0
//#define RV_ST_MEDIAN     1
//#define RV_ST_GAUSSIAN   2
//#define RV_ST_AVG        3
//过时
//extern "C" RvImage PPRS_API  rvSmooth(RvImage image, int type, RvSize kernelSize, double option1=0, double option2=0);

//图象格式RIT_GRAY ,RIT_RGB
extern "C" RvImage PPRS_API  rvBlur(RvImage image,   int kernWidth, int kernHeight);
extern "C" RvImage PPRS_API  rvSmoothGaussian(RvImage image, int kernWidth, int kernHeight);
extern "C" RvImage PPRS_API   rvSmoothMedian(RvImage image, int kernelSize);

 //使用平均滤波核进行简单的平滑处理。
 //kernelsize 为3,5,7,9
 extern "C" RvImage PPRS_API    rvSmoothAvg(RvImage image, int kernelSize);	

//morphology type
#define RV_MT_ERODE       0
#define RV_MT_DILATE      1
#define RV_MT_OPEN        2
#define RV_MT_CLOSE       3
#define RV_MT_GRADIENT    4
#define RV_MT_TOPHAT      5
#define RV_MT_BLACKHAT    6

extern "C" RvImage PPRS_API  rvMorphology(RvImage image,   int type, int times  = 1);

extern "C" RvImage PPRS_API  rvMorpClose(RvImage image);

extern "C" RvImage PPRS_API  rvMorpOpen(RvImage image);
 
//自适应二值化
#define RV_AT_MEAN      0
#define RV_AT_GAUSSIAN  1 
//block size >=1 and block size < 63
extern "C" RvImage PPRS_API rvAdaptive(RvImage image, int method  = RV_AT_MEAN, int blockSize =3);

extern "C" void PPRS_API rvEclose(RvImage image, int radius);

//快速距离变换 
// int* pArrFlags ：应用程序分配 
//UINT size ： size >= w * h
//返回：w * h of image
extern "C" UINT PPRS_API rvDistTrans(const RvImage image, /*int w, int h,*/ int* pArrResult, UINT size );
 
//按照距离变换方法进行腐蚀
//int thres -边缘距离，从1开始
extern "C" RvImage PPRS_API rvErodeE1(RvImage image, int thres );

//低照度图像增强
extern "C" RvImage PPRS_API rvIncreaseLum(const RvImage image);



//fill text仅支持rgb
extern "C"  void PPRS_API rvFillText(RvImage image, const char* strText, int x, int y, int fontSize=12, RvColor textColor =RV_RGB(0,0,0));


 //fill text style
#define FT_TS_ITALIC        1
#define FT_TS_UNDERLINE    (1<<1)
#define FT_TS_BOLD         (1<<2)
#define FT_TS_STRIKEOUT    (1<<3)
#define FT_TS_TRANSPARENT  (1<<4)
#define	FT_MAX_TEXT_LEN     4096
extern "C" void  PPRS_API rvFillTextEx(RvImage image,  const char* strText, int x, int y,  const char* strFaceName, int fontSize, RvColor textColor, RvColor backColor, int flags);
 

extern "C" void PPRS_API rvErodeBin(RvImage image);
extern "C" void PPRS_API rvOutlineE1(RvImage image, const RvMask mask,  int dist, BOOL b8);
extern "C" void PPRS_API rvOutline(RvImage image, const RvMask mask, BOOL b8);

//adust bright, RGB
extern "C" void PPRS_API rvAdjustBright(RvImage image,BOOL  bDarker, float percent);



#endif