konzeptionelle Gedanken optische Darstellung Stammbaum

[hansklok]

So, um eines Vorweg zu nehmen, danke für Eure bisherigen Antworten.
Ich arbeite mich grade erst in die Materie ein. ANFÄNGER!!!! Ich bin wieder in die Delhpipraxis-Community zurückgekehrt, da ich früher hier sehr gute Erfahrungen gemacht habe. Ich entwickle unter OS X mit Xojo. An sich gibt es da sehr!!! viele Parallelen zu Delphi. Deswegen versuche ich es hier im Forum.

Von vorne: Die Beispieldatenbank hat folgende Tabellen:

1. Personen
   • Name
   • Geburtsdatum
2. Familien
   • MutterID
   • VaterID
3. Kinder
   • FamilienID

So, folgendes Szenario:

• Max Mustermann solle der Proband sein
• Seine Eltern sind Hans Mustermann und Elke Musterfrau
• Max ist das Zweitgeborene von 4 Kindern der Familie
• Max war zweimal verheiratet. Mit Maria Streifenmuster und Petra Kairomuster
• aus der ersten Ehe gingen 1 Kind (Ludwig) und aus der zweiten keines hervor.

An sich eine einfache Familienkonstellation. Via SQL-Abfrage wird nun erstmal der Proband innerhalb der Geschwister eingeordnet (Geburtsdatum), diese ordnen sich dann auf der gleichen Ebene links und rechts um ihn. Da er aber auch zwei Frauen hatte, werden diese rechts von ihm vor seinen 3. und 4. Geschwisterteil platziert. Unter die Frauen dann jeweils die Kinder. Ich finde, das ist bei einem solchen Beispiel schon ein sehr komplexes Ding.
Was mich also beschäftigt ist zum einen, wie baue ich um meinen Probanden, der stets zentriert im Fokus der grafischen Ausgabe sein soll, alles andere um ihn herum? Deswegen auch die Frage mit den Scrollbars!

Vielleicht besteht die Möglichkeit, dass wir hier Step by Step, Tutorialartig so etwas gemeinsam definieren können, das fände ich klasse ;)

So würde die grafische Ausgabe zum Beispiel mal ausschauen:

[TiGü]

Was hast du denn bisher?
Zeig mal Quelltext!
Der Ansatz von Namenloser mit den Layern ist eigentlich ganz knuffig.

[hansklok]

Meine Gedanken (der Einfachheit halber mal eingedeutscht):

Delphi-Quellcode:

// es gibt mehrere Möglichkeiten der Darstellung, die mir vorschweben
//
// 1. der Proband ist eine Partnerschaft
// 2. der Proband ist eine einzelne Person

// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// zu 1. (Nachteil hier, es werden keine weiteren Partner & Geschwister angezeigt)
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

TPerson = class
  const
    Width: 200;
    Height: 75;
  public
    Name: String;
    Vater: TPerson;
    Mutter: TPerson;
    procedure Draw(Canvas, TCanvas; x, y: Integer);
end;

TPartnerschaft = class // im Falle 1. wäre Partnerschaft dann der "Proband"
  public
    PartnerA: TPerson; // Mann oder Frau bei gleichgeschlechtlichen Partnerschaften
    PartnerB: TPerson; // Frau "
    Kinder: TList<TPerson>; // Reihenfolge der Kinder kann schon bei der SQL-Abfrage erfolgen
    procedure Draw(Canvas: TCanvas);
end;

procedure TPerson.Draw(Canvas: TCanvas; x, y: Integer);
begin
  Canvas.DrawRectangle(x, y, Width, Height);
  // später kann hier noch der Name der Person ausgegeben werden

  if Vater <> nil and Mother <> nil then begin
    // Eltern zeichnen dementsprechend versetzt über dem Probanden (x, y müssen angepasst werden)
  end else 
  if Vater <> nil and Mother = nil then begin
    // nur Vater zeichnen
  end else
  if Vater = nil and Mother <> Nil then begin
    // nur Mutter zeichnen
  end;
end;

procedure TPartnerschaft.Draw(Canvas: TCanvas);
begin
  // hier wird es nun kompliziert, da zunächst alle Kinder gezählt werden müssen, um den Probanden oberhalb zu zentrieren, ABER
  // sollte die Breite der Elterngenerationen (Eltern, Großeltern) breiter sein, als die der Kinder, so orientiert sich die Ausrichtung an diesen

  if PartnerA <> nil and PartnerB <> nil then begin
    // iterativ alle Elterngenerationen zeichnen, aber wie finde ich heraus, wieviele das sind, also durch Iteration?
    PartnerA.Draw(Canvas, x, y); // ???????
  end else 
  if PartnerA <> nil and PartnerB = nil then begin
    // nur PartnerA zeichnen
  end else
  if PartnerA = nil and PartnerB <> Nil then begin
    // nur PartnerB zeichnen
  end;

  for i as Integer = 0 to Kinder.Count do begin
    // auch hier müssen Koordinaten ausfindig gemacht werden, damit die Kinder unter dem Probanden und jeweils nebeneinander gezeichnet werden können
  end;
