Differential D11198 Diff 29843 libbreezecommon/breezeboxshadowhelper.cpp

Changeset View

Standalone View

libbreezecommon/breezeboxshadowhelper.cpp

This file was added.

1		/*
2		* Copyright (C) 2018 Vlad Zagorodniy <vladzzag@gmail.com>
3		*
4		* This program is free software; you can redistribute it and/or
5		* modify it under the terms of the GNU General Public License as
6		* published by the Free Software Foundation; either version 2 of
7		* the License or (at your option) version 3 or any later version
8		* accepted by the membership of KDE e.V. (or its successor approved
9		* by the membership of KDE e.V.), which shall act as a proxy
10		* defined in Section 14 of version 3 of the license.
11		*
12		* This program is distributed in the hope that it will be useful,
13		* but WITHOUT ANY WARRANTY; without even the implied warranty of
14		* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15		* GNU General Public License for more details.
16		*
17		* You should have received a copy of the GNU General Public License
18		* along with this program. If not, see <http://www.gnu.org/licenses/>.
19		*/
20
21		#include "breezeboxshadowhelper.h"
22		#include "config-breezecommon.h"
23
24		#include <QColor>
25		#include <QPainter>
26		#include <QPoint>
27		#include <QRect>
28		#include <QVector>
29
30		#include <fftw3.h>
31
32		#include <cmath>
33
34
35		namespace Breeze {
36		namespace BoxShadowHelper {
37
38		QVector<double> computeGaussianKernel(double radius, double sigma)
39		{
40		QVector<double> kernel;
41		const int kernelSize = static_cast<int>(radius) * 2 + 1;
42
	hpereiradacostaUnsubmitted Not Done erf -> std::erf (since c++11). same elsewhere. I think it is clearer to add the namespace explicitly, now that it is properly defined. hpereiradacosta: erf -> std::erf (since c++11). same elsewhere. I think it is clearer to add the namespace…
43		const double den = sqrt(2.0) * sigma;
44		double kernelNorm = 0.0;
45		double lastInt = 0.5 * erf((-radius - 0.5) / den);
46
47		for (int i = 0; i < kernelSize; i++) {
48		const double currInt = 0.5 * erf((i - radius + 0.5) / den);
49		const double w = currInt - lastInt;
50		kernel << w;
51		kernelNorm += w;
52		lastInt = currInt;
53		}
54
55		for (auto &w : kernel) {
56		w /= kernelNorm;
57		}
58
59		return kernel;
60		}
61
62		// Blur alpha channel of the given image using separable convolution
63		// gaussian kernel. Not very efficient with big blur radii.
64		void blurAlphaSeparable(QImage &img, double radius, double sigma)
65		{
66		const auto kernel = computeGaussianKernel(radius, sigma);
67
68		QImage tmp(img.height(), img.width(), img.format());
69
70		QRgb imgData = reinterpret_cast<QRgb >(img.scanLine(0));
71		QRgb tmpData = reinterpret_cast<QRgb >(tmp.scanLine(0));
72		const int imgStride = img.width();
73		const int tmpStride = tmp.width();
74
75		const int shift = static_cast<int>(radius);
76
77		// Blur in X direction. Please note, the result is stored in a temporary
78		// transposed buffer. The result is transposed to read memory in linear order.
79		for (int y = 0; y < img.height(); y++) {
80		for (int x = 0; x < img.width(); x++) {
81		double alpha = 0.0;
82
83		for (int i = 0; i < kernel.size(); i++) {
84		const int idx = y * imgStride + qBound(0, x + i - shift, img.width() - 1);
85		alpha += qAlpha(imgData[idx]) * kernel[i];
86		}
87
88		const int idx = x * tmpStride + y;
89		tmpData[idx] = qRgba(0, 0, 0, static_cast<int>(alpha));
90		}
91		}
92
93		// Blur in Y direction. The result is transposed again so size
94		// matches original image size.
95		for (int y = 0; y < tmp.height(); y++) {
96		for (int x = 0; x < tmp.width(); x++) {
97		double alpha = 0.0;
98
99		for (int i = 0; i < kernel.size(); i++) {
100		const int idx = y * tmpStride + qBound(0, x + i - shift, tmp.width() - 1);
101		alpha += qAlpha(tmpData[idx]) * kernel[i];
102		}
103
104		const int idx = x * imgStride + y;
105		imgData[idx] = qRgba(0, 0, 0, static_cast<int>(alpha));
106		}
107		}
108		}
109
110		// Blur alpha channel of the given image using Fourier Transform.
111		// It's somewhat efficient with big blur radii.
112		//
113		// It works as follows:
114		// - do FFT on given input image(it is expected, that the
115		// input image was padded before)
116		// - compute Gaussian kernel, pad it to the size of the input
117		// image, and do FFT on it
118		// - multiply the two in the frequency domain(element-wise)
119		// - transform the result back to "time domain"
120		//
121		void blurAlphaFFT(QImage &img, double radius, double sigma)
122		{
123		QRgb data = reinterpret_cast<QRgb >(img.scanLine(0));
124		const int size = img.width() * img.height();
125
126		// Use FFTW's malloc function so the returned pointer obeys any
127		// special alignment restrictions. (e.g. for SIMD acceleration, etc)
128		// See http://www.fftw.org/fftw3_doc/Memory-Allocation.html
129		fftw_complex *imageIn = fftw_alloc_complex(size);
130		fftw_complex *imageOut = fftw_alloc_complex(size);
131
132		for (int i = 0; i < size; i++) {
133		imageIn[i][0] = qAlpha(data[i]);
134		imageIn[i][1] = 0.0;
135		}
136
137		fftw_plan imageFFT = fftw_plan_dft_2d(
138		img.height(), img.width(),
139		imageIn, imageOut,
140		FFTW_FORWARD, FFTW_ESTIMATE);
141
142		fftw_plan imageIFFT = fftw_plan_dft_2d(
143		img.height(), img.width(),
144		imageOut, imageIn,
145		FFTW_BACKWARD, FFTW_ESTIMATE);
146
147		// The computed Gaussian kernel has to have the same size as the input image.
148		// Please note that the center of the computed Gaussian kernel is placed
149		// at the top-left corner and the whole kernel is wrapped around so we read
150		// result in linear order.
151		// Note: the kernel is computed by taking a product of two 1-D Gaussian kernels.
152		QVector<double> kernel(size, 0);
153		const QVector<double> kernel_ = computeGaussianKernel(radius, sigma);
154		const int kernelSize = kernel_.size();
155		const int shift = -static_cast<int>(radius);
156		for (int y = 0; y < kernelSize; y++) {
157		for (int x = 0; x < kernelSize; x++) {
158		const int j = (img.width() + x + shift) % img.width();
159		const int i = (img.height() + y + shift) % img.height();
160		kernel[j + i * img.width()] = kernel_[x] * kernel_[y];
161		}
162		}
163
164		fftw_complex *kernelIn = fftw_alloc_complex(kernel.size());
165		fftw_complex *kernelOut = fftw_alloc_complex(kernel.size());
166
167		for (int i = 0; i < size; i++) {
168		kernelIn[i][0] = kernel[i];
169		kernelIn[i][1] = 0.0;
170		}
171
172		fftw_plan kernelFFT = fftw_plan_dft_2d(
173		img.height(), img.width(),
174		kernelIn, kernelOut,
175		FFTW_FORWARD, FFTW_ESTIMATE);
176
177		// Do actual FFT.
178		fftw_execute(imageFFT);
179		fftw_execute(kernelFFT);
180
181		for (int i = 0; i < size; i++) {
182		const double re = imageOut[i][0] * kernelOut[i][0] - imageOut[i][1] * kernelOut[i][1];
183		const double im = imageOut[i][0] * kernelOut[i][1] + imageOut[i][1] * kernelOut[i][0];
184		imageOut[i][0] = re;
185		imageOut[i][1] = im;
186		}
187
188		fftw_execute(imageIFFT);
189
190		// Copy result back. Please note, result is scaled by `width x height` so we need to scale it down.
191		for (int i = 0; i < size; i++) {
192		data[i] = qRgba(0, 0, 0, imageIn[i][0] / size);
193		}
194
195		fftw_destroy_plan(kernelFFT);
196		fftw_destroy_plan(imageFFT);
197		fftw_destroy_plan(imageIFFT);
198
199		fftw_free(kernelIn);
200		fftw_free(kernelOut);
201
202		fftw_free(imageIn);
203		fftw_free(imageOut);
204		}
205
206		namespace {
207		// FFT approach outperforms separable convolution kernels when blur radius >= 64.
208		// (was discovered after doing a lot of benchmarks)
209		const int FFT_BLUR_RADIUS_THRESHOLD = 64;
210
211		// According to the CSS Level 3 spec, standard deviation must be equal to
212		// half of the blur radius. https://www.w3.org/TR/css-backgrounds-3/#shadow-blur
213		// Current window size is too small for sigma equal to half of the blur radius.
214		// As a workaround, sigma blur scale is lowered. With the lowered sigma
215		// blur scale, area under the kernel equals to 0.98, which is pretty enough.
216		// Maybe, it should be changed in the future.
217		const double SIGMA_BLUR_SCALE = 0.4375;
218		}
219
220		inline double radiusToSigma(double radius)
221		{
222		return SIGMA_BLUR_SCALE * radius;
223		}
224
225		void boxShadow(QPainter *p, const QRect &box, const QPoint &offset, int radius, const QColor &color)
226		{
227		const QSize size = box.size() + 2 * QSize(radius, radius);
228
229		#if BREEZE_COMMON_USE_KDE4
230		const qreal dpr = 1.0;
231		#else
232		const qreal dpr = p->device()->devicePixelRatioF();
233		#endif
234
235		QPainter painter;
236
237		QImage shadow(size * dpr, QImage::Format_ARGB32_Premultiplied);
238		#if !BREEZE_COMMON_USE_KDE4
239		shadow.setDevicePixelRatio(dpr);
240		#endif
241		shadow.fill(Qt::transparent);
242
243		painter.begin(&shadow);
244		painter.fillRect(QRect(QPoint(radius, radius), box.size()), Qt::black);
245		painter.end();
246
247		// There is no need to blur RGB channels. Blur the alpha
248		// channel and do compositing stuff later.
249		const double radius_ = radius * dpr;
250		const double sigma = radiusToSigma(radius_);
251		if (radius_ < FFT_BLUR_RADIUS_THRESHOLD) {
252		blurAlphaSeparable(shadow, radius_, sigma);
253		} else {
254		blurAlphaFFT(shadow, radius_, sigma);
255		}
256
257		painter.begin(&shadow);
258		painter.setCompositionMode(QPainter::CompositionMode_SourceIn);
259		painter.fillRect(shadow.rect(), color);
260		painter.end();
261
262		QRect shadowRect = shadow.rect();
263		shadowRect.setSize(shadowRect.size() / dpr);
264		shadowRect.moveCenter(box.center() + offset);
265		p->drawImage(shadowRect, shadow);
266		}
267
268		} // BoxShadowHelper
269		} // Breeze