/*
Copyright (c) 2019 Ferhat Kurtulmuş
Boost Software License - Version 1.0 - August 17th, 2003
Permission is hereby granted, free of charge, to any person or organization
obtaining a copy of the software and accompanying documentation covered by
this license (the "Software") to use, reproduce, display, distribute,
execute, and transmit the Software, and to prepare derivative works of the
Software, and to permit third-parties to whom the Software is furnished to
do so, all subject to the following:
The copyright notices in the Software and this entire statement, including
the above license grant, this restriction and the following disclaimer,
must be included in all copies of the Software, in whole or in part, and
all derivative works of the Software, unless such copies or derivative
works are solely in the form of machine-executable object code generated by
a source language processor.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
*/

module opencvd.cvcore;

import core.stdc.stdint;
import core.stdc.stdlib;

import std.conv;

struct Size {
    int width;
    int height;
    
    alias rows = height;
    alias cols = width;
}

struct ByteArray {
    ubyte* data;
    int length;
}

struct CStrings {
    const char** strs;
    int length;
}

struct Scalar {
    double val1;
    double val2;
    double val3;
    double val4;
    
    static Scalar all(double val){
        return Scalar(val,val,val,val);
    }
    
    double opIndex(int i){
        double[4] tmp = [val1, val2, val3, val4];
        return tmp[i];
    }
    
    void opIndexAssign(double val, int i){
        double*[4] tmp = [&val1, &val2, &val3, &val4];
        *tmp[i] = val;
    }
    
    bool opEquals(Scalar b){
        if (this is b) return true;
        if ((this.val1 == b.val1)&&
            (this.val1 == b.val1)&&
            (this.val1 == b.val1)&&
            (this.val1 == b.val1))
                return true;
        return false;
    }
}

alias Color = Scalar;

struct Vec4f {
    float val1;
    float val2;
    float val3;
    float val4;
    
    static Vec4f all(float val){
        return Vec4f(val,val,val,val);
    }
    
    float opIndex(int i){
        float[4] tmp = [val1, val2, val3, val4];
        return tmp[i];
    }
    
    void opIndexAssign(float val, int i){
        float*[4] tmp = [&val1, &val2, &val3, &val4];
        *tmp[i] = val;
    }
}

struct Vec4fs {
    Vec4f* vec4fs;
    int length;
    // alias vec4fs this;// todo for all
    Vec4f opIndex(int i){
        return vec4fs[i];
    }
}

struct Vec3f {
    float val1;
    float val2;
    float val3;
    
    static Vec3f all(float val){
        return Vec3f(val,val,val);
    }
    
    float opIndex(int i){
        float[3] tmp = [val1, val2, val3];
        return tmp[i];
    }
    
    void opIndexAssign(float val, int i){
        float*[3] tmp = [&val1, &val2, &val3];
        *tmp[i] = val;
    }
}

struct Vec3fs{
    Vec3f* vec3fs;
    int length;
    
    Vec3f opIndex(int i){
        return vec3fs[i];
    }
}

struct Vec4i {
    int val1;
    int val2;
    int val3;
    int val4;
    
    static Vec4i all(int val){
        return Vec4i(val,val,val,val);
    }
    
    int opIndex(int i){
        int[4] tmp = [val1, val2, val3, val4];
        return tmp[i];
    }
    
    void opIndexAssign(int val, int i){
        int*[4] tmp = [&val1, &val2, &val3, &val4];
        *tmp[i] = val;
    }
}

struct Vec4is{
    Vec4i* vec4is;
    int length;
    
    Vec4i opIndex(int i){
        return vec4is[i];
    }
}

struct Vec3i {
    int val1;
    int val2;
    int val3;
    
    static Vec3i all(int val){
        return Vec3i(val,val,val);
    }
    
    int opIndex(int i){
        int[3] tmp = [val1, val2, val3];
        return tmp[i];
    }
    
    void opIndexAssign(int val, int i){
        int*[3] tmp = [&val1, &val2, &val3];
        *tmp[i] = val;
    }
}

struct Vec3is {
    Vec3i* vec3is;
    int length;
    
    Vec3i opIndex(int i){
        return vec3is[i];
    }
}

struct Vec2f {
    float val1;
    float val2;
    
    static Vec2f all(float val){
        return Vec2f(val,val);
    }
    
    float opIndex(int i){
        float[2] tmp = [val1, val2];
        return tmp[i];
    }
    
    void opIndexAssign(float val, int i){
        float*[2] tmp = [&val1, &val2];
        *tmp[i] = val;
    }
    
}

struct Vec2fs {
    Vec2f* vec2fs;
    int length;
    
    Vec2f opIndex(int i){
        return vec2fs[i];
    }
}

struct Vec6f {
    float val1;
    float val2;
    float val3;
    float val4;
    float val5;
    float val6;
    
    static Vec6f all(float val){
        return Vec6f(val,val,val,val,val,val);
    }
    
    float opIndex(int i){
        float[6] tmp = [val1, val2, val3, val4, val5, val6];
        return tmp[i];
    }
    
    void opIndexAssign(float val, int i){
        float*[6] tmp = [&val1, &val2, &val3, &val4, &val5, &val6];
        *tmp[i] = val;
    }
}

struct Vec6fs {
    Vec6f* vec6fs;
    int length;
    
    Vec6f opIndex(int i){
        return vec6fs[i];
    }
}

struct Hierarchy {
    Scalar* scalars;
    int length;
    
    Scalar opIndex(int i){
        return scalars[i];
    }
}

alias Colors = Hierarchy;

struct IntVector {
    int* val;
    int length;
    
    int opIndex(int i){
        return val[i];
    }
}

struct FloatVector {
    float* val;
    int length;
    
    float opIndex(int i){
        return val[i];
    }
}

struct DoubleVector {
    double* val;
    int length;
    
    double opIndex(int i){
        return val[i];
    }
}

struct CharVector {
    char* val;
    int length;
    
    char opIndex(int i){
        return val[i];
    }
}

struct Rect {
    int x;
    int y;
    int width;
    int height;
}

bool contains(Rect r, Point p){
    return Rect_Contains(r, p);
}

struct Rects {
    Rect* rects;
    int length;
    
    Rect opIndex(int i){
        return rects[i];
    }
}

struct RotatedRect {
    Contour pts;
    Rect boundingRect;
    Point center;
    Size size;
    double angle;
    
    Point[] points(){
        return pts.points[0..pts.length];
    }
    
    static RotatedRect opCall(Point center, Size size, double angle){
        RotatedRect rr = New_RotatedRect(center, size, angle);
        Point[] ps = rr.pts.points[0..rr.pts.length].dup;
        Points_Close(rr.pts);
        RotatedRect ret = {Contour(ps.ptr, cast(int)ps.length), rr.boundingRect, rr.center, rr.size, rr.angle};
        return ret;
    }
}

struct RotatedRects {
    RotatedRect* rects;
    int length;
}

struct Point {
    int x;
    int y;

    int opCmp(Point rhs) {
        if (x < rhs.x) return -1;
        if (rhs.x < x) return 1;
        return 0;
    }
    
    void toString(scope void delegate(const(char)[]) sink) const {
        import std.format;
        sink("(");
        formattedWrite(sink, "%d", x);
        sink(",");
        formattedWrite(sink, "%d", y);
        sink(")");
    }
    
    Point2f asFloat(){
        return Point2f(x.to!float, y.to!float);
    }
    
    Point opBinary(string op)(double a){
        static if (op == "+"){
            return Point((x+a).to!int,(y+a).to!int);
        }
        else static if (op == "-"){
            return Point((x-a).to!int,(y-a).to!int);
        }
        else static if (op == "*"){
            return Point((x*a).to!int,(y*a).to!int);
        }
    }
    
    Point opBinary(string op)(Point a){
        static if (op == "+"){
            return Point((x+a.x).to!int,(y+a.y).to!int);
        }
        else static if (op == "-"){
            return Point((x-a.x).to!int,(y-a.y).to!int);
        }
    }
}

struct Point2f {
    float x;
    float y;
    
    Point asInt(){
        return Point(x.to!int, y.to!int);
    }
    
