esp32 camera的简单使用 crop +EloquentVision

已于 2023-05-12 16:09:51 修改
阅读量704 收藏 3
点赞数
分类专栏： 硬件和移动端 文章标签： 单片机 stm32 mysql
于 2023-05-07 19:07:35 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ResumeProject/article/details/128695578
版权

简单使用

  • 去github官方看看camera是如何调用的，按照官方的提示进行简单的修改Serial.println(fb->len); //Serial.println(fb->width); Serial.println(fb->height);Serial.println(fb->format);
    在这里插入图片描述

全部代码

#include "esp_camera.h"

#define PWDN_GPIO_NUM     32
#define RESET_GPIO_NUM    -1
#define XCLK_GPIO_NUM      0
#define SIOD_GPIO_NUM     26
#define SIOC_GPIO_NUM     27

#define Y9_GPIO_NUM       35
#define Y8_GPIO_NUM       34
#define Y7_GPIO_NUM       39
#define Y6_GPIO_NUM       36
#define Y5_GPIO_NUM       21
#define Y4_GPIO_NUM       19
#define Y3_GPIO_NUM       18
#define Y2_GPIO_NUM        5
#define VSYNC_GPIO_NUM    25
#define HREF_GPIO_NUM     23
#define PCLK_GPIO_NUM     22


static camera_config_t camera_config = {
    .pin_pwdn  = PWDN_GPIO_NUM,
    .pin_reset = RESET_GPIO_NUM,
    .pin_xclk = XCLK_GPIO_NUM,
    .pin_sscb_sda = SIOD_GPIO_NUM,
    .pin_sscb_scl = SIOC_GPIO_NUM,

    .pin_d7 = Y9_GPIO_NUM,
    .pin_d6 = Y8_GPIO_NUM,
    .pin_d5 = Y7_GPIO_NUM,
    .pin_d4 = Y6_GPIO_NUM,
    .pin_d3 = Y5_GPIO_NUM,
    .pin_d2 = Y4_GPIO_NUM,
    .pin_d1 = Y3_GPIO_NUM,
    .pin_d0 = Y2_GPIO_NUM,
    .pin_vsync = VSYNC_GPIO_NUM,
    .pin_href = HREF_GPIO_NUM,
    .pin_pclk = PCLK_GPIO_NUM,

    //XCLK 20MHz or 10MHz for OV2640 double FPS (Experimental)
    .xclk_freq_hz = 20000000,
    .ledc_timer = LEDC_TIMER_0,
    .ledc_channel = LEDC_CHANNEL_0,

    .pixel_format = PIXFORMAT_RGB565,//YUV422,GRAYSCALE,RGB565,JPEG
    .frame_size = FRAMESIZE_QQVGA,//QQVGA-QXGA Do not use sizes above QVGA when not JPEG

    .jpeg_quality = 12, //0-63 lower number means higher quality
    .fb_count = 1 //if more than one, i2s runs in continuous mode. Use only with JPEG
};

esp_err_t camera_init(){
    //initialize the camera
    esp_err_t err = esp_camera_init(&camera_config);
    if (err != ESP_OK) {
        Serial.print("Camera Init Failed");
        return err;
    }
    return ESP_OK;
}


esp_err_t camera_capture(){
    uint8_t * buf = NULL;
    size_t buf_len = 0;  
    
    //acquire a frame
    camera_fb_t * fb = esp_camera_fb_get();
    if (!fb) {
        Serial.print("Camera Capture Failed");
        return ESP_FAIL;
    }
    
    Serial.println(fb->len);  //Serial.println(fb->width); Serial.println(fb->height);Serial.println(fb->format);  

    esp_camera_fb_return(fb);
    return ESP_OK;
}


void setup() {
  Serial.begin(115200);
  camera_init();    //摄像头初始化
  camera_capture();  //摄像头获取图像
  Serial.println("sys is running");
}

void loop() {
  camera_capture();
}

效果

在这里插入图片描述

crop

在这里插入图片描述

#include "esp_camera.h"
#include "stream.h"

#define PWDN_GPIO_NUM     32
#define RESET_GPIO_NUM    -1
#define XCLK_GPIO_NUM      0
#define SIOD_GPIO_NUM     26
#define SIOC_GPIO_NUM     27

