mitsuba/src/qtgui/rendersettingsdlg.cpp

#include "rendersettingsdlg.h"
#include "ui_rendersettingsdlg.h"
#include <mitsuba/core/plugin.h>

/* ====================== Some helper routines ====================== */

static void setComboBox(QComboBox *box, const std::string &pluginName) {
	for (int i=0; i<box->count(); ++i) {
		const QList<QVariant> &data = box->itemData(i).toList();
		if (data.at(2) == pluginName.c_str()) {
			box->setCurrentIndex(i);
			return;
		}
	}
	SLog(EError, "Unable to find combo box entry named \"%s\"", pluginName.c_str());
}

static std::string getPluginName(QComboBox *box) {
	return box->itemData(box->currentIndex()).toList().at(2).toString().toStdString();
}

/* ====================== RenderSettingsDialog impl ====================== */

RenderSettingsDialog::RenderSettingsDialog(QWidget *parent) :
		QDialog(parent, Qt::Sheet),
	ui(new Ui::RenderSettingsDialog), m_icNode(NULL), m_aiNode(NULL) {
	ui->setupUi(this);

	connect(ui->integratorBox, SIGNAL(highlighted(int)), SLOT(cbHighlighted(int)));
	connect(ui->integratorBox, SIGNAL(activated(int)), SLOT(update()));
	connect(ui->samplerBox, SIGNAL(highlighted(int)), SLOT(cbHighlighted(int)));
	connect(ui->samplerBox, SIGNAL(activated(int)), SLOT(update()));
	connect(ui->rFilterBox, SIGNAL(highlighted(int)), SLOT(cbHighlighted(int)));
	connect(ui->rFilterBox, SIGNAL(activated(int)), SLOT(update()));
	connect(ui->icBox, SIGNAL(pressed()), SLOT(chkBoxPressed()));
	connect(ui->aiBox, SIGNAL(pressed()), SLOT(chkBoxPressed()));
	connect(ui->icBox, SIGNAL(toggled(bool)), SLOT(update()));
	connect(ui->aiBox, SIGNAL(toggled(bool)), SLOT(update()));
	connect(ui->resolutionBox, SIGNAL(activated(int)), SLOT(refresh()));
	connect(ui->resolutionBox, SIGNAL(editTextChanged(const QString &)), SLOT(refresh()));

	QFile file(":/resources/docs.xml");
	if (!file.open(QIODevice::ReadOnly) || !m_document.setContent(&file))
		SLog(EError, "Unable to read the documentation file!");
	file.close();

	/* Populate the integrator, rec. filter & sampler combo box widgets */
	QDomElement docRoot = m_document.documentElement();
	for (QDomElement e = docRoot.firstChildElement("plugin"); !e.isNull();
		 e = e.nextSiblingElement("plugin")) {
		QString docString, name = e.attribute("name");
		if (!e.firstChildElement("descr").isNull()) {
			/* Create a HTML-based documentation string */
			QDomDocument helpDoc;
			QDomElement root = helpDoc.createElement("p");
			helpDoc.appendChild(root);

			for (QDomNode child = e.firstChildElement("descr").firstChild();
			   !child.isNull(); child = child.nextSibling())
			root.appendChild(helpDoc.importNode(child, true));
			docString = helpDoc.toString();
		}

		if (e.hasAttribute("show") && e.attribute("show") == "true") {
			QString type = e.attribute("type"),
					className = e.attribute("className"),
					readableName = e.attribute("readableName"),
					name = e.attribute("name");

			QList<QVariant> list;
			list.append(className);
			list.append(docString);
			list.append(name);

			if (type == "integrator")
				ui->integratorBox->addItem(readableName, list);
			else if (type == "sampler")
				ui->samplerBox->addItem(readableName, list);
			else if (type == "rfilter")
				ui->rFilterBox->addItem(readableName, list);
		}
		if (name == "irrcache")
			ui->icBox->setProperty("help", docString);
		else if (name == "errctrl")
			ui->aiBox->setProperty("help", docString);
	}

	m_model = new XMLTreeModel(docRoot, palette(), this);
	ui->treeView->setModel(m_model);
	ui->treeView->setAlternatingRowColors(true);
	ui->treeView->setUniformRowHeights(true);
	ui->treeView->setColumnWidth(0, 270);
	ui->treeView->setItemDelegate(new PropertyDelegate(this));
	connect(ui->treeView->selectionModel(), SIGNAL(selectionChanged(const QItemSelection &, const QItemSelection)), 
		SLOT(onTreeSelectionChange(const QItemSelection &, const QItemSelection &)));
	connect(m_model, SIGNAL(dataChanged(const QModelIndex&, const QModelIndex&)), this, SLOT(dataChanged()));
	m_integratorNode = m_model->registerClass("MIPathTracer", "Path tracer");
	m_samplerNode = m_model->registerClass("IndependentSampler", "Independent sampler");
	m_rFilterNode = m_model->registerClass("BoxFilter", "Box filter");
	QRegExp resRegExp("^[1-9]\\d{0,4}x[1-9]\\d{0,4}$");
	ui->resolutionBox->setValidator(new QRegExpValidator(resRegExp, this));
	QPalette pal = ui->helpViewer->palette();
	pal.setColor(QPalette::Text, pal.color(QPalette::Foreground));
	pal.setColor(QPalette::Base, pal.color(QPalette::Window));
	ui->helpViewer->setPalette(pal);
}
	
