public KmeansInput(Array samples, MatrixType samplesType, int nClusters, CvTermCriteria criteria)
 {
     Samples = samples;
     SamplesType = samplesType;
     NClusters = nClusters;
     Criteria = criteria;
 }

        protected Expression Visit(BinaryExpression expression)
        {
            // First, dispatch to resolve type of node at deeper level
            Visit((Node)expression);

            var leftType = expression.Left.TypeInference.TargetType;
            var rightType = expression.Right.TypeInference.TargetType;
            var returnType = expression.TypeInference.ExpectedType ?? expression.TypeInference.TargetType;

            bool isNumericOperator = true;

            switch (expression.Operator)
            {
                case BinaryOperator.LogicalAnd:
                case BinaryOperator.LogicalOr:
                    isNumericOperator = false;
                    returnType = GetBinaryImplicitConversionType(expression.Span, leftType, rightType, true);
                    expression.TypeInference.TargetType = returnType;
                    break;
                case BinaryOperator.Less:
                case BinaryOperator.LessEqual:
                case BinaryOperator.Greater:
                case BinaryOperator.GreaterEqual:
                case BinaryOperator.Equality:
                case BinaryOperator.Inequality:
                    isNumericOperator = false;
                    returnType = GetBinaryImplicitConversionType(expression.Span, leftType, rightType, false);

                    TypeBase resultType = ScalarType.Bool;
                    if (returnType is VectorType)
                    {
                        resultType = new VectorType(ScalarType.Bool, ((VectorType)returnType).Dimension);
                    }
                    else if (returnType is MatrixType)
                    {
                        var matrixType = (MatrixType)returnType;
                        resultType = new MatrixType(ScalarType.Bool, matrixType.RowCount, matrixType.ColumnCount);
                    }
                    expression.TypeInference.TargetType = resultType;
                    break;
            }

            if (returnType != null)
            {
                if (returnType == ScalarType.Bool && isNumericOperator)
                {
                    var typeToCheck = leftType ?? rightType;
                    if (typeToCheck != null)
                        return ConvertExpressionToBool(expression, typeToCheck);
                } 
            }

            if (!isNumericOperator || CastHelper.NeedConvertForBinary(leftType, returnType))
                expression.Left = Cast(leftType, returnType, expression.Left);
            if (!isNumericOperator || CastHelper.NeedConvertForBinary(rightType, returnType))
                expression.Right = Cast(rightType, returnType, expression.Right);

            return expression;
        }

 /// <summary>
 /// Construct a rotation matrix,origin at (0,0,0)
 /// </summary>
 /// <param name="xAxis">identity of x axis</param>
 /// <param name="yAxis">identity of y axis</param>
 /// <param name="zAxis">identity of z axis</param>
 public Matrix4(Vector4 xAxis,Vector4 yAxis, Vector4 zAxis)
 {
     m_type = MatrixType.Rotation;
     Identity();
     m_matrix[0, 0] = xAxis.X; m_matrix[0, 1] = xAxis.Y; m_matrix[0, 2] = xAxis.Z;
     m_matrix[1, 0] = yAxis.X; m_matrix[1, 1] = yAxis.Y; m_matrix[1, 2] = yAxis.Z;
     m_matrix[2, 0] = zAxis.X; m_matrix[2, 1] = zAxis.Y; m_matrix[2, 2] = zAxis.Z;
 }

        public static void ConvertMaps(Mat map1, Mat map2, Mat dstmap1, Mat dstmap2, MatrixType dstmap1type, bool nninterpolation = false)
        {
            if (map1 == null)
                throw new ArgumentNullException("map1");
            if (map2 == null)
                throw new ArgumentNullException("map2");
            if (dstmap1 == null)
                throw new ArgumentNullException("dstmap1");
            if (dstmap2 == null)
                throw new ArgumentNullException("dstmap2");

            CppInvoke.cv_convertMaps(map1.CvPtr, map2.CvPtr, dstmap1.CvPtr, dstmap2.CvPtr, dstmap1type, nninterpolation);
        }

        internal DoubleSubmatrix(Matrix<double> matrix, int rowOffset, int columnOffset, int rows, int columns)
        {
            if (typeof(Matrix_SDA).IsInstanceOfType(matrix)) mt = MatrixType.SDA; // дописать
            else mt = MatrixType.SDA;

            this.offsetRow = rowOffset;
            this.offsetColumn = columnOffset;

            this.rows = rows;
            this.columns = columns;

            this.parent = matrix;
        }

        private static void PrintMatrix(int[,] matrix, MatrixType type)
        {
            Console.WriteLine(type + "\n");

            for (int row = 0; row < matrix.GetLength(0); row++)
            {
                for (int col = 0; col < matrix.GetLength(1); col++)
                {
                    Console.Write("{0, -4}", matrix[row, col]);
                }
                Console.WriteLine();
            }
            Console.WriteLine(new String('_', matrix.GetLength(0) * 5));
        }

        internal AnimatableMatrix GetMatrix(MatrixType whichMatrix)
        {
            switch (whichMatrix) {
                case MatrixType.World:
                    return World;

                case MatrixType.View:
                    return View;

                case MatrixType.Projection:
                    return Projection;

            }

            throw new InvalidOperationException(String.Format("Unrecognized matrix type: {0}", whichMatrix));
        }

        /// <summary>
        /// Extracts all of the 6 values from a Transformation Matrix
        /// </summary>
        /// <param name="path">The XML containing the Transformation Matrix</param>
        /// <param name="matrixType">The type of attribute to be extracted</param>
        /// <returns></returns>
        public static string[] GetMatrixValuesFromXml(XElement path, MatrixType matrixType)
        {
            string attribute;

            if (matrixType == MatrixType.PathMatrix)
            {
                attribute = "transform";
            }
            else
            {
                attribute = "gradientTransform";
            }

            string input = path.Attribute(attribute).Value;
            return input.Split('(', ')')[1].Split(' ');
        }

        /// <summary>
        /// Constructs a matrix with a special structure, like an "Eye" Matrix (see Matlab)
        /// </summary>
        /// <param name="_n">Number of rows</param>
        /// <param name="_m">Number of columns</param>
        /// <param name="structure">Structure Type </param>
        public Matrix(int _n, int _m, MatrixType type)
        {
            noRows = _n;
            noColumns = _m;
            values = new double[noRows, noColumns];

            switch (type)
            {
                case MatrixType.EYE:
                    for (int i = 0; i < noRows; i++)
                        for (int j = 0; j < noColumns; j++)
                            if (i == j)
                                this[i, j] = 1;
                    break;
                case MatrixType.ONES:
                    for (int i = 0; i < noRows; i++)
                        for (int j = 0; j < noColumns; j++)
                            this[i, j] = 1;
                    break;
            }
        }

        public int[,] GetMatrix(MatrixType type)
        {
            switch (type)
            {
                case MatrixType.Type_A:
                    GetMatrixTypeA();
                    break;
                case MatrixType.Type_B:
                    GetMatrixTypeB();
                    break;
                case MatrixType.Type_C:
                    GetMatrixTypeC();
                    break;
                case MatrixType.Type_D:
                    GetMatrixTypeD();
                    break;
                default:
                    break;
            }

            return this.matrix;
        }

        /// <summary>
        /// Construct in-memory LSH table, with n bins.
        /// </summary>
        /// <param name="d"></param>
        /// <param name="n"></param>
        /// <param name="L"></param>
        /// <param name="k"></param>
        /// <param name="type"></param>
        /// <returns></returns>
