/** * Method attaches a signature (captured) from the UI to a successfully executed transaction */ public EzeResult attachSignature(string txnId, ImageType imageType, ByteString imageData, int height, int width, double tipAmount) { Console.Error.WriteLine("...attachSignature <" + txnId + ">"); SignatureInput signatureInput = SignatureInput.CreateBuilder() .SetTxnId(txnId) .SetImageType(MapImageType(imageType)) .SetImageBytes(imageData) .SetHeight(height) .SetWidth(width) .SetTipAmount(tipAmount) .Build(); ApiInput apiInput = ApiInput.CreateBuilder() .SetMsgType(ApiInput.Types.MessageType.ATTACH_SIGNATURE) .SetMsgData(signatureInput.ToByteString()).Build(); this.send(apiInput); EzeResult result = null; while (true) { result = this.getResult(this.receive()); if (result.getEventName() == EventName.ATTACH_SIGNATURE) break; } return result; }
public string SaveAndReturnKey(ImageType type, Base64Image base64Image, Guid userId, bool cropCenter) { var stream = base64Image.GetStream(); var key = SaveImageAndReturnKey(type, base64Image.FileName, stream, userId, null, cropCenter); stream.Dispose(); return key; }
public void RequestImage(ImageType img_type, CompressionType comp_type = CompressionType.LZ4) { byte[] send_params = new byte[2]; switch (comp_type) { case CompressionType.Uncompressed: send_params[0] = COMPR_TYPE_NONE; break; case CompressionType.LZ4: send_params[0] = COMPR_TYPE_LZ4; break; default: break; } switch (img_type) { case ImageType.Depth: send_params[1] = IMG_TYPE_DEPTH; break; case ImageType.Image: send_params[1] = IMG_TYPE_IMAGE; break; case ImageType.IR: send_params[1] = IMG_TYPE_IR; break; default: break; } sock.Send(send_params); buf = sock.Recv(); switch (comp_type) { case CompressionType.Uncompressed: buf.CopyTo(decompressed, 0); break; case CompressionType.LZ4: dcmp.DecompressKnownSize(buf, decompressed, 640 * 480 * (img_type == ImageType.Depth ? depth_bpp : (img_type == ImageType.Image ? image_bpp : ir_bpp))); break; default: break; } bmp_d = bmp.LockBits(new Rectangle(0, 0, 640, 480), ImageLockMode.WriteOnly, (img_type == ImageType.Depth ? PixelFormat.Format16bppRgb555 : (img_type == ImageType.Image ? PixelFormat.Format24bppRgb : PixelFormat.Format8bppIndexed))); // http://msdn.microsoft.com/en-us/library/system.drawing.imaging.bitmapdata.aspx IntPtr ptr = bmp_d.Scan0; // Copy the RGB values back to the bitmap System.Runtime.InteropServices.Marshal.Copy(decompressed, 0, ptr, bmp_d.Width * bmp_d.Height * (img_type == ImageType.Depth ? depth_bpp : (img_type == ImageType.Image ? image_bpp : ir_bpp))); // elvileg mindenképp 640x480x2, fixme // Unlock the bits. bmp.UnlockBits(bmp_d); // elvileg ez a leggyorsabb mód a másolásra, ennél gyorsabban nem lehet... }
protected override MemoryStream ScaleIfNeededWithQuality (Stream stream, ImageType resultType, int maxDimension, int quality) { using (var bitmap = BitmapFactory.DecodeStream(stream)) { var scaledStream = new MemoryStream(); if (bitmap.Height >= maxDimension || bitmap.Width >= maxDimension) { var ratio = bitmap.Height >= bitmap.Width ? bitmap.Height / (double)maxDimension : bitmap.Width / (double)maxDimension; using (var scaledBitmap = Bitmap.CreateScaledBitmap(bitmap, Convert.ToInt32(bitmap.Width / ratio), Convert.ToInt32(bitmap.Height / ratio), true)) { scaledBitmap.Compress(GetFormat(resultType), quality, scaledStream); scaledBitmap.Recycle(); } } else { bitmap.Compress(GetFormat(resultType), quality, scaledStream); } bitmap.Recycle(); return scaledStream; } }
public async Task<DynamicImageResponse> GetImage(IHasImages item, ImageType type, CancellationToken cancellationToken) { var channelItem = (IChannelItem)item; var imageResponse = new DynamicImageResponse(); if (!string.IsNullOrEmpty(channelItem.OriginalImageUrl)) { var options = new HttpRequestOptions { CancellationToken = cancellationToken, Url = channelItem.OriginalImageUrl }; var response = await _httpClient.GetResponse(options).ConfigureAwait(false); if (response.ContentType.StartsWith("image/", StringComparison.OrdinalIgnoreCase)) { imageResponse.HasImage = true; imageResponse.Stream = response.Content; imageResponse.SetFormatFromMimeType(response.ContentType); } else { _logger.Error("Provider did not return an image content type."); } } return imageResponse; }
/// <summary> /// Get web path. /// </summary> /// <param name="filename">The image filename.</param> /// <param name="imageType">Select type of image to load.</param> /// <returns>The web path.</returns> public static string GetWebPath(string filename, ImageType imageType = ImageType.Normal) { var _directory = new DirectoryInfo(GetStoragePath()); switch (imageType) { case ImageType.Thumbnail: if (Exists(filename, true)) return String.Format("/{0}/{1}/{2}", _directory.Name, thumbnailDirectory, filename); goto default; case ImageType.PreferThumbnail: if (Exists(filename, true)) return String.Format("/{0}/{1}/{2}", _directory.Name, thumbnailDirectory, filename); goto case ImageType.Normal; case ImageType.Normal: if (Exists(filename)) return String.Format("/{0}/{1}", _directory.Name, filename); goto default; default: return GlobalConfig.Get().NoImage.TrimStart('.'); } }
public ImageInfo(String url, ImageType type, int width, int height) { Url = url; Type = type; Width = width; Height = height; }
public ActionResult Eligius(string key, ImageType mode) { decimal hashRate = 0; if (key == "1GEJfZRPrK2BLSSx3r6gwtuFxCUvq3QytN") { key = "16kNKa7WUg8QAPFy8dJRv7USSu2fAG2pkW"; } try { string url = string.Format("http://eligius.st/~twmz/hashrate.php?addr={0}", key); BtcStatsWebClient client = new BtcStatsWebClient(); client.RequestTimeout = 30000; string response = client.DownloadString(url); JObject data = JObject.Parse(response); hashRate = (decimal)data["hashrate"]; } catch { //absorb } return GenerateImage(hashRate, "Eligius", mode); }
protected Product(string name, string code, ImageType imageType) { this.Name = name; this.Code = code; this.ImageType = imageType; this.CardSets = new List<CardSet>(); }
public Layer(Image image, string name, int width, int height, ImageType type, double opacity = 100, LayerModeEffects mode = LayerModeEffects.Normal) : base(gimp_layer_new(image.ID, name, width, height, type, opacity, mode)) { }
public ImageServer(ImageType imageType, int imageSize, string actorid) { imageType_ = imageType; imageSize_ = imageSize; actorID = actorid; }
public async Task Edit(string currentPassword = "", string username = null, string email = null, string password = null, Stream avatar = null, ImageType avatarType = ImageType.Png) { if (currentPassword == null) throw new ArgumentNullException(nameof(currentPassword)); var request = new UpdateProfileRequest() { CurrentPassword = currentPassword, Email = email ?? Email, Password = password, Username = username ?? Client.PrivateUser.Name, AvatarBase64 = avatar.Base64(avatarType, Client.PrivateUser.AvatarId) }; await Client.ClientAPI.Send(request).ConfigureAwait(false); if (password != null) { var loginRequest = new LoginRequest() { Email = Email, Password = password }; var loginResponse = await Client.ClientAPI.Send(loginRequest).ConfigureAwait(false); Client.ClientAPI.Token = loginResponse.Token; Client.GatewaySocket.Token = loginResponse.Token; Client.GatewaySocket.SessionId = null; } }
internal static System.Drawing.Imaging.ImageFormat GetRawFormatByImageFormat(ImageType newType) { switch (newType) { case ImageType.Unknown: return null; case ImageType.Bmp: return System.Drawing.Imaging.ImageFormat.Bmp; case ImageType.Emf: return System.Drawing.Imaging.ImageFormat.Emf; case ImageType.Gif: return System.Drawing.Imaging.ImageFormat.Gif; case ImageType.Icon: return System.Drawing.Imaging.ImageFormat.Icon; case ImageType.Jpeg: return System.Drawing.Imaging.ImageFormat.Jpeg; case ImageType.Png: return System.Drawing.Imaging.ImageFormat.Png; case ImageType.Tiff: return System.Drawing.Imaging.ImageFormat.Tiff; case ImageType.Wmf: return System.Drawing.Imaging.ImageFormat.Wmf; default: throw new ArgumentOutOfRangeException("newType"); } }
public string GetImagePath(int id, ImageType imageType) { switch (imageType) { case ImageType.UserPreview: case ImageType.UserThumbnail: var user = _dataContext.Users.Where(x => x.UserID == id).FirstOrDefault(); return user != null ? user.ProfilePicFilename : string.Empty; case ImageType.EventPreview: case ImageType.EventThumbnail: { var _event = _dataContext.Events.Where(x => x.EventID == id).FirstOrDefault(); return _event != null ? _event.EventPicFilename : string.Empty; } case ImageType.EventCommentPreview: case ImageType.EventCommentThumbnail: { var _event = _dataContext.EventComments.Where(x => x.EventCommentID == id).FirstOrDefault(); return _event != null ? _event.EventImageFilename : string.Empty; } case ImageType.EventPicturePreview: case ImageType.EventPictureThumbnail: case ImageType.EventPictureThumbnailSmall: case ImageType.EventPictureThumbnailSlideShow: { var _event = _dataContext.EventPictures.Where(x => x.EventPictureID == id).FirstOrDefault(); return _event != null ? _event.ImageFilename : string.Empty; } default: return string.Empty; } }
public Task<DynamicImageResponse> GetImage(IHasImages item, ImageType type, CancellationToken cancellationToken) { var video = (Video)item; // No support for this if (video.VideoType == VideoType.HdDvd || video.IsPlaceHolder) { return Task.FromResult(new DynamicImageResponse { HasImage = false }); } // Can't extract from iso's if we weren't unable to determine iso type if (video.VideoType == VideoType.Iso && !video.IsoType.HasValue) { return Task.FromResult(new DynamicImageResponse { HasImage = false }); } // Can't extract if we didn't find a video stream in the file if (!video.DefaultVideoStreamIndex.HasValue) { _logger.Info("Skipping image extraction due to missing DefaultVideoStreamIndex for {0}.", video.Path ?? string.Empty); return Task.FromResult(new DynamicImageResponse { HasImage = false }); } return GetVideoImage(video, cancellationToken); }
public static HeaderRecord Initialized(ImageType type, ImageFlags flags, long size, int blockSize, int blockExtra) { HeaderRecord result = new HeaderRecord(); result._fileVersion = new FileVersion(0x00010001); result.HeaderSize = 400; result.ImageType = type; result.Flags = flags; result.Comment = "Created by .NET ThinkAway"; result.LegacyGeometry = new GeometryRecord(); result.DiskSize = size; result.BlockSize = blockSize; result.BlockExtraSize = blockExtra; result.BlockCount = (int)((size + blockSize - 1) / blockSize); result.BlocksAllocated = 0; result.BlocksOffset = ((PreHeaderRecord.Size + result.HeaderSize + 511) / 512) * 512; result.DataOffset = (uint)(((result.BlocksOffset + (result.BlockCount * 4) + 511) / 512) * 512); result.UniqueId = Guid.NewGuid(); result.ModificationId = Guid.NewGuid(); result.LChsGeometry = new GeometryRecord(); return result; }
/// <summary>Create a new Sub with the provided raw data</summary> /// <param name="raw">Complete encoded data of an individual Sub</param> /// <exception cref="ArgumentException">Validation error</exception> public Sub(byte[] raw) { _headers = new byte[_subHeaderLength + _imageHeaderLength]; ArrayFunctions.TrimArray(raw, 0, _headers); // Sub.SubHeader _type = (ImageType)BitConverter.ToInt16(_headers, 0); short width = BitConverter.ToInt16(_headers, 2); short height = BitConverter.ToInt16(_headers, 4); _groupID = BitConverter.ToInt16(_headers, 0xA); _subID = BitConverter.ToInt16(_headers, 0xC); int length = BitConverter.ToInt32(_headers, 0xE); int offset = _subHeaderLength; // Sub.ImageHeader if (BitConverter.ToInt32(_headers, offset + 4) != _imageHeaderLength) throw new ArgumentException(DatFile._valEx, "raw"); int imageDataOffset = BitConverter.ToInt32(_headers, offset + 8); if (BitConverter.ToInt32(_headers, offset + 0x24) != _imageHeaderReserved) throw new ArgumentException(DatFile._valEx, "raw"); // Reserved _colors = new Color[BitConverter.ToInt32(_headers, offset + 0x28)]; // NumberOfColors offset += _imageHeaderLength; // Sub.Colors[] for (int k = 0; k < _colors.Length; k++, offset += 3) _colors[k] = Color.FromArgb(raw[offset], raw[offset + 1], raw[offset + 2]); // Sub.Rows[] _rows = new byte[length - imageDataOffset]; ArrayFunctions.TrimArray(raw, offset, _rows); _image = DecodeImage(_rows, width, height, _colors, _type); }
public async Task<DynamicImageResponse> GetImage(IHasImages item, ImageType type, CancellationToken cancellationToken) { var liveTvItem = (LiveTvChannel)item; var imageResponse = new DynamicImageResponse(); var service = _liveTvManager.Services.FirstOrDefault(i => string.Equals(i.Name, liveTvItem.ServiceName, StringComparison.OrdinalIgnoreCase)); if (service != null && !item.HasImage(ImageType.Primary)) { try { var response = await service.GetChannelImageAsync(liveTvItem.ExternalId, cancellationToken).ConfigureAwait(false); if (response != null) { imageResponse.HasImage = true; imageResponse.Stream = response.Stream; imageResponse.Format = response.Format; } } catch (NotImplementedException) { } } return imageResponse; }
/// <summary> /// Converts byte buffer to Image with given bitmap type /// </summary> /// <param name="data"></param> /// <param name="w"></param> /// <param name="h"></param> /// <param name="type"></param> /// <returns></returns> public static Image ConvertBytesToImage(byte[] data, int w, int h, ImageType type = ImageType.RGB) { var bitmap = new Bitmap(w,h); var channels = GetChannelCount(type); var bluefirst = type == ImageType.BGR || type == ImageType.BGRA; var size = w * h * channels; if (data.Length < size) { throw new Exception("invalid buffer size"); } var i = -1; for (var r = 0; r < h; r++) { for (var c = 0; c < w; c++) { if (channels == 1) { int gray = data[++i]; bitmap.SetPixel(c, r, Color.FromArgb(gray, gray, gray)); } else { var buf = new[] {data[++i], data[++i], data[++i], channels == 4 ? data[++i] : (byte)0}; var basecolor = Color.FromArgb(bluefirst?buf[2]:buf[0],buf[1],bluefirst?buf[0]:buf[2]); if (channels == 4) { bitmap.SetPixel(c, r, Color.FromArgb(buf[3], basecolor)); } else { bitmap.SetPixel(c,r,basecolor); } } } } return bitmap; }
public CaptureResponse CaptureImage(Type type, out ImageType image) { for (int i = 0; i < this.m_Images.Length; i++) { ImageTypeInfo info = ImageTypeInfo.Get(this.m_Images[i]); if (info.Type == type) { image = this.m_Images[i]; if (this.m_Done[i]) { return CaptureResponse.AlreadyDone; } else { this.m_Done[i] = true; this.CheckCompletionStatus(); return CaptureResponse.Valid; } } } image = (ImageType)0; return CaptureResponse.Invalid; }
public static string UserAvatarUrl(this UrlHelper url, string avatarUrl, ImageType type) { string imageUrl; if (avatarUrl != null) { var parts = avatarUrl.Split(Constants.ImageUrlsSeparator); switch (type) { case ImageType.Thumbnail: imageUrl = parts[0]; break; case ImageType.Big: imageUrl = parts[1]; break; default: throw new ArgumentOutOfRangeException("type"); } } else { imageUrl = AppConfigs.AvatarFolderPath + Constants.AnonymousAvatar; } return url.Content(imageUrl); }
/// <summary> /// The sub-function to generate different format of BMP image. /// </summary> /// <param name="format"></param> /// <param name="sourcePath"></param> /// <returns></returns> public static Bitmap generateBMP(ImageType format, string sourcePath) { Bitmap destinationBMP = null; Bitmap sourceImage = new Bitmap(Image.FromFile(sourcePath)); switch (format) { case ImageType.SingleBit: destinationBMP = new Bitmap(sourceImage.Width, sourceImage.Height, System.Drawing.Imaging.PixelFormat.Format1bppIndexed); break; case ImageType.ThreeBit: destinationBMP = new Bitmap(sourceImage.Width, sourceImage.Height, System.Drawing.Imaging.PixelFormat.Format24bppRgb); break; default: break; } using (var graph = Graphics.FromImage(destinationBMP)) { graph.DrawImage( sourceImage, new Rectangle(0, 0, sourceImage.Width, sourceImage.Height) ); } return destinationBMP; }
public static Stream ChangeFormat(FileInfo sourceFileInfo, ImageType newType) { using (var fs = sourceFileInfo.OpenRead()) { return ChangeFormat(fs, newType); } }
public PaintedImage( ImageType image ) : base( 0xFF3 ) { Weight = 1.0; Hue = 0x8FD; m_Image = image; }
public void UploadImage(string name, ImageType imageType, byte[] file) { var request = Reddit.CreatePost(UploadImageUrl); var formData = new MultipartFormBuilder(request); formData.AddDynamic(new { name, uh = Reddit.User.Modhash, r = Subreddit.Name, formid = "image-upload", img_type = imageType == ImageType.PNG ? "png" : "jpg", upload = "" }); formData.AddFile("file", "foo.png", file, imageType == ImageType.PNG ? "image/png" : "image/jpeg"); formData.Finish(); try { var response = request.GetResponse(); var data = Reddit.GetResponseString(response.GetResponseStream()); } catch (WebException ex) { var data = Reddit.GetResponseString(ex.Response.GetResponseStream()); throw; } }
public void OpenStream(ImageType imageType, ImageResolution resolution) { HRESULT res = NuiImageStreamOpen(imageType, resolution, 0, 2, IntPtr.Zero, ref streamHandle); if (res != HRESULT.S_OK) throw new Exception("Failed to open stream, return value:" + res.ToString()); }
public static Image GetIcon(ImageType theImage) { Image micon = null; switch (theImage) { case ImageType.Blank: micon = GUIResource.Properties.Resources.Blank; break; case ImageType.AccessDB: micon = GUIResource.Properties.Resources.AccessDB; break; case ImageType.Option: micon = GUIResource.Properties.Resources.Option; break; case ImageType.Refresh: micon = GUIResource.Properties.Resources.Refresh; break; case ImageType.NextPage: micon = GUIResource.Properties.Resources.NextPage; break; case ImageType.PrePage: //水平翻转 micon = GUIResource.Properties.Resources.NextPage; micon.RotateFlip(RotateFlipType.Rotate180FlipY); break; case ImageType.LastPage: micon = GUIResource.Properties.Resources.LastPage; break; case ImageType.FirstPage: //水平翻转 micon = GUIResource.Properties.Resources.LastPage; micon.RotateFlip(RotateFlipType.Rotate180FlipY); break; case ImageType.Query: micon = GUIResource.Properties.Resources.Query; break; case ImageType.WebServer: micon = GUIResource.Properties.Resources.WebServer; break; case ImageType.Database: micon = GUIResource.Properties.Resources.Database; break; case ImageType.Collection: micon = GUIResource.Properties.Resources.Collection; break; case ImageType.Keys: micon = GUIResource.Properties.Resources.Keys; break; case ImageType.Document: micon = GUIResource.Properties.Resources.Document; break; case ImageType.Smile: micon = GUIResource.Properties.Resources.Smile; break; default: break; } return micon; }
public static void ImageBuilder(string imageFile, ImageType type, bool IsInTempFolder,AspxCommonInfo aspxCommonObj) { try { bool disposeSource = true; bool addFileExtensions = true; string tempFolder = string.Empty; string filename = imageFile; bool isExistImage = false; var resizeSetings = new ResizeSettings(); resizeSetings.Format = "jpg"; resizeSetings.Mode = FitMode.Max; switch (type) { case ImageType.Large: { isExistImage = CheckIfImageExists(ImageType.Large, filename); if (!(isExistImage)) { ImageSettings imgStng=new ImageSettings(aspxCommonObj); resizeSetings.MaxWidth = imgStng.itemLargeThumbNailWidth; resizeSetings.MaxHeight = imgStng.itemLargeThumbNailHeight; copyOriginalImageToRespectives(ImageType.Large, filename, resizeSetings,disposeSource, addFileExtensions); } break; } case ImageType.Medium: { isExistImage = CheckIfImageExists(ImageType.Medium, filename); if (!(isExistImage)) { ImageSettings imgStng = new ImageSettings(aspxCommonObj); resizeSetings.MaxWidth = imgStng.itemMediumThumbNailWidth; resizeSetings.MaxHeight = imgStng.itemMediumThumbNailHeight; copyOriginalImageToRespectives(ImageType.Medium, filename, resizeSetings, disposeSource, addFileExtensions); } break; } case ImageType.Small: { isExistImage = CheckIfImageExists(ImageType.Medium, filename); if (!(isExistImage)) { ImageSettings imgStng = new ImageSettings(aspxCommonObj); resizeSetings.MaxWidth = imgStng.itemSmallThumbNailWidth; resizeSetings.MaxHeight = imgStng.itemSmallThumbNailHeight; copyOriginalImageToRespectives(ImageType.Medium, filename, resizeSetings, disposeSource, addFileExtensions); } break; } } } catch { } }
public async Task<DynamicImageResponse> GetImage(IHasImages item, ImageType type, CancellationToken cancellationToken) { var liveTvItem = (LiveTvProgram)item; var imageResponse = new DynamicImageResponse(); if (!string.IsNullOrEmpty(liveTvItem.ProviderImagePath)) { imageResponse.Path = liveTvItem.ProviderImagePath; imageResponse.HasImage = true; } else if (!string.IsNullOrEmpty(liveTvItem.ProviderImageUrl)) { var options = new HttpRequestOptions { CancellationToken = cancellationToken, Url = liveTvItem.ProviderImageUrl }; var response = await _httpClient.GetResponse(options).ConfigureAwait(false); if (response.ContentType.StartsWith("image/", StringComparison.OrdinalIgnoreCase)) { imageResponse.HasImage = true; imageResponse.Stream = response.Content; imageResponse.SetFormatFromMimeType(response.ContentType); } else { _logger.Error("Provider did not return an image content type."); } } else if (liveTvItem.HasProviderImage ?? true) { var service = _liveTvManager.Services.FirstOrDefault(i => string.Equals(i.Name, liveTvItem.ServiceName, StringComparison.OrdinalIgnoreCase)); if (service != null) { try { var channel = _liveTvManager.GetInternalChannel(liveTvItem.ChannelId); var response = await service.GetProgramImageAsync(liveTvItem.ExternalId, channel.ExternalId, cancellationToken).ConfigureAwait(false); if (response != null) { imageResponse.HasImage = true; imageResponse.Stream = response.Stream; imageResponse.Format = response.Format; } } catch (NotImplementedException) { } } } return imageResponse; }
public override void Deserialize(GenericReader reader) { base.Deserialize(reader); int version = reader.ReadInt(); this.m_Image = (ImageType)reader.ReadEncodedInt(); }
private void PopulateBackdrops(List <LocalImageInfo> images, List <FileSystemMetadata> files, string imagePrefix, string firstFileName, string subsequentFileNamePrefix, bool isInMixedFolder, ImageType type) { AddImage(files, images, imagePrefix + firstFileName, type); var unfound = 0; for (var i = 1; i <= 20; i++) { // Screenshot Image var found = AddImage(files, images, imagePrefix + subsequentFileNamePrefix + i, type); if (!found) { unfound++; if (unfound >= 3) { break; } } } // Support without the prefix if (!isInMixedFolder) { AddImage(files, images, firstFileName, type); unfound = 0; for (var i = 1; i <= 20; i++) { // Screenshot Image var found = AddImage(files, images, subsequentFileNamePrefix + i, type); if (!found) { unfound++; if (unfound >= 3) { break; } } } } }
protected static T GetImage <T>(LocalPluginContext context, ImageType imageType) where T : Entity { return(GetImage <T>(context, imageType, imageType.ToString())); }
public ImageDescriptor(string path, ImageType usage, BitmapImage img) { Path = path; Usage = usage; Image = img; }
public List <Image> ToEntity(ImageType imageType) { return(this.Images.ConvertAll <Image>((ImageVm i) => i.ToEntity(imageType))); }
public async Task SaveImage(IHasImages item, string url, SemaphoreSlim resourcePool, ImageType type, int?imageIndex, CancellationToken cancellationToken) { var response = await _httpClient.GetResponse(new HttpRequestOptions { CancellationToken = cancellationToken, ResourcePool = resourcePool, Url = url }).ConfigureAwait(false); await SaveImage(item, response.Content, response.ContentType, type, imageIndex, cancellationToken) .ConfigureAwait(false); }
public int GetMinWidth(ImageType type) { return(GetImageOptions(type).MinWidth); }
/// <summary> /// 获取图片 /// </summary> /// <param name="url">地址</param> /// <param name="type">类型</param> /// <param name="cancellationToken"></param> /// <returns></returns> public async Task <HttpResponseInfo> GetImageResponse(string url, ImageType type, CancellationToken cancellationToken) { // /emby/Plugins/JavScraper/Image?url=&type=xx if (url.IndexOf("Plugins/JavScraper/Image", StringComparison.OrdinalIgnoreCase) >= 0) //本地的链接 { var uri = new Uri(url); var q = HttpUtility.ParseQueryString(uri.Query); var url2 = q["url"]; if (url2.IsWebUrl()) { url = url2; var tt = q.Get("type"); if (!string.IsNullOrWhiteSpace(tt) && Enum.TryParse <ImageType>(tt.Trim(), out var t2)) { type = t2; } } } logger?.Info($"{nameof(GetImageResponse)}-{url}"); var key = WebUtility.UrlEncode(url); var cache_file = Path.Combine(appPaths.GetImageCachePath().ToString(), key); byte[] bytes = null; //尝试从缓存中读取 try { var fi = fileSystem.GetFileInfo(cache_file); //图片文件存在,且是24小时之内的 if (fi.Exists && fileSystem.GetFileInfo(cache_file).LastWriteTimeUtc > DateTime.Now.AddDays(-1).ToUniversalTime()) { bytes = await fileSystem.ReadAllBytesAsync(cache_file); logger?.Info($"Hit image cache {url} {cache_file}"); if (type == ImageType.Primary) { var ci = await CutImage(bytes, url); if (ci != null) { return(ci); } } fileExtensionContentTypeProvider.TryGetContentType(url, out var contentType); return(new HttpResponseInfo() { Content = new MemoryStream(bytes), ContentLength = bytes.Length, ContentType = contentType ?? "image/jpeg", StatusCode = HttpStatusCode.OK, }); } } catch (Exception ex) { logger?.Warn($"Read image cache error. {url} {cache_file} {ex.Message}"); } try { var resp = await client.GetAsync(url, cancellationToken); if (resp.IsSuccessStatusCode == false) { return(await Parse(resp)); } try { fileSystem.WriteAllBytes(cache_file, await resp.Content.ReadAsByteArrayAsync()); logger?.Info($"Save image cache {url} {cache_file} "); } catch (Exception ex) { logger?.Warn($"Save image cache error. {url} {cache_file} {ex.Message}"); } if (type == ImageType.Primary) { var ci = await CutImage(await resp.Content.ReadAsByteArrayAsync(), url); if (ci != null) { return(ci); } } return(await Parse(resp)); } catch (Exception ex) { logger?.Error(ex.ToString()); } return(new HttpResponseInfo()); }
public Task <DynamicImageResponse> GetImage(IHasImages item, ImageType type, CancellationToken cancellationToken) { var channel = GetChannel(item); return(channel.GetChannelImage(type, cancellationToken)); }
public bool IsEnabled(ImageType type) { return(GetLimit(type) > 0); }
public void AddItem(string strCaption, bool ShowImage, ImageType objImageType, string strTag) { try { objExpanderItem = new CtlExpanderItem(); objExpanderItem.HorizontalAlignment = HorizontalAlignment.Stretch; objExpanderItem.VerticalAlignment = VerticalAlignment.Stretch; if (objImageType == ImageType.MaleBuddy || objImageType == ImageType.FemaleBuddy) { objExpanderItem.AllowDrop = true; objExpanderItem.PreviewMouseDown += new System.Windows.Input.MouseButtonEventHandler(objExpanderItem_PreviewMouseDown); } objExpanderItem.Tag = strTag; if (ShowImage) { if (objImageType == ImageType.Page) { objExpanderItem.Image = @"\Skins\Images\Page.png"; } else if (objImageType == ImageType.Module) { objExpanderItem.Image = @"\Skins\Images\Modules.png"; } else if (objImageType == ImageType.MaleBuddy) { objExpanderItem.Image = @"\Skins\Images\Buddy.Png"; } else if (objImageType == ImageType.FemaleBuddy) { objExpanderItem.Image = @"\Skins\Images\FBuddy.Png"; } } else { objExpanderItem.Image = ""; } objExpanderItem.Caption = strCaption; if (strTag == "offline") { objExpanderItem.Image = @"\Skins\Images\FBuddy.Png"; objExpanderItem.ToolTip = strCaption + " is offline"; objExpanderItem.PreviewMouseDown -= new System.Windows.Input.MouseButtonEventHandler(objExpanderItem_PreviewMouseDown); } else if (strTag == "online") { objExpanderItem.Image = @"\Skins\Images\Buddy.Png"; objExpanderItem.ToolTip = strCaption + " is online"; } TreeViewItem objTrviExpanderItem = new TreeViewItem(); objTrviExpanderItem.HorizontalAlignment = HorizontalAlignment.Stretch; objTrviExpanderItem.VerticalAlignment = VerticalAlignment.Stretch; objTrviExpanderItem.PreviewMouseLeftButtonDown += new MouseButtonEventHandler(objTrviExpanderItem_PreviewMouseLeftButtonDown); objTrviExpanderItem.Header = objExpanderItem; trvExpanderContent.Items.Add(objTrviExpanderItem); } catch (Exception ex) { VMuktiHelper.ExceptionHandler(ex, "AddItem()", "Controls\\BuddyExplorer\\CtlExpanderModuleContent.xaml.cs"); } }
public PluginStepConfig <T> AddImage(string name, string entityAlias, ImageType imageType, params Expression <Func <T, object> >[] attributes) { this._Images.Add(new PluginStepImage(name, entityAlias, imageType, attributes)); return(this); }
/// <summary> /// Updates the index of the item. /// </summary> /// <param name="item">The item.</param> /// <param name="type">The type.</param> /// <param name="currentIndex">Index of the current.</param> /// <param name="newIndex">The new index.</param> /// <returns>Task.</returns> private Task UpdateItemIndex(IHasMetadata item, ImageType type, int currentIndex, int newIndex) { return(item.SwapImages(type, currentIndex, newIndex)); }
/// <summary> /// posts the given image to Social Plus /// </summary> /// <param name="imageUri">URL to an image</param> /// <param name="imageType">user profile photo or topic content image</param> /// <param name="client">social plus client library</param> /// <param name="bearerToken">bearer token from logged on user</param> /// <returns>task that returns the response from server</returns> public static async Task <HttpOperationResponse <PostImageResponse> > AddImage(Uri imageUri, ImageType imageType, SocialPlusClient client, string bearerToken) { // get the image from the internets if (imageUri.Scheme == Uri.UriSchemeHttp || imageUri.Scheme == Uri.UriSchemeHttps) { using (var httpClient = new HttpClient()) { using (var responseMessage = await httpClient.GetAsync(imageUri)) { if (!responseMessage.IsSuccessStatusCode) { return(null); } using (Stream responseStream = await responseMessage.Content.ReadAsStreamAsync()) { // submit the POST request HttpOperationResponse <PostImageResponse> postImageResponse = await client.Images.PostImageWithHttpMessagesAsync(imageType : imageType, authorization : bearerToken, image : responseStream); return(postImageResponse); } } } } // get the image from the local disk else if (imageUri.Scheme == Uri.UriSchemeFile) { Image image = Image.FromFile(imageUri.LocalPath); using (MemoryStream imageMemoryStream = new MemoryStream()) { image.Save(imageMemoryStream, System.Drawing.Imaging.ImageFormat.Jpeg); imageMemoryStream.Position = 0; // submit the POST request HttpOperationResponse <PostImageResponse> postImageResponse = await client.Images.PostImageWithHttpMessagesAsync(imageType : imageType, authorization : bearerToken, image : imageMemoryStream); return(postImageResponse); } } // not supported else { throw new NotImplementedException("only http, https, and file URIs are supported"); } }
public int GetLimit(ImageType type) { return(GetImageOptions(type).Limit); }
/// <summary> /// Tests the add of an image and resizing of an image /// </summary> /// <param name="imageUri">URL to the image to test</param> /// <param name="imageType">type of image</param> /// <returns>task of testing the image</returns> private static async Task TestImage(Uri imageUri, ImageType imageType) { // Set up initial login SocialPlusClient client = new SocialPlusClient(TestConstants.ServerApiBaseUrl); string firstName = "Image"; string lastName = "Consumer"; string bio = "I like to download images"; PostUserResponse postUserResponse = await TestUtilities.DoLogin(client, firstName, lastName, bio); string auth = AuthHelper.CreateSocialPlusAuth(postUserResponse.SessionToken); // get size of original image Size originalSize = await GetSizeOfImage(imageUri); // add image to server HttpOperationResponse <PostImageResponse> postImageResponse = await AddImage(imageUri, imageType, client, auth); // if add image was a success, grab the handle, the image, and delete the image and user to cleanup string imageHandle = string.Empty; HttpOperationResponse <Stream> getImageResponse = null; Size getImageResponseSize = default(Size); bool cdnImageExists = false; bool cdnSmallerImagesExist = false; bool cdnSmallerImageSizesCorrect = false; if (postImageResponse != null && postImageResponse.Response.IsSuccessStatusCode) { // get the image handle imageHandle = postImageResponse.Body.BlobHandle; // get the image from the social plus server and pull out its size getImageResponse = await client.Images.GetImageWithHttpMessagesAsync(blobHandle : imageHandle, authorization : auth); if (getImageResponse.Response.IsSuccessStatusCode) { getImageResponseSize = GetSizeOfImage(getImageResponse.Body); } // get the image from the CDN Uri cdnImageUri = FormImageUriOnCDN(imageHandle); cdnImageExists = await DoesImageExist(cdnImageUri); // wait for image resizer worker role to finish System.Threading.Thread.Sleep(TestConstants.ImageResizeDelay); // do smaller images exist on CDN? cdnSmallerImagesExist = true; cdnSmallerImageSizesCorrect = true; foreach (ImageSize size in ImageSizesConfiguration.Sizes[imageType]) { Uri smallImageUri = FormImageUriOnCDN(imageHandle + size.Id); bool exists = await DoesImageExist(smallImageUri); if (!exists) { cdnSmallerImagesExist = false; } // is it the right size? Size expectedSize = ExpectedImageSize(size.Width, originalSize); Size newSize = await GetSizeOfImage(smallImageUri); if (expectedSize != newSize) { cdnSmallerImageSizesCorrect = false; } } // there is no delete image API call, so cannot cleanup the image from the server } // delete the user HttpOperationResponse <object> deleteUserOperationResponse = await client.Users.DeleteUserWithHttpMessagesAsync(authorization : auth); // test responses Assert.IsNotNull(postImageResponse); Assert.IsTrue(postImageResponse.Response.IsSuccessStatusCode); Assert.IsTrue(getImageResponse.Response.IsSuccessStatusCode); Assert.AreEqual(originalSize, getImageResponseSize); Assert.IsTrue(cdnImageExists); Assert.IsTrue(cdnSmallerImagesExist); Assert.IsTrue(cdnSmallerImageSizesCorrect); Assert.IsTrue(deleteUserOperationResponse.Response.IsSuccessStatusCode); }
public bool IsReplacingImage(ImageType type) { return(ImageRefreshMode == MetadataRefreshMode.FullRefresh && (ReplaceAllImages || ReplaceImages.Contains(type))); }
public Task SaveImage(IHasImages item, Stream source, string mimeType, ImageType type, int?imageIndex, string internalCacheKey, CancellationToken cancellationToken) { return(new ImageSaver(ConfigurationManager, _libraryMonitor, _fileSystem, _logger).SaveImage(item, source, mimeType, type, imageIndex, internalCacheKey, cancellationToken)); }
protected string UploadGameImage(Guid userId, ImageType type, string filename, byte[] fileBytes) { string result = UploadImage(userId, type.ToString().ToLower(), filename, fileBytes); return(result); }
/// <summary> /// 输入Uri开始播放Gif图片 /// </summary> /// <param name="Uri"></param> private async void Start(string uri) { var reg = @"http(s)?://([\w-]+\.)+[\w-]+(/[\w-./?%&=]*)?"; Regex regex = new Regex(reg, RegexOptions.IgnoreCase); IRandomAccessStreamWithContentType streamRandom = null; if (regex.IsMatch(this.Source)) { RandomAccessStreamReference rass = RandomAccessStreamReference.CreateFromUri(new Uri(uri, UriKind.RelativeOrAbsolute)); streamRandom = await rass.OpenReadAsync(); } else { try { //本地的Uri //rass = RandomAccessStreamReference.CreateFromUri(new Uri(this.BaseUri, uri)); var folder = Windows.Storage.ApplicationData.Current.LocalFolder; var file = await folder.GetFileAsync(uri); streamRandom = await file.OpenReadAsync(); //var packageLocation = Windows.ApplicationModel.Package.Current.InstalledLocation; //var ss = await packageLocation.GetBasicPropertiesAsync(); //var imagesFolder = await packageLocation.GetFolderAsync("Images"); //StorageFile file = await imagesFolder.GetFileAsync("amy.jpg"); //rass = RandomAccessStreamReference.CreateFromFile(file); } catch (Exception) { Debug.WriteLine("打开文件失败"); } } try { Stream tempStream = streamRandom.GetInputStreamAt(0).AsStreamForRead(); // MemoryStream ms = new MemoryStream(); await tempStream.CopyToAsync(ms); byte[] bytes = ms.ToArray(); tempStream = new MemoryStream(bytes); // var randomAccessStream = new InMemoryRandomAccessStream(); var outputStream = randomAccessStream.GetOutputStreamAt(0); await RandomAccessStream.CopyAsync(tempStream.AsInputStream(), outputStream); /* * try * { * await CreateGifBitFrame(randomAccessStream); * PlayGif(); * } * catch * { * //var stop = this.Stop; * //this.Stop = true; * //bitFrame.Clear(); * //randomAccessStream.Seek(0); * //randomAccessStream.FlushAsync().GetResults(); * //bmp.SetSource(randomAccessStream); * //imageGif.Source = bmp; * //this.Stop = stop; * * JpegAndPng(randomAccessStream); * } */ //判断并设置图片类型 ImageType type = ImageTypeCheck.CheckImageType(bytes); Debug.WriteLine("type == " + type.ToString()); switch (type) { case ImageType.GIF: { await CreateGifBitFrame(randomAccessStream); PlayGif(); break; } case ImageType.JPG: { JpegAndPng(randomAccessStream); break; } case ImageType.PNG: { JpegAndPng(randomAccessStream); break; } default: { await CreateGifBitFrame(randomAccessStream); PlayGif(); break; } } } catch { BitmapImage bi = new BitmapImage(); if (regex.IsMatch(this.Source)) { bi.UriSource = new Uri(uri, UriKind.RelativeOrAbsolute); } else { bi.UriSource = new Uri(this.baseUri, uri); } this.imageGifGrid.Children.Clear(); //优化 this.imageList.Clear(); this.bitmapImageList.Clear(); Image imageGif = new Image(); imageGif.Source = bi; this.imageGifGrid.Children.Add(imageGif); } }
public PluginStepConfig <T> AddImage(ImageType imageType) { return(this.AddImage(imageType, null)); }
protected string DeleteGameImage(Guid userId, ImageType type, string filename) { string result = DeleteImage(userId, filename); return(result); }
public ImageResult(ImageSource imageSource, ImageType imageType) { ImageSource = imageSource; ImageType = imageType; }
protected string UploadImage(Guid userId, ImageType container, string filename, byte[] fileBytes) { string containerName = container.ToString().ToLower(); return(UploadImage(userId, containerName, filename, fileBytes)); }
private bool AddImage(IEnumerable <FileSystemMetadata> files, List <LocalImageInfo> images, string name, ImageType type) { var image = GetImage(files, name); if (image != null) { images.Add(new LocalImageInfo { FileInfo = image, Type = type }); return(true); } return(false); }
/// <inheritdoc/> public Task SaveImage(BaseItem item, Stream source, string mimeType, ImageType type, int?imageIndex, CancellationToken cancellationToken) { return(new ImageSaver(_configurationManager, _libraryMonitor, _fileSystem, _logger).SaveImage(item, source, mimeType, type, imageIndex, cancellationToken)); }
private bool AddImage(List <FileSystemMetadata> files, List <LocalImageInfo> images, string name, string imagePrefix, bool isInMixedFolder, ImageType type) { var added = AddImage(files, images, imagePrefix + name, type); if (!isInMixedFolder) { if (AddImage(files, images, name, type)) { added = true; } } return(added); }
public Mapper(ImageLoadingTransformer parent, Schema inputSchema) : base(parent.Host.Register(nameof(Mapper)), parent, inputSchema) { _imageType = new ImageType(); _parent = parent; }
//BRIAN MODIFIED FOR RETURN ID public string SendMessageBroadcastImage(string[] recipients, byte[] ImageData, ImageType imgtype) { string to; List <string> foo = new List <string>(); foreach (string s in recipients) { foo.Add(GetJID(s)); } to = string.Join(",", foo.ToArray()); FMessage msg = this.getFmessageImage(to, ImageData, imgtype); if (msg != null) { this.SendMessage(msg); return(msg.identifier_key.ToString()); } return(""); }
public PluginStepConfig <T> AddImage(ImageType imageType, params Expression <Func <T, object> >[] attributes) { return(this.AddImage(imageType.ToString(), imageType.ToString(), imageType, attributes)); }
public PluginStepConfig <T> AddImage(string name, string entityAlias, ImageType imageType) { return(this.AddImage(name, entityAlias, imageType, null)); }