public MediaPart CreateMedia(Stream stream, string path, string mimeType, string contentType)
{
if (String.IsNullOrEmpty(contentType))
{
contentType = "Image";
}
var part = _contentManager.New <MediaPart>(contentType);
part.LogicalType = "Image";
part.MimeType = mimeType;
part.Title = Path.GetFileNameWithoutExtension(path);
var imagePart = part.As <ImagePart>();
if (imagePart == null)
{
return(null);
}
using (var image = Image.FromStream(stream)) {
imagePart.Width = image.Width;
imagePart.Height = image.Height;
}
return(part);
}
protected override Tuple <Image, object> GetImage()
{
var source = HasChanges ? ChangesFile : Path;
_currentDDS = TexHelper.Instance.LoadFromDDSFile(source, DDS_FLAGS.NONE);
var codec = TexHelper.Instance.GetWICCodec(WICCodecs.PNG);
var metadata = _currentDDS.GetMetadata();
ScratchImage decompressed;
try
{
decompressed = _currentDDS.Decompress(DXGI_FORMAT.UNKNOWN);
}
catch (ArgumentException e)
{
decompressed = _currentDDS;
}
try
{
var imageStream = decompressed.SaveToWICMemory(0, WIC_FLAGS.NONE, codec);
var image = Image.FromStream(imageStream);
var properties = new TexMetadataView(metadata);
return(new Tuple <Image, object>(image, properties));
}
catch (Exception e)
{
return(new Tuple <Image, object>(null, null));
}
}
public static Image SaveImgBase64ToFile(string FileMapPath, string strBase64Img)
{
// Save the image to a file.
var mem = Base64StringToStream(strBase64Img);
Image pic = Image.FromStream(mem);
var fPath = FileMapPath;
if (fPath.ToLower().EndsWith(".gif"))
{
pic.Save(fPath, ImageFormat.Gif);
}
else if (fPath.ToLower().EndsWith(".jpg") | fPath.ToLower().EndsWith(".jpeg"))
{
pic.Save(fPath, ImageFormat.Jpeg);
}
else if (fPath.ToLower().EndsWith(".png"))
{
pic.Save(fPath, ImageFormat.Png);
}
else
{
pic.Save(fPath, ImageFormat.Jpeg);
}
return(pic);
}
public BufferedImage byteArrayToImage(byte[] byteArrayIn)
{
MemoryStream ms = new MemoryStream(byteArrayIn);
BufferedImage returnImage = BufferedImage.FromStream(ms);
return(returnImage);
}
private void sendImage()
{
Console.WriteLine("Picking image");
OpenFileDialog op = new OpenFileDialog();
op.Title = "Select a picture";
op.Filter = "All supported graphics|*.jpg;*.jpeg;*.png|" +
"JPEG (*.jpg;*.jpeg)|*.jpg;*.jpeg|" +
"Portable Network Graphic (*.png)|*.png";
if (op.ShowDialog() == true)
{
Console.WriteLine("Showing dialog");
MessageItem message = new MessageItem();
var wc = new WebClient();
Image image = Image.FromStream(wc.OpenRead(new Uri(op.FileName)));
var imageInBase64 = Utilities.imageToBase64(image);
Console.WriteLine("image to send:" + imageInBase64);
message.Image = imageInBase64;
Console.WriteLine("message.image: " + message.Image);
sendMessage(message);
}
}
public Image GetCaptchaImage(string proxy, bool _useProxy)
{
_proxy = proxy;
//load Steam page
if (_useProxy)
{
_client.Proxy = new WebProxy(Regex.Split(proxy, ":")[0], int.Parse(Regex.Split(proxy, ":")[1]));
}
_client.BaseUrl = JoinUri;
_request.Method = Method.GET;
var response = _client.Execute(_request);
//Store captcha ID
_captchaGid = CaptchaRegex.Matches(response.Content)[0].Groups[1].Value;
//download and return captcha image
_client.BaseUrl = new Uri(CaptchaUri + _captchaGid);
var captchaResponse = _client.DownloadData(_request);
using (var ms = new MemoryStream(captchaResponse))
{
return(Image.FromStream(ms));
}
}
private List <Image> ConvertImages(IEnumerable <Novacode.Picture> pictures, IEnumerable <Novacode.Image> images)
{
var result = new List <Image>(0);
var enumerable = images as Novacode.Image[] ?? images.ToArray();
foreach (var pic in pictures)
{
Novacode.Image image = null;
foreach (var img in enumerable)
{
if (pic.FileName != img.FileName)
{
continue;
}
image = img;
break;
}
if (image == null)
{
continue;
}
result.Add(Image.FromStream(image.GetStream(FileMode.Open, FileAccess.Read)));
}
return(result);
}
/// <summary>
/// Return the Image from the given URL
/// </summary>
/// <param name="sURL"></param>
/// <returns></returns>
public static Image GetImageFromURL(string sURL)
{
if (sURL.Length == 0)
{
return(null);
}
Image img = null;
try
{
WebRequest webReq = null;
webReq = WebRequest.Create(sURL);
try
{
// Use the current user in case an NTLM Proxy or similar is used.
// wr.Proxy = WebProxy.GetDefaultProxy();
webReq.Proxy.Credentials = CredentialCache.DefaultCredentials;
}
catch (Exception) {}
WebResponse webResp = webReq.GetResponse();
img = Image.FromStream(webResp.GetResponseStream());
}
catch {}
return(img);
}
public byte[] Convert(byte[] bmpBytes)
{
byte[] result = null;
ImageCodecInfo encoderInfo = ImageCodecInfo.GetImageEncoders().First(i => i.MimeType == "image/tiff");
EncoderParameters encoderParams = new EncoderParameters(2);
EncoderParameter parameter = new EncoderParameter(Encoder.Compression, (long)EncoderValue.CompressionCCITT3);
encoderParams.Param[0] = parameter;
parameter = new EncoderParameter(Encoder.SaveFlag, (long)EncoderValue.FrameDimensionPage);
encoderParams.Param[1] = parameter;
using (MemoryStream inStream = new MemoryStream(bmpBytes))
using (MemoryStream outStream = new MemoryStream())
{
using (NetImage tiff = NetImage.FromStream(inStream))
{
tiff.Save(outStream, encoderInfo, encoderParams);
}
result = outStream.ToArray();
}
return(result);
}
private async void Headerimagebox_TextChanged(object sender, TextChangedEventArgs e)
{
try
{
if (!Headerimagebox.Text.Contains("http://"))
{
BusyIndicator.IsBusy = true;
await Task.Delay(100);
var fileInfo = new FileInfo(Headerimagebox.Text);
Kernel.ScriptUploaderWindow.Title = "Size: " + fileInfo.Length / 1024 + "kbs";
try
{
Image img;
using (var msPng = new MemoryStream(File.ReadAllBytes(Headerimagebox.Text)))
{
img = Image.FromStream(msPng);
}
using (var msJpeg = new MemoryStream())
{
img.Save(msJpeg, ImageFormat.Jpeg);
File.WriteAllBytes(Headerimagebox.Text, msJpeg.ToArray());
}
}
catch { }
fileInfo = new FileInfo(Headerimagebox.Text);
Kernel.ScriptUploaderWindow.Title += " | New Size: " + fileInfo.Length / 1024 + "kbs";
}
var bitmap = new BitmapImage();
bitmap.BeginInit();
bitmap.UriSource = new Uri(Headerimagebox.Text, UriKind.Absolute);
bitmap.EndInit();
Headerimage.Source = bitmap;
if (bitmap.Width > 1280 || bitmap.Height > 720)
{
MessageBox.Show("Sorry, the image is too big. max is 1280x720");
return;
}
if (Headerimagebox.Text.Contains("cdn.votc.xyz") || Headerimagebox.Text == "")
{
return;
}
var fileName = HashIt(Headerimagebox.Text) + ".png";
await ImageUpload.Upload(Headerimagebox.Text, fileName);
Headerimagebox.Text = "http://cdn.votc.xyz/votcstore/" + fileName;
}
catch (Exception ex)
{
IoQueue.Add(ex);
}
finally
{
BusyIndicator.IsBusy = false;
}
}
public ImageType Recognize()
{
using (var memoryStream = new MemoryStream(_data))
{
var image = DrawingImage.FromStream(memoryStream);
return(ImageTypeMatchers.First(matcher => matcher.Match(image)).ImageType);
}
}
public SDSize TiffSystemDrawing()
{
using (var memoryStream = new MemoryStream(this.data))
using (var image = SDImage.FromStream(memoryStream))
{
return(image.Size);
}
}
/// <summary>
/// Upload image to be approved by admin
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
protected void btnUpload_Click(object sender, EventArgs e)
{
lblMessage.Text = "";
lblError.Text = "";
try
{
string targetPath = $@"{Server.MapPath("~/tempimages")}";
if (Directory.Exists(targetPath))
{
if (uplImage.HasFile)
{
int fileLength = uplImage.PostedFile.ContentLength;
ImageD img = ImageD.FromStream(uplImage.PostedFile.InputStream);
string imageType = "";
if (ImageFormat.Jpeg.Equals(img.RawFormat))
{
imageType = "JPEG";
}
if (ImageFormat.Png.Equals(img.RawFormat))
{
imageType = "PNG";
}
if (ImageFormat.Gif.Equals(img.RawFormat))
{
imageType = "GIF";
}
if (File.Exists($@"{targetPath}\{uplImage.FileName}"))
{
this.lblMessage.Text = "File exists and will be overwritten. ";
}
uplImage.SaveAs($@"{targetPath}\{uplImage.FileName}");
this.lblMessage.Text += $"{uplImage.FileName}" +
$" has been uploaded to the physical directory " +
$"{targetPath}. " +
$"The size is " +
$"{fileLength.ToString()} bytes " +
$"and the filetype is {imageType}";
}
}
else
{
this.lblError.Text = "No image selected";
}
}
catch (Exception ex)
{
lblError.Text = ex.Message;
}
}
protected void CreateBrand()
{
try
{
var brand = new Brand
{
Name = txtName.Text,
//BrandLogo = logo,
Description = FCKDescription.Text,
BriefDescription = FCKBriefDescription.Text,
Enabled = chkEnabled.Checked,
UrlPath = txtURL.Text,
SortOrder = txtSortOrder.Text.TryParseInt(),
CountryId = SQLDataHelper.GetInt(ddlCountry.SelectedValue),
BrandSiteUrl = txtBrandSiteUrl.Text,
Meta = new MetaInfo
{
Type = MetaType.Brand,
MetaDescription = txtMetaDescription.Text,
Title = txtHeadTitle.Text,
MetaKeywords = txtMetaKeys.Text,
H1 = txtH1.Text
}
};
var tempbrandId = BrandService.AddBrand(brand);
if (FileUpload1.HasFile)
{
var tempName = PhotoService.AddPhoto(new Photo(0, tempbrandId, PhotoType.Brand)
{
OriginName = FileUpload1.FileName
});
if (!string.IsNullOrWhiteSpace(tempName))
{
using (Image image = Image.FromStream(FileUpload1.FileContent))
{
FileHelpers.SaveResizePhotoFile(FoldersHelper.GetPathAbsolut(FolderType.BrandLogo, tempName), SettingsPictureSize.BrandLogoWidth, SettingsPictureSize.BrandLogoHeight, image);
}
}
}
if (lblError.Visible == false)
{
txtName.Text = string.Empty;
FCKDescription.Text = string.Empty;
FCKBriefDescription.Text = string.Empty;
chkEnabled.Checked = true;
}
// close
}
catch (Exception ex)
{
MsgErr(ex.Message + " CreateBrand main");
Debug.LogError(ex);
}
}
/// <summary>
/// Export a plot model to an image.
/// </summary>
/// <param name="plot">Plot model to be exported.</param>
/// <param name="width">Desired width of the image (in px).</param>
/// <param name="height">Desired height of the image (in px).</param>
public Image Export(IPlotModel plot, double width, double height)
{
using (Stream stream = new MemoryStream())
{
PngExporter.Export(plot, stream, (int)width, (int)height);
stream.Seek(0, SeekOrigin.Begin);
return(Image.FromStream(stream));
}
}
public SDSize PngSystemDrawing()
{
using (var memoryStream = new MemoryStream(this.pngBytes))
{
using (var image = SDImage.FromStream(memoryStream))
{
return(image.Size);
}
}
}
public void ReadImages()
{
if (this.bmpStream == null)
{
this.bmpStream = File.OpenRead(Path.Combine(TestEnvironment.InputImagesDirectoryFullPath, TestImages.Bmp.Car));
this.bmpCore = Image.Load <Rgba32>(this.bmpStream);
this.bmpStream.Position = 0;
this.bmpDrawing = SDImage.FromStream(this.bmpStream);
}
}
private Image LoadImage()
{
var url = HttpUtility.UrlDecode(ImageMap.ImageUrl, System.Text.Encoding.GetEncoding("ISO-8859-1"));
var unifiedFile = HostingEnvironment.VirtualPathProvider.GetFile(url) as UnifiedFile;
using (var stream = unifiedFile.Open())
{
return(Image.FromStream(stream));
}
}
static bool IsValidImage(Stream stream)
{
try {
using (var image = Image.FromStream(stream)) {
return(true);
}
} catch (Exception) {
return(false);
}
}
public async Task <Image> LoadRelatedArtistsImages(FullArtist artist)
{
using (WebClient webClient = new WebClient())
{
var data = await webClient.DownloadDataTaskAsync(artist.Images.LastOrDefault().Url);
var mem = new MemoryStream(data);
return(Image.FromStream(mem));
}
}
private void ReceiveMessage()
{
try
{
while (true)
{
byte[] data = new byte[1024];
StringBuilder builder = new StringBuilder();
int bytes = 0;
do
{
bytes = _stream.Read(data, 0, data.Length);
builder.Append(Encoding.Default.GetString(data, 0, bytes));
}while (_stream.DataAvailable);
string json = builder.ToString();
string json2 = "";
Message messageResp = null;
if (json.Contains("&image#"))
{
string imageString = json.Split(new[] { "&image#" }, StringSplitOptions.None)[1];
byte[] buffer = Encoding.Default.GetBytes(imageString);
using (Image image = Image.FromStream(new MemoryStream(buffer)))
{
image.Save("output.jpg", ImageFormat.Jpeg); // Or Png
}
json2 = json.Split(new[] { "&image#" }, StringSplitOptions.None)[0];
messageResp = JsonConvert.DeserializeObject <Message>(json2);
}
else
{
messageResp = JsonConvert.DeserializeObject <Message>(json);
}
Dispatcher.Invoke(() => { txtBoxChat.Text += messageResp.From + ": " + messageResp.Text + Environment.NewLine; });
}
}
catch (SocketException ex)
{
MessageBox.Show(ex.Message);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
finally
{
_stream.Close();
_client.Close();
}
}
private Image UpdateTogglePinningToolStripMenuItemImage()
{
if (this.togglePinningToolStripMenuItem.Checked)
{
return(Image.FromStream(Application.GetResourceStream(new Uri(string.Format(imageRuiFormat, "pinned.ico"))).Stream));
}
else
{
return(Image.FromStream(Application.GetResourceStream(new Uri(string.Format(imageRuiFormat, "unpinned.ico"))).Stream));
}
}
public ActionResult UploadImage(HttpPostedFileBase file1, bool isSaveSource)
{
var uploadPath = WebContext.Path.UploadPath(WebUser.UserId);
if (string.IsNullOrEmpty(uploadPath) || file1 == null)
{
return(Content("error:路径有错误"));
}
IOFactory.Folder.Create(uploadPath);
if (file1.ContentLength > 2004800)
{
return(Content("error:文件请小于2M"));
}
var fileExtension = System.IO.Path.GetExtension(file1.FileName).ToLower();
if (!ConfigSerializer.Load <List <string> >("AllowImageExt").Contains(fileExtension))
{
return(Content("error:您上传的文件扩展名不正确"));
}
var fileName = WebContext.Path.NewPhoto(WebUser.UserId, fileExtension);
var photourl = System.IO.Path.Combine(uploadPath, fileName);
if (isSaveSource)
{
IOFactory.StoreFile.Save(file1.InputStream, photourl);
}
//按比例生成缩略图
using (var imgSrc = Image.FromStream(file1.InputStream))
{
foreach (var keyvalue in ConfigSerializer.Load <List <ThumbnailPair> >("ThumbnailSize"))
{
Thumbnail.CreateThumbnail(
imgSrc,
WebContext.Path.ThumbPhoto(fileName, keyvalue.ImageType),
keyvalue.Size.Width,
keyvalue.Size.Height
);
}
}
//SetStarLevel(CHUser.UserId); //更新
Photo.Add(new Photo
{
Title = "头像" + DateTime.Now.ToString("yyyyMMddhhmm"),
UserId = WebUser.UserId,
Summary = "",
Domain = WebContext.Site.Upload.Domain,
Url = photourl
});
UserInfo.ChangeFace(WebUser.UserId, System.IO.Path.Combine(WebContext.Site.Upload.Domain, photourl));
//更新头像地址
//将新头像地址存入相册
return
(Content(WebContext.Path.ThumbUrl(photourl, ThumbType.Big, WebContext)));
}
public void ReadImages()
{
if (this.bmpStream == null)
{
string path = Path.Combine(TestEnvironment.InputImagesDirectoryFullPath, this.LargeImage ? TestImages.Jpeg.Baseline.Jpeg420Exif : TestImages.Bmp.Car);
this.bmpStream = File.OpenRead(path);
this.bmpCore = Image.Load <Rgba32>(this.bmpStream);
this.bmpStream.Position = 0;
this.bmpDrawing = SDImage.FromStream(this.bmpStream);
}
}
private async Task LoadArtistImageFromApi(string url)
{
using (WebClient webClient = new WebClient())
{
var data = await webClient.DownloadDataTaskAsync(url);
using (MemoryStream mem = new MemoryStream(data))
{
ArtistImage = Image.FromStream(mem);
}
}
}
/// <summary>
/// Tries to load image from specified stream.
/// </summary>
/// <param name="imageStream">The input stream to load image from.</param>
/// <param name="key">The image key to be used for diagnostics purposes.</param>
/// <returns>The <see cref="Image"/> object if succeeded; otherwise - <c>nulll</c>.</returns>
private static Image LoadImageSafe(Stream imageStream, string key)
{
try
{
return(Image.FromStream(imageStream));
}
catch (Exception) // catch everything -- there could be out of memory, file not found else???
{
Trace.TraceError("Unable to load image '{0}'.", key);
return(null);
}
}
/// <summary>
/// Export a plot model to an image.
/// </summary>
/// <param name="plot">Plot model to be exported.</param>
/// <param name="width">Desired width of the image (in px).</param>
/// <param name="height">Desired height of the image (in px).</param>
public Image Export(IPlotModel plot, double width, double height)
{
using (Stream stream = new MemoryStream())
{
PngExporter exporter = new PngExporter();
exporter.Height = (int)height;
exporter.Width = (int)width;
exporter.UseTextShaping = false;
exporter.Export(plot, stream);
stream.Seek(0, SeekOrigin.Begin);
return(Image.FromStream(stream));
}
}
public void ReadImages()
{
if (this.bmpStream == null)
{
const string TestImage = TestImages.Jpeg.BenchmarkSuite.Jpeg420Exif_MidSizeYCbCr;
this.bmpStream = File.OpenRead(Path.Combine(TestEnvironment.InputImagesDirectoryFullPath, TestImage));
this.bmpCore = Image.Load <Rgba32>(this.bmpStream);
this.bmpCore.Metadata.ExifProfile = null;
this.bmpStream.Position = 0;
this.bmpDrawing = SDImage.FromStream(this.bmpStream);
this.destinationStream = new MemoryStream();
}
}
public Image DeserializeImage(string name)
{
JToken imageToken = _json["Images"][name];
var base64String = imageToken.ToString();
byte[] data = Convert.FromBase64String(base64String);
using (var stream = new MemoryStream(data, 0, data.Length))
{
Image image = Image.FromStream(stream);
image.Tag = name;
return(image);
}
}
private static void SaveToLocalStorage(byte[] byteArray, bool isThumb, Guid imageGuid, int width, int height,
string ext = "png")
{
if (!isThumb)
{
width = height = 0;
}
using (var ms = new MemoryStream(byteArray)) {
var image = MsImage.FromStream(ms);
var path = string.Format("{0}\\{1}_{2}x{3}.{4}", _imagesDirectory, imageGuid, width, height, ext);
image.Save(path);
}
}