ÇÁ·Î±×·¡¹Ö

 3206, 2/161 ȸ¿ø°¡ÀÔ  ·Î±×ÀΠ 
   sgolds
   ºôµå´Â µÇ´Âµ¥ µð¹ö±ëÀÌ ¾ÈµÇ³×¿ä ¤Ð¤Ð

http://www.hackerschool.org/HS_Boards/zboard.php?id=QNA_programming&no=6574 [º¹»ç]


#include <stdio.h>
#include <stdlib.h>


typedef int boolean;
#define true  1
#define false 0

#define M                                 5
#define N                                 30
#define winSize                        250
#define HP_CONSTANT                ((float) 1 / (float) M)

void detect(float* ecg, int* result, int len);

int main(int argc, char** argv){
        float new_pt;
        float ecg[1000000] = { 0 };
        int result[1000000] = { 0 };
        int i=0, j;

        // read in ECG data
        FILE *fid = NULL;

        if (argc > 1){
                fid = fopen(argv[1], "r");
        }
        else{
                fid = fopen("100.text", "r");
        }


        while (EOF != fscanf(fid, "%f\n", &new_pt)){
                ecg[i++] = new_pt;

                //                printf("%f\n", new_pt);
        }

        fclose(fid);

        // perform realtime QRS detection
        detect(ecg, result, i);

        // save detection results
        fid = fopen("101.text", "w");

        for (j = 0; j < i; j++){
                fprintf(fid, "%d\n", result[j]);
        }

        fclose(fid);

        return 0;
}

void detect(float* ecg, int* result, int len) {
        // circular buffer for input ecg signal
        // we need to keep a history of M + 1 samples for HP filter
        float ecg_buff[M + 1] = { 0 };
        int ecg_buff_WR_idx = 0;
        int ecg_buff_RD_idx = 0;

        // circular buffer for input ecg signal
        // we need to keep a history of N+1 samples for LP filter
        float hp_buff[N + 1] = { 0 };
        int hp_buff_WR_idx = 0;
        int hp_buff_RD_idx = 0;

        // LP filter outputs a single point for every input point
        // This goes straight to adaptive filtering for eval
        float next_eval_pt = 0;

        // running sums for HP and LP filters, values shifted in FILO
        float hp_sum = 0;
        float lp_sum = 0;

        // parameters for adaptive thresholding
        double treshold = 0;
        boolean triggered = false;
        int trig_time = 0;
        float win_max = 0;
        int win_idx = 0;

        int i = 0;

        for (i = 0; i < len; i++){
                ecg_buff[ecg_buff_WR_idx++] = ecg[i];
                ecg_buff_WR_idx %= (M + 1);

                //printf("i - %d\n", i);

                /* High pass filtering */
                if (i < M){
                        // first fill buffer with enough points for HP filter
                        hp_sum += ecg_buff[ecg_buff_RD_idx];
                        hp_buff[hp_buff_WR_idx] = 0;

                        //printf("hp_buff[hp_buff_WR_idx] - %f\n", hp_buff[hp_buff_WR_idx]);
                }
                else{
                        hp_sum += ecg_buff[ecg_buff_RD_idx];

                        int tmp = ecg_buff_RD_idx - M;
                        if (tmp < 0) tmp += M + 1;

                        hp_sum -= ecg_buff[tmp];

                        float y1 = 0;
                        float y2 = 0;

                        tmp = (ecg_buff_RD_idx - ((M + 1) / 2));
                        if (tmp < 0) tmp += M + 1;

                        y2 = ecg_buff[tmp];

                        y1 = HP_CONSTANT * hp_sum;

                        hp_buff[hp_buff_WR_idx] = y2 - y1;

                        //printf("hp_buff[hp_buff_WR_idx] - %f\n", hp_buff[hp_buff_WR_idx]);
                }

                // done reading ECG buffer, increment position
                ecg_buff_RD_idx++;
                ecg_buff_RD_idx %= (M + 1);

                // done writing to HP buffer, increment position
                hp_buff_WR_idx++;
                hp_buff_WR_idx %= (N + 1);

                /* Low pass filtering */

                // shift in new sample from high pass filter
                lp_sum += hp_buff[hp_buff_RD_idx] * hp_buff[hp_buff_RD_idx];

                if (i < N){
                        // first fill buffer with enough points for LP filter
                        next_eval_pt = 0;

                }
                else{
                        // shift out oldest data point
                        int tmp = hp_buff_RD_idx - N;
                        if (tmp < 0) tmp += N + 1;

                        lp_sum -= hp_buff[tmp] * hp_buff[tmp];

                        next_eval_pt = lp_sum;
                }

                // done reading HP buffer, increment position
                hp_buff_RD_idx++;
                hp_buff_RD_idx %= (N + 1);

                /* Adapative thresholding beat detection */
                // set initial threshold                                
                if (i < winSize) {
                        if (next_eval_pt > treshold) {
                                treshold = next_eval_pt;
                        }
                }

                // check if detection hold off period has passed
                if (triggered){
                        trig_time++;

                        if (trig_time >= 100){
                                triggered = false;
                                trig_time = 0;
                        }
                }

                // find if we have a new max
                if (next_eval_pt > win_max) win_max = next_eval_pt;

                // find if we are above adaptive threshold
                if (next_eval_pt > treshold && !triggered) {
                        result[i] = 1;

                        triggered = true;
                }
                else {
                        result[i] = 0;
                }

                // adjust adaptive threshold using max of signal found
                // in previous window            
                if (win_idx++ >= winSize){
                        // weighting factor for determining the contribution of
                        // the current peak value to the threshold adjustment
                        double gamma = 0.175;

                        // forgetting factor -
                        // rate at which we forget old observations
                        double alpha = 0.01 + (((float)rand() / (float)RAND_MAX) * ((0.1 - 0.01)));

                        treshold = alpha * gamma * win_max + (1 - alpha) * treshold;

                        // reset current window ind
                        win_idx = 0;
                        win_max = -10000000;
                }
        }
}
  À§ ¿¡ ÄÚµùÀÌ°í¿ä ¤Ð¤Ð
