Woolz Image Processing Version 1.4.0
WlzMacro.h
Go to the documentation of this file.
00001 #ifndef WLZMACRO_H
00002 #define WLZMACRO_H
00003 #if defined(__GNUC__)
00004 #ident "University of Edinburgh $Id: 0e0b25f2a13125d93f22615642b835e1bf831840 $"
00005 #else
00006 static char _WlzMacro_h[] = "University of Edinburgh $Id: 0e0b25f2a13125d93f22615642b835e1bf831840 $";
00007 #endif
00008 /*!
00009 * \file         libWlz/WlzMacro.h
00010 * \author       Bill Hill
00011 * \date         March 1999
00012 * \version      $Id: 0e0b25f2a13125d93f22615642b835e1bf831840 $
00013 * \par
00014 * Address:
00015 *               MRC Human Genetics Unit,
00016 *               MRC Institute of Genetics and Molecular Medicine,
00017 *               University of Edinburgh,
00018 *               Western General Hospital,
00019 *               Edinburgh, EH4 2XU, UK.
00020 * \par
00021 * Copyright (C), [2012],
00022 * The University Court of the University of Edinburgh,
00023 * Old College, Edinburgh, UK.
00024 * 
00025 * This program is free software; you can redistribute it and/or
00026 * modify it under the terms of the GNU General Public License
00027 * as published by the Free Software Foundation; either version 2
00028 * of the License, or (at your option) any later version.
00029 *
00030 * This program is distributed in the hope that it will be
00031 * useful but WITHOUT ANY WARRANTY; without even the implied
00032 * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
00033 * PURPOSE.  See the GNU General Public License for more
00034 * details.
00035 *
00036 * You should have received a copy of the GNU General Public
00037 * License along with this program; if not, write to the Free
00038 * Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
00039 * Boston, MA  02110-1301, USA.
00040 * \brief        Woolz C pre-processor directives, eg macros.
00041 * \ingroup      Wlz
00042 */
00043 
00044 #ifndef WLZ_EXT_BIND
00045 #ifdef  __cplusplus
00046 extern "C" {
00047 #endif /* __cplusplus */
00048 #endif /* WLZ_EXT_BIND */
00049 
00050 #define WLZ_VERSION     PACKAGE_VERSION
00051 
00052 /************************************************************************
00053 * Simple macros not always available elsewhere.                         *
00054 ************************************************************************/
00055 #define WLZ_MAX(X,Y)    (((X)>=(Y))?(X):(Y))
00056 #define WLZ_MIN(X,Y)    (((X)<=(Y))?(X):(Y))
00057 #define WLZ_ABS(X)      (((X)>0)?(X):(-(X)))
00058 #define WLZ_NINT(X)     ((int)(((X)<0)?((X)-(0.5)):((X)+(0.5))))
00059 #define WLZ_SIGN(X)     (((X)<0)?-1:((X)>0)?1:0)
00060 
00061 /************************************************************************
00062 * Pixel value clamping. Used in WlzGreyScan() and WlzConvertPix().      *
00063 ************************************************************************/
00064 #define WLZ_CLAMP(v, min, max) (v<min ? min : v>max ? max : v)
00065 
00066 /************************************************************************
00067 * Math constants.                                                       *
00068 ************************************************************************/
00069 #define WLZ_M_E         (2.7182818284590452354)
00070 #define WLZ_M_LOG2E     (1.4426950408889634074)
00071 #define WLZ_M_LOG10E    (0.43429448190325182765)
00072 #define WLZ_M_LN2       (0.69314718055994530942)
00073 #define WLZ_M_LN10      (2.30258509299404568402)
00074 #define WLZ_M_PI        (3.14159265358979323846)
00075 #define WLZ_M_PI_2      (1.57079632679489661923)
00076 #define WLZ_M_PI_4      (0.78539816339744830961)
00077 #define WLZ_M_1_PI      (0.31830988618379067154)
00078 #define WLZ_M_2_PI      (0.63661977236758134308)
00079 #define WLZ_M_2_SQRTPI  (1.12837916709551257390)
00080 #define WLZ_M_SQRT2     (1.41421356237309504880)
00081 #define WLZ_M_SQRT1_2   (0.70710678118654752440)
00082 #define WLZ_M_SQRT3     (1.73205080756887729352)
00083 #define WLZ_M_SQRT3_2   (0.86602540378443864676)
00084 
00085 /************************************************************************
00086 * Mesh tolerance control.                                               *
00087 ************************************************************************/
00088 #define WLZ_MESH_TOLERANCE      (1.0E-04)
00089 #define WLZ_MESH_TOLERANCE_SQ   (WLZ_MESH_TOLERANCE * WLZ_MESH_TOLERANCE)
00090 #define WLZ_MESH_ELEM_AREA_TOLERANCE   (WLZ_M_SQRT3_2 * WLZ_MESH_TOLERANCE_SQ)
00091 
00092 /************************************************************************
00093 * Byte packed bitmap macros
00094 ************************************************************************/
00095 #define WLZ_BIT_SET(A,B)        *((A)+((B)>>3))|=(1<<((B)&7))
00096 #define WLZ_BIT_GET(A,B)        (*((A)+((B)>>3))&(1<<((B)&7)))
00097 
00098 /************************************************************************
00099 * Colour values macros
00100 ************************************************************************/
00101 #define WLZ_RGBA_RED_GET(V)     ((((WlzUInt )V) & 0xff)>>0)
00102 #define WLZ_RGBA_GREEN_GET(V)   ((((WlzUInt )V) & 0xff00)>>8)
00103 #define WLZ_RGBA_BLUE_GET(V)    ((((WlzUInt )V) & 0xff0000)>>16)
00104 #define WLZ_RGBA_ALPHA_GET(V)   ((((WlzUInt )V) & 0xff000000)>>24)
00105 
00106 #define WLZ_RGBA_RED_SET(V,C)   (V = (((WlzUInt )V)&0xffffff00) | \
00107                                                (((WlzUInt) C)&0xff))
00108 #define WLZ_RGBA_GREEN_SET(V,C) (V = (((WlzUInt )V)&0xffff00ff) | \
00109                                                ((((WlzUInt) C)&0xff)<<8))
00110 #define WLZ_RGBA_BLUE_SET(V,C)  (V = (((WlzUInt )V)&0xff00ffff) | \
00111                                                ((((WlzUInt) C)&0xff)<<16))
00112 #define WLZ_RGBA_ALPHA_SET(V,C) (V = (((WlzUInt )V)&0x00ffffff) | \
00113                                                ((((WlzUInt) C)&0xff)<<24))
00114 #define WLZ_RGBA_RGBA_SET(V,R,G,B,A) (V = ((((WlzUInt )R)&0xff) + \
00115                                            ((((WlzUInt )G)&0xff)<<8) + \
00116                                            ((((WlzUInt )B)&0xff)<<16) + \
00117                                            ((((WlzUInt )A)&0xff)<<24))) 
00118 
00119 #define WLZ_RGBA_MEAN(V)        ((WLZ_RGBA_RED_GET(V) + \
00120                                   WLZ_RGBA_GREEN_GET(V) + \
00121                                   WLZ_RGBA_BLUE_GET(V))/3.0)
00122 
00123 #define WLZ_RGBA_MODULUS_2(V)(WLZ_RGBA_RED_GET(V)*WLZ_RGBA_RED_GET(V) + \
00124                               WLZ_RGBA_GREEN_GET(V)*WLZ_RGBA_GREEN_GET(V) + \
00125                               WLZ_RGBA_BLUE_GET(V)*WLZ_RGBA_BLUE_GET(V))
00126 
00127 #define WLZ_RGBA_MODULUS(V) (sqrt((double) WLZ_RGBA_MODULUS_2(V)))
00128 
00129 /************************************************************************
00130 * Vertex macros.                                                        *
00131 ************************************************************************/
00132 /* WLZ_VTX_2_ABS: Absolute value of a Wlz[DFI]Vertex2 */
00133 #define WLZ_VTX_2_ABS(A,X) \
00134                 (A).vtX = WLZ_ABS((X).vtX), \
00135                 (A).vtY = WLZ_ABS((X).vtY)
00136 /* WLZ_VTX_3_ABS: Absolute value of a Wlz[DFI]Vertex3 */
00137 #define WLZ_VTX_3_ABS(A,X) \
00138                 (A).vtX = WLZ_ABS((X).vtX), \
00139                 (A).vtY = WLZ_ABS((X).vtY), \
00140                 (A).vtZ = WLZ_ABS((X).vtZ)
00141 /* WLZ_VTX_2_SIGN: Sign of a Wlz[DFI]Vertex2 */
00142 #define WLZ_VTX_2_SIGN(S,X) \
00143                 (S).vtX = WLZ_SIGN((X).vtX), \
00144                 (S).vtY = WLZ_SIGN((X).vtY)
00145 /* WLZ_VTX_3_SIGN: Sign of a Wlz[DFI]Vertex3 */
00146 #define WLZ_VTX_3_SIGN(S,X) \
00147                 (S).vtX = WLZ_SIGN((X).vtX), \
00148                 (S).vtY = WLZ_SIGN((X).vtY), \
00149                 (S).vtZ = WLZ_SIGN((X).vtZ)
00150 /* WLZ_VTX_2_SET: Set Wlz[DFI]Vertex2 */
00151 #define WLZ_VTX_2_SET(U,X,Y) \
00152                 (U).vtX = (X), \
00153                 (U).vtY = (Y)
00154 
00155 /* WLZ_VTX_3_SET: Set Wlz[DFI]Vertex3 */
00156 #define WLZ_VTX_3_SET(U,X,Y,Z) \
00157                 (U).vtX = (X), \
00158                 (U).vtY = (Y), \
00159                 (U).vtZ = (Z)
00160 
00161 /* WLZ_VTX_2_ADD: Add two Wlz[DFI]Vertex2's */
00162 #define WLZ_VTX_2_ADD(U,V,W) \
00163                 (U).vtX = (V).vtX + (W).vtX, \
00164                 (U).vtY = (V).vtY + (W).vtY
00165 
00166 /* WLZ_VTX_3_ADD: Add two Wlz[DFI]Vertex3's */
00167 #define WLZ_VTX_3_ADD(U,V,W) \
00168                 (U).vtX = (V).vtX + (W).vtX, \
00169                 (U).vtY = (V).vtY + (W).vtY, \
00170                 (U).vtZ = (V).vtZ + (W).vtZ
00171 
00172 /* WLZ_VTX_2_ADD: Add three Wlz[DFI]Vertex2's */
00173 #define WLZ_VTX_2_ADD3(U,V,W,X) \
00174                 (U).vtX = (V).vtX + (W).vtX + (X).vtX, \
00175                 (U).vtY = (V).vtY + (W).vtY + (X).vtY
00176 
00177 /* WLZ_VTX_3_ADD: Add three Wlz[DFI]Vertex3's */
00178 #define WLZ_VTX_3_ADD3(U,V,W,X) \
00179                 (U).vtX = (V).vtX + (W).vtX + (X).vtX, \
00180                 (U).vtY = (V).vtY + (W).vtY + (X).vtY, \
00181                 (U).vtZ = (V).vtZ + (W).vtZ + (X).vtZ
00182 
00183 /* WLZ_VTX_4_ADD: Add four Wlz[DFI]Vertex3's */
00184 #define WLZ_VTX_3_ADD4(U,V,W,X,Y) \
00185                 (U).vtX = (V).vtX + (W).vtX + (X).vtX + (Y).vtX, \
00186                 (U).vtY = (V).vtY + (W).vtY + (X).vtY + (Y).vtY, \
00187                 (U).vtZ = (V).vtZ + (W).vtZ + (X).vtZ + (Y).vtZ
00188 
00189 /* WLZ_VTX_2_SUB: Subtract two Wlz[DFI]Vertex2's */
00190 #define WLZ_VTX_2_SUB(U,V,W) \
00191                 (U).vtX = (V).vtX - (W).vtX, \
00192                 (U).vtY = (V).vtY - (W).vtY
00193 
00194 /* WLZ_VTX_3_SUB: Subtract two Wlz[DFI]Vertex3's */
00195 #define WLZ_VTX_3_SUB(U,V,W) \
00196                 (U).vtX = (V).vtX - (W).vtX, \
00197                 (U).vtY = (V).vtY - (W).vtY, \
00198                 (U).vtZ = (V).vtZ - (W).vtZ
00199 
00200 /* WLZ_VTX_2_SCALE: Scale a Wlz[DFI]Vertex2 */
00201 #define WLZ_VTX_2_SCALE(U,V,C) \
00202                 (U).vtX = (V).vtX * (C), \
00203                 (U).vtY = (V).vtY * (C)
00204 
00205 /* WLZ_VTX_3_SCALE: Scale a Wlz[DFI]Vertex3 */
00206 #define WLZ_VTX_3_SCALE(U,V,C) \
00207                 (U).vtX = (V).vtX * (C), \
00208                 (U).vtY = (V).vtY * (C), \
00209                 (U).vtZ = (V).vtZ * (C)
00210 /* WLZ_VTX_2_SCALE_ADD: Scale a Wlz[DFI]Vertex2 then add a Wlz[DFI]Vertex2. */
00211 #define WLZ_VTX_2_SCALE_ADD(U,V,C,W) \
00212                 (U).vtX = (V).vtX * (C) + (W.vtX), \
00213                 (U).vtY = (V).vtY * (C) + (W.vtY)
00214 
00215 /* WLZ_VTX_3_SCALE_ADD: Scale a Wlz[DFI]Vertex3 then add a Wlz[DFI]Vertex3. */
00216 #define WLZ_VTX_3_SCALE_ADD(U,V,C,W) \
00217                 (U).vtX = (V).vtX * (C) + (W.vtX), \
00218                 (U).vtY = (V).vtY * (C) + (W.vtY), \
00219                 (U).vtZ = (V).vtZ * (C) + (W.vtZ)
00220 
00221 /* WLZ_VTX_2_DOT: Dot (scalar) product of two Wlz[DFI]Vertex2's */
00222 #define WLZ_VTX_2_DOT(V,W) \
00223                 ((V).vtX * ((W).vtX) + \
00224                 ((V).vtY *  (W).vtY))
00225 
00226 /* WLZ_VTX_3_DOT: Dot (scalar) product of two Wlz[DFI]Vertex3s */
00227 #define WLZ_VTX_3_DOT(V,W) \
00228                 ((V).vtX * ((W).vtX) + \
00229                 ((V).vtY *  (W).vtY) + \
00230                 ((V).vtZ *  (W).vtZ))
00231 
00232 /* WLZ_VTX_3_CROSS: Cross (vector) product of two Wlz[DFI]Vertex3s */
00233 #define WLZ_VTX_3_CROSS(U,V,W) \
00234                 (U).vtX = ((V).vtY * (W).vtZ) - ((W).vtY * (V).vtZ), \
00235                 (U).vtY = ((V).vtZ * (W).vtX) - ((W).vtZ * (V).vtX), \
00236                 (U).vtZ = ((V).vtX * (W).vtY) - ((W).vtX * (V).vtY)
00237 
00238 /* WLZ_VTX_2_LENGTH: Square of length of a Wlz[DFI]Vertex2 */
00239 #define WLZ_VTX_2_SQRLEN(U) \
00240                 (((U).vtX * (U).vtX) + \
00241                  ((U).vtY * (U).vtY))
00242 
00243 /* WLZ_VTX_3_LENGTH: Square of length of a Wlz[DFI]Vertex3 */
00244 #define WLZ_VTX_3_SQRLEN(U) \
00245                 (((U).vtX * (U).vtX) + \
00246                  ((U).vtY * (U).vtY) + \
00247                  ((U).vtZ * (U).vtZ))
00248 
00249 /* WLZ_VTX_2_LENGTH: Length of a Wlz[DFI]Vertex2 */
00250 #define WLZ_VTX_2_LENGTH(U) \
00251                 (sqrt(WLZ_VTX_2_SQRLEN(U)))
00252 
00253 /* WLZ_VTX_3_LENGTH: Length of a Wlz[DFI]Vertex3 */
00254 #define WLZ_VTX_3_LENGTH(U) \
00255                 (sqrt(WLZ_VTX_3_SQRLEN(U)))
00256 
00257 /* WLZ_VTX_2_ZERO: Set vector to zero. */
00258 #define WLZ_VTX_2_ZERO(U) \
00259                 (U).vtX = 0, \
00260                 (U).vtY = 0
00261 
00262 /* WLZ_VTX_3_ZERO: Set vector to zero. */
00263 #define WLZ_VTX_3_ZERO(U) \
00264                 (U).vtX = 0, \
00265                 (U).vtY = 0, \
00266                 (U).vtZ = 0
00267 
00268 /* WLZ_VTX_2_NEGATE: Set vector to zero. */
00269 #define WLZ_VTX_2_NEGATE(U,V) \
00270                 (U).vtX = -((V).vtX), \
00271                 (U).vtY = -((V).vtY)
00272 
00273 /* WLZ_VTX_3_NEGATE: Set vector to zero. */
00274 #define WLZ_VTX_3_NEGATE(U,V) \
00275                 (U).vtX = -((V).vtX), \
00276                 (U).vtY = -((V).vtY), \
00277                 (U).vtZ = -((V).vtZ)
00278 
00279 /* WLZ_VTX_2_EQUAL: Tests for equality of vertices. */
00280 #define WLZ_VTX_2_EQUAL(U,V,T) \
00281                 ((fabs((U).vtX - (V).vtX) < (T)) && \
00282                  (fabs((U).vtY - (V).vtY) < (T)))
00283 
00284 /* WLZ_VTX_3_EQUAL: Tests for equality of vertices. */
00285 #define WLZ_VTX_3_EQUAL(U,V,T) \
00286                 ((fabs((U).vtX - (V).vtX) < (T)) && \
00287                  (fabs((U).vtY - (V).vtY) < (T)) && \
00288                  (fabs((U).vtZ - (V).vtZ) < (T)))
00289 
00290 /* WLZ_VTX_2_FABS: Floating point absolute value. */
00291 #define WLZ_VTX_2_FABS(U,V) \
00292                 ((U).vtX = fabs((V).vtX), \
00293                  (U).vtY = fabs((V).vtY))
00294 
00295 /* WLZ_VTX_3_FABS: Floating point absolute value. */
00296 #define WLZ_VTX_3_FABS(U,V) \
00297                 ((U).vtX = fabs((V).vtX), \
00298                  (U).vtY = fabs((V).vtY), \
00299                  (U).vtZ = fabs((V).vtZ))
00300 
00301 /* WLZ_VTX_2_NINT: Nearest integer position. */
00302 #define WLZ_VTX_2_NINT(U,P) \
00303                 ((U).vtX = WLZ_NINT((P).vtX), \
00304                  (U).vtY = WLZ_NINT((P).vtY))
00305 
00306 /* WLZ_VTX_3_NINT: Nearest integer position. */
00307 #define WLZ_VTX_3_NINT(U,P) \
00308                 ((U).vtX = WLZ_NINT((P).vtX), \
00309                  (U).vtY = WLZ_NINT((P).vtY) \
00310                  (U).vtZ = WLZ_NINT((P).vtZ))
00311 
00312 /************************************************************************
00313 * CMesh node access
00314 ************************************************************************/
00315 #define WLZ_CMESH_ELM2D_GET_NODE_0(e)   ((e)->edu[0].nod)
00316 #define WLZ_CMESH_ELM2D_GET_NODE_1(e)   ((e)->edu[1].nod)
00317 #define WLZ_CMESH_ELM2D_GET_NODE_2(e)   ((e)->edu[2].nod)
00318 #define WLZ_CMESH_ELM2D5_GET_NODE_0(e)  ((e)->edu[0].nod)
00319 #define WLZ_CMESH_ELM2D5_GET_NODE_1(e)  ((e)->edu[1].nod)
00320 #define WLZ_CMESH_ELM2D5_GET_NODE_2(e)  ((e)->edu[2].nod)
00321 #define WLZ_CMESH_ELM3D_GET_NODE_0(e)   ((e)->face[0].edu[0].nod)
00322 #define WLZ_CMESH_ELM3D_GET_NODE_1(e)   ((e)->face[0].edu[1].nod)
00323 #define WLZ_CMESH_ELM3D_GET_NODE_2(e)   ((e)->face[0].edu[2].nod)
00324 #define WLZ_CMESH_ELM3D_GET_NODE_3(e)   ((e)->face[1].edu[1].nod)
00325 
00326 #ifndef WLZ_EXT_BIND
00327 #ifdef  __cplusplus
00328 }
00329 #endif /* __cplusplus */
00330 #endif /* WLZ_EXT_BIND */
00331 
00332 #endif /* WLZMACRO_H */