otb::StreamingTraits< TImage > Class Template Reference

This class is a helper class for terminal streaming filter implementation. More...

#include <otbStreamingTraits.h>

Collaboration diagram for otb::StreamingTraits< TImage >:

[legend]

List of all members.

Public Types
typedef StreamingTraits	Self
typedef TImage	ImageType
typedef ImageType::Pointer	ImagePointerType
typedef ImageType::RegionType	RegionType
typedef ImageType::InternalPixelType	PixelType
typedef StreamingMode	StreamingModeType
typedef itk::ImageRegionSplitter < itkGetStaticConstMacro(ImageDimension)>	SplitterType
typedef itk::InterpolateImageFunction < TImage, double >	InterpolationType
typedef itk::BSplineInterpolateImageFunction < TImage, double >	BSplineInterpolationType
typedef itk::LinearInterpolateImageFunction < TImage, double >	LinearInterpolationType
typedef itk::NearestNeighborInterpolateImageFunction < TImage, double >	NearestNeighborInterpolationType
typedef WindowedSincInterpolateImageGaussianFunction < ImageType >	GaussianInterpolationType
typedef WindowedSincInterpolateImageCosineFunction < ImageType >	CosineInterpolationType
typedef WindowedSincInterpolateImageHammingFunction < ImageType >	HammingInterpolationType
typedef WindowedSincInterpolateImageWelchFunction < ImageType >	WelchInterpolationType
typedef WindowedSincInterpolateImageLanczosFunction < ImageType >	LanczosInterpolationType
typedef WindowedSincInterpolateImageBlackmanFunction < ImageType >	BlackmanInterpolationType
typedef otb::ProlateInterpolateImageFunction < ImageType >	ProlateInterpolationType
Static Public Member Functions
static unsigned long	CalculateNumberOfStreamDivisions (const TImage *image, RegionType region, SplitterType *splitter, StreamingModeType mode, unsigned long numberOfStreamDivision, unsigned long bufferMemorySize, unsigned long bufferNumberOfLinesDivisions)
static unsigned int	CalculateNeededRadiusForInterpolator (const InterpolationType *interpolator)
static std::string	GetMethodUseToCalculateNumberOfStreamDivisions (StreamingModeType mode)
Static Public Attributes
static const unsigned int	ImageDimension = ImageType::ImageDimension

---

Detailed Description

template<class TImage>
class otb::StreamingTraits< TImage >

This class is a helper class for terminal streaming filter implementation.

See also:

StreamingImageFileWriter

StreamingStatisticsImageFilter

Definition at line 60 of file otbStreamingTraits.h.

---

Member Typedef Documentation

template<class TImage>

typedef StreamingTraits otb::StreamingTraits< TImage >::Self

Standard class typedefs.

Definition at line 64 of file otbStreamingTraits.h.

---

Member Function Documentation

template<class TImage>

unsigned long otb::StreamingTraits< TImage >::CalculateNumberOfStreamDivisions	(	const TImage *	image,
		RegionType	region,
		SplitterType *	splitter,
		StreamingModeType	mode,
		unsigned long	numberOfStreamDivision,
		unsigned long	bufferMemorySize,
		unsigned long	bufferNumberOfLinesDivisions
	)			[inline, static]

This method computes the number of streaming divisions, based on the streaming mode and the image attributes. The last three parameters are ignored if the mode does not need them.

Parameters:

	image	The image to stream,
	region	the region to stream,
	splitter	the splitter used for the division,
	mode	the streaming mode,
	numberOfStreamDivision	the number of stream division if streaming mode is SET_NUMBER_OF_STREAM_DIVISIONS,
	bufferMemorySize	the buffer memory size in bytes if streaming mode is SET_BUFFER_MEMORY_SIZE,
	bufferNumberOfLinesDivisions	the buffer number of lines division if the streaming mode is SET_BUFFER_NUMBER_OF_LINES.

Returns:

The number of streaming divisions.

In tiling streaming mode, we keep the number of divisions calculed by splitter

Definition at line 36 of file otbStreamingTraits.txx.

References itk::ImageRegionSplitter< VImageDimension >::GetNumberOfSplits().

