Control Desgine - Sigmoid Kurve

  • C#
  • .NET (FX) 4.5–4.8

Es gibt 5 Antworten in diesem Thema. Der letzte Beitrag () ist von ErfinderDesRades.

    Control Desgine - Sigmoid Kurve

    Hallo Zusammen :D



    Ich bin grade an dem Problem, das ich eine Sigmoid-Funktion habe, die von Oben bzw. Unten nach Unten bzw. Oben läuft.
    Verlauf von Unten nach Oben
    		Verlauf von Oben nach Unten



    Dies Funktion habe ich so angepasst, das ich
    die Y-Achse und die X-Achse einstellen kann so
    das das Funktion an dem Punkt P(5,5) zb. ausläuft.



    Das ganze mach ich mit einer Funktion die 4 Parameter brauch,

    C#-Quellcode

    1. /// <summary>
    2. /// draw sigmoid
    3. /// </summary>
    4. /// <param name="x">X-Achsen Position</param>
    5. /// <param name="width">Defintions-Bereich</param>
    6. /// <param name="height">Werte-Bereich</param>
    7. /// <param name="direction">Abfallen oder Steigend</param>
    8. /// <returns></returns>
    9. [MethodImpl(MethodImplOptions.AggressiveInlining)]
    10. private float Sigmoid(float x, float width, float height, DrawDirection direction)
    11. => (float)(height / (1 + Math.Pow(Math.E, (int) direction * ((6 / (width - (height / 10)) * x))))) - (height * .5f);



    *Unten ist die Methode mit der ich Zeichne
    Nun würde ich gern die Funtion wie den Tangens laufen lassen, Also von Rechts btw. Links nach Links bzw. Rechts
    *Die Bilder sind manuell gedreht
    Links nach Rechts
    		Rechts nach Links




    Mein gedanken gang war nun: "Drehen wir einfach X und Y um", gemacht getan sah es nun so auf

    C#-Quellcode

    1. private void UpdatePath() {
    2. //[...]
    3. if (gamma > 1) {
    4. sigmodY = (x, w, h, d) => Sigmoid(x, w, h, d); //orginal
    5. vectorP = (x, y) => new PointF(y + wh, x + hh);
    6. }
    7. //[..]
    8. }



    Hier kann man erkennen, das die Funktion schon richtig verläuft aber nicht richtig auf die breite angepasst ist so tauschte ich die Breite mit der höhe,

    C#-Quellcode

    1. private void UpdatePath() {
    2. //[...]
    3. if (gamma > 1) {
    4. sigmodY = (x, w, h, d) => Sigmoid(x, h, w, d); //Tausch
    5. vectorP = (x, y) => new PointF(y + wh, x + hh);
    6. }
    7. //[..]
    8. }



    was da raus kam, war nicht so wie ich es wollte, nun hab ich ein wenig rum gespielt mit den werten

    C#-Quellcode

    1. private void UpdatePath() {
    2. //[...]
    3. if (gamma > 1) {
    4. sigmodY = (x, w, h, d) => Sigmoid(x, w, w, d); //Tausch
    5. vectorP = (x, y) => new PointF(y + wh, x + hh);
    6. }
    7. //[..]
    8. }


    C#-Quellcode

    1. private void UpdatePath() {
    2. //[...]
    3. if (gamma > 1) {
    4. sigmodY = (x, w, h, d) => Sigmoid(x, h, h, d); //Tausch
    5. vectorP = (x, y) => new PointF(y + wh, x + hh);
    6. }
    7. //[..]
    8. }



    Jetzt zu meiner Frage :D
    Hat jm eine idee wie ich die Parameter anpassen müsste so das die Kurve in den Ecken endet des Controls,
    bzw. hat jm. eine idee wie ich die funktion mittels Tangens hinbekomme oder wie ich die Punkte der Kurve so drehe das
    mein gewünschtes ziel rauskommt ?

    *Methode

    C#-Quellcode

    1. private void UpdatePath() {
    2. int segments = 32; //Eine linie besteht aus vielen Punkten die verbunden werden (32 Punkte hier)
    3. float wh = Width * .5f; //Halbe höhe um die Funktion zu verschieben *Bild drunter [a1]
    4. float hh = Height * .5f;
    5. float steps = wh / segments; //Einteilung der Abstände der Punkte
    6. PointF[] vertex = new PointF[segments + segments]; //Das array für die Punkte (Doppelt so viele, denn Links und rechts von der Y-Achse
    7. //L = Links, R = Rechts, B = Bottom, T = Top
    8. float gamma = (float)Math.Atan2(Height, Width); // zu erkenne ob ich [TB|BT] oder [LR|RL] Zeichnen muss
    9. //ISt der Winkel von (0,0) zu (Breite, Höhe) größer als 45° so soll die Funktion von RL oder LR laufen
    10. //default [TB|BT]
    11. Func<float, float, float, DrawDirection, float> sigmodY = (x, w, h, d) => Sigmoid(x, w, h, d);
    12. Func<float, float, PointF> vectorP = (x, y) => new PointF(x + wh, y + hh);
    13. //ende default
    14. if (gamma > 1) { //[RL|LR]
    15. sigmodY = (x, w, h, d) => Sigmoid(x, h, w, d);
    16. vectorP = (x, y) => new PointF(y + wh, x + hh);
    17. }
    18. for (int i = -segments; i < segments; i++) {
    19. float x = i * steps;
    20. float y = sigmodY(x, Width, Height, Direction);
    21. vertex[i + segments] = vectorP(x, y);
    22. //Console.WriteLine($"x: {x} y: {y}");
    23. }
    24. GraphicsPath path = new GraphicsPath();
    25. path.AddLines(vertex);
    26. WirePath = path;
    27. }

    		[a1]



    *Voller code
    Spoiler anzeigen

    C#-Quellcode

    1. using System;
    2. using System.ComponentModel;
    3. using System.Drawing;
    4. using System.Drawing.Drawing2D;
    5. using System.Runtime.CompilerServices;
    6. using System.Windows.Forms;
    8. namespace Block {
    9. public class Wire : Control {
    11. private const float PI = 3.14159f;
    12. private GraphicsPath WirePath;
    14. private Color _WireColor = Color.Gray;
    15. [Category("Wire")]
    16. public Color WireColor {
    17. get => _WireColor;
    18. set {
    19. if (_WireColor == value)
    20. return;
    21. _WireColor = value;
    22. Invalidate();
    23. }
    24. }
    26. private int _StrokeWidth = 5;
    27. [Category("Wire")]
    28. public int StrokeWidth {
    29. get => _StrokeWidth;
    30. set {
    31. if (_StrokeWidth == value)
    32. return;
    33. _StrokeWidth = value;
    34. Invalidate();
    35. }
    36. }
    38. private DrawDirection _DrawDirection = DrawDirection.BottomToTop;
    39. public DrawDirection Direction {
    40. get => _DrawDirection;
    41. set {
    42. if (_DrawDirection == value)
    43. return;
    44. _DrawDirection = value;
    45. Invalidate();
    46. }
    47. }
    49. public Wire() {
    50. InitializeStyle();
    51. InitializeValues();
    52. InitializeEvents();
    53. }
    55. private void InitializeStyle() {
    56. ControlStyles styles = ControlStyles.OptimizedDoubleBuffer
    57. | ControlStyles.SupportsTransparentBackColor
    58. | ControlStyles.UserPaint
    59. | ControlStyles.ResizeRedraw;
    60. SetStyle(styles, true);
    61. }
    63. private void InitializeValues() {
    64. BackColor = Color.Transparent;
    65. }
    67. private void InitializeEvents() {
    68. Invalidated += Wire_Invalidated;
    69. Paint += Wire_Paint;
    70. void Wire_Paint(object sender, PaintEventArgs e) {
    71. ///Setting
    72. ///
    73. Graphics graphics = e.Graphics;
    74. graphics = e.Graphics;
    75. graphics.SmoothingMode = SmoothingMode.AntiAlias;
    76. graphics.CompositingQuality = CompositingQuality.HighQuality;
    77. graphics.PixelOffsetMode = PixelOffsetMode.HighQuality;
    78. graphics.InterpolationMode = InterpolationMode.HighQualityBilinear;
    80. if (WirePath != null)
    81. graphics.DrawPath(new Pen(_WireColor, _StrokeWidth), WirePath);
    82. }
    83. }
    85. private void Wire_Invalidated(object sender, InvalidateEventArgs e) => UpdatePath();
    87. private void UpdatePath() {
    88. int segments = 32;
    89. float wh = Width * .5f;
    90. float hh = Height * .5f;
    91. float steps = wh / segments;
    93. PointF[] vertex = new PointF[segments + segments];
    94. float gamma = (float)Math.Atan2(Height, Width);
    95. //default
    96. Func<float, float, float, DrawDirection, float> sigmodY = (x, w, h, d) => Sigmoid(x, w, h, d);
    97. Func<float, float, PointF> vectorP = (x, y) => new PointF(x + wh, y + hh);
    98. if (gamma > 1) {
    99. sigmodY = (x, w, h, d) => Sigmoid(x, w, w, d);
    100. vectorP = (x, y) => new PointF(y + wh, x + hh);
    101. }
    102. //end default
    103. for (int i = -segments; i < segments; i++) {
    104. float x = i * steps;
    105. float y = sigmodY(x, Width, Height, Direction);
    106. vertex[i + segments] = vectorP(x, y);
    107. //Console.WriteLine($"x: {x} y: {y}");
    108. }
    110. GraphicsPath path = new GraphicsPath();
    111. path.AddLines(vertex);
    112. WirePath = path;
    113. }
    114. /// <summary>
    115. /// draw sigmoid
    116. /// </summary>
    117. /// <param name="x">X-Achsen Position</param>
    118. /// <param name="width">Defintions-Bereich</param>
    119. /// <param name="height">Werte-Bereich</param>
    120. /// <param name="direction">Abfallen oder Steigend</param>
    121. /// <returns></returns>
    122. [MethodImpl(MethodImplOptions.AggressiveInlining)]
    123. private float Sigmoid(float x, float width, float height, DrawDirection direction)
    124. => (float)(height / (1 + Math.Pow(Math.E, (int) direction * ((6 / (width - (height / 10)) * x))))) - (height * .5f);
    126. public enum DrawDirection : int {
    127. TopToBottom = -1,
    128. BottomToTop = 1,
    129. LeftToRight = -1,
    130. RightToLeft = 1
    131. }
    132. }
    133. }

    Dieser Beitrag wurde bereits 8 mal editiert, zuletzt von „Facebamm“ ()

    @Facebamm Kann es sein, dass die Werte Deines enum DrawDirection falsch (weil Paarweise gleich) sind?
    Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
    Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
    Ein guter .NET-Snippetkonverter (der ist verfügbar).
    Programmierfragen über PN / Konversation werden ignoriert!

    hier probier ma dieses Control:

    VB.NET-Quellcode

    1. Imports System.Windows.Forms
    2. Imports System.Drawing
    3. Imports System.Drawing.Drawing2D
    5. Public Class Bezier1 : Inherits Control
    7. Private Shared _GP As New GraphicsPath
    8. Private Shared _rctNorm As New Rectangle(0, 0, 10, 10)
    10. Shared Sub New()
    11. With _rctNorm
    12. #If True Then
    13. _GP.AddBezier(.Location, New Point(.Right \ 2, .Top), New Point(.Right \ 2, .Bottom), New Point(.Right, .Bottom))
    14. #ElseIf True Then
    15. _GP.AddBezier(.Location, New Point(.Right, .Top), New Point(.Left, .Bottom), New Point(.Right, .Bottom))
    16. #ElseIf True Then
    17. #End If
    18. End With
    19. End Sub
    21. Protected Overrides Sub OnPaint(e As PaintEventArgs)
    22. MyBase.OnPaint(e)
    23. With Me.ClientRectangle
    24. Using gp = _GP.CloneX, mtr As New Matrix(_rctNorm, {.Location, New Point(.Right, 0), New Point(0, .Bottom)})
    25. gp.Transform(mtr)
    26. e.Graphics.DrawPath(Pens.Peru, gp)
    27. End Using
    28. End With
    29. End Sub
    31. End Class