image.h

Go to the documentation of this file.

#pragma once
#include <any>
#include <cstdint>
#include <map>
#include <memory>
#include <iostream>
#include <xtd/object.h>
#include <xtd/ustring.h>
#include "../drawing_export.h"
#include "imaging/color_palette.h"
#include "imaging/encoder_parameters.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 "graphics_unit.h"
#include "rectangle.h"
#include "rotate_flip_type.h"
#include "size.h"
#include "size_f.h"

namespace xtd {
  namespace drawing {
    class bitmap;
    
    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;
      bool operator !=(const image& image) const;
      
      
      static image empty;
      
      
      int32_t flags() const;
      
      std::vector<guid> frame_dimentions_list() const;
      
      intptr_t handle() const;
      
      int32_t height() const;
      
      float horizontal_resolution() const;
      
      imaging::color_palette palette() const;
      void palette(const imaging::color_palette& palette);
      
      const size_f& physical_dimension() const;
      
      imaging::pixel_format pixel_format() const;
      
      const std::vector<int32_t>& property_id_list() const;
      
      const std::vector<imaging::property_item>& property_items() const;
      
      const imaging::image_format& raw_format() const;
      
      const drawing::size& size() const;
      
      const std::any& tag() const;
      void tag(const std::any& tag);
      
      float vertical_resolution() const;
      
      int32_t width() const;
      
      
      
      graphics create_graphics() {return graphics::from_image(*this);}
      
      static image from_file(const xtd::ustring& filename) {return image(filename);}
      
      static bitmap from_hbitmap(intptr_t hbitmap);
      
      static image from_stream(std::istream& stream);
      
      static image from_data(const char* const* bits);
      
      xtd::drawing::rectangle_f get_bounds(xtd::drawing::graphics_unit page_unit) const;
      
      xtd::drawing::imaging::encoder_parameters get_encoder_parameter_list(xtd::guid encoder) const;
      
      size_t get_frame_count(const xtd::drawing::imaging::frame_dimension& dimension) const;
      
      static int32_t get_pixel_format_size(xtd::drawing::imaging::pixel_format pixfmt);
      
      xtd::drawing::imaging::property_item get_property_item(int32_t propid);
      
      xtd::drawing::image get_thmbnail_image(int32_t thumb_width, int32_t thunb_height);
      
      static bool is_alpha_pixel_format(xtd::drawing::imaging::pixel_format pixfmt);
      
      static bool is_canonical_pixel_format(xtd::drawing::imaging::pixel_format pixfmt);
      
      static bool is_extended_pixel_format(xtd::drawing::imaging::pixel_format pixfmt);
      
      void rotate_flip(xtd::drawing::rotate_flip_type rotate_flip_type);
      
      void save(const xtd::ustring& filename) const;
      void save(const xtd::ustring& filename, const xtd::drawing::imaging::image_format& format) const;
      void save(std::ostream& stream, const xtd::drawing::imaging::image_format& format) const;
      
    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);
      
    private:
      void update_properties();
      
      struct data {
        imaging::image_flags flags_ = imaging::image_flags::none;
        std::map<xtd::guid, size_t> frame_dimensions = {{xtd::drawing::imaging::frame_dimension::page().guid(), 1}};
        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_items_;
        imaging::image_format raw_format_;
        drawing::size size_;
        std::any tag_;
        float vertical_resolution_ = .0f;
        xtd::drawing::imaging::encoder_parameters encoder_parameter_list_;
      };
      std::shared_ptr<data> data_ = std::make_shared<data>();
    };
  }
}