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);
}
Example #2
0
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;
}
Example #3
0
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);
}
Example #4
0
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;
}
Example #5
0
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;
}
Example #6
0
/*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;
}
Example #12
0
//------------------------------------------------------------------------
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]);	
        }
    }
}
Example #13
0
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));
	}
}
Example #14
0
/**
 * 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);
}
Example #15
0
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");
}
Example #16
0
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);

}
Example #17
0
//------------------------------------------------------------------------
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);
}
Example #18
0
//--------------------------------------------------------------
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();
}
Example #19
0
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);
	}
}
Example #20
0
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();
}
Example #21
0
 /*
 * 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
 }
Example #22
0
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!
}
Example #23
0
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");
	}
}
Example #24
0
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 );
 }
Example #26
0
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)));
            }
        }
        
    }
}
Example #27
0
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));
}
Example #28
0
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));
}
Example #29
0
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();
}