#else
        /// <summary>
        /// Construct in-memory LSH table, with n bins.
        /// </summary>
        /// <param name="d"></param>
        /// <param name="n"></param>
        /// <param name="L"></param>
        /// <param name="k"></param>
        /// <param name="type"></param>
        /// <returns></returns>
#endif
        public static CvLSH CreateMemoryLSH(int d, int n, int L, int k, MatrixType type)
        {
            return Cv.CreateMemoryLSH(d, n, L, k, type, 4, -1);
        }

        /// <summary>
        /// Construct in-memory LSH table, with n bins.
        /// </summary>
        /// <param name="d"></param>
        /// <param name="n"></param>
        /// <param name="L"></param>
        /// <param name="k"></param>
        /// <param name="type"></param>
        /// <param name="r"></param>
        /// <param name="seed"></param>
#else
        /// <summary>
        /// Construct in-memory LSH table, with n bins.
        /// </summary>
        /// <param name="d"></param>
        /// <param name="n"></param>
        /// <param name="L"></param>
        /// <param name="k"></param>
        /// <param name="type"></param>
        /// <param name="r"></param>
        /// <param name="seed"></param>
#endif
        public CvLSH(int d, int n, int L, int k, MatrixType type, double r, Int64 seed)
        {
            _ptr = CvInvoke.cvCreateMemoryLSH(d, n, L, k, type, r, seed);
            if (_ptr == IntPtr.Zero)
            {
                throw new OpenCvSharpException("Failed to create CvLSH");
            }
        }

        /// <summary>
        /// Construct a Locality Sensitive Hash (LSH) table, for indexing d-dimensional vectors of
        /// given type. Vectors will be hashed L times with k-dimensional p-stable (p=2) functions.
        /// </summary>
        /// <param name="ops">(not supported argument on OpenCvSharp)</param>
        /// <param name="d"></param>
        /// <param name="L"></param>
        /// <param name="k"></param>
        /// <param name="type"></param>
        /// <param name="r"></param>
        /// <param name="seed"></param>
        /// <returns></returns>
