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;
}
