diff --git a/krita/krita.action b/krita/krita.action
--- a/krita/krita.action
+++ b/krita/krita.action
@@ -2219,6 +2219,18 @@
false
+
+ filterMask
+ &Colorize Mask
+
+ Colorize Mask
+ Colorize Mask
+ 100000
+ 0
+
+ false
+
+
transformMask
&Transform Mask...
diff --git a/krita/pics/layers/dark_colorizeMask.svg b/krita/pics/layers/dark_colorizeMask.svg
new file mode 100644
--- /dev/null
+++ b/krita/pics/layers/dark_colorizeMask.svg
@@ -0,0 +1,81 @@
+
+
+
+
diff --git a/krita/pics/layers/layers-icons.qrc b/krita/pics/layers/layers-icons.qrc
--- a/krita/pics/layers/layers-icons.qrc
+++ b/krita/pics/layers/layers-icons.qrc
@@ -2,6 +2,7 @@
dark_cloneLayer.svg
+ dark_colorizeMask.svg
dark_fileLayer.svg
dark_fillLayer.svg
dark_filterLayer.svg
@@ -15,6 +16,7 @@
dark_transparencyMask.svg
dark_vectorLayer.svg
light_cloneLayer.svg
+ light_colorizeMask.svg
light_fileLayer.svg
light_fillLayer.svg
light_filterLayer.svg
diff --git a/krita/pics/layers/light_colorizeMask.svg b/krita/pics/layers/light_colorizeMask.svg
new file mode 100644
--- /dev/null
+++ b/krita/pics/layers/light_colorizeMask.svg
@@ -0,0 +1,77 @@
+
+
+
+
diff --git a/krita/pics/svg/dark_showColoring.svg b/krita/pics/svg/dark_showColoring.svg
new file mode 100644
--- /dev/null
+++ b/krita/pics/svg/dark_showColoring.svg
@@ -0,0 +1,1470 @@
+
+
+
+
diff --git a/krita/pics/svg/dark_showColoringOff.svg b/krita/pics/svg/dark_showColoringOff.svg
new file mode 100644
--- /dev/null
+++ b/krita/pics/svg/dark_showColoringOff.svg
@@ -0,0 +1,1461 @@
+
+
+
+
diff --git a/krita/pics/svg/dark_showMarks.svg b/krita/pics/svg/dark_showMarks.svg
new file mode 100644
--- /dev/null
+++ b/krita/pics/svg/dark_showMarks.svg
@@ -0,0 +1,1468 @@
+
+
+
+
diff --git a/krita/pics/svg/dark_showMarksOff.svg b/krita/pics/svg/dark_showMarksOff.svg
new file mode 100644
--- /dev/null
+++ b/krita/pics/svg/dark_showMarksOff.svg
@@ -0,0 +1,1474 @@
+
+
+
+
diff --git a/krita/pics/svg/dark_updateColorize.svg b/krita/pics/svg/dark_updateColorize.svg
new file mode 100644
--- /dev/null
+++ b/krita/pics/svg/dark_updateColorize.svg
@@ -0,0 +1,1461 @@
+
+
+
+
diff --git a/krita/pics/svg/light_showColoring.svg b/krita/pics/svg/light_showColoring.svg
new file mode 100644
--- /dev/null
+++ b/krita/pics/svg/light_showColoring.svg
@@ -0,0 +1,1470 @@
+
+
+
+
diff --git a/krita/pics/svg/light_showColoringOff.svg b/krita/pics/svg/light_showColoringOff.svg
new file mode 100644
--- /dev/null
+++ b/krita/pics/svg/light_showColoringOff.svg
@@ -0,0 +1,1461 @@
+
+
+
+
diff --git a/krita/pics/svg/light_showMarks.svg b/krita/pics/svg/light_showMarks.svg
new file mode 100644
--- /dev/null
+++ b/krita/pics/svg/light_showMarks.svg
@@ -0,0 +1,1468 @@
+
+
+
+
diff --git a/krita/pics/svg/light_showMarksOff.svg b/krita/pics/svg/light_showMarksOff.svg
new file mode 100644
--- /dev/null
+++ b/krita/pics/svg/light_showMarksOff.svg
@@ -0,0 +1,1474 @@
+
+
+
+
diff --git a/krita/pics/svg/light_updateColorize.svg b/krita/pics/svg/light_updateColorize.svg
new file mode 100644
--- /dev/null
+++ b/krita/pics/svg/light_updateColorize.svg
@@ -0,0 +1,1461 @@
+
+
+
+
diff --git a/krita/pics/svg/svg-icons.qrc b/krita/pics/svg/svg-icons.qrc
--- a/krita/pics/svg/svg-icons.qrc
+++ b/krita/pics/svg/svg-icons.qrc
@@ -80,7 +80,16 @@
light_landscape.svg
light_portrait.svg
-
+ dark_showColoring.svg
+ dark_showMarks.svg
+ dark_showColoringOff.svg
+ dark_showMarksOff.svg
+ dark_updateColorize.svg
+ light_showColoring.svg
+ light_showMarks.svg
+ light_showColoringOff.svg
+ light_showMarksOff.svg
+ light_updateColorize.svg
diff --git a/libs/global/kis_dom_utils.h b/libs/global/kis_dom_utils.h
--- a/libs/global/kis_dom_utils.h
+++ b/libs/global/kis_dom_utils.h
@@ -198,37 +198,50 @@
}
/**
+ * A special adapter method that makes vector- and tag-based methods
+ * work with environment parameter uniformly.
+ */
+template
+ typename std::enable_if::value, bool>::type
+loadValue(const QDomElement &parent, T *value, const E &env) {
+ return KisDomUtils::loadValue(parent, value);
+}
+
+/**
* Load an array from an XML element, which is a child of \p parent
* and has a tag \p tag.
*
* \return true if the object is successfully loaded and is unique
*
* \see saveValue()
*/
-template class Container, typename T>
-bool loadValue(const QDomElement &e, Container *array)
+template class Container, typename T, typename E = std::tuple<>>
+ bool loadValue(const QDomElement &e, Container *array, const E &env = E())
+
{
if (!Private::checkType(e, "array")) return false;
QDomElement child = e.firstChildElement();
while (!child.isNull()) {
T value;
- if (!loadValue(child, &value)) return false;
+ if (!loadValue(child, &value, env)) return false;
*array << value;
child = child.nextSiblingElement();
}
return true;
}
-template
-bool loadValue(const QDomElement &parent, const QString &tag, T *value)
+template >
+ bool loadValue(const QDomElement &parent, const QString &tag, T *value, const E &env = E())
{
QDomElement e;
if (!findOnlyElement(parent, tag, &e)) return false;
- return loadValue(e, value);
+ return loadValue(e, value, env);
}
+
+
KRITAGLOBAL_EXPORT QDomElement findElementByAttibute(QDomNode parent,
const QString &tag,
const QString &attribute,
diff --git a/libs/image/CMakeLists.txt b/libs/image/CMakeLists.txt
--- a/libs/image/CMakeLists.txt
+++ b/libs/image/CMakeLists.txt
@@ -117,6 +117,11 @@
generator/kis_generator_registry.cpp
floodfill/kis_fill_interval_map.cpp
floodfill/kis_scanline_fill.cpp
+ lazybrush/kis_min_cut_worker.cpp
+ lazybrush/kis_lazy_fill_tools.cpp
+ lazybrush/kis_multiway_cut.cpp
+ lazybrush/kis_colorize_mask.cpp
+ lazybrush/kis_colorize_stroke_strategy.cpp
kis_adjustment_layer.cc
kis_selection_based_layer.cpp
kis_node_filter_interface.cpp
@@ -243,6 +248,7 @@
kis_undo_store.cpp
kis_undo_stores.cpp
kis_undo_adapter.cpp
+ kis_macro_based_undo_store.cpp
kis_surrogate_undo_adapter.cpp
kis_legacy_undo_adapter.cpp
kis_post_execution_undo_adapter.cpp
diff --git a/libs/image/commands_new/kis_image_set_resolution_command.cpp b/libs/image/commands_new/kis_image_set_resolution_command.cpp
--- a/libs/image/commands_new/kis_image_set_resolution_command.cpp
+++ b/libs/image/commands_new/kis_image_set_resolution_command.cpp
@@ -71,6 +71,7 @@
void visit(KisTransformMask *mask, KisUndoAdapter*) { KIS_ASSERT_RECOVER_NOOP(!mask->selection()); }
void visit(KisTransparencyMask *mask, KisUndoAdapter*) { mask->selection()->updateProjection(); }
void visit(KisSelectionMask *mask, KisUndoAdapter*) { mask->selection()->updateProjection(); }
+ void visit(KisColorizeMask *, KisUndoAdapter*) {}
};
diff --git a/libs/image/floodfill/kis_scanline_fill.h b/libs/image/floodfill/kis_scanline_fill.h
--- a/libs/image/floodfill/kis_scanline_fill.h
+++ b/libs/image/floodfill/kis_scanline_fill.h
@@ -34,9 +34,34 @@
KisScanlineFill(KisPaintDeviceSP device, const QPoint &startPoint, const QRect &boundingRect);
~KisScanlineFill();
+ /**
+ * Fill the source device with \p fillColor
+ */
void fillColor(const KoColor &fillColor);
+
+ /**
+ * Fill \p externalDevice with \p fillColor basing on the contents
+ * of the source device.
+ */
+ void fillColor(const KoColor &fillColor, KisPaintDeviceSP externalDevice);
+
+ /**
+ * Fill \p pixelSelection with the opacity of the contiguous area
+ */
void fillSelection(KisPixelSelectionSP pixelSelection);
+ /**
+ * Clear the contiguous non-zero area of the device
+ *
+ * WARNING: the threshold parameter is not counted!
+ */
+ void clearNonZeroComponent();
+
+ /**
+ * Set the threshold of the filling operation
+ *
+ * Used in all functions except clearNonZeroComponent()
+ */
void setThreshold(int threshold);
private:
diff --git a/libs/image/floodfill/kis_scanline_fill.cpp b/libs/image/floodfill/kis_scanline_fill.cpp
--- a/libs/image/floodfill/kis_scanline_fill.cpp
+++ b/libs/image/floodfill/kis_scanline_fill.cpp
@@ -92,6 +92,46 @@
int m_pixelSize;
};
+template
+class FillWithColorExternal : public BaseClass
+{
+public:
+ typedef KisRandomConstAccessorSP SourceAccessorType;
+
+ SourceAccessorType createSourceDeviceAccessor(KisPaintDeviceSP device) {
+ return device->createRandomConstAccessorNG(0, 0);
+ }
+
+public:
+ void setDestinationDevice(KisPaintDeviceSP device) {
+ m_externalDevice = device;
+ m_it = m_externalDevice->createRandomAccessorNG(0,0);
+ }
+
+ void setFillColor(const KoColor &sourceColor) {
+ m_sourceColor = sourceColor;
+ m_pixelSize = sourceColor.colorSpace()->pixelSize();
+ m_data = m_sourceColor.data();
+ }
+
+ ALWAYS_INLINE void fillPixel(quint8 *dstPtr, quint8 opacity, int x, int y) {
+ Q_UNUSED(dstPtr);
+
+ m_it->moveTo(x, y);
+ if (opacity == MAX_SELECTED) {
+ memcpy(m_it->rawData(), m_data, m_pixelSize);
+ }
+ }
+
+private:
+ KisPaintDeviceSP m_externalDevice;
+ KisRandomAccessorSP m_it;
+
+ KoColor m_sourceColor;
+ const quint8 *m_data;
+ int m_pixelSize;
+};
+
class DifferencePolicySlow
{
public:
@@ -188,6 +228,40 @@
int m_threshold;
};
+class IsNonNullPolicySlow
+{
+public:
+ ALWAYS_INLINE void initDifferencies(KisPaintDeviceSP device, const KoColor &srcPixel) {
+ Q_UNUSED(srcPixel);
+
+ m_pixelSize = device->pixelSize();
+ m_testPixel.resize(m_pixelSize);
+ }
+
+ ALWAYS_INLINE quint8 calculateDifference(quint8* pixelPtr) {
+ return memcmp(m_testPixel.data(), pixelPtr, m_pixelSize);
+ }
+
+private:
+ int m_pixelSize;
+ QByteArray m_testPixel;
+};
+
+template
+class IsNonNullPolicyOptimized
+{
+public:
+ ALWAYS_INLINE void initDifferencies(KisPaintDeviceSP device, const KoColor &srcPixel) {
+ Q_UNUSED(device);
+ Q_UNUSED(srcPixel);
+ }
+
+ ALWAYS_INLINE quint8 calculateDifference(quint8* pixelPtr) {
+ SrcPixelType *pixel = reinterpret_cast(pixelPtr);
+ return *pixel == 0;
+ }
+};
+
struct Q_DECL_HIDDEN KisScanlineFill::Private
{
KisPaintDeviceSP device;
@@ -427,6 +501,46 @@
}
}
+void KisScanlineFill::fillColor(const KoColor &fillColor, KisPaintDeviceSP externalDevice)
+{
+ KisRandomConstAccessorSP it = m_d->device->createRandomConstAccessorNG(m_d->startPoint.x(), m_d->startPoint.y());
+ KoColor srcColor(it->rawDataConst(), m_d->device->colorSpace());
+
+ const int pixelSize = m_d->device->pixelSize();
+
+ if (pixelSize == 1) {
+ SelectionPolicy, FillWithColorExternal>
+ policy(m_d->device, srcColor, m_d->threshold);
+ policy.setDestinationDevice(externalDevice);
+ policy.setFillColor(fillColor);
+ runImpl(policy);
+ } else if (pixelSize == 2) {
+ SelectionPolicy, FillWithColorExternal>
+ policy(m_d->device, srcColor, m_d->threshold);
+ policy.setDestinationDevice(externalDevice);
+ policy.setFillColor(fillColor);
+ runImpl(policy);
+ } else if (pixelSize == 4) {
+ SelectionPolicy, FillWithColorExternal>
+ policy(m_d->device, srcColor, m_d->threshold);
+ policy.setDestinationDevice(externalDevice);
+ policy.setFillColor(fillColor);
+ runImpl(policy);
+ } else if (pixelSize == 8) {
+ SelectionPolicy, FillWithColorExternal>
+ policy(m_d->device, srcColor, m_d->threshold);
+ policy.setDestinationDevice(externalDevice);
+ policy.setFillColor(fillColor);
+ runImpl(policy);
+ } else {
+ SelectionPolicy
+ policy(m_d->device, srcColor, m_d->threshold);
+ policy.setDestinationDevice(externalDevice);
+ policy.setFillColor(fillColor);
+ runImpl(policy);
+ }
+}
+
void KisScanlineFill::fillSelection(KisPixelSelectionSP pixelSelection)
{
KisRandomConstAccessorSP it = m_d->device->createRandomConstAccessorNG(m_d->startPoint.x(), m_d->startPoint.y());
@@ -462,6 +576,39 @@
}
}
+void KisScanlineFill::clearNonZeroComponent()
+{
+ const int pixelSize = m_d->device->pixelSize();
+ KoColor srcColor(Qt::transparent, m_d->device->colorSpace());
+
+ if (pixelSize == 1) {
+ SelectionPolicy, FillWithColor>
+ policy(m_d->device, srcColor, m_d->threshold);
+ policy.setFillColor(srcColor);
+ runImpl(policy);
+ } else if (pixelSize == 2) {
+ SelectionPolicy, FillWithColor>
+ policy(m_d->device, srcColor, m_d->threshold);
+ policy.setFillColor(srcColor);
+ runImpl(policy);
+ } else if (pixelSize == 4) {
+ SelectionPolicy, FillWithColor>
+ policy(m_d->device, srcColor, m_d->threshold);
+ policy.setFillColor(srcColor);
+ runImpl(policy);
+ } else if (pixelSize == 8) {
+ SelectionPolicy, FillWithColor>
+ policy(m_d->device, srcColor, m_d->threshold);
+ policy.setFillColor(srcColor);
+ runImpl(policy);
+ } else {
+ SelectionPolicy
+ policy(m_d->device, srcColor, m_d->threshold);
+ policy.setFillColor(srcColor);
+ runImpl(policy);
+ }
+}
+
void KisScanlineFill::testingProcessLine(const KisFillInterval &processInterval)
{
KoColor srcColor(QColor(0,0,0,0), m_d->device->colorSpace());
diff --git a/libs/image/kis_async_merger.cpp b/libs/image/kis_async_merger.cpp
--- a/libs/image/kis_async_merger.cpp
+++ b/libs/image/kis_async_merger.cpp
@@ -192,6 +192,9 @@
bool visit(KisSelectionMask*) {
return true;
}
+ bool visit(KisColorizeMask*) {
+ return true;
+ }
private:
QRect m_updateRect;
diff --git a/libs/image/kis_cached_paint_device.h b/libs/image/kis_cached_paint_device.h
--- a/libs/image/kis_cached_paint_device.h
+++ b/libs/image/kis_cached_paint_device.h
@@ -21,7 +21,6 @@
#include "tiles3/kis_lockless_stack.h"
-
class KisCachedPaintDevice
{
public:
@@ -45,4 +44,26 @@
KisLocklessStack m_stack;
};
+class KisCachedSelection
+{
+public:
+ KisSelectionSP getSelection() {
+ KisSelectionSP selection;
+
+ if(!m_stack.pop(selection)) {
+ selection = new KisSelection();
+ }
+
+ return selection;
+ }
+
+ void putSelection(KisSelectionSP selection) {
+ selection->clear();
+ m_stack.push(selection);
+ }
+
+private:
+ KisLocklessStack m_stack;
+};
+
#endif /* __KIS_CACHED_PAINT_DEVICE_H */
diff --git a/libs/image/kis_change_profile_visitor.h b/libs/image/kis_change_profile_visitor.h
--- a/libs/image/kis_change_profile_visitor.h
+++ b/libs/image/kis_change_profile_visitor.h
@@ -23,6 +23,7 @@
#include "kis_types.h"
#include "kis_node_visitor.h"
#include "kis_paint_layer.h"
+#include "lazybrush/kis_colorize_mask.h"
#include "kis_adjustment_layer.h"
#include "generator/kis_generator_layer.h"
#include "kis_group_layer.h"
@@ -102,6 +103,13 @@
return true;
}
+ bool visit(KisColorizeMask *mask) {
+ if (mask->colorSpace()->colorModelId() == m_oldColorSpace->colorModelId()) {
+ mask->setProfile(m_dstColorSpace->profile());
+ }
+ return true;
+ }
+
private:
bool updatePaintDevice(KisLayer *layer) {
diff --git a/libs/image/kis_colorspace_convert_visitor.h b/libs/image/kis_colorspace_convert_visitor.h
--- a/libs/image/kis_colorspace_convert_visitor.h
+++ b/libs/image/kis_colorspace_convert_visitor.h
@@ -67,6 +67,8 @@
return true;
}
+ bool visit(KisColorizeMask *mask);
+
private:
bool convertPaintDevice(KisLayer* layer);
diff --git a/libs/image/kis_colorspace_convert_visitor.cpp b/libs/image/kis_colorspace_convert_visitor.cpp
--- a/libs/image/kis_colorspace_convert_visitor.cpp
+++ b/libs/image/kis_colorspace_convert_visitor.cpp
@@ -23,6 +23,7 @@
#include "kis_adjustment_layer.h"
#include "kis_paint_layer.h"
#include "kis_group_layer.h"
+#include "lazybrush/kis_colorize_mask.h"
#include "kis_external_layer_iface.h"
#include "filter/kis_filter_configuration.h"
#include "filter/kis_filter_registry.h"
@@ -113,26 +114,23 @@
if (layer->original()) {
KUndo2Command* cmd = layer->original()->convertTo(m_dstColorSpace, m_renderingIntent, m_conversionFlags);
- if (cmd)
+ if (cmd) {
m_image->undoAdapter()->addCommand(cmd);
- else
- delete cmd;
+ }
}
if (layer->paintDevice()) {
KUndo2Command* cmd = layer->paintDevice()->convertTo(m_dstColorSpace, m_renderingIntent, m_conversionFlags);
- if (cmd)
+ if (cmd) {
m_image->undoAdapter()->addCommand(cmd);
- else
- delete cmd;
+ }
}
if (layer->projection()) {
KUndo2Command* cmd = layer->projection()->convertTo(m_dstColorSpace, m_renderingIntent, m_conversionFlags);
- if (cmd)
+ if (cmd) {
m_image->undoAdapter()->addCommand(cmd);
- else
- delete cmd;
+ }
}
KisPaintLayer *paintLayer = 0;
@@ -145,3 +143,12 @@
return true;
}
+
+bool KisColorSpaceConvertVisitor::visit(KisColorizeMask *mask)
+{
+ KUndo2Command* cmd = mask->setColorSpace(m_dstColorSpace, m_renderingIntent, m_conversionFlags);
+ if (cmd) {
+ m_image->undoAdapter()->addCommand(cmd);
+ }
+ return true;
+}
diff --git a/libs/image/kis_command_utils.h b/libs/image/kis_command_utils.h
--- a/libs/image/kis_command_utils.h
+++ b/libs/image/kis_command_utils.h
@@ -65,7 +65,19 @@
private:
bool m_finalize;
bool m_firstRedo;
- KisSurrogateUndoStore m_store;
+ };
+
+ struct KRITAIMAGE_EXPORT CompositeCommand : public KUndo2Command {
+ CompositeCommand(KUndo2Command *parent = 0);
+ ~CompositeCommand();
+
+ void addCommand(KUndo2Command *cmd);
+
+ void redo();
+ void undo();
+
+ private:
+ QVector m_commands;
};
}
diff --git a/libs/image/kis_command_utils.cpp b/libs/image/kis_command_utils.cpp
--- a/libs/image/kis_command_utils.cpp
+++ b/libs/image/kis_command_utils.cpp
@@ -96,4 +96,29 @@
void FlipFlopCommand::init() {}
void FlipFlopCommand::end() {}
+
+ CompositeCommand::CompositeCommand(KUndo2Command *parent)
+ : KUndo2Command(parent) {}
+
+ CompositeCommand::~CompositeCommand() {
+ qDeleteAll(m_commands);
+ }
+
+ void CompositeCommand::addCommand(KUndo2Command *cmd) {
+ if (cmd) {
+ m_commands << cmd;
+ }
+ }
+
+ void CompositeCommand::redo() {
+ Q_FOREACH (KUndo2Command *cmd, m_commands) {
+ cmd->redo();
+ }
+ }
+
+ void CompositeCommand::undo() {
+ Q_FOREACH (KUndo2Command *cmd, m_commands) {
+ cmd->undo();
+ }
+ }
}
diff --git a/libs/image/kis_convolution_worker_spatial.h b/libs/image/kis_convolution_worker_spatial.h
--- a/libs/image/kis_convolution_worker_spatial.h
+++ b/libs/image/kis_convolution_worker_spatial.h
@@ -270,7 +270,7 @@
qreal channelPixelValue;
if (additionalMultiplierActive) {
- channelPixelValue = (interimConvoResult * m_kernelFactor + m_absoluteOffset[channel]) * additionalMultiplier;
+ channelPixelValue = (interimConvoResult * m_kernelFactor) * additionalMultiplier + m_absoluteOffset[channel];
} else {
channelPixelValue = interimConvoResult * m_kernelFactor + m_absoluteOffset[channel];
}
@@ -287,6 +287,11 @@
if (m_alphaCachePos >= 0) {
qreal alphaValue = convolveOneChannelFromCache(dstPtr, m_alphaCachePos);
+ // TODO: we need a special case for applying LoG filter,
+ // when the alpha i suniform and therefore should not be
+ // filtered!
+ //alphaValue = 255.0;
+
if (alphaValue != 0.0) {
qreal alphaValueInv = 1.0 / alphaValue;
diff --git a/libs/image/kis_count_visitor.h b/libs/image/kis_count_visitor.h
--- a/libs/image/kis_count_visitor.h
+++ b/libs/image/kis_count_visitor.h
@@ -34,6 +34,7 @@
#include "kis_transform_mask.h"
#include "kis_transparency_mask.h"
#include "kis_selection_mask.h"
+#include "lazybrush/kis_colorize_mask.h"
#include "generator/kis_generator_layer.h"
/**
* The count visitor traverses the node stack for nodes that conform
@@ -107,6 +108,10 @@
return check(mask);
}
+ bool visit(KisColorizeMask* mask) {
+ return check(mask);
+ }
+
private:
bool inList(KisNode* node);
diff --git a/libs/image/kis_fill_painter.cc b/libs/image/kis_fill_painter.cc
--- a/libs/image/kis_fill_painter.cc
+++ b/libs/image/kis_fill_painter.cc
@@ -92,7 +92,7 @@
void KisFillPainter::fillSelection(const QRect &rc, const KoColor &color)
{
KisPaintDeviceSP fillDevice = new KisPaintDevice(device()->colorSpace());
- fillDevice->setDefaultPixel(color.data());
+ fillDevice->setDefaultPixel(color);
bitBlt(rc.topLeft(), fillDevice, rc);
}
diff --git a/libs/image/kis_filter_weights_applicator.h b/libs/image/kis_filter_weights_applicator.h
--- a/libs/image/kis_filter_weights_applicator.h
+++ b/libs/image/kis_filter_weights_applicator.h
@@ -224,7 +224,8 @@
int pixelSize = m_src->pixelSize();
KoMixColorsOp *mixOp = m_src->colorSpace()->mixColorsOp();
- const quint8 *defaultPixel = m_src->defaultPixel();
+ const KoColor defaultPixelObject = m_src->defaultPixel();
+ const quint8 *defaultPixel = defaultPixelObject.data();
const quint8 *borderPixel = defaultPixel;
quint8 *srcLineBuf = new quint8[pixelSize * (rightSrcBorder - leftSrcBorder)];
diff --git a/libs/image/kis_gaussian_kernel.h b/libs/image/kis_gaussian_kernel.h
--- a/libs/image/kis_gaussian_kernel.h
+++ b/libs/image/kis_gaussian_kernel.h
@@ -49,6 +49,14 @@
qreal xRadius, qreal yRadius,
const QBitArray &channelFlags,
KoUpdater *updater);
+
+ static Eigen::Matrix createLoGMatrix(qreal radius);
+
+ static void applyLoG(KisPaintDeviceSP device,
+ const QRect& rect,
+ qreal radius,
+ const QBitArray &channelFlags,
+ KoUpdater *progressUpdater);
};
#endif /* __KIS_GAUSSIAN_KERNEL_H */
diff --git a/libs/image/kis_gaussian_kernel.cpp b/libs/image/kis_gaussian_kernel.cpp
--- a/libs/image/kis_gaussian_kernel.cpp
+++ b/libs/image/kis_gaussian_kernel.cpp
@@ -18,6 +18,7 @@
#include "kis_gaussian_kernel.h"
+#include "kis_global.h"
#include "kis_convolution_kernel.h"
#include
#include
@@ -145,3 +146,94 @@
painter.applyMatrix(kernelVertical, device, srcTopLeft, srcTopLeft, rect.size(), BORDER_REPEAT);
}
}
+
+Eigen::Matrix
+KisGaussianKernel::createLoGMatrix(qreal radius)
+{
+ int kernelSize = 4 * std::ceil(radius) + 1;
+ Eigen::Matrix matrix(kernelSize, kernelSize);
+
+ const qreal sigma = radius/* / sqrt(2)*/;
+ const qreal multiplicand = -1 / (M_PI * pow2(pow2(sigma)));
+ const qreal exponentMultiplicand = 1 / (2 * pow2(sigma));
+
+ /**
+ * The kernel size should always be odd, then the position of the
+ * central pixel can be easily calculated
+ */
+ KIS_ASSERT_RECOVER_NOOP(kernelSize & 0x1);
+ const int center = kernelSize / 2;
+
+ for (int y = 0; y < kernelSize; y++) {
+ const qreal yDistance = center - y;
+ for (int x = 0; x < kernelSize; x++) {
+ const qreal xDistance = center - x;
+ const qreal distance = pow2(xDistance) + pow2(yDistance);
+ const qreal normalizedDistance = exponentMultiplicand * distance;
+
+ matrix(x, y) = multiplicand *
+ (1.0 - normalizedDistance) *
+ exp(-normalizedDistance);
+ }
+ }
+
+ qreal lateral = matrix.sum() - matrix(center, center);
+ matrix(center, center) = -lateral;
+
+ qreal positiveSum = 0;
+ qreal sideSum = 0;
+ qreal quarterSum = 0;
+
+ for (int y = 0; y < kernelSize; y++) {
+ for (int x = 0; x < kernelSize; x++) {
+ const qreal value = matrix(x, y);
+ if (value > 0) {
+ positiveSum += value;
+ }
+ if (x > center) {
+ sideSum += value;
+ }
+ if (x > center && y > center) {
+ quarterSum += value;
+ }
+ }
+ }
+
+
+ const qreal scale = 2.0 / positiveSum;
+ matrix *= scale;
+ positiveSum *= scale;
+ sideSum *= scale;
+ quarterSum *= scale;
+
+ //qDebug() << ppVar(positiveSum) << ppVar(sideSum) << ppVar(quarterSum);
+
+ return matrix;
+}
+
+#include "kis_transaction.h"
+
+void KisGaussianKernel::applyLoG(KisPaintDeviceSP device,
+ const QRect& rect,
+ qreal radius,
+ const QBitArray &channelFlags,
+ KoUpdater *progressUpdater)
+{
+ QPoint srcTopLeft = rect.topLeft();
+
+ KisConvolutionPainter painter(device);
+ painter.setChannelFlags(channelFlags);
+ painter.setProgress(progressUpdater);
+
+ Eigen::Matrix matrix = createLoGMatrix(radius);
+ qDebug() << ppVar(matrix.sum());
+ KisConvolutionKernelSP kernel =
+ KisConvolutionKernel::fromMatrix(matrix,
+ 0,
+ 0);
+
+ // TODO: move applying transaction to a higher level!
+ KisTransaction t(device);
+ painter.applyMatrix(kernel, device, srcTopLeft, srcTopLeft, rect.size(), BORDER_REPEAT);
+ t.end();
+}
diff --git a/libs/image/kis_group_layer.cc b/libs/image/kis_group_layer.cc
--- a/libs/image/kis_group_layer.cc
+++ b/libs/image/kis_group_layer.cc
@@ -190,14 +190,8 @@
KisPaintDeviceSP dev = new KisPaintDevice(this, colorSpace, new KisDefaultBounds(image()));
dev->setX(this->x());
dev->setY(this->y());
- quint8* defaultPixel = new quint8[colorSpace->pixelSize()];
-
- m_d->paintDevice->colorSpace()->
- convertPixelsTo(m_d->paintDevice->defaultPixel(), defaultPixel, colorSpace, 1,
- KoColorConversionTransformation::internalRenderingIntent(),
- KoColorConversionTransformation::internalConversionFlags());
- dev->setDefaultPixel(defaultPixel);
- delete[] defaultPixel;
+ dev->setDefaultPixel(m_d->paintDevice->defaultPixel());
+
m_d->paintDevice = dev;
m_d->paintDevice->setProjectionDevice(true);
} else {
@@ -239,8 +233,7 @@
!child->layerStyle()) {
quint8 defaultOpacity =
- m_d->paintDevice->colorSpace()->opacityU8(
- m_d->paintDevice->defaultPixel());
+ m_d->paintDevice->defaultPixel().opacityU8();
if(defaultOpacity == OPACITY_TRANSPARENT_U8) {
return child->projection();
@@ -276,8 +269,7 @@
void KisGroupLayer::setDefaultProjectionColor(KoColor color)
{
- color.convertTo(m_d->paintDevice->colorSpace());
- m_d->paintDevice->setDefaultPixel(color.data());
+ m_d->paintDevice->setDefaultPixel(color);
}
KoColor KisGroupLayer::defaultProjectionColor() const
diff --git a/libs/image/kis_image.cc b/libs/image/kis_image.cc
--- a/libs/image/kis_image.cc
+++ b/libs/image/kis_image.cc
@@ -1103,16 +1103,15 @@
m_d->rootLayer->disconnect();
KisPaintDeviceSP original = m_d->rootLayer->original();
- defaultProjectionColor.setColor(original->defaultPixel(), original->colorSpace());
+ defaultProjectionColor = original->defaultPixel();
}
m_d->rootLayer = rootLayer;
m_d->rootLayer->disconnect();
m_d->rootLayer->setGraphListener(this);
KisPaintDeviceSP newOriginal = m_d->rootLayer->original();
- defaultProjectionColor.convertTo(newOriginal->colorSpace());
- newOriginal->setDefaultPixel(defaultProjectionColor.data());
+ newOriginal->setDefaultPixel(defaultProjectionColor);
setRoot(m_d->rootLayer.data());
}
diff --git a/libs/image/kis_indirect_painting_support.h b/libs/image/kis_indirect_painting_support.h
--- a/libs/image/kis_indirect_painting_support.h
+++ b/libs/image/kis_indirect_painting_support.h
@@ -29,6 +29,7 @@
class KisPainter;
class KUndo2MagicString;
class KoCompositeOp;
+class KoColor;
/**
* For classes that support indirect painting.
@@ -47,8 +48,9 @@
bool hasTemporaryTarget() const;
+ virtual void setCurrentColor(const KoColor &color);
void setTemporaryTarget(KisPaintDeviceSP t);
- void setTemporaryCompositeOp(const KoCompositeOp* c);
+ void setTemporaryCompositeOp(const QString &id);
void setTemporaryOpacity(quint8 o);
void setTemporaryChannelFlags(const QBitArray& channelFlags);
void setTemporarySelection(KisSelectionSP selection);
@@ -65,8 +67,7 @@
* Writes the temporary target into the paint device of the layer.
* This action will lock the temporary target itself.
*/
- void mergeToLayer(KisNodeSP layer, KisUndoAdapter *undoAdapter, const KUndo2MagicString &transactionText,int timedID = -1);
- void mergeToLayer(KisNodeSP layer, KisPostExecutionUndoAdapter *undoAdapter, const KUndo2MagicString &transactionText,int timedID = -1);
+ virtual void mergeToLayer(KisNodeSP layer, KisPostExecutionUndoAdapter *undoAdapter, const KUndo2MagicString &transactionText, int timedID = -1);
/**
@@ -84,8 +85,15 @@
*/
void unlockTemporaryTarget() const;
- KisPaintDeviceSP temporaryTarget();
- const KisPaintDeviceSP temporaryTarget() const;
+ KisPaintDeviceSP temporaryTarget() const;
+
+protected:
+ void mergeToLayerImpl(KisPaintDeviceSP dst, KisPostExecutionUndoAdapter *undoAdapter, const KUndo2MagicString &transactionText, int timedID = -1, bool cleanResources = true);
+ virtual void writeMergeData(KisPainter *painter, KisPaintDeviceSP src);
+ void lockTemporaryTargetForWrite() const;
+
+ QString temporaryCompositeOp() const;
+ void releaseResources();
private:
friend class KisPainterBasedStrokeStrategy;
@@ -97,14 +105,6 @@
KisSelectionSP temporarySelection() const;
private:
-
- template
- void mergeToLayerImpl(KisNodeSP layer,
- UndoAdapter *undoAdapter,
- const KUndo2MagicString &transactionText,int timedID = -1);
- void releaseResources();
-
-private:
struct Private;
Private* const d;
};
diff --git a/libs/image/kis_indirect_painting_support.cpp b/libs/image/kis_indirect_painting_support.cpp
--- a/libs/image/kis_indirect_painting_support.cpp
+++ b/libs/image/kis_indirect_painting_support.cpp
@@ -35,7 +35,7 @@
struct Q_DECL_HIDDEN KisIndirectPaintingSupport::Private {
// To simulate the indirect painting
KisPaintDeviceSP temporaryTarget;
- const KoCompositeOp* compositeOp;
+ QString compositeOp;
quint8 compositeOpacity;
QBitArray channelFlags;
KisSelectionSP selection;
@@ -47,22 +47,26 @@
KisIndirectPaintingSupport::KisIndirectPaintingSupport()
: d(new Private)
{
- d->compositeOp = 0;
}
KisIndirectPaintingSupport::~KisIndirectPaintingSupport()
{
delete d;
}
+void KisIndirectPaintingSupport::setCurrentColor(const KoColor &color)
+{
+ Q_UNUSED(color);
+}
+
void KisIndirectPaintingSupport::setTemporaryTarget(KisPaintDeviceSP t)
{
d->temporaryTarget = t;
}
-void KisIndirectPaintingSupport::setTemporaryCompositeOp(const KoCompositeOp* c)
+void KisIndirectPaintingSupport::setTemporaryCompositeOp(const QString &id)
{
- d->compositeOp = c;
+ d->compositeOp = id;
}
void KisIndirectPaintingSupport::setTemporaryOpacity(quint8 o)
@@ -85,19 +89,24 @@
d->lock.lockForRead();
}
+void KisIndirectPaintingSupport::lockTemporaryTargetForWrite() const
+{
+ d->lock.lockForWrite();
+}
+
void KisIndirectPaintingSupport::unlockTemporaryTarget() const
{
d->lock.unlock();
}
-KisPaintDeviceSP KisIndirectPaintingSupport::temporaryTarget()
+KisPaintDeviceSP KisIndirectPaintingSupport::temporaryTarget() const
{
return d->temporaryTarget;
}
-const KisPaintDeviceSP KisIndirectPaintingSupport::temporaryTarget() const
+QString KisIndirectPaintingSupport::temporaryCompositeOp() const
{
- return d->temporaryTarget;
+ return d->compositeOp;
}
KisSelectionSP KisIndirectPaintingSupport::temporarySelection() const
@@ -112,32 +121,24 @@
void KisIndirectPaintingSupport::setupTemporaryPainter(KisPainter *painter) const
{
- painter->setOpacity(d->compositeOpacity);
- painter->setCompositeOp(d->compositeOp);
- painter->setChannelFlags(d->channelFlags);
- painter->setSelection(d->selection);
-}
-
-void KisIndirectPaintingSupport::mergeToLayer(KisNodeSP layer, KisUndoAdapter *undoAdapter, const KUndo2MagicString &transactionText,int timedID)
-{
- mergeToLayerImpl(layer, undoAdapter, transactionText,timedID);
+ painter->setOpacity(d->compositeOpacity);
+ painter->setCompositeOp(d->compositeOp);
+ painter->setChannelFlags(d->channelFlags);
+ painter->setSelection(d->selection);
}
void KisIndirectPaintingSupport::mergeToLayer(KisNodeSP layer, KisPostExecutionUndoAdapter *undoAdapter, const KUndo2MagicString &transactionText,int timedID)
{
- mergeToLayerImpl(layer, undoAdapter, transactionText,timedID);
+ mergeToLayerImpl(layer->paintDevice(), undoAdapter, transactionText, timedID);
}
-template
-void KisIndirectPaintingSupport::mergeToLayerImpl(KisNodeSP layer,
- UndoAdapter *undoAdapter,
- const KUndo2MagicString &transactionText,int timedID)
+void KisIndirectPaintingSupport::mergeToLayerImpl(KisPaintDeviceSP dst, KisPostExecutionUndoAdapter *undoAdapter, const KUndo2MagicString &transactionText, int timedID, bool cleanResources)
{
/**
* We do not apply selection here, because it has already
* been taken into account in a tool code
*/
- KisPainter gc(layer->paintDevice());
+ KisPainter gc(dst);
setupTemporaryPainter(&gc);
d->lock.lockForWrite();
@@ -148,18 +149,27 @@
if(undoAdapter) {
gc.beginTransaction(transactionText,timedID);
}
- Q_FOREACH (const QRect &rc, d->temporaryTarget->region().rects()) {
- gc.bitBlt(rc.topLeft(), d->temporaryTarget, rc);
+
+ writeMergeData(&gc, d->temporaryTarget);
+
+ if (cleanResources) {
+ releaseResources();
}
- releaseResources();
if(undoAdapter) {
gc.endTransaction(undoAdapter);
}
d->lock.unlock();
}
+void KisIndirectPaintingSupport::writeMergeData(KisPainter *painter, KisPaintDeviceSP src)
+{
+ Q_FOREACH (const QRect &rc, src->region().rects()) {
+ painter->bitBlt(rc.topLeft(), src, rc);
+ }
+}
+
void KisIndirectPaintingSupport::releaseResources()
{
d->temporaryTarget = 0;
diff --git a/libs/image/kis_layer_composition.cpp b/libs/image/kis_layer_composition.cpp
--- a/libs/image/kis_layer_composition.cpp
+++ b/libs/image/kis_layer_composition.cpp
@@ -28,6 +28,7 @@
#include "kis_transform_mask.h"
#include "kis_transparency_mask.h"
#include "kis_selection_mask.h"
+#include "lazybrush/kis_colorize_mask.h"
#include
@@ -60,6 +61,7 @@
virtual bool visit(KisTransformMask* mask) { return process(mask); }
virtual bool visit(KisTransparencyMask* mask) { return process(mask); }
virtual bool visit(KisSelectionMask* mask) { return process(mask); }
+ virtual bool visit(KisColorizeMask* mask) { return process(mask); }
bool process(KisNode* node) {
if(m_mode == STORE) {
diff --git a/libs/image/kis_layer_properties_icons.h b/libs/image/kis_layer_properties_icons.h
--- a/libs/image/kis_layer_properties_icons.h
+++ b/libs/image/kis_layer_properties_icons.h
@@ -40,13 +40,28 @@
static const KoID passThrough;
static const KoID selectionActive;
static const KoID colorLabelIndex;
+ static const KoID colorizeNeedsUpdate;
+ static const KoID colorizeEditKeyStrokes;
+ static const KoID colorizeShowColoring;
static KisLayerPropertiesIcons* instance();
static KisBaseNode::Property getProperty(const KoID &id, bool state);
static KisBaseNode::Property getProperty(const KoID &id, bool state,
bool isInStasis, bool stateInStasis);
+ /**
+ * Sets the specified property of the node and updates it
+ */
+ static void setNodeProperty(KisNodeSP node, const KoID &id, const QVariant &value, KisImageSP image);
+
+ static void setNodeProperty(KisBaseNode::PropertyList *props, const KoID &id, const QVariant &value);
+
+ /**
+ * Gets the specified property of the node
+ */
+ static QVariant nodeProperty(KisNodeSP node, const KoID &id, const QVariant &defaultValue);
+
private:
void updateIcons();
diff --git a/libs/image/kis_layer_properties_icons.cpp b/libs/image/kis_layer_properties_icons.cpp
--- a/libs/image/kis_layer_properties_icons.cpp
+++ b/libs/image/kis_layer_properties_icons.cpp
@@ -24,6 +24,9 @@
Q_GLOBAL_STATIC(KisLayerPropertiesIcons, s_instance)
#include
+#include
+#include
+#include "kis_image.h"
const KoID KisLayerPropertiesIcons::locked("locked", ki18n("Locked"));
@@ -35,6 +38,9 @@
const KoID KisLayerPropertiesIcons::passThrough("pass-through", ki18n("Pass Through"));
const KoID KisLayerPropertiesIcons::selectionActive("selection-active", ki18n("Active"));
const KoID KisLayerPropertiesIcons::colorLabelIndex("color-label", ki18n("Color Label"));
+const KoID KisLayerPropertiesIcons::colorizeNeedsUpdate("colorize-needs-update", ki18n("Update Result"));
+const KoID KisLayerPropertiesIcons::colorizeEditKeyStrokes("colorize-show-key-strokes", ki18n("Edit Key Strokes"));
+const KoID KisLayerPropertiesIcons::colorizeShowColoring("colorize-show-coloring", ki18n("Show Coloring"));
struct IconsPair {
@@ -80,6 +86,9 @@
m_d->icons.insert(onionSkins.id(), IconsPair(KisIconUtils::loadIcon("onionOn"), KisIconUtils::loadIcon("onionOff")));
m_d->icons.insert(passThrough.id(), IconsPair(KisIconUtils::loadIcon("passthrough-enabled"), KisIconUtils::loadIcon("passthrough-disabled")));
m_d->icons.insert(selectionActive.id(), IconsPair(KisIconUtils::loadIcon("local_selection_active"), KisIconUtils::loadIcon("local_selection_inactive")));
+ m_d->icons.insert(colorizeNeedsUpdate.id(), IconsPair(KisIconUtils::loadIcon("updateColorize"), KisIconUtils::loadIcon("updateColorize")));
+ m_d->icons.insert(colorizeEditKeyStrokes.id(), IconsPair(KisIconUtils::loadIcon("showMarks"), KisIconUtils::loadIcon("showMarksOff")));
+ m_d->icons.insert(colorizeShowColoring.id(), IconsPair(KisIconUtils::loadIcon("showColoring"), KisIconUtils::loadIcon("showColoringOff")));
}
KisBaseNode::Property KisLayerPropertiesIcons::getProperty(const KoID &id, bool state)
@@ -97,3 +106,37 @@
pair.on, pair.off, state,
isInStasis, stateInStasis);
}
+
+void KisLayerPropertiesIcons::setNodeProperty(KisNodeSP node, const KoID &id, const QVariant &value, KisImageSP image)
+{
+ KisBaseNode::PropertyList props = node->sectionModelProperties();
+ setNodeProperty(&props, id, value);
+ KisNodePropertyListCommand::setNodePropertiesNoUndo(node, image, props);
+}
+
+void KisLayerPropertiesIcons::setNodeProperty(KisBaseNode::PropertyList *props, const KoID &id, const QVariant &value)
+{
+ KisBaseNode::PropertyList::iterator it = props->begin();
+ KisBaseNode::PropertyList::iterator end = props->end();
+ for (; it != end; ++it) {
+ if (it->id == id.id()) {
+ it->state = value;
+ break;
+ }
+ }
+}
+
+QVariant KisLayerPropertiesIcons::nodeProperty(KisNodeSP node, const KoID &id, const QVariant &defaultValue)
+{
+ KisBaseNode::PropertyList props = node->sectionModelProperties();
+
+ KisBaseNode::PropertyList::const_iterator it = props.constBegin();
+ KisBaseNode::PropertyList::const_iterator end = props.constEnd();
+ for (; it != end; ++it) {
+ if (it->id == id.id()) {
+ return it->state;
+ }
+ }
+
+ return defaultValue;
+}
diff --git a/libs/image/kis_layer_utils.cpp b/libs/image/kis_layer_utils.cpp
--- a/libs/image/kis_layer_utils.cpp
+++ b/libs/image/kis_layer_utils.cpp
@@ -45,6 +45,9 @@
#include "kis_command_utils.h"
#include "kis_processing_applicator.h"
#include "commands_new/kis_change_projection_color_command.h"
+#include "kis_layer_properties_icons.h"
+#include "lazybrush/kis_colorize_mask.h"
+#include "commands/kis_node_property_list_command.h"
namespace KisLayerUtils {
@@ -144,6 +147,31 @@
MergeDownInfoBaseSP m_info;
};
+ struct DisableColorizeKeyStrokes : public KisCommandUtils::AggregateCommand {
+ DisableColorizeKeyStrokes(MergeDownInfoBaseSP info) : m_info(info) {}
+
+ void populateChildCommands() {
+ Q_FOREACH (KisNodeSP node, m_info->allSrcNodes()) {
+ recursiveApplyNodes(node,
+ [this] (KisNodeSP node) {
+ if (dynamic_cast(node.data()) &&
+ KisLayerPropertiesIcons::nodeProperty(node, KisLayerPropertiesIcons::colorizeEditKeyStrokes, true).toBool()) {
+
+ KisBaseNode::PropertyList props = node->sectionModelProperties();
+ KisLayerPropertiesIcons::setNodeProperty(&props,
+ KisLayerPropertiesIcons::colorizeEditKeyStrokes,
+ false);
+
+ addCommand(new KisNodePropertyListCommand(node, props));
+ }
+ });
+ }
+ }
+
+ private:
+ MergeDownInfoBaseSP m_info;
+ };
+
struct RefreshHiddenAreas : public KUndo2Command {
RefreshHiddenAreas(MergeDownInfoBaseSP info) : m_info(info) {}
@@ -675,6 +703,11 @@
if (layer->visible() && prevLayer->visible()) {
MergeDownInfoSP info(new MergeDownInfo(image, prevLayer, layer));
+ // disable key strokes on all colorize masks and wait until
+ // update is finished with a barrier
+ applicator.applyCommand(new DisableColorizeKeyStrokes(info));
+ applicator.applyCommand(new KUndo2Command(), KisStrokeJobData::BARRIER);
+
applicator.applyCommand(new KeepMergedNodesSelected(info, false));
applicator.applyCommand(new FillSelectionMasks(info));
applicator.applyCommand(new CreateMergedLayer(info), KisStrokeJobData::BARRIER);
@@ -959,6 +992,11 @@
if (mergedNodes.size() > 1 || invisibleNodes.isEmpty()) {
MergeMultipleInfoSP info(new MergeMultipleInfo(image, mergedNodes));
+ // disable key strokes on all colorize masks and wait until
+ // update is finished with a barrier
+ applicator.applyCommand(new DisableColorizeKeyStrokes(info));
+ applicator.applyCommand(new KUndo2Command(), KisStrokeJobData::BARRIER);
+
applicator.applyCommand(new KeepMergedNodesSelected(info, putAfter, false));
applicator.applyCommand(new FillSelectionMasks(info));
applicator.applyCommand(new CreateMergedLayerMultiple(info), KisStrokeJobData::BARRIER);
diff --git a/libs/image/kis_macro_based_undo_store.h b/libs/image/kis_macro_based_undo_store.h
new file mode 100644
--- /dev/null
+++ b/libs/image/kis_macro_based_undo_store.h
@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) 2016 Dmitry Kazakov
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+
+#ifndef __KIS_MACRO_BASED_UNDO_STORE_H
+#define __KIS_MACRO_BASED_UNDO_STORE_H
+
+#include
+#include "kis_undo_store.h"
+
+class KisSavedMacroCommand;
+
+
+/**
+ * This undo store is supposed to be stacked with a KisPostExecutionUndoAdapter.
+ *
+ * That chain looks like:
+ * KisPostExecutionUndoAdapter ->
+ * KisMacroBasedUndoStore ->
+ * KisSavedMacroCommand;
+ *
+ * So the store calls redo() on every command that is added via
+ * addCommand();
+ */
+class KisMacroBasedUndoStore : public KisUndoStore
+{
+public:
+ KisMacroBasedUndoStore(KisSavedMacroCommand *command);
+ ~KisMacroBasedUndoStore();
+
+ const KUndo2Command* presentCommand();
+ void undoLastCommand();
+ void addCommand(KUndo2Command *cmd);
+ void beginMacro(const KUndo2MagicString& macroName);
+ void endMacro();
+ void purgeRedoState();
+
+private:
+ struct Private;
+ const QScopedPointer m_d;
+};
+
+#endif /* __KIS_MACRO_BASED_UNDO_STORE_H */
diff --git a/libs/image/kis_macro_based_undo_store.cpp b/libs/image/kis_macro_based_undo_store.cpp
new file mode 100644
--- /dev/null
+++ b/libs/image/kis_macro_based_undo_store.cpp
@@ -0,0 +1,76 @@
+/*
+ * Copyright (c) 2016 Dmitry Kazakov
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+
+#include "kis_macro_based_undo_store.h"
+
+#include "kis_saved_commands.h"
+#include "kis_global.h"
+
+
+struct KisMacroBasedUndoStore::Private
+{
+ Private(KisSavedMacroCommand *_command) : command(_command) {}
+ KisSavedMacroCommand *command;
+};
+
+KisMacroBasedUndoStore::KisMacroBasedUndoStore(KisSavedMacroCommand *_command)
+ : m_d(new Private(_command))
+{
+}
+
+KisMacroBasedUndoStore::~KisMacroBasedUndoStore()
+{
+}
+
+const KUndo2Command* KisMacroBasedUndoStore::presentCommand()
+{
+ KIS_ASSERT(0 && "Not implemented");
+ return 0;
+}
+
+void KisMacroBasedUndoStore::undoLastCommand()
+{
+ KIS_ASSERT(0 && "Not implemented");
+}
+
+void KisMacroBasedUndoStore::addCommand(KUndo2Command *cmd)
+{
+ /**
+ * This store if stacked with a post-execution undo adapter,
+ * so we should call redo() explicitly when adding a command.
+ */
+ cmd->redo();
+ m_d->command->addCommand(toQShared(cmd));
+}
+
+void KisMacroBasedUndoStore::beginMacro(const KUndo2MagicString& macroName)
+{
+ Q_UNUSED(macroName);
+ KIS_ASSERT(0 && "Not implemented");
+}
+
+void KisMacroBasedUndoStore::endMacro()
+{
+ KIS_ASSERT(0 && "Not implemented");
+}
+
+void KisMacroBasedUndoStore::purgeRedoState()
+{
+ KIS_ASSERT(0 && "Not implemented");
+}
+
diff --git a/libs/image/kis_mask.h b/libs/image/kis_mask.h
--- a/libs/image/kis_mask.h
+++ b/libs/image/kis_mask.h
@@ -64,7 +64,7 @@
XXX: For now, all masks are 8 bit. Make the channel depth settable.
*/
-class KRITAIMAGE_EXPORT KisMask : public KisNode, KisIndirectPaintingSupport
+class KRITAIMAGE_EXPORT KisMask : public KisNode, public KisIndirectPaintingSupport
{
Q_OBJECT
diff --git a/libs/image/kis_mask.cc b/libs/image/kis_mask.cc
--- a/libs/image/kis_mask.cc
+++ b/libs/image/kis_mask.cc
@@ -27,6 +27,7 @@
#include
+#include
#include
#include
@@ -123,12 +124,11 @@
* Please think it over...
*/
- KisNodeSP parentNode = parent();
- if (!parentNode) return 0;
+ const KoColorSpace *colorSpace = this->colorSpace();
+ if (!colorSpace) return 0;
- if (!parentNode->colorSpace()) return 0;
- const KoCompositeOp* op = parentNode->colorSpace()->compositeOp(compositeOpId());
- return op ? op : parentNode->colorSpace()->compositeOp(COMPOSITE_OVER);
+ const KoCompositeOp* op = colorSpace->compositeOp(compositeOpId());
+ return op ? op : colorSpace->compositeOp(COMPOSITE_OVER);
}
void KisMask::initSelection(KisSelectionSP copyFrom, KisLayerSP parentLayer)
@@ -170,9 +170,7 @@
} else {
selection = new KisSelection(new KisSelectionDefaultBounds(parentPaintDevice, parentLayer->image()));
-
- quint8 newDefaultPixel = MAX_SELECTED;
- selection->pixelSelection()->setDefaultPixel(&newDefaultPixel);
+ selection->pixelSelection()->setDefaultPixel(KoColor(Qt::white, selection->pixelSelection()->colorSpace()));
if (deferredSelectionOffset) {
selection->setX(deferredSelectionOffset->x());
diff --git a/libs/image/kis_node_visitor.h b/libs/image/kis_node_visitor.h
--- a/libs/image/kis_node_visitor.h
+++ b/libs/image/kis_node_visitor.h
@@ -32,6 +32,8 @@
class KisSelectionMask;
class KisGeneratorLayer;
class KisTransformMask;
+class KisColorizeMask;
+
class KRITAIMAGE_EXPORT KisNodeVisitor
{
@@ -62,6 +64,8 @@
virtual bool visit(KisSelectionMask *mask) = 0;
+ virtual bool visit(KisColorizeMask *mask) = 0;
+
protected:
/**
diff --git a/libs/image/kis_onion_skin_compositor.cpp b/libs/image/kis_onion_skin_compositor.cpp
--- a/libs/image/kis_onion_skin_compositor.cpp
+++ b/libs/image/kis_onion_skin_compositor.cpp
@@ -52,7 +52,7 @@
{
KisPaintDeviceSP tintDevice = new KisPaintDevice(colorSpace);
KoColor color = KoColor(tintColor, colorSpace);
- tintDevice->setDefaultPixel(color.data());
+ tintDevice->setDefaultPixel(color);
return tintDevice;
}
diff --git a/libs/image/kis_paint_device.h b/libs/image/kis_paint_device.h
--- a/libs/image/kis_paint_device.h
+++ b/libs/image/kis_paint_device.h
@@ -248,6 +248,12 @@
QRegion region() const;
/**
+ * The slow version of region() that searches for exact bounds of
+ * each rectangle in the region
+ */
+ QRegion regionExact() const;
+
+ /**
* Cut the paint device down to the specified rect. If the crop
* area is bigger than the paint device, nothing will happen.
*/
@@ -280,14 +286,14 @@
* caller still owns the pointer and needs to delete it to avoid memory leaks.
* If frame ID is given, set default pixel for that frame. Otherwise use active frame.
*/
- void setDefaultPixel(const quint8 *defPixel);
+ void setDefaultPixel(const KoColor &defPixel);
/**
* Get a pointer to the default pixel.
* If the frame parameter is given, get the default pixel of
* specified frame. Otherwise use currently active frame.
*/
- const quint8 *defaultPixel() const;
+ KoColor defaultPixel() const;
/**
* Fill the given rectangle with the given pixel. The paint device will expand to
@@ -748,6 +754,13 @@
*/
void requestTimeSwitch(int time);
+ /**
+ * \return a sequence number corresponding to the current paint
+ * device state. Every time the paint device is changed,
+ * the sequence number is increased
+ */
+ int sequenceNumber() const;
+
public:
KisHLineIteratorSP createHLineIteratorNG(qint32 x, qint32 y, qint32 w);
diff --git a/libs/image/kis_paint_device.cc b/libs/image/kis_paint_device.cc
--- a/libs/image/kis_paint_device.cc
+++ b/libs/image/kis_paint_device.cc
@@ -66,6 +66,7 @@
#include "kis_transform_worker.h"
#include "kis_filter_strategy.h"
+#include "krita_utils.h"
struct KisPaintDeviceSPStaticRegistrar {
@@ -365,16 +366,19 @@
return data->dataManager()->write(store);
}
- void setFrameDefaultPixel(const quint8 *defPixel, int frameId)
+ void setFrameDefaultPixel(const KoColor &defPixel, int frameId)
{
DataSP data = m_frames[frameId];
- data->dataManager()->setDefaultPixel(defPixel);
+ KoColor color(defPixel);
+ color.convertTo(data->colorSpace());
+ data->dataManager()->setDefaultPixel(color.data());
}
- const quint8* frameDefaultPixel(int frameId) const
+ KoColor frameDefaultPixel(int frameId) const
{
- DataSP data = m_frames[frameId];
- return data->dataManager()->defaultPixel();
+ DataSP data = m_frames[frameId];
+ return KoColor(data->dataManager()->defaultPixel(),
+ data->colorSpace());
}
void fetchFrame(int frameId, KisPaintDeviceSP targetDevice);
@@ -464,7 +468,7 @@
{
currentData()->prepareClone(srcData);
- q->setDefaultPixel(srcData->dataManager()->defaultPixel());
+ q->setDefaultPixel(KoColor(srcData->dataManager()->defaultPixel(), colorSpace()));
q->setDefaultBounds(src->defaultBounds());
}
@@ -1024,6 +1028,11 @@
}
}
+int KisPaintDevice::sequenceNumber() const
+{
+ return m_d->cache()->sequenceNumber();
+}
+
void KisPaintDevice::setParentNode(KisNodeWSP parent)
{
m_d->parent = parent;
@@ -1265,7 +1274,7 @@
QRect startRect = extent();
QRect endRect;
- quint8 defaultOpacity = m_d->colorSpace()->opacityU8(defaultPixel());
+ quint8 defaultOpacity = defaultPixel().opacityU8();
if (defaultOpacity != OPACITY_TRANSPARENT_U8) {
if (!nonDefaultOnly) {
/**
@@ -1282,7 +1291,8 @@
}
if (nonDefaultOnly) {
- Impl::CheckNonDefault compareOp(pixelSize(), defaultPixel());
+ const KoColor defaultPixel = this->defaultPixel();
+ Impl::CheckNonDefault compareOp(pixelSize(), defaultPixel.data());
endRect = Impl::calculateExactBoundsImpl(this, startRect, endRect, compareOp);
} else {
Impl::CheckFullyTransparent compareOp(m_d->colorSpace());
@@ -1292,6 +1302,29 @@
return endRect;
}
+QRegion KisPaintDevice::regionExact() const
+{
+ QRegion resultRegion;
+ QVector rects = region().rects();
+
+ const KoColor defaultPixel = this->defaultPixel();
+ Impl::CheckNonDefault compareOp(pixelSize(), defaultPixel.data());
+
+ Q_FOREACH (const QRect &rc1, rects) {
+ const int patchSize = 64;
+ QVector smallerRects = KritaUtils::splitRectIntoPatches(rc1, QSize(patchSize, patchSize));
+ Q_FOREACH (const QRect &rc2, smallerRects) {
+
+ const QRect result =
+ Impl::calculateExactBoundsImpl(this, rc2, QRect(), compareOp);
+
+ if (!result.isEmpty()) {
+ resultRegion += result;
+ }
+ }
+ }
+ return resultRegion;
+}
void KisPaintDevice::crop(qint32 x, qint32 y, qint32 w, qint32 h)
{
@@ -1310,15 +1343,18 @@
dm->purge(dm->extent());
}
-void KisPaintDevice::setDefaultPixel(const quint8 *defPixel)
+void KisPaintDevice::setDefaultPixel(const KoColor &defPixel)
{
- m_d->dataManager()->setDefaultPixel(defPixel);
+ KoColor color(defPixel);
+ color.convertTo(colorSpace());
+
+ m_d->dataManager()->setDefaultPixel(color.data());
m_d->cache()->invalidate();
}
-const quint8 *KisPaintDevice::defaultPixel() const
+KoColor KisPaintDevice::defaultPixel() const
{
- return m_d->dataManager()->defaultPixel();
+ return KoColor(m_d->dataManager()->defaultPixel(), colorSpace());
}
void KisPaintDevice::clear()
@@ -1643,15 +1679,15 @@
KisHLineIteratorSP devIt = createHLineIteratorNG(r.x(), r.y(), r.width());
KisHLineConstIteratorSP selectionIt = selection->projection()->createHLineConstIteratorNG(r.x(), r.y(), r.width());
- const quint8* defaultPixel_ = defaultPixel();
- bool transparentDefault = (colorSpace->opacityU8(defaultPixel_) == OPACITY_TRANSPARENT_U8);
+ const KoColor defaultPixel = this->defaultPixel();
+ bool transparentDefault = (defaultPixel.opacityU8() == OPACITY_TRANSPARENT_U8);
for (qint32 y = 0; y < r.height(); y++) {
do {
// XXX: Optimize by using stretches
colorSpace->applyInverseAlphaU8Mask(devIt->rawData(), selectionIt->rawDataConst(), 1);
if (transparentDefault && colorSpace->opacityU8(devIt->rawData()) == OPACITY_TRANSPARENT_U8) {
- memcpy(devIt->rawData(), defaultPixel_, colorSpace->pixelSize());
+ memcpy(devIt->rawData(), defaultPixel.data(), colorSpace->pixelSize());
}
} while (devIt->nextPixel() && selectionIt->nextPixel());
devIt->nextRow();
@@ -1950,16 +1986,16 @@
return q->m_d->frameOffset(frameId);
}
-void KisPaintDeviceFramesInterface::setFrameDefaultPixel(const quint8 *defPixel, int frameId)
+void KisPaintDeviceFramesInterface::setFrameDefaultPixel(const KoColor &defPixel, int frameId)
{
KIS_ASSERT_RECOVER_RETURN(frameId >= 0);
q->m_d->setFrameDefaultPixel(defPixel, frameId);
}
-const quint8* KisPaintDeviceFramesInterface::frameDefaultPixel(int frameId) const
+KoColor KisPaintDeviceFramesInterface::frameDefaultPixel(int frameId) const
{
KIS_ASSERT_RECOVER(frameId >= 0) {
- return (quint8*)"deadbeef";
+ return KoColor(Qt::red, q->m_d->colorSpace());
}
return q->m_d->frameDefaultPixel(frameId);
}
diff --git a/libs/image/kis_paint_device_cache.h b/libs/image/kis_paint_device_cache.h
--- a/libs/image/kis_paint_device_cache.h
+++ b/libs/image/kis_paint_device_cache.h
@@ -30,15 +30,17 @@
: m_paintDevice(paintDevice),
m_exactBoundsCache(paintDevice),
m_nonDefaultPixelAreaCache(paintDevice),
- m_regionCache(paintDevice)
+ m_regionCache(paintDevice),
+ m_sequenceNumber(0)
{
}
KisPaintDeviceCache(const KisPaintDeviceCache &rhs)
: m_paintDevice(rhs.m_paintDevice),
m_exactBoundsCache(rhs.m_paintDevice),
m_nonDefaultPixelAreaCache(rhs.m_paintDevice),
- m_regionCache(rhs.m_paintDevice)
+ m_regionCache(rhs.m_paintDevice),
+ m_sequenceNumber(0)
{
}
@@ -51,6 +53,7 @@
m_exactBoundsCache.invalidate();
m_nonDefaultPixelAreaCache.invalidate();
m_regionCache.invalidate();
+ m_sequenceNumber++;
}
QRect exactBounds() {
@@ -102,6 +105,10 @@
return thumbnail;
}
+ int sequenceNumber() const {
+ return m_sequenceNumber;
+ }
+
private:
inline QImage findThumbnail(qint32 w, qint32 h, qreal oversample) {
QImage resultImage;
@@ -154,6 +161,7 @@
bool m_thumbnailsValid;
QMap > > m_thumbnails;
+ QAtomicInt m_sequenceNumber;
};
#endif /* __KIS_PAINT_DEVICE_CACHE_H */
diff --git a/libs/image/kis_paint_device_frames_interface.h b/libs/image/kis_paint_device_frames_interface.h
--- a/libs/image/kis_paint_device_frames_interface.h
+++ b/libs/image/kis_paint_device_frames_interface.h
@@ -86,12 +86,12 @@
/**
* Sets default pixel for \p frameId
*/
- void setFrameDefaultPixel(const quint8 *defPixel, int frameId);
+ void setFrameDefaultPixel(const KoColor &defPixel, int frameId);
/**
* @return default pixel for \p frameId
*/
- const quint8* frameDefaultPixel(int frameId) const;
+ KoColor frameDefaultPixel(int frameId) const;
/**
* Write a \p frameId onto \p store
diff --git a/libs/image/kis_paint_device_strategies.h b/libs/image/kis_paint_device_strategies.h
--- a/libs/image/kis_paint_device_strategies.h
+++ b/libs/image/kis_paint_device_strategies.h
@@ -52,8 +52,7 @@
y += m_d->y();
extent = QRect(x, y, w, h);
- quint8 defaultOpacity =
- m_device->colorSpace()->opacityU8(m_device->defaultPixel());
+ quint8 defaultOpacity = m_device->defaultPixel().opacityU8();
if (defaultOpacity != OPACITY_TRANSPARENT_U8)
extent |= m_d->defaultBounds->bounds();
diff --git a/libs/image/kis_painter.h b/libs/image/kis_painter.h
--- a/libs/image/kis_painter.h
+++ b/libs/image/kis_painter.h
@@ -103,6 +103,9 @@
const QRect &originalSrcRect,
KisSelectionSP selection);
+ static KisPaintDeviceSP convertToAlphaAsAlpha(KisPaintDeviceSP src);
+ static KisPaintDeviceSP convertToAlphaAsGray(KisPaintDeviceSP src);
+
/**
* Start painting on the specified device. Not undoable.
*/
diff --git a/libs/image/kis_painter.cc b/libs/image/kis_painter.cc
--- a/libs/image/kis_painter.cc
+++ b/libs/image/kis_painter.cc
@@ -65,9 +65,9 @@
#include "kis_perspective_math.h"
#include "tiles3/kis_random_accessor.h"
#include
+#include
#include "kis_lod_transform.h"
-
// Maximum distance from a Bezier control point to the line through the start
// and end points for the curve to be considered flat.
#define BEZIER_FLATNESS_THRESHOLD 0.5
@@ -266,6 +266,47 @@
}
}
+KisPaintDeviceSP KisPainter::convertToAlphaAsAlpha(KisPaintDeviceSP src)
+{
+ const KoColorSpace *srcCS = src->colorSpace();
+ const QRect processRect = src->extent();
+ KisPaintDeviceSP dst = new KisPaintDevice(KoColorSpaceRegistry::instance()->alpha8());
+
+ KisSequentialConstIterator srcIt(src, processRect);
+ KisSequentialIterator dstIt(dst, processRect);
+
+ do {
+ const quint8 *srcPtr = srcIt.rawDataConst();
+ quint8 *alpha8Ptr = dstIt.rawData();
+
+ const quint8 white = srcCS->intensity8(srcPtr);
+ const quint8 alpha = srcCS->opacityU8(srcPtr);
+
+ *alpha8Ptr = KoColorSpaceMaths::multiply(alpha, KoColorSpaceMathsTraits::unitValue - white);
+ } while (srcIt.nextPixel() && dstIt.nextPixel());
+
+ return dst;
+}
+
+KisPaintDeviceSP KisPainter::convertToAlphaAsGray(KisPaintDeviceSP src)
+{
+ const KoColorSpace *srcCS = src->colorSpace();
+ const QRect processRect = src->extent();
+ KisPaintDeviceSP dst = new KisPaintDevice(KoColorSpaceRegistry::instance()->alpha8());
+
+ KisSequentialConstIterator srcIt(src, processRect);
+ KisSequentialIterator dstIt(dst, processRect);
+
+ do {
+ const quint8 *srcPtr = srcIt.rawDataConst();
+ quint8 *alpha8Ptr = dstIt.rawData();
+
+ *alpha8Ptr = srcCS->intensity8(srcPtr);
+ } while (srcIt.nextPixel() && dstIt.nextPixel());
+
+ return dst;
+}
+
void KisPainter::begin(KisPaintDeviceSP device)
{
begin(device, d->selection);
diff --git a/libs/image/kis_pixel_selection.h b/libs/image/kis_pixel_selection.h
--- a/libs/image/kis_pixel_selection.h
+++ b/libs/image/kis_pixel_selection.h
@@ -81,6 +81,11 @@
void clear();
/**
+ * Copies alpha channel form the specified \p src device
+ */
+ void copyAlphaFrom(KisPaintDeviceSP src, const QRect &processRect);
+
+ /**
* Apply a selection to the selection using the specified selection mode
*/
void applySelection(KisPixelSelectionSP selection, SelectionAction action);
diff --git a/libs/image/kis_pixel_selection.cpp b/libs/image/kis_pixel_selection.cpp
--- a/libs/image/kis_pixel_selection.cpp
+++ b/libs/image/kis_pixel_selection.cpp
@@ -155,6 +155,25 @@
}
}
+void KisPixelSelection::copyAlphaFrom(KisPaintDeviceSP src, const QRect &processRect)
+{
+ const KoColorSpace *srcCS = src->colorSpace();
+
+ KisSequentialConstIterator srcIt(src, processRect);
+ KisSequentialIterator dstIt(this, processRect);
+
+ do {
+ const quint8 *srcPtr = srcIt.rawDataConst();
+ quint8 *alpha8Ptr = dstIt.rawData();
+
+ *alpha8Ptr = srcCS->opacityU8(srcPtr);
+ } while (srcIt.nextPixel() && dstIt.nextPixel());
+
+ m_d->outlineCacheValid = false;
+ m_d->outlineCache = QPainterPath();
+ m_d->invalidateThumbnailImage();
+}
+
void KisPixelSelection::addSelection(KisPixelSelectionSP selection)
{
QRect r = selection->selectedRect();
@@ -238,7 +257,7 @@
void KisPixelSelection::clear(const QRect & r)
{
- if (*defaultPixel() != MIN_SELECTED) {
+ if (*defaultPixel().data() != MIN_SELECTED) {
KisFillPainter painter(KisPaintDeviceSP(this));
const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
painter.fillRect(r, KoColor(Qt::white, cs), MIN_SELECTED);
@@ -258,8 +277,7 @@
void KisPixelSelection::clear()
{
- quint8 defPixel = MIN_SELECTED;
- setDefaultPixel(&defPixel);
+ setDefaultPixel(KoColor(Qt::transparent, colorSpace()));
KisPaintDevice::clear();
m_d->outlineCacheValid = true;
@@ -282,8 +300,8 @@
*(it.rawData()) = MAX_SELECTED - *(it.rawData());
} while (it.nextPixel());
}
- quint8 defPixel = MAX_SELECTED - *defaultPixel();
- setDefaultPixel(&defPixel);
+ quint8 defPixel = MAX_SELECTED - *defaultPixel().data();
+ setDefaultPixel(KoColor(&defPixel, colorSpace()));
if (m_d->outlineCacheValid) {
QPainterPath path;
@@ -320,7 +338,7 @@
bool KisPixelSelection::isTotallyUnselected(const QRect & r) const
{
- if (*defaultPixel() != MIN_SELECTED)
+ if (*defaultPixel().data() != MIN_SELECTED)
return false;
QRect sr = selectedExactRect();
return ! r.intersects(sr);
@@ -346,7 +364,7 @@
* value sane we should limit the calculated area by the bounds of
* the image.
*/
- if (*defaultPixel() != MIN_SELECTED) {
+ if (*defaultPixel().data() != MIN_SELECTED) {
selectionExtent &= defaultBounds()->bounds();
}
@@ -376,7 +394,7 @@
bool KisPixelSelection::isEmpty() const
{
- return *defaultPixel() == MIN_SELECTED && selectedRect().isEmpty();
+ return *defaultPixel().data() == MIN_SELECTED && selectedRect().isEmpty();
}
QPainterPath KisPixelSelection::outlineCache() const
diff --git a/libs/image/kis_post_execution_undo_adapter.h b/libs/image/kis_post_execution_undo_adapter.h
--- a/libs/image/kis_post_execution_undo_adapter.h
+++ b/libs/image/kis_post_execution_undo_adapter.h
@@ -46,9 +46,8 @@
KisSavedMacroCommand* createMacro(const KUndo2MagicString& macroName);
void addMacro(KisSavedMacroCommand *macro);
- inline void setUndoStore(KisUndoStore *undoStore) {
- m_undoStore = undoStore;
- }
+ void setUndoStore(KisUndoStore *undoStore);
+ KisStrokesFacade* strokesFacade() const;
private:
KisUndoStore *m_undoStore;
diff --git a/libs/image/kis_post_execution_undo_adapter.cpp b/libs/image/kis_post_execution_undo_adapter.cpp
--- a/libs/image/kis_post_execution_undo_adapter.cpp
+++ b/libs/image/kis_post_execution_undo_adapter.cpp
@@ -47,3 +47,13 @@
{
m_undoStore->addCommand(macro);
}
+
+void KisPostExecutionUndoAdapter::setUndoStore(KisUndoStore *undoStore)
+{
+ m_undoStore = undoStore;
+}
+
+KisStrokesFacade* KisPostExecutionUndoAdapter::strokesFacade() const
+{
+ return m_strokesFacade;
+}
diff --git a/libs/image/kis_processing_visitor.h b/libs/image/kis_processing_visitor.h
--- a/libs/image/kis_processing_visitor.h
+++ b/libs/image/kis_processing_visitor.h
@@ -38,6 +38,7 @@
class KisTransparencyMask;
class KisSelectionMask;
class KisGeneratorLayer;
+class KisColorizeMask;
/**
* A visitor that processes a single layer; it does not recurse into the
@@ -59,6 +60,7 @@
virtual void visit(KisFilterMask *mask, KisUndoAdapter *undoAdapter) = 0;
virtual void visit(KisTransformMask *mask, KisUndoAdapter *undoAdapter) = 0;
virtual void visit(KisTransparencyMask *mask, KisUndoAdapter *undoAdapter) = 0;
+ virtual void visit(KisColorizeMask *mask, KisUndoAdapter *undoAdapter) = 0;
virtual void visit(KisSelectionMask *mask, KisUndoAdapter *undoAdapter) = 0;
public:
diff --git a/libs/image/kis_selection_based_layer.cpp b/libs/image/kis_selection_based_layer.cpp
--- a/libs/image/kis_selection_based_layer.cpp
+++ b/libs/image/kis_selection_based_layer.cpp
@@ -85,8 +85,7 @@
void KisSelectionBasedLayer::initSelection()
{
m_d->selection = new KisSelection(new KisDefaultBounds(image()));
- quint8 newDefaultPixel = MAX_SELECTED;
- m_d->selection->pixelSelection()->setDefaultPixel(&newDefaultPixel);
+ m_d->selection->pixelSelection()->setDefaultPixel(KoColor(Qt::white, m_d->selection->pixelSelection()->colorSpace()));
m_d->selection->setParentNode(this);
m_d->selection->updateProjection();
}
diff --git a/libs/image/kis_transform_worker.cc b/libs/image/kis_transform_worker.cc
--- a/libs/image/kis_transform_worker.cc
+++ b/libs/image/kis_transform_worker.cc
@@ -478,7 +478,8 @@
KisRandomAccessorSP leftIt = dev->createRandomAccessorNG(mirrorRect.x(), mirrorRect.y());
KisRandomAccessorSP rightIt = dev->createRandomAccessorNG(mirrorRect.x(), mirrorRect.y());
- const quint8 *defaultPixel = dev->defaultPixel();
+ const KoColor defaultPixelObject = dev->defaultPixel();
+ const quint8 *defaultPixel = defaultPixelObject.data();
const int pixelSize = dev->pixelSize();
QByteArray buf(pixelSize, 0);
diff --git a/libs/image/kis_types.h b/libs/image/kis_types.h
--- a/libs/image/kis_types.h
+++ b/libs/image/kis_types.h
@@ -105,6 +105,10 @@
typedef KisSharedPtr KisTransparencyMaskSP;
typedef KisWeakSharedPtr KisTransparencyMaskWSP;
+class KisColorizeMask;
+typedef KisSharedPtr KisColorizeMaskSP;
+typedef KisWeakSharedPtr KisColorizeMaskWSP;
+
class KisLayer;
typedef KisSharedPtr KisLayerSP;
typedef KisWeakSharedPtr KisLayerWSP;
diff --git a/libs/image/krita_utils.h b/libs/image/krita_utils.h
--- a/libs/image/krita_utils.h
+++ b/libs/image/krita_utils.h
@@ -133,6 +133,11 @@
QImage KRITAIMAGE_EXPORT convertQImageToGrayA(const QImage &image);
QColor KRITAIMAGE_EXPORT blendColors(const QColor &c1, const QColor &c2, qreal r1);
+
+ void KRITAIMAGE_EXPORT applyToAlpha8Device(KisPaintDeviceSP dev, const QRect &rc, std::function func);
+ void KRITAIMAGE_EXPORT filterAlpha8Device(KisPaintDeviceSP dev, const QRect &rc, std::function func);
+
+ qreal KRITAIMAGE_EXPORT estimatePortionOfTransparentPixels(KisPaintDeviceSP dev, const QRect &rect, qreal samplePortion);
}
#endif /* __KRITA_UTILS_H */
diff --git a/libs/image/krita_utils.cpp b/libs/image/krita_utils.cpp
--- a/libs/image/krita_utils.cpp
+++ b/libs/image/krita_utils.cpp
@@ -38,6 +38,8 @@
#include "kis_image_config.h"
#include "kis_debug.h"
#include "kis_node.h"
+#include "kis_sequential_iterator.h"
+#include "kis_random_accessor_ng.h"
namespace KritaUtils
@@ -506,4 +508,48 @@
c1.greenF() * r1 + c2.greenF() * r2,
c1.blueF() * r1 + c2.blueF() * r2);
}
+
+ void applyToAlpha8Device(KisPaintDeviceSP dev, const QRect &rc, std::function func) {
+ KisSequentialConstIterator dstIt(dev, rc);
+ do {
+ const quint8 *dstPtr = dstIt.rawDataConst();
+ func(*dstPtr);
+ } while (dstIt.nextPixel());
+ }
+
+ void filterAlpha8Device(KisPaintDeviceSP dev, const QRect &rc, std::function func) {
+ KisSequentialIterator dstIt(dev, rc);
+ do {
+ quint8 *dstPtr = dstIt.rawData();
+ *dstPtr = func(*dstPtr);
+ } while (dstIt.nextPixel());
+ }
+
+ qreal estimatePortionOfTransparentPixels(KisPaintDeviceSP dev, const QRect &rect, qreal samplePortion) {
+ const KoColorSpace *cs = dev->colorSpace();
+
+ const qreal linearPortion = std::sqrt(samplePortion);
+ const qreal ratio = qreal(rect.width()) / rect.height();
+ const int xStep = qMax(1, qRound(1.0 / linearPortion * ratio));
+ const int yStep = qMax(1, qRound(1.0 / linearPortion / ratio));
+
+ int numTransparentPixels = 0;
+ int numPixels = 0;
+
+ KisRandomConstAccessorSP it = dev->createRandomConstAccessorNG(rect.x(), rect.y());
+ for (int y = rect.y(); y <= rect.bottom(); y += yStep) {
+ for (int x = rect.x(); x <= rect.right(); x += xStep) {
+ it->moveTo(x, y);
+ const quint8 alpha = cs->opacityU8(it->rawDataConst());
+
+ if (alpha != OPACITY_OPAQUE_U8) {
+ numTransparentPixels++;
+ }
+
+ numPixels++;
+ }
+ }
+
+ return qreal(numTransparentPixels) / numPixels;
+ }
}
diff --git a/libs/image/layerstyles/kis_ls_bevel_emboss_filter.cpp b/libs/image/layerstyles/kis_ls_bevel_emboss_filter.cpp
--- a/libs/image/layerstyles/kis_ls_bevel_emboss_filter.cpp
+++ b/libs/image/layerstyles/kis_ls_bevel_emboss_filter.cpp
@@ -80,7 +80,7 @@
quint8 selectedness = invert ?
qRound(qreal(size - i - 1) / size * 255.0) :
qRound(qreal(i + 1) / size * 255.0);
- fillDevice->setDefaultPixel(&selectedness);
+ fillDevice->setDefaultPixel(KoColor(&selectedness, fillDevice->colorSpace()));
tmpSelection->makeCloneFromRough(srcSelection, srcSelection->selectedRect());
@@ -421,7 +421,7 @@
const KoColor fillColor(config->shadowColor(), dstDevice->colorSpace());
const QRect &fillRect = d.shadowHighlightsFinalRect;
KisPaintDeviceSP fillDevice = new KisPaintDevice(dstDevice->colorSpace());
- fillDevice->setDefaultPixel(fillColor.data());
+ fillDevice->setDefaultPixel(fillColor);
KisPainter gc(dstDevice);
gc.setSelection(baseSelection);
@@ -444,7 +444,7 @@
const KoColor fillColor(config->highlightColor(), dstDevice->colorSpace());
const QRect &fillRect = d.shadowHighlightsFinalRect;
KisPaintDeviceSP fillDevice = new KisPaintDevice(dstDevice->colorSpace());
- fillDevice->setDefaultPixel(fillColor.data());
+ fillDevice->setDefaultPixel(fillColor);
KisPainter gc(dstDevice);
gc.setSelection(baseSelection);
gc.setCompositeOp(COMPOSITE_OVER);
diff --git a/libs/image/layerstyles/kis_ls_utils.cpp b/libs/image/layerstyles/kis_ls_utils.cpp
--- a/libs/image/layerstyles/kis_ls_utils.cpp
+++ b/libs/image/layerstyles/kis_ls_utils.cpp
@@ -419,7 +419,7 @@
{
if (config->fillType() == psd_fill_solid_color) {
KoColor color(config->color(), fillDevice->colorSpace());
- fillDevice->setDefaultPixel(color.data());
+ fillDevice->setDefaultPixel(color);
} else if (config->fillType() == psd_fill_pattern) {
fillPattern(fillDevice, applyRect, env,
diff --git a/libs/image/lazybrush/kis_colorize_mask.h b/libs/image/lazybrush/kis_colorize_mask.h
new file mode 100644
--- /dev/null
+++ b/libs/image/lazybrush/kis_colorize_mask.h
@@ -0,0 +1,140 @@
+/*
+ * Copyright (c) 2016 Dmitry Kazakov
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+
+#ifndef __KIS_COLORIZE_MASK_H
+#define __KIS_COLORIZE_MASK_H
+
+#include
+
+#include "kis_types.h"
+#include "kis_effect_mask.h"
+#include "kritaimage_export.h"
+
+class KoColor;
+class KUndo2Command;
+
+namespace KisLazyFillTools
+{
+ struct KeyStroke;
+}
+
+
+class KRITAIMAGE_EXPORT KisColorizeMask : public KisEffectMask
+{
+ Q_OBJECT
+public:
+ struct KeyStrokeColors {
+ QVector colors;
+ int transparentIndex;
+ };
+
+public:
+ KisColorizeMask();
+ ~KisColorizeMask();
+
+ KisColorizeMask(const KisColorizeMask& rhs);
+
+ void initializeCompositeOp();
+ const KoColorSpace* colorSpace() const;
+
+ // assign color profile without conversion of pixel data
+ void setProfile(const KoColorProfile *profile);
+
+ KUndo2Command* setColorSpace(const KoColorSpace * dstColorSpace,
+ KoColorConversionTransformation::Intent renderingIntent = KoColorConversionTransformation::internalRenderingIntent(),
+ KoColorConversionTransformation::ConversionFlags conversionFlags = KoColorConversionTransformation::internalConversionFlags());
+
+ KisPaintDeviceSP paintDevice() const;
+ KisPaintDeviceSP coloringProjection() const;
+
+ KisNodeSP clone() const {
+ return KisNodeSP(new KisColorizeMask(*this));
+ }
+
+ QIcon icon() const;
+
+ void setImage(KisImageWSP image);
+ bool accept(KisNodeVisitor &v);
+ void accept(KisProcessingVisitor &visitor, KisUndoAdapter *undoAdapter);
+
+ QRect decorateRect(KisPaintDeviceSP &src,
+ KisPaintDeviceSP &dst,
+ const QRect & rc,
+ PositionToFilthy maskPos) const;
+
+ void setCurrentColor(const KoColor &color);
+ void mergeToLayer(KisNodeSP layer, KisPostExecutionUndoAdapter *undoAdapter, const KUndo2MagicString &transactionText,int timedID);
+ void writeMergeData(KisPainter *painter, KisPaintDeviceSP src);
+
+ QRect exactBounds() const;
+ QRect extent() const;
+
+ void setSectionModelProperties(const KisBaseNode::PropertyList &properties);
+ KisBaseNode::PropertyList sectionModelProperties() const;
+
+ KeyStrokeColors keyStrokesColors() const;
+ void setKeyStrokesColors(KeyStrokeColors colors);
+
+ void removeKeyStroke(const KoColor &color);
+
+ QVector allPaintDevices() const;
+ void resetCache();
+
+ void testingAddKeyStroke(KisPaintDeviceSP dev, const KoColor &color, bool isTransparent = false);
+ void testingRegenerateMask();
+ KisPaintDeviceSP testingFilteredSource() const;
+
+ QList fetchKeyStrokesDirect() const;
+ void setKeyStrokesDirect(const QList &strokes);
+
+ qint32 x() const;
+ qint32 y() const;
+ void setX(qint32 x);
+ void setY(qint32 y);
+
+private Q_SLOTS:
+ void slotUpdateRegenerateFilling();
+ void slotRegenerationFinished();
+
+Q_SIGNALS:
+ void sigKeyStrokesListChanged();
+
+private:
+ // NOTE: please access this methods using model properties only!
+
+ bool needsUpdate() const;
+ void setNeedsUpdate(bool value);
+
+ bool showColoring() const;
+ void setShowColoring(bool value);
+
+ bool showKeyStrokes() const;
+ void setShowKeyStrokes(bool value);
+
+
+private:
+ void rerenderFakePaintDevice();
+ KisImageSP fetchImage() const;
+ void moveAllInternalDevices(const QPoint &diff);
+
+private:
+ struct Private;
+ const QScopedPointer m_d;
+};
+
+#endif /* __KIS_COLORIZE_MASK_H */
diff --git a/libs/image/lazybrush/kis_colorize_mask.cpp b/libs/image/lazybrush/kis_colorize_mask.cpp
new file mode 100644
--- /dev/null
+++ b/libs/image/lazybrush/kis_colorize_mask.cpp
@@ -0,0 +1,892 @@
+/*
+ * Copyright (c) 2016 Dmitry Kazakov
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+
+#include "kis_colorize_mask.h"
+
+#include
+
+#include
+#include "kis_pixel_selection.h"
+
+#include "kis_icon_utils.h"
+
+#include "kis_node_visitor.h"
+#include "kis_processing_visitor.h"
+#include "kis_painter.h"
+#include "kis_fill_painter.h"
+#include "kis_lazy_fill_tools.h"
+#include "kis_cached_paint_device.h"
+#include "kis_paint_device_debug_utils.h"
+#include "kis_layer_properties_icons.h"
+#include "kis_signal_compressor.h"
+
+#include "kis_colorize_stroke_strategy.h"
+#include "kis_multiway_cut.h"
+#include "kis_image.h"
+#include "kis_layer.h"
+#include "kis_macro_based_undo_store.h"
+#include "kis_post_execution_undo_adapter.h"
+#include "kis_command_utils.h"
+#include "kis_processing_applicator.h"
+#include "krita_utils.h"
+#include "kis_command_utils.h"
+
+
+using namespace KisLazyFillTools;
+
+struct KisColorizeMask::Private
+{
+ Private()
+ : needAddCurrentKeyStroke(false),
+ showKeyStrokes(true),
+ showColoring(true),
+ needsUpdate(true),
+ originalSequenceNumber(-1),
+ updateCompressor(1000, KisSignalCompressor::POSTPONE)
+ {
+ }
+
+ Private(const Private &rhs)
+ : coloringProjection(new KisPaintDevice(*rhs.coloringProjection)),
+ fakePaintDevice(new KisPaintDevice(*rhs.fakePaintDevice)),
+ needAddCurrentKeyStroke(rhs.needAddCurrentKeyStroke),
+ showKeyStrokes(rhs.showKeyStrokes),
+ showColoring(rhs.showColoring),
+ needsUpdate(false),
+ originalSequenceNumber(-1),
+ updateCompressor(1000, KisSignalCompressor::POSTPONE),
+ offset(rhs.offset)
+ {
+ Q_FOREACH (const KeyStroke &stroke, rhs.keyStrokes) {
+ keyStrokes << KeyStroke(new KisPaintDevice(*stroke.dev), stroke.color, stroke.isTransparent);
+ }
+ }
+
+ QList keyStrokes;
+ KisPaintDeviceSP coloringProjection;
+ KisPaintDeviceSP fakePaintDevice;
+ KisPaintDeviceSP filteredSource;
+
+ KoColor currentColor;
+ KisPaintDeviceSP currentKeyStrokeDevice;
+ bool needAddCurrentKeyStroke;
+
+ bool showKeyStrokes;
+ bool showColoring;
+
+ KisCachedSelection cachedSelection;
+ KisCachedSelection cachedConversionSelection;
+
+ bool needsUpdate;
+ int originalSequenceNumber;
+
+ KisSignalCompressor updateCompressor;
+ QPoint offset;
+};
+
+KisColorizeMask::KisColorizeMask()
+ : m_d(new Private)
+{
+ const KoColorSpace *colorSpace = KoColorSpaceRegistry::instance()->rgb8();
+ m_d->fakePaintDevice = new KisPaintDevice(colorSpace);
+ m_d->filteredSource = new KisPaintDevice(colorSpace);
+ m_d->coloringProjection = new KisPaintDevice(colorSpace);
+
+ connect(&m_d->updateCompressor,
+ SIGNAL(timeout()),
+ SLOT(slotUpdateRegenerateFilling()));
+
+ m_d->updateCompressor.moveToThread(qApp->thread());
+}
+
+KisColorizeMask::~KisColorizeMask()
+{
+}
+
+KisColorizeMask::KisColorizeMask(const KisColorizeMask& rhs)
+ : KisEffectMask(rhs),
+ m_d(new Private(*rhs.m_d))
+{
+ connect(&m_d->updateCompressor,
+ SIGNAL(timeout()),
+ SLOT(slotUpdateRegenerateFilling()));
+
+ m_d->updateCompressor.moveToThread(qApp->thread());
+}
+
+void KisColorizeMask::initializeCompositeOp()
+{
+ KisLayerSP parentLayer = dynamic_cast(parent().data());
+ if (!parentLayer || !parentLayer->original()) return;
+
+ KisImageSP image = parentLayer->image();
+ if (!image) return;
+
+ const qreal samplePortion = 0.1;
+ const qreal alphaPortion =
+ KritaUtils::estimatePortionOfTransparentPixels(parentLayer->original(),
+ image->bounds(),
+ samplePortion);
+
+ setCompositeOpId(alphaPortion > 0.3 ? COMPOSITE_BEHIND : COMPOSITE_MULT);
+}
+
+const KoColorSpace* KisColorizeMask::colorSpace() const
+{
+ return m_d->fakePaintDevice->colorSpace();
+}
+
+struct SetKeyStrokesColorSpaceCommand : public KUndo2Command {
+ SetKeyStrokesColorSpaceCommand(const KoColorSpace *dstCS,
+ KoColorConversionTransformation::Intent renderingIntent,
+ KoColorConversionTransformation::ConversionFlags conversionFlags,
+ QList *list,
+ KisColorizeMaskSP node)
+ : m_dstCS(dstCS),
+ m_renderingIntent(renderingIntent),
+ m_conversionFlags(conversionFlags),
+ m_list(list),
+ m_node(node) {}
+
+ void undo() {
+ KIS_ASSERT_RECOVER_RETURN(m_list->size() == m_oldColors.size());
+
+ for (int i = 0; i < m_list->size(); i++) {
+ (*m_list)[i].color = m_oldColors[i];
+ }
+ }
+
+ void redo() {
+ if (m_oldColors.isEmpty()) {
+ Q_FOREACH(const KeyStroke &stroke, *m_list) {
+ m_oldColors << stroke.color;
+ m_newColors << stroke.color;
+ m_newColors.last().convertTo(m_dstCS, m_renderingIntent, m_conversionFlags);
+ }
+ }
+
+ KIS_ASSERT_RECOVER_RETURN(m_list->size() == m_newColors.size());
+
+ for (int i = 0; i < m_list->size(); i++) {
+ (*m_list)[i].color = m_newColors[i];
+ }
+ }
+
+private:
+ QVector m_oldColors;
+ QVector m_newColors;
+
+ const KoColorSpace *m_dstCS;
+ KoColorConversionTransformation::Intent m_renderingIntent;
+ KoColorConversionTransformation::ConversionFlags m_conversionFlags;
+ QList *m_list;
+ KisColorizeMaskSP m_node;
+};
+
+
+void KisColorizeMask::setProfile(const KoColorProfile *profile)
+{
+ // WARNING: there is no undo information, used only while loading!
+
+ m_d->fakePaintDevice->setProfile(profile);
+ m_d->coloringProjection->setProfile(profile);
+
+ for (auto stroke : m_d->keyStrokes) {
+ stroke.color.setProfile(profile);
+ }
+}
+
+KUndo2Command* KisColorizeMask::setColorSpace(const KoColorSpace * dstColorSpace,
+ KoColorConversionTransformation::Intent renderingIntent,
+ KoColorConversionTransformation::ConversionFlags conversionFlags)
+{
+ using namespace KisCommandUtils;
+
+ CompositeCommand *composite = new CompositeCommand();
+
+ composite->addCommand(m_d->fakePaintDevice->convertTo(dstColorSpace, renderingIntent, conversionFlags));
+ composite->addCommand(m_d->coloringProjection->convertTo(dstColorSpace, renderingIntent, conversionFlags));
+
+ KUndo2Command *strokesConversionCommand =
+ new SetKeyStrokesColorSpaceCommand(
+ dstColorSpace, renderingIntent, conversionFlags,
+ &m_d->keyStrokes, this);
+ strokesConversionCommand->redo();
+
+ composite->addCommand(new SkipFirstRedoWrapper(strokesConversionCommand));
+
+ return composite;
+}
+
+bool KisColorizeMask::needsUpdate() const
+{
+ return m_d->needsUpdate;
+}
+
+void KisColorizeMask::setNeedsUpdate(bool value)
+{
+ if (value != m_d->needsUpdate) {
+ m_d->needsUpdate = value;
+ baseNodeChangedCallback();
+
+ if (!value) {
+ m_d->updateCompressor.start();
+ }
+ }
+}
+
+void KisColorizeMask::slotUpdateRegenerateFilling()
+{
+ KisPaintDeviceSP src = parent()->original();
+ KIS_ASSERT_RECOVER_RETURN(src);
+
+ bool filteredSourceValid = m_d->originalSequenceNumber == src->sequenceNumber();
+ m_d->originalSequenceNumber = src->sequenceNumber();
+ m_d->coloringProjection->clear();
+
+ KisLayerSP parentLayer = dynamic_cast(parent().data());
+ if (!parentLayer) return;
+
+ KisImageSP image = parentLayer->image();
+ if (image) {
+ KisColorizeStrokeStrategy *strategy =
+ new KisColorizeStrokeStrategy(src,
+ m_d->coloringProjection,
+ m_d->filteredSource,
+ filteredSourceValid,
+ image->bounds());
+
+ Q_FOREACH (const KeyStroke &stroke, m_d->keyStrokes) {
+ const KoColor color =
+ !stroke.isTransparent ?
+ stroke.color :
+ KoColor(Qt::transparent, stroke.color.colorSpace());
+
+ strategy->addKeyStroke(stroke.dev, color);
+ }
+
+ connect(strategy, SIGNAL(sigFinished()), SLOT(slotRegenerationFinished()));
+ KisStrokeId id = image->startStroke(strategy);
+ image->endStroke(id);
+ }
+}
+
+void KisColorizeMask::slotRegenerationFinished()
+{
+ setNeedsUpdate(true);
+ setDirty();
+}
+
+KisBaseNode::PropertyList KisColorizeMask::sectionModelProperties() const
+{
+ KisBaseNode::PropertyList l = KisMask::sectionModelProperties();
+ l << KisLayerPropertiesIcons::getProperty(KisLayerPropertiesIcons::colorizeNeedsUpdate, needsUpdate());
+ l << KisLayerPropertiesIcons::getProperty(KisLayerPropertiesIcons::colorizeEditKeyStrokes, showKeyStrokes());
+ l << KisLayerPropertiesIcons::getProperty(KisLayerPropertiesIcons::colorizeShowColoring, showColoring());
+
+ return l;
+}
+
+void KisColorizeMask::setSectionModelProperties(const KisBaseNode::PropertyList &properties)
+{
+ KisMask::setSectionModelProperties(properties);
+
+ Q_FOREACH (const KisBaseNode::Property &property, properties) {
+ if (property.id == KisLayerPropertiesIcons::colorizeNeedsUpdate.id()) {
+ if (m_d->needsUpdate != property.state.toBool()) {
+ setNeedsUpdate(property.state.toBool());
+ }
+ }
+ if (property.id == KisLayerPropertiesIcons::colorizeEditKeyStrokes.id()) {
+ if (m_d->showKeyStrokes != property.state.toBool()) {
+ setShowKeyStrokes(property.state.toBool());
+ }
+ }
+ if (property.id == KisLayerPropertiesIcons::colorizeShowColoring.id()) {
+ if (m_d->showColoring != property.state.toBool()) {
+ setShowColoring(property.state.toBool());
+ }
+ }
+ }
+}
+
+KisPaintDeviceSP KisColorizeMask::paintDevice() const
+{
+ return m_d->showKeyStrokes ? m_d->fakePaintDevice : 0;
+}
+
+KisPaintDeviceSP KisColorizeMask::coloringProjection() const
+{
+ return m_d->coloringProjection;
+}
+
+QIcon KisColorizeMask::icon() const
+{
+ return KisIconUtils::loadIcon("filterMask");
+}
+
+
+bool KisColorizeMask::accept(KisNodeVisitor &v)
+{
+ return v.visit(this);
+}
+
+void KisColorizeMask::accept(KisProcessingVisitor &visitor, KisUndoAdapter *undoAdapter)
+{
+ return visitor.visit(this, undoAdapter);
+}
+
+QRect KisColorizeMask::decorateRect(KisPaintDeviceSP &src,
+ KisPaintDeviceSP &dst,
+ const QRect &rect,
+ PositionToFilthy maskPos) const
+{
+ Q_UNUSED(maskPos);
+
+ KIS_ASSERT(dst != src);
+
+ // Draw the filling and the original layer
+ {
+ KisPainter gc(dst);
+
+ if (m_d->showKeyStrokes &&
+ m_d->filteredSource &&
+ !m_d->filteredSource->extent().isEmpty()) {
+
+ // TODO: the filtered source should be converted back into alpha!
+ gc.setOpacity(128);
+ gc.bitBlt(rect.topLeft(), m_d->filteredSource, rect);
+ } else {
+ gc.setOpacity(255);
+ gc.bitBlt(rect.topLeft(), src, rect);
+ }
+
+ if (m_d->showColoring && m_d->coloringProjection) {
+ gc.setOpacity(opacity());
+ gc.setCompositeOp(compositeOpId());
+ gc.bitBlt(rect.topLeft(), m_d->coloringProjection, rect);
+ }
+ }
+
+ // Draw the key strokes
+ if (m_d->showKeyStrokes) {
+ lockTemporaryTarget();
+
+ KisSelectionSP selection = m_d->cachedSelection.getSelection();
+ KisSelectionSP conversionSelection = m_d->cachedConversionSelection.getSelection();
+ KisPixelSelectionSP tempSelection = conversionSelection->pixelSelection();
+
+ KisPaintDeviceSP temporaryTarget = this->temporaryTarget();
+ const bool isTemporaryTargetErasing = temporaryCompositeOp() == COMPOSITE_ERASE;
+ const QRect temporaryExtent = temporaryTarget ? temporaryTarget->extent() : QRect();
+
+
+ KisFillPainter gc(dst);
+
+ QList extendedStrokes = m_d->keyStrokes;
+
+ if (m_d->currentKeyStrokeDevice &&
+ m_d->needAddCurrentKeyStroke &&
+ !isTemporaryTargetErasing) {
+
+ extendedStrokes << KeyStroke(m_d->currentKeyStrokeDevice, m_d->currentColor);
+ }
+
+ Q_FOREACH (const KeyStroke &stroke, extendedStrokes) {
+ selection->pixelSelection()->makeCloneFromRough(stroke.dev, rect);
+ gc.setSelection(selection);
+
+ if (stroke.color == m_d->currentColor ||
+ (isTemporaryTargetErasing &&
+ temporaryExtent.intersects(selection->pixelSelection()->selectedRect()))) {
+
+ if (temporaryTarget) {
+ tempSelection->copyAlphaFrom(temporaryTarget, rect);
+
+ KisPainter selectionPainter(selection->pixelSelection());
+ setupTemporaryPainter(&selectionPainter);
+ selectionPainter.bitBlt(rect.topLeft(), tempSelection, rect);
+ }
+ }
+
+ gc.fillSelection(rect, stroke.color);
+ }
+
+ m_d->cachedSelection.putSelection(selection);
+ m_d->cachedSelection.putSelection(conversionSelection);
+
+ unlockTemporaryTarget();
+ }
+
+ return rect;
+}
+
+QRect KisColorizeMask::extent() const
+{
+ QRect rc;
+
+ // TODO: take care about the filtered device, which can be painted
+ // semi-transparent sometimes
+
+ if (m_d->showColoring && m_d->coloringProjection) {
+ rc |= m_d->coloringProjection->extent();
+ }
+
+ if (m_d->showKeyStrokes) {
+ Q_FOREACH (const KeyStroke &stroke, m_d->keyStrokes) {
+ rc |= stroke.dev->extent();
+ }
+
+ lockTemporaryTarget();
+ KisPaintDeviceSP temporaryTarget = this->temporaryTarget();
+ if (temporaryTarget) {
+ rc |= temporaryTarget->extent();
+ }
+ unlockTemporaryTarget();
+ }
+
+ return rc;
+}
+
+QRect KisColorizeMask::exactBounds() const
+{
+ QRect rc;
+
+ if (m_d->showColoring && m_d->coloringProjection) {
+ rc |= m_d->coloringProjection->exactBounds();
+ }
+
+ if (m_d->showKeyStrokes) {
+ Q_FOREACH (const KeyStroke &stroke, m_d->keyStrokes) {
+ rc |= stroke.dev->exactBounds();
+ }
+
+ lockTemporaryTarget();
+ KisPaintDeviceSP temporaryTarget = this->temporaryTarget();
+ if (temporaryTarget) {
+ rc |= temporaryTarget->exactBounds();
+ }
+ unlockTemporaryTarget();
+ }
+
+ return rc;
+
+}
+
+KisImageSP KisColorizeMask::fetchImage() const
+{
+ KisLayerSP parentLayer = dynamic_cast(parent().data());
+ if (!parentLayer) return 0;
+
+ return parentLayer->image();
+}
+
+void KisColorizeMask::setImage(KisImageWSP image)
+{
+ auto it = m_d->keyStrokes.begin();
+ for(; it != m_d->keyStrokes.end(); ++it) {
+ it->dev->setDefaultBounds(new KisDefaultBounds(image));
+ }
+}
+
+void KisColorizeMask::setCurrentColor(const KoColor &_color)
+{
+ KoColor color = _color;
+ color.convertTo(colorSpace());
+
+ lockTemporaryTargetForWrite();
+
+ setNeedsUpdate(true);
+
+ QList::const_iterator it =
+ std::find_if(m_d->keyStrokes.constBegin(),
+ m_d->keyStrokes.constEnd(),
+ [color] (const KeyStroke &s) {
+ return s.color == color;
+ });
+
+ KisPaintDeviceSP activeDevice;
+ bool newKeyStroke = false;
+
+ if (it == m_d->keyStrokes.constEnd()) {
+ activeDevice = new KisPaintDevice(KoColorSpaceRegistry::instance()->alpha8());
+ activeDevice->setParentNode(this);
+ activeDevice->setDefaultBounds(new KisDefaultBounds(fetchImage()));
+ newKeyStroke = true;
+ } else {
+ activeDevice = it->dev;
+ }
+
+ m_d->currentColor = color;
+ m_d->currentKeyStrokeDevice = activeDevice;
+ m_d->needAddCurrentKeyStroke = newKeyStroke;
+
+ unlockTemporaryTarget();
+}
+
+
+
+struct KeyStrokeAddRemoveCommand : public KisCommandUtils::FlipFlopCommand {
+ KeyStrokeAddRemoveCommand(bool add, int index, KeyStroke stroke, QList *list, KisColorizeMaskSP node)
+ : FlipFlopCommand(!add),
+ m_index(index), m_stroke(stroke),
+ m_list(list), m_node(node) {}
+
+ void init() {
+ m_list->insert(m_index, m_stroke);
+ emit m_node->sigKeyStrokesListChanged();
+ }
+
+ void end() {
+ KIS_ASSERT_RECOVER_RETURN((*m_list)[m_index] == m_stroke);
+ m_list->removeAt(m_index);
+ emit m_node->sigKeyStrokesListChanged();
+ }
+
+private:
+ int m_index;
+ KeyStroke m_stroke;
+ QList *m_list;
+ KisColorizeMaskSP m_node;
+};
+
+void KisColorizeMask::mergeToLayer(KisNodeSP layer, KisPostExecutionUndoAdapter *undoAdapter, const KUndo2MagicString &transactionText,int timedID)
+{
+ Q_UNUSED(layer);
+
+ KisPaintDeviceSP temporaryTarget = this->temporaryTarget();
+ const bool isTemporaryTargetErasing = temporaryCompositeOp() == COMPOSITE_ERASE;
+ const QRect temporaryExtent = temporaryTarget ? temporaryTarget->extent() : QRect();
+
+ KisSavedMacroCommand *macro = undoAdapter->createMacro(transactionText);
+ KisMacroBasedUndoStore store(macro);
+ KisPostExecutionUndoAdapter fakeUndoAdapter(&store, undoAdapter->strokesFacade());
+
+ /**
+ * Add a new key stroke plane
+ */
+ if (m_d->needAddCurrentKeyStroke && !isTemporaryTargetErasing) {
+ KeyStroke key(m_d->currentKeyStrokeDevice, m_d->currentColor);
+
+ KUndo2Command *cmd =
+ new KeyStrokeAddRemoveCommand(
+ true, m_d->keyStrokes.size(), key, &m_d->keyStrokes, this);
+ cmd->redo();
+ fakeUndoAdapter.addCommand(toQShared(cmd));
+ }
+
+ /**
+ * When erasing, the brush affects all the key strokes, not only
+ * the current one.
+ */
+ if (!isTemporaryTargetErasing) {
+ mergeToLayerImpl(m_d->currentKeyStrokeDevice, &fakeUndoAdapter, transactionText, timedID, false);
+ } else {
+ Q_FOREACH (const KeyStroke &stroke, m_d->keyStrokes) {
+ if (temporaryExtent.intersects(stroke.dev->extent())) {
+ mergeToLayerImpl(stroke.dev, &fakeUndoAdapter, transactionText, timedID, false);
+ }
+ }
+ }
+
+ mergeToLayerImpl(m_d->fakePaintDevice, &fakeUndoAdapter, transactionText, timedID, false);
+
+ m_d->currentKeyStrokeDevice = 0;
+ m_d->currentColor = KoColor();
+ releaseResources();
+
+ /**
+ * Try removing the key strokes that has been completely erased
+ */
+ if (isTemporaryTargetErasing) {
+ lockTemporaryTargetForWrite();
+
+ for (int index = 0; index < m_d->keyStrokes.size(); /*noop*/) {
+ const KeyStroke &stroke = m_d->keyStrokes[index];
+
+ if (stroke.dev->exactBounds().isEmpty()) {
+ KUndo2Command *cmd =
+ new KeyStrokeAddRemoveCommand(
+ false, index, stroke, &m_d->keyStrokes, this);
+
+ cmd->redo();
+ fakeUndoAdapter.addCommand(toQShared(cmd));
+
+ } else {
+ index++;
+ }
+ }
+
+ unlockTemporaryTarget();
+ }
+
+ undoAdapter->addMacro(macro);
+}
+
+void KisColorizeMask::writeMergeData(KisPainter *painter, KisPaintDeviceSP src)
+{
+ const KoColorSpace *alpha8 = KoColorSpaceRegistry::instance()->alpha8();
+ const bool nonAlphaDst = !(*painter->device()->colorSpace() == *alpha8);
+
+ if (nonAlphaDst) {
+ Q_FOREACH (const QRect &rc, src->region().rects()) {
+ painter->bitBlt(rc.topLeft(), src, rc);
+ }
+ } else {
+ KisSelectionSP conversionSelection = m_d->cachedConversionSelection.getSelection();
+ KisPixelSelectionSP tempSelection = conversionSelection->pixelSelection();
+
+ Q_FOREACH (const QRect &rc, src->region().rects()) {
+ tempSelection->copyAlphaFrom(src, rc);
+ painter->bitBlt(rc.topLeft(), tempSelection, rc);
+ }
+ m_d->cachedSelection.putSelection(conversionSelection);
+ }
+}
+
+bool KisColorizeMask::showColoring() const
+{
+ return m_d->showColoring;
+}
+
+void KisColorizeMask::setShowColoring(bool value)
+{
+ QRect savedExtent;
+ if (m_d->showColoring && !value) {
+ savedExtent = extent();
+ }
+
+ m_d->showColoring = value;
+
+ if (!savedExtent.isEmpty()) {
+ setDirty(savedExtent);
+ }
+}
+
+bool KisColorizeMask::showKeyStrokes() const
+{
+ return m_d->showKeyStrokes;
+}
+
+void KisColorizeMask::setShowKeyStrokes(bool value)
+{
+ QRect savedExtent;
+ if (m_d->showKeyStrokes && !value) {
+ savedExtent = extent();
+ }
+
+ m_d->showKeyStrokes = value;
+
+ if (!savedExtent.isEmpty()) {
+ setDirty(savedExtent);
+ }
+}
+
+KisColorizeMask::KeyStrokeColors KisColorizeMask::keyStrokesColors() const
+{
+ KeyStrokeColors colors;
+
+ // TODO: thread safety!
+ for (int i = 0; i < m_d->keyStrokes.size(); i++) {
+ colors.colors << m_d->keyStrokes[i].color;
+
+ if (m_d->keyStrokes[i].isTransparent) {
+ colors.transparentIndex = i;
+ }
+ }
+
+ return colors;
+}
+
+struct SetKeyStrokeColorsCommand : public KUndo2Command {
+ SetKeyStrokeColorsCommand(const QList newList, QList *list, KisColorizeMaskSP node)
+ : m_newList(newList),
+ m_oldList(*list),
+ m_list(list),
+ m_node(node) {}
+
+ void redo() {
+ *m_list = m_newList;
+
+ emit m_node->sigKeyStrokesListChanged();
+ m_node->setDirty();
+ }
+
+ void undo() {
+ *m_list = m_oldList;
+
+ emit m_node->sigKeyStrokesListChanged();
+ m_node->setDirty();
+ }
+
+private:
+ QList m_newList;
+ QList m_oldList;
+ QList *m_list;
+ KisColorizeMaskSP m_node;
+};
+
+void KisColorizeMask::setKeyStrokesColors(KeyStrokeColors colors)
+{
+ KIS_ASSERT_RECOVER_RETURN(colors.colors.size() == m_d->keyStrokes.size());
+
+ QList newList = m_d->keyStrokes;
+
+ for (int i = 0; i < newList.size(); i++) {
+ newList[i].color = colors.colors[i];
+ newList[i].color.convertTo(colorSpace());
+ newList[i].isTransparent = colors.transparentIndex == i;
+ }
+
+ KisProcessingApplicator applicator(fetchImage(), this,
+ KisProcessingApplicator::NONE,
+ KisImageSignalVector(),
+ kundo2_i18n("Change Key Stroke Color"));
+ applicator.applyCommand(
+ new SetKeyStrokeColorsCommand(
+ newList, &m_d->keyStrokes, this));
+
+ applicator.end();
+}
+
+void KisColorizeMask::removeKeyStroke(const KoColor &_color)
+{
+ KoColor color = _color;
+ color.convertTo(colorSpace());
+
+ QList::iterator it =
+ std::find_if(m_d->keyStrokes.begin(),
+ m_d->keyStrokes.end(),
+ [color] (const KeyStroke &s) {
+ return s.color == color;
+ });
+
+ KIS_SAFE_ASSERT_RECOVER_RETURN(it != m_d->keyStrokes.end());
+
+ const int index = it - m_d->keyStrokes.begin();
+
+ KisProcessingApplicator applicator(fetchImage(), this,
+ KisProcessingApplicator::NONE,
+ KisImageSignalVector(),
+ kundo2_i18n("Remove Key Stroke"));
+ applicator.applyCommand(
+ new KeyStrokeAddRemoveCommand(
+ false, index, *it, &m_d->keyStrokes, this));
+
+ applicator.end();
+}
+
+
+QVector KisColorizeMask::allPaintDevices() const
+{
+ QVector devices;
+
+ Q_FOREACH (const KeyStroke &stroke, m_d->keyStrokes) {
+ devices << stroke.dev;
+ }
+
+ devices << m_d->coloringProjection;
+ devices << m_d->fakePaintDevice;
+
+ return devices;
+}
+
+void KisColorizeMask::resetCache()
+{
+ m_d->filteredSource->clear();
+ m_d->originalSequenceNumber = -1;
+
+ rerenderFakePaintDevice();
+}
+
+
+void KisColorizeMask::rerenderFakePaintDevice()
+{
+ m_d->fakePaintDevice->clear();
+ KisFillPainter gc(m_d->fakePaintDevice);
+
+ KisSelectionSP selection = m_d->cachedSelection.getSelection();
+
+ Q_FOREACH (const KeyStroke &stroke, m_d->keyStrokes) {
+ const QRect rect = stroke.dev->extent();
+
+ selection->pixelSelection()->makeCloneFromRough(stroke.dev, rect);
+ gc.setSelection(selection);
+ gc.fillSelection(rect, stroke.color);
+ }
+
+ m_d->cachedSelection.putSelection(selection);
+}
+
+void KisColorizeMask::testingAddKeyStroke(KisPaintDeviceSP dev, const KoColor &color, bool isTransparent)
+{
+ m_d->keyStrokes << KeyStroke(dev, color, isTransparent);
+}
+
+void KisColorizeMask::testingRegenerateMask()
+{
+ slotUpdateRegenerateFilling();
+}
+
+KisPaintDeviceSP KisColorizeMask::testingFilteredSource() const
+{
+ return m_d->filteredSource;
+}
+
+QList KisColorizeMask::fetchKeyStrokesDirect() const
+{
+ return m_d->keyStrokes;
+}
+
+void KisColorizeMask::setKeyStrokesDirect(const QList &strokes)
+{
+ m_d->keyStrokes = strokes;
+}
+
+qint32 KisColorizeMask::x() const
+{
+ return m_d->offset.x();
+}
+
+qint32 KisColorizeMask::y() const
+{
+ return m_d->offset.y();
+}
+
+void KisColorizeMask::setX(qint32 x)
+{
+ const QPoint oldOffset = m_d->offset;
+ m_d->offset.rx() = x;
+ moveAllInternalDevices(m_d->offset - oldOffset);
+}
+
+void KisColorizeMask::setY(qint32 y)
+{
+ const QPoint oldOffset = m_d->offset;
+ m_d->offset.ry() = y;
+ moveAllInternalDevices(m_d->offset - oldOffset);
+}
+
+void KisColorizeMask::moveAllInternalDevices(const QPoint &diff)
+{
+ QVector devices = allPaintDevices();
+
+ Q_FOREACH (KisPaintDeviceSP dev, devices) {
+ dev->moveTo(dev->offset() + diff);
+ }
+}
diff --git a/libs/image/lazybrush/kis_colorize_stroke_strategy.h b/libs/image/lazybrush/kis_colorize_stroke_strategy.h
new file mode 100644
--- /dev/null
+++ b/libs/image/lazybrush/kis_colorize_stroke_strategy.h
@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) 2016 Dmitry Kazakov
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+
+#ifndef __KIS_COLORIZE_STROKE_STRATEGY_H
+#define __KIS_COLORIZE_STROKE_STRATEGY_H
+
+#include
+#include
+
+#include "kis_types.h"
+#include
+
+class KoColor;
+
+
+class KisColorizeStrokeStrategy : public QObject, public KisSimpleStrokeStrategy
+{
+ Q_OBJECT
+
+public:
+ KisColorizeStrokeStrategy(KisPaintDeviceSP src,
+ KisPaintDeviceSP dst,
+ KisPaintDeviceSP filteredSource,
+ bool filteredSourceValid,
+ const QRect &boundingRect);
+ ~KisColorizeStrokeStrategy();
+
+ void addKeyStroke(KisPaintDeviceSP dev, const KoColor &color);
+
+ void initStrokeCallback();
+
+Q_SIGNALS:
+ void sigFinished();
+
+private:
+ struct Private;
+ const QScopedPointer m_d;
+};
+
+#endif /* __KIS_COLORIZE_STROKE_STRATEGY_H */
diff --git a/libs/image/lazybrush/kis_colorize_stroke_strategy.cpp b/libs/image/lazybrush/kis_colorize_stroke_strategy.cpp
new file mode 100644
--- /dev/null
+++ b/libs/image/lazybrush/kis_colorize_stroke_strategy.cpp
@@ -0,0 +1,96 @@
+/*
+ * Copyright (c) 2016 Dmitry Kazakov
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+
+#include "kis_colorize_stroke_strategy.h"
+
+#include
+
+#include "kis_multiway_cut.h"
+#include "kis_paint_device.h"
+#include "kis_lazy_fill_tools.h"
+#include "kis_gaussian_kernel.h"
+#include "kis_painter.h"
+
+using namespace KisLazyFillTools;
+
+struct KisColorizeStrokeStrategy::Private
+{
+ KisPaintDeviceSP src;
+ KisPaintDeviceSP dst;
+ KisPaintDeviceSP filteredSource;
+ KisPaintDeviceSP internalFilteredSource;
+ bool filteredSourceValid;
+ QRect boundingRect;
+
+ QVector keyStrokes;
+};
+
+KisColorizeStrokeStrategy::KisColorizeStrokeStrategy(KisPaintDeviceSP src,
+ KisPaintDeviceSP dst,
+ KisPaintDeviceSP filteredSource,
+ bool filteredSourceValid,
+ const QRect &boundingRect)
+ : m_d(new Private)
+{
+ m_d->src = src;
+ m_d->dst = dst;
+ m_d->filteredSource = filteredSource;
+ m_d->boundingRect = boundingRect;
+ m_d->filteredSourceValid = filteredSourceValid;
+
+ enableJob(JOB_INIT, true, KisStrokeJobData::SEQUENTIAL, KisStrokeJobData::EXCLUSIVE);
+}
+
+KisColorizeStrokeStrategy::~KisColorizeStrokeStrategy()
+{
+}
+
+void KisColorizeStrokeStrategy::addKeyStroke(KisPaintDeviceSP dev, const KoColor &color)
+{
+ KoColor convertedColor(color);
+ convertedColor.convertTo(m_d->dst->colorSpace());
+
+ m_d->keyStrokes << KeyStroke(dev, convertedColor);
+}
+
+void KisColorizeStrokeStrategy::initStrokeCallback()
+{
+ if (!m_d->filteredSourceValid) {
+ KisPaintDeviceSP filteredMainDev = KisPainter::convertToAlphaAsAlpha(m_d->src);
+
+ // optional filtering
+ // KisGaussianKernel::applyLoG(filteredMainDev,
+ // m_d->boundingRect,
+ // 1.0,
+ // QBitArray(), 0);
+
+ normalizeAndInvertAlpha8Device(filteredMainDev, m_d->boundingRect);
+
+ m_d->filteredSource->makeCloneFrom(filteredMainDev, m_d->boundingRect);
+ }
+
+ KisMultiwayCut cut(m_d->filteredSource, m_d->dst, m_d->boundingRect);
+
+ Q_FOREACH (const KeyStroke &stroke, m_d->keyStrokes) {
+ cut.addKeyStroke(new KisPaintDevice(*stroke.dev), stroke.color);
+ }
+
+ cut.run();
+
+ emit sigFinished();
+}
diff --git a/libs/image/lazybrush/kis_lazy_fill_capacity_map.h b/libs/image/lazybrush/kis_lazy_fill_capacity_map.h
new file mode 100644
--- /dev/null
+++ b/libs/image/lazybrush/kis_lazy_fill_capacity_map.h
@@ -0,0 +1,180 @@
+/*
+ * Copyright (c) 2016 Dmitry Kazakov
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+
+#ifndef __KIS_LAZY_FILL_CAPACITY_MAP_H
+#define __KIS_LAZY_FILL_CAPACITY_MAP_H
+
+#include
+
+#include "kis_lazy_fill_graph.h"
+#include "kis_paint_device.h"
+#include "kis_types.h"
+#include "kis_painter.h"
+#include "kis_random_accessor_ng.h"
+#include "kis_global.h"
+
+
+class KisLazyFillCapacityMap
+{
+ typedef KisLazyFillCapacityMap type;
+ typedef typename boost::graph_traits::vertex_descriptor VertexDescriptor;
+ typedef typename boost::graph_traits::edge_descriptor EdgeDescriptor;
+
+public:
+ typedef EdgeDescriptor key_type;
+ typedef float value_type;
+ typedef const float& reference;
+ typedef boost::readable_property_map_tag category;
+
+ KisLazyFillCapacityMap(KisPaintDeviceSP mainImage,
+ KisPaintDeviceSP aLabelImage,
+ KisPaintDeviceSP bLabelImage,
+ KisPaintDeviceSP maskImage,
+ const QRect &boundingRect)
+ : m_mainImage(mainImage),
+ m_aLabelImage(aLabelImage),
+ m_bLabelImage(bLabelImage),
+ m_maskImage(maskImage),
+ m_mainRect(boundingRect),
+ m_aLabelRect(m_aLabelImage->exactBounds() & boundingRect),
+ m_bLabelRect(m_bLabelImage->exactBounds() & boundingRect),
+ m_colorSpace(mainImage->colorSpace()),
+ m_pixelSize(m_colorSpace->pixelSize()),
+ m_graph(m_mainRect,
+ m_aLabelImage->regionExact() & boundingRect,
+ m_bLabelImage->regionExact() & boundingRect)
+ {
+ KIS_ASSERT_RECOVER_NOOP(m_mainImage->colorSpace()->pixelSize() == 1);
+ KIS_ASSERT_RECOVER_NOOP(m_aLabelImage->colorSpace()->pixelSize() == 1);
+ KIS_ASSERT_RECOVER_NOOP(m_bLabelImage->colorSpace()->pixelSize() == 1);
+
+
+ const QPoint pt = m_mainRect.topLeft();
+
+ m_mainAccessor = m_mainImage->createRandomConstAccessorNG(pt.x(), pt.y());
+ m_aAccessor = m_aLabelImage->createRandomConstAccessorNG(pt.x(), pt.y());
+ m_bAccessor = m_bLabelImage->createRandomConstAccessorNG(pt.x(), pt.y());
+ m_maskAccessor = m_maskImage->createRandomConstAccessorNG(pt.x(), pt.y());
+ m_srcPixelBuf.resize(m_pixelSize);
+ }
+
+ int maxCapacity() const {
+ const int k = 2 * (m_mainRect.width() + m_mainRect.height());
+ return k + 1;
+ }
+
+ friend value_type get(type &map,
+ const key_type &key)
+ {
+ VertexDescriptor src = source(key, map.m_graph);
+ VertexDescriptor dst = target(key, map.m_graph);
+
+ if (src.type == VertexDescriptor::NORMAL) {
+ map.m_maskAccessor->moveTo(src.x, src.y);
+ if (*map.m_maskAccessor->rawDataConst()) {
+ return 0;
+ }
+ }
+
+ if (dst.type == VertexDescriptor::NORMAL) {
+ map.m_maskAccessor->moveTo(dst.x, dst.y);
+ if (*map.m_maskAccessor->rawDataConst()) {
+ return 0;
+ }
+ }
+
+ bool srcLabelA = src.type == VertexDescriptor::LABEL_A;
+ bool srcLabelB = src.type == VertexDescriptor::LABEL_B;
+ bool dstLabelA = dst.type == VertexDescriptor::LABEL_A;
+ bool dstLabelB = dst.type == VertexDescriptor::LABEL_B;
+
+ if (srcLabelA || srcLabelB) {
+ std::swap(src, dst);
+ std::swap(srcLabelA, dstLabelA);
+ std::swap(srcLabelB, dstLabelB);
+ }
+
+ Q_ASSERT(!srcLabelA && !srcLabelB);
+
+
+ // TODO: precalculate!
+ const int k = 2 * (map.m_mainRect.width() + map.m_mainRect.height());
+
+ float value = 0.0;
+
+ if (dstLabelA) {
+ map.m_aAccessor->moveTo(src.x, src.y);
+ const int i0 = *((quint8*)map.m_aAccessor->rawDataConst());
+ value = i0 / 255.0 * k;
+
+ } else if (dstLabelB) {
+ map.m_bAccessor->moveTo(src.x, src.y);
+ const int i0 = *((quint8*)map.m_bAccessor->rawDataConst());
+ value = i0 / 255.0 * k;
+
+ } else {
+ map.m_mainAccessor->moveTo(src.x, src.y);
+ memcpy(map.m_srcPixelBuf.data(), map.m_mainAccessor->rawDataConst(), map.m_pixelSize);
+ map.m_mainAccessor->moveTo(dst.x, dst.y);
+
+ //const quint8 diff = map.m_colorSpace->differenceA((quint8*)map.m_srcPixelBuf.data(), map.m_mainAccessor->rawDataConst());
+ //const quint8 i0 = map.m_colorSpace->intensity8((quint8*)map.m_srcPixelBuf.data());
+ //const quint8 i1 = map.m_colorSpace->intensity8(map.m_mainAccessor->rawDataConst());
+
+ const quint8 i0 = *((quint8*)map.m_srcPixelBuf.data());
+ const quint8 i1 = *map.m_mainAccessor->rawDataConst();
+
+ const quint8 diff = qAbs(i1 - i0);
+
+ const qreal diffPenalty = qBound(0.0, qreal(diff) / 10.0, 1.0);
+ const qreal intensityPenalty = 1.0 - i1 / 255.0;
+
+ const qreal totalPenalty = qMax(0.0 * diffPenalty, intensityPenalty);
+
+ value = 1.0 + k * (1.0 - pow2(totalPenalty));
+ }
+
+ return value;
+ }
+
+ KisLazyFillGraph& graph() {
+ return m_graph;
+ }
+
+private:
+ KisPaintDeviceSP m_mainImage;
+ KisPaintDeviceSP m_aLabelImage;
+ KisPaintDeviceSP m_bLabelImage;
+ KisPaintDeviceSP m_maskImage;
+
+ QRect m_mainRect;
+ QRect m_aLabelRect;
+ QRect m_bLabelRect;
+
+ const KoColorSpace *m_colorSpace;
+ int m_pixelSize;
+ KisRandomConstAccessorSP m_mainAccessor;
+ KisRandomConstAccessorSP m_aAccessor;
+ KisRandomConstAccessorSP m_bAccessor;
+ KisRandomConstAccessorSP m_maskAccessor;
+ QByteArray m_srcPixelBuf;
+
+ KisLazyFillGraph m_graph;
+};
+
+#endif /* __KIS_LAZY_FILL_CAPACITY_MAP_H */
diff --git a/libs/image/lazybrush/kis_lazy_fill_graph.h b/libs/image/lazybrush/kis_lazy_fill_graph.h
new file mode 100644
--- /dev/null
+++ b/libs/image/lazybrush/kis_lazy_fill_graph.h
@@ -0,0 +1,1035 @@
+/*
+ * Copyright (c) 2016 Dmitry Kazakov
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+
+#ifndef __KIS_LAZY_FILL_GRAPH_H
+#define __KIS_LAZY_FILL_GRAPH_H
+
+#include
+#include
+#include
+
+#include
+#include
+#include
+#include
+
+#include
+
+
+using namespace boost;
+
+/*
+BOOST_CONCEPT_ASSERT(( ReadablePropertyMapConcept )); //read flow-values from vertices
+*/
+
+class KisLazyFillGraph;
+
+template
+struct MyScribbleLabelMap {
+ typedef typename Graph::vertex_descriptor key_type;
+ typedef float value_type;
+ typedef const float& reference;
+ typedef readable_property_map_tag category;
+
+ friend value_type get(const MyScribbleLabelMap &map,
+ const key_type &key) {
+ return 0;
+ }
+
+ friend QRegion region(const MyScribbleLabelMap &map) {
+ return QRegion();
+ }
+
+ friend QRect boundingRect(const MyScribbleLabelMap &map) {
+ return QRect(10,10,100,100);
+ }
+};
+
+//===================
+// Index Property Map
+//===================
+
+template
+struct lazy_fill_graph_index_map {
+public:
+ typedef Index value_type;
+ typedef Index reference_type;
+ typedef reference_type reference;
+ typedef Descriptor key_type;
+ typedef readable_property_map_tag category;
+
+ lazy_fill_graph_index_map() { }
+
+ lazy_fill_graph_index_map(const Graph& graph) :
+ m_graph(&graph) { }
+
+ value_type operator[](key_type key) const {
+ value_type index = m_graph->index_of(key);
+ KIS_ASSERT(index >= 0);
+ return index;
+ }
+
+ friend inline Index
+ get(const lazy_fill_graph_index_map& index_map,
+ const typename lazy_fill_graph_index_map::key_type& key)
+ {
+ return (index_map[key]);
+ }
+
+protected:
+ const Graph* m_graph;
+};
+
+//==========================
+// Reverse Edge Property Map
+//==========================
+
+template
+struct lazy_fill_graph_reverse_edge_map {
+public:
+ typedef Descriptor value_type;
+ typedef Descriptor reference_type;
+ typedef reference_type reference;
+ typedef Descriptor key_type;
+ typedef readable_property_map_tag category;
+
+ lazy_fill_graph_reverse_edge_map() { }
+
+ value_type operator[](const key_type& key) const {
+ return (value_type(key.second, key.first));
+ }
+
+ friend inline Descriptor
+ get(const lazy_fill_graph_reverse_edge_map& rev_map,
+ const typename lazy_fill_graph_reverse_edge_map::key_type& key)
+ {
+ return (rev_map[key]);
+ }
+};
+
+//=================
+// Function Objects
+//=================
+
+namespace kis_detail {
+
+ // vertex_at
+ template
+ struct lazy_fill_graph_vertex_at {
+
+ typedef typename graph_traits::vertex_descriptor result_type;
+
+ lazy_fill_graph_vertex_at() : m_graph(0) {}
+
+ lazy_fill_graph_vertex_at(const Graph* graph) :
+ m_graph(graph) { }
+
+ result_type
+ operator()
+ (typename graph_traits::vertices_size_type vertex_index) const {
+ return (vertex(vertex_index, *m_graph));
+ }
+
+ private:
+ const Graph* m_graph;
+ };
+
+ // out_edge_at
+ template
+ struct lazy_fill_graph_out_edge_at {
+
+ private:
+ typedef typename graph_traits::vertex_descriptor vertex_descriptor;
+
+ public:
+ typedef typename graph_traits::edge_descriptor result_type;
+
+ lazy_fill_graph_out_edge_at() : m_vertex(), m_graph(0) {}
+
+ lazy_fill_graph_out_edge_at(vertex_descriptor source_vertex,
+ const Graph* graph) :
+ m_vertex(source_vertex),
+ m_graph(graph) { }
+
+ result_type
+ operator()
+ (typename graph_traits::degree_size_type out_edge_index) const {
+ return (out_edge_at(m_vertex, out_edge_index, *m_graph));
+ }
+
+ private:
+ vertex_descriptor m_vertex;
+ const Graph* m_graph;
+ };
+
+ // in_edge_at
+ template
+ struct lazy_fill_graph_in_edge_at {
+
+ private:
+ typedef typename graph_traits::vertex_descriptor vertex_descriptor;
+
+ public:
+ typedef typename graph_traits::edge_descriptor result_type;
+
+ lazy_fill_graph_in_edge_at() : m_vertex(), m_graph(0) {}
+
+ lazy_fill_graph_in_edge_at(vertex_descriptor target_vertex,
+ const Graph* graph) :
+ m_vertex(target_vertex),
+ m_graph(graph) { }
+
+ result_type
+ operator()
+ (typename graph_traits::degree_size_type in_edge_index) const {
+ return (in_edge_at(m_vertex, in_edge_index, *m_graph));
+ }
+
+ private:
+ vertex_descriptor m_vertex;
+ const Graph* m_graph;
+ };
+
+ // edge_at
+ template
+ struct lazy_fill_graph_edge_at {
+
+ typedef typename graph_traits::edge_descriptor result_type;
+
+ lazy_fill_graph_edge_at() : m_graph(0) {}
+
+ lazy_fill_graph_edge_at(const Graph* graph) :
+ m_graph(graph) { }
+
+ result_type
+ operator()
+ (typename graph_traits::edges_size_type edge_index) const {
+ return (edge_at(edge_index, *m_graph));
+ }
+
+ private:
+ const Graph* m_graph;
+ };
+
+ // adjacent_vertex_at
+ template
+ struct lazy_fill_graph_adjacent_vertex_at {
+
+ public:
+ typedef typename graph_traits::vertex_descriptor result_type;
+
+ lazy_fill_graph_adjacent_vertex_at(result_type source_vertex,
+ const Graph* graph) :
+ m_vertex(source_vertex),
+ m_graph(graph) { }
+
+ result_type
+ operator()
+ (typename graph_traits::degree_size_type adjacent_index) const {
+ return (target(out_edge_at(m_vertex, adjacent_index, *m_graph), *m_graph));
+ }
+
+ private:
+ result_type m_vertex;
+ const Graph* m_graph;
+ };
+
+} // namespace kis_detail
+
+
+class KisLazyFillGraph
+{
+public:
+ typedef KisLazyFillGraph type;
+
+
+ typedef long VertexIndex;
+ typedef long EdgeIndex;
+
+ // sizes
+ typedef VertexIndex vertices_size_type;
+ typedef EdgeIndex edges_size_type;
+ typedef EdgeIndex degree_size_type;
+
+ struct VertexDescriptor : public equality_comparable
+ {
+ enum VertexType {
+ NORMAL = 0,
+ LABEL_A,
+ LABEL_B
+ };
+
+
+ vertices_size_type x;
+ vertices_size_type y;
+ VertexType type;
+
+ VertexDescriptor(vertices_size_type _x, vertices_size_type _y, VertexType _type = NORMAL)
+ : x(_x), y(_y), type(_type) {}
+
+ VertexDescriptor(VertexType _type)
+ : x(0), y(0), type(_type) {}
+
+ VertexDescriptor()
+ : x(0), y(0), type(NORMAL) {}
+
+ bool operator ==(const VertexDescriptor &rhs) const {
+ return rhs.x == x && rhs.y == y && rhs.type == type;
+ }
+ };
+
+ // descriptors
+ typedef VertexDescriptor vertex_descriptor;
+ typedef std::pair edge_descriptor;
+
+ friend QDebug operator<<(QDebug dbg, const KisLazyFillGraph::edge_descriptor &e);
+ friend QDebug operator<<(QDebug dbg, const KisLazyFillGraph::vertex_descriptor &v);
+
+ // vertex_iterator
+ typedef counting_iterator vertex_index_iterator;
+ typedef kis_detail::lazy_fill_graph_vertex_at vertex_function;
+ typedef transform_iterator vertex_iterator;
+
+ // edge_iterator
+ typedef counting_iterator edge_index_iterator;
+ typedef kis_detail::lazy_fill_graph_edge_at edge_function;
+ typedef transform_iterator edge_iterator;
+
+ // out_edge_iterator
+ typedef counting_iterator degree_iterator;
+ typedef kis_detail::lazy_fill_graph_out_edge_at out_edge_function;
+ typedef transform_iterator out_edge_iterator;
+
+ // adjacency_iterator
+ typedef kis_detail::lazy_fill_graph_adjacent_vertex_at adjacent_vertex_function;
+ typedef transform_iterator adjacency_iterator;
+
+ // categories
+ typedef directed_tag directed_category;
+ typedef disallow_parallel_edge_tag edge_parallel_category;
+ struct traversal_category : virtual public incidence_graph_tag,
+ virtual public adjacency_graph_tag,
+ virtual public vertex_list_graph_tag,
+ virtual public edge_list_graph_tag,
+ virtual public adjacency_matrix_tag { };
+
+ static inline vertex_descriptor null_vertex()
+ {
+ vertex_descriptor maxed_out_vertex(
+ std::numeric_limits::max(),
+ std::numeric_limits::max(),
+ vertex_descriptor::NORMAL);
+
+ return (maxed_out_vertex);
+ }
+
+ KisLazyFillGraph() {}
+
+ KisLazyFillGraph(const QRect &mainRect,
+ const QRegion &aLabelRegion,
+ const QRegion &bLabelRegion)
+ : m_x(mainRect.x()),
+ m_y(mainRect.y()),
+ m_width(mainRect.width()),
+ m_height(mainRect.height())
+ {
+ m_mainArea = mainRect;
+ m_aLabelArea = aLabelRegion.boundingRect();
+ m_bLabelArea = bLabelRegion.boundingRect();
+ m_aLabelRects = aLabelRegion.rects();
+ m_bLabelRects = bLabelRegion.rects();
+
+ KIS_ASSERT(m_mainArea.contains(m_aLabelArea));
+ KIS_ASSERT(m_mainArea.contains(m_bLabelArea));
+
+ m_numVertices = m_width * m_height + 2;
+
+ m_edgeBins << EdgeIndexBin(0, m_mainArea.adjusted(0, 0, -1, 0), HORIZONTAL);
+ m_edgeBins << EdgeIndexBin(m_edgeBins.last(), m_mainArea.adjusted(0, 0, -1, 0), HORIZONTAL_REVERSED);
+
+ m_edgeBins << EdgeIndexBin(m_edgeBins.last(), m_mainArea.adjusted(0, 0, 0, -1), VERTICAL);
+ m_edgeBins << EdgeIndexBin(m_edgeBins.last(), m_mainArea.adjusted(0, 0, 0, -1), VERTICAL_REVERSED);
+
+ Q_FOREACH (const QRect &rc, m_aLabelRects) {
+ m_edgeBins << EdgeIndexBin(m_edgeBins.last(), rc, LABEL_A);
+ }
+
+ // out_edge_at relies on the sequential layout of reversed edges of one type
+ m_aReversedEdgesStart = m_edgeBins.last().last() + 1;
+
+ Q_FOREACH (const QRect &rc, m_aLabelRects) {
+ m_edgeBins << EdgeIndexBin(m_edgeBins.last(), rc, LABEL_A_REVERSED);
+ }
+
+ m_numAEdges = m_edgeBins.last().last() + 1 - m_aReversedEdgesStart;
+
+ Q_FOREACH (const QRect &rc, m_bLabelRects) {
+ m_edgeBins << EdgeIndexBin(m_edgeBins.last(), rc, LABEL_B);
+ }
+
+ // out_edge_at relies on the sequential layout of reversed edges of one type
+ m_bReversedEdgesStart = m_edgeBins.last().last() + 1;
+
+ Q_FOREACH (const QRect &rc, m_bLabelRects) {
+ m_edgeBins << EdgeIndexBin(m_edgeBins.last(), rc, LABEL_B_REVERSED);
+ }
+
+ m_numBEdges = m_edgeBins.last().last() + 1 - m_bReversedEdgesStart;
+
+ m_numEdges = m_edgeBins.last().last() + 1;
+ }
+
+ ~KisLazyFillGraph() {
+
+ }
+
+ QSize size() const { return QSize(m_width, m_height); }
+ QRect rect() const { return QRect(m_x, m_y, m_width, m_height); }
+
+
+ vertices_size_type m_x;
+ vertices_size_type m_y;
+
+ vertices_size_type m_width;
+ vertices_size_type m_height;
+
+ vertices_size_type m_numVertices;
+ vertices_size_type m_numEdges;
+
+ vertices_size_type m_aReversedEdgesStart;
+ vertices_size_type m_bReversedEdgesStart;
+ vertices_size_type m_numAEdges;
+ vertices_size_type m_numBEdges;
+
+ enum EdgeIndexBinId {
+ HORIZONTAL,
+ HORIZONTAL_REVERSED,
+ VERTICAL,
+ VERTICAL_REVERSED,
+ LABEL_A,
+ LABEL_A_REVERSED,
+ LABEL_B,
+ LABEL_B_REVERSED,
+ };
+
+ struct EdgeIndexBin {
+ EdgeIndexBin()
+ : start(0), stride(0), size(0) {}
+
+ EdgeIndexBin(edges_size_type _start,
+ const QRect &_rect,
+ EdgeIndexBinId _binId)
+ : start(_start),
+ stride(_rect.width()),
+ size(_rect.width() * _rect.height()),
+ xOffset(_rect.x()),
+ yOffset(_rect.y()),
+ binId(_binId),
+ isReversed(int(_binId) & 0x1),
+ rect(_rect) {}
+
+ EdgeIndexBin(const EdgeIndexBin &putAfter,
+ const QRect &_rect,
+ EdgeIndexBinId _binId)
+ : start(putAfter.last() + 1),
+ stride(_rect.width()),
+ size(_rect.width() * _rect.height()),
+ xOffset(_rect.x()),
+ yOffset(_rect.y()),
+ binId(_binId),
+ isReversed(int(_binId) & 0x1),
+ rect(_rect) {}
+
+ edges_size_type last() const {
+ return start + size - 1;
+ }
+
+ bool contains(edges_size_type index) const {
+ index -= start;
+ return index >= 0 && index < size;
+ }
+
+ bool contains(const edge_descriptor &edge) const {
+ return indexOf(edge) >= 0;
+ }
+
+ edges_size_type indexOf(const edge_descriptor &edge) const {
+ vertex_descriptor src_vertex = source(edge, *this);
+ vertex_descriptor dst_vertex = target(edge, *this);
+
+ const bool srcColoredA = src_vertex.type == vertex_descriptor::LABEL_A;
+ const bool dstColoredA = dst_vertex.type == vertex_descriptor::LABEL_A;
+ const bool srcColoredB = src_vertex.type == vertex_descriptor::LABEL_B;
+ const bool dstColoredB = dst_vertex.type == vertex_descriptor::LABEL_B;
+
+ if (srcColoredA || dstColoredA) {
+ const bool edgeReversed = srcColoredA;
+
+ if (isReversed != edgeReversed ||
+ (binId != LABEL_A && binId != LABEL_A_REVERSED) ||
+ (srcColoredA && (dst_vertex.type != vertex_descriptor::NORMAL)) ||
+ (dstColoredA && (src_vertex.type != vertex_descriptor::NORMAL))) {
+
+ return -1;
+ }
+ } else if (srcColoredB || dstColoredB) {
+ const bool edgeReversed = srcColoredB;
+
+ if (isReversed != edgeReversed ||
+ (binId != LABEL_B && binId != LABEL_B_REVERSED) ||
+ (srcColoredB && (dst_vertex.type != vertex_descriptor::NORMAL)) ||
+ (dstColoredB && (src_vertex.type != vertex_descriptor::NORMAL))) {
+
+ return -1;
+ }
+ } else {
+ const vertices_size_type xDiff = dst_vertex.x - src_vertex.x;
+ const vertices_size_type yDiff = dst_vertex.y - src_vertex.y;
+ const vertices_size_type xAbsDiff = qAbs(xDiff);
+ const vertices_size_type yAbsDiff = qAbs(yDiff);
+ const bool edgeReversed = xDiff < 0 || yDiff < 0;
+
+ if (isReversed != edgeReversed ||
+ (xAbsDiff && binId != HORIZONTAL && binId != HORIZONTAL_REVERSED) ||
+ (yAbsDiff && binId != VERTICAL && binId != VERTICAL_REVERSED) ||
+ xAbsDiff > 1 ||
+ yAbsDiff > 1 ||
+ xAbsDiff == yAbsDiff) {
+
+ return -1;
+ }
+ }
+
+ if (isReversed) {
+ std::swap(src_vertex, dst_vertex);
+ }
+
+ if (!rect.contains(QPoint(src_vertex.x, src_vertex.y))) {
+ return -1;
+ }
+
+ edges_size_type internalIndex =
+ (src_vertex.x - xOffset) +
+ (src_vertex.y - yOffset) * stride;
+
+ KIS_ASSERT_RECOVER(internalIndex >= 0 && internalIndex < size) {
+ return -1;
+ }
+
+ return internalIndex + start;
+ }
+
+
+ edge_descriptor edgeAt(edges_size_type index) const {
+ edges_size_type localOffset = index - start;
+
+ if (localOffset < 0 || localOffset >= size) {
+ return edge_descriptor();
+ }
+
+ const edges_size_type x = localOffset % stride + xOffset;
+ const edges_size_type y = localOffset / stride + yOffset;
+
+ vertex_descriptor src_vertex(x, y, vertex_descriptor::NORMAL);
+ vertex_descriptor dst_vertex;
+
+ switch (binId) {
+ case HORIZONTAL:
+ case HORIZONTAL_REVERSED:
+ dst_vertex.x = x + 1;
+ dst_vertex.y = y;
+ dst_vertex.type = vertex_descriptor::NORMAL;
+ break;
+ case VERTICAL:
+ case VERTICAL_REVERSED:
+ dst_vertex.x = x;
+ dst_vertex.y = y + 1;
+ dst_vertex.type = vertex_descriptor::NORMAL;
+ break;
+ case LABEL_A:
+ case LABEL_A_REVERSED:
+ dst_vertex.type = vertex_descriptor::LABEL_A;
+ break;
+ case LABEL_B:
+ case LABEL_B_REVERSED:
+ dst_vertex.type = vertex_descriptor::LABEL_B;
+ break;
+ }
+
+ if (isReversed) {
+ std::swap(src_vertex, dst_vertex);
+ }
+
+ return std::make_pair(src_vertex, dst_vertex);
+ }
+
+ edges_size_type start;
+ edges_size_type stride;
+ edges_size_type size;
+ edges_size_type xOffset;
+ edges_size_type yOffset;
+ EdgeIndexBinId binId;
+ bool isReversed;
+ QRect rect;
+ };
+
+ QVector m_edgeBins;
+
+ QRect m_aLabelArea;
+ QRect m_bLabelArea;
+ QRect m_mainArea;
+
+ QVector m_aLabelRects;
+ QVector m_bLabelRects;
+
+protected:
+public:
+
+ // Returns the number of vertices in the graph
+ inline vertices_size_type num_vertices() const {
+ return (m_numVertices);
+ }
+
+ // Returns the number of edges in the graph
+ inline edges_size_type num_edges() const {
+ return (m_numEdges);
+ }
+
+ // Returns the index of [vertex] (See also vertex_at)
+ vertices_size_type index_of(vertex_descriptor vertex) const {
+ vertices_size_type vertex_index = -1;
+
+ switch (vertex.type) {
+ case vertex_descriptor::NORMAL:
+ vertex_index = vertex.x - m_x + (vertex.y - m_y) * m_width;
+ break;
+ case vertex_descriptor::LABEL_A:
+ vertex_index = m_numVertices - 2;
+ break;
+ case vertex_descriptor::LABEL_B:
+ vertex_index = m_numVertices - 1;
+ break;
+ }
+
+ return vertex_index;
+ }
+
+ // Returns the vertex whose index is [vertex_index] (See also
+ // index_of(vertex_descriptor))
+ vertex_descriptor vertex_at (vertices_size_type vertex_index) const {
+ vertex_descriptor vertex;
+
+ if (vertex_index == m_numVertices - 2) {
+ vertex.type = vertex_descriptor::LABEL_A;
+ } else if (vertex_index == m_numVertices - 1) {
+ vertex.type = vertex_descriptor::LABEL_B;
+ } else if (vertex_index >= 0) {
+ vertex.x = vertex_index % m_width + m_x;
+ vertex.y = vertex_index / m_width + m_y;
+ vertex.type = vertex_descriptor::NORMAL;
+ }
+
+ return vertex;
+ }
+
+ // Returns the edge whose index is [edge_index] (See also
+ // index_of(edge_descriptor)). NOTE: The index mapping is
+ // dependent upon dimension wrapping.
+ edge_descriptor edge_at(edges_size_type edge_index) const {
+
+ int binIndex = 0;
+
+ while (binIndex < m_edgeBins.size() &&
+ !m_edgeBins[binIndex].contains(edge_index)) {
+
+ binIndex++;
+ }
+
+ if (binIndex >= m_edgeBins.size()) {
+ return edge_descriptor();
+ }
+
+ return m_edgeBins[binIndex].edgeAt(edge_index);
+ }
+
+ // Returns the index for [edge] (See also edge_at)
+ edges_size_type index_of(edge_descriptor edge) const {
+ edges_size_type index = -1;
+
+ Q_FOREACH (const EdgeIndexBin &bin, m_edgeBins) {
+ index = bin.indexOf(edge);
+ if (index >= 0) break;
+ }
+
+
+ //ENTER_FUNCTION() << ppVar(edge) << ppVar(index);
+ //KIS_ASSERT(index >= 0);
+
+ return index;
+ }
+
+private:
+ static vertices_size_type numVacantEdges(const vertex_descriptor &vertex, const QRect &rc) {
+ vertices_size_type vacantEdges = 4;
+
+ if (vertex.x == rc.x()) {
+ vacantEdges--;
+ }
+
+ if (vertex.y == rc.y()) {
+ vacantEdges--;
+ }
+
+ if (vertex.x == rc.right()) {
+ vacantEdges--;
+ }
+
+ if (vertex.y == rc.bottom()) {
+ vacantEdges--;
+ }
+
+ return vacantEdges;
+ }
+
+ static inline bool findInRects(const QVector &rects, const QPoint &pt) {
+ bool result = false;
+ Q_FOREACH (const QRect &rc, rects) {
+ if (rc.contains(pt)) {
+ result = true;
+ break;
+ }
+ }
+ return result;
+ }
+public:
+ // Returns the number of out-edges for [vertex]
+ degree_size_type out_degree(vertex_descriptor vertex) const {
+ degree_size_type out_edge_count = 0;
+ if (index_of(vertex) < 0) return out_edge_count;
+
+ switch (vertex.type) {
+ case vertex_descriptor::NORMAL: {
+ out_edge_count = numVacantEdges(vertex, m_mainArea);
+
+ const QPoint pt = QPoint(vertex.x, vertex.y);
+
+ if (m_aLabelArea.contains(pt) && findInRects(m_aLabelRects, pt)) {
+ out_edge_count++;
+ }
+
+ if (m_bLabelArea.contains(pt) && findInRects(m_bLabelRects, pt)) {
+ out_edge_count++;
+ }
+
+ break;
+ }
+ case vertex_descriptor::LABEL_A:
+ out_edge_count = m_numAEdges;
+ break;
+ case vertex_descriptor::LABEL_B:
+ out_edge_count = m_numBEdges;
+ break;
+ }
+
+ return (out_edge_count);
+ }
+
+ // Returns an out-edge for [vertex] by index. Indices are in the
+ // range [0, out_degree(vertex)).
+ edge_descriptor out_edge_at (vertex_descriptor vertex,
+ degree_size_type out_edge_index) const {
+
+ const QPoint pt = QPoint(vertex.x, vertex.y);
+ vertex_descriptor dst_vertex = vertex;
+
+ switch (vertex.type) {
+ case vertex_descriptor::NORMAL:
+ if (vertex.x > m_mainArea.x() && !out_edge_index--) {
+ dst_vertex.x--;
+ } else if (vertex.y > m_mainArea.y() && !out_edge_index--) {
+ dst_vertex.y--;
+ } else if (vertex.x < m_mainArea.right() && !out_edge_index--) {
+ dst_vertex.x++;
+ } else if (vertex.y < m_mainArea.bottom() && !out_edge_index--) {
+ dst_vertex.y++;
+ } else if (m_aLabelArea.contains(pt) && findInRects(m_aLabelRects, pt) && !out_edge_index--) {
+ dst_vertex = vertex_descriptor(0, 0, vertex_descriptor::LABEL_A);
+ } else if (m_bLabelArea.contains(pt) && findInRects(m_bLabelRects, pt) && !out_edge_index--) {
+ dst_vertex = vertex_descriptor(0, 0, vertex_descriptor::LABEL_B);
+ } else {
+ qDebug() << ppVar(vertex) << ppVar(out_edge_index) << ppVar(out_degree(vertex));
+ qFatal("Wrong edge sub-index");
+ }
+ break;
+ case vertex_descriptor::LABEL_A: {
+ edge_descriptor edge = edge_at(m_aReversedEdgesStart + out_edge_index);
+ dst_vertex = edge.second;
+ break;
+ }
+ case vertex_descriptor::LABEL_B: {
+ edge_descriptor edge = edge_at(m_bReversedEdgesStart + out_edge_index);
+ dst_vertex = edge.second;
+ break;
+ }
+ }
+
+ return std::make_pair(vertex, dst_vertex);
+ }
+
+public:
+
+ //================
+ // VertexListGraph
+ //================
+
+ friend inline std::pair
+ vertices(const type& graph) {
+ typedef typename type::vertex_iterator vertex_iterator;
+ typedef typename type::vertex_function vertex_function;
+ typedef typename type::vertex_index_iterator vertex_index_iterator;
+
+ return (std::make_pair
+ (vertex_iterator(vertex_index_iterator(0),
+ vertex_function(&graph)),
+ vertex_iterator(vertex_index_iterator(graph.num_vertices()),
+ vertex_function(&graph))));
+ }
+
+ friend inline typename type::vertices_size_type
+ num_vertices(const type& graph) {
+ return (graph.num_vertices());
+ }
+
+ friend inline typename type::vertex_descriptor
+ vertex(typename type::vertices_size_type vertex_index,
+ const type& graph) {
+
+ return (graph.vertex_at(vertex_index));
+ }
+
+ //===============
+ // IncidenceGraph
+ //===============
+
+ friend inline std::pair
+ out_edges(typename type::vertex_descriptor vertex,
+ const type& graph) {
+ typedef typename type::degree_iterator degree_iterator;
+ typedef typename type::out_edge_function out_edge_function;
+ typedef typename type::out_edge_iterator out_edge_iterator;
+
+ return (std::make_pair
+ (out_edge_iterator(degree_iterator(0),
+ out_edge_function(vertex, &graph)),
+ out_edge_iterator(degree_iterator(graph.out_degree(vertex)),
+ out_edge_function(vertex, &graph))));
+ }
+
+ friend inline typename type::degree_size_type
+ out_degree
+ (typename type::vertex_descriptor vertex,
+ const type& graph) {
+ return (graph.out_degree(vertex));
+ }
+
+ friend inline typename type::edge_descriptor
+ out_edge_at(typename type::vertex_descriptor vertex,
+ typename type::degree_size_type out_edge_index,
+ const type& graph) {
+ return (graph.out_edge_at(vertex, out_edge_index));
+ }
+
+ //===============
+ // AdjacencyGraph
+ //===============
+
+ friend typename std::pair
+ adjacent_vertices (typename type::vertex_descriptor vertex,
+ const type& graph) {
+ typedef typename type::degree_iterator degree_iterator;
+ typedef typename type::adjacent_vertex_function adjacent_vertex_function;
+ typedef typename type::adjacency_iterator adjacency_iterator;
+
+ return (std::make_pair
+ (adjacency_iterator(degree_iterator(0),
+ adjacent_vertex_function(vertex, &graph)),
+ adjacency_iterator(degree_iterator(graph.out_degree(vertex)),
+ adjacent_vertex_function(vertex, &graph))));
+ }
+
+ //==================
+ // Adjacency Matrix
+ //==================
+
+ friend std::pair
+ edge (typename type::vertex_descriptor source_vertex,
+ typename type::vertex_descriptor destination_vertex,
+ const type& graph) {
+
+ std::pair edge_exists =
+ std::make_pair(std::make_pair(source_vertex, destination_vertex), false);
+
+ const edges_size_type index = graph.index_of(edge_exists.first);
+
+ edge_exists.second = index >= 0;
+
+ return edge_exists;
+ }
+
+ //==============
+ // EdgeListGraph
+ //==============
+
+ friend inline typename type::edges_size_type
+ num_edges(const type& graph) {
+ return (graph.num_edges());
+ }
+
+ friend inline typename type::edge_descriptor
+ edge_at(typename type::edges_size_type edge_index,
+ const type& graph) {
+ return (graph.edge_at(edge_index));
+ }
+
+ friend inline std::pair
+ edges(const type& graph) {
+ typedef typename type::edge_index_iterator edge_index_iterator;
+ typedef typename type::edge_function edge_function;
+ typedef typename type::edge_iterator edge_iterator;
+
+ return (std::make_pair
+ (edge_iterator(edge_index_iterator(0),
+ edge_function(&graph)),
+ edge_iterator(edge_index_iterator(graph.num_edges()),
+ edge_function(&graph))));
+ }
+
+ //=============================
+ // Index Property Map Functions
+ //=============================
+
+ friend inline typename type::vertices_size_type
+ get(vertex_index_t,
+ const type& graph,
+ typename type::vertex_descriptor vertex) {
+
+ type::vertices_size_type index = graph.index_of(vertex);
+ KIS_ASSERT(index >= 0);
+ return index;
+ }
+
+ friend inline typename type::edges_size_type
+ get(edge_index_t,
+ const type& graph,
+ typename type::edge_descriptor edge) {
+
+ type::edges_size_type index = graph.index_of(edge);
+ KIS_ASSERT(index >= 0);
+ return index;
+ }
+
+ friend inline lazy_fill_graph_index_map<
+ type,
+ typename type::vertex_descriptor,
+ typename type::vertices_size_type>
+ get(vertex_index_t, const type& graph) {
+ return (lazy_fill_graph_index_map<
+ type,
+ typename type::vertex_descriptor,
+ typename type::vertices_size_type>(graph));
+ }
+
+ friend inline lazy_fill_graph_index_map<
+ type,
+ typename type::edge_descriptor,
+ typename type::edges_size_type>
+ get(edge_index_t, const type& graph) {
+ return (lazy_fill_graph_index_map<
+ type,
+ typename type::edge_descriptor,
+ typename type::edges_size_type>(graph));
+ }
+
+ friend inline lazy_fill_graph_reverse_edge_map<
+ typename type::edge_descriptor>
+ get(edge_reverse_t, const type& graph) {
+ Q_UNUSED(graph);
+ return (lazy_fill_graph_reverse_edge_map<
+ typename type::edge_descriptor>());
+ }
+
+ template
+ friend struct lazy_fill_graph_index_map;
+
+ template
+ friend struct lazy_fill_graph_reverse_edge_map;
+};
+
+namespace boost {
+ template <>
+ struct property_map {
+ typedef lazy_fill_graph_index_map::vertex_descriptor,
+ typename graph_traits::vertices_size_type> type;
+ typedef type const_type;
+ };
+
+ template<>
+ struct property_map {
+ typedef lazy_fill_graph_index_map::edge_descriptor,
+ typename graph_traits::edges_size_type> type;
+ typedef type const_type;
+ };
+}
+
+namespace boost {
+ template <>
+ struct property_map {
+ typedef lazy_fill_graph_reverse_edge_map::edge_descriptor> type;
+ typedef type const_type;
+ };
+}
+
+QDebug operator<<(QDebug dbg, const KisLazyFillGraph::vertex_descriptor &v) {
+ const QString type =
+ v.type == KisLazyFillGraph::vertex_descriptor::NORMAL ? "normal" :
+ v.type == KisLazyFillGraph::vertex_descriptor::LABEL_A ? "label_A" :
+ v.type == KisLazyFillGraph::vertex_descriptor::LABEL_B ? "label_B" : "";
+
+ dbg.nospace() << "(" << v.x << ", " << v.y << ", " << type << ")";
+ return dbg.space();
+}
+
+QDebug operator<<(QDebug dbg, const KisLazyFillGraph::edge_descriptor &e) {
+ KisLazyFillGraph::vertex_descriptor src = e.first;
+ KisLazyFillGraph::vertex_descriptor dst = e.second;
+
+ dbg.nospace() << "(" << src << " -> " << dst << ")";
+ return dbg.space();
+}
+
+#endif /* __KIS_LAZY_FILL_GRAPH_H */
diff --git a/libs/image/lazybrush/kis_lazy_fill_tools.h b/libs/image/lazybrush/kis_lazy_fill_tools.h
new file mode 100644
--- /dev/null
+++ b/libs/image/lazybrush/kis_lazy_fill_tools.h
@@ -0,0 +1,81 @@
+/*
+ * Copyright (c) 2016 Dmitry Kazakov
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+
+#ifndef __KIS_LAZY_FILL_TOOLS_H
+#define __KIS_LAZY_FILL_TOOLS_H
+
+#include "kis_types.h"
+#include "kritaimage_export.h"
+#include
+
+#include
+
+
+
+class KoColor;
+
+namespace KisLazyFillTools
+{
+ KRITAIMAGE_EXPORT
+ void normalizeAndInvertAlpha8Device(KisPaintDeviceSP dev, const QRect &rect);
+
+ /**
+ * Uses Boykov-Kolmogorov Max-Flow/Min-Cut algorithm to split the
+ * device \src into two parts. The first part is defined by \p
+ * colorScribble and the second part --- by \p
+ * backgroundScribble. In the result of the split the area defined
+ * by \p colorScribble in \p resultDevice is filled with \p
+ * color. Also the same area in \p maskDevice is filled with a
+ * non-null scribble index.
+ *
+ * \p maskDevice is used for limiting the area used for filling
+ * the color.
+ */
+ KRITAIMAGE_EXPORT
+ void cutOneWay(const KoColor &color,
+ KisPaintDeviceSP src,
+ KisPaintDeviceSP colorScribble,
+ KisPaintDeviceSP backgroundScribble,
+ KisPaintDeviceSP resultDevice,
+ KisPaintDeviceSP maskDevice,
+ const QRect &boundingRect);
+
+ /**
+ * Returns one pixel from each connected component of \p src.
+ *
+ * WARNING: \p src is used as a temporary device, so it will be
+ * cleared(!) after the execution of the algorithm
+ */
+
+ KRITAIMAGE_EXPORT
+ QVector splitIntoConnectedComponents(KisPaintDeviceSP src, const QRect &boundingRect);
+
+ struct KRITAIMAGE_EXPORT KeyStroke : public boost::equality_comparable
+ {
+ KeyStroke();
+ KeyStroke(KisPaintDeviceSP _dev, const KoColor &_color, bool isTransparent = false);
+
+ friend bool operator==(const KeyStroke& t1, const KeyStroke&t2);
+
+ KisPaintDeviceSP dev;
+ KoColor color;
+ bool isTransparent;
+ };
+};
+
+#endif /* __KIS_LAZY_FILL_TOOLS_H */
diff --git a/libs/image/lazybrush/kis_lazy_fill_tools.cpp b/libs/image/lazybrush/kis_lazy_fill_tools.cpp
new file mode 100644
--- /dev/null
+++ b/libs/image/lazybrush/kis_lazy_fill_tools.cpp
@@ -0,0 +1,175 @@
+/*
+ * Copyright (c) 2016 Dmitry Kazakov
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+
+#include "kis_lazy_fill_tools.h"
+
+#include
+#include
+
+#include
+#include
+#include
+#include
+
+#include
+#include
+#include
+
+#include "lazybrush/kis_lazy_fill_graph.h"
+#include "lazybrush/kis_lazy_fill_capacity_map.h"
+
+#include "kis_sequential_iterator.h"
+#include
+
+#include "krita_utils.h"
+
+namespace KisLazyFillTools {
+
+void normalizeAndInvertAlpha8Device(KisPaintDeviceSP dev, const QRect &rect)
+{
+ quint8 maxPixel = std::numeric_limits::min();
+ quint8 minPixel = std::numeric_limits::max();
+ KritaUtils::applyToAlpha8Device(dev, rect,
+ [&minPixel, &maxPixel](quint8 pixel) {
+ if (pixel > maxPixel) {
+ maxPixel = pixel;
+ }
+ if (pixel < minPixel) {
+ minPixel = pixel;
+ }
+ });
+
+ const qreal scale = 255.0 / (maxPixel - minPixel);
+ KritaUtils::filterAlpha8Device(dev, rect,
+ [minPixel, scale](quint8 pixel) {
+ return pow2(255 - quint8((pixel - minPixel) * scale)) / 255;
+ });
+}
+
+void cutOneWay(const KoColor &color,
+ KisPaintDeviceSP src,
+ KisPaintDeviceSP colorScribble,
+ KisPaintDeviceSP backgroundScribble,
+ KisPaintDeviceSP resultDevice,
+ KisPaintDeviceSP maskDevice,
+ const QRect &boundingRect)
+{
+ using namespace boost;
+
+ KIS_ASSERT_RECOVER_RETURN(src->pixelSize() == 1);
+ KIS_ASSERT_RECOVER_RETURN(colorScribble->pixelSize() == 1);
+ KIS_ASSERT_RECOVER_RETURN(backgroundScribble->pixelSize() == 1);
+ KIS_ASSERT_RECOVER_RETURN(maskDevice->pixelSize() == 1);
+ KIS_ASSERT_RECOVER_RETURN(*resultDevice->colorSpace() == *color.colorSpace());
+
+ KisLazyFillCapacityMap capacityMap(src, colorScribble, backgroundScribble, maskDevice, boundingRect);
+ KisLazyFillGraph &graph = capacityMap.graph();
+
+ std::vector groups(num_vertices(graph));
+ std::vector residual_capacity(num_edges(graph), 0);
+
+ std::vector::vertices_size_type> distance_vec(num_vertices(graph), 0);
+ std::vector::edge_descriptor> predecessor_vec(num_vertices(graph));
+
+ auto vertexIndexMap = get(boost::vertex_index, graph);
+
+ typedef KisLazyFillGraph::vertex_descriptor Vertex;
+
+ Vertex s(Vertex::LABEL_A);
+ Vertex t(Vertex::LABEL_B);
+
+ float maxFlow =
+ boykov_kolmogorov_max_flow(graph,
+ capacityMap,
+ make_iterator_property_map(&residual_capacity[0], get(boost::edge_index, graph)),
+ get(boost::edge_reverse, graph),
+ make_iterator_property_map(&predecessor_vec[0], vertexIndexMap),
+ make_iterator_property_map(&groups[0], vertexIndexMap),
+ make_iterator_property_map(&distance_vec[0], vertexIndexMap),
+ vertexIndexMap,
+ s,
+ t);
+ Q_UNUSED(maxFlow);
+
+ KisSequentialIterator dstIt(resultDevice, graph.rect());
+ KisSequentialIterator mskIt(maskDevice, graph.rect());
+
+ const int pixelSize = resultDevice->pixelSize();
+
+ do {
+ KisLazyFillGraph::vertex_descriptor v(dstIt.x(), dstIt.y());
+ long vertex_idx = get(boost::vertex_index, graph, v);
+ default_color_type label = groups[vertex_idx];
+
+ if (label == black_color) {
+ memcpy(dstIt.rawData(), color.data(), pixelSize);
+ *mskIt.rawData() = 10 + (int(label) << 4);
+ }
+ } while (dstIt.nextPixel() && mskIt.nextPixel());
+}
+
+ QVector splitIntoConnectedComponents(KisPaintDeviceSP dev,
+ const QRect &boundingRect)
+{
+ QVector points;
+ const KoColorSpace *cs = dev->colorSpace();
+
+ const QRect rect = dev->exactBounds() & boundingRect;
+ if (rect.isEmpty()) return points;
+
+ /**
+ * Please note that since we modify the device inside
+ * clearNonZeroComponent() call, we must use a *writable*
+ * iterator, for not ending up with a lazy copied old version of a
+ * device.
+ */
+ KisSequentialIterator dstIt(dev, rect);
+
+ do {
+ if (cs->opacityU8(dstIt.rawData()) > 0) {
+ const QPoint pt(dstIt.x(), dstIt.y());
+ points << pt;
+
+ KisScanlineFill fill(dev, pt, rect);
+ fill.clearNonZeroComponent();
+ }
+ } while (dstIt.nextPixel());
+
+ return points;
+}
+
+
+KeyStroke::KeyStroke()
+ : isTransparent(false)
+{
+}
+
+KeyStroke::KeyStroke(KisPaintDeviceSP _dev, const KoColor &_color, bool _isTransparent)
+ : dev(_dev), color(_color), isTransparent(_isTransparent)
+{
+}
+
+bool operator==(const KeyStroke& t1, const KeyStroke&t2)
+{
+ return
+ t1.dev == t2.dev &&
+ t1.color == t2.color &&
+ t1.isTransparent == t2.isTransparent;
+}
+
+}
diff --git a/libs/ui/tests/kis_kra_saver_test.h b/libs/image/lazybrush/kis_min_cut_worker.h
copy from libs/ui/tests/kis_kra_saver_test.h
copy to libs/image/lazybrush/kis_min_cut_worker.h
--- a/libs/ui/tests/kis_kra_saver_test.h
+++ b/libs/image/lazybrush/kis_min_cut_worker.h
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2007 Boudewijn Rempt boud@valdyas.org
+ * Copyright (c) 2016 Dmitry Kazakov
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
@@ -16,29 +16,21 @@
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
-#ifndef KIS_KRA_SAVER_TEST_H
-#define KIS_KRA_SAVER_TEST_H
+#ifndef __KIS_MIN_CUT_WORKER_H
+#define __KIS_MIN_CUT_WORKER_H
-#include
+#include
-class KisKraSaverTest : public QObject
-{
- Q_OBJECT
-private Q_SLOTS:
-
- void initTestCase();
-
- // XXX: Also test roundtripping of metadata
- void testRoundTrip();
- void testSaveEmpty();
- void testRoundTripFillLayerColor();
- void testRoundTripFillLayerPattern();
-
- void testRoundTripLayerStyles();
-
- void testRoundTripAnimation();
+class KisMinCutWorker
+{
+public:
+ KisMinCutWorker();
+ ~KisMinCutWorker();
+private:
+ struct Private;
+ const QScopedPointer m_d;
};
-#endif
+#endif /* __KIS_MIN_CUT_WORKER_H */
diff --git a/libs/ui/tests/kis_kra_saver_test.h b/libs/image/lazybrush/kis_min_cut_worker.cpp
copy from libs/ui/tests/kis_kra_saver_test.h
copy to libs/image/lazybrush/kis_min_cut_worker.cpp
--- a/libs/ui/tests/kis_kra_saver_test.h
+++ b/libs/image/lazybrush/kis_min_cut_worker.cpp
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2007 Boudewijn Rempt boud@valdyas.org
+ * Copyright (c) 2016 Dmitry Kazakov
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
@@ -16,29 +16,17 @@
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
-#ifndef KIS_KRA_SAVER_TEST_H
-#define KIS_KRA_SAVER_TEST_H
+#include "kis_min_cut_worker.h"
-#include
-
-class KisKraSaverTest : public QObject
+struct KisMinCutWorker::Private
{
- Q_OBJECT
-private Q_SLOTS:
-
- void initTestCase();
-
- // XXX: Also test roundtripping of metadata
- void testRoundTrip();
-
- void testSaveEmpty();
- void testRoundTripFillLayerColor();
- void testRoundTripFillLayerPattern();
-
- void testRoundTripLayerStyles();
-
- void testRoundTripAnimation();
-
};
-#endif
+KisMinCutWorker::KisMinCutWorker()
+ : m_d(new Private)
+{
+}
+
+KisMinCutWorker::~KisMinCutWorker()
+{
+}
diff --git a/plugins/extensions/offsetimage/kis_offset_processing_visitor.h b/libs/image/lazybrush/kis_multiway_cut.h
copy from plugins/extensions/offsetimage/kis_offset_processing_visitor.h
copy to libs/image/lazybrush/kis_multiway_cut.h
--- a/plugins/extensions/offsetimage/kis_offset_processing_visitor.h
+++ b/libs/image/lazybrush/kis_multiway_cut.h
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2013 Lukáš Tvrdý
+ * Copyright (c) 2016 Dmitry Kazakov
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
@@ -16,24 +16,34 @@
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
-#ifndef __KIS_OFFSET_PROCESSING_VISITOR_H
-#define __KIS_OFFSET_PROCESSING_VISITOR_H
+#ifndef __KIS_MULTIWAY_CUT_H
+#define __KIS_MULTIWAY_CUT_H
-#include "processing/kis_simple_processing_visitor.h"
-#include
+#include
+#include "kis_types.h"
+#include "kritaimage_export.h"
-class KisOffsetProcessingVisitor : public KisSimpleProcessingVisitor
+class KoColor;
+
+class KRITAIMAGE_EXPORT KisMultiwayCut
{
public:
- KisOffsetProcessingVisitor(const QPoint &offsetPoint, const QRect &wrapRect);
+ KisMultiwayCut(KisPaintDeviceSP src,
+ KisPaintDeviceSP dst,
+ const QRect &boundingRect);
+ ~KisMultiwayCut();
+
+ void addKeyStroke(KisPaintDeviceSP dev, const KoColor &color);
+
+ void run();
- void visitNodeWithPaintDevice(KisNode *node, KisUndoAdapter *undoAdapter);
- void visitExternalLayer(KisExternalLayer *layer, KisUndoAdapter *undoAdapter);
+ KisPaintDeviceSP srcDevice() const;
+ KisPaintDeviceSP dstDevice() const;
private:
- QPoint m_offset;
- QRect m_wrapRect;
+ struct Private;
+ const QScopedPointer m_d;
};
-#endif /* __KIS_OFFSET_PROCESSING_VISITOR_H */
+#endif /* __KIS_MULTIWAY_CUT_H */
diff --git a/libs/image/lazybrush/kis_multiway_cut.cpp b/libs/image/lazybrush/kis_multiway_cut.cpp
new file mode 100644
--- /dev/null
+++ b/libs/image/lazybrush/kis_multiway_cut.cpp
@@ -0,0 +1,137 @@
+/*
+ * Copyright (c) 2016 Dmitry Kazakov
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+
+#include "kis_multiway_cut.h"
+
+#include
+#include
+#include
+
+#include "kis_paint_device.h"
+#include "kis_painter.h"
+#include "kis_lazy_fill_tools.h"
+#include "kis_sequential_iterator.h"
+#include
+
+
+using namespace KisLazyFillTools;
+
+struct KisMultiwayCut::Private
+{
+ KisPaintDeviceSP src;
+ KisPaintDeviceSP dst;
+ KisPaintDeviceSP mask;
+ QRect boundingRect;
+
+ QVector keyStrokes;
+
+ static void maskOutKeyStroke(KisPaintDeviceSP keyStrokeDevice, KisPaintDeviceSP mask, const QRect &boundingRect);
+};
+
+KisMultiwayCut::KisMultiwayCut(KisPaintDeviceSP src,
+ KisPaintDeviceSP dst,
+ const QRect &boundingRect)
+ : m_d(new Private)
+{
+ m_d->src = src;
+ m_d->dst = dst;
+ m_d->mask = new KisPaintDevice(KoColorSpaceRegistry::instance()->alpha8());
+ m_d->boundingRect = boundingRect;
+}
+
+KisMultiwayCut::~KisMultiwayCut()
+{
+}
+
+void KisMultiwayCut::addKeyStroke(KisPaintDeviceSP dev, const KoColor &color)
+{
+ m_d->keyStrokes << KeyStroke(dev, color);
+}
+
+
+void KisMultiwayCut::Private::maskOutKeyStroke(KisPaintDeviceSP keyStrokeDevice, KisPaintDeviceSP mask, const QRect &boundingRect)
+{
+ KIS_ASSERT_RECOVER_RETURN(keyStrokeDevice->pixelSize() == 1);
+ KIS_ASSERT_RECOVER_RETURN(mask->pixelSize() == 1);
+
+ QRegion region =
+ keyStrokeDevice->region() &
+ mask->exactBounds() & boundingRect;
+
+ Q_FOREACH (const QRect &rc, region.rects()) {
+ KisSequentialIterator dstIt(keyStrokeDevice, rc);
+ KisSequentialConstIterator mskIt(mask, rc);
+
+ do {
+ if (*mskIt.rawDataConst() > 0) {
+ *dstIt.rawData() = 0;
+ }
+ } while (dstIt.nextPixel() && mskIt.nextPixel());
+ }
+}
+
+void KisMultiwayCut::run()
+{
+ KisPaintDeviceSP other = new KisPaintDevice(KoColorSpaceRegistry::instance()->alpha8());
+
+ while (m_d->keyStrokes.size() > 1) {
+ KeyStroke current = m_d->keyStrokes.takeFirst();
+ KisPainter gc(other);
+
+ Q_FOREACH (const KeyStroke &s, m_d->keyStrokes) {
+ const QRect rc = s.dev->extent() & m_d->boundingRect;
+ gc.bitBlt(rc.topLeft(), s.dev, rc);
+ }
+
+ KisLazyFillTools::cutOneWay(current.color,
+ m_d->src,
+ current.dev,
+ other,
+ m_d->dst,
+ m_d->mask,
+ m_d->boundingRect);
+
+ other->clear();
+ }
+
+ // TODO: check if one can use the last cut for this purpose!
+
+ if (m_d->keyStrokes.size() == 1) {
+ KeyStroke current = m_d->keyStrokes.takeLast();
+
+ m_d->maskOutKeyStroke(current.dev, m_d->mask, m_d->boundingRect);
+
+ QVector points =
+ KisLazyFillTools::splitIntoConnectedComponents(current.dev, m_d->boundingRect);
+
+ Q_FOREACH (const QPoint &pt, points) {
+ KisScanlineFill fill(m_d->mask, pt, m_d->boundingRect);
+ fill.fillColor(current.color, m_d->dst);
+ }
+ }
+}
+
+KisPaintDeviceSP KisMultiwayCut::srcDevice() const
+{
+ return m_d->src;
+}
+
+KisPaintDeviceSP KisMultiwayCut::dstDevice() const
+{
+ return m_d->dst;
+}
diff --git a/libs/image/metadata/kis_exif_info_visitor.h b/libs/image/metadata/kis_exif_info_visitor.h
--- a/libs/image/metadata/kis_exif_info_visitor.h
+++ b/libs/image/metadata/kis_exif_info_visitor.h
@@ -53,6 +53,9 @@
bool visit(KisSelectionMask*) {
return true;
}
+ bool visit(KisColorizeMask*) {
+ return true;
+ }
bool visit(KisExternalLayer*) {
return true;
}
diff --git a/libs/image/processing/kis_crop_processing_visitor.h b/libs/image/processing/kis_crop_processing_visitor.h
--- a/libs/image/processing/kis_crop_processing_visitor.h
+++ b/libs/image/processing/kis_crop_processing_visitor.h
@@ -21,6 +21,7 @@
#include "kis_simple_processing_visitor.h"
#include
+#include "kis_types.h"
class KRITAIMAGE_EXPORT KisCropProcessingVisitor : public KisSimpleProcessingVisitor
@@ -35,10 +36,12 @@
public:
void visit(KisTransformMask *mask, KisUndoAdapter *undoAdapter);
+ void visitColorizeMask(KisColorizeMask *mask, KisUndoAdapter *undoAdapter);
using KisSimpleProcessingVisitor::visit;
private:
void moveNodeImpl(KisNode *node, KisUndoAdapter *undoAdapter);
+ void cropPaintDeviceImpl(KisPaintDeviceSP device, KisUndoAdapter *undoAdapter);
private:
QRect m_rect;
diff --git a/libs/image/processing/kis_crop_processing_visitor.cpp b/libs/image/processing/kis_crop_processing_visitor.cpp
--- a/libs/image/processing/kis_crop_processing_visitor.cpp
+++ b/libs/image/processing/kis_crop_processing_visitor.cpp
@@ -29,6 +29,7 @@
#include "kis_transaction.h"
#include "kis_undo_adapter.h"
#include "kis_transform_mask.h"
+#include "lazybrush/kis_colorize_mask.h"
KisCropProcessingVisitor::KisCropProcessingVisitor(const QRect &rect, bool cropLayers, bool moveLayers)
@@ -55,24 +56,39 @@
}
}
-void KisCropProcessingVisitor::visitNodeWithPaintDevice(KisNode *node, KisUndoAdapter *undoAdapter)
+void KisCropProcessingVisitor::cropPaintDeviceImpl(KisPaintDeviceSP device, KisUndoAdapter *undoAdapter)
{
/**
* TODO: implement actual robust cropping of the selections,
* including the cropping of vector (!) selection.
*/
if (m_cropLayers) {
- KisTransaction transaction(kundo2_noi18n("crop"), node->paintDevice());
- node->paintDevice()->crop(m_rect);
+ KisTransaction transaction(kundo2_noi18n("crop"), device);
+ device->crop(m_rect);
transaction.commit(undoAdapter);
}
+}
+void KisCropProcessingVisitor::visitNodeWithPaintDevice(KisNode *node, KisUndoAdapter *undoAdapter)
+{
+ cropPaintDeviceImpl(node->paintDevice(), undoAdapter);
moveNodeImpl(node, undoAdapter);
}
void KisCropProcessingVisitor::visit(KisTransformMask *node, KisUndoAdapter *undoAdapter)
{
moveNodeImpl(node, undoAdapter);
KisSimpleProcessingVisitor::visit(node, undoAdapter);
}
+
+void KisCropProcessingVisitor::visitColorizeMask(KisColorizeMask *node, KisUndoAdapter *undoAdapter)
+{
+ QVector devices = node->allPaintDevices();
+
+ Q_FOREACH (KisPaintDeviceSP device, devices) {
+ cropPaintDeviceImpl(device, undoAdapter);
+ }
+
+ moveNodeImpl(node, undoAdapter);
+}
diff --git a/libs/image/processing/kis_do_nothing_processing_visitor.h b/libs/image/processing/kis_do_nothing_processing_visitor.h
--- a/libs/image/processing/kis_do_nothing_processing_visitor.h
+++ b/libs/image/processing/kis_do_nothing_processing_visitor.h
@@ -38,6 +38,7 @@
void visit(KisTransformMask *mask, KisUndoAdapter *undoAdapter);
void visit(KisTransparencyMask *mask, KisUndoAdapter *undoAdapter);
void visit(KisSelectionMask *mask, KisUndoAdapter *undoAdapter);
+ void visit(KisColorizeMask *mask, KisUndoAdapter *undoAdapter);
};
#endif /* __KIS_DO_NOTHING_PROCESSING_VISITOR_H */
diff --git a/libs/image/processing/kis_do_nothing_processing_visitor.cpp b/libs/image/processing/kis_do_nothing_processing_visitor.cpp
--- a/libs/image/processing/kis_do_nothing_processing_visitor.cpp
+++ b/libs/image/processing/kis_do_nothing_processing_visitor.cpp
@@ -96,3 +96,9 @@
Q_UNUSED(mask);
Q_UNUSED(undoAdapter);
}
+
+void KisDoNothingProcessingVisitor::visit(KisColorizeMask *mask, KisUndoAdapter *undoAdapter)
+{
+ Q_UNUSED(mask);
+ Q_UNUSED(undoAdapter);
+}
diff --git a/libs/image/processing/kis_mirror_processing_visitor.h b/libs/image/processing/kis_mirror_processing_visitor.h
--- a/libs/image/processing/kis_mirror_processing_visitor.h
+++ b/libs/image/processing/kis_mirror_processing_visitor.h
@@ -21,6 +21,7 @@
#include "kis_simple_processing_visitor.h"
#include
+#include "kis_types.h"
class KRITAIMAGE_EXPORT KisMirrorProcessingVisitor : public KisSimpleProcessingVisitor
@@ -32,6 +33,11 @@
void visitNodeWithPaintDevice(KisNode *node, KisUndoAdapter *undoAdapter);
void visitExternalLayer(KisExternalLayer *layer, KisUndoAdapter *undoAdapter);
+ void visitColorizeMask(KisColorizeMask *node, KisUndoAdapter *undoAdapter);
+
+private:
+ void transformPaintDevice(KisPaintDeviceSP device, KisUndoAdapter *undoAdapter);
+
QRect m_bounds;
Qt::Orientation m_orientation;
};
diff --git a/libs/image/processing/kis_mirror_processing_visitor.cpp b/libs/image/processing/kis_mirror_processing_visitor.cpp
--- a/libs/image/processing/kis_mirror_processing_visitor.cpp
+++ b/libs/image/processing/kis_mirror_processing_visitor.cpp
@@ -24,28 +24,33 @@
#include "kis_image.h"
#include "kis_transform_worker.h"
+#include "lazybrush/kis_colorize_mask.h"
#include "processing/kis_transform_processing_visitor.h"
KisMirrorProcessingVisitor::KisMirrorProcessingVisitor(const QRect &bounds, Qt::Orientation orientation)
: m_bounds(bounds), m_orientation(orientation)
{
}
-void KisMirrorProcessingVisitor::visitNodeWithPaintDevice(KisNode *node, KisUndoAdapter *undoAdapter)
+void KisMirrorProcessingVisitor::transformPaintDevice(KisPaintDeviceSP device, KisUndoAdapter *undoAdapter)
{
- KisPaintDeviceSP dev = node->paintDevice();
- KisTransaction transaction(dev);
+ KisTransaction transaction(device);
qreal axis = m_orientation == Qt::Horizontal ?
m_bounds.x() + 0.5 * m_bounds.width() :
m_bounds.y() + 0.5 * m_bounds.height();
- KisTransformWorker::mirror(dev, axis, m_orientation);
-
+ KisTransformWorker::mirror(device, axis, m_orientation);
transaction.commit(undoAdapter);
}
+void KisMirrorProcessingVisitor::visitNodeWithPaintDevice(KisNode *node, KisUndoAdapter *undoAdapter)
+{
+ transformPaintDevice(node->paintDevice(), undoAdapter);
+
+}
+
void KisMirrorProcessingVisitor::visitExternalLayer(KisExternalLayer *layer, KisUndoAdapter *undoAdapter)
{
if (m_orientation == Qt::Horizontal) {
@@ -64,3 +69,12 @@
visitor.visit(layer, undoAdapter);
}
}
+
+void KisMirrorProcessingVisitor::visitColorizeMask(KisColorizeMask *node, KisUndoAdapter *undoAdapter)
+{
+ QVector devices = node->allPaintDevices();
+
+ Q_FOREACH (KisPaintDeviceSP device, devices) {
+ transformPaintDevice(device, undoAdapter);
+ }
+}
diff --git a/libs/image/processing/kis_simple_processing_visitor.h b/libs/image/processing/kis_simple_processing_visitor.h
--- a/libs/image/processing/kis_simple_processing_visitor.h
+++ b/libs/image/processing/kis_simple_processing_visitor.h
@@ -38,10 +38,12 @@
void visit(KisTransformMask *mask, KisUndoAdapter *undoAdapter);
void visit(KisTransparencyMask *mask, KisUndoAdapter *undoAdapter);
void visit(KisSelectionMask *mask, KisUndoAdapter *undoAdapter);
+ void visit(KisColorizeMask *mask, KisUndoAdapter *undoAdapter);
protected:
virtual void visitNodeWithPaintDevice(KisNode *node, KisUndoAdapter *undoAdapter) = 0;
virtual void visitExternalLayer(KisExternalLayer *layer, KisUndoAdapter *undoAdapter) = 0;
+ virtual void visitColorizeMask(KisColorizeMask *mask, KisUndoAdapter *undoAdapter) = 0;
};
#endif /* __KIS_SIMPLE_PROCESSING_VISITOR_H */
diff --git a/libs/image/processing/kis_simple_processing_visitor.cpp b/libs/image/processing/kis_simple_processing_visitor.cpp
--- a/libs/image/processing/kis_simple_processing_visitor.cpp
+++ b/libs/image/processing/kis_simple_processing_visitor.cpp
@@ -107,3 +107,8 @@
{
visitNodeWithPaintDevice(mask, undoAdapter);
}
+
+void KisSimpleProcessingVisitor::visit(KisColorizeMask *mask, KisUndoAdapter *undoAdapter)
+{
+ visitColorizeMask(mask, undoAdapter);
+}
diff --git a/libs/image/processing/kis_transform_processing_visitor.h b/libs/image/processing/kis_transform_processing_visitor.h
--- a/libs/image/processing/kis_transform_processing_visitor.h
+++ b/libs/image/processing/kis_transform_processing_visitor.h
@@ -50,6 +50,7 @@
void visit(KisTransformMask *mask, KisUndoAdapter *undoAdapter);
void visit(KisTransparencyMask *mask, KisUndoAdapter *undoAdapter);
void visit(KisSelectionMask *mask, KisUndoAdapter *undoAdapter);
+ void visit(KisColorizeMask *mask, KisUndoAdapter *undoAdapter);
private:
void transformClones(KisLayer *layer, KisUndoAdapter *undoAdapter);
diff --git a/libs/image/processing/kis_transform_processing_visitor.cpp b/libs/image/processing/kis_transform_processing_visitor.cpp
--- a/libs/image/processing/kis_transform_processing_visitor.cpp
+++ b/libs/image/processing/kis_transform_processing_visitor.cpp
@@ -35,6 +35,7 @@
#include "kis_filter_mask.h"
#include "kis_transform_mask.h"
#include "kis_selection_mask.h"
+#include "lazybrush/kis_colorize_mask.h"
#include "kis_external_layer_iface.h"
@@ -148,6 +149,15 @@
transformSelection(mask->selection(), undoAdapter, ProgressHelper(mask));
}
+void KisTransformProcessingVisitor::visit(KisColorizeMask *mask, KisUndoAdapter *undoAdapter)
+{
+ QVector devices = mask->allPaintDevices();
+
+ Q_FOREACH (KisPaintDeviceSP device, devices) {
+ transformPaintDevice(device, undoAdapter, ProgressHelper(mask));
+ }
+}
+
void KisTransformProcessingVisitor::transformClones(KisLayer *layer, KisUndoAdapter *undoAdapter)
{
QList clones = layer->registeredClones();
diff --git a/libs/image/tests/CMakeLists.txt b/libs/image/tests/CMakeLists.txt
--- a/libs/image/tests/CMakeLists.txt
+++ b/libs/image/tests/CMakeLists.txt
@@ -688,3 +688,14 @@
kde4_add_unit_test(KisAslParserTest TESTNAME kritalibpsd-asl_parser_test ${kis_asl_parser_test_SRCS})
target_link_libraries(KisAslParserTest kritapsd kritapigment kritawidgetutils ${QT_QTXML_LIBRARY} Qt5::Test)
+########### next target ###############
+
+set(kis_lazy_brush_test_SRCS kis_lazy_brush_test.cpp )
+kde4_add_unit_test(KisLazyBrushTest TESTNAME kritaimage-lazy_brush_test ${kis_lazy_brush_test_SRCS})
+target_link_libraries(KisLazyBrushTest kritaimage ${QT_QTTEST_LIBRARY})
+
+########### next target ###############
+
+set(kis_colorize_mask_test_SRCS kis_colorize_mask_test.cpp )
+kde4_add_unit_test(KisColorizeMaskTest TESTNAME kritaimage-colorize_mask_test ${kis_colorize_mask_test_SRCS})
+target_link_libraries(KisColorizeMaskTest kritaimage ${QT_QTTEST_LIBRARY})
diff --git a/libs/image/tests/data/fill1_a.png b/libs/image/tests/data/fill1_a.png
new file mode 100644
index 0000000000000000000000000000000000000000..a405589fec9a2b8b91289ad668371911eeaea40c
GIT binary patch
literal 1363
zc$}S->pK$)0LI5?GcC+y2op|3YS?i(F3()XFln|?xo#GjiM2H)U6zSsBITNpvF4Io
zQXL1aW6kI!s?%lmWYUFBm?PSea`Z2p55M30Jnx71<696B9t4G$LI3~&6c-#o*vOo3(
z@RD$Decha4Xx30
z9LbU71J@$l1|VxcVV)a(tg|uQ+UQGDI;oHll@U9d19BG#hIk{-E-3V!sj=xE1GC|&
zL@krznneL~8WnL7@y_Q41FYIQHdZuAJk%CgmFdL~Plaol01utDEm$OS9Ygp9GY25v
zHREJ^d4)@DYs`bu8N~|kJ*H%H<-UaTE5}H*)VL~wX@pSTJN1<*t+pU}Oh-Z}Z!smM
z@(G@u8<})_zInpb2CM6S5iudQOl7n(vC}`hSnuV+8}#G(Ou=@Pa61Z;BXQS$jrE_@
zEo<}UWjiz#I=!za?$XdBwOEMyuUa6nm1r*Frj5i!TP-|PvIO7lN#cY#SnrhMcZKrz
z@bs$D)huJ~a*C=|6WzX*higX?lKh%daeiJz(c?7`YKx7unkj&!*@sr!SMcEH)*i~t
z%Tge92>myS`?ExV_~PDXs4{kh(l}GXO<%3y_BALfi#>O43Y&uVbfG=0bJf{OM?LRT
zsq>Zlj7j5doyeij2Mc53%+}%pDY*b&Jngxx5Sf^XkShXdvYJ!zpQiXoS#!t}vTJgh
z<`F{GA4}ve>D%0F*!Fyby47W75O^{6w}uvHBcUpk>4&o7T%N6^{rS{eJ7#Q&Y01eY
zt!Ca5Kq!6W+FQd0&EV2uoo*Nf(?stY0w5|{xQgMH;K&$hvOn}nXiyxO4#$$9(^
z)}6a-4{FdQ_2IZsQpmZ)lgA7sDRynwKVKVGe@J`^Y9D<-hb$lbS3Zhoxi!0^BSpy&
zb%&FEMvtpk83Ns#{ATy86Oaf4b%{8%3l1X}o`|PbQ5X)0Hw#{HRms`90Dq1gx
zkR5twCsuRR&J#K8cx~^=3cDWqtIT0=$p{m*`8d?WHvcnOllO$(*!D8=Ji9)YM29Oh
z`tN-`ad5#_@cXN)ggnLg<1uL7u$R_4%3obqwBCyBw3{9&T@=Mw?QktKek4Lmxr()V
zgkHgYt2uh{7Hg~(XyHZ{<4h8qw?~Sg@=^a+3ZK(J`j>)DHg{f{XE
z)7O>#0S6O5CtI;dwkA+Wvcxr_#5q4VH#M(>!MP|ku_QG`p**uBL&4qCHz2%`Pn>~)
zImy$-F{I+w+ZmC;!j2+t=Y85#l^CbU9_0Pv`Tu|X#Z4k>ghaR}sOsE2Hhq0}bTDI0
zgT&eLRm-e4t1y56@^;_dgdW3V63J8}W*nT%`|y78<@+IFQQVadjL8nZx>?=|?7Mbd
zW39@verUsWN;`LD`aj8uH{)ya`Ft2AA5h*}nhS(%vPS#;y23EuB}#FaM#QKyvT=bZ7U^tn{#EwC*6=b=J{`7Yf9DeEk+MT
zKk!v>@8K}|?H1osd&f*&5Gdi`2e*LjnjTFw)=k?VDaY!OEdbKQ$SJA$&Q;EveG!-?89ZJ6T-G@yGywo?%dyb_
literal 0
Hc$@sD^4N3lR|`B5e^PixPSfkRV+`lP;kN3NF1j={+J%KuSQ0p(9m9
zHkT%XL^>$d2&i=ZhJBvzuY2>%nUhTBoSAul<(-K$G|*ya5nzEpAnZEY>PF!1aC*TR
zLG87eX$)@6UfLE9AP`pW(~Az0_Y?^lnS6EhHJIk%P;MwPWPBnMH1YdtnER@E5(thS
zz7RDZM>}6f2h<~1Ul){?j=rH;7{^%%1i_%Au43#zy@kK~VA}L7UKJXbfJOCDq7l@%
zE%~pvE}onZ+ML_CJ9j9e7_`d&9={A^__a19-M#@gT
z8MAPvb^M&Zi>fxQ;%%N0+}*w~AL_Lf>V<9g#$r&PFeo8}hY*4Te(m4F6e-9QN#FB?
zzK3q%4c)@OJ^x4NroZjR2+CF@)6F_7sgL)=QCJ?0pF$9ritTVqhZdGEfgx+?f>Q%O
z_yX$ByVpStTEG<4aq3FK1NL=Yfj5~TZ|m7`JPUhA*D=3&QYPH``GVwfZIy(3y@eh=
z)f3Or6ZgWOP3VU%cp+^U+N=vk04Hi@dNj8zwfGe)F{G2awPj-}aGO|WoX
z`DrWD<%NkPP*?YkUP`j|E+8VhAtj^m^g-D88V`6=g)xh>v-AE+w#|sU0%t;h;f5kx
zZ>Sw|#P5$$7oPZHu#C>JM^pB7p&PAWY@-hA7)Og$Uqu;x?lRY6>Q)b#@cr=(Oj5+C
zOXQmGyPm8v*ZrSV&+Xnb%3XeVm%L~Pxj1))gp-q?<=p^>1`Dxt9d%Jo?X*6#poDAx
ze0iW(ekW1$Jo%s$tcRCm%DVMX5Y*t+bF^Oa*45!cD<~vc_(u3f>;77K0cuE2G!?$M
zjgiY`o8D589O`kA2Y+dokH>13d^-aP1xlB`w*?APXlqy6YuB!^e`9f5jS<
zM-YjEV6J?{ZlXp-M`%pdV@^~YmSatz9m$pbmVUlMTvA`Yih
zcC@(9=B}7;FPAIBg$XyQ;9-^fFlU6q&;J+Pb#Hx^`)O-R+8;&Wca2EE*c_
z#z7N&Ofp1w(e{3q8t^~S%%M23p&pAAcik*FGwSkPIr9!+O@g?Ync0iU4RrPp8)7H1
z+ctF20a`J+Q8yjI_p3(mK|=rHf1o~!`91ZLjGI0!4t{ayc!UOLW#zAn=xx9>7kO2%
z$PR0*QX`cXD@{;HrfO9aJ%B9!N=|+S@JNmiO`WI;
zVmjgIcsLB2;>ZukngrnAUWZi9WraMaY+;wp^4?X287{&hsdC@X7~jD|W|08!ny
z_AYPMPPhVxvR(sm2I9?f{Mm|*4^i>w&X{nEvaV&q@f4w1!n;v_!=Q9xTyet^gUJK;
z8mR>1Dw7P|3&()+=uF+_)>hRfs-uImnL`>mfc^?uOvl}f2}&1R9NWXw`#(C_JsZA?s*S>vK=b}7Vb{y)}vpDBlQ@|C%e9%@`rL7)ha
z>B9=qEZnRmqiAln*9V^k_XBSNU!&!fH%NsWQO}0IJV+e4ms1vJh>moTe+Mz+
zVE_n*Vdv9f5pcbdQEaJEHz0#`yMLG^iOg3<*5LGX;L_maib~NI3s)Bn1I1U79Y2{m
z=#ZjYYKvq9E>?_2^Cf&c2=xEC$C~lFg8Lk{
z?SGtJbsMN5y7ycjMf{$zv`wcv7`AQZjf0%s&N!hZuQ)Qppxh40XjH*7wkBWyQ4-k3
zsvmw5_}mBkU%ra{**3wE*Jtp6Faa}-6Ezl_Tgdm@E0{nzTRKIZURSh
zSGZ?%;;x`pK5jwfCth48fgB(K1Tth+WC*XUoV_KzZ9U+t80DIGx(1-t-7mv9lBxHD
z2NA)qhkM@FJXJ}&GwH{}!XP9pytup!8#A*BigH(A#ZMNwPET`m5OBxA%JTa63Jr%Q
zFEbe;sSk0mMGA#|wml$1U9`KWL~>}a%=Y`bZ{wiQfJ*szcYi;_t@%@90BM6j{foam
zoARzc5u^mwqR{d2J5TfT7q*uMQl2RVK=sFwq@c6uj{MPfwl@nJYO