12611954629

Committed 04 Jan 2025 04:17PM UTC coverage: 31.468% (-0.5%) from 31.963%

Build # 12611954629

Build Type

Pull #1649

github

Committed by

web-flow

Commit Message

Merge d17d3ec9b into 3ed321c32

Pull Request Pull Request #1649: Function Wizard: create Effects

Run Details

2 of 53 new or added lines in 2 files covered. (3.77%)

2597 existing lines in 15 files now uncovered.

14093 of 44785 relevant lines covered (31.47%)

26791.82 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

4.02

/engine/src/rgbimage.cpp

/*
  Q Light Controller Plus
  rgbimage.cpp

  Copyright (c) Heikki Junnila
  Copyright (c) Jano Svitok
  Copyright (c) Massimo Callegari

  Licensed under the Apache License, Version 2.0 (the "License");
  you may not use this file except in compliance with the License.
  You may obtain a copy of the License at

      http://www.apache.org/licenses/LICENSE-2.0.txt

  Unless required by applicable law or agreed to in writing, software
  distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions and
  limitations under the License.
*/

#include <QXmlStreamReader>
#include <QXmlStreamWriter>
#include <QPainter>
#include <QDebug>

#include "rgbimage.h"
#include "qlcmacros.h"
#include "doc.h"

#define KXMLQLCRGBImageFilename       QString("Filename")
#define KXMLQLCRGBImageAnimationStyle QString("Animation")
#define KXMLQLCRGBImageOffset         QString("Offset")
#define KXMLQLCRGBImageOffsetX        QString("X")
#define KXMLQLCRGBImageOffsetY        QString("Y")

RGBImage::RGBImage(Doc * doc)
    : RGBAlgorithm(doc)
    , m_filename("")
    , m_animatedSource(false)
    , m_animationStyle(Static)
    , m_xOffset(0)
    , m_yOffset(0)
{
}

RGBImage::RGBImage(const RGBImage& i)
    : RGBAlgorithm(i.doc())
    , m_filename(i.filename())
    , m_animatedSource(i.animatedSource())
    , m_animationStyle(i.animationStyle())
    , m_xOffset(i.xOffset())
    , m_yOffset(i.yOffset())
{
    reloadImage();
}

RGBImage::~RGBImage()
{
}

RGBAlgorithm* RGBImage::clone() const
{
    RGBImage* image = new RGBImage(*this);
    return static_cast<RGBAlgorithm*> (image);
}

/****************************************************************************
 * Image file
 ****************************************************************************/

void RGBImage::setFilename(const QString& filename)
{
    m_filename = filename;
    reloadImage();
}

QString RGBImage::filename() const
{
    return m_filename;
}

void RGBImage::setImageData(int width, int height, const QByteArray &pixelData)
{
    QMutexLocker locker(&m_mutex);

    qDebug() << "[RGBImage] setting image data:" << width << height << pixelData.length();
    QImage newImg(width, height, QImage::Format_RGB888);
    newImg.fill(Qt::black);

    int i = 0;
    for (int y = 0; y < height; y++)
    {
        for (int x = 0; x < width; x++)
        {
            if (i + 3 > pixelData.length())
                break;
            QRgb pixel = qRgb((uchar)pixelData.at(i), (uchar)pixelData.at(i + 1), (uchar)pixelData.at(i + 2));
            newImg.setPixel(x, y, pixel);
            i+=3;
        }
    }
    m_image = newImg;
}

bool RGBImage::animatedSource() const
{
    return m_animatedSource;
}

void RGBImage::reloadImage()
{
    m_animatedSource = false;

    if (m_filename.isEmpty())
    {
        qDebug() << "[RGBImage] Empty image!";
        return;
    }

    QMutexLocker locker(&m_mutex);

    if (m_filename.endsWith(".gif"))
    {
        m_animatedPlayer.setFileName(m_filename);
        if (m_animatedPlayer.frameCount() > 1)
            m_animatedSource = true;
    }

    if (m_animatedSource == false)
    {
        if (!m_image.load(m_filename))
        {
            qDebug() << "[RGBImage] Failed to load" << m_filename;
            return;
        }
    }
}