#define Y9_GPIO_NUM       35
#define Y8_GPIO_NUM       34
#define Y7_GPIO_NUM       39
#define Y6_GPIO_NUM       36
#define Y5_GPIO_NUM       21
#define Y4_GPIO_NUM       19
#define Y3_GPIO_NUM       18
#define Y2_GPIO_NUM        5
#define VSYNC_GPIO_NUM    25
#define HREF_GPIO_NUM     23
#define PCLK_GPIO_NUM     22


static camera_config_t camera_config = {
    .pin_pwdn  = PWDN_GPIO_NUM,
    .pin_reset = RESET_GPIO_NUM,
    .pin_xclk = XCLK_GPIO_NUM,
    .pin_sscb_sda = SIOD_GPIO_NUM,
    .pin_sscb_scl = SIOC_GPIO_NUM,

    .pin_d7 = Y9_GPIO_NUM,
    .pin_d6 = Y8_GPIO_NUM,
    .pin_d5 = Y7_GPIO_NUM,
    .pin_d4 = Y6_GPIO_NUM,
    .pin_d3 = Y5_GPIO_NUM,
    .pin_d2 = Y4_GPIO_NUM,
    .pin_d1 = Y3_GPIO_NUM,
    .pin_d0 = Y2_GPIO_NUM,
    .pin_vsync = VSYNC_GPIO_NUM,
    .pin_href = HREF_GPIO_NUM,
    .pin_pclk = PCLK_GPIO_NUM,

    //XCLK 20MHz or 10MHz for OV2640 double FPS (Experimental)
    .xclk_freq_hz = 20000000,
    .ledc_timer = LEDC_TIMER_0,
    .ledc_channel = LEDC_CHANNEL_0,

    .pixel_format = PIXFORMAT_RGB565,//YUV422,GRAYSCALE,RGB565,JPEG
    .frame_size = FRAMESIZE_SXGA,//QQVGA-QXGA Do not use sizes above QVGA when not JPEG

    .jpeg_quality = 12, //0-63 lower number means higher quality
    .fb_count = 1 //if more than one, i2s runs in continuous mode. Use only with JPEG
};

esp_err_t camera_init(){
    //initialize the camera
    esp_err_t err = esp_camera_init(&camera_config);
    if (err != ESP_OK) {
        Serial.print("Camera Init Failed");
        return err;
    }
    return ESP_OK;
}


const char hz[][100]={"宽:","长:",};
esp_err_t camera_capture(){
    uint8_t * buf = NULL;
    size_t buf_len = 0;  
    
    //acquire a frame
    camera_fb_t * fb = esp_camera_fb_get();
    if (!fb) {
        Serial.print("Camera Capture Failed");
        return ESP_FAIL;
    }
    Serial.println(hz[0]);
    Serial.println(fb->width); // 1280
    Serial.println(hz[1]);
    Serial.println(fb->height);//1024

    crop_image(fb, 550, 602, 406, 490);

    Serial.println(hz[0]);
    Serial.println(fb->width);  
    Serial.println(hz[1]);
    Serial.println(fb->height);
    
    esp_camera_fb_return(fb);
    return ESP_OK;
}


void crop_image(camera_fb_t *fb, unsigned short cropLeft, unsigned short cropRight, unsigned short cropTop, unsigned short cropBottom)
{
    unsigned int maxTopIndex = cropTop * fb->width * 2;
    unsigned int minBottomIndex = ((fb->width*fb->height) - (cropBottom * fb->width)) * 2;
    unsigned short maxX = fb->width - cropRight; // In pixels
    unsigned short newWidth = fb->width - cropLeft - cropRight;
    unsigned short newHeight = fb->height - cropTop - cropBottom;
    size_t newJpgSize = newWidth * newHeight *2;

    unsigned int writeIndex = 0;
    // Loop over all bytes
    for(int i = 0; i < fb->len; i+=2){
        // Calculate current X, Y pixel position
        int x = (i/2) % fb->width;

        // Crop from the top
        if(i < maxTopIndex){ continue; }

        // Crop from the bottom
        if(i > minBottomIndex){ continue; }

        // Crop from the left
        if(x <= cropLeft){ continue; }

        // Crop from the right
        if(x > maxX){ continue; }

        // If we get here, keep the pixels
        fb->buf[writeIndex++] = fb->buf[i];
        fb->buf[writeIndex++] = fb->buf[i+1];
    }

    // Set the new dimensions of the framebuffer for further use.
    fb->width = newWidth;
    fb->height = newHeight;
    fb->len = newJpgSize;
}


