SDK V2 简介

简介

功能说明

Smart Vision SDK V2 为开发者提供：

• 操作获取相机照片数据的API接口。所获相机照片数据用于后续人工智能模型推理。
• IO/TCP信号输出API接口。信号输出可发送NG/Alarm/Alarm Clear信号。

Smart Vision SDK V2 提供了C++和python两种类型的接口。开发者可以根据自身情况选择使用。

开发环境

Smart Vision SDK V2运行于Aidlux智能相机环境中。

类别	要求
操作系统	Ubuntu22.04
Aidlux	aidlux_2.x.x.x
支持语言接口	Python3.10.12/ C++

限制

只能运行在开发环境所要求的运行条件下。

安装/卸载

可通过应用中心安装或卸载Smart Vision SDK。关于应用中心操作介绍，请参考相应文档。

也可以通过命令在线安装或卸载，例如：

安装：
sudo aid-pkg install smartvision-sdk

安装后需执行：
sudo systemctl restart aid-sve
sudo systemctl restart sdkqmmfserver

卸载：
sudo aid-pkg remove smartvision-sdk

打开相机流程介绍

流程图

流程详细步骤介绍

1. 首先调用打开摄像头API接口打开摄像头。
2. 然后通过while循环并且调用获取图片数据API接口不断获取图片数据。
3. 最后调用关闭流开关API接口关闭相机。

日志功能

SDK日志功能分为：

• 打印日志，即控制台输出
• 保存日志，即日志保存到文件
• 动态设置日志等级，即可通过命令动态改变当前日志等级配置（影响文件输出）
• 关闭日志，即关闭日志文件输出

动态修改日志级别

格式：
/opt/aidlux/cpf/aid-rtcm/tools/rtcm_tool <Command> <Module> <Key> <Value>

其中，Command为：set或者'-s'。
Module为smartvisionsdk_<pid>。
Key为log_level。

Value为：
off：关闭日志
err：打印错误日志
warn：打印警告日志
info：打印信息日志

例如：
/opt/aidlux/cpf/aid-rtcm/tools/rtcm_tool set smartvisionsdk_1234 log_level info

其中，查询当前引用smartvision sdk的执行程序的pid可通过以下命令：
/opt/aidlux/cpf/aid-rtcm/tools/rtcm_tool query smartvisionsdk camera_process_id

关于rtcm_tool工具更多用法，请参考其帮助信息。

修改日志文件路径

格式：
/opt/aidlux/cpf/aid-rtcm/tools/rtcm_tool <Command> <Module> <Key> <Value>

其中，Command为：set或者'-s'。
Module为smartvisionsdk_<pid>。
Key为log_file_path。
Value为日志文件路径。如：/home/aidlux/，表示将在/home/aidlux路径下创建日志文件。(注：SDK初始日志默认存储在/tmp/smartvisionsdk/目录下)

例如：
/opt/aidlux/cpf/aid-rtcm/tools/rtcm_tool set smartvisionsdk_1234 log_file_path /home/aidlux/

日志文件路径默认值为应用程序所在路径。

其中，查询当前引用smartvision sdk的执行程序的pid可通过以下命令：
/opt/aidlux/cpf/aid-rtcm/tools/rtcm_tool query smartvisionsdk camera_process_id

关于rtcm_tool工具更多用法，请参考其帮助信息。

查询日志级别配置

格式：
/opt/aidlux/cpf/aid-rtcm/tools/rtcm_tool <Command> <Module> <Key>

其中，Command为：query或者'-q'。
Module为smartvisionsdk_<pid>。
Key为log_level。

例如：
/opt/aidlux/cpf/aid-rtcm/tools/rtcm_tool query smartvisionsdk_1234 log_level

日志保存于应用执行程序同一目录。例如：

$ ls -rlt 
-rwxr-xr-x. 1 aidlux aidlux 127032 Jun 21 11:50 demo
-rw-r--r--. 1 aidlux aidlux 919473 Jun 21 13:34 aidclog_smartvisionsdk_logger_115125_429_2024-06-21.aidclog

无参形式-使用相机的示例

无参形式-C++示例

TIP

下列示例中的camera_idx参数说明：

• camera_idx = 0：默认相机索引，即主设备相机0。
• camera_idx = 1：指定相机索引，即分设备相机1。
• camera_idx = 2：指定相机索引，即分设备相机2。

#include <iostream>
#include <unistd.h>
#include <signal.h>
#include <nlohmann/json.hpp>
#include <chrono>                                                                                                   
#include <ctime>
#include <vector>
#include <sys/mman.h>

#include "smart_vision.hpp"
#include "example.hpp"
#include "lmcsdk/license_manager_sdk.hpp"
#include "aidclog/aidclog.hpp"
#include "aidrtcm/aidrtcm.hpp"
#include "crow.h"
#include "crow/json.h"

