AnnotationPage.h

#pragma once
#include <list>
#include "Annotation.h"

using namespace System;
using namespace System::Text;
using namespace System::Drawing;
using namespace System::Drawing::Drawing2D;
using namespace MST::Imaging::Annotations;
using namespace System::Collections::Generic;

namespace MST
{
    namespace Imaging
    {
        namespace Annotations
        {
            public ref class AnnotationCollection : public System::Collections::IEnumerable 
            {
            public:
                AnnotationCollection()
                {
                    m_AnnList = gcnew List<MSTAnnotation^>();
                }
                
                property int AnnotationCount
                {
                    int get(){return m_AnnList->Count;}
                }

                property List<MSTAnnotation^>^ AllAnnotation
                {
                    List<MSTAnnotation^>^ get(){return m_AnnList;}
                }

                property MSTAnnotation^ Annotation[Int32]
                {
                    MSTAnnotation^ get(Int32 value)
                    {
                        if(value <= m_AnnList->Count)
                            return m_AnnList[value];
                        else
                            return nullptr;
                    } 
                }

                virtual System::Collections::IEnumerator^ GetEnumerator();
                
                void AddAnnotation(MSTAnnotation^ obj);

                void RemoveAnnotation(MSTAnnotation^ obj); 

                void RemoveAllAnnotation();
            private:
                List<MSTAnnotation^>^ m_AnnList; 
                
            };