end;

// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// zu 2. (Partner & Geschwister können angezeigt werden)
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

// um diesen soll sich dann alles drehen, also der Stammbaum aufbauen
TProband = class(TPerson)
  public
    Geschwister: TList<TPerson>;
    Partner: TList<TPerson>;
    Kinder: TList<TPerson>;
    // Draw-Methoden müssten analog zu oben sein
end;

TStammbaum = class(TCanvas)
  puclic
    Proband: TProband; // oder eben TPartnerschaft
    // Draw-Methoden müssten analog zu oben sein
end;

Ist das ein prinzipiell falscher Ansatz?

[Sir Rufo]

Wenn ich mir das Bild so anschaue, dann kann man die Daten zu dieser Anzeige hiermit abbilden (die Bilder habe ich jetzt mal weggelassen):

Delphi-Quellcode:

unit Unit2;

interface

uses
  System.Generics.Collections;

type
  TLocationDateTime = record
    Location: string;
    Timestamp: TDateTime;
  end;

  TPersonViewModel = class
  private
    FID: TGUID;
    FLastName: string;
    FFirstName: string;
    FBorn: TLocationDateTime;
    FDied: TLocationDateTime;
  public
    property ID: TGUID read FID write FID;
    property LastName: string read FLastName;
    property FirstName: string read FFirstName;
    property Born: TLocationDateTime read FBorn;
    property Died: TLocationDateTime read FDied;
  end;

  TParentViewModel = class( TPersonViewModel )
  private
    FFather: TPersonViewModel;
    FMother: TPersonViewModel;
  public
    property Father: TPersonViewModel read FFather;
    property Mother: TPersonViewModel read FMother;
  end;

  TChildViewModel = class( TPersonViewModel )
  private
    FEngagedTo: TList<TPersonViewModel>;
  public
    property EngagedTo: TList<TPersonViewModel> read FEngagedTo;
  end;

  TRelationViewModel = class( TPersonViewModel )
  private
    FChildren: TList<TChildViewModel>;
  public
    property Children: TList<TChildViewModel> read FChildren;
  end;

  TSelectedPersonViewModel = class( TPersonViewModel )
  private
    FFather: TParentViewModel;
    FMother: TParentViewModel;
    FRelations: TList<TRelationViewModel>;
    FSiblings: TList<TChildViewModel>;
  public
    property Father: TParentViewModel read FFather;
    property Mother: TParentViewModel read FMother;
    property Siblings: TList<TChildViewModel> read FSiblings;
    property Relations: TList<TRelationViewModel> read FRelations;
  end;

implementation

end.

[hansklok]

Zitat:

Zitat von Sir Rufo (Beitrag 1311148)

Wenn ich mir das Bild so anschaue, dann kann man die Daten zu dieser Anzeige hiermit abbilden (die Bilder habe ich jetzt mal weggelassen):

Delphi-Quellcode:

unit Unit2;

interface

uses
  System.Generics.Collections;

type
  TLocationDateTime = record
    Location: string;
    Timestamp: TDateTime;
  end;

  TPersonViewModel = class
  private
    FID: TGUID;
    FLastName: string;
    FFirstName: string;
    FBorn: TLocationDateTime;
    FDied: TLocationDateTime;
  public
    property ID: TGUID read FID write FID;
    property LastName: string read FLastName;
    property FirstName: string read FFirstName;
    property Born: TLocationDateTime read FBorn;
    property Died: TLocationDateTime read FDied;
  end;

  TParentViewModel = class( TPersonViewModel )
  private
    FFather: TPersonViewModel;
    FMother: TPersonViewModel;
  public
    property Father: TPersonViewModel read FFather;
    property Mother: TPersonViewModel read FMother;
  end;

  TChildViewModel = class( TPersonViewModel )
  private
    FEngagedTo: TList<TPersonViewModel>;
  public
    property EngagedTo: TList<TPersonViewModel> read FEngagedTo;
  end;

  TRelationViewModel = class( TPersonViewModel )
  private
    FChildren: TList<TChildViewModel>;
  public
    property Children: TList<TChildViewModel> read FChildren;
  end;

  TSelectedPersonViewModel = class( TPersonViewModel )
  private
    FFather: TParentViewModel;
    FMother: TParentViewModel;
    FRelations: TList<TRelationViewModel>;
    FSiblings: TList<TChildViewModel>;
  public
    property Father: TParentViewModel read FFather;
    property Mother: TParentViewModel read FMother;
    property Siblings: TList<TChildViewModel> read FSiblings;
    property Relations: TList<TRelationViewModel> read FRelations;
  end;

