/*
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.features2d;

import std.conv;

import opencvd.cvcore;

private extern (C){
    AKAZE AKAZE_Create();
    void AKAZE_Close(AKAZE a);
    KeyPoints AKAZE_Detect(AKAZE a, Mat src);
    KeyPoints AKAZE_DetectAndCompute(AKAZE a, Mat src, Mat mask, Mat desc);
    
    AgastFeatureDetector AgastFeatureDetector_Create();
    void AgastFeatureDetector_Close(AgastFeatureDetector a);
    KeyPoints AgastFeatureDetector_Detect(AgastFeatureDetector a, Mat src);

    BRISK BRISK_Create();
    void BRISK_Close(BRISK b);
    KeyPoints BRISK_Detect(BRISK b, Mat src);
    KeyPoints BRISK_DetectAndCompute(BRISK b, Mat src, Mat mask, Mat desc);

    FastFeatureDetector FastFeatureDetector_Create();
    void FastFeatureDetector_Close(FastFeatureDetector f);
    KeyPoints FastFeatureDetector_Detect(FastFeatureDetector f, Mat src);

    GFTTDetector GFTTDetector_Create();
    void GFTTDetector_Close(GFTTDetector a);
    KeyPoints GFTTDetector_Detect(GFTTDetector a, Mat src);

    KAZE KAZE_Create();
    void KAZE_Close(KAZE a);
    KeyPoints KAZE_Detect(KAZE a, Mat src);
    KeyPoints KAZE_DetectAndCompute(KAZE a, Mat src, Mat mask, Mat desc);

    MSER MSER_Create();
    void MSER_Close(MSER a);
    KeyPoints MSER_Detect(MSER a, Mat src);

    ORB ORB_Create();
    void ORB_Close(ORB o);
    KeyPoints ORB_Detect(ORB o, Mat src);
    KeyPoints ORB_DetectAndCompute(ORB o, Mat src, Mat mask, Mat desc);

    SimpleBlobDetector SimpleBlobDetector_Create();
    void SimpleBlobDetector_Close(SimpleBlobDetector b);
    KeyPoints SimpleBlobDetector_Detect(SimpleBlobDetector b, Mat src);

    BFMatcher BFMatcher_Create();
    BFMatcher BFMatcher_CreateWithParams(int normType, bool crossCheck);
    void BFMatcher_Close(BFMatcher b);
    MultiDMatches BFMatcher_KnnMatch(BFMatcher b, Mat query, Mat train, int k);

    void DrawKeyPoints(Mat src, KeyPoints kp, Mat dst, const Scalar s, int flags);
    
    FlannBasedMatcher FlannBasedMatcher_Create1();
    void FlannBasedMatcher_Close(FlannBasedMatcher fbm);
    MultiDMatches FlannBasedMatcher_KnnMatch(FlannBasedMatcher fbm,
        Mat queryDescriptors, Mat trainDescriptors, int k, Mat mask, bool compactResult);
    void DrawMatches1(Mat img1,
                KeyPoints kp1,
                Mat img2,
                KeyPoints kp2,
                DMatches matches1to2,
                Mat outImg,
                Scalar matchColor,
                Scalar singlePointColor,
                CharVector matchesMask,
                int flags);
}

struct AKAZE {
    void* p;
    
    static AKAZE opCall(){
        return AKAZE_Create();
    }
    
    KeyPoint[] detect(Mat src){
        KeyPoints kpts = AKAZE_Detect(this, src);
        KeyPoint[] ret = kpts.keypoints[0..kpts.length].dup;
        KeyPoints_Close(kpts);
        return ret;
    }
    
    KeyPoint[] detectAndCompute(Mat src, Mat mask, Mat desc){
        KeyPoints kpts = AKAZE_DetectAndCompute(this, src, mask, desc);
        KeyPoint[] ret = kpts.keypoints[0..kpts.length].dup;
        KeyPoints_Close(kpts);
        return ret;
    }
}

void Destroy(AKAZE a){
    AKAZE_Close(a);
}

struct AgastFeatureDetector{
    void* p;
    
    static AgastFeatureDetector opCall(){
        return AgastFeatureDetector_Create();
    }
    
    KeyPoint[] detect(Mat src){
        KeyPoints kpts = AgastFeatureDetector_Detect(this, src);
        KeyPoint[] ret = kpts.keypoints[0..kpts.length].dup;
        KeyPoints_Close(kpts);
        return ret;
    }
}

void Destroy(AgastFeatureDetector a){
    AgastFeatureDetector_Close(a);
}

struct BRISK {
    void* p;
    
    static BRISK opCall(){
        return BRISK_Create();
    }
    
    KeyPoint[] detect(Mat src){
        KeyPoints kpts = BRISK_Detect(this, src);
        KeyPoint[] ret = kpts.keypoints[0..kpts.length].dup;
        KeyPoints_Close(kpts);
        return ret;
    }
    
    KeyPoint[] detectAndCompute(Mat src, Mat mask, Mat desc){
        KeyPoints kpts = BRISK_DetectAndCompute(this, src, mask, desc);
        KeyPoint[] ret = kpts.keypoints[0..kpts.length].dup;
        KeyPoints_Close(kpts);
        return ret;
    }
}

void Destroy(BRISK a){
    BRISK_Close(a);
}

struct FastFeatureDetector {
    void* p;
    
    static FastFeatureDetector opCall(){
        return FastFeatureDetector_Create();
    }
    
    KeyPoint[] detect(Mat src){
        KeyPoints kpts = FastFeatureDetector_Detect(this, src);
        KeyPoint[] ret = kpts.keypoints[0..kpts.length].dup;
        KeyPoints_Close(kpts);
        return ret;
    }
}

void Destroy(FastFeatureDetector a){
    FastFeatureDetector_Close(a);
}

struct GFTTDetector {
    void* p;
    
    static GFTTDetector opCall(){
        return GFTTDetector_Create();
    }
    
    KeyPoint[] detect(Mat src){
        KeyPoints kpts = GFTTDetector_Detect(this, src);
        KeyPoint[] ret = kpts.keypoints[0..kpts.length].dup;
        KeyPoints_Close(kpts);
        return ret;
    }
}

void Destroy(GFTTDetector a){
    GFTTDetector_Close(a);
}

struct KAZE {
    void* p;
    
    static KAZE opCall(){
        return KAZE_Create();
    }
    
    KeyPoint[] detect(Mat src){
        KeyPoints kpts = KAZE_Detect(this, src);
        KeyPoint[] ret = kpts.keypoints[0..kpts.length].dup;
        KeyPoints_Close(kpts);
        return ret;
    }
    
    KeyPoint[] detectAndCompute(Mat src, Mat mask, Mat desc){
        KeyPoints kpts = KAZE_DetectAndCompute(this, src, mask, desc);
        KeyPoint[] ret = kpts.keypoints[0..kpts.length].dup;
        KeyPoints_Close(kpts);
        return ret;
    }
}

void Destroy(KAZE a){
    KAZE_Close(a);
}

struct MSER {
    void* p;
    
    static MSER opCall(){
        return MSER_Create();
    }
    
    KeyPoint[] detect(Mat src){
        KeyPoints kpts = MSER_Detect(this, src);
        KeyPoint[] ret = kpts.keypoints[0..kpts.length].dup;
        KeyPoints_Close(kpts);
        return ret;
    }
}
void Destroy(MSER a){
    MSER_Close(a);
}

struct ORB {
    void* p;
    
    static ORB opCall(){
        return ORB_Create();
    }
    
    KeyPoint[] detect(Mat src){
        KeyPoints kpts = ORB_Detect(this, src);
        KeyPoint[] ret = kpts.keypoints[0..kpts.length].dup;
        KeyPoints_Close(kpts);
        return ret;
    }
    
    KeyPoint[] detectAndCompute(Mat src, Mat mask, Mat desc){
        KeyPoints kpts = ORB_DetectAndCompute(this, src, mask, desc);
        KeyPoint[] ret = kpts.keypoints[0..kpts.length].dup;
        KeyPoints_Close(kpts);
        return ret;
    }
}

void Destroy(ORB a){
    ORB_Close(a);
}

struct SimpleBlobDetector {
    void* p;
    
    static SimpleBlobDetector opCall(){
        return SimpleBlobDetector_Create();
    }
    
    KeyPoint[] detect(Mat src){
        KeyPoints kpts = SimpleBlobDetector_Detect(this, src);
        KeyPoint[] ret = kpts.keypoints[0..kpts.length].dup;
        KeyPoints_Close(kpts);
        return ret;
    }
}

void Destroy(SimpleBlobDetector a){
    SimpleBlobDetector_Close(a);
}

struct BFMatcher {
    void* p;
    /*
    static BFMatcher opCall(){
        return BFMatcher_Create();
    }
    */
    static BFMatcher opCall(int normType=NORM_L2, bool crossCheck=false){
        return BFMatcher_CreateWithParams(normType, crossCheck);
    }
    
    DMatch[][] knnMatch(Mat query, Mat train, int k){
        
        MultiDMatches mdms = BFMatcher_KnnMatch(this, query, train, k);
        
        DMatch[][] ret; ret.length = mdms.length;
        foreach(i; 0..mdms.length){
            DMatches ds = mdms.dmatches[i];
            DMatch[] dmats = ds.dmatches[0..ds.length].dup;
            ret[i] = dmats;
        }
        MultiDMatches_Close(mdms);
        return ret;
    }
}

