image.h

Go to the documentation of this file.

#pragma once
#include <any>
#include <cstdint>
#include <memory>
#include <iostream>
#include <xtd/object.h>
#include <xtd/ustring.h>
#include "../drawing_export.h"
#include "imaging/color_palette.h"
#include "imaging/frame_dimension.h"
#include "imaging/image_flags.h"
#include "imaging/image_format.h"
#include "imaging/pixel_format.h"
#include "imaging/property_item.h"
#include "graphics.h"
#include "rectangle.h"
#include "size.h"
#include "size_f.h"
 
namespace xtd {
  namespace drawing {
    class drawing_export_ image : public object {
    public:
      image() = default;
      image(const image& image) = default;
      image& operator=(const image& image) = default;
      ~image();
      bool operator==(const image& image) const {return data_->handle_ == image.data_->handle_;}
      bool operator!=(const image& image) const {return !operator==(image);}
      
      int32_t flags() const {return static_cast<int32_t>(data_->flags_);}
      
      const std::vector<guid>& frame_dimentions_list() const {return data_->frame_dimentions_list_;}
      
      intptr_t handle() const {return data_->handle_;}
      
      int32_t height() const {return data_->size_.height();}
      
      float horizontal_resolution() const {return data_->horizontal_resolution_;}
      
      imaging::color_palette palette() const {return data_->palette_;}
      void palette(const imaging::color_palette& palette) {data_->palette_ = palette;}
 
      const size_f& physical_dimension() const {return data_->physical_dimension_;}
      
      imaging::pixel_format pixel_format() const {return data_->pixel_format_;}
      
      const std::vector<int32_t>& property_id_list() const {return data_->property_id_list_;}
      
      const std::vector<imaging::property_item>& property_items() const {return data_->property_ityems_;}
      
      const imaging::image_format& raw_format() const {return data_->raw_format_;}
      
      const drawing::size& size() const {return data_->size_;}
      
      const std::any& tag() const {return data_->tag_;}
      void tag(const std::any& tag) {data_->tag_ = tag;}
      
      float vertical_resolution() const {return data_->vertical_resolution_;}
 
      int32_t width() const {return data_->size_.width();}
  
      graphics create_graphics() {return graphics::from_image(*this);}
 
      static image from_hbitmap(intptr_t hbitmap) {return image(hbitmap);}
 
      static image from_file(const xtd::ustring& filename) {return image(filename);}
 
      static image from_stream(std::istream& stream) {return image(stream);}
 
      static image from_data(const char* const* bits) {return image(bits);}
      
      void save(const xtd::ustring& filename) const;
      void save(const xtd::ustring& filename, const imaging::image_format& format) const;
      void save(std::ostream& stream, const imaging::image_format& format) const;
 
      static image empty;
      
    protected:
      explicit image(intptr_t hbitmap);
      explicit image(const xtd::ustring& fileName);
      explicit image(std::istream& stream);
      explicit image(const char* const* bits);
      image(int32_t width, int32_t height);
      image(const image& image, int32_t width, int32_t height);
      image(const image& image, const rectangle& rect);
      void update_properties();
 
      struct data {
        imaging::image_flags flags_ = imaging::image_flags::none;
        std::vector<guid> frame_dimentions_list_;
        intptr_t handle_ = 0;
        float horizontal_resolution_ = .0f;
        imaging::color_palette palette_;
        imaging::pixel_format pixel_format_ = imaging::pixel_format::undefined;
        size_f physical_dimension_;
        std::vector<int32_t> property_id_list_;
        std::vector<imaging::property_item> property_ityems_;
        imaging::image_format raw_format_;
        drawing::size size_;
        std::any tag_;
        float vertical_resolution_ = .0f;
      };
      std::shared_ptr<data> data_ = std::make_shared<data>();
    };
  }
}