2. 程式人生 > >Android 端基於 OpenCV 的邊框識別功能

Android 端基於 OpenCV 的邊框識別功能

阿新 • • 發佈：2019-02-05

智慧圖片裁剪庫：SmartCropper，選擇照片之後會自動識別出邊框的位置，適用於身份證，名片，文件等照片的裁剪。本篇文章主要就邊框識別部分說一下開發過程及實現原理，通過閱讀本篇文章，你將具備以下技能：

  1. 瞭解 NDK 開發的基本步驟，能使用 Java、C++/C 混合開發簡單的應用
  2. 瞭解 OpenCV 庫的作用及其用法，能使用 OpenCV 做影象處理
  3. 瞭解基於 OpenCV 的邊框識別實現

OpenCV 的全稱是 Open Source Computer Vision Library，是一個使用 C++ 編寫的跨平臺的計算機視覺庫，能對輸入的圖片進行處理，包括常見的高斯模糊，提取灰度圖片，提取輪廓等等，可以應用於增強現實，人臉識別，運動跟蹤，物體識別，影象分割槽等。

在 Android 平臺需要使用 JNI 技術來呼叫 C++ 的庫，事實上，OpenCV 的官網已經提供了編寫好的 Android 庫：OpenCv4Android，我們可以按照提示匯入該庫，就可用以使用 Java 程式碼來呼叫了。但是該庫包含了 OpenCV 所有的模組，造成了該庫體積非常大，其中很多並不是我們需要的。所以我的做法是隻使用該庫提供的編譯好的 C++ 庫，挑選自己需要用到的模組，引入其動態或者靜態庫，編寫 C++ 程式碼呼叫 OpenCV 的這些模組完成主要功能，最後使用 JNI 技術編寫 Java 介面供 Android 程式呼叫。

匯入 OpenCV 庫

OpenCV-2.4
 
.13-android-sdk
|_ doc
|_ samples
|_ sdk
|    |_ etc
|    |_ java
|    |_ native
|          |_ 3rdparty
|          |_ jni
|          |_ libs
|               |_ armeabi
|               |_ armeabi-v7a
|               |_ x86
|
|_ LICENSE
|_ README.android

sdk/java 目錄提供了 OpenCv  的 Java API，匯入到專案中，並且將 native/libs 下面的 native 庫匯入之後就可以使用 OpenCV 的 Java API 了。native/jni 目錄下提供了編譯用的 cmake 檔案以及標頭檔案。

在 SmartCropper 中只使用到了 opencv_core 與 opencv_imgproc 模組,  所以只需要匯入這兩個模組的標頭檔案與動態庫/靜態庫就行了。
目錄如下所示：

smartcropperlib
├── opencv
│   ├── include
│   │      └── opencv2
│   │      ├── core
│   │      ├── imgproc
│   │      ├── opencv.hpp
│   │      └── opencv_modules.hpp
│   └── lib
│        ├── armeabi
│        │   ├── libopencv_core.a
│        │   └── libopencv_imgproc.a
│        ├── armeabi-v7a
│        ├── mips
│        └── x86
├── CMakeLists.txt
└── build.gradle
└── src
     └── main
          ├── cpp
          │    ├── Scanner.cpp
          │    ├── android_utils.cpp
          │    ├── include
          │    │     ├── Scanner.h
          │    │     └── android_utils.h
          │    └── smart_cropper.cpp
          ├── java
          └── res

編寫 cmake 檔案：


include_directories(opencv/include
                    src/main/cpp/include)

add_library(opencv_imgproc STATIC IMPORTED)
add_library(opencv_core STATIC IMPORTED)

set_target_properties(opencv_imgproc PROPERTIES IMPORTED_LOCATION${PROJECT_SOURCE_DIR}/opencv/lib/${ANDROID_ABI}/libopencv_imgproc.a)
set_target_properties(opencv_core PROPERTIES IMPORTED_LOCATION${PROJECT_SOURCE_DIR}/opencv/lib/${ANDROID_ABI}/libopencv_core.a)

