/// <summary>
 /// Creates instance from cv::Ptr&lt;T&gt; .
 /// ptr is disposed when the wrapper disposes. 
 /// </summary>
 /// <param name="ptr"></param>
 internal static new BRISK FromPtr(IntPtr ptr)
 {
     if (ptr == IntPtr.Zero)
         throw new OpenCvSharpException("Invalid cv::Ptr<BRISK> pointer");
     var ptrObj = new Ptr<BRISK>(ptr);
     return new BRISK(ptrObj);
 }

 /// <summary>
 /// Creates instance from cv::Ptr&lt;T&gt; .
 /// ptr is disposed when the wrapper disposes. 
 /// </summary>
 /// <param name="ptr"></param>
 internal new static FlannBasedMatcher FromPtr(IntPtr ptr)
 {
     if (ptr == IntPtr.Zero)
         throw new OpenCvSharpException("Invalid cv::Ptr<FlannBasedMatcher> pointer");
     var ptrObj = new Ptr<FlannBasedMatcher>(ptr);
     return new FlannBasedMatcher(ptrObj);
 }

    /// <summary>
    /// リソースの解放
    /// </summary>
    /// <param name="disposing">
    /// trueの場合は、このメソッドがユーザコードから直接が呼ばれたことを示す。マネージ・アンマネージ双方のリソースが解放される。
    /// falseの場合は、このメソッドはランタイムからファイナライザによって呼ばれ、もうほかのオブジェクトから参照されていないことを示す。アンマネージリソースのみ解放される。
    ///</param>
#else
        /// <summary>
        /// Releases the resources
        /// </summary>
        /// <param name="disposing">
        /// If disposing equals true, the method has been called directly or indirectly by a user's code. Managed and unmanaged resources can be disposed.
        /// If false, the method has been called by the runtime from inside the finalizer and you should not reference other objects. Only unmanaged resources can be disposed.
        /// </param>
#endif
        protected override void Dispose(bool disposing)
        {
            if (!disposed)
            {
                try
                {
                    // releases managed resources
                    if (disposing)
                    {
                    }
                    // releases unmanaged resources
                    if (IsEnabledDispose)
                    {
                        ptrObj?.Dispose();
                        ptrObj = null;
                        ptr = IntPtr.Zero;
                    }
                    disposed = true;
                }
                finally
                {
                    base.Dispose(disposing);
                }
            }
        }

 /// <summary>
 /// Creates instance from cv::Ptr&lt;T&gt; .
 /// ptr is disposed when the wrapper disposes. 
 /// </summary>
 /// <param name="ptr"></param>
 internal static new StarDetector FromPtr(IntPtr ptr)
 {
     if (ptr == IntPtr.Zero)
         throw new OpenCvSharpException("Invalid cv::Ptr<StarDetector> pointer");
     var ptrObj = new Ptr<StarDetector>(ptr);
     return new StarDetector(ptrObj);
 }

        private Ptr<RPC_SERVER_INTERFACE> Configure(RpcHandle handle, Ptr<MIDL_SERVER_INFO> me, Guid iid,
                                                    Byte[] formatTypes, Byte[] formatProc, ushort[] formatProcOffsets,
                                                    Delegate[] funcs)
        {
            Ptr<RPC_SERVER_INTERFACE> svrIface = handle.CreatePtr(new RPC_SERVER_INTERFACE(handle, me, iid));
            Ptr<MIDL_STUB_DESC> stub = handle.CreatePtr(new MIDL_STUB_DESC(handle, svrIface.Handle, formatTypes, true));
            pStubDesc = stub.Handle;

            var dispatches = new IntPtr[funcs.Length];
            for (var i = 0; i < funcs.Length; ++i)
            {
              dispatches[i] = handle.PinFunction(funcs[i]);
            }
            DispatchTable = handle.Pin(dispatches);

            ProcString = handle.Pin(formatProc);
            FmtStringOffset = handle.Pin(formatProcOffsets.Clone());

            ThunkTable = IntPtr.Zero;
            pTransferSyntax = IntPtr.Zero;
            nCount = IntPtr.Zero;
            pSyntaxInfo = IntPtr.Zero;

            //Copy us back into the pinned address
            Marshal.StructureToPtr(this, me.Handle, false);
            return svrIface;
        }

    /// <summary>
    /// リソースの解放
    /// </summary>
    /// <param name="disposing">
    /// trueの場合は、このメソッドがユーザコードから直接が呼ばれたことを示す。マネージ・アンマネージ双方のリソースが解放される。
    /// falseの場合は、このメソッドはランタイムからファイナライザによって呼ばれ、もうほかのオブジェクトから参照されていないことを示す。アンマネージリソースのみ解放される。
    ///</param>
