/* /////////////////////////////////////////////////////////////////////////////
//
// INTEL CORPORATION PROPRIETARY INFORMATION
// This software is supplied under the terms of a license agreement or
// nondisclosure agreement with Intel Corporation and may not be copied
// or disclosed except in accordance with the terms of that agreement.
// Copyright(c) 2006-2009 Intel Corporation. All Rights Reserved.
//
// Intel(R) Performance Primitives
// Realistic Rendering Library (ippRR)
//
*/
#if !defined( __IPPR_H__ ) || defined( _OWN_BLDPCS )
#define __IPPR_H__
#if defined (_WIN32_WCE) && defined (_M_IX86) && defined (__stdcall)
#define _IPP_STDCALL_CDECL
#undef __stdcall
#endif
#ifndef __IPPDEFS_H__
#include "ippdefs.h"
#endif
#ifdef __cplusplus
extern "C" {
#endif
#if !defined( _OWN_BLDPCS )
typedef float IppPoint2D_32f[2];
typedef float IppPoint3D_32f[3];
typedef float IppVector3D_32f[4];
typedef IppPoint3D_32f IppBox3D_32f[2];
typedef IppPoint3D_32f IppTriangle3D_32f[3];
typedef struct TriangleAccel IpprTriangleAccel;
typedef struct KDTreeNode{
Ipp32s flag_k_ofs;
union _tree_data{
Ipp32f split;
Ipp32s items;
}tree_data;
}IpprKDTreeNode;
typedef struct IntersectContext{
IppBox3D_32f *pBound; /* pointer to bounding box for a whole object */
IpprTriangleAccel *pAccel; /* pointer to triangle acceleration structure */
IpprKDTreeNode *pRootNode; /* pointer to KD-tree root node */
}IpprIntersectContext;
/* Tree building algorithm identifiers */
typedef enum {
ippKDTBuildSimple = 0x499d3dc2, /* Simple building mode */
ippKDTBuildPureSAH = 0x2d07705b /* SAH building mode */
}IpprKDTreeBuildAlg;
/* Context for simple building mode */
typedef struct SimpleBuilderContext{
IpprKDTreeBuildAlg Alg; /* Must be equal to ippKDTBuildSimple constant */
Ipp32s MaxDepth; /* Subdivision depth (with middle point subdivision) */
}IpprSmplBldContext;
/* Context for SAH building mode */
typedef struct PSAHBuilderContext{
IpprKDTreeBuildAlg Alg; /* Must be equal to ippKDTBuildPureSAH constant */
Ipp32s MaxDepth; /* Maximum tree subdivision depth (minimum - 0, maximum - 51) */
Ipp32f QoS; /* Termination criteria modifier */
Ipp32s AvailMemory; /* Maximum available memory in Mb */
IppBox3D_32f *Bounds; /* Cut-off bounding box */
}IpprPSAHBldContext;
typedef enum {
ippNormInd = 3,
ippTriInd = 4
} IpprIndexType;
typedef enum _IpprSHType{
ipprSHNormDirect=0, /* Normalized Spherical harmonic functions, direct computation */
ipprSHNormRecurr /* Normalized Spherical harmonic functions, recurrent computation */
}IpprSHType;
typedef struct rSHState IpprSHState;
#endif /* _OWN_BLDPCS */
/* /////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
// Functions declarations
////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////// */
/* /////////////////////////////////////////////////////////////////////////////
// Name: ipprGetLibVersion
// Purpose: getting of the library version
// Returns: the structure of information about version
// of ippRR library
// Parameters:
//
// Notes: not necessary to release the returned structure
*/
IPPAPI( const IppLibraryVersion*, ipprGetLibVersion, (void) )
/* /////////////////////////////////////////////////////////////////////////////
// Acceleration Functions
//////////////////////////////////////////////////////////////////////////////// */
/* ///////////////////////////////////////////////////////////////////////////
// Name:
// ipprTriangleAccelInit
// Purpose:
// Initialize a IpprtTriangleAccel for future usage in ipprIntersect...
// Input Arguments:
// pVertexCoord - pointer to the array of vertex coordinate.
// pTrnglIndex - pointer to the triangle's indexes.
// cntTrngl - the number of triangles.
// Input Arguments:
// pTrnglAccel - pointer to the structure IpprTriangleAccel
// Returns:
// ippStsNoErr No error.
*/
IPPAPI(IppStatus, ipprTriangleAccelInit,(
IpprTriangleAccel* pTrnglAccel,const Ipp32f* pVertexCoord,const Ipp32s* pTrnglIndex,int cntTrngl ))
/* ///////////////////////////////////////////////////////////////////////////
// Name:
// ipprTriangleAccelGetSize
//
// Purpose:
// Return size of IpprtTriangleAccel
// Parameters:
// pTrnglAccelSize - pointer to the resulting size of the structure
// IpprtTriangleAccel
// Returns:
// ippStsNoErr No error.
// ippStsNullPtrErr Indicates an error when pointer pTrnglAccelSize is NULL.
*/
IPPAPI(IppStatus, ipprTriangleAccelGetSize,(int* pTrnglAccelSize))
/* ///////////////////////////////////////////////////////////////////////////
Name:
ippiKDTreeBuildAlloc
Purpose:
Build the k-D tree for the set of triangles using one of predefined construction
algorithms controlled by service parameters context.
Parameters:
pDstKDTree - address of a pointer to the built tree;
pSrcVert - pointer to the scene element vertices array;
pSrcTriInx - pointer to the scene element indexed triangles array;
SrcVertSize - size of vertices array;
SrcTriSize - size of triangles array;
pDstKDTreeSize - address of the built tree size;
QoS - fuzzy quality control parameter. takes values from 0.0 to 1.0;
AlgType - type of tree construction algorithm
Returns:
ippStsNoErr No error.
ippStsNullPtrErr Indicates an error when one of the pointers is NULL.
ippStsSizeErr Wrong (negative) size of one of arrays.
ippStsOutOfRangeErr QoS is out of [0.0, 1.0] range.
ippStsNoMemErr Not enough memory for the tree construction algorithm.
ippStsBadArgErr Unknown algorithm type.
*/
IPPAPI(IppStatus, ipprKDTreeBuildAlloc,(
IpprKDTreeNode **pDstKDTree,
const Ipp32f * const pSrcVert,
const Ipp32s * const pSrcTriInx,
Ipp32s SrcVertSize,
Ipp32s SrcTriSize,
Ipp32s *pDstKDTreeSize,
const void * const pBldContext))
/* ///////////////////////////////////////////////////////////////////////////
Name:
ippiKDTreeFree
Purpose:
Frees memory allocated for the k-D tree during ippiKDTreeBuildAlloc.
Parameters:
pSrcKDTree - a pointer to the k-D tree;
Returns:
*/
IPPAPI(void, ipprKDTreeFree,(
IpprKDTreeNode *pSrcKDTree))
/* /////////////////////////////////////////////////////////////////////////////
// Ray-scene Intersection Engine
////////////////////////////////////////////////////////////////////////////// */
/* /////////////////////////////////////////////////////////////////////////////
// Names: ipprIntersectMO_32f
// Purpose: Calculates intersection points of rays with triangles,the indexes those triangles,
// the distances from origin points to intersection points.
//
// Input Arguments:
// pOrigin - array of pointers to a separate coordinates(x,y,z)of planes of the origin points..
// pDirection - array of pointers to a separate coordinates(x,y,z)of planes of the ray's directions.
// pContext - pointer to the intersection's context.
// blockSize - size of rays' block.
// Input/Output Arguments:
// pDist - pointer to the distance from origin to intersection point. Else it is input value.
// As input pDist[i] should be 0.f if you don't want to process this ray.
// Output Arguments:
// pHit - pointer to the local surface parameters( u, v )at hit point in case of intersection was found.
// pTrngl - pointer to the Triangle index in case of intersection was found. Else it is -1.
// Returns:
// ippStsNoErr No errors
// ippStsNoMemErr The node stack is overfilled.
*/
IPPAPI(IppStatus,ipprIntersectMO_32f,(
const Ipp32f* const pOrigin[3],
const Ipp32f* const pDirection[3],
Ipp32f* pDist,
Ipp32f* pHit[2],
Ipp32s* pTrngl,
const IpprIntersectContext* pContext,
IppiSize blockSize
))
/* /////////////////////////////////////////////////////////////////////////////
// Names: ipprIntersectEyeSO_32f
// Purpose: Calculates intersection points of rays with triangles,the indexes those triangles,
// the distances from origin points to intersection points.
//
// Input Arguments:
// originEye - origin point.All rays have a single origin.
// pDirection - array of pointers to a separate coordinates(x,y,z)of planes of the ray's directions.
// pContext - pointer to the intersection's context.
// blockSize - size of rays' block.
// Output Arguments:
// pDist - pointer to the distance from origin to intersection point. Else it is IPP_MAXABS_32F.
// pHit - pointer to the local surface parameters( u, v )at hit point in case of intersection was found.
// pTrngl - pointer to the Triangle index in case of intersection was found. Else it is -1.
// Returns:
// ippStsNoErr No errors
// ippStsNoMemErr The node stack is overfilled.
*/
IPPAPI(IppStatus,ipprIntersectEyeSO_32f,(
IppPoint3D_32f originEye,
const Ipp32f* const pDirection[3],
Ipp32f* pDist,
Ipp32f* pHit[2],
Ipp32s* pTrngl,
const IpprIntersectContext* pContext,
IppiSize blockSize
))
/* /////////////////////////////////////////////////////////////////////////////
// Names: ipprIntersectMultipleSO_32f
// Purpose: Calculates intersection points of rays with triangles,the indexes those triangles,
// the distances from origin points to intersection points.
//
//Input parameters:
// originEye origin point.All rays have a single origin.
// pDirection 2D array of pointers to the vectors of directions.
// pContext Pointer to the intersection context.
// blockVolume blockVolume.width * blockVolume.height is total number of the rays.
// blockVolume.depth - the specified number of the scene triangles.
//Input Output parameters:
//pDist Pointer to the 3D array of distances between the hit point and origin of the rays.
//Output parameters:
//pHit 3D array of pointers to the local surface parameters (u, v) at the hit
// point if the intersection is found.
//pTrngl Pointer to the 3D array of triangle indexes if the intersection is found. If not it is set to-1.
// Returns:
// ippStsNoErr No errors
*/
IPPAPI(IppStatus,ipprIntersectMultipleSO_32f,(
IppPoint3D_32f originEye,
const Ipp32f* const pDirection[3],
Ipp32f* pDistance,
Ipp32f* pHit[2],
Ipp32s* pTrngl,
IpprVolume blockVolume,
const IpprIntersectContext* pContext
))
/* /////////////////////////////////////////////////////////////////////////////
// Names: ipprIntersectAnySO_32f
// Purpose: performs occlusion tests for block of rays with single origin.
//
// Input Arguments:
// originEye - origin point.All rays have a single origin.
// pDirection - array of pointers to a separate coordinates(x,y,z)of planes of the ray's directions.
// pContext - pointer to the intersection's context.
// blockSize - size of rays' block.
// Input/Output Arguments:
// pMask - pointer to the array of the mask. If output pMask[i][j] = 0, occlusion test for this ray is true.
// Else it is input value.
// As input pMask[i][j] should be 0 if you don't want to process this ray.Else it should be -1.
// pTrngl - pointer to the Triangle index in case of intersection was found. Else it is -1.
// Returns:
// ippStsNoErr No errors
// ippStsNoMemErr The node stack is overfilled.
*/
IPPAPI(IppStatus,ipprIntersectAnySO_32f,(
IppPoint3D_32f originEye,
const Ipp32f* const pDirection[3],
Ipp32s* pOccluder,
Ipp32s* pMask,
IppiSize blockSize,
const IpprIntersectContext* pContext
))
/* /////////////////////////////////////////////////////////////////////////////
// Shaders Support Functions
//////////////////////////////////////////////////////////////////////////////// */
/* /////////////////////////////////////////////////////////////////////////////
// Name: ipprMul_32f_C1P3IM
// Purpose: Purpose: multiplies each element of three vectors of the accumulator (pSrcDst)
// for which the corresponding element of a vector of a mask more or is equal to zero,
// by an element of an source vector.
// Name: ipprMul_32f_IM
// Purpose: Multiplies an element of the accumulator (pSrcDst)
// for which the corresponding element of a vector of a mask more or is equal to zero,
// by an element of an source vector.
// Input Arguments:
// pSrc - pointer to the first source vector
// pMask - pointer to the first mask's vector
// len length of the vectors
// Input/Output Arguments:
// pSrcDst - pointer to the source/destination (accumulator) vectors.
// Returns:
// ippStsNoErr No errors
*/
IPPAPI(IppStatus,ipprMul_32f_C1P3IM,( const Ipp32f* pSrc, const Ipp32s* pMask,
Ipp32f* pSrcDst[3], int len ))
IPPAPI(IppStatus,ipprMul_32f_C1IM,( const Ipp32f* pSrc, const Ipp32s* pMask,
Ipp32f* pSrcDst, int len ))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ipprAddMulMul_32f_AC1P3IM
// Purpose: multiplies elements of two triplex source vectors and adds product
// to triplex of the accumulator vectors ???
// Input Arguments:
// point - source point.
// pSrc0 - pointer to the first source vector
// pSrc1 - pointer to the second source vector
// pMask - pointer to the mask's vector
// len - length of the vectors
// Output Arguments:
// pSrcDst - pointer to the source/destination (accumulator) vector.
// Notes:
// pSrcDst[0][n] = pSrcDst[0][n] + pSrc1[n] * pSrc2[n] * point[0], n=0,1,2,..len-1.
// pSrcDst[1][n] = pSrcDst[1][n] + pSrc1[n] * pSrc2[n] * point[1],
// pSrcDst[2][n] = pSrcDst[2][n] + pSrc1[n] * pSrc2[n] * point[2],
// E.g for Lambertian cosine low.
// Returns:
// ippStsNoErr No errors
*/
IPPAPI(IppStatus,ipprAddMulMul_32f_AC1P3IM,(
IppPoint3D_32f point,
const Ipp32f* pSrc0,
const Ipp32f* const pSrc1[3],
const Ipp32s* pMask,
Ipp32f* pSrcDst[3],
int len
))
/* /////////////////////////////////////////////////////////////////////////////
// Name: ipprDiv_32f_C1IM
// Purpose: divides an element of the accumulator (pSrcDst) for which the corresponding
// element of a vector of a mask more or is equal to zero, into an element of an source vector.
// Input Arguments:
// pSrc - pointer to the divisor source vector
// pMask - pointer to the mask vector.
// len - vector's length, number of items.
// Input-Output Argument:
// pSrcDst - pointer to the source/destination (accumulator) vector.
//
// Returns:
// ippStsNoErr No errors
*/
IPPAPI(IppStatus,ipprDiv_32f_C1IM,(const Ipp32f* pSrc, const Ipp32s* pMask, Ipp32f* pSrcDst, int len ))
/* ///////////////////////////////////////////////////////////////////////////
// Name:
// ipprDot_32f_P3C1M
// Purpose:
// calculates dot product of the incident ray directions and normales of surface.
// Input Arguments:
// pDirection - pointer to array of pointers to a separate coordinates(x,y,z)of planes of the ray's directions.
// pDist - pointer to the IpprPointsOnRays_SO structure
// pSurfNorm - pointer to the surface's normals.
// Output arguments:
// pSurfDotIn - pointer to the dot product.
// Returns:
// ippStsNoErr No errors
*/
IPPAPI(IppStatus, ipprDot_32f_P3C1M,( const Ipp32f* const pSrc0[3],
const Ipp32f* const pSrc1[3],const Ipp32s* pMask, Ipp32f* pDot, int len ))
IPPAPI(IppStatus, ipprDotChangeNorm_32f_IM,( const Ipp32f* const pSrc[3],
const Ipp32s* pMask, Ipp32f* pSrcDst[3],Ipp32f* pDot,int len ))
/* ///////////////////////////////////////////////////////////////////////////
// Name:
// ipprDot_32f_M
*/
IPPAPI(IppStatus, ipprDistAttenuationSO_32f_M,( IppPoint3D_32f point, const Ipp32f* const pSurfHit[3],
const Ipp32s* pMask, Ipp32f* pDist, int len ))
/* /////////////////////////////////////////////////////////////////////////////
// Rays' casting
//////////////////////////////////////////////////////////////////////////////// */
/* /////////////////////////////////////////////////////////////////////////////
// Name: ipprCastEye_32f
// Purpose: to calculate the primary ray's vectors.
// Input Arguments:
// imPlaneOrg - the coordinate of origin the projection's plane.
// dW - a step along width of the projection's plane.
// dH - a step along height of the projection's plane.
// wB - the number of block along width of Image.
// hB - the number of block along height of Image.
// cBlock - total number of rays in the block
// blockSize - total number of the rays in the current block.
// Input-Output Argument:
// pDirection - pointer to the destination vector. It is not normalised.
// Returns:
// ippStsNoErr No errors
*/
IPPAPI(IppStatus,ipprCastEye_32f,(
IppPoint3D_32f imPlaneOrg,
IppPoint3D_32f dW,
IppPoint3D_32f dH,
int wB,int hB,
IppiSize cBlock,
Ipp32f* pDirection[3],
IppiSize blockSize ))
/* /////////////////////////////////////////////////////////////////////////////
// Names: ipprCastShadowSO_32f
// Purpose: calculates block of shadow rays. for which the corresponding
// element of a vector of a pMask more or is equal to zero.
// Input Arguments:
// pOrigin - pointer to the origin point.
// pSurfDotIn - pointer to the vector of dot products of incident rays and normals
// at intersections point.
// pSurfNorm - pointer to array of pointers to a separate coordinates(x,y,z)of planes
// of normals at intersections point.
// pSurfHit - pointer to array of pointers to a separate coordinates(x,y,z)of planes of the intersection points.
// pMask - pointer to the mask vector.
// Output Arguments:
// pDirection - pointer to the destination vector. Shouldn't be normalised.
// pDist - . Here it is can be 0.f or 1.f
// pDotRay - pointer to the vector of dot products of shadow rays and normals.
// Returns:
// ippStsNoErr No errors
*/
IPPAPI(IppStatus,ipprCastShadowSO_32f,(
IppPoint3D_32f pOrigin,
const Ipp32f* pSurfDotIn,
const Ipp32f* const pSurfNorm[3],
const Ipp32f* const pSurfHit[3],
Ipp32s* pMask,
Ipp32f* pDotRay,
Ipp32f* pDirection[3],
int len
))
/* /////////////////////////////////////////////////////////////////////////////
// Names: ipprCastReflectionRay_32f
// Purpose: calculates array of reflected rays, for which the corresponding
// element of a vector of a mask more or is equal to zero.
//
// Input Arguments:
// pIncident - pointer to the array of vectors of incident rays.
// pMask - pointer to the mask vector.
// pSurfNorm - pointer to array of pointers to a separate coordinates(x,y,z)of planes
// of normals at intersections point.
// Output Arguments:
// pReflect - pointer to the array of rflected vectors.
// Returns:
// ippStsNoErr No errors
*/
IPPAPI(IppStatus,ipprCastReflectionRay_32f,(
const Ipp32f* const pInc[3],
const Ipp32s* pMask,
const Ipp32f* const pSurfNorm[3],
Ipp32f* pReflect[3],
int len ))
/* /////////////////////////////////////////////////////////////////////////////
// Surface properties ( pSurfHit, pSurfNorm, pSurfDotIn )
//////////////////////////////////////////////////////////////////////////////// */
/* /////////////////////////////////////////////////////////////////////////////
// Name:
// ipprHitPoint3DS0_32f/ipprHitPoint3DM0_32f
// Purpose:
// calculates explicit intersection coordinates in world coordinate system for a block
// of rays from single/multiple origin.
// Input Arguments:
// pDist - generalized distance from origin to intersection point.
// originEye - origin point. All rays have a single origin.
// pOrigin - pointer to array of pointers to a separate coordinates(x,y,z)of planes of the origin points.
// pDirection - pointer to array of pointers to a separate coordinates(x,y,z)of planes of the ray's directions.
// blockSize - size of rays' block.
// Output arguments:
// pSurfHit - pointer to array of pointers to a separate coordinates(x,y,z)of planes of the intersection points.
// Returns:
// ippStsNoErr No errors
*/
IPPAPI(IppStatus, ipprHitPoint3DEpsS0_32f_M,(
const IppPoint3D_32f originEye,
const Ipp32f* const pDirection[3],
const Ipp32f* pDist,
const Ipp32s* pMask,
Ipp32f* pSurfHit[3],
int len,
Ipp32f eps
))
IPPAPI(IppStatus, ipprHitPoint3DEpsM0_32f_M,(
const Ipp32f* const pOrigin[3],
const Ipp32f* const pDirection[3],
const Ipp32f* pDist,
const Ipp32s* pMask,
Ipp32f* pSurfHit[3],
int len,
Ipp32f eps
))
/* /////////////////////////////////////////////////////////////////////////////
// Names: ipprSurfTriangleNormal_32f
// Purpose: calculates the surface's normals from triangles' normals.
//
// Input Arguments:
// pTrnglNorm - pointer to the triangles' normal. Interlived
// pTrngl - pointer to triangles' indexes
// pHit - pointer to the local surface parameters( u, v )at hit point in case of intersection was found.
// blockSize - size of rays' block.
// Output Arguments:
// pSurfNorm - pointer to the surface's normals.
// sameTri ???
// Returns:
// ippStsNoErr No errors
*/
IPPAPI(IppStatus, ipprSurfFlatNormal_32f,(
const Ipp32f* pTrnglNorm,
const Ipp32s* pTrngl,
Ipp32f* pSurfNorm[3],
int len
))
IPPAPI(IppStatus, ipprSurfSmoothNormal_32f,(
const Ipp32f* pVertNorm,
const Ipp32s* pIndexNorm,
const Ipp32s* pTrngl,
const Ipp32f* const pHit[2],
Ipp32f* pSurfNorm[3], int len, IpprIndexType ippInd
))
/* /////////////////////////////////////////////////////////////////////////////
// Helper Functions
//////////////////////////////////////////////////////////////////////////////// */
/* /////////////////////////////////////////////////////////////////////////////
// Names: ipprSetBoundBox_32f
// Purpose: Calculates an axis aligned bounding box for the object.
//
// Input Arguments:
// pVertCoor - pointer to the coordinates of triangle's vertexes.
// lenTri - the number of triangles in the mesh.
// Output Arguments:
// pBound - pointer to the axis aligned bounding box of current object.
// Returns:
// ippStsNoErr No errors
*/
IPPAPI(IppStatus, ipprSetBoundBox_32f,(
const Ipp32f* pVertCoor,
int lenTri,
IppBox3D_32f* pBound
))
/* /////////////////////////////////////////////////////////////////////////////
// Names: ipprTriangleNormal_32f
// Purpose: calculates triangles' normals from object.
//
// Input Arguments:
// pTrnglCoor - pointer to the coordinates of triangle's vertexes.
// pTrnglIndex - pointer to the triangle's indexes.
// lenTri - the number of triangles in the mesh.
// Output Arguments:
// pTrnglNorm - pointer to the triangles' normals.
// Returns:
// ippStsNoErr No errors
*/
IPPAPI(IppStatus, ipprTriangleNormal_32f,(
const Ipp32f* pTrnglCoor,
const int* pTrnglIndex,
Ipp32f* pTrnglNorm,
int lenTrngl
))
/* /////////////////////////////////////////////////////////////////////////////
// 3D Geometric Transform Functions
//////////////////////////////////////////////////////////////////////////////// */
/*
// Name: ipprResizeGetBufSize
// Purpose: Computes the size of an external work buffer (in bytes)
// Parameters:
// srcVOI region of interest of source volume
// dstVOI region of interest of destination volume
// nChannel number of channels
// interpolation type of interpolation to perform for resizing the input volume:
// IPPI_INTER_NN nearest neighbor interpolation
// IPPI_INTER_LINEAR trilinear interpolation
// IPPI_INTER_CUBIC tricubic polynomial interpolation
// including two-parameter cubic filters:
// IPPI_INTER_CUBIC2P_BSPLINE B-spline filter (1, 0)
// IPPI_INTER_CUBIC2P_CATMULLROM Catmull-Rom filter (0, 1/2)
// IPPI_INTER_CUBIC2P_B05C03 special filter with parameters (1/2, 3/10)
// pSize pointer to the external buffer`s size
// Returns:
// ippStsNoErr no errors
// ippStsNullPtrErr pSize == NULL
// ippStsSizeErr width or height or depth of volumes is less or equal zero
// ippStsNumChannelsErr number of channels is not one
// ippStsInterpolationErr (interpolation != IPPI_INTER_NN) &&
// (interpolation != IPPI_INTER_LINEAR) &&
// (interpolation != IPPI_INTER_CUBIC) &&
// (interpolation != IPPI_INTER_CUBIC2P_BSPLINE) &&
// (interpolation != IPPI_INTER_CUBIC2P_CATMULLROM) &&
// (interpolation != IPPI_INTER_CUBIC2P_B05C03)
*/
IPPAPI(IppStatus, ipprResizeGetBufSize, (
IpprCuboid srcVOI, IpprCuboid dstVOI, int nChannel, int interpolation, int* pSize))
/*
// Name: ipprResize_<mode>
// Purpose: Performs RESIZE transform of the source volume
// by xFactor, yFactor, zFactor and xShift, yShift, zShift
// |X'| |xFactor 0 0 | |X| |xShift|
// |Y'| = | yFactor 0 | * |Y| + |yShift|
// |Z'| | 0 0 zFactor| |Z| |zShift|
// Parameters:
// pSrc pointer to source volume data (8u_C1V, 16u_C1V, 32f_C1V modes)
// or array of pointers to planes in source volume data
// srcVolume size of source volume
// srcStep step in every plane of source volume
// srcPlaneStep step between planes of source volume (8u_C1V, 16u_C1V, 32f_C1V modes)
// srcVOI volume of interest of source volume
// pDst pointer to destination volume data (8u_C1V and 16u_C1V modes)
// or array of pointers to planes in destination volume data
// dstStep step in every plane of destination volume
// dstPlaneStep step between planes of destination volume (8u_C1V, 16u_C1V, 32f_C1V modes)
// dstVOI volume of interest of destination volume
// xFactor they specify fraction of resizing in X direction
// yFactor they specify fraction of resizing in Y direction
// zFactor they specify fraction of resizing in Z direction
// xShift they specify shifts of resizing in X direction
// yShift they specify shifts of resizing in Y direction
// zShift they specify shifts of resizing in Z direction
// interpolation type of interpolation to perform for resizing the input volume:
// IPPI_INTER_NN nearest neighbor interpolation
// IPPI_INTER_LINEAR trilinear interpolation
// IPPI_INTER_CUBIC tricubic polynomial interpolation
// including two-parameter cubic filters:
// IPPI_INTER_CUBIC2P_BSPLINE B-spline filter (1, 0)
// IPPI_INTER_CUBIC2P_CATMULLROM Catmull-Rom filter (0, 1/2)
// IPPI_INTER_CUBIC2P_B05C03 special filter with parameters (1/2, 3/10)
// pBuffer pointer to work buffer
// Returns:
// ippStsNoErr no errors
// ippStsNullPtrErr pSrc == NULL or pDst == NULL or pBuffer == NULL
// ippStsSizeErr width or height or depth of volumes is less or equal zero
// ippStsWrongIntersectVOI VOI hasn't an intersection with the source or destination volume
// ippStsResizeFactorErr xFactor or yFactor or zFactor is less or equal zero
// ippStsInterpolationErr (interpolation != IPPI_INTER_NN) &&
// (interpolation != IPPI_INTER_LINEAR) &&
// (interpolation != IPPI_INTER_CUBIC) &&
// (interpolation != IPPI_INTER_CUBIC2P_BSPLINE) &&
// (interpolation != IPPI_INTER_CUBIC2P_CATMULLROM) &&
// (interpolation != IPPI_INTER_CUBIC2P_B05C03)
// Notes:
// <mode> are 8u_C1V or 16u_C1V or 32f_C1V or 8u_C1PV or 16u_C1PV or 32f_C1PV
*/
IPPAPI(IppStatus, ipprResize_8u_C1V, (
const Ipp8u* pSrc, IpprVolume srcVolume, int srcStep, int srcPlaneStep, IpprCuboid srcVOI,
Ipp8u* pDst, int dstStep, int dstPlaneStep, IpprCuboid dstVOI,
double xFactor, double yFactor, double zFactor, double xShift, double yShift, double zShift,
int interpolation, Ipp8u* pBuffer))
IPPAPI(IppStatus, ipprResize_16u_C1V, (
const Ipp16u* pSrc, IpprVolume srcVolume, int srcStep, int srcPlaneStep, IpprCuboid srcVOI,
Ipp16u* pDst, int dstStep, int dstPlaneStep, IpprCuboid dstVOI,
double xFactor, double yFactor, double zFactor, double xShift, double yShift, double zShift,
int interpolation, Ipp8u* pBuffer))
IPPAPI(IppStatus, ipprResize_32f_C1V, (
const Ipp32f* pSrc, IpprVolume srcVolume, int srcStep, int srcPlaneStep, IpprCuboid srcVOI,
Ipp32f* pDst, int dstStep, int dstPlaneStep, IpprCuboid dstVOI,
double xFactor, double yFactor, double zFactor, double xShift, double yShift, double zShift,
int interpolation, Ipp8u* pBuffer))
IPPAPI(IppStatus, ipprResize_8u_C1PV, (
const Ipp8u* const pSrc[], IpprVolume srcVolume, int srcStep, IpprCuboid srcVOI,
Ipp8u* const pDst[], int dstStep, IpprCuboid dstVOI,
double xFactor, double yFactor, double zFactor, double xShift, double yShift, double zShift,
int interpolation, Ipp8u* pBuffer))
IPPAPI(IppStatus, ipprResize_16u_C1PV, (
const Ipp16u* const pSrc[], IpprVolume srcVolume, int srcStep, IpprCuboid srcVOI,
Ipp16u* const pDst[], int dstStep, IpprCuboid dstVOI,
double xFactor, double yFactor, double zFactor, double xShift, double yShift, double zShift,
int interpolation, Ipp8u* pBuffer))
IPPAPI(IppStatus, ipprResize_32f_C1PV, (
const Ipp32f* const pSrc[], IpprVolume srcVolume, int srcStep, IpprCuboid srcVOI,
Ipp32f* const pDst[], int dstStep, IpprCuboid dstVOI,
double xFactor, double yFactor, double zFactor, double xShift, double yShift, double zShift,
int interpolation, Ipp8u* pBuffer))
/*
// Name: ipprWarpAffineGetBufSize
// Purpose: Computes the size of an external work buffer (in bytes)
// Parameters:
// srcVOI region of interest of source volume
// dstVOI region of interest of destination volume
// nChannel number of channels
// interpolation type of interpolation to perform for resizing the input volume:
// IPPI_INTER_NN nearest neighbor interpolation
// IPPI_INTER_LINEAR trilinear interpolation
// IPPI_INTER_CUBIC tricubic polynomial interpolation
// including two-parameter cubic filters:
// IPPI_INTER_CUBIC2P_BSPLINE B-spline filter (1, 0)
// IPPI_INTER_CUBIC2P_CATMULLROM Catmull-Rom filter (0, 1/2)
// IPPI_INTER_CUBIC2P_B05C03 special filter with parameters (1/2, 3/10)
// pSize pointer to the external buffer`s size
// Returns:
// ippStsNoErr no errors
// ippStsNullPtrErr pSize == NULL
// ippStsSizeErr size of source or destination volumes is less or equal zero
// ippStsNumChannelsErr number of channels is not one
// ippStsInterpolationErr (interpolation != IPPI_INTER_NN) &&
// (interpolation != IPPI_INTER_LINEAR) &&
// (interpolation != IPPI_INTER_CUBIC) &&
// (interpolation != IPPI_INTER_CUBIC2P_BSPLINE) &&
// (interpolation != IPPI_INTER_CUBIC2P_CATMULLROM) &&
// (interpolation != IPPI_INTER_CUBIC2P_B05C03)
*/
IPPAPI(IppStatus, ipprWarpAffineGetBufSize, (
IpprCuboid srcVOI, IpprCuboid dstVOI, int nChannel, int interpolation, int* pSize))
/*
// Names: ipprWarpAffine_<mode>
// Purpose: Performs AFFINE transform of the source volume by matrix a[3][4]
// |X'| |a00 a01 a02| |X| |a03|
// |Y'| = |a10 a11 a12| * |Y| + |a13|
// |Z'| |a20 a21 a22| |Z| |a23|
// Parameters:
// pSrc array of pointers to planes in source volume data
// srcVolume size of source volume
// srcStep step in every plane of source volume
// srcVOI volume of interest of source volume
// pDst array of pointers to planes in destination volume data
// dstStep step in every plane of destination volume
// dstVOI volume of interest of destination volume
// coeffs affine transform matrix
// interpolation type of interpolation to perform for affine transform the input volume:
// IPPI_INTER_NN nearest neighbor interpolation
// IPPI_INTER_LINEAR trilinear interpolation
// IPPI_INTER_CUBIC tricubic polynomial interpolation
// including two-parameter cubic filters:
// IPPI_INTER_CUBIC2P_BSPLINE B-spline filter (1, 0)
// IPPI_INTER_CUBIC2P_CATMULLROM Catmull-Rom filter (0, 1/2)
// IPPI_INTER_CUBIC2P_B05C03 special filter with parameters (1/2, 3/10)
// pBuffer pointer to work buffer
// Returns:
// ippStsNoErr no errors
// ippStsNullPtrErr pSrc == NULL or pDst == NULL or pBuffer == NULL
// ippStsSizeErr width or height or depth of source volume is less or equal zero
// ippStsWrongIntersectVOI VOI hasn't an intersection with the source or destination volume
// ippStsCoeffErr determinant of the transform matrix Aij is equal to zero
// ippStsInterpolationErr interpolation has an illegal value
// Notes:
// <mode> are 8u_C1PV or 16u_C1PV or 32f_C1PV
*/
IPPAPI(IppStatus, ipprWarpAffine_8u_C1PV, (
const Ipp8u* const pSrc[], IpprVolume srcVolume, int srcStep, IpprCuboid srcVOI,
Ipp8u* const pDst[], int dstStep, IpprCuboid dstVOI,
const double coeffs[3][4], int interpolation, Ipp8u* pBuffer))
IPPAPI(IppStatus, ipprWarpAffine_16u_C1PV, (
const Ipp16u* const pSrc[], IpprVolume srcVolume, int srcStep, IpprCuboid srcVOI,
Ipp16u* const pDst[], int dstStep, IpprCuboid dstVOI,
const double coeffs[3][4], int interpolation, Ipp8u* pBuffer))
IPPAPI(IppStatus, ipprWarpAffine_32f_C1PV, (
const Ipp32f* const pSrc[], IpprVolume srcVolume, int srcStep, IpprCuboid srcVOI,
Ipp32f* const pDst[], int dstStep, IpprCuboid dstVOI,
const double coeffs[3][4], int interpolation, Ipp8u* pBuffer))
/*
// Names: ipprRemap_<mode>
// Purpose: Performs REMAP TRANSFORM of the source volume by remapping
// dst[i,j,k] = src[xMap[i,j,k], yMap[i,j,k], zMap[i,j,k]]
// Parameters:
// pSrc array of pointers to planes in source volume data
// srcVolume size of source volume
// srcStep step in every plane of source volume
// srcVOI volume of interest of source volume
// pxMap array of pointers to images with X coordinates of map
// pyMap array of pointers to images with Y coordinates of map
// pzMap array of pointers to images with Z coordinates of map
// mapStep step in every plane of each map volumes
// pDst array of pointers to planes in destination volume data
// dstStep step in every plane of destination volume
// dstVolume size of destination volume
// interpolation type of interpolation to perform for resizing the input volume:
// IPPI_INTER_NN nearest neighbor interpolation
// IPPI_INTER_LINEAR trilinear interpolation
// IPPI_INTER_CUBIC tricubic polynomial interpolation
// including two-parameter cubic filters:
// IPPI_INTER_CUBIC2P_BSPLINE B-spline filter (1, 0)
// IPPI_INTER_CUBIC2P_CATMULLROM Catmull-Rom filter (0, 1/2)
// IPPI_INTER_CUBIC2P_B05C03 special filter with parameters (1/2, 3/10)
// Returns:
// ippStsNoErr no errors
// ippStsNullPtrErr pSrc == NULL or pDst == NULL or
// pxMap == NULL or pyMap == NULL or pzMap == NULL
// ippStsSizeErr width or height or depth of volumes is less or equal zero
// ippStsInterpolationErr interpolation has an illegal value
// ippStsWrongIntersectVOI srcVOI hasn't intersection with the source volume, no operation
// Notes:
// <mode> are 8u_C1PV or 16u_C1PV or 32f_C1PV
*/
IPPAPI(IppStatus, ipprRemap_8u_C1PV, (
const Ipp8u* const pSrc[], IpprVolume srcVolume, int srcStep, IpprCuboid srcVOI,
const Ipp32f* const pxMap[], const Ipp32f* const pyMap[], const Ipp32f* const pzMap[], int mapStep,
Ipp8u* const pDst[], int dstStep, IpprVolume dstVolume, int interpolation))
IPPAPI(IppStatus, ipprRemap_16u_C1PV, (
const Ipp16u* const pSrc[], IpprVolume srcVolume, int srcStep, IpprCuboid srcVOI,
const Ipp32f* const pxMap[], const Ipp32f* const pyMap[], const Ipp32f* const pzMap[], int mapStep,
Ipp16u* const pDst[], int dstStep, IpprVolume dstVolume, int interpolation))
IPPAPI(IppStatus, ipprRemap_32f_C1PV, (
const Ipp32f* const pSrc[], IpprVolume srcVolume, int srcStep, IpprCuboid srcVOI,
const Ipp32f* const pxMap[], const Ipp32f* const pyMap[], const Ipp32f* const pzMap[], int mapStep,
Ipp32f* const pDst[], int dstStep, IpprVolume dstVolume, int interpolation))
/* /////////////////////////////////////////////////////////////////////////////
// 3D General Linear Filters
//////////////////////////////////////////////////////////////////////////////// */
/*
// Name: ipprFilterGetBufSize
// Purpose: Computes the size of an external work buffer (in bytes)
// Parameters:
// dstVolume size of the volume
// kernelVolume size of the kernel volume
// nChannel number of channels
// pSize pointer to the external buffer`s size
// Returns:
// ippStsNoErr no errors
// ippStsNullPtrErr pSize == NULL
// ippStsSizeErr width or height or depth of volumes is less or equal zero
// ippStsNumChannelsErr number of channels is not one
*/
IPPAPI(IppStatus, ipprFilterGetBufSize, (
IpprVolume dstVolume, IpprVolume kernelVolume, int nChannel, int* pSize))
/*
// Name: ipprFilter_16s_C1PV
// Purpose: Filters a volume using a general integer cuboidal kernel
// Parameters:
// pSrc array of pointers to planes in source volume data
// srcStep step in every plane of source volume
// pDst array of pointers to planes in destination volume data
// dstStep step in every plane of destination volume
// dstVolume size of the processed volume
// pKernel pointer to the kernel values
// kernelVolume size of the kernel volume
// anchor anchor 3d-cell specifying the cuboidal kernel alignment
// with respect to the position of the input voxel
// divisor the integer value by which the computed result is divided
// pBuffer pointer to the external buffer`s size
// Returns:
// ippStsNoErr no errors
// ippStsNullPtrErr one of the pointers is NULL
// ippStsSizeErr width or height or depth of volumes is less or equal zero
// ippStsDivisorErr divisor value is zero, function execution is interrupted
*/
IPPAPI(IppStatus, ipprFilter_16s_C1PV, (
const Ipp16s* const pSrc[], int srcStep,
const Ipp16s* pDst[], int dstStep, IpprVolume dstVolume,
const Ipp32s* pKernel, IpprVolume kernelVolume, IpprPoint anchor, int divisor,
Ipp8u* pBuffer))
/* /////////////////////////////////////////////////////////////////////////////
// Spherical Harmonics lighting function
///////////////////////////////////////////////////////////////////////////// */
/*
// Name: ipprSHGetSize_32f
// Purpose: Acquires the size of state structure used for Spherical Harmonic computations
// Returns size of a memory buffer which is required for initialization of the state structure
// used in various algorithms related to Spherical Harmonic functions.
// Parameters:
// maxL the maximal order for Spherical Harmonic to support after initialization
// of SH structure by ipprSHInit function with given order and type
// shType the type of algorithm used for SH calculation: ippSHNormDirect or ippSHNormRecurr.
// pSize the size of memory in bytes required for this IppSHState instance to be initialized correctly
//
//
// Returns:
// ippStsNoErr Indicates no error.
// ippStsSizeErr Indicates an error when maxL is greater then 15.
// ippStsNullPtrErr Indicates an error when the pSize pointer is NULL.
// ippStsRangeErr Indicates an error when shType is not equal to ippSHNormDirect or ippSHNormRecurr.
*/
IPPAPI(IppStatus, ipprSHGetSize_32f,(Ipp32u maxL, IpprSHType shType, Ipp32u *pSize))
/*
// Name: ipprSHInit_32f
// Purpose: Initializes the state structure used for Spherical Harmonic computations
// in the buffer which must be provided of size not less than acquired by the ipprSHGetSize function.
// Parameters:
// pSHState pointer to the memory buffer used for pSHState structure initialization
// maxL the maximal order of Spherical Harmonics to support after initialization
// with using pSHState structure.
// shType the type of algorithm to use for SH calculation with using this state structure:
// ippSHNormDirect or ippSHNormRecurr.
// Returns:
// ippStsNoErr Indicates no error.
// ippStsNullPtrErr Indicates an error when the pSHState pointer is NULL.
// ippStsSizeErr Indicates an error when L is greater then 15.
// ippStsRangeErr Indicates an error when shType is not equal to ippSHNormDirect or ippSHNormRecurr.
*/
IPPAPI(IppStatus, ipprSHInit_32f,(IpprSHState *pSHState, Ipp32u maxL, IpprSHType shType))
/*
// Name: ipprSH_32f, ipprSHBand_32f
// Purpose: Compute the Spherical Harmonics
// Parameters:
// pX, pY, pZ pointers to the source vectors of length N
// which represents the points of a unit sphere given in Cartesians coordinates
// N the number of Cartesians points, i.e. the length of input vectors
// pDstYlm pointer to the destination vector to store SH values computed at given points
// for orders up to order L, of size (L+1)*(L+1)
// pDstBandYlm pointer to the destination vector to store SH values computed at given points
// for order L only, of size (2*L+1)
// L the order up to which to compute SH values,
// must not be greater then maximal order used in the function ipprSHInit call.
// pSHState pointer to the SH state structure initialized with maximal order not less then L
// Returns:
// ippStsNoErr Indicates no error.
// ippStsNullPtrErr Indicates an error when the pX, pY, pZ, pDstYlm or pDstBandYlm pointer is NULL.
// ippStsRangeErr Indicates an error when L is greater then maximal order used for SH state structure
// initialization by the function ipprSHInit.
// ippStsSizeErr Indicates an error when N is equal to zero
*/
IPPAPI(IppStatus, ipprSH_32f,(const Ipp32f *pX, const Ipp32f *pY, const Ipp32f *pZ, Ipp32u N,
Ipp32f *pDstYlm, Ipp32u L, IpprSHState *pSHState))
IPPAPI(IppStatus, ipprSHBand_32f,(const Ipp32f *pX, const Ipp32f *pY, const Ipp32f *pZ, Ipp32u N,
Ipp32f *pDstBandYlm, Ipp32u L))
/*
// Name: ipprSHTFwd_32f_C1I, ipprSHTFwd_32f_C3P3I, ipprSHTFwd_32f_P3I
// Purpose: The functions perform projecting of a given function defined on unit sphere into SH basis
// i.e. computes SH transform
// C1I: single value function (gray)
// C3I: RGB color function (x,y,z) -> (R,G,B)
// Parameters:
// pX, pY, pZ pointers to the source vectors of length N
// which represents the points of a unit sphere given in Cartesians coordinates
// pDst Pointer the input vector of values of a color function on a unit sphere
// Points to the source image for pixel-order data or
// to an array of pointers to separate source color planes for plane-order data.
// N the number of Cartesians points, i.e. the length of input vectors
// pSrcDstClm pointer to the destination vector or arrays of vectors
// storing running values of SHT coefficients. Do not forget to zero them proir to first call.
// of length (L+1)*(L+1)
// L the order up to which to compute SH transform,
// must not be greater then maximal order used in the function ipprSHInit call.
// pSHState pointer to the SH state structure initialized with maximal order not less then L
// Returns:
// ippStsNoErr Indicates no error.
// ippStsNullPtrErr Indicates an error when the pX, pY, pZ, pSrc, pSrcDstSHT or pSHState pointer is NULL.
// ippStsSizeErr Indicates an error when N is equal to zero
// ippStsRangeErr Indicates an error when L is greater then maximal order
// used in SH state structure initialization by the function ipprSHInit.
//
*/
IPPAPI(IppStatus, ipprSHTFwd_32f_C1I,(const Ipp32f *pX, const Ipp32f *pY, const Ipp32f *pZ, const Ipp32f *pSrc,
Ipp32u N, Ipp32f *pSrcDstClm, Ipp32u L, IpprSHState *pSHState))
IPPAPI(IppStatus, ipprSHTFwd_32f_C3P3I,(const Ipp32f *pX, const Ipp32f *pY, const Ipp32f *pZ, const Ipp32f *pSrc,
Ipp32u N, Ipp32f *pSrcDstClm[3], Ipp32u L, IpprSHState *pSHState))
IPPAPI(IppStatus, ipprSHTFwd_32f_P3I,(const Ipp32f *pX, const Ipp32f *pY, const Ipp32f *pZ, const Ipp32f *pSrc[3],
Ipp32u N, Ipp32f *pSrcDstClm[3], Ipp32u L, IpprSHState *pSHState))
/*
// Name: ipprSHTInv_32f_C1,ipprSHTInv_32f_P3
// Purpose: The functions reconstruct a function defined on unit sphere by its SHT coefficients
// i.e. computes ISHT transform
// C1: single value function (gray)
// C3: RGB color function (x,y,z) -> (R,G,B)
//
// Parameters:
// pSrcClm the input vector or arrays of vectors of the pre-computed SHT coefficients of the length (L+1)*(L+1)
// L the order of SHT, must not be greater then maximal order used in the ipprSHInit call.
// pX, pY, pZ pointers to the source vectors which represents the points of a unit sphere
// given in Cartesians coordinates
// pDst Pointer the output vector of values of reconstructed color function on a unit sphere
// Points to the source image for pixel-order data or
// to an array of pointers to separate source color planes for plane-order data.
// N the number of Cartesians points, i.e. the length of input pX, pY, pZ and number of dst pixels
// pSHState pointer to the SH state structure initialized with maximal order not less then L
*/
IPPAPI(IppStatus, ipprSHTInv_32f_C1,(const Ipp32f *pSrcClm, Ipp32u L, const Ipp32f *pX, const Ipp32f *pY,
const Ipp32f *pZ, Ipp32f *pDst, Ipp32u N, IpprSHState *pSHState))
IPPAPI(IppStatus, ipprSHTInv_32f_P3C3,(const Ipp32f *pSrcClm[3], Ipp32u L, const Ipp32f *pX, const Ipp32f *pY,
const Ipp32f *pZ, Ipp32f *pDst, Ipp32u N, IpprSHState *pSHState))
IPPAPI(IppStatus, ipprSHTInv_32f_P3,(const Ipp32f *pSrcClm[3], Ipp32u L, const Ipp32f *pX, const Ipp32f *pY,
const Ipp32f *pZ, Ipp32f *pDst[3], Ipp32u N, IpprSHState *pSHState))
#ifdef __cplusplus
}
#endif
#if defined (_IPP_STDCALL_CDECL)
#undef _IPP_STDCALL_CDECL
#define __stdcall __cdecl
#endif
#endif /* __IPPR_H__ */
/* ////////////////////////////// End of file /////////////////////////////// */