add_library( smart_cropper
             SHARED
             src/main/cpp/Scanner.cpp
             src/main/cpp/smart_cropper.cpp
             src/main/cpp/android_utils.cpp)
find_library( log-lib
              log)
find_library(jnigraphics-lib
             jnigraphics)
target_link_libraries( smart_cropper
                       opencv_imgproc
                       opencv_core
                       ${log-lib}
                       ${jnigraphics-lib})

主要注意點如下：

  1. include_directories新增標頭檔案查詢路徑，包括引入庫的和自己寫的
  2. add_library新增動態庫或靜態庫，其中本地的動態庫名稱,位置可以由set_target_properties設定
  3. find_library通過名稱查詢並引入庫，可以引入 NDK 中的庫，比如日誌模組
  4. target_link_libraries新增參加編譯的庫名稱，也可以是絕對路徑，注意被依賴的模組寫在後面

修改 build.gradle 檔案：


android {
    //...
    defaultConfig {
        //...
        externalNativeBuild {
            cmake {
                cppFlags "-std=c++11 -frtti -fexceptions -lz"
                abiFilters 'armeabi'
            }
        }
    }
    externalNativeBuild {
        cmake {
            path "CMakeLists.txt"
        }
    }
    //...
}

這裡指定了 C++ 的版本為11，開啟 RTTI，啟用異常處理，這樣就完成了匯入 OpenCV 程式碼庫的配置。

邊框識別

SmartCropper 類中提供了圖片的邊框識別與裁剪：


public class SmartCropper {

    /**
     *  輸入圖片掃描邊框頂點
     * @param srcBmp 掃描圖片
     * @return 返回頂點陣列，以 左上，右上，右下，左下排序
     */
    public static Point[] scan(Bitmap srcBmp) {
        //...
    }

    /**
     * 裁剪圖片
     * @param srcBmp 待裁剪圖片
     * @param cropPoints 裁剪區域頂點，頂點座標以圖片大小為準
     * @return 返回裁剪後的圖片
     */
    public static Bitmap crop(Bitmap srcBmp, Point[] cropPoints) {
        //...
    }

    private static native void nativeScan(Bitmap srcBitmap, Point[] outPoints);

    private static native void nativeCrop(Bitmap srcBitmap, Point[] points, Bitmap outBitmap);

    static {
        System.loadLibrary("smart_cropper");
    }

}

主要邏輯位於 native 層，先看 nativeScan 方法對應的 C++ 程式碼：


static void native_scan(JNIEnv *env, jclass type, jobject srcBitmap, jobjectArray outPoint_) {
    if (env -> GetArrayLength(outPoint_) != 4) {
        return;
    }
    Mat srcBitmapMat;
    bitmap_to_mat(env, srcBitmap, srcBitmapMat);
    Mat bgrData(srcBitmapMat.rows, srcBitmapMat.cols, CV_8UC3);
    cvtColor(srcBitmapMat, bgrData, CV_RGBA2BGR);
    scanner::Scanner docScanner(bgrData);
    std::vector scanPoints = docScanner.scanPoint();
    if (scanPoints.size() == 4) {
        for (int i = 0; i < 4; ++i) { env -> SetObjectArrayElement(outPoint_, i, createJavaPoint(env, scanPoints[i]));
        }
    }
}

先將傳入的 Bitmap 物件轉化成 OpenCV 提供的 Mat 物件，你可以理解成一個多維矩陣，儲存了點陣圖的資訊，在 OpenCV 中 Mat 即為圖片 ，所有對圖片的操作即為操作 Mat 物件，然後將 RGBA 格式的圖片轉化成 BGR 格式，這種轉化對於 OpenCV 來說十分方便，cvtColor(srcBitmapMat, bgrData, CV_RGBA2BGR); 當然還提供了其他的色彩空間轉化。接著呼叫 scanner::Scanner 物件的 scanPoint 函式獲取識別好的四個頂點。
可以看到主要邏輯位於 docScanner.scanPoint() 中，我們先看一下 bitmap_to_ma 是如何將 bitmap 轉化成 Mat 物件的：


