MetaData::MetaData (Rcpp::List md)
/*
* Construct meta data from the R list of meta data.
*
* Used for prediction.
*
* Format:
* [[0]] ---- Number of variables
* [[1]] ---- Index of target variable
* [[2]] ---- Target variable name
* [[3]] ---- Variable name vector
* [[4]] ---- Variable type vector
* [[5]] ---- Discrete variable value list
*/
{
nvars_ = Rcpp::as<int>(md[NVARS]);
var_types_ = type_vec(Rcpp::as<vector<int> >(md[VAR_TYPES]));
feature_vars_ = idx_vec(nvars_);
var_names_ = name_vec(nvars_);
Rcpp::CharacterVector varnames((SEXP)(md[VAR_NAMES]));
for (int vindex = 0; vindex < nvars_; vindex++) {
string name = Rcpp::as<string>((SEXPREC*)varnames[vindex]);
var_names_[vindex] = name;
}
Rcpp::List valuenames((SEXP)(md[VAL_NAMES]));
for (int i = 0; i < valuenames.size(); i++) {
Rcpp::List lst(valuenames[i]);
int vindex = Rcpp::as<int>((SEXPREC*)lst[0]);
Rcpp::CharacterVector levels(lst[1]);
int nlevels = levels.size();
name_vec levnames(nlevels);
name_value_map namevals;
for (int lindex = 0; lindex < nlevels; lindex++) {
string name = Rcpp::as<string>((SEXPREC*)levels[lindex]);
namevals.insert(name_value_map::value_type(name, lindex));
levnames[lindex] = name;
}
var_values_[vindex].swap(namevals);
val_names_[vindex].swap(levnames);
}
for (int i = 0; i < nvars_; ++i)
feature_vars_[i] = i;
nlabels_ = val_names_[nvars_].size();
}
MetaData::MetaData (SEXP xSEXP, SEXP ySEXP)
/*
* Obtain meta data directly from data set.
*
* Used for training.
*
* Assume that the target variable is the last variable,
* and no unused variables are in argument <data>
*/
{
Rcpp::DataFrame data(xSEXP);
nvars_ = data.size();
if (nvars_ == 0) throw std::range_error(EMPTY_DATASET_MSG);
feature_vars_ = idx_vec(nvars_);
var_names_ = name_vec(nvars_);
var_types_ = type_vec(nvars_);
Rcpp::CharacterVector vnames(data.names());
for (int vindex = 0; vindex < nvars_; vindex++) {
// Store the names of feature variables.
var_names_[vindex] = Rcpp::as<string>((SEXPREC*)vnames[vindex]);
}
for (int vindex = 0; vindex < nvars_; vindex++) {
if (Rf_isFactor((SEXPREC*)data[vindex])) {
// Store the levels of factor variables.
Rcpp::IntegerVector vals(data[vindex]);
Rcpp::CharacterVector levels(vals.attr("levels"));
int nlevels = levels.size();
name_value_map namevals;
name_vec levnames(nlevels);
for (int lindex = 0; lindex < nlevels; lindex++) {
string name = Rcpp::as<string>((SEXPREC*)levels[lindex]);
namevals.insert(name_value_map::value_type(name, lindex)); // Here, factor values starts from 0.
levnames[lindex] = name;
}
var_values_[vindex].swap(namevals);
val_names_[vindex].swap(levnames);
var_types_[vindex] = DISCRETE;
} else {
var_types_[vindex] = TYPEOF((SEXPREC*)data[vindex]);
}
}
// Store the levels of the target variable.
Rcpp::IntegerVector vals(ySEXP);
Rcpp::CharacterVector levels(vals.attr("levels"));
int nlevels = levels.size();
name_value_map namevals;
name_vec levnames(nlevels);
for (int lindex = 0; lindex < nlevels; lindex++) {
string name = Rcpp::as<string>((SEXPREC*)levels[lindex]);
namevals.insert(name_value_map::value_type(name, lindex));
levnames[lindex] = name;
}
var_values_[nvars_].swap(namevals);
val_names_[nvars_].swap(levnames);
nlabels_ = val_names_[nvars_].size();
// Store the indexes of feature variables.
for (int i = 0; i < nvars_; ++i)
feature_vars_[i] = i;
}
int
osl_parse_shader(char *shadername, ShaderInfo &sh_info)
{
/* Split string around # */
const char *item;
item = strtok(shadername, "#");
/* We are going to look for shader in ../shaders/ */
sh_info.shadername = "../shaders/" + std::string(item);
/* Check for parameters */
while ((item = strtok(NULL, "#")) != NULL) {
/* Setting layer name, in case we're doing a shader group */
if (BU_STR_EQUAL(item, "layername")) {
/* Get the name of the layer being set */
item = strtok(NULL, "#");
if (item == NULL) {
fprintf(stderr, "[Error] Missing layer name\n");
return -1;
}
sh_info.layername = std::string(item);
}
else {
/* Name of the parameter */
std::string param_name = item;
/* Get the type of parameter being set */
item = strtok(NULL, "#");
if (item == NULL) {
fprintf(stderr, "[Error] Missing parameter type\n");
return -1;
}
else if (BU_STR_EQUAL(item, "int")) {
item = strtok(NULL, "#");
if (item == NULL) {
fprintf(stderr, "[Error] Missing float value\n");
return -1;
}
int value = atoi(item);
sh_info.iparam.push_back(std::make_pair(param_name, value));
}
else if (BU_STR_EQUAL(item, "float")) {
item = strtok(NULL, "#");
if (item == NULL) {
fprintf(stderr, "[Error] Missing float value\n");
return -1;
}
float value = atof(item);
sh_info.fparam.push_back(std::make_pair(param_name, value));
}
else if (BU_STR_EQUAL(item, "color")) {
Color3 color_value;
for (int i=0; i<3; i++) {
item = strtok(NULL, "#");
if (item == NULL) {
fprintf(stderr, "[Error] Missing %d-th component of color value\n", i);
return -1;
}
color_value[i] = atof(item);
}
sh_info.cparam.push_back(std::make_pair(param_name, color_value));
}
else if (BU_STR_EQUAL(item, "normal") || BU_STR_EQUAL(item, "point") || BU_STR_EQUAL(item, "vector")) {
TypeDesc type;
std::string type_name(item);
if (BU_STR_EQUAL(item, "normal")) type = TypeDesc::TypeNormal;
else if (BU_STR_EQUAL(item, "point")) type = TypeDesc::TypePoint;
else if (BU_STR_EQUAL(item, "vector")) type = TypeDesc::TypeVector;
Vec3 vec_value;
for (int i=0; i<3; i++) {
item = strtok(NULL, "#");
if (item == NULL) {
fprintf(stderr, "[Error] Missing %d-th component of %s value\n", i, type_name.c_str());
return -1;
}
vec_value[i] = atof(item);
}
ShaderInfo::TypeVec type_vec(type, vec_value);
sh_info.vparam.push_back(std::make_pair(param_name, type_vec));
}
else if (BU_STR_EQUAL(item, "matrix")) {
fprintf(stderr, "matrix\n");
Matrix44 mat_value;
for (int i=0; i<4; i++)
for (int j=0; j<4; j++) {
item = strtok(NULL, "#");
if (item == NULL) {
fprintf(stderr, "[Error] Missing %d-th component of matrix value\n", i*4 + j);
return -1;
}
mat_value[i][j] = atof(item);
fprintf(stderr, "%.2lf ", mat_value[i][j]);
}
fprintf(stderr, "\n");
sh_info.mparam.push_back(std::make_pair(param_name, mat_value));
}
else if (BU_STR_EQUAL(item, "string")) {
item = strtok(NULL, "#");
if (item == NULL) {
fprintf(stderr, "[Error] Missing string\n");
return -1;
}
std::string string_value = item;
sh_info.sparam.push_back(std::make_pair(param_name, string_value));
}
else {
/* FIXME: add support to TypePoint, TypeVector, TypeNormal parameters */
fprintf(stderr, "[Error] Unknown parameter type\n");
return -1;
}
}
}
}
