48 votes

Je veux générer ce:

enter image description here

Avec cette structure de données (id aléatoire, btw non séquentielle):

var tree = [
    { "id": 1, "name": "Me", "dob": "1988", "children": [4], "partners" : [2,3], root:true, level: 0, "parents": [5,6] },
    { "id": 2, "name": "Mistress 1", "dob": "1987", "children": [4], "partners" : [1], level: 0, "parents": [] },
    { "id": 3, "name": "Wife 1", "dob": "1988", "children": [5], "partners" : [1], level: 0, "parents": [] },
    { "id": 4, "name": "son 1", "dob": "", "children": [], "partners" : [], level: -1, "parents": [1,2] },
    { "id": 5, "name": "daughter 1", "dob": "", "children": [7], "partners" : [6], level: -1, "parents": [1,3] },
    { "id": 6, "name": "daughter 1s boyfriend", "dob": "", "children": [7], "partners" : [5], level: -1, "parents": [] },
    { "id": 7, "name": "son (bottom most)", "dob": "", "children": [], "partners" : [], level: -2, "parents": [5,6] },
    { "id": 8, "name": "jeff", "dob": "", "children": [1], "partners" : [9], level: 1, "parents": [10,11] },
    { "id": 9, "name": "maggie", "dob": "", "children": [1], "partners" : [8], level: 1, "parents": [] },
    { "id": 10, "name": "bob", "dob": "", "children": [8], "partners" : [11], level: 2, "parents": [12] },
    { "id": 11, "name": "mary", "dob": "", "children": [], "partners" : [10], level: 2, "parents": [] },
    { "id": 12, "name": "john", "dob": "", "children": [10], "partners" : [], level: 3, "parents": [] },
    { "id": 13, "name": "robert", "dob": "", "children": [9], "partners" : [], level: 2, "parents": [] },
    { "id": 14, "name": "jessie", "dob": "", "children": [9], "partners" : [], level: 2, "parents": [15,16] },
    { "id": 15, "name": "raymond", "dob": "", "children": [14], "partners" : [], level: 3, "parents": [] },
    { "id": 16, "name": "betty", "dob": "", "children": [14], "partners" : [], level: 3, "parents": [] },
];

Pour donner une description de la structure des données, la racine/noeud de départ (moi) est défini. Tout partenaire (femme,ex) est sur le même niveau. Tout devient-dessous du niveau -1, -2. Tout ce qui précède est de niveau 1, 2, etc. Il y a des propriétés pour les parents, les frères et sœurs, enfants et partenaires qui définissent les numéros pour ce domaine particulier.

Dans ma précédente question, eh9 décrit comment il allait régler ce. Je tente de le faire, mais comme je l'ai découvert, il n'est pas une tâche facile.

Ma première tentative est rendu présent par niveaux, de haut en bas. Dans ce plus simple tentative, j'ai essentiellement nid tous les gens par niveaux et de rendre ce de haut en bas.

Ma deuxième tentative est rendu avec cette une de l'ancêtre des nœuds à l'aide d'une profondeur d'abord de recherche.

Ma principale question est: Comment puis-je appliquer effectivement que la réponse à ce que j'ai actuellement? Dans ma deuxième tentative, j'ai essaye de faire un parcours en profondeur d'abord la traversée, mais comment puis-je commencer à compte pour le calcul de la distance nécessaire pour compenser les grilles pour le rendre compatible avec la façon dont je veux générer ce?

Aussi, c'est de ma compréhension et de mise en œuvre de la profondeur d'abord l'idéal, ou puis-je traverser autrement?

Les nœuds évidemment se chevauchent dans mon deuxième exemple, puisque je n'ai pas de compensation/calcul de la distance de code, mais je suis perdu à essayer de comprendre comment je peux commencer.

Voici une description de la marche de la fonction que j'ai fait, où je suis tenter de faire un parcours en profondeur d'abord de la traversée:

// this is used to map nodes to what they have "traversed". So on the first call of "john", dict would internally store this:
// dict.getItems() = [{ '12': [10] }]
// this means john (id=10) has traversed bob (id=10) and the code makes it not traverse if its already been traversed. 
var dict = new Dictionary;

walk( nested[0]['values'][0] ); // this calls walk on the first element in the "highest" level. in this case it's "john"

function walk( person, fromPersonId, callback ) {

    // if a person hasn't been defined in the dict map, define them
    if ( dict.get(person.id) == null ) {
        dict.set(person.id, []);


        if ( fromPersonId !== undefined || first ) {

            var div = generateBlock ( person, {
                // this offset code needs to be replaced
                top: first ? 0 : parseInt( $(getNodeById( fromPersonId ).element).css('top'), 10 )+50,
                left: first ? 0 : parseInt( $(getNodeById( fromPersonId ).element).css('left'), 10 )+50
            });

            //append this to the canvas
            $(canvas).append(div);

            person.element = div;
        }
    }

    // if this is not the first instance, so if we're calling walk on another node, and if the parent node hasn't been defined, define it
    if ( fromPersonId !== undefined ) {
        if ( dict.get(fromPersonId) == null ) {
            dict.set(fromPersonId, []);
        }

        // if the "caller" person hasn't been defined as traversing the current node, define them
        // so on the first call of walk, fromPersonId is null
        // it calls walk on the children and passes fromPersonId which is 12
        // so this defines {12:[10]} since fromPersonId is 12 and person.id would be 10 (bob)
        if ( dict.get(fromPersonId).indexOf(person.id) == -1 )
            dict.get(fromPersonId).push( person.id );
    }

    console.log( person.name );

    // list of properties which house ids of relationships
    var iterable = ['partners', 'siblings', 'children', 'parents'];
    iterable.forEach(function(property) {
        if ( person[property] ) {
            person[property].forEach(function(nodeId) {
                // if this person hasnt been "traversed", walk through them
                if ( dict.get(person.id).indexOf(nodeId) == -1 )
                    walk( getNodeById( nodeId ), person.id, function() {
                        dict.get(person.id).push( nodeId );
                    });
            });
        }
    });


}

}

Exigences et restrictions:

  1. C'est pour un éditeur et serait semblable à familyecho.com. Pratiquement toutes les règles commerciales ne peuvent être pris en charge au moyen que.
  2. En élevage familial n'est pas pris en charge comme il le ferait de cette façon trop complexe. Ne vous inquiétez pas à ce sujet.
  3. Plusieurs partenaires sont pris en charge si ce n'est pas aussi facile que d'un traditionnel "arbre généalogique" avec seulement 2 parents et 1 enfant.
  4. Il n'y a qu'un seul "root" nœud, ce qui est tout le nœud de départ.

Notes: familyecho.com l'air de "cacher" une branche si il y a beaucoup de nœuds feuilles et il y a une collision. Peut-être besoin de mettre en œuvre cette.

Prograide.com

Prograide est une communauté de développeurs qui cherche à élargir la connaissance de la programmation au-delà de l'anglais.
Pour cela nous avons les plus grands doutes résolus en français et vous pouvez aussi poser vos propres questions ou résoudre celles des autres.

Powered by:

X