Laden...

[gelöst] Netzwerk zeichnen: Position der Knoten berechnen (ohne das es zu Überlappungen kommt)

Erstellt von Yeats vor 12 Jahren Letzter Beitrag vor 12 Jahren 2.372 Views
Y
Yeats Themenstarter:in
102 Beiträge seit 2005
vor 12 Jahren
[gelöst] Netzwerk zeichnen: Position der Knoten berechnen (ohne das es zu Überlappungen kommt)

Hallo

Sitze seit einiger Zeit an einem Problem und komme nicht richtig weiter.

Im Anhang befindet sich ein Bild von Netzwerk, dass ich zeichnen muss. Die drei Werte im PT(x,x,x) geben an, an welcher Position im Netzwerk sich der Knoten PT befindet. K ist ein Wert der weiters nichts zur Sache tut.

Ich bin nun her gegangen und habe eine Klasse erstellt die mir die Nodes representiert. Weiters eine Klasse für das Netzwerk. Eine dritte Klasse für die Rechtecke, um diese zeichnen zu können.

Die Rechtecke werden von mir in einer Liste gehalten, so dass beim Zeichnen nur mehr die Liste durchlaufen werden muss um die Objekte zu zeichnen.

Hinweis: Das Netzwerk selbst verjüngt sich nach oben hin wieder zu einem Knoten. Ein Knoten hat nicht unbedingt drei Nachfolger.

Nun schlage ich mich mit der Positionierung der Nodes herum und komme nicht weiter. Meine Frage ist nun, wie könnte ich herangehen um die X-Koordinaten der Rechtecke so zu ermitteln, damit es zu keinen Überlappungen kommt?


//Node Klasse
    class Node
    {
        private int left, middle, right;
        public int intLeft { get { return left; } }
        public int intMiddle { get { return middle; } }
        public int intRight { get { return right; } }
        private uint k;
        public uint K { get { return k; } }

        internal Node Left { get; set; }
        internal Node Right { get; set; }
        internal Node Middle { get; set; }

        public Node(uint k_db, int left, int middle, int right)
        {
            ...
        }
    }


//Netzwer Klasse: Beinhaltet sämtliche Knoten, baut das Netzwerk auf und soll es wieder ausgeben
class Network
    {
        public Node root;

        public Network()
        { root = null; }
        
        ///Hängt einen neuen Knoten in das Netzwerk
        public Node createNetwork(Node value, Node newNode, int left, int middle, int right)
        {
            ....
        }

        public enum direction { left, middle, right, center };

        ///Durchläuft das Netzwerk, überprüft ob ein Knoten schon in der list ist und fügt ihn gegebenenfalls hinzu.
       ///xsize und ysize sind die Höhe und Breite der Bitmap in die gezeichnet wird.
       ///xoffset und yoffset sind Werte, um wie viel das Rechteck vom Mittelpunkt der Bitmap verschoben sind
        ///direction: Von welchem Knoten wurde die Methode aufgerufen
        public void getNodes(Node value, List<GraphicObject> list, int xsize, int ysize, int xoffset, int yoffset, float factor, int count, direction Direction)
        {
            GraphicObject temp = null;
            if (value != null)
            {
                temp = new GraphicObject(value, xsize, ysize, xoffset, yoffset);

                if (list.Count != 0)
                {
                    bool isIn = false;
                    foreach (GraphicObject n in list)
                    {
                        if (n == temp) { isIn = true; break; }
                    }
                    if (!isIn) { list.Add(temp); }
                }
                else list.Add(temp);

                if (value.Left != null)
                {
                    getNodes(value.Left, list, xsize, ysize, (int)(xoffset + 250), (int)(yoffset + 70), factor + 0.1f, direction.left);
                }

                if (value.Middle != null)
                {
                    getNodes(value.Middle, list, xsize, ysize, (int)(xoffset), (int)(yoffset + 70), factor + 0.1f, direction.middle);
                }

                if (value.Right != null)
                {
                    getNodes(value.Right, list, xsize, ysize, (int)(xoffset - 250), (int)(yoffset + 70), factor + 0.1f, direction.right);
                }
            }
        }


//GraphicObject: Wird für das Zeichnen des Netzwerks verwendet. 
class GraphicObject
    {
        private const int width = 80, height = 30; 
        private string text;

        public Rectangle Rect { get; set; }
        public string Text { get { return text; } }
        
        public GraphicObject(Node value, int xsize, int ysize, int xoffset, int yoffset)
        {            
            if (value.intLeft == 0 && value.intMiddle == 0 && value.intRight == 0)
            {
                text = string.Format("PT = GT({0},{1},{2})\nk={3}", value.intLeft, value.intMiddle, value.intRight, value.K);
            }
            else
                text = string.Format("GT({0},{1},{2})\nk={3}", value.intLeft, value.intMiddle, value.intRight, value.K);
        
            Rect = new Rectangle((xsize / 2) - (width / 2) - xoffset, ysize - height - yoffset, width, height);
        }

        public static bool operator ==(GraphicObject G1, GraphicObject G2)
        { ... }

        public static bool operator !=(GraphicObject G1, GraphicObject G2)
        { ... }
    }

Falls ich mich unklar ausgedrückt haben sollte, bitte einfach nachfragen.

mfg Yeats

G
538 Beiträge seit 2008
vor 12 Jahren

Berechne den Abstand der Rechtecke die auf einer Ebene liegen und wenn der Abstand in X richtung kleiner ist als das Rechteck und der Abstand in Y Richtung ebenfalls kleiner, dann liegt wohl eine überlappung vor.

Umgekehrt für das Zeichnen kannst du (sofern du Anzahl pro "Zeile" und Reihenfolge kennst) den Abstand der Rechtecke berechnen der ist nämlich grade (Rechtecklänge + Abstand) * Rechtecknummer in der Reihe

Den Abstand kannst du auch aus Anzahl und maximaler Breite errechnen.

Der Vorteil der Klugheit liegt darin, dass man sich dumm stellen kann - umgekehrt ist das schon schwieriger (K. Tucholsky)
Das Problem mit Internet-Zitaten ist, dass sie oftmals zu unrecht als authentisch angenommen werden. (K. Adenauer)

49.485 Beiträge seit 2005
vor 12 Jahren

Hallo Yeats,

siehe Graphendarstellung: Positionen der Knoten eines Graphen ausrechnen

Und auch wenn du keinen Binärbaum hast, könnten die folgenden beiden Threads hilfreich sein:
Baum grafisch darstellen - wie Knotenposition berechnen?
Binärbaum zeichnen (binary search tree)...

herbivore

Y
Yeats Themenstarter:in
102 Beiträge seit 2005
vor 12 Jahren

Hallo.

Wollte noch eine kurze Meldung abgeben. Nachdem ich nun wieder Zeit gefunden habe mich diesem Projekt zu widmen (und sich die Anforderungen zum Teil geändert haben) konnte ich einen anderen Ansatz wählen.
Die Knoten werden nun in einem 2D Array gespeichert. Somit kann ich wie von Gumbler85 vorgeschlagen mir die Position eines Knotens über die Anzahl der Elemente pro Ebene berechnen.

Vielen Dank noch einmal an Gumbler85 und herbivore
mfg Yeats