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 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);
}

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]);	
        }
    }
}

/**
 * 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 &parameterName : 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");
	}
}