void GlutDisplaySystem::setup(Setting& setting)
{
String sCfg;
setting.lookupValue("config", sCfg);
int width;
int height;
myFov = 60;
myNearz = 1.0f;
myFarz = 100;
libconfig::ArgumentHelper ah;
ah.newInt("width", "Resolution width", width);
ah.newInt("height", "Resolution width", height);
ah.newNamedInt('f', "fov", "fov", "field of view", myFov);
ah.newNamedDouble('z', "nearz", "nearZ", "near Z clipping plane", myNearz);
ah.newNamedDouble('Z', "farz", "farZ", "far Z clipping plane", myFarz);
ah.process(sCfg.c_str());
myResolution[0] = width;
myResolution[1] = height;
myAspect = (float)width / height;
mySetting = &setting;
}
int ClientExec::addInstance(const Setting &instance)
{
int ret;
ClientInstance *ci = new ClientInstance();
string testbed_ip;
string labelconf;
string cmd_line;
string epoch;
if (instance.lookupValue("testbed_ip", testbed_ip)) {
cout << "This instance will be deployed on " << testbed_ip << endl;
ci->testbed_ip = testbed_ip;
} else {
cerr << "error no testbed_ip - don't know where to deploy this instance" << endl;
return -1;
}
if (instance.lookupValue("labelconf", labelconf)) {
ci->labelconf = labelconf;
} else {
cerr << "labelconf is missing from node and is mandatory for stdout file naming" << endl;
return -1;
}
if (instance.lookupValue("cmd_line", cmd_line)) {
ci->cmd_line = cmd_line;
} else {
cerr << "cmd_line is mandatory, what am i deploying?" << endl;
}
if (instance.lookupValue("epoch", epoch)) {
ci->epoch = atoi(epoch.c_str());
} else {
cerr << "epoch is mandatory " << endl;
}
instances.push_back(ci);
return 0;
}
bool sHotKeyOpts::Read(Setting& cProfile)
{
std::string hk("Start");
if(cProfile.exists(hk)) {
const Setting& s = cProfile[hk];
s.lookupValue("Key", m_RecordStart.m_vKey);
s.lookupValue("Mod", m_RecordStart.m_fsMod);
}
hk = "End";
if(cProfile.exists(hk)) {
const Setting& s = cProfile[hk];
s.lookupValue("Key", m_RecordEnd.m_vKey);
s.lookupValue("Mod", m_RecordEnd.m_fsMod);
}
hk = "Cancel";
if(cProfile.exists(hk)) {
const Setting& s = cProfile[hk];
s.lookupValue("Key", m_RecordCancel.m_vKey);
s.lookupValue("Mod", m_RecordCancel.m_fsMod);
}
hk = "Next";
if(cProfile.exists(hk)) {
const Setting& s = cProfile[hk];
s.lookupValue("Key", m_Next.m_vKey);
s.lookupValue("Mod", m_Next.m_fsMod);
}
hk = "Prev";
if(cProfile.exists(hk)) {
const Setting& s = cProfile[hk];
s.lookupValue("Key", m_Prev.m_vKey);
s.lookupValue("Mod", m_Prev.m_fsMod);
}
hk = "Layout";
if(cProfile.exists(hk)) {
const Setting& s = cProfile[hk];
s.lookupValue("Key", m_ShowLayout.m_vKey);
s.lookupValue("Mod", m_ShowLayout.m_fsMod);
}
hk = "Zoom";
if(cProfile.exists(hk)) {
const Setting& s = cProfile[hk];
s.lookupValue("Key", m_Zoom.m_vKey);
s.lookupValue("Mod", m_Zoom.m_fsMod);
}
bool pass = false;
cProfile.lookupValue("PassThrough", pass);
setPassThrough(pass); // see hook.cpp
return true;
}
void ReadTA(Setting& s, TextAttributes& taResult)
{
s.lookupValue("position", (int&)taResult.position);
s.lookupValue("posType", (int&)taResult.posType);
s.lookupValue("xPosRatio", taResult.xPosRatio);
s.lookupValue("yPosRatio", taResult.yPosRatio);
std::string text;
s.lookupValue("text", text);
taResult.text = text.c_str();
s.lookupValue("backgroundColor", (int&)taResult.backgroundColor);
s.lookupValue("textColor", (int&)taResult.textColor);
s.lookupValue("isFontSelected", taResult.isFontSelected);
if (s.exists("Font"))
ReadFont(s["Font"], taResult.logfont);
}
void ReadIA(Setting& s, ImageAttributes& iaResult)
{
s.lookupValue("Brightness", (int&)iaResult.m_lBrightness);
s.lookupValue("Contrast", (int&)iaResult.m_lContrast);
s.lookupValue("Position", (int&)iaResult.position);
s.lookupValue("PosType", (int&)iaResult.posType);
s.lookupValue("xPosRatio", iaResult.xPosRatio);
s.lookupValue("yPosRatio", iaResult.yPosRatio);
std::string text;
if (s.lookupValue("text", text))
iaResult.text = text.c_str();
}
//------------------------------------------------------------------------------
UniformResize::UniformResize(const Setting &setting, Domain *domain):
Modifier(domain),
relaxInterval( getSetting(setting, {"relaxInterval"}) )
{
const Scaling & scaling = domain->scaling();
startTime = getSetting(setting, {"startTime"});
endTime = checkEndtime( getSetting(setting, {"endTime"}) );
double n = double(endTime - startTime)/relaxInterval;
string axis;
setting.lookupValue("axis", axis);
double sf = 1.0;
//--------------------------------------
// If velocity is used for the scaling:
//--------------------------------------
try
{
const Setting &cfg = domain->getConfigurationSettings();
double dt = getSetting(cfg, {"integrator", "dt"});
double v = setting["v0"];
if(scaling.dimensionlessScaling)
{
dt /= scaling.T;
v /= scaling.V;
}
double L = 1;
const VEC3 & domainLength = domain->getDomainLength();
if(axis == "X")
L = domainLength[X];
else if(axis == "Y")
L = domainLength[Y];
else if(axis == "Z")
L = domainLength[Z];
else
{
std::cerr << "When using a velocity scaling in 'ScaleBoundaries'"
<< " only one axis can be scaled" << std::endl;
exit(EXIT_FAILURE);
}
double L_ = L + v*(endTime - startTime)*dt;
sf = L_/L;
}
catch(const SettingNotFoundException &nfex)
{
//--------------------------------------
// If scaling parameter is used
//--------------------------------------
try
{
sf = setting["scaleFactor"];
}
catch(const SettingNotFoundException &nfex)
{
std::cerr << "In 'ScaleBoundaries' either a 'v0'' or 'scaleFactor'' "
<< "must be supplied in the config file" << std::endl;
exit(EXIT_FAILURE);
}
}
//--------------------------------------
// Finding the scale per iteration
sf = pow(sf, 1.0/n);
scalefactor = {1,1,1};
if(axis == "X"){
scalefactor[0] = sf;
scaleAxis.push_back(X);
}
if(axis == "Y"){
scalefactor[1] = sf;
scaleAxis.push_back(Y);
}
if(axis == "Z"){
scalefactor[2] = sf;
scaleAxis.push_back(Z);
}
if(axis == "XY"){
scalefactor[X] = sf;
scalefactor[Y] = sf;
scaleAxis.push_back(X);
scaleAxis.push_back(Y);
}
if(axis == "YZ"){
scalefactor[Y] = sf;
scalefactor[Z] = sf;
scaleAxis.push_back(Y);
scaleAxis.push_back(Z);
}
if(axis == "XZ"){
scalefactor[X] = sf;
scalefactor[Z] = sf;
scaleAxis.push_back(X);
scaleAxis.push_back(Z);
}
if(axis == "XYZ"){
scalefactor[X] = sf;
scalefactor[Y] = sf;
scalefactor[Z] = sf;
scaleAxis.push_back(X);
scaleAxis.push_back(Y);
scaleAxis.push_back(Z);
}
}
void PluginManager::load_plugin(const Setting& plugin_config) {
string name, library, config_file;
bool enabled = true;
/* Lookup the name and library config items. Both are required. */
if(!plugin_config.lookupValue("name", name)) {
LOG_CRITICAL("Missing required plugin 'name' configuration option.\n");
}
if(!plugin_config.lookupValue("library", library)) {
LOG_CRITICAL("Missing required plugin 'name' configuration option.\n");
}
/* Lookup the optional config and enabled config items. */
plugin_config.lookupValue("config", config_file);
plugin_config.lookupValue("enabled", enabled);
boost::filesystem::path plugin_library_name();
boost::filesystem::path plugin_config_full_path();
boost::filesystem::path plugin_config_name();
/* The path to the library works as follows:
1. If an absolute path, use as is.
2. If a relative path, build as follows:
a. Start with the path to the 'npsgate' executable
b. Append the 'plugindir' path from the main config file
c. Append the 'library' option for this plugin
*/
boost::filesystem::path plugin_library_path(library);
if(plugin_library_path.is_absolute()) {
// use as is, path is absolute
} else {
plugin_library_path = context.npsgate_execute_path;
plugin_library_path /= context.plugin_dir;
plugin_library_path /= library;
}
/* The path to the config file works as follows:
1. If an absolute path, use as is.
2. If a relative path, build as follows:
a. Start with the path to the main config file
b. Append the 'plugin_conf_dir' path from the main config file
c. Append the 'config' option for this plugin
*/
boost::filesystem::path plugin_config_file(config_file);
if(plugin_config_file.is_absolute()) {
// use as is, path is absolute
} else {
plugin_config_file = context.main_config_path;
plugin_config_file /= context.plugin_config_dir;
plugin_config_file /= config_file;
}
library = plugin_library_path.native();
config_file = plugin_config_file.native();
if(enabled) {
PluginCore* p = new PluginCore(context, name);
p->load(library, config_file);
p->init();
plugins[name] = p;
plugin_threads[p->thread_id] = name;
}
LOG_INFO("Plugin Loaded: %s\n", name.c_str());
LOG_INFO(" Library: %s\n", library.c_str());
LOG_INFO(" Config: %s\n", config_file.c_str());
LOG_INFO(" Enabled: %u\n", enabled);
}
void ReadFont(Setting& s, LOGFONT& f)
{
unsigned tmp;
if (s.lookupValue("CharSet", tmp))
f.lfCharSet = tmp;
if (s.lookupValue("ClipPrecision", tmp))
f.lfClipPrecision = tmp;
s.lookupValue("Escapement", (int&)f.lfEscapement);
std::string text;
if (s.lookupValue("FaceName", text))
strncpy(f.lfFaceName, text.c_str(), 32);
s.lookupValue("Height", (int&)f.lfHeight);
if (s.lookupValue("Italic", tmp))
f.lfItalic = tmp;
s.lookupValue("Orientation", (int&)f.lfOrientation);
if (s.lookupValue("OutPrecision", tmp))
f.lfOutPrecision = tmp;
if (s.lookupValue("PitchAndFamily", tmp))
f.lfPitchAndFamily = tmp;
if (s.lookupValue("Quality", tmp))
f.lfQuality = tmp;
if (s.lookupValue("StrikeOut", tmp))
f.lfStrikeOut = tmp;
if (s.lookupValue("Underline", tmp))
f.lfUnderline = tmp;
s.lookupValue("Weight", (int&)f.lfWeight);
s.lookupValue("Width", (int&)f.lfWidth);
}
