toan / Robofork

1

using RoboforkApp.DataModel;

1

using RoboforkApp.DataModel;

2

using System;

2

using System;

3

using System.Collections.Generic;

3

using System.Collections.Generic;

4

using System.Linq;

4

using System.Linq;

5

using System.Windows;

5

using System.Windows;

6

using System.Windows.Controls;

6

using System.Windows.Controls;

7

using System.Windows.Documents;

7

using System.Windows.Documents;

8

using System.Windows.Input;

8

using System.Windows.Input;

9

using System.Windows.Markup;

9

using System.Windows.Markup;

10

using System.Windows.Media;

10

using System.Windows.Media;

11

using System.Windows.Shapes;

11

using System.Windows.Shapes;

12

using System.Xml;

12

using System.Xml;

13

14

namespace RoboforkApp

14

namespace RoboforkApp

15

{

15

{

16

public class DesignerCanvas : Canvas

16

public class DesignerCanvas : Canvas

17

{

17

{

18

const double RADIUS_NODE = 25d; //8d;

18

const double RADIUS_NODE = 25d; //8d;

19

const double RADIUS_CURVER_LINE = 130d;

19

const double RADIUS_CURVER_LINE = 130d;

20

const double DISTANCE_AUTO_NODES = 100d;

20

const double DISTANCE_AUTO_NODES = 100d;

21

const double DISTANCE_START_NODES = 30d;

21

const double DISTANCE_START_NODES = 30d;

22

const double DISTANCE_END_NODES = 30d;

22

const double DISTANCE_END_NODES = 30d;

23

const double DISTANCE_FREE_NODES = 40d;

23

const double DISTANCE_FREE_NODES = 40d;

24

const double STROKE_ROOT_LINE = 6d;

24

const double STROKE_ROOT_LINE = 6d;

25

const double STROKE_LINE = 4d;

25

const double STROKE_LINE = 4d;

26

const double STROKE_NODE = 1d;

26

const double STROKE_NODE = 1d;

27

const double DISTANCE_RATIO = 100;

27

const double DISTANCE_RATIO = 100;

28

29

const double UCNODE_SETLEFT = 17;

29

const double UCNODE_SETLEFT = 17;

30

const double UCNODE_SETTOP = 17;

30

const double UCNODE_SETTOP = 17;

31

const double UCNODE_WIDTH = 34;

31

const double UCNODE_WIDTH = 34;

32

const double UCNODE_HEIGHT = 34;

32

const double UCNODE_HEIGHT = 34;

33

34

private List<Rectangle> shapeList = new List<Rectangle>();

34

private List<Rectangle> shapeList = new List<Rectangle>();

35

private TextBlock shapePosIndicator;

35

private TextBlock shapePosIndicator;

36

private TextBlock shapeSizeIndicator;

36

private TextBlock shapeSizeIndicator;

37

private int currentLine;

37

private int currentLine;

38

private ucStartEndButton _startPoint;

38

private ucStartEndButton _startPoint;

39

private ucNode _ucNodeFree;

39

private ucNode _ucNodeFree;

40

private ucStartEndButton _goalPoint;

40

private ucStartEndButton _goalPoint;

41

private ucDisplayCoordinate _displayAxiPosition;

41

private ucDisplayCoordinate _displayAxiPosition;

42

43

// Add variable for draw route

43

// Add variable for draw route

44

public Path pLine = new Path();

44

public Path pLine = new Path();

45

public Path pRootLine = new Path();

45

public Path pRootLine = new Path();

46

public Path pCurverLine = new Path();

46

public Path pCurverLine = new Path();

47

public Path pRedNode = new Path();

47

public Path pRedNode = new Path();

48

public Path pYellowNode = new Path();

48

public Path pYellowNode = new Path();

49

public GeometryGroup gGrpLine = new GeometryGroup();

49

public GeometryGroup gGrpLine = new GeometryGroup();

50

public GeometryGroup gGrpRootLine = new GeometryGroup();

50

public GeometryGroup gGrpRootLine = new GeometryGroup();

51

public GeometryGroup gGrpCurverLine = new GeometryGroup();

51

public GeometryGroup gGrpCurverLine = new GeometryGroup();

52

public GeometryGroup gGrpRedNode = new GeometryGroup();

52

public GeometryGroup gGrpRedNode = new GeometryGroup();

53

public GeometryGroup gGrpYellowNode = new GeometryGroup();

53

public GeometryGroup gGrpYellowNode = new GeometryGroup();

54

public int currentShape;

54

public int currentShape;

55

public static bool isStartDrawRoute = false;

55

public static bool isStartDrawRoute = false;

56

public static bool isGoalDrawRoute = false;

56

public static bool isGoalDrawRoute = false;

57

58

public struct NodeInfo

58

public struct NodeInfo

59

{

59

{

60

public double X;

60

public double X;

61

public double Y;

61

public double Y;

62

public String Mode1;

62

public String Mode1;

63

public String Mode2;

63

public String Mode2;

64

public String Mode3;

64

public String Mode3;

65

}

65

}

66

List<NodeInfo> NodeInfo_List = new List<NodeInfo>();

66

List<NodeInfo> NodeInfo_List = new List<NodeInfo>();

67

68

// Add variable for Set Schedule

68

// Add variable for Set Schedule

69

public Path pScheduleNode = new Path();

69

public Path pScheduleNode = new Path();

70

public Path pScheduleLine = new Path();

70

public Path pScheduleLine = new Path();

71

public GeometryGroup gGrpScheduleNode = new GeometryGroup();

71

public GeometryGroup gGrpScheduleNode = new GeometryGroup();

72

public GeometryGroup gGrpScheduleLine = new GeometryGroup();

72

public GeometryGroup gGrpScheduleLine = new GeometryGroup();

73

74

public static bool EditNodeFlag = false;

74

public static bool EditNodeFlag = false;

75

public static bool DragDeltaFlag = false;

75

public static bool DragDeltaFlag = false;

76

77

//Add variable for Vehicle Item click

77

//Add variable for Vehicle Item click

78

public string VehicleItem = "FK_15";

78

public string VehicleItem = "FK_15";

79

VehicleModel VehicleModel = new VehicleModel();

79

public VehicleModel VehicleModel = new VehicleModel();

80

public int VehicleIndex = 0;

80

public int VehicleIndex = 0;

81

public string ColorNode_Add = "Blue";

81

public string ColorNode_Add = "Blue";

82

public string ColorNode_Insert = "Brown";

82

public string ColorNode_Insert = "Brown";

83

84

//2017/03/04 NAM ADD START

84

//2017/03/04 NAM ADD START

85

public static bool isDrawingNode = false;

85

public static bool isDrawingNode = false;

86

public static bool isDragNode = false;

86

public static bool isDragNode = false;

87

public Path pNewLine = new Path();

87

public Path pNewLine = new Path();

88

public GeometryGroup gGrpNewLine = new GeometryGroup();

88

public GeometryGroup gGrpNewLine = new GeometryGroup();

89

90

public struct NewNodeInfo

90

public struct NewNodeInfo

91

{

91

{

92

public double X;

92

public double X;

93

public double Y;

93

public double Y;

94

public String Mode;

94

public String Mode;

95

}

95

}

96

List<NewNodeInfo> NewNodeInfo_List = new List<NewNodeInfo>();

96

List<NewNodeInfo> NewNodeInfo_List = new List<NewNodeInfo>();

97

98

//List Node's Info

98

//List Node's Info

99

List<Node_tmp> Lst_Node_tmp = new List<Node_tmp>();

99

List<Node_tmp> Lst_Node_tmp = new List<Node_tmp>();

100

101

102

103

104

List<TextBlock> NodeNo = new List<TextBlock>();

104

List<TextBlock> NodeNo = new List<TextBlock>();

105

List<ucNode> ucNode_Lst = new List<ucNode>();

105

List<ucNode> ucNode_Lst = new List<ucNode>();

106

public List<ucNode> ucScheduleNode_Lst = new List<ucNode>();

106

public List<ucNode> ucScheduleNode_Lst = new List<ucNode>();

107

int stt = 1;

107

int stt = 1;

108

//2017/03/04 NAM ADD END

108

//2017/03/04 NAM ADD END

109

public struct ListIndexNodeInsert

109

public struct ListIndexNodeInsert

110

{

110

{

111

public double X;

111

public double X;

112

public double Y;

112

public double Y;

113

}

113

}

114

List<ListIndexNodeInsert> IndexNodeInsert_List = new List<ListIndexNodeInsert>();

114

List<ListIndexNodeInsert> IndexNodeInsert_List = new List<ListIndexNodeInsert>();

115

116

117

public ScheduleCanvas scheduleCanvas;

117

public ScheduleCanvas scheduleCanvas;

118

119

// Add variable for Set Auto Nodes

119

// Add variable for Set Auto Nodes

120

public Path pBlueNode = new Path();

120

public Path pBlueNode = new Path();

121

private GeometryGroup gGrpBlueNode = new GeometryGroup();

121

private GeometryGroup gGrpBlueNode = new GeometryGroup();

122

123

// Add variable for Set Free Nodes

123

// Add variable for Set Free Nodes

124

public Path pFreeNode = new Path();

124

public Path pFreeNode = new Path();

125

//private GeometryGroup gGrpFreeNode = new GeometryGroup();

125

//private GeometryGroup gGrpFreeNode = new GeometryGroup();

126

127

// The part of the rectangle the mouse is over.

127

// The part of the rectangle the mouse is over.

128

private enum HitType

128

private enum HitType

129

{

129

{

130

None, Body, UL, UR, LR, LL, L, R, T, B

130

None, Body, UL, UR, LR, LL, L, R, T, B

131

};

131

};

132

public enum OperationState

132

public enum OperationState

133

{

133

{

134

None, DrawObstract, DrawRoute, DrawSetFreeNode, EditNode, NewDrawSetFreeNode

134

None, DrawObstract, DrawRoute, DrawSetFreeNode, EditNode, NewDrawSetFreeNode

135

};

135

};

136

public enum MouseState

136

public enum MouseState

137

{

137

{

138

None, Draw, Drag,

138

None, Draw, Drag,

139

}

139

}

140

public OperationState Operation = OperationState.None;

140

public OperationState Operation = OperationState.None;

141

public MouseState mouseState = MouseState.None;

141

public MouseState mouseState = MouseState.None;

142

143

// The draw start point.

143

// The draw start point.

144

private Point StartDrawPoint;

144

private Point StartDrawPoint;

145

146

// The drag's last point.

146

// The drag's last point.

147

private Point LastPoint;

147

private Point LastPoint;

148

149

// The part of the rectangle under the mouse.

149

// The part of the rectangle under the mouse.

150

HitType MouseHitType = HitType.None;

150

HitType MouseHitType = HitType.None;

151

152

public void Init()

152

public void Init()

153

{

153

{

154

if (shapePosIndicator == null)

154

if (shapePosIndicator == null)

155

{

155

{

156

shapePosIndicator = new TextBlock()

156

shapePosIndicator = new TextBlock()

157

{

157

{

158

Foreground = Brushes.Black,

158

Foreground = Brushes.Black,

159

Background = Brushes.Transparent,

159

Background = Brushes.Transparent,

160

FontSize = 20,

160

FontSize = 20,

161

};

161

};

162

}

162

}

163

if (shapeSizeIndicator == null)

163

if (shapeSizeIndicator == null)

164

{

164

{

165

shapeSizeIndicator = new TextBlock()

165

shapeSizeIndicator = new TextBlock()

166

{

166

{

167

Foreground = Brushes.Black,

167

Foreground = Brushes.Black,

168

Background = Brushes.Transparent,

168

Background = Brushes.Transparent,

169

FontSize = 20,

169

FontSize = 20,

170

};

170

};

171

}

171

}

172

}

172

}

173

174

// Return a HitType value to indicate what is at the point.

174

// Return a HitType value to indicate what is at the point.

175

private HitType SetHitType(Point point)

175

private HitType SetHitType(Point point)

176

{

176

{

177

if (shapeList.Count == 0)

177

if (shapeList.Count == 0)

178

{

178

{

179

currentShape = 0;

179

currentShape = 0;

180

return HitType.None;

180

return HitType.None;

181

}

181

}

182

for (int i = 0; i < shapeList.Count; i++)

182

for (int i = 0; i < shapeList.Count; i++)

183

{

183

{

184

Rectangle rect = shapeList[i];

184

Rectangle rect = shapeList[i];

185

double left = Canvas.GetLeft(rect);

185

double left = Canvas.GetLeft(rect);

186

double top = Canvas.GetTop(rect);

186

double top = Canvas.GetTop(rect);

187

double right = left + rect.Width;

187

double right = left + rect.Width;

188

double bottom = top + rect.Height;

188

double bottom = top + rect.Height;

189

if (point.X < left) continue;

189

if (point.X < left) continue;

190

if (point.X > right) continue;

190

if (point.X > right) continue;

191

if (point.Y < top) continue;

191

if (point.Y < top) continue;

192

if (point.Y > bottom) continue;

192

if (point.Y > bottom) continue;

193

currentShape = i;

193

currentShape = i;

194

195

const double GAP = 10;

195

const double GAP = 10;

196

if (point.X - left < GAP)

196

if (point.X - left < GAP)

197

{

197

{

198

// Left edge.

198

// Left edge.

199

if (point.Y - top < GAP) return HitType.UL;

199

if (point.Y - top < GAP) return HitType.UL;

200

if (bottom - point.Y < GAP) return HitType.LL;

200

if (bottom - point.Y < GAP) return HitType.LL;

201

return HitType.L;

201

return HitType.L;

202

}

202

}

203

if (right - point.X < GAP)

203

if (right - point.X < GAP)

204

{

204

{

205

// Right edge.

205

// Right edge.

206

if (point.Y - top < GAP) return HitType.UR;

206

if (point.Y - top < GAP) return HitType.UR;

207

if (bottom - point.Y < GAP) return HitType.LR;

207

if (bottom - point.Y < GAP) return HitType.LR;

208

return HitType.R;

208

return HitType.R;

209

}

209

}

210

if (point.Y - top < GAP) return HitType.T;

210

if (point.Y - top < GAP) return HitType.T;

211

if (bottom - point.Y < GAP) return HitType.B;

211

if (bottom - point.Y < GAP) return HitType.B;

212

return HitType.Body;

212

return HitType.Body;

213

}

213

}

214

currentShape = 0;

214

currentShape = 0;

215

return HitType.None;

215

return HitType.None;

216

}

216

}

217

218

// Set a mouse cursor appropriate for the current hit type.

218

// Set a mouse cursor appropriate for the current hit type.

219

private void SetMouseCursor()

219

private void SetMouseCursor()

220

{

220

{

221

// See what cursor we should display.

221

// See what cursor we should display.

222

Cursor desired_cursor = Cursors.Arrow;

222

Cursor desired_cursor = Cursors.Arrow;

223

switch (MouseHitType)

223

switch (MouseHitType)

224

{

224

{

225

case HitType.None:

225

case HitType.None:

226

desired_cursor = Cursors.Arrow;

226

desired_cursor = Cursors.Arrow;

227

break;

227

break;

228

case HitType.Body:

228

case HitType.Body:

229

desired_cursor = Cursors.ScrollAll;

229

desired_cursor = Cursors.ScrollAll;

230

break;

230

break;

231

case HitType.UL:

231

case HitType.UL:

232

case HitType.LR:

232

case HitType.LR:

233

desired_cursor = Cursors.SizeNWSE;

233

desired_cursor = Cursors.SizeNWSE;

234

break;

234

break;

235

case HitType.LL:

235

case HitType.LL:

236

case HitType.UR:

236

case HitType.UR:

237

desired_cursor = Cursors.SizeNESW;

237

desired_cursor = Cursors.SizeNESW;

238

break;

238

break;

239

case HitType.T:

239

case HitType.T:

240

case HitType.B:

240

case HitType.B:

241

desired_cursor = Cursors.SizeNS;

241

desired_cursor = Cursors.SizeNS;

242

break;

242

break;

243

case HitType.L:

243

case HitType.L:

244

case HitType.R:

244

case HitType.R:

245

desired_cursor = Cursors.SizeWE;

245

desired_cursor = Cursors.SizeWE;

246

break;

246

break;

247

}

247

}

248

249

// Display the desired cursor.

249

// Display the desired cursor.

250

if (Cursor != desired_cursor) Cursor = desired_cursor;

250

if (Cursor != desired_cursor) Cursor = desired_cursor;

251

}

251

}

252

253

// constance

253

// constance

254

int indicatorAligment = 2;

254

int indicatorAligment = 2;

255

256

/*

256

/*

257

private Point? dragStartPoint = null;

257

private Point? dragStartPoint = null;

258

259

*/

259

*/

260

public IEnumerable<DesignerItem> SelectedItems

260

public IEnumerable<DesignerItem> SelectedItems

261

{

261

{

262

get

262

get

263

{

263

{

264

var selectedItems = from item in this.Children.OfType<DesignerItem>()

264

var selectedItems = from item in this.Children.OfType<DesignerItem>()

265

where item.IsSelected == true

265

where item.IsSelected == true

266

select item;

266

select item;

267

268

return selectedItems;

268

return selectedItems;

269

}

269

}

270

}

270

}

271

272

public void DeselectAll()

272

public void DeselectAll()

273

{

273

{

274

/*

274

/*

275

foreach (DesignerItem item in this.SelectedItems)

275

foreach (DesignerItem item in this.SelectedItems)

276

{

276

{

277

item.IsSelected = false;

277

item.IsSelected = false;

278

}*/

278

}*/

279

}

279

}

280

281

protected override void OnMouseDown(MouseButtonEventArgs e)

281

protected override void OnMouseDown(MouseButtonEventArgs e)

282

{

282

{

283

base.OnMouseDown(e);

283

base.OnMouseDown(e);

284

285

MouseHitType = SetHitType(Mouse.GetPosition(this));

285

MouseHitType = SetHitType(Mouse.GetPosition(this));

286

SetMouseCursor();

286

SetMouseCursor();

287

288

if (Operation == OperationState.DrawRoute && isStartDrawRoute)

288

if (Operation == OperationState.DrawRoute && isStartDrawRoute)

289

{

289

{

290

if (isGoalDrawRoute)

290

if (isGoalDrawRoute)

291

{

291

{

292

return;

292

return;

293

}

293

}

294

295

// Check state draw

295

// Check state draw

296

if (MouseHitType == HitType.None)

296

if (MouseHitType == HitType.None)

297

{

297

{

298

if (gGrpLine.Children.Count == 1)

298

if (gGrpLine.Children.Count == 1)

299

{

299

{

300

LineGeometry lineGeometry = (LineGeometry)gGrpLine.Children[0];

300

LineGeometry lineGeometry = (LineGeometry)gGrpLine.Children[0];

301

lineGeometry.EndPoint = LastPoint;

301

lineGeometry.EndPoint = LastPoint;

302

303

// Check end route

303

// Check end route

304

if (IsEndRoute(_goalPoint, lineGeometry))

304

if (IsEndRoute(_goalPoint, lineGeometry))

305

{

305

{

306

isGoalDrawRoute = true;

306

isGoalDrawRoute = true;

307

ProcessEndRoute();

307

ProcessEndRoute();

308

return;

308

return;

309

}

309

}

310

}

310

}

311

else if (IsCurverNode((LineGeometry)gGrpLine.Children[currentLine - 1]

311

else if (IsCurverNode((LineGeometry)gGrpLine.Children[currentLine - 1]

312

, (LineGeometry)gGrpLine.Children[currentLine]))

312

, (LineGeometry)gGrpLine.Children[currentLine]))

313

{

313

{

314

// Set end point to finish draw line

314

// Set end point to finish draw line

315

LineGeometry lineGeometry = (LineGeometry)gGrpLine.Children[currentLine];

315

LineGeometry lineGeometry = (LineGeometry)gGrpLine.Children[currentLine];

316

lineGeometry.EndPoint = LastPoint;

316

lineGeometry.EndPoint = LastPoint;

317

318

// Add node to curver postion

318

// Add node to curver postion

319

AddNode(lineGeometry.StartPoint, gGrpRedNode);

319

AddNode(lineGeometry.StartPoint, gGrpRedNode);

320

321

// Check end route

321

// Check end route

322

if (IsEndRoute(_goalPoint, lineGeometry))

322

if (IsEndRoute(_goalPoint, lineGeometry))

323

{

323

{

324

isGoalDrawRoute = true;

324

isGoalDrawRoute = true;

325

ProcessEndRoute();

325

ProcessEndRoute();

326

return;

326

return;

327

}

327

}

328

}

328

}

329

else

329

else

330

{

330

{

331

// Remove current line

331

// Remove current line

332

gGrpLine.Children.RemoveAt(currentLine);

332

gGrpLine.Children.RemoveAt(currentLine);

333

334

// Set end point to finish draw line

334

// Set end point to finish draw line

335

LineGeometry lineGeometry = (LineGeometry)gGrpLine.Children[currentLine - 1];

335

LineGeometry lineGeometry = (LineGeometry)gGrpLine.Children[currentLine - 1];

336

lineGeometry.EndPoint = LastPoint;

336

lineGeometry.EndPoint = LastPoint;

337

338

// Check end route

338

// Check end route

339

if (IsEndRoute(_goalPoint, lineGeometry))

339

if (IsEndRoute(_goalPoint, lineGeometry))

340

{

340

{

341

isGoalDrawRoute = true;

341

isGoalDrawRoute = true;

342

ProcessEndRoute();

342

ProcessEndRoute();

343

return;

343

return;

344

}

344

}

345

}

345

}

346

347

// Draw new line

347

// Draw new line

348

DrawLine(LastPoint, LastPoint, gGrpLine);

348

DrawLine(LastPoint, LastPoint, gGrpLine);

349

// Setting start point for new line

349

// Setting start point for new line

350

StartDrawPoint = LastPoint;

350

StartDrawPoint = LastPoint;

351

352

mouseState = MouseState.Draw;

352

mouseState = MouseState.Draw;

353

currentLine = gGrpLine.Children.Count - 1;

353

currentLine = gGrpLine.Children.Count - 1;

354

return;

354

return;

355

}

355

}

356

}

356

}

357

else if (Operation == OperationState.DrawSetFreeNode)

357

else if (Operation == OperationState.DrawSetFreeNode)

358

{

358

{

359

bool RightClick = false;

359

bool RightClick = false;

360

if (IsStopDrawRoute(e))

360

if (IsStopDrawRoute(e))

361

RightClick = true;

361

RightClick = true;

362

363

StartDrawPoint = e.MouseDevice.GetPosition(this);

363

StartDrawPoint = e.MouseDevice.GetPosition(this);

364

365

SetFreeNodes(StartDrawPoint, RightClick);

365

SetFreeNodes(StartDrawPoint, RightClick);

366

}

366

}

367

368

else if (Operation == OperationState.EditNode)

368

else if (Operation == OperationState.EditNode)

369

{

369

{

370

Point node_edited = e.MouseDevice.GetPosition(this);

370

Point node_edited = e.MouseDevice.GetPosition(this);

371

372

// start Edit Node Infor

372

// start Edit Node Infor

373

EditNode(node_edited);

373

EditNode(node_edited);

374

375

}

375

}

376

else if (Operation == OperationState.DrawObstract)

376

else if (Operation == OperationState.DrawObstract)

377

{

377

{

378

if (MouseHitType == HitType.None)

378

if (MouseHitType == HitType.None)

379

{

379

{

380

Rectangle shape = new Rectangle();

380

Rectangle shape = new Rectangle();

381

shape.Width = 1;

381

shape.Width = 1;

382

shape.Height = 1;

382

shape.Height = 1;

383

// Create a SolidColorBrush and use it to

383

// Create a SolidColorBrush and use it to

384

// paint the rectangle.

384

// paint the rectangle.

385

shape.Stroke = Brushes.Blue;

385

shape.Stroke = Brushes.Blue;

386

shape.StrokeThickness = 1;

386

shape.StrokeThickness = 1;

387

shape.Fill = new SolidColorBrush(Colors.LightCyan);

387

shape.Fill = new SolidColorBrush(Colors.LightCyan);

388

StartDrawPoint = e.MouseDevice.GetPosition(this);

388

StartDrawPoint = e.MouseDevice.GetPosition(this);

389

shape.SetValue(Canvas.LeftProperty, StartDrawPoint.X);

389

shape.SetValue(Canvas.LeftProperty, StartDrawPoint.X);

390

shape.SetValue(Canvas.TopProperty, StartDrawPoint.Y);

390

shape.SetValue(Canvas.TopProperty, StartDrawPoint.Y);

391

this.Children.Add(shape);

391

this.Children.Add(shape);

392

shapeList.Add(shape);

392

shapeList.Add(shape);

393

394

mouseState = MouseState.Draw;

394

mouseState = MouseState.Draw;

395

currentShape = shapeList.Count() - 1;

395

currentShape = shapeList.Count() - 1;

396

397

double shapeX = Canvas.GetLeft(shapeList[currentShape]);

397

double shapeX = Canvas.GetLeft(shapeList[currentShape]);

398

double shapeY = Canvas.GetTop(shapeList[currentShape]);

398

double shapeY = Canvas.GetTop(shapeList[currentShape]);

399

shapePosIndicator.Text = "(" + Math.Round(shapeX, 0) + "," + Math.Round(shapeY, 0) + ")";

399

shapePosIndicator.Text = "(" + Math.Round(shapeX, 0) + "," + Math.Round(shapeY, 0) + ")";

400

shapePosIndicator.SetValue(Canvas.LeftProperty, shapeX + indicatorAligment);

400

shapePosIndicator.SetValue(Canvas.LeftProperty, shapeX + indicatorAligment);

401

shapePosIndicator.SetValue(Canvas.TopProperty, shapeY + indicatorAligment);

401

shapePosIndicator.SetValue(Canvas.TopProperty, shapeY + indicatorAligment);

402

403

double width = (int)shapeList[currentShape].Width;

403

double width = (int)shapeList[currentShape].Width;

404

double height = (int)shapeList[currentShape].Height;

404

double height = (int)shapeList[currentShape].Height;

405

shapeSizeIndicator.Text = "(" + Math.Round(width, 0) + "," + Math.Round(height, 0) + ")";

405

shapeSizeIndicator.Text = "(" + Math.Round(width, 0) + "," + Math.Round(height, 0) + ")";

406

shapeSizeIndicator.SetValue(Canvas.LeftProperty, shapeX + indicatorAligment + width);

406

shapeSizeIndicator.SetValue(Canvas.LeftProperty, shapeX + indicatorAligment + width);

407

shapeSizeIndicator.SetValue(Canvas.TopProperty, shapeY + indicatorAligment + height);

407

shapeSizeIndicator.SetValue(Canvas.TopProperty, shapeY + indicatorAligment + height);

408

409

this.Children.Add(shapePosIndicator);

409

this.Children.Add(shapePosIndicator);

410

this.Children.Add(shapeSizeIndicator);

410

this.Children.Add(shapeSizeIndicator);

411

412

413

return;

413

return;

414

}

414

}

415

else

415

else

416

{

416

{

417

if (shapeList.Count() != 0)

417

if (shapeList.Count() != 0)

418

shapeList[currentShape].Fill = new SolidColorBrush(Colors.LightCyan);

418

shapeList[currentShape].Fill = new SolidColorBrush(Colors.LightCyan);

419

420

double shapeX = Canvas.GetLeft(shapeList[currentShape]);

420

double shapeX = Canvas.GetLeft(shapeList[currentShape]);

421

double shapeY = Canvas.GetTop(shapeList[currentShape]);

421

double shapeY = Canvas.GetTop(shapeList[currentShape]);

422

shapePosIndicator.Text = "(" + Math.Round(shapeX, 0) + "," + Math.Round(shapeY, 0) + ")";

422

shapePosIndicator.Text = "(" + Math.Round(shapeX, 0) + "," + Math.Round(shapeY, 0) + ")";

423

shapePosIndicator.SetValue(Canvas.LeftProperty, shapeX + indicatorAligment);

423

shapePosIndicator.SetValue(Canvas.LeftProperty, shapeX + indicatorAligment);

424

shapePosIndicator.SetValue(Canvas.TopProperty, shapeY + indicatorAligment);

424

shapePosIndicator.SetValue(Canvas.TopProperty, shapeY + indicatorAligment);

425

426

double width = (int)shapeList[currentShape].Width;

426

double width = (int)shapeList[currentShape].Width;

427

double height = (int)shapeList[currentShape].Height;

427

double height = (int)shapeList[currentShape].Height;

428

shapeSizeIndicator.Text = "(" + Math.Round(width, 0) + "," + Math.Round(height, 0) + ")";

428

shapeSizeIndicator.Text = "(" + Math.Round(width, 0) + "," + Math.Round(height, 0) + ")";

429

shapeSizeIndicator.SetValue(Canvas.LeftProperty, shapeX + indicatorAligment + width);

429

shapeSizeIndicator.SetValue(Canvas.LeftProperty, shapeX + indicatorAligment + width);

430

shapeSizeIndicator.SetValue(Canvas.TopProperty, shapeY + indicatorAligment + height);

430

shapeSizeIndicator.SetValue(Canvas.TopProperty, shapeY + indicatorAligment + height);

431

432

this.Children.Add(shapePosIndicator);

432

this.Children.Add(shapePosIndicator);

433

this.Children.Add(shapeSizeIndicator);

433

this.Children.Add(shapeSizeIndicator);

434

}

434

}

435

436

LastPoint = Mouse.GetPosition(this);

436

LastPoint = Mouse.GetPosition(this);

437

mouseState = MouseState.Drag;

437

mouseState = MouseState.Drag;

438

}

438

}

439

e.Handled = true;

439

e.Handled = true;

440

}

440

}

441

442

protected override void OnMouseMove(MouseEventArgs e)

442

protected override void OnMouseMove(MouseEventArgs e)

443

{

443

{

444

base.OnMouseMove(e);

444

base.OnMouseMove(e);

445

446

if (mouseState == MouseState.None)

446

if (mouseState == MouseState.None)

447

{

447

{

448

MouseHitType = SetHitType(Mouse.GetPosition(this));

448

MouseHitType = SetHitType(Mouse.GetPosition(this));

449

SetMouseCursor();

449

SetMouseCursor();

450

}

450

}

451

else if (Operation == OperationState.DrawRoute && isStartDrawRoute)

451

else if (Operation == OperationState.DrawRoute && isStartDrawRoute)

452

{

452

{

453

LineGeometry lineGeometry = (LineGeometry)gGrpLine.Children[currentLine];

453

LineGeometry lineGeometry = (LineGeometry)gGrpLine.Children[currentLine];

454

455

// See how much the mouse has moved.

455

// See how much the mouse has moved.

456

Point point = Mouse.GetPosition(this);

456

Point point = Mouse.GetPosition(this);

457

double offset_x = point.X - StartDrawPoint.X;

457

double offset_x = point.X - StartDrawPoint.X;

458

double offset_y = point.Y - StartDrawPoint.Y;

458

double offset_y = point.Y - StartDrawPoint.Y;

459

460

// Get the line's current position.

460

// Get the line's current position.

461

double new_x = lineGeometry.StartPoint.X;

461

double new_x = lineGeometry.StartPoint.X;

462

double new_y = lineGeometry.StartPoint.Y;

462

double new_y = lineGeometry.StartPoint.Y;

463

464

if (offset_x != 0 || offset_y != 0)

464

if (offset_x != 0 || offset_y != 0)

465

{

465

{

466

if (Math.Abs(offset_x) >= Math.Abs(offset_y))

466

if (Math.Abs(offset_x) >= Math.Abs(offset_y))

467

{

467

{

468

new_x = point.X;

468

new_x = point.X;

469

}

469

}

470

else

470

else

471

{

471

{

472

new_y = point.Y;

472

new_y = point.Y;

473

}

473

}

474

}

474

}

475

476

// Set end point of current line

476

// Set end point of current line

477

LastPoint = new Point(new_x, new_y);

477

LastPoint = new Point(new_x, new_y);

478

lineGeometry.EndPoint = LastPoint;

478

lineGeometry.EndPoint = LastPoint;

479

DisplayCoordinate(LastPoint);

479

DisplayCoordinate(LastPoint);

480

}

480

}

481

else if (Operation == OperationState.DrawObstract)

481

else if (Operation == OperationState.DrawObstract)

482

{

482

{

483

if (mouseState == MouseState.Drag)

483

if (mouseState == MouseState.Drag)

484

{

484

{

485

// See how much the mouse has moved.

485

// See how much the mouse has moved.

486

Point point = Mouse.GetPosition(this);

486

Point point = Mouse.GetPosition(this);

487

double offset_x = point.X - LastPoint.X;

487

double offset_x = point.X - LastPoint.X;

488

double offset_y = point.Y - LastPoint.Y;

488

double offset_y = point.Y - LastPoint.Y;

489

490

// Get the rectangle's current position.

490

// Get the rectangle's current position.

491

double new_x = Canvas.GetLeft(shapeList[currentShape]);

491

double new_x = Canvas.GetLeft(shapeList[currentShape]);

492

double new_y = Canvas.GetTop(shapeList[currentShape]);

492

double new_y = Canvas.GetTop(shapeList[currentShape]);

493

double new_width = shapeList[currentShape].Width;

493

double new_width = shapeList[currentShape].Width;

494

double new_height = shapeList[currentShape].Height;

494

double new_height = shapeList[currentShape].Height;

495

496

// Update the rectangle.

496

// Update the rectangle.

497

switch (MouseHitType)

497

switch (MouseHitType)

498

{

498

{

499

case HitType.Body:

499

case HitType.Body:

500

new_x += offset_x;

500

new_x += offset_x;

501

new_y += offset_y;

501

new_y += offset_y;

502

break;

502

break;

503

case HitType.UL:

503

case HitType.UL:

504

new_x += offset_x;

504

new_x += offset_x;

505

new_y += offset_y;

505

new_y += offset_y;

506

new_width -= offset_x;

506

new_width -= offset_x;

507

new_height -= offset_y;

507

new_height -= offset_y;

508

break;

508

break;

509

case HitType.UR:

509

case HitType.UR:

510

new_y += offset_y;

510

new_y += offset_y;

511

new_width += offset_x;

511

new_width += offset_x;

512

new_height -= offset_y;

512

new_height -= offset_y;

513

break;

513

break;

514

case HitType.LR:

514

case HitType.LR:

515

new_width += offset_x;

515

new_width += offset_x;

516

new_height += offset_y;

516

new_height += offset_y;

517

break;

517

break;

518

case HitType.LL:

518

case HitType.LL:

519

new_x += offset_x;

519

new_x += offset_x;

520

new_width -= offset_x;

520

new_width -= offset_x;

521

new_height += offset_y;

521

new_height += offset_y;

522

break;

522

break;

523

case HitType.L:

523

case HitType.L:

524

new_x += offset_x;

524

new_x += offset_x;

525

new_width -= offset_x;

525

new_width -= offset_x;

526

break;

526

break;

527

case HitType.R:

527

case HitType.R:

528

new_width += offset_x;

528

new_width += offset_x;

529

break;

529

break;

530

case HitType.B:

530

case HitType.B:

531

new_height += offset_y;

531

new_height += offset_y;

532

break;

532

break;

533

case HitType.T:

533

case HitType.T:

534

new_y += offset_y;

534

new_y += offset_y;

535

new_height -= offset_y;

535

new_height -= offset_y;

536

break;

536

break;

537

}

537

}

538

// Don't use negative width or height.

538

// Don't use negative width or height.

539

if ((new_width > 0) && (new_height > 0))

539

if ((new_width > 0) && (new_height > 0))

540

{

540

{

541

// Update the rectangle.

541

// Update the rectangle.

542

Canvas.SetLeft(shapeList[currentShape], new_x);

542

Canvas.SetLeft(shapeList[currentShape], new_x);

543

Canvas.SetTop(shapeList[currentShape], new_y);

543

Canvas.SetTop(shapeList[currentShape], new_y);

544

shapeList[currentShape].Width = new_width;

544

shapeList[currentShape].Width = new_width;

545

shapeList[currentShape].Height = new_height;

545

shapeList[currentShape].Height = new_height;

546

547

// Save the mouse's new location.

547

// Save the mouse's new location.

548

LastPoint = point;

548

LastPoint = point;

549

550

}

550

}

551

}

551

}

552

else if (mouseState == MouseState.Draw)

552

else if (mouseState == MouseState.Draw)

553

{

553

{

554

555

// See how much the mouse has moved.

555

// See how much the mouse has moved.

556

Point point = Mouse.GetPosition(this);

556

Point point = Mouse.GetPosition(this);

557

558

559

double offset_x = point.X - StartDrawPoint.X;

559

double offset_x = point.X - StartDrawPoint.X;

560

double offset_y = point.Y - StartDrawPoint.Y;

560

double offset_y = point.Y - StartDrawPoint.Y;

561

562

// Get the rectangle's current position.

562

// Get the rectangle's current position.

563

double start_x = Canvas.GetLeft(shapeList[currentShape]);

563

double start_x = Canvas.GetLeft(shapeList[currentShape]);

564

double start_y = Canvas.GetTop(shapeList[currentShape]);

564

double start_y = Canvas.GetTop(shapeList[currentShape]);

565

double new_x = Canvas.GetLeft(shapeList[currentShape]);

565

double new_x = Canvas.GetLeft(shapeList[currentShape]);

566

double new_y = Canvas.GetTop(shapeList[currentShape]);

566

double new_y = Canvas.GetTop(shapeList[currentShape]);

567

double new_width = offset_x;

567

double new_width = offset_x;

568

double new_height = offset_y;

568

double new_height = offset_y;

569

if (offset_x < 0)

569

if (offset_x < 0)

570

{

570

{

571

new_x = point.X;

571

new_x = point.X;

572

new_width = -offset_x;

572

new_width = -offset_x;

573

}

573

}

574

if (offset_y < 0)

574

if (offset_y < 0)

575

{

575

{

576

new_y = point.Y;

576

new_y = point.Y;

577

new_height = -offset_y;

577

new_height = -offset_y;

578

}

578

}

579

Canvas.SetLeft(shapeList[currentShape], new_x);

579

Canvas.SetLeft(shapeList[currentShape], new_x);

580

Canvas.SetTop(shapeList[currentShape], new_y);

580

Canvas.SetTop(shapeList[currentShape], new_y);

581

shapeList[currentShape].Width = new_width;

581

shapeList[currentShape].Width = new_width;

582

shapeList[currentShape].Height = new_height;

582

shapeList[currentShape].Height = new_height;

583

584

}

584

}

585

586

double shapeX = Canvas.GetLeft(shapeList[currentShape]);

586

double shapeX = Canvas.GetLeft(shapeList[currentShape]);

587

double shapeY = Canvas.GetTop(shapeList[currentShape]);

587

double shapeY = Canvas.GetTop(shapeList[currentShape]);

588

shapePosIndicator.Text = "(" + Math.Round(shapeX, 0) + "," + Math.Round(shapeY, 0) + ")";

588

shapePosIndicator.Text = "(" + Math.Round(shapeX, 0) + "," + Math.Round(shapeY, 0) + ")";

589

shapePosIndicator.SetValue(Canvas.LeftProperty, shapeX + indicatorAligment);

589

shapePosIndicator.SetValue(Canvas.LeftProperty, shapeX + indicatorAligment);

590

shapePosIndicator.SetValue(Canvas.TopProperty, shapeY + indicatorAligment);

590

shapePosIndicator.SetValue(Canvas.TopProperty, shapeY + indicatorAligment);

591

592

double width = (int)shapeList[currentShape].Width;

592

double width = (int)shapeList[currentShape].Width;

593

double height = (int)shapeList[currentShape].Height;

593

double height = (int)shapeList[currentShape].Height;

594

shapeSizeIndicator.Text = "(" + Math.Round(width, 0) + "," + Math.Round(height, 0) + ")";

594

shapeSizeIndicator.Text = "(" + Math.Round(width, 0) + "," + Math.Round(height, 0) + ")";

595

shapeSizeIndicator.SetValue(Canvas.LeftProperty, shapeX + indicatorAligment + width);

595

shapeSizeIndicator.SetValue(Canvas.LeftProperty, shapeX + indicatorAligment + width);

596

shapeSizeIndicator.SetValue(Canvas.TopProperty, shapeY + indicatorAligment + height);

596

shapeSizeIndicator.SetValue(Canvas.TopProperty, shapeY + indicatorAligment + height);

597

}

597

}

598

e.Handled = true;

598

e.Handled = true;

599

}

599

}

600

601

protected override void OnMouseUp(MouseButtonEventArgs e)

601

protected override void OnMouseUp(MouseButtonEventArgs e)

602

{

602

{

603

base.OnMouseUp(e);

603

base.OnMouseUp(e);

604

if (Operation == OperationState.DrawObstract)

604

if (Operation == OperationState.DrawObstract)

605

{

605

{

606

if (shapeList.Count() != 0)

606

if (shapeList.Count() != 0)

607

shapeList[currentShape].Fill = new SolidColorBrush(Colors.Blue);

607

shapeList[currentShape].Fill = new SolidColorBrush(Colors.Blue);

608

shapePosIndicator.Text = "";

608

shapePosIndicator.Text = "";

609

shapeSizeIndicator.Text = "";

609

shapeSizeIndicator.Text = "";

610

this.Children.Remove(shapePosIndicator);

610

this.Children.Remove(shapePosIndicator);

611

this.Children.Remove(shapeSizeIndicator);

611

this.Children.Remove(shapeSizeIndicator);

612

613

mouseState = MouseState.None;

613

mouseState = MouseState.None;

614

currentShape = 0;

614

currentShape = 0;

615

}

615

}

616

e.Handled = true;

616

e.Handled = true;

617

}

617

}

618

619

protected override void OnPreviewMouseUp(MouseButtonEventArgs e)

619

protected override void OnPreviewMouseUp(MouseButtonEventArgs e)

620

{

620

{

621

base.OnPreviewMouseUp(e);

621

base.OnPreviewMouseUp(e);

622

623

EllipseGeometry ellipseGeometry;

623

EllipseGeometry ellipseGeometry;

624

bool flag = false;

624

bool flag = false;

625

626

StartDrawPoint = e.MouseDevice.GetPosition(this);

626

StartDrawPoint = e.MouseDevice.GetPosition(this);

627

628

if (EditNodeFlag == true)

628

if (EditNodeFlag == true)

629

{

629

{

630

execEditNode(StartDrawPoint);

630

execEditNode(StartDrawPoint);

631

EditNodeFlag = false;

631

EditNodeFlag = false;

632

return;

632

return;

633

}

633

}

634

635

if (DragDeltaFlag == true)

635

if (DragDeltaFlag == true)

636

{

636

{

637

for (int i = 0; i < gGrpBlueNode.Children.Count; i++)

637

for (int i = 0; i < gGrpBlueNode.Children.Count; i++)

638

{

638

{

639

640

for (int j = 0; j < ucNode_Lst.Count; j++)

640

for (int j = 0; j < ucNode_Lst.Count; j++)

641

{

641

{

642

if (j == i)

642

if (j == i)

643

{

643

{

644

_ucNodeFree = ucNode_Lst[j];

644

_ucNodeFree = ucNode_Lst[j];

645

flag = true;

645

flag = true;

646

}

646

}

647

}

647

}

648

if (flag)

648

if (flag)

649

{

649

{

650

if (gGrpNewLine.Children.Count > 0)

650

if (gGrpNewLine.Children.Count > 0)

651

{

651

{

652

for (int k = 0; k < gGrpNewLine.Children.Count; k++)

652

for (int k = 0; k < gGrpNewLine.Children.Count; k++)

653

{

653

{

654

LineGeometry lineGeometry = (LineGeometry)gGrpNewLine.Children[k];

654

LineGeometry lineGeometry = (LineGeometry)gGrpNewLine.Children[k];

655

Point p1 = lineGeometry.StartPoint;

655

Point p1 = lineGeometry.StartPoint;

656

Point p2 = lineGeometry.EndPoint;

656

Point p2 = lineGeometry.EndPoint;

657

658

//bool pInL = PointInLine(StartDrawPoint, p1, p2, 25);

658

//bool pInL = PointInLine(StartDrawPoint, p1, p2, 25);

659

660

//if (pInL)

660

//if (pInL)

661

//{

661

//{

662

663

// //this.Children.Remove(_ucNodeFree);

663

// //this.Children.Remove(_ucNodeFree);

664

// //this.Children.Add(_ucNodeFree);

664

// //this.Children.Add(_ucNodeFree);

665

// return;

665

// return;

666

//}

666

//}

667

}

667

}

668

}

668

}

669

670

ellipseGeometry = (EllipseGeometry)gGrpBlueNode.Children[i];

670

ellipseGeometry = (EllipseGeometry)gGrpBlueNode.Children[i];

671

672

ellipseGeometry.Center = new Point(StartDrawPoint.X, StartDrawPoint.Y);

672

ellipseGeometry.Center = new Point(StartDrawPoint.X, StartDrawPoint.Y);

673

674

double centerY = Canvas.GetTop(_ucNodeFree);

674

double centerY = Canvas.GetTop(_ucNodeFree);

675

double centerX = Canvas.GetLeft(_ucNodeFree);

675

double centerX = Canvas.GetLeft(_ucNodeFree);

676

677

mouseState = MouseState.Draw;

677

mouseState = MouseState.Draw;

678

679

680

StartDrawPoint = new Point(centerX + UCNODE_SETLEFT, centerY + UCNODE_SETTOP);

680

StartDrawPoint = new Point(centerX + UCNODE_SETLEFT, centerY + UCNODE_SETTOP);

681

ellipseGeometry.Center = new Point(centerX + UCNODE_SETLEFT, centerY + UCNODE_SETTOP);

681

ellipseGeometry.Center = new Point(centerX + UCNODE_SETLEFT, centerY + UCNODE_SETTOP);

682

683

this.Children.Remove(_ucNodeFree);

683

this.Children.Remove(_ucNodeFree);

684

this.Children.Add(_ucNodeFree);

684

this.Children.Add(_ucNodeFree);

685

}

685

}

686

}

686

}

687

688

ReDrawAllNode();

688

ReDrawAllNode();

689

690

SetScheduleRoute();

690

SetScheduleRoute();

691

DragDeltaFlag = false;

691

DragDeltaFlag = false;

692

}

692

}

693

694

695

696

return;

696

return;

697

}

697

}

698

699

/// <summary>

699

/// <summary>

700

/// On Preview Mouse Down

700

/// On Preview Mouse Down

701

/// </summary>

701

/// </summary>

702

/// <param name="e"></param>

702

/// <param name="e"></param>

703

protected override void OnPreviewMouseDown(MouseButtonEventArgs e)

703

protected override void OnPreviewMouseDown(MouseButtonEventArgs e)

704

{

704

{

705

base.OnPreviewMouseDown(e);

705

base.OnPreviewMouseDown(e);

706

if (Operation != OperationState.NewDrawSetFreeNode)

706

if (Operation != OperationState.NewDrawSetFreeNode)

707

{

707

{

708

return;

708

return;

709

}

709

}

710

711

Point currentPoint = e.MouseDevice.GetPosition(this);

711

Point currentPoint = e.MouseDevice.GetPosition(this);

712

713

if (isDrawingNode == false)

713

if (isDrawingNode == false)

714

{

714

{

715

716

isDrawingNode = true;

716

isDrawingNode = true;

717

InitDrawRoute();

717

InitDrawRoute();

718

mouseState = MouseState.Draw;

718

mouseState = MouseState.Draw;

719

720

StartDrawPoint = e.MouseDevice.GetPosition(this);

720

StartDrawPoint = e.MouseDevice.GetPosition(this);

721

722

723

execCreateNode(StartDrawPoint);

723

execCreateNode(StartDrawPoint);

724

725

//backup DB

725

//backup DB

726

CreateVehicleNode();

726

CreateVehicleNode();

727

728

return;

728

return;

729

}

729

}

730

else

730

else

731

{

731

{

732

733

bool RightClick = false;

733

bool RightClick = false;

734

bool LeftClick = false;

734

bool LeftClick = false;

735

736

737

if (IsMouseLeftClick(e))

737

if (IsMouseLeftClick(e))

738

LeftClick = true;

738

LeftClick = true;

739

if (IsStopDrawRoute(e))

739

if (IsStopDrawRoute(e))

740

RightClick = true;

740

RightClick = true;

741

742

StartDrawPoint = e.MouseDevice.GetPosition(this);

742

StartDrawPoint = e.MouseDevice.GetPosition(this);

743

744

if (RightClick)

744

if (RightClick)

745

{

745

{

746

execDeleteNode(StartDrawPoint);

746

execDeleteNode(StartDrawPoint);

747

748

//backup DB

748

//backup DB

749

CreateVehicleNode();

749

CreateVehicleNode();

750

}

750

}

751

else if (LeftClick)

751

else if (LeftClick)

752

{

752

{

753

//check click to exist node

753

//check click to exist node

754

for (int i = 0; i < gGrpBlueNode.Children.Count; i++)

754

for (int i = 0; i < gGrpBlueNode.Children.Count; i++)

755

{

755

{

756

EllipseGeometry ellipseGeometry = (EllipseGeometry)gGrpBlueNode.Children[i];

756

EllipseGeometry ellipseGeometry = (EllipseGeometry)gGrpBlueNode.Children[i];

757

Point node = ellipseGeometry.Center;

757

Point node = ellipseGeometry.Center;

758

bool isEditNode = CheckIsNode(StartDrawPoint, node, RADIUS_NODE);

758

bool isEditNode = CheckIsNode(StartDrawPoint, node, RADIUS_NODE);

759

760

if (isEditNode)

760

if (isEditNode)

761

{

761

{

762

return;

762

return;

763

}

763

}

764

}

764

}

765

766

execCreateNode(StartDrawPoint);

766

execCreateNode(StartDrawPoint);

767

768

//backup DB

768

//backup DB

769

CreateVehicleNode();

769

CreateVehicleNode();

770

}

770

}

771

772

}

772

}

773

}

773

}

774

775

#region Functions for draw route

775

#region Functions for draw route

776

777

/// <summary>

777

/// <summary>

778

/// Check start or end draw route

778

/// Check start or end draw route

779

/// </summary>

779

/// </summary>

780

/// <param name="_ucStartEndButton">Button start</param>

780

/// <param name="_ucStartEndButton">Button start</param>

781

/// <param name="currentPoint">Position for check</param>

781

/// <param name="currentPoint">Position for check</param>

782

/// <returns>true: start, false: not start</returns>

782

/// <returns>true: start, false: not start</returns>

783

private bool IsStartEndRoute(ucStartEndButton _ucStartEndButton, Point currentPoint)

783

private bool IsStartEndRoute(ucStartEndButton _ucStartEndButton, Point currentPoint)

784

{

784

{

785

if (_ucStartEndButton == null)

785

if (_ucStartEndButton == null)

786

{

786

{

787

return false;

787

return false;

788

}

788

}

789

790

double centerX = Canvas.GetLeft(_ucStartEndButton);

790

double centerX = Canvas.GetLeft(_ucStartEndButton);

791

double centerY = Canvas.GetTop(_ucStartEndButton);

791

double centerY = Canvas.GetTop(_ucStartEndButton);

792

793

if (currentPoint.X < centerX + 50 && currentPoint.X > centerX

793

if (currentPoint.X < centerX + 50 && currentPoint.X > centerX

794

&& currentPoint.Y < centerY + 50 && currentPoint.Y > centerY)

794

&& currentPoint.Y < centerY + 50 && currentPoint.Y > centerY)

795

{

795

{

796

return true;

796

return true;

797

}

797

}

798

return false;

798

return false;

799

}

799

}

800

801

/// <summary>

801

/// <summary>

802

/// Process when end draw route

802

/// Process when end draw route

803

/// </summary>

803

/// </summary>

804

private void ProcessEndRoute()

804

private void ProcessEndRoute()

805

{

805

{

806

Operation = OperationState.None;

806

Operation = OperationState.None;

807

AutoEditLine();

807

AutoEditLine();

808

this.Children.Remove(_displayAxiPosition);

808

this.Children.Remove(_displayAxiPosition);

809

this.Children.Remove(_goalPoint);

809

this.Children.Remove(_goalPoint);

810

this.Children.Add(_goalPoint);

810

this.Children.Add(_goalPoint);

811

}

811

}

812

813

/// <summary>

813

/// <summary>

814

/// Check end draw route

814

/// Check end draw route

815

/// </summary>

815

/// </summary>

816

/// <param name="_ucStartEndButton">Button end</param>

816

/// <param name="_ucStartEndButton">Button end</param>

817

/// <param name="currentPoint">Position for check</param>

817

/// <param name="currentPoint">Position for check</param>

818

/// <returns>true: end, false: not end</returns>

818

/// <returns>true: end, false: not end</returns>

819

private bool IsEndRoute(ucStartEndButton _ucStartEndButton, LineGeometry lineGeometry)

819

private bool IsEndRoute(ucStartEndButton _ucStartEndButton, LineGeometry lineGeometry)

820

{

820

{

821

if (_ucStartEndButton == null)

821

if (_ucStartEndButton == null)

822

{

822

{

823

return false;

823

return false;

824

}

824

}

825

826

double centerX = Canvas.GetLeft(_ucStartEndButton);

826

double centerX = Canvas.GetLeft(_ucStartEndButton);

827

double centerY = Canvas.GetTop(_ucStartEndButton);

827

double centerY = Canvas.GetTop(_ucStartEndButton);

828

Point startPoint = lineGeometry.StartPoint;

828

Point startPoint = lineGeometry.StartPoint;

829

Point endPoint = lineGeometry.EndPoint;

829

Point endPoint = lineGeometry.EndPoint;

830

831

if (IsVerticalLine(lineGeometry))

831

if (IsVerticalLine(lineGeometry))

832

{

832

{

833

if (endPoint.X < centerX || endPoint.X > centerX + 50)

833

if (endPoint.X < centerX || endPoint.X > centerX + 50)

834

return false;

834

return false;

835

836

if (startPoint.Y > centerY + 50 && endPoint.Y > centerY + 50)

836

if (startPoint.Y > centerY + 50 && endPoint.Y > centerY + 50)

837

return false;

837

return false;

838

839

if (startPoint.Y < centerY && endPoint.Y < centerY)

839

if (startPoint.Y < centerY && endPoint.Y < centerY)

840

return false;

840

return false;

841

}

841

}

842

else

842

else

843

{

843

{

844

if (endPoint.Y < centerY || endPoint.Y > centerY + 50)

844

if (endPoint.Y < centerY || endPoint.Y > centerY + 50)

845

return false;

845

return false;

846

847

if (startPoint.X > centerX + 50 && endPoint.X > centerX + 50)

847

if (startPoint.X > centerX + 50 && endPoint.X > centerX + 50)

848

return false;

848

return false;

849

850

if (startPoint.X < centerX && endPoint.X < centerX)

850

if (startPoint.X < centerX && endPoint.X < centerX)

851

return false;

851

return false;

852

}

852

}

853

854

return true;

854

return true;

855

}

855

}

856

857

/// <summary>

857

/// <summary>

858

/// Make root

858

/// Make root

859

/// </summary>

859

/// </summary>

860

public void MakeRoot()

860

public void MakeRoot()

861

{

861

{

862

// If still not route

862

// If still not route

863

if (gGrpLine.Children.Count == 0)

863

if (gGrpLine.Children.Count == 0)

864

return;

864

return;

865

866

pLine.Stroke = new SolidColorBrush(Colors.Red);

866

pLine.Stroke = new SolidColorBrush(Colors.Red);

867

pLine.StrokeThickness = STROKE_ROOT_LINE;

867

pLine.StrokeThickness = STROKE_ROOT_LINE;

868

869

}

869

}

870

871

/// <summary>

871

/// <summary>

872

/// Auto edit leght of line

872

/// Auto edit leght of line

873

/// </summary>

873

/// </summary>

874

private void AutoEditLine()

874

private void AutoEditLine()

875

{

875

{

876

double temp;

876

double temp;

877

int index = gGrpLine.Children.Count - 1;

877

int index = gGrpLine.Children.Count - 1;

878

double centerY = Canvas.GetTop(_goalPoint) + 25;

878

double centerY = Canvas.GetTop(_goalPoint) + 25;

879

double centerX = Canvas.GetLeft(_goalPoint) + 25;

879

double centerX = Canvas.GetLeft(_goalPoint) + 25;

880

LineGeometry lastLine = (LineGeometry)gGrpLine.Children[index];

880

LineGeometry lastLine = (LineGeometry)gGrpLine.Children[index];

881

LineGeometry beforeLastLine = (LineGeometry)gGrpLine.Children[index];

881

LineGeometry beforeLastLine = (LineGeometry)gGrpLine.Children[index];

882

883

if (gGrpLine.Children.Count > 1)

883

if (gGrpLine.Children.Count > 1)

884

{

884

{

885

beforeLastLine = (LineGeometry)gGrpLine.Children[index - 1];

885

beforeLastLine = (LineGeometry)gGrpLine.Children[index - 1];

886

887

if (!IsCurverNode(beforeLastLine, lastLine))

887

if (!IsCurverNode(beforeLastLine, lastLine))

888

{

888

{

889

beforeLastLine.EndPoint = lastLine.EndPoint;

889

beforeLastLine.EndPoint = lastLine.EndPoint;

890

gGrpLine.Children.RemoveAt(index);

890

gGrpLine.Children.RemoveAt(index);

891

index = index - 1;

891

index = index - 1;

892

lastLine = (LineGeometry)gGrpLine.Children[index];

892

lastLine = (LineGeometry)gGrpLine.Children[index];

893

}

893

}

894

}

894

}

895

896

if (index == gGrpRedNode.Children.Count + 1)

896

if (index == gGrpRedNode.Children.Count + 1)

897

{

897

{

898

AddNode(lastLine.StartPoint, gGrpRedNode);

898

AddNode(lastLine.StartPoint, gGrpRedNode);

899

}

899

}

900

901

if (lastLine.EndPoint.X == centerX && lastLine.EndPoint.Y == centerY)

901

if (lastLine.EndPoint.X == centerX && lastLine.EndPoint.Y == centerY)

902

return;

902

return;

903

904

if (IsVerticalLine(lastLine))

904

if (IsVerticalLine(lastLine))

905

{

905

{

906

temp = lastLine.StartPoint.Y;

906

temp = lastLine.StartPoint.Y;

907

lastLine.StartPoint = new Point(centerX, temp);

907

lastLine.StartPoint = new Point(centerX, temp);

908

lastLine.EndPoint = new Point(centerX, centerY);

908

lastLine.EndPoint = new Point(centerX, centerY);

909

910

if (gGrpLine.Children.Count > 1)

910

if (gGrpLine.Children.Count > 1)

911

{

911

{

912

beforeLastLine = (LineGeometry)gGrpLine.Children[index - 1];

912

beforeLastLine = (LineGeometry)gGrpLine.Children[index - 1];

913

temp = beforeLastLine.EndPoint.Y;

913

temp = beforeLastLine.EndPoint.Y;

914

beforeLastLine.EndPoint = new Point(centerX, temp);

914

beforeLastLine.EndPoint = new Point(centerX, temp);

915

}

915

}

916

}

916

}

917

else

917

else

918

{

918

{

919

temp = lastLine.StartPoint.X;

919

temp = lastLine.StartPoint.X;

920

lastLine.StartPoint = new Point(temp, centerY);

920

lastLine.StartPoint = new Point(temp, centerY);

921

lastLine.EndPoint = new Point(centerX, centerY);

921

lastLine.EndPoint = new Point(centerX, centerY);

922

if (gGrpLine.Children.Count > 1)

922

if (gGrpLine.Children.Count > 1)

923

{

923

{

924

beforeLastLine = (LineGeometry)gGrpLine.Children[index - 1];

924

beforeLastLine = (LineGeometry)gGrpLine.Children[index - 1];

925

temp = beforeLastLine.EndPoint.X;

925

temp = beforeLastLine.EndPoint.X;

926

beforeLastLine.EndPoint = new Point(temp, centerY);

926

beforeLastLine.EndPoint = new Point(temp, centerY);

927

}

927

}

928

}

928

}

929

930

// Draw curver line

930

// Draw curver line

931

if (IsCurverNode(beforeLastLine, lastLine))

931

if (IsCurverNode(beforeLastLine, lastLine))

932

{

932

{

933

EllipseGeometry ellipseGeometry = (EllipseGeometry)gGrpRedNode.Children[gGrpRedNode.Children.Count - 1];

933

EllipseGeometry ellipseGeometry = (EllipseGeometry)gGrpRedNode.Children[gGrpRedNode.Children.Count - 1];

934

ellipseGeometry.Center = lastLine.StartPoint;

934

ellipseGeometry.Center = lastLine.StartPoint;

935

}

935

}

936

}

936

}

937

938

/// <summary>

938

/// <summary>

939

/// Check draw curver node

939

/// Check draw curver node

940

/// </summary>

940

/// </summary>

941

/// <param name="oldLine">Old line</param>

941

/// <param name="oldLine">Old line</param>

942

/// <param name="newLine">New line</param>

942

/// <param name="newLine">New line</param>

943

/// <returns>true:is curver, fasle: not curver</returns>

943

/// <returns>true:is curver, fasle: not curver</returns>

944

private bool IsCurverNode(LineGeometry oldLine, LineGeometry newLine)

944

private bool IsCurverNode(LineGeometry oldLine, LineGeometry newLine)

945

{

945

{

946

if (oldLine.StartPoint.Y == oldLine.EndPoint.Y && oldLine.StartPoint.Y == newLine.EndPoint.Y)

946

if (oldLine.StartPoint.Y == oldLine.EndPoint.Y && oldLine.StartPoint.Y == newLine.EndPoint.Y)

947

{

947

{

948

return false;

948

return false;

949

}

949

}

950

951

if (oldLine.StartPoint.X == oldLine.EndPoint.X && oldLine.StartPoint.X == newLine.EndPoint.X)

951

if (oldLine.StartPoint.X == oldLine.EndPoint.X && oldLine.StartPoint.X == newLine.EndPoint.X)

952

{

952

{

953

return false;

953

return false;

954

}

954

}

955

956

return true;

956

return true;

957

}

957

}

958

959

/// <summary>

959

/// <summary>

960

/// Check timming to stop draw route

960

/// Check timming to stop draw route

961

/// </summary>

961

/// </summary>

962

/// <param name="e"></param>

962

/// <param name="e"></param>

963

/// <returns>true:stop; false:continue</returns>

963

/// <returns>true:stop; false:continue</returns>

964

private bool IsStopDrawRoute(MouseEventArgs e)

964

private bool IsStopDrawRoute(MouseEventArgs e)

965

{

965

{

966

if (e.RightButton == MouseButtonState.Pressed)

966

if (e.RightButton == MouseButtonState.Pressed)

967

{

967

{

968

return true;

968

return true;

969

}

969

}

970

971

return false;

971

return false;

972

}

972

}

973

974

//2017/03/05 NAM ADD START

974

//2017/03/05 NAM ADD START

975

private bool IsMouseLeftClick(MouseEventArgs e)

975

private bool IsMouseLeftClick(MouseEventArgs e)

976

{

976

{

977

if (e.LeftButton == MouseButtonState.Pressed)

977

if (e.LeftButton == MouseButtonState.Pressed)

978

{

978

{

979

return true;

979

return true;

980

}

980

}

981

982

return false;

982

return false;

983

}

983

}

984

//2017/03/05 NAM ADD END

984

//2017/03/05 NAM ADD END

985

986

/// <summary>

986

/// <summary>

987

/// Draw curver line and yellow node

987

/// Draw curver line and yellow node

988

/// </summary>

988

/// </summary>

989

/// <param name="oldLine">Old line</param>

989

/// <param name="oldLine">Old line</param>

990

/// <param name="newLine">New line</param>

990

/// <param name="newLine">New line</param>

991

private void DrawCurver(LineGeometry oldLine, LineGeometry newLine)

991

private void DrawCurver(LineGeometry oldLine, LineGeometry newLine)

992

{

992

{

993

double radius = RADIUS_CURVER_LINE;

993

double radius = RADIUS_CURVER_LINE;

994

995

Point startPoint;

995

Point startPoint;

996

Point endPoint;

996

Point endPoint;

997

998

// Get postion of yellow node on old line

998

// Get postion of yellow node on old line

999

if (IsVerticalLine(oldLine))

999

if (IsVerticalLine(oldLine))

1000

{

1000

{

1001

if (oldLine.StartPoint.Y > oldLine.EndPoint.Y)

1001

if (oldLine.StartPoint.Y > oldLine.EndPoint.Y)

1002

startPoint = new Point(oldLine.EndPoint.X, oldLine.EndPoint.Y + radius);

1002

startPoint = new Point(oldLine.EndPoint.X, oldLine.EndPoint.Y + radius);

1003

else

1003

else

1004

startPoint = new Point(oldLine.EndPoint.X, oldLine.EndPoint.Y - radius);

1004

startPoint = new Point(oldLine.EndPoint.X, oldLine.EndPoint.Y - radius);

1005

}

1005

}

1006

else

1006

else

1007

{

1007

{

1008

if (oldLine.StartPoint.X > oldLine.EndPoint.X)

1008

if (oldLine.StartPoint.X > oldLine.EndPoint.X)

1009

startPoint = new Point(oldLine.EndPoint.X + radius, oldLine.EndPoint.Y);

1009

startPoint = new Point(oldLine.EndPoint.X + radius, oldLine.EndPoint.Y);

1010

else

1010

else

1011

startPoint = new Point(oldLine.EndPoint.X - radius, oldLine.EndPoint.Y);

1011

startPoint = new Point(oldLine.EndPoint.X - radius, oldLine.EndPoint.Y);

1012

}

1012

}

1013

1014

// Get postion of yellow node on new line

1014

// Get postion of yellow node on new line

1015

if (IsVerticalLine(newLine))

1015

if (IsVerticalLine(newLine))

1016

{

1016

{

1017

if (newLine.StartPoint.Y > newLine.EndPoint.Y)

1017

if (newLine.StartPoint.Y > newLine.EndPoint.Y)

1018

endPoint = new Point(newLine.StartPoint.X, newLine.StartPoint.Y - radius);

1018

endPoint = new Point(newLine.StartPoint.X, newLine.StartPoint.Y - radius);

1019

else

1019

else

1020

endPoint = new Point(newLine.StartPoint.X, newLine.StartPoint.Y + radius);

1020

endPoint = new Point(newLine.StartPoint.X, newLine.StartPoint.Y + radius);

1021

}

1021

}

1022

else

1022

else

1023

{

1023

{

1024

if (newLine.StartPoint.X > newLine.EndPoint.X)

1024

if (newLine.StartPoint.X > newLine.EndPoint.X)

1025

endPoint = new Point(newLine.StartPoint.X - radius, newLine.StartPoint.Y);

1025

endPoint = new Point(newLine.StartPoint.X - radius, newLine.StartPoint.Y);

1026

else

1026

else

1027

endPoint = new Point(newLine.StartPoint.X + radius, newLine.StartPoint.Y);

1027

endPoint = new Point(newLine.StartPoint.X + radius, newLine.StartPoint.Y);

1028

}

1028

}

1029

1030

// Add node to postion distance 1300mm

1030

// Add node to postion distance 1300mm

1031

if (GetDistance(oldLine.StartPoint, oldLine.EndPoint) > RADIUS_CURVER_LINE)

1031

if (GetDistance(oldLine.StartPoint, oldLine.EndPoint) > RADIUS_CURVER_LINE)

1032

{

1032

{

1033

AddNode(startPoint, gGrpYellowNode);

1033

AddNode(startPoint, gGrpYellowNode);

1034

}

1034

}

1035

1036

if (GetDistance(newLine.StartPoint, newLine.EndPoint) > RADIUS_CURVER_LINE)

1036

if (GetDistance(newLine.StartPoint, newLine.EndPoint) > RADIUS_CURVER_LINE)

1037

{

1037

{

1038

AddNode(endPoint, gGrpYellowNode);

1038

AddNode(endPoint, gGrpYellowNode);

1039

}

1039

}

1040

}

1040

}

1041

1042

/// <summary>

1042

/// <summary>

1043

/// Init data for draw route

1043

/// Init data for draw route

1044

/// </summary>

1044

/// </summary>

1045

private void InitDrawRoute()

1045

private void InitDrawRoute()

1046

{

1046

{

1047

//2017/03/04 NAM ADD START

1047

//2017/03/04 NAM ADD START

1048

pNewLine.Stroke = new SolidColorBrush(Colors.Red);

1048

pNewLine.Stroke = new SolidColorBrush(Colors.Red);

1049

pNewLine.StrokeThickness = STROKE_LINE;

1049

pNewLine.StrokeThickness = STROKE_LINE;

1050

pNewLine.Data = gGrpNewLine;

1050

pNewLine.Data = gGrpNewLine;

1051

//2017/03/04 NAM ADD END

1051

//2017/03/04 NAM ADD END

1052

1053

pScheduleLine.Stroke = new SolidColorBrush(Colors.Red);

1053

pScheduleLine.Stroke = new SolidColorBrush(Colors.Red);

1054

pScheduleLine.StrokeThickness = STROKE_LINE;

1054

pScheduleLine.StrokeThickness = STROKE_LINE;

1055

pScheduleLine.Data = gGrpScheduleLine;

1055

pScheduleLine.Data = gGrpScheduleLine;

1056

1057

// Setting for path line

1057

// Setting for path line

1058

pLine.Stroke = new SolidColorBrush(Colors.Blue);

1058

pLine.Stroke = new SolidColorBrush(Colors.Blue);

1059

pLine.StrokeThickness = STROKE_LINE;

1059

pLine.StrokeThickness = STROKE_LINE;

1060

pLine.Data = gGrpLine;

1060

pLine.Data = gGrpLine;

1061

1062

// Setting for path of curver line

1062

// Setting for path of curver line

1063

pCurverLine.Stroke = Brushes.Red;

1063

pCurverLine.Stroke = Brushes.Red;

1064

pCurverLine.StrokeThickness = STROKE_LINE;

1064

pCurverLine.StrokeThickness = STROKE_LINE;

1065

pCurverLine.Data = gGrpCurverLine;

1065

pCurverLine.Data = gGrpCurverLine;

1066

1067

// Setting for path of red node

1067

// Setting for path of red node

1068

pRedNode.Stroke = new SolidColorBrush(Colors.Blue);

1068

pRedNode.Stroke = new SolidColorBrush(Colors.Blue);

1069

pRedNode.Fill = new SolidColorBrush(Colors.Red);

1069

pRedNode.Fill = new SolidColorBrush(Colors.Red);

1070

pRedNode.StrokeThickness = STROKE_NODE;

1070

pRedNode.StrokeThickness = STROKE_NODE;

1071

pRedNode.Data = gGrpRedNode;

1071

pRedNode.Data = gGrpRedNode;

1072

1073

// Setting for path of yellow node

1073

// Setting for path of yellow node

1074

pYellowNode.Stroke = new SolidColorBrush(Colors.Blue);

1074

pYellowNode.Stroke = new SolidColorBrush(Colors.Blue);

1075

pYellowNode.Fill = new SolidColorBrush(Colors.Yellow);

1075

pYellowNode.Fill = new SolidColorBrush(Colors.Yellow);

1076

pYellowNode.StrokeThickness = STROKE_NODE;

1076

pYellowNode.StrokeThickness = STROKE_NODE;

1077

pYellowNode.Data = gGrpYellowNode;

1077

pYellowNode.Data = gGrpYellowNode;

1078

1079

// Setting for path of Blue node

1079

// Setting for path of Blue node

1080

pBlueNode.Stroke = new SolidColorBrush(Colors.Blue);

1080

pBlueNode.Stroke = new SolidColorBrush(Colors.Blue);

1081

pBlueNode.Fill = new SolidColorBrush(Colors.LightBlue);

1081

pBlueNode.Fill = new SolidColorBrush(Colors.LightBlue);

1082

pBlueNode.StrokeThickness = STROKE_NODE;

1082

pBlueNode.StrokeThickness = STROKE_NODE;

1083

pBlueNode.Data = gGrpBlueNode;

1083

pBlueNode.Data = gGrpBlueNode;

1084

1085

// Add paths to canvas

1085

// Add paths to canvas

1086

this.Children.Add(pLine);

1086

this.Children.Add(pLine);

1087

this.Children.Add(pCurverLine);

1087

this.Children.Add(pCurverLine);

1088

this.Children.Add(pRedNode);

1088

this.Children.Add(pRedNode);

1089

this.Children.Add(pYellowNode);

1089

this.Children.Add(pYellowNode);

1090

1091

//this.Children.Add(pNewLine);

1091

//this.Children.Add(pNewLine);

1092

scheduleCanvas.Children.Add(pScheduleLine);

1092

scheduleCanvas.Children.Add(pScheduleLine);

1093

}

1093

}

1094

1095

/// <summary>

1095

/// <summary>

1096

/// Clear all route

1096

/// Clear all route

1097

/// </summary>

1097

/// </summary>

1098

public void ClearRoute()

1098

public void ClearRoute()

1099

{

1099

{

1100

isStartDrawRoute = false;

1100

isStartDrawRoute = false;

1101

isGoalDrawRoute = false;

1101

isGoalDrawRoute = false;

1102

1103

gGrpLine.Children.Clear();

1103

gGrpLine.Children.Clear();

1104

gGrpRootLine.Children.Clear();

1104

gGrpRootLine.Children.Clear();

1105

gGrpCurverLine.Children.Clear();

1105

gGrpCurverLine.Children.Clear();

1106

gGrpRedNode.Children.Clear();

1106

gGrpRedNode.Children.Clear();

1107

gGrpYellowNode.Children.Clear();

1107

gGrpYellowNode.Children.Clear();

1108

gGrpBlueNode.Children.Clear();

1108

gGrpBlueNode.Children.Clear();

1109

1110

this.Children.Remove(pLine);

1110

this.Children.Remove(pLine);

1111

this.Children.Remove(pRootLine);

1111

this.Children.Remove(pRootLine);

1112

this.Children.Remove(pCurverLine);

1112

this.Children.Remove(pCurverLine);

1113

this.Children.Remove(pRedNode);

1113

this.Children.Remove(pRedNode);

1114

this.Children.Remove(pYellowNode);

1114

this.Children.Remove(pYellowNode);

1115

this.Children.Remove(pBlueNode);

1115

this.Children.Remove(pBlueNode);

1116

}

1116

}

1117

1118

/// <summary>

1118

/// <summary>

1119

/// Draw line for route

1119

/// Draw line for route

1120

/// </summary>

1120

/// </summary>

1121

/// <param name="startPoint">Start point</param>

1121

/// <param name="startPoint">Start point</param>

1122

/// <param name="endPoint">End point</param>

1122

/// <param name="endPoint">End point</param>

1123

/// <param name="geometryGroup">Geometry Group</param>

1123

/// <param name="geometryGroup">Geometry Group</param>

1124

private void DrawLine(Point startPoint, Point endPoint, GeometryGroup geometryGroup)

1124

private void DrawLine(Point startPoint, Point endPoint, GeometryGroup geometryGroup)

1125

{

1125

{

1126

LineGeometry lineGeometry = new LineGeometry();

1126

LineGeometry lineGeometry = new LineGeometry();

1127

lineGeometry.StartPoint = startPoint;

1127

lineGeometry.StartPoint = startPoint;

1128

lineGeometry.EndPoint = endPoint;

1128

lineGeometry.EndPoint = endPoint;

1129

geometryGroup.Children.Add(lineGeometry);

1129

geometryGroup.Children.Add(lineGeometry);

1130

}

1130

}

1131

1132

/// <summary>

1132

/// <summary>

1133

/// Draw curver line

1133

/// Draw curver line

1134

/// </summary>

1134

/// </summary>

1135

/// <param name="startPoint">Point start curver line</param>

1135

/// <param name="startPoint">Point start curver line</param>

1136

/// <param name="endPoint">Point end curver line</param>

1136

/// <param name="endPoint">Point end curver line</param>

1137

/// <param name="radius">Radius</param>

1137

/// <param name="radius">Radius</param>

1138

/// <param name="geometryGroup">Geometry Group</param>

1138

/// <param name="geometryGroup">Geometry Group</param>

1139

private void DrawCurverLine(Point startPoint, Point endPoint, SweepDirection sweepDirection, GeometryGroup geometryGroup)

1139

private void DrawCurverLine(Point startPoint, Point endPoint, SweepDirection sweepDirection, GeometryGroup geometryGroup)

1140

{

1140

{

1141

PathGeometry pathGeometry = new PathGeometry();

1141

PathGeometry pathGeometry = new PathGeometry();

1142

PathFigure figure = new PathFigure();

1142

PathFigure figure = new PathFigure();

1143

figure.StartPoint = startPoint;

1143

figure.StartPoint = startPoint;

1144

figure.Segments.Add(new ArcSegment(endPoint, new Size(RADIUS_CURVER_LINE, RADIUS_CURVER_LINE), 90, false, sweepDirection, true));

1144

figure.Segments.Add(new ArcSegment(endPoint, new Size(RADIUS_CURVER_LINE, RADIUS_CURVER_LINE), 90, false, sweepDirection, true));

1145

pathGeometry.Figures.Add(figure);

1145

pathGeometry.Figures.Add(figure);

1146

geometryGroup.Children.Add(pathGeometry);

1146

geometryGroup.Children.Add(pathGeometry);

1147

}

1147

}

1148

1149

/// <summary>

1149

/// <summary>

1150

/// Setting node

1150

/// Setting node

1151

/// </summary>

1151

/// </summary>

1152

/// <param name="centerPoit">Position of center node</param>

1152

/// <param name="centerPoit">Position of center node</param>

1153

/// <param name="geometryGroup">Geometry Group</param>

1153

/// <param name="geometryGroup">Geometry Group</param>

1154

private void AddNode(Point centerPoit, GeometryGroup geometryGroup)

1154

private void AddNode(Point centerPoit, GeometryGroup geometryGroup)

1155

{

1155

{

1156

double radius = RADIUS_NODE;

1156

double radius = RADIUS_NODE;

1157

geometryGroup.Children.Add(new EllipseGeometry(centerPoit, radius, radius));

1157

geometryGroup.Children.Add(new EllipseGeometry(centerPoit, radius, radius));

1158

}

1158

}

1159

1160

/// <summary>

1160

/// <summary>

1161

/// Check line is vertical or horizontal

1161

/// Check line is vertical or horizontal

1162

/// </summary>

1162

/// </summary>

1163

/// <param name="line"></param>

1163

/// <param name="line"></param>

1164

/// <returns>true:Vertical, false:Horizontal</returns>

1164

/// <returns>true:Vertical, false:Horizontal</returns>

1165

private bool IsVerticalLine(LineGeometry line)

1165

private bool IsVerticalLine(LineGeometry line)

1166

{

1166

{

1167

if (line.StartPoint.X == line.EndPoint.X)

1167

if (line.StartPoint.X == line.EndPoint.X)

1168

{

1168

{

1169

// Vertical line

1169

// Vertical line

1170

return true;

1170

return true;

1171

}

1171

}

1172

1173

// Horizontal line

1173

// Horizontal line

1174

return false;

1174

return false;

1175

}

1175

}

1176

1177

/// <summary>

1177

/// <summary>

1178

/// Get distance between two point

1178

/// Get distance between two point

1179

/// </summary>

1179

/// </summary>

1180

/// <param name="point1">Point 1</param>

1180

/// <param name="point1">Point 1</param>

1181

/// <param name="point2">Point 2</param>

1181

/// <param name="point2">Point 2</param>

1182

/// <returns>Distance between two point</returns>

1182

/// <returns>Distance between two point</returns>

1183

private double GetDistance(Point point1, Point point2)

1183

private double GetDistance(Point point1, Point point2)

1184

{

1184

{

1185

//pythagorean theorem c^2 = a^2 + b^2

1185

//pythagorean theorem c^2 = a^2 + b^2

1186

//thus c = square root(a^2 + b^2)

1186

//thus c = square root(a^2 + b^2)

1187

double a = (double)(point2.X - point1.X);

1187

double a = (double)(point2.X - point1.X);

1188

double b = (double)(point2.Y - point1.Y);

1188

double b = (double)(point2.Y - point1.Y);

1189

1190

return Math.Sqrt(a * a + b * b);

1190

return Math.Sqrt(a * a + b * b);

1191

}

1191

}

1192

1193

/// <summary>

1193

/// <summary>

1194

/// Check point is valid for draw

1194

/// Check point is valid for draw

1195

/// </summary>

1195

/// </summary>

1196

/// <param name="point">Poit need check</param>

1196

/// <param name="point">Poit need check</param>

1197

/// <returns>true:Valid, false:Invalid</returns>

1197

/// <returns>true:Valid, false:Invalid</returns>

1198

private bool IsValidPoint(Point point)

1198

private bool IsValidPoint(Point point)

1199

{

1199

{

1200

return true;

1200

return true;

1201

}

1201

}

1202

1203

/// <summary>

1203

/// <summary>

1204

/// Display coordinate position

1204

/// Display coordinate position

1205

/// </summary>

1205

/// </summary>

1206

/// <param name="point">Position to display</param>

1206

/// <param name="point">Position to display</param>

1207

private void DisplayCoordinate(Point point)

1207

private void DisplayCoordinate(Point point)

1208

{

1208

{

1209

if (_displayAxiPosition == null)

1209

if (_displayAxiPosition == null)

1210

{

1210

{

1211

_displayAxiPosition = new ucDisplayCoordinate();

1211

_displayAxiPosition = new ucDisplayCoordinate();

1212

this.Children.Add(_displayAxiPosition);

1212

this.Children.Add(_displayAxiPosition);

1213

}

1213

}

1214

_displayAxiPosition.Display(point);

1214

_displayAxiPosition.Display(point);

1215

}

1215

}

1216

1217

#endregion

1217

#endregion

1218

1219

#region Functions for Set Auto Nodes

1219

#region Functions for Set Auto Nodes

1220

1221

/// <summary>

1221

/// <summary>

1222

/// SetAutoNodes

1222

/// SetAutoNodes

1223

/// </summary>

1223

/// </summary>

1224

public void SetAutoNodes()

1224

public void SetAutoNodes()

1225

{

1225

{

1226

double radiusStart = DISTANCE_START_NODES;

1226

double radiusStart = DISTANCE_START_NODES;

1227

double radiusEnd = DISTANCE_END_NODES;

1227

double radiusEnd = DISTANCE_END_NODES;

1228

double radiusCurver = RADIUS_CURVER_LINE;

1228

double radiusCurver = RADIUS_CURVER_LINE;

1229

1230

Point startNode;

1230

Point startNode;

1231

Point endNode;

1231

Point endNode;

1232

1233

gGrpBlueNode.Children.Clear();

1233

gGrpBlueNode.Children.Clear();

1234

1235

if (gGrpLine.Children.Count == 1)

1235

if (gGrpLine.Children.Count == 1)

1236

radiusCurver = radiusEnd;

1236

radiusCurver = radiusEnd;

1237

1238

if (gGrpLine.Children.Count > 0)

1238

if (gGrpLine.Children.Count > 0)

1239

{

1239

{

1240

for (int i = 0; i < gGrpLine.Children.Count; i++)

1240

for (int i = 0; i < gGrpLine.Children.Count; i++)

1241

{

1241

{

1242

LineGeometry lineGeometry = (LineGeometry)gGrpLine.Children[i];

1242

LineGeometry lineGeometry = (LineGeometry)gGrpLine.Children[i];

1243

if (i == 0)

1243

if (i == 0)

1244

{

1244

{

1245

startNode = lineGeometry.EndPoint;

1245

startNode = lineGeometry.EndPoint;

1246

endNode = lineGeometry.StartPoint;

1246

endNode = lineGeometry.StartPoint;

1247

DrawAutoNodes(startNode, endNode, radiusCurver, radiusStart);

1247

DrawAutoNodes(startNode, endNode, radiusCurver, radiusStart);

1248

}

1248

}

1249

else if (i == gGrpLine.Children.Count - 1 && i > 0)

1249

else if (i == gGrpLine.Children.Count - 1 && i > 0)

1250

{

1250

{

1251

startNode = lineGeometry.StartPoint;

1251

startNode = lineGeometry.StartPoint;

1252

endNode = lineGeometry.EndPoint;

1252

endNode = lineGeometry.EndPoint;

1253

DrawAutoNodes(startNode, endNode, radiusCurver, radiusEnd);

1253

DrawAutoNodes(startNode, endNode, radiusCurver, radiusEnd);

1254

}

1254

}

1255

else

1255

else

1256

{

1256

{

1257

startNode = lineGeometry.StartPoint;

1257

startNode = lineGeometry.StartPoint;

1258

endNode = lineGeometry.EndPoint;

1258

endNode = lineGeometry.EndPoint;

1259

DrawAutoNodes(startNode, endNode, radiusCurver, radiusCurver);

1259

DrawAutoNodes(startNode, endNode, radiusCurver, radiusCurver);

1260

}

1260

}

1261

}

1261

}

1262

}

1262

}

1263

}

1263

}

1264

1265

1266

/// <summary>

1266

/// <summary>

1267

/// DrawAutoNodes

1267

/// DrawAutoNodes

1268

/// </summary>

1268

/// </summary>

1269

/// <param name="startNode"></param>

1269

/// <param name="startNode"></param>

1270

/// <param name="endNode"></param>

1270

/// <param name="endNode"></param>

1271

/// <param name="radiusStart"></param>

1271

/// <param name="radiusStart"></param>

1272

/// <param name="radiusEnd"></param>

1272

/// <param name="radiusEnd"></param>

1273

private void DrawAutoNodes(Point startNode, Point endNode, double radiusStart, double radiusEnd)

1273

private void DrawAutoNodes(Point startNode, Point endNode, double radiusStart, double radiusEnd)

1274

{

1274

{

1275

double distance = DISTANCE_AUTO_NODES;

1275

double distance = DISTANCE_AUTO_NODES;

1276

double i;

1276

double i;

1277

1278

Point node;

1278

Point node;

1279

1280

// Get postion of blue node on line

1280

// Get postion of blue node on line

1281

if (startNode.X == endNode.X)

1281

if (startNode.X == endNode.X)

1282

{

1282

{

1283

if (startNode.Y > endNode.Y)

1283

if (startNode.Y > endNode.Y)

1284

{

1284

{

1285

i = startNode.Y - radiusStart;

1285

i = startNode.Y - radiusStart;

1286

if (i - distance > endNode.Y + radiusEnd)

1286

if (i - distance > endNode.Y + radiusEnd)

1287

{

1287

{

1288

do

1288

do

1289

{

1289

{

1290

i = i - distance;

1290

i = i - distance;

1291

node = new Point(endNode.X, i);

1291

node = new Point(endNode.X, i);

1292

// Add node to postion distance 1000mm

1292

// Add node to postion distance 1000mm

1293

AddNode(node, gGrpBlueNode);

1293

AddNode(node, gGrpBlueNode);

1294

1295

} while (i > endNode.Y + radiusEnd + distance);

1295

} while (i > endNode.Y + radiusEnd + distance);

1296

}

1296

}

1297

}

1297

}

1298

else

1298

else

1299

{

1299

{

1300

i = startNode.Y + radiusStart;

1300

i = startNode.Y + radiusStart;

1301

if (i + distance < endNode.Y - radiusEnd)

1301

if (i + distance < endNode.Y - radiusEnd)

1302

{

1302

{

1303

do

1303

do

1304

{

1304

{

1305

i = i + distance;

1305

i = i + distance;

1306

node = new Point(endNode.X, i);

1306

node = new Point(endNode.X, i);

1307

// Add node to postion distance 1000mm

1307

// Add node to postion distance 1000mm

1308

AddNode(node, gGrpBlueNode);

1308

AddNode(node, gGrpBlueNode);

1309

} while (i < endNode.Y - radiusEnd - distance);

1309

} while (i < endNode.Y - radiusEnd - distance);

1310

}

1310

}

1311

}

1311

}

1312

}

1312

}

1313

else

1313

else

1314

{

1314

{

1315

if (startNode.X > endNode.X)

1315

if (startNode.X > endNode.X)

1316

{

1316

{

1317

i = startNode.X - radiusStart;

1317

i = startNode.X - radiusStart;

1318

if (i - distance > endNode.X + radiusEnd)

1318

if (i - distance > endNode.X + radiusEnd)

1319

{

1319

{

1320

do

1320

do

1321

{

1321

{

1322

i = i - distance;

1322

i = i - distance;

1323

node = new Point(i, endNode.Y);

1323

node = new Point(i, endNode.Y);

1324

// Add node to postion distance 1000mm

1324

// Add node to postion distance 1000mm

1325

AddNode(node, gGrpBlueNode);

1325

AddNode(node, gGrpBlueNode);

1326

} while (i > endNode.X + radiusEnd + distance);

1326

} while (i > endNode.X + radiusEnd + distance);

1327

}

1327

}

1328

}

1328

}

1329

else

1329

else

1330

{

1330

{

1331

i = startNode.X + radiusStart;

1331

i = startNode.X + radiusStart;

1332

if (i + distance < endNode.X - radiusEnd)

1332

if (i + distance < endNode.X - radiusEnd)

1333

{

1333

{

1334

do

1334

do

1335

{

1335

{

1336

i = i + distance;

1336

i = i + distance;

1337

node = new Point(i, endNode.Y);

1337

node = new Point(i, endNode.Y);

1338

// Add node to postion distance 1000mm

1338

// Add node to postion distance 1000mm

1339

AddNode(node, gGrpBlueNode);

1339

AddNode(node, gGrpBlueNode);

1340

} while (i < endNode.X - radiusEnd - distance);

1340

} while (i < endNode.X - radiusEnd - distance);

1341

}

1341

}

1342

}

1342

}

1343

}

1343

}

1344

1345

}

1345

}

1346

1347

#endregion

1347

#endregion

1348

1349

#region Functions for Set Free Nodes

1349

#region Functions for Set Free Nodes

1350

/// <summary>

1350

/// <summary>

1351

/// Draw Auto Blue node

1351

/// Draw Auto Blue node

1352

/// </summary>

1352

/// </summary>

1353

1354

public void SetFreeNodes(Point FreeNode, bool RightClick)

1354

public void SetFreeNodes(Point FreeNode, bool RightClick)

1355

{

1355

{

1356

double radiusStart = DISTANCE_START_NODES;

1356

double radiusStart = DISTANCE_START_NODES;

1357

double radiusEnd = DISTANCE_END_NODES;

1357

double radiusEnd = DISTANCE_END_NODES;

1358

double radiusNode = RADIUS_NODE;

1358

double radiusNode = RADIUS_NODE;

1359

double radiusCurver = RADIUS_CURVER_LINE + RADIUS_NODE;

1359

double radiusCurver = RADIUS_CURVER_LINE + RADIUS_NODE;

1360

1361

EllipseGeometry ellipseGeometry;

1361

EllipseGeometry ellipseGeometry;

1362

Point node;

1362

Point node;

1363

bool deleteFlag = false;

1363

bool deleteFlag = false;

1364

1365

1366

if (RightClick)

1366

if (RightClick)

1367

{

1367

{

1368

if (gGrpBlueNode.Children.Count > 0)

1368

if (gGrpBlueNode.Children.Count > 0)

1369

{

1369

{

1370

for (int i = 0; i < gGrpBlueNode.Children.Count; i++)

1370

for (int i = 0; i < gGrpBlueNode.Children.Count; i++)

1371

{

1371

{

1372

ellipseGeometry = (EllipseGeometry)gGrpBlueNode.Children[i];

1372

ellipseGeometry = (EllipseGeometry)gGrpBlueNode.Children[i];

1373

node = ellipseGeometry.Center;

1373

node = ellipseGeometry.Center;

1374

if (FreeNode.X == node.X)

1374

if (FreeNode.X == node.X)

1375

{

1375

{

1376

if (CheckIsNode(FreeNode, node, radiusNode))

1376

if (CheckIsNode(FreeNode, node, radiusNode))

1377

{

1377

{

1378

deleteFlag = true;

1378

deleteFlag = true;

1379

}

1379

}

1380

}

1380

}

1381

else

1381

else

1382

{

1382

{

1383

if (CheckIsNode(FreeNode, node, radiusNode))

1383

if (CheckIsNode(FreeNode, node, radiusNode))

1384

{

1384

{

1385

deleteFlag = true;

1385

deleteFlag = true;

1386

}

1386

}

1387

}

1387

}

1388

if (deleteFlag)

1388

if (deleteFlag)

1389

{

1389

{

1390

MessageBoxResult result = MessageBox.Show("Do You Delete This Node?", "Delete Node", MessageBoxButton.OKCancel);

1390

MessageBoxResult result = MessageBox.Show("Do You Delete This Node?", "Delete Node", MessageBoxButton.OKCancel);

1391

if (result == MessageBoxResult.OK)

1391

if (result == MessageBoxResult.OK)

1392

{

1392

{

1393

gGrpBlueNode.Children.RemoveAt(i);

1393

gGrpBlueNode.Children.RemoveAt(i);

1394

1395

this.Children.Remove(NodeNo[i]);

1395

this.Children.Remove(NodeNo[i]);

1396

return;

1396

return;

1397

}

1397

}

1398

else

1398

else

1399

{

1399

{

1400

return;

1400

return;

1401

}

1401

}

1402

}

1402

}

1403

}

1403

}

1404

}

1404

}

1405

}

1405

}

1406

else

1406

else

1407

{

1407

{

1408

1409

for (int i = 0; i < gGrpBlueNode.Children.Count; i++)

1409

for (int i = 0; i < gGrpBlueNode.Children.Count; i++)

1410

{

1410

{

1411

ellipseGeometry = (EllipseGeometry)gGrpBlueNode.Children[i];

1411

ellipseGeometry = (EllipseGeometry)gGrpBlueNode.Children[i];

1412

node = ellipseGeometry.Center;

1412

node = ellipseGeometry.Center;

1413

bool isEditNode = CheckIsNode(FreeNode, node, RADIUS_NODE);

1413

bool isEditNode = CheckIsNode(FreeNode, node, RADIUS_NODE);

1414

1415

if (isEditNode)

1415

if (isEditNode)

1416

{

1416

{

1417

EditNode(node);

1417

EditNode(node);

1418

return;

1418

return;

1419

}

1419

}

1420

}

1420

}

1421

1422

1423

MessageBoxResult result = MessageBox.Show("Do You Want To Add This Node?", "Add Node", MessageBoxButton.OKCancel);

1423

MessageBoxResult result = MessageBox.Show("Do You Want To Add This Node?", "Add Node", MessageBoxButton.OKCancel);

1424

if (result == MessageBoxResult.OK)

1424

if (result == MessageBoxResult.OK)

1425

{

1425

{

1426

AddNode(FreeNode, gGrpBlueNode);

1426

AddNode(FreeNode, gGrpBlueNode);

1427

1428

TextBlock textBlock = new TextBlock();

1428

TextBlock textBlock = new TextBlock();

1429

textBlock.Text = stt.ToString();

1429

textBlock.Text = stt.ToString();

1430

textBlock.FontSize = 17;

1430

textBlock.FontSize = 17;

1431

textBlock.Foreground = new SolidColorBrush(Colors.Red);

1431

textBlock.Foreground = new SolidColorBrush(Colors.Red);

1432

Canvas.SetLeft(textBlock, FreeNode.X - RADIUS_NODE / 2);

1432

Canvas.SetLeft(textBlock, FreeNode.X - RADIUS_NODE / 2);

1433

Canvas.SetTop(textBlock, FreeNode.Y - 1.5 * RADIUS_NODE);

1433

Canvas.SetTop(textBlock, FreeNode.Y - 1.5 * RADIUS_NODE);

1434

1435

this.Children.Add(textBlock);

1435

this.Children.Add(textBlock);

1436

NodeNo.Add(textBlock);

1436

NodeNo.Add(textBlock);

1437

1438

if (stt > 1)

1438

if (stt > 1)

1439

{

1439

{

1440

int tmp = gGrpBlueNode.Children.Count;

1440

int tmp = gGrpBlueNode.Children.Count;

1441

1442

EllipseGeometry elip = (EllipseGeometry)gGrpBlueNode.Children[tmp - 2];

1442

EllipseGeometry elip = (EllipseGeometry)gGrpBlueNode.Children[tmp - 2];

1443

Point node1 = elip.Center;

1443

Point node1 = elip.Center;

1444

elip = (EllipseGeometry)gGrpBlueNode.Children[tmp - 1];

1444

elip = (EllipseGeometry)gGrpBlueNode.Children[tmp - 1];

1445

Point node2 = elip.Center;

1445

Point node2 = elip.Center;

1446

DrawLine(node1, node2, gGrpCurverLine);

1446

DrawLine(node1, node2, gGrpCurverLine);

1447

}

1447

}

1448

1449

1450

stt++;

1450

stt++;

1451

}

1451

}

1452

}

1452

}

1453

1454

if (gGrpLine.Children.Count > 0)

1454

if (gGrpLine.Children.Count > 0)

1455

{

1455

{

1456

for (int i = 0; i < gGrpLine.Children.Count; i++)

1456

for (int i = 0; i < gGrpLine.Children.Count; i++)

1457

{

1457

{

1458

LineGeometry lineGeometry = (LineGeometry)gGrpLine.Children[i];

1458

LineGeometry lineGeometry = (LineGeometry)gGrpLine.Children[i];

1459

1460

// Get postion of node on line

1460

// Get postion of node on line

1461

if (IsVerticalLine(lineGeometry))

1461

if (IsVerticalLine(lineGeometry))

1462

{

1462

{

1463

if (FreeNode.X < lineGeometry.EndPoint.X + radiusNode && FreeNode.X > lineGeometry.EndPoint.X - radiusNode)

1463

if (FreeNode.X < lineGeometry.EndPoint.X + radiusNode && FreeNode.X > lineGeometry.EndPoint.X - radiusNode)

1464

{

1464

{

1465

FreeNode.X = lineGeometry.EndPoint.X;

1465

FreeNode.X = lineGeometry.EndPoint.X;

1466

1467

if (i == 0)

1467

if (i == 0)

1468

{

1468

{

1469

if (CheckFreeNodes(lineGeometry, FreeNode, radiusStart, radiusCurver))

1469

if (CheckFreeNodes(lineGeometry, FreeNode, radiusStart, radiusCurver))

1470

{

1470

{

1471

1472

AddNode(FreeNode, gGrpBlueNode);

1472

AddNode(FreeNode, gGrpBlueNode);

1473

}

1473

}

1474

}

1474

}

1475

else if (i == gGrpLine.Children.Count - 1 && i > 0)

1475

else if (i == gGrpLine.Children.Count - 1 && i > 0)

1476

{

1476

{

1477

if (CheckFreeNodes(lineGeometry, FreeNode, radiusCurver, radiusEnd))

1477

if (CheckFreeNodes(lineGeometry, FreeNode, radiusCurver, radiusEnd))

1478

{

1478

{

1479

1480

AddNode(FreeNode, gGrpBlueNode);

1480

AddNode(FreeNode, gGrpBlueNode);

1481

}

1481

}

1482

}

1482

}

1483

else

1483

else

1484

{

1484

{

1485

if (CheckFreeNodes(lineGeometry, FreeNode, radiusCurver, radiusCurver))

1485

if (CheckFreeNodes(lineGeometry, FreeNode, radiusCurver, radiusCurver))

1486

{

1486

{

1487

1488

AddNode(FreeNode, gGrpBlueNode);

1488

AddNode(FreeNode, gGrpBlueNode);

1489

}

1489

}

1490

}

1490

}

1491

1492

}

1492

}

1493

}

1493

}

1494

else

1494

else

1495

{

1495

{

1496

if (FreeNode.Y < lineGeometry.EndPoint.Y + radiusNode && FreeNode.Y > lineGeometry.EndPoint.Y - radiusNode)

1496

if (FreeNode.Y < lineGeometry.EndPoint.Y + radiusNode && FreeNode.Y > lineGeometry.EndPoint.Y - radiusNode)

1497

{

1497

{

1498

FreeNode.Y = lineGeometry.EndPoint.Y;

1498

FreeNode.Y = lineGeometry.EndPoint.Y;

1499

if (i == 0)

1499

if (i == 0)

1500

{

1500

{

1501

if (CheckFreeNodes(lineGeometry, FreeNode, radiusStart, radiusCurver))

1501

if (CheckFreeNodes(lineGeometry, FreeNode, radiusStart, radiusCurver))

1502

{

1502

{

1503

1504

AddNode(FreeNode, gGrpBlueNode);

1504

AddNode(FreeNode, gGrpBlueNode);

1505

}

1505

}

1506

}

1506

}

1507

else if (i == gGrpLine.Children.Count - 1 && i > 0)

1507

else if (i == gGrpLine.Children.Count - 1 && i > 0)

1508

{

1508

{

1509

if (CheckFreeNodes(lineGeometry, FreeNode, radiusCurver, radiusEnd))

1509

if (CheckFreeNodes(lineGeometry, FreeNode, radiusCurver, radiusEnd))

1510

{

1510

{

1511

1512

AddNode(FreeNode, gGrpBlueNode);

1512

AddNode(FreeNode, gGrpBlueNode);

1513

}

1513

}

1514

}

1514

}

1515

else

1515

else

1516

{

1516

{

1517

if (CheckFreeNodes(lineGeometry, FreeNode, radiusCurver, radiusCurver))

1517

if (CheckFreeNodes(lineGeometry, FreeNode, radiusCurver, radiusCurver))

1518

{

1518

{

1519

1520

AddNode(FreeNode, gGrpBlueNode);

1520

AddNode(FreeNode, gGrpBlueNode);

1521

}

1521

}

1522

}

1522

}

1523

1524

}

1524

}

1525

}

1525

}

1526

}

1526

}

1527

}

1527

}

1528

}

1528

}

1529

1530

1531

public bool CheckFreeNodes(LineGeometry lineNode, Point Freenode, double radiusStart, double radiusEnd)

1531

public bool CheckFreeNodes(LineGeometry lineNode, Point Freenode, double radiusStart, double radiusEnd)

1532

{

1532

{

1533

1534

double distanceFreeNode = DISTANCE_FREE_NODES;

1534

double distanceFreeNode = DISTANCE_FREE_NODES;

1535

double radiusNode = RADIUS_NODE;

1535

double radiusNode = RADIUS_NODE;

1536

EllipseGeometry ellipseGeometry;

1536

EllipseGeometry ellipseGeometry;

1537

Point node;

1537

Point node;

1538

1539

if (IsVerticalLine(lineNode))

1539

if (IsVerticalLine(lineNode))

1540

{

1540

{

1541

if (lineNode.StartPoint.Y < lineNode.EndPoint.Y)

1541

if (lineNode.StartPoint.Y < lineNode.EndPoint.Y)

1542

{

1542

{

1543

if (Freenode.Y < lineNode.StartPoint.Y + radiusStart || Freenode.Y > lineNode.EndPoint.Y - radiusEnd)

1543

if (Freenode.Y < lineNode.StartPoint.Y + radiusStart || Freenode.Y > lineNode.EndPoint.Y - radiusEnd)

1544

{

1544

{

1545

return false;

1545

return false;

1546

}

1546

}

1547

}

1547

}

1548

else

1548

else

1549

{

1549

{

1550

if (Freenode.Y > lineNode.StartPoint.Y - radiusStart || Freenode.Y < lineNode.EndPoint.Y + radiusEnd)

1550

if (Freenode.Y > lineNode.StartPoint.Y - radiusStart || Freenode.Y < lineNode.EndPoint.Y + radiusEnd)

1551

{

1551

{

1552

return false;

1552

return false;

1553

}

1553

}

1554

}

1554

}

1555

}

1555

}

1556

else

1556

else

1557

{

1557

{

1558

if (lineNode.StartPoint.X < lineNode.EndPoint.X)

1558

if (lineNode.StartPoint.X < lineNode.EndPoint.X)

1559

{

1559

{

1560

if (Freenode.X < lineNode.StartPoint.X + radiusStart || Freenode.X > lineNode.EndPoint.X - radiusEnd)

1560

if (Freenode.X < lineNode.StartPoint.X + radiusStart || Freenode.X > lineNode.EndPoint.X - radiusEnd)

1561

{

1561

{

1562

return false;

1562

return false;

1563

}

1563

}

1564

}

1564

}

1565

else

1565

else

1566

{

1566

{

1567

if (Freenode.X > lineNode.StartPoint.X - radiusStart || Freenode.X < lineNode.EndPoint.X + radiusEnd)

1567

if (Freenode.X > lineNode.StartPoint.X - radiusStart || Freenode.X < lineNode.EndPoint.X + radiusEnd)

1568

{

1568

{

1569

return false;

1569

return false;

1570

}

1570

}

1571

}

1571

}

1572

}

1572

}

1573

1574

if (gGrpBlueNode.Children.Count > 0)

1574

if (gGrpBlueNode.Children.Count > 0)

1575

{

1575

{

1576

for (int i = 0; i < gGrpBlueNode.Children.Count; i++)

1576

for (int i = 0; i < gGrpBlueNode.Children.Count; i++)

1577

{

1577

{

1578

ellipseGeometry = (EllipseGeometry)gGrpBlueNode.Children[i];

1578

ellipseGeometry = (EllipseGeometry)gGrpBlueNode.Children[i];

1579

node = ellipseGeometry.Center;

1579

node = ellipseGeometry.Center;

1580

if (Freenode.X == node.X)

1580

if (Freenode.X == node.X)

1581

{

1581

{

1582

if (CheckIsNode(Freenode, node, radiusNode))

1582

if (CheckIsNode(Freenode, node, radiusNode))

1583

{

1583

{

1584

return false;

1584

return false;

1585

}

1585

}

1586

else if (Freenode.Y < node.Y + distanceFreeNode && Freenode.Y > node.Y - distanceFreeNode)

1586

else if (Freenode.Y < node.Y + distanceFreeNode && Freenode.Y > node.Y - distanceFreeNode)

1587

{

1587

{

1588

return false;

1588

return false;

1589

}

1589

}

1590

}

1590

}

1591

else if (Freenode.Y == node.Y)

1591

else if (Freenode.Y == node.Y)

1592

{

1592

{

1593

if (CheckIsNode(Freenode, node, radiusNode))

1593

if (CheckIsNode(Freenode, node, radiusNode))

1594

{

1594

{

1595

return false;

1595

return false;

1596

}

1596

}

1597

else if (Freenode.X < node.X + distanceFreeNode && Freenode.X > node.X - distanceFreeNode)

1597

else if (Freenode.X < node.X + distanceFreeNode && Freenode.X > node.X - distanceFreeNode)

1598

{

1598

{

1599

return false;

1599

return false;

1600

}

1600

}

1601

}

1601

}

1602

}

1602

}

1603

}

1603

}

1604

1605

return true;

1605

return true;

1606

}

1606

}

1607

1608

public bool CheckIsNode(Point FreeNode, Point Node, double radiusNode)

1608

public bool CheckIsNode(Point FreeNode, Point Node, double radiusNode)

1609

{

1609

{

1610

if (FreeNode.X < Node.X + radiusNode && FreeNode.X > Node.X - radiusNode && FreeNode.Y < Node.Y + radiusNode && FreeNode.Y > Node.Y - radiusNode)

1610

if (FreeNode.X < Node.X + radiusNode && FreeNode.X > Node.X - radiusNode && FreeNode.Y < Node.Y + radiusNode && FreeNode.Y > Node.Y - radiusNode)

1611

{

1611

{

1612

return true;

1612

return true;

1613

}

1613

}

1614

return false;

1614

return false;

1615

}

1615

}

1616

1617

#endregion

1617

#endregion

1618

1619

#region Edit Node

1619

#region Edit Node

1620

public void InitNodeInfo_List()

1620

public void InitNodeInfo_List()

1621

{

1621

{

1622

//Reset List

1622

//Reset List

1623

NodeInfo_List = new List<NodeInfo>();

1623

NodeInfo_List = new List<NodeInfo>();

1624

1625

if (gGrpBlueNode.Children.Count > 0)

1625

if (gGrpBlueNode.Children.Count > 0)

1626

{

1626

{

1627

// Get start point

1627

// Get start point

1628

LineGeometry lineGeometry = (LineGeometry)gGrpNewLine.Children[0];

1628

LineGeometry lineGeometry = (LineGeometry)gGrpNewLine.Children[0];

1629

Point startPoint = lineGeometry.StartPoint;

1629

Point startPoint = lineGeometry.StartPoint;

1630

1631

NodeInfo n1 = new NodeInfo();

1631

NodeInfo n1 = new NodeInfo();

1632

n1.X = startPoint.X;

1632

n1.X = startPoint.X;

1633

n1.Y = startPoint.Y;

1633

n1.Y = startPoint.Y;

1634

n1.Mode1 = "";

1634

n1.Mode1 = "";

1635

n1.Mode2 = "";

1635

n1.Mode2 = "";

1636

n1.Mode3 = "";

1636

n1.Mode3 = "";

1637

NodeInfo_List.Add(n1);

1637

NodeInfo_List.Add(n1);

1638

1639

for (int i = 0; i < gGrpBlueNode.Children.Count; i++)

1639

for (int i = 0; i < gGrpBlueNode.Children.Count; i++)

1640

{

1640

{

1641

Point point;

1641

Point point;

1642

EllipseGeometry eGeometry = (EllipseGeometry)gGrpBlueNode.Children[i];

1642

EllipseGeometry eGeometry = (EllipseGeometry)gGrpBlueNode.Children[i];

1643

point = eGeometry.Center;

1643

point = eGeometry.Center;

1644

1645

NodeInfo Ninfo = new NodeInfo();

1645

NodeInfo Ninfo = new NodeInfo();

1646

Ninfo.X = point.X;

1646

Ninfo.X = point.X;

1647

Ninfo.Y = point.Y;

1647

Ninfo.Y = point.Y;

1648

1649

Ninfo.Mode1 = "";

1649

Ninfo.Mode1 = "";

1650

Ninfo.Mode2 = "";

1650

Ninfo.Mode2 = "";

1651

Ninfo.Mode3 = "";

1651

Ninfo.Mode3 = "";

1652

1653

NodeInfo_List.Add(Ninfo);

1653

NodeInfo_List.Add(Ninfo);

1654

}

1654

}

1655

1656

// Get end point

1656

// Get end point

1657

lineGeometry = (LineGeometry)gGrpLine.Children[gGrpLine.Children.Count - 1];

1657

lineGeometry = (LineGeometry)gGrpLine.Children[gGrpLine.Children.Count - 1];

1658

Point endPoint = lineGeometry.EndPoint;

1658

Point endPoint = lineGeometry.EndPoint;

1659

1660

NodeInfo n2 = new NodeInfo();

1660

NodeInfo n2 = new NodeInfo();

1661

n2.X = startPoint.X;

1661

n2.X = startPoint.X;

1662

n2.Y = startPoint.Y;

1662

n2.Y = startPoint.Y;

1663

n2.Mode1 = "";

1663

n2.Mode1 = "";

1664

n2.Mode2 = "";

1664

n2.Mode2 = "";

1665

n2.Mode3 = "";

1665

n2.Mode3 = "";

1666

NodeInfo_List.Add(n2);

1666

NodeInfo_List.Add(n2);

1667

1668

//Resort NodeInfo_List From Start to Goal

1668

//Resort NodeInfo_List From Start to Goal

1669

LineGeometry firstLine = (LineGeometry)gGrpLine.Children[0];

1669

LineGeometry firstLine = (LineGeometry)gGrpLine.Children[0];

1670

Point startNode = firstLine.StartPoint;

1670

Point startNode = firstLine.StartPoint;

1671

Point endNode = firstLine.EndPoint;

1671

Point endNode = firstLine.EndPoint;

1672

1673

1674

List<NodeInfo> tmpLst = new List<NodeInfo>();

1674

List<NodeInfo> tmpLst = new List<NodeInfo>();

1675

1676

// Create temp List

1676

// Create temp List

1677

if (startNode.X == endNode.X)

1677

if (startNode.X == endNode.X)

1678

{

1678

{

1679

for (int i = 1; i < NodeInfo_List.Count; i++)

1679

for (int i = 1; i < NodeInfo_List.Count; i++)

1680

{

1680

{

1681

if (NodeInfo_List[i].X != endNode.X)

1681

if (NodeInfo_List[i].X != endNode.X)

1682

{

1682

{

1683

break;

1683

break;

1684

}

1684

}

1685

else

1685

else

1686

{

1686

{

1687

tmpLst.Add(NodeInfo_List[i]);

1687

tmpLst.Add(NodeInfo_List[i]);

1688

}

1688

}

1689

}

1689

}

1690

}

1690

}

1691

1692

if (startNode.Y == endNode.Y)

1692

if (startNode.Y == endNode.Y)

1693

{

1693

{

1694

for (int i = 1; i < NodeInfo_List.Count; i++)

1694

for (int i = 1; i < NodeInfo_List.Count; i++)

1695

{

1695

{

1696

if (NodeInfo_List[i].Y != endNode.Y)

1696

if (NodeInfo_List[i].Y != endNode.Y)

1697

{

1697

{

1698

break;

1698

break;

1699

}

1699

}

1700

else

1700

else

1701

{

1701

{

1702

tmpLst.Add(NodeInfo_List[i]);

1702

tmpLst.Add(NodeInfo_List[i]);

1703

}

1703

}

1704

}

1704

}

1705

}

1705

}

1706

1707

// Sort NodeInfo_List

1707

// Sort NodeInfo_List

1708

for (int i = 0; i < tmpLst.Count; i++)

1708

for (int i = 0; i < tmpLst.Count; i++)

1709

{

1709

{

1710

NodeInfo_List[i + 1] = tmpLst[tmpLst.Count - 1 - i];

1710

NodeInfo_List[i + 1] = tmpLst[tmpLst.Count - 1 - i];

1711

}

1711

}

1712

1713

}

1713

}

1714

}

1714

}

1715

1716

1717

public void EditNode(Point node_edited)

1717

public void EditNode(Point node_edited)

1718

{

1718

{

1719

EllipseGeometry ellipseGeometry;

1719

EllipseGeometry ellipseGeometry;

1720

Point node;

1720

Point node;

1721

double radiusNode = RADIUS_NODE;

1721

double radiusNode = RADIUS_NODE;

1722

1723

bool flag = false;

1723

bool flag = false;

1724

1725

if (gGrpBlueNode.Children.Count > 0)

1725

if (gGrpBlueNode.Children.Count > 0)

1726

{

1726

{

1727

for (int i = 0; i < gGrpBlueNode.Children.Count; i++)

1727

for (int i = 0; i < gGrpBlueNode.Children.Count; i++)

1728

{

1728

{

1729

ellipseGeometry = (EllipseGeometry)gGrpBlueNode.Children[i];

1729

ellipseGeometry = (EllipseGeometry)gGrpBlueNode.Children[i];

1730

node = ellipseGeometry.Center;

1730

node = ellipseGeometry.Center;

1731

1732

if (CheckIsNode(node_edited, node, radiusNode))

1732

if (CheckIsNode(node_edited, node, radiusNode))

1733

{

1733

{

1734

flag = true;

1734

flag = true;

1735

}

1735

}

1736

1737

if (flag)

1737

if (flag)

1738

{

1738

{

1739

node_edited.X = node.X;

1739

node_edited.X = node.X;

1740

node_edited.Y = node.Y;

1740

node_edited.Y = node.Y;

1741

1742

// show form edit node

1742

// show form edit node

1743

EditNodeWindow edtNodeWindow = new EditNodeWindow();

1743

EditNodeWindow edtNodeWindow = new EditNodeWindow();

1744

edtNodeWindow.ShowDialog();

1744

edtNodeWindow.ShowDialog();

1745

1746

string result1 = edtNodeWindow._txtMode1;

1746

string result1 = edtNodeWindow._txtMode1;

1747

string result2 = edtNodeWindow._txtMode2;

1747

string result2 = edtNodeWindow._txtMode2;

1748

string result3 = edtNodeWindow._txtMode3;

1748

string result3 = edtNodeWindow._txtMode3;

1749

bool exit = edtNodeWindow._ExitFlg;

1749

bool exit = edtNodeWindow._ExitFlg;

1750

1751

if (!exit)

1751

if (!exit)

1752

{

1752

{

1753

SaveChanged(node_edited.X, node_edited.Y, result1, result2, result3);

1753

SaveChanged(node_edited.X, node_edited.Y, result1, result2, result3);

1754

}

1754

}

1755

1756

return;

1756

return;

1757

}

1757

}

1758

}

1758

}

1759

}

1759

}

1760

}

1760

}

1761

1762

public void SaveChanged(double x, double y, string st1, string st2, string st3)

1762

public void SaveChanged(double x, double y, string st1, string st2, string st3)

1763

{

1763

{

1764

for (int i = 0; i < NodeInfo_List.Count; i++)

1764

for (int i = 0; i < NodeInfo_List.Count; i++)

1765

{

1765

{

1766

NodeInfo ni = new NodeInfo();

1766

NodeInfo ni = new NodeInfo();

1767

ni = NodeInfo_List[i];

1767

ni = NodeInfo_List[i];

1768

1769

if (ni.X == x && ni.Y == y)

1769

if (ni.X == x && ni.Y == y)

1770

{

1770

{

1771

1772

ni.Mode1 = st1;

1772

ni.Mode1 = st1;

1773

ni.Mode2 = st2;

1773

ni.Mode2 = st2;

1774

ni.Mode3 = st3;

1774

ni.Mode3 = st3;

1775

1776

NodeInfo_List[i] = ni;

1776

NodeInfo_List[i] = ni;

1777

return;

1777

return;

1778

}

1778

}

1779

}

1779

}

1780

}

1780

}

1781

1782

1783

#endregion

1783

#endregion

1784

1785

#region Display RouteInfo

1785

#region Display RouteInfo

1786

1787

public void DspRouteInfo()

1787

public void DspRouteInfo()

1788

{

1788

{

1789

//Clear Route Info Table

1789

//Clear Route Info Table

1790

((RoboforkMenu)System.Windows.Application.Current.MainWindow).grdRouteInfo.Children.Clear();

1790

((RoboforkMenu)System.Windows.Application.Current.MainWindow).grdRouteInfo.Children.Clear();

1791

1792

if (NodeInfo_List.Count != 0)

1792

if (NodeInfo_List.Count != 0)

1793

{

1793

{

1794

int _RowIdx = 0;

1794

int _RowIdx = 0;

1795

string _Content = "";

1795

string _Content = "";

1796

1797

for (int i = 0; i < NodeInfo_List.Count; i++)

1797

for (int i = 0; i < NodeInfo_List.Count; i++)

1798

{

1798

{

1799

1800

NodeInfo ni = new NodeInfo();

1800

NodeInfo ni = new NodeInfo();

1801

ni = NodeInfo_List[i];

1801

ni = NodeInfo_List[i];

1802

1803

//column 1

1803

//column 1

1804

if (i == 0)

1804

if (i == 0)

1805

{

1805

{

1806

_Content = "S";

1806

_Content = "S";

1807

}

1807

}

1808

else if (i == NodeInfo_List.Count - 1)

1808

else if (i == NodeInfo_List.Count - 1)

1809

{

1809

{

1810

_Content = "G";

1810

_Content = "G";

1811

}

1811

}

1812

else

1812

else

1813

{

1813

{

1814

_Content = i.ToString();

1814

_Content = i.ToString();

1815

}

1815

}

1816

AddLabeltoGrid(_RowIdx, 0, _Content);

1816

AddLabeltoGrid(_RowIdx, 0, _Content);

1817

1818

//column 2

1818

//column 2

1819

// Display Node's Position

1819

// Display Node's Position

1820

_Content = ni.X + ", " + ni.Y;

1820

_Content = ni.X + ", " + ni.Y;

1821

AddLabeltoGrid(_RowIdx, 1, _Content);

1821

AddLabeltoGrid(_RowIdx, 1, _Content);

1822

1823

// Display Node's Field

1823

// Display Node's Field

1824

if (ni.Mode1 != "" && ni.Mode1 != null)

1824

if (ni.Mode1 != "" && ni.Mode1 != null)

1825

{

1825

{

1826

char delimiterChars = '_';

1826

char delimiterChars = '_';

1827

string[] tmp = ni.Mode1.Split(delimiterChars);

1827

string[] tmp = ni.Mode1.Split(delimiterChars);

1828

foreach (string s in tmp)

1828

foreach (string s in tmp)

1829

{

1829

{

1830

_RowIdx++;

1830

_RowIdx++;

1831

delimiterChars = ':';

1831

delimiterChars = ':';

1832

1833

if (s.Split(delimiterChars)[0] == "Mode")

1833

if (s.Split(delimiterChars)[0] == "Mode")

1834

{

1834

{

1835

double distance = 0;

1835

double distance = 0;

1836

if (i == NodeInfo_List.Count - 1)

1836

if (i == NodeInfo_List.Count - 1)

1837

{

1837

{

1838

distance = 0;

1838

distance = 0;

1839

}

1839

}

1840

else

1840

else

1841

{

1841

{

1842

distance = DistanceCalculate(NodeInfo_List[i].X, NodeInfo_List[i].Y, NodeInfo_List[i + 1].X, NodeInfo_List[i + 1].Y);

1842

distance = DistanceCalculate(NodeInfo_List[i].X, NodeInfo_List[i].Y, NodeInfo_List[i + 1].X, NodeInfo_List[i + 1].Y);

1843

}

1843

}

1844

_Content = "MOVE " + distance.ToString() + "mm";

1844

_Content = "MOVE " + distance.ToString() + "mm";

1845

}

1845

}

1846

else

1846

else

1847

{

1847

{

1848

_Content = s.Split(delimiterChars)[0] + " " + s.Split(delimiterChars)[1];

1848

_Content = s.Split(delimiterChars)[0] + " " + s.Split(delimiterChars)[1];

1849

}

1849

}

1850

1851

AddLabeltoGrid(_RowIdx, 1, _Content);

1851

AddLabeltoGrid(_RowIdx, 1, _Content);

1852

}

1852

}

1853

}

1853

}

1854

1855

if (ni.Mode2 != "" && ni.Mode2 != null)

1855

if (ni.Mode2 != "" && ni.Mode2 != null)

1856

{

1856

{

1857

char delimiterChars = '_';

1857

char delimiterChars = '_';

1858

string[] tmp = ni.Mode2.Split(delimiterChars);

1858

string[] tmp = ni.Mode2.Split(delimiterChars);

1859

foreach (string s in tmp)

1859

foreach (string s in tmp)

1860

{

1860

{

1861

_RowIdx++;

1861

_RowIdx++;

1862

delimiterChars = ':';

1862

delimiterChars = ':';

1863

1864

if (s.Split(delimiterChars)[0] == "Mode")

1864

if (s.Split(delimiterChars)[0] == "Mode")

1865

{

1865

{

1866

double distance = 0;

1866

double distance = 0;

1867

if (i == NodeInfo_List.Count - 1)

1867

if (i == NodeInfo_List.Count - 1)

1868

{

1868

{

1869

distance = 0;

1869

distance = 0;

1870

}

1870

}

1871

else

1871

else

1872

{

1872

{

1873

distance = DistanceCalculate(NodeInfo_List[i].X, NodeInfo_List[i].Y, NodeInfo_List[i + 1].X, NodeInfo_List[i + 1].Y);

1873

distance = DistanceCalculate(NodeInfo_List[i].X, NodeInfo_List[i].Y, NodeInfo_List[i + 1].X, NodeInfo_List[i + 1].Y);

1874

}

1874

}

1875

_Content = "MOVE " + distance.ToString() + "mm";

1875

_Content = "MOVE " + distance.ToString() + "mm";

1876

}

1876

}

1877

else

1877

else

1878

{

1878

{

1879

_Content = s.Split(delimiterChars)[0] + " " + s.Split(delimiterChars)[1];

1879

_Content = s.Split(delimiterChars)[0] + " " + s.Split(delimiterChars)[1];

1880

}

1880

}

1881

1882

AddLabeltoGrid(_RowIdx, 1, _Content);

1882

AddLabeltoGrid(_RowIdx, 1, _Content);

1883

}

1883

}

1884

}

1884

}

1885

1886

if (ni.Mode3 != "" && ni.Mode3 != null)

1886

if (ni.Mode3 != "" && ni.Mode3 != null)

1887

{

1887

{

1888

char delimiterChars = '_';

1888

char delimiterChars = '_';

1889

string[] tmp = ni.Mode3.Split(delimiterChars);

1889

string[] tmp = ni.Mode3.Split(delimiterChars);

1890

foreach (string s in tmp)

1890

foreach (string s in tmp)

1891

{

1891

{

1892

_RowIdx++;

1892

_RowIdx++;

1893

delimiterChars = ':';

1893

delimiterChars = ':';

1894

1895

if (s.Split(delimiterChars)[0] == "Mode")

1895

if (s.Split(delimiterChars)[0] == "Mode")

1896

{

1896

{

1897

double distance = 0;

1897

double distance = 0;

1898

if (i == NodeInfo_List.Count - 1)

1898

if (i == NodeInfo_List.Count - 1)

1899

{

1899

{

1900

distance = 0;

1900

distance = 0;

1901

}

1901

}

1902

else

1902

else

1903

{

1903

{

1904

distance = DistanceCalculate(NodeInfo_List[i].X, NodeInfo_List[i].Y, NodeInfo_List[i + 1].X, NodeInfo_List[i + 1].Y);

1904

distance = DistanceCalculate(NodeInfo_List[i].X, NodeInfo_List[i].Y, NodeInfo_List[i + 1].X, NodeInfo_List[i + 1].Y);

1905

}

1905

}

1906

_Content = "MOVE " + distance.ToString() + "mm";

1906

_Content = "MOVE " + distance.ToString() + "mm";

1907

}

1907

}

1908

else

1908

else

1909

{

1909

{

1910

_Content = s.Split(delimiterChars)[0] + " " + s.Split(delimiterChars)[1];

1910

_Content = s.Split(delimiterChars)[0] + " " + s.Split(delimiterChars)[1];

1911

}

1911

}

1912

1913

AddLabeltoGrid(_RowIdx, 1, _Content);

1913

AddLabeltoGrid(_RowIdx, 1, _Content);

1914

}

1914

}

1915

}

1915

}

1916

_RowIdx++;

1916

_RowIdx++;

1917

}

1917

}

1918

}

1918

}

1919

}

1919

}

1920

1921

public double DistanceCalculate(double _X1, double _Y1, double _X2, double _Y2)

1921

public double DistanceCalculate(double _X1, double _Y1, double _X2, double _Y2)

1922

{

1922

{

1923

double dist = 0;

1923

double dist = 0;

1924

1925

if (_X1 == _X2)

1925

if (_X1 == _X2)

1926

{

1926

{

1927

dist = System.Math.Abs(_Y1 - _Y2) * DISTANCE_RATIO;

1927

dist = System.Math.Abs(_Y1 - _Y2) * DISTANCE_RATIO;

1928

}

1928

}

1929

else if (_Y1 == _Y2)

1929

else if (_Y1 == _Y2)

1930

{

1930

{

1931

dist = System.Math.Abs(_X1 - _X2) * DISTANCE_RATIO;

1931

dist = System.Math.Abs(_X1 - _X2) * DISTANCE_RATIO;

1932

}

1932

}

1933

return dist;

1933

return dist;

1934

}

1934

}

1935

1936

public void AddLabeltoGrid(int RowIdx, int ColIdx, string Content)

1936

public void AddLabeltoGrid(int RowIdx, int ColIdx, string Content)

1937

{

1937

{

1938

//Add Row to Grid

1938

//Add Row to Grid

1939

RowDefinition _rd = new RowDefinition();

1939

RowDefinition _rd = new RowDefinition();

1940

((RoboforkMenu)System.Windows.Application.Current.MainWindow).grdRouteInfo.RowDefinitions.Add(_rd);

1940

((RoboforkMenu)System.Windows.Application.Current.MainWindow).grdRouteInfo.RowDefinitions.Add(_rd);

1941

1942

// Add data to Grid

1942

// Add data to Grid

1943

Label dynamicLabel = new Label();

1943

Label dynamicLabel = new Label();

1944

1945

dynamicLabel.Content = Content;

1945

dynamicLabel.Content = Content;

1946

dynamicLabel.Margin = new Thickness(0, 0, 0, 0);

1946

dynamicLabel.Margin = new Thickness(0, 0, 0, 0);

1947

dynamicLabel.Foreground = new SolidColorBrush(Colors.Black);

1947

dynamicLabel.Foreground = new SolidColorBrush(Colors.Black);

1948

dynamicLabel.Background = new SolidColorBrush(Colors.White);

1948

dynamicLabel.Background = new SolidColorBrush(Colors.White);

1949

dynamicLabel.BorderBrush = new SolidColorBrush(Colors.LightGray);

1949

dynamicLabel.BorderBrush = new SolidColorBrush(Colors.LightGray);

1950

dynamicLabel.BorderThickness = new Thickness(1);

1950

dynamicLabel.BorderThickness = new Thickness(1);

1951

1952

Grid.SetRow(dynamicLabel, RowIdx);

1952

Grid.SetRow(dynamicLabel, RowIdx);

1953

Grid.SetColumn(dynamicLabel, ColIdx);

1953

Grid.SetColumn(dynamicLabel, ColIdx);

1954

((RoboforkMenu)System.Windows.Application.Current.MainWindow).grdRouteInfo.Children.Add(dynamicLabel);

1954

((RoboforkMenu)System.Windows.Application.Current.MainWindow).grdRouteInfo.Children.Add(dynamicLabel);

1955

}

1955

}

1956

#endregion

1956

#endregion

1957

1958

1959

public void CreateGoalPoint()

1959

public void CreateGoalPoint()

1960

{

1960

{

1961

if (isGoalDrawRoute)

1961

if (isGoalDrawRoute)

1962

{

1962

{

1963

return;

1963

return;

1964

}

1964

}

1965

1966

isStartDrawRoute = false;

1966

isStartDrawRoute = false;

1967

if (_goalPoint == null)

1967

if (_goalPoint == null)

1968

{

1968

{

1969

_goalPoint = new ucStartEndButton();

1969

_goalPoint = new ucStartEndButton();

1970

_goalPoint.btnWidth = 50.0;

1970

_goalPoint.btnWidth = 50.0;

1971

_goalPoint.btnHeight = 50.0;

1971

_goalPoint.btnHeight = 50.0;

1972

_goalPoint.buttText = "G";

1972

_goalPoint.buttText = "G";

1973

Canvas.SetLeft(_goalPoint, 675);

1973

Canvas.SetLeft(_goalPoint, 675);

1974

Canvas.SetTop(_goalPoint, 75);

1974

Canvas.SetTop(_goalPoint, 75);

1975

this.Children.Add(_goalPoint);

1975

this.Children.Add(_goalPoint);

1976

}

1976

}

1977

}

1977

}

1978

1979

public void CreateStartPoint()

1979

public void CreateStartPoint()

1980

{

1980

{

1981

if (isGoalDrawRoute)

1981

if (isGoalDrawRoute)

1982

{

1982

{

1983

return;

1983

return;

1984

}

1984

}

1985

1986

isStartDrawRoute = false;

1986

isStartDrawRoute = false;

1987

if (_startPoint == null)

1987

if (_startPoint == null)

1988

{

1988

{

1989

_startPoint = new ucStartEndButton();

1989

_startPoint = new ucStartEndButton();

1990

_startPoint.btnWidth = 50.0;

1990

_startPoint.btnWidth = 50.0;

1991

_startPoint.btnHeight = 50.0;

1991

_startPoint.btnHeight = 50.0;

1992

_startPoint.buttText = "S";

1992

_startPoint.buttText = "S";

1993

Canvas.SetLeft(_startPoint, 75);

1993

Canvas.SetLeft(_startPoint, 75);

1994

Canvas.SetTop(_startPoint, 675);

1994

Canvas.SetTop(_startPoint, 675);

1995

this.Children.Add(_startPoint);

1995

this.Children.Add(_startPoint);

1996

}

1996

}

1997

}

1997

}

1998

1999

2000

#region Draw New FreeNode

2000

#region Draw New FreeNode

2001

2002

/// <summary>

2002

/// <summary>

2003

/// Draw Auto Blue node

2003

/// Draw Auto Blue node

2004

/// </summary>

2004

/// </summary>

2005

2006

2007

public void NewSetFreeNodes(Point FreeNode, bool RightClick)

2007

public void NewSetFreeNodes(Point FreeNode, bool RightClick)

2008

{

2008

{

2009

double radiusNode = RADIUS_NODE;

2009

double radiusNode = RADIUS_NODE;

2010

2011

EllipseGeometry ellipseGeometry;

2011

EllipseGeometry ellipseGeometry;

2012

Point node;

2012

Point node;

2013

bool deleteFlag = false;

2013

bool deleteFlag = false;

2014

2015

2016

if (RightClick)

2016

if (RightClick)

2017

{

2017

{

2018

if (gGrpBlueNode.Children.Count > 0)

2018

if (gGrpBlueNode.Children.Count > 0)

2019

{

2019

{

2020

for (int i = 0; i < gGrpBlueNode.Children.Count; i++)

2020

for (int i = 0; i < gGrpBlueNode.Children.Count; i++)

2021

{

2021

{

2022

ellipseGeometry = (EllipseGeometry)gGrpBlueNode.Children[i];

2022

ellipseGeometry = (EllipseGeometry)gGrpBlueNode.Children[i];

2023

node = ellipseGeometry.Center;

2023

node = ellipseGeometry.Center;

2024

if (FreeNode.X == node.X)

2024

if (FreeNode.X == node.X)

2025

{

2025

{

2026

if (CheckIsNode(FreeNode, node, radiusNode))

2026

if (CheckIsNode(FreeNode, node, radiusNode))

2027

{

2027

{

2028

deleteFlag = true;

2028

deleteFlag = true;

2029

}

2029

}

2030

}

2030

}

2031

else

2031

else

2032

{

2032

{

2033

if (CheckIsNode(FreeNode, node, radiusNode))

2033

if (CheckIsNode(FreeNode, node, radiusNode))

2034

{

2034

{

2035

deleteFlag = true;

2035

deleteFlag = true;

2036

}

2036

}

2037

}

2037

}

2038

if (deleteFlag)

2038

if (deleteFlag)

2039

{

2039

{

2040

MessageBoxResult result = MessageBox.Show("Do You Delete This Node?", "Delete Node", MessageBoxButton.OKCancel);

2040

MessageBoxResult result = MessageBox.Show("Do You Delete This Node?", "Delete Node", MessageBoxButton.OKCancel);

2041

if (result == MessageBoxResult.OK)

2041

if (result == MessageBoxResult.OK)

2042

{

2042

{

2043

//Call Function Delete Node

2043

//Call Function Delete Node

2044

DeleteNode(i);

2044

DeleteNode(i);

2045

2046

return;

2046

return;

2047

}

2047

}

2048

else

2048

else

2049

{

2049

{

2050

return;

2050

return;

2051

}

2051

}

2052

}

2052

}

2053

}

2053

}

2054

}

2054

}

2055

}

2055

}

2056

else

2056

else

2057

{

2057

{

2058

//Check EditNode State

2058

//Check EditNode State

2059

for (int i = 0; i < gGrpBlueNode.Children.Count; i++)

2059

for (int i = 0; i < gGrpBlueNode.Children.Count; i++)

2060

{

2060

{

2061

ellipseGeometry = (EllipseGeometry)gGrpBlueNode.Children[i];

2061

ellipseGeometry = (EllipseGeometry)gGrpBlueNode.Children[i];

2062

node = ellipseGeometry.Center;

2062

node = ellipseGeometry.Center;

2063

bool isEditNode = CheckIsNode(FreeNode, node, RADIUS_NODE);

2063

bool isEditNode = CheckIsNode(FreeNode, node, RADIUS_NODE);

2064

2065

if (isEditNode)

2065

if (isEditNode)

2066

{

2066

{

2067

NewEditNode(node);

2067

NewEditNode(node);

2068

NewDspRouteInfo();

2068

NewDspRouteInfo();

2069

return;

2069

return;

2070

}

2070

}

2071

}

2071

}

2072

2073

2074

MessageBoxResult result = MessageBox.Show("Do You Want To Add This Node?", "Add Node", MessageBoxButton.OKCancel);

2074

MessageBoxResult result = MessageBox.Show("Do You Want To Add This Node?", "Add Node", MessageBoxButton.OKCancel);

2075

if (result == MessageBoxResult.OK)

2075

if (result == MessageBoxResult.OK)

2076

{

2076

{

2077

AddNode(FreeNode, gGrpBlueNode);

2077

AddNode(FreeNode, gGrpBlueNode);

2078

2079

TextBlock textBlock = new TextBlock();

2079

TextBlock textBlock = new TextBlock();

2080

textBlock.Text = stt.ToString();

2080

textBlock.Text = stt.ToString();

2081

textBlock.FontSize = 35;

2081

textBlock.FontSize = 35;

2082

textBlock.VerticalAlignment = VerticalAlignment.Center;

2082

textBlock.VerticalAlignment = VerticalAlignment.Center;

2083

textBlock.HorizontalAlignment = HorizontalAlignment.Center;

2083

textBlock.HorizontalAlignment = HorizontalAlignment.Center;

2084

textBlock.Foreground = new SolidColorBrush(Colors.Red);

2084

textBlock.Foreground = new SolidColorBrush(Colors.Red);

2085

2086

Canvas.SetLeft(textBlock, FreeNode.X - RADIUS_NODE / 2);

2086

Canvas.SetLeft(textBlock, FreeNode.X - RADIUS_NODE / 2);

2087

Canvas.SetTop(textBlock, FreeNode.Y - 1.5 * RADIUS_NODE);

2087

Canvas.SetTop(textBlock, FreeNode.Y - 1.5 * RADIUS_NODE);

2088

2089

2090

this.Children.Add(textBlock);

2090

this.Children.Add(textBlock);

2091

NodeNo.Add(textBlock);

2091

NodeNo.Add(textBlock);

2092

2093

if (stt > 1)

2093

if (stt > 1)

2094

{

2094

{

2095

int tmp = gGrpBlueNode.Children.Count;

2095

int tmp = gGrpBlueNode.Children.Count;

2096

2097

EllipseGeometry elip = (EllipseGeometry)gGrpBlueNode.Children[tmp - 2];

2097

EllipseGeometry elip = (EllipseGeometry)gGrpBlueNode.Children[tmp - 2];

2098

Point node1 = elip.Center;

2098

Point node1 = elip.Center;

2099

elip = (EllipseGeometry)gGrpBlueNode.Children[tmp - 1];

2099

elip = (EllipseGeometry)gGrpBlueNode.Children[tmp - 1];

2100

Point node2 = elip.Center;

2100

Point node2 = elip.Center;

2101

DrawLine(node1, node2, gGrpNewLine);

2101

DrawLine(node1, node2, gGrpNewLine);

2102

2103

2104

this.Children.Remove(pBlueNode);

2104

this.Children.Remove(pBlueNode);

2105

for (int i = 0; i < tmp; i++)

2105

for (int i = 0; i < tmp; i++)

2106

{

2106

{

2107

this.Children.Remove(NodeNo[i]);

2107

this.Children.Remove(NodeNo[i]);

2108

}

2108

}

2109

2110

this.Children.Add(pBlueNode);

2110

this.Children.Add(pBlueNode);

2111

for (int i = 0; i < tmp; i++)

2111

for (int i = 0; i < tmp; i++)

2112

{

2112

{

2113

this.Children.Add(NodeNo[i]);

2113

this.Children.Add(NodeNo[i]);

2114

}

2114

}

2115

}

2115

}

2116

2117

stt++;

2117

stt++;

2118

NewInitNodeInfo_List();

2118

NewInitNodeInfo_List();

2119

NewDspRouteInfo();

2119

NewDspRouteInfo();

2120

}

2120

}

2121

}

2121

}

2122

}

2122

}

2123

2124

public void DeleteNode(int i)

2124

public void DeleteNode(int i)

2125

{

2125

{

2126

//DrawLine(Point startPoint, Point endPoint, GeometryGroup geometryGroup)

2126

//DrawLine(Point startPoint, Point endPoint, GeometryGroup geometryGroup)

2127

2128

LineGeometry lineGeometry = new LineGeometry();

2128

LineGeometry lineGeometry = new LineGeometry();

2129

EllipseGeometry ellip;

2129

EllipseGeometry ellip;

2130

2131

//check delete last node

2131

//check delete last node

2132

if (i == gGrpBlueNode.Children.Count - 1)

2132

if (i == gGrpBlueNode.Children.Count - 1)

2133

{

2133

{

2134

// delete line

2134

// delete line

2135

if (gGrpNewLine.Children.Count > 0)

2135

if (gGrpNewLine.Children.Count > 0)

2136

{

2136

{

2137

gGrpNewLine.Children.RemoveAt(i - 1);

2137

gGrpNewLine.Children.RemoveAt(i - 1);

2138

}

2138

}

2139

2140

// delete ucNode

2140

// delete ucNode

2141

ucNode _ucNode = new ucNode();

2141

ucNode _ucNode = new ucNode();

2142

_ucNode = ucNode_Lst[i];

2142

_ucNode = ucNode_Lst[i];

2143

this.Children.Remove(_ucNode);

2143

this.Children.Remove(_ucNode);

2144

ucNode_Lst.RemoveAt(i);

2144

ucNode_Lst.RemoveAt(i);

2145

2146

// delete node

2146

// delete node

2147

gGrpBlueNode.Children.RemoveAt(i);

2147

gGrpBlueNode.Children.RemoveAt(i);

2148

NewNodeInfo_List.RemoveAt(i);

2148

NewNodeInfo_List.RemoveAt(i);

2149

2150

}

2150

}

2151

else

2151

else

2152

{

2152

{

2153

//delete all line and remove Point at 'i'

2153

//delete all line and remove Point at 'i'

2154

gGrpNewLine.Children.Clear();

2154

gGrpNewLine.Children.Clear();

2155

this.Children.Remove(pNewLine);

2155

this.Children.Remove(pNewLine);

2156

gGrpBlueNode.Children.RemoveAt(i);

2156

gGrpBlueNode.Children.RemoveAt(i);

2157

2158

//redraw line

2158

//redraw line

2159

for (int j = 0; j < gGrpBlueNode.Children.Count - 1; j++)

2159

for (int j = 0; j < gGrpBlueNode.Children.Count - 1; j++)

2160

{

2160

{

2161

ellip = (EllipseGeometry)gGrpBlueNode.Children[j];

2161

ellip = (EllipseGeometry)gGrpBlueNode.Children[j];

2162

Point node1 = ellip.Center;

2162

Point node1 = ellip.Center;

2163

ellip = (EllipseGeometry)gGrpBlueNode.Children[j + 1];

2163

ellip = (EllipseGeometry)gGrpBlueNode.Children[j + 1];

2164

Point node2 = ellip.Center;

2164

Point node2 = ellip.Center;

2165

DrawLine(node1, node2, gGrpNewLine);

2165

DrawLine(node1, node2, gGrpNewLine);

2166

}

2166

}

2167

2168

this.Children.Add(pNewLine);

2168

this.Children.Add(pNewLine);

2169

2170

//remove ucNode

2170

//remove ucNode

2171

for (int j = ucNode_Lst.Count - 1; j > i; j--)

2171

for (int j = ucNode_Lst.Count - 1; j > i; j--)

2172

{

2172

{

2173

ucNode_Lst[j].txtNode = ucNode_Lst[j - 1].txtNode;

2173

ucNode_Lst[j].txtNode = ucNode_Lst[j - 1].txtNode;

2174

}

2174

}

2175

this.Children.Remove(ucNode_Lst[i]);

2175

this.Children.Remove(ucNode_Lst[i]);

2176

ucNode_Lst.RemoveAt(i);

2176

ucNode_Lst.RemoveAt(i);

2177

2178

//redraw ucNode

2178

//redraw ucNode

2179

for (int k = 0; k < ucNode_Lst.Count; k++)

2179

for (int k = 0; k < ucNode_Lst.Count; k++)

2180

{

2180

{

2181

this.Children.Remove(ucNode_Lst[k]);

2181

this.Children.Remove(ucNode_Lst[k]);

2182

this.Children.Add(ucNode_Lst[k]);

2182

this.Children.Add(ucNode_Lst[k]);

2183

}

2183

}

2184

}

2184

}

2185

2186

//NewInitNodeInfo_List();

2186

//NewInitNodeInfo_List();

2187

2188

Lst_Node_tmp.RemoveAt(i);

2188

Lst_Node_tmp.RemoveAt(i);

2189

NewDspRouteInfo();

2189

NewDspRouteInfo();

2190

stt--;

2190

stt--;

2191

2192

}

2192

}

2193

2194

public void ReDrawAllNode()

2194

public void ReDrawAllNode()

2195

{

2195

{

2196

LineGeometry lineGeometry = new LineGeometry();

2196

LineGeometry lineGeometry = new LineGeometry();

2197

EllipseGeometry ellip;

2197

EllipseGeometry ellip;

2198

//delete all line

2198

//delete all line

2199

gGrpNewLine.Children.Clear();

2199

gGrpNewLine.Children.Clear();

2200

this.Children.Remove(pNewLine);

2200

this.Children.Remove(pNewLine);

2201

2202

//redraw line

2202

//redraw line

2203

for (int j = 0; j < gGrpBlueNode.Children.Count - 1; j++)

2203

for (int j = 0; j < gGrpBlueNode.Children.Count - 1; j++)

2204

{

2204

{

2205

ellip = (EllipseGeometry)gGrpBlueNode.Children[j];

2205

ellip = (EllipseGeometry)gGrpBlueNode.Children[j];

2206

Point node1 = ellip.Center;

2206

Point node1 = ellip.Center;

2207

ellip = (EllipseGeometry)gGrpBlueNode.Children[j + 1];

2207

ellip = (EllipseGeometry)gGrpBlueNode.Children[j + 1];

2208

Point node2 = ellip.Center;

2208

Point node2 = ellip.Center;

2209

DrawLine(node1, node2, gGrpNewLine);

2209

DrawLine(node1, node2, gGrpNewLine);

2210

}

2210

}

2211

2212

this.Children.Add(pNewLine);

2212

this.Children.Add(pNewLine);

2213

2214

2215

//redraw ucNode

2215

//redraw ucNode

2216

for (int k = 0; k < ucNode_Lst.Count; k++)

2216

for (int k = 0; k < ucNode_Lst.Count; k++)

2217

{

2217

{

2218

this.Children.Remove(ucNode_Lst[k]);

2218

this.Children.Remove(ucNode_Lst[k]);

2219

this.Children.Add(ucNode_Lst[k]);

2219

this.Children.Add(ucNode_Lst[k]);

2220

}

2220

}

2221

2222

//backup DB

2222

//backup DB

2223

CreateVehicleNode();

2223

CreateVehicleNode();

2224

}

2224

}

2225

2226

2227

public void NewInitNodeInfo_List()

2227

public void NewInitNodeInfo_List()

2228

{

2228

{

2229

//Reset List

2229

//Reset List

2230

//NewNodeInfo_List = new List<NewNodeInfo>();

2230

//NewNodeInfo_List = new List<NewNodeInfo>();

2231

2232

if (gGrpBlueNode.Children.Count > 0)

2232

if (gGrpBlueNode.Children.Count > 0)

2233

{

2233

{

2234

//for (int i = 0; i < gGrpBlueNode.Children.Count; i++)

2234

//for (int i = 0; i < gGrpBlueNode.Children.Count; i++)

2235

//{

2235

//{

2236

int i = gGrpBlueNode.Children.Count - 1;

2236

int i = gGrpBlueNode.Children.Count - 1;

2237

Point point;

2237

Point point;

2238

EllipseGeometry eGeometry = (EllipseGeometry)gGrpBlueNode.Children[i];

2238

EllipseGeometry eGeometry = (EllipseGeometry)gGrpBlueNode.Children[i];

2239

point = eGeometry.Center;

2239

point = eGeometry.Center;

2240

2241

NewNodeInfo Ninfo = new NewNodeInfo();

2241

NewNodeInfo Ninfo = new NewNodeInfo();

2242

Ninfo.X = point.X;

2242

Ninfo.X = point.X;

2243

Ninfo.Y = point.Y;

2243

Ninfo.Y = point.Y;

2244

2245

Ninfo.Mode = "";

2245

Ninfo.Mode = "";

2246

2247

NewNodeInfo_List.Add(Ninfo);

2247

NewNodeInfo_List.Add(Ninfo);

2248

//}

2248

//}

2249

2250

}

2250

}

2251

}

2251

}

2252

2253

public void NewEditNode(Point node_edited)

2253

public void NewEditNode(Point node_edited)

2254

{

2254

{

2255

EllipseGeometry ellipseGeometry;

2255

EllipseGeometry ellipseGeometry;

2256

Point node;

2256

Point node;

2257

double radiusNode = RADIUS_NODE;

2257

double radiusNode = RADIUS_NODE;

2258

2259

bool flag = false;

2259

bool flag = false;

2260

2261

if (gGrpBlueNode.Children.Count > 0)

2261

if (gGrpBlueNode.Children.Count > 0)

2262

{

2262

{

2263

for (int i = 0; i < gGrpBlueNode.Children.Count; i++)

2263

for (int i = 0; i < gGrpBlueNode.Children.Count; i++)

2264

{

2264

{

2265

ellipseGeometry = (EllipseGeometry)gGrpBlueNode.Children[i];

2265

ellipseGeometry = (EllipseGeometry)gGrpBlueNode.Children[i];

2266

node = ellipseGeometry.Center;

2266

node = ellipseGeometry.Center;

2267

2268

if (CheckIsNode(node_edited, node, radiusNode))

2268

if (CheckIsNode(node_edited, node, radiusNode))

2269

{

2269

{

2270

flag = true;

2270

flag = true;

2271

}

2271

}

2272

2273

if (flag)

2273

if (flag)

2274

{

2274

{

2275

node_edited.X = node.X;

2275

node_edited.X = node.X;

2276

node_edited.Y = node.Y;

2276

node_edited.Y = node.Y;

2277

2278

// show form edit node

2278

// show form edit node

2279

EditNodeWindow edtNodeWindow = new EditNodeWindow();

2279

EditNodeWindow edtNodeWindow = new EditNodeWindow();

2280

edtNodeWindow.ShowDialog();

2280

edtNodeWindow.ShowDialog();

2281

2282

string result = edtNodeWindow._txtMode;

2282

string result = edtNodeWindow._txtMode;

2283

2284

2285

List<EditNodeWindow.NodeInf> tmp = edtNodeWindow.NodeInf_List;

2285

List<EditNodeWindow.NodeInf> tmp = edtNodeWindow.NodeInf_List;

2286

2287

for (int j = 0; j < tmp.Count; j++)

2287

for (int j = 0; j < tmp.Count; j++)

2288

{

2288

{

2289

EditNodeWindow.NodeInf ni = new EditNodeWindow.NodeInf();

2289

EditNodeWindow.NodeInf ni = new EditNodeWindow.NodeInf();

2290

ni.Mode = tmp[j].Mode;

2290

ni.Mode = tmp[j].Mode;

2291

ni.Speed = tmp[j].Speed;

2291

ni.Speed = tmp[j].Speed;

2292

ni.Angle = tmp[j].Angle;

2292

ni.Angle = tmp[j].Angle;

2293

ni.Height = tmp[j].Height;

2293

ni.Height = tmp[j].Height;

2294

2295

2296

ListNodeInfo NodeInfo_tmp = new ListNodeInfo();

2296

ListNodeInfo NodeInfo_tmp = new ListNodeInfo();

2297

2298

NodeInfo_tmp.Mode = ni.Mode;

2298

NodeInfo_tmp.Mode = ni.Mode;

2299

NodeInfo_tmp.Speed = ni.Speed;

2299

NodeInfo_tmp.Speed = ni.Speed;

2300

NodeInfo_tmp.Angle = ni.Angle;

2300

NodeInfo_tmp.Angle = ni.Angle;

2301

NodeInfo_tmp.Height = ni.Height;

2301

NodeInfo_tmp.Height = ni.Height;

2302

2303

Lst_Node_tmp[i].NodeInfo_tmp.Add(NodeInfo_tmp);

2303

Lst_Node_tmp[i].NodeInfo_tmp.Add(NodeInfo_tmp);

2304

}

2304

}

2305

2306

2307

//backup DB

2307

//backup DB

2308

CreateVehicleNode();

2308

CreateVehicleNode();

2309

2310

2311

2312

2313

bool exit = edtNodeWindow._ExitFlg;

2313

bool exit = edtNodeWindow._ExitFlg;

2314

2315

if (!exit)

2315

if (!exit)

2316

{

2316

{

2317

NewSaveChanged(node_edited.X, node_edited.Y, result);

2317

NewSaveChanged(node_edited.X, node_edited.Y, result);

2318

}

2318

}

2319

2320

return;

2320

return;

2321

}

2321

}

2322

}

2322

}

2323

}

2323

}

2324

}

2324

}

2325

2326

//Save Node's Data Edited

2326

//Save Node's Data Edited

2327

public void NewSaveChanged(double x, double y, string st)

2327

public void NewSaveChanged(double x, double y, string st)

2328

{

2328

{

2329

for (int i = 0; i < NewNodeInfo_List.Count; i++)

2329

for (int i = 0; i < NewNodeInfo_List.Count; i++)

2330

{

2330

{

2331

NewNodeInfo ni = new NewNodeInfo();

2331

NewNodeInfo ni = new NewNodeInfo();

2332

ni = NewNodeInfo_List[i];

2332

ni = NewNodeInfo_List[i];

2333

2334

if (ni.X == x && ni.Y == y)

2334

if (ni.X == x && ni.Y == y)

2335

{

2335

{

2336

ni.Mode = st;

2336

ni.Mode = st;

2337

2338

NewNodeInfo_List[i] = ni;

2338

NewNodeInfo_List[i] = ni;

2339

return;

2339

return;

2340

}

2340

}

2341

}

2341

}

2342

}

2342

}

2343

2344

public void NewDspRouteInfo()

2344

public void NewDspRouteInfo()

2345

{

2345

{

2346

//Clear Route Info Table

2346

//Clear Route Info Table

2347

((RoboforkMenu)System.Windows.Application.Current.MainWindow).grdRouteInfo.Children.Clear();

2347

((RoboforkMenu)System.Windows.Application.Current.MainWindow).grdRouteInfo.Children.Clear();

2348

int _RowIdx = 0;

2348

int _RowIdx = 0;

2349

string _Content = "";

2349

string _Content = "";

2350

2351

if (Lst_Node_tmp.Count != 0)

2351

if (Lst_Node_tmp.Count != 0)

2352

{

2352

{

2353

for (int i = 0; i < Lst_Node_tmp.Count; i++)

2353

for (int i = 0; i < Lst_Node_tmp.Count; i++)

2354

{

2354

{

2355

//column 1 : node index

2355

//column 1 : node index

2356

_Content = (i + 1).ToString();

2356

_Content = (i + 1).ToString();

2357

AddLabeltoGrid(_RowIdx, 0, _Content);

2357

AddLabeltoGrid(_RowIdx, 0, _Content);

2358

2359

//column 2

2359

//column 2

2360

// Display Node's Position

2360

// Display Node's Position

2361

_Content = "LAT " + Lst_Node_tmp[i].pointMap_X;

2361

_Content = "LAT " + Lst_Node_tmp[i].pointMap_X;

2362

AddLabeltoGrid(_RowIdx, 1, _Content);

2362

AddLabeltoGrid(_RowIdx, 1, _Content);

2363

_RowIdx++;

2363

_RowIdx++;

2364

2365

_Content = "LOC " + Lst_Node_tmp[i].pointMap_Y;

2365

_Content = "LOC " + Lst_Node_tmp[i].pointMap_Y;

2366

AddLabeltoGrid(_RowIdx, 1, _Content);

2366

AddLabeltoGrid(_RowIdx, 1, _Content);

2367

2368

// Display Node's Field

2368

// Display Node's Field

2369

if (Lst_Node_tmp[i].NodeInfo_tmp.Count != 0)

2369

if (Lst_Node_tmp[i].NodeInfo_tmp.Count != 0)

2370

{

2370

{

2371

foreach (ListNodeInfo ni in Lst_Node_tmp[i].NodeInfo_tmp)

2371

foreach (ListNodeInfo ni in Lst_Node_tmp[i].NodeInfo_tmp)

2372

{

2372

{

2373

if (ni.Speed != 0)

2373

if (ni.Speed != 0)

2374

{

2374

{

2375

_RowIdx++;

2375

_RowIdx++;

2376

_Content = "SPD " + ni.Speed.ToString() + " Km/h";

2376

_Content = "SPD " + ni.Speed.ToString() + " Km/h";

2377

AddLabeltoGrid(_RowIdx, 1, _Content);

2377

AddLabeltoGrid(_RowIdx, 1, _Content);

2378

}

2378

}

2379

}

2379

}

2380

2381

}

2381

}

2382

_RowIdx++;

2382

_RowIdx++;

2383

}

2383

}

2384

2385

}

2385

}

2386

2387

}

2387

}

2388

2389

2390

//2017/03/07 tach rieng CreateNode start

2390

//2017/03/07 tach rieng CreateNode start

2391

private void execDeleteNode(Point FreeNode)

2391

private void execDeleteNode(Point FreeNode)

2392

{

2392

{

2393

2394

double radiusNode = RADIUS_NODE;

2394

double radiusNode = RADIUS_NODE;

2395

2396

EllipseGeometry ellipseGeometry;

2396

EllipseGeometry ellipseGeometry;

2397

Point node;

2397

Point node;

2398

bool deleteFlag = false;

2398

bool deleteFlag = false;

2399

2400

if (gGrpBlueNode.Children.Count > 0)

2400

if (gGrpBlueNode.Children.Count > 0)

2401

{

2401

{

2402

for (int i = 0; i < gGrpBlueNode.Children.Count; i++)

2402

for (int i = 0; i < gGrpBlueNode.Children.Count; i++)

2403

{

2403

{

2404

ellipseGeometry = (EllipseGeometry)gGrpBlueNode.Children[i];

2404

ellipseGeometry = (EllipseGeometry)gGrpBlueNode.Children[i];

2405

node = ellipseGeometry.Center;

2405

node = ellipseGeometry.Center;

2406

if (FreeNode.X == node.X)

2406

if (FreeNode.X == node.X)

2407

{

2407

{

2408

if (CheckIsNode(FreeNode, node, radiusNode))

2408

if (CheckIsNode(FreeNode, node, radiusNode))

2409

{

2409

{

2410

deleteFlag = true;

2410

deleteFlag = true;

2411

}

2411

}

2412

}

2412

}

2413

else

2413

else

2414

{

2414

{

2415

if (CheckIsNode(FreeNode, node, radiusNode))

2415

if (CheckIsNode(FreeNode, node, radiusNode))

2416

{

2416

{

2417

deleteFlag = true;

2417

deleteFlag = true;

2418

}

2418

}

2419

}

2419

}

2420

if (deleteFlag)

2420

if (deleteFlag)

2421

{

2421

{

2422

MessageBoxResult result = MessageBox.Show("Do You Delete This Node?", "Delete Node", MessageBoxButton.OKCancel);

2422

MessageBoxResult result = MessageBox.Show("Do You Delete This Node?", "Delete Node", MessageBoxButton.OKCancel);

2423

if (result == MessageBoxResult.OK)

2423

if (result == MessageBoxResult.OK)

2424

{

2424

{

2425

DeleteNode(i);

2425

DeleteNode(i);

2426

SetScheduleRoute();

2426

SetScheduleRoute();

2427

2428

return;

2428

return;

2429

}

2429

}

2430

else

2430

else

2431

{

2431

{

2432

return;

2432

return;

2433

}

2433

}

2434

}

2434

}

2435

}

2435

}

2436

}

2436

}

2437

}

2437

}

2438

2439

2440

private void execEditNode(Point FreeNode)

2440

private void execEditNode(Point FreeNode)

2441

{

2441

{

2442

EllipseGeometry ellipseGeometry;

2442

EllipseGeometry ellipseGeometry;

2443

Point node;

2443

Point node;

2444

for (int i = 0; i < gGrpBlueNode.Children.Count; i++)

2444

for (int i = 0; i < gGrpBlueNode.Children.Count; i++)

2445

{

2445

{

2446

ellipseGeometry = (EllipseGeometry)gGrpBlueNode.Children[i];

2446

ellipseGeometry = (EllipseGeometry)gGrpBlueNode.Children[i];

2447

node = ellipseGeometry.Center;

2447

node = ellipseGeometry.Center;

2448

bool isEditNode = CheckIsNode(FreeNode, node, RADIUS_NODE);

2448

bool isEditNode = CheckIsNode(FreeNode, node, RADIUS_NODE);

2449

2450

if (isEditNode)

2450

if (isEditNode)

2451

{

2451

{

2452

NewEditNode(node);

2452

NewEditNode(node);

2453

NewDspRouteInfo();

2453

NewDspRouteInfo();

2454

return;

2454

return;

2455

}

2455

}

2456

}

2456

}

2457

}

2457

}

2458

2459

2460

private void execCreateNode(Point FreeNode)

2460

private void execCreateNode(Point FreeNode)

2461

{

2461

{

2462

//check new node in exist line

2462

//check new node in exist line

2463

if (gGrpNewLine.Children.Count > 0)

2463

if (gGrpNewLine.Children.Count > 0)

2464

{

2464

{

2465

for (int i = 0; i < gGrpNewLine.Children.Count; i++)

2465

for (int i = 0; i < gGrpNewLine.Children.Count; i++)

2466

{

2466

{

2467

LineGeometry lineGeometry = (LineGeometry)gGrpNewLine.Children[i];

2467

LineGeometry lineGeometry = (LineGeometry)gGrpNewLine.Children[i];

2468

Point p1 = lineGeometry.StartPoint;

2468

Point p1 = lineGeometry.StartPoint;

2469

Point p2 = lineGeometry.EndPoint;

2469

Point p2 = lineGeometry.EndPoint;

2470

2471

bool pInL = PointInLine(FreeNode, p1, p2, UCNODE_SETLEFT);

2471

bool pInL = PointInLine(FreeNode, p1, p2, UCNODE_SETLEFT);

2472

2473

if (pInL)

2473

if (pInL)

2474

{

2474

{

2475

MessageBoxResult result = MessageBox.Show("Do You Want To Add This Node?", "Add Node", MessageBoxButton.OKCancel);

2475

MessageBoxResult result = MessageBox.Show("Do You Want To Add This Node?", "Add Node", MessageBoxButton.OKCancel);

2476

if (result == MessageBoxResult.OK)

2476

if (result == MessageBoxResult.OK)

2477

{

2477

{

2478

Point tmpPoint = ConvertNodeinLine(FreeNode, p1, p2);

2478

Point tmpPoint = ConvertNodeinLine(FreeNode, p1, p2);

2479

FreeNode = tmpPoint;

2479

FreeNode = tmpPoint;

2480

2481

CreateMapNode(FreeNode, i + 1, ColorNode_Insert);

2481

CreateMapNode(FreeNode, i + 1, ColorNode_Insert);

2482

gGrpBlueNode.Children.Insert(i + 1, new EllipseGeometry(FreeNode, RADIUS_NODE, RADIUS_NODE));

2482

gGrpBlueNode.Children.Insert(i + 1, new EllipseGeometry(FreeNode, RADIUS_NODE, RADIUS_NODE));

2483

//set location infor to table info

2483

//set location infor to table info

2484

SetLoc_NodeInfoList(FreeNode, i + 1);

2484

SetLoc_NodeInfoList(FreeNode, i + 1);

2485

2486

SetScheduleRoute();

2486

SetScheduleRoute();

2487

2488

ListIndexNodeInsert ListIndex = new ListIndexNodeInsert();

2488

ListIndexNodeInsert ListIndex = new ListIndexNodeInsert();

2489

ListIndex.X = FreeNode.X;

2489

ListIndex.X = FreeNode.X;

2490

ListIndex.Y = FreeNode.Y;

2490

ListIndex.Y = FreeNode.Y;

2491

IndexNodeInsert_List.Add(ListIndex);

2491

IndexNodeInsert_List.Add(ListIndex);

2492

2493

//rename Point textName

2493

//rename Point textName

2494

for (int j = 0; j < ucNode_Lst.Count; j++)

2494

for (int j = 0; j < ucNode_Lst.Count; j++)

2495

{

2495

{

2496

ucNode_Lst[j].txtNode = (j + 1).ToString();

2496

ucNode_Lst[j].txtNode = (j + 1).ToString();

2497

this.Children.Remove(ucNode_Lst[j]);

2497

this.Children.Remove(ucNode_Lst[j]);

2498

this.Children.Add(ucNode_Lst[j]);

2498

this.Children.Add(ucNode_Lst[j]);

2499

}

2499

}

2500

2501

ReDrawAllNode();

2501

ReDrawAllNode();

2502

2503

stt++;

2503

stt++;

2504

NewInitNodeInfo_List();

2504

NewInitNodeInfo_List();

2505

NewDspRouteInfo();

2505

NewDspRouteInfo();

2506

return;

2506

return;

2507

}

2507

}

2508

else

2508

else

2509

{

2509

{

2510

return;

2510

return;

2511

}

2511

}

2512

}

2512

}

2513

}

2513

}

2514

}

2514

}

2515

2516

2517

CreateMapNode(FreeNode, gGrpBlueNode.Children.Count, ColorNode_Add);

2517

CreateMapNode(FreeNode, gGrpBlueNode.Children.Count, ColorNode_Add);

2518

gGrpBlueNode.Children.Insert(gGrpBlueNode.Children.Count, new EllipseGeometry(FreeNode, RADIUS_NODE, RADIUS_NODE));

2518

gGrpBlueNode.Children.Insert(gGrpBlueNode.Children.Count, new EllipseGeometry(FreeNode, RADIUS_NODE, RADIUS_NODE));

2519

//set location infor to table info

2519

//set location infor to table info

2520

SetLoc_NodeInfoList(FreeNode, gGrpBlueNode.Children.Count - 1);

2520

SetLoc_NodeInfoList(FreeNode, gGrpBlueNode.Children.Count - 1);

2521

2522

SetScheduleRoute();

2522

SetScheduleRoute();

2523

2524

//draw line

2524

//draw line

2525

if (stt > 1)

2525

if (stt > 1)

2526

{

2526

{

2527

//delete all line

2527

//delete all line

2528

gGrpNewLine.Children.Clear();

2528

gGrpNewLine.Children.Clear();

2529

this.Children.Remove(pNewLine);

2529

this.Children.Remove(pNewLine);

2530

//redraw line

2530

//redraw line

2531

for (int j = 0; j < gGrpBlueNode.Children.Count - 1; j++)

2531

for (int j = 0; j < gGrpBlueNode.Children.Count - 1; j++)

2532

{

2532

{

2533

EllipseGeometry ellip = (EllipseGeometry)gGrpBlueNode.Children[j];

2533

EllipseGeometry ellip = (EllipseGeometry)gGrpBlueNode.Children[j];

2534

Point node1 = ellip.Center;

2534

Point node1 = ellip.Center;

2535

ellip = (EllipseGeometry)gGrpBlueNode.Children[j + 1];

2535

ellip = (EllipseGeometry)gGrpBlueNode.Children[j + 1];

2536

Point node2 = ellip.Center;

2536

Point node2 = ellip.Center;

2537

DrawLine(node1, node2, gGrpNewLine);

2537

DrawLine(node1, node2, gGrpNewLine);

2538

}

2538

}

2539

2540

this.Children.Add(pNewLine);

2540

this.Children.Add(pNewLine);

2541

2542

//rename Point textName

2542

//rename Point textName

2543

for (int j = 0; j < ucNode_Lst.Count; j++)

2543

for (int j = 0; j < ucNode_Lst.Count; j++)

2544

{

2544

{

2545

ucNode_Lst[j].txtNode = (j + 1).ToString();

2545

ucNode_Lst[j].txtNode = (j + 1).ToString();

2546

this.Children.Remove(ucNode_Lst[j]);

2546

this.Children.Remove(ucNode_Lst[j]);

2547

this.Children.Add(ucNode_Lst[j]);

2547

this.Children.Add(ucNode_Lst[j]);

2548

}

2548

}

2549

}

2549

}

2550

2551

stt++;

2551

stt++;

2552

NewInitNodeInfo_List();

2552

NewInitNodeInfo_List();

2553

NewDspRouteInfo();

2553

NewDspRouteInfo();

2554

}

2554

}

2555

2556

public void CreateMapNode(Point FreeNode, int stt, String Color)

2556

public void CreateMapNode(Point FreeNode, int stt, String Color)

2557

{

2557

{

2558

ucNode _ucNode = new ucNode();

2558

ucNode _ucNode = new ucNode();

2559

_ucNode.btnWidth = UCNODE_WIDTH;

2559

_ucNode.btnWidth = UCNODE_WIDTH;

2560

_ucNode.btnHeight = UCNODE_HEIGHT;

2560

_ucNode.btnHeight = UCNODE_HEIGHT;

2561

2562

_ucNode.txtNode = (stt + 1).ToString();

2562

_ucNode.txtNode = (stt + 1).ToString();

2563

2564

_ucNode.fillColor = Color;

2564

_ucNode.fillColor = Color;

2565

_ucNode.IsDragDelta = true;

2565

_ucNode.IsDragDelta = true;

2566

Canvas.SetLeft(_ucNode, FreeNode.X - UCNODE_SETLEFT);

2566

Canvas.SetLeft(_ucNode, FreeNode.X - UCNODE_SETLEFT);

2567

Canvas.SetTop(_ucNode, FreeNode.Y - UCNODE_SETTOP);

2567

Canvas.SetTop(_ucNode, FreeNode.Y - UCNODE_SETTOP);

2568

this.Children.Add(_ucNode);

2568

this.Children.Add(_ucNode);

2569

//ucNode_Lst.Add(_ucNode);

2569

//ucNode_Lst.Add(_ucNode);

2570

ucNode_Lst.Insert(stt, _ucNode);

2570

ucNode_Lst.Insert(stt, _ucNode);

2571

2572

2573

2574

2575

2576

//AddNode(FreeNode, gGrpBlueNode);

2576

//AddNode(FreeNode, gGrpBlueNode);

2577

//gGrpBlueNode.Children.Insert(stt, new EllipseGeometry(FreeNode, RADIUS_NODE, RADIUS_NODE));

2577

//gGrpBlueNode.Children.Insert(stt, new EllipseGeometry(FreeNode, RADIUS_NODE, RADIUS_NODE));

2578

2579

}

2579

}

2580

2581

public void SetLoc_NodeInfoList(Point FreeNode, int stt)

2581

public void SetLoc_NodeInfoList(Point FreeNode, int stt)

2582

{

2582

{

2583

//add location for NodeInfoList

2583

//add location for NodeInfoList

2584

Node_tmp nodetmp = new Node_tmp();

2584

Node_tmp nodetmp = new Node_tmp();

2585

nodetmp.pointMap_X = FreeNode.X;

2585

nodetmp.pointMap_X = FreeNode.X;

2586

nodetmp.pointMap_Y = FreeNode.Y;

2586

nodetmp.pointMap_Y = FreeNode.Y;

2587

2588

Lst_Node_tmp.Insert(stt, nodetmp);

2588

Lst_Node_tmp.Insert(stt, nodetmp);

2589

2590

}

2590

}

2591

2592

public void BindBlueNode2ucNode()

2592

public void BindBlueNode2ucNode()

2593

{

2593

{

2594

bool NodeIsInsert = false;

2594

bool NodeIsInsert = false;

2595

if (gGrpBlueNode.Children.Count > 0)

2595

if (gGrpBlueNode.Children.Count > 0)

2596

{

2596

{

2597

for (int i = 0; i < gGrpBlueNode.Children.Count; i++)

2597

for (int i = 0; i < gGrpBlueNode.Children.Count; i++)

2598

{

2598

{

2599

NodeIsInsert = false;

2599

NodeIsInsert = false;

2600

EllipseGeometry ellipseGeometry = (EllipseGeometry)gGrpBlueNode.Children[i];

2600

EllipseGeometry ellipseGeometry = (EllipseGeometry)gGrpBlueNode.Children[i];

2601

Point node = ellipseGeometry.Center;

2601

Point node = ellipseGeometry.Center;

2602

2603

//Draw Node Insert Color is Brown

2603

//Draw Node Insert Color is Brown

2604

if (IndexNodeInsert_List.Count > 0)

2604

if (IndexNodeInsert_List.Count > 0)

2605

{

2605

{

2606

for (int j = 0; j < IndexNodeInsert_List.Count; j++)

2606

for (int j = 0; j < IndexNodeInsert_List.Count; j++)

2607

{

2607

{

2608

if (node.X == IndexNodeInsert_List[j].X && node.Y == IndexNodeInsert_List[j].Y)

2608

if (node.X == IndexNodeInsert_List[j].X && node.Y == IndexNodeInsert_List[j].Y)

2609

{

2609

{

2610

NodeIsInsert = true;

2610

NodeIsInsert = true;

2611

}

2611

}

2612

}

2612

}

2613

}

2613

}

2614

if (NodeIsInsert)

2614

if (NodeIsInsert)

2615

{

2615

{

2616

CreateMapNode(node, i, ColorNode_Insert);

2616

CreateMapNode(node, i, ColorNode_Insert);

2617

}

2617

}

2618

else

2618

else

2619

{

2619

{

2620

CreateMapNode(node, i, ColorNode_Add);

2620

CreateMapNode(node, i, ColorNode_Add);

2621

}

2621

}

2622

}

2622

}

2623

}

2623

}

2624

}

2624

}

2625

2626

//2017/03/07 tach CreateNode End

2626

//2017/03/07 tach CreateNode End

2627

2628

2629

public Point ConvertNodeinLine(Point point, Point l1, Point l2)

2629

public Point ConvertNodeinLine(Point point, Point l1, Point l2)

2630

{

2630

{

2631

Point pointResult = new Point();

2631

Point pointResult = new Point();

2632

double X = 0;

2632

double X = 0;

2633

double Y = 0;

2633

double Y = 0;

2634

2635

double distance_Line = 0;

2635

double distance_Line = 0;

2636

double distance_l1ToPoint = 0;

2636

double distance_l1ToPoint = 0;

2637

2638

distance_Line = DistanceTo(l1, l2);

2638

distance_Line = DistanceTo(l1, l2);

2639

distance_l1ToPoint = DistanceTo(l1, point);

2639

distance_l1ToPoint = DistanceTo(l1, point);

2640

2641

2642

if (l1.X == l2.X)

2642

if (l1.X == l2.X)

2643

{

2643

{

2644

X = l1.X;

2644

X = l1.X;

2645

Y = point.Y;

2645

Y = point.Y;

2646

}

2646

}

2647

else if (l1.Y == l2.Y)

2647

else if (l1.Y == l2.Y)

2648

{

2648

{

2649

X = point.X;

2649

X = point.X;

2650

Y = l1.Y;

2650

Y = l1.Y;

2651

}

2651

}

2652

else

2652

else

2653

{

2653

{

2654

if (l1.X < l2.X)

2654

if (l1.X < l2.X)

2655

{

2655

{

2656

if (l1.Y < l2.Y)

2656

if (l1.Y < l2.Y)

2657

{

2657

{

2658

Y = l1.Y + (distance_l1ToPoint * (l2.Y - l1.Y) / distance_Line);

2658

Y = l1.Y + (distance_l1ToPoint * (l2.Y - l1.Y) / distance_Line);

2659

X = l1.X + (distance_l1ToPoint * (l2.X - l1.X) / distance_Line);

2659

X = l1.X + (distance_l1ToPoint * (l2.X - l1.X) / distance_Line);

2660

}

2660

}

2661

else

2661

else

2662

{

2662

{

2663

Y = l1.Y - (distance_l1ToPoint * (l1.Y - l2.Y) / distance_Line);

2663

Y = l1.Y - (distance_l1ToPoint * (l1.Y - l2.Y) / distance_Line);

2664

X = l1.X + (distance_l1ToPoint * (l2.X - l1.X) / distance_Line);

2664

X = l1.X + (distance_l1ToPoint * (l2.X - l1.X) / distance_Line);

2665

}

2665

}

2666

}

2666

}

2667

else

2667

else

2668

{

2668

{

2669

if (l1.Y < l2.Y)

2669

if (l1.Y < l2.Y)

2670

{

2670

{

2671

Y = l1.Y + (distance_l1ToPoint * (l2.Y - l1.Y) / distance_Line);

2671

Y = l1.Y + (distance_l1ToPoint * (l2.Y - l1.Y) / distance_Line);

2672

X = l1.X - (distance_l1ToPoint * (l1.X - l2.X) / distance_Line);

2672

X = l1.X - (distance_l1ToPoint * (l1.X - l2.X) / distance_Line);

2673

}

2673

}

2674

else

2674

else

2675

{

2675

{

2676

Y = l1.Y - (distance_l1ToPoint * (l1.Y - l2.Y) / distance_Line);

2676

Y = l1.Y - (distance_l1ToPoint * (l1.Y - l2.Y) / distance_Line);

2677

X = l1.X - (distance_l1ToPoint * (l1.X - l2.X) / distance_Line);

2677

X = l1.X - (distance_l1ToPoint * (l1.X - l2.X) / distance_Line);

2678

}

2678

}

2679

}

2679

}

2680

2681

2682

}

2682

}

2683

2684

pointResult.X = X;

2684

pointResult.X = X;

2685

pointResult.Y = Y;

2685

pointResult.Y = Y;

2686

return pointResult;

2686

return pointResult;

2687

}

2687

}

2688

2689

public static double DistanceTo(Point point1, Point point2)

2689

public static double DistanceTo(Point point1, Point point2)

2690

{

2690

{

2691

var a = (double)(point2.X - point1.X);

2691

var a = (double)(point2.X - point1.X);

2692

var b = (double)(point2.Y - point1.Y);

2692

var b = (double)(point2.Y - point1.Y);

2693

2694

return Math.Sqrt(a * a + b * b);

2694

return Math.Sqrt(a * a + b * b);

2695

}

2695

}

2696

2697

public bool PointInLine(Point point, Point l1, Point l2, double radius)

2697

public bool PointInLine(Point point, Point l1, Point l2, double radius)

2698

{

2698

{

2699

double distance = 0;

2699

double distance = 0;

2700

bool falg = false;

2700

bool falg = false;

2701

2702

if (l1.X < l2.X)

2702

if (l1.X < l2.X)

2703

{

2703

{

2704

if (l1.Y < l2.Y)

2704

if (l1.Y < l2.Y)

2705

{

2705

{

2706

if (point.X > l1.X - radius && point.X < l2.X + radius && point.Y > l1.Y - radius && point.Y < l2.Y + radius)

2706

if (point.X > l1.X - radius && point.X < l2.X + radius && point.Y > l1.Y - radius && point.Y < l2.Y + radius)

2707

{

2707

{

2708

falg = true;

2708

falg = true;

2709

}

2709

}

2710

}

2710

}

2711

else

2711

else

2712

{

2712

{

2713

if (point.X > l1.X - radius && point.X < l2.X + radius && point.Y < l1.Y + radius && point.Y > l2.Y - radius)

2713

if (point.X > l1.X - radius && point.X < l2.X + radius && point.Y < l1.Y + radius && point.Y > l2.Y - radius)

2714

{

2714

{

2715

falg = true;

2715

falg = true;

2716

}

2716

}

2717

}

2717

}

2718

}

2718

}

2719

else

2719

else

2720

{

2720

{

2721

if (l1.Y < l2.Y)

2721

if (l1.Y < l2.Y)

2722

{

2722

{

2723

if (point.X < l1.X + radius && point.X > l2.X - radius && point.Y > l1.Y - radius && point.Y < l2.Y + radius)

2723

if (point.X < l1.X + radius && point.X > l2.X - radius && point.Y > l1.Y - radius && point.Y < l2.Y + radius)

2724

{

2724

{

2725

falg = true;

2725

falg = true;

2726

}

2726

}

2727

}

2727

}

2728

else

2728

else

2729

{

2729

{

2730

if (point.X < l1.X + radius && point.X > l2.X - radius && point.Y < l1.Y + radius && point.Y > l2.Y - radius)

2730

if (point.X < l1.X + radius && point.X > l2.X - radius && point.Y < l1.Y + radius && point.Y > l2.Y - radius)

2731

{

2731

{

2732

falg = true;

2732

falg = true;

2733

}

2733

}

2734

}

2734

}

2735

}

2735

}

2736

if (falg == false)

2736

if (falg == false)

2737

{

2737

{

2738

return false;

2738

return false;

2739

}

2739

}

2740

2741

distance = DistanceFromPointToLine(point, l1, l2);

2741

distance = DistanceFromPointToLine(point, l1, l2);

2742

2743

if (distance > radius)

2743

if (distance > radius)

2744

{

2744

{

2745

return false;

2745

return false;

2746

}

2746

}

2747

return true;

2747

return true;

2748

}

2748

}

2749

2750

public static double DistanceFromPointToLine(Point point, Point l1, Point l2)

2750

public static double DistanceFromPointToLine(Point point, Point l1, Point l2)

2751

{

2751

{

2752

2753

return Math.Abs((l2.X - l1.X) * (l1.Y - point.Y) - (l1.X - point.X) * (l2.Y - l1.Y)) /

2753

return Math.Abs((l2.X - l1.X) * (l1.Y - point.Y) - (l1.X - point.X) * (l2.Y - l1.Y)) /

2754

Math.Sqrt(Math.Pow(l2.X - l1.X, 2) + Math.Pow(l2.Y - l1.Y, 2));

2754

Math.Sqrt(Math.Pow(l2.X - l1.X, 2) + Math.Pow(l2.Y - l1.Y, 2));

2755

}

2755

}

2756

2757

#endregion

2757

#endregion

2758

2759

#region Schedule

2759

#region Schedule

2760

2761

public void SetScheduleRoute()

2761

public void SetScheduleRoute()

2762

{

2762

{

2763

2764

EllipseGeometry ellipseGeometry_1;

2764

EllipseGeometry ellipseGeometry_1;

2765

EllipseGeometry ellipseGeometry_2;

2765

EllipseGeometry ellipseGeometry_2;

2766

Point node_1;

2766

Point node_1;

2767

Point node_2;

2767

Point node_2;

2768

Point node_Schedule = new Point();

2768

Point node_Schedule = new Point();

2769

double x_1 = 50;

2769

double x_1 = 50;

2770

double y_1 = 80;

2770

double y_1 = 80;

2771

double Totaldistance = 1270;

2771

double Totaldistance = 1270;

2772

2773

2774

if (ucScheduleNode_Lst.Count > 0)

2774

if (ucScheduleNode_Lst.Count > 0)

2775

{

2775

{

2776

for (int i = 0; i < ucScheduleNode_Lst.Count; i++)

2776

for (int i = 0; i < ucScheduleNode_Lst.Count; i++)

2777

{

2777

{

2778

ucNode _ucScheduleNode = new ucNode();

2778

ucNode _ucScheduleNode = new ucNode();

2779

_ucScheduleNode = ucScheduleNode_Lst[i];

2779

_ucScheduleNode = ucScheduleNode_Lst[i];

2780

scheduleCanvas.Children.Remove(_ucScheduleNode);

2780

scheduleCanvas.Children.Remove(_ucScheduleNode);

2781

2782

}

2782

}

2783

ucScheduleNode_Lst.Clear();

2783

ucScheduleNode_Lst.Clear();

2784

}

2784

}

2785

2786

gGrpScheduleNode.Children.Clear();

2786

gGrpScheduleNode.Children.Clear();

2787

gGrpScheduleLine.Children.Clear();

2787

gGrpScheduleLine.Children.Clear();

2788

2789

//Remove existed simulation

2790

if(scheduleCanvas.simulation !=null)

2791

{

2792

scheduleCanvas.Children.Remove(scheduleCanvas.simulation);

2793

}

2788

2794

2789

2795

2790

List<double> distance = new List<double>();

2796

List<double> distance = new List<double>();

2791

double addDistance;

2797

double addDistance;

2792

2798

2793

if (gGrpBlueNode.Children.Count > 0)

2799

if (gGrpBlueNode.Children.Count > 0)

2794

{

2800

{

2795

for (int i = 0; i < gGrpBlueNode.Children.Count; i++)

2801

for (int i = 0; i < gGrpBlueNode.Children.Count; i++)

2796

{

2802

{

2797

ellipseGeometry_2 = (EllipseGeometry)gGrpBlueNode.Children[i];

2803

ellipseGeometry_2 = (EllipseGeometry)gGrpBlueNode.Children[i];

2798

node_2 = ellipseGeometry_2.Center;

2804

node_2 = ellipseGeometry_2.Center;

2799

2805

2800

if (i >= 1)

2806

if (i >= 1)

2801

{

2807

{

2802

ellipseGeometry_1 = (EllipseGeometry)gGrpBlueNode.Children[i - 1];

2808

ellipseGeometry_1 = (EllipseGeometry)gGrpBlueNode.Children[i - 1];

2803

node_1 = ellipseGeometry_1.Center;

2809

node_1 = ellipseGeometry_1.Center;

2804

if (node_1.X == node_2.X)

2810

if (node_1.X == node_2.X)

2805

{

2811

{

2806

addDistance = Math.Abs(node_1.Y - node_2.Y);

2812

addDistance = Math.Abs(node_1.Y - node_2.Y);

2807

distance.Add(addDistance);

2813

distance.Add(addDistance);

2808

}

2814

}

2809

else if (node_1.Y == node_2.Y)

2815

else if (node_1.Y == node_2.Y)

2810

{

2816

{

2811

addDistance = Math.Abs(node_1.X - node_2.X);

2817

addDistance = Math.Abs(node_1.X - node_2.X);

2812

distance.Add(addDistance);

2818

distance.Add(addDistance);

2813

}

2819

}

2814

else

2820

else

2815

{

2821

{

2816

var a = (double)(node_2.X - node_1.X);

2822

var a = (double)(node_2.X - node_1.X);

2817

var b = (double)(node_2.Y - node_1.Y);

2823

var b = (double)(node_2.Y - node_1.Y);

2818

addDistance = Math.Sqrt(a * a + b * b);

2824

addDistance = Math.Sqrt(a * a + b * b);

2819

distance.Add(addDistance);

2825

distance.Add(addDistance);

2820

}

2826

}

2821

}

2827

}

2822

}

2828

}

2823

}

2829

}

2824

if (distance.Count > 0)

2830

if (distance.Count > 0)

2825

{

2831

{

2826

double total = 0;

2832

double total = 0;

2827

double distance_i;

2833

double distance_i;

2828

2834

2829

for (int i = 0; i < distance.Count; i++)

2835

for (int i = 0; i < distance.Count; i++)

2830

{

2836

{

2831

total = total + distance[i];

2837

total = total + distance[i];

2832

}

2838

}

2833

2839

2834

for (int i = 0; i < distance.Count; i++)

2840

for (int i = 0; i < distance.Count; i++)

2835

{

2841

{

2836

distance_i = distance[i] * (Totaldistance / total);

2842

distance_i = distance[i] * (Totaldistance / total);

2837

distance[i] = distance_i;

2843

distance[i] = distance_i;

2838

}

2844

}

2839

}

2845

}

2840

2846

2841

if (gGrpBlueNode.Children.Count > 0)

2847

if (gGrpBlueNode.Children.Count > 0)

2842

{

2848

{

2843

node_Schedule.X = x_1;

2849

node_Schedule.X = x_1;

2844

node_Schedule.Y = y_1;

2850

node_Schedule.Y = y_1;

2845

AddNode(node_Schedule, gGrpScheduleNode);

2851

AddNode(node_Schedule, gGrpScheduleNode);

2846

}

2852

}

2847

2853

2848

addDistance = 0;

2854

addDistance = 0;

2849

for (int i = 0; i < distance.Count; i++)

2855

for (int i = 0; i < distance.Count; i++)

2850

{

2856

{

2851

2857

2852

node_Schedule.Y = y_1;

2858

node_Schedule.Y = y_1;

2853

addDistance = addDistance + distance[i];

2859

addDistance = addDistance + distance[i];

2854

node_Schedule.X = addDistance;

2860

node_Schedule.X = addDistance;

2855

AddNode(node_Schedule, gGrpScheduleNode);

2861

AddNode(node_Schedule, gGrpScheduleNode);

2856

}

2862

}

2857

2863

2858

if (gGrpScheduleNode.Children.Count > 0)

2864

if (gGrpScheduleNode.Children.Count > 0)

2859

{

2865

{

2860

for (int i = 0; i < gGrpScheduleNode.Children.Count; i++)

2866

for (int i = 0; i < gGrpScheduleNode.Children.Count; i++)

2861

{

2867

{

2862

ellipseGeometry_1 = (EllipseGeometry)gGrpScheduleNode.Children[i];

2868

ellipseGeometry_1 = (EllipseGeometry)gGrpScheduleNode.Children[i];

2863

node_1 = ellipseGeometry_1.Center;

2869

node_1 = ellipseGeometry_1.Center;

2864

if (i > 0)

2870

if (i > 0)

2865

{

2871

{

2866

ellipseGeometry_2 = (EllipseGeometry)gGrpScheduleNode.Children[i - 1];

2872

ellipseGeometry_2 = (EllipseGeometry)gGrpScheduleNode.Children[i - 1];

2867

node_2 = ellipseGeometry_2.Center;

2873

node_2 = ellipseGeometry_2.Center;

2868

DrawLine(node_1, node_2, gGrpScheduleLine);

2874

DrawLine(node_1, node_2, gGrpScheduleLine);

2869

}

2875

}

2870

CreateScheduleNode(node_1, i + 1);

2876

CreateScheduleNode(node_1, i + 1);

2871

}

2877

}

2872

}

2878

}

2873

}

2879

}

2874

2880

2875

private void CreateScheduleNode(Point point, int indexNode)

2881

private void CreateScheduleNode(Point point, int indexNode)

2876

{

2882

{

2877

ucNode _ucNode = new ucNode();

2883

ucNode _ucNode = new ucNode();

2878

_ucNode.btnWidth = UCNODE_WIDTH;

2884

_ucNode.btnWidth = UCNODE_WIDTH;

2879

_ucNode.btnHeight = UCNODE_HEIGHT;

2885

_ucNode.btnHeight = UCNODE_HEIGHT;

2880

_ucNode.txtNode = indexNode.ToString();

2886

_ucNode.txtNode = indexNode.ToString();

2881

_ucNode.IsDragDelta = false;

2887

_ucNode.IsDragDelta = false;

2882

Canvas.SetLeft(_ucNode, point.X - UCNODE_SETLEFT);

2888

Canvas.SetLeft(_ucNode, point.X - UCNODE_SETLEFT);

2883

Canvas.SetTop(_ucNode, point.Y - UCNODE_SETTOP);

2889

Canvas.SetTop(_ucNode, point.Y - UCNODE_SETTOP);

2884

scheduleCanvas.Children.Add(_ucNode);

2890

scheduleCanvas.Children.Add(_ucNode);

2885

ucScheduleNode_Lst.Add(_ucNode);

2891

ucScheduleNode_Lst.Add(_ucNode);

2886

}

2892

}

2887

2893

2888

#endregion

2894

#endregion

2889

2895

2890

#region Add Vehicle

2896

#region Add Vehicle

2891

public void GetIndexVehicle()

2897

public void GetIndexVehicle()

2892

{

2898

{

2893

bool flag = false;

2899

bool flag = false;

2894

if (VehicleModel.VehicleModelList.Count > 0)

2900

if (VehicleModel.VehicleModelList.Count > 0)

2895

{

2901

{

2896

for (int i = 0; i < VehicleModel.VehicleModelList.Count; i++)

2902

for (int i = 0; i < VehicleModel.VehicleModelList.Count; i++)

2897

{

2903

{

2898

if (VehicleItem == VehicleModel.VehicleModelList[i].VehicleName)

2904

if (VehicleItem == VehicleModel.VehicleModelList[i].VehicleName)

2899

{

2905

{

2900

VehicleIndex = i;

2906

VehicleIndex = i;

2901

flag = true;

2907

flag = true;

2902

}

2908

}

2903

}

2909

}

2904

if (!flag)

2910

if (!flag)

2905

{

2911

{

2906

VehicleIndex = VehicleModel.VehicleModelList.Count;

2912

VehicleIndex = VehicleModel.VehicleModelList.Count;

2907

}

2913

}

2908

}

2914

}

2909

else

2915

else

2910

{

2916

{

2911

VehicleIndex = 0;

2917

VehicleIndex = 0;

2912

}

2918

}

2913

}

2919

}

2914

2920

2915

public void GetdataVehicle()

2921

public void GetdataVehicle()

2916

{

2922

{

2917

2923

2918

GetIndexVehicle();

2924

GetIndexVehicle();

2919

2925

2920

if (VehicleModel.VehicleModelList.Count > 0)

2926

if (VehicleModel.VehicleModelList.Count > 0)

2921

{

2927

{

2922

2928

2923

2929

2924

for (int i = 0; i < ucNode_Lst.Count; i++)

2930

for (int i = 0; i < ucNode_Lst.Count; i++)

2925

{

2931

{

2926

this.Children.Remove(ucNode_Lst[i]);

2932

this.Children.Remove(ucNode_Lst[i]);

2927

}

2933

}

2928

2934

2929

gGrpNewLine.Children.Clear();

2935

gGrpNewLine.Children.Clear();

2930

this.Children.Remove(pNewLine);

2936

this.Children.Remove(pNewLine);

2931

ucNode_Lst.Clear();

2937

ucNode_Lst.Clear();

2932

Lst_Node_tmp.Clear();

2938

Lst_Node_tmp.Clear();

2933

2939

2934

2940

2935

gGrpBlueNode.Children.Clear();

2941

gGrpBlueNode.Children.Clear();

2936

gGrpScheduleNode.Children.Clear();

2942

gGrpScheduleNode.Children.Clear();

2937

IndexNodeInsert_List.Clear();

2943

IndexNodeInsert_List.Clear();

2938

2944

2939

if (VehicleIndex < VehicleModel.VehicleModelList.Count)

2945

if (VehicleIndex < VehicleModel.VehicleModelList.Count)

2940

{

2946

{

2941

if (VehicleModel.VehicleModelList[VehicleIndex].pointMapList.Count > 0)

2947

if (VehicleModel.VehicleModelList[VehicleIndex].pointMapList.Count > 0)

2942

{

2948

{

2943

for (int k = 0; k < VehicleModel.VehicleModelList[VehicleIndex].pointMapList.Count; k++)

2949

for (int k = 0; k < VehicleModel.VehicleModelList[VehicleIndex].pointMapList.Count; k++)

2944

{

2950

{

2945

double X = VehicleModel.VehicleModelList[VehicleIndex].pointMapList[k].pointMap_X;

2951

double X = VehicleModel.VehicleModelList[VehicleIndex].pointMapList[k].pointMap_X;

2946

double Y = VehicleModel.VehicleModelList[VehicleIndex].pointMapList[k].pointMap_Y;

2952

double Y = VehicleModel.VehicleModelList[VehicleIndex].pointMapList[k].pointMap_Y;

2947

2953

2948

Point node = new Point(X, Y);

2954

Point node = new Point(X, Y);

2949

AddNode(node, gGrpBlueNode);

2955

AddNode(node, gGrpBlueNode);

2950

2956

2951

//Get list Node Insert

2957

//Get list Node Insert

2952

if (VehicleModel.VehicleModelList[VehicleIndex].pointMapList[k].color == ColorNode_Insert)

2958

if (VehicleModel.VehicleModelList[VehicleIndex].pointMapList[k].color == ColorNode_Insert)

2953

{

2959

{

2954

ListIndexNodeInsert ListIndex = new ListIndexNodeInsert();

2960

ListIndexNodeInsert ListIndex = new ListIndexNodeInsert();

2955

ListIndex.X = X;

2961

ListIndex.X = X;

2956

ListIndex.Y = Y;

2962

ListIndex.Y = Y;

2957

IndexNodeInsert_List.Add(ListIndex);

2963

IndexNodeInsert_List.Add(ListIndex);

2958

}

2964

}

2959

2965

2960

//Bind VehicleModel's NodeInfo to List Node Info temp

2966

//Bind VehicleModel's NodeInfo to List Node Info temp

2961

Node_tmp node_tmp = new Node_tmp();

2967

Node_tmp node_tmp = new Node_tmp();

2962

node_tmp.pointMap_X = X;

2968

node_tmp.pointMap_X = X;

2963

node_tmp.pointMap_Y = Y;

2969

node_tmp.pointMap_Y = Y;

2964

2970

2965

foreach (ListNodeInfo tmp in VehicleModel.VehicleModelList[VehicleIndex].pointMapList[k].ListNodeInfo)

2971

foreach (ListNodeInfo tmp in VehicleModel.VehicleModelList[VehicleIndex].pointMapList[k].ListNodeInfo)

2966

{

2972

{

2967

node_tmp.NodeInfo_tmp.Add(tmp);

2973

node_tmp.NodeInfo_tmp.Add(tmp);

2968

}

2974

}

2969

Lst_Node_tmp.Add(node_tmp);

2975

Lst_Node_tmp.Add(node_tmp);

2970

2976

2971

2977

2972

2978

2973

X = VehicleModel.VehicleModelList[VehicleIndex].pointMapList[k].pointSchedule_X;

2979

X = VehicleModel.VehicleModelList[VehicleIndex].pointMapList[k].pointSchedule_X;

2974

Y = VehicleModel.VehicleModelList[VehicleIndex].pointMapList[k].pointSchedule_Y;

2980

Y = VehicleModel.VehicleModelList[VehicleIndex].pointMapList[k].pointSchedule_Y;

2975

node = new Point(X, Y);

2981

node = new Point(X, Y);

2976

AddNode(node, gGrpScheduleNode);

2982

AddNode(node, gGrpScheduleNode);

2977

2983

2978

}

2984

}

2979

}

2985

}

2980

}

2986

}

2981

}

2987

}

2982

2988

2983

BindBlueNode2ucNode();

2989

BindBlueNode2ucNode();

2984

2990

2985

ReDrawAllNode();

2991

ReDrawAllNode();

2986

2992

2987

SetScheduleRoute();

2993

SetScheduleRoute();

2988

2994

2989

NewDspRouteInfo();

2995

NewDspRouteInfo();

2990

2996

2991

//Clear Route Info Table

2997

//Clear Route Info Table

2992

//((RoboforkMenu)System.Windows.Application.Current.MainWindow).grdRouteInfo.Children.Clear();

2998

//((RoboforkMenu)System.Windows.Application.Current.MainWindow).grdRouteInfo.Children.Clear();

2993

2999

2994

3000

2995

}

3001

}

2996

3002

2997

public void CreateVehicleNode()

3003

public void CreateVehicleNode()

2998

{

3004

{

2999

EllipseGeometry ellipseGeometry;

3005

EllipseGeometry ellipseGeometry;

3000

Point node;

3006

Point node;

3001

ListNodeInfo ListNodeInfo = new ListNodeInfo();

3007

ListNodeInfo ListNodeInfo = new ListNodeInfo();

3002

VehicleModelList VehicleModelList = new VehicleModelList();

3008

VehicleModelList VehicleModelList = new VehicleModelList();

3003

bool NodeISInsert = false;

3009

bool NodeISInsert = false;

3004

3010

3005

if (VehicleModel.VehicleModelList.Count > 0 && VehicleIndex < VehicleModel.VehicleModelList.Count)

3011

if (VehicleModel.VehicleModelList.Count > 0 && VehicleIndex < VehicleModel.VehicleModelList.Count)

3006

{

3012

{

3007

if (VehicleModel.VehicleModelList[VehicleIndex].pointMapList.Count > 0)

3013

if (VehicleModel.VehicleModelList[VehicleIndex].pointMapList.Count > 0)

3008

{

3014

{

3009

VehicleModel.VehicleModelList[VehicleIndex].pointMapList.Clear();

3015

VehicleModel.VehicleModelList[VehicleIndex].pointMapList.Clear();

3010

}

3016

}

3011

3017

3012

//back up

3018

//back up

3013

if (gGrpBlueNode.Children.Count > 0)

3019

if (gGrpBlueNode.Children.Count > 0)

3014

{

3020

{

3015

for (int i = 0; i < gGrpBlueNode.Children.Count; i++)

3021

for (int i = 0; i < gGrpBlueNode.Children.Count; i++)

3016

{

3022

{

3017

NodeISInsert = false;

3023

NodeISInsert = false;

3018

ellipseGeometry = (EllipseGeometry)gGrpBlueNode.Children[i];

3024

ellipseGeometry = (EllipseGeometry)gGrpBlueNode.Children[i];

3019

node = ellipseGeometry.Center;

3025

node = ellipseGeometry.Center;

3020

3026

3021

PointMap pMap = new PointMap();

3027

PointMap pMap = new PointMap();

3022

pMap.pointMap_X = node.X;

3028

pMap.pointMap_X = node.X;

3023

pMap.pointMap_Y = node.Y;

3029

pMap.pointMap_Y = node.Y;

3024

pMap.speed_Map = 5;

3030

pMap.speed_Map = 5;

3025

3031

3026

//Backup List Node Insert of fork

3032

//Backup List Node Insert of fork

3027

if (IndexNodeInsert_List.Count> 0)

3033

if (IndexNodeInsert_List.Count> 0)

3028

{

3034

{

3029

for (int j = 0; j < IndexNodeInsert_List.Count; j++)

3035

for (int j = 0; j < IndexNodeInsert_List.Count; j++)

3030

{

3036

{

3031

if (node.X == IndexNodeInsert_List[j].X && node.Y == IndexNodeInsert_List[j].Y) NodeISInsert = true;

3037

if (node.X == IndexNodeInsert_List[j].X && node.Y == IndexNodeInsert_List[j].Y) NodeISInsert = true;

3032

}

3038

}

3033

}

3039

}

3034

if (NodeISInsert)

3040

if (NodeISInsert)

3035

{

3041

{

3036

pMap.color = ColorNode_Insert;

3042

pMap.color = ColorNode_Insert;

3037

}

3043

}

3038

else

3044

else

3039

{

3045

{

3040

pMap.color = ColorNode_Add;

3046

pMap.color = ColorNode_Add;

3041

}

3047

}

3042

3048

3043

ellipseGeometry = (EllipseGeometry)gGrpScheduleNode.Children[i];

3049

ellipseGeometry = (EllipseGeometry)gGrpScheduleNode.Children[i];

3044

node = ellipseGeometry.Center;

3050

node = ellipseGeometry.Center;

3045

pMap.pointSchedule_X = node.X;

3051

pMap.pointSchedule_X = node.X;

3046

pMap.pointSchedule_Y = node.Y;

3052

pMap.pointSchedule_Y = node.Y;

3047

pMap.speed_Schedule = 0;

3053

pMap.speed_Schedule = 0.2; //Hard code

3048

3054

3049

//Node info

3055

//Node info

3050

foreach (ListNodeInfo temp in Lst_Node_tmp[i].NodeInfo_tmp)

3056

foreach (ListNodeInfo temp in Lst_Node_tmp[i].NodeInfo_tmp)

3051

{

3057

{

3052

pMap.ListNodeInfo.Add(temp);

3058

pMap.ListNodeInfo.Add(temp);

3053

}

3059

}

3054

3060

3055

VehicleModel.VehicleModelList[VehicleIndex].pointMapList.Add(pMap);

3061

VehicleModel.VehicleModelList[VehicleIndex].pointMapList.Add(pMap);

3056

3062

3057

}

3063

}

3058

}

3064

}

3059

3065

3060

}

3066

}

3061

// create new

3067

// create new

3062

else

3068

else

3063

{

3069

{

3064

VehicleModelList.VehicleName = VehicleItem;

3070

VehicleModelList.VehicleName = VehicleItem;

3065

3071

3066

if (gGrpBlueNode.Children.Count > 0)

3072

if (gGrpBlueNode.Children.Count > 0)

3067

{

3073

{

3068

for (int i = 0; i < gGrpBlueNode.Children.Count; i++)

3074

for (int i = 0; i < gGrpBlueNode.Children.Count; i++)

3069

{

3075

{

3070

NodeISInsert = false;

3076

NodeISInsert = false;

3071

ellipseGeometry = (EllipseGeometry)gGrpBlueNode.Children[i];

3077

ellipseGeometry = (EllipseGeometry)gGrpBlueNode.Children[i];

3072

node = ellipseGeometry.Center;

3078

node = ellipseGeometry.Center;

3073

3079

3074

PointMap pMap = new PointMap();

3080

PointMap pMap = new PointMap();

3075

pMap.pointMap_X = node.X;

3081

pMap.pointMap_X = node.X;

3076

pMap.pointMap_Y = node.Y;

3082

pMap.pointMap_Y = node.Y;

3077

pMap.speed_Map = 5;

3083

pMap.speed_Map = 5;

3078

3084

3079

if (IndexNodeInsert_List.Count > 0)

3085

if (IndexNodeInsert_List.Count > 0)

3080

{

3086

{

3081

for (int j = 0; j < IndexNodeInsert_List.Count; j++)

3087

for (int j = 0; j < IndexNodeInsert_List.Count; j++)

3082

{

3088

{

3083

if (node.X == IndexNodeInsert_List[j].X && node.Y == IndexNodeInsert_List[j].Y) NodeISInsert = true;

3089

if (node.X == IndexNodeInsert_List[j].X && node.Y == IndexNodeInsert_List[j].Y) NodeISInsert = true;

3084

}

3090

}

3085

}

3091

}

3086

if (NodeISInsert)

3092

if (NodeISInsert)

3087

{

3093

{

3088

pMap.color = ColorNode_Insert;

3094

pMap.color = ColorNode_Insert;

3089

}

3095

}

3090

else

3096

else

3091

{

3097

{

3092

pMap.color = ColorNode_Add;

3098

pMap.color = ColorNode_Add;

3093

}

3099

}

3094

3100

3095

//Node info

3101

//Node info

3096

foreach (ListNodeInfo temp in Lst_Node_tmp[i].NodeInfo_tmp)

3102

foreach (ListNodeInfo temp in Lst_Node_tmp[i].NodeInfo_tmp)

3097

{

3103

{

3098

pMap.ListNodeInfo.Add(temp);

3104

pMap.ListNodeInfo.Add(temp);

3099

}

3105

}

3100

3106

3101

ellipseGeometry = (EllipseGeometry)gGrpScheduleNode.Children[i];

3107

ellipseGeometry = (EllipseGeometry)gGrpScheduleNode.Children[i];

3102

node = ellipseGeometry.Center;

3108

node = ellipseGeometry.Center;

3103

pMap.pointSchedule_X = node.X;

3109

pMap.pointSchedule_X = node.X;

3104

pMap.pointSchedule_Y = node.Y;

3110

pMap.pointSchedule_Y = node.Y;

3105

pMap.speed_Schedule = 0;

3111

pMap.speed_Schedule = 0.2; //Hard code

3106

3112

3107

VehicleModelList.pointMapList.Add(pMap);

3113

VehicleModelList.pointMapList.Add(pMap);

3108

}

3114

}

3109

}

3115

}

3110

VehicleModel.VehicleModelList.Add(VehicleModelList);

3116

VehicleModel.VehicleModelList.Add(VehicleModelList);

3111

}

3117

}

3112

}

3118

}

3113

#endregion

3119

#endregion

3114

3120

3115

}

3121

}

3116

}