using namespace std;
using namespace Aidlux::SmartVision;

std::atomic<bool> g_stop_signal{false}; //原子操作，用于控制程序退出

void signal_handler(int signal)     //信号处理函数，用ctrl+c退出程序
{
    if (signal == SIGINT)
    {
        g_stop_signal = true;
    }
}

void camera_example(int camera_idx) //相机使用，用于获取图片数据
{
    Image img; //Image结构体，用于存储图片数据
    
    if(start_camera(camera_idx) != 0)
    {
        CLOGI("Start camera failed.");
        return;
    }
    CLOGI(" Camera %d started successfully", camera_idx);

    usleep(500 * 1000);

    while (!g_stop_signal)
    {
        cv::Mat frame = Aidlux::SmartVision::get_cvimage(img, camera_idx, 1000);
        printf("res=%dx%d | exp=%ld ns | iso=%ld\n",img.h, img.w,img.exposureTimeNs,img.isoValue);
        if (frame.empty())
        {
            CLOGI ("Failed to get frame from camera %d",camera_idx);
            usleep(10 * 1000);
            continue;
        }

        // 在获取帧之后，用户可以在这里添加自定义的操作。 
        // 1：将获取到的帧转换为灰度图像
        // 2：保存图像到文件
        // 3: 进行图像处理
        // 4：进行物体识别

    printf("Camera %d frame processed successfully!", camera_idx);

        // 控制采集/处理频率：
        // - 使用 usleep() 可精确控制微秒级间隔
        // - 或替换为 std::this_thread::sleep_for(...)
        //   示例：std::this_thread::sleep_for(std::chrono::milliseconds(33)); // ≈30 FPS
        //
        // 注意：若自定义处理逻辑本身耗时较长，此处 sleep 时间应相应缩短，
        //         否则会导致实际帧率低于预期。
        usleep(/* 请根据目标帧率设置延迟，单位：微秒 */);
    }

    close_camera(camera_idx);
    printf("Camera %d stopped gracefully.", camera_idx);
}

int main(int argc, char * argv[])
{
    signal(SIGINT, signal_handler);  //注册使用crtl+c退出
    int camera_idx = 0;
    camera_example(camera_idx);
}

无参形式-C++示例精讲

必须优先调用start_camera启动摄像头。开启成功后可以看到相机启动成功的信息。

 if(start_camera(camera_idx) != 0)
    {
        CLOGI("Start camera failed.");
        return;
    }

然后使用while循环，通过调用get_cvimage,使用该函数时一定优先构建Image对象，并传入get_cvimage函数。 获取成功后可以看到相机获取数据成功信息。（例如：Camera 0 success!）

    while (!g_stop_signal)
    {
        cv::Mat frame = Aidlux::SmartVision::get_cvimage(img, camera_idx, 1000);
        printf("res=%dx%d | exp=%ld ns | iso=%ld\n",img.h, img.w,img.exposureTimeNs,img.isoValue);
        if (frame.empty())
        {
            CLOGI ("Failed to get frame from camera %d",camera_idx);
            usleep(10 * 1000);
            continue;
        }

        /*自定义内容*/

        CLOGI("Camera %d success!",camera_idx);
    }

最后，一定记得使用使用close_camera关闭摄像头。 完成后即可完成相机操作。

TIP

该实例中使用了原子变量g_stop_signal，用于控制程序退出。 退出时可以按下CTRL + C 来退出程序。 主函数中一定要注册signal(SIGINT, signal_handler);

std::atomic<bool> g_stop_signal{false};

void signal_handler(int signal)
{
    if (signal == SIGINT)
    {
        g_stop_signal = true;
    }
}

无参形式-python示例

import cv2
import time
import sys
import os
import signal
import threading
import numpy as np
import aidclog
import aidrtcm
import aidcvsdk
import aidcv
from pysmartvision import smartvisionsdk

g_stop_signal = False
Image img
def signal_handler(signal, frame):
    global g_stop_signal
    aidrtcm.rtcm_tool('-q', 'smartvisionsdk_%d' % os.getpid(), 'log_level', 'off')
    aidrtcm.rtcm_tool('-q', 'smartvisionsdk_%d' % os.getpid(), 'log_file_path', '')
    aidrtcm.rtcm_tool('-q', 'smartvisionsdk_%d' % os.getpid(), 'log_file_size', '0')
    aidrtcm.rtcm_tool('-q', 'smartvisionsdk_%d' % os.getpid(), 'log_file_count', '0')
    aidrtcm.rtcm_tool('-q', 'smartvisionsdk_%d' % os.getpid(), 'log_level', 'info')
    g_stop_signal = True

