1370 lines
64 KiB
C++
Executable File
1370 lines
64 KiB
C++
Executable File
/** \file
|
|
* \brief Name space for C++ high level API
|
|
*
|
|
* See Copyright Notice in im_lib.h
|
|
*/
|
|
|
|
#ifndef __IM_PLUS_H
|
|
#define __IM_PLUS_H
|
|
|
|
|
|
#include "im.h"
|
|
#include "im_lib.h"
|
|
#include "im_raw.h"
|
|
#include "im_image.h"
|
|
#include "im_palette.h"
|
|
#include "im_kernel.h"
|
|
#include "im_capture.h"
|
|
#include "im_process.h"
|
|
#include "im_counter.h"
|
|
#include "im_convert.h"
|
|
#include "im_attrib_flat.h"
|
|
|
|
|
|
|
|
/** \brief Name space for C++ high level API
|
|
*
|
|
* \par
|
|
* Defines wrapper classes for all C structures.
|
|
*
|
|
* See \ref im_plus.h
|
|
*/
|
|
namespace im
|
|
{
|
|
inline const char* Version() { return imVersion(); }
|
|
inline const char* VersionDate() { return imVersionDate(); }
|
|
inline int VersionNumber() { return imVersionNumber(); }
|
|
|
|
|
|
class Palette
|
|
{
|
|
protected:
|
|
long* pal;
|
|
int count;
|
|
|
|
public:
|
|
Palette(int pal_count = 256) {
|
|
count = pal_count;
|
|
pal = imPaletteNew(count); }
|
|
Palette(long* palette, int pal_count = 256) {
|
|
count = pal_count;
|
|
pal = palette; }
|
|
Palette(const Palette& src_palette) {
|
|
count = src_palette.count;
|
|
pal = imPaletteDuplicate(src_palette.pal, src_palette.count); }
|
|
virtual ~Palette() {
|
|
if (pal)
|
|
imPaletteRelease(pal);
|
|
}
|
|
|
|
long* GetData() const { return pal; }
|
|
int Count() const { return count; }
|
|
|
|
long& operator [] (int index) {
|
|
static long err = -1;
|
|
if (!pal || index < 0 || index >= count)
|
|
return err;
|
|
return pal[index];
|
|
}
|
|
|
|
|
|
int FindNearest(long color) const {
|
|
return imPaletteFindNearest(pal, count, color); }
|
|
int FindColor(long color, unsigned char tol) {
|
|
return imPaletteFindColor(pal, count, color, tol); }
|
|
|
|
static long ColorEncode(unsigned char red, unsigned char green, unsigned char blue) {
|
|
return (((long)red) << 16) | (((long)green) << 8) | ((long)blue); }
|
|
static unsigned char ColorRed(long color) {
|
|
return (unsigned char)(color >> 16); }
|
|
static unsigned char ColorGreen(long color) {
|
|
return (unsigned char)(color >> 8); }
|
|
static unsigned char ColorBlue(long color) {
|
|
return (unsigned char)color; }
|
|
|
|
/* pre-defined palettes */
|
|
static Palette Gray() {
|
|
return Palette(imPaletteGray()); }
|
|
static Palette Red() {
|
|
return Palette(imPaletteRed()); }
|
|
static Palette Green() {
|
|
return Palette(imPaletteGreen()); }
|
|
static Palette Blue() {
|
|
return Palette(imPaletteBlue()); }
|
|
static Palette Yellow() {
|
|
return Palette(imPaletteYellow()); }
|
|
static Palette Magenta() {
|
|
return Palette(imPaletteMagenta()); }
|
|
static Palette Cyan() {
|
|
return Palette(imPaletteCyan()); }
|
|
static Palette Rainbow() {
|
|
return Palette(imPaletteRainbow()); }
|
|
static Palette Hues() {
|
|
return Palette(imPaletteHues()); }
|
|
static Palette BlueIce() {
|
|
return Palette(imPaletteBlueIce()); }
|
|
static Palette HotIron() {
|
|
return Palette(imPaletteHotIron()); }
|
|
static Palette BlackBody() {
|
|
return Palette(imPaletteBlackBody()); }
|
|
static Palette HighContrast() {
|
|
return Palette(imPaletteHighContrast()); }
|
|
static Palette Linear() {
|
|
return Palette(imPaletteLinear()); }
|
|
|
|
static Palette Uniform() {
|
|
return Palette(imPaletteUniform()); }
|
|
static int UniformIndex(long color) {
|
|
return imPaletteUniformIndex(color); }
|
|
static int UniformIndexHalftoned(long color, int x, int y) {
|
|
return imPaletteUniformIndexHalftoned(color, x, y); }
|
|
};
|
|
|
|
class AttribTable
|
|
{
|
|
imAttribTablePrivate* ptable;
|
|
|
|
/* forbidden */
|
|
AttribTable() {}
|
|
|
|
public:
|
|
|
|
AttribTable(int hash_size) {
|
|
ptable = imAttribTableCreate(hash_size); }
|
|
AttribTable(const AttribTable& attrib_table) {
|
|
imAttribTableCopyFrom(ptable, attrib_table.ptable); }
|
|
virtual ~AttribTable() {
|
|
if (ptable)
|
|
imAttribTableDestroy(ptable);
|
|
}
|
|
|
|
int Count() const {
|
|
return imAttribTableCount(ptable); }
|
|
void RemoveAll() {
|
|
imAttribTableRemoveAll(ptable); }
|
|
|
|
void MergeFrom(const AttribTable& attrib_table) {
|
|
imAttribTableMergeFrom(ptable, attrib_table.ptable); }
|
|
|
|
void Set(const char* name, int data_type, int count, const void* data) {
|
|
imAttribTableSet(ptable, name, data_type, count, data); }
|
|
void SetInteger(const char* name, int data_type, int value) {
|
|
imAttribTableSetInteger(ptable, name, data_type, value); }
|
|
void SetReal(const char* name, int data_type, double value) {
|
|
imAttribTableSetReal(ptable, name, data_type, value); }
|
|
void SetString(const char* name, const char* value) {
|
|
imAttribTableSetString(ptable, name, value); }
|
|
void Reset(const char *name) {
|
|
imAttribTableUnSet(ptable, name); }
|
|
|
|
const void* Get(const char *name, int *data_type = 0, int *count = 0) const {
|
|
return imAttribTableGet(ptable, name, data_type, count); }
|
|
int GetInteger(const char *name, int index = 0) const {
|
|
return imAttribTableGetInteger(ptable, name, index); }
|
|
double GetReal(const char *name, int index = 0) const {
|
|
return imAttribTableGetReal(ptable, name, index); }
|
|
const char* GetString(const char *name) const {
|
|
return imAttribTableGetString(ptable, name); }
|
|
|
|
void ForEach(void* user_data, imAttribTableCallback attrib_func) const {
|
|
imAttribTableForEach(ptable, user_data, attrib_func); }
|
|
};
|
|
|
|
|
|
class ImageChannelLine
|
|
{
|
|
imImage* image;
|
|
int lin;
|
|
void* channel_buffer;
|
|
|
|
public:
|
|
ImageChannelLine(imImage* ref_image, int ref_lin, void* ref_channel_buffer)
|
|
: image(ref_image), lin(ref_lin), channel_buffer(ref_channel_buffer) { }
|
|
|
|
double operator [] (int col) {
|
|
if (image == 0 || col < 0 || col >= image->width)
|
|
return 0;
|
|
else
|
|
{
|
|
int index = lin * image->width + col;
|
|
|
|
switch (image->data_type)
|
|
{
|
|
case IM_BYTE:
|
|
{
|
|
unsigned char *bdata = (unsigned char*)channel_buffer;
|
|
return (double)bdata[index];
|
|
}
|
|
case IM_SHORT:
|
|
{
|
|
short *sdata = (short*)channel_buffer;
|
|
return (double)sdata[index];
|
|
}
|
|
case IM_USHORT:
|
|
{
|
|
unsigned short *udata = (unsigned short*)channel_buffer;
|
|
return (double)udata[index];
|
|
}
|
|
case IM_INT:
|
|
{
|
|
int *idata = (int*)channel_buffer;
|
|
return (double)idata[index];
|
|
}
|
|
case IM_FLOAT:
|
|
{
|
|
float *fdata = (float*)channel_buffer;
|
|
return (double)fdata[index];
|
|
}
|
|
case IM_DOUBLE:
|
|
{
|
|
double *fdata = (double*)channel_buffer;
|
|
return fdata[index];
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
}
|
|
};
|
|
|
|
|
|
class ImageChannel
|
|
{
|
|
imImage* image;
|
|
int plane;
|
|
|
|
public:
|
|
ImageChannel(imImage* ref_image, int ref_plane)
|
|
: image(ref_image), plane(ref_plane) {
|
|
}
|
|
|
|
ImageChannelLine operator [] (int lin) {
|
|
if (image == 0 || lin < 0 || lin >= image->height)
|
|
return ImageChannelLine(0, 0, 0);
|
|
else
|
|
return ImageChannelLine(image, lin, image->data[plane]);
|
|
}
|
|
};
|
|
|
|
|
|
class Image
|
|
{
|
|
protected:
|
|
imImage* im_image;
|
|
|
|
/* forbidden */
|
|
Image() { im_image = 0; };
|
|
|
|
void IncRef()
|
|
{
|
|
if (!im_image) return;
|
|
int image_ref = GetAttribInteger("_IMAGE_REF");
|
|
image_ref++;
|
|
SetAttribInteger("_IMAGE_REF", IM_INT, image_ref);
|
|
}
|
|
bool DecRef()
|
|
{
|
|
int image_ref = GetAttribInteger("_IMAGE_REF");
|
|
if (image_ref > 0)
|
|
{
|
|
image_ref--;
|
|
SetAttribInteger("_IMAGE_REF", IM_INT, image_ref);
|
|
}
|
|
return image_ref == 0;
|
|
}
|
|
|
|
public:
|
|
Image(int width, int height, int color_space, int data_type) {
|
|
im_image = imImageCreate(width, height, color_space, data_type);
|
|
IncRef();
|
|
}
|
|
Image(const Image& src_image, int width, int height, int color_space, int data_type) {
|
|
im_image = imImageCreateBased(src_image.im_image, width, height, color_space, data_type);
|
|
if (im_image)
|
|
IncRef();
|
|
}
|
|
Image(const char* file_name, int index, int &error, bool as_bitmap) {
|
|
if (as_bitmap)
|
|
im_image = imFileImageLoad(file_name, index, &error);
|
|
else
|
|
im_image = imFileImageLoadBitmap(file_name, index, &error);
|
|
if (im_image)
|
|
IncRef();
|
|
}
|
|
Image(const Image& ref_image) {
|
|
im_image = ref_image.im_image;
|
|
IncRef();
|
|
}
|
|
Image(imImage* ref_image) {
|
|
im_image = ref_image;
|
|
IncRef();
|
|
}
|
|
virtual ~Image() {
|
|
if (im_image)
|
|
{
|
|
if (DecRef())
|
|
imImageDestroy(im_image);
|
|
}
|
|
}
|
|
|
|
imImage* GetHandle() const { return im_image; }
|
|
|
|
|
|
bool Failed() const {
|
|
return im_image == 0; }
|
|
|
|
/* image[plane][line][column] */
|
|
ImageChannel operator [] (int plane) {
|
|
int depth = im_image->has_alpha? im_image->depth + 1 : im_image->depth;
|
|
if (plane < 0 || plane >= depth)
|
|
return ImageChannel(0, 0);
|
|
else
|
|
return ImageChannel(im_image, plane);
|
|
}
|
|
|
|
/* image info */
|
|
int Width() const {
|
|
return im_image->width; }
|
|
int Height() const {
|
|
return im_image->height; }
|
|
int ColorSpace() const {
|
|
return im_image->color_space; }
|
|
int DataType() const {
|
|
return im_image->data_type; }
|
|
bool HasAlpha() const {
|
|
return im_image->has_alpha != 0; }
|
|
int Depth() const {
|
|
return im_image->depth; }
|
|
bool IsBitmap() const {
|
|
return imImageIsBitmap(im_image) == 1; }
|
|
|
|
|
|
/* image io */
|
|
int Save(const char* file_name, const char* format) {
|
|
return imFileImageSave(file_name, format, im_image); }
|
|
|
|
void SetValue(int plane, int lin, int col, double value) {
|
|
int depth = im_image->has_alpha ? im_image->depth + 1 : im_image->depth;
|
|
if (plane < 0 || plane >= depth)
|
|
return;
|
|
if (lin < 0 || lin >= im_image->height)
|
|
return;
|
|
if (col < 0 || col >= im_image->width)
|
|
return;
|
|
|
|
int index = lin * im_image->width + col;
|
|
void* channel_buffer = im_image->data[plane];
|
|
|
|
switch (im_image->data_type)
|
|
{
|
|
case IM_BYTE:
|
|
{
|
|
unsigned char *bdata = (unsigned char*)channel_buffer;
|
|
bdata[index] = (unsigned char)value;
|
|
}
|
|
case IM_SHORT:
|
|
{
|
|
short *sdata = (short*)channel_buffer;
|
|
sdata[index] = (short)value;
|
|
}
|
|
case IM_USHORT:
|
|
{
|
|
unsigned short *udata = (unsigned short*)channel_buffer;
|
|
udata[index] = (unsigned short)value;
|
|
}
|
|
case IM_INT:
|
|
{
|
|
int *idata = (int*)channel_buffer;
|
|
idata[index] = (int)value;
|
|
}
|
|
case IM_FLOAT:
|
|
{
|
|
float *fdata = (float*)channel_buffer;
|
|
fdata[index] = (float)value;
|
|
}
|
|
case IM_DOUBLE:
|
|
{
|
|
double *fdata = (double*)channel_buffer;
|
|
fdata[index] = value;
|
|
}
|
|
}
|
|
}
|
|
double GetValue(int plane, int lin, int col) {
|
|
int depth = im_image->has_alpha ? im_image->depth + 1 : im_image->depth;
|
|
if (plane < 0 || plane >= depth)
|
|
return 0;
|
|
if (lin < 0 || lin >= im_image->height)
|
|
return 0;
|
|
if (col < 0 || col >= im_image->width)
|
|
return 0;
|
|
|
|
int index = lin * im_image->width + col;
|
|
void* channel_buffer = im_image->data[plane];
|
|
|
|
switch (im_image->data_type)
|
|
{
|
|
case IM_BYTE:
|
|
{
|
|
unsigned char *bdata = (unsigned char*)channel_buffer;
|
|
return (double)bdata[index];
|
|
}
|
|
case IM_SHORT:
|
|
{
|
|
short *sdata = (short*)channel_buffer;
|
|
return (double)sdata[index];
|
|
}
|
|
case IM_USHORT:
|
|
{
|
|
unsigned short *udata = (unsigned short*)channel_buffer;
|
|
return (double)udata[index];
|
|
}
|
|
case IM_INT:
|
|
{
|
|
int *idata = (int*)channel_buffer;
|
|
return (double)idata[index];
|
|
}
|
|
case IM_FLOAT:
|
|
{
|
|
float *fdata = (float*)channel_buffer;
|
|
return (double)fdata[index];
|
|
}
|
|
case IM_DOUBLE:
|
|
{
|
|
double *fdata = (double*)channel_buffer;
|
|
return fdata[index];
|
|
}
|
|
}
|
|
|
|
return 0; }
|
|
|
|
/* copy utilities */
|
|
Image Duplicate() {
|
|
return Image(imImageDuplicate(im_image)); }
|
|
void Copy(Image& dst_image) const {
|
|
imImageCopy(im_image, dst_image.im_image); }
|
|
void CopyAttributes(Image& dst_image) const {
|
|
imImageCopyAttributes(im_image, dst_image.im_image); }
|
|
void MergeAttributes(Image& dst_image) const {
|
|
imImageMergeAttributes(im_image, dst_image.im_image); }
|
|
void CopyData(Image& dst_image) const {
|
|
imImageCopyData(im_image, dst_image.im_image); }
|
|
void CopyPlane(Image& dst_image, int src_plane, int dst_plane) const {
|
|
imImageCopyPlane(im_image, src_plane, dst_image.im_image, dst_plane); }
|
|
|
|
|
|
/* initialization utilities */
|
|
void Clear() {
|
|
imImageClear(im_image); }
|
|
void Reshape(int width, int height) {
|
|
imImageReshape(im_image, width, height); }
|
|
|
|
|
|
/* palette */
|
|
void SetPalette(const Palette& palette) {
|
|
imImageSetPalette(im_image, imPaletteDuplicate(palette.GetData(), palette.Count()), palette.Count()); }
|
|
Palette GetPalette() {
|
|
return Palette(imPaletteDuplicate(im_image->palette, im_image->palette_count), im_image->palette_count); }
|
|
|
|
|
|
/* alpha */
|
|
void AddAlpha() {
|
|
imImageAddAlpha(im_image); }
|
|
void SetAlpha(double alpha) {
|
|
imImageSetAlpha(im_image, alpha); }
|
|
void RemoveAlpha() {
|
|
imImageRemoveAlpha(im_image); }
|
|
|
|
|
|
/* color utilities */
|
|
void MakeBinary() {
|
|
imImageMakeBinary(im_image); }
|
|
void MakeGray() {
|
|
imImageMakeGray(im_image); }
|
|
void SetBinary() {
|
|
imImageSetBinary(im_image); }
|
|
void SetGray() {
|
|
imImageSetGray(im_image); }
|
|
void SetMap() {
|
|
imImageSetMap(im_image); }
|
|
|
|
|
|
/* attributes or metadata */
|
|
void SetAttribute(const char* attrib, int data_type, int count, const void* data) {
|
|
imImageSetAttribute(im_image, attrib, data_type, count, data); }
|
|
void SetAttribInteger(const char* attrib, int data_type, int value) {
|
|
imImageSetAttribInteger(im_image, attrib, data_type, value); }
|
|
void SetAttribReal(const char* attrib, int data_type, double value) {
|
|
imImageSetAttribReal(im_image, attrib, data_type, value); }
|
|
void SetAttribString(const char* attrib, const char* value) {
|
|
imImageSetAttribString(im_image, attrib, value); }
|
|
|
|
const void* GetAttribute(const char* attrib, int *data_type = 0, int *count = 0) const {
|
|
return imImageGetAttribute(im_image, attrib, data_type, count); }
|
|
int GetAttribInteger(const char* attrib, int index = 0) const {
|
|
return imImageGetAttribInteger(im_image, attrib, index); }
|
|
double GetAttribReal(const char* attrib, int index = 0) const {
|
|
return imImageGetAttribReal(im_image, attrib, index); }
|
|
const char* GetAttribString(const char* attrib) const {
|
|
return imImageGetAttribString(im_image, attrib); }
|
|
|
|
void GetAttributeList(char** attrib, int &attrib_count) const {
|
|
imImageGetAttributeList(im_image, attrib, &attrib_count); }
|
|
|
|
|
|
/* compare */
|
|
bool operator==(const Image& image2) const {
|
|
return Match(image2); }
|
|
bool Match(const Image& image2) const {
|
|
return imImageMatch(im_image, image2.im_image) == 1; }
|
|
bool MatchColor(const Image& image2) const {
|
|
return imImageMatchColor(im_image, image2.im_image) == 1; }
|
|
bool MatchColorSpace(const Image& image2) const {
|
|
return imImageMatchColorSpace(im_image, image2.im_image) == 1; }
|
|
bool MatchDataType(const Image& image2) const {
|
|
return imImageMatchDataType(im_image, image2.im_image) == 1; }
|
|
bool MatchSize(const Image& image2) const {
|
|
return imImageMatchSize(im_image, image2.im_image) == 1; }
|
|
|
|
|
|
/* conversion */
|
|
int ConvertDataType(Image& dst_image, int cpx2real, double gamma, bool absolute, int cast_mode) const {
|
|
return imConvertDataType(im_image, dst_image.im_image, cpx2real, gamma, absolute, cast_mode); }
|
|
int ConvertColorSpace(Image& dst_image) const {
|
|
return imConvertColorSpace(im_image, dst_image.im_image); }
|
|
int ConvertToBitmap(Image& dst_image, int cpx2real, double gamma, bool absolute, int cast_mode) {
|
|
return imConvertToBitmap(im_image, dst_image.im_image, cpx2real, gamma, absolute, cast_mode); }
|
|
|
|
};
|
|
|
|
|
|
/********************************************************************/
|
|
|
|
|
|
class CounterCallback
|
|
{
|
|
void* cc_user_data;
|
|
|
|
static int c_callback(int counter, void* user_data, const char* text, int progress) {
|
|
CounterCallback* cc = (CounterCallback*)user_data;
|
|
return cc->Callback(counter, cc->cc_user_data, text, progress);
|
|
}
|
|
|
|
public:
|
|
CounterCallback(void* user_data) {
|
|
cc_user_data = user_data;
|
|
imCounterSetCallback(this, c_callback);
|
|
}
|
|
virtual ~CounterCallback() { }
|
|
|
|
virtual int Callback(int counter, void* user_data, const char* text, int progress) = 0;
|
|
};
|
|
|
|
|
|
/********************************************************************/
|
|
|
|
|
|
class File
|
|
{
|
|
friend class Image;
|
|
|
|
/* forbidden */
|
|
File(const File&) { }
|
|
|
|
protected:
|
|
imFile* im_file;
|
|
|
|
File() { im_file = 0; }
|
|
|
|
public:
|
|
File(const char* file_name, int &error) {
|
|
im_file = imFileOpen(file_name, &error); }
|
|
File(const char* file_name, const char* format, int &error) {
|
|
im_file = imFileNew(file_name, format, &error); }
|
|
File(imFile* ref_file) {
|
|
im_file = ref_file; }
|
|
virtual ~File() {
|
|
if (im_file)
|
|
imFileClose(im_file);
|
|
}
|
|
|
|
bool Failed() const {
|
|
return im_file == 0; }
|
|
|
|
|
|
/* attributes or metadata */
|
|
void SetAttribute(const char* attrib, int data_type, int count, const void* data) {
|
|
imFileSetAttribute(im_file, attrib, data_type, count, data); }
|
|
void SetAttribInteger(const char* attrib, int data_type, int value) {
|
|
imFileSetAttribInteger(im_file, attrib, data_type, value); }
|
|
void SetAttribReal(const char* attrib, int data_type, double value) {
|
|
imFileSetAttribReal(im_file, attrib, data_type, value); }
|
|
void SetAttribString(const char* attrib, const char* value) {
|
|
imFileSetAttribString(im_file, attrib, value); }
|
|
const void* GetAttribute(const char* attrib, int &data_type, int &count) const {
|
|
return imFileGetAttribute(im_file, attrib, &data_type, &count); }
|
|
int GetAttribInteger(const char* attrib, int index) const {
|
|
return imFileGetAttribInteger(im_file, attrib, index); }
|
|
double GetAttribReal(const char* attrib, int index) const {
|
|
return imFileGetAttribReal(im_file, attrib, index); }
|
|
const char* GetAttribString(const char* attrib) {
|
|
return imFileGetAttribString(im_file, attrib); }
|
|
|
|
|
|
/* file info */
|
|
void GetInfo(char* format, char* compression, int &image_count) {
|
|
imFileGetInfo(im_file, format, compression, &image_count); }
|
|
void SetInfo(const char* compression) {
|
|
imFileSetInfo(im_file, compression); }
|
|
|
|
|
|
/* image io */
|
|
Image LoadImage(int index, int &error) {
|
|
return Image(imFileLoadImage(im_file, index, &error)); }
|
|
int SaveImage(const Image& im_image) {
|
|
return imFileSaveImage(im_file, im_image.GetHandle()); }
|
|
void LoadFrame(int index, Image& im_image, int &error, bool as_bitmap) {
|
|
if (as_bitmap)
|
|
imFileLoadBitmapFrame(im_file, index, im_image.GetHandle(), &error);
|
|
else
|
|
imFileLoadImageFrame(im_file, index, im_image.GetHandle(), &error); }
|
|
};
|
|
|
|
|
|
/********************************************************************/
|
|
|
|
|
|
class FileRaw : public File
|
|
{
|
|
/* forbidden */
|
|
FileRaw() {}
|
|
FileRaw(const FileRaw&) {}
|
|
|
|
public:
|
|
|
|
FileRaw(const char* file_name, int &error, bool new_file) : File() {
|
|
if (new_file)
|
|
im_file = imFileNewRaw(file_name, &error);
|
|
else
|
|
im_file = imFileOpenRaw(file_name, &error);
|
|
}
|
|
};
|
|
|
|
|
|
/********************************************************************/
|
|
|
|
|
|
namespace Format
|
|
{
|
|
inline void RegisterInternal() {
|
|
imFormatRegisterInternal(); }
|
|
inline void RemoveAll() {
|
|
imFormatRemoveAll(); }
|
|
|
|
inline void List(char** format_list, int &format_count) {
|
|
imFormatList(format_list, &format_count); }
|
|
|
|
inline int Info(const char* format, char* desc, char* ext, int &can_sequence) {
|
|
return imFormatInfo(format, desc, ext, &can_sequence); }
|
|
inline int InfoExtra(const char* format, char* extra) {
|
|
return imFormatInfoExtra(format, extra); }
|
|
inline int Compressions(const char* format, char** comp, int &comp_count, int color_mode, int data_type) {
|
|
return imFormatCompressions(format, comp, &comp_count, color_mode, data_type); }
|
|
inline int CanWriteImage(const char* format, const char* compression, int color_mode, int data_type) {
|
|
return imFormatCanWriteImage(format, compression, color_mode, data_type); }
|
|
}
|
|
|
|
|
|
/********************************************************************/
|
|
|
|
|
|
namespace VideoCaptureDevice
|
|
{
|
|
inline void ReloadList() {
|
|
imVideoCaptureReloadDevices(); }
|
|
inline void ReleaseList() {
|
|
imVideoCaptureReleaseDevices(); }
|
|
|
|
inline int Count()
|
|
{
|
|
return imVideoCaptureDeviceCount(); }
|
|
|
|
inline const char* DeviceDescription(int device)
|
|
{
|
|
return imVideoCaptureDeviceDesc(device); }
|
|
inline const char* DeviceExtendedDescription(int device)
|
|
{
|
|
return imVideoCaptureDeviceExDesc(device); }
|
|
inline const char* DevicePath(int device)
|
|
{
|
|
return imVideoCaptureDevicePath(device); }
|
|
inline const char* DeviceVendorInfo(int device)
|
|
{
|
|
return imVideoCaptureDeviceVendorInfo(device); }
|
|
}
|
|
|
|
|
|
/********************************************************************/
|
|
|
|
|
|
class VideoCapture
|
|
{
|
|
imVideoCapture* im_vc;
|
|
|
|
/* forbidden */
|
|
VideoCapture(const VideoCapture&) {}
|
|
|
|
public:
|
|
VideoCapture() {
|
|
im_vc = imVideoCaptureCreate(); }
|
|
VideoCapture(imVideoCapture* ref_vc) {
|
|
im_vc = ref_vc; }
|
|
virtual ~VideoCapture() {
|
|
if (im_vc)
|
|
imVideoCaptureDestroy(im_vc); }
|
|
|
|
bool Failed() const {
|
|
return im_vc == 0; }
|
|
|
|
|
|
/* capture connection */
|
|
int Connect(int device) {
|
|
return imVideoCaptureConnect(im_vc, device); }
|
|
void Disconnect() {
|
|
imVideoCaptureDisconnect(im_vc); }
|
|
bool SetInOut(int input, int output, int cross) {
|
|
return imVideoCaptureSetInOut(im_vc, input, output, cross) != 0; }
|
|
bool GetLive() const {
|
|
return imVideoCaptureLive(im_vc, -1) == 1; }
|
|
bool SetLive(int live) {
|
|
return imVideoCaptureLive(im_vc, live) != 0; }
|
|
|
|
|
|
/* configuration dialogs */
|
|
int DialogCount() const {
|
|
return imVideoCaptureDialogCount(im_vc); }
|
|
bool ShowDialog(int dialog, void* parent) {
|
|
return imVideoCaptureShowDialog(im_vc, dialog, parent) != 0; }
|
|
const char* DialogDescription(int dialog) const {
|
|
return imVideoCaptureDialogDesc(im_vc, dialog); }
|
|
|
|
|
|
/* video format */
|
|
int FormatCount() const {
|
|
return imVideoCaptureFormatCount(im_vc); }
|
|
bool GetFormatInfo(int format, int &width, int &height, char* desc) const {
|
|
return imVideoCaptureGetFormat(im_vc, format, &width, &height, desc) != 0; }
|
|
int GetFormat() const {
|
|
return imVideoCaptureSetFormat(im_vc, -1); }
|
|
bool SetFormat(int format) {
|
|
return imVideoCaptureSetFormat(im_vc, format) != 0; }
|
|
|
|
|
|
/* image info */
|
|
void GetImageSize(int &width, int &height) const {
|
|
imVideoCaptureGetImageSize(im_vc, &width, &height); }
|
|
bool SetImageSize(int width, int height) {
|
|
return imVideoCaptureSetImageSize(im_vc, width, height) != 0; }
|
|
|
|
|
|
/* image capture */
|
|
Image CaptureImage(bool as_gray) {
|
|
int width, height;
|
|
GetImageSize(width, height);
|
|
return Image(imImageCreate(width, height, as_gray ? IM_GRAY : IM_RGB, IM_BYTE));
|
|
}
|
|
bool CaptureFrame(Image& dst_image, int timeout = -1) {
|
|
imImage* image = dst_image.GetHandle();
|
|
|
|
if (image->color_space != IM_GRAY &&
|
|
image->color_space != IM_RGB &&
|
|
image->data_type != IM_BYTE)
|
|
return false;
|
|
|
|
return imVideoCaptureFrame(im_vc, (unsigned char*)image->data[0], image->color_space, timeout) != 0;
|
|
}
|
|
bool CaptureOneFrame(Image& dst_image) {
|
|
imImage* image = dst_image.GetHandle();
|
|
|
|
if (image->color_space != IM_GRAY &&
|
|
image->color_space != IM_RGB &&
|
|
image->data_type != IM_BYTE)
|
|
return false;
|
|
|
|
return imVideoCaptureOneFrame(im_vc, (unsigned char*)image->data[0], image->color_space) != 0;
|
|
}
|
|
|
|
|
|
/* attributes */
|
|
bool ResetAttribute(const char* attrib, int fauto) {
|
|
return imVideoCaptureResetAttribute(im_vc, attrib, fauto) != 0; }
|
|
bool GetAttribute(const char* attrib, double &percent) const {
|
|
return imVideoCaptureGetAttribute(im_vc, attrib, &percent) != 0; }
|
|
bool SetAttribute(const char* attrib, double percent) {
|
|
return imVideoCaptureSetAttribute(im_vc, attrib, percent) != 0; }
|
|
const char** GetAttributeList(int &num_attrib) const {
|
|
return imVideoCaptureGetAttributeList(im_vc, &num_attrib); }
|
|
};
|
|
|
|
|
|
/********************************************************************/
|
|
|
|
|
|
namespace Kernel
|
|
{
|
|
/* pre-defined kernels */
|
|
inline Image Sobel() {
|
|
return Image(imKernelSobel()); }
|
|
inline Image Prewitt() {
|
|
return Image(imKernelPrewitt()); }
|
|
inline Image Kirsh() {
|
|
return Image(imKernelKirsh()); }
|
|
inline Image Laplacian4() {
|
|
return Image(imKernelLaplacian4()); }
|
|
inline Image Laplacian8() {
|
|
return Image(imKernelLaplacian8()); }
|
|
inline Image Laplacian5x5() {
|
|
return Image(imKernelLaplacian5x5()); }
|
|
inline Image Laplacian7x7() {
|
|
return Image(imKernelLaplacian7x7()); }
|
|
inline Image Gradian3x3() {
|
|
return Image(imKernelGradian3x3()); }
|
|
inline Image Gradian7x7() {
|
|
return Image(imKernelGradian7x7()); }
|
|
inline Image Sculpt() {
|
|
return Image(imKernelSculpt()); }
|
|
inline Image Mean3x3() {
|
|
return Image(imKernelMean3x3()); }
|
|
inline Image Mean5x5() {
|
|
return Image(imKernelMean5x5()); }
|
|
inline Image CircularMean5x5() {
|
|
return Image(imKernelCircularMean5x5()); }
|
|
inline Image Mean7x7() {
|
|
return Image(imKernelMean7x7()); }
|
|
inline Image CircularMean7x7() {
|
|
return Image(imKernelCircularMean7x7()); }
|
|
inline Image Gaussian3x3() {
|
|
return Image(imKernelGaussian3x3()); }
|
|
inline Image Gaussian5x5() {
|
|
return Image(imKernelGaussian5x5()); }
|
|
inline Image Barlett5x5() {
|
|
return Image(imKernelBarlett5x5()); }
|
|
inline Image TopHat5x5() {
|
|
return Image(imKernelTopHat5x5()); }
|
|
inline Image TopHat7x7() {
|
|
return Image(imKernelTopHat7x7()); }
|
|
inline Image Enhance() {
|
|
return Image(imKernelEnhance()); }
|
|
}
|
|
|
|
|
|
namespace Process
|
|
{
|
|
inline int GaussianStdDev2KernelSize(double stddev) {
|
|
return imGaussianStdDev2KernelSize(stddev); }
|
|
inline double GaussianKernelSize2StdDev(int kernel_size) {
|
|
return imGaussianKernelSize2StdDev(kernel_size); }
|
|
inline void CalcRotateSize(int width, int height, int &new_width, int &new_height, double cos0, double sin0) {
|
|
imProcessCalcRotateSize(width, height, &new_width, &new_height, cos0, sin0); }
|
|
inline int OpenMPSetMinCount(int min_count) {
|
|
return imProcessOpenMPSetMinCount(min_count); }
|
|
inline int OpenMPSetNumThreads(int thread_count) {
|
|
return imProcessOpenMPSetNumThreads(thread_count); }
|
|
|
|
inline int HoughLines(const Image& src_image, Image& dst_image) {
|
|
return imProcessHoughLines(src_image.GetHandle(), dst_image.GetHandle()); }
|
|
inline int HoughLinesDraw(const Image& src_image, const Image& hough, const Image& hough_points, Image& dst_image) {
|
|
return imProcessHoughLinesDraw(src_image.GetHandle(), hough.GetHandle(), hough_points.GetHandle(), dst_image.GetHandle()); }
|
|
inline void CrossCorrelation(const Image& src_image1, const Image& src_image2, Image& dst_image) {
|
|
imProcessCrossCorrelation(src_image1.GetHandle(), src_image2.GetHandle(), dst_image.GetHandle()); }
|
|
inline void AutoCorrelation(const Image& src_image, Image& dst_image) {
|
|
imProcessAutoCorrelation(src_image.GetHandle(), dst_image.GetHandle()); }
|
|
inline void DistanceTransform(const Image& src_image, Image& dst_image) {
|
|
imProcessDistanceTransform(src_image.GetHandle(), dst_image.GetHandle()); }
|
|
inline void RegionalMaximum(const Image& src_image, Image& dst_image) {
|
|
imProcessRegionalMaximum(src_image.GetHandle(), dst_image.GetHandle()); }
|
|
inline void FFT(const Image& src_image, Image& dst_image) {
|
|
imProcessFFT(src_image.GetHandle(), dst_image.GetHandle()); }
|
|
inline void IFFT(const Image& src_image, Image& dst_image) {
|
|
imProcessIFFT(src_image.GetHandle(), dst_image.GetHandle()); }
|
|
inline int UnaryPointOp(const Image& src_image, Image& dst_image, imUnaryPointOpFunc func, double* params, void* userdata, const char* op_name) {
|
|
return imProcessUnaryPointOp(src_image.GetHandle(), dst_image.GetHandle(), func, params, userdata, op_name); }
|
|
inline int UnaryPointColorOp(const Image& src_image, Image& dst_image, imUnaryPointColorOpFunc func, double* params, void* userdata, const char* op_name) {
|
|
return imProcessUnaryPointColorOp(src_image.GetHandle(), dst_image.GetHandle(), func, params, userdata, op_name); }
|
|
inline int MultiPointOp(const Image *src_image_list, int src_image_count, Image& dst_image, imMultiPointOpFunc func, double* params, void* userdata, const char* op_name) {
|
|
imImage** c_src_image_list = new imImage*[src_image_count];
|
|
for (int i = 0; i < src_image_count; i++) c_src_image_list[i] = src_image_list[i].GetHandle();
|
|
int ret = imProcessMultiPointOp((const imImage**)c_src_image_list, src_image_count, dst_image.GetHandle(), func, params, userdata, op_name);
|
|
delete[] c_src_image_list;
|
|
return ret; }
|
|
inline int MultiPointColorOp(const Image *src_image_list, int src_image_count, Image& dst_image, imMultiPointColorOpFunc func, double* params, void* userdata, const char* op_name) {
|
|
imImage** c_src_image_list = new imImage*[src_image_count];
|
|
for (int i = 0; i < src_image_count; i++) c_src_image_list[i] = src_image_list[i].GetHandle();
|
|
int ret = imProcessMultiPointColorOp((const imImage**)c_src_image_list, src_image_count, dst_image.GetHandle(), func, params, userdata, op_name);
|
|
delete[] c_src_image_list;
|
|
return ret; }
|
|
inline void UnArithmeticOp(const Image& src_image, Image& dst_image, int op) {
|
|
imProcessUnArithmeticOp(src_image.GetHandle(), dst_image.GetHandle(), op); }
|
|
inline void ArithmeticOp(const Image& src_image1, const Image& src_image2, Image& dst_image, int op) {
|
|
imProcessArithmeticOp(src_image1.GetHandle(), src_image2.GetHandle(), dst_image.GetHandle(), op); }
|
|
inline void ArithmeticConstOp(const Image& src_image, double src_const, Image& dst_image, int op) {
|
|
imProcessArithmeticConstOp(src_image.GetHandle(), src_const, dst_image.GetHandle(), op); }
|
|
inline void BlendConst(const Image& src_image1, const Image& src_image2, Image& dst_image, double alpha) {
|
|
imProcessBlendConst(src_image1.GetHandle(), src_image2.GetHandle(), dst_image.GetHandle(), alpha); }
|
|
inline void Blend(const Image& src_image1, const Image& src_image2, const Image& alpha_image, Image& dst_image) {
|
|
imProcessBlend(src_image1.GetHandle(), src_image2.GetHandle(), alpha_image.GetHandle(), dst_image.GetHandle()); }
|
|
inline void Compose(const Image& src_image1, const Image& src_image2, Image& dst_image) {
|
|
imProcessCompose(src_image1.GetHandle(), src_image2.GetHandle(), dst_image.GetHandle()); }
|
|
inline void SplitComplex(const Image& src_image, Image& dst_image1, Image& dst_image2, int polar) {
|
|
imProcessSplitComplex(src_image.GetHandle(), dst_image1.GetHandle(), dst_image2.GetHandle(), polar); }
|
|
inline void MergeComplex(const Image& src_image1, const Image& src_image2, Image& dst_image, int polar) {
|
|
imProcessMergeComplex(src_image1.GetHandle(), src_image2.GetHandle(), dst_image.GetHandle(), polar); }
|
|
inline void MultipleMean(const Image *src_image_list, int src_image_count, Image& dst_image) {
|
|
imImage** c_src_image_list = new imImage*[src_image_count];
|
|
for (int i = 0; i < src_image_count; i++) c_src_image_list[i] = src_image_list[i].GetHandle();
|
|
imProcessMultipleMean((const imImage**)c_src_image_list, src_image_count, dst_image.GetHandle());
|
|
delete[] c_src_image_list;
|
|
}
|
|
inline void MultipleStdDev(const Image *src_image_list, int src_image_count, const Image& mean_image, Image& dst_image) {
|
|
imImage** c_src_image_list = new imImage*[src_image_count];
|
|
for (int i = 0; i < src_image_count; i++) c_src_image_list[i] = src_image_list[i].GetHandle();
|
|
imProcessMultipleStdDev((const imImage**)c_src_image_list, src_image_count, mean_image.GetHandle(), dst_image.GetHandle());
|
|
delete[] c_src_image_list;
|
|
}
|
|
inline int MultipleMedian(const Image *src_image_list, int src_image_count, Image& dst_image) {
|
|
imImage** c_src_image_list = new imImage*[src_image_count];
|
|
for (int i = 0; i < src_image_count; i++) c_src_image_list[i] = src_image_list[i].GetHandle();
|
|
return imProcessMultipleMedian((const imImage**)c_src_image_list, src_image_count, dst_image.GetHandle());
|
|
delete[] c_src_image_list;
|
|
}
|
|
inline int AutoCovariance(const Image& src_image, const Image& mean_image, Image& dst_image) {
|
|
return imProcessAutoCovariance(src_image.GetHandle(), mean_image.GetHandle(), dst_image.GetHandle()); }
|
|
inline void MultiplyConj(const Image& src_image1, const Image& src_image2, Image& dst_image) {
|
|
imProcessMultiplyConj(src_image1.GetHandle(), src_image2.GetHandle(), dst_image.GetHandle()); }
|
|
inline void BackSub(const Image& src_image1, const Image& src_image2, Image& dst_image, double tol, int diff) {
|
|
imProcessBackSub(src_image1.GetHandle(), src_image2.GetHandle(), dst_image.GetHandle(), tol, diff); }
|
|
inline void QuantizeRGBUniform(const Image& src_image, Image& dst_image, int do_dither) {
|
|
imProcessQuantizeRGBUniform(src_image.GetHandle(), dst_image.GetHandle(), do_dither); }
|
|
inline void QuantizeRGBMedianCut(const Image& src_image, Image& dst_image) {
|
|
imProcessQuantizeRGBMedianCut(src_image.GetHandle(), dst_image.GetHandle()); }
|
|
inline void QuantizeGrayUniform(const Image& src_image, Image& dst_image, int grays) {
|
|
imProcessQuantizeGrayUniform(src_image.GetHandle(), dst_image.GetHandle(), grays); }
|
|
inline void QuantizeGrayMedianCut(const Image& src_image, Image& dst_image, int grays) {
|
|
imProcessQuantizeGrayMedianCut(src_image.GetHandle(), dst_image.GetHandle(), grays); }
|
|
inline void ExpandHistogram(const Image& src_image, Image& dst_image, double percent) {
|
|
imProcessExpandHistogram(src_image.GetHandle(), dst_image.GetHandle(), percent); }
|
|
inline void EqualizeHistogram(const Image& src_image, Image& dst_image) {
|
|
imProcessEqualizeHistogram(src_image.GetHandle(), dst_image.GetHandle()); }
|
|
inline void SplitYChroma(const Image& src_image, Image& y_image, Image& chroma_image) {
|
|
imProcessSplitYChroma(src_image.GetHandle(), y_image.GetHandle(), chroma_image.GetHandle()); }
|
|
inline void SplitHSI(const Image& src_image, Image& h_image, Image& s_image, Image& i_image) {
|
|
imProcessSplitHSI(src_image.GetHandle(), h_image.GetHandle(), s_image.GetHandle(), i_image.GetHandle()); }
|
|
inline void MergeHSI(const Image& h_image, const Image& s_image, const Image& i_image, Image& dst_image) {
|
|
imProcessMergeHSI(h_image.GetHandle(), s_image.GetHandle(), i_image.GetHandle(), dst_image.GetHandle()); }
|
|
inline void SplitComponents(const Image& src_image, Image *dst_image_list) {
|
|
imImage* c_dst_image_list[4];
|
|
c_dst_image_list[0] = dst_image_list[0].GetHandle();
|
|
c_dst_image_list[1] = dst_image_list[1].GetHandle();
|
|
c_dst_image_list[2] = dst_image_list[2].GetHandle();
|
|
if (src_image.Depth() == 4 || src_image.HasAlpha())
|
|
c_dst_image_list[3] = dst_image_list[3].GetHandle();
|
|
imProcessSplitComponents(src_image.GetHandle(), c_dst_image_list);
|
|
}
|
|
inline void MergeComponents(const Image *src_image_list, Image& dst_image) {
|
|
imImage* c_src_image_list[4];
|
|
c_src_image_list[0] = src_image_list[0].GetHandle();
|
|
c_src_image_list[1] = src_image_list[1].GetHandle();
|
|
c_src_image_list[2] = src_image_list[2].GetHandle();
|
|
if (dst_image.Depth() == 4 || dst_image.HasAlpha())
|
|
c_src_image_list[3] = src_image_list[3].GetHandle();
|
|
imProcessMergeComponents((const imImage**)c_src_image_list, dst_image.GetHandle());
|
|
}
|
|
inline void NormalizeComponents(const Image& src_image, Image& dst_image) {
|
|
imProcessNormalizeComponents(src_image.GetHandle(), dst_image.GetHandle()); }
|
|
inline void PseudoColor(const Image& src_image, Image& dst_image) {
|
|
imProcessPseudoColor(src_image.GetHandle(), dst_image.GetHandle()); }
|
|
inline void FixBGR(const Image& src_image, Image& dst_image) {
|
|
imProcessFixBGR(src_image.GetHandle(), dst_image.GetHandle()); }
|
|
inline void SelectHue(const Image& src_image, Image& dst_image, double hue_start, double hue_end) {
|
|
imProcessSelectHue(src_image.GetHandle(), dst_image.GetHandle(), hue_start, hue_end); }
|
|
inline void SelectHSI(const Image& src_image, Image& dst_image, double hue_start, double hue_end, double sat_start, double sat_end, double int_start, double int_end) {
|
|
imProcessSelectHSI(src_image.GetHandle(), dst_image.GetHandle(), hue_start, hue_end, sat_start, sat_end, int_start, int_end); }
|
|
inline void ReplaceColor(const Image& src_image, Image& dst_image, double* src_color, double* dst_color) {
|
|
imProcessReplaceColor(src_image.GetHandle(), dst_image.GetHandle(), src_color, dst_color); }
|
|
inline void SetAlphaColor(const Image& src_image, Image& dst_image, double* src_color, double dst_alpha) {
|
|
imProcessSetAlphaColor(src_image.GetHandle(), dst_image.GetHandle(), src_color, dst_alpha); }
|
|
inline void BitwiseOp(const Image& src_image1, const Image& src_image2, Image& dst_image, int op) {
|
|
imProcessBitwiseOp(src_image1.GetHandle(), src_image2.GetHandle(), dst_image.GetHandle(), op); }
|
|
inline void BitwiseNot(const Image& src_image, Image& dst_image) {
|
|
imProcessBitwiseNot(src_image.GetHandle(), dst_image.GetHandle()); }
|
|
inline void BitMask(const Image& src_image, Image& dst_image, unsigned char mask, int op) {
|
|
imProcessBitMask(src_image.GetHandle(), dst_image.GetHandle(), mask, op); }
|
|
inline void BitPlane(const Image& src_image, Image& dst_image, int plane, int do_reset) {
|
|
imProcessBitPlane(src_image.GetHandle(), dst_image.GetHandle(), plane, do_reset); }
|
|
inline int RenderAddSpeckleNoise(const Image& src_image, Image& dst_image, double percent) {
|
|
return imProcessRenderAddSpeckleNoise(src_image.GetHandle(), dst_image.GetHandle(), percent); }
|
|
inline int RenderAddGaussianNoise(const Image& src_image, Image& dst_image, double mean, double stddev) {
|
|
return imProcessRenderAddGaussianNoise(src_image.GetHandle(), dst_image.GetHandle(), mean, stddev); }
|
|
inline int RenderAddUniformNoise(const Image& src_image, Image& dst_image, double mean, double stddev) {
|
|
return imProcessRenderAddUniformNoise(src_image.GetHandle(), dst_image.GetHandle(), mean, stddev); }
|
|
inline void ToneGamut(const Image& src_image, Image& dst_image, int op, double* params) {
|
|
imProcessToneGamut(src_image.GetHandle(), dst_image.GetHandle(), op, params); }
|
|
inline void UnNormalize(const Image& src_image, Image& dst_image) {
|
|
imProcessUnNormalize(src_image.GetHandle(), dst_image.GetHandle()); }
|
|
inline void DirectConv(const Image& src_image, Image& dst_image) {
|
|
imProcessDirectConv(src_image.GetHandle(), dst_image.GetHandle()); }
|
|
inline void Negative(const Image& src_image, Image& dst_image) {
|
|
imProcessNegative(src_image.GetHandle(), dst_image.GetHandle()); }
|
|
inline double CalcAutoGamma(const Image& image) {
|
|
return imProcessCalcAutoGamma(image.GetHandle()); }
|
|
inline void ShiftHSI(const Image& src_image, Image& dst_image, double h_shift, double s_shift, double i_shift) {
|
|
imProcessShiftHSI(src_image.GetHandle(), dst_image.GetHandle(), h_shift, s_shift, i_shift); }
|
|
inline void ShiftComponent(const Image& src_image, Image& dst_image, double h_shift, double s_shift, double i_shift) {
|
|
imProcessShiftComponent(src_image.GetHandle(), dst_image.GetHandle(), h_shift, s_shift, i_shift); }
|
|
inline void Threshold(const Image& src_image, Image& dst_image, double level, int value) {
|
|
imProcessThreshold(src_image.GetHandle(), dst_image.GetHandle(), level, value); }
|
|
inline void ThresholdByDiff(const Image& src_image1, const Image& src_image2, Image& dst_image) {
|
|
imProcessThresholdByDiff(src_image1.GetHandle(), src_image2.GetHandle(), dst_image.GetHandle()); }
|
|
inline void HysteresisThreshold(const Image& src_image, Image& dst_image, int low_thres, int high_thres) {
|
|
imProcessHysteresisThreshold(src_image.GetHandle(), dst_image.GetHandle(), low_thres, high_thres); }
|
|
inline void HysteresisThresEstimate(const Image& image, int &low_level, int &high_level) {
|
|
imProcessHysteresisThresEstimate(image.GetHandle(), &low_level, &high_level); }
|
|
inline int UniformErrThreshold(const Image& src_image, Image& dst_image) {
|
|
return imProcessUniformErrThreshold(src_image.GetHandle(), dst_image.GetHandle()); }
|
|
inline void DiffusionErrThreshold(const Image& src_image, Image& dst_image, int level) {
|
|
imProcessDiffusionErrThreshold(src_image.GetHandle(), dst_image.GetHandle(), level); }
|
|
inline int PercentThreshold(const Image& src_image, Image& dst_image, double percent) {
|
|
return imProcessPercentThreshold(src_image.GetHandle(), dst_image.GetHandle(), percent); }
|
|
inline int OtsuThreshold(const Image& src_image, Image& dst_image) {
|
|
return imProcessOtsuThreshold(src_image.GetHandle(), dst_image.GetHandle()); }
|
|
inline double MinMaxThreshold(const Image& src_image, Image& dst_image) {
|
|
return imProcessMinMaxThreshold(src_image.GetHandle(), dst_image.GetHandle()); }
|
|
inline void LocalMaxThresEstimate(const Image& image, int &level) {
|
|
imProcessLocalMaxThresEstimate(image.GetHandle(), &level); }
|
|
inline void SliceThreshold(const Image& src_image, Image& dst_image, double start_level, double end_level) {
|
|
imProcessSliceThreshold(src_image.GetHandle(), dst_image.GetHandle(), start_level, end_level); }
|
|
inline void ThresholdColor(const Image& src_image, Image& dst_image, double *src_color, double tol) {
|
|
imProcessThresholdColor(src_image.GetHandle(), dst_image.GetHandle(), src_color, tol); }
|
|
inline void ThresholdSaturation(const Image& src_image, Image& dst_image, double S_min) {
|
|
imProcessThresholdSaturation(src_image.GetHandle(), dst_image.GetHandle(), S_min); }
|
|
inline void Pixelate(const Image& src_image, Image& dst_image, int box_size) {
|
|
imProcessPixelate(src_image.GetHandle(), dst_image.GetHandle(), box_size); }
|
|
inline void Posterize(const Image& src_image, Image& dst_image, int level) {
|
|
imProcessPosterize(src_image.GetHandle(), dst_image.GetHandle(), level); }
|
|
inline void BinaryMask(const Image& src_image, Image& dst_image, Image& mask_image) {
|
|
imProcessBinaryMask(src_image.GetHandle(), dst_image.GetHandle(), mask_image.GetHandle()); }
|
|
inline void NormDiffRatio(const Image& image1, const Image& image2, Image& dst_image) {
|
|
imProcessNormDiffRatio(image1.GetHandle(), image2.GetHandle(), dst_image.GetHandle()); }
|
|
inline void AbnormalHyperionCorrection(const Image& src_image, Image& dst_image, int threshold_consecutive, int threshold_percent, Image& image_abnormal) {
|
|
imProcessAbnormalHyperionCorrection(src_image.GetHandle(), dst_image.GetHandle(), threshold_consecutive, threshold_percent, image_abnormal.GetHandle()); }
|
|
inline int ConvertDataType(const Image& src_image, Image& dst_image, int cpx2real, double gamma, int absolute, int cast_mode) {
|
|
return imProcessConvertDataType(src_image.GetHandle(), dst_image.GetHandle(), cpx2real, gamma, absolute, cast_mode); }
|
|
inline int ConvertColorSpace(const Image& src_image, Image& dst_image) {
|
|
return imProcessConvertColorSpace(src_image.GetHandle(), dst_image.GetHandle()); }
|
|
inline int ConvertToBitmap(const Image& src_image, Image& dst_image, int cpx2real, double gamma, int absolute, int cast_mode) {
|
|
return imProcessConvertToBitmap(src_image.GetHandle(), dst_image.GetHandle(), cpx2real, gamma, absolute, cast_mode); }
|
|
inline int Reduce(const Image& src_image, Image& dst_image, int order) {
|
|
return imProcessReduce(src_image.GetHandle(), dst_image.GetHandle(), order); }
|
|
inline int Resize(const Image& src_image, Image& dst_image, int order) {
|
|
return imProcessResize(src_image.GetHandle(), dst_image.GetHandle(), order); }
|
|
inline int ReduceBy4(const Image& src_image, Image& dst_image) {
|
|
return imProcessReduceBy4(src_image.GetHandle(), dst_image.GetHandle()); }
|
|
inline int Crop(const Image& src_image, Image& dst_image, int xmin, int ymin) {
|
|
return imProcessCrop(src_image.GetHandle(), dst_image.GetHandle(), xmin, ymin); }
|
|
inline int Insert(const Image& src_image, const Image& region_image, Image& dst_image, int xmin, int ymin) {
|
|
return imProcessInsert(src_image.GetHandle(), region_image.GetHandle(), dst_image.GetHandle(), xmin, ymin); }
|
|
inline int AddMargins(const Image& src_image, Image& dst_image, int xmin, int ymin) {
|
|
return imProcessAddMargins(src_image.GetHandle(), dst_image.GetHandle(), xmin, ymin); }
|
|
inline int Rotate(const Image& src_image, Image& dst_image, double cos0, double sin0, int order) {
|
|
return imProcessRotate(src_image.GetHandle(), dst_image.GetHandle(), cos0, sin0, order); }
|
|
inline int RotateRef(const Image& src_image, Image& dst_image, double cos0, double sin0, int x, int y, int to_origin, int order) {
|
|
return imProcessRotateRef(src_image.GetHandle(), dst_image.GetHandle(), cos0, sin0, x, y, to_origin, order); }
|
|
inline int Rotate90(const Image& src_image, Image& dst_image, int dir_clockwise) {
|
|
return imProcessRotate90(src_image.GetHandle(), dst_image.GetHandle(), dir_clockwise); }
|
|
inline int Rotate180(const Image& src_image, Image& dst_image) {
|
|
return imProcessRotate180(src_image.GetHandle(), dst_image.GetHandle()); }
|
|
inline int Mirror(const Image& src_image, Image& dst_image) {
|
|
return imProcessMirror(src_image.GetHandle(), dst_image.GetHandle()); }
|
|
inline int Flip(const Image& src_image, Image& dst_image) {
|
|
return imProcessFlip(src_image.GetHandle(), dst_image.GetHandle()); }
|
|
inline int Radial(const Image& src_image, Image& dst_image, double k1, int order) {
|
|
return imProcessRadial(src_image.GetHandle(), dst_image.GetHandle(), k1, order); }
|
|
inline int LensDistort(const Image& src_image, Image& dst_image, double a, double b, double c, int order) {
|
|
return imProcessLensDistort(src_image.GetHandle(), dst_image.GetHandle(), a, b, c, order); }
|
|
inline int Swirl(const Image& src_image, Image& dst_image, double k1, int order) {
|
|
return imProcessSwirl(src_image.GetHandle(), dst_image.GetHandle(), k1, order); }
|
|
inline int InterlaceSplit(const Image& src_image, Image& dst_image1, Image& dst_image2) {
|
|
return imProcessInterlaceSplit(src_image.GetHandle(), dst_image1.GetHandle(), dst_image2.GetHandle()); }
|
|
inline int GrayMorphConvolve(const Image& src_image, Image& dst_image, const Image& kernel, int ismax) {
|
|
return imProcessGrayMorphConvolve(src_image.GetHandle(), dst_image.GetHandle(), kernel.GetHandle(), ismax); }
|
|
inline int GrayMorphErode(const Image& src_image, Image& dst_image, int kernel_size) {
|
|
return imProcessGrayMorphErode(src_image.GetHandle(), dst_image.GetHandle(), kernel_size); }
|
|
inline int GrayMorphDilate(const Image& src_image, Image& dst_image, int kernel_size) {
|
|
return imProcessGrayMorphDilate(src_image.GetHandle(), dst_image.GetHandle(), kernel_size); }
|
|
inline int GrayMorphOpen(const Image& src_image, Image& dst_image, int kernel_size) {
|
|
return imProcessGrayMorphOpen(src_image.GetHandle(), dst_image.GetHandle(), kernel_size); }
|
|
inline int GrayMorphClose(const Image& src_image, Image& dst_image, int kernel_size) {
|
|
return imProcessGrayMorphClose(src_image.GetHandle(), dst_image.GetHandle(), kernel_size); }
|
|
inline int GrayMorphTopHat(const Image& src_image, Image& dst_image, int kernel_size) {
|
|
return imProcessGrayMorphTopHat(src_image.GetHandle(), dst_image.GetHandle(), kernel_size); }
|
|
inline int GrayMorphWell(const Image& src_image, Image& dst_image, int kernel_size) {
|
|
return imProcessGrayMorphWell(src_image.GetHandle(), dst_image.GetHandle(), kernel_size); }
|
|
inline int GrayMorphGradient(const Image& src_image, Image& dst_image, int kernel_size) {
|
|
return imProcessGrayMorphGradient(src_image.GetHandle(), dst_image.GetHandle(), kernel_size); }
|
|
inline int BinMorphConvolve(const Image& src_image, Image& dst_image, const Image& kernel, int hit_white, int iter) {
|
|
return imProcessBinMorphConvolve(src_image.GetHandle(), dst_image.GetHandle(), kernel.GetHandle(), hit_white, iter); }
|
|
inline int BinMorphErode(const Image& src_image, Image& dst_image, int kernel_size, int iter) {
|
|
return imProcessBinMorphErode(src_image.GetHandle(), dst_image.GetHandle(), kernel_size, iter); }
|
|
inline int BinMorphDilate(const Image& src_image, Image& dst_image, int kernel_size, int iter) {
|
|
return imProcessBinMorphDilate(src_image.GetHandle(), dst_image.GetHandle(), kernel_size, iter); }
|
|
inline int BinMorphOpen(const Image& src_image, Image& dst_image, int kernel_size, int iter) {
|
|
return imProcessBinMorphOpen(src_image.GetHandle(), dst_image.GetHandle(), kernel_size, iter); }
|
|
inline int BinMorphClose(const Image& src_image, Image& dst_image, int kernel_size, int iter) {
|
|
return imProcessBinMorphClose(src_image.GetHandle(), dst_image.GetHandle(), kernel_size, iter); }
|
|
inline int BinMorphOutline(const Image& src_image, Image& dst_image, int kernel_size, int iter) {
|
|
return imProcessBinMorphOutline(src_image.GetHandle(), dst_image.GetHandle(), kernel_size, iter); }
|
|
inline int BinThinNhMaps(const Image& src_image, Image& dst_image) {
|
|
return imProcessBinThinNhMaps(src_image.GetHandle(), dst_image.GetHandle()); }
|
|
inline int BinThinZhangSuen(const Image& src_image, Image& dst_image) {
|
|
return imProcessBinThinZhangSuen(src_image.GetHandle(), dst_image.GetHandle()); }
|
|
inline int MedianConvolve(const Image& src_image, Image& dst_image, int kernel_size) {
|
|
return imProcessMedianConvolve(src_image.GetHandle(), dst_image.GetHandle(), kernel_size); }
|
|
inline int RangeConvolve(const Image& src_image, Image& dst_image, int kernel_size) {
|
|
return imProcessRangeConvolve(src_image.GetHandle(), dst_image.GetHandle(), kernel_size); }
|
|
inline int RankClosestConvolve(const Image& src_image, Image& dst_image, int kernel_size) {
|
|
return imProcessRankClosestConvolve(src_image.GetHandle(), dst_image.GetHandle(), kernel_size); }
|
|
inline int RankMaxConvolve(const Image& src_image, Image& dst_image, int kernel_size) {
|
|
return imProcessRankMaxConvolve(src_image.GetHandle(), dst_image.GetHandle(), kernel_size); }
|
|
inline int RankMinConvolve(const Image& src_image, Image& dst_image, int kernel_size) {
|
|
return imProcessRankMinConvolve(src_image.GetHandle(), dst_image.GetHandle(), kernel_size); }
|
|
inline int RangeContrastThreshold(const Image& src_image, Image& dst_image, int kernel_size, int min_range) {
|
|
return imProcessRangeContrastThreshold(src_image.GetHandle(), dst_image.GetHandle(), kernel_size, min_range); }
|
|
inline int LocalMaxThreshold(const Image& src_image, Image& dst_image, int kernel_size, int min_level) {
|
|
return imProcessLocalMaxThreshold(src_image.GetHandle(), dst_image.GetHandle(), kernel_size, min_level); }
|
|
inline int Convolve(const Image& src_image, Image& dst_image, const Image& kernel) {
|
|
return imProcessConvolve(src_image.GetHandle(), dst_image.GetHandle(), kernel.GetHandle()); }
|
|
inline int ConvolveSep(const Image& src_image, Image& dst_image, const Image& kernel) {
|
|
return imProcessConvolveSep(src_image.GetHandle(), dst_image.GetHandle(), kernel.GetHandle()); }
|
|
inline int ConvolveDual(const Image& src_image, Image& dst_image, const Image& kernel1, const Image& kernel2) {
|
|
return imProcessConvolveDual(src_image.GetHandle(), dst_image.GetHandle(), kernel1.GetHandle(), kernel2.GetHandle()); }
|
|
inline int ConvolveRep(const Image& src_image, Image& dst_image, const Image& kernel, int rep_count) {
|
|
return imProcessConvolveRep(src_image.GetHandle(), dst_image.GetHandle(), kernel.GetHandle(), rep_count); }
|
|
inline int CompassConvolve(const Image& src_image, Image& dst_image, Image& kernel) {
|
|
return imProcessCompassConvolve(src_image.GetHandle(), dst_image.GetHandle(), kernel.GetHandle()); }
|
|
inline int DiffOfGaussianConvolve(const Image& src_image, Image& dst_image, double stddev1, double stddev2) {
|
|
return imProcessDiffOfGaussianConvolve(src_image.GetHandle(), dst_image.GetHandle(), stddev1, stddev2); }
|
|
inline int LapOfGaussianConvolve(const Image& src_image, Image& dst_image, double stddev) {
|
|
return imProcessLapOfGaussianConvolve(src_image.GetHandle(), dst_image.GetHandle(), stddev); }
|
|
inline int MeanConvolve(const Image& src_image, Image& dst_image, int kernel_size) {
|
|
return imProcessMeanConvolve(src_image.GetHandle(), dst_image.GetHandle(), kernel_size); }
|
|
inline int GaussianConvolve(const Image& src_image, Image& dst_image, double stddev) {
|
|
return imProcessGaussianConvolve(src_image.GetHandle(), dst_image.GetHandle(), stddev); }
|
|
inline int BarlettConvolve(const Image& src_image, Image& dst_image, int kernel_size) {
|
|
return imProcessBarlettConvolve(src_image.GetHandle(), dst_image.GetHandle(), kernel_size); }
|
|
inline int SobelConvolve(const Image& src_image, Image& dst_image) {
|
|
return imProcessSobelConvolve(src_image.GetHandle(), dst_image.GetHandle()); }
|
|
inline int PrewittConvolve(const Image& src_image, Image& dst_image) {
|
|
return imProcessPrewittConvolve(src_image.GetHandle(), dst_image.GetHandle()); }
|
|
inline int SplineEdgeConvolve(const Image& src_image, Image& dst_image) {
|
|
return imProcessSplineEdgeConvolve(src_image.GetHandle(), dst_image.GetHandle()); }
|
|
inline int ZeroCrossing(const Image& src_image, Image& dst_image) {
|
|
return imProcessZeroCrossing(src_image.GetHandle(), dst_image.GetHandle()); }
|
|
inline int Canny(const Image& src_image, Image& dst_image, double stddev) {
|
|
return imProcessCanny(src_image.GetHandle(), dst_image.GetHandle(), stddev); }
|
|
inline int Unsharp(const Image& src_image, Image& dst_image, double stddev, double amount, double threshold) {
|
|
return imProcessUnsharp(src_image.GetHandle(), dst_image.GetHandle(), stddev, amount, threshold); }
|
|
inline int Sharp(const Image& src_image, Image& dst_image, double amount, double threshold) {
|
|
return imProcessSharp(src_image.GetHandle(), dst_image.GetHandle(), amount, threshold); }
|
|
inline int SharpKernel(const Image& src_image, const Image& kernel, Image& dst_image, double amount, double threshold) {
|
|
return imProcessSharpKernel(src_image.GetHandle(), kernel.GetHandle(), dst_image.GetHandle(), amount, threshold); }
|
|
inline int PerimeterLine(const Image& src_image, Image& dst_image) {
|
|
return imProcessPerimeterLine(src_image.GetHandle(), dst_image.GetHandle()); }
|
|
inline int RemoveByArea(const Image& src_image, Image& dst_image, int connect, int start_size, int end_size, int inside) {
|
|
return imProcessRemoveByArea(src_image.GetHandle(), dst_image.GetHandle(), connect, start_size, end_size, inside); }
|
|
inline int FillHoles(const Image& src_image, Image& dst_image, int connect) {
|
|
return imProcessFillHoles(src_image.GetHandle(), dst_image.GetHandle(), connect); }
|
|
inline void RotateKernel(Image& kernel) {
|
|
imProcessRotateKernel(kernel.GetHandle()); }
|
|
inline void FFTraw(Image& image, int inverse, int center, int normalize) {
|
|
imProcessFFTraw(image.GetHandle(), inverse, center, normalize); }
|
|
inline void SwapQuadrants(Image& image, int center2origin) {
|
|
imProcessSwapQuadrants(image.GetHandle(), center2origin); }
|
|
|
|
inline int RenderOp(Image& image, imRenderFunc render_func, const char* render_name, double* params, int plus) {
|
|
return imProcessRenderOp(image.GetHandle(), render_func, render_name, params, plus); }
|
|
inline int RenderCondOp(Image& image, imRenderCondFunc render_cond_func, const char* render_name, double* params) {
|
|
return imProcessRenderCondOp(image.GetHandle(), render_cond_func, render_name, params); }
|
|
inline int RenderOpAlpha(Image& image, imRenderFunc render_func, const char* render_name, double* params, int plus) {
|
|
return imProcessRenderOpAlpha(image.GetHandle(), render_func, render_name, params, plus); }
|
|
inline int RenderCondOpAlpha(Image& image, imRenderCondFunc render_cond_func, const char* render_name, double* params) {
|
|
return imProcessRenderCondOpAlpha(image.GetHandle(), render_cond_func, render_name, params); }
|
|
inline int RenderRandomNoise(Image& image) {
|
|
return imProcessRenderRandomNoise(image.GetHandle()); }
|
|
inline int RenderConstant(Image& image, double* value) {
|
|
return imProcessRenderConstant(image.GetHandle(), value); }
|
|
inline int RenderWheel(Image& image, int internal_radius, int external_radius) {
|
|
return imProcessRenderWheel(image.GetHandle(), internal_radius, external_radius); }
|
|
inline int RenderCone(Image& image, int radius) {
|
|
return imProcessRenderCone(image.GetHandle(), radius); }
|
|
inline int RenderTent(Image& image, int tent_width, int tent_height) {
|
|
return imProcessRenderTent(image.GetHandle(), tent_width, tent_height); }
|
|
inline int RenderRamp(Image& image, int start, int end, int vert_dir) {
|
|
return imProcessRenderRamp(image.GetHandle(), start, end, vert_dir); }
|
|
inline int RenderBox(Image& image, int box_width, int box_height) {
|
|
return imProcessRenderBox(image.GetHandle(), box_width, box_height); }
|
|
inline int RenderSinc(Image& image, double x_period, double y_period) {
|
|
return imProcessRenderSinc(image.GetHandle(), x_period, y_period); }
|
|
inline int RenderGaussian(Image& image, double stddev) {
|
|
return imProcessRenderGaussian(image.GetHandle(), stddev); }
|
|
inline int RenderLapOfGaussian(Image& image, double stddev) {
|
|
return imProcessRenderLapOfGaussian(image.GetHandle(), stddev); }
|
|
inline int RenderCosine(Image& image, double x_period, double y_period) {
|
|
return imProcessRenderCosine(image.GetHandle(), x_period, y_period); }
|
|
inline int RenderGrid(Image& image, int x_space, int y_space) {
|
|
return imProcessRenderGrid(image.GetHandle(), x_space, y_space); }
|
|
inline int RenderChessboard(Image& image, int x_space, int y_space) {
|
|
return imProcessRenderChessboard(image.GetHandle(), x_space, y_space); }
|
|
inline void RenderFloodFill(Image& image, int start_x, int start_y, double* replace_color, double tolerance) {
|
|
imProcessRenderFloodFill(image.GetHandle(), start_x, start_y, replace_color, tolerance); }
|
|
}
|
|
|
|
class Histogram
|
|
{
|
|
/* forbidden */
|
|
Histogram() { }
|
|
|
|
protected:
|
|
unsigned long* histo;
|
|
int count;
|
|
|
|
public:
|
|
|
|
Histogram(int image_data_type) {
|
|
count = imHistogramCount(image_data_type);
|
|
histo = new unsigned long[count];
|
|
}
|
|
virtual ~Histogram() {
|
|
if (histo)
|
|
delete[] histo;
|
|
}
|
|
|
|
unsigned long* GetData() const { return histo; }
|
|
int Count() const { return count; }
|
|
|
|
Histogram(const Histogram& histogram) {
|
|
count = histogram.count;
|
|
histo = new unsigned long[count];
|
|
for (int i = 0; i < count; i++)
|
|
histo[i] = histogram.histo[i];
|
|
}
|
|
|
|
unsigned long& operator [](int index)
|
|
{
|
|
static unsigned long err = (unsigned long)-1;
|
|
if (!histo || index < 0 || index >= count)
|
|
return err;
|
|
return histo[index];
|
|
}
|
|
};
|
|
|
|
|
|
namespace Calc
|
|
{
|
|
inline int RMSError(const Image& image1, const Image& image2, double& rmserror) {
|
|
return imCalcRMSError(image1.GetHandle(), image2.GetHandle(), &rmserror); }
|
|
inline int SNR(const Image& src_image, const Image& noise_image, double& snr) {
|
|
return imCalcSNR(src_image.GetHandle(), noise_image.GetHandle(), &snr); }
|
|
inline int CountColors(const Image& image, unsigned long &count) {
|
|
return imCalcCountColors(image.GetHandle(), &count); }
|
|
inline int GrayHistogram(const Image& image, im::Histogram& histogram, int cumulative) {
|
|
return imCalcGrayHistogram(image.GetHandle(), histogram.GetData(), cumulative); }
|
|
inline int Histogram(const Image& image, im::Histogram& histogram, int plane, int cumulative) {
|
|
return imCalcHistogram(image.GetHandle(), histogram.GetData(), plane, cumulative); }
|
|
inline int ImageStatistics(const Image& image, imStats& stats) {
|
|
return imCalcImageStatistics(image.GetHandle(), &stats); }
|
|
inline int HistogramStatistics(const Image& image, imStats& stats) {
|
|
return imCalcHistogramStatistics(image.GetHandle(), &stats); }
|
|
inline int HistoImageStatistics(const Image& image, int* median, int* mode) {
|
|
return imCalcHistoImageStatistics(image.GetHandle(), median, mode); }
|
|
inline int PercentMinMax(const Image& image, double percent, int ignore_zero, int &min, int &max) {
|
|
return imCalcPercentMinMax(image.GetHandle(), percent, ignore_zero, &min, &max); }
|
|
}
|
|
|
|
class MeasureTable : protected AttribTable
|
|
{
|
|
int region_count;
|
|
|
|
public:
|
|
MeasureTable(int _region_count)
|
|
:AttribTable(0), region_count(_region_count) {
|
|
}
|
|
virtual ~MeasureTable() {}
|
|
|
|
int RegionCount() const { return region_count; }
|
|
|
|
const void* AddMeasure(const char* name, int data_type) {
|
|
const void* data = Get(name);
|
|
if (!data)
|
|
{
|
|
Set(name, data_type, region_count, (const void*)0);
|
|
data = Get(name);
|
|
}
|
|
return data;
|
|
}
|
|
const void* GetMeasure(const char* name, int *data_type = (int*)0) const {
|
|
return Get(name, data_type); }
|
|
|
|
int* AddMeasureInt(const char* name) {
|
|
return (int*)AddMeasure(name, IM_INT); }
|
|
double* AddMeasureDouble(const char* name) {
|
|
return (double*)AddMeasure(name, IM_DOUBLE);
|
|
}
|
|
int* GetMeasureInt(const char* name) const {
|
|
int data_type;
|
|
const void* data = Get(name, &data_type);
|
|
if (!data || data_type != IM_INT)
|
|
return (int*)0;
|
|
else
|
|
return (int*)data;
|
|
}
|
|
double* GetMeasureDouble(const char* name) const {
|
|
int data_type;
|
|
const void* data = Get(name, &data_type);
|
|
if (!data || data_type != IM_DOUBLE)
|
|
return (double*)0;
|
|
else
|
|
return (double*)data;
|
|
}
|
|
};
|
|
|
|
namespace Analyze
|
|
{
|
|
inline int FindRegions(const Image& image, Image& region_image, int connect, int touch_border, int ®ion_count) {
|
|
return imAnalyzeFindRegions(image.GetHandle(), region_image.GetHandle(), connect, touch_border, ®ion_count); }
|
|
|
|
inline int MeasureArea(const Image& region_image, MeasureTable& measure_table) {
|
|
return imAnalyzeMeasureArea(region_image.GetHandle(), measure_table.AddMeasureInt("Area"), measure_table.RegionCount()); }
|
|
inline int MeasurePerimArea(const Image& region_image, MeasureTable& measure_table) {
|
|
return imAnalyzeMeasurePerimArea(region_image.GetHandle(), measure_table.AddMeasureDouble("PerimeterArea"), measure_table.RegionCount()); }
|
|
inline int MeasureCentroid(const Image& region_image, MeasureTable& measure_table) {
|
|
return imAnalyzeMeasureCentroid(region_image.GetHandle(), measure_table.GetMeasureInt("Area"), measure_table.RegionCount(),
|
|
measure_table.AddMeasureDouble("CentroidX"), measure_table.AddMeasureDouble("CentroidY")); }
|
|
inline int MeasurePrincipalAxis(const Image& region_image, MeasureTable& measure_table) {
|
|
return imAnalyzeMeasurePrincipalAxis(region_image.GetHandle(), measure_table.GetMeasureInt("Area"),
|
|
measure_table.GetMeasureDouble("CentroidX"), measure_table.GetMeasureDouble("CentroidY"),
|
|
measure_table.RegionCount(),
|
|
measure_table.AddMeasureDouble("MajorSlope"), measure_table.AddMeasureDouble("MajorLength"),
|
|
measure_table.AddMeasureDouble("MinorSlope"), measure_table.AddMeasureDouble("MinorLength")); }
|
|
inline int MeasureHoles(const Image& region_image, int connect, MeasureTable& measure_table) {
|
|
return imAnalyzeMeasureHoles(region_image.GetHandle(), connect, measure_table.RegionCount(),
|
|
measure_table.AddMeasureInt("HolesCount"),
|
|
measure_table.AddMeasureInt("HolesArea"),
|
|
measure_table.AddMeasureDouble("HolesPerimeter")); }
|
|
inline int MeasurePerimeter(const Image& region_image, MeasureTable& measure_table) {
|
|
return imAnalyzeMeasurePerimeter(region_image.GetHandle(), measure_table.AddMeasureDouble("Perimeter"), measure_table.RegionCount()); }
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|