JunShi101ShiNei/Assets/OpenCVForUnity/org/opencv_contrib/fuzzy/Fuzzy.cs


using OpenCVForUnity.CoreModule;
using OpenCVForUnity.UtilsModule;
using System;
using System.Collections.Generic;
using System.Runtime.InteropServices;

namespace OpenCVForUnity.FuzzyModule {
    // C++: class Fuzzy
    //javadoc: Fuzzy

    public class Fuzzy {

        // C++: enum <unnamed>
        public const int LINEAR = 1;
        public const int SINUS = 2;
        public const int ONE_STEP = 1;
        public const int MULTI_STEP = 2;
        public const int ITERATIVE = 3;
        //
        // C++:  int cv::ft::FT02D_iteration(Mat matrix, Mat kernel, Mat& output, Mat mask, Mat& maskOutput, bool firstStop)
        //

        //javadoc: FT02D_iteration(matrix, kernel, output, mask, maskOutput, firstStop)
        public static int FT02D_iteration(Mat matrix, Mat kernel, Mat output, Mat mask, Mat maskOutput, bool firstStop) {
            if (matrix != null) matrix.ThrowIfDisposed();
            if (kernel != null) kernel.ThrowIfDisposed();
            if (output != null) output.ThrowIfDisposed();
            if (mask != null) mask.ThrowIfDisposed();
            if (maskOutput != null) maskOutput.ThrowIfDisposed();
#if (UNITY_ANDROID && !UNITY_EDITOR)

            int retVal = fuzzy_Fuzzy_FT02D_1iteration_10(matrix.nativeObj, kernel.nativeObj, output.nativeObj, mask.nativeObj, maskOutput.nativeObj, firstStop);

            return retVal;
#else
            return -1;
#endif
        }


        //
        // C++:  void cv::ft::FT02D_FL_process(Mat matrix, int radius, Mat& output)
        //

        //javadoc: FT02D_FL_process(matrix, radius, output)
        public static void FT02D_FL_process(Mat matrix, int radius, Mat output) {
            if (matrix != null) matrix.ThrowIfDisposed();
            if (output != null) output.ThrowIfDisposed();
#if (UNITY_ANDROID && !UNITY_EDITOR)

            fuzzy_Fuzzy_FT02D_1FL_1process_10(matrix.nativeObj, radius, output.nativeObj);

            return;
#else
            return;
#endif
        }


        //
        // C++:  void cv::ft::FT02D_FL_process_float(Mat matrix, int radius, Mat& output)
        //

        //javadoc: FT02D_FL_process_float(matrix, radius, output)
        public static void FT02D_FL_process_float(Mat matrix, int radius, Mat output) {
            if (matrix != null) matrix.ThrowIfDisposed();
            if (output != null) output.ThrowIfDisposed();
#if (UNITY_ANDROID && !UNITY_EDITOR)

            fuzzy_Fuzzy_FT02D_1FL_1process_1float_10(matrix.nativeObj, radius, output.nativeObj);

            return;
#else
            return;
#endif
        }


        //
        // C++:  void cv::ft::FT02D_components(Mat matrix, Mat kernel, Mat& components, Mat mask = Mat())
        //

        //javadoc: FT02D_components(matrix, kernel, components, mask)
        public static void FT02D_components(Mat matrix, Mat kernel, Mat components, Mat mask) {
            if (matrix != null) matrix.ThrowIfDisposed();
            if (kernel != null) kernel.ThrowIfDisposed();
            if (components != null) components.ThrowIfDisposed();
            if (mask != null) mask.ThrowIfDisposed();
#if (UNITY_ANDROID && !UNITY_EDITOR)

            fuzzy_Fuzzy_FT02D_1components_10(matrix.nativeObj, kernel.nativeObj, components.nativeObj, mask.nativeObj);

            return;
#else
            return;
#endif
        }

        //javadoc: FT02D_components(matrix, kernel, components)
        public static void FT02D_components(Mat matrix, Mat kernel, Mat components) {
            if (matrix != null) matrix.ThrowIfDisposed();
            if (kernel != null) kernel.ThrowIfDisposed();
            if (components != null) components.ThrowIfDisposed();
#if (UNITY_ANDROID && !UNITY_EDITOR)

            fuzzy_Fuzzy_FT02D_1components_11(matrix.nativeObj, kernel.nativeObj, components.nativeObj);

            return;
#else
            return;
#endif
        }


