matrix.hpp

Go to the documentation of this file.

 
#pragma once
#include "../../drawing_export.hpp"
#include "../point.hpp"
#include "../point_f.hpp"
#include "../rectangle.hpp"
#include "../rectangle_f.hpp"
#include "matrix_order.hpp"
#include <xtd/iequatable>
#include <xtd/object>
#include <xtd/string>
#include <cstdint>
#include <ostream>
 
namespace xtd {
  namespace drawing {
    class graphics;
    
    namespace drawing_2d {
      class drawing_export_ matrix final : public object, public xtd::iequatable<matrix> {
        struct data;
        
      public:
        
        matrix();
        matrix(float m11, float m12, float m21, float m22, float dx, float dy);
        matrix(const xtd::drawing::rectangle& rect, const std::vector<xtd::drawing::point>& plgpts);
        matrix(const xtd::drawing::rectangle_f& rect, const std::vector<xtd::drawing::point_f>& plgpts);
        
        matrix(const xtd::drawing::drawing_2d::matrix& value);
        matrix& operator =(const xtd::drawing::drawing_2d::matrix& value);
        ~matrix();
        
        
        std::vector<float> elements() const;
        
        intptr handle() const noexcept;
        
        bool is_identity() const;
        
        bool is_invertible() const;
        
        float offset_x() const;
        
        float offset_y() const;
        
        
        using object::equals;
        bool equals(const xtd::drawing::drawing_2d::matrix& value) const noexcept override;
        
        void invert();
        
        void multiply(const xtd::drawing::drawing_2d::matrix& matrix);
        void multiply(const xtd::drawing::drawing_2d::matrix& matrix, xtd::drawing::drawing_2d::matrix_order order);
        
        void reset();
        
        void rotate(float angle);
        void rotate(float angle, xtd::drawing::drawing_2d::matrix_order order);
        
        void rotate_at(float angle, const xtd::drawing::point_f& point);
        void rotate_at(float angle, const xtd::drawing::point_f& point, xtd::drawing::drawing_2d::matrix_order order);
        
        void scale(float scale_x, float scale_y);
        void scale(float scale_x, float scale_y, xtd::drawing::drawing_2d::matrix_order order);
        
        void shear(float scale_x, float scale_y);
        void shear(float scale_x, float scale_y, xtd::drawing::drawing_2d::matrix_order order);
        
        void transform_points(std::vector<xtd::drawing::point>& points);
        void transform_points(std::vector<xtd::drawing::point_f>& points);
        
        void transform_vectors(std::vector<xtd::drawing::point>& points);
        void transform_vectors(std::vector<xtd::drawing::point_f>& points);
        
        void translate(float offset_x, float offset_y);
        void translate(float offset_x, float offset_y, xtd::drawing::drawing_2d::matrix_order order);
        
        void vector_transform_points(std::vector<xtd::drawing::point>& points);
        
        xtd::string to_string() const noexcept override;
        
      private:
        void init_from_rect_3points(const xtd::drawing::rectangle_f& rect, const xtd::drawing::point_f pt1, const xtd::drawing::point_f pt2, const xtd::drawing::point_f pt3);
        friend class xtd::drawing::graphics;
        explicit matrix(intptr handle);
        
        xtd::sptr<data> data_;
      };
    }
  }
}