void RenderSettingsDialog::setDocumentation(const QString &text) {
	m_currentDocumentation = text;
	bool hasErrors = false;
	QString comments;

	if (m_statusMessages.size() > 0) {
		comments = QString("<ul style=\"margin:0px;\">");
		ui->groupBox->setTitle(tr("Issues with the current configuration"));
		for (int i=0; i<m_statusMessages.size(); ++i) {
			const QString &message = m_statusMessages[i];
			bool isWarning = false, isError = false;

			if (message.contains("Warning"))
				isWarning = true;
			if (message.contains("Error"))
				isError = true;

			if (isError || isWarning)
				comments += QString("<li><em>%1</em></li>").arg(message);
			else
				comments += QString("<li>%1</li>").arg(message);
			hasErrors |= isError;
		}
		comments += "</ul>";
	} else {
		ui->groupBox->setTitle(tr("Documentation"));
	}

	ui->helpViewer->setHtml(comments + m_currentDocumentation);
   	ui->buttonBox->button(QDialogButtonBox::Ok)->setEnabled(!hasErrors);
}

void RenderSettingsDialog::dataChanged() {
	QStringList statusMessages = validateConfiguration();
	if (statusMessages != m_statusMessages) {
		m_statusMessages = statusMessages;
		setDocumentation(m_currentDocumentation);
	}
}


void RenderSettingsDialog::cbHighlighted(int index) {
	QComboBox *comboBox = static_cast<QComboBox *>(sender());
	setDocumentation(comboBox->itemData(index).toList().at(1).toString());
}

void RenderSettingsDialog::chkBoxPressed() {
	QCheckBox *checkBox = static_cast<QCheckBox *>(sender());
	setDocumentation(checkBox->property("help").toString());
}

void RenderSettingsDialog::onTreeSelectionChange(const QItemSelection &selected, const QItemSelection &deselected) {
	QModelIndexList indexList = selected.indexes();
	if (indexList.size() > 0)
		setDocumentation(m_model->data(indexList[0], Qt::ToolTipRole).toString());
}

