CGO入门和OCR文字识别（非第三方API，有源码，效果好）实战

最新推荐文章于 2024-08-22 08:10:23 发布
最新推荐文章于 2024-08-22 08:10:23 发布
阅读量1.7k 收藏 3
点赞数
分类专栏： Golang学习和进阶 文章标签： cgo ocr识别 cgo入门 cgo字符串 cgo数组
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xmcy001122/article/details/119795546
版权

文章目录

CGO入门和OCR文字识别（非第三方API，有源码，效果好）实战

CGO是什么

简单点来讲，如果要调用C++，C写的库（动态库，静态库），那么就需要使用Cgo。其他情况下一般用不到，只需要知道Go能调用C就行了，当然C也可以回调到Go中。

使用Cgo有2种姿势：

  1. 直接在go中写c代码
  2. go调用so动态库（c++要用extern “c”导出）

为了熟悉CGO，我们先介绍第一种方法，直接在Go中写C代码。

极简入门

引用：Command cgo
首先，通过import “C”导入伪包（这个包并不真实存在，也不会被Go的compile组件见到，它会在编译前被CGO工具捕捉到，并做一些代码的改写和桩文件的生成）

import "C"

然后，Go 就可以使用C的变量和函数了， C.size_t 之类的类型、诸如 C.stdout 之类的变量或诸如 C.putchar 之类的函数。

func main(){
    cInt := C.int(1)     // 使用C中的int类型
    fmt.Println(goInt)

    ptr := C.malloc(20)  // 调用C中的函数
    fmt.Println(ptr)     // 打印指针地址
    C.free(ptr)          // 释放，需要 #include <stdlib.h>
}

如果“C”的导入紧跟在注释之前，则该注释称为序言。例如：

// #include <stdio.h> 
/* #include <errno.h> */
import "C"

序言可以包含任何 C 代码，包括函数和变量声明和定义。然后可以从 Go 代码中引用它们，就好像它们是在包“C”中定义的一样。可以使用序言中声明的所有名称，即使它们以小写字母开头。例外：序言中的静态变量不能从 Go 代码中引用；静态函数是允许的。

所以，你可以直接在/**/里面写C代码（注意，C++不行！）：

package main

/*
int add(int a,int b){
   return a+b;
}
*/
import "C"
import "fmt"

func main() {
    a, b := 1, 2
    c := C.add(a, b)
}

编译下，会出现下面的问题（ fmt.Println(C.add(1, 2)) 能编译通过，思考下为什么？ ）：

./main.go:20:12: cannot use a (type int) as type _Ctype_int in argument to _Cfunc_add
./main.go:20:12: cannot use b (type int) as type _Ctype_int in argument to _Cfunc_add

为什么呢？因为C没有办法使用Go的类型，必须先转换成CGO类型才可以，改成这样就行了：

func main() {
   cgoIntA, cgoIntB := C.int(1), C.int(2)

   c := C.add(cgoIntA, cgoIntB)
   fmt.Println(c)
}

运行后输出：

3

CGO基础类型

就像上面的代码一样，Go没有办法直接使用C的东西，必须先转换成CGO类型，下面是一个基础类型对应表。

C类型CGO类型GO类型
charC.charbyte
signed charC.scharint8
unsigned charC.ucharuint8
shortC.shortint16
unsigned shortC.ushortuint16
intC.intint32
unsigned intC.uintuint32
longC.longint32
unsigned longC.ulonguint32
long long intC.longlongint64
unsigned long long intC.ulonglonguint64
floatC.floatfloat32
doubleC.doublefloat64
size_tC.size_tuint

如果直接在C中#include <stdint.h>，则类型关系就比较一致了，例如：

C类型CGO类型GO类型
int8_tC.int8_tint8
int16_tC.int16_tint16
uint32_tC.uint32_tuint32
uint64_tC.uint64_tuint64

字符串、数组和函数调用

那么，在Go要如何传递字符串、字节数组以及指针？
CGO的C虚拟包提供了以下一组函数，用于Go语言和C语言之间数组和字符串的双向转换：

