/// <summary> /// Initializes a new instance of the <see cref="ResizeLayer"/> class. /// </summary> /// <param name="size"> /// The <see cref="T:System.Drawing.Size"/> containing the width and height to set the image to. /// </param> /// <param name="anchorPosition"> /// The <see cref="AnchorPosition"/> to apply to resized image. /// </param> public ResizeLayer(Size size, AnchorPosition anchorPosition) { this.Size = size; this.AnchorPosition = anchorPosition; this.ResizeMode = ResizeMode.Pad; this.BackgroundColor = Color.Transparent; }
private AnchorPositionMode GetAnchorPositionMode(AnchorPosition anchorPosition) { switch (anchorPosition) { case AnchorPosition.TopLeft: return(AnchorPositionMode.TopLeft); case AnchorPosition.TopCenter: return(AnchorPositionMode.Top); case AnchorPosition.TopRight: return(AnchorPositionMode.TopRight); case AnchorPosition.CenterLeft: return(AnchorPositionMode.Left); case AnchorPosition.Center: return(AnchorPositionMode.Center); case AnchorPosition.CenterRight: return(AnchorPositionMode.Right); case AnchorPosition.BottomLeft: return(AnchorPositionMode.BottomLeft); case AnchorPosition.BottomCenter: return(AnchorPositionMode.Bottom); case AnchorPosition.BottomRight: return(AnchorPositionMode.BottomRight); default: throw new ArgumentOutOfRangeException($"AnchorPosition {anchorPosition.ToString()} not supported."); } }
private void _AdaptModel(AnchorPosition pos, Anchor anchor) { Destroy(model); GameObject pref = prefabFromPos(pos); model = Instantiate <GameObject>(pref, anchor.transform); switch (pos) { case AnchorPosition.APLOR: model.transform.localPosition += new Vector3(2, -1, 1.5f); model.transform.localEulerAngles = new Vector3(109, 0, 0); break; case AnchorPosition.APRoutes: model.transform.localPosition += new Vector3(1, -1, 1.5f); model.transform.localEulerAngles = new Vector3(109, 0, 0); break; case AnchorPosition.APStatus: model.transform.localPosition += new Vector3(0, -1, 1.5f); model.transform.localEulerAngles = new Vector3(109, 0, 0); break; case AnchorPosition.APWall: model.transform.localPosition += new Vector3(-1, -1, 1.5f); model.transform.localEulerAngles = new Vector3(109, 0, 0); break; default: break; } }
private void GenerateUIs() { //Hardcoded because the corners in a ui are limited GenerateUI(AllCultures[0], AnchorPosition.LeftDownAnchor()); GenerateUI(AllCultures[1], AnchorPosition.RightUpAnchor()); GenerateUI(AllCultures[2], AnchorPosition.RightDownAnchor()); }
public static void CropImage(string pathFrom, string destinationPath, int Width, int Height, AnchorPosition anchor, ImageFormat format, CropOptions cropOptions) { string pathRead = pathFrom; if (pathFrom == destinationPath) { FileInfo fi = new FileInfo(pathFrom); pathRead = Path.Combine(fi.Directory.FullName, System.Guid.NewGuid().ToString() + Path.GetExtension(pathFrom)); fi.MoveTo(pathRead); } System.Drawing.Image im = System.Drawing.Image.FromFile(pathRead); System.Drawing.Image dest = Crop(im, Width, Height, cropOptions); if (format == ImageFormat.Jpeg) { SaveJpeg(destinationPath, dest, JpegQuality); } else { dest.Save(destinationPath, format); } im.Dispose(); dest.Dispose(); if (pathRead != pathFrom) { File.Delete(pathRead); } RotateImageByExifOrientationData(destinationPath, true); }
private void UpdateCurrentPosition(AnchorPosition anchorPos) { string name = anchorPos.SpatialAnchorObject.Name; string destination = destinationAnchor; updateMinimap(name.Substring(0, name.Length - 1), destination.Substring(0, destination.Length - 1)); }
public static AnchorElement AnchorElement(AnchorPosition position, NodeElement owner, Canvas canvas) { if (owner == null) { throw new ArgumentNullException(nameof(owner)); } int x = 0, y = 0; switch (position) { case AnchorPosition.Top: x = owner.X + owner.Width / 2; y = owner.Y; break; case AnchorPosition.Right: x = owner.X + owner.Width; y = owner.Y + owner.Height / 2; break; case AnchorPosition.Bottom: x = owner.X + owner.Width / 2; y = owner.Y + owner.Height; break; case AnchorPosition.Left: x = owner.X; y = owner.Y + owner.Height / 2; break; default: throw new ArgumentOutOfRangeException(nameof(position), position, null); } return(new Anchor(x, y, owner, canvas)); }
private ThumbnailOption Create(JObject jObject) { ResizeMethod resultResizeMethod = default(ResizeMethod); var resizeMethod = jObject["method"]; if (resizeMethod != null) { Enum.TryParse(resizeMethod.Value <string>(), out resultResizeMethod); } AnchorPosition resultAnchorPosition = default(AnchorPosition); var anchorPosition = jObject["anchorposition"]; if (anchorPosition != null) { Enum.TryParse(anchorPosition.Value <string>(), out resultAnchorPosition); } var result = new ThumbnailOption() { BackgroundColor = jObject["color"]?.Value <string>(), FileSuffix = jObject["alias"]?.Value <string>(), Width = jObject["width"]?.Value <int>(), Height = jObject["height"]?.Value <int>(), AnchorPosition = resultAnchorPosition, ResizeMethod = resultResizeMethod }; return(result); }
public byte[] Get(string relativeFilePath, int width, int height, ImageMod imageMod, string hexBackgroundColour, AnchorPosition? anchor, OutputFormat outputFormat) { using (var bitmap = Get(relativeFilePath, width, height, imageMod, hexBackgroundColour, anchor)) { return bitmap.GetBytes(outputFormat); } }
private Vector2 getOrigo(AnchorPosition anchor, Rect viewport) { Vector2 origo = new Vector2(); switch (anchor) { case AnchorPosition.BOTTOM_LEFT: origo.y = Screen.height - viewport.height; break; case AnchorPosition.BOTTOM_RIGHT: origo.x = Screen.width - viewport.width; origo.y = Screen.height - viewport.height; break; case AnchorPosition.TOP_LEFT: //Do nothing.. break; case AnchorPosition.TOP_RIGHT: origo.x = Screen.width - viewport.width; break; } return(origo); }
public SubwindowSpec(AnchorPosition anchor, float x, float y) { Anchor = anchor; Position = new Vector2(x, y); xRelative = false; yRelative = false; }
private void GenerateTransitionLines() { LinkedListNode <string> it = anchorList.First; while (it != anchorList.Last) { AnchorPosition baseAnchor = null; AnchorPosition targetAnchor = null; foreach (AnchorPosition anchorPos in SceneAnchorPositions) { if (anchorPos.SpatialAnchorObject.Name == it.Value) { baseAnchor = anchorPos; } if (anchorPos.SpatialAnchorObject.Name == it.Next.Value) { targetAnchor = anchorPos; } } if (baseAnchor != null && targetAnchor != null) { baseAnchor.ConnectToAnchor(targetAnchor); } else { Debug.Log($"Cannot find the anchor connecting to {it.Value}"); break; } it = it.Next; } }
private static Image Crop(Image imgPhoto, int Width, int Height, AnchorPosition Anchor) { int num10; int width = imgPhoto.Width; int height = imgPhoto.Height; int x = 0; int y = 0; int num5 = 0; int num6 = 0; float num7 = 0f; float num8 = 0f; float num9 = 0f; num8 = ((float)Width) / ((float)width); num9 = ((float)Height) / ((float)height); if (num9 >= num8) { num7 = num9; switch (Anchor) { case AnchorPosition.Left: num5 = 0; goto Label_00D1; case AnchorPosition.Right: num5 = Width - ((int)(width * num7)); goto Label_00D1; } num5 = (int)((Width - (width * num7)) / 2f); } else { num7 = num8; switch (Anchor) { case AnchorPosition.Top: num6 = 0; goto Label_00D1; case AnchorPosition.Bottom: num6 = Height - ((int)(height * num7)); goto Label_00D1; } num6 = (int)((Height - (height * num7)) / 2f); } Label_00D1: num10 = (int)(width * num7); int num11 = (int)(height * num7); Bitmap image = new Bitmap(Width - 1, Height - 1, PixelFormat.Format24bppRgb); image.SetResolution(imgPhoto.HorizontalResolution, imgPhoto.VerticalResolution); Graphics graphics = Graphics.FromImage(image); graphics.Clear(Color.White); graphics.InterpolationMode = InterpolationMode.HighQualityBicubic; graphics.DrawImage(imgPhoto, new Rectangle(num5, num6, num10, num11), new Rectangle(x, y, width, height - 2), GraphicsUnit.Pixel); graphics.Dispose(); return(image); }
public void CancelAnchorProfile() { // remove the instance of AnchorPosition Destroy(currentAnchorPosition.gameObject); // assign previousSpatialAnchor to currentSpatialAnchor currentAnchorPosition = previousAnchorPosition; previousAnchorPosition = SceneAnchorPositions[SceneAnchorPositions.Count - 1]; }
public FANBannerData(AdSize adSize, AdPosition adPosition, float xPos, float yPos, AnchorPosition anchorPos = AnchorPosition.Center) { this.adSize = adSize; this.adPosition = adPosition; this.xPos = xPos; this.yPos = yPos; this.anchorPosition = anchorPos; }
protected override bool OnMouseMove(MouseMoveEvent e) { var angle = AnchorPosition.GetDegreesFromPosition(e.MousePosition); Rotation = angle; return(base.OnMouseMove(e)); }
public Bitmap Get(string relativeFilePath, int width, int height, ImageMod imageMod, string hexBackgroundColour, AnchorPosition? anchor) { using (var image = (relativeFilePath == "Default" ? getDefault(width, height) : loadImage(relativeFilePath) ?? getDefault(width, height))) { return ResizeUtility.Get(image, width, height, imageMod, hexBackgroundColour, anchor); } }
static void RenderMapGizmono(AnchorPosition map, GizmoType gizmoType) { var p = map.transform.position; Handles.color = Gizmos.color = map.color; Gizmos.DrawSphere(p, map.transform.localScale.magnitude * 0.2f); Handles.color = Gizmos.color = new Color(1, 1, 1, 1); Handles.Label(p, map.name); }
private void UpdateCurrentPosition(AnchorPosition anchorPos) { //Debug.Log(anchorPos.SpatialAnchorObject.Name); //Debug.Log("******Call Proximity " + name.Substring(3,name.Length-3) + " CurrentanchorID " + currentAnchorID); string name = anchorPos.SpatialAnchorObject.Name; string destination = destinationAnchor; updateMinimap(name.Substring(0, name.Length - 1), destination.Substring(0, destination.Length - 1)); }
public void ConnectToAnchor(AnchorPosition target) { var lineDataProvider = GetComponent <SimpleLineDataProvider>(); lineDataProvider.EndPoint = new MixedRealityPose(target.GetTransform().position, Quaternion.identity); var mrLineRenderer = GetComponent <MixedRealityLineRenderer>(); mrLineRenderer.enabled = true; }
/// <summary> /// Constructor /// </summary> /// <param name="text">Text to display</param> /// <param name="color">Color of the text</param> /// <param name="fontSize">Size of the text's characters</param> /// <param name="anchor">Position of the text's anchor</param> public TextDebugDrawer(string text, Color color, float fontSize, AnchorPosition anchor = AnchorPosition.TopLeft) { Color = color; m_fontSize = fontSize; m_textLines = text.Split(s_newlineCharacters, StringSplitOptions.RemoveEmptyEntries); m_anchorPosition = new Vector2(GetHorizontalAnchorOffset(m_textLines, anchor) * fontSize, GetVerticalAnchorOffset(m_textLines, anchor) * fontSize); }
public void ConnectToAnchor(AnchorPosition target) { var lineDataProvider = GetComponent <SimpleLineDataProvider>(); lineDataProvider.SetPoint(1, target.GetTransform().position); var mrLineRenderer = GetComponent <MixedRealityLineRenderer>(); mrLineRenderer.enabled = true; }
public override void Read(EndianStream stream) { base.Read(stream); AnchorMin.Read(stream); AnchorMax.Read(stream); AnchorPosition.Read(stream); SizeDelta.Read(stream); Pivot.Read(stream); }
public override void Read(AssetReader reader) { base.Read(reader); AnchorMin.Read(reader); AnchorMax.Read(reader); AnchorPosition.Read(reader); SizeDelta.Read(reader); Pivot.Read(reader); }
/// <summary> /// Resizes the image to a certain width and height. It will crop the image whenever necessary. The module will not perform /// any image resizing if both width and height are set to <c>null</c>. If the source image is smaller than the specified /// width and height, the image will be enlarged. /// </summary> /// <param name="width">The desired width. If set to <c>null</c> or <c>0</c>, the image will be resized to its height.</param> /// <param name="height">The desired height. If set to <c>null</c> or <c>0</c>, the image will be resized to its width.</param> /// <param name="anchor">The anchor position to use for cropping (if necessary). The available values are: /// <list type="bullet"> /// <item><description>AnchorPosition.Center</description></item> /// <item><description>AnchorPosition.Top</description></item> /// <item><description>AnchorPosition.Bottom</description></item> /// <item><description>AnchorPosition.Left</description></item> /// <item><description>AnchorPosition.Right</description></item> /// <item><description>AnchorPosition.TopLeft</description></item> /// <item><description>AnchorPosition.TopRight</description></item> /// <item><description>AnchorPosition.BottomLeft</description></item> /// <item><description>AnchorPosition.BottomRight</description></item> /// </list> /// </param> public Image Resize(int?width, int?height, AnchorPosition anchor = AnchorPosition.Center) { EnsureCurrentInstruction(); _currentInstruction.Width = width; _currentInstruction.Height = height; _currentInstruction.AnchorPosition = anchor; return(this); }
protected override YAMLMappingNode ExportYAMLRoot(IExportContainer container) { YAMLMappingNode node = base.ExportYAMLRoot(container); node.Add("m_AnchorMin", AnchorMin.ExportYAML(container)); node.Add("m_AnchorMax", AnchorMax.ExportYAML(container)); node.Add("m_AnchoredPosition", AnchorPosition.ExportYAML(container)); node.Add("m_SizeDelta", SizeDelta.ExportYAML(container)); node.Add("m_Pivot", Pivot.ExportYAML(container)); return(node); }
private Vector2 AnchorToVector(AnchorPosition anchorPosition) { Vector2 result = new Vector2(0, 0); result.x += (anchorPosition & AnchorPosition.Right) > 0 ? 1 : 0; result.x += (anchorPosition & AnchorPosition.Left) > 0 ? -1 : 0; result.y += (anchorPosition & AnchorPosition.Top) > 0 ? 1 : 0; result.y += (anchorPosition & AnchorPosition.Bottom) > 0 ? -1 : 0; return(result); }
protected override YAMLMappingNode ExportYAMLRoot(IExportContainer container) { YAMLMappingNode node = base.ExportYAMLRoot(container); node.Add(AnchorMinName, AnchorMin.ExportYAML(container)); node.Add(AnchorMaxName, AnchorMax.ExportYAML(container)); node.Add(AnchoredPositionName, AnchorPosition.ExportYAML(container)); node.Add(SizeDeltaName, SizeDelta.ExportYAML(container)); node.Add(PivotName, Pivot.ExportYAML(container)); return(node); }
public static Bitmap Get(Image image, int width, int height, ImageMod imageMod, string hexBackgroundColour, AnchorPosition? anchor) { switch (imageMod) { case ImageMod.Scale: return Scale(image, width, height, hexBackgroundColour); case ImageMod.Crop: return Crop(image, width, height, anchor ?? AnchorPosition.Center); default: return Scale(image, width, height, hexBackgroundColour); } }
private void _TrackingMarker(AugmentedImage image) { AnchorPosition pos = _PosForName(image.Name); Anchor anchor; if (!anchors.TryGetValue(pos, out anchor)) { anchor = image.CreateAnchor(image.CenterPose); anchors.Add(pos, anchor); _AdaptModel(pos, anchor); } }
/// <summary> /// Initializes a new instance of the <see cref="ResizeLayer"/> class. /// </summary> /// <param name="size"> /// The <see cref="T:System.Drawing.Size"/> containing the width and height to set the image to. /// </param> /// <param name="backgroundColor"> /// The <see cref="T:System.Drawing.Color"/> to set as the background color. /// <remarks>Used for image formats that do not support transparency (Default transparent)</remarks> /// </param> /// <param name="resizeMode"> /// The resize mode to apply to resized image. (Default ResizeMode.Pad) /// </param> /// <param name="anchorPosition"> /// The <see cref="AnchorPosition"/> to apply to resized image. (Default AnchorPosition.Center) /// </param> /// <param name="upscale"> /// Whether to allow up-scaling of images. (Default true) /// </param> public ResizeLayer( Size size, Color? backgroundColor = null, ResizeMode resizeMode = ResizeMode.Pad, AnchorPosition anchorPosition = AnchorPosition.Center, bool upscale = true) { this.Size = size; this.Upscale = upscale; this.BackgroundColor = backgroundColor ?? Color.Transparent; this.ResizeMode = resizeMode; this.AnchorPosition = anchorPosition; }
/// <summary> /// Initializes a new instance of the <see cref="ResizeLayer"/> class. /// </summary> /// <param name="size"> /// The <see cref="T:System.Drawing.Size"/> containing the width and height to set the image to. /// </param> /// <param name="backgroundColor"> /// The <see cref="T:System.Drawing.Color"/> to set as the background color. /// <remarks>Used for image formats that do not support transparency (Default transparent)</remarks> /// </param> /// <param name="resizeMode"> /// The resize mode to apply to resized image. (Default ResizeMode.Pad) /// </param> /// <param name="anchorPosition"> /// The <see cref="AnchorPosition"/> to apply to resized image. (Default AnchorPosition.Center) /// </param> /// <param name="upscale"> /// Whether to allow up-scaling of images. (Default true) /// </param> public ResizeLayer( Size size, Color?backgroundColor = null, ResizeMode resizeMode = ResizeMode.Stretch, AnchorPosition anchorPosition = AnchorPosition.Center, bool upscale = true) { this.Size = size; this.Upscale = upscale; this.BackgroundColor = backgroundColor ?? Color.Transparent; this.ResizeMode = resizeMode; this.AnchorPosition = anchorPosition; }
/// <summary> /// Resize and trim excess. /// The image will have given size /// </summary> public virtual Image Crop(Image image, int width, int height, AnchorPosition anchor) { var source = new ImageDimensions { Width = image.Width, Height = image.Height }; var destination = new ImageDimensions(); float nPercent; var nPercentW = width / (float)source.Width; var nPercentH = height / (float)source.Height; if (nPercentH < nPercentW) { nPercent = nPercentW; if (anchor == AnchorPosition.TopLeft || anchor == AnchorPosition.TopCenter || anchor == AnchorPosition.TopRight) { destination.Y = 0; } else if (anchor == AnchorPosition.BottomLeft || anchor == AnchorPosition.BottomCenter || anchor == AnchorPosition.BottomRight) { destination.Y = (int)(height - source.Height * nPercent); } else { destination.Y = (int)((height - source.Height * nPercent) / 2); } } else { nPercent = nPercentH; if (anchor == AnchorPosition.TopLeft || anchor == AnchorPosition.CenterLeft || anchor == AnchorPosition.BottomLeft) { destination.X = 0; } else if (anchor == AnchorPosition.TopRight || anchor == AnchorPosition.CenterRight || anchor == AnchorPosition.BottomRight) { destination.X = (int)(width - source.Width * nPercent); } else { destination.X = (int)((width - source.Width * nPercent) / 2); } } destination.Width = (int)(source.Width * nPercent); destination.Height = (int)(source.Height * nPercent); return(Transform(image, source, destination, new Size { Height = height, Width = width }, null)); }
public void ShowTooltip(string message, Rectangle target, AnchorPosition anchor, float duration) { if (this.currentTween != null) { this.currentTween.Kill(); } this.gameObject.SetActive(true); this.duration = duration; this.label.text = message; this.label.ComputeMarginSize(); float width = this.label.GetPreferredValues().x + 2 * this.labelMargin; this.back.Width = width; float height = this.back.Height; float targetWidth = target.Width; float targetHeight = target.Height; DOTween.To((float t) => { this.backColorHidden.a = t; this.back.Color = this.backColorHidden; }, 0.0f, 1.0f, this.transitionDuration); this.label.DOColor(this.labelColorVisible, this.transitionDuration); Vector2 deltaDirection = this.AnchorToVector(anchor); Vector3 position = target.transform.position; position.x += deltaDirection.x * targetWidth * .5f + width * .5f * deltaDirection.x; position.y += deltaDirection.y * targetHeight * .5f + height * .5f * deltaDirection.y; this.hidePosition = position; position += new Vector3(deltaDirection.x, deltaDirection.y, 0) * this.targetMargin; this.transform.position = this.hidePosition; this.currentTween = this.transform.DOMove(position, this.transitionDuration).SetEase(Ease.OutCubic).OnKill(() => { this.currentTween = null; this.currentState = State.Visible; }); this.showDate = UnityEngine.Time.timeSinceLevelLoad; this.currentState = State.TransitionToVisible; }
/// <summary> /// Resizes the given image. /// </summary> /// <param name="source">The source <see cref="Image"/> to resize.</param> /// <param name="linear">Whether to resize the image using the linear color space.</param> /// <returns> /// The resized <see cref="Image"/>. /// </returns> public Bitmap ResizeImage(Image source, bool linear) { int width = this.ResizeLayer.Size.Width; int height = this.ResizeLayer.Size.Height; ResizeMode mode = this.ResizeLayer.ResizeMode; AnchorPosition anchor = this.ResizeLayer.AnchorPosition; bool upscale = this.ResizeLayer.Upscale; float[] centerCoordinates = this.ResizeLayer.CenterCoordinates; int maxWidth = this.ResizeLayer.MaxSize.HasValue ? this.ResizeLayer.MaxSize.Value.Width : int.MaxValue; int maxHeight = this.ResizeLayer.MaxSize.HasValue ? this.ResizeLayer.MaxSize.Value.Height : int.MaxValue; List <Size> restrictedSizes = this.ResizeLayer.RestrictedSizes; return(this.ResizeImage(source, width, height, maxWidth, maxHeight, restrictedSizes, mode, anchor, upscale, centerCoordinates, linear)); }
public Bitmap Get(string relativeFilePath, int width, int height, ImageMod imageMod, string hexBackgroundColour, AnchorPosition? anchor) { using (var image = (relativeFilePath == "Default" ? getDefault(width, height) : loadImage(relativeFilePath) ?? getDefault(width, height))) { switch (imageMod) { case ImageMod.Scale: return scale(image, width, height, hexBackgroundColour); case ImageMod.Crop: return crop(image, width, height, anchor ?? AnchorPosition.Center); default: return scale(image, width, height, hexBackgroundColour); } } }
/// <summary> /// Initializes a new instance of the <see cref="ResizeLayer"/> class. /// </summary> /// <param name="size"> /// The <see cref="T:System.Drawing.Size"/> containing the width and height to set the image to. /// </param> /// <param name="resizeMode"> /// The resize mode to apply to resized image. (Default ResizeMode.Pad) /// </param> /// <param name="anchorPosition"> /// The <see cref="AnchorPosition"/> to apply to resized image. (Default AnchorPosition.Center) /// </param> /// <param name="upscale"> /// Whether to allow up-scaling of images. (Default true) /// </param> /// <param name="centerCoordinates"> /// The center coordinates (Default null) /// </param> /// <param name="maxSize"> /// The maximum size to resize an image to. /// Used to restrict resizing based on calculated resizing /// </param> /// <param name="restrictedSizes"> /// The range of sizes to restrict resizing an image to. /// Used to restrict resizing based on calculated resizing /// </param> public ResizeLayer( Size size, ResizeMode resizeMode = ResizeMode.Pad, AnchorPosition anchorPosition = AnchorPosition.Center, bool upscale = true, float[] centerCoordinates = null, Size? maxSize = null, List<Size> restrictedSizes = null) { this.Size = size; this.Upscale = upscale; this.ResizeMode = resizeMode; this.AnchorPosition = anchorPosition; this.CenterCoordinates = centerCoordinates ?? new float[] { }; this.MaxSize = maxSize; this.RestrictedSizes = restrictedSizes ?? new List<Size>(); }
/// <summary> /// Funnctions that repositions the anchor based the postion chosen from the enum, through the screen to world point function. /// </summary> void RepositionAnchor() { // If the previous postion of the anchor is equal to the current position of the anchor, return out of the function. if (oldPosition == anchorPosition) return; if (!hudCamera) hudCamera = transform.parent.camera; float aspectRatio = (float)Screen.width / (float)Screen.height; float height = hudCamera.orthographicSize; float width = height * aspectRatio; switch (anchorPosition) { case AnchorPosition.TopLeft: transform.localPosition = (Vector3.left * width) + (Vector3.up * height); break; case AnchorPosition.Top: transform.localPosition = (Vector3.up * height); break; case AnchorPosition.TopRight: transform.localPosition = (Vector3.right * width) + (Vector3.up * height); break; case AnchorPosition.Left: transform.localPosition = (Vector3.left * width); break; case AnchorPosition.Center: transform.localPosition = Vector3.zero; break; case AnchorPosition.Right: transform.localPosition = (Vector3.right * width); break; case AnchorPosition.BottomLeft: transform.localPosition = (Vector3.left * width) + (Vector3.down * height); break; case AnchorPosition.Bottom: transform.localPosition = (Vector3.down * height); break; case AnchorPosition.BottomRight: transform.localPosition = (Vector3.right * width) + (Vector3.down * height); break; default: break; } // Set the name of the object to Anchor and what ever the anchor postion is. name = "Anchor - " + anchorPosition.ToString(); // Then set old postion to the new position. oldPosition = anchorPosition; }
public static Image Crop(Image image, int width, int height, AnchorPosition anchor) { int sourceWidth = image.Width; int sourceHeight = image.Height; int destX = 0; int destY = 0; float percent = 0; float percentWidth = 0; float percentHeight = 0; percentWidth = ((float)width / (float)sourceWidth); percentHeight = ((float)height / (float)sourceHeight); if (percentHeight < percentWidth) { percent = percentWidth; switch (anchor) { case AnchorPosition.Top: destY = 0; break; case AnchorPosition.Bottom: destY = (int)(height - (sourceHeight * percent)); break; default: destY = (int)((height - (sourceHeight * percent)) / 2); break; } } else { percent = percentHeight; switch (anchor) { case AnchorPosition.Left: destX = 0; break; case AnchorPosition.Right: destX = (int)(width - (sourceWidth * percent)); break; default: destX = (int)((width - (sourceWidth * percent)) / 2); break; } } int destWidth = (int)(sourceWidth * percent); int destHeight = (int)(sourceHeight * percent); Size size = new Size(destWidth, destHeight); Bitmap scaledImage = new Bitmap(width, height); scaledImage.SetResolution(image.HorizontalResolution, image.VerticalResolution); Graphics g = Graphics.FromImage(scaledImage); g.InterpolationMode = InterpolationMode.HighQualityBicubic; g.PixelOffsetMode = PixelOffsetMode.HighQuality; g.CompositingQuality = CompositingQuality.HighQuality; g.SmoothingMode = SmoothingMode.HighQuality; g.DrawImage(image, new Rectangle(new Point(destX, destY), size), new Rectangle(new Point(0, 0), image.Size), GraphicsUnit.Pixel); g.Dispose(); return scaledImage; }
/// <summary> /// Funnctions that repositions the anchor based the postion chosen from the enum, through the screen to world point function. /// </summary> void RepositionAnchor() { // If the previous postion of the anchor is equal to the current position of the anchor, return out of the function. if (oldPosition == anchorPosition) return; if (!hudCamera) hudCamera = transform.parent.camera; switch (anchorPosition) { case AnchorPosition.TopLeft: transform.position = hudCamera.ScreenToWorldPoint(new Vector3(0, Screen.height, 0)); break; case AnchorPosition.Top: transform.position = hudCamera.ScreenToWorldPoint(new Vector3(Screen.width / 2, Screen.height, 0)); break; case AnchorPosition.TopRight: transform.position = hudCamera.ScreenToWorldPoint(new Vector3(Screen.width, Screen.height, 0)); break; case AnchorPosition.Left: transform.position = hudCamera.ScreenToWorldPoint(new Vector3(0, Screen.height / 2, 0)); break; case AnchorPosition.Center: transform.position = hudCamera.ScreenToWorldPoint(new Vector3(Screen.width / 2, Screen.height / 2, 0)); break; case AnchorPosition.Right: transform.position = hudCamera.ScreenToWorldPoint(new Vector3(Screen.width, Screen.height / 2, 0)); break; case AnchorPosition.BottomLeft: transform.position = hudCamera.ScreenToWorldPoint(new Vector3(0, 0, 0)); break; case AnchorPosition.Bottom: transform.position = hudCamera.ScreenToWorldPoint(new Vector3(Screen.width / 2, 0, 0)); break; case AnchorPosition.BottomRight: transform.position = hudCamera.ScreenToWorldPoint(new Vector3(Screen.width, 0, 0)); break; default: break; } // Set the name of the object to Anchor and what ever the anchor postion is. name = "Anchor - " + anchorPosition.ToString(); // Then set old postion to the new position. oldPosition = anchorPosition; }
public static Image ImageCrop(Image image, int width, int height, AnchorPosition anchor) { int sourceWidth = image.Width; int sourceHeight = image.Height; int sourceX = 0; int sourceY = 0; int destX = 0; int destY = 0; float nPercent = 0; float nPercentW = 0; float nPercentH = 0; nPercentW = (Convert.ToSingle(width) / Convert.ToSingle(sourceWidth)); nPercentH = (Convert.ToSingle(height) / Convert.ToSingle(sourceHeight)); if (nPercentH < nPercentW) { nPercent = nPercentW; switch (anchor) { case AnchorPosition.Top: destY = 0; break; case AnchorPosition.Bottom: destY = Convert.ToInt32(height - (sourceHeight * nPercent)); break; default: destY = Convert.ToInt32((height - (sourceHeight * nPercent)) / 2); break; } } else { nPercent = nPercentH; switch (anchor) { case AnchorPosition.Left: destX = 0; break; case AnchorPosition.Right: destX = Convert.ToInt32((width - (sourceWidth * nPercent))); break; default: destX = Convert.ToInt32(((width - (sourceWidth * nPercent)) / 2)); break; } } int destWidth = Convert.ToInt32((sourceWidth * nPercent)); int destHeight = Convert.ToInt32((sourceHeight * nPercent)); Bitmap bmPhoto = new Bitmap(width, height, PixelFormat.Format24bppRgb); bmPhoto.SetResolution(image.HorizontalResolution, image.VerticalResolution); Graphics grPhoto = Graphics.FromImage(bmPhoto); grPhoto.InterpolationMode = InterpolationMode.HighQualityBicubic; grPhoto.DrawImage(image, new Rectangle(destX, destY, destWidth, destHeight), new Rectangle(sourceX, sourceY, sourceWidth, sourceHeight), GraphicsUnit.Pixel); grPhoto.Dispose(); return bmPhoto; }
/// <summary> /// The resize image. /// </summary> /// <param name="factory"> /// The the current instance of the <see cref="T:ImageProcessor.ImageFactory"/> class containing /// the image to process. /// </param> /// <param name="width"> /// The width to resize the image to. /// </param> /// <param name="height"> /// The height to resize the image to. /// </param> /// <param name="defaultMaxWidth"> /// The default max width to resize the image to. /// </param> /// <param name="defaultMaxHeight"> /// The default max height to resize the image to. /// </param> /// <param name="backgroundColor"> /// The background color to pad the image with. /// </param> /// <param name="resizeMode"> /// The mode with which to resize the image. /// </param> /// <param name="anchorPosition"> /// The anchor position to place the image at. /// </param> /// <param name="upscale"> /// Whether to allow up-scaling of images. (Default true) /// </param> /// <returns> /// The processed image from the current instance of the <see cref="T:ImageProcessor.ImageFactory"/> class. /// </returns> private Image ResizeImage( ImageFactory factory, int width, int height, int defaultMaxWidth, int defaultMaxHeight, Color backgroundColor, ResizeMode resizeMode = ResizeMode.Pad, AnchorPosition anchorPosition = AnchorPosition.Center, bool upscale = true) { Bitmap newImage = null; Image image = factory.Image; try { int sourceWidth = image.Width; int sourceHeight = image.Height; int destinationWidth = width; int destinationHeight = height; int maxWidth = defaultMaxWidth > 0 ? defaultMaxWidth : int.MaxValue; int maxHeight = defaultMaxHeight > 0 ? defaultMaxHeight : int.MaxValue; // Fractional variants for preserving aspect ratio. double percentHeight = Math.Abs(height / (double)sourceHeight); double percentWidth = Math.Abs(width / (double)sourceWidth); int destinationX = 0; int destinationY = 0; // Change the destination rectangle coordinates if padding and // there has been a set width and height. if (resizeMode == ResizeMode.Pad && width > 0 && height > 0) { double ratio; if (percentHeight < percentWidth) { ratio = percentHeight; destinationX = (int)((width - (sourceWidth * ratio)) / 2); destinationWidth = (int)Math.Ceiling(sourceWidth * percentHeight); } else { ratio = percentWidth; destinationY = (int)((height - (sourceHeight * ratio)) / 2); destinationHeight = (int)Math.Ceiling(sourceHeight * percentWidth); } } // Change the destination rectangle coordinates if cropping and // there has been a set width and height. if (resizeMode == ResizeMode.Crop && width > 0 && height > 0) { double ratio; if (percentHeight < percentWidth) { ratio = percentWidth; switch (anchorPosition) { case AnchorPosition.Top: destinationY = 0; break; case AnchorPosition.Bottom: destinationY = (int)(height - (sourceHeight * ratio)); break; default: destinationY = (int)((height - (sourceHeight * ratio)) / 2); break; } destinationHeight = (int)Math.Ceiling(sourceHeight * percentWidth); } else { ratio = percentHeight; switch (anchorPosition) { case AnchorPosition.Left: destinationX = 0; break; case AnchorPosition.Right: destinationX = (int)(width - (sourceWidth * ratio)); break; default: destinationX = (int)((width - (sourceWidth * ratio)) / 2); break; } destinationWidth = (int)Math.Ceiling(sourceWidth * percentHeight); } } // Constrain the image to fit the maximum possible height or width. if (resizeMode == ResizeMode.Max) { if (sourceWidth > width || sourceHeight > height) { double ratio = Math.Abs(height / width); double sourceRatio = Math.Abs(sourceHeight / sourceWidth); if (sourceRatio < ratio) { height = 0; } else { width = 0; } } } // If height or width is not passed we assume that the standard ratio is to be kept. if (height == 0) { destinationHeight = (int)Math.Ceiling(sourceHeight * percentWidth); height = destinationHeight; } if (width == 0) { destinationWidth = (int)Math.Ceiling(sourceWidth * percentHeight); width = destinationWidth; } if (width > 0 && height > 0 && width <= maxWidth && height <= maxHeight) { // Exit if upscaling is not allowed. if ((width > sourceWidth || height > sourceHeight) && upscale == false && resizeMode != ResizeMode.Stretch) { return image; } newImage = new Bitmap(width, height, PixelFormat.Format32bppPArgb); using (Graphics graphics = Graphics.FromImage(newImage)) { // We want to use two different blending algorithms for enlargement/shrinking. // Bicubic is better enlarging for whilst Bilinear is better for shrinking. // http://www.codinghorror.com/blog/2007/07/better-image-resizing.html if (image.Width < destinationWidth && image.Height < destinationHeight) { // We are making it larger. graphics.SmoothingMode = SmoothingMode.AntiAlias; graphics.InterpolationMode = InterpolationMode.HighQualityBicubic; graphics.PixelOffsetMode = PixelOffsetMode.HighQuality; graphics.CompositingQuality = CompositingQuality.HighQuality; } else { // We are making it smaller. graphics.SmoothingMode = SmoothingMode.None; graphics.InterpolationMode = InterpolationMode.HighQualityBilinear; graphics.PixelOffsetMode = PixelOffsetMode.HighQuality; graphics.CompositingQuality = CompositingQuality.HighQuality; } // An unwanted border appears when using InterpolationMode.HighQualityBicubic to resize the image // as the algorithm appears to be pulling averaging detail from surCeilinging pixels beyond the edge // of the image. Using the ImageAttributes class to specify that the pixels beyond are simply mirror // images of the pixels within solves this problem. using (ImageAttributes wrapMode = new ImageAttributes()) { wrapMode.SetWrapMode(WrapMode.TileFlipXY); graphics.Clear(backgroundColor); Rectangle destRect = new Rectangle(destinationX, destinationY, destinationWidth, destinationHeight); graphics.DrawImage(image, destRect, 0, 0, sourceWidth, sourceHeight, GraphicsUnit.Pixel, wrapMode); } // Reassign the image. image.Dispose(); image = newImage; } } } catch { if (newImage != null) { newImage.Dispose(); } } return image; }
/// <summary> /// Resizes the given image. /// </summary> /// <param name="source"> /// The source <see cref="Image"/> to resize /// </param> /// <param name="width"> /// The width to resize the image to. /// </param> /// <param name="height"> /// The height to resize the image to. /// </param> /// <param name="maxWidth"> /// The default max width to resize the image to. /// </param> /// <param name="maxHeight"> /// The default max height to resize the image to. /// </param> /// <param name="restrictedSizes"> /// A <see cref="List{T}"/> containing image resizing restrictions. /// </param> /// <param name="resizeMode"> /// The mode with which to resize the image. /// </param> /// <param name="anchorPosition"> /// The anchor position to place the image at. /// </param> /// <param name="upscale"> /// Whether to allow up-scaling of images. (Default true) /// </param> /// <param name="centerCoordinates"> /// If the resize mode is crop, you can set a specific center coordinate, use as alternative to anchorPosition /// </param> /// <returns> /// The resized <see cref="Image"/>. /// </returns> private Bitmap ResizeImage( Image source, int width, int height, int maxWidth, int maxHeight, List<Size> restrictedSizes, ResizeMode resizeMode = ResizeMode.Pad, AnchorPosition anchorPosition = AnchorPosition.Center, bool upscale = true, float[] centerCoordinates = null) { Bitmap newImage = null; try { int sourceWidth = source.Width; int sourceHeight = source.Height; int destinationWidth = width; int destinationHeight = height; maxWidth = maxWidth > 0 ? maxWidth : int.MaxValue; maxHeight = maxHeight > 0 ? maxHeight : int.MaxValue; // Fractional variants for preserving aspect ratio. double percentHeight = Math.Abs(height / (double)sourceHeight); double percentWidth = Math.Abs(width / (double)sourceWidth); int destinationX = 0; int destinationY = 0; // Change the destination rectangle coordinates if padding and // there has been a set width and height. if (resizeMode == ResizeMode.Pad && width > 0 && height > 0) { double ratio; if (percentHeight < percentWidth) { ratio = percentHeight; destinationWidth = Convert.ToInt32(sourceWidth * percentHeight); switch (anchorPosition) { case AnchorPosition.Left: destinationX = 0; break; case AnchorPosition.Right: destinationX = (int)(width - (sourceWidth * ratio)); break; default: destinationX = Convert.ToInt32((width - (sourceWidth * ratio)) / 2); break; } } else { ratio = percentWidth; destinationHeight = Convert.ToInt32(sourceHeight * percentWidth); switch (anchorPosition) { case AnchorPosition.Top: destinationY = 0; break; case AnchorPosition.Bottom: destinationY = (int)(height - (sourceHeight * ratio)); break; default: destinationY = (int)((height - (sourceHeight * ratio)) / 2); break; } } } // Change the destination rectangle coordinates if cropping and // there has been a set width and height. if (resizeMode == ResizeMode.Crop && width > 0 && height > 0) { double ratio; if (percentHeight < percentWidth) { ratio = percentWidth; if (centerCoordinates != null && centerCoordinates.Any()) { double center = -(ratio * sourceHeight) * centerCoordinates[0]; destinationY = (int)center + (height / 2); if (destinationY > 0) { destinationY = 0; } if (destinationY < (int)(height - (sourceHeight * ratio))) { destinationY = (int)(height - (sourceHeight * ratio)); } } else { switch (anchorPosition) { case AnchorPosition.Top: destinationY = 0; break; case AnchorPosition.Bottom: destinationY = (int)(height - (sourceHeight * ratio)); break; default: destinationY = (int)((height - (sourceHeight * ratio)) / 2); break; } } destinationHeight = (int)Math.Ceiling(sourceHeight * percentWidth); } else { ratio = percentHeight; if (centerCoordinates != null && centerCoordinates.Any()) { double center = -(ratio * sourceWidth) * centerCoordinates[1]; destinationX = (int)center + (width / 2); if (destinationX > 0) { destinationX = 0; } if (destinationX < (int)(width - (sourceWidth * ratio))) { destinationX = (int)(width - (sourceWidth * ratio)); } } else { switch (anchorPosition) { case AnchorPosition.Left: destinationX = 0; break; case AnchorPosition.Right: destinationX = (int)(width - (sourceWidth * ratio)); break; default: destinationX = (int)((width - (sourceWidth * ratio)) / 2); break; } } destinationWidth = (int)Math.Ceiling(sourceWidth * percentHeight); } } // Constrain the image to fit the maximum possible height or width. if (resizeMode == ResizeMode.Max) { // If either is 0, we don't need to figure out orientation if (width > 0 && height > 0) { // Integers must be cast to doubles to get needed precision double ratio = (double)height / width; double sourceRatio = (double)sourceHeight / sourceWidth; if (sourceRatio < ratio) { height = 0; } else { width = 0; } } } // If height or width is not passed we assume that the standard ratio is to be kept. if (height == 0) { destinationHeight = Convert.ToInt32(sourceHeight * percentWidth); height = destinationHeight; } if (width == 0) { destinationWidth = Convert.ToInt32(sourceWidth * percentHeight); width = destinationWidth; } // Restrict sizes if (restrictedSizes != null && restrictedSizes.Any()) { bool reject = true; foreach (Size restrictedSize in restrictedSizes) { if (restrictedSize.Height == 0 || restrictedSize.Width == 0) { if (restrictedSize.Width == width || restrictedSize.Height == height) { reject = false; } } else if (restrictedSize.Width == width && restrictedSize.Height == height) { reject = false; } } if (reject) { return (Bitmap)source; } } if (width > 0 && height > 0 && width <= maxWidth && height <= maxHeight) { // Exit if upscaling is not allowed. if ((width > sourceWidth || height > sourceHeight) && upscale == false && resizeMode != ResizeMode.Stretch) { return (Bitmap)source; } newImage = new Bitmap(width, height); newImage.SetResolution(source.HorizontalResolution, source.VerticalResolution); using (Graphics graphics = Graphics.FromImage(newImage)) { // We want to use two different blending algorithms for enlargement/shrinking. if (source.Width < destinationWidth && source.Height < destinationHeight) { // We are making it larger. graphics.SmoothingMode = SmoothingMode.AntiAlias; } else { // We are making it smaller. graphics.SmoothingMode = SmoothingMode.None; } graphics.InterpolationMode = InterpolationMode.HighQualityBicubic; graphics.PixelOffsetMode = PixelOffsetMode.HighQuality; graphics.CompositingQuality = CompositingQuality.HighQuality; // An unwanted border appears when using InterpolationMode.HighQualityBicubic to resize the image // as the algorithm appears to be pulling averaging detail from surrounding pixels beyond the edge // of the image. Using the ImageAttributes class to specify that the pixels beyond are simply mirror // images of the pixels within solves this problem. using (ImageAttributes wrapMode = new ImageAttributes()) { wrapMode.SetWrapMode(WrapMode.TileFlipXY); Rectangle destinationRectangle = new Rectangle(destinationX, destinationY, destinationWidth, destinationHeight); graphics.DrawImage(source, destinationRectangle, 0, 0, sourceWidth, sourceHeight, GraphicsUnit.Pixel, wrapMode); } // Reassign the image. source.Dispose(); source = newImage; } } } catch (Exception ex) { if (newImage != null) { newImage.Dispose(); } throw new ImageProcessingException("Error processing image with " + this.GetType().Name, ex); } return (Bitmap)source; }
public static Image Crop(Image imgPhoto, int Width, int Height, AnchorPosition Anchor) { int sourceWidth = imgPhoto.Width; int sourceHeight = imgPhoto.Height; int sourceX = 0; int sourceY = 0; int destX = 0; int destY = 0; float nPercent = 0; float nPercentW = 0; float nPercentH = 0; nPercentW = ((float)Width / (float)sourceWidth); nPercentH = ((float)Height / (float)sourceHeight); if(nPercentH < nPercentW) { nPercent = nPercentW; switch(Anchor) { case AnchorPosition.Top: destY = 0; break; case AnchorPosition.Bottom: destY = (int) (Height - (sourceHeight * nPercent)); break; default: destY = (int) ((Height - (sourceHeight * nPercent)) / 2); break; } } else { nPercent = nPercentH; switch(Anchor) { case AnchorPosition.Left: destX = 0; break; case AnchorPosition.Right: destX = (int) (Width - (sourceWidth * nPercent)); break; default: destX = (int) ((Width - (sourceWidth * nPercent)) / 2); break; } } int destWidth = (int)(sourceWidth * nPercent); int destHeight = (int)(sourceHeight * nPercent); Bitmap bmPhoto = new Bitmap(Width, Height, PixelFormat.Format24bppRgb); bmPhoto.SetResolution(imgPhoto.HorizontalResolution, imgPhoto.VerticalResolution); Graphics grPhoto = Graphics.FromImage(bmPhoto); grPhoto.InterpolationMode = InterpolationMode.HighQualityBicubic; grPhoto.DrawImage(imgPhoto, new Rectangle(destX, destY, destWidth, destHeight), new Rectangle(sourceX, sourceY, sourceWidth, sourceHeight), GraphicsUnit.Pixel); grPhoto.Dispose(); return bmPhoto; }
public static Image Crop(Image img, int width, int height, AnchorPosition Anchor) { if (img == null) return null; int sourceWidth = img.Width; int sourceHeight = img.Height; int sourceX = 0; int sourceY = 0; int destX = 0; int destY = 0; float nPercent = 0; float nPercentW = 0; float nPercentH = 0; nPercentW = ((float)width / (float)sourceWidth); nPercentH = ((float)height / (float)sourceHeight); if (nPercentH < nPercentW) { nPercent = nPercentW; switch (Anchor) { case AnchorPosition.Top: destY = 0; break; case AnchorPosition.Bottom: destY = (int)(height - (sourceHeight * nPercent)); break; default: destY = (int)((height - (sourceHeight * nPercent)) / 2); break; } } else { nPercent = nPercentH; switch (Anchor) { case AnchorPosition.Left: destX = 0; break; case AnchorPosition.Right: destX = (int)(width - (sourceWidth * nPercent)); break; default: destX = (int)((width - (sourceWidth * nPercent)) / 2); break; } } int destWidth = (int)(sourceWidth * nPercent); int destHeight = (int)(sourceHeight * nPercent); Bitmap bmPhoto = new Bitmap(width, height, PixelFormat.Format24bppRgb); bmPhoto.SetResolution(img.HorizontalResolution, img.VerticalResolution); Graphics grPhoto = Graphics.FromImage(bmPhoto); grPhoto.Clear(Color.White); //grPhoto.SmoothingMode = SmoothingMode.AntiAlias; grPhoto.SmoothingMode = SmoothingMode.HighSpeed; grPhoto.CompositingQuality = CompositingQuality.HighQuality; grPhoto.InterpolationMode = InterpolationMode.HighQualityBicubic; //grPhoto.TextRenderingHint = TextRenderingHint.AntiAlias; Rectangle destRec = new Rectangle(destX, destY, destWidth, destHeight); Rectangle sourceRec = new Rectangle(sourceX, sourceY, sourceWidth, sourceHeight); grPhoto.DrawImage(img, destRec, sourceRec, GraphicsUnit.Pixel); grPhoto.Dispose(); //Quantizer //OctreeQuantizer quantizer = new OctreeQuantizer(255, 8); //bmPhoto = quantizer.Quantize(bmPhoto); return bmPhoto; }
public static System.Drawing.Image ImageCrop(string imgURL, int Width, int Height, AnchorPosition Anchor) { try { Bitmap b; //try //{ WebClient wc = new WebClient(); byte[] img = wc.DownloadData(imgURL); MemoryStream imgStream = new MemoryStream(img); b = (Bitmap)System.Drawing.Image.FromStream(imgStream); //} //catch (Exception ex1) //{ //b = (Bitmap)System.Drawing.Image.FromFile(HttpContext.Current.Server.MapPath(imgURL.Replace("http://", ""))); //} return ImageCrop(b, Width, Height, Anchor); } catch (Exception ex) { } Bitmap bm = new Bitmap(Width, Height); Graphics g = Graphics.FromImage(bm); g.FillRectangle(new SolidBrush(Color.Black), 0, 0, (float)Width, (float)Height); g.Dispose(); return bm; }
private Bitmap crop(Image image, int width, int height, AnchorPosition Anchor) { var sourceWidth = image.Width; var sourceHeight = image.Height; var sourceX = 0; var sourceY = 0; var destX = 0; var destY = 0; float nPercent; float nPercentW; float nPercentH; nPercentW = (width / (float)sourceWidth); nPercentH = (height / (float)sourceHeight); if (nPercentH < nPercentW) { nPercent = nPercentW; switch (Anchor) { case AnchorPosition.Top: destY = 0; break; case AnchorPosition.Bottom: destY = (int)(height - Math.Round(sourceHeight * nPercent)); break; default: destY = (int)((height - Math.Round(sourceHeight * nPercent)) / 2); break; } } else { nPercent = nPercentH; switch (Anchor) { case AnchorPosition.Left: destX = 0; break; case AnchorPosition.Right: destX = (int)(width - Math.Round(sourceWidth * nPercent)); break; default: destX = (int)((width - Math.Round(sourceWidth * nPercent)) / 2); break; } } var destWidth = (int)Math.Round(sourceWidth * nPercent); var destHeight = (int)Math.Round(sourceHeight * nPercent); var bmPhoto = new Bitmap(width, height, PixelFormat.Format24bppRgb); bmPhoto.SetResolution(image.HorizontalResolution, image.VerticalResolution); var grPhoto = Graphics.FromImage(bmPhoto); grPhoto.Clear(Utilities.BackgroundColour); grPhoto.PixelOffsetMode = PixelOffsetMode.HighQuality; grPhoto.CompositingQuality = CompositingQuality.HighQuality; grPhoto.InterpolationMode = InterpolationMode.HighQualityBicubic; grPhoto.CompositingMode = CompositingMode.SourceCopy; var imageAttributes = new ImageAttributes(); imageAttributes.SetWrapMode(WrapMode.TileFlipXY); grPhoto.DrawImage(image, new Rectangle(destX, destY, destWidth, destHeight), sourceX, sourceY, sourceWidth, sourceHeight, GraphicsUnit.Pixel, imageAttributes); grPhoto.Dispose(); return bmPhoto; }
public byte[] GetCached(string relativeFilePath, int width, int height, ImageMod imageMod, string hexBackgroundColour, AnchorPosition? anchor, OutputFormat outputFormat) { var key = string.Format("ImageManager-{0}-{1}-{2}-{3}-{4}", relativeFilePath, width, height, imageMod, outputFormat); if (Context.Cache[key] == null) { var image = Get(relativeFilePath, width, height, imageMod, hexBackgroundColour, anchor, outputFormat); if (image == null) throw new FileNotFoundException("The image requested does not exist."); Context.Cache.Insert(key, image, null, Cache.NoAbsoluteExpiration, Configs.CacheExpiration); } return (byte[])Context.Cache[key]; }
public Image Crop(Image imgPhoto, int Width, int Height, AnchorPosition Anchor) { int sourceWidth = imgPhoto.Width; int sourceHeight = imgPhoto.Height; int sourceX = 0; int sourceY = 0; int destX = 0; int destY = 0; float nPercent = 0; float nPercentW = 0; float nPercentH = 0; nPercentW = ((float)Width / (float)sourceWidth); nPercentH = ((float)Height / (float)sourceHeight); if (nPercentH < nPercentW) { nPercent = nPercentW; switch (Anchor) { case AnchorPosition.Top: destY = 0; break; case AnchorPosition.Bottom: destY = (int)(Height - (sourceHeight * nPercent)); break; default: destY = (int)((Height - (sourceHeight * nPercent)) / 3); break; } } else { nPercent = nPercentH; switch (Anchor) { case AnchorPosition.Left: destX = 0; break; case AnchorPosition.Right: destX = (int)(Width - (sourceWidth * nPercent)); break; default: destX = (int)((Width - (sourceWidth * nPercent)) / 2); break; } } int destWidth = (int)(sourceWidth * nPercent); int destHeight = (int)(sourceHeight * nPercent); Bitmap bmPhoto = new Bitmap(Width, Height, PixelFormat.Format32bppArgb); bmPhoto.SetResolution(imgPhoto.HorizontalResolution, imgPhoto.VerticalResolution); Graphics grPhoto = Graphics.FromImage(bmPhoto); //grPhoto.Clear(Color.White); grPhoto.SmoothingMode = SmoothingMode.HighQuality; grPhoto.InterpolationMode = InterpolationMode.HighQualityBilinear; grPhoto.CompositingQuality = CompositingQuality.HighQuality; grPhoto.PixelOffsetMode = PixelOffsetMode.HighQuality; grPhoto.DrawImage(imgPhoto, new Rectangle(destX - 2, destY - 2, destWidth + 4, destHeight + 4), new Rectangle(sourceX, sourceY, sourceWidth, sourceHeight), GraphicsUnit.Pixel); grPhoto.Dispose(); //OnSharpen //if (Width < 168) //{ // BitmapFilter.Sharpen(bmPhoto, 14); //} return bmPhoto; }
public Stream Get(Stream file, int width, int height, ImageMod imageMod, string hexBackgroundColour, AnchorPosition? anchor, OutputFormat outputFormat) { return ResizeUtility.Get(loadImage(file) ?? getDefault(width, height), width, height, imageMod, hexBackgroundColour, anchor).GetStream(outputFormat); }
/// <summary> /// Resizes the image to a certain width and height. It will crop the image whenever necessary. The module will not perform /// any image resizing if both width and height are set to <c>null</c>. If the source image is smaller than the specified /// width and height, the image will be enlarged. /// </summary> /// <param name="width">The desired width. If set to <c>null</c> or <c>0</c>, the image will be resized to its height.</param> /// <param name="height">The desired height. If set to <c>null</c> or <c>0</c>, the image will be resized to its width.</param> /// <param name="anchor">The anchor position to use for cropping (if necessary). The available values are: /// <list type="bullet"> /// <item><description>AnchorPosition.Center</description></item> /// <item><description>AnchorPosition.Top</description></item> /// <item><description>AnchorPosition.Bottom</description></item> /// <item><description>AnchorPosition.Left</description></item> /// <item><description>AnchorPosition.Right</description></item> /// <item><description>AnchorPosition.TopLeft</description></item> /// <item><description>AnchorPosition.TopRight</description></item> /// <item><description>AnchorPosition.BottomLeft</description></item> /// <item><description>AnchorPosition.BottomRight</description></item> /// </list> /// </param> public Image Resize(int? width, int? height, AnchorPosition anchor = AnchorPosition.Center) { EnsureCurrentInstruction(); _currentInstruction.Width = width; _currentInstruction.Height = height; _currentInstruction.AnchorPosition = anchor; return this; }
protected Image Crop(Image imgPhoto, int Width, int Height, AnchorPosition Anchor, int HorizontalRuler, int VerticalRuler, string Text, int TextHeight, int FontSize) { int sourceWidth = imgPhoto.Width; int sourceHeight = imgPhoto.Height; int sourceX = 0; int sourceY = 0; int destX = 0; int destY = 0; float nPercent = 0; float nPercentW = 0; float nPercentH = 0; nPercentW = ((float)Width / (float)sourceWidth); nPercentH = ((float)Height / (float)sourceHeight); sourceWidth = (nPercentW <= 0.25) ? (int)(sourceWidth * 0.75) : sourceWidth; sourceHeight = (nPercentH <= 0.25) ? (int)(sourceHeight * 0.75) : sourceHeight; nPercentW = ((float)Width / (float)sourceWidth); nPercentH = ((float)Height / (float)sourceHeight); if (nPercentW > 1) { nPercentW = 1; Width = sourceWidth; } if (nPercentH > 1) { nPercentH = 1; Height = sourceHeight; } if (nPercentH < nPercentW) { nPercent = nPercentW; if (nPercent != 1.0) { switch (Anchor) { case AnchorPosition.Top: destY = 0; break; case AnchorPosition.Bottom: destY = (int) (Height - (sourceHeight * nPercent)); break; default: destY = (int) ((Height - (sourceHeight * nPercent)) / 2); destX = -(int) ((Width - (sourceWidth * nPercentH)) / 2); break; } } } else { nPercent = nPercentH; if (nPercent != 1.0) { switch (Anchor) { case AnchorPosition.Left: destX = 0; break; case AnchorPosition.Right: destX = (int) (Width - (sourceWidth * nPercent)); break; default: destX = (int) ((Width - (sourceWidth * nPercent)) / 2); destY = -(int) ((Height - (sourceHeight * nPercentW)) / 2); break; } } } int destWidth = (int)(sourceWidth * nPercent); int destHeight = (int)(sourceHeight * nPercent); if (nPercent == nPercentW) { destWidth -= destX; } else { destHeight -= destY; } Bitmap bmPhoto = new Bitmap(Width, Height, PixelFormat.Format24bppRgb); bmPhoto.SetResolution(imgPhoto.HorizontalResolution, imgPhoto.VerticalResolution); Graphics grPhoto = Graphics.FromImage(bmPhoto); grPhoto.Clear(Color.White); grPhoto.InterpolationMode = InterpolationMode.HighQualityBicubic; grPhoto.DrawImage(imgPhoto, new Rectangle(destX, destY, destWidth, destHeight), new Rectangle(sourceX, sourceY, sourceWidth, sourceHeight), GraphicsUnit.Pixel); Pen pen = new Pen(Color.White); pen.Width = 1.5F; grPhoto.DrawImage(imgPhoto, new Rectangle(destX, destY, destWidth, destHeight), new Rectangle(sourceX, sourceY, sourceWidth, sourceHeight), GraphicsUnit.Pixel); if (Text.Length > 0) { StringFormat sf = new StringFormat(); Font font = new Font("Arial", FontSize, FontStyle.Bold); Rectangle rect = new Rectangle(); Color customColor = Color.FromArgb(140, Color.Black); SolidBrush brush = new SolidBrush(customColor); rect.X = 0; rect.Y = Height - TextHeight; rect.Width = Width; rect.Height = TextHeight; sf.LineAlignment = StringAlignment.Center; sf.Alignment = StringAlignment.Center; grPhoto.FillRectangle(brush, rect); grPhoto.DrawString("\"" + Text + "\"", font, Brushes.White, rect, sf); } if (VerticalRuler > 0) grPhoto.DrawLine(pen, Width / 2, 0, Width / 2, Height); if (HorizontalRuler > 0) grPhoto.DrawLine(pen, 0, Height / 2, Width, Height / 2); grPhoto.Dispose(); return bmPhoto; }
public static Image Crop(Image imgPhoto, int width, int height, AnchorPosition anchor) { int sourceWidth = imgPhoto.Width; int sourceHeight = imgPhoto.Height; const int sourceX = 0; const int sourceY = 0; int destX = -1; int destY = -1; double nPercent; double nPercentW = (width / (double)sourceWidth); double nPercentH = (height / (double)sourceHeight); if (nPercentH < nPercentW) { nPercent = nPercentW; switch (anchor) { case AnchorPosition.Top: destY = 0; break; case AnchorPosition.Bottom: destY = (int)(height - (sourceHeight * nPercent)); break; default: destY = (int)((height - (sourceHeight * nPercent)) / 2); break; } } else { nPercent = nPercentH; switch (anchor) { case AnchorPosition.Left: destX = 0; break; case AnchorPosition.Right: destX = (int)(width - (sourceWidth * nPercent)); break; default: destX = (int)((width - (sourceWidth * nPercent)) / 2); break; } } var destWidth = (int)(sourceWidth * nPercent); var destHeight = (int)(sourceHeight * nPercent); var bmPhoto = new Bitmap(width, height, PixelFormat.Format24bppRgb); bmPhoto.SetResolution(imgPhoto.HorizontalResolution, imgPhoto.VerticalResolution); Graphics grPhoto = Graphics.FromImage(bmPhoto); grPhoto.InterpolationMode = InterpolationMode.HighQualityBicubic; grPhoto.DrawImage(imgPhoto, new Rectangle(destX, destY, destWidth + 2, destHeight + 2), new Rectangle(sourceX, sourceY, sourceWidth, sourceHeight), GraphicsUnit.Pixel); grPhoto.Dispose(); return bmPhoto; }
/// <summary> /// Initializes a new instance of the <see cref="ResizeLayer"/> class. /// </summary> /// <param name="backgroundColor"> /// The <see cref="T:System.Drawing.Color"/> to set as the background color. /// <remarks>Used for image formats that do not support transparency</remarks> /// </param> /// <param name="resizeMode"> /// The resize mode to apply to resized image. /// </param> /// <param name="anchorPosition"> /// The <see cref="AnchorPosition"/> to apply to resized image. /// </param> public ResizeLayer(Color backgroundColor, ResizeMode resizeMode = ResizeMode.Pad, AnchorPosition anchorPosition = AnchorPosition.Center) { this.BackgroundColor = backgroundColor; this.ResizeMode = resizeMode; this.AnchorPosition = anchorPosition; }
/// <summary> /// Resizes the given image. /// </summary> /// <param name="source">The source <see cref="Image"/> to resize</param> /// <param name="width">The width to resize the image to.</param> /// <param name="height">The height to resize the image to.</param> /// <param name="maxWidth">The default max width to resize the image to.</param> /// <param name="maxHeight">The default max height to resize the image to.</param> /// <param name="restrictedSizes">A <see cref="List{T}"/> containing image resizing restrictions.</param> /// <param name="resizeMode">The mode with which to resize the image.</param> /// <param name="anchorPosition">The anchor position to place the image at.</param> /// <param name="upscale">Whether to allow up-scaling of images. (Default true)</param> /// <param name="centerCoordinates"> /// If the resize mode is crop, you can set a specific center coordinate, use as alternative to anchorPosition /// </param> /// <param name="linear">Whether to resize the image using the linear color space.</param> /// <returns> /// The resized <see cref="Image"/>. /// </returns> private Bitmap ResizeImage( Image source, int width, int height, int maxWidth, int maxHeight, List<Size> restrictedSizes, ResizeMode resizeMode = ResizeMode.Pad, AnchorPosition anchorPosition = AnchorPosition.Center, bool upscale = true, float[] centerCoordinates = null, bool linear = false) { Bitmap newImage = null; try { int sourceWidth = source.Width; int sourceHeight = source.Height; int destinationWidth = width; int destinationHeight = height; maxWidth = maxWidth > 0 ? maxWidth : int.MaxValue; maxHeight = maxHeight > 0 ? maxHeight : int.MaxValue; // Fractional variants for preserving aspect ratio. double percentHeight = Math.Abs(height / (double)sourceHeight); double percentWidth = Math.Abs(width / (double)sourceWidth); int destinationX = 0; int destinationY = 0; // Change the destination rectangle coordinates if box padding. if (resizeMode == ResizeMode.BoxPad) { height = height > 0 ? height : Convert.ToInt32(sourceHeight * percentWidth); width = width > 0 ? width : Convert.ToInt32(sourceWidth * percentHeight); // Only calculate if upscaling. if (sourceWidth < width || sourceHeight < height) { destinationWidth = sourceWidth; destinationHeight = sourceHeight; upscale = true; switch (anchorPosition) { case AnchorPosition.Left: destinationY = (height - sourceHeight) / 2; destinationX = 0; break; case AnchorPosition.Right: destinationY = (height - sourceHeight) / 2; destinationX = width - sourceWidth; break; case AnchorPosition.TopRight: destinationY = 0; destinationX = width - sourceWidth; break; case AnchorPosition.Top: destinationY = 0; destinationX = (width - sourceWidth) / 2; break; case AnchorPosition.TopLeft: destinationY = 0; destinationX = 0; break; case AnchorPosition.BottomRight: destinationY = height - sourceHeight; destinationX = width - sourceWidth; break; case AnchorPosition.Bottom: destinationY = height - sourceHeight; destinationX = (width - sourceWidth) / 2; break; case AnchorPosition.BottomLeft: destinationY = height - sourceHeight; destinationX = 0; break; default: destinationY = (height - sourceHeight) / 2; destinationX = (width - sourceWidth) / 2; break; } } else { // Switch to pad mode to downscale and calculate from there. resizeMode = ResizeMode.Pad; } } // Change the destination rectangle coordinates if padding and // there has been a set width and height. if (resizeMode == ResizeMode.Pad && width > 0 && height > 0) { double ratio; if (percentHeight < percentWidth) { ratio = percentHeight; destinationWidth = Convert.ToInt32(sourceWidth * percentHeight); switch (anchorPosition) { case AnchorPosition.Left: case AnchorPosition.TopLeft: case AnchorPosition.BottomLeft: destinationX = 0; break; case AnchorPosition.Right: case AnchorPosition.TopRight: case AnchorPosition.BottomRight: destinationX = (int)(width - (sourceWidth * ratio)); break; default: destinationX = Convert.ToInt32((width - (sourceWidth * ratio)) / 2); break; } } else { ratio = percentWidth; destinationHeight = Convert.ToInt32(sourceHeight * percentWidth); switch (anchorPosition) { case AnchorPosition.Top: case AnchorPosition.TopLeft: case AnchorPosition.TopRight: destinationY = 0; break; case AnchorPosition.Bottom: case AnchorPosition.BottomLeft: case AnchorPosition.BottomRight: destinationY = (int)(height - (sourceHeight * ratio)); break; default: destinationY = (int)((height - (sourceHeight * ratio)) / 2); break; } } } // Change the destination rectangle coordinates if cropping and // there has been a set width and height. if (resizeMode == ResizeMode.Crop && width > 0 && height > 0) { double ratio; if (percentHeight < percentWidth) { ratio = percentWidth; if (centerCoordinates != null && centerCoordinates.Any()) { double center = -(ratio * sourceHeight) * centerCoordinates[0]; destinationY = (int)center + (height / 2); if (destinationY > 0) { destinationY = 0; } if (destinationY < (int)(height - (sourceHeight * ratio))) { destinationY = (int)(height - (sourceHeight * ratio)); } } else { switch (anchorPosition) { case AnchorPosition.Top: case AnchorPosition.TopLeft: case AnchorPosition.TopRight: destinationY = 0; break; case AnchorPosition.Bottom: case AnchorPosition.BottomLeft: case AnchorPosition.BottomRight: destinationY = (int)(height - (sourceHeight * ratio)); break; default: destinationY = (int)((height - (sourceHeight * ratio)) / 2); break; } } destinationHeight = (int)Math.Ceiling(sourceHeight * percentWidth); } else { ratio = percentHeight; if (centerCoordinates != null && centerCoordinates.Any()) { double center = -(ratio * sourceWidth) * centerCoordinates[1]; destinationX = (int)center + (width / 2); if (destinationX > 0) { destinationX = 0; } if (destinationX < (int)(width - (sourceWidth * ratio))) { destinationX = (int)(width - (sourceWidth * ratio)); } } else { switch (anchorPosition) { case AnchorPosition.Left: case AnchorPosition.TopLeft: case AnchorPosition.BottomLeft: destinationX = 0; break; case AnchorPosition.Right: case AnchorPosition.TopRight: case AnchorPosition.BottomRight: destinationX = (int)(width - (sourceWidth * ratio)); break; default: destinationX = (int)((width - (sourceWidth * ratio)) / 2); break; } } destinationWidth = (int)Math.Ceiling(sourceWidth * percentHeight); } } // Constrain the image to fit the maximum possible height or width. if (resizeMode == ResizeMode.Max) { // If either is 0, we don't need to figure out orientation if (width > 0 && height > 0) { // Integers must be cast to doubles to get needed precision double ratio = (double)height / width; double sourceRatio = (double)sourceHeight / sourceWidth; if (sourceRatio < ratio) { height = 0; } else { width = 0; } } } // Resize the image until the shortest side reaches the set given dimension. if (resizeMode == ResizeMode.Min) { height = height > 0 ? height : Convert.ToInt32(sourceHeight * percentWidth); width = width > 0 ? width : Convert.ToInt32(sourceWidth * percentHeight); double sourceRatio = (double)sourceHeight / sourceWidth; // Ensure we can't upscale. maxHeight = sourceHeight; maxWidth = sourceWidth; upscale = false; // Find the shortest distance to go. int widthDiff = sourceWidth - width; int heightDiff = sourceHeight - height; if (widthDiff < heightDiff) { destinationHeight = Convert.ToInt32(width * sourceRatio); height = destinationHeight; destinationWidth = width; } else if (widthDiff > heightDiff) { destinationHeight = height; destinationWidth = Convert.ToInt32(height / sourceRatio); width = destinationWidth; } else { destinationWidth = width; destinationHeight = height; } } // If height or width is not passed we assume that the standard ratio is to be kept. if (height == 0) { destinationHeight = Convert.ToInt32(sourceHeight * percentWidth); height = destinationHeight; } if (width == 0) { destinationWidth = Convert.ToInt32(sourceWidth * percentHeight); width = destinationWidth; } // Restrict sizes if (restrictedSizes != null && restrictedSizes.Any()) { bool reject = true; foreach (Size restrictedSize in restrictedSizes) { if (restrictedSize.Height == 0 || restrictedSize.Width == 0) { if (restrictedSize.Width == width || restrictedSize.Height == height) { reject = false; } } else if (restrictedSize.Width == width && restrictedSize.Height == height) { reject = false; } } if (reject) { return (Bitmap)source; } } if (width > 0 && height > 0 && width <= maxWidth && height <= maxHeight) { // Exit if upscaling is not allowed. if ((width > sourceWidth || height > sourceHeight) && upscale == false && resizeMode != ResizeMode.Stretch) { return (Bitmap)source; } // Do the resize. Rectangle destination = new Rectangle(destinationX, destinationY, destinationWidth, destinationHeight); //if (this.ImageFormat is GifFormat || (this.ImageFormat is PngFormat && !((PngFormat)this.ImageFormat).IsIndexed)) //{ // newImage = FastResizer.ResizeBilinear((Bitmap)source, width, height, destination, linear); //} //else //{ // if (width <= sourceWidth && height <= sourceHeight) // { // newImage = FastResizer.ResizeBicubicHighQuality((Bitmap)source, width, height, destination, linear); // } // else // { // // Faster // newImage = FastResizer.ResizeBilinear((Bitmap)source, width, height, destination, linear); // } //} newImage = linear ? ResizeLinear(source, width, height, destination) : ResizeComposite(source, width, height, destination); // Reassign the image. source.Dispose(); source = newImage; } } catch (Exception ex) { if (newImage != null) { newImage.Dispose(); } throw new ImageProcessingException("Error processing image with " + this.GetType().Name, ex); } return (Bitmap)source; }
public static System.Drawing.Image ImageCropLocal(string imgURL, int Width, int Height, AnchorPosition Anchor) { try { Bitmap b; b = (Bitmap)System.Drawing.Image.FromFile(HttpContext.Current.Server.MapPath(imgURL)); return ImageCrop(b, Width, Height, Anchor); } catch (Exception ex) { } Bitmap bm = new Bitmap(Width, Height); Graphics g = Graphics.FromImage(bm); g.FillRectangle(new SolidBrush(Color.Black), 0, 0, (float)Width, (float)Height); g.Dispose(); return bm; }
public static Image Crop(Image imgPhoto, int Width, int Height, AnchorPosition Anchor) { int sourceWidth = imgPhoto.Width; int sourceHeight = imgPhoto.Height; int sourceX = 0; int sourceY = 0; int destX = 0; int destY = 0; float nPercent = 0; float nPercentW = 0; float nPercentH = 0; nPercentW = ((float)Width / (float)sourceWidth); nPercentH = ((float)Height / (float)sourceHeight); if (nPercentH < nPercentW) { nPercent = nPercentW; switch (Anchor) { case AnchorPosition.Top: destY = 0; break; case AnchorPosition.Bottom: destY = (int)(Height - (sourceHeight * nPercent)); break; default: destY = (int)((Height - (sourceHeight * nPercent)) / 2); break; } } else { nPercent = nPercentH; switch (Anchor) { case AnchorPosition.Left: destX = 0; break; case AnchorPosition.Right: destX = (int)(Width - (sourceWidth * nPercent)); break; default: destX = (int)((Width - (sourceWidth * nPercent)) / 2); break; } } int destWidth = (int)(sourceWidth * nPercent); int destHeight = (int)(sourceHeight * nPercent); Bitmap bmPhoto = new Bitmap(Width, Height); bmPhoto.SetResolution(imgPhoto.HorizontalResolution, imgPhoto.VerticalResolution); //Graphics grPhoto = Graphics.FromImage(bmPhoto); //grPhoto.InterpolationMode = InterpolationMode.High; //grPhoto.FillRectangle(Brushes.White, destX, destY, destWidth, destHeight); // Phuong add this line on 26/05/2008 to fix border issue //grPhoto.DrawImage(imgPhoto, // new Rectangle(destX, destY, destWidth, destHeight), // new Rectangle(sourceX, sourceY, sourceWidth, sourceHeight), // GraphicsUnit.Pixel); //grPhoto.Dispose(); using (Graphics g = Graphics.FromImage(bmPhoto)) { g.InterpolationMode = InterpolationMode.HighQualityBicubic; g.FillRectangle(Brushes.White, destX, destY, destWidth, destHeight); g.DrawImage(imgPhoto, new Rectangle(destX, destY, destWidth, destHeight), new Rectangle(sourceX, sourceY, sourceWidth, sourceHeight), GraphicsUnit.Pixel); } return bmPhoto; }