image_data.H

/*
 * This file is part of the "Archon" framework.
 * (http://files3d.sourceforge.net)
 *
 * Copyright © 2006 by Kristian Spangsege and Brian Kristiansen.
 *
 * Permission to use, copy, modify, and distribute this software and
 * its documentation under the terms of the GNU General Public License is
 * hereby granted. No representations are made about the suitability of
 * this software for any purpose. It is provided "as is" without express
 * or implied warranty. See the GNU General Public License
 * (http://www.gnu.org/copyleft/gpl.html) for more details.
 *
 * The characters in this file are ISO8859-1 encoded.
 *
 * The documentation in this file is in "Doxygen" style
 * (http://www.doxygen.org).
 */

#ifndef ARCHON_UTILITIES_IMAGE_DATA_H
#define ARCHON_UTILITIES_IMAGE_DATA_H

#include <inttypes.h>

#include <cmath>
#include <vector>
#include <stdexcept>

#include <archon/math/functions.H>
#include <archon/util/memory.H>
#include <archon/util/pixel_format.H>

namespace Archon
{
  namespace Utilities
  {
    using namespace std;


    struct ImageData
    {
      struct BufferFormat
      {
        bool rightToLeft;

        bool topToBottom;

        bool verticalStrips;

        bool wordAlignStrip;

        BufferFormat(bool rightToLeft = false, bool topToBottom = false,
                     bool verticalStrips = false, bool wordAlignStrip = false):
          rightToLeft(rightToLeft), topToBottom(topToBottom),
          verticalStrips(verticalStrips), wordAlignStrip(wordAlignStrip) {}
      };


      ImageData(void *buffer, int numberOfStrips, int pixelsPerStrip,
                const PixelFormat &pixelFormat = PixelFormat(),
                const BufferFormat &bufferFormat = BufferFormat(),
                int left = 0, int bottom = 0, int width = 0, int height = 0,
                const vector<bool> &endianness = vector<bool>())
        throw(PixelFormat::UnsupportedWordTypeException,
              PixelFormat::InconsistencyException, invalid_argument);



      void queryPixelMap(double x, double y, long double *pixel,
                         int horizontalRepeat = 0, int verticalRepeat = 0) const
      {
        // Sclae to image size and align with integer coordinats
        x = x * interestWidth  - 0.5;
        y = y * interestHeight - 0.5;

        // Determine indices of upper left pixel of relevant 2x2 pixel
        // box within tiled image compound.
        long xi = static_cast<long>(floor(x));
        long yi = static_cast<long>(floor(y));

        // Fetch all four colors in the target 2x2 pixel array
        int n = numberOfChannels;
        Array<long double> c0(n), c1(n), c2(n), c3(n);
        getPixel(xi,   yi,   c0.get(), horizontalRepeat, verticalRepeat);
        getPixel(xi+1, yi,   c1.get(), horizontalRepeat, verticalRepeat);
        getPixel(xi,   yi+1, c2.get(), horizontalRepeat, verticalRepeat);
        getPixel(xi+1, yi+1, c3.get(), horizontalRepeat, verticalRepeat);

        // Get the fractional parts (intra pixel positions)
        long double xf1 = x - xi;
        long double yf1 = y - yi;
        long double xf0 = 1 - xf1;
        long double yf0 = 1 - yf1;

        // The weight w0 is determined as the area of intersection
        // between the real pixel p0 = (xi, yi) and the virtual pixel p
        // = (x, y).
        long double w0 = xf0 * yf0;
        long double w1 = xf1 * yf0;
        long double w2 = xf0 * yf1;
        long double w3 = xf1 * yf1;

        // Produce the weighted mean color
        for(int i=0; i<n; ++i)
          pixel[i] = w0 * c0[i] + w1 * c1[i] + w2 * c2[i] + w3 * c3[i];
      }


