ebm_gui.cpp

Gaussian Mixture Algorithm

#include "ebm_gui.h"

////////////////////////////////////////////////////////////////////////////////////////////
// eb_box related methods
////////////////////////////////////////////////////////////////////////////////////////////

ebbox::ebbox(QWidget *parent, const char* title, QDialog *prop, QWidget *vis, QMutex* argmutex)
	: QGroupBox(title, parent)
{
	properties = prop;
	visible = vis;
	mutex = argmutex;
	open = false;
	ui.setupUi(this, title);
	if(visible != NULL) ui.vboxLayoutcont->addWidget(visible);
	ui.subcontainer->setVisible(false);
	mainwidget = NULL;
	QSizePolicy policy(QSizePolicy::Expanding, QSizePolicy::Expanding);
	setSizePolicy(policy);

	connect( ui.pushButton_expand, SIGNAL( clicked() ), this, SLOT( resize() ) );
	connect( ui.pushButton_print, SIGNAL( clicked() ), this, SLOT( print() ) );
	connect( ui.pushButton_properties, SIGNAL( clicked() ), this, SLOT( openProperties() ) );

	show();
}

ebbox::~ebbox()
{
	delete mutex;
}

void ebbox::resize()
{
   	if( open ) {
   		ui.subcontainer->setVisible(false);
   		open = false;
   	}
   	else {
   		ui.subcontainer->setVisible(true);
   		open = true;
   	}
   	refreshform(true);
}

void ebbox::openProperties()
{
	if(properties != NULL){
		properties->setModal(true);
		properties->show();
	}
}

void ebbox::print(){}

void ebbox::add_box(ebbox *ajout)
{
	ui.vboxLayoutcont->addWidget(ajout);
	added_widgets.push_back(ajout);
	if(mainwidget != NULL) ajout->mainwidget = mainwidget;
	else ajout->mainwidget = this;
}

void ebbox::refreshform(bool propup)
{
   	if((mainwidget != NULL)&&propup){
   		dynamic_cast<ebbox*>(mainwidget)->refreshform();
   	}
   	else{
   		adjustSize();
   		for(int i = 0; i < (int)added_widgets.size(); i++) added_widgets[i]->refreshform();
   	}
}

////////////////////////////////////////////////////////////////////////////////////////////
// Idx gui  properties window related functions
////////////////////////////////////////////////////////////////////////////////////////////

void initialize_data(idx_plotdata* plotdata, idx_printdata* printdata, void* idx, idx_type type){
	plotdata->zoom = 1;
	plotdata->norm = true;
	plotdata->visible = true;
	if(type == DOUBLE){
		plotdata->min = idx_min(*(static_cast<Idx<double>*>(idx)));
		plotdata->max = idx_max(*(static_cast<Idx<double>*>(idx)));
		plotdata->min_norm = idx_min(*(static_cast<Idx<double>*>(idx)));
		plotdata->max_norm = idx_max(*(static_cast<Idx<double>*>(idx)));
	}
	if(type == FLOAT){
		plotdata->min = idx_min(*(static_cast<Idx<float>*>(idx)));
		plotdata->max = idx_max(*(static_cast<Idx<float>*>(idx)));
		plotdata->min_norm = idx_min(*(static_cast<Idx<float>*>(idx)));
		plotdata->max_norm = idx_max(*(static_cast<Idx<float>*>(idx)));
	}
	if(type == INTG){
		plotdata->min = idx_min(*(static_cast<Idx<intg>*>(idx)));
		plotdata->max = idx_max(*(static_cast<Idx<intg>*>(idx)));
		plotdata->min_norm = idx_min(*(static_cast<Idx<intg>*>(idx)));
		plotdata->max_norm = idx_max(*(static_cast<Idx<intg>*>(idx)));
	}
	if(type == UBYTE){
		plotdata->min = idx_min(*(static_cast<Idx<ubyte>*>(idx)));
		plotdata->max = idx_max(*(static_cast<Idx<ubyte>*>(idx)));
		plotdata->min_norm = idx_min(*(static_cast<Idx<ubyte>*>(idx)));
		plotdata->max_norm = idx_max(*(static_cast<Idx<ubyte>*>(idx)));
	}

	plotdata->idx1_as_array = false;
	plotdata->idx3_as_RGB = false;

	printdata->pretty = true;
	printdata->elems = false;
	printdata->onfile = false;
}