void bitmap_to_mat(JNIEnv *env, jobject &srcBitmap, Mat &srcMat) {
    void *srcPixels = 0;
    AndroidBitmapInfo srcBitmapInfo;
    try {
        AndroidBitmap_getInfo(env, srcBitmap, &srcBitmapInfo);
        AndroidBitmap_lockPixels(env, srcBitmap, &srcPixels);
        uint32_t srcHeight = srcBitmapInfo.height;
        uint32_t srcWidth = srcBitmapInfo.width;
        srcMat.create(srcHeight, srcWidth, CV_8UC4);
        if (srcBitmapInfo.format == ANDROID_BITMAP_FORMAT_RGBA_8888) {
            Mat tmp(srcHeight, srcWidth, CV_8UC4, srcPixels);
            tmp.copyTo(srcMat);
        } else {
            Mat tmp = Mat(srcHeight, srcWidth, CV_8UC2, srcPixels);
            cvtColor(tmp, srcMat, COLOR_BGR5652RGBA);
        }
        AndroidBitmap_unlockPixels(env, srcBitmap);
        return;
    } catch (cv::Exception &e) {
        AndroidBitmap_unlockPixels(env, srcBitmap);
        jclass je = env->FindClass("java/lang/Exception");
        env -> ThrowNew(je, e.what());
        return;
    } catch (...) {
        AndroidBitmap_unlockPixels(env, srcBitmap);
        jclass je = env->FindClass("java/lang/Exception");
        env -> ThrowNew(je, "unknown");
        return;
    }
}

AndroidBitmapInfo 類，AndroidBitmap_getInfo 方法等位於 NDK 中，使得我們可以在 native 層方便的操作 Java 層的 Bitmap 物件,該庫是我們在 CMakeLists 檔案中通過 jnigraphics 引入的。
AndroidBitmap_getInfo 獲取了 Bitmap 的資訊，包括圖片寬高，圖片格式，然後通過 AndroidBitmap_lockPixels 獲取畫素陣列，接著通過不同的圖片格式建立不同的 Mat 容器存放畫素陣列。最後統一轉換成 RGBA 格式返回。

回到之前說的主要函式：docScanner.scanPoint()


vector Scanner::scanPoint() {
    //縮小圖片尺寸
    Mat image = resizeImage();
    //預處理圖片
    Mat scanImage = preprocessImage(image);
    vector<vector> contours;
    //提取邊框
    findContours(scanImage, contours, RETR_EXTERNAL, CHAIN_APPROX_NONE);
    //按面積排序
    std::sort(contours.begin(), contours.end(), sortByArea);
    vector result;
    if (contours.size() > 0) {
        vector contour = contours[0];
        double arc = arcLength(contour, true);
        vector outDP;
        //多變形逼近
        approxPolyDP(Mat(contour), outDP, 0.02*arc, true);
        //篩選去除相近的點
        vector selectedPoints = selectPoints(outDP, 1);
        if (selectedPoints.size() != 4) {
            //如果篩選出來之後不是四邊形，那麼使用最小矩形包裹
            RotatedRect rect = minAreaRect(contour);
            Point2f p[4];
            rect.points(p);
            result.push_back(p[0]);
            result.push_back(p[1]);
            result.push_back(p[2]);
            result.push_back(p[3]);
        } else {
            result = selectedPoints;
        }
        for(Point &p : result) {
            p.x *= resizeScale;
            p.y *= resizeScale;
        }
    }
    // 按左上，右上，右下，左下排序
    return sortPointClockwise(result);
}

1. 縮小圖片尺寸：


Mat Scanner::resizeImage() {
    int width = srcBitmap.cols;
    int height = srcBitmap.rows;
    int maxSize = width > height? width : height;
    if (maxSize > resizeThreshold) {
        resizeScale = 1.0f * maxSize / resizeThreshold;
        width = static_cast(width / resizeScale);
        height = static_cast(height / resizeScale);
        Size size(width, height);
        Mat resizedBitmap(size, CV_8UC3);
        resize(srcBitmap, resizedBitmap, size);
        return resizedBitmap;
    }
    return srcBitmap;
}

