private void HandleImagesLoaded()
{
var pack = ImagesLibrary.GetImagesPack(WaveForm);
IsImageEnabled = pack != null && pack.IsLoaded;
IsLoading = false;
if (IsImageEnabled)
{
WavImage = ImagesLibrary.Bitmap2ImageSource(pack.WavImage);
SpectrumImage = ImagesLibrary.Bitmap2ImageSource(pack.Spectrogram);
FrqImage = ImagesLibrary.Bitmap2ImageSource(pack.Frq);
RaisePropertiesChanged(nameof(WavImage), nameof(SpectrumImage), nameof(FrqImage));
OnLoaded();
FirePointsChanged();
}
RaisePropertyChanged(nameof(IsImageEnabled));
RaisePropertyChanged(nameof(IsLoading));
RaisePropertyChanged(nameof(WavImage));
RaisePropertyChanged(nameof(SpectrumImage));
RaisePropertyChanged(nameof(FrqImage));
HandleViewChanged();
ProjectLine.Width = WaveForm.Width;
RaisePropertyChanged(nameof(Width));
UpdatePoints();
IsImagesLoaded = true;
CheckLoaded();
}
public async Task WhenCalling_GetImageAsync_And_CachedImageNotAvailable_Should_ReturnLoadedImage()
{
var imageCache = A.Fake <IImagesCache>();
A.CallTo(() => imageCache.GetImageAsync(A <ImageCacheKey> ._))
.Returns(Task.FromResult((Image)null));
var imageLoader = A.Fake <IImageLoader>();
A.CallTo(() => imageLoader.LoadFromLibraryAsync(A <string> ._))
.ReturnsLazily(callInfo =>
{
var testImage = new Image(callInfo.GetArgument <string>("imageName"));
return(Task.FromResult(testImage));
});
var imageTransformer = A.Fake <IImageTransformer>();
A.CallTo(() => imageTransformer.ApplyTransforms(
A <Image> ._,
A <string> ._,
A <string> ._,
A <string> ._,
A <string> ._))
.ReturnsLazily(callInfo => callInfo.GetArgument <Image>("image"));
var sut = new ImagesLibrary(imageCache, imageLoader, imageTransformer);
var resultImage = await sut.GetImageAsync("01_04_2019_001103");
resultImage.Name.Should().BeEquivalentTo("01_04_2019_001103");
}
public async Task WhenCalling_GetImageAsync_And_CachedImageNotAvailable_And_ImageTypeIsSpecified_Should_CallImageTransformerToRetrieveCorrectImageFormat()
{
var imageCache = A.Fake <IImagesCache>();
A.CallTo(() => imageCache.GetImageAsync(A <ImageCacheKey> ._))
.Returns(Task.FromResult((Image)null));
var imageLoader = A.Fake <IImageLoader>();
A.CallTo(() => imageLoader.LoadFromLibraryAsync(
A <string> .That.Matches(imageName => imageName == "01_04_2019_001103")))
.ReturnsLazily(callInfo =>
{
var testImage = new Image(callInfo.GetArgument <string>("imageName"));
return(Task.FromResult(testImage));
});
var imageTransformer = A.Fake <IImageTransformer>();
var sut = new ImagesLibrary(imageCache, imageLoader, imageTransformer);
await sut.GetImageAsync("01_04_2019_001103", imageType : "jpeg");
A.CallTo(() => imageTransformer.ApplyTransforms(
A <Image> .That.Matches(image => image.Name == "01_04_2019_001103"),
A <string> .That.Matches(newResolution => newResolution == null),
A <string> .That.Matches(backgroundColour => backgroundColour == null),
A <string> .That.Matches(watermarkText => watermarkText == null),
A <string> .That.Matches(imageType => imageType == "jpeg")))
.MustHaveHappenedOnceExactly();
}
/// <summary>
/// Save photo the original.
/// </summary>
/// <param name="old_img">The old image.</param>
/// <param name="control">The control.</param>
/// <param name="imgPathTemp">The image path temporary.</param>
/// <param name="imagePath">The image path.</param>
public void SavephotoOriginal(string old_img, HttpPostedFileBase control, string imgPathTemp, string imagePath)
{
ImagesLibrary imglib = new ImagesLibrary();
if (!string.IsNullOrEmpty(old_img))
{
string strImg = old_img;
strImg = "~" + strImg;
string fileDelete = Server.MapPath(strImg);
if (System.IO.File.Exists(fileDelete))
{
System.IO.File.Delete(fileDelete);
}
string fileDelete2 = Server.MapPath(strImg.Replace("sc_small_", "sc_full_"));
if (System.IO.File.Exists(fileDelete2))
{
System.IO.File.Delete(fileDelete2);
}
}
string imageGoc = imgPathTemp + control.FileName;
string realFile = Request.PhysicalApplicationPath + imageGoc.Replace("/", "\\");
string virtualFolder = "~/" + imageGoc.Substring(0, imageGoc.LastIndexOf('/') + 1);
string folder = Server.MapPath(virtualFolder);
if (!Directory.Exists(folder))
{
Directory.CreateDirectory(folder);
}
if (imagePath.EndsWith(".mp4"))
{
HttpPostedFileBase video_p = control;
////save
string realFile1 = Request.PhysicalApplicationPath + imagePath.Replace("/", "\\");
video_p.SaveAs(realFile1);
}
else
{
System.Drawing.Image img1 = System.Drawing.Image.FromStream(control.InputStream);
////save thumb images
string realFile1 = Request.PhysicalApplicationPath + imagePath.Replace("/", "\\");
if (control.FileName.Contains(".png"))
{
img1.Save(realFile1, System.Drawing.Imaging.ImageFormat.Png);
}
else if (control.FileName.Contains(".gif"))
{
img1.Save(realFile1, System.Drawing.Imaging.ImageFormat.Gif);
}
else
{
img1.Save(realFile1, System.Drawing.Imaging.ImageFormat.Jpeg);
}
}
}
public void WhenCalling_GetImageAsync_WithNullOrWhitespaceString_Should_ThrowArgumentException(string imageNameVal)
{
var imageCache = A.Dummy <IImagesCache>();
var imageProcessor = A.Dummy <IImageLoader>();
var sut = new ImagesLibrary(imageCache, imageProcessor, A.Dummy <IImageTransformer>());
sut.Awaiting(il => il.GetImageAsync(imageNameVal))
.Should().ThrowExactly <ArgumentException>();
}
public async Task WhenCalling_GetImageAsync_Should_ReturnImage()
{
var sut = new ImagesLibrary(
A.Dummy <IImagesCache>(),
A.Dummy <IImageLoader>(),
A.Dummy <IImageTransformer>());
object result = await sut.GetImageAsync("01_04_2019_001103");
result.Should().BeAssignableTo <Image>();
}
private void TryGetImages()
{
var pack = ImagesLibrary.GetImagesPack(WaveForm);
IsImageEnabled = false;
if (pack == null || pack.IsLoading)
{
SetIsLoading();
return;
}
HandleImagesLoaded();
}
public async Task WhenCalling_GetImageAsync_And_CachedImageNotAvailable_Should_CallImageLoaderToLoadFromLibrary()
{
var imageCache = A.Fake <IImagesCache>();
A.CallTo(() => imageCache.GetImageAsync(A <ImageCacheKey> ._))
.Returns(Task.FromResult((Image)null));
var imageLoader = A.Fake <IImageLoader>();
var sut = new ImagesLibrary(imageCache, imageLoader, A.Dummy <IImageTransformer>());
await sut.GetImageAsync("01_04_2019_001103");
A.CallTo(() => imageLoader.LoadFromLibraryAsync(
A <string> .That.Matches(imageName => imageName == "01_04_2019_001103")))
.MustHaveHappenedOnceExactly();
}
public void WhenCalling_GetImageAsync_And_ImageCacheThrows_Should_ThrowImageLibraryExceptionContainingThrownCacheException()
{
var imageCache = A.Fake <IImagesCache>();
A.CallTo(() => imageCache.GetImageAsync(A <ImageCacheKey> ._))
.Throws(new Exception("A caching error occurred"));
var imageLoader = A.Dummy <IImageLoader>();
var sut = new ImagesLibrary(imageCache, imageLoader, A.Dummy <IImageTransformer>());
sut.Awaiting(il => il.GetImageAsync("01_04_2019_001103"))
.Should().ThrowExactly <ImageLibraryException>()
.WithInnerException <Exception>()
.WithMessage("A caching error occurred");
}
public void WhenCalling_GetImageAsync_And_CachedImageNotAvailable_And_LoadedImagesNotAvailable_Should_ThrowImageNotAvailableException()
{
var imageCache = A.Fake <IImagesCache>();
A.CallTo(() => imageCache.GetImageAsync(A <ImageCacheKey> ._))
.Returns(Task.FromResult((Image)null));
var imageLoader = A.Fake <IImageLoader>();
A.CallTo(() => imageLoader.LoadFromLibraryAsync(A <string> ._))
.Returns(Task.FromResult((Image)null));
var sut = new ImagesLibrary(imageCache, imageLoader, A.Dummy <IImageTransformer>());
sut.Awaiting(il => il.GetImageAsync("01_04_2019_001103"))
.Should().ThrowExactly <ImageNotAvailableException>();
}
public async Task WhenCalling_GetImageAsync_And_ImageTypeIsSpecified_Should_IncludeImageTypeInCallToCheckImageCache()
{
var imageCache = A.Fake <IImagesCache>();
var sut = new ImagesLibrary(imageCache, A.Dummy <IImageLoader>(), A.Dummy <IImageTransformer>());
await sut.GetImageAsync("01_04_2019_001103", imageType : "jpeg");
A.CallTo(() => imageCache.GetImageAsync(
A <ImageCacheKey> .That.Matches(cacheKey => cacheKey == new ImageCacheKey(
"01_04_2019_001103",
null,
null,
null,
"jpeg"))))
.MustHaveHappenedOnceExactly();
}
public async Task WhenCalling_GetImageAsync_Should_CheckCacheForImage()
{
var imageCache = A.Fake <IImagesCache>();
var sut = new ImagesLibrary(
imageCache,
A.Dummy <IImageLoader>(),
A.Dummy <IImageTransformer>());
await sut.GetImageAsync("01_04_2019_001103");
A.CallTo(() => imageCache.GetImageAsync(A <ImageCacheKey> .That.Matches(cacheKey => cacheKey == new ImageCacheKey(
"01_04_2019_001103",
null,
null,
null,
null))))
.MustHaveHappenedOnceExactly();
}
public void WhenCalling_GetImageAsync_And_ImageLoaderThrows_Should_ThrowImageLibraryExceptionContainingThrownProcessorException()
{
var imageCache = A.Fake <IImagesCache>();
A.CallTo(() => imageCache.GetImageAsync(A <ImageCacheKey> ._))
.Returns(Task.FromResult((Image)null));
var imageLoader = A.Fake <IImageLoader>();
A.CallTo(() => imageLoader.LoadFromLibraryAsync(A <string> ._))
.Throws(new Exception("An image generation error occurred"));
var sut = new ImagesLibrary(imageCache, imageLoader, A.Dummy <IImageTransformer>());
sut.Awaiting(il => il.GetImageAsync("01_04_2019_001103"))
.Should().ThrowExactly <ImageLibraryException>()
.WithInnerException <Exception>()
.WithMessage("An image generation error occurred");
}
public async Task WhenCalling_GetImageAsync_Should_ReturnCachedImageIfAvailable()
{
var imageCache = A.Fake <IImagesCache>();
A.CallTo(() => imageCache.GetImageAsync(A <ImageCacheKey> ._))
.ReturnsLazily(callInfo =>
{
var testImageName = callInfo.GetArgument <ImageCacheKey>("cacheKey")?.ImageName;
return(Task.FromResult(new Image(testImageName)));
});
var sut = new ImagesLibrary(
imageCache,
A.Dummy <IImageLoader>(),
A.Dummy <IImageTransformer>());
var resultImage = await sut.GetImageAsync("01_04_2019_001103");
resultImage.Name.Should().BeEquivalentTo("01_04_2019_001103");
}
private void DrawPoints(double[][] lines, double[] points, int width, int height, Color fillColor, Color strokeColor)
{
if (width == 0)
{
return;
}
var res = new Bitmap(width, height);
using (var strokePen = new Pen(strokeColor))
using (var fillBrush = new SolidBrush(fillColor))
using (Graphics g = Graphics.FromImage(res))
{
g.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.HighQuality;
foreach (var line in lines)
{
g.DrawLine(strokePen, (float)line[0], (float)line[1], (float)line[2], (float)line[3]);
}
var pointFs = new List <PointF>();
for (int i = 0; i + 1 < points.Length; i += 2)
{
var x1 = (float)points[i];
var y1 = (float)points[i + 1];
var x2 = (float)points[i + 2 >= points.Length ? 0 : i + 2];
var y2 = (float)points[i + 3 >= points.Length ? 1 : i + 3];
pointFs.Add(new PointF(x1, y1));
if (x1 == x2 && (x1 == In || x1 == width))
{
continue;
}
g.DrawLine(strokePen, x1, y1, x2, y2);
}
pointFs.Add(new PointF((float)points[0], (float)points[1]));
g.FillPolygon(fillBrush, pointFs.ToArray());
}
var bitmapImage = ImagesLibrary.Bitmap2ImageSource(res);
res.Dispose();
Image = bitmapImage;
}
public async Task WhenCalling_GetImageAsync_And_CachedImageNotAvailable_And_ImageTypeIsSpecified_Should_IncludeImageTypeInCallToCacheNewlyLoadedImage()
{
var imageCache = A.Fake <IImagesCache>();
A.CallTo(() => imageCache.GetImageAsync(A <ImageCacheKey> ._))
.Returns(Task.FromResult((Image)null));
var imageLoader = A.Fake <IImageLoader>();
A.CallTo(() => imageLoader.LoadFromLibraryAsync(A <string> ._))
.ReturnsLazily(callInfo =>
{
var testImage = new Image(callInfo.GetArgument <string>("imageName"));
return(Task.FromResult(testImage));
});
var imageTransformer = A.Fake <IImageTransformer>();
A.CallTo(() => imageTransformer.ApplyTransforms(
A <Image> ._,
A <string> ._,
A <string> ._,
A <string> ._,
A <string> ._))
.ReturnsLazily(callInfo => callInfo.GetArgument <Image>("image"));
var sut = new ImagesLibrary(imageCache, imageLoader, imageTransformer);
await sut.GetImageAsync("01_04_2019_001103", imageType : "jpeg");
A.CallTo(() => imageCache.CacheImageAsync(
A <ImageCacheKey> .That.Matches(cacheKey => cacheKey == new ImageCacheKey(
"01_04_2019_001103",
null,
null,
null,
"jpeg")),
A <Image> .That.Matches(image => image.Name == "01_04_2019_001103")))
.MustHaveHappenedOnceExactly();
}
public void Should_Implement_IImagesLibrary()
{
object sut = new ImagesLibrary(null, null, null);
sut.Should().BeAssignableTo <IImagesLibrary>();
}
/// <summary>
/// Save photo the specified old image.
/// </summary>
/// <param name="old_img">The old image.</param>
/// <param name="control">The control.</param>
/// <param name="imgPathTemp">The image path temporary.</param>
/// <param name="imagePath">The image path.</param>
/// <param name="imageFullPath">The image full path.</param>
public void SavephotoCategory(string old_img, HttpPostedFileBase control, string imgPathTemp, string imagePath, string imageFullPath)
{
ImagesLibrary imglib = new ImagesLibrary();
var thumb_type = Util.GetConfigValue("ThumbType", "both");
var thumb_width = 400;
var thumb_height = 330;
var larger_width = 800;
var larger_height = 660;
if (!string.IsNullOrEmpty(old_img))
{
string strImg = old_img;
strImg = "~" + strImg;
string fileDelete = Server.MapPath(strImg);
if (System.IO.File.Exists(fileDelete))
{
System.IO.File.Delete(fileDelete);
}
string fileDelete2 = Server.MapPath(strImg.Replace("sc_small_", "sc_full_"));
if (System.IO.File.Exists(fileDelete2))
{
System.IO.File.Delete(fileDelete2);
}
}
string imageGoc = imgPathTemp + control.FileName;
string realFile = Request.PhysicalApplicationPath + imageGoc.Replace("/", "\\");
string virtualFolder = "~/" + imageGoc.Substring(0, imageGoc.LastIndexOf('/') + 1);
string folder = Server.MapPath(virtualFolder);
if (!Directory.Exists(folder))
{
Directory.CreateDirectory(folder);
}
////nén ảnh thành 2 ảnh kích thước khác nhau
System.Drawing.Image img1 = System.Drawing.Image.FromStream(control.InputStream);
////thumb1
if (thumb_type == "width")
{
img1 = imglib.ConstrainProportions(img1, thumb_width, ImagesLibrary.Dimensions.Width);
}
else if (thumb_type == "height")
{
img1 = imglib.ConstrainProportions(img1, thumb_height, ImagesLibrary.Dimensions.Height);
}
else if (thumb_type == "both")
{
img1 = imglib.FixedSize(img1, thumb_width, thumb_height);
}
////watermark1
img1 = imglib.ImagesWatermark(img1, System.Drawing.Image.FromFile(Server.MapPath("~" + Util.GetConfigValue("ImagesWatermark", "/images/logo2.png"))));
////save thumb images
string realFile1 = Request.PhysicalApplicationPath + imagePath.Replace("/", "\\");
img1.Save(realFile1, System.Drawing.Imaging.ImageFormat.Jpeg);
System.Drawing.Image img2 = System.Drawing.Image.FromStream(control.InputStream);
////thumb2
if (thumb_type == "width")
{
img2 = imglib.ConstrainProportions(img2, larger_width, ImagesLibrary.Dimensions.Width);
}
else if (thumb_type == "height")
{
img2 = imglib.ConstrainProportions(img2, larger_height, ImagesLibrary.Dimensions.Height);
}
else if (thumb_type == "both")
{
img2 = imglib.FixedSize(img2, larger_width, larger_height);
}
////watermark1
img2 = imglib.ImagesWatermark(img2, System.Drawing.Image.FromFile(Server.MapPath("~" + Util.GetConfigValue("ImagesWatermark", "/images/logo2.png"))));
////save larger images
string realFile2 = Request.PhysicalApplicationPath + imageFullPath.Replace("/", "\\");
if (control.FileName.Contains(".png"))
{
img2.Save(realFile2, System.Drawing.Imaging.ImageFormat.Png);
}
else if (control.FileName.Contains(".gif"))
{
img2.Save(realFile2, System.Drawing.Imaging.ImageFormat.Gif);
}
else
{
img2.Save(realFile2, System.Drawing.Imaging.ImageFormat.Jpeg);
}
}