// Go string to C string
// The C string is allocated in the C heap using malloc.
// It is the caller's responsibility to arrange for it to be
// freed, such as by calling C.free (be sure to include stdlib.h
// if C.free is needed).
func C.CString(string) *C.char

// Go []byte slice to C array
// The C array is allocated in the C heap using malloc.
// It is the caller's responsibility to arrange for it to be
// freed, such as by calling C.free (be sure to include stdlib.h
// if C.free is needed).
func C.CBytes([]byte) unsafe.Pointer

// C string to Go string
func C.GoString(*C.char) string

// C data with explicit length to Go string
func C.GoStringN(*C.char, C.int) string

// C data with explicit length to Go []byte
func C.GoBytes(unsafe.Pointer, C.int) []byte

字符串，可以通过C.CString()函数（别忘记通过free释放）：

// 通过C.CString，这里会发生内存拷贝，cgo通过malloc重新开辟了一块空间，使用完需要释放，否则内存泄露
imagePath := C.CString("a.png")
defer C.free(unsafe.Pointer(imagePath))

字节数组，直接使用go的数组，然后强制转换即可：

// 只能使用数组，无法使用切片用作缓冲区给C使用
var buffer [20]byte
// &buffer[0]: 数组在内存中是连续存储的，取首地址
// unsafe.Pointer()：转换为非安全指针，类型是*unsafe.Pointer
// (*C.char)()：再强转一次
cBuffer := (*C.char)(unsafe.Pointer(&buffer[0]))

对应类型的指针，直接使用Cgo类型，然后&取地址即可：
bufferLen := C.int(20)
cPoint := &bufferLen      // cPoint在CGO中是*C.int类型，在C中是*int类型。

假如ocr识别函数如下：

int detect(const char* image_path, char * out_buffer, int *len);

有3个参数：

  • image_path：指示了要识别的图片路径。
  • out_buffer：识别到的文字输出到这里，是一个char字节数组。
  • len：指示输出字节缓冲区大小，调用成功后，值变成字符串长度，便于外界读取。

在go中调用方式如下:

imagePath := C.CString("a.png")
defer C.free(unsafe.Pointer(imagePath))

var buffer [20]byte
bufferLen := C.int(20)
cInt := C.detect(imagePath, (*C.char)(unsafe.Pointer(&buffer[0])), &bufferLen)
if cInt == 0 {
   fmt.Println(string(buffer[0:bufferLen]))
}

CGO实战

分离Go和C代码

为了简化代码，我们可以把C的代码放到xxx.h和xxx.c中实现。

有以下结构：

├── hello.c
├── hello.h
└── main.go

hello.h的内容：

#include <stdio.h>

void sayHello(const char* text);

hello.c：

#include "hello.h"

void sayHello(const char* text){
    printf("%s", text);
}

main.go中调用hello.h中的函数：

#include "hello.h"
import "C" // 必须放在导入c代码活头文件的注释后面，否则不生效

func main() {
    cStr := C.CString("hello from go")
    defer C.free(unsafe.Pointer(cStr))
    C.sayHello(cStr)
}

常用cgo编译指令

如果我们把h和c文件放到其他目录，则编译会报错：

├── main.go
└── mylib
    ├── hello.c
    └── hello.h

Undefined symbols for architecture x86_64:
  "_sayHello", referenced from:
      __cgo_7ab15a91ce47_Cfunc_sayHello in _x002.o
     (maybe you meant: __cgo_7ab15a91ce47_Cfunc_sayHello)
ld: symbol(s) not found for architecture x86_64
clang: error: linker command failed with exit code 1 (use -v to see invocation)

这里应该可以使用#cgo预编译解决（CFLAGS、CPPFLAGS、CXXFLAGS、FFLAGS和LDFLAGS） ：

// #cgo CFLAGS: -DPNG_DEBUG=1 -I ./include
// #cgo LDFLAGS: -L /usr/local/lib -lpng
// #include <png.h>
import "C"
  • CFLAGS：-D部分定义了宏PNG_DEBUG，值为1。-I定义了头文件包含的检索目录
  • LDFLAGS：-L指定了链接时库文件检索目录，-l指定了链接时需要链接png库

通常实际的工作中遇到要使用cgo的场景，都是调用动态库的方式，所以这里没有继续往下深究上面的错误如何解决了。

