1
00:00:00,860 --> 00:00:05,300
In the previous cooling session, we developed a graph class to store our math.

2
00:00:05,660 --> 00:00:10,250
Now we will utilize it to create a graph representation for our maize.

3
00:00:10,880 --> 00:00:16,940
For this, we move inside the initialization function of our board member class where we create a new

4
00:00:16,940 --> 00:00:24,350
instance variable that we name as crop and we initialize this to the object of the graph class, thus

5
00:00:24,350 --> 00:00:29,120
providing us access to the graph class from inside the board member class.

6
00:00:30,290 --> 00:00:39,260
Next, we create or define a set of state variables that are connected to their connected, uplift up

7
00:00:39,650 --> 00:00:40,400
and upright.

8
00:00:40,760 --> 00:00:45,380
Basically the for direction any node might be connected to to its neighbor nodes.

9
00:00:45,920 --> 00:00:51,530
So as this is the initializing point, all these particular boolean variables have been initialized

10
00:00:51,530 --> 00:00:52,070
to false.

11
00:00:52,550 --> 00:00:58,700
But if a particular note is connected to its neighbor node in any one of these directions, then they

12
00:00:58,700 --> 00:01:00,860
will be set to true respectively.

13
00:01:01,830 --> 00:01:05,130
Now we need to define the function that actually performs the task.

14
00:01:05,160 --> 00:01:10,380
Now, if you define the function that actually performs the task of connection of each node to its neighbors.

15
00:01:11,220 --> 00:01:13,590
So that function is known as connect neighbors.

16
00:01:14,490 --> 00:01:20,550
So what this function will do is takes these arguments that is, makes no drawing node column representing

17
00:01:20,550 --> 00:01:21,270
the current node.

18
00:01:21,810 --> 00:01:24,060
Then we have the case for that particular node.

19
00:01:24,300 --> 00:01:30,180
Then we have the step and step up representing how many steps have taken in a particular left sort of

20
00:01:30,210 --> 00:01:30,750
direction.

21
00:01:30,990 --> 00:01:36,360
For example, one represents one pixel to the left direction for step out and for the total character

22
00:01:36,420 --> 00:01:41,580
basically represents how many nodes have been connected to a node as this is the initialization point

23
00:01:41,880 --> 00:01:45,870
and we are defining the function, it hasn't been defined to be zero at this point.

24
00:01:47,250 --> 00:01:53,640
Now we define this particular function where we start by defining the note that is basically tuple.

25
00:01:55,420 --> 00:01:59,530
Of consisting of not rule and not column.

26
00:02:00,520 --> 00:02:05,470
Then we start by looking for a path in one of the four directions that is left.

27
00:02:05,710 --> 00:02:07,150
Then top left.

28
00:02:07,480 --> 00:02:09,220
Then top and then top right.

29
00:02:09,550 --> 00:02:13,960
So in this way, we are going to find a neighbor in one of these direction for each note.

30
00:02:14,470 --> 00:02:18,010
So starting off, we start by looking in the maze.

31
00:02:21,050 --> 00:02:21,340
All right.

32
00:02:21,340 --> 00:02:22,840
Ignored route minus.

33
00:02:22,840 --> 00:02:32,380
Step up the note column when it's simpler and if it is greater than zero, then that means that we have

34
00:02:32,380 --> 00:02:37,300
found a path and now we need to find a node in that particular path and connect to it.

35
00:02:38,410 --> 00:02:41,290
So it is a probable neighbor node right here.

36
00:02:43,330 --> 00:02:51,850
And what it would be equal to is basically a tuple that is no draw minus step up note column.

37
00:02:53,450 --> 00:02:54,470
Minus step left.

38
00:02:55,490 --> 00:03:00,830
And this probable note we need to check whether this note exists or not at this particular point, and

39
00:03:00,830 --> 00:03:08,060
that can be done by calling the neighbor node in self node graph, not graph that.

40
00:03:08,060 --> 00:03:12,890
Keith So if it is part of the keys for the graph, then that node is part of the graph.

41
00:03:13,370 --> 00:03:19,190
Then all we need to do is simply connect the current node to our neighbor node, and for that we need

42
00:03:19,190 --> 00:03:24,140
to require information about our neighbor node and that can be accessed by simply writing.

43
00:03:25,940 --> 00:03:32,450
We first need to extract the neighbors case so the neighbors case can be simply extracted by start calling

