Woolz C pre-processor directives, eg macros. More...

Macros
#define	WLZ_VERSION PACKAGE_VERSION

#define	WLZ_MAX(X, Y) (((X)>=(Y))?(X):(Y))

#define	WLZ_MIN(X, Y) (((X)<=(Y))?(X):(Y))

#define	WLZ_ABS(X) (((X)>0)?(X):(-(X)))

#define	WLZ_NINT(X) ((int)(((X)<0)?((X)-(0.5)):((X)+(0.5))))

#define	WLZ_SIGN(X) (((X)<0)?-1:((X)>0)?1:0)

#define	WLZ_SWAP(T, A, B) {(T)=(A);(A)=(B);(B)=(T);}
	Swaps the values of the variables A and B using the temporary variable T. More...

#define	WLZ_CLAMP(V, N, X) (((V)<(N))?(N):((V)>(X))?(X):(V))
	Clamps the value of V such that V >= N and V <= X. More...

#define	WLZ_CLAMP_DOUBLE_TO_GREYP(U, F, V, G)
	Clamps a single double value from V setting U offset by F such that U >= MIN and U <= MAX where MIN and MAX are the minimum and maximum values for the grey type G. The only valid types for G are: WLZ_GREY_UBYTE, WLZ_GREY_SHORT, WLZ_GREY_INT, WLZ_GREY_FLOAT, and WLZ_GREY_DOUBLE; there is no check that G is none of these types. More...

#define	WLZ_M_E (2.7182818284590452354)0

#define	WLZ_M_LOG2E (1.4426950408889634074)

#define	WLZ_M_LOG2E (1.4426950408889634074)

#define	WLZ_M_LOG10E (0.43429448190325182765)

#define	WLZ_M_LN2 (0.69314718055994530942)

#define	WLZ_M_LN10 (2.30258509299404568402)

#define	WLZ_M_PI (3.14159265358979323846)

#define	WLZ_M_PI_2 (1.57079632679489661923)

#define	WLZ_M_PI_4 (0.78539816339744830961)

#define	WLZ_M_1_PI (0.31830988618379067154)

#define	WLZ_M_2_PI (0.63661977236758134308)

#define	WLZ_M_2_SQRTPI (1.12837916709551257390)

#define	WLZ_M_SQRT2 (1.41421356237309504880)

#define	WLZ_M_SQRT1_2 (0.70710678118654752440)

#define	WLZ_M_SQRT3 (1.73205080756887729352)

#define	WLZ_M_SQRT3_2 (0.86602540378443864676)

#define	WLZ_MESH_TOLERANCE (1.0E-04)

#define	WLZ_MESH_TOLERANCE_SQ (WLZ_MESH_TOLERANCE * WLZ_MESH_TOLERANCE)

#define	WLZ_MESH_ELEM_AREA_TOLERANCE (WLZ_M_SQRT3_2 * WLZ_MESH_TOLERANCE_SQ)

#define	WLZ_BIT_SET(A, B) *((A)+((B)>>3))\|=(1<<((B)&7))

#define	WLZ_BIT_GET(A, B) (*((A)+((B)>>3))&(1<<((B)&7)))

#define	WLZ_RGBA_RED_GET(V) ((((WlzUInt )V) & 0xff)>>0)

#define	WLZ_RGBA_GREEN_GET(V) ((((WlzUInt )V) & 0xff00)>>8)

#define	WLZ_RGBA_BLUE_GET(V) ((((WlzUInt )V) & 0xff0000)>>16)

#define	WLZ_RGBA_ALPHA_GET(V) ((((WlzUInt )V) & 0xff000000)>>24)

#define	WLZ_RGBA_RED_SET(V, C)

#define	WLZ_RGBA_GREEN_SET(V, C)

#define	WLZ_RGBA_BLUE_SET(V, C)

#define	WLZ_RGBA_ALPHA_SET(V, C)

#define	WLZ_RGBA_RGBA_SET(V, R, G, B, A)

#define	WLZ_RGBA_MEAN(V)

#define	WLZ_RGBA_MODULUS_2(V)

#define	WLZ_RGBA_MODULUS(V) (sqrt((double) WLZ_RGBA_MODULUS_2(V)))

#define	WLZ_VTX_2_ABS(A, X)

#define	WLZ_VTX_3_ABS(A, X)

#define	WLZ_VTX_2_SIGN(S, X)

#define	WLZ_VTX_3_SIGN(S, X)

#define	WLZ_VTX_2_COPY(D, S)

#define	WLZ_VTX_3_COPY(D, S)

#define	WLZ_VTX_2_SET(U, X, Y)

#define	WLZ_VTX_3_SET(U, X, Y, Z)

#define	WLZ_VTX_2_ADD(U, V, W)

#define	WLZ_VTX_3_ADD(U, V, W)

#define	WLZ_VTX_2_ADD3(U, V, W, X)

#define	WLZ_VTX_3_ADD3(U, V, W, X)

#define	WLZ_VTX_3_ADD4(U, V, W, X, Y)

#define	WLZ_VTX_2_SUB(U, V, W)

#define	WLZ_VTX_3_SUB(U, V, W)

#define	WLZ_VTX_2_SCALE(U, V, C)

#define	WLZ_VTX_3_SCALE(U, V, C)

#define	WLZ_VTX_2_SCALE_ADD(U, V, C, W)

#define	WLZ_VTX_3_SCALE_ADD(U, V, C, W)

#define	WLZ_VTX_2_DOT(V, W)

#define	WLZ_VTX_2_HAD(U, V, W)

#define	WLZ_VTX_3_DOT(V, W)

#define	WLZ_VTX_3_HAD(U, V, W)

#define	WLZ_VTX_3_CROSS(U, V, W)

#define	WLZ_VTX_2_SQRLEN(U)

#define	WLZ_VTX_3_SQRLEN(U)

#define	WLZ_VTX_2_LENGTH(U) (sqrt(WLZ_VTX_2_SQRLEN(U)))

#define	WLZ_VTX_3_LENGTH(U) (sqrt(WLZ_VTX_3_SQRLEN(U)))

#define	WLZ_VTX_2_ZERO(U)

#define	WLZ_VTX_3_ZERO(U)

#define	WLZ_VTX_2_NEGATE(U, V)

#define	WLZ_VTX_3_NEGATE(U, V)

#define	WLZ_VTX_2_EQUAL(U, V, T)

#define	WLZ_VTX_3_EQUAL(U, V, T)

#define	WLZ_VTX_2_FABS(U, V)

#define	WLZ_VTX_3_FABS(U, V)

#define	WLZ_VTX_2_NINT(U, P)

#define	WLZ_VTX_3_NINT(U, P)

#define	WLZ_CMESH_ELM2D_GET_NODE_0(e) ((e)->edu[0].nod)

#define	WLZ_CMESH_ELM2D_GET_NODE_1(e) ((e)->edu[1].nod)

