Rubik's Cube Solver mit 3D-Darstellung

  • C#

Es gibt 85 Antworten in diesem Thema. Der letzte Beitrag () ist von Switcherlapp97.

    @StarGate01
    Meine Rotate-Methode ist in der Point3D Klasse. Hier der Code:

    C#-Quellcode

    1. public Point3D Rotate(RotationType type, int angle)
    2. {
    3. double rad = angle * Math.PI / 180;
    4. double cosa = Math.Cos(rad);
    5. double sina = Math.Sin(rad);
    6. switch (type)
    7. {
    8. case RotationType.X:
    9. return new Point3D(this.X, this.Y * cosa - this.Z * sina, this.Y * sina + this.Z * cosa);
    10. case RotationType.Y:
    11. return new Point3D(this.Z * sina + this.X * cosa, this.Y, this.Z * cosa - this.X * sina);
    12. default:
    13. return new Point3D(this.X * cosa - this.Y * sina, this.X * sina + this.Y * cosa, this.Z);
    14. }
    15. }

    Wie muss ich diese Methode abändern, damit ich den Punkt um den Mittelpunkt des Rubiks Cubes den Punkt drehe?
    Sorry aber ich check das nicht ganz ab :(

    Gruß
    Switcherlapp97
    RubiksCubeSolver


    Jetzt im Showroom

    Ich schreib hier mal meine Gedanken hin:
    Ein Rubik-Würfel besteht ja aus 3*3*3 Subwürfeln, wobei der innere niemals sichtbar ist.
    Von den Subwürfeln sind auch nur 1 (Mitte), 2 (Kante) bzw. 3 (Ecke) Flächen zu sehen.
    Jede Fläche ist Quadratisch und daher definiert durch 4 Punkte mit x-, y- und z-Koordinate.
    Nehmen wir mal an ein einfacher Würfel (1*1*1) liegt im Mittelpunkt (0,0,0), so lauten seine Eckkoordinaten:
    (-0.5,0.5,-0.5), (0.5,0.5,-0.5), (0.5,-0.5,-0.5), (-0.5,-0.5,-0.5), (-0.5,0.5,0.5), (0.5,0.5,0.5), (0.5,-0.5,0.5), (-0.5,-0.5,0.5)
    (Wenn ich mich nicht vertippt hab)
    Nun also nur noch Projizieren und die Flächen Rendern.
    Für den kompletten Rubik-Würfel unterteilst du dir deinen Würfel nun in 9 kleine Würfel.
    De facto unterteilst Du also jede Fläche in 9 kleine.
    Nun errechnest du durch simple Addition und Subtraktion von 1/3 die Flächenkoordinaten dieser Subflächen.
    Danach hast du also 9*6 = 54 Flächen. Die Punkte dieser rotiert du dann nach Wunsch einfach um den Mittelpunkt (0,0,0).
    Diese werden dann wie gehabt projiziert und gerendert.
    Der Witz an der Sache ist also den Rubik als Einheitswürfel mit unterteilten Flächen zu betrachten und nicht als 3*3*3 = 27 Subwürfel.
    Irgendwie find ich das Thema ansprechend, vielleicht komm ich dazu mal was zu programmieren.

    Und jetzt mal ganz OT: Warum eigentlich GDI+ und nicht z.B. DirectX? Es ist zwar spannend das alles selber zu machen aber... ^^

    Du erscheinst mir als durchaus fähiger Programmierer, das packst Du sicherlich.
    SᴛᴀʀGᴀᴛᴇ01

    @StarGate01
    So wie du es beschrieben hast, bin ich bei meiner zweiten Variante vorgegangen (ungefähr so). Dort wird das 3D Modell allerdings nicht korrekt dargestellt. Ich wäre froh, wenn du dir das einmal anschauen könntest, denn ich finde den Fehler einfach nicht. Ich glaube, dass dem Code nicht mehr allzu viel fehlt (ich hoffe es zumindestens), aber ich finde einfach den Fehler nicht :(

    Gruß
    Switcherlapp97
    RubiksCubeSolver


    Jetzt im Showroom

    Kann es sein, dass du die Punkte für die einzelnen Felder im 2D-Raum verschiebst? Dann wäre der ungewollte Effekt ja logisch, du musst bei deinem aktuellen Ansatz die Punkte nämlich im 3D-Raum verschieben, um die einzelnen Würfel an verschiedenen Stellen zu erstellen.

    Alles der Reihe nach.
    Ich bin mal deinen bisherigen Code für _einen_ Würfel durchgegangen.
    Das Z-Buffering ist... nunja... interessant gelöst.
    Der Code kann erheblich vereinfacht werden wenn man eine zusätzliche Klasse einführt: Face3D.
    Ich hab mal was gebastelt, wo du den Code hoffentlich besser Verstehst.
    Für Subwürfel musst Du nur noch die Flächendefinitionen in genFaces() ergänzen.
    Dein Vorhaben liegt zum Greifen nah!

    Form1.cs
    Spoiler anzeigen

    C#-Quellcode

    1. using System;
    2. using System.Collections.Generic;
    3. using System.ComponentModel;
    4. using System.Data;
    5. using System.Drawing;
    6. using System.Drawing.Drawing2D;
    7. using System.Linq;
    8. using System.Text;
    9. using System.Windows.Forms;
    11. namespace CubeGDI3D
    12. {
    13. public partial class Form1 : Form
    14. {
    15. public Form1()
    16. {
    17. InitializeComponent();
    18. SetStyle(ControlStyles.AllPaintingInWmPaint, true);
    19. SetStyle(ControlStyles.DoubleBuffer, true);
    20. SetStyle(ControlStyles.SupportsTransparentBackColor, true);
    21. SetStyle(ControlStyles.UserPaint, true);
    22. }
    24. private Face3D[] faces;
    26. private Face3D[] genFaces()
    27. {
    28. return new Face3D[] {
    29. new Face3D(new Point3D[] { new Point3D(-1, 1, -1), new Point3D(1, 1, -1), new Point3D(1, -1, -1), new Point3D(-1, -1, -1) }, Color.Red),
    30. new Face3D(new Point3D[] { new Point3D(-1, 1, 1), new Point3D(1, 1, 1), new Point3D(1, -1, 1), new Point3D(-1, -1, 1) }, Color.Blue),
    31. new Face3D(new Point3D[] { new Point3D(-1, -1, -1), new Point3D(1, -1, -1), new Point3D(1, -1, 1), new Point3D(-1, -1, 1) }, Color.Green),
    32. new Face3D(new Point3D[] { new Point3D(-1, 1, -1), new Point3D(1, 1, -1), new Point3D(1, 1, 1), new Point3D(-1, 1, 1) }, Color.Yellow),
    33. new Face3D(new Point3D[] { new Point3D(1, 1, 1), new Point3D(1, 1, -1), new Point3D(1, -1, -1), new Point3D(1, -1, 1) }, Color.Purple),
    34. new Face3D(new Point3D[] { new Point3D(-1, 1, 1), new Point3D(-1, 1, -1), new Point3D(-1, -1, -1), new Point3D(-1, -1, 1) }, Color.Brown)
    35. };
    36. }
    38. private void Form1_Load(object sender, EventArgs e)
    39. {
    40. faces = genFaces();
    41. timer1.Start();
    42. }
    44. private void Form1_Paint(object sender, PaintEventArgs e)
    45. {
    46. e.Graphics.SmoothingMode = SmoothingMode.AntiAlias;
    47. Face3D[] facesProjected = new Face3D[faces.Length];
    48. for (int i = 0; i < faces.Length; i++) facesProjected[i] = faces[i].Project(this.ClientRectangle.Width, this.ClientRectangle.Height, 100, 4);
    49. facesProjected = facesProjected.OrderBy(p => p.Edges[0].Z).ToArray();
    50. for (int i = facesProjected.Length-1; i >= 0; i--)
    51. {
    52. PointF[] parr = Array.ConvertAll<Point3D, PointF>(facesProjected[i].Edges, new Converter<Point3D, PointF>(p => new PointF((float)p.X, (float)p.Y)));
    53. e.Graphics.FillPolygon(new SolidBrush(facesProjected[i].Color), parr);
    54. e.Graphics.DrawPolygon(Pens.Black, parr);
    55. }
    56. }
    58. private void timer1_Tick(object sender, EventArgs e)
    59. {
    60. for (int i = 0; i < faces.Length; i++)
    61. {
    62. faces[i] = faces[i].Rotate(Point3D.RotationType.X, 2);
    63. faces[i] = faces[i].Rotate(Point3D.RotationType.Y, 2);
    64. }
    65. Invalidate();
    66. }
    67. }
    68. }


    Point3D.cs (unverändert)
    Spoiler anzeigen

    C#-Quellcode

    1. using System;
    3. public class Point3D
    4. {
    5. public double X { get; set; }
    6. public double Y { get; set; }
    7. public double Z { get; set; }
    9. public Point3D(double x, double y, double z)
    10. {
    11. this.X = x;
    12. this.Y = y;
    13. this.Z = z;
    14. }
    16. public Point3D Rotate(RotationType type, int angle)
    17. {
    18. double rad = angle * Math.PI / 180;
    19. double cosa = Math.Cos(rad);
    20. double sina = Math.Sin(rad);
    21. switch (type)
    22. {
    23. case RotationType.X:
    24. return new Point3D(this.X, this.Y * cosa - this.Z * sina, this.Y * sina + this.Z * cosa);
    25. case RotationType.Y:
    26. return new Point3D(this.Z * sina + this.X * cosa, this.Y, this.Z * cosa - this.X * sina);
    27. default:
    28. return new Point3D(this.X * cosa - this.Y * sina, this.X * sina + this.Y * cosa, this.Z);
    29. }
    30. }
    32. public Point3D Project(int viewWidth, int viewHeight, int fov, int viewDistance)
    33. {
    34. double factor = fov / (viewDistance + this.Z);
    35. double Xn = this.X * factor + viewWidth / 2;
    36. double Yn = this.Y * factor + viewHeight / 2;
    37. return new Point3D(Xn, Yn, this.Z);
    38. }
    40. public enum RotationType { X, Y, Z }
    41. }


    Face3D.cs
    Spoiler anzeigen

    C#-Quellcode

    1. using System;
    2. using System.Collections.Generic;
    3. using System.Linq;
    4. using System.Drawing;
    5. using System.Drawing.Drawing2D;
    7. class Face3D
    8. {
    9. public Point3D[] Edges;
    10. public Color Color;
    12. public Face3D(Point3D[] edges, Color color)
    13. {
    14. this.Edges = edges;
    15. this.Color = color;
    16. }
    18. public Face3D Rotate(Point3D.RotationType type, int angle)
    19. {
    20. Point3D[] parr = new Point3D[Edges.Length];
    21. for(int i=0; i<Edges.Length; i++) parr[i] = Edges[i].Rotate(type, angle);
    22. return new Face3D(parr, Color);
    23. }
    25. public Face3D Project(int viewWidth, int viewHeight, int fov, int viewDistance)
    26. {
    27. Point3D[] parr = new Point3D[Edges.Length];
    28. for (int i = 0; i < Edges.Length; i++) parr[i] = Edges[i].Project(viewWidth, viewHeight, fov, viewDistance);
    29. double mid = parr.Sum(p => p.Z) / parr.Length;
    30. for (int i = 0; i < parr.Length; i++) parr[i].Z = mid;
    31. return new Face3D(parr, Color);
    32. }
    34. }



    Das sieht dann so aus:



    Ich bitte Dich, versteh meinen Code, dann wird dein Vorhaben für dich kein Problem sein.
    Eigentlich ist nur die Face3D-Klasse neu, und die repräsentiert einfach eine Fläche.
    Und nicht vor dem Lambda-Krams zurückschrecken, das spart einfach nur Platz und Schleifen ;)


    Ich hoffe das hilft Dir.


    //EDIT:
    Als Verdeckungsalgorithmus kommt hier Painter's Algorithm zum Einsatz. Er kann in bestimmten Fällen aber fehlschlagen. Eventuell solltest Du später einen richtigen Z-Buffer implementieren.

    //EDIT2:
    Ich habe im Gegensatz zu Deinem alten Code auf einen Indexbuffer verzichtet. Die entstehende Redundanz zu beheben ist auch noch eine Optimierungsmöglichkeit.
    SᴛᴀʀGᴀᴛᴇ01

    Dieser Beitrag wurde bereits 5 mal editiert, zuletzt von „StarGate01“ ()

    Sorry, dass ich hier schon wieder so an euren Codes rumverbessere aber mir steht grad danach. Hoffe, ihr seid nicht böse. Jedenfalls habe ich nochmal etwas in der Form1- und der Face3D-Klasse rumgewerkelt. Rausgekommen ist folgendes:
    Face3D

    C#-Quellcode

    1. class Face3D
    2. {
    3. public IEnumerable<Point3D> Edges { get; set; }
    4. public Color Color;
    6. public Face3D(IEnumerable<Point3D> edges, Color color)
    7. {
    8. this.Edges = edges;
    9. this.Color = color;
    10. }
    12. public Face3D Rotate(Point3D.RotationType type, int angle)
    13. {
    14. IEnumerable<Point3D> parr = Edges.Select(p => p.Rotate(type, angle));
    15. return new Face3D(parr, this.Color);
    16. }
    18. public Face3D Project(int viewWidth, int viewHeight, int fov, int viewDistance)
    19. {
    20. IEnumerable<Point3D> parr = Edges.Select(p => p.Project(viewWidth, viewHeight, fov, viewDistance));
    21. double mid = parr.Sum(p => p.Z) / parr.Count();
    22. parr = parr.Select(p => new Point3D(p.X, p.Y, mid));
    23. return new Face3D(parr, Color);
    24. }
    25. }

    Form

    C#-Quellcode

    1. public partial class Form1 : Form
    2. {
    3. Timer timer;
    4. private IEnumerable<Face3D> faces;
    6. private IEnumerable<Face3D> genFaces()
    7. {
    8. return new Face3D[] {
    9. new Face3D(new Point3D[] { new Point3D(-1, 1, -1), new Point3D(1, 1, -1), new Point3D(1, -1, -1), new Point3D(-1, -1, -1) }, Color.Red),
    10. new Face3D(new Point3D[] { new Point3D(-1, 1, 1), new Point3D(1, 1, 1), new Point3D(1, -1, 1), new Point3D(-1, -1, 1) }, Color.Blue),
    11. new Face3D(new Point3D[] { new Point3D(-1, -1, -1), new Point3D(1, -1, -1), new Point3D(1, -1, 1), new Point3D(-1, -1, 1) }, Color.Green),
    12. new Face3D(new Point3D[] { new Point3D(-1, 1, -1), new Point3D(1, 1, -1), new Point3D(1, 1, 1), new Point3D(-1, 1, 1) }, Color.Yellow),
    13. new Face3D(new Point3D[] { new Point3D(1, 1, 1), new Point3D(1, 1, -1), new Point3D(1, -1, -1), new Point3D(1, -1, 1) }, Color.Purple),
    14. new Face3D(new Point3D[] { new Point3D(-1, 1, 1), new Point3D(-1, 1, -1), new Point3D(-1, -1, -1), new Point3D(-1, -1, 1) }, Color.Brown)
    15. };
    16. }
    18. public Form1()
    19. {
    20. InitializeComponent();
    21. this.SetStyle(ControlStyles.AllPaintingInWmPaint, true);
    22. this.SetStyle(ControlStyles.OptimizedDoubleBuffer, true);
    23. timer = new Timer();
    24. timer.Interval = 25;
    25. timer.Tick += timer_Tick;
    26. timer.Start();
    27. faces = genFaces();
    28. }
    30. void timer_Tick(object sender, EventArgs e)
    31. {
    32. faces = faces.Select(f => f.Rotate(Point3D.RotationType.X, 2).Rotate(Point3D.RotationType.Y, 2));
    33. this.Invalidate();
    34. }
    36. private void Form1_Paint(object sender, PaintEventArgs e)
    37. {
    38. e.Graphics.SmoothingMode = SmoothingMode.AntiAlias;
    39. IEnumerable<Face3D> facesProjected = faces.Select(f => f.Project(this.ClientRectangle.Width, this.ClientRectangle.Height, 100, 4));
    40. facesProjected = facesProjected.OrderBy(p => p.Edges.ElementAt(0).Z).ToArray();
    41. foreach (Face3D face in facesProjected.Reverse()) {
    42. PointF[] parr = face.Edges.Select(p => new PointF((float)p.X, (float)p.Y)).ToArray();
    43. e.Graphics.FillPolygon(new SolidBrush(face.Color), parr);
    44. e.Graphics.DrawPolygon(Pens.Black, parr);
    45. }
    46. }
    47. }

    Falls es noch jemanden interessieren sollte, erwähne ich noch kurz, was ich gemacht habe:
    -Alle Arrays durch IEnumerables ersetzt, wenn möglich und sinnvoll
    -Alle For-Schleifen durch Linq-IEnumerable-Funktionen ersetzt

    MfG Stefan

    @nafets3646: Saubere Arbeit!
    Läuft sogar schneller.

    Und hey, kein Problem, da freu ich mich sogar wenn sich jemand meinem Code annimmt ^^

    Eine Sache habe ich nur auszusetzen:
    genFaces() sollte VOR dem Starten des Timers bzw. dem ersten Durchlauf aufgerufen werden. (Denke ich)
    SᴛᴀʀGᴀᴛᴇ01

    Mal ein anderer Ansatz:
    Wie wärs, wenn du das rumgefrickel mit diesen orthogonalen Projektionen einfach sein lässt, tatsächlich in nem 3D-Raum arbeitest und dann ordentlich nach 2D projizierst?
    Die nötige mathematik kann z.B. diese Lib hier für dich übernehmen: [OpenSource] MathUtils 2.4.2 - erweiterte Mathematikbibliothek

    @StarGate01
    Stimmt, haste Recht. Der Teil, den ich nicht bearbeitet hatte, ist auch nur schnell aus deinem und Switcherlapp seinem Formcode entstanden bzw. zusammenkopiert. Es macht aber insofern nichts aus, da, wenn kein Objekt in der Variable faces ist, alles einfach im Leerlauf läuft ;). Du kannst sogar das genFaces ganz weglassen, Fehler gibts trotztem keine. Es wird halt nur kein Objekt gezeichnet.

    //EDIT:
    @Artentus
    Warum?

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „nafets3646“ ()

    @Artentus: wär ich doch auch stark dafür. So sieht der Würfel aus als würde er sich dauernd minimal verziehen. (Was er ja auch tut).
    Ob man eine so mächtige Lib einsetzen will oder es selbst machen will bleibt dann dem TE überlassen denke ich.
    SᴛᴀʀGᴀᴛᴇ01

    Soo kompliziert ist es nun ja wirklich nicht, dass man gleich ne Library dafür verwenden müsste. Die benötigten Klassen sind ja jetzt vorhanden und der Code im Paint-Event ist auch ziemlich kurz. Außerdem muss man jetzt nicht für alles gleich ne Library nehmen. Sonst würde man bei richtig großen Projekten sicher 30 DLLs mitliefern, von denen man die meisten nur für 1 oder 2 Funktionen braucht :D.

    //EDIT:
    Dass der Würfel sich minimal verzieht ist ja auch nich wirklich schlimm, es fällt auch nur auf, wenn man darauf achtet ;).

    Dafür sind Libraries da, dass man diese verwendet. Und er will etwas 3D darstellen, das ist nicht nur was kleines.
    Vorallem wenn man überlegt, was man da mit einem kleinen DirectX Wrapper alles machen kann. Vielleicht will er das ganze später ja etwas, das nicht ganz so plastisch aussieht. Soetwas mit GDI+ zu machen ist schön und gut. Aber da ist die Frage, was will der TE. Will er verstehen was DirectX macht, will er nur das Ergebnis, oder ist die Motivation wirklich alles zu schreiben(Aber dann ist C# ja langweilig :P)
    Ich wollte auch mal ne total überflüssige Signatur:
    ---Leer---

    Beispiel Indexbuffer:
    Spoiler anzeigen

    C#-Quellcode

    1. private IEnumerable<Face3D> genFaces()
    2. {
    3. Point3D[] Corners = new Point3D[] {
    4. new Point3D(-1, 1, -1),
    5. new Point3D(1, 1, -1),
    6. new Point3D(1, -1, -1),
    7. new Point3D(-1, -1, -1),
    8. new Point3D(-1, 1, 1),
    9. new Point3D(1, 1, 1),
    10. new Point3D(1, -1, 1),
    11. new Point3D(-1, -1, 1)
    12. };
    13. return new Face3D[] {
    14. new Face3D(new Point3D[] { Corners[0], Corners[1], Corners[2], Corners[3] }, Color.Red),
    15. new Face3D(new Point3D[] { Corners[4], Corners[5], Corners[6], Corners[7] }, Color.Blue),
    16. new Face3D(new Point3D[] { Corners[3], Corners[2], Corners[6], Corners[7] }, Color.Green),
    17. new Face3D(new Point3D[] { Corners[0], Corners[1], Corners[5], Corners[4] }, Color.Yellow),
    18. new Face3D(new Point3D[] { Corners[5], Corners[1], Corners[2], Corners[6] }, Color.Purple),
    19. new Face3D(new Point3D[] { Corners[4], Corners[0], Corners[3], Corners[7] }, Color.Brown)
    20. };
    21. }

    SᴛᴀʀGᴀᴛᴇ01

    Hallo,

    Ich hatte jetzt erst die Zeit gefunden, um mit euren Tipps mein 3D-Rubiks-Cube-Model zu optimieren und ich habe echt hilfreiche Beiträge von euch erhalten. Echt ein großes Dankeschön an euch alle. Ich habe mit euren Tipps schon sehr viel dazu gelernt. :D

    jvbsl schrieb:

    Aber da ist die Frage, was will der TE. Will er verstehen was DirectX macht, will er nur das Ergebnis, oder ist die Motivation wirklich alles zu schreiben(Aber dann ist C# ja langweilig :P)

    Nachdem ich viele Lösungsverschläge mit GDI bekommen habe, fing mir das Thema an zu gefallen und finde es interessanter und vor allem lehrreicher mein Problem mit GDI zu verwirklichen. Wo ich mit diesem Thread begonnen habe, wollte ich hauptsächlich das Ergebnis, was sich jetzt geändert hat. Ich habe bereits sehr viel dazu gelernt im Bereich projezieren, 3D, etc. Danke für die super Hilfe von euch :!: :D

    StarGate01 schrieb:

    Und achja. Das Programm braucht im Status quo immer mehr CPU. Keine Ahnung warum. Jedenfalls wird es irgendwann zur Schnecke.

    Dieses Problem tritt bei mir auch auf und ich kann mir nicht erklären, wie es dazu kommt. Habt ihr eine Idee, wieso es mit der Zeit anfängt langsamer zu werden? Mein ursprünglicher 3D-Würfel (ohne die Flächenunterteilung), lief übrigens flüssig, obwohl das Projekt mit viel unnötigem Code vollgepackt war ...

    Danke
    Switcherlapp97
    RubiksCubeSolver


    Jetzt im Showroom

    Wegen der CPU:
    Das sieht mir stark nach nem Memory-Leak oder ner Endlosschleife aus. Allerdings kann ich im Task-Manager nichts Auffälliges (RAM) feststellen!?
    Vielleicht liegt es an den ganzen Enumerables und Linq-Ausdrücken, aber die sind eigentlich hochperformant.
    @nafets3646: Wenn sich jemand erbarmt und das mal debuggt :D ...Würd mich auch interessieren, ich hab aber im Moment leider keine Zeit.
    Ist bestimmt nur ne Kleinigkeit :)
    SᴛᴀʀGᴀᴛᴇ01

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „StarGate01“ ()

    Jo, irgendwas lässt die CPU-Auslastung ziemlich schnell sehr hoch steigen, allerdings nur bis zu einem bestimmten Punkt, dann sinkt sie wieder (bei mir bei 15%).
    Also, es scheint an folgendem Aufruf zu liegen:

    C#-Quellcode

    1. faces = faces.Select(f => f.Rotate(Point3D.RotationType.X, 2).Rotate(Point3D.RotationType.Y, 2));

    Ich schau mal, wie man das verbessern könnte :).

    //EDIT:
    Das Problem liegt eindeutig in der Rotate-Funktion.

    //EDIT 2:
    Das Problem scheint nur aufzutreten, wenn man mit der Rotate-Funktion eine Variable verändert und diese dann auf sich selber zuweist. Beispielcode:

    C#-Quellcode

    1. Face3D TestFace = new Face3D(new Point3D[] { new Point3D(-1, 1, -1), new Point3D(1, 1, -1), new Point3D(1, -1, -1), new Point3D(-1, -1, -1) }, Color.Red);
    2. for (int i = 0; i < 1000000; i++)
    3. {
    4. TestFace = TestFace.Rotate(Point3D.RotationType.X, 2); //Memory-Leak
    5. var Test = TestFace.Rotate(Point3D.RotationType.X, 2); //Kein Memory-Leak
    6. }


    //EDIT 3:
    Ich hab den bzw. die Übeltäter :):
    Die Funktionen Point3D.Rotate und Face3D.Rotate. Geben ja jeweils eine neue Instanz von sich zurück. Hier liegt das Problem, da die "alten" Instanzen im RAM verbleiben und ihn damit zumüllen. Deshalb muss man die Funktionen in Methoden umwandeln:
    Für Face3D

    C#-Quellcode

    1. public void Rotate(Point3D.RotationType type, int angle)
    2. {
    3. this.Edges.ToList().ForEach(p => p.Rotate(type, angle));
    4. }

    Für Point3D

    C#-Quellcode

    1. public void Rotate(RotationType type, int angle)
    2. {
    3. double rad = angle * Math.PI / 180;
    4. double cosa = Math.Cos(rad);
    5. double sina = Math.Sin(rad);
    6. switch (type)
    7. {
    8. case RotationType.X:
    9. this.X = this.X;
    10. this.Y = this.Y * cosa - this.Z * sina;
    11. this.Z = this.Y * sina + this.Z * cosa;
    12. break;
    13. case RotationType.Y:
    14. this.X = this.Z * sina + this.X * cosa;
    15. this.Y = this.Y;
    16. this.Z = this.Z * cosa - this.X * sina;
    17. break;
    18. default:
    19. this.X = this.X * cosa - this.Y * sina;
    20. this.Y = this.X * sina + this.Y * cosa;
    21. this.Z = this.Z;
    22. break;
    23. }
    24. }


    //EDIT 4:
    Es scheint so, als hätte ich irgendwo in den neuen Methoden noch einen Fehler eingebaut, könnte sich das vielleicht noch jemand anschauen? Hab langsam keinen Bock mehr.

    MfG Stefan

    Dieser Beitrag wurde bereits 3 mal editiert, zuletzt von „nafets3646“ ()

    @nafets3646
    Ich habe nun das Problem mit der ansteigenden CPU-Auslastung gelöst :thumbsup: Es hat allerdings recht lange gedauert, bis ich es geschafft habe :)

    Das Problem lag tatsächlich an den alten Instanzen, die den Arbeitsspeicher zumüllten. Als erstes änderte ich die Rotate-Methoden der Point3D und der Face3D Klasse, wie du es in deinem 3.Edit gepostet hast. Im Tick-Event des Timers rief ich dann die Rotate-Methode einer Fläche auf. So der Code:

    C#-Quellcode

    1. faces.ToList().ForEach(f => f.Rotate(Point3D.RotationType.X, 2));

    Als ich dann das Programm startete, wurde der Cube immer länglicher. Hier ein Screenshot:

    Ich denke, dass war auch das Problem von @nafets3646. Schnell wurde mir klar, dass der Fehler in der Rotate-Methode der Point3D-Klasse war. Bis ich dann allerdings den Fehler gefunden habe, ging es doch noch eine ganze Weile. Ich habe so oft den Rechenweg kontrolliert, doch das eigentlich simple Problem ist mir einfach nicht aufgefallen. :D

    C#-Quellcode

    1. case RotationType.X:
    2. Y = Y * cosa - Z * sina;
    3. Z = Y * sina + Z * cosa;

    Die neuen Koordinaten sollen ja aus den ursprünglichen Koordinaten berechnet werden. In dem Code von @nafets3646 wird das Y berechnet, welches allerdings anschließend gleich für die Z-Berechnung verwendet wird. So gehört es dann richtig:

    C#-Quellcode

    1. case RotationType.X:
    2. double yalt = Y;
    3. Y = Y * cosa - Z * sina;
    4. Z = yalt * sina + Z * cosa;

    So jetzt poste ich noch den ganzen Code meiner Anwendung:
    Point3D.cs

    C#-Quellcode

    1. using System;
    3. namespace _3DCube
    4. {
    5. class Point3D
    6. {
    7. public double X { get; set; }
    8. public double Y { get; set; }
    9. public double Z { get; set; }
    11. public Point3D(double x, double y, double z)
    12. {
    13. this.X = x;
    14. this.Y = y;
    15. this.Z = z;
    16. }
    18. public void Rotate(RotationType type, int angle)
    19. {
    20. double rad = angle * Math.PI / 180;
    21. double cosa = Math.Cos(rad);
    22. double sina = Math.Sin(rad);
    24. switch (type)
    25. {
    26. case RotationType.X:
    27. double yalt = Y;
    28. Y = Y * cosa - Z * sina;
    29. Z = yalt * sina + Z * cosa;
    30. break;
    31. case RotationType.Y:
    32. double xalt = X;
    33. X = Z * sina + X * cosa;
    34. Z = Z * cosa - xalt * sina;
    35. break;
    36. case RotationType.Z:
    37. xalt = X;
    38. X = X * cosa - Y * sina;
    39. Y = xalt * sina - Y * cosa;
    40. break;
    41. }
    42. }
    44. public Point3D Project(int viewWidth, int viewHeight, int fov, int viewDistance)
    45. {
    46. double factor = fov / (viewDistance + this.Z);
    47. double Xn = this.X * factor + viewWidth / 2;
    48. double Yn = this.Y * factor + viewHeight / 2;
    49. return new Point3D(Xn, Yn, this.Z);
    50. }
    52. public enum RotationType { X, Y, Z }
    53. }
    54. }


    Face3D.cs

    C#-Quellcode

    1. using System;
    2. using System.Collections.Generic;
    3. using System.Linq;
    4. using System.Drawing;
    5. using System.Drawing.Drawing2D;
    7. namespace _3DCube
    8. {
    9. class Face3D
    10. {
    11. public IEnumerable<Point3D> Edges { get; set; }
    12. public Color Color;
    14. public Face3D(IEnumerable<Point3D> edges, Color color)
    15. {
    16. this.Edges = edges;
    17. this.Color = color;
    18. }
    20. public void Rotate(Point3D.RotationType type, int angle)
    21. {
    22. this.Edges.ToList().ForEach(p => p.Rotate(type, angle));
    23. }
    25. public Face3D Project(int viewWidth, int viewHeight, int fov, int viewDistance)
    26. {
    27. IEnumerable<Point3D> parr = Edges.Select(p => p.Project(viewWidth, viewHeight, fov, viewDistance));
    28. double mid = parr.Sum(p => p.Z) / parr.Count();
    29. parr = parr.Select(p => new Point3D(p.X, p.Y, mid));
    30. return new Face3D(parr, Color);
    31. }
    32. }
    33. }


    FormMain.cs

    C#-Quellcode

    1. using System;
    2. using System.Collections.Generic;
    3. using System.ComponentModel;
    4. using System.Data;
    5. using System.Drawing;
    6. using System.Drawing.Drawing2D;
    7. using System.Linq;
    8. using System.Text;
    9. using System.Windows.Forms;
    11. namespace _3DCube
    12. {
    13. public partial class FormMain : Form
    14. {
    15. private IEnumerable<Face3D> faces;
    16. private Timer timer;
    18. public FormMain()
    19. {
    20. InitializeComponent();
    21. SetStyle(ControlStyles.AllPaintingInWmPaint, true);
    22. SetStyle(ControlStyles.DoubleBuffer, true);
    23. SetStyle(ControlStyles.SupportsTransparentBackColor, true);
    24. SetStyle(ControlStyles.UserPaint, true);
    25. InitCube();
    26. }
    28. void InitCube()
    29. {
    30. timer = new Timer();
    31. timer.Interval = 25;
    32. timer.Tick += timer_Tick;
    33. timer.Start();
    34. faces = genFaces();
    35. }
    37. void timer_Tick(object sender, EventArgs e)
    38. {
    39. faces.ToList().ForEach(f => { f.Rotate(Point3D.RotationType.X, 2); f.Rotate(Point3D.RotationType.Y,2);});
    40. this.Invalidate();
    41. }
    43. private IEnumerable<Face3D> genFaces()
    44. {
    45. Point3D[] Corners = new Point3D[] {
    46. new Point3D(-1, 1, -1),
    47. new Point3D(1, 1, -1),
    48. new Point3D(1, -1, -1),
    49. new Point3D(-1, -1, -1),
    50. new Point3D(-1, 1, 1),
    51. new Point3D(1, 1, 1),
    52. new Point3D(1, -1, 1),
    53. new Point3D(-1, -1, 1)
    54. };
    55. return new Face3D[] {
    56. new Face3D(new Point3D[] { Corners[0], Corners[1], Corners[2], Corners[3] }, Color.Red),
    57. new Face3D(new Point3D[] { Corners[4], Corners[5], Corners[6], Corners[7] }, Color.Blue),
    58. new Face3D(new Point3D[] { Corners[3], Corners[2], Corners[6], Corners[7] }, Color.Green),
    59. new Face3D(new Point3D[] { Corners[0], Corners[1], Corners[5], Corners[4] }, Color.Yellow),
    60. new Face3D(new Point3D[] { Corners[5], Corners[1], Corners[2], Corners[6] }, Color.Purple),
    61. new Face3D(new Point3D[] { Corners[4], Corners[0], Corners[3], Corners[7] }, Color.Brown)
    62. };
    63. }
    65. private void FormMain_Paint(object sender, PaintEventArgs e)
    66. {
    67. e.Graphics.Clear(Color.LightBlue);
    68. e.Graphics.SmoothingMode = SmoothingMode.AntiAlias;
    69. IEnumerable<Face3D> facesProjected = faces.Select(f => f.Project(this.ClientRectangle.Width, this.ClientRectangle.Height, 100, 4));
    70. facesProjected = facesProjected.OrderBy(p => p.Edges.ElementAt(0).Z).ToArray();
    71. foreach (Face3D face in facesProjected.Reverse())
    72. {
    73. PointF[] parr = face.Edges.Select(p => new PointF((float)p.X, (float)p.Y)).ToArray();
    74. e.Graphics.FillPolygon(new SolidBrush(face.Color), parr);
    75. e.Graphics.DrawPolygon(Pens.Black, parr);
    76. }
    77. }
    78. }
    79. }


    Jetzt mache ich mach dann an den nächsten Schritt: Die Unterteilung in 9 Felder pro Fläche. Ich weiß, ich wollte das schon früher machen, doch mir war es wichtiger, dass der Würfel sich zuerst flüssig dreht, bevor ich mit einem fehlerhaften Modell weiterarbeite. Ich melde mich wenn ich das dann geschafft habe :)

    Vielen Dank für die Hilfe
    Switcherlapp97
    RubiksCubeSolver


    Jetzt im Showroom

Facebook
Telefonspende