44
00:03:32,450 --> 00:03:33,410
the sales dot graph.

45
00:03:34,660 --> 00:03:38,470
And graph again and then passing in the neighbor node.

46
00:03:40,070 --> 00:03:43,940
As the key and then the key of this dictionary for the neighbor.

47
00:03:43,940 --> 00:03:45,740
Note It falls in the case.

48
00:03:46,070 --> 00:03:48,110
So we accessed the case for the neighbor.

49
00:03:48,110 --> 00:03:54,560
Note And then to extract the cost of traversing from the current nor the neighbor note all we need to

50
00:03:54,560 --> 00:04:00,740
do is simply write the max value between the absolute of the step left.

51
00:04:02,270 --> 00:04:05,330
And absolute of the step up.

52
00:04:06,110 --> 00:04:11,690
So this provides us the cost of traversing between the neighbor node and the current node or the current

53
00:04:11,750 --> 00:04:12,620
node, put it or not.

54
00:04:12,950 --> 00:04:14,870
So they are interchangeable.

55
00:04:15,710 --> 00:04:20,840
Now, once we have this information, we simply increment the total increment connected by one.

56
00:04:21,050 --> 00:04:24,410
So we have found a connection to the from the current node, the neighbor node.

57
00:04:24,680 --> 00:04:26,030
So we have found one connection.

58
00:04:26,150 --> 00:04:28,310
So the total connected has been incremented by one.

59
00:04:28,730 --> 00:04:31,070
Now all we need to do is simply create the connection.

60
00:04:32,160 --> 00:04:38,700
And that can be done by simply calling a graph object and then calling our vertex function.

61
00:04:39,000 --> 00:04:45,180
So we provide the vertex that is current node and then the neighbor node.

62
00:04:48,870 --> 00:04:54,480
And then for the kids, as we're connecting to the neighbor, you'll we providing the neighbors case

63
00:04:55,890 --> 00:05:03,030
and then we providing the cost in the same way reconnected back by providing the neighbor with.

64
00:05:07,100 --> 00:05:13,820
And connecting it to the crime scene and for the Casey files in the case and for the courts to pass

65
00:05:13,820 --> 00:05:19,040
in the courts now that they have done this connection between the cardinal and the neighbor, knowing

66
00:05:19,040 --> 00:05:24,360
that you just going to present it to the user and that can be done by writing a nice little print or

67
00:05:24,380 --> 00:05:25,580
just a space to the user.

68
00:05:26,000 --> 00:05:29,090
And this connection has been done in a special direction.

69
00:05:29,420 --> 00:05:31,070
So we don't know in which direction.

70
00:05:31,190 --> 00:05:36,050
So we are going to look in all of those directions to see which was the connection that has been just

71
00:05:36,050 --> 00:05:36,500
been done.

72
00:05:36,890 --> 00:05:41,600
So this is following the specific cycle, as I mentioned before, that is start looking in the left

73
00:05:41,600 --> 00:05:44,390
direction if a note is found, look connected to that.

74
00:05:44,810 --> 00:05:50,030
Otherwise look in the opposite direction next to this phone and look in connected with that and then

75
00:05:50,030 --> 00:05:53,090
look up direction and then in the upper right direction.

76
00:05:53,330 --> 00:05:54,650
So this is how the cycle votes.

77
00:05:54,830 --> 00:05:57,080
So we are going to do exactly that.

78
00:05:58,920 --> 00:06:05,370
And simply check whether if you have not already connected to the left, then this means this connection

79
00:06:05,730 --> 00:06:07,500
was to the left.

80
00:06:08,040 --> 00:06:11,760
So the first thing that we need to do is to display this connection to the user.

81
00:06:12,210 --> 00:06:16,050
And that can be done by simply calling a function that is displaying connected notes.

82
00:06:16,350 --> 00:06:19,380
We have not define this function, so let's define this function right here.

83
00:06:20,310 --> 00:06:21,780
So we define this function right here.

84
00:06:22,110 --> 00:06:27,600
And what this function does is simply it takes the current node, takes the neighbor node, and draws

85
00:06:27,600 --> 00:06:29,190
a line on the Miss Connect.

86
00:06:29,430 --> 00:06:30,600
This is the variable.

87
00:06:30,690 --> 00:06:36,720
This is the first hole that will be created later on to simply display the connection between each and

88
00:06:36,720 --> 00:06:37,230
its neighbors.

