IIPImage.h

// IIPImage class
 
/*  IIP fcgi server module
 
    Copyright (C) 2000-2023 Ruven Pillay.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
 
    This program 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 General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software Foundation,
    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
*/
 
 
#ifndef _IIPIMAGE_H
#define _IIPIMAGE_H
 
 
// Fix missing snprintf and vsnprintf in Windows
#if defined _MSC_VER && _MSC_VER<1900
#define snprintf _snprintf
#define vsnprintf _vsnprintf
#endif
 
 
#include <string>
#include <list>
#include <vector>
#include <map>
#include <stdexcept>
 
#include "RawTile.h"
 
 
class file_error : public std::runtime_error {
 public:
  file_error(const std::string& s) : std::runtime_error(s) { }
};
 
 
// Supported image formats
enum ImageFormat { TIF, JPEG2000, UNSUPPORTED };
 
 
// Multi-resolution pyramid type
enum PyramidType { NORMAL, SUBIFD };
 
 
// Structure for storing basic information on image stacks
// - for now just stores stack name and scaling factor
struct Stack {
  std::string name;
  float scale;
  Stack() : scale(1) {};
};
 
 
 
 
class IIPImage {
 
 private:
 
  std::string imagePath;
 
  std::string fileSystemPrefix;
 
  std::string fileSystemSuffix;
 
  std::string fileNamePattern;
 
  bool isFile;
 
  std::string suffix;
 
  void testImageType();
 
  void measureHorizontalAngles();
 
  void measureVerticalAngles();
 
 
 protected:
 
  std::list <int> horizontalAnglesList;
 
  std::list <int> verticalAnglesList;
 
  std::vector <int> lut;
 
  unsigned int virtual_levels;
 
  ImageFormat format;
 
  PyramidType pyramid;
 
  std::list <Stack> stack;
 
  std::vector <uint32_t> resolution_ids;
 
 public:
 
  std::vector <unsigned int> image_widths, image_heights;
 
  std::vector <unsigned int> tile_widths, tile_heights;
 
  ColourSpaces colourspace;
 
  float dpi_x, dpi_y;
 
 
  int dpi_units;
 
  unsigned int numResolutions;
 
  unsigned int bpc;
 
  unsigned int channels;
 
  SampleType sampleType;
 
  std::vector <float> min, max;
 
  unsigned int quality_layers;
 
  bool isSet;
 
  int currentX, currentY;
 
  std::vector<unsigned int> histogram;
 
  std::map <const std::string, std::string> metadata;
 
  time_t timestamp;
 
  static bool logging;
 
 
 public:
 
  IIPImage() :
    isFile( false ),
    virtual_levels( 0 ),
    format( UNSUPPORTED ),
    pyramid( NORMAL ),
    colourspace( NONE ),
    dpi_x( 0 ),
    dpi_y( 0 ),
    dpi_units( 0 ),
    numResolutions( 0 ),
    bpc( 0 ),
    channels( 0 ),
    sampleType( FIXEDPOINT ),
    quality_layers( 0 ),
    isSet( false ),
    currentX( 0 ),
    currentY( 90 ),
    timestamp( 0 ) {};
 
 
  IIPImage( const std::string& s ) :
    imagePath( s ),
    isFile( false ),
    virtual_levels( 0 ),
    format( UNSUPPORTED ),
    pyramid( NORMAL ),
    colourspace( NONE ),
    dpi_x( 0 ),
    dpi_y( 0 ),
    dpi_units( 0 ),
    numResolutions( 0 ),
    bpc( 0 ),
    channels( 0 ),
    sampleType( FIXEDPOINT ),
    quality_layers( 0 ),
    isSet( false ),
    currentX( 0 ),
    currentY( 90 ),
    timestamp( 0 ) {};
 
 
  IIPImage( const IIPImage& image ) :
    imagePath( image.imagePath ),
    fileSystemPrefix( image.fileSystemPrefix ),
    fileSystemSuffix( image.fileSystemSuffix ),
    fileNamePattern( image.fileNamePattern ),
    isFile( image.isFile ),
    suffix( image.suffix ),
    horizontalAnglesList( image.horizontalAnglesList ),
    verticalAnglesList( image.verticalAnglesList ),
    lut( image.lut ),
    virtual_levels( image.virtual_levels ),
    format( image.format ),
    pyramid( image.pyramid ),
    stack( image.stack ),
    resolution_ids( image.resolution_ids ),
    image_widths( image.image_widths ),
    image_heights( image.image_heights ),
    tile_widths( image.tile_widths ),
    tile_heights( image.tile_heights ),
    colourspace( image.colourspace ),
    dpi_x( image.dpi_x ),
    dpi_y( image.dpi_y ),
    dpi_units( image.dpi_units ),
    numResolutions( image.numResolutions ),
    bpc( image.bpc ),
    channels( image.channels ),
    sampleType( image.sampleType ),
    min( image.min ),
    max( image.max ),
    quality_layers( image.quality_layers ),
    isSet( image.isSet ),
    currentX( image.currentX ),
    currentY( image.currentY ),
    histogram( image.histogram ),
    metadata( image.metadata ),
    timestamp( image.timestamp ) {};
 
