Esempio n. 1
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="t"></param>
        /// <returns></returns>
        private static MatType EstimateType(Type t)
        {
            if (!t.IsValueType)
            {
                throw new ArgumentException();
            }

            // Primitive types
            TypeCode code = Type.GetTypeCode(t);

            switch (code)
            {
            case TypeCode.Byte:
                return(MatType.CV_8UC1);

            case TypeCode.SByte:
                return(MatType.CV_8SC1);

            case TypeCode.UInt16:
                return(MatType.CV_16UC1);

            case TypeCode.Int16:
            case TypeCode.Char:
                return(MatType.CV_16SC1);

            case TypeCode.UInt32:
            case TypeCode.Int32:
                return(MatType.CV_32SC1);

            case TypeCode.Single:
                return(MatType.CV_32FC1);

            case TypeCode.Double:
                return(MatType.CV_64FC1);
            }
            // OpenCV struct types
            if (t == typeof(Point))
            {
                return(MatType.CV_32SC2);
            }
            if (t == typeof(Point2f))
            {
                return(MatType.CV_32FC2);
            }
            if (t == typeof(Point2d))
            {
                return(MatType.CV_64FC2);
            }
            if (t == typeof(Point3i))
            {
                return(MatType.CV_32SC3);
            }
            if (t == typeof(Point3f))
            {
                return(MatType.CV_32FC3);
            }
            if (t == typeof(Point3d))
            {
                return(MatType.CV_32FC3);
            }
            if (t == typeof(Range))
            {
                return(MatType.CV_32SC2);
            }
            if (t == typeof(Rangef))
            {
                return(MatType.CV_32FC2);
            }
            if (t == typeof(Rect))
            {
                return(MatType.CV_32SC4);
            }
            if (t == typeof(Size))
            {
                return(MatType.CV_32SC2);
            }
            if (t == typeof(Size2f))
            {
                return(MatType.CV_32FC2);
            }

            if (t == typeof(Vec2b))
            {
                return(MatType.CV_8UC2);
            }
            if (t == typeof(Vec3b))
            {
                return(MatType.CV_8UC3);
            }
            if (t == typeof(Vec4b))
            {
                return(MatType.CV_8UC4);
            }
            if (t == typeof(Vec6b))
            {
                return(MatType.CV_8UC(6));
            }
            if (t == typeof(Vec2s))
            {
                return(MatType.CV_16SC2);
            }
            if (t == typeof(Vec3s))
            {
                return(MatType.CV_16SC3);
            }
            if (t == typeof(Vec4s))
            {
                return(MatType.CV_16SC4);
            }
            if (t == typeof(Vec6s))
            {
                return(MatType.CV_16SC(6));
            }
            if (t == typeof(Vec2w))
            {
                return(MatType.CV_16UC2);
            }
            if (t == typeof(Vec3w))
            {
                return(MatType.CV_16UC3);
            }
            if (t == typeof(Vec4w))
            {
                return(MatType.CV_16UC4);
            }
            if (t == typeof(Vec6w))
            {
                return(MatType.CV_16UC(6));
            }
            if (t == typeof(Vec2s))
            {
                return(MatType.CV_32SC2);
            }
            if (t == typeof(Vec3s))
            {
                return(MatType.CV_32SC3);
            }
            if (t == typeof(Vec4s))
            {
                return(MatType.CV_32SC4);
            }
            if (t == typeof(Vec6s))
            {
                return(MatType.CV_32SC(6));
            }
            if (t == typeof(Vec2f))
            {
                return(MatType.CV_32FC2);
            }
            if (t == typeof(Vec3f))
            {
                return(MatType.CV_32FC3);
            }
            if (t == typeof(Vec4f))
            {
                return(MatType.CV_32FC4);
            }
            if (t == typeof(Vec6f))
            {
                return(MatType.CV_32FC(6));
            }
            if (t == typeof(Vec2d))
            {
                return(MatType.CV_64FC2);
            }
            if (t == typeof(Vec3d))
            {
                return(MatType.CV_64FC3);
            }
            if (t == typeof(Vec4d))
            {
                return(MatType.CV_64FC4);
            }
            if (t == typeof(Vec6d))
            {
                return(MatType.CV_64FC(6));
            }

            throw new ArgumentException("Not supported value type for InputArray");
        }