#else
        /// <summary>
        /// Clean up any resources being used.
        /// </summary>
        /// <param name="disposing">
        /// If disposing equals true, the method has been called directly or indirectly by a user's code. Managed and unmanaged resources can be disposed.
        /// If false, the method has been called by the runtime from inside the finalizer and you should not reference other objects. Only unmanaged resources can be disposed.
        /// </param>
#endif
        protected override void Dispose(bool disposing)
        {
            if (!disposed)
            {
                try
                {
                    if (disposing)
                    {
                    }
                    if (IsEnabledDispose)
                    {
                        if (objectPtr != null)
                        {
                            objectPtr.Dispose();
                        }
                        objectPtr = null;
                        ptr = IntPtr.Zero;
                    }
                    disposed = true;
                }
                finally
                {
                    base.Dispose(disposing);
                }
            }
        }

        /// <summary>
        /// リソースの解放
        /// </summary>
        /// <param name="disposing">
        /// trueの場合は、このメソッドがユーザコードから直接が呼ばれたことを示す。マネージ・アンマネージ双方のリソースが解放される。
        /// falseの場合は、このメソッドはランタイムからファイナライザによって呼ばれ、もうほかのオブジェクトから参照されていないことを示す。アンマネージリソースのみ解放される。
        ///</param>
#else
        /// <summary>
        /// Releases the resources
        /// </summary>
        /// <param name="disposing">
        /// If disposing equals true, the method has been called directly or indirectly by a user's code. Managed and unmanaged resources can be disposed.
        /// If false, the method has been called by the runtime from inside the finalizer and you should not reference other objects. Only unmanaged resources can be disposed.
        /// </param>
#endif
        protected override void Dispose(bool disposing)
        {
            if (!disposed)
            {
                try
                {
                    // releases managed resources
                    if (disposing)
                    {
                        if (detectorPtr != null)
                        {
                            detectorPtr.Dispose();
                            detectorPtr = null;
                        }
                    }
                    // releases unmanaged resources
                    
                    ptr = IntPtr.Zero;
                    disposed = true;
                }
                finally
                {
                    base.Dispose(disposing);
                }
            }
        }

 /// <summary>
 /// the full constructor that takes the length of the history, the number of gaussian mixtures, the background ratio parameter and the noise strength
 /// </summary>
 /// <param name="history"></param>
 /// <param name="varThreshold"></param>
 /// <param name="bShadowDetection"></param>
 public BackgroundSubtractorMOG2(int history, float varThreshold, bool bShadowDetection = true)
 {
     IntPtr po = NativeMethods.video_BackgroundSubtractorMOG2_new2(history, varThreshold, bShadowDetection ? 1 : 0);
     if (po == IntPtr.Zero)
         throw new OpenCvSharpException("Failed to create BackgroundSubtractorMOG2");
     objectPtr = new Ptr<BackgroundSubtractorMOG2>(po);
     ptr = objectPtr.Obj;
 }

 /// <summary>
 /// the full constructor that takes the length of the history, the number of gaussian mixtures, the background ratio parameter and the noise strength
 /// </summary>
 /// <param name="history"></param>
 /// <param name="nmixtures"></param>
 /// <param name="backgroundRatio"></param>
 /// <param name="noiseSigma"></param>
 public BackgroundSubtractorMOG(int history, int nmixtures, double backgroundRatio, double noiseSigma=0)
 {
     IntPtr po = NativeMethods.video_BackgroundSubtractorMOG_new2(history, nmixtures, backgroundRatio, noiseSigma);
     if (po == IntPtr.Zero)
         throw new OpenCvSharpException("Failed to create BackgroundSubtractorMOG");
     objectPtr = new Ptr<BackgroundSubtractorMOG>(po);
     ptr = objectPtr.Obj;
 }

        /// <summary>
        /// Creates instance from cv::Ptr&lt;T&gt; .
        /// ptr is disposed when the wrapper disposes. 
        /// </summary>
        /// <param name="ptr"></param>
        internal new static BriefDescriptorExtractor FromPtr(IntPtr ptr)
        {
            if (ptr == IntPtr.Zero)
                throw new OpenCvSharpException("Invalid BriefDescriptorExtractor pointer");

            var ptrObj = new Ptr<BriefDescriptorExtractor>(ptr);
            var extractor = new BriefDescriptorExtractor(ptrObj,ptrObj.Obj);
            return extractor;
        }

        /// <summary>
        /// SURF初期化
        /// </summary>
        /// <param name="hessianThreshold">keypoint.hessian の値がこの閾値よりも大きい特徴だけが検出される</param>
        /// <param name="nOctaves"></param>
        /// <param name="nOctaveLayers"></param>
        /// <param name="extended">false：基本的なディスクリプタ（64要素）, true：拡張されたディスクリプタ（128要素）</param>
        /// <param name="upright"></param>
