measure of common statistics indicators in the image 3d (mean, max, etc.) computed along Z axis More...

IPSDKIPLGLOBALMEASURE_API ipsdk::image::ImagePtr	ipsdk::imaproc::glbmsr::zProjectionImg (const ipsdk::image::ImageConstPtr &pInImg, const ipsdk::imaproc::attr::eProjStatType &eInProjStatType)
	wrapper function for measure of common statistics indicators in the image 3d (mean, max, etc.) computed along Z axis More...

IPSDKIPLGLOBALMEASURE_API void	ipsdk::imaproc::glbmsr::zProjectionImg (const ipsdk::image::ImageConstPtr &pInImg, const ipsdk::imaproc::attr::eProjStatType &eInProjStatType, const ipsdk::image::ImagePtr &pOutImg)
	wrapper function for measure of common statistics indicators in the image 3d (mean, max, etc.) computed along Z axis More...

Detailed Description

measure of common statistics indicators in the image 3d (mean, max, etc.) computed along Z axis

Depending on the type of indicator specified by the user, (see ipsdk::imaproc::attr::eProjStatType), values of the output image are given by one of the following formula:

for minimum: $OutImg[i]=\min \limits_t(InImg[t, i])$ , with integer, $1\leq t\leq sizeT$
for maximum: $OutImg[i]=\max \limits_t(InImg[t, i])$ , with integer, $1\leq t\leq sizeT$
for sum: $OutImg[i] = \sum_{t = 1}^{sizeT}{InImg[i, t]}$
for mean: $OutImg[i] = \frac{1}{sizeT}\sum_{t=1}^{sizeT}{InImg[i, t]}$
for variance: $OutImg[i] = \frac{1}{sizeT}\sum_{t=1}^{sizeT}{(InImg[i, t]-m)^2}$ , with $m = \frac{1}{sizeT}\sum_{t = 1}^{sizeT}{InImg[i, t]}$
for standard deviation: $OutImg[i] = \frac{1}{sizeT}\sqrt{\sum_{t=1}^{sizeT}{(InImg[i, t]-m)^2}}$ , with $m = \frac{1}{sizeT}\sum_{t = 1}^{sizeT}{InImg[i, t]}$
for median: $OutImg[i]=median_{t,1\leq t\leq sizeT}(InImg[t, i])$

with sizeZ the number of images in the image 3d

Output image must have same dimensions in x and y that images of input 3d image

Attributes description

Attribute description for algorithm :

Name	ToolTip	Default Initializer
ipsdk::imaproc::attr::InImg3d	[Input] 3d image for operation	X
ipsdk::imaproc::attr::InProjStatType	[Input] Predefined types for a statistical projection algorithm	X
ipsdk::imaproc::attr::OutImg2d	[Output] 2d image for processing operation	duplicate2dInOut (_pOutImg2d, _pInImg3d)

Global Rule description

Global rule description for algorithm :
(ipsdk::imaproc::matchSize (eMatchImageSizeType::eMIST_2d,_pInImg3d,_pOutImg2d) &&
ipsdk::imaproc::matchSize (eMatchImageSizeType::eMIST_CT,_pInImg3d,_pOutImg2d))

Example of Python code :

Example imports

import PyIPSDK

import PyIPSDK.IPSDKIPLGlobalMeasure as glbmsr

Code Example

    # opening of input images
    inImg = PyIPSDK.loadTiffImageFile(inputImgPath, PyIPSDK.eTiffDirectoryMode.eTDM_Volume)
    # computation of Z projection image
    outImg = glbmsr.zProjectionImg(inImg, PyIPSDK.eProjStatType.ePST_Mean)

Example of C++ code :

Example informations

Associated library

IPSDKIPLGlobalMeasure

Header file

#include <IPSDKIPL/IPSDKIPLGlobalMeasure/Processor/ZProjectionImg/ZProjectionImg.h>