if __name__ == '__main__':
    signal.signal(signal.SIGINT, signal_handler)
    camera_idx = 0
    if smartvisionsdk.start_camera(camera_idx) != 0:
        aidclog.log("Start camera failed.")
        sys.exit(1)
    aidclog.log("Camera %d started successfully" % camera_idx)

    smartvisionsdk.start_camera_capture(camera_idx)

    time.sleep(0.5)

    while not g_stop_signal:
        img = smartvisionsdk.get_cvimage(img,camera_idx, 1000)
        if img is None:
            aidclog.log("Failed to get frame from camera %d" % camera_idx)
            time.sleep(0.01)
            continue

        aidclog.log("Camera %d success!" % camera_idx)
        time.sleep(0.033)              #模拟33ms的帧率

    smartvisionsdk.close_camera(camera_idx)
    aidclog.log("Camera %d stopped gracefully." % camera_idx)

无参形式-python示例精讲

必须优先调用start_camera启动摄像头。开启成功后可以看到相机启动成功信息。

if smartvisionsdk.start_camera(camera_idx) != 0:
        aidclog.log("Start camera failed.")
        sys.exit(1)
    aidclog.log("Camera %d started successfully" % camera_idx)

其次，调用start_camera_capture函数打开流开关。

然后使用while循环，通过调用get_cvimage,使用该函数时一定优先构建Image对象，并传入get_cvimage函数。 获取成功后可以看到相机获取数据成功信息。（例如：Camera 0 success!）

while not g_stop_signal:
        image = smartvisionsdk.get_cvimage(img,camera_idx, 1000)
        if image is None:
            aidclog.log("Failed to get frame from camera %d" % camera_idx)
            time.sleep(0.01)
            continue

        aidclog.log("Camera %d success!" % camera_idx)
        time.sleep(0.033)

最后，一定记得使用close_camera关闭摄像头。 完成后即可完成相机操作。

有参形式-使用相机示例

有参形式-C++示例

#include <iostream>

#include <unistd.h>
#include <signal.h>
#include <nlohmann/json.hpp>
#include <chrono>                                                                                                   
#include <ctime>
#include <vector>
#include <sys/mman.h>

#include "smart_vision.hpp"
#include "example.hpp"
#include "lmcsdk/license_manager_sdk.hpp"
#include "aidclog/aidclog.hpp"
#include "aidrtcm/aidrtcm.hpp"
#include "crow.h"
#include "crow/json.h"

using namespace std;
using namespace Aidlux::SmartVision;

using json = nlohmann::json;

std::atomic<bool> g_stop_signal{false}; //原子操作，用于控制程序退出

void signal_handler(int signal)     //信号处理函数，用ctrl+c退出程序
{
    if (signal == SIGINT)
    {
        g_stop_signal = true;
    }
}

std::string read_file_to_string(const std::string& path) {
    std::ifstream file(path);
    if (!file.is_open()) {
        std::cerr << "Failed to open config file: " << path << std::endl;
        return "";
    }
    std::ostringstream ss;
    ss << file.rdbuf();
    return ss.str();
}

void camera_example(int camera_idx) {
    const std::string config_path = <自定义配置文件路径>;   //例如 "/home/aidlux/aidlux_smart_vision/data/param.json"

    // 读取配置文件
    std::string config_str = read_file_to_string(config_path);
    if (config_str.empty()) {
        CLOGI("Failed to load camera config.");
        return;
    }

    // 启动摄像头
    if (start_camera(config_str.c_str(), camera_idx) != 0) {
        CLOGI("Start camera failed.");
        return;
    }
    printf("Camera %d started successfully with config.\n", camera_idx);

    usleep(500 * 1000); // 等待初始化

    while (!g_stop_signal) {
        cv::Mat frame = Aidlux::SmartVision::image_read(camera_idx);
        
        if (frame.empty()) {
            CLOGI("Got empty frame from camera %d", camera_idx);
            usleep(10000);
            continue;
        }
        printf("Got frame: %dx%d, size=%ld\n", 
          frame.cols, frame.rows, frame.total());


        // 在获取帧之后，用户可以在这里添加自定义的操作。 
        // 1：将获取到的帧转换为灰度图像
        // 2：保存图像到文件
        // 3: 进行图像处理
        // 4：进行物体识别

        CLOGI("Camera %d frame processed successfully!", camera_idx);

            // 控制采集/处理频率：
            // - 使用 usleep() 可精确控制微秒级间隔
            // - 或替换为 std::this_thread::sleep_for(...)
            //   示例：std::this_thread::sleep_for(std::chrono::milliseconds(33)); // ≈30 FPS
            //
            // 注意：若自定义处理逻辑本身耗时较长，此处 sleep 时间应相应缩短，
            //         否则会导致实际帧率低于预期。
        usleep(/* 请根据目标帧率设置延迟，单位：微秒 */);
    }

    close_camera(camera_idx);
    printf("Camera %d stopped gracefully.\n", camera_idx);
}