      void getPixel(long x, long y, long double *pixel,
                    int horizontalRepeat = 0, int verticalRepeat = 0) const
      {
        // Clamp when the number of repetitions is finite
        if(0 < horizontalRepeat) Math::clamp<long>(x, 0, interestWidth  * horizontalRepeat - 1);
        if(0 < verticalRepeat)   Math::clamp<long>(y, 0, interestHeight * verticalRepeat   - 1);

        // Produce propper image coordinates
        x = Math::modulo<long>(x, interestWidth);
        y = Math::modulo<long>(y, interestHeight);

        // Adjust for direction of growth
        if(rightToLeft) x = interestWidth-1  - x;
        if(topToBottom) y = interestHeight-1 - y;
        if(verticalStrips) swap(x, y);

        // Determine bit offset of pixel within buffer
        long bitOffset = principalBitOffset + x * bitsPerPixel + y * bitsPerStrip;
cerr << "ImageData::getPixel: bit offset: " << bitOffset << endl;

        // Split into word-in-buffer and bit-in-word offsets
        long wordOffset;
        bitOffset = Math::modulo<long>(bitOffset, bitsPerWord, wordOffset);

        decodePixelSequence(buffer + wordOffset * bytesPerWord, bitOffset, 1, pixel);
      }


    private:

      void decodePixelSequence(const char *data, int wordBitOffest, long n, long double *pixels) const;


      void unpackPixelSequence(const char *data, int wordBitOffest, long n, long double *pixels) const;

      template<typename T> inline void
      unpackPixelSequenceDirectInteger(const char *data, long n,
                                       long double *pixels) const;

      template<typename T> inline void
      unpackPixelSequenceDirectFloat(const char *data, long n,
                                     long double *pixels) const;

      PixelFormat::MaxInt readIntegerWord(const char *data) const
      {
        if(bytePermutation.empty()) switch(wordType)
        {
        case PixelFormat::std_char:      return *reinterpret_cast<const unsigned char       *>(data);
        case PixelFormat::std_short:     return *reinterpret_cast<const unsigned short      *>(data);
        case PixelFormat::std_int:       return *reinterpret_cast<const unsigned int        *>(data);
        case PixelFormat::std_long:      return *reinterpret_cast<const unsigned long       *>(data);
        case PixelFormat::std_max_int:   return *reinterpret_cast<const PixelFormat::MaxInt *>(data);
        default: return 0; // Never
        }

        // Handle any kind of alien endianness
        switch(wordType)
        {
        case PixelFormat::std_char:      return readWithBytePermutation< unsigned char       >(data, bytePermutation);
        case PixelFormat::std_short:     return readWithBytePermutation< unsigned short      >(data, bytePermutation);
        case PixelFormat::std_int:       return readWithBytePermutation< unsigned int        >(data, bytePermutation);
        case PixelFormat::std_long:      return readWithBytePermutation< unsigned long       >(data, bytePermutation);
        case PixelFormat::std_max_int:   return readWithBytePermutation< PixelFormat::MaxInt >(data, bytePermutation);
        default: return 0; // Never
        }
      }

      char *buffer; 
      bool rightToLeft;
      bool topToBottom;
      bool verticalStrips;
      int interestWidth;  
      int interestHeight; 



      // Quatities derived from the pixel and buffer format specifications

      PixelFormat::FormatType pixelFormatType;
      PixelFormat::WordType wordType;

      int bytesPerWord;
      int bitsPerWord;

      vector<int> bytePermutation;

      bool mostSignificantBitsFirst;

      int numberOfChannels;


      struct MemoryField
      {
        int channelIndex; 
        int bitWidth;
        PixelFormat::MaxInt bitMask;
        long double min; 
        long double max; 

        MemoryField(int channelIndex = -1, int bitWidth = 0):
          channelIndex(channelIndex), bitWidth(bitWidth),
          // Special trick to support shifts by N bits where N is the number of bits in PixelFormat::MaxInt.
          bitMask((static_cast<PixelFormat::MaxInt>(1)<<bitWidth-1<<1)-1),
          min(0), max(1) {}
      };

      vector<MemoryField> memoryFields;


      long bitsPerPixel;

      long bitsPerStrip;

      long principalBitOffset;
    };
  }
}

#endif // ARCHON_UTILITIES_IMAGE_DATA_H

---