89
00:06:38,420 --> 00:06:41,180
So we call this particular function to display the connections.

90
00:06:41,330 --> 00:06:45,080
And then because we are not we have not connected to left before.

91
00:06:45,260 --> 00:06:49,250
And there was a connection that this indicates that we have connected to the left now.

92
00:06:49,610 --> 00:06:56,240
So we need to set this group and then we need to look in the next election in the cycle, and that is

93
00:06:56,240 --> 00:06:56,830
up there.

94
00:06:56,870 --> 00:07:02,930
And that can be done by sending the step left one and step up to one.

95
00:07:03,710 --> 00:07:06,890
So once we have done this, we have updated the step left and step up.

96
00:07:08,040 --> 00:07:14,400
Then the next thing that we need to do is to simply call the connect neighbors function.

97
00:07:15,000 --> 00:07:19,050
So what this function does is simply recursively call the connect neighbor functions.

98
00:07:19,380 --> 00:07:23,160
Now that we have opted into, step there and step up variables.

99
00:07:23,520 --> 00:07:29,250
And what this updated thing does, it simply says that now we are connected to the left direction.

100
00:07:29,520 --> 00:07:34,320
Look in the upper left direction because we are looking one pixel two and pixel two dot.

101
00:07:35,440 --> 00:07:37,600
So we need to add a few more parameters.

102
00:07:37,750 --> 00:07:43,540
That is the operative step right here and ability to step up and the total connected.

103
00:07:45,110 --> 00:07:50,330
Now, once you've done this to address all the rest of the cases, there is uplift up.

104
00:07:52,540 --> 00:07:53,290
Just like this.

105
00:07:53,620 --> 00:07:57,970
So what we're doing is similar to what we did in the previous case.

106
00:07:58,270 --> 00:07:59,830
That is for the uplift we look.

107
00:07:59,830 --> 00:08:04,840
If we are not connected to the uplift, we display that connection by writing uplift right here and

108
00:08:04,840 --> 00:08:10,930
then exiting that uplift connected uplift boolean to true starting this step lift and step up to zero

109
00:08:10,930 --> 00:08:16,000
one, basically indicating that now look in the other direction and then calling that connect neighbors

110
00:08:16,000 --> 00:08:23,560
again the same way we go up all of the upright function operate boolean where we simply said this to

111
00:08:23,560 --> 00:08:26,410
true and not call the connect name but it's function.

112
00:08:26,620 --> 00:08:30,760
This is because we have completed the cycle and all the connection has been done.

113
00:08:31,540 --> 00:08:33,370
So now we address this condition.

114
00:08:33,370 --> 00:08:34,780
We are to address the condition.

115
00:08:35,050 --> 00:08:39,120
What would happen if the neighbor node was not found in the can?

116
00:08:39,130 --> 00:08:41,890
Step there a step up that we were looking at.

117
00:08:42,550 --> 00:08:48,610
So we are already on a path and if we have not found the node in that particular path, then that means

118
00:08:48,610 --> 00:08:53,800
we need to look a little more in that direction and that can be done by simply implementing whatever

119
00:08:53,800 --> 00:08:56,170
the step, left step of was before.

120
00:08:56,740 --> 00:09:05,470
So for example, to check with the first check whether we have completed the cycle that that was necessary

121
00:09:05,470 --> 00:09:11,230
for us and that means, if not certain, connected upright, then the cycle has not been completed.

122
00:09:11,590 --> 00:09:13,870
We are still looking to connect to its neighbors.

123
00:09:14,350 --> 00:09:21,910
So we start again from the start by looking at the self not connected left.

124
00:09:22,690 --> 00:09:27,640
So we see that if we are looking in the path and we were looking in a particular direction that was

125
00:09:27,640 --> 00:09:32,410
left, so we were looking in the left direction and we haven't found the node, but there was a path

126
00:09:32,410 --> 00:09:32,710
there.

127
00:09:33,160 --> 00:09:37,990
Then the north should be a little more to the left and that can be done by simply incrementing the step

128
00:09:37,990 --> 00:09:38,260
left.

129
00:09:40,170 --> 00:09:40,530
One.

130
00:09:40,950 --> 00:09:42,300
One pixel more to the left.

131
00:09:42,600 --> 00:09:46,580
And we try to find our dear assembly.

132
00:09:46,590 --> 00:09:52,110
We address the rest of the cases where if we are looking if we are looking in the upper left, then