            public delegate void ZoomChangeEvent(float fScale); 
            public ref class MSTAnnotationPage
            {
            public:
                MSTAnnotationPage(System::Windows::Forms::ScrollableControl^ parent)
                {
                    m_AnnCollection = gcnew AnnotationCollection(); 
                    m_iRotateAngle = 0;
                    m_iZoom = 100;
                    m_bHorzFlip = false;
                    m_bVertFlip = false;
                    m_Parent = parent;
                    m_Tag = nullptr;
                    m_OrientationPath = gcnew System::Drawing::Drawing2D::GraphicsPath();
                    m_OrientationPath->AddRectangle(System::Drawing::Rectangle(0,0,100,100));
                    m_ImgPath = gcnew System::Drawing::Drawing2D::GraphicsPath();
                }

                property Object^ Tag
                {
                    Object^ get(){return m_Tag;}
                    void set(Object^ value){m_Tag=value;}
                }
                property AnnotationCollection^ Annotation
                {
                    AnnotationCollection^ get(){return m_AnnCollection;} 
                }

                property System::Windows::Forms::ScrollableControl^ Parent
                {
                    System::Windows::Forms::ScrollableControl^ get()
                    {
                        return m_Parent; 
                    }
                    void set(System::Windows::Forms::ScrollableControl^ parent)
                    {
                        m_Parent = parent;
                    }
                }   

                property float Rotate
                {
                    float get(){return m_iRotateAngle;}
                    void set(float Value)
                    {
                        while(Value >= 360)Value-=360;
                        while(Value <= -360)Value+=360;
                        if(Value < 0)Value = 360 + Value;
                        if(Value==m_iRotateAngle)return;
                        System::Drawing::Drawing2D::Matrix^ matrix = gcnew System::Drawing::Drawing2D::Matrix();
                        System::Drawing::Rectangle ClientRect = m_Parent->ClientRectangle;
                        matrix->RotateAt(Value-m_iRotateAngle,PointF(ClientRect.Width/2,ClientRect.Height/2),System::Drawing::Drawing2D::MatrixOrder::Append);
                        ApplyMatrix(matrix);
                        delete matrix;
                        m_iRotateAngle = (int)Value;
                    }
                }
                property bool FlipHorizontal
                {
                    bool get(){return m_bHorzFlip;}
                    void set(bool Value)
                    {
                        if(m_bHorzFlip!=Value)
                        {
                            System::Drawing::Drawing2D::Matrix^ matrix = gcnew System::Drawing::Drawing2D::Matrix(-1, 0, 0, 1, 0, 0);
                            matrix->Translate(-m_Parent->ClientRectangle.Width,0);
                            ApplyMatrix(matrix);
                            delete matrix;
                            m_bHorzFlip = Value;
                        }
                    }
                }

                property bool FlipVertical
                {
                    bool get(){return m_bVertFlip;}
                    void set(bool Value)
                    {
                        if(m_bVertFlip!=Value)
                        {
                            System::Drawing::Drawing2D::Matrix^ matrix = gcnew System::Drawing::Drawing2D::Matrix(1, 0, 0, -1, 0, 0);
                            matrix->Translate(0,-m_Parent->ClientRectangle.Height);
                            ApplyMatrix(matrix);
                            delete matrix;
                            m_bVertFlip = Value;
                        }
                    }
                }

                property float Zoom
                {
                    float get(){return m_iZoom;}
                    void set(float Value)
                    { 
                        if(Value<10)Value=10;
                        if(Value>9999)Value=9999;
                        if(Value==m_iZoom)return;
                        float fZoom = Value/m_iZoom;
                        System::Drawing::Drawing2D::Matrix^ matrix = gcnew System::Drawing::Drawing2D::Matrix();
                        System::Drawing::Rectangle rect = m_Parent->ClientRectangle;
                        float cx = rect.Width / 2;
                        float cy = rect.Height / 2;
                        matrix->Translate(cx,cy, System::Drawing::Drawing2D::MatrixOrder::Append);
                        matrix->Scale(fZoom,fZoom,System::Drawing::Drawing2D::MatrixOrder::Append);
                        matrix->Translate(-cx*(2*fZoom-1),-cy*(2*fZoom-1), System::Drawing::Drawing2D::MatrixOrder::Append);
                        ApplyMatrix(matrix);
                        delete matrix;
                        m_iZoom = Value;
                        ZoomChangeEventHandler(m_iZoom);
                    }
                }

                property float Slope
                {
                    float get()
                    {
                        PointF pt1 = m_OrientationPath->PathPoints[0];
                        PointF pt2 = m_OrientationPath->PathPoints[1];
                        return GetSlope(pt1 ,pt2);
                    }
                }
                property PointF ReferencePoint
                {
                    PointF get()
                    {
                        array<PointF>^ ptArr = m_OrientationPath->PathPoints;
                        float minX=ptArr[0].X,minY=ptArr[0].Y,maxX=ptArr[0].X,maxY=ptArr[0].Y;
                        for(int i=1; i<ptArr->Length; i++)
                        {
                            minX = Math::Min(minX,ptArr[i].X);
                            minY = Math::Min(minY,ptArr[i].Y);
                            maxX = Math::Max(maxX,ptArr[i].X);
                            maxY = Math::Max(maxY,ptArr[i].Y);
                        }
                        return PointF(((float)(maxX+minX))/2,((float)(maxY+minY))/2);
                    }
                }
                property array<PointF>^ ImagePoints
                {
                    array<PointF>^ get()
                    {
                        return m_ImgPath->PathPoints;
                    }
                }

                MSTAnnotation^ CreateAnnotation(Annotations::Type type,Pen^ pen);   

                void Draw(Graphics^ g,System::Drawing::Image^ image,bool bAnnotationVisible);
                void DrawImage(Graphics^ g,System::Drawing::Image^ image,array<PointF>^ pts);
                void DrawString(Graphics^ g,Font^ font,Color TextColor,StringFormat^ fmt,String^ Text,array<PointF>^ pts);
                void DrawString(Graphics^ g,Font^ font,Color TextColor,String^ Text,array<PointF>^ pts);
                array<Byte>^ BurnAnnotation(System::Drawing::Image^ image);

                void ApplyMatrix(System::Drawing::Drawing2D::Matrix^ matrix);
                
                void Translate(float cx,float cy)
                {
                    if(cx==0&&cy==0)return;
                    System::Drawing::Drawing2D::Matrix^ matrix = gcnew System::Drawing::Drawing2D::Matrix();
                    matrix->Translate(cx,cy,System::Drawing::Drawing2D::MatrixOrder::Append);
                    ApplyMatrix(matrix);
                    delete matrix;
                }
                void BringImageToCenter();
                void ScaleImageToFitWindow();
                void ScaleImageToFitWindowWidth();
                void ScaleImageToFitWindowHeight();
                void SetImageDimension(float cx,float cy)
                {
                    Rotate = 0;
                    FlipHorizontal = false;
                    FlipVertical = false;
                    Zoom = 100;
                    m_ImgPath->Reset();
                    array<PointF> ^arr = gcnew array<PointF>(4);
                    PointF pt = ReferencePoint;
                    arr[0]=PointF(pt.X-cx/2,pt.Y-cy/2);
                    arr[1]=PointF(pt.X+cx/2,pt.Y-cy/2);
                    arr[2]=PointF(pt.X-cx/2,pt.Y+cy/2);
                    arr[3]=PointF(pt.X+cx/2,pt.Y+cy/2);
                    m_ImgPath->AddPolygon(arr);
                    delete arr;
                }
                void TransformPoints(array<PointF>^,bool bFromCenter);
                void TransformPoints(array<PointF>^);
                void DeTransformPoints(array<PointF>^,bool bFromCenter);
                void DeTransformPoints(array<PointF>^);
                static float GetSlope(PointF pt1 , PointF pt2);
            public:
                    event ZoomChangeEvent^ ZoomChangeEventHandler;
            private:

                Object^ m_Tag;
                int m_iRotateAngle;
                float m_iZoom;
                bool m_bHorzFlip;
                bool m_bVertFlip;
                AnnotationCollection^ m_AnnCollection;
                System::Windows::Forms::ScrollableControl^ m_Parent;
                System::Drawing::Drawing2D::GraphicsPath ^m_OrientationPath;
                System::Drawing::Drawing2D::GraphicsPath ^m_ImgPath;
            };

            
        }
    }
}