        //
        // C++:  void cv::ft::FT02D_inverseFT(Mat components, Mat kernel, Mat& output, int width, int height)
        //

        //javadoc: FT02D_inverseFT(components, kernel, output, width, height)
        public static void FT02D_inverseFT(Mat components, Mat kernel, Mat output, int width, int height) {
            if (components != null) components.ThrowIfDisposed();
            if (kernel != null) kernel.ThrowIfDisposed();
            if (output != null) output.ThrowIfDisposed();
#if (UNITY_ANDROID && !UNITY_EDITOR)

            fuzzy_Fuzzy_FT02D_1inverseFT_10(components.nativeObj, kernel.nativeObj, output.nativeObj, width, height);

            return;
#else
            return;
#endif
        }


        //
        // C++:  void cv::ft::FT02D_process(Mat matrix, Mat kernel, Mat& output, Mat mask = Mat())
        //

        //javadoc: FT02D_process(matrix, kernel, output, mask)
        public static void FT02D_process(Mat matrix, Mat kernel, Mat output, Mat mask) {
            if (matrix != null) matrix.ThrowIfDisposed();
            if (kernel != null) kernel.ThrowIfDisposed();
            if (output != null) output.ThrowIfDisposed();
            if (mask != null) mask.ThrowIfDisposed();
#if (UNITY_ANDROID && !UNITY_EDITOR)

            fuzzy_Fuzzy_FT02D_1process_10(matrix.nativeObj, kernel.nativeObj, output.nativeObj, mask.nativeObj);

            return;
#else
            return;
#endif
        }

        //javadoc: FT02D_process(matrix, kernel, output)
        public static void FT02D_process(Mat matrix, Mat kernel, Mat output) {
            if (matrix != null) matrix.ThrowIfDisposed();
            if (kernel != null) kernel.ThrowIfDisposed();
            if (output != null) output.ThrowIfDisposed();
#if (UNITY_ANDROID && !UNITY_EDITOR)

            fuzzy_Fuzzy_FT02D_1process_11(matrix.nativeObj, kernel.nativeObj, output.nativeObj);

            return;
#else
            return;
#endif
        }


        //
        // C++:  void cv::ft::FT12D_components(Mat matrix, Mat kernel, Mat& components)
        //

        //javadoc: FT12D_components(matrix, kernel, components)
        public static void FT12D_components(Mat matrix, Mat kernel, Mat components) {
            if (matrix != null) matrix.ThrowIfDisposed();
            if (kernel != null) kernel.ThrowIfDisposed();
            if (components != null) components.ThrowIfDisposed();
#if (UNITY_ANDROID && !UNITY_EDITOR)

            fuzzy_Fuzzy_FT12D_1components_10(matrix.nativeObj, kernel.nativeObj, components.nativeObj);

            return;
#else
            return;
#endif
        }


        //
        // C++:  void cv::ft::FT12D_createPolynomMatrixHorizontal(int radius, Mat& matrix, int chn)
        //

        //javadoc: FT12D_createPolynomMatrixHorizontal(radius, matrix, chn)
        public static void FT12D_createPolynomMatrixHorizontal(int radius, Mat matrix, int chn) {
            if (matrix != null) matrix.ThrowIfDisposed();
#if (UNITY_ANDROID && !UNITY_EDITOR)

            fuzzy_Fuzzy_FT12D_1createPolynomMatrixHorizontal_10(radius, matrix.nativeObj, chn);

            return;
#else
            return;
#endif
        }


        //
        // C++:  void cv::ft::FT12D_createPolynomMatrixVertical(int radius, Mat& matrix, int chn)
        //

        //javadoc: FT12D_createPolynomMatrixVertical(radius, matrix, chn)
        public static void FT12D_createPolynomMatrixVertical(int radius, Mat matrix, int chn) {
            if (matrix != null) matrix.ThrowIfDisposed();
#if (UNITY_ANDROID && !UNITY_EDITOR)

            fuzzy_Fuzzy_FT12D_1createPolynomMatrixVertical_10(radius, matrix.nativeObj, chn);

            return;
#else
            return;
#endif
        }


        //
        // C++:  void cv::ft::FT12D_inverseFT(Mat components, Mat kernel, Mat& output, int width, int height)
        //