int main() {
    signal(SIGINT, signal_handler); // 注册信号处理函数

    const int camera_index = 0;
    camera_example(camera_index);

    return 0;
}

有参形式-C++示例精讲

必须优先调用start_camera启动摄像头。开启成功后可以看到相机启动成功的信息。

TIP

json配置文件请参考附录。 在使用相关配置文件的时候请确保以下八个参数的存在：

triggerWay, width, height, fps

autoExposure, autoFocus, customWhiteBalance, autoWhiteBalanceMode

json配置文件路径自定义 例如<"/home/aidlux/aidlux_smart_vision/data/param.json">

 if(start_camera(<json配置文件>, camera_idx) != 0)
    {
        CLOGI("Start camera failed.");
        return;
    }

使用while循环，通过调用image_read。

    while (!g_stop_signal) {
        cv::Mat frame = Aidlux::SmartVision::image_read(camera_idx);
        
        if (frame.empty()) {
            CLOGI("Got empty frame from camera %d", camera_idx);
            usleep(10000);
            continue;
        }
        printf("Got frame: %dx%d, size=%ld\n", 
          frame.cols, frame.rows, frame.total());
    }

最后，一定记得使用使用close_camera关闭摄像头。 完成后即可完成相机操作。

TIP

该实例中使用了原子变量g_stop_signal，用于控制程序退出。 退出时可以按下CTRL + C 来退出程序。 主函数中一定要注册signal(SIGINT, signal_handler);

有参形式-Python示例

import os
import signal
import time
import cv2
from pathlib import Path

# 只导入这一行，符合你的要求
from pysmartvision import smartvisionsdk

# 全局停止标志
stop_signal = False

def signal_handler(signum, frame):
    global stop_signal
    if signum == signal.SIGINT:
        print("\n收到中断信号，正在退出...")
        stop_signal = True

def read_file_to_string(path):
    try:
        with open(path, 'r') as f:
            return f.read()
    except:
        print("Failed to open config file:", path)
        return ""

def camera_example(camera_idx=0):
    config_path = <自定义配置文件路径>   #例如 "/home/aidlux/aidlux_smart_vision/data/param.json"

    # 读取配置
    config_str = read_file_to_string(config_path)
    if not config_str:
        print("Failed to load camera config.")
        return

    # 启动摄像头
    if smartvisionsdk.start_camera(config_str, camera_idx) != 0:
        print("Start camera failed.")
        return

    print(f"Camera {camera_idx} started successfully.")
    time.sleep(0.5)  # 等待初始化

    while not stop_signal:
        frame = smartvisionsdk.image_read(camera_idx)

        if frame is None or frame.size == 0:
            print(f"Got empty frame from camera {camera_idx}")
            time.sleep(0.01)
            continue

        # 打印帧信息
        h, w = frame.shape[:2]
        pixel_count = h * w
        ch = frame.shape[2] if len(frame.shape) == 3 else 1
        print(f"Got frame: {w}x{h}, total={pixel_count}, ch={ch}")

    smartvisionsdk.close_camera(camera_idx)
    print(f"Camera {camera_idx} stopped gracefully.")

def main():
    signal.signal(signal.SIGINT, signal_handler)
    camera_example(0)

if __name__ == "__main__":
    main()

有参形式-Python示例精讲

必须优先调用start_camera启动摄像头。开启成功后可以看到相机启动成功的信息。

TIP

参数配置文件请参考附录。 在使用相关配置文件的时候请确保以下八个参数的存在：

triggerWay, width, height, fps

autoExposure, autoFocus, customWhiteBalance, autoWhiteBalanceMode

json配置文件路径自定义 例如<"/home/aidlux/aidlux_smart_vision/data/param.json">

然后使用while循环，通过调用image_read。

while not stop_signal:
    frame = smartvisionsdk.image_read(camera_idx)

    if frame is None or frame.size == 0:
        print(f"Got empty frame from camera {camera_idx}")
        time.sleep(0.01)
        continue

    # 打印帧信息
    h, w = frame.shape[:2]
    pixel_count = h * w
    ch = frame.shape[2] if len(frame.shape) == 3 else 1
    print(f"Got frame: {w}x{h}, total={pixel_count}, ch={ch}")

最后，一定记得使用使用close_camera关闭摄像头。 完成后即可完成相机操作。

TIP

该实例中使用了原子变量stop_signal，用于控制程序退出。 退出时可以按下CTRL + C 来退出程序。 主函数中一定要注册signal(SIGINT, signal_handler);