縮小圖片尺寸對 OpenCV 來說非常簡單，建立一個目標大小的 Size 物件， 建立一個目標大小的 Mat 物件，最後呼叫 resize 就 OK 了。

2. 預處理圖片


Mat Scanner::preprocessImage(Mat& image) {
    Mat grayMat;
    cvtColor(image, grayMat, CV_BGR2GRAY);
    Mat blurMat;
    GaussianBlur(grayMat, blurMat, Size(5,5), 0);
    Mat cannyMat;
    Canny(blurMat, cannyMat, 0, 5);
    return cannyMat;
}

使用 cvtColor 將圖片轉換成灰度圖片；使用 GaussianBlur 對圖片做高斯模糊，減少噪點；使用 Canny 做邊緣檢測，此時圖片會變成黑底，白色細線
描圖片內容邊界的圖片，像下面這樣：

後面的處理就是基於這種圖片的。

3. 提取圖片邊框：


    vector<vector> contours;
    //提取邊框
    findContours(scanImage, contours, RETR_EXTERNAL, CHAIN_APPROX_NONE);
    //按面積排序
    std::sort(contours.begin(), contours.end(), sortByArea);
    vector result;
    if (contours.size() > 0) {
        vector contour = contours[0];
        double arc = arcLength(contour, true);
        vector outDP;
        //多變形逼近
        approxPolyDP(Mat(contour), outDP, 0.02*arc, true);
        //篩選去除相近的點
        vector selectedPoints = selectPoints(outDP, 1);
        if (selectedPoints.size() != 4) {
            //如果篩選出來之後不是四邊形，那麼使用最小矩形包裹
            RotatedRect rect = minAreaRect(contour);
            Point2f p[4];
            rect.points(p);
            result.push_back(p[0]);
            result.push_back(p[1]);
            result.push_back(p[2]);
            result.push_back(p[3]);
        } else {
            result = selectedPoints;
        }
        for(Point &p : result) {
            p.x *= resizeScale;
            p.y *= resizeScale;
        }
    }

OpenCV 的 findContours 方法能提取出所有線段，以陣列的方式返回。然後呼叫 std::sort 按面積排序，注意最後一個引數 sortByArea 是一個函式指標，用於指定排序的規則：


static bool sortByArea(const vector &v1, const vector &v2) {
    double v1Area = fabs(contourArea(Mat(v1)));
    double v2Area = fabs(contourArea(Mat(v2)));
    return v1Area > v2Area;
}

使用 contourArea 可以很方便的計算閉合影象的面積。
找出最大面積的邊界之後使用 approxPolyDP 多邊形逼近來減少線段數量，期望是四邊形，也就是 4 條線段。然後呼叫 selectPoints 去除一些誤判的相近的點：


vector Scanner::selectPoints(vector points, int selectTimes) {
    if (points.size() > 4) {
        double arc = arcLength(points, true);
        vector::iterator itor = points.begin();
        while (itor != points.end()) {
            if (points.size() == 4) {
                return points;
            }
            Point& p = *itor;
            if (itor != points.begin()) {
                Point& lastP = *(itor - 1);
                double pointLength = sqrt(pow((p.x-lastP.x),2) + pow((p.y-lastP.y),2));
                if(pointLength < arc * 0.01 * selectTimes && points.size() > 4) {
                    itor = points.erase(itor);
                    continue;
                }
            }
            itor++;
        }
        if (points.size() > 4) {
            return selectPoints(points, selectTimes + 1);
        }
    }
    return points;
}

這裡使用了遞迴，返回值預期是大小為4的陣列。
如果篩選出來的陣列大小不是 4，就使用 OpenCV 的 minAreaRect 獲取最小外接侷限作為妥協值。

4. 將頂點按左上，右上，右下，左下排序


