algorytm wykrywania tętna iOS

[7]}próbuję zaimplementować funkcję nagrywania bicia serca w rozwijanej aplikacji.

Znalazłem bardzo dobry punkt wyjścia z następującym pytaniem o przepełnienie stosu tutaj

Pytanie dostarcza użytecznego kodu do wykreowania bicia serca Wykres czasu.

Pokazuje, jak uruchomić Avcapturession i włączyć światło kamery w ten sposób:

session = [[AVCaptureSession alloc] init];

AVCaptureDevice* camera = [AVCaptureDevice defaultDeviceWithMediaType:AVMediaTypeVideo];
if([camera isTorchModeSupported:AVCaptureTorchModeOn]) {
    [camera lockForConfiguration:nil];
    camera.torchMode=AVCaptureTorchModeOn;
    //  camera.exposureMode=AVCaptureExposureModeLocked;
    [camera unlockForConfiguration];
}
// Create a AVCaptureInput with the camera device
NSError *error=nil;
AVCaptureInput* cameraInput = [[AVCaptureDeviceInput alloc] initWithDevice:camera error:&error];
if (cameraInput == nil) {
    NSLog(@"Error to create camera capture:%@",error);
}

// Set the output
AVCaptureVideoDataOutput* videoOutput = [[AVCaptureVideoDataOutput alloc] init];

// create a queue to run the capture on
dispatch_queue_t captureQueue=dispatch_queue_create("catpureQueue", NULL);

// setup our delegate
[videoOutput setSampleBufferDelegate:self queue:captureQueue];

// configure the pixel format
videoOutput.videoSettings = [NSDictionary dictionaryWithObjectsAndKeys:[NSNumber numberWithUnsignedInt:kCVPixelFormatType_32BGRA], (id)kCVPixelBufferPixelFormatTypeKey,
                             nil];
videoOutput.minFrameDuration=CMTimeMake(1, 10);

// and the size of the frames we want
[session setSessionPreset:AVCaptureSessionPresetLow];

// Add the input and output
[session addInput:cameraInput];
[session addOutput:videoOutput];

// Start the session
[session startRunning];

Self w tym przykładzie musi być <AVCaptureVideoDataOutputSampleBufferDelegate> I dlatego będzie musiał wdrożyć następującą metodę, aby uzyskać surowe dane z kamery:

- (void)captureOutput:(AVCaptureOutput *)captureOutput didOutputSampleBuffer:(CMSampleBufferRef)sampleBuffer fromConnection:(AVCaptureConnection *)connection {
static int count=0;
count++;
// only run if we're not already processing an image
// this is the image buffer
CVImageBufferRef cvimgRef = CMSampleBufferGetImageBuffer(sampleBuffer);
// Lock the image buffer
CVPixelBufferLockBaseAddress(cvimgRef,0);
// access the data
int width=CVPixelBufferGetWidth(cvimgRef);
int height=CVPixelBufferGetHeight(cvimgRef);
// get the raw image bytes
uint8_t *buf=(uint8_t *) CVPixelBufferGetBaseAddress(cvimgRef);
size_t bprow=CVPixelBufferGetBytesPerRow(cvimgRef);
float r=0,g=0,b=0;
for(int y=0; y<height; y++) {
    for(int x=0; x<width*4; x+=4) {
        b+=buf[x];
        g+=buf[x+1];
        r+=buf[x+2];
        //          a+=buf[x+3];
    }
    buf+=bprow;
}
r/=255*(float) (width*height);
g/=255*(float) (width*height);
b/=255*(float) (width*height);

float h,s,v;

RGBtoHSV(r, g, b, &h, &s, &v);

// simple highpass and lowpass filter 

static float lastH=0;
float highPassValue=h-lastH;
lastH=h;
float lastHighPassValue=0;
float lowPassValue=(lastHighPassValue+highPassValue)/2;

lastHighPassValue=highPassValue;

    //low pass value can now be used for basic heart beat detection


}

RGB jest konwertowany na HSV i to odcień jest monitorowany pod kątem fluktuacji.

I RGB do HSV jest zaimplementowane w następujący sposób

void RGBtoHSV( float r, float g, float b, float *h, float *s, float *v ) {
float min, max, delta; 
min = MIN( r, MIN(g, b )); 
max = MAX( r, MAX(g, b )); 
*v = max;
delta = max - min; 
if( max != 0 )
    *s = delta / max;
else {
    // r = g = b = 0 
    *s = 0; 
    *h = -1; 
    return;
}
if( r == max )
    *h = ( g - b ) / delta; 
else if( g == max )
    *h=2+(b-r)/delta;
else 
    *h=4+(r-g)/delta; 
*h *= 60;
if( *h < 0 ) 
    *h += 360;
}

Wartość low pass obliczona w capureOutput: początkowo dostarcza danych nieregularnych, ale potem