implementation

end.

Genau Rufo, dein Entwurf ist sehr gut nachvollziehbar und Bilder genau das ab, worum es mir ging. Dankeschön.
Bleibt nach wie vor zu klären, wie man den Baum "günstig" grafisch in einer Paintbox ausgibt, sodass er sich auch scrollen lässt (Zoom wäre natürlich super). ;) und, wie lässt es sich umsetzen, bei so einem verschachtelten Modell, dass jeder Eintrag sich auf der Zeichenfläche anklicken lässt?

P.S. Was macht EngagedTo?

[Sir Rufo]

Das war nur eine begriffliche Entgleisung und sollte MarriedWith, oder welche Art der Beziehung du dort abbilden möchtest.

Siehe Geschwister und Kinder auf dem Bild, da sind noch 0..2 Personen darunter.

[Sir Rufo]

Zum Zeichnen:

Die Paintbox in eine ScrollBox packen und schon scrollt das, wenn die ScrollBox kleiner als die Paintbox wird.

Die Größe der Paintbox lässt sich einfach berechnen, denn jeder Eintrag hat eine feste Größe und somit ist es fast ein simples Multiplizieren und Addieren.

[hansklok]

Hallo lieber Community,

ich möchte dieses Thema erneut aufgreifen, da ich keinen Schritt weitergekommen bin. Wie gesagt, ich bin Hobby-Entwickler und kann daher oft nicht jeden Gedanken problemlos nachvollziehen. Ich sage das nur, damit die Antworten gern „normalofreundlich“ ausfallen, ohne Fachbegriffe bzw. diese erklärt.

Zitat:

Zitat von Namenloser (Beitrag 1311117)

Ich würde TTreeItem (oder besser TPerson) so definieren:

Delphi-Quellcode:

TPerson = class
  Mother: TPerson;
  Father: TPerson;
  Name: String;
end;

Und mehr brauchst du gar nicht. Die Kinder musst du gar nicht speichern, weil sie sich implizit ergeben: Das sind die Personen, wo entweder Father oder Mother das jeweilige Subjekt sind.

Ist die Argumentation richtig? Weil es wären doch dann immer Mutter und Vater das Subjekt, oder sind mit dem oder Halbgeschwister gemeint?

Zitat:

Zitat von Namenloser (Beitrag 1311117)

Dann noch TFamilyTree in etwa so:

Delphi-Quellcode:

TFamilyTree = class
  Family: TList<TPerson>;
  function TreeToLayers(Subject: TPerson; Depth: Integer): TList<TLayer>;
end;

Ist TFamilyTree jetzt jeweils ein TLayer oder der vollständige Baum nachher? Was wird jetzt alles in der Family Liste dargestellt? Nur immer ein TLayer, also Ausgangsperson und deren Eltern, sowie die Geschwister der Ausgangsperson? Die Kinder der Ausgangsperson und deren Geschwister müssten ja dann wieder in einen neuen TLayer, oder? Vielleicht kann jemand dazu bitte eine kleine Zeichnung machen, um zu veranschaulichen, was in welcher Klasse jeweils ausgegeben wird. Das sollte dem Verständnis meinerseits helfen :)

Was ist in dem Fall, dass eine Ausgangsperson bzw. deren Geschwister mehrere Partner hatte? Die müssen ja dann auch in dem Layer dargestellt werden und die Kinder der einzelnen Beziehungen darunter.

Zitat:

Zitat von Namenloser (Beitrag 1311117)

Um den Baum (eigentlich ein Graph) zu zeichnen, musst du über den Graphen iterieren und ihn in „Schichten“ (= Generationen) anordnen.

Delphi-Quellcode:

type
  TLayer = TList<TPerson>;

function TFamilyTree.TreeToLayers(Subject: TPerson; Depth: Integer): TList<TLayer>;
  procedure AssignPerson(Person: TPerson; Layers: TList<TLayer>; LayerIndex: Integer);
  begin
    if LayerIndex >= Layers.Count then exit;
    Layers[CurrentLayerIndex].Add(Person);
    AssignPerson(Person.Mother, Layers, LayerIndex+1);
    AssignPerson(Person.Father, Layers, LayerIndex+1);
  end;
