FC2カウンター FPGAの部屋 Vitis Unified IDE 2023.2 でアンシャープマスクキング・フィルタの unsharp_masking_axis_RGB24 を実装する1
fc2ブログ

FPGAやCPLDの話題やFPGA用のツールの話題などです。 マニアックです。 日記も書きます。

FPGAの部屋

FPGAの部屋の有用と思われるコンテンツのまとめサイトを作りました。Xilinx ISEの初心者の方には、FPGAリテラシーおよびチュートリアルのページをお勧めいたします。

Vitis Unified IDE 2023.2 でアンシャープマスクキング・フィルタの unsharp_masking_axis_RGB24 を実装する1

以前にもアンシャープマスキング・フィルタを実装したことがあったが、実装し直すことにして、Vitis Unified IDE 2023.2 でアンシャープマスクキング・フィルタの unsharp_masking_axis_RGB24 を実装した。
アンシャープマスキング・フィルタについては、”アンシャープマスキング(鮮鋭化フィルタ)”を参照した。

Vitis Unified IDE 2023.2 で unsharp_masking_axis_RGB24 プロジェクトを作成する。

Vitis Unified IDE 2023.2 で File メニューから New Component -> HLS を選択して、ZUBoard 1CG 用の unsharp_masking_axis_RGB24 プロジェクトを作成した。

ソースコード、テストベンチのファイルは unsharp_masking_axis_RGB24 プロジェクトのファイルを追加した。

最初に、VITIS COMPONENT -> unsharp_masking_axis_RGB24 -> Settings -> hls_config.cfg をクリックし、設定を行った。
C Sythesis sources の top に unsharp_masking_axis_RGB24 を設定した。これは、C コードの合成時にハードウェアとする関数を指定する。
Testbench sources の CFLAGS-I/usr/local/include を指定した。
C Simulation の ldflags -L/usr/local/lib -lopencv_core -lopencv_imgcodecs -lopencv_imgproc を指定した。

ソースコードに unsharp_masking_axis_RGB24.h と unsharp_masking_axis_RGB24.cpp を追加した。
テストベンチに unsharp_masking_axis_RGB24_tb.cpp と画像ソフトの Pinta で 2.0 のガウスぼかしを掛けた test2.jpg を追加した。
zub1cg_i7filters_82_231125.png

ヘッダ・ファイルの unsharp_masking_axis_RGB24.h を示す。

// unsharp_masking_axis_RGB24.h
// 2023/11/25 by marsee
//

#ifndef __UNSHARP_MASKING_FILTER_AXIS_RGB24_H__
#define __UNSHARP_MASKING_FILTER_AXIS_RGB24_H__

#define HORIZONTAL 0
#define VERTICAL 1

#define ORG_IMGwAxiVdma 0
#define UNSHARP_MASKINGwAxiVdma   1
#define ORG_IMGwAxiDma  2
#define UNSHARP_MASKINGwAxiDma    3

#define UM_FIXED ap_fixed<24, 16, AP_TRN_ZERO, AP_SAT>
#endif


ソースコードの unsharp_masking_axis_RGB24.cpp を示す。

// unsharp_masking_axis_RGB24.cpp
// 2023/08/18 by marsee
// アンシャープマスキング・フィルタのアルゴリズムは”アンシャープマスキング(鮮鋭化フィルタ)”
// (https://imagingsolution.net/imaging/unsharpmasking/)を参照した
//

#include <stdint.h>
#include <ap_int.h>
#include <hls_stream.h>
#include <ap_axi_sdata.h>

#include "unsharp_masking_axis_RGB24.h"

constexpr int size = 3;

void unsharp_masking_fil(ap_int<32> (&pix_mat)[size][size], UM_FIXED k, ap_uint<24> &result);
ap_int<32> unsharp_masking_fil_calc(ap_int<32> *pixd, UM_FIXED k);
ap_int<32> separate_rgb(ap_int<32> rgb, ap_int<32> &r, ap_int<32> &g, ap_int<32> &b);

int unsharp_masking_axis_RGB24(hls::stream<ap_axiu<24,1,1,1> >& ins,
        hls::stream<ap_axiu<24,1,1,1> >& outs, int32_t function,
         int32_t row_size, int32_t col_size, UM_FIXED k){
#pragma HLS INTERFACE mode=s_axilite port=k
#pragma HLS INTERFACE mode=s_axilite port=col_size
#pragma HLS INTERFACE mode=s_axilite port=row_size
#pragma HLS INTERFACE mode=s_axilite port=function
#pragma HLS INTERFACE mode=axis register_mode=both port=outs register
#pragma HLS INTERFACE mode=axis register_mode=both port=ins register
#pragma HLS INTERFACE mode=s_axilite port=return

    ap_axiu<24,1,1,1> pix;
    ap_axiu<24,1,1,1> unsharp_masking;
    ap_uint<24> val;

    ap_int<32> line_buf[2][1920];
#pragma HLS array_partition variable=line_buf block factor=2 dim=1

    ap_int<32> pix_mat[size][size];
#pragma HLS array_partition variable=pix_mat complete

    LOOP_WAIT_USER : do {   // user が 1になった時にフレームがスタートする
#pragma HLS LOOP_TRIPCOUNT min=1 max=1 avg=1
        ins >> pix;
        if(function==ORG_IMGwAxiDma || function==UNSHARP_MASKINGwAxiDma)
            break;
    } while(pix.user == 0);

    LOOP_Y: for(int y=0; y<row_size; y++){
#pragma HLS LOOP_TRIPCOUNT avg=600 max=1080 min=48
        LOOP_X: for(int x=0; x<col_size; x++){
#pragma HLS LOOP_TRIPCOUNT avg=800 max=1920 min=64
#pragma HLS PIPELINE II=1
            if (!(x==0 && y==0))    // 最初の入力はすでに入力されている
                ins >> pix; // AXI4-Stream からの入力

            LOOP_PIX_MAT_K: for(int k=0; k<3; k++){
                LOOP_PIX_MAT_M: for(int m=0; m<2; m++){
                    pix_mat[k][m] = pix_mat[k][m+1];
                }
            }
            pix_mat[0][2] = line_buf[0][x];
            pix_mat[1][2] = line_buf[1][x];
            ap_int<32> y_val = pix.data;
            pix_mat[2][2] = y_val;

            line_buf[0][x] = line_buf[1][x];    // 行の入れ替え
            line_buf[1][x] = y_val;

            unsharp_masking_fil(pix_mat, k, val);
            unsharp_masking.data = val;
            if(x<2 || y<2)
                unsharp_masking.data = 0;

            if(function==ORG_IMGwAxiVdma || function == UNSHARP_MASKINGwAxiVdma){
                if(x==0 && y==0) // 最初のピクセル
                    unsharp_masking.user = 1;
                else
                    unsharp_masking.user = 0;
                if(x == (col_size-1)) // 行の最後
                    unsharp_masking.last = 1;
                else
                    unsharp_masking.last = 0;
            }else{
                unsharp_masking.user = 0;
                unsharp_masking.last = pix.last;
            }
            unsharp_masking.keep = 0x7;
            unsharp_masking.strb = 0x7;
            if(function==UNSHARP_MASKINGwAxiVdma || function==UNSHARP_MASKINGwAxiDma)
                outs << unsharp_masking;
            else
                outs << pix;
        }
    }
    return(0);
}

// アンシャープマスキング・フィルタ
// x0y0 x1y0 x2y0 -k   -j  -k
// x0y1 x1y1 x2y1 -k  9+8k -k x 1/9
// x0y2 x1y2 x2y2 -k   -k  -k
//
// k : 鮮鋭化の強さ(固定小数点) , k != 0
// num_adec_k : Kの小数点の位置
// 2015/09/27 : 演算の小数部は num_adec_k*2 ビットとする。
//
void unsharp_masking_fil(ap_int<32> (&pix_mat)[size][size], UM_FIXED k, ap_uint<24> &result){
    ap_int<32> pix_1d_r[9], pix_1d_b[9], pix_1d_g[9];
    ap_int<32> y_r, y_b, y_g, y;

    for(int i=0; i<9; i++){
        separate_rgb(pix_mat[i/3][i%3], pix_1d_r[i], pix_1d_g[i], pix_1d_b[i]);
    }

    y_r = unsharp_masking_fil_calc(pix_1d_r, k);
    y_b = unsharp_masking_fil_calc(pix_1d_b, k);
    y_g = unsharp_masking_fil_calc(pix_1d_g, k);

    result = (y_r << 16) + (y_g << 8) + y_b;
}

// unsharp_masking_fil_calc
// アルゴリズムは”アンシャープマスキング(鮮鋭化フィルタ)” https://imagingsolution.net/imaging/unsharpmasking/ を参照している
ap_int<32> unsharp_masking_fil_calc(ap_int<32> *pixd, UM_FIXED k){
    UM_FIXED y_fixed;
    ap_int<32> y;

    y_fixed = (-(UM_FIXED)pixd[0] - (UM_FIXED)pixd[1] - (UM_FIXED)pixd[2] -(UM_FIXED)pixd[3]
        - (UM_FIXED)pixd[5] - (UM_FIXED)pixd[6] - (UM_FIXED)pixd[7] - (UM_FIXED)pixd[8]) * k;
    y_fixed += ((UM_FIXED)9.0 + (UM_FIXED)8.0 * k) * pixd[4];
    y_fixed /= (UM_FIXED)9.0;
    y = (ap_int<32>)(y_fixed + (UM_FIXED)0.5); // 四捨五入          

    if(y<0)
        //y = -y;
        y = 0;
    else if(y>255) // 8 bits
        y = 255;
    return(y);
}

// separate_rgb
// RGBを分離する
// RBGのフォーマットは、{R(8bits), G(8bits), B(8bits)}, 1pixel = 32bits
//
ap_int<32> separate_rgb(ap_int<32> rbg, ap_int<32> &r, ap_int<32> &g, ap_int<32> &b){
    b = rbg & 0xff;
    g = (rbg>>8) & 0xff;
    r = (rbg>>16) & 0xff;
    return(0);
}


テストベンチの unsharp_masking_axis_RGB24_tb.cpp を示す。

// unsharp_masking_axis_RGB24_tb.cpp
// 2023/08/18 by marsee
// UNSHARP_MASKINGwXilinxVideoStandard を define すると axi_vdma 用となり、コメントアウトすると axi_dma 用になる
//

#include <stdio.h>
#include <stdint.h>
#include <ap_int.h>
#include <hls_stream.h>
#include <ap_axi_sdata.h>
#include "opencv2/opencv.hpp"
#include "opencv2/imgproc/imgproc.hpp"
#include "opencv2/highgui/highgui.hpp"
#include "opencv2/imgcodecs/imgcodecs.hpp"

#include "unsharp_masking_axis_RGB24.h"

//#define UNSHARP_MASKINGwXilinxVideoStandard

constexpr int size = 3;

int unsharp_masking_axis_RGB24(hls::stream<ap_axiu<24,1,1,1> >& ins,
        hls::stream<ap_axiu<24,1,1,1> >& outs, int32_t function,
         int32_t row_size, int32_t col_size, UM_FIXED k);
int unsharp_masking_axis_RGB24_soft(hls::stream<ap_axiu<24,1,1,1> >& ins,
        hls::stream<ap_axiu<24,1,1,1> >& outs, int32_t function,
         int32_t row_size, int32_t col_size, float k);
void unsharp_masking_fil_soft(ap_int<32> (&pix_mat)[size][size], float k, ap_uint<24> &result);
ap_int<32> unsharp_masking_fil_calc_soft(ap_int<32> *pixd, float k);
ap_int<32> separate_rgb_soft(ap_int<32> rgb, ap_int<32> &r, ap_int<32> &g, ap_int<32> &b);

const char INPUT_JPG_FILE[] = "test2.jpg";
const char OUTPUT_JPG_FILE[] = "unsharp_masking.jpg";
const char ORG_OUT_JPG_FILE[] = "org_image.jpg";

#define SHARPENING_STRENGTH 4.0
#define SQUARE_ERROR_LIMIT    0 // 2乗誤差のエラー限界、この数より上はエラーとする

