ÇÁ·Î±×·¡¹Ö

 3206, 1/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 : 3858     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  
3206   SNSÇØÅ·ÀÌ µÇ³ª¿ë? µµ¿ÍÁÖ¼¼¿ä ¤Ð¤Ð¤Ð [2]     ÇÑä¹Î
02/28 343
3205   Ä¡Æ®¿£Áø °í¼öºÐ °è½Ç±î¿ä[1]     rjsdudals123
02/15 195
3204   ¿À·ù Á» ã¾ÆÁÖ¼¼¿ä [1]     marunim
05/30 927
3203 ºñ¹Ð±ÛÀÔ´Ï´Ù  124     minsub87
08/17 1
3202   c¾ð¾î segmentation fault:11 ¿À·ù Áú¹®µå¸³´Ï´Ù![2]     leebk1124
05/21 2011
3201   C++ÇÔ¼ö°ü·Ã Áú¹®ÀÌ¿¡¿ë!![3]     1999dylee
05/11 1846
3200   ÆÄÀ̽ã Áö¹® µå¸³´Ï´Ù.[1]     kksh1107
04/24 1589
3199   ¸®¹ö½ÌÀÇ ¼¼¹ø¤Š ²É - ¿ª¶û-     nninni79
04/20 2289
3198   ´Þ°í³ª ¹®¼­ ½©ÄÚµå[1]     ghjk645
03/24 1609
3197 ºñ¹Ð±ÛÀÔ´Ï´Ù  c¾ð¾î ¼Ò¼ö °ª     adwefq
04/29 0
3196   C¾ð¾î ¼Ò½ºÁú¹®ÀÔ´Ï´Ù![5]     an0088
01/05 5130
3195   C++ /// ºôµå ¿¡·¯ ¤Ð¤Ð[1]     guichanta
08/23 2399
3194 ºñ¹Ð±ÛÀÔ´Ï´Ù  c¾ð¾î µµ¿ÍÁÖ¼¼¿ä¤Ð¤Ð     su6339
04/06 0
3193   ÇØÅ·À» ¹è¿ì·Á°íÇϴµ¥[3]     zoodem04
03/26 4181
3192   c¾ð¾î¸¦ ¹è¿ì°í½Í¾î¿ä ![7]     dwc07238
02/11 4067
3191   ½ºÅÃÀÌ ½×ÀÌ´Â ¹æÇâ¿¡ °üÇؼ­!![1]     hackxx123
12/10 3519
3190   ÇØÅ·Åø¿¡¼­ ip ¾øÀÌ Çϵ忡 ½É´Â°Å¿¡´Â ¾î¶²°Ô ÀÖÀ»±î¿ä?[2]     aowlrgmlals
11/27 4281
3189   C¾ð¾î Çϴµ¥ double ½Ç¼ö¸¦ ³ÖÀºµ¥ ÀÚ²Ù 0.0ÀÌ ³ª¿Í¿ä[2]     fatou10336
11/20 3737
3188   dumpcode.h ÀÌÇØÁ» µµ¿ÍÁÖ¼¼¿ä .[1]     cm6418
11/06 3708
3187   c¾ð¾î ¾Ë°í¸®Áò Áú¹®ÀÔ´Ï´Ù.[3]     alstn8150
10/12 3738
1 [2][3][4][5][6][7][8][9][10]..[161]

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