/****************************************************************************
 * Animation
 ****************************************************************************/

void RGBImage::setAnimationStyle(RGBImage::AnimationStyle ani)
{
    if (ani >= Static && ani <= Animation)
        m_animationStyle = ani;
    else
        m_animationStyle = Static;
}

RGBImage::AnimationStyle RGBImage::animationStyle() const
{
    return m_animationStyle;
}

QString RGBImage::animationStyleToString(RGBImage::AnimationStyle ani)
{
    switch (ani)
    {
        default:
        case Static:
            return QString("Static");
        case Horizontal:
            return QString("Horizontal");
        case Vertical:
            return QString("Vertical");
        case Animation:
            return QString("Animation");
    }
}

RGBImage::AnimationStyle RGBImage::stringToAnimationStyle(const QString& str)
{
    if (str == QString("Horizontal"))
        return Horizontal;
    else if (str == QString("Vertical"))
        return Vertical;
    else if (str == QString("Animation"))
        return Animation;
    else
        return Static;
}

QStringList RGBImage::animationStyles()
{
    QStringList list;
    list << animationStyleToString(Static);
    list << animationStyleToString(Horizontal);
    list << animationStyleToString(Vertical);
    list << animationStyleToString(Animation);
    return list;
}

void RGBImage::setXOffset(int offset)
{
    m_xOffset = offset;
}

int RGBImage::xOffset() const
{
    return m_xOffset;
}

void RGBImage::setYOffset(int offset)
{
    m_yOffset = offset;
}

int RGBImage::yOffset() const
{
    return m_yOffset;
}

/****************************************************************************
 * RGBAlgorithm
 ****************************************************************************/

int RGBImage::rgbMapStepCount(const QSize& size)
{
    QMutexLocker locker(&m_mutex);

    switch (animationStyle())
    {
        default:
        case Static:
            return 1;
        case Horizontal:
            return m_image.width();
        case Vertical:
            return m_image.height();
        case Animation:
            qDebug() << m_image.width() << " " << size.width() << " " << (m_image.width() / size.width());
            return MAX(1, m_image.width() / size.width());
    }
}

void RGBImage::rgbMapSetColors(QVector<uint> &colors)
{
    Q_UNUSED(colors);
}

QVector<uint> RGBImage::rgbMapGetColors()
{
    return QVector<uint>();
}

void RGBImage::rgbMap(const QSize& size, uint rgb, int step, RGBMap &map)
{
    Q_UNUSED(rgb);

    QMutexLocker locker(&m_mutex);

    if (m_animatedSource == false && (m_image.width() == 0 || m_image.height() == 0))
        return;

    int xOffs = xOffset();
    int yOffs = yOffset();

    switch(animationStyle())
    {
        default:
        case Static:
        break;
        case Horizontal:
            xOffs += step;
        break;
        case Vertical:
            yOffs += step;
        break;
        case Animation:
            xOffs += step * size.width();
        break;
    }

    if (m_animatedSource)
    {
        m_animatedPlayer.jumpToNextFrame();
        m_image = m_animatedPlayer.currentImage().scaled(size);
    }

    map.resize(size.height());
    for (int y = 0; y < size.height(); y++)
    {
        map[y].resize(size.width());
        for (int x = 0; x < size.width(); x++)
        {
            int x1 = (x + xOffs) % m_image.width();
            int y1 = (y + yOffs) % m_image.height();

            map[y][x] = m_image.pixel(x1,y1);
            if (qAlpha(map[y][x]) == 0)
                map[y][x] = 0;
        }
    }
}

QString RGBImage::name() const
{
    return QString("Image");
}

QString RGBImage::author() const
{
    return QString("Jano Svitok");
}

int RGBImage::apiVersion() const
{
    return 1;
}

RGBAlgorithm::Type RGBImage::type() const
{
    return RGBAlgorithm::Image;
}

