TEST_F(ClinicalTests, NeuroVesselsUSA) {
std::string name = "Neuro-Vessels-USA";
setParameter(parameters, "parameters", name);
if(!dataExists(name)) {
SUCCEED();
return;
}
loadParameterPreset(parameters, PARAMETERS_DIR);
try {
result = runClinicalData(parameters, name);
} catch(SIPL::SIPLException e) {
// Out of memory on GPU
// Try to run cropped version instead
std::cout << "Exception occurred. Trying cropped volume instead." << std::endl;
setParameter(parameters, "cropping", "no");
result = runClinicalData(parameters, name+"-cropped");
}
EXPECT_GT(1.5, result.averageDistanceFromCenterline);
EXPECT_LT(75.0, result.percentageExtractedCenterlines);
EXPECT_LT(0.7, result.precision);
EXPECT_LT(0.7, result.recall);
EXPECT_GT(200, result.incorrectCenterpoints);
}
void MidiOutFilter::setCurrentProgram (int index)
{
if (!init) {
programs[curProgram].icon = icon;
}
init=false;
JuceProgram* ap = &programs[index];
curProgram = index;
setActiveDevice(ap->device);
for (int i=0;i<getNumParameters();i++) {
setParameter(i, ap->param[i]);
}
icon = ap->icon;
}
bool THDM::Update(const std::map<std::string, double>& DPars) {
if(!PreUpdate()) return (false);
UpdateError = false;
for (std::map<std::string, double>::const_iterator it = DPars.begin(); it != DPars.end(); it++)
setParameter(it->first, it->second);
if (UpdateError) return (false);
if(!PostUpdate()) return (false);
return (true);
}
bool UffBondStrechCalculation::setup()
{
const UffAtomParameters *pa = parameters(atom(0));
const UffAtomParameters *pb = parameters(atom(1));
if(!pa || !pb){
return false;
}
// n = bondorder (1.5 for aromatic, 1.366 for amide)
chemkit::Real bondorder = bondOrder(atom(0), atom(1));
chemkit::Real r0 = bondLength(pa, pb, bondorder);
// parameter(1) = k_ij = 664.12 * (Z*_i * Z*_j) / r_ij^3
chemkit::Real za = pa->Z;
chemkit::Real zb = pb->Z;
chemkit::Real kb = 664.12 * (za * zb) / pow(r0, 3);
setParameter(0, kb);
setParameter(1, r0);
return true;
}
bool MmffOutOfPlaneBendingCalculation::setup(const MmffParameters *parameters)
{
const MmffAtom *a = atom(0);
const MmffAtom *b = atom(1);
const MmffAtom *c = atom(2);
const MmffAtom *d = atom(3);
const MmffOutOfPlaneBendingParameters *outOfPlaneBendingParameters = parameters->outOfPlaneBendingParameters(a, b, c, d);
if(!outOfPlaneBendingParameters){
return false;
}
setParameter(0, outOfPlaneBendingParameters->koop);
return true;
}
/*update*/
void SphereShape::update()
{
OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_mutex);
if(!_dirty)
return;
float radius = _radius;
osg::Vec3 center = _center;
osg::Vec4 color = _color;
std::string vert = _vertex_shader;
std::string frag = _fragment_shader;
setParameter("radius", radius);
setParameter("x", center.x());
setParameter("y", center.y());
setParameter("z", center.z());
setParameter("r1", color[0]);
setParameter("g1", color[1]);
setParameter("b1", color[2]);
setParameter("a1", color[3]);
setParameter("vertex", vert);
setParameter("fragment", frag);
setPosition(center, radius);
setShapeColor(color);
setShaders(vert, frag);
dirtyBound();
//reset flag
_dirty = false;
}
QFFitAlgorithmLMFit::QFFitAlgorithmLMFit() {
// set default parameter values
lm_control_struct control = lm_control_double;
setParameter("ftol", control.ftol);
setParameter("xtol", control.xtol);
setParameter("gtol", control.gtol);
setParameter("epsilon", control.epsilon);
setParameter("stepbound", control.stepbound);
setParameter("max_iterations", control.patience);
}
void Settings::loadSettings(const QString & fileName, QByteArray * windowGeometry, QByteArray * windowState)
{
QString path = fileName;
if(fileName.isEmpty())
{
path = iniDefaultPath();
}
QSettings ini(path, QSettings::IniFormat);
for(ParametersMap::const_iterator iter = defaultParameters_.begin(); iter!=defaultParameters_.end(); ++iter)
{
const QString & key = iter.key();
QVariant value = ini.value(key, QVariant());
if(value.isValid())
{
QString str = value.toString();
if(str.contains(";") && str.size() != getParameter(key).toString().size())
{
// If a string list is modified, update the value
// (assuming that index < 10... one character for index)
QChar index = str.at(0);
str = getParameter(key).toString();
str[0] = index.toAscii();
value = QVariant(str);
printf("Updated list of parameter \"%s\"\n", key.toStdString().c_str());
}
setParameter(key, value);
}
}
if(windowGeometry)
{
QVariant value = ini.value("windowGeometry", QVariant());
if(value.isValid())
{
*windowGeometry = value.toByteArray();
}
}
if(windowState)
{
QVariant value = ini.value("windowState", QVariant());
if(value.isValid())
{
*windowState = value.toByteArray();
}
}
printf("Settings loaded from %s\n", path.toStdString().c_str());
}
mdaOverdrive::mdaOverdrive(audioMasterCallback audioMaster) : AudioEffectX(audioMaster, 1, 3) // 1 program, 3 parameters
{
fParam1 = 0.0f;
fParam2 = 0.0f;
fParam3 = 0.5f;
setNumInputs(2);
setNumOutputs(2);
setUniqueID('mdaO'); // identify
DECLARE_VST_DEPRECATED(canMono) ();
canProcessReplacing();
strcpy(programName, "Soft Overdrive");
filt1 = filt2 = 0.0f;
setParameter(0, 0.0f);
}
TEST_F(ClinicalTests, PhantomAccUS) {
std::string name = "Phantom-Acc-US";
setParameter(parameters, "parameters", name);
if(!dataExists(name)) {
SUCCEED();
return;
}
loadParameterPreset(parameters, PARAMETERS_DIR);
result = runClinicalData(parameters, name);
EXPECT_GT(1.5, result.averageDistanceFromCenterline);
EXPECT_LT(75.0, result.percentageExtractedCenterlines);
EXPECT_LT(0.7, result.precision);
EXPECT_LT(0.7, result.recall);
EXPECT_GT(200, result.incorrectCenterpoints);
}
void AP_UnixDialog_Field::event_Insert(void)
{
UT_ASSERT(m_windowMain && m_listTypes && m_listFields);
// find item selected in the Types list box, save it to m_iTypeIndex
GtkTreeSelection * selection;
GtkTreeIter iter;
GtkTreeModel * model;
selection = gtk_tree_view_get_selection( GTK_TREE_VIEW(m_listTypes) );
// if there is no selection, or the selection's data (GtkListItem widget)
// is empty, return cancel. GTK can make this happen.
if ( !selection ||
!gtk_tree_selection_get_selected (selection, &model, &iter)
)
{
m_answer = AP_Dialog_Field::a_CANCEL;
return;
}
// get the ID of the selected Type
gtk_tree_model_get (model, &iter, 1, &m_iTypeIndex, -1);
// find item selected in the Field list box, save it to m_iFormatIndex
selection = gtk_tree_view_get_selection( GTK_TREE_VIEW(m_listFields) );
// if there is no selection, or the selection's data (GtkListItem widget)
// is empty, return cancel. GTK can make this happen.
if ( !selection ||
!gtk_tree_selection_get_selected (selection, &model, &iter)
)
{
m_answer = AP_Dialog_Field::a_CANCEL;
return;
}
// get the ID of the selected Type
gtk_tree_model_get (model, &iter, 1, &m_iFormatIndex, -1);
setParameter(gtk_entry_get_text(GTK_ENTRY(m_entryParam)));
m_answer = AP_Dialog_Field::a_OK;
}
//------------------------------------------------------------------------
void Midi16CCRouter::setProgram (VstInt32 program) {
Midi16CCRouterProgram* ap = &programs[program];
curProgram = program;
if (automated) {
for (int i=0;i<kNumParams;i++) {
setParameterAutomated (i, ap->param[i]);
}
updateDisplay();
automated=false;
}
else {
for (int i=0;i<kNumParams;i++) {
setParameter (i, ap->param[i]);
}
}
}
void TestTubeSegmentationFramework::testParameters()
{
std::string path = getParametersDir().toStdString();
{
INFO("Could not find parameter file: "+path);
REQUIRE(QFile::exists(qstring_cast(path)));
}
{
INFO("Inititalizing parameters with default values failed.");
REQUIRE_NOTHROW(initParameters(path));
}
paramList defaultParameters = initParameters(path);
{
INFO("No default string parameters found.");
REQUIRE(!defaultParameters.strings.empty());
}
{
INFO("No default bool parameters found.");
REQUIRE(!defaultParameters.bools.empty());
}
{
INFO("No default numeric parameters found.");
REQUIRE(!defaultParameters.numerics.empty());
}
{
INFO("Gpu not validated as device.");
REQUIRE(defaultParameters.strings["device"].validate("gpu"));
}
{
INFO("250 not a valid gvf-iterations value.");
REQUIRE(defaultParameters.numerics["gvf-iterations"].validate(250));
}
{
INFO("Set parameter parameter to Lung-Airways-CT failed.");
REQUIRE_NOTHROW(setParameter(defaultParameters, "parameters", "Lung-Airways-CT"));
}
{
INFO("Load presets failed.");
REQUIRE_NOTHROW(loadParameterPreset(defaultParameters, path));
}
}
/**
* Sets a new value to a parameter by name.
* @param name :: The name of the parameter.
* @param value :: The new value
* @param explicitlySet :: A boolean flagging the parameter as explicitly set
* (by user)
*/
void ParamFunction::setParameter(const std::string &name, const double &value,
bool explicitlySet) {
auto it = std::find(m_parameterNames.cbegin(), m_parameterNames.cend(), name);
if (it == m_parameterNames.cend()) {
std::ostringstream msg;
msg << "ParamFunction tries to set value to non-exist parameter (" << name
<< ") "
<< "of function " << this->name();
msg << "\nAllowed parameters: ";
for (const auto ¶meterName : m_parameterNames) {
msg << parameterName << ", ";
}
throw std::invalid_argument(msg.str());
}
setParameter(static_cast<int>(it - m_parameterNames.begin()), value,
explicitlySet);
}
void TextShape::update(std::string command)
{
OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_mutex);
_dirty = true;
// check for changed values
// TODO deal with triples for values e.g. color/backdrop
setParameter(command, "pos");
setParameter(command, "color");
setParameter(command, "bcolor");
setParameter(command, "size");
setParameter(command, "label");
setParameter(command, "enableOutline");
setParameter(command, "font");
}
void Mixer1::onParamChange() {
// get the signal sender
QObject* obj = QObject::sender();
// cast it to a midi-ui element
const MidiUI* ui = dynamic_cast<const MidiUI*>(obj);
if (!ui) {throw "invalid element attached";}
// get the new value to set (between [0,1])
Param param = ui->getParamType();
ParamValue val = ui->getValueAsParam();
// set
setParameter(param, val);
}
//------------------------------------------------------------------------
void MidiVelocityScale::setProgram (VstInt32 program)
{
MidiVelocityScaleProgram* ap = &programs[program];
curProgram = program;
setParameter (kVel1, ap->fVel1);
setParameter (kVel2, ap->fVel2);
setParameter (kOffset, ap->fOffset);
setParameter (kOffVel1, ap->fOffVel1);
setParameter (kOffVel2, ap->fOffVel2);
setParameter (kOffOffset, ap->fOffOffset);
}
//--------------------------------------------------------------
void ofApp::update(){
//++ roundClock;
//if (roundClock % 2 != 0) return;
ofxUIToggle* live = (ofxUIToggle*)gui->getWidget("live");
ofxUIToggle* record = (ofxUIToggle*)gui->getWidget("record");
ofxUIIntSlider * frame = (ofxUIIntSlider *) gui->getWidget("frame");
if (!stop)
{
if (loadFrame < frame->getMax())
{
++ loadFrame;
setFrame();
}
}
device_->update();
if (live->getValue() || frame->getValue() == 0)
{
if (color_.isFrameNew() && depth_.isFrameNew())
{
img_originColor->setFromPixels(color_.getPixelsRef());
img_color->setFromPixels(depthProcessor.mapDepthToColor(color_.getPixelsRef(), depth_.getPixelsRef()));
//img_depth->setFromPixels(depth_.getPixelsRef(depth_.getNear(), depth_.getFar()));
img_depth->setFromPixels(depth_.getPixelsRef());
img_color->mirror(false, true);
img_depth->mirror(false, true);
img_originColor->mirror(false, true);
}
if (record->getValue() && color_.isFrameNew() && depth_.isFrameNew())
{
queue_originColor->Produce(img_originColor);
queue_color->Produce(img_color);
queue_depth->Produce(img_depth);
recorder.signal();
img_originColor = new ofImage(*img_originColor);
img_color = new ofImage(*img_color);
img_depth = new ofShortImage(*img_depth);
++ frameNum;
}
}
setParameter();
}
void Settings::loadSettings(const QString & fileName)
{
QString path = fileName;
if(fileName.isEmpty())
{
path = iniPath();
}
if(!path.isEmpty())
{
QSettings ini(path, QSettings::IniFormat);
for(ParametersMap::const_iterator iter = defaultParameters_.begin(); iter!=defaultParameters_.end(); ++iter)
{
const QString & key = iter.key();
QVariant value = ini.value(key, QVariant());
if(value.isValid())
{
QString str = value.toString();
if(str.contains(";") && str.size() != getParameter(key).toString().size())
{
// If a string list is modified, update the value
// (assuming that index < 10... one character for index)
QChar index = str.at(0);
str = getParameter(key).toString();
str[0] = index.toAscii();
value = QVariant(str);
UINFO("Updated list of parameter \"%s\"", key.toStdString().c_str());
}
setParameter(key, value);
}
}
UINFO("Settings loaded from %s.", path.toStdString().c_str());
}
else
{
parameters_ = defaultParameters_;
UINFO("Settings set to defaults.");
}
if(cv::gpu::getCudaEnabledDeviceCount() == 0)
{
Settings::setFeature2D_SURF_gpu(false);
Settings::setFeature2D_Fast_gpu(false);
Settings::setFeature2D_ORB_gpu(false);
}
}
void SynthEngine::reset() {
setParameter(SENGINE_LFO2_TO_CUTOFF, 0.0f);
setParameter(SENGINE_LFO1_TO_AMP, 0.0f);
setParameter(SENGINE_ENV1_TO_OSC1PW, 0.0f);
setParameter(SENGINE_ENV1_TO_OSC2PW, 0.0f);
setParameter(SENGINE_OSCMIX, 0.5f);
setParameter(SENGINE_AMPLEVEL, 1.0f);
setParameter(SENGINE_FILTFREQ, 1.0f);
setParameter(SENGINE_FILTRESO, -1.0f);
setParameter(SENGINE_ENV2_TO_CUTOFF, 0.0f);
setFilter24dB(0);
oscillators[0]->reset();
oscillators[1]->reset();
envelopes[0]->reset();
envelopes[1]->reset();
filters[0]->reset();
filters[1]->reset();
lfos[0]->reset();
lfos[1]->reset();
echo->reset();
}
/*
* Load internal state from an archive.
*/
void Perturbation::loadParameters(Serializable::IArchive &ar)
{
loadParameter<int>(ar, "mode", mode_);
loadParameter<int>(ar, "nParameters", nParameters_);
parameter_.allocate(nParameters_);
parameters_.allocate(size_, nParameters_);
initialParameter_.allocate(nParameters_);
finalParameter_.allocate(nParameters_);
if (mode_ == 0) {
loadDMatrix<double>(ar, "parameters", parameters_, size_, nParameters_);
} else if (mode_ == 1) {
loadDArray<double>(ar, "initialParameter", initialParameter_, nParameters_);
loadDArray<double>(ar, "finalParameter", finalParameter_, nParameters_);
ar & parameters_;
}
ar & parameter_;
setParameter(); // Modify parameter of associated System
}
mdaImage::mdaImage(audioMasterCallback audioMaster) : AudioEffectX(audioMaster, 1, 6) // programs, parameters
{
fParam1 = 0.6f; //mode
fParam2 = 0.75f; //width
fParam3 = 0.5f; //skew
fParam4 = 0.75f; //centre
fParam5 = 0.5f; //balance
fParam6 = 0.5f; //output
setNumInputs(2);
setNumOutputs(2);
setUniqueID('mdaI'); // identify here
DECLARE_VST_DEPRECATED(canMono) ();
canProcessReplacing();
strcpy(programName, "Stereo Image / MS Matrix");
setParameter(0, 0.6f); //go and set initial values!
}
void Clamp::updateClampMode(int index) {
if (index == 0) { // STEP
mode = STEP;
update(MODIFY);
emit setStepMode(true);
emit setPlotMode(false);
printf("Entering STEP mode\n");
}
else if (index == 1) { // RAMP
mode = RAMP;
minamp = 0;
setParameter("Min Amplitude (pA)", QString::number(minamp * 1e12)); // initialized in A, display in pA
update(MODIFY);
emit setStepMode(false);
plotFI = false;
printf("Entering RAMP mode\n");
}
}
void TextShape::update()
{
OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_mutex);
if( !_dirty )
return;
osg::Vec3 p = getPosition();
osg::Vec4 c = getColor();
float size = getCharacterHeight();
std::string text = getText().createUTF8EncodedString();
setParameter("x", p.x());
setParameter("y", p.y());
setParameter("z", p.z());
setParameter("r", c.r());
setParameter("g", c.g());
setParameter("b", c.b());
setParameter("a", c.a());
setParameter("size", size);
setParameter("label", text);
setText(text);
setCharacterSize(size);
setPosition(p);
setColor(c);
dirtyBound();
if(c[3] != 1.0)
getOrCreateStateSet()->setRenderingHint(osg::StateSet::TRANSPARENT_BIN);
else
getOrCreateStateSet()->setRenderingHint(osg::StateSet::DEFAULT_BIN);
// reset flag
_dirty = false;
}
/**
* Set new height of the peak. This method does this approximately.
* @param h :: New value for the height.
*/
void BackToBackExponential::setHeight(const double h)
{
double h0 = height();
if ( h0 == 0.0 )
{
h0 = 1e-6;
}
double area = getParameter( 0 ); // == I
area *= h / h0;
if ( area <= 0.0 )
{
area = 1e-6;
}
if ( boost::math::isnan( area ) || boost::math::isinf( area ) )
{
area = std::numeric_limits<double>::max() / 2;
}
setParameter( 0, area );
}
void Ambix_directional_loudnessAudioProcessor::setStateInformation (const void* data, int sizeInBytes)
{
// You should use this method to restore your parameters from this memory block,
// whose contents will have been created by the getStateInformation() call.
ScopedPointer<XmlElement> xmlState (getXmlFromBinary (data, sizeInBytes));
if (xmlState != nullptr)
{
// make sure that it's actually our type of XML object..
if (xmlState->hasTagName ("MYPLUGINSETTINGS"))
{
for (int i=0; i < getNumParameters(); i++) {
setParameter(i, xmlState->getDoubleAttribute(String(i)));
}
}
}
}
void ListJobs::actHostsMaskExclude()
{
ItemJob* jobitem = (ItemJob*)getCurrentItem();
if( jobitem == NULL ) return;
QString current = jobitem->hostsmask_exclude;
bool ok;
QString mask = QInputDialog::getText(this, "Change Exclude Mask", "Enter New Mask", QLineEdit::Normal, current, &ok);
if( !ok) return;
QRegExp rx( mask, Qt::CaseInsensitive);
if( rx.isValid() == false )
{
displayError( rx.errorString());
return;
}
setParameter("hosts_mask_exclude", afqt::qtos( mask));
}
void ListJobs::actDependMaskGlobal()
{
ItemJob* jobitem = (ItemJob*)getCurrentItem();
if( jobitem == NULL ) return;
QString current = jobitem->dependmask_global;
bool ok;
QString mask = QInputDialog::getText(this, "Change Depend Mask", "Enter New Mask", QLineEdit::Normal, current, &ok);
if( !ok) return;
QRegExp rx( mask, Qt::CaseInsensitive);
if( rx.isValid() == false )
{
displayError( rx.errorString());
return;
}
setParameter("depend_mask_global", afqt::qtos( mask));
}
void ListJobs::actNeedProperties()
{
ItemJob* jobitem = (ItemJob*)getCurrentItem();
if( jobitem == NULL ) return;
QString current = jobitem->need_properties;
bool ok;
QString mask = QInputDialog::getText(this, "Change Properties Needed", "Enter New Mask", QLineEdit::Normal, current, &ok);
if( !ok) return;
QRegExp rx( mask, Qt::CaseInsensitive);
if( rx.isValid() == false )
{
displayError( rx.errorString());
return;
}
setParameter("need_properties", afqt::qtos( mask));
}
void VstEffectControls::loadSettings( const QDomElement & _this )
{
//m_effect->closePlugin();
//m_effect->openPlugin( _this.attribute( "plugin" ) );
m_effect->m_pluginMutex.lock();
if( m_effect->m_plugin != NULL )
{
m_effect->m_plugin->loadSettings( _this );
const QMap<QString, QString> & dump = m_effect->m_plugin->parameterDump();
paramCount = dump.size();
char paramStr[35];
vstKnobs = new knob *[ paramCount ];
knobFModel = new FloatModel *[ paramCount ];
QStringList s_dumpValues;
QWidget * widget = new QWidget();
for( int i = 0; i < paramCount; i++ )
{
sprintf( paramStr, "param%d", i );
s_dumpValues = dump[ paramStr ].split( ":" );
vstKnobs[i] = new knob( knobBright_26, widget, s_dumpValues.at( 1 ) );
vstKnobs[i]->setHintText( s_dumpValues.at( 1 ) + ":", "" );
vstKnobs[i]->setLabel( s_dumpValues.at( 1 ).left( 15 ) );
knobFModel[i] = new FloatModel( 0.0f, 0.0f, 1.0f, 0.01f, this, QString::number(i) );
knobFModel[i]->loadSettings( _this, paramStr );
if( !( knobFModel[ i ]->isAutomated() ||
knobFModel[ i ]->controllerConnection() ) )
{
knobFModel[ i ]->setValue( (s_dumpValues.at( 2 ) ).toFloat() );
knobFModel[ i ]->setInitValue( (s_dumpValues.at( 2 ) ).toFloat() );
}
connect( knobFModel[i], SIGNAL( dataChanged() ), this, SLOT( setParameter() ) );
vstKnobs[i]->setModel( knobFModel[i] );
}
}
m_effect->m_pluginMutex.unlock();
}