private void HandleSelfFittingAlongAxis(int axis)
{
FitMode fitting = (axis == 0 ? horizontalFit : verticalFit);
if (fitting == FitMode.Unconstrained)
{
// Keep a reference to the tracked transform, but don't control its properties:
m_Tracker.Add(this, rectTransform, DrivenTransformProperties.None);
return;
}
m_Tracker.Add(this, rectTransform, (axis == 0 ? DrivenTransformProperties.SizeDeltaX : DrivenTransformProperties.SizeDeltaY));
// Set size to min or preferred size
if (fitting == FitMode.MinSize)
{
float min;
if (m_Viewport != null)
{
min = axis == 0 ? m_Viewport.rect.width : m_Viewport.rect.height;
}
else
{
min = axis == 0 ? m_MinWidth : m_MinHeight;
}
rectTransform.SetSizeWithCurrentAnchors((RectTransform.Axis)axis, Mathf.Max(min, LayoutUtility.GetMinSize(m_Rect, axis)));
}
else
{
rectTransform.SetSizeWithCurrentAnchors((RectTransform.Axis)axis, LayoutUtility.GetPreferredSize(m_Rect, axis));
}
}
public static Vector2 GetFit2(this Vector2 sizeLimit, Vector2 innerSize, FitMode mode)
{
Vector2 scalage = sizeLimit / innerSize;
float adjust = mode == FitMode.Shrink ? scalage.x.Min(scalage.y) : scalage.x.Max(scalage.y);
return(innerSize * adjust);
}
protected void CalcAlongAxis(int axis)
{
float combinedPadding = (axis == 0 ? padding.horizontal : padding.vertical);
float size = rectTransform.rect.size[axis];
FitMode fitting = (axis == 0 ? horizontalFit : verticalFit);
float totalPreferred = combinedPadding;
if (fitting == FitMode.Unconstrained)
{
//不约束的情况下，不能添加padding，否则会导致ListView在设置的时候，导致栈溢出
SetLayoutInputForAxis(size, size, -1, axis);
return;
}
for (int i = 0; i < rectChildren.Count; i++)
{
RectTransform child = rectChildren[i];
float preferred = LayoutUtility.GetPreferredSize(child, axis);
if (fitting == FitMode.MaxChildrenSize)
{
totalPreferred = Mathf.Max(preferred + combinedPadding, totalPreferred);
}
else
{
totalPreferred += preferred;
}
}
SetLayoutInputForAxis(totalPreferred, totalPreferred, -1, axis);
}
public ImageResizer.FitMode Convert(FitMode compressor)
{
switch (compressor)
{
case FitMode.Stretch:
return(ImageResizer.FitMode.Stretch);
case FitMode.Carve:
return(ImageResizer.FitMode.Carve);
case FitMode.Crop:
return(ImageResizer.FitMode.Crop);
case FitMode.Max:
return(ImageResizer.FitMode.Max);
case FitMode.None:
return(ImageResizer.FitMode.None);
case FitMode.Pad:
return(ImageResizer.FitMode.Pad);
default:
return(ImageResizer.FitMode.None);
}
}
private void HandleSelfFittingAlongAxis(int axis)
{
//获取目标轴的适应类型
FitMode fitting = (axis == 0 ? horizontalFit : verticalFit);
if (fitting == FitMode.Unconstrained)
{
// Keep a reference to the tracked transform, but don't control its properties:
m_Tracker.Add(this, rectTransform, DrivenTransformProperties.None);
return;
}
//添加Tracker的部分无法被修改
m_Tracker.Add(this, rectTransform, (axis == 0 ? DrivenTransformProperties.SizeDeltaX : DrivenTransformProperties.SizeDeltaY));
// Set size to min or preferred size
//根据类型选择适应的尺寸
if (fitting == FitMode.MinSize)
{
rectTransform.SetSizeWithCurrentAnchors((RectTransform.Axis)axis, LayoutUtility.GetMinSize(m_Rect, axis));
}
else
{
rectTransform.SetSizeWithCurrentAnchors((RectTransform.Axis)axis, LayoutUtility.GetPreferredSize(m_Rect, axis));
}
}
private FitMode determineFitMode(ResizeSettings settings)
{
FitMode fit = settings.Mode;
//Determine fit mode to use if both vertical and horizontal limits are used.
if (fit == FitMode.None)
{
if (settings.Width != -1 || settings.Height != -1)
{
if ("fill".Equals(settings["stretch"], StringComparison.OrdinalIgnoreCase))
{
fit = FitMode.Stretch;
}
else if ("auto".Equals(settings["crop"], StringComparison.OrdinalIgnoreCase))
{
fit = FitMode.Crop;
}
else if (!string.IsNullOrEmpty(settings["carve"]) &&
!"false".Equals(settings["carve"], StringComparison.OrdinalIgnoreCase) &&
!"none".Equals(settings["carve"], StringComparison.OrdinalIgnoreCase))
{
fit = FitMode.Carve;
}
else
{
fit = FitMode.Pad;
}
}
else
{
fit = FitMode.Max;
}
}
return(fit);
}
private void HandleSelfFittingAlongAxis(int axis)
{
if (m_Rect == null)
{
m_Rect = GetComponent <RectTransform>();
}
FitMode fitting = (axis == 0 ? horizontalFit : verticalFit);
if (fitting == FitMode.Unconstrained)
{
// Keep a reference to the tracked transform, but don't control its properties:
m_Tracker.Add(this, targetRectTransform, DrivenTransformProperties.None);
return;
}
m_Tracker.Add(this, targetRectTransform, (axis == 0 ? DrivenTransformProperties.SizeDeltaX : DrivenTransformProperties.SizeDeltaY));
// Set size to min or preferred size
if (fitting == FitMode.MinSize)
{
targetRectTransform.SetSizeWithCurrentAnchors((RectTransform.Axis)axis, LayoutUtility.GetMinSize(m_Rect, axis));
}
else
{
targetRectTransform.SetSizeWithCurrentAnchors((RectTransform.Axis)axis, LayoutUtility.GetPreferredSize(m_Rect, axis));
}
}
void HandleSelfFittingAlongAxis(int axis)
{
FitMode fitting = (axis == 0 ? horizontalFit : verticalFit);
if (fitting == FitMode.Unconstrained)
{
return;
}
tracker.Add(this, target,
axis == 0 ? DrivenTransformProperties.SizeDeltaX :
DrivenTransformProperties.SizeDeltaY
);
if (fitting == FitMode.MinSize)
{
target.SetSizeWithCurrentAnchors(
(RectTransform.Axis)axis,
LayoutUtility.GetMinSize(rectTransform, axis)
);
}
else
{
target.SetSizeWithCurrentAnchors(
(RectTransform.Axis)axis,
LayoutUtility.GetPreferredSize(rectTransform, axis)
);
}
}
private bool RefreshSafeArea()
{
if (_panel == null)
{
_panel = transform as RectTransform;
}
if (_panel == null)
{
return(false);
}
var safeArea = SafeAreaBinding.SafeArea;
if (!NeedFitSafeArea(safeArea))
{
return(true);
}
if (CocoDebugSettingsData.Instance.IsDebugLogEnabled)
{
Debug.LogErrorFormat(gameObject, "ScreenSafeAreaFitter->RefreshSafeArea: obj: [{0}] {1} -> {2}", name, _lastSafeArea, safeArea);
}
FitSafeArea(safeArea);
_lastSafeArea = safeArea;
_lastFitMode = _fitMode;
return(true);
}
public ImageHelper(FitMode mode = FitMode.Max, SearchOption directoryMode = SearchOption.TopDirectoryOnly,
SaveMode saveOption = SaveMode.Overwrite)
{
Mode = mode;
DirectoryMode = directoryMode;
SaveOption = saveOption;
SaveExtension = "jpg";
}
public static Vector2 GetFit(this Vector2 sizeLimit, float wantAspect, FitMode mode)
{
float d1 = sizeLimit.x / wantAspect, d2 = sizeLimit.y;
float adjust = mode == FitMode.Extented ? d1.Max(d2) : d1.Min(d2);
bool toAdjustX = d2 == adjust;
return(toAdjustX ? new Vector2(wantAspect * adjust, sizeLimit.y) : new Vector2(sizeLimit.x, adjust));
}
public TextFit(FitMode mode = FitMode.Fill, uint options = FontMeasurementOptions.Maximum) :
base(mode)
{
Options = options;
//Debug.EnableTracing(@class);
//Debug.EnableTracing(Extensions.@class);
}
public CustomResizeSettings(string suffix, int width, int height, FitMode mode = FitMode.Stretch, string imageFormat = null)
{
Suffix = suffix;
Height = height;
Width = width;
Mode = mode;
Format = imageFormat;
}
public static UrlBuilder FitMode(this UrlBuilder target, FitMode mode)
{
if (target == null)
throw new ArgumentNullException(nameof(target));
target.QueryCollection.Add("mode", mode.ToString().ToLower());
return target;
}
public static Rect GetFit2(this Rect limitRect, float wantAspect, FitMode mode)
{
Vector2 limitSize = limitRect.size;
Vector2 fitSize = limitSize.GetFit2(wantAspect, mode);
Vector2 posOffset = (limitSize - fitSize) / 2.0f;
return(new Rect(limitRect.position + posOffset, fitSize));
}
/// <summary>
/// Fits the specified image to the supplied max width / height.
/// </summary>
/// <param name="image">The image.</param>
/// <param name="maxWidthHeight">max width / height.</param>
/// <param name="fitMode">The fit mode.</param>
/// <param name="scaleMode">The scale mode.</param>
/// <param name="alignMode">The align mode.</param>
/// <param name="format">The format.</param>
/// <param name="quality">The quality.</param>
/// <param name="colors">The colors.</param>
/// <param name="bgColor">Color of the background.</param>
/// <returns></returns>
public static IFilteredImage Fit(this IFilteredImage image, int maxWidthHeight,
FitMode fitMode = FitMode.Pad, ScaleMode scaleMode = ScaleMode.Down,
AlignMode alignMode = AlignMode.MiddleCenter, ImageFormat format = ImageFormat.Auto,
int quality = 90, int colors = 256, string bgColor = "")
{
return(image.Fit(maxWidthHeight, maxWidthHeight, fitMode, scaleMode, alignMode,
format, quality, colors, bgColor));
}
public ImageHelper(FitMode mode = FitMode.Max, SearchOption directoryMode = SearchOption.TopDirectoryOnly,
SaveMode saveOption = SaveMode.Overwrite)
{
Mode = mode;
DirectoryMode = directoryMode;
SaveOption = saveOption;
SaveExtension = "jpg";
}
/// <summary>
/// Creates a new resize settings object with the specified resizing settings
/// </summary>
/// <param name="width"></param>
/// <param name="height"></param>
/// <param name="mode"></param>
/// <param name="imageFormat">The desired image format, like 'jpg', 'gif', or 'png'. Leave null if you want to preserve the original format.</param>
public ResizeSettings(int width, int height, FitMode mode, string imageFormat)
{
this.Width = width;
this.Height = height;
this.Mode = mode;
if (imageFormat != null)
{
this.Format = imageFormat;
}
}
private void Fit()
{
Vector3 rectCenter = (min.position + max.position) * 0.5f;
Vector3 rectExtents = (max.position - min.position) * 0.5f;
float referenceScaleFactor = rectExtents.x / rectExtents.y;
float scaleFactor = (float)Screen.width / Screen.height;
FitMode tempFitMode = fitMode;
if (tempFitMode == FitMode.Auto)
{
if (scaleFactor > referenceScaleFactor)
{
tempFitMode = FitMode.Height;
}
else if (scaleFactor < referenceScaleFactor)
{
tempFitMode = FitMode.Width;
}
}
if (viewCamera.orthographic)
{
Vector3 viewCameraPos = viewCamera.transform.position;
viewCameraPos.x = rectCenter.x;
viewCameraPos.y = rectCenter.y;
viewCamera.transform.position = viewCameraPos;
if (tempFitMode == FitMode.Height)
{
//匹配高度
viewCamera.orthographicSize = rectExtents.y;
}
else if (tempFitMode == FitMode.Width)
{
//匹配宽度
viewCamera.orthographicSize = rectExtents.x / scaleFactor;
}
}
else
{
float distance = Vector3.Distance(rectCenter, viewCamera.transform.position);
viewCamera.transform.LookAt(rectCenter);
if (tempFitMode == FitMode.Height)
{
//匹配高度
viewCamera.fieldOfView = Mathf.Atan(rectExtents.y / distance) * Mathf.Rad2Deg * 2f;
}
else if (tempFitMode == FitMode.Width)
{
//匹配宽度
float tempExtentsY = rectExtents.x / viewCamera.aspect;
viewCamera.fieldOfView = Mathf.Atan(tempExtentsY / distance) * Mathf.Rad2Deg * 2f;
}
}
}
public wImage(Bitmap InitialBitmap, FillSpace Extents, bool Embed, AlignMode ImageAlignment, FitMode ImageFitting)
{
BitmapImage = InitialBitmap;
FillMode = Extents;
IsEmbedded = Embed;
Alignment = ImageAlignment;
Fitting = ImageFitting;
ToByteArray();
}
private float GetAtLeastValue(FitMode fitting)
{
if (!fillParent)
{
return(0f);
}
var parent = ((RectTransform)transform.parent.transform).rect;
var target = fitting == horizontalFit ? parent.width : parent.height;
return(target);
}
private void HandleSelfFittingAlongAxis(int axis)
{
FitMode fitting = (axis == 0 ? horizontalFit : verticalFit);
if (fitting == FitMode.Unconstrained)
{
// Keep a reference to the tracked transform, but don't control its properties:
m_Tracker.Add(this, rectTransform, DrivenTransformProperties.None);
return;
}
m_Tracker.Add(this, rectTransform, (axis == 0 ? DrivenTransformProperties.SizeDeltaX : DrivenTransformProperties.SizeDeltaY));
// Set size to min or preferred size
if (fitting == FitMode.MinSize)
{
rectTransform.SetSizeWithCurrentAnchors((RectTransform.Axis)axis, LayoutUtility.GetMinSize(m_Rect, axis));
}
else
{
float toBeSize = LayoutUtility.GetPreferredSize(m_Rect, axis);
var p = m_Rect.parent as RectTransform;
if (!ReferenceEquals(p, null))
{
if (axis == 0 && m_HorizontalConstrainToParentSize)
{
toBeSize = Mathf.Clamp(toBeSize, 0, p.rect.size.x);
}
if (axis == 1)
{
if (m_VerticalConstrainToParentSize)
{
toBeSize = Mathf.Clamp(toBeSize, 0, p.rect.size.y);
}
if (m_VerticalConstrainToCanvasSize)
{
float constrt = RootCanvasRectTransform.rect.size.y *
m_VerticalCanvasSizeFraction;
if (m_VerticalConstrainToConstant)
{
constrt += m_VerticalConstant;
}
toBeSize = Mathf.Clamp(toBeSize, 0, constrt);
}
}
}
rectTransform.SetSizeWithCurrentAnchors((RectTransform.Axis)axis, toBeSize);
}
}
private void HandleSelfFittingAlongAxis(int axis)
{
FitMode fitting = (axis == 0 ? HorizontalFit : VerticalFit);
if (fitting == FitMode.Unconstrained)
{
_tracker.Add(this, rectTransform, DrivenTransformProperties.None);
return;
}
_tracker.Add(this, rectTransform, (axis == 0 ? DrivenTransformProperties.SizeDeltaX : DrivenTransformProperties.SizeDeltaY));
float size;
if (fitting == FitMode.MinSize)
{
size = LayoutUtility.GetMinSize(_rect, axis);
}
else
{
size = LayoutUtility.GetPreferredSize(_rect, axis);
}
var sWidth = _fallback?.rect.width - _padding.left - _padding.right;
var sHeight = _fallback?.rect.height - _padding.top - _padding.bottom;
if (axis == 0)
{
if (MinWidth < 0 && size < sWidth)
{
size = sWidth.Value;
}
else if (size < MinWidth)
{
size = MinWidth;
}
}
else
{
if (MinHeight < 0 && size < sHeight)
{
size = sHeight.Value;
}
else if (size < MinHeight)
{
size = MinHeight;
}
}
rectTransform.SetSizeWithCurrentAnchors((RectTransform.Axis)axis, size);
}
public object ToImageflowDynamic(int ioId)
{
return(new
{
io_id = ioId,
gravity = Gravity?.ToImageflowDynamic(),
fit_box = FitBox?.ToImageflowDynamic(),
fit_mode = FitMode?.ToString().ToLowerInvariant(),
min_canvas_width = MinCanvasWidth,
min_canvas_height = MinCanvasWidth,
opacity = Opacity,
hints = Hints?.ToImageflowDynamic()
});
}
public static UrlBuilder FitMode(this UrlBuilder target, FitMode mode)
{
if (target == null)
{
throw new ArgumentNullException(nameof(target));
}
if (!target.IsEmpty)
{
target.QueryCollection.Add("mode", mode.ToString().ToLower());
}
return(target);
}
private void HandleSelfFittingAlongAxis(int axis)
{
FitMode fitting = (axis == 0 ? horizontalFit : verticalFit);
if (fitting == FitMode.Unconstrained)
{
// Keep a reference to the tracked transform, but don't control its properties:
m_Tracker.Add(this, rectTsfm, DrivenTransformProperties.None);
return;
}
DrivenTransformProperties flags = DrivenTransformProperties.ScaleX | DrivenTransformProperties.ScaleY;
if (horizontalFit != FitMode.Unconstrained)
{
flags |= DrivenTransformProperties.SizeDeltaX;
}
if (verticalFit != FitMode.Unconstrained)
{
flags |= DrivenTransformProperties.SizeDeltaY;
}
m_Tracker.Add(this, rectTsfm, flags);
// Set size to min or preferred size
float newSize = 0f;
if (fitting == FitMode.MinSize)
{
newSize = LayoutUtility.GetMinSize(m_Rect, axis);
newSize = axis == 0 ? Mathf.Max(newSize, m_fixedSize.x) : Mathf.Max(newSize, m_fixedSize.y);
}
else
{
newSize = LayoutUtility.GetPreferredSize(m_Rect, axis);
}
Vector2 newSizeV;
if (axis == 0)
{
newSizeV = new Vector2(Mathf.Max(newSize, m_fixedSize.x), m_Rect.sizeDelta.y);
}
else
{
newSizeV = new Vector2(m_Rect.sizeDelta.x, Mathf.Max(newSize, m_fixedSize.y));
}
m_Rect.SetSizeWithCurrentAnchors((RectTransform.Axis)axis, newSize);
m_Rect.localScale = CalculateSizeScale(newSizeV, axis);
}
private void SetScale(SKCanvas canvas, FitMode mode, Size newSize, SKBitmap bitmap)
{
switch (mode)
{
case FitMode.Stretch:
var sx = (float)newSize.Width / bitmap.Width;
var sy = (float)newSize.Height / bitmap.Height;
canvas.Scale(sx, sy);
break;
default:
throw new InvalidOperationException($"FitMode not supported:{mode}");
}
}
void SizeChanged()
{
if (Template == null)
{
return;
}
FitMode prevFitMode = FitMode;
templateHeight = template.CanvasHeight + 10;
templateWidth = template.CanvasWidth + 10;
/* When going from Original to Fill or Fit, we can't know the new
* size of the shrinked object until we have a resize */
if (FitMode == FitMode.Original)
{
widget.Width = templateWidth;
widget.Height = templateHeight;
ScaleX = ScaleY = 1;
Translation = new Point(0, 0);
}
else if (FitMode == FitMode.Fill)
{
ScaleX = (double)widget.Width / templateWidth;
ScaleY = (double)widget.Height / templateHeight;
Translation = new Point(0, 0);
}
else if (FitMode == FitMode.Fit)
{
double scaleX, scaleY;
Point translation;
Image.ScaleFactor(templateWidth, templateHeight,
(int)widget.Width, (int)widget.Height,
out scaleX, out scaleY, out translation);
ScaleX = scaleX;
ScaleY = scaleY;
Translation = translation;
}
if (modeChanged)
{
modeChanged = false;
foreach (CanvasObject co in Objects)
{
co.ResetDrawArea();
}
}
widget.ReDraw();
}
private void UpdateFitMode(ref FitMode f, int index)
{
switch (index)
{
case 0:
f = FitMode.None;
break;
case 1:
f = FitMode.Average;
break;
case 2:
f = FitMode.Shot;
break;
}
}
private void HandleSelfFittingAlongAxis(int axis)
{
FitMode fitMode = (axis != 0) ? verticalFit : horizontalFit;
if (fitMode != 0)
{
m_Tracker.Add(this, rectTransform, (axis != 0) ? DrivenTransformProperties.SizeDeltaY : DrivenTransformProperties.SizeDeltaX);
if (fitMode == FitMode.MinSize)
{
rectTransform.SetSizeWithCurrentAnchors((RectTransform.Axis)axis, LayoutUtility.GetMinSize(m_Rect, axis));
}
else
{
rectTransform.SetSizeWithCurrentAnchors((RectTransform.Axis)axis, LayoutUtility.GetPreferredSize(m_Rect, axis));
}
}
}
private void HandleSelfFittingAlongAxis(int axis)
{
FitMode mode = (axis != 0) ? this.verticalFit : this.horizontalFit;
if (mode != FitMode.Unconstrained)
{
this.m_Tracker.Add(this, this.rectTransform, (axis != 0) ? DrivenTransformProperties.SizeDeltaY : DrivenTransformProperties.SizeDeltaX);
if (mode == FitMode.MinSize)
{
this.rectTransform.SetSizeWithCurrentAnchors((RectTransform.Axis)axis, LayoutUtility.GetMinSize(this.m_Rect, axis));
}
else
{
this.rectTransform.SetSizeWithCurrentAnchors((RectTransform.Axis)axis, LayoutUtility.GetPreferredSize(this.m_Rect, axis));
}
}
}
/// <summary>
/// Fits the specified image to the supplied max width and height.
/// </summary>
/// <param name="image">The image.</param>
/// <param name="maxWidth">Width of the max.</param>
/// <param name="maxHeight">Height of the max.</param>
/// <param name="fitMode">The fit mode.</param>
/// <param name="scaleMode">The scale mode.</param>
/// <param name="alignMode">The align mode.</param>
/// <param name="format">The format.</param>
/// <param name="quality">The quality.</param>
/// <param name="colors">The colors.</param>
/// <param name="bgColor">Color of the background.</param>
/// <returns></returns>
public static IFilteredImage Fit(this IFilteredImage image, int maxWidth, int maxHeight,
FitMode fitMode = FitMode.Pad, ScaleMode scaleMode = ScaleMode.Down,
AlignMode alignMode = AlignMode.MiddleCenter, ImageFormat format = ImageFormat.Auto,
int quality = 90, int colors = 256, string bgColor = "")
{
image.Filters.Add("w", maxWidth);
image.Filters.Add("h", maxHeight);
if (fitMode != FitMode.Pad)
{
image.Filters.Add("mode", fitMode.ToString().ToLower());
}
if (scaleMode != ScaleMode.Down)
{
image.Filters.Add("scale", scaleMode.ToString().ToLower());
}
if (alignMode != AlignMode.MiddleCenter)
{
image.Filters.Add("anchor", alignMode.ToString().ToLower());
}
if (format != ImageFormat.Auto)
{
image.Filters.Add("format", format.ToString().ToLower());
}
if (quality != 90)
{
image.Filters.Add("quality", Math.Min(100, Math.Max(0, quality)));
}
if (colors != 256)
{
image.Filters.Add("colors", Math.Min(256, Math.Max(2, quality)));
}
if (!string.IsNullOrEmpty(bgColor))
{
image.Filters.Add("bgcolor", bgColor);
}
return(image);
}
/// <summary>
/// 获取隐藏panel的宽或高
/// </summary>
private float HandleSelfFittingAlongAxis(int axis, GameObject obj)
{
//获取当前隐藏panel选择的适配模式
FitMode fitting = (axis == 0 ? obj.GetComponent <ContentSizeFitter>().horizontalFit : obj.GetComponent <ContentSizeFitter>().verticalFit);
if (fitting == FitMode.MinSize)
{
return(LayoutUtility.GetMinSize(obj.GetComponent <RectTransform>(), axis));
}
else if (fitting == FitMode.PreferredSize)
{
return(LayoutUtility.GetPreferredSize(obj.GetComponent <RectTransform>(), axis));
}
else
{
//如果是unconstrained的话直接获取当前的大小
return(axis == 0 ? obj.GetComponent <RectTransform>().sizeDelta.x : obj.GetComponent <RectTransform>().sizeDelta.y);
}
}
public static void SaveImage(Stream source, int width, int height, string path, FitMode mode, bool dispose = true, bool resetSource = false)
{
var instructions = new Instructions
{
Width = width,
Height = height,
Mode = mode,
Encoder = "freeimage",
OutputFormat = OutputFormat.Jpeg
};
var job = new ImageJob
{
Instructions = instructions,
Source = source,
Dest = path,
CreateParentDirectory = true,
ResetSourceStream = resetSource,
DisposeSourceObject = dispose,
AddFileExtension = !Path.HasExtension(path)
};
ImageBuilder.Current.Build(job);
}
/// <summary>
/// Fits the specified image to the supplied max width / height.
/// </summary>
/// <param name="image">The image.</param>
/// <param name="maxWidthHeight">max width / height.</param>
/// <param name="fitMode">The fit mode.</param>
/// <param name="scaleMode">The scale mode.</param>
/// <param name="alignMode">The align mode.</param>
/// <param name="format">The format.</param>
/// <param name="quality">The quality.</param>
/// <param name="colors">The colors.</param>
/// <param name="bgColor">Color of the background.</param>
/// <returns></returns>
public static IFilteredImage Fit(this IImageFile image, int maxWidthHeight,
FitMode fitMode = FitMode.Pad, ScaleMode scaleMode = ScaleMode.Down,
AlignMode alignMode = AlignMode.MiddleCenter, ImageFormat format = ImageFormat.Auto,
int quality = 90, int colors = 256, string bgColor = "")
{
return image.Fit(maxWidthHeight, maxWidthHeight, fitMode, scaleMode, alignMode,
format, quality, colors, bgColor);
}
public FileResult getResizeFile(Dictionary<string, string> item, string width, string height, FitMode mode)
{
if (item != null)
{
var settings = new ResizeSettings();
int intWidth = 0;
int intHeight = 0;
if (!int.TryParse(width, out intWidth))
{
return null;
}
if (!int.TryParse(height, out intHeight))
{
return null;
}
settings.Width = intWidth;
settings.Height = intHeight;
settings.Quality = 100;
settings.Mode = mode;
byte[] fileByte;
using (MemoryStream st = new MemoryStream())
{
ImageBuilder.Current.Build(item.First().Key, st, settings);
st.Position = 0;
fileByte = st.ToArray();
}
return File(fileByte, item.First().Value);
}
else
{
return null;
}
}
public Dictionary<string, string> getFileResized(string photoName, string path, int width, int height, FitMode mode)
{
Dictionary<string, string> returnItem = new Dictionary<string, string>();
if (string.IsNullOrWhiteSpace(photoName) || string.IsNullOrWhiteSpace(path))
{
return null;
}
var fileProperty = getExtenstionWithFileExistControl(path, photoName);
if (fileProperty.Item1)
{
string resultExtention = fileProperty.Item2;
string filePath = fileProperty.Item3;
string withoutCommaCoordinate = width.ToString() + height.ToString();
string filePathWithCoordiante = Server.MapPath("~/" + "Download/item/" + path + "/" + withoutCommaCoordinate + mode.ToString() + "_" + photoName);
if (System.IO.File.Exists(filePathWithCoordiante))
{
returnItem.Add(filePathWithCoordiante, resultExtention);
return returnItem;
}
else
{
var settings = new ResizeSettings();
settings.Width = width;
settings.Height = height;
settings.Mode = mode;
settings.Quality = 100;
ImageBuilder.Current.Build(filePath, filePathWithCoordiante,
settings);
returnItem.Add(filePathWithCoordiante, resultExtention);
return returnItem;
}
}
return null;
}
private void CalculateFit()
{
if (_project == null || _project.FullHeight == 0 || _pixelHeight == 0)
{
_fitMode = FitMode.FitWidth;
_pixelsPerInch = 0;
return;
}
var pixelAspectRatio = (double)_pixelWidth / _pixelHeight;
var imageAspectRatio = _project.FullWidth / _project.FullHeight;
if (pixelAspectRatio >= imageAspectRatio)
{
_fitMode = FitMode.FitHeight;
_pixelsPerInch = _pixelHeight / _project.FullHeight;
}
else
{
_fitMode = FitMode.FitWidth;
_pixelsPerInch = _pixelWidth / _project.FullWidth;
}
}
private void UpdateFitMode(ref FitMode f, int index)
{
switch (index)
{
case 0:
f = FitMode.None;
break;
case 1:
f = FitMode.Average;
break;
case 2:
f = FitMode.Shot;
break;
}
}
/// <summary>
/// Fits the specified image to the supplied max width and height.
/// </summary>
/// <param name="image">The image.</param>
/// <param name="maxWidth">Width of the max.</param>
/// <param name="maxHeight">Height of the max.</param>
/// <param name="fitMode">The fit mode.</param>
/// <param name="scaleMode">The scale mode.</param>
/// <param name="alignMode">The align mode.</param>
/// <param name="format">The format.</param>
/// <param name="quality">The quality.</param>
/// <param name="colors">The colors.</param>
/// <param name="bgColor">Color of the background.</param>
/// <returns></returns>
public static IFilteredImage Fit(this IFilteredImage image, int maxWidth, int maxHeight,
FitMode fitMode = FitMode.Pad, ScaleMode scaleMode = ScaleMode.Down,
AlignMode alignMode = AlignMode.MiddleCenter, ImageFormat format = ImageFormat.Auto,
int quality = 90, int colors = 256, string bgColor = "")
{
image.Filters.Add("w", maxWidth);
image.Filters.Add("h", maxHeight);
if(fitMode != FitMode.Pad)
image.Filters.Add("mode", fitMode.ToString().ToLower());
if(scaleMode != ScaleMode.Down)
image.Filters.Add("scale", scaleMode.ToString().ToLower());
if(alignMode != AlignMode.MiddleCenter)
image.Filters.Add("anchor", alignMode.ToString().ToLower());
if(format != ImageFormat.Auto)
image.Filters.Add("format", format.ToString().ToLower());
if(quality != 90)
image.Filters.Add("quality", Math.Min(100, Math.Max(0, quality)));
if (colors != 256)
image.Filters.Add("colors", Math.Min(256, Math.Max(2, quality)));
if (!string.IsNullOrEmpty(bgColor))
image.Filters.Add("bgcolor", bgColor);
return image;
}