#else
        /// <summary>
        /// Construct a Locality Sensitive Hash (LSH) table, for indexing d-dimensional vectors of
        /// given type. Vectors will be hashed L times with k-dimensional p-stable (p=2) functions.
        /// </summary>
        /// <param name="ops">(not supported argument on OpenCvSharp)</param>
        /// <param name="d"></param>
        /// <param name="L"></param>
        /// <param name="k"></param>
        /// <param name="type"></param>
        /// <param name="r"></param>
        /// <param name="seed"></param>
        /// <returns></returns>
#endif
        public static CvLSH CreateLSH(IntPtr ops, int d, int L, int k, MatrixType type, double r, Int64 seed)
        {
            return Cv.CreateLSH(ops, d, L, k, type, r, seed);
        }

 public static extern IntPtr cvInitMatNDHeader(IntPtr mat, int dims, int[] sizes, MatrixType type, IntPtr data);

 public static extern IntPtr cvCreateMemoryLSH(int d, int n, int L, int k, MatrixType type, double r, Int64 seed);

 public static extern IntPtr cvCreateLSH(IntPtr ops, int d, int L, int k, MatrixType type, double r, Int64 seed);

 /// <summary>
 /// Visits the specified type.
 /// </summary>
 /// <param name="type">the type.</param>
 public override void Visit(MatrixType type)
 {
     Write("Matrix");
     ProcessInitialValueStatus = true;
 }

//.........这里部分代码省略.........

            // Buffer Rules
            buffer_type.Rule = TypeName("Buffer") + less_than + simple_type_or_type_name + ">";

            // Vectors Rules
            vector_type.AstNodeCreator = CreateVectorAst;
            vector_type.Rule = Keyword("vector") + less_than + scalars_or_typename + "," + number + ">";
            vector_type_list.Rule = vector_type;

            // Add all vector int1 int2 int3 int4... float1 float2 float3 float4... etc.
            foreach (var scalarTypeIt in scalarTypes)
            {
                var scalarType = scalarTypeIt;
                for (var dim = 1; dim <= 4; dim++)
                {
                    var vectorTypeInstance = new VectorType(scalarTypeIt, dim);
                    var nonGenericType = vectorTypeInstance.ToNonGenericType();
                    var name = nonGenericType.Name.Text;
                    vector_type_list.Rule |= new NonTerminal(name,
                        (ctx, node) =>
                        {
                                var typeName = vectorTypeInstance.ToNonGenericType(SpanConverter.Convert(node.Span));
                                node.AstNode = typeName;
                            }) { Rule = Keyword(name) };
                }
            }

            // Matrices
            matrix_type_simple.Rule = Keyword("matrix");
            matrix_type_simple.AstNodeCreator = (ctx, node) =>
                {
                    var typeName = Ast<TypeName>(node);
                    typeName.Name = new Identifier("matrix") { Span = SpanConverter.Convert(node.Span) };
                    typeName.TypeInference.TargetType = new MatrixType(ScalarType.Float, 4, 4);
                };

            matrix_type.Rule = Keyword("matrix") + less_than + scalars_or_typename + "," + number + "," + number + ">";
            matrix_type.AstNodeCreator = CreateMatrixAst;
            matrix_type_list.Rule = matrix_type | matrix_type_simple;

            // Add all matrix typedefs: int1x1 int1x2... float1x1 float1x2 float1x3 float1x4... etc.
            foreach (var scalarTypeIt in scalarTypes)
            {
                var scalarType = scalarTypeIt;
                for (var dimX = 1; dimX <= 4; dimX++)
                    for (var dimY = 1; dimY <= 4; dimY++)
                    {
                        var matrixTypeInstance = new MatrixType(scalarTypeIt, dimY, dimX);
                        var nonGenericType = matrixTypeInstance.ToNonGenericType();
                        var name = nonGenericType.Name.Text;

                        // var typeName = new TypeName(name) { Alias = matrixTypeInstance };
                        matrix_type_list.Rule |= new NonTerminal(
                            name,
                            (ctx, node) =>
                                {
                                    var typeName = matrixTypeInstance.ToNonGenericType(SpanConverter.Convert(node.Span));
                                    node.AstNode = typeName;
                                }) { Rule = Keyword(name) };
                    }
            }

            // Sampler types
            state_type.Rule = CreateRuleFromObjectTypes(
                StateType.BlendState,
                StateType.DepthStencilState,

 public static extern IntPtr cvCreateSparseMat(int dims, [In] int[] sizes, MatrixType type);

 public static extern IntPtr cvInitMatHeader(IntPtr mat, int rows, int cols, MatrixType type, IntPtr data, int step);