image.hpp

Go to the documentation of this file.

 
#pragma once
#include "../drawing_export.hpp"
#include "drawing_2d/interpolation_mode.hpp"
#include "imaging/color_palette.hpp"
#include "imaging/encoder_parameters.hpp"
#include "imaging/frame_dimension.hpp"
#include "imaging/image_flags.hpp"
#include "imaging/image_format.hpp"
#include "imaging/pixel_format.hpp"
#include "imaging/property_item.hpp"
#include "graphics.hpp"
#include "graphics_unit.hpp"
#include "rectangle.hpp"
#include "rotate_flip_type.hpp"
#include "size.hpp"
#include "size_f.hpp"
#include <xtd/any_object>
#include <xtd/iequatable>
#include <xtd/object>
#include <xtd/string>
 
namespace xtd {
  namespace drawing {
    class bitmap;
    namespace imaging::effects {
      struct resize_effect;
      struct scale_effect;
    }
    
    class drawing_export_ image : public xtd::object, public xtd::iequatable<image> {
      struct data;
      
    public:
      image();
      image(image&&) = default;
      image(const image& image) = default;
      image& operator =(const image& image) = default;
      ~image();
      
      
      static image empty;
      
      
      const xtd::byte* alpha() const;
      
      xtd::byte* alpha();
      
      int32 flags() const noexcept;
      
      xtd::array<guid> frame_dimentions_list() const noexcept;
      
      intptr handle() const noexcept;
      
      int32 height() const noexcept;
      
      float horizontal_resolution() const noexcept;
      
      imaging::color_palette palette() const noexcept;
      void palette(const imaging::color_palette& palette) noexcept;
      
      const size_f& physical_dimension() const noexcept;
      
      imaging::pixel_format pixel_format() const noexcept;
      
      const xtd::array<int32>& property_id_list() const noexcept;
      
      const xtd::array<imaging::property_item>& property_items() const noexcept;
      
      const imaging::image_format& raw_format() const noexcept;
      
      const xtd::byte* rgb() const;
      
      xtd::byte* rgb();
 
      const drawing::size& size() const noexcept;
      
      const xtd::any_object& tag() const noexcept;
      void tag(const xtd::any_object& tag) noexcept;
      
      float vertical_resolution() const noexcept;
      
      int32 width() const noexcept;
      
      
      image clone() const;
      
      graphics create_graphics();
      
      bool equals(const object& obj) const noexcept override;
      bool equals(const image& other) const noexcept override;
 
      xtd::drawing::rectangle_f get_bounds(xtd::drawing::graphics_unit page_unit) const noexcept;
 
      xtd::drawing::imaging::encoder_parameters get_encoder_parameter_list(xtd::guid encoder) const noexcept;
      
      xtd::size get_frame_count(const xtd::drawing::imaging::frame_dimension& dimension) const;
 
      xtd::size get_hash_code() const noexcept override;
 
      xtd::drawing::imaging::property_item get_property_item(int32 propid);
 
      xtd::drawing::image get_thmbnail_image(int32 thumb_width, int32 thunb_height) noexcept;
 
      void rotate_flip(xtd::drawing::rotate_flip_type rotate_flip_type);
      
      void save(const xtd::string& filename) const;
      void save(const xtd::string& filename, const xtd::drawing::imaging::image_format& format) const;
      void save(std::ostream& stream, const xtd::drawing::imaging::image_format& format) const;
      
      
      static image from_file(const xtd::string& filename);
      
      static bitmap from_hbitmap(intptr hbitmap);
      
      static image from_stream(std::istream& stream);
      
      static bitmap from_xbm_data(const unsigned char* bits, int32 width, int32 height);
      
      static bitmap from_xpm_data(const char* const* bits);
      
      static int32 get_pixel_format_size(xtd::drawing::imaging::pixel_format pixfmt) noexcept;
      
      static bool is_alpha_pixel_format(xtd::drawing::imaging::pixel_format pixfmt) noexcept;
      
      static bool is_canonical_pixel_format(xtd::drawing::imaging::pixel_format pixfmt) noexcept;
      
      static bool is_extended_pixel_format(xtd::drawing::imaging::pixel_format pixfmt) noexcept;
 
    protected:
      friend xtd::drawing::imaging::effects::resize_effect;
      friend xtd::drawing::imaging::effects::scale_effect;
      explicit image(intptr hbitmap);
      explicit image(const xtd::string& filename);
      explicit image(const xtd::string& filename, bool use_icm);
      explicit image(std::istream& stream);
      explicit image(std::istream& stream, bool use_icm);
      image(int32 width, int32 height);
      image(int32 width, int32 height, float horizontal_resolution, float vertical_resolution);
      image(int32 width, int32 height, xtd::drawing::imaging::pixel_format format);
      image(int32 width, int32 height, int32 stride, xtd::drawing::imaging::pixel_format format, intptr scan0);
      image(const image& image, int32 width, int32 height);
      image(const image& image, const rectangle& rect);
      static image from_hicon(intptr hicon);
      drawing::color get_pixel(int32 x, int32 y) const;
      void resize(const xtd::drawing::rectangle& rect, const xtd::drawing::color& fill_color);
      void scale(const xtd::drawing::size& size, xtd::drawing::drawing_2d::interpolation_mode interpolation_mode);
      void set_pixel(int32 x, int32 y, const drawing::color& color);
      void set_pixel_format(imaging::pixel_format value);
      
    private:
      void update_properties();
      
      xtd::sptr<data> data_;
    };
  }
}