BUG: backout rev 3db61e102740

Code/BasicFilters/otbStreamingShrinkImageFilter.cxx

@@ -17,8 +17,6 @@
 =========================================================================*/
 #include "otbStreamingShrinkImageFilter.h"
 
-//encapsulate  adaptative splitter
-#include "otbImageRegionAdaptativeSplitter.h"
 namespace otb
 {
 
@@ -26,96 +24,73 @@ unsigned int
 StreamingShrinkImageRegionSplitter
 ::GetNumberOfSplits(const RegionType& region, unsigned int requestedNumber)
 {
-  //New method
-  // Set parameters
-  this->SetImageRegion(region);
-  this->SetRequestedNumberOfSplits(requestedNumber);
-
-  // Check if we need to compute split map again
-  m_Lock.Lock();
-  if(!m_IsUpToDate)
+  unsigned int theoricalNbPixelPerTile = region.GetNumberOfPixels() / requestedNumber;
+  unsigned int theoricalTileDimension = static_cast<unsigned int> (vcl_sqrt(static_cast<double>(theoricalNbPixelPerTile)) );
+
+  // Take the previous multiple of m_TileSizeAlignment (eventually generate more splits than requested)
+  m_TileDimension = theoricalTileDimension / m_TileSizeAlignment * m_TileSizeAlignment;
+
+  // Minimal tile size is m_TileSizeAlignment * m_TileSizeAlignment
+  if (m_TileDimension < m_TileSizeAlignment)
     {
-    // Do so if we need to
-    this->EstimateSplitMap(requestedNumber);
+    otbMsgDevMacro(<< "Using the minimal tile size : " << m_TileSizeAlignment << " * " << m_TileSizeAlignment);
+    m_TileDimension = m_TileSizeAlignment;
     }
-  m_Lock.Unlock();
-  otbMsgDevMacro(<<"Stream vector size " << m_StreamVector.size() << std::endl);
-  // Return the size of the split map
-  return m_StreamVector.size();
-}
 
+  // Use the computed tile size, and generate (m_TileDimension * 1) tiles
+  const SizeType&  regionSize = region.GetSize();
+  m_SplitsPerDimension[0] = (regionSize[0] + m_TileDimension - 1) / m_TileDimension;
+  m_SplitsPerDimension[1] = regionSize[1] / m_TileSizeAlignment;
 
-StreamingShrinkImageRegionSplitter::RegionType
-StreamingShrinkImageRegionSplitter
-::GetSplit(unsigned int i, unsigned int numberOfPieces, const RegionType& region)
-{
-  // Set parameters
-  this->SetImageRegion(region);
+  if (m_SplitsPerDimension[1] == 0)
+    m_SplitsPerDimension[1] = 1;
 
-  // Check if we need to compute split map agagin
-  m_Lock.Lock();
-  if(!m_IsUpToDate)
+  unsigned int numPieces = 1;
+  for (unsigned int j = 0; j < ImageDimension; ++j)
     {
-    // Do so if we need to
-    this->EstimateSplitMap(numberOfPieces);
+    numPieces *= m_SplitsPerDimension[j];
     }
-  m_Lock.Unlock();
 
-  // Return the requested split
-  return m_StreamVector.at(i);
+  otbMsgDevMacro(<< "Tile dimension : " << m_TileDimension)
+  otbMsgDevMacro(<< "Number of splits per dimension : " << m_SplitsPerDimension[0] << " " <<  m_SplitsPerDimension[1])
+
+  return numPieces;
 }
 
-void
+StreamingShrinkImageRegionSplitter::RegionType
 StreamingShrinkImageRegionSplitter
-::EstimateSplitMap(unsigned int numberOfPieces)
+::GetSplit(unsigned int i, unsigned int numberOfPieces, const RegionType& region)
 {
-  // Clear previous split map
-  m_StreamVector.clear();
-
-  //Encapsulate adpatative splitter to get a list of streams
-  //adapted to the tiling scheme
-  typedef ImageRegionAdaptativeSplitter<2> AdaptativeSplitterType;
-  AdaptativeSplitterType::Pointer internalSplitter = AdaptativeSplitterType::New();
-
-  internalSplitter->SetTileHint(m_TileHint);
-  unsigned int nbSplits = internalSplitter->GetNumberOfSplits(m_ImageRegion,numberOfPieces);
+  RegionType splitRegion;
+  IndexType  splitIndex;
 
-  //Iterate over streams computed by the adaptative splitter
-  for (unsigned int i = 0; i < nbSplits; ++i)
+  // Compute the actual number of splits
+  unsigned int numPieces = 1;
+  for (unsigned int j = 0; j < ImageDimension; ++j)
     {
-    RegionType region;
-    IndexType  index;
-
-    region = internalSplitter->GetSplit(i,numberOfPieces,m_ImageRegion);
-    index = region.GetIndex();
-
-    const unsigned int sizeY = region.GetSize()[1] - 1;
+    numPieces *= m_SplitsPerDimension[j];
+    }
 
-    for (unsigned int j = 0; j < sizeY; ++j)
-      {
-      //Add region aligned with the shrink factor
-      if (((index[1]+j) % m_TileSizeAlignment) == 0)
-        {
-        RegionType splitRegion;
+  if (i >= numPieces)
+    {
+    itkExceptionMacro("Requested split number " << i << " but region contains only " << numPieces << " splits");
+    }
 
-        splitRegion.SetIndex(0, index[0]);
-        splitRegion.SetIndex(1, index[1]+j);
+  // Compute the split index in the streaming grid
+  splitIndex[1] = i / m_SplitsPerDimension[0];
+  splitIndex[0] = i % m_SplitsPerDimension[0];
 
-        splitRegion.SetSize(0, region.GetSize()[0]);
-        splitRegion.SetSize(1, 1);
+  // Transform the split index to the actual coordinates
+  splitRegion.SetIndex(0, region.GetIndex(0) + m_TileDimension * splitIndex[0]);
+  splitRegion.SetIndex(1, region.GetIndex(1) + m_TileSizeAlignment * splitIndex[1]);
 
-        // Handle the borders
-        splitRegion.Crop(region);
+  splitRegion.SetSize(0, m_TileDimension);
+  splitRegion.SetSize(1, 1);
 
-        //Add this split to the vector (we keep the order given by
-        //the adaptative splitter)
-        m_StreamVector.push_back(splitRegion);
-        }
+  // Handle the borders
+  splitRegion.Crop(region);
 
-      }
-    }
-  m_IsUpToDate = true;
-  return;
+  return splitRegion;
 }
 
 void

