C++ 在qt中更改svg的颜色

我在参考资料中加载了一个svg，但它是黑色的。如何将颜色更改为白色？

只要您在Mac上不需要它，这应该可以：

编辑：或者，如果您需要支持Mac，请在QGraphicsView中执行svg渲染和效果

将着色效果设置为白色，并将其设置为svgWidget

---

希望有帮助。

如果白色是您唯一需要的颜色，那么一个简单的解决方案就是使用图像编辑器（例如Inkscape）更改原始SVG图像的颜色。当然，如果您需要使用多种颜色的图像，这将不是一个合理的解决方案。

因为SVG格式是基于XML的，XML只是ASCII文本。。。您可以将SVG资源加载到QString中，调用QString:：replace（“000000”）和“ffffff”），然后将修改后的QString传递到QSVGrender中。

这是在Qt中实现的方法，别忘了将xml和SVG模块添加到Qt项目（*.pro文件）。此代码段通过修改任何“path”元素的“fill”属性来更改颜色，但您可以使用它来修改任何元素的任何属性

void SetAttrRecur(QDomElement &elem, QString strtagname, QString strattr, QString strattrval);

void ChangeSVGColor()
{

    // open svg resource load contents to qbytearray
    QFile file("myfile.svg");
    file.open(QIODevice::ReadOnly);
    QByteArray baData = file.readAll();
    // load svg contents to xml document and edit contents
    QDomDocument doc;
    doc.setContent(baData);
    // recurivelly change color
    SetAttrRecur(doc.documentElement(), "path", "fill", "white");
    // create svg renderer with edited contents
    QSvgRenderer svgRenderer(doc.toByteArray());
    // create pixmap target (could be a QImage)
    QPixmap pix(svgRenderer.defaultSize());
    pix.fill(Qt::transparent);
    // create painter to act over pixmap
    QPainter pixPainter(&pix);
    // use renderer to render over painter which paints on pixmap
    svgRenderer.render(&pixPainter);
    QIcon myicon(pix);
    // Use icon ....    

}


void SetAttrRecur(QDomElement &elem, QString strtagname, QString strattr, QString strattrval)
{
    // if it has the tagname then overwritte desired attribute
    if (elem.tagName().compare(strtagname) == 0)
    {
        elem.setAttribute(strattr, strattrval);
    }
    // loop all children
    for (int i = 0; i < elem.childNodes().count(); i++)
    {
        if (!elem.childNodes().at(i).isElement())
        {
            continue;
        }
        SetAttrRecur(elem.childNodes().at(i).toElement(), strtagname, strattr, strattrval);
    }
}

