1817 lines
105 KiB
C
1817 lines
105 KiB
C
/*****************************************************************************
|
|
* HMacro.h
|
|
*****************************************************************************
|
|
*
|
|
* Project: HALCON/libhalcon
|
|
* Description: Definition of macros
|
|
*
|
|
* (c) 1996-2020 by MVTec Software GmbH
|
|
* www.mvtec.com
|
|
*
|
|
*****************************************************************************/
|
|
|
|
#ifndef HMACRO_H
|
|
#define HMACRO_H
|
|
|
|
/*
|
|
* HALCON traditionally used 'FAST' instead of 'HC_FAST', but that clashes
|
|
* with VxWorks.
|
|
*/
|
|
#if !defined(__vxworks) && defined(FAST) && !defined(HC_FAST)
|
|
# define HC_FAST
|
|
#endif
|
|
|
|
/*
|
|
* 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 = (double)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, (void*)VOID_PTR, \
|
|
H__FILE__, (INT4_8)H__LINE__) \
|
|
: HXFreeGeneral(PROC_HANDLE, (void*)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, (void*)VOID_PTR)
|
|
#endif
|
|
|
|
#define HReallocGeneral(PROC_HANDLE, VOID_PTR, SIZE, NEW_PTR) \
|
|
HXReallocGeneral(PROC_HANDLE, (void*)(VOID_PTR), SIZE, (void*)(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, (void*)(VOID_PTR)) \
|
|
: HXAlloc(PROC_HANDLE, SIZE, (void*)(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, (void*)(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, \
|
|
(void*)(VOID_PTR)) \
|
|
: HXAllocAlign(PROC_HANDLE, SIZE, ALIGNMENT, (void*)(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, (void*)(VOID_PTR))
|
|
#endif
|
|
|
|
#define HRealloc(PROC_HANDLE, VOID_PTR, SIZE, NEW_PTR) \
|
|
HXRealloc(PROC_HANDLE, (void*)(VOID_PTR), SIZE, (void*)(NEW_PTR), \
|
|
H__FILE__, (INT4_8)H__LINE__)
|
|
|
|
#define HReallocToGlobal(PROC_HANDLE, VOID_PTR, SIZE, NEW_PTR) \
|
|
HXReallocToGlobal(PROC_HANDLE, (void*)(VOID_PTR), SIZE, (void*)(NEW_PTR), \
|
|
H__FILE__, (INT4_8)H__LINE__)
|
|
|
|
|
|
#ifndef _LIntStatic
|
|
# define HFree(PROC_HANDLE, VOID_PTR) \
|
|
(HTraceMemory ? HXFreeMemCheck(PROC_HANDLE, (void*)(VOID_PTR), H__FILE__, \
|
|
(INT4_8)H__LINE__) \
|
|
: HXFree(PROC_HANDLE, (void*)(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, (void*)(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, (void*)(PTR), SIZE, H__FILE__, (INT4_8)H__LINE__)
|
|
|
|
#define HAllocTmpAlign(PROC_HANDLE, PTR, SIZE, ALIGNMENT) \
|
|
HXAllocTmpAlign(PROC_HANDLE, (void*)(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, (void*)(MEM_PTR), (void*)(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, (void*)(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, (void*)(VOID_PTR), H__FILE__, (INT4_8)H__LINE__)
|
|
|
|
#define HFreeUpToTmpExcl(PROC_HANDLE, VOID_PTR) \
|
|
HXFreeUpToTmpExcl(PROC_HANDLE, (void*)(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__, \
|
|
(void*)(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__, \
|
|
(void*)(VOID_PTR))
|
|
|
|
#define HAllocLocalAlign(PROC_HANDLE, SIZE, ALIGNMENT, VOID_PTR) \
|
|
HXAllocLocalAlign(PROC_HANDLE, SIZE, ALIGNMENT, H__FILE__, \
|
|
(INT4_8)H__LINE__, (void*)(VOID_PTR))
|
|
|
|
#define HReallocLocal(PROC_HANDLE, VOID_PTR, SIZE, NEW_PTR) \
|
|
HXReallocLocal(PROC_HANDLE, (void*)(VOID_PTR), SIZE, (void*)(NEW_PTR), \
|
|
H__FILE__, (INT4_8)H__LINE__)
|
|
|
|
#define HFreeLocal(PROC_HANDLE, VOID_PTR) \
|
|
HXFreeLocal(PROC_HANDLE, (void*)(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)); \
|
|
}
|
|
|
|
#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(HC_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(HC_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(HC_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(HC_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(HC_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 HCkSingleInputObj(PROC_HANDLE, OBJ_NUM) \
|
|
HCkP(HPCheckSingleInputObject(PROC_HANDLE, OBJ_NUM))
|
|
|
|
#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 HC_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 HAllCompChecked(PROC_HANDLE, OBJ_IN, IM_IN_KEY, IM_IN, INDEX) \
|
|
HCkP(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 */
|
|
|