C++ QColor::rgb方法代码示例

QuillImage LoadFilter::renderAlpha(const QuillImage &image,
                                   const QColor &backgroundColor)
{
    QuillImage target(image, QImage(image.size(), QImage::Format_RGB32));
    target.fill(backgroundColor.rgb());
    QPainter painter(&target);
    painter.drawImage(QPoint(0, 0), image);
    return target;
}

void Exercise123::diffusePixel(QImage &image, int x, int y, const float &weight, const float &error) {
    if (!inBounds(image, x, y)) {
        return;
    }

    QColor pixel = getPixel(image, x, y);
    QColor diffusedPixel = getDiffusedColor(pixel, weight, error);
    image.setPixel(x, y, diffusedPixel.rgb());
}

void EditorTablePropertiesForm::setColorForButtonBackgroundColor(QColor iColor)
{
  // Квадратик на кнопке выбора цвета кода
  QPixmap pix(16, 16);
  pix.fill(iColor.rgb());
  buttonBackgroundColor.setIcon(pix);

  backgroundColor=iColor;
}

void Canvas::paint(const QPoint center, const int radius,const QColor color,QImage& efffectiveImage){
    for(int x = center.x()-radius; x < center.x()+radius; x++){
        for(int y = center.y()-radius; y < center.y()+radius; y++){
            if(Util::calcL2Distance(center, QPoint(x,y)) < radius){
                efffectiveImage.setPixel(x, y,color.rgb());
            }
        }
    }
}

void ColorView::setValue(const QColor &col)
{
    if (col.rgb() == value_.rgb()) {
        return;
    }
    value_ = col;
    update();
    emit valueChanged(col);
}

void KbLight::color(const QColor& newColor){
    QRgb newRgb = newColor.rgb();
    QMutableHashIterator<QString, QRgb> i(_colorMap);
    while(i.hasNext()){
        i.next();
        i.value() = newRgb;
    }
    _needsSave = true;
}

void MainWindow::update(){
    // we draw by using a QImage - turn it into a Pixmap, then put it on a label
    QImage img(200, 200, QImage::Format_RGB32);
    bool display;
    /* Our color wheel has a radius of 100.  Loop through the rectangle
      looking for pixels within that radius. For good pixels we calculate
      the H value based on the angle from the origin.  The S value is
      set according to the distance / radius, and the V is fixed (but
      settable by a slider).
     */
    for (int i = 0; i < 200; i++)
    {
        for (int j = 0; j < 200; j++)
        {
            float dist = sqrt((i - 100) * (i - 100) + (j - 100) * (j - 100));
            if (dist < 100.0)
            {
                display = true;
                float s = dist / 100.0f;
                float h = atan2(i - 100, j - 100) / (2.0f * 3.14156);
                if (h < 0)
                {
                    h = 1.0f + h;
                }
                // Since H is an angle the math is modulo.
                if (hMax > hMin)
                {
                    if (hMin > h || hMax < h)
                    {
                        display = false;
                    }
                } else if (hMin > h && hMax < h )
                {
                    display = false;
                }
                if (s < sMin || s > sMax)
                {
                    display = false;
                }
                QColor c;
                if (display)
                {
                    c.setHsvF(h, s, zValue);
                } else{
                    c.setHsvF(0.0, 0.0, 1.0f);
                }
                img.setPixel(i, j, c.rgb());
            }
        }
    }
    QPixmap pix;
    pix.convertFromImage(img);
    ui->colwheel->setPixmap(pix);
    ui->colwheel->repaint();

}

QColor RenderReplaced::selectionColor(QPainter *p) const
{
    QColor color = RenderBox::selectionColor(p);
         
    // Force a 60% alpha so that no user-specified selection color can obscure selected images.
    if (qAlpha(color.rgb()) > 153)
        color = QColor(qRgba(color.red(), color.green(), color.blue(), 153));

    return color;
}

RGBA Qwt3D::Qt2GL(QColor col)
{
	QRgb qrgb = col.rgb();
	RGBA rgba;
	rgba.r = qRed(qrgb) / 255.0;
	rgba.g = qGreen(qrgb) / 255.0;
	rgba.b = qBlue(qrgb) / 255.0;
	rgba.a = qAlpha(qrgb) / 255.0;
	return rgba;	
}

void MixerDetails::trackColorChanged(QColor col)
      {
      if (trackColorLabel->color() != col) {
            trackColorLabel->blockSignals(true);
            trackColorLabel->setColor(col);
            trackColorLabel->blockSignals(false);
            }

      _mti->setColor(col.rgb());
      }

QColor macGetColor( const QColor& initial, QWidget *parent, const char *name )
{
    bool ok;
    QRgb rgb = macGetRgba( initial.rgb(), &ok, parent, name );

    QColor ret;
    if(ok)
	ret = QColor(rgb);
    return ret;
}

void BBTCOView::setColor( QColor new_color )
{
	if( new_color.rgb() != m_bbTCO->color() )
	{
		m_bbTCO->setColor( new_color );
		m_bbTCO->m_useStyleColor = false;
		Engine::getSong()->setModified();
		update();
	}
	BBTrack::setLastTCOColor( new_color );
}

QString QTextFormat::getKey( const QFont &fn, const QColor &col, bool misspelled, VerticalAlignment a )
{
    QString k = fn.key();
    k += '/';
    k += QString::number( (uint)col.rgb() );
    k += '/';
    k += QString::number( (int)misspelled );
    k += '/';
    k += QString::number( (int)a );
    return k;
}

 static void FillAndFrameBlack(QImage* image, const QColor& color, int size)
 {
     image->fill(color.rgb());
     for (int i = 0; i < size; i++)
     {
         image->setPixel(0, i, 0);
         image->setPixel(size - 1, i, 0);
         image->setPixel(i, 0, 0);
         image->setPixel(i, size - 1, 0);
     }
 }

/**
 * @brief Canvas::bucket
 * @brief 颜料桶工具的绘制函数，用特定的颜色填充整个图像区域
 * @param color 表示所绘制的颜色
 * @return 没有返回值
 */
void Canvas::bucket(const QColor color){
    QImage* image = &(this->layerManager->getDisplayLayerItem()->image);

    for(int x = 0; x < image->width(); x++){
        for(int y = 0; y < image->height(); y++){
            image->setPixel(x, y,color.rgb());
        }
    }

    this->update();
}