toan / Robofork

1

using RoboforkApp.DataModel;

1

using RoboforkApp.DataModel;

2

//using RoboforkApp.Entities;

2

//using RoboforkApp.Entities;

3

//using RoboforkApp.Services;

3

//using RoboforkApp.Services;

4

using System;

4

using System;

5

using System.Collections.Generic;

5

using System.Collections.Generic;

6

using System.Linq;

6

using System.Linq;

7

using System.Windows;

7

using System.Windows;

8

using System.Windows.Controls;

8

using System.Windows.Controls;

9

using System.Windows.Documents;

9

using System.Windows.Documents;

10

using System.Windows.Input;

10

using System.Windows.Input;

11

using System.Windows.Markup;

11

using System.Windows.Markup;

12

using System.Windows.Media;

12

using System.Windows.Media;

13

using System.Windows.Shapes;

13

using System.Windows.Shapes;

14

using System.Xml;

14

using System.Xml;

15

using System.Data;

15

using System.Data;

16

using RoboforkApp.View;

16

using RoboforkApp.View;

17

using RoboforkApp.Services;

17

using RoboforkApp.Services;

18

using RoboforkApp.Entities;

18

using RoboforkApp.Entities;

19

20

namespace RoboforkApp

20

namespace RoboforkApp

21

