Differential D1979 Diff 5533 libs/image/kis_paint_device.cc

Changeset View

Standalone View

View Options

libs/image/kis_paint_device.cc

Context not available.
37#include <KoColorModelStandardIds.h> 37​#include <KoColorModelStandardIds.h>
38#include <KoIntegerMaths.h> 38​#include <KoIntegerMaths.h>
39#include <KoMixColorsOp.h> 39​#include <KoMixColorsOp.h>
40 40​#include <KoUpdater.h>
41 41​
42#include "kis_image.h" 42​#include "kis_image.h"
43#include "kis_random_sub_accessor.h" 43​#include "kis_random_sub_accessor.h"
Context not available.
64#include "kis_paint_device_data.h" 64​#include "kis_paint_device_data.h"
65#include "kis_paint_device_frames_interface.h" 65​#include "kis_paint_device_frames_interface.h"
66 66​
67​#include "kis_transform_worker.h"
68​#include "kis_filter_strategy.h"
69​
67 70​
68struct KisPaintDeviceSPStaticRegistrar { 71​struct KisPaintDeviceSPStaticRegistrar {
69 KisPaintDeviceSPStaticRegistrar() { 72​ KisPaintDeviceSPStaticRegistrar() {
Context not available.
105 KUndo2Command* convertColorSpace(const KoColorSpace * dstColorSpace, KoColorConversionTransformation::Intent renderingIntent, KoColorConversionTransformation::ConversionFlags conversionFlags); 108​ KUndo2Command* convertColorSpace(const KoColorSpace * dstColorSpace, KoColorConversionTransformation::Intent renderingIntent, KoColorConversionTransformation::ConversionFlags conversionFlags);
106 bool assignProfile(const KoColorProfile * profile); 109​ bool assignProfile(const KoColorProfile * profile);
107 110​
108 inline const KoColorSpace* colorSpace() const { return currentData()->colorSpace(); } 111​ inline const KoColorSpace* colorSpace() const
109 inline KisDataManagerSP dataManager() const { return currentData()->dataManager(); } 112​ {
113​ return currentData()->colorSpace();
114​ }
115​ inline KisDataManagerSP dataManager() const
116​ {
117​ return currentData()->dataManager();
118​ }
110 119​
111 inline qint32 x() const {return currentData()->x();} 120​ inline qint32 x() const
112 inline qint32 y() const {return currentData()->y();} 121​ {
113 inline void setX(qint32 x) { currentData()->setX(x); } 122​ return currentData()->x();
114 inline void setY(qint32 y) { currentData()->setY(y); } 123​ }
124​ inline qint32 y() const
125​ {
126​ return currentData()->y();
127​ }
128​ inline void setX(qint32 x)
129​ {
130​ currentData()->setX(x);
131​ }
132​ inline void setY(qint32 y)
133​ {
134​ currentData()->setY(y);
135​ }
115 136​
116 inline KisPaintDeviceCache* cache() { return currentData()->cache(); } 137​ inline KisPaintDeviceCache* cache()
138​ {
139​ return currentData()->cache();
140​ }
117 141​
118 142​
119 void cloneAllDataObjects(Private *rhs, bool copyFrames) { 143​ void cloneAllDataObjects(Private *rhs, bool copyFrames)
144​ {
120 145​
121 m_lodData.reset(); 146​ m_lodData.reset();
122 m_externalFrameData.reset(); 147​ m_externalFrameData.reset();
Context not available.
167 return fastBitBltPossibleImpl(src->m_d->currentData()); 192​ return fastBitBltPossibleImpl(src->m_d->currentData());
168 } 193​ }
169 194​
170 int currentFrameId() const { 195​ int currentFrameId() const
171 KIS_ASSERT_RECOVER(contentChannel) { return -1; } 196​ {
197​ KIS_ASSERT_RECOVER(contentChannel) {
198​ return -1;
199​ }
172 return !defaultBounds->currentLevelOfDetail() ? 200​ return !defaultBounds->currentLevelOfDetail() ?
173 contentChannel->frameIdAt(defaultBounds->currentTime()) : 201​ contentChannel->frameIdAt(defaultBounds->currentTime()) :
174 -1; 202​ -1;
175 } 203​ }
176 204​
177 KisDataManagerSP frameDataManager(int frameId) const { 205​ KisDataManagerSP frameDataManager(int frameId) const
206​ {
178 DataSP data = m_frames[frameId]; 207​ DataSP data = m_frames[frameId];
179 return data->dataManager(); 208​ return data->dataManager();
180 } 209​ }
181 210​
182 void invalidateFrameCache(int frameId) { 211​ void invalidateFrameCache(int frameId)
212​ {
183 DataSP data = m_frames[frameId]; 213​ DataSP data = m_frames[frameId];
184 return data->cache()->invalidate(); 214​ return data->cache()->invalidate();
185 } 215​ }
Context not available.
189 typedef QSharedPointer<Data> DataSP; 219​ typedef QSharedPointer<Data> DataSP;
190 typedef QHash<int, DataSP> FramesHash; 220​ typedef QHash<int, DataSP> FramesHash;
191 221​
192 class FrameInsertionCommand : public KUndo2Command { 222​ class FrameInsertionCommand : public KUndo2Command
223​ {
193 public: 224​ public:
194 225​
195 FrameInsertionCommand(FramesHash *hash, DataSP data, int frameId, bool insert, KUndo2Command *parentCommand) 226​ FrameInsertionCommand(FramesHash *hash, DataSP data, int frameId, bool insert, KUndo2Command *parentCommand)
Context not available.
201 { 232​ {
202 } 233​ }
203 234​
204 void redo() { 235​ void redo()
236​ {
205 doSwap(m_insert); 237​ doSwap(m_insert);
206 } 238​ }
207 239​
208 void undo() { 240​ void undo()
241​ {
209 doSwap(!m_insert); 242​ doSwap(!m_insert);
210 } 243​ }
211 244​
212 private: 245​ private:
213 void doSwap(bool insert) { 246​ void doSwap(bool insert)
247​ {
214 if (insert) { 248​ if (insert) {
215 m_hash->insert(m_frameId, m_data); 249​ m_hash->insert(m_frameId, m_data);
216 } else { 250​ } else {
Context not available.
229 263​
230 int createFrame(bool copy, int copySrc, const QPoint &offset, KUndo2Command *parentCommand) 264​ int createFrame(bool copy, int copySrc, const QPoint &offset, KUndo2Command *parentCommand)
231 { 265​ {
232 KIS_ASSERT_RECOVER(parentCommand) { return -1; } 266​ KIS_ASSERT_RECOVER(parentCommand) {
267​ return -1;
268​ }
233 269​
234 DataSP data; 270​ DataSP data;
235 bool initialFrame = false; 271​ bool initialFrame = false;
Context not available.
296 return extent; 332​ return extent;
297 } 333​ }
298 334​
299 QPoint frameOffset(int frameId) const { 335​ QPoint frameOffset(int frameId) const
336​ {
300 DataSP data = m_frames[frameId]; 337​ DataSP data = m_frames[frameId];
301 return QPoint(data->x(), data->y()); 338​ return QPoint(data->x(), data->y());
302 } 339​ }
303 340​
304 void setFrameOffset(int frameId, const QPoint &offset) { 341​ void setFrameOffset(int frameId, const QPoint &offset)
342​ {
305 DataSP data = m_frames[frameId]; 343​ DataSP data = m_frames[frameId];
306 data->setX(offset.x()); 344​ data->setX(offset.x());
307 data->setY(offset.y()); 345​ data->setY(offset.y());
Context not available.
312 return m_frames.keys(); 350​ return m_frames.keys();
313 } 351​ }
314 352​
315 bool readFrame(QIODevice *stream, int frameId) { 353​ bool readFrame(QIODevice *stream, int frameId)
354​ {
316 bool retval = false; 355​ bool retval = false;
317 DataSP data = m_frames[frameId]; 356​ DataSP data = m_frames[frameId];
318 retval = data->dataManager()->read(stream); 357​ retval = data->dataManager()->read(stream);
Context not available.
320 return retval; 359​ return retval;
321 } 360​ }
322 361​
323 bool writeFrame(KisPaintDeviceWriter &store, int frameId) { 362​ bool writeFrame(KisPaintDeviceWriter &store, int frameId)
363​ {
324 DataSP data = m_frames[frameId]; 364​ DataSP data = m_frames[frameId];
325 return data->dataManager()->write(store); 365​ return data->dataManager()->write(store);
326 } 366​ }
327 367​
328 void setFrameDefaultPixel(const quint8 *defPixel, int frameId) { 368​ void setFrameDefaultPixel(const quint8 *defPixel, int frameId)
369​ {
329 DataSP data = m_frames[frameId]; 370​ DataSP data = m_frames[frameId];
330 data->dataManager()->setDefaultPixel(defPixel); 371​ data->dataManager()->setDefaultPixel(defPixel);
331 } 372​ }
332 373​
333 const quint8* frameDefaultPixel(int frameId) const { 374​ const quint8* frameDefaultPixel(int frameId) const
375​ {
334 DataSP data = m_frames[frameId]; 376​ DataSP data = m_frames[frameId];
335 return data->dataManager()->defaultPixel(); 377​ return data->dataManager()->defaultPixel();
336 } 378​ }
Context not available.
352 394​
353 QRegion syncWholeDevice(Data *srcData); 395​ QRegion syncWholeDevice(Data *srcData);
354 396​
355 inline DataSP currentFrameData() const { 397​ inline DataSP currentFrameData() const
398​ {
356 DataSP data; 399​ DataSP data;
357 400​
358 const int numberOfFrames = contentChannel->keyframeCount(); 401​ const int numberOfFrames = contentChannel->keyframeCount();
359 402​
360 if (numberOfFrames > 1) { 403​ if (numberOfFrames > 1) {
361 int frameId = contentChannel->frameIdAt(defaultBounds->currentTime()); 404​ int frameId = contentChannel->frameIdAt(defaultBounds->currentTime());
362 KIS_ASSERT_RECOVER(m_frames.contains(frameId)) { return m_frames.begin().value(); } 405​ KIS_ASSERT_RECOVER(m_frames.contains(frameId)) {
406​ return m_frames.begin().value();
407​ }
363 data = m_frames[frameId]; 408​ data = m_frames[frameId];
364 } else if (numberOfFrames == 1) { 409​ } else if (numberOfFrames == 1) {
365 data = m_frames.begin().value(); 410​ data = m_frames.begin().value();
Context not available.
370 return data; 415​ return data;
371 } 416​ }
372 417​
373 inline Data* currentNonLodData() const { 418​ inline Data* currentNonLodData() const
419​ {
374 Data *data = m_data.data(); 420​ Data *data = m_data.data();
375 421​
376 if (contentChannel) { 422​ if (contentChannel) {
Context not available.
388 return data; 434​ return data;
389 } 435​ }
390 436​
391 inline void ensureLodDataPresent() const { 437​ inline void ensureLodDataPresent() const
438​ {
392 if (!m_lodData) { 439​ if (!m_lodData) {
393 Data *srcData = currentNonLodData(); 440​ Data *srcData = currentNonLodData();
394 441​
Context not available.
399 } 446​ }
400 } 447​ }
401 448​
402 inline Data* currentData() const { 449​ inline Data* currentData() const
450​ {
403 Data *data = m_data.data(); 451​ Data *data = m_data.data();
404 452​
405 if (defaultBounds->currentLevelOfDetail()) { 453​ if (defaultBounds->currentLevelOfDetail()) {
Context not available.
423 bool fastBitBltPossibleImpl(Data *srcData) 471​ bool fastBitBltPossibleImpl(Data *srcData)
424 { 472​ {
425 return x() == srcData->x() && y() == srcData->y() && 473​ return x() == srcData->x() && y() == srcData->y() &&
426 *colorSpace() == *srcData->colorSpace(); 474​ *colorSpace() == *srcData->colorSpace();
427 } 475​ }
428 476​
429 QList<Data*> allDataObjects() const { 477​ QList<Data*> allDataObjects() const
478​ {
430 QList<Data*> dataObjects; 479​ QList<Data*> dataObjects;
431 480​
432 if (m_frames.isEmpty()) { 481​ if (m_frames.isEmpty()) {
Context not available.
503 { 552​ {
504 } 553​ }
505 554​
506 KisHLineConstIteratorSP createConstIterator(const QRect &rect) { 555​ KisHLineConstIteratorSP createConstIterator(const QRect &rect)
556​ {
507 return m_strategy->createHLineConstIteratorNG(m_dataManager, rect.x(), rect.y(), rect.width(), m_offsetX, m_offsetY); 557​ return m_strategy->createHLineConstIteratorNG(m_dataManager, rect.x(), rect.y(), rect.width(), m_offsetX, m_offsetY);
508 } 558​ }
509 559​
510 KisHLineIteratorSP createIterator(const QRect &rect) { 560​ KisHLineIteratorSP createIterator(const QRect &rect)
561​ {
511 return m_strategy->createHLineIteratorNG(m_dataManager, rect.x(), rect.y(), rect.width(), m_offsetX, m_offsetY); 562​ return m_strategy->createHLineIteratorNG(m_dataManager, rect.x(), rect.y(), rect.width(), m_offsetX, m_offsetY);
512 } 563​ }
513 564​
514 int pixelSize() const { 565​ int pixelSize() const
566​ {
515 return m_dataManager->pixelSize(); 567​ return m_dataManager->pixelSize();
516 } 568​ }
517 569​
Context not available.
522 int m_offsetY; 574​ int m_offsetY;
523}; 575​};
524 576​
525struct KisPaintDevice::Private::LodDataStructImpl : public KisPaintDevice::LodDataStruct 577​struct KisPaintDevice::Private::LodDataStructImpl : public KisPaintDevice::LodDataStruct {
526{ ​
527 LodDataStructImpl(Data *_lodData) : lodData(_lodData) {} 578​ LodDataStructImpl(Data *_lodData) : lodData(_lodData) {}
528 QScopedPointer<Data> lodData; 579​ QScopedPointer<Data> lodData;
529}; 580​};
Context not available.
703 uploadFrameData(srcData, dstData); 754​ uploadFrameData(srcData, dstData);
704} 755​}
705 756​
706void KisPaintDevice::Private::uploadFrame(int dstFrameId, KisPaintDeviceSP srcDevice) { 757​void KisPaintDevice::Private::uploadFrame(int dstFrameId, KisPaintDeviceSP srcDevice)
758​{
707 DataSP dstData = m_frames[dstFrameId]; 759​ DataSP dstData = m_frames[dstFrameId];
708 KIS_ASSERT_RECOVER_RETURN(dstData); 760​ KIS_ASSERT_RECOVER_RETURN(dstData);
709 761​
Context not available.
713 uploadFrameData(srcData, dstData); 765​ uploadFrameData(srcData, dstData);
714} 766​}
715 767​
716void KisPaintDevice::Private::uploadFrameData(DataSP srcData, DataSP dstData) { 768​void KisPaintDevice::Private::uploadFrameData(DataSP srcData, DataSP dstData)
769​{
717 if (srcData->colorSpace() != dstData->colorSpace() && 770​ if (srcData->colorSpace() != dstData->colorSpace() &&
718 !(*srcData->colorSpace() == *dstData->colorSpace())) { 771​ !(*srcData->colorSpace() == *dstData->colorSpace())) {
719 772​
Context not available.
741 transferFromData(data, targetDevice); 794​ transferFromData(data, targetDevice);
742} 795​}
743 796​
744KUndo2Command* KisPaintDevice::Private::convertColorSpace(const KoColorSpace * dstColorSpace, KoColorConversionTransformation::Intent renderingIntent, KoColorConversionTransformation::ConversionFlags conversionFlags) { 797​KUndo2Command* KisPaintDevice::Private::convertColorSpace(const KoColorSpace * dstColorSpace, KoColorConversionTransformation::Intent renderingIntent, KoColorConversionTransformation::ConversionFlags conversionFlags)
798​{
745 799​
746 class DeviceChangeColorSpaceCommand : public KUndo2Command { 800​ class DeviceChangeColorSpaceCommand : public KUndo2Command
801​ {
747 public: 802​ public:
748 DeviceChangeColorSpaceCommand(KisPaintDeviceSP device) 803​ DeviceChangeColorSpaceCommand(KisPaintDeviceSP device)
749 : m_firstRun(true), 804​ : m_firstRun(true),
750 m_device(device) 805​ m_device(device)
751 { 806​ {
752 } 807​ }
753 808​
754 void emitNotifications() { 809​ void emitNotifications()
810​ {
755 m_device->emitColorSpaceChanged(); 811​ m_device->emitColorSpaceChanged();
756 m_device->setDirty(); 812​ m_device->setDirty();
757 } 813​ }
758 814​
759 void redo() { 815​ void redo()
816​ {
760 KUndo2Command::redo(); 817​ KUndo2Command::redo();
761 818​
762 if (!m_firstRun) { 819​ if (!m_firstRun) {
Context not available.
767 emitNotifications(); 824​ emitNotifications();
768 } 825​ }
769 826​
770 void undo() { 827​ void undo()
828​ {
771 KUndo2Command::undo(); 829​ KUndo2Command::undo();
772 emitNotifications(); 830​ emitNotifications();
773 } 831​ }
Context not available.
913{ 971​{
914 prepareClone(src); 972​ prepareClone(src);
915 973​
916 // we guarantee that *this is totally empty, so copy pixels that 974​ // we guarantee that *this is totally empty, so copy pixels that
917 // are areally present on the source image only 975​ // are areally present on the source image only
918 const QRect optimizedRect = rect & src->extent(); 976​ const QRect optimizedRect = rect & src->extent();
919 977​
Context not available.
1053 return m_d->cache()->exactBoundsAmortized(); 1111​ return m_d->cache()->exactBoundsAmortized();
1054} 1112​}
1055 1113​
1056namespace Impl { 1114​namespace Impl
1057 ​
1058struct CheckFullyTransparent ​
1059{ 1115​{
1116​
1117​struct CheckFullyTransparent {
1060 CheckFullyTransparent(const KoColorSpace *colorSpace) 1118​ CheckFullyTransparent(const KoColorSpace *colorSpace)
1061 : m_colorSpace(colorSpace) 1119​ : m_colorSpace(colorSpace)
1062 { 1120​ {
1063 } 1121​ }
1064 1122​
1065 bool isPixelEmpty(const quint8 *pixelData) { 1123​ bool isPixelEmpty(const quint8 *pixelData)
1124​ {
1066 return m_colorSpace->opacityU8(pixelData) == OPACITY_TRANSPARENT_U8; 1125​ return m_colorSpace->opacityU8(pixelData) == OPACITY_TRANSPARENT_U8;
1067 } 1126​ }
1068 1127​
Context not available.
1070 const KoColorSpace *m_colorSpace; 1129​ const KoColorSpace *m_colorSpace;
1071}; 1130​};
1072 1131​
1073struct CheckNonDefault 1132​struct CheckNonDefault {
1074{ ​
1075 CheckNonDefault(int pixelSize, const quint8 *defaultPixel) 1133​ CheckNonDefault(int pixelSize, const quint8 *defaultPixel)
1076 : m_pixelSize(pixelSize), 1134​ : m_pixelSize(pixelSize),
1077 m_defaultPixel(defaultPixel) 1135​ m_defaultPixel(defaultPixel)
1078 { 1136​ {
1079 } 1137​ }
1080 1138​
1081 bool isPixelEmpty(const quint8 *pixelData) { 1139​ bool isPixelEmpty(const quint8 *pixelData)
1140​ {
1082 return memcmp(m_defaultPixel, pixelData, m_pixelSize) == 0; 1141​ return memcmp(m_defaultPixel, pixelData, m_pixelSize) == 0;
1083 } 1142​ }
1084 1143​
Context not available.
1177 { 1236​ {
1178 1237​
1179 for (qint32 x2 = x + w - 1; x2 >= endDirW; --x2) { 1238​ for (qint32 x2 = x + w - 1; x2 >= endDirW; --x2) {
1180 for (qint32 y2 = y + h -1; y2 >= y || found; --y2) { 1239​ for (qint32 y2 = y + h - 1; y2 >= y || found; --y2) {
1181 accessor->moveTo(x2, y2); 1240​ accessor->moveTo(x2, y2);
1182 if (!compareOp.isPixelEmpty(accessor->rawDataConst())) { 1241​ if (!compareOp.isPixelEmpty(accessor->rawDataConst())) {
1183 boundRight = x2; 1242​ boundRight = x2;
Context not available.
1202 QRect endRect; 1261​ QRect endRect;
1203 1262​
1204 quint8 defaultOpacity = m_d->colorSpace()->opacityU8(defaultPixel()); 1263​ quint8 defaultOpacity = m_d->colorSpace()->opacityU8(defaultPixel());
1205 if(defaultOpacity != OPACITY_TRANSPARENT_U8) { 1264​ if (defaultOpacity != OPACITY_TRANSPARENT_U8) {
1206 if (!nonDefaultOnly) { 1265​ if (!nonDefaultOnly) {
1207 /** 1266​ /**
1208 * We will calculate exact bounds only outside of the 1267​ * We will calculate exact bounds only outside of the
Context not available.
1336 try { 1395​ try {
1337 quint8 * dstData = new quint8[image.width() * image.height() * pixelSize()]; 1396​ quint8 * dstData = new quint8[image.width() * image.height() * pixelSize()];
1338 KoColorSpaceRegistry::instance() 1397​ KoColorSpaceRegistry::instance()
1339 ->colorSpace(RGBAColorModelID.id(), Integer8BitsColorDepthID.id(), profile) 1398​ ->colorSpace(RGBAColorModelID.id(), Integer8BitsColorDepthID.id(), profile)
1340 ->convertPixelsTo(image.constBits(), dstData, colorSpace(), image.width() * image.height(), 1399​ ->convertPixelsTo(image.constBits(), dstData, colorSpace(), image.width() * image.height(),
1341 KoColorConversionTransformation::internalRenderingIntent(), 1400​ KoColorConversionTransformation::internalRenderingIntent(),
1342 KoColorConversionTransformation::internalConversionFlags()); 1401​ KoColorConversionTransformation::internalConversionFlags());
dkazakovUnsubmitted
Not Done

Hi, @eingerman!

Could you tell why this function is needed? Probably, it should be somehow integrated into KisSequentialConstIterator?

dkazakov: Hi, @eingerman! Could you tell why this function is needed? Probably, it should be somehow…
1343 1402​
1344 writeBytes(dstData, offsetX, offsetY, image.width(), image.height()); 1403​ writeBytes(dstData, offsetX, offsetY, image.width(), image.height());
1345 delete[] dstData; 1404​ delete[] dstData;
Context not available.
1405 return image; 1464​ return image;
1406} 1465​}
1407 1466​
1408KisPaintDeviceSP KisPaintDevice::createThumbnailDevice(qint32 w, qint32 h, QRect rect) const 1467​inline bool moveBy(KisSequentialConstIterator& iter, int numPixels)
1409{ 1468​{
1410 KisPaintDeviceSP thumbnail = new KisPaintDevice(colorSpace()); 1469​ int pos = 0;
1411 1470​ while (pos < numPixels) {
1412 int srcWidth, srcHeight; 1471​ int step = std::min(iter.nConseqPixels(), numPixels - pos);
1413 int srcX0, srcY0; 1472​ if (!iter.nextPixels(step))
1414 QRect e = rect.isValid() ? rect : extent(); 1473​ return false;
1415 e.getRect(&srcX0, &srcY0, &srcWidth, &srcHeight); 1474​ pos += step;
1416 ​
1417 if (w > srcWidth) { ​
1418 w = srcWidth; ​
1419 h = qint32(double(srcWidth) / w * h); ​
1420 } 1475​ }
1421 if (h > srcHeight) { 1476​ return true;
1422 h = srcHeight; 1477​}
1423 w = qint32(double(srcHeight) / h * w); ​
1424 } ​
1425 ​
1426 if (srcWidth > srcHeight) ​
1427 h = qint32(double(srcHeight) / srcWidth * w); ​
1428 else if (srcHeight > srcWidth) ​
1429 w = qint32(double(srcWidth) / srcHeight * h); ​
1430 1478​
1431 const qint32 pixelSize = this->pixelSize(); 1479​static KisPaintDeviceSP createThumbnailDeviceInternal(const KisPaintDevice* srcDev, qint32 srcX0, qint32 srcY0, qint32 srcWidth, qint32 srcHeight, qint32 w, qint32 h, QRect outputRect)
1480​{
1481​ KisPaintDeviceSP thumbnail = new KisPaintDevice(srcDev->colorSpace());
1482​ qint32 pixelSize = srcDev->pixelSize();
1432 1483​
1433 KisRandomConstAccessorSP iter = createRandomConstAccessorNG(0, 0); 1484​ KisRandomConstAccessorSP srcIter = srcDev->createRandomConstAccessorNG(0, 0);
1434 KisRandomAccessorSP dstIter = thumbnail->createRandomAccessorNG(0, 0); 1485​ KisRandomAccessorSP dstIter = thumbnail->createRandomAccessorNG(0, 0);
1435 1486​
1436 for (qint32 y = 0; y < h; ++y) { 1487​ for (qint32 y = outputRect.y(); y < outputRect.y() + outputRect.height(); ++y) {
1437 qint32 iY = srcY0 + (y * srcHeight) / h; 1488​ qint32 iY = srcY0 + (y * srcHeight) / h;
1438 for (qint32 x = 0; x < w; ++x) { 1489​ for (qint32 x = outputRect.x(); x < outputRect.x() + outputRect.width(); ++x) {
1439 qint32 iX = srcX0 + (x * srcWidth) / w; 1490​ qint32 iX = srcX0 + (x * srcWidth) / w;
1440 iter->moveTo(iX, iY); 1491​ srcIter->moveTo(iX, iY);
1441 dstIter->moveTo(x, y); 1492​ dstIter->moveTo(x, y);
1442 memcpy(dstIter->rawData(), iter->rawDataConst(), pixelSize); 1493​ memcpy(dstIter->rawData(), srcIter->rawDataConst(), pixelSize);
1443 } 1494​ }
1444 } 1495​ }
1445 return thumbnail; 1496​ return thumbnail;
1497​}
1498​
1499​KisPaintDeviceSP KisPaintDevice::createThumbnailDevice(qint32 w, qint32 h, QRect rect, QRect outputRect) const
1500​{
1501​ QSize thumbnailSize(w, h);
1502​
1503​ int srcWidth, srcHeight;
1504​ int srcX0, srcY0;
1505​ QRect imageRect = rect.isValid() ? rect : extent();
1506​
1507​ //can't create thumbnail for an empty device, e.g. layer thumbnail for empty image
1508​ if (imageRect.isEmpty() || !imageRect.isValid()) {
1509​ return new KisPaintDevice(colorSpace());
1510​ }
1511​
1512​ imageRect.getRect(&srcX0, &srcY0, &srcWidth, &srcHeight);
1513​
1514​ if ((thumbnailSize.width() > imageRect.width()) || (thumbnailSize.height() > imageRect.height())) {
1515​ thumbnailSize.scale(imageRect.size(), Qt::KeepAspectRatio);
1516​ }
1446 1517​
1518​ if (!outputRect.isValid()) {
1519​ outputRect = QRect(0, 0, w, h);
1520​ }
1521​
1522​ KisPaintDeviceSP thumbnail = createThumbnailDeviceInternal(this, imageRect.x(), imageRect.y(), imageRect.width(), imageRect.height(),
1523​ thumbnailSize.width(), thumbnailSize.height(), outputRect);
1524​
1525​ return thumbnail;
1447} 1526​}
1448 1527​
1449QImage KisPaintDevice::createThumbnail(qint32 w, qint32 h, QRect rect, KoColorConversionTransformation::Intent renderingIntent, KoColorConversionTransformation::ConversionFlags conversionFlags) 1528​KisPaintDeviceSP KisPaintDevice::createThumbnailDeviceOversampled(qint32 w, qint32 h, qreal oversample, QRect rect, QRect outputTileRect) const
1450{ 1529​{
1451 KisPaintDeviceSP dev = createThumbnailDevice(w, h, rect); 1530​ QSize thumbnailSize(w, h);
1531​ qreal oversampleAdjusted = qMax(oversample, 1.);
1532​ QSize thumbnailOversampledSize = oversampleAdjusted * thumbnailSize;
1533​
1534​ QRect outputRect;
1535​ QRect imageRect = (rect.isValid() && !rect.isNull()) ? rect : extent();
1536​
1537​ //can't create thumbnail for an empty device, e.g. layer thumbnail for empty image
1538​ if (imageRect.isEmpty() || !imageRect.isValid()) {
1539​ return new KisPaintDevice(colorSpace());
1540​ }
1541​
1542​ qint32 hstart = thumbnailOversampledSize.height();
1543​
1544​ if ((thumbnailOversampledSize.width() > imageRect.width()) || (thumbnailOversampledSize.height() > imageRect.height())) {
1545​ thumbnailOversampledSize.scale(imageRect.size(), Qt::KeepAspectRatio);
1546​ }
1547​
1548​ oversampleAdjusted *= (hstart > 0) ? ((qreal)thumbnailOversampledSize.height() / hstart) : 1.; //readjusting oversample ratio, given that we had to adjust thumbnail size
1549​
1550​ outputRect = QRect(0, 0, thumbnailOversampledSize.width(), thumbnailOversampledSize.height());
1551​
1552​ if (outputTileRect.isValid()) {
1553​ //compensating output rectangle for oversampling
1554​ outputTileRect = QRect(oversampleAdjusted * outputTileRect.topLeft(), oversampleAdjusted * outputTileRect.bottomRight());
1555​ outputRect = outputRect.intersected(outputTileRect);
1556​ }
1557​
1558​ KisPaintDeviceSP thumbnail = createThumbnailDeviceInternal(this, imageRect.x(), imageRect.y(), imageRect.width(), imageRect.height(),
1559​ thumbnailOversampledSize.width(), thumbnailOversampledSize.height(), outputRect);
1560​
1561​ if (oversample != 1. && oversampleAdjusted != 1.) {
1562​ KoDummyUpdater updater;
1563​ KisTransformWorker worker(thumbnail, 1 / oversampleAdjusted, 1 / oversampleAdjusted, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
1564​ &updater, KisFilterStrategyRegistry::instance()->value("Bilinear"));
1565​ worker.run();
1566​ }
1567​ return thumbnail;
1568​}
1569​
1570​QImage KisPaintDevice::createThumbnail(qint32 w, qint32 h, QRect rect, qreal oversample, KoColorConversionTransformation::Intent renderingIntent, KoColorConversionTransformation::ConversionFlags conversionFlags)
1571​{
1572​ KisPaintDeviceSP dev = createThumbnailDeviceOversampled(w, h, oversample, rect);
1452 QImage thumbnail = dev->convertToQImage(KoColorSpaceRegistry::instance()->rgb8()->profile(), 0, 0, w, h, renderingIntent, conversionFlags); 1573​ QImage thumbnail = dev->convertToQImage(KoColorSpaceRegistry::instance()->rgb8()->profile(), 0, 0, w, h, renderingIntent, conversionFlags);
1453 return thumbnail; 1574​ return thumbnail;
1454} 1575​}
1455 1576​
1456QImage KisPaintDevice::createThumbnail(qint32 w, qint32 h, KoColorConversionTransformation::Intent renderingIntent, KoColorConversionTransformation::ConversionFlags conversionFlags) 1577​QImage KisPaintDevice::createThumbnail(qint32 w, qint32 h, qreal oversample, KoColorConversionTransformation::Intent renderingIntent, KoColorConversionTransformation::ConversionFlags conversionFlags)
1457{ 1578​{
1458 return m_d->cache()->createThumbnail(w, h, renderingIntent, conversionFlags); 1579​ return m_d->cache()->createThumbnail(w, h, oversample, renderingIntent, conversionFlags);
1459} 1580​}
1460 1581​
1461KisHLineIteratorSP KisPaintDevice::createHLineIteratorNG(qint32 x, qint32 y, qint32 w) 1582​KisHLineIteratorSP KisPaintDevice::createHLineIteratorNG(qint32 x, qint32 y, qint32 w)
Context not available.
1832 1953​
1833const quint8* KisPaintDeviceFramesInterface::frameDefaultPixel(int frameId) const 1954​const quint8* KisPaintDeviceFramesInterface::frameDefaultPixel(int frameId) const
1834{ 1955​{
1835 KIS_ASSERT_RECOVER(frameId >= 0) { return (quint8*)"deadbeef"; } 1956​ KIS_ASSERT_RECOVER(frameId >= 0) {
1957​ return (quint8*)"deadbeef";
1958​ }
1836 return q->m_d->frameDefaultPixel(frameId); 1959​ return q->m_d->frameDefaultPixel(frameId);
1837} 1960​}
1838 1961​
1839bool KisPaintDeviceFramesInterface::writeFrame(KisPaintDeviceWriter &store, int frameId) 1962​bool KisPaintDeviceFramesInterface::writeFrame(KisPaintDeviceWriter &store, int frameId)
1840{ 1963​{
1841 KIS_ASSERT_RECOVER(frameId >= 0) { return false; } 1964​ KIS_ASSERT_RECOVER(frameId >= 0) {
1965​ return false;
1966​ }
1842 return q->m_d->writeFrame(store, frameId); 1967​ return q->m_d->writeFrame(store, frameId);
1843} 1968​}
1844 1969​
1845bool KisPaintDeviceFramesInterface::readFrame(QIODevice *stream, int frameId) 1970​bool KisPaintDeviceFramesInterface::readFrame(QIODevice *stream, int frameId)
1846{ 1971​{
1847 KIS_ASSERT_RECOVER(frameId >= 0) { return false; } 1972​ KIS_ASSERT_RECOVER(frameId >= 0) {
1973​ return false;
1974​ }
1848 return q->m_d->readFrame(stream, frameId); 1975​ return q->m_d->readFrame(stream, frameId);
1849} 1976​}
1850 1977​
Context not available.
1855 1982​
1856KisDataManagerSP KisPaintDeviceFramesInterface::frameDataManager(int frameId) const 1983​KisDataManagerSP KisPaintDeviceFramesInterface::frameDataManager(int frameId) const
1857{ 1984​{
1858 KIS_ASSERT_RECOVER(frameId >= 0) { return q->m_d->dataManager(); } 1985​ KIS_ASSERT_RECOVER(frameId >= 0) {
1986​ return q->m_d->dataManager();
1987​ }
1859 return q->m_d->frameDataManager(frameId); 1988​ return q->m_d->frameDataManager(frameId);
1860} 1989​}
1861 1990​
Context not available.