public static void merge(List <Mat> src, Mat dst)
        {
            if (src == null || src.Count == 0)
            {
                return;
            }

            if (!src[0].Valid || src[0].IsEmpty)
            {
                return;
            }

            if (!dst.Valid)
            {
                return;
            }

            int rows = src[0].Rows, cols = src[0].Cols;

            int dstChannels = src[0].Channels;
            int n           = src.Count;   // src[i] may have more than 1 channel
            var srcPtrs     = new IntPtr[n];

            srcPtrs[0] = src[0].MatObj;

            for (int i = 1; i < n; i++)             // check valid, size, and sumation over channel
            {
                if (src[i].Valid && src[i].Rows == rows && src[i].Cols == cols)
                {
                    dstChannels += src[i].Channels;
                    srcPtrs[i]   = src[i].MatObj;
                }
                else
                {
                    return;
                }
            }

            if (dstChannels > Mat.CV_CN_MAX)             // exceed max channels support
            {
                return;
            }

            var srcPtrMat = new Mat(1, n * Marshal.SizeOf <IntPtr>(), Mat.makeType(1, Mat.MatDepth.CV_8U));

            if (!srcPtrMat.Valid)             // alloc unmanaged memory
            {
                return;
            }
            Marshal.Copy(srcPtrs, 0, srcPtrMat.Data, n);
            NativeInvoker.coreCvMerge(srcPtrMat.Data, n, dst.MatObj);
        }
        public static void split(Mat src, List <Mat> dst)
        {
            if (!src.Valid || src.IsEmpty)
            {
                return;
            }
            int channel = src.Channels;

            if (dst == null)
            {
                dst = new List <Mat>();
            }
            if (channel > dst.Count)
            {
                while (dst.Count < channel)
                {
                    dst.Add(new Mat());
                }
            }
            else if (channel < dst.Count)
            {
                dst.RemoveRange(channel, dst.Count - channel);
            }

            var dstPtrs = new IntPtr[channel];

            for (int i = 0; i < channel; i++)
            {
                if (dst[i].Valid)
                {
                    dstPtrs[i] = dst[i].MatObj;
                }
                else
                {
                    return;                     // check every mat in dst is valid
                }
            }
            var dstPtrMat = new Mat(1, channel * Marshal.SizeOf <IntPtr>(), Mat.makeType(1, Mat.MatDepth.CV_8U));
            if (!dstPtrMat.Valid)             // alloc unmanaged memory
            {
                return;
            }
            Marshal.Copy(dstPtrs, 0, dstPtrMat.Data, channel);
            NativeInvoker.coreCvSplit(src.MatObj, dstPtrMat.Data, channel);
        }
Esempio n. 3
0
        public static void warpAffine(Mat src, Mat dst, System.Numerics.Matrix3x2 trans, Size dSize,
                                      Interpolation inter   = Interpolation.INTER_LINEAR, bool inverseMap      = false,
                                      BorderMode borderMode = BorderMode.BORDER_CONSTANT, double[] borderValue = null)
        {
            Mat    transMat       = trans;
            int    flags          = inverseMap ? ((int)InverseMap.WARP_INVERSE_MAP | (int)inter) : (int)inter;
            Mat    matBorderValue = null;
            IntPtr ptrBorderValue = IntPtr.Zero;

            if (borderMode == BorderMode.BORDER_CONSTANT && borderValue != null && borderValue.Length > 0)
            {
                matBorderValue = new Mat(1, borderValue.Length, Mat.makeType(1, Mat.MatDepth.CV_64F));
                if (matBorderValue.Valid && matBorderValue.copyAll(borderValue, 0, borderValue.Length))
                {
                    ptrBorderValue = matBorderValue.Data;
                }
            }
            NativeInvoker.coreCvWarpAffine(src.MatObj, dst.MatObj, transMat.MatObj, (int)dSize.w, (int)dSize.h,
                                           flags, (int)borderMode, ptrBorderValue);
        }