#define	WLZ_CMESH_ELM2D_GET_NODE_2(e) ((e)->edu[2].nod)

#define	WLZ_CMESH_ELM2D5_GET_NODE_0(e) ((e)->edu[0].nod)

#define	WLZ_CMESH_ELM2D5_GET_NODE_1(e) ((e)->edu[1].nod)

#define	WLZ_CMESH_ELM2D5_GET_NODE_2(e) ((e)->edu[2].nod)

#define	WLZ_CMESH_ELM3D_GET_NODE_0(e) ((e)->face[0].edu[0].nod)

#define	WLZ_CMESH_ELM3D_GET_NODE_1(e) ((e)->face[0].edu[1].nod)

#define	WLZ_CMESH_ELM3D_GET_NODE_2(e) ((e)->face[0].edu[2].nod)

#define	WLZ_CMESH_ELM3D_GET_NODE_3(e) ((e)->face[1].edu[1].nod)

Detailed Description

Woolz C pre-processor directives, eg macros.

Author: Bill Hill

Date: March 1999

Version

Id: cdd543f95c0f143485246493458d74bc07f5d2c4

: Address: MRC Human Genetics Unit, MRC Institute of Genetics and Molecular Medicine, University of Edinburgh, Western General Hospital, Edinburgh, EH4 2XU, UK.

: Copyright (C), [2012], The University Court of the University of Edinburgh, Old College, Edinburgh, UK.

This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

Macro Definition Documentation

◆ WLZ_VERSION

#define WLZ_VERSION PACKAGE_VERSION

◆ WLZ_MAX

#define WLZ_MAX	(	X,
		Y
	)	(((X)>=(Y))?(X):(Y))

Referenced by WlzClipObjToBox2D(), WlzClipObjToBox3D(), WlzConvolveObj(), WlzDistMetricVertex2D(), WlzDistMetricVertex3D(), WlzHasIntersection(), WlzMakeLBTDomain2D(), WlzMakeLBTDomain3D(), WlzMatchICPCtr(), WlzRegICPVertices(), WlzRegICPVerticesWSD2D(), WlzRGBAConvertRGBToHSV_UBYTENormalised(), and WlzSnapFit().

◆ WLZ_MIN

#define WLZ_MIN	(	X,
		Y
	)	(((X)<=(Y))?(X):(Y))

Referenced by WlzClipObjToBox2D(), WlzClipObjToBox3D(), WlzHasIntersection(), WlzRegICPVertices(), WlzRegICPVerticesWSD2D(), and WlzRGBAConvertRGBToHSV_UBYTENormalised().

◆ WLZ_ABS

#define WLZ_ABS ( X ) (((X)>0)?(X):(-(X)))

Referenced by WlzPrincipalAngle().

◆ WLZ_NINT

#define WLZ_NINT ( X ) ((int)(((X)<0)?((X)-(0.5)):((X)+(0.5))))

Referenced by Wlz3DSectionIncrementDistance(), Wlz3DSectionSegmentObject(), Wlz3DViewStructSetupTransformLuts(), Wlz3DViewTransformObj(), WlzAffineTransformVertexI2(), WlzAffineTransformVertexI3(), WlzBasisFnTransformGMModel(), WlzBasisFnTransformVertexI(), WlzCMeshSetDispFromField(), WlzFilterNObjValues(), WlzGetProjectionFromObject(), WlzGMShellSetGBB2D(), WlzGMShellSetGBB3D(), WlzGMShellUpdateGBB2D(), WlzGMShellUpdateGBB3D(), WlzGMVertexSetG2D(), WlzGMVertexSetG2N(), WlzGMVertexSetG3D(), WlzGMVertexSetG3N(), WlzGreySetRange(), WlzGreyValueGetI(), WlzInsideDomain(), WlzMakeCircleObject(), WlzMakeCuboidObject(), WlzMakeRectangleObject(), WlzMakeSphereObject(), WlzMakeStdStructElement(), WlzPointsToDomObj(), WlzPolyEquispace(), WlzPolyTo8Polygon(), WlzProjectObjToPlane(), WlzRegICPVerticesWSD2D(), WlzValueClampDoubleIntoInt(), WlzValueClampDoubleIntoShort(), WlzValueClampFloatIntoInt(), WlzValueClampFloatIntoShort(), WlzValueConvertPixel(), WlzValueCopyDoubleToInt(), WlzValueCopyDoubleToShort(), WlzValueCopyDoubleToUByte(), WlzValueCopyDVertexToIVertex(), WlzValueCopyDVertexToIVertex3(), WlzValueCopyFloatToInt(), WlzValueCopyFloatToShort(), WlzValueCopyFloatToUByte(), WlzValueCopyFVertexToIVertex(), WlzValueCopyFVertexToIVertex3(), and WlzValueDitherI().

◆ WLZ_SIGN

#define WLZ_SIGN ( X ) (((X)<0)?-1:((X)>0)?1:0)

◆ WLZ_SWAP

#define WLZ_SWAP	(	T,
		A,
		B
	)	{(T)=(A);(A)=(B);(B)=(T);}

Swaps the values of the variables A and B using the temporary variable T.

◆ WLZ_CLAMP

#define WLZ_CLAMP	(	V,
		N,
		X
	)	(((V)<(N))?(N):((V)>(X))?(X):(V))

◆ WLZ_CLAMP_DOUBLE_TO_GREYP

#define WLZ_CLAMP_DOUBLE_TO_GREYP	(	U,
		F,
		V,
		G
	)

Value:

{\
                  switch((G))\
                  {\
                    case WLZ_GREY_UBYTE:\
                      (U).inp[(F)]=WLZ_CLAMP((V),0,255);\
                      break;\
                    case WLZ_GREY_SHORT:\
                      (U).shp[(F)]=WLZ_CLAMP((V),SHRT_MIN,SHRT_MAX);\
                      break;\
                    case WLZ_GREY_INT:\
                      (U).inp[(F)]=WLZ_CLAMP((V),-FLT_MAX,FLT_MAX);\
                      break;\
                    case WLZ_GREY_FLOAT:\
                      (U).flp[(F)]=WLZ_CLAMP((V),-FLT_MAX,FLT_MAX);\
                      break;\
                    case WLZ_GREY_DOUBLE:\
                      (U).dbp[(F)]=(V);\
                      break;\
                    default:\
                      break;\
                  }\
                }\

Clamps a single double value from V setting U offset by F such that U >= MIN and U <= MAX where MIN and MAX are the minimum and maximum values for the grey type G. The only valid types for G are: WLZ_GREY_UBYTE, WLZ_GREY_SHORT, WLZ_GREY_INT, WLZ_GREY_FLOAT, and WLZ_GREY_DOUBLE; there is no check that G is none of these types.

◆ WLZ_M_E

#define WLZ_M_E (2.7182818284590452354)0