Esempio n. 2
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="t"></param>
        /// <returns></returns>
        private static MatType EstimateType(Type t)
        {
#if NET40
            if (!t.IsValueType)
#else
            if (!t.GetTypeInfo().IsValueType)
#endif
            { throw new ArgumentException("Reference type is not supported."); }

            // Primitive types
#if false
            if (t == typeof(byte))
            {
                return(MatType.CV_8UC1);
            }
            if (t == typeof(sbyte))
            {
                return(MatType.CV_8SC1);
            }
            if (t == typeof(ushort) || t == typeof(char))
            {
                return(MatType.CV_16UC1);
            }
            if (t == typeof(short))
            {
                return(MatType.CV_16SC1);
            }
            if (t == typeof(int) || t == typeof(uint))
            {
                return(MatType.CV_32SC1);
            }
            if (t == typeof(float))
            {
                return(MatType.CV_32FC1);
            }
            if (t == typeof(double))
            {
                return(MatType.CV_64FC1);
            }
#else
            var code = System.Type.GetTypeCode(t);
            switch (code)
            {
            case TypeCode.Byte:
                return(MatType.CV_8UC1);

            case TypeCode.SByte:
                return(MatType.CV_8SC1);

            case TypeCode.UInt16:
                return(MatType.CV_16UC1);

            case TypeCode.Int16:
            case TypeCode.Char:
                return(MatType.CV_16SC1);

            case TypeCode.UInt32:
            case TypeCode.Int32:
                return(MatType.CV_32SC1);

            case TypeCode.Single:
                return(MatType.CV_32FC1);

            case TypeCode.Double:
                return(MatType.CV_64FC1);
            }
#endif

            // OpenCV struct types
            if (t == typeof(Point))
            {
                return(MatType.CV_32SC2);
            }
            if (t == typeof(Point2f))
            {
                return(MatType.CV_32FC2);
            }
            if (t == typeof(Point2d))
            {
                return(MatType.CV_64FC2);
            }
            if (t == typeof(Point3i))
            {
                return(MatType.CV_32SC3);
            }
            if (t == typeof(Point3f))
            {
                return(MatType.CV_32FC3);
            }
            if (t == typeof(Point3d))
            {
                return(MatType.CV_32FC3);
            }
            if (t == typeof(Range))
            {
                return(MatType.CV_32SC2);
            }
            if (t == typeof(Rangef))
            {
                return(MatType.CV_32FC2);
            }
            if (t == typeof(Rect))
            {
                return(MatType.CV_32SC4);
            }
            if (t == typeof(Size))
            {
                return(MatType.CV_32SC2);
            }
            if (t == typeof(Size2f))
            {
                return(MatType.CV_32FC2);
            }

            if (t == typeof(Vec2b))
            {
                return(MatType.CV_8UC2);
            }
            if (t == typeof(Vec3b))
            {
                return(MatType.CV_8UC3);
            }
            if (t == typeof(Vec4b))
            {
                return(MatType.CV_8UC4);
            }
            if (t == typeof(Vec6b))
            {
                return(MatType.CV_8UC(6));
            }
            if (t == typeof(Vec2s))
            {
                return(MatType.CV_16SC2);
            }
            if (t == typeof(Vec3s))
            {
                return(MatType.CV_16SC3);
            }
            if (t == typeof(Vec4s))
            {
                return(MatType.CV_16SC4);
            }
            if (t == typeof(Vec6s))
            {
                return(MatType.CV_16SC(6));
            }
            if (t == typeof(Vec2w))
            {
                return(MatType.CV_16UC2);
            }
            if (t == typeof(Vec3w))
            {
                return(MatType.CV_16UC3);
            }
            if (t == typeof(Vec4w))
            {
                return(MatType.CV_16UC4);
            }
            if (t == typeof(Vec6w))
            {
                return(MatType.CV_16UC(6));
            }
            if (t == typeof(Vec2i))
            {
                return(MatType.CV_32SC2);
            }
            if (t == typeof(Vec3i))
            {
                return(MatType.CV_32SC3);
            }
            if (t == typeof(Vec4i))
            {
                return(MatType.CV_32SC4);
            }
            if (t == typeof(Vec6i))
            {
                return(MatType.CV_32SC(6));
            }
            if (t == typeof(Vec2f))
            {
                return(MatType.CV_32FC2);
            }
            if (t == typeof(Vec3f))
            {
                return(MatType.CV_32FC3);
            }
            if (t == typeof(Vec4f))
            {
                return(MatType.CV_32FC4);
            }
            if (t == typeof(Vec6f))
            {
                return(MatType.CV_32FC(6));
            }
            if (t == typeof(Vec2d))
            {
                return(MatType.CV_64FC2);
            }
            if (t == typeof(Vec3d))
            {
                return(MatType.CV_64FC3);
            }
            if (t == typeof(Vec4d))
            {
                return(MatType.CV_64FC4);
            }
            if (t == typeof(Vec6d))
            {
                return(MatType.CV_64FC(6));
            }

            throw new ArgumentException("Not supported value type for InputArray");
        }
