DImg Canvas::currentImage() const
{
DImg* const image = d->core->getImg();
if (image)
{
return DImg(*image);
}
return DImg();
}
void BorderFilter::solid2(DImg& src, DImg& dest, const DColor& fg, int borderWidth)
{
dest = DImg(src.width() + borderWidth * 2, src.height() + borderWidth * 2,
src.sixteenBit(), src.hasAlpha());
dest.fill(fg);
dest.bitBltImage(&src, borderWidth, borderWidth);
}
void LevelsFilter::filterImage()
{
ImageLevels levels(m_orgImage.sixteenBit());
for (int i = 0 ; i < 5 ; ++i)
{
postProgress(i * 10);
levels.setLevelLowInputValue(i, m_settings.lInput[i]);
levels.setLevelHighInputValue(i, m_settings.hInput[i]);
levels.setLevelLowOutputValue(i, m_settings.lOutput[i]);
levels.setLevelHighOutputValue(i, m_settings.hOutput[i]);
levels.setLevelGammaValue(i, m_settings.gamma[i]);
}
postProgress(50);
m_destImage = DImg(m_orgImage.width(), m_orgImage.height(), m_orgImage.sixteenBit(), m_orgImage.hasAlpha());
postProgress(60);
levels.levelsCalculateTransfers();
postProgress(70);
// Process all channels Levels
levels.levelsLutSetup(AlphaChannel);
postProgress(80);
levels.levelsLutProcess(m_orgImage.bits(), m_destImage.bits(), m_orgImage.width(), m_orgImage.height());
postProgress(90);
}
DImg SharedLoadSaveThread::cacheLookup(const QString& filePath, AccessMode /*accessMode*/)
{
LoadingCache* cache = LoadingCache::cache();
LoadingCache::CacheLock lock(cache);
DImg* cachedImg = cache->retrieveImage(filePath);
// Qt4: uncomment this code.
// See comments in SharedLoadingTask::execute for explanation.
/*
if (cachedImg)
{
if (accessMode == AccessModeReadWrite)
return cachedImg->copy();
else
return *cachedImg;
}
else
return DImg();
*/
if (cachedImg)
{
return cachedImg->copy();
}
else
{
return DImg();
}
}
DImg ImageIface::preview() const
{
// NOTE: corrects the values for width and height of the preview image from the image data interface
// See Bug #320382 for details.
uchar* const data = d->previewImageData();
return DImg(d->previewWidth, d->previewHeight, previewSixteenBit(), previewHasAlpha(), data);
}
DImg UndoCache::getData(int level) const
{
int w = 0;
int h = 0;
bool sixteenBit = false;
bool hasAlpha = false;
QFile file(d->cacheFile(level));
if (!file.open(QIODevice::ReadOnly))
{
return DImg();
}
QDataStream ds(&file);
ds >> w;
ds >> h;
ds >> sixteenBit;
ds >> hasAlpha;
QByteArray ba;
ds >> ba;
DImg img(w, h, sixteenBit, hasAlpha, (uchar*)ba.data(), true);
file.close();
return img;
}
ImageRegionItem::ImageRegionItem(ImageRegionWidget* const widget):
d_ptr(new Private)
{
d_ptr->view = widget;
d_ptr->iface = new ImageIface;
setAcceptHoverEvents(true);
setImage(d_ptr->iface->original() ? d_ptr->iface->original()->copy() : DImg());
}
void BorderFilter::solid(DImg& src, DImg& dest, const DColor& fg, int borderWidth)
{
if (d->settings.orgWidth > d->settings.orgHeight)
{
int height = src.height() + borderWidth * 2;
dest = DImg((int)(height * d->orgRatio), height, src.sixteenBit(), src.hasAlpha());
dest.fill(fg);
dest.bitBltImage(&src, (dest.width() - src.width()) / 2, borderWidth);
}
else
{
int width = src.width() + borderWidth * 2;
dest = DImg(width, (int)(width / d->orgRatio), src.sixteenBit(), src.hasAlpha());
dest.fill(fg);
dest.bitBltImage(&src, borderWidth, (dest.height() - src.height()) / 2);
}
}
void WhiteBalanceTool::setPreviewImage()
{
DImg preview = filter()->getTargetImage();
d->previewWidget->setPreviewImage(preview);
// Update histogram.
d->gboxSettings->histogramBox()->histogram()->updateData(preview.copy(), DImg(), false);
}
void BorderFilter::bevel2(DImg& src, DImg& dest, const DColor& topColor,
const DColor& btmColor, int borderWidth)
{
int x, y;
int wc;
dest = DImg(src.width() + borderWidth * 2,
src.height() + borderWidth * 2,
src.sixteenBit(), src.hasAlpha());
// top
for (y = 0, wc = (int)dest.width() - 1; y < borderWidth; ++y, --wc)
{
for (x = 0; x < wc; ++x)
{
dest.setPixelColor(x, y, topColor);
}
for (; x < (int)dest.width(); ++x)
{
dest.setPixelColor(x, y, btmColor);
}
}
// left and right
for (; y < (int)dest.height() - borderWidth; ++y)
{
for (x = 0; x < borderWidth; ++x)
{
dest.setPixelColor(x, y, topColor);
}
for (x = (int)dest.width() - 1; x > (int)dest.width() - borderWidth - 1; --x)
{
dest.setPixelColor(x, y, btmColor);
}
}
// bottom
for (wc = borderWidth; y < (int)dest.height(); ++y, --wc)
{
for (x = 0; x < wc; ++x)
{
dest.setPixelColor(x, y, topColor);
}
for (; x < (int)dest.width(); ++x)
{
dest.setPixelColor(x, y, btmColor);
}
}
dest.bitBltImage(&src, borderWidth, borderWidth);
}
void RawImport::slotLoadingStarted()
{
d->postProcessedImage = DImg();
d->settingsBox->enableUpdateBtn(false);
d->settingsBox->histogramBox()->histogram()->setDataLoading();
d->settingsBox->curvesWidget()->setDataLoading();
EditorToolIface::editorToolIface()->setToolStartProgress(i18n("Raw Decoding"));
setBusy(true);
}
void RawImport::slotOk()
{
// NOTE: work around bug #211810
if (d->settingsBox->curvesWidget()->isSixteenBits() != d->settingsBox->settings().rawPrm.sixteenBitsImage)
{
d->settingsBox->curvesWidget()->updateData(DImg(0, 0, d->settingsBox->settings().rawPrm.sixteenBitsImage));
}
EditorTool::slotOk();
}
void LightTablePreview::setDragAndDropMessage()
{
if (d->dragAndDropEnabled)
{
QPixmap pix(visibleWidth(), visibleHeight());
pix.fill(ThemeEngine::instance()->baseColor());
QPainter p(&pix);
p.setPen(QPen(ThemeEngine::instance()->textRegColor()));
p.drawText(0, 0, pix.width(), pix.height(),
Qt::AlignCenter|Qt::TextWordWrap,
i18n("Drag and drop an image here"));
p.end();
setImage(DImg(pix.toImage()));
}
}
RefocusFilter::RefocusFilter(DImg* const orgImage, QObject* const parent, int matrixSize, double radius,
double gauss, double correlation, double noise)
: DImgThreadedFilter(orgImage, parent, QLatin1String("Refocus")),
d(new Private)
{
d->matrixSize = matrixSize;
d->radius = radius;
d->gauss = gauss;
d->correlation = correlation;
d->noise = noise;
// initialize filter
initFilter();
// initialize intermediate image
d->preImage = DImg(orgImage->width() + 4 * MAX_MATRIX_SIZE,
orgImage->height() + 4 * MAX_MATRIX_SIZE,
orgImage->sixteenBit(), orgImage->hasAlpha());
}
SharpenFilter::SharpenFilter(DImgThreadedFilter* const parentFilter,
const DImg& orgImage, const DImg& destImage,
int progressBegin, int progressEnd, double radius, double sigma)
: DImgThreadedFilter(parentFilter, orgImage, destImage, progressBegin, progressEnd,
parentFilter->filterName() + QLatin1String(": Sharpen"))
{
m_radius = radius;
m_sigma = sigma;
// We need to provide support for orgImage == destImage.
// The algorithm does not support this out of the box, so use a temporary.
if (orgImage.bits() == destImage.bits())
{
m_destImage = DImg(destImage.width(), destImage.height(), destImage.sixteenBit());
}
filterImage();
if (orgImage.bits() == destImage.bits())
{
memcpy(destImage.bits(), m_destImage.bits(), m_destImage.numBytes());
}
}
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();
}
}
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());
}
void FreeRotationFilter::filterImage()
{
int progress;
register int w, h, nw, nh, j, i = 0;
int nNewHeight, nNewWidth;
int nhdx, nhdy, nhsx, nhsy;
double lfSin, lfCos, lfx, lfy;
int nWidth = m_orgImage.width();
int nHeight = m_orgImage.height();
uchar* pBits = m_orgImage.bits();
unsigned short* pBits16 = (unsigned short*)m_orgImage.bits();
// first of all, we need to calculate the sin and cos of the given angle
lfSin = sin(d->settings.angle * -d->DEG2RAD);
lfCos = cos(d->settings.angle * -d->DEG2RAD);
// now, we have to calc the new size for the destination image
if ((lfSin * lfCos) < 0)
{
nNewWidth = lround (fabs (nWidth * lfCos - nHeight * lfSin));
nNewHeight = lround (fabs (nWidth * lfSin - nHeight * lfCos));
}
else
{
nNewWidth = lround (fabs (nWidth * lfCos + nHeight * lfSin));
nNewHeight = lround (fabs (nWidth * lfSin + nHeight * lfCos));
}
// getting the destination's center position
nhdx = nNewWidth / 2;
nhdy = nNewHeight / 2;
// getting the source's center position
nhsx = nWidth / 2;
nhsy = nHeight / 2;
// now, we have to alloc a new image
bool sixteenBit = m_orgImage.sixteenBit();
m_destImage = DImg(nNewWidth, nNewHeight, sixteenBit, m_orgImage.hasAlpha());
if (m_destImage.isNull())
{
return;
}
m_destImage.fill( DColor(d->settings.backgroundColor.rgb(), sixteenBit) );
uchar* pResBits = m_destImage.bits();
unsigned short* pResBits16 = (unsigned short*)m_destImage.bits();
PixelsAliasFilter alias;
// main loop
for (h = 0; runningFlag() && (h < nNewHeight); ++h)
{
nh = h - nhdy;
for (w = 0; runningFlag() && (w < nNewWidth); ++w)
{
nw = w - nhdx;
i = setPosition (nNewWidth, w, h);
lfx = (double)nw * lfCos - (double)nh * lfSin + nhsx;
lfy = (double)nw * lfSin + (double)nh * lfCos + nhsy;
if (isInside (nWidth, nHeight, (int)lfx, (int)lfy))
{
if (d->settings.antiAlias)
{
if (!sixteenBit)
alias.pixelAntiAliasing(pBits, nWidth, nHeight, lfx, lfy,
&pResBits[i+3], &pResBits[i+2],
&pResBits[i+1], &pResBits[i]);
else
alias.pixelAntiAliasing16(pBits16, nWidth, nHeight, lfx, lfy,
&pResBits16[i+3], &pResBits16[i+2],
&pResBits16[i+1], &pResBits16[i]);
}
else
{
j = setPosition (nWidth, (int)lfx, (int)lfy);
for (int p = 0 ; p < 4 ; ++p)
{
if (!sixteenBit)
{
pResBits[i] = pBits[j];
}
else
{
pResBits16[i] = pBits16[j];
}
++i;
++j;
}
}
}
}
// Update the progress bar in dialog.
progress = (int) (((double) h * 100.0) / nNewHeight);
if (progress % 5 == 0)
{
postProgress(progress);
}
}
// Compute the rotated destination image size using original image dimensions.
int W, H;
double absAngle = fabs(d->settings.angle);
// stop here when no angle was set
if (absAngle == 0.0)
{
return;
}
if (absAngle < 90.0)
{
W = (int)(d->settings.orgW * cos(absAngle * d->DEG2RAD) + d->settings.orgH * sin(absAngle * d->DEG2RAD));
H = (int)(d->settings.orgH * cos(absAngle * d->DEG2RAD) + d->settings.orgW * sin(absAngle * d->DEG2RAD));
}
else
{
H = (int)(d->settings.orgW * cos((absAngle-90.0) * d->DEG2RAD) + d->settings.orgH * sin((absAngle-90.0) * d->DEG2RAD));
W = (int)(d->settings.orgH * cos((absAngle-90.0) * d->DEG2RAD) + d->settings.orgW * sin((absAngle-90.0) * d->DEG2RAD));
}
// Auto-cropping destination image without black holes around.
QRect autoCrop;
switch (d->settings.autoCrop)
{
case FreeRotationContainer::WidestArea:
{
// 'Widest Area' method (by Renchi Raju).
autoCrop.setX((int) (nHeight * sin(absAngle * d->DEG2RAD)));
autoCrop.setY((int) (nWidth * sin(absAngle * d->DEG2RAD)));
autoCrop.setWidth((int) (nNewWidth - 2* nHeight * sin(absAngle * d->DEG2RAD)));
autoCrop.setHeight((int) (nNewHeight - 2* nWidth * sin(absAngle * d->DEG2RAD)));
if (!autoCrop.isValid())
{
m_destImage = DImg(m_orgImage.width(), m_orgImage.height(), m_orgImage.sixteenBit(),
m_orgImage.hasAlpha());
m_destImage.fill(DColor(d->settings.backgroundColor.rgb(), sixteenBit));
d->settings.newSize = QSize();
}
else
{
m_destImage = m_destImage.copy(autoCrop);
d->settings.newSize.setWidth((int) (W - 2* d->settings.orgH * sin(absAngle * d->DEG2RAD)));
d->settings.newSize.setHeight((int) (H - 2* d->settings.orgW * sin(absAngle * d->DEG2RAD)));
}
break;
}
case FreeRotationContainer::LargestArea:
{
// 'Largest Area' method (by Gerhard Kulzer).
float gamma = 0.0f;
if (nHeight > nWidth)
{
gamma = atan((float) nWidth / (float) nHeight);
if (absAngle < 90.0)
{
autoCrop.setHeight((int) ((float) nWidth / cos(absAngle * d->DEG2RAD) / (tan(gamma) +
tan(absAngle * d->DEG2RAD))));
autoCrop.setWidth((int) ((float) autoCrop.height() * tan(gamma)));
}
else
{
autoCrop.setWidth((int) ((float) nWidth / cos((absAngle - 90.0) * d->DEG2RAD) / (tan(gamma) +
tan((absAngle - 90.0) * d->DEG2RAD))));
autoCrop.setHeight((int) ((float) autoCrop.width() * tan(gamma)));
}
}
else
{
gamma = atan((float) nHeight / (float) nWidth);
if (absAngle < 90.0)
{
autoCrop.setWidth((int) ((float) nHeight / cos(absAngle * d->DEG2RAD) / (tan(gamma) +
tan(absAngle * d->DEG2RAD))));
autoCrop.setHeight((int) ((float) autoCrop.width() * tan(gamma)));
}
else
{
autoCrop.setHeight((int) ((float) nHeight / cos((absAngle - 90.0) * d->DEG2RAD) /
(tan(gamma) + tan((absAngle - 90.0) * d->DEG2RAD))));
autoCrop.setWidth((int) ((float) autoCrop.height() * tan(gamma)));
}
}
autoCrop.moveCenter(QPoint(nNewWidth / 2, nNewHeight / 2));
if (!autoCrop.isValid())
{
m_destImage = DImg(m_orgImage.width(), m_orgImage.height(), m_orgImage.sixteenBit(),
m_orgImage.hasAlpha());
m_destImage.fill(DColor(d->settings.backgroundColor.rgb(), sixteenBit));
d->settings.newSize = QSize();
}
else
{
m_destImage = m_destImage.copy(autoCrop);
gamma = atan((float) d->settings.orgH / (float) d->settings.orgW);
if (absAngle < 90.0)
{
d->settings.newSize.setWidth((int) ((float) d->settings.orgH / cos(absAngle * d->DEG2RAD) / (tan(gamma) +
tan(absAngle * d->DEG2RAD))));
d->settings.newSize.setHeight((int) ((float) d->settings.newSize.width() * tan(gamma)));
}
else
{
d->settings.newSize.setHeight((int) ((float) d->settings.orgH / cos((absAngle - 90.0) * d->DEG2RAD) /
(tan(gamma) + tan((absAngle - 90.0) * d->DEG2RAD))));
d->settings.newSize.setWidth((int) ((float) d->settings.newSize.height() * tan(gamma)));
}
}
break;
}
default: // No auto cropping.
{
d->settings.newSize.setWidth(W);
d->settings.newSize.setHeight(H);
break;
}
}
}
void BorderFilter::bevel(DImg& src, DImg& dest, const DColor& topColor,
const DColor& btmColor, int borderWidth)
{
int width, height;
if (d->settings.orgWidth > d->settings.orgHeight)
{
height = src.height() + borderWidth * 2;
width = (int)(height * d->orgRatio);
}
else
{
width = src.width() + borderWidth * 2;
height = (int)(width / d->orgRatio);
}
dest = DImg(width, height, src.sixteenBit(), src.hasAlpha());
dest.fill(topColor);
QPolygon btTriangle(3);
btTriangle.setPoint(0, width, 0);
btTriangle.setPoint(1, 0, height);
btTriangle.setPoint(2, width, height);
QRegion btRegion(btTriangle);
// paint upper right corner
QPoint upperRightCorner((width - ((width - src.width()) / 2) - 2),
((0 + (height - src.height())) / 2 + 2)
);
for (int x = upperRightCorner.x(); x < width; ++x)
{
for (int y = 0; y < upperRightCorner.y(); ++y)
{
if (btRegion.contains(QPoint(x, y)))
{
dest.setPixelColor(x, y, btmColor);
}
}
}
// paint right border
for (int x = upperRightCorner.x(); x < width; ++x)
{
for (int y = upperRightCorner.y(); y < height; ++y)
{
dest.setPixelColor(x, y, btmColor);
}
}
// paint lower left corner
QPoint lowerLeftCorner((0 + ((width - src.width()) / 2) + 2),
(height - ((height - src.height()) / 2) - 2)
);
for (int x = 0; x < lowerLeftCorner.x(); ++x)
{
for (int y = lowerLeftCorner.y(); y < height; ++y)
{
if (btRegion.contains(QPoint(x, y)))
{
dest.setPixelColor(x, y, btmColor);
}
}
}
// paint bottom border
for (int x = lowerLeftCorner.x(); x < width; ++x)
{
for (int y = lowerLeftCorner.y(); y < height; ++y)
{
dest.setPixelColor(x, y, btmColor);
}
}
if (d->settings.orgWidth > d->settings.orgHeight)
{
dest.bitBltImage(&src, (dest.width() - src.width()) / 2, borderWidth);
}
else
{
dest.bitBltImage(&src, borderWidth, (dest.height() - src.height()) / 2);
}
}
bool UserScript::toolOperations()
{
QString script = settings()[QLatin1String("Script")].toString();
if (script.isEmpty())
{
setErrorDescription(i18n("User Script: No script."));
return false;
}
// Replace all occurences of $INPUT and $OUTPUT in script to file names. Case sensitive.
script.replace(QLatin1String("$INPUT"), QLatin1Char('"') + inputUrl().toLocalFile() + QLatin1Char('"'));
script.replace(QLatin1String("$OUTPUT"), QLatin1Char('"') + outputUrl().toLocalFile() + QLatin1Char('"'));
QString shellScript;
#ifndef WIN32
QString envCmd = QLatin1String("export ");
#else
QString envCmd = QLatin1String("set ");
#endif // WIN32
QString tagPath = TagsCache::instance()->tagPaths(imageInfo().tagIds(), TagsCache::NoLeadingSlash,
TagsCache::NoHiddenTags).join(QLatin1Char(';'));
// Populate env variables from metadata
shellScript.append(envCmd + QString::fromUtf8("COLORLABEL=\"%1\"\n").arg(imageInfo().colorLabel()));
shellScript.append(envCmd + QString::fromUtf8("PICKLABEL=\"%1\"\n") .arg(imageInfo().pickLabel()));
shellScript.append(envCmd + QString::fromUtf8("COMMENTS=\"%1\"\n") .arg(imageInfo().comment()));
shellScript.append(envCmd + QString::fromUtf8("RATING=\"%1\"\n") .arg(imageInfo().rating()));
shellScript.append(envCmd + QString::fromUtf8("TITLE=\"%1\"\n") .arg(imageInfo().title()));
shellScript.append(envCmd + QString::fromUtf8("TAGSPATH=\"%1\"\n") .arg(tagPath));
shellScript.append(script);
// Empties d->image, not to pass it to the next tool in chain
setImageData(DImg());
QProcess process(this);
// call the shell script
#ifndef WIN32
int returncode = process.execute(QLatin1String("/bin/sh"), QStringList() << QLatin1String("-c") << shellScript);
#else
int returncode = process.execute(QLatin1String("cmd.exe"), QStringList() << QLatin1String("/c") << shellScript);
#endif // WIN32
if (returncode == -2)
{
setErrorDescription(i18n("User Script: Failed to start script."));
return false;
}
if (returncode == -1)
{
setErrorDescription(i18n("User Script: Script process crashed."));
return false;
}
if (returncode == 127)
{
setErrorDescription(i18n("User Script: Command not found."));
return false;
}
return true;
}
void ShearFilter::filterImage()
{
int progress;
register int x, y, p = 0, pt;
int new_width, new_height;
double nx, ny, dx, dy;
double horz_factor, vert_factor;
double horz_add, vert_add;
double horz_beta_angle, vert_beta_angle;
int nWidth = m_orgImage.width();
int nHeight = m_orgImage.height();
uchar* pBits = m_orgImage.bits();
unsigned short* pBits16 = reinterpret_cast<unsigned short*>(m_orgImage.bits());
// get beta ( complementary ) angle for horizontal and vertical angles
horz_beta_angle = (((d->hAngle < 0.0) ? 180.0 : 90.0) - d->hAngle) * DEG2RAD;
vert_beta_angle = (((d->vAngle < 0.0) ? 180.0 : 90.0) - d->vAngle) * DEG2RAD;
// get new distance for width and height values
horz_add = nHeight * ((d->hAngle < 0.0) ? sin(horz_beta_angle) : cos(horz_beta_angle));
vert_add = nWidth * ((d->vAngle < 0.0) ? sin(vert_beta_angle) : cos(vert_beta_angle));
// get absolute values for the distances
horz_add = fabs(horz_add);
vert_add = fabs(vert_add);
// get new image size ( original size + distance )
new_width = (int)horz_add + nWidth;
new_height = (int)vert_add + nHeight;
// get scale factor for width and height
horz_factor = horz_add / new_height;
vert_factor = vert_add / new_width;
// if horizontal angle is greater than zero...
// else, initial distance is equal to maximum distance ( in negative form )
if (d->hAngle > 0.0)
{
// initial distance is zero and scale is negative ( to decrease )
dx = 0;
horz_factor *= -1.0;
}
else
{
dx = -horz_add;
}
// if vertical angle is greater than zero...
// else, initial distance is equal to maximum distance ( in negative form )
if (d->vAngle > 0.0)
{
// initial distance is zero and scale is negative ( to decrease )
dy = 0;
vert_factor *= -1.0;
}
else
{
dy = -vert_add;
}
// allocates a new image with the new size
bool sixteenBit = m_orgImage.sixteenBit();
m_destImage = DImg(new_width, new_height, sixteenBit, m_orgImage.hasAlpha());
m_destImage.fill(DColor(d->backgroundColor.rgb(), sixteenBit));
uchar* pResBits = m_destImage.bits();
unsigned short* pResBits16 = reinterpret_cast<unsigned short*>(m_destImage.bits());
PixelsAliasFilter alias;
for (y = 0; y < new_height; ++y)
{
for (x = 0; x < new_width; ++x, p += 4)
{
// get new positions
nx = x + dx + y * horz_factor;
ny = y + dy + x * vert_factor;
// if is inside the source image
if (isInside(nWidth, nHeight, lround(nx), lround(ny)))
{
if (d->antiAlias)
{
if (!sixteenBit)
alias.pixelAntiAliasing(pBits, nWidth, nHeight, nx, ny,
&pResBits[p + 3], &pResBits[p + 2],
&pResBits[p + 1], &pResBits[p]);
else
alias.pixelAntiAliasing16(pBits16, nWidth, nHeight, nx, ny,
&pResBits16[p + 3], &pResBits16[p + 2],
&pResBits16[p + 1], &pResBits16[p]);
}
else
{
pt = setPosition(nWidth, lround(nx), lround(ny));
for (int z = 0 ; z < 4 ; ++z)
{
if (!sixteenBit)
{
pResBits[p + z] = pBits[pt + z];
}
else
{
pResBits16[p + z] = pBits16[pt + z];
}
}
}
}
}
// Update the progress bar in dialog.
progress = (int)(((double)y * 100.0) / new_height);
if (progress % 5 == 0)
{
postProgress(progress);
}
}
// To compute the rotated destination image size using original image dimensions.
int W = (int)(fabs(d->orgH * ((d->hAngle < 0.0) ? sin(horz_beta_angle) : cos(horz_beta_angle)))) + d->orgW;
int H = (int)(fabs(d->orgW * ((d->vAngle < 0.0) ? sin(vert_beta_angle) : cos(vert_beta_angle)))) + d->orgH;
d->newSize.setWidth(W);
d->newSize.setHeight(H);
}
void PanIconWidget::setImage(int previewWidth, int previewHeight, const DImg& image)
{
DImg img = DImg(image).smoothScale(previewWidth, previewHeight, Qt::KeepAspectRatio);
setImage(img.copyQImage(), image.size());
}