    Point2f opBinary(string op)(double a){
        static if (op == "+"){
            return Point2f((x+a).to!float,(y+a).to!float);
        }
        else static if (op == "-"){
            return Point2f((x-a).to!float,(y-a).to!float);
        }else static if (op == "*"){
            return Point2f(float(x*a),float(y*a));
        }
    }
    
    Point2f opBinary(string op)(Point2f a){
        static if (op == "+"){
            return Point2f((x+a.x).to!float,(y+a.y).to!float);
        }
        else static if (op == "-"){
            return Point2f((x-a.x).to!float,(y-a.y).to!float);
        }
    }
}

struct Point2fs {
    Point2f* points;
    int length;
    
    Point2f opIndex(int i){
        return points[i];
    }
}

struct Point2fss {
    Point2fs* point2fss;
    int length;
    
    Point2fs opIndex(int i){
        return point2fss[i];
    }
}

struct Points {
    Point* points;
    int length;
    
    Point opIndex(int i){
        return points[i];
    }
}

struct Pointss {
    Points* pointss;
    int length;
    
    Points opIndex(int i){
        return pointss[i];
    }
}

alias Contour = Points;

Point[] asInt(Point2f[] ip){
    
    Point[] ret; ret.length = ip.length;
    foreach(j; 0..ip.length){
        Point p = Point(ip[j].x.to!int, ip[j].y.to!int);
        ret[j] = p;
    }
    return ret;
}

Point[][] asInt(Point2f[][] pts){
    
    Point[][] ret; ret.length = pts.length;
    foreach(i; 0..pts.length){
        Point2f[] ip = pts[i];
        Point[] iip; iip.length = ip.length;
        foreach(j; 0..ip.length){
            Point p = Point(ip[j].x.to!int, ip[j].y.to!int);
            iip[j] = p;
        }
        ret[i] = iip;
    }
    return ret;
}

Point2f[] asFloat(Point[] ip){
    
    Point2f[] ret; ret.length = ip.length;
    foreach(j; 0..ip.length){
        Point2f p = Point2f(ip[j].x.to!float, ip[j].y.to!float);
        ret[j] = p;
    }
    return ret;
}

Point2f[][] asFloat(Point[][] pts){
    
    Point2f[][] ret; ret.length = pts.length;
    foreach(i; 0..pts.length){
        Point2f[] iip;
        Point[] ip = pts[i];
        iip.length = ip.length;
        foreach(j; 0..ip.length){
            Point2f p = Point2f(ip[j].x.to!float, ip[j].y.to!float);
            iip[j] = p;
        }
        ret[i] = iip;
    }
    return ret;
}

struct Point2d {
    double x;
    double y;
    
    Point asInt(){
        return Point(x.to!int, y.to!int);
    }
    
    Point2f asFloat(){
        return Point2f(x.to!float, y.to!float);
    }
    
    Point2d opBinary(string op)(double a){
        static if(op == "*")
            return Point2d(double(x*a),double(y*a));
        else static assert(0, "Operator "~op~" not implemented");
    }
}

struct Contours {
    Contour* contours;
    int length;
    
    Contour opIndex(int i){
        return contours[i];
    }
}

struct KeyPoint {
    double x;
    double y;
    double size;
    double angle;
    double response;
    int octave;
    int classID;
    
    Point2f pt(){
        return Point2f(x.to!float, y.to!float);
    }
}

struct KeyPoints {
    KeyPoint* keypoints;
    int length;
    
    KeyPoint opIndex(int i){
        return keypoints[i];
    }
}

struct DMatch {
    int queryIdx;
    int trainIdx;
    int imgIdx;
    float distance;
}

struct DMatches {
    DMatch* dmatches;
    int length;
    
    DMatch opIndex(int i){
        return dmatches[i];
    }
}

struct MultiDMatches {
    DMatches* dmatches;
    int length;
    
    DMatches opIndex(int i){
        return dmatches[i];
    }
}

struct Moment {
    double m00;
    double m10;
    double m01;
    double m20;
    double m11;
    double m02;
    double m30;
    double m21;
    double m12;
    double m03;

    double mu20;
    double mu11;
    double mu02;
    double mu30;
    double mu21;
    double mu12;
    double mu03;

    double nu20;
    double nu11;
    double nu02;
    double nu30;
    double nu21;
    double nu12;
    double nu03;
}

struct Mat {
    void* p;
    
    int rows() {return Mat_Rows(this);}
    int cols() {return Mat_Cols(this);}
    int type() {return Mat_Type(this);}
    int channels(){return Mat_Channels(this);}
    int step() {return Mat_Step(this);}
    int dims() {return Mat_Dims(this);}
    int height() {return rows();}
    int width() {return cols();}
    Size size() {return Size(width(), height());}
    int size(int i){return Mat_SizeFromInd(this, i);}
    int total() {return Mat_Total(this);}
    int flatLength() {return Mat_FlatLength(this);}
    void* rawDataPtr() {return Mat_DataPtrNoCast(this);}
    ubyte* ptr(int i = 0) { return Mat_RowPtr(this, i);}
    ubyte* ptr(int row, int col) { return Mat_RowPtr2(this, row, col);}
    void* ptr(int i0, int i1, int i2) { return Mat_RowPtr3(this, i0, i1, i2);}
    
    Scalar mean() {return Mat_Mean(this);}
    Mat sqrt() {return Mat_Sqrt(this);}
    
    bool isContinuous(){
        return Mat_IsContinuous(this);
    }
    
    bool isSubmatrix(){
        return Mat_IsSubmatrix(this);
    }
    
    void locateROI(Size* wholeSize, Point* ofs){
        Mat_LocateROI(this, wholeSize, ofs);
    }
    
    Mat opCall(Rect r){
        return matFromRect(this, r);
    }
    
    static Mat opCall(){
        return newMat();
    }
    
    static Mat opCall(int rows, int cols, int mt ){
        return Mat_NewWithSize(rows, cols, mt);
    }
    
    static Mat opCall(Size sz, int mt ){
        return Mat_NewWithSize(sz.height, sz.width, mt);
    }
    
    static Mat opCall( const Scalar ar, int type){
        return Mat_NewFromScalar(ar, type);
    }

    static Mat opCall(const Scalar ar, int rows, int cols, int type){
        return Mat_NewWithSizeFromScalar(ar, rows, cols, type);
    }

    static Mat opCall(int rows, int cols, int type, ByteArray buf){
        return Mat_NewFromBytes(rows, cols, type, buf);
    }

    static Mat opCall(Mat m, int rows, int cols, int type, int prows, int pcols){
        return Mat_FromPtr(m, rows, cols, type, prows, pcols);
    }

    static Mat opCall(int rows, int cols, int type, void* data){
        return Mat_FromArrayPtr(rows, cols, type, data);
    }
    
    static Mat opCall(Point[] points){
        return newMatFromContour(points);
    }
    
    static Mat opCall(int[] data){ 
        return Mat_FromIntVector(IntVector(data.ptr, data.length.to!int));
    }
    
    static Mat opCall(float[] data){ 
        return Mat_FromFloatVector(FloatVector(data.ptr, data.length.to!int));
    }
    
    Mat opCall(Range rowRange, Range colRange = Range.all()){
        return Mat_FromRanges(this, rowRange, colRange);
    }
    
    int opDollar(int dimension)() {
        static if (dimension == 0) {
            return this.rows;

        } else static if (dimension == 1){
            return this.cols;
        }
    }
    
    Range opSlice(size_t dimension)(int start, int end){
        return Range(start, end);
    }
    
    /* syntactic sugar for Mat slicing
     * Based on: http://ddili.org/ders/d.en/templates_more.html
     * Mat m = img[0..$-50, 50 .. 200];
    */
    Mat opIndex(A...)(A arguments){
        Range rowRange = Range(0, this.rows);
        Range colRange = Range(0, this.cols);
        
        Range[2] ranges = [rowRange, colRange];
        
        foreach (dimension, a; arguments) {
            static if (is (typeof(a) == Range)) {
                ranges[dimension] = a;
            } else
            static if (is (typeof(a) : int) || is (typeof(a) : size_t)) {
                ranges[dimension] = Range(a, a + 1);
            }
            else {
                static assert( false, "Invalid index type!");
            }
        }
        
        return Mat_FromRanges(this, ranges[0], ranges[1]);
    }
    
