public static string ToContentType(this ImageFormat rawFormat)
{
var format = new ImageFormatConverter().ConvertToString(rawFormat).ToLower();
new FileExtensionContentTypeProvider().TryGetContentType($".{format}", out string contentType);
return(contentType);
}
private void button5_Click(object sender, EventArgs e)
{
//make an openfiledialog to search for an image
OpenFileDialog os = new OpenFileDialog();
os.ShowDialog();
Image currentImage = null;
string Pfad = os.FileName;
try
{
currentImage = Image.FromFile(Pfad);
}
catch
{
}
if (currentImage != null)
{
MemoryStream ms = new MemoryStream();
ImageFormatConverter mf = new ImageFormatConverter();
currentImage.Save(ms, ImageFormat.Jpeg);
byte[] convertedImage = ms.ToArray();
orga.SendMessageWithContent(CurrentSeletctedChatID, convertedImage);
}
}
public static string GetExtension(this Image img)
{
var converter = new ImageFormatConverter();
var extension = converter.ConvertToString(img.RawFormat);
return(extension?.ToLower());
}
private void button5_Click(object sender, EventArgs e)
{
//Open FileDialog to select a image
OpenFileDialog os = new OpenFileDialog();
os.ShowDialog();
string Pfad = os.FileName;
Image currentSelected = null;
try
{
currentSelected = Image.FromFile(Pfad);
}
catch
{
Console.WriteLine("Cant open the selected file");
}
if (currentSelected != null)
{
MemoryStream ms = new MemoryStream();
ImageFormatConverter mf = new ImageFormatConverter();
currentSelected.Save(ms, ImageFormat.Jpeg);
byte[] Image = ms.ToArray();
//now make a message
ASCIIEncoding enc = new ASCIIEncoding();
orga.SendMessage(CurrentSeletctedChatID, enc.GetString(Image));
}
}
public static GalImage MakeTexture(NvGpuVmm Vmm, long TicPosition)
{
int[] Tic = ReadWords(Vmm, TicPosition, 8);
GalTextureType RType = (GalTextureType)((Tic[0] >> 7) & 7);
GalTextureType GType = (GalTextureType)((Tic[0] >> 10) & 7);
GalTextureType BType = (GalTextureType)((Tic[0] >> 13) & 7);
GalTextureType AType = (GalTextureType)((Tic[0] >> 16) & 7);
GalImageFormat Format = ImageFormatConverter.ConvertTexture((GalTextureFormat)(Tic[0] & 0x7f), RType, GType, BType, AType);
GalTextureSource XSource = (GalTextureSource)((Tic[0] >> 19) & 7);
GalTextureSource YSource = (GalTextureSource)((Tic[0] >> 22) & 7);
GalTextureSource ZSource = (GalTextureSource)((Tic[0] >> 25) & 7);
GalTextureSource WSource = (GalTextureSource)((Tic[0] >> 28) & 7);
int Width = (Tic[4] & 0xffff) + 1;
int Height = (Tic[5] & 0xffff) + 1;
return(new GalImage(
Width,
Height,
Format,
XSource,
YSource,
ZSource,
WSource));
}
private void SetZeta(NvGpuVmm Vmm)
{
long ZA = MakeInt64From2xInt32(NvGpuEngine3dReg.ZetaAddress);
int Format = ReadRegister(NvGpuEngine3dReg.ZetaFormat);
bool ZetaEnable = (ReadRegister(NvGpuEngine3dReg.ZetaEnable) & 1) != 0;
if (ZA == 0 || Format == 0 || !ZetaEnable)
{
Gpu.Renderer.FrameBuffer.UnbindZeta();
return;
}
long Key = Vmm.GetPhysicalAddress(ZA);
int Width = ReadRegister(NvGpuEngine3dReg.ZetaHoriz);
int Height = ReadRegister(NvGpuEngine3dReg.ZetaVert);
GalImageFormat ImageFormat = ImageFormatConverter.ConvertZeta((GalZetaFormat)Format);
GalImage Image = new GalImage(Width, Height, ImageFormat);
long Size = TextureHelper.GetTextureSize(Image);
Gpu.Renderer.Texture.CreateFb(Key, Size, Image);
Gpu.Renderer.FrameBuffer.BindZeta(Key);
}
public void SetUp()
{
imageFmt = ImageFormat.Bmp;
imageFmtStr = imageFmt.ToString();
imgFmtConv = new ImageFormatConverter();
imgFmtConvFrmTD = (ImageFormatConverter)TypeDescriptor.GetConverter(imageFmt);
}
public ImageFormatConverterTest()
{
_imageFmt = ImageFormat.Bmp;
_imageFmtStr = _imageFmt.ToString();
_imgFmtConv = new ImageFormatConverter();
_imgFmtConvFrmTD = (ImageFormatConverter)TypeDescriptor.GetConverter(_imageFmt);
}
/// <summary>
/// Extends ConvertTo so that methods that return a specific type object given a Type parameter can be
/// used as generic method and casting is not required.
/// <example>
/// imageformatconverter.ConvertTo<int>(context, culture, value);
/// </example>
/// </summary>
public static T ConvertTo <T>(this ImageFormatConverter imageformatconverter, System.ComponentModel.ITypeDescriptorContext context, System.Globalization.CultureInfo culture, Object value)
{
if (imageformatconverter == null)
{
throw new ArgumentNullException("imageformatconverter");
}
return((T)imageformatconverter.ConvertTo(context, culture, value, typeof(T)));
}
private string ImageToBase64(Image pImage)
{
string format = new ImageFormatConverter().ConvertToString(pImage.RawFormat);
ImageConverter imgCon = new ImageConverter();
byte[] imageArr = (byte[])imgCon.ConvertTo(pImage, typeof(byte[]));
return("data:image/" + format + ";base64," + Convert.ToBase64String(imageArr));
}
/// <summary>
/// Extends ConvertTo so that methods that return a specific type object given a Type parameter can be
/// used as generic method and casting is not required.
/// <example>
/// typeconverter.ConvertTo<int>(value);
/// </example>
/// </summary>
public static T ConvertTo <T>(this ImageFormatConverter typeconverter, Object value)
{
if (typeconverter == null)
{
throw new ArgumentNullException("typeconverter");
}
return((T)typeconverter.ConvertTo(value, typeof(T)));
}
public void SaveAllImages()
{
//ExStart
//ExFor:ImageData.HasImage
//ExFor:ImageData.ToImage
//ExFor:ImageData.Save(Stream)
//ExSummary:Shows how to save all the images from a document to the file system.
Document imgSourceDoc = new Document(MyDir + "Images.docx");
// Images are stored inside shapes, and if a shape contains an image, its "HasImage" flag will be set
// Get an enumerator for all shapes with that flag in the document
IEnumerable <Shape> shapes = imgSourceDoc.GetChildNodes(NodeType.Shape, true).Cast <Shape>().Where(s => s.HasImage);
// We will use an ImageFormatConverter to determine an image's file extension
ImageFormatConverter formatConverter = new ImageFormatConverter();
// Go over all of the document's shapes
// If a shape contains image data, save the image in the local file system
using (IEnumerator <Shape> enumerator = shapes.GetEnumerator())
{
int shapeIndex = 0;
while (enumerator.MoveNext())
{
ImageData imageData = enumerator.Current.ImageData;
ImageFormat format = imageData.ToImage().RawFormat;
string fileExtension = formatConverter.ConvertToString(format);
using (FileStream fileStream = File.Create(ArtifactsDir + $"Drawing.SaveAllImages.{++shapeIndex}.{fileExtension}"))
imageData.Save(fileStream);
}
}
//ExEnd
string[] imageFileNames = Directory.GetFiles(ArtifactsDir).Where(s => s.StartsWith(ArtifactsDir + "Drawing.SaveAllImages.")).ToArray();
List <FileInfo> fileInfos = imageFileNames.Select(s => new FileInfo(s)).ToList();
TestUtil.VerifyImage(2467, 1500, fileInfos[0].FullName);
Assert.AreEqual(".Jpeg", fileInfos[0].Extension);
TestUtil.VerifyImage(400, 400, fileInfos[1].FullName);
Assert.AreEqual(".Png", fileInfos[1].Extension);
TestUtil.VerifyImage(382, 138, fileInfos[2].FullName);
Assert.AreEqual(".Emf", fileInfos[2].Extension);
TestUtil.VerifyImage(1600, 1600, fileInfos[3].FullName);
Assert.AreEqual(".Wmf", fileInfos[3].Extension);
TestUtil.VerifyImage(534, 534, fileInfos[4].FullName);
Assert.AreEqual(".Emf", fileInfos[4].Extension);
TestUtil.VerifyImage(1260, 660, fileInfos[5].FullName);
Assert.AreEqual(".Jpeg", fileInfos[5].Extension);
TestUtil.VerifyImage(1125, 1500, fileInfos[6].FullName);
Assert.AreEqual(".Jpeg", fileInfos[6].Extension);
TestUtil.VerifyImage(1027, 1500, fileInfos[7].FullName);
Assert.AreEqual(".Jpeg", fileInfos[7].Extension);
TestUtil.VerifyImage(1200, 1500, fileInfos[8].FullName);
Assert.AreEqual(".Jpeg", fileInfos[8].Extension);
}
public static string GetImageFileExtension(byte[] imageData)
{
using (var image = Image.FromStream(new MemoryStream(imageData)))
{
var formatName = new ImageFormatConverter().ConvertToString(image.RawFormat);
return(!string.IsNullOrEmpty(formatName)
? "." + formatName.ToLower()
: null);
}
}
protected void Page_Load(object sender, EventArgs e)
{
if (!Page.IsPostBack)
{
try
{
if (Request.Url.AbsoluteUri != Request.UrlReferrer.AbsoluteUri)
{
try{
if(Session[SessionLastURL].ToString()=="")
Session[SessionLastURL]=Request.UrlReferrer.AbsoluteUri;
}
catch{
Session.Add(SessionLastURL, Request.UrlReferrer.AbsoluteUri);
}
lblLastLink.Text = Session[SessionLastURL].ToString();
}
}
catch {
}
}
string SignatureFileName="NoName.jpg";
bool bRapportino = false;
try
{
SignatureFileName = this.Request.QueryString["SignatureName"].ToString();
bRapportino = true;
}
catch { }
try
{
String s = this.Request.Form[1].ToString();
SignatureToImage.SignatureToImage sig = new SignatureToImage.SignatureToImage();
sig.Height = 250;
sig.Width = 600;
Bitmap bt = sig.SigJsonToImage(s);
s = sPathFile + SignatureFileName;
ImageFormatConverter format = new ImageFormatConverter();
bt.Save(s, System.Drawing.Imaging.ImageFormat.Jpeg);
if (bRapportino) SalvaRapportino();
}
catch
{
}
}
public void SaveAllImages()
{
//ExStart
//ExFor:ImageData.HasImage
//ExFor:ImageData.ToImage
//ExFor:ImageData.Save(Stream)
//ExSummary:Shows how to save all images from a document to the file system.
Document imgSourceDoc = new Document(MyDir + "Images.docx");
// Shapes with the "HasImage" flag set store and display all the document's images.
IEnumerable <Shape> shapesWithImages =
imgSourceDoc.GetChildNodes(NodeType.Shape, true).Cast <Shape>().Where(s => s.HasImage);
// Go through each shape and save its image.
ImageFormatConverter formatConverter = new ImageFormatConverter();
using (IEnumerator <Shape> enumerator = shapesWithImages.GetEnumerator())
{
int shapeIndex = 0;
while (enumerator.MoveNext())
{
ImageData imageData = enumerator.Current.ImageData;
ImageFormat format = imageData.ToImage().RawFormat;
string fileExtension = formatConverter.ConvertToString(format);
using (FileStream fileStream = File.Create(ArtifactsDir + $"Drawing.SaveAllImages.{++shapeIndex}.{fileExtension}"))
imageData.Save(fileStream);
}
}
//ExEnd
string[] imageFileNames = Directory.GetFiles(ArtifactsDir).Where(s => s.StartsWith(ArtifactsDir + "Drawing.SaveAllImages.")).OrderBy(s => s).ToArray();
List <FileInfo> fileInfos = imageFileNames.Select(s => new FileInfo(s)).ToList();
TestUtil.VerifyImage(2467, 1500, fileInfos[0].FullName);
Assert.AreEqual(".Jpeg", fileInfos[0].Extension);
TestUtil.VerifyImage(400, 400, fileInfos[1].FullName);
Assert.AreEqual(".Png", fileInfos[1].Extension);
TestUtil.VerifyImage(382, 138, fileInfos[2].FullName);
Assert.AreEqual(".Emf", fileInfos[2].Extension);
TestUtil.VerifyImage(1600, 1600, fileInfos[3].FullName);
Assert.AreEqual(".Wmf", fileInfos[3].Extension);
TestUtil.VerifyImage(534, 534, fileInfos[4].FullName);
Assert.AreEqual(".Emf", fileInfos[4].Extension);
TestUtil.VerifyImage(1260, 660, fileInfos[5].FullName);
Assert.AreEqual(".Jpeg", fileInfos[5].Extension);
TestUtil.VerifyImage(1125, 1500, fileInfos[6].FullName);
Assert.AreEqual(".Jpeg", fileInfos[6].Extension);
TestUtil.VerifyImage(1027, 1500, fileInfos[7].FullName);
Assert.AreEqual(".Jpeg", fileInfos[7].Extension);
TestUtil.VerifyImage(1200, 1500, fileInfos[8].FullName);
Assert.AreEqual(".Jpeg", fileInfos[8].Extension);
}
/// <summary>
/// Zapisanie zdjęcia o zadanym formacie i nazwie jako pliku tymczasowego
/// </summary>
/// <param name="image">Zdjęcie do zapisania</param>
/// <param name="imageFormat">Format w jakim zdjęcie zostanie zapisane</param>
/// <param name="name">Nazwa pliku ze zdjęciem do zapisania</param>
/// <returns>Ścieżka do zapisanego zdjęcia</returns>
public static string SaveTemp(this Image image, ImageFormat imageFormat, string name)
{
string extension = new ImageFormatConverter().ConvertToString(imageFormat); //Przekonwertowanie formatu zdjęcia na rozszerzenie w formie łańcucha znaków
string fileName = name + "." + extension; //Utworzenie nazwy pliku na podstawie przekazanej nazwy i otrzymanego roszerzenia
string path = SecurityUtils.TemplateDirPath() + fileName; //Utworzenie ścieżki w jakiej zostanie zapisany plik, na podstawie pobranej ścieżki plików tymczasowych i otrzymanej nazwy pliku
File.WriteAllBytes(path, image.GetBuffer(imageFormat)); //Pobranie tablicy bajtów dla zadanego zdjęcia i zapisanie zdjęcia w zadanej lokalizacji
return(path); //Zwrócenie ścieżki do zdjęcia
}
public BindingImage(int num, string name, Image image)
{
ColorDepth = Image.GetPixelFormatSize(image.PixelFormat);
Number = num;
Name = name;
Format = new ImageFormatConverter().ConvertToString(image.RawFormat);
Height = image.Height;
Width = image.Width;
HorisontalResolution = image.HorizontalResolution;
VerticalResolution = image.VerticalResolution;
CompressionType = GetCompressionType(image);
}
protected override void Load(ContainerBuilder builder)
{
var imageFormatConverter = new ImageFormatConverter();
var baseTransformerSettings = new BaseTransformerSettings
{
MainTransformerFormat = (ImageFormat)imageFormatConverter
.ConvertFromString(_configuration["FileProcessing:TargetTransformerFormat"])
};
builder.RegisterType <UserListsService>()
.As <IUserListsService>();
builder.RegisterType <DeviceService>()
.As <IDeviceService>();
builder.RegisterType <SeriesService>()
.As <ISeriesService>();
builder.RegisterType <AuthorService>()
.As <IAuthorService>();
builder.RegisterType <BookRepository>()
.As <IBookRepository>();
builder.RegisterType <EditionRepository>()
.As <IEditionRepository>();
builder.RegisterType <FilterService>()
.As <IFilterService>();
builder.RegisterType <BookService>()
.As <IBookService>();
builder.RegisterType <EditionService>()
.As <IEditionService>()
.WithParameters(new Parameter[]
{
new TypedParameter(typeof(BaseTransformerSettings), baseTransformerSettings),
new TypedParameter(typeof(StorageSettings), new StorageSettings
{
StoragePath = _configuration["FileProcessing:SaveEditionPath"]
})
});
builder.RegisterType <CoverService>()
.As <ICoverService>()
.WithParameters(new Parameter[]
{
new TypedParameter(typeof(BaseTransformerSettings), baseTransformerSettings),
new TypedParameter(typeof(StorageSettings), new StorageSettings
{
StoragePath = _configuration["FileProcessing:SaveCoverPath"]
})
});
}
public void ParserImageTest()
{
int pageNumber = 1;
int width = 460;
int height = 520;
int dpiX = 460;
int dpiY = 520;
Image i = P.Render(pageNumber, width, height, dpiX, dpiY);
string imageType = new ImageFormatConverter().ConvertToString(i.RawFormat);
Console.WriteLine("Image type: " + imageType);
Assert.That(i.RawFormat.Equals(ImageFormat.MemoryBmp));
i.Dispose();
}
public static MagickImage ConvertToMagickImage(Bitmap bitmap, string format = "PNG")
{
MagickImage result;
ImageFormatConverter formatConv = new ImageFormatConverter();
ImageFormat imageFormat = (ImageFormat)formatConv.ConvertFromString(format);
using (MemoryStream memoryStream = new MemoryStream())
{
bitmap.Save(memoryStream, imageFormat);
memoryStream.Position = 0;
result = new MagickImage(memoryStream, new MagickReadSettings()
{
Format = MagickFormat.Png00
});
}
return(result);
}
/// <summary>
/// Saves image with new name and selected Image Format. Returns saved file path and isUploaded
/// </summary>
/// <param name="newImage">Image to save</param>
/// <param name="fullFolderPath">Full path of folder to save. For example ~/Content/Images/ExampleFolder</param>
/// <param name="format">Format to be saved</param>
/// <param name="isUploaded">out Is save successfull?</param>
/// <returns></returns>
public static string ImageUpload(Image newImage, string fullFolderPath, ImageFormat format, out bool isUploaded)
{
try
{
ImageFormatConverter imgConverter = new ImageFormatConverter();
string fileName = Guid.NewGuid().ToString().Replace("-", string.Empty).ToLower();
string extension = imgConverter.ConvertToString(format);
string path = string.Format("{0}/{1}.{2}", fullFolderPath, fileName, extension);
newImage.Save(HttpContext.Current.Server.MapPath(path));
isUploaded = true;
return(path);
}
catch (Exception ex)
{
isUploaded = false;
return(ex.Message);
}
}
private void SetFrameBuffer(NvGpuVmm Vmm, int FbIndex)
{
long VA = MakeInt64From2xInt32(NvGpuEngine3dReg.FrameBufferNAddress + FbIndex * 0x10);
int Format = ReadRegister(NvGpuEngine3dReg.FrameBufferNFormat + FbIndex * 0x10);
if (VA == 0 || Format == 0)
{
Gpu.Renderer.FrameBuffer.UnbindColor(FbIndex);
return;
}
long Key = Vmm.GetPhysicalAddress(VA);
FrameBuffers.Add(Key);
int Width = ReadRegister(NvGpuEngine3dReg.FrameBufferNWidth + FbIndex * 0x10);
int Height = ReadRegister(NvGpuEngine3dReg.FrameBufferNHeight + FbIndex * 0x10);
float TX = ReadRegisterFloat(NvGpuEngine3dReg.ViewportNTranslateX + FbIndex * 8);
float TY = ReadRegisterFloat(NvGpuEngine3dReg.ViewportNTranslateY + FbIndex * 8);
float SX = ReadRegisterFloat(NvGpuEngine3dReg.ViewportNScaleX + FbIndex * 8);
float SY = ReadRegisterFloat(NvGpuEngine3dReg.ViewportNScaleY + FbIndex * 8);
int VpX = (int)MathF.Max(0, TX - MathF.Abs(SX));
int VpY = (int)MathF.Max(0, TY - MathF.Abs(SY));
int VpW = (int)(TX + MathF.Abs(SX)) - VpX;
int VpH = (int)(TY + MathF.Abs(SY)) - VpY;
GalImageFormat ImageFormat = ImageFormatConverter.ConvertFrameBuffer((GalFrameBufferFormat)Format);
GalImage Image = new GalImage(Width, Height, ImageFormat);
long Size = TextureHelper.GetTextureSize(Image);
Gpu.Renderer.Texture.CreateFb(Key, Size, Image);
Gpu.Renderer.FrameBuffer.BindColor(Key, FbIndex);
Gpu.Renderer.FrameBuffer.SetViewport(VpX, VpY, VpW, VpH);
}
public void SaveAllImages()
{
//ExStart
//ExFor:ImageData.HasImage
//ExFor:ImageData.ToImage
//ExFor:ImageData.Save(Stream)
//ExSummary:Shows how to save all the images from a document to the file system.
Document imgSourceDoc = new Document(MyDir + "Image.SampleImages.doc");
// Images are stored as shapes
// Get into the document's shape collection to verify that it contains 6 images
List <Shape> shapes = imgSourceDoc.GetChildNodes(NodeType.Shape, true).Cast <Shape>().ToList();
Assert.AreEqual(6, shapes.Count);
// We will use an ImageFormatConverter to determine an image's file extension
ImageFormatConverter formatConverter = new ImageFormatConverter();
// Go over all of the document's shapes
// If a shape contains image data, save the image in the local file system
for (int i = 0; i < shapes.Count; i++)
{
ImageData imageData = shapes[i].ImageData;
if (imageData.HasImage)
{
ImageFormat format = imageData.ToImage().RawFormat;
string fileExtension = formatConverter.ConvertToString(format);
using (FileStream fileStream = File.Create(ArtifactsDir + $"Image from shape {i}.{fileExtension}"))
{
imageData.Save(fileStream);
}
}
}
//ExEnd
}
private void tsmiSaveImage_Click(object sender, EventArgs e)
{
var node = lbChat.SelectedItem as ChatNode;
if (node?.image != null)
{
try
{
string ext = new ImageFormatConverter().ConvertToString(node.image.RawFormat)?.ToLower();
var fopd = new SaveFileDialog();
fopd.Title = "Save image as..";
fopd.Filter = $"Image Files (*.{ext})|*.{ext}";
fopd.DefaultExt = ext;
var res = fopd.ShowDialog();
if (res == DialogResult.OK)
{
node.image.Save(fopd.FileName, node.image.RawFormat);
}
}
catch { }
}
}
private void button1_Click_1(object sender, EventArgs e)
{
this.Visible = false;
//get the User-Information
string Name = textBox1.Text;
string Comment = textBox2.Text;
MemoryStream ms = new MemoryStream();
//get the Image Format
byte[] ProfilePic;
if (profilePic)
{
ImageFormatConverter mf = new ImageFormatConverter();
pictureBox1.Image.Save(ms, ImageFormat.Jpeg);
ProfilePic = ms.ToArray();
}
else
{
ProfilePic = new byte[0];
}
MainMenu mn = new MainMenu(Name, Comment, ProfilePic);
mn.Show();
}
public ProfileModule(PeopleContext people)
{
this.RequiresAuthentication();
_people = people;
Get["/profile"] = parameters =>
{
// call when user visit it's own profile
var identity = Context.CurrentUser as FloreamIdentity;
var user = _people.People.FirstOrDefault(p => p.AdUser == identity.UserName);
return(View["profile", user]);
};
Post["/profile/upload"] = parameters =>
{
var file = Request.Files.FirstOrDefault();
if (file == null)
{
return(new Response().WithStatusCode(HttpStatusCode.BadRequest));
}
var identity = Context.CurrentUser as FloreamIdentity;
var imageType = file.ContentType.Split('/')[1];
var imageHeight = int.Parse(ConfigurationManager.AppSettings.Get("profile-image-height"));
var imageWidth = int.Parse(ConfigurationManager.AppSettings.Get("profile-image-width"));
var memStream = new MemoryStream();
var img = Image.FromStream(file.Value);
if (img.Height > imageHeight || img.Width > imageWidth)
{
// Resize the image
var bmp = ScaleImage(img, imageWidth, imageHeight);
// Save the resized image to a stream
var imageFormatConverter = new ImageFormatConverter();
var imageObj = imageFormatConverter.ConvertFromString(imageType);
if (imageObj != null)
{
bmp.Save(memStream, (ImageFormat)imageObj);
}
}
else
{
img.Save(memStream, img.RawFormat);
}
var array = memStream.ToArray();
// Update the user's profile
var user = _people.People.FirstOrDefault(p => p.AdUser == identity.UserName);
if (user != null)
{
user.PictureExtension = imageType;
user.Picture = array;
_people.SaveChanges();
}
return(Response.AsText(HtmlHelper.GetProfileImage(array, imageType)));
};
}
