Debian Codegraph @

plugins/paintops/defaultpaintops/brush/tests/KisDabRenderingQueueTest.cpp

raw
1 /*
2 * SPDX-FileCopyrightText: 2017 Dmitry Kazakov <[email protected]>
3 *
4 * SPDX-License-Identifier: GPL-2.0-or-later
5 */
6
7 #include "KisDabRenderingQueueTest.h"
8
9 #include <simpletest.h>
10 #include <KoColorSpace.h>
11 #include <KoColorSpaceRegistry.h>
12
13 #include <../KisDabRenderingQueue.h>
14 #include <../KisRenderedDab.h>
15 #include <../KisDabRenderingJob.h>
16
17 struct SurrogateCacheInterface : public KisDabRenderingQueue::CacheInterface
18 {
19 void getDabType(bool hasDabInCache,
20 KisDabCacheUtils::DabRenderingResources *resources,
21 const KisDabCacheUtils::DabRequestInfo &request,
22 /* out */
23 KisDabCacheUtils::DabGenerationInfo *di,
24 bool *shouldUseCache) override
25 {
26 Q_UNUSED(resources);
27 Q_UNUSED(request);
28
29 if (!hasDabInCache || typeOverride == KisDabRenderingJob::Dab) {
30 di->needsPostprocessing = false;
31 *shouldUseCache = false;
32 } else if (typeOverride == KisDabRenderingJob::Copy) {
33 di->needsPostprocessing = false;
34 *shouldUseCache = true;
35 } else if (typeOverride == KisDabRenderingJob::Postprocess) {
36 di->needsPostprocessing = true;
37 *shouldUseCache = true;
38 }
39
40 di->info = request.info;
41 }
42
43 bool hasSeparateOriginal(KisDabCacheUtils::DabRenderingResources *resources) const override {
44 Q_UNUSED(resources);
45 return typeOverride == KisDabRenderingJob::Postprocess;
46 }
47
48 KisDabRenderingJob::JobType typeOverride = KisDabRenderingJob::Dab;
49 };
50
51 #include <kis_mask_generator.h>
52 #include "kis_auto_brush.h"
53
54 KisDabCacheUtils::DabRenderingResources *testResourcesFactory()
55 {
56 KisDabCacheUtils::DabRenderingResources *resources =
57 new KisDabCacheUtils::DabRenderingResources();
58
59 KisCircleMaskGenerator* circle = new KisCircleMaskGenerator(10, 1.0, 1.0, 1.0, 2, false);
60 KisBrushSP brush(new KisAutoBrush(circle, 0.0, 0.0));
61 resources->brush = brush;
62
63 return resources;
64 }
65
66 void KisDabRenderingQueueTest::testCachedDabs()
67 {
68 const KoColorSpace *cs = KoColorSpaceRegistry::instance()->rgb8();
69
70 SurrogateCacheInterface *cacheInterface = new SurrogateCacheInterface();
71
72 KisDabRenderingQueue queue(cs, testResourcesFactory);
73 queue.setCacheInterface(cacheInterface);
74
75 KoColor color;
76 QPointF pos1(10,10);
77 QPointF pos2(20,20);
78 KisDabShape shape;
79 KisPaintInformation pi1(pos1);
80 KisPaintInformation pi2(pos2);
81
82 KisDabCacheUtils::DabRequestInfo request1(color, pos1, shape, pi1, 1.0);
83 KisDabCacheUtils::DabRequestInfo request2(color, pos2, shape, pi2, 1.0);
84
85 cacheInterface->typeOverride = KisDabRenderingJob::Dab;
86 KisDabRenderingJobSP job0 = queue.addDab(request1, OPACITY_OPAQUE_F, OPACITY_OPAQUE_F);
87
88 QVERIFY(job0);
89 QCOMPARE(job0->seqNo, 0);
90 QCOMPARE(job0->generationInfo.info.pos(), request1.info.pos());
91 QCOMPARE(job0->type, KisDabRenderingJob::Dab);
92 QVERIFY(!job0->originalDevice);
93 QVERIFY(!job0->postprocessedDevice);
94
95 cacheInterface->typeOverride = KisDabRenderingJob::Dab;
96 KisDabRenderingJobSP job1 = queue.addDab(request2, OPACITY_OPAQUE_F, OPACITY_OPAQUE_F);
97
98 QVERIFY(job1);
99 QCOMPARE(job1->seqNo, 1);
100 QCOMPARE(job1->generationInfo.info.pos(), request2.info.pos());
101 QCOMPARE(job1->type, KisDabRenderingJob::Dab);
102 QVERIFY(!job1->originalDevice);
103 QVERIFY(!job1->postprocessedDevice);
104
105 cacheInterface->typeOverride = KisDabRenderingJob::Copy;
106 KisDabRenderingJobSP job2 = queue.addDab(request2, OPACITY_OPAQUE_F, OPACITY_OPAQUE_F);
107 QVERIFY(!job2);
108
109 cacheInterface->typeOverride = KisDabRenderingJob::Copy;
110 KisDabRenderingJobSP job3 = queue.addDab(request2, OPACITY_OPAQUE_F, OPACITY_OPAQUE_F);
111 QVERIFY(!job3);
112
113 // we only added the dabs, but we haven't completed them yet
114 QVERIFY(!queue.hasPreparedDabs());
115 QCOMPARE(queue.testingGetQueueSize(), 4);
116
117 QList<KisDabRenderingJobSP > jobs;
118 QList<KisRenderedDab> renderedDabs;
119
120
121 {
122 // we've completed job0
123 job0->originalDevice = new KisFixedPaintDevice(cs);
124 job0->postprocessedDevice = job0->originalDevice;
125
126 jobs = queue.notifyJobFinished(job0->seqNo);
127 QVERIFY(jobs.isEmpty());
128
129 // now we should have at least one job in prepared state
130 QVERIFY(queue.hasPreparedDabs());
131
132 // take the prepared dabs
133 renderedDabs = queue.takeReadyDabs();
134 QCOMPARE(renderedDabs.size(), 1);
135
136 // the list should be empty again
137 QVERIFY(!queue.hasPreparedDabs());
138 QCOMPARE(queue.testingGetQueueSize(), 3);
139 }
140
141 {
142 // we've completed job1
143 job1->originalDevice = new KisFixedPaintDevice(cs);
144 job1->postprocessedDevice = job1->originalDevice;
145
146 jobs = queue.notifyJobFinished(job1->seqNo);
147 QVERIFY(jobs.isEmpty());
148
149 // now we should have at least one job in prepared state
150 QVERIFY(queue.hasPreparedDabs());
151
152 // take the prepared dabs
153 renderedDabs = queue.takeReadyDabs();
154 QCOMPARE(renderedDabs.size(), 3);
155
156 // since they are copies, they should be the same
157 QCOMPARE(renderedDabs[1].device, renderedDabs[0].device);
158 QCOMPARE(renderedDabs[2].device, renderedDabs[0].device);
159
160 // the list should be empty again
161 QVERIFY(!queue.hasPreparedDabs());
162
163 // we delete all the painted jobs except the latest 'dab' job
164 QCOMPARE(queue.testingGetQueueSize(), 1);
165 }
166
167 {
168 // add one more cached job and take it
169 cacheInterface->typeOverride = KisDabRenderingJob::Copy;
170 KisDabRenderingJobSP job = queue.addDab(request2, OPACITY_OPAQUE_F, OPACITY_OPAQUE_F);
171 QVERIFY(!job);
172
173 // now we should have at least one job in prepared state
174 QVERIFY(queue.hasPreparedDabs());
175
176 // take the prepared dabs
177 renderedDabs = queue.takeReadyDabs();
178 QCOMPARE(renderedDabs.size(), 1);
179
180 // the list should be empty again
181 QVERIFY(!queue.hasPreparedDabs());
182
183 // we delete all the painted jobs except the latest 'dab' job
184 QCOMPARE(queue.testingGetQueueSize(), 1);
185 }
186
187 {
188 // add a 'dab' job and complete it
189
190 cacheInterface->typeOverride = KisDabRenderingJob::Dab;
191 KisDabRenderingJobSP job = queue.addDab(request1, OPACITY_OPAQUE_F, OPACITY_OPAQUE_F);
192
193 QVERIFY(job);
194 QCOMPARE(job->seqNo, 5);
195 QCOMPARE(job->generationInfo.info.pos(), request1.info.pos());
196 QCOMPARE(job->type, KisDabRenderingJob::Dab);
197 QVERIFY(!job->originalDevice);
198 QVERIFY(!job->postprocessedDevice);
199
200 // now the queue can be cleared from the completed dabs!
201 QCOMPARE(queue.testingGetQueueSize(), 1);
202
203 job->originalDevice = new KisFixedPaintDevice(cs);
204 job->postprocessedDevice = job->originalDevice;
205
206 jobs = queue.notifyJobFinished(job->seqNo);
207 QVERIFY(jobs.isEmpty());
208
209 // now we should have at least one job in prepared state
210 QVERIFY(queue.hasPreparedDabs());
211
212 // take the prepared dabs
213 renderedDabs = queue.takeReadyDabs();
214 QCOMPARE(renderedDabs.size(), 1);
215
216 // the list should be empty again
217 QVERIFY(!queue.hasPreparedDabs());
218
219 // we do not delete the queue of jobs until the next 'dab'
220 // job arrives
221 QCOMPARE(queue.testingGetQueueSize(), 1);
222 }
223
224 }
225
226 void KisDabRenderingQueueTest::testPostprocessedDabs()
227 {
228 const KoColorSpace *cs = KoColorSpaceRegistry::instance()->rgb8();
229
230 SurrogateCacheInterface *cacheInterface = new SurrogateCacheInterface();
231
232 KisDabRenderingQueue queue(cs, testResourcesFactory);
233 queue.setCacheInterface(cacheInterface);
234
235 KoColor color;
236 QPointF pos1(10,10);
237 QPointF pos2(20,20);
238 KisDabShape shape;
239 KisPaintInformation pi1(pos1);
240 KisPaintInformation pi2(pos2);
241
242 KisDabCacheUtils::DabRequestInfo request1(color, pos1, shape, pi1, 1.0);
243 KisDabCacheUtils::DabRequestInfo request2(color, pos2, shape, pi2, 1.0);
244
245 cacheInterface->typeOverride = KisDabRenderingJob::Dab;
246 KisDabRenderingJobSP job0 = queue.addDab(request1, OPACITY_OPAQUE_F, OPACITY_OPAQUE_F);
247
248 QVERIFY(job0);
249 QCOMPARE(job0->seqNo, 0);
250 QCOMPARE(job0->generationInfo.info.pos(), request1.info.pos());
251 QCOMPARE(job0->type, KisDabRenderingJob::Dab);
252 QVERIFY(!job0->originalDevice);
253 QVERIFY(!job0->postprocessedDevice);
254
255 cacheInterface->typeOverride = KisDabRenderingJob::Dab;
256 KisDabRenderingJobSP job1 = queue.addDab(request2, OPACITY_OPAQUE_F, OPACITY_OPAQUE_F);
257
258 QVERIFY(job1);
259 QCOMPARE(job1->seqNo, 1);
260 QCOMPARE(job1->generationInfo.info.pos(), request2.info.pos());
261 QCOMPARE(job1->type, KisDabRenderingJob::Dab);
262 QVERIFY(!job1->originalDevice);
263 QVERIFY(!job1->postprocessedDevice);
264
265 cacheInterface->typeOverride = KisDabRenderingJob::Postprocess;
266 KisDabRenderingJobSP job2 = queue.addDab(request2, OPACITY_OPAQUE_F, OPACITY_OPAQUE_F);
267 QVERIFY(!job2);
268
269 cacheInterface->typeOverride = KisDabRenderingJob::Postprocess;
270 KisDabRenderingJobSP job3 = queue.addDab(request2, OPACITY_OPAQUE_F, OPACITY_OPAQUE_F);
271 QVERIFY(!job3);
272
273 // we only added the dabs, but we haven't completed them yet
274 QVERIFY(!queue.hasPreparedDabs());
275 QCOMPARE(queue.testingGetQueueSize(), 4);
276
277 QList<KisDabRenderingJobSP > jobs;
278 QList<KisRenderedDab> renderedDabs;
279
280
281 {
282 // we've completed job0
283 job0->originalDevice = new KisFixedPaintDevice(cs);
284 job0->postprocessedDevice = job0->originalDevice;
285
286 jobs = queue.notifyJobFinished(job0->seqNo);
287 QVERIFY(jobs.isEmpty());
288
289 // now we should have at least one job in prepared state
290 QVERIFY(queue.hasPreparedDabs());
291
292 // take the prepared dabs
293 renderedDabs = queue.takeReadyDabs();
294 QCOMPARE(renderedDabs.size(), 1);
295
296 // the list should be empty again
297 QVERIFY(!queue.hasPreparedDabs());
298 QCOMPARE(queue.testingGetQueueSize(), 3);
299 }
300
301 {
302 // we've completed job1
303 job1->originalDevice = new KisFixedPaintDevice(cs);
304 job1->postprocessedDevice = job1->originalDevice;
305
306 jobs = queue.notifyJobFinished(job1->seqNo);
307 QCOMPARE(jobs.size(), 2);
308
309 QCOMPARE(jobs[0]->seqNo, 2);
310 QCOMPARE(jobs[1]->seqNo, 3);
311
312 QVERIFY(jobs[0]->originalDevice);
313 QVERIFY(!jobs[0]->postprocessedDevice);
314
315 QVERIFY(jobs[1]->originalDevice);
316 QVERIFY(!jobs[1]->postprocessedDevice);
317
318 // pretend we have created a postprocessed device
319 jobs[0]->postprocessedDevice = new KisFixedPaintDevice(cs);
320 jobs[1]->postprocessedDevice = new KisFixedPaintDevice(cs);
321
322 // now we should have at least one job in prepared state
323 QVERIFY(queue.hasPreparedDabs());
324
325 // take the prepared dabs
326 renderedDabs = queue.takeReadyDabs();
327 QCOMPARE(renderedDabs.size(), 1);
328
329 // the list should be empty again
330 QVERIFY(!queue.hasPreparedDabs());
331
332
333 // return back two postprocessed dabs
334 QList<KisDabRenderingJobSP > emptyJobs;
335 emptyJobs = queue.notifyJobFinished(jobs[0]->seqNo);
336 QVERIFY(emptyJobs.isEmpty());
337
338 emptyJobs = queue.notifyJobFinished(jobs[1]->seqNo);
339 QVERIFY(emptyJobs.isEmpty());
340
341
342 // now we should have at least one job in prepared state
343 QVERIFY(queue.hasPreparedDabs());
344
345 // take the prepared dabs
346 renderedDabs = queue.takeReadyDabs();
347 QCOMPARE(renderedDabs.size(), 2);
348
349 // the list should be empty again
350 QVERIFY(!queue.hasPreparedDabs());
351
352 // we delete all the painted jobs except the latest 'dab' job
353 QCOMPARE(queue.testingGetQueueSize(), 1);
354 }
355
356 {
357 // add one more postprocessed job and take it
358 cacheInterface->typeOverride = KisDabRenderingJob::Postprocess;
359 KisDabRenderingJobSP job = queue.addDab(request2, OPACITY_OPAQUE_F, OPACITY_OPAQUE_F);
360
361 QVERIFY(job);
362 QCOMPARE(job->seqNo, 4);
363 QCOMPARE(job->generationInfo.info.pos(), request2.info.pos());
364 ENTER_FUNCTION() << ppVar(job->type);
365
366 QCOMPARE(job->type, KisDabRenderingJob::Postprocess);
367 QVERIFY(job->originalDevice);
368 QVERIFY(!job->postprocessedDevice);
369
370 // the list should still be empty
371 QVERIFY(!queue.hasPreparedDabs());
372
373 // pretend we have created a postprocessed device
374 job->postprocessedDevice = new KisFixedPaintDevice(cs);
375
376 // return back the postprocessed dab
377 QList<KisDabRenderingJobSP > emptyJobs;
378 emptyJobs = queue.notifyJobFinished(job->seqNo);
379 QVERIFY(emptyJobs.isEmpty());
380
381 // now we should have at least one job in prepared state
382 QVERIFY(queue.hasPreparedDabs());
383
384 // take the prepared dabs
385 renderedDabs = queue.takeReadyDabs();
386 QCOMPARE(renderedDabs.size(), 1);
387
388 // the list should be empty again
389 QVERIFY(!queue.hasPreparedDabs());
390
391 // we delete all the painted jobs except the latest 'dab' job
392 QCOMPARE(queue.testingGetQueueSize(), 1);
393 }
394
395 {
396 // add a 'dab' job and complete it. That will clear the queue!
397
398 cacheInterface->typeOverride = KisDabRenderingJob::Dab;
399 KisDabRenderingJobSP job = queue.addDab(request1, OPACITY_OPAQUE_F, OPACITY_OPAQUE_F);
400
401 QVERIFY(job);
402 QCOMPARE(job->seqNo, 5);
403 QCOMPARE(job->generationInfo.info.pos(), request1.info.pos());
404 QCOMPARE(job->type, KisDabRenderingJob::Dab);
405 QVERIFY(!job->originalDevice);
406 QVERIFY(!job->postprocessedDevice);
407
408 // now the queue can be cleared from the completed dabs!
409 QCOMPARE(queue.testingGetQueueSize(), 1);
410
411 job->originalDevice = new KisFixedPaintDevice(cs);
412 job->postprocessedDevice = job->originalDevice;
413
414 jobs = queue.notifyJobFinished(job->seqNo);
415 QVERIFY(jobs.isEmpty());
416
417 // now we should have at least one job in prepared state
418 QVERIFY(queue.hasPreparedDabs());
419
420 // take the prepared dabs
421 renderedDabs = queue.takeReadyDabs();
422 QCOMPARE(renderedDabs.size(), 1);
423
424 // the list should be empty again
425 QVERIFY(!queue.hasPreparedDabs());
426
427 // we do not delete the queue of jobs until the next 'dab'
428 // job arrives
429 QCOMPARE(queue.testingGetQueueSize(), 1);
430 }
431
432 }
433
434 #include <../KisDabRenderingQueueCache.h>
435
436 void KisDabRenderingQueueTest::testRunningJobs()
437 {
438 const KoColorSpace *cs = KoColorSpaceRegistry::instance()->rgb8();
439
440 KisDabRenderingQueueCache *cacheInterface = new KisDabRenderingQueueCache();
441 // we do *not* initialize any options yet!
442
443 KisDabRenderingQueue queue(cs, testResourcesFactory);
444 queue.setCacheInterface(cacheInterface);
445
446
447 KoColor color(Qt::red, cs);
448 QPointF pos1(10,10);
449 QPointF pos2(20,20);
450 KisDabShape shape;
451 KisPaintInformation pi1(pos1);
452 KisPaintInformation pi2(pos2);
453
454 KisDabCacheUtils::DabRequestInfo request1(color, pos1, shape, pi1, 1.0);
455 KisDabCacheUtils::DabRequestInfo request2(color, pos2, shape, pi2, 1.0);
456
457 KisDabRenderingJobSP job0 = queue.addDab(request1, OPACITY_OPAQUE_F, OPACITY_OPAQUE_F);
458
459 QVERIFY(job0);
460 QCOMPARE(job0->seqNo, 0);
461 QCOMPARE(job0->generationInfo.info.pos(), request1.info.pos());
462 QCOMPARE(job0->type, KisDabRenderingJob::Dab);
463
464 QVERIFY(!job0->originalDevice);
465 QVERIFY(!job0->postprocessedDevice);
466
467 KisDabRenderingJobRunner runner(job0, &queue, 0);
468 runner.run();
469
470 QVERIFY(job0->originalDevice);
471 QVERIFY(job0->postprocessedDevice);
472 QCOMPARE(job0->originalDevice, job0->postprocessedDevice);
473
474 QVERIFY(!job0->originalDevice->bounds().isEmpty());
475
476 KisDabRenderingJobSP job1 = queue.addDab(request2, OPACITY_OPAQUE_F, OPACITY_OPAQUE_F);
477 QVERIFY(!job1);
478
479 QList<KisRenderedDab> renderedDabs = queue.takeReadyDabs();
480 QCOMPARE(renderedDabs.size(), 2);
481
482 // we did the caching
483 QVERIFY(renderedDabs[0].device == renderedDabs[1].device);
484
485 QCOMPARE(renderedDabs[0].offset, QPoint(5,5));
486 QCOMPARE(renderedDabs[1].offset, QPoint(15,15));
487 }
488
489 #include "../KisDabRenderingExecutor.h"
490 #include "KisFakeRunnableStrokeJobsExecutor.h"
491
492 void KisDabRenderingQueueTest::testExecutor()
493 {
494 const KoColorSpace *cs = KoColorSpaceRegistry::instance()->rgb8();
495
496 QScopedPointer<KisRunnableStrokeJobsInterface> runner(new KisFakeRunnableStrokeJobsExecutor());
497
498 KisDabRenderingExecutor executor(cs, testResourcesFactory, runner.data());
499
500 KoColor color(Qt::red, cs);
501 QPointF pos1(10,10);
502 QPointF pos2(20,20);
503 KisDabShape shape;
504 KisPaintInformation pi1(pos1);
505 KisPaintInformation pi2(pos2);
506
507 KisDabCacheUtils::DabRequestInfo request1(color, pos1, shape, pi1, 1.0);
508 KisDabCacheUtils::DabRequestInfo request2(color, pos2, shape, pi2, 1.0);
509
510 executor.addDab(request1, 0.5, 0.25);
511 executor.addDab(request2, 0.125, 1.0);
512
513 QList<KisRenderedDab> renderedDabs = executor.takeReadyDabs();
514 QCOMPARE(renderedDabs.size(), 2);
515
516 // we did the caching
517 QVERIFY(renderedDabs[0].device == renderedDabs[1].device);
518
519 QCOMPARE(renderedDabs[0].offset, QPoint(5,5));
520 QCOMPARE(renderedDabs[1].offset, QPoint(15,15));
521
522 QCOMPARE(renderedDabs[0].opacity, 0.5);
523 QCOMPARE(renderedDabs[0].flow, 0.25);
524 QCOMPARE(renderedDabs[1].opacity, 0.125);
525 QCOMPARE(renderedDabs[1].flow, 1.0);
526
527 }
528
529 SIMPLE_TEST_MAIN(KisDabRenderingQueueTest)