    Mat opIndexAssign(A...)(Scalar value, A arguments){
        Mat subMatrix = opIndex(arguments);
        subMatrix = value;
        return subMatrix;
    }
    
    Mat opCall(Range[] ranges){
        return Mat_FromMultiRanges(this, RangeVector(ranges.ptr, ranges.length.to!int));
    }
    
    Mat row(int y){
        return Mat_HeaderFromRow(this, y);
    }
    
    Mat col(int x){
        return Mat_HeaderFromCol(this, x);
    }
    
    void opAssign(Color c){
        this.setTo(c);
    }
    
    Mat opBinary(string op, V)(V a){
        static if (op == "*"){
            static if (is(V == ubyte)){
                multiplyUChar(this, a);
            } else
            static if (is(V == int)){
                Mat_MultiplyInt(this, a);
            } else
            static if (is(V == float)){
                Mat_MultiplyFloat(this, a);
            } else
            static if (is(V == double)){
                Mat_MultiplyDouble(this, a);
            }
            static if (is(V == Mat)){
                Mat_Multiply(this, a, this);
            }
            return this;
        } else
        static if (op == "/"){
            static if (is(V == float)){
                Mat_MultiplyFloat(this, 1.0f/a);
            } else
            static if (is(V == int)){
                Mat_DivideInt(this, a);
            } else
            static if (is(V == double)){
                Mat_MultiplyDouble(this, 1.0/a);
            }
            return this;
        } else
        static if (op == "+"){
            static if (is(V == int)){
                Mat_AddInt(this, a);
            } else
            static if (is(V == float)){
                Mat_AddFloat(this, a);
            }else
            static if (is(V == Mat)){
                add(this, a, this);
            } else
            static if (is(V == Scalar)){
                Mat_AddScalar(this, a);
            }
            return this;
        } else
        static if (op == "-"){
            static if (is(V == int)){
                Mat_SubtractInt(this, a);
            } else
            static if (is(V == float)){
                Mat_SubtractFloat(this, a);
            } else
            static if (is(V == Mat)){
                matSubtract(this, a, this);
            } else
            static if (is(V == Scalar)){
                Mat_AddScalar(this, Scalar(-a.val1, -a.val2, -a.val3, -a.val4));
            }
            return this;
        } else
        static assert(0, "Operator "~op~" not implemented for type " ~ V.stringof);
    }

    // so sad that the D does not support struct > 5
    Mat EQInt(int a){
        return Mat_EQInt(this, a);
    }
    
    Mat GTInt(int a){
        return Mat_GTInt(this, a);
    }
    
    Mat GEInt(int a){
        return Mat_GEInt(this, a);
    }
    
    Mat LTInt(int a){
        return Mat_LTInt(this, a);
    }
    
    Mat LEInt(int a){
        return Mat_LEInt(this, a);
    }
    Mat NEInt(int a){
        return Mat_NEInt(this, a);
    }
    
    Mat EQDouble(double a){
        return Mat_EQDouble(this, a);
    }
    
    Mat GTDouble(double a){
        return Mat_GTDouble(this, a);
    }
    
    Mat GEDouble(double a){
        return Mat_GEDouble(this, a);
    }
    
    Mat LTDouble(double a){
        return Mat_LTDouble(this, a);
    }
    
    Mat LEDouble(double a){
        return Mat_LEDouble(this, a);
    }
    
    Mat NEDouble(double a){
        return Mat_NEDouble(this, a);
    }
    
    string type2str(){
        import std.conv;
        import core.stdc.stdlib;
        
        auto chr = _type2str(type());
        string stype = chr.to!string.dup;
        free(chr);
        return stype;
    }

    ByteArray byteArray(){ // no reason to use this now. will be removed soon.
        return Mat_DataPtr(this);
    }

    // retuns d array. use it like: double[] myarray = mat.array!double;
    T[] array(T)(){
        T* ret = cast(T*)rawDataPtr();
        return ret[0..flatLength()];
    }
    
    Scalar opIndex(int row, int col){
        return at(row, col);
    }
    
    /* Setters */
    void opIndexAssign(Scalar color, int row, int col){
        setColorAt(color, row, col);
    }
    
    void opIndexAssign(T)(T val, int row, int col){
        assert(this.channels == 1, "This is only allowed for single-channel Mat types!");
        this.set!T(row, col, cast(T)val);
    }
    
    void setColorAt(Scalar color, int row, int col){
        assert(this.channels > 1, "Color assignment is only allowed for multi-channel Mat types!");
        Mat_SetColorAt(this, color, row, col);
    }
    
    void set(T)(int row, int col, T val){
        static if (is(T == float)){
            setFloatAt(row, col, val);
        } else static if (is(T == double)){
            setDoubleAt(row, col, val);
        } else static if (is(T == int)){
            setIntAt(row, col, val);
        } else static if (is(T == ubyte)){
            setUCharAt(row, col, val);
        } else static if (is(T == byte)){
            setSCharAt(row, col, val);
        } else static if (is(T == short)){
            setShortAt(row, col, val);
        }
    }
    
    void setUCharAt(int row, int col, ubyte val){
        Mat_SetUChar(this, row, col, val);
    }

    void setUChar3At( int x, int y, int z, ubyte val){
        Mat_SetUChar3(this, x, y, z, val);
    }

    void setSCharAt(int row, int col, byte val){
        Mat_SetSChar(this, row, col, val);
    }

    void setSChar3At(int x, int y, int z, byte val){
        Mat_SetSChar3(this, x, y, z, val);
    }
    
    void setShortAt(int row, int col, short val){
        Mat_SetShort(this, row, col, val);    
    }
    
    void setShort3At(int x, int y, int z, short val){
        Mat_SetShort3(this, x, y, z, val);   
    }
    
    void setIntAt(int row, int col, int val){
        Mat_SetInt(this, row, col, val);
    }
    
    void setInt3At(int x, int y, int z, int val){
        Mat_SetInt3(this, x, y, z, val);
    }
    
    void setFloatAt(int row, int col, float val){
        Mat_SetFloat(this, row, col, val);
    }
    
    void setFloat3At(int x, int y, int z, float val){
        Mat_SetFloat3(this, x, y, z, val);
    }
    
    void setDoubleAt(int row, int col, double val){
        Mat_SetDouble(this, row, col, val);
    }

    void setDouble3At(int x, int y, int z, double val){
        Mat_SetDouble3(this, x, y, z, val);
    }

    /* Getters */
    
    T at(T)(int row, int col){
        static if (is(T == float)){
            return getFloatAt(row, col);
        } else static if (is(T == double)){
            return getDoubleAt(row, col);
        } else static if (is(T == int)){
            return getIntAt(row, col);
        } else static if (is(T == ubyte)){
            return getUCharAt(row, col);
        } else static if (is(T == byte)){
            return getSCharAt(row, col);
        } else static if (is(T == short)){
            return getShortAt(row, col);
        }
    }
    
    T at(T)(int flatInd){
        T* ret = cast(T*)rawDataPtr();
        return ret[flatInd];
    }
    
    Color at(int row, int col){
        return Mat_ColorAt(this, row, col);
    }
    
    ubyte getUCharAt(int row, int col){
        return Mat_GetUChar(this, row, col);
    }

    ubyte getUChar3At(int x, int y, int z){
        return Mat_GetUChar3(this, x, y, z);
    }

    byte getSCharAt(int row, int col){
        return Mat_GetSChar(this, row, col);
    }

    byte getSChar3At(int x, int y, int z){
        return Mat_GetSChar3(this, x, y, z);
    }

    short getShortAt(int row, int col){
        return Mat_GetShort(this, row, col);
    }

    short getShort3At(int x, int y, int z){
        return Mat_GetShort3(this, x, y, z);
    }

    int getIntAt(int row, int col){
        return Mat_GetInt(this, row, col);
    }

    int getInt3At(int x, int y, int z){
        return Mat_GetInt3(this, x, y, z);
    }

