demo

parameter

#define DEMO 1

#ifdef OPENCV

static char **demo_names;
static image **demo_alphabet;
static int demo_classes;

static network *net;
static image buff [3];
static image buff_letter[3];
static int buff_index = 0;
static void * cap;
static float fps = 0;
static float demo_thresh = 0;
static float demo_hier = .5;
static int running = 0;

static int demo_frame = 3;
static int demo_index = 0;
static float **predictions;
static float *avg;
static int demo_done = 0;
static int demo_total = 0;
double demo_time;

detection *get_network_boxes(network *net, int w, int h, float thresh, float hier, int *map, int relative, int *num);

demo_names: 클래스 이름을 담고 있는 문자열 배열
demo_alphabet: 이미지 출력 시 사용되는 폰트 이미지 배열
demo_classes: 클래스의 개수
net: 딥러닝 모델을 담고 있는 네트워크 구조체
buff: 카메라 또는 비디오 스트림에서 읽어들인 이미지를 담고 있는 이미지 배열
buff_letter: 이미지 출력 시 사용되는 글자 이미지 배열
buff_index: 현재 사용 중인 이미지 배열의 인덱스
cap: 카메라 또는 비디오 스트림을 담고 있는 포인터
fps: 현재 프레임 속도
demo_thresh: 객체 탐지에 사용되는 임계값
demo_hier: 객체 탐지 시 사용되는 IoU 임계값
running: 프로그램이 실행 중인지 나타내는 플래그
demo_frame: 현재 프레임 인덱스
demo_index: 현재 클래스 인덱스
predictions: 네트워크가 예측한 객체의 정보를 담고 있는 이차원 배열
avg: 예측한 객체 정보의 평균값
demo_done: 객체 탐지가 완료되었는지 나타내는 플래그
demo_total: 객체 탐지된 전체 개수
demo_time: 객체 탐지에 소요된 시간

함수 이름: detection *get_network_boxes

입력:

network *net : 사용할 네트워크
int w : 이미지의 가로 크기
int h : 이미지의 세로 크기
float thresh : 객체 검출을 위한 최소 확률 임계값
float hier : 객체 검출을 위한 최소 IOU 임계값
int *map : 사용하지 않음
int relative : 좌표 계산에 사용
int *num : 검출된 객체의 수를 저장할 포인터

size_network

int size_network(network *net)
{
    int i;
    int count = 0;
    for(i = 0; i < net->n; ++i){
        layer l = net->layers[i];
        if(l.type == YOLO || l.type == REGION || l.type == DETECTION){
            count += l.outputs;
        }
    }
    return count;
}

함수 이름: size_network

입력:

network 구조체 포인터 (neural network 모델)

동작:

입력으로 받은 neural network 모델에서 YOLO, REGION, DETECTION 레이어의 출력 크기를 합산하여 총 출력 크기를 계산한다.

설명:

이 함수는 neural network 모델의 출력 크기를 계산하는 함수이다.
입력으로 받은 모델의 모든 레이어를 순회하면서 YOLO, REGION, DETECTION 레이어의 출력 크기를 합산하여 반환한다.
이 함수는 예를 들어 모델의 출력 크기를 계산하는 데 사용될 수 있으며, 예측이나 추론 결과를 처리하는 데 유용하게 사용될 수 있다.

remember_network

void remember_network(network *net)
{
    int i;
    int count = 0;
    for(i = 0; i < net->n; ++i){
        layer l = net->layers[i];
        if(l.type == YOLO || l.type == REGION || l.type == DETECTION){
            memcpy(predictions[demo_index] + count, net->layers[i].output, sizeof(float) * l.outputs);
            count += l.outputs;
        }
    }
}

함수 이름: remember_network

입력:

network *net: 뉴럴 네트워크 구조체 포인터

동작:

네트워크의 출력 값을 예측 값으로 복사하여 기억합니다.
이 함수는 YOLO, REGION 또는 DETECTION 레이어에서 나온 출력 값만 복사합니다.

설명:

뉴럴 네트워크에서는 입력 데이터를 이용하여 출력 값을 예측합니다.
이 함수는 해당 네트워크의 예측 값을 복사하여 기억합니다.
이 기억된 예측 값은 나중에 다양한 목적으로 사용될 수 있습니다.
이 함수는 demo_index와 predictions 배열을 사용합니다.
demo_index는 현재 데모에서 사용되는 이미지의 인덱스를 나타내며, predictions 배열은 예측 값을 기억하기 위한 배열입니다.
이 함수는 각 레이어의 출력 값의 크기를 count 변수에 누적하여 predictions 배열의 적절한 위치에 복사합니다.

avg_predictions

detection *avg_predictions(network *net, int *nboxes)
{
    int i, j;
    int count = 0;
    fill_cpu(demo_total, 0, avg, 1);
    for(j = 0; j < demo_frame; ++j){
        axpy_cpu(demo_total, 1./demo_frame, predictions[j], 1, avg, 1);
    }
    for(i = 0; i < net->n; ++i){
        layer l = net->layers[i];
        if(l.type == YOLO || l.type == REGION || l.type == DETECTION){
            memcpy(l.output, avg + count, sizeof(float) * l.outputs);
            count += l.outputs;
        }
    }
    detection *dets = get_network_boxes(net, buff[0].w, buff[0].h, demo_thresh, demo_hier, 0, 1, nboxes);
    return dets;
}

함수 이름: avg_predictions

입력:

network *net: 네트워크 모델
int *nboxes: 감지된 bounding box의 개수를 담을 포인터 변수

동작:

이전에 저장된 예측(predictions)을 이용하여 각 클래스에 대한 확률값의 평균을 계산한다.
계산된 평균값을 이용하여 다시 네트워크를 실행하고, 감지된 bounding box를 반환한다.

설명:

이전에 저장된 predictions은 remember_network 함수를 통해 저장된 예측값을 말한다.
이 함수에서는 저장된 예측값들의 평균값을 계산하고, 이를 이용하여 네트워크를 실행한다.
이전 예측값들의 평균을 이용함으로써 일시적인 예측값의 변동성을 줄이고, 보다 안정적인 예측 결과를 얻을 수 있다.
계산된 예측값을 이용하여 get_network_boxes 함수를 호출하여 bounding box를 감지하고, 이를 반환한다.

detect_in_thread

void *detect_in_thread(void *ptr)
{
    running = 1;
    float nms = .4;

    layer l = net->layers[net->n-1];
    float *X = buff_letter[(buff_index+2)%3].data;
    network_predict(net, X);

    /*
       if(l.type == DETECTION){
       get_detection_boxes(l, 1, 1, demo_thresh, probs, boxes, 0);
       } else */
    remember_network(net);
    detection *dets = 0;
    int nboxes = 0;
    dets = avg_predictions(net, &nboxes);


    /*
       int i,j;
       box zero = {0};
       int classes = l.classes;
       for(i = 0; i < demo_detections; ++i){
       avg[i].objectness = 0;
       avg[i].bbox = zero;
       memset(avg[i].prob, 0, classes*sizeof(float));
       for(j = 0; j < demo_frame; ++j){
       axpy_cpu(classes, 1./demo_frame, dets[j][i].prob, 1, avg[i].prob, 1);
       avg[i].objectness += dets[j][i].objectness * 1./demo_frame;
       avg[i].bbox.x += dets[j][i].bbox.x * 1./demo_frame;
       avg[i].bbox.y += dets[j][i].bbox.y * 1./demo_frame;
       avg[i].bbox.w += dets[j][i].bbox.w * 1./demo_frame;
       avg[i].bbox.h += dets[j][i].bbox.h * 1./demo_frame;
       }
    //copy_cpu(classes, dets[0][i].prob, 1, avg[i].prob, 1);
    //avg[i].objectness = dets[0][i].objectness;
    }
     */

    if (nms > 0) do_nms_obj(dets, nboxes, l.classes, nms);

    printf("\033[2J");
    printf("\033[1;1H");
    printf("\nFPS:%.1f\n",fps);
    printf("Objects:\n\n");
    image display = buff[(buff_index+2) % 3];
    draw_detections(display, dets, nboxes, demo_thresh, demo_names, demo_alphabet, demo_classes);
    free_detections(dets, nboxes);

    demo_index = (demo_index + 1)%demo_frame;
    running = 0;
    return 0;
}

함수 이름: detect_in_thread

입력:

