QFrame* Viewer::createCentralWidget()
{
QFrame* frame = new QFrame(this);
grid = new QGridLayout(frame);
grid->setSpacing(8);
grid->setMargin(4);
layout()->setSizeConstraint(QLayout::SetFixedSize);
QSize labelSize(256, 256);
finalWidget = new FinalWidget(frame, tr("Final image"), labelSize);
cyanWidget = new ScreenWidget(frame, Qt::cyan, tr("Cyan"),
ScreenWidget::Cyan, labelSize);
magentaWidget = new ScreenWidget(frame, Qt::magenta, tr("Magenta"),
ScreenWidget::Magenta, labelSize);
yellowWidget = new ScreenWidget(frame, Qt::yellow, tr("Yellow"),
ScreenWidget::Yellow, labelSize);
connect(cyanWidget, SIGNAL(imageChanged()), this, SLOT(createImage()));
connect(magentaWidget, SIGNAL(imageChanged()), this, SLOT(createImage()));
connect(yellowWidget, SIGNAL(imageChanged()), this, SLOT(createImage()));
grid->addWidget(finalWidget, 0, 0, Qt::AlignTop | Qt::AlignHCenter);
grid->addWidget(cyanWidget, 0, 1, Qt::AlignTop | Qt::AlignHCenter);
grid->addWidget(magentaWidget, 1, 0, Qt::AlignTop | Qt::AlignHCenter);
grid->addWidget(yellowWidget, 1, 1, Qt::AlignTop | Qt::AlignHCenter);
return frame;
}
void MainWindow::open(std::unique_ptr<Project> project) {
assert(project);
project_ = std::move(project);
imageChanged();
instructionsChanged();
treeChanged();
/* Log messages to the log window. */
project_->setLogToken(logToken_);
/* Connect the project to the slots for updating views. */
connect(project_.get(), SIGNAL(nameChanged()), this, SLOT(updateGuiState()));
connect(project_.get(), SIGNAL(imageChanged()), this, SLOT(imageChanged()));
connect(project_.get(), SIGNAL(instructionsChanged()), this, SLOT(instructionsChanged()));
connect(project_.get(), SIGNAL(treeChanged()), this, SLOT(treeChanged()));
/* Connect the project to the progress dialog. */
connect(project_->commandQueue(), SIGNAL(nextCommand()), this, SLOT(updateGuiState()));
connect(project_->commandQueue(), SIGNAL(idle()), this, SLOT(updateGuiState()));
connect(progressDialog_, SIGNAL(canceled()), project_.get(), SLOT(cancelAll()));
/* Delegate "Cancel All" to the project. */
connect(cancelAllAction_, SIGNAL(triggered()), project_.get(), SLOT(cancelAll()));
updateGuiState();
}
MainWindow::MainWindow(QWidget *parent) :
QMainWindow(parent)
{
viewer = new PicManager(this);
setCentralWidget(viewer);
viewer->installEventFilter(this);
wasMaximized = false;
slideInterval = 4000;
slideTimer = new QTimer(this);
slideTimer->setInterval(slideInterval);
//! if file numbers is 0 or 1, stop timer???......................
connect(slideTimer, SIGNAL(timeout()), viewer, SLOT(nextPic()));
connect(viewer, SIGNAL(imageChanged(QString)), SLOT(imageChanged(QString)));
initContextMenu();
initButtomBar();
initSwitchFrame();
registerAllFunction();
resize(Config::WindowFitSize);
QRect rect = QApplication::desktop()->availableGeometry();
QPoint pos = QPoint((rect.width() - Config::WindowFitSize.width()) / 2 + rect.left(),
(rect.height() - Config::WindowFitSize.height()) / 2 + rect.top());
move(pos); // show this window in the center of Desktop
readSettings();
Config::insertConfigWatcher(this, SLOT(applyConfig()));
imageChanged();
setWindowIcon(QIcon(":/appIcon"));
setAcceptDrops(true); //! !!
}
OpenSearchEngineAction::OpenSearchEngineAction(OpenSearchEngine *engine, QObject *parent)
: QAction(parent)
, m_engine(engine)
{
setText(engine->name());
imageChanged();
connect(engine, SIGNAL(imageChanged()), this, SLOT(imageChanged()));
}
void ImageModel::updateRows(const QModelIndex &, int start, int end)
{
for (int row = start; row <= end; ++row) {
QJsonValue rowData = EnginioModel::data(index(row)).value<QJsonValue>();
QString id = rowData.toObject().value("id").toString();
if (id.isEmpty() || m_images.contains(id))
continue;
ImageObject *image = new ImageObject(client());
connect(image, SIGNAL(imageChanged(QString)), this, SLOT(imageChanged(QString)));
m_images.insert(id, image);
image->setObject(rowData.toObject());
QModelIndex changedIndex = index(row);
emit dataChanged(changedIndex, changedIndex);
}
}
void Monitor::setCvCapture(CvCapture* c)
{
int w, h, bpp;
if(c)
reset();
mCvCapture = c;
if(c)
{
cvSetCaptureProperty(mCvCapture, CV_CAP_PROP_POS_FRAMES, mCurrentFrameNumber);
IplImage *im = cvQueryFrame(mCvCapture);
w = im->width;
h = im->height;
bpp = im->nChannels;
lockImages();
mCurrImage = new QImage(w, h, QImage::Format_ARGB32);
convertRGB2ARGB(im, mCurrImage);
releaseImages();
mInputType = AviFile;
mFirstFrameNumber = 0;
mLastFrameNumber = cvGetCaptureProperty(mCvCapture, CV_CAP_PROP_FRAME_COUNT) - 1;
mInitialized = true;
emit imageChanged();
}
}
void FilteredImage::setSource(const QString &source)
{
if(m_source != source)
{
m_source = source;
QImageReader ir(m_source);
QByteArray format(ir.format());
m_image = ir.read();
NemoImageMetadata meta(m_source, format);
if (meta.orientation() != NemoImageMetadata::TopLeft)
{
m_image = rotate(m_image, meta.orientation());
}
setImplicitWidth((qreal)m_image.width());
setImplicitHeight((qreal)m_image.height());
m_imageChanged = true;
emit sourceChanged(m_source);
emit imageChanged(m_image);
}
}
void PicManager::readFile(const QString &fullPath)
{
QFileInfo fileInfo(fullPath);
if(curPath == fileInfo.absoluteFilePath() )//! if the image needs refresh?
return;
curPath = fileInfo.absoluteFilePath();
curName = fileInfo.fileName();
curImage->recycle();
curImage = ImageFactory::getImageWrapper(curPath);
if(curImage->isAnimation()) {
connect(curImage, SIGNAL(animationUpdated()), SLOT(updateAnimation()));
curImage->startAnimation();
} else if (curImage->frameCount() > 1){ // like ico format
connect(curImage, SIGNAL(frameUpdated()), SLOT(updateImage()));
}
QImage image = curImage->currentImage();
QString errorMsg = image.isNull() ? Global::LoadFileErrorInfo().arg(curPath)
: QString::null;
loadImage(image, errorMsg);
// state = image.isNull() ? FileNoPicture : FilePicture;
emit imageChanged(curName);
}
// The constructor for the line object
GLEText::GLEText(double resolution, QSize imageSize, GLEDrawingArea *area) :
GLEDrawingObject(resolution, imageSize, area)
{
lastdpi = -1;
// Make sure the line is updated if a point changes or
// the image size changes
connect(this, SIGNAL(pointChanged()),
this, SLOT(updateText()));
connect(this, SIGNAL(imageChanged()),
this, SLOT(resChanged()));
connect(this, SIGNAL(propertyChanged(int)),
this, SLOT(updateFromProperty(int)));
amove = false;
drawPoint = QPointF(0.0,0.0);
// More to be added
validProperties
<< Text
<< FontName
<< FontStyle
<< FontSize
<< Alignment
<< LineColour;
properties[Text] = propertyDescriptions[Text].defaultValue;
properties[FontName] = propertyDescriptions[FontName].defaultValue;
properties[FontStyle] = propertyDescriptions[FontStyle].defaultValue;
properties[FontSize] = propertyDescriptions[FontSize].defaultValue;
properties[Alignment] = propertyDescriptions[Alignment].defaultValue;
properties[LineColour] = propertyDescriptions[LineColour].defaultValue;
}
bool SoXipImage::setKitConnections()
{
mApplyLut = SoBaseKit::getAnyPart("applylut", TRUE);
mTexture = SoBaseKit::getAnyPart("texture", TRUE);
mMatrix = SoBaseKit::getAnyPart("matrix", TRUE);
mQuad = SoBaseKit::getAnyPart("quad", TRUE);
SoField * field = mTexture->getField("model");
mTextureMode = mMatrix ? dynamic_cast<SoSFEnum*>(field) : 0;
bool valid = (mApplyLut && mTexture && mMatrix && mQuad && mTextureMode);
if (!valid)
{
SoDebugError::post("SoXipImage", "Failed to retrieve kit pointers");
return false;
}
valid = valid && connectField(mApplyLut, "image", &image, true);
valid = valid && connectFields(mApplyLut, "output", mTexture, "image");
valid = valid && connectFields(mTexture, "modelMatrix", mMatrix, "matrix");
if (!valid)
{
SoDebugError::post("SoXipImage", "Failed to set kit field connections");
return false;
}
imageChanged();
return valid;
}
void SinglePhotoPreviewLayout::addItem(GraphicsDImgItem* item)
{
if (d->item)
{
disconnect(d->item, SIGNAL(imageChanged()),
this, SLOT(updateZoomAndSize()));
}
d->item = item;
if (d->item)
{
connect(d->item, SIGNAL(imageChanged()),
this, SLOT(updateZoomAndSize()));
}
}
void ImageLoader::onReplyFinished() {
QNetworkReply* reply = qobject_cast<QNetworkReply*>(sender());
QString response;
if (reply) {
if (reply->error() == QNetworkReply::NoError) {
const int available = reply->bytesAvailable();
if (available > 0) {
const QByteArray data(reply->readAll());
QImage image;
image.loadFromData(data);
image = image.scaled(120, 120, Qt::KeepAspectRatioByExpanding);
const QImage swappedImage = image.rgbSwapped();
const bb::ImageData imageData = bb::ImageData::fromPixels(swappedImage.bits(), bb::PixelFormat::RGBA_Premultiplied, swappedImage.width(), swappedImage.height(), swappedImage.bytesPerLine());
_image = bb::cascades::Image(imageData);
emit imageChanged();
_loading = false;
emit loadingChanged();
reply->deleteLater();
return;
}
}
reply->deleteLater();
}
// TODO: handle error: set default icon
}
void OOFImage3D::threshold(double T) {
vtkImageData *rgb = getRGB();
vtkImageData *alpha = getAlpha();
vtkImageData *gray;
vtkImageLuminance *luminance;
vtkImageThreshold *thold1, *thold2;
luminance = vtkImageLuminance::New();
luminance->SetInputConnection(rgb->GetProducerPort());
gray = luminance->GetOutput();
thold1 = vtkImageThreshold::New();
thold1->ThresholdByUpper(T*255);
thold1->SetOutValue(0);
thold1->SetInputConnection(gray->GetProducerPort());
thold2 = vtkImageThreshold::New();
thold2->ThresholdByLower(T*255);
thold2->SetOutValue(255);
thold2->SetInputConnection(thold1->GetOutputPort());
gray = thold2->GetOutput();
gray->Update();
combineChannels(gray,alpha);
imageChanged();
}
void ImageDisplay::setImage(QImage image)
{
if ( m_image == image )
return;
m_image = image;
imageLabel->setPixmap(QPixmap::fromImage(image));
imageLabel->adjustSize();
bool resized = false;
int newHeight = imageLabel->height();
int newWidth = imageLabel->width();
if (imageLabel->width() >= maxCurWidth)
{
newWidth = maxCurWidth-10;
resize(newWidth, newHeight);
resized = true;
}
if (imageLabel->height() >= maxCurHeight)
{
newHeight = maxCurHeight-44;
resize(newWidth, newHeight);
resized = true;
}
if (!resized)
resize(imageLabel->width() + 20, imageLabel->height() + 20);
emit imageChanged( m_image );
}
void PainterWidget::paintEvent(QPaintEvent * /* event */)
{
//QPainter painter(&image);
// setupPainter(painter);
// painter.drawPoint(QPoint(20,20));
QPainter painter2(this);
painter2.drawImage(QPoint(0, 0), image);
//painter2.drawPoint(QPoint(100,100));
float* datap = cutoffData;
for(int i = 0; i < 256; i++)
{
for(int j = 0; j < 256; j++)
{
QColor c = QColor(image.pixel(j,255-i));
datap[0] = float(c.red())/255.0f;
datap[1] = float(c.green())/255.f;
datap[2] = float(c.blue())/255.f;
datap[3] = 1.0f;
datap+=4;
}
}
emit imageChanged(cutoffData, 256, 256);
}
void ItemImage::setImage( const QImage& img )
{
QMutexLocker locker( &mutex );
clearContents();
m_image = new QImage( img );
if( m_image->width() < 32 && m_image->height() < 32 ) {
setMinimumSize( QSize( 32, 32 ) );
setMaximumSize( QSize( 32, 32 ) );
} else if( m_image->width() < 32 && m_image->height() >= 32 ) {
setMinimumSize( QSize( 32, m_image->size().height() ) );
setMaximumSize( QSize( 32, m_image->size().height() ) );
} else if( m_image->width() >= 32 && m_image->height() < 32 ) {
setMinimumSize( QSize( m_image->size().width(), 32 ) );
setMaximumSize( QSize( m_image->size().width(), 32 ) );
} else {
setMinimumSize( m_image->size() );
setMaximumSize( m_image->size() );
}
emit imageChanged( img );
updatePieces();
update();
}
// The constructor for the ellipse object
GLEEllipse::GLEEllipse(double resolution, QSize imageSize, GLEDrawingArea *area) :
GLEDrawingObject(resolution, imageSize, area)
{
// Make sure the ellipse is updated if a point changes or
// the image size changes
connect(this, SIGNAL(pointChanged()),
this, SLOT(updateEllipse()));
connect(this, SIGNAL(imageChanged()),
this, SLOT(updateEllipse()));
connect(this, SIGNAL(propertyChanged(int)),
this, SLOT(updateFromProperty(int)));
amove = false;
pointHash[Angle] = QPointF(0.0, 0.0);
// More to be added
validProperties
<< FillColour
<< LineColour
<< LineWidth
<< LineStyle;
properties[FillColour] = propertyDescriptions[FillColour].defaultValue;
properties[LineColour] = propertyDescriptions[LineColour].defaultValue;
properties[LineWidth] = propertyDescriptions[LineWidth].defaultValue;
properties[LineStyle] = propertyDescriptions[LineStyle].defaultValue;
}
void ScreenWidget::invertImage()
{
//inverted = invertButton->isOn();
inverted = !inverted;
createImage();
emit imageChanged();
}
void ImageViewer::setImage(const ApogeeImage &img)
{
connect(&img, SIGNAL(changed()),
this, SLOT(imageChanged()));
m_image = &img;
drawImage();
}
void FilteredImage::filterApplied(const QImage &image)
{
m_filteredImage = image;
m_imageChanged = true;
emit imageChanged(m_filteredImage);
setIsApplyingFilter(false);
}
ImageDisplayWidget::ImageDisplayWidget(QWidget *parent) : QWidget(parent),
layout(new QGridLayout),scrollArea(new QScrollArea),
imageDisplayLabel(new QLabel)
{
connect(this, SIGNAL(pathChanged(QString)),this, SLOT(updateDisplayImage(QString)));
connect(this, SIGNAL(imageChanged(QImage)),this, SLOT(updateDisplayArea(QImage)));
setupDisplayArea();
}
void PicManager::noFileToShow()
{
curImage->recycle();
curImage = ImageFactory::getImageWrapper(QString::null);
curPath = curName = QString::null;
// state = NoFileNoPicture;
loadImage(QImage());
emit imageChanged(QString::null); //
}
void MainWindow::setDirty() {
if (m_videoControls->isTracking()) {
imageChanged(m_player->image());
}
else if (!m_dirty) {
m_dirty = true;
QMetaObject::invokeMethod(this, "process", Qt::QueuedConnection);
}
}
/**
\brief Sets the image data for the page of notes
\param cwImage - This is the object that stores the ids to all the image
data on disk
*/
void cwNote::setImage(cwImage image) {
if(ImageIds != image) {
ImageIds = image;
emit originalChanged(ImageIds.original());
emit iconChanged(ImageIds.icon());
emit imageChanged(ImageIds);
resetImageResolution();
}
}
FilteredImage::FilteredImage(QQuickItem *parent) :
QQuickItem(parent)
{
m_filter = 0;
m_isApplyingFilter = false;
setFlag(QQuickItem::ItemHasContents, true);
connect(this,SIGNAL(imageChanged(QImage)),SLOT(update()));
}
void ImageLoader::onImageProcessingFinished()
{
const QImage swappedImage = m_watcher.future().result().rgbSwapped();
const bb::ImageData imageData = bb::ImageData::fromPixels(swappedImage.bits(), bb::PixelFormat::RGBX, swappedImage.width(), swappedImage.height(), swappedImage.bytesPerLine());
m_image = bb::cascades::Image(imageData);
emit imageChanged();
m_loading = false;
emit loadingChanged();
}
void OOFImage3D::normalize() {
padImage(-1);
vtkImageData *alpha = getAlpha();
vtkImageAppendComponents *appender;
vtkImageExtractComponents *extractor[3];
vtkImageMathematics *adder[3], *mult[3];
double *minmax, K;
appender = vtkImageAppendComponents::New();
for(int i=0; i<3; i++) {
extractor[i] = vtkImageExtractComponents::New();
extractor[i]->SetInputConnection(image->GetProducerPort());
extractor[i]->SetComponents(i);
extractor[i]->Update();
minmax = extractor[i]->GetOutput()->GetScalarRange();
adder[i] = vtkImageMathematics::New();
adder[i]->SetInputConnection(extractor[i]->GetOutputPort());
adder[i]->SetOperationToAddConstant();
if(minmax[0] > 0 && minmax[0] != minmax[1]) {
adder[i]->SetConstantC(256-minmax[0]);
}
else{
adder[i]->SetConstantC(0);
}
mult[i] = vtkImageMathematics::New();
mult[i]->SetInputConnection(adder[i]->GetOutputPort());
mult[i]->SetOperationToMultiplyByK();
if(minmax[0]!=minmax[1]) {
K = 255.0/(minmax[1]-minmax[0]);
mult[i]->SetConstantK(K);
}
else {
mult[i]->SetConstantK(1.0);
}
mult[i]->GetOutput()->SetScalarTypeToUnsignedChar();
appender->AddInputConnection(mult[i]->GetOutputPort());
}
appender->AddInputConnection(alpha->GetProducerPort());
image = appender->GetOutput();
padImage(1);
imageChanged();
}
void FilteredImage::resetFilter()
{
if(m_filter != 0)
{
m_filter->resetParameters();
}
m_filteredImage = m_image;
m_imageChanged = true;
emit imageChanged(m_filteredImage);
setIsApplyingFilter(false);
}
QImage QHotLoadImageBay::skipTo(QFileInfo fi) {
for (int i = 0; i < imgList.length(); i++) {
const QFileInfo &lfi = std::get<1>(imgList.at(i));
if (lfi == fi) {
index = i;
this->internalSettleIndex();
emit imageChanged(lfi.fileName());
return current();
}
}
return current();
}
void QImageItem::setImage(const QImage &image)
{
bool oldImageNull = m_image.isNull();
m_image = image;
update();
emit nativeWidthChanged();
emit nativeHeightChanged();
emit imageChanged();
if (oldImageNull != m_image.isNull()) {
emit nullChanged();
}
}