133
00:09:52,110 --> 00:09:53,850
we need to look a little more up there.

134
00:09:54,180 --> 00:09:55,050
We're looking to look up.

135
00:09:55,230 --> 00:09:56,580
We need to look a little more up.

136
00:09:57,030 --> 00:10:00,270
And if we look upright, we need to look a little more upright.

137
00:10:00,870 --> 00:10:07,380
And for the upright instead difference, the step left of step left is not incremented because it either

138
00:10:07,380 --> 00:10:11,030
decrement because minus minus gives this step there positive.

139
00:10:11,760 --> 00:10:17,640
And then we call the connect neighbors recursively basically start looking a little more in that particular

140
00:10:17,640 --> 00:10:23,280
direction to connect to the neighbor node if found now, now that we've addressed all these cases,

141
00:10:23,280 --> 00:10:24,510
we address the case.

142
00:10:24,780 --> 00:10:30,240
What would happen if the direction that we are looking does not contain a but that means no, it is

143
00:10:30,240 --> 00:10:30,510
there.

144
00:10:30,720 --> 00:10:34,230
We need to look in the next election in our cycle.

145
00:10:34,680 --> 00:10:37,350
So we need to address that case and that can be done.

146
00:10:37,350 --> 00:10:38,460
This ls right here.

147
00:10:39,360 --> 00:10:43,200
So the direction that you were looking is was not a path.

148
00:10:43,440 --> 00:10:50,070
So for that else case, we need to start looking from the start and that is if not self not connected

149
00:10:50,070 --> 00:10:50,460
left.

150
00:10:51,780 --> 00:10:57,930
So the first direction, the cycle, what we need to do is simply say the sender connected left is true.

151
00:10:58,050 --> 00:11:02,100
So don't look in the left direction anymore because we haven't found it.

152
00:11:02,340 --> 00:11:03,330
That part's blocked.

153
00:11:04,080 --> 00:11:08,730
So we update the step left to one and step up to one.

154
00:11:09,260 --> 00:11:16,710
We basically say to the goal to simply loop in the opposite direction and then we call the connect.

155
00:11:16,710 --> 00:11:25,950
Neighbors function once more and provided the new primitives of step left and step up and a total connected.

156
00:11:27,870 --> 00:11:33,900
And once we have done this to address all the other cases that might come and that are up, left up

157
00:11:34,350 --> 00:11:35,190
and upright.

158
00:11:35,850 --> 00:11:40,620
So finally, when we get to the upright, we said that to upright or true, this was the last of action,

159
00:11:40,680 --> 00:11:41,280
the cycle.

160
00:11:41,730 --> 00:11:45,930
We reset the step there and step up to zero and simply return the function.

161
00:11:46,230 --> 00:11:47,770
This completes the function definition.

162
00:11:48,030 --> 00:11:52,620
And now we can simply utilize this function inside the One Path algorithm.

163
00:11:53,070 --> 00:11:57,630
So instead of one path algorithm, the very first thing that we need to do is to simply call that graph

164
00:11:59,250 --> 00:12:04,980
or the graph object and call the graph dictionary inside of it and simply clear it so that whenever

165
00:12:04,980 --> 00:12:10,110
we call this one false function, it does not start filling it in the previous dictionary.

166
00:12:10,680 --> 00:12:13,870
So this gets cleared whenever this one passed functions your scope.

167
00:12:15,030 --> 00:12:19,620
The next thing that we need to do is to simply create the disconnect that we were talking about earlier.

168
00:12:19,980 --> 00:12:26,160
This is basically the variable or the image which will display the connection from each node to its

169
00:12:26,160 --> 00:12:26,790
neighbor nodes.

170
00:12:27,570 --> 00:12:33,720
And then we simply create a few counters that are the count of the number of times that be a phone,

171
00:12:33,750 --> 00:12:36,500
number of three junctions, a number of four junctions that we have.

172
00:12:37,170 --> 00:12:42,450
And because we have created a miss connect or an instance variable, Obama is going to to initialize

173
00:12:42,450 --> 00:12:43,680
this inside.

174
00:12:44,930 --> 00:12:46,160
Our initialize and function.

175
00:12:46,850 --> 00:12:49,280
So right here we initialize them is connect.

176
00:12:50,120 --> 00:12:53,120
So this is we have initialize this to an empty list.

177
00:12:54,050 --> 00:12:55,490
Now we move inside.