idx_propgui::idx_propgui(QWidget* parent, int order):
	QDialog(parent)
{

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

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

	// 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);
	vmainLayout->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) vmainLayout->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) vmainLayout->addWidget(idx3widget);


	QGroupBox* groupbox = new QGroupBox("display properties");
	QGridLayout* gLayout = new QGridLayout();
	groupbox->setLayout(gLayout);

	maxbox = new QDoubleSpinBox(this);
	maxbox->setMaximum(999.99);
	gLayout->addWidget(new QLabel("     max : ", this), 0,0);
	gLayout->addWidget(maxbox, 0, 1);
	minbox = new QDoubleSpinBox(this);
	minbox->setMinimum(-999.99);
	gLayout->addWidget(new QLabel("     min : ", this), 1, 0);
	gLayout->addWidget(minbox, 1, 1);

	min_normval = new QLabel();
	min_normval->setEnabled(false);
	gLayout->addWidget(min_normval, 1, 2);
	max_normval = new QLabel();
	max_normval->setEnabled(false);
	gLayout->addWidget(max_normval, 0, 2);

	visiblecheck = new QCheckBox("visibility");
	gLayout->addWidget(visiblecheck, 0 , 3);
	normalcheck = new QCheckBox("normalize");
	gLayout->addWidget(normalcheck, 1, 3);

	vmainLayout->addWidget(groupbox);

	connect(normalcheck, SIGNAL(toggled(bool)), minbox, SLOT(setDisabled(bool)));
	connect(normalcheck, SIGNAL(toggled(bool)), maxbox, SLOT(setDisabled(bool)));


	QGroupBox* printbox = new QGroupBox("Printing properties");
	QGridLayout* printLayout = new QGridLayout();
	printbox->setLayout(printLayout);

	pretty = new QCheckBox("Pretty print");
	printLayout->addWidget(pretty, 0, 0);

	elems = new QCheckBox("print elems");
	printLayout->addWidget(elems, 0, 2);

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

	vmainLayout->addWidget(printbox);

	///////////////////////////////////////////////////////
	// 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 idx_propgui::set_data(idx_plotdata* plotdata, idx_printdata* printdata)
{
	zoombox->setValue(plotdata->zoom);

	arraybutton->setChecked(plotdata->idx1_as_array);
	rgbbutton->setChecked(plotdata->idx3_as_RGB);

	minbox->setValue(plotdata->min);
	maxbox->setValue(plotdata->max);
	min_normval->setNum((double)plotdata->min_norm);
	max_normval->setNum((double)plotdata->max_norm);
	visiblecheck->setChecked(plotdata->visible);
	normalcheck->setChecked(plotdata->norm);

	pretty->setChecked(printdata->pretty);
	elems->setChecked(printdata->elems);
	print_onfile->setChecked(printdata->onfile);
	fileedit->setText(printdata->file);
}

void idx_propgui::get_data(idx_plotdata* plotdata, idx_printdata* printdata)
{
	plotdata->zoom = zoombox->value();

	plotdata->idx1_as_array = arraybutton->isChecked();
	plotdata->idx3_as_RGB = rgbbutton->isChecked();

	plotdata->min = minbox->value();
	plotdata->max = maxbox->value();
	plotdata->visible = visiblecheck->isChecked();
	plotdata->norm = normalcheck->isChecked();

	printdata->pretty = pretty->isChecked();
	printdata->elems = elems->isChecked();
	printdata->onfile = print_onfile->isChecked();
	printdata->file = fileedit->text();
}

void idx_propgui::choose_file()
{
	QString fichier = QFileDialog::getOpenFileName(this, "Choose file as output", QString());
	fileedit->setText(fichier);
}


////////////////////////////////////////////////////////////////////////////
// Idx gui displaying widget related function
///////////////////////////////////////////////////////////////////////////

idx_displayGui::idx_displayGui(QWidget* parent, int NofDisplay,const char* title):
	QWidget(parent)
{
	QVBoxLayout* mainlayout = new QVBoxLayout();
	mainlayout->setMargin(1);
	setLayout(mainlayout);

	QSizePolicy policy(QSizePolicy::Expanding, QSizePolicy::Expanding);

	// scrolling display area for X
	displayer = new QWidget();
	hlayout = new QHBoxLayout();
	displayer->setLayout(hlayout);
	displayer->setSizePolicy(policy);
	scroll = new QScrollArea();
	scroll->setWidget(displayer);
	scroll->setSizePolicy(policy);

	mainlayout->addWidget(scroll);

	QLabel *labeltemp;

	// QLabels containers for displaying the different layers of X
	QLabel* label = new QLabel(title);
	label->setScaledContents(true);
	label->setSizePolicy(policy);
	hlayout->addWidget(label);
	for(int i = 0; i < NofDisplay; i++){
		labeltemp = new QLabel();
		labeltemp->setScaledContents(true);
		hlayout->addWidget(labeltemp);
		display.push_back(labeltemp);
	}

	setSizePolicy(policy);
}

void idx_displayGui::displaymatrixlayer(QLabel* container, void* matrix, idx_type type, int indexofLayer, double vmin, double vmax, double zoom, bool idx1_as_array, bool idx3_as_rgb)
{
	int dim0 = static_cast<Idx<double>*>(matrix)->dim(0);
	int dim1 = static_cast<Idx<double>*>(matrix)->dim(1);
	int dim2 = static_cast<Idx<double>*>(matrix)->dim(2);
	int order = static_cast<Idx<double>*>(matrix)->order();

	// if we try to access to a non-existant layer, error
	if((order > 2) && (indexofLayer > dim0-1) ) ylerror("non-existant layer");

	// if it is an Idx-1 and idx1_as_array is false, we plot it
	if(order == 1 && !idx1_as_array){
		QPixmap displaymap(dim0*zoom, 30*zoom);
		displaymap.fill(Qt::white);
		QPainter painter(&displaymap);