int main(){
    hls::stream<ap_axiu<24,1,1,1> > ins, ins2;
    hls::stream<ap_axiu<24,1,1,1> > ins_soft;
    hls::stream<ap_axiu<24,1,1,1> > outs, outs2;
    hls::stream<ap_axiu<24,1,1,1> > outs_soft;
    ap_axiu<24,1,1,1> pix;
    ap_axiu<24,1,1,1> vals, vals_soft;
    UM_FIXED k;
    float fk;

    // JPG ファイルをMat に読み込む
    cv::Mat img = cv::imread(INPUT_JPG_FILE);

    // ピクセルを入れる領域の確保
    std::vector<int32_t> rd_bmp(sizeof(int32_t)*img.cols*img.rows);
    std::vector<int32_t> hw_unsharp_masking(sizeof(int32_t)*(img.cols)*(img.rows));
    std::vector<int32_t> sw_unsharp_masking(sizeof(int32_t)*(img.cols)*(img.rows));

    // rd_bmp にJPGのピクセルを代入
    cv::Mat_<cv::Vec3b> dst_vec3b = cv::Mat_<cv::Vec3b>(img);
    for (int y=0; y<img.rows; y++){
        for (int x=0; x<img.cols; x++){
            cv::Vec3b pixel;
            pixel = dst_vec3b(y,x);
            rd_bmp[y*img.cols+x] = (pixel[0] & 0xff) | ((pixel[1] & 0xff)<<8) | ((pixel[2] & 0xff)<<16); // RGB 8 bits
            // blue - pixel[0]; green - pixel[1]; red - pixel[2];
        }
    }

#ifdef UNSHARP_MASKINGwXilinxVideoStandard
    // ins に入力データを用意する
    for(int i=0; i<5; i++){ // dummy data
        pix.user = 0;
        pix.data = i;
        pix.last = 0;
        pix.user = 0;
        pix.keep = 0x7;
        pix.strb = 0x7;
        ins << pix;
    }
#endif

    for(int j=0; j < img.rows; j++){
        for(int i=0; i < img.cols; i++){
            pix.data = (int32_t)rd_bmp[(j*img.cols)+i];
#ifdef UNSHARP_MASKINGwXilinxVideoStandard
            if (j==0 && i==0)   // 最初のデータの時に TUSER を 1 にする
                pix.user = 1;
            else
                pix.user = 0;

            if (i == img.cols-1) // 行の最後でTLASTをアサートする
                pix.last = 1;
            else
                pix.last = 0;
#else
            if(j==img.rows-1 && i==img.cols-1)
                pix.last = 1;
            else
                pix.last = 0;
            pix.user = 0;
#endif
            pix.keep = 0x7;
            pix.strb = 0x7;

            ins << pix;
            ins2 << pix;
            ins_soft << pix;
        }
    }

    k = (UM_FIXED)SHARPENING_STRENGTH;
    fk = (float)SHARPENING_STRENGTH;
#ifdef UNSHARP_MASKINGwXilinxVideoStandard
    unsharp_masking_axis_RGB24(ins, outs, UNSHARP_MASKINGwAxiVdma, img.rows, img.cols, k); // ハードウェアのメディアンフィルタ
    unsharp_masking_axis_RGB24_soft(ins_soft, outs_soft, UNSHARP_MASKINGwAxiVdma, img.rows, img.cols, fk);  // ソフトウェアのメディアンフィルタ
#else
    unsharp_masking_axis_RGB24(ins, outs, UNSHARP_MASKINGwAxiDma, img.rows, img.cols, k); // ハードウェアのメディアンフィルタ
    unsharp_masking_axis_RGB24_soft(ins_soft, outs_soft, UNSHARP_MASKINGwAxiDma, img.rows, img.cols, fk);  // ソフトウェアのメディアンフィルタ
#endif

    // ハードウェアとソフトウェアのメディアンフィルタの値のチェック
    for (int y=0; y<img.rows; y++){ // 結果の画像サイズはx-2, y-2
        for (int x=0; x<img.cols; x++){
            outs >> vals;
            outs_soft >> vals_soft;
            ap_uint<32> val = vals.data;
            ap_uint<32> val_soft = vals_soft.data;
            hw_unsharp_masking[y*img.cols+x] = (int32_t)val;
            if ((double)pow((double)(val&0xff)-(val_soft&0xff),(double)2) > SQUARE_ERROR_LIMIT || // v の2乗誤差が4よりも大きい
                (double)pow((double)((val>>8)&0xff)-((val_soft>>8)&0xff),(double)2) > SQUARE_ERROR_LIMIT || // s の2乗誤差が4よりも大きい
                (double)pow((double)((val>>16)&0x1ff)-((val_soft>>16)&0x1ff),(double)2) > SQUARE_ERROR_LIMIT){ // h の2乗誤差が4よりも大きい
                printf("ERROR HW and SW results mismatch x = %ld, y = %ld, HW = %x, SW = %x\n",
                        x, y, val, val_soft);
                return(1);
            }
        }
    }
    printf("Success HW and SW results match\n");

    const int unsharp_masking_row = img.rows;
    const int unsharp_masking_cols = img.cols;
    cv::Mat wbmpf(unsharp_masking_row, unsharp_masking_cols, CV_8UC3);
    // wbmpf にunsharp_masking フィルタ処理後の画像を入力
    cv::Mat_<cv::Vec3b> sob_vec3b = cv::Mat_<cv::Vec3b>(wbmpf);
    for (int y=0; y<wbmpf.rows; y++){
        for (int x=0; x<wbmpf.cols; x++){
            cv::Vec3b pixel;
            pixel = sob_vec3b(y,x);
            int32_t rbg = hw_unsharp_masking[y*wbmpf.cols+x];
            pixel[0] = (rbg & 0xff); // blue
            pixel[1] = ((rbg >> 8) & 0xff); // green
            pixel[2] = ((rbg >> 16) & 0xff); // red
            sob_vec3b(y,x) = pixel;
        }
    }

    // ハードウェアのメディアンフィルタの結果を jpg ファイルへ出力する
    cv::imwrite(OUTPUT_JPG_FILE, wbmpf);

#ifdef UNSHARP_MASKINGwXilinxVideoStandard
    unsharp_masking_axis_RGB24(ins2, outs2, ORG_IMGwAxiVdma, img.rows, img.cols, k); // ハードウェアのメディアンフィルタ
#else
    unsharp_masking_axis_RGB24(ins2, outs2, ORG_IMGwAxiDma, img.rows, img.cols, k); // ハードウェアのメディアンフィルタ
#endif

    cv::Mat wbmpf2(unsharp_masking_row, unsharp_masking_cols, CV_8UC3);
    // wbmpf2 に元画像を入力
    sob_vec3b = cv::Mat_<cv::Vec3b>(wbmpf2);
    for (int y=0; y<wbmpf.rows; y++){
        for (int x=0; x<wbmpf.cols; x++){
            cv::Vec3b pixel;
            pixel = sob_vec3b(y,x);
            outs2 >> vals;
            int32_t val = vals.data;
            pixel[0] = (val & 0xff); // blue
            pixel[1] = ((val >> 8) & 0xff); // green
            pixel[2] = ((val >> 16) & 0xff); // red
            sob_vec3b(y,x) = pixel;
        }
    }

    // 元画像を jpg ファイルへ出力する
    cv::imwrite(ORG_OUT_JPG_FILE, wbmpf2);

    return(0);
}

