ebm_gui.cpp

Gaussian Mixture Algorithm

	else {
		ofstream stream;
		stream.open( printdata.file.toAscii());

		switch(type){
			case 0:
				if(printdata.pretty) { stream <<  "Idx : \n" ; static_cast<Idx<double>*>(idx)->pretty(stream); }
				if(printdata.elems) { stream << "elements : \n"; static_cast<Idx<double>*>(idx)->printElems(stream); stream << "\n";}
				break;
			case 1:
				if(printdata.pretty) { stream <<  "Idx : \n" ; static_cast<Idx<float>*>(idx)->pretty(stream); }
				if(printdata.elems) { stream << "elements : \n"; static_cast<Idx<float>*>(idx)->printElems(stream); stream << "\n";}
				break;
			case 2:
				if(printdata.pretty) { stream <<  "Idx : \n" ; static_cast<Idx<intg>*>(idx)->pretty(stream); }
				if(printdata.elems) { stream << "elements : \n"; static_cast<Idx<intg>*>(idx)->printElems(stream); stream << "\n";}
				break;
			case 3:
				if(printdata.pretty) { stream <<  "Idx : \n" ; static_cast<Idx<ubyte>*>(idx)->pretty(stream); }
				if(printdata.elems) { stream << "elements : \n"; static_cast<Idx<ubyte>*>(idx)->printElems(stream); stream << "\n";}
				break;
		}

		stream.close();
	}
	if(mutex != NULL) mutex->unlock();
}

void Idx_Gui::keyPressEvent( QKeyEvent* event){
	if(event->key() == Qt::Key_Equal){
		plotdata.zoom++;
		refreshdisplay();
	}
	if(event->key() == Qt::Key_Minus){
		int validate;
		if(plotdata.zoom == 1) validate = QMessageBox::warning(this, "properties checking", "The zoom will be set to 0. Are you sure ?", QMessageBox::Yes | QMessageBox::No);
		else validate = QMessageBox::Yes;
		if(validate == QMessageBox::Yes){
			plotdata.zoom--;
			refreshdisplay();
		}
	}
	if(event->key() == Qt::Key_P){
		print();
	}
	if(event->key() == Qt::Key_Q){
		close();
	}
}

void Idx_Gui::setvmin(double min){
	plotdata.min = min;
	plotdata.norm = false;
	dynamic_cast<idx_displayGui*>(visible)->displayAll(idx, type, &plotdata);
}

void Idx_Gui::setvmax(double max){
	plotdata.max = max;
	plotdata.norm = false;
	dynamic_cast<idx_displayGui*>(visible)->displayAll(idx, type, &plotdata);
}

void Idx_Gui::setvisible(bool isvisible){
	plotdata.visible = isvisible;
	refreshdisplay();
}

void Idx_Gui::setidx1_as_array(bool array){
	if(static_cast<Idx<double>*>(idx)->order() == 1){
		plotdata.idx1_as_array = array;
		refreshdisplay();
	}
}

void Idx_Gui::setidx3_as_RGB(bool rgb){
	if(static_cast<Idx<double>*>(idx)->order() >= 3){
		plotdata.idx3_as_RGB = rgb;
		refreshdisplay();
	}
}


////////////////////////////////////////////////////////////////////////////
// state_Idx gui  properties window related functions
///////////////////////////////////////////////////////////////////////////