调用C静态库和动态库

目录结构如下：

├── call_shared_lib
│   └── main.go
├── call_static_lib
│   └── main.go
└── mylib
    ├── hello.c
    ├── hello.h
    ├── libhello.a
    └── libhello.so
静态库

把上面的hello.h 和 hello.c 生成为静态库（需要安装gcc，省略）：

# 生成o对象
$ gcc -c hello.c
# 生成静态库
$ ar crv libhello.a hello.o

# 查看里面包含的内容
# ar -t libhello.a
# 使用静态库
#gcc main.c libhello.a -o main

在go中调用：

package main

/*
#cgo CFLAGS: -I ../mylib
#cgo LDFLAGS: -L ../mylib -lhello
#include <stdlib.h>
#include "hello.h"
 */
import "C"
import "unsafe"

func main() {
   cStr := C.CString("hello from go")
   defer C.free(unsafe.Pointer(cStr))

   C.sayHello(cStr)
}
  • CFLAGS：C的编译参数，-I指示 include路径
  • LDFLAGS: 链接参数，-L 指示搜索静态库的路径，-lhello表示链接libhello.a，记住lib这里不用写，编译器会自己补全。
动态库

生成

# 生成o对象
$ gcc -fPIC -c hello.c
# 生成动态库
$ gcc -shared -fPIC -o libhello.so hello.o

# 使用动态库
#gcc main.c -L. -lhello -o main

Go中调用和静态库一样：

package main


// 注意，生成的so文件一定的得增加lib前缀，如libhello.so
// 然后在Go中只需要写-lhello（代表libhello.a或libhello.so）即可
// linux下会自动增加lib前缀。

/*
#cgo CFLAGS: -I ../mylib
#cgo LDFLAGS: -L ../mylib -lhello
#include <stdlib.h>
#include "hello.h"
 */
import "C"
import "unsafe"

func main() {
   cStr := C.CString("hello from go")
   defer C.free(unsafe.Pointer(cStr))

   C.sayHello(cStr)
}

唯一不同的是，静态库需要指定so文件的搜索路径或者把so动态库拷贝到/usr/lib下，在环境变量中配置：

$ export LD_LIBRARY_PATH=../mylib
$ go run main.go

# 也可以在goland中在Run -> Edit Configurations -> Environment 
# 配置 LD_LIBRARY_PATH=../mylib ，方便调试

更多关于静态库和动态库的区别：https://segmentfault.com/a/1190000020651578

调用C++动态库

本质上和调用c动态库在Go的写法上是一样的，只是需要导出成C风格的即可：

#ifdef __cplusplus
extern "C"
{
#else

// 导出C 命名风格函数，函数名字和定义的一样，C++因为支持重载，所以导出的函数名被编译器改变了

#ifdef __cplusplus
}
#endif

然后在go的LDFLAGS中增加 -lstdc++：

#cgo LDFLAGS: -L ../mylib -lhello -lstdc++

CGO的缺陷

cgo is not Go中总结了cgo 的缺点：

  1. 编译变慢，实际会使用 c 语言编译工具，还要处理 c 语言的跨平台问题
  2. 编译变得复杂
  3. 不支持交叉编译
  4. 其他很多 go 语言的工具不能使用
  5. C 与 Go 语言之间的的互相调用繁琐，是会有性能开销的
  6. C 语言是主导，这时候 go 变得不重要，其实和你用 python 调用 c 一样
  7. 部署复杂，不再只是一个简单的二进制

这篇文章描述了CGO通过go去调用C性能开销大的原因：https://blog.csdn.net/u010853261/article/details/108186405

  • 必须切换go的协程栈到系统线程的主栈去执行C函数
  • 涉及到系统调用以及协程的调度。
  • 由于需要同时保留C/C++的运行时，CGO需要在两个运行时和两个ABI（抽象二进制接口）之间做翻译和协调。这就带来了很大的开销。

《GO原本》中进一步通过runtime源码解读了原因。

所以，使用的时候，自己灵活根据场景取舍吧。

CGO最佳使用场景总结

