void DimensionSelector::transform (ITransformer::info info, ssi_stream_t &stream_in, ssi_stream_t &stream_out, ssi_size_t xtra_stream_in_num, ssi_stream_t xtra_stream_in[]) { ssi_byte_t *inptr = ssi_pcast (ssi_byte_t , stream_in.ptr); ssi_byte_t *outptr = ssi_pcast (ssi_byte_t, stream_out.ptr); for (ssi_size_t i = 0; i < stream_in.num; i++) { ssi_size_t cur_selected = 0; for (ssi_size_t a = 0; a < _max_selected; a++) { if(_selector[a]) { memcpy(outptr, inptr, sizeof(_bytes)); outptr += _bytes; ++cur_selected; //stop searching if we found all needed values if(cur_selected >= _n_selected) break; } //go to next input inptr += _bytes; } } }
void QRSDetection::sendEvent_h(ITransformer::info &info, ssi_time_t sample_rate, ssi_size_t frame_count, ssi_size_t sample_number){ ssi_size_t samples_per_frame = info.frame_num; ssi_size_t frame_time = ssi_sec2ms (info.time); ssi_real_t time_per_sample = 1000.0f / (ssi_real_t) sample_rate; ssi_size_t current_sample = frame_count * samples_per_frame + sample_number; ssi_size_t current_sample_time = ssi_cast (ssi_size_t, current_sample * time_per_sample + 0.5); if (_listener) { _r_event.time = current_sample_time; _r_event.dur = ssi_cast (ssi_size_t, time_per_sample + 0.5); if(_send_etuple) { ssi_event_map_t *ptr = ssi_pcast (ssi_event_map_t, _r_event.ptr); ptr[0].value = ssi_real_t (current_sample_time - _last_R); } else { ssi_real_t *ptr = ssi_pcast (ssi_real_t, _r_event.ptr); ptr[0] = ssi_real_t(current_sample_time - _last_R); } _listener->update (_r_event); } else { ssi_print("\nR-spike detected in \n\tframe number %u with starting time %u ms", frame_count, frame_time); ssi_print("\n\tat sample number %u at time %u ms", current_sample, current_sample_time); } _last_R = current_sample_time; }
void PreEmphasis::transform (ITransformer::info info, ssi_stream_t &stream_in, ssi_stream_t &stream_out, ssi_size_t xtra_stream_in_num, ssi_stream_t xtra_stream_in[]) { ssi_size_t num = stream_in.num; ssi_real_t *x = ssi_pcast (ssi_real_t, stream_in.ptr); ssi_real_t *y = ssi_pcast (ssi_real_t, stream_out.ptr); if (first_call) { hist = *x; first_call = false; } if (de) { for (ssi_size_t n = 0; n < num; n++) { *(y++) = *(x) + k * hist; hist = *x++; } } else { for (ssi_size_t n = 0; n < num; n++) { *(y++) = *(x) - k * hist; hist = *x++; } } }
void AudioConvert::transform (ITransformer::info info, ssi_stream_t &stream_in, ssi_stream_t &stream_out, ssi_size_t xtra_stream_in_num, ssi_stream_t xtra_stream_in[]) { if (_short_to_float) { int16_t *srcptr = ssi_pcast (int16_t, stream_in.ptr); ssi_real_t *dstptr = ssi_pcast (ssi_real_t, stream_out.ptr); ssi_size_t N = stream_in.num * stream_in.dim; for (ssi_size_t i = 0; i < N; i++) { *dstptr++ = ssi_cast (ssi_real_t, *srcptr++) / 32768.0f; } } else { ssi_real_t *srcptr = ssi_pcast (ssi_real_t, stream_in.ptr); int16_t *dstptr = ssi_pcast (int16_t, stream_out.ptr); ssi_size_t N = stream_in.num * stream_in.dim; for (ssi_size_t i = 0; i < N; i++) { *dstptr++ = ssi_cast (int16_t, *srcptr++ * 32768.0f); } } }
void SignalPainter::consume (IConsumer::info consume_info, ssi_size_t stream_in_num, ssi_stream_t stream_in[]) { for (ssi_size_t i = 0; i < _n_windows; i++) { if (_options.type == PaintSignalType::BAR || _options.type == PaintSignalType::BAR_POS) { if (_options.barNames[0] != '\0') { ssi_size_t n = ssi_split_string_count(_options.barNames, ','); ssi_char_t **tokens = new ssi_char_t *[n]; ssi_split_string(n, tokens, _options.barNames, ','); ssi_pcast(PaintBars, _client[i])->setExternalAxisCaptions(n, tokens); for (ssi_size_t j = 0; j < n; j++) { delete[] tokens[j]; } delete[] tokens; } if (_options.reset) { ssi_pcast(PaintBars, _client[i])->reset(); } ssi_pcast(PaintBars, _client[i])->setData(stream_in[i]); } else { if (_options.reset) { ssi_pcast(PaintSignal, _client[i])->resetLimits(); } ssi_pcast(PaintSignal, _client[i])->setData(stream_in[i], consume_info.time); } _canvas[i]->update(); } }
void QRSDetection::transform_enter (ssi_stream_t &stream_in, ssi_stream_t &stream_out, ssi_size_t xtra_stream_in_num, ssi_stream_t xtra_stream_in[]) { //bandpass Butfilt *bandpass = ssi_pcast (Butfilt, Factory::Create (Butfilt::GetCreateName (), 0, false)); bandpass->getOptions()->type = Butfilt::BAND; bandpass->getOptions()->norm = false; bandpass->getOptions()->high = 15; bandpass->getOptions()->low = 5; bandpass->getOptions()->order = 13; _bandpass = bandpass; ssi_stream_init (_bandpass_stream, 0, _bandpass->getSampleDimensionOut (stream_in.dim), _bandpass->getSampleBytesOut (stream_in.byte), _bandpass->getSampleTypeOut (stream_in.type), stream_in.sr); _bandpass->transform_enter (stream_in, _bandpass_stream); //diff Derivative *diff = ssi_pcast(Derivative, Factory::Create (Derivative::GetCreateName (), 0, false)); ssi_strcpy (diff->getOptions()->names, "1st"); _diff = diff; ssi_stream_init (_diff_stream, 0, _diff->getSampleDimensionOut (_bandpass_stream.dim), _diff->getSampleBytesOut (_bandpass_stream.byte), _diff->getSampleTypeOut (_bandpass_stream.type), _bandpass_stream.sr); _diff->transform_enter (_bandpass_stream, _diff_stream); //qrs-pre-process QRSPreProcess *pre = ssi_pcast(QRSPreProcess, Factory::Create (QRSPreProcess::GetCreateName (), 0, false)); _pre = pre; ssi_stream_init (_pre_stream, 0, _pre->getSampleDimensionOut (_diff_stream.dim), _pre->getSampleBytesOut (_diff_stream.byte), _pre->getSampleTypeOut (_diff_stream.type), _diff_stream.sr); _pre->transform_enter(_diff_stream, _pre_stream); Butfilt *pre_low = ssi_create (Butfilt, 0, false); pre_low->getOptions()->zero = true; pre_low->getOptions()->norm = false; pre_low->getOptions ()->low = 6.4; pre_low->getOptions ()->order = 3; pre_low->getOptions ()->type = Butfilt::LOW; _pre_low = pre_low; ssi_stream_init (_pre_low_stream, 0, _pre_low->getSampleDimensionOut (_pre_stream.dim), _pre_low->getSampleBytesOut (_pre_stream.byte), _pre_low->getSampleTypeOut (_pre_stream.type), _pre_stream.sr); _pre_low->transform_enter(_pre_stream, _pre_low_stream); //qrs-detect ssi_size_t sample_dimension = _pre_low_stream.dim; _pulsed = false; _n_R = 0; _samples_since_last_R = 0; _sum_RR = 0; _average_RR = 0.0f; _history_RR = new ssi_size_t[_options.depthRR]; _last_R = 0; for (ssi_size_t k = 0; k < _options.depthRR; k++) { _history_RR[k] = 0; } _first_call = true; }
bool ISNorm::Norm(ssi_stream_t &stream, Params params) { if (stream.dim != params.n_features) { ssi_wrn("wrong stream dimension '%u' != '%u'", stream.dim, params.n_features); return false; } if (params.method == METHOD::NONE) { return true; } switch (params.method) { case METHOD::SCALE: { ssi_real_t *ptr = ssi_pcast(ssi_real_t, stream.ptr); ssi_real_t *aptr = params.mins; ssi_real_t *bptr = params.maxs; for (ssi_size_t j = 0; j < params.n_features; j++) { *ptr -= *aptr++; *ptr++ /= *bptr++; } if (params.limits[0] != 0.0f || params.limits[1] != 1.0f) { ptr = ssi_pcast(ssi_real_t, stream.ptr); ssi_real_t a = params.limits[1] - params.limits[0]; ssi_real_t b = params.limits[0]; for (ssi_size_t j = 0; j < params.n_features; j++) { *ptr *= a; *ptr++ += b; } } break; } case METHOD::ZSCORE: { ssi_real_t *ptr = ssi_pcast(ssi_real_t, stream.ptr); ssi_real_t *aptr = params.mean; ssi_real_t *bptr = params.stdv; for (ssi_size_t j = 0; j < params.n_features; j++) { *ptr -= *aptr++; *ptr++ /= *bptr++; } break; } } return true; }
void MyEventSender::consume(IConsumer::info consume_info, ssi_size_t stream_in_num, ssi_stream_t stream_in[]) { ssi_real_t *in = ssi_pcast(ssi_real_t, stream_in[0].ptr); ssi_real_t *out = ssi_pcast(ssi_real_t, _event.ptr); ssi_mean(stream_in[0].num, stream_in[0].dim, in, out); _event.time = ssi_cast(ssi_size_t, consume_info.time * 1000); _event.dur = ssi_cast(ssi_size_t, consume_info.dur * 1000); _elistener->update(_event); }
void StreamTransformer::transform(ITransformer::info info, ssi_stream_t &stream_in, ssi_stream_t &stream_out, ssi_size_t xtra_stream_in_num, ssi_stream_t xtra_stream_in[]) { ssi_size_t dim = stream_in.dim; ssi_size_t num = info.frame_num; ssi_real_t *srcptr = ssi_pcast(ssi_real_t, stream_in.ptr); ssi_real_t *dstptr = ssi_pcast(ssi_real_t, stream_out.ptr); transformThreshold(dim, num, srcptr, dstptr); }
void TupleEventSender::consume (IConsumer::info consume_info, ssi_size_t stream_in_num, ssi_stream_t stream_in[]) { ssi_size_t dim = stream_in[0].dim; ssi_size_t num = stream_in[0].num; ssi_real_t *src = ssi_pcast(ssi_real_t, stream_in[0].ptr); ssi_event_tuple_t *dst = ssi_pcast(ssi_event_tuple_t, _event.ptr); _event.time = ssi_cast (ssi_size_t, 1000 * consume_info.time + 0.5); _event.dur = ssi_cast (ssi_size_t, 1000 * consume_info.dur + 0.5); _event.state = consume_info.status == IConsumer::COMPLETED ? SSI_ESTATE_COMPLETED : SSI_ESTATE_CONTINUED; if (_options.mean) { ssi_real_t *mean = new ssi_real_t[dim]; ssi_mean(num, dim, src, mean); for (ssi_size_t i = 0; i < dim; i++) { dst++->value = mean[i]; } } if (_options.var) { ssi_real_t *var = new ssi_real_t[dim]; ssi_var(num, dim, src, var); for (ssi_size_t i = 0; i < dim; i++) { dst++->value = var[i]; } } if (_options.minval || _options.maxval) { ssi_real_t *minval = new ssi_real_t[dim]; ssi_size_t *minpos = new ssi_size_t[dim]; ssi_real_t *maxval = new ssi_real_t[dim]; ssi_size_t *maxpos = new ssi_size_t[dim]; ssi_minmax(num, dim, src, minval, minpos, maxval, maxpos); if (_options.minval) { for (ssi_size_t i = 0; i < dim; i++) { dst++->value = minval[i]; } } if (_options.maxval) { for (ssi_size_t i = 0; i < dim; i++) { dst++->value = maxval[i]; } } } _listener->update(_event); }
void SignalTools::Series (ssi_stream_t &series, ssi_time_t duration, ssi_real_t offset) { /* matlab code: t = 0:1/sr:dur-1/sr; */ ssi_real_t delta = ssi_cast (ssi_real_t, 1.0 / series.sr); ssi_size_t number = ssi_cast (ssi_size_t, duration / delta); SSI_ASSERT (number > 0); ssi_stream_adjust (series, number); ssi_real_t *out = ssi_pcast (ssi_real_t, series.ptr); ssi_real_t *outptr_new = out; ssi_real_t *outptr_old = out; for (ssi_size_t i = 0; i < series.dim; ++i) { *outptr_new++ = offset; } for (ssi_size_t i = series.dim; i < series.dim * series.num; ++i) { *outptr_new++ = *outptr_old++ + delta; } }
void MyFilter2::transform(ITransformer::info info, ssi_stream_t &stream_in, ssi_stream_t &stream_out, ssi_size_t xtra_stream_in_num, ssi_stream_t xtra_stream_in[]) { ssi_real_t *ptr_in = ssi_pcast(ssi_real_t, stream_in.ptr); char *ptr_out = ssi_pcast(char, stream_out.ptr); if (!_hist) { _hist = new ssi_real_t[stream_in.dim]; for (ssi_size_t i = 0; i < stream_in.dim; i++) { _hist[i] = ptr_in[i]; } } for (ssi_size_t i = 0; i < stream_in.num; i++) { bool result = false; for (ssi_size_t j = 0; j < stream_in.dim; j++) { result = result || (abs(_hist[j] - *ptr_in) > _options.speed); _hist[j] = *ptr_in++; } *ptr_out++ = result ? 1 : 0; } }
void SignalTools::Cosine (ssi_stream_t &series, ssi_time_t *frequency, ssi_real_t *amplitude) { /* matlab code: t = 0:1/sr:dur-1/sr; signal = A' * sin (2*pi*f*t); */ ssi_real_t *ptr = ssi_pcast (ssi_real_t, series.ptr); ssi_real_t *pipif = new ssi_real_t[series.dim]; for (ssi_size_t j = 0; j < series.dim; ++j) { pipif[j] = static_cast<ssi_real_t> (2.0 * PI * frequency[j]); } for (ssi_size_t i = 0; i < series.num; ++i) { for (ssi_size_t j = 0; j < series.dim; ++j) { *ptr = amplitude[j] * cos (pipif[j] * *ptr); ++ptr; } } delete[] pipif; }
void SignalTools::Random(ssi_stream_t &stream) { ssi_real_t *ptr = ssi_pcast(ssi_real_t, stream.ptr); for (ssi_size_t i = 0; i < stream.dim * stream.num; i++) { *ptr++ = ssi_cast (ssi_real_t, ssi_random()); } }
bool MyEventListener::update(IEvents &events, ssi_size_t n_new_events, ssi_size_t time_ms) { EventAddress ea; ssi_event_t *e = 0; for (ssi_size_t i = 0; i < n_new_events; i++) { e = events.next(); ea.clear(); ea.setSender(Factory::GetString(e->sender_id)); ea.setEvents(Factory::GetString(e->event_id)); ssi_print("received event %s of type %s at %ums for %ums\n", ea.getAddress(), SSI_ETYPE_NAMES[e->type], e->time, e->dur); if (e->type == SSI_ETYPE_FLOATS) { ssi_real_t *ptr = ssi_pcast(ssi_real_t, e->ptr); ssi_size_t n = e->tot / sizeof(ssi_real_t); for (ssi_size_t j = 0; j < n; j++) { ssi_print("%.2f ", *ptr++); } ssi_print("\n"); } } return true; }
bool QRSDetection::setEventListener (IEventListener *listener) { _listener = listener; _send_etuple = _options.tuple; if(_send_etuple) { ssi_event_init (_r_event, SSI_ETYPE_MAP); ssi_event_adjust (_r_event, 1 * sizeof (ssi_event_map_t)); ssi_event_map_t *ptr = ssi_pcast (ssi_event_map_t, _r_event.ptr); ptr[0].id = Factory::AddString ("delta"); } else { ssi_event_init (_r_event, SSI_ETYPE_TUPLE); ssi_event_adjust (_r_event, 1 * sizeof (ssi_real_t)); } _r_event.sender_id = Factory::AddString (_options.sname); if (_r_event.sender_id == SSI_FACTORY_STRINGS_INVALID_ID) { return false; } _r_event.event_id = Factory::AddString (_options.ename); if (_r_event.event_id == SSI_FACTORY_STRINGS_INVALID_ID) { return false; } _event_address.setSender (_options.sname); _event_address.setEvents (_options.ename); return true; }
void Energy::transform (ITransformer::info info, ssi_stream_t &stream_in, ssi_stream_t &stream_out, ssi_size_t xtra_stream_in_num, ssi_stream_t xtra_stream_in[]) { ssi_size_t sample_dimension = stream_in.dim; ssi_size_t sample_number = stream_in.num; ssi_real_t *srcptr = ssi_pcast (ssi_real_t, stream_in.ptr); ssi_real_t *dstptr = ssi_pcast (ssi_real_t, stream_out.ptr); if (_options.global) { ssi_real_t sum = 0; ssi_size_t elems = sample_number * sample_dimension; ssi_real_t value; for (ssi_size_t i = 0; i < elems; i++) { value = *srcptr++; sum += value * value; } *dstptr = sqrt (sum / elems); } else { ssi_real_t *dstptr_tmp = dstptr; ssi_real_t value; for (ssi_size_t i = 0; i < sample_dimension; i++) { value = *srcptr++; *dstptr++ = value * value; } for (ssi_size_t i = 1; i < sample_number; i++) { dstptr = dstptr_tmp; for (ssi_size_t j = 0; j < sample_dimension; j++) { value = *srcptr++; *dstptr++ += value * value; } } dstptr = dstptr_tmp; for (ssi_size_t i = 0; i < sample_dimension; i++) { value = *dstptr; *dstptr++ = sqrt (value / sample_number); } } }
void SignalTools::Sum (ssi_stream_t &series) { ssi_real_t *old_ptr = ssi_pcast (ssi_real_t, series.ptr); ssi_real_t *new_ptr = new ssi_real_t[series.num]; ssi_real_t *srcptr = old_ptr; ssi_real_t *dstptr = new_ptr; for (ssi_size_t i = 0; i < series.num; i++) { *dstptr = 0; for (ssi_size_t j = 0; j < series.dim; j++) { *dstptr += *srcptr++; } dstptr++; } series.ptr = ssi_pcast (ssi_byte_t, new_ptr); series.dim = 1; delete[] old_ptr; }
void AudioActivity::transform_enter (ssi_stream_t &stream_in, ssi_stream_t &stream_out, ssi_size_t xtra_stream_in_num, ssi_stream_t xtra_stream_in[]) { switch (_options.method) { case AudioActivity::INTENSITY: { AudioIntensity *intensity = ssi_pcast (AudioIntensity, Factory::Create (AudioIntensity::GetCreateName (), 0, false)); intensity->getOptions ()->intensity = true; intensity->getOptions ()->loudness = false; _feature = intensity; break; } case AudioActivity::LOUDNESS: { AudioIntensity *loudness = ssi_pcast (AudioIntensity, Factory::Create (AudioIntensity::GetCreateName (), 0, false)); loudness->getOptions ()->intensity = false; loudness->getOptions ()->loudness = true; _feature = loudness; break; } case AudioActivity::SNRATIO: { SNRatio *snratio = ssi_pcast (SNRatio, Factory::Create (SNRatio::GetCreateName (), 0, false)); snratio->getOptions ()->thresh = 0; _feature = snratio; break; } } ssi_stream_init (_stream_feat, 1, 1, sizeof (ssi_real_t), SSI_REAL, stream_out.sr); _convert_input = stream_in.type == SSI_SHORT; if (_convert_input) { _convert = ssi_pcast (AudioConvert, Factory::Create (AudioConvert::GetCreateName (), 0, false)); ssi_stream_init (_stream_convert, 0, stream_in.dim, sizeof (ssi_real_t), SSI_REAL, stream_in.sr); _convert->transform_enter (stream_in, _stream_convert); _feature->transform_enter (_stream_convert, _stream_feat); } else { _feature->transform_enter (stream_in, _stream_feat); } }
void MFCC::transform (ITransformer::info info, ssi_stream_t &stream_in, ssi_stream_t &stream_out, ssi_size_t xtra_stream_in_num, ssi_stream_t xtra_stream_in[]) { ssi_size_t sample_dimension = stream_in.dim; ssi_size_t sample_number = stream_in.num; ssi_real_t *srcptr = ssi_pcast (ssi_real_t, stream_in.ptr); ssi_real_t *dstptr = ssi_pcast (ssi_real_t, stream_out.ptr); Matrix<ssi_real_t> matrix_in (sample_number, sample_dimension, srcptr); Matrix<ssi_real_t> matrix_out (1, _options.n_last - _options.n_first, dstptr); transform (&matrix_in, &matrix_out); matrix_in.data = 0; matrix_out.data = 0; }
Sensor::Sensor (ISensor *sensor) : _sensor (sensor), _connected (false) { _frame = ssi_pcast (TheFramework, Factory::GetFramework ()); // add consumer to framework if (_frame->IsAutoRun ()) { _frame->AddRunnable (this); } }
void MvgConDiv::transform_enter (ssi_stream_t &stream_in, ssi_stream_t &stream_out, ssi_size_t xtra_stream_in_num, ssi_stream_t xtra_stream_in[]) { MvgAvgVar *mvgs = ssi_pcast (MvgAvgVar, MvgAvgVar::Create (0)); mvgs->getOptions ()->format = MvgAvgVar::AVG; mvgs->getOptions ()->method = _options.method == MOVING ? MvgAvgVar::MOVING : MvgAvgVar::SLIDING; mvgs->getOptions ()->win = _options.wins; _mvgs = mvgs; ssi_stream_init (_mvgs_tmp, 0, _mvgs->getSampleDimensionOut (stream_in.dim), stream_in.byte, stream_in.type, stream_in.sr); _mvgs->transform_enter (stream_in, _mvgs_tmp); MvgAvgVar *mvgl = ssi_pcast (MvgAvgVar, MvgAvgVar::Create (0)); mvgl->getOptions ()->format = MvgAvgVar::AVG; mvgl->getOptions ()->method = _options.method == MOVING ? MvgAvgVar::MOVING : MvgAvgVar::SLIDING; mvgl->getOptions ()->win = _options.winl; _mvgl = mvgl; ssi_stream_init (_mvgl_tmp, 0, _mvgl->getSampleDimensionOut (stream_in.dim), stream_in.byte, stream_in.type, stream_in.sr); _mvgl->transform_enter (stream_in, _mvgl_tmp); }
void Statistics::transform(ITransformer::info info, ssi_stream_t &stream_in, ssi_stream_t &stream_out, ssi_size_t xtra_stream_in_num /*= 0*/, ssi_stream_t xtra_stream_in[] /*= 0*/) { provide_temp_array(stream_in.num_real); calculate(stream_in); ssi_real_t * out_ptr = ssi_pcast(ssi_real_t, stream_out.ptr); for (ssi_size_t i = 0; i < _dim * _options.getSelection().size(); i++) { out_ptr[i] = _res[i]; } }
void Butfilt::transform (ITransformer::info info, ssi_stream_t &stream_in, ssi_stream_t &stream_out, ssi_size_t xtra_stream_in_num, ssi_stream_t xtra_stream_in[]) { if (_first_call) { if (_options.zero) { _first_sample = new ssi_real_t[stream_in.dim]; memcpy (_first_sample, stream_in.ptr, stream_in.dim * stream_in.byte); } _first_call = false; } if (_first_sample) { ssi_real_t *ptr = ssi_pcast (ssi_real_t, stream_in.ptr); ssi_real_t *sub = _first_sample; for (ssi_size_t i = 0; i < info.frame_num; i++) { for (ssi_size_t j = 0; j < stream_in.dim; j++) { *ptr++ -= *sub++; } sub = _first_sample; } } _iir->transform (info, stream_in, stream_out, xtra_stream_in_num, xtra_stream_in); if (_first_sample) { ssi_real_t *ptr = ssi_pcast (ssi_real_t, stream_out.ptr); ssi_real_t *sub = _first_sample; for (ssi_size_t i = 0; i < info.frame_num; i++) { for (ssi_size_t j = 0; j < stream_in.dim; j++) { *ptr++ += *sub++; } sub = _first_sample; } } }
void Butfilt::transform_enter (ssi_stream_t &stream_in, ssi_stream_t &stream_out, ssi_size_t xtra_stream_in_num, ssi_stream_t xtra_stream_in[]) { getCoefs (stream_in.sr); _iir = ssi_pcast (IIR, IIR::Create (0)); _iir->setCoefs (_coefs); _iir->transform_enter (stream_in, stream_out, xtra_stream_in_num, xtra_stream_in); _first_call = true; }
void AudioActivity::transform (ITransformer::info info, ssi_stream_t &stream_in, ssi_stream_t &stream_out, ssi_size_t xtra_stream_in_num, ssi_stream_t xtra_stream_in[]) { ssi_size_t sample_dimension = stream_in.dim; ssi_size_t sample_number = stream_in.num; ssi_real_t threshold = _options.threshold; if (_convert_input) { ssi_stream_adjust (_stream_convert, stream_in.num); _convert->transform (info, stream_in, _stream_convert); _feature->transform (info, _stream_convert, _stream_feat); } else { _feature->transform (info, stream_in, _stream_feat); } ssi_real_t *srcptr = ssi_pcast (ssi_real_t, _stream_feat.ptr); ssi_real_t *dstptr = ssi_pcast (ssi_real_t, stream_out.ptr); *dstptr = *srcptr > _options.threshold ? *srcptr : 0.0f; }
bool ISTrigger::setTriggerStream (ssi_size_t index, ssi_stream_t &trigger, ssi_real_t thres) { if (trigger.type != SSI_REAL) { ssi_wrn ("ISTrigger::setTriggerStream () -> stream.type != SSI_REAL"); return false; } if (trigger.dim != 1) { ssi_wrn ("ISTrigger::setTriggerStream () -> stream.dim != 1"); return false; } _samples.reset (); ssi_sample_t *sample; ssi_size_t count = 0; ssi_real_t *ptr = 0; ssi_real_t sum = 0; ssi_size_t from, to; while (sample = _samples.next ()) { if (sample->streams[index] == 0) { _trigger[index][count] = false; ++count; continue; } from = ssi_cast (ssi_size_t, sample->time * trigger.sr + 0.5); to = from + ssi_cast (ssi_size_t, sample->streams[index]->num / sample->streams[index]->sr * trigger.sr + 0.5) - 1; if (to >= trigger.num) { ssi_wrn ("sample#%u exceeds trigger stream, setting remaining samples to false", count); for (; count < _samples.getSize (); count++) { _trigger[index][count] = false; } break; } sum = 0; ptr = ssi_pcast (ssi_real_t, trigger.ptr) + from; for (ssi_size_t i = from; i <= to; i++) { sum += *ptr++; } _trigger[index][count] = sum / (to - from + 1) > thres; ++count; } return true; }
void MapEventSender::consume (IConsumer::info consume_info, ssi_size_t stream_in_num, ssi_stream_t stream_in[]) { ssi_size_t dim = stream_in[0].dim; ssi_size_t num = stream_in[0].num; _event.time = ssi_cast (ssi_size_t, 1000 * consume_info.time + 0.5); _event.dur = ssi_cast (ssi_size_t, 1000 * consume_info.dur + 0.5); _event.state = consume_info.status == IConsumer::COMPLETED ? SSI_ESTATE_COMPLETED : SSI_ESTATE_CONTINUED; if (_options.mean) { ssi_real_t *src = ssi_pcast(ssi_real_t, stream_in[0].ptr); ssi_event_map_t *dst = ssi_pcast(ssi_event_map_t, _event.ptr); ssi_real_t *mean = new ssi_real_t[dim]; ssi_mean(num, dim, src, mean); for (ssi_size_t i = 0; i < dim; i++) { dst++->value = mean[i]; } if (_listener) { _listener->update(_event); } delete[] mean; } else { ssi_real_t *src = ssi_pcast(ssi_real_t, stream_in[0].ptr); ssi_event_map_t *dst = ssi_pcast(ssi_event_map_t, _event.ptr); for (ssi_size_t i = 0; i < num; i++) { for (ssi_size_t j = 0; j < dim; j++) { dst++->value = *src++; } if (_listener) { _listener->update(_event); } } } }
void MvgConDiv::transform (ITransformer::info info, ssi_stream_t &stream_in, ssi_stream_t &stream_out, ssi_size_t xtra_stream_in_num, ssi_stream_t xtra_stream_in[]) { /* Matlab code: [avg, vrc, hist] = avgfun (signal, sr, [N_short, N_long], hist); macd = avg(:,1:2:dim*2) - avg(:,2:2:dim*2); */ ssi_size_t sample_dimension = stream_in.dim; ssi_size_t sample_number = stream_in.num; ssi_stream_adjust (_mvgs_tmp, sample_number); ssi_stream_adjust (_mvgl_tmp, sample_number); _mvgs->transform (info, stream_in, _mvgs_tmp); _mvgl->transform (info, stream_in, _mvgl_tmp); ssi_real_t *srcptr = ssi_pcast (ssi_real_t, stream_in.ptr); ssi_real_t *dstptr = ssi_pcast (ssi_real_t, stream_out.ptr); ssi_real_t *mvgsptr = ssi_pcast (ssi_real_t, _mvgs_tmp.ptr); ssi_real_t *mvglptr = ssi_pcast (ssi_real_t, _mvgl_tmp.ptr); ssi_real_t short_value, long_value; for (ssi_size_t i = 0; i < sample_number; ++i) { for (ssi_size_t j = 0; j < sample_dimension; ++j) { short_value = *mvgsptr++; long_value = *mvglptr++; *dstptr++ = short_value - long_value; } } }
bool Chain::parseFeature (TiXmlElement *element) { int n_features = 0; element->QueryIntAttribute ("size", &n_features); ssi_msg (SSI_LOG_LEVEL_DETAIL, "found %u feature", n_features); if (n_features > 0) { _n_features = n_features; _features = new IFeature *[_n_features]; for (ssi_size_t i = 0; i < _n_features; i++) { _features[i] = 0; } TiXmlElement *item = 0; for (ssi_size_t i = 0; i < _n_features; i++) { if (i == 0) { item = element->FirstChildElement ("item"); } else { item = item->NextSiblingElement ("item"); } if (!item) { ssi_wrn ("feature: failed parsing '%u'th <item> tag", i); return false; } IObject *object = _xmlpipe->parseObject (item, false); if (!object) { ssi_wrn ("filter: class not found"); return false; } if (object->getType () != SSI_FEATURE) { ssi_wrn ("feature: class is not a feature"); return false; } IFeature *feature = ssi_pcast (IFeature, object); if (!feature) { ssi_wrn ("feature: failed loading feature object"); return false; } ssi_msg (SSI_LOG_LEVEL_DETAIL, "load %u. feature '%s'", i+1, object->getName ()); _features[i] = feature; } } return true; }