// アンシャープマスキング・フィルタのアルゴリズムは”アンシャープマスキング(鮮鋭化フィルタ)”
// (https://imagingsolution.net/imaging/unsharpmasking/)を参照した
//
int unsharp_masking_axis_RGB24_soft(hls::stream<ap_axiu<24,1,1,1> >& ins,
        hls::stream<ap_axiu<24,1,1,1> >& outs, int32_t function,
         int32_t row_size, int32_t col_size, float k){

    ap_axiu<24,1,1,1> pix;
    ap_axiu<24,1,1,1> unsharp_masking;
    ap_uint<24> val;

    ap_int<32> line_buf[2][1920];
#pragma HLS array_partition variable=line_buf block factor=2 dim=1

    ap_int<32> pix_mat[size][size];
#pragma HLS array_partition variable=pix_mat complete

    LOOP_WAIT_USER : do {   // user が 1になった時にフレームがスタートする
#pragma HLS LOOP_TRIPCOUNT min=1 max=1 avg=1
        ins >> pix;
        if(function==ORG_IMGwAxiDma || function==UNSHARP_MASKINGwAxiDma)
            break;
    } while(pix.user == 0);

    LOOP_Y: for(int y=0; y<row_size; y++){
#pragma HLS LOOP_TRIPCOUNT avg=600 max=1080 min=48
        LOOP_X: for(int x=0; x<col_size; x++){
#pragma HLS LOOP_TRIPCOUNT avg=800 max=1920 min=64
#pragma HLS PIPELINE II=1
            if (!(x==0 && y==0))    // 最初の入力はすでに入力されている
                ins >> pix; // AXI4-Stream からの入力

            LOOP_PIX_MAT_K: for(int k=0; k<3; k++){
                LOOP_PIX_MAT_M: for(int m=0; m<2; m++){
                    pix_mat[k][m] = pix_mat[k][m+1];
                }
            }
            pix_mat[0][2] = line_buf[0][x];
            pix_mat[1][2] = line_buf[1][x];
            ap_int<32> y_val = pix.data;
            pix_mat[2][2] = y_val;

            line_buf[0][x] = line_buf[1][x];    // 行の入れ替え
            line_buf[1][x] = y_val;

            unsharp_masking_fil_soft(pix_mat, k, val);
            unsharp_masking.data = val;
            if(x<2 || y<2)
                unsharp_masking.data = 0;

            if(function==ORG_IMGwAxiVdma || function == UNSHARP_MASKINGwAxiVdma){
                if(x==0 && y==0) // 最初のピクセル
                    unsharp_masking.user = 1;
                else
                    unsharp_masking.user = 0;
                if(x == (col_size-1)) // 行の最後
                    unsharp_masking.last = 1;
                else
                    unsharp_masking.last = 0;
            }else{
                unsharp_masking.user = 0;
                unsharp_masking.last = pix.last;
            }
            unsharp_masking.keep = 0x7;
            unsharp_masking.strb = 0x7;
            if(function==UNSHARP_MASKINGwAxiVdma || function==UNSHARP_MASKINGwAxiDma)
                outs << unsharp_masking;
            else
                outs << pix;
        }
    }
    return(0);
}