        //javadoc: FT12D_inverseFT(components, kernel, output, width, height)
        public static void FT12D_inverseFT(Mat components, Mat kernel, Mat output, int width, int height) {
            if (components != null) components.ThrowIfDisposed();
            if (kernel != null) kernel.ThrowIfDisposed();
            if (output != null) output.ThrowIfDisposed();
#if (UNITY_ANDROID && !UNITY_EDITOR)

            fuzzy_Fuzzy_FT12D_1inverseFT_10(components.nativeObj, kernel.nativeObj, output.nativeObj, width, height);

            return;
#else
            return;
#endif
        }


        //
        // C++:  void cv::ft::FT12D_polynomial(Mat matrix, Mat kernel, Mat& c00, Mat& c10, Mat& c01, Mat& components, Mat mask = Mat())
        //

        //javadoc: FT12D_polynomial(matrix, kernel, c00, c10, c01, components, mask)
        public static void FT12D_polynomial(Mat matrix, Mat kernel, Mat c00, Mat c10, Mat c01, Mat components, Mat mask) {
            if (matrix != null) matrix.ThrowIfDisposed();
            if (kernel != null) kernel.ThrowIfDisposed();
            if (c00 != null) c00.ThrowIfDisposed();
            if (c10 != null) c10.ThrowIfDisposed();
            if (c01 != null) c01.ThrowIfDisposed();
            if (components != null) components.ThrowIfDisposed();
            if (mask != null) mask.ThrowIfDisposed();
#if (UNITY_ANDROID && !UNITY_EDITOR)

            fuzzy_Fuzzy_FT12D_1polynomial_10(matrix.nativeObj, kernel.nativeObj, c00.nativeObj, c10.nativeObj, c01.nativeObj, components.nativeObj, mask.nativeObj);

            return;
#else
            return;
#endif
        }

        //javadoc: FT12D_polynomial(matrix, kernel, c00, c10, c01, components)
        public static void FT12D_polynomial(Mat matrix, Mat kernel, Mat c00, Mat c10, Mat c01, Mat components) {
            if (matrix != null) matrix.ThrowIfDisposed();
            if (kernel != null) kernel.ThrowIfDisposed();
            if (c00 != null) c00.ThrowIfDisposed();
            if (c10 != null) c10.ThrowIfDisposed();
            if (c01 != null) c01.ThrowIfDisposed();
            if (components != null) components.ThrowIfDisposed();
#if (UNITY_ANDROID && !UNITY_EDITOR)

            fuzzy_Fuzzy_FT12D_1polynomial_11(matrix.nativeObj, kernel.nativeObj, c00.nativeObj, c10.nativeObj, c01.nativeObj, components.nativeObj);

            return;
#else
            return;
#endif
        }


        //
        // C++:  void cv::ft::FT12D_process(Mat matrix, Mat kernel, Mat& output, Mat mask = Mat())
        //

        //javadoc: FT12D_process(matrix, kernel, output, mask)
        public static void FT12D_process(Mat matrix, Mat kernel, Mat output, Mat mask) {
            if (matrix != null) matrix.ThrowIfDisposed();
            if (kernel != null) kernel.ThrowIfDisposed();
            if (output != null) output.ThrowIfDisposed();
            if (mask != null) mask.ThrowIfDisposed();
#if (UNITY_ANDROID && !UNITY_EDITOR)

            fuzzy_Fuzzy_FT12D_1process_10(matrix.nativeObj, kernel.nativeObj, output.nativeObj, mask.nativeObj);

            return;
#else
            return;
#endif
        }

        //javadoc: FT12D_process(matrix, kernel, output)
        public static void FT12D_process(Mat matrix, Mat kernel, Mat output) {
            if (matrix != null) matrix.ThrowIfDisposed();
            if (kernel != null) kernel.ThrowIfDisposed();
            if (output != null) output.ThrowIfDisposed();
#if (UNITY_ANDROID && !UNITY_EDITOR)

            fuzzy_Fuzzy_FT12D_1process_11(matrix.nativeObj, kernel.nativeObj, output.nativeObj);

            return;
#else
            return;
#endif
        }


        //
        // C++:  void cv::ft::createKernel(Mat A, Mat B, Mat& kernel, int chn)
        //

        //javadoc: createKernel1(A, B, kernel, chn)
        public static void createKernel1(Mat A, Mat B, Mat kernel, int chn) {
            if (A != null) A.ThrowIfDisposed();
            if (B != null) B.ThrowIfDisposed();
            if (kernel != null) kernel.ThrowIfDisposed();
#if (UNITY_ANDROID && !UNITY_EDITOR)

            fuzzy_Fuzzy_createKernel1_10(A.nativeObj, B.nativeObj, kernel.nativeObj, chn);

            return;
#else
            return;
#endif
        }