Esempio n. 3
0
        /// <summary>
        /// /
        /// </summary>
        static Mat()
        {
            typeMap = new Dictionary <Type, MatType>
            {
                [typeof(byte)]   = MatType.CV_8UC1,
                [typeof(sbyte)]  = MatType.CV_8SC1,
                [typeof(short)]  = MatType.CV_16SC1,
                [typeof(char)]   = MatType.CV_16UC1,
                [typeof(ushort)] = MatType.CV_16UC1,
                [typeof(int)]    = MatType.CV_32SC1,
                [typeof(float)]  = MatType.CV_32FC1,
                [typeof(double)] = MatType.CV_64FC1,

                [typeof(Vec2b)] = MatType.CV_8UC2,
                [typeof(Vec3b)] = MatType.CV_8UC3,
                [typeof(Vec4b)] = MatType.CV_8UC4,
                [typeof(Vec6b)] = MatType.CV_8UC(6),

                [typeof(Vec2s)] = MatType.CV_16SC2,
                [typeof(Vec3s)] = MatType.CV_16SC3,
                [typeof(Vec4s)] = MatType.CV_16SC4,
                [typeof(Vec6s)] = MatType.CV_16SC(6),

                [typeof(Vec2w)] = MatType.CV_16UC2,
                [typeof(Vec3w)] = MatType.CV_16UC3,
                [typeof(Vec4w)] = MatType.CV_16UC4,
                [typeof(Vec6w)] = MatType.CV_16UC(6),

                [typeof(Vec2i)] = MatType.CV_32SC2,
                [typeof(Vec3i)] = MatType.CV_32SC3,
                [typeof(Vec4i)] = MatType.CV_32SC4,
                [typeof(Vec6i)] = MatType.CV_32SC(6),

                [typeof(Vec2f)] = MatType.CV_32FC2,
                [typeof(Vec3f)] = MatType.CV_32FC3,
                [typeof(Vec4f)] = MatType.CV_32FC4,
                [typeof(Vec6f)] = MatType.CV_32FC(6),

                [typeof(Vec2d)] = MatType.CV_64FC2,
                [typeof(Vec3d)] = MatType.CV_64FC3,
                [typeof(Vec4d)] = MatType.CV_64FC4,
                [typeof(Vec6d)] = MatType.CV_64FC(6),

                [typeof(Point)]   = MatType.CV_32SC2,
                [typeof(Point2f)] = MatType.CV_32FC2,
                [typeof(Point2d)] = MatType.CV_64FC2,

                [typeof(Point3i)] = MatType.CV_32SC3,
                [typeof(Point3f)] = MatType.CV_32FC3,
                [typeof(Point3d)] = MatType.CV_64FC3,

                [typeof(Size)]   = MatType.CV_32SC2,
                [typeof(Size2f)] = MatType.CV_32FC2,
                [typeof(Size2d)] = MatType.CV_64FC2,

                [typeof(Rect)]   = MatType.CV_32SC4,
                [typeof(Rect2f)] = MatType.CV_32FC4,
                [typeof(Rect2d)] = MatType.CV_64FC4,

                [typeof(DMatch)] = MatType.CV_32FC4,
            };
        }