vector Scanner::sortPointClockwise(vector points) {
    if (points.size() != 4) {
        return points;
    }
    Point unFoundPoint;
    vector result = {unFoundPoint, unFoundPoint, unFoundPoint, unFoundPoint};
    long minDistance = -1;
    for(Point &point : points) {
        long distance = point.x * point.x + point.y * point.y;
        if(minDistance == -1 || distance < minDistance) {
            result[0] = point;
            minDistance = distance;
        }
    }
    if (result[0] != unFoundPoint) {
        Point &leftTop = result[0];
        points.erase(std::remove(points.begin(), points.end(), leftTop));
        if ((pointSideLine(leftTop, points[0], points[1]) * pointSideLine(leftTop, points[0], points[2])) < 0) {
            result[2] = points[0];
        } else if ((pointSideLine(leftTop, points[1], points[0]) * pointSideLine(leftTop, points[1], points[2])) < 0) {
            result[2] = points[1];
        } else if ((pointSideLine(leftTop, points[2], points[0]) * pointSideLine(leftTop, points[2], points[1])) < 0) { result[2] = points[2]; } } if (result[0] != unFoundPoint && result[2] != unFoundPoint) { Point &leftTop = result[0]; Point &rightBottom = result[2]; points.erase(std::remove(points.begin(), points.end(), rightBottom)); if (pointSideLine(leftTop, rightBottom, points[0]) > 0) {
            result[1] = points[0];
            result[3] = points[1];
        } else {
            result[1] = points[1];
            result[3] = points[0];
        }
    }
    if (result[0] != unFoundPoint && result[1] != unFoundPoint && result[2] != unFoundPoint && result[3] != unFoundPoint) {
        return result;
    }
    return points;
}

已知四個頂點形成的四邊形為凸四邊形（入參做判斷），預設以距離頂點（0，0）最近的點作為左上，然後找一個點與該點相連，如果此時另外兩個點分別位於這條線的兩側，那麼這條線就位對角線，該點為右下。位於這條線上方的為右上，下發的為左下。
以上就是邊框識別的所有內容，

邊框裁剪

裁剪相對比較簡單一些，下面是通過4個頂點作透視變換裁剪出想要的圖片：


static void native_crop(JNIEnv *env, jclass type, jobject srcBitmap, jobjectArray points_, jobject outBitmap) {
    std::vector points = pointsToNative(env, points_);
    if (points.size() != 4) {
        return;
    }
    Point leftTop = points[0];
    Point rightTop = points[1];
    Point rightBottom = points[2];
    Point leftBottom = points[3];

    Mat srcBitmapMat;
    bitmap_to_mat(env, srcBitmap, srcBitmapMat);

    AndroidBitmapInfo outBitmapInfo;
    AndroidBitmap_getInfo(env, outBitmap, &outBitmapInfo);
    Mat dstBitmapMat;
    int newHeight = outBitmapInfo.height;
    int newWidth = outBitmapInfo.width;
    dstBitmapMat = Mat::zeros(newHeight, newWidth, srcBitmapMat.type());

    vector srcTriangle;
    vector dstTriangle;

    srcTriangle.push_back(Point2f(leftTop.x, leftTop.y));
    srcTriangle.push_back(Point2f(rightTop.x, rightTop.y));
    srcTriangle.push_back(Point2f(leftBottom.x, leftBottom.y));
    srcTriangle.push_back(Point2f(rightBottom.x, rightBottom.y));

    dstTriangle.push_back(Point2f(0, 0));
    dstTriangle.push_back(Point2f(newWidth, 0));
    dstTriangle.push_back(Point2f(0, newHeight));
    dstTriangle.push_back(Point2f(newWidth, newHeight));

    Mat transform = getPerspectiveTransform(srcTriangle, dstTriangle);
    warpPerspective(srcBitmapMat, dstBitmapMat, transform, dstBitmapMat.size());

    mat_to_bitmap(env, dstBitmapMat, outBitmap);
}

還是使用 bitmap_to_mat 讀出圖片資訊，分別使用 srcTriangle、dstTriangle 儲存待裁剪的區域頂點與裁剪頂點，可以看到裁剪的4個頂點分別對應圖片的4個頂點，通過 getPerspectiveTransform 獲得變換矩陣，然後運用變換 warpPerspective 得到裁剪好的 Mat 物件， 最後將 Mat 物件轉換回 Bitmap 物件。