void* ptr: 포인터 타입의 인자, 사용하지 않음

동작:

YOLO 신경망으로 객체를 탐지하고, 결과를 출력 이미지에 표시한다.
평균 예측 값을 계산하고, 이를 바탕으로 객체를 탐지하고, 비최대 억제(NMS)를 수행한다.
마지막으로, 탐지된 객체들을 이미지에 그리고 출력한다.

설명:

먼저, running 변수를 1로 설정하여 스레드가 실행중임을 표시한다.
nms 변수에 0.4를 할당하여 비최대 억제에 사용될 임계값을 설정한다.
다음으로, YOLO 신경망의 출력층(layer)을 가져와서, 현재 처리할 이미지 데이터인 buff_letter[(buff_index+2)%3].data를 입력값으로 전달하여 객체를 예측한다.
예측된 결과를 평균 예측 값으로 기억하고, avg_predictions() 함수를 사용하여 평균 예측 값을 바탕으로 객체를 탐지한다.
비최대 억제를 수행하여 중복으로 탐지된 객체를 제거한다.
마지막으로, 출력 이미지에 탐지된 객체들을 그리고 출력한다. 스레드가 실행을 완료하면 running 변수를 0으로 설정하여 스레드가 종료되었음을 표시한다.

fetch_in_thread

void *fetch_in_thread(void *ptr)
{
    free_image(buff[buff_index]);
    buff[buff_index] = get_image_from_stream(cap);
    if(buff[buff_index].data == 0) {
        demo_done = 1;
        return 0;
    }
    letterbox_image_into(buff[buff_index], net->w, net->h, buff_letter[buff_index]);
    return 0;
}

함수 이름: fetch_in_thread

입력:

void *ptr: 포인터

동작:

카메라로부터 이미지를 가져와서 해당 이미지를 신경망 모델의 입력 크기에 맞게 리사이징하고, 이전 이미지를 해제하고 새 이미지로 대체함.

설명:

이 함수는 쓰레드에서 실행되며, 카메라 스트림에서 이미지를 가져와서 이전 버퍼 이미지를 해제하고, 새 이미지를 신경망 모델의 입력 크기에 맞게 리사이징하여 현재 버퍼에 할당하는 역할을 합니다.
이전에 할당된 이미지 메모리를 해제하여 메모리 누수를 방지합니다.

display_in_thread

void *display_in_thread(void *ptr)
{
    int c = show_image(buff[(buff_index + 1)%3], "Demo", 1);
    if (c != -1) c = c%256;
    if (c == 27) {
        demo_done = 1;
        return 0;
    } else if (c == 82) {
        demo_thresh += .02;
    } else if (c == 84) {
        demo_thresh -= .02;
        if(demo_thresh <= .02) demo_thresh = .02;
    } else if (c == 83) {
        demo_hier += .02;
    } else if (c == 81) {
        demo_hier -= .02;
        if(demo_hier <= .0) demo_hier = .0;
    }
    return 0;
}

함수 이름: display_in_thread

입력:

void *ptr: 포인터

동작:

현재 버퍼 중 뒤의 두 번째 이미지를 화면에 표시한다.
키보드 입력을 받아 해당하는 기능을 수행한다. (ESC: 종료, R: detection 임계값 증가, F: detection 임계값 감소, T: hierarchy 임계값 증가, G: hierarchy 임계값 감소)

설명:

딥러닝 모델이 예측한 결과를 화면에 보여주는 역할을 담당하는 함수이다.
버퍼 중 뒤의 두 번째 이미지를 화면에 표시하여 실시간으로 영상을 확인할 수 있도록 한다.
키보드 입력을 받아 해당하는 기능을 수행한다. ESC를 누르면 프로그램이 종료되고, R, F, T, G 키를 누르면 각각 detection 임계값을 증가시키거나 감소시키고, hierarchy 임계값을 증가시키거나 감소시킨다.

display_loop

void *display_loop(void *ptr)
{
    while(1){
        display_in_thread(0);
    }
}

함수 이름: display_loop

입력:

ptr: void 포인터

동작:

display_in_thread 함수를 무한 루프로 실행하여 영상 출력 창을 유지시키고, 사용자 입력에 따라 demo_thresh와 demo_hier 등의 변수 값을 변경할 수 있도록 한다.

