// Constructor, which saves away all of the important information.
// We assume that the lock on the "graphics" object is held by the caller.
internal GraphicsContainer(Graphics graphics)
{
// Push this container onto the stack.
this.graphics = graphics;
next = graphics.stackTop;
graphics.stackTop = this;
// Save the graphics state information.
clip = graphics.Clip;
if(clip != null)
{
clip = clip.Clone();
}
compositingMode = graphics.CompositingMode;
compositingQuality = graphics.CompositingQuality;
interpolationMode = graphics.InterpolationMode;
pageScale = graphics.PageScale;
pageUnit = graphics.PageUnit;
pixelOffsetMode = graphics.PixelOffsetMode;
renderingOrigin = graphics.RenderingOrigin;
smoothingMode = graphics.SmoothingMode;
textContrast = graphics.TextContrast;
textRenderingHint = graphics.TextRenderingHint;
if (graphics.transform == null)
{
transform = null;
}
else
{
transform = Matrix.Clone(graphics.transform);
}
}
public GraphicsQualityManager(Graphics g, bool setHighQuality = true)
{
this.g = g;
previousCompositingQuality = g.CompositingQuality;
previousInterpolationMode = g.InterpolationMode;
previousSmoothingMode = g.SmoothingMode;
if (setHighQuality)
{
SetHighQuality();
}
}
// Constructor.
protected ToolkitGraphicsBase(IToolkit toolkit)
{
this.toolkit = toolkit;
clip = null;
compositingMode = CompositingMode.SourceOver;
compositingQuality = CompositingQuality.Default;
interpolationMode = InterpolationMode.Default;
pixelOffsetMode = PixelOffsetMode.Default;
renderingOrigin = new Point(0, 0);
smoothingMode = SmoothingMode.Default;
textContrast = 4;
textRenderingHint = TextRenderingHint.SystemDefault;
dirtyFlags = DirtyFlags.All;
}
public void 缩放图像Test()
{
Image 图像 = null; // TODO: 初始化为适当的值
int 指定宽度 = 0; // TODO: 初始化为适当的值
int 指定高度 = 0; // TODO: 初始化为适当的值
缩放方式 缩放方式 = new 缩放方式(); // TODO: 初始化为适当的值
InterpolationMode 插值算法 = new InterpolationMode(); // TODO: 初始化为适当的值
SmoothingMode 平滑模式 = new SmoothingMode(); // TODO: 初始化为适当的值
CompositingQuality 合成质量 = new CompositingQuality(); // TODO: 初始化为适当的值
Bitmap expected = null; // TODO: 初始化为适当的值
Bitmap actual;
actual = Drawing处理函数.缩放图像(图像, 指定宽度, 指定高度, 缩放方式, 插值算法, 平滑模式, 合成质量);
Assert.AreEqual(expected, actual);
Assert.Inconclusive("验证此测试方法的正确性。");
}
private static Image Resize(Image originalImage, int newWidth, int newHeight, CompositingQuality compositingQuality, SmoothingMode smoothingMode, InterpolationMode interpolationMode, PixelOffsetMode pixelOffsetmode)
{
Image result = new Bitmap(newWidth, newHeight);
using (var graphic = Graphics.FromImage(result))
{
graphic.CompositingQuality = compositingQuality;
graphic.SmoothingMode = smoothingMode;
graphic.InterpolationMode = interpolationMode;
graphic.PixelOffsetMode = pixelOffsetmode;
Rectangle rectangle = new Rectangle(0, 0, newWidth, newHeight);
graphic.DrawImage(originalImage, rectangle);
return result;
}
}
/// <summary>
/// Initiates the Painting of the item
/// </summary>
/// <param name="e"></param>
public override void Paint(ItemPaintArgs e)
{
Graphics g = e.Graphics;
// Lets have it draw as best it can
CompositingQuality comp = g.CompositingQuality;
g.CompositingQuality = CompositingQuality.HighQuality;
// Draw the border and content area
DrawBorder(g);
DrawContent(g);
// Set our CompostingQuality back
g.CompositingQuality = comp;
}
/// <summary>
/// 重设Bitmap图片大小
/// </summary>
/// <param name="bm"></param>
/// <param name="w">宽</param>
/// <param name="h">高</param>
/// <param name="interpolationMode"></param>
/// <param name="smoothingMode"></param>
/// <param name="compositingQuality"></param>
/// <returns></returns>
public static Bitmap SetSize(this Bitmap bm, int w, int h,
InterpolationMode interpolationMode = InterpolationMode.HighQualityBicubic,
SmoothingMode smoothingMode = SmoothingMode.HighQuality,
CompositingQuality compositingQuality = CompositingQuality.HighSpeed
)
{
int nowWidth = w;
int nowHeight = h;
Bitmap newbm = new Bitmap(nowWidth, nowHeight);//新建一个放大后大小的图片
Graphics g = Graphics.FromImage(newbm);
g.InterpolationMode = interpolationMode;
g.SmoothingMode = smoothingMode;
g.CompositingQuality = compositingQuality;
g.DrawImage(bm, new Rectangle(0, 0, nowWidth, nowHeight), new Rectangle(0, 0, bm.Width, bm.Height), GraphicsUnit.Pixel);
g.Dispose();
return(newbm);
}
/// <summary>
/// Affichage
/// </summary>
/// <param name="g"></param>
/// <param name="maintenant"></param>
/// <param name="tailleEcran"></param>
/// <param name="couleur"></param>
public override void AfficheGDI(Graphics g, Temps maintenant, Rectangle tailleEcran, Color couleur)
{
#if TRACER
RenderStart(CHRONO_TYPE.RENDER);
#endif
g.Clear(getCouleurOpaqueAvecAlpha(couleur, ALPHA));
SmoothingMode s = g.SmoothingMode;
g.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.HighSpeed;
CompositingQuality q = g.CompositingQuality;
g.CompositingQuality = CompositingQuality.HighSpeed;
if (AFFICHE_FOND)
{
g.DrawImage(_fond, 0, HAUTEUR - HAUTEUR_TOUFFE * 4, LARGEUR, HAUTEUR_TOUFFE * 4);
}
g.DrawImage(_soleil, _xSoleil - TAILLE_SOLEIL / 2, _ySoleil - TAILLE_SOLEIL / 2, TAILLE_SOLEIL, TAILLE_SOLEIL);
foreach (Herbe h in _herbes)
{
h.Affiche(g, _vent);
}
float dx = CENTREX - _xSoleil;
float dy = CENTREY - _ySoleil;
foreach (Flare f in _flares)
{
DrawBitmapNuance(g, f._bmp, _xSoleil + dx * f._distance - f._taille / 2,
_ySoleil + dy * f._distance - f._taille / 2,
f._taille,
f._taille, getCouleurAvecAlpha(couleur, f._alpha));
}
g.SmoothingMode = s;
g.CompositingQuality = q;
#if TRACER
RenderStop(CHRONO_TYPE.RENDER);
#endif
}
/// <summary>
/// sets The quality of the drawing to the given graphics.
/// </summary>
/// <param name="e">The Graphics to set the quality</param>
/// <param name="smoothingMode">Gets or sets the rendering quality for this System.Drawing.Graphics.</param>
/// <param name="textRenderingHint"></param>
/// <param name="pixelOffsetMode">Gets or set a value specifying how pixels are offset during rendering of this </param>
/// <param name="interpolationMode">Gets or sets the interpolation mode associated with this System.Drawing.Graphics.</param>
/// <param name="compositingQuality">Gets or sets the rendering quality of composited images drawn to this System.Drawing.Graphics.</param>
public void SetQuality(Graphics e,
SmoothingMode smoothingMode = SmoothingMode.Default,
TextRenderingHint textRenderingHint = TextRenderingHint.ClearTypeGridFit,
PixelOffsetMode pixelOffsetMode = PixelOffsetMode.Default,
InterpolationMode interpolationMode = InterpolationMode.Default,
CompositingQuality compositingQuality = CompositingQuality.Default)
{
try
{
e.SmoothingMode = smoothingMode;
e.PixelOffsetMode = pixelOffsetMode;
e.InterpolationMode = interpolationMode;
e.CompositingQuality = compositingQuality;
e.TextRenderingHint = textRenderingHint;
}
catch (Exception ex)
{
MessageBox.Show(ex.StackTrace);
}
}
public static Bitmap GdiResize(Image photo, int width, int height,
InterpolationMode interpolationMode = InterpolationMode.HighQualityBicubic,
SmoothingMode smoothingMode = SmoothingMode.HighQuality,
PixelOffsetMode pixelMode = PixelOffsetMode.HighQuality,
CompositingQuality compositingQuality = CompositingQuality.HighQuality,
CompositingMode compositingMode = CompositingMode.SourceOver
)
{
var resized = new Bitmap(width, height);
using (var graphics = Graphics.FromImage(resized)) {
graphics.CompositingQuality = compositingQuality;
graphics.InterpolationMode = interpolationMode;
graphics.CompositingMode = compositingMode;
graphics.SmoothingMode = smoothingMode;
graphics.PixelOffsetMode = pixelMode;
graphics.DrawImage(photo, 0, 0, width, height);
}
return resized;
}
/// <summary>
/// Resizes the image.
/// </summary>
/// <param name="self">The self.</param>
/// <param name="newSize">The new size.</param>
/// <param name="compositingQuality">The compositing quality.</param>
/// <param name="interpolationMode">The interpolation mode.</param>
/// <param name="smoothingMode">The smoothing mode.</param>
/// <returns>A resized bitmap.</returns>
public static Bitmap Resize(
this Image self,
Size newSize,
CompositingQuality compositingQuality = CompositingQuality.Default,
InterpolationMode interpolationMode = InterpolationMode.Default,
SmoothingMode smoothingMode = SmoothingMode.Default)
{
var result = new Bitmap(newSize.Width, newSize.Height);
using (Graphics graphics = Graphics.FromImage(result))
{
graphics.CompositingQuality = compositingQuality;
graphics.InterpolationMode = interpolationMode;
graphics.SmoothingMode = smoothingMode;
graphics.DrawImage(self, new Rectangle(0, 0, result.Width, result.Height));
}
return(result);
}
public static Bitmap GdiResize(Image photo, int width, int height,
InterpolationMode interpolationMode = InterpolationMode.HighQualityBicubic,
SmoothingMode smoothingMode = SmoothingMode.HighQuality,
PixelOffsetMode pixelMode = PixelOffsetMode.HighQuality,
CompositingQuality compositingQuality = CompositingQuality.HighQuality,
CompositingMode compositingMode = CompositingMode.SourceOver
)
{
var resized = new Bitmap(width, height);
using (var graphics = Graphics.FromImage(resized)) {
graphics.CompositingQuality = compositingQuality;
graphics.InterpolationMode = interpolationMode;
graphics.CompositingMode = compositingMode;
graphics.SmoothingMode = smoothingMode;
graphics.PixelOffsetMode = pixelMode;
graphics.DrawImage(photo, 0, 0, width, height);
}
return(resized);
}
public static Stream Resize(int width, Stream imageStream, CompositingQuality compositingQuality, SmoothingMode smoothingMode, InterpolationMode interpolationMode)
{
var image = Image.FromStream(imageStream);
var thumbnailSize = width;
int newWidth, newHeight;
if (image.Width > image.Height)
{
newWidth = thumbnailSize;
newHeight = image.Height * thumbnailSize / image.Width;
}
else
{
newWidth = image.Width * thumbnailSize / image.Height;
newHeight = thumbnailSize;
}
var bitmap = new Bitmap(newWidth, newHeight);
var graphic = Graphics.FromImage(bitmap);
graphic.CompositingQuality = compositingQuality;
graphic.SmoothingMode = smoothingMode;
graphic.InterpolationMode = interpolationMode;
var rectangle = new Rectangle(0, 0, newWidth, newHeight);
graphic.DrawImage(image, rectangle);
var resizedStream = new MemoryStream();
bitmap.Save(resizedStream, ImageFormat.Png);
graphic.Dispose();
bitmap.Dispose();
image.Dispose();
return(resizedStream);
}
public static Metafile CreateMetafile(
this BitmapSource bitmap,
double horizontalScale = 1.0,
double verticalScale = 1.0,
EmfType emf = EmfType.EmfOnly,
SmoothingMode smoothingMode = SmoothingMode.HighQuality,
InterpolationMode interpolationMode = InterpolationMode.HighQualityBicubic,
PixelOffsetMode pixelOffsetMode = PixelOffsetMode.HighQuality,
CompositingQuality compositingQuality = CompositingQuality.HighQuality)
{
var mf = (Metafile)null;
using (System.Drawing.Graphics cx = System.Drawing.Graphics.FromHwndInternal(IntPtr.Zero))
{
mf = new Metafile(new MemoryStream(), cx.GetHdc(), emf);
using (var g = System.Drawing.Graphics.FromImage(mf))
{
var img = bitmap.ToBitmap();
g.SmoothingMode = smoothingMode;
g.InterpolationMode = interpolationMode;
g.PixelOffsetMode = pixelOffsetMode;
g.CompositingQuality = compositingQuality;
var rect =
new System.Drawing.RectangleF(
0,
0,
img.PhysicalDimension.Width * (float)horizontalScale,
img.PhysicalDimension.Height * (float)verticalScale);
g.DrawImage(img, rect);
}
}
return mf;
}
public static byte[] ReduceImageSize(byte[] inputImage, CompositingQuality compositingQuality = CompositingQuality.HighQuality, SmoothingMode smoothingMode = SmoothingMode.HighQuality, InterpolationMode interpolationMode = InterpolationMode.High)
{
var outputImage = Array.Empty <byte>();
if (Debugger.IsAttached && (inputImage is null || inputImage.Length == 0))
{
Debugger.Break();
}
try
{
var image = Image.FromStream(new MemoryStream(inputImage));
var desiredWidth = image.Width;
var desiredHeight = image.Height;
var bmp = new Bitmap(desiredWidth, desiredHeight);
using var grfx = Graphics.FromImage(bmp);
grfx.CompositingQuality = compositingQuality;
grfx.SmoothingMode = smoothingMode;
grfx.InterpolationMode = interpolationMode;
var rectangle = new Rectangle(0, 0, desiredWidth, desiredHeight);
grfx.DrawImage(image, rectangle);
// make a memory stream to work with the image bytes
using var imageStream = new MemoryStream();
bmp.Save(imageStream, ImageFormat.Jpeg);
outputImage = imageStream.ToArray();
bmp.Dispose();
image.Dispose();
}
catch
{
//return null when the input is an invalid image
}
return(outputImage);
}
public static Image ReDraw(this Image main, int w, int h,
CompositingQuality quality = CompositingQuality.Default, //linear?
SmoothingMode smoothing_mode = SmoothingMode.None,
InterpolationMode ip_mode = InterpolationMode.NearestNeighbor)
{
//size
double dbl = (double)main.Width / (double)main.Height;
//preserve size ratio
if ((int)((double)h * dbl) <= w)
{
w = (int)((double)h * dbl);
}
else
{
h = (int)((double)w / dbl);
}
//draw
Image newImage = new System.Drawing.Bitmap(w, h);
using (Graphics gfx = Graphics.FromImage(newImage))
{
gfx.CompositingQuality = quality;
gfx.SmoothingMode = smoothing_mode;
gfx.InterpolationMode = ip_mode;
gfx.PixelOffsetMode = System.Drawing.Drawing2D.PixelOffsetMode.HighQuality;
gfx.Clear(Color.Transparent);
gfx.DrawImage(main,
new System.Drawing.Rectangle(0, 0, w, h),
new System.Drawing.Rectangle(0, 0, main.Width, main.Height),
System.Drawing.GraphicsUnit.Pixel);
}
return(newImage);
}
protected override void OnPaint(PaintEventArgs e)
{
Rectangle imageBounds = Rectangle.Empty;
imageBounds.Size = _increaseSize ? _maxSize.Size : _minSize.Size;
Image img = _increaseSize ? Properties.Resources.GreenCircle_27x27 : Properties.Resources.TanCircle_27x27;
imageBounds.Location = new Point(
(ClientRectangle.Width - imageBounds.Width) / 2,
(ClientRectangle.Height - imageBounds.Height) / 2);
CompositingQuality compositingQuality = e.Graphics.CompositingQuality;
InterpolationMode interpolationMode = e.Graphics.InterpolationMode;
SmoothingMode smoothingMode = e.Graphics.SmoothingMode;
e.Graphics.CompositingQuality = CompositingQuality.HighQuality;
e.Graphics.InterpolationMode = InterpolationMode.HighQualityBicubic;
e.Graphics.SmoothingMode = SmoothingMode.HighQuality;
e.Graphics.DrawImage(img, imageBounds);
e.Graphics.CompositingQuality = compositingQuality;
e.Graphics.InterpolationMode = interpolationMode;
e.Graphics.SmoothingMode = smoothingMode;
}
/// <summary>
/// Affiche l'objet
/// </summary>
/// <param name="g"></param>
/// <param name="maintenant"></param>
/// <param name="tailleEcran"></param>
/// <param name="couleur"></param>
///
#if USE_GDI_PLUS_FOR_2D
public override void AfficheGDI(Graphics g, Temps maintenant, Rectangle tailleEcran, Color couleur)
{
#if TRACER
RenderStart(CHRONO_TYPE.RENDER);
#endif
// Mise a jour de la palette de couleurs
updatePalette(couleur);
// Construire la bitmap
updateFrame();
SmoothingMode q = g.SmoothingMode;
CompositingQuality c = g.CompositingQuality;
InterpolationMode m = g.InterpolationMode;
g.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.HighSpeed;
g.CompositingQuality = CompositingQuality.HighSpeed;
g.InterpolationMode = InterpolationMode.NearestNeighbor;
g.DrawImage(_bmp, 0, 0, tailleEcran.Width, tailleEcran.Height);
g.SmoothingMode = q;
g.CompositingQuality = c;
g.InterpolationMode = m;
#if TRACER
RenderStop(CHRONO_TYPE.RENDER);
#endif
}
internal GraphicsState(Graphics graphics, Matrix matrix, bool resetState)
{
_compositingMode = graphics.CompositingMode;
_compositingQuality = graphics.CompositingQuality;
_clip = graphics.ScaledClip;
_baseClip = graphics.NativeObject.getClip();
_interpolationMode = graphics.InterpolationMode;
_pageScale = graphics.PageScale;
_pageUnit = graphics.PageUnit;
_pixelOffsetMode = graphics.PixelOffsetMode;
// FIXME: render orign is not implemented yet
//_renderingOrigin = new Point( g.RenderingOrigin.X, g.RenderingOrigin.Y );
_smoothingMode = graphics.SmoothingMode;
_transform = graphics.Transform;
_baseTransform = graphics.BaseTransform;
_textContrast = graphics.TextContrast;
_textRenderingHint = graphics.TextRenderingHint;
if (resetState)
ResetState(graphics, matrix);
}
/// <summary>
/// Initiates the Painting of the item
/// </summary>
/// <param name="e"></param>
public override void Paint(ItemPaintArgs e)
{
Graphics g = e.Graphics;
// Lets have it draw as best it can
CompositingQuality comp = g.CompositingQuality;
g.CompositingQuality = CompositingQuality.HighQuality;
// The color scheme used is based on whether
// the CheckBox is checked or not
int scheme = _CheckBox.Checked ? 0 : 1;
// Draw the border and content area
DrawBorder(e, scheme);
DrawContent(e, scheme);
// Set our CompostingQuality back
g.CompositingQuality = comp;
}
/// <summary>
/// Private method that takes an image file name and rescales it so that it's largest edge is equal
/// to the one supplied.
/// </summary>
private void CreateThumbnailForImage(string thumbnailFilePath, string originalFilePath, int maxEdge, CompositingQuality compositingQuality)
{
// Load the existing image.
Image original = Image.FromFile(originalFilePath);
// The math for calculating the correct sizes.
float aspect = (float)original.Width / (float)original.Height;
int width = (original.Width > original.Height) ? maxEdge : (int)(maxEdge * aspect);
int height = (original.Height > original.Width) ? maxEdge : (int)(maxEdge / aspect);
// Code to rescale the image.
Bitmap thumbnail = new Bitmap(width, height);
using (Graphics graphics = Graphics.FromImage(thumbnail))
{
graphics.CompositingQuality = compositingQuality;
graphics.InterpolationMode = InterpolationMode.HighQualityBicubic;
graphics.CompositingMode = CompositingMode.SourceCopy;
graphics.DrawImage(original, 0, 0, width, height);
thumbnail.Save(thumbnailFilePath, ImageFormat.Jpeg);
}
}
public void setCompositeQuality(CompositingQuality compositeQuality)
{
this.compositeQuality = compositeQuality;
}
private void PostBack()
{
string cPath = curPath + "\\";
try
{
if (Request.Form["txtFolderName"] != null)
{
#region Создать папку
if (Request.Form["txtFolderName"].Trim().Length > 0)
{
if(!Directory.Exists((cPath + Request.Form["txtFolderName"])))
{
Directory.CreateDirectory((cPath + Request.Form["txtFolderName"]));
}
}
#endregion
}
else if (Request.Files.Count > 0)
{
if (Request.Form["hReplace"] == null)
{
#region Загрузка архива
HttpPostedFile pf = Request.Files[0];
if (pf.FileName.Length > 0)
{
using (ZipInputStream s = new ZipInputStream(pf.InputStream))
{
ZipEntry theEntry;
while ((theEntry = s.GetNextEntry()) != null)
{
string directoryName = Request.MapPath(sCurPath + "/" + Path.GetDirectoryName(theEntry.Name));
string fileName = Path.GetFileName(theEntry.Name);
//Hashtable ht = new Hashtable();
//ht["name"] = theEntry.Name;
//ht["directoryName"] = directoryName;
//ht["fileName"] = fileName;
//Log.Write("entry", ht);
//continue;
// create directory
if (directoryName.Length > 0)
{
Directory.CreateDirectory(directoryName);
}
if (fileName != String.Empty)
{
using (FileStream streamWriter = File.Create(directoryName + "\\" + fileName))
{
int size = 2048;
byte[] data = new byte[2048];
while (true)
{
size = s.Read(data, 0, data.Length);
if (size > 0)
{
streamWriter.Write(data, 0, size);
}
else
{
break;
}
}
}
}
}
}
}
#endregion
}
else
{
#region Загрузка файла
HttpPostedFile pf = Request.Files[0];
if (pf.FileName.Length > 0)
{
//получение имени файла
string[] af = pf.FileName.Split('\\');
string file = af[af.Length - 1];
//проверка типа файла
bool wrongType = false;
if (sFilter != "*")
{
wrongType = true;
string[] arFilter = sFilter.ToLower().Split(';');
string ext = this.GetExtention(file).ToLower();
foreach (string fe in arFilter)
if (ext == fe)
{
wrongType = false;
break;
}
}
if (!wrongType)
{
//создание уникального имени
if (Request.Form["hReplace"] != "1")
{
int i = 0;
while (File.Exists(cPath + file))
{
i++;
file = i + file;
}
}
//сохранение
pf.SaveAs(cPath + file);
}
else
{
throw new Exception("Wrong file type.");
}
}
#endregion
}
}
else if (Request.Form["txtNewName"] != null
&& Request.Form["txtOldName"] != null
&& Request.Form["txtPreviewW"] != null
&& Request.Form["txtPreviewH"] != null)
{
#region Сохранение с новым размером
if (Request.Form["txtNewName"].Trim().Length > 0
&& Request.Form["txtOldName"].Trim().Length > 0
&& Request.Form["txtPreviewW"].Trim().Length > 0
&& Request.Form["txtPreviewH"].Trim().Length > 0
)
{
ImageFormat imageFormat = ImageFormat.Png;
string sOldFile = Request.Form["txtOldName"].Trim();
string sNewFile = Request.Form["txtNewName"].Trim();
int nWidth = int.Parse(Request.Form["txtPreviewW"]);
int nHeigth = int.Parse(Request.Form["txtPreviewH"]);
string ext = GetExtention(sNewFile).ToLower();
switch (ext)
{
case "gif":
imageFormat = ImageFormat.Gif;
break;
case "jpg":
case "jpeg":
imageFormat = ImageFormat.Jpeg;
break;
case "png":
imageFormat = ImageFormat.Png;
break;
case "bmp":
imageFormat = ImageFormat.Bmp;
break;
default:
sNewFile += ".png";
break;
}
Bitmap bitmap = null;
Image image = null;
Graphics gr = null;
SmoothingMode sm = (SmoothingMode)Enum.Parse(typeof(SmoothingMode), Request.Form["cmbSmoothingMode"], true);
CompositingQuality cq = (CompositingQuality)Enum.Parse(typeof(CompositingQuality), Request.Form["cmbCompositingQuality"], true);
try
{
bitmap = new Bitmap(cPath + sOldFile);
image = new Bitmap(nWidth, nHeigth);
gr = Graphics.FromImage(image);
gr.SmoothingMode = sm;
gr.CompositingQuality = cq;
gr.DrawImage(bitmap, 0, 0, nWidth, nHeigth);
bitmap.Dispose();
gr.Dispose();
while (File.Exists(cPath + sNewFile))
{
sNewFile = "0" + sNewFile;
}
image.Save(cPath + sNewFile, imageFormat);
}
finally
{
if (gr != null)
gr.Dispose();
if (bitmap != null)
bitmap.Dispose();
if (image != null)
image.Dispose();
}
}
#endregion
}
else if (Request.Form["txtFileName"] != null)
{
#region Создание файла
string file = Request.Form["txtFileName"].Trim();
if (Request.Form["cmbFileType"] == "*")
{
if(Request.Form["hReplace"]!="1")
{
int i=0;
while (File.Exists(cPath + file))
{
i++;
file = i + file;
}
}
File.Create(cPath + file).Close();
}
else
{
string content = "";
string cext = Request.Form["cmbFileType"].Split('-')[0];
file = file + "." + cext;
if(Request.Form["hReplace"]!="1")
{
int i=0;
while (File.Exists(cPath + file))
{
i++;
file = i + file;
}
}
DataRow[] rows = tbTemplates.Select("id like '*;" + Request.Form["cmbFileType"] + ";*'");
if (rows.Length > 0)
{
content = rows[0]["content"].ToString();
}
Encoding enc = Encoding.Default;
if (IsXmlFile(file))
enc = Encoding.UTF8;
StreamWriter sw = null;
try
{
sw = new StreamWriter(cPath + file, false, enc);
sw.Write(content);
}
finally
{
if (sw != null)
sw.Close();
}
}
#endregion
}
else if (Request.Form["act"] == "delete")
{
#region Удаление файла
string file = Request.MapPath(Request.Form["hFile"]).ToLower();
if (File.Exists(file))
{
bool allowed = false;
DataTable tb = Config.GetConfigTable("delete.config","folder");
for(int i=0;i<tb.Rows.Count;i++)
{
string folder = Request.MapPath(tb.Rows[i]["name"].ToString()).ToLower();
if(file.StartsWith(folder))
{
allowed = tb.Rows[i]["allow"].ToString()=="1";
if(!allowed)
{
break;
}
}
}
if(allowed)
{
File.Delete(file);
}
else
{
throw new UnauthorizedAccessException("Удаление запрещено!");
}
}
#endregion
}
else if (Request.Form["act"] == "deletefolder")
{
#region Удаление папки
string folder = Request.MapPath(Request.Form["hFolder"]);
if (Directory.Exists(folder))
{
if(Directory.GetFileSystemEntries(folder).Length>0)
{
Directory.Delete(folder);
}
}
#endregion
}
Response.Redirect(Sota.Web.SimpleSite.Path.Full);
}
catch (Exception ex)
{
sError = ex.Message;
}
}
/// <summary><inheritdoc cref="Resize(Bitmap, int, int, int, int, CompositingMode, CompositingQuality, InterpolationMode, SmoothingMode, PixelOffsetMode, WrapMode)"/> Final result represents the <see cref="Bitmap"/> upscaled to the largest relative resolution, cropped to fit. </summary>
/// <param name="Bmp">The BMP.</param>
/// <param name="RequestedWidth">The requested width.</param>
/// <param name="RequestedHeight">The requested height.</param>
/// <param name="Format">The resultant image format</param>
/// <param name="CompositingMode">The compositing mode.</param>
/// <param name="CompositingQuality">The compositing quality.</param>
/// <param name="InterpolationMode">The interpolation mode.</param>
/// <param name="SmoothingMode">The smoothing mode.</param>
/// <param name="PixelOffsetMode">The pixel offset mode.</param>
/// <param name="WrapMode">The wrap mode.</param>
/// <returns><see cref="Bitmap"/></returns>
public static Bitmap ResizeToFill(this Bitmap Bmp, int RequestedWidth, int RequestedHeight, PixelFormat Format = PixelFormat.Format24bppRgb, CompositingMode CompositingMode = CompositingMode.SourceCopy, CompositingQuality CompositingQuality = CompositingQuality.HighQuality, InterpolationMode InterpolationMode = InterpolationMode.HighQualityBicubic, SmoothingMode SmoothingMode = SmoothingMode.HighQuality, PixelOffsetMode PixelOffsetMode = PixelOffsetMode.HighQuality, WrapMode WrapMode = WrapMode.TileFlipXY)
{
//Store original sizes to prevent multiple getter calls.
int BmpWidth = Bmp.Width;
int BmpHeight = Bmp.Height;
//Find the (up/down)scaling ratios and pick the largest one.
//We do this since we want to scale to the largest fit size and crop the excess,
// instead of scaling to possibly the lower size and needing stretch out one dimension.
float RatioA = (float)RequestedWidth / BmpWidth;
float RatioB = (float)RequestedHeight / BmpHeight;
float Ratio = RatioA > RatioB ? RatioA : RatioB;
//Find the final (up/down)scaled size by multiplying the original size by the largest ratio.
int FinalWidth = (BmpWidth * Ratio).CeilToWhole();
int FinalHeight = (BmpHeight * Ratio).CeilToWhole();
//Find the center offsets
int OffsetX = ((FinalWidth - RequestedWidth) / 2.0f).CeilToWhole();
int OffsetY = ((FinalHeight - RequestedHeight) / 2.0f).CeilToWhole();
//Resize the original bitmap to the largest possible fitting size.
Bitmap Resized = Bmp.Resize(FinalWidth, FinalHeight, 0, 0, CompositingMode, CompositingQuality, InterpolationMode, SmoothingMode, PixelOffsetMode, WrapMode);
//Determine the final dimensions and crop the resized bitmap to them. Return it.
Rectangle FinalDimensions = new Rectangle(OffsetX, OffsetY, RequestedWidth, RequestedHeight);
return(Resized.Clone(FinalDimensions, Format));
}
internal static extern int GdipGetCompositingQuality(HandleRef graphics, out CompositingQuality quality);
/// <summary>
/// 将图像调整到指定尺寸
/// </summary>
/// <param name="图像">源图像</param>
/// <param name="缩放尺寸">目标尺寸</param>
/// <param name="插值算法">插值算法</param>
/// <param name="平滑模式">平滑模式</param>
/// <param name="合成质量">合成质量</param>
/// <returns>调整后的图像</returns>
public static Bitmap 缩放图像(this Image 图像, Size 缩放尺寸, InterpolationMode 插值算法, SmoothingMode 平滑模式, CompositingQuality 合成质量)
{
Bitmap resizedBmp = new Bitmap(缩放尺寸.Width, 缩放尺寸.Height);
Graphics g = Graphics.FromImage(resizedBmp);
g.InterpolationMode = 插值算法;
g.SmoothingMode = 平滑模式;
g.CompositingQuality = 合成质量;
g.DrawImage(图像, new Rectangle(0, 0, 缩放尺寸.Width, 缩放尺寸.Height), new Rectangle(0, 0, 图像.Width, 图像.Height), GraphicsUnit.Pixel);
return(resizedBmp);
}
GdipGetCompositingQuality(GpGraphics graphics,
out CompositingQuality compositingQuality);
/// <summary>
/// Creates a new instance using the specified settings.
/// </summary>
/// <param name="compositingQuality"></param>
/// <param name="interpolationMode"></param>
/// <param name="pixelOffsetMode"></param>
/// <param name="smoothingMode"></param>
/// <param name="textRenderingHint"></param>
/// <param name="textContrast"></param>
internal GraphicsSettings(
CompositingQuality compositingQuality,
InterpolationMode interpolationMode,
PixelOffsetMode pixelOffsetMode,
SmoothingMode smoothingMode,
TextRenderingHint textRenderingHint,
int textContrast)
{
_compositingQuality = compositingQuality;
_interpolationMode = interpolationMode;
_pixelOffsetMode = pixelOffsetMode;
_smoothingMode = smoothingMode;
_textContrast = textContrast;
_textRenderingHint = textRenderingHint;
}
public DrawingSettings(SmoothingMode smoothingMode, TextRenderingHint textRenderingHint, PixelOffsetMode pixelOffsetMode, CompositingQuality composingQuality, InterpolationMode interpolationMode)
{
this.SmoothingMode = smoothingMode;
this.TextRenderingHint = textRenderingHint;
this.PixelOffsetMode = pixelOffsetMode;
this.CompositingQuality = composingQuality;
this.InterpolationMode = interpolationMode;
}
public static extern GpStatus GdipSetCompositingQuality(GpGraphics graphics,
CompositingQuality compositingQuality);
private void PaintCellImage(ChartGraphics chartGraph, int fontSizeReducedBy, Font legendAutoFont, Size singleWCharacterSize, PointF animationLocationAdjustment)
{
if (this.Image.Length > 0)
{
Rectangle empty = Rectangle.Empty;
Image image = this.GetLegend().Common.ImageLoader.LoadImage(this.Image);
SizeF sizeF = default(SizeF);
ImageLoader.GetAdjustedImageSize(image, chartGraph.Graphics, ref sizeF);
empty.Width = (int)sizeF.Width;
empty.Height = (int)sizeF.Height;
Rectangle rectangle = this.cellPosition;
rectangle.Width = empty.Width;
rectangle.Height = empty.Height;
if (!this.ImageSize.IsEmpty)
{
if (this.ImageSize.Width > 0)
{
int num = (int)((float)(this.ImageSize.Width * singleWCharacterSize.Width) / 100.0);
if (num > this.cellPosition.Width)
{
num = this.cellPosition.Width;
}
rectangle.Width = num;
}
if (this.ImageSize.Height > 0)
{
int num2 = (int)((float)(this.ImageSize.Height * singleWCharacterSize.Height) / 100.0);
if (num2 > this.cellPosition.Height)
{
num2 = this.cellPosition.Height;
}
rectangle.Height = num2;
}
}
float num3 = 1f;
if (empty.Height > rectangle.Height)
{
num3 = (float)empty.Height / (float)rectangle.Height;
}
if (empty.Width > rectangle.Width)
{
num3 = Math.Max(num3, (float)empty.Width / (float)rectangle.Width);
}
empty.Height = (int)((float)empty.Height / num3);
empty.Width = (int)((float)empty.Width / num3);
empty.X = (int)((float)this.cellPosition.X + (float)this.cellPosition.Width / 2.0 - (float)empty.Width / 2.0);
empty.Y = (int)((float)this.cellPosition.Y + (float)this.cellPosition.Height / 2.0 - (float)empty.Height / 2.0);
if (this.Alignment == ContentAlignment.BottomLeft || this.Alignment == ContentAlignment.MiddleLeft || this.Alignment == ContentAlignment.TopLeft)
{
empty.X = this.cellPosition.X;
}
else if (this.Alignment == ContentAlignment.BottomRight || this.Alignment == ContentAlignment.MiddleRight || this.Alignment == ContentAlignment.TopRight)
{
empty.X = this.cellPosition.Right - empty.Width;
}
if (this.Alignment == ContentAlignment.BottomCenter || this.Alignment == ContentAlignment.BottomLeft || this.Alignment == ContentAlignment.BottomRight)
{
empty.Y = this.cellPosition.Bottom - empty.Height;
}
else if (this.Alignment == ContentAlignment.TopCenter || this.Alignment == ContentAlignment.TopLeft || this.Alignment == ContentAlignment.TopRight)
{
empty.Y = this.cellPosition.Y;
}
ImageAttributes imageAttributes = new ImageAttributes();
if (this.ImageTransparentColor != Color.Empty)
{
imageAttributes.SetColorKey(this.ImageTransparentColor, this.ImageTransparentColor, ColorAdjustType.Default);
}
SmoothingMode smoothingMode = chartGraph.SmoothingMode;
CompositingQuality compositingQuality = chartGraph.Graphics.CompositingQuality;
InterpolationMode interpolationMode = chartGraph.Graphics.InterpolationMode;
chartGraph.SmoothingMode = SmoothingMode.AntiAlias;
chartGraph.Graphics.CompositingQuality = CompositingQuality.HighQuality;
chartGraph.Graphics.InterpolationMode = InterpolationMode.HighQualityBicubic;
chartGraph.DrawImage(image, empty, 0, 0, image.Width, image.Height, GraphicsUnit.Pixel, imageAttributes);
chartGraph.SmoothingMode = smoothingMode;
chartGraph.Graphics.CompositingQuality = compositingQuality;
chartGraph.Graphics.InterpolationMode = interpolationMode;
}
}
public static System.Drawing.Drawing2D.CompositingQuality AsDrawingCompositingQuality(this CompositingQuality compositingQuality)
{
System.Drawing.Drawing2D.CompositingQuality drawingcompositingQuality = System.Drawing.Drawing2D.CompositingQuality.HighQuality;
switch (compositingQuality)
{
case CompositingQuality.AssumeLinear:
drawingcompositingQuality = System.Drawing.Drawing2D.CompositingQuality.AssumeLinear;
break;
case CompositingQuality.Default:
drawingcompositingQuality = System.Drawing.Drawing2D.CompositingQuality.Default;
break;
case CompositingQuality.GammaCorrected:
drawingcompositingQuality = System.Drawing.Drawing2D.CompositingQuality.GammaCorrected;
break;
case CompositingQuality.HighQuality:
drawingcompositingQuality = System.Drawing.Drawing2D.CompositingQuality.HighQuality;
break;
case CompositingQuality.HighSpeed:
drawingcompositingQuality = System.Drawing.Drawing2D.CompositingQuality.HighSpeed;
break;
case CompositingQuality.Invalid:
drawingcompositingQuality = System.Drawing.Drawing2D.CompositingQuality.Invalid;
break;
default:
break;
}
return(drawingcompositingQuality);
}
/// <summary><inheritdoc cref="Resize(Bitmap, int, int, int, int, CompositingMode, CompositingQuality, InterpolationMode, SmoothingMode, PixelOffsetMode, WrapMode)"/> Final result represents the <see cref="Bitmap"/> stretched to the given dimensions. </summary>
/// <param name="Bmp">The BMP.</param>
/// <param name="MinWidth">The minimum width.</param>
/// <param name="MinHeight">The minimum height.</param>
/// <param name="CompositingMode">The compositing mode.</param>
/// <param name="CompositingQuality">The compositing quality.</param>
/// <param name="InterpolationMode">The interpolation mode.</param>
/// <param name="SmoothingMode">The smoothing mode.</param>
/// <param name="PixelOffsetMode">The pixel offset mode.</param>
/// <param name="WrapMode">The wrap mode.</param>
/// <returns><see cref="Bitmap"/></returns>
public static Bitmap ResizeToStretch(this Bitmap Bmp, int MinWidth, int MinHeight, CompositingMode CompositingMode = CompositingMode.SourceCopy, CompositingQuality CompositingQuality = CompositingQuality.HighQuality, InterpolationMode InterpolationMode = InterpolationMode.HighQualityBicubic, SmoothingMode SmoothingMode = SmoothingMode.HighQuality, PixelOffsetMode PixelOffsetMode = PixelOffsetMode.HighQuality, WrapMode WrapMode = WrapMode.TileFlipXY)
{
int FinalHeight = (int)(Bmp.Width * ((double)MinHeight / MinWidth)).Ceil();
return(Bmp.Resize(Bmp.Width, FinalHeight, 0, 0, CompositingMode, CompositingQuality, InterpolationMode, SmoothingMode, PixelOffsetMode, WrapMode));
}
/// <summary>
/// 将图像放大或缩小
/// </summary>
/// <param name="图像">源图像</param>
/// <param name="指定宽度">指定的宽度，为0则保持原始值</param>
/// <param name="指定高度">指定的高度，为0则保持原始值</param>
/// <param name="缩放方式">缩放时采用的处理方式</param>
/// <param name="插值算法">插值算法</param>
/// <param name="平滑模式">平滑模式</param>
/// <param name="合成质量">合成质量</param>
/// <returns>缩放后的图像</returns>
public static Bitmap 缩放图像(this Image 图像, int 指定宽度, int 指定高度, 缩放方式 缩放方式, InterpolationMode 插值算法, SmoothingMode 平滑模式, CompositingQuality 合成质量)
{
var s = 计算缩放尺寸(缩放方式, 图像.Width, 图像.Height, 指定宽度, 指定高度);
var img = 缩放图像(图像, s, 插值算法, 平滑模式, 合成质量);
if (缩放方式 == 缩放方式.强制裁剪)
{
var tw = 指定宽度 == 0 ? 图像.Width : 指定宽度;
var th = 指定高度 == 0 ? 图像.Height : 指定高度;
img = 剪裁图像(img, new Point(img.Width / 2 - tw / 2, img.Height / 2 - th / 2), new Size(tw, th));
}
return(img);
}
public static extern GdiPlusStatus GdipGetCompositingQuality
(
IntPtr graphics,
out CompositingQuality compositingQuality
);
private static void SetQualityParams(ThumbQuality quality_)
{
switch (quality_)
{
case ThumbQuality.fastest:
_currentCompositingQuality = CompositingQuality.HighSpeed;
_currentInterpolationMode = InterpolationMode.NearestNeighbor;
_currentSmoothingMode = SmoothingMode.None;
_currentThumbSize = ThumbSize.small;
_currentLargeThumbSize = LargeThumbSize.small;
break;
case ThumbQuality.fast:
_currentCompositingQuality = CompositingQuality.HighSpeed;
_currentInterpolationMode = InterpolationMode.Low;
_currentSmoothingMode = SmoothingMode.HighSpeed;
_currentThumbSize = ThumbSize.small;
_currentLargeThumbSize = LargeThumbSize.small;
break;
case ThumbQuality.higher:
_currentCompositingQuality = CompositingQuality.AssumeLinear;
_currentInterpolationMode = InterpolationMode.High;
_currentSmoothingMode = SmoothingMode.HighQuality;
_currentThumbSize = ThumbSize.average;
_currentLargeThumbSize = LargeThumbSize.average;
break;
case ThumbQuality.highest:
_currentCompositingQuality = CompositingQuality.HighQuality;
_currentInterpolationMode = InterpolationMode.HighQualityBicubic;
_currentSmoothingMode = SmoothingMode.HighQuality;
_currentThumbSize = ThumbSize.large;
_currentLargeThumbSize = LargeThumbSize.large;
break;
case ThumbQuality.uhd:
_currentCompositingQuality = CompositingQuality.HighQuality;
_currentInterpolationMode = InterpolationMode.HighQualityBicubic;
_currentSmoothingMode = SmoothingMode.HighQuality;
_currentThumbSize = ThumbSize.uhd;
_currentLargeThumbSize = LargeThumbSize.uhd;
break;
default:
_currentCompositingQuality = CompositingQuality.Default;
_currentInterpolationMode = InterpolationMode.Default;
_currentSmoothingMode = SmoothingMode.Default;
_currentThumbSize = ThumbSize.average;
_currentLargeThumbSize = LargeThumbSize.average;
break;
}
}
public static Stream Resize(int width, Stream imageStream, string outputPath, CompositingQuality compositingQuality, SmoothingMode smoothingMode, InterpolationMode interpolationMode)
{
var resizedStream = Resize(width, imageStream, compositingQuality, smoothingMode, interpolationMode);
Save(resizedStream, outputPath);
return(resizedStream);
}
internal static extern Status GdipGetCompositingQuality(IntPtr graphics, out CompositingQuality compositingQuality);
private static Image Resize(Image originalImage, int newWidth, int newHeight, CompositingQuality compositingQuality, SmoothingMode smoothingMode, InterpolationMode interpolationMode, PixelOffsetMode pixelOffsetmode)
{
Image result = new Bitmap(newWidth, newHeight);
using (var graphic = Graphics.FromImage(result))
{
graphic.CompositingQuality = compositingQuality;
graphic.SmoothingMode = smoothingMode;
graphic.InterpolationMode = interpolationMode;
graphic.PixelOffsetMode = pixelOffsetmode;
Rectangle rectangle = new Rectangle(0, 0, newWidth, newHeight);
graphic.DrawImage(originalImage, rectangle);
return(result);
}
}
GdipSetCompositingQuality(GpGraphics graphics,
CompositingQuality compositingQuality);
public void DrawRaw(float dx, float dy, InterpolationMode iMmode, CompositingQuality cQuality, SmoothingMode sm)
{
if (Main.Graphs.Count == 0)
{
labelHint.Visible = true;
Bitmap im = new Bitmap(pictureBox1.Width, pictureBox1.Height);
using (Graphics gr = Graphics.FromImage(im))
{
gr.FillRectangle(Brushes.White, 0, 0, pictureBox1.Width, pictureBox1.Height);
}
Image img = pictureBox1.Image;
pictureBox1.Image = im;
if (img != null)
{
img.Dispose();
}
}
else
{
labelHint.Visible = false;
Bitmap im = new Bitmap(pictureBox1.Width, pictureBox1.Height);
using (Graphics gr = Graphics.FromImage(im))
{
gr.InterpolationMode = iMmode;
gr.CompositingQuality = cQuality;
gr.SmoothingMode = sm;
gr.FillRectangle(Brushes.White, 0, 0, pictureBox1.Width, pictureBox1.Height);
Matrix mat = new Matrix();
mat.Translate(dx, dy);
mat.Scale(Zoom, Zoom);
foreach (var b in Main.Graphs)
{
var grP = b.Build();
grP.Transform(mat);
if (b.MainPen.Width != 1)
{
gr.DrawPath(new Pen(b.MainPen.Color, b.MainPen.Width * Zoom / 100), grP);
}
else
{
gr.DrawPath(b.MainPen, grP);
}
if (b.Display && b.Markers.Use)
{
foreach (var c in b.Markers.Points)
{
gr.FillEllipse(new SolidBrush(b.Markers.Color), Zoom * c + dx - b.Markers.Size / 2, (-Zoom) * (b.DataSource.GetValue(c)) + dy - b.Markers.Size / 2, b.Markers.Size, b.Markers.Size);
}
}
}
if (Main.AxisParams.Show)
{
var AxisPen = new Pen(Main.AxisParams.Color, Main.AxisParams.Width);
var xAxis = Main.GetXAxis();
var yAxis = Main.GetYAxis();
xAxis.Transform(mat);
yAxis.Transform(mat);
gr.DrawPath(AxisPen, xAxis);
gr.DrawPath(AxisPen, yAxis);
}
}
Image img = pictureBox1.Image;
pictureBox1.Image = im;
if (img != null)
{
img.Dispose();
}
ZeroPoint = new PointF(dx, dy);
}
}
public static void DrawImageEx(this Graphics g, Bitmap bit, Rectangle area,
CompositingQuality CompositingQuality,
InterpolationMode InterpolationMode,
PixelOffsetMode PixelOffsetMode,
SmoothingMode SmoothingMode,
ZoomType ZoomType, ImageAttributes ImageAttributes
)
{
g.CompositingQuality = CompositingQuality;
g.InterpolationMode = InterpolationMode;
g.PixelOffsetMode = PixelOffsetMode;
g.SmoothingMode = SmoothingMode;
if (ZoomType == ZoomType.CenterIfNoZoom)
{
if (bit.Width < area.Width && bit.Height < area.Height)
{
ZoomType = Drawing.ZoomType.Center;
}
else
{
ZoomType = Drawing.ZoomType.Zoom;
}
}
switch (ZoomType)
{
case ZoomType.Tile:
if (ImageAttributes != null)
{
using (var brush = new TextureBrush(bit, area, ImageAttributes)) {
g.FillRectangle(brush, area);
}
}
else
{
using (var brush = new TextureBrush(bit)) {
g.FillRectangle(brush, area);
}
}
break;
case ZoomType.Center:
area.X += (area.Width - bit.Width) / 2;
area.Y += (area.Height - bit.Height) / 2;
area.Width = bit.Width;
area.Height = bit.Height;
FinalDraw(g, bit, area, ImageAttributes);
break;
case ZoomType.Stretch:
FinalDraw(g, bit, area, ImageAttributes);
break;
case ZoomType.Zoom:
int nw, nh;
SetZoomSize(bit.Width, bit.Height, area.Width, area.Height, out nw, out nh);
area.X = ((area.Width - nw) / 2) + area.X;
area.Y = ((area.Height - nh) / 2) + area.Y;
area.Width = nw;
area.Height = nh;
FinalDraw(g, bit, area, ImageAttributes);
break;
case Drawing.ZoomType.Crop:
SetCorpSize(bit.Width, bit.Height, area.Width, area.Height, out nw, out nh);
g.SetClip(area);
area.X = ((area.Width - nw) / 2) + area.X;
area.Y = ((area.Height - nh) / 2) + area.Y;
area.Width = nw;
area.Height = nh;
FinalDraw(g, bit, area, ImageAttributes);
break;
}
}
/// <summary>Returns a resized form of the specified <paramref name="Bmp"/> to the requested <paramref name="FinalWidth"/> and <paramref name="FinalHeight"/>, using the specified parameters.</summary>
/// <param name="Bmp">The BMP.</param>
/// <param name="FinalWidth">The final width.</param>
/// <param name="FinalHeight">The final height.</param>
/// <param name="OffsetX">The offset x.</param>
/// <param name="OffsetY">The offset y.</param>
/// <param name="CompositingMode">The compositing mode.</param>
/// <param name="CompositingQuality">The compositing quality.</param>
/// <param name="InterpolationMode">The interpolation mode.</param>
/// <param name="SmoothingMode">The smoothing mode.</param>
/// <param name="PixelOffsetMode">The pixel offset mode.</param>
/// <param name="WrapMode">The wrap mode.</param>
/// <returns></returns>
public static Bitmap Resize(this Bitmap Bmp, int FinalWidth, int FinalHeight, int OffsetX = 0, int OffsetY = 0, CompositingMode CompositingMode = CompositingMode.SourceCopy, CompositingQuality CompositingQuality = CompositingQuality.HighQuality, InterpolationMode InterpolationMode = InterpolationMode.HighQualityBicubic, SmoothingMode SmoothingMode = SmoothingMode.HighQuality, PixelOffsetMode PixelOffsetMode = PixelOffsetMode.HighQuality, WrapMode WrapMode = WrapMode.TileFlipXY)
{
Rectangle DestRect = new Rectangle(OffsetX, OffsetY, FinalWidth, FinalHeight);
Bitmap DestImage = new Bitmap(FinalWidth, FinalHeight);
DestImage.SetResolution(Bmp.HorizontalResolution, Bmp.VerticalResolution);
using (Graphics Graphics = Graphics.FromImage(DestImage)) {
Graphics.CompositingMode = CompositingMode;
Graphics.CompositingQuality = CompositingQuality;
Graphics.InterpolationMode = InterpolationMode;
Graphics.SmoothingMode = SmoothingMode;
Graphics.PixelOffsetMode = PixelOffsetMode;
using (ImageAttributes WrapAttrb = new ImageAttributes()) {
WrapAttrb.SetWrapMode(WrapMode);
Graphics.DrawImage(Bmp, DestRect, 0, 0, Bmp.Width, Bmp.Height, GraphicsUnit.Pixel, WrapAttrb);
}
}
return(DestImage);
}
internal static extern GpStatus GdipGetCompositingQuality(GpGraphics graphics, out CompositingQuality compositingQuality);
private void PaintCellImage(MapGraphics chartGraph, int fontSizeReducedBy, Font legendAutoFont, Size singleWCharacterSize)
{
if (string.IsNullOrEmpty(Image))
{
return;
}
Rectangle empty = Rectangle.Empty;
Image image = GetLegend().Common.ImageLoader.LoadImage(Image);
empty.Width = image.Size.Width;
empty.Height = image.Size.Height;
Rectangle rectangle = cellPosition;
rectangle.Width = empty.Width;
rectangle.Height = empty.Height;
if (!ImageSize.IsEmpty)
{
if (ImageSize.Width > 0)
{
int num = (int)((float)(ImageSize.Width * singleWCharacterSize.Width) / 100f);
if (num > cellPosition.Width)
{
num = cellPosition.Width;
}
rectangle.Width = num;
}
if (ImageSize.Height > 0)
{
int num2 = (int)((float)(ImageSize.Height * singleWCharacterSize.Height) / 100f);
if (num2 > cellPosition.Height)
{
num2 = cellPosition.Height;
}
rectangle.Height = num2;
}
}
float num3 = 1f;
if (empty.Height > rectangle.Height)
{
num3 = (float)empty.Height / (float)rectangle.Height;
}
if (empty.Width > rectangle.Width)
{
num3 = Math.Max(num3, (float)empty.Width / (float)rectangle.Width);
}
empty.Height = (int)((float)empty.Height / num3);
empty.Width = (int)((float)empty.Width / num3);
empty.X = (int)((float)cellPosition.X + (float)cellPosition.Width / 2f - (float)empty.Width / 2f);
empty.Y = (int)((float)cellPosition.Y + (float)cellPosition.Height / 2f - (float)empty.Height / 2f);
if (Alignment == ContentAlignment.BottomLeft || Alignment == ContentAlignment.MiddleLeft || Alignment == ContentAlignment.TopLeft)
{
empty.X = cellPosition.X;
}
else if (Alignment == ContentAlignment.BottomRight || Alignment == ContentAlignment.MiddleRight || Alignment == ContentAlignment.TopRight)
{
empty.X = cellPosition.Right - empty.Width;
}
if (Alignment == ContentAlignment.BottomCenter || Alignment == ContentAlignment.BottomLeft || Alignment == ContentAlignment.BottomRight)
{
empty.Y = cellPosition.Bottom - empty.Height;
}
else if (Alignment == ContentAlignment.TopCenter || Alignment == ContentAlignment.TopLeft || Alignment == ContentAlignment.TopRight)
{
empty.Y = cellPosition.Y;
}
ImageAttributes imageAttributes = new ImageAttributes();
if (ImageTranspColor != Color.Empty)
{
imageAttributes.SetColorKey(ImageTranspColor, ImageTranspColor, ColorAdjustType.Default);
}
SmoothingMode smoothingMode = chartGraph.SmoothingMode;
CompositingQuality compositingQuality = chartGraph.Graphics.CompositingQuality;
InterpolationMode interpolationMode = chartGraph.Graphics.InterpolationMode;
chartGraph.SmoothingMode = SmoothingMode.AntiAlias;
chartGraph.Graphics.CompositingQuality = CompositingQuality.HighQuality;
chartGraph.Graphics.InterpolationMode = InterpolationMode.HighQualityBicubic;
chartGraph.DrawImage(image, empty, 0, 0, image.Width, image.Height, GraphicsUnit.Pixel, imageAttributes);
chartGraph.SmoothingMode = smoothingMode;
chartGraph.Graphics.CompositingQuality = compositingQuality;
chartGraph.Graphics.InterpolationMode = interpolationMode;
}