CGO的一些缺点：

  1. 内存隔离
  2. C函数执行切换到g0(系统线程)
  3. 收到GOMAXPROC线程限制
  4. CGO空调用的性能损耗(50+ns)
  5. 编译损耗(CGO其实是有个中间层)

CGO 适合的场景：

  1. C 函数是个大计算任务(不在乎CGO调用性能损耗)
  2. C 函数调用不频繁
  3. C 函数中不存在阻塞IO
  4. C 函数中不存在新建线程(与go里面协程调度由潜在可能互相影响)
  5. 不在乎编译以及部署的复杂性

更多可以阅读：

CGO案例：在Go中调用动态库实现OCR文字识别

chineseocr_lite介绍

GitHub: https://github.com/DayBreak-u/chineseocr_lite
Star: 7.1 k
介绍：超轻量级中文ocr，支持竖排文字识别, 支持ncnn、mnn、tnn推理 ( dbnet(1.8M) + crnn(2.5M) + anglenet(378KB)) 总模型仅4.7M。

这个开源项目提供了C++、JVM、Android、.Net等实现，只依赖OpenCV和微软的Onnx推理框架，有源码，经作者实践，识别效果中等，越小的图片越快。

识别效果

比如识别一个发票号码，只需要50ms左右：
在这里插入图片描述
复杂的图片识别大概500-900ms左右：
在这里插入图片描述

表格识别效果一般
在这里插入图片描述

所以，适合格式一致的识别场景。比如发票的某个位置，身份证，银行卡等等。

编译chineseocr_lite

按照 chineseocr_lite/cpp_projects/OcrLiteOnnx 中的README.md文档编译即可，推荐在Linux下，我再windows和Macos没编译通过。

然后需要改造成动态库，我改动的内容有：

  • 默认生成动态库，给ocr_http_server使用
  • 去掉jni的支持
  • 增加ocr.h，导出c风格函数

导出c函数

ocr.h

/** @file ocr.h
  * @brief  封装给GO调用
  * @author teng.qing
  * @date 8/13/21
  */
#ifndef ONLINE_BASE_OCRLITEONNX_OCR_H
#define ONLINE_BASE_OCRLITEONNX_OCR_H

#ifdef __cplusplus
extern "C"
{
#else
    // c
    typedef enum{
        false, true
    }bool;
#endif

const int kOcrError = 0;
const int kOcrSuccess = 1;
const int kDefaultPadding = 50;
const int kDefaultMaxSideLen = 1024;
const float kDefaultBoxScoreThresh = 0.6f;
const float kDefaultBoxThresh = 0.3f;
const float kDefaultUnClipRatio = 2.0f;
const bool kDefaultDoAngle = true;
const bool kDefaultMostAngle = true;

/**@fn ocr_init
  *@brief 初始化OCR
  *@param numThread: 线程数量，不超过CPU数量
  *@param dbNetPath: dbnet模型路径
  *@param anglePath: 角度识别模型路径
  *@param crnnPath: crnn推理模型路径
  *@param keyPath: keys.txt样本路径
  *@return <0: error, >0: instance
  */
int ocr_init(int numThread, const char *dbNetPath, const char *anglePath, const char *crnnPath, const char *keyPath);

/**@fn ocr_cleanup
  *@brief 清理，退出程序前执行
  */
void ocr_cleanup();

/**@fn ocr_detect
  *@brief 识别图片
  *@param image_path: 图片完整路径，会在同路径下生成图片识别框选效果，便于调试
  *@param out_json_result: 识别结果输出，json格式。
  *@param buffer_len: 输出缓冲区大小
  *@param padding: 50
  *@param maxSideLen: 1024
  *@param boxScoreThresh: 0.6f
  *@param boxThresh: 0.3f
  *@param unClipRatio: 2.0f
  *@param doAngle: true
  *@param mostAngle: true
  *@return 成功与否
  */
int ocr_detect(const char *image_path, char *out_buffer, int *buffer_len, int padding, int maxSideLen,
                float boxScoreThresh, float boxThresh, float unClipRatio, bool doAngle, bool mostAngle);
                
/**@fn ocr_detect
  *@brief 使用默认参数，识别图片
  *@param image_path: 图片完整路径
  *@param out_buffer: 识别结果，json格式。
  *@param buffer_len: 输出缓冲区大小
  *@return 成功与否
  */
int ocr_detect2(const char *image_path, char *out_buffer, int *buffer_len);

#ifdef __cplusplus
}
#endif