    float getFloatAt(int row, int col){
        return Mat_GetFloat(this, row, col);
    }

    float getFloat3At(int x, int y, int z){
        return Mat_GetFloat3(this, x, y, z);
    }

    double getDoubleAt(int row, int col){
        return Mat_GetDouble(this, row, col);
    }

    double getDouble3At(int x, int y, int z){
        return Mat_GetDouble3(this, x, y, z);
    }
    
    Mat rowRange(int startrow, int endrow){
        return Mat_RowRange1(this, startrow, endrow);
    }
    
}

struct Mats {
    Mat* mats;
    int length;
    
    Mat opIndex(int i){
        return mats[i];
    }
}

enum: int {
    // MatChannels1 is a single channel Mat.
    MatChannels1 = 0,

    // MatChannels2 is 2 channel Mat.
    MatChannels2 = 8,

    // MatChannels3 is 3 channel Mat.
    MatChannels3 = 16,

    // MatChannels4 is 4 channel Mat.
    MatChannels4 = 24
}

enum: int {
    // CV8U is a Mat of 8-bit unsigned int
    CV8U = 0,

    // CV8S is a Mat of 8-bit signed int
    CV8S = 1,

    // CV16U is a Mat of 16-bit unsigned int
    CV16U = 2,

    // CV16S is a Mat of 16-bit signed int
    CV16S = 3,

    // CV16SC2 is a Mat of 16-bit signed int with 2 channels
    CV16SC2 = CV16S + MatChannels2,

    // CV32S is a Mat of 32-bit signed int
    CV32S = 4,

    // CV32F is a Mat of 32-bit float
    CV32F = 5,

    // CV64F is a Mat of 64-bit float
    CV64F = 6,

    // CV8UC1 is a Mat of 8-bit unsigned int with a single channel
    CV8UC1 = CV8U + MatChannels1,

    // CV8UC2 is a Mat of 8-bit unsigned int with 2 channels
    CV8UC2 = CV8U + MatChannels2,

    // MatTypeCV8UC3 is a Mat of 8-bit unsigned int with 3 channels
    CV8UC3 = CV8U + MatChannels3,

    // MatTypeCV8UC4 is a Mat of 8-bit unsigned int with 4 channels
    CV8UC4 = CV8U + MatChannels4
}

alias CV_8U = CV8U;
alias CV_8S = CV8S;
alias CV_16U = CV16U;
alias CV_16S = CV16S;
alias CV_16SC2 = CV16SC2;
alias CV_32S = CV32S;
alias CV_32F = CV32F;
alias CV_64F = CV64F;
alias CV_8UC1 = CV8UC1;
alias CV_8UC2 = CV8UC2;
alias CV_8UC3 = CV8UC3;
alias CV_8UC4 = CV8UC4;

alias MatType = int;

extern (C) {
    void Close_Vec6fs(Vec6fs vec6fs);
    void Close_Vec4fs(Vec4fs vec4fs);
    void Close_Vec3fs(Vec3fs vec3fs);
    void Close_Vec2fs(Vec2fs vec2fs);
    void Close_Vec4is(Vec4is vec4is);
    void Close_Vec3is(Vec3is vec3is);
    void Close_IntVector(IntVector iv);
    void Close_DoubleVector(DoubleVector iv);
    void Close_FloatVector(FloatVector iv);
    
    void Contours_Close(Contours cs);
    void KeyPoints_Close(KeyPoints ks);
    void Rects_Close(Rects rs);
    void Mats_Close(Mats mats);
    void Point_Close(Point p);
    void Points_Close(Points ps);
    void DMatches_Close(DMatches ds);
    void MultiDMatches_Close(MultiDMatches mds);
}

