ImageDistribution.cpp

/*
This file is part of the BIAS library (Basic ImageAlgorithmS).

Copyright (C) 2003-2009    (see file CONTACT for details)
  Multimediale Systeme der Informationsverarbeitung
  Institut fuer Informatik
  Christian-Albrechts-Universitaet Kiel


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

BIAS 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 Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License
along with BIAS; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/

#include "ImageDistribution.hh"

using namespace std;
using namespace BIAS;

void ImageDistribution::MapImagesToFixedSize(vector<Image<unsigned char> > &inputImages,
                                             Image<unsigned char> &outputImage,
                                             vector<Vector2<unsigned int> > &imagePositionsPixel)
{
 
  vector<Image<unsigned char>*> inputPtrs;
  
  for(unsigned int i=0; i<inputImages.size(); i++){
    inputPtrs.push_back(&inputImages[i]);
  }
  
  MapImagesToFixedSize(inputPtrs, 
                       outputImage, 
                       imagePositionsPixel);
  
}

void ImageDistribution::MapImagesToFixedSize(const vector<Image<unsigned char>*> &inputImages,
                                             Image<unsigned char> &outputImage,
                                             vector<Vector2<unsigned int> > &imagePositionsPixel)
{
  cout << "mapping to fixed size..." << endl;

  // init output
  outputImage.SetZero();
  imagePositionsPixel.clear();

  // assertions and early termination
  if (inputImages.size() == 0) return;

  BIASASSERT(inputImages[0]->GetWidth() > 0)
  BIASASSERT(inputImages[0]->GetHeight() > 0)
  BIASASSERT(outputImage.GetWidth() > 0)
  BIASASSERT(outputImage.GetHeight() > 0)

  // define some vars for better readability
  const unsigned int &numImages = inputImages.size();
  const unsigned int &widthIn = inputImages[0]->GetWidth();
  const unsigned int &heightIn = inputImages[0]->GetHeight();

  const unsigned int &widthOut = outputImage.GetWidth();
  const unsigned int &heightOut = outputImage.GetHeight();

  // compute grid and scale
  unsigned int numCols;
  unsigned int numRows;
  float scale;

  ComputeGridAndScale(numImages, widthIn, heightIn, widthOut, heightOut,
                      numCols, numRows, scale);

  // compute image positions
  vector<Vector2<unsigned int> > imPosGrid;
  vector<vector<int> > imageIndices;

  ComputeImagePositions(numImages, widthIn, heightIn, numRows, numCols, scale,
                        imPosGrid, imagePositionsPixel, imageIndices);

  // map the input images
  unsigned char* outputImData = outputImage.GetImageData();

  float widthInScaled = float(widthIn) * scale;
  float heightInScaled = float(heightIn) * scale;

  for (unsigned int y = 0; y < heightOut; ++y) {
    // at the bottom may be unused pixels
    if (y >= (numRows * heightInScaled)) { break; }

    // get row in which current pixel lies
    const unsigned int row = (unsigned)floor(float(y) / heightInScaled);

    for (unsigned int x = 0; x < widthOut; ++x) {
      // at the right-hand side may be unused pixels
      if (x >= (numCols * widthInScaled)) { break; }

      // get column in which current pixel lies
      const unsigned int col = (unsigned)floor(float(x) / widthInScaled);

      // now search for the image in the current row and column
      const int curImageIndex = imageIndices[col][row];

      if (curImageIndex == -1) {
        continue;
      }

      // compute the array offsets
      const unsigned int xImage = (unsigned)rint((x - col * widthInScaled) / scale);
      const unsigned int yImage = (unsigned)rint((y - row * heightInScaled) / scale);

      const unsigned int inputOffset
          = (yImage
             * inputImages[curImageIndex]->GetWidth()
             * inputImages[curImageIndex]->GetChannelCount())
            + (xImage
               * inputImages[curImageIndex]->GetChannelCount());

      const unsigned int outputOffset
          = (y
             * outputImage.GetWidth()
             * outputImage.GetChannelCount())
            + (x
               * outputImage.GetChannelCount());

      // finally map pixels
      const unsigned char* inputImData
          = inputImages[curImageIndex]->GetImageData();

      for (unsigned int c = 0; c < outputImage.GetChannelCount(); ++c) {
        outputImData[outputOffset + c] = inputImData[inputOffset + c];
      }
    }
  }
}



void ImageDistribution::MapImagesToSquare(vector<Image<unsigned char> > &inputImages,
                                          Image<unsigned char> &outputImage,
                                          vector<Vector2<unsigned int> > &imagePositionsPixel)
{
  vector<Image<unsigned char>*> inputPtrs;
  
  for(unsigned int i=0; i<inputImages.size(); i++){
    inputPtrs.push_back(&inputImages[i]);
  }
  
  MapImagesToSquare(inputPtrs, 
                    outputImage, 
                    imagePositionsPixel);
}

void ImageDistribution::MapImagesToSquare(const vector<Image<unsigned char>*> &inputImages,
                                          Image<unsigned char> &outputImage,
                                          vector<Vector2<unsigned int> > &imagePositionsPixel)
{
  cout << "mapping to square (scale is ignored)..." << endl;

  outputImage.SetZero();

  const unsigned int numImages = inputImages.size();
  const unsigned int widthIn = inputImages[0]->GetWidth();
  const unsigned int heightIn = inputImages[0]->GetHeight();

  // map to unit square and later ignore the scale factor
  const unsigned int widthOut = 1;
  const unsigned int heightOut = 1;

  // compute grid and scale
  unsigned int numCols;
  unsigned int numRows;
  float scale;

  ComputeGridAndScale(numImages, widthIn, heightIn, widthOut, heightOut,
                      numCols, numRows, scale);

  // compute image positions
  vector<Vector2<unsigned int> > imPosGrid;
  vector<Vector2<unsigned int> > imPosPixel;
  vector<vector<int> > imageIndices;

  ComputeImagePositions(numImages, widthIn, heightIn, numRows, numCols, scale,
                        imPosGrid, imPosPixel, imageIndices);

  // compute size of output image and resize it
  const unsigned int edgeLength = max(numCols * widthIn, numRows * heightIn);

  outputImage.Init(edgeLength, edgeLength, inputImages[0]->GetChannelCount());

  // map the input images
  unsigned char* outputImData = outputImage.GetImageData();

  for (size_t imageCount = 0; imageCount < numImages; ++imageCount) {
    const unsigned char* inputImData = inputImages[imageCount]->GetImageData();

    const unsigned int xOffset = imPosGrid[imageCount][0] * widthIn;
    const unsigned int yOffset = imPosGrid[imageCount][1] * heightIn;

    for (unsigned int y = 0; y < inputImages[imageCount]->GetHeight(); ++y) {
      for (unsigned int x = 0; x < inputImages[imageCount]->GetWidth(); ++x) {
        const unsigned int inputOffset
            = (y
               * inputImages[imageCount]->GetWidth()
               * inputImages[imageCount]->GetChannelCount())
              + (x
                 * inputImages[imageCount]->GetChannelCount());

        const unsigned int outputOffset
            = ((y + yOffset)
               * outputImage.GetWidth()
               * outputImage.GetChannelCount())
              + ((x + xOffset)
                 * outputImage.GetChannelCount());

        for (unsigned int c = 0; c < inputImages[imageCount]->GetChannelCount(); ++c) {
          outputImData[outputOffset + c] = inputImData[inputOffset + c];
        }
      }
    }
  }

  // recompute image positions with scale 1.0
  ComputeImagePositions(numImages, widthIn, heightIn, numRows, numCols, 1.0,
                        imPosGrid, imagePositionsPixel, imageIndices);
}


void ImageDistribution::ComputeGridAndScale(unsigned int numImages,
                                            unsigned int widthIn,
                                            unsigned int heightIn,
                                            unsigned int widthOut,
                                            unsigned int heightOut,
                                            unsigned int &numCols,
                                            unsigned int &numRows,
                                            float &scale)
{
  numCols = 0;
  numRows = 0;
  scale = 0.0;

  // using floats for the computations
  const float numImagesF = (float)numImages;
  const float widthInF = (float)widthIn;
  const float heightInF = (float)heightIn;

  const float widthOutF = (float)widthOut;
  const float heightOutF = (float)heightOut;

  // find optimal configuration with highest scaling factor
  for (float tmpNumCols = numImagesF; tmpNumCols >= 1.0; --tmpNumCols) {
    const float tmpNumRows = ceil(numImagesF / tmpNumCols);

    // minimun of horizontal or vertical scale
    const float tmpScale = min(widthOutF / (tmpNumCols * widthInF),
                               heightOutF / (tmpNumRows * heightInF));

    if (tmpScale > scale) {
      numCols = (unsigned int)tmpNumCols;
      numRows = (unsigned int)tmpNumRows;
      scale = tmpScale;
    }
  }

  cout << "taking " << numCols << "x" << numRows << " @ "
      << (scale * 100.0) << "%" << endl;
}

void ImageDistribution::ComputeImagePositions(unsigned int numImages,
                                              unsigned int widthIn,
                                              unsigned int heightIn,
                                              unsigned int numRows,
                                              unsigned int numCols,
                                              float scale,
                                              vector<Vector2<unsigned int> > &imagePositionsGrid,
                                              vector<Vector2<unsigned int> > &imagePositionsPixel,
                                              vector<vector<int> > &imageIndices)
{
  // using floats for the computations
  const float numImagesF = (float)numImages;
  const float widthInF = (float)widthIn;
  const float heightInF = (float)heightIn;

  const float numColsF = (float)numCols;

  // for each grid cell we want to know which image is to be painted inside
  imageIndices.clear();

  imageIndices.resize(numCols);
  for (unsigned int colCount = 0; colCount < numCols; ++colCount) {
    imageIndices[colCount].resize(numRows, -1);
  }

  // compute upper left corner for each image in destination area
  imagePositionsGrid.clear();
  imagePositionsGrid.reserve(size_t(numImagesF));
  imagePositionsPixel.clear();
  imagePositionsPixel.reserve(size_t(numImagesF));

  for (size_t imageCount = 0; imageCount < size_t(numImagesF); ++imageCount) {
    // compute row and column of current image
    const unsigned int row = (unsigned int)floor(float(imageCount) / numColsF);
    const unsigned int col = (unsigned int)(imageCount - (row * numColsF));

    // save grid as well as pixel position and image index
    imagePositionsGrid.push_back(Vector2<unsigned int>(col, row));
    imagePositionsPixel.push_back(Vector2<unsigned int>((unsigned)rint(col * widthInF * scale),
                                                        (unsigned)rint(row * heightInF * scale)));
    imageIndices[col][row] = imageCount;

    cout << "image " << imageCount << " is at "
        << imagePositionsGrid[imageCount][0] << "x" << imagePositionsGrid[imageCount][1]
        << " ("
        << imagePositionsPixel[imageCount][0] << "," << imagePositionsPixel[imageCount][1]
        << ")" << endl;
  }
}