void setup() {
  Serial.begin(115200);
  camera_init();    //摄像头初始化
  camera_capture();  //摄像头获取图像
  Serial.println("sys is running");
}

void loop() {
  camera_capture();
}

# utf-8

import tensorflow as tf
import numpy as np
import pandas as pd
import matplotlib as mpl
import matplotlib.pyplot as plt
import os

from tensorflow import keras
import sys
import cv2


print(tf.__version__)
print(sys.version_info)
for module in mpl, pd, np, keras:
    print(module.__name__, module.__version__)

# set path
train_dir = './input/train'
valid_dir = './input/validation'
test_dir = './input/test'

# set para
height = 1280
width = 1024
channel = 3
batch_size = 64
valid_batch_size = 64
num_classes = 2
epochs = 1


# train model
def trainModel(model, train_generator, valid_generator, callbacks):
    history = model.fit(
        train_generator,
        epochs=epochs,
        validation_data = valid_generator,
        callbacks = callbacks
    )
    return history

# show the changes of loss and accuracy during training
def plot_learning_curves(history, label, epochs, min_value, max_value):
    data = {}
    data[label] = history.history[label]
    data['val_' + label] = history.history['val_' + label]
    pd.DataFrame(data).plot(figsize=(8, 5))
    plt.grid(True)
    plt.axis([0, epochs, min_value, max_value])
    plt.show()


# use the model after finish training to classify images and save them into two different folders
def predictModel(model, output_model_file):

    # load the weights of model
    model.load_weights(output_model_file)

    os.makedirs('./save', exist_ok=True)
    os.makedirs('./save/cat', exist_ok=True)
    os.makedirs('./save/dog', exist_ok=True)

    test_dir = './input/test1/'  # 1-12500.jpg
    for i in range(1, 12500):
        img_name = test_dir + '{}.jpg'.format(i)
        img = cv2.imread(img_name)
        img = cv2.resize(img, (width, height))
        img_arr = img / 255.0
        img_arr = img_arr.reshape((1, width, height, 3))
        pre = model.predict(img_arr)
        if pre[0][0] > pre[0][1]:
            cv2.imwrite('./save/cat/' + '{}.jpg'.format(i), img)
            print(img_name, ' is classified as Cat.')
        else:
            cv2.imwrite('./save/dog/' + '{}.jpg'.format(i), img)
            print(img_name, ' is classified as Dog.')


if __name__ ==  '__main__':

    print('Start importing data...')

    # import the data and make a augmentation
    train_datagen = keras.preprocessing.image.ImageDataGenerator(
        rescale=1,#. / 255, todo
        rotation_range=40,
        width_shift_range=0.2,
        height_shift_range=0.2,
        shear_range=0.2,
        zoom_range=0.2,
        horizontal_flip=True,
        fill_mode='nearest',
    )

    train_generator = train_datagen.flow_from_directory(
        train_dir,
        target_size=(width, height),
        batch_size=batch_size,
        seed=7,
        shuffle=True,
        class_mode='categorical'
    )

    valid_datagen = keras.preprocessing.image.ImageDataGenerator(
        rescale=1. / 255,
    )

    valid_generator = valid_datagen.flow_from_directory(
        valid_dir,
        target_size=(width, height),
        batch_size=valid_batch_size,
        seed=7,
        shuffle=False,
        class_mode="categorical"
    )


    train_num = train_generator.samples
    valid_num = valid_generator.samples
    # print(train_num, valid_num)

    print('Building model...')

    # Build model
    model = keras.models.Sequential([
        keras.layers.MaxPool2D(pool_size=4,
                            input_shape=[width, height, channel]),
        keras.layers.Conv2D(filters=32, kernel_size=3,
                            padding='valid', activation='relu'),
        keras.layers.MaxPool2D(pool_size=4),
        keras.layers.Conv2D(filters=32, kernel_size=3,
                            padding='valid', activation='relu'),
        keras.layers.MaxPool2D(pool_size=2),

        # keras.layers.Conv2D(filters=64, kernel_size=3,
        #                     padding='same', activation='relu'),
        # keras.layers.Conv2D(filters=64, kernel_size=3,
        #                     padding='same', activation='relu'),
        # keras.layers.MaxPool2D(pool_size=2),

        keras.layers.Conv2D(filters=12, kernel_size=3,
                            padding='same', activation='relu'),
        keras.layers.Conv2D(filters=12, kernel_size=3,
                            padding='same', activation='relu'),
        keras.layers.MaxPool2D(pool_size=2),

        keras.layers.Flatten(),
        keras.layers.Dense(4, activation='relu'),
        keras.layers.Dense(num_classes, activation='softmax')
    ])

    model.compile(loss='categorical_crossentropy',
                  optimizer='adam', metrics=['accuracy'])
    model.summary()

    # set path of saving model
    logdir = './graph_def_and_weights'
    if not os.path.exists(logdir):
        os.mkdir(logdir)

    output_model_file = os.path.join(logdir,
                                     "catDog_weights.h5")


    print('Start training ...')
    # start training

    mode = '1' #input('Select mode: 1.Train 2.Predict\nInput number: ')
    if mode == '1':
        callbacks = [
            keras.callbacks.TensorBoard(logdir),
            keras.callbacks.ModelCheckpoint(output_model_file,
                                            save_best_only=True,
                                            save_weights_only=True),
            keras.callbacks.EarlyStopping(patience=5, min_delta=1e-3)
        ]
        history = trainModel(model, train_generator, valid_generator, callbacks)
        plot_learning_curves(history, 'accuracy', epochs, 0, 1)
        plot_learning_curves(history, 'loss', epochs, 0, 5)
    elif mode == '2':
        # Only run this mode if you have already finished training your model and saved it.
        predictModel(model, output_model_file)
    else:
        print('Please input the correct number.')

    print('Finish! Exit.')

    # Convertir modelo al formato tensorflow lite
    converter = tf.lite.TFLiteConverter.from_keras_model(model)
    tflite_model = converter.convert()

    # Guardar modelo en el disco
    open("model.tflite", "wb").write(tflite_model)


    from tinymlgen import port
    # Convertir modelo en un array C
    c_code = port(model, pretty_print=True)
    print(c_code)
    with open('model.h', 'w') as f:
        f.write(c_code)