설명:

이 함수는 사용자에게 영상 출력 창을 제공하고, 사용자 입력을 받아들여 변수 값들을 조절할 수 있도록 한다.
display_in_thread 함수는 이 함수 내에서 무한히 반복되며, 영상 출력 창이 종료되거나 프로그램이 종료될 때까지 유지된다.
이 함수는 쓰레드로 실행되기 때문에, 메인 프로그램과 별개로 동작하며 영상 출력 창이 종료되더라도 메인 프로그램은 계속해서 실행될 수 있다.

detect_loop


void *detect_loop(void *ptr)
{
    while(1){
        detect_in_thread(0);
    }
}

함수 이름: detect_loop 입력:

ptr: void 포인터 (사용하지 않음)

동작:

무한 루프를 돌면서 detect_in_thread 함수를 호출하여 객체 탐지를 수행

설명:

객체 탐지 루프를 돌며 영상에서 객체를 탐지하고, 그 결과를 화면에 표시하는 함수입니다.

demo

void demo(char *cfgfile, char *weightfile, float thresh, int cam_index, const char *filename, char **names, int classes, int delay, char *prefix, int avg_frames, float hier, int w, int h, int frames, int fullscreen)
{
    //demo_frame = avg_frames;
    image **alphabet = load_alphabet();
    demo_names = names;
    demo_alphabet = alphabet;
    demo_classes = classes;
    demo_thresh = thresh;
    demo_hier = hier;
    printf("Demo\n");
    net = load_network(cfgfile, weightfile, 0);
    set_batch_network(net, 1);
    pthread_t detect_thread;
    pthread_t fetch_thread;

    srand(2222222);

    int i;
    demo_total = size_network(net);
    predictions = calloc(demo_frame, sizeof(float*));
    for (i = 0; i < demo_frame; ++i){
        predictions[i] = calloc(demo_total, sizeof(float));
    }
    avg = calloc(demo_total, sizeof(float));

    if(filename){
        printf("video file: %s\n", filename);
        cap = open_video_stream(filename, 0, 0, 0, 0);
    }else{
        cap = open_video_stream(0, cam_index, w, h, frames);
    }

    if(!cap) error("Couldn't connect to webcam.\n");

    buff[0] = get_image_from_stream(cap);
    buff[1] = copy_image(buff[0]);
    buff[2] = copy_image(buff[0]);
    buff_letter[0] = letterbox_image(buff[0], net->w, net->h);
    buff_letter[1] = letterbox_image(buff[0], net->w, net->h);
    buff_letter[2] = letterbox_image(buff[0], net->w, net->h);

    int count = 0;
    if(!prefix){
        make_window("Demo", 1352, 1013, fullscreen);
    }

    demo_time = what_time_is_it_now();

    while(!demo_done){
        buff_index = (buff_index + 1) %3;
        if(pthread_create(&fetch_thread, 0, fetch_in_thread, 0)) error("Thread creation failed");
        if(pthread_create(&detect_thread, 0, detect_in_thread, 0)) error("Thread creation failed");
        if(!prefix){
            fps = 1./(what_time_is_it_now() - demo_time);
            demo_time = what_time_is_it_now();
            display_in_thread(0);
        }else{
            char name[256];
            sprintf(name, "%s_%08d", prefix, count);
            save_image(buff[(buff_index + 1)%3], name);
        }
        pthread_join(fetch_thread, 0);
        pthread_join(detect_thread, 0);
        ++count;
    }
}

함수 이름: demo

입력:

char *cfgfile: YOLO 모델의 설정 파일 경로
char *weightfile: 학습된 YOLO 모델의 가중치 파일 경로
float thresh: Object detection 결과의 임계값
int cam_index: 사용할 웹캠의 인덱스 (0부터 시작)
const char *filename: Object detection을 수행할 동영상 파일 경로 (웹캠을 사용하지 않을 경우에만 사용)
char **names: Object detection 대상 클래스명 배열
int classes: Object detection 대상 클래스 수
int delay: Object detection 프레임 간의 딜레이
char *prefix: Object detection 결과 저장시 사용할 파일 이름 prefix
int avg_frames: Object detection 프레임의 평균화 수 (최근 몇 개의 프레임을 평균화하여 Object detection 수행)
float hier: YOLO 모델의 hier 파라미터 값
int w: 동영상 또는 웹캠 프레임의 너비
int h: 동영상 또는 웹캠 프레임의 높이
int frames: Object detection 수행할 프레임 수 (동영상에서 사용)
int fullscreen: Object detection 결과를 풀스크린으로 표시할지 여부

