feature-match: add debug info

6 files changed, 181 insertions, 71 deletions

diff --git a/modules/ocl/cv_feature_match.cpp b/modules/ocl/cv_feature_match.cpp
index fb5e081..d685e75 100644
--- a/modules/ocl/cv_feature_match.cpp
+++ b/modules/ocl/cv_feature_match.cpp
@@ -24,11 +24,15 @@
 #include "image_file_handle.h"
 #include "cl_utils.h"
 
-namespace XCam {
-
 #define XCAM_CV_FM_DEBUG 0
 #define XCAM_CV_OF_DRAW_SCALE 2
 
+namespace XCam {
+#if XCAM_CV_FM_DEBUG
+static void debug_write_image (
+    const SmartPtr<VideoBuffer> &buf, const Rect &rect, char *img_name, char *frame_str, char *fm_idx_str);
+#endif
+
 CVFeatureMatch::CVFeatureMatch ()
     : CVBaseClass ()
     , FeatureMatch ()
@@ -47,7 +51,7 @@ CVFeatureMatch::get_crop_image (
     cv::UMat umat;
     cv::ocl::convertFromBuffer (cl_mem_id, info.strides[0], info.height, info.width, CV_8U, umat);
     if (umat.empty ()) {
-        XCAM_LOG_ERROR ("convert bo buffer to UMat failed");
+        XCAM_LOG_ERROR ("FeatureMatch(idx:%d): convert bo buffer to UMat failed", _fm_idx);
         return false;
     }
 
@@ -71,17 +75,17 @@ CVFeatureMatch::add_detected_data (
 
 void
 CVFeatureMatch::get_valid_offsets (
-    cv::InputOutputArray image, cv::Size img0_size,
     std::vector<cv::Point2f> corner0, std::vector<cv::Point2f> corner1,
     std::vector<uchar> status, std::vector<float> error,
-    std::vector<float> &offsets, float &sum, int &count)
+    std::vector<float> &offsets, float &sum, int &count,
+    cv::InputOutputArray debug_img, cv::Size &img0_size)
 {
     count = 0;
     sum = 0.0f;
     for (uint32_t i = 0; i < status.size (); ++i) {
 #if XCAM_CV_FM_DEBUG
         cv::Point start = cv::Point(corner0[i]) * XCAM_CV_OF_DRAW_SCALE;
-        cv::circle (image, start, 4, cv::Scalar(255, 255, 255), XCAM_CV_OF_DRAW_SCALE);
+        cv::circle (debug_img, start, 4, cv::Scalar(255), XCAM_CV_OF_DRAW_SCALE);
 #endif
 
         if (!status[i] || error[i] > 24)
@@ -96,9 +100,9 @@ CVFeatureMatch::get_valid_offsets (
 
 #if XCAM_CV_FM_DEBUG
         cv::Point end = (cv::Point(corner1[i]) + cv::Point (img0_size.width, 0)) * XCAM_CV_OF_DRAW_SCALE;
-        cv::line (image, start, end, cv::Scalar(255, 255, 255), XCAM_CV_OF_DRAW_SCALE);
+        cv::line (debug_img, start, end, cv::Scalar(255), XCAM_CV_OF_DRAW_SCALE);
 #else
-        XCAM_UNUSED (image);
+        XCAM_UNUSED (debug_img);
         XCAM_UNUSED (img0_size);
 #endif
     }
@@ -111,7 +115,7 @@ CVFeatureMatch::calc_of_match (
     std::vector<uchar> &status, std::vector<float> &error,
     int &last_count, float &last_mean_offset, float &out_x_offset)
 {
-    cv::_InputOutputArray out_image;
+    cv::_InputOutputArray debug_img;
     cv::Size img0_size = image0.size ();
     cv::Size img1_size = image1.size ();
     XCAM_ASSERT (img0_size.height == img1_size.height);
@@ -123,22 +127,22 @@ CVFeatureMatch::calc_of_match (
 
     if (image0.isUMat ()) {
         umat.create (size, image0.type ());
-        out_image = cv::_InputOutputArray (umat);
+        debug_img = cv::_InputOutputArray (umat);
 
         image0.copyTo (umat (cv::Rect(0, 0, img0_size.width, img0_size.height)));
         image1.copyTo (umat (cv::Rect(img0_size.width, 0, img1_size.width, img1_size.height)));
-        umat.copyTo (out_image);
+        umat.copyTo (debug_img);
     } else {
         mat.create (size, image0.type ());
-        out_image = cv::_InputOutputArray (mat);
+        debug_img = cv::_InputOutputArray (mat);
 
         image0.copyTo (mat (cv::Rect(0, 0, img0_size.width, img0_size.height)));
         image1.copyTo (mat (cv::Rect(img0_size.width, 0, img1_size.width, img1_size.height)));
-        mat.copyTo (out_image);
+        mat.copyTo (debug_img);
     }
 
     cv::Size scale_size = size * XCAM_CV_OF_DRAW_SCALE;
-    cv::resize (out_image, out_image, scale_size, 0, 0);
+    cv::resize (debug_img, debug_img, scale_size, 0, 0);
 #endif
 
     std::vector<float> offsets;
@@ -146,8 +150,14 @@ CVFeatureMatch::calc_of_match (
     int count = 0;
     float mean_offset = 0.0f;
     offsets.reserve (corner0.size ());
-    get_valid_offsets (out_image, img0_size, corner0, corner1, status, error,
-                       offsets, offset_sum, count);
+    get_valid_offsets (corner0, corner1, status, error,
+                       offsets, offset_sum, count, debug_img, img0_size);
+#if XCAM_CV_FM_DEBUG
+    XCAM_LOG_INFO ("FeatureMatch(idx:%d): valid offsets:%d", _fm_idx, offsets.size ());
+    char file_name[256];
+    std::snprintf (file_name, 256, "fm_optical_flow_%d_%d.jpg", _frame_num, _fm_idx);
+    cv::imwrite (file_name, debug_img);
+#endif
 
     bool ret = get_mean_offset (offsets, offset_sum, count, mean_offset);
     if (ret) {
@@ -161,12 +171,6 @@ CVFeatureMatch::calc_of_match (
 
     last_count = count;
     last_mean_offset = mean_offset;
-
-#if XCAM_CV_FM_DEBUG
-    char file_name[1024];
-    snprintf (file_name, 1023, "fm_optical_flow_%d_%d.jpg", _frame_num, _fm_idx);
-    cv::imwrite (file_name, out_image);
-#endif
 }
 
 void
@@ -202,8 +206,8 @@ CVFeatureMatch::detect_and_match (
 
 #if XCAM_CV_FM_DEBUG
     XCAM_LOG_INFO (
-        "Stiching area: left_area(x:%d, width:%d), right_area(x:%d, width:%d)",
-        crop_left.pos_x, crop_left.width, crop_right.pos_x, crop_right.width);
+        "FeatureMatch(idx:%d): stiching area: left_area(pos_x:%d, width:%d), right_area(pos_x:%d, width:%d)",
+        _fm_idx, crop_left.pos_x, crop_left.width, crop_right.pos_x, crop_right.width);
 #endif
 }
 
@@ -236,38 +240,48 @@ CVFeatureMatch::optical_flow_feature_match (
 
 #if XCAM_CV_FM_DEBUG
     XCAM_ASSERT (_fm_idx >= 0);
-    char file_name[1024];
 
-#if 0
-    VideoBufferInfo info = left_buf->get_video_info ();
-    std::snprintf (file_name, 1023, "fm_in_%d_%d_%dx%d_0.nv12", info.width, info.height, _frame_num, _fm_idx);
-    dump_video_buf (left_buf, file_name);
+    char frame_str[64] = {'\0'};
+    std::snprintf (frame_str, 64, "frame:%d", _frame_num);
+    char fm_idx_str[64] = {'\0'};
+    std::snprintf (fm_idx_str, 64, "fm_idx:%d", _fm_idx);
 
-    info = right_buf->get_video_info ();
-    std::snprintf (file_name, 1023, "fm_in_%d_%d_%dx%d_1.nv12", info.width, info.height, _frame_num, _fm_idx);
-    dump_video_buf (right_buf, file_name);
-#endif
+    char img_name[256] = {'\0'};
+    std::snprintf (img_name, 256, "fm_in_stitch_area_%d_%d_0.jpg", _frame_num, _fm_idx);
+    debug_write_image (left_buf, left_crop_rect, img_name, frame_str, fm_idx_str);
 
-    cv::Mat mat;
-    std::snprintf (file_name, 1023, "fm_in_stitch_area_%d_%d_0.jpg", _frame_num, _fm_idx);
-    convert_to_mat (left_buf, mat);
-    cv::line (mat, cv::Point(left_crop_rect.pos_x, 0),
-              cv::Point(left_crop_rect.pos_x, dst_width), cv::Scalar(0, 0, 255), 2);
-    cv::line (mat, cv::Point(left_crop_rect.pos_x + left_crop_rect.width, 0),
-              cv::Point(left_crop_rect.pos_x + left_crop_rect.width, dst_width), cv::Scalar(0, 0, 255), 2);
-    cv::imwrite (file_name, mat);
-
-    std::snprintf (file_name, 1023, "fm_in_stitch_area_%d_%d_1.jpg", _frame_num, _fm_idx);
-    convert_to_mat (right_buf, mat);
-    cv::line (mat, cv::Point(right_crop_rect.pos_x, 0),
-              cv::Point(right_crop_rect.pos_x, dst_width), cv::Scalar(0, 0, 255), 2);
-    cv::line (mat, cv::Point(right_crop_rect.pos_x + right_crop_rect.width, 0),
-              cv::Point(right_crop_rect.pos_x + right_crop_rect.width, dst_width), cv::Scalar(0, 0, 255), 2);
-    cv::imwrite (file_name, mat);
-
-    XCAM_LOG_INFO ("Feature match: frame number:%d index:%d done", _frame_num, _fm_idx);
+    std::snprintf (img_name, 256, "fm_in_stitch_area_%d_%d_1.jpg", _frame_num, _fm_idx);
+    debug_write_image (right_buf, right_crop_rect, img_name, frame_str, fm_idx_str);
+
+    XCAM_LOG_INFO ("FeatureMatch(idx:%d): frame number:%d done", _fm_idx, _frame_num);
     _frame_num++;
 #endif
 }
 
+#if XCAM_CV_FM_DEBUG
+static void
+debug_write_image (
+    const SmartPtr<VideoBuffer> &buf, const Rect &rect, char *img_name, char *frame_str, char *fm_idx_str)
+{
+    cv::Scalar color = cv::Scalar(0, 0, 255);
+    VideoBufferInfo info = buf->get_video_info ();
+
+    cv::Mat mat;
+    CVBaseClass cv_obj;
+    cv_obj.convert_to_mat (buf, mat);
+
+    cv::putText (mat, frame_str, cv::Point(rect.pos_x, 30), cv::FONT_HERSHEY_COMPLEX, 0.8f, color, 2, 8, false);
+    cv::putText (mat, fm_idx_str, cv::Point(rect.pos_x, 70), cv::FONT_HERSHEY_COMPLEX, 0.8f, color, 2, 8, false);
+
+    cv::line (mat, cv::Point(rect.pos_x, rect.pos_y), cv::Point(rect.pos_x + rect.width, rect.pos_y), color, 1);
+    cv::line (mat, cv::Point(rect.pos_x, rect.pos_y + rect.height),
+              cv::Point(rect.pos_x + rect.width, rect.pos_y + rect.height), color, 1);
+
+    cv::line (mat, cv::Point(rect.pos_x, 0), cv::Point(rect.pos_x, info.height), color, 2);
+    cv::line (mat, cv::Point(rect.pos_x + rect.width, 0), cv::Point(rect.pos_x + rect.width, info.height), color, 2);
+
+    cv::imwrite (img_name, mat);
+}
+#endif
+
 }
diff --git a/modules/ocl/cv_feature_match.h b/modules/ocl/cv_feature_match.h
index 02b038d..1d9834c 100644
--- a/modules/ocl/cv_feature_match.h
+++ b/modules/ocl/cv_feature_match.h
@@ -56,10 +56,10 @@ protected:
     bool get_crop_image (SmartPtr<VideoBuffer> buffer, Rect crop_rect, cv::UMat &img);
 
     void add_detected_data (cv::InputArray image, cv::Ptr<cv::Feature2D> detector, std::vector<cv::Point2f> &corners);
-    void get_valid_offsets (cv::InputOutputArray out_image, cv::Size img0_size,
-                            std::vector<cv::Point2f> corner0, std::vector<cv::Point2f> corner1,
+    void get_valid_offsets (std::vector<cv::Point2f> corner0, std::vector<cv::Point2f> corner1,
                             std::vector<uchar> status, std::vector<float> error,
-                            std::vector<float> &offsets, float &sum, int &count);
+                            std::vector<float> &offsets, float &sum, int &count,
+                            cv::InputOutputArray debug_img, cv::Size &img0_size);
 
     void calc_of_match (cv::InputArray image0, cv::InputArray image1,
                         std::vector<cv::Point2f> corner0, std::vector<cv::Point2f> corner1,
diff --git a/modules/soft/cv_capi_feature_match.cpp b/modules/soft/cv_capi_feature_match.cpp
index ed5fd76..51abda1 100644
--- a/modules/soft/cv_capi_feature_match.cpp
+++ b/modules/soft/cv_capi_feature_match.cpp
@@ -22,7 +22,18 @@
 
 #include "cv_capi_feature_match.h"
 
+#define XCAM_CV_CAPI_FM_DEBUG 0
+
+#if XCAM_CV_CAPI_FM_DEBUG
+#include "ocl/cv_base_class.h"
+#endif
+
 namespace XCam {
+#if XCAM_CV_CAPI_FM_DEBUG
+static void
+debug_write_image (
+    const SmartPtr<VideoBuffer> &buf, const Rect &rect, char *img_name, char *frame_str, char *fm_idx_str);
+#endif
 
 CVCapiFeatureMatch::CVCapiFeatureMatch ()
     : FeatureMatch()
@@ -66,24 +77,32 @@ CVCapiFeatureMatch::add_detected_data (
 
     cvGoodFeaturesToTrack (image, NULL, NULL, corner_points, &found_num, quality, min_dist);
     XCAM_ASSERT (found_num <= 300);
-    if (found_num < (int)corners.size ()) {
-        XCAM_LOG_DEBUG ("Detedt corners:%d, less than reserved size:%d\n", found_num, (int)corners.size ());
+
+#if XCAM_CV_CAPI_FM_DEBUG
+    XCAM_LOG_INFO ("FeatureMatch(idx:%d): detected corners:%d, reserved size:%d", _fm_idx, found_num, (int)corners.size ());
+#endif
+    if (found_num < (int)corners.size ())
         corners.resize (found_num);
-    }
 }
 
 void
 CVCapiFeatureMatch::get_valid_offsets (
-    CvArr* image, CvSize img0_size,
     std::vector<CvPoint2D32f> corner0, std::vector<CvPoint2D32f> corner1,
     std::vector<char> status, std::vector<float> error,
-    std::vector<float> &offsets, float &sum, int &count)
+    std::vector<float> &offsets, float &sum, int &count,
+    CvArr* image, CvSize &img0_size)
 {
     count = 0;
     sum = 0.0f;
     for (uint32_t i = 0; i < status.size (); ++i) {
         if (!status[i] || error[i] > 24)
             continue;
+
+#if XCAM_CV_CAPI_FM_DEBUG
+        cv::Mat mat = cv::cvarrToMat (image);
+        cv::Point start = cv::Point (corner0[i].x, corner0[i].y);
+        cv::circle (mat, start, 2, cv::Scalar(255), 2);
+#endif
         if (fabs(corner0[i].y - corner1[i].y) >= 8)
             continue;
 
@@ -92,8 +111,12 @@ CVCapiFeatureMatch::get_valid_offsets (
         ++count;
         offsets.push_back (offset);
 
+#if XCAM_CV_CAPI_FM_DEBUG
+        cv::line (mat, start, cv::Point(corner1[i].x + img0_size.width, corner1[i].y), cv::Scalar(255), 2);
+#else
         XCAM_UNUSED (image);
         XCAM_UNUSED (img0_size);
+#endif
     }
 }
 
@@ -104,6 +127,7 @@ CVCapiFeatureMatch::calc_of_match (
     std::vector<char> &status, std::vector<float> &error,
     int &last_count, float &last_mean_offset, float &out_x_offset)
 {
+    CvMat debug_image;
     CvSize img0_size = cvSize(((CvMat*)image0)->width, ((CvMat*)image0)->height);
     CvSize img1_size = cvSize(((CvMat*)image1)->width, ((CvMat*)image1)->height);
     XCAM_ASSERT (img0_size.height == img1_size.height);
@@ -113,8 +137,24 @@ CVCapiFeatureMatch::calc_of_match (
     int count = 0;
     float mean_offset = 0.0f;
     offsets.reserve (corner0.size ());
-    get_valid_offsets (NULL, img0_size, corner0, corner1, status, error,
-                       offsets, offset_sum, count);
+
+#if XCAM_CV_CAPI_FM_DEBUG
+    cv::Mat mat;
+    mat.create (img0_size.height, img0_size.width + img1_size.width, ((CvMat*)image0)->type);
+    debug_image = cvMat (img0_size.height, img0_size.width + img1_size.width, ((CvMat*)image0)->type, mat.ptr());
+    cv::cvarrToMat(image0, true).copyTo (mat (cv::Rect(0, 0, img0_size.width, img0_size.height)));
+    cv::cvarrToMat(image1, true).copyTo (mat (cv::Rect(img0_size.width, 0, img1_size.width, img1_size.height)));
+#endif
+
+    get_valid_offsets (corner0, corner1, status, error,
+                       offsets, offset_sum, count, &debug_image, img0_size);
+
+#if XCAM_CV_CAPI_FM_DEBUG
+    XCAM_LOG_INFO ("FeatureMatch(idx:%d): valid offsets:%d", _fm_idx, offsets.size ());
+    char file_name[256] = {'\0'};
+    std::snprintf (file_name, 256, "fm_optical_flow_%d_%d.jpg", _frame_num, _fm_idx);
+    cv::imwrite (file_name, mat);
+#endif
 
     bool ret = get_mean_offset (offsets, offset_sum, count, mean_offset);
     if (ret) {
@@ -161,10 +201,20 @@ CVCapiFeatureMatch::detect_and_match (
         img_left, img_right, 0, 0, corner_points1, corner_points2, count, win_size, 3,
         optflow_status, optflow_errs, cvTermCriteria(CV_TERMCRIT_ITER, 40, 0.1), 0 );
 
+#if XCAM_CV_CAPI_FM_DEBUG
+    XCAM_LOG_INFO ("FeatureMatch(idx:%d): matched corners:%d", _fm_idx, count);
+#endif
+
     calc_of_match (img_left, img_right, corner_left, corner_right,
                    status, err, valid_count, mean_offset, x_offset);
 
     adjust_stitch_area (dst_width, x_offset, crop_left, crop_right);
+
+#if XCAM_CV_CAPI_FM_DEBUG
+    XCAM_LOG_INFO (
+        "FeatureMatch(idx:%d): stiching area: left_area(pos_x:%d, width:%d), right_area(pos_x:%d, width:%d)",
+        _fm_idx, crop_left.pos_x, crop_left.width, crop_right.pos_x, crop_right.width);
+#endif
 }
 
 void
@@ -180,6 +230,52 @@ CVCapiFeatureMatch::optical_flow_feature_match (
 
     detect_and_match ((CvArr*)(&left_img), (CvArr*)(&right_img), left_crop_rect, right_crop_rect,
                       _valid_count, _mean_offset, _x_offset, dst_width);
+
+#if XCAM_CV_CAPI_FM_DEBUG
+    XCAM_ASSERT (_fm_idx >= 0);
+
+    char frame_str[64] = {'\0'};
+    std::snprintf (frame_str, 64, "frame:%d", _frame_num);
+    char fm_idx_str[64] = {'\0'};
+    std::snprintf (fm_idx_str, 64, "fm_idx:%d", _fm_idx);
+
+    char img_name[256] = {'\0'};
+    std::snprintf (img_name, 256, "fm_in_stitch_area_%d_%d_0.jpg", _frame_num, _fm_idx);
+    debug_write_image (left_buf, left_crop_rect, img_name, frame_str, fm_idx_str);
+
+    std::snprintf (img_name, 256, "fm_in_stitch_area_%d_%d_1.jpg", _frame_num, _fm_idx);
+    debug_write_image (right_buf, right_crop_rect, img_name, frame_str, fm_idx_str);
+
+    XCAM_LOG_INFO ("FeatureMatch(idx:%d): frame number:%d done", _fm_idx, _frame_num);
+
+    _frame_num++;
+#endif
+}
+
+#if XCAM_CV_CAPI_FM_DEBUG
+static void
+debug_write_image (
+    const SmartPtr<VideoBuffer> &buf, const Rect &rect, char *img_name, char *frame_str, char *fm_idx_str)
+{
+    cv::Scalar color = cv::Scalar(0, 0, 255);
+    VideoBufferInfo info = buf->get_video_info ();
+
+    cv::Mat mat;
+    CVBaseClass cv_obj;
+    cv_obj.convert_to_mat (buf, mat);
+
+    cv::putText (mat, frame_str, cv::Point(rect.pos_x, 30), cv::FONT_HERSHEY_COMPLEX, 0.8f, color, 2, 8, false);
+    cv::putText (mat, fm_idx_str, cv::Point(rect.pos_x, 70), cv::FONT_HERSHEY_COMPLEX, 0.8f, color, 2, 8, false);
+
+    cv::line (mat, cv::Point(rect.pos_x, rect.pos_y), cv::Point(rect.pos_x + rect.width, rect.pos_y), color, 1);
+    cv::line (mat, cv::Point(rect.pos_x, rect.pos_y + rect.height),
+              cv::Point(rect.pos_x + rect.width, rect.pos_y + rect.height), color, 1);
+
+    cv::line (mat, cv::Point(rect.pos_x, 0), cv::Point(rect.pos_x, info.height), color, 2);
+    cv::line (mat, cv::Point(rect.pos_x + rect.width, 0), cv::Point(rect.pos_x + rect.width, info.height), color, 2);
+
+    cv::imwrite (img_name, mat);
 }
+#endif
 
 }
diff --git a/modules/soft/cv_capi_feature_match.h b/modules/soft/cv_capi_feature_match.h
index 095463f..c5655ba 100644
--- a/modules/soft/cv_capi_feature_match.h
+++ b/modules/soft/cv_capi_feature_match.h
@@ -56,10 +56,10 @@ protected:
     bool get_crop_image (SmartPtr<VideoBuffer> buffer, Rect crop_rect, std::vector<char> &crop_image, CvMat &img);
 
     void add_detected_data (CvArr* image, std::vector<CvPoint2D32f> &corners);
-    void get_valid_offsets (CvArr* out_image, CvSize img0_size,
-                            std::vector<CvPoint2D32f> corner0, std::vector<CvPoint2D32f> corner1,
+    void get_valid_offsets (std::vector<CvPoint2D32f> corner0, std::vector<CvPoint2D32f> corner1,
                             std::vector<char> status, std::vector<float> error,
-                            std::vector<float> &offsets, float &sum, int &count);
+                            std::vector<float> &offsets, float &sum, int &count,
+                            CvArr* out_image, CvSize &img0_size);
 
     void calc_of_match (CvArr* image0, CvArr* image1,
                         std::vector<CvPoint2D32f> corner0, std::vector<CvPoint2D32f> corner1,
diff --git a/tests/test-soft-image.cpp b/tests/test-soft-image.cpp
index 7161ff2..92fbd35 100644
--- a/tests/test-soft-image.cpp
+++ b/tests/test-soft-image.cpp
@@ -68,7 +68,7 @@ parse_camera_info (const char *path, uint32_t idx, CameraInfo &info)
         "extrinsic_camera_front.txt", "extrinsic_camera_right.txt",
         "extrinsic_camera_rear.txt", "extrinsic_camera_left.txt"
     };
-    static const float viewpoints_range[] = {60.0f, 150.0f, 60.0f, 150.0f};
+    static const float viewpoints_range[] = {64.0f, 160.0f, 64.0f, 160.0f};
 
     char intrinsic_path[1024];
     char extrinsic_path[1024];
diff --git a/xcore/interface/feature_match.cpp b/xcore/interface/feature_match.cpp
index ac4dceb..de752fd 100644
--- a/xcore/interface/feature_match.cpp
+++ b/xcore/interface/feature_match.cpp
@@ -21,10 +21,10 @@
 
 #include "feature_match.h"
 
-namespace XCam {
-
 #define XCAM_FM_DEBUG 0
 
+namespace XCam {
+
 FeatureMatch::FeatureMatch ()
     : _x_offset (0.0f)
     , _mean_offset (0.0f)
@@ -69,8 +69,8 @@ FeatureMatch::get_mean_offset (std::vector<float> offsets, float sum, int &count
 
 #if XCAM_FM_DEBUG
     XCAM_LOG_INFO (
-        "X-axis mean offset:%.2f, pre_mean_offset:%.2f (%d times, count:%d)",
-        mean_offset, 0.0f, 0, count);
+        "FeatureMatch(idx:%d): X-axis mean offset:%.2f, pre_mean_offset:%.2f (%d times, count:%d)",
+        _fm_idx, mean_offset, 0.0f, 0, count);
 #endif
 
     bool ret = true;
@@ -95,8 +95,8 @@ FeatureMatch::get_mean_offset (std::vector<float> offsets, float sum, int &count
         mean_offset = sum / recur_count;
 #if XCAM_FM_DEBUG
         XCAM_LOG_INFO (
-            "X-axis mean offset:%.2f, pre_mean_offset:%.2f (%d times, count:%d)",
-            mean_offset, pre_mean_offset, try_times, recur_count);
+            "FeatureMatch(idx:%d): X-axis mean_offset:%.2f, pre_mean_offset:%.2f (%d times, count:%d)",
+            _fm_idx, mean_offset, pre_mean_offset, try_times, recur_count);
 #endif
 
         if (mean_offset == pre_mean_offset && recur_count == count)