/// <summary>
/// Rotate and/or flip bitmap
/// </summary>
/// <param name="bitmap">Image</param>
/// <param name="type">Operation</param>
/// <returns>Modified bitmap</returns>
static public Bitmap RotateFlip(Bitmap bitmap, RotationAngle angle, FlipAxis axis)
{
if (bitmap == null)
{
throw new ArgumentNullException();
}
IBitmapImage image = BitmapToIImageBitmap(bitmap);
try
{
IBitmapImage imageBitmap = BitmapToIImageBitmap(bitmap);
IBasicBitmapOps ops = (IBasicBitmapOps)imageBitmap;
if (angle != 0)
{
ops.Rotate((float)angle, InterpolationHint.InterpolationHintDefault, out imageBitmap);
Marshal.FinalReleaseComObject(ops);
ops = (IBasicBitmapOps)imageBitmap;
}
if (axis != FlipAxis.None)
{
ops.Flip((axis & FlipAxis.X) == FlipAxis.X, (axis & FlipAxis.Y) == FlipAxis.Y, out imageBitmap);
Marshal.FinalReleaseComObject(ops);
ops = (IBasicBitmapOps)imageBitmap;
}
return(IBitmapImageToBitmap(imageBitmap));
}
finally
{
Marshal.FinalReleaseComObject(image);
}
}
public override void Flip(FlipAxis flip, GridLayout.CellLayout layout)
{
if (UnityEngine.Event.current.character == '>')
{
// TODO flip?
}
}
public static extern int mirror(
int bitsPerPixel,
int x,
int y,
int width,
int height,
[In, Out] ulong[] src,
int srcstep,
[Out] ulong[] dst,
int dststep,
FlipAxis flip);
/// <summary>
/// Flips all drag points on a given axis.
/// </summary>
/// <param name="flipAxis">Axis to flip on</param>
public void FlipDragPoints(FlipAxis flipAxis)
{
if (_dragPointsInspector.HandleType != ItemDataTransformType.ThreeD && flipAxis == FlipAxis.Z)
{
return;
}
PrepareUndo($"Flip-{flipAxis} Drag Points");
DragPointsHandler.FlipDragPoints(flipAxis);
RebuildMeshes();
}
/// <summary>Flips the brush in the given axis.</summary>
/// <param name="flip">Axis to flip by.</param>
/// <param name="layout">Cell Layout for flipping.</param>
public override void Flip(FlipAxis flip, Grid.CellLayout layout)
{
if (flip == FlipAxis.X)
{
FlipX();
}
else
{
FlipY();
}
}
public override void Flip(FlipAxis flip, GridLayout.CellLayout layout)
{
base.Flip(flip, layout);
if (flip == FlipAxis.X)
{
AddToPrefabRotation(Vector3.up * 180);
}
else if (flip == FlipAxis.Y)
{
AddToPrefabRotation(Vector3.forward * 180);
}
}
public override void Flip(FlipAxis flip, GridLayout.CellLayout layout)
{
if (gridBrushes == null)
{
return;
}
foreach (var gridBrush in gridBrushes)
{
gridBrush.Flip(flip, layout);
}
}
// Deprecated in v 2.3 with no error
static public Bitmap RotateFlip(Bitmap bitmap, RotateFlipType type)
{
if (bitmap == null)
{
throw new ArgumentNullException();
}
RotationAngle angle = RotationAngle.Zero;
FlipAxis axis = FlipAxis.None;
switch (type)
{
case RotateFlipType.RotateNoneFlipX:
axis = FlipAxis.X;
break;
case RotateFlipType.Rotate90FlipX:
axis = FlipAxis.X;
angle = RotationAngle.Clockwise90;
break;
case RotateFlipType.Rotate270FlipX:
angle = RotationAngle.Clockwise270;
axis = FlipAxis.X;
break;
case RotateFlipType.RotateNoneFlipXY:
axis = FlipAxis.X | FlipAxis.Y;
break;
case RotateFlipType.Rotate90FlipXY:
angle = RotationAngle.Clockwise90;
axis = FlipAxis.X | FlipAxis.Y;
break;
case RotateFlipType.Rotate180FlipXY:
angle = RotationAngle.Clockwise180;
axis = FlipAxis.X | FlipAxis.Y;
break;
case RotateFlipType.Rotate270FlipXY:
angle = RotationAngle.Clockwise270;
axis = FlipAxis.X | FlipAxis.Y;
break;
case RotateFlipType.RotateNoneFlipY:
axis = FlipAxis.Y;
break;
}
return(RotateFlip(bitmap, angle, axis));
}
/// <summary>
/// Flips the bitmap along the given axis
/// </summary>
public static Bitmap Flip(Bitmap image, FlipAxis Axis)
{
try
{
image.RotateFlip(Axis == FlipAxis.X ? RotateFlipType.RotateNoneFlipX :
RotateFlipType.RotateNoneFlipY);
}
catch (Exception ex)
{
Global.WriteToLog(ex);
}
return(image);
}
/// <summary>
/// Flips all drag points on a given axis.
/// </summary>
/// <param name="flipAxis">Axis to flip on</param>
public void FlipDragPoints(FlipAxis flipAxis)
{
if (!(target is IDragPointsEditable editable))
{
return;
}
if (editable.GetHandleType() != ItemDataTransformType.ThreeD && flipAxis == FlipAxis.Z)
{
return;
}
PrepareUndo($"Flip drag points on {flipAxis} axis");
DragPointsHandler.FlipDragPoints(flipAxis);
}
/// <summary>
/// Flips image around X and/or Y axes
/// </summary>
/// <param name="bitmap">Image</param>
/// <param name="axis">Axis or axes to flip on</param>
private static Bitmap Flip(IBitmapImage image, FlipAxis axis)
{
Bitmap bmRet;
IBitmapImage imageBitmap;
IBasicBitmapOps ops = (IBasicBitmapOps)image;
ops.Flip((axis & FlipAxis.X) == FlipAxis.X, (axis & FlipAxis.Y) == FlipAxis.Y, out imageBitmap);
try
{
bmRet = IBitmapImageToBitmap(imageBitmap);
}
finally
{
Marshal.FinalReleaseComObject(imageBitmap);
}
return(bmRet);
}
/// <summary>
/// Flips image around X and/or Y axes
/// </summary>
/// <param name="bitmap">Image</param>
/// <param name="axis">Axis or axes to flip on</param>
static public Bitmap Flip(Bitmap bitmap, FlipAxis axis)
{
if (bitmap == null)
{
throw new ArgumentNullException();
}
IBitmapImage image = BitmapToIImageBitmap(bitmap);
try
{
return(Flip(image, axis));
}
finally
{
Marshal.FinalReleaseComObject(image);
}
}
protected override void ProcessRecord()
{
if (!ShouldProcess(FileImage.FileInfo.ToString(), "Flip Image"))
{
return;
}
FlipAxis axis = Axis[0];
if (axis == FlipAxis.Horizontal || axis == FlipAxis.Both)
{
FileImage.Image.Mutate(im => im.Flip(FlipMode.Horizontal));
}
if (axis == FlipAxis.Vertical || axis == FlipAxis.Both)
{
FileImage.Image.Mutate(im => im.Flip(FlipMode.Vertical));
}
WriteObject(FileImage);
}
// Deprecated in v 2.3 with no error
static public Bitmap Flip(Bitmap bitmap, bool flipX, bool flipY)
{
if (bitmap == null)
{
throw new ArgumentNullException();
}
FlipAxis axis = FlipAxis.None;
if (flipX)
{
axis |= FlipAxis.X;
}
if (flipY)
{
axis |= FlipAxis.Y;
}
return(Flip(bitmap, axis));
}
/// <summary>
/// Flips all drag points around the given axis.
/// </summary>
/// <param name="flipAxis">Axis to flip</param>
public void FlipDragPoints(FlipAxis flipAxis)
{
var axis = flipAxis == FlipAxis.X
? _flipAxis.x
: flipAxis == FlipAxis.Y ? _flipAxis.y : _flipAxis.z;
var offset = DragPointEditable.GetEditableOffset();
var wlMat = Transform.worldToLocalMatrix;
foreach (var controlPoint in ControlPoints)
{
var coord = flipAxis == FlipAxis.X
? controlPoint.WorldPos.x
: flipAxis == FlipAxis.Y
? controlPoint.WorldPos.y
: controlPoint.WorldPos.z;
coord = axis + (axis - coord);
switch (flipAxis)
{
case FlipAxis.X:
controlPoint.WorldPos.x = coord;
break;
case FlipAxis.Y:
controlPoint.WorldPos.y = coord;
break;
case FlipAxis.Z:
controlPoint.WorldPos.z = coord;
break;
default:
throw new ArgumentOutOfRangeException(nameof(flipAxis), flipAxis, null);
}
controlPoint.UpdateDragPoint(DragPointEditable, Transform);
}
}
/// <summary>
/// Mirrors this <see cref="Image"/> about the specified axis.
/// </summary>
/// <param name="dst">The destination <see cref="Image"/>. Can be <b>null</b>.</param>
/// <param name="flip">The axis to flip the image about.</param>
/// <returns>
/// The destination <see cref="Image"/>.
/// </returns>
/// <exception cref="NotSupportedException">
/// <para>The depth of this <see cref="Image"/> is neither 8 nor 24 nor 32 bits per pixel.</para>
/// </exception>
/// <remarks>
/// <para>If <paramref name="dst"/> is <b>null</b> the method creates new destination <see cref="Image"/> with dimensions of this <see cref="Image"/>.</para>
/// <para>If <paramref name="dst"/> equals this <see cref="Image"/>, the operation is performed in-place.</para>
/// <para>Conversely, the <paramref name="dst"/> is reallocated to the dimensions of this <see cref="Image"/>.</para>
/// </remarks>
public Image Flip(Image dst, FlipAxis flip)
{
if (this.BitsPerPixel != 8 && this.BitsPerPixel != 24 && this.BitsPerPixel != 32)
{
throw new NotSupportedException(string.Format(
CultureInfo.InvariantCulture,
Properties.Resources.E_UnsupportedDepth,
this.BitsPerPixel));
}
if (flip == Imaging.FlipAxis.None)
{
return(this.Copy(dst, true));
}
else
{
dst = this.Copy(dst, false);
IPP.Execute(() =>
{
return(NativeMethods.mirror(
this.BitsPerPixel,
0,
0,
this.Width,
this.Height,
this.Bits,
this.Stride8,
dst == this ? null : dst.Bits,
dst.Stride8,
flip));
});
return(dst);
}
}
public Flip(FlipAxis direction)
{
this.Direction = direction;
}
public virtual void Flip(FlipAxis flip, GridLayout.CellLayout layout)
{
}
/// <summary>
/// Creates and initializes a new instance of the FlipEffect class.
/// </summary>
/// <param name="axis">Flipping axis (X or Y).</param>
/// <param name="clockWise">Flipping Direction. True is clockwise.</param>
/// <param name="resizable">Resizable effect with FlipEffect.</param>
/// <since_tizen> preview </since_tizen>
public FlipEffect(FlipAxis axis, bool clockWise, bool resizable = false)
{
_axis = axis;
_clockWise = clockWise;
_resizable = resizable;
}
public override void Flip(FlipAxis flip, Grid.CellLayout layout)
{
Debug.Log("Flip not supported");
}
public static Flip New(FlipAxis direction) => new Flip(direction);
public MoveAlgorithm(FlipAxis axis, RotationType type)
{
IsFlip = true;
Axis = axis;
RotationType = type;
}
static DoubleAnimation MakeRotationAnimation(PlaneProjection planeProjection, FlipAxis axis, FlipDirection direction, Duration duration)
{
DoubleAnimation da = new DoubleAnimation();
da.Duration = duration;
switch (axis)
{
case FlipAxis.Vertical:
da.By = direction == FlipDirection.Backwards ? -90 : 90;
break;
case FlipAxis.Horizontal:
da.By = direction == FlipDirection.Backwards ? 90 : -90;
break;
default:
break;
}
Storyboard.SetTarget(da, planeProjection);
Storyboard.SetTargetProperty(da, new PropertyPath(
axis == FlipAxis.Vertical ? "RotationX" : "RotationY"));
return (da);
}
/// <summary>
/// Rotates an element x number of times in based on submitted repeat times.
///
///
/// <Usage>
///
/// FlipOnAxisStoryboard(myGrid, 0, -180, FlipAxis.FlipOnXAxis, 3, 2);
///
/// </Usage>
/// </summary>
/// <param name="element">FrameworkElement to be moved.</param>
/// <param name="from">Double defining starting position.</param>
/// <param name="to">Double defining ending position.</param>
/// <param name="flipAxis">Enumerated value indicating axis to perform the rotation on.</param>
/// <param name="duration">Double defining the duration of rotation to the ending position</param>
/// <param name="repeatTimes"></param>
/// <returns></returns>
public static Storyboard FlipOnAxisStoryboard(FrameworkElement element, double from, double to, FlipAxis flipAxis, double duration = 3, double repeatTimes = 1)
{
if (element.Projection == null)
{
element.Projection = new PlaneProjection();
}
else if (element.Projection.GetType() != typeof(PlaneProjection))
{
element.Projection = new PlaneProjection();
}
Storyboard storyboard = new Storyboard();
DoubleAnimation doubleAnimationRotate = new DoubleAnimation();
doubleAnimationRotate.From = from;
doubleAnimationRotate.To = to * repeatTimes;
doubleAnimationRotate.Duration = TimeSpan.FromMilliseconds(duration);
switch (flipAxis)
{
case FlipAxis.FlipOnXAxis:
Storyboard.SetTargetProperty(doubleAnimationRotate, PlaneProjectPropertyRotationX);
break;
case FlipAxis.FlipOnYAxis:
Storyboard.SetTargetProperty(doubleAnimationRotate, PlaneProjectPropertyRotationY);
break;
default:
Storyboard.SetTargetProperty(doubleAnimationRotate, PlaneProjectPropertyRotationX);
break;
}
Storyboard.SetTarget(doubleAnimationRotate, element);
return(storyboard);
}
public static extern int imaqFlip(IntPtr dest, IntPtr source, FlipAxis axis);
public void FlipCube(FlipAxis axis, RotationType direction)
{
RotationIndex[] rotationOrder;
if (axis == FlipAxis.Horizontal)
{
rotationOrder = direction == RotationType.Clockwise ? _facesNearestLayers[LayerType.Right] : _facesNearestLayers[LayerType.Right].Reverse().ToArray();
GetFace(FaceType.Right).Rotate90Degrees(direction);
GetFace(FaceType.Left).Rotate90Degrees(direction == RotationType.Clockwise ? RotationType.CounterClockwise : RotationType.Clockwise);
}
else
{
rotationOrder = direction == RotationType.Clockwise ? _facesNearestLayers[LayerType.Top] : _facesNearestLayers[LayerType.Top].Reverse().ToArray();
GetFace(FaceType.Up).Rotate90Degrees(direction);
GetFace(FaceType.Down).Rotate90Degrees(direction == RotationType.Clockwise ? RotationType.CounterClockwise : RotationType.Clockwise);
}
var faceTypes = rotationOrder.Select(o => o.Face);
var faces = (from ft in faceTypes
join f in Faces
on ft equals f.Type
select f).ToArray();
Face prevFace = null;
FacePieceType[,] prevField = null;
for (int i = 0; i <= faces.Length; i++)
{
var face = faces[i % faces.Length];
var rotationItem = rotationOrder[i % faces.Length];
var field = face.Field;
if (i == 0)
{
prevFace = face;
prevField = face.Field;
}
else
{
if ((face.Type == FaceType.Back || prevFace.Type == FaceType.Back) && axis == FlipAxis.Horizontal)
{
var thisField = (FacePieceType[, ])face.Field.Clone();
for (int k = 0; k < 9; k++)
{
int x = 0;
int y = 0;
Face.GetIndecies(8 - k, out x, out y);
face[k] = prevField[x, y];
}
prevField = thisField;
}
else
{
var thisField = (FacePieceType[, ])face.Field.Clone();
face.Field = (FacePieceType[, ])prevField.Clone();
prevField = thisField;
}
prevFace = face;
}
}
}
public override void Flip(FlipAxis flip, GridLayout.CellLayout layout)
{
//Debug.Log("Flip(FlipAxis flip, GridLayout.CellLayout layout)");
base.Flip(flip, layout);
}
public Flip(FlipAxis axis)
{
Axis = axis;
}
public override void Flip(FlipAxis flip, GridLayout.CellLayout layout)
{
flipAxis = flip;
base.Flip(flip, layout);
}
static DoubleAnimation MakeRotationAnimation(PlaneProjection planeProjection, FlipAxis axis, FlipDirection direction, Duration duration)
{
DoubleAnimation da = new DoubleAnimation();
da.Duration = duration;
switch (axis)
{
case FlipAxis.Vertical:
da.By = direction == FlipDirection.Backwards ? -90 : 90;
break;
case FlipAxis.Horizontal:
da.By = direction == FlipDirection.Backwards ? 90 : -90;
break;
default:
break;
}
Storyboard.SetTarget(da, planeProjection);
Storyboard.SetTargetProperty(da, new PropertyPath(
axis == FlipAxis.Vertical ? "RotationX" : "RotationY"));
return(da);
}
public FlipTransform(FlipAxis axis)
{
Axis = axis;
}