◆ WLZ_M_LOG2E [1/2]

#define WLZ_M_LOG2E (1.4426950408889634074)

◆ WLZ_M_LOG2E [2/2]

#define WLZ_M_LOG2E (1.4426950408889634074)

◆ WLZ_M_LOG10E

#define WLZ_M_LOG10E (0.43429448190325182765)

◆ WLZ_M_LN2

#define WLZ_M_LN2 (0.69314718055994530942)

◆ WLZ_M_LN10

#define WLZ_M_LN10 (2.30258509299404568402)

◆ WLZ_M_PI

#define WLZ_M_PI (3.14159265358979323846)

Referenced by Wlz3DViewTransformBitmap(), WlzEffBibParse3DSectionViewParamsRecord(), WlzEffBibWrite3DSectionViewParamsRecord(), and WlzGauss2().

◆ WLZ_M_PI_2

#define WLZ_M_PI_2 (1.57079632679489661923)

Referenced by WlzPrincipalAngle().

◆ WLZ_M_PI_4

#define WLZ_M_PI_4 (0.78539816339744830961)

◆ WLZ_M_1_PI

#define WLZ_M_1_PI (0.31830988618379067154)

◆ WLZ_M_2_PI

#define WLZ_M_2_PI (0.63661977236758134308)

◆ WLZ_M_2_SQRTPI

#define WLZ_M_2_SQRTPI (1.12837916709551257390)

◆ WLZ_M_SQRT2

#define WLZ_M_SQRT2 (1.41421356237309504880)

◆ WLZ_M_SQRT1_2

#define WLZ_M_SQRT1_2 (0.70710678118654752440)

◆ WLZ_M_SQRT3

#define WLZ_M_SQRT3 (1.73205080756887729352)

◆ WLZ_M_SQRT3_2

#define WLZ_M_SQRT3_2 (0.86602540378443864676)

◆ WLZ_MESH_TOLERANCE

#define WLZ_MESH_TOLERANCE (1.0E-04)

Referenced by WlzBasisFnSetCMesh2D(), WlzBasisFnSetCMesh3D(), WlzCMeshClosestNod2D5(), WlzCMeshCmpElmFeat2D(), WlzCMeshCmpElmFeat3D(), WlzCMeshCopy2D(), WlzCMeshCopy2D5(), WlzCMeshCopy3D(), WlzCMeshDGTensorAtPts(), WlzCMeshElmEnclosesPos2D5(), WlzCMeshIntersectDom2D5(), WlzCMeshMeshMeshProduct(), WlzCMeshTrRegSM3D(), and WlzGeomTetrahedronVtxDistSq3D().

◆ WLZ_MESH_TOLERANCE_SQ

#define WLZ_MESH_TOLERANCE_SQ (WLZ_MESH_TOLERANCE * WLZ_MESH_TOLERANCE)

Referenced by WlzCMeshBoundConform3D(), WlzCMeshCopy2D(), WlzCMeshCopy2D5(), WlzCMeshCopy3D(), WlzCMeshFixNegativeElms2D(), WlzCMeshFixNegativeElms3D(), WlzCMeshSetElm2D(), WlzCMeshSetElm2D5(), WlzCMeshSetElm3D(), WlzCMeshVerify2D(), WlzCMeshVerify3D(), WlzMeshClosestNod2D(), WlzMeshElemFindVxWalk(), WlzMeshElemReplace1(), WlzMeshElemReplaceNWithN(), WlzMeshElemSplit(), and WlzMeshElemVerify().

◆ WLZ_MESH_ELEM_AREA_TOLERANCE

#define WLZ_MESH_ELEM_AREA_TOLERANCE (WLZ_M_SQRT3_2 * WLZ_MESH_TOLERANCE_SQ)

Referenced by WlzMeshEarPowerSet().

◆ WLZ_BIT_SET

#define WLZ_BIT_SET	(	A,
		B
	)	*((A)+((B)>>3))\|=(1<<((B)&7))

◆ WLZ_BIT_GET

#define WLZ_BIT_GET	(	A,
		B
	)	(*((A)+((B)>>3))&(1<<((B)&7)))

Referenced by WlzContourGrdObj2D().

◆ WLZ_RGBA_RED_GET

#define WLZ_RGBA_RED_GET ( V ) ((((WlzUInt )V) & 0xff)>>0)

Referenced by Wlz1DConv(), WlzEffWriteObjJpeg(), WlzGreyMeanDifference(), WlzGreySetRange(), WlzGreySetRangeLut(), WlzIndexedValueBufWeight(), WlzLUTGreyTransformSet(), WlzLUTTransformGreyValues(), WlzRGBABoxThreshold(), WlzRGBAMultiThreshold(), WlzRGBAPixelValue(), WlzSplitMontageObj(), and WlzVectorThreshCb().

◆ WLZ_RGBA_GREEN_GET

#define WLZ_RGBA_GREEN_GET ( V ) ((((WlzUInt )V) & 0xff00)>>8)

Referenced by Wlz1DConv(), WlzEffWriteObjJpeg(), WlzGreyMeanDifference(), WlzGreySetRange(), WlzGreySetRangeLut(), WlzIndexedValueBufWeight(), WlzLUTGreyTransformSet(), WlzLUTTransformGreyValues(), WlzRGBABoxThreshold(), WlzRGBAMultiThreshold(), WlzRGBAPixelValue(), WlzSplitMontageObj(), and WlzVectorThreshCb().

◆ WLZ_RGBA_BLUE_GET

#define WLZ_RGBA_BLUE_GET ( V ) ((((WlzUInt )V) & 0xff0000)>>16)

Referenced by Wlz1DConv(), WlzEffWriteObjJpeg(), WlzGreyMeanDifference(), WlzGreySetRange(), WlzGreySetRangeLut(), WlzIndexedValueBufWeight(), WlzLUTGreyTransformSet(), WlzLUTTransformGreyValues(), WlzRGBABoxThreshold(), WlzRGBAMultiThreshold(), WlzRGBAPixelValue(), WlzSplitMontageObj(), and WlzVectorThreshCb().

◆ WLZ_RGBA_ALPHA_GET

#define WLZ_RGBA_ALPHA_GET ( V ) ((((WlzUInt )V) & 0xff000000)>>24)

Referenced by WlzGreySetRange(), WlzGreySetRangeLut(), WlzIndexedValueBufWeight(), WlzLUTGreyTransformSet(), and WlzLUTTransformGreyValues().

◆ WLZ_RGBA_RED_SET

#define WLZ_RGBA_RED_SET	(	V,
		C
	)

Value:

(V = (((WlzUInt )V)&0xffffff00) | \

(((WlzUInt) C)&0xff))

WlzUInt

unsigned int WlzUInt

A 32 bit unsigned integer.

Definition: WlzType.h:63

Referenced by WlzGreySetRangeLut(), and WlzRGBABoxThreshold().

