SM::SM( std::string input, int size ) : num_Camber( 0 )
, num_Speed( 0 )
//, SPACE( 60 )
//, HEIGHT( 160 )
//, WIDTH( 5 )
, font_index( -1 )
, _size_width( size )
, _size_height( size )
, barOffsetX( 0 )
, barOffsetY( 0 )
, _index( -1 )
, _HIGHLIGHT( -1 )
, _INIT( true )
, COLORSTATE( 0 )
{
pathName = input;
//
int start = pathName.find_last_of( "/" );
int end = pathName.find_last_of( "." );
int length = end - start - 1;
_name = pathName.substr( start + 1, length );
//
initParameters();
loadData();
}
YuvSourceFilter::YuvSourceFilter(IUnknown *pUnk, HRESULT *phr)
: CSource(NAME("CSIR RTVC YUV Source"), pUnk, CLSID_VPP_YUVSource),
m_iWidth(352),
m_iHeight(288),
m_sDimensions("352x288"),
m_iFramesPerSecond(30),
m_iNoFrames(150), //TODO: move to property page
m_dBytesPerPixel(1.5),
m_pYuvBuffer(NULL),
m_iFileSize(0),
m_iRead(0)
{
// Init CSettingsInterface
initParameters();
m_pPin = new YuvOutputPin(phr, this);
if (phr)
{
if (m_pPin == NULL)
*phr = E_OUTOFMEMORY;
else
*phr = S_OK;
}
}
ConnSettings::ConnSettings(QWidget *parent) :
QDialog(parent)
{
setWindowTitle("Connection: <noname>");
restoreGeometry(settings.value("SetDlgGeometry").toByteArray());
setModal(false);
setContentsMargins(1,1,1,1);
initParamLayout();
warning = new QLabel(this);
warning->setText(
"<b>WARNING</b> See for: <a href='http://libvirt.org/remote.html'><b>Libvirt Remote support</b></a>");
warning->setOpenExternalLinks(true);
initButtons();
URI = new QTextEdit(this);
URI->setReadOnly(true);
commonLayout = new QVBoxLayout();
commonLayout->addWidget(parameters);
commonLayout->addWidget(warning);
commonLayout->addWidget(URI);
commonLayout->addWidget(buttons);
commonLayout->insertStretch(-1);
setLayout(commonLayout);
initParameters();
timerId = startTimer(1000);
}
MusicDesktopWallpaperWidget::MusicDesktopWallpaperWidget(QWidget *parent)
: MusicAbstractMoveWidget(parent),
ui(new Ui::MusicDesktopWallpaperWidget)
{
ui->setupUi(this);
setAttribute(Qt::WA_DeleteOnClose);
setAttribute(Qt::WA_TranslucentBackground);
ui->topTitleCloseButton->setIcon(QIcon(":/share/searchclosed"));
ui->topTitleCloseButton->setStyleSheet(MusicUIObject::MToolButtonStyle03);
ui->topTitleCloseButton->setCursor(QCursor(Qt::PointingHandCursor));
ui->topTitleCloseButton->setToolTip(tr("Close"));
connect(ui->topTitleCloseButton, SIGNAL(clicked()), SLOT(close()));
initWidgetStyle();
initParameters();
connect(ui->netRadioButton, SIGNAL(clicked()), SLOT(netRadioButtonPressed()));
connect(ui->localRadioButton, SIGNAL(clicked()), SLOT(localRadioButtonPressed()));
connect(ui->playRadioButton, SIGNAL(clicked()), SLOT(playRadioButtonPressed()));
connect(ui->viewButton, SIGNAL(clicked()), SLOT(viewButtonPressed()));
connect(ui->confirmButton, SIGNAL(clicked()), SLOT(confirmButtonPressed()));
connect(ui->stopButton, SIGNAL(clicked()), SLOT(stopButtonPressed()));
connect(ui->cancelButton, SIGNAL(clicked()), SLOT(cancelButtonPressed()));
ui->localRadioButton->setChecked(true);
localRadioButtonPressed();
m_wallThread = new MusicDesktopWallpaperThread(this);
}
PairAlign::PairAlign(MSAEditor* _msa)
: msa(_msa), pairwiseAlignmentWidgetsSettings(_msa->getPairwiseAlignmentWidgetsSettings()),
distanceCalcTask(NULL), settingsWidget(NULL),
showHideSequenceWidget(NULL), showHideSettingsWidget(NULL), showHideOutputWidget(NULL),
saveController(NULL), savableTab(this, GObjectViewUtils::findViewByName(_msa->getName())),
showSequenceWidget(_msa->getPairwiseAlignmentWidgetsSettings()->showSequenceWidget),
showAlgorithmWidget(_msa->getPairwiseAlignmentWidgetsSettings()->showAlgorithmWidget),
showOutputWidget(_msa->getPairwiseAlignmentWidgetsSettings()->showOutputWidget),
firstSequenceSelectionOn(false), secondSequenceSelectionOn(false),
sequencesChanged(true), sequenceNamesIsOk(false), alphabetIsOk(false)
{
SAFE_POINT(NULL != msa, "MSA Editor is NULL.", );
SAFE_POINT(NULL != pairwiseAlignmentWidgetsSettings, "pairwiseAlignmentWidgetsSettings is NULL.", );
setupUi(this);
firstSeqSelectorWC = new SequenceSelectorWidgetController(msa);
firstSeqSelectorWC->setObjectName("firstSeqSelectorWC");
secondSeqSelectorWC = new SequenceSelectorWidgetController(msa);
secondSeqSelectorWC->setObjectName("secondSeqSelectorWC");
firstSequenceLayout->addWidget(firstSeqSelectorWC);
secondSequenceLayout->addWidget(secondSeqSelectorWC);
initLayout();
initSaveController();
connectSignals();
initParameters();
U2WidgetStateStorage::restoreWidgetState(savableTab);
checkState();
}
ClassNamePage::ClassNamePage(QWidget *parent)
: QWizardPage(parent)
, m_isValid(false)
{
setTitle(tr("Enter Class Name"));
setSubTitle(tr("The source file name will be derived from the class name"));
m_newClassWidget.reset(new Utils::NewClassWidget);
// Order, set extensions first before suggested name is derived
m_newClassWidget->setClassTypeComboVisible(true);
m_newClassWidget->setBaseClassChoices(QStringList()
<< QString()
<< QLatin1String("QObject")
<< QLatin1String("QWidget")
<< QLatin1String("QMainWindow")
<< QLatin1String("QDeclarativeItem"));
m_newClassWidget->setBaseClassEditable(true);
m_newClassWidget->setFormInputVisible(false);
m_newClassWidget->setHeaderInputVisible(false);
m_newClassWidget->setNamespacesEnabled(true);
m_newClassWidget->setBaseClassInputVisible(true);
m_newClassWidget->setNamesDelimiter(QLatin1String("."));
m_newClassWidget->setAllowDirectories(true);
connect(m_newClassWidget.data(), SIGNAL(validChanged()), this, SLOT(slotValidChanged()));
QVBoxLayout *pageLayout = new QVBoxLayout(this);
pageLayout->addWidget(m_newClassWidget.data());
QSpacerItem *vSpacer = new QSpacerItem(0, 0, QSizePolicy::Ignored, QSizePolicy::Expanding);
pageLayout->addItem(vSpacer);
initParameters();
}
void KdTreeFLANN<PointT>::setInputCloud (const PointCloudConstPtr &cloud, const IndicesConstPtr &indices)
{
cleanup (); // Perform an automatic cleanup of structures
if (!initParameters())
return;
input_ = cloud;
indices_ = indices;
if (input_ == NULL)
return;
m_lock_.lock ();
// Allocate enough data
if (!input_)
{
ROS_ERROR ("[pcl::KdTreeANN::setInputCloud] Invalid input!");
return;
}
if (indices != NULL)
convertCloudToArray (*input_, *indices_);
else
convertCloudToArray (*input_);
initData ();
m_lock_.unlock ();
}
void VisualBird::initiation()
{
initParameters();
//defining first flight target point
//targetPoint = eye->getStartPoint();
//readTargets();
targetPoint = eye->getOriginPoint();
//targetPoint.z += flight_height;
targetPoint.z += flight_height;
//targetPoint.x += flight_height;
//targetPoint.y += flight_height;
ROS_INFO("hover to %.3f %.3f %.3f",targetPoint.x,targetPoint.y,targetPoint.z);
shiftOrigin.z = targetPoint.z;
targetBound = shiftOrigin;
//sleep(5);
if (fly)
{
dummy->on();
double secs =ros::Time::now().toSec();
timeTable.push_back(secs);
}
}
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));
}
}
paramList TestTubeSegmentationFramework::loadPreset(QString preset)
{
std::string path = getParametersDir().toStdString();
paramList parameters = initParameters(path);
setParameter(parameters, "parameters", preset.toStdString());
loadParameterPreset(parameters, path);
return parameters;
}
void medVtkViewItkDataImage4DInteractor::setData(medAbstractData *data)
{
double range[2]={0,0};
double mintimestep, mintime, maxtime;
unsigned int numberofsteps;
d->imageData = dynamic_cast<medAbstractImageData *>(data);
if(!d->imageData)
return;
if( data->identifier().contains("itkDataImage") && d->imageData->Dimension() == 4 ) {
d->sequence = vtkMetaDataSetSequence::New();
int layer = d->view->layer(data);
if ( AppendImageSequence<char>(data,d->view,d->sequence, layer) ||
AppendImageSequence<unsigned char>(data,d->view,d->sequence, layer) ||
AppendImageSequence<short>(data,d->view,d->sequence, layer) ||
AppendImageSequence<unsigned short>(data,d->view,d->sequence, layer) ||
AppendImageSequence<float>(data,d->view,d->sequence, layer) ||
AppendImageSequence<double>(data,d->view,d->sequence, layer))
{
d->view2d->GetImageActor(d->view2d->GetCurrentLayer())->GetProperty()->SetInterpolationTypeToCubic();
initParameters(d->imageData);
d->timeLineParameter = new medTimeLineParameter("TimeLine", this);
this->timeRange(range);
mintimestep = this->frameRate();
mintime = range[0];
maxtime = range[1];
d->timeLineParameter->setNumberOfFrame(d->sequence->GetNumberOfMetaDataSets());
d->timeLineParameter->setDuration((maxtime));
qDebug() << d->sequence->GetTimeResolution();
connect(d->timeLineParameter, SIGNAL(frameChanged(double)), this, SLOT(setCurrentTime(double)));
if(d->view->layer(d->imageData) == 0)
{
switch(d->view2d->GetViewOrientation())
{
case vtkImageView2D::VIEW_ORIENTATION_AXIAL:
d->view->setOrientation(medImageView::VIEW_ORIENTATION_AXIAL);
break;
case vtkImageView2D::VIEW_ORIENTATION_SAGITTAL:
d->view->setOrientation(medImageView::VIEW_ORIENTATION_SAGITTAL);
break;
case vtkImageView2D::VIEW_ORIENTATION_CORONAL:
d->view->setOrientation(medImageView::VIEW_ORIENTATION_CORONAL);
break;
}
}
}
Generator::Generator(QObject *parent) :
QObject(parent)
{
initParameters();
parseWebsiteIndexFile();
generateWebroot();
qDebug()<<"finish";
exit(0);
}
// Just the constructor.
AMAmp::AMAmp(void) : DefaultGUIModel("AM Amp 2400 Controller", ::vars, ::num_vars) {
setWhatsThis("<p>Controls the AM Amp 2400 amplifier by scaling the gains on the analog input/output channels and sending a mode telegraph to set the amplifier mode (custom).</p>");
DefaultGUIModel::createGUI(vars, num_vars);
initParameters();
customizeGUI();
update( INIT );
DefaultGUIModel::refresh();
QTimer::singleShot(0, this, SLOT(resizeMe()));
};
ConnorStevens::ConnorStevens(void) : DefaultGUIModel("Connor Stevens", ::vars, ::num_vars) {
setWhatsThis(
"<p><b>Connor-Stevens:</b><br>This module simulates a Connor-Stevens model neuron.</p>");
createGUI(vars, num_vars);
initParameters();
update( INIT );
refresh();
resizeMe();
}
TEST(ParameterTest, SetParameters) {
paramList parameters = initParameters(PARAMETERS_DIR);
setParameter(parameters, "display", "true");
EXPECT_TRUE(getParamBool(parameters, "display"));
setParameter(parameters, "cropping", "lung");
EXPECT_EQ("lung", getParamStr(parameters, "cropping"));
setParameter(parameters, "tdf-high", "0.9");
EXPECT_EQ(0.9f, getParam(parameters, "tdf-high"));
}
ofFFGLPlugin::ofFFGLPlugin( ofFFGLApp * app, int minInputs, int maxInputs )
{
// Input properties
SetMinInputs(minInputs);
SetMaxInputs(maxInputs);
_app = app;
initParameters();
}
void ConnSettings::setConnectItem(ConnItemIndex *idx)
{
own_index = idx;
name = idx->getName();
previousName = name;
set_Title_Name(name);
if (name!=QString("<noname>")) {
initParameters();
};
}
ImageProcessSystem::ImageProcessSystem(QWidget *parent, Qt::WFlags flags)
: QMainWindow(parent, flags)
{
ui.setupUi(this);
connnecting();
initParameters();
#ifdef DEMO
ui.actionOpen->setEnabled(false);
#endif
}
QDeclarativePlaceIcon::QDeclarativePlaceIcon(const QPlaceIcon &icon, QDeclarativeGeoServiceProvider *plugin, QObject *parent)
: QObject(parent), m_parameters(new QQmlPropertyMap(this))
{
if (icon.isEmpty())
m_plugin = 0;
else
m_plugin = plugin;
initParameters(icon.parameters());
}
int
pcl::modeler::AbstractWorker::exec()
{
for (auto &cloud_mesh_item : cloud_mesh_items_)
initParameters(cloud_mesh_item);
setupParameters();
return (parameter_dialog_->exec());
}
int
pcl::modeler::AbstractWorker::exec()
{
for (size_t i = 0, i_end = cloud_actors_.size(); i < i_end; ++ i)
initParameters(cloud_actors_[i]->getCloud());
setupParameters();
return (parameter_dialog_->exec());
}
void medVtkViewItkDataImage4DInteractor::setInputData(medAbstractData *data)
{
d->imageData = dynamic_cast<medAbstractImageData *>(data);
if(!d->imageData)
return;
if( data->identifier().contains("itkDataImage") && d->imageData->Dimension() == 4 ) {
d->sequence = vtkMetaDataSetSequence::New();
int layer = d->view->layer(data);
if ( AppendImageSequence<char>(data,d->view,d->sequence, layer) ||
AppendImageSequence<unsigned char>(data,d->view,d->sequence, layer) ||
AppendImageSequence<short>(data,d->view,d->sequence, layer) ||
AppendImageSequence<unsigned short>(data,d->view,d->sequence, layer) ||
AppendImageSequence<int>(data,d->view,d->sequence, layer) ||
AppendImageSequence<unsigned int>(data,d->view,d->sequence, layer) ||
AppendImageSequence<long>(data,d->view,d->sequence, layer) ||
AppendImageSequence<unsigned long>(data,d->view,d->sequence, layer) ||
AppendImageSequence<float>(data,d->view,d->sequence, layer) ||
AppendImageSequence<double>(data,d->view,d->sequence, layer))
{
d->imageData->addMetaData("SequenceDuration", QString::number(d->sequence->GetMaxTime()));
d->imageData->addMetaData("SequenceFrameRate", QString::number((double)d->sequence->GetNumberOfMetaDataSets() /
(double)d->sequence->GetMaxTime()));
qDebug() << "SequenceDuration" << d->sequence->GetMaxTime();
qDebug() << "SequenceFrameRate" <<(double)d->sequence->GetNumberOfMetaDataSets() / (double)d->sequence->GetMaxTime();
d->view2d->GetImageActor(d->view2d->GetCurrentLayer())->GetProperty()->SetInterpolationTypeToCubic();
initParameters(d->imageData);
double* range = d->sequence->GetCurrentScalarRange();
d->view2d->SetColorRange(range);
this->initWindowLevelParameters(range);
if(d->view->layer(d->imageData) == 0)
{
switch(d->view2d->GetViewOrientation())
{
case vtkImageView2D::VIEW_ORIENTATION_AXIAL:
d->view->setOrientation(medImageView::VIEW_ORIENTATION_AXIAL);
break;
case vtkImageView2D::VIEW_ORIENTATION_SAGITTAL:
d->view->setOrientation(medImageView::VIEW_ORIENTATION_SAGITTAL);
break;
case vtkImageView2D::VIEW_ORIENTATION_CORONAL:
d->view->setOrientation(medImageView::VIEW_ORIENTATION_CORONAL);
break;
}
}
}
}
}
//this is the main optimization routine with the loop that lowers the temperature
//and the disk radius geometrically until the temperature is zero. For each
//temperature, a certain number of new positions for a random vertex are tried
void DavidsonHarel::call(GraphAttributes &AG)
{
initParameters();
m_shrinkingFactor = m_shrinkFactor;
OGDF_ASSERT(!m_energyFunctions.empty());
const Graph &G = AG.constGraph();
//compute the list of vertices with degree greater than zero
G.allNodes(m_nonIsolatedNodes);
ListIterator<node> it,itSucc;
for(it = m_nonIsolatedNodes.begin(); it.valid(); it = itSucc) {
itSucc = it.succ();
if((*it)->degree() == 0) m_nonIsolatedNodes.del(it);
}
if(G.numberOfEdges() > 0) { //else only isolated nodes
computeFirstRadius(AG);
computeInitialEnergy();
if(m_numberOfIterations == 0)
m_numberOfIterations = m_nonIsolatedNodes.size() * m_iterationMultiplier;
//this is the main optimization loop
while(m_temperature > 0) {
//iteration loop for each temperature
for(int ic = 1; ic <= m_numberOfIterations; ic ++) {
DPoint newPos;
//choose random vertex and new position for vertex
node v = computeCandidateLayout(AG,newPos);
//compute candidate energy and decide if new layout is chosen
ListIterator<double> it2 = m_weightsOfEnergyFunctions.begin();
double newEnergy = 0.0;
for(EnergyFunction *f : m_energyFunctions) {
newEnergy += f->computeCandidateEnergy(v,newPos) * (*it2);
++it2;
}
OGDF_ASSERT(newEnergy >= 0.0);
//this tests if the new layout is accepted. If this is the case,
//all energy functions are informed that the new layout is accepted
if(testEnergyValue(newEnergy)) {
for(EnergyFunction *f : m_energyFunctions)
f->candidateTaken();
AG.x(v) = newPos.m_x;
AG.y(v) = newPos.m_y;
m_energy = newEnergy;
}
}
//lower the temperature and decrease the disk radius
m_temperature = (int)floor(m_temperature*m_coolingFactor);
m_diskRadius *= m_shrinkingFactor;
}
}
//if there are zero degree vertices, they are placed using placeIsolatedNodes
if(m_nonIsolatedNodes.size() != G.numberOfNodes())
placeIsolatedNodes(AG);
}
PDF_GLWADS_DK_hh_Dmix::PDF_GLWADS_DK_hh_Dmix(config cObs, config cErr, config cCor,
double Mxy, ParametersAbs* pars, TString d)
: PDF_GLWADS_DK_hh(cObs,cErr,cCor,pars,d)
{
name = "glwads-dk-hh-dmix";
_Mxy = Mxy;
initParameters();
initRelations();
delete pdf; // it was built already by the super class constructor
buildPdf();
}
TEST(ParameterTest, GetDefaultParameters) {
paramList parameters = initParameters(PARAMETERS_DIR);
EXPECT_FALSE(getParamBool(parameters, "display"));
EXPECT_EQ("gpu", getParamStr(parameters, "device"));
EXPECT_EQ(0.05f, getParam(parameters, "gvf-mu"));
EXPECT_EQ("Display results", parameters.bools["display"].getDescription());
EXPECT_EQ("Which type of processor to use", parameters.strings["device"].getDescription());
EXPECT_EQ("Mu regularization constant of GVF", parameters.numerics["gvf-mu"].getDescription());
}
NoiseGen::NoiseGen(void) : DefaultGUIModel("Noise Generator", ::vars, ::num_vars) {
setWhatsThis(
"<p><b>Noise Generator:</b></p><p>Generates noise of the type specified.</p>");
initParameters();
initStimulus();
DefaultGUIModel::createGUI(vars, num_vars); // this is required to create the GUI
customizeGUI();
update( INIT);
refresh();
QTimer::singleShot(0, this, SLOT(resizeMe()));
}
void BirdEye::initiation()
{
initPosition();
initParameters();
flightOrigin();
initPointcloud();
//defining pre points for later velocity calculation
prePoint = originPoint;
ROS_INFO("origin at %.3f %.3f %.3f",originPoint.x,originPoint.y,originPoint.z);
}
int main(int argc, char * argv[]){
Population * pop, * selected;
Individual * best_solution;
int generation_num;
initParameters(argc, argv);
pop = genSeededPopulation(POP_SIZE);
#if (defined DIVERSITY)
printGeneComposition(pop);
#endif
determineFitness(pop);
sortByFitness(pop);
generation_num = 0;
while(generation_num < MAX_NUM_GENERATIONS){
#if (defined VERBOSE || defined DIVERSITY)
fprintf(stdout, "\n----------------- GENERATION %d -----------------\n", generation_num + 1);
printPopulation(pop);
#endif
// FIX - use function pointers instead of flags + if statement
if(selection_type == 1)
selected = tournamentSelection(pop);
else
selected = randomSelection(pop);
// FIX - use function pointers instead of flags + if statement
evolvePopulation(selected, crossover_type, mutation_type);
determineFitness(selected);
// FIX - use function pointers instead of flags + if statement
if(replacement_type == 1)
pop = replaceAll(pop, selected);
else
pop = retainBest(pop, selected);
generation_num++;
}
fprintf(stdout, "\nFINAL RESULT:\n");
printPopulation(pop);
fprintf(stdout, "\nBEST SOLUTION:\n");
best_solution = findBest(pop);
printIndividual(best_solution);
freePopulation(pop);
freeParameters();
return EXIT_SUCCESS;
}
int
pcl::modeler::AbstractWorker::exec()
{
for (QList<CloudMeshItem*>::iterator cloud_mesh_items_it = cloud_mesh_items_.begin();
cloud_mesh_items_it != cloud_mesh_items_.end();
++ cloud_mesh_items_it)
initParameters(*cloud_mesh_items_it);
setupParameters();
return (parameter_dialog_->exec());
}
WaveMaker::WaveMaker(void) :
DefaultGUIModel("Wave Maker", ::vars, ::num_vars)
{
QWhatsThis::add(
this,
"<p><b>Wave Maker:</b><br>This module reads a single value from an ascii file and outputs it as a signal.</p>");
initParameters();
createGUI(vars, num_vars);
update( INIT);
refresh();
}