private extern (C) {
    
    Mat Mat_New();
    Mat Mat_NewWithSize(int rows, int cols, int type);
    Mat Mat_NewFromScalar(const Scalar ar, int type);
    Mat Mat_NewWithSizeFromScalar(const Scalar ar, int rows, int cols, int type);
    Mat Mat_NewFromBytes(int rows, int cols, int type, ByteArray buf);
    Mat Mat_FromPtr(Mat m, int rows, int cols, int type, int prows, int pcols);
    Mat Mat_FromArrayPtr(int rows, int cols, int type, void* data);
    Mat Mat_FromFloatVector(FloatVector vec);
    Mat Mat_FromIntVector(IntVector vec);
    Mat Mat_HeaderFromRow(Mat src, int y);
    Mat Mat_HeaderFromCol(Mat src, int x);
    Mat Mat_RowRange1(Mat src, int startrow, int endrow);
    Mat Mat_FromRanges(Mat src, Range rowRange, Range colRange);
    Mat Mat_FromMultiRanges(Mat src, RangeVector rngs);
    Mat Mat_FromContour(Contour points);
    ubyte* Mat_RowPtr(Mat m, int i);
    ubyte* Mat_RowPtr2(Mat m, int row, int col);
    void* Mat_RowPtr3(Mat m, int i0, int i1, int i2);
    int Mat_CV_MAKETYPE(int depth, int cn);
    
    int Mat_Rows(Mat m);
    int Mat_Cols(Mat m);
    int Mat_Type(Mat m);
    int Mat_Channels(Mat m);
    int Mat_Step(Mat m);
    int Mat_Dims(Mat m);
    int Mat_SizeFromInd(Mat m, int i);
    bool Mat_IsContinuous(Mat src);
    bool Mat_IsSubmatrix(Mat src);
    void Mat_LocateROI(Mat src, Size* wholeSize, Point* ofs);
    
    char* _type2str(int type);

    ByteArray Mat_DataPtr(Mat m);
    int Mat_FlatLength(Mat src);
    void* Mat_DataPtrNoCast(Mat src);
    Scalar Mat_ColorAt(Mat src, int row, int col);
    
    Mat Mat_Reshape(Mat m, int cn, int rows);

    void Mat_Close(Mat m);
    int Mat_Empty(Mat m);
    Mat Mat_Clone(Mat m);
    void Mat_CopyTo(Mat m, Mat dst);
    void Mat_CopyToWithMask(Mat m, Mat dst, Mat mask);
    void Mat_ConvertTo(Mat m, Mat dst, int type);
    void Mat_convertTo2(Mat m, Mat dst, int rtype, double alpha, double beta);

    int Mat_Total(Mat m);
    Scalar Mat_Mean(Mat m);
    Mat Mat_Sqrt(Mat m);
    
    void Mat_SetColorAt(Mat src, Scalar color, int row, int col);
    void Mat_SetTo(Mat m, Scalar value);
    void Mat_SetToWithMask(Mat m, Scalar value, Mat mask);
    void Mat_SetUChar(Mat m, int row, int col, uint8_t val);
    void Mat_SetUChar3(Mat m, int x, int y, int z, uint8_t val);
    void Mat_SetSChar(Mat m, int row, int col, int8_t val);
    void Mat_SetSChar3(Mat m, int x, int y, int z, int8_t val);
    void Mat_SetShort(Mat m, int row, int col, int16_t val);
    void Mat_SetShort3(Mat m, int x, int y, int z, int16_t val);
    void Mat_SetInt(Mat m, int row, int col, int32_t val);
    void Mat_SetInt3(Mat m, int x, int y, int z, int32_t val);
    void Mat_SetFloat(Mat m, int row, int col, float val);
    void Mat_SetFloat3(Mat m, int x, int y, int z, float val);
    void Mat_SetDouble(Mat m, int row, int col, double val);
    void Mat_SetDouble3(Mat m, int x, int y, int z, double val);

    uint8_t Mat_GetUChar(Mat m, int row, int col);
    uint8_t Mat_GetUChar3(Mat m, int x, int y, int z);
    int8_t Mat_GetSChar(Mat m, int row, int col);
    int8_t Mat_GetSChar3(Mat m, int x, int y, int z);
    int16_t Mat_GetShort(Mat m, int row, int col);
    int16_t Mat_GetShort3(Mat m, int x, int y, int z);
    int32_t Mat_GetInt(Mat m, int row, int col);
    int32_t Mat_GetInt3(Mat m, int x, int y, int z);
    float Mat_GetFloat(Mat m, int row, int col);
    float Mat_GetFloat3(Mat m, int x, int y, int z);
    double Mat_GetDouble(Mat m, int row, int col);
    double Mat_GetDouble3(Mat m, int x, int y, int z);

    Mat Mat_Region(Mat m, Rect r);
    void Mat_PatchNaNs(Mat m);
    
    void Mat_MultiplyInt(Mat m, int val);
    void Mat_DivideInt(Mat m, int val);
    void Mat_AddDouble(Mat m, double val);
    void Mat_SubtractDouble(Mat m, double val);
    void Mat_AddInt(Mat m, int val);
    void Mat_SubtractInt(Mat m, int val);
    void Mat_AddScalar(Mat m, Scalar s);
    
    Mat Mat_EQInt(Mat m, int a);
    Mat Mat_GTInt(Mat m, int a);
    Mat Mat_GEInt(Mat m, int a);
    Mat Mat_LTInt(Mat m, int a);
    Mat Mat_LEInt(Mat m, int a);
    Mat Mat_NEInt(Mat m, int a);

    Mat Mat_EQDouble(Mat m, double a);
    Mat Mat_GTDouble(Mat m, double a);
    Mat Mat_GEDouble(Mat m, double a);
    Mat Mat_LTDouble(Mat m, double a);
    Mat Mat_LEDouble(Mat m, double a);
    Mat Mat_NEDouble(Mat m, double a);
    
    void Mat_AddUChar(Mat m, uint8_t val);
    void Mat_SubtractUChar(Mat m, uint8_t val);
    void Mat_MultiplyUChar(Mat m, uint8_t val);
    void Mat_DivideUChar(Mat m, uint8_t val);
    void Mat_AddFloat(Mat m, float val);
    void Mat_SubtractFloat(Mat m, float val);
    void Mat_MultiplyFloat(Mat m, float val);
    void Mat_MultiplyDouble(Mat m, double val);
    void Mat_DivideFloat(Mat m, float val);

    void LUT(Mat src, Mat lut, Mat dst);

    void Mat_AbsDiff(Mat src1, Mat src2, Mat dst);
    void Mat_Add(Mat src1, Mat src2, Mat dst);
    void Mat_AddWeighted(Mat src1, double alpha, Mat src2, double beta, double gamma, Mat dst);
    void Mat_BitwiseAnd(Mat src1, Mat src2, Mat dst);
    void Mat_BitwiseAndWithMask(Mat src1, Mat src2, Mat dst, Mat mask);
    void Mat_BitwiseNot(Mat src1, Mat dst);
    void Mat_BitwiseNotWithMask(Mat src1, Mat dst, Mat mask);
    void Mat_BitwiseOr(Mat src1, Mat src2, Mat dst);
    void Mat_BitwiseOrWithMask(Mat src1, Mat src2, Mat dst, Mat mask);
    void Mat_BitwiseXor(Mat src1, Mat src2, Mat dst);
    void Mat_BitwiseXorWithMask(Mat src1, Mat src2, Mat dst, Mat mask);
    void Mat_Compare(Mat src1, Mat src2, Mat dst, int ct);
    void Mat_CompareWithScalar(Mat src1, Scalar src2, Mat dst, int ct);
    void Mat_BatchDistance(Mat src1, Mat src2, Mat dist, int dtype, Mat nidx, int normType, int K, Mat mask, int update, bool crosscheck);
    int Mat_BorderInterpolate(int p, int len, int borderType);
    void Mat_CalcCovarMatrix(Mat samples, Mat covar, Mat mean, int flags, int ctype);
    void Mat_CartToPolar(Mat x, Mat y, Mat magnitude, Mat angle, bool angleInDegrees);
    bool Mat_CheckRange(Mat m);
    void Mat_CompleteSymm(Mat m, bool lowerToUpper);
    void Mat_ConvertScaleAbs(Mat src, Mat dst, double alpha, double beta);
    void Mat_CopyMakeBorder(Mat src, Mat dst, int top, int bottom, int left, int right, int borderType, Scalar value);
    int Mat_CountNonZero(Mat src);
    void Mat_DCT(Mat src, Mat dst, int flags);
    double Mat_Determinant(Mat m);
    void Mat_DFT(Mat m, Mat dst, int flags);
    void Mat_Divide(Mat src1, Mat src2, Mat dst);
    bool Mat_Eigen(Mat src, Mat eigenvalues, Mat eigenvectors);
    void Mat_EigenNonSymmetric(Mat src, Mat eigenvalues, Mat eigenvectors);
    void Mat_Exp(Mat src, Mat dst);
    void Mat_ExtractChannel(Mat src, Mat dst, int coi);
    void Mat_FindNonZero(Mat src, Mat idx);
    void Mat_Flip(Mat src, Mat dst, int flipCode);
    void Mat_Gemm(Mat src1, Mat src2, double alpha, Mat src3, double beta, Mat dst, int flags);
    int Mat_GetOptimalDFTSize(int vecsize);
    void Mat_Hconcat(Mat src1, Mat src2, Mat dst);
    void Mat_Vconcat(Mat src1, Mat src2, Mat dst);
    void Rotate(Mat src, Mat dst, int rotationCode);
    void Mat_Idct(Mat src, Mat dst, int flags);
    void Mat_Idft(Mat src, Mat dst, int flags, int nonzeroRows);
    void Mat_InRange(Mat src, Mat lowerb, Mat upperb, Mat dst);
    void Mat_InRangeWithScalar(Mat src, const Scalar lowerb, const Scalar upperb, Mat dst);
    void Mat_InsertChannel(Mat src, Mat dst, int coi);
    double Mat_Invert(Mat src, Mat dst, int flags);
    void Mat_Log(Mat src, Mat dst);
    void Mat_Magnitude(Mat x, Mat y, Mat magnitude);
    void Mat_Max(Mat src1, Mat src2, Mat dst);
    void Mat_MeanStdDev(Mat src, Mat dstMean, Mat dstStdDev);
    void Mat_Merge(Mats mats, Mat dst);
    void Mat_Merge2(Mats mats, int count, Mat dst);
    void Mat_Min(Mat src1, Mat src2, Mat dst);
    void Mat_MinMaxIdx(Mat m, double* minVal, double* maxVal, int* minIdx, int* maxIdx);
    void Mat_MinMaxLoc(Mat m, double* minVal, double* maxVal, Point* minLoc, Point* maxLoc);
    void Mat_MinMaxLoc2(Mat a, double* minVal, double* maxVal, int* minIdx, int* maxIdx);
    void Mat_MulSpectrums(Mat a, Mat b, Mat c, int flags);
    void Mat_Multiply(Mat src1, Mat src2, Mat dst);
    void Mat_Normalize(Mat src, Mat dst, double alpha, double beta, int typ);
    double Norm(Mat src1, int normType);
    void Mat_PerspectiveTransform(Mat src, Mat dst, Mat tm);
    bool Mat_Solve(Mat src1, Mat src2, Mat dst, int flags);
    int Mat_SolveCubic(Mat coeffs, Mat roots);
    double Mat_SolvePoly(Mat coeffs, Mat roots, int maxIters);
    void Mat_Reduce(Mat src, Mat dst, int dim, int rType, int dType);
    void Mat_Repeat(Mat src, int nY, int nX, Mat dst);
    void Mat_ScaleAdd(Mat src1, double alpha, Mat src2, Mat dst);
    void Mat_Sort(Mat src, Mat dst, int flags);
    void Mat_SortIdx(Mat src, Mat dst, int flags);
    void Mat_Split(Mat src, Mats* mats);
    Mats Mat_Split2(Mat src);
    void Mat_Subtract(Mat src1, Mat src2, Mat dst);
    Scalar Mat_Trace(Mat src);
    void Mat_Transform(Mat src, Mat dst, Mat tm);
    void Mat_Transpose(Mat src, Mat dst);
    void Mat_PolarToCart(Mat magnitude, Mat degree, Mat x, Mat y, bool angleInDegrees);
    void Mat_Pow(Mat src, double power, Mat dst);
    void Mat_Phase(Mat x, Mat y, Mat angle, bool angleInDegrees);
    Scalar Mat_Sum(Mat src1);
    
    RotatedRect New_RotatedRect(Point center, Size size, double angle);
    
    TermCriteria TermCriteria_New(int typ, int maxCount, double epsilon);
    double Get_TermCriteria_Epsilon(TermCriteria tc);
    int Get_TermCriteria_MaxCount(TermCriteria tc);
    int Get_TermCriteria_Type(TermCriteria tc);
    void TermCriteria_Close(TermCriteria tc);
    
    int64_t GetCVTickCount();
    double GetTickFrequency();
    
    Mat Mat_ZerosFromRC(int rows, int cols, int type);
    Mat Mat_ZerosFromSize(Size sz, int type);
    Mat Mat_OnesFromRC(int rows, int cols, int type);
    Mat Mat_OnesFromSize(Size sz, int type);
    
    double Mat_Dot(Mat m1, Mat m2);
    Mat Mat_Diag(Mat src, int d);
    Mat Mat_EyeFromRC(int rows, int cols, int type);
    
    bool Rect_Contains(Rect r, Point p);
    
    PCA PCA_New();
    PCA PCA_NewWithMaxComp(Mat data, Mat mean, int flags, int maxComponents);
    PCA PCA_NewWithRetVar(Mat data, Mat mean, int flags, double retainedVariance);
    void PCA_BackProject(PCA pca, Mat vec, Mat result);
    void PCA_Project(PCA pca, Mat vec, Mat result);
    Mat PCA_Eigenvalues(PCA pca);
    Mat PCA_Eigenvectors(PCA pca);
    Mat PCA_Mean(PCA pca);
    
    double Kmeans(Mat data, int K, Mat bestLabels,
        TermCriteria criteria, int attempts, int flags, Mat centers);
    double Kmeans2(Mat data, int K, Mat bestLabels,
        TermCriteria criteria, int attempts, int flags, Point2fs* centers);
    void Mat_Fill_Random(uint64_t state, Mat mat, int distType, Scalar a, Scalar b, bool saturateRange);
    void Mat_RandShuffle(uint64_t state, Mat dst, double iterFactor);
    
    Range Range_New();
    Range Range_NewWithParams(int _start, int _end);
    Range Range_All();
    bool Range_Empty(Range rng);
    int Range_Size(Range rng);
    int Range_GetStart(Range rng);
    int Range_GetEnd(Range rng);
}


