void ut_file::testDoubleRevertRestore()
{
// Tests that revert and restore still work after a previous revert.
QTemporaryFile testFile;
testFile.open();
QuillImage image = Unittests::generatePaletteImage();
image.save(testFile.fileName(), "png");
QuillImageFilter *filter =
QuillImageFilterFactory::createImageFilter(QuillImageFilter::Name_BrightnessContrast);
QVERIFY(filter);
filter->setOption(QuillImageFilter::Brightness, QVariant(20));
QuillImageFilter *filter2 =
QuillImageFilterFactory::createImageFilter(QuillImageFilter::Name_BrightnessContrast);
QVERIFY(filter2);
filter2->setOption(QuillImageFilter::Brightness, QVariant(-20));
QuillFile *file = new QuillFile(testFile.fileName(), Strings::png);
file->runFilter(filter);
QVERIFY(file->canRevert());
file->revert();
QVERIFY(file->canRestore());
file->runFilter(filter2);
QVERIFY(file->canRevert());
file->revert();
QVERIFY(file->canRestore());
delete file;
}
void ut_file::testDifferentPreviewLevels()
{
QTemporaryFile testFile;
testFile.open();
QuillImage image = Unittests::generatePaletteImage();
image.save(testFile.fileName(), "png");
QuillImageFilter *filter =
QuillImageFilterFactory::createImageFilter(QuillImageFilter::Name_BrightnessContrast);
QVERIFY(filter);
filter->setOption(QuillImageFilter::Brightness, QVariant(20));
QuillImage imageAfter = filter->apply(image);
Quill::setPreviewSize(0, QSize(4, 1));
QuillFile *file = new QuillFile(testFile.fileName(), Strings::png);
QuillFile *file2 = new QuillFile(testFile.fileName(), Strings::png);
QSignalSpy spy(file, SIGNAL(imageAvailable(const QuillImageList)));
QSignalSpy spy2(file2, SIGNAL(imageAvailable(const QuillImageList)));
QVERIFY(file != file2);
QVERIFY(file2->setDisplayLevel(1));
QVERIFY(file->setDisplayLevel(0));
file->runFilter(filter);
Quill::releaseAndWait(); // load level 0
Quill::releaseAndWait(); // brightness level 0
QCOMPARE(spy.count(), 1);
QCOMPARE(spy2.count(), 1);
QCOMPARE(file->image().size(), QSize(4, 1));
QCOMPARE(file->image().z(), 0);
QCOMPARE(file2->image().size(), QSize(4, 1));
QCOMPARE(file2->image().z(), 0);
Quill::releaseAndWait(); // load level 1
Quill::releaseAndWait(); // brightness level 1
QCOMPARE(spy.count(), 1);
QCOMPARE(spy2.count(), 2);
QCOMPARE(file->image().size(), QSize(4, 1));
QCOMPARE(file->image().z(), 0);
QVERIFY(Unittests::compareImage(file2->image(), imageAfter));
QCOMPARE(file2->image().z(), 1);
delete file2;
// Ensure that the display level is kept even if the other image reference
// is removed.
QCOMPARE(file->image().size(), QSize(4, 1));
QCOMPARE(file->image().z(), 0);
delete file;
}
void ut_file::testEdittingHistory()
{
QTemporaryFile testFile1;
testFile1.open();
QuillImage image = Unittests::generatePaletteImage();
image.save(testFile1.fileName(), "png");
QuillImageFilter *filter =
QuillImageFilterFactory::createImageFilter(QuillImageFilter::Name_BrightnessContrast);
QVERIFY(filter);
filter->setOption(QuillImageFilter::Brightness, QVariant(20));
QuillFile *file = new QuillFile(testFile1.fileName(), Strings::png);
File *fileObject = file->internalFile();
QVERIFY(file->setDisplayLevel(0));
QVERIFY(!fileObject->hasOriginal());
QFile editHistory(fileObject->editHistoryFileName(fileObject->fileName(),
Core::instance()->editHistoryPath()));
QVERIFY(!editHistory.exists());
file->runFilter(filter);
file->undo();
QVERIFY(editHistory.exists());
QVERIFY(!fileObject->hasOriginal());
}
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;
}
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_load::testTransparency()
{
QTemporaryFile testFile;
testFile.open();
QImage image = Unittests::generatePaletteImage();
image = image.convertToFormat(QImage::Format_ARGB32);
image.setPixel(QPoint(0, 0), qRgba(255, 0, 0, 0));
image.setPixel(QPoint(0, 1), qRgba(255, 0, 0, 127));
image.save(testFile.fileName(), "png");
QuillImageFilter *filter =
QuillImageFilterFactory::createImageFilter("org.maemo.load");
filter->setOption(QuillImageFilter::FileName, testFile.fileName());
filter->setOption(QuillImageFilter::FileFormat, QString("png"));
filter->setOption(QuillImageFilter::BackgroundColor, QColor(qRgb(0, 0, 255)));
QuillImage imageAfter = filter->apply(image);
QCOMPARE(imageAfter.pixel(QPoint(0, 0)), qRgb(0, 0, 255));
QCOMPARE(imageAfter.pixel(QPoint(0, 1)), qRgb(127, 0, 128));
delete filter;
}
void ut_croppedthumbnail::testCroppedThumbnailAfterEdit()
{
QTemporaryFile testFile;
testFile.open();
QuillImage image = Unittests::generatePaletteImage();
image.save(testFile.fileName(), "png");
Quill::setPreviewLevelCount(1);
Quill::setPreviewSize(0, QSize(2, 2));
Quill::setMinimumPreviewSize(0, QSize(2, 2));
QuillFile *file = new QuillFile(testFile.fileName());
QuillImageFilter *filter =
QuillImageFilterFactory::createImageFilter(QuillImageFilter::Name_Crop);
filter->setOption(QuillImageFilter::CropRectangle, QRect(0, 0, 4, 2));
file->runFilter(filter);
file->setDisplayLevel(1);
Quill::releaseAndWait(); // load 0
Quill::releaseAndWait(); // crop 0 - bad version
Quill::releaseAndWait(); // load 1
Quill::releaseAndWait(); // crop 1
Quill::releaseAndWait(); // reform 0
file->setDisplayLevel(0);
QCOMPARE(file->allImageLevels().count(), 1);
QCOMPARE(file->allImageLevels().first().size(), QSize(2, 2));
QVERIFY(Unittests::compareImage(file->allImageLevels().first(),
image.copy(1, 0, 2, 2)));
delete file;
}
void ut_stack::testDropRedoHistory()
{
QTemporaryFile testFile;
testFile.open();
QuillImage image = Unittests::generatePaletteImage();
image.save(testFile.fileName(), "png");
QuillImageFilter *filter =
QuillImageFilterFactory::createImageFilter(QuillImageFilter::Name_BrightnessContrast);
QVERIFY(filter);
filter->setOption(QuillImageFilter::Brightness, QVariant(20));
QuillImage resultImage = filter->apply(image);
QuillImageFilter *filter2 =
QuillImageFilterFactory::createImageFilter(QuillImageFilter::Name_BrightnessContrast);
QVERIFY(filter);
filter2->setOption(QuillImageFilter::Contrast, QVariant(20));
QuillImage resultImage2 = filter2->apply(resultImage);
QuillFile *file = new QuillFile(testFile.fileName(), Strings::png);
file->runFilter(filter);
file->runFilter(filter2);
file->undo();
QVERIFY(file->canRedo());
file->dropRedoHistory();
QVERIFY(!file->canRedo());
delete file;
}
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;
}
QRect LoadFilter::rotateArea(const QSize &fullImageSize, const QRect &area, const QuillImage &tile) const
{
switch (priv->orientation) {
case Exif_Orientation_Normal:
return area;
case Exif_Orientation_Rotated180:
return QRect(fullImageSize.width()-area.right() - 1,
fullImageSize.height()-area.bottom() - 1,
area.width(), area.height());
case Exif_Orientation_Rotated270:
if(tile.isFragment())
return QRect(fullImageSize.height()-area.bottom()-1,
area.left(),
area.height(), area.width());
else
return QRect(area.top(),
fullImageSize.width()-area.right() - 1,
area.height(), area.width());
case Exif_Orientation_Rotated90:
//The used base image is 3840x2160(WxH), we need to map from 2160x3840(WxH) when we use tiles
if(tile.isFragment())
return QRect(area.top(),
fullImageSize.width()-area.right() - 1,
area.height(), area.width());
//for full screen display from the full image
else
return QRect(fullImageSize.height()-area.bottom() - 1,
area.left(),
area.height(), area.width());
default:
return area;
}
}
bool SerialSaver::process(const QuillImage &image)
{
if (!priv->file) {
errorExit();
return false;
}
uchar *imageData = data(image);
uchar **rows = (uchar**) new int[image.height()];
for (int y=0; y<image.height(); y++)
{
rows[y] = imageData + (image.width() * 3) * y;
}
if (!setjmp(priv->error.setjmp_buffer)) {
int result = jpeg_write_scanlines(&priv->cinfo, rows, image.height());
priv->linesLeft -= image.height();
if (result == 0)
errorExit();
else if (isFinished()) {
jpeg_finish_compress(&priv->cinfo);
jpeg_destroy_compress(&priv->cinfo);
fclose(priv->file);
priv->file = 0;
}
} else
errorExit();
delete[] rows;
delete[] imageData;
return !priv->hasError;
}
void ut_file::testLastModified()
{
QTemporaryFile testFile;
testFile.open();
QuillImage image = Unittests::generatePaletteImage();
image.save(testFile.fileName(), "png");
QDateTime lastModified = QFileInfo(testFile.fileName()).lastModified();
QuillFile *file = new QuillFile(testFile.fileName(), Strings::png);
QCOMPARE(file->lastModified(), lastModified);
delete file;
}
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));
}
double EnlargeShrink::getRadius(const QuillImage &img) const
{
double radius = m_Radius;
if (!img.isFragment() || (img.width() == 170 && img.height() == 170)) {
if (img.fullImageSize().width() < img.fullImageSize().height()) {
radius = radius * img.width() / img.fullImageSize().width();
} else {
radius = radius * img.height() / img.fullImageSize().height();
}
}
return radius;
}
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;
}
void ut_file::testMultipleAccess()
{
QTemporaryFile testFile;
testFile.open();
QuillImage image = Unittests::generatePaletteImage();
image.save(testFile.fileName(), "png");
QuillImageFilter *filter =
QuillImageFilterFactory::createImageFilter(QuillImageFilter::Name_BrightnessContrast);
QVERIFY(filter);
filter->setOption(QuillImageFilter::Brightness, QVariant(20));
QuillImage imageAfter = filter->apply(image);
QuillFile *file = new QuillFile(testFile.fileName(), Strings::png);
QuillFile *file2 = new QuillFile(testFile.fileName(), Strings::png);
QVERIFY(file != file2);
QVERIFY(file->setDisplayLevel(0));
QVERIFY(file2->setDisplayLevel(0));
file->runFilter(filter);
Quill::releaseAndWait();
Quill::releaseAndWait();
QVERIFY(Unittests::compareImage(file->image(), imageAfter));
QVERIFY(Unittests::compareImage(file2->image(), imageAfter));
file2->undo();
Quill::releaseAndWait();
QVERIFY(Unittests::compareImage(file->image(), image));
QVERIFY(Unittests::compareImage(file2->image(), image));
delete file2;
file->redo();
Quill::releaseAndWait();
QVERIFY(Unittests::compareImage(file->image(), imageAfter));
delete file;
}
void ut_stack::testSessionSetup()
{
QTemporaryFile testFile;
testFile.open();
QuillImage image = Unittests::generatePaletteImage();
image.save(testFile.fileName(), "png");
QuillImageFilter *filter =
QuillImageFilterFactory::createImageFilter(QuillImageFilter::Name_BrightnessContrast);
QVERIFY(filter);
filter->setOption(QuillImageFilter::Brightness, QVariant(20));
QuillImageFilter *filter2 =
QuillImageFilterFactory::createImageFilter(QuillImageFilter::Name_BrightnessContrast);
QVERIFY(filter);
filter->setOption(QuillImageFilter::Contrast, QVariant(20));
QuillFile *file = new QuillFile(testFile.fileName(), Strings::png);
file->runFilter(filter);
file->runFilter(filter2);
file->undo();
QVERIFY(!file->isSession());
QVERIFY(file->canUndo());
QVERIFY(file->canRedo());
file->startSession();
// We are in a session now, cannot undo or redo
QVERIFY(file->isSession());
QVERIFY(!file->canUndo());
QVERIFY(!file->canRedo());
// If we end the session now, we should still be able to undo and redo
file->endSession();
QVERIFY(!file->isSession());
QVERIFY(file->canUndo());
QVERIFY(file->canRedo());
delete file;
}
QuillImage EnlargeShrink::apply(const QuillImage& image) const
{
if (image.fullImageSize().isEmpty()) {
return QImage();
}
QuillImage out;
enlargeShrink(image, &out);
return out;
}
void ut_file::testSaveAfterDelete()
{
QTemporaryFile testFile;
testFile.open();
QuillImage image = Unittests::generatePaletteImage();
image.save(testFile.fileName(), "png");
QuillImageFilter *filter =
QuillImageFilterFactory::createImageFilter(QuillImageFilter::Name_BrightnessContrast);
QVERIFY(filter);
filter->setOption(QuillImageFilter::Brightness, QVariant(20));
QuillImage imageAfter = filter->apply(image);
QuillFile *file = new QuillFile(testFile.fileName(), Strings::png);
file->runFilter(filter);
QVERIFY(!Quill::isSaveInProgress());
QVERIFY(!file->isSaveInProgress());
file->save();
QVERIFY(Quill::isSaveInProgress());
QVERIFY(file->isSaveInProgress());
delete file;
QVERIFY(Quill::isSaveInProgress());
Quill::releaseAndWait(); // load
QVERIFY(Quill::isSaveInProgress());
Quill::releaseAndWait(); // b/c
QVERIFY(Quill::isSaveInProgress());
Quill::releaseAndWait(); // save
QVERIFY(!Quill::isSaveInProgress());
Unittests::compareImage(QImage(testFile.fileName()), imageAfter);
}
void ut_file::testOriginal()
{
QTemporaryFile testFile;
testFile.open();
QuillImage image = Unittests::generatePaletteImage();
image.save(testFile.fileName(), "png");
QuillFile *file = new QuillFile(testFile.fileName(), Strings::png);
QuillImageFilter *filter =
QuillImageFilterFactory::createImageFilter(QuillImageFilter::Name_BrightnessContrast);
QVERIFY(filter);
filter->setOption(QuillImageFilter::Brightness, QVariant(20));
QuillImage processedImage = filter->apply(image);
file->runFilter(filter);
QuillFile *original = file->original();
QCOMPARE(file->fileName(), original->fileName());
QCOMPARE(file->originalFileName(), original->originalFileName());
QVERIFY(file->canUndo());
QVERIFY(!original->canUndo());
file->setDisplayLevel(0);
Quill::releaseAndWait();
Quill::releaseAndWait();
original->setDisplayLevel(0);
Quill::releaseAndWait();
QCOMPARE(file->image(), processedImage);
QCOMPARE(original->image(), image);
file->remove();
QVERIFY(!file->exists());
QVERIFY(!original->exists());
delete file;
delete original;
}
QPoint EnlargeShrink::getCenter(const QuillImage &img) const
{
QPoint center = m_Center;
if (!img.isFragment() || (img.width() == 170 && img.height() == 170)) {
center.setX(center.x() * img.width() / img.fullImageSize().width());
center.setY(center.y() * img.height() / img.fullImageSize().height());
}
return center;
}
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_file::testReadOnly()
{
if (Unittests::isRoot()) {
qDebug() << "Running as root, disabling file permissions test!";
return;
}
QTemporaryFile testFile;
testFile.open();
QuillImage image = Unittests::generatePaletteImage();
image.save(testFile.fileName(), "png");
QFile qFile(testFile.fileName());
qFile.setPermissions(QFile::ReadOwner);
QuillFile *file = new QuillFile(testFile.fileName(), Strings::png);
QVERIFY(!file->supportsEditing());
delete file;
}
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);
}
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_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;
}
bool EnlargeShrink::enlargeShrink(const QuillImage &img,
QuillImage *outputImg) const
{
*outputImg = img;
double radius = getRadius(img);
QPoint center = getCenter(img);
for (int y = 0; y < img.height(); y++) {
for (int x = 0; x < img.width(); x++) {
int dx = x - center.x();
int dy = y - center.y();
double distance = sqrt(dx * dx + dy * dy);
if (distance <= radius + M_SQRT2) {
// Evaluate the area inside the radius + this M_SQRT2
// (to reduce aliasing effects)
double n = distance / radius;
if (n > 0.0 && n < 1.0) {
n = distort(n, m_Force);
}
// Normalize the distance vector< and find the length after
// distortion
if (dx != 0 || dy != 0) {
double mag = n * radius/distance;
dx = dx * mag;
dy = dy * mag;
}
double tx = center.x() + dx;
double ty = center.y() + dy;
// Crop off overflows
if (tx >= img.width() || tx < 0) tx = x;
if (ty >= img.height() || ty < 0) ty = y;
outputImg->setPixel(x, y, getPixel(img, tx, ty));
}
}
}
return true;
}
void ut_load::testLoadSameFilterTwice()
{
QTemporaryFile testFile;
testFile.open();
QImage greenTestImage("/usr/share/quillimagefilter-tests/images/854x480_blue.png");
// Verify whether image exists
QVERIFY(!greenTestImage.isNull());
greenTestImage.save(testFile.fileName(), "jpg");
QuillImage target = QuillImage();
target.setFullImageSize(QSize(854, 480));
target.setArea(QRect(0, 0, 854, 480));
QuillImage target2 = QuillImage();
target2.setFullImageSize(QSize(854, 480));
target2.setArea(QRect(0, 0, 854, 480));
QuillImageFilter *filter =
QuillImageFilterFactory::createImageFilter("org.maemo.load");
filter->setOption(QuillImageFilter::FileName, testFile.fileName());
// Passing JPEG through the filter
QuillImage imageAfter = filter->apply(target);
// Passing JPEG through the filter
QuillImage imageAfter2 = filter->apply(target2);
// Checking the red channel value which should be always bigger than that of greeen channel
QVERIFY( qBlue(imageAfter.pixel(QPoint(0, 0))) > qGreen(imageAfter.pixel(QPoint(0, 0))) );
// Checking the red channel value which should be always bigger than that of greeen channel
QVERIFY( qBlue(imageAfter2.pixel(QPoint(0, 0))) > qGreen(imageAfter2.pixel(QPoint(0, 0))) );
delete filter;
}
void ut_tileloading::testFilter()
{
QFile testFile("/usr/share/libquill-tests/images/image_16x4.jpg");
TileCache *tileCache = new TileCache(100);
QVERIFY(tileCache);
QuillImageFilter *filter =
QuillImageFilterFactory::createImageFilter(QuillImageFilter::Role_Load);
QVERIFY(filter);
filter->setOption(QuillImageFilter::FileName,
testFile.fileName());
TileMap tileMap(QSize(8, 2), QSize(2, 2), tileCache);
for (int i=0; i<4; i++) {
QCOMPARE(tileMap.tile(i).fullImageSize(), QSize(8, 2));
QuillImage tile = filter->apply(tileMap.tile(i));
QCOMPARE(tile.fullImageSize(), QSize(8, 2));;
tileMap.setTile(i, tile);
QCOMPARE(tileMap.tile(i).fullImageSize(), QSize(8, 2));
}
QImage image("/usr/share/libquill-tests/images/image_16x4.png");
QCOMPARE(tileMap.tile(0).area(), QRect(0, 0, 2, 2));
test_utils::analyze((QImage)tileMap.tile(0), image.copy(0, 0, 2, 2), 13);
QCOMPARE(tileMap.tile(1).area(), QRect(2, 0, 2, 2));
test_utils::analyze((QImage)tileMap.tile(1), image.copy(2, 0, 2, 2), 13);
QCOMPARE(tileMap.tile(2).area(), QRect(4, 0, 2, 2));
test_utils::analyze((QImage)tileMap.tile(2), image.copy(4, 0, 2, 2), 13);
QCOMPARE(tileMap.tile(3).area(), QRect(6, 0, 2, 2));
test_utils::analyze((QImage)tileMap.tile(3), image.copy(6, 0, 2, 2), 13);
delete filter;
delete tileCache;
}
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();
}
