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 MyEventSender::consume_enter(ssi_size_t stream_in_num,
ssi_stream_t stream_in[]) {
ssi_event_adjust(_event, stream_in[0].dim * sizeof(ssi_real_t));
ssi_msg(SSI_LOG_LEVEL_BASIC, "enter()..ok");
}
void SocketEventReader::message (const char *from,
const ssi_char_t *id,
osc_int32 time,
osc_int32 dur,
const ssi_char_t *msg) {
if (_elistener) {
_event_string.time = _frame->GetElapsedTimeMs ();
_event_string.dur = dur;
ssi_event_adjust (_event_string, ssi_strlen (msg) + 1);
strcpy (_event_string.ptr, msg);
_elistener->update (_event_string);
}
}
void TupleEventSender::consume_enter (ssi_size_t stream_in_num,
ssi_stream_t stream_in[]) {
if (stream_in[0].type != SSI_REAL) {
ssi_err ("type '%s' not supported", SSI_TYPE_NAMES[stream_in[0].type]);
}
ssi_size_t dim = stream_in[0].dim;
_n_tuple = 0;
if (_options.mean) _n_tuple++;
if (_options.var) _n_tuple++;
if (_options.minval) _n_tuple++;
if (_options.maxval) _n_tuple++;
ssi_event_adjust(_event, _n_tuple * sizeof(ssi_event_tuple_t) * dim);
ssi_event_tuple_t *dst = ssi_pcast(ssi_event_tuple_t, _event.ptr);
if (_options.mean) {
ssi_size_t id = Factory::AddString("mean");
for (ssi_size_t i = 0; i < dim; i++) {
dst++->id = id;
}
}
if (_options.var) {
ssi_size_t id = Factory::AddString("var");
for (ssi_size_t i = 0; i < dim; i++) {
dst++->id = id;
}
}
if (_options.minval) {
ssi_size_t id = Factory::AddString("min");
for (ssi_size_t i = 0; i < dim; i++) {
dst++->id = id;
}
}
if (_options.maxval) {
ssi_size_t id = Factory::AddString("max");
for (ssi_size_t i = 0; i < dim; i++) {
dst++->id = id;
}
}
}
void MapEventSender::consume_enter (ssi_size_t stream_in_num,
ssi_stream_t stream_in[]) {
if (stream_in[0].type != SSI_REAL) {
ssi_err ("type '%s' not supported", SSI_TYPE_NAMES[stream_in[0].type]);
}
ssi_size_t dim = stream_in[0].dim;
ssi_event_adjust(_event, sizeof(ssi_event_map_t) * dim);
ssi_event_map_t *dst = ssi_pcast(ssi_event_map_t, _event.ptr);
ssi_char_t **keys = 0;
if (_options.keys[0] != '\0') {
ssi_size_t n = ssi_split_string_count(_options.keys, ',');
keys = new ssi_char_t *[dim];
ssi_split_string(n, keys, _options.keys, ',');
for (ssi_size_t i = n; i < dim; i++) {
keys[i] = ssi_strcpy(keys[i%n]);
}
}
ssi_char_t str[512];
if (keys) {
for (ssi_size_t i = 0; i < dim; i++) {
dst++->id = Factory::AddString(keys[i]);
}
} else {
for (ssi_size_t i = 0; i < dim; i++) {
ssi_sprint(str, "dim#%u", i);
dst++->id = Factory::AddString(str);
}
}
if (keys) {
for (ssi_size_t i = 0; i < dim; i++) {
delete[] keys[i];
}
delete[] keys; keys = 0;
}
}
void SocketEventReader::run () {
int result = 0;
if (_options.osc) {
result = _socket_osc->recv (this, _options.timeout);
} else {
result = _socket->recv (_buffer, _options.size, _options.timeout);
if (result > 0) {
// send event
if (_elistener) {
_event_string.time = _frame->GetElapsedTimeMs ();
_event_string.dur = 0;
ssi_event_adjust (_event_string, ssi_strlen (_buffer) + 1);
strcpy (_event_string.ptr, _buffer);
_elistener->update (_event_string);
}
}
}
SSI_DBG (SSI_LOG_LEVEL_DEBUG, "received %d bytes", result);
};
bool ClockEventSender::setEventListener (IEventListener *listener) {
if (_options.empty) {
ssi_event_init(_event, SSI_ETYPE_EMPTY);
}
else {
ssi_event_init(_event, SSI_ETYPE_STRING);
ssi_event_adjust(_event, ssi_strlen(_options.string) + 1);
ssi_strcpy(_event.ptr, _options.string);
}
_listener = listener;
if (_options.address[0] != '\0') {
SSI_OPTIONLIST_SET_ADDRESS(_options.address, _event_address, _event);
}
else {
ssi_wrn("use of deprecated option 'sname' and 'ename', use 'address' instead")
_event.sender_id = Factory::AddString(_options.sname);
if (_event.sender_id == SSI_FACTORY_STRINGS_INVALID_ID) {
return false;
}
_event.event_id = Factory::AddString(_options.ename);
if (_event.event_id == SSI_FACTORY_STRINGS_INVALID_ID) {
return false;
}
_event_address.setSender(_options.sname);
_event_address.setEvents(_options.ename);
}
return true;
}
void Tensorflow::EventHandler::handle(ssi_time_t time,
ssi_time_t duration,
ssi_size_t n_classes,
ssi_size_t class_index,
const ssi_real_t *probs,
ssi_char_t *const *class_names,
ssi_size_t n_metas,
ssi_real_t *metas) {
if (_event.tot == 0) {
_class_ids = new ssi_size_t[n_classes];
for (ssi_size_t i = 0; i < n_classes; i++) {
_class_ids[i] = Factory::AddString(class_names[i]);
}
if (_winner_only) {
ssi_event_adjust(_event, sizeof(ssi_event_map_t));
} else if (_select) {
ssi_event_adjust(_event, _n_select * sizeof(ssi_event_map_t));
// check if indices are valid
for (ssi_size_t i = 0; i < _n_select; i++) {
if (_select[i] < 0) {
ssi_wrn_static("index '%d' is negative and will be replaced by 0", _select[i]);
_select[i] = 0;
} else if (_select[i] >= n_classes) {
ssi_wrn_static("index '%d' out of range and will be replaced by 0", _select[i]);
_select[i] = 0;
}
}
} else {
ssi_event_adjust(_event, n_classes * sizeof(ssi_event_map_t));
}
}
ssi_event_map_t *ptr = ssi_pcast(ssi_event_map_t, _event.ptr);
if (_winner_only) {
ssi_real_t max_val = probs[0];
ssi_size_t max_ind = 0;
for (ssi_size_t i = 1; i < n_classes; i++) {
if (probs[i] > max_val) {
max_val = probs[i];
max_ind = i;
}
}
ptr[0].id = _class_ids[max_ind];
ptr[0].value = probs[max_ind];
} else if (_select) {
for (ssi_size_t i = 0; i < _n_select; i++) {
ptr[i].value = probs[_select[i]];
ptr[i].id = _class_ids[_select[i]];
}
} else {
for (ssi_size_t i = 0; i < n_classes; i++) {
ptr[i].value = probs[i];
ptr[i].id = _class_ids[i];
}
}
_event.time = ssi_cast(ssi_size_t, time * 1000 + 0.5);
_event.dur = ssi_cast(ssi_size_t, duration * 1000 + 0.5);
_listener->update(_event);
};