Mat newMat(){
    return Mat_New();
}

Mat newMatWithSize( int rows, int cols, int mt ){
    return Mat_NewWithSize(rows, cols, mt);
}

Mat newMatFromScalar( const Scalar ar, int type){
    return Mat_NewFromScalar(ar, type);
}

Mat newMatWithSizeFromScalar(const Scalar ar, int rows, int cols, int type){
    return Mat_NewWithSizeFromScalar(ar, rows, cols, type);
}

Mat newMatFromBytes(int rows, int cols, int type, ByteArray buf){
    return Mat_NewFromBytes(rows, cols, type, buf);
}

Mat newMatFromPtr(Mat m, int rows, int cols, int type, int prows, int pcols){
    return Mat_FromPtr(m, rows, cols, type, prows, pcols);
}

Mat newMatFromArrayPtr(int rows, int cols, int type, void* data){
    return Mat_FromArrayPtr(rows, cols, type, data);
}

Mat newMatFromContour(Point[] pts){
    return Mat_FromContour(Contour(pts.ptr, pts.length.to!int));
}

Mat zeros(int rows, int cols, int type){
    return Mat_ZerosFromRC(rows, cols, type);
}

Mat zeros(Size sz, int type){
    return Mat_ZerosFromSize(sz, type);
}

Mat ones(int rows, int cols, int type){
    return Mat_OnesFromRC(rows, cols, type);
}
Mat ones(Size sz, int type){
    return Mat_OnesFromSize(sz, type);
}

int CV_MAKETYPE(int depth, int cn){
    return Mat_CV_MAKETYPE(depth, cn);
}

Size getSize(Mat m){
    return Size(m.rows, m.cols);
}

Mat reshape(Mat m, int cn, int rows){
    return Mat_Reshape( m, cn, rows);
}

void Destroy(Mat m){
    Mat_Close(m);
}

bool isEmpty(Mat m){
    return Mat_Empty(m) == 0 ? false: true;
}

alias empty = isEmpty;

Mat clone(Mat m){
    return Mat_Clone(m);
}

void copyTo(Mat m, Mat dst){
    Mat_CopyTo(m, dst);
}

void copyToWithMask(Mat m, Mat dst, Mat mask){
    Mat_CopyToWithMask(m, dst, mask);
}

void convertTo(Mat m, Mat dst, int type){
    Mat_ConvertTo(m, dst, type);
}

void convertTo(Mat m, Mat dst, int rtype, double alpha = 1, double beta = 0 ){
    Mat_convertTo2(m, dst, rtype, alpha, beta);
}

void setTo(Mat m, Scalar s){
    Mat_SetTo(m, s);
}

void setTo(Mat m, Scalar s, Mat mask){
    Mat_SetToWithMask(m, s, mask);
}

void patchNaNs(Mat m){
    Mat_PatchNaNs(m);
}

Mat matFromRect(Mat m, Rect r){
    return Mat_Region(m, r);
}

alias subImageFromROI = matFromRect;

void addUChar(Mat m, ubyte val){
    Mat_AddUChar(m, val);
}

void subtractUChar(Mat m, ubyte val){
    Mat_SubtractUChar(m, val);
}

void multiplyUChar(Mat m, ubyte val){
    Mat_MultiplyUChar(m, val);
}

void divideUChar(Mat m, ubyte val){
    Mat_DivideUChar(m, val);
}

void addFloat(Mat m, float val){
    Mat_AddFloat(m, val);
}

void subtractFloat(Mat m, float val){
    Mat_SubtractFloat(m, val);
}

void multiplyFloat(Mat m, float val){
    multiplyFloat(m, val);
}

void multiplyDouble(Mat m, double val){
    Mat_MultiplyDouble(m, val);
}

void divideFloat(Mat m, float val){
    Mat_DivideFloat(m, val);
}

void multiplyInt(Mat m, int val){
    Mat_MultiplyInt(m, val);
}

void divideInt(Mat m, int val){
    Mat_DivideInt(m, val);
}

void addDouble(Mat m, double val){
    Mat_AddDouble(m, val);
}

void subtractDouble(Mat m, double val){
    Mat_SubtractDouble(m, val);
}

void addInt(Mat m, int val){
    Mat_AddInt(m, val);
}

void subtractInt(Mat m, int val){
    Mat_SubtractInt(m, val);
}


void performLUT(Mat src, Mat lut, Mat dst){
    LUT(src, lut, dst);
}

void absDiff(Mat src1, Mat src2, Mat dst){
    Mat_AbsDiff(src1, src2, dst);
}

void add(Mat src1, Mat src2, Mat dst){
    Mat_Add(src1, src2, dst);
}

void addScalar(Mat m, Scalar s){
    Mat_AddScalar(m, s);
}

void addWeighted(Mat src1, double alpha, Mat src2, double beta, double gamma, Mat dst){
    Mat_AddWeighted(src1, alpha, src2, beta, gamma, dst);
}

void bitwiseAnd(Mat src1, Mat src2, Mat dst){
    Mat_BitwiseAnd(src1, src2, dst);
}

void bitwiseAndWithMask(Mat src1, Mat src2, Mat dst, Mat mask){
    Mat_BitwiseAndWithMask(src1, src2, dst, mask);
}

void bitwiseNot(Mat src1, Mat dst){
    Mat_BitwiseNot(src1, dst);
}

void bitwiseNotWithMask(Mat src1, Mat dst, Mat mask){
    Mat_BitwiseNotWithMask(src1, dst, mask);
}

void bitwiseOr(Mat src1, Mat src2, Mat dst){
    Mat_BitwiseOr(src1, src2, dst);
}

void bitwiseOrWithMask(Mat src1, Mat src2, Mat dst, Mat mask){
    Mat_BitwiseOrWithMask(src1, src2, dst, mask);
}

