/// <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; }