關於 UI 實現部分就不詳細介紹了，全部內容位於 CropImageView 中。最後再說幾句，使用 OpenCV 做邊框識別還是有很多侷限性，容易受背景顏色，其他邊框的干擾，如果待識別物體與背景的顏色很相似，那麼可能就識別不出來，或者背景有複雜的線也會干擾識別。之前看過一篇文章使用 TensorFlow 結合 OpenCV 來識別邊框的方式能很好的彌補單純用 OpenCV 來做識別的侷限性，可以參考：手機端運行卷積神經網路的一次實踐 — 基於 TensorFlow 和 OpenCV 實現文件檢測功能。

相關推薦

Android 端基於 OpenCV 的邊框識別功能

智慧圖片裁剪庫：SmartCropper，選擇照片之後會自動識別出邊框的位置，適用於身份證，名片，文件等照片的裁剪。本篇文章主要就邊框識別部分說一下開發過程及實現原理，通過閱讀本篇文章，你將具備以下技能： 瞭解 NDK 開發的基本步驟，能使用 Java、C++/C 混合開

android端使用openCV與深度學習實現車牌識別

車牌識別的應用場景隨處可見：高速公路上超速抓拍、小區門口關卡、車庫入口關卡，甚至出現在車載裝置上。它的工作原理大致這樣：使用攝像頭充當“眼睛”，使用openCV與深度學習充當“大腦”。實時車牌識別工作

android端使用openCV實現車牌檢測

        現在，汽車的蹤影無處不在，公路上疾馳，大街邊臨停，小區中停靠，車庫裡停泊。管理監控如此龐大數量的汽車是個頭疼的問題。精明的人們把目光放在車牌上，因為車牌是汽車的“身份證”。所以車牌識別

React Native呼叫Android原生程式碼實現車牌識別功能【附效果圖附原始碼】

        這段時間研究了下React Native，Facebook推出的，結合了Web應用和Native應用的優勢，可以使用JavaScript來開發iOS和Android原生應用，決定簡單研究下，於是開始搭建環境，編寫HelloWorld，完成後又覺得HelloWo

基於OpenCV性別識別

描述 所謂性別識別就是判斷檢測出來的臉是男性還是女性，是個二元分類問題。識別所用的演算法可以是SVM，BP神經網路，LDA，PCA，PCA+LDA等等。OpenCV官網給出的文件是基於Fisherfaces檢測器（LDA）方法實現的。連結：http://doc

基於Eros的Android端功能增強的工具類庫

當前工具類支援--基礎依賴包wxframework <= 1.0.9 的版本 如果您的基礎依賴包wxframework的版本 > 1.0.9 , 為了使該工具類繼續可以使用， 可前往: Eros-plugin-android-extend 基於Eros框架下的

Android Camera動態人臉識別+人臉檢測基於OpenCV(無需OpenCVManager)

       最近因為需要實現了一下人臉識別,實現了這個功能之後,就想著把踩過的坑總結出來。參考過許多部落格,發現主要有兩種形式,一種是基於 android SDK 實現人臉檢測,而另一種是利用open

基於 OpenCV 的人臉識別

權重 apc 更多 你在 控制 leg 神經網絡 註意事項 初始化 基於 OpenCV 的人臉識別 一點背景知識 OpenCV 是一個開源的計算機視覺和機器學習庫。它包含成千上萬優化過的算法，為各種計算機視覺應用提供了一個通用工具包。根據這個項目的關於頁面，OpenCV

我的畢設-基於OpenCV的圖像車牌識別（I）

應該 details 計算 inpu eight 切換 named path變量 pen 由於大三以來一直在學路由交換和Linux方面，所以Coding能力大幅下降，加上畢設老師指定了一個完全不會的題目，恍如晴天霹靂，硬著頭皮接下了任務，查閱了相關資料以後暫定使用OpenC

SmileyFace——基於OpenCV的人臉人眼檢測、面部識別程序