void RenderSettingsDialog::update() {
	int index = ui->integratorBox->currentIndex();

	int sampleCount = -1;
	if (sender() == ui->samplerBox) {
		Properties samplerProps;
		m_samplerNode->putProperties(samplerProps);
		if (samplerProps.hasProperty("sampleCount"))
			sampleCount = samplerProps.getInteger("sampleCount");
		else if (samplerProps.hasProperty("resolution"))
			sampleCount = (int) std::pow((Float) samplerProps.getInteger("resolution"), (Float) 2);
	}
	
	m_integratorNode = m_model->updateClass(m_integratorNode,
		ui->integratorBox->itemData(index).toList().at(0).toString(),
		ui->integratorBox->itemText(index));
	index = ui->samplerBox->currentIndex();
	m_samplerNode = m_model->updateClass(m_samplerNode,
		ui->samplerBox->itemData(index).toList().at(0).toString(),
		ui->samplerBox->itemText(index));
	index = ui->rFilterBox->currentIndex();
	m_rFilterNode = m_model->updateClass(m_rFilterNode,
		ui->rFilterBox->itemData(index).toList().at(0).toString(),
		ui->rFilterBox->itemText(index));

	if (ui->icBox->isChecked()) {
		m_icNode = m_model->updateClass(m_icNode,
			"IrradianceCacheIntegrator", tr("Irradiance Cache"));
	} else {
		m_icNode = m_model->updateClass(m_icNode, "", "");
	}

	if (ui->aiBox->isChecked()) {
		m_aiNode = m_model->updateClass(m_aiNode,
			"ErrorControl", tr("Adaptive Integration"));
	} else {
		m_aiNode = m_model->updateClass(m_aiNode, "", "");
	}

	if (sender() == ui->samplerBox && sampleCount != -1) {
		std::string samplerPlugin = getPluginName(ui->samplerBox);
		for (int i=0; i<m_samplerNode->childCount(); ++i) {
			TreeItem *treeItem = m_samplerNode->child(i);
			if (treeItem->getName() == "sampleCount") {
				treeItem->setValue(sampleCount);
			} else if (treeItem->getName() == "resolution") {
				treeItem->setValue((int) std::sqrt((Float) sampleCount));
			}
		}
	}

	ui->treeView->expandAll();
	dataChanged();
}

bool RenderSettingsDialog::resolutionHasChanged() const {
	return ui->resolutionBox->currentText() != m_originalResolution;
}

void RenderSettingsDialog::refresh() {
	bool valid = true;
	int pos;

	QString resolutionString(ui->resolutionBox->currentText());
	valid &= ui->resolutionBox->validator()->validate(resolutionString,pos)
		== QValidator::Acceptable;

	ui->buttonBox->button(QDialogButtonBox::Ok)->setEnabled(valid);
}

void RenderSettingsDialog::load(const SceneContext *ctx) {
	const Scene *scene = ctx->scene.get();
	const Film *film = scene->getFilm();
	const Properties &rFilterProps = film->getReconstructionFilter()->getProperties();
	const Properties &samplerProps = scene->getSampler()->getProperties();
	const Integrator *integrator = scene->getIntegrator();
	Properties integratorProps = integrator->getProperties();

	if (integratorProps.getPluginName() == "errctrl") {
		ui->aiBox->setChecked(true);
		m_model->setProperties(m_aiNode, integratorProps);
		integrator = integrator->getSubIntegrator();
		integratorProps = integrator->getProperties();
	}

	if (integratorProps.getPluginName() == "irrcache") {
		ui->icBox->setChecked(true);
		m_model->setProperties(m_icNode, integratorProps);
		integrator = integrator->getSubIntegrator();
		integratorProps = integrator->getProperties();
	}

	ui->resolutionBox->lineEdit()->setText(QString("%1x%2")
		.arg(film->getSize().x).arg(film->getSize().y));
	m_originalResolution = ui->resolutionBox->lineEdit()->text();

	setComboBox(ui->integratorBox, integratorProps.getPluginName());
	setComboBox(ui->rFilterBox, rFilterProps.getPluginName());
	setComboBox(ui->samplerBox, samplerProps.getPluginName());
	update();

	m_model->setProperties(m_rFilterNode, rFilterProps);
	m_model->setProperties(m_samplerNode, samplerProps);
	m_model->setProperties(m_integratorNode, integratorProps);
	ui->treeView->expandAll();
}