int RGBImage::acceptColors() const
{
    return 0;
}

bool RGBImage::loadXML(QXmlStreamReader &root)
{
    if (root.name() != KXMLQLCRGBAlgorithm)
    {
        qWarning() << Q_FUNC_INFO << "RGB Algorithm node not found";
        return false;
    }

    if (root.attributes().value(KXMLQLCRGBAlgorithmType).toString() != KXMLQLCRGBImage)
    {
        qWarning() << Q_FUNC_INFO << "RGB Algorithm is not Image";
        return false;
    }

    while (root.readNextStartElement())
    {
        if (root.name() == KXMLQLCRGBImageFilename)
        {
            setFilename(doc()->denormalizeComponentPath(root.readElementText()));
        }
        else if (root.name() == KXMLQLCRGBImageAnimationStyle)
        {
            setAnimationStyle(stringToAnimationStyle(root.readElementText()));
        }
        else if (root.name() == KXMLQLCRGBImageOffset)
        {
            QString str;
            int value;
            bool ok;
            QXmlStreamAttributes attrs = root.attributes();

            str = attrs.value(KXMLQLCRGBImageOffsetX).toString();
            ok = false;
            value = str.toInt(&ok);
            if (ok == true)
                setXOffset(value);
            else
                qWarning() << Q_FUNC_INFO << "Invalid X offset:" << str;

            str = attrs.value(KXMLQLCRGBImageOffsetY).toString();
            ok = false;
            value = str.toInt(&ok);
            if (ok == true)
                setYOffset(value);
            else
                qWarning() << Q_FUNC_INFO << "Invalid Y offset:" << str;
            root.skipCurrentElement();
        }
        else
        {
            qWarning() << Q_FUNC_INFO << "Unknown RGBImage tag:" << root.name();
            root.skipCurrentElement();
        }
    }

    return true;
}

bool RGBImage::saveXML(QXmlStreamWriter *doc) const
{
    Q_ASSERT(doc != NULL);

    doc->writeStartElement(KXMLQLCRGBAlgorithm);
    doc->writeAttribute(KXMLQLCRGBAlgorithmType, KXMLQLCRGBImage);

    doc->writeTextElement(KXMLQLCRGBImageFilename, this->doc()->normalizeComponentPath(m_filename));

    doc->writeTextElement(KXMLQLCRGBImageAnimationStyle, animationStyleToString(animationStyle()));

    doc->writeStartElement(KXMLQLCRGBImageOffset);
    doc->writeAttribute(KXMLQLCRGBImageOffsetX, QString::number(xOffset()));
    doc->writeAttribute(KXMLQLCRGBImageOffsetY, QString::number(yOffset()));
    doc->writeEndElement();

    /* End the <Algorithm> tag */
    doc->writeEndElement();

    return true;
}