void Destroy(BFMatcher a){
    BFMatcher_Close(a);
}

enum: int { // cv::DrawMatchesFlags 
    DrawMatchesFlags_DEFAULT = 0, 
    DrawMatchesFlags_DRAW_OVER_OUTIMG = 1, 
    DrawMatchesFlags_NOT_DRAW_SINGLE_POINTS = 2, 
    DrawMatchesFlags_DRAW_RICH_KEYPOINTS = 4 
}

void drawKeyPoints(Mat src, KeyPoint[] kp, Mat dst,
        const Scalar s = Scalar.all(-1), int flags = DrawMatchesFlags_DEFAULT){
    DrawKeyPoints(src, KeyPoints(kp.ptr, kp.length.to!int), dst, s, flags);
}

struct FlannBasedMatcher {
    void* p;
    
    static FlannBasedMatcher opCall(){
        return FlannBasedMatcher_Create1();
    }
    
    DMatch[][] knnMatch(
        Mat queryDescriptors, Mat trainDescriptors, int k, Mat mask = Mat(), bool compactResult=false){
        
        MultiDMatches mdms = FlannBasedMatcher_KnnMatch(this, queryDescriptors, trainDescriptors, k, mask, compactResult);
        
        DMatch[][] ret; ret.length = mdms.length;
        foreach(i; 0..mdms.length){
            DMatches ds = mdms.dmatches[i];
            DMatch[] dmats = ds.dmatches[0..ds.length].dup;
            ret[i] = dmats;
        }
        MultiDMatches_Close(mdms);
        return ret;
    }
}

void Destroy(FlannBasedMatcher fbm){
    FlannBasedMatcher_Close(fbm);
}

void drawMatches(Mat img1,
                KeyPoint[] kp1,
                Mat img2,
                KeyPoint[] kp2,
                DMatch[] matches1to2,
                Mat outImg,
                Scalar matchColor = Scalar.all(-1),
                Scalar singlePointColor = Scalar.all(-1),
                char[] matchesMask = [],
                int flags = DrawMatchesFlags_DEFAULT){
    DrawMatches1(img1,
                KeyPoints(kp1.ptr, kp1.length.to!int),
                img2,
                KeyPoints(kp2.ptr, kp2.length.to!int),
                DMatches(matches1to2.ptr, matches1to2.length.to!int),
                outImg,
                matchColor,
                singlePointColor,
                CharVector(matchesMask.ptr, matchesMask.length.to!int),
                flags);
}