void RenderSettingsDialog::apply(SceneContext *ctx) {
	Scene *scene = new Scene(ctx->scene);
	const PinholeCamera *oldCamera = static_cast<const PinholeCamera *>(scene->getCamera());
	Properties filmProps = oldCamera->getFilm()->getProperties();
	ref<PluginManager> pluginMgr = PluginManager::getInstance();

	/* Configure the reconstruction filter */
	Properties rFilterProps(getPluginName(ui->rFilterBox));
	if (m_rFilterNode != NULL) 
		m_rFilterNode->putProperties(rFilterProps);
	ref<ReconstructionFilter> rFilter = static_cast<ReconstructionFilter *> 
		(pluginMgr->createObject(ReconstructionFilter::m_theClass, rFilterProps));

	/* Configure the sampler */
	Properties samplerProps(getPluginName(ui->samplerBox));
	if (m_samplerNode != NULL) 
		m_samplerNode->putProperties(samplerProps);
	ref<Sampler> sampler = static_cast<Sampler *> 
		(pluginMgr->createObject(Sampler::m_theClass, samplerProps));
	sampler->configure();
	
	/* Configure the integrator */
	Properties integratorProps(getPluginName(ui->integratorBox));
	if (m_integratorNode != NULL) 
		m_integratorNode->putProperties(integratorProps);
	ref<Integrator> integrator = static_cast<Integrator *> 
		(pluginMgr->createObject(Integrator::m_theClass, integratorProps));
	integrator->configure();

	if (ui->icBox->isChecked()) {
		Properties icProps("irrcache");
		if (m_icNode != NULL) 
			m_icNode->putProperties(icProps);
		ref<Integrator> ic = static_cast<Integrator *> 
			(pluginMgr->createObject(Integrator::m_theClass, icProps));
		ic->addChild("", integrator);
		ic->configure();
		integrator = ic;
	}

	if (ui->aiBox->isChecked()) {
		Properties aiProps("errctrl");
		if (m_aiNode != NULL) 
			m_aiNode->putProperties(aiProps);
		ref<Integrator> ai = static_cast<Integrator *> 
			(pluginMgr->createObject(Integrator::m_theClass, aiProps));
		ai->addChild("", integrator);
		ai->configure();
		integrator = ai;
	}

	/* Configure the film */
	QStringList resolution = ui->resolutionBox->currentText().split('x');
	SAssert(resolution.size() == 2);
	int width = resolution[0].toInt(), height = resolution[1].toInt();
	filmProps.setInteger("width", width, false);
	filmProps.setInteger("height", height, false);
	ref<Film> film = static_cast<Film *> (pluginMgr->createObject(Film::m_theClass, filmProps));
	film->addChild("", rFilter);
	film->configure();
	if (width != ctx->framebuffer->getWidth() ||
		height != ctx->framebuffer->getHeight()) {
		ctx->framebuffer = new Bitmap(width, height, 128);
		ctx->framebuffer->clear();
		ctx->mode = EPreview;
	}

	/* Configure the camera */
	Properties cameraProps = oldCamera->getProperties();
	ref<PinholeCamera> camera = static_cast<PinholeCamera *> 
		(pluginMgr->createObject(Camera::m_theClass, cameraProps));
	camera->addChild("", sampler);
	camera->addChild("", film);
	camera->setViewTransform(oldCamera->getViewTransform());
	camera->setFov(oldCamera->getFov());
	camera->configure();
	
	/* Update the scene with the newly constructed elements */
	scene->setCamera(camera);
	scene->setSampler(sampler);
	scene->setIntegrator(integrator);
	scene->configure();

	ctx->scene = scene;
}

RenderSettingsDialog::~RenderSettingsDialog() {
	delete ui;
}

void RenderSettingsDialog::changeEvent(QEvent *e) {
    QDialog::changeEvent(e);
    switch (e->type()) {
    case QEvent::LanguageChange:
		ui->retranslateUi(this);
        break;
    default:
        break;
    }
}

/* ====================== PropertyDelegate impl ====================== */

PropertyDelegate::PropertyDelegate(QObject *parent) : QStyledItemDelegate(parent) {
}

PropertyDelegate::~PropertyDelegate() {
}

QString	PropertyDelegate::displayText(const QVariant &value, const QLocale &locale) const {
	if (value.type() == QVariant::Bool)
		return value.toBool() ? tr("Yes") : tr("No");
	return QStyledItemDelegate::displayText(value, locale);
}

