Revision 1987
trunk/code/projects/traffic_navigation/mapping.c  

17  17 
* placed somewhere randomly on the map in the middle of the road*/ 
18  18 
char driveToNextInt(){ 
19  19 
char barcode; 
20 


20  
21 
/* Keep driving until we see a barcode */ 

21  22 
do { 
22 
barcode = (char) doDrive(200); 

23 
barcode = (char) doDrive(200);


23  24 
} 
24  25 
while(barcode < 0); /* Condition codes are all neg. */ 
25  26  
...  ...  
42  43  
43  44 
turn(type, direction); 
44  45  
46 
/* Keep driving until we see a barcode */ 

45  47 
do { 
46 
barcode = (char) doDrive(200); 

48 
barcode = (char) doDrive(200);


47  49 
} 
48  50 
while(barcode < 0); /* Condition codes are all neg. */ 
49  51  
...  ...  
51  53  
52  54 
newEdge>to = barcode; 
53  55 
newEdge>dist = time; 
54 


56  
55  57 
return barcode; 
56  58 
} 
57  59  
58  60 
/* This function performs mapping */ 
59  61 
int createMap(){ 
60  62  
61 
int seenout_count = 0; /* The number of intersections we have completely seen */ 

63 
char seen[NUM_FEATURES]; /* Have we been at this intersection before*/ 

64 
char seenout[NUM_FEATURES]; /* Have we seen the outoging edges of this intersection? */ 

62  65  
63 
char seen[NUM_FEATURES]; /* Have we seen this node? */


64 
char seenout[NUM_FEATURES]; /* Have we seen the outoging edges of this node? */


66 
char seenall[NUM_FEATURES]; /* This is how the array should look like once we have


67 
* seen everything */


65  68  
66 
int outEdges, currInt, chosenDir;


69 
int outEdges, currInt, chosenDir, i;


67  70  
68 
initGraph(seen, seenout); 

71 
/* Initialize the graph to all zeros */ 

72 
initGraph(seen, seenout); 

69  73  
70 
/* Drives to the nearest intersection */ 

71 
char barcode = driveToNextInt(); 

74 
/* When we see all the outgoing edges for the intersections, 

75 
* seenout will look as follows */ 

76 
for(i=0; i<NUM_FEATURES; i++) 

77 
seenall[i] = 1; 

72  78  
73 
while(seenout_count < NUM_FEATURES) 

74 
{ 

75 
currInt = getIntersectNum(barcode); 

76 
seen[currInt] = 1; 

77 


78 
/* Get the number of outgoing edges */ 

79 
outEdges = getNumOut(getIntersectType(currInt)); 

79 
/* First drives to the nearest intersection */ 

80 
char barcode = driveToNextInt(); 

80  81  
81 
/* Randomly choose an outgoing edge that we have not seen to go down 

82 
* if no such edge exists */ 

83 
// TODO: include the appropriate header file for rand() 

84 
chosenDir = rand() % outEdges; 

85  82  
86 
/* We have not seen all the outgoing edges */ 

87 
if(!seenout[currInt]){ 

88 
intersections[currInt].outSeen++; 

89 
/* We have finished seeing all outgoing edges of the intersection */ 

90 
if(intersections[currInt].numOut == intersections[currInt].outSeen){ 

91 
seenout[currInt] = 1; 

92 
seenout_count ++; 

93 
} 

94 
} 

95 
/* Traverses edge, stores information in struct */ 

96 
createEdge(&(intersections[currInt].outgoingEdges[chosenDir]), 

97 
getIntersectType(currInt), chosenDir); 

98 
} 

83 
/* Randomly traverses the graph until all edges are seen */ 

84 
while(seenout != seenall) 

85 
{ 

86 
currInt = getIntersectNum(barcode); 

87 
seen[currInt] = 1; 

99  88  
100 
/* We are done traversing send the graph to the robots */


101 
sendIntersectionGraph();


89 
/* Get the number of outgoing edges */


90 
outEdges = getNumOut(getIntersectType(currInt));


102  91  
92 
/* Assign the number of outgoing edges for the current int */ 

93 
intersections[currInt].numOut = outEdges; 

103  94  
104 
return 0; 

95 
/* Randomly choose an outgoing edge that we have not seen to go down 

96 
* if no such edge exists */ 

97 
chosenDir = rand() % outEdges; 

98  
99 
/* We have not seen all the outgoing edges for the intersection we are at */ 

100 
if(!seenout[currInt]){ 

101 
intersections[currInt].outSeen++; 

102 
/* We have finished seeing all outgoing edges of the intersection */ 

103 
if(outEdges == intersections[currInt].outSeen){ 

104 
seenout[currInt] = 1; 

105 
} 

106 
} 

107 


108 
/* Traverses edge, stores information in struct */ 

109 
//TODO: Does the chosendDir, correspond with what is in Priya's Code? 

110 
//A number between 0 and the number of outgoing edges ? 

111 
createEdge(&(intersections[currInt].outgoingEdges[chosenDir]), 

112 
getIntersectType(currInt), chosenDir); 

113 
} 

114  
115 
/* We are done traversing send the graph to the robots */ 

116 
while(1) sendIntersectionGraph(); 

117  
118 
return 0; 

105  119 
} 
106  120  
107  121 
/* Initializes the elements in the graph to 0 */ 
108  122 
void initGraph(char* seen, char* seenout){ 
109  123  
110 
int i;


124 
int i, j;


111  125  
112 
/* Initialize all of these arrays */ 

113 
for(i = 0; i<NUM_FEATURES; i++) { 

114 
seen[i] = 0; 

115 
seenout[i] = 0; 

116 
intersections[i].type = 0; 

117 
intersections[i].intNum = 0; 

118 
intersections[i].numOut = 0; 

119 
intersections[i].outSeen = 0; 

120 
intersections[i].outgoingEdges[0].to = 0; 

121 
intersections[i].outgoingEdges[0].dist = 0; 

122 
intersections[i].outgoingEdges[1].to = 0; 

123 
intersections[i].outgoingEdges[1].dist = 0; 

124 
intersections[i].outgoingEdges[2].to = 0; 

125 
intersections[i].outgoingEdges[2].dist = 0; 

126 
intersections[i].outgoingEdges[3].to = 0; 

127 
intersections[i].outgoingEdges[3].dist = 0; 

128 
} 

126 
/* Set all graph storge elements to 0 */ 

127 
for(i = 0; i<NUM_FEATURES; i++) { 

128 
seen[i] = 0; 

129 
seenout[i] = 0; 

130 
intersections[i].type = 0; 

131 
intersections[i].intNum = 0; 

132 
intersections[i].numOut = 0; 

133 
intersections[i].outSeen = 0; 

134 
for(j = 0; j<4; j++){ 

135 
intersections[i].outgoingEdges[0].to = 0; 

136 
intersections[i].outgoingEdges[0].dist = 0; 

137 
} 

138 
} 

129  139 
} 
130  140  
131  141  
132  142 
/* Given an intersection type, returns the number of outgoing edges */ 
133  143 
int getNumOut(int type) { 
134 
switch(type){ 

135 
case 0: return 3; 

136 
case 1: return 1; 

137 
case 2: return 1; 

138 
case 3: return 3; 

139 
case 4: return 2; 

140 
} 

141 
return 1; 

144 
switch(type){


145 
case 0: return 3;


146 
case 1: return 1;


147 
case 2: return 1;


148 
case 3: return 3;


149 
case 4: return 2;


150 
}


151 
return 1;


142  152 
} 
143  
144 
/* 

145 
* Drives to the next intersection and returns its ID 

146 
* If we are at a dead end, returns 1 

147 
*/ 

148 
int nextInt(){ 

149 
return 0; 

150 
} 

151  
152  
153 
/* 

154 
* Given an intersection node returns an integer that 

155 
* can be sent wirelessly 

156 
* 

157 
*/ 

158 
int encodeNode(node n){ 

159 
return 0; 

160 
} 

161 
Also available in: Unified diff