#endif //ONLINE_BASE_OCRLITEONNX_OCR_H

ocr.cpp

/** @file ocr.h
  * @brief 
  * @author teng.qing
  * @date 8/13/21
  */
#include "ocr.h"
#include "OcrLite.h"
#include "omp.h"
#include "json.hpp"
#include <iostream>
#include <sys/stat.h>

using json = nlohmann::json;

static OcrLite *g_ocrLite = nullptr;

inline bool isFileExists(const char *name) {
    struct stat buffer{};
    return (stat(name, &buffer) == 0);
}

int ocr_init(int numThread, const char *dbNetPath, const char *anglePath, const char *crnnPath, const char *keyPath) {
    omp_set_num_threads(numThread); // 并行计算
    if (g_ocrLite == nullptr) {
        g_ocrLite = new OcrLite();
    }
    g_ocrLite->setNumThread(numThread);
    g_ocrLite->initLogger(
            true,//isOutputConsole
            false,//isOutputPartImg
            true);//isOutputResultImg
    g_ocrLite->Logger(
            "ocr_init numThread=%d, dbNetPath=%s,anglePath=%s,crnnPath=%s,keyPath=%s \n",
            numThread, dbNetPath, anglePath, crnnPath, keyPath);
    if (!isFileExists(dbNetPath) || !isFileExists(anglePath) || !isFileExists(crnnPath) || !isFileExists(keyPath)) {
        g_ocrLite->Logger("invalid file path.\n");
        return kOcrError;
    }
    g_ocrLite->initModels(dbNetPath, anglePath, crnnPath, keyPath);
    return kOcrSuccess;
}

void ocr_cleanup() {
    if (g_ocrLite != nullptr) {
        delete g_ocrLite;
        g_ocrLite = nullptr;
    }
}

int ocr_detect(const char *image_path, char *out_buffer, int *buffer_len, int padding, int maxSideLen,
               float boxScoreThresh, float boxThresh, float unClipRatio, bool doAngle, bool mostAngle) {
    if (g_ocrLite == nullptr) {
        return kOcrError;
    }
    if (!isFileExists(image_path)) {
        return kOcrError;
    }
    g_ocrLite->Logger(
            "padding(%d),maxSideLen(%d),boxScoreThresh(%f),boxThresh(%f),unClipRatio(%f),doAngle(%d),mostAngle(%d)\n",
            padding, maxSideLen, boxScoreThresh, boxThresh, unClipRatio, doAngle, mostAngle);
    OcrResult result = g_ocrLite->detect("", image_path, padding, maxSideLen,
                                         boxScoreThresh, boxThresh, unClipRatio, doAngle, mostAngle);
    json root;
    root["dbNetTime"] = result.dbNetTime;
    root["detectTime"] = result.detectTime;
    for (const auto &item : result.textBlocks) {
        json textBlock;
        for (const auto &boxPoint : item.boxPoint) {
            json point;
            point["x"] = boxPoint.x;
            point["y"] = boxPoint.y;
            textBlock["boxPoint"].push_back(point);
        }
        for (const auto &score : item.charScores) {
            textBlock["charScores"].push_back(score);
        }
        textBlock["text"] = item.text;
        textBlock["boxScore"] = item.boxScore;
        textBlock["angleIndex"] = item.angleIndex;
        textBlock["angleScore"] = item.angleScore;
        textBlock["angleTime"] = item.angleTime;
        textBlock["crnnTime"] = item.crnnTime;
        textBlock["blockTime"] = item.blockTime;
        root["textBlocks"].push_back(textBlock);
        root["texts"].push_back(item.text);
    }
    std::string tempJsonStr = root.dump();
    if (static_cast<int>(tempJsonStr.length()) > *buffer_len) {
        g_ocrLite->Logger("buff_len is too small \n");
        return kOcrError;
    }
    *buffer_len = static_cast<int>(tempJsonStr.length());
    ::memcpy(out_buffer, tempJsonStr.c_str(), tempJsonStr.length());
    return kOcrSuccess;
}

