ImageArea::ImageArea(const bool &isOpen, const QString &filePath, QWidget *parent) : QWidget(parent), mIsEdited(false), mIsPaint(false), mIsResize(false) { setMouseTracking(true); mRightButtonPressed = false; mFilePath.clear(); makeFormatsFilters(); initializeImage(); mZoomFactor = 1; mAdditionalTools = new AdditionalTools(this); mUndoStack = new QUndoStack(this); mUndoStack->setUndoLimit(DataSingleton::Instance()->getHistoryDepth()); if(isOpen && filePath.isEmpty()) { open(); } else if(isOpen && !filePath.isEmpty()) { open(filePath); } else { QPainter *painter = new QPainter(mImage); painter->fillRect(0, 0, DataSingleton::Instance()->getBaseSize().width(), DataSingleton::Instance()->getBaseSize().height(), Qt::white); painter->end(); resize(mImage->rect().right() + 6, mImage->rect().bottom() + 6); } QTimer *autoSaveTimer = new QTimer(this); autoSaveTimer->setInterval(DataSingleton::Instance()->getAutoSaveInterval() * 1000); connect(autoSaveTimer, SIGNAL(timeout()), this, SLOT(autoSave())); connect(mAdditionalTools, SIGNAL(sendNewImageSize(QSize)), this, SIGNAL(sendNewImageSize(QSize))); autoSaveTimer->start(); SelectionInstrument *selectionInstrument = new SelectionInstrument(this); connect(selectionInstrument, SIGNAL(sendEnableCopyCutActions(bool)), this, SIGNAL(sendEnableCopyCutActions(bool))); connect(selectionInstrument, SIGNAL(sendEnableSelectionInstrument(bool)), this, SIGNAL(sendEnableSelectionInstrument(bool))); // Instruments handlers mInstrumentsHandlers.fill(0, (int)INSTRUMENTS_COUNT); mInstrumentsHandlers[CURSOR] = selectionInstrument; mInstrumentsHandlers[PEN] = new PencilInstrument(this); mInstrumentsHandlers[LINE] = new LineInstrument(this); mInstrumentsHandlers[ERASER] = new EraserInstrument(this); mInstrumentsHandlers[RECTANGLE] = new RectangleInstrument(this); mInstrumentsHandlers[ELLIPSE] = new EllipseInstrument(this); mInstrumentsHandlers[FILL] = new FillInstrument(this); mInstrumentsHandlers[SPRAY] = new SprayInstrument(this); mInstrumentsHandlers[MAGNIFIER] = new MagnifierInstrument(this); mInstrumentsHandlers[COLORPICKER] = new ColorpickerInstrument(this); mInstrumentsHandlers[CURVELINE] = new CurveLineInstrument(this); mInstrumentsHandlers[TEXT] = new TextInstrument(this); // Effects handlers mEffectsHandlers.fill(0, (int)EFFECTS_COUNT); mEffectsHandlers[NEGATIVE] = new NegativeEffect(this); mEffectsHandlers[GRAY] = new GrayEffect(this); mEffectsHandlers[BINARIZATION] = new BinarizationEffect(this); mEffectsHandlers[GAUSSIANBLUR] = new GaussianBlurEffect(this); mEffectsHandlers[GAMMA] = new GammaEffect(this); mEffectsHandlers[SHARPEN] = new SharpenEffect(this); mEffectsHandlers[CUSTOM] = new CustomEffect(this); }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- QImage PoleFigureImageUtilities::Create3ImagePoleFigure(UInt8ArrayType* i0, UInt8ArrayType* i1, UInt8ArrayType* i2, PoleFigureConfiguration_t& config, int32_t layout) { // Create a QImage that is the width of the first 2 images and the height of the first and third QImage img0 = PoleFigureImageUtilities::CreateQImageFromRgbaArray(i0, config.imageDim, true); QImage img1 = PoleFigureImageUtilities::CreateQImageFromRgbaArray(i1, config.imageDim, true); QImage img2 = PoleFigureImageUtilities::CreateQImageFromRgbaArray(i2, config.imageDim, true); // Create the Scalar Bar image QImage scalarBar = PoleFigureImageUtilities::GenerateScalarBar(img0.width(), img0.height(), config); int pImageWidth = 0; int pImageHeight = 0; QPoint pos1; QPoint pos2; QPoint pos3; QPoint pos4; if(layout == SIMPL::Layout::Horizontal) { pImageWidth = img0.width() * 4; pImageHeight = img0.height(); pos1 = QPoint(0, 0); pos2 = QPoint(img0.width(), 0); pos3 = QPoint(img0.width() * 2, 0); pos4 = QPoint(img0.width() * 3, 0); } else if(layout == SIMPL::Layout::Vertical) { pImageWidth = img0.width(); pImageHeight = img0.height() * 4; pos1 = QPoint(0, 0); pos2 = QPoint(0, img0.height()); pos3 = QPoint(0, img0.height() * 2); pos4 = QPoint(0, img0.height() * 3); } else if(layout == SIMPL::Layout::Square) { pImageWidth = img0.width() + img1.width(); pImageHeight = img0.height() + img2.height(); pos1 = QPoint(0, 0); pos2 = QPoint(pImageWidth / 2, 0); pos3 = QPoint(0, pImageHeight / 2); pos4 = QPoint(pImageWidth / 2, pImageHeight / 2); } QImage pImage(pImageWidth, pImageHeight, QImage::Format_ARGB32_Premultiplied); pImage.fill(0xFFFFFFFF); // All white background // Create a Painter backed by a QImage to draw into QPainter painter; painter.begin(&pImage); painter.setRenderHint(QPainter::Antialiasing, true); painter.drawImage(pos1, img0); // Draw the first image in the upper Left painter.drawImage(pos2, img1); // Draw the second image in the upper right painter.drawImage(pos3, img2); // Draw the third image in the lower Left painter.drawImage(pos4, scalarBar); // Draw the Scalar Bar painter.end(); // Scale the image down to 225 pixels return pImage; }
void MainWindow::btnExportClicked() { QList<QChar> charset; if (chkLowerAZ->isChecked()) for (char c = 'a'; c <= 'z'; c++) charset.append(c); if (chkUpperAZ->isChecked()) for (char c = 'A'; c <= 'Z'; c++) charset.append(c); if (chkNumbers->isChecked()) for (char c = '0'; c <= '9'; c++) charset.append(c); QString str = ldtCharacters->text(); for (QString::const_iterator itr(str.begin()); itr != str.end(); itr++) if (!charset.contains(*itr)) charset.append(*itr); qSort(charset); // Render characters QFont font = fontSelector->currentFont(); font.setPixelSize(font.pointSize()); QFontMetrics metrics = QFontMetrics(font); QTextCodec *codec = QTextCodec::codecForName("utf-8"); QString glyphs; QString fontName = QString("font_%1%2") .arg(font.family().toLower()) .arg(font.pixelSize()) .replace(' ', '_'); QString fontstruct = QString( "const struct glib_font %1 = {\n" " .charcount = %2,\n" " .size = %3,\n" " .glyphs = {\n ") .arg(fontName) .arg(charset.size()) .arg(font.pixelSize()); QListIterator<QChar> itr(charset); while (itr.hasNext()) { QChar c = itr.next(); if (c == ' ') { // Add space character fontstruct += QString("{.utf8 = 0x20, .x = %1, .y = 0, .bitmap = NULL}") .arg(metrics.width(' ')); } else { QRect boundingRect = metrics.boundingRect(c); QImage image = QImage(boundingRect.width(), boundingRect.height(), QImage::Format_Mono); image.fill(Qt::color1); QPainter p; p.begin(&image); p.setFont(font); p.setWindow(metrics.boundingRect(c)); p.drawText(0, 0, c); p.end(); QString utf8 = codec->fromUnicode(c).toHex(); glyphs += renderGlyph(utf8, image); fontstruct += QString("{.utf8 = 0x%1, .x = %2, .y = %3, .bitmap = &glyph_%1}") .arg(utf8) .arg(boundingRect.x() + 1) .arg(boundingRect.y() - metrics.descent() + 1); // +1 for the base line } if (itr.hasNext()) fontstruct += ",\n "; } fontstruct += "\n }\n};\n"; glyphs = "#include <liblcd/glib.h>\n\n" + glyphs + "\n" + fontstruct; QString filename = QFileDialog::getSaveFileName(this, tr("Save Font"), fontName + ".c", tr("Source Files (*.c *.cpp)")); if (!filename.isEmpty()) { if (!(filename.endsWith(".c") || filename.endsWith(".cpp"))) filename += ".c"; QFile file(filename); if (!file.open(QIODevice::WriteOnly | QIODevice::Text)) return; QTextStream out(&file); out << glyphs; file.close(); } }
SplashScreen::SplashScreen(QWidget *parent) : QWidget(parent) { QRect rec = QApplication::desktop()->screenGeometry(); int screenWidth = rec.width(); int screenHeight = rec.height(); this->setWindowFlags(Qt::FramelessWindowHint); this->setGeometry(0,screenHeight/2-150,screenWidth,300); QPixmap bgPixmap(screenWidth,300); QLinearGradient bgGradient(QPointF(0, 0), QPointF(screenWidth, 0)); bgGradient.setColorAt(0, QColor("#6c3d94")); bgGradient.setColorAt(1, QColor("#a13469")); //#3c3c3b QRect rect_linear(0,0,screenWidth,300); QPainter *painter = new QPainter(&bgPixmap); painter->fillRect(rect_linear, bgGradient); painter->end(); bg = new QLabel(this); bg->setPixmap(bgPixmap); bg->setGeometry(0,0,screenWidth,300); splashImage = new QLabel(this); QPixmap newPixmap; if(GetBoolArg("-testnet")) { newPixmap.load(":/images/splash_testnet"); } else { newPixmap.load(":/images/splash"); } splashImage->setPixmap(newPixmap); splashImage->move(screenWidth/2-567/2,50); QFont smallFont; smallFont.setPixelSize(12); versionLabel = new QLabel(this); versionLabel->setStyleSheet("QLabel { color: #3C3C3B; }"); versionLabel->setFont(smallFont); versionLabel->setText(QString::fromStdString(FormatFullVersion()).split("-")[0]); versionLabel->setFixedSize(1000,30); versionLabel->move(screenWidth/2-108,220); QFont largeFont; largeFont.setPixelSize(20); label = new QLabel(this); label->setStyleSheet("QLabel { color: #FFFFFF; }"); label->setFont(largeFont); label->setText("..."); label->setFixedSize(1000,30); label->move(screenWidth/2-108,260); }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- QImage PoleFigureImageUtilities::GenerateScalarBar(int imageWidth, int imageHeight, PoleFigureConfiguration_t& config) { int numColors = config.numColors; QImage pImage(imageWidth, imageHeight, QImage::Format_ARGB32_Premultiplied); pImage.fill(0xFFFFFFFF); // All white background // Create a Painter backed by a QImage to draw into QPainter painter; painter.begin(&pImage); painter.setRenderHint(QPainter::Antialiasing, true); int penWidth = 1; #if 0 // DRAW A BORDER AROUND THE IMAGE FOR DEBUGGING QColor c(RgbColor::dRgb(255, 0, 0, 255)); painter.setPen(QPen(c, penWidth, Qt::SolidLine, Qt::SquareCap, Qt::RoundJoin)); painter.drawLine(0, 0, imageWidth, 0); // Top painter.drawLine(0, 0, 0, imageHeight); // Left painter.drawLine(imageWidth, 0, imageWidth, imageHeight); // Right painter.drawLine(0, imageHeight, imageWidth, imageHeight); // Bottom //----------------- #endif //Get all the colors that we will need QVector<SIMPL::Rgb> colorTable(numColors); QVector<float> colors(3 * numColors, 0.0); SIMPLColorTable::GetColorTable(numColors, colors); // Generate the color table values float r = 0.0, g = 0.0, b = 0.0; for (int i = 0; i < numColors; i++) // Convert them to QRgbColor values { r = colors[3 * i]; g = colors[3 * i + 1]; b = colors[3 * i + 2]; colorTable[i] = RgbColor::dRgb(r * 255, g * 255, b * 255, 255); } // Now start from the bottom and draw colored lines up the scale bar // A Slight Indentation for the scalar bar float margin = 0.05f; float scaleBarRelativeWidth = 0.10f; float scaleBarRelativeHeight = 1.0f - (margin * 2); int colorHeight = int( (imageHeight * scaleBarRelativeHeight) / numColors); QPointF topLeft(imageWidth * margin, imageHeight * margin); QSizeF size(imageWidth * scaleBarRelativeWidth, imageHeight * scaleBarRelativeHeight); int yLinePos = topLeft.y(); QPointF start = topLeft; QPointF end = topLeft; for(int i = numColors - 1; i >= 0; i--) { QColor c(colorTable[i]); painter.setPen(QPen(c, penWidth, Qt::SolidLine, Qt::SquareCap, Qt::RoundJoin)); for(int j = 0; j < colorHeight; j++) { start.setY(yLinePos); end.setX(topLeft.x() + (imageWidth * scaleBarRelativeWidth)); end.setY(yLinePos); painter.drawLine(start, end); yLinePos++; } } // Draw the border of the scale bar size = QSizeF(imageWidth * scaleBarRelativeWidth, numColors * colorHeight); // Add two pixel to the height so we don't over write part of the scale bar QRectF scaleBorder(topLeft, size); penWidth = 2; painter.setPen(QPen(QColor(0, 0, 0, 255), penWidth, Qt::SolidLine, Qt::RoundCap, Qt::RoundJoin)); painter.drawRect(scaleBorder); // Draw the Text Labels of the Scale Bar int startFontPtSize = 10; QFont font("Ariel", startFontPtSize, QFont::Bold); QFontMetrics metrics(font); int fontPixelsHeight = metrics.height(); while(fontPixelsHeight < colorHeight * 2) { startFontPtSize++; font = QFont("Ariel", startFontPtSize, QFont::Bold); metrics = QFontMetrics(font); fontPixelsHeight = metrics.height(); } painter.setFont(font); // Draw some more information to the right of the Scale Bar QString maxStr = QString::number(config.maxScale, 'f', 3); painter.drawText(topLeft.x() + (imageWidth * scaleBarRelativeWidth) + 10, topLeft.y() + fontPixelsHeight, maxStr); QString minStr = QString::number(config.minScale, 'f', 3); painter.drawText(topLeft.x() + (imageWidth * scaleBarRelativeWidth) + 10, topLeft.y() + size.height(), minStr); //------------------------------ // Draw some statistics for the pole figures startFontPtSize = 8; // Set it to a rather large point size so we can fit the text perfectly. Only an insanely large Polefigure would go past this size int labelWidth = 0; // Make sure the size of font we just picked will allow the string to NOT be clipped because the rendered // pixel width is past the right side of the image int endOfStringYPos = topLeft.x() + (imageWidth * scaleBarRelativeWidth) + 10 + labelWidth; while(endOfStringYPos < imageWidth) { startFontPtSize++; font = QFont("Ariel", startFontPtSize, QFont::Bold); metrics = QFontMetrics(font); QString label("Upper & Lower"); QString label2 = QString("Samples: ") + QString::number(config.eulers->getNumberOfTuples()); fontPixelsHeight = metrics.height(); // Update the font height int labelWidth = metrics.width(label); // Figure out which string is longer (pixel wise) if (labelWidth < metrics.width(label2)) { labelWidth = metrics.width(label2); } endOfStringYPos = topLeft.x() + (imageWidth * scaleBarRelativeWidth) + 10 + labelWidth; } startFontPtSize--; font = QFont("Ariel", startFontPtSize, QFont::Bold); metrics = QFontMetrics(font); QString label("Upper & Lower"); QString label2 = QString("Samples: ") + QString::number(config.eulers->getNumberOfTuples()); labelWidth = metrics.width(label); if (labelWidth < metrics.width(label2)) { labelWidth = metrics.width(label2); } // Set the font into the Painter painter.setFont(font); QPointF statsPoint(topLeft.x() + (imageWidth * scaleBarRelativeWidth) + 10, imageHeight * .5); // Draw some more Statistics Text painter.drawText(statsPoint, label); statsPoint.setY(imageHeight * .5 + fontPixelsHeight); painter.drawText(statsPoint, label2); painter.end(); // Scale the image down to 225 pixels return pImage; }
void QColorTabBar::paintEvent(QPaintEvent *) { //QTabBar::paintEvent(evt); QPainter painter; painter.begin( this ); int nDiameter = 3 << 1; for( int i=0 ;i<count(); i++ ) { QRect rectTab( tabRect(i).adjusted( 0, 0, -1, 0 ) ); bool bActive = (m_nActiveIndex == i); if( bActive ) rectTab.adjust( 0, 0, 0, 1 ); bool bHover = (m_nHoverIndex == i); bool bNotify = (m_nNotifyIndex == i); QPainterPath tabPath; QPainterPath tabS; QRectF arcRect( 0, 0, nDiameter, nDiameter ); if (m_bHorz) { // Horz-Tab tabPath.moveTo( rectTab.bottomLeft() ); tabPath.lineTo( rectTab.left(), rectTab.top()+nDiameter/2); tabS.moveTo( rectTab.left(), rectTab.top()+nDiameter/2 ); arcRect.moveTo( rectTab.topLeft() ); tabPath.arcTo( arcRect, 180, -90 ); tabS.arcTo( arcRect, 180, -90 ); tabPath.lineTo( rectTab.right()-nDiameter/2, rectTab.top() ); tabS.lineTo( rectTab.right()-nDiameter/2, rectTab.top() ); arcRect.moveTo( rectTab.right()-nDiameter, rectTab.top() ); tabPath.arcTo( arcRect, 90, -90 ); tabS.arcTo( arcRect, 90, -90 ); tabPath.lineTo( rectTab.bottomRight() ); //tabS.closeSubpath(); } else { // Vert-Tab tabPath.moveTo( rectTab.right(), rectTab.y() ); tabPath.lineTo( rectTab.x()+nDiameter, rectTab.y() ); tabS.moveTo( rectTab.x()+nDiameter, rectTab.y() ); arcRect.moveTo(rectTab.topLeft()); tabPath.arcTo( arcRect, -270, 90 ); tabS.arcTo( arcRect, -270, 90 ); arcRect.moveTo(rectTab.x(), rectTab.bottom()-nDiameter); tabPath.arcTo( arcRect, -180, 90 ); tabS.arcTo( arcRect, -180, 90 ); tabPath.moveTo( rectTab.left()+nDiameter, rectTab.bottom() ); tabPath.lineTo( rectTab.right(), rectTab.bottom() ); //tabS.closeSubpath(); } QColor colorBody; if (bNotify && (m_nBlinkCount % 2 == 0)) { colorBody = QColor(252, 209, 211); } else { if (bActive) colorBody = QColor(255, 255, 255); else colorBody = QColor(0xF5, 0xF5, 0xF5); } painter.fillPath( tabPath, QBrush(colorBody) ); QColor colorStart = bActive ? g_TabDefaultColor[i] : (bHover ? QColor(255, 190, 60, 200) : QColor(255, 255, 255, 200)); QColor colorEnd(255, 255, 255, 200); QRectF rectTabTip; rectTabTip = tabS.boundingRect(); QLinearGradient gradTip; if (m_bHorz) { gradTip.setStart(rectTabTip.center().x(), rectTabTip.top()); gradTip.setFinalStop(rectTabTip.center().x(), rectTabTip.bottom()); } else { gradTip.setStart(rectTabTip.left(), rectTabTip.center().y()); gradTip.setFinalStop(rectTabTip.right(), rectTabTip.center().y()); } gradTip.setColorAt( 0, colorStart ); gradTip.setColorAt( 1.f, colorEnd ); painter.setBrush(Qt::NoBrush); painter.setPen( QPen(QColor(160,160,160,100), 2.f) ); painter.drawPath( tabPath ); painter.setPen( QPen(QColor(160,160,160)) ); painter.drawPath( tabPath ); painter.setPen( Qt::white ); if( bActive ) painter.drawLine( rectTab.bottomLeft(), rectTab.bottomRight() ); painter.fillPath( tabS, QBrush(gradTip) ); if (bActive || bHover) { painter.setPen( colorStart ); painter.drawPath( tabS ); } QRectF rectText; float fTextOffset = 0.f; if (m_bHorz) { rectText.setX((float)rectTab.x() + fTextOffset); rectText.setY((float)rectTab.y() + nDiameter/2); rectText.setWidth((float)rectTab.width() - fTextOffset); rectText.setHeight((float)rectTab.height() - nDiameter/2); } else { rectText.setX((float)rectTab.x() + nDiameter/2 + fTextOffset); rectText.setY((float)rectTab.y()); rectText.setWidth((float)rectTab.width() - nDiameter/2 - fTextOffset); rectText.setHeight((float)rectTab.height()); } QFont fnt( font() ); fnt.setBold(bActive); painter.setFont( fnt ); int flags = Qt::AlignCenter|Qt::AlignVCenter|Qt::TextSingleLine; painter.setPen( QColor(80,80,80) ); painter.drawText( rectText, flags, tabText(i) ); if( m_nBlinkIndex == i && m_bBlinkFalg ) { painter.fillPath( tabPath, QColor(240,240,0,128) ); } } painter.end(); }
void Printer::render(int Pages = 0) { // keep original preferences QPointer<ProfileWidget2> profile = MainWindow::instance()->graphics(); int profileFrameStyle = profile->frameStyle(); int animationOriginal = prefs.animation_speed; double fontScale = profile->getFontPrintScale(); double printFontScale = 1.0; // apply printing settings to profile profile->setFrameStyle(QFrame::NoFrame); profile->setPrintMode(true, !printOptions->color_selected); profile->setToolTipVisibile(false); prefs.animation_speed = 0; // render the Qwebview QPainter painter; QRect viewPort(0, 0, pageSize.width(), pageSize.height()); painter.begin(paintDevice); painter.setRenderHint(QPainter::Antialiasing); painter.setRenderHint(QPainter::SmoothPixmapTransform); // get all refereces to diveprofile class in the Html template QWebElementCollection collection = webView->page()->mainFrame()->findAllElements(".diveprofile"); QSize originalSize = profile->size(); if (collection.count() > 0) { printFontScale = (double)collection.at(0).geometry().size().height() / (double)profile->size().height(); profile->resize(collection.at(0).geometry().size()); } profile->setFontPrintScale(printFontScale); int elemNo = 0; for (int i = 0; i < Pages; i++) { // render the base Html template webView->page()->mainFrame()->render(&painter, QWebFrame::ContentsLayer); // render all the dive profiles in the current page while (elemNo < collection.count() && collection.at(elemNo).geometry().y() < viewPort.y() + viewPort.height()) { // dive id field should be dive_{{dive_no}} se we remove the first 5 characters QString diveIdString = collection.at(elemNo).attribute("id"); int diveId = diveIdString.remove(0, 5).toInt(0, 10); putProfileImage(collection.at(elemNo).geometry(), viewPort, &painter, get_dive_by_uniq_id(diveId), profile); elemNo++; } // scroll the webview to the next page webView->page()->mainFrame()->scroll(0, pageSize.height()); viewPort.adjust(0, pageSize.height(), 0, pageSize.height()); // rendering progress is 4/5 of total work emit(progessUpdated((i * 80.0 / Pages) + done)); if (i < Pages - 1 && printMode == Printer::PRINT) static_cast<QPrinter*>(paintDevice)->newPage(); } painter.end(); // return profle settings profile->setFrameStyle(profileFrameStyle); profile->setPrintMode(false); profile->setFontPrintScale(fontScale); profile->setToolTipVisibile(true); profile->resize(originalSize); prefs.animation_speed = animationOriginal; //replot the dive after returning the settings profile->plotDive(0, true); }
void DockWnd::timer() { if (++m_state >= 4) m_state = 0; ShowIcon needIcon = State; bool bBlinked = pClient->isConnecting(); unsigned short msgType = 0; if (pMain->messages.size()) msgType = pMain->messages.back().type(); switch (m_state){ case 1: if (msgType){ needIcon = Message; }else if (bBlinked){ needIcon = Blinked; } break; case 2: if (msgType && bBlinked) needIcon = Blinked; break; case 3: if (msgType){ needIcon = Message; }else if (bBlinked){ needIcon = Blinked; } break; } if (needIcon == showIcon) return; showIcon = needIcon; switch (showIcon){ case State: setIcon(Pict(pClient->getStatusIcon())); break; case Message: setIcon(Pict(SIMClient::getMessageIcon(msgType))); break; case Blinked: setIcon(Pict(SIMClient::getStatusIcon(ICQ_STATUS_ONLINE))); break; default: break; } #ifndef WIN32 if (inTray) return; const char *icon = pClient->getStatusIcon(); const char *msg = NULL; const char *bmsg = NULL; if (msgType) bmsg = SIMClient::getMessageIcon(msgType); if (bBlinked){ if (m_state & 1){ icon = SIMClient::getStatusIcon(ICQ_STATUS_ONLINE); }else{ msg = bmsg; } }else{ if (!(m_state & 1)){ msg = bmsg; } } if (wharfIcon){ wharfIcon->set(icon, msg); return; } const QIconSet &icons = Icon(icon); QPixmap nvis(icons.pixmap(QIconSet::Large, QIconSet::Normal)); if (!bEnlightenment){ resize(nvis.width(), nvis.height()); if (msg){ QPixmap msgPict = Pict(msg); QRegion *rgn = NULL; if (nvis.mask() && msgPict.mask()){ rgn = new QRegion(*msgPict.mask()); rgn->translate(nvis.width() - msgPict.width() - SMALL_PICT_OFFS, nvis.height() - msgPict.height() - SMALL_PICT_OFFS); *rgn += *nvis.mask(); } QPainter p; p.begin(&nvis); p.drawPixmap(nvis.width() - msgPict.width() - SMALL_PICT_OFFS, nvis.height() - msgPict.height() - SMALL_PICT_OFFS, msgPict); p.end(); if (rgn){ setMask(*rgn); delete rgn; } }else{ const QBitmap *mask = nvis.mask(); if (mask) setMask(*mask); } } drawIcon = nvis; repaint(); #endif }
void MainWindow::on_chooseCube_editingFinished() { ui->divideButton->clicked(); ui->picLabelRoi->clear(); int num_cube = ui->chooseCube->value(); if(num_cube > 0 && num_cube <= cubeRow * cubeCol) { //find cube in pic int num_row = (num_cube - 1) / cubeCol;//start at 0 int num_col = (num_cube - 1) % cubeCol; // start at 0 //qDebug() << "row,col:" << num_row << num_col; chooseCubeColor = image_resize(cv::Rect(num_col*3,num_row*3,3,3));//cube what we choose // //painting roi // float multiple = (float)imgScaled.width() / (float)image_resize.size().width; // QPicture picture0; // QPainter painter0; // QPen pen_roi; // pen_roi.setColor(Qt::red); // pen_roi.setWidth(2); // painter0.begin(&picture0); // painter0.setPen(pen_roi); // //painting red Roi // painter0.drawRect(QRectF(num_col*3*multiple,num_row*3*multiple,3*multiple,3*multiple)); // //qDebug() << QRectF(num_col*3*multiple,num_row*3*multiple,3*multiple,3*multiple); // painter0.end(); // picture0.save("draw_roi.pic"); // ui->picLabelRoi->setPicture(picture0); //painting cube QPicture picture; QPainter painter; QPen pen_cube; pen_cube.setColor(Qt::black); pen_cube.setWidth(2); painter.begin(&picture); painter.setPen(pen_cube); QBrush brush(Qt::SolidPattern); //painting choose cube int block_size = 40; for(int i = 0; i < 9; i++) { //qDebug() << "RGB:" << chooseCubeColor.at<Vec3b>(i/3,i%3).val[0]<<chooseCubeColor.at<Vec3b>(i/3,i%3).val[1]<<chooseCubeColor.at<Vec3b>(i/3,i%3).val[2]; brush.setColor(QColor(chooseCubeColor.at<Vec3b>(i/3,i%3).val[0],chooseCubeColor.at<Vec3b>(i/3,i%3).val[1],chooseCubeColor.at<Vec3b>(i/3,i%3).val[2]));//RGB 3 channels painter.setBrush(brush); painter.drawRoundRect(QRect(block_size*i%(block_size*3),block_size*(i/3),block_size,block_size)); } painter.end(); picture.save("draw_cube.pic"); ui->showCubeChoose->setPicture(picture); //store colors of cube for(int i = 0; i < 9; i++) { QColor qcolor = QColor(chooseCubeColor.at<Vec3b>(i/3,i%3).val[0],chooseCubeColor.at<Vec3b>(i/3,i%3).val[1],chooseCubeColor.at<Vec3b>(i/3,i%3).val[2]);//RGB 3 channels int color_num; if(qcolor == colorTable_cube[0]) color_num = 0; else if(qcolor == colorTable_cube[1]) color_num = 1; else if(qcolor == colorTable_cube[2]) color_num = 2; else if(qcolor == colorTable_cube[3]) color_num = 3; else if(qcolor == colorTable_cube[4]) color_num = 4; else if(qcolor == colorTable_cube[5]) color_num = 5; else color_num = -1; col[i] = RubikColor(color_num); //qDebug() << "color:" << color_num; } dlg.setRubikColor(col); } else { int ret = QMessageBox::warning(this, "Warning", "Please choose the cube you want to make!", QMessageBox::Abort); if (ret == QMessageBox::Abort) qDebug() << "WARNING!!"; } }
int bandageImage(QStringList arguments) { QTextStream out(stdout); QTextStream err(stderr); if (checkForHelp(arguments)) { printImageUsage(&out, false); return 0; } if (checkForHelpAll(arguments)) { printImageUsage(&out, true); return 0; } if (arguments.size() < 2) { printImageUsage(&err, false); return 1; } QString graphFilename = arguments.at(0); arguments.pop_front(); if (!checkIfFileExists(graphFilename)) { err << "Bandage error: " << graphFilename << " does not exist" << endl; return 1; } QString imageSaveFilename = arguments.at(0); arguments.pop_front(); QString imageFileExtension = imageSaveFilename.right(4); bool pixelImage; if (imageFileExtension == ".png" || imageFileExtension == ".jpg") pixelImage = true; else if (imageFileExtension == ".svg") pixelImage = false; else { err << "Bandage error: the output filename must end in .png, .jpg or .svg" << endl; return 1; } QString error = checkForInvalidImageOptions(arguments); if (error.length() > 0) { err << "Bandage error: " << error << endl; return 1; } bool loadSuccess = g_assemblyGraph->loadGraphFromFile(graphFilename); if (!loadSuccess) { err << "Bandage error: could not load " << graphFilename << endl; return 1; } int width = 0; int height = 0; parseImageOptions(arguments, &width, &height); //For Bandage image, it is necessary to position node labels at the //centre of the node, not the visible centre(s). This is because there //is no viewport. g_settings->positionTextNodeCentre = true; //Since frame rate performance doesn't matter for a fixed image, set the //default node outline to a nonzero value. g_settings->outlineThickness = 0.3; bool blastUsed = isOptionPresent("--query", &arguments); if (blastUsed) { if (!createBlastTempDirectory()) { err << "Error creating temporary directory for BLAST files" << endl; return 1; } QString blastError = g_blastSearch->doAutoBlastSearch(); if (blastError != "") { err << blastError << endl; return 1; } } QString errorTitle; QString errorMessage; std::vector<DeBruijnNode *> startingNodes = g_assemblyGraph->getStartingNodes(&errorTitle, &errorMessage, g_settings->doubleMode, g_settings->startingNodes, "all"); if (errorMessage != "") { err << errorMessage << endl; return 1; } g_assemblyGraph->buildOgdfGraphFromNodesAndEdges(startingNodes, g_settings->nodeDistance); g_assemblyGraph->layoutGraph(); MyGraphicsScene scene; g_assemblyGraph->addGraphicsItemsToScene(&scene); scene.setSceneRectangle(); double sceneRectAspectRatio = scene.sceneRect().width() / scene.sceneRect().height(); //Determine image size //If neither height nor width set, use a default of height = 1000. if (height == 0 && width == 0) height = 1000; //If only height or width is set, scale the other to fit. if (height > 0 && width == 0) width = height * sceneRectAspectRatio; else if (height == 0 && width > 0) height = width / sceneRectAspectRatio; bool success = true; QPainter painter; if (pixelImage) { QImage image(width, height, QImage::Format_ARGB32); image.fill(Qt::white); painter.begin(&image); painter.setRenderHint(QPainter::Antialiasing); painter.setRenderHint(QPainter::TextAntialiasing); scene.render(&painter); success = image.save(imageSaveFilename); painter.end(); } else //SVG { QSvgGenerator generator; generator.setFileName(imageSaveFilename); generator.setSize(QSize(width, height)); generator.setViewBox(QRect(0, 0, width, height)); painter.begin(&generator); painter.fillRect(0, 0, width, height, Qt::white); painter.setRenderHint(QPainter::Antialiasing); painter.setRenderHint(QPainter::TextAntialiasing); scene.render(&painter); painter.end(); } int returnCode; if (!success) { out << "There was an error writing the image to file." << endl; returnCode = 1; } else returnCode = 0; if (blastUsed) deleteBlastTempDirectory(); return returnCode; }
void dialogAnalog::fillPixmap(CData *data, QPen *dataPen) { mainwindow->analogMutex.lock(); TAnalog_Data plot,next_plot; QPainter painter; int heightPerField = lastPixmap.height() / NbBits; painter.begin(&lastPixmap); painter.setPen(*dataPen); QVector< QVector<QPoint> > polyline(64); Qt::CheckState csMarker = chkBShowMarker->checkState(); for (int j=1;j<data->size();j++) { plot = data->Read(j-1); next_plot = data->Read(j); int current = heightPerField; int X1,Y1,X2,Y2; X1=StateToX(plot.state); X2=StateToX(next_plot.state); // Crop to the visible area if (!( (j>1) && ( (X2<0) || ( X1>frame_dataview->width())))) { for (int jj=0;jj<NbBits;jj++) { //#define READ_BIT(b,p) ( ((b)>>(p)) & 0x01 ? 1 :0 ) Y1= current - READ_BIT(plot.values,jj)* 3 * heightPerField / 5; Y2= current - READ_BIT(next_plot.values,jj)* 3 * heightPerField / 5; //painter.drawLine(X1,Y1,X2,Y1); //painter.drawLine(X2,Y1,X2,Y2); polyline[jj].append( QPoint(X1,Y1) ); polyline[jj].append( QPoint(X2,Y1) ); current += heightPerField; } // plot the Markers // Need to optimize if ( plot.marker && (csMarker == Qt::Checked) ) { QPen pen((Qt::white)); pen.setStyle(Qt::DotLine); painter.setPen(pen); painter.drawLine(X1,12,X1,height()); // set font ------------------------------------------------------------------------------------ QFont textFont; textFont.setPixelSize(10); painter.setFont(textFont); painter.drawText(X1, 11, QString::number(plot.marker,10)); painter.setPen(*dataPen); } } } if (polyline.size()) { for (int jj=0;jj<NbBits;jj++) { if (polyline[jj].size()) painter.drawPolyline(polyline[jj].data(),polyline[jj].size()); } } painter.end(); mainwindow->analogMutex.unlock(); }
void DBThread::TriggerMapRendering() { RenderMapRequest request; { QMutexLocker locker(&mutex); request=currentRenderRequest; if (!doRender) { return; } renderBreaker->Reset(); } if (currentImage==NULL || currentImage->width()!=(int)request.width || currentImage->height()!=(int)request.height) { delete currentImage; currentImage=new QImage(QSize(request.width,request.height),QImage::Format_RGB32); } currentLon=request.lon; currentLat=request.lat; currentAngle=request.angle; currentMagnification=request.magnification; QPainter p; if (database->IsOpen() && styleConfig) { osmscout::MapParameter drawParameter; osmscout::AreaSearchParameter searchParameter; searchParameter.SetBreaker(renderBreakerRef); searchParameter.SetMaximumAreaLevel(4); searchParameter.SetUseMultithreading(currentMagnification.GetMagnification()<=osmscout::Magnification::magCity); std::list<std::string> paths; paths.push_back(iconDirectory.toLocal8Bit().data()); drawParameter.SetIconPaths(paths); drawParameter.SetPatternPaths(paths); drawParameter.SetDebugPerformance(true); drawParameter.SetOptimizeWayNodes(osmscout::TransPolygon::quality); drawParameter.SetOptimizeAreaNodes(osmscout::TransPolygon::quality); drawParameter.SetRenderSeaLand(true); drawParameter.SetBreaker(renderBreakerRef); double fs = drawParameter.GetFontSize(); QSettings s; double fsMul = s.value("fontSize", 1).toDouble(); qDebug()<<"FontSize: "<<fs; qDebug()<<"DPI:" << dpi; fs*=(dpi/50)*fsMul; //for 100DPI, multiply by 1.5 drawParameter.SetFontSize(fs); std::cout << std::endl; osmscout::StopClock overallTimer; projection.Set(currentLon, currentLat, currentAngle, currentMagnification, dpi, request.width, request.height); osmscout::StopClock dataRetrievalTimer; mapService->GetObjects(searchParameter, styleConfig, projection, data); if (drawParameter.GetRenderSeaLand()) { mapService->GetGroundTiles(projection, data.groundTiles); } dataRetrievalTimer.Stop(); osmscout::StopClock drawTimer; p.begin(currentImage); p.setRenderHint(QPainter::Antialiasing); p.setRenderHint(QPainter::TextAntialiasing); p.setRenderHint(QPainter::SmoothPixmapTransform); painter->DrawMap(projection, drawParameter, data, &p); p.end(); drawTimer.Stop(); overallTimer.Stop(); std::cout << "All: " << overallTimer << " Data: " << dataRetrievalTimer << " Draw: " << drawTimer << std::endl; } else { std::cout << "Cannot draw map: " << database->IsOpen() << " " << styleConfig.Valid() << std::endl; p.begin(currentImage); p.setRenderHint(QPainter::Antialiasing); p.setRenderHint(QPainter::TextAntialiasing); p.setRenderHint(QPainter::SmoothPixmapTransform); p.fillRect(0,0,request.width,request.height, QColor::fromRgbF(0.0,0.0,0.0,1.0)); p.setPen(QColor::fromRgbF(1.0,1.0,1.0,1.0)); QString text("not initialized (yet)"); p.drawText(QRect(0,0,request.width,request.height), Qt::AlignCenter|Qt::AlignVCenter, text, NULL); p.end(); } QMutexLocker locker(&mutex); if (renderBreaker->IsAborted()) { return; } std::swap(currentImage,finishedImage); std::swap(currentLon,finishedLon); std::swap(currentLat,finishedLat); std::swap(currentAngle,finishedAngle); std::swap(currentMagnification,finishedMagnification); doRender=false; emit HandleMapRenderingResult(); }
void RulerT::paintEvent(QPaintEvent *) { double xl; QPainter p; p.begin(this); p.drawLine(0, 24, width(), 24); p.translate(-offset, 0); p.setBrush(Qt::black); p.setFont(font()); p.setPen(QPen(Qt::black, 1, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin)); for (xl = 0; xl < width()+offset; xl += iter) { if (xl < offset) continue; p.drawLine(qRound(xl), 18, qRound(xl), 24); } for (xl = 0; xl < width()+(iter2/2)+offset; xl += iter2) { if (xl < offset) continue; p.drawLine(qRound(xl), 11, qRound(xl), 24); switch (unitIndex) { case 2: { QString tx = ""; int num1 = static_cast<int>(xl / iter2); if (num1 != 0) tx = QString::number(num1); double frac = (xl / iter2) - num1; if ((frac > 0.24) && (frac < 0.26)) tx += QChar(0xBC); if ((frac > 0.49) && (frac < 0.51)) tx += QChar(0xBD); if ((frac > 0.74) && (frac < 0.76)) tx += QChar(0xBE); p.drawText(qRound(xl+2), 17, tx); break; } case 3: p.drawText(qRound(xl+2), 17, QString::number(xl / iter)); break; default: p.drawText(qRound(xl+2), 17, QString::number(xl / iter * 10)); break; } } if (tabValues.count() != 0) { for (int yg = 0; yg < static_cast<int>(tabValues.count()); yg++) { if (yg == actTab) p.setPen(QPen(Qt::red, 2, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin)); else p.setPen(QPen(Qt::black, 2, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin)); switch (static_cast<int>(tabValues[yg].tabType)) { case 0: p.drawLine(qRound(tabValues[yg].tabPosition), 15, qRound(tabValues[yg].tabPosition), 23); p.drawLine(qRound(tabValues[yg].tabPosition), 23, qRound(tabValues[yg].tabPosition+8), 23); break; case 1: p.drawLine(qRound(tabValues[yg].tabPosition), 15, qRound(tabValues[yg].tabPosition), 23); p.drawLine(qRound(tabValues[yg].tabPosition), 23, qRound(tabValues[yg].tabPosition-8), 23); break; case 2: case 3: p.drawLine(qRound(tabValues[yg].tabPosition), 15, qRound(tabValues[yg].tabPosition), 23); p.drawLine(qRound(tabValues[yg].tabPosition-4), 23, qRound(tabValues[yg].tabPosition+4), 23); p.drawLine(qRound(tabValues[yg].tabPosition+3), 20, qRound(tabValues[yg].tabPosition+2), 20); break; case 4: p.drawLine(qRound(tabValues[yg].tabPosition), 15, qRound(tabValues[yg].tabPosition), 23); p.drawLine(qRound(tabValues[yg].tabPosition-4), 23, qRound(tabValues[yg].tabPosition+4), 23); break; default: break; } } } if (haveInd) { p.setPen(QPen(Qt::blue, 1, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin)); p.setBrush(Qt::blue); QPolygon cr; cr.setPoints(3, qRound(firstLine+leftIndent), 12, qRound(firstLine+leftIndent-4), 0, qRound(firstLine+leftIndent+4), 0); p.drawPolygon(cr); QPolygon cr2; cr2.setPoints(3, qRound(leftIndent), 12, qRound(leftIndent+4), 24, qRound(leftIndent-4), 24); p.drawPolygon(cr2); } p.end(); }
QImage* QgsPieDiagramFactory::createDiagram( int size, const QgsFeature& f, const QgsRenderContext& renderContext ) const { QgsAttributeMap dataValues = f.attributeMap(); double sizeScaleFactor = diagramSizeScaleFactor( renderContext ); //create transparent QImage int imageSideLength = size * sizeScaleFactor * renderContext.rasterScaleFactor() + 2 * mMaximumPenWidth + 2 * mMaximumGap; QImage* diagramImage = new QImage( QSize( imageSideLength, imageSideLength ), QImage::Format_ARGB32_Premultiplied ); diagramImage->fill( qRgba( 0, 0, 0, 0 ) ); //transparent background QPainter p; p.begin( diagramImage ); p.setRenderHint( QPainter::Antialiasing ); p.setPen( Qt::NoPen ); //calculate sum of data values double sum = 0; QList<double> valueList; //cash the values to use them in drawing later QgsAttributeMap::const_iterator value_it; QList<QgsDiagramCategory>::const_iterator it = mCategories.constBegin(); for ( ; it != mCategories.constEnd(); ++it ) { value_it = dataValues.find( it->propertyIndex() ); valueList.push_back( value_it->toDouble() ); if ( value_it != dataValues.constEnd() ) { sum += value_it->toDouble(); } } if ( doubleNear( sum, 0.0 ) ) { p.end(); delete diagramImage; return 0; } //draw pies int totalAngle = 0; int currentAngle, currentGap; int xGapOffset = 0; int yGapOffset = 0; QList<QgsDiagramCategory>::const_iterator category_it = mCategories.constBegin(); QList<double>::const_iterator valueList_it = valueList.constBegin(); for ( ; category_it != mCategories.constEnd() && valueList_it != valueList.constEnd(); ++category_it, ++valueList_it ) { p.setPen( category_it->pen() ); currentAngle = ( int )(( *valueList_it ) / sum * 360 * 16 ); p.setBrush( category_it->brush() ); xGapOffset = 0; yGapOffset = 0; currentGap = category_it->gap(); if ( currentGap != 0 ) { //qt angles are degrees*16 gapOffsetsForPieSlice( currentGap, totalAngle + currentAngle / 2, xGapOffset, yGapOffset ); } p.drawPie( mMaximumPenWidth * renderContext.rasterScaleFactor() + mMaximumGap + xGapOffset, mMaximumPenWidth * renderContext.rasterScaleFactor() + mMaximumGap - yGapOffset, sizeScaleFactor * renderContext.rasterScaleFactor() * size, sizeScaleFactor * renderContext.rasterScaleFactor() * size, totalAngle, currentAngle ); totalAngle += currentAngle; } p.end(); return diagramImage; }
// public virtual [base kpCommand] void kpToolAutoCropCommand::unexecute () { #if DEBUG_KP_TOOL_AUTO_CROP && 1 kdDebug () << "kpToolAutoCropCommand::unexecute()" << endl; #endif kpDocument *doc = document (); if (!doc) return; QPixmap pixmap (m_oldWidth, m_oldHeight); QBitmap maskBitmap; // restore the position of the centre image kpPixmapFX::setPixmapAt (&pixmap, m_contentsRect, *doc->pixmap (m_actOnSelection)); // draw the borders QPainter painter (&pixmap); QPainter maskPainter; const kpToolAutoCropBorder *borders [] = { &m_leftBorder, &m_rightBorder, &m_topBorder, &m_botBorder, 0 }; const QPixmap *pixmaps [] = { m_leftPixmap, m_rightPixmap, m_topPixmap, m_botPixmap, 0 }; const QPixmap **p = pixmaps; for (const kpToolAutoCropBorder **b = borders; *b; b++, p++) { if (!(*b)->exists ()) continue; if ((*b)->isSingleColor ()) { kpColor col = (*b)->referenceColor (); #if DEBUG_KP_TOOL_AUTO_CROP && 1 kdDebug () << "\tdrawing border " << (*b)->rect () << " rgb=" << (int *) col.toQRgb () /* %X hack */ << endl; #endif if (col.isOpaque ()) { painter.fillRect ((*b)->rect (), col.toQColor ()); } else { if (maskBitmap.isNull ()) { // TODO: dangerous when a painter is active on pixmap? maskBitmap = kpPixmapFX::getNonNullMask (pixmap); maskPainter.begin (&maskBitmap); } maskPainter.fillRect ((*b)->rect (), Qt::color0/*transparent*/); } } else { #if DEBUG_KP_TOOL_AUTO_CROP && 1 kdDebug () << "\trestoring border pixmap " << (*b)->rect () << endl; #endif // **p cannot contain a single transparent pixel because // if it did, all other pixels must be transparent (only // transparent pixels are similar to transparent pixels) // and the other branch would execute. if (*p) { // TODO: We should really edit the mask here. Due to good // luck (if "maskBitmap" is initialized above, this region // will be marked as opaque in the mask; if it's not // initialized, we will be opaque by default), we // don't actually have to edit the mask but this is // highly error-prone. painter.drawPixmap ((*b)->rect (), **p); } } } if (maskPainter.isActive ()) maskPainter.end (); painter.end (); if (!maskBitmap.isNull ()) pixmap.setMask (maskBitmap); if (!m_actOnSelection) doc->setPixmap (pixmap); else { kpSelection sel = m_oldSelection; sel.setPixmap (pixmap); doc->setSelection (sel); if (m_mainWindow->tool ()) m_mainWindow->tool ()->somethingBelowTheCursorChanged (); } deleteUndoPixmaps (); }
void MainWindow::on_divideButton_clicked() { cubeRow = ui->cubeRow->value(); cubeCol = ui->cubeCol->value(); if(cubeRow*cubeCol >= 4 && !filename.isEmpty() && image_origin.rows >= cubeRow*3 && image_origin.cols >= cubeCol*3) { //I. divide image //1.prepare //int largeSquare = (int)floor(sqrt(cubeNum));//get the largest square that can be made //qDebug() << "largeSquare:" <<largeSquare; float picRatio = (float)image_origin.rows / (float)image_origin.cols;//row行数col列数 //qDebug() << "picRatio:" <<picRatio; float cubeRatio = (float)cubeRow / (float)cubeCol; int scale, fixedCol, fixedRow; if(picRatio >= cubeRatio)//row long { scale = image_origin.cols/(cubeCol*3);//img size devide cube's totol col fixedRow = scale*cubeRow*3;//set the size corresponding cube's fixedCol = scale*cubeCol*3; } else//col long { scale = image_origin.rows/(cubeRow*3); fixedRow = scale*cubeRow*3; fixedCol = scale*cubeCol*3; } int removeRows = image_origin.rows - fixedRow; int removeCols = image_origin.cols - fixedCol; //qDebug()<<"scale:"<<scale<<" row:"<<fixedRow<<" col:"<<fixedCol<<" Original resolution:"<<image_origin.rows<<image_origin.cols<<" remove:"<<removeRows<<removeCols; int removeRows_top,removeRows_down,removeCols_left,removeCols_right; if(removeRows%2 != 0)//the remove num of rows is not even number { //up need remove one more than down removeRows_top = removeRows/2 + 1; removeRows_down = removeRows/2; } else removeRows_top = removeRows_down = removeRows/2; if(removeCols%2 != 0)//the remove num of cols is not even number { //left need remove one more than right removeCols_left = removeCols/2 + 1; removeCols_right = removeCols/2; } else removeCols_left = removeCols_right = removeCols/2; //qDebug()<<"removeRow_fixed:"<<removeRows_top<<removeRows_down<<"removeCol_fixed:"<<removeCols_left<<removeCols_right; cv::Mat fixedImage = image_origin(Rect(removeCols_left,removeRows_top,fixedCol,fixedRow));//改好大小的图片 //resize the image cv::Size dsize = cv::Size(cubeCol*3,cubeRow*3);//Image resolution of the match cube ratio //cv::Mat image_resize = fixedImage; cv::resize(fixedImage, image_resize, dsize); image_resize = changeRubixColor(image_resize); cv::cvtColor(image_resize, image_resize, CV_BGR2RGB); //image_resize---->this is what we want!!!! QImage QimgResize = QImage((const unsigned char*)(image_resize.data),image_resize.cols,image_resize.rows, image_resize.cols*image_resize.channels(), QImage::Format_RGB888); //qDebug() << "QimgResizeRect:" << QimgResize.rect(); ui->picLabel->clear(); imgScaled = QimgResize.scaled(ui->picLabel->size(),Qt::KeepAspectRatio); //qDebug() << "imgScaledRect:" << imgScaled.rect(); ui->picLabel->setPixmap(QPixmap::fromImage(imgScaled));//image insert into label /*--------------------------drawing grids----------------------------*/ QPicture picture; QPainter painter; QPen pen_thick,pen_thin; pen_thick.setWidth(3); pen_thick.setColor(Qt::gray); pen_thin.setWidth(1); pen_thin.setColor(Qt::gray); painter.begin(&picture); picture.setBoundingRect(imgScaled.rect()); //set the boundary of painting //draw col line painter.setPen(pen_thin); for(int i = 0; i <= cubeCol*3; i++) painter.drawLine(QLineF((float)imgScaled.rect().width()/cubeCol/3.0*i, 0, (float)imgScaled.rect().width()/cubeCol/3.0*i, imgScaled.rect().height())); painter.setPen(pen_thick); for(int i = 0; i <= cubeCol; i++) painter.drawLine(QLineF((float)imgScaled.rect().width()/cubeCol*i, 0, (float)imgScaled.rect().width()/cubeCol*i, imgScaled.rect().height())); //draw row line painter.setPen(pen_thin); for(int i = 0; i <= cubeRow*3; i++) painter.drawLine(QLineF(0, (float)imgScaled.rect().height()/cubeRow/3.0*i, imgScaled.rect().width(), (float)imgScaled.rect().height()/cubeRow/3.0*i)); painter.setPen(pen_thick); for(int i = 0; i <= cubeRow; i++) painter.drawLine(QLineF(0, (float)imgScaled.rect().height()/cubeRow*i, imgScaled.rect().width(), (float)imgScaled.rect().height()/cubeRow*i)); painter.end(); picture.save("draw_record.pic"); ui->picLabelUp->setPicture(picture); } else if(cubeRow*cubeCol < 4) { int ret = QMessageBox::warning(this, "Warning", "The number of cubes is at least four!", QMessageBox::Abort); if (ret == QMessageBox::Abort) qDebug() << "WARNING!!"; } else if(filename.isEmpty()) { int ret = QMessageBox::warning(this, "Warning", "You need choose an image file!", QMessageBox::Abort); if (ret == QMessageBox::Abort) qDebug() << "WARNING!!"; } else if(image_origin.rows < cubeRow*3 || image_origin.cols < cubeCol*3) { int ret = QMessageBox::warning(this, "Warning", "Too many cubes!", QMessageBox::Abort); if (ret == QMessageBox::Abort) qDebug() << "WARNING!!"; } }
void PlayField::mouseMoveEvent(QMouseEvent *e) { lastMouseXPos_ = e->x(); lastMouseYPos_ = e->y(); if (!dragInProgress_) return highlight(); int old_x = dragX_, old_y = dragY_; dragX_ = lastMouseXPos_ - mousePosX_; dragY_ = lastMouseYPos_ - mousePosY_; { int x = pixel2x(dragX_ + size_/2); int y = pixel2y(dragY_ + size_/2); if (x >= 0 && x < levelMap_->width() && y >= 0 && y < levelMap_->height() && pathFinder_.canDragTo(x, y)) { x = x2pixel(x); y = y2pixel(y); if (dragX_ >= x - size_/4 && dragX_ < x + size_/4 && dragY_ >= y - size_/4 && dragY_ < y + size_/4) { dragX_ = x; dragY_ = y; } } } if (dragX_ == old_x && dragY_ == old_y) return; QRect rect(dragX_, dragY_, size_, size_); dragXpm_= QPixmap(size_, size_); QPainter paint; paint.begin(&dragXpm_); paint.setBackground(palette().color(backgroundRole())); paint.setBrushOrigin(- dragX_, - dragY_); paint.translate((double) (- dragX_), (double) (- dragY_)); paintPainter(paint, rect); paint.end(); dragImage_ = dragXpm_.toImage(); for (int yy=0; yy<size_; yy++) { for (int xx=0; xx<size_; xx++) { QRgb rgb1 = imageData_->objectImg().pixel(xx, yy); int r1 = qRed(rgb1); int g1 = qGreen(rgb1); int b1 = qBlue(rgb1); if (r1 != g1 || r1 != b1 || r1 == 255) { QRgb rgb2 = dragImage_.pixel(xx, yy); int r2 = qRed(rgb2); int g2 = qGreen(rgb2); int b2 = qBlue(rgb2); r2 = (int) (0.75 * r1 + 0.25 * r2 + 0.5); g2 = (int) (0.75 * g1 + 0.25 * g2 + 0.5); b2 = (int) (0.75 * b1 + 0.25 * b2 + 0.5); dragImage_.setPixel(xx, yy, qRgb(r2, g2, b2)); } } } paint.begin(this); // the following line is a workaround for a bug in Qt 2.0.1 // (and possibly earlier versions) paint.setBrushOrigin(0, 0); dragXpm_ = QPixmap::fromImage(dragImage_, Qt::OrderedDither|Qt::OrderedAlphaDither| Qt::ColorOnly|Qt::AvoidDither); paint.drawPixmap(dragX_, dragY_, dragXpm_); { int dx = dragX_ - old_x; int dy = dragY_ - old_y; int y2 = old_y; if (dy > 0) { paintPainterClip(paint, old_x, old_y, size_, dy); // NOTE: clipping is now activated in the QPainter paint y2 += dy; } else if (dy < 0) { paintPainterClip(paint, old_x, old_y+size_+dy, size_, -dy); // NOTE: clipping is now activated in the QPainter paint dy = -dy; } if (dx > 0) { paintPainterClip(paint, old_x, y2, dx, size_-dy); // NOTE: clipping is now activated in the QPainter paint } else if (dx < 0) { paintPainterClip(paint, old_x+size_+dx, y2, -dx, size_-dy); // NOTE: clipping is now activated in the QPainter paint } } paint.end(); }
bool rasterizePolygons(QString const &outputFolder, QList<QList<Vec2d> > const &listPolygons) { qDebug() << "INFO: Rasterizing polys to images in" << outputFolder; int kSzMult=100; QImage shImage1(180*kSzMult,180*kSzMult, QImage::Format_RGB888); QImage shImage2(180*kSzMult,180*kSzMult, QImage::Format_RGB888); shImage1.fill(Qt::white); shImage2.fill(Qt::white); // setup painter QPainter shPainter; QBrush shBrush(Qt::blue); // draw polys on image 1 shPainter.begin(&shImage1); shPainter.setPen(Qt::NoPen); for(int i=0; i < listPolygons.size(); i++) { QPainterPath pPath; pPath.setFillRule(Qt::WindingFill); pPath.moveTo(listPolygons[i][0].x*kSzMult, listPolygons[i][0].y*kSzMult); for(int j=0; j < listPolygons[i].size(); j++) { pPath.lineTo(listPolygons[i][j].x*kSzMult, listPolygons[i][j].y*kSzMult); } pPath.closeSubpath(); shBrush.setColor(listPolygons[i][0].c); shPainter.setBrush(shBrush); shPainter.drawPath(pPath); } shPainter.end(); // draw polys on image2 shPainter.begin(&shImage2); shPainter.setPen(Qt::NoPen); for(int i=0; i < listPolygons.size(); i++) { QPainterPath pPath; pPath.setFillRule(Qt::WindingFill); pPath.moveTo(listPolygons[i][0].x*kSzMult - 180*kSzMult, listPolygons[i][0].y*kSzMult); for(int j=0; j < listPolygons[i].size(); j++) { pPath.lineTo(listPolygons[i][j].x*kSzMult - 180*kSzMult, listPolygons[i][j].y*kSzMult); } pPath.closeSubpath(); shBrush.setColor(listPolygons[i][0].c); shPainter.setBrush(shBrush); shPainter.drawPath(pPath); } shPainter.end(); QString fname1 = outputFolder + "/imgW.png"; QString fname2 = outputFolder + "/imgE.png"; if(shImage1.save(fname1) && shImage2.save(fname2)) { qDebug() << "INFO: Saved images as" << fname1 << "and" << fname2; return true; } qDebug() << "ERROR: Could not save images"; return false; }
void ColorCombo::addColors() { QRect rect( 0, 0, width(), 20 ); QPixmap pixmap( rect.width(), rect.height() ); QPainter painter; QPen pen; int i; clear(); for ( i = 0; i < STANDARD_PAL_SIZE; i++ ) if ( standardPalette[i] == internalcolor ) break; if ( i == STANDARD_PAL_SIZE ) customColor = internalcolor; insertItem( i18n("None") ); if ( qGray( customColor.rgb() ) < 128 ) pen.setColor( white ); else pen.setColor( black ); painter.begin( &pixmap ); QBrush brush( customColor ); painter.fillRect( rect, brush ); painter.setPen( pen ); painter.drawText( 2, painter.fontMetrics().height(), i18n("Custom...") ); painter.end(); insertItem( pixmap ); pixmap.detach(); bool findColor = false; for ( i = 0; i < STANDARD_PAL_SIZE; i++ ) { painter.begin( &pixmap ); QBrush brush( standardPalette[i] ); painter.fillRect( rect, brush ); painter.end(); insertItem( pixmap ); pixmap.detach(); if ( standardPalette[i] == internalcolor ) { setCurrentItem( i + 2 ); findColor = true; } } if ( !findColor ) setCurrentItem(1); if ( !hascolor ) setCurrentItem(0); }
void WindowServerLuna::generateWallpaperImages() { qreal hScale, vScale, wallpaperScale, wallpaperScaleRot = 0.0; int screenWidth = SystemUiController::instance()->currentUiWidth(); int screenHeight = SystemUiController::instance()->currentUiHeight(); QPixmap image = QPixmap(m_wallpaperFileName); if (image.isNull()) return; bool desktop(false); #ifdef TARGET_DESKTOP desktop = true; #endif if(((image.width() < screenWidth) || (image.height() < screenHeight)) && ((image.height() < screenWidth) || (image.width() < screenHeight)) && !desktop) { // image is not large enough to fill the screen in any orientation, so do not scale it and // draw it centered on the screen m_normalWallpaperImage = QPixmap(image.width(), image.height()); m_rotatedWallpaperImage = QPixmap(); wallpaperScale = 1; m_wallpaperFullScreen = false; if (m_normalWallpaperImage.isNull()) return; } else { // image can fill the screen in some orientations, so scale it to always fill the entire screen m_normalWallpaperImage = QPixmap(m_screenWidth, m_screenHeight); m_rotatedWallpaperImage = QPixmap(m_screenWidth, m_screenHeight); hScale = (qreal)m_screenWidth / image.width(); vScale = (qreal)m_screenHeight / image.height(); if(hScale >= vScale) wallpaperScale = hScale; else wallpaperScale = vScale; vScale = (qreal)m_screenHeight / image.width(); hScale = (qreal)m_screenWidth / image.height(); if(hScale >= vScale) wallpaperScaleRot = hScale; else wallpaperScaleRot = vScale; m_wallpaperFullScreen = true; if (m_normalWallpaperImage.isNull()) return; if (m_rotatedWallpaperImage.isNull()) return; } QRect target; QPainter painter; painter.begin(&m_normalWallpaperImage); target = QRect((-image.rect().width()/2), (-image.rect().height()/2), image.rect().width(), image.rect().height()); painter.setRenderHint(QPainter::SmoothPixmapTransform, true); painter.translate(m_normalWallpaperImage.width()/2, m_normalWallpaperImage.height()/2); painter.scale(wallpaperScale,wallpaperScale); painter.drawPixmap(target, image); painter.end(); if(m_wallpaperFullScreen) {// also generate the cropped and rotated version painter.begin(&m_rotatedWallpaperImage); target = QRect((-image.rect().width()/2), (-image.rect().height()/2), image.rect().width(), image.rect().height()); painter.setRenderHint(QPainter::SmoothPixmapTransform, true); painter.translate(m_rotatedWallpaperImage.width()/2, m_rotatedWallpaperImage.height()/2); painter.rotate(90); painter.scale(wallpaperScaleRot,wallpaperScaleRot); painter.drawPixmap(target, image); painter.end(); } if(Settings::LunaSettings()->displayUiRotates) { updateWallpaperForRotation(m_currentUiOrientation); } else { m_currWallpaperImg = &m_normalWallpaperImage; Q_EMIT signalWallpaperImageChanged(m_currWallpaperImg, m_wallpaperFullScreen, 0); } }
/** This is overloaded function. It's version for SVG vector image. * * Sets required image size. * \return negative value when an error has occured * \return 0 when an unsupported SharedInformation::sizeUnit value was set * \return 1 when success (for 2 (\e bytes) value of SharedInformation::sizeUnit only) */ char ConvertThread::computeSize(QSvgRenderer *renderer, const QString &imagePath) { QSize defaultSize = renderer->defaultSize(); if (shared.sizeUnit == 0) // px // compute size when it wasn't typed in pixels return 1; else if (shared.sizeUnit == 1) { // % width *= defaultSize.width() / 100.; height *= defaultSize.height() / 100.; return 1; } else if (shared.sizeUnit == 2) { // bytes width = defaultSize.width(); height = defaultSize.height(); hasWidth = true; hasHeight = true; double destSize = shared.sizeBytes; if (isLinearFileSizeFormat(&destSize)) { double sourceSizeSqrt = sqrt(width * height); double sourceWidthRatio = width / sourceSizeSqrt; double sourceHeightRatio = height / sourceSizeSqrt; destSize = sqrt(destSize); width = sourceWidthRatio * destSize; height = sourceHeightRatio * destSize; } else { // non-linear size relationship QString tempFilePath = QDir::tempPath() + QDir::separator() + "sir_temp" + QString::number(tid) + "." + shared.format; qint64 fileSize = QFile(imagePath).size(); QSize size = defaultSize; double fileSizeRatio = (double) fileSize / shared.sizeBytes; fileSizeRatio = sqrt(fileSizeRatio); QFile tempFile(tempFilePath); QPainter painter; for (uchar i=0; i<10 && (fileSizeRatio<0.97412 || fileSizeRatio>1.); i++) { tempFile.open(QIODevice::WriteOnly); tempFile.seek(0); width = size.width() / fileSizeRatio; height = size.height() / fileSizeRatio; QImage tempImage(width, height, QImage::Format_ARGB32); fillImage(&tempImage); painter.begin(&tempImage); renderer->render(&painter); painter.end(); tempImage = paintEffects(&tempImage); tempImage = rotateImage(tempImage); #ifdef SIR_METADATA_SUPPORT updateThumbnail(tempImage); #endif // SIR_METADATA_SUPPORT if (tempImage.save(&tempFile, 0, shared.quality)) { #ifdef SIR_METADATA_SUPPORT if (saveMetadata) metadata.write(tempFilePath, tempImage); #endif // SIR_METADATA_SUPPORT } else { qWarning("tid %d: Save temporary image file " "into %s failed", tid, String(targetFilePath). toNativeStdString().data()); emit imageStatus(imageData, tr("Failed to compute image size"), Failed); return -4; } tempFile.close(); fileSize = tempFile.size(); size = tempImage.size(); fileSizeRatio = (double) fileSize / shared.sizeBytes; fileSizeRatio = sqrt(fileSizeRatio); } // ask overwrite char answer = askOverwrite(&tempFile); if (answer < 0) return answer; } return 2; } return 0; }
void TimeRuler::initUI() { int width = m_widthMonth + (m_lstDates.numYears() * 12 ) * m_widthMonth + m_widthMonth; m_pixmap = QPixmap(width, m_height); m_pixmap.fill(backgroundColor()); QPainter p (&m_pixmap); p.save(); p.setPen(Qt::gray); p.setBrush(Qt::white); QStyle& style = KApplication::kApplication()->style(); //draw a frame QColorGroup cg = colorGroup(); cg.setColor(QColorGroup::Background, Qt::white); style.drawPrimitive(QStyle::PE_ButtonBevel, &p, QRect(m_widthMonth, 3, width - 2 * m_widthMonth, m_yBase - 3), cg); p.restore(); //first create the month counter on a temporaroy pixmap QPixmap tp(12 * m_widthMonth, 20); tp.fill(backgroundColor()); QPainter tpp (&tp); tpp.translate(0,20); tpp.rotate(-90); QFont f(p.font()); f.setPixelSize(10); f.setBold(false); tpp.setFont(f); for (int i = 0; i <12; ++i) { tpp.drawText(0, i * m_widthMonth, 20, m_widthMonth, Qt::AlignRight | Qt::AlignVCenter, QString::number(i+1)); } tpp.end(); int over = -2; int x = 0; //reset the counting mechanism... m_lstDates.count(-1); for (int y = m_lstDates.firstYear(); y <= m_lstDates.lastYear(); ++ y) { for (int m = 1; m <= 12 ; ++m) { x = m_widthMonth + ((y - m_lstDates.firstYear())*12 + m -1 ) * m_widthMonth; if (m == 1) { bitBlt(&m_pixmap, x, m_yBase + 3, &tp, 0, 0, tp.width(), tp.height()); //draw the year numbers f.setPixelSize(16); f.setBold(true); p.setFont(f); p.drawText(x, m_yBase, 12 * m_widthMonth, m_height-m_yBase, Qt::AlignHCenter | Qt::AlignBottom, QString::number(y)); //draw the bold year lines p.setPen(QPen(Qt::gray, 3)); p.drawLine(x, m_yBase+over, x, m_yBase+22); p.setPen(QPen(Qt::black, 1)); p.drawLine(x, m_yBase+over, x, m_yBase+22); } else if (m == 7) { //draw the semi big half year marks p.setPen(QPen(Qt::gray, 3)); p.drawLine(x, m_yBase+over, x, m_yBase+8); p.setPen(QPen(Qt::black, 1)); p.drawLine(x, m_yBase+over, x, m_yBase+8); } else { //draw the thin month marks p.setPen(QPen(Qt::black, 1)); p.drawLine(x, m_yBase+over, x, m_yBase+8); } drawBeam(&p, m_lstDates.count(y,m, -1, true) * 100 / m_lstDates.maxMonth(), y, m); } } //draw the final year bar thats missing from the loop x += m_widthMonth; p.setPen(QPen(Qt::gray, 3)); p.drawLine(x, m_yBase+over, x, m_yBase+22); p.setPen(QPen(Qt::black, 1)); p.drawLine(x, m_yBase+over, x, m_yBase+22); //now draw the base line p.setPen(QPen(Qt::black, 1)); p.drawLine(10, m_yBase, width - 10 , m_yBase); //done p.end(); }
void MainWindow::drawGraph(bool notEmpty) { QPixmap graph(540,370); QPainter paint; paint.begin(&graph); paint.eraseRect(0,0,540,370); paint.drawLine(Ox*onePixelX,0,Ox*onePixelX,pictHeight); paint.drawLine(0,Oy*onePixelY,pictWidth,Oy*onePixelY); paint.setPen(QPen(Qt::black,3)); for(double i = leftX;i<=rightX;i+=10.0) paint.drawPoint((i+Ox)*onePixelX,Oy*onePixelY); for(double i = leftY;i<=rightY;i+=10.0) paint.drawPoint(Ox*onePixelX,(i+Oy)*onePixelY); if(!notEmpty) { paint.end(); ui->outputGraph->setPixmap(graph); return; } paint.setPen(QPen(Qt::green,1,Qt::SolidLine)); paint.setRenderHint(QPainter::Antialiasing, true); QPainterPath path,p[3]; bool first[4] = {1,1,1,1}; for(double i = (double)leftX+step;i<=(double)rightX;i+=step) { if(!isnan(f(i))) { if(first[0]) { path.moveTo((i+Ox)*onePixelX,(f(i)+Oy)*onePixelY); first[0] = false; } else path.lineTo((i+Ox)*onePixelX,(f(i)+Oy)*onePixelY); } if(!isnan(f1(i))) { if(first[1]) { p[0].moveTo((i+Ox)*onePixelX,(f1(i)+Oy)*onePixelY); first[1] = false; } else p[0].lineTo((i+Ox)*onePixelX,(f1(i)+Oy)*onePixelY); } if(!isnan(f2(i))) { if(first[2]) { p[1].moveTo((i+Ox)*onePixelX,(f2(i)+Oy)*onePixelY); first[2] = false; } else p[1].lineTo((i+Ox)*onePixelX,(f2(i)+Oy)*onePixelY); } if(!isnan(f3(i))) { if(first[3]) { p[2].moveTo((i+Ox)*onePixelX,(f3(i)+Oy)*onePixelY); first[3] = false; } else p[2].lineTo((i+Ox)*onePixelX,(f3(i)+Oy)*onePixelY); } } if(ui->main->isChecked()) { paint.setPen(QPen(Qt::blue,1,Qt::SolidLine)); paint.drawPath(path); } if(ui->sin->isChecked()) { paint.setPen(QPen(Qt::green,1,Qt::SolidLine)); paint.drawPath(p[0]); } if(ui->cos->isChecked()) { paint.setPen(QPen(Qt::red,1,Qt::SolidLine)); paint.drawPath(p[1]); } if(ui->tg->isChecked()) { paint.setPen(QPen(Qt::darkMagenta,1,Qt::SolidLine)); paint.drawPath(p[2]); } paint.end(); ui->outputGraph->setPixmap(graph); return; }
void GLView::paintEvent( QPaintEvent * event ) { makeCurrent(); QPainter painter; painter.begin( this ); painter.setRenderHint( QPainter::TextAntialiasing ); #else void GLView::paintGL() { #endif // Save GL state glPushAttrib( GL_ALL_ATTRIB_BITS ); glMatrixMode( GL_PROJECTION ); glPushMatrix(); glMatrixMode( GL_MODELVIEW ); glPushMatrix(); // Clear Viewport if ( scene->visMode & Scene::VisSilhouette ) { qglClearColor( QColor( 255, 255, 255, 255 ) ); } //glViewport( 0, 0, width(), height() ); glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT ); // Compile the model if ( doCompile ) { textures->setNifFolder( model->getFolder() ); scene->make( model ); scene->transform( Transform(), scene->timeMin() ); axis = (scene->bounds().radius <= 0) ? 1024.0 : scene->bounds().radius; if ( scene->timeMin() != scene->timeMax() ) { if ( time < scene->timeMin() || time > scene->timeMax() ) time = scene->timeMin(); emit sequencesUpdated(); } else if ( scene->timeMax() == 0 ) { // No Animations in this NIF emit sequencesDisabled( true ); } emit sceneTimeChanged( time, scene->timeMin(), scene->timeMax() ); doCompile = false; } // Center the model if ( doCenter ) { setCenter(); doCenter = false; } // Transform the scene Matrix ap; // TODO: Redo for new Settings class //if ( Options::upAxis() == Options::YAxis ) { // ap( 0, 0 ) = 0; ap( 0, 1 ) = 0; ap( 0, 2 ) = 1; // ap( 1, 0 ) = 1; ap( 1, 1 ) = 0; ap( 1, 2 ) = 0; // ap( 2, 0 ) = 0; ap( 2, 1 ) = 1; ap( 2, 2 ) = 0; //} else if ( Options::upAxis() == Options::XAxis ) { // ap( 0, 0 ) = 0; ap( 0, 1 ) = 1; ap( 0, 2 ) = 0; // ap( 1, 0 ) = 0; ap( 1, 1 ) = 0; ap( 1, 2 ) = 1; // ap( 2, 0 ) = 1; ap( 2, 1 ) = 0; ap( 2, 2 ) = 0; //} Transform viewTrans; viewTrans.rotation.fromEuler( Rot[0] / 180.0 * PI, Rot[1] / 180.0 * PI, Rot[2] / 180.0 * PI ); viewTrans.rotation = viewTrans.rotation * ap; viewTrans.translation = viewTrans.rotation * Pos; if ( view != ViewWalk ) viewTrans.translation[2] -= Dist * 2; scene->transform( viewTrans, time ); // Setup projection mode glProjection(); glLoadIdentity(); // Draw the grid if ( scene->options & Scene::ShowAxes ) { glDisable( GL_ALPHA_TEST ); glDisable( GL_BLEND ); glDisable( GL_LIGHTING ); glDisable( GL_COLOR_MATERIAL ); glEnable( GL_DEPTH_TEST ); glDepthMask( GL_TRUE ); glDepthFunc( GL_LESS ); glDisable( GL_TEXTURE_2D ); glDisable( GL_NORMALIZE ); glLineWidth( 2.0f ); glPushMatrix(); glLoadMatrix( viewTrans ); // TODO: Configurable grid in Settings // 1024 game units, major lines every 128, minor lines every 64 drawGrid( 1024, 128, 2 ); glPopMatrix(); } #ifndef QT_NO_DEBUG // Debug scene bounds glEnable( GL_DEPTH_TEST ); glDepthMask( GL_TRUE ); glDepthFunc( GL_LESS ); glPushMatrix(); glLoadMatrix( viewTrans ); if ( debugMode == DbgBounds ) { BoundSphere bs = scene->bounds(); bs |= BoundSphere( Vector3(), axis ); drawSphere( bs.center, bs.radius ); } glPopMatrix(); #endif GLfloat mat_spec[] = { 0.0f, 0.0f, 0.0f, 1.0f }; if ( scene->options & Scene::DoLighting ) { // Setup light Vector4 lightDir( 0.0, 0.0, 1.0, 0.0 ); if ( !frontalLight ) { float decl = declination / 180.0 * PI; Vector3 v( sin( decl ), 0, cos( decl ) ); Matrix m; m.fromEuler( 0, 0, planarAngle / 180.0 * PI ); v = m * v; lightDir = Vector4( viewTrans.rotation * v, 0.0 ); if ( scene->visMode & Scene::VisLightPos ) { glEnable( GL_BLEND ); glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA ); glEnable( GL_DEPTH_TEST ); glDepthMask( GL_TRUE ); glDepthFunc( GL_LESS ); glPushMatrix(); glLoadMatrix( viewTrans ); glLineWidth( 2.0f ); glColor4f( 1.0f, 1.0f, 1.0f, 0.5f ); // Scale the distance a bit float l = axis + 64.0; l = (l < 128) ? axis * 1.5 : l; l = (l > 2048) ? axis * 0.66 : l; l = (l > 1024) ? axis * 0.75 : l; drawDashLine( Vector3( 0, 0, 0 ), v * l, 30 ); drawSphere( v * l, axis / 10 ); glPopMatrix(); glDisable( GL_BLEND ); } } float amb = ambient; if ( (scene->visMode & Scene::VisNormalsOnly) && (scene->options & Scene::DoTexturing) && !(scene->options & Scene::DisableShaders) ) { amb = 0.1f; } GLfloat mat_amb[] = { amb, amb, amb, 1.0f }; GLfloat mat_diff[] = { brightness, brightness, brightness, 1.0f }; glShadeModel( GL_SMOOTH ); glEnable( GL_LIGHTING ); glEnable( GL_LIGHT0 ); glLightfv( GL_LIGHT0, GL_AMBIENT, mat_amb ); glLightfv( GL_LIGHT0, GL_DIFFUSE, mat_diff ); glLightfv( GL_LIGHT0, GL_SPECULAR, mat_diff ); glLightfv( GL_LIGHT0, GL_POSITION, lightDir.data() ); // Necessary? glLightModeli( GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE ); } else { float amb = 0.5f; if ( scene->options & Scene::DisableShaders ) { amb = 0.0f; } GLfloat mat_amb[] = { amb, amb, amb, 1.0f }; GLfloat mat_diff[] = { 1.0f, 1.0f, 1.0f, 1.0f }; glShadeModel( GL_SMOOTH ); glEnable( GL_LIGHTING ); glEnable( GL_LIGHT0 ); glLightfv( GL_LIGHT0, GL_AMBIENT, mat_amb ); glLightfv( GL_LIGHT0, GL_DIFFUSE, mat_diff ); glLightfv( GL_LIGHT0, GL_SPECULAR, mat_spec ); } if ( scene->visMode & Scene::VisSilhouette ) { GLfloat mat_diff[] = { 0.0f, 0.0f, 0.0f, 1.0f }; GLfloat mat_amb[] = { 0.0f, 0.0f, 0.0f, 1.0f }; glShadeModel( GL_FLAT ); glEnable( GL_LIGHTING ); glEnable( GL_LIGHT0 ); glLightModelfv( GL_LIGHT_MODEL_AMBIENT, mat_diff ); glMaterialfv( GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, mat_diff ); glLightfv( GL_LIGHT0, GL_AMBIENT, mat_amb ); glLightfv( GL_LIGHT0, GL_DIFFUSE, mat_diff ); glLightfv( GL_LIGHT0, GL_SPECULAR, mat_spec ); } if ( scene->options & Scene::DoMultisampling ) glEnable( GL_MULTISAMPLE_ARB ); #ifndef QT_NO_DEBUG // Color Key debug if ( debugMode == DbgColorPicker ) { glDisable( GL_MULTISAMPLE ); glDisable( GL_LINE_SMOOTH ); glDisable( GL_TEXTURE_2D ); glDisable( GL_BLEND ); glDisable( GL_DITHER ); glDisable( GL_LIGHTING ); glShadeModel( GL_FLAT ); glDisable( GL_FOG ); glDisable( GL_MULTISAMPLE_ARB ); glEnable( GL_DEPTH_TEST ); glDepthFunc( GL_LEQUAL ); glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT ); Node::SELECTING = 1; } else { Node::SELECTING = 0; } #endif // Draw the model scene->draw(); if ( scene->options & Scene::ShowAxes ) { // Resize viewport to small corner of screen int axesSize = std::min( width() / 10, 125 ); glViewport( 0, 0, axesSize, axesSize ); // Reset matrices glMatrixMode( GL_PROJECTION ); glLoadIdentity(); // Square frustum auto nr = 1.0; auto fr = 250.0; GLdouble h2 = tan( FOV / 360 * M_PI ) * nr; GLdouble w2 = h2; glFrustum( -w2, +w2, -h2, +h2, nr, fr ); // Reset matrices glMatrixMode( GL_MODELVIEW ); glLoadIdentity(); glPushMatrix(); // Store and reset viewTrans translation auto viewTransOrig = viewTrans.translation; // Zoom out slightly viewTrans.translation = { 0, 0, -150.0 }; // Load modified viewTrans glLoadMatrix( viewTrans ); // Restore original viewTrans translation viewTrans.translation = viewTransOrig; // Find direction of axes auto vtr = viewTrans.rotation; QVector<float> axesDots = { vtr( 2, 0 ), vtr( 2, 1 ), vtr( 2, 2 ) }; drawAxesOverlay( { 0, 0, 0 }, 50.0, sortAxes( axesDots ) ); glPopMatrix(); // Restore viewport size glViewport( 0, 0, width(), height() ); // Restore matrices glProjection(); } // Restore GL state glPopAttrib(); glMatrixMode( GL_MODELVIEW ); glPopMatrix(); glMatrixMode( GL_PROJECTION ); glPopMatrix(); // Check for errors GLenum err; while ( ( err = glGetError() ) != GL_NO_ERROR ) qDebug() << tr( "glview.cpp - GL ERROR (paint): " ) << (const char *)gluErrorString( err ); emit paintUpdate(); // Manually handle the buffer swap swapBuffers(); #ifdef USE_GL_QPAINTER painter.end(); #endif }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- QImage PoleFigureImageUtilities::PaintPoleFigureOverlay(int imageWidth, int imageHeight, QString label, QImage image) { int pxHigh = 0; int pxWide = 0; // Scale the Font Point size to something reasonable to the size of the image. Here our standard was 14Pt Font when the // Pole figure was 512 Pixels square. int fontPtSize = imageHeight / 32; QFont font("Ariel", fontPtSize, QFont::Bold); QFontMetrics metrics(font); pxHigh = metrics.height(); pxWide = metrics.width(QString("Y")); int pxOffset = 2 * pxWide; int pyOffset = 2 * pxHigh; int pImageWidth = imageWidth + pxOffset * 2; int pImageHeight = imageHeight + pyOffset * 2; QImage pImage(pImageWidth, pImageHeight, QImage::Format_ARGB32_Premultiplied); pImage.fill(0xFFFFFFFF); // All white background // Create a Painter backed by a QImage to draw into QPainter painter; painter.begin(&pImage); painter.setRenderHint(QPainter::Antialiasing, true); qint32 penWidth = 1; #if 0 // DRAW A BORDER AROUND THE IMAGE FOR DEBUGGING QColor c(RgbColor::dRgb(255, 0, 0, 255)); painter.setPen(QPen(c, penWidth, Qt::SolidLine, Qt::SquareCap, Qt::RoundJoin)); painter.drawLine(0, 0, pImageWidth, 0); // Top painter.drawLine(0, 0, 0, pImageHeight); // Left painter.drawLine(pImageWidth, 0, pImageWidth, pImageHeight); // Right painter.drawLine(0, pImageHeight, pImageWidth, pImageHeight); // Bottom //----------------- #endif painter.setFont(font); // metrics = painter.fontMetrics(); // pxHigh = metrics.height(); // pxWide = metrics.width(QString("Y")); // Draw the Pole Figure into the center of the canvas QPoint point(pxOffset, pyOffset); painter.drawImage(point, image); // Scale pen width based on the size of the image penWidth = imageHeight / 256; painter.setPen(QPen(QColor(0, 0, 0, 255), penWidth, Qt::SolidLine, Qt::RoundCap, Qt::RoundJoin)); // Draw the Outer circular border around the pole figure QPainterPath circle; QPointF center(pImageWidth / 2, pImageHeight / 2); circle.addEllipse(center, imageWidth / 2, imageHeight / 2); painter.drawPath(circle); // Label the X Axis painter.drawText(pImageWidth - (pxWide * 1.5), pImageHeight / 2 + pxHigh / 3, "X"); // Label the Y Axis pxWide = metrics.width(QString("Y")); painter.drawText(pImageWidth / 2 - pxWide / 2, pyOffset - penWidth - 1, "Y"); // Draw the name of the Pole Figure int labelWidth = 0; int maxWidth = pImageWidth / 5; // No more than a Quarter of the width of the image while(labelWidth < maxWidth) { fontPtSize++; font = QFont("Ariel", fontPtSize, QFont::Bold); metrics = QFontMetrics(font); labelWidth = metrics.width(label); // Figure out which string is longer (pixel wise) } painter.setFont(font); pxHigh = metrics.height() + 2; // pxWide = metrics.width(label); painter.drawText(pxOffset, pxHigh, label); // Draw slightly transparent lines //penWidth = 1; painter.setPen(QPen(QColor(0, 0, 0, 180), penWidth, Qt::SolidLine, Qt::RoundCap, Qt::RoundJoin)); // Draw the X Axis painter.drawLine(pxOffset, pImageHeight / 2, pImageWidth - pxOffset, pImageHeight / 2); // Draw the Y Axis painter.drawLine(pImageWidth / 2, pyOffset, pImageWidth / 2, pImageHeight - pyOffset); painter.end(); return pImage; }
void MapScene::add_mark(QPointF pos, Tag mark,Channel channel) { QPointF posForPicture = QPointF(pos.x()-12.0, pos.y()-12.0); //QPointF posForText = QPointF(pos.x()-24.0, pos.y()+24.0); QGraphicsPixmapItem * pi = 0; QString channel_name = channel.getName(); if(channel_name == "Fuel prices") { pi = addPixmap(QPixmap(":/img/fuel.png")); } else if(channel_name == "Public announcements") { pi = addPixmap(QPixmap(":/img/public.png")); } else if(channel_name == "ObsTestChannel") { pi = addPixmap(QPixmap(":/img/test.png")); //painter.drawText(posForText, "Test text"); } else if(channel_name.startsWith("bus_")) { pi = addPixmap(QPixmap(":/img/bus.png")); //painter.drawText(posForText, channel_name.split('_').at(1)); } else if(channel_name.startsWith("tram_")) { pi = addPixmap(QPixmap(":/img/tram.png")); //painter.drawText(posForText, channel_name.split('_').at(1)); } else if(channel_name.startsWith("troll_")) { pi = addPixmap(QPixmap(":/img/trolleybus.png")); //painter.drawText(posForText, channel_name.split('_').at(1)); } else if(channel_name.startsWith("user_")) { pi = addPixmap(QPixmap(":/img/user.png")); } else { QPixmap pixmap(50,50); pixmap.fill(Qt::transparent); QPoint center(pixmap.width()/2, pixmap.height()/4); QPoint posForText = QPoint(0, pixmap.height()/2+8); QPainter painter; painter.begin(&pixmap); QFont font=painter.font(); font.setPointSize(7); painter.setFont(font); painter.setBrush(Qt::blue); painter.drawEllipse(center, pixmap.width()/4, pixmap.height()/4); painter.setBrush(Qt::black); painter.drawEllipse(center, pixmap.width()/10, pixmap.height()/10); int mins_ago=(mark.getTime().toUTC().secsTo(QDateTime::currentDateTime()))/60; qDebug() << "Text for mark: " << mark.getLabel()+", "+ QString::number(mins_ago)+" min. ago" ; painter.drawText(posForText,QString::number(mins_ago)+" min ago"); painter.end(); pi = this->addPixmap(pixmap); } pi->setX(posForPicture.x()); pi->setY(posForPicture.y()); m_marks.push_back(pi); }
void MainWidget::paintGL() { makeCurrent(); QPainter painter; painter.begin(this); painter.beginNativePainting(); glClearColor(0.0f, 0.0f, 0.0f, 1.0f); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // Enable depth buffer if(bDepthTest) glEnable(GL_DEPTH_TEST); QQuaternion quat = this->trackball.rotation(); // Calculate model view transformation QMatrix4x4 modelviewearth; modelviewearth.translate(0.0, 0.0, distance); modelviewearth.rotate(quat); QMatrix4x4 rotmatrix; rotmatrix.rotate(quat); programskybox.bind(); skybox->render(projection, modelviewearth, rotmatrix); programskybox.release(); if(bWireFrame) // Draw as wireframe glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); else glPolygonMode(GL_FRONT_AND_BACK, GL_FILL); if(bTexture) { if(bNoBump) { programearthnobump.bind(); textureearth->bind(0); geometries->render(projection, modelviewearth, bNoBump); textureearth->release(); programearthnobump.release(); } else { programearth.bind(); textureearth->bind(0); texturenormal->bind(1); geometries->render(projection, modelviewearth, bNoBump); texturenormal->release(); textureearth->release(); programearth.release(); } } glPolygonMode(GL_FRONT_AND_BACK, GL_FILL); if(bBorders) { programgshhs.bind(); gshhs->render(projection, modelviewearth); gshhs->rendersoc(projection, modelviewearth); programgshhs.release(); } glDisable(GL_DEPTH_TEST); painter.endNativePainting(); QString framesPerSecond; if (const int elapsed = m_time.elapsed()) { framesPerSecond.setNum(m_frames /(elapsed / 1000.0), 'f', 2); painter.setPen(Qt::white); painter.drawText(20, 40, framesPerSecond + " paintGL calls / s"); } //this->setWindowTitle(framesPerSecond + " paintGL calls / s" ); painter.end(); if (!(m_frames % 100)) { m_time.start(); m_frames = 0; } ++m_frames; }
void ScalePlot::drawScale () { QPainter painter; painter.begin(&buffer); painter.setFont(plotFont); painter.setPen(QPen(borderColor, 1, QPen::SolidLine)); painter.fillRect(0, 0, buffer.width(), buffer.height(), backgroundColor); QMemArray<double> scaleArray; scaler.getScaleArray(scaleArray); QFontMetrics fm(plotFont); int x = 0; int loop; for (loop = 0; loop < (int) scaleArray.size(); loop++) { int y = scaler.convertToY(scaleArray[loop]); painter.drawLine (x, y, x + 4, y); // draw the text QString s; strip(scaleArray[loop], 4, s); // abbreviate too many (>=3) trailing zeroes in large numbers on y-axes if (! mainFlag) { bool flag = FALSE; if (s.toDouble() < 0) { flag = TRUE; s.remove(0, 1); } if (s.toDouble() >= 1000000000) { strip(s.toDouble() / 1000000000, 4, s); s.append("b"); } else { if (s.toDouble() >= 1000000) { strip(s.toDouble() / 1000000, 4, s); s.append("m"); } // else // { // if (s.toDouble() >= 1000) // { // strip(s.toDouble() / 1000, 4, s); // s.append("k"); // } // } } if (flag) s.prepend("-"); } painter.drawText(x + 7, y + (fm.height() / 2), s); } painter.drawLine (x, 0, x, buffer.height()); // draw the last value pointer on the scale of main plot int y = scaler.convertToY(close); QPointArray array; array.setPoints(3, x + 2, y, x + 8, y - 4, x + 8, y + 4); painter.setBrush(borderColor); painter.drawPolygon(array, TRUE, 0, -1); painter.end(); }
~TestFixtureForPaintingWindowDrawingMethods() { _painter.end(); _test_window->scrollArea()->deleteLater(); }
void ImageArea::drawCursor() { QPainter painter; mPixmap = new QPixmap(25, 25); QPoint center(13, 13); switch(DataSingleton::Instance()->getInstrument()) { case NONE_INSTRUMENT: case LINE: case COLORPICKER: case MAGNIFIER: case SPRAY: case FILL: case RECTANGLE: case ELLIPSE: case CURSOR: case INSTRUMENTS_COUNT: case CURVELINE: case TEXT: break; case PEN: case ERASER: mPixmap->fill(QColor(0, 0, 0, 0)); break; } painter.begin(mPixmap); switch(DataSingleton::Instance()->getInstrument()) { case NONE_INSTRUMENT: case LINE: case COLORPICKER: case MAGNIFIER: case SPRAY: case FILL: case RECTANGLE: case ELLIPSE: case CURSOR: case INSTRUMENTS_COUNT: case CURVELINE: case TEXT: break; case PEN: if(mRightButtonPressed) { painter.setPen(QPen(DataSingleton::Instance()->getSecondaryColor())); painter.setBrush(QBrush(DataSingleton::Instance()->getSecondaryColor())); } else { painter.setPen(QPen(DataSingleton::Instance()->getPrimaryColor())); painter.setBrush(QBrush(DataSingleton::Instance()->getPrimaryColor())); } painter.drawEllipse(center, DataSingleton::Instance()->getPenSize()/2, DataSingleton::Instance()->getPenSize()/2); break; case ERASER: painter.setBrush(QBrush(Qt::white)); painter.drawEllipse(center, DataSingleton::Instance()->getPenSize()/2, DataSingleton::Instance()->getPenSize()/2); break; } painter.setPen(Qt::black); painter.drawPoint(13, 13); painter.drawPoint(13, 3); painter.drawPoint(13, 5); painter.drawPoint(13, 21); painter.drawPoint(13, 23); painter.drawPoint(3, 13); painter.drawPoint(5, 13); painter.drawPoint(21, 13); painter.drawPoint(23, 13); painter.setPen(Qt::white); painter.drawPoint(13, 12); painter.drawPoint(13, 14); painter.drawPoint(12, 13); painter.drawPoint(14, 13); painter.drawPoint(13, 4); painter.drawPoint(13, 6); painter.drawPoint(13, 20); painter.drawPoint(13, 22); painter.drawPoint(4, 13); painter.drawPoint(6, 13); painter.drawPoint(20, 13); painter.drawPoint(22, 13); painter.end(); }