//

// ReferenceImageManager.cs

//

// Author:

// Lluis Sanchez <lluis@xamarin.com>

//

// Copyright (c) 2013 Xamarin Inc.

//

// Permission is hereby granted, free of charge, to any person obtaining a copy

// of this software and associated documentation files (the "Software"), to deal

// in the Software without restriction, including without limitation the rights

// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

// copies of the Software, and to permit persons to whom the Software is

// furnished to do so, subject to the following conditions:

//

// The above copyright notice and this permission notice shall be included in

// all copies or substantial portions of the Software.

//

// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

// THE SOFTWARE.

using System;

using Xwt.Drawing;

using System.Collections.Generic;

using System.IO;

using NUnit.Framework;

namespace Xwt

{

public class ReferenceImageManager

{

internal static string ProjectReferenceImageDir;

public static string ProjectCustomReferenceImageDir;

public static bool RecheckAll;

internal static string FailedImageCacheDir;

public static List<FailedImageInfo> ImageFailures = new List<FailedImageInfo> ();

static ReferenceImageManager ()

{

}

public static void Init (string projectName)

{

var baseDir = Path.GetDirectoryName (typeof(ReferenceImageManager).Assembly.Location);

while (Path.GetFileName (baseDir) != "Testing")

baseDir = Path.GetDirectoryName (baseDir);

ProjectReferenceImageDir = Path.Combine (baseDir, "Tests", "ReferenceImages");

ProjectCustomReferenceImageDir = Path.Combine (baseDir, projectName, "ReferenceImages");

FailedImageCacheDir = Path.Combine (baseDir, "bin", projectName, "FailedImageCache");

}

public static Image LoadReferenceImage (string name)

{

var f = Path.Combine (ProjectReferenceImageDir, name);

if (File.Exists (f))

return Image.FromFile (f);

else

return null;

}

public static Image LoadCustomReferenceImage (string name)

{

var file = Path.Combine (ProjectCustomReferenceImageDir, name);

if (File.Exists (file))

return Image.FromFile (file);

else

return null;

}

public static void ShowImageVerifier ()

{

if (ImageFailures.Count > 0) {

var dlg = new ReferenceImageVerifierDialog ();

dlg.Run ();

}

}

static Image TryLoadImage (System.Reflection.Assembly asm, string name)

{

try {

if (asm.GetManifestResourceInfo (name) != null)

return Image.FromResource (asm, name);

}

catch {

}

try {

if (asm.GetManifestResourceInfo ("WpfTestRunner.ReferenceImages." + name) != null)

return Image.FromResource (asm, "WpfTestRunner.ReferenceImages." + name);

}

catch {

}

return null;

}

public static void CheckImage (string refImageName, Image im)

{

BitmapImage img = im as BitmapImage ?? im.ToBitmap ();

Image coreRefImage = LoadReferenceImage (refImageName);

Image refImage = !RecheckAll ? LoadCustomReferenceImage (refImageName) : null;

if (refImage == null)

refImage = coreRefImage;

if (refImage == null) {

ImageFailures.Add (new FailedImageInfo () {

TestImage = img.WithSize (img.PixelWidth, img.PixelHeight),

ReferenceImage = img.WithSize (img.PixelWidth, img.PixelHeight),

Name = refImageName,

TargetDir = ProjectReferenceImageDir

});

return;

}

var diff = DiffImages (img, refImage);

if (diff != null && refImage != coreRefImage) {

// Maybe the original image has changed

refImage = coreRefImage;

diff = DiffImages (img, refImage);

}

if (diff != null) {

bool knownFailure = false;

var failedImageFile = Path.Combine (FailedImageCacheDir, refImageName);

if (File.Exists (failedImageFile)) {

var failedImage = Image.FromFile (Path.Combine (FailedImageCacheDir, refImageName));

if (DiffImages (img, failedImage) == null)

knownFailure = true;

}

if (!knownFailure) {

ImageFailures.Add (new FailedImageInfo () {

TestImage = img.WithSize (img.PixelWidth, img.PixelHeight),

ReferenceImage = refImage.WithSize (img.PixelWidth, img.PixelHeight),

DiffImage = diff,

Name = refImageName,

TargetDir = ProjectCustomReferenceImageDir

});

}

Assert.Fail ("Image " + refImageName + " doesn't match");

}

}

public static Image DiffImages (Image img1, Image img2)

{

bool foundDifference = false;

var bmp1 = (img1 as BitmapImage) ?? img1.ToBitmap ();

var bmp2 = (img2 as BitmapImage) ?? img2.ToBitmap ();

var res = new ImageBuilder ((int)Math.Min (bmp1.PixelWidth, bmp2.PixelWidth), (int) Math.Min (bmp1.PixelHeight, bmp2.PixelHeight));

var bmpr = res.ToBitmap ();

res.Dispose ();

for (int y=0; y<bmp1.PixelHeight && y < bmp2.PixelHeight; y++) {

for (int x=0; x<bmp1.PixelWidth && x<bmp2.PixelWidth; x++) {

var p1 = bmp1.GetPixel (x, y);

var p2 = bmp2.GetPixel (x, y);

var col = Colors.White;

if (p1 != p2) {

foundDifference = true;

var r = Math.Pow (p1.Red - p2.Red, 2) + Math.Pow (p1.Green - p2.Green, 2) + Math.Pow (p1.Blue - p2.Blue, 2) + Math.Pow (p1.Alpha - p2.Alpha, 2);

if (r < 0.01)

col = new Color (0.9, 0.9, 0.9);

else if (r < 0.1)

col = new Color (0.7, 0.7, 0.7);

else

col = Colors.Red;

}

bmpr.SetPixel (x, y, col);

}

}

if (foundDifference)

return bmpr;

else

return null;

}

}

public class FailedImageInfo

{

public Image TestImage { get; set; }

public Image ReferenceImage { get; set; }

public Image DiffImage { get; set; }

public string Name { get; set; }

public string TargetDir { get; set; }

public void Validate ()

{

if (!Directory.Exists (TargetDir))

Directory.CreateDirectory (TargetDir);

TestImage.Save (Path.Combine (TargetDir, Name), ImageFileType.Png);

}

public void Fail ()

{

if (!Directory.Exists (ReferenceImageManager.FailedImageCacheDir))

Directory.CreateDirectory (ReferenceImageManager.FailedImageCacheDir);

TestImage.Save (Path.Combine (ReferenceImageManager.FailedImageCacheDir, Name), ImageFileType.Png);

}

}

}