View.h

/*
    Image View and Transform Parameters
 
    Copyright (C) 2003-2025 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 in range 0 -> 1.0
  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;                      
  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;                                 
  ColorSpace colorspace;                      
  std::vector< std::vector<float> > ctw;      
  int flip;                                   
  bool maintain_aspect;                       
  bool allow_upscaling;                       
  int max_icc;                                
  ImageEncoding output_format;                
  float contrast;                             
  float gamma;                                
  std::vector<float> convolution;             
  bool equalization;                          
  bool minmax;                                
 
 
  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;
    colorspace = ColorSpace::NONE;
    max_icc = -1;
    output_format = ImageEncoding::JPEG;
    equalization = false;
    minmax = false;
  };
 
 
 
  void setMaxSize( int m ){ max_size = m; };
 
 
 
  int getMaxSize(){ return max_size; };
 
 
 
  unsigned int getMinSize(){ return min_size; };
 
 
 
  void setAllowUpscaling( bool upscale ){ allow_upscaling = upscale; };
 
 
 
  bool allowUpscaling(){ return allow_upscaling; };
 
 
 
  void setMaxICC( int max ){ max_icc = max; };
 
 
 
  int maxICC(){
    // Disable if colour-mapping, twist, hill-shading or greyscale conversion applied
    if( cmapped || shaded || ctw.size() || colorspace==ColorSpace::GREYSCALE ) return 0;
    return max_icc;
  }
 
 
 
  void setMaxResolutions( unsigned int r ){ max_resolutions = r; resolution=r-1; };
 
 
 
  void setRequestWidth( unsigned int w ){
    requested_width = w;
  };
 
 
 
  std::vector<unsigned int> getRequestSize();
 
 
 
  void setRequestHeight( unsigned int h ){
    requested_height = h;
  };
 
 
 
  unsigned int getResolution();
 
 
 
  float getScale();
 
 
 
  void setViewLeft( float x );
 
 
 
  void setViewTop( float y );
 
 
 
  void setViewWidth( float w );
 
 
 
  void setViewHeight( float h );
 
 
 
  std::vector<float> getViewSize(){
    std::vector<float> size = { width*view_width, height*view_height };
    return size;
  };
 
 
 
  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();
 
 
  unsigned int getImageWidth(){ return width; };
 
 
  unsigned int getImageHeight(){ return height; };
 
 
  unsigned int getViewLeft() ;
 
 
  unsigned int getViewTop();
 
 
  unsigned int getViewWidth();
 
 
  unsigned int getViewHeight();
 
 
  bool viewPortSet();
 
 
  void setRotation( float r ){ rotation = r; };
 
 
  float getRotation(){ return rotation; };
 
  bool floatProcessing(){
    if( contrast != 1.0 || gamma != 1.0 || cmapped || shaded || inverted || minmax || ctw.size() || convolution.size() ){
      return true;
    }
    else return false;
  }
 
  bool requireHistogram(){
    if( equalization || colorspace==ColorSpace::BINARY || contrast==-1 ) return true;
    else return false;
  }
 
};
 
 
#endif