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::Transform_Xtra (ssi_stream_t &from, ssi_stream_t &to, ITransformer &transformer, ssi_size_t frame_size, ssi_size_t delta_size, bool call_enter, bool call_flush, ssi_size_t xtra_stream_in_num, ssi_stream_t xtra_stream_in[]){ if (frame_size <= 0) { ssi_time_t sample_rate_in = from.sr; ssi_size_t sample_number_in = from.num; ssi_size_t sample_dimension_in = from.dim; ssi_size_t sample_bytes_in = from.byte; ssi_type_t sample_type_in = from.type; ssi_size_t sample_number_out = sample_number_in == 0 ? 0 : transformer.getSampleNumberOut (sample_number_in); ssi_size_t sample_dimension_out = transformer.getSampleDimensionOut (sample_dimension_in); ssi_size_t sample_bytes_out = transformer.getSampleBytesOut (sample_bytes_in); ssi_type_t sample_type_out = transformer.getSampleTypeOut (sample_type_in); ssi_time_t sample_rate_out = sample_number_in == 0 ? 0 : (ssi_cast (ssi_time_t, sample_number_out) / ssi_cast (ssi_time_t, sample_number_in)) * sample_rate_in; ssi_stream_init (to, 0, sample_dimension_out, sample_bytes_out, sample_type_out, sample_rate_out); if (sample_number_out > 0) { ssi_stream_adjust (to, sample_number_out); if (call_enter) { transformer.transform_enter (from, to, xtra_stream_in_num, xtra_stream_in); } ITransformer::info tinfo; tinfo.delta_num = 0; tinfo.frame_num = from.num; tinfo.time = 0; transformer.transform (tinfo, from, to, xtra_stream_in_num, xtra_stream_in); if (call_flush) { transformer.transform_flush (from, to, xtra_stream_in_num, xtra_stream_in); } } } else { ssi_time_t sample_rate_in = from.sr; ssi_size_t n_froms = n_froms = 1 + xtra_stream_in_num;; ssi_real_t *from_nums = new ssi_real_t[n_froms]; ssi_size_t *from_tots = new ssi_size_t[n_froms]; ssi_size_t from_num_min = 0; from_nums[0] = (ssi_real_t)from.num; from_tots[0] = from.tot; for(ssi_size_t i = 1; i < n_froms; i++){ from_nums[i] = (ssi_real_t)xtra_stream_in[i-1].num; from_tots[i] = xtra_stream_in[i-1].tot; } if(n_froms > 1){ ssi_real_t maxval = 0; ssi_real_t minval = 0; ssi_size_t maxpos = 0; ssi_size_t minpos = 0; ssi_minmax(n_froms, 1, from_nums, &minval, &minpos, &maxval, &maxpos); from_num_min = (ssi_size_t)minval; } else { from_num_min = (ssi_size_t)from_nums[0]; } SSI_ASSERT (from_num_min > frame_size + delta_size); ssi_size_t max_shift = (from_num_min - delta_size) / frame_size; ssi_size_t sample_number_out = transformer.getSampleNumberOut (frame_size); ssi_size_t sample_dimension_in = from.dim; ssi_size_t sample_dimension_out = transformer.getSampleDimensionOut (sample_dimension_in); ssi_size_t sample_byte_in = from.byte; ssi_size_t sample_bytes_out = transformer.getSampleBytesOut (sample_byte_in); ssi_type_t sample_type_in = from.type; ssi_type_t sample_type_out = transformer.getSampleTypeOut (sample_type_in); ssi_time_t sample_rate_out = (ssi_cast (ssi_time_t, sample_number_out) / ssi_cast (ssi_time_t, frame_size)) * sample_rate_in; ssi_size_t to_num = max_shift * sample_number_out; ssi_stream_init (to, 0, sample_dimension_out, sample_bytes_out, sample_type_out, sample_rate_out); ssi_stream_adjust (to, to_num); ssi_size_t to_tot = to.tot; ssi_byte_t **from_ptrs = new ssi_byte_t*[n_froms]; from_ptrs[0] = from.ptr; for(ssi_size_t i = 1; i < n_froms; i++){ from_ptrs[i] = xtra_stream_in[i-1].ptr; } ssi_byte_t *to_ptr = to.ptr; ssi_size_t byte_shift_out = sample_bytes_out * sample_dimension_out * sample_number_out; to.tot = byte_shift_out; to.num = sample_number_out;//! ssi_size_t sample_number_in = frame_size + delta_size; from.num = sample_number_in; ssi_size_t byte_shift_in = sample_byte_in * sample_dimension_in * frame_size; from.tot = byte_shift_in; ssi_time_t from_secs = 0; ssi_time_t to_secs = 0; if (call_enter) { for(ssi_size_t k = 1; k < n_froms; k++){ xtra_stream_in[k-1].ptr = 0; xtra_stream_in[k-1].num = 0; xtra_stream_in[k-1].tot = 0; } transformer.transform_enter (from, to, xtra_stream_in_num, xtra_stream_in); } for (ssi_size_t i = 0; i < max_shift; i++) { ITransformer::info tinfo; tinfo.delta_num = delta_size; tinfo.frame_num = frame_size; tinfo.time = 0; from_secs = (i * frame_size) / from.sr; to_secs = from_secs + (frame_size + delta_size)/from.sr; ssi_size_t from_num, n_num; for(ssi_size_t k = 1; k < n_froms; k++){ from_num = (ssi_size_t)(from_secs * xtra_stream_in[k-1].sr + 0.5); n_num = (ssi_size_t)((to_secs - from_secs) * xtra_stream_in[k-1].sr + 0.5); xtra_stream_in[k-1].ptr = from_ptrs[k] + from_num * xtra_stream_in[k-1].dim * xtra_stream_in[k-1].byte; xtra_stream_in[k-1].num = n_num; xtra_stream_in[k-1].tot = n_num * xtra_stream_in[k-1].dim * xtra_stream_in[k-1].byte; SSI_ASSERT( (from_num + n_num) <= xtra_stream_in[k-1].num_real); } transformer.transform (tinfo, from, to, xtra_stream_in_num, xtra_stream_in); tinfo.time += frame_size / sample_rate_in; from.ptr += byte_shift_in; to.ptr += byte_shift_out; } if (call_flush) { from_secs = (0 * frame_size) / from.sr; to_secs = from_secs + (frame_size + delta_size)/from.sr; for(ssi_size_t k = 1; k < n_froms; k++){ xtra_stream_in[k-1].ptr = 0; xtra_stream_in[k-1].num = 0; xtra_stream_in[k-1].tot = 0; } transformer.transform_flush (from, to, xtra_stream_in_num, xtra_stream_in); } from.ptr = from_ptrs[0]; from.num = (ssi_size_t)from_nums[0]; from.tot = from_tots[0]; for(ssi_size_t i = 1; i < n_froms; i++){ xtra_stream_in[i-1].ptr = from_ptrs[i]; xtra_stream_in[i-1].num = (ssi_size_t)from_nums[i]; xtra_stream_in[i-1].tot = from_tots[i]; } to.ptr = to_ptr; to.num = to_num; to.tot = to_tot; delete [] from_nums; from_nums = 0; delete [] from_tots; from_tots = 0; delete [] from_ptrs; from_ptrs = 0; } }
void PaintData::paint(ICanvas *canvas, ssi_handle_t context, ssi_rect_t area) { Lock lock(_mutex); if (_stream.num == 0) { return; } _painter->begin(context, area); if (_stream_has_changed) { if (_stream.dim != _dim) { ssi_stream_destroy(_resample); ssi_stream_init(_resample, 0, _stream.dim, _stream.byte, _stream.type, _stream.sr, _stream.time); _dim = _stream.dim; delete[] _mins; delete[] _maxs; _mins = new ssi_real_t[_dim]; _maxs = new ssi_real_t[_dim]; } switch (_type) { case TYPE::SIGNAL: case TYPE::AUDIO: case TYPE::IMAGE: { ssi_stream_adjust(_resample, ssi_cast(ssi_size_t, area.width)); ssi_resample(_stream.num, _resample.num, _stream.dim, ssi_pcast(ssi_real_t, _stream.ptr), ssi_pcast(ssi_real_t, _resample.ptr), _type == TYPE::AUDIO ? ssi_max : ssi_mean); break; } case TYPE::PATH: case TYPE::SCATTER: { ssi_stream_adjust(_resample, _stream.num); memcpy(_resample.ptr, _stream.ptr, _stream.tot); break; } } if (!_fix_limits) { if (_reset_limits) { ssi_minmax(_resample.num, _resample.dim, ssi_pcast(ssi_real_t, _resample.ptr), _mins, _maxs); _reset_limits = false; } else { ssi_real_t *mins = new ssi_real_t[_dim]; ssi_real_t *maxs = new ssi_real_t[_dim]; ssi_minmax(_resample.num, _resample.dim, ssi_pcast(ssi_real_t, _resample.ptr), mins, maxs); for (ssi_size_t i = 0; i < _dim; i++) { _mins[i] = min(_mins[i], mins[i]); _maxs[i] = max(_maxs[i], maxs[i]); } delete[] mins; delete[] maxs; } if (_type == TYPE::AUDIO) { for (ssi_size_t i = 0; i < _dim; i++) { _maxs[i] = abs(_maxs[i]); _mins[i] = -_maxs[i]; } } } else { for (ssi_size_t i = 0; i < _dim; i++) { _mins[i] = _fix_min; _maxs[i] = _fix_max; } } ssi_norm(_resample.num, _resample.dim, ssi_pcast(ssi_real_t, _resample.ptr), _mins, _maxs); _stream_has_changed = false; } if (_back_toggle) { _painter->fill(*_back_brush, area); } switch (_type) { case TYPE::SIGNAL: GraphicTools::PaintAsSignal(_resample, *_painter, *_pen); break; case TYPE::AUDIO: GraphicTools::PaintAsAudio(_resample, *_painter, *_pen); break; case TYPE::PATH: GraphicTools::PaintAsPath(_resample, _indx, _indy, *_painter, *_pen); break; case TYPE::SCATTER: GraphicTools::PaintAsScatter(_resample, _indx, _indy, *_painter, *_pen, *_brush, _point_size); break; case TYPE::IMAGE: GraphicTools::PaintAsImage(_resample, *_painter, *_colormap); break; } switch (_type) { case TYPE::SIGNAL: case TYPE::AUDIO: GraphicTools::PaintAxis(_stream.dim, _stream.time, _stream.time + (_stream.sr > 0 ? _stream.num / _stream.sr : 0), _mins, _maxs, *_painter, *_font, *_font_pen, *_font_brush, _precision); break; case TYPE::PATH: case TYPE::SCATTER: case TYPE::IMAGE: ssi_real_t minval, maxval, tmp; ssi_minmax(_dim, 1, _mins, &minval, &tmp); ssi_minmax(_dim, 1, _maxs, &tmp, &maxval); GraphicTools::PaintAxis(1, _stream.time, _stream.time + (_stream.sr > 0 ? _stream.num / _stream.sr : 0), &minval, &maxval, *_painter, *_font, *_font_pen, *_font_brush, _precision); break; } _painter->end(); }
bool ISNorm::setNorm (ssi_size_t index, Params ¶ms) { if (index >= _n_streams) { ssi_wrn("index exceeds #streams (%u != %u)", index, _n_streams); return false; } if (params.inialized && params.n_features != _n_features[index]) { ssi_wrn("precomputed parameters are bad #features (%u != %u)", params.n_features, _n_features[index]); return false; } _params[index] = ¶ms; if (!params.inialized) { InitParams(params, _n_features[index]); if (params.method != METHOD::NONE) { ssi_real_t **matrix; ssi_size_t *classes; ModelTools::CreateSampleMatrix(_samples, index, _n_samples, params.n_features, &classes, &matrix); switch (params.method) { case METHOD::SCALE: { ssi_minmax(_n_samples, params.n_features, matrix[0], params.mins, params.maxs); ssi_real_t *aptr = params.mins; ssi_real_t *bptr = params.maxs; for (ssi_size_t j = 0; j < params.n_features; j++) { *bptr -= *aptr++; if (*bptr == 0.0f) { ssi_wrn("zero interval '%u'", j); *bptr = 1.0f; } bptr++; } break; } case METHOD::ZSCORE: { ssi_mean(_n_samples, params.n_features, matrix[0], params.mean); ssi_stdv(_n_samples, params.n_features, matrix[0], params.stdv); ssi_real_t *bptr = params.stdv; for (ssi_size_t j = 0; j < params.n_features; j++) { *bptr = sqrt(*bptr); if (*bptr == 0.0f) { ssi_wrn("zero stdv '%u'", j); *bptr = 1.0f; } bptr++; } break; } } ModelTools::ReleaseSampleMatrix(_n_samples, classes, matrix); } params.inialized = true; } return true; }