Code Example

                    // compute minimum Z projection for input image
                    // --------------------------------------------
            ImagePtr pRetOutImgMin = glbmsr::zProjectionImg(pInImg, eProjStatType::ePST_Min);
            boost::shared_ptr<MemoryImage> pOutImgMin(boost::make_shared<MemoryImage>());
            pOutImgMin->init(*pOutputImageGeometry);
            glbmsr::zProjectionImg(pInImg, eProjStatType::ePST_Min, pOutImgMin);
            ImagePtr pOutRefImgMin = computeZProjectionMinImg<inType, outType>(pInImg);
            // compute maximum Z projection for input image
            // --------------------------------------------
            ImagePtr pRetOutImgMax = glbmsr::zProjectionImg(pInImg, eProjStatType::ePST_Max);
            boost::shared_ptr<MemoryImage> pOutImgMax(boost::make_shared<MemoryImage>());
            pOutImgMax->init(*pOutputImageGeometry);
            glbmsr::zProjectionImg(pInImg, eProjStatType::ePST_Max, pOutImgMax);
            ImagePtr pOutRefImgMax = computeZProjectionMaxImg<inType, outType>(pInImg);
            // compute sum Z projection for input image
            // --------------------------------------------
            ImagePtr pRetOutImgSum = glbmsr::zProjectionImg(pInImg, eProjStatType::ePST_Sum);
            boost::shared_ptr<MemoryImage> pOutImgSum(boost::make_shared<MemoryImage>());
            pOutImgSum->init(*pOutputImageGeometry);
            glbmsr::zProjectionImg(pInImg, eProjStatType::ePST_Sum, pOutImgSum);
            ImagePtr pOutRefImgSum = computeZProjectionSumImg<inType, outType>(pInImg);
            // compute mean Z projection for input image
            // --------------------------------------------
            ImagePtr pRetOutImgMean = glbmsr::zProjectionImg(pInImg, eProjStatType::ePST_Mean);
            boost::shared_ptr<MemoryImage> pOutImgMean(boost::make_shared<MemoryImage>());
            pOutImgMean->init(*pOutputImageGeometry);
            glbmsr::zProjectionImg(pInImg, eProjStatType::ePST_Mean, pOutImgMean);
            ImagePtr pOutRefImgMean = computeZProjectionMeanImg<inType, outType>(pInImg);
            // compute variance Z projection for input image
            // --------------------------------------------
            ImagePtr pRetOutImgVar = glbmsr::zProjectionImg(pInImg, eProjStatType::ePST_Variance);
            boost::shared_ptr<MemoryImage> pOutImgVar(boost::make_shared<MemoryImage>());
            pOutImgVar->init(*pOutputImageGeometry);
            glbmsr::zProjectionImg(pInImg, eProjStatType::ePST_Variance, pOutImgVar);
            ImagePtr pOutRefImgVar = computeZProjectionVarImg<inType, outType>(pInImg);
            // compute standard deviation Z projection for input image
            // --------------------------------------------
            ImagePtr pRetOutImgStdDev = glbmsr::zProjectionImg(pInImg, eProjStatType::ePST_StdDev);
            boost::shared_ptr<MemoryImage> pOutImgStdDev(boost::make_shared<MemoryImage>());
            pOutImgStdDev->init(*pOutputImageGeometry);
            glbmsr::zProjectionImg(pInImg, eProjStatType::ePST_StdDev, pOutImgStdDev);
            ImagePtr pOutRefImgStdDev = computeZProjectionStdDevImg<inType, outType>(pInImg);
            // compute median Z projection for input image
            // --------------------------------------------
            ImagePtr pRetOutImgMedian = glbmsr::zProjectionImg(pInImg, eProjStatType::ePST_Median);
            boost::shared_ptr<MemoryImage> pOutImgMedian(boost::make_shared<MemoryImage>());
            pOutImgMedian->init(*pOutputImageGeometry);
            glbmsr::zProjectionImg(pInImg, eProjStatType::ePST_Median, pOutImgMedian);
            ImagePtr pOutRefImgMedian = computeZProjectionMedianImg<inType, outType>(pInImg);

See also: ZProjectionImgLvl1; ZProjectionImgLvl2

Function Documentation

◆ zProjectionImg() [1/2]

IPSDKIPLGLOBALMEASURE_API ipsdk::image::ImagePtr ipsdk::imaproc::glbmsr::zProjectionImg	(	const ipsdk::image::ImageConstPtr &	pInImg,
		const ipsdk::imaproc::attr::eProjStatType &	eInProjStatType
	)

wrapper function for measure of common statistics indicators in the image 3d (mean, max, etc.) computed along Z axis

Exceptions

ipsdk::processor::IPSDKBaseProcessingException on failure

◆ zProjectionImg() [2/2]

IPSDKIPLGLOBALMEASURE_API void ipsdk::imaproc::glbmsr::zProjectionImg	(	const ipsdk::image::ImageConstPtr &	pInImg,
		const ipsdk::imaproc::attr::eProjStatType &	eInProjStatType,
		const ipsdk::image::ImagePtr &	pOutImg
	)

wrapper function for measure of common statistics indicators in the image 3d (mean, max, etc.) computed along Z axis

Exceptions

ipsdk::processor::IPSDKBaseProcessingException on failure