![]() |
![]() |
00001 /******************************************************************************* 00002 * GX IMAGE EXTENSION header file - V7.2.12 00003 * 00004 * 2006-2015 (c) Adaptive Recognition (https://adaptiverecognition.com) 00005 ******************************************************************************/ 00016 /******************************************************************************/ 00017 #ifndef GX_IMGEXT_INCL 00018 #define GX_IMGEXT_INCL 00019 /******************************************************************************/ 00020 #include "gxsd.h" 00021 #include "gximage.h" 00022 #include "gxtrafo.h" 00023 /******************************************************************************/ 00024 #ifdef GX_NAMESPACES 00025 namespace gx { 00026 #endif 00027 /******************************************************************************/ 00028 #ifdef GX_DOTNET 00029 #pragma managed 00030 #endif 00031 /******************************************************************************/ 00033 GX_ENUM GX_COLORADJUST_FLAGS { 00034 GX_COLORADJUST_BRIGHTNESS_BASIC = 1, 00035 GX_COLORADJUST_BRIGHTNESS_ADVANCED = 2, 00036 GX_COLORADJUST_CONTRAST_BASIC = 4, 00037 GX_COLORADJUST_CONTRAST_ADVANCED = 8, 00038 }; 00039 00041 GX_ENUM GX_COMPOSE_FLAGS { 00042 GX_COMPOSE_DONT_ENLARGE_IMAGE = 0x01, 00043 GX_COMPOSE_ENLARGE_IMAGE = 0x02, 00044 GX_COMPOSE_ALPHA = 0x04, 00045 GX_COMPOSE_WEIGHTING = 0x08, 00046 }; 00047 00049 GX_ENUM GX_TEXT_FLAGS { 00050 GX_TEXT_ITALIC = 0x01, 00051 GX_TEXT_STRAIGHT = 0x02, 00052 GX_TEXT_BOLD = 0x10, 00053 GX_TEXT_NORMAL = 0x20, 00054 GX_TEXT_THIN = 0x30, 00055 }; 00056 00057 /******************************************************************************/ 00058 #if defined(GX_DOTNET) && !defined(GX_MANUAL) 00059 #pragma unmanaged 00060 #define gxPNT _gxPNT 00061 #define gxPG4 _gxPG4 00062 #endif 00063 /******************************************************************************/ 00064 00065 #if !defined(GX_SWIGIF) && !defined(GX_MANUAL) /*(*/ 00066 00067 enum { 00068 GX_CALL_COLORADJUST = GX_CALL_GROUP_GX_IMGEXT, /* Call code of the gx_coloradjust() function. */ 00069 GX_CALL_COLORMIXER = GX_CALL_GROUP_GX_IMGEXT+1, /* Call code of the gx_colormixer() function. */ 00070 GX_CALL_IMAGEDIFFERENCE = GX_CALL_GROUP_GX_IMGEXT+2, /* Call code of the gx_imagedifference() function. */ 00071 GX_CALL_IMAGETRANSFORM = GX_CALL_GROUP_GX_IMGEXT+3, /* Call code of the gx_imagetransform() function. */ 00072 GX_CALL_IMAGEFTRANSFORM = GX_CALL_GROUP_GX_IMGEXT+4, /* Call code of the gx_imageftransform() function. */ 00073 GX_CALL_IMAGECOMPOSE = GX_CALL_GROUP_GX_IMGEXT+5, /* Call code of the gx_imagecompose() function. */ 00074 GX_CALL_DRAWTEXT = GX_CALL_GROUP_GX_IMGEXT+6, /* Call code of the gx_drawtext() function. */ 00075 }; 00076 00077 /******************************************************************************/ 00079 struct GX_PARM_COLORADJUST { 00080 gxIMAGE *image; /* Image to adjust. */ 00081 float contrast; /* Contrast adjust level. */ 00082 float brightness; /* Brightness adjust level. */ 00083 float saturation; /* Saturation adjust level. */ 00084 float gamma; /* Gamma correction level. */ 00085 int flags; /* Color adjusting flags, see \ref GX_COLORADJUST_FLAGS. */ 00086 }; 00087 00089 struct GX_PARM_COLORMIXER { 00090 gxIMAGE *target; /* Preallocated image to return the result. */ 00091 gxIMAGE *source; /* Image to process. */ 00092 int r1; /* Adaptable weight. */ 00093 int g1; /* Adaptable weight. */ 00094 int b1; /* Adaptable weight. */ 00095 int r2; /* Adaptable weight. */ 00096 int g2; /* Adaptable weight. */ 00097 int b2; /* Adaptable weight. */ 00098 int r3; /* Adaptable weight. */ 00099 int g3; /* Adaptable weight. */ 00100 int b3; /* Adaptable weight. */ 00101 }; 00102 00104 struct GX_PARM_IMAGEDIFFERENCE { 00105 gxIMAGE *target; /* Preallocated image to return the result. */ 00106 gxIMAGE *source1; /* First image. */ 00107 gxIMAGE *source2; /* Second image. */ 00108 }; 00109 00111 struct GX_PARM_IMAGETRANSFORM { 00112 gxIMAGE *target; /* Preallocated image to return the result. */ 00113 gxIMAGE *source; /* Image to process. */ 00114 gxPG4 area; /* Area defined on the source image to transform in the target image. */ 00115 void *bgcolor; /* Background color for filling parts that are not defined by the source image. */ 00116 }; 00117 00119 struct GX_PARM_IMAGEFTRANSFORM { 00120 gxIMAGE *target; /* Preallocated image to return the result. */ 00121 gxIMAGE *source; /* Image to process. */ 00122 gxTRAFO *trafo; /* Transformation descriptor. */ 00123 void *bgcolor; /* Background color for filling parts that are not defined by the source image. */ 00124 }; 00125 00127 struct GX_PARM_IMAGECOMPOSE { 00128 gxIMAGE *target; /* Preallocated image to return the result. */ 00129 gxIMAGE *upper; /* Upper image. */ 00130 gxIMAGE *lower; /* Lower image. */ 00131 gxPNT position; /* Position of the upper image on the lower image. */ 00132 float alpha_u; /* Alpha channel for the upper image. */ 00133 float alpha_l; /* Alpha channel for the lower image. */ 00134 int flags; /* Image composing flags, see \ref GX_COMPOSE_FLAGS. */ 00135 void *bgcolor; /* Background color for filling parts that are not defined by the source images. */ 00136 }; 00137 00140 struct GX_PARM_DRAWTEXT { 00141 gxIMAGE *image; /* Image to return the result. */ 00142 const char *text; /* Text to draw */ 00143 gxPNT position; /* Position of the text on image */ 00144 const char *fonttype; /* Name of the fontface (WIN32) or path of the font file (LINUX) */ 00145 int fontheight; /* Character height of the text in logical units */ 00146 int fontwidth; /* Average character width in logical units */ 00147 void *txtcolor; /* Text color */ 00148 int flags; /* Image composing flags, see \ref GX_COMPOSE_FLAGS. */ 00149 }; 00150 00151 #endif /* GX_SWIGIF GX_MANUAL )*/ 00152 00153 /******************************************************************************/ 00154 #if !defined(NO_GX_FUNCTIONS) && !defined(GX_SWIGIF) /*(*/ 00155 /******************************************************************************/ 00156 00157 /******************************************************************************/ 00161 /******************************************************************************/ 00162 00163 /******************************************************************************/ 00185 inline int gx_coloradjust(gxHANDLE imgexthandle, gxIMAGE *image, 00186 float contrast GX_DEFARG(0), float brightness GX_DEFARG(0), float saturation GX_DEFARG(0), 00187 float gamma GX_DEFARG(1), int flags GX_DEFARG(0)) 00188 { 00189 struct GX_PARM_COLORADJUST col; 00190 assert(image); 00191 col.image = image; 00192 col.contrast = contrast; 00193 col.brightness = brightness; 00194 col.saturation = saturation; 00195 col.gamma = gamma; 00196 col.flags = flags; 00197 return gx_call(imgexthandle, GX_CALL_COLORADJUST, &col); 00198 } 00199 00200 /******************************************************************************/ 00223 inline int gx_colormixer(gxHANDLE imgexthandle, gxIMAGE *target, 00224 gxIMAGE *source, int r1, int g1, int b1, 00225 int r2 GX_DEFARG(0), int g2 GX_DEFARG(0), int b2 GX_DEFARG(0), 00226 int r3 GX_DEFARG(0), int g3 GX_DEFARG(0), int b3 GX_DEFARG(0)) 00227 { 00228 struct GX_PARM_COLORMIXER col; 00229 assert(target); 00230 assert(source); 00231 col.target = target; 00232 col.source = source; 00233 col.r1 = r1; 00234 col.g1 = g1; 00235 col.b1 = b1; 00236 col.r2 = r2; 00237 col.g2 = g2; 00238 col.b2 = b2; 00239 col.r3 = r3; 00240 col.g3 = g3; 00241 col.b3 = b3; 00242 return gx_call(imgexthandle, GX_CALL_COLORMIXER, &col); 00243 } 00244 00245 /******************************************************************************/ 00254 inline int gx_imagedifference(gxHANDLE imgexthandle, gxIMAGE *target, 00255 gxIMAGE *source1, gxIMAGE *source2) 00256 { 00257 struct GX_PARM_IMAGEDIFFERENCE idf; 00258 assert(target); 00259 assert(source1); 00260 assert(source2); 00261 idf.target = target; 00262 idf.source1 = source1; 00263 idf.source2 = source2; 00264 return gx_call(imgexthandle, GX_CALL_IMAGEDIFFERENCE, &idf); 00265 } 00266 00267 /******************************************************************************/ 00277 inline int gx_imagetransform(gxHANDLE imgexthandle, gxIMAGE *target, 00278 gxIMAGE *source, gxPG4 area, void *bgcolor GX_DEFARG(0)) 00279 { 00280 struct GX_PARM_IMAGETRANSFORM itr; 00281 assert(target); 00282 assert(source); 00283 itr.target = target; 00284 itr.source = source; 00285 itr.area = area; 00286 itr.bgcolor = bgcolor; 00287 return gx_call(imgexthandle, GX_CALL_IMAGETRANSFORM, &itr); 00288 } 00289 00290 /******************************************************************************/ 00300 inline int gx_imageftransform(gxHANDLE imgexthandle, gxIMAGE *target, 00301 gxIMAGE *source, gxTRAFO *trafo, void *bgcolor GX_DEFARG(0)) 00302 { 00303 struct GX_PARM_IMAGEFTRANSFORM ftr; 00304 assert(target); 00305 assert(source); 00306 assert(trafo); 00307 ftr.target = target; 00308 ftr.source = source; 00309 ftr.trafo = trafo; 00310 ftr.bgcolor = bgcolor; 00311 return gx_call(imgexthandle, GX_CALL_IMAGEFTRANSFORM, &ftr); 00312 } 00313 00314 /******************************************************************************/ 00328 inline int gx_imagecompose(gxHANDLE imgexthandle, gxIMAGE *target, 00329 gxIMAGE *upper, gxIMAGE *lower, gxPNT position, 00330 float alpha_u GX_DEFARG(1), float alpha_l GX_DEFARG(1), 00331 int flags GX_DEFARG(0), void *bgcolor GX_DEFARG(0)) 00332 { 00333 struct GX_PARM_IMAGECOMPOSE ic; 00334 assert(target); 00335 assert(upper); 00336 assert(lower); 00337 ic.target = target; 00338 ic.upper = upper; 00339 ic.lower = lower; 00340 ic.position = position; 00341 ic.alpha_u = alpha_u; 00342 ic.alpha_l = alpha_l; 00343 ic.flags = flags; 00344 ic.bgcolor = bgcolor; 00345 return gx_call(imgexthandle, GX_CALL_IMAGECOMPOSE, &ic); 00346 } 00347 00348 /******************************************************************************/ 00363 inline int gx_drawtext(gxHANDLE imgexthandle, gxIMAGE *image, const char *text, 00364 gxPNT position, const char *fonttype, int fontheight, int fontwidth, 00365 void *txtcolor, unsigned int flags) 00366 { 00367 struct GX_PARM_DRAWTEXT dt; 00368 assert(text); 00369 assert(txtcolor); 00370 dt.image = image; 00371 dt.text = text; 00372 dt.position = position; 00373 dt.fonttype = fonttype; 00374 dt.fontheight = fontheight; 00375 dt.fontwidth = fontwidth; 00376 dt.txtcolor = txtcolor; 00377 dt.flags = flags; 00378 return gx_call(imgexthandle, GX_CALL_DRAWTEXT, &dt); 00379 } 00380 00381 /******************************************************************************/ 00383 /******************************************************************************/ 00384 #endif /*)*/ 00385 /******************************************************************************/ 00386 #ifdef GX_DOTNET 00387 #pragma managed 00388 #undef gxPNT 00389 #undef gxPG4 00390 #endif 00391 /******************************************************************************/ 00392 00393 /******************************************************************************/ 00394 #if !defined(NO_GX_CLASSES) /*(*/ 00395 /******************************************************************************/ 00397 GX_CLASS gxImgExt : public gxHandle 00398 { 00399 00400 public: 00401 00403 gxImgExt() gxFuncThrowsError { 00404 #ifndef GX_DOTNET 00405 if(!gx_openmodule(this, L"gximgext", 0)) gxthrow; 00406 #else 00407 GX_GETHANDLE(h); 00408 if(!gx_openmodule(&h, L"gximgext", 0)) gxthrow; 00409 _set_handle(h.handle); 00410 #endif 00411 } 00412 00413 /**************************************************************************/ 00434 inline bool ColorAdjust(gxImage GX_REF_CLASS(image), float contrast GX_DEFARG(0), float brightness GX_DEFARG(0), 00435 float saturation GX_DEFARG(0), float gamma GX_DEFARG(1), int flags GX_DEFARG(0)) gxFuncThrowsError { 00436 GX_GETHANDLE(h); 00437 GX_GETIMAGE2(_image, image); 00438 bool st = gx_coloradjust(h, _image, contrast, brightness, saturation, gamma, flags) != 0; 00439 gxcondthrow(!st); 00440 return st; 00441 } 00442 00443 /**************************************************************************/ 00461 inline bool Contrast(gxImage GX_REF_CLASS(image), float contrast, int flags GX_DEFARG(0)) gxFuncThrowsError { 00462 GX_GETHANDLE(h); 00463 GX_GETIMAGE2(_image,image); 00464 bool st = gx_coloradjust(h, _image, contrast, 0, 0, 1.f, flags) != 0; 00465 gxcondthrow(!st); 00466 return st; 00467 } 00468 00469 /**************************************************************************/ 00485 inline bool Brightness(gxImage GX_REF_CLASS(image), float brightness, int flags GX_DEFARG(0)) gxFuncThrowsError { 00486 GX_GETHANDLE(h); 00487 GX_GETIMAGE2(_image, image); 00488 bool st = gx_coloradjust(h, _image, 0, brightness, 0, 1.f, flags) != 0; 00489 gxcondthrow(!st); 00490 return st; 00491 } 00492 00493 /**************************************************************************/ 00510 inline bool Saturation(gxImage GX_REF_CLASS(image), float saturation) gxFuncThrowsError { 00511 GX_GETHANDLE(h); 00512 GX_GETIMAGE2(_image, image); 00513 bool st = gx_coloradjust(h, _image, 0, 0, saturation, 1.f, 0) != 0; 00514 gxcondthrow(!st); 00515 return st; 00516 } 00517 00518 /**************************************************************************/ 00528 inline bool Gamma(gxImage GX_REF_CLASS(image), float gamma) gxFuncThrowsError { 00529 GX_GETHANDLE(h); 00530 GX_GETIMAGE2(_image, image); 00531 bool st = gx_coloradjust(h, _image, 0, 0, 0, gamma, 0) != 0; 00532 gxcondthrow(!st); 00533 return st; 00534 } 00535 00536 /**************************************************************************/ 00558 inline bool ColorMixer(gxImage GX_REF_CLASS(target), gxImage GX_REF_CLASS(source), 00559 int r1, int g1, int b1, 00560 int r2 GX_DEFARG(0), int g2 GX_DEFARG(0), int b2 GX_DEFARG(0), 00561 int r3 GX_DEFARG(0), int g3 GX_DEFARG(0), int b3 GX_DEFARG(0)) gxFuncThrowsError { 00562 GX_GETHANDLE(h); 00563 GX_GETIMAGE2(_target, target); 00564 GX_GETIMAGE2(_source, source); 00565 bool st = gx_colormixer(h, _target, _source, r1, g1, b1, r2, g2, b2, r3, g3, b3) != 0; 00566 gxcondthrow(!st); 00567 return st; 00568 } 00569 00570 /**************************************************************************/ 00578 inline bool Difference(gxImage GX_REF_CLASS(target), gxImage GX_REF_CLASS(source1), gxImage GX_REF_CLASS(source2)) gxFuncThrowsError { 00579 GX_GETHANDLE(h); 00580 GX_GETIMAGE2(_target, target); 00581 GX_GETIMAGE2(_source1, source1); 00582 GX_GETIMAGE2(_source2, source2); 00583 bool st = gx_imagedifference(h, _target, _source1, _source2) != 0; 00584 gxcondthrow(!st); 00585 return st; 00586 } 00587 00588 #if !defined(GX_SWIG) && !defined(GX_DOTNET) 00589 /**************************************************************************/ 00597 inline bool Transform(gxImage & target, gxImage & source, gxPG4 area) gxFuncThrowsError { 00598 GX_GETHANDLE(h); 00599 GX_GETIMAGE2(_target, target); 00600 GX_GETIMAGE2(_source, source); 00601 bool st = gx_imagetransform(h, _target, _source, area) != 0; 00602 gxcondthrow(!st); 00603 return st; 00604 } 00605 00606 /**************************************************************************/ 00614 inline bool FTransform(gxImage & target, gxImage & source, gxTrafo & trafo) gxFuncThrowsError { 00615 GX_GETHANDLE(h); 00616 GX_GETIMAGE2(_target, target); 00617 GX_GETIMAGE2(_source, source); 00618 bool st = gx_imageftransform(h, _target, _source, trafo) != 0; 00619 gxcondthrow(!st); 00620 return st; 00621 } 00622 00623 /**************************************************************************/ 00635 inline bool Compose(gxImage & target, gxImage & upper, gxImage & lower, gxPNT position, 00636 float alpha_u GX_DEFARG(1), float alpha_l GX_DEFARG(1), int flags GX_DEFARG(0)) gxFuncThrowsError { 00637 GX_GETHANDLE(h); 00638 GX_GETIMAGE2(_target, target); 00639 GX_GETIMAGE2(_upper, upper); 00640 GX_GETIMAGE2(_lower, lower); 00641 bool st = gx_imagecompose(h, _target, _upper, _lower, position, alpha_u, alpha_l, flags) != 0; 00642 gxcondthrow(!st); 00643 return st; 00644 } 00645 00646 /******************************************************************************/ 00659 inline bool DrawText(gxImage & image, const char *text, gxPNT position, const char *fonttype, 00660 int fontheight, int fontwidth, void *txtcolor, unsigned int flags) gxFuncThrowsError { 00661 GX_GETHANDLE(h); 00662 GX_GETIMAGE2(_image, image); 00663 00664 bool st = gx_drawtext(h, _image, text, position, fonttype, fontheight, 00665 fontwidth, txtcolor, flags) != 0; 00666 gxcondthrow(!st); 00667 return st; 00668 } 00669 00670 #endif /* GX_SWIG GX_DOTNET */ 00671 00672 }; 00673 00674 /******************************************************************************/ 00675 #endif /* NO_GX_CLASSES )*/ 00676 /******************************************************************************/ 00677 #ifdef GX_NAMESPACES 00678 } 00679 #endif 00680 /******************************************************************************/ 00681 #endif /* GX_IMGEXT_INCL */ 00682 /******************************************************************************/