◆ WLZ_RGBA_GREEN_SET

#define WLZ_RGBA_GREEN_SET	(	V,
		C
	)

Value:

(V = (((WlzUInt )V)&0xffff00ff) | \

((((WlzUInt) C)&0xff)<<8))

WlzUInt

unsigned int WlzUInt

A 32 bit unsigned integer.

Definition: WlzType.h:63

Referenced by WlzGreySetRangeLut(), and WlzRGBABoxThreshold().

◆ WLZ_RGBA_BLUE_SET

#define WLZ_RGBA_BLUE_SET	(	V,
		C
	)

Value:

(V = (((WlzUInt )V)&0xff00ffff) | \

((((WlzUInt) C)&0xff)<<16))

WlzUInt

unsigned int WlzUInt

A 32 bit unsigned integer.

Definition: WlzType.h:63

Referenced by WlzGreySetRangeLut(), and WlzRGBABoxThreshold().

◆ WLZ_RGBA_ALPHA_SET

#define WLZ_RGBA_ALPHA_SET	(	V,
		C
	)

Value:

(V = (((WlzUInt )V)&0x00ffffff) | \

((((WlzUInt) C)&0xff)<<24))

WlzUInt

unsigned int WlzUInt

A 32 bit unsigned integer.

Definition: WlzType.h:63

Referenced by WlzGreySetRangeLut().

◆ WLZ_RGBA_RGBA_SET

#define WLZ_RGBA_RGBA_SET	(	V,
		R,
		G,
		B,
		A
	)

Value:

(V = ((((WlzUInt )R)&0xff) + \
                                           ((((WlzUInt )G)&0xff)<<8) + \
                                           ((((WlzUInt )B)&0xff)<<16) + \
                                           ((((WlzUInt )A)&0xff)<<24)))

Referenced by Wlz1DConv(), WlzEffReadObjJpeg(), WlzGreySetRange(), WlzIndexedValueBufWeight(), WlzLUTGreyTransformSet(), WlzLUTMergeToRGBA(), WlzLUTTransformGreyValues(), WlzRGBABoxThreshold(), WlzSplitMontageObj(), WlzValueClampDoubleIntoRGBA(), WlzValueClampFloatIntoRGBA(), WlzValueClampIntIntoRGBA(), WlzValueClampShortIntoRGBA(), WlzValueConvertPixel(), and WlzValueCopyUByteToRGBA().

◆ WLZ_RGBA_MEAN

#define WLZ_RGBA_MEAN ( V )

Value:

((WLZ_RGBA_RED_GET(V) + \
                                  WLZ_RGBA_GREEN_GET(V) + \
                                  WLZ_RGBA_BLUE_GET(V))/3.0)

◆ WLZ_RGBA_MODULUS_2

#define WLZ_RGBA_MODULUS_2 ( V )

Value:

(WLZ_RGBA_RED_GET(V)*WLZ_RGBA_RED_GET(V) + \
                              WLZ_RGBA_GREEN_GET(V)*WLZ_RGBA_GREEN_GET(V) + \
                              WLZ_RGBA_BLUE_GET(V)*WLZ_RGBA_BLUE_GET(V))

◆ WLZ_RGBA_MODULUS

#define WLZ_RGBA_MODULUS ( V ) (sqrt((double) WLZ_RGBA_MODULUS_2(V)))

Referenced by WlzLUTTransformGreyValues(), WlzPointsFromDomObj(), WlzPrincipalAngle(), WlzRGBAModulusRange(), WlzRGBAPixelValue(), WlzValueConvertPixel(), WlzValueCopyRGBAToDouble(), WlzValueCopyRGBAToFloat(), WlzValueCopyRGBAToInt(), WlzValueCopyRGBAToShort(), and WlzValueCopyRGBAToUByte().

◆ WLZ_VTX_2_ABS

#define WLZ_VTX_2_ABS	(	A,
		X
	)

Value:

(A).vtX = WLZ_ABS((X).vtX), \

(A).vtY = WLZ_ABS((X).vtY)

WLZ_ABS

#define WLZ_ABS(X)

Definition: WlzMacro.h:57

◆ WLZ_VTX_3_ABS

#define WLZ_VTX_3_ABS	(	A,
		X
	)

Value:

(A).vtX = WLZ_ABS((X).vtX), \
                (A).vtY = WLZ_ABS((X).vtY), \
                (A).vtZ = WLZ_ABS((X).vtZ)

◆ WLZ_VTX_2_SIGN

#define WLZ_VTX_2_SIGN	(	S,
		X
	)

Value:

(S).vtX = WLZ_SIGN((X).vtX), \

(S).vtY = WLZ_SIGN((X).vtY)

WLZ_SIGN

#define WLZ_SIGN(X)

Definition: WlzMacro.h:59

◆ WLZ_VTX_3_SIGN

#define WLZ_VTX_3_SIGN	(	S,
		X
	)

Value:

(S).vtX = WLZ_SIGN((X).vtX), \
                (S).vtY = WLZ_SIGN((X).vtY), \
                (S).vtZ = WLZ_SIGN((X).vtZ)

◆ WLZ_VTX_2_COPY

#define WLZ_VTX_2_COPY	(	D,
		S
	)

Value:

(D).vtX = (S).vtX, \

(D).vtY = (S).vtY

Referenced by WlzPointsDither().

◆ WLZ_VTX_3_COPY

#define WLZ_VTX_3_COPY	(	D,
		S
	)

Value:

(D).vtX = (S).vtX, \
                (D).vtY = (S).vtY, \
                (D).vtZ = (S).vtZ

Referenced by WlzPointsDither().

◆ WLZ_VTX_2_SET

#define WLZ_VTX_2_SET	(	U,
		X,
		Y
	)

Value:

(U).vtX = (X), \

(U).vtY = (Y)

Referenced by WlzBSplineLength(), and WlzCMeshClosePointDom2D5().

◆ WLZ_VTX_3_SET

#define WLZ_VTX_3_SET	(	U,
		X,
		Y,
		Z
	)

Value:

(U).vtX = (X), \
                (U).vtY = (Y), \
                (U).vtZ = (Z)

Referenced by WlzBSplineLength(), WlzCMeshClosePointDom2D5(), WlzCMeshClosestNod2D5(), WlzCMeshComputeNormalsIxv2D5(), WlzGeomCurvature(), and WlzObjToConvexHull().

◆ WLZ_VTX_2_ADD

#define WLZ_VTX_2_ADD	(	U,
		V,
		W
	)

Value:

(U).vtX = (V).vtX + (W).vtX, \

(U).vtY = (V).vtY + (W).vtY

Referenced by WlzAffineTransformLSqReg2D(), WlzAffineTransformLSqScale2D(), WlzBasisFnSetCMesh2D(), WlzBasisFnTransformNormalD(), WlzCentreOfMassVtx2D(), WlzCMeshIntersect2Mesh2D(), WlzCMeshMeshMeshProduct(), WlzConvexHullFromVtx2(), WlzGeomObjLineSegIntersect2D(), WlzGeomRectFromWideLine(), WlzMeshAffineProduct(), and WlzPointsDither().

