public void ExtendPipeline(Pipeline pipeline, IImageParams destImageParams, ColorManagement colorManagement, float scale, out IEnumerable <IDisposable> deps)
{
deps = new List <IDisposable>();
pipeline.Add(GetShapeDrawer(destImageParams, colorManagement, scale));
var scaleAlpha = new ScaleAlpha(Opacity);
var combiner = GetImageCombiner(destImageParams, colorManagement, scale, deps, scaleAlpha);
if (combiner != null)
{
pipeline.Add(combiner);
}
}
/// <summary>
/// Get image size and resolution. This method doesn't load bitmap in memory.
/// </summary>
/// <param name="imageFileName">image file</param>
/// <param name="imageSize">image size in pixels</param>
/// <param name="horizontalResolution">Horizontal Resolution</param>
/// <param name="verticalResolution">Vertical Resolution</param>
public static void GetImageSize(IImageParams reader, out Size imageSize, out float horizontalResolution, out float verticalResolution)
{
imageSize = new Size(reader.Width, reader.Height);
horizontalResolution = reader.DpiX;
verticalResolution = reader.DpiY;
// BUG 0015883: Use default resolution 72, if reader return incorrect value.
if (horizontalResolution <= 0)
{
horizontalResolution = 72;
}
if (verticalResolution <= 0)
{
verticalResolution = 72;
}
}
internal override void Draw(Graphics graphics, IImageParams destImageParams, ColorManagement colorManagement)
{
var bounds = Bounds;
if (bounds.Width <= 0 || bounds.Height <= 0)
{
return;
}
var dpi = graphics.DpiX;
var width = Width;
if (width > 0)
{
var color = ColorManagement.ConvertColor(colorManagement, Color, destImageParams);
color = color.ScaleAlpha(Opacity);
graphics.DrawPath(new Pen(color, width), GetDrawingPath(dpi));
}
}
internal override void Draw(Graphics graphics, IImageParams destImageParams, ColorManagement colorManagement)
{
var bounds = Bounds;
if (bounds.Width <= 0 || bounds.Height <= 0)
{
return;
}
var dpi = graphics.DpiX;
var width = GetWidth(dpi * graphics.Transform.Elements[0]);
if (width > 0)
{
var paths = GetPaths();
if (!Utils.EqualsOfFloatNumbers(dpi, 72))
{
using (var matrix = new Matrix())
{
matrix.Scale(dpi / 72, dpi / 72, MatrixOrder.Append);
paths[0].ApplyTransform(matrix);
paths[1].ApplyTransform(matrix);
}
}
if (!Color.IsTransparent)
{
var color = ColorManagement.ConvertColor(colorManagement, Color, destImageParams);
color = color.ScaleAlpha(Opacity);
graphics.DrawPath(new Pen(color, width), paths[0]);
}
if (!AltColor.IsTransparent)
{
var altColor = ColorManagement.ConvertColor(colorManagement, AltColor, destImageParams);
altColor = altColor.ScaleAlpha(Opacity);
graphics.DrawPath(new Pen(altColor, width), paths[1]);
}
}
}
private Drawer GetStrokeShapeDrawer(IImageParams destImageParams, ColorManagement colorManagement, float scale)
{
var drawer = new Drawer();
drawer.Draw += (sender, e) =>
{
if (!Utils.EqualsOfFloatNumbers(scale, 1))
{
e.Graphics.Transform.Scale(scale, scale);
}
StrokeShape(e.Graphics, destImageParams, colorManagement);
if (!Utils.EqualsOfFloatNumbers(scale, 1))
{
e.Graphics.Transform.Scale(1 / scale, 1 / scale);
}
};
return(drawer);
}
protected internal void FillShape(Graphics graphics, IImageParams destImageParams, ColorManagement colorManagement)
{
var bounds = Bounds;
if (bounds.Width <= 0 || bounds.Height <= 0)
{
return;
}
if (FillColor.IsTransparent)
{
return;
}
using (var path = GetDrawingPath(graphics.DpiX))
{
var fillColor = ColorManagement.ConvertColor(colorManagement, FillColor, destImageParams);
fillColor = fillColor.ScaleAlpha(Opacity);
graphics.FillPath(new SolidBrush(fillColor), path);
}
}
internal override void Draw(Graphics graphics, IImageParams destImageParams, ColorManagement colorManagement)
{
var bounds = Bounds;
if (bounds.Width <= 0 || bounds.Height <= 0)
{
return;
}
FillShape(graphics, destImageParams, colorManagement);
if (!IsStubOrEmptyContent)
{
using (var clippingPath = GetClippingPath(graphics.DpiX))
{
var globalClippingPath = graphics.ClippingPaths.FirstOrDefault();
if (globalClippingPath != null)
{
graphics.ClippingPaths.Remove(globalClippingPath);
using (var intersectedClippingPath = AdvancedPath.Intersect(clippingPath, globalClippingPath))
{
graphics.ClippingPaths.Add(intersectedClippingPath);
Content.Draw(graphics, destImageParams, colorManagement);
graphics.ClippingPaths.Remove(intersectedClippingPath);
}
graphics.ClippingPaths.Add(globalClippingPath);
}
else
{
graphics.ClippingPaths.Add(clippingPath);
Content.Draw(graphics, destImageParams, colorManagement);
graphics.ClippingPaths.Remove(clippingPath);
}
}
}
StrokeShape(graphics, destImageParams, colorManagement);
}
internal override void Draw(Graphics graphics, IImageParams destImageParams, ColorManagement colorManagement)
{
var dpi = graphics.DpiX;
var bounds = Bounds;
var lineWidth = System.Math.Abs(GetLineWidth(dpi * graphics.Transform.Elements[0]));
if (bounds.Width <= 0 || bounds.Height <= 0 || lineWidth <= 0)
{
return;
}
var paths = GetPaths();
if (!Utils.EqualsOfFloatNumbers(dpi, 72))
{
using (var matrix = new Matrix())
{
matrix.Scale(dpi / 72, dpi / 72, MatrixOrder.Append);
paths[0].ApplyTransform(matrix);
paths[1].ApplyTransform(matrix);
}
}
if (!VerticalLineColor.IsTransparent)
{
var verticalLineColor = ColorManagement.ConvertColor(colorManagement, VerticalLineColor, destImageParams);
verticalLineColor = verticalLineColor.ScaleAlpha(Opacity);
graphics.DrawPath(new Pen(verticalLineColor, lineWidth), paths[0]);
}
if (!HorizontalLineColor.IsTransparent)
{
var horizontalLineColor = ColorManagement.ConvertColor(colorManagement, HorizontalLineColor, destImageParams);
horizontalLineColor = horizontalLineColor.ScaleAlpha(Opacity);
graphics.DrawPath(new Pen(horizontalLineColor, lineWidth), paths[1]);
}
}
private Pipeline GetSvgPipeline(IImageParams destImageParams, ColorManagement colorManagement, float scale = 1)
{
var dpi = destImageParams.DpiX * scale;
var rect = GetImageRectangle(dpi);
var svg = (SvgLib.SvgDocument)_svgDoc.Clone();
if (((RectangleF)svg.ViewBox).IsEmpty)
{
svg.Transforms.Add(new SvgLib.Transforms.SvgScale(rect.Width / svg.Width, rect.Height / svg.Height));
}
svg.Width = rect.Width;
svg.Height = rect.Height;
svg.Ppi = (int)dpi;
UpdateStrokeColor(svg, colorManagement);
var bitmap = new Bitmap(svg.Draw());
bitmap.DpiX = dpi;
bitmap.DpiY = dpi;
svg.Transforms.Clear();
var pipeline = new Pipeline(bitmap);
var colorConverter = ColorManagement.GetColorConverter(colorManagement, bitmap, destImageParams);
if (colorConverter != null)
{
pipeline.Add(colorConverter);
}
return(pipeline);
}
protected internal void StrokeShape(Graphics graphics, IImageParams destImageParams, ColorManagement colorManagement)
{
var bounds = Bounds;
if (bounds.Width <= 0 || bounds.Height <= 0)
{
return;
}
var dpi = graphics.DpiX;
var borderWidth = GetBorderWidth(dpi * graphics.Transform.Elements[0]);
if (Utils.EqualsOfFloatNumbers(0, borderWidth))
{
return;
}
using (var path = GetDrawingPath(dpi))
{
var borderColor = ColorManagement.ConvertColor(colorManagement, BorderColor, destImageParams);
borderColor = borderColor.ScaleAlpha(Opacity);
graphics.DrawPath(new Pen(borderColor, borderWidth), path);
}
}
internal Combiner GetImageCombiner(IImageParams destImageParams, ColorManagement colorManagement, float scale, IEnumerable <IDisposable> deps, ScaleAlpha alpha)
{
if (!Configuration.FileCache.FileExists(SourceFileId))
{
return(null);
}
var imageStream = Configuration.FileCache.GetReadStream(SourceFileId, true);
((IList)deps).Add(imageStream);
var reader = ImageReader.Create(imageStream);
((IList)deps).Add(reader);
IImageParams firstElement;
var psdReader = reader as PsdReader;
if (psdReader != null)
{
firstElement = psdReader.MergedImageFrame;
}
else
{
firstElement = reader;
}
var pipeline = new Pipeline((PipelineElement)firstElement);
var dpi = destImageParams.DpiX * scale;
var imageRect = GetImageRectangle(dpi);
if (firstElement.Width != imageRect.Width || firstElement.Height != imageRect.Height)
{
pipeline.Add(new Resize(imageRect.Width, imageRect.Height, _resizeInterpolationMode));
}
if (alpha != null)
{
pipeline.Add(alpha);
}
// Convert color of image
var colorConverter = ColorManagement.GetColorConverter(colorManagement, firstElement, destImageParams);
if (colorConverter != null)
{
pipeline.Add(colorConverter);
}
if (!Angle.Equals(0))
{
// Don't rotate bitmap without alpha channel.
if (!firstElement.PixelFormat.HasAlpha)
{
// Add alpha channel if scaleAlpha or color conversion does not add it
if (alpha == null && (colorConverter == null || !colorConverter.DestinationPixelFormat.HasAlpha))
{
pipeline.Add(new SetAlpha(1));
}
}
var rotate = new MatrixTransform
{
Matrix = Matrix.CreateRotate((float)Angle),
InterpolationMode = InterpolationMode.High,
BackgroundColor = ColorManagement.GetTransparentColor(destImageParams.PixelFormat)
};
pipeline.Add(rotate);
}
var imageLocation = GetDrawingRectangle(dpi).Bounds.Location;
var imageCombiner = new Combiner(CombineMode.AlphaOverlay, pipeline, true)
{
X = (int)imageLocation.X,
Y = (int)imageLocation.Y
};
return(imageCombiner);
}
internal abstract void Draw(Graphics graphics, IImageParams destImageParams, ColorManagement colorManagement);
public static ColorConverter GetColorConverter(ColorManagement colorManagement, IImageParams source, ColorSpace destinationColorSpace)
{
return(GetColorConverter(colorManagement, source, GetPixelFormat(destinationColorSpace)));
}
private static void DrawVObjects(IEnumerable <VObject> vObjects, Graphics graphics, IImageParams destImageParams, ColorManagement colorManagement)
{
foreach (var vObject in vObjects)
{
vObject.Draw(graphics, destImageParams, colorManagement);
}
}
public static ColorConverter GetColorConverter(ColorManagement colorManagement, IImageParams source, PixelFormat destinationPixelFormat, bool isPreview = false)
{
var destination = new ImageParams(destinationPixelFormat, GetProfile(colorManagement, destinationPixelFormat.ColorSpace, isPreview));
return(GetColorConverter(colorManagement, source, destination));
}
public static ColorConverter GetColorConverter(ColorManagement colorManagement, IImageParams source, PixelFormat destinationPixelFormat, ColorProfile destinationProfile)
{
var destination = new ImageParams(destinationPixelFormat, destinationProfile);
return(GetColorConverter(colorManagement, source, destination));
}
public static ColorConverter GetColorConverter(ColorManagement colorManagement, IImageParams source, IImageParams destination)
{
if (colorManagement != null)
{
var targetProfile = GetTargetProfile(colorManagement);
if (!CompareProfiles(source.ColorProfile, destination.ColorProfile) || targetProfile != null && !CompareProfiles(targetProfile, destination.ColorProfile))
{
return(new ColorConverter
{
ColorManagementEngine = ColorManagementEngine.LittleCms,
DestinationPixelFormat = destination.PixelFormat,
DestinationProfile = destination.ColorProfile,
DefaultSourceProfile = GetProfile(colorManagement, source.PixelFormat.ColorSpace),
TargetDeviceProfile = targetProfile
});
}
return(null);
}
if (source.PixelFormat != destination.PixelFormat &&
(source.PixelFormat.ColorSpace != destination.PixelFormat.ColorSpace || source.PixelFormat.IsExtended != destination.PixelFormat.IsExtended ||
source.PixelFormat.IsIndexed != destination.PixelFormat.IsIndexed || (!source.PixelFormat.HasAlpha && destination.PixelFormat.HasAlpha)))
{
return(new ColorConverter
{
ColorManagementEngine = ColorManagementEngine.None,
DestinationPixelFormat = destination.PixelFormat
});
}
return(null);
}
protected internal abstract void DrawContent(Graphics graphics, IImageParams destImageParams, ColorManagement colorManagement);
internal override void Draw(Graphics graphics, IImageParams destImageParams, ColorManagement colorManagement)
{
FillShape(graphics, destImageParams, colorManagement);
StrokeShape(graphics, destImageParams, colorManagement);
}
public static Color ConvertColor(ColorManagement colorManagement, Color color, IImageParams destination)
{
var result = GetColorFromColorMap(colorManagement, color, destination);
if (result != null)
{
return(result);
}
var source = new ImageParams(color.PixelFormat, GetProfile(colorManagement, color.ColorSpace));
var colorConverter = GetColorConverter(colorManagement, source, destination);
return(colorConverter != null?colorConverter.ConvertColor(color, source.ColorProfile) : color);
}
private bool HasColorMap(IImageParams destination)
{
return(_colorMap != null && _colorMapDestinationPixelFormat == destination.PixelFormat &&
CompareProfiles(_colorMapDestinationColorProfile, destination.ColorProfile) &&
_colorMapTargetColorSpace == TargetColorSpace);
}
internal static Color GetColorFromColorMap(ColorManagement colorManagement, Color color, IImageParams destination)
{
if (colorManagement == null || !colorManagement.HasColorMap(destination))
{
return(null);
}
return(colorManagement._colorMap.GetColor(color));
}