{

21

{

22

public class DesignerCanvas : Canvas

22

public class DesignerCanvas : Canvas

23

{

23

{

24

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

24

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

25

const double RADIUS_CURVER_LINE = 130d;

25

const double RADIUS_CURVER_LINE = 130d;

26

const double DISTANCE_AUTO_NODES = 100d;

26

const double DISTANCE_AUTO_NODES = 100d;

27

const double DISTANCE_START_NODES = 30d;

27

const double DISTANCE_START_NODES = 30d;

28

const double DISTANCE_END_NODES = 30d;

28

const double DISTANCE_END_NODES = 30d;

29

const double DISTANCE_FREE_NODES = 40d;

29

const double DISTANCE_FREE_NODES = 40d;

30

const double STROKE_ROOT_LINE = 6d;

30

const double STROKE_ROOT_LINE = 6d;

31

const double STROKE_LINE = 4d;

31

const double STROKE_LINE = 4d;

32

const double STROKE_NODE = 1d;

32

const double STROKE_NODE = 1d;

33

const double DISTANCE_RATIO = 100;

33

const double DISTANCE_RATIO = 100;

34

35

const double UCNODE_SETLEFT = 17;

35

const double UCNODE_SETLEFT = 17;

36

const double UCNODE_SETTOP = 17;

36

const double UCNODE_SETTOP = 17;

37

const double UCNODE_WIDTH = 34;

37

const double UCNODE_WIDTH = 34;

38

const double UCNODE_HEIGHT = 34;

38

const double UCNODE_HEIGHT = 34;

39

40

const double UCSCHEDULENODE_SETLEFT = 12;

40

const double UCSCHEDULENODE_SETLEFT = 12;

41

const double UCSCHEDULENODE_SETTOP = 12;

41

const double UCSCHEDULENODE_SETTOP = 12;

42

const double UCSCHEDULENODE_WIDTH = 24;

42

const double UCSCHEDULENODE_WIDTH = 24;

43

const double UCSCHEDULENODE_HEIGHT = 24;

43

const double UCSCHEDULENODE_HEIGHT = 24;

44

45

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

45

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

46

private TextBlock shapePosIndicator;

46

private TextBlock shapePosIndicator;

47

private TextBlock shapeSizeIndicator;

47

private TextBlock shapeSizeIndicator;

48

private int currentLine;

48

private int currentLine;

49

private ucStartEndButton _startPoint;

49

private ucStartEndButton _startPoint;

50

private ucNode _ucNodeFree;

50

private ucNode _ucNodeFree;

51

private ucStartEndButton _goalPoint;

51

private ucStartEndButton _goalPoint;

52

private ucDisplayCoordinate _displayAxiPosition;

52

private ucDisplayCoordinate _displayAxiPosition;

53

54

// Add variable for draw route

54

// Add variable for draw route

55

public Path pLine = new Path();

55

public Path pLine = new Path();

56

public Path pRootLine = new Path();

56

public Path pRootLine = new Path();

57

public Path pCurverLine = new Path();

57

public Path pCurverLine = new Path();

58

public Path pRedNode = new Path();

58

public Path pRedNode = new Path();

59

public Path pYellowNode = new Path();

59

public Path pYellowNode = new Path();

60

public GeometryGroup gGrpLine = new GeometryGroup();

60

public GeometryGroup gGrpLine = new GeometryGroup();

61

public GeometryGroup gGrpRootLine = new GeometryGroup();

61

public GeometryGroup gGrpRootLine = new GeometryGroup();

62

public GeometryGroup gGrpCurverLine = new GeometryGroup();

62

public GeometryGroup gGrpCurverLine = new GeometryGroup();

63

public GeometryGroup gGrpRedNode = new GeometryGroup();

63

public GeometryGroup gGrpRedNode = new GeometryGroup();

64

public GeometryGroup gGrpYellowNode = new GeometryGroup();

64

public GeometryGroup gGrpYellowNode = new GeometryGroup();

65

public int currentShape;

65

public int currentShape;

66

public static bool isStartDrawRoute = false;

66

public static bool isStartDrawRoute = false;

67

public static bool isGoalDrawRoute = false;

67

public static bool isGoalDrawRoute = false;

68

69

public static bool readMapFan = true;

69

public static bool readMapFan = true;

70

71

public static double CanvasScheduleWidth = 0;

71

public static double CanvasScheduleWidth = 0;

72

public static double CanvasScheduleHeight = 0;

72

public static double CanvasScheduleHeight = 0;

73

public const double NodeSchedule_X = 50;

73

public const double NodeSchedule_X = 50;

74

75

public double PointMapStart_X = 127.85783428698775;

75

public double PointMapStart_X = 127.85783428698775;

76

public double PointMapStart_Y = 26.336094486866543;

76

public double PointMapStart_Y = 26.336094486866543;

77

78

public double PointMapEnd_X = 128.85783428698775;

78

public double PointMapEnd_X = 128.85783428698775;

79

public double PointMapEnd_Y = 27.336094486866543;

79

public double PointMapEnd_Y = 27.336094486866543;

80

81

const double DISTANCEMAPDISPLAY = 1000;

81

const double DISTANCEMAPDISPLAY = 1000;

82

83

public double Scale_X = 0;

83

public double Scale_X = 0;

84

public double Scale_Y = 0;

84

public double Scale_Y = 0;

85

86

public struct NodeInfo

86

public struct NodeInfo

87

{

87

{

88

public double X;

88

public double X;

89

public double Y;

89

public double Y;

90

public String Mode1;

90

public String Mode1;

91

public String Mode2;

91

public String Mode2;

92

public String Mode3;

92

public String Mode3;

93

}

93

}

94

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

94

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

95

96

// Add variable for Set Schedule

96

// Add variable for Set Schedule

97

public Path pScheduleNode = new Path();

97

public Path pScheduleNode = new Path();

98

public Path pScheduleLine = new Path();

98

public Path pScheduleLine = new Path();

99

public GeometryGroup gGrpScheduleNode = new GeometryGroup();

99

public GeometryGroup gGrpScheduleNode = new GeometryGroup();

100

public GeometryGroup gGrpScheduleLine = new GeometryGroup();

100

public GeometryGroup gGrpScheduleLine = new GeometryGroup();

101

102

public static bool EditNodeFlag = false;

102

public static bool EditNodeFlag = false;

103

public static bool DragDeltaFlag = false;

103

public static bool DragDeltaFlag = false;

104

public static bool LoadDBFlag = false;

104

public static bool LoadDBFlag = false;

105

106

//Add variable for Vehicle Item click

106

//Add variable for Vehicle Item click

107

public string VehicleItem = "FK_15";

107

public string VehicleItem = "FK_15";

108

109

public int VehicleIndex = 0;

109

public int VehicleIndex = 0;

110

public string ColorNode_Add = "Blue";

110

public string ColorNode_Add = "Blue";

111

public string ColorNode_Insert = "Brown";

111

public string ColorNode_Insert = "Brown";

112

113

public int ProjectIndex = 0;

113

public int ProjectIndex = 0;

114

public string ProjectItem = "ProjectAAA";

114

public string ProjectItem = "ProjectAAA";

115

public ProjectModel ProjectModel = new ProjectModel();

115

public ProjectModel ProjectModel = new ProjectModel();

116

117

//2017/03/04 NAM ADD START

117

//2017/03/04 NAM ADD START

118

public static bool isDrawingNode = false;

118

public static bool isDrawingNode = false;

119

public static bool isDragNode = false;

119

public static bool isDragNode = false;

120

public Path pNewLine = new Path();

120

public Path pNewLine = new Path();

121

public GeometryGroup gGrpNewLine = new GeometryGroup();

121

public GeometryGroup gGrpNewLine = new GeometryGroup();

122

123

public struct NewNodeInfo

123

public struct NewNodeInfo

124

{

124

{

125

public double X;

125

public double X;

126

public double Y;

126

public double Y;

127

public String Mode;

127

public String Mode;

128

}

128

}

129

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

129

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

130

131

//List Node's Info

131

//List Node's Info

132

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

132

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

133

134

135

136

137

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

137

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

138

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

138

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

139

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

139

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

140

int stt = 1;

140

int stt = 1;

141

//2017/03/04 NAM ADD END

141

//2017/03/04 NAM ADD END

142

public struct ListIndexNodeInsert

142

public struct ListIndexNodeInsert

143

{

143

{

144

public double X;

144

public double X;

145

public double Y;

145

public double Y;

146

}

146

}

147

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

147

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

148

149

public struct ListNameNode

149

public struct ListNameNode

150

{

150

{

151

public double X;

151

public double X;

152

public double Y;

152

public double Y;

153

public string nameNode;

153

public string nameNode;

154

}

154

}

155

List<ListNameNode> NameNode_List = new List<ListNameNode>();

155

List<ListNameNode> NameNode_List = new List<ListNameNode>();

156

157

158

public ScheduleCanvas scheduleCanvas = new ScheduleCanvas();

158

public ScheduleCanvas scheduleCanvas = new ScheduleCanvas();

159

160

// Add variable for Set Auto Nodes

160

// Add variable for Set Auto Nodes

161

public Path pBlueNode = new Path();

161

public Path pBlueNode = new Path();

162

private GeometryGroup gGrpBlueNode = new GeometryGroup();

162

private GeometryGroup gGrpBlueNode = new GeometryGroup();

163

164

// Add variable for Actual Nodes

164

// Add variable for Actual Nodes

165

public Path pActualNode = new Path();

165

public Path pActualNode = new Path();

166

private GeometryGroup gGrpActualNode = new GeometryGroup();

166

private GeometryGroup gGrpActualNode = new GeometryGroup();

167

168

// Add variable for Set Free Nodes

168

// Add variable for Set Free Nodes

169

public Path pFreeNode = new Path();

169

public Path pFreeNode = new Path();

170

//private GeometryGroup gGrpFreeNode = new GeometryGroup();

170

//private GeometryGroup gGrpFreeNode = new GeometryGroup();

171

172

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

172

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

173

private enum HitType

173

private enum HitType

174

{

174

{

175

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

175

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

176

};

176

};

177

public enum OperationState

177

public enum OperationState

178

{

178

{

179

None, DrawObstract, DrawRoute, DrawSetFreeNode, EditNode, NewDrawSetFreeNode

179

None, DrawObstract, DrawRoute, DrawSetFreeNode, EditNode, NewDrawSetFreeNode

180

};

180

};

181

public enum MouseState

181

public enum MouseState

182

{

182

{

183

None, Draw, Drag,

183

None, Draw, Drag,

184

}

184

}

185

public OperationState Operation = OperationState.None;

185

public OperationState Operation = OperationState.None;

186

public MouseState mouseState = MouseState.None;

186

public MouseState mouseState = MouseState.None;

187

188

// The draw start point.

188

// The draw start point.

189

private Point StartDrawPoint;

189

private Point StartDrawPoint;

190

191

// The drag's last point.

191

// The drag's last point.

192

private Point LastPoint;

192

private Point LastPoint;

193

194

// The part of the rectangle under the mouse.

194

// The part of the rectangle under the mouse.

195

HitType MouseHitType = HitType.None;

195

HitType MouseHitType = HitType.None;

196

197

public void Init()

197

public void Init()

198

{

198

{

199

if (shapePosIndicator == null)

199

if (shapePosIndicator == null)

200

{

200

{

201

shapePosIndicator = new TextBlock()

201

shapePosIndicator = new TextBlock()

202

{

202

{

203

Foreground = Brushes.Black,

203

Foreground = Brushes.Black,

204

Background = Brushes.Transparent,

204

Background = Brushes.Transparent,

205

FontSize = 20,

205

FontSize = 20,

206

};

206

};

207

}

207

}

208

if (shapeSizeIndicator == null)

208

if (shapeSizeIndicator == null)

209

{

209

{

210

shapeSizeIndicator = new TextBlock()

210

shapeSizeIndicator = new TextBlock()

211

{

211

{

212

Foreground = Brushes.Black,

212

Foreground = Brushes.Black,

213

Background = Brushes.Transparent,

213

Background = Brushes.Transparent,

214

FontSize = 20,

214

FontSize = 20,

215

};

215

};

216

}

216

}

217

}

217

}

218

219

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

219

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

220

private HitType SetHitType(Point point)

220

private HitType SetHitType(Point point)

221

{

221

{

222

if (shapeList.Count == 0)

222

if (shapeList.Count == 0)

223

{

223

{

224

currentShape = 0;

224

currentShape = 0;

225

return HitType.None;

225

return HitType.None;

226

}

226

}

227

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

227

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

228

{

228

{

229

Rectangle rect = shapeList[i];

229

Rectangle rect = shapeList[i];

230

double left = Canvas.GetLeft(rect);

230

double left = Canvas.GetLeft(rect);

231

double top = Canvas.GetTop(rect);

231

double top = Canvas.GetTop(rect);

232

double right = left + rect.Width;

232

double right = left + rect.Width;

233

double bottom = top + rect.Height;

233

double bottom = top + rect.Height;

234

if (point.X < left) continue;

234

if (point.X < left) continue;

235

if (point.X > right) continue;

235

if (point.X > right) continue;

236

if (point.Y < top) continue;

236

if (point.Y < top) continue;

237

if (point.Y > bottom) continue;

237

if (point.Y > bottom) continue;

238

currentShape = i;

238

currentShape = i;

239

240

const double GAP = 10;

240

const double GAP = 10;

241

if (point.X - left < GAP)

241

if (point.X - left < GAP)

242

{

242

{

243

// Left edge.

243

// Left edge.

244

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

244

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

245

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

245

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

246

return HitType.L;

246

return HitType.L;

247

}

247

}

248

if (right - point.X < GAP)

248

if (right - point.X < GAP)

249

{

249

{

250

// Right edge.

250

// Right edge.

251

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

251

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

252

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

252

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

253

return HitType.R;

253

return HitType.R;

254

}

254

}

255

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

255

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

256

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

256

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

257

return HitType.Body;

257

return HitType.Body;

258

}

258

}

259

currentShape = 0;

259

currentShape = 0;

260

return HitType.None;

260

return HitType.None;

261

}

261

}

262

263

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

263

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

264

private void SetMouseCursor()

264

private void SetMouseCursor()

265

{

265

{

266

// See what cursor we should display.

266

// See what cursor we should display.

267

Cursor desired_cursor = Cursors.Arrow;

267

Cursor desired_cursor = Cursors.Arrow;

268

switch (MouseHitType)

268

switch (MouseHitType)

269

{

269

{

270

case HitType.None:

270

case HitType.None:

271

desired_cursor = Cursors.Arrow;

271

desired_cursor = Cursors.Arrow;

272

break;

272

break;

273

case HitType.Body:

273

case HitType.Body:

274

desired_cursor = Cursors.ScrollAll;

274

desired_cursor = Cursors.ScrollAll;

275

break;

275

break;

276

case HitType.UL:

276

case HitType.UL:

277

case HitType.LR:

277

case HitType.LR:

278

desired_cursor = Cursors.SizeNWSE;

278

desired_cursor = Cursors.SizeNWSE;

279

break;

279

break;

280

case HitType.LL:

280

case HitType.LL:

281

case HitType.UR:

281

case HitType.UR:

282

desired_cursor = Cursors.SizeNESW;

282

desired_cursor = Cursors.SizeNESW;

283

break;

283

break;

284

case HitType.T:

284

case HitType.T:

285

case HitType.B:

285

case HitType.B:

286

desired_cursor = Cursors.SizeNS;

286

desired_cursor = Cursors.SizeNS;

287

break;

287

break;

288

case HitType.L:

288

case HitType.L:

289

case HitType.R:

289

case HitType.R:

290

desired_cursor = Cursors.SizeWE;

290

desired_cursor = Cursors.SizeWE;

291

break;

291

break;

292

}

292

}

293

294

// Display the desired cursor.

294

// Display the desired cursor.

295

if (Cursor != desired_cursor) Cursor = desired_cursor;

295

if (Cursor != desired_cursor) Cursor = desired_cursor;

296

}

296

}

297

298

// constance

298

// constance

299

int indicatorAligment = 2;

299

int indicatorAligment = 2;

300

301

/*

301

/*

302

private Point? dragStartPoint = null;

302

private Point? dragStartPoint = null;

303

304

*/

304

*/

305

public IEnumerable<DesignerItem> SelectedItems

305

public IEnumerable<DesignerItem> SelectedItems

306

{

306

{

307

get

307

get

308

{

308

{

309

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

309

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

310

where item.IsSelected == true

310

where item.IsSelected == true

311

select item;

311

select item;

312

313

return selectedItems;

313

return selectedItems;

314

}

314

}

315

}

315

}

316

317

public void DeselectAll()

317

public void DeselectAll()

318

{

318

{

319

/*

319

/*

320

foreach (DesignerItem item in this.SelectedItems)

320

foreach (DesignerItem item in this.SelectedItems)

321

{

321

{

322

item.IsSelected = false;

322

item.IsSelected = false;

323

}*/

323

}*/

324

}

324

}

325

326

protected override void OnMouseDown(MouseButtonEventArgs e)

326

protected override void OnMouseDown(MouseButtonEventArgs e)

327

{

327

{

328

base.OnMouseDown(e);

328

base.OnMouseDown(e);

329

330

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

330

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

331

SetMouseCursor();

331

SetMouseCursor();

332

333

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

333

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

334

{

334

{

335

if (isGoalDrawRoute)

335

if (isGoalDrawRoute)

336

{

336

{

337

return;

337

return;

338

}

338

}

339

340

// Check state draw

340

// Check state draw

341

if (MouseHitType == HitType.None)

341

if (MouseHitType == HitType.None)

342

{

342

{

343

if (gGrpLine.Children.Count == 1)

343

if (gGrpLine.Children.Count == 1)

344

{

344

{

345

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

345

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

346

lineGeometry.EndPoint = LastPoint;

346

lineGeometry.EndPoint = LastPoint;

347

348

// Check end route

348

// Check end route

349

if (IsEndRoute(_goalPoint, lineGeometry))

349

if (IsEndRoute(_goalPoint, lineGeometry))

350

{

350

{

351

isGoalDrawRoute = true;

351

isGoalDrawRoute = true;

352

ProcessEndRoute();

352

ProcessEndRoute();

353

return;

353

return;

354

}

354

}

355

}

355

}

356

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

356

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

357

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

357

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

358

{

358

{

359

// Set end point to finish draw line

359

// Set end point to finish draw line

360

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

360

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

361

lineGeometry.EndPoint = LastPoint;

361

lineGeometry.EndPoint = LastPoint;

362

363

// Add node to curver postion

363

// Add node to curver postion

364

AddNode(lineGeometry.StartPoint, gGrpRedNode);

364

AddNode(lineGeometry.StartPoint, gGrpRedNode);

365

366

// Check end route

366

// Check end route

367

if (IsEndRoute(_goalPoint, lineGeometry))

367

if (IsEndRoute(_goalPoint, lineGeometry))

368

{

368

{

369

isGoalDrawRoute = true;

369

isGoalDrawRoute = true;

370

ProcessEndRoute();

370

ProcessEndRoute();

371

return;

371

return;

372

}

372

}

373

}

373

}

374

else

374

else

375

{

375

{

376

// Remove current line

376

// Remove current line

377

gGrpLine.Children.RemoveAt(currentLine);

377

gGrpLine.Children.RemoveAt(currentLine);

378

379

// Set end point to finish draw line

379

// Set end point to finish draw line

380

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

380

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

381

lineGeometry.EndPoint = LastPoint;

381

lineGeometry.EndPoint = LastPoint;

382

383

// Check end route

383

// Check end route

384

if (IsEndRoute(_goalPoint, lineGeometry))

384

if (IsEndRoute(_goalPoint, lineGeometry))

385

{

385

{

386

isGoalDrawRoute = true;

386

isGoalDrawRoute = true;

387

ProcessEndRoute();

387

ProcessEndRoute();

388

return;

388

return;

389

}

389

}

390

}

390

}

391

392

// Draw new line

392

// Draw new line

393

DrawLine(LastPoint, LastPoint, gGrpLine);

393

DrawLine(LastPoint, LastPoint, gGrpLine);

394

// Setting start point for new line

394

// Setting start point for new line

395

StartDrawPoint = LastPoint;

395

StartDrawPoint = LastPoint;

396

397

mouseState = MouseState.Draw;

397

mouseState = MouseState.Draw;

398

currentLine = gGrpLine.Children.Count - 1;

398

currentLine = gGrpLine.Children.Count - 1;

399

return;

399

return;

400

}

400

}

401

}

401

}

402

else if (Operation == OperationState.DrawSetFreeNode)

402

else if (Operation == OperationState.DrawSetFreeNode)

403

{

403

{

404

bool RightClick = false;

404

bool RightClick = false;

405

if (IsStopDrawRoute(e))

405

if (IsStopDrawRoute(e))

406

RightClick = true;

406

RightClick = true;

407

408

StartDrawPoint = e.MouseDevice.GetPosition(this);

408

StartDrawPoint = e.MouseDevice.GetPosition(this);

409

410

SetFreeNodes(StartDrawPoint, RightClick);

410

SetFreeNodes(StartDrawPoint, RightClick);

411

}

411

}

412

413

else if (Operation == OperationState.EditNode)

413

else if (Operation == OperationState.EditNode)

414

{

414

{

415

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

415

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

416

417

// start Edit Node Infor

417

// start Edit Node Infor

418

//EditNode(node_edited);

418

//EditNode(node_edited);

419

420

}

420

}

421

else if (Operation == OperationState.DrawObstract)

421

else if (Operation == OperationState.DrawObstract)

422

{

422

{

423

if (MouseHitType == HitType.None)

423

if (MouseHitType == HitType.None)

424

{

424

{

425

Rectangle shape = new Rectangle();

425

Rectangle shape = new Rectangle();

426

shape.Width = 1;

426

shape.Width = 1;

427

shape.Height = 1;

427

shape.Height = 1;

428

// Create a SolidColorBrush and use it to

428

// Create a SolidColorBrush and use it to

429

// paint the rectangle.

429

// paint the rectangle.

430

shape.Stroke = Brushes.Blue;

430

shape.Stroke = Brushes.Blue;

431

shape.StrokeThickness = 1;

431

shape.StrokeThickness = 1;

432

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

432

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

433

StartDrawPoint = e.MouseDevice.GetPosition(this);

433

StartDrawPoint = e.MouseDevice.GetPosition(this);

434

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

434

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

435

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

435

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

436

this.Children.Add(shape);

436

this.Children.Add(shape);

437

shapeList.Add(shape);

437

shapeList.Add(shape);

438

439

mouseState = MouseState.Draw;

439

mouseState = MouseState.Draw;

440

currentShape = shapeList.Count() - 1;

440

currentShape = shapeList.Count() - 1;

441

442

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

442

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

443

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

443

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

444

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

444

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

445

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

445

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

446

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

446

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

447

448

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

448

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

449

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

449

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

450

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

450

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

451

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

451

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

452

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

452

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

453

454

this.Children.Add(shapePosIndicator);

454

this.Children.Add(shapePosIndicator);

455

this.Children.Add(shapeSizeIndicator);

455

this.Children.Add(shapeSizeIndicator);

456

457

458

return;

458

return;

459

}

459

}

460

else

460

else

461

{

461

{

462

if (shapeList.Count() != 0)

462

if (shapeList.Count() != 0)

463

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

463

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

464

465

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

465

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

466

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

466

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

467

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

467

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

468

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

468

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

469

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

469

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

470

471

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

471

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

472

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

472

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

473

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

473

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

474

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

474

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

475

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

475

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

476

477

this.Children.Add(shapePosIndicator);

477

this.Children.Add(shapePosIndicator);

478

this.Children.Add(shapeSizeIndicator);

478

this.Children.Add(shapeSizeIndicator);

479

}

479

}

480

481

LastPoint = Mouse.GetPosition(this);

481

LastPoint = Mouse.GetPosition(this);

482

mouseState = MouseState.Drag;

482

mouseState = MouseState.Drag;

483

}

483

}

484

e.Handled = true;

484

e.Handled = true;

485

}

485

}

486

487

protected override void OnMouseMove(MouseEventArgs e)

487

protected override void OnMouseMove(MouseEventArgs e)

488

{

488

{

489

base.OnMouseMove(e);

489

base.OnMouseMove(e);

490

491

if (mouseState == MouseState.None)

491

if (mouseState == MouseState.None)

492

{

492

{

493

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

493

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

494

SetMouseCursor();

494

SetMouseCursor();

495

}

495

}

496

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

496

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

497

{

497

{

498

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

498

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

499

500

// See how much the mouse has moved.

500

// See how much the mouse has moved.

501

Point point = Mouse.GetPosition(this);

501

Point point = Mouse.GetPosition(this);

502

double offset_x = point.X - StartDrawPoint.X;

502

double offset_x = point.X - StartDrawPoint.X;

503

double offset_y = point.Y - StartDrawPoint.Y;

503

double offset_y = point.Y - StartDrawPoint.Y;

504

505

// Get the line's current position.

505

// Get the line's current position.

506

double new_x = lineGeometry.StartPoint.X;

506

double new_x = lineGeometry.StartPoint.X;

507

double new_y = lineGeometry.StartPoint.Y;

507

double new_y = lineGeometry.StartPoint.Y;

508

509

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

509

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

510

{

510

{

511

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

511

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

512

{

512

{

513

new_x = point.X;

513

new_x = point.X;

514

}

514

}

515

else

515

else

516

{

516

{

517

new_y = point.Y;

517

new_y = point.Y;

518

}

518

}

519

}

519

}

520

521

// Set end point of current line

521

// Set end point of current line

522

LastPoint = new Point(new_x, new_y);

522

LastPoint = new Point(new_x, new_y);

523

lineGeometry.EndPoint = LastPoint;

523

lineGeometry.EndPoint = LastPoint;

524

DisplayCoordinate(LastPoint);

524

DisplayCoordinate(LastPoint);

525

}

525

}

526

else if (Operation == OperationState.DrawObstract)

526

else if (Operation == OperationState.DrawObstract)

527

{

527

{

528

if (mouseState == MouseState.Drag)

528

if (mouseState == MouseState.Drag)

529

{

529

{

530

// See how much the mouse has moved.

530

// See how much the mouse has moved.

531

Point point = Mouse.GetPosition(this);

531

Point point = Mouse.GetPosition(this);

532

double offset_x = point.X - LastPoint.X;

532

double offset_x = point.X - LastPoint.X;

533

double offset_y = point.Y - LastPoint.Y;

533

double offset_y = point.Y - LastPoint.Y;

534

535

// Get the rectangle's current position.

535

// Get the rectangle's current position.

536

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

536

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

537

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

537

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

538

double new_width = shapeList[currentShape].Width;

538

double new_width = shapeList[currentShape].Width;

539

double new_height = shapeList[currentShape].Height;

539

double new_height = shapeList[currentShape].Height;

540

541

// Update the rectangle.

541

// Update the rectangle.

542

switch (MouseHitType)

542

switch (MouseHitType)

543

{

543

{

544

case HitType.Body:

544

case HitType.Body:

545

new_x += offset_x;

545

new_x += offset_x;

546

new_y += offset_y;

546

new_y += offset_y;

547

break;

547

break;

548

case HitType.UL:

548

case HitType.UL:

549

new_x += offset_x;

549

new_x += offset_x;

550

new_y += offset_y;

550

new_y += offset_y;

551

new_width -= offset_x;

551

new_width -= offset_x;

552

new_height -= offset_y;

552

new_height -= offset_y;

553

break;

553

break;

554

case HitType.UR:

554

case HitType.UR:

555

new_y += offset_y;

555

new_y += offset_y;

556

new_width += offset_x;

556

new_width += offset_x;

557

new_height -= offset_y;

557

new_height -= offset_y;

558

break;

558

break;

559

case HitType.LR:

559

case HitType.LR:

560

new_width += offset_x;

560

new_width += offset_x;

561

new_height += offset_y;

561

new_height += offset_y;

562

break;

562

break;

563

case HitType.LL:

563

case HitType.LL:

564

new_x += offset_x;

564

new_x += offset_x;

565

new_width -= offset_x;

565

new_width -= offset_x;

566

new_height += offset_y;

566

new_height += offset_y;

567

break;

567

break;

568

case HitType.L:

568

case HitType.L:

569

new_x += offset_x;

569

new_x += offset_x;

570

new_width -= offset_x;

570

new_width -= offset_x;

571

break;

571

break;

572

case HitType.R:

572

case HitType.R:

573

new_width += offset_x;

573

new_width += offset_x;

574

break;

574

break;

575

case HitType.B:

575

case HitType.B:

576

new_height += offset_y;

576

new_height += offset_y;

577

break;

577

break;

578

case HitType.T:

578

case HitType.T:

579

new_y += offset_y;

579

new_y += offset_y;

580

new_height -= offset_y;

580

new_height -= offset_y;

581

break;

581

break;

582

}

582

}

583

// Don't use negative width or height.

583

// Don't use negative width or height.

584

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

584

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

585

{

585

{

586

// Update the rectangle.

586

// Update the rectangle.

587

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

587

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

588

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

588

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

589

shapeList[currentShape].Width = new_width;

589

shapeList[currentShape].Width = new_width;

590

shapeList[currentShape].Height = new_height;

590

shapeList[currentShape].Height = new_height;

591

592

// Save the mouse's new location.

592

// Save the mouse's new location.

593

LastPoint = point;

593

LastPoint = point;

594

595

}

595

}

596

}

596

}

597

else if (mouseState == MouseState.Draw)

597

else if (mouseState == MouseState.Draw)

598

{

598

{

599

600

// See how much the mouse has moved.

600

// See how much the mouse has moved.

601

Point point = Mouse.GetPosition(this);

601

Point point = Mouse.GetPosition(this);

602

603

604

double offset_x = point.X - StartDrawPoint.X;

604

double offset_x = point.X - StartDrawPoint.X;

605

double offset_y = point.Y - StartDrawPoint.Y;

605

double offset_y = point.Y - StartDrawPoint.Y;

606

607

// Get the rectangle's current position.

607

// Get the rectangle's current position.

608

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

608

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

609

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

609

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

610

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

610

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

611

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

611

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

612

double new_width = offset_x;

612

double new_width = offset_x;

613

double new_height = offset_y;

613

double new_height = offset_y;

614

if (offset_x < 0)

614

if (offset_x < 0)

615

{

615

{

616

new_x = point.X;

616

new_x = point.X;

617

new_width = -offset_x;

617

new_width = -offset_x;

618

}

618

}

619

if (offset_y < 0)

619

if (offset_y < 0)

620

{

620

{

621

new_y = point.Y;

621

new_y = point.Y;

622

new_height = -offset_y;

622

new_height = -offset_y;

623

}

623

}

624

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

624

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

625

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

625

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

626

shapeList[currentShape].Width = new_width;

626

shapeList[currentShape].Width = new_width;

627

shapeList[currentShape].Height = new_height;

627

shapeList[currentShape].Height = new_height;

628

629

}

629

}

630

631

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

631

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

632

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

632

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

633

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

633

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

634

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

634

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

635

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

635

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

636

637

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

637

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

638

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

638

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

639

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

639

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

640

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

640

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

641

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

641

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

642

}

642

}

643

e.Handled = true;

643

e.Handled = true;

644

}

644

}

645

646

protected override void OnMouseUp(MouseButtonEventArgs e)

646

protected override void OnMouseUp(MouseButtonEventArgs e)

647

{

647

{

648

base.OnMouseUp(e);

648

base.OnMouseUp(e);

649

if (Operation == OperationState.DrawObstract)

649

if (Operation == OperationState.DrawObstract)

650

{

650

{

651

if (shapeList.Count() != 0)

651

if (shapeList.Count() != 0)

652

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

652

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

653

shapePosIndicator.Text = "";

653

shapePosIndicator.Text = "";

654

shapeSizeIndicator.Text = "";

654

shapeSizeIndicator.Text = "";

655

this.Children.Remove(shapePosIndicator);

655

this.Children.Remove(shapePosIndicator);

656

this.Children.Remove(shapeSizeIndicator);

656

this.Children.Remove(shapeSizeIndicator);

657

658

mouseState = MouseState.None;

658

mouseState = MouseState.None;

659

currentShape = 0;

659

currentShape = 0;

660

}

660

}

661

e.Handled = true;

661

e.Handled = true;

662

}

662

}

663

664

protected override void OnPreviewMouseUp(MouseButtonEventArgs e)

664

protected override void OnPreviewMouseUp(MouseButtonEventArgs e)

665

{

665

{

666

base.OnPreviewMouseUp(e);

666

base.OnPreviewMouseUp(e);

667

668

EllipseGeometry ellipseGeometry;

668

EllipseGeometry ellipseGeometry;

669

bool flag = false;

669

bool flag = false;

670

671

StartDrawPoint = e.MouseDevice.GetPosition(this);

671

StartDrawPoint = e.MouseDevice.GetPosition(this);

672

673

if (EditNodeFlag == true)

673

if (EditNodeFlag == true)

674

{

674

{

675

execEditNode(StartDrawPoint);

675

execEditNode(StartDrawPoint);

676

EditNodeFlag = false;

676

EditNodeFlag = false;

677

return;

677

return;

678

}

678

}

679

680

if (DragDeltaFlag == true)

680

if (DragDeltaFlag == true)

681

{

681

{

682

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

682

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

683

{

683

{

684

685

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

685

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

686

{

686

{

687

if (j == i)

687

if (j == i)

688

{

688

{

689

_ucNodeFree = ucNode_Lst[j];

689

_ucNodeFree = ucNode_Lst[j];

690

flag = true;

690

flag = true;

691

}

691

}

692

}

692

}

693

if (flag)

693

if (flag)

694

{

694

{

695

if (gGrpNewLine.Children.Count > 0)

695

if (gGrpNewLine.Children.Count > 0)

696

{

696

{

697

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

697

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

698

{

698

{

699

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

699

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

700

Point p1 = lineGeometry.StartPoint;

700

Point p1 = lineGeometry.StartPoint;

701

Point p2 = lineGeometry.EndPoint;

701

Point p2 = lineGeometry.EndPoint;

702

703

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

703

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

704

705

//if (pInL)

705

//if (pInL)

706

//{

706

//{

707

708

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

708

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

709

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

709

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

710

// return;

710

// return;

711

//}

711

//}

712

}

712

}

713

}

713

}

714

715

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

715

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

716

717

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

717

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

718

719

double centerY = Canvas.GetTop(_ucNodeFree);

719

double centerY = Canvas.GetTop(_ucNodeFree);

720

double centerX = Canvas.GetLeft(_ucNodeFree);

720

double centerX = Canvas.GetLeft(_ucNodeFree);

721

722

mouseState = MouseState.Draw;

722

mouseState = MouseState.Draw;

723

724

725

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

725

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

726

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

726

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

727

728

this.Children.Remove(_ucNodeFree);

728

this.Children.Remove(_ucNodeFree);

729

this.Children.Add(_ucNodeFree);

729

this.Children.Add(_ucNodeFree);

730

Lst_Node_tmp[i].pointMap_X = ConvertPointDisplayToActual(StartDrawPoint.X, Scale_X, PointMapStart_X);

730

Lst_Node_tmp[i].pointMap_X = ConvertPointDisplayToActual(StartDrawPoint.X, Scale_X, PointMapStart_X);

731

Lst_Node_tmp[i].pointMap_Y = ConvertPointDisplayToActual(StartDrawPoint.Y, Scale_X, PointMapStart_Y);

731

Lst_Node_tmp[i].pointMap_Y = ConvertPointDisplayToActual(StartDrawPoint.Y, Scale_X, PointMapStart_Y);

732

733

//Update Location for List NameNode_List -> Compare Location to get Name

733

//Update Location for List NameNode_List -> Compare Location to get Name

734

ListNameNode nmNode = new ListNameNode();

734

ListNameNode nmNode = new ListNameNode();

735

ListNameNode nmNode_old = new ListNameNode();

735

ListNameNode nmNode_old = new ListNameNode();

736

nmNode_old = NameNode_List[i];

736

nmNode_old = NameNode_List[i];

737

738

nmNode.X = StartDrawPoint.X;

738

nmNode.X = StartDrawPoint.X;

739

nmNode.Y = StartDrawPoint.Y;

739

nmNode.Y = StartDrawPoint.Y;

740

nmNode.nameNode = nmNode_old.nameNode;

740

nmNode.nameNode = nmNode_old.nameNode;

741

NameNode_List[i] = nmNode;

741

NameNode_List[i] = nmNode;

742

}

742

}

743

}

743

}

744

745

ReDrawAllNode();

745

ReDrawAllNode();

746

NewDspRouteInfo();

746

NewDspRouteInfo();

747

748

SetScheduleRoute();

748

SetScheduleRoute();

749

DragDeltaFlag = false;

749

DragDeltaFlag = false;

750

}

750

}

751

752

753

754

return;

754

return;

755

}

755

}

756

757

/// <summary>

757

/// <summary>

758

/// On Preview Mouse Down

758

/// On Preview Mouse Down

759

/// </summary>

759

/// </summary>

760

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

760

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

761

protected override void OnPreviewMouseDown(MouseButtonEventArgs e)

761

protected override void OnPreviewMouseDown(MouseButtonEventArgs e)

762

{

762

{

763

base.OnPreviewMouseDown(e);

763

base.OnPreviewMouseDown(e);

764

765

if (DesignerCanvas.LoadDBFlag)

765

if (DesignerCanvas.LoadDBFlag)

766

return;

766

return;

767

768

if (Operation != OperationState.NewDrawSetFreeNode)

768

if (Operation != OperationState.NewDrawSetFreeNode)

769

{

769

{

770

return;

770

return;

771

}

771

}

772

773

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

773

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

774

775

if (isDrawingNode == false)

775

if (isDrawingNode == false)

776

{

776

{

777

778

isDrawingNode = true;

778

isDrawingNode = true;

779

//InitDrawRoute();

779

//InitDrawRoute();

780

mouseState = MouseState.Draw;

780

mouseState = MouseState.Draw;

781

782

StartDrawPoint = e.MouseDevice.GetPosition(this);

782

StartDrawPoint = e.MouseDevice.GetPosition(this);

783

784

785

execCreateNode(StartDrawPoint);

785

execCreateNode(StartDrawPoint);

786

787

//backup DB

787

//backup DB

788

CreateVehicleNode();

788

CreateVehicleNode();

789

790

return;

790

return;

791

}

791

}

792

else

792

else

793

{

793

{

794

795

bool RightClick = false;

795

bool RightClick = false;

796

bool LeftClick = false;

796

bool LeftClick = false;

797

798

799

if (IsMouseLeftClick(e))

799

if (IsMouseLeftClick(e))

800

LeftClick = true;

800

LeftClick = true;

801

if (IsStopDrawRoute(e))

801

if (IsStopDrawRoute(e))

802

RightClick = true;

802

RightClick = true;

803

804

StartDrawPoint = e.MouseDevice.GetPosition(this);

804

StartDrawPoint = e.MouseDevice.GetPosition(this);

805

806

if (RightClick)

806

if (RightClick)

807

{

807

{

808

execDeleteNode(StartDrawPoint);

808

execDeleteNode(StartDrawPoint);

809

810

//backup DB

810

//backup DB

811

CreateVehicleNode();

811

CreateVehicleNode();

812

}

812

}

813

else if (LeftClick)

813

else if (LeftClick)

814

{

814

{

815

//check click to exist node

815

//check click to exist node

816

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

816

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

817

{

817

{

818

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

818

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

819

Point node = ellipseGeometry.Center;

819

Point node = ellipseGeometry.Center;

820

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

820

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

821

822

if (isEditNode)

822

if (isEditNode)

823

{

823

{

824

return;

824

return;

825

}

825

}

826

}

826

}

827

828

execCreateNode(StartDrawPoint);

828

execCreateNode(StartDrawPoint);

829

830

//backup DB

830

//backup DB

831

CreateVehicleNode();

831

CreateVehicleNode();

832

}

832

}

833

834

}

834

}

835

}

835

}

836

837

#region Functions for draw route

837

#region Functions for draw route

838

839

/// <summary>

839

/// <summary>

840

/// Check start or end draw route

840

/// Check start or end draw route

841

/// </summary>

841

/// </summary>

842

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

842

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

843

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

843

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

844

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

844

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

845

private bool IsStartEndRoute(ucStartEndButton _ucStartEndButton, Point currentPoint)

845

private bool IsStartEndRoute(ucStartEndButton _ucStartEndButton, Point currentPoint)

846

{

846

{

847

if (_ucStartEndButton == null)

847

if (_ucStartEndButton == null)

848

{

848

{

849

return false;

849

return false;

850

}

850

}

851

852

double centerX = Canvas.GetLeft(_ucStartEndButton);

852

double centerX = Canvas.GetLeft(_ucStartEndButton);

853

double centerY = Canvas.GetTop(_ucStartEndButton);

853

double centerY = Canvas.GetTop(_ucStartEndButton);

854

855

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

855

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

856

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

856

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

857

{

857

{

858

return true;

858

return true;

859

}

859

}

860

return false;

860

return false;

861

}

861

}

862

863

/// <summary>

863

/// <summary>

864

/// Process when end draw route

864

/// Process when end draw route

865

/// </summary>

865

/// </summary>

866

private void ProcessEndRoute()

866

private void ProcessEndRoute()

867

{

867

{

868

Operation = OperationState.None;

868

Operation = OperationState.None;

869

AutoEditLine();

869

AutoEditLine();

870

this.Children.Remove(_displayAxiPosition);

870

this.Children.Remove(_displayAxiPosition);

871

this.Children.Remove(_goalPoint);

871

this.Children.Remove(_goalPoint);

872

this.Children.Add(_goalPoint);

872

this.Children.Add(_goalPoint);

873

}

873

}

874

875

/// <summary>

875

/// <summary>

876

/// Check end draw route

876

/// Check end draw route

877

/// </summary>

877

/// </summary>

878

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

878

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

879

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

879

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

880

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

880

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

881

private bool IsEndRoute(ucStartEndButton _ucStartEndButton, LineGeometry lineGeometry)

881

private bool IsEndRoute(ucStartEndButton _ucStartEndButton, LineGeometry lineGeometry)

882

{

882

{

883

if (_ucStartEndButton == null)

883

if (_ucStartEndButton == null)

884

{

884

{

885

return false;

885

return false;

886

}

886

}

887

888

double centerX = Canvas.GetLeft(_ucStartEndButton);

888

double centerX = Canvas.GetLeft(_ucStartEndButton);

889

double centerY = Canvas.GetTop(_ucStartEndButton);

889

double centerY = Canvas.GetTop(_ucStartEndButton);

890

Point startPoint = lineGeometry.StartPoint;

890

Point startPoint = lineGeometry.StartPoint;

891

Point endPoint = lineGeometry.EndPoint;

891

Point endPoint = lineGeometry.EndPoint;

892

893

if (IsVerticalLine(lineGeometry))

893

if (IsVerticalLine(lineGeometry))

894

{

894

{

895

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

895

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

896

return false;

896

return false;

897

898

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

898

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

899

return false;

899

return false;

900

901

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

901

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

902

return false;

902

return false;

903

}

903

}

904

else

904

else

905

{

905

{

906

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

906

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

907

return false;

907

return false;

908

909

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

909

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

910

return false;

910

return false;

911

912

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

912

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

913

return false;

913

return false;

914

}

914

}

915

916

return true;

916

return true;

917

}

917

}

918

919

/// <summary>

919

/// <summary>

920

/// Make root

920

/// Make root

921

/// </summary>

921

/// </summary>

922

public void MakeRoot()

922

public void MakeRoot()

923

{

923

{

924

// If still not route

924

// If still not route

925

if (gGrpLine.Children.Count == 0)

925

if (gGrpLine.Children.Count == 0)

926

return;

926

return;

927

928

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

928

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

929

pLine.StrokeThickness = STROKE_ROOT_LINE;

929

pLine.StrokeThickness = STROKE_ROOT_LINE;

930

931

}

931

}

932

933

/// <summary>

933

/// <summary>

934

/// Auto edit leght of line

934

/// Auto edit leght of line

935

/// </summary>

935

/// </summary>

936

private void AutoEditLine()

936

private void AutoEditLine()

937

{

937

{

938

double temp;

938

double temp;

939

int index = gGrpLine.Children.Count - 1;

939

int index = gGrpLine.Children.Count - 1;

940

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

940

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

941

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

941

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

942

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

942

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

943

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

943

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

944

945

if (gGrpLine.Children.Count > 1)

945

if (gGrpLine.Children.Count > 1)

946

{

946

{

947

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

947

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

948

949

if (!IsCurverNode(beforeLastLine, lastLine))

949

if (!IsCurverNode(beforeLastLine, lastLine))

950

{

950

{

951

beforeLastLine.EndPoint = lastLine.EndPoint;

951

beforeLastLine.EndPoint = lastLine.EndPoint;

952

gGrpLine.Children.RemoveAt(index);

952

gGrpLine.Children.RemoveAt(index);

953

index = index - 1;

953

index = index - 1;

954

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

954

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

955

}

955

}

956

}

956

}

957

958

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

958

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

959

{

959

{

960

AddNode(lastLine.StartPoint, gGrpRedNode);

960

AddNode(lastLine.StartPoint, gGrpRedNode);

961

}

961

}

962

963

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

963

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

964

return;

964

return;

965

966

if (IsVerticalLine(lastLine))

966

if (IsVerticalLine(lastLine))

967

{

967

{

968

temp = lastLine.StartPoint.Y;

968

temp = lastLine.StartPoint.Y;

969

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

969

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

970

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

970

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

971

972

if (gGrpLine.Children.Count > 1)

972

if (gGrpLine.Children.Count > 1)

973

{

973

{

974

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

974

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

975

temp = beforeLastLine.EndPoint.Y;

975

temp = beforeLastLine.EndPoint.Y;

976

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

976

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

977

}

977

}

978

}

978

}

979

else

979

else

980

{

980

{

981

temp = lastLine.StartPoint.X;

981

temp = lastLine.StartPoint.X;

982

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

982

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

983

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

983

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

984

if (gGrpLine.Children.Count > 1)

984

if (gGrpLine.Children.Count > 1)

985

{

985

{

986

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

986

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

987

temp = beforeLastLine.EndPoint.X;

987

temp = beforeLastLine.EndPoint.X;

988

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

988

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

989

}

989

}

990

}

990

}

991

992

// Draw curver line

992

// Draw curver line

993

if (IsCurverNode(beforeLastLine, lastLine))

993

if (IsCurverNode(beforeLastLine, lastLine))

994

{

994

{

995

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

995

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

996

ellipseGeometry.Center = lastLine.StartPoint;

996

ellipseGeometry.Center = lastLine.StartPoint;

997

}

997

}

998

}

998

}

999

1000

/// <summary>

1000

/// <summary>

1001

/// Check draw curver node

1001

/// Check draw curver node

1002

/// </summary>

1002

/// </summary>

1003

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

1003

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

1004

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

1004

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

1005

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

1005

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

1006

private bool IsCurverNode(LineGeometry oldLine, LineGeometry newLine)

1006

private bool IsCurverNode(LineGeometry oldLine, LineGeometry newLine)

1007

{

1007

{

1008

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

1008

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

1009

{

1009

{

1010

return false;

1010

return false;

1011

}

1011

}

1012

1013

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

1013

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

1014

{

1014

{

1015

return false;

1015

return false;

1016

}

1016

}

1017

1018

return true;

1018

return true;

1019

}

1019

}

1020

1021

/// <summary>

1021

/// <summary>

1022

/// Check timming to stop draw route

1022

/// Check timming to stop draw route

1023

/// </summary>

1023

/// </summary>

1024

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

1024

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

1025

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

1025

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

1026

private bool IsStopDrawRoute(MouseEventArgs e)

1026

private bool IsStopDrawRoute(MouseEventArgs e)

1027

{

1027

{

1028

if (e.RightButton == MouseButtonState.Pressed)

1028

if (e.RightButton == MouseButtonState.Pressed)

1029

{

1029

{

1030

return true;

1030

return true;

1031

}

1031

}

1032

1033

return false;

1033

return false;

1034

}

1034

}

1035

1036

//2017/03/05 NAM ADD START

1036

//2017/03/05 NAM ADD START

1037

private bool IsMouseLeftClick(MouseEventArgs e)

1037

private bool IsMouseLeftClick(MouseEventArgs e)

1038

{

1038

{

1039

if (e.LeftButton == MouseButtonState.Pressed)

1039

if (e.LeftButton == MouseButtonState.Pressed)

1040

{

1040

{

1041

return true;

1041

return true;

1042

}

1042

}

1043

1044

return false;

1044

return false;

1045

}

1045

}

1046

//2017/03/05 NAM ADD END

1046

//2017/03/05 NAM ADD END

1047

1048

/// <summary>

1048

/// <summary>

1049

/// Draw curver line and yellow node

1049

/// Draw curver line and yellow node

1050

/// </summary>

1050

/// </summary>

1051

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

1051

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

1052

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

1052

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

1053

private void DrawCurver(LineGeometry oldLine, LineGeometry newLine)

1053

private void DrawCurver(LineGeometry oldLine, LineGeometry newLine)

1054

{

1054

{

1055

double radius = RADIUS_CURVER_LINE;

1055

double radius = RADIUS_CURVER_LINE;

1056

1057

Point startPoint;

1057

Point startPoint;

1058

Point endPoint;

1058

Point endPoint;

1059

1060

// Get postion of yellow node on old line

1060

// Get postion of yellow node on old line

1061

if (IsVerticalLine(oldLine))

1061

if (IsVerticalLine(oldLine))

1062

{

1062

{

1063

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

1063

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

1064

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

1064

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

1065

else

1065

else

1066

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

1066

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

1067

}

1067

}

1068

else

1068

else

1069

{

1069

{

1070

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

1070

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

1071

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

1071

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

1072

else

1072

else

1073

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

1073

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

1074

}

1074

}

1075

1076

// Get postion of yellow node on new line

1076

// Get postion of yellow node on new line

1077

if (IsVerticalLine(newLine))

1077

if (IsVerticalLine(newLine))

1078

{

1078

{

1079

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

1079

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

1080

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

1080

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

1081

else

1081

else

1082

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

1082

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

1083

}

1083

}

1084

else

1084

else

1085

{

1085

{

1086

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

1086

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

1087

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

1087

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

1088

else

1088

else

1089

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

1089

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

1090

}

1090

}

1091

1092

// Add node to postion distance 1300mm

1092

// Add node to postion distance 1300mm

1093

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

1093

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

1094

{

1094

{

1095

AddNode(startPoint, gGrpYellowNode);

1095

AddNode(startPoint, gGrpYellowNode);

1096

}

1096

}

1097

1098

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

1098

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

1099

{

1099

{

1100

AddNode(endPoint, gGrpYellowNode);

1100

AddNode(endPoint, gGrpYellowNode);

1101

}

1101

}

1102

}

1102

}

1103

1104

/// <summary>

1104

/// <summary>

1105

/// Init data for draw route

1105

/// Init data for draw route

1106

/// </summary>

1106

/// </summary>

1107

public void InitDrawRoute()

1107

public void InitDrawRoute()

1108

{

1108

{

1109

//2017/03/04 NAM ADD START

1109

//2017/03/04 NAM ADD START

1110

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

1110

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

1111

pNewLine.StrokeThickness = STROKE_LINE;

1111

pNewLine.StrokeThickness = STROKE_LINE;

1112

pNewLine.Data = gGrpNewLine;

1112

pNewLine.Data = gGrpNewLine;

1113

//2017/03/04 NAM ADD END

1113

//2017/03/04 NAM ADD END

1114

1115

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

1115

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

1116

pScheduleLine.StrokeThickness = STROKE_LINE;

1116

pScheduleLine.StrokeThickness = STROKE_LINE;

1117

pScheduleLine.Data = gGrpScheduleLine;

1117

pScheduleLine.Data = gGrpScheduleLine;

1118

1119

// Setting for path line

1119

// Setting for path line

1120

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

1120

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

1121

pLine.StrokeThickness = STROKE_LINE;

1121

pLine.StrokeThickness = STROKE_LINE;

1122

pLine.Data = gGrpLine;

1122

pLine.Data = gGrpLine;

1123

1124

// Setting for path of curver line

1124

// Setting for path of curver line

1125

pCurverLine.Stroke = Brushes.Red;

1125

pCurverLine.Stroke = Brushes.Red;

1126

pCurverLine.StrokeThickness = STROKE_LINE;

1126

pCurverLine.StrokeThickness = STROKE_LINE;

1127

pCurverLine.Data = gGrpCurverLine;

1127

pCurverLine.Data = gGrpCurverLine;

1128

1129

// Setting for path of red node

1129

// Setting for path of red node

1130

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

1130

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

1131

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

1131

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

1132

pRedNode.StrokeThickness = STROKE_NODE;

1132

pRedNode.StrokeThickness = STROKE_NODE;

1133

pRedNode.Data = gGrpRedNode;

1133

pRedNode.Data = gGrpRedNode;

1134

1135

// Setting for path of yellow node

1135

// Setting for path of yellow node

1136

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

1136

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

1137

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

1137

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

1138

pYellowNode.StrokeThickness = STROKE_NODE;

1138

pYellowNode.StrokeThickness = STROKE_NODE;

1139

pYellowNode.Data = gGrpYellowNode;

1139

pYellowNode.Data = gGrpYellowNode;

1140

1141

// Setting for path of Blue node

1141

// Setting for path of Blue node

1142

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

1142

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

1143

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

1143

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

1144

pBlueNode.StrokeThickness = STROKE_NODE;

1144

pBlueNode.StrokeThickness = STROKE_NODE;

1145

pBlueNode.Data = gGrpBlueNode;

1145

pBlueNode.Data = gGrpBlueNode;

1146

1147

// Add paths to canvas

1147

// Add paths to canvas

1148

this.Children.Add(pLine);

1148

this.Children.Add(pLine);

1149

this.Children.Add(pCurverLine);

1149

this.Children.Add(pCurverLine);

1150

this.Children.Add(pRedNode);

1150

this.Children.Add(pRedNode);

1151

this.Children.Add(pYellowNode);

1151

this.Children.Add(pYellowNode);

1152

1153

//this.Children.Add(pNewLine);

1153

//this.Children.Add(pNewLine);

1154

//scheduleCanvas.Children.Add(pScheduleLine);

1154

//scheduleCanvas.Children.Add(pScheduleLine);

1155

}

1155

}

1156

1157

/// <summary>

1157

/// <summary>

1158

/// Clear all route

1158

/// Clear all route

1159

/// </summary>

1159

/// </summary>

1160

public void ClearRoute()

1160

public void ClearRoute()

1161

{

1161

{

1162

isStartDrawRoute = false;

1162

isStartDrawRoute = false;

1163

isGoalDrawRoute = false;

1163

isGoalDrawRoute = false;

1164

1165

gGrpLine.Children.Clear();

1165

gGrpLine.Children.Clear();

1166

gGrpRootLine.Children.Clear();

1166

gGrpRootLine.Children.Clear();

1167

gGrpCurverLine.Children.Clear();

1167

gGrpCurverLine.Children.Clear();

1168

gGrpRedNode.Children.Clear();

1168

gGrpRedNode.Children.Clear();

1169

gGrpYellowNode.Children.Clear();

1169

gGrpYellowNode.Children.Clear();

1170

gGrpBlueNode.Children.Clear();

1170

gGrpBlueNode.Children.Clear();

1171

1172

this.Children.Remove(pLine);

1172

this.Children.Remove(pLine);

1173

this.Children.Remove(pRootLine);

1173

this.Children.Remove(pRootLine);

1174

this.Children.Remove(pCurverLine);

1174

this.Children.Remove(pCurverLine);

1175

this.Children.Remove(pRedNode);

1175

this.Children.Remove(pRedNode);

1176

this.Children.Remove(pYellowNode);

1176

this.Children.Remove(pYellowNode);

1177

this.Children.Remove(pBlueNode);

1177

this.Children.Remove(pBlueNode);

1178

}

1178

}

1179

1180

/// <summary>

1180

/// <summary>

1181

/// Draw line for route

1181

/// Draw line for route

1182

/// </summary>

1182

/// </summary>

1183

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

1183

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

1184

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

1184

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

1185

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

1185

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

1186

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

1186

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

1187

{

1187

{

1188

LineGeometry lineGeometry = new LineGeometry();

1188

LineGeometry lineGeometry = new LineGeometry();

1189

lineGeometry.StartPoint = startPoint;

1189

lineGeometry.StartPoint = startPoint;

1190

lineGeometry.EndPoint = endPoint;

1190

lineGeometry.EndPoint = endPoint;

1191

geometryGroup.Children.Add(lineGeometry);

1191

geometryGroup.Children.Add(lineGeometry);

1192

}

1192

}

1193

1194

/// <summary>

1194

/// <summary>

1195

/// Draw curver line

1195

/// Draw curver line

1196

/// </summary>

1196

/// </summary>

1197

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

1197

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

1198

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

1198

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

1199

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

1199

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

1200

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

1200

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

1201

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

1201

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

1202

{

1202

{

1203

PathGeometry pathGeometry = new PathGeometry();

1203

PathGeometry pathGeometry = new PathGeometry();

1204

PathFigure figure = new PathFigure();

1204

PathFigure figure = new PathFigure();

1205

figure.StartPoint = startPoint;

1205

figure.StartPoint = startPoint;

1206

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

1206

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

1207

pathGeometry.Figures.Add(figure);

1207

pathGeometry.Figures.Add(figure);

1208

geometryGroup.Children.Add(pathGeometry);

1208

geometryGroup.Children.Add(pathGeometry);

1209

}

1209

}

1210

1211

/// <summary>

1211

/// <summary>

1212

/// Setting node

1212

/// Setting node

1213

/// </summary>

1213

/// </summary>

1214

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

1214

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

1215

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

1215

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

1216

private void AddNode(Point centerPoit, GeometryGroup geometryGroup)

1216

private void AddNode(Point centerPoit, GeometryGroup geometryGroup)

1217

{

1217

{

1218

double radius = RADIUS_NODE;

1218

double radius = RADIUS_NODE;

1219

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

1219

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

1220

}

1220

}

1221

1222

/// <summary>

1222

/// <summary>

1223

/// Check line is vertical or horizontal

1223

/// Check line is vertical or horizontal

1224

/// </summary>

1224

/// </summary>

1225

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

1225

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

1226

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

1226

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

1227

private bool IsVerticalLine(LineGeometry line)

1227

private bool IsVerticalLine(LineGeometry line)

1228

{

1228

{

1229

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

1229

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

1230

{

1230

{

1231

// Vertical line

1231

// Vertical line

1232

return true;

1232

return true;

1233

}

1233

}

1234

1235

// Horizontal line

1235

// Horizontal line

1236

return false;

1236

return false;

1237

}

1237

}

1238

1239

/// <summary>

1239

/// <summary>

1240

/// Get distance between two point

1240

/// Get distance between two point

1241

/// </summary>

1241

/// </summary>

1242

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

1242

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

1243

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

1243

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

1244

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

1244

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

1245

private double GetDistance(Point point1, Point point2)

1245

private double GetDistance(Point point1, Point point2)

1246

{

1246

{

1247

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

1247

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

1248

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

1248

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

1249

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

1249

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

1250

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

1250

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

1251

1252

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

1252

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

1253

}

1253

}

1254

1255

/// <summary>

1255

/// <summary>

1256

/// Check point is valid for draw

1256

/// Check point is valid for draw

1257

/// </summary>

1257

/// </summary>

1258

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

1258

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

1259

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

1259

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

1260

private bool IsValidPoint(Point point)

1260

private bool IsValidPoint(Point point)

1261

{

1261

{

1262

return true;

1262

return true;

1263

}

1263

}

1264

1265

/// <summary>

1265

/// <summary>

1266

/// Display coordinate position

1266

/// Display coordinate position

1267

/// </summary>

1267

/// </summary>

1268

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

1268

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

1269

private void DisplayCoordinate(Point point)

1269

private void DisplayCoordinate(Point point)

1270

{

1270

{

1271

if (_displayAxiPosition == null)

1271

if (_displayAxiPosition == null)

1272

{

1272

{

1273

_displayAxiPosition = new ucDisplayCoordinate();

1273

_displayAxiPosition = new ucDisplayCoordinate();

1274

this.Children.Add(_displayAxiPosition);

1274

this.Children.Add(_displayAxiPosition);

1275

}

1275

}

1276

_displayAxiPosition.Display(point);

1276

_displayAxiPosition.Display(point);

1277

}

1277

}

1278

1279

#endregion

1279

#endregion

1280

1281

#region Functions for Set Auto Nodes

1281

#region Functions for Set Auto Nodes

1282

1283

/// <summary>

1283

/// <summary>

1284

/// SetAutoNodes

1284

/// SetAutoNodes

1285

/// </summary>

1285

/// </summary>

1286

public void SetAutoNodes()

1286

public void SetAutoNodes()

1287

{

1287

{

1288

double radiusStart = DISTANCE_START_NODES;

1288

double radiusStart = DISTANCE_START_NODES;

1289

double radiusEnd = DISTANCE_END_NODES;

1289

double radiusEnd = DISTANCE_END_NODES;

1290

double radiusCurver = RADIUS_CURVER_LINE;

1290

double radiusCurver = RADIUS_CURVER_LINE;

1291

1292

Point startNode;

1292

Point startNode;

1293

Point endNode;

1293

Point endNode;

1294

1295

gGrpBlueNode.Children.Clear();

1295

gGrpBlueNode.Children.Clear();

1296

1297

if (gGrpLine.Children.Count == 1)

1297

if (gGrpLine.Children.Count == 1)

1298

radiusCurver = radiusEnd;

1298

radiusCurver = radiusEnd;

1299

1300

if (gGrpLine.Children.Count > 0)

1300

if (gGrpLine.Children.Count > 0)

1301

{

1301

{

1302

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

1302

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

1303

{

1303

{

1304

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

1304

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

1305

if (i == 0)

1305

if (i == 0)

1306

{

1306

{

1307

startNode = lineGeometry.EndPoint;

1307

startNode = lineGeometry.EndPoint;

1308

endNode = lineGeometry.StartPoint;

1308

endNode = lineGeometry.StartPoint;

1309

DrawAutoNodes(startNode, endNode, radiusCurver, radiusStart);

1309

DrawAutoNodes(startNode, endNode, radiusCurver, radiusStart);

1310

}

1310

}

1311

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

1311

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

1312

{

1312

{

1313

startNode = lineGeometry.StartPoint;

1313

startNode = lineGeometry.StartPoint;

1314

endNode = lineGeometry.EndPoint;

1314

endNode = lineGeometry.EndPoint;

1315

DrawAutoNodes(startNode, endNode, radiusCurver, radiusEnd);

1315

DrawAutoNodes(startNode, endNode, radiusCurver, radiusEnd);

1316

}

1316

}

1317

else

1317

else

1318

{

1318

{

1319

startNode = lineGeometry.StartPoint;

1319

startNode = lineGeometry.StartPoint;

1320

endNode = lineGeometry.EndPoint;

1320

endNode = lineGeometry.EndPoint;

1321

DrawAutoNodes(startNode, endNode, radiusCurver, radiusCurver);

1321

DrawAutoNodes(startNode, endNode, radiusCurver, radiusCurver);

1322

}

1322

}

1323

}

1323

}

1324

}

1324

}

1325

}

1325

}

1326

1327

1328

/// <summary>

1328

/// <summary>

1329

/// DrawAutoNodes

1329

/// DrawAutoNodes

1330

/// </summary>

1330

/// </summary>

1331

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

1331

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

1332

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

1332

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

1333

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

1333

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

1334

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

1334

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

1335

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

1335

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

1336

{

1336

{

1337

double distance = DISTANCE_AUTO_NODES;

1337

double distance = DISTANCE_AUTO_NODES;

1338

double i;

1338

double i;

1339

1340

Point node;

1340

Point node;

1341

1342

// Get postion of blue node on line

1342

// Get postion of blue node on line

1343

if (startNode.X == endNode.X)

1343

if (startNode.X == endNode.X)

1344

{

1344

{

1345

if (startNode.Y > endNode.Y)

1345

if (startNode.Y > endNode.Y)

1346

{

1346

{

1347

i = startNode.Y - radiusStart;

1347

i = startNode.Y - radiusStart;

1348

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

1348

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

1349

{

1349

{

1350

do

1350

do

1351

{

1351

{

1352

i = i - distance;

1352

i = i - distance;

1353

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

1353

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

1354

// Add node to postion distance 1000mm

1354

// Add node to postion distance 1000mm

1355

AddNode(node, gGrpBlueNode);

1355

AddNode(node, gGrpBlueNode);

1356

1357

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

1357

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

1358

}

1358

}

1359

}

1359

}

1360

else

1360

else

1361

{

1361

{

1362

i = startNode.Y + radiusStart;

1362

i = startNode.Y + radiusStart;

1363

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

1363

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

1364

{

1364

{

1365

do

1365

do

1366

{

1366

{

1367

i = i + distance;

1367

i = i + distance;

1368

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

1368

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

1369

// Add node to postion distance 1000mm

1369

// Add node to postion distance 1000mm

1370

AddNode(node, gGrpBlueNode);

1370

AddNode(node, gGrpBlueNode);

1371

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

1371

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

1372

}

1372

}

1373

}

1373

}

1374

}

1374

}

1375

else

1375

else

1376

{

1376

{

1377

if (startNode.X > endNode.X)

1377

if (startNode.X > endNode.X)

1378

{

1378

{

1379

i = startNode.X - radiusStart;

1379

i = startNode.X - radiusStart;

1380

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

1380

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

1381

{

1381

{

1382

do

1382

do

1383

{

1383

{

1384

i = i - distance;

1384

i = i - distance;

1385

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

1385

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

1386

// Add node to postion distance 1000mm

1386

// Add node to postion distance 1000mm

1387

AddNode(node, gGrpBlueNode);

1387

AddNode(node, gGrpBlueNode);

1388

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

1388

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

1389

}

1389

}

1390

}

1390

}

1391

else

1391

else

1392

{

1392

{

1393

i = startNode.X + radiusStart;

1393

i = startNode.X + radiusStart;

1394

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

1394

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

1395

{

1395

{

1396

do

1396

do

1397

{

1397

{

1398

i = i + distance;

1398

i = i + distance;

1399

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

1399

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

1400

// Add node to postion distance 1000mm

1400

// Add node to postion distance 1000mm

1401

AddNode(node, gGrpBlueNode);

1401

AddNode(node, gGrpBlueNode);

1402

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

1402

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

1403

}

1403

}

1404

}

1404

}

1405

}

1405

}

1406

1407

}

1407

}

1408

1409

#endregion

1409

#endregion

1410

1411

#region Functions for Set Free Nodes

1411

#region Functions for Set Free Nodes

1412

/// <summary>

1412

/// <summary>

1413

/// Draw Auto Blue node

1413

/// Draw Auto Blue node

1414

/// </summary>

1414

/// </summary>

1415

1416

public void SetFreeNodes(Point FreeNode, bool RightClick)

1416

public void SetFreeNodes(Point FreeNode, bool RightClick)

1417

{

1417

{

1418

double radiusStart = DISTANCE_START_NODES;

1418

double radiusStart = DISTANCE_START_NODES;

1419

double radiusEnd = DISTANCE_END_NODES;

1419

double radiusEnd = DISTANCE_END_NODES;

1420

double radiusNode = RADIUS_NODE;

1420

double radiusNode = RADIUS_NODE;

1421

double radiusCurver = RADIUS_CURVER_LINE + RADIUS_NODE;

1421

double radiusCurver = RADIUS_CURVER_LINE + RADIUS_NODE;

1422

1423

EllipseGeometry ellipseGeometry;

1423

EllipseGeometry ellipseGeometry;

1424

Point node;

1424

Point node;

1425

bool deleteFlag = false;

1425

bool deleteFlag = false;

1426

1427

1428

if (RightClick)

1428

if (RightClick)

1429

{

1429

{

1430

if (gGrpBlueNode.Children.Count > 0)

1430

if (gGrpBlueNode.Children.Count > 0)

1431

{

1431

{

1432

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

1432

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

1433

{

1433

{

1434

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

1434

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

1435

node = ellipseGeometry.Center;

1435

node = ellipseGeometry.Center;

1436

if (FreeNode.X == node.X)

1436

if (FreeNode.X == node.X)

1437

{

1437

{

1438

if (CheckIsNode(FreeNode, node, radiusNode))

1438

if (CheckIsNode(FreeNode, node, radiusNode))

1439

{

1439

{

1440

deleteFlag = true;

1440

deleteFlag = true;

1441

}

1441

}

1442

}

1442

}

1443

else

1443

else

1444

{

1444

{

1445

if (CheckIsNode(FreeNode, node, radiusNode))

1445

if (CheckIsNode(FreeNode, node, radiusNode))

1446

{

1446

{

1447

deleteFlag = true;

1447

deleteFlag = true;

1448

}

1448

}

1449

}

1449

}

1450

if (deleteFlag)

1450

if (deleteFlag)

1451

{

1451

{

1452

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

1452

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

1453

if (result == MessageBoxResult.OK)

1453

if (result == MessageBoxResult.OK)

1454

{

1454

{

1455

gGrpBlueNode.Children.RemoveAt(i);

1455

gGrpBlueNode.Children.RemoveAt(i);

1456

1457

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

1457

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

1458

return;

1458

return;

1459

}

1459

}

1460

else

1460

else

1461

{

1461

{

1462

return;

1462

return;

1463

}

1463

}

1464

}

1464

}

1465

}

1465

}

1466

}

1466

}

1467

}

1467

}

1468

else

1468

else

1469

{

1469

{

1470

1471

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

1471

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

1472

{

1472

{

1473

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

1473

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

1474

node = ellipseGeometry.Center;

1474

node = ellipseGeometry.Center;

1475

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

1475

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

1476

1477

if (isEditNode)

1477

if (isEditNode)

1478

{

1478

{

1479

//EditNode(node);

1479

//EditNode(node);

1480

return;

1480

return;

1481

}

1481

}

1482

}

1482

}

1483

1484

1485

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

1485

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

1486

if (result == MessageBoxResult.OK)

1486

if (result == MessageBoxResult.OK)

1487

{

1487

{

1488

AddNode(FreeNode, gGrpBlueNode);

1488

AddNode(FreeNode, gGrpBlueNode);

1489

1490

TextBlock textBlock = new TextBlock();

1490

TextBlock textBlock = new TextBlock();

1491

textBlock.Text = stt.ToString();

1491

textBlock.Text = stt.ToString();

1492

textBlock.FontSize = 17;

1492

textBlock.FontSize = 17;

1493

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

1493

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

1494

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

1494

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

1495

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

1495

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

1496

1497

this.Children.Add(textBlock);

1497

this.Children.Add(textBlock);

1498

NodeNo.Add(textBlock);

1498

NodeNo.Add(textBlock);

1499

1500

if (stt > 1)

1500

if (stt > 1)

1501

{

1501

{

1502

int tmp = gGrpBlueNode.Children.Count;

1502

int tmp = gGrpBlueNode.Children.Count;

1503

1504

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

1504

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

1505

Point node1 = elip.Center;

1505

Point node1 = elip.Center;

1506

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

1506

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

1507

Point node2 = elip.Center;

1507

Point node2 = elip.Center;

1508

DrawLine(node1, node2, gGrpCurverLine);

1508

DrawLine(node1, node2, gGrpCurverLine);

1509

}

1509

}

1510

1511

1512

stt++;

1512

stt++;

1513

}

1513

}

1514

}

1514

}

1515

1516

if (gGrpLine.Children.Count > 0)

1516

if (gGrpLine.Children.Count > 0)

1517

{

1517

{

1518

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

1518

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

1519

{

1519

{

1520

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

1520

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

1521

1522

// Get postion of node on line

1522

// Get postion of node on line

1523

if (IsVerticalLine(lineGeometry))

1523

if (IsVerticalLine(lineGeometry))

1524

{

1524

{

1525

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

1525

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

1526

{

1526

{

1527

FreeNode.X = lineGeometry.EndPoint.X;

1527

FreeNode.X = lineGeometry.EndPoint.X;

1528

1529

if (i == 0)

1529

if (i == 0)

1530

{

1530

{

1531

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

1531

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

1532

{

1532

{

1533

1534

AddNode(FreeNode, gGrpBlueNode);

1534

AddNode(FreeNode, gGrpBlueNode);

1535

}

1535

}

1536

}

1536

}

1537

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

1537

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

1538

{

1538

{

1539

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

1539

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

1540

{

1540

{

1541

1542

AddNode(FreeNode, gGrpBlueNode);

1542

AddNode(FreeNode, gGrpBlueNode);

1543

}

1543

}

1544

}

1544

}

1545

else

1545

else

1546

{

1546

{

1547

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

1547

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

1548

{

1548

{

1549

1550

AddNode(FreeNode, gGrpBlueNode);

1550

AddNode(FreeNode, gGrpBlueNode);

1551

}

1551

}

1552

}

1552

}

1553

1554

}

1554

}

1555

}

1555

}

1556

else

1556

else

1557

{

1557

{

1558

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

1558

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

1559

{

1559

{

1560

FreeNode.Y = lineGeometry.EndPoint.Y;

1560

FreeNode.Y = lineGeometry.EndPoint.Y;

1561

if (i == 0)

1561

if (i == 0)

1562

{

1562

{

1563

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

1563

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

1564

{

1564

{

1565

1566

AddNode(FreeNode, gGrpBlueNode);

1566

AddNode(FreeNode, gGrpBlueNode);

1567

}

1567

}

1568

}

1568

}

1569

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

1569

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

1570

{

1570

{

1571

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

1571

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

1572

{

1572

{

1573

1574

AddNode(FreeNode, gGrpBlueNode);

1574

AddNode(FreeNode, gGrpBlueNode);

1575

}

1575

}

1576

}

1576

}

1577

else

1577

else

1578

{

1578

{

1579

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

1579

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

1580

{

1580

{

1581

1582

AddNode(FreeNode, gGrpBlueNode);

1582

AddNode(FreeNode, gGrpBlueNode);

1583

}

1583

}

1584

}

1584

}

1585

1586

}

1586

}

1587

}

1587

}

1588

}

1588

}

1589

}

1589

}

1590

}

1590

}

1591

1592

1593

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

1593

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

1594

{

1594

{

1595

1596

double distanceFreeNode = DISTANCE_FREE_NODES;

1596

double distanceFreeNode = DISTANCE_FREE_NODES;

1597

double radiusNode = RADIUS_NODE;

1597

double radiusNode = RADIUS_NODE;

1598

EllipseGeometry ellipseGeometry;

1598

EllipseGeometry ellipseGeometry;

1599

Point node;

1599

Point node;

1600

1601

if (IsVerticalLine(lineNode))

1601

if (IsVerticalLine(lineNode))

1602

{

1602

{

1603

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

1603

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

1604

{

1604

{

1605

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

1605

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

1606

{

1606

{

1607

return false;

1607

return false;

1608

}

1608

}

1609

}

1609

}

1610

else

1610

else

1611

{

1611

{

1612

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

1612

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

1613

{

1613

{

1614

return false;

1614

return false;

1615

}

1615

}

1616

}

1616

}

1617

}

1617

}

1618

else

1618

else

1619

{

1619

{

1620

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

1620

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

1621

{

1621

{

1622

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

1622

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

1623

{

1623

{

1624

return false;

1624

return false;

1625

}

1625

}

1626

}

1626

}

1627

else

1627

else

1628

{

1628

{

1629

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

1629

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

1630

{

1630

{

1631

return false;

1631

return false;

1632

}

1632

}

1633

}

1633

}

1634

}

1634

}

1635

1636

if (gGrpBlueNode.Children.Count > 0)

1636

if (gGrpBlueNode.Children.Count > 0)

1637

{

1637

{

1638

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

1638

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

1639

{

1639

{

1640

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

1640

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

1641

node = ellipseGeometry.Center;

1641

node = ellipseGeometry.Center;

1642

if (Freenode.X == node.X)

1642

if (Freenode.X == node.X)

1643

{

1643

{

1644

if (CheckIsNode(Freenode, node, radiusNode))

1644

if (CheckIsNode(Freenode, node, radiusNode))

1645

{

1645

{

1646

return false;

1646

return false;

1647

}

1647

}

1648

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

1648

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

1649

{

1649

{

1650

return false;

1650

return false;

1651

}

1651

}

1652

}

1652

}

1653

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

1653

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

1654

{

1654

{

1655

if (CheckIsNode(Freenode, node, radiusNode))

1655

if (CheckIsNode(Freenode, node, radiusNode))

1656

{

1656

{

1657

return false;

1657

return false;

1658

}

1658

}

1659

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

1659

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

1660

{

1660

{

1661

return false;

1661

return false;

1662

}

1662

}

1663

}

1663

}

1664

}

1664

}

1665

}

1665

}

1666

1667

return true;

1667

return true;

1668

}

1668

}

1669

1670

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

1670

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

1671

{

1671

{

1672

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

1672

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

1673

{

1673

{

1674

return true;

1674

return true;

1675

}

1675

}

1676

return false;

1676

return false;

1677

}

1677

}

1678

1679

#endregion

1679

#endregion

1680

1681

#region Edit Node

1681

#region Edit Node

1682

public void InitNodeInfo_List()

1682

public void InitNodeInfo_List()

1683

{

1683

{

1684

//Reset List

1684

//Reset List

1685

NodeInfo_List = new List<NodeInfo>();

1685

NodeInfo_List = new List<NodeInfo>();

1686

1687

if (gGrpBlueNode.Children.Count > 0)

1687

if (gGrpBlueNode.Children.Count > 0)

1688

{

1688

{

1689

// Get start point

1689

// Get start point

1690

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

1690

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

1691

Point startPoint = lineGeometry.StartPoint;

1691

Point startPoint = lineGeometry.StartPoint;

1692

1693

NodeInfo n1 = new NodeInfo();

1693

NodeInfo n1 = new NodeInfo();

1694

n1.X = startPoint.X;

1694

n1.X = startPoint.X;

1695

n1.Y = startPoint.Y;

1695

n1.Y = startPoint.Y;

1696

n1.Mode1 = "";

1696

n1.Mode1 = "";

1697

n1.Mode2 = "";

1697

n1.Mode2 = "";

1698

n1.Mode3 = "";

1698

n1.Mode3 = "";

1699

NodeInfo_List.Add(n1);

1699

NodeInfo_List.Add(n1);

1700

1701

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

1701

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

1702

{

1702

{

1703

Point point;

1703

Point point;

1704

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

1704

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

1705

point = eGeometry.Center;

1705

point = eGeometry.Center;

1706

1707

NodeInfo Ninfo = new NodeInfo();

1707

NodeInfo Ninfo = new NodeInfo();

1708

Ninfo.X = point.X;

1708

Ninfo.X = point.X;

1709

Ninfo.Y = point.Y;

1709

Ninfo.Y = point.Y;

1710

1711

Ninfo.Mode1 = "";

1711

Ninfo.Mode1 = "";

1712

Ninfo.Mode2 = "";

1712

Ninfo.Mode2 = "";

1713

Ninfo.Mode3 = "";

1713

Ninfo.Mode3 = "";

1714

1715

NodeInfo_List.Add(Ninfo);

1715

NodeInfo_List.Add(Ninfo);

1716

}

1716

}

1717

1718

// Get end point

1718

// Get end point

1719

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

1719

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

1720

Point endPoint = lineGeometry.EndPoint;

1720

Point endPoint = lineGeometry.EndPoint;

1721

1722

NodeInfo n2 = new NodeInfo();

1722

NodeInfo n2 = new NodeInfo();

1723

n2.X = startPoint.X;

1723

n2.X = startPoint.X;

1724

n2.Y = startPoint.Y;

1724

n2.Y = startPoint.Y;

1725

n2.Mode1 = "";

1725

n2.Mode1 = "";

1726

n2.Mode2 = "";

1726

n2.Mode2 = "";

1727

n2.Mode3 = "";

1727

n2.Mode3 = "";

1728

NodeInfo_List.Add(n2);

1728

NodeInfo_List.Add(n2);

1729

1730

//Resort NodeInfo_List From Start to Goal

1730

//Resort NodeInfo_List From Start to Goal

1731

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

1731

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

1732

Point startNode = firstLine.StartPoint;

1732

Point startNode = firstLine.StartPoint;

1733

Point endNode = firstLine.EndPoint;

1733

Point endNode = firstLine.EndPoint;

1734

1735

1736

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

1736

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

1737

1738

// Create temp List

1738

// Create temp List

1739

if (startNode.X == endNode.X)

1739

if (startNode.X == endNode.X)

1740

{

1740

{

1741

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

1741

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

1742

{

1742

{

1743

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

1743

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

1744

{

1744

{

1745

break;

1745

break;

1746

}

1746

}

1747

else

1747

else

1748

{

1748

{

1749

tmpLst.Add(NodeInfo_List[i]);

1749

tmpLst.Add(NodeInfo_List[i]);

1750

}

1750

}

1751

}

1751

}

1752

}

1752

}

1753

1754

if (startNode.Y == endNode.Y)

1754

if (startNode.Y == endNode.Y)

1755

{

1755

{

1756

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

1756

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

1757

{

1757

{

1758

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

1758

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

1759

{

1759

{

1760

break;

1760

break;

1761

}

1761

}

1762

else

1762

else

1763

{

1763

{

1764

tmpLst.Add(NodeInfo_List[i]);

1764

tmpLst.Add(NodeInfo_List[i]);

1765

}

1765

}

1766

}

1766

}

1767

}

1767

}

1768

1769

// Sort NodeInfo_List

1769

// Sort NodeInfo_List

1770

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

1770

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

1771

{

1771

{

1772

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

1772

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

1773

}

1773

}

1774

1775

}

1775

}

1776

}

1776

}

1777

1778

1779

//public void EditNode(Point node_edited)

1779

//public void EditNode(Point node_edited)

1780

//{

1780

//{

1781

// EllipseGeometry ellipseGeometry;

1781

// EllipseGeometry ellipseGeometry;

1782

// Point node;

1782

// Point node;

1783

// double radiusNode = RADIUS_NODE;

1783

// double radiusNode = RADIUS_NODE;

1784

1785

// bool flag = false;

1785

// bool flag = false;

1786

1787

// if (gGrpBlueNode.Children.Count > 0)

1787

// if (gGrpBlueNode.Children.Count > 0)

1788

// {

1788

// {

1789

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

1789

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

1790

// {

1790

// {

1791

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

1791

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

1792

// node = ellipseGeometry.Center;

1792

// node = ellipseGeometry.Center;

1793

1794

// if (CheckIsNode(node_edited, node, radiusNode))

1794

// if (CheckIsNode(node_edited, node, radiusNode))

1795

// {

1795

// {

1796

// flag = true;

1796

// flag = true;

1797

// }

1797

// }

1798

1799

// if (flag)

1799

// if (flag)

1800

// {

1800

// {

1801

// node_edited.X = node.X;

1801

// node_edited.X = node.X;

1802

// node_edited.Y = node.Y;

1802

// node_edited.Y = node.Y;

1803

1804

// // show form edit node

1804

// // show form edit node

1805

// EditNodeWindow edtNodeWindow = new EditNodeWindow();

1805

// EditNodeWindow edtNodeWindow = new EditNodeWindow();

1806

// edtNodeWindow.ShowDialog();

1806

// edtNodeWindow.ShowDialog();

1807

1808

// string result1 = edtNodeWindow._txtMode1;

1808

// string result1 = edtNodeWindow._txtMode1;

1809

// string result2 = edtNodeWindow._txtMode2;

1809

// string result2 = edtNodeWindow._txtMode2;

1810

// string result3 = edtNodeWindow._txtMode3;

1810

// string result3 = edtNodeWindow._txtMode3;

1811

// bool exit = edtNodeWindow._ExitFlg;

1811

// bool exit = edtNodeWindow._ExitFlg;

1812

1813

// if (!exit)

1813

// if (!exit)

1814

// {

1814

// {

1815

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

1815

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

1816

// }

1816

// }

1817

1818

// return;

1818

// return;

1819

// }

1819

// }

1820

// }

1820

// }

1821

// }

1821

// }

1822

//}

1822

//}

1823

1824

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

1824

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

1825

{

1825

{

1826

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

1826

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

1827

{

1827

{

1828

NodeInfo ni = new NodeInfo();

1828

NodeInfo ni = new NodeInfo();

1829

ni = NodeInfo_List[i];

1829

ni = NodeInfo_List[i];

1830

1831

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

1831

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

1832

{

1832

{

1833

1834

ni.Mode1 = st1;

1834

ni.Mode1 = st1;

1835

ni.Mode2 = st2;

1835

ni.Mode2 = st2;

1836

ni.Mode3 = st3;

1836

ni.Mode3 = st3;

1837

1838

NodeInfo_List[i] = ni;

1838

NodeInfo_List[i] = ni;

1839

return;

1839

return;

1840

}

1840

}

1841

}

1841

}

1842

}

1842

}

1843

1844

1845

#endregion

1845

#endregion

1846

1847

#region Display RouteInfo

1847

#region Display RouteInfo

1848

1849

public void DspRouteInfo()

1849

public void DspRouteInfo()

1850

{

1850

{

1851

//Clear Route Info Table

1851

//Clear Route Info Table

1852

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

1852

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

1853

1854

if (NodeInfo_List.Count != 0)

1854

if (NodeInfo_List.Count != 0)

1855

{

1855

{

1856

int _RowIdx = 0;

1856

int _RowIdx = 0;

1857

string _Content = "";

1857

string _Content = "";

1858

1859

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

1859

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

1860

{

1860

{

1861

1862

NodeInfo ni = new NodeInfo();

1862

NodeInfo ni = new NodeInfo();

1863

ni = NodeInfo_List[i];

1863

ni = NodeInfo_List[i];

1864

1865

//column 1

1865

//column 1

1866

if (i == 0)

1866

if (i == 0)

1867

{

1867

{

1868

_Content = "S";

1868

_Content = "S";

1869

}

1869

}

1870

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

1870

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

1871

{

1871

{

1872

_Content = "G";

1872

_Content = "G";

1873

}

1873

}

1874

else

1874

else

1875

{

1875

{

1876

_Content = i.ToString();

1876

_Content = i.ToString();

1877

}

1877

}

1878

AddLabeltoGrid(_RowIdx, 0, _Content);

1878

AddLabeltoGrid(_RowIdx, 0, _Content);

1879

1880

//column 2

1880

//column 2

1881

// Display Node's Position

1881

// Display Node's Position

1882

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

1882

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

1883

AddLabeltoGrid(_RowIdx, 1, _Content);

1883

AddLabeltoGrid(_RowIdx, 1, _Content);

1884

1885

// Display Node's Field

1885

// Display Node's Field

1886

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

1886

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

1887

{

1887

{

1888

char delimiterChars = '_';

1888

char delimiterChars = '_';

1889

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

1889

string[] tmp = ni.Mode1.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

1917

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

1917

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

1918

{

1918

{

1919

char delimiterChars = '_';

1919

char delimiterChars = '_';

1920

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

1920

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

1921

foreach (string s in tmp)

1921

foreach (string s in tmp)

1922

{

1922

{

1923

_RowIdx++;

1923

_RowIdx++;

1924

delimiterChars = ':';

1924

delimiterChars = ':';

1925

1926

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

1926

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

1927

{

1927

{

1928

double distance = 0;

1928

double distance = 0;

1929

if (i == NodeInfo_List.Count - 1)

1929

if (i == NodeInfo_List.Count - 1)

1930

{

1930

{

1931

distance = 0;

1931

distance = 0;

1932

}

1932

}

1933

else

1933

else

1934

{

1934

{

1935

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

1935

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

1936

}

1936

}

1937

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

1937

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

1938

}

1938

}

1939

else

1939

else

1940

{

1940

{

1941

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

1941

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

1942

}

1942

}

1943

1944

AddLabeltoGrid(_RowIdx, 1, _Content);

1944

AddLabeltoGrid(_RowIdx, 1, _Content);

1945

}

1945

}

1946

}

1946

}

1947

1948

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

1948

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

1949

{

1949

{

1950

char delimiterChars = '_';

1950

char delimiterChars = '_';

1951

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

1951

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

1952

foreach (string s in tmp)

1952

foreach (string s in tmp)

1953

{

1953

{

1954

_RowIdx++;

1954

_RowIdx++;

1955

delimiterChars = ':';

1955

delimiterChars = ':';

1956

1957

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

1957

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

1958

{

1958

{

1959

double distance = 0;

1959

double distance = 0;

1960

if (i == NodeInfo_List.Count - 1)

1960

if (i == NodeInfo_List.Count - 1)

1961

{

1961

{

1962

distance = 0;

1962

distance = 0;

1963

}

1963

}

1964

else

1964

else

1965

{

1965

{

1966

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

1966

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

1967

}

1967

}

1968

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

1968

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

1969

}

1969

}

1970

else

1970

else

1971

{

1971

{

1972

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

1972

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

1973

}

1973

}

1974

1975

AddLabeltoGrid(_RowIdx, 1, _Content);

1975

AddLabeltoGrid(_RowIdx, 1, _Content);

1976

}

1976

}

1977

}

1977

}

1978

_RowIdx++;

1978

_RowIdx++;

1979

}

1979

}

1980

}

1980

}

1981

}

1981

}

1982

1983

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

1983

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

1984

{

1984

{

1985

double dist = 0;

1985

double dist = 0;

1986

1987

if (_X1 == _X2)

1987

if (_X1 == _X2)

1988

{

1988

{

1989

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

1989

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

1990

}

1990

}

1991

else if (_Y1 == _Y2)

1991

else if (_Y1 == _Y2)

1992

{

1992

{

1993

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

1993

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

1994

}

1994

}

1995

return dist;

1995

return dist;

1996

}

1996

}

1997

1998

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

1998

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

1999

{

1999

{

2000

//Add Row to Grid

2000

//Add Row to Grid

2001

RowDefinition _rd = new RowDefinition();

2001

RowDefinition _rd = new RowDefinition();

2002

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

2002

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

2003

2004

// Add data to Grid

2004

// Add data to Grid

2005

Label dynamicLabel = new Label();

2005

Label dynamicLabel = new Label();

2006

2007

dynamicLabel.Content = Content;

2007

dynamicLabel.Content = Content;

2008

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

2008

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

2009

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

2009

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

2010

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

2010

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

2011

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

2011

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

2012

dynamicLabel.BorderThickness = new Thickness(1);

2012

dynamicLabel.BorderThickness = new Thickness(1);

2013

2014

Grid.SetRow(dynamicLabel, RowIdx);

2014

Grid.SetRow(dynamicLabel, RowIdx);

2015

Grid.SetColumn(dynamicLabel, ColIdx);

2015

Grid.SetColumn(dynamicLabel, ColIdx);

2016

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

2016

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

2017

}

2017

}

2018

#endregion

2018

#endregion

2019

2020

2021

public void CreateGoalPoint()

2021

public void CreateGoalPoint()

2022

{

2022

{

2023

if (isGoalDrawRoute)

2023

if (isGoalDrawRoute)

2024

{

2024

{

2025

return;

2025

return;

2026

}

2026

}

2027

2028

isStartDrawRoute = false;

2028

isStartDrawRoute = false;

2029

if (_goalPoint == null)

2029

if (_goalPoint == null)

2030

{

2030

{

2031

_goalPoint = new ucStartEndButton();

2031

_goalPoint = new ucStartEndButton();

2032

_goalPoint.btnWidth = 50.0;

2032

_goalPoint.btnWidth = 50.0;

2033

_goalPoint.btnHeight = 50.0;

2033

_goalPoint.btnHeight = 50.0;

2034

_goalPoint.buttText = "G";

2034

_goalPoint.buttText = "G";

2035

Canvas.SetLeft(_goalPoint, 675);

2035

Canvas.SetLeft(_goalPoint, 675);

2036

Canvas.SetTop(_goalPoint, 75);

2036

Canvas.SetTop(_goalPoint, 75);

2037

this.Children.Add(_goalPoint);

2037

this.Children.Add(_goalPoint);

2038

}

2038

}

2039

}

2039

}

2040

2041

public void CreateStartPoint()

2041

public void CreateStartPoint()

2042

{

2042

{

2043

if (isGoalDrawRoute)

2043

if (isGoalDrawRoute)

2044

{

2044

{

2045

return;

2045

return;

2046

}

2046

}

2047

2048

isStartDrawRoute = false;

2048

isStartDrawRoute = false;

2049

if (_startPoint == null)

2049

if (_startPoint == null)

2050

{

2050

{

2051

_startPoint = new ucStartEndButton();

2051

_startPoint = new ucStartEndButton();

2052

_startPoint.btnWidth = 50.0;

2052

_startPoint.btnWidth = 50.0;

2053

_startPoint.btnHeight = 50.0;

2053

_startPoint.btnHeight = 50.0;

2054

_startPoint.buttText = "S";

2054

_startPoint.buttText = "S";

2055

Canvas.SetLeft(_startPoint, 75);

2055

Canvas.SetLeft(_startPoint, 75);

2056

Canvas.SetTop(_startPoint, 675);

2056

Canvas.SetTop(_startPoint, 675);

2057

this.Children.Add(_startPoint);

2057

this.Children.Add(_startPoint);

2058

}

2058

}

2059

}

2059

}

2060

2061

2062

#region Draw New FreeNode

2062

#region Draw New FreeNode

2063

2064

/// <summary>

2064

/// <summary>

2065

/// Draw Auto Blue node

2065

/// Draw Auto Blue node

2066

/// </summary>

2066

/// </summary>

2067

2068

2069

public void NewSetFreeNodes(Point FreeNode, bool RightClick)

2069

public void NewSetFreeNodes(Point FreeNode, bool RightClick)

2070

{

2070

{

2071

double radiusNode = RADIUS_NODE;

2071

double radiusNode = RADIUS_NODE;

2072

2073

EllipseGeometry ellipseGeometry;

2073

EllipseGeometry ellipseGeometry;

2074

Point node;

2074

Point node;

2075

bool deleteFlag = false;

2075

bool deleteFlag = false;

2076

2077

2078

if (RightClick)

2078

if (RightClick)

2079

{

2079

{

2080

if (gGrpBlueNode.Children.Count > 0)

2080

if (gGrpBlueNode.Children.Count > 0)

2081

{

2081

{

2082

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

2082

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

2083

{

2083

{

2084

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

2084

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

2085

node = ellipseGeometry.Center;

2085

node = ellipseGeometry.Center;

2086

if (FreeNode.X == node.X)

2086

if (FreeNode.X == node.X)

2087

{

2087

{

2088

if (CheckIsNode(FreeNode, node, radiusNode))

2088

if (CheckIsNode(FreeNode, node, radiusNode))

2089

{

2089

{

2090

deleteFlag = true;

2090

deleteFlag = true;

2091

}

2091

}

2092

}

2092

}

2093

else

2093

else

2094

{

2094

{

2095

if (CheckIsNode(FreeNode, node, radiusNode))

2095

if (CheckIsNode(FreeNode, node, radiusNode))

2096

{

2096

{

2097

deleteFlag = true;

2097

deleteFlag = true;

2098

}

2098

}

2099

}

2099

}

2100

if (deleteFlag)

2100

if (deleteFlag)

2101

{

2101

{

2102

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

2102

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

2103

if (result == MessageBoxResult.OK)

2103

if (result == MessageBoxResult.OK)

2104

{

2104

{

2105

//Call Function Delete Node

2105

//Call Function Delete Node

2106

DeleteNode(i);

2106

DeleteNode(i);

2107

2108

return;

2108

return;

2109

}

2109

}

2110

else

2110

else

2111

{

2111

{

2112

return;

2112

return;

2113

}

2113

}

2114

}

2114

}

2115

}

2115

}

2116

}

2116

}

2117

}

2117

}

2118

else

2118

else

2119

{

2119

{

2120

//Check EditNode State

2120

//Check EditNode State

2121

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

2121

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

2122

{

2122

{

2123

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

2123

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

2124

node = ellipseGeometry.Center;

2124

node = ellipseGeometry.Center;

2125

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

2125

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

2126

2127

if (isEditNode)

2127

if (isEditNode)

2128

{

2128

{

2129

NewEditNode(node);

2129

NewEditNode(node);

2130

NewDspRouteInfo();

2130

NewDspRouteInfo();

2131

return;

2131

return;

2132

}

2132

}

2133

}

2133

}

2134

2135

2136

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

2136

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

2137

if (result == MessageBoxResult.OK)

2137

if (result == MessageBoxResult.OK)

2138

{

2138

{

2139

AddNode(FreeNode, gGrpBlueNode);

2139

AddNode(FreeNode, gGrpBlueNode);

2140

2141

TextBlock textBlock = new TextBlock();

2141

TextBlock textBlock = new TextBlock();

2142

textBlock.Text = stt.ToString();

2142

textBlock.Text = stt.ToString();

2143

textBlock.FontSize = 35;

2143

textBlock.FontSize = 35;

2144

textBlock.VerticalAlignment = VerticalAlignment.Center;

2144

textBlock.VerticalAlignment = VerticalAlignment.Center;

2145

textBlock.HorizontalAlignment = HorizontalAlignment.Center;

2145

textBlock.HorizontalAlignment = HorizontalAlignment.Center;

2146

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

2146

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

2147

2148

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

2148

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

2149

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

2149

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

2150

2151

2152

this.Children.Add(textBlock);

2152

this.Children.Add(textBlock);

2153

NodeNo.Add(textBlock);

2153

NodeNo.Add(textBlock);

2154

2155

if (stt > 1)

2155

if (stt > 1)

2156

{

2156

{

2157

int tmp = gGrpBlueNode.Children.Count;

2157

int tmp = gGrpBlueNode.Children.Count;

2158

2159

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

2159

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

2160

Point node1 = elip.Center;

2160

Point node1 = elip.Center;

2161

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

2161

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

2162

Point node2 = elip.Center;

2162

Point node2 = elip.Center;

2163

DrawLine(node1, node2, gGrpNewLine);

2163

DrawLine(node1, node2, gGrpNewLine);

2164

2165

2166

this.Children.Remove(pBlueNode);

2166

this.Children.Remove(pBlueNode);

2167

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

2167

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

2168

{

2168

{

2169

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

2169

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

2170

}

2170

}

2171

2172

this.Children.Add(pBlueNode);

2172

this.Children.Add(pBlueNode);

2173

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

2173

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

2174

{

2174

{

2175

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

2175

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

2176

}

2176

}

2177

}

2177

}

2178

2179

stt++;

2179

stt++;

2180

NewInitNodeInfo_List();

2180

NewInitNodeInfo_List();

2181

NewDspRouteInfo();

2181

NewDspRouteInfo();

2182

}

2182

}

2183

}

2183

}

2184

}

2184

}

2185

2186

public void DeleteNode(int i)

2186

public void DeleteNode(int i)

2187

{

2187

{

2188

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

2188

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

2189

2190

LineGeometry lineGeometry = new LineGeometry();

2190

LineGeometry lineGeometry = new LineGeometry();

2191

EllipseGeometry ellip;

2191

EllipseGeometry ellip;

2192

2193

//check delete last node

2193

//check delete last node

2194

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

2194

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

2195

{

2195

{

2196

// delete line

2196

// delete line

2197

if (gGrpNewLine.Children.Count > 0)

2197

if (gGrpNewLine.Children.Count > 0)

2198

{

2198

{

2199

gGrpNewLine.Children.RemoveAt(i - 1);

2199

gGrpNewLine.Children.RemoveAt(i - 1);

2200

}

2200

}

2201

2202

// delete ucNode

2202

// delete ucNode

2203

ucNode _ucNode = new ucNode();

2203

ucNode _ucNode = new ucNode();

2204

_ucNode = ucNode_Lst[i];

2204

_ucNode = ucNode_Lst[i];

2205

this.Children.Remove(_ucNode);

2205

this.Children.Remove(_ucNode);

2206

ucNode_Lst.RemoveAt(i);

2206

ucNode_Lst.RemoveAt(i);

2207

2208

// delete node

2208

// delete node

2209

gGrpBlueNode.Children.RemoveAt(i);

2209

gGrpBlueNode.Children.RemoveAt(i);

2210

NewNodeInfo_List.RemoveAt(i);

2210

NewNodeInfo_List.RemoveAt(i);

2211

2212

}

2212

}

2213

else

2213

else

2214

{

2214

{

2215

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

2215

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

2216

gGrpNewLine.Children.Clear();

2216

gGrpNewLine.Children.Clear();

2217

this.Children.Remove(pNewLine);

2217

this.Children.Remove(pNewLine);

2218

gGrpBlueNode.Children.RemoveAt(i);

2218

gGrpBlueNode.Children.RemoveAt(i);

2219

2220

//redraw line

2220

//redraw line

2221

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

2221

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

2222

{

2222

{

2223

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

2223

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

2224

Point node1 = ellip.Center;

2224

Point node1 = ellip.Center;

2225

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

2225

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

2226

Point node2 = ellip.Center;

2226

Point node2 = ellip.Center;

2227

DrawLine(node1, node2, gGrpNewLine);

2227

DrawLine(node1, node2, gGrpNewLine);

2228

}

2228

}

2229

2230

this.Children.Add(pNewLine);

2230

this.Children.Add(pNewLine);

2231

2232

//remove ucNode

2232

//remove ucNode

2233

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

2233

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

2234

{

2234

{

2235

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

2235

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

2236

}

2236

}

2237

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

2237

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

2238

ucNode_Lst.RemoveAt(i);

2238

ucNode_Lst.RemoveAt(i);

2239

2240

//redraw ucNode

2240

//redraw ucNode

2241

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

2241

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

2242

{

2242

{

2243

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

2243

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

2244

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

2244

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

2245

}

2245

}

2246

}

2246

}

2247

2248

//NewInitNodeInfo_List();

2248

//NewInitNodeInfo_List();

2249

2250

Lst_Node_tmp.RemoveAt(i);

2250

Lst_Node_tmp.RemoveAt(i);

2251

NewDspRouteInfo();

2251

NewDspRouteInfo();

2252

stt--;

2252

stt--;

2253

2254

}

2254

}

2255

2256

public void ReDrawAllNode()

2256

public void ReDrawAllNode()

2257

{

2257

{

2258

LineGeometry lineGeometry = new LineGeometry();

2258

LineGeometry lineGeometry = new LineGeometry();

2259

EllipseGeometry ellip;

2259

EllipseGeometry ellip;

2260

//delete all line

2260

//delete all line

2261

gGrpNewLine.Children.Clear();

2261

gGrpNewLine.Children.Clear();

2262

this.Children.Remove(pNewLine);

2262

this.Children.Remove(pNewLine);

2263

2264

//redraw line

2264

//redraw line

2265

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

2265

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

2266

{

2266

{

2267

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

2267

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

2268

Point node1 = ellip.Center;

2268

Point node1 = ellip.Center;

2269

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

2269

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

2270

Point node2 = ellip.Center;

2270

Point node2 = ellip.Center;

2271

DrawLine(node1, node2, gGrpNewLine);

2271

DrawLine(node1, node2, gGrpNewLine);

2272

}

2272

}

2273

2274

this.Children.Add(pNewLine);

2274

this.Children.Add(pNewLine);

2275

2276

2277

//redraw ucNode

2277

//redraw ucNode

2278

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

2278

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

2279

{

2279

{

2280

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

2280

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

2281

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

2281

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

2282

}

2282

}

2283

2284

//backup DB

2284

//backup DB

2285

CreateVehicleNode();

2285

CreateVehicleNode();

2286

}

2286

}

2287

2288

2289

public void NewInitNodeInfo_List()

2289

public void NewInitNodeInfo_List()

2290

{

2290

{

2291

//Reset List

2291

//Reset List

2292

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

2292

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

2293

2294

if (gGrpBlueNode.Children.Count > 0)

2294

if (gGrpBlueNode.Children.Count > 0)

2295

{

2295

{

2296

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

2296

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

2297

//{

2297

//{

2298

int i = gGrpBlueNode.Children.Count - 1;

2298

int i = gGrpBlueNode.Children.Count - 1;

2299

Point point;

2299

Point point;

2300

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

2300

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

2301

point = eGeometry.Center;

2301

point = eGeometry.Center;

2302

2303

NewNodeInfo Ninfo = new NewNodeInfo();

2303

NewNodeInfo Ninfo = new NewNodeInfo();

2304

Ninfo.X = point.X;

2304

Ninfo.X = point.X;

2305

Ninfo.Y = point.Y;

2305

Ninfo.Y = point.Y;

2306

2307

Ninfo.Mode = "";

2307

Ninfo.Mode = "";

2308

2309

NewNodeInfo_List.Add(Ninfo);

2309

NewNodeInfo_List.Add(Ninfo);

2310

//}

2310

//}

2311

2312

}

2312

}

2313

}

2313

}

2314

2315

public void NewEditNode(Point node_edited)

2315

public void NewEditNode(Point node_edited)

2316

{

2316

{

2317

EllipseGeometry ellipseGeometry;

2317

EllipseGeometry ellipseGeometry;

2318

Point node;

2318

Point node;

2319

double radiusNode = RADIUS_NODE;

2319

double radiusNode = RADIUS_NODE;

2320

2321

bool flag = false;

2321

bool flag = false;

2322

2323

if (gGrpBlueNode.Children.Count > 0)

2323

if (gGrpBlueNode.Children.Count > 0)

2324

{

2324

{

2325

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

2325

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

2326

{

2326

{

2327

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

2327

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

2328

node = ellipseGeometry.Center;

2328

node = ellipseGeometry.Center;

2329

2330

if (CheckIsNode(node_edited, node, radiusNode))

2330

if (CheckIsNode(node_edited, node, radiusNode))

2331

{

2331

{

2332

flag = true;

2332

flag = true;

2333

}

2333

}

2334

2335

if (flag)

2335

if (flag)

2336

{

2336

{

2337

node_edited.X = node.X;

2337

node_edited.X = node.X;

2338

node_edited.Y = node.Y;

2338

node_edited.Y = node.Y;

2339

2340

// show form edit node

2340

// show form edit node

2341

EditNodeWindow edtNodeWindow = new EditNodeWindow();

2341

EditNodeWindow edtNodeWindow = new EditNodeWindow();

2342

List<ListNodeInfo> lst_tmpdfd = new List<ListNodeInfo>();

2342

List<ListNodeInfo> lst_tmpdfd = new List<ListNodeInfo>();

2343

2344

if (ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList.Count > 0)

2344

if (ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList.Count > 0)

2345

{

2345

{

2346

for (int k = 0; k < ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList.Count; k++)

2346

for (int k = 0; k < ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList.Count; k++)

2347

{

2347

{

2348

double X = ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList[k].pointMap_X;

2348

double X = ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList[k].pointMap_X;

2349

double Y = ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList[k].pointMap_Y;

2349

double Y = ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList[k].pointMap_Y;

2350

if (node_edited.X == X && node_edited.Y == Y)

2350

if (node_edited.X == X && node_edited.Y == Y)

2351

{

2351

{

2352

if (ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList[k].ListNodeInfo.Count > 0)

2352

if (ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList[k].ListNodeInfo.Count > 0)

2353

{

2353

{

2354

for (int m = 0; m < ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList[k].ListNodeInfo.Count; m++)

2354

for (int m = 0; m < ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList[k].ListNodeInfo.Count; m++)

2355

{

2355

{

2356

ListNodeInfo InputNodeInfo = new ListNodeInfo();

2356

ListNodeInfo InputNodeInfo = new ListNodeInfo();

2357

InputNodeInfo.Mode = ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList[k].ListNodeInfo[m].Mode;

2357

InputNodeInfo.Mode = ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList[k].ListNodeInfo[m].Mode;

2358

InputNodeInfo.Speed = ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList[k].ListNodeInfo[m].Speed;

2358

InputNodeInfo.Speed = ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList[k].ListNodeInfo[m].Speed;

2359

InputNodeInfo.Angle = ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList[k].ListNodeInfo[m].Angle;

2359

InputNodeInfo.Angle = ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList[k].ListNodeInfo[m].Angle;

2360

InputNodeInfo.Height = ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList[k].ListNodeInfo[m].Height;

2360

InputNodeInfo.Height = ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList[k].ListNodeInfo[m].Height;

2361

InputNodeInfo.ModeSelected = ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList[k].ListNodeInfo[m].ModeSelected;

2361

InputNodeInfo.ModeSelected = ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList[k].ListNodeInfo[m].ModeSelected;

2362

lst_tmpdfd.Add(InputNodeInfo);

2362

lst_tmpdfd.Add(InputNodeInfo);

2363

}

2363

}

2364

2365

edtNodeWindow.NodeInf_List = lst_tmpdfd;

2365

edtNodeWindow.NodeInf_List = lst_tmpdfd;

2366

2367

}

2367

}

2368

edtNodeWindow.NameNode = ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList[k].nameNode;

2368

edtNodeWindow.NameNode = ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList[k].nameNode;

2369

edtNodeWindow.LAT = X.ToString(); ;

2369

edtNodeWindow.LAT = X.ToString(); ;

2370

edtNodeWindow.LOC = Y.ToString();

2370

edtNodeWindow.LOC = Y.ToString();

2371

2372

}

2372

}

2373

}

2373

}

2374

}

2374

}

2375

2376

edtNodeWindow.ShowDialog();

2376

edtNodeWindow.ShowDialog();

2377

2378

//Save NameNode

2378

//Save NameNode

2379

string strNameNode = edtNodeWindow.NameNode;

2379

string strNameNode = edtNodeWindow.NameNode;

2380

ListNameNode nmNode = new ListNameNode();

2380

ListNameNode nmNode = new ListNameNode();

2381

2382

nmNode.X = node.X;

2382

nmNode.X = node.X;

2383

nmNode.Y = node.Y;

2383

nmNode.Y = node.Y;

2384

nmNode.nameNode = strNameNode;

2384

nmNode.nameNode = strNameNode;

2385

2386

NameNode_List[i] = nmNode;

2386

NameNode_List[i] = nmNode;

2387

2388

2389

ucNode _ucNode = new ucNode();

2389

ucNode _ucNode = new ucNode();

2390

_ucNode = ucNode_Lst[i];

2390

_ucNode = ucNode_Lst[i];

2391

this.Children.Remove(_ucNode);

2391

this.Children.Remove(_ucNode);

2392

ucNode_Lst.RemoveAt(i);

2392

ucNode_Lst.RemoveAt(i);

2393

2394

string color = ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList[i].color;

2394

string color = ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList[i].color;

2395

CreateMapNode(node, i, color, strNameNode);

2395

CreateMapNode(node, i, color, strNameNode);

2396

2397

2398

2399

2400

2401

2402

string result = edtNodeWindow._txtMode;

2402

string result = edtNodeWindow._txtMode;

2403

2404

List<ListNodeInfo> lst_tmp = edtNodeWindow.NodeInf_List;

2404

List<ListNodeInfo> lst_tmp = edtNodeWindow.NodeInf_List;

2405

Lst_Node_tmp[i].NodeInfo_tmp.Clear();

2405

Lst_Node_tmp[i].NodeInfo_tmp.Clear();

2406

2407

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

2407

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

2408

{

2408

{

2409

2410

ListNodeInfo ni = new ListNodeInfo();

2410

ListNodeInfo ni = new ListNodeInfo();

2411

ni = lst_tmp[j];

2411

ni = lst_tmp[j];

2412

2413

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

2413

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

2414

}

2414

}

2415

2416

2417

//backup DB

2417

//backup DB

2418

CreateVehicleNode();

2418

CreateVehicleNode();

2419

2420

bool exit = edtNodeWindow._ExitFlg;

2420

bool exit = edtNodeWindow._ExitFlg;

2421

2422

if (!exit)

2422

if (!exit)

2423

{

2423

{

2424

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

2424

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

2425

}

2425

}

2426

2427

return;

2427

return;

2428

}

2428

}

2429

}

2429

}

2430

}

2430

}

2431

}

2431

}

2432

2433

//Save Node's Data Edited

2433

//Save Node's Data Edited

2434

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

2434

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

2435

{

2435

{

2436

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

2436

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

2437

{

2437

{

2438

NewNodeInfo ni = new NewNodeInfo();

2438

NewNodeInfo ni = new NewNodeInfo();

2439

ni = NewNodeInfo_List[i];

2439

ni = NewNodeInfo_List[i];

2440

2441

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

2441

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

2442

{

2442

{

2443

ni.Mode = st;

2443

ni.Mode = st;

2444

2445

NewNodeInfo_List[i] = ni;

2445

NewNodeInfo_List[i] = ni;

2446

return;

2446

return;

2447

}

2447

}

2448

}

2448

}

2449

}

2449

}

2450

2451

public void NewDspRouteInfo()

2451

public void NewDspRouteInfo()

2452

{

2452

{

2453

//Clear Route Info Table

2453

//Clear Route Info Table

2454

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

2454

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

2455

int _RowIdx = 0;

2455

int _RowIdx = 0;

2456

string _Content = "";

2456

string _Content = "";

2457

2458

if (Lst_Node_tmp.Count != 0)

2458

if (Lst_Node_tmp.Count != 0)

2459

{

2459

{

2460

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

2460

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

2461

{

2461

{

2462

//column 1 : node index

2462

//column 1 : node index

2463

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

2463

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

2464

AddLabeltoGrid(_RowIdx, 0, _Content);

2464

AddLabeltoGrid(_RowIdx, 0, _Content);

2465

2466

//column 2

2466

//column 2

2467

// Display Node's Position

2467

// Display Node's Position

2468

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

2468

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

2469

AddLabeltoGrid(_RowIdx, 1, _Content);

2469

AddLabeltoGrid(_RowIdx, 1, _Content);

2470

_RowIdx++;

2470

_RowIdx++;

2471

2472

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

2472

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

2473

AddLabeltoGrid(_RowIdx, 1, _Content);

2473

AddLabeltoGrid(_RowIdx, 1, _Content);

2474

2475

// Display Node's Field

2475

// Display Node's Field

2476

2477

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

2477

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

2478

{

2478

{

2479

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

2479

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

2480

{

2480

{

2481

if (ni.Speed != 0 && ni.ModeSelected == 1)

2481

if (ni.Speed != 0 && ni.ModeSelected == 1)

2482

{

2482

{

2483

_RowIdx++;

2483

_RowIdx++;

2484

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

2484

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

2485

AddLabeltoGrid(_RowIdx, 1, _Content);

2485

AddLabeltoGrid(_RowIdx, 1, _Content);

2486

}

2486

}

2487

}

2487

}

2488

2489

}

2489

}

2490

_RowIdx++;

2490

_RowIdx++;

2491

}

2491

}

2492

2493

}

2493

}

2494

2495

}

2495

}

2496

2497

2498

//2017/03/07 tach rieng CreateNode start

2498

//2017/03/07 tach rieng CreateNode start

2499

private void execDeleteNode(Point FreeNode)

2499

private void execDeleteNode(Point FreeNode)

2500

{

2500

{

2501

2502

double radiusNode = RADIUS_NODE;

2502

double radiusNode = RADIUS_NODE;

2503

2504

EllipseGeometry ellipseGeometry;

2504

EllipseGeometry ellipseGeometry;

2505

Point node;

2505

Point node;

2506

bool deleteFlag = false;

2506

bool deleteFlag = false;

2507

2508

if (gGrpBlueNode.Children.Count > 0)

2508

if (gGrpBlueNode.Children.Count > 0)

2509

{

2509

{

2510

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

2510

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

2511

{

2511

{

2512

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

2512

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

2513

node = ellipseGeometry.Center;

2513

node = ellipseGeometry.Center;

2514

if (FreeNode.X == node.X)

2514

if (FreeNode.X == node.X)

2515

{

2515

{

2516

if (CheckIsNode(FreeNode, node, radiusNode))

2516

if (CheckIsNode(FreeNode, node, radiusNode))

2517

{

2517

{

2518

deleteFlag = true;

2518

deleteFlag = true;

2519

}

2519

}

2520

}

2520

}

2521

else

2521

else

2522

{

2522

{

2523

if (CheckIsNode(FreeNode, node, radiusNode))

2523

if (CheckIsNode(FreeNode, node, radiusNode))

2524

{

2524

{

2525

deleteFlag = true;

2525

deleteFlag = true;

2526

}

2526

}

2527

}

2527

}

2528

if (deleteFlag)

2528

if (deleteFlag)

2529

{

2529

{

2530

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

2530

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

2531

if (result == MessageBoxResult.OK)

2531

if (result == MessageBoxResult.OK)

2532

{

2532

{

2533

DeleteNode(i);

2533

DeleteNode(i);

2534

SetScheduleRoute();

2534

SetScheduleRoute();

2535

2536

return;

2536

return;

2537

}

2537

}

2538

else

2538

else

2539

{

2539

{

2540

return;

2540

return;

2541

}

2541

}

2542

}

2542

}

2543

}

2543

}

2544

}

2544

}

2545

}

2545

}

2546

2547

2548

private void execEditNode(Point FreeNode)

2548

private void execEditNode(Point FreeNode)

2549

{

2549

{

2550

EllipseGeometry ellipseGeometry;

2550

EllipseGeometry ellipseGeometry;

2551

Point node;

2551

Point node;

2552

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

2552

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

2553

{

2553

{

2554

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

2554

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

2555

node = ellipseGeometry.Center;

2555

node = ellipseGeometry.Center;

2556

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

2556

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

2557

2558

if (isEditNode)

2558

if (isEditNode)

2559

{

2559

{

2560

NewEditNode(node);

2560

NewEditNode(node);

2561

NewDspRouteInfo();

2561

NewDspRouteInfo();

2562

return;

2562

return;

2563

}

2563

}

2564

}

2564

}

2565

}

2565

}

2566

2567

2568

private void execCreateNode(Point FreeNode)

2568

private void execCreateNode(Point FreeNode)

2569

{

2569

{

2570

bool createNodeFlag = false;

2570

bool createNodeFlag = false;

2571

string NameNode = "";

2571

string NameNode = "";

2572

//check new node in exist line

2572

//check new node in exist line

2573

if (gGrpNewLine.Children.Count > 0)

2573

if (gGrpNewLine.Children.Count > 0)

2574

{

2574

{

2575

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

2575

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

2576

{

2576

{

2577

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

2577

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

2578

Point p1 = lineGeometry.StartPoint;

2578

Point p1 = lineGeometry.StartPoint;

2579

Point p2 = lineGeometry.EndPoint;

2579

Point p2 = lineGeometry.EndPoint;

2580

2581

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

2581

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

2582

2583

if (pInL)

2583

if (pInL)

2584

{

2584

{

2585

// show form create node

2585

// show form create node

2586

2587

AddNodeView edtNodeWindow = new AddNodeView();

2587

AddNodeView edtNodeWindow = new AddNodeView();

2588

edtNodeWindow.ShowDialog();

2588

edtNodeWindow.ShowDialog();

2589

createNodeFlag = edtNodeWindow.CreateNodeFlag;

2589

createNodeFlag = edtNodeWindow.CreateNodeFlag;

2590

NameNode = edtNodeWindow.NameNode;

2590

NameNode = edtNodeWindow.NameNode;

2591

2592

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

2592

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

2593

if (createNodeFlag)

2593

if (createNodeFlag)

2594

{

2594

{

2595

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

2595

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

2596

FreeNode = tmpPoint;

2596

FreeNode = tmpPoint;

2597

2598

CreateMapNode(FreeNode, i + 1, ColorNode_Insert, NameNode);

2598

CreateMapNode(FreeNode, i + 1, ColorNode_Insert, NameNode);

2599

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

2599

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

2600

//set location infor to table info

2600

//set location infor to table info

2601

SetLoc_NodeInfoList(FreeNode, i + 1);

2601

SetLoc_NodeInfoList(FreeNode, i + 1);

2602

2603

SetScheduleRoute();

2603

SetScheduleRoute();

2604

2605

ListIndexNodeInsert ListIndex = new ListIndexNodeInsert();

2605

ListIndexNodeInsert ListIndex = new ListIndexNodeInsert();

2606

ListIndex.X = FreeNode.X;

2606

ListIndex.X = FreeNode.X;

2607

ListIndex.Y = FreeNode.Y;

2607

ListIndex.Y = FreeNode.Y;

2608

IndexNodeInsert_List.Add(ListIndex);

2608

IndexNodeInsert_List.Add(ListIndex);

2609

2610

ListNameNode ListNamenodde = new ListNameNode();

2610

ListNameNode ListNamenodde = new ListNameNode();

2611

ListNamenodde.X = FreeNode.X;

2611

ListNamenodde.X = FreeNode.X;

2612

ListNamenodde.Y = FreeNode.Y;

2612

ListNamenodde.Y = FreeNode.Y;

2613

ListNamenodde.nameNode = NameNode;

2613

ListNamenodde.nameNode = NameNode;

2614

NameNode_List.Add(ListNamenodde);

2614

NameNode_List.Add(ListNamenodde);

2615

2616

//rename Point textName

2616

//rename Point textName

2617

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

2617

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

2618

{

2618

{

2619

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

2619

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

2620

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

2620

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

2621

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

2621

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

2622

}

2622

}

2623

2624

ReDrawAllNode();

2624

ReDrawAllNode();

2625

2626

stt++;

2626

stt++;

2627

NewInitNodeInfo_List();

2627

NewInitNodeInfo_List();

2628

NewDspRouteInfo();

2628

NewDspRouteInfo();

2629

return;

2629

return;

2630

}

2630

}

2631

else

2631

else

2632

{

2632

{

2633

return;

2633

return;

2634

}

2634

}

2635

}

2635

}

2636

}

2636

}

2637

}

2637

}

2638

2639

if(readMapFan == true)

2639

if(readMapFan == true)

2640

{

2640

{

2641

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

2641

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

2642

2643

ListNameNode ListNamenodde = new ListNameNode();

2643

ListNameNode ListNamenodde = new ListNameNode();

2644

ListNamenodde.X = FreeNode.X;

2644

ListNamenodde.X = FreeNode.X;

2645

ListNamenodde.Y = FreeNode.Y;

2645

ListNamenodde.Y = FreeNode.Y;

2646

ListNamenodde.nameNode = NameNode;

2646

ListNamenodde.nameNode = NameNode;

2647

NameNode_List.Add(ListNamenodde);

2647

NameNode_List.Add(ListNamenodde);

2648

2649

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

2649

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

2650

//set location infor to table info

2650

//set location infor to table info

2651

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

2651

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

2652

2653

SetScheduleRoute();

2653

SetScheduleRoute();

2654

2655

//draw line

2655

//draw line

2656

if (stt > 1)

2656

if (stt > 1)

2657

{

2657

{

2658

//delete all line

2658

//delete all line

2659

gGrpNewLine.Children.Clear();

2659

gGrpNewLine.Children.Clear();

2660

this.Children.Remove(pNewLine);

2660

this.Children.Remove(pNewLine);

2661

//redraw line

2661

//redraw line

2662

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

2662

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

2663

{

2663

{

2664

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

2664

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

2665

Point node1 = ellip.Center;

2665

Point node1 = ellip.Center;

2666

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

2666

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

2667

Point node2 = ellip.Center;

2667

Point node2 = ellip.Center;

2668

DrawLine(node1, node2, gGrpNewLine);

2668

DrawLine(node1, node2, gGrpNewLine);

2669

}

2669

}

2670

2671

this.Children.Add(pNewLine);

2671

this.Children.Add(pNewLine);

2672

2673

//rename Point textName

2673

//rename Point textName

2674

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

2674

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

2675

{

2675

{

2676

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

2676

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

2677

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

2677

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

2678

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

2678

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

2679

}

2679

}

2680

}

2680

}

2681

2682

stt++;

2682

stt++;

2683

NewInitNodeInfo_List();

2683

NewInitNodeInfo_List();

2684

NewDspRouteInfo();

2684

NewDspRouteInfo();

2685

}

2685

}

2686

else

2686

else

2687

{

2687

{

2688

2689

AddNodeView createNodeWindow = new AddNodeView();

2689

AddNodeView createNodeWindow = new AddNodeView();

2690

createNodeWindow.ShowDialog();

2690

createNodeWindow.ShowDialog();

2691

createNodeFlag = createNodeWindow.CreateNodeFlag;

2691

createNodeFlag = createNodeWindow.CreateNodeFlag;

2692

NameNode = createNodeWindow.NameNode;

2692

NameNode = createNodeWindow.NameNode;

2693

if (createNodeFlag)

2693

if (createNodeFlag)

2694

{

2694

{

2695

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

2695

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

2696

2697

ListNameNode ListNamenodde = new ListNameNode();

2697

ListNameNode ListNamenodde = new ListNameNode();

2698

ListNamenodde.X = FreeNode.X;

2698

ListNamenodde.X = FreeNode.X;

2699

ListNamenodde.Y = FreeNode.Y;

2699

ListNamenodde.Y = FreeNode.Y;

2700

ListNamenodde.nameNode = NameNode;

2700

ListNamenodde.nameNode = NameNode;

2701

NameNode_List.Add(ListNamenodde);

2701

NameNode_List.Add(ListNamenodde);

2702

2703

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

2703

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

2704

//set location infor to table info

2704

//set location infor to table info

2705

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

2705

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

2706

2707

SetScheduleRoute();

2707

SetScheduleRoute();

2708

2709

//draw line

2709

//draw line

2710

if (stt > 1)

2710

if (stt > 1)

2711

{

2711

{

2712

//delete all line

2712

//delete all line

2713

gGrpNewLine.Children.Clear();

2713

gGrpNewLine.Children.Clear();

2714

this.Children.Remove(pNewLine);

2714

this.Children.Remove(pNewLine);

2715

//redraw line

2715

//redraw line

2716

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

2716

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

2717

{

2717

{

2718

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

2718

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

2719

Point node1 = ellip.Center;

2719

Point node1 = ellip.Center;

2720

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

2720

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

2721

Point node2 = ellip.Center;

2721

Point node2 = ellip.Center;

2722

DrawLine(node1, node2, gGrpNewLine);

2722

DrawLine(node1, node2, gGrpNewLine);

2723

}

2723

}

2724

2725

this.Children.Add(pNewLine);

2725

this.Children.Add(pNewLine);

2726

2727

//rename Point textName

2727

//rename Point textName

2728

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

2728

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

2729

{

2729

{

2730

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

2730

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

2731

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

2731

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

2732

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

2732

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

2733

}

2733

}

2734

}

2734

}

2735

2736

stt++;

2736

stt++;

2737

NewInitNodeInfo_List();

2737

NewInitNodeInfo_List();

2738

NewDspRouteInfo();

2738

NewDspRouteInfo();

2739

}

2739

}

2740

}

2740

}

2741

2742

2743

}

2743

}

2744

2745

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

2745

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

2746

{

2746

{

2747

ucNode _ucNode = new ucNode();

2747

ucNode _ucNode = new ucNode();

2748

_ucNode.btnWidth = UCNODE_WIDTH;

2748

_ucNode.btnWidth = UCNODE_WIDTH;

2749

_ucNode.btnHeight = UCNODE_HEIGHT;

2749

_ucNode.btnHeight = UCNODE_HEIGHT;

2750

2751

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

2751

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

2752

_ucNode.coordString = NameNode;

2752

_ucNode.coordString = NameNode;

2753

_ucNode.NameNode = NameNode;

2753

_ucNode.NameNode = NameNode;

2754

2755

_ucNode.fillColor = Color;

2755

_ucNode.fillColor = Color;

2756

_ucNode.IsDragDelta = true;

2756

_ucNode.IsDragDelta = true;

2757

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

2757

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

2758

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

2758

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

2759

this.Children.Add(_ucNode);

2759

this.Children.Add(_ucNode);

2760

//ucNode_Lst.Add(_ucNode);

2760

//ucNode_Lst.Add(_ucNode);

2761

ucNode_Lst.Insert(stt, _ucNode);

2761

ucNode_Lst.Insert(stt, _ucNode);

2762

2763

2764

2765

2766

2767

//AddNode(FreeNode, gGrpBlueNode);

2767

//AddNode(FreeNode, gGrpBlueNode);

2768

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

2768

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

2769

2770

}

2770

}

2771

2772

public void SetLoc_NodeInfoList(Point FreeNode, int stt)

2772

public void SetLoc_NodeInfoList(Point FreeNode, int stt)

2773

{

2773

{

2774

//add location for NodeInfoList

2774

//add location for NodeInfoList

2775

Node_tmp nodetmp = new Node_tmp();

2775

Node_tmp nodetmp = new Node_tmp();

2776

nodetmp.pointMap_X = ConvertPointDisplayToActual(FreeNode.X,Scale_X,PointMapStart_X);

2776

nodetmp.pointMap_X = ConvertPointDisplayToActual(FreeNode.X,Scale_X,PointMapStart_X);

2777

nodetmp.pointMap_Y = ConvertPointDisplayToActual(FreeNode.Y,Scale_Y,PointMapStart_Y);

2777

nodetmp.pointMap_Y = ConvertPointDisplayToActual(FreeNode.Y,Scale_Y,PointMapStart_Y);

2778

2779

Lst_Node_tmp.Insert(stt, nodetmp);

2779

Lst_Node_tmp.Insert(stt, nodetmp);

2780

2781

}

2781

}

2782

2783

public void BindBlueNode2ucNode()

2783

public void BindBlueNode2ucNode()

2784

{

2784

{

2785

string NameNode = "";

2785

string NameNode = "";

2786

bool NodeIsInsert = false;

2786

bool NodeIsInsert = false;

2787

if (gGrpBlueNode.Children.Count > 0)

2787

if (gGrpBlueNode.Children.Count > 0)

2788

{

2788

{

2789

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

2789

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

2790

{

2790

{

2791

NodeIsInsert = false;

2791

NodeIsInsert = false;

2792

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

2792

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

2793

Point node = ellipseGeometry.Center;

2793

Point node = ellipseGeometry.Center;

2794

2795

//Get Name Node

2795

//Get Name Node

2796

if (NameNode_List.Count > 0)

2796

if (NameNode_List.Count > 0)

2797

{

2797

{

2798

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

2798

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

2799

{

2799

{

2800

if (node.X == NameNode_List[k].X && node.Y == NameNode_List[k].Y)

2800

if (node.X == NameNode_List[k].X && node.Y == NameNode_List[k].Y)

2801

{

2801

{

2802

NameNode = NameNode_List[k].nameNode;

2802

NameNode = NameNode_List[k].nameNode;

2803

}

2803

}

2804

}

2804

}

2805

}

2805

}

2806

2807

//Draw Node Insert Color is Brown

2807

//Draw Node Insert Color is Brown

2808

if (IndexNodeInsert_List.Count > 0)

2808

if (IndexNodeInsert_List.Count > 0)

2809

{

2809

{

2810

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

2810

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

2811

{

2811

{

2812

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

2812

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

2813

{

2813

{

2814

NodeIsInsert = true;

2814

NodeIsInsert = true;

2815

}

2815

}

2816

}

2816

}

2817

}

2817

}

2818

if (NodeIsInsert)

2818

if (NodeIsInsert)

2819

{

2819

{

2820

CreateMapNode(node, i, ColorNode_Insert, NameNode);

2820

CreateMapNode(node, i, ColorNode_Insert, NameNode);

2821

}

2821

}

2822

else

2822

else

2823

{

2823

{

2824

CreateMapNode(node, i, ColorNode_Add, NameNode);

2824

CreateMapNode(node, i, ColorNode_Add, NameNode);

2825

}

2825

}

2826

}

2826

}

2827

}

2827

}

2828

}

2828

}

2829

2830

//2017/03/07 tach CreateNode End

2830

//2017/03/07 tach CreateNode End

2831

2832

2833

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

2833

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

2834

{

2834

{

2835

Point pointResult = new Point();

2835

Point pointResult = new Point();

2836

double X = 0;

2836

double X = 0;

2837

double Y = 0;

2837

double Y = 0;

2838

2839

double distance_Line = 0;

2839

double distance_Line = 0;

2840

double distance_l1ToPoint = 0;

2840

double distance_l1ToPoint = 0;

2841

2842

distance_Line = DistanceTo(l1, l2);

2842

distance_Line = DistanceTo(l1, l2);

2843

distance_l1ToPoint = DistanceTo(l1, point);

2843

distance_l1ToPoint = DistanceTo(l1, point);

2844

2845

2846

if (l1.X == l2.X)

2846

if (l1.X == l2.X)

2847

{

2847

{

2848

X = l1.X;

2848

X = l1.X;

2849

Y = point.Y;

2849

Y = point.Y;

2850

}

2850

}

2851

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

2851

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

2852

{

2852

{

2853

X = point.X;

2853

X = point.X;

2854

Y = l1.Y;

2854

Y = l1.Y;

2855

}

2855

}

2856

else

2856

else

2857

{

2857

{

2858

if (l1.X < l2.X)

2858

if (l1.X < l2.X)

2859

{

2859

{

2860

if (l1.Y < l2.Y)

2860

if (l1.Y < l2.Y)

2861

{

2861

{

2862

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

2862

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

2863

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

2863

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

2864

}

2864

}

2865

else

2865

else

2866

{

2866

{

2867

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

2867

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

2868

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

2868

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

2869

}

2869

}

2870

}

2870

}

2871

else

2871

else

2872

{

2872

{

2873

if (l1.Y < l2.Y)

2873

if (l1.Y < l2.Y)

2874

{

2874

{

2875

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

2875

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

2876

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

2876

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

2877

}

2877

}

2878

else

2878

else

2879

{

2879

{

2880

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

2880

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

2881

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

2881

X = l1.X - (distance_l1ToPoint * (l1.X - l2.X) / distance_Line);

2882

}

2882

}

2883

}

2883

}

2884

2885

2886

}

2886

}

2887

2888

pointResult.X = X;

2888

pointResult.X = X;

2889

pointResult.Y = Y;

2889

pointResult.Y = Y;

2890

return pointResult;

2890

return pointResult;

2891

}

2891

}

2892

2893

public static double DistanceTo(Point point1, Point point2)

2893

public static double DistanceTo(Point point1, Point point2)

2894

{

2894

{

2895

var a = (double)(point2.X - point1.X);

2895

var a = (double)(point2.X - point1.X);

2896

var b = (double)(point2.Y - point1.Y);

2896

var b = (double)(point2.Y - point1.Y);

2897

2898

return Math.Sqrt(a * a + b * b);

2898

return Math.Sqrt(a * a + b * b);

2899

}

2899

}

2900

2901

public bool PointInLine(Point point, Point l1, Point l2, double radius)

2901

public bool PointInLine(Point point, Point l1, Point l2, double radius)

2902

{

2902

{

2903

double distance = 0;

2903

double distance = 0;

2904

bool falg = false;

2904

bool falg = false;

2905

2906

if (l1.X < l2.X)

2906

if (l1.X < l2.X)

2907

{

2907

{

2908

if (l1.Y < l2.Y)

2908

if (l1.Y < l2.Y)

2909

{

2909

{

2910

if (point.X > l1.X - radius && point.X < l2.X + radius && point.Y > l1.Y - radius && point.Y < l2.Y + radius)

2910

if (point.X > l1.X - radius && point.X < l2.X + radius && point.Y > l1.Y - radius && point.Y < l2.Y + radius)

2911

{

2911

{

2912

falg = true;

2912

falg = true;

2913

}

2913

}

2914

}

2914

}

2915

else

2915

else

2916

{

2916

{

2917

if (point.X > l1.X - radius && point.X < l2.X + radius && point.Y < l1.Y + radius && point.Y > l2.Y - radius)

2917

if (point.X > l1.X - radius && point.X < l2.X + radius && point.Y < l1.Y + radius && point.Y > l2.Y - radius)

2918

{

2918

{

2919

falg = true;

2919

falg = true;

2920

}

2920

}

2921

}

2921

}

2922

}

2922

}

2923

else

2923

else

2924

{

2924

{

2925

if (l1.Y < l2.Y)

2925

if (l1.Y < l2.Y)

2926

{

2926

{

2927

if (point.X < l1.X + radius && point.X > l2.X - radius && point.Y > l1.Y - radius && point.Y < l2.Y + radius)

2927

if (point.X < l1.X + radius && point.X > l2.X - radius && point.Y > l1.Y - radius && point.Y < l2.Y + radius)

2928

{

2928

{

2929

falg = true;

2929

falg = true;

2930

}

2930

}

2931

}

2931

}

2932

else

2932

else

2933

{

2933

{

2934

if (point.X < l1.X + radius && point.X > l2.X - radius && point.Y < l1.Y + radius && point.Y > l2.Y - radius)

2934

if (point.X < l1.X + radius && point.X > l2.X - radius && point.Y < l1.Y + radius && point.Y > l2.Y - radius)

2935

{

2935

{

2936

falg = true;

2936

falg = true;

2937

}

2937

}

2938

}

2938

}

2939

}

2939

}

2940

if (falg == false)

2940

if (falg == false)

2941

{

2941

{

2942

return false;

2942

return false;

2943

}

2943

}

2944

2945

distance = DistanceFromPointToLine(point, l1, l2);

2945

distance = DistanceFromPointToLine(point, l1, l2);

2946

2947

if (distance > radius)

2947

if (distance > radius)

2948

{

2948

{

2949

return false;

2949

return false;

2950

}

2950

}

2951

return true;

2951

return true;

2952

}

2952

}

2953

2954

public static double DistanceFromPointToLine(Point point, Point l1, Point l2)

2954

public static double DistanceFromPointToLine(Point point, Point l1, Point l2)

2955

{

2955

{

2956

2957

return Math.Abs((l2.X - l1.X) * (l1.Y - point.Y) - (l1.X - point.X) * (l2.Y - l1.Y)) /

2957

return Math.Abs((l2.X - l1.X) * (l1.Y - point.Y) - (l1.X - point.X) * (l2.Y - l1.Y)) /

2958

Math.Sqrt(Math.Pow(l2.X - l1.X, 2) + Math.Pow(l2.Y - l1.Y, 2));

2958

Math.Sqrt(Math.Pow(l2.X - l1.X, 2) + Math.Pow(l2.Y - l1.Y, 2));

2959

}

2959

}

2960

2961

#endregion

2961

#endregion

2962

2963

#region Schedule

2963

#region Schedule

2964

2965

public void SetScheduleRoute()

2965

public void SetScheduleRoute()

2966

{

2966

{

2967

2968

EllipseGeometry ellipseGeometry_1;

2968

EllipseGeometry ellipseGeometry_1;

2969

EllipseGeometry ellipseGeometry_2;

2969

EllipseGeometry ellipseGeometry_2;

2970

Point node_1;

2970

Point node_1;

2971

Point node_2;

2971

Point node_2;

2972

Point node_Schedule = new Point();

2972

Point node_Schedule = new Point();

2973

//double x_1 = 50;

2973

//double x_1 = 50;

2974

//double y_1 = 80;

2974

//double y_1 = 80;

2975

//double Totaldistance = 1220;

2975

//double Totaldistance = 1220;

2976

double x_1 = NodeSchedule_X;

2976

double x_1 = NodeSchedule_X;

2977

double y_1 = CanvasScheduleHeight / 2;

2977

double y_1 = CanvasScheduleHeight / 2;

2978

double Totaldistance = CanvasScheduleWidth - NodeSchedule_X - NodeSchedule_X;

2978

double Totaldistance = CanvasScheduleWidth - NodeSchedule_X - NodeSchedule_X;

2979

2980

2981

if (ucScheduleNode_Lst.Count > 0)

2981

if (ucScheduleNode_Lst.Count > 0)

2982

{

2982

{

2983

for (int i = 0; i < ucScheduleNode_Lst.Count; i++)

2983

for (int i = 0; i < ucScheduleNode_Lst.Count; i++)

2984

{

2984

{

2985

ucNode _ucScheduleNode = new ucNode();

2985

ucNode _ucScheduleNode = new ucNode();

2986

_ucScheduleNode = ucScheduleNode_Lst[i];

2986

_ucScheduleNode = ucScheduleNode_Lst[i];

2987

scheduleCanvas.Children.Remove(_ucScheduleNode);

2987

scheduleCanvas.Children.Remove(_ucScheduleNode);

2988

2989

}

2989

}

2990

ucScheduleNode_Lst.Clear();

2990

ucScheduleNode_Lst.Clear();

2991

}

2991

}

2992

2993

gGrpScheduleNode.Children.Clear();

2993

gGrpScheduleNode.Children.Clear();

2994

gGrpScheduleLine.Children.Clear();

2994

gGrpScheduleLine.Children.Clear();

2995

2996

//Remove existed simulation

2996

//Remove existed simulation

2997

if(scheduleCanvas.simulation !=null)

2997

if(scheduleCanvas.simulation !=null)

2998

{

2998

{

2999

scheduleCanvas.Children.Remove(scheduleCanvas.simulation);

2999

scheduleCanvas.Children.Remove(scheduleCanvas.simulation);

3000

}

3000

}

3001

3002

3003

List<double> distance = new List<double>();

3003

List<double> distance = new List<double>();

3004

double addDistance;

3004

double addDistance;

3005

3006

if (gGrpBlueNode.Children.Count > 0)

3006

if (gGrpBlueNode.Children.Count > 0)

3007

{

3007

{

3008

for (int i = 0; i < gGrpBlueNode.Children.Count; i++)

3008

for (int i = 0; i < gGrpBlueNode.Children.Count; i++)

3009

{

3009

{

3010

ellipseGeometry_2 = (EllipseGeometry)gGrpBlueNode.Children[i];

3010

ellipseGeometry_2 = (EllipseGeometry)gGrpBlueNode.Children[i];

3011

node_2 = ellipseGeometry_2.Center;

3011

node_2 = ellipseGeometry_2.Center;

3012

3013

if (i >= 1)

3013

if (i >= 1)

3014

{

3014

{

3015

ellipseGeometry_1 = (EllipseGeometry)gGrpBlueNode.Children[i - 1];

3015

ellipseGeometry_1 = (EllipseGeometry)gGrpBlueNode.Children[i - 1];

3016

node_1 = ellipseGeometry_1.Center;

3016

node_1 = ellipseGeometry_1.Center;

3017

if (node_1.X == node_2.X)

3017

if (node_1.X == node_2.X)

3018

{

3018

{

3019

addDistance = Math.Abs(node_1.Y - node_2.Y);

3019

addDistance = Math.Abs(node_1.Y - node_2.Y);

3020

distance.Add(addDistance);

3020

distance.Add(addDistance);

3021

}

3021

}

3022

else if (node_1.Y == node_2.Y)

3022

else if (node_1.Y == node_2.Y)

3023

{

3023

{

3024

addDistance = Math.Abs(node_1.X - node_2.X);

3024

addDistance = Math.Abs(node_1.X - node_2.X);

3025

distance.Add(addDistance);

3025

distance.Add(addDistance);

3026

}

3026

}

3027

else

3027

else

3028

{

3028

{

3029

var a = (double)(node_2.X - node_1.X);

3029

var a = (double)(node_2.X - node_1.X);

3030

var b = (double)(node_2.Y - node_1.Y);

3030

var b = (double)(node_2.Y - node_1.Y);

3031

addDistance = Math.Sqrt(a * a + b * b);

3031

addDistance = Math.Sqrt(a * a + b * b);

3032

distance.Add(addDistance);

3032

distance.Add(addDistance);

3033

}

3033

}

3034

}

3034

}

3035

}

3035

}

3036

}

3036

}

3037

if (distance.Count > 0)

3037

if (distance.Count > 0)

3038

{

3038

{

3039

double total = 0;

3039

double total = 0;

3040

double distance_i;

3040

double distance_i;

3041

3042

for (int i = 0; i < distance.Count; i++)

3042

for (int i = 0; i < distance.Count; i++)

3043

{

3043

{

3044

total = total + distance[i];

3044

total = total + distance[i];

3045

}

3045

}

3046

3047

for (int i = 0; i < distance.Count; i++)

3047

for (int i = 0; i < distance.Count; i++)

3048

{

3048

{

3049

distance_i = distance[i] * (Totaldistance / total);

3049

distance_i = distance[i] * (Totaldistance / total);

3050

distance[i] = distance_i;

3050

distance[i] = distance_i;

3051

}

3051

}

3052

}

3052

}

3053

3054

if (gGrpBlueNode.Children.Count > 0)

3054

if (gGrpBlueNode.Children.Count > 0)

3055

{

3055

{

3056

node_Schedule.X = x_1;

3056

node_Schedule.X = x_1;

3057

node_Schedule.Y = y_1;

3057

node_Schedule.Y = y_1;

3058

AddNode(node_Schedule, gGrpScheduleNode);

3058

AddNode(node_Schedule, gGrpScheduleNode);

3059

}

3059

}

3060

3061

addDistance = x_1;

3061

addDistance = x_1;

3062

for (int i = 0; i < distance.Count; i++)

3062

for (int i = 0; i < distance.Count; i++)

3063

{

3063

{

3064

3065

node_Schedule.Y = y_1;

3065

node_Schedule.Y = y_1;

3066

addDistance = addDistance + distance[i];

3066

addDistance = addDistance + distance[i];

3067

node_Schedule.X = addDistance;

3067

node_Schedule.X = addDistance;

3068

AddNode(node_Schedule, gGrpScheduleNode);

3068

AddNode(node_Schedule, gGrpScheduleNode);

3069

}

3069

}

3070

3071

if (gGrpScheduleNode.Children.Count > 0)

3071

if (gGrpScheduleNode.Children.Count > 0)

3072

{

3072

{

3073

for (int i = 0; i < gGrpScheduleNode.Children.Count; i++)

3073

for (int i = 0; i < gGrpScheduleNode.Children.Count; i++)

3074

{

3074

{

3075

ellipseGeometry_1 = (EllipseGeometry)gGrpScheduleNode.Children[i];

3075

ellipseGeometry_1 = (EllipseGeometry)gGrpScheduleNode.Children[i];

3076

node_1 = ellipseGeometry_1.Center;

3076

node_1 = ellipseGeometry_1.Center;

3077

if (i > 0)

3077

if (i > 0)

3078

{

3078

{

3079

ellipseGeometry_2 = (EllipseGeometry)gGrpScheduleNode.Children[i - 1];

3079

ellipseGeometry_2 = (EllipseGeometry)gGrpScheduleNode.Children[i - 1];

3080

node_2 = ellipseGeometry_2.Center;

3080

node_2 = ellipseGeometry_2.Center;

3081

DrawLine(node_1, node_2, gGrpScheduleLine);

3081

DrawLine(node_1, node_2, gGrpScheduleLine);

3082

}

3082

}

3083

CreateScheduleNode(node_1, i + 1);

3083

CreateScheduleNode(node_1, i + 1);

3084

}

3084

}

3085

}

3085

}

3086

}

3086

}

3087

3088

private void CreateScheduleNode(Point point, int indexNode)

3088

private void CreateScheduleNode(Point point, int indexNode)

3089

{

3089

{

3090

ucNode _ucNode = new ucNode();

3090

ucNode _ucNode = new ucNode();

3091

_ucNode.btnWidth = UCSCHEDULENODE_WIDTH;

3091

_ucNode.btnWidth = UCSCHEDULENODE_WIDTH;

3092

_ucNode.btnHeight = UCSCHEDULENODE_HEIGHT;

3092

_ucNode.btnHeight = UCSCHEDULENODE_HEIGHT;

3093

_ucNode.txtNode = indexNode.ToString();

3093

_ucNode.txtNode = indexNode.ToString();

3094

_ucNode.IsDragDelta = false;

3094

_ucNode.IsDragDelta = false;

3095

Canvas.SetLeft(_ucNode, point.X - UCSCHEDULENODE_SETLEFT);

3095

Canvas.SetLeft(_ucNode, point.X - UCSCHEDULENODE_SETLEFT);

3096

Canvas.SetTop(_ucNode, point.Y - UCSCHEDULENODE_SETTOP);

3096

Canvas.SetTop(_ucNode, point.Y - UCSCHEDULENODE_SETTOP);

3097

scheduleCanvas.Children.Add(_ucNode);

3097

scheduleCanvas.Children.Add(_ucNode);

3098

ucScheduleNode_Lst.Add(_ucNode);

3098

ucScheduleNode_Lst.Add(_ucNode);

3099

}

3099

}

3100

3101

#endregion

3101

#endregion

3102

3103

#region Add Vehicle

3103

#region Add Vehicle

3104

3105

public void GetIndexProject()

3105

public void GetIndexProject()

3106

{

3106

{

3107

bool flag = false;

3107

bool flag = false;

3108

if (ProjectModel.ProjectModelList.Count > 0)

3108

if (ProjectModel.ProjectModelList.Count > 0)

3109

{

3109

{

3110

for (int i = 0; i < ProjectModel.ProjectModelList.Count; i++)

3110

for (int i = 0; i < ProjectModel.ProjectModelList.Count; i++)

3111

{

3111

{

3112

if (ProjectItem == ProjectModel.ProjectModelList[i].ProjectName)

3112

if (ProjectItem == ProjectModel.ProjectModelList[i].ProjectName)

3113

{

3113

{

3114

ProjectIndex = i;

3114

ProjectIndex = i;

3115

flag = true;

3115

flag = true;

3116

}

3116

}

3117

}

3117

}

3118

if (!flag)

3118

if (!flag)

3119

{

3119

{

3120

ProjectIndex = ProjectModel.ProjectModelList.Count;

3120

ProjectIndex = ProjectModel.ProjectModelList.Count;

3121

}

3121

}

3122

}

3122

}

3123

else

3123

else

3124

{

3124

{

3125

ProjectIndex = 0;

3125

ProjectIndex = 0;

3126

}

3126

}

3127

}

3127

}

3128

3129

3130

3131

3132

public void GetIndexVehicle()

3132

public void GetIndexVehicle()

3133

{

3133

{

3134

bool flag = false;

3134

bool flag = false;

3135

3136

if (ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList.Count > 0)

3136

if (ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList.Count > 0)

3137

{

3137

{

3138

for (int i = 0; i < ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList.Count; i++)

3138

for (int i = 0; i < ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList.Count; i++)

3139

{

3139

{

3140

if (VehicleItem == ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[i].VehicleName)

3140

if (VehicleItem == ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[i].VehicleName)

3141

{

3141

{

3142

VehicleIndex = i;

3142

VehicleIndex = i;

3143

flag = true;

3143

flag = true;

3144

}

3144

}

3145

}

3145

}

3146

if (!flag)

3146

if (!flag)

3147

{

3147

{

3148

VehicleIndex = ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList.Count;

3148

VehicleIndex = ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList.Count;

3149

}

3149

}

3150

}

3150

}

3151

else

3151

else

3152

{

3152

{

3153

VehicleIndex = 0;

3153

VehicleIndex = 0;

3154

}

3154

}

3155

}

3155

}

3156

3157

public void GetdataVehicle()

3157

public void GetdataVehicle()

3158

{

3158

{

3159

string NameNode = "";

3159

string NameNode = "";

3160

3161

GetIndexProject();

3161

GetIndexProject();

3162

GetIndexVehicle();

3162

GetIndexVehicle();

3163

3164

if (ProjectModel.ProjectModelList.Count > 0)

3164

if (ProjectModel.ProjectModelList.Count > 0)

3165

{

3165

{

3166

for (int i = 0; i < ucNode_Lst.Count; i++)

3166

for (int i = 0; i < ucNode_Lst.Count; i++)

3167

{

3167

{

3168

this.Children.Remove(ucNode_Lst[i]);

3168

this.Children.Remove(ucNode_Lst[i]);

3169

}

3169

}

3170

3171

3172

gGrpNewLine.Children.Clear();

3172

gGrpNewLine.Children.Clear();

3173

this.Children.Remove(pNewLine);

3173

this.Children.Remove(pNewLine);

3174

ucNode_Lst.Clear();

3174

ucNode_Lst.Clear();

3175

Lst_Node_tmp.Clear();

3175

Lst_Node_tmp.Clear();

3176

3177

3178

gGrpBlueNode.Children.Clear();

3178

gGrpBlueNode.Children.Clear();

3179

gGrpScheduleNode.Children.Clear();

3179

gGrpScheduleNode.Children.Clear();

3180

IndexNodeInsert_List.Clear();

3180

IndexNodeInsert_List.Clear();

3181

NameNode_List.Clear();

3181

NameNode_List.Clear();

3182

3183

if (VehicleIndex < ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList.Count)

3183

if (VehicleIndex < ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList.Count)

3184

{

3184

{

3185

3186

PointMapStart_X = ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapStart_X;

3186

PointMapStart_X = ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapStart_X;

3187

PointMapStart_Y = ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapStart_Y;

3187

PointMapStart_Y = ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapStart_Y;

3188

PointMapEnd_X = ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapEnd_X;

3188

PointMapEnd_X = ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapEnd_X;

3189

PointMapEnd_Y = ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapEnd_Y;

3189

PointMapEnd_Y = ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapEnd_Y;

3190

if (ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList.Count > 0)

3190

if (ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList.Count > 0)

3191

{

3191

{

3192

for (int k = 0; k < ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList.Count; k++)

3192

for (int k = 0; k < ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList.Count; k++)

3193

{

3193

{

3194

double X = ConvertPointActualToDisplay(ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList[k].pointMap_X,Scale_X,PointMapStart_X);

3194

double X = ConvertPointActualToDisplay(ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList[k].pointMap_X,Scale_X,PointMapStart_X);

3195

double Y = ConvertPointActualToDisplay(ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList[k].pointMap_Y,Scale_Y,PointMapStart_Y);

3195

double Y = ConvertPointActualToDisplay(ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList[k].pointMap_Y,Scale_Y,PointMapStart_Y);

3196

NameNode = ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList[k].nameNode;

3196

NameNode = ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList[k].nameNode;

3197

3198

Point node = new Point(X, Y);

3198

Point node = new Point(X, Y);

3199

AddNode(node, gGrpBlueNode);

3199

AddNode(node, gGrpBlueNode);

3200

3201

//Get list Node Insert

3201

//Get list Node Insert

3202

if (ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList[k].color == ColorNode_Insert)

3202

if (ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList[k].color == ColorNode_Insert)

3203

{

3203

{

3204

ListIndexNodeInsert ListIndex = new ListIndexNodeInsert();

3204

ListIndexNodeInsert ListIndex = new ListIndexNodeInsert();

3205

ListIndex.X = X;

3205

ListIndex.X = X;

3206

ListIndex.Y = Y;

3206

ListIndex.Y = Y;

3207

IndexNodeInsert_List.Add(ListIndex);

3207

IndexNodeInsert_List.Add(ListIndex);

3208

}

3208

}

3209

3210

//Get List Name Node

3210

//Get List Name Node

3211

ListNameNode ListNamenode = new ListNameNode();

3211

ListNameNode ListNamenode = new ListNameNode();

3212

ListNamenode.X = X;

3212

ListNamenode.X = X;

3213

ListNamenode.Y = Y;

3213

ListNamenode.Y = Y;

3214

ListNamenode.nameNode = NameNode;

3214

ListNamenode.nameNode = NameNode;

3215

NameNode_List.Add(ListNamenode);

3215

NameNode_List.Add(ListNamenode);

3216

3217

//Bind VehicleModel's NodeInfo to List Node Info temp

3217

//Bind VehicleModel's NodeInfo to List Node Info temp

3218

Node_tmp node_tmp = new Node_tmp();

3218

Node_tmp node_tmp = new Node_tmp();

3219

node_tmp.pointMap_X = ConvertPointDisplayToActual(X,Scale_X,PointMapStart_X);

3219

node_tmp.pointMap_X = ConvertPointDisplayToActual(X,Scale_X,PointMapStart_X);

3220

node_tmp.pointMap_Y = ConvertPointDisplayToActual(Y, Scale_Y, PointMapStart_Y);

3220

node_tmp.pointMap_Y = ConvertPointDisplayToActual(Y, Scale_Y, PointMapStart_Y);

3221

3222

foreach (ListNodeInfo tmp in ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList[k].ListNodeInfo)

3222

foreach (ListNodeInfo tmp in ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList[k].ListNodeInfo)

3223

{

3223

{

3224

node_tmp.NodeInfo_tmp.Add(tmp);

3224

node_tmp.NodeInfo_tmp.Add(tmp);

3225

}

3225

}

3226

Lst_Node_tmp.Add(node_tmp);

3226

Lst_Node_tmp.Add(node_tmp);

3227

3228

3229

X = ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList[k].pointSchedule_X;

3229

X = ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList[k].pointSchedule_X;

3230

Y = ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList[k].pointSchedule_Y;

3230

Y = ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList[k].pointSchedule_Y;

3231

node = new Point(X, Y);

3231

node = new Point(X, Y);

3232

AddNode(node, gGrpScheduleNode);

3232

AddNode(node, gGrpScheduleNode);

3233

3234

NameNode = ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList[k].nameNode;

3234

NameNode = ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList[k].nameNode;

3235

3236

}

3236

}

3237

}

3237

}

3238

}

3238

}

3239

}

3239

}

3240

3241

BindBlueNode2ucNode();

3241

BindBlueNode2ucNode();

3242

3243

ReDrawAllNode();

3243

ReDrawAllNode();

3244

3245

SetScheduleRoute();

3245

SetScheduleRoute();

3246

3247

NewDspRouteInfo();

3247

NewDspRouteInfo();

3248

3249

//Clear Route Info Table

3249

//Clear Route Info Table

3250

//((RoboforkMenu)System.Windows.Application.Current.MainWindow).grdRouteInfo.Children.Clear();

3250

//((RoboforkMenu)System.Windows.Application.Current.MainWindow).grdRouteInfo.Children.Clear();

3251

3252

3253

}

3253

}

3254

3255

public void CreateVehicleNode()

3255

public void CreateVehicleNode()

3256

{

3256

{

3257

EllipseGeometry ellipseGeometry;

3257

EllipseGeometry ellipseGeometry;

3258

Point node;

3258

Point node;

3259

ListNodeInfo ListNodeInfo = new ListNodeInfo();

3259

ListNodeInfo ListNodeInfo = new ListNodeInfo();

3260

VehicleModelList VehicleModelList = new VehicleModelList();

3260

VehicleModelList VehicleModelList = new VehicleModelList();

3261

bool NodeISInsert = false;

3261

bool NodeISInsert = false;

3262

string NameNode = "";

3262

string NameNode = "";

3263

3264

if (ProjectModel.ProjectModelList.Count == 0)

3264

if (ProjectModel.ProjectModelList.Count == 0)

3265

{

3265

{

3266

ProjectModelList ProjectModelList = new ProjectModelList();

3266

ProjectModelList ProjectModelList = new ProjectModelList();

3267

ProjectModelList.ProjectName = ProjectItem;

3267

ProjectModelList.ProjectName = ProjectItem;

3268

ProjectModel.ProjectModelList.Add(ProjectModelList);

3268

ProjectModel.ProjectModelList.Add(ProjectModelList);

3269

}

3269

}

3270

3271

3272

if (ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList.Count > 0 && VehicleIndex < ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList.Count)

3272

if (ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList.Count > 0 && VehicleIndex < ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList.Count)

3273

{

3273

{

3274

3275

ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapStart_X = PointMapStart_X;

3275

ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapStart_X = PointMapStart_X;

3276

ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapStart_Y = PointMapStart_Y;

3276

ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapStart_Y = PointMapStart_Y;

3277

ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapEnd_X = PointMapEnd_X;

3277

ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapEnd_X = PointMapEnd_X;

3278

ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapEnd_Y = PointMapEnd_Y;

3278

ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapEnd_Y = PointMapEnd_Y;

3279

3280

if (ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList.Count > 0)

3280

if (ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList.Count > 0)

3281

{

3281

{

3282

ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList.Clear();

3282

ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList.Clear();

3283

}

3283

}

3284

3285

//back up

3285

//back up

3286

if (gGrpBlueNode.Children.Count > 0)

3286

if (gGrpBlueNode.Children.Count > 0)

3287

{

3287

{

3288

for (int i = 0; i < gGrpBlueNode.Children.Count; i++)

3288

for (int i = 0; i < gGrpBlueNode.Children.Count; i++)

3289

{

3289

{

3290

NodeISInsert = false;

3290

NodeISInsert = false;

3291

ellipseGeometry = (EllipseGeometry)gGrpBlueNode.Children[i];

3291

ellipseGeometry = (EllipseGeometry)gGrpBlueNode.Children[i];

3292

node = ellipseGeometry.Center;

3292

node = ellipseGeometry.Center;

3293

3294

PointMap pMap = new PointMap();

3294

PointMap pMap = new PointMap();

3295

pMap.pointMap_X = ConvertPointDisplayToActual(node.X,Scale_X,PointMapStart_X);

3295

pMap.pointMap_X = ConvertPointDisplayToActual(node.X,Scale_X,PointMapStart_X);

3296

pMap.pointMap_Y = ConvertPointDisplayToActual(node.Y,Scale_Y,PointMapStart_Y);

3296

pMap.pointMap_Y = ConvertPointDisplayToActual(node.Y,Scale_Y,PointMapStart_Y);

3297

pMap.speed_Map = 1;

3297

pMap.speed_Map = 1;

3298

3299

//Backup List Node Insert of fork

3299

//Backup List Node Insert of fork

3300

if (IndexNodeInsert_List.Count > 0)

3300

if (IndexNodeInsert_List.Count > 0)

3301

{

3301

{

3302

for (int j = 0; j < IndexNodeInsert_List.Count; j++)

3302

for (int j = 0; j < IndexNodeInsert_List.Count; j++)

3303

{

3303

{

3304

if (node.X == IndexNodeInsert_List[j].X && node.Y == IndexNodeInsert_List[j].Y) NodeISInsert = true;

3304

if (node.X == IndexNodeInsert_List[j].X && node.Y == IndexNodeInsert_List[j].Y) NodeISInsert = true;

3305

}

3305

}

3306

}

3306

}

3307

if (NodeISInsert)

3307

if (NodeISInsert)

3308

{

3308

{

3309

pMap.color = ColorNode_Insert;

3309

pMap.color = ColorNode_Insert;

3310

}

3310

}

3311

else

3311

else

3312

{

3312

{

3313

pMap.color = ColorNode_Add;

3313

pMap.color = ColorNode_Add;

3314

}

3314

}

3315

3316

//Backup Name Node for fork

3316

//Backup Name Node for fork

3317

if (NameNode_List.Count > 0)

3317

if (NameNode_List.Count > 0)

3318

{

3318

{

3319

for (int j = 0; j < NameNode_List.Count; j++)

3319

for (int j = 0; j < NameNode_List.Count; j++)

3320

{

3320

{

3321

if (node.X == NameNode_List[j].X && node.Y == NameNode_List[j].Y) NameNode = NameNode_List[j].nameNode;

3321

if (node.X == NameNode_List[j].X && node.Y == NameNode_List[j].Y) NameNode = NameNode_List[j].nameNode;

3322

}

3322

}

3323

}

3323

}

3324

pMap.nameNode = NameNode;

3324

pMap.nameNode = NameNode;

3325

3326

3327

ellipseGeometry = (EllipseGeometry)gGrpScheduleNode.Children[i];

3327

ellipseGeometry = (EllipseGeometry)gGrpScheduleNode.Children[i];

3328

node = ellipseGeometry.Center;

3328

node = ellipseGeometry.Center;

3329

pMap.pointSchedule_X = node.X;

3329

pMap.pointSchedule_X = node.X;

3330

pMap.pointSchedule_Y = node.Y;

3330

pMap.pointSchedule_Y = node.Y;

3331

pMap.speed_Schedule = 0.2; //Hard code

3331

pMap.speed_Schedule = 0.2; //Hard code

3332

3333

//Node info

3333

//Node info

3334

foreach (ListNodeInfo temp in Lst_Node_tmp[i].NodeInfo_tmp)

3334

foreach (ListNodeInfo temp in Lst_Node_tmp[i].NodeInfo_tmp)

3335

{

3335

{

3336

pMap.ListNodeInfo.Add(temp);

3336

pMap.ListNodeInfo.Add(temp);

3337

3338

//set tam

3338

//set tam

3339

pMap.speed_Map = Lst_Node_tmp[i].NodeInfo_tmp[0].Speed;

3339

pMap.speed_Map = Lst_Node_tmp[i].NodeInfo_tmp[0].Speed;

3340

}

3340

}

3341

3342

ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList.Add(pMap);

3342

ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList.Add(pMap);

3343

3344

}

3344

}

3345

}

3345

}

3346

}

3346

}

3347

// create new

3347

// create new

3348

else

3348

else

3349

{

3349

{

3350

VehicleModelList.VehicleName = VehicleItem;

3350

VehicleModelList.VehicleName = VehicleItem;

3351

VehicleModelList.pointMapStart_X = PointMapStart_X;

3351

VehicleModelList.pointMapStart_X = PointMapStart_X;

3352

VehicleModelList.pointMapStart_Y = PointMapStart_Y;

3352

VehicleModelList.pointMapStart_Y = PointMapStart_Y;

3353

VehicleModelList.pointMapEnd_X = PointMapEnd_X;

3353

VehicleModelList.pointMapEnd_X = PointMapEnd_X;

3354

VehicleModelList.pointMapEnd_Y = PointMapEnd_Y;

3354

VehicleModelList.pointMapEnd_Y = PointMapEnd_Y;

3355

3356

if (gGrpBlueNode.Children.Count > 0)

3356

if (gGrpBlueNode.Children.Count > 0)

3357

{

3357

{

3358

for (int i = 0; i < gGrpBlueNode.Children.Count; i++)

3358

for (int i = 0; i < gGrpBlueNode.Children.Count; i++)

3359

{

3359

{

3360

NodeISInsert = false;

3360

NodeISInsert = false;

3361

ellipseGeometry = (EllipseGeometry)gGrpBlueNode.Children[i];

3361

ellipseGeometry = (EllipseGeometry)gGrpBlueNode.Children[i];

3362

node = ellipseGeometry.Center;

3362

node = ellipseGeometry.Center;

3363

3364

PointMap pMap = new PointMap();

3364

PointMap pMap = new PointMap();

3365

pMap.pointMap_X = ConvertPointDisplayToActual(node.X, Scale_X, PointMapStart_X);

3365

pMap.pointMap_X = ConvertPointDisplayToActual(node.X, Scale_X, PointMapStart_X);

3366

pMap.pointMap_Y = ConvertPointDisplayToActual(node.Y, Scale_Y, PointMapStart_Y);

3366

pMap.pointMap_Y = ConvertPointDisplayToActual(node.Y, Scale_Y, PointMapStart_Y);

3367

pMap.speed_Map = 1;

3367

pMap.speed_Map = 1;

3368

3369

//Backup List Node Insert of fork

3369

//Backup List Node Insert of fork

3370

if (IndexNodeInsert_List.Count > 0)

3370

if (IndexNodeInsert_List.Count > 0)

3371

{

3371

{

3372

for (int j = 0; j < IndexNodeInsert_List.Count; j++)

3372

for (int j = 0; j < IndexNodeInsert_List.Count; j++)

3373

{

3373

{

3374

if (node.X == IndexNodeInsert_List[j].X && node.Y == IndexNodeInsert_List[j].Y) NodeISInsert = true;

3374

if (node.X == IndexNodeInsert_List[j].X && node.Y == IndexNodeInsert_List[j].Y) NodeISInsert = true;

3375

}

3375

}

3376

}

3376

}

3377

if (NodeISInsert)

3377

if (NodeISInsert)

3378

{

3378

{

3379

pMap.color = ColorNode_Insert;

3379

pMap.color = ColorNode_Insert;

3380

}

3380

}

3381

else

3381

else

3382

{

3382

{

3383

pMap.color = ColorNode_Add;

3383

pMap.color = ColorNode_Add;

3384

}

3384

}

3385

3386

//Backup Name Node for fork

3386

//Backup Name Node for fork

3387

if (NameNode_List.Count > 0)

3387

if (NameNode_List.Count > 0)

3388

{

3388

{

3389

for (int j = 0; j < NameNode_List.Count; j++)

3389

for (int j = 0; j < NameNode_List.Count; j++)

3390

{

3390

{

3391

if (node.X == NameNode_List[j].X && node.Y == NameNode_List[j].Y) NameNode = NameNode_List[j].nameNode;

3391

if (node.X == NameNode_List[j].X && node.Y == NameNode_List[j].Y) NameNode = NameNode_List[j].nameNode;

3392

}

3392

}

3393

}

3393

}

3394

pMap.nameNode = NameNode;

3394

pMap.nameNode = NameNode;

3395

3396

//Node info

3396

//Node info

3397

foreach (ListNodeInfo temp in Lst_Node_tmp[i].NodeInfo_tmp)

3397

foreach (ListNodeInfo temp in Lst_Node_tmp[i].NodeInfo_tmp)

3398

{

3398

{

3399

pMap.ListNodeInfo.Add(temp);

3399

pMap.ListNodeInfo.Add(temp);

3400

}

3400

}

3401

3402

ellipseGeometry = (EllipseGeometry)gGrpScheduleNode.Children[i];

3402

ellipseGeometry = (EllipseGeometry)gGrpScheduleNode.Children[i];

3403

node = ellipseGeometry.Center;

3403

node = ellipseGeometry.Center;

3404

pMap.pointSchedule_X = node.X;

3404

pMap.pointSchedule_X = node.X;

3405

pMap.pointSchedule_Y = node.Y;

3405

pMap.pointSchedule_Y = node.Y;

3406

pMap.speed_Schedule = 0.2; //Hard code

3406

pMap.speed_Schedule = 0.2; //Hard code

3407

3408

VehicleModelList.pointMapList.Add(pMap);

3408

VehicleModelList.pointMapList.Add(pMap);

3409

}

3409

}

3410

}

3410

}

3411

ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList.Add(VehicleModelList);

3411

ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList.Add(VehicleModelList);

3412

}

3412

}

3413

}

3413

}

3414

#endregion

3414

#endregion

3415

3416

#region Read file Mapfan

3416

#region Read file Mapfan

3417

3418

public void ReadFile()

3418

public void ReadFile()

3419

{

3419

{

3420

//Point node;

3420

//Point node;

3421

bool line1 = true;

3421

bool line1 = true;

3422

string[] lines = System.IO.File.ReadAllLines(@"Mapfan\MapFan.index");

3422

string[] lines = System.IO.File.ReadAllLines(@"Mapfan\MapFan.index");

3423

3424

foreach (string line in lines)

3424

foreach (string line in lines)

3425

{

3425

{

3426

// Use a tab to indent each line of the file.

3426

// Use a tab to indent each line of the file.

3427

string[] tmp = line.Split('\t');

3427

string[] tmp = line.Split('\t');

3428

if (line1)

3428

if (line1)

3429

{

3429

{

3430

PointMapStart_X = Double.Parse(tmp[1]);

3430

PointMapStart_X = Double.Parse(tmp[1]);

3431

PointMapStart_Y = Double.Parse(tmp[3]);

3431

PointMapStart_Y = Double.Parse(tmp[3]);

3432

line1 = false;

3432

line1 = false;

3433

}

3433

}

3434

else

3434

else

3435

{

3435

{

3436

PointMapEnd_X = Double.Parse(tmp[1]);

3436

PointMapEnd_X = Double.Parse(tmp[1]);

3437

PointMapEnd_Y = Double.Parse(tmp[3]);

3437

PointMapEnd_Y = Double.Parse(tmp[3]);

3438

}

3438

}

3439

//double lat = ConvertPointActualToDisplay(Double.Parse(tmp[1]),Scale_X,PointMapStart_X);

3439

//double lat = ConvertPointActualToDisplay(Double.Parse(tmp[1]),Scale_X,PointMapStart_X);

3440

//double log = ConvertPointActualToDisplay(Double.Parse(tmp[3]),Scale_Y,PointMapStart_Y);

3440

//double log = ConvertPointActualToDisplay(Double.Parse(tmp[3]),Scale_Y,PointMapStart_Y);

3441

3442

//node = new Point(lat, log);

3442

//node = new Point(lat, log);

3443

3444

3445

//execCreateNode(node);

3445

//execCreateNode(node);

3446

////AddNode(node, gGrpBlueNode);

3446

////AddNode(node, gGrpBlueNode);

3447

3448

3449

}

3449

}

3450

getScaleMap();

3450

getScaleMap();

3451

3452

//SetScheduleRoute();

3452

//SetScheduleRoute();

3453

ReDrawAllNode2();

3453

ReDrawAllNode2();

3454

3455

readMapFan = false;

3455

readMapFan = false;

3456

////backup DB

3456

////backup DB

3457

//CreateVehicleNode();

3457

//CreateVehicleNode();

3458

3459

}

3459

}

3460

public void ReDrawAllNode2()

3460

public void ReDrawAllNode2()

3461

{

3461

{

3462

LineGeometry lineGeometry = new LineGeometry();

3462

LineGeometry lineGeometry = new LineGeometry();

3463

EllipseGeometry ellip;

3463

EllipseGeometry ellip;

3464

//delete all line

3464

//delete all line

3465

gGrpScheduleLine.Children.Clear();

3465

gGrpScheduleLine.Children.Clear();

3466

scheduleCanvas.Children.Remove(pScheduleLine);

3466

scheduleCanvas.Children.Remove(pScheduleLine);

3467

3468

//redraw line

3468

//redraw line

3469

for (int j = 0; j < gGrpScheduleNode.Children.Count - 1; j++)

3469

for (int j = 0; j < gGrpScheduleNode.Children.Count - 1; j++)

3470

{

3470

{

3471

ellip = (EllipseGeometry)gGrpScheduleNode.Children[j];

3471

ellip = (EllipseGeometry)gGrpScheduleNode.Children[j];

3472

Point node1 = ellip.Center;

3472

Point node1 = ellip.Center;

3473

ellip = (EllipseGeometry)gGrpScheduleNode.Children[j + 1];

3473

ellip = (EllipseGeometry)gGrpScheduleNode.Children[j + 1];

3474

Point node2 = ellip.Center;

3474

Point node2 = ellip.Center;

3475

DrawLine(node1, node2, gGrpScheduleLine);

3475

DrawLine(node1, node2, gGrpScheduleLine);

3476

}

3476

}

3477

3478

scheduleCanvas.Children.Add(pScheduleLine);

3478

scheduleCanvas.Children.Add(pScheduleLine);

3479

3480

3481

//redraw ucNode

3481

//redraw ucNode

3482

for (int k = 0; k < ucScheduleNode_Lst.Count; k++)

3482

for (int k = 0; k < ucScheduleNode_Lst.Count; k++)

3483

{

3483

{

3484

scheduleCanvas.Children.Remove(ucScheduleNode_Lst[k]);

3484

scheduleCanvas.Children.Remove(ucScheduleNode_Lst[k]);

3485

scheduleCanvas.Children.Add(ucScheduleNode_Lst[k]);

3485

scheduleCanvas.Children.Add(ucScheduleNode_Lst[k]);

3486

}

3486

}

3487

3488

////backup DB

3488

////backup DB

3489

//CreateVehicleNode();

3489

//CreateVehicleNode();

3490

}

3490

}

3491

#endregion

3491

#endregion

3492

3493

#region Get data from AWS

3493

#region Get data from AWS

3494

// Get info fork

3494

// Get info fork

3495

public void GetInfoFork()

3495

public void GetInfoFork()

3496

{

3496

{

3497

var service = new Fork2PCTableService();

3497

var service = new Fork2PCTableService();

3498

/*Read*/

3498

/*Read*/

3499

IEnumerable<Fork2PC> fork2PCs = service.GetAllFork2PCs().Where(x => x.ForkID == 1);

3499

IEnumerable<Fork2PC> fork2PCs = service.GetAllFork2PCs().Where(x => x.ForkID == 1);

3500

if (fork2PCs.Count() == 0)

3500

if (fork2PCs.Count() == 0)

3501

return;

3501

return;

3502

var fork2PC = fork2PCs.ElementAt(0);

3502

var fork2PC = fork2PCs.ElementAt(0);

3503

3504

//Clear Route Info Table

3504

//Clear Route Info Table

3505

((RoboforkMenu)System.Windows.Application.Current.MainWindow).grdRouteInfo.Children.Clear();

3505

((RoboforkMenu)System.Windows.Application.Current.MainWindow).grdRouteInfo.Children.Clear();

3506

3507

int _RowIdx = 0;

3507

int _RowIdx = 0;

3508

AddLabeltoGrid(_RowIdx, 0, "ID");

3508

AddLabeltoGrid(_RowIdx, 0, "ID");

3509

AddLabeltoGrid(_RowIdx, 1, fork2PC.ForkID.ToString());

3509

AddLabeltoGrid(_RowIdx, 1, fork2PC.ForkID.ToString());

3510

_RowIdx++;

3510

_RowIdx++;

3511

AddLabeltoGrid(_RowIdx, 0, "LAT");

3511

AddLabeltoGrid(_RowIdx, 0, "LAT");

3512

AddLabeltoGrid(_RowIdx, 1, fork2PC.ForkPos_x.ToString());

3512

AddLabeltoGrid(_RowIdx, 1, fork2PC.ForkPos_x.ToString());

3513

_RowIdx++;

3513

_RowIdx++;

3514

AddLabeltoGrid(_RowIdx, 0, "LOC");

3514

AddLabeltoGrid(_RowIdx, 0, "LOC");

3515

AddLabeltoGrid(_RowIdx, 1, fork2PC.ForkPos_y.ToString());

3515

AddLabeltoGrid(_RowIdx, 1, fork2PC.ForkPos_y.ToString());

3516

_RowIdx++;

3516

_RowIdx++;

3517

AddLabeltoGrid(_RowIdx, 0, "SPD");

3517

AddLabeltoGrid(_RowIdx, 0, "SPD");

3518

AddLabeltoGrid(_RowIdx, 1, fork2PC.spd_veh.ToString() + "Km/h");

3518

AddLabeltoGrid(_RowIdx, 1, fork2PC.spd_veh.ToString() + "Km/h");

3519

_RowIdx++;

3519

_RowIdx++;

3520

AddLabeltoGrid(_RowIdx, 0, "GPS");

3520

AddLabeltoGrid(_RowIdx, 0, "GPS");

3521

AddLabeltoGrid(_RowIdx, 1, fork2PC.GPS_data);

3521

AddLabeltoGrid(_RowIdx, 1, fork2PC.GPS_data);

3522

}

3522

}

3523

3524

/// <summary>

3524

/// <summary>

3525

/// Get infor node

3525

/// Get infor node

3526

/// </summary>

3526

/// </summary>

3527

public void UploadData()

3528

{

3529

if (ucNode_Lst.Count < 1)

3530

return;

3531

3532

Robofork15DemoService service = new Robofork15DemoService();

3533

for (int i = 0; i < ucNode_Lst.Count; i++)

3534

{

3535

Robofork15Demo node = new Robofork15Demo();

3536

ucNode _ucScheduleNode = new ucNode();

3537

_ucScheduleNode = ucNode_Lst[i];

3538

node.NodeID = i + 1;

3539

node.ForkNo = 1;

3540

node.NodePos_x = Math.Round(Canvas.GetLeft(_ucScheduleNode) + UCNODE_SETLEFT, 2);

3541

node.NodePos_y = Math.Round(Canvas.GetTop(_ucScheduleNode) + UCNODE_SETTOP, 2);

3542

service.AddRobofork15Demo(node);

3543

}

3544

3545

IEnumerable<Robofork15Demo> nodes = service.GetAllRobofork15Demos().Where(x => x.ForkNo == 1).OrderBy(x=>x.NodeID);

3546

3547

// Delete node

3548

if (ucNode_Lst.Count() == nodes.Count())

3549

{

3550

GetInfoNode();

3551

return;

3552

}

3553

3554

for (int i = ucNode_Lst.Count(); i < nodes.Count(); i++)

3555

{

3556

Robofork15Demo node = new Robofork15Demo();

3557

node = nodes.ElementAt(i);

3558

service.DeleteRobofork15Demo(node);

3559

}

3560

}

3561

3562

/// <summary>

3563

/// Get infor node

3564

/// </summary>

3565

public void GetInfoNode()

3527

public void GetInfoNode()

3566

{

3528

{

3567

var service = new Robofork15DemoService();

3529

var service = new Robofork15DemoService();

3568

3569

readMapFan = true;

3570

/*Read*/

3530

/*Read*/

3571

IEnumerable<Robofork15Demo> nodes = service.GetAllRobofork15Demos().Where(x => x.ForkNo == 1).OrderBy(x => x.NodeID);

3531

IEnumerable<Robofork15Demo> fork2PCs = service.GetAllRobofork15Demos().Where(x => x.ForkNo == 1).OrderBy(x => x.NodeID);

3572

3532

3573

//Clear Route Info Table

3533

//Clear Route Info Table

3574

((RoboforkMenu)System.Windows.Application.Current.MainWindow).grdRouteInfo.Children.Clear();

3534

((RoboforkMenu)System.Windows.Application.Current.MainWindow).grdRouteInfo.Children.Clear();

3575

3535

3576

// Process clear canvas

3536

// Process clear canvas

3577

ClearCanvas();

3537

ClearCanvas();

3578

3538

3579

//int _RowIdx = 0;

3539

int _RowIdx = 0;

3580

foreach (var node in nodes)

3540

foreach (var fork2PC in fork2PCs)

3581

{

3541

{

3582

//execCreateNode(new Point(ConvertPointActualToDisplay(node.NodePos_x, Scale_X, PointMapStart_X)

3542

ucNode _ucNode = new ucNode();

3583

// , ConvertPointActualToDisplay(node.NodePos_y, Scale_X, PointMapStart_Y)));

3543

_ucNode.txtNode = fork2PC.NodeID.ToString();

3544

_ucNode.IsDragDelta = true;

3545

_ucNode._dataNode = fork2PC;

3546

Canvas.SetLeft(_ucNode, fork2PC.NodePos_x - UCNODE_SETLEFT);

3547

Canvas.SetTop(_ucNode, fork2PC.NodePos_y - UCNODE_SETTOP);

3548

ucNode_Lst.Add(_ucNode);

3549

this.Children.Add(_ucNode);

3584

3550

3585

execCreateNode(new Point(node.NodePos_x, node.NodePos_y));

3551

//Column 1 : node index

3586

}

3552

AddLabeltoGrid(_RowIdx, 0, fork2PC.NodeID.ToString());

3587

3553

3588

CreateVehicleNode();

3554

//Column 2 : Pos_X, Pos_Y, Speed

3555

AddLabeltoGrid(_RowIdx, 1, "LAT: " + fork2PC.NodePos_x.ToString());

3556

_RowIdx++;

3557

AddLabeltoGrid(_RowIdx, 1, "LOC: " + fork2PC.NodePos_y.ToString());

3558

_RowIdx++;

3559

AddLabeltoGrid(_RowIdx, 1, "SPD: " + fork2PC.NodeVehSpd.ToString() + "Km/h");

3560

_RowIdx++;

3561

}

3589

}

3562

}

3590

3563

3591

/// <summary>

3564

/// <summary>

3592

/// Clear all data on canvas

3565

/// Clear all data on canvas

3593

/// </summary>

3566

/// </summary>

3594

public void ClearCanvas()

3567

public void ClearCanvas()

3595

{

3568

{

3596

// Clear data on designer canvas

3569

// Clear data on designer canvas

3597

for (int i = 0; i < ucNode_Lst.Count; i++)

3570

for (int i = 0; i < ucNode_Lst.Count; i++)

3598

{

3571

{

3599

this.Children.Remove(ucNode_Lst[i]);

3572

this.Children.Remove(ucNode_Lst[i]);

3600

}

3573

}

3601

3574

3602

gGrpNewLine.Children.Clear();

3575

gGrpNewLine.Children.Clear();

3603

this.Children.Remove(pNewLine);

3576

this.Children.Remove(pNewLine);

3604

ucNode_Lst.Clear();

3577

ucNode_Lst.Clear();

3605

Lst_Node_tmp.Clear();

3578

Lst_Node_tmp.Clear();

3606

3579

3607

gGrpBlueNode.Children.Clear();

3580

gGrpBlueNode.Children.Clear();

3608

gGrpScheduleNode.Children.Clear();

3581

gGrpScheduleNode.Children.Clear();

3609

IndexNodeInsert_List.Clear();

3582

IndexNodeInsert_List.Clear();

3610

3583

3611

// Clear data on schedule canvas

3584

// Clear data on schedule canvas

3612

if (ucScheduleNode_Lst.Count > 0)

3585

if (ucScheduleNode_Lst.Count > 0)

3613

{

3586

{

3614

for (int i = 0; i < ucScheduleNode_Lst.Count; i++)

3587

for (int i = 0; i < ucScheduleNode_Lst.Count; i++)

3615

{

3588

{

3616

ucNode _ucScheduleNode = new ucNode();

3589

ucNode _ucScheduleNode = new ucNode();

3617

_ucScheduleNode = ucScheduleNode_Lst[i];

3590

_ucScheduleNode = ucScheduleNode_Lst[i];

3618

scheduleCanvas.Children.Remove(_ucScheduleNode);

3591

scheduleCanvas.Children.Remove(_ucScheduleNode);

3619

3592

3620

}

3593

}

3621

ucScheduleNode_Lst.Clear();

3594

ucScheduleNode_Lst.Clear();

3622

}

3595

}

3623

gGrpScheduleNode.Children.Clear();

3596

gGrpScheduleNode.Children.Clear();

3624

gGrpScheduleLine.Children.Clear();

3597

gGrpScheduleLine.Children.Clear();

3625

}

3598

}

3626

#endregion

3599

#endregion

3627

3600

3628

#region Add new Project

3601

#region Add new Project

3629

public void AddNewProjectItem()

3602

public void AddNewProjectItem()

3630

{

3603

{

3631

ProjectModelList ProjectModelList = new ProjectModelList();

3604

ProjectModelList ProjectModelList = new ProjectModelList();

3632

ProjectModelList.ProjectName = ProjectItem;

3605

ProjectModelList.ProjectName = ProjectItem;

3633

3606

3634

ProjectModel.ProjectModelList.Add(ProjectModelList);

3607

ProjectModel.ProjectModelList.Add(ProjectModelList);

3635

}

3608

}

3636

3609

3637

#endregion

3610

#endregion

3638

3611

3639

#region get scale map

3612

#region get scale map

3640

3613

3641

public void getScaleMap()

3614

public void getScaleMap()

3642

{

3615

{

3643

Scale_X = ConvertScaleMap(PointMapEnd_X - PointMapStart_X, DISTANCEMAPDISPLAY);

3616

Scale_X = ConvertScaleMap(PointMapEnd_X - PointMapStart_X, DISTANCEMAPDISPLAY);

3644

Scale_Y = ConvertScaleMap(PointMapEnd_Y - PointMapStart_Y, DISTANCEMAPDISPLAY);

3617

Scale_Y = ConvertScaleMap(PointMapEnd_Y - PointMapStart_Y, DISTANCEMAPDISPLAY);

3645

}

3618

}

3646

3619

3647

public double ConvertScaleMap(double distance, double const1000)

3620

public double ConvertScaleMap(double distance, double const1000)

3648

{

3621

{

3649

return distance / const1000;

3622

return distance / const1000;

3650

}

3623

}

3651

3624

GITLAB

toan / Robofork

Revert "RM2101 commit source"

 using RoboforkApp.DataModel;
 //using RoboforkApp.Entities;
 //using RoboforkApp.Services;
 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;
 using System.Data;
 using RoboforkApp.View;
 using RoboforkApp.Services;
 using RoboforkApp.Entities;
 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;
         const double UCSCHEDULENODE_SETLEFT = 12;
         const double UCSCHEDULENODE_SETTOP = 12;
         const double UCSCHEDULENODE_WIDTH = 24;
         const double UCSCHEDULENODE_HEIGHT = 24;
         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 static bool readMapFan = true;
         public static double CanvasScheduleWidth = 0;
         public static double CanvasScheduleHeight = 0;
         public const double NodeSchedule_X = 50;
         public double PointMapStart_X = 127.85783428698775;
         public double PointMapStart_Y = 26.336094486866543;
         public double PointMapEnd_X = 128.85783428698775;
         public double PointMapEnd_Y = 27.336094486866543;
         const double DISTANCEMAPDISPLAY = 1000;
         public double Scale_X = 0;
         public double Scale_Y = 0;
         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;
         public static bool LoadDBFlag = false;
         //Add variable for Vehicle Item click
         public string VehicleItem = "FK_15";
         public int VehicleIndex = 0;
         public string ColorNode_Add = "Blue";
         public string ColorNode_Insert = "Brown";
         public int ProjectIndex = 0;
         public string ProjectItem = "ProjectAAA";
         public ProjectModel ProjectModel = new ProjectModel();
         //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 struct ListNameNode
         {
             public double X;
             public double Y;
             public string nameNode;
         }
         List<ListNameNode> NameNode_List = new List<ListNameNode>();
         public ScheduleCanvas scheduleCanvas = new ScheduleCanvas();
         // Add variable for Set Auto Nodes
         public Path pBlueNode = new Path();
         private GeometryGroup gGrpBlueNode = new GeometryGroup();
         // Add variable for Actual Nodes
         public Path pActualNode = new Path();
         private GeometryGroup gGrpActualNode = 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);
                         Lst_Node_tmp[i].pointMap_X = ConvertPointDisplayToActual(StartDrawPoint.X, Scale_X, PointMapStart_X);
                         Lst_Node_tmp[i].pointMap_Y = ConvertPointDisplayToActual(StartDrawPoint.Y, Scale_X, PointMapStart_Y);
                         //Update Location for List NameNode_List -> Compare Location to get Name
                         ListNameNode nmNode = new ListNameNode();
                         ListNameNode nmNode_old = new ListNameNode();
                         nmNode_old = NameNode_List[i];
                         nmNode.X = StartDrawPoint.X;
                         nmNode.Y = StartDrawPoint.Y;
                         nmNode.nameNode = nmNode_old.nameNode;
                         NameNode_List[i] = nmNode;
                     }
                 }
                 ReDrawAllNode();
                 NewDspRouteInfo();
                 SetScheduleRoute();
                 DragDeltaFlag = false;
             }
             return;
         }
         /// <summary>
         /// On Preview Mouse Down
         /// </summary>
         /// <param name="e"></param>
         protected override void OnPreviewMouseDown(MouseButtonEventArgs e)
         {
             base.OnPreviewMouseDown(e);
             if (DesignerCanvas.LoadDBFlag)
                 return;
             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>
         public 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();
                         List<ListNodeInfo> lst_tmpdfd = new List<ListNodeInfo>();
                         if (ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList.Count > 0)
                         {
                             for (int k = 0; k < ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList.Count; k++)
                             {
                                 double X = ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList[k].pointMap_X;
                                 double Y = ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList[k].pointMap_Y;
                                 if (node_edited.X == X && node_edited.Y == Y)
                                 {
                                     if (ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList[k].ListNodeInfo.Count > 0)
                                     {
                                         for (int m = 0; m < ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList[k].ListNodeInfo.Count; m++)
                                         {
                                             ListNodeInfo InputNodeInfo = new ListNodeInfo();
                                             InputNodeInfo.Mode = ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList[k].ListNodeInfo[m].Mode;
                                             InputNodeInfo.Speed = ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList[k].ListNodeInfo[m].Speed;
                                             InputNodeInfo.Angle = ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList[k].ListNodeInfo[m].Angle;
                                             InputNodeInfo.Height = ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList[k].ListNodeInfo[m].Height;
                                             InputNodeInfo.ModeSelected = ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList[k].ListNodeInfo[m].ModeSelected;
                                             lst_tmpdfd.Add(InputNodeInfo);
                                         }
                                         edtNodeWindow.NodeInf_List = lst_tmpdfd;
                                     }
                                     edtNodeWindow.NameNode = ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList[k].nameNode;
                                     edtNodeWindow.LAT = X.ToString(); ;
                                     edtNodeWindow.LOC = Y.ToString();
                                 }
                             }
                         }
                         edtNodeWindow.ShowDialog();
                         //Save NameNode
                         string strNameNode = edtNodeWindow.NameNode;
                         ListNameNode nmNode = new ListNameNode();
                         nmNode.X = node.X;
                         nmNode.Y = node.Y;
                         nmNode.nameNode = strNameNode;
                         NameNode_List[i] = nmNode;
                         ucNode _ucNode = new ucNode();
                         _ucNode = ucNode_Lst[i];
                         this.Children.Remove(_ucNode);
                         ucNode_Lst.RemoveAt(i);
                         string color = ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList[i].color;
                         CreateMapNode(node, i, color, strNameNode);
                         string result = edtNodeWindow._txtMode;
                         List<ListNodeInfo> lst_tmp = edtNodeWindow.NodeInf_List;
                         Lst_Node_tmp[i].NodeInfo_tmp.Clear();
                         for (int j = 0; j < lst_tmp.Count; j++)
                         {
                             ListNodeInfo ni = new ListNodeInfo();
                             ni = lst_tmp[j];
                             Lst_Node_tmp[i].NodeInfo_tmp.Add(ni);
                         }
                         //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 && ni.ModeSelected == 1)
                             {
                                 _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)
         {
             bool createNodeFlag = false;
             string NameNode = "";
             //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)
                     {
                         // show form create node
                         AddNodeView edtNodeWindow = new AddNodeView();
                         edtNodeWindow.ShowDialog();
                         createNodeFlag = edtNodeWindow.CreateNodeFlag;
                         NameNode = edtNodeWindow.NameNode;
                         //MessageBoxResult result = MessageBox.Show("Do You Want To Add This Node?", "Add Node", MessageBoxButton.OKCancel);
                         if (createNodeFlag)
                         {
                             Point tmpPoint = ConvertNodeinLine(FreeNode, p1, p2);
                             FreeNode = tmpPoint;
                             CreateMapNode(FreeNode, i + 1, ColorNode_Insert, NameNode);
                             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);
                             ListNameNode ListNamenodde = new ListNameNode();
                             ListNamenodde.X = FreeNode.X;
                             ListNamenodde.Y = FreeNode.Y;
                             ListNamenodde.nameNode = NameNode;
                             NameNode_List.Add(ListNamenodde);
                             //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;
                         }
                     }
                 }
             }
             if(readMapFan == true)
             {
                 CreateMapNode(FreeNode, gGrpBlueNode.Children.Count, ColorNode_Add, NameNode);
                 ListNameNode ListNamenodde = new ListNameNode();
                 ListNamenodde.X = FreeNode.X;
                 ListNamenodde.Y = FreeNode.Y;
                 ListNamenodde.nameNode = NameNode;
                 NameNode_List.Add(ListNamenodde);
                 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();
             }
             else
             {
                 AddNodeView createNodeWindow = new AddNodeView();
                 createNodeWindow.ShowDialog();
                 createNodeFlag = createNodeWindow.CreateNodeFlag;
                 NameNode = createNodeWindow.NameNode;
                 if (createNodeFlag)
                 {
                     CreateMapNode(FreeNode, gGrpBlueNode.Children.Count, ColorNode_Add, NameNode);
                     ListNameNode ListNamenodde = new ListNameNode();
                     ListNamenodde.X = FreeNode.X;
                     ListNamenodde.Y = FreeNode.Y;
                     ListNamenodde.nameNode = NameNode;
                     NameNode_List.Add(ListNamenodde);
                     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, string NameNode)
         {
             ucNode _ucNode = new ucNode();
             _ucNode.btnWidth = UCNODE_WIDTH;
             _ucNode.btnHeight = UCNODE_HEIGHT;
             _ucNode.txtNode = (stt + 1).ToString();
             _ucNode.coordString = NameNode;
             _ucNode.NameNode = NameNode;
             _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 = ConvertPointDisplayToActual(FreeNode.X,Scale_X,PointMapStart_X);
             nodetmp.pointMap_Y = ConvertPointDisplayToActual(FreeNode.Y,Scale_Y,PointMapStart_Y);
             Lst_Node_tmp.Insert(stt, nodetmp);
         }
         public void BindBlueNode2ucNode()
         {
             string NameNode = "";
             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;
                     //Get Name Node
                     if (NameNode_List.Count > 0)
                     {
                         for (int k = 0; k < NameNode_List.Count; k++)
                         {
                             if (node.X == NameNode_List[k].X && node.Y == NameNode_List[k].Y)
                             {
                                 NameNode = NameNode_List[k].nameNode;
                             }
                         }
                     }
                     //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, NameNode);
                     }
                     else
                     {
                         CreateMapNode(node, i, ColorNode_Add, NameNode);
                     }
                 }
             }
         }
         //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 = 1220;
             double x_1 = NodeSchedule_X;
             double y_1 = CanvasScheduleHeight / 2;
             double Totaldistance = CanvasScheduleWidth - NodeSchedule_X - NodeSchedule_X;
             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 = x_1;
             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 = UCSCHEDULENODE_WIDTH;
             _ucNode.btnHeight = UCSCHEDULENODE_HEIGHT;
             _ucNode.txtNode = indexNode.ToString();
             _ucNode.IsDragDelta = false;
             Canvas.SetLeft(_ucNode, point.X - UCSCHEDULENODE_SETLEFT);
             Canvas.SetTop(_ucNode, point.Y - UCSCHEDULENODE_SETTOP);
             scheduleCanvas.Children.Add(_ucNode);
             ucScheduleNode_Lst.Add(_ucNode);
         }
         #endregion
         #region Add Vehicle
         public void GetIndexProject()
         {
             bool flag = false;
             if (ProjectModel.ProjectModelList.Count > 0)
             {
                 for (int i = 0; i < ProjectModel.ProjectModelList.Count; i++)
                 {
                     if (ProjectItem == ProjectModel.ProjectModelList[i].ProjectName)
                     {
                         ProjectIndex = i;
                         flag = true;
                     }
                 }
                 if (!flag)
                 {
                     ProjectIndex = ProjectModel.ProjectModelList.Count;
                 }
             }
             else
             {
                 ProjectIndex = 0;
             }
         }
         public void GetIndexVehicle()
         {
             bool flag = false;
             if (ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList.Count > 0)
             {
                 for (int i = 0; i < ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList.Count; i++)
                 {
                     if (VehicleItem == ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[i].VehicleName)
                     {
                         VehicleIndex = i;
                         flag = true;
                     }
                 }
                 if (!flag)
                 {
                     VehicleIndex = ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList.Count;
                 }
             }
             else
             {
                 VehicleIndex = 0;
             }
         }
         public void GetdataVehicle()
         {
             string NameNode = "";
             GetIndexProject();
             GetIndexVehicle();
             if (ProjectModel.ProjectModelList.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();
                 NameNode_List.Clear();
                 if (VehicleIndex < ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList.Count)
                 {
                     PointMapStart_X = ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapStart_X;
                     PointMapStart_Y = ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapStart_Y;
                     PointMapEnd_X = ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapEnd_X;
                     PointMapEnd_Y = ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapEnd_Y;
                     if (ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList.Count > 0)
                     {
                         for (int k = 0; k < ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList.Count; k++)
                         {
                             double X = ConvertPointActualToDisplay(ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList[k].pointMap_X,Scale_X,PointMapStart_X);
                             double Y = ConvertPointActualToDisplay(ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList[k].pointMap_Y,Scale_Y,PointMapStart_Y);
                             NameNode = ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList[k].nameNode;
                             Point node = new Point(X, Y);
                             AddNode(node, gGrpBlueNode);
                             //Get list Node Insert
                             if (ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList[k].color == ColorNode_Insert)
                             {
                                 ListIndexNodeInsert ListIndex = new ListIndexNodeInsert();
                                 ListIndex.X = X;
                                 ListIndex.Y = Y;
                                 IndexNodeInsert_List.Add(ListIndex);
                             }
                             //Get List Name Node
                             ListNameNode ListNamenode = new ListNameNode();
                             ListNamenode.X = X;
                             ListNamenode.Y = Y;
                             ListNamenode.nameNode = NameNode;
                             NameNode_List.Add(ListNamenode);
                             //Bind VehicleModel's NodeInfo to List Node Info temp
                             Node_tmp node_tmp = new Node_tmp();
                             node_tmp.pointMap_X = ConvertPointDisplayToActual(X,Scale_X,PointMapStart_X);
                             node_tmp.pointMap_Y = ConvertPointDisplayToActual(Y, Scale_Y, PointMapStart_Y);
                             foreach (ListNodeInfo tmp in ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList[k].ListNodeInfo)
                             {
                                 node_tmp.NodeInfo_tmp.Add(tmp);
                             }
                             Lst_Node_tmp.Add(node_tmp);
                             X = ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList[k].pointSchedule_X;
                             Y = ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList[k].pointSchedule_Y;
                             node = new Point(X, Y);
                             AddNode(node, gGrpScheduleNode);
                             NameNode = ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList[k].nameNode;
                         }
                     }
                 }
             }
             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;
             string NameNode = "";
             if (ProjectModel.ProjectModelList.Count == 0)
             {
                 ProjectModelList ProjectModelList = new ProjectModelList();
                 ProjectModelList.ProjectName = ProjectItem;
                 ProjectModel.ProjectModelList.Add(ProjectModelList);
             }
             if (ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList.Count > 0 && VehicleIndex < ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList.Count)
             {
                 ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapStart_X = PointMapStart_X;
                 ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapStart_Y = PointMapStart_Y;
                 ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapEnd_X = PointMapEnd_X;
                 ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapEnd_Y = PointMapEnd_Y;
                 if (ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList.Count > 0)
                 {
                     ProjectModel.ProjectModelList[ProjectIndex].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 = ConvertPointDisplayToActual(node.X,Scale_X,PointMapStart_X);
                         pMap.pointMap_Y = ConvertPointDisplayToActual(node.Y,Scale_Y,PointMapStart_Y);
                         pMap.speed_Map = 1;
                         //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;
                         }
                         //Backup Name Node for fork
                         if (NameNode_List.Count > 0)
                         {
                             for (int j = 0; j < NameNode_List.Count; j++)
                             {
                                 if (node.X == NameNode_List[j].X && node.Y == NameNode_List[j].Y) NameNode = NameNode_List[j].nameNode;
                             }
                         }
                         pMap.nameNode = NameNode;
                         ellipseGeometry = (EllipseGeometry)gGrpScheduleNode.Children[i];
                         node = ellipseGeometry.Center;
                         pMap.pointSchedule_X = node.X;
                         pMap.pointSchedule_Y = node.Y;
                         pMap.speed_Schedule = 0.2; //Hard code
                         //Node info
                         foreach (ListNodeInfo temp in Lst_Node_tmp[i].NodeInfo_tmp)
                         {
                             pMap.ListNodeInfo.Add(temp);
                             //set tam
                             pMap.speed_Map = Lst_Node_tmp[i].NodeInfo_tmp[0].Speed;
                         }
                         ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList.Add(pMap);
                     }
                 }
             }
             // create new
             else
             {
                 VehicleModelList.VehicleName = VehicleItem;
                 VehicleModelList.pointMapStart_X = PointMapStart_X;
                 VehicleModelList.pointMapStart_Y = PointMapStart_Y;
                 VehicleModelList.pointMapEnd_X = PointMapEnd_X;
                 VehicleModelList.pointMapEnd_Y = PointMapEnd_Y;
                 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 = ConvertPointDisplayToActual(node.X, Scale_X, PointMapStart_X);
                         pMap.pointMap_Y = ConvertPointDisplayToActual(node.Y, Scale_Y, PointMapStart_Y);
                         pMap.speed_Map = 1;
                         //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;
                         }
                         //Backup Name Node for fork
                         if (NameNode_List.Count > 0)
                         {
                             for (int j = 0; j < NameNode_List.Count; j++)
                             {
                                 if (node.X == NameNode_List[j].X && node.Y == NameNode_List[j].Y) NameNode = NameNode_List[j].nameNode;
                             }
                         }
                         pMap.nameNode = NameNode;
                         //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.2; //Hard code
                         VehicleModelList.pointMapList.Add(pMap);
                     }
                 }
                 ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList.Add(VehicleModelList);
             }
         }
         #endregion
         #region Read file Mapfan
         public void ReadFile()
         {
             //Point node;
             bool line1 = true;
             string[] lines = System.IO.File.ReadAllLines(@"Mapfan\MapFan.index");
             foreach (string line in lines)
             {
                 // Use a tab to indent each line of the file.
                 string[] tmp = line.Split('\t');
                 if (line1)
                 {
                     PointMapStart_X = Double.Parse(tmp[1]);
                     PointMapStart_Y = Double.Parse(tmp[3]);
                     line1 = false;
                 }
                 else
                 {
                     PointMapEnd_X = Double.Parse(tmp[1]);
                     PointMapEnd_Y = Double.Parse(tmp[3]);
                 }
                 //double lat = ConvertPointActualToDisplay(Double.Parse(tmp[1]),Scale_X,PointMapStart_X);
                 //double log = ConvertPointActualToDisplay(Double.Parse(tmp[3]),Scale_Y,PointMapStart_Y);
                 //node = new Point(lat, log);
                 //execCreateNode(node);
                 ////AddNode(node, gGrpBlueNode);
             }
             getScaleMap();
             //SetScheduleRoute();
             ReDrawAllNode2();
             readMapFan = false;
             ////backup DB
             //CreateVehicleNode();
         }
         public void ReDrawAllNode2()
         {
             LineGeometry lineGeometry = new LineGeometry();
             EllipseGeometry ellip;
             //delete all line
             gGrpScheduleLine.Children.Clear();
             scheduleCanvas.Children.Remove(pScheduleLine);
             //redraw line
             for (int j = 0; j < gGrpScheduleNode.Children.Count - 1; j++)
             {
                 ellip = (EllipseGeometry)gGrpScheduleNode.Children[j];
                 Point node1 = ellip.Center;
                 ellip = (EllipseGeometry)gGrpScheduleNode.Children[j + 1];
                 Point node2 = ellip.Center;
                 DrawLine(node1, node2, gGrpScheduleLine);
             }
             scheduleCanvas.Children.Add(pScheduleLine);
             //redraw ucNode
             for (int k = 0; k < ucScheduleNode_Lst.Count; k++)
             {
                 scheduleCanvas.Children.Remove(ucScheduleNode_Lst[k]);
                 scheduleCanvas.Children.Add(ucScheduleNode_Lst[k]);
             }
             ////backup DB
             //CreateVehicleNode();
         }
         #endregion
         #region Get data from AWS
         // Get info fork
         public void GetInfoFork()
         {
             var service = new Fork2PCTableService();
             /*Read*/
             IEnumerable<Fork2PC> fork2PCs = service.GetAllFork2PCs().Where(x => x.ForkID == 1);
             if (fork2PCs.Count() == 0)
                 return;
             var fork2PC = fork2PCs.ElementAt(0);
             //Clear Route Info Table
             ((RoboforkMenu)System.Windows.Application.Current.MainWindow).grdRouteInfo.Children.Clear();
             int _RowIdx = 0;
             AddLabeltoGrid(_RowIdx, 0, "ID");
             AddLabeltoGrid(_RowIdx, 1, fork2PC.ForkID.ToString());
             _RowIdx++;
             AddLabeltoGrid(_RowIdx, 0, "LAT");
             AddLabeltoGrid(_RowIdx, 1, fork2PC.ForkPos_x.ToString());
             _RowIdx++;
             AddLabeltoGrid(_RowIdx, 0, "LOC");
             AddLabeltoGrid(_RowIdx, 1, fork2PC.ForkPos_y.ToString());
             _RowIdx++;
             AddLabeltoGrid(_RowIdx, 0, "SPD");
             AddLabeltoGrid(_RowIdx, 1, fork2PC.spd_veh.ToString() + "Km/h");
             _RowIdx++;
             AddLabeltoGrid(_RowIdx, 0, "GPS");
             AddLabeltoGrid(_RowIdx, 1, fork2PC.GPS_data);
         }
         /// <summary>
         /// Get infor node
         /// </summary>