◆ WLZ_VTX_3_ADD

#define WLZ_VTX_3_ADD	(	U,
		V,
		W
	)

Value:

(U).vtX = (V).vtX + (W).vtX, \
                (U).vtY = (V).vtY + (W).vtY, \
                (U).vtZ = (V).vtZ + (W).vtZ

Referenced by WlzAffineTransformLSqReg3D(), WlzBasisFnSetCMesh3D(), WlzCentreOfMassVtx3D(), WlzCMeshComputeNormalsIxv2D5(), WlzCMeshIntersectDom2D5(), WlzGeomObjLineSegIntersect3D(), WlzGMVertexNormal3D(), WlzLBTClassifyNodeFace3D(), and WlzPointsDither().

◆ WLZ_VTX_2_ADD3

#define WLZ_VTX_2_ADD3	(	U,
		V,
		W,
		X
	)

Value:

(U).vtX = (V).vtX + (W).vtX + (X).vtX, \

(U).vtY = (V).vtY + (W).vtY + (X).vtY

Referenced by WlzGeomTriangleCen2D().

◆ WLZ_VTX_3_ADD3

#define WLZ_VTX_3_ADD3	(	U,
		V,
		W,
		X
	)

Value:

(U).vtX = (V).vtX + (W).vtX + (X).vtX, \
                (U).vtY = (V).vtY + (W).vtY + (X).vtY, \
                (U).vtZ = (V).vtZ + (W).vtZ + (X).vtZ

Referenced by WlzGeomTriangleCen3D().

◆ WLZ_VTX_3_ADD4

#define WLZ_VTX_3_ADD4	(	U,
		V,
		W,
		X,
		Y
	)

Value:

(U).vtX = (V).vtX + (W).vtX + (X).vtX + (Y).vtX, \
                (U).vtY = (V).vtY + (W).vtY + (X).vtY + (Y).vtY, \
                (U).vtZ = (V).vtZ + (W).vtZ + (X).vtZ + (Y).vtZ

Referenced by WlzGeomTetrahedronCen3D().

◆ WLZ_VTX_2_SUB

#define WLZ_VTX_2_SUB	(	U,
		V,
		W
	)

Value:

(U).vtX = (V).vtX - (W).vtX, \

(U).vtY = (V).vtY - (W).vtY

Referenced by WlzAffineTransformLSqReg2D(), WlzAffineTransformLSqScale2D(), WlzBasisFnSetCMesh2D(), WlzBasisFnTransformNormalD(), WlzCMeshClosePointDom2D5(), WlzCMeshCmpElmFeat2D(), WlzCMeshCompSurfMapToDomain(), WlzCMeshCurvToImage(), WlzCMeshElmMinEdgLnSq2D(), WlzCMeshMeshMeshProduct(), WlzCMeshSetElm2D(), WlzGeomArcLength2D(), WlzGeomCmpVtx2D(), WlzGeomCos3V(), WlzGeomDist2D(), WlzGeomDistSq2D(), WlzGeomEllipseVxDistSq(), WlzGeomInterpolateConvexPoly2D(), WlzGeomObjLineSegIntersect2D(), WlzGeomPolar2D(), WlzGeomRectFromWideLine(), WlzGeomTriangleAABBIntersect2D(), WlzGeomTriangleVtxDistSq2D(), WlzGeomUnitVector2D2(), WlzGeomVertexInDiamCircle(), WlzGeomVtxOnLineSegment2D(), WlzGeomVxInTriangle2D(), WlzGMModelSpxStats(), WlzKrigOSetModelSV2D(), WlzKrigOSetPosSV2D(), WlzMeshAffineProduct(), WlzMeshClosestNod2D(), and WlzMeshMaxEdgeLenSq().

◆ WLZ_VTX_3_SUB

#define WLZ_VTX_3_SUB	(	U,
		V,
		W
	)

Value:

(U).vtX = (V).vtX - (W).vtX, \
                (U).vtY = (V).vtY - (W).vtY, \
                (U).vtZ = (V).vtZ - (W).vtZ

Referenced by WlzAffineTransformLSqReg3D(), WlzBasisFnSetCMesh3D(), WlzBasisFnValueMOS3D(), WlzBasisFnValueScalarMOS3D(), WlzCMeshCmpElmFeat3D(), WlzCMeshCompSurfMapToDomain(), WlzCMeshComputeNormalsIxv2D5(), WlzCMeshElmMinEdgLnSq3D(), WlzCMeshElmMinMaxEdgLnSq3D(), WlzCMeshIntersectDom2D5(), WlzCMeshSetElm2D5(), WlzGeomBaryCoordsTet3D(), WlzGeomCmpVtx3D(), WlzGeomCurvature(), WlzGeomDist3D(), WlzGeomDistSq3D(), WlzGeometryLSqOPlane(), WlzGeomLineLineSegmentIntersect3D(), WlzGeomLinePlaneIntersection(), WlzGeomLineTriangleIntersect3D(), WlzGeomMap3DTriangleTo2D(), WlzGeomObjLineSegIntersect3D(), WlzGeomPlaneTriangleIntersect(), WlzGeomTetrahedronAABBIntersect3D(), WlzGeomTetVolZeroD(), WlzGeomTetVolZeroI(), WlzGeomTriangleAABBIntersect3D(), WlzGeomTriangleArea2Sq3(), WlzGeomTriangleArea2Sq3I(), WlzGeomTriangleNormal(), WlzGeomTriangleVtxDistSq3D(), WlzGeomUnitVector3D2(), WlzGeomVtxOnLine3D(), WlzGeomVtxOnLineSegment3D(), WlzGeomVxInTriangle3D(), WlzGMEdgeTInsertRadial(), WlzKrigOSetModelSV3D(), WlzKrigOSetPosSV3D(), and WlzProfileLineIDom().

◆ WLZ_VTX_2_SCALE

#define WLZ_VTX_2_SCALE	(	U,
		V,
		C
	)

Value:

(U).vtX = (V).vtX * (C), \

(U).vtY = (V).vtY * (C)

Referenced by WlzAffineTransformLSqReg2D(), WlzAffineTransformLSqScale2D(), WlzBasisFnSetCMesh2D(), WlzBasisFnTransformNormalD(), WlzBSplineTangent(), WlzCentreOfMassVtx2D(), WlzConvexHullFromVtx2(), WlzGeomObjLineSegIntersect2D(), WlzGeomTriangleCen2D(), WlzGeomUnitVector2D(), and WlzGeomUnitVector2D2().

◆ WLZ_VTX_3_SCALE

#define WLZ_VTX_3_SCALE	(	U,
		V,
		C
	)

