/// <summary> /// Loads the expected image with a reference decoder + compares it to <paramref name="image"/>. /// Also performs a debug save using <see cref="ImagingTestCaseUtility.SaveTestOutputFile{TPixel}"/>. /// </summary> internal static void VerifyEncoder <TPixel>( this Image <TPixel> image, ITestImageProvider provider, string extension, object testOutputDetails, IImageEncoder encoder, ImageComparer customComparer = null, bool appendPixelTypeToFileName = true, string referenceImageExtension = null, IImageDecoder referenceDecoder = null) where TPixel : struct, IPixel <TPixel> { string actualOutputFile = provider.Utility.SaveTestOutputFile( image, extension, encoder, testOutputDetails, appendPixelTypeToFileName); referenceDecoder = referenceDecoder ?? TestEnvironment.GetReferenceDecoder(actualOutputFile); using (var actualImage = Image.Load <TPixel>(actualOutputFile, referenceDecoder)) { ImageComparer comparer = customComparer ?? ImageComparer.Exact; comparer.VerifySimilarity(actualImage, image); } }
public static void DebugSave( this Image image, ITestImageProvider provider, IImageEncoder encoder, FormattableString testOutputDetails, bool appendPixelTypeToFileName = true) => image.DebugSave(provider, encoder, (object)testOutputDetails, appendPixelTypeToFileName);
private static IImageEncoder GetEncoder(string extension) { IImageEncoder encoder = null; extension = extension.Replace(".", ""); var isSupported = Regex.IsMatch(extension, "gif|png|jpe?g", RegexOptions.IgnoreCase); if (isSupported) { switch (extension.ToLower()) { case "png": encoder = new PngEncoder(); break; case "jpg": encoder = new JpegEncoder(); break; case "jpeg": encoder = new JpegEncoder(); break; case "gif": encoder = new GifEncoder(); break; default: break; } } return(encoder); }
/// <summary> /// Writes the image to the given stream using the currently loaded image format. /// </summary> /// <param name="source">The source image.</param> /// <param name="filePath">The file path to save the image to.</param> /// <exception cref="System.ArgumentNullException">Thrown if the stream is null.</exception> public static void Save(this Image source, string filePath) { Guard.NotNullOrWhiteSpace(filePath, nameof(filePath)); string ext = Path.GetExtension(filePath); IImageFormat format = source.GetConfiguration().ImageFormatsManager.FindFormatByFileExtension(ext); if (format is null) { var sb = new StringBuilder(); sb.AppendLine($"No encoder was found for extension '{ext}'. Registered encoders include:"); foreach (IImageFormat fmt in source.GetConfiguration().ImageFormats) { sb.AppendLine($" - {fmt.Name} : {string.Join(", ", fmt.FileExtensions)}"); } throw new NotSupportedException(sb.ToString()); } IImageEncoder encoder = source.GetConfiguration().ImageFormatsManager.FindEncoder(format); if (encoder is null) { var sb = new StringBuilder(); sb.AppendLine($"No encoder was found for extension '{ext}' using image format '{format.Name}'. Registered encoders include:"); foreach (KeyValuePair <IImageFormat, IImageEncoder> enc in source.GetConfiguration().ImageFormatsManager.ImageEncoders) { sb.AppendLine($" - {enc.Key} : {enc.Value.GetType().Name}"); } throw new NotSupportedException(sb.ToString()); } source.Save(filePath, encoder); }
public string[] SaveTestOutputFileMultiFrame <TPixel>( Image <TPixel> image, string extension = "png", IImageEncoder encoder = null, object testOutputDetails = null, bool appendPixelTypeToFileName = true) where TPixel : unmanaged, IPixel <TPixel> { encoder ??= TestEnvironment.GetReferenceEncoder($"foo.{extension}"); string[] files = this.GetTestOutputFileNamesMultiFrame( image.Frames.Count, extension, testOutputDetails, appendPixelTypeToFileName).ToArray(); for (int i = 0; i < image.Frames.Count; i++) { using (Image <TPixel> frameImage = image.Frames.CloneFrame(i)) { string filePath = files[i]; using (FileStream stream = File.OpenWrite(filePath)) { frameImage.Save(stream, encoder); } } } return(files); }
public static void Save(this Image image, string path, IImageEncoder encoder) { using (var stream = File.Create(path)) { Save(image, stream, encoder); } }
/// <summary> /// Writes the image to the given stream using the given image format. /// </summary> /// <param name="source">The source image.</param> /// <param name="stream">The stream to save the image to.</param> /// <param name="format">The format to save the image in.</param> /// <exception cref="ArgumentNullException">The stream is null.</exception> /// <exception cref="ArgumentNullException">The format is null.</exception> /// <exception cref="NotSupportedException">The stream is not writable.</exception> /// <exception cref="NotSupportedException">No encoder available for provided format.</exception> public static void Save(this Image source, Stream stream, IImageFormat format) { Guard.NotNull(stream, nameof(stream)); Guard.NotNull(format, nameof(format)); if (!stream.CanWrite) { throw new NotSupportedException("Cannot write to the stream."); } IImageEncoder encoder = source.GetConfiguration().ImageFormatsManager.FindEncoder(format); if (encoder is null) { var sb = new StringBuilder(); sb.AppendLine("No encoder was found for the provided mime type. Registered encoders include:"); foreach (KeyValuePair <IImageFormat, IImageEncoder> val in source.GetConfiguration().ImageFormatsManager.ImageEncoders) { sb.AppendFormat(" - {0} : {1}{2}", val.Key.Name, val.Value.GetType().Name, Environment.NewLine); } throw new NotSupportedException(sb.ToString()); } source.Save(stream, encoder); }
private IPropagatorBlock <RenderedSceneTile <TPixel>, EncodedSceneTile> CreateImageEncoding <TPixel>(ZZMapsImageFormat format, ExecutionDataflowBlockOptions dataflowOptions, ProgressStep?progressStep) where TPixel : unmanaged, IPixel <TPixel> { IImageEncoder encoder = format switch { ZZMapsImageFormat.Png => new PngEncoder() { CompressionLevel = (PngCompressionLevel)Math.Clamp(options.PNGCompression, (int)PngCompressionLevel.BestSpeed, (int)PngCompressionLevel.BestCompression) }, ZZMapsImageFormat.Jpeg => new JpegEncoder() { Quality = Math.Clamp(options.JPEGQuality, 0, 100) }, _ => throw new NotSupportedException($"Unsupported image format {format}") }; return(new TransformBlock <RenderedSceneTile <TPixel>, EncodedSceneTile>(renderedTile => { var stream = new MemoryStream(); encoder.Encode(renderedTile.Image, stream); stream.Position = 0; progressStep?.Increment(); return new EncodedSceneTile(renderedTile.SceneName, renderedTile.Layer, renderedTile.TileID, stream); }, dataflowOptions)); }
/// <summary> /// Saves the image to the given stream using the currently loaded image format. /// </summary> /// <param name="filePath">The file path to save the image to.</param> /// <exception cref="System.ArgumentNullException">Thrown if the stream is null.</exception> /// <returns>The <see cref="Image{TPixel}"/></returns> public Image <TPixel> Save(string filePath) { Guard.NotNullOrEmpty(filePath, nameof(filePath)); string ext = Path.GetExtension(filePath).Trim('.'); var format = this.Configuration.FindFormatByFileExtensions(ext); if (format == null) { var stringBuilder = new StringBuilder(); stringBuilder.AppendLine($"Can't find a format that is associated with the file extention '{ext}'. Registered formats with there extensions include:"); foreach (IImageFormat fmt in this.Configuration.ImageFormats) { stringBuilder.AppendLine($" - {fmt.Name} : {string.Join(", ", fmt.FileExtensions)}"); } throw new NotSupportedException(stringBuilder.ToString()); } IImageEncoder encoder = this.Configuration.FindEncoder(format); if (encoder == null) { var stringBuilder = new StringBuilder(); stringBuilder.AppendLine($"Can't find encoder for file extention '{ext}' using image format '{format.Name}'. Registered encoders include:"); foreach (KeyValuePair <IImageFormat, IImageEncoder> enc in this.Configuration.ImageEncoders) { stringBuilder.AppendLine($" - {enc.Key} : {enc.Value.GetType().Name}"); } throw new NotSupportedException(stringBuilder.ToString()); } return(this.Save(filePath, encoder)); }
public void ApplyEncoderDefaults(IImageEncoder encoder) { switch (encoder) { case BmpEncoder bmpEncoder: bmpEncoder.BitsPerPixel = BmpBitsPerPixel.Pixel32; bmpEncoder.SupportTransparency = false; break; case GifEncoder: // Use the ImageSharp defaults break; case JpegEncoder jpegEncoder: jpegEncoder.ColorType = JpegColorType.Rgb; jpegEncoder.Quality = 100; break; case PngEncoder pngEncoder: pngEncoder.BitDepth = PngBitDepth.Bit16; pngEncoder.ColorType = PngColorType.Rgb; pngEncoder.CompressionLevel = PngCompressionLevel.NoCompression; pngEncoder.TransparentColorMode = PngTransparentColorMode.Clear; break; case TiffEncoder tiffEncoder: tiffEncoder.CompressionLevel = SixLabors.ImageSharp.Compression.Zlib.DeflateCompressionLevel.NoCompression; tiffEncoder.BitsPerPixel = TiffBitsPerPixel.Bit24; break; default: throw new NotSupportedException("Unable to provide any default values for this encoder."); } }
/// <summary> /// For a given file path find the best encoder to use via its extension. /// </summary> /// <param name="source">The source image.</param> /// <param name="filePath">The target file path to save the image to.</param> /// <returns>The matching encoder.</returns> public static IImageEncoder DetectEncoder(this Image source, string filePath) { Guard.NotNull(filePath, nameof(filePath)); string ext = Path.GetExtension(filePath); IImageFormat format = source.GetConfiguration().ImageFormatsManager.FindFormatByFileExtension(ext); if (format is null) { var sb = new StringBuilder(); sb.AppendLine($"No encoder was found for extension '{ext}'. Registered encoders include:"); foreach (IImageFormat fmt in source.GetConfiguration().ImageFormats) { sb.AppendFormat(" - {0} : {1}{2}", fmt.Name, string.Join(", ", fmt.FileExtensions), Environment.NewLine); } throw new NotSupportedException(sb.ToString()); } IImageEncoder encoder = source.GetConfiguration().ImageFormatsManager.FindEncoder(format); if (encoder is null) { var sb = new StringBuilder(); sb.AppendLine($"No encoder was found for extension '{ext}' using image format '{format.Name}'. Registered encoders include:"); foreach (KeyValuePair <IImageFormat, IImageEncoder> enc in source.GetConfiguration().ImageFormatsManager.ImageEncoders) { sb.AppendFormat(" - {0} : {1}{2}", enc.Key, enc.Value.GetType().Name, Environment.NewLine); } throw new NotSupportedException(sb.ToString()); } return(encoder); }
private static Configuration CreateDefaultConfiguration() { var cfg = new Configuration( new JpegConfigurationModule(), new GifConfigurationModule() ); // Magick codecs should work on all platforms IImageEncoder pngEncoder = IsWindows ? (IImageEncoder)SystemDrawingReferenceEncoder.Png : new PngEncoder(); IImageEncoder bmpEncoder = IsWindows ? (IImageEncoder)SystemDrawingReferenceEncoder.Bmp : new BmpEncoder(); cfg.ConfigureCodecs( ImageFormats.Png, MagickReferenceDecoder.Instance, pngEncoder, new PngImageFormatDetector()); cfg.ConfigureCodecs( ImageFormats.Bmp, SystemDrawingReferenceDecoder.Instance, bmpEncoder, new BmpImageFormatDetector()); return(cfg); }
public ImageRenderer( int pixelSize = 10, int barHeightFor1DBarcode = 40, ImageFormat imageFormat = ImageFormat.Png, int jpegQuality = 75, bool includeEanContentAsText = false, string eanFontFamily = null) { if (pixelSize <= 0) { throw new ArgumentOutOfRangeException(nameof(pixelSize), "Value must be larger than zero"); } if (barHeightFor1DBarcode <= 0) { throw new ArgumentOutOfRangeException(nameof(barHeightFor1DBarcode), "Value must be larger than zero"); } if (jpegQuality < 0 || jpegQuality > 100) { throw new ArgumentOutOfRangeException(nameof(jpegQuality), "Value must be a value between 0 and 100"); } _pixelSize = pixelSize; _barHeightFor1DBarcode = barHeightFor1DBarcode; _imageEncoder = GetImageEncoder(imageFormat, jpegQuality); _includeEanContentAsText = includeEanContentAsText; _eanFontFamily = eanFontFamily ?? "Arial"; }
/// <summary> /// Encode the image into a byte array in accordance with the specified image format /// </summary> /// <typeparam name="T">Pixel data type</typeparam> /// <param name="image">Image data</param> /// <param name="imageFormat">Image format</param> /// <param name="quality">Quality index that will be used to encode the image</param> /// <returns>Image binary data</returns> protected virtual byte[] EncodeImage <T>(Image <T> image, IImageFormat imageFormat, int?quality = null) where T : struct, IPixel <T> { using (MemoryStream stream = new MemoryStream()) { IImageEncoder imageEncoder = SixLabors.ImageSharp.Configuration.Default.ImageFormatsManager.FindEncoder(imageFormat); switch (imageEncoder) { case JpegEncoder jpegEncoder: jpegEncoder.Quality = quality ?? _mediaSettings.DefaultImageQuality; jpegEncoder.Encode(image, stream); break; case PngEncoder pngEncoder: pngEncoder.ColorType = PngColorType.Rgb; pngEncoder.Encode(image, stream); break; case BmpEncoder bmpEncoder: bmpEncoder.BitsPerPixel = BmpBitsPerPixel.Pixel32; bmpEncoder.Encode(image, stream); break; case GifEncoder gifEncoder: gifEncoder.Encode(image, stream); break; default: imageEncoder.Encode(image, stream); break; } return(stream.ToArray()); } }
private Size GetOptimumImageSize(Image image, int maxFileSize, IImageEncoder imageEncoder) { Size size = image.Size(); int maxPossibleWidth = size.Width; int minPossibleWidth = GetMinimumPossibleWidth(size, maxFileSize); long imageFileSize = 0; long lastImageFileSize; Size trySize = size; // use binary search to find maximum size within filesize constraint do { lastImageFileSize = imageFileSize; imageFileSize = GetImageFileSize(image, trySize, imageEncoder); if (imageFileSize > maxFileSize) { maxPossibleWidth = trySize.Width - 1; } else { minPossibleWidth = trySize.Width; } int tryWidth = (minPossibleWidth + maxPossibleWidth) / 2; int tryHeight = (tryWidth * size.Height) / size.Width; trySize = new Size(tryWidth, tryHeight); } while (maxPossibleWidth > (minPossibleWidth + 1)); return(new Size(minPossibleWidth, (minPossibleWidth * size.Height) / size.Width)); }
/// <summary> /// Sets a specific image encoder as the encoder for a specific image format. /// </summary> /// <param name="imageFormat">The image format to register the encoder for.</param> /// <param name="encoder">The encoder to use,</param> public void SetEncoder(IImageFormat imageFormat, IImageEncoder encoder) { Guard.NotNull(imageFormat, nameof(imageFormat)); Guard.NotNull(encoder, nameof(encoder)); this.AddImageFormat(imageFormat); this.mimeTypeEncoders.AddOrUpdate(imageFormat, encoder, (s, e) => encoder); }
public static async void LimitImageScale(string path, int maxWidth, int maxHeight) { await Task.Run(() => { try { IImageFormat format = Image.DetectFormat(path); IImageEncoder encoder = null; if (format == Png) { encoder = PngEncoder; } else if (format == Jpeg) { encoder = JpegEncoder; } else if (format == Bmp) { encoder = BmpEncoder; } else if (format == Gif) { encoder = GifEncoder; } else { return; } var image = Image.Load <Rgba32>(path); bool flag = false; var width = image.Width; var height = image.Height; if (width > maxWidth) { flag = true; var rate = (double)maxWidth / width; width = Convert.ToInt32(Math.Floor(width *rate)); height = Convert.ToInt32(Math.Floor(height *rate)); } if (height > maxHeight) { flag = true; var rate = (double)maxHeight / height; width = Convert.ToInt32(Math.Floor(width *rate)); height = Convert.ToInt32(Math.Floor(height *rate)); } if (flag) { image.Mutate(x => x.Resize(width, height, new BoxResampler())); image.Save(path, encoder); } } catch (Exception ex) { ConsoleLog.Error("Image Utils", ex.GetFormatString()); } }); }
public ContourTracingDetector( IImageEncoder imageEncoder, IBlobSearcher blobSearcher ) { m_imageEncoder = imageEncoder; m_blobSearcher = blobSearcher; }
/// <summary> /// Saves the image to the given stream using the given image encoder. /// </summary> /// <param name="stream">The stream to save the image to.</param> /// <param name="encoder">The encoder to save the image with.</param> /// <param name="cancellationToken">The token to monitor for cancellation requests.</param> /// <exception cref="ArgumentNullException">Thrown if the stream or encoder is null.</exception> /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns> public Task SaveAsync(Stream stream, IImageEncoder encoder, CancellationToken cancellationToken = default) { Guard.NotNull(stream, nameof(stream)); Guard.NotNull(encoder, nameof(encoder)); this.EnsureNotDisposed(); return(this.AcceptVisitorAsync(new EncodeVisitor(encoder, stream), cancellationToken)); }
public RecursiveBasedDetector( IImageEncoder imageEncoder, IBlobSearcher blobSearcher ) { m_imageEncoder = imageEncoder; m_blobSearcher = blobSearcher; }
public static byte[] ToBytes(this Image <Rgba32> image, IImageEncoder encoder = null) { using (var m = new MemoryStream()) { image.Save(m, _encoder); return(m.ToArray()); } }
public static byte[] ToByteArray(this Image <Rgba32> imageIn, IImageEncoder encoder) { using (var ms = new MemoryStream()) { imageIn.Save(ms, encoder); return(ms.ToArray()); } }
public static byte[] ToArray <TPixel>(this Image <TPixel> image, IImageEncoder encoder) where TPixel : unmanaged, IPixel <TPixel> { using (var memoryStream = new MemoryStream()) { image.Save(memoryStream, encoder); return(memoryStream.ToArray()); } }
/// <summary> /// Writes the image to the given stream using the currently loaded image format. /// </summary> /// <param name="source">The source image.</param> /// <param name="filePath">The file path to save the image to.</param> /// <param name="encoder">The encoder to save the image with.</param> /// <exception cref="ArgumentNullException">Thrown if the encoder is null.</exception> public static void Save(this Image source, string filePath, IImageEncoder encoder) { Guard.NotNull(encoder, nameof(encoder)); using (Stream fs = source.GetConfiguration().FileSystem.Create(filePath)) { source.Save(fs, encoder); } }
public void Save(Stream stream, IImageEncoder encoder) { if (stream == null) { throw new ArgumentNullException(); } encoder.Encode(this, stream); }
/// <summary> /// Saves the image to the given stream using the currently loaded image format. /// </summary> /// <param name="filePath">The file path to save the image to.</param> /// <param name="encoder">The encoder to save the image with.</param> /// <param name="options">The options for the encoder.</param> /// <exception cref="System.ArgumentNullException">Thrown if the encoder is null.</exception> /// <returns>The <see cref="Image{TColor}"/></returns> public Image <TColor> Save(string filePath, IImageEncoder encoder, IEncoderOptions options) { Guard.NotNull(encoder, nameof(encoder)); using (FileStream fs = File.Create(filePath)) { return(this.Save(fs, encoder)); } }
/// <summary> /// Saves the image to the given stream using the given image encoder. /// </summary> /// <param name="stream">The stream to save the image to.</param> /// <param name="encoder">The encoder to save the image with.</param> /// <exception cref="ArgumentNullException">Thrown if the stream or encoder is null.</exception> public void Save(Stream stream, IImageEncoder encoder) { Guard.NotNull(stream, nameof(stream)); Guard.NotNull(encoder, nameof(encoder)); this.EnsureNotDisposed(); this.AcceptVisitor(new EncodeVisitor(encoder, stream)); }
/// <summary> /// Saves the image to the given stream using the given image encoder. /// </summary> /// <param name="stream">The stream to save the image to.</param> /// <param name="encoder">The encoder to save the image with.</param> /// <exception cref="System.ArgumentNullException">Thrown if the stream or encoder is null.</exception> /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns> public async Task SaveAsync(Stream stream, IImageEncoder encoder) { Guard.NotNull(stream, nameof(stream)); Guard.NotNull(encoder, nameof(encoder)); this.EnsureNotDisposed(); await this.AcceptVisitorAsync(new EncodeVisitor(encoder, stream)).ConfigureAwait(false); }
/// <summary> /// Saves the image to the given stream using the currently loaded image format. /// </summary> /// <param name="filePath">The file path to save the image to.</param> /// <param name="encoder">The encoder to save the image with.</param> /// <param name="options">The options for the encoder.</param> /// <exception cref="System.ArgumentNullException">Thrown if the encoder is null.</exception> /// <returns>The <see cref="Image{TPixel}"/></returns> public Image <TPixel> Save(string filePath, IImageEncoder encoder, IEncoderOptions options) { Guard.NotNull(encoder, nameof(encoder)); using (Stream fs = this.Configuration.FileSystem.Create(filePath)) { return(this.Save(fs, encoder, options)); } }
void SaveToImage(Canvas canvas, SaveFileDialog dialog, IImageEncoder encoder) { using (var stream = dialog.OpenFile()) { var image = canvas.ToImage(); encoder.Encode(image, stream); } }
public VideoStreamingService(ICameraController cameraController, IImageEncoder imageEncoder, IModuleConfiguration moduleConfiguration, IWebClient webClient) { encoder = imageEncoder; SendImage += OnSendImage; client = webClient; controller = cameraController; configuration = moduleConfiguration; configuration.StreamingValueChanged += OnStreamingValueChanged; configuration.CurrentVideoSizeChanged += OnCurrentVideoSizeChanged; }
public ImageProcessor(ILogger logger, IServerApplicationPaths appPaths, IFileSystem fileSystem, IJsonSerializer jsonSerializer, IImageEncoder imageEncoder, int maxConcurrentImageProcesses, Func<ILibraryManager> libraryManager) { _logger = logger; _fileSystem = fileSystem; _jsonSerializer = jsonSerializer; _imageEncoder = imageEncoder; _libraryManager = libraryManager; _appPaths = appPaths; ImageEnhancers = new List<IImageEnhancer>(); _saveImageSizeTimer = new Timer(SaveImageSizeCallback, null, Timeout.Infinite, Timeout.Infinite); Dictionary<Guid, ImageSize> sizeDictionary; try { sizeDictionary = jsonSerializer.DeserializeFromFile<Dictionary<Guid, ImageSize>>(ImageSizeFile) ?? new Dictionary<Guid, ImageSize>(); } catch (FileNotFoundException) { // No biggie sizeDictionary = new Dictionary<Guid, ImageSize>(); } catch (DirectoryNotFoundException) { // No biggie sizeDictionary = new Dictionary<Guid, ImageSize>(); } catch (Exception ex) { logger.ErrorException("Error parsing image size cache file", ex); sizeDictionary = new Dictionary<Guid, ImageSize>(); } _cachedImagedSizes = new ConcurrentDictionary<Guid, ImageSize>(sizeDictionary); _logger.Info("ImageProcessor started with {0} max concurrent image processes", maxConcurrentImageProcesses); _imageProcessingSemaphore = new SemaphoreSlim(maxConcurrentImageProcesses, maxConcurrentImageProcesses); }
public ClipboardService(IClipboard clipboard, IImageEncoder encoder, IMimeTypeResolver mimeTypeResolver) { _clipboard = clipboard; _encoder = encoder; _mimeTypeResolver = mimeTypeResolver; }
public static void Save(this Image image, Stream stream, IImageEncoder encoder) => encoder.Encode(image, stream);
//Handles encoding/decoding using the correct method and settings when the 'Proceed' button is pressed. private void _encodeOrDecodeImage() { if (rdioEncode.Checked) { if (picResult.Image != null) { picResult.Image.Dispose(); } byte[] msg = _getMessageFromTextboxOrFile(); //Create an _imageEncoder according according to selected method if (!OptionsForm.LSBMethodSelected) { lblProcessing.Text = "Encoding using GT method..."; lblProcessing.Visible = true; Application.DoEvents(); //Use simple constructor if a table is null if (OptionsForm.QuantizationTableY == null || OptionsForm.QuantizationTableChr == null || OptionsForm.HuffmanTableYAC == null || OptionsForm.HuffmanTableYDC == null || OptionsForm.HuffmanTableChrAC == null || OptionsForm.HuffmanTableChrDC == null) { _imageEncoder = new JpegImage(CoverImage, OptionsForm.Quality, OptionsForm.MValue); } else { _imageEncoder = new JpegImage(CoverImage, OptionsForm.Quality, OptionsForm.MValue, OptionsForm.QuantizationTableY, OptionsForm.QuantizationTableChr, OptionsForm.HuffmanTableYDC, OptionsForm.HuffmanTableYAC, OptionsForm.HuffmanTableChrDC, OptionsForm.HuffmanTableChrAC); } } else { lblProcessing.Text = "Encoding using LSB method..."; lblProcessing.Visible = true; Application.DoEvents(); _imageEncoder = new LeastSignificantBitImage(CoverImage); } //Encode try { _imageEncoder.Encode(msg); _imageEncoder.Save(_userSavePath); picResult.Image = Image.FromFile(_userSavePath); } catch (ImageCannotContainDataException) { MessageBox.Show("Image cannot contain data!"); } catch (ExternalException) { MessageBox.Show("Failed to load result picture! Your Huffman table may be invalid"); } catch (Exception) { MessageBox.Show("An error occured when encoding!"); } } else if (rdioDecode.Checked) { picResult.Image = null; tbMessage.Text = ""; if (!OptionsForm.LSBMethodSelected) { lblProcessing.Text = "Decoding using GT method..."; lblProcessing.Visible = true; Application.DoEvents(); _imageDecoder = new JPEGDecoder(_decodeFilePath); } else { lblProcessing.Text = "Decoding using LSB method..."; lblProcessing.Visible = true; Application.DoEvents(); _imageDecoder = new LeastSignificantBitDecoder(_decodeFilePath); } //Decode try { byte[] message = _imageDecoder.Decode(); tbMessage.Text = new string(message.Select(x => (char)x).ToArray()); File.WriteAllBytes(_userSavePath, message); } catch (Exception) { MessageBox.Show("An Error occured when decoding! Cover image might not contain a message."); } } }