int ocr_detect2(const char *image_path, char *out_buffer, int *buffer_len) {
    return ocr_detect(image_path, out_buffer, buffer_len, kDefaultPadding, kDefaultMaxSideLen, kDefaultBoxScoreThresh,
                      kDefaultBoxThresh, kDefaultUnClipRatio, kDefaultDoAngle, kDefaultMostAngle);
}

ocr_wrapper.go

package ocr

// -I: 配置编译选项
// -L: 依赖库路径

/*
#cgo CFLAGS: -I ../../../OcrLiteOnnx/include
#cgo LDFLAGS: -L ../../../OcrLiteOnnx/lib -lOcrLiteOnnx -lstdc++

#include <stdlib.h>
#include <string.h>
#include "ocr.h"
*/
import "C"
import (
        "runtime"
        "unsafe"
)

//const kModelDbNet = "dbnet.onnx"
//const kModelAngle = "angle_net.onnx"
//const kModelCRNN = "crnn_lite_lstm.onnx"
//const kModelKeys = "keys.txt"

const kDefaultBufferLen = 10 * 1024

var (
        buffer [kDefaultBufferLen]byte
)

func Init(dbNet, angle, crnn, keys string) int {
        threadNum := runtime.NumCPU()

        cDbNet := C.CString(dbNet) // to c char*
        cAngle := C.CString(angle) // to c char*
        cCRNN := C.CString(crnn)   // to c char*
        cKeys := C.CString(keys)   // to c char*

        ret := C.ocr_init(C.int(threadNum), cDbNet, cAngle, cCRNN, cKeys)

        C.free(unsafe.Pointer(cDbNet))
        C.free(unsafe.Pointer(cAngle))
        C.free(unsafe.Pointer(cCRNN))
        C.free(unsafe.Pointer(cKeys))
        return int(ret)
}

func Detect(imagePath string) (bool, string) {
        resultLen := C.int(kDefaultBufferLen)

        // 构造C的缓冲区
        cTempBuffer := (*C.char)(unsafe.Pointer(&buffer[0]))
        cImagePath := C.CString(imagePath)
        defer C.free(unsafe.Pointer(cImagePath))

        isSuccess := C.ocr_detect2(cImagePath, cTempBuffer, &resultLen)
        return int(isSuccess) == 1, C.GoStringN(cTempBuffer, resultLen)
}

func CleanUp() {
        C.ocr_cleanup()
}

环境变量设置

路径包含库所在目录，或者直接把动态库拷贝到/usr/lib中，推荐后者：

export LD_LIBRARY_PATH=../mylib

运行

效果如下
在这里插入图片描述

参考