3122

}

3117

3123

GITLAB

toan / Robofork

RM2063 : Update source

 using RoboforkApp.DataModel;
 using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Windows;
 using System.Windows.Controls;
 using System.Windows.Documents;
 using System.Windows.Input;
 using System.Windows.Markup;
 using System.Windows.Media;
 using System.Windows.Shapes;
 using System.Xml;
 namespace RoboforkApp
 {
     public class DesignerCanvas : Canvas
     {
         const double RADIUS_NODE = 25d; //8d;
         const double RADIUS_CURVER_LINE = 130d;
         const double DISTANCE_AUTO_NODES = 100d;
         const double DISTANCE_START_NODES = 30d;
         const double DISTANCE_END_NODES = 30d;
         const double DISTANCE_FREE_NODES = 40d;
         const double STROKE_ROOT_LINE = 6d;
         const double STROKE_LINE = 4d;
         const double STROKE_NODE = 1d;
         const double DISTANCE_RATIO = 100;
         const double UCNODE_SETLEFT = 17;
         const double UCNODE_SETTOP = 17;
         const double UCNODE_WIDTH = 34;
         const double UCNODE_HEIGHT = 34;
         private List<Rectangle> shapeList = new List<Rectangle>();
         private TextBlock shapePosIndicator;
         private TextBlock shapeSizeIndicator;
         private int currentLine;
         private ucStartEndButton _startPoint;
         private ucNode _ucNodeFree;
         private ucStartEndButton _goalPoint;
         private ucDisplayCoordinate _displayAxiPosition;
         // Add variable for draw route
         public Path pLine = new Path();
         public Path pRootLine = new Path();
         public Path pCurverLine = new Path();
         public Path pRedNode = new Path();
         public Path pYellowNode = new Path();
         public GeometryGroup gGrpLine = new GeometryGroup();
         public GeometryGroup gGrpRootLine = new GeometryGroup();
         public GeometryGroup gGrpCurverLine = new GeometryGroup();
         public GeometryGroup gGrpRedNode = new GeometryGroup();
         public GeometryGroup gGrpYellowNode = new GeometryGroup();
         public int currentShape;
         public static bool isStartDrawRoute = false;
         public static bool isGoalDrawRoute = false;
         public struct NodeInfo
         {
             public double X;
             public double Y;
             public String Mode1;
             public String Mode2;
             public String Mode3;
         }
         List<NodeInfo> NodeInfo_List = new List<NodeInfo>();
         // Add variable for Set Schedule
         public Path pScheduleNode = new Path();
         public Path pScheduleLine = new Path();
         public GeometryGroup gGrpScheduleNode = new GeometryGroup();
         public GeometryGroup gGrpScheduleLine = new GeometryGroup();
         public static bool EditNodeFlag = false;
         public static bool DragDeltaFlag = false;
         //Add variable for Vehicle Item click
         public string VehicleItem = "FK_15";
-        VehicleModel VehicleModel = new VehicleModel();
+        public VehicleModel VehicleModel = new VehicleModel();
         public int VehicleIndex = 0;
         public string ColorNode_Add = "Blue";
         public string ColorNode_Insert = "Brown";
         //2017/03/04 NAM ADD START
         public static bool isDrawingNode = false;
         public static bool isDragNode = false;
         public Path pNewLine = new Path();
         public GeometryGroup gGrpNewLine = new GeometryGroup();
         public struct NewNodeInfo
         {
             public double X;
             public double Y;
             public String Mode;
         }
         List<NewNodeInfo> NewNodeInfo_List = new List<NewNodeInfo>();
         //List Node's Info
         List<Node_tmp> Lst_Node_tmp = new List<Node_tmp>();
         List<TextBlock> NodeNo = new List<TextBlock>();
         List<ucNode> ucNode_Lst = new List<ucNode>();
         public List<ucNode> ucScheduleNode_Lst = new List<ucNode>();
         int stt = 1;
         //2017/03/04 NAM ADD END
         public struct ListIndexNodeInsert
         {
             public double X;
             public double Y;
         }
         List<ListIndexNodeInsert> IndexNodeInsert_List = new List<ListIndexNodeInsert>();
         public ScheduleCanvas scheduleCanvas;
         // Add variable for Set Auto Nodes
         public Path pBlueNode = new Path();
         private GeometryGroup gGrpBlueNode = new GeometryGroup();
         // Add variable for Set Free Nodes
         public Path pFreeNode = new Path();
         //private GeometryGroup gGrpFreeNode = new GeometryGroup();
         // The part of the rectangle the mouse is over.
         private enum HitType
         {
             None, Body, UL, UR, LR, LL, L, R, T, B
         };
         public enum OperationState
         {
             None, DrawObstract, DrawRoute, DrawSetFreeNode, EditNode, NewDrawSetFreeNode
         };
         public enum MouseState
         {
             None, Draw, Drag,
         }
         public OperationState Operation = OperationState.None;
         public MouseState mouseState = MouseState.None;
         // The draw start point.
         private Point StartDrawPoint;
         // The drag's last point.
         private Point LastPoint;
         // The part of the rectangle under the mouse.
         HitType MouseHitType = HitType.None;
         public void Init()
         {
             if (shapePosIndicator == null)
             {
                 shapePosIndicator = new TextBlock()
                 {
                     Foreground = Brushes.Black,
                     Background = Brushes.Transparent,
                     FontSize = 20,
                 };
             }
             if (shapeSizeIndicator == null)
             {
                 shapeSizeIndicator = new TextBlock()
                 {
                     Foreground = Brushes.Black,
                     Background = Brushes.Transparent,
                     FontSize = 20,
                 };
             }
         }
         // Return a HitType value to indicate what is at the point.
         private HitType SetHitType(Point point)
         {
             if (shapeList.Count == 0)
             {
                 currentShape = 0;
                 return HitType.None;
             }
             for (int i = 0; i < shapeList.Count; i++)
             {
                 Rectangle rect = shapeList[i];
                 double left = Canvas.GetLeft(rect);
                 double top = Canvas.GetTop(rect);
                 double right = left + rect.Width;
                 double bottom = top + rect.Height;
                 if (point.X < left) continue;
                 if (point.X > right) continue;
                 if (point.Y < top) continue;
                 if (point.Y > bottom) continue;
                 currentShape = i;
                 const double GAP = 10;
                 if (point.X - left < GAP)
                 {
                     // Left edge.
                     if (point.Y - top < GAP) return HitType.UL;
                     if (bottom - point.Y < GAP) return HitType.LL;
                     return HitType.L;
                 }
                 if (right - point.X < GAP)
                 {
                     // Right edge.
                     if (point.Y - top < GAP) return HitType.UR;
                     if (bottom - point.Y < GAP) return HitType.LR;
                     return HitType.R;
                 }
                 if (point.Y - top < GAP) return HitType.T;
                 if (bottom - point.Y < GAP) return HitType.B;
                 return HitType.Body;
             }
             currentShape = 0;
             return HitType.None;
         }
         // Set a mouse cursor appropriate for the current hit type.
         private void SetMouseCursor()
         {
             // See what cursor we should display.
             Cursor desired_cursor = Cursors.Arrow;
             switch (MouseHitType)
             {
                 case HitType.None:
                     desired_cursor = Cursors.Arrow;
                     break;
                 case HitType.Body:
                     desired_cursor = Cursors.ScrollAll;
                     break;
                 case HitType.UL:
                 case HitType.LR:
                     desired_cursor = Cursors.SizeNWSE;
                     break;
                 case HitType.LL:
                 case HitType.UR:
                     desired_cursor = Cursors.SizeNESW;
                     break;
                 case HitType.T:
                 case HitType.B:
                     desired_cursor = Cursors.SizeNS;
                     break;
                 case HitType.L:
                 case HitType.R:
                     desired_cursor = Cursors.SizeWE;
                     break;
             }
             // Display the desired cursor.
             if (Cursor != desired_cursor) Cursor = desired_cursor;
         }
         // constance
         int indicatorAligment = 2;
         /*
         private Point? dragStartPoint = null;
         */
         public IEnumerable<DesignerItem> SelectedItems
         {
             get
             {
                 var selectedItems = from item in this.Children.OfType<DesignerItem>()
                                     where item.IsSelected == true
                                     select item;
                 return selectedItems;
             }
         }
         public void DeselectAll()
         {
             /*
             foreach (DesignerItem item in this.SelectedItems)
             {
                 item.IsSelected = false;
             }*/
         }
         protected override void OnMouseDown(MouseButtonEventArgs e)
         {
             base.OnMouseDown(e);
             MouseHitType = SetHitType(Mouse.GetPosition(this));
             SetMouseCursor();
             if (Operation == OperationState.DrawRoute && isStartDrawRoute)
             {
                 if (isGoalDrawRoute)
                 {
                     return;
                 }
                 // Check state draw
                 if (MouseHitType == HitType.None)
                 {
                     if (gGrpLine.Children.Count == 1)
                     {
                         LineGeometry lineGeometry = (LineGeometry)gGrpLine.Children[0];
                         lineGeometry.EndPoint = LastPoint;
                         // Check end route
                         if (IsEndRoute(_goalPoint, lineGeometry))
                         {
                             isGoalDrawRoute = true;
                             ProcessEndRoute();
                             return;
                         }
                     }
                     else if (IsCurverNode((LineGeometry)gGrpLine.Children[currentLine - 1]
                                         , (LineGeometry)gGrpLine.Children[currentLine]))
                     {
                         // Set end point to finish draw line
                         LineGeometry lineGeometry = (LineGeometry)gGrpLine.Children[currentLine];
                         lineGeometry.EndPoint = LastPoint;
                         // Add node to curver postion
                         AddNode(lineGeometry.StartPoint, gGrpRedNode);
                         // Check end route
                         if (IsEndRoute(_goalPoint, lineGeometry))
                         {
                             isGoalDrawRoute = true;
                             ProcessEndRoute();
                             return;
                         }
                     }
                     else
                     {
                         // Remove current line
                         gGrpLine.Children.RemoveAt(currentLine);
                         // Set end point to finish draw line
                         LineGeometry lineGeometry = (LineGeometry)gGrpLine.Children[currentLine - 1];
                         lineGeometry.EndPoint = LastPoint;
                         // Check end route
                         if (IsEndRoute(_goalPoint, lineGeometry))
                         {
                             isGoalDrawRoute = true;
                             ProcessEndRoute();
                             return;
                         }
                     }
                     // Draw new line
                     DrawLine(LastPoint, LastPoint, gGrpLine);
                     // Setting start point for new line
                     StartDrawPoint = LastPoint;
                     mouseState = MouseState.Draw;
                     currentLine = gGrpLine.Children.Count - 1;
                     return;
                 }
             }
             else if (Operation == OperationState.DrawSetFreeNode)
             {
                 bool RightClick = false;
                 if (IsStopDrawRoute(e))
                     RightClick = true;
                 StartDrawPoint = e.MouseDevice.GetPosition(this);
                 SetFreeNodes(StartDrawPoint, RightClick);
             }
             else if (Operation == OperationState.EditNode)
             {
                 Point node_edited = e.MouseDevice.GetPosition(this);
                 // start Edit Node Infor
                 EditNode(node_edited);
             }
             else if (Operation == OperationState.DrawObstract)
             {
                 if (MouseHitType == HitType.None)
                 {
                     Rectangle shape = new Rectangle();
                     shape.Width = 1;
                     shape.Height = 1;
                     // Create a SolidColorBrush and use it to
                     // paint the rectangle.
                     shape.Stroke = Brushes.Blue;
                     shape.StrokeThickness = 1;
                     shape.Fill = new SolidColorBrush(Colors.LightCyan);
                     StartDrawPoint = e.MouseDevice.GetPosition(this);
                     shape.SetValue(Canvas.LeftProperty, StartDrawPoint.X);
                     shape.SetValue(Canvas.TopProperty, StartDrawPoint.Y);
                     this.Children.Add(shape);
                     shapeList.Add(shape);
                     mouseState = MouseState.Draw;
                     currentShape = shapeList.Count() - 1;
                     double shapeX = Canvas.GetLeft(shapeList[currentShape]);
                     double shapeY = Canvas.GetTop(shapeList[currentShape]);
                     shapePosIndicator.Text = "(" + Math.Round(shapeX, 0) + "," + Math.Round(shapeY, 0) + ")";
                     shapePosIndicator.SetValue(Canvas.LeftProperty, shapeX + indicatorAligment);
                     shapePosIndicator.SetValue(Canvas.TopProperty, shapeY + indicatorAligment);
                     double width = (int)shapeList[currentShape].Width;
                     double height = (int)shapeList[currentShape].Height;
                     shapeSizeIndicator.Text = "(" + Math.Round(width, 0) + "," + Math.Round(height, 0) + ")";
                     shapeSizeIndicator.SetValue(Canvas.LeftProperty, shapeX + indicatorAligment + width);
                     shapeSizeIndicator.SetValue(Canvas.TopProperty, shapeY + indicatorAligment + height);
                     this.Children.Add(shapePosIndicator);
                     this.Children.Add(shapeSizeIndicator);
                     return;
                 }
                 else
                 {
                     if (shapeList.Count() != 0)
                         shapeList[currentShape].Fill = new SolidColorBrush(Colors.LightCyan);
                     double shapeX = Canvas.GetLeft(shapeList[currentShape]);
                     double shapeY = Canvas.GetTop(shapeList[currentShape]);
                     shapePosIndicator.Text = "(" + Math.Round(shapeX, 0) + "," + Math.Round(shapeY, 0) + ")";
                     shapePosIndicator.SetValue(Canvas.LeftProperty, shapeX + indicatorAligment);
                     shapePosIndicator.SetValue(Canvas.TopProperty, shapeY + indicatorAligment);
                     double width = (int)shapeList[currentShape].Width;
                     double height = (int)shapeList[currentShape].Height;
                     shapeSizeIndicator.Text = "(" + Math.Round(width, 0) + "," + Math.Round(height, 0) + ")";
                     shapeSizeIndicator.SetValue(Canvas.LeftProperty, shapeX + indicatorAligment + width);
                     shapeSizeIndicator.SetValue(Canvas.TopProperty, shapeY + indicatorAligment + height);
                     this.Children.Add(shapePosIndicator);
                     this.Children.Add(shapeSizeIndicator);
                 }
                 LastPoint = Mouse.GetPosition(this);
                 mouseState = MouseState.Drag;
             }
             e.Handled = true;
         }
         protected override void OnMouseMove(MouseEventArgs e)
         {
             base.OnMouseMove(e);
             if (mouseState == MouseState.None)
             {
                 MouseHitType = SetHitType(Mouse.GetPosition(this));
                 SetMouseCursor();
             }
             else if (Operation == OperationState.DrawRoute && isStartDrawRoute)
             {
                 LineGeometry lineGeometry = (LineGeometry)gGrpLine.Children[currentLine];
                 // See how much the mouse has moved.
                 Point point = Mouse.GetPosition(this);
                 double offset_x = point.X - StartDrawPoint.X;
                 double offset_y = point.Y - StartDrawPoint.Y;
                 // Get the line's current position.
                 double new_x = lineGeometry.StartPoint.X;
                 double new_y = lineGeometry.StartPoint.Y;
                 if (offset_x != 0 || offset_y != 0)
                 {
                     if (Math.Abs(offset_x) >= Math.Abs(offset_y))
                     {
                         new_x = point.X;
                     }
                     else
                     {
                         new_y = point.Y;
                     }
                 }
                 // Set end point of current line
                 LastPoint = new Point(new_x, new_y);
                 lineGeometry.EndPoint = LastPoint;
                 DisplayCoordinate(LastPoint);
             }
             else if (Operation == OperationState.DrawObstract)
             {
                 if (mouseState == MouseState.Drag)
                 {
                     // See how much the mouse has moved.
                     Point point = Mouse.GetPosition(this);
                     double offset_x = point.X - LastPoint.X;
                     double offset_y = point.Y - LastPoint.Y;
                     // Get the rectangle's current position.
                     double new_x = Canvas.GetLeft(shapeList[currentShape]);
                     double new_y = Canvas.GetTop(shapeList[currentShape]);
                     double new_width = shapeList[currentShape].Width;
                     double new_height = shapeList[currentShape].Height;
                     // Update the rectangle.
                     switch (MouseHitType)
                     {
                         case HitType.Body:
                             new_x += offset_x;
                             new_y += offset_y;
                             break;
                         case HitType.UL:
                             new_x += offset_x;
                             new_y += offset_y;
                             new_width -= offset_x;
                             new_height -= offset_y;
                             break;
                         case HitType.UR:
                             new_y += offset_y;
                             new_width += offset_x;
                             new_height -= offset_y;
                             break;
                         case HitType.LR:
                             new_width += offset_x;
                             new_height += offset_y;
                             break;
                         case HitType.LL:
                             new_x += offset_x;
                             new_width -= offset_x;
                             new_height += offset_y;
                             break;
                         case HitType.L:
                             new_x += offset_x;
                             new_width -= offset_x;
                             break;
                         case HitType.R:
                             new_width += offset_x;
                             break;
                         case HitType.B:
                             new_height += offset_y;
                             break;
                         case HitType.T:
                             new_y += offset_y;
                             new_height -= offset_y;
                             break;
                     }
                     // Don't use negative width or height.
                     if ((new_width > 0) && (new_height > 0))
                     {
                         // Update the rectangle.
                         Canvas.SetLeft(shapeList[currentShape], new_x);
                         Canvas.SetTop(shapeList[currentShape], new_y);
                         shapeList[currentShape].Width = new_width;
                         shapeList[currentShape].Height = new_height;
                         // Save the mouse's new location.
                         LastPoint = point;
                     }
                 }
                 else if (mouseState == MouseState.Draw)
                 {
                     // See how much the mouse has moved.
                     Point point = Mouse.GetPosition(this);
                     double offset_x = point.X - StartDrawPoint.X;
                     double offset_y = point.Y - StartDrawPoint.Y;
                     // Get the rectangle's current position.
                     double start_x = Canvas.GetLeft(shapeList[currentShape]);
                     double start_y = Canvas.GetTop(shapeList[currentShape]);
                     double new_x = Canvas.GetLeft(shapeList[currentShape]);
                     double new_y = Canvas.GetTop(shapeList[currentShape]);
                     double new_width = offset_x;
                     double new_height = offset_y;
                     if (offset_x < 0)
                     {
                         new_x = point.X;
                         new_width = -offset_x;
                     }
                     if (offset_y < 0)
                     {
                         new_y = point.Y;
                         new_height = -offset_y;
                     }
                     Canvas.SetLeft(shapeList[currentShape], new_x);
                     Canvas.SetTop(shapeList[currentShape], new_y);
                     shapeList[currentShape].Width = new_width;
                     shapeList[currentShape].Height = new_height;
                 }
                 double shapeX = Canvas.GetLeft(shapeList[currentShape]);
                 double shapeY = Canvas.GetTop(shapeList[currentShape]);
                 shapePosIndicator.Text = "(" + Math.Round(shapeX, 0) + "," + Math.Round(shapeY, 0) + ")";
                 shapePosIndicator.SetValue(Canvas.LeftProperty, shapeX + indicatorAligment);
                 shapePosIndicator.SetValue(Canvas.TopProperty, shapeY + indicatorAligment);
                 double width = (int)shapeList[currentShape].Width;
                 double height = (int)shapeList[currentShape].Height;
                 shapeSizeIndicator.Text = "(" + Math.Round(width, 0) + "," + Math.Round(height, 0) + ")";
                 shapeSizeIndicator.SetValue(Canvas.LeftProperty, shapeX + indicatorAligment + width);
                 shapeSizeIndicator.SetValue(Canvas.TopProperty, shapeY + indicatorAligment + height);
             }
             e.Handled = true;
         }
         protected override void OnMouseUp(MouseButtonEventArgs e)
         {
             base.OnMouseUp(e);
             if (Operation == OperationState.DrawObstract)
             {
                 if (shapeList.Count() != 0)
                     shapeList[currentShape].Fill = new SolidColorBrush(Colors.Blue);
                 shapePosIndicator.Text = "";
                 shapeSizeIndicator.Text = "";
                 this.Children.Remove(shapePosIndicator);
                 this.Children.Remove(shapeSizeIndicator);
                 mouseState = MouseState.None;
                 currentShape = 0;
             }
             e.Handled = true;
         }
         protected override void OnPreviewMouseUp(MouseButtonEventArgs e)
         {
             base.OnPreviewMouseUp(e);
             EllipseGeometry ellipseGeometry;
             bool flag = false;
             StartDrawPoint = e.MouseDevice.GetPosition(this);
             if (EditNodeFlag == true)
             {
                 execEditNode(StartDrawPoint);
                 EditNodeFlag = false;
                 return;
             }
             if (DragDeltaFlag == true)
             {
                 for (int i = 0; i < gGrpBlueNode.Children.Count; i++)
                 {
                     for (int j = 0; j < ucNode_Lst.Count; j++)
                     {
                         if (j == i)
                         {
                             _ucNodeFree = ucNode_Lst[j];
                             flag = true;
                         }
                     }
                     if (flag)
                     {
                         if (gGrpNewLine.Children.Count > 0)
                         {
                             for (int k = 0; k < gGrpNewLine.Children.Count; k++)
                             {
                                 LineGeometry lineGeometry = (LineGeometry)gGrpNewLine.Children[k];
                                 Point p1 = lineGeometry.StartPoint;
                                 Point p2 = lineGeometry.EndPoint;
                                 //bool pInL = PointInLine(StartDrawPoint, p1, p2, 25);
                                 //if (pInL)
                                 //{
                                 //    //this.Children.Remove(_ucNodeFree);
                                 //    //this.Children.Add(_ucNodeFree);
                                 //    return;
                                 //}
                             }
                         }
                         ellipseGeometry = (EllipseGeometry)gGrpBlueNode.Children[i];
                         ellipseGeometry.Center = new Point(StartDrawPoint.X, StartDrawPoint.Y);
                         double centerY = Canvas.GetTop(_ucNodeFree);
                         double centerX = Canvas.GetLeft(_ucNodeFree);
                         mouseState = MouseState.Draw;
                         StartDrawPoint = new Point(centerX + UCNODE_SETLEFT, centerY + UCNODE_SETTOP);
                         ellipseGeometry.Center = new Point(centerX + UCNODE_SETLEFT, centerY + UCNODE_SETTOP);
                         this.Children.Remove(_ucNodeFree);
                         this.Children.Add(_ucNodeFree);
                     }
                 }
                 ReDrawAllNode();
                 SetScheduleRoute();
                 DragDeltaFlag = false;
             }
             return;
         }
         /// <summary>
         /// On Preview Mouse Down
         /// </summary>
         /// <param name="e"></param>
         protected override void OnPreviewMouseDown(MouseButtonEventArgs e)
         {
             base.OnPreviewMouseDown(e);
             if (Operation != OperationState.NewDrawSetFreeNode)
             {
                 return;
             }
             Point currentPoint = e.MouseDevice.GetPosition(this);
             if (isDrawingNode == false)
             {
                 isDrawingNode = true;
                 InitDrawRoute();
                 mouseState = MouseState.Draw;
                 StartDrawPoint = e.MouseDevice.GetPosition(this);
                 execCreateNode(StartDrawPoint);
                 //backup DB
                 CreateVehicleNode();
                 return;
             }
             else
             {
                 bool RightClick = false;
                 bool LeftClick = false;
                 if (IsMouseLeftClick(e))
                     LeftClick = true;
                 if (IsStopDrawRoute(e))
                     RightClick = true;
                 StartDrawPoint = e.MouseDevice.GetPosition(this);
                 if (RightClick)
                 {
                     execDeleteNode(StartDrawPoint);
                     //backup DB
                     CreateVehicleNode();
                 }
                 else if (LeftClick)
                 {
                     //check click to exist node
                     for (int i = 0; i < gGrpBlueNode.Children.Count; i++)
                     {
                         EllipseGeometry ellipseGeometry = (EllipseGeometry)gGrpBlueNode.Children[i];
                         Point node = ellipseGeometry.Center;
                         bool isEditNode = CheckIsNode(StartDrawPoint, node, RADIUS_NODE);
                         if (isEditNode)
                         {
                             return;
                         }
                     }
                     execCreateNode(StartDrawPoint);
                     //backup DB
                     CreateVehicleNode();
                 }
             }
         }
         #region Functions for draw route
         /// <summary>
         /// Check start or end draw route
         /// </summary>
         /// <param name="_ucStartEndButton">Button start</param>
         /// <param name="currentPoint">Position for check</param>
         /// <returns>true: start, false: not start</returns>
         private bool IsStartEndRoute(ucStartEndButton _ucStartEndButton, Point currentPoint)
         {
             if (_ucStartEndButton == null)
             {
                 return false;
             }
             double centerX = Canvas.GetLeft(_ucStartEndButton);
             double centerY = Canvas.GetTop(_ucStartEndButton);
             if (currentPoint.X < centerX + 50 && currentPoint.X > centerX
                 && currentPoint.Y < centerY + 50 && currentPoint.Y > centerY)
             {
                 return true;
             }
             return false;
         }
         /// <summary>
         /// Process when end draw route
         /// </summary>
         private void ProcessEndRoute()
         {
             Operation = OperationState.None;
             AutoEditLine();
             this.Children.Remove(_displayAxiPosition);
             this.Children.Remove(_goalPoint);
             this.Children.Add(_goalPoint);
         }
         /// <summary>
         /// Check end draw route
         /// </summary>
         /// <param name="_ucStartEndButton">Button end</param>
         /// <param name="currentPoint">Position for check</param>
         /// <returns>true: end, false: not end</returns>
         private bool IsEndRoute(ucStartEndButton _ucStartEndButton, LineGeometry lineGeometry)
         {
             if (_ucStartEndButton == null)
             {
                 return false;
             }
             double centerX = Canvas.GetLeft(_ucStartEndButton);
             double centerY = Canvas.GetTop(_ucStartEndButton);
             Point startPoint = lineGeometry.StartPoint;
             Point endPoint = lineGeometry.EndPoint;
             if (IsVerticalLine(lineGeometry))
             {
                 if (endPoint.X < centerX || endPoint.X > centerX + 50)
                     return false;
                 if (startPoint.Y > centerY + 50 && endPoint.Y > centerY + 50)
                     return false;
                 if (startPoint.Y < centerY && endPoint.Y < centerY)
                     return false;
             }
             else
             {
                 if (endPoint.Y < centerY || endPoint.Y > centerY + 50)
                     return false;
                 if (startPoint.X > centerX + 50 && endPoint.X > centerX + 50)
                     return false;
                 if (startPoint.X < centerX && endPoint.X < centerX)
                     return false;
             }
             return true;
         }
         /// <summary>
         /// Make root
         /// </summary>
         public void MakeRoot()
         {
             // If still not route
             if (gGrpLine.Children.Count == 0)
                 return;
             pLine.Stroke = new SolidColorBrush(Colors.Red);
             pLine.StrokeThickness = STROKE_ROOT_LINE;
         }
         /// <summary>
         /// Auto edit leght of line
         /// </summary>
         private void AutoEditLine()
         {
             double temp;
             int index = gGrpLine.Children.Count - 1;
             double centerY = Canvas.GetTop(_goalPoint) + 25;
             double centerX = Canvas.GetLeft(_goalPoint) + 25;
             LineGeometry lastLine = (LineGeometry)gGrpLine.Children[index];
             LineGeometry beforeLastLine = (LineGeometry)gGrpLine.Children[index];
             if (gGrpLine.Children.Count > 1)
             {
                 beforeLastLine = (LineGeometry)gGrpLine.Children[index - 1];
                 if (!IsCurverNode(beforeLastLine, lastLine))
                 {
                     beforeLastLine.EndPoint = lastLine.EndPoint;
                     gGrpLine.Children.RemoveAt(index);
                     index = index - 1;
                     lastLine = (LineGeometry)gGrpLine.Children[index];
                 }
             }
             if (index == gGrpRedNode.Children.Count + 1)
             {
                 AddNode(lastLine.StartPoint, gGrpRedNode);
             }
             if (lastLine.EndPoint.X == centerX && lastLine.EndPoint.Y == centerY)
                 return;
             if (IsVerticalLine(lastLine))
             {
                 temp = lastLine.StartPoint.Y;
                 lastLine.StartPoint = new Point(centerX, temp);
                 lastLine.EndPoint = new Point(centerX, centerY);
                 if (gGrpLine.Children.Count > 1)
                 {
                     beforeLastLine = (LineGeometry)gGrpLine.Children[index - 1];
                     temp = beforeLastLine.EndPoint.Y;
                     beforeLastLine.EndPoint = new Point(centerX, temp);
                 }
             }
             else
             {
                 temp = lastLine.StartPoint.X;
                 lastLine.StartPoint = new Point(temp, centerY);
                 lastLine.EndPoint = new Point(centerX, centerY);
                 if (gGrpLine.Children.Count > 1)
                 {
                     beforeLastLine = (LineGeometry)gGrpLine.Children[index - 1];
                     temp = beforeLastLine.EndPoint.X;
                     beforeLastLine.EndPoint = new Point(temp, centerY);
                 }
             }
             // Draw curver line
             if (IsCurverNode(beforeLastLine, lastLine))
             {
                 EllipseGeometry ellipseGeometry = (EllipseGeometry)gGrpRedNode.Children[gGrpRedNode.Children.Count - 1];
                 ellipseGeometry.Center = lastLine.StartPoint;
             }
         }
         /// <summary>
         /// Check draw curver node
         /// </summary>
         /// <param name="oldLine">Old line</param>
         /// <param name="newLine">New line</param>
         /// <returns>true:is curver, fasle: not curver</returns>
         private bool IsCurverNode(LineGeometry oldLine, LineGeometry newLine)
         {
             if (oldLine.StartPoint.Y == oldLine.EndPoint.Y && oldLine.StartPoint.Y == newLine.EndPoint.Y)
             {
                 return false;
             }
             if (oldLine.StartPoint.X == oldLine.EndPoint.X && oldLine.StartPoint.X == newLine.EndPoint.X)
             {
                 return false;
             }
             return true;
         }
         /// <summary>
         /// Check timming to stop draw route
         /// </summary>
         /// <param name="e"></param>
         /// <returns>true:stop; false:continue</returns>
         private bool IsStopDrawRoute(MouseEventArgs e)
         {
             if (e.RightButton == MouseButtonState.Pressed)
             {
                 return true;
             }
             return false;
         }
         //2017/03/05 NAM ADD START
         private bool IsMouseLeftClick(MouseEventArgs e)
         {
             if (e.LeftButton == MouseButtonState.Pressed)
             {
                 return true;
             }
             return false;
         }
         //2017/03/05 NAM ADD END
         /// <summary>
         /// Draw curver line and yellow node
         /// </summary>
         /// <param name="oldLine">Old line</param>
         /// <param name="newLine">New line</param>
         private void DrawCurver(LineGeometry oldLine, LineGeometry newLine)
         {
             double radius = RADIUS_CURVER_LINE;
             Point startPoint;
             Point endPoint;
             // Get postion of yellow node on old line
             if (IsVerticalLine(oldLine))
             {
                 if (oldLine.StartPoint.Y > oldLine.EndPoint.Y)
                     startPoint = new Point(oldLine.EndPoint.X, oldLine.EndPoint.Y + radius);
                 else
                     startPoint = new Point(oldLine.EndPoint.X, oldLine.EndPoint.Y - radius);
             }
             else
             {
                 if (oldLine.StartPoint.X > oldLine.EndPoint.X)
                     startPoint = new Point(oldLine.EndPoint.X + radius, oldLine.EndPoint.Y);
                 else
                     startPoint = new Point(oldLine.EndPoint.X - radius, oldLine.EndPoint.Y);
             }
             // Get postion of yellow node on new line
             if (IsVerticalLine(newLine))
             {
                 if (newLine.StartPoint.Y > newLine.EndPoint.Y)
                     endPoint = new Point(newLine.StartPoint.X, newLine.StartPoint.Y - radius);
                 else
                     endPoint = new Point(newLine.StartPoint.X, newLine.StartPoint.Y + radius);
             }
             else
             {
                 if (newLine.StartPoint.X > newLine.EndPoint.X)
                     endPoint = new Point(newLine.StartPoint.X - radius, newLine.StartPoint.Y);
                 else
                     endPoint = new Point(newLine.StartPoint.X + radius, newLine.StartPoint.Y);
             }
             // Add node to postion distance 1300mm
             if (GetDistance(oldLine.StartPoint, oldLine.EndPoint) > RADIUS_CURVER_LINE)
             {
                 AddNode(startPoint, gGrpYellowNode);
             }
             if (GetDistance(newLine.StartPoint, newLine.EndPoint) > RADIUS_CURVER_LINE)
             {
                 AddNode(endPoint, gGrpYellowNode);
             }
         }
         /// <summary>
         /// Init data for draw route
         /// </summary>
         private void InitDrawRoute()
         {
             //2017/03/04 NAM ADD START
             pNewLine.Stroke = new SolidColorBrush(Colors.Red);
             pNewLine.StrokeThickness = STROKE_LINE;
             pNewLine.Data = gGrpNewLine;
             //2017/03/04 NAM ADD END
             pScheduleLine.Stroke = new SolidColorBrush(Colors.Red);
             pScheduleLine.StrokeThickness = STROKE_LINE;
             pScheduleLine.Data = gGrpScheduleLine;
             // Setting for path line
             pLine.Stroke = new SolidColorBrush(Colors.Blue);
             pLine.StrokeThickness = STROKE_LINE;
             pLine.Data = gGrpLine;
             // Setting for path of curver line
             pCurverLine.Stroke = Brushes.Red;
             pCurverLine.StrokeThickness = STROKE_LINE;
             pCurverLine.Data = gGrpCurverLine;
             // Setting for path of red node
             pRedNode.Stroke = new SolidColorBrush(Colors.Blue);
             pRedNode.Fill = new SolidColorBrush(Colors.Red);
             pRedNode.StrokeThickness = STROKE_NODE;
             pRedNode.Data = gGrpRedNode;
             // Setting for path of yellow node
             pYellowNode.Stroke = new SolidColorBrush(Colors.Blue);
             pYellowNode.Fill = new SolidColorBrush(Colors.Yellow);
             pYellowNode.StrokeThickness = STROKE_NODE;
             pYellowNode.Data = gGrpYellowNode;
             // Setting for path of Blue node
             pBlueNode.Stroke = new SolidColorBrush(Colors.Blue);
             pBlueNode.Fill = new SolidColorBrush(Colors.LightBlue);
             pBlueNode.StrokeThickness = STROKE_NODE;
             pBlueNode.Data = gGrpBlueNode;
             // Add paths to canvas
             this.Children.Add(pLine);
             this.Children.Add(pCurverLine);
             this.Children.Add(pRedNode);
             this.Children.Add(pYellowNode);
             //this.Children.Add(pNewLine);
             scheduleCanvas.Children.Add(pScheduleLine);
         }
         /// <summary>
         /// Clear all route
         /// </summary>
         public void ClearRoute()
         {
             isStartDrawRoute = false;
             isGoalDrawRoute = false;
             gGrpLine.Children.Clear();
             gGrpRootLine.Children.Clear();
             gGrpCurverLine.Children.Clear();
             gGrpRedNode.Children.Clear();
             gGrpYellowNode.Children.Clear();
             gGrpBlueNode.Children.Clear();
             this.Children.Remove(pLine);
             this.Children.Remove(pRootLine);
             this.Children.Remove(pCurverLine);
             this.Children.Remove(pRedNode);
             this.Children.Remove(pYellowNode);
             this.Children.Remove(pBlueNode);
         }
         /// <summary>
         /// Draw line for route
         /// </summary>
         /// <param name="startPoint">Start point</param>
         /// <param name="endPoint">End point</param>
         /// <param name="geometryGroup">Geometry Group</param>
         private void DrawLine(Point startPoint, Point endPoint, GeometryGroup geometryGroup)
         {
             LineGeometry lineGeometry = new LineGeometry();
             lineGeometry.StartPoint = startPoint;
             lineGeometry.EndPoint = endPoint;
             geometryGroup.Children.Add(lineGeometry);
         }
         /// <summary>
         /// Draw curver line
         /// </summary>
         /// <param name="startPoint">Point start curver line</param>
         /// <param name="endPoint">Point end curver line</param>
         /// <param name="radius">Radius</param>
         /// <param name="geometryGroup">Geometry Group</param>
         private void DrawCurverLine(Point startPoint, Point endPoint, SweepDirection sweepDirection, GeometryGroup geometryGroup)
         {
             PathGeometry pathGeometry = new PathGeometry();
             PathFigure figure = new PathFigure();
             figure.StartPoint = startPoint;
             figure.Segments.Add(new ArcSegment(endPoint, new Size(RADIUS_CURVER_LINE, RADIUS_CURVER_LINE), 90, false, sweepDirection, true));
             pathGeometry.Figures.Add(figure);
             geometryGroup.Children.Add(pathGeometry);
         }
         /// <summary>
         /// Setting node
         /// </summary>
         /// <param name="centerPoit">Position of center node</param>
         /// <param name="geometryGroup">Geometry Group</param>
         private void AddNode(Point centerPoit, GeometryGroup geometryGroup)
         {
             double radius = RADIUS_NODE;
             geometryGroup.Children.Add(new EllipseGeometry(centerPoit, radius, radius));
         }
         /// <summary>
         /// Check line is vertical or horizontal
         /// </summary>
         /// <param name="line"></param>
         /// <returns>true:Vertical, false:Horizontal</returns>
         private bool IsVerticalLine(LineGeometry line)
         {
             if (line.StartPoint.X == line.EndPoint.X)
             {
                 // Vertical line
                 return true;
             }
             // Horizontal line
             return false;
         }
         /// <summary>
         /// Get distance between two point
         /// </summary>
         /// <param name="point1">Point 1</param>
         /// <param name="point2">Point 2</param>
         /// <returns>Distance between two point</returns>
         private double GetDistance(Point point1, Point point2)
         {
             //pythagorean theorem c^2 = a^2 + b^2
             //thus c = square root(a^2 + b^2)
             double a = (double)(point2.X - point1.X);
             double b = (double)(point2.Y - point1.Y);
             return Math.Sqrt(a * a + b * b);
         }
         /// <summary>
         /// Check point is valid for draw
         /// </summary>
         /// <param name="point">Poit need check</param>
         /// <returns>true:Valid, false:Invalid</returns>
         private bool IsValidPoint(Point point)
         {
             return true;
         }
         /// <summary>
         /// Display coordinate position
         /// </summary>
         /// <param name="point">Position to display</param>
         private void DisplayCoordinate(Point point)
         {
             if (_displayAxiPosition == null)
             {
                 _displayAxiPosition = new ucDisplayCoordinate();
                 this.Children.Add(_displayAxiPosition);
             }
             _displayAxiPosition.Display(point);
         }
         #endregion
         #region Functions for Set Auto Nodes
         /// <summary>
         /// SetAutoNodes
         /// </summary>
         public void SetAutoNodes()
         {
             double radiusStart = DISTANCE_START_NODES;
             double radiusEnd = DISTANCE_END_NODES;
             double radiusCurver = RADIUS_CURVER_LINE;
             Point startNode;
             Point endNode;
             gGrpBlueNode.Children.Clear();
             if (gGrpLine.Children.Count == 1)
                 radiusCurver = radiusEnd;
             if (gGrpLine.Children.Count > 0)
             {
                 for (int i = 0; i < gGrpLine.Children.Count; i++)
                 {
                     LineGeometry lineGeometry = (LineGeometry)gGrpLine.Children[i];
                     if (i == 0)
                     {
                         startNode = lineGeometry.EndPoint;
                         endNode = lineGeometry.StartPoint;
                         DrawAutoNodes(startNode, endNode, radiusCurver, radiusStart);
                     }
                     else if (i == gGrpLine.Children.Count - 1 && i > 0)
                     {
                         startNode = lineGeometry.StartPoint;
                         endNode = lineGeometry.EndPoint;
                         DrawAutoNodes(startNode, endNode, radiusCurver, radiusEnd);
                     }
                     else
                     {
                         startNode = lineGeometry.StartPoint;
                         endNode = lineGeometry.EndPoint;
                         DrawAutoNodes(startNode, endNode, radiusCurver, radiusCurver);
                     }
                 }
             }
         }
         /// <summary>
         /// DrawAutoNodes
         /// </summary>
         /// <param name="startNode"></param>
         /// <param name="endNode"></param>
         /// <param name="radiusStart"></param>
         /// <param name="radiusEnd"></param>
         private void DrawAutoNodes(Point startNode, Point endNode, double radiusStart, double radiusEnd)
         {
             double distance = DISTANCE_AUTO_NODES;
             double i;
             Point node;
             // Get postion of blue node on line
             if (startNode.X == endNode.X)
             {
                 if (startNode.Y > endNode.Y)
                 {
                     i = startNode.Y - radiusStart;
                     if (i - distance > endNode.Y + radiusEnd)
                     {
                         do
                         {
                             i = i - distance;
                             node = new Point(endNode.X, i);
                             // Add node to postion distance 1000mm
                             AddNode(node, gGrpBlueNode);
                         } while (i > endNode.Y + radiusEnd + distance);
                     }
                 }
                 else
                 {
                     i = startNode.Y + radiusStart;
                     if (i + distance < endNode.Y - radiusEnd)
                     {
                         do
                         {
                             i = i + distance;
                             node = new Point(endNode.X, i);
                             // Add node to postion distance 1000mm
                             AddNode(node, gGrpBlueNode);
                         } while (i < endNode.Y - radiusEnd - distance);
                     }
                 }
             }
             else
             {
                 if (startNode.X > endNode.X)
                 {
                     i = startNode.X - radiusStart;
                     if (i - distance > endNode.X + radiusEnd)
                     {
                         do
                         {
                             i = i - distance;
                             node = new Point(i, endNode.Y);
                             // Add node to postion distance 1000mm
                             AddNode(node, gGrpBlueNode);
                         } while (i > endNode.X + radiusEnd + distance);
                     }
                 }
                 else
                 {
                     i = startNode.X + radiusStart;
                     if (i + distance < endNode.X - radiusEnd)
                     {
                         do
                         {
                             i = i + distance;
                             node = new Point(i, endNode.Y);
                             // Add node to postion distance 1000mm
                             AddNode(node, gGrpBlueNode);
                         } while (i < endNode.X - radiusEnd - distance);
                     }
                 }
             }
         }
         #endregion
         #region Functions for Set Free Nodes
         /// <summary>
         /// Draw Auto Blue node
         /// </summary>
         public void SetFreeNodes(Point FreeNode, bool RightClick)
         {
             double radiusStart = DISTANCE_START_NODES;
             double radiusEnd = DISTANCE_END_NODES;
             double radiusNode = RADIUS_NODE;
             double radiusCurver = RADIUS_CURVER_LINE + RADIUS_NODE;
             EllipseGeometry ellipseGeometry;
             Point node;
             bool deleteFlag = false;
             if (RightClick)
             {
                 if (gGrpBlueNode.Children.Count > 0)
                 {
                     for (int i = 0; i < gGrpBlueNode.Children.Count; i++)
                     {
                         ellipseGeometry = (EllipseGeometry)gGrpBlueNode.Children[i];
                         node = ellipseGeometry.Center;
                         if (FreeNode.X == node.X)
                         {
                             if (CheckIsNode(FreeNode, node, radiusNode))
                             {
                                 deleteFlag = true;
                             }
                         }
                         else
                         {
                             if (CheckIsNode(FreeNode, node, radiusNode))
                             {
                                 deleteFlag = true;
                             }
                         }
                         if (deleteFlag)
                         {
                             MessageBoxResult result = MessageBox.Show("Do You Delete This Node?", "Delete Node", MessageBoxButton.OKCancel);
                             if (result == MessageBoxResult.OK)
                             {
                                 gGrpBlueNode.Children.RemoveAt(i);
                                 this.Children.Remove(NodeNo[i]);
                                 return;
                             }
                             else
                             {
                                 return;
                             }
                         }
                     }
                 }
             }
             else
             {
                 for (int i = 0; i < gGrpBlueNode.Children.Count; i++)
                 {
                     ellipseGeometry = (EllipseGeometry)gGrpBlueNode.Children[i];
                     node = ellipseGeometry.Center;
                     bool isEditNode = CheckIsNode(FreeNode, node, RADIUS_NODE);
                     if (isEditNode)
                     {
                         EditNode(node);
                         return;
                     }
                 }
                 MessageBoxResult result = MessageBox.Show("Do You Want To Add This Node?", "Add Node", MessageBoxButton.OKCancel);
                 if (result == MessageBoxResult.OK)
                 {
                     AddNode(FreeNode, gGrpBlueNode);
                     TextBlock textBlock = new TextBlock();
                     textBlock.Text = stt.ToString();
                     textBlock.FontSize = 17;
                     textBlock.Foreground = new SolidColorBrush(Colors.Red);
                     Canvas.SetLeft(textBlock, FreeNode.X - RADIUS_NODE / 2);
                     Canvas.SetTop(textBlock, FreeNode.Y - 1.5 * RADIUS_NODE);
                     this.Children.Add(textBlock);
                     NodeNo.Add(textBlock);
                     if (stt > 1)
                     {
                         int tmp = gGrpBlueNode.Children.Count;
                         EllipseGeometry elip = (EllipseGeometry)gGrpBlueNode.Children[tmp - 2];
                         Point node1 = elip.Center;
                         elip = (EllipseGeometry)gGrpBlueNode.Children[tmp - 1];
                         Point node2 = elip.Center;
                         DrawLine(node1, node2, gGrpCurverLine);
                     }
                     stt++;
                 }
             }
             if (gGrpLine.Children.Count > 0)
             {
                 for (int i = 0; i < gGrpLine.Children.Count; i++)
                 {
                     LineGeometry lineGeometry = (LineGeometry)gGrpLine.Children[i];
                     // Get postion of  node on line
                     if (IsVerticalLine(lineGeometry))
                     {
                         if (FreeNode.X < lineGeometry.EndPoint.X + radiusNode && FreeNode.X > lineGeometry.EndPoint.X - radiusNode)
                         {
                             FreeNode.X = lineGeometry.EndPoint.X;
                             if (i == 0)
                             {
                                 if (CheckFreeNodes(lineGeometry, FreeNode, radiusStart, radiusCurver))
                                 {
                                     AddNode(FreeNode, gGrpBlueNode);
                                 }
                             }
                             else if (i == gGrpLine.Children.Count - 1 && i > 0)
                             {
                                 if (CheckFreeNodes(lineGeometry, FreeNode, radiusCurver, radiusEnd))
                                 {
                                     AddNode(FreeNode, gGrpBlueNode);
                                 }
                             }
                             else
                             {
                                 if (CheckFreeNodes(lineGeometry, FreeNode, radiusCurver, radiusCurver))
                                 {
                                     AddNode(FreeNode, gGrpBlueNode);
                                 }
                             }
                         }
                     }
                     else
                     {
                         if (FreeNode.Y < lineGeometry.EndPoint.Y + radiusNode && FreeNode.Y > lineGeometry.EndPoint.Y - radiusNode)
                         {
                             FreeNode.Y = lineGeometry.EndPoint.Y;
                             if (i == 0)
                             {
                                 if (CheckFreeNodes(lineGeometry, FreeNode, radiusStart, radiusCurver))
                                 {
                                     AddNode(FreeNode, gGrpBlueNode);
                                 }
                             }
                             else if (i == gGrpLine.Children.Count - 1 && i > 0)
                             {
                                 if (CheckFreeNodes(lineGeometry, FreeNode, radiusCurver, radiusEnd))
                                 {
                                     AddNode(FreeNode, gGrpBlueNode);
                                 }
                             }
                             else
                             {
                                 if (CheckFreeNodes(lineGeometry, FreeNode, radiusCurver, radiusCurver))
                                 {
                                     AddNode(FreeNode, gGrpBlueNode);
                                 }
                             }
                         }
                     }
                 }
             }
         }
         public bool CheckFreeNodes(LineGeometry lineNode, Point Freenode, double radiusStart, double radiusEnd)
         {
             double distanceFreeNode = DISTANCE_FREE_NODES;
             double radiusNode = RADIUS_NODE;
             EllipseGeometry ellipseGeometry;
             Point node;
             if (IsVerticalLine(lineNode))
             {
                 if (lineNode.StartPoint.Y < lineNode.EndPoint.Y)
                 {
                     if (Freenode.Y < lineNode.StartPoint.Y + radiusStart || Freenode.Y > lineNode.EndPoint.Y - radiusEnd)
                     {
                         return false;
                     }
                 }
                 else
                 {
                     if (Freenode.Y > lineNode.StartPoint.Y - radiusStart || Freenode.Y < lineNode.EndPoint.Y + radiusEnd)
                     {
                         return false;
                     }
                 }
             }
             else
             {
                 if (lineNode.StartPoint.X < lineNode.EndPoint.X)
                 {
                     if (Freenode.X < lineNode.StartPoint.X + radiusStart || Freenode.X > lineNode.EndPoint.X - radiusEnd)
                     {
                         return false;
                     }
                 }
                 else
                 {
                     if (Freenode.X > lineNode.StartPoint.X - radiusStart || Freenode.X < lineNode.EndPoint.X + radiusEnd)
                     {
                         return false;
                     }
                 }
             }
             if (gGrpBlueNode.Children.Count > 0)
             {
                 for (int i = 0; i < gGrpBlueNode.Children.Count; i++)
                 {
                     ellipseGeometry = (EllipseGeometry)gGrpBlueNode.Children[i];
                     node = ellipseGeometry.Center;
                     if (Freenode.X == node.X)
                     {
                         if (CheckIsNode(Freenode, node, radiusNode))
                         {
                             return false;
                         }
                         else if (Freenode.Y < node.Y + distanceFreeNode && Freenode.Y > node.Y - distanceFreeNode)
                         {
                             return false;
                         }
                     }
                     else if (Freenode.Y == node.Y)
                     {
                         if (CheckIsNode(Freenode, node, radiusNode))
                         {
                             return false;
                         }
                         else if (Freenode.X < node.X + distanceFreeNode && Freenode.X > node.X - distanceFreeNode)
                         {
                             return false;
                         }
                     }
                 }
             }
             return true;
         }
         public bool CheckIsNode(Point FreeNode, Point Node, double radiusNode)
         {
             if (FreeNode.X < Node.X + radiusNode && FreeNode.X > Node.X - radiusNode && FreeNode.Y < Node.Y + radiusNode && FreeNode.Y > Node.Y - radiusNode)
             {
                 return true;
             }
             return false;
         }
         #endregion
         #region Edit Node
         public void InitNodeInfo_List()
         {
             //Reset List
             NodeInfo_List = new List<NodeInfo>();
             if (gGrpBlueNode.Children.Count > 0)
             {
                 // Get start point
                 LineGeometry lineGeometry = (LineGeometry)gGrpNewLine.Children[0];
                 Point startPoint = lineGeometry.StartPoint;
                 NodeInfo n1 = new NodeInfo();
                 n1.X = startPoint.X;
                 n1.Y = startPoint.Y;
                 n1.Mode1 = "";
                 n1.Mode2 = "";
                 n1.Mode3 = "";
                 NodeInfo_List.Add(n1);
                 for (int i = 0; i < gGrpBlueNode.Children.Count; i++)
                 {
                     Point point;
                     EllipseGeometry eGeometry = (EllipseGeometry)gGrpBlueNode.Children[i];
                     point = eGeometry.Center;
                     NodeInfo Ninfo = new NodeInfo();
                     Ninfo.X = point.X;
                     Ninfo.Y = point.Y;
                     Ninfo.Mode1 = "";
                     Ninfo.Mode2 = "";
                     Ninfo.Mode3 = "";
                     NodeInfo_List.Add(Ninfo);
                 }
                 // Get end point
                 lineGeometry = (LineGeometry)gGrpLine.Children[gGrpLine.Children.Count - 1];
                 Point endPoint = lineGeometry.EndPoint;
                 NodeInfo n2 = new NodeInfo();
                 n2.X = startPoint.X;
                 n2.Y = startPoint.Y;
                 n2.Mode1 = "";
                 n2.Mode2 = "";
                 n2.Mode3 = "";
                 NodeInfo_List.Add(n2);
                 //Resort NodeInfo_List From Start to Goal
                 LineGeometry firstLine = (LineGeometry)gGrpLine.Children[0];
                 Point startNode = firstLine.StartPoint;
                 Point endNode = firstLine.EndPoint;
                 List<NodeInfo> tmpLst = new List<NodeInfo>();
                 // Create temp List
                 if (startNode.X == endNode.X)
                 {
                     for (int i = 1; i < NodeInfo_List.Count; i++)
                     {
                         if (NodeInfo_List[i].X != endNode.X)
                         {
                             break;
                         }
                         else
                         {
                             tmpLst.Add(NodeInfo_List[i]);
                         }
                     }
                 }
                 if (startNode.Y == endNode.Y)
                 {
                     for (int i = 1; i < NodeInfo_List.Count; i++)
                     {
                         if (NodeInfo_List[i].Y != endNode.Y)
                         {
                             break;
                         }
                         else
                         {
                             tmpLst.Add(NodeInfo_List[i]);
                         }
                     }
                 }
                 // Sort NodeInfo_List
                 for (int i = 0; i < tmpLst.Count; i++)
                 {
                     NodeInfo_List[i + 1] = tmpLst[tmpLst.Count - 1 - i];
                 }
             }
         }
         public void EditNode(Point node_edited)
         {
             EllipseGeometry ellipseGeometry;
             Point node;
             double radiusNode = RADIUS_NODE;
             bool flag = false;
             if (gGrpBlueNode.Children.Count > 0)
             {
                 for (int i = 0; i < gGrpBlueNode.Children.Count; i++)
                 {
                     ellipseGeometry = (EllipseGeometry)gGrpBlueNode.Children[i];
                     node = ellipseGeometry.Center;
                     if (CheckIsNode(node_edited, node, radiusNode))
                     {
                         flag = true;
                     }
                     if (flag)
                     {
                         node_edited.X = node.X;
                         node_edited.Y = node.Y;
                         // show form edit node
                         EditNodeWindow edtNodeWindow = new EditNodeWindow();
                         edtNodeWindow.ShowDialog();
                         string result1 = edtNodeWindow._txtMode1;
                         string result2 = edtNodeWindow._txtMode2;
                         string result3 = edtNodeWindow._txtMode3;
                         bool exit = edtNodeWindow._ExitFlg;
                         if (!exit)
                         {
                             SaveChanged(node_edited.X, node_edited.Y, result1, result2, result3);
                         }
                         return;
                     }
                 }
             }
         }
         public void SaveChanged(double x, double y, string st1, string st2, string st3)
         {
             for (int i = 0; i < NodeInfo_List.Count; i++)
             {
                 NodeInfo ni = new NodeInfo();
                 ni = NodeInfo_List[i];
                 if (ni.X == x && ni.Y == y)
                 {
                     ni.Mode1 = st1;
                     ni.Mode2 = st2;
                     ni.Mode3 = st3;
                     NodeInfo_List[i] = ni;
                     return;
                 }
             }
         }
         #endregion
         #region Display RouteInfo
         public void DspRouteInfo()
         {
             //Clear Route Info Table
             ((RoboforkMenu)System.Windows.Application.Current.MainWindow).grdRouteInfo.Children.Clear();
             if (NodeInfo_List.Count != 0)
             {
                 int _RowIdx = 0;
                 string _Content = "";
                 for (int i = 0; i < NodeInfo_List.Count; i++)
                 {
                     NodeInfo ni = new NodeInfo();
                     ni = NodeInfo_List[i];
                     //column 1
                     if (i == 0)
                     {
                         _Content = "S";
                     }
                     else if (i == NodeInfo_List.Count - 1)
                     {
                         _Content = "G";
                     }
                     else
                     {
                         _Content = i.ToString();
                     }
                     AddLabeltoGrid(_RowIdx, 0, _Content);
                     //column 2
                     // Display Node's Position
                     _Content = ni.X + ", " + ni.Y;
                     AddLabeltoGrid(_RowIdx, 1, _Content);
                     // Display Node's Field
                     if (ni.Mode1 != "" && ni.Mode1 != null)
                     {
                         char delimiterChars = '_';
                         string[] tmp = ni.Mode1.Split(delimiterChars);
                         foreach (string s in tmp)
                         {
                             _RowIdx++;
                             delimiterChars = ':';
                             if (s.Split(delimiterChars)[0] == "Mode")
                             {
                                 double distance = 0;
                                 if (i == NodeInfo_List.Count - 1)
                                 {
                                     distance = 0;
                                 }
                                 else
                                 {
                                     distance = DistanceCalculate(NodeInfo_List[i].X, NodeInfo_List[i].Y, NodeInfo_List[i + 1].X, NodeInfo_List[i + 1].Y);
                                 }
                                 _Content = "MOVE " + distance.ToString() + "mm";
                             }
                             else
                             {
                                 _Content = s.Split(delimiterChars)[0] + " " + s.Split(delimiterChars)[1];
                             }
                             AddLabeltoGrid(_RowIdx, 1, _Content);
                         }
                     }
                     if (ni.Mode2 != "" && ni.Mode2 != null)
                     {
                         char delimiterChars = '_';
                         string[] tmp = ni.Mode2.Split(delimiterChars);
                         foreach (string s in tmp)
                         {
                             _RowIdx++;
                             delimiterChars = ':';
                             if (s.Split(delimiterChars)[0] == "Mode")
                             {
                                 double distance = 0;
                                 if (i == NodeInfo_List.Count - 1)
                                 {
                                     distance = 0;
                                 }
                                 else
                                 {
                                     distance = DistanceCalculate(NodeInfo_List[i].X, NodeInfo_List[i].Y, NodeInfo_List[i + 1].X, NodeInfo_List[i + 1].Y);
                                 }
                                 _Content = "MOVE " + distance.ToString() + "mm";
                             }
                             else
                             {
                                 _Content = s.Split(delimiterChars)[0] + " " + s.Split(delimiterChars)[1];
                             }
                             AddLabeltoGrid(_RowIdx, 1, _Content);
                         }
                     }
                     if (ni.Mode3 != "" && ni.Mode3 != null)
                     {
                         char delimiterChars = '_';
                         string[] tmp = ni.Mode3.Split(delimiterChars);
                         foreach (string s in tmp)
                         {
                             _RowIdx++;
                             delimiterChars = ':';
                             if (s.Split(delimiterChars)[0] == "Mode")
                             {
                                 double distance = 0;
                                 if (i == NodeInfo_List.Count - 1)
                                 {
                                     distance = 0;
                                 }
                                 else
                                 {
                                     distance = DistanceCalculate(NodeInfo_List[i].X, NodeInfo_List[i].Y, NodeInfo_List[i + 1].X, NodeInfo_List[i + 1].Y);
                                 }
                                 _Content = "MOVE " + distance.ToString() + "mm";
                             }
                             else
                             {
                                 _Content = s.Split(delimiterChars)[0] + " " + s.Split(delimiterChars)[1];
                             }
                             AddLabeltoGrid(_RowIdx, 1, _Content);
                         }
                     }
                     _RowIdx++;
                 }
             }
         }
         public double DistanceCalculate(double _X1, double _Y1, double _X2, double _Y2)
         {
             double dist = 0;
             if (_X1 == _X2)
             {
                 dist = System.Math.Abs(_Y1 - _Y2) * DISTANCE_RATIO;
             }
             else if (_Y1 == _Y2)
             {
                 dist = System.Math.Abs(_X1 - _X2) * DISTANCE_RATIO;
             }
             return dist;
         }
         public void AddLabeltoGrid(int RowIdx, int ColIdx, string Content)
         {
             //Add Row to Grid
             RowDefinition _rd = new RowDefinition();
             ((RoboforkMenu)System.Windows.Application.Current.MainWindow).grdRouteInfo.RowDefinitions.Add(_rd);
             // Add data to Grid
             Label dynamicLabel = new Label();
             dynamicLabel.Content = Content;
             dynamicLabel.Margin = new Thickness(0, 0, 0, 0);
             dynamicLabel.Foreground = new SolidColorBrush(Colors.Black);
             dynamicLabel.Background = new SolidColorBrush(Colors.White);
             dynamicLabel.BorderBrush = new SolidColorBrush(Colors.LightGray);
             dynamicLabel.BorderThickness = new Thickness(1);
             Grid.SetRow(dynamicLabel, RowIdx);
             Grid.SetColumn(dynamicLabel, ColIdx);
             ((RoboforkMenu)System.Windows.Application.Current.MainWindow).grdRouteInfo.Children.Add(dynamicLabel);
         }
         #endregion
         public void CreateGoalPoint()
         {
             if (isGoalDrawRoute)
             {
                 return;
             }
             isStartDrawRoute = false;
             if (_goalPoint == null)
             {
                 _goalPoint = new ucStartEndButton();
                 _goalPoint.btnWidth = 50.0;
                 _goalPoint.btnHeight = 50.0;
                 _goalPoint.buttText = "G";
                 Canvas.SetLeft(_goalPoint, 675);
                 Canvas.SetTop(_goalPoint, 75);
                 this.Children.Add(_goalPoint);
             }
         }
         public void CreateStartPoint()
         {
             if (isGoalDrawRoute)
             {
                 return;
             }
             isStartDrawRoute = false;
             if (_startPoint == null)
             {
                 _startPoint = new ucStartEndButton();
                 _startPoint.btnWidth = 50.0;
                 _startPoint.btnHeight = 50.0;
                 _startPoint.buttText = "S";
                 Canvas.SetLeft(_startPoint, 75);
                 Canvas.SetTop(_startPoint, 675);
                 this.Children.Add(_startPoint);
             }
         }
         #region Draw New FreeNode
         /// <summary>
         /// Draw Auto Blue node
         /// </summary>
         public void NewSetFreeNodes(Point FreeNode, bool RightClick)
         {
             double radiusNode = RADIUS_NODE;
             EllipseGeometry ellipseGeometry;
             Point node;
             bool deleteFlag = false;
             if (RightClick)
             {
                 if (gGrpBlueNode.Children.Count > 0)
                 {
                     for (int i = 0; i < gGrpBlueNode.Children.Count; i++)
                     {
                         ellipseGeometry = (EllipseGeometry)gGrpBlueNode.Children[i];
                         node = ellipseGeometry.Center;
                         if (FreeNode.X == node.X)
                         {
                             if (CheckIsNode(FreeNode, node, radiusNode))
                             {
                                 deleteFlag = true;
                             }
                         }
                         else
                         {
                             if (CheckIsNode(FreeNode, node, radiusNode))
                             {
                                 deleteFlag = true;
                             }
                         }
                         if (deleteFlag)
                         {
                             MessageBoxResult result = MessageBox.Show("Do You Delete This Node?", "Delete Node", MessageBoxButton.OKCancel);
                             if (result == MessageBoxResult.OK)
                             {
                                 //Call Function Delete Node
                                 DeleteNode(i);
                                 return;
                             }
                             else
                             {
                                 return;
                             }
                         }
                     }
                 }
             }
             else
             {
                 //Check EditNode State
                 for (int i = 0; i < gGrpBlueNode.Children.Count; i++)
                 {
                     ellipseGeometry = (EllipseGeometry)gGrpBlueNode.Children[i];
                     node = ellipseGeometry.Center;
                     bool isEditNode = CheckIsNode(FreeNode, node, RADIUS_NODE);
                     if (isEditNode)
                     {
                         NewEditNode(node);
                         NewDspRouteInfo();
                         return;
                     }
                 }
                 MessageBoxResult result = MessageBox.Show("Do You Want To Add This Node?", "Add Node", MessageBoxButton.OKCancel);
                 if (result == MessageBoxResult.OK)
                 {
                     AddNode(FreeNode, gGrpBlueNode);
                     TextBlock textBlock = new TextBlock();
                     textBlock.Text = stt.ToString();
                     textBlock.FontSize = 35;
                     textBlock.VerticalAlignment = VerticalAlignment.Center;
                     textBlock.HorizontalAlignment = HorizontalAlignment.Center;
                     textBlock.Foreground = new SolidColorBrush(Colors.Red);
                     Canvas.SetLeft(textBlock, FreeNode.X - RADIUS_NODE / 2);
                     Canvas.SetTop(textBlock, FreeNode.Y - 1.5 * RADIUS_NODE);
                     this.Children.Add(textBlock);
                     NodeNo.Add(textBlock);
                     if (stt > 1)
                     {
                         int tmp = gGrpBlueNode.Children.Count;
                         EllipseGeometry elip = (EllipseGeometry)gGrpBlueNode.Children[tmp - 2];
                         Point node1 = elip.Center;
                         elip = (EllipseGeometry)gGrpBlueNode.Children[tmp - 1];
                         Point node2 = elip.Center;
                         DrawLine(node1, node2, gGrpNewLine);
                         this.Children.Remove(pBlueNode);
                         for (int i = 0; i < tmp; i++)
                         {
                             this.Children.Remove(NodeNo[i]);
                         }
                         this.Children.Add(pBlueNode);
                         for (int i = 0; i < tmp; i++)
                         {
                             this.Children.Add(NodeNo[i]);
                         }
                     }
                     stt++;
                     NewInitNodeInfo_List();
                     NewDspRouteInfo();
                 }
             }
         }
         public void DeleteNode(int i)
         {
             //DrawLine(Point startPoint, Point endPoint, GeometryGroup geometryGroup)
             LineGeometry lineGeometry = new LineGeometry();
             EllipseGeometry ellip;
             //check delete last node
             if (i == gGrpBlueNode.Children.Count - 1)
             {
                 // delete line
                 if (gGrpNewLine.Children.Count > 0)
                 {
                     gGrpNewLine.Children.RemoveAt(i - 1);
                 }
                 // delete ucNode
                 ucNode _ucNode = new ucNode();
                 _ucNode = ucNode_Lst[i];
                 this.Children.Remove(_ucNode);
                 ucNode_Lst.RemoveAt(i);
                 // delete node
                 gGrpBlueNode.Children.RemoveAt(i);
                 NewNodeInfo_List.RemoveAt(i);
             }
             else
             {
                 //delete all line and remove Point at 'i'
                 gGrpNewLine.Children.Clear();
                 this.Children.Remove(pNewLine);
                 gGrpBlueNode.Children.RemoveAt(i);
                 //redraw line
                 for (int j = 0; j < gGrpBlueNode.Children.Count - 1; j++)
                 {
                     ellip = (EllipseGeometry)gGrpBlueNode.Children[j];
                     Point node1 = ellip.Center;
                     ellip = (EllipseGeometry)gGrpBlueNode.Children[j + 1];
                     Point node2 = ellip.Center;
                     DrawLine(node1, node2, gGrpNewLine);
                 }
                 this.Children.Add(pNewLine);
                 //remove ucNode
                 for (int j = ucNode_Lst.Count - 1; j > i; j--)
                 {
                     ucNode_Lst[j].txtNode = ucNode_Lst[j - 1].txtNode;
                 }
                 this.Children.Remove(ucNode_Lst[i]);
                 ucNode_Lst.RemoveAt(i);
                 //redraw ucNode
                 for (int k = 0; k < ucNode_Lst.Count; k++)
                 {
                     this.Children.Remove(ucNode_Lst[k]);
                     this.Children.Add(ucNode_Lst[k]);
                 }
             }
             //NewInitNodeInfo_List();
             Lst_Node_tmp.RemoveAt(i);
             NewDspRouteInfo();
             stt--;
         }
         public void ReDrawAllNode()
         {
             LineGeometry lineGeometry = new LineGeometry();
             EllipseGeometry ellip;
             //delete all line
             gGrpNewLine.Children.Clear();
             this.Children.Remove(pNewLine);
             //redraw line
             for (int j = 0; j < gGrpBlueNode.Children.Count - 1; j++)
             {
                 ellip = (EllipseGeometry)gGrpBlueNode.Children[j];
                 Point node1 = ellip.Center;
                 ellip = (EllipseGeometry)gGrpBlueNode.Children[j + 1];
                 Point node2 = ellip.Center;
                 DrawLine(node1, node2, gGrpNewLine);
             }
             this.Children.Add(pNewLine);
             //redraw ucNode
             for (int k = 0; k < ucNode_Lst.Count; k++)
             {
                 this.Children.Remove(ucNode_Lst[k]);
                 this.Children.Add(ucNode_Lst[k]);
             }
             //backup DB
             CreateVehicleNode();
         }
         public void NewInitNodeInfo_List()
         {
             //Reset List
             //NewNodeInfo_List = new List<NewNodeInfo>();
             if (gGrpBlueNode.Children.Count > 0)
             {
                 //for (int i = 0; i < gGrpBlueNode.Children.Count; i++)
                 //{
                 int i = gGrpBlueNode.Children.Count - 1;
                 Point point;
                 EllipseGeometry eGeometry = (EllipseGeometry)gGrpBlueNode.Children[i];
                 point = eGeometry.Center;
                 NewNodeInfo Ninfo = new NewNodeInfo();
                 Ninfo.X = point.X;
                 Ninfo.Y = point.Y;
                 Ninfo.Mode = "";
                 NewNodeInfo_List.Add(Ninfo);
                 //}
             }
         }
         public void NewEditNode(Point node_edited)
         {
             EllipseGeometry ellipseGeometry;
             Point node;
             double radiusNode = RADIUS_NODE;
             bool flag = false;
             if (gGrpBlueNode.Children.Count > 0)
             {
                 for (int i = 0; i < gGrpBlueNode.Children.Count; i++)
                 {
                     ellipseGeometry = (EllipseGeometry)gGrpBlueNode.Children[i];
                     node = ellipseGeometry.Center;
                     if (CheckIsNode(node_edited, node, radiusNode))
                     {
                         flag = true;
                     }
                     if (flag)
                     {
                         node_edited.X = node.X;
                         node_edited.Y = node.Y;
                         // show form edit node
                         EditNodeWindow edtNodeWindow = new EditNodeWindow();
                         edtNodeWindow.ShowDialog();
                         string result = edtNodeWindow._txtMode;
                         List<EditNodeWindow.NodeInf> tmp = edtNodeWindow.NodeInf_List;
                         for (int j = 0; j < tmp.Count; j++)
                         {
                             EditNodeWindow.NodeInf ni = new EditNodeWindow.NodeInf();
                             ni.Mode = tmp[j].Mode;
                             ni.Speed = tmp[j].Speed;
                             ni.Angle = tmp[j].Angle;
                             ni.Height = tmp[j].Height;
                             ListNodeInfo NodeInfo_tmp = new ListNodeInfo();
                             NodeInfo_tmp.Mode = ni.Mode;
                             NodeInfo_tmp.Speed = ni.Speed;
                             NodeInfo_tmp.Angle = ni.Angle;
                             NodeInfo_tmp.Height = ni.Height;
                             Lst_Node_tmp[i].NodeInfo_tmp.Add(NodeInfo_tmp);
                         }
                         //backup DB
                         CreateVehicleNode();
                         bool exit = edtNodeWindow._ExitFlg;
                         if (!exit)
                         {
                             NewSaveChanged(node_edited.X, node_edited.Y, result);
                         }
                         return;
                     }
                 }
             }
         }
         //Save Node's Data Edited
         public void NewSaveChanged(double x, double y, string st)
         {
             for (int i = 0; i < NewNodeInfo_List.Count; i++)
             {
                 NewNodeInfo ni = new NewNodeInfo();
                 ni = NewNodeInfo_List[i];
                 if (ni.X == x && ni.Y == y)
                 {
                     ni.Mode = st;
                     NewNodeInfo_List[i] = ni;
                     return;
                 }
             }
         }
         public void NewDspRouteInfo()
         {
             //Clear Route Info Table
             ((RoboforkMenu)System.Windows.Application.Current.MainWindow).grdRouteInfo.Children.Clear();
             int _RowIdx = 0;
             string _Content = "";
             if (Lst_Node_tmp.Count != 0)
             {
                 for (int i = 0; i < Lst_Node_tmp.Count; i++)
                 {
                     //column 1 : node index
                     _Content = (i + 1).ToString();
                     AddLabeltoGrid(_RowIdx, 0, _Content);
                     //column 2
                     // Display Node's Position
                     _Content = "LAT " + Lst_Node_tmp[i].pointMap_X;
                     AddLabeltoGrid(_RowIdx, 1, _Content);
                     _RowIdx++;
                     _Content = "LOC " + Lst_Node_tmp[i].pointMap_Y;
                     AddLabeltoGrid(_RowIdx, 1, _Content);
                     // Display Node's Field
                     if (Lst_Node_tmp[i].NodeInfo_tmp.Count != 0)
                     {
                         foreach (ListNodeInfo ni in Lst_Node_tmp[i].NodeInfo_tmp)
                         {
                             if (ni.Speed != 0)
                             {
                                 _RowIdx++;
                                 _Content = "SPD " + ni.Speed.ToString() + " Km/h";
                                 AddLabeltoGrid(_RowIdx, 1, _Content);
                             }
                         }
                     }
                     _RowIdx++;
                 }
             }
         }
         //2017/03/07 tach rieng CreateNode start
         private void execDeleteNode(Point FreeNode)
         {
             double radiusNode = RADIUS_NODE;
             EllipseGeometry ellipseGeometry;
             Point node;
             bool deleteFlag = false;
             if (gGrpBlueNode.Children.Count > 0)
             {
                 for (int i = 0; i < gGrpBlueNode.Children.Count; i++)
                 {
                     ellipseGeometry = (EllipseGeometry)gGrpBlueNode.Children[i];
                     node = ellipseGeometry.Center;
                     if (FreeNode.X == node.X)
                     {
                         if (CheckIsNode(FreeNode, node, radiusNode))
                         {
                             deleteFlag = true;
                         }
                     }
                     else
                     {
                         if (CheckIsNode(FreeNode, node, radiusNode))
                         {
                             deleteFlag = true;
                         }
                     }
                     if (deleteFlag)
                     {
                         MessageBoxResult result = MessageBox.Show("Do You Delete This Node?", "Delete Node", MessageBoxButton.OKCancel);
                         if (result == MessageBoxResult.OK)
                         {
                             DeleteNode(i);
                             SetScheduleRoute();
                             return;
                         }
                         else
                         {
                             return;
                         }
                     }
                 }
             }
         }
         private void execEditNode(Point FreeNode)
         {
             EllipseGeometry ellipseGeometry;
             Point node;
             for (int i = 0; i < gGrpBlueNode.Children.Count; i++)
             {
                 ellipseGeometry = (EllipseGeometry)gGrpBlueNode.Children[i];
                 node = ellipseGeometry.Center;
                 bool isEditNode = CheckIsNode(FreeNode, node, RADIUS_NODE);
                 if (isEditNode)
                 {
                     NewEditNode(node);
                     NewDspRouteInfo();
                     return;
                 }
             }
         }
         private void execCreateNode(Point FreeNode)
         {
             //check new node in exist line
             if (gGrpNewLine.Children.Count > 0)
             {
                 for (int i = 0; i < gGrpNewLine.Children.Count; i++)
                 {
                     LineGeometry lineGeometry = (LineGeometry)gGrpNewLine.Children[i];
                     Point p1 = lineGeometry.StartPoint;
                     Point p2 = lineGeometry.EndPoint;
                     bool pInL = PointInLine(FreeNode, p1, p2, UCNODE_SETLEFT);
                     if (pInL)
                     {
                         MessageBoxResult result = MessageBox.Show("Do You Want To Add This Node?", "Add Node", MessageBoxButton.OKCancel);
                         if (result == MessageBoxResult.OK)
                         {
                             Point tmpPoint = ConvertNodeinLine(FreeNode, p1, p2);
                             FreeNode = tmpPoint;
                             CreateMapNode(FreeNode, i + 1, ColorNode_Insert);
                             gGrpBlueNode.Children.Insert(i + 1, new EllipseGeometry(FreeNode, RADIUS_NODE, RADIUS_NODE));
                             //set location infor to table info
                             SetLoc_NodeInfoList(FreeNode, i + 1);
                             SetScheduleRoute();
                             ListIndexNodeInsert ListIndex = new ListIndexNodeInsert();
                             ListIndex.X = FreeNode.X;
                             ListIndex.Y = FreeNode.Y;
                             IndexNodeInsert_List.Add(ListIndex);
                             //rename Point textName
                             for (int j = 0; j < ucNode_Lst.Count; j++)
                             {
                                 ucNode_Lst[j].txtNode = (j + 1).ToString();
                                 this.Children.Remove(ucNode_Lst[j]);
                                 this.Children.Add(ucNode_Lst[j]);
                             }
                             ReDrawAllNode();
                             stt++;
                             NewInitNodeInfo_List();
                             NewDspRouteInfo();
                             return;
                         }
                         else
                         {
                             return;
                         }
                     }
                 }
             }
             CreateMapNode(FreeNode, gGrpBlueNode.Children.Count, ColorNode_Add);
             gGrpBlueNode.Children.Insert(gGrpBlueNode.Children.Count, new EllipseGeometry(FreeNode, RADIUS_NODE, RADIUS_NODE));
             //set location infor to table info
             SetLoc_NodeInfoList(FreeNode, gGrpBlueNode.Children.Count - 1);
             SetScheduleRoute();
             //draw line
             if (stt > 1)
             {
                 //delete all line
                 gGrpNewLine.Children.Clear();
                 this.Children.Remove(pNewLine);
                 //redraw line
                 for (int j = 0; j < gGrpBlueNode.Children.Count - 1; j++)
                 {
                     EllipseGeometry ellip = (EllipseGeometry)gGrpBlueNode.Children[j];
                     Point node1 = ellip.Center;
                     ellip = (EllipseGeometry)gGrpBlueNode.Children[j + 1];
                     Point node2 = ellip.Center;
                     DrawLine(node1, node2, gGrpNewLine);
                 }
                 this.Children.Add(pNewLine);
                 //rename Point textName
                 for (int j = 0; j < ucNode_Lst.Count; j++)
                 {
                     ucNode_Lst[j].txtNode = (j + 1).ToString();
                     this.Children.Remove(ucNode_Lst[j]);
                     this.Children.Add(ucNode_Lst[j]);
                 }
             }
             stt++;
             NewInitNodeInfo_List();
             NewDspRouteInfo();
         }
         public void CreateMapNode(Point FreeNode, int stt, String Color)
         {
             ucNode _ucNode = new ucNode();
             _ucNode.btnWidth = UCNODE_WIDTH;
             _ucNode.btnHeight = UCNODE_HEIGHT;
             _ucNode.txtNode = (stt + 1).ToString();
             _ucNode.fillColor = Color;
             _ucNode.IsDragDelta = true;
             Canvas.SetLeft(_ucNode, FreeNode.X - UCNODE_SETLEFT);
             Canvas.SetTop(_ucNode, FreeNode.Y - UCNODE_SETTOP);
             this.Children.Add(_ucNode);
             //ucNode_Lst.Add(_ucNode);
             ucNode_Lst.Insert(stt, _ucNode);
             //AddNode(FreeNode, gGrpBlueNode);
             //gGrpBlueNode.Children.Insert(stt, new EllipseGeometry(FreeNode, RADIUS_NODE, RADIUS_NODE));
         }
         public void SetLoc_NodeInfoList(Point FreeNode, int stt)
         {
             //add location for NodeInfoList
             Node_tmp nodetmp = new Node_tmp();
             nodetmp.pointMap_X = FreeNode.X;
             nodetmp.pointMap_Y = FreeNode.Y;
             Lst_Node_tmp.Insert(stt, nodetmp);
         }
         public void BindBlueNode2ucNode()
         {
             bool NodeIsInsert = false;
             if (gGrpBlueNode.Children.Count > 0)
             {
                 for (int i = 0; i < gGrpBlueNode.Children.Count; i++)
                 {
                     NodeIsInsert = false;
                     EllipseGeometry ellipseGeometry = (EllipseGeometry)gGrpBlueNode.Children[i];
                     Point node = ellipseGeometry.Center;
                     //Draw Node Insert Color is Brown
                     if (IndexNodeInsert_List.Count > 0)
                     {
                         for (int j = 0; j < IndexNodeInsert_List.Count; j++)
                         {
                             if (node.X == IndexNodeInsert_List[j].X && node.Y == IndexNodeInsert_List[j].Y)
                             {
                                 NodeIsInsert = true;
                             }
                         }
                     }
                     if (NodeIsInsert)
                     {
                         CreateMapNode(node, i, ColorNode_Insert);
                     }
                     else
                     {
                         CreateMapNode(node, i, ColorNode_Add);
                     }
                 }
             }
         }
         //2017/03/07 tach CreateNode End
         public Point ConvertNodeinLine(Point point, Point l1, Point l2)
         {
             Point pointResult = new Point();
             double X = 0;
             double Y = 0;
             double distance_Line = 0;
             double distance_l1ToPoint = 0;
             distance_Line = DistanceTo(l1, l2);
             distance_l1ToPoint = DistanceTo(l1, point);
             if (l1.X == l2.X)
             {
                 X = l1.X;
                 Y = point.Y;
             }
             else if (l1.Y == l2.Y)
             {
                 X = point.X;
                 Y = l1.Y;
             }
             else
             {
                 if (l1.X < l2.X)
                 {
                     if (l1.Y < l2.Y)
                     {
                         Y = l1.Y + (distance_l1ToPoint * (l2.Y - l1.Y) / distance_Line);
                         X = l1.X + (distance_l1ToPoint * (l2.X - l1.X) / distance_Line);
                     }
                     else
                     {
                         Y = l1.Y - (distance_l1ToPoint * (l1.Y - l2.Y) / distance_Line);
                         X = l1.X + (distance_l1ToPoint * (l2.X - l1.X) / distance_Line);
                     }
                 }
                 else
                 {
                     if (l1.Y < l2.Y)
                     {
                         Y = l1.Y + (distance_l1ToPoint * (l2.Y - l1.Y) / distance_Line);
                         X = l1.X - (distance_l1ToPoint * (l1.X - l2.X) / distance_Line);
                     }
                     else
                     {
                         Y = l1.Y - (distance_l1ToPoint * (l1.Y - l2.Y) / distance_Line);
                         X = l1.X - (distance_l1ToPoint * (l1.X - l2.X) / distance_Line);
                     }
                 }
             }
             pointResult.X = X;
             pointResult.Y = Y;
             return pointResult;
         }
         public static double DistanceTo(Point point1, Point point2)
         {
             var a = (double)(point2.X - point1.X);
             var b = (double)(point2.Y - point1.Y);
             return Math.Sqrt(a * a + b * b);
         }
         public bool PointInLine(Point point, Point l1, Point l2, double radius)
         {
             double distance = 0;
             bool falg = false;
             if (l1.X < l2.X)
             {
                 if (l1.Y < l2.Y)
                 {
                     if (point.X > l1.X - radius && point.X < l2.X + radius && point.Y > l1.Y - radius && point.Y < l2.Y + radius)
                     {
                         falg = true;
                     }
                 }
                 else
                 {
                     if (point.X > l1.X - radius && point.X < l2.X + radius && point.Y < l1.Y + radius && point.Y > l2.Y - radius)
                     {
                         falg = true;
                     }
                 }
             }
             else
             {
                 if (l1.Y < l2.Y)
                 {
                     if (point.X < l1.X + radius && point.X > l2.X - radius && point.Y > l1.Y - radius && point.Y < l2.Y + radius)
                     {
                         falg = true;
                     }
                 }
                 else
                 {
                     if (point.X < l1.X + radius && point.X > l2.X - radius && point.Y < l1.Y + radius && point.Y > l2.Y - radius)
                     {
                         falg = true;
                     }
                 }
             }
             if (falg == false)
             {
                 return false;
             }
             distance = DistanceFromPointToLine(point, l1, l2);
             if (distance > radius)
             {
                 return false;
             }
             return true;
         }
         public static double DistanceFromPointToLine(Point point, Point l1, Point l2)
         {
             return Math.Abs((l2.X - l1.X) * (l1.Y - point.Y) - (l1.X - point.X) * (l2.Y - l1.Y)) /
                     Math.Sqrt(Math.Pow(l2.X - l1.X, 2) + Math.Pow(l2.Y - l1.Y, 2));
         }
         #endregion
         #region Schedule
         public void SetScheduleRoute()
         {
             EllipseGeometry ellipseGeometry_1;
             EllipseGeometry ellipseGeometry_2;
             Point node_1;
             Point node_2;
             Point node_Schedule = new Point();
             double x_1 = 50;
             double y_1 = 80;
             double Totaldistance = 1270;
             if (ucScheduleNode_Lst.Count > 0)
             {
                 for (int i = 0; i < ucScheduleNode_Lst.Count; i++)
                 {
                     ucNode _ucScheduleNode = new ucNode();
                     _ucScheduleNode = ucScheduleNode_Lst[i];
                     scheduleCanvas.Children.Remove(_ucScheduleNode);
                 }
                 ucScheduleNode_Lst.Clear();
             }
             gGrpScheduleNode.Children.Clear();
             gGrpScheduleLine.Children.Clear();
+            //Remove existed simulation
+            if(scheduleCanvas.simulation !=null)
+            {
+                scheduleCanvas.Children.Remove(scheduleCanvas.simulation);
+            }
             List<double> distance = new List<double>();
             double addDistance;
             if (gGrpBlueNode.Children.Count > 0)
             {
                 for (int i = 0; i < gGrpBlueNode.Children.Count; i++)
                 {
                     ellipseGeometry_2 = (EllipseGeometry)gGrpBlueNode.Children[i];
                     node_2 = ellipseGeometry_2.Center;
                     if (i >= 1)
                     {
                         ellipseGeometry_1 = (EllipseGeometry)gGrpBlueNode.Children[i - 1];
                         node_1 = ellipseGeometry_1.Center;
                         if (node_1.X == node_2.X)
                         {
                             addDistance = Math.Abs(node_1.Y - node_2.Y);
                             distance.Add(addDistance);
                         }
                         else if (node_1.Y == node_2.Y)
                         {
                             addDistance = Math.Abs(node_1.X - node_2.X);
                             distance.Add(addDistance);
                         }
                         else
                         {
                             var a = (double)(node_2.X - node_1.X);
                             var b = (double)(node_2.Y - node_1.Y);
                             addDistance = Math.Sqrt(a * a + b * b);
                             distance.Add(addDistance);
                         }
                     }
                 }
             }
             if (distance.Count > 0)
             {
                 double total = 0;
                 double distance_i;
                 for (int i = 0; i < distance.Count; i++)
                 {
                     total = total + distance[i];
                 }
                 for (int i = 0; i < distance.Count; i++)
                 {
                     distance_i = distance[i] * (Totaldistance / total);
                     distance[i] = distance_i;
                 }
             }
             if (gGrpBlueNode.Children.Count > 0)
             {
                 node_Schedule.X = x_1;
                 node_Schedule.Y = y_1;
                 AddNode(node_Schedule, gGrpScheduleNode);
             }
             addDistance = 0;
             for (int i = 0; i < distance.Count; i++)
             {
                 node_Schedule.Y = y_1;
                 addDistance = addDistance + distance[i];
                 node_Schedule.X = addDistance;
                 AddNode(node_Schedule, gGrpScheduleNode);
             }
             if (gGrpScheduleNode.Children.Count > 0)
             {
                 for (int i = 0; i < gGrpScheduleNode.Children.Count; i++)
                 {
                     ellipseGeometry_1 = (EllipseGeometry)gGrpScheduleNode.Children[i];
                     node_1 = ellipseGeometry_1.Center;
                     if (i > 0)
                     {
                         ellipseGeometry_2 = (EllipseGeometry)gGrpScheduleNode.Children[i - 1];
                         node_2 = ellipseGeometry_2.Center;
                         DrawLine(node_1, node_2, gGrpScheduleLine);
                     }
                     CreateScheduleNode(node_1, i + 1);
                 }
             }
         }
         private void CreateScheduleNode(Point point, int indexNode)
         {
             ucNode _ucNode = new ucNode();
             _ucNode.btnWidth = UCNODE_WIDTH;
             _ucNode.btnHeight = UCNODE_HEIGHT;
             _ucNode.txtNode = indexNode.ToString();
             _ucNode.IsDragDelta = false;
             Canvas.SetLeft(_ucNode, point.X - UCNODE_SETLEFT);
             Canvas.SetTop(_ucNode, point.Y - UCNODE_SETTOP);
             scheduleCanvas.Children.Add(_ucNode);
             ucScheduleNode_Lst.Add(_ucNode);
         }
         #endregion
         #region Add Vehicle
         public void GetIndexVehicle()
         {
             bool flag = false;
             if (VehicleModel.VehicleModelList.Count > 0)
             {
                 for (int i = 0; i < VehicleModel.VehicleModelList.Count; i++)
                 {
                     if (VehicleItem == VehicleModel.VehicleModelList[i].VehicleName)
                     {
                         VehicleIndex = i;
                         flag = true;
                     }
                 }
                 if (!flag)
                 {
                     VehicleIndex = VehicleModel.VehicleModelList.Count;
                 }
             }
             else
             {
                 VehicleIndex = 0;
             }
         }
         public void GetdataVehicle()
         {
             GetIndexVehicle();
             if (VehicleModel.VehicleModelList.Count > 0)
             {
                 for (int i = 0; i < ucNode_Lst.Count; i++)
                 {
                     this.Children.Remove(ucNode_Lst[i]);
                 }
                 gGrpNewLine.Children.Clear();
                 this.Children.Remove(pNewLine);
                 ucNode_Lst.Clear();
                 Lst_Node_tmp.Clear();
                 gGrpBlueNode.Children.Clear();
                 gGrpScheduleNode.Children.Clear();
                 IndexNodeInsert_List.Clear();
                 if (VehicleIndex < VehicleModel.VehicleModelList.Count)
                 {
                     if (VehicleModel.VehicleModelList[VehicleIndex].pointMapList.Count > 0)
                     {
                         for (int k = 0; k < VehicleModel.VehicleModelList[VehicleIndex].pointMapList.Count; k++)
                         {
                             double X = VehicleModel.VehicleModelList[VehicleIndex].pointMapList[k].pointMap_X;
                             double Y = VehicleModel.VehicleModelList[VehicleIndex].pointMapList[k].pointMap_Y;
                             Point node = new Point(X, Y);
                             AddNode(node, gGrpBlueNode);
                             //Get list Node Insert
                             if (VehicleModel.VehicleModelList[VehicleIndex].pointMapList[k].color == ColorNode_Insert)
                             {
                                 ListIndexNodeInsert ListIndex = new ListIndexNodeInsert();
                                 ListIndex.X = X;
                                 ListIndex.Y = Y;
                                 IndexNodeInsert_List.Add(ListIndex);
                             }
                             //Bind VehicleModel's NodeInfo to List Node Info temp
                             Node_tmp node_tmp = new Node_tmp();
                             node_tmp.pointMap_X = X;
                             node_tmp.pointMap_Y = Y;
                             foreach (ListNodeInfo tmp in VehicleModel.VehicleModelList[VehicleIndex].pointMapList[k].ListNodeInfo)
                             {
                                 node_tmp.NodeInfo_tmp.Add(tmp);
                             }
                             Lst_Node_tmp.Add(node_tmp);
                             X = VehicleModel.VehicleModelList[VehicleIndex].pointMapList[k].pointSchedule_X;
                             Y = VehicleModel.VehicleModelList[VehicleIndex].pointMapList[k].pointSchedule_Y;
                             node = new Point(X, Y);
                             AddNode(node, gGrpScheduleNode);
                         }
                     }
                 }
             }
             BindBlueNode2ucNode();
             ReDrawAllNode();
             SetScheduleRoute();
             NewDspRouteInfo();
             //Clear Route Info Table
             //((RoboforkMenu)System.Windows.Application.Current.MainWindow).grdRouteInfo.Children.Clear();
         }
         public void CreateVehicleNode()
         {
             EllipseGeometry ellipseGeometry;
             Point node;
             ListNodeInfo ListNodeInfo = new ListNodeInfo();
             VehicleModelList VehicleModelList = new VehicleModelList();
             bool NodeISInsert = false;
             if (VehicleModel.VehicleModelList.Count > 0 && VehicleIndex < VehicleModel.VehicleModelList.Count)
             {
                 if (VehicleModel.VehicleModelList[VehicleIndex].pointMapList.Count > 0)
                 {
                     VehicleModel.VehicleModelList[VehicleIndex].pointMapList.Clear();
                 }
                 //back up
                 if (gGrpBlueNode.Children.Count > 0)
                 {
                     for (int i = 0; i < gGrpBlueNode.Children.Count; i++)
                     {
                         NodeISInsert = false;
                         ellipseGeometry = (EllipseGeometry)gGrpBlueNode.Children[i];
                         node = ellipseGeometry.Center;
                         PointMap pMap = new PointMap();
                         pMap.pointMap_X = node.X;
                         pMap.pointMap_Y = node.Y;
                         pMap.speed_Map = 5;
                         //Backup List Node Insert of fork
                         if (IndexNodeInsert_List.Count> 0)
                         {
                             for (int j = 0; j < IndexNodeInsert_List.Count; j++)
                             {
                                 if (node.X == IndexNodeInsert_List[j].X && node.Y == IndexNodeInsert_List[j].Y) NodeISInsert = true;
                             }
                         }
                         if (NodeISInsert)
                         {
                             pMap.color = ColorNode_Insert;
                         }
                         else
                         {
                             pMap.color = ColorNode_Add;
                         }
                         ellipseGeometry = (EllipseGeometry)gGrpScheduleNode.Children[i];
                         node = ellipseGeometry.Center;
                         pMap.pointSchedule_X = node.X;
                         pMap.pointSchedule_Y = node.Y;
-                        pMap.speed_Schedule = 0;
+                        pMap.speed_Schedule = 0.2; //Hard code
                         //Node info
                         foreach (ListNodeInfo temp in Lst_Node_tmp[i].NodeInfo_tmp)
                         {
                             pMap.ListNodeInfo.Add(temp);
                         }
                         VehicleModel.VehicleModelList[VehicleIndex].pointMapList.Add(pMap);
                     }
                 }
             }
             // create new
             else
             {
                 VehicleModelList.VehicleName = VehicleItem;
                 if (gGrpBlueNode.Children.Count > 0)
                 {
                     for (int i = 0; i < gGrpBlueNode.Children.Count; i++)
                     {
                         NodeISInsert = false;
                         ellipseGeometry = (EllipseGeometry)gGrpBlueNode.Children[i];
                         node = ellipseGeometry.Center;
                         PointMap pMap = new PointMap();
                         pMap.pointMap_X = node.X;
                         pMap.pointMap_Y = node.Y;
                         pMap.speed_Map = 5;
                         if (IndexNodeInsert_List.Count > 0)
                         {
                             for (int j = 0; j < IndexNodeInsert_List.Count; j++)
                             {
                                 if (node.X == IndexNodeInsert_List[j].X && node.Y == IndexNodeInsert_List[j].Y) NodeISInsert = true;
                             }
                         }
                         if (NodeISInsert)
                         {
                             pMap.color = ColorNode_Insert;
                         }
                         else
                         {
                             pMap.color = ColorNode_Add;
                         }
                         //Node info
                         foreach (ListNodeInfo temp in Lst_Node_tmp[i].NodeInfo_tmp)
                         {
                             pMap.ListNodeInfo.Add(temp);
                         }
                         ellipseGeometry = (EllipseGeometry)gGrpScheduleNode.Children[i];
                         node = ellipseGeometry.Center;
                         pMap.pointSchedule_X = node.X;
                         pMap.pointSchedule_Y = node.Y;
-                        pMap.speed_Schedule = 0;
+                        pMap.speed_Schedule = 0.2; //Hard code
                         VehicleModelList.pointMapList.Add(pMap);
                     }
                 }
                 VehicleModel.VehicleModelList.Add(VehicleModelList);
             }
         }
         #endregion
     }
 }

