1. 20 Jul, 2020 1 commit
  2. 15 Jul, 2020 2 commits
  3. 14 Jul, 2020 1 commit
  4. 13 Jul, 2020 5 commits
    • Torbjørn Ludvigsen's avatar
      4ef2d983
    • Torbjørn Ludvigsen's avatar
      b87c1096
    • Torbjørn Ludvigsen's avatar
      If collision was found, writes linc.stl · 9466ff56
      Torbjørn Ludvigsen authored
      This model includes the "cone triangle" (representing the line)
      that collided, the printed model, cut at the right height,
      and a symbolic representation of the effector.
      
      It can be opened in any 3d viewer program to inspect details about
      the collision visually.
      9466ff56
    • Torbjørn Ludvigsen's avatar
      a6157f48
    • Torbjørn Ludvigsen's avatar
      Binary search through model's height · 96566d2a
      Torbjørn Ludvigsen authored
      Instead of starting at the model's top and working layer by layer
      downwards, we give each thread the responsibility of searching
      through a segment of the model's height.
      
      Each thread will start searching at the top of their segment.
      Then they will do binary search within their segment.
      That is:
      Each thread will check for collisions right at the middle of
      their segment, splitting the segment into two sub-segments.
      If they didn't find any collision, they will go on to
      check right at the middle of each sub-segment.
      And so on.
      
      This has several advantages, particularly for collision-detected runs:
       1. Any wide hotspots for collision will be encountered early,
          so collisions will be found quickly, even if the riskiest
          part of the print is not near its top layer. (But collision
          near top layer will still be found quickly.)
          Average speed increase is 5x for any model with a collision.
       2. The model will be searched in the same fashion regardless
          of the layerHeight that the user chooses.
          Therefore, the user doesn't have to worry about choosing
          an optimal layerHeight, the algorithm will find collisions
          quickly regardless.
       3. Long runs get less frustrating because user gets valuable
          information early.
          Likelyhood of finding a collision decreases as execution time
          increases. This lets users put a time limit on their analysis
          instead of a layer height limit. They will still get meaningful
          results, without having to specify a specific height segment,
          or layer height that they want analyzed, or anything like that.
      
      It also has one disadvantage, for the non-collision runs:
       1. The layerHeight input parameter has become less intuitive.
          It is now an upper limit instead
          of being the actual layer height that the algorithm uses.
          Execution time of non-collision runs used to vary linearly with layerHeight.
          Now it will double, or halve, at ceirtain threshold values that
          the user doesn't know about (unless willing to calculate by hand).
          However doubling layerHeight will still double execution time,
          and halving it will halve execution time, as intuitively expected.
      96566d2a
  5. 12 Jul, 2020 1 commit
  6. 11 Jul, 2020 1 commit
    • Torbjørn Ludvigsen's avatar
      Utilizes bounding planes to optimize · 3b8bfce1
      Torbjørn Ludvigsen authored
      Creates planes for each anchorPivot and layer, for which
      points below it can impossibly intersect with the that line during
      that layer. This reduces the number of calls to the
      intersect(Triangle, Triangle) function.
      
      Benchmark test runs with 3DBenchy_scale16.4.binary.stl reduces execution
      times from 22 min to 22 seconds, a 98.3% improvement.
      3b8bfce1
  7. 10 Jul, 2020 5 commits
  8. 08 Jul, 2020 2 commits
  9. 07 Jul, 2020 3 commits
  10. 06 Jul, 2020 2 commits
  11. 05 Jul, 2020 3 commits
    • Torbjørn Ludvigsen's avatar
      Fixes comment · 141fa229
      Torbjørn Ludvigsen authored
      141fa229
    • Torbjørn Ludvigsen's avatar
      Collision detection working on convex-layer shapes · c92ccf53
      Torbjørn Ludvigsen authored
      If all layers of a print have a convex shape, and sizes/dimensions are
      within reason, then the program should correctly detect collisions.
      The only tested configurations are those encoded in linc.test.c++.
      That is, with params from params-example, we correctly detect
      collision or no collision for the test models:
      
       - small-cube.binary.stl
       - cube-100.ascii.stl
       - cube-268.ascii.stl
       - cube-468.ascii.stl
       - cube-469.ascii.stl
       - cube-470.ascii.stl
       - cube-471.ascii.stl
      c92ccf53
    • Torbjørn Ludvigsen's avatar
      Starts triangle intersection detection · 422a54cd
      Torbjørn Ludvigsen authored
      A very small start at the method of separating axes
      422a54cd
  12. 03 Jul, 2020 2 commits
    • Torbjørn Ludvigsen's avatar
      Fixes truncation error in softClip · 8ae7a93d
      Torbjørn Ludvigsen authored
       - Also adds static function orderCounterClockWise in linc.c++
       - Also uncomments the willCollide algorithm in linc.c++
       - Also changes willCollide algorithm away from iteratively cutting
         down one single MeshClipper. Create new MeshClipper object before
         each clip instead. This saves us from clipping the edges that we
         ourselves added in the previous pass. Fixes an edge case where very
         tall triangles would be split into extremely small pieces.
         It generally carries less state, so it's better.
       - Also changes away from Eigen::Matrix class in Pivots class.
      8ae7a93d
    • Torbjørn Ludvigsen's avatar
      Fixes bug in binary stl read/write · 2ddba39d
      Torbjørn Ludvigsen authored
      2ddba39d
  13. 02 Jul, 2020 2 commits
  14. 01 Jul, 2020 3 commits
  15. 30 Jun, 2020 3 commits
  16. 29 Jun, 2020 1 commit
  17. 28 Jun, 2020 3 commits