tro 識別 open HR tps 應用 動態 框圖 顯示 項目地址 https://github.com/guoyaohua/SmileyFace 開發環境 Visual Studio 2010 MFC + OpenCV 功能描述 靜態圖像人臉檢測 視頻人臉追蹤檢測

關於基於Linphone的視頻通話Android端開發過程中遇到的問題

浪費 phone 模式 需要 class 通話 其他 了解 同時 關於基於Linphone的視頻通話Android端開發過程中遇到的問題　　 　　運用開源項目Linphone的SDK進行開發，由於是小組進行開發，我主要負責的是界面部分。 　　由於當時是初學Android開發

Java基於opencv實現圖像數字識別(一)

binary oid ring 是把 sca pre 內存 還需要 自己 Java基於opencv實現圖像數字識別(一) 最近分到了一個任務，要做數字識別，我分配到的任務是把數字一個個的分開；當時一臉懵逼，直接百度java如何分割圖片中的數字，然後就百度到了用Buffere

Java基於opencv實現圖像數字識別(二)—基本流程

數字 都是 模型 PE 設計 category 理解 兩種 ace Java基於opencv實現圖像數字識別(二)—基本流程 做一個項目之前呢，我們應該有一個總體把握，或者是進度條；來一步步的督促著我們來完成這個項目，在我們正式開始前呢，我們先討論下流程。 我做的主要是表格

Android 6.0 指紋識別功能學習（一）----阿冬專欄！！！

轉載自：http://www.cnblogs.com/changyuet/p/5535082.html     由於畢設需要設計增強的身份認證（生物特徵認證方式），所以需要學習指紋識別相關的android6.0功能，進而設計自己的畢設：支援媒體可信通訊的andro

怎麼才能在APP裡實現移動端車牌識別功能？

隨著移動通訊技術和網際網路技術的不斷髮展, 使手機成為了重要的生產和生活工具, 手機已經成為資訊時代中最重要的資訊來源。企業為了迎合市場需求，也紛紛加入了移動互聯大軍，到現在基於手機端的APP已經深入到人們生活中的方方面面。那麼在APP中整合移動端車牌識別演算法需要注意哪些事項呢？ 移動端車牌識別OCR

怎麽才能在APP裏實現移動端車牌識別功能？

作者 手機 方案 聯網 mar nag -a 點擊 ima 隨著移動通信技術和互聯網技術的不斷發展, 使手機成為了重要的生產和生活工具, 手機已經成為信息時代中最重要的信息來源。企業為了迎合市場需求，也紛紛加入了移動互聯大軍，到現在基於手機端的APP已經深入到人們生活中的方

Android 二維碼開發功能實現(四)------基於Zxing實現編碼功能(生成二維碼,一維碼等)

Android 二維碼開發功能實現(四)------基於Zxing實現編碼功能(生成二維碼,一維碼等) 前言 關於Google的開源庫Zxing,前面也寫了幾遍文章進行介紹.我們先簡單的回顧一下! Android 二維碼的掃碼功能實現（一） 這篇文章主要介紹了,Zxi

可以用手機實現的移動端車牌識別功能

可以用手機實現的移動端車牌識別功能 關鍵詞：ios車牌識別、移動端車牌識別技術、手機端車牌識別、OCR車牌識別、手機端車牌識別、移動車牌識別技術、車牌識別技術移動端。 移動端車牌識別OCR技術描述 移動端車牌識別OCR技術是我公司開發的基於移動平臺的車牌識別軟體開發包，支援android、ios等多種主

基於藍芽介面卡的PC與Android端通訊

Demo 首先，直接給Demo，對於只想使用的朋友，直接下載使用即可。Demo其實也是從網上爬來的，之後做了各種除錯和修改。 原有Demo程式碼下載，可見地址。 修改後Demo效果如下。效果不太清晰，見諒。 （1）PC端 （2）Android端 細節實現 Android端a

基於opencv的數字識別

    最近學習了opencv，然後想通過其對圖片上的數字進行識別，參考了網上幾篇關於opencv數字識別的部落格，我自己也寫了一個程式玩玩。我是在vs2017和opencv3.4.1環境下實現的。     這裡先說一下我的思路和步驟：