178
00:12:55,490 --> 00:13:02,480
The iterative loop that we were doing to loop over our in time is right after we have found a particular

179
00:13:02,480 --> 00:13:02,810
part.

180
00:13:03,920 --> 00:13:06,950
What we need to do is to simply really slice.

181
00:13:08,020 --> 00:13:12,100
Our myths connect to the gray or BGR myth.

182
00:13:12,610 --> 00:13:18,400
So basically, if we are debugging the mapping, we are going to display the individual connection of

183
00:13:18,400 --> 00:13:20,170
each node to its neighbor nodes.

184
00:13:20,500 --> 00:13:21,580
So this is just for debugging.

185
00:13:22,330 --> 00:13:28,540
Then after we have found the start and end, we need to add the start and end to the graph now.

186
00:13:29,080 --> 00:13:34,360
So instead of just displaying them in the form for nice looking colors, we now add them to the graph.

187
00:13:34,480 --> 00:13:36,130
And that can be done by simply going.

188
00:13:38,130 --> 00:13:38,670
The graph.

189
00:13:40,790 --> 00:13:45,290
And add vertex and vertex passing information, that is.

190
00:13:46,980 --> 00:13:49,290
The tuple that is row and column.

191
00:13:49,890 --> 00:13:52,290
And for the neighbor, we have no neighbors.

192
00:13:52,320 --> 00:13:58,260
We are simply adding this particular vertex that is a current vertex and we pass in the case.

193
00:13:58,620 --> 00:14:00,870
That is because this this was formed as a start.

194
00:14:01,170 --> 00:14:02,340
So the case is basically.

195
00:14:03,670 --> 00:14:04,180
Start.

196
00:14:05,500 --> 00:14:06,200
Represented.

197
00:14:06,200 --> 00:14:07,210
This is the start.

198
00:14:09,900 --> 00:14:12,480
And then if we have the costs, we don't have the cost.

199
00:14:12,900 --> 00:14:19,890
And then we simply update the graph information of the start that this is the start and by writing the

200
00:14:19,890 --> 00:14:21,870
tuple after four column.

201
00:14:22,530 --> 00:14:27,930
So basically we now have updated that we have found the start of the graph that is the role column at

202
00:14:27,930 --> 00:14:29,940
this particular moment and the ROIs zero.

203
00:14:30,450 --> 00:14:36,570
And we have added this particular node to the graph and we have named it name this node or named the

204
00:14:36,570 --> 00:14:38,100
case of the node as start.

205
00:14:38,760 --> 00:14:44,820
We do the same process for the end node when we have found it, so that can be done by system graph

206
00:14:45,090 --> 00:14:45,890
added vertex.

207
00:14:47,400 --> 00:14:50,640
Your boss in the win column as the vertex.

208
00:14:51,450 --> 00:14:52,950
And then for the case.

209
00:14:54,380 --> 00:14:55,210
We're right here.

210
00:14:56,380 --> 00:14:57,340
That this is the end.

211
00:14:58,750 --> 00:14:59,110
So.

212
00:15:00,790 --> 00:15:03,820
And here we also need to write here that this was the case.

213
00:15:04,540 --> 00:15:12,160
So once we have done this, we need to also update the instance variable of graph that was the and as

214
00:15:12,160 --> 00:15:12,690
we have found.

215
00:15:12,700 --> 00:15:18,580
And so we need to simply say that this particular row and column that we are on right now is the end.

216
00:15:19,210 --> 00:15:20,620
Now for the end.

217
00:15:20,620 --> 00:15:26,740
And from this point onwards, we need to also perform the connection from our current note to its neighbor

218
00:15:26,740 --> 00:15:32,830
note because for the start we could not connected to anywhere because the the cycle that we were looking

219
00:15:32,830 --> 00:15:38,050
for, for any neighbor notes, does not exist for the start note as it is on the first row.

220
00:15:38,770 --> 00:15:41,290
So the cycle was looking left direction.

221
00:15:41,290 --> 00:15:45,010
Look in the top left direction, look in the top and look in the top, right.

222
00:15:45,220 --> 00:15:50,530
So none of these conditions occur for the start note so we don't connected to any and they were not

223
00:15:51,040 --> 00:15:57,940
but for the end or we can do that so we simply right here so that connect neighbors.

224
00:15:58,940 --> 00:16:01,070
And that can be done by simply passing in the midst.