Code/BasicFilters/otbStreamingShrinkImageFilter.h

@@ -65,8 +65,6 @@ public:
   /** Region typedef support.   */
   typedef itk::ImageRegion<ImageDimension> RegionType;
 
-  typedef std::vector<RegionType> StreamVectorType;
-
   /** How many pieces can the specified region be split? A given region
    *  cannot always be divided into the requested number of pieces.  For
    *  instance, if the numberOfPieces exceeds the number of pixels along
@@ -89,42 +87,12 @@ public:
   itkSetMacro(ShrinkFactor, unsigned int);
   itkGetMacro(ShrinkFactor, unsigned int);
 
-  /** Set the TileHint parameter */
-  itkSetMacro(TileHint, SizeType);
-
-  /** Get the TileHint parameter */
-  itkGetConstReferenceMacro(TileHint, SizeType);
-
-  /** Set the ImageRegion parameter */
-  itkSetMacro(ImageRegion, RegionType);
-
-  /** Get the ImageRegion parameter */
-  itkGetConstReferenceMacro(ImageRegion, RegionType);
-
-  /** Set the requested number of splits parameter */
-  itkSetMacro(RequestedNumberOfSplits, unsigned int);
-
-  /** Get the requested number of splits parameter */
-  itkGetConstReferenceMacro(RequestedNumberOfSplits, unsigned int);
-
 protected:
-  StreamingShrinkImageRegionSplitter() : m_SplitsPerDimension(0U),
-                                         m_ShrinkFactor(10),
-                                         m_TileHint(),
-                                         m_ImageRegion(),
-                                         m_RequestedNumberOfSplits(0),
-                                         m_StreamVector(),
-                                         m_IsUpToDate(false)
-                                           {}
+  StreamingShrinkImageRegionSplitter() : m_SplitsPerDimension(0U), m_ShrinkFactor(10) {}
   virtual ~StreamingShrinkImageRegionSplitter() {}
   void PrintSelf(std::ostream& os, itk::Indent indent) const;
 
 private:
-  /** This methods actually estimate the split map using the
-  ImageRegionAdaptativeSplitter and stores it in a
-  vector */
-  void EstimateSplitMap(unsigned int numberOfPieces);
-
   StreamingShrinkImageRegionSplitter(const StreamingShrinkImageRegionSplitter &); //purposely not implemented
   void operator =(const StreamingShrinkImageRegionSplitter&); //purposely not implemented
 
@@ -132,24 +100,6 @@ private:
   unsigned int m_TileDimension;
   unsigned int m_TileSizeAlignment;
   unsigned int m_ShrinkFactor;
-
-  // This reflects the input image tiling
-  SizeType   m_TileHint;
-
-  // This contains the ImageRegion that is currently beeing split
-  RegionType m_ImageRegion;
-
-  // This contains the requested number of splits
-  unsigned int m_RequestedNumberOfSplits;
-
-  // This is a vector of all regions which will be split
-  StreamVectorType m_StreamVector;
-
-  // Is the splitter up-to-date ?
-  mutable bool m_IsUpToDate;
-
-  // Lock to ensure thread-safety
-  itk::SimpleFastMutexLock m_Lock;
 };
 
 

Code/BasicFilters/otbStreamingShrinkImageFilter.txx

@@ -40,32 +40,9 @@ template <class TImage>
 void
 StreamingShrinkStreamingManager<TImage>::PrepareStreaming( itk::DataObject * input, const RegionType &region )
 {
-
-
-
   typedef otb::StreamingShrinkImageRegionSplitter TileSplitterType;
   TileSplitterType::Pointer splitter = TileSplitterType::New();
   splitter->SetTileSizeAlignment(m_ShrinkFactor);
-
-  //Uses the TileHint from the MetaDataDictionnary to find out
-  //the tiling sheme of the input file if available.
-  typename otb::StreamingShrinkStreamingManager<TImage>::SizeType tileHint;
-
-  unsigned int tileHintX(0), tileHintY(0);
-
-  itk::ExposeMetaData<unsigned int>(input->GetMetaDataDictionary(),
-                                    MetaDataKey::TileHintX,
-                                    tileHintX);
-
-  itk::ExposeMetaData<unsigned int>(input->GetMetaDataDictionary(),
-                                    MetaDataKey::TileHintY,
-                                    tileHintY);
-
-  tileHint[0] = tileHintX;
-  tileHint[1] = tileHintY;
-
-  splitter->SetTileHint(tileHint);
-
   this->m_Splitter = splitter;
 
   unsigned long nbDivisions = this->EstimateOptimalNumberOfDivisions(input, region, 0);