// select a gradient from the browse list
void PaletteEditor::selectGradientAction(const QModelIndex& idx)
{
if (idx.isValid())
{
if (hasUGR)
{
logFine("PaletteEditor::selectGradientAction : UGR %d", idx.row());
setPalette(ugrList[idx.row()].pa);
emit paletteChanged();
emit undoStateSignal();
}
else
{
QFileInfo file = m_browseFileList.at(idx.row());
logFine("PaletteEditor::selectGradientAction : selecting %d", idx.row());
if ((file.suffix() == "ggr" && loadGIMPGradient(file, p))
|| (file.suffix() == "cpt" && loadCPTGradient(file, p)))
{
m_gradientEnds->resetStops();
m_gradientStops->setStops(p_stops);
emit undoStateSignal();
}
else
QMessageBox::warning(this, tr("Invalid path"),
tr("The directory path %1 couldn't be opened.")
.arg(file.absoluteFilePath()), QMessageBox::NoButton);
}
}
}
void Master::onStart() {
CliArguments &args = CliArguments::getInstance();
#ifdef WIN32
m_settings = new Settings("mbedsys.org", "NodeBus", QSettings::NativeFormat);
#else
m_settings = new Settings(args.getValue("config").toString(), QSettings::NativeFormat);
#endif
m_settings->define("master/pidfile", tr("Path of the file where the service PID will be written in"),
NODEBUS_DEFAULT_PIDFILE);
m_settings->define("master/bundle-rootpath", tr("Bundle root directory path"),
NODEBUS_DEFAULT_PLUGIN_DIR_PATH);
m_settings->define("master/registry-service-name", tr("Registry service name"),
NODEBUS_DEFAULT_REGISTRY_SERVICE_NAME);
if (args.isEnabled("edit-settings")) {
m_settings->setup();
throw ExitApplicationException();
}
QString path = m_settings->value("master/bundle-rootpath").toString();
QDirIterator it(path, QStringList("*.so"), QDir::Files, QDirIterator::Subdirectories);
logFiner() << "Search for bundles in the directory " << path;
while (it.hasNext()) {
QString file = it.next();
logFinest() << "Found file " << file;
try {
BundlePtr bundle = new Bundle(file);
m_bundles[bundle->property("Bundle-SymbolicName").toString()] = bundle;
logFine() << "Found bundle " << bundle->property("Bundle-Name") << " (" << bundle->property("Bundle-SymbolicName") << ')';
} catch (Exception &e) {
logWarn() << "Invalid bundle file " << file << " (" << e.message() << ')';
}
}
if (m_bundles.isEmpty()) {
throw ApplicationException("No valid bundle found in the directory " + path);
}
}
void RenderThread::render(RenderRequest* req)
{
logFiner(QString("RenderThread::render : req 0x%1").arg((long)req,0,16));
if (req->type() == RenderRequest::Preview)
{
preview_request = req;
// rendering a preview preempts everything except files and previews
if (isRendering())
switch (current_request->type())
{
case RenderRequest::Image:
case RenderRequest::Queued:
stopRendering();
default:
;
}
}
else if (req->type() == RenderRequest::Image)
image_request = req;
else if (request_queue.contains(req))
logWarn(QString("RenderThread::render : req 0x%1 already queued")
.arg((long)req,0,16));
else
{
logFine("RenderThread::render : queueing req %#x", (long)req);
req->setFinished(false);
rqueue_mutex.lock();
request_queue.enqueue(req);
rqueue_mutex.unlock();
}
}
void PeerAdmin::run() {
try {
while (m_enabled) {
if (m_selector.select() && m_enabled) {
auto list = m_selector.selectedKeys();
for(auto it = list.begin(); it != list.end(); it++) {
SelectionKeyPtr key = *it;
if (!key->isValid()) {
continue;
}
if (key->channel().instanceof<ServerSocketChannel>()) {
processServer(key->channel(), key->attachment());
} else if (key->channel().instanceof<SocketChannel>()) {
processPeer(key->attachment());
}
}
}
}
} catch (ParserException &e) {
if (m_enabled) {
logFine() << __demangle(typeid(*this).name()) << " leaving main loop normally";
} else {
logCrit() << __demangle(typeid(*this).name()) << " leaving main loop after throwing an instance of '" << __demangle(typeid(e).name()) << "'";
if (!e.message().isEmpty())
logCrit() << " what(): " << e.message();
}
} catch (Exception &e) {
logCrit() << __demangle(typeid(*this).name()) << " leaving main loop after throwing an instance of '" << __demangle(typeid(e).name()) << "'";
if (!e.message().isEmpty())
logCrit() << " what(): " << e.message();
}
cancel();
}
// open a and parse a directory containing gimp gradient files
void PaletteEditor::openGradientAction(bool noprompt)
{
logFine(QString("PaletteEditor::openGradientAction : %1").arg(noprompt));
QString openDir;
if (noprompt)
{
openDir = m_lastBrowseDir;
m_lastBrowseDir.clear();
}
else
{
openDir = QFileDialog::getOpenFileName(this,
tr("Select a gradient file to load"),
QFileInfo(m_lastBrowseDir).absoluteFilePath(),
tr("Gradient Files (*.cpt *.ggr *.ugr)"));
}
if (openDir.isEmpty())
return;
if (openDir != m_lastBrowseDir)
m_lastBrowseDir = openDir;
if (openDir.indexOf(QRegExp(".*\\.ugr$")) >= 0)
{
logFine(QString("PaletteEditor::openGradientAction : ugr %1").arg(openDir));
QFileInfo ugrFile(openDir);
if (ugrFile.exists())
{
loadUGRGradients(ugrFile);
QSize s = m_browseView->iconSize();
QImage palette(s.width(), s.height(), QImage::Format_RGB32);
QPainter painter(&palette);
m_browsePalettes.clear();
foreach (flam3_palette_t t, ugrList)
{
for (int n = 0 ; n < 256 ; n++)
{
painter.setPen(QColor::fromRgbF(t.pa[n].color[0], t.pa[n].color[1], t.pa[n].color[2]));
painter.drawLine(n, 0, n, s.height());
}
m_browsePalettes.addGradient(QPixmap::fromImage(palette));
}
hasUGR=true;
m_browseLineEdit->setText(m_lastBrowseDir);
}
void RenderThread::cancel(RenderRequest* req)
{
if (req->type() == RenderRequest::Queued)
{
rqueue_mutex.lock();
int count = request_queue.removeAll(req);
logFine("RenderThread::cancel : removing %d queued requests", count);
rqueue_mutex.unlock();
}
else if (req->type() == RenderRequest::Preview)
preview_request = 0;
else if (req->type() == RenderRequest::Image)
image_request = 0;
else
logWarn("RenderThread::cancel : unknown request type %d", (int)req->type());
}
void MotionViewItemDelegate::setModelData(QWidget* editor, QAbstractItemModel* model, const QModelIndex& index ) const
{
logFine(QString("MotionViewItemDelegate::setModelData : %1,%2").arg(index.row()).arg(index.column()));
QStandardItemModel* m = qobject_cast<QStandardItemModel*>(model);
if (index.column() == 0 || index.column() == 2)
{
QComboBox* box = qobject_cast<QComboBox*>(editor);
m->itemFromIndex(index)->setText(box->currentText());
}
else if (index.column() == 1)
{
DoubleValueEditor* e = qobject_cast<DoubleValueEditor*>(editor);
m->itemFromIndex(index)->setText(QString::number(e->value()));
}
else if (index.column() == 3)
{
IntValueEditor* e = qobject_cast<IntValueEditor*>(editor);
m->itemFromIndex(index)->setText(QString::number(e->value()));
}
}
void RenderThread::run()
{
logInfo("RenderThread::run : starting thread");
while (running)
{
running_mutex.lock();
RenderRequest* job;
if (preview_request != 0)
{
job = preview_request;
preview_request = 0;
}
else if (image_request != 0)
{
job = image_request;
image_request = 0;
}
else
{
rqueue_mutex.lock();
if (request_queue.isEmpty())
{
// sleep only after checking for requests
current_request = 0;
rqueue_mutex.unlock();
running_mutex.unlock();
usleep(10000);
continue;
}
else
{
job = request_queue.dequeue();
logFine("RenderThread::run : dequeueing request %#x", (long)job);
rqueue_mutex.unlock();
}
}
render_loop_flag = true;
current_request = job;
// make sure there is something to calculate
bool no_pos_xf = true;
for (flam3_xform* xf = job->genome()->xform ;
xf < job->genome()->xform + job->genome()->num_xforms ; xf++)
if (xf->density > 0.0)
{
no_pos_xf = false;
break;
}
if (no_pos_xf)
{
logWarn(QString("RenderThread::run : no xform in request 0x%1").arg((long)job,0,16));
running_mutex.unlock();
continue;
}
logFiner(QString("RenderThread::run : rendering request 0x%1").arg((long)job,0,16));
rtype = job->name();
flame.time = job->time();
flame.ngenomes = job->numGenomes();
flam3_genome* genomes = new flam3_genome[flame.ngenomes]();
flam3_genome* job_genome = job->genome();
for (int n = 0 ; n < flame.ngenomes ; n++)
flam3_copy(genomes + n, job_genome + n);
flame.genomes = genomes;
QSize imgSize(job->size());
if (!imgSize.isEmpty())
{
for (int n = 0 ; n < flame.ngenomes ; n++)
{
flam3_genome* genome = genomes + n;
// scale images, previews, etc. if necessary
int width = genome->width;
genome->width = imgSize.width();
genome->height = imgSize.height();
// "rescale" the image scale to maintain the camera
// for smaller/larger image size
genome->pixels_per_unit /= ((double)width) / genome->width;
}
}
// Load image quality settings for Image, Preview, and File types
switch (job->type())
{
case RenderRequest::File:
rtype = QFileInfo(job->name()).fileName();
case RenderRequest::Image:
case RenderRequest::Preview:
case RenderRequest::Queued:
{
const flam3_genome* g = job->imagePresets();
if (g->nbatches > 0) // valid quality settings for nbatches > 0
for (int n = 0 ; n < flame.ngenomes ; n++)
{
flam3_genome* genome = genomes + n;
genome->sample_density = g->sample_density;
genome->spatial_filter_radius = g->spatial_filter_radius;
genome->spatial_oversample = g->spatial_oversample;
genome->nbatches = g->nbatches;
genome->ntemporal_samples = g->ntemporal_samples;
genome->estimator = g->estimator;
genome->estimator_curve = g->estimator_curve;
genome->estimator_minimum = g->estimator_minimum;
}
}
default:
;
}
// add symmetry xforms before rendering
for (int n = 0 ; n < flame.ngenomes ; n++)
{
flam3_genome* genome = genomes + n;
if (genome->symmetry != 1)
flam3_add_symmetry(genome, genome->symmetry);
}
int msize = channels * genomes->width * genomes->height;
unsigned char* out = new unsigned char[msize];
unsigned char* head = out;
logFine("RenderThread::run : allocated %d bytes, rendering...", msize);
init_status_cb();
rendering = true;
ptimer.start();
int rv = flam3_render(&flame, out, 0, channels, alpha_trans, &_stats);
millis = ptimer.elapsed();
rendering = false;
render_loop_flag = false;
if (_stop_current_job) // if stopRendering() is called
{
logFine(QString("RenderThread::run : %1 rendering stopped").arg(rtype));
delete[] head;
for (int n = 0 ; n < flame.ngenomes ; n++)
clear_cp(genomes + n, flam3_defaults_off);
delete[] genomes;
if (kill_all_jobs)
{
preview_request = 0;
image_request = 0;
rqueue_mutex.lock();
request_queue.clear();
rqueue_mutex.unlock();
kill_all_jobs = false;
emit flameRenderingKilled();
}
else
if (job->type() == RenderRequest::Queued)
{
logFine("RenderThread::run : re-adding queued request");
rqueue_mutex.lock();
request_queue.prepend(job);
rqueue_mutex.unlock();
}
_stop_current_job = false;
running_mutex.unlock();
continue;
}
QSize buf_size(genomes->width, genomes->height);
if (img_format == RGB32)
{
if (buf_size != img_buf.size())
img_buf = QImage(buf_size, QImage::Format_RGB32);
if (rv == 0)
{
for (int h = 0 ; h < genomes->height ; h++)
for (int w = 0 ; w < genomes->width ; w++, out += channels)
img_buf.setPixel(QPoint(w, h), qRgb(out[0], out[1], out[2]));
}
else
img_buf.fill(0);
}
else
{
if (buf_size != img_buf.size())
img_buf = QImage(buf_size, QImage::Format_ARGB32);
if (rv == 0)
{
for (int h = 0 ; h < genomes->height ; h++)
for (int w = 0 ; w < genomes->width ; w++, out += channels)
img_buf.setPixel(QPoint(w, h), qRgba(out[0], out[1], out[2], out[3]));
}
else
img_buf.fill(0);
}
delete[] head;
for (int n = 0 ; n < flame.ngenomes ; n++)
clear_cp(genomes + n, flam3_defaults_off);
delete[] genomes;
if (job->type() == RenderRequest::File)
img_buf.save(job->name(), "png", 100);
job->setImage(img_buf);
job->setFinished(true);
// look for a free event
RenderEvent* event = 0;
foreach (RenderEvent* e, event_list)
if (e->accepted())
{
e->accept(false);
event = e;
break;
}
if (!event)
{
logFinest(QString("RenderThread::run : adding event"));
event = new RenderEvent();
event->accept(false);
event_list.append(event);
}
logFiner(QString("RenderThread::run : event list size %1")
.arg(event_list.size()));
event->setRequest(job);
emit flameRendered(event);
logFiner(QString("RenderThread::run : finished"));
running_mutex.unlock();
}
logInfo("RenderThread::run : thread exiting");
}