동작:

YOLO 모델을 로드하고, 웹캠 또는 동영상을 캡처하기 위한 초기화 작업을 수행한다.
Object detection 결과를 저장하기 위한 배열과 변수를 초기화한다.
Object detection을 위한 fetch, detect, display 스레드를 생성하고, 결과를 출력한다.
prefix가 설정되어 있으면 Object detection 결과를 이미지 파일로 저장한다.
demo_done 플래그가 설정되면 프로그램을 종료한다.

설명:

이 코드는 YOLO 알고리즘을 사용하여 object detection을 수행하는 데모 프로그램이다.
프로그램은 웹캠 또는 동영상을 입력으로 받아서 Object detection을 수행하고, 결과를 실시간으로 출력한다.
프로그램은 fetch, detect, display 스레드를 생성하여 Object detection 처리를 병렬화하고, 최적화된 성능을 보인다.
프로그램에서 사용하는 fetch_in_thread, detect_in_thread, display_in_thread 함수들은 각각 fetch, detect, display 스레드에서 실행되는 함수이다.
demo 함수는 이들 스레드를 생성하고, Object detection 결과를 출력하는 메인 루프 역할을 수행한다.

demo error

#else
void demo(char *cfgfile, char *weightfile, float thresh, int cam_index, const char *filename, char **names, int classes, int delay, char *prefix, int avg, float hier, int w, int h, int frames, int fullscreen)
{
    fprintf(stderr, "Demo needs OpenCV for webcam images.\n");
}
#endif

함수 이름: demo

입력:

char *cfgfile: YOLO 모델의 구성 파일 경로
char *weightfile: 학습된 YOLO 모델의 가중치 파일 경로
float thresh: 객체 탐지 임계값
int cam_index: 사용할 카메라의 인덱스
const char *filename: 사용할 비디오 파일 경로
char **names: 클래스 이름 배열
int classes: 클래스 수
int delay: 비디오 재생 프레임 간 딜레이 (밀리초 단위)
char *prefix: 결과 이미지 파일 이름의 prefix
int avg: YOLO 모델에서 사용되는 평균화 프레임 수
float hier: YOLO 모델에서 사용되는 Hierarchy 임계값
int w: 입력 이미지의 너비
int h: 입력 이미지의 높이
int frames: 비디오에서 읽을 프레임 수
int fullscreen: 전체 화면 모드 여부

동작:

YOLO 모델을 로드하고 입력 이미지를 처리하며 객체 탐지 결과를 표시하는 데모를 수행한다.
OpenCV를 사용하여 웹캠 또는 비디오 파일에서 입력 이미지를 가져온다.
YOLO 모델에서 객체 탐지를 위해 fetch_in_thread 및 detect_in_thread 함수를 실행하는 스레드를 생성한다.
display_in_thread 함수를 사용하여 객체 탐지 결과를 화면에 표시한다.
비디오에서 프레임을 읽고 이미지를 처리한 후 결과 이미지를 파일로 저장할 수 있다.
프로그램 종료 조건인 demo_done이 true가 될 때까지 무한 루프를 실행한다.

설명:

이 함수는 OpenCV를 사용하여 웹캠 또는 비디오 파일에서 입력 이미지를 가져와 YOLO 모델을 사용하여 객체를 탐지하는 데모를 수행한다.
만약 OpenCV가 설치되어 있지 않은 경우에는 "Demo needs OpenCV for webcam images." 메시지가 출력된다.
이 함수에서는 fetch_in_thread 및 detect_in_thread 함수를 실행하는 스레드를 생성하여 객체 탐지 속도를 향상시키고, display_in_thread 함수를 사용하여 객체 탐지 결과를 화면에 표시한다.
또한, 비디오에서 프레임을 읽고 이미지를 처리한 후 결과 이미지를 파일로 저장할 수 있다.

Previousdeconvolutional_layer Nextdetection_layer

Last updated 1 year ago