{
  unsigned long numDivisions(0);

  switch (mode)
    {
    case SET_TILING_WITH_SET_NUMBER_OF_STREAM_DIVISIONS: // Just like SET_AUTOMATIC_NUMBER_OF_STREAM_DIVISIONS
    case SET_NUMBER_OF_STREAM_DIVISIONS:
      {
      numDivisions = numberOfStreamDivision;
      }
      break;
    case SET_BUFFER_MEMORY_SIZE:
      {
      const unsigned long bufferMemorySizeOctet = bufferMemorySize / 8;
      unsigned long       numberColumnsOfRegion = region.GetSize()[0]; // X dimension
      const unsigned long sizeLine = numberColumnsOfRegion * \
                                     image->GetNumberOfComponentsPerPixel() * \
                                     sizeof(PixelType);
      unsigned long regionSize = region.GetSize()[1] * sizeLine;
      otbMsgDevMacro(<< "image->GetNumberOfComponentsPerPixel()   = " << image->GetNumberOfComponentsPerPixel());
      otbMsgDevMacro(<< "sizeof(PixelType)                        = " << sizeof(PixelType));
      otbMsgDevMacro(<< "numberColumnsOfRegion                    = " << numberColumnsOfRegion);
      otbMsgDevMacro(<< "sizeLine                                 = " << sizeLine);
      otbMsgDevMacro(<< "regionSize                               = " << regionSize);
      otbMsgDevMacro(<< "BufferMemorySize                         = " << bufferMemorySize);
      otbMsgDevMacro(<< "bufferMemorySizeOctet                    = " << bufferMemorySizeOctet);

      //Active streaming
      if (regionSize > bufferMemorySizeOctet)
        {
        //The regionSize must be at list equal to the sizeLine
        if (regionSize < sizeLine)
          {
          otbMsgDevMacro(<< "Force buffer size.");
          regionSize = sizeLine;
          }
        //Calculate NumberOfStreamDivisions
        numDivisions = static_cast<unsigned long>(
          vcl_ceil(static_cast<double>(regionSize) / static_cast<double>(bufferMemorySizeOctet))
          );
        }
      else
        {
        //Non streaming
        numDivisions = 1;
        }

      }
      break;
    case SET_BUFFER_NUMBER_OF_LINES:
      {
      if (bufferNumberOfLinesDivisions < 1)
        {
        itkGenericExceptionMacro(<< "Buffer number of lines division must be greater than 0 !");
        }
      /* Calculate number of split */
      unsigned long numberLinesOfRegion = region.GetSize()[1]; // Y dimension
      if (numberLinesOfRegion > bufferNumberOfLinesDivisions)
        {
        numDivisions =
          static_cast<unsigned long>(vcl_ceil(static_cast<double>(numberLinesOfRegion) /
                                              static_cast<double>(bufferNumberOfLinesDivisions)));
        }
      else
        {
        //Non streaming
        numDivisions = 1;
        }
      }
      break;
    case SET_TILING_WITH_SET_AUTOMATIC_NUMBER_OF_STREAM_DIVISIONS: // Just like SET_AUTOMATIC_NUMBER_OF_STREAM_DIVISIONS
    case SET_AUTOMATIC_NUMBER_OF_STREAM_DIVISIONS:
      {
      typedef otb::ConfigurationFile ConfigurationType;
      ConfigurationType::Pointer conf = ConfigurationType::GetInstance();
      std::streamoff             streamMaxSizeBufferForStreamingBytes;
      std::streamoff             streamImageSizeToActivateStreamingBytes;
      try
        {
        streamMaxSizeBufferForStreamingBytes = conf->GetParameter<std::streamoff>(
          "OTB_STREAM_MAX_SIZE_BUFFER_FOR_STREAMING");
        streamImageSizeToActivateStreamingBytes = conf->GetParameter<std::streamoff>(
          "OTB_STREAM_IMAGE_SIZE_TO_ACTIVATE_STREAMING");
        }
      catch(...)
        {
        // We should never have to go here if the configuration file is
        // correct and found. In case it is not fallback on the cmake
        // defined constants.
        streamMaxSizeBufferForStreamingBytes = OTB_STREAM_MAX_SIZE_BUFFER_FOR_STREAMING;
        streamImageSizeToActivateStreamingBytes = OTB_STREAM_IMAGE_SIZE_TO_ACTIVATE_STREAMING;
        }

      //Convert in octet unit
      std::streamoff       streamMaxSizeBufferForStreaming = streamMaxSizeBufferForStreamingBytes / 8;
      const std::streamoff streamImageSizeToActivateStreaming = streamImageSizeToActivateStreamingBytes / 8;

      std::streamoff       numberColumnsOfRegion = region.GetSize()[0]; // X dimension
      const std::streamoff sizeLine = static_cast<std::streamoff>(numberColumnsOfRegion) * \
                                      static_cast<std::streamoff>(image->GetNumberOfComponentsPerPixel()) * \
                                      static_cast<std::streamoff>(sizeof(PixelType));
      const std::streamoff regionSize = region.GetSize()[1] * sizeLine;
      otbMsgDevMacro(<< "streamImageSizeToActivateStreaming in Bytes  = " << streamImageSizeToActivateStreamingBytes);
      otbMsgDevMacro(<< "streamMaxSizeBufferForStreaming in Bytes     = " << streamMaxSizeBufferForStreamingBytes);
      otbMsgDevMacro(<< "streamImageSizeToActivateStreaming           = " << streamImageSizeToActivateStreaming);
      otbMsgDevMacro(<< "streamMaxSizeBufferForStreaming              = " << streamMaxSizeBufferForStreaming);
      otbMsgDevMacro(<< "image->GetNumberOfComponentsPerPixel()   = " << image->GetNumberOfComponentsPerPixel());
      otbMsgDevMacro(<< "sizeof(PixelType)                 = " << sizeof(PixelType));
      otbMsgDevMacro(<< "numberColumnsOfRegion                        = " << numberColumnsOfRegion);
      otbMsgDevMacro(<< "sizeLine                                     = " << sizeLine);
      otbMsgDevMacro(<< "regionSize                                   = " << regionSize);

      //Active streaming
      if (regionSize > streamImageSizeToActivateStreaming)
        {
        //On s'assure que la taille du bandeau fait au moins une ligne de l'image si pas TILING
        if ((mode != SET_TILING_WITH_SET_AUTOMATIC_NUMBER_OF_STREAM_DIVISIONS)
            && (streamMaxSizeBufferForStreaming < sizeLine))
          {
          otbMsgDevMacro(<< "Force buffer size.");
          streamMaxSizeBufferForStreaming = sizeLine;
          }
        otbMsgDevMacro(<< "Buffer size : " << streamMaxSizeBufferForStreaming);
        //Calculate NumberOfStreamDivisions
        numDivisions =
          static_cast<unsigned long>(vcl_ceil(static_cast<double>(regionSize) /
                                              static_cast<double>(streamMaxSizeBufferForStreaming)));
        }
      else
        {
        //Non streaming
        numDivisions = 1;
        }

      }
      break;
    default:
      itkGenericExceptionMacro(<< "Method use to calculate number of stream divisions is not set !");
      break;
    }
  if (numDivisions == 0) numDivisions = 1;
  otbMsgDevMacro(<< " -> Resume : method : " << mode << "\n -> Number of divisions = " << numDivisions);

  // Compute real number of splitter
  unsigned int numDivisionsFromSplitter = splitter->GetNumberOfSplits(region, numDivisions);

  if ((numDivisionsFromSplitter < numDivisions)
      || (mode == SET_TILING_WITH_SET_NUMBER_OF_STREAM_DIVISIONS)
      || (mode == SET_TILING_WITH_SET_AUTOMATIC_NUMBER_OF_STREAM_DIVISIONS)
      )
    {
    numDivisions = numDivisionsFromSplitter;
    }

  return (numDivisions);
}

---

Member Data Documentation

template<class TImage>

const unsigned int otb::StreamingTraits< TImage >::ImageDimension = ImageType::ImageDimension [static]

Dimension of input image.

Definition at line 75 of file otbStreamingTraits.h.

---

The documentation for this class was generated from the following files:

• otbStreamingTraits.h
• otbStreamingTraits.txx