Go和分布式IM
关注
专栏目录
Go ：验证是否检测到非法字符文字(附完整源码)
希望我的博客，能帮上你解决学习中工作中所遇到的问题
10-27 317
Go ：验证是否检测到非法字符文字(附完整源码)
探索PaddleOCR-Go：高效且灵活的Go语言版 OCR 工具
gitblog_00061的博客
04-20 1458
探索PaddleOCR-Go：高效且灵活的Go语言版 OCR 工具 项目地址:https://gitcode.com/LKKlein/paddleocr-go 在数字化和自动化日益普及的时代，光学字符识别（OCR）技术已经变得至关重要，它可以帮助我们自动识别图像中的文本并进行处理。今天，我们将要介绍的是一个基于Go语言实现的OCR工具——PaddleOCR-Go，它是源自PaddleOCR的轻量级...
OCR Lite Onnx: 基于ONNX的轻量级OCR引擎教程
最新发布
gitblog_00079的博客
08-22 571
OCR Lite Onnx: 基于ONNX的轻量级OCR引擎教程 OcrLiteOnnxchineseocr lite onnx，超轻量级中文ocr demo，支持onnx推理 ( dbnet+crnn+anglenet)项目地址:https://gitcode.com/gh_mirrors/oc/OcrLiteOnnx 项目介绍 OCR Lite Onnx 是一个专注于高效、轻量化文字识别的...
go+orc文字识别
永不秃头的博客
03-08 388
本文识别的是tiff 文件中的文字```
ocr识别
best_go_to_success的博客
06-05 1317
abc OCR在线识别 abc OCR在线识别 abc OCR在线识别 abc OCR在线识别 abc OCR在线识别 abc OCR在线识别 abc OCR在线识别 abc OCR在线识别 abc OCR在线识别 abc OCR在线识别 abc OCR在线识别
百度OCR文字识别go语言示例
懒人程序员的博客
04-08 1820
使用go实现百度OCR文字识别接口 百度OCR文字识别提供了每天50000次免费接口的调用，但是没有提供go语言示例。下面是使用go写的一个示例 package baidu import ( "compress/gzip" "encoding/base64" "encoding/json" "fmt" "io" "io/ioutil" "log" "net/http" "net/url" "os" "strings" ) const ( // 客户端凭证类型，固定为client_
使用Go实现文字识别验证码的自动化处理
asfdsgdf的博客
07-05 335
具体步骤包括提取目标文字和背景图文字，计算点击坐标并模拟点击。// 计算文字点击坐标 更多内容联系1436423940。// 使用Tesseract进行OCR识别目标文字。获取图片后，使用gosseract库识别背景图文字和位置。// 使用Tesseract识别背景图文字和位置。首先，我们需要提取目标文字的图片URL并下载。// 提取目标文字图片URL并下载。文字识别完成后，计算点击坐标并模拟点击。同样地，先提取背景图片的URL并下载。// 提取背景图片URL并下载。// 计算最终点击顺序与坐标。
【BP分类】基于matlab混沌博弈算法优化BP神经网络CGO-BP故障识别数据分类【含Matlab源码 5000期】.zip
07-10
运行结果效果图； 2、代码运行版本 Matlab 2019b；若运行有误，根据提示修改；若不会，可私信博主； 3、运行操作步骤 步骤一：将所有文件放到Matlab的当前文件夹中； 步骤二：双击打开除Main.m的其他m文件； ...
混沌博弈算法CGO-Kmean-Transformer-LSTM组合状态识别分类【含Matlab源码 6728期】.zip
08-02
运行结果效果图； 2、代码运行版本 Matlab 2019b；若运行有误，根据提示修改；若不会，可私信博主； 3、运行操作步骤 步骤一：将所有文件放到Matlab的当前文件夹中； 步骤二：双击打开除Main.m的其他m文件； ...
混沌博弈算法CGO-Kmean-Transformer-BiLSTM组合状态识别分类【含Matlab源码 6612期】.zip
08-02
运行结果效果图； 2、代码运行版本 Matlab 2019b；若运行有误，根据提示修改；若不会，可私信博主； 3、运行操作步骤 步骤一：将所有文件放到Matlab的当前文件夹中； 步骤二：双击打开除Main.m的其他m文件； ...
windows环境下cgo使用opencv和遇到的疑难问题解决
网易搬砖选手
05-06 230
最近使用opencv在做一些ai智能化的项目，其中需要使用go来调用opencv的算法来进行一些视频流的处理，硬件环境是Debian环境，需要远程开发和调试，如果多人使用远程调试则带来不便，因此在本地我更期望使用windows环境搭建一套环境来方便开发和调试。 在搭建windows环境过程中我遇到了不少调用opencv的问题，我将在本地给大家分享下我是如何解决的：目录1.下载和编译opencv库cgo调用opencv的问题整理： 问题1：macro "CVPY_TYPE" requires 7
gosseract：使用Tesseract C ++库的OCR（光学字符识别）软件包
02-04
八卦OCR 使用Tesseract C ++库的Golang OCR软件包。 OCR服务器 您是否只需要OCR服务器，或查看此软件包的工作示例？ 是的，已经有现成的服务器应用程序，非常易于部署！ :backhand_index_pointing_right: 例 package main import ( "fmt" "github.com/otiai10/gosseract/v2" ) func main () { client := gosseract . NewClient () defer client . Close () client . SetImage ( "path/to/image.png" ) text , _
ocrad.js (js版ocr)
09-21
Ocrad.js 相当于是 Ocrad 项目的纯 JavaScript 版本，使用 Emscripten 自动转换。这是一个简单的 OCR （光学字符识别）程序，可以扫描图像中的文字回文本。
ocrserver, 由Golang编写的OCR服务器，可以通过 Docker 轻松部署.zip
09-18
ocrserver, 由Golang编写的OCR服务器，可以通过 Docker 轻松部署 ocrserver 简单的OCR服务器，作为一个小的工作样本的 gosseract 。现在试试这里的 https://ocr-example.herokuapp.com/插件，现在部署你自己的。 部署到 Heroku
《自然语言处理实战入门》 第一章： 自然语言处理（NLP）技术简介
shiter编写程序的艺术
12-19 8666
本博客为《自然语言处理实战课程》---- 第一课：自然语言处理简介 讲稿 文章大纲本节课程导览1.自然语言处理（NLP）简介1.1 基础技术1.2 NLP 核心技术1.3 NLP+（高端技术）1.4 课程涵盖的主要内容总揽2.知名NLP服务系统与开源组件简介2.1 单一服务提供商2.1.1 汉语分词系统ICTCLAS2.1.2 哈工大语言云（Language Technology Platfor...
Go识别自定义命令字
迷惘宅猪的专栏
03-25 435
1.需求描述 想通过go语言实现识别自定义的消息命令字头，例如自定义命令字是：0x87 0x4b 2.format_output.go package main import ( "bytes" "encoding/binary" "fmt" ) func main() { var message []byte message = make([]b...
c语言编写ocr软件下载,OCR算法之C语言代码 - 源码下载|图形图象|图形/文字识别|源代码 - 源码中国...
weixin_30320587的博客
05-20 489
OCR算法之C语言代码..................\abstract_character.cpp..................\abstract_character.h..................\character.cpp..................\character.h..................\character_database.cpp.........
OCR识别的开源分析
热门推荐
luo2007专栏Gods determine what you're going to be！
06-08 1万+
OCR识别的开源分析OCR软件主要是由下面几个部分组成。　　1. 图像输入、预处理： 　　2. 图像输入：对于不同的图像格式，有着不同的存储格式，不同的压缩方式。预处理：主要包括二值化，噪声去除，倾斜较正等 　　3. 二值化： 　　对摄像头拍摄的图片，大多数是彩色图像，彩色图像所含信息量巨大，对于图片的内容，我们可以简单的分为前景与背景，为了让计算机更快的，更好的识别文字，我们需要先对彩色图进
Android 百度文字识别（详细步骤+源码）
晨曦
11-20 6884
运行效果图 识别到的内容： {"words_result":[{"words":"突然间有想看书的冲动"},{"words":"eel"},{"words":"你不是直正的快乐"},{"words":"你说你有点难追"},{"words":"我就打断你的腿CN"}],"log_id":1329724251397160960,"words_result_num":5,"direction":0} 百度SDK文字识别一、创建平台应用二、创建及配置Android项目三、初始化四、UI模块导入五、UI模块使用
window下 go1.19 带有Cgo的可执行源码 生成Centos下可执行文件
06-08
要在Windows下生成带有Cgo的可执行文件，你需要使用交叉编译工具链。以下是一些步骤： 1. 下载并安装 MinGW-w64 工具链。你可以从这个链接下载：https://sourceforge.net/projects/mingw-w64/files/latest/download 2. 设置环境变量。将 MinGW-w64 安装目录下的 bin 目录添加到系统 PATH 环境变量中。 3. 在 Windows 上编译你的程序。使用 `GOOS=linux GOARCH=amd64 CGO_ENABLED=1` 交叉编译选项来构建 Linux x86_64 可执行文件。例如： ``` set GOOS=linux set GOARCH=amd64 set CGO_ENABLED=1 go build -o myapp main.go ``` 这将生成一个名为 `myapp` 的可执行文件。 4. 将生成的可执行文件上传到 CentOS 服务器上。 5. 如果你的 CentOS 服务器是 x86_64 架构，则无需任何其他操作即可运行可执行文件。如果你的服务器是其他架构，则需要使用相应的交叉编译工具链生成适用于该架构的可执行文件。 希望这些步骤对你有所帮助！
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值