QWidget *PropertyDelegate::createEditor(QWidget *parent, const QStyleOptionViewItem &option,
		const QModelIndex &index) const {
	if (index.data().type() == QVariant::Bool) {
		QComboBox *cbox = new QComboBox(parent);
		/* Nicer boolean editor -- by default, Qt creates a True/False combo box */
		cbox->addItem(tr("No"));
		cbox->addItem(tr("Yes"));
		return cbox;
	}
	QWidget *widget = QStyledItemDelegate::createEditor(parent, option, index);
#if defined(__OSX__)
	/* Don't draw focus halos on OSX, they're really distracting */
	if (widget != NULL && widget->testAttribute(Qt::WA_MacShowFocusRect))
		widget->setAttribute(Qt::WA_MacShowFocusRect, false);
	if (index.data().type() != QVariant::Bool) {
		widget->setAttribute(Qt::WA_MacMiniSize, true);
		widget->setStyleSheet("font-size: 13pt;");
	}
#endif
	return widget;
}

void PropertyDelegate::setEditorData(QWidget *editor, const QModelIndex &index) const {
	if (index.data().type() == QVariant::Bool) {
		QComboBox *cbox = static_cast<QComboBox *>(editor);
		cbox->setCurrentIndex(index.data().toBool() ? 1 : 0);
		return;
	}

	QStyledItemDelegate::setEditorData(editor, index);
}

void PropertyDelegate::setModelData(QWidget *editor, QAbstractItemModel *model,
	const QModelIndex &index) const {
	if (index.data().type() == QVariant::Bool) {
		QComboBox *cbox = static_cast<QComboBox *>(editor);
		model->setData(index, QVariant(cbox->currentIndex() == 1), Qt::EditRole);
		return;
	}
	QStyledItemDelegate::setModelData(editor, model, index);
}

void PropertyDelegate::updateEditorGeometry(QWidget *editor,
	const QStyleOptionViewItem &option, const QModelIndex &index) const {
	if (index.data().type() == QVariant::Bool) {
		editor->setGeometry(option.rect);
		return;
	}

	QStyledItemDelegate::updateEditorGeometry(editor, option, index);
}

QStringList RenderSettingsDialog::validateConfiguration() const {
	/* Ad-hoc verification until we have something better 
	   (preferably specifiable by the plugins themselves) */
	QStringList messages;
	std::string integratorName = getPluginName(ui->integratorBox);
	std::string samplerName = getPluginName(ui->samplerBox);
	Properties integratorProps, samplerProps;
	m_integratorNode->putProperties(integratorProps);
	m_samplerNode->putProperties(samplerProps);

	if (samplerName != "independent") {
		if (integratorName == "ptracer" || integratorName == "mlt" || integratorName == "kelemen")
			messages << "Error: This integrator requires the independent sampler.";
		if (ui->aiBox->isChecked())
			messages << "Error: Adaptive integration requires the independent sampler.";
	}
	if (ui->icBox->isChecked()) {
		if (integratorName != "direct" && integratorName != "path" && integratorName != "volpath" && integratorName != "volpath_simple" && integratorName != "photonmapper")
			messages << "Error: Irradiance Caching requires a sampling-based integrator.";

	}
	if (ui->aiBox->isChecked()) {
		if (integratorName != "direct" && integratorName != "path" && integratorName != "volpath" && integratorName != "volpath_simple" && integratorName != "photonmapper")
			messages << "Error: Adaptive integration requires a sampling-based integrator.";
	}
	if (integratorName == "ppm") {
		if ((samplerName == "independent" || samplerName == "ldsampler") && samplerProps.hasProperty("sampleCount")) {
			if (samplerProps.getInteger("sampleCount") > 4)
				messages << "Warning: are you sure you need more than 4 samples/pixel for progressive photon mapping? This will be slow..";
		} else if (samplerName == "stratified" && samplerProps.hasProperty("resolution")) {
			if (samplerProps.getInteger("resolution") > 2)
				messages << "Warning: are you sure you need more than 4 samples/pixel for progressive photon mapping? This will be slow..";
		}
	}
	return messages;
}