Statistics
| Revision:

root / trunk / code / projects / traffic_navigation / mapping.c @ 1973

History | View | Annotate | Download (3.58 KB)

1
#include ""
2
#include "mapping.h"
3
#include "lineDrive.h"
4
#include <dragonfly_lib.h>
5

    
6
//The last intersection that we encountered
7
int lastInt;
8

    
9

    
10
/* 
11
 * Traverses the map using DFS 
12
 * Returns 0 if all of the intersections in the database were seen
13
 * 1 otherwise 
14
 */
15
int createMap(){
16

    
17
    int seenout_count = 0;                        /* The number of intersections we have completely seen */
18
    //int hist_count = 0;                        /* The size of our history stack */ 
19

    
20
    char[NUM_FEATURES] seen;                /* Have we seen this node? */
21
    char[NUM_FEATURES] seenout;                /* Have we seen the outoging edges of this node? */
22
    //char[NUM_FEATURES] history;                /* A stack representing the history */
23

    
24
    int i;
25
    int outEdges, currInt, chosenEdge;
26

    
27

    
28
    /* Initialize all of these arrays */
29
    for(i = 0; i<NUM_FEATURES; i++) {
30
            seen[i] = 0;
31
            seenout[i] = 0;
32
            history[i] = 0;
33
            intersections[i].type = 0;
34
            intersections[i].intNum = 0;
35
            intersections[i].numOut = 0;
36
            intersections[i].outSeen = 0;
37
            intersections[i].outgoingEdges[0].to = 0;
38
            intersections[i].outgoingEdges[0].dist = 0;
39
            intersections[i].outgoingEdges[1].to = 0;
40
            intersections[i].outgoingEdges[1].dist = 0;
41
            intersections[i].outgoingEdges[2].to = 0;
42
            intersections[i].outgoingEdges[2].dist = 0;
43
            intersections[i].outgoingEdges[3].to = 0;
44
            intersections[i].outgoingEdges[3].dist = 0;        
45
    }
46

    
47

    
48
        /* Drives to the nearest intersection */
49
        barcode = nextInt();
50

    
51
        while(seenout_count < NUM_FEATURES)
52
        {
53
                currInt = getIntersectionNum(barcode);
54
                seen[currInt] = 1;
55

    
56
                /* Get the number of outgoing edges */
57
                outEdges = getNumOut(getIntersectType(currInt));
58

    
59
                /* Randomly choose an outgoing edge that we have not seen to go down 
60
                 * if no such edge exists */
61
                chosenEdge = rand() % outEdges;
62

    
63
                /* We have not seen all the outgoing edges */
64
                if(!seenout[currInt]){
65
                        intersection[currInt].outSeen++;
66
                        /* We have finished seeing all outgoing edges of the intersection */
67
                        if(intersections[currInt].numOut == intersection[currInt].outSeen){
68
                                seenout[currInt] = 1;
69
                                seenout_count ++;
70
                        }
71
                }
72
                /* Traverses edge, stores information in struct */
73
                traverseEdge(chosenEdge, &(intersection[currInt].outgoingEdges[chosenEdge]));
74
        }
75

    
76
        /* We are done traversing send the graph to the robots */
77
        sendIntersectionGraph();
78

    
79

    
80
        return 0;
81
}
82

    
83
/* Given an intersection type, returns the number of outgoing edges */
84
int getNumOut(int type) {
85
    switch(type){
86
        case 0: return;
87
        case 1:        return; 
88
        case 2:        return; 
89
        case 3:        return;
90
        case 4:        return;
91
    }
92

    
93
    return -1;
94
}
95

    
96

    
97
/* Creates an edge in the graph */
98
int insertEdge(){
99

    
100
}
101

    
102

    
103
/* 
104
 * Drives to the next intersection and returns its ID
105
 * If we are at a dead end, returns -1
106
 */
107
int nextInt(){
108

    
109
}
110

    
111

    
112
/*
113
 * Given an intersection node returns an integer that
114
 * can be sent wirelessly
115
 *
116
 */
117
int encodeNode(node n){
118

    
119

    
120
}
121

    
122
/*
123
 * Uses wireless to send the graph sructure
124
 * to other robots
125
 *
126
 * @return 
127
 *
128
 */
129
void sendIntersectionGraph() {
130
        int i;
131
        node_union graph;
132

    
133
        for(i=0; i< NUM_FEATURES; i++){
134
                graph.n = intersctions[i];
135
                wl_basic_send_global(42, graph.array, 12);
136
        }
137
}