1517 lines
75 KiB
C
1517 lines
75 KiB
C
/*****************************************************************************
|
|
* HMacro.h
|
|
*****************************************************************************
|
|
*
|
|
* Project: HALCON/libhalcon
|
|
* Description: Definition of macros
|
|
*
|
|
* (c) 1996-2018 by MVTec Software GmbH
|
|
* www.mvtec.com
|
|
*
|
|
*****************************************************************************/
|
|
|
|
#ifndef HMACRO_H
|
|
#define HMACRO_H
|
|
|
|
/*
|
|
* If SMALL is defined, file names and line number information should not be
|
|
* included in the binary.
|
|
*/
|
|
#ifndef SMALL
|
|
# define H__FILE__ __FILE__
|
|
# define H__LINE__ __LINE__
|
|
#else
|
|
# define H__FILE__ ""
|
|
# define H__LINE__ -1
|
|
#endif
|
|
|
|
|
|
#define HDFImage(VAR,IMAGE_IN,KOOR) { VAR = 0.0; \
|
|
switch ((IMAGE_IN)->kind) {\
|
|
case BYTE_IMAGE: VAR = (double)(IMAGE_IN)->pixel.b[KOOR]; break;\
|
|
case INT1_IMAGE: VAR = (double)(IMAGE_IN)->pixel.i[KOOR]; break;\
|
|
case INT2_IMAGE: VAR = (double)(IMAGE_IN)->pixel.s.p[KOOR]; break;\
|
|
case UINT2_IMAGE: VAR = (double)(IMAGE_IN)->pixel.u.p[KOOR]; break;\
|
|
case DIR_IMAGE: VAR = (double)(IMAGE_IN)->pixel.d[KOOR]; break;\
|
|
case CYCLIC_IMAGE: VAR = (double)(IMAGE_IN)->pixel.z[KOOR]; break;\
|
|
case INT4_IMAGE: VAR = (double)(IMAGE_IN)->pixel.l[KOOR]; break;\
|
|
case INT8_IMAGE: VAR = (double)(IMAGE_IN)->pixel.i8[KOOR]; break;\
|
|
case FLOAT_IMAGE: VAR = (double)(IMAGE_IN)->pixel.f[KOOR]; break;\
|
|
case COMPLEX_IMAGE: return(H_ERR_WITFO); /* wrong image type */ \
|
|
case VF_IMAGE: return(H_ERR_WITFO); /* wrong image type */ \
|
|
default: return(H_ERR_NIIT); /* not implemented image type */\
|
|
}}
|
|
|
|
|
|
#define HAbsImage(VAR,IMAGE_IN,KOOR) \
|
|
switch ((IMAGE_IN)->kind) { \
|
|
case BYTE_IMAGE: VAR = ABS((double)(IMAGE_IN)->pixel.b[KOOR]); break; \
|
|
default: ; \
|
|
}
|
|
|
|
|
|
#define HImageFD(IMAGE_OUT,VAR,KOOR) \
|
|
switch ((IMAGE_OUT)->kind) { \
|
|
case BYTE_IMAGE: { \
|
|
HINT HHH; \
|
|
HHH = HIRound(VAR); \
|
|
if (HHH > 255) HHH = 255; else if (HHH < 0) HHH = 0; \
|
|
(IMAGE_OUT)->pixel.b[KOOR] = (HBYTE)HHH; \
|
|
break; } \
|
|
case CYCLIC_IMAGE: \
|
|
(IMAGE_OUT)->pixel.z[KOOR] = HMOD(HLRound(VAR),(HINT)(UCHAR_MAX+1)); \
|
|
break; \
|
|
case INT1_IMAGE: { \
|
|
HINT HHH; \
|
|
HHH = HIRound(VAR); \
|
|
if (HHH > INT1_MAX) HHH = INT1_MAX; \
|
|
else if (HHH < INT1_MIN) HHH = INT1_MIN; \
|
|
(IMAGE_OUT)->pixel.i[KOOR] = (INT1)HHH; \
|
|
break; } \
|
|
case INT2_IMAGE: { \
|
|
double DDD = (VAR); \
|
|
if (DDD > (double)INT2_MAX) DDD = INT2_MAX; \
|
|
else if (DDD < INT2_MIN) DDD = INT2_MIN; \
|
|
(IMAGE_OUT)->pixel.s.p[KOOR] = (INT2)HLRound(DDD); \
|
|
break; } \
|
|
case UINT2_IMAGE: { \
|
|
double DDD = (VAR); \
|
|
if (DDD > (double)UINT2_MAX) DDD = UINT2_MAX; \
|
|
else if (DDD < 0) DDD = 0; \
|
|
(IMAGE_OUT)->pixel.s.p[KOOR] = (UINT2)HLRound(DDD); \
|
|
break; } \
|
|
case LONG_IMAGE: { \
|
|
double DDD = (VAR); \
|
|
if (DDD > (double)INT4_MAX) DDD = INT4_MAX; \
|
|
else if (DDD < INT4_MIN) DDD = INT4_MIN; \
|
|
(IMAGE_OUT)->pixel.l[KOOR] = (INT4)HLRound(DDD); \
|
|
break; } \
|
|
case INT8_IMAGE: { \
|
|
double DDD = (VAR); \
|
|
if (DDD > (double)HINT8_MAX) DDD = HINT8_MAX; \
|
|
else if (DDD < HINT8_MIN) DDD = HINT8_MIN; \
|
|
(IMAGE_OUT)->pixel.i8[KOOR] = (HINT8)HI8Round(DDD); \
|
|
break; } \
|
|
case FLOAT_IMAGE: { \
|
|
double DDD = (VAR); \
|
|
if (DDD > (double)FLT_MAX) DDD = FLT_MAX; \
|
|
else if (DDD < -(double)FLT_MAX) DDD = -(double)FLT_MAX; \
|
|
(IMAGE_OUT)->pixel.f[KOOR] = (float)DDD; \
|
|
break; } \
|
|
case COMPLEX_IMAGE: { \
|
|
double DDD = (VAR); \
|
|
if (DDD > (double)FLT_MAX) DDD = FLT_MAX; \
|
|
else if (DDD < -(double)FLT_MAX) DDD = -(double)FLT_MAX; \
|
|
(IMAGE_OUT)->pixel.c[KOOR].re = (float)DDD; \
|
|
(IMAGE_OUT)->pixel.c[KOOR].im = (float)0.0; \
|
|
break; } \
|
|
case DIR_IMAGE: return(H_ERR_WITFO); \
|
|
case VF_IMAGE: return(H_ERR_WITFO); /* wrong image type */ \
|
|
default: return(H_ERR_NIIT); /* not implemented image type */ \
|
|
}
|
|
|
|
|
|
#define HCkFilterSize(IMAGE_WIDTH,IMAGE_HEIGHT,FILTER_WIDTH,FILTER_HEIGHT) \
|
|
if(((IMAGE_WIDTH) < ((FILTER_WIDTH)>>1)+1) || \
|
|
((IMAGE_HEIGHT) < ((FILTER_HEIGHT)>>1)+1)) \
|
|
return(H_ERR_FSEIS);
|
|
|
|
#define HCkFilterSize_2(IMAGE_WIDTH,IMAGE_HEIGHT, \
|
|
FILTER_WIDTH_2, FILTER_HEIGHT_2) \
|
|
if(((IMAGE_WIDTH) < (FILTER_WIDTH_2)+1) || \
|
|
((IMAGE_HEIGHT) < (FILTER_HEIGHT_2)+1)) \
|
|
return(H_ERR_FSEIS);
|
|
|
|
|
|
#define DIST(PIX,PIX2,ABSDIF,IMAGE_IN_KIND) \
|
|
switch (IMAGE_IN_KIND) { \
|
|
case BYTE_IMAGE: \
|
|
case LONG_IMAGE: \
|
|
case INT8_IMAGE: \
|
|
case INT1_IMAGE: \
|
|
case INT2_IMAGE: \
|
|
case UINT2_IMAGE: \
|
|
case FLOAT_IMAGE: \
|
|
ABSDIF = ABS((PIX)-(PIX2)); \
|
|
break; \
|
|
case CYCLIC_IMAGE: \
|
|
{ double dmax,dmaxh; \
|
|
dmax = (double)UCHAR_MAX + 1.; \
|
|
dmaxh = (double)(int)(dmax/2.); \
|
|
ABSDIF = ABS((PIX)-(PIX2)); \
|
|
if ((ABSDIF) > dmaxh) ABSDIF = dmax - (ABSDIF); \
|
|
} \
|
|
break; \
|
|
case DIR_IMAGE: \
|
|
if ((PIX) > 200. || (PIX2) > 200.) ABSDIF = (double)UCHAR_MAX; \
|
|
else \
|
|
{ ABSDIF = ABS((PIX)-(PIX2)); \
|
|
if ((ABSDIF) > 90.) ABSDIF = 181. - (ABSDIF); \
|
|
} \
|
|
break; \
|
|
default: return(H_ERR_NIIT); \
|
|
}
|
|
|
|
#define HiType2iIDX(iTYPE,iIDX) \
|
|
switch (iTYPE) \
|
|
{ \
|
|
case UNDEF_IMAGE: \
|
|
iIDX = iUNDEF; \
|
|
break; \
|
|
case BYTE_IMAGE: \
|
|
iIDX = iBYTE; \
|
|
break; \
|
|
case INT4_IMAGE: \
|
|
iIDX = iINT4; \
|
|
break; \
|
|
case FLOAT_IMAGE: \
|
|
iIDX = iFLOAT; \
|
|
break; \
|
|
case DIR_IMAGE: \
|
|
iIDX = iDIR; \
|
|
break; \
|
|
case CYCLIC_IMAGE: \
|
|
iIDX = iCYCLIC; \
|
|
break; \
|
|
case INT1_IMAGE: \
|
|
iIDX = iINT1; \
|
|
break; \
|
|
case COMPLEX_IMAGE: \
|
|
iIDX = iCOMPLEX; \
|
|
break; \
|
|
case INT2_IMAGE: \
|
|
iIDX = iINT2; \
|
|
break; \
|
|
case UINT2_IMAGE: \
|
|
iIDX = iUINT2; \
|
|
break; \
|
|
case VF_IMAGE: \
|
|
iIDX = iVF; \
|
|
break; \
|
|
default: \
|
|
iIDX = UNDEF_IMAGE; \
|
|
break; \
|
|
}
|
|
|
|
|
|
|
|
#define HMOD(VAL,VALMAX) (((VAL) < 0) ? \
|
|
((unsigned char)(((VALMAX) - (-(VAL) % (VALMAX))) % (VALMAX))) :\
|
|
((unsigned char)((VAL) % (VALMAX))))
|
|
|
|
|
|
|
|
|
|
/* Grauwertkomponente eines Graubildes */
|
|
#define IMAGE_INDEX 1
|
|
|
|
#define HBitImageSize(WIDTH,HEIGHT) (size_t)((HIMGCNT)WIDTH*HEIGHT/8+1)
|
|
|
|
#define WarningCompl(Proc) \
|
|
(void)printf("warning: is_compl not yet full implemented (%s)\n",Proc)
|
|
|
|
|
|
/*****************************************************************************
|
|
* Routines for freeing and reallocating "permanent","local", or "temporary"
|
|
* memory.
|
|
*****************************************************************************/
|
|
#ifndef _LIntStatic
|
|
# define HFreeGeneral(PROC_HANDLE,VOID_PTR) \
|
|
(HTraceMemory ? \
|
|
HXFreeGeneralMemCheck(PROC_HANDLE, (VOIDP)VOID_PTR, \
|
|
H__FILE__,(INT4_8)H__LINE__): \
|
|
HXFreeGeneral(PROC_HANDLE,(VOIDP)VOID_PTR) )
|
|
#else
|
|
/* in case of static language interfaces, do not use HTraceMemory to allow
|
|
* delayed loading */
|
|
# define HFreeGeneral(PROC_HANDLE,VOID_PTR) \
|
|
HXFreeGeneral(PROC_HANDLE,(VOIDP)VOID_PTR)
|
|
#endif
|
|
|
|
#define HReallocGeneral(PROC_HANDLE,VOID_PTR,SIZE,NEW_PTR) \
|
|
HXReallocGeneral(PROC_HANDLE,(VOIDP)(VOID_PTR),SIZE,(VOIDP)(NEW_PTR), \
|
|
H__FILE__, (INT4_8)H__LINE__)
|
|
|
|
#define HFreeRLGeneral(PROC_HANDLE,REGION) \
|
|
HXFreeRLGeneral(PROC_HANDLE,REGION,H__FILE__,(INT4_8)H__LINE__)
|
|
|
|
#define HReallocRLNumGeneral(PROC_HANDLE,REGION,SIZE,NEW_REGION) \
|
|
HXReallocRLNumGeneral(PROC_HANDLE,REGION,SIZE,NEW_REGION, \
|
|
H__FILE__,(INT4_8)H__LINE__)
|
|
|
|
|
|
/*****************************************************************************
|
|
* Routines for allocating "permanent" memory from the heap. This memory is
|
|
* _not_ freed automatically after each call to a HALCON operator.
|
|
*****************************************************************************/
|
|
#ifndef _LIntStatic
|
|
# define HAlloc(PROC_HANDLE,SIZE,VOID_PTR) \
|
|
(HTraceMemory ? \
|
|
HXAllocMemCheck(PROC_HANDLE,SIZE,H__FILE__,(INT4_8)H__LINE__, \
|
|
H_GLOBAL_ALLOC,(VOIDP)(VOID_PTR)): \
|
|
HXAlloc(PROC_HANDLE,SIZE,(VOIDP)(VOID_PTR)))
|
|
#else
|
|
/* in case of static language interfaces, do not use HTraceMemory to allow
|
|
* delayed loading */
|
|
# define HAlloc(PROC_HANDLE,SIZE,VOID_PTR) \
|
|
HXAlloc(PROC_HANDLE,SIZE,(VOIDP)(VOID_PTR))
|
|
#endif
|
|
|
|
#define HIsAligned(VOID_PTR,ALIGNMENT) (((UINT4_8)ptr & (ALIGNMENT-1)) == 0)
|
|
|
|
#ifndef _LIntStatic
|
|
# define HAllocAlign(PROC_HANDLE,SIZE,ALIGNMENT,VOID_PTR) \
|
|
(HTraceMemory ? \
|
|
HXAllocAlignMemCheck(PROC_HANDLE,SIZE,ALIGNMENT,H__FILE__, \
|
|
(INT4_8)H__LINE__,H_GLOBAL_ALLOC, \
|
|
(VOIDP)(VOID_PTR)): \
|
|
HXAllocAlign(PROC_HANDLE,SIZE,ALIGNMENT,(VOIDP)(VOID_PTR)))
|
|
#else
|
|
/* in case of static language interfaces, do not use HTraceMemory to allow
|
|
* delayed loading */
|
|
# define HAllocAlign(PROC_HANDLE,SIZE,ALIGNMENT,VOID_PTR) \
|
|
HXAllocAlign(PROC_HANDLE,SIZE,ALIGNMENT,(VOIDP)(VOID_PTR))
|
|
#endif
|
|
|
|
#define HRealloc(PROC_HANDLE,VOID_PTR,SIZE,NEW_PTR) \
|
|
HXRealloc(PROC_HANDLE,(VOIDP)(VOID_PTR),SIZE,(VOIDP)(NEW_PTR), \
|
|
H__FILE__,(INT4_8)H__LINE__)
|
|
|
|
#define HReallocToGlobal(PROC_HANDLE,VOID_PTR,SIZE,NEW_PTR) \
|
|
HXReallocToGlobal(PROC_HANDLE,(VOIDP)(VOID_PTR),SIZE,(VOIDP)(NEW_PTR),\
|
|
H__FILE__, (INT4_8)H__LINE__)
|
|
|
|
|
|
#ifndef _LIntStatic
|
|
# define HFree(PROC_HANDLE,VOID_PTR) \
|
|
(HTraceMemory ? \
|
|
HXFreeMemCheck(PROC_HANDLE,(VOIDP)(VOID_PTR), \
|
|
H__FILE__,(INT4_8)H__LINE__): \
|
|
HXFree(PROC_HANDLE,(VOIDP)(VOID_PTR)))
|
|
#else
|
|
/* in case of static language interfaces, do not use HTraceMemory to allow
|
|
* delayed loading */
|
|
# define HFree(PROC_HANDLE,VOID_PTR) \
|
|
HXFree(PROC_HANDLE,(VOIDP)(VOID_PTR))
|
|
#endif
|
|
|
|
#define HAllocRLNum(PROC_HANDLE,REGION,SIZE) \
|
|
HXAllocRLNum(PROC_HANDLE,REGION,SIZE,H__FILE__,(INT4_8)H__LINE__)
|
|
|
|
#define HReallocRLNum(PROC_HANDLE,REGION,SIZE,NEW_REGION) \
|
|
HXReallocRLNum(PROC_HANDLE,REGION,SIZE,NEW_REGION,H__FILE__, \
|
|
(INT4_8)H__LINE__)
|
|
|
|
#define HReallocRLNumToGlobal(PROC_HANDLE,REGION,SIZE,NEW_REGION) \
|
|
HXReallocRLNumToGlobal(PROC_HANDLE,REGION,SIZE,NEW_REGION, \
|
|
H__FILE__,(INT4_8)H__LINE__)
|
|
|
|
#define HAllocRL(PROC_HANDLE,REGION) \
|
|
HXAllocRL(PROC_HANDLE,REGION,H__FILE__,(INT4_8)H__LINE__)
|
|
|
|
#define HFreeRL(PROC_HANDLE,REGION) \
|
|
HXFreeRL(PROC_HANDLE,REGION,H__FILE__,(INT4_8)H__LINE__)
|
|
|
|
|
|
/*****************************************************************************
|
|
* Routines for allocating temporary memory from a "stack" of memory. This
|
|
* memory is freed automatically after each call to a HALCON operator.
|
|
*****************************************************************************/
|
|
|
|
#define HAllocTmp(PROC_HANDLE,PTR,SIZE) \
|
|
HXAllocTmp(PROC_HANDLE,(VOIDP)(PTR),SIZE,H__FILE__,(INT4_8)H__LINE__)
|
|
|
|
#define HAllocTmpAlign(PROC_HANDLE,PTR,SIZE,ALIGNMENT) \
|
|
HXAllocTmpAlign(PROC_HANDLE,(VOIDP)(PTR),SIZE,ALIGNMENT, \
|
|
H__FILE__,(INT4_8)H__LINE__)
|
|
|
|
#define HAllocDomainImageTmp(PROC_HANDLE,MEM_PTR,IMAGE_PTR,REGION, \
|
|
WIDTH,HEIGHT,BYTE_PER_PIXEL, \
|
|
BORDER_ROWS,BORDER_BYTES) \
|
|
HXAllocDomainImageTmp(PROC_HANDLE,(VOIDP)(MEM_PTR),(VOIDP)(IMAGE_PTR),\
|
|
REGION, \
|
|
WIDTH,HEIGHT,BYTE_PER_PIXEL, \
|
|
BORDER_ROWS,BORDER_BYTES, \
|
|
H__FILE__,(INT4_8)H__LINE__)
|
|
|
|
#define HFreeTmp(PROC_HANDLE,VOID_PTR) \
|
|
HXFreeTmp(PROC_HANDLE,(VOIDP)(VOID_PTR),H__FILE__,(INT4_8)H__LINE__)
|
|
|
|
#define HFreeNTmp(PROC_HANDLE,NUM) \
|
|
HXFreeNTmp(PROC_HANDLE,NUM,H__FILE__,(INT4_8)H__LINE__)
|
|
|
|
#define HFreeAllTmp(PROC_HANDLE) \
|
|
HXFreeAllTmp(PROC_HANDLE,H__FILE__,(INT4_8)H__LINE__)
|
|
|
|
#define HFreeUpToTmp(PROC_HANDLE,VOID_PTR) \
|
|
HXFreeUpToTmp(PROC_HANDLE,(VOIDP)(VOID_PTR),H__FILE__,(INT4_8)H__LINE__)
|
|
|
|
#define HFreeUpToTmpExcl(PROC_HANDLE,VOID_PTR) \
|
|
HXFreeUpToTmpExcl(PROC_HANDLE,(VOIDP)(VOID_PTR),H__FILE__,(INT4_8)H__LINE__)
|
|
|
|
#define HAllocRLNumTmp(PROC_HANDLE,REGION,SIZE) \
|
|
HXAllocRLNumTmp(PROC_HANDLE,REGION,SIZE,H__FILE__,(INT4_8)H__LINE__)
|
|
|
|
#define HAllocRLTmp(PROC_HANDLE,REGION) \
|
|
HXAllocRLTmp(PROC_HANDLE,REGION,H__FILE__,(INT4_8)H__LINE__)
|
|
|
|
#define HFreeRLTmp(PROC_HANDLE,REGION) \
|
|
HXFreeRLTmp(PROC_HANDLE,REGION,H__FILE__,(INT4_8)H__LINE__)
|
|
|
|
#define HTestTmp(PROC_HANDLE,VOID_PTR) \
|
|
HXTestTmp(PROC_HANDLE,VOID_PTR,H__FILE__,(INT4_8)H__LINE__,TRUE)
|
|
|
|
#define HTestPtr(VOID_PTR) \
|
|
HXTestPtr(VOID_PTR,H__FILE__,(INT4_8)H__LINE__)
|
|
|
|
#define HTestAllTmp(VOID_PTR) \
|
|
HXTestAllTmp(VOID_PTR,H__FILE__,(INT4_8)H__LINE__)
|
|
|
|
|
|
/*****************************************************************************
|
|
* Routines for allocating temporary memory from the heap. This memory is
|
|
* freed automatically after each call to a HALCON operator.
|
|
*****************************************************************************/
|
|
|
|
#define HAllocLocal(PROC_HANDLE,SIZE,VOID_PTR) \
|
|
HXAllocLocal(PROC_HANDLE,SIZE,H__FILE__,(INT4_8)H__LINE__,(VOIDP)(VOID_PTR))
|
|
|
|
/*
|
|
* HAllocLocalGC: Operator local, garbage collecting mermory allocation. In
|
|
* comparison to HAllocLocal, HAllocLocalGC does not prompt low error messages
|
|
* when freeing memory if HDoLowErrors and HTraceMemory are turned on.
|
|
*/
|
|
#define HAllocLocalGC(PROC_HANDLE, SIZE, VOID_PTR) \
|
|
HXAllocLocalGC(PROC_HANDLE,SIZE,H__FILE__,(INT4_8)H__LINE__,(VOIDP)(VOID_PTR))
|
|
|
|
#define HAllocLocalAlign(PROC_HANDLE,SIZE,ALIGNMENT,VOID_PTR) \
|
|
HXAllocLocalAlign(PROC_HANDLE,SIZE,ALIGNMENT,H__FILE__,(INT4_8)H__LINE__, \
|
|
(VOIDP)(VOID_PTR))
|
|
|
|
#define HReallocLocal(PROC_HANDLE,VOID_PTR,SIZE,NEW_PTR) \
|
|
HXReallocLocal(PROC_HANDLE,(VOIDP)(VOID_PTR),SIZE,(VOIDP)(NEW_PTR), \
|
|
H__FILE__,(INT4_8)H__LINE__)
|
|
|
|
#define HFreeLocal(PROC_HANDLE,VOID_PTR) \
|
|
HXFreeLocal(PROC_HANDLE,(VOIDP)(VOID_PTR),H__FILE__,(INT4_8)H__LINE__)
|
|
|
|
#define HAllocRLNumLocal(PROC_HANDLE,REGION,SIZE) \
|
|
HXAllocRLNumLocal(PROC_HANDLE,REGION,SIZE,H__FILE__,(INT4_8)H__LINE__)
|
|
|
|
#define HReallocRLNumLocal(PROC_HANDLE,REGION,SIZE,NEW_REGION) \
|
|
HXReallocRLNumLocal(PROC_HANDLE,REGION,SIZE,NEW_REGION, \
|
|
H__FILE__,(INT4_8)H__LINE__)
|
|
|
|
#define HAllocRLLocal(PROC_HANDLE,REGION) \
|
|
HXAllocRLLocal(PROC_HANDLE,REGION,H__FILE__,(INT4_8)H__LINE__)
|
|
|
|
#define HFreeRLLocal(PROC_HANDLE,REGION) \
|
|
HXFreeRLLocal(PROC_HANDLE,REGION,H__FILE__,(INT4_8)H__LINE__)
|
|
|
|
#ifndef ABS
|
|
# define ABS(A) (((A) >= 0) ? (A) : (-(A)))
|
|
#endif
|
|
|
|
/* Umwandlung Bogenmass in Grad und zurueck */
|
|
#define RadToDeg(x) (double)(x) * 57.295779513082
|
|
#define DegToRad(x) (double)(x) / 57.295779513082
|
|
|
|
#define HIRound(Val) (((Val) < 0.0) ? ((HINT)((Val)-0.5)):((HINT)((Val)+0.5)))
|
|
#define HI4Round(Val) (((Val) < 0.0) ? ((INT4)((Val)-0.5)):((INT4)((Val)+0.5)))
|
|
#define HLRound(Val) (((Val) < 0.0) ? ((INT4_8)((Val)-0.5)): \
|
|
((INT4_8)((Val)+0.5)))
|
|
#define HI8Round(Val) (((Val) < 0.0) ? ((HINT8)((Val)-0.5)): \
|
|
((HINT8)((Val)+0.5)))
|
|
#define HIMGCOORRound(Val) (((Val) < 0.0) ? ((HIMGCOOR)((Val)-0.5)): \
|
|
((HIMGCOOR)((Val)+0.5)))
|
|
#define HFIRound(Val) (((Val)<0.0f)?((HINT)((Val)-0.5f)):((HINT)((Val)+0.5f)))
|
|
|
|
|
|
/*
|
|
* Edge handling for images by mirroring.
|
|
*
|
|
* IMPORTANT: 'width' and 'height' are assumed to be defined for any code
|
|
* using these macros
|
|
*/
|
|
#define BR(ROW) (((ROW) < 0) ? (-(ROW)) : \
|
|
(((ROW) >= height) ? (height-(ROW)+height-2) : \
|
|
(ROW)))
|
|
#define BC(COL) (((COL) < 0) ? (-(COL)) : \
|
|
(((COL) >= width) ? (width - (COL) + width - 2) : \
|
|
(COL)))
|
|
|
|
/*
|
|
* Optimized variants of the BR and BC macros above when the bound to check
|
|
* against (upper or lower) is known by the caller.
|
|
*/
|
|
#define BRL(ROW) (((ROW) < 0) ? -(ROW) : (ROW))
|
|
#define BRU(ROW) (((ROW) >= height) ? (height-(ROW)+height-2) : (ROW))
|
|
#define BCL(COL) (((COL) < 0) ? -(COL) : (COL))
|
|
#define BCU(COL) (((COL) >= width) ? (width-(COL)+width-2) : (COL))
|
|
|
|
/* Hrlregion */
|
|
#define HRLReset(RL) \
|
|
{ \
|
|
(RL)->feature.def.all = 0; \
|
|
(RL)->feature.shape = 0; \
|
|
(RL)->is_compl = FALSE; \
|
|
(RL)->num = 0; \
|
|
(RL)->rl = (Hrun*)(((HBYTE*)(void*)&(RL)->rl)+sizeof((RL)->rl)); \
|
|
}
|
|
|
|
|
|
/*
|
|
* Macros to test and set feature cache flags. To ensure thread safety without
|
|
* the overhead of locking, memory barriers must be used on architectures that
|
|
* do not have strongly consistent memory ordering. on all architectures, the
|
|
* compiler must be prevented from reordering memory accesses. Therefore, the
|
|
* C standard allows volatile casts to prevent compiler optimizations accross
|
|
* sequence points.
|
|
*
|
|
* NOTE: for non-gcc compatible compilers and platforms without consistent
|
|
* memory ordering, the test macros do not include the memory barrier
|
|
* instruction. If needed, we must compile
|
|
* with gcc or a compatible compiler.
|
|
*/
|
|
|
|
# define HTestF(RL,FEAT) \
|
|
(((volatile HFeatureFlags *)&(RL)->feature.def.single)->FEAT == 1)
|
|
#define HSetF(RL,FEAT) \
|
|
((volatile HFeatureFlags *)&(RL)->feature.def.single)->FEAT = 1
|
|
|
|
#define HGetFVal(RL,FEAT) ((volatile HRegFeature*)&(RL)->feature)->FEAT
|
|
|
|
#define HTestBF(RL,FEAT) (HTestF(RL,FEAT) && (HGetFVal(RL,FEAT) == TRUE))
|
|
|
|
#define HSetBF(RL,FEAT) { HSetF(RL,FEAT); HSetFVal(RL,FEAT,TRUE); }
|
|
|
|
#define HSetFVal(RL,FEAT,VAL) ((volatile HRegFeature*)&(RL)->feature)->FEAT = VAL
|
|
|
|
#define HRLSize(NumRuns) ((size_t)((NumRuns) * sizeof(Hrun) + \
|
|
(sizeof(Hrlregion))))
|
|
|
|
/* Binaerbild */
|
|
#define HTestBit(D,P) ((D)[(P)>>3] & (1<<(7-((P)&7))))
|
|
|
|
#define HDelBit(D,P) (D)[(P)>>3] &= (UINT1)(~(1<<(7-((P)&7))))
|
|
|
|
#define HSetBit(D,P) (D)[(P)>>3] |= (UINT1)(1<<(7-((P)&7)))
|
|
|
|
/* Koordinaten */
|
|
#define HLinCoor(L,C,W) (((INT4_8)(L)*(INT4_8)(W))+(INT4_8)(C))
|
|
|
|
#define HXLinCoor(L,C,W) HLinCoor(L,C,W)
|
|
|
|
#define HCol(K,W) (HIMGCOOR)(((K) % (W)))
|
|
|
|
#define HRow(K,W) (HIMGCOOR)(((K) / (W)))
|
|
|
|
#define CB(RL,I,W) HLinCoor((RL)[I].l,(RL)[I].cb,W)
|
|
|
|
#define CE(RL,I,W) HLinCoor((RL)[I].l,(RL)[I].ce,W)
|
|
|
|
|
|
#define FLinCoor(R,C,H) ((C)*(H)+(R))
|
|
|
|
|
|
/* misc */
|
|
#ifndef SGN
|
|
#define SGN(X) (((X)==0)?0:(((X)>0)?1:(-1)))
|
|
#endif
|
|
|
|
#ifndef ODD
|
|
#define ODD(X) ((X) % 2)
|
|
#endif
|
|
|
|
#ifndef EVEN
|
|
#define EVEN(X) (!((X)%2))
|
|
#endif
|
|
|
|
#ifndef MIN
|
|
#define MIN(X,Y) (((X)>(Y))?(Y):(X))
|
|
#endif
|
|
|
|
#ifndef MAX
|
|
#define MAX(X,Y) (((X)>(Y))?(X):(Y))
|
|
#endif
|
|
|
|
#define DToINT4_8(Val) ((Val)<(double)INT4_8_MIN?INT4_8_MIN: \
|
|
((Val)<INT_4_8_MAXDOUBLE?(INT4_8)(Val): \
|
|
(((INT4_8_MIN==(INT4_8)(Val))&&((Val)>0))?INT4_8_MAX: \
|
|
((INT4_8)(Val)))))
|
|
#define DToINT4(Val) ((INT4)MIN((double)INT4_MAX,MAX((double)INT4_MIN,(Val))))
|
|
#define DToINT2(Val) ((INT2)MIN((double)INT2_MAX,MAX((double)INT2_MIN,(Val))))
|
|
#define DToINT(Val) ((HINT)MIN((double)INT_MAX,MAX((double)INT_MIN,(Val))))
|
|
|
|
#define HInsideImage(R,C,WIDTH,HEIGHT) \
|
|
((((R)>=0) && ((C)>=0) && ((R)<(HEIGHT)) && ((C)<(WIDTH)))?TRUE:FALSE)
|
|
|
|
|
|
#if !defined HCkP
|
|
# if !defined(NO_SPY) && !defined(FAST)
|
|
# define HCkP(Proc) \
|
|
XHCkP(Proc)
|
|
# define XHCkP(Proc) \
|
|
do{ \
|
|
Herror _H_ERR; \
|
|
Herror _H_ERR_P; \
|
|
if (IOGetSpyProcCallSwitch()) \
|
|
IOSpyProcCall(#Proc,__LINE__,__FILE__); \
|
|
if ( HIsError(_H_ERR = (Proc))) \
|
|
{ \
|
|
if( HIsError(_H_ERR_P = HProcessErr(#Proc,_H_ERR,__LINE__,__FILE__))) \
|
|
return(_H_ERR_P); \
|
|
return(_H_ERR); \
|
|
} \
|
|
} while(0)
|
|
# else
|
|
# define HCkP(Proc) \
|
|
XHCkP(Proc)
|
|
# define XHCkP(Proc) \
|
|
do { \
|
|
Herror _H_ERR; \
|
|
if (HIsError(_H_ERR = (Proc))) \
|
|
{ \
|
|
return(_H_ERR); \
|
|
} \
|
|
} while(0)
|
|
# endif
|
|
#endif /* if not defined HCkP */
|
|
|
|
#if !defined(NO_SPY) && !defined(FAST)
|
|
# define HCkPCloseFile(Proc,File) \
|
|
XHCkPCloseFile(Proc,File)
|
|
# define XHCkPCloseFile(Proc,File) \
|
|
do { \
|
|
Herror ERR; \
|
|
Herror H_ERR_P; \
|
|
if (IOGetSpyProcCallSwitch()) \
|
|
IOSpyProcCall(#Proc,__LINE__,__FILE__); \
|
|
if ((ERR = (Proc)) != H_MSG_OK) \
|
|
{ \
|
|
fclose(File); \
|
|
if( (H_ERR_P = HProcessErr(#Proc,ERR,__LINE__,__FILE__)) != H_MSG_OK) \
|
|
return(H_ERR_P); \
|
|
return(ERR); \
|
|
} \
|
|
} while(0)
|
|
#else
|
|
# define HCkPCloseFile(Proc,File) \
|
|
XHCkPCloseFile(Proc,File)
|
|
# define XHCkPCloseFile(Proc,File) \
|
|
do { \
|
|
Herror ERR; \
|
|
if ((ERR = (Proc)) != H_MSG_OK) \
|
|
{ \
|
|
fclose(File); \
|
|
return(ERR); \
|
|
} \
|
|
} while(0)
|
|
#endif
|
|
|
|
#if !defined(NO_SPY) && !defined(FAST)
|
|
#define HCkPasync(Proc,GapingFlag,ComplFlag,ErrFlag) \
|
|
do { \
|
|
Herror ERR,H_ERR_P; \
|
|
if(IOGetSpyProcCallSwitch()) \
|
|
IOSpyProcCall(#Proc,__LINE__,__FILE__); \
|
|
if( (ERR = Proc) != H_MSG_OK) \
|
|
{ \
|
|
if( (H_ERR_P = HProcessErr(#Proc,ERR,__LINE__,__FILE__)) != H_MSG_OK) \
|
|
{ \
|
|
if(GapingFlag == FALSE) \
|
|
{ \
|
|
*ErrFlag = H_ERR_P; \
|
|
*ComplFlag = TRUE; \
|
|
} \
|
|
return(H_ERR_P); \
|
|
} \
|
|
if(GapingFlag == FALSE) \
|
|
{ \
|
|
*ErrFlag = ERR; \
|
|
*ComplFlag = TRUE; \
|
|
} \
|
|
return(ERR); \
|
|
} \
|
|
} while(0)
|
|
#else
|
|
#define HCkPasync(Proc,GapingFlag,ComplFlag,ErrFlag) \
|
|
do { \
|
|
Herror ERR; \
|
|
if( (ERR = Proc) != H_MSG_OK) \
|
|
{ \
|
|
if(GapingFlag == FALSE) \
|
|
{ \
|
|
*ErrFlag = ERR; \
|
|
*ComplFlag = TRUE; \
|
|
} \
|
|
return(ERR); \
|
|
} \
|
|
} while(0)
|
|
#endif
|
|
|
|
#define HCkE(ERR) XHCkE(ERR)
|
|
#if defined(FAST) || defined (NO_SPY)
|
|
#define XHCkE(ERR) {if (ERR != H_MSG_OK) return(ERR);}
|
|
#else
|
|
#define XHCkE(ERR) \
|
|
do { \
|
|
if (ERR != H_MSG_OK) \
|
|
{ \
|
|
if (IOGetSpyProcCallSwitch()) \
|
|
(void)HProcessErr("-",ERR,__LINE__,__FILE__); \
|
|
return(ERR); \
|
|
} \
|
|
} while(0)
|
|
#endif
|
|
|
|
#define HCkPME(ERR,PROC) XHCkPME(ERR,PROC)
|
|
#if defined(FAST) || defined (NO_SPY)
|
|
#define XHCkPME(ERR,PROC) \
|
|
do { \
|
|
Herror _terr; \
|
|
if (H_MSG_OK!=(_terr=(PROC))) (ERR)=_terr; \
|
|
} while(0)
|
|
#else
|
|
#define XHCkPME(ERR,PROC) \
|
|
{ Herror _terr; \
|
|
if (H_MSG_OK!=(_terr=(PROC))) \
|
|
{ \
|
|
if (IOGetSpyProcCallSwitch()) \
|
|
(void)HProcessErr("-",ERR,__LINE__,__FILE__); \
|
|
(ERR)=_terr; \
|
|
} \
|
|
}
|
|
#endif
|
|
|
|
#define HCkNoObj(PROC_HANDLE) \
|
|
do { \
|
|
HBOOL BOOL_PTR; \
|
|
if ((HNoInpObj(PROC_HANDLE, &BOOL_PTR) != H_MSG_OK) || \
|
|
(BOOL_PTR == TRUE)) \
|
|
{ \
|
|
Herror N_OBJ_RESULT; \
|
|
HReadGV(PROC_HANDLE,HGNoObjResult,&N_OBJ_RESULT); \
|
|
return(N_OBJ_RESULT); \
|
|
} \
|
|
} while(0)
|
|
|
|
#define HCkOnlySqr(width,height) \
|
|
if (!HIs2Pot(width) || (!HIs2Pot(height))) return(H_ERR_NPOT)
|
|
|
|
#define HIsError(ERR) ((ERR) != H_MSG_OK)
|
|
#define HIsMessage(ERR) ((ERR) == H_MSG_OK)
|
|
|
|
#ifdef FAST
|
|
#define HCkRL(PROC_HANDLE,RL,PROC,IN_OUT)
|
|
#else
|
|
#define HCkRL(PROC_HANDLE,RL,PROC,IN_OUT) \
|
|
do { \
|
|
Herror H_ERR_RL; \
|
|
INT4 CHECK_F; \
|
|
HReadGV(PROC_HANDLE,HGcheck,&CHECK_F); \
|
|
if (CHECK_F & CHECK_CHORD) \
|
|
{ \
|
|
H_ERR_RL = HRLTest(PROC_HANDLE,RL,FALSE); \
|
|
if (H_ERR_RL != H_MSG_OK) \
|
|
{ \
|
|
(void)fprintf(stderr,"runlength error (%s) %s: #%u\n", \
|
|
IN_OUT,PROC,H_ERR_RL); \
|
|
(void)fprintf(stderr,"runlength data dump in file: <<%s>>\n",RL_DUMP); \
|
|
HCkP(HRLDump(PROC_HANDLE,RL,RL_DUMP)); \
|
|
return(H_ERR_RL); \
|
|
} \
|
|
} \
|
|
} while(0)
|
|
#endif
|
|
|
|
|
|
#define LongToNet(L,N) \
|
|
{ \
|
|
unsigned char *HH; HH = (unsigned char*)&(N); \
|
|
HH[0] = ((L) >> 24) & 255; \
|
|
HH[1] = ((L) >> 16) & 255; \
|
|
HH[2] = ((L) >> 8) & 255; \
|
|
HH[3] = (L) & 255; \
|
|
}
|
|
|
|
#define NetToLong(N,L) \
|
|
{ \
|
|
unsigned char *HH; \
|
|
HH = (unsigned char*)&(N); \
|
|
L = ((INT4)(HH[0]) << 24) | \
|
|
((INT4)(HH[1]) << 16) | \
|
|
((INT4)(HH[2]) << 8) | \
|
|
((INT4)(HH[3])); \
|
|
}
|
|
|
|
#define ShortToNet(S,N) \
|
|
{ \
|
|
unsigned char *HH; HH = (unsigned char*)&(N); \
|
|
HH[0] = ((S) >> 8) & 255; \
|
|
HH[1] = (S) & 255; \
|
|
}
|
|
|
|
#define NetToShort(N,S) \
|
|
{ \
|
|
unsigned char *HH; HH = (unsigned char*)&(N); \
|
|
S = ((short)(HH[0]) << 8) | \
|
|
((short)(HH[1])); \
|
|
}
|
|
|
|
#define HAllocStringMem(PROC_HANDLE,SIZE) \
|
|
HCkP(HPAllocStringMem(PROC_HANDLE,(size_t)SIZE))
|
|
|
|
/* macros for accessing input ctrl parameters
|
|
* - without copying
|
|
* - with type and/or number check
|
|
*===========================================================================*/
|
|
#define HGetCParNum(PROC_HANDLE,Par,Num) {Herror ERR; \
|
|
ERR = HPGetCParNum(PROC_HANDLE,Par,Num); \
|
|
if (ERR != H_MSG_OK) return(ERR); }
|
|
|
|
#if !defined(NO_SPY) && !defined(SMALL)
|
|
# define HGetPElemL(PROC_HANDLE,PAR,CONVERT,ELEM,N) \
|
|
do{ \
|
|
Herror _ERR; \
|
|
_ERR = HPGetPElemL(PROC_HANDLE,PAR,CONVERT,ELEM,N); \
|
|
if (_ERR != H_MSG_OK) return(_ERR); \
|
|
_ERR = IOSpyElem(PROC_HANDLE,PAR,*(INT4_8**)(ELEM),*(INT4_8*)(N), \
|
|
LONG_PAR,TRUE); \
|
|
if (_ERR != H_MSG_OK) return(_ERR); \
|
|
}while(0)
|
|
#else
|
|
# define HGetPElemL(PROC_HANDLE,PAR,CONVERT,ELEM,N) \
|
|
HCkP( HPGetPElemL(PROC_HANDLE,PAR,CONVERT,ELEM,N) )
|
|
#endif
|
|
|
|
#if !defined(NO_SPY) && !defined(SMALL)
|
|
# define HGetPElemD(PROC_HANDLE,PAR,CONVERT,ELEM,N) \
|
|
do{ \
|
|
Herror _ERR; \
|
|
_ERR = HPGetPElemD(PROC_HANDLE,PAR,CONVERT,ELEM,N); \
|
|
if (_ERR != H_MSG_OK) return(_ERR); \
|
|
_ERR = IOSpyElem(PROC_HANDLE,PAR,*(double**)(ELEM),*(INT4_8*)(N), \
|
|
DOUBLE_PAR,TRUE); \
|
|
if (_ERR != H_MSG_OK) return(_ERR); \
|
|
}while(0)
|
|
#else
|
|
# define HGetPElemD(PROC_HANDLE,PAR,CONVERT,ELEM,N) \
|
|
HCkP( HPGetPElemD(PROC_HANDLE,PAR,CONVERT,ELEM,N) )
|
|
#endif
|
|
|
|
#if !defined(NO_SPY) && !defined(SMALL)
|
|
# define HGetPElemS(PROC_HANDLE,PAR,CONVERT,ELEM,N) \
|
|
do{ \
|
|
Herror _ERR; \
|
|
_ERR = HPGetPElemS(PROC_HANDLE,PAR,CONVERT,ELEM,N); \
|
|
if (_ERR != H_MSG_OK) return(_ERR); \
|
|
_ERR = IOSpyElem(PROC_HANDLE,PAR,*(char***)(ELEM),*(INT4_8*)(N), \
|
|
STRING_PAR,TRUE); \
|
|
if (_ERR != H_MSG_OK) return(_ERR); \
|
|
}while(0)
|
|
#else
|
|
# define HGetPElemS(PROC_HANDLE,PAR,CONVERT,ELEM,N) \
|
|
HCkP( HPGetPElemS(PROC_HANDLE,PAR,CONVERT,ELEM,N) )
|
|
#endif
|
|
|
|
/* Retrives a single handle from an input parameter */
|
|
#define HGetCElemH1(PROC_HANDLE, PAR, HTYPE, ELEM) \
|
|
HCkP(HPGetPElemH(PROC_HANDLE, PAR, HTYPE, 1, (void **)ELEM, NULL, FALSE))
|
|
|
|
/* Retrives all handles from an input parameter. The returned array contains
|
|
* pointers to the data stored in the handles. It is freed automatically
|
|
* when the operator finishes. */
|
|
#define HGetCElemH(PROC_HANDLE, PAR, HTYPE, ELEM, N) \
|
|
HCkP(HPGetPElemH(PROC_HANDLE, PAR, HTYPE, -1, (void **)ELEM, N, TRUE))
|
|
|
|
/* Retrives given number of handles from an input parameter. The returned array
|
|
* contains pointers to the data stored in the handles. It is freed
|
|
* automatically when the operator finishes. */
|
|
#define HGetCElemHN(PROC_HANDLE, PAR, HTYPE, N, ELEM) \
|
|
HCkP(HPGetPElemH(PROC_HANDLE, PAR, HTYPE, N, ELEM, TRUE))
|
|
|
|
#if !defined(NO_SPY) && !defined(SMALL)
|
|
# define HGetPElem(PROC_HANDLE,PAR,ELEM,N,TYPE) \
|
|
do{ \
|
|
Herror _ERR; \
|
|
HPGetPElem(PROC_HANDLE,PAR,ELEM,N,TYPE); \
|
|
_ERR = IOSpyElem(PROC_HANDLE,PAR,*(void**)(ELEM),*(INT4_8*)(N), \
|
|
*(HINT*)(TYPE),TRUE); \
|
|
if (_ERR != H_MSG_OK) return(_ERR); \
|
|
}while(0)
|
|
#else
|
|
# define HGetPElem(PROC_HANDLE,PAR,ELEM,N,TYPE) \
|
|
HPGetPElem(PROC_HANDLE,PAR,ELEM,N,TYPE)
|
|
#endif
|
|
|
|
#if !defined(NO_SPY) && !defined(SMALL)
|
|
# define HGetElemL(PROC_HANDLE,PAR,CONVERT,MEM_TYPE,ELEM,N) \
|
|
do{ \
|
|
Herror _ERR; \
|
|
_ERR = HPGetElemL(PROC_HANDLE,PAR,CONVERT,MEM_TYPE,ELEM,N); \
|
|
if (_ERR != H_MSG_OK) return(_ERR); \
|
|
_ERR = IOSpyElem(PROC_HANDLE,PAR,*(INT4_8**)(ELEM),*(INT4_8*)(N), \
|
|
LONG_PAR,TRUE); \
|
|
if (_ERR != H_MSG_OK) return(_ERR); \
|
|
}while(0)
|
|
#else
|
|
# define HGetElemL(PROC_HANDLE,PAR,CONVERT,MEM_TYPE,ELEM,N) \
|
|
HCkP( HPGetElemL(PROC_HANDLE,PAR,CONVERT,MEM_TYPE,ELEM,N) )
|
|
#endif
|
|
|
|
#if !defined(NO_SPY) && !defined(SMALL)
|
|
# define HGetElemD(PROC_HANDLE,PAR,CONVERT,MEM_TYPE,ELEM,N) \
|
|
do{ \
|
|
Herror _ERR; \
|
|
_ERR = HPGetElemD(PROC_HANDLE,PAR,CONVERT,MEM_TYPE,ELEM,N); \
|
|
if (_ERR != H_MSG_OK) return(_ERR); \
|
|
_ERR = IOSpyElem(PROC_HANDLE,PAR,*(double**)(ELEM),*(INT4_8*)(N), \
|
|
DOUBLE_PAR,TRUE); \
|
|
if (_ERR != H_MSG_OK) return(_ERR); \
|
|
}while(0)
|
|
#else
|
|
# define HGetElemD(PROC_HANDLE,PAR,CONVERT,MEM_TYPE,ELEM,N) \
|
|
HCkP( HPGetElemD(PROC_HANDLE,PAR,CONVERT,MEM_TYPE,ELEM,N) )
|
|
#endif
|
|
|
|
#if !defined(NO_SPY) && !defined(SMALL)
|
|
# define HGetElemS(PROC_HANDLE,PAR,CONVERT,MEM_TYPE,ELEM,N) \
|
|
do{ \
|
|
Herror _ERR; \
|
|
_ERR = HPGetElemS(PROC_HANDLE,PAR,CONVERT,MEM_TYPE,ELEM,N); \
|
|
if (_ERR != H_MSG_OK) return(_ERR); \
|
|
_ERR = IOSpyElem(PROC_HANDLE,PAR,*(char***)(ELEM),*(INT4_8*)(N), \
|
|
STRING_PAR,TRUE); \
|
|
if (_ERR != H_MSG_OK) return(_ERR); \
|
|
}while(0)
|
|
#else
|
|
# define HGetElemS(PROC_HANDLE,PAR,CONVERT,MEM_TYPE,ELEM,N) \
|
|
HCkP( HPGetElemS(PROC_HANDLE,PAR,CONVERT,MEM_TYPE,ELEM,N) )
|
|
#endif
|
|
|
|
#if !defined(NO_SPY) && !defined(SMALL)
|
|
# define HCopyElemL(PROC_HANDLE,PAR,CONVERT,ELEM,N) \
|
|
do{ \
|
|
Herror _ERR; \
|
|
_ERR = HPCopyElemL(PROC_HANDLE,PAR,CONVERT,ELEM,N); \
|
|
if (_ERR != H_MSG_OK) return(_ERR); \
|
|
_ERR = IOSpyElem(PROC_HANDLE,PAR,ELEM,*(INT4_8*)(N),LONG_PAR,TRUE); \
|
|
if (_ERR != H_MSG_OK) return(_ERR); \
|
|
}while(0)
|
|
#else
|
|
# define HCopyElemL(PROC_HANDLE,PAR,CONVERT,ELEM,N) \
|
|
HCkP( HPCopyElemL(PROC_HANDLE,PAR,CONVERT,ELEM,N) )
|
|
#endif
|
|
|
|
#if !defined(NO_SPY) && !defined(SMALL)
|
|
# define HCopyElemD(PROC_HANDLE,PAR,CONVERT,ELEM,N) \
|
|
do{ \
|
|
Herror _ERR; \
|
|
_ERR = HPCopyElemD(PROC_HANDLE,PAR,CONVERT,ELEM,N); \
|
|
if (_ERR != H_MSG_OK) return(_ERR); \
|
|
_ERR = IOSpyElem(PROC_HANDLE,PAR,ELEM,*(INT4_8*)(N),DOUBLE_PAR, \
|
|
TRUE); \
|
|
if (_ERR != H_MSG_OK) return(_ERR); \
|
|
}while(0)
|
|
#else
|
|
# define HCopyElemD(PROC_HANDLE,PAR,CONVERT,ELEM,N) \
|
|
HCkP( HPCopyElemD(PROC_HANDLE,PAR,CONVERT,ELEM,N) )
|
|
#endif
|
|
|
|
/*
|
|
* Note: since there is no easy way to implement the SPY functionality
|
|
* for HCopyElemF, we don't bother.
|
|
*/
|
|
# define HCopyElemF(PROC_HANDLE,PAR,CONVERT,ELEM,N) \
|
|
HCkP( HPCopyElemF(PROC_HANDLE,PAR,CONVERT,ELEM,N) )
|
|
|
|
|
|
/* HGetPParN:
|
|
* specify the exact number of the read parameter (any type)
|
|
*---------------------------------------------------------------------------*/
|
|
#if !defined(NO_SPY) && !defined(SMALL)
|
|
# define HGetPParN(PROC_HANDLE,PAR,NUM,VAL) { \
|
|
INT4_8 _NUM; \
|
|
Herror ERR = HPGetPPar(PROC_HANDLE,PAR,VAL,&_NUM); \
|
|
if (ERR != H_MSG_OK) return ERR; \
|
|
if (NUM != _NUM) return (H_ERR_WIPN1-1)+(PAR); \
|
|
ERR = IOSpyCPar(PROC_HANDLE,PAR,*VAL,_NUM,TRUE); \
|
|
if (ERR != H_MSG_OK) return ERR; }
|
|
#else
|
|
# define HGetPParN(PROC_HANDLE,PAR,NUM,VAL) { \
|
|
INT4_8 _NUM; \
|
|
Herror ERR = HPGetPPar(PROC_HANDLE,PAR,VAL,&_NUM); \
|
|
if (ERR != H_MSG_OK) return ERR; \
|
|
if (NUM != _NUM) return (H_ERR_WIPN1-1)+(PAR); }
|
|
#endif
|
|
|
|
|
|
/* HGetPParMM:
|
|
* the value number of the read parameter is expected to be within a
|
|
* certain range
|
|
*---------------------------------------------------------------------------*/
|
|
#if !defined(NO_SPY) && !defined(SMALL)
|
|
# define HGetPParMM(PROC_HANDLE,PAR,MIN,MAX,VAL,NUM) { \
|
|
Herror ERR = HPGetPPar(PROC_HANDLE,PAR,VAL,NUM); \
|
|
if (ERR != H_MSG_OK) return ERR; \
|
|
if (*NUM < MIN || *NUM > MAX) return (H_ERR_WIPN1-1)+(PAR); \
|
|
ERR = IOSpyCPar(PROC_HANDLE,PAR,*VAL,*(NUM),TRUE); \
|
|
if (ERR != H_MSG_OK) return ERR; }
|
|
#else
|
|
# define HGetPParMM(PROC_HANDLE,PAR,MIN,MAX,VAL,NUM) { \
|
|
Herror ERR = HPGetPPar(PROC_HANDLE,PAR,VAL,NUM); \
|
|
if (ERR != H_MSG_OK) return ERR; \
|
|
if (*NUM < MIN || *NUM > MAX) return (H_ERR_WIPN1-1)+(PAR); }
|
|
#endif
|
|
|
|
|
|
/* HGetPParT:
|
|
* specify the expected type(s) of the read parameter
|
|
*---------------------------------------------------------------------------*/
|
|
#if !defined(NO_SPY) && !defined(SMALL)
|
|
# define HGetPParT(PROC_HANDLE,PAR,TYPE,VAL,NUM) { \
|
|
INT4_8 _IDX; \
|
|
Herror ERR = HPGetPPar(PROC_HANDLE,PAR,VAL,NUM); \
|
|
if (ERR != H_MSG_OK) return ERR; \
|
|
for (_IDX=0; _IDX<*(NUM); _IDX++) \
|
|
if (((TYPE) & (*(VAL))[_IDX].type) == 0) return (H_ERR_WIPT1-1)+(PAR); \
|
|
ERR = IOSpyCPar(PROC_HANDLE,PAR,*(VAL),*(NUM),TRUE); \
|
|
if (ERR != H_MSG_OK) return ERR; }
|
|
#else
|
|
# define HGetPParT(PROC_HANDLE,PAR,TYPE,VAL,NUM) { \
|
|
INT4_8 _IDX; \
|
|
Herror ERR = HPGetPPar(PROC_HANDLE,PAR,VAL,NUM); \
|
|
if (ERR != H_MSG_OK) return ERR; \
|
|
for (_IDX=0; _IDX<*(NUM); _IDX++) \
|
|
if (((TYPE) & (*(VAL))[_IDX].type) == 0) return (H_ERR_WIPT1-1)+(PAR); }
|
|
#endif
|
|
|
|
|
|
/* HGetPParTN:
|
|
* specify the exact number and the expected type(s) of the read parameter
|
|
*---------------------------------------------------------------------------*/
|
|
#if !defined(NO_SPY) && !defined(SMALL)
|
|
# define HGetPParTN(PROC_HANDLE,PAR,TYPE,NUM,VAL) { \
|
|
INT4_8 _IDX, _NUM; \
|
|
Herror ERR = HPGetPPar(PROC_HANDLE,PAR,VAL,&_NUM); \
|
|
if (ERR != H_MSG_OK) return ERR; \
|
|
if ((NUM) != _NUM) return (H_ERR_WIPN1-1)+(PAR); \
|
|
for (_IDX=0; _IDX<_NUM; _IDX++) \
|
|
if (((TYPE) & (*(VAL))[_IDX].type) == 0) return (H_ERR_WIPT1-1)+(PAR); \
|
|
ERR = IOSpyCPar(PROC_HANDLE,PAR,*(VAL),_NUM,TRUE); \
|
|
if (ERR != H_MSG_OK) return ERR; }
|
|
#else
|
|
# define HGetPParTN(PROC_HANDLE,PAR,TYPE,NUM,VAL) { \
|
|
INT4_8 _IDX, _NUM; \
|
|
Herror ERR = HPGetPPar(PROC_HANDLE,PAR,VAL,&_NUM); \
|
|
if (ERR != H_MSG_OK) return ERR; \
|
|
if ((NUM) != _NUM) return (H_ERR_WIPN1-1)+(PAR); \
|
|
for (_IDX=0; _IDX<_NUM; _IDX++) \
|
|
if (((TYPE) & (*(VAL))[_IDX].type) == 0) return (H_ERR_WIPT1-1)+(PAR); }
|
|
#endif
|
|
|
|
|
|
/* HGetPParTMM:
|
|
* specify a range for the number of the read parameters as well as
|
|
* the expected type(s)
|
|
*---------------------------------------------------------------------------*/
|
|
#if !defined(NO_SPY) && !defined(SMALL)
|
|
# define HGetPParTMM(PROC_HANDLE,PAR,TYPE,MIN,MAX,VAL,NUM) { \
|
|
INT4_8 _IDX; \
|
|
Herror ERR = HPGetPPar(PROC_HANDLE,PAR,VAL,NUM); \
|
|
if (ERR != H_MSG_OK) return ERR; \
|
|
if (*(NUM) < MIN || *(NUM) > MAX) return (H_ERR_WIPN1-1)+(PAR); \
|
|
for (_IDX=0; _IDX<*(NUM); _IDX++) \
|
|
if (((TYPE) & (*(VAL))[_IDX].type) == 0) return (H_ERR_WIPT1-1)+(PAR); \
|
|
ERR = IOSpyCPar(PROC_HANDLE,PAR,*(VAL),*(NUM),TRUE); \
|
|
if (ERR != H_MSG_OK) return ERR; }
|
|
#else
|
|
# define HGetPParTMM(PROC_HANDLE,PAR,TYPE,MIN,MAX,VAL,NUM) { \
|
|
INT4_8 _IDX; \
|
|
Herror ERR = HPGetPPar(PROC_HANDLE,PAR,VAL,NUM); \
|
|
if (ERR != H_MSG_OK) return ERR; \
|
|
if (*(NUM) < MIN || *(NUM) > MAX) return (H_ERR_WIPN1-1)+(PAR); \
|
|
for (_IDX=0; _IDX<*(NUM); _IDX++) \
|
|
if (((TYPE) & (*(VAL))[_IDX].type) == 0) return (H_ERR_WIPT1-1)+(PAR); }
|
|
#endif
|
|
|
|
#if !defined(NO_SPY) && !defined(SMALL)
|
|
# define HGetPPar(PROC_HANDLE,P,V,N) {Herror ERR; \
|
|
ERR = HPGetPPar(PROC_HANDLE,P,V,N); \
|
|
if (ERR != H_MSG_OK) return(ERR); \
|
|
ERR = IOSpyCPar(PROC_HANDLE,P,*V,*N,TRUE); \
|
|
if (ERR != H_MSG_OK) return(ERR); }
|
|
#else
|
|
# define HGetPPar(PROC_HANDLE,P,V,N) {Herror ERR; \
|
|
ERR = HPGetPPar(PROC_HANDLE,P,V,N); \
|
|
if (ERR != H_MSG_OK) return(ERR); }
|
|
#endif
|
|
|
|
|
|
#if !defined(NO_SPY) && !defined(SMALL)
|
|
# define HGetPar(PROC_HANDLE,Par,Kind,Val,Num) {Herror ERR; \
|
|
ERR = HPGetPar(PROC_HANDLE,Par,ANY_ELEM,Kind,Val,(INT4_8)0, \
|
|
(INT4_8)10000000,Num); \
|
|
if (ERR != H_MSG_OK) return(ERR); \
|
|
ERR = IOSpyCPar(PROC_HANDLE,Index,Val,*(Num),TRUE); \
|
|
if (ERR != H_MSG_OK) return(ERR); }
|
|
#else
|
|
# define HGetPar(Par,Kind,Val,Num) {Herror ERR; \
|
|
ERR = HPGetPar(Par,ANY_ELEM,Kind,Val,(INT4_8)0, \
|
|
(INT4_8)10000000,Num); \
|
|
if (ERR != H_MSG_OK) return(ERR); }
|
|
#endif
|
|
|
|
#if !defined(NO_SPY) && !defined(SMALL)
|
|
# define HGetSPar(PROC_HANDLE,Index,Type,Val,N) {INT4_8 _HN; Herror ERR; \
|
|
ERR = HPGetCPar(PROC_HANDLE,Index,Type,Val,(INT4_8)(N),(INT4_8)(N),&_HN); \
|
|
if (ERR != H_MSG_OK) return(ERR); \
|
|
ERR = IOSpyCPar(PROC_HANDLE,Index,Val,_HN,TRUE); \
|
|
if (ERR != H_MSG_OK) return(ERR); }
|
|
#else
|
|
# define HGetSPar(PROC_HANDLE,Index,Type,Val,N) {INT4_8 _HN; Herror ERR; \
|
|
ERR = HPGetCPar(PROC_HANDLE,Index,Type,Val,(INT4_8)(N),(INT4_8)(N),&_HN); \
|
|
if (ERR != H_MSG_OK) return(ERR); }
|
|
#endif
|
|
|
|
|
|
#if !defined(NO_SPY) && !defined(SMALL)
|
|
# define HGetCPar(PROC_HANDLE,Index,InpType,Val,Min,Max,ResNum) {Herror ERR; \
|
|
ERR = HPGetCPar(PROC_HANDLE,Index,InpType,Val,(INT4_8)(Min), \
|
|
(INT4_8)(Max),ResNum); \
|
|
if (ERR != H_MSG_OK) return(ERR); \
|
|
ERR = IOSpyCPar(PROC_HANDLE,Index,Val,(INT4_8)*ResNum,TRUE); \
|
|
if (ERR != H_MSG_OK) return(ERR); }
|
|
#else
|
|
# define HGetCPar(PROC_HANDLE,Index,InpType,Val,Min,Max,ResNum) {Herror ERR; \
|
|
ERR = HPGetCPar(PROC_HANDLE,Index,InpType,Val,(INT4_8)(Min), \
|
|
(INT4_8)(Max),ResNum); \
|
|
if (ERR != H_MSG_OK) return(ERR); }
|
|
#endif
|
|
|
|
#if !defined(NO_SPY) && !defined(SMALL)
|
|
# define HGetFPar(PROC_HANDLE,Index,Type,Val,Num) \
|
|
{ \
|
|
int _HT; INT4_8 _HN; Herror ERR; \
|
|
ERR = HPGetPar(PROC_HANDLE,Index,Type,&_HT,Val,(INT4_8)(Num), \
|
|
(INT4_8)(Num),&_HN); \
|
|
if (ERR != H_MSG_OK) return(ERR); \
|
|
ERR = IOSpyPar(PROC_HANDLE,Index,_HT,Val,_HN,TRUE); \
|
|
if (ERR != H_MSG_OK) return(ERR); \
|
|
}
|
|
#else
|
|
# define HGetFPar(PROC_HANDLE,Index,Type,Val,Num) \
|
|
{ \
|
|
int _HT; INT4_8 _HN; Herror ERR; \
|
|
ERR = HPGetPar(PROC_HANDLE,Index,Type,&_HT,Val,(INT4_8)(Num), \
|
|
(INT4_8)(Num),&_HN); \
|
|
if (ERR != H_MSG_OK) return(ERR); \
|
|
}
|
|
#endif
|
|
|
|
#if !defined(NO_SPY) && !defined(SMALL)
|
|
# define HGetEPar(PROC_HANDLE,Index,InpType,ResType,Val,Min,Max,Num) \
|
|
{ \
|
|
Herror ERR; \
|
|
ERR = HPGetPar(PROC_HANDLE,Index,InpType,ResType,Val,(INT4_8)(Min), \
|
|
(INT4_8)(Max),Num); \
|
|
if (ERR != H_MSG_OK) return(ERR); \
|
|
ERR = IOSpyPar(PROC_HANDLE,Index,*ResType,Val,(INT4_8)*Num,TRUE); \
|
|
if (ERR != H_MSG_OK) return(ERR); \
|
|
}
|
|
#else
|
|
# define HGetEPar(PROC_HANDLE,Index,InpType,ResType,Val,Min,Max,Num) \
|
|
{ \
|
|
Herror ERR; \
|
|
ERR = HPGetPar(PROC_HANDLE,Index,InpType,ResType,Val,(INT4_8)(Min), \
|
|
(INT4_8)(Max),Num); \
|
|
if (ERR != H_MSG_OK) return(ERR); \
|
|
}
|
|
#endif
|
|
|
|
/* macros for accessing ctrl output parameters
|
|
*===========================================================================*/
|
|
|
|
#define HPutPElem(PROC_HANDLE,PAR,ELEM,NUM,TYPE) \
|
|
do{ \
|
|
HCkP( HPPutPElem(PROC_HANDLE,PAR,ELEM,NUM,TYPE)); \
|
|
} while(0)
|
|
|
|
#define HPutElem(PROC_HANDLE,PAR,ELEM,NUM,TYPE) \
|
|
do{ \
|
|
HCkP( HPPutElem(PROC_HANDLE,PAR,ELEM,NUM,TYPE)); \
|
|
} while(0)
|
|
|
|
#if !defined(NO_SPY) && !defined(SMALL)
|
|
# define HPutPar(PROC_HANDLE,P,K,V,N) {Herror ERR; \
|
|
ERR = IOSpyPar(PROC_HANDLE,P,K,V,(INT4_8)(N),FALSE); \
|
|
if (ERR != H_MSG_OK) return(ERR); \
|
|
ERR = HPPutPar(PROC_HANDLE,P,K,V,(INT4_8)(N)); \
|
|
if (ERR != H_MSG_OK) return(ERR); }
|
|
#else
|
|
# define HPutPar(PROC_HANDLE,P,K,V,N) {Herror ERR; \
|
|
ERR = HPPutPar(PROC_HANDLE,P,K,V,(INT4_8)(N)); \
|
|
if (ERR != H_MSG_OK) return(ERR); }
|
|
#endif
|
|
|
|
#if !defined(NO_SPY) && !defined(SMALL)
|
|
# define HPutCPar(PROC_HANDLE,P,V,N) {Herror ERR; \
|
|
ERR = IOSpyCPar(PROC_HANDLE,P,V,(INT4_8)N,FALSE); \
|
|
if (ERR != H_MSG_OK) return(ERR); \
|
|
ERR = HPPutCPar(PROC_HANDLE,P,V,(INT4_8)(N)); \
|
|
if (ERR != H_MSG_OK) return(ERR); }
|
|
#else
|
|
# define HPutCPar(PROC_HANDLE,P,V,N) {Herror ERR; \
|
|
ERR = HPPutCPar(PROC_HANDLE,P,V,(INT4_8)(N)); \
|
|
if (ERR != H_MSG_OK) return(ERR); }
|
|
#endif
|
|
|
|
#if !defined(NO_SPY) && !defined(SMALL)
|
|
# define HPutPPar(PROC_HANDLE,P,V,N) {Herror ERR; \
|
|
ERR = IOSpyCPar(PROC_HANDLE,P,V,(INT4_8)N,FALSE); \
|
|
if (ERR != H_MSG_OK) return(ERR); \
|
|
ERR = HPPutPPar(PROC_HANDLE,P,V,N); \
|
|
if (ERR != H_MSG_OK) return(ERR); }
|
|
#else
|
|
# define HPutPPar(PROC_HANDLE,P,V,N) {Herror ERR; \
|
|
ERR = HPPutPPar(PROC_HANDLE,P,V,N); \
|
|
if (ERR != H_MSG_OK) return(ERR); }
|
|
#endif
|
|
|
|
/* Write NUM handle references in the output control PAR.
|
|
* HANDLETYPE is the type of the corresponding handles (const HhandleInfo*).
|
|
* ELEM points to an array that holds NUM elements.
|
|
*
|
|
* IMPORTANT: The output control variable gains ownership of all pointers that
|
|
* are in ELEM. When aborting an operator with an error,
|
|
* those values MUST NOT be cleared inside the operator's code,
|
|
* but will be cleared automatically when cleaning the output
|
|
* control variable.
|
|
*/
|
|
#define HPutElemH(PROC_HANDLE, PAR, ELEM, NUM, HANDLETYPE) \
|
|
do \
|
|
{ \
|
|
HCkP(HPPutElemH(PROC_HANDLE, PAR, ELEM, NUM, HANDLETYPE)); \
|
|
} while (0)
|
|
|
|
/* Allocates one handle in the output control parameter PAR.
|
|
* HANDLETYPE is the type of the corresponding handles (const HhandleInfo*).
|
|
* ELEM is modified to point to where the new tool can be allocated.
|
|
*
|
|
* IMPORTANT: The output control variable gains ownership of the pointer in
|
|
* ELEM. When aborting an operator with an error,
|
|
* the value MUST NOT be cleared inside the operator's code,
|
|
* but will be cleared automatically when cleaning the output
|
|
* control variable.
|
|
*/
|
|
#define HAllocOutputHandle(PROC_HANDLE, PAR, ELEM, HANDLETYPE) \
|
|
HXAllocOutputHandle(PROC_HANDLE, PAR, (void ***)ELEM, HANDLETYPE)
|
|
|
|
/* macros for accessing iconic object parameters
|
|
*===========================================================================*/
|
|
|
|
#define HNumOfChannels(PROC_HANDLE,OBJ,NUM) \
|
|
HCkP(HPNumOfChannels(PROC_HANDLE,(HINT)1, \
|
|
(INT4_8)OBJ,NUM))
|
|
|
|
#define HAllObj(PROC_HANDLE,VAR,Hkey,I) \
|
|
I=0; \
|
|
while ((HCheckInpObjNum(PROC_HANDLE,VAR,I+1) == TRUE) && \
|
|
(HPGetObj(PROC_HANDLE,VAR,(INT4_8)++I, &Hkey) == H_MSG_OK) && \
|
|
(Hkey != H_UNDEFINED))
|
|
|
|
#define HAllOutpObj(PROC_HANDLE,VAR,Hkey,I) \
|
|
I=0; \
|
|
while ((HCheckOutpObjNum(PROC_HANDLE,VAR,I+1) == TRUE) && \
|
|
(HPGetOutpObj(PROC_HANDLE,VAR,(INT4_8)++I, &Hkey) == H_MSG_OK) && \
|
|
(Hkey != H_UNDEFINED))
|
|
|
|
#define HAllSegm(PROC_HANDLE,RL,IMAGES,MAX_CHANNELS,I) \
|
|
I=0; \
|
|
while ((HCheckInpObjNum(PROC_HANDLE,1,I+1) == TRUE) && \
|
|
(HPAllSegm(PROC_HANDLE,(INT4_8)++I,RL,IMAGES,MAX_CHANNELS) == H_MSG_OK))
|
|
|
|
#define HAllReg(PROC_HANDLE,RL,I) \
|
|
I=0; \
|
|
while ((HCheckInpObjNum(PROC_HANDLE,1,I+1) == TRUE) && \
|
|
(HPAllReg(PROC_HANDLE,(INT4_8)++I,RL) == H_MSG_OK))
|
|
|
|
#define HAllFilter(PROC_HANDLE,RL,IMA_IN,IMA_OUT,MAX_CHANNELS,I) \
|
|
I=0; \
|
|
while ((HCheckInpObjNum(PROC_HANDLE,1,I+1) == TRUE) && \
|
|
(HPAllFilter(PROC_HANDLE,(INT4_8)++I,RL,IMA_IN,IMA_OUT,MAX_CHANNELS) == H_MSG_OK))
|
|
|
|
#define HAllComp(PROC_HANDLE,OBJ_IN,IM_IN_KEY,IM_IN,INDEX) \
|
|
HPGetComp(PROC_HANDLE,OBJ_IN,IMAGE_INDEX,&IM_IN_KEY); \
|
|
if (IM_IN_KEY == H_UNDEFINED) return(H_ERR_AUDI); \
|
|
for(INDEX = IMAGE_INDEX; \
|
|
(HPGetComp(PROC_HANDLE,OBJ_IN,INDEX,&IM_IN_KEY) == H_MSG_OK) && \
|
|
(IM_IN_KEY != H_UNDEFINED) && \
|
|
HPGetImage(PROC_HANDLE,IM_IN_KEY,&IM_IN) == H_MSG_OK; \
|
|
INDEX++)
|
|
|
|
#define HIfFirstComp(INDEX) if(INDEX == IMAGE_INDEX)
|
|
|
|
#define HAllFilter2(PROC_HANDLE,RL,IMA_IN1,IMA_IN2,IMA_OUT,MAX_CHANNELS,I) \
|
|
I=0; \
|
|
while ((HCheckInpObjNum(PROC_HANDLE,1,I+1) == TRUE) && \
|
|
(HPAllFilter2(PROC_HANDLE,(INT4_8)++I,RL,IMA_IN1,IMA_IN2,IMA_OUT,MAX_CHANNELS) == H_MSG_OK))
|
|
|
|
#define HGetFRL(PROC_HANDLE,Key,region) \
|
|
HCkP(HPGetFRL(PROC_HANDLE,Key,region))
|
|
|
|
#define HGetRL(PROC_HANDLE,Key,region) \
|
|
HCkP(HPGetRL(PROC_HANDLE,Key,region))
|
|
|
|
#define HGetFDRL(PROC_HANDLE,Key,region) \
|
|
HCkP(HPGetFDRL(PROC_HANDLE,Key,region))
|
|
|
|
#define HGetDRL(PROC_HANDLE,Key,region) \
|
|
HCkP(HPGetDRL(PROC_HANDLE,Key,region))
|
|
|
|
#define HGetURL(PROC_HANDLE,Par,region) \
|
|
HCkP(HPGetURL(PROC_HANDLE,Par,region))
|
|
|
|
#define HGetImage(PROC_HANDLE,Key,Image) \
|
|
HCkP(HPGetImage(PROC_HANDLE,Key,Image))
|
|
|
|
#define HGetImageInfo(PROC_HANDLE,Key,Image) \
|
|
HCkP(HP0GetCDImage(PROC_HANDLE,Key,Image))
|
|
|
|
#define HGetDImage(PROC_HANDLE,Key,Comp,Image) \
|
|
HCkP(HPGetDImage(PROC_HANDLE,Key,Comp,Image))
|
|
|
|
#define HDelObj(PROC_HANDLE,Key) HCkP(HPDelObj(PROC_HANDLE,Key))
|
|
|
|
#define HNewRegion(PROC_HANDLE,RL) HCkP(HPNewRegion(PROC_HANDLE,RL))
|
|
|
|
#define HPushRegion(PROC_HANDLE,RL) HCkP(HPPushRegion(PROC_HANDLE,RL))
|
|
|
|
#define HPushGlobalRegion(PROC_HANDLE,RL) \
|
|
HCkP(HPPushGlobalRegion(PROC_HANDLE,RL))
|
|
|
|
#define HDupObj(PROC_HANDLE,INDEX) HCkP(HPDupObj(PROC_HANDLE,INDEX))
|
|
|
|
#define HPutDRL(PROC_HANDLE,Key,RL,KEY_PTR) \
|
|
HCkP(HPPutDRL(PROC_HANDLE,Key,RL,KEY_PTR));
|
|
|
|
#define HPutPRLComp(PROC_HANDLE,ObjKey,RL,KEY_PTR) \
|
|
HCkP(HPPutPRLComp(PROC_HANDLE,ObjKey,RL,KEY_PTR));
|
|
|
|
#define HPutRect(PROC_HANDLE,Key,W,H) HCkP(HPPutRect(PROC_HANDLE,Key,W,H));
|
|
|
|
#define HPutImage(PROC_HANDLE,Image,Copy,KEY_PTR) \
|
|
HCkP(HPPutImage(PROC_HANDLE,Image,Copy,KEY_PTR));
|
|
|
|
#define HPutDImage(PROC_HANDLE,Key,Comp,Image,Copy,KEY_PTR) \
|
|
HCkP(HPPutDImage(PROC_HANDLE,Key,Comp,Image,Copy,KEY_PTR));
|
|
|
|
#define HDefObj(PROC_HANDLE,Obj,Key,Comp) \
|
|
HCkP(HPDefObj(PROC_HANDLE,Obj,Key,Comp));
|
|
|
|
#define HCrObj(PROC_HANDLE,Par,KEY_PTR) HCkP(HPCrObj(PROC_HANDLE,Par,KEY_PTR));
|
|
|
|
#define HCopyObj(PROC_HANDLE,Key,Par,KEY_PTR) \
|
|
HCkP(HPCopyObj(PROC_HANDLE,Key,Par,KEY_PTR));
|
|
|
|
#define HGetObj(PROC_HANDLE,Par,Num,KEY_PTR) \
|
|
HCkP(HPGetObj(PROC_HANDLE,Par,(INT4_8)Num,KEY_PTR));
|
|
|
|
#define HGetObjNum(PROC_HANDLE,Par,Num) \
|
|
HCkP(HPGetObjNum(PROC_HANDLE,Par,Num));
|
|
|
|
#define HGetComp(PROC_HANDLE,Obj,CompId,Id) \
|
|
HCkP(HPGetComp(PROC_HANDLE,Obj,CompId,Id));
|
|
|
|
#define HGetXLD(PROC_HANDLE,DBKEY,TYPE,XLD) \
|
|
{ \
|
|
HINT TMP_TYPE; HINT NUM_USES; Hkey *USES; \
|
|
HCkP(HPGetXLD(PROC_HANDLE,DBKEY,&TMP_TYPE,XLD,&USES,&NUM_USES)); \
|
|
if (TYPE != TMP_TYPE) return(H_ERR_XLDWT); \
|
|
}
|
|
|
|
#define HGetSXLD(PROC_HANDLE,DBKEY,TYPE,XLD) \
|
|
{ \
|
|
HINT NUM_USES; Hkey *USES; \
|
|
HCkP(HPGetXLD(PROC_HANDLE,DBKEY,TYPE,XLD,&USES,&NUM_USES)); \
|
|
}
|
|
|
|
#define HCrXLD(PROC_HANDLE,PAR,XLD,TYPE,USES,NUM_USES,FREE,KEY_PTR) \
|
|
HCkP(HPCrXLD(PROC_HANDLE,PAR,XLD,TYPE,USES,NUM_USES,FREE,KEY_PTR));
|
|
|
|
|
|
/* -------- Makros for accessing HALCON operator context information ------- */
|
|
/* write a global context Variable ('normal' variable) */
|
|
#define HWriteGV(ProcHandle,Element,Value) \
|
|
HCkP(HAccessGlVar(ProcHandle,Element,GV_WRITE_INFO,NULL,(double)Value,(char *)NULL,(Hkey)NULL,0))
|
|
/* write a global context Variable ('normal' variable) with index */
|
|
#define HWriteGVI(ProcHandle,Element,Value,Index) \
|
|
HCkP(HAccessGlVar(ProcHandle,Element,GV_WRITE_INFO,NULL,(double)Value,(char *)NULL,(Hkey)NULL,Index))
|
|
/* write a global context Variable (String) */
|
|
#define HWriteGVS(ProcHandle,Element,String) \
|
|
HCkP(HAccessGlVar(ProcHandle,Element,GV_WRITE_INFO,NULL,(double)0,String,(Hkey)NULL,0))
|
|
/* write a global context variable (String in element of Array) */
|
|
#define HWriteGVSA(ProcHandle,Element,String,Index) \
|
|
HCkP(HAccessGlVar(ProcHandle,Element,GV_WRITE_INFO,NULL,(double)0,String,(Hkey)NULL,Index))
|
|
/* write a global context variable (HALCON object Key in element of Array) */
|
|
#define HWriteGVKA(ProcHandle,Element,Key,Index) \
|
|
HCkP(HAccessGlVar(ProcHandle,Element,GV_WRITE_INFO,NULL,(double)0,(char *)NULL,Key,Index))
|
|
/* write a global context variable (Pointer in element of Array) */
|
|
#define HWriteGVPA(ProcHandle,Element,Pointer,Index) \
|
|
HCkP(HAccessGlVar(ProcHandle,Element,GV_WRITE_INFO,Pointer,(double)0,(char *)NULL,NULL,Index))
|
|
/* write a global context variable (element of Array) */
|
|
#define HWriteGVA(ProcHandle,Element,Value,Index) \
|
|
HCkP(HAccessGlVar(ProcHandle,Element,GV_WRITE_INFO,NULL,(double)Value,(char *)NULL,(Hkey)NULL,Index))
|
|
/* write a global context Variable ('normal' variable); force changement of */
|
|
/* the corresponding reference version */
|
|
#define HWriteGVR(ProcHandle,Element,Value) \
|
|
HCkP(HAccessGlVar(ProcHandle,Element,GV_WRITE_REF,NULL,(double)Value,(char *)NULL,(Hkey)NULL,0))
|
|
/* write a global context Variable ('normal' variable) with index; */
|
|
/* force changement of the corresponding reference version */
|
|
#define HWriteGVRI(ProcHandle,Element,Value,Index) \
|
|
HCkP(HAccessGlVar(ProcHandle,Element,GV_WRITE_REF,NULL,(double)Value,(char *)NULL,(Hkey)NULL,Index))
|
|
/* read a global context Variable ('normal' variable) */
|
|
#define HReadGV(ProcHandle,Element,Buffer) \
|
|
HCkP(HAccessGlVar(ProcHandle,Element,GV_READ_INFO,Buffer,(double)0,(char *)NULL,(Hkey)NULL,0))
|
|
/* read a global context Variable (element of Array) */
|
|
#define HReadGVA(ProcHandle,Element,Buffer,Index) \
|
|
HCkP(HAccessGlVar(ProcHandle,Element,GV_READ_INFO,Buffer,(double)0,(char *)NULL,(Hkey)NULL,Index))
|
|
/* read a global context Variable from reference */
|
|
#define HReadGVR(ProcHandle,Element,Buffer) \
|
|
HCkP(HAccessGlVar(ProcHandle,Element,GV_READ_REF,Buffer,(double)0,(char *)NULL,(Hkey)NULL,0))
|
|
/* read a global context Variable from reference with index */
|
|
#define HReadGVRI(ProcHandle,Element,Buffer,Index) \
|
|
HCkP(HAccessGlVar(ProcHandle,Element,GV_READ_REF,Buffer,(double)0,(char *)NULL,(Hkey)NULL,Index))
|
|
/* initialize a global context Variable (Array) */
|
|
#define HInitGVA(ProcHandle,Element,Address) \
|
|
HCkP(HAccessGlVar(ProcHandle,Element,GV_INIT_INFO,Address,(double)0,(char *)NULL,(Hkey)NULL,0))
|
|
/* get the address of a global context Variable (Array) */
|
|
#define HGetAddrGVA(ProcHandle,Element,Buffer) \
|
|
HCkP(HAccessGlVar(ProcHandle,Element,GV_GET_ADRESS,Buffer,(double)0,(char *)NULL,(Hkey)NULL,0))
|
|
/* realloc the memory of a global context Variable (Array) */
|
|
#define HReallocGVA(ProcHandle,Element,NewSize) \
|
|
HCkP(HAccessGlVar(ProcHandle,Element,GV_REALLOC_A,NULL,(double)0,(char *)NULL,(Hkey)NULL,NewSize))
|
|
|
|
|
|
/* lock a global context mutex variable */
|
|
#if defined H_PARALLEL
|
|
# define HLockGVM(ProcHandle,Element) \
|
|
HCkP(HAccessGlVar(ProcHandle,Element,GV_LOCK,NULL,(double)0,(char *)NULL, \
|
|
(Hkey)NULL,0))
|
|
/* lock a global context mutex variable and directly return Herror result */
|
|
# define HLockGVMdirect(ProcHandle,Element) \
|
|
HAccessGlVar(ProcHandle,Element,GV_LOCK,NULL,(double)0,(char *)NULL, \
|
|
(Hkey)NULL,0)
|
|
/* unlock a global context mutex variable */
|
|
# define HUnlockGVM(ProcHandle,Element) \
|
|
HCkP(HAccessGlVar(ProcHandle,Element,GV_UNLOCK,NULL,(double)0, \
|
|
(char *)NULL,(Hkey)NULL,0))
|
|
/* unlock a global context mutex variable and directly return Herror result */
|
|
# define HUnlockGVMdirect(ProcHandle,Element) \
|
|
HAccessGlVar(ProcHandle,Element,GV_UNLOCK,NULL,(double)0,(char *)NULL, \
|
|
(Hkey)NULL,0)
|
|
#else
|
|
# define HLockGVM(ProcHandle,Element)
|
|
# define HLockGVMdirect(ProcHandle,Element) H_MSG_OK
|
|
# define HUnlockGVM(ProcHandle,Element)
|
|
# define HUnlockGVMdirect(ProcHandle,Element) H_MSG_OK
|
|
#endif
|
|
|
|
/* calculate 'bitwise OR' with the content of a global context variable */
|
|
#define HBOrGV(ProcHandle,Element,Value) \
|
|
HCkP(HAccessGlVar(ProcHandle,Element,GV_BOR_INFO,NULL,(double)Value, \
|
|
(char *)NULL,(Hkey)NULL,0))
|
|
/* calculate 'bitwise AND' with the content of a global context variable */
|
|
#define HBAndGV(ProcHandle,Element,Value) \
|
|
HCkP(HAccessGlVar(ProcHandle,Element,GV_BAND_INFO,NULL,(double)Value, \
|
|
(char *)NULL,(Hkey)NULL,0))
|
|
/* - - - - old Makros for accessing HALCON operator context information - - */
|
|
/* (all accesses using the old makros should be replaced by the new ones in */
|
|
/* the long term */
|
|
/* write an element of the global structure HInterInfo */
|
|
#define HWriteInterInfo(ProcHandle,Element,Value) \
|
|
HCkP(HAccessGlVar(ProcHandle,Element,GV_WRITE_INFO,NULL,(double)Value,(char *)NULL,(Hkey)NULL,0))
|
|
/* write an element of the global structure HInterInfo (String) */
|
|
#define HWriteInterInfoS(ProcHandle,Element,Value) \
|
|
HCkP(HAccessGlVar(ProcHandle,Element,GV_WRITE_INFO,NULL,(double)0,Value,(Hkey)NULL,0))
|
|
/* write an element of the global structure HInterInfo (String into Array) */
|
|
#define HWriteInterInfoSA(ProcHandle,Element,Value,Index) \
|
|
HCkP(HAccessGlVar(ProcHandle,Element,GV_WRITE_INFO,NULL,(double)0,Value,(Hkey)NULL,Index))
|
|
/* write an element of the global structure HInterInfo (Array element) */
|
|
#define HWriteInterInfoA(ProcHandle,Element,Value,Index) \
|
|
HCkP(HAccessGlVar(ProcHandle,Element,GV_WRITE_INFO,NULL,(double)Value,(char *)NULL,(Hkey)NULL,Index))
|
|
/* read an element of the global structure HInterInfo */
|
|
#define HReadInterInfo(ProcHandle,Element,Value) \
|
|
HCkP(HAccessGlVar(ProcHandle,Element,GV_READ_INFO,Value,(double)0,(char *)NULL,(Hkey)NULL,0))
|
|
/* read an element of the global structure HInterInfo (Array element) */
|
|
#define HReadInterInfoA(ProcHandle,Element,Value,Index) \
|
|
HCkP(HAccessGlVar(ProcHandle,Element,GV_READ_INFO,Value,(double)0,(char *)NULL,(Hkey)NULL,Index))
|
|
/* initialize an element of the global structure HInterInfo (Array element) */
|
|
#define HInitInterInfoA(ProcHandle,Element,Value) \
|
|
HCkP(HAccessGlVar(ProcHandle,Element,GV_INIT_INFO,Value,(double)0,(char *)NULL,(Hkey)NULL,0))
|
|
|
|
/* write an element of the global structure HSysComInfo */
|
|
#define HWriteSysComInfo(ProcHandle,Element,Value) \
|
|
HCkP(HAccessGlVar(ProcHandle,Element,GV_WRITE_INFO,NULL,(double)Value,(char *)NULL,(Hkey)NULL,0))
|
|
/* write an element of the global structure HSysComInfo (String) */
|
|
#define HWriteSysComInfoS(ProcHandle,Element,Value) \
|
|
HCkP(HAccessGlVar(ProcHandle,Element,GV_WRITE_INFO,NULL,(double)0,Value,(Hkey)NULL,0))
|
|
/* write an element of the global structure HSysComInfo (String into Array) */
|
|
#define HWriteSysComInfoSA(ProcHandle,Element,Value,Index) \
|
|
HCkP(HAccessGlVar(ProcHandle,Element,GV_WRITE_INFO,NULL,(double)0,Value,(Hkey)NULL,Index))
|
|
/* write an element of the global structure HSysComInfo (Array element) */
|
|
#define HWriteSysComInfoA(ProcHandle,Element,Value,Index) \
|
|
HCkP(HAccessGlVar(ProcHandle,Element,GV_WRITE_INFO,NULL,(double)Value,(char *)NULL,(Hkey)NULL,Index))
|
|
/* write an element of the global structure HSysInfoShared */
|
|
#define HWriteSysInfoShared(ProcHandle,Element,Value) \
|
|
HAccessGlVar(ProcHandle,Element,GV_WRITE_INFO,NULL,(double)Value,(char *)NULL,(Hkey)NULL,0)
|
|
/* write an element of the global structure HSysInfoShared (String) */
|
|
#define HWriteSysInfoSharedS(ProcHandle,Element,Value) \
|
|
HAccessGlVar(ProcHandle,Element,GV_WRITE_INFO,NULL,(double)0,Value,(Hkey)NULL,0)
|
|
/* write an element of the global structure HSysInfoShared(String into Array)*/
|
|
#define HWriteSysInfoSharedSA(ProcHandle,Element,Value,Index) \
|
|
HAccessGlVar(ProcHandle,Element,GV_WRITE_INFO,NULL,(double)0,Value,(Hkey)NULL,Index)
|
|
/* write an element of the global structure HSysComInfo (Array element) */
|
|
#define HWriteSysInfoSharedA(ProcHandle,Element,Value,Index) \
|
|
HAccessGlVar(ProcHandle,Element,GV_WRITE_INFO,NULL,(double)Value,(char *)NULL,(Hkey)NULL,Index)
|
|
|
|
/* read an element of the global structure HSysComInfo */
|
|
#define HReadSysComInfo(ProcHandle,Element,Value) \
|
|
HCkP(HAccessGlVar(ProcHandle,Element,GV_READ_INFO,Value,(double)0,(char *)NULL,(Hkey)NULL,0))
|
|
/* read an element of the global structure HSysComInfo (Array element) */
|
|
#define HReadSysComInfoA(ProcHandle,Element,Value,Index) \
|
|
HCkP(HAccessGlVar(ProcHandle,Element,GV_READ_INFO,Value,(double)0,(char *)NULL,(Hkey)NULL,Index))
|
|
/* initialize an element of the global structure HSysComInfo (Array element) */
|
|
#define HInitSysComInfoA(ProcHandle,Element,Value) \
|
|
HCkP(HAccessGlVar(ProcHandle,Element,GV_INIT_INFO,Value,(double)0,(char *)NULL,(Hkey)NULL,0))
|
|
/* write an element of the global structure HProcCallInfo */
|
|
#define HWriteProcCallInfo(ProcHandle,Element,Value) \
|
|
HCkP(HAccessGlVar(ProcHandle,Element,GV_WRITE_INFO,NULL,(double)Value,(char *)NULL,(Hkey)NULL,0))
|
|
/* write an element of the global structure HProcCallInfo (String) */
|
|
#define HWriteProcCallInfoS(ProcHandle,Element,Value) \
|
|
HCkP(HAccessGlVar(ProcHandle,Element,GV_WRITE_INFO,NULL,(double)0,Value,(Hkey)NULL,0))
|
|
/* write an element of the global structure HProcCallInfo (String into Array)*/
|
|
#define HWriteProcCallInfoSA(ProcHandle,Element,Value,Index) \
|
|
HCkP(HAccessGlVar(ProcHandle,Element,GV_WRITE_INFO,NULL,(double)0,Value,(Hkey)NULL,Index))
|
|
/* write an element of the global structure HProcCallInfo (Key into Array) */
|
|
#define HWriteProcCallInfoKA(ProcHandle,Element,Value,Index) \
|
|
HCkP(HAccessGlVar(ProcHandle,Element,GV_WRITE_INFO,NULL,(double)0,(char *)NULL,Value,Index))
|
|
/* write an element of the global structure HProcCallInfo (Array element) */
|
|
#define HWriteProcCallInfoA(ProcHandle,Element,Value,Index) \
|
|
HCkP(HAccessGlVar(ProcHandle,Element,GV_WRITE_INFO,NULL,(double)Value,(char *)NULL,(Hkey)NULL,Index))
|
|
/* Lesen eines Elements der globalen Struktur HProcCallInfo */
|
|
#define HReadProcCallInfo(ProcHandle,Element,Value) \
|
|
HCkP(HAccessGlVar(ProcHandle,Element,GV_READ_INFO,Value,(double)0,(char *)NULL,(Hkey)NULL,0))
|
|
/* read an element of the global structure HProcCallInfo */
|
|
#define HReadProcCallInfoA(ProcHandle,Element,Value,Index) \
|
|
HCkP(HAccessGlVar(ProcHandle,Element,GV_READ_INFO,Value,(double)0,(char *)NULL,(Hkey)NULL,Index))
|
|
/* initialize an element of the global structure HProcCallInfo (Array) */
|
|
#define HInitProcCallInfoA(ProcHandle,Element,Value) \
|
|
HCkP(HAccessGlVar(ProcHandle,Element,GV_INIT_INFO,Value,(double)0,(char *)NULL,(Hkey)NULL,0))
|
|
/* get the address of an array element of the global structure HProcCallInfo */
|
|
#define HGetAdrProcCallInfoA(ProcHandle,Element,Value) \
|
|
HCkP(HAccessGlVar(ProcHandle,Element,GV_GET_ADRESS,Value,(double)0,(char *)NULL,(Hkey)NULL,0))
|
|
|
|
#endif /* HMACRO_H */
|