state_idx_propgui::state_idx_propgui(QWidget* parent, int order):
	QDialog(parent)
{
	QTabWidget* tabs = new QTabWidget();

	//setFixedSize(350, 600);
	setWindowTitle("Idx Properties");

	QVBoxLayout* vmainLayout = new QVBoxLayout();
	setLayout(vmainLayout);


	//////////////////////////////////////////////
	// display tab
	/////////////////////////////////////////////

	QWidget* displaytab = new QWidget();
	QVBoxLayout* displayLayout = new QVBoxLayout();
	displaytab->setLayout(displayLayout);

	// zoom box
	QWidget* zoomwidget = new QWidget();
	QHBoxLayout* hzoomLayout = new QHBoxLayout();
	zoombox = new QDoubleSpinBox(this);
	hzoomLayout->addWidget(new QLabel("Zoom factor : ", this));
	hzoomLayout->addWidget(zoombox);
	zoomwidget->setLayout(hzoomLayout);
	displayLayout->addWidget(zoomwidget);

	// Idx1 special properties box. Added only for Idx-1
	QWidget* idx1widget = new QWidget();
	QHBoxLayout* hidx1Layout = new QHBoxLayout();
	hidx1Layout->addWidget(new QLabel("Display Idx1 as :", 0));
	QRadioButton* plotbutton = new QRadioButton("a plot", idx1widget);
	plotbutton->setChecked(true);
	arraybutton = new QRadioButton("an array", idx1widget);
	hidx1Layout->addWidget(plotbutton);
	hidx1Layout->addWidget(arraybutton);
	idx1widget->setLayout(hidx1Layout);
	if(order == 1) displayLayout->addWidget(idx1widget);

	// Idx3 special properties. Added only for Idx-3 or more
	QWidget* idx3widget = new QWidget();
	QHBoxLayout* hidx3Layout = new QHBoxLayout();
	hidx3Layout->addWidget(new QLabel("Display Idx3 in :", 0));
	QRadioButton* graybutton = new QRadioButton("grayscale (1 layer)", idx3widget);
	graybutton->setChecked(true);
	rgbbutton = new QRadioButton("RGB (3 layers)", idx3widget);
	hidx3Layout->addWidget(graybutton);
	hidx3Layout->addWidget(rgbbutton);
	idx3widget->setLayout(hidx3Layout);
	if(order >= 3) displayLayout->addWidget(idx3widget);


	// X box
	QGroupBox* Xgroupbox = new QGroupBox("X properties");
	QGridLayout* gxLayout = new QGridLayout();
	Xgroupbox->setLayout(gxLayout);

	X_maxbox = new QDoubleSpinBox(this);
	X_maxbox->setMaximum(999.99);
	gxLayout->addWidget(new QLabel("     X max : ", this), 0, 0);
	gxLayout->addWidget(X_maxbox, 0, 1);
	X_minbox = new QDoubleSpinBox(this);
	X_minbox->setMinimum(-999.99);
	gxLayout->addWidget(new QLabel("     X min : ", this), 1, 0);
	gxLayout->addWidget(X_minbox, 1, 1);

	X_maxnorm = new QLabel();
	X_maxnorm->setEnabled(false);
	gxLayout->addWidget(X_maxnorm, 0, 2);
	X_minnorm = new QLabel();
	X_minnorm->setEnabled(false);
	gxLayout->addWidget(X_minnorm, 1, 2);

	X_visiblecheck = new QCheckBox("visibility");
	gxLayout->addWidget(X_visiblecheck, 0,3);
	X_normalcheck = new QCheckBox("normalize");
	gxLayout->addWidget(X_normalcheck, 1, 3);

	displayLayout->addWidget(Xgroupbox);

	connect(X_normalcheck, SIGNAL(toggled(bool)), X_minbox, SLOT(setDisabled(bool)));
	connect(X_normalcheck, SIGNAL(toggled(bool)), X_maxbox, SLOT(setDisabled(bool)));


	//DX box
	QGroupBox* DXgroupbox = new QGroupBox("dX properties");
	QGridLayout* gdxLayout = new QGridLayout();
	DXgroupbox->setLayout(gdxLayout);

	DX_maxbox = new QDoubleSpinBox(this);
	DX_maxbox->setMaximum(999.99);
	gdxLayout->addWidget(new QLabel("   dX max : ", this), 0, 0);
	gdxLayout->addWidget(DX_maxbox, 0, 1);
	DX_minbox = new QDoubleSpinBox(this);
	DX_minbox->setMinimum(-999.99);
	gdxLayout->addWidget(new QLabel("   dX min : ", this), 1, 0);
	gdxLayout->addWidget(DX_minbox, 1, 1);

	DX_maxnorm = new QLabel();
	DX_maxnorm->setEnabled(false);
	gdxLayout->addWidget(DX_maxnorm, 0, 2);
	DX_minnorm = new QLabel();
	DX_minnorm->setEnabled(false);
	gdxLayout->addWidget(DX_minnorm, 1, 2);

	DX_visiblecheck = new QCheckBox("visibility");
	gdxLayout->addWidget(DX_visiblecheck, 0,3);
	DX_normalcheck = new QCheckBox("normalize");
	gdxLayout->addWidget(DX_normalcheck, 1, 3);

	displayLayout->addWidget(DXgroupbox);

	connect(DX_normalcheck, SIGNAL(toggled(bool)), DX_minbox, SLOT(setDisabled(bool)));
	connect(DX_normalcheck, SIGNAL(toggled(bool)), DX_maxbox, SLOT(setDisabled(bool)));

	//DDX box
	QGroupBox* DDXgroupbox = new QGroupBox("ddX properties");
	QGridLayout* gddxLayout = new QGridLayout();
	DDXgroupbox->setLayout(gddxLayout);

	DDX_maxbox = new QDoubleSpinBox(this);
	DDX_maxbox->setMaximum(999.99);
	gddxLayout->addWidget(new QLabel("  ddX max : ", this), 0, 0);
	gddxLayout->addWidget(DDX_maxbox, 0, 1);
	DDX_minbox = new QDoubleSpinBox(this);
	DDX_minbox->setMinimum(-999.99);
	gddxLayout->addWidget(new QLabel("  ddX min : ", this), 1, 0);
	gddxLayout->addWidget(DDX_minbox, 1, 1);

	DDX_maxnorm = new QLabel();
	DDX_maxnorm->setEnabled(false);
	gddxLayout->addWidget(DDX_maxnorm, 0, 2);
	DDX_minnorm = new QLabel();
	DDX_minnorm->setEnabled(false);
	gddxLayout->addWidget(DDX_minnorm, 1, 2);

	DDX_visiblecheck = new QCheckBox("visibility");
	gddxLayout->addWidget(DDX_visiblecheck, 0,3);
	DDX_normalcheck = new QCheckBox("normalize");
	gddxLayout->addWidget(DDX_normalcheck, 1, 3);

	displayLayout->addWidget(DDXgroupbox);

	connect(DDX_normalcheck, SIGNAL(toggled(bool)), DDX_minbox, SLOT(setDisabled(bool)));
	connect(DDX_normalcheck, SIGNAL(toggled(bool)), DDX_maxbox, SLOT(setDisabled(bool)));

	tabs->addTab(displaytab, "display properties");


	/////////////////////////////////////////////////////////////
	// print tab
	////////////////////////////////////////////////////////////
	QWidget* printtab = new QWidget();

	QGridLayout* printLayout = new QGridLayout();
	printtab->setLayout(printLayout);

	printLayout->addWidget(new QLabel("pretty print :"), 0, 0);
	X_pretty = new QCheckBox("X");
	printLayout->addWidget(X_pretty, 1, 0);
	DX_pretty = new QCheckBox("dX");
	printLayout->addWidget(DX_pretty, 1,1);
	DDX_pretty = new QCheckBox("ddX");
	printLayout->addWidget(DDX_pretty, 1,2);

	printLayout->addWidget(new QLabel("print elems :"), 2, 0);
	X_elems = new QCheckBox("X");
	printLayout->addWidget(X_elems, 3, 0);
	DX_elems = new QCheckBox("dX");
	printLayout->addWidget(DX_elems, 3,1);
	DDX_elems = new QCheckBox("ddX");
	printLayout->addWidget(DDX_elems, 3,2);

	print_onfile = new QCheckBox("print on file : (default : print on console)");
	printLayout->addWidget(print_onfile, 4, 0, 1, 3);
	fileedit = new QLineEdit();
	fileedit->setEnabled(false);
	printLayout->addWidget(fileedit, 5,0, 1, 2);
	QPushButton* filebutton = new QPushButton("select file...");
	filebutton->setEnabled(false);
	printLayout->addWidget(filebutton, 5,2);

	connect(print_onfile, SIGNAL(toggled(bool)), fileedit, SLOT(setEnabled(bool)));
	connect(print_onfile, SIGNAL(toggled(bool)), filebutton, SLOT(setEnabled(bool)));
	connect(filebutton, SIGNAL(clicked()), this, SLOT( choose_file()));

	printLayout->setMargin(40);

	tabs->addTab(printtab, "printing properties");

	vmainLayout->addWidget(tabs);

	///////////////////////////////////////////////////////
	// OK and cancel button
	//////////////////////////////////////////////////////
	QHBoxLayout* hbuttonLayout = new QHBoxLayout();
	okbutton = new QPushButton("OK", this);
	hbuttonLayout->addWidget(okbutton);
	cancelbutton = new QPushButton("Cancel", this);
	hbuttonLayout->addWidget(cancelbutton);
	vmainLayout->addLayout(hbuttonLayout);

	connect( cancelbutton, SIGNAL( clicked() ), this, SLOT( reject() ) );

}

