public FloatPoint Limit(FloatPoint min, FloatPoint max) { var result = this.Clone(); result.X = result.X.MinMax(min.X, max.X).ToSingle(); result.Y = result.Y.MinMax(min.Y, max.Y).ToSingle(); return(result); }
static public FloatPoint Average(params FloatPoint[] xp) { FloatPoint p = new FloatPoint(0); foreach (FloatPoint pt in xp) { p += pt; } return(p / xp.Length); }
public static void DoCircle(Graphics gfx, Pen pen, float phase, FloatPoint O, int M, int R) { for (float i=-M;i<M;i++) { double ox = -Math.Sin(cvt(M,i+phase)); double oy = Math.Cos(cvt(M,i+phase)); double nx = -Math.Sin(cvt(M,i+1+phase)); double ny = Math.Cos(cvt(M,i+1+phase)); gfx.DrawLine( pen, (float)(ox*R)+O.X,(float)(oy*R)+O.Y, (float)(nx*R)+O.X,(float)(ny*R)+O.Y ); } }
/// ? Not quite sure if this works /// <returns></returns> /// <param name="PhaseOffset"> /// Zero-Point or the offset from N=0. /// Positive moves from north to east at circumference. /// </param> /// <param name="CircumferencePoints">Number of Points on the path</param> /// <param name="Radius">Radius</param> public static System.Drawing.Drawing2D.GraphicsPath CirclePath(FloatPoint PhaseOffset, int CircumferencePoints, int Radius) { var P = new PointF[Radius]; var T = new byte[Radius]; for (int i=0; i < CircumferencePoints; i++) { FloatPoint point = CirclePoint(i,CircumferencePoints)+PhaseOffset; /*double ox = -Math.Sin(cvt(M,i)), oy = Math.Cos(cvt(M,i)); P[i]=new FloatPoint((float)(ox*R)+O.X,(float)(oy*R)+O.Y); T[i] = (byte)PatFPointType.Line;*/ } T[0] = (byte)System.Drawing.Drawing2D.PathPointType.Start; T[T.Length-1] = (byte)System.Drawing.Drawing2D.PathPointType.CloseSubpath; return new System.Drawing.Drawing2D.GraphicsPath(P,T); }
/// <summary> /// /// </summary> /// <param name="dest"></param> /// <param name="source"></param> /// <param name="ScaleFlagBit"> 0x00 | (width) 0x01 | (height) 0x02 = 0x03 so you can check both width and height bits with a value of three.</param> /// <returns></returns> static public FloatPoint Fit(FloatPoint dest, FloatPoint source, int ScaleFlagBit) { FloatPoint HX = dest / source; if (ScaleFlagBit == 0) { return(Fit(dest, source, 1)); } else { return((ScaleFlagBit == 1) ? source * HX.X : source *HX.Y); } }
private Point Pt2Px(FloatPoint point) { var edge = new double[,] { { -18.88, -9.44 }, { 18.88, 9.44 } }; var image = new double[,] { { 0, 0 }, { 4096, 2048 } }; var widthRatio = (edge[1, 0] - edge[0, 0]) / (image[1, 0] - image[0, 0]); var heightRatio = (edge[1, 1] - edge[0, 1]) / (image[1, 1] - image[0, 1]); double x = (point.X - 37.76 / 2)/widthRatio; if (x<0) x+=4096; if (x>4096) x-=4096; var y=(int)((point.Y+edge[1, 1]) / heightRatio); return new Point() { X = (int)x, Y = 2048-y }; }
/// <summary>use Flat or flatten calls.</summary> public FloatPoint ScaleTo(FloatPoint point) { if (point.X == X && point.Y == Y) { throw new InvalidOperationException("you mucker"); } System.Windows.Forms.MessageBox.Show(string.Format("X: {1},Y: {0}", Y / point.Y, X / point.X)); if (X > point.Y) { #if CONSOLE && COR3 Global.cstat(ConsoleColor.Red, "X is BIGGER"); #else Debug.Print("X is BIGGER"); #endif } #if CONSOLE && COR3 else { Global.cstat(ConsoleColor.Red, "X is SMALLER"); }
/// <summary> /// Approximates: PianoCalculator, Key, Count, Quarter and Pulse. /// Also acts as storage for LoopPoint (piano-view transport or /// buffer-transport). /// </summary> /// <param name="clientMouse">(stored); ClientInput</param> /// <param name="loopRegion">(stored); LoopRegion</param> /// <param name="pxNode">(ref) ignored after usage (only referenced)</param> /// <param name="wedge">(stored); Typically (in local terms): pxNode.X * 4 * 4</param> /// <param name="multiply">(stored); Typically 4</param> /// <param name="division">(stored); From sequencer or midi program</param> /// <param name="upper">(stored); Top visible midi key. (Key and Count values are provided from this value in relation to clientMouse)</param> public NoteTransport( FloatPoint clientMouse, LoopPoint loopRegion, FloatPoint pxNode, double wedge, double multiply, double division, double upper) { this.ClientInput = clientMouse; this.loopRegion = loopRegion; this.pianoInfo = PianoCalculator.Create(clientMouse,pxNode.X*4); this.wedge = wedge; // nodewidth * 4 * 4 this.multiply = multiply; // 4 this.division = division; // quarter bar // beat measure // wedge * multiply == nodewidth * 4 * 4 * 4 Quarter = ClientInput.X / wedge * multiply; Pulse = GetPulses(division); Upper = upper; Key = Upper.ToInt32() - Convert.ToDouble(ClientInput.Y/pxNode.Y).FloorMinimum(0).ToInt32(); Count = Convert.ToDouble(pxNode.Y).FloorMinMax(0,127).ToInt32()-1; }
public static void DoCircle(Graphics gfx, Pen pen, FloatPoint O, int M, int R) { DoCircle(gfx,pen,0,O,M,R); }
public static FloatPoint CenteredX(FloatPoint xp, double max_radius, double velocity) { double velo = (velocity/1024) * max_radius; return xp - (velo*.5F); }
public static FloatPoint[] CirclePoints(float phase, FloatPoint box_dimension, FloatPoint size, int _count) { var points = new List<FloatPoint>(); for (float i=0;i<_count;i++) points.Add(CirclePoint(i,_count,phase)); return points.ToArray(); }
public static bool HitTest(FloatPoint Center, float CircleRadius, FloatPoint TestPoint) { FloatPoint newPoint = Center-TestPoint, maxPoint = HitTestMaxPoint(Center,CircleRadius), minPoint = HitTestMinPoint(Center,CircleRadius); return newPoint.Slope <= new FloatPoint(CircleRadius).Slope; //double Slope = newPoint.Slope; // return ( TestPoint.IsLEq(maxPoint) ) && ( TestPoint.IsGEq(minPoint) ); }
// WTF? public static FloatPoint[] ScalePoints(FloatPoint box, FloatPoint size, int _count, float scale_by) { var points = new List<FloatPoint>(); FloatPoint scale = FloatPoint.FlattenPoint(box,false); for (float i=-_count;i<_count;i++) { points.Add(scale * scale_by*0.5f); } return points.ToArray(); }
public UPointD(FloatPoint value) : this((decimal)value.X,(decimal)value.Y) { }
public static void ElipseToPath(System.Drawing.Drawing2D.GraphicsPath gp, FloatPoint xp, int rad_max, int velo) { ElipseToPath(gp,xp,(double)rad_max,(double)velo); }
/// <summary>Flattens the calling point</summary> public void Flatten(bool roundUp) { FloatPoint f = Flat(roundUp); this.X = f.X; this.Y = f.Y; f = null; }
public bool Contains(FloatPoint point) { return(point >= this.Location && point <= this.BottomRight); }
public FloatPoint GetRation(FloatPoint dst) { return(dst / this); }
public FloatPoint GetScaledRation(FloatPoint dst) { return(this * (dst / this)); }
/* /// todo: replace this with something more accurate and faster * /// use Boxed as the default scale flag * static public HPoint Fit(Point dest, Point source, scaleFlags sf) * { * HPoint skaler = new HPoint(); * float tr=0; * string omax,cmax; * if (source.X >= source.Y) omax = "width"; else omax="height"; * if (dest.X >= dest.Y) cmax = "width"; else cmax="height"; * switch (cmax) * { * case "width": if (omax==cmax) sf = scaleFlags.sWidth; else sf = scaleFlags.sHeight; break; * case "height": if (omax==cmax) sf = scaleFlags.sHeight; else sf = scaleFlags.sWidth; break; * } * skale: * switch (sf) * { * case scaleFlags.sHeight: * if ( source.Y > dest.Y ) { skaler.Y = dest.Y; tr = (float)((float)dest.Y / (float)source.Y); skaler.X = (int)Math.Round(source.X*tr); } * else skaler = source; break; * case scaleFlags.sWidth: * if ( source.X > dest.X ) { skaler.X = dest.X; tr = (float)((float)dest.X / (float)source.X); skaler.Y = (int)Math.Round(source.Y*tr); } * else skaler = source; break; * } * if ((skaler.X > dest.X) | (skaler.Y > dest.Y)) * { * switch (sf) * { * case scaleFlags.sWidth: sf = scaleFlags.sHeight; goto skale; * case scaleFlags.sHeight: sf = scaleFlags.sWidth; goto skale; * } * } * return skaler; * }*/ #endregion #endregion #region Help // public XPoint Translate(XPoint offset, XPoint zoom, bool ZoomAfterOffset, bool MultiplyOffset) // { // return (ZoomAfterOffset) ? (this+((MultiplyOffset) ? offset*zoom : offset ))*zoom : (this*zoom)+((MultiplyOffset) ? offset*zoom : offset ); // } /// <summary> /// Note that this is not a suggested optimal translation. /// The relation of most transforms should be provided via /// the context of the window or container. /// </summary> /// <param name="offset"></param> /// <param name="zoom"></param> /// <returns></returns> public FloatPoint Translate(FloatPoint translateOffset, FloatPoint translateZoom) { return((this + translateOffset) * translateZoom); }
static public FloatPoint FlattenPoint(FloatPoint _pin) { return(FlattenPoint(_pin, false)); }
/// scales src to dest static public FloatPoint Fit(FloatPoint dest, FloatPoint source) { return(Fit(dest, source, 0)); }
public static void DrawCircleOutlines(Graphics gfx, Pen pen, float phase, FloatPoint box_dimension, FloatPoint size, int _count, float scale_by) { FloatPoint Offset = box_dimension * 0.5f; FloatPoint scale = FloatPoint.FlattenPoint(box_dimension,false); FloatRect render_rect = new FloatRect(Offset,size); FloatPoint[] points = CirclePoints(phase,box_dimension,size,_count); FloatPoint scaler = scale * (scale_by*0.5f); for (int i=0;i<points.Length;i++) { FloatPoint Position = new FloatPoint( (float)(-Math.Sin(cvtf(_count,i+phase))) , (float)(Math.Cos(cvtf(_count,i+phase))) ); render_rect.Location = Offset+(Position*scaler)-(size*0.5f); gfx.DrawEllipse(pen,render_rect); } }
public FloatRect(FloatPoint L, FloatPoint S) : this(L.X, L.Y, S.X, S.Y) { }
void Render(Graphics g) { FloatPoint h = HalfPoint; string value = string.Format("{0:N0}x{1:N0}",ClientSize.Width,ClientSize.Height); FloatPoint posText = new FloatPoint(0,HalfPoint.Y); posText.Y -= HalfLineHeight; using (Pen line = new Pen(LineColor,1)) g.DrawLine(line,0,h.Y,ClientSize.Width,h.Y); using (Brush fg = new SolidBrush(BackColor)) g.DrawString(value,Font,fg,posText+-2); using (Brush fg = new SolidBrush(BackColor)) g.DrawString(value,Font,fg,posText+2); using (Brush fg = new SolidBrush(LineColor)) g.DrawString(value,Font,fg,posText); }
/// <summary> /// X < input.X ? X : input.X, Y < input.Y ? Y : input.Y /// </summary> /// <param name="input"></param> /// <returns></returns> public FloatPoint Nearest(FloatPoint input) { return(new FloatPoint(X < input.X ? X : input.X, Y < input.Y ? Y : input.Y)); }
static public FloatPoint FlattenUp(FloatPoint _pin) { return(FlattenPoint(_pin, true)); }
/// <summary> /// FloatPoint(X > input.X ? X : input.X, Y > input.Y ? Y : input.Y) /// </summary> /// <param name="input"></param> /// <returns></returns> public FloatPoint Furthest(FloatPoint input) { return(new FloatPoint(X > input.X ? X : input.X, Y > input.Y ? Y : input.Y)); }
public static void ElipseToPath(System.Drawing.Drawing2D.GraphicsPath gp, FloatPoint xp, double rad_max, double velo) { FloatPoint pnew = Centered(xp,rad_max,velo); FloatPoint hp = GetPressureRadius(rad_max,velo); gp.AddEllipse(xp.X-hp.X,xp.Y-hp.Y,hp.X,hp.Y); }
/// Returnes a Floored point (copy) static public FloatPoint Floor(FloatPoint source) { return(new FloatPoint(Math.Floor(source.X), Math.Floor(source.Y))); }
public static FloatPoint HitTestMinPoint(FloatPoint Center, float CircleRadius) { return Center - new FloatPoint(CircleRadius); }
/// nearest int: digits static public FloatPoint Round(FloatPoint source, int digits) { return(new FloatPoint(Math.Round(source.X, digits), Math.Round(source.Y, digits))); }
public static FloatPoint Centered(FloatPoint xp, double max_radius, double velocity) { float velo = (float)((velocity/1024D) * max_radius); return xp - (velo*.5D); }
/// nearest int static public FloatPoint Round(FloatPoint source) { return(Round(source, 0)); }
public FloatRect(float x, float y, float width, float height) { Location = new FloatPoint(x, y); Size = new FloatPoint(width, height); }
/// <summary> /// 水波紋效果 /// </summary> /// <param name="src"></param> /// <param name="nWave">坡度</param> /// <returns></returns> public Bitmap AdjustRippleEffect(Bitmap src, short nWave) { int nWidth = src.Width; int nHeight = src.Height; // 透過公式進行水波紋的採樣 FloatPoint[,] fp = new FloatPoint[nWidth, nHeight]; Point[,] pt = new Point[nWidth, nHeight]; Point mid = new Point(); mid.X = nWidth / 2; mid.Y = nHeight / 2; double newX, newY; double xo, yo; //先取樣將水波紋座標跟RGB取出 for (int x = 0; x < nWidth; ++x) for (int y = 0; y < nHeight; ++y) { xo = (nWave * Math.Sin(2.0 * 3.1415 * y / 128.0)); yo = (nWave * Math.Cos(2.0 * 3.1415 * x / 128.0)); newX = (x + xo); newY = (y + yo); if (newX > 0 && newX < nWidth) { fp[x, y].X = newX; pt[x, y].X = (int)newX; } else { fp[x, y].X = 0.0; pt[x, y].X = 0; } if (newY > 0 && newY < nHeight) { fp[x, y].Y = newY; pt[x, y].Y = (int)newY; } else { fp[x, y].Y = 0.0; pt[x, y].Y = 0; } } //進行合成 Bitmap bSrc = (Bitmap)src.Clone(); // 依照 Format24bppRgb 每三個表示一 Pixel 0: 藍 1: 綠 2: 紅 BitmapData bitmapData = src.LockBits(new Rectangle(0, 0, src.Width, src.Height), ImageLockMode.ReadWrite, PixelFormat.Format24bppRgb); BitmapData bmSrc = bSrc.LockBits(new Rectangle(0, 0, bSrc.Width, bSrc.Height), ImageLockMode.ReadWrite, PixelFormat.Format24bppRgb); int scanline = bitmapData.Stride; IntPtr scan0 = bitmapData.Scan0; IntPtr srcScan0 = bmSrc.Scan0; unsafe { byte* p = (byte*)(void*)scan0; byte* pSrc = (byte*)(void*)srcScan0; int nOffset = bitmapData.Stride - src.Width * 3; int xOffset, yOffset; for (int y = 0; y < nHeight; ++y) { for (int x = 0; x < nWidth; ++x) { xOffset = pt[x, y].X; yOffset = pt[x, y].Y; if (yOffset >= 0 && yOffset < nHeight && xOffset >= 0 && xOffset < nWidth) { p[0] = pSrc[(yOffset * scanline) + (xOffset * 3)]; p[1] = pSrc[(yOffset * scanline) + (xOffset * 3) + 1]; p[2] = pSrc[(yOffset * scanline) + (xOffset * 3) + 2]; } p += 3; } p += nOffset; } } src.UnlockBits(bitmapData); bSrc.UnlockBits(bmSrc); return src; }
public static void DoCircle(Graphics gfx, FloatPoint O, int M, int R) { DoCircle(gfx,SystemPens.ControlText,O,M,R); }
protected override void OnMouseMove(MouseEventArgs e) { if (!IsMouseDown) { base.OnMouseMove(e); Invalidate(Needs.Mouse); return; } MouseTrail = (new FloatPoint(PointToClient(MousePosition))-MousePoint); base.OnMouseMove(e); Invalidate(Needs.Select|Needs.Mouse); }
/// static FromControl Methods (relative to the control) static public FloatRect FromControl(Control ctl, Padding pad) { return(new FloatRect(FloatPoint.GetPaddingTopLeft(pad), FloatPoint.GetClientSize(ctl) - FloatPoint.GetPaddingOffset(pad))); }
/// static FromControl Methods (relative to the control) public static FloatRect FromClientInfo(FloatPoint ClientSize, Padding pad) { return new FloatRect(FloatPoint.GetPaddingTopLeft(pad),ClientSize-FloatPoint.GetPaddingOffset(pad)); }
/// <summary> /// /// </summary> /// <param name="x">Solving for y at x</param> /// <param name="a"></param> /// <param name="b"></param> /// <returns></returns> public static float Process(int x, FloatPoint a, FloatPoint b) { return Process(x,a.X,a.Y,b.X,b.Y); }
public FloatRect(float x, float y, float width, float height) { Location = new FloatPoint(x,y); Size = new FloatPoint(width,height); }
public UPointD(FloatPoint value) : this((decimal)value.X, (decimal)value.Y) { }
/// static FromControl Methods (relative to the control) static public FloatRect FromClientInfo(FloatPoint ClientSize, Padding pad) { return(new FloatRect(FloatPoint.GetPaddingTopLeft(pad), ClientSize - FloatPoint.GetPaddingOffset(pad))); }
public DoublePoint(FloatPoint value) : this(value.X,value.Y) { }
/// <summary>same as FlattenPoint overload without boolean</summary> static public FloatPoint FlattenDown(FloatPoint _pin) { return(FlattenPoint(_pin)); }
protected override void OnMouseDown(MouseEventArgs e) { isMouseDown = true; Focused = true; MousePoint = PointToClient(MousePosition); base.OnMouseDown(e); Invalidate(Needs.Select|Needs.Mouse); }
public DoublePoint(FloatPoint value) : this(value.X, value.Y) { }
protected override void OnMouseUp(MouseEventArgs e) { // MousePoint = MousePosition; isMouseDown = false; MouseTrail = new FloatPoint(0); base.OnMouseUp(e); Invalidate(Needs.Deselect|Needs.Mouse); }
public static void DrawCirclePoints( Graphics gfx, Brush brush, float phase, FloatPoint box_dimension, FloatPoint size, int _count, float scale_by ) { FloatPoint Offset = box_dimension * 0.5f; FloatPoint scale = FloatPoint.FlattenPoint(box_dimension,false); FloatRect render_rect = new FloatRect(Offset,size); for (float i=-_count;i<_count;i++) { FloatPoint Position = new FloatPoint( (float)(-Math.Sin(cvt(_count,i+phase))*((scale.X*scale_by)*0.5f)) , (float)(Math.Cos(cvt(_count,i+phase))*((scale.Y*scale_by)*0.5f)) ); render_rect.Location = Offset+Position-(size*0.5f); gfx.FillEllipse(brush,render_rect); } }
public bool Contains(FloatPoint point) { return point >= this.Location && point <= this.BottomRight; }
public static void DrawCircles( Graphics gfx, Brush brush, float phase, FloatPoint box_dimension, FloatPoint size, int _count, float scale_by) { FloatPoint Offset = box_dimension * 0.5f; FloatPoint scale = FloatPoint.FlattenPoint(box_dimension,false); FloatRect render_rect = new FloatRect(Offset,size); FloatPoint[] points = CirclePoints(phase,box_dimension,size,_count); FloatPoint scaler = scale * (scale_by*0.5f); for (int i=0;i<points.Length;i++) { FloatPoint Position = CirclePoint(i,_count,phase); render_rect.Location = Offset+(Position*scaler)-(size*0.5f); gfx.FillEllipse(brush,render_rect); } }
public FloatRect(FloatPoint L, FloatPoint S) : this(L.X,L.Y,S.X,S.Y) { }
public static void ElipseToPath(System.Drawing.Drawing2D.GraphicsPath gp, FloatPoint xp, double radius) { FloatPoint rp = new FloatPoint(radius), hp = rp * 0.5f, dp = rp * 2.0f; FloatPoint p = xp-rp; gp.AddEllipse(p.X,p.Y,dp.X,dp.Y); }