EloquentVision

  • 这个例子是machine learing的例子，来自另一个包，但是没运行成功，说检测不到我的摄像头,可能是官方没有和我板子的gpio匹配
    在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

  • Detected camera not supported
load:0x3fff001c,len:1216
ho 0 tail 12 room 4
load:0x40078000,len:10944
load:0x40080400,len:6388
entry 0x400806b4
[E][camera.c:1113] camera_probe(): Detected camera not supported.
[E][camera.c:1379] esp_camera_init(): Camera probe failed with error 0x20004
Guru Meditation Error: Core  1 panic'ed (LoadProhibited). Exception was unhandled.
Core 1 register dump:
PC      : 0x400d1aa8  PS      : 0x00060530  A0      : 0x800d1c31  A1      : 0x3ffb1f00  
A2      : 0x00000005  A3      : 0x00000001  A4      : 0x0800001c  A5      : 0x00000003  
A6      : 0x00000003  A7      : 0x00000000  A8      : 0x800d1aa6  A9      : 0x3ffb1ee0  
A10     : 0x00000000  A11     : 0x00000005  A12     : 0x3ffbdc14  A13     : 0x00000003  
A14     : 0x00000001  A15     : 0x00000000  SAR     : 0x00000004  EXCCAUSE: 0x0000001c  
EXCVADDR: 0x00000040  LBEG    : 0x40089ded  LEND    : 0x40089dfd  LCOUNT  : 0xfffffffb

cg

  • https://savjee.be/blog/esp32-cam-cropping-images-on-device/
