public ImageController( PreviewFacade preview, IImageFormat[] formats, IUserAuthentication authentication, IImageRequestStrategy strategy ) : base(authentication) { this.preview = preview; this.formats = formats; this.strategy = strategy; }
public ImageCache( ILocation cacheRoot, IImageFormat cacheFormat, IImageLoader imageLoader, ICacheDependencyProvider[] dependencyProviders ) { this.CacheRoot = cacheRoot; this.CacheFormat = cacheFormat; this.imageLoader = imageLoader; this.dependencyProviders = dependencyProviders; }
/// <summary> /// Create a new instance of the <see cref="Image{TPixel}"/> class from the given stream. /// </summary> /// <param name="stream">The stream containing image information.</param> /// <param name="format">The format type of the decoded image.</param> /// <exception cref="ArgumentNullException">The stream is null.</exception> /// <exception cref="NotSupportedException">The stream is not readable.</exception> /// <exception cref="UnknownImageFormatException">Image format not recognised.</exception> /// <exception cref="InvalidImageContentException">Image contains invalid content.</exception> /// <typeparam name="TPixel">The pixel format.</typeparam> /// <returns>A new <see cref="Image{TPixel}"/>.</returns> public static Image <TPixel> Load <TPixel>(Stream stream, out IImageFormat format) where TPixel : unmanaged, IPixel <TPixel> => Load <TPixel>(Configuration.Default, stream, out format);
/// <inheritdoc/> public void Save(Stream stream, IImageFormat format) { Guard.NotNull(stream, nameof(stream)); format.Encoder.Encode(this, stream); }
/// <summary> /// Create a new instance of the <see cref="Image{TPixel}"/> class from the given file. /// </summary> /// <param name="path">The file path to the image.</param> /// <param name="format">The mime type of the decoded image.</param> /// <exception cref="NotSupportedException"> /// Thrown if the stream is not readable nor seekable. /// </exception> /// <typeparam name="TPixel">The pixel format.</typeparam> /// <returns>A new <see cref="Image{TPixel}"/>.</returns> public static Image <TPixel> Load <TPixel>(string path, out IImageFormat format) where TPixel : unmanaged, IPixel <TPixel> { return(Load <TPixel>(Configuration.Default, path, out format)); }
/// <summary> /// Load a new instance of <see cref="Image{TPixel}"/> from the given encoded byte array. /// </summary> /// <param name="data">The byte array containing image data.</param> /// <param name="format">The mime type of the decoded image.</param> /// <typeparam name="TPixel">The pixel format.</typeparam> /// <returns>A new <see cref="Image{TPixel}"/>.</returns> public static Image <TPixel> Load <TPixel>(byte[] data, out IImageFormat format) where TPixel : struct, IPixel <TPixel> => Load <TPixel>(Configuration.Default, data, out format);
/// <summary> /// Load a new instance of <see cref="Image{TPixel}"/> from the given encoded byte array. /// </summary> /// <param name="configuration">The configuration options.</param> /// <param name="data">The byte array containing encoded image data.</param> /// <param name="format">The <see cref="IImageFormat"/> of the decoded image.</param> /// <typeparam name="TPixel">The pixel format.</typeparam> /// <exception cref="ArgumentNullException">The configuration is null.</exception> /// <exception cref="ArgumentNullException">The data is null.</exception> /// <exception cref="UnknownImageFormatException">Image format not recognised.</exception> /// <exception cref="InvalidImageContentException">Image contains invalid content.</exception> /// <returns>A new <see cref="Image{TPixel}"/>.</returns> public static Image <TPixel> Load <TPixel>(Configuration configuration, byte[] data, out IImageFormat format) where TPixel : unmanaged, IPixel <TPixel> { Guard.NotNull(data, nameof(data)); using (var stream = new MemoryStream(data, 0, data.Length, false, true)) { return(Load <TPixel>(configuration, stream, out format)); } }
/// <summary> /// Reads the raw image information from the specified stream without fully decoding it. /// </summary> /// <param name="configuration">The configuration.</param> /// <param name="stream">The image stream to read the information from.</param> /// <param name="format">The format type of the decoded image.</param> /// <exception cref="ArgumentNullException">The configuration is null.</exception> /// <exception cref="ArgumentNullException">The stream is null.</exception> /// <exception cref="NotSupportedException">The stream is not readable.</exception> /// <exception cref="InvalidImageContentException">Image contains invalid content.</exception> /// <returns> /// The <see cref="IImageInfo"/> or null if a suitable info detector is not found. /// </returns> public static IImageInfo Identify(Configuration configuration, Stream stream, out IImageFormat format) { (IImageInfo ImageInfo, IImageFormat Format)data = WithSeekableStream(configuration, stream, s => InternalIdentity(s, configuration ?? Configuration.Default)); format = data.Format; return(data.ImageInfo); }
/// <summary> /// Create a new instance of the <see cref="Image{Rgba32}"/> class from the given stream. /// </summary> /// <param name="config">The config for the decoder.</param> /// <param name="stream">The stream containing image information.</param> /// <param name="format">the mime type of the decoded image.</param> /// <exception cref="NotSupportedException"> /// Thrown if the stream is not readable nor seekable. /// </exception> /// <returns>A new <see cref="Image{Rgba32}"/>.</returns>> public static Image <Rgba32> Load(Configuration config, Stream stream, out IImageFormat format) => Load <Rgba32>(config, stream, out format);
public LoadImageFromUrlResult(Image <Rgba32> image, IImageFormat imageFormat) { this.Image = image; this.ImageFormat = imageFormat; }
private static byte[] ImageToByteArray(Image <Rgba32> image, IImageFormat imageFormat) { using var ms = new MemoryStream(); image.Save(ms, imageFormat); return(ms.ToArray()); }
private static byte[] ImageToBytes(Image image, IImageFormat format) { using MemoryStream ms = new MemoryStream(); image.Save(ms, format); return(ms.ToArray()); }
static PhpGdImageResource imagecreatecommon(int x_size, int y_size, IConfigurationModule configuration, IImageFormat format) { if (x_size <= 0 || y_size <= 0) { PhpException.Throw(PhpError.Warning, string.Format(Resources.invalid_image_dimensions)); return(null); } return(new PhpGdImageResource(x_size, y_size, configuration, format)); }
/// <summary> /// Create a new instance of the <see cref="Image{TPixel}"/> class from the given stream. /// </summary> /// <param name="configuration">The configuration options.</param> /// <param name="stream">The stream containing image information.</param> /// <param name="format">The format type of the decoded image.</param> /// <exception cref="ArgumentNullException">The configuration is null.</exception> /// <exception cref="ArgumentNullException">The stream is null.</exception> /// <exception cref="NotSupportedException">The stream is not readable.</exception> /// <exception cref="UnknownImageFormatException">Image format not recognised.</exception> /// <exception cref="InvalidImageContentException">Image contains invalid content.</exception> /// <typeparam name="TPixel">The pixel format.</typeparam> /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns> public static Image <TPixel> Load <TPixel>(Configuration configuration, Stream stream, out IImageFormat format) where TPixel : unmanaged, IPixel <TPixel> { (Image <TPixel> Image, IImageFormat Format)data = WithSeekableStream(configuration, stream, s => Decode <TPixel>(s, configuration)); format = data.Format; if (data.Image != null) { return(data.Image); } var sb = new StringBuilder(); sb.AppendLine("Image cannot be loaded. Available decoders:"); foreach (KeyValuePair <IImageFormat, IImageDecoder> val in configuration.ImageFormatsManager.ImageDecoders) { sb.AppendFormat(" - {0} : {1}{2}", val.Key.Name, val.Value.GetType().Name, Environment.NewLine); } throw new UnknownImageFormatException(sb.ToString()); }
public void WhenNoMatchingFormatFound_ReturnsNull() { IImageFormat type = Image.DetectFormat(new Configuration(), this.DataStream); Assert.Null(type); }
/// <summary> /// Reads the raw image information from the specified stream without fully decoding it. /// </summary> /// <param name="stream">The image stream to read the header from.</param> /// <param name="format">The format type of the decoded image.</param> /// <exception cref="ArgumentNullException">The stream is null.</exception> /// <exception cref="NotSupportedException">The stream is not readable.</exception> /// <exception cref="InvalidImageContentException">Image contains invalid content.</exception> /// <returns> /// The <see cref="IImageInfo"/> or null if a suitable info detector is not found. /// </returns> public static IImageInfo Identify(Stream stream, out IImageFormat format) => Identify(Configuration.Default, stream, out format);
/// <summary> /// Create a new instance of the <see cref="Image{TPixel}"/> class from the given stream. /// </summary> /// <param name="stream">The stream containing image information.</param> /// <param name="format">the mime type of the decoded image.</param> /// <exception cref="NotSupportedException"> /// Thrown if the stream is not readable nor seekable. /// </exception> /// <typeparam name="TPixel">The pixel format.</typeparam> /// <returns>A new <see cref="Image{TPixel}"/>.</returns>> public static Image <TPixel> Load <TPixel>(Stream stream, out IImageFormat format) where TPixel : struct, IPixel <TPixel> { return(Load <TPixel>(null, stream, out format)); }
/// <summary> /// html view model /// </summary> /// <param name="captcha"></param> /// <param name="imagePath">Get pictures using HTTP</param> /// <param name="format">Get pictures using Base64</param> /// <returns></returns> public static CaptchaViewModel ToViewModel(this CaptchaImage captcha, string validatePath, Action <CaptchaViewModel> imagePath = null, bool hasBackground = false, IImageFormat format = null) { if (captcha == null) { return(new CaptchaViewModel()); } var model = new CaptchaViewModel(); model.Extension = captcha.Extension; model.Index = JsonSerializer.Serialize(captcha.Index); model.Change = JsonSerializer.Serialize(captcha.Change); model.Width = captcha.Backgorund.Width; model.Height = captcha.Backgorund.Height; model.Row = captcha.Row; model.Col = captcha.Col; model.X = captcha.Points.Count; model.validate = validatePath; model.Tips = captcha.Tips; if (imagePath != null) { model.IsAction = true; imagePath(model); } else { model.IsAction = false; if (format == null) { format = JpegFormat.Instance; } model.Gap = captcha.Gap?.ToBase64String(PngFormat.Instance); model.BgGap = captcha.GapBackground?.ToBase64String(model.Height != captcha.GapBackground.Height?PngFormat.Instance:format); if (hasBackground) { model.Full = captcha.Backgorund?.ToBase64String(format); } } model.Type = captcha.Type; model.Tk = captcha.Token; model.Name = captcha.Name; return(model); }
/// <summary> /// Create a new instance of the <see cref="Image{TPixel}"/> class from the given stream. /// </summary> /// <param name="config">The configuration options.</param> /// <param name="stream">The stream containing image information.</param> /// <param name="format">the mime type of the decoded image.</param> /// <exception cref="NotSupportedException"> /// Thrown if the stream is not readable nor seekable. /// </exception> /// <typeparam name="TPixel">The pixel format.</typeparam> /// <returns>A new <see cref="Image{TPixel}"/>.</returns>> public static Image <TPixel> Load <TPixel>(Configuration config, Stream stream, out IImageFormat format) where TPixel : struct, IPixel <TPixel> { config = config ?? Configuration.Default; var data = WithSeekableStream(stream, s => Decode <TPixel>(s, config)); format = data.Item2; if (data.Item1 != null) { return(data.Item1); } var stringBuilder = new StringBuilder(); stringBuilder.AppendLine("Image cannot be loaded. Available decoders:"); foreach (KeyValuePair <IImageFormat, IImageDecoder> val in config.ImageDecoders) { stringBuilder.AppendLine($" - {val.Key.Name} : {val.Value.GetType().Name}"); } throw new NotSupportedException(stringBuilder.ToString()); }
/// <summary> /// Reads the raw image information from the specified stream without fully decoding it. /// </summary> /// <param name="data">The byte array containing encoded image data to read the header from.</param> /// <param name="format">The format type of the decoded image.</param> /// <exception cref="ArgumentNullException">The data is null.</exception> /// <exception cref="NotSupportedException">The data is not readable.</exception> /// <returns> /// The <see cref="IImageInfo"/> or null if suitable info detector not found. /// </returns> public static IImageInfo Identify(byte[] data, out IImageFormat format) => Identify(Configuration.Default, data, out format);
/// <summary> /// Create a new instance of the <see cref="Image{Rgba32}"/> class from the given stream. /// </summary> /// <param name="stream">The stream containing image information.</param> /// <param name="format">the mime type of the decoded image.</param> /// <exception cref="NotSupportedException"> /// Thrown if the stream is not readable nor seekable. /// </exception> /// <returns>A new <see cref="Image{Rgba32}"/>.</returns>> public static Image <Rgba32> Load(Stream stream, out IImageFormat format) => Load <Rgba32>(stream, out format);
/// <summary> /// Load a new instance of <see cref="Image{TPixel}"/> from the given encoded byte array. /// </summary> /// <param name="config">The configuration options.</param> /// <param name="data">The byte array containing encoded image data.</param> /// <param name="format">The <see cref="IImageFormat"/> of the decoded image.</param> /// <typeparam name="TPixel">The pixel format.</typeparam> /// <returns>A new <see cref="Image{TPixel}"/>.</returns> public static Image <TPixel> Load <TPixel>(Configuration config, byte[] data, out IImageFormat format) where TPixel : struct, IPixel <TPixel> { using (var stream = new MemoryStream(data)) { return(Load <TPixel>(config, stream, out format)); } }
/// <summary> /// By reading the header on the provided stream this calculates the images format. /// </summary> /// <param name="stream">The image stream to read the header from.</param> /// <param name="config">The configuration.</param> /// <param name="format">The IImageFormat.</param> /// <returns>The image format or null if none found.</returns> private static IImageDecoder DiscoverDecoder(Stream stream, Configuration config, out IImageFormat format) { format = InternalDetectFormat(stream, config); return(format != null ? config.ImageFormatsManager.FindDecoder(format) : null); }
/// <summary> /// Create a new instance of the <see cref="Image{TPixel}"/> class from the given file. /// </summary> /// <param name="config">The configuration options.</param> /// <param name="path">The file path to the image.</param> /// <param name="format">The mime type of the decoded image.</param> /// <exception cref="NotSupportedException"> /// Thrown if the stream is not readable nor seekable. /// </exception> /// <typeparam name="TPixel">The pixel format.</typeparam> /// <returns>A new <see cref="Image{TPixel}"/>.</returns> public static Image <TPixel> Load <TPixel>(Configuration config, string path, out IImageFormat format) where TPixel : unmanaged, IPixel <TPixel> { using (Stream stream = config.FileSystem.OpenRead(path)) { return(Load <TPixel>(config, stream, out format)); } }
public void FromFileSystemPath_GlobalConfiguration() { IImageFormat type = Image.DetectFormat(ActualImagePath); Assert.Equal(ExpectedGlobalFormat, type); }
public void AddImageFormat(IImageFormat format){ imageFormats.Add(format); }
public void FromFileSystemPath_CustomConfiguration() { IImageFormat type = Image.DetectFormat(this.LocalConfiguration, this.MockFilePath); Assert.Equal(this.LocalImageFormat, type); }
public void FromStream_CustomConfiguration() { IImageFormat type = Image.DetectFormat(this.LocalConfiguration, this.DataStream); Assert.Equal(this.LocalImageFormat, type); }
/// <summary> /// Decode a new instance of the <see cref="Image"/> class from the given stream. /// The pixel format is selected by the decoder. /// </summary> /// <param name="stream">The stream containing image information.</param> /// <param name="format">The format type of the decoded image.</param> /// <exception cref="ArgumentNullException">The stream is null.</exception> /// <exception cref="NotSupportedException">The stream is not readable.</exception> /// <exception cref="UnknownImageFormatException">Image format not recognised.</exception> /// <exception cref="InvalidImageContentException">Image contains invalid content.</exception> /// <returns>The <see cref="Image"/>.</returns> public static Image Load(Stream stream, out IImageFormat format) => Load(Configuration.Default, stream, out format);