cs237-image.hpp

Go to the documentation of this file.

 
/*
 * COPYRIGHT (c) 2023 John Reppy (http://cs.uchicago.edu/~jhr)
 * All rights reserved.
 */
 
#ifndef _CS237_IMAGE_HPP_
#define _CS237_IMAGE_HPP_
 
#ifndef _CS237_HPP_
#error "cs237-image.hpp should not be included directly"
#endif
 
#include <fstream>
 
namespace cs237 {
 
enum class Channels {
    UNKNOWN,        
    R,              
    RG,             
    RGB,            
    BGR,            
    RGBA,           
    BGRA            
};
 
std::string to_string (Channels ch);
 
enum class ChannelTy {
    UNKNOWN,        
    U8,             
    S8,             
    U16,            
    S16,            
    U32,            
    S32,            
    F32             
};
 
std::string to_string (ChannelTy ty);
 
namespace __detail {
 
    vk::Format toVkFormat (Channels chans, ChannelTy ty, bool sRGB);
 
    class ImageBase {
    public:
        uint32_t nDims () const { return this->_nDims; }
        Channels channels () const { return this->_chans; }
        ChannelTy type () const { return this->_type; }
        vk::Format format () const { return toVkFormat(this->_chans, this->_type, this->_sRGB); }
        void *data () const { return this->_data; }
        size_t nBytes () const { return this->_nBytes; }
 
        unsigned int nChannels () const;
 
        size_t nBytesPerPixel () const;
 
        void addAlphaChannel ();
 
    protected:
        uint32_t _nDims;        
        Channels _chans;        
        ChannelTy _type;        
        bool _sRGB;             
        size_t _nBytes;         
        void *_data;            
 
        explicit ImageBase ()
          : _nDims(0), _chans(Channels::UNKNOWN), _type(ChannelTy::UNKNOWN), _sRGB(false),
            _nBytes(0), _data(nullptr)
        { }
        explicit ImageBase (uint32_t nd)
          : _nDims(nd), _chans(Channels::UNKNOWN), _type(ChannelTy::UNKNOWN), _sRGB(false),
            _nBytes(0), _data(nullptr)
        { }
        explicit ImageBase (uint32_t nd, Channels chans, ChannelTy ty, size_t nPixels);
 
        virtual ~ImageBase ();
 
    };
 
} /* namespace __detail */
 
/* 1D images */
class Image1D : public __detail::ImageBase {
  public:
    Image1D (uint32_t wid, Channels chans, ChannelTy ty);
 
    Image1D (std::string const &file);
 
    size_t width () const { return this->_wid; }
 
    bool write (const char *file);
 
  private:
    uint32_t _wid;      
};
 
class Image2D : public __detail::ImageBase {
  public:
    Image2D (uint32_t wid, uint32_t ht, Channels chans, ChannelTy ty);
 
    Image2D (std::string const &file, bool flip = true);
 
    Image2D (std::ifstream &inS, bool flip = true);
 
    size_t width () const { return this->_wid; }
 
    size_t height () const { return this->_ht; }
 
    bool write (const char *file, bool flip = true);
 
    bool write (std::ofstream &outS, bool flip = true);
 
    void bitblt (Image2D const &src, uint32_t row, uint32_t col);
 
  protected:
    uint32_t _wid;      
    uint32_t _ht;       
};
 
class DataImage2D : public Image2D {
  public:
    DataImage2D (uint32_t wid, uint32_t ht, Channels chans, ChannelTy ty)
      : Image2D (wid, ht, chans, ty)
    {
        this->_sRGB = false;
    }
 
    DataImage2D (std::string const &file, bool flip = true)
      : Image2D (file, flip)
    {
        this->_sRGB = false;
    }
 
    DataImage2D (std::ifstream &inS, bool flip = true)
      : Image2D (inS, flip)
    {
        this->_sRGB = false;
    }
 
};
 
} /* namespace cs237 */
 
#endif /* !_CS237_IMAGE_HPP_ */