public BitMapSkipper(IBitmap bitmap, List<Point2D> points)
{
FromVectors(points);
CreateScans();
FillScans(points);
FormatScans(bitmap);
}
public void DrawImage(IBitmap source, double opacity, Rect sourceRect, Rect destRect)
{
var impl = (BitmapImpl) source.PlatformImpl;
var s = SkRect.FromRect(sourceRect);
var d = SkRect.FromRect(destRect);
MethodTable.Instance.DrawImage(Handle, impl.Handle, (float) opacity, ref s, ref d);
}
/// <summary>
///
/// </summary>
/// <param name="bitmap"></param>
public VideoTrack(IBitmap bitmap)
{
Contract.Requires(bitmap != null);
this.dimensions = new Size(bitmap.Width, bitmap.Height);
this.format = bitmap.Format;
}
public static Bitmap Fill(IBitmap contraints, VectorInt2 p)
{
var result = new Bitmap(contraints.Size);
FillCell(contraints, result, p);
return result;
}
public ActionSheetOptionViewModel(bool visible, string text, Action action, IBitmap image = null)
{
this.Text = text;
this.Action = new Command(action);
this.Visible = visible ? Visibility.Visible : Visibility.Collapsed;
this.ItemIcon = image;
}
public void Release(IBitmap bitmap)
{
if (!MathUtils.IsPowerOf2(bitmap.Width) ||
!MathUtils.IsPowerOf2(bitmap.Height)) return;
getPool(bitmap.Width, bitmap.Height).Release(bitmap);
}
/// <summary>
/// Initializes a new instance of the <see cref="Layer"/> class.
/// </summary>
/// <param name="owner"></param>
internal Layer(Image owner)
{
Contract.Requires(owner != null);
this.owner = owner;
this.content = owner.Format.CreateBitmap(owner.Size);
this.mask = owner.Format.CreateBitmap(owner.Size);
}
/// <summary>
/// Copy Constructor. Deep copy.
/// </summary>
/// <param name="copy"></param>
public Bitmap(IBitmap copy)
: this(copy.Size.X, copy.Size.Y)
{
for (int cy = 0; cy < copy.Size.Y; cy++)
for (int cx = 0; cx < copy.Size.X; cx++)
{
this[cx, cy] = copy[cx, cy];
}
}
/// <summary>
/// Init from a bitmap, setting on true positions to <paramref name="Value"/>
/// </summary>
/// <param name="Bitmap"></param>
/// <param name="Value"></param>
public Matrix(IBitmap Bitmap, float Value)
{
Size = Bitmap.Size;
for (int ccx = 0; ccx < Width; ccx++)
for (int ccy = 0; ccy < Height; ccy++)
{
if (Bitmap[ccx, ccy]) this[ccx, ccy] = Value;
}
}
public GLImage(IBitmap bitmap, string id, ITexture texture, ISpriteSheet spriteSheet, ILoadImageConfig loadConfig)
{
OriginalBitmap = bitmap;
Width = bitmap.Width;
Height = bitmap.Height;
ID = id;
Texture = texture;
SpriteSheet = spriteSheet;
LoadConfig = loadConfig;
}
public IObject GetDrawable(IArea area, IBitmap bg)
{
IWalkBehindArea walkBehind = area.GetComponent<IWalkBehindArea>();
if (walkBehind == null) return null;
AreaKey key = new AreaKey (area, bg);
IObject obj = _objects.GetOrAdd(key, () => createObject());
obj.Z = walkBehind.Baseline == null ? area.Mask.MinY : walkBehind.Baseline.Value;
obj.Image = _images.GetOrAdd(key, () => createImage(area, bg));
return obj;
}
public void DrawImage(IBitmap source, double opacity, Rect sourceRect, Rect destRect)
{
var impl = (BitmapImpl)source.PlatformImpl;
var s = sourceRect.ToSKRect();
var d = destRect.ToSKRect();
using (var paint = new SKPaint()
{ Color = new SKColor(255, 255, 255, (byte)(255 * opacity)) })
{
Canvas.DrawBitmap(impl.Bitmap, s, d, paint);
}
}
private void InvertBitmap(IBitmap bitmap)
{
for (int y = 0; y < bitmap.Height; y++)
for (int x = 0; x < bitmap.Width; x++)
{
var px = bitmap[x, y];
px.Red = 1.0f - px.Red;
px.Green = 1.0f - px.Green;
px.Blue = 1.0f - px.Blue;
bitmap[x, y] = px;
}
}
public SkyBox(IBitmap neg_x, IBitmap pos_x, IBitmap neg_y, IBitmap pos_y, IBitmap neg_z, IBitmap pos_z)
{
_config = Constants.Kernel.Get<RenderConfig>();
ITextureAtlasFactory atlasFactory = Constants.Kernel.Get<ITextureAtlasFactory>();
_atlas = atlasFactory.CreateTextureAtlas(new Size(_config.MaxTextureSize,_config.MaxTextureSize/2), new Size(_config.MaxTextureSize / 4, _config.MaxTextureSize / 4), 1);
_neg_x = _atlas.AddSubImage(neg_x);
_pos_x = _atlas.AddSubImage(pos_x);
_pos_y = _atlas.AddSubImage(pos_y);
_neg_y = _atlas.AddSubImage(neg_y);
_pos_z = _atlas.AddSubImage(pos_z);
_neg_z = _atlas.AddSubImage(neg_z);
}
public void DrawImage(IBitmap bitmap, double opacity, Rect sourceRect, Rect destRect)
{
var impl = bitmap.PlatformImpl as BitmapImpl;
var size = new Size(impl.PixelWidth, impl.PixelHeight);
var scaleX = destRect.Size.Width / sourceRect.Size.Width;
var scaleY = destRect.Size.Height / sourceRect.Size.Height;
_context.Save();
_context.Scale(scaleX, scaleY);
Gdk.CairoHelper.SetSourcePixbuf(_context, impl.Surface, (int)sourceRect.X, (int)sourceRect.Y);
_context.Rectangle(sourceRect.ToCairo());
_context.Fill();
_context.Restore();
}
private static void FillCell(IBitmap contraints, IBitmap result, VectorInt2 p)
{
if (p.X < 0 || p.Y < 0) return;
if (p.X > contraints.Size.X || p.Y > contraints.Size.Y) return;
if (contraints[p]) return;
if (result[p]) return;
result[p] = true;
FillCell(contraints, result, p + VectorInt2.Up);
FillCell(contraints, result, p + VectorInt2.Down);
FillCell(contraints, result, p + VectorInt2.Left);
FillCell(contraints, result, p + VectorInt2.Right);
}
public GLTexture2D(string name, IBitmap bmp, bool genmipmaps = false, bool linearfilter = false, OpenTK.Graphics.OpenGL.PixelFormat sourceformat = OpenTK.Graphics.OpenGL.PixelFormat.Bgra, PixelInternalFormat destformat = PixelInternalFormat.Rgba, PixelType sourcetype = PixelType.UnsignedByte)
: base(name, TextureTarget.Texture2D, bmp.Width, bmp.Height)
{
tex = GL.GenTexture();
GL.BindTexture(TextureTarget.Texture2D, tex);
reattempt_load:
try {
/*BitmapData bmpdata = bmp.LockBits(new Rectangle(0, 0, bmp.Width, bmp.Height), ImageLockMode.ReadOnly, System.Drawing.Imaging.PixelFormat.Format32bppArgb);
GL.TexImage2D(TextureTarget.Texture2D, 0, destformat, bmpdata.Width, bmpdata.Height, 0, sourceformat, sourcetype, bmpdata.Scan0);
bmp.UnlockBits(bmpdata);*/
bmp.TexImage2D(destformat);
}
catch(OutOfMemoryException) {
GC.WaitForPendingFinalizers();
goto reattempt_load;
}
if(genmipmaps)
{
GL.GenerateMipmap(GenerateMipmapTarget.Texture2D);
if(linearfilter)
{
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMinFilter, (int)TextureMinFilter.LinearMipmapLinear);
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMagFilter, (int)TextureMagFilter.Linear);
}
else
{
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMinFilter, (int)TextureMinFilter.NearestMipmapNearest);
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMagFilter, (int)TextureMagFilter.Nearest);
}
}
else
{
if(linearfilter)
{
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMinFilter, (int)TextureMinFilter.Linear);
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMagFilter, (int)TextureMagFilter.Linear);
}
else
{
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMinFilter, (int)TextureMinFilter.Nearest);
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMagFilter, (int)TextureMagFilter.Nearest);
}
}
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureWrapS, (int)TextureWrapMode.Clamp);
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureWrapT, (int)TextureWrapMode.Clamp);
}
public RGBLuminanceSource(IBitmap d, int W, int H)
: base(W, H) {
int width = __width = W;
int height = __height = H;
// In order to measure pure decoding speed, we convert the entire image to a greyscale array
// up front, which is the same as the Y channel of the YUVLuminanceSource in the real app.
luminances = new sbyte[width * height];
//if (format == PixelFormat.Format8bppIndexed)
{
Color c;
for (int y = 0; y < height; y++) {
int offset = y * width;
for (int x = 0; x < width; x++) {
c = d.GetPixel(x, y);
luminances[offset + x] = (sbyte)(((int)c.R) << 16 | ((int)c.G) << 8 | ((int)c.B));
}
}
}
}
public static Map<float> AverageOver(Map<float> input, IBitmap within, IBitmap start)
{
var res = new Map<float>(input);
var done = new Bitmap(start);
var hit = false;
do
{
hit = false;
foreach (var pos in done.TruePositions())
{
foreach (var dir in VectorInt2.Directions)
{
var p = pos + dir;
if (within[p] && !done[p])
{
float cc = 0;
float total = 0;
foreach (var around in VectorInt2.Directions)
{
var x = p + around;
if (within[x]) cc++;
if (done[x])
{
total += res[x];
}
}
if (cc > 0)
{
res[p] = total / cc;
done[p] = true;
hit = true;
break;
}
}
}
}
} while (hit);
return res;
}
/// <summary>
/// Draws a bitmap image.
/// </summary>
/// <param name="source">The bitmap image.</param>
/// <param name="opacity">The opacity to draw with.</param>
/// <param name="sourceRect">The rect in the image to draw.</param>
/// <param name="destRect">The rect in the output to draw to.</param>
public void DrawImage(IBitmap bitmap, double opacity, Rect sourceRect, Rect destRect)
{
var impl = bitmap.PlatformImpl as BitmapImpl;
var size = new Size(impl.PixelWidth, impl.PixelHeight);
var scale = new Vector(destRect.Width / sourceRect.Width, destRect.Height / sourceRect.Height);
_context.Save();
Gdk.CairoHelper.SetSourcePixbuf (
_context,
impl,
-sourceRect.X + destRect.X,
-sourceRect.Y + destRect.Y);
impl.Scale (impl, (int)destRect.X, (int)destRect.Y, (int)destRect.Width, (int)destRect.Height, 0, 0, scale.X, scale.Y, Gdk.InterpType.Bilinear);
_context.PushGroup ();
_context.Rectangle (destRect.ToCairo ());
_context.Fill ();
_context.PopGroupToSource ();
_context.PaintWithAlpha (opacityOverride);
_context.Restore();
}
/// <summary>
/// Draws a bitmap image.
/// </summary>
/// <param name="source">The bitmap image.</param>
/// <param name="opacity">The opacity to draw with.</param>
/// <param name="sourceRect">The rect in the image to draw.</param>
/// <param name="destRect">The rect in the output to draw to.</param>
public void DrawImage(IBitmap bitmap, double opacity, Rect sourceRect, Rect destRect)
{
var impl = bitmap.PlatformImpl as BitmapImpl;
var size = new Size(impl.PixelWidth, impl.PixelHeight);
var scale = new Vector(destRect.Width / sourceRect.Width, destRect.Height / sourceRect.Height);
_context.Save();
_context.Scale(scale.X, scale.Y);
destRect /= scale;
if (opacityOverride < 1.0f) {
_context.PushGroup ();
Gdk.CairoHelper.SetSourcePixbuf (
_context,
impl.Surface,
-sourceRect.X + destRect.X,
-sourceRect.Y + destRect.Y);
_context.Rectangle (destRect.ToCairo ());
_context.Fill ();
_context.PopGroupToSource ();
_context.PaintWithAlpha (opacityOverride);
} else {
_context.PushGroup ();
Gdk.CairoHelper.SetSourcePixbuf (
_context,
impl.Surface,
-sourceRect.X + destRect.X,
-sourceRect.Y + destRect.Y);
_context.Rectangle (destRect.ToCairo ());
_context.Fill ();
_context.PopGroupToSource ();
_context.PaintWithAlpha (opacityOverride);
}
_context.Restore();
}
public static IBitmap FillRectangle(this IBitmap bitmap, int left, int top, int width, int height, byte colour)
{
bitmap.Bitmap.FillRectangle(left, top, width, height, colour);
return(bitmap);
}
public static IBitmap DrawRectangle(this IBitmap bitmap, Point point, Size size, byte colour = 5) => DrawRectangle3D(bitmap, point.X, point.Y, size.Width, size.Height, colour, colour);
public static IBitmap DrawRectangle3D(this IBitmap bitmap, Rectangle rectangle, byte colourLight = 15, byte colourDark = 8) => DrawRectangle3D(bitmap, rectangle.X, rectangle.Y, rectangle.Width, rectangle.Height, colourLight, colourDark);
public static IBitmap DrawLine(this IBitmap bitmap, Point from, Point to, byte colour) => DrawLine(bitmap, from.X, from.Y, to.X, to.Y, colour = 5);
public Cursor(IBitmap cursor, PixelPoint hotSpot)
: this(GetCursorFactory().CreateCursor(cursor.PlatformImpl.Item, hotSpot))
{
}
protected Texture CreateTexture(IBitmap bitmap) => new Texture(_renderer, bitmap?.Palette, bitmap?.Bitmap);
void FormatScans(IBitmap bitmap) {
for (int index = 0; index < scans.Length; ++index) {
scans[index].Sort();
FormatScan(bitmap, index);
}
}
/// <summary>
/// Converts a <see cref="BitmapSource"/> to a splat <see cref="IBitmap"/>.
/// </summary>
/// <param name="value">The native bitmap to convert from.</param>
/// <returns>A <see cref="IBitmap"/> bitmap.</returns>
public static BitmapSource ToNative(this IBitmap value)
{
return(((BitmapSourceBitmap)value).Inner);
}
private IImage createImage(IBitmap bg)
{
var bitmap = bg.ApplyArea(_area);
return(_factory.Graphics.LoadImage(bitmap));
}
public IGraphics FromImage(IBitmap bitmap) => Graphics.FromImage(bitmap);
public void DrawBitmap(IBitmap bitmap, CanvasPointF pointF)
{
CheckUsability();
_graphics.DrawImage((Bitmap)bitmap.EngineElement, pointF.ToGdiPointF());
}
public WindowIcon(IBitmap bitmap)
{
PlatformImpl = AvaloniaLocator.Current.GetService <IPlatformIconLoader>().LoadIcon(bitmap.PlatformImpl.Item);
}
public IBitmap Transform(IBitmap source)
{
throw new Exception(DoNotReference);
}
public static Bitmap ToNative(this IBitmap This)
{
return(((BitmapBitmap)This).inner);
}
public static Vector2[] CreateFromBitmap(IBitmap bitmap) {
return Reduce(CreateFromBitmap(bitmap, GetFirst(bitmap)));
}
public static void SaveTiff16(string outputFilename, IBitmap <ushort> bitmap)
{
var bitmap2 = bitmap.Convert((p) => { return((ushort)(p - short.MinValue)); });
SaveTiff16(outputFilename, bitmap2);
}
private static List<Vector2> CreateFromBitmap(IBitmap bitmap, Vector2 first) {
Vector2 current = first;
Vector2 last = first - new Vector2(0, 1);
List<Vector2> result = new List<Vector2>();
do {
result.Add(current);
current = GetNextVertex(bitmap, current, last);
last = result[result.Count - 1];
} while (current != first);
if (result.Count < 3) {
throw new ArgumentException("The image has an area with less then 3 pixels (possibly an artifact).", "bitmap");
}
return result;
}
public static Vector2D[] CreateFromBitmap(IBitmap bitmap)
{
return(Reduce(CreateFromBitmap(bitmap, GetFirst(bitmap))));
}
private static IEnumerable<Vector2> GetFirsts(IBitmap bitmap, List<BitMapSkipper> skippers) {
for (int x = bitmap.Width - 1; x > -1; --x) {
for (int y = 0; y < bitmap.Height; ++y) {
if (bitmap[x, y]) {
bool contains = false;
Vector2 result = new Vector2(x, y);
for (int index = 0; index < skippers.Count; ++index) {
float nextY;
if (skippers[index].TryGetSkip(result, out nextY)) {
contains = true;
y = (int)nextY;
break;
}
}
if (!contains) {
yield return result;
}
}
}
}
}
public static IBitmap DrawRectangle3D(this IBitmap bitmap, Point point, Size size, byte colourLight = 15, byte colourDark = 8) => DrawRectangle3D(bitmap, point.X, point.Y, size.Width, size.Height, colourLight, colourDark);
public static IBitmap FillRectangle(this IBitmap bitmap, Point point, Size size, byte colour) => FillRectangle(bitmap, point.X, point.Y, size.Width, size.Height, colour);
public static IBitmap DrawRectangle(this IBitmap bitmap, int left = 0, int top = 0, int width = -1, int height = -1, byte colour = 5) => DrawRectangle3D(bitmap, left, top, width, height, colour, colour);
public IBitmap Transform(IBitmap sourceBitmap, string path, ImageSource source, bool isPlaceholder, string key)
{
throw new Exception(Common.DoNotReferenceMessage);
}
public static IBitmap DrawRectangle(this IBitmap bitmap, Rectangle rectangle, byte colour = 5) => DrawRectangle3D(bitmap, rectangle.X, rectangle.Y, rectangle.Width, rectangle.Height, colour, colour);
protected async override Task <WriteableBitmap> GenerateImageAsync(string path, ImageSource source, Stream imageData, ImageInformation imageInformation, bool enableTransformations, bool isPlaceholder)
{
BitmapHolder imageIn = null;
if (imageData == null)
{
throw new ArgumentNullException(nameof(imageData));
}
ThrowIfCancellationRequested();
try
{
// Special case to handle WebP decoding on Windows
string ext = null;
if (!string.IsNullOrWhiteSpace(path))
{
if (source == ImageSource.Url && Uri.IsWellFormedUriString(path, UriKind.RelativeOrAbsolute))
{
ext = Path.GetExtension(new Uri(path).LocalPath).ToLowerInvariant();
}
else
{
ext = Path.GetExtension(path).ToLowerInvariant();
}
}
bool allowUpscale = Parameters.AllowUpscale ?? Configuration.AllowUpscale;
if (source != ImageSource.Stream && ext == ".webp")
{
throw new NotImplementedException("Webp is not implemented on Windows");
}
else if (enableTransformations && Parameters.Transformations != null && Parameters.Transformations.Count > 0)
{
imageIn = await imageData.ToBitmapHolderAsync(Parameters.DownSampleSize, Parameters.DownSampleUseDipUnits, Parameters.DownSampleInterpolationMode, allowUpscale, imageInformation).ConfigureAwait(false);
}
else
{
return(await imageData.ToBitmapImageAsync(Parameters.DownSampleSize, Parameters.DownSampleUseDipUnits, Parameters.DownSampleInterpolationMode, allowUpscale, imageInformation).ConfigureAwait(false));
}
}
finally
{
imageData?.Dispose();
}
ThrowIfCancellationRequested();
if (enableTransformations && Parameters.Transformations != null && Parameters.Transformations.Count > 0)
{
var transformations = Parameters.Transformations.ToList();
await _decodingLock.WaitAsync().ConfigureAwait(false); // Applying transformations is both CPU and memory intensive
try
{
foreach (var transformation in transformations)
{
ThrowIfCancellationRequested();
var old = imageIn;
try
{
IBitmap bitmapHolder = transformation.Transform(imageIn, path, source, isPlaceholder, Key);
imageIn = bitmapHolder.ToNative();
}
catch (Exception ex)
{
Logger.Error(string.Format("Transformation failed: {0}", transformation.Key), ex);
throw;
}
finally
{
if (old != null && old != imageIn && old.PixelData != imageIn.PixelData)
{
old.FreePixels();
old = null;
}
}
}
}
finally
{
_decodingLock.Release();
}
}
try
{
return(await imageIn.ToBitmapImageAsync());
}
finally
{
imageIn.FreePixels();
imageIn = null;
}
}
protected virtual void AddActionSheetOption(ActionSheetOption opt, UIAlertController controller, UIAlertActionStyle style, IBitmap image = null)
{
var alertAction = UIAlertAction.Create(opt.Text, style, x => opt.Action?.Invoke());
if (opt.ItemIcon == null && image != null)
{
opt.ItemIcon = image;
}
if (opt.ItemIcon != null)
{
alertAction.SetValueForKey(opt.ItemIcon.ToNative(), new NSString("image"));
}
controller.AddAction(alertAction);
}
public override void ShowImage(IBitmap image, string message, int timeoutMillis)
{
BTProgressHUD.ShowImage(image.ToNative(), message, timeoutMillis);
//this.ShowWithOverlay(timeoutMillis, () => BTProgressHUD.ShowImage(image.ToNative(), message, timeoutMillis));
}
public IBitmap Transform(IBitmap source)
{
throw new Exception(Common.DoNotReferenceMessage);
}
protected async override Task <WriteableBitmap> GenerateImageAsync(string path, ImageSource source, Stream imageData, ImageInformation imageInformation, bool enableTransformations, bool isPlaceholder)
{
BitmapHolder imageIn = null;
if (imageData == null)
{
throw new ArgumentNullException(nameof(imageData));
}
ThrowIfCancellationRequested();
try
{
bool allowUpscale = Parameters.AllowUpscale ?? Configuration.AllowUpscale;
if (source != ImageSource.Stream && imageInformation.Type == ImageInformation.ImageType.WEBP)
{
throw new NotImplementedException("Webp is not implemented on Windows");
}
else if (enableTransformations && Parameters.Transformations != null && Parameters.Transformations.Count > 0)
{
imageIn = await imageData.ToBitmapHolderAsync(Parameters.DownSampleSize, Parameters.DownSampleUseDipUnits, Parameters.DownSampleInterpolationMode, allowUpscale, imageInformation).ConfigureAwait(false);
}
else
{
return(await imageData.ToBitmapImageAsync(Parameters.DownSampleSize, Parameters.DownSampleUseDipUnits, Parameters.DownSampleInterpolationMode, allowUpscale, imageInformation).ConfigureAwait(false));
}
}
finally
{
imageData.TryDispose();
}
ThrowIfCancellationRequested();
if (enableTransformations && Parameters.Transformations != null && Parameters.Transformations.Count > 0)
{
var transformations = Parameters.Transformations.ToList();
await _decodingLock.WaitAsync(CancellationTokenSource.Token).ConfigureAwait(false); // Applying transformations is both CPU and memory intensive
ThrowIfCancellationRequested();
try
{
foreach (var transformation in transformations)
{
ThrowIfCancellationRequested();
var old = imageIn;
try
{
IBitmap bitmapHolder = transformation.Transform(imageIn, path, source, isPlaceholder, Key);
imageIn = bitmapHolder.ToNative();
}
catch (Exception ex)
{
Logger.Error(string.Format("Transformation failed: {0}", transformation.Key), ex);
throw;
}
finally
{
if (old != null && old != imageIn && old.PixelData != imageIn.PixelData)
{
old.FreePixels();
old = null;
}
}
}
}
finally
{
_decodingLock.Release();
}
}
try
{
return(await imageIn.ToBitmapImageAsync());
}
finally
{
imageIn.FreePixels();
imageIn = null;
}
}
public ActionSheetOption(string text, Action action = null, IBitmap icon = null) {
this.Text = text;
this.Action = action;
this.ItemIcon = icon;
}
/// <summary>
/// Draws a bitmap image.
/// </summary>
/// <param name="source">The bitmap image.</param>
/// <param name="opacity">The opacity to draw with.</param>
/// <param name="sourceRect">The rect in the image to draw.</param>
/// <param name="destRect">The rect in the output to draw to.</param>
/// <param name="bitmapInterpolationMode">The bitmap interpolation mode.</param>
public void DrawImage(IBitmap source, double opacity, Rect sourceRect, Rect destRect, BitmapInterpolationMode bitmapInterpolationMode = default)
{
Contract.Requires <ArgumentNullException>(source != null);
PlatformImpl.DrawImage(source.PlatformImpl, opacity, sourceRect, destRect, bitmapInterpolationMode);
}
void FormatScan(IBitmap bitmap, int x) {
List<float> scan = scans[x];
List<float> newScan = new List<float>();
bool inPoly = false;
for (int index = 0; index < scan.Count; ++index) {
float y = scan[index];
if (!inPoly) {
newScan.Add(y);
}
bool value = bitmap[(int)(x + xMin), (int)y + 1];
if (value) {
inPoly = true;
}
else {
newScan.Add(y);
inPoly = false;
}
}
//if (newScan.Count % 2 != 0) { throw new Exception(); }
scans[x] = newScan;
}
public void RenderAreaSymbol(RenderContext renderContext, Display display, int priority, IBitmap symbol, PolylineContainer way)
{
Point centerPosition = way.CenterAbsolute;
renderContext.labels.Add(new SymbolContainer(centerPosition, display, priority, symbol));
}
public static Vector2[][] CreateManyFromBitmap(IBitmap bitmap) {
List<BitMapSkipper> skippers = new List<BitMapSkipper>();
List<Vector2[]> result = new List<Vector2[]>();
foreach (Vector2 first in GetFirsts(bitmap, skippers)) {
List<Vector2> points = CreateFromBitmap(bitmap, first);
BitMapSkipper skipper = new BitMapSkipper(bitmap, points);
skippers.Add(skipper);
result.Add(Reduce(points));
}
return result.ToArray();
}
public void RenderPointOfInterestSymbol(RenderContext renderContext, Display display, int priority, IBitmap symbol, PointOfInterest poi)
{
Point poiPosition = MercatorProjection.GetPixelAbsolute(poi.Position, renderContext.rendererJob.tile.MapSize);
renderContext.labels.Add(new SymbolContainer(poiPosition, display, priority, symbol));
}
private static Vector2 GetFirst(IBitmap bitmap) {
for (int x = bitmap.Width - 1; x > -1; --x) {
for (int y = 0; y < bitmap.Height; ++y) {
if (bitmap[x, y]) {
return new Vector2(x, y);
}
}
}
throw new ArgumentException("TODO", "bitmap");
}
public void RenderWaySymbol(RenderContext renderContext, Display display, int priority, IBitmap symbol, float dy, bool alignCenter, bool repeat, float repeatGap, float repeatStart, bool rotate, PolylineContainer way)
{
WayDecorator.RenderSymbol(symbol, display, priority, dy, alignCenter, repeat, repeatGap, repeatStart, rotate, way.CoordinatesAbsolute, renderContext.labels);
}
private static Vector2 GetNextVertex(IBitmap bitmap, Vector2 current, Vector2 last) {
int offset = 0;
Vector2 point;
for (int index = 0; index < bitmapPoints.Length; ++index) {
point = current + bitmapPoints[index];
if (point == last) {
offset = index + 1;
break;
}
}
for (int index = 0; index < bitmapPoints.Length; ++index) {
point = current + bitmapPoints[(index + offset) % bitmapPoints.Length];
if (point.x >= 0 && point.x < bitmap.Width &&
point.y >= 0 && point.y < bitmap.Height &&
bitmap[(int)point.x, (int)point.y]) {
return point;
}
}
throw new ArgumentException("The image has an area with less then 3 pixels (possibly an artifact).", "bitmap");
}
public static Path ConvertSolutionNodeToPath(SolverNode node, IBitmap walls, Puzzle puzzle)
{
if (node.Evaluator.GetType() == typeof(ReverseEvaluator))
{
var pathToRoot = node.PathToRoot().ToList();
pathToRoot.Reverse();
var offset = GeneralHelper.OffsetWalk(pathToRoot).ToList();
var r = new Path();
var cc = 0;
// PuzzleStart to First Push
var b = walls.BitwiseOR(puzzle.ToMap(puzzle.Definition.AllCrates));
var f = puzzle.Player.Position;
var t = pathToRoot[0].PlayerAfter;
var first = PathFinder.Find(b, f, t);
if (first == null)
{
//throw new Exception(string.Format("Bad Path at INIT. {0} => {1}. This is an indicator or a FALSE positive. Ie. An invalid start position.\n{2}", f, t, b)); // Not solution
return(null);
}
r.AddRange(first);
foreach (var pair in offset)
{
if (pair.Item2.Parent == null)
{
break;
}
r.Add(pair.Item1.PlayerBefore - pair.Item1.PlayerAfter);
var boundry = walls.BitwiseOR(pair.Item2.CrateMap);
var start = pair.Item1.PlayerBefore;
var end = pair.Item2.PlayerAfter;
var walk = PathFinder.Find(boundry, start, end);
if (walk == null)
{
throw new Exception($"Bad Path at step {cc}\n"); // Not solution
}
r.AddRange(walk);
//Console.WriteLine("PAIR: {0}", cc);
//Console.WriteLine("{0} => {1}", pair.Item1.PlayerBefore, pair.Item1.PlayerAfter);
//Console.WriteLine(pair.Item1.ToStringDebug());
//Console.WriteLine("{0} => {1}", pair.Item2.PlayerBefore, pair.Item2.PlayerAfter);
//Console.WriteLine(pair.Item2.ToStringDebug());
//var debug = boundry.ToCharMap();
//debug[start] = 'S';
//debug[end] = 'E';
//var d = debug.ToString();
//Console.WriteLine(d);
//Console.WriteLine(r);
cc++;
}
if (pathToRoot.Count > 1)
{
var last = pathToRoot[pathToRoot.Count - 2];
r.Add(last.PlayerBefore - last.PlayerAfter);
}
return(r);
}
return(ConvertForwardNodeToPath(node, walls));
}