Value:

(U).vtX = (V).vtX * (C), \
                (U).vtY = (V).vtY * (C), \
                (U).vtZ = (V).vtZ * (C)

Referenced by WlzAffineTransformLSqReg3D(), WlzBasisFnSetCMesh3D(), WlzBSplineTangent(), WlzCentreOfMassVtx3D(), WlzCMeshComputeNormalsIxv2D5(), WlzCMeshComputeNormalsNod(), WlzCMeshIntersectDom2D5(), WlzFitPlaneSVD(), WlzGeomCurvature(), WlzGeomMap3DTriangleTo2D(), WlzGeomObjLineSegIntersect3D(), WlzGeomTetrahedronCen3D(), WlzGeomTriangleCen3D(), WlzGeomTriangleNormal(), WlzGeomUnitVector3D(), WlzGeomUnitVector3D2(), WlzGeomVtxSortRadial(), WlzGeomVxInTriangle3D(), WlzGMEdgeTInsertRadial(), and WlzGMVertexNormal3D().

◆ WLZ_VTX_2_SCALE_ADD

#define WLZ_VTX_2_SCALE_ADD	(	U,
		V,
		C,
		W
	)

Value:

(U).vtX = (V).vtX * (C) + (W.vtX), \

(U).vtY = (V).vtY * (C) + (W.vtY)

Referenced by WlzGeomTriangleVtxDistSq2D().

◆ WLZ_VTX_3_SCALE_ADD

#define WLZ_VTX_3_SCALE_ADD	(	U,
		V,
		C,
		W
	)

Value:

(U).vtX = (V).vtX * (C) + (W.vtX), \
                (U).vtY = (V).vtY * (C) + (W.vtY), \
                (U).vtZ = (V).vtZ * (C) + (W.vtZ)

Referenced by WlzGeomLineLineSegmentIntersect3D(), and WlzGeomVtxOnLineSegment3D().

◆ WLZ_VTX_2_DOT

#define WLZ_VTX_2_DOT	(	V,
		W
	)

Value:

(((V).vtX * (W).vtX) + \

((V).vtY * (W).vtY))

Referenced by WlzAffineTransformLSqReg2D(), WlzGeomTriangleVtxDistSq2D(), and WlzGeomVertexInDiamCircle().

◆ WLZ_VTX_2_HAD

#define WLZ_VTX_2_HAD	(	U,
		V,
		W
	)

Value:

(U).vtX = (V).vtX * (W).vtX, \

(U).vtY = (V).vtY * (W).vtY

Referenced by WlzBSplineLength().

◆ WLZ_VTX_3_DOT

#define WLZ_VTX_3_DOT	(	V,
		W
	)

Value:

(((V).vtX * (W).vtX) + \
                 ((V).vtY * (W).vtY) + \
                 ((V).vtZ * (W).vtZ))

Referenced by WlzAffineTransformLSqReg3D(), WlzGeomCurvature(), WlzGeomLineTriangleIntersect3D(), WlzGeomMap3DTriangleTo2D(), WlzGeomTetVolZeroD(), WlzGeomTetVolZeroI(), WlzGeomTriangleVtxDistSq3D(), WlzGeomVtxOnLineSegment3D(), WlzGeomVtxSortRadial(), WlzGeomVxInTriangle3D(), and WlzGMEdgeTInsertRadial().

◆ WLZ_VTX_3_HAD

#define WLZ_VTX_3_HAD	(	U,
		V,
		W
	)

Value:

(U).vtX = (V).vtX * (W).vtX, \
                (U).vtY = (V).vtY * (W).vtY, \
                (U).vtZ = (V).vtZ * (W).vtZ

Referenced by WlzBSplineLength().

◆ WLZ_VTX_3_CROSS

#define WLZ_VTX_3_CROSS	(	U,
		V,
		W
	)

Value:

(U).vtX = ((V).vtY * (W).vtZ) - ((W).vtY * (V).vtZ), \
                (U).vtY = ((V).vtZ * (W).vtX) - ((W).vtZ * (V).vtX), \
                (U).vtZ = ((V).vtX * (W).vtY) - ((W).vtX * (V).vtY)

Referenced by WlzCMeshComputeNormalsIxv2D5(), WlzGeomCurvature(), WlzGeomLineLineSegmentIntersect3D(), WlzGeomLineTriangleIntersect3D(), WlzGeomMap3DTriangleTo2D(), WlzGeomTetrahedronAABBIntersect3D(), WlzGeomTetVolZeroD(), WlzGeomTetVolZeroI(), WlzGeomTriangleAABBIntersect3D(), WlzGeomTriangleArea2Sq3(), WlzGeomTriangleArea2Sq3I(), WlzGeomTriangleNormal(), WlzGeomVtxOnLine3D(), WlzGeomVtxOnLineSegment3D(), WlzGeomVtxSortRadial(), WlzGeomVxInTriangle3D(), and WlzGMEdgeTInsertRadial().

◆ WLZ_VTX_2_SQRLEN

#define WLZ_VTX_2_SQRLEN ( U )

Value:

(((U).vtX * (U).vtX) + \

((U).vtY * (U).vtY))

Referenced by WlzBasisFnTransformNormalD(), WlzCMeshCmpElmFeat2D(), WlzCMeshCompSurfMapToDomain(), WlzCMeshCurvToImage(), WlzCMeshElmMinEdgLnSq2D(), WlzCMeshMeshMeshProduct(), WlzCMeshSetElm2D(), WlzGeomArcLength2D(), WlzGeomCos3V(), WlzGeomDistSq2D(), WlzGeomInterpolateConvexPoly2D(), WlzGeomObjLineSegIntersect2D(), WlzGeomTriangleVtxDistSq2D(), WlzGMModelSpxStats(), WlzMeshClosestNod2D(), and WlzMeshMaxEdgeLenSq().

◆ WLZ_VTX_3_SQRLEN

#define WLZ_VTX_3_SQRLEN ( U )

Value:

(((U).vtX * (U).vtX) + \
                 ((U).vtY * (U).vtY) + \
                 ((U).vtZ * (U).vtZ))

Referenced by WlzCMeshCmpElmFeat3D(), WlzCMeshCompSurfMapToDomain(), WlzCMeshElmMinEdgLnSq3D(), WlzCMeshElmMinMaxEdgLnSq3D(), WlzCMeshSetElm2D5(), WlzDGTensorFeatures(), WlzGeomDistSq3D(), WlzGeomLineLineSegmentIntersect3D(), WlzGeomObjLineSegIntersect3D(), WlzGeomPlaneTriangleIntersect(), WlzGeomTetrahedronAABBIntersect3D(), WlzGeomTriangleAABBIntersect3D(), WlzGeomTriangleArea2Sq3(), WlzGeomTriangleArea2Sq3I(), WlzGeomVtxOnLine3D(), WlzGeomVtxOnLineSegment3D(), and WlzGeomVxInTriangle3D().