-        public void UploadData()
-        {
-            if (ucNode_Lst.Count < 1)
-                return;
-            Robofork15DemoService service = new Robofork15DemoService();
-            for (int i = 0; i < ucNode_Lst.Count; i++)
-            {
-                Robofork15Demo node = new Robofork15Demo();
-                ucNode _ucScheduleNode = new ucNode();
-                _ucScheduleNode = ucNode_Lst[i];
-                node.NodeID = i + 1;
-                node.ForkNo = 1;
-                node.NodePos_x = Math.Round(Canvas.GetLeft(_ucScheduleNode) + UCNODE_SETLEFT, 2);
-                node.NodePos_y = Math.Round(Canvas.GetTop(_ucScheduleNode) + UCNODE_SETTOP, 2);
-                service.AddRobofork15Demo(node);
-            }
-            IEnumerable<Robofork15Demo> nodes = service.GetAllRobofork15Demos().Where(x => x.ForkNo == 1).OrderBy(x=>x.NodeID);
-            // Delete node
-            if (ucNode_Lst.Count() == nodes.Count())
-            {
-                GetInfoNode();
-                return;
-            }
-            for (int i = ucNode_Lst.Count(); i < nodes.Count(); i++)
-            {
-                Robofork15Demo node = new Robofork15Demo();
-                node = nodes.ElementAt(i);
-                service.DeleteRobofork15Demo(node);
-            }
-        }
-        /// <summary>
-        /// Get infor node
-        /// </summary>
         public void GetInfoNode()
         {
             var service = new Robofork15DemoService();
-            readMapFan = true;
             /*Read*/
-            IEnumerable<Robofork15Demo> nodes = service.GetAllRobofork15Demos().Where(x => x.ForkNo == 1).OrderBy(x => x.NodeID);
+            IEnumerable<Robofork15Demo> fork2PCs = service.GetAllRobofork15Demos().Where(x => x.ForkNo == 1).OrderBy(x => x.NodeID);
             //Clear Route Info Table
             ((RoboforkMenu)System.Windows.Application.Current.MainWindow).grdRouteInfo.Children.Clear();
             // Process clear canvas
             ClearCanvas();
-            //int _RowIdx = 0;
+            int _RowIdx = 0;
-            foreach (var node in nodes)
+            foreach (var fork2PC in fork2PCs)
             {
-                //execCreateNode(new Point(ConvertPointActualToDisplay(node.NodePos_x, Scale_X, PointMapStart_X)
+                ucNode _ucNode = new ucNode();
-                //                        , ConvertPointActualToDisplay(node.NodePos_y, Scale_X, PointMapStart_Y)));
+                _ucNode.txtNode = fork2PC.NodeID.ToString();
+                _ucNode.IsDragDelta = true;
+                _ucNode._dataNode = fork2PC;
+                Canvas.SetLeft(_ucNode, fork2PC.NodePos_x - UCNODE_SETLEFT);
+                Canvas.SetTop(_ucNode, fork2PC.NodePos_y - UCNODE_SETTOP);
+                ucNode_Lst.Add(_ucNode);
+                this.Children.Add(_ucNode);
-                execCreateNode(new Point(node.NodePos_x, node.NodePos_y));
+                //Column 1 : node index
-            }
+                AddLabeltoGrid(_RowIdx, 0, fork2PC.NodeID.ToString());
-            CreateVehicleNode();
+                //Column 2 : Pos_X, Pos_Y, Speed
+                AddLabeltoGrid(_RowIdx, 1, "LAT: " + fork2PC.NodePos_x.ToString());
+                _RowIdx++;
+                AddLabeltoGrid(_RowIdx, 1, "LOC: " + fork2PC.NodePos_y.ToString());
+                _RowIdx++;
+                AddLabeltoGrid(_RowIdx, 1, "SPD: " + fork2PC.NodeVehSpd.ToString() + "Km/h");
+                _RowIdx++;
+            }
         }
         /// <summary>
         /// Clear all data on canvas
         /// </summary>
         public void ClearCanvas()
         {
             // Clear data on designer canvas
             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();
             // Clear data on schedule canvas
             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();
         }
         #endregion
         #region Add new Project
         public void AddNewProjectItem()
         {
             ProjectModelList ProjectModelList = new ProjectModelList();
             ProjectModelList.ProjectName = ProjectItem;
             ProjectModel.ProjectModelList.Add(ProjectModelList);
         }
         #endregion
         #region get scale map
         public void getScaleMap()
         {
             Scale_X = ConvertScaleMap(PointMapEnd_X - PointMapStart_X, DISTANCEMAPDISPLAY);
             Scale_Y = ConvertScaleMap(PointMapEnd_Y - PointMapStart_Y, DISTANCEMAPDISPLAY);
         }
         public double ConvertScaleMap(double distance, double const1000)
         {
             return distance / const1000;
         }

 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.Data;
 using System.Windows.Documents;
 using System.Windows.Input;
 using System.Windows.Media;
 using System.Windows.Media.Imaging;
 using System.Windows.Shapes;
 using RoboforkApp.Commons;
 namespace RoboforkApp
 {
     /// <summary>
     /// Interaction logic for RoboforkMenu.xaml
     /// </summary>
     public partial class RoboforkMenu : Window
     {
         private Common cm = new Common();
         private const double CanvasdWidth = 1000;
         private const double CanvasHeight = 1000;
         public int IndexVehicle = 15;
         public int IndexProject = 0;
         public RoboforkMenu()
         {
             InitializeComponent();
             Load_Form();
         }
         private void Load_Form()
         {
             //PassplanTree.IsEnabled = false;
             //NodeTree.IsEnabled = false;
             MyDesignerCanvas.InitDrawRoute();
             MyDesignerCanvas.scheduleCanvas = MyScheduleCanvas;
         }
         private void Window_Loaded(object sender, RoutedEventArgs e)
         {
             GetScaleCanVas();
             GetScheduleCanVas();
             MyDesignerCanvas.ReadFile();
-            NewDoBeginSetFreeNotes();
-            DesignerCanvas.isDrawingNode = true;
-            MyDesignerCanvas.GetInfoNode();
             DisplayMap_1();
         }
         public void GetScaleCanVas()
         {
             double Width = 0;
             double Height = 0;
             Width = GridCanVas.ActualWidth;
             Height = GridCanVas.ActualHeight;
             ScaleCanvas scale = new ScaleCanvas();
             scale.scaleWidthCanvas = Width / CanvasdWidth;
             scale.scaleHeightCanvas = Height / CanvasHeight;
             this.MyDesignerCanvas.DataContext = scale;
         }
         public void GetScheduleCanVas()
         {
             double Width = 0;
             double Height = 0;
             Width = MCGridShedule.ActualWidth;
             Height = MCGridShedule.ActualHeight;
             DesignerCanvas.CanvasScheduleWidth = Width;
             DesignerCanvas.CanvasScheduleHeight = Height;
         }
         private void DisplayMap_1()
         {
             ImageBrush myBrush = new ImageBrush();
             Image image = new Image();
             //myBrush.ImageSource = new BitmapImage(new Uri(@"..\..\Images\map.png", UriKind.Relative));
             image.Source = new BitmapImage(new Uri("pack://application:,,,/Images/mapindex.png"));
             myBrush.ImageSource = image.Source;
             //Grid grid = new Grid();
             MCGrid.Background = myBrush;
         }
         private void DisplayMap_2()
         {
             ImageBrush myBrush = new ImageBrush();
             Image image = new Image();
             //myBrush.ImageSource = new BitmapImage(new Uri(@"..\..\Images\map.png", UriKind.Relative));
             image.Source = new BitmapImage(new Uri("pack://application:,,,/Images/map.png"));
             myBrush.ImageSource = image.Source;
             //Grid grid = new Grid();
             MCGrid.Background = myBrush;
         }
         private void btnMenu_Selected(object sender, RoutedEventArgs e)
         {
             if (((TreeViewItem)sender) == null)
             {
                 return;
             }
             string tag = ((TreeViewItem)sender).Tag.ToString();
             switch (tag)
             {
                 //2017/03/04 NAM ADD START1
                 case "NodeTree":
                     NewDoBeginSetFreeNotes();
                     break;
                 //2017/03/04 NAM ADD END
                 case "SetupRestriction":
                     DoBeginSetupRestriction();
                     break;
                 case "SetStart":
                     DoBeginSetStart();
                     break;
                 case "SetGoal":
                     DoBeginSetGoal();
                     break;
                 case "SetupRoute":
                     DoBeginSetupRoute();
                     break;
                 case "MakeRoot":
                     DoBeginMakeRoot();
                     break;
                 case "DeleteRoute":
                     DoBeginDeleteRoute();
                     break;
                 case "SetAutoNodes":
                     DoBeginSetAutoNotes();
                     break;
                 case "SetFreeNodes":
                     DoBeginSetFreeNotes();
                     break;
                 case "ScheduleRoute":
                     DoBeginSetSchedule();
                     break;
                 case "TaskpattermTree":
                     DoBeginTask();
                     break;
                 case "InfoFork":
                     LoadInfoFork();
                     break;
                 case "InfoNode":
                     LoadInfoNode();
                     break;
                 default:
                     break;
             }
         }
         private void DoBeginSetSchedule()
         {
             MyDesignerCanvas.SetScheduleRoute();
         }
         private void NewDoBeginSetFreeNotes()
         {
             MyDesignerCanvas.Init();
             MyDesignerCanvas.Operation = DesignerCanvas.OperationState.NewDrawSetFreeNode;
             MyDesignerCanvas.scheduleCanvas = MyScheduleCanvas;
         }
         private void LoadInfoFork()
         {
             DesignerCanvas.LoadDBFlag = true;
             MyDesignerCanvas.GetInfoFork();
         }
         private void LoadInfoNode()
         {
             DesignerCanvas.LoadDBFlag = true;
             MyDesignerCanvas.GetInfoNode();
         }
         private void btnMenu_UnselectedSet(object sender, RoutedEventArgs e)
         {
             if (((TreeViewItem)sender) == null)
             {
                 return;
             }
             string tag = ((TreeViewItem)sender).Tag.ToString();
             switch (tag)
             {
                 case "InfoFork":
                     DesignerCanvas.LoadDBFlag = false;
                     break;
                 case "InfoNode":
                     DesignerCanvas.LoadDBFlag = false;
                     break;
                 default:
                     break;
             }
         }
         private void DoBeginTask()
         {
-            //MyScheduleCanvas.CreateSimulation(MyDesignerCanvas.ucScheduleNode_Lst, MyDesignerCanvas.ProjectModel.ProjectModelList[MyDesignerCanvas.ProjectIndex], MyDesignerCanvas.VehicleIndex);
+            MyScheduleCanvas.CreateSimulation(MyDesignerCanvas.ucScheduleNode_Lst, MyDesignerCanvas.ProjectModel.ProjectModelList[MyDesignerCanvas.ProjectIndex], MyDesignerCanvas.VehicleIndex);
-            MessageBoxResult result = MessageBox.Show("Do you want upload data?", "Upload data", MessageBoxButton.OKCancel);
-            if (result == MessageBoxResult.OK)
-            {
-                MyDesignerCanvas.UploadData();
-                MyDesignerCanvas.GetInfoNode();
-            }
         }
         private void DoBeginSetAutoNotes()
         {
             MyDesignerCanvas.SetAutoNodes();
         }
         private void DoBeginSetFreeNotes()
         {
             MyDesignerCanvas.Init();
             MyDesignerCanvas.Operation = DesignerCanvas.OperationState.DrawSetFreeNode;
         }
         private void DoBeginSetupRestriction()
         {
             MyDesignerCanvas.Init();
             MyDesignerCanvas.Operation = DesignerCanvas.OperationState.DrawObstract;
             MyDesignerCanvas.mouseState = DesignerCanvas.MouseState.None;
         }
         private void DoBeginSetStart()
         {
             MyDesignerCanvas.CreateStartPoint();
         }
         private void DoBeginSetGoal()
         {
             MyDesignerCanvas.CreateGoalPoint();
         }
         private void DoBeginSetupRoute()
         {
             MyDesignerCanvas.Operation = DesignerCanvas.OperationState.DrawRoute;
         }
         private void DoBeginMakeRoot()
         {
             MyDesignerCanvas.Children.Remove(MyDesignerCanvas.pRootLine);
             MyDesignerCanvas.MakeRoot();
         }
         private void DoBeginDeleteRoute()
         {
             MessageBoxResult result = MessageBox.Show("Do you want delete route?", "Delete route", MessageBoxButton.OKCancel);
             if (result == MessageBoxResult.OK)
             {
                 MyDesignerCanvas.ClearRoute();
             }
         }
         private void GetPassplanTree(object sender, RoutedEventArgs e)
         {
             MessageBoxResult result = MessageBox.Show("Selected PassplanTree", "", MessageBoxButton.OKCancel);
         }
         private void SetPassplanTree(object sender, RoutedEventArgs e)
         {
         }
         private void GetNodeTree(object sender, RoutedEventArgs e)
         {
             MessageBoxResult result = MessageBox.Show("Selected NodeTree", "", MessageBoxButton.OKCancel);
         }
         private void SetNodeTree(object sender, RoutedEventArgs e)
         {
         }
         private void GetFK15Tree(object sender, RoutedEventArgs e)
         {
             MessageBoxResult result = MessageBox.Show("Selected FK15Tree", "", MessageBoxButton.OKCancel);
         }
         private void SetFK15Tree(object sender, RoutedEventArgs e)
         {
         }
         private void GetVehicleAddTree(object sender, RoutedEventArgs e)
         {
             MessageBoxResult result = MessageBox.Show("Selected VehicleAddTree", "", MessageBoxButton.OKCancel);
         }
         #region Add new Vehicle Item
         private void btnVehicleItem_Selected(object sender, RoutedEventArgs e)
         {
             if (((TreeViewItem)sender) == null)
             {
                 return;
             }
             string _VehicleName = ((TreeViewItem)sender).Name.ToString();
             string _VehicleTag = ((TreeViewItem)sender).Tag.ToString();
             string _VehicleHeader = ((TreeViewItem)sender).Header.ToString();
             string _ProjectName = "ProjectAAA";
             //get Parent Tree item
             TreeViewItem _VehicleItem = Vehicle;
             TreeViewItem item = e.OriginalSource as TreeViewItem;
             if (item != null)
             {
                 ItemsControl parent = cm.GetSelectedTreeViewItemParent(item);
                 _VehicleItem = parent as TreeViewItem;
             }
             //get Project item
             TreeViewItem _ProjectItem = Vehicle;
             if (_VehicleItem != null)
             {
                 ItemsControl parent = cm.GetSelectedTreeViewItemParent(_VehicleItem);
                 _ProjectItem = parent as TreeViewItem;
                 _ProjectName = _ProjectItem.Name.ToString();
             }
             switch (_VehicleTag)
             {
                 case "VehicleAddTree":
                     AddNewVehicleItem(_VehicleItem);
                     break;
                 case "VehicleItem":
                     GetDataVehicle(_ProjectName, _VehicleName, _VehicleHeader);
                     break;
                 default:
                     break;
             }
         }
         private void AddNewVehicleItem(TreeViewItem treeitem)
         {
             IndexVehicle += 1;
             treeitem.Items.RemoveAt(treeitem.Items.Count - 1);
             treeitem.Items.RemoveAt(treeitem.Items.Count - 1);
             TreeViewItem item = new TreeViewItem();
             item.Header = "FK"+ IndexVehicle.ToString()+"_#1";
             item.Tag = "VehicleItem";
             item.FontSize = 13;
             item.Selected += new RoutedEventHandler(btnVehicleItem_Selected);
             //item.IsSelected = true;
             item.IsExpanded = true;
             item.Name = "FK_" + IndexVehicle.ToString();
             treeitem.Items.Add(item);
             TreeViewItem item2 = new TreeViewItem();
             item2.Header = "[+]";
             item2.Tag = "VehicleAddTree";
             item2.FontSize = 13;
             item2.Selected += new RoutedEventHandler(btnVehicleItem_Selected);
             item2.Name = "VehicleAdd";
             treeitem.Items.Add(item2);
             TreeViewItem item3 = new TreeViewItem();
             item3.Header = "--------------------";
             item3.FontSize = 13;
             item3.Name = "UnderLine";
             treeitem.Items.Add(item3);
         }
         private void GetDataVehicle(string ProjectItem, string VehicleItem, String VehicleHeader)
         {
             if (VehicleItem == "FK_15")
             {
                 DisplayMap_1();
             }
             else
             {
                 DisplayMap_2();
             }
             MyDesignerCanvas.ProjectItem = ProjectItem;
             MyDesignerCanvas.VehicleItem = VehicleItem;
             MyDesignerCanvas.GetdataVehicle();
             LabelSchedule.Content = VehicleHeader;
             WorkVehicle.Content = "Work [" + VehicleHeader + "]";
             TaskpattermTree.Header = "Task patterm [" + VehicleHeader + "]";
         }
         #endregion
         #region Project Item
         private void btnProjectItem_Selected(object sender, RoutedEventArgs e)
         {
             if (((TreeViewItem)sender) == null)
             {
                 return;
             }
             string name = ((TreeViewItem)sender).Name.ToString();
             string tag = ((TreeViewItem)sender).Tag.ToString();
             string header = ((TreeViewItem)sender).Header.ToString();
             switch (tag)
             {
                 case "ProjectAddTree":
                     AddNewProjectItem();
                     break;
                 case "ProjectItem":
                     //GetDataProject(name, header);
                     break;
                 default:
                     break;
             }
         }
         private void AddNewProjectItem()
         {
             IndexProject += 1;
             ProjectTreeView.Items.RemoveAt(ProjectTreeView.Items.Count - 1);
             //Root Project
             TreeViewItem itemProject = new TreeViewItem();
             itemProject.Header = "Project[" + IndexProject + "工場]";
             itemProject.FontSize = 13;
             itemProject.Selected += new RoutedEventHandler(btnProjectItem_Selected);
             //itemProject.Name = "Project";
             itemProject.Name = "Project" + IndexProject;
             itemProject.Tag = "ProjectItem";
             itemProject.IsExpanded = true;
             ProjectTreeView.Items.Add(itemProject);
             //Tree Map
             TreeViewItem itemMap = new TreeViewItem();
             itemMap.Header = "Map";
             itemMap.FontSize = 13;
             itemMap.Name = "Map";
             itemProject.Items.Add(itemMap);
             TreeViewItem itemRestrict = new TreeViewItem();
             itemRestrict.Header = "Setup Restriction";
             itemRestrict.FontSize = 13;
             itemRestrict.Selected += new RoutedEventHandler(btnMenu_Selected);
             itemRestrict.Name = "SetupRestriction";
             itemRestrict.Tag = "SetupRestriction";
             itemMap.Items.Add(itemRestrict);
             TreeViewItem itemNode = new TreeViewItem();
             itemNode.Header = "Node";
             itemNode.FontSize = 13;
             itemNode.Selected += new RoutedEventHandler(btnMenu_Selected);
             itemNode.Name = "NodeTree";
             itemNode.Tag = "NodeTree";
             itemMap.Items.Add(itemNode);
             TreeViewItem itemDivision = new TreeViewItem();
             itemDivision.Header = "--------------------";
             itemDivision.FontSize = 13;
             itemMap.Items.Add(itemDivision);
             //Tree Vehicle
             TreeViewItem itemVehicle = new TreeViewItem();
             itemVehicle.Header = "Vehicle";
             itemVehicle.FontSize = 13;
             itemVehicle.Name = "Vehicle" + IndexProject.ToString();
             itemProject.Items.Add(itemVehicle);
             IndexVehicle += 1;
             TreeViewItem itemVehicleBr = new TreeViewItem();
             itemVehicleBr.Header = "FK"+ IndexVehicle.ToString()+"_#1";
             itemVehicleBr.Tag = "VehicleItem";
             itemVehicleBr.FontSize = 13;
             itemVehicleBr.Selected += new RoutedEventHandler(btnVehicleItem_Selected);
             itemVehicleBr.IsExpanded = true;
             itemVehicleBr.Name = "FK_" + IndexVehicle.ToString();
             itemVehicle.Items.Add(itemVehicleBr);
             itemVehicleBr = new TreeViewItem();
             itemVehicleBr.Header = "[+]";
             itemVehicleBr.Tag = "VehicleAddTree";
             itemVehicleBr.FontSize = 13;
             itemVehicleBr.Selected += new RoutedEventHandler(btnVehicleItem_Selected);
             itemVehicleBr.Name = "VehicleAdd";
             itemVehicle.Items.Add(itemVehicleBr);
             itemVehicleBr = new TreeViewItem();
             itemVehicleBr.Header = "--------------------";
             itemVehicleBr.FontSize = 13;
             itemVehicleBr.Name = "UnderLine";
             itemVehicle.Items.Add(itemVehicleBr);
             //Tree Work
             TreeViewItem itemWork = new TreeViewItem();
             itemWork.Header = "Work";
             itemWork.FontSize = 13;
             itemProject.Items.Add(itemWork);
             TreeViewItem itemWorkChild = new TreeViewItem();
             itemWorkChild.Header = "Task patterm [FK15_#1]";
             itemWorkChild.FontSize = 13;
             itemWorkChild.Name = "TaskpattermTree";
             itemWorkChild.Tag = "TaskpattermTree";
             itemWorkChild.Selected += new RoutedEventHandler(btnMenu_Selected);
             itemWorkChild.IsExpanded = true;
             itemWork.Items.Add(itemWorkChild);
             itemWorkChild = new TreeViewItem();
             itemWorkChild.Header = "[+]";
             itemWorkChild.FontSize = 13;
             itemWorkChild.Selected += new RoutedEventHandler(btnMenu_UnselectedSet);
             itemWorkChild.Name = "WorkAddTree";
             itemWork.Items.Add(itemWorkChild);
             itemWorkChild = new TreeViewItem();
             itemWorkChild.Header = "--------------------";
             itemWorkChild.FontSize = 13;
             itemWork.Items.Add(itemWorkChild);
             //Tree Setting
             TreeViewItem itemSetting = new TreeViewItem();
             itemSetting.Header = "Setting";
             itemSetting.FontSize = 13;
             itemProject.Items.Add(itemSetting);
             TreeViewItem itemSettingChild = new TreeViewItem();
             itemSettingChild.Header = "Connect [Wi-Fi]";
             itemSettingChild.FontSize = 13;
             itemSettingChild.Name = "ConnectTree";
             itemSettingChild.Selected += new RoutedEventHandler(btnMenu_UnselectedSet);
             itemSettingChild.IsExpanded = true;
             itemSetting.Items.Add(itemSettingChild);
             itemSettingChild = new TreeViewItem();
             itemSettingChild.Header = "Parameter";
             itemSettingChild.FontSize = 13;
             itemSettingChild.Selected += new RoutedEventHandler(btnMenu_UnselectedSet);
             itemSettingChild.Name = "ParameterTree";
             itemSetting.Items.Add(itemSettingChild);
             itemSettingChild = new TreeViewItem();
             itemSettingChild.Header = "--------------------";
             itemSettingChild.FontSize = 13;
             itemSetting.Items.Add(itemSettingChild);
             //Tree Logging
             TreeViewItem itemLog = new TreeViewItem();
             itemLog.Header = "Logging";
             itemLog.Name = "LoggingTree";
             itemLog.Selected += new RoutedEventHandler(btnMenu_UnselectedSet);
             itemLog.FontSize = 13;
             itemProject.Items.Add(itemLog);
             //Tree --------------------
             //Tree Logging
             TreeViewItem itemDash = new TreeViewItem();
             itemDash.Header = "--------------------";
             itemDash.FontSize = 13;
             itemProject.Items.Add(itemDash);
             ////Root Alert
             //TreeViewItem itemAlert = new TreeViewItem();
             //itemAlert.Header = "Alert";
             //itemAlert.FontSize = 13;
             //itemAlert.Selected += new RoutedEventHandler(GetAlertTree);
             //itemAlert.Name = "AlertTree";
             //ProjectTreeView.Items.Add(itemAlert);
             ////Root Help
             //TreeViewItem itemHelp = new TreeViewItem();
             //itemHelp.Header = "Help";
             //itemHelp.FontSize = 13;
             //itemHelp.Selected += new RoutedEventHandler(GetHelpTree);
             //itemHelp.Name = "HelpTree";
             //ProjectTreeView.Items.Add(itemHelp);
             //Root New Project
             TreeViewItem itemNewProject = new TreeViewItem();
             itemNewProject.Header = "[+New Project]";
             itemNewProject.FontSize = 13;
             itemNewProject.Selected += new RoutedEventHandler(btnProjectItem_Selected);
             itemNewProject.Name = "NewProjectTree";
             itemNewProject.Tag = "ProjectAddTree";
             ProjectTreeView.Items.Add(itemNewProject);
             MyDesignerCanvas.ProjectItem = itemProject.Name;
             MyDesignerCanvas.ProjectIndex++;
             MyDesignerCanvas.AddNewProjectItem();
         }
         #endregion