FakeOccupational
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
esp32 camera 中文资料
10-17
本资源是采用的esp32+ov2640 可以做到的最大分辨率是1024*600，具有很强的自恢复性，有一定的参考价值
jquery crop+java 裁剪上传图片
11-08
jquery crop+java 裁剪上传图片，对图片缩放、移动、旋转、裁剪 上传到服务器。
ESP32-CAM 板载摄像头模块进行简单的图像采集和网络传输。
冰骑士的博客
06-13 4142
ESP32-CAM 是一款集成了 Wi-Fi 和图像传感器的开发板，它可以用于实现基于 Arduino 平台的物联网应用和图像处理等项目。本文将介绍如何使用 ESP32-CAM 板载摄像头模块进行简单的图像采集和网络传输。
最全ESP32-Cam学习（1）——拍摄第一张照片_esp32相机，2024年最新物联网嵌入式开发入门视频教程
最新发布
2401_85015259的博客
05-15 422
在某宝可以轻易买到。它分为主板，和底板。底板的主要功能是供电、程序下载等等。主板才是ESP32芯片的核心。
ESP32-CAM入门
m0_71827453的博客
10-20 3408
ESP32-CAM可选用淘宝带的烧录座，这个直接用常见的手机数据线就可以连接了，也可以用USB To TTL，实质也是串口通信，感觉烧录座的原理也一样，我使用的是USB To TTL的。12.注意还需要找到111行这里的代码，这里默认的是OV3660，需要更改为自已购买的摄像头型号，在这里卡了很久，一直下载不成功就是因为这里参数不匹配，我的更改为2640。15. 下载成功后点击右上角的串口监视器，然后把掉IO0和GND的连接，复位重启ESP32-CAM，就会有下图网址出现，复制其到浏览器上。
ESP32-FPV-Camera介绍和使用
lida2003的专栏
02-24 3636
ESP32是一款高性价比的嵌入式芯片，且其ESP-IDF工具采用了CMake的Unix Style开发方式，也是笔者比较喜欢的一种工程组织方式。IDE工具对于应用开发带来了便捷性，屏蔽了很多系统，模块，组件，开源（非开源）的底层细节。尤其是IDE工具经常升级，导致很多由于工具升级带来的各种问题（有的时候感觉莫名其妙），但是Makefile/CMake等成熟的嵌入工程组织方式更加稳定、可靠。
ESP32-Camera性能(简单)测试评估
lida2003的专栏
01-18 8681
最近因为接触了ESP32摄像头相关的资料和信息，稍微简单整理下，希望对该方案有兴趣的朋友可以有所帮助。同样配置（800x600的分辨率）情况下，OV2640会比OV5640流畅（帧速率更高）；基于AITHINKER Camera硬件条件下，摄像头帧速率不稳定，平均速率都比较低（低于25FPS）；Github:和库上代码均存在诸多问题：a) 驱动稳定性；b)代码适配性；c) 代码健壮性WiFi视频角度：可以做简单固定场景非专业类监控，且交易受到干扰影响（2.4G频段）
AE脚本-Auto+Crop+3.1.1.zip
03-18
ae的插件
PNS.BAFS.337.2022_+PNS+Organic+Crop+Production,+
11-13
"PNS.BAFS.337.2022_+PNS+Organic+Crop+Production,+Postharvest+and+Processing+-+Code+of+Practice.pdf" 这是一份菲律宾国家标准局（Bureau of Agriculture and Fisheries Standards，简称BAFS）发布的《有机作物...
camera_app_crop_function
05-13
camera_app_crop_function
VB摄像头操作.rar_Q87_crop64v_vb6-camera_vb拍照代码_关闭摄像头
07-14
VB6代码,无需复杂驱动,实现开启摄像头,关闭摄像头,拍照功能
esp32-homekit-camera:esp32-camera模块的固件充当Apple Homekit IP摄像机
05-23
esp32-homekit-camera esp32-camera模块的固件，用作Apple Homekit IP摄像机。 基于 。 先决条件 esp-idf 按照esp-idf项目页面（ ）上的说明安装esp-idf。 最后，您应该在路径中包含xtensa-esp32-elf工具链，并应具有指向esp-idf目录的IDF_PATH环境变量。 esp32-homekit-camera代码 克隆此存储库git clone https://github.com/maximkulkin/esp32-homekit-camera.git 从此目录开始工作cd esp32-homekit-camera 初始化和同步所有子模块（递归） git submodule update --init --recursive 配置 编译之前，您需要更改menuconfig中的几个设置。 确保保存此文
CameraWifiMotion:使用便宜的ESP32-cam摄像头模块进行运动检测安全摄像头
04-04
这是一个Arduino IDE草图，使用便宜的eSP32摄像头模块之一（来自eBay的5ukp）作为运动检测安全摄像头。 它每秒大约从相机捕获4张图像，每次将其与前一张图像进行比较以查找任何变化。 如果检测到重大变化，它将捕获更高分辨率的图像并将其存储在内部存储器中。 它还具有通过电子邮件或FTP捕获的图像或将其存储到SD卡的选项。 最新消息！！！ 现在有一款非常便宜的esp32cam主板可供使用，这使其与其他esp开发板一样易于使用。 在eBay上搜索“ esp32cam mb”-参见看起来与它们一起提供的esp32cam不是标准的并且有一个的GND引脚经过修改以用作复位引脚？ 因此，在没有此功能的esp32cam模块上，您必须在按住程序按钮的同时插入USB以上传草图，而且我发现我必须使用最低的上传速度，否则上传失败。 在主板上时，wifi状况非常差（如果您在esp32cam模块的天线
esp32 ov7670 摄像头
10-17
这是一个esp32驱动ov7670的典型案例，对于学习arduino的同学很有帮助和参考意义
esp32-camera
08-04
ESP32 相机驱动 一般信息 该存储库托管用于图像传感器的 ESP32 系列 Soc 兼容驱动程序。 此外，它还提供了一些工具，允许将捕获的帧数据转换为更常见的 BMP 和 JPEG 格式。 支持的系统 ESP32 ESP32-S2 ESP32-S3 支持的传感器 模型 最大分辨率 颜色类型 输出格式 镜头尺寸 OV2640 1600 × 1200 颜色 YUV(422/420)/YCbCr422 RGB565/555 8 位压缩数据8/10 位原始 RGB 数据 1/4" OV3660 2048 x 1536 颜色 原始 RGB 数据RGB565/555/444 CCIR656 YCbCr422 压缩 1/5" OV5640 2592 × 1944 颜色 原始RGB RGB565/555/444 CCIR656 YUV422/420 YCbCr422 压缩 1/4"
esp_cam
02-18
esp_cam IGNORE NANOPB这个项目的想法是处理来自esp相机的帧缓冲区并通过wifi发送， MAIN（）的描述：将数据从相机发送到客户端。 camera_fb_t是指向帧缓冲区的指针，使用函数esp_camera_fb_get（）对其进行更新，该函数恢复帧数据和其他杂项信息，例如其处理的帧的大小和类型。 -第一步是成功发送数据或帧缓冲区-下一步是找到一种序列化帧缓冲区的方法，因为像素数据是一个数组，我们将使用msgpack之类的库进行购买。 -最后一步是通过将帧缓冲区处理为您可以肉眼看到的图像来弄清楚客户端该做什么 / include的描述：_debug.h：用于调试camera.h：定义管脚，配置，例如camera.c中的帧大小。camera_fb_t.pb.h：“ IGNORE” camera_pins.h：而是使用#define定义管脚，以便可以在编程socket
ESP32之esp_camera分析(一)
professionalmcu的专栏
12-16 6737
初始化分析，首先定义一个camera_config_t类型的结构体变量，然后给结构中的成员赋值，再调用err = esp_camera_init(&camera_config);函数进行初始化，代码如下： esp_err_t err; camera_config_t camera_config = { .pin_pwdn = CAM_PWDN, .pin_reset = CAM_RET, .pin_xclk = CAM_XCLK, .pin_sscb_sda = CA
在platformio使用esp32-camera库
qq_44690417的博客
12-14 2461
在platformio使用esp32-camera库获取esp32-camera编译工程使用总结 获取esp32-camera 创建好的ESP32的工程后，进入工程的lib文件夹 首先初始化git： 在控制台中执行 git init 然后使用git命令获取esp32-camera git submodule add -b master https://github.com/espressif/esp32-camera.git 编译工程 首先在platformio.ini文件中添加： build_flags
使用 micropython 编写 ESP32-CAM 自动拍照程序
qq_62819897的博客
07-16 3287
使用 micropython 编写 ESP32-CAM 自动拍照程序
halcon read image crop+projection 得到8个一维度信号
06-08
好的，您的问题是关于使用 Halcon 读取图像、裁剪和投影得到8个一维信号的方法。 首先，您可以使用read_image函数读取图像，例如： ``` read_image(Image, 'your_image.jpg') ``` 接着，您可以使用crop_rectangle1函数来裁剪图像的感兴趣区域，例如： ``` crop_rectangle1(Image, CroppedImage, Row1, Column1, Row2, Column2) ``` 其中，Row1、Column1、Row2、Column2分别代表感兴趣区域的上下左右四个坐标。裁剪后的图像保存在CroppedImage中。 最后，您可以使用project_1d函数来对裁剪后的图像进行投影，得到8个一维信号，例如： ``` project_1d(CroppedImage, 'column', Projection) ``` 其中，'column'代表按列进行投影，Projection保存了8个一维信号。 综上所述，您可以按照以上方法使用Halcon来读取图像、裁剪和投影得到8个一维信号。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值