ssi_size_t FileSamplesOut::getUserId(const ssi_char_t *name) {
ssi_size_t result = SSI_ISAMPLES_GARBAGE_USER_ID;
for (ssi_size_t i = 0; i < _n_users; i++) {
if (ssi_strcmp(name, _users[i])) {
return i;
}
}
return result;
}
ssi_size_t FileSamplesOut::getClassId(const ssi_char_t *name) {
ssi_size_t result = SSI_ISAMPLES_GARBAGE_CLASS_ID;
for (ssi_size_t i = 0; i < _n_classes; i++) {
if (ssi_strcmp(name, _classes[i])) {
return i;
}
}
return result;
}
FileAnnotationWriter::FileAnnotationWriter(const ssi_char_t *filename, const ssi_char_t *label, const ssi_char_t *tier)
: _file(0),
_label(0),
_tier(0),
_meta(0),
_time(0),
_duration(0),
_filename(0) {
if (filename) {
FilePath fp(filename);
if (ssi_strcmp(fp.getExtension(), ".csv")) {
_filename = ssi_strcpy(filename);
}
else {
_filename = ssi_strcat(filename, ".csv");
}
_file = fopen(_filename, "w");
if (_file == 0) {
ssi_err("could not open file %s", _filename);
return;
}
}
else {
_file = stdout;
}
if (label) {
_label = ssi_strcpy(label);
}
if (tier) {
_tier = ssi_strcpy(tier);
}
_meta = new ssi_char_t[2056];
}
bool FFMPEGReader::isStream(const ssi_char_t *url)
{
return ssi_strcmp(url, "udp://", false, 6);
}
bool ISNorm::LoadParams(const ssi_char_t *path, Params ¶ms) {
FilePath fp(path);
ssi_char_t *path_xml;
ssi_char_t *path_data;
if (ssi_strcmp(fp.getExtension(), ".norm", false)) {
path_xml = ssi_strcpy(path);
}
else {
path_xml = ssi_strcat(path, ".norm");
}
path_data = ssi_strcat(path_xml, "~");
TiXmlDocument doc;
if (!doc.LoadFile(path_xml)) {
ssi_wrn("failed loading trainer from file '%s' (r:%d,c:%d)", path_xml, doc.ErrorRow(), doc.ErrorCol());
return false;
}
TiXmlElement *body = doc.FirstChildElement();
if (!body || strcmp(body->Value(), "norm") != 0) {
ssi_wrn("tag <norm> missing");
return false;
}
TiXmlElement *element = 0;
element = body->FirstChildElement("method");
const ssi_char_t *method_s = element->GetText();
bool found = false;
METHOD::List method;
for (ssi_size_t i = 0; i < METHOD::NUM; i++) {
if (ssi_strcmp(method_s, METHOD_NAMES[i], false)) {
method = (METHOD::List) i;
found = true;
}
}
if (!found) {
ssi_wrn("unkown method '%s'", method_s);
return false;
}
ISNorm::ZeroParams(params, method);
element = body->FirstChildElement("dim");
const ssi_char_t *dim_s = element->GetText();
ssi_size_t dim;
if (sscanf(dim_s, "%u", &dim) != 1) {
ssi_wrn("could not parse dimension '%s'", dim_s);
return false;
}
ISNorm::InitParams(params, dim);
if (method == METHOD::SCALE) {
element = body->FirstChildElement("limits");
const ssi_char_t *limits_s = element->GetText();
if (sscanf(limits_s, "%f %f", params.limits, params.limits + 1) != 2) {
ssi_wrn("could not parse limits '%s'", limits_s);
return false;
}
}
element = body->FirstChildElement("type");
const ssi_char_t *type_s = element->GetText();
found = false;
File::TYPE type;
if (ssi_strcmp(type_s, File::TYPE_NAMES[File::ASCII], false)) {
type = File::ASCII;
found = true;
} else if (ssi_strcmp(type_s, File::TYPE_NAMES[File::BINARY], false)) {
type = File::BINARY;
found = true;
}
if (!found) {
ssi_wrn("unkown type '%s'", type_s);
return false;
}
if (method != METHOD::NONE) {
FILE *fp = fopen(path_data, type == File::BINARY ? "rb" : "r");
if (fp) {
switch (params.method) {
case METHOD::NONE:
break;
case METHOD::SCALE:
if (type == File::BINARY) {
fread(params.mins, params.n_features, sizeof(ssi_real_t), fp);
fread(params.maxs, params.n_features, sizeof(ssi_real_t), fp);
} else {
ssi_real_t *mins = params.mins;
ssi_real_t *maxs = params.maxs;
for (ssi_size_t i = 0; i < params.n_features; i++) {
fscanf(fp, "%f %f\n", mins++, maxs++);
}
}
break;
case METHOD::ZSCORE:
if (type == File::BINARY) {
fread(params.mean, params.n_features, sizeof(ssi_real_t), fp);
fread(params.stdv, params.n_features, sizeof(ssi_real_t), fp);
} else {
ssi_real_t *mean = params.mean;
ssi_real_t *stdv = params.stdv;
for (ssi_size_t i = 0; i < params.n_features; i++) {
fscanf(fp, "%f %f\n", mean++, stdv++);
}
}
break;
}
fclose(fp);
}
else {
ssi_wrn("could not open file '%s'", path_data);
return false;
}
}
delete[] path_xml;
delete[] path_data;
return true;
}
bool ISNorm::SaveParams(const ssi_char_t *path, Params ¶ms, File::TYPE type) {
ssi_char_t string[SSI_MAX_CHAR];
FilePath fp(path);
ssi_char_t *path_xml;
ssi_char_t *path_data;
if (ssi_strcmp(fp.getExtension(), "norm", false)) {
path_xml = ssi_strcpy(path);
} else {
path_xml = ssi_strcat(path, ".norm");
}
path_data = ssi_strcat(path_xml, "~");
TiXmlElement norm("norm");
TiXmlElement norm_method("method");
norm_method.InsertEndChild(TiXmlText(METHOD_NAMES[params.method]));
norm.InsertEndChild(norm_method);
if (params.method == METHOD::SCALE) {
TiXmlElement norm_limits("limits");
ssi_sprint(string, "%f %f", params.limits[0], params.limits[1]);
norm_limits.InsertEndChild(TiXmlText(string));
norm.InsertEndChild(norm_limits);
}
TiXmlElement norm_dim("dim");
ssi_sprint(string, "%u", params.n_features);
norm_dim.InsertEndChild(TiXmlText(string));
norm.InsertEndChild(norm_dim);
TiXmlElement norm_type("type");
norm_type.InsertEndChild(TiXmlText(File::TYPE_NAMES[type]));
norm.InsertEndChild(norm_type);
TiXmlDocument doc;
TiXmlDeclaration head("1.0", "", "");
doc.InsertEndChild(head);
doc.InsertEndChild(norm);
doc.SaveFile(path_xml);
if (params.method != METHOD::NONE) {
FILE *fp = fopen(path_data, type == File::BINARY ? "wb" : "w");
if (fp) {
switch (params.method) {
case METHOD::SCALE:
if (type == File::BINARY) {
fwrite(params.mins, params.n_features, sizeof(ssi_real_t), fp);
fwrite(params.maxs, params.n_features, sizeof(ssi_real_t), fp);
} else {
ssi_real_t *mins = params.mins;
ssi_real_t *maxs = params.maxs;
for (ssi_size_t i = 0; i < params.n_features; i++) {
ssi_fprint(fp, "%f %f\n", *mins++, *maxs++);
}
}
break;
case METHOD::ZSCORE:
if (type == File::BINARY) {
fwrite(params.mean, params.n_features, sizeof(ssi_real_t), fp);
fwrite(params.stdv, params.n_features, sizeof(ssi_real_t), fp);
}
else {
ssi_real_t *mean = params.mean;
ssi_real_t *stdv = params.stdv;
for (ssi_size_t i = 0; i < params.n_features; i++) {
ssi_fprint(fp, "%f %f\n", *mean++, *stdv++);
}
}
break;
}
}
else {
ssi_wrn("could not open file '%s'", path_data);
return false;
}
fclose(fp);
}
delete[] path_data;
delete[] path_xml;
return true;
}