1	/*
2	Q Light Controller Plus
3	rgbimage.cpp
4
5	Copyright (c) Heikki Junnila
6	Copyright (c) Jano Svitok
7	Copyright (c) Massimo Callegari
8
9	Licensed under the Apache License, Version 2.0 (the "License");
10	you may not use this file except in compliance with the License.
11	You may obtain a copy of the License at
12
13	http://www.apache.org/licenses/LICENSE-2.0.txt
14
15	Unless required by applicable law or agreed to in writing, software
16	distributed under the License is distributed on an "AS IS" BASIS,
17	WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
18	See the License for the specific language governing permissions and
19	limitations under the License.
20	*/
21
22	#include <QXmlStreamReader>
23	#include <QXmlStreamWriter>
24	#include <QPainter>
25	#include <QDebug>
26
27	#include "rgbimage.h"
28	#include "qlcmacros.h"
29	#include "doc.h"
30
31	#define KXMLQLCRGBImageFilename QString("Filename")
32	#define KXMLQLCRGBImageAnimationStyle QString("Animation")
33	#define KXMLQLCRGBImageOffset QString("Offset")
34	#define KXMLQLCRGBImageOffsetX QString("X")
35	#define KXMLQLCRGBImageOffsetY QString("Y")
36
37	RGBImage::RGBImage(Doc * doc)	8✔
38	: RGBAlgorithm(doc)
39	, m_filename("")
40	, m_animatedSource(false)
41	, m_animationStyle(Static)
42	, m_xOffset(0)
43	, m_yOffset(0)	8✔
44	{
45	}	8✔
46
47	RGBImage::RGBImage(const RGBImage& i)	×
48	: RGBAlgorithm(i.doc())
49	, m_filename(i.filename())
50	, m_animatedSource(i.animatedSource())	×
51	, m_animationStyle(i.animationStyle())	×
52	, m_xOffset(i.xOffset())	×
53	, m_yOffset(i.yOffset())	×
54	{
55	reloadImage();	×
56	}	×
57
58	RGBImage::~RGBImage()	8✔
59	{
60	}	8✔
61
62	RGBAlgorithm* RGBImage::clone() const	×
63	{
64	RGBImage* image = new RGBImage(*this);	×
65	return static_cast<RGBAlgorithm*> (image);	×
66	}
67
68	/****************************************************************************
69	* Image file
70	****************************************************************************/
71
72	void RGBImage::setFilename(const QString& filename)	×
73	{
74	m_filename = filename;	×
75	reloadImage();	×
76	}	×
77
78	QString RGBImage::filename() const	×
79	{
80	return m_filename;	×
81	}
82
83	void RGBImage::setImageData(int width, int height, const QByteArray &pixelData)	×
84	{
85	QMutexLocker locker(&m_mutex);	×
86
87	qDebug() << "[RGBImage] setting image data:" << width << height << pixelData.length();
88	QImage newImg(width, height, QImage::Format_RGB888);	×
89	newImg.fill(Qt::black);	×
90
91	int i = 0;
92	for (int y = 0; y < height; y++)	×
93	{
94	for (int x = 0; x < width; x++)	×
95	{
96	if (i + 3 > pixelData.length())	×
97	break;
98	QRgb pixel = qRgb((uchar)pixelData.at(i), (uchar)pixelData.at(i + 1), (uchar)pixelData.at(i + 2));	×
99	newImg.setPixel(x, y, pixel);	×
100	i+=3;	×
101	}
102	}
103	m_image = newImg;	×
104	}	×
105
106	bool RGBImage::animatedSource() const	×
107	{
108	return m_animatedSource;	×
109	}
110
111	void RGBImage::reloadImage()	×
112	{
113	m_animatedSource = false;	×
114
115	if (m_filename.isEmpty())	×
116	{
117	qDebug() << "[RGBImage] Empty image!";
118	return;
119	}
120
121	QMutexLocker locker(&m_mutex);	×
122
123	if (m_filename.endsWith(".gif"))	×
124	{
125	m_animatedPlayer.setFileName(m_filename);	×
126	if (m_animatedPlayer.frameCount() > 1)	×
127	m_animatedSource = true;	×
128	}
129
130	if (m_animatedSource == false)	×
131	{
132	if (!m_image.load(m_filename))	×
133	{
134	qDebug() << "[RGBImage] Failed to load" << m_filename;
135	return;
136	}
137	}
138	}
139
140	/****************************************************************************
141	* Animation
142	****************************************************************************/
143
144	void RGBImage::setAnimationStyle(RGBImage::AnimationStyle ani)	×
145	{
146	if (ani >= Static && ani <= Animation)	×
147	m_animationStyle = ani;	×
148	else
149	m_animationStyle = Static;	×
150	}	×
151
152	RGBImage::AnimationStyle RGBImage::animationStyle() const	×
153	{
154	return m_animationStyle;	×
155	}
156
157	QString RGBImage::animationStyleToString(RGBImage::AnimationStyle ani)	×
158	{
159	switch (ani)	×
160	{
161	default:	×
162	case Static:
163	return QString("Static");	×
164	case Horizontal:	×
165	return QString("Horizontal");	×
166	case Vertical:	×
167	return QString("Vertical");	×
168	case Animation:	×
169	return QString("Animation");	×
170	}
171	}
172
173	RGBImage::AnimationStyle RGBImage::stringToAnimationStyle(const QString& str)	×
174	{
175	if (str == QString("Horizontal"))	×
176	return Horizontal;
177	else if (str == QString("Vertical"))	×
178	return Vertical;
179	else if (str == QString("Animation"))	×
180	return Animation;
181	else
182	return Static;	×
183	}
184
185	QStringList RGBImage::animationStyles()	×
186	{
187	QStringList list;
188	list << animationStyleToString(Static);	×
189	list << animationStyleToString(Horizontal);	×
190	list << animationStyleToString(Vertical);	×
191	list << animationStyleToString(Animation);	×
192	return list;	×
193	}
194
195	void RGBImage::setXOffset(int offset)	×
196	{
197	m_xOffset = offset;	×
198	}	×
199
200	int RGBImage::xOffset() const	×
201	{
202	return m_xOffset;	×
203	}
204
205	void RGBImage::setYOffset(int offset)	×
206	{
207	m_yOffset = offset;	×
208	}	×
209
210	int RGBImage::yOffset() const	×
211	{
212	return m_yOffset;	×
213	}
214
215	/****************************************************************************
216	* RGBAlgorithm
217	****************************************************************************/
218
219	int RGBImage::rgbMapStepCount(const QSize& size)	×
220	{
221	QMutexLocker locker(&m_mutex);	×
222
223	switch (animationStyle())	×
224	{
225	default:
226	case Static:
227	return 1;
228	case Horizontal:	×
229	return m_image.width();	×
230	case Vertical:	×
231	return m_image.height();	×
232	case Animation:	×
233	qDebug() << m_image.width() << " " << size.width() << " " << (m_image.width() / size.width());
234	return MAX(1, m_image.width() / size.width());	×
235	}
236	}
237
238	void RGBImage::rgbMapSetColors(QVector<uint> &colors)	×
239	{
240	Q_UNUSED(colors);
UNCOV 241	}	×
242
UNCOV 243	QVector<uint> RGBImage::rgbMapGetColors()	×
244	{
UNCOV 245	return QVector<uint>();	×
246	}
247
248	void RGBImage::rgbMap(const QSize& size, uint rgb, int step, RGBMap &map)	×
249	{
250	Q_UNUSED(rgb);
251
UNCOV 252	QMutexLocker locker(&m_mutex);	×
253
UNCOV 254	if (m_animatedSource == false && (m_image.width() == 0 \|\| m_image.height() == 0))	×
255	return;
256
257	int xOffs = xOffset();	×
258	int yOffs = yOffset();	×
259
260	switch(animationStyle())	×
261	{
262	default:
263	case Static:
264	break;
UNCOV 265	case Horizontal:	×
266	xOffs += step;	×
UNCOV 267	break;	×
268	case Vertical:	×
269	yOffs += step;	×
UNCOV 270	break;	×
UNCOV 271	case Animation:	×
272	xOffs += step * size.width();	×
273	break;	×
274	}
275
276	if (m_animatedSource)	×
277	{
278	m_animatedPlayer.jumpToNextFrame();	×
279	m_image = m_animatedPlayer.currentImage().scaled(size);	×
280	}
281
282	map.resize(size.height());	×
283	for (int y = 0; y < size.height(); y++)	×
284	{
UNCOV 285	map[y].resize(size.width());	×
UNCOV 286	for (int x = 0; x < size.width(); x++)	×
287	{
UNCOV 288	int x1 = (x + xOffs) % m_image.width();	×
UNCOV 289	int y1 = (y + yOffs) % m_image.height();	×
290
UNCOV 291	map[y][x] = m_image.pixel(x1,y1);	×
UNCOV 292	if (qAlpha(map[y][x]) == 0)	×
293	map[y][x] = 0;	×
294	}
295	}
296	}
297
298	QString RGBImage::name() const	7✔
299	{
300	return QString("Image");	7✔
301	}
302
303	QString RGBImage::author() const	×
304	{
305	return QString("Jano Svitok");	×
306	}
307
308	int RGBImage::apiVersion() const	×
309	{
310	return 1;	×
311	}
312
313	RGBAlgorithm::Type RGBImage::type() const	×
314	{
315	return RGBAlgorithm::Image;	×
316	}
317
318	int RGBImage::acceptColors() const	×
319	{
UNCOV 320	return 0;	×
321	}
322
323	bool RGBImage::loadXML(QXmlStreamReader &root)	×
324	{
UNCOV 325	if (root.name() != KXMLQLCRGBAlgorithm)	×
326	{
327	qWarning() << Q_FUNC_INFO << "RGB Algorithm node not found";	×
UNCOV 328	return false;	×
329	}
330
331	if (root.attributes().value(KXMLQLCRGBAlgorithmType).toString() != KXMLQLCRGBImage)	×
332	{
333	qWarning() << Q_FUNC_INFO << "RGB Algorithm is not Image";	×
UNCOV 334	return false;	×
335	}
336
337	while (root.readNextStartElement())	×
338	{
339	if (root.name() == KXMLQLCRGBImageFilename)	×
340	{
UNCOV 341	setFilename(doc()->denormalizeComponentPath(root.readElementText()));	×
342	}
UNCOV 343	else if (root.name() == KXMLQLCRGBImageAnimationStyle)	×
344	{
345	setAnimationStyle(stringToAnimationStyle(root.readElementText()));	×
346	}
347	else if (root.name() == KXMLQLCRGBImageOffset)	×
348	{
UNCOV 349	QString str;	×
350	int value;
351	bool ok;
352	QXmlStreamAttributes attrs = root.attributes();	×
353
354	str = attrs.value(KXMLQLCRGBImageOffsetX).toString();	×
355	ok = false;	×
356	value = str.toInt(&ok);	×
UNCOV 357	if (ok == true)	×
358	setXOffset(value);	×
359	else
UNCOV 360	qWarning() << Q_FUNC_INFO << "Invalid X offset:" << str;	×
361
UNCOV 362	str = attrs.value(KXMLQLCRGBImageOffsetY).toString();	×
363	ok = false;	×
364	value = str.toInt(&ok);	×
UNCOV 365	if (ok == true)	×
UNCOV 366	setYOffset(value);	×
367	else
UNCOV 368	qWarning() << Q_FUNC_INFO << "Invalid Y offset:" << str;	×
UNCOV 369	root.skipCurrentElement();	×
370	}
371	else
372	{
UNCOV 373	qWarning() << Q_FUNC_INFO << "Unknown RGBImage tag:" << root.name();	×
UNCOV 374	root.skipCurrentElement();	×
375	}
376	}
377
378	return true;
379	}
380
UNCOV 381	bool RGBImage::saveXML(QXmlStreamWriter *doc) const	×
382	{
383	Q_ASSERT(doc != NULL);
384
385	doc->writeStartElement(KXMLQLCRGBAlgorithm);	×
UNCOV 386	doc->writeAttribute(KXMLQLCRGBAlgorithmType, KXMLQLCRGBImage);	×
387
388	doc->writeTextElement(KXMLQLCRGBImageFilename, this->doc()->normalizeComponentPath(m_filename));	×
389
390	doc->writeTextElement(KXMLQLCRGBImageAnimationStyle, animationStyleToString(animationStyle()));	×
391
UNCOV 392	doc->writeStartElement(KXMLQLCRGBImageOffset);	×
UNCOV 393	doc->writeAttribute(KXMLQLCRGBImageOffsetX, QString::number(xOffset()));	×
UNCOV 394	doc->writeAttribute(KXMLQLCRGBImageOffsetY, QString::number(yOffset()));	×
UNCOV 395	doc->writeEndElement();	×
396
397	/* End the <Algorithm> tag */
UNCOV 398	doc->writeEndElement();	×
399
UNCOV 400	return true;	×
401	}

mcallegari / qlcplus / 12611954629

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous