Enumerations | |
enum | CxImage::ImageOpType { CxImage::OpAdd, CxImage::OpAnd, CxImage::OpXor, CxImage::OpOr, CxImage::OpMask, CxImage::OpSrcCopy, CxImage::OpDstCopy, CxImage::OpSub, CxImage::OpSrcBlend, CxImage::OpScreen, CxImage::OpAvg, CxImage::OpBlendAlpha } |
Functions | |
bool | CxImage::Contour () |
bool | CxImage::HistogramStretch (int32_t method=0, double threshold=0) |
bool | CxImage::HistogramEqualize () |
bool | CxImage::HistogramNormalize () |
bool | CxImage::HistogramRoot () |
bool | CxImage::HistogramLog () |
int32_t | CxImage::Histogram (int32_t *red, int32_t *green=0, int32_t *blue=0, int32_t *gray=0, int32_t colorspace=0) |
bool | CxImage::Jitter (int32_t radius=2) |
bool | CxImage::Repair (float radius=0.25f, int32_t niterations=1, int32_t colorspace=0) |
bool | CxImage::Combine (CxImage *r, CxImage *g, CxImage *b, CxImage *a, int32_t colorspace=0) |
bool | CxImage::FFT2 (CxImage *srcReal, CxImage *srcImag, CxImage *dstReal, CxImage *dstImag, int32_t direction=1, bool bForceFFT=true, bool bMagnitude=true) |
bool | CxImage::Noise (int32_t level) |
bool | CxImage::Median (int32_t Ksize=3) |
bool | CxImage::Gamma (float gamma) |
bool | CxImage::GammaRGB (float gammaR, float gammaG, float gammaB) |
bool | CxImage::ShiftRGB (int32_t r, int32_t g, int32_t b) |
bool | CxImage::Threshold (uint8_t level) |
bool | CxImage::Threshold (CxImage *pThresholdMask) |
bool | CxImage::Threshold2 (uint8_t level, bool bDirection, RGBQUAD nBkgndColor, bool bSetAlpha=false) |
bool | CxImage::Colorize (uint8_t hue, uint8_t sat, float blend=1.0f) |
bool | CxImage::Light (int32_t brightness, int32_t contrast=0) |
float | CxImage::Mean () |
bool | CxImage::Filter (int32_t *kernel, int32_t Ksize, int32_t Kfactor, int32_t Koffset) |
bool | CxImage::Erode (int32_t Ksize=2) |
bool | CxImage::Dilate (int32_t Ksize=2) |
bool | CxImage::Edge (int32_t Ksize=2) |
void | CxImage::HuePalette (float correction=1) |
void | CxImage::Mix (CxImage &imgsrc2, ImageOpType op, int32_t lXOffset=0, int32_t lYOffset=0, bool bMixAlpha=false) |
void | CxImage::MixFrom (CxImage &imagesrc2, int32_t lXOffset, int32_t lYOffset) |
bool | CxImage::UnsharpMask (float radius=5.0f, float amount=0.5f, int32_t threshold=0) |
bool | CxImage::Lut (uint8_t *pLut) |
bool | CxImage::Lut (uint8_t *pLutR, uint8_t *pLutG, uint8_t *pLutB, uint8_t *pLutA=0) |
bool | CxImage::GaussianBlur (float radius=1.0f, CxImage *iDst=0) |
bool | CxImage::TextBlur (uint8_t threshold=100, uint8_t decay=2, uint8_t max_depth=5, bool bBlurHorizontal=true, bool bBlurVertical=true, CxImage *iDst=0) |
bool | CxImage::SelectiveBlur (float radius=1.0f, uint8_t threshold=25, CxImage *iDst=0) |
bool | CxImage::Solarize (uint8_t level=128, bool bLinkedChannels=true) |
bool | CxImage::FloodFill (const int32_t xStart, const int32_t yStart, const RGBQUAD cFillColor, const uint8_t tolerance=0, uint8_t nOpacity=255, const bool bSelectFilledArea=false, const uint8_t nSelectionLevel=255) |
bool | CxImage::Saturate (const int32_t saturation, const int32_t colorspace=1) |
bool | CxImage::ConvertColorSpace (const int32_t dstColorSpace, const int32_t srcColorSpace) |
int32_t | CxImage::OptimalThreshold (int32_t method=0, RECT *pBox=0, CxImage *pContrastMask=0) |
bool | CxImage::AdaptiveThreshold (int32_t method=0, int32_t nBoxSize=64, CxImage *pContrastMask=0, int32_t nBias=0, float fGlobalLocalBalance=0.5f) |
bool | CxImage::RedEyeRemove (float strength=0.8f) |
bool | CxImage::Trace (RGBQUAD color_target, RGBQUAD color_trace) |
enum CxImage::ImageOpType [inherited] |
bool CxImage::AdaptiveThreshold | ( | int32_t | method = 0 , |
|
int32_t | nBoxSize = 64 , |
|||
CxImage * | pContrastMask = 0 , |
|||
int32_t | nBias = 0 , |
|||
float | fGlobalLocalBalance = 0.5f | |||
) | [inherited] |
Converts the image to B&W, using an optimal threshold mask
method,: | 0 = average all methods (default); 1 = Otsu; 2 = Kittler & Illingworth; 3 = max entropy; 4 = potential difference; | |
nBoxSize,: | the image is divided into "nBoxSize x nBoxSize" blocks, from where the threshold is computed; min = 8; default = 64. | |
pContrastMask,: | limit the computation only in regions with contrasted (!=0) pixels; default = 0. | |
nBias,: | global offset added to the threshold mask; default = 0. | |
fGlobalLocalBalance,: | balance between local and global threshold. default = 0.5 fGlobalLocalBalance can be from 0.0 (use only local threshold) to 1.0 (use only global threshold) the pContrastMask image must be grayscale with same with and height of the current image, |
bool CxImage::Colorize | ( | uint8_t | hue, | |
uint8_t | sat, | |||
float | blend = 1.0f | |||
) | [inherited] |
Replaces the original hue and saturation values.
hue,: | hue | |
sat,: | saturation | |
blend,: | can be from 0 (no effect) to 1 (full effect) |
bool CxImage::Combine | ( | CxImage * | r, | |
CxImage * | g, | |||
CxImage * | b, | |||
CxImage * | a, | |||
int32_t | colorspace = 0 | |||
) | [inherited] |
Combines different color components into a single image
r,g,b,: | color channels | |
a,: | alpha layer, can be NULL | |
colorspace,: | 0 = RGB, 1 = HSL, 2 = YUV, 3 = YIQ, 4 = XYZ |
bool CxImage::Contour | ( | ) | [inherited] |
bool CxImage::ConvertColorSpace | ( | const int32_t | dstColorSpace, | |
const int32_t | srcColorSpace | |||
) | [inherited] |
Converts the RGB triplets to and from different colorspace
dstColorSpace,: | destination colorspace; 0 = RGB, 1 = HSL, 2 = YUV, 3 = YIQ, 4 = XYZ | |
srcColorSpace,: | source colorspace; 0 = RGB, 1 = HSL, 2 = YUV, 3 = YIQ, 4 = XYZ |
bool CxImage::Dilate | ( | int32_t | Ksize = 2 |
) | [inherited] |
Enhance the light areas of the image
Ksize,: | size of the kernel. |
bool CxImage::Edge | ( | int32_t | Ksize = 2 |
) | [inherited] |
bool CxImage::Erode | ( | int32_t | Ksize = 2 |
) | [inherited] |
Enhance the dark areas of the image
Ksize,: | size of the kernel. |
bool CxImage::FFT2 | ( | CxImage * | srcReal, | |
CxImage * | srcImag, | |||
CxImage * | dstReal, | |||
CxImage * | dstImag, | |||
int32_t | direction = 1 , |
|||
bool | bForceFFT = true , |
|||
bool | bMagnitude = true | |||
) | [inherited] |
Computes the bidimensional FFT or DFT of the image.
srcReal,srcImag,: | source images: One can be NULL, but not both | |
dstReal,dstImag,: | destination images. Can be NULL. | |
direction,: | 1 = forward, -1 = inverse. | |
bForceFFT,: | if true, the images are resampled to make the dimensions a power of 2. | |
bMagnitude,: | if true, the real part returns the magnitude, the imaginary part returns the phase |
bool CxImage::Filter | ( | int32_t * | kernel, | |
int32_t | Ksize, | |||
int32_t | Kfactor, | |||
int32_t | Koffset | |||
) | [inherited] |
2D linear filter
kernel,: | convolving matrix, in row format. | |
Ksize,: | size of the kernel. | |
Kfactor,: | normalization constant. | |
Koffset,: | bias. Example: the "soften" filter uses this kernel: 1 1 1 1 8 1 1 1 1 the function needs: kernel={1,1,1,1,8,1,1,1,1}; Ksize=3; Kfactor=16; Koffset=0; |
bool CxImage::FloodFill | ( | const int32_t | xStart, | |
const int32_t | yStart, | |||
const RGBQUAD | cFillColor, | |||
const uint8_t | nTolerance = 0 , |
|||
uint8_t | nOpacity = 255 , |
|||
const bool | bSelectFilledArea = false , |
|||
const uint8_t | nSelectionLevel = 255 | |||
) | [inherited] |
Flood Fill
xStart,yStart,: | starting point | |
cFillColor,: | filling color | |
nTolerance,: | deviation from the starting point color | |
nOpacity,: | can be from 0 (transparent) to 255 (opaque, default) | |
bSelectFilledArea,: | if true, the pixels in the region are also set in the selection layer; default = false | |
nSelectionLevel,: | if bSelectFilledArea is true, the selected pixels are set to nSelectionLevel; default = 255 Note: nOpacity=0 && bSelectFilledArea=true act as a "magic wand" |
bool CxImage::Gamma | ( | float | gamma | ) | [inherited] |
Adjusts the color balance of the image
gamma | can be from 0.1 to 5. |
bool CxImage::GammaRGB | ( | float | gammaR, | |
float | gammaG, | |||
float | gammaB | |||
) | [inherited] |
Adjusts the color balance indipendent for each color channel
gammaR,gammaG,gammaB | can be from 0.1 to 5. |
bool CxImage::GaussianBlur | ( | float | radius = 1.0f , |
|
CxImage * | iDst = 0 | |||
) | [inherited] |
int32_t CxImage::Histogram | ( | int32_t * | red, | |
int32_t * | green = 0 , |
|||
int32_t * | blue = 0 , |
|||
int32_t * | gray = 0 , |
|||
int32_t | colorspace = 0 | |||
) | [inherited] |
bool CxImage::HistogramEqualize | ( | ) | [inherited] |
bool CxImage::HistogramLog | ( | ) | [inherited] |
bool CxImage::HistogramNormalize | ( | ) | [inherited] |
bool CxImage::HistogramRoot | ( | ) | [inherited] |
bool CxImage::HistogramStretch | ( | int32_t | method = 0 , |
|
double | threshold = 0 | |||
) | [inherited] |
HistogramStretch
method,: | 0 = luminance (default), 1 = linked channels , 2 = independent channels. | |
threshold,: | minimum percentage level in the histogram to recognize it as meaningful. Range: 0.0 to 1.0; default = 0; typical = 0.005 (0.5%); |
void CxImage::HuePalette | ( | float | correction = 1 |
) | [inherited] |
Generates a "rainbow" palette with saturated colors
correction,: | 1 generates a single hue spectrum. 0.75 is nice for scientific applications. |
bool CxImage::Jitter | ( | int32_t | radius = 2 |
) | [inherited] |
Adds a random offset to each pixel in the image
radius,: | maximum pixel displacement |
bool CxImage::Light | ( | int32_t | brightness, | |
int32_t | contrast = 0 | |||
) | [inherited] |
Changes the brightness and the contrast of the image.
brightness,: | can be from -255 to 255, if brightness is negative, the image becomes dark. | |
contrast,: | can be from -100 to 100, the neutral value is 0. |
bool CxImage::Lut | ( | uint8_t * | pLutR, | |
uint8_t * | pLutG, | |||
uint8_t * | pLutB, | |||
uint8_t * | pLutA = 0 | |||
) | [inherited] |
Apply an indipendent look up table for each channel
pLutR,pLutG,pLutB,pLutA,: | uint8_t[256] look up tables |
bool CxImage::Lut | ( | uint8_t * | pLut | ) | [inherited] |
Apply a look up table to the image.
pLut,: | uint8_t[256] look up table |
float CxImage::Mean | ( | ) | [inherited] |
bool CxImage::Median | ( | int32_t | Ksize = 3 |
) | [inherited] |
Adjusts the intensity of each pixel to the median intensity of its surrounding pixels.
Ksize,: | size of the kernel. |
void CxImage::Mix | ( | CxImage & | imgsrc2, | |
ImageOpType | op, | |||
int32_t | lXOffset = 0 , |
|||
int32_t | lYOffset = 0 , |
|||
bool | bMixAlpha = false | |||
) | [inherited] |
Blends two images
imgsrc2,: | image to be mixed with this | |
op,: | blending method; see ImageOpType | |
lXOffset,lYOffset,: | image displacement | |
bMixAlpha,: | if true and imgsrc2 has a valid alpha layer, it will be mixed in the destination image. |
void CxImage::MixFrom | ( | CxImage & | imagesrc2, | |
int32_t | lXOffset, | |||
int32_t | lYOffset | |||
) | [inherited] |
bool CxImage::Noise | ( | int32_t | level | ) | [inherited] |
Adds an uniform noise to the image
level,: | can be from 0 (no noise) to 255 (lot of noise). |
int32_t CxImage::OptimalThreshold | ( | int32_t | method = 0 , |
|
RECT * | pBox = 0 , |
|||
CxImage * | pContrastMask = 0 | |||
) | [inherited] |
Finds the optimal (global or local) treshold for image binarization
method,: | 0 = average all methods (default); 1 = Otsu; 2 = Kittler & Illingworth; 3 = max entropy; 4 = potential difference; | |
pBox,: | region from where the threshold is computed; 0 = full image (default). | |
pContrastMask,: | limit the computation only in regions with contrasted (!=0) pixels; default = 0. the pContrastMask image must be grayscale with same with and height of the current image, can be obtained from the current image with a filter: CxImage iContrastMask(*image,true,false,false); iContrastMask.GrayScale(); int32_t edge[]={-1,-1,-1,-1,8,-1,-1,-1,-1}; iContrastMask.Filter(edge,3,1,0); int32_t blur[]={1,1,1,1,1,1,1,1,1}; iContrastMask.Filter(blur,3,9,0); |
bool CxImage::RedEyeRemove | ( | float | strength = 0.8f |
) | [inherited] |
Use the RedEyeRemove function to remove the red-eye effect that frequently occurs in photographs of humans and animals. You must select the region where the function will filter the red channel.
strength,: | range from 0.0f (no effect) to 1.0f (full effect). Default = 0.8 |
bool CxImage::Repair | ( | float | radius = 0.25f , |
|
int32_t | niterations = 1 , |
|||
int32_t | colorspace = 0 | |||
) | [inherited] |
Smart blurring to remove small defects, dithering or artifacts.
radius,: | normally between 0.01 and 0.5 | |
niterations,: | should be trimmed with radius, to avoid blurring should be (radius*niterations)<1 | |
colorspace,: | 0 = RGB, 1 = HSL, 2 = YUV, 3 = YIQ, 4 = XYZ |
bool CxImage::Saturate | ( | const int32_t | saturation, | |
const int32_t | colorspace = 1 | |||
) | [inherited] |
Changes the saturation of the image.
saturation,: | can be from -100 to 100, positive values increase the saturation. | |
colorspace,: | can be 1 (HSL) or 2 (YUV). |
bool CxImage::SelectiveBlur | ( | float | radius = 1.0f , |
|
uint8_t | threshold = 25 , |
|||
CxImage * | iDst = 0 | |||
) | [inherited] |
bool CxImage::ShiftRGB | ( | int32_t | r, | |
int32_t | g, | |||
int32_t | b | |||
) | [inherited] |
Adjusts separately the red, green, and blue values in the image.
r,g,b,: | can be from -255 to +255. |
bool CxImage::Solarize | ( | uint8_t | level = 128 , |
|
bool | bLinkedChannels = true | |||
) | [inherited] |
Solarize: convert all colors above a given lightness level into their negative
level | : lightness threshold. Range = 0 to 255; default = 128. | |
bLinkedChannels,: | true = compare with luminance, preserve colors (default) false = compare with independent R,G,B levels |
bool CxImage::TextBlur | ( | uint8_t | threshold = 100 , |
|
uint8_t | decay = 2 , |
|||
uint8_t | max_depth = 5 , |
|||
bool | bBlurHorizontal = true , |
|||
bool | bBlurVertical = true , |
|||
CxImage * | iDst = 0 | |||
) | [inherited] |
bool CxImage::Threshold | ( | CxImage * | pThresholdMask | ) | [inherited] |
Converts the image to B&W, using a threshold mask
pThresholdMask,: | the lightness threshold mask. the pThresholdMask image must be grayscale with same with and height of the current image |
bool CxImage::Threshold | ( | uint8_t | level | ) | [inherited] |
Converts the image to B&W. The OptimalThreshold() function can be used for calculating the optimal threshold.
level,: | the lightness threshold. |
bool CxImage::Threshold2 | ( | uint8_t | level, | |
bool | bDirection, | |||
RGBQUAD | nBkgndColor, | |||
bool | bSetAlpha = false | |||
) | [inherited] |
Filters only the pixels with a lightness less (or more) than the threshold level, and preserves the colors for the unfiltered pixels.
level | = the lightness threshold. | |
bDirection | = false: filter dark pixels, true: filter light pixels | |
nBkgndColor | = filtered pixels are set to nBkgndColor color | |
bSetAlpha | = if true, sets also the alpha component for the filtered pixels, with nBkgndColor.rgbReserved |
bool CxImage::Trace | ( | RGBQUAD | color_target, | |
RGBQUAD | color_trace | |||
) | [inherited] |
bool CxImage::UnsharpMask | ( | float | radius = 5.0f , |
|
float | amount = 0.5f , |
|||
int32_t | threshold = 0 | |||
) | [inherited] |
sharpen the image by subtracting a blurred copy from the original image.
radius,: | width in pixels of the blurring effect. Range: >0; default = 5. | |
amount,: | strength of the filter. Range: 0.0 (none) to 1.0 (max); default = 0.5 | |
threshold,: | difference, between blurred and original pixel, to trigger the filter Range: 0 (always triggered) to 255 (never triggered); default = 0. |