void Calculate()
{
int i;
double kx[4],kv[4];
kx[0] = fx(v)*dt;
kv[0] = fv(x)*dt;
kx[1] = fx(v+kv[0]/2.0)*dt;
kv[1] = fv(x+kx[0]/2.0)*dt;
kx[2] = fx(v+kv[1]/2.0)*dt;
kv[2] = fv(x+kx[1]/2.0)*dt;
kx[3] = fx(v+kv[2])*dt;
kv[3] = fv(x+kx[2])*dt;
t += dt;
x += (kx[0]+2.0*kx[1]+2.0*kx[2]+kx[3])/6.0;
v += (kv[0]+2.0*kv[1]+2.0*kv[2]+kv[3])/6.0;
T = m*pow((l*v),2.0)/2.0;
U = g/l*(1.0-cos(x));
E = T + U;
for(i=0;i<GN-1;i++){
graphT[i] = graphT[i+1];
graphU[i] = graphU[i+1];
}
graphT[GN-1] = T;
graphU[GN-1] = U;
}
// FIXME: why do we get 2 error messages
template <typename ... T> void g(T &... t) { //expected-note3{{declared here}}
f([&a(t)]()->decltype(auto) {
return a;
}() ...);
auto L = [x = f([&a(t)]()->decltype(auto) { return a; }()...)]() { return x; };
const int y = 10;
auto M = [x = y,
&z = y](T& ... t) { };
auto N = [x = y,
&z = y, n = f(t...),
o = f([&a(t)](T& ... t)->decltype(auto) { return a; }(t...)...), t...](T& ... s) {
fv([&a(t)]()->decltype(auto) {
return a;
}() ...);
};
auto N2 = [x = y, //expected-note3{{begins here}}
&z = y, n = f(t...),
o = f([&a(t)](T& ... t)->decltype(auto) { return a; }(t...)...)](T& ... s) {
fv([&a(t)]()->decltype(auto) { //expected-error 3{{captured}}
return a;
}() ...);
};
}
void printDialog::printExpo()
{
QString str = tr("<h2>Expo/Dr Settings</h2>");
for(int i=0; i<4; i++)
{
str.append("<h3>" + getSourceStr(g_eeGeneral->stickMode, i+1) + "</h3>");
//high, mid, low
//left right / expo, dr
str.append(fv(tr("Switch 1:"), getSWName(g_model->expoData[i].drSw1,0)));
str.append(fv(tr("Switch 2:"), getSWName(g_model->expoData[i].drSw2,0)));
str.append("<table border=1 cellspacing=0 cellpadding=3>");
str.append("<tr>");
str.append(doTC(" "));
str.append(doTC(tr("Expo Left"), "", true));
str.append(doTC(tr("D/R Left"), "", true));
str.append(doTC(tr("D/R Right"), "", true));
str.append(doTC(tr("Expo Right"), "", true));
str.append("</tr>");
str.append("<tr>");
str.append(doTC(tr("High"), "", true));
str.append(doTC(QString::number(g_model->expoData[i].expo[DR_HIGH][DR_EXPO][DR_LEFT]),"green"));
str.append(doTC(QString::number(g_model->expoData[i].expo[DR_HIGH][DR_WEIGHT][DR_LEFT]+100),"green"));
str.append(doTC(QString::number(g_model->expoData[i].expo[DR_HIGH][DR_WEIGHT][DR_RIGHT]+100),"green"));
str.append(doTC(QString::number(g_model->expoData[i].expo[DR_HIGH][DR_EXPO][DR_RIGHT]),"green"));
str.append("</tr>");
str.append("<tr>");
str.append(doTC(tr("Mid"), "", true));
str.append(doTC(QString::number(g_model->expoData[i].expo[DR_MID][DR_EXPO][DR_LEFT]),"green"));
str.append(doTC(QString::number(g_model->expoData[i].expo[DR_MID][DR_WEIGHT][DR_LEFT]+100),"green"));
str.append(doTC(QString::number(g_model->expoData[i].expo[DR_MID][DR_WEIGHT][DR_RIGHT]+100),"green"));
str.append(doTC(QString::number(g_model->expoData[i].expo[DR_MID][DR_EXPO][DR_RIGHT]),"green"));
str.append("</tr>");
str.append("<tr>");
str.append(doTC(tr("Low"), "", true));
str.append(doTC(QString::number(g_model->expoData[i].expo[DR_LOW][DR_EXPO][DR_LEFT]),"green"));
str.append(doTC(QString::number(g_model->expoData[i].expo[DR_LOW][DR_WEIGHT][DR_LEFT]+100),"green"));
str.append(doTC(QString::number(g_model->expoData[i].expo[DR_LOW][DR_WEIGHT][DR_RIGHT]+100),"green"));
str.append(doTC(QString::number(g_model->expoData[i].expo[DR_LOW][DR_EXPO][DR_RIGHT]),"green"));
str.append("</tr>");
str.append("</table>");
}
str.append("<br><br>");
te->append(str);
}
static void ShowSplash(fs::path const& ydwe_path)
{
fs::path splashPath = ydwe_path / L"bin" / L"splash.bmp";
if (fs::exists(splashPath))
{
FILE* f = _wfopen(splashPath.c_str(), L"rb");
if (f)
{
try {
ydwe::win::simple_file_version fv((ydwe_path / "YDWE.exe").c_str());
cimg_library::CImg<boost::uint8_t> splashImage = cimg_library::CImg<boost::uint8_t>::get_load_bmp(f);
boost::uint8_t color[] = { 255, 255, 255 };
splashImage.draw_text(10, 10, (boost::format("YDWE %1$d.%2$d.%3$d.%4$d") % fv.major % fv.minor % fv.revision % fv.build).str().c_str(), color, 0, 1, 20);
cimg_library::CImgDisplay display(splashImage, "YDWE", 3, false, true);
display.move(
(cimg_library::CImgDisplay::screen_width() - display.width()) / 2,
(cimg_library::CImgDisplay::screen_height() - display.height()) / 2
).hide_mouse();
display.show();
Sleep(1000);
display.show_mouse();
} catch (...) { }
fclose(f);
}
}
}
bool DllModule::SearchPatch(fs::path& result, std::wstring const& fv_str)
{
try {
fs::directory_iterator end_itr;
for (fs::directory_iterator itr(ydwe_path / L"share" / L"patch"); itr != end_itr; ++itr)
{
try {
if (fs::is_directory(*itr))
{
if (fs::exists(*itr / "Game.dll") && fs::exists(*itr / "Patch.mpq"))
{
base::win::file_version fv((*itr / "Game.dll").c_str());
if (fv_str == fv[L"FileVersion"])
{
result = *itr;
return true;
}
}
}
}
catch(...) {
}
}
}
catch(...) {
}
return false;
}
void EkfSlam::move(Mat R, Mat u, Mat n)
{
Mat Rtemp = fv(R, u, n);
// get jacobians
Mat dfdr = df_dxb(R, u,n);
Mat dfdn = df_dn(R, u,n);
mState.at<double>(0) = Rtemp.at<double>(0);
mState.at<double>(1) = Rtemp.at<double>(1);
mState.at<double>(2) = Rtemp.at<double>(2);
Mat q2 = q.clone();
q2.at<double>(0) *= q2.at<double>(0);
q2.at<double>(1) *= q2.at<double>(1);
Mat N = Mat::diag(q2);
// update covariance matrix
if(Prm.rows) {
Prr = dfdr*Prr*dfdr.t() + dfdn*N*dfdn.t();
Prm = dfdr*Prm;
Pmr = Prm.t();
}
}
// Build rotation matrix angle_in_degrees about x,y,z specified axis e.g. 90 degrees about x axis is BuildRotationMatrix(90, 1,0,0)
Mat44 Mat44::BuildRotationMatrix(f32 angle_in_degrees, f32 x, f32 y, f32 z)
{
float3 fv(x,y,z);
fv.normalize();
x = fv.x();
y = fv.y();
z = fv.z();
f32 angle = DEGTORAD(angle_in_degrees);
f32 c = cos(angle);
f32 s = sin(angle);
return Mat44
(
x*x*(1-c)+c, // m11
x*y*(1-c)-z*s, // m12
x*z*(1-c)+y*s, // m13
0, // m14
y*x*(1-c)+z*s, // m21
y*y*(1-c)+c, // m22
y*z*(1-c)-x*s, // m23
0, // m24
x*z*(1-c)-y*s, // m31
y*z*(1-c)+x*s, // m32
z*z*(1-c)+c, // m33
0, // m34
0, 0, 0, 1 // m41, m42, m43, m44
);
};
std::vector<int32_t> getNNsByVector(std::vector<double> dv, size_t n) {
std::vector<float> fv(dv.size());
std::copy(dv.begin(), dv.end(), fv.begin());
std::vector<int32_t> result;
ptr->get_nns_by_vector(&fv[0], n, -1, &result, NULL);
return result;
}
bool CPWFiltersDlg::VerifyFilters()
{
// Verify that the active filters have a criterion set
if (UpdateData(TRUE) == FALSE)
return false;
// First non-History/non-Policy filters on the main filter dialog
vFilterRows *pvFilterRows(NULL);
switch (m_iType) {
case DFTYPE_MAIN:
pvFilterRows = &m_pfilters->vMfldata;
break;
case DFTYPE_PWHISTORY:
pvFilterRows = &m_pfilters->vHfldata;
break;
case DFTYPE_PWPOLICY:
pvFilterRows = &m_pfilters->vPfldata;
break;
case DFTYPE_ATTACHMENT:
pvFilterRows = &m_pfilters->vAfldata;
break;
default:
VERIFY(0);
}
CGeneralMsgBox gmb;
CString cs_text;
int iHistory(-1), iPolicy(-1), iAttachment(-1);
FilterValidator fv(cs_text, iHistory, iPolicy, iAttachment);
if (find_if(pvFilterRows->begin(), pvFilterRows->end(), fv) !=
pvFilterRows->end()) {
gmb.AfxMessageBox(cs_text);
return false;
}
if (m_iType == DFTYPE_MAIN) {
// Now check that the filters were correct on
// History/Policy/Attachment sub-filter dialogs
if (m_FilterLC.IsPWHIST_Set() && !m_FilterLC.IsHistoryGood()) {
cs_text.Format(IDS_FILTERINCOMPLETE, iHistory + 1);
gmb.AfxMessageBox(cs_text);
return false;
}
if (m_FilterLC.IsPOLICY_Set() && !m_FilterLC.IsPolicyGood()) {
cs_text.Format(IDS_FILTERINCOMPLETE, iPolicy + 1);
gmb.AfxMessageBox(cs_text);
return false;
}
if (m_FilterLC.IsAttachment_Set() && !m_FilterLC.IsAttachmentGood()) {
cs_text.Format(IDS_FILTERINCOMPLETE, iPolicy + 1);
gmb.AfxMessageBox(cs_text);
return false;
}
}
return true;
}
void printDialog::printCurves()
{
QString str = tr("<h2>Curves</h2>");
str.append(fv(tr("5-point Curves"), ""));
str.append("<table border=1 cellspacing=0 cellpadding=3>");
str.append("<tr>");
str.append(doTC(" "));
for(int i=0; i<5; i++) str.append(doTC(tr("pt %1").arg(i+1), "", true));
str.append("</tr>");
for(int i=0; i<MAX_CURVE5; i++)
{
str.append("<tr>");
str.append(doTC(tr("Curve %1").arg(i+1), "", true));
for(int j=0; j<5; j++)
str.append(doTC(QString::number(g_model->curves5[i][j]),"green"));
str.append("</tr>");
}
str.append("</table>");
str.append("<br><br>");
str.append(fv(tr("9-point Curves"), ""));
str.append("<table border=1 cellspacing=0 cellpadding=3>");
str.append("<tr>");
str.append(doTC(" "));
for(int i=0; i<9; i++) str.append(doTC(tr("pt %1").arg(i+1), "", true));
str.append("</tr>");
for(int i=0; i<MAX_CURVE9; i++)
{
str.append("<tr>");
str.append(doTC(tr("Curve %1").arg(i+1), "", true));
for(int j=0; j<9; j++)
str.append(doTC(QString::number(g_model->curves9[i][j]),"green"));
str.append("</tr>");
}
str.append("</table>");
str.append("<br><br>");
te->append(str);
}
void printDialog::printSetup()
{
QString str = tr("<h2>General Model Settings</h2><br>");
str.append(fv(tr("Name"), getModelName()));
str.append(fv(tr("Timer"), getTimer())); //value, mode, count up/down
str.append(fv(tr("Protocol"), getProtocol())); //proto, numch, delay,
str.append(fv(tr("Pulse Polarity"), g_model->pulsePol ? "NEG" : "POS"));
str.append(fv(tr("Throttle Trim"), g_model->thrTrim ? tr("Enabled") : tr("Disabled")));
str.append(fv(tr("Throttle Expo"), g_model->thrExpo ? tr("Enabled") : tr("Disabled")));
str.append(fv(tr("Trim Switch"), getSWName(g_model->trimSw,0)));
str.append(fv(tr("Trim Increment"), getTrimInc()));
str.append(fv(tr("Center Beep"), getCenterBeep())); // specify which channels beep
str.append("<br><br>");
te->append(str);
}
FaceGeometry PrimitiveGeometryBuilder::createFace(std::vector<tgt::vec3>& vertices, tgt::vec4 color) {
FaceGeometry face;
tgt::vec3 faceNormal = tgt::cross(vertices[1] - vertices[0], vertices[2] - vertices[0]);
// Face vertices
// TODO Replace faceNormal with vertex normals for smoother representation
for (size_t i = 0; i < vertices.size(); i++) {
VertexGeometry fv(vertices[i], tgt::vec3(0.f), color, faceNormal);
face.addVertex(fv);
}
return face;
}
void RConstants::setValue(std::string section, std::string name, SEXP value) {
if(TYPEOF(value) != STRSXP) {
Rcpp::NumericVector v(value);
std::ostringstream strs;
for(size_t i=0; i<v.size(); i++) {
if(i>= c->lc->size) {
std::cout << "Too many values. Add more layers \n";
break;
}
if(i>0) strs << " ";
strs << v[i];
}
writeOption(section, name, strs.str());
} else {
Rcpp::CharacterVector v(value);
assert(v.size() > 0);
std::string fv(v[0]);
if(fv.find(' ') != std::string::npos) {
if(v.size() > 1) {
std::cout << "Too messy value\n";
return;
}
std::vector<std::string> x = split(fv, ' ');
std::string acc_str("");
for(size_t i=0; i<x.size(); i++) {
if(i>= c->lc->size) {
std::cout << "Too many values. Add more layers \n";
break;
}
if(i>0) acc_str += " ";
acc_str += x[i];
}
writeOption(section, name, acc_str);
} else {
std::string acc_str("");
for(size_t i=0; i<v.size(); i++) {
if(i>= c->lc->size) {
std::cout << "Too many values. Add more layers \n";
break;
}
if(i>0) acc_str += " ";
acc_str += v[i];
}
writeOption(section, name, acc_str);
}
}
}
bool Dataset::findNext(void) {
bool result;
if (plist.empty()) return false;
std::map<string,field_value>::const_iterator i;
while (!eof()) {
result = true;
for (i=plist.begin();i!=plist.end();++i)
if (fv(i->first.c_str()).get_asString() == i->second.get_asString()) {
continue;
}
else {result = false; break;}
if (result) { return result;}
next();
}
return false;
}
void
DataFieldFileReader::ScanDirectoryTop(const TCHAR* filter)
{
if (!loaded) {
if (!postponed_patterns.full() &&
_tcslen(filter) < PatternList::value_type::MAX_SIZE) {
postponed_patterns.append() = filter;
return;
} else
EnsureLoaded();
}
FileVisitor fv(*this);
VisitDataFiles(filter, fv);
Sort();
}
static void
ImportClicked(gcc_unused WndButton &button)
{
ComboList list;
PolarFileVisitor fv(list);
// Fill list
VisitDataFiles(_T("*.plr"), fv);
list.Sort();
// let the user select
int result = ComboPicker(UIGlobals::GetMainWindow(),
_("Load Polar From File"), list, NULL);
if (result < 0)
return;
assert((unsigned)result < list.size());
PolarInfo polar;
const TCHAR* path = list[result].StringValue;
PolarGlue::LoadFromFile(polar, path);
plane.reference_mass = polar.reference_mass;
plane.dry_mass = polar.reference_mass;
plane.max_ballast = polar.max_ballast;
if (positive(polar.wing_area))
plane.wing_area = polar.wing_area;
if (positive(polar.v_no))
plane.max_speed = polar.v_no;
plane.v1 = polar.v1;
plane.v2 = polar.v2;
plane.v3 = polar.v3;
plane.w1 = polar.w1;
plane.w2 = polar.w2;
plane.w3 = polar.w3;
plane.polar_name = list[result].StringValueFormatted;
Update();
}
void
PolarConfigPanel::LoadFromFile()
{
ComboList list;
PolarFileVisitor fv(list);
// Fill list
VisitDataFiles(_T("*.plr"), fv);
// Sort list
list.Sort();
// Show selection dialog
int result = ComboPicker(UIGlobals::GetMainWindow(),
_("Load Polar From File"), list, NULL);
if (result >= 0) {
const TCHAR* path = list[result].StringValue;
PolarInfo polar;
PolarGlue::LoadFromFile(polar, path);
UpdatePolarPoints(polar.v1, polar.v2, polar.v3, polar.w1, polar.w2, polar.w3);
LoadFormProperty(form, _T("prpPolarReferenceMass"), polar.reference_mass);
LoadFormProperty(form, _T("prpPolarDryMass"), polar.reference_mass);
LoadFormProperty(form, _T("prpPolarMaxBallast"), polar.max_ballast);
if (positive(polar.wing_area))
LoadFormProperty(form, _T("prpPolarWingArea"), polar.wing_area);
if (positive(polar.v_no))
LoadFormProperty(form, _T("prpMaxManoeuveringSpeed"), ugHorizontalSpeed,
polar.v_no);
CommonInterface::SetComputerSettings().plane.polar_name =
list[result].StringValueFormatted;
UpdatePolarTitle();
UpdatePolarInvalidLabel();
}
}
/**
* Evaluates a function and returns the values as a vector
*
*
* @param functionString :: the function string
* @param xVal :: A vector of the x values
* @param noiseScale :: A scaling factor for niose to be added to the data, 0=
*no noise
* @returns the calculated values
*/
std::vector<double>
CreateSampleWorkspace::evalFunction(const std::string &functionString,
const std::vector<double> &xVal,
double noiseScale = 0) {
size_t xSize = xVal.size();
// replace $PCx$ values
std::string parsedFuncString = functionString;
for (int x = 0; x <= 10; ++x) {
// get the rough peak centre value
int index = static_cast<int>((xSize / 10) * x);
if ((x == 10) && (index > 0))
--index;
double replace_val = xVal[index];
std::ostringstream tokenStream;
tokenStream << "$PC" << x << "$";
std::string token = tokenStream.str();
std::string replaceStr = boost::lexical_cast<std::string>(replace_val);
replaceAll(parsedFuncString, token, replaceStr);
}
IFunction_sptr func_sptr =
FunctionFactory::Instance().createInitialized(parsedFuncString);
FunctionDomain1DVector fd(xVal);
FunctionValues fv(fd);
func_sptr->function(fd, fv);
std::vector<double> results;
results.resize(xSize);
for (size_t x = 0; x < xSize; ++x) {
results[x] = fv.getCalculated(x);
if (noiseScale != 0) {
results[x] += ((m_randGen->nextValue() - 0.5) * noiseScale);
}
// no negative values please - it messes up the error calculation
results[x] = fabs(results[x]);
}
return results;
}
void MotionModel::predict_state_and_covariance(VectorXd x_k_k, MatrixXd p_k_k, string type, double std_a,
double std_alpha, VectorXd *X_km1_k, MatrixXd *P_km1_k)
{
size_t x_k_size = x_k_k.size(), p_k_size = p_k_k.rows();
double delta_t = 1, linear_acceleration_noise_covariance, angular_acceleration_noise_covariance;
VectorXd Xv_km1_k(18), Pn_diag(6);
MatrixXd F = MatrixXd::Identity(18,18), // The camera state size is assumed to be 18
Pn, Q, G;
// Camera motion prediction
fv(x_k_k.head(18), delta_t, type, std_a, std_alpha, &Xv_km1_k);
// Feature prediction
(*X_km1_k).resize(x_k_size);
// Add the feature points to the state vector after cam motion prediction
(*X_km1_k) << Xv_km1_k, x_k_k.tail(x_k_size - 18);
// State transition equation derivatives
dfv_by_dxv(x_k_k.head(18), delta_t, type, &F);
// State noise
linear_acceleration_noise_covariance = (std_a * delta_t) * (std_a * delta_t);
angular_acceleration_noise_covariance = (std_alpha * delta_t) * (std_alpha * delta_t);
Pn_diag << linear_acceleration_noise_covariance, linear_acceleration_noise_covariance, linear_acceleration_noise_covariance,
angular_acceleration_noise_covariance, angular_acceleration_noise_covariance, angular_acceleration_noise_covariance;
Pn = Pn_diag.asDiagonal();
func_Q(x_k_k.head(18), Pn, delta_t, type, &G, &Q);
// P_km1_k resize and update
// With the property of symmetry for the covariance matrix, only the Pxx and Pxy
// which means the camera state covariance and camera feature points covariance can be calculated
(*P_km1_k).resize(p_k_size,p_k_size);
(*P_km1_k).block(0,0,18,18) = F * p_k_k.block(0,0,18,18) * F.transpose() + Q;
(*P_km1_k).block(0,18,18,p_k_size - 18) = F * p_k_k.block(0,18,18,p_k_size - 18);
(*P_km1_k).block(18,0,p_k_size - 18,18) = p_k_k.block(18,0,p_k_size - 18,18) * F.transpose();
(*P_km1_k).block(18,18,p_k_size - 18,p_k_size - 18) = p_k_k.block(18,18,p_k_size - 18,p_k_size - 18);
}
inline void
PlanePolarWidget::ImportClicked()
{
ComboList list;
PolarFileVisitor fv(list);
// Fill list
VisitDataFiles(_T("*.plr"), fv);
list.Sort();
// let the user select
int result = ComboPicker(_("Load Polar From File"), list, NULL);
if (result < 0)
return;
assert((unsigned)result < list.size());
PolarInfo polar;
const TCHAR* path = list[result].StringValue;
PolarGlue::LoadFromFile(polar, path);
plane.reference_mass = polar.reference_mass;
plane.dry_mass = polar.reference_mass;
plane.max_ballast = polar.max_ballast;
if (positive(polar.wing_area))
plane.wing_area = polar.wing_area;
if (positive(polar.v_no))
plane.max_speed = polar.v_no;
plane.polar_shape = polar.shape;
plane.polar_name = list[result].StringValueFormatted;
Update();
}
void
moto_setVarVal(MotoEnv *env, MotoVar *var, MotoVal *val) {
moto_castVal(env,var->vs,val);
/* If the MotoVar is a member var then we need to set the var in the MCI
which this var is a member of */
if(var->isMemberVar) {
switch (var->type->kind) {
case INT32_TYPE:
*(int32_t*)var->address = iv(var->vs);
break;
case INT64_TYPE:
*(int64_t*)var->address = lv(var->vs);
break;
case FLOAT_TYPE:
*(float*)var->address = fv(var->vs);
break;
case DOUBLE_TYPE:
*(double*)var->address = dv(var->vs);
break;
case BOOLEAN_TYPE:
*(unsigned char*)var->address = bv(var->vs);
break;
case BYTE_TYPE:
*(signed char*)var->address = yv(var->vs);
break;
case CHAR_TYPE:
*(char*)var->address = cv(var->vs);
break;
case REF_TYPE:
*(void**)var->address = var->vs->refval.value;
break;
default:
break;
}
}
}
static void regfunc(Pu *L)
{
PU_NUMBER fpos = (PU_NUMBER)TOKEN.optype;
NEXT_TOKEN;
if (TOKEN.type == VAR)
{
__pu_value fv(L);
fv.SetType(FUN);
fv.numVal() = fpos;
fv.userdata() = L->cur_nup;
if (L->cur_nup)
{
L->cur_nup->refcount++;
}
__pu_value *got = reg_var(L, TOKEN.value.strVal());
TOKEN.regvar = got;
*got = fv;
L->cur_token = L->funclist[(int)fv.numVal()].end;
NEXT_TOKEN;
return;
}
error(L, 29);
}
void Video::loadVideos() {
const char *path = "/Users/Jobs/Documents/Xcode/HolumV0.1/HolumV0.1/Resource Files";
string videoPath(path);
struct dirent *entry;
DIR *dp;
dp = opendir(path);
if(dp == NULL) {
cout << "Errore 004: Il percorso della directory video non esiste o non è definito.";
return -1;
}
while((entry = readdir(dp))) {
string videoName = string(entry->d_name);
int videoNameLen = strlen(videoName.c_str());
if(checkExtension(videoName, videoNameLen)) {
videoPath += "/" + videoName;
FileVideo fv(videoPath, videoName.substr(0, videoName.find(".")));
videoFiles.push_back(fv);
}
}
closedir(dp);
}
void operator()(Mint& interp, bool is_active, const MintArgList& args) {
if (args.size() > 3) {
bool found;
const MintString& formName = args[1].getValue();
MintString fv(interp.getForm(formName, &found));
if (found) {
MintArgList::const_iterator first = args.begin();
std::advance(first, 2);
#ifdef USE_ARGS_SLIST
MintArgList::const_iterator last = args.begin();
std::advance(last, args.size() - 1);
#else
MintArgList::const_iterator last = args.end();
--last;
#endif
// FIXME: Dodgy magic numbers and hardcoded types
umintchar_t insch = 0x80;
for (MintArgList::const_iterator i = first; i != last; ++i, ++insch) {
const MintString& av = i->getValue();
if (!av.empty()) {
const char* avp = av.c_str();
for (MintString::size_type pos = fv.find(avp, 0);
pos != MintString::npos; pos = fv.find(avp, pos + 1)) {
#ifdef USE_MINTSTRING_ROPE
fv.replace(pos, av.size(), static_cast<char>(insch));
#else
fv.replace(pos, av.size(), 1, static_cast<char>(insch));
#endif
} // for
} // if
} // for
interp.setFormValue(formName, fv);
} // if
} // if
interp.returnNull(is_active);
} // operator()
bool test_lin_indep(Shapeset *shapeset) {
_F_
printf("I. linear independency\n");
UMFPackMatrix mat;
UMFPackVector rhs;
UMFPackLinearSolver solver(&mat, &rhs);
ShapeFunction fu(shapeset), fv(shapeset);
int n =
Hex::NUM_VERTICES * 1 + // 1 vertex fn
Hex::NUM_EDGES * shapeset->get_num_edge_fns(H3D_MAX_ELEMENT_ORDER) +
Hex::NUM_FACES * shapeset->get_num_face_fns(order2_t(H3D_MAX_ELEMENT_ORDER, H3D_MAX_ELEMENT_ORDER)) +
shapeset->get_num_bubble_fns(Ord3(H3D_MAX_ELEMENT_ORDER, H3D_MAX_ELEMENT_ORDER, H3D_MAX_ELEMENT_ORDER));
printf("number of functions = %d\n", n);
int *fn_idx = new int [n];
int m = 0;
// vertex fns
for (int i = 0; i < Hex::NUM_VERTICES; i++, m++)
fn_idx[m] = shapeset->get_vertex_index(i);
// edge fns
for (int i = 0; i < Hex::NUM_EDGES; i++) {
int order = H3D_MAX_ELEMENT_ORDER;
int *edge_idx = shapeset->get_edge_indices(i, 0, order);
for (int j = 0; j < shapeset->get_num_edge_fns(order); j++, m++)
fn_idx[m] = edge_idx[j];
}
// face fns
for (int i = 0; i < Hex::NUM_FACES; i++) {
order2_t order(H3D_MAX_ELEMENT_ORDER, H3D_MAX_ELEMENT_ORDER);
int *face_idx = shapeset->get_face_indices(i, 0, order);
for (int j = 0; j < shapeset->get_num_face_fns(order); j++, m++)
fn_idx[m] = face_idx[j];
}
// bubble
Ord3 order(H3D_MAX_ELEMENT_ORDER, H3D_MAX_ELEMENT_ORDER, H3D_MAX_ELEMENT_ORDER);
int *bubble_idx = shapeset->get_bubble_indices(order);
for (int j = 0; j < shapeset->get_num_bubble_fns(order); j++, m++)
fn_idx[m] = bubble_idx[j];
// precalc structure
mat.prealloc(n);
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
mat.pre_add_ij(i, j);
mat.alloc();
rhs.alloc(n);
printf("assembling matrix ");
for (int i = 0; i < n; i++) {
fu.set_active_shape(fn_idx[i]);
printf(".");
fflush(stdout); // prevent caching of output (to see that it did not freeze)
for (int j = 0; j < n; j++) {
fv.set_active_shape(fn_idx[j]);
double value = l2_product(&fu, &fv);
mat.add(i, j, value);
}
}
printf("\n");
for (int i = 0; i < n; i++)
rhs.add(i, 0.0);
printf("solving matrix\n");
// solve the system
if (solver.solve()) {
double *sln = solver.get_solution();
bool indep = true;
for (int i = 1; i < n + 1; i++) {
if (sln[i] >= EPS) {
indep = false;
break;
}
}
if (indep)
printf("ok\n");
else
printf("Shape functions are not linearly independent\n");
}
else {
printf("Shape functions are not linearly independent\n");
}
delete [] fn_idx;
return true;
}
void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
{
long i;
/* check input args */
if (nrhs < 5)
{
mexErrMsgTxt("Local constant prediction : Time series, dim, delay, length to predict, number of NN must be given, mode (0-3) and metric factor is optional\n");
return;
}
/* handle matrix and parameter I/O */
long mode = 0;
double metric_factor = 1; // can be choosen out of ]0,1], 1 means : use exact euclidian metric
const long N = mxGetM(prhs[0]) * mxGetN(prhs[0]);
double* const ts = (double *)mxGetPr(prhs[0]);
const long dim = (long) *((double *)mxGetPr(prhs[1]));
const long delay = (long) *((double *)mxGetPr(prhs[2]));
const long length = (long) *((double *)mxGetPr(prhs[3]));
const long NNR = (long) *((double *)mxGetPr(prhs[4]));
if (nrhs > 5) mode = (long) *((double *)mxGetPr(prhs[5])); // averaging mode
if (nrhs > 6) metric_factor = (double) *((double *)mxGetPr(prhs[6])); // weighting factor for exponential weighted euclidian metric
if (dim < 1) {
mexErrMsgTxt("Embedding dimension must be greater zero");
return;
}
if (delay < 1) {
mexErrMsgTxt("Time delay must be greater zero");
return;
}
if (length < 1) {
mexErrMsgTxt("Length must be greater zero");
return;
}
if (NNR < 1) {
mexErrMsgTxt("Number of nearest neighbors must be greater zero");
return;
}
if ((metric_factor < 0) || (metric_factor > 1)) {
mexErrMsgTxt("Metric factor must be out of ]0,1]");
return;
}
exp_weighted_euclidian_distance metric(metric_factor);
embedded_time_series_point_set<exp_weighted_euclidian_distance> dummy(N, dim, delay, ts, metric);
if (dummy.size() < 1) {
mexErrMsgTxt("Time series must to short for given parameters");
return;
}
mexPrintf("Length of input time series : %d\n", N);
mexPrintf("Length of prediction : %d\n", length);
mexPrintf("Reconstruction dimension : %d\n", dim);
mexPrintf("Reconstruction delay : %d\n", delay);
mexPrintf("Number of reconstruction points : %d\n", dummy.size());
mexPrintf("Number of nearest neighbors : %d\n", NNR);
mexPrintf("Metric factor : %lf\n", metric_factor);
plhs[0] = mxCreateDoubleMatrix(N + length, 1, mxREAL);
double* const x = (double *) mxGetPr(plhs[0]);
embedded_time_series_point_set<exp_weighted_euclidian_distance> points(N + length, dim, delay, x, metric);
copy(ts, ts + N, x); // copy time series samples to output
ATRIA<embedded_time_series_point_set < exp_weighted_euclidian_distance > > searcher(points, length + 1);
nn_predictor< ATRIA<embedded_time_series_point_set < exp_weighted_euclidian_distance > > > predictor(searcher);
if (predictor.geterr()) {
mexErrMsgTxt("Error preparing predictor : Inconsistent parameters given ?");
return;
}
switch(mode) {
case 1 :
{
mexPrintf("Local constant prediction using direct weighting\n");
biquadratic_weight wg;
direct_prediction<embedded_time_series_point_set < exp_weighted_euclidian_distance > > fv(points);
local_approx< direct_prediction<embedded_time_series_point_set < exp_weighted_euclidian_distance > > , biquadratic_weight> approximator(fv , wg);
for (long t = 0; t < length; t++) {
x[N + t] = predictor.predict(NNR + 1, points.point_begin(t + dummy.size()-1), approximator, - 1, -1);
}
break;
}
case 2 :
{
mexPrintf("Local constant prediction using integrated mean\n");
constant_weight wg;
integrated_prediction<embedded_time_series_point_set < exp_weighted_euclidian_distance > > fv(points);
local_approx< integrated_prediction<embedded_time_series_point_set < exp_weighted_euclidian_distance > > , constant_weight> approximator(fv , wg);
for (long t = 0; t < length; t++) {
x[N + t] = x[N + t - 1] + predictor.predict(NNR, points.point_begin(t + dummy.size()-1), approximator, - 1, -1);
}
break;
}
case 3 :
{
mexPrintf("Local constant prediction using integrated weighting\n");
biquadratic_weight wg;
integrated_prediction<embedded_time_series_point_set < exp_weighted_euclidian_distance > > fv(points);
local_approx< integrated_prediction<embedded_time_series_point_set < exp_weighted_euclidian_distance > > , biquadratic_weight> approximator(fv , wg);
for (long t = 0; t < length; t++) {
x[N + t] = x[N + t - 1] + predictor.predict(NNR + 1, points.point_begin(t + dummy.size()-1), approximator, - 1, -1);
}
break;
}
default :
{
mexPrintf("Local constant prediction using direct mean\n");
constant_weight wg;
direct_prediction<embedded_time_series_point_set < exp_weighted_euclidian_distance > > fv(points);
local_approx< direct_prediction<embedded_time_series_point_set < exp_weighted_euclidian_distance > > , constant_weight> approximator(fv , wg);
for (long t = 0; t < length; t++) {
x[N + t] = predictor.predict(NNR, points.point_begin(t + dummy.size()-1), approximator, - 1, -1);
}
break;
}
}
}
void UltraEyeRenderer::drawHenshinInstruction()
{
XuSkeletonJointInfo jrh, jh, jre;
m_henshinDetector->getUserDetector()->getSkeletonJointInfo(XU_SKEL_RIGHT_HAND, &jrh);
m_henshinDetector->getUserDetector()->getSkeletonJointInfo(XU_SKEL_HEAD, &jh);
m_henshinDetector->getUserDetector()->getSkeletonJointInfo(XU_SKEL_RIGHT_ELBOW, &jre);
if (!isConfident(jrh) || !isConfident(jh) || !isConfident(jre)) return;
const float CIRCLE_RADIUS = 100;
XV3 fv(m_henshinDetector->getUserDetector()->getForwardVector());
XV3 uv(m_henshinDetector->getUserDetector()->getUpVector());
XV3 armDirection((jrh.position - jre.position).normalize());
XV3 adjustedRightHand(jrh.position + armDirection * 30); // slightly move to the fingertip side
XV3 adjustedHead(jh.position + fv * 100); // slightly move forward
XV3 arrowTip(adjustedRightHand.interpolate(adjustedHead, 0.95f));
XV3 arrowBottom(adjustedRightHand.interpolate(adjustedHead, 0.0f));
float len = (arrowTip - arrowBottom).magnitude();
XV3 triangleBottom(arrowBottom.interpolate(arrowTip, 0.8f));
XV3 triangleOpening = (arrowTip - arrowBottom).cross(armDirection).normalize() * len * 0.1f;
XV3 arrowPlaneNorm = (arrowTip - arrowBottom).cross(triangleOpening).normalize();
XV3 triangleEnd1(triangleBottom + triangleOpening);
XV3 triangleEnd2(triangleBottom - triangleOpening);
float maxAlpha = cramp((len - 50.0f) / 150.0f, 0, 1);
float blinkSpeed = 1000.0f / std::max(len - 100.0f, 100.f);
m_phase += m_ticker.tick() * blinkSpeed;
float alpha = square(std::sin(m_phase)) * maxAlpha;
M3DVector4f arrowColor = { 0.7f, 0.0f, 0.0f, alpha };
m_rctx->shaderMan->UseStockShader(GLT_SHADER_FLAT, m_rctx->transform.GetModelViewProjectionMatrix(), arrowColor);
const float THICKNESS = 2;
glDisable(GL_DEPTH_TEST);
glLineWidth(getPointSize() * THICKNESS);
glPointSize(getPointSize() * THICKNESS);
glBegin(GL_LINES);
if (len > CIRCLE_RADIUS) {
glVertex3fv(XV3toM3D(arrowBottom + (arrowTip - arrowBottom).normalize() * CIRCLE_RADIUS));
glVertex3fv(XV3toM3D(arrowTip));
}
glVertex3fv(XV3toM3D(arrowTip));
glVertex3fv(XV3toM3D(triangleEnd1));
glVertex3fv(XV3toM3D(arrowTip));
glVertex3fv(XV3toM3D(triangleEnd2));
glEnd();
glBegin(GL_LINE_LOOP);
XV3 r0((arrowTip - arrowBottom).normalize() * CIRCLE_RADIUS);
GLFrame f;
f.SetForwardVector(0, 0, 1); // invert Z
const int SEGMENTS = 24;
const float STEP_ANGLE = float(M_PI * 2 / SEGMENTS);
for (int i = 0; i < SEGMENTS; i++) {
f.RotateLocal(STEP_ANGLE, arrowPlaneNorm.X, arrowPlaneNorm.Y, arrowPlaneNorm.Z);
M3DVector3f r;
f.TransformPoint(XV3toM3D(r0), r);
glVertex3fv(XV3toM3D(arrowBottom + r));
}
glEnd();
if (m_isNewUser) {
XV3 p(-0.95f, 0.80f, 0.0f), s(0.001f, 0.0015f, 1.0f);
renderStrokeText(m_rctx, "Put your Ultra Eye On! Now!", p, s, 3.0f, arrowColor);
}
glEnable(GL_DEPTH_TEST);
}
void Module::vectorizeFcts()
{
FctVectorizer fv(ctxt_);
}
TEST(pqrs_xml_compiler_filter_vector, filter_vector)
{
pqrs::xml_compiler::symbol_map s;
s.add("ApplicationType", "APP1", 1);
s.add("ApplicationType", "APP2", 2);
s.add("ApplicationType", "APP3", 3);
s.add("DeviceVendor", "VENDOR1", 10);
s.add("DeviceVendor", "VENDOR2", 20);
s.add("DeviceVendor", "VENDOR3", 30);
s.add("DeviceProduct", "PRODUCT1", 100);
s.add("DeviceProduct", "PRODUCT2", 200);
s.add("DeviceProduct", "PRODUCT3", 300);
s.add("ConfigIndex", "config1", 1000);
s.add("ConfigIndex", "config2", 2000);
s.add("ConfigIndex", "config3", 3000);
s.add("ModifierFlag", "MOD1", 0x1000);
s.add("ModifierFlag", "MOD2", 0x2000);
s.add("ModifierFlag", "MOD3", 0x4000);
std::string xml("<?xml version=\"1.0\"?>"
"<item>"
" <only>APP1,APP3</only>"
" <only><!-- empty --></only>"
" <only>,,</only>"
" <not><!-- XXX --->APP2</not>"
" <identifier>sample</identifier>"
" <device_only>DeviceVendor::VENDOR1, DeviceProduct::PRODUCT1, </device_only>"
" <device_not>"
" DeviceVendor::VENDOR3,,,,"
" DeviceProduct::PRODUCT3,"
" </device_not>"
" <config_only>config1,config2</config_only>"
" <config_not>config3</config_not>"
" <modifier_only>ModifierFlag::MOD1 ||| ModifierFlag::MOD3</modifier_only>"
" <modifier_not> ModifierFlag::MOD2 </modifier_not>"
"</item>");
std::stringstream istream(xml, std::stringstream::in);
pqrs::xml_compiler xml_compiler("data/system_xml", "data/private_xml");
int flags = boost::property_tree::xml_parser::no_comments;
boost::property_tree::ptree pt;
boost::property_tree::read_xml(istream, pt, flags);
pqrs::string::replacement replacement;
for (auto& it : pt) {
pqrs::xml_compiler::filter_vector fv(s);
fv.traverse(pqrs::xml_compiler::extracted_ptree(xml_compiler, replacement, it.second, ""));
std::vector<uint32_t> expected;
// <only>APP1,APP3</only>
expected.push_back(3); // count
expected.push_back(BRIDGE_FILTERTYPE_APPLICATION_ONLY);
expected.push_back(1); // APP1
expected.push_back(3); // APP3
// <only><!-- empty --></only>"
// <only>,,</only>"
// ***IGNORED***
// <not>APP2</not>
expected.push_back(2); // count
expected.push_back(BRIDGE_FILTERTYPE_APPLICATION_NOT);
expected.push_back(2); // APP2
// <device_only>DeviceVendor::VENDOR1, DeviceProduct::PRODUCT1, </device_only>
expected.push_back(3); // count
expected.push_back(BRIDGE_FILTERTYPE_DEVICE_ONLY);
expected.push_back(10);
expected.push_back(100);
// <device_not>DeviceVendor::VENDOR3, DeviceProduct::PRODUCT3, </device_not>
expected.push_back(3); // count
expected.push_back(BRIDGE_FILTERTYPE_DEVICE_NOT);
expected.push_back(30);
expected.push_back(300);
// <config_only>config1,config2</config_only>
expected.push_back(3); // count
expected.push_back(BRIDGE_FILTERTYPE_CONFIG_ONLY);
expected.push_back(1000);
expected.push_back(2000);
// <config_not>config3</config_not>
expected.push_back(2); // count
expected.push_back(BRIDGE_FILTERTYPE_CONFIG_NOT);
expected.push_back(3000);
// <modifier_only>ModifierFlag::MOD1 ||| ModifierFlag::MOD3</modifier_only>
expected.push_back(2);
expected.push_back(BRIDGE_FILTERTYPE_MODIFIER_ONLY);
expected.push_back(0x1000 | 0x4000);
// <modifier_not> ModifierFlag::MOD2 </modifier_not>
expected.push_back(2);
expected.push_back(BRIDGE_FILTERTYPE_MODIFIER_NOT);
expected.push_back(0x2000);
EXPECT_EQ(expected, fv.get());
}
}
long double operator()(long double i)
{
return fv(first_, last_, i) - x_;
}
