void ut_rotate::testRotateFilter()
{
QuillImageFilter *filter =
QuillImageFilterFactory::createImageFilter("org.maemo.rotate");
QVERIFY(filter);
QVERIFY(filter->supportsOption(QuillImageFilter::Angle));
QVERIFY(filter->setOption(QuillImageFilter::Angle, QVariant(90)));
bool bOK = true;
QCOMPARE(filter->option(QuillImageFilter::Angle).toDouble(&bOK), 90.0);
QVERIFY(bOK);
QuillImage image = Unittests::generatePaletteImage();
QCOMPARE(image.size(), QSize(8, 2));
QuillImage filteredImage = filter->apply(image);
QCOMPARE(filteredImage.size(), QSize(2, 8));
// Get reference image with QImage::transformed()
QuillImage compareToQImage = image.transformed(QTransform().rotate(90));
QCOMPARE(filteredImage, compareToQImage);
// Four rotates should produce the original image
QCOMPARE(filter->apply(filter->apply(filter->apply(filteredImage))),
image);
delete filter;
}
void ut_lanczos::testApply()
{
QVERIFY(filter->setOption(QuillImageFilter::SizeAfter,
QVariant(QSize(16, 16))));
QuillImage image = Unittests::generatePaletteImage();
QCOMPARE(image.size(), QSize(8, 2));
QuillImage filteredImage = filter->apply(image);
// Only verify size, for now
QCOMPARE(filteredImage.size(), QSize(16, 16));
}
void ut_scale::testScalePreview()
{
// No changes must be made to a preview image
QuillImageFilter *filter =
QuillImageFilterFactory::createImageFilter("org.maemo.scale");
QVERIFY(filter);
QVERIFY(filter->setOption(QuillImageFilter::SizeAfter, QSize(4, 1)));
QuillImage image = Unittests::generatePaletteImage();
QCOMPARE(image.size(), QSize(8, 2));
image.setFullImageSize(QSize(16, 4));
image.setArea(QRect(0, 0, 16, 4));
QuillImage image2 = filter->apply(image);
QCOMPARE(image2.size(), QSize(8, 2));
QCOMPARE(image2.fullImageSize(), QSize(4, 1));
QCOMPARE(image2.area(), QRect(0, 0, 4, 1));
QVERIFY(Unittests::compareImage(image, image2));
delete filter;
}
void ut_file::testOriginalAfterSave()
{
QTemporaryFile testFile;
testFile.open();
QuillImage image = Unittests::generatePaletteImage();
image.save(testFile.fileName(), "png");
QuillFile *file = new QuillFile(testFile.fileName(), Strings::png);
QuillFile *original = file->original();
// This makes us to setup the original's undo stack
QCOMPARE(original->fullImageSize(), image.size());
QuillImageFilter *filter =
QuillImageFilterFactory::createImageFilter(QuillImageFilter::Name_BrightnessContrast);
QVERIFY(filter);
filter->setOption(QuillImageFilter::Brightness, QVariant(20));
QuillImage processedImage = filter->apply(image);
file->runFilter(filter);
file->save();
Quill::releaseAndWait();
Quill::releaseAndWait();
Quill::releaseAndWait();
original->setDisplayLevel(0);
Quill::releaseAndWait();
QVERIFY(Unittests::compareImage(original->image(), image));
delete file;
delete original;
}
QuillImage LoadFilter::renderAlpha(const QuillImage &image,
const QColor &backgroundColor)
{
QuillImage target(image, QImage(image.size(), QImage::Format_RGB32));
target.fill(backgroundColor.rgb());
QPainter painter(&target);
painter.drawImage(QPoint(0, 0), image);
return target;
}
QuillImage TiltShift::apply(const QuillImage& image) const
{
if (image.isNull()) {
return image;
}
if (image.isFragment()) {
m_gaussianFilter->setOption(QuillImageFilter::Radius, QVariant(GAUSSIAN_BLUR_RADIUS_TILE));
} else if (image.size() == QSize(170, 170)) {
m_gaussianFilter->setOption(QuillImageFilter::Radius, QVariant(GAUSSIAN_BLUR_RADIUS_THUMBNAIL));
} else {
m_gaussianFilter->setOption(QuillImageFilter::Radius, QVariant(GAUSSIAN_BLUR_RADIUS_PREVIEW));
}
QuillImage blurredImage = m_gaussianFilter->apply(image);
float** mask = maskImage(image);
QImage resultImage(image.size(), QImage::Format_RGB32);
for (int y=0; y<image.height(); y++) {
const QRgb* originalPixelRow = (const QRgb*)image.constScanLine(y);
const QRgb* blurredPixelRow = (const QRgb*)blurredImage.constScanLine(y);
QRgb* resultPixelRow = (QRgb*)resultImage.scanLine(y);
for (int x=0; x<image.width(); x++) {
int red = qRed(originalPixelRow[x]) * mask[x][y] + qRed(blurredPixelRow[x]) * (1 - mask[x][y]);
int blue = qBlue(originalPixelRow[x]) * mask[x][y] + qBlue(blurredPixelRow[x]) * (1 - mask[x][y]);
int green = qGreen(originalPixelRow[x]) * mask[x][y] + qGreen(blurredPixelRow[x]) * (1 - mask[x][y]);
QColor result(red, green, blue);
result.setHsvF(result.hueF(), qMin(SATURATION_FACTOR * result.saturationF(), 1.0), result.valueF());
resultPixelRow[x] = result.rgb();
}
}
for (int i = 0; i < image.size().width(); i ++) {
delete[] mask[i];
}
delete[] mask;
return QuillImage(image, resultImage);
}
void ut_serialsaver::testSerialSaver()
{
QTemporaryFile testFile;
testFile.open();
QByteArray metadata = QByteArray();
QuillImage image =
Unittests::generatePaletteImage().transformed(QTransform().rotate(90)).
scaled(QSize(16, 64));
SerialSaver serialSaver(testFile.fileName(), image.size(),metadata);
QVERIFY(serialSaver.process(image.copy(0, 0, 16, 16)));
QVERIFY(serialSaver.process(image.copy(0, 16, 16, 16)));
QVERIFY(serialSaver.process(image.copy(0, 32, 16, 16)));
QVERIFY(serialSaver.process(image.copy(0, 48, 16, 16)));
QImage resultImage(testFile.fileName());
Unittests::compareImage(resultImage, image);
}
void ut_load::testLoadSetTargetSizeOnly()
{
QTemporaryFile testFile;
testFile.open();
Unittests::generatePaletteImage().save(testFile.fileName(), "jpg");
QuillImageFilter filter("com.meego.load");
filter.setOption(QuillImageFilter::FileName,
QVariant(testFile.fileName()));
filter.setOption(QuillImageFilter::MimeType,
QVariant("image/jpeg"));
QuillImage image;
image.setTargetSize(QSize(4, 1));
QuillImage loadedImage = filter.apply(image);
QCOMPARE(loadedImage.size(), QSize(4, 1));
}
void ut_load::testExifRotation()
{
QTemporaryFile testFile;
testFile.open();
QImage image("/usr/share/quillimagefilter-tests/images/16_color_palette.png");
image.save(testFile.fileName(), "jpeg");
QuillMetadata metadata;
metadata.setEntry(QuillMetadata::Tag_Orientation, QVariant(6));
metadata.write(testFile.fileName());
QuillImageFilter *filter =
QuillImageFilterFactory::createImageFilter("org.maemo.load");
filter->setOption(QuillImageFilter::FileName, QString(testFile.fileName()));
QuillImage resultImage = filter->apply(QuillImage());
QCOMPARE(resultImage.size(), QSize(2, 8));
delete filter;
}
void ut_load::testCropping()
{
QuillImageFilter *filter =
QuillImageFilterFactory::createImageFilter("org.maemo.load");
QFile file("/usr/share/quillimagefilter-tests/images/16_color_palette.png");
filter->setOption(QuillImageFilter::FileName, QString(file.fileName()));
QuillImage target = QuillImage();
target.setTargetSize(QSize(1, 1));
target.setFullImageSize(QSize(8, 2));
target.setArea(QRect(2, 0, 2, 2));
QuillImage result = filter->apply(target);
QCOMPARE(result.size(), QSize(1, 1));
// Expect an average of the given area (png = smooth scaling).
QCOMPARE(qRed(result.pixel(QPoint(0,0))), 96);
QCOMPARE(qGreen(result.pixel(QPoint(0,0))), 193);
QCOMPARE(qBlue(result.pixel(QPoint(0,0))), 0);
delete filter;
}
QuillImage SaveFilter::saveJpeg(const QuillImage &image) const
{
// For thumbnail saving, set save target size to the thumbnail size
QSize targetSize = image.fullImageSize();
if (!image.isFragment())
targetSize = image.size();
if (priv->serialSaver == 0)
priv->serialSaver = new SerialSaver(priv->fileName,
targetSize,
priv->rawExifData);
bool result = priv->serialSaver->process(image);
priv->tileCount--;
setFileModificationDateTime();
if (result)
return image;
else
return QuillImage();
}
void ut_tileloading::testMultiOperation()
{
QTemporaryFile tempFile;
tempFile.open();
// The original file may be write protected and edits are disabled for
// such files so we need to make a copy
QImage originalImage("/usr/share/libquill-tests/images/image_16x4.png");
originalImage.save(tempFile.fileName(), "jpg");
Quill::setDefaultTileSize(QSize(2, 2));
QuillFile *file =
new QuillFile(tempFile.fileName(), Strings::jpg);
file->setViewPort(QRect(-8, -2, 16, 4));
file->setDisplayLevel(1);
QuillImageFilter *filter =
QuillImageFilterFactory::createImageFilter(QuillImageFilter::Name_BrightnessContrast);
filter->setOption(QuillImageFilter::Brightness,
QVariant(20));
QImage referenceImage = filter->apply(originalImage);
file->runFilter(filter);
Quill::releaseAndWait(); // preview load
Quill::releaseAndWait(); // preview filter
QCOMPARE(file->allImageLevels().count(), 1);
QuillImage previewImage = file->allImageLevels().at(0);
QCOMPARE(previewImage.size(), QSize(4, 1));
QCOMPARE(previewImage.fullImageSize(), QSize(16, 4));
Quill::releaseAndWait();
QCOMPARE(file->allImageLevels().count(), 1);
Quill::releaseAndWait();
QCOMPARE(file->allImageLevels().count(), 2);
QuillImage fragment = file->allImageLevels().at(1);
QCOMPARE(fragment.size(), QSize(2, 2));
QCOMPARE(fragment.fullImageSize(), QSize(16, 4));
QCOMPARE(fragment.area(), QRect(0, 0, 2, 2));
Quill::releaseAndWait();
QCOMPARE(file->allImageLevels().count(), 2);
Quill::releaseAndWait();
QCOMPARE(file->allImageLevels().count(), 3);
fragment = file->allImageLevels().at(2);
QCOMPARE(fragment.size(), QSize(2, 2));
QCOMPARE(fragment.fullImageSize(), QSize(16, 4));
QCOMPARE(fragment.area(), QRect(2, 0, 2, 2));
test_utils::analyze((QImage)fragment, referenceImage.copy(2, 0, 2, 2),13);
Quill::releaseAndWait();
QCOMPARE(file->allImageLevels().count(), 3);
Quill::releaseAndWait();
QCOMPARE(file->allImageLevels().count(), 4);
fragment = file->allImageLevels().at(3);
QCOMPARE(fragment.size(), QSize(2, 2));
QCOMPARE(fragment.fullImageSize(), QSize(16, 4));
QCOMPARE(fragment.area(), QRect(4, 0, 2, 2));
test_utils::analyze((QImage)fragment, referenceImage.copy(4, 0, 2, 2),13);
Quill::releaseAndWait();
QCOMPARE(file->allImageLevels().count(), 4);
Quill::releaseAndWait();
QCOMPARE(file->allImageLevels().count(), 5);
fragment = file->allImageLevels().at(4);
QCOMPARE(fragment.size(), QSize(2, 2));
QCOMPARE(fragment.fullImageSize(), QSize(16, 4));
QCOMPARE(fragment.area(), QRect(6, 0, 2, 2));
test_utils::analyze((QImage)fragment, referenceImage.copy(6, 0, 2, 2),13);
delete file;
}
void ut_tileloading::testQuill()
{
QFile testFile("/usr/share/libquill-tests/images/image_16x4.jpg");
QImage referenceImage("/usr/share/libquill-tests/images/image_16x4.png");
Quill::setDefaultTileSize(QSize(2, 2));
QuillFile *file =
new QuillFile(testFile.fileName());
file->setViewPort(QRect(-8, -2, 16, 4));
file->setDisplayLevel(1);
Quill::releaseAndWait(); // preview
QCOMPARE(file->allImageLevels().count(), 1);
QuillImage previewImage = file->allImageLevels().at(0);
QCOMPARE(previewImage.size(), QSize(4, 1));
QCOMPARE(previewImage.fullImageSize(), QSize(16, 4));
Quill::releaseAndWait();
QCOMPARE(file->allImageLevels().count(), 2);
QuillImage fragment = file->allImageLevels().at(1);
QCOMPARE(fragment.size(), QSize(2, 2));
QCOMPARE(fragment.fullImageSize(), QSize(16, 4));
QCOMPARE(fragment.area(), QRect(0, 0, 2, 2));
Quill::releaseAndWait();
QCOMPARE(file->allImageLevels().count(), 3);
fragment = file->allImageLevels().at(2);
QCOMPARE(fragment.size(), QSize(2, 2));
QCOMPARE(fragment.fullImageSize(), QSize(16, 4));
QCOMPARE(fragment.area(), QRect(2, 0, 2, 2));
test_utils::analyze((QImage)fragment, referenceImage.copy(2, 0, 2, 2), 13);
Quill::releaseAndWait();
QCOMPARE(file->allImageLevels().count(), 4);
fragment = file->allImageLevels().at(3);
QCOMPARE(fragment.size(), QSize(2, 2));
QCOMPARE(fragment.fullImageSize(), QSize(16, 4));
QCOMPARE(fragment.area(), QRect(4, 0, 2, 2));
test_utils::analyze((QImage)fragment, referenceImage.copy(4, 0, 2, 2), 13);
Quill::releaseAndWait();
QCOMPARE(file->allImageLevels().count(), 5);
fragment = file->allImageLevels().at(4);
QCOMPARE(fragment.size(), QSize(2, 2));
QCOMPARE(fragment.fullImageSize(), QSize(16, 4));
QCOMPARE(fragment.area(), QRect(6, 0, 2, 2));
test_utils::analyze((QImage)fragment, referenceImage.copy(6, 0, 2, 2), 13);
delete file;
}