void SetAttrRecur（qdomeElement&elem、QString strtagname、QString strattrval、QString strattrval）；
void ChangeSVGColor（）
{
//打开svg资源加载内容到qbytearray
QFile文件（“myfile.svg”）；
open（QIODevice:：ReadOnly）；
QByteArray baData=file.readAll（）；
//将svg内容加载到xml文档并编辑内容
QDOM文件文档；
文件设置内容（baData）；
//反复变色
SetAttrRecur（doc.documentElement（），“路径”，“填充”，“白色”）；
//使用编辑的内容创建svg渲染器
qsvgrendersvgrender（doc.toByteArray（））；
//创建pixmap目标（可以是QImage）
QPixmap pix（svgrender.defaultSize（））；
pix.fill（Qt：：透明）；
//创建要在pixmap上执行操作的画师
QPainter-pixPainter（&pix）；
//使用渲染器渲染在pixmap上绘制的画师
svgrender.render（&pixPainter）；
奇康myicon（pix）；
//使用图标。。。。
}
无效设置属性重复出现（QdomeElement&elem、QString strtagname、QString strattr、QString strattrval）
{
//如果它有标记名，则覆盖所需的属性
if（elem.tagName（）.compare（strtagname）==0）
{
元素setAttribute（strattr，strattrval）；
}
//循环所有子项
对于（int i=0；i

您可以使用彩色套印，如本问题末尾所述：

---

它不会改变SVG，但会创建一个彩色图层，该图层的形状与您的图形相同（假设您的图形背景是透明的）。

如果您的SVG是黑色的，有一种非常简单的方法：QGraphicsEffect

#include <QGraphicsItem>
#include <QGraphicsColorizeEffect>

QGraphicsItem *item;
QGraphicsColorizeEffect *effect;    

item = new QGraphicsItem;
effect = new QGraphicsColorizeEffect;

effect->setColor(Qt::white);
effect->setStrength(1);

item->setGraphicsEffect(effect)    

#包括
#包括
QM*项目；
QGraphicsColorizeEffect*效应；
项目=新的QM；
效果=新的QGraphicsColorizeEffect；
效果->设置颜色（Qt:：白色）；
效果->设置强度（1）；
项目->设置图形效果（效果）

这不适用于白色SVG，但考虑到几乎所有提供黑色图标的网站都是这样做的，这相当不错。

\ifndef SVG\u ITEM\H
#ifndef SVG_ITEM_H
#define SVG_ITEM_H

#include <QObject>
#include <QPen>
#include <QQuickItem>
#include <QQuickPaintedItem>
#include <QSvgRenderer>


class SVG_Item : public QQuickPaintedItem
{

    Q_PROPERTY(QString source READ source WRITE setSource NOTIFY sourceChanged)
    Q_PROPERTY(QColor color READ color WRITE setColor NOTIFY colorChanged)
    Q_PROPERTY(QPen stroke READ stroke WRITE setStroke NOTIFY strokeChanged)
    Q_PROPERTY(bool debuging READ debuging WRITE setdebuging)
    Q_PROPERTY(QColor backgroundColor READ backgroundColor WRITE setBackgroundColor NOTIFY backgroundColorChanged)

    Q_OBJECT

public:
    explicit SVG_Item(QQuickItem *parent = nullptr);
    void paint(QPainter *painter) Q_DECL_OVERRIDE;
    QString source() const;
    QColor color() const;
    QPen stroke() const;
    bool debuging() const;

    QColor backgroundColor() const;

signals:
    void sourceChanged(QString source);
    void colorChanged(QColor color);
    void strokeChanged(QPen stroke);
    void backgroundColorChanged(QColor backgroundColor);

public slots:
    void setSource(QString source);
    void setColor(QColor color);
    void setStroke(QPen stroke);
    void setdebuging(bool debuging);    
    void setBackgroundColor(QColor backgroundColor);

private:
    QString m_source;
    QColor m_color;
    QPen m_stroke;
    QString svgContent;
    QSvgRenderer *renderer;
    bool changed;
    bool m_debuging;
    QColor m_backgroundColor;
    QColor m_test;
};

#endif // SVG_ITEM_H





#include "svg_item.h"

#include <QSvgRenderer>
#include <QDebug>
#include <QPainter>
#include <QSvgGenerator>

SVG_Item::SVG_Item(QQuickItem *parent) : QQuickPaintedItem(parent)
{
    changed = false;
    renderer = NULL;
    m_debuging = false;
    m_backgroundColor = Qt::transparent;
}


void SVG_Item::paint(QPainter *painter)
{
    painter->fillRect(0,0,this->width(),this->height(),m_backgroundColor);
    if(m_source != "")
    {
        if(changed)
        {
            if(renderer != NULL)
            {
                renderer->deleteLater();
            }
            renderer = new QSvgRenderer(svgContent.toLocal8Bit());
        }
        if(renderer != NULL)
            renderer->render(painter);
    }

}


void SVG_Item::setSource(QString source)
{
    if(source.startsWith("qrc"))
        source = source.remove(0,3);
    if (m_source == source)
        return;

    QFile readFile(source);
    if(!readFile.exists())
    {
        qWarning("file not found");
    }
    readFile.open(QFile::ReadOnly);
    svgContent = readFile.readAll();

    setColor(color());

    //readData.replace()

    m_source = source;
    emit sourceChanged(m_source);
}

void SVG_Item::setColor(QColor color)
{
    changed = true;
    QString fillStr = "fill:%1";
    fillStr = fillStr.arg(color.name());
    svgContent = svgContent.replace(QRegExp("fill:[# 0-9 a b c d e f A B C D E F]+"), fillStr);

    if(!svgContent.contains(QRegExp("fill:[# 0-9 a b c d e f A B C D E F]+")))
    {
        QString style = "<path \n style=\"fill:%1;fill-opacity:1\"";
        style = style.arg(color.name());
        svgContent = svgContent.replace("<path",style);

        style = "<rect \n style=\"fill:%1;fill-opacity:1\"";
        style = style.arg(color.name());
        svgContent = svgContent.replace("<rect",style);

        style = "<circle \n style=\"fill:%1;fill-opacity:1\"";
        style = style.arg(color.name());
        svgContent = svgContent.replace("<circle",style);

        style = "<ellipse \n style=\"fill:%1;fill-opacity:1\"";
        style = style.arg(color.name());
        svgContent = svgContent.replace("<ellipse",style);

        style = "<polygon \n style=\"fill:%1;fill-opacity:1\"";
        style = style.arg(color.name());
        svgContent = svgContent.replace("<polygon",style);
    }

    //

    this->update();

    if (m_color == color)
        return;

    m_color = color;
    emit colorChanged(m_color);
}

void SVG_Item::setStroke(QPen stroke)
{
    changed = true;
    if (m_stroke == stroke)
        return;

    m_stroke = stroke;
    emit strokeChanged(m_stroke);
}

void SVG_Item::setdebuging(bool debuging)
{
    m_debuging = debuging;
}

void SVG_Item::setBackgroundColor(QColor backgroundColor)
{
    if (m_backgroundColor == backgroundColor)
        return;

    m_backgroundColor = backgroundColor;
    emit backgroundColorChanged(m_backgroundColor);
}


QString SVG_Item::source() const
{
    return m_source;
}

QColor SVG_Item::color() const
{
    return m_color;
}

QPen SVG_Item::stroke() const
{
    return m_stroke;
}

bool SVG_Item::debuging() const
{
    return m_debuging;
}


QColor SVG_Item::backgroundColor() const
{
    return m_backgroundColor;
}

#定义SVG_项目
#包括
#包括
#包括
#包括
#包括
类SVG_项：公共QQuickPaintedItem
{
Q_属性（QString源读取源写入设置源通知源已更改）
Q_属性（QColor颜色读取颜色写入设置颜色通知颜色更改）
Q_属性（QPen笔划读取笔划写入设置笔划通知笔划更改）
Q_属性（布尔调试读取调试写入设置调试）
Q_属性（QColor backgroundColor读取backgroundColor写入setBackgroundColor通知backgroundColorChanged）
Q_对象
公众：
显式SVG_项（QQuickItem*parent=nullptr）；
无效油漆（油漆工*油漆工）Q_DECL_覆盖；
QString source（）常量；
QColor color（）常数；
QPen stroke（）常数；
bool debuging（）常量；
QColor backgroundColor（）常量；
信号：
void sourceChanged（QString source）；
空隙颜色改变（QColor颜色）；
无效冲程改变（QPen冲程）；
无效背景颜色更改（QColor backgroundColor）；
公众时段：
void setSource（QString source）；
void setColor（QColor颜色）；
无效设定行程（QPen行程）；
无效设置调试（bool调试）；
void setBackgroundColor（QColor backgroundColor）；
私人：
QString m_源；
QColor m_颜色；
QPen m_中风；
QString SVG内容；
QSVGrender*渲染器；
布尔变了；
boolmu调试；
QColor m_背景色；
QColor m_试验；
};
#endif//SVG\u项目
#包括“svg_item.h”
#包括
#包括
#包括
#包括
SVG_项：：SVG_项（QQuickItem*父项）：QQuickPaintedItem（父项）
{
更改=错误；
渲染器=空；
m_调试=错误；
m_backgroundColor=Qt:：透明；
}
无效SVG_项：：绘制（QPainter*painter）
{
painter->fillRect（0,0，this->width（），this->height（），m_backgroundColor）；
如果（m_源！=“”）
{
如果（更改）
{
if（渲染器！=NULL）
{
渲染器->删除后期（）；
}
renderer=新的QSvgRenderer（svgContent.toLocal8Bit（））；
}
if（渲染器！=NULL）
渲染器->渲染（画师）；
}
}
void SVG_Item:：setSource（QString源）
{
if（source.startsWith（“qrc”））
source=source.remove（0,3）；
if（m_source==source）
返回；
QFile readFile（源文件）；
如果（！readFile.exists（））
{
qWarning（“未找到文件”）；
}
打开（QFile:：ReadOnly）；
svgContent=readFile.readAll（）；
setColor（color（））；
//readData.replace（）
m_源=源；
发射源已更改（m_源）；
}
无效SVG_项：：设置颜色（QColor颜色
def QIcon_from_svg(svg_filepath, color='black'):
    img = QPixmap(svg_filepath)
    qp = QPainter(img)
    qp.setCompositionMode(QPainter.CompositionMode_SourceIn)
    qp.fillRect( img.rect(), QColor(color) )
    qp.end()
    return QIcon(img)