225
00:16:02,180 --> 00:16:09,500
For the no rule, you passing the rule for the note column you pass in the column and for the kids in

226
00:16:09,500 --> 00:16:11,330
Boston that this is the end.

227
00:16:15,610 --> 00:16:17,140
So once we pass this information.

228
00:16:19,010 --> 00:16:26,540
And once they passed the information, they basically called to connect this and vertex to all of the

229
00:16:26,540 --> 00:16:31,010
neighbor vertex that might come in any of the four directions that we mentioned before.

230
00:16:31,460 --> 00:16:35,270
So in this way, we connect our end vertex to all of its neighbors.

231
00:16:37,730 --> 00:16:44,150
So one thing that we need to do before this particular function is to simply call another function that

232
00:16:44,150 --> 00:16:47,360
is self-talk graph, but self-talk.

233
00:16:49,610 --> 00:16:51,620
Reset or reset?

234
00:16:54,920 --> 00:16:56,030
Connect parameters.

235
00:16:56,540 --> 00:16:58,610
This function will get called right here.

236
00:16:58,910 --> 00:17:03,770
This basically resets the connection parameters or the state variables that represents the connection

237
00:17:04,040 --> 00:17:05,120
for each particular node.

238
00:17:05,330 --> 00:17:09,800
So these needs to be reset for every time we want to connect a particular node to its neighbors.

239
00:17:10,490 --> 00:17:13,910
So this needs to be called every time we want to connect to particular Northwest neighbors.

240
00:17:15,550 --> 00:17:17,890
So these are the two things that we need to perform.

241
00:17:18,160 --> 00:17:21,870
The same way we look for the dating after we have found a dating.

242
00:17:22,690 --> 00:17:27,250
So what we need to do, we need to add that different or note to the graph.

243
00:17:28,450 --> 00:17:36,180
We're writing at Vertex for the Vertex three path in the row and column and for the case you pass in

244
00:17:36,940 --> 00:17:38,320
that this is a dead end.

245
00:17:41,830 --> 00:17:50,890
So once we have mentioned this information, we need to reset, reset the correction parameters and

246
00:17:50,890 --> 00:17:51,460
then call.

247
00:17:53,460 --> 00:17:54,350
To connect neighbors.

248
00:17:54,540 --> 00:17:59,910
We need to connect this dating to its neighbors and that can be simply be done by setting the miss.

249
00:18:01,840 --> 00:18:10,120
And that in order to grow and passing the column as not going and for the kids we passing.

250
00:18:12,650 --> 00:18:16,350
The case of this particular note that is it said there that.

251
00:18:18,400 --> 00:18:23,320
So once you've done this, you basically perform all the connections for any dating that we might come

252
00:18:23,320 --> 00:18:23,680
across.

253
00:18:24,700 --> 00:18:27,640
And then we need to address the same case for the tenants.

254
00:18:28,420 --> 00:18:29,680
So once we have found the tone.

255
00:18:30,430 --> 00:18:35,200
So once we have found a tone, we do the exact same thing and add the words.

256
00:18:35,590 --> 00:18:39,760
Writing the ruined column say that that case was stones.

257
00:18:40,270 --> 00:18:41,830
And we just said the connect barometers.

258
00:18:42,220 --> 00:18:44,470
And we connect the neighbors to these stones.

259
00:18:44,920 --> 00:18:46,960
And then we increment the tone counter.

260
00:18:47,230 --> 00:18:51,480
So basically, we now know that how many stones that we have in our particular mix.

261
00:18:52,400 --> 00:18:54,530
And then we do the same for the three junction.

262
00:18:56,980 --> 00:19:03,160
The same exact same thing that is adding that note the vertex saying that that is the tree junction

263
00:19:03,880 --> 00:19:08,680
connecting it to its neighbors after resetting the connection perimeters, updating the junctions,

264
00:19:09,160 --> 00:19:12,730
three junction that we have found, and the same for the four junction.

265
00:19:15,430 --> 00:19:20,440
And then finally printing the tones, the three junctions and the full junction that we have found in

266
00:19:20,440 --> 00:19:21,040
our growth.

267
00:19:21,490 --> 00:19:28,270
So this completes our whole mapping process, and now we can simply test this out to see whether this

268
00:19:28,270 --> 00:19:31,870
performs in the way that we wanted to build in.

269
00:19:32,230 --> 00:19:33,040
Thank you and bye.