void bitwiseXor(Mat src1, Mat src2, Mat dst){
    Mat_BitwiseXor(src1, src2, dst);
}

void bitwiseXorWithMask(Mat src1, Mat src2, Mat dst, Mat mask){
    Mat_BitwiseXorWithMask(src1, src2, dst, mask);
}

enum: int {
    // enum cv::CmpTypes
    CMP_EQ,
    CMP_GT,
    CMP_GE,
    CMP_LT,
    CMP_LE,
    CMP_NE,
}

void compare(Mat src1, Mat src2, Mat dst, int ct){
    Mat_Compare(src1, src2, dst, ct);
}

void compare(Mat src1, Scalar src2, Mat dst, int ct){
    Mat_CompareWithScalar(src1, src2, dst, ct);
}

void batchDistance(Mat src1, Mat src2, Mat dist, int dtype, Mat nidx, int normType, int K, Mat mask, int update, bool crosscheck){
    Mat_BatchDistance(src1, src2, dist, dtype, nidx, normType, K, mask, update, crosscheck);
}

enum: int {
	// CovarScrambled indicates to scramble the results.
	CovarScrambled = 0,

	// CovarNormal indicates to use normal covariation.
	CovarNormal = 1,

	// CovarUseAvg indicates to use average covariation.
	CovarUseAvg = 2,

	// CovarScale indicates to use scaled covariation.
	CovarScale = 4,

	// CovarRows indicates to use covariation on rows.
	CovarRows = 8,

	// CovarCols indicates to use covariation on columns.
	CovarCols = 16,
}
alias CovarFlags = int;

int borderInterpolate(int p, int len, CovarFlags borderType){
    return Mat_BorderInterpolate(p, len, borderType);
}

void calcCovarMatrix(Mat samples, Mat covar, Mat mean, CovarFlags flags, int ctype){
    Mat_CalcCovarMatrix(samples, covar, mean, flags, ctype);
}

void cartToPolar(Mat x, Mat y, Mat magnitude, Mat angle, bool angleInDegrees){
    Mat_CartToPolar(x, y, magnitude, angle, angleInDegrees);
}

bool checkRange(Mat m){
    return Mat_CheckRange(m);
}

void completeSymm(Mat m, bool lowerToUpper){
    Mat_CompleteSymm(m, lowerToUpper);
}

void convertScaleAbs(Mat src, Mat dst, double alpha = 1, double beta = 0){
    Mat_ConvertScaleAbs(src, dst, alpha, beta);
}

void copyMakeBorder(Mat src, Mat dst, int top, int bottom, int left, int right, CovarFlags borderType, Scalar value){
    Mat_CopyMakeBorder(src, dst, top, bottom, left, right, borderType, value);
}

enum: int {
    // DftForward performs forward 1D or 2D dft or dct.
    DftForward  = 0,

    // DftInverse performs an inverse 1D or 2D transform.
    DftInverse = 1,

    // DftScale scales the result: divide it by the number of array elements. Normally, it is combined with DFT_INVERSE.
    DftScale = 2,

    // DftRows performs a forward or inverse transform of every individual row of the input matrix.
    DftRows = 4,

    // DftComplexOutput performs a forward transformation of 1D or 2D real array; the result, though being a complex array, has complex-conjugate symmetry
    DftComplexOutput = 16,

    // DftRealOutput performs an inverse transformation of a 1D or 2D complex array; the result is normally a complex array of the same size,
    // however, if the input array has conjugate-complex symmetry (for example, it is a result of forward transformation with DFT_COMPLEX_OUTPUT flag),
    // the output is a real array.
    DftRealOutput = 32,

    // DftComplexInput specifies that input is complex input. If this flag is set, the input must have 2 channels.
    DftComplexInput = 64,

    // DctInverse performs an inverse 1D or 2D dct transform.
    DctInverse = DftInverse,

    // DctRows performs a forward or inverse dct transform of every individual row of the input matrix.
    DctRows = DftRows
}

alias DftFlags = int;

int countNonZero(Mat src){
    return Mat_CountNonZero(src);
}

void DCT(Mat src, Mat dst, int flags){
    Mat_DCT(src, dst, flags);
}

double determinant(Mat m){
    return Mat_Determinant(m);
}

void DFT(Mat m, Mat dst, DftFlags flags){
    Mat_DFT(m, dst, flags);
}

void divide(Mat src1, Mat src2, Mat dst){
    Mat_Divide(src1, src2, dst);
}

bool eigen(Mat src, Mat eigenvalues, Mat eigenvectors){
    return Mat_Eigen(src, eigenvalues, eigenvectors);
}

void eigenNonSymmetric(Mat src, Mat eigenvalues, Mat eigenvectors){
    Mat_EigenNonSymmetric(src, eigenvalues, eigenvectors);
}

void matExp(Mat src, Mat dst){
    Mat_Exp(src, dst);
}

void extractChannel(Mat src, Mat dst, int coi){
    Mat_ExtractChannel(src, dst, coi);
}

void findNonZero(Mat src, Mat idx){
    Mat_FindNonZero(src, idx);
}

void flip(Mat src, Mat dst, int flipCode){
    Mat_Flip(src, dst, flipCode);
}

void gemm(Mat src1, Mat src2, double alpha, Mat src3, double beta, Mat dst, int flags){
    Mat_Gemm(src1, src2, alpha, src3, beta, dst, flags);
}

int getOptimalDFTSize(int vecsize){
    return Mat_GetOptimalDFTSize(vecsize);
}

void hconcat(Mat src1, Mat src2, Mat dst){
    Mat_Hconcat(src1, src2, dst);
}

void vconcat(Mat src1, Mat src2, Mat dst){
    Mat_Vconcat(src1, src2, dst);
}

void rotate(Mat src, Mat dst, int rotationCode){
    Rotate(src, dst, rotationCode);
}

void idct(Mat src, Mat dst, int flags){
    Mat_Idct(src, dst, flags);
}

void idft(Mat src, Mat dst, int flags, int nonzeroRows){
    Mat_Idft(src, dst, flags, nonzeroRows);
}

void inRange(Mat src, Mat lowerb, Mat upperb, Mat dst){
    Mat_InRange(src, lowerb, upperb, dst);
}

void inRange(Mat src, const Scalar lowerb, const Scalar upperb, Mat dst){
    Mat_InRangeWithScalar(src, lowerb, upperb, dst);
}

void insertChannel(Mat src, Mat dst, int coi){
    Mat_InsertChannel(src, dst, coi);
}

double invert(Mat src, Mat dst, int flags){
    return Mat_Invert(src, dst, flags);
}

void matLog(Mat src, Mat dst){
    Mat_Log(src, dst);
}

void magnitude(Mat x, Mat y, Mat magnitude){
    Mat_Magnitude(x, y, magnitude);
}

void matMax(Mat src1, Mat src2, Mat dst){
    Mat_Max(src1, src2, dst);
}

void meanStdDev(Mat src, Mat dstMean, Mat dstStdDev){
    Mat_MeanStdDev(src, dstMean, dstStdDev);
}

void merge(Mats mats, Mat dst){
    Mat_Merge(mats, dst);
}

void merge(Mat[] mats, Mat dst){
    Mat_Merge(Mats(mats.ptr, cast(int)mats.length), dst);
}

void matMin(Mat src1, Mat src2, Mat dst){
    Mat_Min(src1, src2, dst);
}

void minMaxIdx(Mat m, double* minVal, double* maxVal, int* minIdx, int* maxIdx){
    Mat_MinMaxIdx(m, minVal, maxVal, minIdx, maxIdx);
}

void minMaxLoc(Mat m, double* minVal, double* maxVal, Point* minLoc, Point* maxLoc){
    Mat_MinMaxLoc(m, minVal, maxVal, minLoc, maxLoc);
}

void minMaxLoc(Mat a, double* minVal, double* maxVal, int* minIdx, int* maxIdx){
    Mat_MinMaxLoc2(a, minVal, maxVal, minIdx, maxIdx);
}

void mulSpectrums(Mat a, Mat b, Mat c, int flags){
    Mat_MulSpectrums(a, b, c, flags);
}

void multiply(Mat src1, Mat src2, Mat dst){
    Mat_Multiply(src1, src2, dst);
}