◆ WLZ_VTX_2_LENGTH

#define WLZ_VTX_2_LENGTH ( U ) (sqrt(WLZ_VTX_2_SQRLEN(U)))

Referenced by WlzAffineTransformLSqScale2D(), WlzBasisFnSetCMesh2D(), WlzBSplineLength(), WlzBSplineTangent(), WlzGeomDist2D(), WlzGeomObjLineSegIntersect2D(), WlzGeomPolar2D(), WlzGeomRectFromWideLine(), WlzGeomUnitVector2D(), WlzGeomUnitVector2D2(), WlzKrigOSetModelSV2D(), and WlzKrigOSetPosSV2D().

◆ WLZ_VTX_3_LENGTH

◆ WLZ_VTX_2_ZERO

#define WLZ_VTX_2_ZERO ( U )

Value:

(U).vtX = 0, \

(U).vtY = 0

Referenced by WlzBasisFnSetCMesh2D(), WlzBasisFnTransformNormalD(), WlzCentreOfMassVtx2D(), and WlzConvexHullFromVtx2().

◆ WLZ_VTX_3_ZERO

#define WLZ_VTX_3_ZERO ( U )

Value:

(U).vtX = 0, \
                (U).vtY = 0, \
                (U).vtZ = 0

Referenced by WlzBasisFnSetCMesh3D(), WlzCentreOfMassVtx3D(), WlzCMeshComputeNormalsIxv2D5(), WlzCMeshComputeNormalsNod(), WlzCMeshIntersectDom2D5(), WlzDomainNearby(), and WlzFitPlaneSVD().

◆ WLZ_VTX_2_NEGATE

#define WLZ_VTX_2_NEGATE	(	U,
		V
	)

Value:

(U).vtX = -((V).vtX), \

(U).vtY = -((V).vtY)

◆ WLZ_VTX_3_NEGATE

#define WLZ_VTX_3_NEGATE	(	U,
		V
	)

Value:

(U).vtX = -((V).vtX), \
                (U).vtY = -((V).vtY), \
                (U).vtZ = -((V).vtZ)

◆ WLZ_VTX_2_EQUAL

#define WLZ_VTX_2_EQUAL	(	U,
		V,
		T
	)

Value:

((fabs((U).vtX - (V).vtX) < (T)) && \

(fabs((U).vtY - (V).vtY) < (T)))

Referenced by WlzConvexHullFromVtx2().

◆ WLZ_VTX_3_EQUAL

#define WLZ_VTX_3_EQUAL	(	U,
		V,
		T
	)

Value:

((fabs((U).vtX - (V).vtX) < (T)) && \
                 (fabs((U).vtY - (V).vtY) < (T)) && \
                 (fabs((U).vtZ - (V).vtZ) < (T)))

Referenced by WlzCMeshTrRegSM3D().

◆ WLZ_VTX_2_FABS

#define WLZ_VTX_2_FABS	(	U,
		V
	)

Value:

((U).vtX = fabs((V).vtX), \

(U).vtY = fabs((V).vtY))

◆ WLZ_VTX_3_FABS

#define WLZ_VTX_3_FABS	(	U,
		V
	)

Value:

((U).vtX = fabs((V).vtX), \
                 (U).vtY = fabs((V).vtY), \
                 (U).vtZ = fabs((V).vtZ))

◆ WLZ_VTX_2_NINT

#define WLZ_VTX_2_NINT	(	U,
		P
	)

Value:

((U).vtX = WLZ_NINT((P).vtX), \

(U).vtY = WLZ_NINT((P).vtY))

WLZ_NINT

#define WLZ_NINT(X)

Definition: WlzMacro.h:58

Referenced by WlzConvexHullFromVtx2(), WlzDomainNearby(), and WlzProjectObjToPlane().

◆ WLZ_VTX_3_NINT

#define WLZ_VTX_3_NINT	(	U,
		P
	)

Value:

((U).vtX = WLZ_NINT((P).vtX), \
                 (U).vtY = WLZ_NINT((P).vtY), \
                 (U).vtZ = WLZ_NINT((P).vtZ))

Referenced by WlzDomainNearby().

◆ WLZ_CMESH_ELM2D_GET_NODE_0

#define WLZ_CMESH_ELM2D_GET_NODE_0 ( e ) ((e)->edu[0].nod)

Referenced by WlzCMeshBoundConform2D(), WlzCMeshCopy2D(), WlzCMeshCopy2D5(), WlzCMeshCurvToImage(), WlzCMeshElmGetNodes2D(), WlzCMeshFixNegativeElms2D(), and WlzEffWriteObjNodeEle().

◆ WLZ_CMESH_ELM2D_GET_NODE_1

#define WLZ_CMESH_ELM2D_GET_NODE_1 ( e ) ((e)->edu[1].nod)

Referenced by WlzCMeshBoundConform2D(), WlzCMeshCopy2D(), WlzCMeshCopy2D5(), WlzCMeshCurvToImage(), WlzCMeshElmGetNodes2D(), WlzCMeshFixNegativeElms2D(), and WlzEffWriteObjNodeEle().

◆ WLZ_CMESH_ELM2D_GET_NODE_2

#define WLZ_CMESH_ELM2D_GET_NODE_2 ( e ) ((e)->edu[2].nod)

Referenced by WlzCMeshBoundConform2D(), WlzCMeshCopy2D(), WlzCMeshCopy2D5(), WlzCMeshCurvToImage(), WlzCMeshElmGetNodes2D(), WlzCMeshFixNegativeElms2D(), and WlzEffWriteObjNodeEle().

◆ WLZ_CMESH_ELM2D5_GET_NODE_0

#define WLZ_CMESH_ELM2D5_GET_NODE_0 ( e ) ((e)->edu[0].nod)

Referenced by WlzCMeshCopy2D5(), and WlzCMeshElmGetNodes2D5().

◆ WLZ_CMESH_ELM2D5_GET_NODE_1

#define WLZ_CMESH_ELM2D5_GET_NODE_1 ( e ) ((e)->edu[1].nod)

Referenced by WlzCMeshCopy2D5(), and WlzCMeshElmGetNodes2D5().

◆ WLZ_CMESH_ELM2D5_GET_NODE_2

#define WLZ_CMESH_ELM2D5_GET_NODE_2 ( e ) ((e)->edu[2].nod)

Referenced by WlzCMeshCopy2D5(), and WlzCMeshElmGetNodes2D5().

◆ WLZ_CMESH_ELM3D_GET_NODE_0

#define WLZ_CMESH_ELM3D_GET_NODE_0 ( e ) ((e)->face[0].edu[0].nod)