        //
        // C++:  void cv::ft::createKernel(int function, int radius, Mat& kernel, int chn)
        //

        //javadoc: createKernel(function, radius, kernel, chn)
        public static void createKernel(int function, int radius, Mat kernel, int chn) {
            if (kernel != null) kernel.ThrowIfDisposed();
#if (UNITY_ANDROID && !UNITY_EDITOR)

            fuzzy_Fuzzy_createKernel_10(function, radius, kernel.nativeObj, chn);

            return;
#else
            return;
#endif
        }


        //
        // C++:  void cv::ft::filter(Mat image, Mat kernel, Mat& output)
        //

        //javadoc: filter(image, kernel, output)
        public static void filter(Mat image, Mat kernel, Mat output) {
            if (image != null) image.ThrowIfDisposed();
            if (kernel != null) kernel.ThrowIfDisposed();
            if (output != null) output.ThrowIfDisposed();
#if (UNITY_ANDROID && !UNITY_EDITOR)

            fuzzy_Fuzzy_filter_10(image.nativeObj, kernel.nativeObj, output.nativeObj);

            return;
#else
            return;
#endif
        }


        //
        // C++:  void cv::ft::inpaint(Mat image, Mat mask, Mat& output, int radius, int function, int algorithm)
        //

        //javadoc: inpaint(image, mask, output, radius, function, algorithm)
        public static void inpaint(Mat image, Mat mask, Mat output, int radius, int function, int algorithm) {
            if (image != null) image.ThrowIfDisposed();
            if (mask != null) mask.ThrowIfDisposed();
            if (output != null) output.ThrowIfDisposed();
#if (UNITY_ANDROID && !UNITY_EDITOR)

            fuzzy_Fuzzy_inpaint_10(image.nativeObj, mask.nativeObj, output.nativeObj, radius, function, algorithm);

            return;
#else
            return;
#endif
        }



#if (UNITY_ANDROID && !UNITY_EDITOR)
        const string LIBNAME = "opencvforunity";



        // C++:  int cv::ft::FT02D_iteration(Mat matrix, Mat kernel, Mat& output, Mat mask, Mat& maskOutput, bool firstStop)
        [DllImport(LIBNAME)]
        private static extern int fuzzy_Fuzzy_FT02D_1iteration_10(IntPtr matrix_nativeObj, IntPtr kernel_nativeObj, IntPtr output_nativeObj, IntPtr mask_nativeObj, IntPtr maskOutput_nativeObj, bool firstStop);

        // C++:  void cv::ft::FT02D_FL_process(Mat matrix, int radius, Mat& output)
        [DllImport(LIBNAME)]
        private static extern void fuzzy_Fuzzy_FT02D_1FL_1process_10(IntPtr matrix_nativeObj, int radius, IntPtr output_nativeObj);

        // C++:  void cv::ft::FT02D_FL_process_float(Mat matrix, int radius, Mat& output)
        [DllImport(LIBNAME)]
        private static extern void fuzzy_Fuzzy_FT02D_1FL_1process_1float_10(IntPtr matrix_nativeObj, int radius, IntPtr output_nativeObj);

        // C++:  void cv::ft::FT02D_components(Mat matrix, Mat kernel, Mat& components, Mat mask = Mat())
        [DllImport(LIBNAME)]
        private static extern void fuzzy_Fuzzy_FT02D_1components_10(IntPtr matrix_nativeObj, IntPtr kernel_nativeObj, IntPtr components_nativeObj, IntPtr mask_nativeObj);
        [DllImport(LIBNAME)]
        private static extern void fuzzy_Fuzzy_FT02D_1components_11(IntPtr matrix_nativeObj, IntPtr kernel_nativeObj, IntPtr components_nativeObj);

        // C++:  void cv::ft::FT02D_inverseFT(Mat components, Mat kernel, Mat& output, int width, int height)
        [DllImport(LIBNAME)]
        private static extern void fuzzy_Fuzzy_FT02D_1inverseFT_10(IntPtr components_nativeObj, IntPtr kernel_nativeObj, IntPtr output_nativeObj, int width, int height);