var 
  i: Integer;
begin
  Result := TList<TLayer>.Create;
  for i := 0 to Depth-1 do
    Result.Add(TLayer.Create);
  AssignPerson(Subject, 0);
end;

In dem Beispielcode werden nur die Ahnen berücksichtigt, aber es ist nicht schwer es so zu erweitern, dass auch Kinder, Geschwichter, Cousins etc. in die jeweiligen Schichten eingefügt werden. Man muss dann nur aufpassen, dass man einen Knoten nicht mehrfach hinzufügt.

Die Schichten kannst du dann problemlos in einer Richtung zeichnen.

Jetzt wird es kompliziert. Der eigentliche Baum ist ist also dann eine Liste von TLayer? Wie kann ich das integrieren, damit die richtigen Kinder jeweils unter dem richtigen Elternpaar abgebildet werden?

Zitat:

Zitat von Sir Rufo (Beitrag 1311148)

Wenn ich mir das Bild so anschaue, dann kann man die Daten zu dieser Anzeige hiermit abbilden (die Bilder habe ich jetzt mal weggelassen):

Vermutlich ist der Vorschlag von Namensloser, den ich wie gesagt noch nicht ganz durchblicke günstiger, weil er nicht nur auf vier Generationen begrenzt ist. Oder kann man Ihre Struktur dynamisch erweitern?

Ich würde mich sehr freuen, wenn wir das Step-by-Step behandeln könnten, damit ich es verstehe und dann auch zu dem, juhu, wie ich Mathematik geliebt habe :( , Berechnungen der Koordinaten kommen.

Ich danke sehr im Voraus.

[p80286]

Also erst einmal hierzu:

Zitat:

Zitat von Namenloser (Beitrag 1311117)

Ich würde TTreeItem (oder besser TPerson) so definieren:

Delphi-Quellcode:

TPerson = class
  Mother: TPerson;
  Father: TPerson;
  Name: String;
end;

Und mehr brauchst du gar nicht. Die Kinder musst du gar nicht speichern, weil sie sich implizit ergeben: Das sind die Personen, wo entweder Father oder Mother das jeweilige Subjekt sind.

Wenn Du Dich auf rein biologische Vorgänge beschränkst (keine Adoption o.ä.) ist diese Struktur ausreichend frei nach "Mater semper certa est " ist die "Mutter" in den meisten Fällen bekannt. Wobei es auch hierbei Ausnahmen geben kann (z.B. Findelkinder).D.h in den meisten Fällen ist Mother/Father nicht Nil. Geschwister einer Person sind somit alle Personen deren Father oder Mother mit Father oder Mother der Person übereinstimmen.
Willst Du hingegen die Möglichkeiten die sich juristisch ergeben können, wirst Du nicht umhin kommen deine Daten in einer solchen (oder ähnlichen) Struktur abzulegen:

Delphi-Quellcode:

TRelPerson =class
  relatedPersID : tID;
  reltype : Treltype;
end;


TPerson = class
  relpersonslist: tlistofRelPerson;
  Name: String;
end;

Gruß
K-H

[hansklok]

Zitat:

Zitat von p80286 (Beitrag 1401989)

Wenn Du Dich auf rein biologische Vorgänge beschränkst (keine Adoption o.ä.) ist diese Struktur ausreichend frei nach "Mater semper certa est " ist die "Mutter" in den meisten Fällen bekannt. Wobei es auch hierbei Ausnahmen geben kann (z.B. Findelkinder).D.h in den meisten Fällen ist Mother/Father nicht Nil. Geschwister einer Person sind somit alle Personen deren Father oder Mother mit Father oder Mother der Person übereinstimmen.
Willst Du hingegen die Möglichkeiten die sich juristisch ergeben können, wirst Du nicht umhin kommen deine Daten in einer solchen (oder ähnlichen) Struktur abzulegen:

Vielen Dank für den Input. Genau, das hatte ich mir auch schon so in die Richtung gedacht, da ich auch Adoptivkinder darstellen möchte.

Wie gesagt, mir bereitet eher die Datenstruktur und deren grafische Ausgabe Kopfzerbrechen, ein normaler Baum kommt hier nicht in Frage und ich denke, Namenloser hat mit seiner Graphen-Argumentation recht. Nur ist diese Materie mir völlig fremd. Ich weiß nur, dass man da nicht unbedingt auf Rekursion zurückgreifen muss.