View.h

/*
    Image View and Transform Parameters

    Copyright (C) 2003-2019 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 _VIEW_H
#define _VIEW_H


#include <cstddef>
#include <vector>

#include "Transforms.h"





class View{


 private:

  // Resolution independent x,y,w,h region viewport
  float view_left, view_top, view_width, view_height; 

  int resolution;                             
  unsigned int max_resolutions;               
  unsigned int width, height;                 
  unsigned int res_width, res_height;         
  unsigned int min_size;                      
  unsigned int max_size;                      
  unsigned int requested_width;               
  unsigned int requested_height;              
  float rotation;                             



  void calculateResolution( unsigned int m, unsigned int r );


 public:

  int xangle;                                 
  int yangle;                                 
  bool shaded;                                
  int shade[3];                               
  bool cmapped;                               
  enum cmap_type cmap;                        
  bool inverted;                              
  int max_layers;                             
  int layers;                                 
  ColourSpaces colourspace;                   
  std::vector< std::vector<float> > ctw;      
  int flip;                                   
  bool maintain_aspect;                       
  bool allow_upscaling;                       
  bool embed_icc;                             
  CompressionType output_format;              
  float contrast;                             
  float gamma;                                
  bool equalization;                          


  View() {
    view_left = 0.0; view_top = 0.0; view_width = 1.0; view_height = 1.0;
    resolution = 0; max_resolutions = 0;
    width = 0; height = 0;
    res_width = 0; res_height = 0;
    min_size = 1; max_size = 0;
    requested_width = 0; requested_height = 0;
    contrast = 1.0; gamma = 1.0;
    xangle = 0; yangle = 90;
    shaded = false; shade[0] = 0; shade[1] = 0; shade[2] = 0;
    cmapped = false; cmap = HOT; inverted = false;
    max_layers = 0; layers = 0;
    rotation = 0.0; flip = 0;
    maintain_aspect = true;
    allow_upscaling = true;
    colourspace = NONE;
    embed_icc = true;
    output_format = JPEG;
    equalization = false;
  };



  void setMaxSize( unsigned int m ){ max_size = m; };


  /* @return maximum output dimension */
  unsigned int getMaxSize(){ return max_size; };
  


  void setAllowUpscaling( bool upscale ){ allow_upscaling = upscale; };


  /* @return true or false */
  bool allowUpscaling(){ return allow_upscaling; };



  void setEmbedICC( bool embed ){ embed_icc = embed; };



  bool embedICC(){
    // Disable if colour-mapping, twist, hill-shading or greyscale conversion applied
    if( cmapped || shaded || ctw.size() || colourspace==GREYSCALE ) return false;
    return embed_icc;
  };



  void setMaxResolutions( unsigned int r ){ max_resolutions = r; resolution=r-1; };


  /* @return requested width */
  unsigned int getRequestWidth();



  void setRequestWidth( unsigned int w ){
    requested_width = w;
  };


  /* @return requested height */
  unsigned int getRequestHeight();



  void setRequestHeight( unsigned int h ){
    requested_height = h;
  };


  /* @return requested resolution level */
  unsigned int getResolution();


  /* @return scaling factor */
  float getScale();



  void setViewLeft( float x );



  void setViewTop( float y );



  void setViewWidth( float w );



  void setViewHeight( float h );



  void setImageSize( unsigned int w, unsigned int h ){ width = w; height = h; };



  void setMaxLayers( int l ){ max_layers = l; };


  void setLayers( int l ){ layers = l; };

  int getLayers();

  /* @return image width */
  unsigned int getImageWidth(){ return width; };

  /* @return image height */
  unsigned int getImageHeight(){ return height; };

  /* @return position of left of viewport in pixels */
  unsigned int getViewLeft() ;

  /* @return position of top of viewport in pixels */
  unsigned int getViewTop();

  /* @return width of viewport in pixels */
  unsigned int getViewWidth();

  /* @return height of viewport in pixels */
  unsigned int getViewHeight();

  /* @return boolean indicating whether viewport specified */
  bool viewPortSet();


  void setRotation( float r ){ rotation = r; };

  /* @return requested rotation angle in degrees */
  float getRotation(){ return rotation; };

  bool floatProcessing(){
    if( contrast != 1.0 || gamma != 1.0 || cmapped || shaded || inverted || ctw.size() ){
      return true;
    }
    else return false;
  }

  bool requireHistogram(){
    if( equalization || colourspace==BINARY || contrast==-1 ) return true;
    else return false;
  }

};


#endif