ÇÁ·Î±×·¡¹Ö

 3206, 3/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 : 3844     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  
  ºôµå´Â µÇ´Âµ¥ µð¹ö±ëÀÌ ¾ÈµÇ³×¿ä ¤Ð¤Ð[2]     sgolds
03/26 3843
3165   C¿¡¼­ python subprocess°°Àº°Ô ÀÖ³ª¿ä?[3]     vngkv123
03/17 3290
3164   ¼Ò½º¿Í °á°ú°¡ °°Àº ¼Ò½ºÄÚµå[1]     ewqqw
03/08 3355
3163   ÆÄÀ̽㠰ü·ÃÁú¹®ÇÕ´Ï´Ù.[1]     cgw0525
02/27 2259
3162   c++ ´Ù¸¥Å¬·¡½ºÀÇ ¸â¹öº¯¼ö °ª °¡Á®¿Í¼­ »ç¿ë¹æ¹ýÁú¹®ÀÌ¿©[2]     ÀÔ¹®»ý
02/02 15896
3161   sniffing Áß Áú¹®ÀÖ½À´Ï´Ù..     ssk1547
12/11 2351
3160   ÄÚµù¹®Á¦°¡ ÀÌÇØ°¡ ¾ÈµË´Ï´Ù..     ncheg97
11/15 3411
3159   gui ÇÁ·Î±×·¡¹Ö¿¡ ´ëÇØ Áú¹®ÇÕ´Ï´Ù![1]     iwonderhow
10/07 3894
3158   C¾ð¾î µµ´ëü ¹¹°¡ ¹®Á¨Áö ¸ô¶ó¼­ Áú¹®µå¸³´Ï´Ù.[6]     dydwo9177
08/27 8415
3157   ºñÁÖ¾óº£ÀÌÁ÷ 6.0 ȣȯ[1]     bluessky
08/10 3445
3156   ¹öÆÛ ¿À¹öÇ÷οì-¿Õ±âÃÊÆí12pdf[2]     Error123
07/24 3436
3155   C¾ð¾î µµ¿òÁ»ÁÖ¼¼¿ä. Call by address [3]     good3951
06/09 3843
3154   C¾ð¾î »ó¼ö °ü·Ã Áú¹®ÀÔ´Ï´Ù ¤Ð µµ¿ÍÁֽʼî, ¸àºØÀÔ´Ï´Ù.[3]     ysl1121
06/05 3348
3153   C¾ð¾î °øºÎ ¹æ±Ý ¸· ½ÃÀÛÇߴµ¥ ...[2]     Å©¾û
06/04 3586
3152   c¾ð¾î °ü·Ã Áú¹®[3]     twin0719
05/08 3258
3151   JAVA ÄÚµå¾ÆÄ«µ¥¹Ì °ü·ÃÇؼ­ ¿©Â庾´Ï´Ù[3]     king1706
04/20 4507
3150   ÀÌ ½ºÅ©¸³Æ®¸¦ ¾µ¶§ ½ºÅà ¿À¹ö Ç÷ο찡 ³ª¿À´Â Çö»ó[1]     formor
04/18 4090
3149   cÇÁ·Î±×·¥ ºñÁê¾ó½ºÆ©µð¿À¶û xnote¶û ÄÄÆÄÀÏ·¯ Â÷ÀÌ.[1]     poiu2069
04/06 2952
3148   ³í¸®¿¬»êÀÚ ºÎºÐ¿¡¼­ °è¼Ó ¿À·ù°¡ ¶ß³×¿ä...;;[4]     zxc1400
11/08 3664
3147   ÀÌ ÇÁ·Î±×·¥¿¡¼­ À߸øµÈ Á¡ ÀÖÀ¸¸é ¾Ë·ÁÁÖ¼¼¿ä ...[5]     ktw365
10/16 3430
[1][2] 3 [4][5][6][7][8][9][10]..[161]

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