void KisFeatherSelectionFilter::process(KisPixelSelectionSP pixelSelection, const QRect& rect)
{
// compute horizontal kernel
const uint kernelSize = m_radius * 2 + 1;
Matrix<qreal, Dynamic, Dynamic> gaussianMatrix(1, kernelSize);
const qreal multiplicand = 1 / (2 * M_PI * m_radius * m_radius);
const qreal exponentMultiplicand = 1 / (2 * m_radius * m_radius);
for (uint x = 0; x < kernelSize; x++) {
uint xDistance = qAbs((int)m_radius - (int)x);
gaussianMatrix(0, x) = multiplicand * exp( -(qreal)((xDistance * xDistance) + (m_radius * m_radius)) * exponentMultiplicand );
}
KisConvolutionKernelSP kernelHoriz = KisConvolutionKernel::fromMatrix(gaussianMatrix, 0, gaussianMatrix.sum());
KisConvolutionKernelSP kernelVertical = KisConvolutionKernel::fromMatrix(gaussianMatrix.transpose(), 0, gaussianMatrix.sum());
KisPaintDeviceSP interm = new KisPaintDevice(pixelSelection->colorSpace());
KisConvolutionPainter horizPainter(interm);
horizPainter.setChannelFlags(interm->colorSpace()->channelFlags(false, true));
horizPainter.applyMatrix(kernelHoriz, pixelSelection, rect.topLeft(), rect.topLeft(), rect.size(), BORDER_REPEAT);
horizPainter.end();
KisConvolutionPainter verticalPainter(pixelSelection);
verticalPainter.setChannelFlags(pixelSelection->colorSpace()->channelFlags(false, true));
verticalPainter.applyMatrix(kernelVertical, interm, rect.topLeft(), rect.topLeft(), rect.size(), BORDER_REPEAT);
verticalPainter.end();
}
void KisFillPainterTest::benchmarkFillingScanlineSelection()
{
const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
KisPaintDeviceSP dev = new KisPaintDevice(cs);
QImage srcImage(TestUtil::fetchDataFileLazy("heavy_labyrinth.png"));
QVERIFY(!srcImage.isNull());
QRect imageRect = srcImage.rect();
dev->convertFromQImage(srcImage, 0, 0, 0);
KisPixelSelectionSP pixelSelection = new KisPixelSelection();
QBENCHMARK_ONCE {
KisScanlineFill gc(dev, QPoint(), imageRect);
gc.setThreshold(THRESHOLD);
gc.fillSelection(pixelSelection);
}
QImage resultImage =
pixelSelection->convertToQImage(0,
imageRect.x(), imageRect.y(),
imageRect.width(), imageRect.height());
QVERIFY(TestUtil::checkQImage(resultImage,
"fill_painter",
"scanline_",
"heavy_labyrinth_top_left_selection"));
}
bool KisKraLoadVisitor::loadSelection(const QString& location, KisSelectionSP dstSelection)
{
// Pixel selection
bool result = true;
QString pixelSelectionLocation = location + DOT_PIXEL_SELECTION;
if (m_store->hasFile(pixelSelectionLocation)) {
KisPixelSelectionSP pixelSelection = dstSelection->pixelSelection();
result = loadPaintDevice(pixelSelection, pixelSelectionLocation);
if (!result) {
m_errorMessages << i18n("Could not load raster selection %1.", location);
}
pixelSelection->invalidateOutlineCache();
}
// Shape selection
QString shapeSelectionLocation = location + DOT_SHAPE_SELECTION;
if (m_store->hasFile(shapeSelectionLocation + "/content.xml")) {
m_store->pushDirectory();
m_store->enterDirectory(shapeSelectionLocation) ;
KisShapeSelection* shapeSelection = new KisShapeSelection(m_image, dstSelection);
dstSelection->setShapeSelection(shapeSelection);
result = shapeSelection->loadSelection(m_store);
m_store->popDirectory();
if (!result) {
m_errorMessages << i18n("Could not load vector selection %1.", location);
}
}
return result;
}
void KisSelectionToolHelper::addSelectionShape(KoShape* shape)
{
KisView2* view = m_canvas->view();
/**
* Mark a shape that it belongs to a shape selection
*/
if(!shape->userData()) {
shape->setUserData(new KisShapeSelectionMarker);
}
KisUndoAdapter *undoAdapter = view->image()->undoAdapter();
undoAdapter->beginMacro(m_name);
if (!view->selection()) {
undoAdapter->addCommand(new KisSetEmptyGlobalSelectionCommand(m_image));
}
KisPixelSelectionSP pixelSelection = view->selection()->pixelSelection();
KisSelectionTransaction transaction(m_name, pixelSelection);
pixelSelection->clear();
transaction.commit(undoAdapter);
undoAdapter->addCommand(m_canvas->shapeController()->addShape(shape));
undoAdapter->endMacro();
}
void KisSelectionToolHelper::addSelectionShapes(QList< KoShape* > shapes)
{
KisViewManager* view = m_canvas->viewManager();
if (view->image()->wrapAroundModePermitted()) {
view->showFloatingMessage(
i18n("Shape selection does not fully "
"support wraparound mode. Please "
"use pixel selection instead"),
KisIconUtils::loadIcon("selection-info"));
}
KisProcessingApplicator applicator(view->image(),
0 /* we need no automatic updates */,
KisProcessingApplicator::NONE,
KisImageSignalVector() << ModifiedSignal,
m_name);
applicator.applyCommand(new LazyInitGlobalSelection(view));
struct ClearPixelSelection : public KisTransactionBasedCommand {
ClearPixelSelection(KisViewManager *view) : m_view(view) {}
KisViewManager *m_view;
KUndo2Command* paint() {
KisPixelSelectionSP pixelSelection = m_view->selection()->pixelSelection();
KIS_ASSERT_RECOVER(pixelSelection) { return 0; }
KisSelectionTransaction transaction(pixelSelection);
pixelSelection->clear();
return transaction.endAndTake();
}
};
applicator.applyCommand(new ClearPixelSelection(view));
struct AddSelectionShape : public KisTransactionBasedCommand {
AddSelectionShape(KisViewManager *view, KoShape* shape) : m_view(view),
m_shape(shape) {}
KisViewManager *m_view;
KoShape* m_shape;
KUndo2Command* paint() {
/**
* Mark a shape that it belongs to a shape selection
*/
if(!m_shape->userData()) {
m_shape->setUserData(new KisShapeSelectionMarker);
}
return m_view->canvasBase()->shapeController()->addShape(m_shape);
}
};
foreach(KoShape* shape, shapes) {
applicator.applyCommand(
new KisGuiContextCommand(new AddSelectionShape(view, shape), view));
}
void testShapedGradientPainterImpl(const QPolygonF &selectionPolygon,
const QString &testName,
const QPolygonF &selectionErasePolygon = QPolygonF())
{
const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
KisPaintDeviceSP dev = new KisPaintDevice(cs);
QRect imageRect(0,0,300,300);
KisSelectionSP selection = new KisSelection();
KisPixelSelectionSP pixelSelection = selection->pixelSelection();
KisPainter selPainter(pixelSelection);
selPainter.setFillStyle(KisPainter::FillStyleForegroundColor);
selPainter.setPaintColor(KoColor(Qt::white, pixelSelection->colorSpace()));
selPainter.paintPolygon(selectionPolygon);
if (!selectionErasePolygon.isEmpty()) {
selPainter.setCompositeOp(COMPOSITE_ERASE);
selPainter.setPaintColor(KoColor(Qt::white, pixelSelection->colorSpace()));
selPainter.paintPolygon(selectionErasePolygon);
}
selPainter.end();
pixelSelection->invalidateOutlineCache();
pixelSelection->convertToQImage(0, imageRect).save("sgt_selection.png");
QLinearGradient testGradient;
testGradient.setColorAt(0.0, Qt::white);
testGradient.setColorAt(0.5, Qt::green);
testGradient.setColorAt(1.0, Qt::black);
testGradient.setSpread(QGradient::ReflectSpread);
QScopedPointer<KoStopGradient> gradient(
KoStopGradient::fromQGradient(&testGradient));
KisGradientPainter gc(dev, selection);
gc.setGradient(gradient.data());
gc.setGradientShape(KisGradientPainter::GradientShapePolygonal);
gc.paintGradient(selectionPolygon.boundingRect().topLeft(),
selectionPolygon.boundingRect().bottomRight(),
KisGradientPainter::GradientRepeatNone,
0,
false,
imageRect.x(),
imageRect.y(),
imageRect.width(),
imageRect.height());
QVERIFY(TestUtil::checkQImageExternal(dev->convertToQImage(0, imageRect),
"shaped_gradient",
"fill",
testName, 1, 1, 0));
}
void KisFilterSelectionsBenchmark::initSelection()
{
m_selection = new KisSelection();
KisPixelSelectionSP pixelSelection = m_selection->pixelSelection();
//67.2% deselected
dbgKrita << "Deselected: 67.2%";
pixelSelection->dataManager()->clear(75, 75, 500, 320, 255);
pixelSelection->dataManager()->clear(100, 100, 50, 50, quint8(0));
pixelSelection->dataManager()->clear(150, 150, 50, 50, quint8(0));
pixelSelection->dataManager()->clear(200, 200, 50, 50, quint8(0));
pixelSelection->dataManager()->clear(375, 195, 200, 200, quint8(0));
pixelSelection->dataManager()->clear(75, 195, 200, 200, quint8(0));
pixelSelection->dataManager()->clear(375, 75, 150, 150, quint8(0));
pixelSelection->dataManager()->clear(205, 105, 50, 50, quint8(128));
// 94.9% deselected
// dbgKrita << "Deselected: 94.9%";
// pixelSelection->dataManager()->clear(75,75,500,320,255);
// pixelSelection->dataManager()->clear(80,80,490,310,quint8(0));
pixelSelection->convertToQImage(0).save("TEST_FILTER_SELECTION.png");
}
void KisDilateSelectionFilter::process(KisPixelSelectionSP pixelSelection, const QRect& rect)
{
// dilate (radius 1 pixel) a mask (1bpp)
quint8* buf[3];
qint32 width = rect.width();
qint32 height = rect.height();
quint8* out = new quint8[width];
for (qint32 i = 0; i < 3; i++)
buf[i] = new quint8[width + 2];
// load top of image
pixelSelection->readBytes(buf[0] + 1, rect.x(), rect.y(), width, 1);
buf[0][0] = buf[0][1];
buf[0][width + 1] = buf[0][width];
memcpy(buf[1], buf[0], width + 2);
for (qint32 y = 0; y < height; y++) {
if (y + 1 < height) {
pixelSelection->readBytes(buf[2] + 1, rect.x(), rect.y() + y + 1, width, 1);
buf[2][0] = buf[2][1];
buf[2][width + 1] = buf[2][width];
} else {
memcpy(buf[2], buf[1], width + 2);
}
for (qint32 x = 0 ; x < width; x++) {
qint32 max = 0;
if (buf[0][x+1] > max) max = buf[0][x+1];
if (buf[1][x] > max) max = buf[1][x];
if (buf[1][x+1] > max) max = buf[1][x+1];
if (buf[1][x+2] > max) max = buf[1][x+2];
if (buf[2][x+1] > max) max = buf[2][x+1];
out[x] = max;
}
pixelSelection->writeBytes(out, rect.x(), rect.y() + y, width, 1);
rotatePointers(buf, 3);
}
for (qint32 i = 0; i < 3; i++)
delete[] buf[i];
delete[] out;
}
void KisSelectionTest::testUpdatePixelSelection()
{
KisSelectionSP selection = new KisSelection();
KisPixelSelectionSP pSel = selection->getOrCreatePixelSelection();
pSel->select(QRect(0, 0, 348, 212));
QVERIFY(selection->pixelSelection()->selectedExactRect() == QRect(0, 0, 348, 212));
selection->updateProjection(QRect(0, 0, 348, 212));
for (int i = 0; i < 212; ++i) {
for (int j = 0; j < 348; ++j) {
QVERIFY(selection->selected(j, i) == MAX_SELECTED);
}
}
}
void KisSmoothSelectionFilter::process(KisPixelSelectionSP pixelSelection, const QRect& rect)
{
// Simple convolution filter to smooth a mask (1bpp)
quint8 *buf[3];
qint32 width = rect.width();
qint32 height = rect.height();
quint8* out = new quint8[width];
for (qint32 i = 0; i < 3; i++)
buf[i] = new quint8[width + 2];
// load top of image
pixelSelection->readBytes(buf[0] + 1, rect.x(), rect.y(), width, 1);
buf[0][0] = buf[0][1];
buf[0][width + 1] = buf[0][width];
memcpy(buf[1], buf[0], width + 2);
for (qint32 y = 0; y < height; y++) {
if (y + 1 < height) {
pixelSelection->readBytes(buf[2] + 1, rect.x(), rect.y() + y + 1, width, 1);
buf[2][0] = buf[2][1];
buf[2][width + 1] = buf[2][width];
} else {
memcpy(buf[2], buf[1], width + 2);
}
for (qint32 x = 0 ; x < width; x++) {
qint32 value = (buf[0][x] + buf[0][x+1] + buf[0][x+2] +
buf[1][x] + buf[2][x+1] + buf[1][x+2] +
buf[2][x] + buf[1][x+1] + buf[2][x+2]);
out[x] = value / 9;
}
pixelSelection->writeBytes(out, rect.x(), rect.y() + y, width, 1);
rotatePointers(buf, 3);
}
for (qint32 i = 0; i < 3; i++)
delete[] buf[i];
delete[] out;
}
void bumpmap (KisPixelSelectionSP device,
const QRect &selectionRect,
const bumpmap_vals_t &bmvals)
{
KIS_ASSERT_RECOVER_RETURN(bmvals.xofs == 0);
KIS_ASSERT_RECOVER_RETURN(bmvals.yofs == 0);
bumpmap_params_t params;
bumpmap_init_params (¶ms, bmvals);
const QRect dataRect = kisGrowRect(selectionRect, 1);
const int dataRowSize = dataRect.width() * sizeof(quint8);
const int selectionRowSize = selectionRect.width() * sizeof(quint8);
QScopedArrayPointer<quint8> dstRow(new quint8[selectionRowSize]);
QScopedArrayPointer<quint8> bmRow1(new quint8[dataRowSize]);
QScopedArrayPointer<quint8> bmRow2(new quint8[dataRowSize]);
QScopedArrayPointer<quint8> bmRow3(new quint8[dataRowSize]);
device->readBytes(bmRow1.data(), dataRect.left(), dataRect.top(), dataRect.width(), 1);
device->readBytes(bmRow2.data(), dataRect.left(), dataRect.top() + 1, dataRect.width(), 1);
device->readBytes(bmRow3.data(), dataRect.left(), dataRect.top() + 2, dataRect.width(), 1);
convertRow(bmRow1.data(), dataRect.width(), params.lut);
convertRow(bmRow2.data(), dataRect.width(), params.lut);
convertRow(bmRow3.data(), dataRect.width(), params.lut);
for (int row = selectionRect.top();
row < selectionRect.top() + selectionRect.height(); row++) {
bumpmap_row (bmvals, dstRow.data(), selectionRect.width(),
bmRow1.data() + 1, bmRow2.data() + 1, bmRow3.data() + 1,
¶ms);
device->writeBytes(dstRow.data(), selectionRect.left(), row, selectionRect.width(), 1);
bmRow1.swap(bmRow2);
bmRow2.swap(bmRow3);
device->readBytes(bmRow3.data(), dataRect.left(), row + 1, dataRect.width(), 1);
convertRow(bmRow3.data(), dataRect.width(), params.lut);
}
}
void KisPixelSelection::intersectSelection(KisPixelSelectionSP selection)
{
QRect r = selection->selectedRect().united(selectedRect());
KisHLineIteratorPixel dst = createHLineIterator(r.x(), r.y(), r.width());
KisHLineConstIteratorPixel src = selection->createHLineConstIterator(r.x(), r.y(), r.width());
for (int i = 0; i < r.height(); ++i) {
while (!src.isDone()) {
if (*dst.rawData() == MAX_SELECTED && *src.rawData() == MAX_SELECTED)
*dst.rawData() = MAX_SELECTED;
else
*dst.rawData() = MIN_SELECTED;
++src;
++dst;
}
dst.nextRow();
src.nextRow();
}
}
QUndoCommand* KisSelectionToolHelper::selectPixelSelection(KisPixelSelectionSP selection, selectionAction action)
{
bool hasSelection = m_layer->selection();
QUndoCommand* selectionCmd = new QUndoCommand(m_name);
if (!hasSelection)
new KisSetGlobalSelectionCommand(m_image, selectionCmd);
new KisSelectionTransaction(m_name, m_image, m_layer->selection(), selectionCmd);
KisPixelSelectionSP getOrCreatePixelSelection = m_layer->selection()->getOrCreatePixelSelection();
if (! hasSelection || action == SELECTION_REPLACE) {
getOrCreatePixelSelection->clear();
if (action == SELECTION_SUBTRACT)
getOrCreatePixelSelection->invert();
}
getOrCreatePixelSelection->applySelection(selection, action);
if (hasSelection && action != SELECTION_REPLACE && action != SELECTION_INTERSECT) {
QRect rc = selection->selectedRect();
getOrCreatePixelSelection->setDirty(rc);
m_layer->selection()->updateProjection(rc);
m_canvas->view()->selectionManager()->selectionChanged();
} else {
getOrCreatePixelSelection->setDirty(m_image->bounds());
m_layer->selection()->updateProjection(m_image->bounds());
m_canvas->view()->selectionManager()->selectionChanged();
}
return selectionCmd;
}
void paintBevelSelection(KisPixelSelectionSP srcSelection,
KisPixelSelectionSP dstSelection,
const QRect &applyRect,
int size,
int initialSize,
bool invert)
{
KisSelectionSP tmpBaseSelection = new KisSelection(new KisSelectionEmptyBounds(0));
KisPixelSelectionSP tmpSelection = tmpBaseSelection->pixelSelection();
// NOTE: we are not using createCompositionSourceDevice() intentionally,
// because the source device doesn't have alpha channel
KisPixelSelectionSP fillDevice = new KisPixelSelection();
KisPainter gc(dstSelection);
gc.setCompositeOp(COMPOSITE_COPY);
for (int i = 0; i < size; i++) {
const int growSize = initialSize - i - 1;
quint8 selectedness = invert ?
qRound(qreal(size - i - 1) / size * 255.0) :
qRound(qreal(i + 1) / size * 255.0);
fillDevice->setDefaultPixel(KoColor(&selectedness, fillDevice->colorSpace()));
tmpSelection->makeCloneFromRough(srcSelection, srcSelection->selectedRect());
QRect changeRect = KisLsUtils::growSelectionUniform(tmpSelection, growSize, applyRect);
gc.setSelection(tmpBaseSelection);
gc.bitBlt(changeRect.topLeft(), fillDevice, changeRect);
}
}
void KisShapeSelectionTest::testAddChild()
{
const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
KisImageSP image = new KisImage(new KisUndoAdapter(0), 300, 300, cs, "test");
KisSelectionSP selection = new KisSelection();
QVERIFY(selection->hasPixelSelection() == false);
QVERIFY(selection->hasShapeSelection() == false);
KisPixelSelectionSP pixelSelection = selection->getOrCreatePixelSelection();
pixelSelection->select(QRect(0, 0, 100, 100));
// Selection is using the pixel selection as datamanager so no projection update
// needed
QCOMPARE(pixelSelection->selected(25, 25), MAX_SELECTED);
QCOMPARE(selection->selectedExactRect(), QRect(0, 0, 100, 100));
QRect rect(50, 50, 100, 100);
QTransform matrix;
matrix.scale(1 / image->xRes(), 1 / image->yRes());
rect = matrix.mapRect(rect);
KoPathShape* shape = new KoPathShape();
shape->setShapeId(KoPathShapeId);
shape->moveTo(rect.topLeft());
shape->lineTo(rect.topLeft() + QPointF(rect.width(), 0));
shape->lineTo(rect.bottomRight());
shape->lineTo(rect.topLeft() + QPointF(0, rect.height()));
shape->close();
shape->normalize();
KisShapeSelection * shapeSelection = new KisShapeSelection(image, selection);
selection->setShapeSelection(shapeSelection);
shapeSelection->addShape(shape);
QCOMPARE(pixelSelection->selected(25, 25), MAX_SELECTED);
QCOMPARE(selection->selectedExactRect(), QRect(0, 0, 150, 150));
selection->updateProjection();
}
bool KisKraLoadVisitor::visit(KisPaintLayer *layer)
{
loadNodeKeyframes(layer);
dbgFile << "Visit: " << layer->name() << " colorSpace: " << layer->colorSpace()->id();
if (!loadPaintDevice(layer->paintDevice(), getLocation(layer))) {
return false;
}
if (!loadProfile(layer->paintDevice(), getLocation(layer, DOT_ICC))) {
return false;
}
if (!loadMetaData(layer)) {
return false;
}
if (m_syntaxVersion == 1) {
// Check whether there is a file with a .mask extension in the
// layer directory, if so, it's an old-style transparency mask
// that should be converted.
QString location = getLocation(layer, ".mask");
if (m_store->open(location)) {
KisSelectionSP selection = KisSelectionSP(new KisSelection());
KisPixelSelectionSP pixelSelection = selection->pixelSelection();
if (!pixelSelection->read(m_store->device())) {
pixelSelection->disconnect();
} else {
KisTransparencyMask* mask = new KisTransparencyMask();
mask->setSelection(selection);
m_image->addNode(mask, layer, layer->firstChild());
}
m_store->close();
}
}
bool result = visitAll(layer);
return result;
}
void KisSelectionToolHelper::selectPixelSelection(KisPixelSelectionSP selection, SelectionAction action)
{
KisViewManager* view = m_canvas->viewManager();
if (selection->selectedExactRect().isEmpty()) {
m_canvas->viewManager()->selectionManager()->deselect();
return;
}
KisProcessingApplicator applicator(view->image(),
0 /* we need no automatic updates */,
KisProcessingApplicator::SUPPORTS_WRAPAROUND_MODE,
KisImageSignalVector() << ModifiedSignal,
m_name);
applicator.applyCommand(new LazyInitGlobalSelection(view));
struct ApplyToPixelSelection : public KisTransactionBasedCommand {
ApplyToPixelSelection(KisViewManager *view,
KisPixelSelectionSP selection,
SelectionAction action) : m_view(view),
m_selection(selection),
m_action(action) {}
KisViewManager *m_view;
KisPixelSelectionSP m_selection;
SelectionAction m_action;
KUndo2Command* paint() {
KisPixelSelectionSP pixelSelection = m_view->selection()->pixelSelection();
KIS_ASSERT_RECOVER(pixelSelection) { return 0; }
bool hasSelection = !pixelSelection->isEmpty();
KisSelectionTransaction transaction(pixelSelection);
if (!hasSelection && m_action == SELECTION_SUBTRACT) {
pixelSelection->invert();
}
pixelSelection->applySelection(m_selection, m_action);
QRect dirtyRect = m_view->image()->bounds();
if (hasSelection && m_action != SELECTION_REPLACE && m_action != SELECTION_INTERSECT) {
dirtyRect = m_selection->selectedRect();
}
m_view->selection()->updateProjection(dirtyRect);
KUndo2Command *savedCommand = transaction.endAndTake();
pixelSelection->setDirty(dirtyRect);
return savedCommand;
}
};
applicator.applyCommand(new ApplyToPixelSelection(view, selection, action));
applicator.end();
}
void KisSelectionToolHelper::selectPixelSelection(KisPixelSelectionSP selection, SelectionAction action)
{
KisView2* view = m_canvas->view();
if (selection->selectedRect().isEmpty()) {
m_canvas->view()->selectionManager()->deselect();
return;
}
KisUndoAdapter *undoAdapter = view->image()->undoAdapter();
undoAdapter->beginMacro(m_name);
bool hasSelection = view->selection();
if (!hasSelection) {
undoAdapter->addCommand(new KisSetEmptyGlobalSelectionCommand(m_image));
}
KisSelectionTransaction transaction(m_name, m_image->undoAdapter(), view->selection());
KisPixelSelectionSP pixelSelection = view->selection()->getOrCreatePixelSelection();
if (!hasSelection && action == SELECTION_SUBTRACT) {
pixelSelection->invert();
}
pixelSelection->applySelection(selection, action);
QRect dirtyRect = m_image->bounds();
if (hasSelection && action != SELECTION_REPLACE && action != SELECTION_INTERSECT) {
dirtyRect = selection->selectedRect();
}
view->selection()->updateProjection(dirtyRect);
transaction.commit(undoAdapter);
undoAdapter->endMacro();
pixelSelection->setDirty(dirtyRect);
m_canvas->view()->selectionManager()->selectionChanged();
}
void KisSelectionToolHelper::selectPixelSelection(KisPixelSelectionSP selection, SelectionAction action)
{
KisViewManager* view = m_canvas->viewManager();
if (selection->selectedExactRect().isEmpty()) {
m_canvas->viewManager()->selectionManager()->deselect();
return;
}
KisProcessingApplicator applicator(view->image(),
0 /* we need no automatic updates */,
KisProcessingApplicator::SUPPORTS_WRAPAROUND_MODE,
KisImageSignalVector() << ModifiedSignal,
m_name);
applicator.applyCommand(new LazyInitGlobalSelection(view));
struct ApplyToPixelSelection : public KisTransactionBasedCommand {
ApplyToPixelSelection(KisViewManager *view,
KisPixelSelectionSP selection,
SelectionAction action) : m_view(view),
m_selection(selection),
m_action(action) {}
KisViewManager *m_view;
KisPixelSelectionSP m_selection;
SelectionAction m_action;
KUndo2Command* paint() override {
KisPixelSelectionSP pixelSelection = m_view->selection()->pixelSelection();
KIS_ASSERT_RECOVER(pixelSelection) { return 0; }
bool hasSelection = !pixelSelection->isEmpty();
KisSelectionTransaction transaction(pixelSelection);
if (!hasSelection && m_action == SELECTION_SUBTRACT) {
pixelSelection->invert();
}
pixelSelection->applySelection(m_selection, m_action);
const QRect imageBounds = m_view->image()->bounds();
QRect selectionExactRect = m_view->selection()->selectedExactRect();
if (!imageBounds.contains(selectionExactRect)) {
pixelSelection->crop(imageBounds);
if (pixelSelection->outlineCacheValid()) {
QPainterPath cache = pixelSelection->outlineCache();
QPainterPath imagePath;
imagePath.addRect(imageBounds);
cache &= imagePath;
pixelSelection->setOutlineCache(cache);
}
selectionExactRect &= imageBounds;
}
QRect dirtyRect = imageBounds;
if (hasSelection && m_action != SELECTION_REPLACE && m_action != SELECTION_INTERSECT) {
dirtyRect = m_selection->selectedRect();
}
m_view->selection()->updateProjection(dirtyRect);
KUndo2Command *savedCommand = transaction.endAndTake();
pixelSelection->setDirty(dirtyRect);
if (selectionExactRect.isEmpty()) {
KisCommandUtils::CompositeCommand *cmd = new KisCommandUtils::CompositeCommand();
cmd->addCommand(savedCommand);
cmd->addCommand(new KisDeselectGlobalSelectionCommand(m_view->image()));
savedCommand = cmd;
}
return savedCommand;
}
};
applicator.applyCommand(new ApplyToPixelSelection(view, selection, action));
applicator.end();
}
void KisLsBevelEmbossFilter::applyBevelEmboss(KisPaintDeviceSP srcDevice,
KisMultipleProjection *dst,
const QRect &applyRect,
const psd_layer_effects_bevel_emboss *config,
KisLayerStyleFilterEnvironment *env) const
{
if (applyRect.isEmpty()) return;
BevelEmbossRectCalculator d(applyRect, config);
KisSelectionSP baseSelection = KisLsUtils::selectionFromAlphaChannel(srcDevice, d.initialFetchRect);
KisPixelSelectionSP selection = baseSelection->pixelSelection();
//selection->convertToQImage(0, QRect(0,0,300,300)).save("0_selection_initial.png");
const int size = config->size();
int limitingGrowSize = 0;
KisPixelSelectionSP bumpmapSelection = new KisPixelSelection(new KisSelectionEmptyBounds(0));
switch (config->style()) {
case psd_bevel_outer_bevel:
paintBevelSelection(selection, bumpmapSelection, d.applyBevelRect, size, size, false);
limitingGrowSize = size;
break;
case psd_bevel_inner_bevel:
paintBevelSelection(selection, bumpmapSelection, d.applyBevelRect, size, 0, false);
limitingGrowSize = 0;
break;
case psd_bevel_emboss: {
const int initialSize = std::ceil(qreal(size) / 2.0);
paintBevelSelection(selection, bumpmapSelection, d.applyBevelRect, size, initialSize, false);
limitingGrowSize = initialSize;
break;
}
case psd_bevel_pillow_emboss: {
const int halfSizeF = std::floor(qreal(size) / 2.0);
const int halfSizeC = std::ceil(qreal(size) / 2.0);
// TODO: probably not correct!
paintBevelSelection(selection, bumpmapSelection, d.applyBevelRect, halfSizeC, halfSizeC, false);
paintBevelSelection(selection, bumpmapSelection, d.applyBevelRect, halfSizeF, 0, true);
limitingGrowSize = halfSizeC;
break;
}
case psd_bevel_stroke_emboss:
warnKrita << "WARNING: Stroke Emboss style is not implemented yet!";
return;
}
KisPixelSelectionSP limitingSelection = new KisPixelSelection(*selection);
{
QRect changeRectUnused =
KisLsUtils::growSelectionUniform(limitingSelection,
limitingGrowSize,
d.applyBevelRect);
Q_UNUSED(changeRectUnused);
}
//bumpmapSelection->convertToQImage(0, QRect(0,0,300,300)).save("1_selection_xconv.png");
if (config->textureEnabled()) {
KisPixelSelectionSP textureSelection = new KisPixelSelection(new KisSelectionEmptyBounds(0));
KisLsUtils::fillPattern(textureSelection, d.applyTextureRect, env,
config->textureScale(),
config->texturePattern(),
config->textureHorizontalPhase(),
config->textureVerticalPhase(),
config->textureAlignWithLayer());
int contrastadj = 0;
{
using namespace std;
int tex_depth = config->textureDepth();
if (tex_depth >= 0.0) {
if (tex_depth <= 100.0) {
contrastadj = int(qRound((1-(tex_depth/100.0)) * -127));
} else {
contrastadj = int(qRound(((tex_depth-100.0)/900.0) * 127));
}
} else {
textureSelection->invert();
if (tex_depth >= -100.0) {
contrastadj = int(qRound((1-(abs(tex_depth)/100.0)) * -127));
} else {
contrastadj = int(qRound(((abs(tex_depth)-100.0)/900.0) * 127));
}
}
}
qreal contrast = qBound(-1.0, qreal(contrastadj) / 127.0, 1.0);
mapPixelValues(textureSelection, ContrastOp(contrast), d.applyTextureRect);
{
KisPainter gc(bumpmapSelection);
gc.setCompositeOp(COMPOSITE_MULT);
gc.bitBlt(d.applyTextureRect.topLeft(), textureSelection, d.applyTextureRect);
gc.end();
}
}
//bumpmapSelection->convertToQImage(0, QRect(0,0,300,300)).save("15_selection_texture.png");
if (config->contourEnabled()) {
if (config->range() != KisLsUtils::FULL_PERCENT_RANGE) {
KisLsUtils::adjustRange(bumpmapSelection, d.applyContourRect, config->range());
}
KisLsUtils::applyContourCorrection(bumpmapSelection,
d.applyContourRect,
config->contourLookupTable(),
config->antiAliased(),
true);
}
bumpmap_vals_t bmvals;
bmvals.azimuth = config->angle();
bmvals.elevation = config->altitude();
bmvals.depth = config->depth();
bmvals.ambient = 0;
bmvals.compensate = true;
bmvals.invert = config->direction() == psd_direction_down;
bmvals.type = LINEAR;
bumpmap(bumpmapSelection, d.applyBumpmapRect, bmvals);
//bumpmapSelection->convertToQImage(0, QRect(0,0,300,300)).save("3_selection_bumpmap.png");
{ // TODO: optimize!
KisLsUtils::applyContourCorrection(bumpmapSelection,
d.applyGlossContourRect,
config->glossContourLookupTable(),
config->glossAntiAliased(),
true);
}
if (config->soften()) {
KisLsUtils::applyGaussian(bumpmapSelection, d.applyGaussianRect, config->soften());
}
if (config->textureEnabled() && config->textureInvert()) {
bumpmapSelection->invert();
}
selection->clear();
mapPixelValues(bumpmapSelection, selection,
ShadowsFetchOp(), d.shadowHighlightsFinalRect);
selection->applySelection(limitingSelection, SELECTION_INTERSECT);
//dstDevice->convertToQImage(0, QRect(0,0,300,300)).save("4_dst_before_apply.png");
//selection->convertToQImage(0, QRect(0,0,300,300)).save("4_shadows_sel.png");
{
KisPaintDeviceSP dstDevice = dst->getProjection("00_bevel_shadow", config->shadowBlendMode(), srcDevice);
const KoColor fillColor(config->shadowColor(), dstDevice->colorSpace());
const QRect &fillRect = d.shadowHighlightsFinalRect;
KisPaintDeviceSP fillDevice = new KisPaintDevice(dstDevice->colorSpace());
fillDevice->setDefaultPixel(fillColor);
KisPainter gc(dstDevice);
gc.setSelection(baseSelection);
gc.setCompositeOp(COMPOSITE_OVER);
env->setupFinalPainter(&gc, config->shadowOpacity(), QBitArray());
gc.bitBlt(fillRect.topLeft(), fillDevice, fillRect);
gc.end();
}
selection->clear();
mapPixelValues(bumpmapSelection, selection,
HighlightsFetchOp(), d.shadowHighlightsFinalRect);
selection->applySelection(limitingSelection, SELECTION_INTERSECT);
//selection->convertToQImage(0, QRect(0,0,300,300)).save("5_highlights_sel.png");
{
KisPaintDeviceSP dstDevice = dst->getProjection("01_bevel_highlight", config->highlightBlendMode(), srcDevice);
const KoColor fillColor(config->highlightColor(), dstDevice->colorSpace());
const QRect &fillRect = d.shadowHighlightsFinalRect;
KisPaintDeviceSP fillDevice = new KisPaintDevice(dstDevice->colorSpace());
fillDevice->setDefaultPixel(fillColor);
KisPainter gc(dstDevice);
gc.setSelection(baseSelection);
gc.setCompositeOp(COMPOSITE_OVER);
env->setupFinalPainter(&gc, config->highlightOpacity(), QBitArray());
gc.bitBlt(fillRect.topLeft(), fillDevice, fillRect);
gc.end();
}
}
void applyDropShadow(KisPaintDeviceSP srcDevice,
KisPaintDeviceSP dstDevice,
const QRect &applyRect,
const psd_layer_effects_context *context,
const psd_layer_effects_shadow_base *shadow,
const KisLayerStyleFilterEnvironment *env)
{
if (applyRect.isEmpty()) return;
ShadowRectsData d(applyRect, context, shadow, ShadowRectsData::NEED_RECT);
KisSelectionSP baseSelection =
KisLsUtils::selectionFromAlphaChannel(srcDevice, d.spreadNeedRect);
KisPixelSelectionSP selection = baseSelection->pixelSelection();
//selection->convertToQImage(0, QRect(0,0,300,300)).save("0_selection_initial.png");
if (shadow->invertsSelection()) {
selection->invert();
}
/**
* Copy selection which will be erased from the original later
*/
KisPixelSelectionSP knockOutSelection;
if (shadow->knocksOut()) {
knockOutSelection = new KisPixelSelection(*selection);
}
if (shadow->technique() == psd_technique_precise) {
KisLsUtils::findEdge(selection, d.blurNeedRect, true);
}
/**
* Spread and blur the selection
*/
if (d.spread_size) {
KisLsUtils::applyGaussian(selection, d.blurNeedRect, d.spread_size);
// TODO: find out why in libpsd we pass false here. If we do so,
// the result is fully black, which is not expected
KisLsUtils::findEdge(selection, d.blurNeedRect, true /*shadow->edgeHidden()*/);
}
//selection->convertToQImage(0, QRect(0,0,300,300)).save("1_selection_spread.png");
if (d.blur_size) {
KisLsUtils::applyGaussian(selection, d.noiseNeedRect, d.blur_size);
}
//selection->convertToQImage(0, QRect(0,0,300,300)).save("2_selection_blur.png");
if (shadow->range() != KisLsUtils::FULL_PERCENT_RANGE) {
KisLsUtils::adjustRange(selection, d.noiseNeedRect, shadow->range());
}
const psd_layer_effects_inner_glow *iglow = 0;
if ((iglow =
dynamic_cast<const psd_layer_effects_inner_glow *>(shadow)) &&
iglow->source() == psd_glow_center) {
selection->invert();
}
/**
* Contour correction
*/
KisLsUtils::applyContourCorrection(selection,
d.noiseNeedRect,
shadow->contourLookupTable(),
shadow->antiAliased(),
shadow->edgeHidden());
//selection->convertToQImage(0, QRect(0,0,300,300)).save("3_selection_contour.png");
/**
* Noise
*/
if (shadow->noise() > 0) {
KisLsUtils::applyNoise(selection,
d.srcRect,
shadow->noise(),
context);
}
//selection->convertToQImage(0, QRect(0,0,300,300)).save("4_selection_noise.png");
if (!d.offset.isNull()) {
selection->setX(d.offset.x());
selection->setY(d.offset.y());
}
/**
* Knock-out original outline of the device from the resulting shade
*/
if (shadow->knocksOut()) {
KIS_ASSERT_RECOVER_RETURN(knockOutSelection);
QRect knockOutRect = !shadow->invertsSelection() ?
d.srcRect : d.spreadNeedRect;
knockOutRect &= d.dstRect;
KisPainter gc(selection);
gc.setCompositeOp(COMPOSITE_ERASE);
gc.bitBlt(knockOutRect.topLeft(), knockOutSelection, knockOutRect);
}
//selection->convertToQImage(0, QRect(0,0,300,300)).save("5_selection_knockout.png");
KisLsUtils::applyFinalSelection(baseSelection,
srcDevice,
dstDevice,
d.srcRect,
d.dstRect,
context,
shadow,
env);
}
void KisInvertSelectionFilter::process(KisPixelSelectionSP pixelSelection, const QRect& rect)
{
Q_UNUSED(rect);
pixelSelection->invert();
}
void KisShrinkSelectionFilter::process(KisPixelSelectionSP pixelSelection, const QRect& rect)
{
if (m_xRadius <= 0 || m_yRadius <= 0) return;
/*
pretty much the same as fatten_region only different
blame all bugs in this function on [email protected]
*/
/* If edge_lock is true we assume that pixels outside the region
we are passed are identical to the edge pixels.
If edge_lock is false, we assume that pixels outside the region are 0
*/
quint8 **buf; // caches the region's pixels
quint8 **max; // caches the smallest values for each column
qint32 last_max, last_index;
max = new quint8* [rect.width() + 2 * m_xRadius];
buf = new quint8* [m_yRadius + 1];
for (qint32 i = 0; i < m_yRadius + 1; i++) {
buf[i] = new quint8[rect.width()];
}
qint32 buffer_size = (rect.width() + 2 * m_xRadius + 1) * (m_yRadius + 1);
quint8* buffer = new quint8[buffer_size];
if (m_edgeLock)
memset(buffer, 255, buffer_size);
else
memset(buffer, 0, buffer_size);
for (qint32 i = 0; i < rect.width() + 2 * m_xRadius; i++) {
if (i < m_xRadius)
if (m_edgeLock)
max[i] = buffer;
else
max[i] = &buffer[(m_yRadius + 1) * (rect.width() + m_xRadius)];
else if (i < rect.width() + m_xRadius)
max[i] = &buffer[(m_yRadius + 1) * (i - m_xRadius)];
else if (m_edgeLock)
max[i] = &buffer[(m_yRadius + 1) * (rect.width() + m_xRadius - 1)];
else
max[i] = &buffer[(m_yRadius + 1) * (rect.width() + m_xRadius)];
}
if (!m_edgeLock)
for (qint32 j = 0 ; j < m_xRadius + 1; j++) max[0][j] = 0;
// offset the max pointer by m_xRadius so the range of the array is [-m_xRadius] to [region->w + m_xRadius]
max += m_xRadius;
quint8* out = new quint8[rect.width()]; // holds the new scan line we are computing
qint32* circ = new qint32[2 * m_xRadius + 1]; // holds the y coords of the filter's mask
computeBorder(circ, m_xRadius, m_yRadius);
// offset the circ pointer by m_xRadius so the range of the array is [-m_xRadius] to [m_xRadius]
circ += m_xRadius;
for (qint32 i = 0; i < m_yRadius && i < rect.height(); i++) // load top of image
pixelSelection->readBytes(buf[i + 1], rect.x(), rect.y() + i, rect.width(), 1);
if (m_edgeLock)
memcpy(buf[0], buf[1], rect.width());
else
memset(buf[0], 0, rect.width());
for (qint32 x = 0; x < rect.width(); x++) { // set up max for top of image
max[x][0] = buf[0][x];
for (qint32 j = 1; j < m_yRadius + 1; j++)
max[x][j] = MIN(buf[j][x], max[x][j-1]);
}
for (qint32 y = 0; y < rect.height(); y++) {
rotatePointers(buf, m_yRadius + 1);
if (y < rect.height() - m_yRadius)
pixelSelection->readBytes(buf[m_yRadius], rect.x(), rect.y() + y + m_yRadius, rect.width(), 1);
else if (m_edgeLock)
memcpy(buf[m_yRadius], buf[m_yRadius - 1], rect.width());
else
memset(buf[m_yRadius], 0, rect.width());
for (qint32 x = 0 ; x < rect.width(); x++) { // update max array
for (qint32 i = m_yRadius; i > 0; i--) {
max[x][i] = MIN(MIN(max[x][i - 1], buf[i - 1][x]), buf[i][x]);
}
max[x][0] = buf[0][x];
}
last_max = max[0][circ[-1]];
last_index = 0;
for (qint32 x = 0 ; x < rect.width(); x++) { // render scan line
last_index--;
if (last_index >= 0) {
if (last_max == 0)
out[x] = 0;
else {
last_max = 255;
for (qint32 i = m_xRadius; i >= 0; i--)
if (last_max > max[x + i][circ[i]]) {
last_max = max[x + i][circ[i]];
last_index = i;
}
out[x] = last_max;
}
} else {
last_index = m_xRadius;
last_max = max[x + m_xRadius][circ[m_xRadius]];
for (qint32 i = m_xRadius - 1; i >= -m_xRadius; i--)
if (last_max > max[x + i][circ[i]]) {
last_max = max[x + i][circ[i]];
last_index = i;
}
out[x] = last_max;
}
}
pixelSelection->writeBytes(out, rect.x(), rect.y() + y, rect.width(), 1);
}
// undo the offsets to the pointers so we can free the malloced memmory
circ -= m_xRadius;
max -= m_xRadius;
delete[] circ;
delete[] buffer;
delete[] max;
for (qint32 i = 0; i < m_yRadius + 1; i++)
delete buf[i];
delete[] buf;
delete[] out;
}
void KisGrowSelectionFilter::process(KisPixelSelectionSP pixelSelection, const QRect& rect)
{
if (m_xRadius <= 0 || m_yRadius <= 0) return;
/**
* Much code resembles Shrink filter, so please fix bugs
* in both filters
*/
quint8 **buf; // caches the region's pixel data
quint8 **max; // caches the largest values for each column
max = new quint8* [rect.width() + 2 * m_xRadius];
buf = new quint8* [m_yRadius + 1];
for (qint32 i = 0; i < m_yRadius + 1; i++) {
buf[i] = new quint8[rect.width()];
}
quint8* buffer = new quint8[(rect.width() + 2 * m_xRadius) *(m_yRadius + 1)];
for (qint32 i = 0; i < rect.width() + 2 * m_xRadius; i++) {
if (i < m_xRadius)
max[i] = buffer;
else if (i < rect.width() + m_xRadius)
max[i] = &buffer[(m_yRadius + 1) * (i - m_xRadius)];
else
max[i] = &buffer[(m_yRadius + 1) * (rect.width() + m_xRadius - 1)];
for (qint32 j = 0; j < m_xRadius + 1; j++)
max[i][j] = 0;
}
/* offset the max pointer by m_xRadius so the range of the array
is [-m_xRadius] to [region->w + m_xRadius] */
max += m_xRadius;
quint8* out = new quint8[ rect.width()]; // holds the new scan line we are computing
qint32* circ = new qint32[ 2 * m_xRadius + 1 ]; // holds the y coords of the filter's mask
computeBorder(circ, m_xRadius, m_yRadius);
/* offset the circ pointer by m_xRadius so the range of the array
is [-m_xRadius] to [m_xRadius] */
circ += m_xRadius;
memset(buf[0], 0, rect.width());
for (qint32 i = 0; i < m_yRadius && i < rect.height(); i++) { // load top of image
pixelSelection->readBytes(buf[i + 1], rect.x(), rect.y() + i, rect.width(), 1);
}
for (qint32 x = 0; x < rect.width() ; x++) { // set up max for top of image
max[x][0] = 0; // buf[0][x] is always 0
max[x][1] = buf[1][x]; // MAX (buf[1][x], max[x][0]) always = buf[1][x]
for (qint32 j = 2; j < m_yRadius + 1; j++) {
max[x][j] = MAX(buf[j][x], max[x][j-1]);
}
}
for (qint32 y = 0; y < rect.height(); y++) {
rotatePointers(buf, m_yRadius + 1);
if (y < rect.height() - (m_yRadius))
pixelSelection->readBytes(buf[m_yRadius], rect.x(), rect.y() + y + m_yRadius, rect.width(), 1);
else
memset(buf[m_yRadius], 0, rect.width());
for (qint32 x = 0; x < rect.width(); x++) { /* update max array */
for (qint32 i = m_yRadius; i > 0; i--) {
max[x][i] = MAX(MAX(max[x][i - 1], buf[i - 1][x]), buf[i][x]);
}
max[x][0] = buf[0][x];
}
qint32 last_max = max[0][circ[-1]];
qint32 last_index = 1;
for (qint32 x = 0; x < rect.width(); x++) { /* render scan line */
last_index--;
if (last_index >= 0) {
if (last_max == 255)
out[x] = 255;
else {
last_max = 0;
for (qint32 i = m_xRadius; i >= 0; i--)
if (last_max < max[x + i][circ[i]]) {
last_max = max[x + i][circ[i]];
last_index = i;
}
out[x] = last_max;
}
} else {
last_index = m_xRadius;
last_max = max[x + m_xRadius][circ[m_xRadius]];
for (qint32 i = m_xRadius - 1; i >= -m_xRadius; i--)
if (last_max < max[x + i][circ[i]]) {
last_max = max[x + i][circ[i]];
last_index = i;
}
out[x] = last_max;
}
}
pixelSelection->writeBytes(out, rect.x(), rect.y() + y, rect.width(), 1);
}
/* undo the offsets to the pointers so we can free the malloced memmory */
circ -= m_xRadius;
max -= m_xRadius;
delete[] circ;
delete[] buffer;
delete[] max;
for (qint32 i = 0; i < m_yRadius + 1; i++)
delete[] buf[i];
delete[] buf;
delete[] out;
}
void KisSelectionTest::testSelectionActions()
{
KisPixelSelectionSP pixelSelection = new KisPixelSelection();
KisSelectionSP selection = new KisSelection();
QVERIFY(selection->hasPixelSelection() == false);
QVERIFY(selection->hasShapeSelection() == false);
selection->setPixelSelection(pixelSelection);
pixelSelection->select(QRect(0, 0, 20, 20));
KisPixelSelectionSP tmpSel = KisPixelSelectionSP(new KisPixelSelection());
tmpSel->select(QRect(10, 0, 20, 20));
pixelSelection->addSelection(tmpSel);
QCOMPARE(pixelSelection->selectedExactRect(), QRect(0, 0, 30, 20));
selection->updateProjection();
QCOMPARE(selection->selectedExactRect(), QRect(0, 0, 30, 20));
pixelSelection->clear();
pixelSelection->select(QRect(0, 0, 20, 20));
pixelSelection->subtractSelection(tmpSel);
selection->updateProjection();
QCOMPARE(selection->selectedExactRect(), QRect(0, 0, 10, 20));
pixelSelection->clear();
selection->updateProjection();
pixelSelection->select(QRect(0, 0, 20, 20));
pixelSelection->intersectSelection(tmpSel);
selection->updateProjection();
QCOMPARE(selection->selectedExactRect(), QRect(10, 0, 10, 20));
}
void KisBorderSelectionFilter::process(KisPixelSelectionSP pixelSelection, const QRect& rect)
{
if (m_xRadius <= 0 || m_yRadius <= 0) return;
quint8 *buf[3];
quint8 **density;
quint8 **transition;
if (m_xRadius == 1 && m_yRadius == 1) {
// optimize this case specifically
quint8* source[3];
for (qint32 i = 0; i < 3; i++)
source[i] = new quint8[rect.width()];
quint8* transition = new quint8[rect.width()];
pixelSelection->readBytes(source[0], rect.x(), rect.y(), rect.width(), 1);
memcpy(source[1], source[0], rect.width());
if (rect.height() > 1)
pixelSelection->readBytes(source[2], rect.x(), rect.y() + 1, rect.width(), 1);
else
memcpy(source[2], source[1], rect.width());
computeTransition(transition, source, rect.width());
pixelSelection->writeBytes(transition, rect.x(), rect.y(), rect.width(), 1);
for (qint32 y = 1; y < rect.height(); y++) {
rotatePointers(source, 3);
if (y + 1 < rect.height())
pixelSelection->readBytes(source[2], rect.x(), rect.y() + y + 1, rect.width(), 1);
else
memcpy(source[2], source[1], rect.width());
computeTransition(transition, source, rect.width());
pixelSelection->writeBytes(transition, rect.x(), rect.y() + y, rect.width(), 1);
}
for (qint32 i = 0; i < 3; i++)
delete[] source[i];
delete[] transition;
return;
}
qint32* max = new qint32[rect.width() + 2 * m_xRadius];
for (qint32 i = 0; i < (rect.width() + 2 * m_xRadius); i++)
max[i] = m_yRadius + 2;
max += m_xRadius;
for (qint32 i = 0; i < 3; i++)
buf[i] = new quint8[rect.width()];
transition = new quint8*[m_yRadius + 1];
for (qint32 i = 0; i < m_yRadius + 1; i++) {
transition[i] = new quint8[rect.width() + 2 * m_xRadius];
memset(transition[i], 0, rect.width() + 2 * m_xRadius);
transition[i] += m_xRadius;
}
quint8* out = new quint8[rect.width()];
density = new quint8*[2 * m_xRadius + 1];
density += m_xRadius;
for (qint32 x = 0; x < (m_xRadius + 1); x++) { // allocate density[][]
density[ x] = new quint8[2 * m_yRadius + 1];
density[ x] += m_yRadius;
density[-x] = density[x];
}
for (qint32 x = 0; x < (m_xRadius + 1); x++) { // compute density[][]
double tmpx, tmpy, dist;
quint8 a;
if (x > 0)
tmpx = x - 0.5;
else if (x < 0)
tmpx = x + 0.5;
else
tmpx = 0.0;
for (qint32 y = 0; y < (m_yRadius + 1); y++) {
if (y > 0)
tmpy = y - 0.5;
else if (y < 0)
tmpy = y + 0.5;
else
tmpy = 0.0;
dist = ((tmpy * tmpy) / (m_yRadius * m_yRadius) +
(tmpx * tmpx) / (m_xRadius * m_xRadius));
if (dist < 1.0)
a = (quint8)(255 * (1.0 - sqrt(dist)));
else
a = 0;
density[ x][ y] = a;
density[ x][-y] = a;
density[-x][ y] = a;
density[-x][-y] = a;
}
}
pixelSelection->readBytes(buf[0], rect.x(), rect.y(), rect.width(), 1);
memcpy(buf[1], buf[0], rect.width());
if (rect.height() > 1)
pixelSelection->readBytes(buf[2], rect.x(), rect.y() + 1, rect.width(), 1);
else
memcpy(buf[2], buf[1], rect.width());
computeTransition(transition[1], buf, rect.width());
for (qint32 y = 1; y < m_yRadius && y + 1 < rect.height(); y++) { // set up top of image
rotatePointers(buf, 3);
pixelSelection->readBytes(buf[2], rect.x(), rect.y() + y + 1, rect.width(), 1);
computeTransition(transition[y + 1], buf, rect.width());
}
for (qint32 x = 0; x < rect.width(); x++) { // set up max[] for top of image
max[x] = -(m_yRadius + 7);
for (qint32 j = 1; j < m_yRadius + 1; j++)
if (transition[j][x]) {
max[x] = j;
break;
}
}
for (qint32 y = 0; y < rect.height(); y++) { // main calculation loop
rotatePointers(buf, 3);
rotatePointers(transition, m_yRadius + 1);
if (y < rect.height() - (m_yRadius + 1)) {
pixelSelection->readBytes(buf[2], rect.x(), rect.y() + y + m_yRadius + 1, rect.width(), 1);
computeTransition(transition[m_yRadius], buf, rect.width());
} else
memcpy(transition[m_yRadius], transition[m_yRadius - 1], rect.width());
for (qint32 x = 0; x < rect.width(); x++) { // update max array
if (max[x] < 1) {
if (max[x] <= -m_yRadius) {
if (transition[m_yRadius][x])
max[x] = m_yRadius;
else
max[x]--;
} else if (transition[-max[x]][x])
max[x] = -max[x];
else if (transition[-max[x] + 1][x])
max[x] = -max[x] + 1;
else
max[x]--;
} else
max[x]--;
if (max[x] < -m_yRadius - 1)
max[x] = -m_yRadius - 1;
}
quint8 last_max = max[0][density[-1]];
qint32 last_index = 1;
for (qint32 x = 0 ; x < rect.width(); x++) { // render scan line
last_index--;
if (last_index >= 0) {
last_max = 0;
for (qint32 i = m_xRadius; i >= 0; i--)
if (max[x + i] <= m_yRadius && max[x + i] >= -m_yRadius && density[i][max[x+i]] > last_max) {
last_max = density[i][max[x + i]];
last_index = i;
}
out[x] = last_max;
} else {
last_max = 0;
for (qint32 i = m_xRadius; i >= -m_xRadius; i--)
if (max[x + i] <= m_yRadius && max[x + i] >= -m_yRadius && density[i][max[x + i]] > last_max) {
last_max = density[i][max[x + i]];
last_index = i;
}
out[x] = last_max;
}
if (last_max == 0) {
qint32 i;
for (i = x + 1; i < rect.width(); i++) {
if (max[i] >= -m_yRadius)
break;
}
if (i - x > m_xRadius) {
for (; x < i - m_xRadius; x++)
out[x] = 0;
x--;
}
last_index = m_xRadius;
}
}
pixelSelection->writeBytes(out, rect.x(), rect.y() + y, rect.width(), 1);
}
delete [] out;
for (qint32 i = 0; i < 3; i++)
delete buf[i];
max -= m_xRadius;
delete[] max;
for (qint32 i = 0; i < m_yRadius + 1; i++) {
transition[i] -= m_xRadius;
delete transition[i];
}
delete[] transition;
for (qint32 i = 0; i < m_xRadius + 1 ; i++) {
density[i] -= m_yRadius;
delete density[i];
}
density -= m_xRadius;
delete[] density;
}
void KisSelectionTest::testInvertSelection()
{
KisSelectionSP selection = new KisSelection();
KisPixelSelectionSP pixelSelection = selection->getOrCreatePixelSelection();
pixelSelection->select(QRect(20, 20, 20, 20));
QCOMPARE(pixelSelection->selected(30, 30), MAX_SELECTED);
QCOMPARE(pixelSelection->selected(0, 0), MIN_SELECTED);
QCOMPARE(pixelSelection->selected(512, 512), MIN_SELECTED);
pixelSelection->invert();
QCOMPARE(pixelSelection->selected(100, 100), MAX_SELECTED);
QCOMPARE(pixelSelection->selected(22, 22), MIN_SELECTED);
QCOMPARE(pixelSelection->selected(0, 0), MAX_SELECTED);
QCOMPARE(pixelSelection->selected(512, 512), MAX_SELECTED);
pixelSelection->convertToQImage(0, 0, 0, 100, 100).save("yyy.png");
// XXX: This should happen automatically
selection->updateProjection();
selection->convertToQImage(0, 0, 0, 100, 100).save("zzz.png");
QCOMPARE(selection->selectedExactRect(), QRect(qint32_MIN/2, qint32_MIN/2, qint32_MAX, qint32_MAX));
QCOMPARE(selection->selectedRect(), QRect(qint32_MIN/2, qint32_MIN/2, qint32_MAX, qint32_MAX));
QCOMPARE(selection->selected(100, 100), MAX_SELECTED);
QCOMPARE(selection->selected(22, 22), MIN_SELECTED);
QCOMPARE(selection->selected(10, 10), MAX_SELECTED);
QCOMPARE(selection->selected(0, 0), MAX_SELECTED);
QCOMPARE(selection->selected(512, 512), MAX_SELECTED);
}