#else
        /// <summary>
        /// The SURF constructor.
        /// </summary>
        /// <param name="hessianThreshold">Only features with keypoint.hessian larger than that are extracted. </param>
        /// <param name="nOctaves">The number of a gaussian pyramid octaves that the detector uses. It is set to 4 by default. 
        /// If you want to get very large features, use the larger value. If you want just small features, decrease it.</param>
        /// <param name="nOctaveLayers">The number of images within each octave of a gaussian pyramid. It is set to 2 by default.</param>
        /// <param name="extended">false means basic descriptors (64 elements each), true means extended descriptors (128 elements each) </param>
        /// <param name="upright">false means that detector computes orientation of each feature.
        /// true means that the orientation is not computed (which is much, much faster).</param>
#endif
        public SURF(double hessianThreshold,
            int nOctaves = 4, int nOctaveLayers = 2,
            bool extended = true, bool upright = false)
            : base()
        {
            ptr = NativeMethods.nonfree_SURF_new(hessianThreshold, nOctaves, nOctaveLayers,
                extended ? 1 : 0, upright ? 1 : 0);
            detectorPtr = null;
        }

        /// <summary>
        /// Creates instance from cv::Ptr&lt;T&gt; .
        /// ptr is disposed when the wrapper disposes. 
        /// </summary>
        /// <param name="ptr"></param>
        internal static new BackgroundSubtractorMOG FromPtr(IntPtr ptr)
        {
            if (ptr == IntPtr.Zero)
                throw new OpenCvSharpException("Invalid BackgroundSubtractorMOG pointer");

            var ptrObj = new Ptr<BackgroundSubtractorMOG>(ptr);
            var obj = new BackgroundSubtractorMOG(ptrObj, ptrObj.Obj);
            return obj;
        }

 /// <summary>
 /// Creates instance from cv::Ptr&lt;T&gt; .
 /// ptr is disposed when the wrapper disposes. 
 /// </summary>
 /// <param name="ptr"></param>
 internal static FrameSource FromPtr(IntPtr ptr)
 {
     if (ptr == IntPtr.Zero)
         throw new OpenCvSharpException("Invalid FrameSource pointer");
     var obj = new FrameSourceImpl();
     var ptrObj = new Ptr<FrameSource>(ptr);
     obj.ptrObj = ptrObj;
     obj.ptr = ptr;
     return obj;
 }

 /// <summary>
 /// Creates instance from cv::Ptr&lt;T&gt; .
 /// ptr is disposed when the wrapper disposes. 
 /// </summary>
 /// <param name="ptr"></param>
 internal static DescriptorMatcher FromPtr(IntPtr ptr)
 {
     if (ptr == IntPtr.Zero)
         throw new OpenCvSharpException("Invalid cv::Ptr<DescriptorMatcher> pointer");
     var ptrObj = new Ptr<DescriptorMatcher>(ptr);
     var detector = new DescriptorMatcher
         {
             detectorPtr = ptrObj, 
             ptr = ptrObj.Obj
         };
     return detector;
 }

 /// <summary>
 /// Creates instance from cv::Ptr&lt;T&gt; .
 /// ptr is disposed when the wrapper disposes. 
 /// </summary>
 /// <param name="ptr"></param>
 internal static Feature2D FromPtr(IntPtr ptr)
 {
     if (ptr == IntPtr.Zero)
         throw new OpenCvSharpException("Invalid cv::Ptr<Feature2D> pointer");
     var ptrObj = new Ptr<Feature2D>(ptr);
     var detector = new Feature2D
     {
         ptrObj = ptrObj,
         ptr = ptrObj.Get()
     };
     return detector;
 }

 /// <summary>
 /// Creates instance from cv::Ptr&lt;T&gt; .
 /// ptr is disposed when the wrapper disposes. 
 /// </summary>
 /// <param name="ptr"></param>
 internal static FaceRecognizer FromPtr(IntPtr ptr)
 {
     if (ptr == IntPtr.Zero)
         throw new OpenCvSharpException("Invalid cv::Ptr<FaceRecognizer> pointer");
     var ptrObj = new Ptr<FaceRecognizer>(ptr);
     var detector = new FaceRecognizer
         {
             recognizerPtr = ptrObj, 
             ptr = ptrObj.Obj
         };
     return detector;
 }

 /// <summary>
 /// Creates instance from cv::Ptr&lt;T&gt; .
 /// ptr is disposed when the wrapper disposes. 
 /// </summary>
 /// <param name="ptr"></param>
 internal static SuperResolutionImpl FromPtr(IntPtr ptr)
 {
     if (ptr == IntPtr.Zero)
         throw new OpenCvSharpException("Invalid FrameSource pointer");
     
     var ptrObj = new Ptr<SuperResolution>(ptr);
     var obj = new SuperResolutionImpl
         {
             detectorPtr = ptrObj, 
             ptr = ptrObj.Obj
         };
     return obj;
 }

        /// <summary>
        /// Creates instance from cv::Ptr&lt;T&gt; .
        /// ptr is disposed when the wrapper disposes. 
        /// </summary>
        /// <param name="ptr"></param>
        internal static DescriptorExtractor FromPtr(IntPtr ptr)
        {
            if (ptr == IntPtr.Zero)
                throw new OpenCvSharpException("Invalid DescriptorExtractor pointer");

            var ptrObj = new Ptr<DescriptorExtractor>(ptr);
            var extractor = new DescriptorExtractor
                {
                    extractorPtr = ptrObj,
                    ptr = ptrObj.Obj
                };
            return extractor;
        }

        /// <summary>
        /// Creates instance from cv::Ptr&lt;T&gt; .
        /// ptr is disposed when the wrapper disposes. 
        /// </summary>
        /// <param name="ptr"></param>
        internal static FeatureDetector FromPtr(IntPtr ptr)
        {
            if (ptr == IntPtr.Zero)
                throw new OpenCvSharpException("Invalid FeatureDetector pointer");

            var ptrObj = new Ptr<FeatureDetector>(ptr);
            var detector = new FeatureDetector
                {
                    detectorPtr = ptrObj,
                    ptr = ptrObj.Obj
                };
            return detector;
        }

        /// <summary>
        /// Creates instance from cv::Ptr&lt;T&gt; .
        /// ptr is disposed when the wrapper disposes. 
        /// </summary>
        /// <param name="ptr"></param>
        internal static CLAHE FromPtr(IntPtr ptr)
        {
            if (ptr == IntPtr.Zero)
                throw new OpenCvSharpException("Invalid CLAHE pointer");

            var ptrObj = new Ptr<CLAHE>(ptr);
            var ret = new CLAHE
                {
                    ptr = ptrObj.Obj,
                    ptrObj = ptrObj,
                };
            return ret;
        }