0x009120C7¿¡(QRS.exeÀÇ) ù° ¿¹¿Ü°¡ ÀÖ½À´Ï´Ù. 0xC00000FD: Stack overflow(¸Å°³ º¯¼ö: 0x00000000, 0x00552000).
0x009120C7¿¡(QRS.exeÀÇ) 󸮵ÇÁö ¾ÊÀº ¿¹¿Ü°¡ ÀÖ½À´Ï´Ù. 0xC00000FD: Stack overflow(¸Å°³ º¯¼ö: 0x00000000, 0x00552000).
ÀÌ·¸°Ô  ¶ß³×¿ä  ÀüÀÚ°øÇаú Àε¥ ÄÚµùÀ» ÇÏ·Ã Èûµå³×¿ä ¤Ð¤Ð

  Hit : 3831     Date : 2017/03/26 02:23



    
ÇØÄð·¯ ecg_buff[ecg_buff_WR_idx++] = ecg[i];
hp_buff[hp_buff_WR_idx] = y2 - y1;
lp_sum -= hp_buff[tmp] * hp_buff[tmp];
ÀÌ·±½ÄÀ¸·Î ¹è¿­¿¡ Á¢±ÙÇÏ´Â ¸ðµç ÄÚµåµéÀº À妽º °ª¿¡ ´ëÇÑ °ËÁõÀÌ È®½ÇÇØ¾ß ÇÕ´Ï´Ù
assert(ecg_buff_WR_IDX < M + 1); ó·³ ¿¹¿Üó¸® Äڵ带 ¸ðµÎ »ðÀÔÇÏ°í Á¤È®È÷ ¾îµð¼­ Out Of Bounds access°¡ ÀϾ´ÂÁö ¾Ë¾Æ¾ßÇÕ´Ï´Ù
ÀÌ·¸°Ô ÇÏÁö ¾ÊÀ¸·Á¸é ¾î¼Àºí¸®¾î¸¦ º¸°í µð¹ö±ëÇؾßÇϴµ¥ ±×°Ô ´õ ¾î·Æ½À´Ï´Ù
2017/03/26  
pwnnnt °«Äð·¯´Ô. 2017/03/26  
3186     [re] c¾ð¾î ¾Ë°í¸®Áò Áú¹®ÀÔ´Ï´Ù.     dafher
05/13 1576
3185   c¾ð¾î ¼Ò½º Áú¹® ¹¹°¡ ¹®Á¦ÀÎÁö¤Ì¤Ì¤Ì¤Ì[2]     sjjh96
05/23 4262
3184   ÆÄÀ̽ã Ŭ·¡½º °øºÎÁß Áú¹®[1]     wnsdud5534
04/12 3466
3183   dll ÀÎÁ§¼Ç Å°º¸µå ÈÄÅ·(win32api)[1]     healer
03/11 3299
3182   C++ ÇÔ¼ö ¿À¹ö·Îµù ¿À·ù Áú¹®ÀÔ´Ï´Ù. [1]     sweetick
03/04 5501
3181   Æ÷ÀÎÅÍ¿¡ ¸Þ¸ð¸®¸¦ Á÷Á¢ ³Ö´Â°Ô °¡´ÉÇÒ±î¿ä??[3]     ljs0652
01/24 2215
3180   File Descriptor °ü·Ã Áú¹®ÀÔ´Ï´Ù.     tjdalstjr938
01/22 2021
3179   C¾ð¾î [2]     rhdbrkd2
01/02 2656
3178   C¾ð¾î °øºÎ¸¦ ÇÏ·Á°í Çϴµ¥...[3]     rhdbrkd2
12/15 3546
3177   c¾ð¾î ±¸Á¶Ã¼ ¹è¿­ Æ÷ÀÎÅÍ·Î ÇÔ¼ö·Î Àü´ÞÇϴµ¥...[3]     my10045139
12/13 6075
3176   ÇÙ¸Ç ÄÚµå Áú¹®     yyy3399
12/09 3142
3175   ÀÚ¹Ù ±âÃÊ Ã¥, ¾Û ±âÃÊ Ã¥, ¾Û º¸¾È Ã¥ (3°¡Áö À¯¸íÇÑ Ã¥Á» Ãßõ¹Ù¶ø´Ï´Ù.)[1]     viewstar
11/26 3485
3174   ÀÚ¹Ù ÇÁ·Î±×·¡¹Ö °è»ê±â ÇÁ·Î±×·¥ Áú¹®µå¸³´Ï´Ù.[2]     daze1234
10/27 4497
3173   ÆÄÀ̽ã: ÆĽºÄ®ÀÇ »ï°¢Çü[1]     sunnykim97
10/14 3888
3172   visual studio 2017 c++ ÄÄÆÄÀÏ ¿¡·¯³µ´Âµ¥ ÇØ°á¹æ¹ýÀ» ¸ð¸£°Ú¾î¿ä¤Ð¤Ð     93jmj
10/13 3185
3171   ÇÑ ÇÁ·Î±×·¥ ³» ¼ÒÄÏ 2°³[1]     ysl1121
09/19 3886
3170   C¾ð¾î(¿­Ç÷C) ¿¹Á¦Ç®ÀÌÁß ¾ÈÇ®·Á¼­ Áú¹®µå·Á¿ä ¤Ð¤Ð[5]     ijs2you
08/28 3621
3169   c°øºÎ ½ÃÀÛÇߴµ¥ ¿¹Á¦¸¶´Ù »õ·Î¿î ¼Ò½ºÆÄÀÏ Ãß°¡ÇؾßÇϳª¿ä?[5]     Newbiee
05/10 2978
3168   ÆÄÀ̽ã Äڵ尡 ¹¹°¡¹®Á¦ÀÎÁö ¤Ð¤Ð[1]     zero1
04/29 3314
3167   ÁÖ¾îÁø ¹®Á¦¶û ÄÚµåÀÛ¼ºµÈ°Å¶û ¸Â´ÂÁöºÁÁÖ¼¼¿ä..     lia9173
04/05 2575
[1] 2 [3][4][5][6][7][8][9][10]..[161]

Copyright 1999-2024 Zeroboard / skin by Hackerschool.org / Secure Patch by Hackerschool.org