// アンシャープマスキング・フィルタ
// x0y0 x1y0 x2y0 -k   -j  -k
// x0y1 x1y1 x2y1 -k  9+8k -k x 1/9
// x0y2 x1y2 x2y2 -k   -k  -k
//
// k : 鮮鋭化の強さ(固定小数点) , k != 0
// num_adec_k : Kの小数点の位置
// 2015/09/27 : 演算の小数部は num_adec_k*2 ビットとする。
//
void unsharp_masking_fil_soft(ap_int<32> (&pix_mat)[size][size], float k, ap_uint<24> &result){
    ap_int<32> pix_1d_r[9], pix_1d_b[9], pix_1d_g[9];
    ap_int<32> y_r, y_b, y_g, y;

    for(int i=0; i<9; i++){
        separate_rgb_soft(pix_mat[i/3][i%3], pix_1d_r[i], pix_1d_g[i], pix_1d_b[i]);
    }

    y_r = unsharp_masking_fil_calc_soft(pix_1d_r, k);
    y_b = unsharp_masking_fil_calc_soft(pix_1d_b, k);
    y_g = unsharp_masking_fil_calc_soft(pix_1d_g, k);

    result = (y_r << 16) + (y_g << 8) + y_b;
}

// unsharp_masking_fil_calc
// アルゴリズムは”アンシャープマスキング(鮮鋭化フィルタ)” https://imagingsolution.net/imaging/unsharpmasking/ を参照している
ap_int<32> unsharp_masking_fil_calc_soft(ap_int<32> *pixd, float k){
    float y_fixed;
    ap_int<32> y;

    y_fixed = (-(float)pixd[0] - (float)pixd[1] - (float)pixd[2] -(float)pixd[3]
        - (float)pixd[5] - (float)pixd[6] - (float)pixd[7] - (float)pixd[8]) * k;
    y_fixed += ((float)9.0 + (float)8.0 * k) * pixd[4];
    y_fixed /= (float)9.0;
    y = (ap_int<32>)(y_fixed + (float)0.5); // 四捨五入          

    if(y<0)
        //y = -y;
        y = 0;
    else if(y>255) // 8 bits
        y = 255;
    return(y);
}

// separate_rgb
// RGBを分離する
// RBGのフォーマットは、{R(8bits), G(8bits), B(8bits)}, 1pixel = 32bits
//
ap_int<32> separate_rgb_soft(ap_int<32> rbg, ap_int<32> &r, ap_int<32> &g, ap_int<32> &b){
    b = rbg & 0xff;
    g = (rbg>>8) & 0xff;
    r = (rbg>>16) & 0xff;
    return(0);
}


画像ソフトの Pinta で 2.0 のガウスぼかしを掛けた test2.jpg を示す。
zub1cg_i7filters_83_231125.jpg
  1. 2023年11月25日 07:58 |
  2. Vitis HLS
  3. | トラックバック:0
  4. | コメント:0

コメント

コメントの投稿


管理者にだけ表示を許可する

トラックバック URL
https://marsee101.blog.fc2.com/tb.php/6106-1bc1766f
この記事にトラックバックする(FC2ブログユーザー)