-using System;
+using RoboforkApp.DataModel;
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
 using System.Windows;
 using System.Windows.Controls;
 using System.Windows.Media;
 using System.Windows.Media.Animation;
 using System.Windows.Shapes;
 namespace RoboforkApp
 {
     public class ScheduleCanvas : Canvas
     {
         const double COOR_Y = 65;
         const double RADIUS_NODE = 25;
-        private simulationRobo simulation;
+        public simulationRobo simulation;
+        private VehicleModelList vehicleModelList;
         private Point startPoint;
         private Point endPoint;
         private bool _isGoal = false;
-        private double _speed = 0.2; //Now _speed is fixed, but when update node
+        private double _speed;
         private int index;
         private List<ucNode> _lstNode;
         /// <summary>
         /// Create simulation
         /// </summary>
-        /// <param name="lstNode"></param>
+        /// <param name="lstNode">List node on schedule</param>
-        public void CreateSimulation(List<ucNode> lstNode)
+        /// <param name="vehicleModel">Vehicle model on map</param>
+        /// <param name="vehicleIndex">Current index of vehicle</param>
+        public void CreateSimulation(List<ucNode> lstNode, VehicleModel vehicleModel, int vehicleIndex)
         {
             //If node is less than 2 so return
             if (this.Children.Count < 2)
             {
                 return;
             }
             this.Children.Remove(simulation);
             //Init data
             this._lstNode = lstNode;
+            this.vehicleModelList = vehicleModel.VehicleModelList[vehicleIndex];
             this.startPoint = new Point(Canvas.GetLeft(_lstNode[index]) + RADIUS_NODE, COOR_Y);
             this.endPoint = new Point(Canvas.GetLeft(_lstNode[index + 1]) + RADIUS_NODE, COOR_Y);
+            this._speed = vehicleModelList.pointMapList[index].speed_Schedule;
             this.index += 1;
             if (index == _lstNode.Count - 1)
             {
                 _isGoal = true;
             }
             // Start simulation
             RoboSimulation();
         }
         /// <summary>
         /// Create robo simulation on line
         /// </summary>
         private void RoboSimulation()
         {
             simulation = new simulationRobo();
             simulation.storyBoard = CreatPathAnimation(startPoint, endPoint, _speed); //pathAnimationStoryboard;
             this.Children.Add(simulation);
         }
         /// <summary>
         /// Get storyboard
         /// </summary>
         /// <param name="startPoint">Point start line</param>
         /// <param name="endPoit">Point end line</param>
         /// <param name="speed">speed on line</param>
         /// <returns>Storyboard</returns>
         private Storyboard CreatPathAnimation(Point startPoint, Point endPoit, double speed)
         {
             PathGeometry animationPath = new PathGeometry();
             PathFigure pFigure = new PathFigure();
             pFigure.StartPoint = startPoint; //new Point(50, 65);
             LineSegment lineSegment = new LineSegment();
             lineSegment.Point = endPoit; // new Point(800, 65);
             pFigure.Segments.Add(lineSegment);
             animationPath.Figures.Add(pFigure);
             // Freeze the PathGeometry for performance benefits.
             animationPath.Freeze();
             // Create a MatrixAnimationUsingPath to move the
             // simulation along the path by animating
             // its MatrixTransform.
             MatrixAnimationUsingPath matrixAnimation = new MatrixAnimationUsingPath();
             matrixAnimation.PathGeometry = animationPath;
             matrixAnimation.SpeedRatio = speed;
             matrixAnimation.AutoReverse = false;
             matrixAnimation.DoesRotateWithTangent = true;
             matrixAnimation.Completed += delegate { AnimationCompleted(this._isGoal); };
             // Set the animation to target the Matrix property
             // of the MatrixTransform named "ButtonMatrixTransform".
             Storyboard.SetTargetName(matrixAnimation, "fl");
             Storyboard.SetTargetProperty(matrixAnimation, new PropertyPath(MatrixTransform.MatrixProperty));
             // Create a Storyboard to contain and apply the animation.
             Storyboard pathAnimationStoryboard = new Storyboard();
             pathAnimationStoryboard.Children.Add(matrixAnimation);
             return pathAnimationStoryboard;
         }
         /// <summary>
         /// Process when simulation is end line
         /// </summary>
         /// <param name="isGoal">check is node end</param>
         private void AnimationCompleted(bool isGoal)
         {
             // If not end node
             if (!isGoal)
             {
+                this._speed = vehicleModelList.pointMapList[index].speed_Schedule;
                 this.index += 1;
                 this.Children.Remove(simulation);
                 this.startPoint = endPoint;
                 this.endPoint = new Point(Canvas.GetLeft(_lstNode[index]) + RADIUS_NODE, COOR_Y);
                 if (this.index == this._lstNode.Count - 1)
                 {
                     this._isGoal = true;
                 }
-                this._speed += 0.2;
                 RoboSimulation();
                 return;
             }
             // Reset data when finish
             this.index = 0;
-            this._speed = 0.2;
+            this._speed = 0;
             this._isGoal = false;
         }
     }
 }