        // C++:  void cv::ft::FT02D_process(Mat matrix, Mat kernel, Mat& output, Mat mask = Mat())
        [DllImport(LIBNAME)]
        private static extern void fuzzy_Fuzzy_FT02D_1process_10(IntPtr matrix_nativeObj, IntPtr kernel_nativeObj, IntPtr output_nativeObj, IntPtr mask_nativeObj);
        [DllImport(LIBNAME)]
        private static extern void fuzzy_Fuzzy_FT02D_1process_11(IntPtr matrix_nativeObj, IntPtr kernel_nativeObj, IntPtr output_nativeObj);

        // C++:  void cv::ft::FT12D_components(Mat matrix, Mat kernel, Mat& components)
        [DllImport(LIBNAME)]
        private static extern void fuzzy_Fuzzy_FT12D_1components_10(IntPtr matrix_nativeObj, IntPtr kernel_nativeObj, IntPtr components_nativeObj);

        // C++:  void cv::ft::FT12D_createPolynomMatrixHorizontal(int radius, Mat& matrix, int chn)
        [DllImport(LIBNAME)]
        private static extern void fuzzy_Fuzzy_FT12D_1createPolynomMatrixHorizontal_10(int radius, IntPtr matrix_nativeObj, int chn);

        // C++:  void cv::ft::FT12D_createPolynomMatrixVertical(int radius, Mat& matrix, int chn)
        [DllImport(LIBNAME)]
        private static extern void fuzzy_Fuzzy_FT12D_1createPolynomMatrixVertical_10(int radius, IntPtr matrix_nativeObj, int chn);

        // C++:  void cv::ft::FT12D_inverseFT(Mat components, Mat kernel, Mat& output, int width, int height)
        [DllImport(LIBNAME)]
        private static extern void fuzzy_Fuzzy_FT12D_1inverseFT_10(IntPtr components_nativeObj, IntPtr kernel_nativeObj, IntPtr output_nativeObj, int width, int height);

        // C++:  void cv::ft::FT12D_polynomial(Mat matrix, Mat kernel, Mat& c00, Mat& c10, Mat& c01, Mat& components, Mat mask = Mat())
        [DllImport(LIBNAME)]
        private static extern void fuzzy_Fuzzy_FT12D_1polynomial_10(IntPtr matrix_nativeObj, IntPtr kernel_nativeObj, IntPtr c00_nativeObj, IntPtr c10_nativeObj, IntPtr c01_nativeObj, IntPtr components_nativeObj, IntPtr mask_nativeObj);
        [DllImport(LIBNAME)]
        private static extern void fuzzy_Fuzzy_FT12D_1polynomial_11(IntPtr matrix_nativeObj, IntPtr kernel_nativeObj, IntPtr c00_nativeObj, IntPtr c10_nativeObj, IntPtr c01_nativeObj, IntPtr components_nativeObj);

        // C++:  void cv::ft::FT12D_process(Mat matrix, Mat kernel, Mat& output, Mat mask = Mat())
        [DllImport(LIBNAME)]
        private static extern void fuzzy_Fuzzy_FT12D_1process_10(IntPtr matrix_nativeObj, IntPtr kernel_nativeObj, IntPtr output_nativeObj, IntPtr mask_nativeObj);
        [DllImport(LIBNAME)]
        private static extern void fuzzy_Fuzzy_FT12D_1process_11(IntPtr matrix_nativeObj, IntPtr kernel_nativeObj, IntPtr output_nativeObj);

        // C++:  void cv::ft::createKernel(Mat A, Mat B, Mat& kernel, int chn)
        [DllImport(LIBNAME)]
        private static extern void fuzzy_Fuzzy_createKernel1_10(IntPtr A_nativeObj, IntPtr B_nativeObj, IntPtr kernel_nativeObj, int chn);

        // C++:  void cv::ft::createKernel(int function, int radius, Mat& kernel, int chn)
        [DllImport(LIBNAME)]
        private static extern void fuzzy_Fuzzy_createKernel_10(int function, int radius, IntPtr kernel_nativeObj, int chn);

        // C++:  void cv::ft::filter(Mat image, Mat kernel, Mat& output)
        [DllImport(LIBNAME)]
        private static extern void fuzzy_Fuzzy_filter_10(IntPtr image_nativeObj, IntPtr kernel_nativeObj, IntPtr output_nativeObj);

        // C++:  void cv::ft::inpaint(Mat image, Mat mask, Mat& output, int radius, int function, int algorithm)
        [DllImport(LIBNAME)]
        private static extern void fuzzy_Fuzzy_inpaint_10(IntPtr image_nativeObj, IntPtr mask_nativeObj, IntPtr output_nativeObj, int radius, int function, int algorithm);

#endif
    }
}