Referenced by WlzCMeshBoundConform3D(), WlzCMeshCmpElmFeat3D(), WlzCMeshCopy3D(), WlzCMeshElmEnclosesPos3D(), WlzCMeshElmGetNodes3D(), WlzCMeshElmMaxSqEdgLen3D(), WlzCMeshElmMinEdgLnSq3D(), WlzCMeshElmMinMaxEdgLnSq3D(), WlzCMeshElmRingElmIndices3D(), WlzCMeshElmSnVolume63D(), WlzCMeshFixNegativeElms3D(), WlzCMeshTrRegSM3D(), WlzCMeshUpdateMaxSqEdgLen3D(), WlzEffWriteObjMesh(), and WlzEffWriteObjNodeEle().

◆ WLZ_CMESH_ELM3D_GET_NODE_1

#define WLZ_CMESH_ELM3D_GET_NODE_1 ( e ) ((e)->face[0].edu[1].nod)

Referenced by WlzCMeshBoundConform3D(), WlzCMeshCmpElmFeat3D(), WlzCMeshCopy3D(), WlzCMeshElmEnclosesPos3D(), WlzCMeshElmGetNodes3D(), WlzCMeshElmMaxSqEdgLen3D(), WlzCMeshElmMinEdgLnSq3D(), WlzCMeshElmMinMaxEdgLnSq3D(), WlzCMeshElmRingElmIndices3D(), WlzCMeshElmSnVolume63D(), WlzCMeshFixNegativeElms3D(), WlzCMeshTrRegSM3D(), WlzCMeshUpdateMaxSqEdgLen3D(), WlzEffWriteObjMesh(), and WlzEffWriteObjNodeEle().

◆ WLZ_CMESH_ELM3D_GET_NODE_2

#define WLZ_CMESH_ELM3D_GET_NODE_2 ( e ) ((e)->face[0].edu[2].nod)

Referenced by WlzCMeshBoundConform3D(), WlzCMeshCmpElmFeat3D(), WlzCMeshCopy3D(), WlzCMeshElmEnclosesPos3D(), WlzCMeshElmGetNodes3D(), WlzCMeshElmMaxSqEdgLen3D(), WlzCMeshElmMinEdgLnSq3D(), WlzCMeshElmMinMaxEdgLnSq3D(), WlzCMeshElmRingElmIndices3D(), WlzCMeshElmSnVolume63D(), WlzCMeshFixNegativeElms3D(), WlzCMeshTrRegSM3D(), WlzCMeshUpdateMaxSqEdgLen3D(), WlzEffWriteObjMesh(), and WlzEffWriteObjNodeEle().

◆ WLZ_CMESH_ELM3D_GET_NODE_3

#define WLZ_CMESH_ELM3D_GET_NODE_3 ( e ) ((e)->face[1].edu[1].nod)

Referenced by WlzCMeshBoundConform3D(), WlzCMeshCmpElmFeat3D(), WlzCMeshCopy3D(), WlzCMeshElmEnclosesPos3D(), WlzCMeshElmGetNodes3D(), WlzCMeshElmMaxSqEdgLen3D(), WlzCMeshElmMinEdgLnSq3D(), WlzCMeshElmMinMaxEdgLnSq3D(), WlzCMeshElmRingElmIndices3D(), WlzCMeshElmSnVolume63D(), WlzCMeshFixNegativeElms3D(), WlzCMeshTrRegSM3D(), WlzCMeshUpdateMaxSqEdgLen3D(), WlzEffWriteObjMesh(), and WlzEffWriteObjNodeEle().

Macros

Detailed Description

Macro Definition Documentation

◆ WLZ_VERSION

◆ WLZ_MAX

◆ WLZ_MIN

◆ WLZ_ABS

◆ WLZ_NINT

◆ WLZ_SIGN

◆ WLZ_SWAP

◆ WLZ_CLAMP

◆ WLZ_CLAMP_DOUBLE_TO_GREYP

◆ WLZ_M_E

◆ WLZ_M_LOG2E [1/2]

◆ WLZ_M_LOG2E [2/2]

◆ WLZ_M_LOG10E

◆ WLZ_M_LN2

◆ WLZ_M_LN10

◆ WLZ_M_PI

◆ WLZ_M_PI_2

◆ WLZ_M_PI_4

◆ WLZ_M_1_PI

◆ WLZ_M_2_PI

◆ WLZ_M_2_SQRTPI

◆ WLZ_M_SQRT2

◆ WLZ_M_SQRT1_2

◆ WLZ_M_SQRT3

◆ WLZ_M_SQRT3_2

◆ WLZ_MESH_TOLERANCE

◆ WLZ_MESH_TOLERANCE_SQ

◆ WLZ_MESH_ELEM_AREA_TOLERANCE

◆ WLZ_BIT_SET

◆ WLZ_BIT_GET

◆ WLZ_RGBA_RED_GET

◆ WLZ_RGBA_GREEN_GET

◆ WLZ_RGBA_BLUE_GET

◆ WLZ_RGBA_ALPHA_GET

◆ WLZ_RGBA_RED_SET

◆ WLZ_RGBA_GREEN_SET

◆ WLZ_RGBA_BLUE_SET

◆ WLZ_RGBA_ALPHA_SET

◆ WLZ_RGBA_RGBA_SET

◆ WLZ_RGBA_MEAN

◆ WLZ_RGBA_MODULUS_2

◆ WLZ_RGBA_MODULUS

◆ WLZ_VTX_2_ABS

◆ WLZ_VTX_3_ABS

◆ WLZ_VTX_2_SIGN

◆ WLZ_VTX_3_SIGN

◆ WLZ_VTX_2_COPY

◆ WLZ_VTX_3_COPY

◆ WLZ_VTX_2_SET

◆ WLZ_VTX_3_SET

◆ WLZ_VTX_2_ADD

◆ WLZ_VTX_3_ADD

◆ WLZ_VTX_2_ADD3

◆ WLZ_VTX_3_ADD3

◆ WLZ_VTX_3_ADD4

◆ WLZ_VTX_2_SUB

◆ WLZ_VTX_3_SUB

◆ WLZ_VTX_2_SCALE

◆ WLZ_VTX_3_SCALE

◆ WLZ_VTX_2_SCALE_ADD

◆ WLZ_VTX_3_SCALE_ADD

◆ WLZ_VTX_2_DOT

◆ WLZ_VTX_2_HAD

◆ WLZ_VTX_3_DOT

◆ WLZ_VTX_3_HAD

◆ WLZ_VTX_3_CROSS

◆ WLZ_VTX_2_SQRLEN

◆ WLZ_VTX_3_SQRLEN

◆ WLZ_VTX_2_LENGTH

◆ WLZ_VTX_3_LENGTH

◆ WLZ_VTX_2_ZERO

◆ WLZ_VTX_3_ZERO

◆ WLZ_VTX_2_NEGATE

◆ WLZ_VTX_3_NEGATE

◆ WLZ_VTX_2_EQUAL

◆ WLZ_VTX_3_EQUAL

◆ WLZ_VTX_2_FABS