2013-11-04 16:18:13.619 SampleHeartRateApp[1743:1803] -0.071218
2013-11-04 16:18:13.719 SampleHeartRateApp[1743:1803] -0.050072
2013-11-04 16:18:13.819 SampleHeartRateApp[1743:1803] -0.011375
2013-11-04 16:18:13.918 SampleHeartRateApp[1743:1803] 0.018456
2013-11-04 16:18:14.019 SampleHeartRateApp[1743:1803] 0.059024
2013-11-04 16:18:14.118 SampleHeartRateApp[1743:1803] 0.052198
2013-11-04 16:18:14.219 SampleHeartRateApp[1743:1803] 0.078189
2013-11-04 16:18:14.318 SampleHeartRateApp[1743:1803] 0.046035
2013-11-04 16:18:14.419 SampleHeartRateApp[1743:1803] -0.113153
2013-11-04 16:18:14.519 SampleHeartRateApp[1743:1803] -0.079792
2013-11-04 16:18:14.618 SampleHeartRateApp[1743:1803] -0.027654
2013-11-04 16:18:14.719 SampleHeartRateApp[1743:1803] -0.017288

Przykład błędnych danych podanych na początku jest tutaj:

2013-11-04 16:17:28.747 SampleHeartRateApp[1743:3707] 17.271435
2013-11-04 16:17:28.822 SampleHeartRateApp[1743:1803] -0.049067
2013-11-04 16:17:28.922 SampleHeartRateApp[1743:1803] -6.524201
2013-11-04 16:17:29.022 SampleHeartRateApp[1743:1803] -0.766260
2013-11-04 16:17:29.137 SampleHeartRateApp[1743:3707] 9.956407
2013-11-04 16:17:29.221 SampleHeartRateApp[1743:1803] 0.076244
2013-11-04 16:17:29.321 SampleHeartRateApp[1743:1803] -1.049292
2013-11-04 16:17:29.422 SampleHeartRateApp[1743:1803] 0.088634
2013-11-04 16:17:29.522 SampleHeartRateApp[1743:1803] -1.035559
2013-11-04 16:17:29.621 SampleHeartRateApp[1743:1803] 0.019196
2013-11-04 16:17:29.719 SampleHeartRateApp[1743:1803] -1.027754
2013-11-04 16:17:29.821 SampleHeartRateApp[1743:1803] 0.045803
2013-11-04 16:17:29.922 SampleHeartRateApp[1743:1803] -0.857693
2013-11-04 16:17:30.021 SampleHeartRateApp[1743:1803] 0.061945
2013-11-04 16:17:30.143 SampleHeartRateApp[1743:1803] -0.701269

Wartość low pass jest dodatnia, gdy jest bicie serca. Wypróbowałem więc bardzo prosty algorytm wykrywania NA ŻYWO, który w zasadzie patrzy na aktualną wartość i widzi, czy jest dodatnia, patrzy również na poprzednią wartość, jeśli ujemna wykrywa ujemną przechodzącą na dodatnią i odtwarza dźwięk dźwiękowy.

Problem w tym, że dane nie zawsze są tak doskonałe, jak powyżej, czasami są anomalne pozytywne odczyty wśród negatywnych odczytów i vice versa.

Wykres wartości niskiego przejścia w czasie wygląda następująco:

Co ciekawe powyższa anomalia jest dość powszechna, jeśli nagram Wykres przez chwilę, zobaczę bardzo podobną anomalię w kształcie wiele razy.

W moim bardzo prostym algorytmie wykrywania uderzeń, jeśli wystąpi anomalia, jak pokazano powyżej, zliczona liczba uderzeń w okresie wykrywania (10 sekund) może wzrosnąć o 4 lub 5 bity. To sprawia, że obliczony BPM jest bardzo niedokładny. Ale tak proste, jak to jest, działa około 70% czasu.

Aby zwalczyć ten problem, próbowałem następujących.

1.Rozpoczęte nagrywanie ostatnich 3 wartości dolnoprzepustowych w tablicy

2.Następnie spojrzał, czy Średnia wartość miała dwie mniejsze wartości otaczające go przed i po. (Podstawowe wykrywanie piku)

3.Policzył ten scenariusz jako beat i dodał go do sumy uderzeń w danym czas.

Ta metoda jest jednak tak samo podatna na anomalie, jak każda inna. I wydawało się, że to gorsza metoda. (Podczas odtwarzania sygnałów dźwiękowych na żywo po wykryciu wydawały się znacznie bardziej nieregularne niż algorytm dodatni do ujemnego) {]}

Moje pytanie brzmi, czy możesz mi pomóc wymyślić algorytm, który może niezawodnie wykryć, gdy wystąpi bicie serca z rozsądną dokładnością.

Innym problemem, który zdaję sobie sprawę, że będę musiał rozwiązać, jest wykrywanie, czy palec użytkownika jest na obiektywie.

Myślałem o wykryciu nieobliczalnych wartości dolnoprzepustowych, ale problem polega na tym, że filtr dolnoprzepustowy odpowiada za nieobliczalne wartości i wygładza je w czasie. Więc pomoc tam też będzie mile widziana.