  virtual ~IIPImage() {};
 
  void Initialise();
 
 
  void swap( IIPImage& a, IIPImage& b );
 
  std::list <int> getVerticalViewsList() const { return verticalAnglesList; };
 
  std::list <int> getHorizontalViewsList() const { return horizontalAnglesList; };
 
  const std::string& getImagePath() const { return imagePath; };
 
 
  const std::string getFileName( int x, int y );
 
  ImageFormat getImageFormat() const { return format; };
 
 
  void updateTimestamp( const std::string& s );
 
  const std::string getTimestamp();
 
  bool set() const { return isSet; };
 
  void setFileSystemPrefix( const std::string& prefix ) { fileSystemPrefix = prefix; };
 
  void setFileSystemSuffix( const std::string& s ) { fileSystemSuffix = s; };
 
  void setFileNamePattern( const std::string& pattern ) { fileNamePattern = pattern; };
 
  unsigned int getNumResolutions() const { return numResolutions; };
 
 
  int getNativeResolution( const int res ) const { return numResolutions - res - 1; };
 
  unsigned int getNumBitsPerPixel() const { return bpc; };
 
  unsigned int getNumChannels() const { return channels; };
 
 
  float getMinValue( int n=0 ) const { return min[n]; };
 
 
  float getMaxValue( int n=0 ) const { return max[n]; };
 
  SampleType getSampleType() const { return sampleType; };
 
 
  unsigned int getImageWidth( int n=0 ) const { return image_widths[n]; };
 
 
  unsigned int getImageHeight( int n=0 ) const { return image_heights[n]; };
 
 
  unsigned int getTileWidth( int n=-1 ) const {
    if( n == -1 ) n = 0;
    else n = getNativeResolution( n );
    if( tile_widths.size() < (size_t) n+1 ) n = 0;
    return tile_widths[n];
  };
 
 
  unsigned int getTileHeight( int n=-1 ) const {
    if( n == -1 ) n = 0;
    else n = getNativeResolution( n );
    if( tile_heights.size() < (size_t) n+1 ) n = 0;
    return tile_heights[n];
  };
 
  ColourSpaces getColourSpace() const { return colourspace; };
 
  bool isStack() const {
    if( stack.size() > 0 ) return true;
    return false;
  };
 
  std::list <Stack> getStack() const { return stack; };
 
 
  const std::string& getMetadata( const std::string& index ){
    return metadata[index];
  };
 
  float getHorizontalDPI() const { return (dpi_units==2) ? dpi_x*10.0 : ( (dpi_units==1) ? dpi_x*25.4 : dpi_x ); };
 
  float getVerticalDPI() const { return (dpi_units==2) ? dpi_y*10.0 : ( (dpi_units==1) ? dpi_y*25.4 : dpi_y ); };
 
  virtual bool regionDecoding(){ return false; };
 
 
  virtual void Load( const std::string& module ) {};
 
  virtual std::string getDescription() const { return std::string( "IIPImage Base Class" ); };
 
  virtual void openImage() { throw file_error( "IIPImage openImage called" ); };
 
 
  virtual void loadImageInfo( int x, int y ) {};
 
  virtual void closeImage() {};
 
 
 
  virtual RawTile getTile( int h, int v, unsigned int r, int l, unsigned int t ) { return RawTile(); };
 
 
 
  virtual RawTile getRegion( int ha, int va, unsigned int r, int layers, int x, int y, unsigned int w, unsigned int h ){ return RawTile(); };
 
 
 
  IIPImage& operator = ( IIPImage image ){
    swap( *this, image );
    return *this;
  };
 
 
  static void setupLogging(){;};
 
 
  friend int operator == ( const IIPImage&, const IIPImage& );
 
  friend int operator != ( const IIPImage&, const IIPImage& );
 
};
 
 
#endif