DataStructures.h

Go to the documentation of this file.

#pragma once
 
#include "Enums.h"
#include <vector>
 
using namespace System;
using namespace System::Collections::Generic;
 
namespace Mmind {
namespace Dl {

    public value struct MPoint
    {
        int x;
        int y;
 
        MPoint(int x, int y) : x(x), y(y) {}
 
        static MPoint operator+(MPoint p1, MPoint p2)
        {
            return MPoint(p1.x + p2.x, p1.y + p2.y);
        }
    };

    public value struct MPointF
    {
        float x;
        float y;
 
        MPointF(float x, float y) : x(x), y(y) {}
 
        static MPointF operator+(MPointF p1, MPointF p2)
        {
            return MPointF(p1.x + p2.x, p1.y + p2.y);
        }
    };

    public value struct MBlobValue
    {
        double area;
        double overallArea;
        double width;
        double height;
        double aspectRatio;
        double angle;
        double circularity;
        double centerX;
        double centerY;
        double inscribedRadius;
        double circumscribedRadius;
        double maxInscribedRectWidth;
        double maxInscribedRectHeight;
        double centroidX;
        double centroidY;
        double topLeftX;
        double topLeftY;
        double bottomRightX;
        double bottomRightY;
        double minCircumscribedRectWidth;
        double minCircumscribedRectHeight;
    };

    public value struct MBbox
    {
        float startX;
        float startY;
        float endX;
        float endY;
 
        value struct ExtraInfo
        {
            float confidence;
            int labelIndex;
            String^ labelName;
        };
 
        ExtraInfo extraInfo;
 
        MBbox(float startX, float startY, float endX, float endY, float confidence, int labelIndex, String^ labelName)
        {
            this->startX = startX;
            this->startY = startY;
            this->endX = endX;
            this->endY = endY;
            this->extraInfo.confidence = confidence;
            this->extraInfo.labelIndex = labelIndex;
            this->extraInfo.labelName = labelName;
        }
 
        property float Width { float get() { return endX - startX; } }
        property float Height { float get() { return endY - startY; } }
        property float Area { float get() { return Width * Height; } }
 
        MPointF get()
        {
            return MPointF((endX + startX) / 2, (endY + startY) / 2);
        }
    };

    public value struct MRotatedBbox
    {
        MPointF center;
        float width;
        float height;
        float angle;
 
        value struct ExtraInfo
        {
            float confidence;
            int labelIndex;
            String^ labelName;
        };
 
        ExtraInfo extraInfo;
 
        MRotatedBbox(MPointF center, float width, float height, float angle, float confidence, int labelIndex, String^ labelName)
        {
            this->center = center;
            this->width = width;
            this->height = height;
            this->angle = angle;
            this->extraInfo.confidence = confidence;
            this->extraInfo.labelIndex = labelIndex;
            this->extraInfo.labelName = labelName;
        }
 
        List<MPointF>^ ToBboxPoints()
        {
            auto points = gcnew List<MPointF>();
            float cos = (float)Math::Cos(angle);
            float sin = (float)Math::Sin(angle);
            float halfWidth = width / 2;
            float halfHeight = height / 2;
 
            // Calculate four corners
            points->Add(MPointF(center.x + halfWidth * cos - halfHeight * sin, center.y + halfWidth * sin + halfHeight * cos));
            points->Add(MPointF(center.x - halfWidth * cos - halfHeight * sin, center.y - halfWidth * sin + halfHeight * cos));
            points->Add(MPointF(center.x - halfWidth * cos + halfHeight * sin, center.y - halfWidth * sin - halfHeight * cos));
            points->Add(MPointF(center.x + halfWidth * cos + halfHeight * sin, center.y + halfWidth * sin - halfHeight * cos));
 
            return points;
        }
 
        MBbox ToBbox()
        {
            auto points = ToBboxPoints();
            float minX = Single::MaxValue, minY = Single::MaxValue;
            float maxX = Single::MinValue, maxY = Single::MinValue;
 
            for each (auto point in points)
            {
                minX = Math::Min(minX, point.x);
                minY = Math::Min(minY, point.y);
                maxX = Math::Max(maxX, point.x);
                maxY = Math::Max(maxY, point.y);
            }
 
            return MBbox(minX, minY, maxX, maxY, extraInfo.confidence, extraInfo.labelIndex, extraInfo.labelName);
        }
    };

    public value struct MContour
    {
        array<MPoint>^ outerContourPoints;
        array<array<MPoint>^>^ innerContourPoints;
        int imageWidth;
        int imageHeight;
        MBlobValue blobValue;
 
        value struct ExtraInfo
        {
            float confidence;
            int labelIndex;
            String^ labelName;
        };
 
        ExtraInfo extraInfo;
    };

    public value struct ModelEfficiencyParam
    {
        int batchSize;
        PrecisionType precisionType;
 
        ModelEfficiencyParam(int batchSize, PrecisionType precisionType)
        {
            this->batchSize = batchSize;
            this->precisionType = precisionType;
        }
 
        static bool operator==(ModelEfficiencyParam left, ModelEfficiencyParam right)
        {
            return left.batchSize == right.batchSize && left.precisionType == right.precisionType;
        }
 
        static bool operator!=(ModelEfficiencyParam left, ModelEfficiencyParam right)
        {
            return !(left == right);
        }
    };

    public ref class MMindResult
    {
    public:
        List<MRotatedBbox>^ bboxes;
        List<MContour>^ contours;
 
        MMindResult()
        {
            bboxes = gcnew List<MRotatedBbox>();
            contours = gcnew List<MContour>();
        }
    };
 
}} // namespace Mmind::Dl