MVP_Model.cs 28 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708
  1. using System;
  2. using System.Collections.Generic;
  3. using System.Windows;
  4. using System.Linq;
  5. using System.Text;
  6. using System.Threading.Tasks;
  7. using System.Windows.Controls;
  8. using System.Windows.Media;
  9. using System.Windows.Media.Imaging;
  10. using OptiTrack;
  11. using System.Runtime.InteropServices;
  12. using System.IO;
  13. namespace SketchAssistantWPF
  14. {
  15. public class MVP_Model
  16. {
  17. /// <summary>
  18. /// The Presenter of the MVP-Model.
  19. /// </summary>
  20. MVP_Presenter programPresenter;
  21. /// <summary>
  22. /// History of Actions
  23. /// </summary>
  24. ActionHistory historyOfActions;
  25. /// <summary>
  26. /// The assistant responsible for the redraw mode
  27. /// </summary>
  28. OptiTrackConnector connector;
  29. /***********************/
  30. /*** CLASS VARIABLES ***/
  31. /***********************/
  32. /// <summary>
  33. /// If the program is in drawing mode.
  34. /// </summary>
  35. public bool inDrawingMode { get; private set; }
  36. /// <summary>
  37. /// if the program is using OptiTrack
  38. /// </summary>
  39. public bool optiTrackInUse { get; private set; }
  40. /// <summary>
  41. /// Size of deletion area
  42. /// </summary>
  43. int deletionRadius = 5;
  44. /// <summary>
  45. /// The Position of the Cursor in the right picture box
  46. /// </summary>
  47. Point currentCursorPosition;
  48. /// <summary>
  49. /// The Previous Cursor Position in the right picture box
  50. /// </summary>
  51. Point previousCursorPosition;
  52. /// <summary>
  53. /// Queue for the cursorPositions
  54. /// </summary>
  55. Queue<Point> cursorPositions = new Queue<Point>();
  56. /// <summary>
  57. /// The Position of the Cursor of opti track
  58. /// </summary>
  59. Point currentOptiCursorPosition;
  60. /// <summary>
  61. /// The Previous Cursor Position of opti track
  62. /// </summary>
  63. Point previousOptiCursorPosition;
  64. /// <summary>
  65. /// Queue for the cursorPositions of opti track
  66. /// </summary>
  67. Queue<Point> optiCursorPositions = new Queue<Point>();
  68. /// <summary>
  69. /// Lookup Matrix for checking postions of lines in the image
  70. /// </summary>
  71. bool[,] isFilledMatrix;
  72. /// <summary>
  73. /// Lookup Matrix for getting line ids at a certain postions of the image
  74. /// </summary>
  75. HashSet<int>[,] linesMatrix;
  76. /// <summary>
  77. /// Width of the LeftImageBox.
  78. /// </summary>
  79. public int leftImageBoxWidth;
  80. /// <summary>
  81. /// Height of the LeftImageBox.
  82. /// </summary>
  83. public int leftImageBoxHeight;
  84. /// <summary>
  85. /// Width of the RightImageBox.
  86. /// </summary>
  87. public int rightImageBoxWidth;
  88. /// <summary>
  89. /// Height of the RightImageBox.
  90. /// </summary>
  91. public int rightImageBoxHeight;
  92. public ImageDimension leftImageSize { get; private set; }
  93. public ImageDimension rightImageSize { get; private set; }
  94. /// <summary>
  95. /// Indicates whether or not the canvas on the right side is active.
  96. /// </summary>
  97. public bool canvasActive { get; set; }
  98. /// <summary>
  99. /// Indicates if there is a graphic loaded in the left canvas.
  100. /// </summary>
  101. public bool graphicLoaded { get; set; }
  102. /// <summary>
  103. /// Whether or not an optitrack system is avaiable.
  104. /// </summary>
  105. public bool optitrackAvailable { get; private set; }
  106. /// <summary>
  107. /// x coordinate in real world. one unit is one meter. If standing in front of video wall facing it, moving left results in incrementation of x.
  108. /// </summary>
  109. public float optiTrackX;
  110. /// <summary>
  111. /// y coordinate in real world. one unit is one meter. If standing in front of video wall, moving up results in incrementation of y.
  112. /// </summary>
  113. public float optiTrackY;
  114. /// <summary>
  115. /// z coordinate in real world. one unit is one meter. If standing in front of video wall, moving back results in incrementation of y.
  116. /// </summary>
  117. public float optiTrackZ;
  118. /// <summary>
  119. /// keeps track of whether last tick the trackable was inside drawing zone or not.
  120. /// </summary>
  121. private bool optiTrackInsideDrawingZone = false;
  122. /// <summary>
  123. /// this is a variable used for detecting whether the tracker is in the warning zone (0 +- variable), no drawing zone (0 +- 2 * variable) or normal drawing zone
  124. /// </summary>
  125. private double WARNING_ZONE_BOUNDARY = 0.10; //10cm
  126. /// <summary>
  127. /// object of class Armband used for controlling the vibrotactil armband
  128. /// </summary>
  129. private Armband armband;
  130. /// <summary>
  131. /// deactivates all Console.WriteLine() when set to false
  132. /// </summary>
  133. bool testing = false;//TODO: remove after finishing userstory
  134. /// <summary>
  135. /// Is set to true when the trackable has passed to the backside of the drawing surface,
  136. /// invalidating all inputs on its way back.
  137. /// </summary>
  138. bool OptiMovingBack = false;
  139. /// <summary>
  140. /// The Layer in which the optitrack system was. 0 is drawing layer, -1 is in front, 1 is behind
  141. /// </summary>
  142. int OptiLayer = 0;
  143. /// <summary>
  144. /// Whether or not the mouse is pressed.
  145. /// </summary>
  146. private bool mouseDown;
  147. List<InternalLine> leftLineList;
  148. List<Tuple<bool, InternalLine>> rightLineList;
  149. List<Point> currentLine = new List<Point>();
  150. public MVP_Model(MVP_Presenter presenter)
  151. {
  152. programPresenter = presenter;
  153. historyOfActions = new ActionHistory();
  154. //redrawAss = new RedrawAssistant();
  155. //overlayItems = new List<Tuple<bool, HashSet<Point>>>();
  156. rightLineList = new List<Tuple<bool, InternalLine>>();
  157. canvasActive = false;
  158. UpdateUI();
  159. rightImageSize = new ImageDimension(0, 0);
  160. leftImageSize = new ImageDimension(0, 0);
  161. connector = new OptiTrackConnector();
  162. armband = new Armband();
  163. optitrackAvailable = false;
  164. if (File.Exists(@"C:\Users\videowall-pc-user\Documents\BP-SketchAssistant\SketchAssistant\optitrack_setup.ttp"))
  165. {
  166. if (connector.Init(@"C:\Users\videowall-pc-user\Documents\BP-SketchAssistant\SketchAssistant\optitrack_setup.ttp"))
  167. {
  168. optitrackAvailable = true;
  169. connector.StartTracking(getOptiTrackPosition);
  170. }
  171. }
  172. }
  173. [DllImport("user32.dll", EntryPoint = "SetCursorPos")]
  174. private static extern bool SetCursorPos(int X, int Y);
  175. //[DllImport("user32.dll")]
  176. //public static extern void mouse_event(int dwFlags, int dx, int dy, int cButtons, int dwExtraInfo);
  177. public enum MouseEventType : int
  178. {
  179. LeftDown = 0x02,
  180. LeftUp = 0x04,
  181. RightDown = 0x08,
  182. RightUp = 0x10
  183. }
  184. /**************************/
  185. /*** INTERNAL FUNCTIONS ***/
  186. /**************************/
  187. /// <summary>
  188. /// Change the status of whether or not the lines are shown.
  189. /// </summary>
  190. /// <param name="lines">The HashSet containing the affected Line IDs.</param>
  191. /// <param name="shown">True if the lines should be shown, false if they should be hidden.</param>
  192. private void ChangeLines(HashSet<int> lines, bool shown)
  193. {
  194. foreach (int lineId in lines)
  195. {
  196. if (lineId <= rightLineList.Count - 1 && lineId >= 0)
  197. {
  198. rightLineList[lineId] = new Tuple<bool, InternalLine>(shown, rightLineList[lineId].Item2);
  199. }
  200. }
  201. }
  202. /// <summary>
  203. /// A function that populates the matrixes needed for deletion detection with line data.
  204. /// </summary>
  205. private void RepopulateDeletionMatrixes()
  206. {
  207. if (canvasActive)
  208. {
  209. isFilledMatrix = new bool[rightImageSize.Width, rightImageSize.Height];
  210. linesMatrix = new HashSet<int>[rightImageSize.Width, rightImageSize.Height];
  211. foreach (Tuple<bool, InternalLine> lineTuple in rightLineList)
  212. {
  213. if (lineTuple.Item1)
  214. {
  215. lineTuple.Item2.PopulateMatrixes(isFilledMatrix, linesMatrix);
  216. }
  217. }
  218. }
  219. }
  220. /// <summary>
  221. /// Tells the Presenter to Update the UI
  222. /// </summary>
  223. private void UpdateUI()
  224. {
  225. programPresenter.UpdateUIState(inDrawingMode, historyOfActions.CanUndo(), historyOfActions.CanRedo(), canvasActive, graphicLoaded, optitrackAvailable, optiTrackInUse);
  226. }
  227. /// <summary>
  228. /// A function that checks the deletion matrixes at a certain point
  229. /// and returns all Line ids at that point and in a square around it in a certain range.
  230. /// </summary>
  231. /// <param name="p">The point around which to check.</param>
  232. /// <param name="range">The range around the point. If range is 0, only the point is checked.</param>
  233. /// <returns>A List of all lines.</returns>
  234. private HashSet<int> CheckDeletionMatrixesAroundPoint(Point p, int range)
  235. {
  236. HashSet<int> returnSet = new HashSet<int>();
  237. foreach (Point pnt in GeometryCalculator.FilledCircleAlgorithm(p, (int)range))
  238. {
  239. if (pnt.X >= 0 && pnt.Y >= 0 && pnt.X < rightImageSize.Width && pnt.Y < rightImageSize.Height)
  240. {
  241. if (isFilledMatrix[(int)pnt.X, (int)pnt.Y])
  242. {
  243. returnSet.UnionWith(linesMatrix[(int)pnt.X, (int)pnt.Y]);
  244. }
  245. }
  246. }
  247. return returnSet;
  248. }
  249. //TODO: calibrate
  250. double OPTITRACK_X_OFFSET = -0.4854;
  251. double OPTITRACK_Y_OFFSET = 0.9;
  252. double OPTITRACK_CANVAS_HEIGHT = 1.2;
  253. double OPTITRACK_X_SCALE = 0.21 * (((1.8316/*size of canvis*/ / 0.0254) * 96) / (1.8316));
  254. double OPTITRACK_Y_SCALE = 0.205 * (((1.2 / 0.0254) * 96) / (1.2));
  255. /// <summary>
  256. /// converts given point to device-independent pixel
  257. /// </summary>
  258. /// <param name="p">real world coordinate</param>
  259. /// <returns>The given Point converted to device-independent pixel </returns>
  260. private Point ConvertTo96thsOfInch(Point p)
  261. {
  262. double xCoordinate = (p.X - OPTITRACK_X_OFFSET) * OPTITRACK_X_SCALE;
  263. double yCoordinate = (OPTITRACK_CANVAS_HEIGHT - (p.Y - OPTITRACK_Y_OFFSET)) * OPTITRACK_Y_SCALE;
  264. return new Point(xCoordinate, yCoordinate);
  265. }
  266. /// <summary>
  267. /// converts given point to pixel, calibrated for video wall in a08
  268. /// </summary>
  269. /// <param name="p"></param>
  270. /// <returns></returns>
  271. private Point ConvertToPixel(Point p)
  272. {//TODO: realize comments
  273. double xCoordinate = (p.X - OPTITRACK_X_OFFSET) * -1 * (/*Anzahl Pixel X-Richtung*/0 / (1.816)) + 0/*1/2 * x-richtung pixel*/; //TODO
  274. double yCoordinate = (((OPTITRACK_CANVAS_HEIGHT + 0/*meter von oberer Rand Leinwand zu oberer Rand Bildschirm*/) - (p.Y - OPTITRACK_Y_OFFSET))) * (/*Anzahl Pixel Y-Richtung*/0 / (1.360));
  275. return new Point(xCoordinate, yCoordinate);
  276. }
  277. /// <summary>
  278. /// Updates the Optitrack coordiantes, aswell as the marker for optitrack.
  279. /// </summary>
  280. /// <param name="p">The new cursor position</param>
  281. public void SetCurrentFingerPosition(Point p)
  282. {
  283. Point correctedPoint = ConvertTo96thsOfInch(p);
  284. if (testing)
  285. {
  286. Console.WriteLine("raw coordinates: " + p.X + ";" + p.Y);
  287. Console.WriteLine(correctedPoint.X + "," + correctedPoint.Y);
  288. }
  289. if (optiTrackZ < -2.2 * WARNING_ZONE_BOUNDARY && OptiLayer > -1)
  290. {
  291. OptiLayer = -1; OptiMovingBack = false;
  292. programPresenter.SetOverlayColor("optipoint", Brushes.Yellow);
  293. }
  294. else if (optiTrackZ > 2 * WARNING_ZONE_BOUNDARY && OptiLayer < 1)
  295. {
  296. programPresenter.SetOverlayColor("optipoint", Brushes.Red);
  297. OptiLayer = 1;
  298. }
  299. else if(optiTrackZ <= 2 * WARNING_ZONE_BOUNDARY && optiTrackZ >= -2.2 * WARNING_ZONE_BOUNDARY){
  300. if(OptiLayer > 0)
  301. OptiMovingBack = true;
  302. programPresenter.SetOverlayColor("optipoint", Brushes.Green);
  303. OptiLayer = 0;
  304. }
  305. currentOptiCursorPosition = correctedPoint;
  306. programPresenter.MoveOptiPoint(currentOptiCursorPosition);
  307. if (optiCursorPositions.Count > 0) { previousOptiCursorPosition = optiCursorPositions.Dequeue(); }
  308. else { previousOptiCursorPosition = currentOptiCursorPosition; }
  309. }
  310. /********************************************/
  311. /*** FUNCTIONS TO INTERACT WITH PRESENTER ***/
  312. /********************************************/
  313. /// <summary>
  314. /// A function to update the dimensions of the left and right canvas when the window is resized.
  315. /// </summary>
  316. /// <param name="LeftCanvas">The size of the left canvas.</param>
  317. /// <param name="RightCanvas">The size of the right canvas.</param>
  318. public void ResizeEvent(ImageDimension LeftCanvas, ImageDimension RightCanvas)
  319. {
  320. if (LeftCanvas.Height >= 0 && LeftCanvas.Width >= 0) { leftImageSize = LeftCanvas; }
  321. if (RightCanvas.Height >= 0 && RightCanvas.Width >= 0) { rightImageSize = RightCanvas; }
  322. RepopulateDeletionMatrixes();
  323. }
  324. /// <summary>
  325. /// A function to reset the right image.
  326. /// </summary>
  327. public void ResetRightImage()
  328. {
  329. if(currentLine.Count > 0)
  330. FinishCurrentLine(true);
  331. rightLineList.Clear();
  332. programPresenter.PassLastActionTaken(historyOfActions.Reset());
  333. programPresenter.ClearRightLines();
  334. }
  335. /// <summary>
  336. /// The function to set the left image.
  337. /// </summary>
  338. /// <param name="width">The width of the left image.</param>
  339. /// <param name="height">The height of the left image.</param>
  340. /// <param name="listOfLines">The List of Lines to be displayed in the left image.</param>
  341. public void SetLeftLineList(int width, int height, List<InternalLine> listOfLines)
  342. {
  343. leftImageSize = new ImageDimension(width, height);
  344. rightImageSize = new ImageDimension(width, height);
  345. leftLineList = listOfLines;
  346. graphicLoaded = true;
  347. programPresenter.UpdateLeftLines(leftLineList);
  348. CanvasActivated();
  349. }
  350. /// <summary>
  351. /// A function to tell the model a new canvas was activated.
  352. /// </summary>
  353. public void CanvasActivated()
  354. {
  355. canvasActive = true;
  356. RepopulateDeletionMatrixes();
  357. UpdateUI();
  358. }
  359. /// <summary>
  360. /// Will undo the last action taken, if the action history allows it.
  361. /// </summary>
  362. public void Undo()
  363. {
  364. if (historyOfActions.CanUndo())
  365. {
  366. HashSet<int> affectedLines = historyOfActions.GetCurrentAction().GetLineIDs();
  367. SketchAction.ActionType undoAction = historyOfActions.GetCurrentAction().GetActionType();
  368. switch (undoAction)
  369. {
  370. case SketchAction.ActionType.Delete:
  371. //Deleted Lines need to be shown
  372. ChangeLines(affectedLines, true);
  373. break;
  374. case SketchAction.ActionType.Draw:
  375. //Drawn lines need to be hidden
  376. ChangeLines(affectedLines, false);
  377. break;
  378. default:
  379. break;
  380. }
  381. programPresenter.UpdateRightLines(rightLineList);
  382. }
  383. RepopulateDeletionMatrixes();
  384. programPresenter.PassLastActionTaken(historyOfActions.MoveAction(true));
  385. UpdateUI();
  386. }
  387. /// <summary>
  388. /// Will redo the last action undone, if the action history allows it.
  389. /// </summary>
  390. public void Redo()
  391. {
  392. if (historyOfActions.CanRedo())
  393. {
  394. programPresenter.PassLastActionTaken(historyOfActions.MoveAction(false));
  395. HashSet<int> affectedLines = historyOfActions.GetCurrentAction().GetLineIDs();
  396. SketchAction.ActionType redoAction = historyOfActions.GetCurrentAction().GetActionType();
  397. switch (redoAction)
  398. {
  399. case SketchAction.ActionType.Delete:
  400. //Deleted Lines need to be redeleted
  401. ChangeLines(affectedLines, false);
  402. break;
  403. case SketchAction.ActionType.Draw:
  404. //Drawn lines need to be redrawn
  405. ChangeLines(affectedLines, true);
  406. break;
  407. default:
  408. break;
  409. }
  410. //TODO: For the person implementing overlay: Add check if overlay needs to be added
  411. programPresenter.UpdateRightLines(rightLineList);
  412. RepopulateDeletionMatrixes();
  413. }
  414. UpdateUI();
  415. }
  416. /// <summary>
  417. /// The function called by the Presenter to change the drawing state of the program.
  418. /// </summary>
  419. /// <param name="nowDrawing">The new drawingstate of the program</param>
  420. public void ChangeState(bool nowDrawing)
  421. {
  422. if(inDrawingMode && !nowDrawing && currentLine.Count > 0)
  423. FinishCurrentLine(true);
  424. inDrawingMode = nowDrawing;
  425. UpdateUI();
  426. }
  427. /// <summary>
  428. /// The function called by the Presenter to set a variable which describes if OptiTrack is in use
  429. /// </summary>
  430. /// <param name="usingOptiTrack"></param>
  431. public void SetOptiTrack(bool usingOptiTrack)
  432. {
  433. optiTrackInUse = usingOptiTrack;
  434. if (usingOptiTrack && optiTrackX == 0 && optiTrackY == 0 && optiTrackZ == 0)
  435. {
  436. programPresenter.PassWarning("Trackable not detected, please check if OptiTrack is activated and Trackable is recognized");
  437. optiTrackInUse = false;
  438. //Disable optipoint
  439. programPresenter.SetOverlayStatus("optipoint", false, currentCursorPosition);
  440. Console.WriteLine("Point disabled");
  441. }
  442. else
  443. {
  444. Console.WriteLine("Point enabled: {0}",optiTrackInUse);
  445. //Enable optipoint
  446. programPresenter.SetOverlayStatus("optipoint", true, currentCursorPosition);
  447. }
  448. }
  449. /// <summary>
  450. /// Updates the current cursor position of the model.
  451. /// </summary>
  452. /// <param name="p">The new cursor position</param>
  453. public void SetCurrentCursorPosition(Point p)
  454. {
  455. if (!optiTrackInUse) currentCursorPosition = p;
  456. //Temporary position of the optipoint change, change this when merging with optitrack branch
  457. mouseDown = programPresenter.IsMousePressed();
  458. }
  459. /// <summary>
  460. /// Start a new Line, when the Mouse is pressed down.
  461. /// </summary>
  462. public void StartNewLine()
  463. {
  464. mouseDown = true;
  465. if (inDrawingMode)
  466. {
  467. if(optiTrackInUse)
  468. {
  469. currentLine.Clear();
  470. currentLine.Add(currentOptiCursorPosition);
  471. }
  472. else if (programPresenter.IsMousePressed())
  473. {
  474. currentLine.Clear();
  475. currentLine.Add(currentCursorPosition);
  476. }
  477. }
  478. }
  479. /// <summary>
  480. /// Finish the current Line, when the pressed Mouse is released.
  481. /// </summary>
  482. /// <param name="valid">Whether the up event is valid or not</param>
  483. public void FinishCurrentLine(bool valid)
  484. {
  485. if (testing)
  486. foreach (Point p in currentLine)
  487. Console.WriteLine(p.X + ";" + p.Y);
  488. mouseDown = false;
  489. if (valid)
  490. {
  491. if (inDrawingMode && currentLine.Count > 0)
  492. {
  493. InternalLine newLine = new InternalLine(currentLine, rightLineList.Count);
  494. rightLineList.Add(new Tuple<bool, InternalLine>(true, newLine));
  495. newLine.PopulateMatrixes(isFilledMatrix, linesMatrix);
  496. programPresenter.PassLastActionTaken(historyOfActions.AddNewAction(new SketchAction(SketchAction.ActionType.Draw, newLine.GetID())));
  497. //TODO: For the person implementing overlay: Add check if overlay needs to be added
  498. programPresenter.UpdateRightLines(rightLineList);
  499. currentLine.Clear();
  500. programPresenter.UpdateCurrentLine(currentLine);
  501. }
  502. }
  503. else
  504. {
  505. currentLine.Clear();
  506. }
  507. UpdateUI();
  508. }
  509. /// <summary>
  510. /// Finish the current Line, when the pressed Mouse is released.
  511. /// Overload that is used to pass a list of points to be used when one is available.
  512. /// </summary>
  513. /// <param name="p">The list of points</param>
  514. public void FinishCurrentLine(List<Point> p)
  515. {
  516. mouseDown = false;
  517. if (inDrawingMode && currentLine.Count > 0)
  518. {
  519. InternalLine newLine = new InternalLine(p, rightLineList.Count);
  520. rightLineList.Add(new Tuple<bool, InternalLine>(true, newLine));
  521. newLine.PopulateMatrixes(isFilledMatrix, linesMatrix);
  522. programPresenter.PassLastActionTaken(historyOfActions.AddNewAction(new SketchAction(SketchAction.ActionType.Draw, newLine.GetID())));
  523. programPresenter.UpdateRightLines(rightLineList);
  524. currentLine.Clear();
  525. }
  526. UpdateUI();
  527. }
  528. void getOptiTrackPosition(OptiTrack.Frame frame)
  529. {
  530. if (frame.Trackables.Length >= 1)
  531. {
  532. optiTrackX = frame.Trackables[0].X;
  533. optiTrackY = frame.Trackables[0].Y;
  534. optiTrackZ = frame.Trackables[0].Z;
  535. /*
  536. Console.WriteLine("X:" + optiTrackX);
  537. Console.WriteLine("Y:" + optiTrackY);
  538. Console.WriteLine("Z:" + optiTrackZ);
  539. */
  540. }
  541. }
  542. /// <summary>
  543. /// Method to be called every tick. Updates the current Line, or checks for Lines to delete, depending on the drawing mode.
  544. /// </summary>
  545. public void Tick()
  546. {
  547. if (cursorPositions.Count > 0) { previousCursorPosition = cursorPositions.Dequeue(); }
  548. else { previousCursorPosition = currentCursorPosition; }
  549. if(optitrackAvailable)
  550. SetCurrentFingerPosition(new Point(optiTrackX, optiTrackY));
  551. if (optiTrackInUse && inDrawingMode && !OptiMovingBack) // optitrack is being used
  552. {
  553. //outside of drawing zone
  554. if (!CheckInsideDrawingZone(optiTrackZ))
  555. {
  556. //Check if trackable was in drawing zone last tick & program is in drawing mode-> finish line
  557. if (optiTrackInsideDrawingZone && inDrawingMode)
  558. {
  559. optiTrackInsideDrawingZone = false;
  560. FinishCurrentLine(true);
  561. if (testing) Console.WriteLine("line finished");
  562. }
  563. }
  564. //Draw with optitrack, when in drawing zone
  565. if (CheckInsideDrawingZone(optiTrackZ))
  566. {
  567. //Optitrack wasn't in the drawing zone last tick -> start a new line
  568. if (!optiTrackInsideDrawingZone)
  569. {
  570. optiTrackInsideDrawingZone = true;
  571. StartNewLine();
  572. if (testing) Console.WriteLine("new line begun");
  573. }
  574. else currentLine.Add(currentOptiCursorPosition);
  575. programPresenter.UpdateCurrentLine(currentLine);
  576. if (optiTrackZ > WARNING_ZONE_BOUNDARY)
  577. {
  578. armband.pushForward();
  579. }
  580. else if (optiTrackZ < -1 * WARNING_ZONE_BOUNDARY)
  581. {
  582. armband.pushBackward();
  583. }
  584. }
  585. }
  586. else if( !optiTrackInUse && inDrawingMode)
  587. {
  588. //drawing without optitrack
  589. cursorPositions.Enqueue(currentCursorPosition);
  590. if (inDrawingMode && programPresenter.IsMousePressed())
  591. {
  592. currentLine.Add(currentCursorPosition);
  593. //programPresenter.UpdateCurrentLine(currentLine);
  594. }
  595. }
  596. //Deletion mode for optitrack and regular use
  597. if (!inDrawingMode)
  598. {
  599. List<Point> uncheckedPoints = new List<Point>();
  600. if (programPresenter.IsMousePressed() && !optiTrackInUse) //without optitrack
  601. uncheckedPoints = GeometryCalculator.BresenhamLineAlgorithm(previousCursorPosition, currentCursorPosition);
  602. if(optiTrackInUse && CheckInsideDrawingZone(optiTrackZ) && !OptiMovingBack)
  603. {//with optitrack
  604. uncheckedPoints = GeometryCalculator.BresenhamLineAlgorithm(previousOptiCursorPosition, currentOptiCursorPosition);
  605. }
  606. foreach (Point currPoint in uncheckedPoints)
  607. {
  608. HashSet<int> linesToDelete = CheckDeletionMatrixesAroundPoint(currPoint, deletionRadius);
  609. if (linesToDelete.Count > 0)
  610. {
  611. programPresenter.PassLastActionTaken(historyOfActions.AddNewAction(new SketchAction(SketchAction.ActionType.Delete, linesToDelete)));
  612. foreach (int lineID in linesToDelete)
  613. {
  614. rightLineList[lineID] = new Tuple<bool, InternalLine>(false, rightLineList[lineID].Item2);
  615. }
  616. RepopulateDeletionMatrixes();
  617. programPresenter.UpdateRightLines(rightLineList);
  618. }
  619. }
  620. }
  621. }
  622. /*
  623. private void projectPointOntoScreen(float optiTrackX, float optiTrackY)
  624. {
  625. Point auxiliaryPoint = ConvertToPixel(new Point(optiTrackX, optiTrackY));
  626. //SetCursorPos((int)auxiliaryPoint.X, (int)auxiliaryPoint.Y);
  627. }
  628. */
  629. private bool CheckInsideDrawingZone(float optiTrackZ)
  630. {
  631. if (Math.Abs(optiTrackZ) > WARNING_ZONE_BOUNDARY * 2) return false;
  632. return true;
  633. }
  634. /// <summary>
  635. /// If there is unsaved progress.
  636. /// </summary>
  637. /// <returns>True if there is progress that has not been saved.</returns>
  638. public bool HasUnsavedProgress()
  639. {
  640. return !historyOfActions.IsEmpty();
  641. }
  642. }
  643. }