uchar* ImageIface::Private::previewImageData()
{
if (previewImage.isNull())
{
DImg* im = 0;
if (previewType == FullImage)
{
im = core->getImg();
if (!im || im->isNull())
{
return 0;
}
}
else // ImageSelection
{
im = new DImg(core->getImgSelection());
if (!im)
{
return 0;
}
if (im->isNull())
{
delete im;
return 0;
}
im->setIccProfile(core->getEmbeddedICC());
}
QSize sz(im->width(), im->height());
sz.scale(constrainWidth, constrainHeight, Qt::KeepAspectRatio);
previewImage = im->smoothScale(sz.width(), sz.height());
previewWidth = previewImage.width();
previewHeight = previewImage.height();
// only create another copy if needed, in setPreviewImage
targetPreviewImage = previewImage;
if (previewType == ImageSelection)
{
delete im;
}
}
DImg previewData = previewImage.copyImageData();
return previewData.stripImageData();
}
void DImgPreviewItem::slotGotImagePreview(const LoadingDescription& description, const DImg& image)
{
Q_D(DImgPreviewItem);
if (description.filePath != d->path || description.isThumbnail())
{
return;
}
setImage(image);
if (image.isNull())
{
d->state = ImageLoadingFailed;
emit stateChanged(d->state);
emit loadingFailed();
}
else
{
d->state = ImageLoaded;
emit stateChanged(d->state);
emit loaded();
}
preloadNext();
}
void ImageQualityTask::run()
{
if (!d->cancel)
{
// Get item preview to perform quality analysis. No need to load whole image, this will be slower.
// TODO : check if 1024 pixels size is enough to get suitable Quality results.
DImg dimg = PreviewLoadThread::loadFastSynchronously(d->path, 1024);
if (!dimg.isNull() && !d->cancel)
{
// TODO : run here Quality analysis backend and store Pick Label result to DB.
// Backend Input : d->quality as Quality analysis settings,
// dimg as reduced size image data to parse,
// d->path as file path to patch DB properties.
// Result : Backend must scan Quality of image depending of settings and compute a Quality estimation accordingly.
// Finaly, using file path, DB Pick Label properties must be assigned through ImageInfo interface.
// Warning : All code here will run in a separated thread and must be re-entrant/thread-safe. Only pure computation
// must be processed. GUI calls are prohibited. ImageInfo and DImg can be used safety in thread.
PickLabel pick;
d->imgqsort = new ImgQSort(dimg, d->quality, &pick);
d->imgqsort->startAnalyse();
ImageInfo info = ImageInfo::fromLocalFile(d->path);
info.setPickLabel(pick);
delete d->imgqsort; //delete image data after setting label
d->imgqsort = 0;
}
// Dispatch progress to Progress Manager
QImage qimg = dimg.smoothScale(22, 22, Qt::KeepAspectRatio).copyQImage();
emit signalFinished(qimg);
emit signalDone();
}
}
void UndoManager::restoreSnapshot(int index, const UndoMetadataContainer& c)
{
DImg img = d->undoCache->getData(index);
if (!img.isNull())
{
d->core->setUndoImg(c, img);
}
}
void BCGFilter::applyBCG(DImg& image)
{
if (image.isNull())
{
return;
}
applyBCG(image.bits(), image.width(), image.height(), image.sixteenBit());
}
void ImageIface::setOriginal(const QString& caller, const FilterAction& action, const DImg& img)
{
if (img.isNull())
{
kDebug() << "No image data to handle";
return;
}
d->core->putImg(caller, action, img);
}
void ImageIface::setSelection(const QString& caller, const FilterAction& action, const DImg& img)
{
if (img.hasAlpha() != originalHasAlpha() ||
img.sixteenBit() != originalSixteenBit() ||
img.size() != selectionRect().size()
)
{
kDebug() << "Properties of image to overwrite selection differs than original image";
return;
}
if (img.isNull())
{
kDebug() << "No image data to handle";
return;
}
d->core->putImgSelection(caller, action, img);
}
void FingerPrintsGenerator::slotGotImagePreview(const LoadingDescription& desc, const DImg& img)
{
if (d->allPicturesPath.isEmpty())
{
return;
}
if (d->allPicturesPath.first() != desc.filePath)
{
return;
}
if (!img.isNull())
{
// compute Haar fingerprint
d->haarIface.indexImage(desc.filePath, img);
}
QPixmap pix = DImg(img).smoothScale(128, 128, Qt::KeepAspectRatio).convertToPixmap();
addedAction(pix, desc.filePath);
advance(1);
if (!d->allPicturesPath.isEmpty())
{
d->allPicturesPath.removeFirst();
}
if (d->allPicturesPath.isEmpty())
{
complete();
}
else
{
processOne();
}
}
void HSLFilter::applyHSL(DImg& image)
{
if (image.isNull())
{
return;
}
bool sixteenBit = image.sixteenBit();
uint numberOfPixels = image.numPixels();
int progress;
int hue, sat, lig;
double vib = d->settings.vibrance;
DColor color;
if (sixteenBit) // 16 bits image.
{
unsigned short* data = (unsigned short*) image.bits();
for (uint i=0; runningFlag() && (i<numberOfPixels); ++i)
{
color = DColor(data[2], data[1], data[0], 0, sixteenBit);
// convert RGB to HSL
color.getHSL(&hue, &sat, &lig);
// convert HSL to RGB
color.setHSL(d->htransfer16[hue], vibranceBias(d->stransfer16[sat], hue, vib, sixteenBit), d->ltransfer16[lig], sixteenBit);
data[2] = color.red();
data[1] = color.green();
data[0] = color.blue();
data += 4;
progress = (int)(((double)i * 100.0) / numberOfPixels);
if ( progress%5 == 0 )
{
postProgress( progress );
}
}
}
else // 8 bits image.
{
uchar* data = image.bits();
for (uint i=0; runningFlag() && (i<numberOfPixels); ++i)
{
color = DColor(data[2], data[1], data[0], 0, sixteenBit);
// convert RGB to HSL
color.getHSL(&hue, &sat, &lig);
// convert HSL to RGB
color.setHSL(d->htransfer[hue], vibranceBias(d->stransfer[sat],hue,vib,sixteenBit), d->ltransfer[lig], sixteenBit);
data[2] = color.red();
data[1] = color.green();
data[0] = color.blue();
data += 4;
progress = (int)(((double)i * 100.0) / numberOfPixels);
if ( progress%5 == 0 )
{
postProgress( progress );
}
}
}
}
/**
Take data from image, draw text at x|y with specified parameters.
If destPainter is null, draw to image,
if destPainter is not null, draw directly using the painter.
Returns modified area of image.
*/
QRect InsertTextWidget::composeImage(DImg* const image, QPainter* const destPainter,
int x, int y,
QFont font, float pointSize, int textRotation, QColor textColor,
int textOpacity, int alignMode, const QString& textString,
bool transparentBackground, QColor backgroundColor,
BorderMode borderMode, int borderWidth, int spacing, float fontScale)
{
/*
The problem we have to solve is that we have no pixel access to font rendering,
we have to let Qt do the drawing. On the other hand we need to support 16 bit, which
cannot be done with QPixmap.
The current solution cuts out the text area, lets Qt do its drawing, converts back and blits to original.
*/
int maxWidth, maxHeight;
if (x == -1 && y == -1)
{
maxWidth = image->width();
maxHeight = image->height();
}
else
{
maxWidth = image->width() - x;
maxHeight = image->height() - y;
}
fontScale = qMax(0.01f, fontScale);
// find out size of the area that we are drawing to
font.setPointSizeF(pointSize);
QFontMetrics fontMt(font);
QRect fontRect = fontMt.boundingRect(0, 0,
qRound(maxWidth / fontScale),
qRound(maxHeight / fontScale),
alignMode, textString);
fontRect.setWidth(qRound(fontRect.width() * fontScale));
fontRect.setHeight(qRound(fontRect.height() * fontScale));
if (!fontRect.isValid())
{
return QRect();
}
int fontWidth, fontHeight;
switch (textRotation)
{
case ROTATION_NONE:
case ROTATION_180:
default:
fontWidth = fontRect.width();
fontHeight = fontRect.height();
break;
case ROTATION_90:
case ROTATION_270:
fontWidth = fontRect.height();
fontHeight = fontRect.width();
break;
}
// x, y == -1 means that we have to find a good initial position for the text here
if (x == -1 && y == -1)
{
int boxWidth = fontWidth + 2 * borderWidth + 2 * spacing;
int boxHeight = fontHeight + 2 * borderWidth + 2 * spacing;
// was a valid position hint stored from last use?
if (d->positionHint.isValid())
{
// We assume that people tend to orient text along the edges,
// so we do some guessing so that positions such as "in the lower right corner"
// will be remembered across different image sizes.
// get relative positions
float fromTop = (float)d->positionHint.top() / 10000.0;
float fromBottom = 1.0 - (float)d->positionHint.bottom() / 10000.0;
float fromLeft = (float)d->positionHint.left() / 10000.0;
float fromRight = 1.0 - (float)d->positionHint.right() / 10000.0;
// calculate horizontal position
if (fromLeft < fromRight)
{
x = qRound(fromLeft * maxWidth);
// we are placing from the smaller distance,
// so if now the larger distance is actually too small,
// fall back to standard placement, nothing to lose.
if (x + boxWidth > maxWidth)
{
x = qMax( (maxWidth - boxWidth) / 2, 0);
}
}
else
{
x = maxWidth - qRound(fromRight * maxWidth) - boxWidth;
if ( x < 0 )
{
x = qMax( (maxWidth - boxWidth) / 2, 0);
}
}
// calculate vertical position
if (fromTop < fromBottom)
{
y = qRound(fromTop * maxHeight);
if (y + boxHeight > maxHeight)
{
y = qMax( (maxHeight - boxHeight) / 2, 0);
}
}
else
{
y = maxHeight - qRound(fromBottom * maxHeight) - boxHeight;
if ( y < 0 )
{
y = qMax( (maxHeight - boxHeight) / 2, 0);
}
}
if (! QRect(x, y, boxWidth, boxHeight).
intersects(QRect(0, 0, maxWidth, maxHeight)) )
{
// emergency fallback - nothing is visible
x = qMax( (maxWidth - boxWidth) / 2, 0);
y = qMax( (maxHeight - boxHeight) / 2, 0);
}
// invalidate position hint, use only once
d->positionHint = QRect();
}
else
{
// use standard position
x = qMax( (maxWidth - boxWidth) / 2, 0);
y = qMax( (maxHeight - boxHeight) / 2, 0);
}
}
// create a rectangle relative to image
QRect drawRect( x, y, fontWidth + 2 * borderWidth + 2 * spacing, fontHeight + 2 * borderWidth + 2 * spacing);
// create a rectangle relative to textArea, excluding the border
QRect textAreaBackgroundRect( borderWidth, borderWidth, fontWidth + 2 * spacing, fontHeight + 2 * spacing);
// create a rectangle relative to textArea, excluding the border and spacing
QRect textAreaTextRect( borderWidth + spacing, borderWidth + spacing, fontWidth, fontHeight );
// create a rectangle relative to textArea, including the border,
// for drawing the rectangle, taking into account that the width of the QPen goes in and out in equal parts
QRect textAreaDrawRect( borderWidth / 2, borderWidth / 2, fontWidth + borderWidth + 2 * spacing,
fontHeight + borderWidth + 2 * spacing );
// cut out the text area
DImg textArea = image->copy(drawRect);
if (textArea.isNull())
{
return QRect();
}
// compose semi-transparent background over textArea
DColorComposer* composer = DColorComposer::getComposer(DColorComposer::PorterDuffNone);
if (transparentBackground)
{
DImg transparentLayer(textAreaBackgroundRect.width(), textAreaBackgroundRect.height(), textArea.sixteenBit(), true);
DColor transparent(backgroundColor);
transparent.setAlpha(d->transparency);
if (image->sixteenBit())
{
transparent.convertToSixteenBit();
}
transparentLayer.fill(transparent);
textArea.bitBlendImage(composer, &transparentLayer, 0, 0, transparentLayer.width(), transparentLayer.height(),
textAreaBackgroundRect.x(), textAreaBackgroundRect.y());
}
DImg textNotDrawn;
if (textArea.sixteenBit())
{
textNotDrawn = textArea.copy();
textNotDrawn.convertToEightBit();
}
else
{
textNotDrawn = textArea;
}
// We have no direct pixel access to font rendering, so now we need to use Qt/X11 for the drawing
// convert text area to pixmap
QPixmap pixmap;
if (destPainter)
{
// We working on tool preview, deal with CM as well
pixmap = d->iface->convertToPixmap(textNotDrawn);
}
else
{
// We working on target image. Do no apply double CM adjustment here.
pixmap = textNotDrawn.convertToPixmap();
}
int fontScaleWidth = qRound(fontWidth / fontScale);
int fontScaleHeight = qRound(fontHeight / fontScale);
QPixmap textPixmap(fontScaleWidth, fontScaleHeight);
textPixmap.fill(Qt::transparent);
QPainter tp(&textPixmap);
tp.setOpacity((qreal)textOpacity / 100.0);
tp.setPen(QPen(textColor, 1));
tp.setFont(font);
switch (textRotation)
{
case ROTATION_NONE:
tp.drawText(0, 0, fontScaleWidth, fontScaleHeight,
alignMode, textString);
break;
case ROTATION_90:
tp.translate(fontScaleWidth, 0);
tp.rotate(90.0);
tp.drawText(0, 0, fontScaleHeight, fontScaleWidth,
alignMode, textString);
break;
case ROTATION_180:
tp.translate(fontScaleWidth, fontScaleHeight);
tp.rotate(180.0);
tp.drawText(0, 0, fontScaleWidth, fontScaleHeight,
alignMode, textString);
break;
case ROTATION_270:
tp.translate(0, fontScaleHeight);
tp.rotate(270.0);
tp.drawText(0, 0, fontScaleHeight, fontScaleWidth,
alignMode, textString);
break;
}
tp.end();
// paint on pixmap
QPainter p(&pixmap);
p.drawPixmap(textAreaTextRect, textPixmap.scaled(fontWidth,
fontHeight,
Qt::IgnoreAspectRatio,
Qt::SmoothTransformation));
// Drawing rectangle around text.
if (borderMode == BORDER_NORMAL) // Decorative border using text color.
{
p.setPen( QPen(textColor, borderWidth, Qt::SolidLine,
Qt::SquareCap, Qt::RoundJoin) ) ;
p.drawRect(textAreaDrawRect);
}
else if (borderMode == BORDER_SUPPORT) // Make simple dot line border to help user.
{
p.setPen(QPen(Qt::white, 1, Qt::SolidLine));
p.drawRect(textAreaDrawRect);
p.setPen(QPen(Qt::red, 1, Qt::DotLine));
p.drawRect(textAreaDrawRect);
}
p.end();
if (!destPainter)
{
// convert to QImage, then to DImg
QImage pixmapImage = pixmap.toImage();
DImg textDrawn(pixmapImage.width(), pixmapImage.height(), false, true, pixmapImage.bits());
// This does not work: during the conversion, colors are altered significantly (diffs of 1 to 10 in each component),
// so we cannot find out which pixels have actually been touched.
/*
// Compare the result of drawing with the previous version.
// Set all unchanged pixels to transparent
DColor color, ncolor;
uchar *ptr, *nptr;
ptr = textDrawn.bits();
nptr = textNotDrawn.bits();
int bytesDepth = textDrawn.bytesDepth();
int numPixels = textDrawn.width() * textDrawn.height();
for (int i = 0; i < numPixels; ++i, ptr+= bytesDepth, nptr += bytesDepth)
{
color.setColor(ptr, false);
ncolor.setColor(nptr, false);
if ( color.red() == ncolor.red() &&
color.green() == ncolor.green() &&
color.blue() == ncolor.blue())
{
color.setAlpha(0);
color.setPixel(ptr);
}
}
// convert to 16 bit if needed
*/
textDrawn.convertToDepthOfImage(&textArea);
// now compose to original: only pixels affected by drawing text and border are changed, not whole area
textArea.bitBlendImage(composer, &textDrawn, 0, 0, textDrawn.width(), textDrawn.height(), 0, 0);
// copy result to original image
image->bitBltImage(&textArea, drawRect.x(), drawRect.y());
}
else
{
destPainter->drawPixmap(drawRect.x(), drawRect.y(), pixmap, 0, 0, pixmap.width(), pixmap.height());
}
delete composer;
return drawRect;
}
bool WaterMark::toolOperations()
{
if (!loadToDImg())
{
return false;
}
QString fileName = settings()[QLatin1String("Watermark image")].toString();
int placement = settings()[QLatin1String("Placement")].toInt();
int size = settings()[QLatin1String("Watermark size")].toInt();
int xMargin = settings()[QLatin1String("X margin")].toInt();
int yMargin = settings()[QLatin1String("Y margin")].toInt();
bool useImage = settings()[QLatin1String("Use image")].toBool();
QString text = settings()[QLatin1String("Text")].toString();
QFont font = settings()[QLatin1String("Font")].toString();
QColor fontColor = settings()[QLatin1String("Color")].toString();
int textOpacity = settings()[QLatin1String("Text opacity")].toInt();
bool useBackground = settings()[QLatin1String("Use background")].toBool();
QColor backgroundColor = settings()[QLatin1String("Background color")].toString();
int backgroundOpacity = settings()[QLatin1String("Background opacity")].toInt();
DImg watermarkImage;
DColorComposer* composer = DColorComposer::getComposer(DColorComposer::PorterDuffNone);
int marginW = lround(image().width() * (xMargin / 100.0));
int marginH = lround(image().height() * (yMargin / 100.0));
if (useImage)
{
watermarkImage = DImg(fileName);
if (watermarkImage.isNull())
{
return false;
}
DImg tempImage = watermarkImage.smoothScale(image().width() * size / 100, image().height() * size / 100, Qt::KeepAspectRatio);
watermarkImage = tempImage;
}
else
{
int alignMode;
const int radius = 10;
if (text.isEmpty())
{
return false;
}
int fontSize = queryFontSize(text, font, size);
if (fontSize == 0)
{
return false;
}
switch (placement)
{
case Private::TopLeft:
alignMode = Qt::AlignLeft;
break;
case Private::TopRight:
alignMode = Qt::AlignRight;
break;
case Private::BottomLeft:
alignMode = Qt::AlignLeft;
break;
case Private::Center:
alignMode = Qt::AlignCenter;
break;
default : // BottomRight
alignMode = Qt::AlignRight;
break;
}
font.setPointSizeF(fontSize);
QFontMetrics fontMt(font);
QRect fontRect = fontMt.boundingRect(radius, radius, image().width(), image().height(), 0, text);
// Add a transparent layer.
QRect backgroundRect(fontRect.x() - radius, fontRect.y() - radius,
fontRect.width() + 2 * radius, fontRect.height() + 2 * radius);
DImg backgroundLayer(backgroundRect.width(), backgroundRect.height(), image().sixteenBit(), true);
DColor transparent(QColor(0, 0, 0));
transparent.setAlpha(0);
if (image().sixteenBit())
{
transparent.convertToSixteenBit();
}
backgroundLayer.fill(transparent);
DImg grayTransLayer(fontRect.width(), fontRect.height(), image().sixteenBit(), true);
if (useBackground)
{
DColor grayTrans(backgroundColor);
grayTrans.setAlpha(backgroundOpacity * 255 / 100);
if (image().sixteenBit())
{
grayTrans.convertToSixteenBit();
}
grayTransLayer.fill(grayTrans);
backgroundLayer.bitBlendImage(composer, &grayTransLayer, 0, 0,
grayTransLayer.width(), grayTransLayer.height(),
radius, radius);
}
BlurFilter blur(&backgroundLayer, 0L, radius);
blur.startFilterDirectly();
backgroundLayer.putImageData(blur.getTargetImage().bits());
// Draw text
QImage img = backgroundLayer.copyQImage(fontRect);
QPainter p(&img);
fontColor.setAlpha(textOpacity * 255 / 100);
p.setPen(QPen(fontColor, 1));
p.setFont(font);
p.save();
p.drawText(0, 0, fontRect.width(), fontRect.height(), alignMode, text);
p.restore();
p.end();
watermarkImage = DImg(img);
}
watermarkImage.convertToDepthOfImage(&image());
QRect watermarkRect(0, 0, watermarkImage.width(), watermarkImage.height());
switch (placement)
{
case Private::TopLeft:
watermarkRect.moveTopLeft(QPoint(marginW, marginH));
break;
case Private::TopRight:
watermarkRect.moveTopRight(QPoint(image().width() - marginW, marginH));
break;
case Private::BottomLeft:
watermarkRect.moveBottomLeft(QPoint(marginW, image().height() - marginH));
break;
case Private::Center:
watermarkRect.moveCenter(QPoint((int)(image().width() / 2), (int)(image().height() / 2)));
break;
default : // BottomRight
watermarkRect.moveBottomRight(QPoint(image().width() - marginW, image().height() - marginH));
break;
}
// TODO: Create watermark filter, move code there, implement FilterAction
image().bitBlendImage(composer, &watermarkImage, 0, 0, watermarkImage.width(), watermarkImage.height(),
watermarkRect.left(), watermarkRect.top());
delete composer;
return (savefromDImg());
}