void state_idx_propgui::set_data(state_idx_data* data)
{
	zoombox->setValue(data->x_plotdata.zoom);
	X_minbox->setValue(data->x_plotdata.min);
	X_maxbox->setValue(data->x_plotdata.max);
	X_maxnorm->setNum((double) data->x_plotdata.max_norm);
	X_minnorm->setNum((double) data->x_plotdata.min_norm);
	X_visiblecheck->setChecked(data->x_plotdata.visible);
	X_normalcheck->setChecked(data->x_plotdata.norm);
	arraybutton->setChecked(data->x_plotdata.idx1_as_array);
	rgbbutton->setChecked(data->x_plotdata.idx3_as_RGB);

	zoombox->setValue(data->dx_plotdata.zoom);
	DX_minbox->setValue(data->dx_plotdata.min);
	DX_maxbox->setValue(data->dx_plotdata.max);
	DX_maxnorm->setNum((double) data->dx_plotdata.max_norm);
	DX_minnorm->setNum((double) data->dx_plotdata.min_norm);
	DX_visiblecheck->setChecked(data->dx_plotdata.visible);
	DX_normalcheck->setChecked(data->dx_plotdata.norm);
	arraybutton->setChecked(data->dx_plotdata.idx1_as_array);
	rgbbutton->setChecked(data->dx_plotdata.idx3_as_RGB);

	zoombox->setValue(data->ddx_plotdata.zoom);
	DDX_minbox->setValue(data->ddx_plotdata.min);
	DDX_maxbox->setValue(data->ddx_plotdata.max);
	DDX_maxnorm->setNum((double) data->ddx_plotdata.max_norm);
	DDX_minnorm->setNum((double) data->ddx_plotdata.min_norm);
	DDX_visiblecheck->setChecked(data->ddx_plotdata.visible);
	DDX_normalcheck->setChecked(data->ddx_plotdata.norm);
	arraybutton->setChecked(data->ddx_plotdata.idx1_as_array);
	rgbbutton->setChecked(data->ddx_plotdata.idx3_as_RGB);

	X_pretty->setChecked(data->x_printdata.pretty);
	X_elems->setChecked(data->x_printdata.elems);
	print_onfile->setChecked(data->x_printdata.onfile);