void subtract(Mat src1, Mat src2, Mat dst){
    Mat_Subtract(src1, src2, dst);
}

enum: int {// cv::NormTypes
    NORM_INF = 1, 
    NORM_L1 = 2, 
    NORM_L2 = 4, 
    NORM_L2SQR = 5, 
    NORM_HAMMING = 6, 
    NORM_HAMMING2 = 7, 
    NORM_TYPE_MASK = 7, 
    NORM_RELATIVE = 8, 
    NORM_MINMAX = 32 
}

void normalize(Mat src, Mat dst, double alpha, double beta, int typ){
    Mat_Normalize(src, dst, alpha, beta, typ);
}

double norm(Mat src1, int normType){
    return Norm(src1, normType);
}

void perspectiveTransform(Mat src, Mat dst, Mat tm){
    Mat_PerspectiveTransform(src, dst, tm);
}

void perspectiveTransform(Point2f[] src, ref Point2f[] dst, Mat tm){
    
    Mat srcmat = zeros(src.length.to!int, 1, CV_MAKETYPE(CV_32F, 2));
    foreach(int i; 0..src.length.to!int){
        srcmat.set!float(i, 0, src[i].x);
        srcmat.set!float(i, 1, src[i].y);
    }
    
    Mat dstmat = zeros(src.length.to!int, 1, CV_MAKETYPE(CV_32F, 2));
    
    Mat_PerspectiveTransform(srcmat, dstmat, tm);
    
    dst.length = dstmat.rows.to!size_t; 
    foreach(int i; 0..dstmat.rows){
        float xx = dstmat.at!float(i, 0);
        float yy = dstmat.at!float(i, 1);
        dst[i] = Point2f(xx, yy);
    }
    
    Destroy(srcmat);
    Destroy(dstmat);
}

bool solve(Mat src1, Mat src2, Mat dst, int flags){
    return Mat_Solve(src1, src2, dst, flags);
}

int solveCubic(Mat coeffs, Mat roots){
    return Mat_SolveCubic(coeffs, roots);
}

double solvePoly(Mat coeffs, Mat roots, int maxIters){
    return Mat_SolvePoly(coeffs, roots, maxIters);
}

void reduce(Mat src, Mat dst, int dim, int rType, int dType){
    Mat_Reduce(src, dst, dim, rType, dType);
}

void repeat(Mat src, int nY, int nX, Mat dst){
    Mat_Repeat(src, nY, nX, dst);
}

void scaleAdd(Mat src1, double alpha, Mat src2, Mat dst){
    Mat_ScaleAdd(src1, alpha, src2, dst);
}

void matSort(Mat src, Mat dst, int flags){
    Mat_Sort(src, dst, flags);
}

void matSortIdx(Mat src, Mat dst, int flags){
    Mat_SortIdx(src, dst, flags);
}

void matSplit(Mat src, Mats* mats){
    Mats _mats = Mat_Split2(src);
    mats = &_mats;
}

void matSplit(Mat src, ref Mat[] _mats){
    Mats mats = Mat_Split2(src);
    _mats = mats.mats[0..mats.length];
}

alias split = matSplit;

void matSubtract(Mat src1, Mat src2, Mat dst){
    Mat_Subtract(src1, src2, dst);
}

Scalar matTrace(Mat src){
    return Mat_Trace(src);
}

void transform(Mat src, Mat dst, Mat tm){
    Mat_Transform(src, dst, tm);
}

void transpose(Mat src, Mat dst){
    Mat_Transpose(src, dst);
}

void polarToCart(Mat magnitude, Mat degree, Mat x, Mat y, bool angleInDegrees){
    Mat_PolarToCart(magnitude, degree, x, y, angleInDegrees);
}

void matPow(Mat src, double power, Mat dst){
    Mat_Pow(src, power, dst);
}

void phase(Mat x, Mat y, Mat angle, bool angleInDegrees){
    Mat_Phase(x, y, angle, angleInDegrees);
}

Scalar matSum(Mat src1){
    return Mat_Sum(src1);
}

struct TermCriteria {
    void* p;
    
    enum: int { 
        COUNT =1, 
        MAX_ITER =COUNT, 
        EPS =2 
    }
    
    static TermCriteria opCall(int typ, int maxCount, double epsilon){
        return TermCriteria_New(typ, maxCount, epsilon);
    }
    
    double epsilon(){
        return Get_TermCriteria_Epsilon(this);
    }
    
    int maxCount(){
        return Get_TermCriteria_MaxCount(this);
    }
    
    int type(){
        return Get_TermCriteria_Type(this);
    }
}

TermCriteria newTermCriteria(int typ, int maxCount, double epsilon){
    return TermCriteria_New(typ, maxCount, epsilon);
}

void Destroy(TermCriteria tc){
    TermCriteria_Close(tc);
}

int64_t getCVTickCount(){
    return GetCVTickCount();
}

double getTickFrequency(){
    return GetTickFrequency();
}

double dot(Mat m1, Mat m2){
    return Mat_Dot(m1, m2);
}

Mat diag(Mat src, int d = 0){
    return Mat_Diag(src, d);
}

Mat eye(int rows, int cols, int type){
    return Mat_EyeFromRC(rows, cols, type);
}

Mat eye(Size sz, int type){
    return Mat_EyeFromRC(sz.height, sz.width, type);
}

struct PCA {
    void* p;
    
    static int DATA_AS_ROW = 0;
    static int DATA_AS_COL = 1;
    static int USE_AVG = 2;
    
    static PCA opCall(){
        return PCA_New();
    }
    
    static PCA opCall(Mat data, Mat mean, int flags, int maxComponents = 0){
        return PCA_NewWithMaxComp(data, mean, flags, maxComponents);
    }
    
    static PCA opCall(Mat data, Mat mean, int flags, double retainedVariance){
        return PCA_NewWithRetVar(data, mean, flags, retainedVariance);
    }
    
    void backProject(Mat vec, Mat result){
        PCA_BackProject(this, vec, result);
    }
    
    void project(Mat vec, Mat result){
        PCA_Project(this, vec, result);
    }
    
    Mat eigenvalues(){
        return PCA_Eigenvalues(this);
    }
    
    Mat eigenvectors(){
        return PCA_Eigenvectors(this);
    }
    
    Mat mean(){
        return PCA_Mean(this);
    }
}

enum: int { // cv::KmeansFlags
    KMEANS_RANDOM_CENTERS = 0, 
    KMEANS_PP_CENTERS = 2, 
    KMEANS_USE_INITIAL_LABELS = 1 
}

double kmeans(Mat data, int K, Mat bestLabels,
        TermCriteria criteria, int attempts, int flags, Mat centers = Mat()){
    return Kmeans(data, K, bestLabels, criteria, attempts, flags, centers);
}

double kmeans(Mat data, int K, Mat bestLabels,
        TermCriteria criteria, int attempts, int flags, ref Point2f[] centers){
    Point2fs _centers;
    double ret = Kmeans2(data, K, bestLabels, criteria, attempts, flags, &_centers);
    centers = _centers.points[0.._centers.length.to!int].dup;
    free(_centers.points);
    return ret;
}

enum { // 
    RNG_UNIFORM = 0, 
    RNG_NORMAL = 1
}

void fillRandom(uint64_t state, Mat mat, int distType, Scalar a, Scalar b, bool saturateRange = false){
    Mat_Fill_Random(state, mat, distType, a, b, saturateRange);
}

void randShuffle(uint64_t state, Mat dst, double iterFactor=1.0){
    Mat_RandShuffle(state, dst, iterFactor);
}

struct Range {
    void* p;
    
    static Range opCall(){
        return Range_New();
    }
    
    static Range opCall(int _start, int _end){
        return Range_NewWithParams(_start, _end);
    }
    
    static Range all(){
        return Range_All();
    }
    
    bool empty(){
        return Range_Empty(this);
    }
    
    int size(){
        return Range_Size(this);
    }
    
    int start(){
        return Range_GetStart(this);
    } 
     
    int end(){
        return Range_GetEnd(this);
    }
}

struct RangeVector {
    Range* ranges;
    int length;
}