Exemple #1
0
GEODE_UNUSED static void check_bsp(const TriangleTopology& mesh, RawArray<const Node> bsp, RawField<const Vector<int,2>,FaceId> face_to_bsp, RawField<const Perturbed2,VertexId> X_) {
  if (self_check) {
    cout << "bsp:\n";
    #define CHILD(c) format("%c%d",(c<0?'f':'n'),(c<0?~c:c))
    for (const int n : range(bsp.size()))
      cout << "  "<<n<<" : test "<<bsp[n].test<<", children "<<CHILD(bsp[n].children[0])<<" "<<CHILD(bsp[n].children[1])<<endl;
    cout << "tris = "<<mesh.elements()<<endl;
    cout << "X = "<<X_.flat<<endl;
  }
  for (const int n : range(bsp.size()))
    for (const int i : range(2))
      if (bsp[n].children[i]<0)
        GEODE_ASSERT(face_to_bsp[FaceId(~bsp[n].children[i])].contains(2*n+i));
  auto X = X_.copy();
  for (const auto f : mesh.faces()) {
    int i0,i1;
    face_to_bsp[f].get(i0,i1);
    if (bsp.size())
      GEODE_ASSERT(bsp[i0/2].children[i0&1]==~f.id);
    if (i1>=0)
      GEODE_ASSERT(bsp[i1/2].children[i1&1]==~f.id);
    const auto v = mesh.vertices(f);
    if (!is_sentinel(X[v.x]) && !is_sentinel(X[v.y]) && !is_sentinel(X[v.z])) {
      const auto center = X.append(Perturbed2(X.size(),(X[v.x].value()+X[v.y].value()+X[v.z].value())/3));
      const auto found = bsp_search(bsp,X,center);
      if (found!=f) {
        cout << "bsp search failed: f "<<f<<", v "<<v<<", found "<<found<<endl;
        GEODE_ASSERT(false);
      }
      X.flat.pop();
    }
  }
}
 bool equal(common_cursor<I2, S2> const &that) const
 {
     return is_sentinel() ?
         (that.is_sentinel() || that.it() == se()) :
         (that.is_sentinel() ?
             it() == that.se() :
             it() == that.it());
 }
Exemple #3
0
// Test whether an edge containing sentinels is Delaunay
GEODE_COLD GEODE_PURE static inline bool is_delaunay_sentinels(Perturbed2 x0, Perturbed2 x1, Perturbed2 x2, Perturbed2 x3) {
  // Unfortunately, the sentinels need to be at infinity for purposes of Delaunay testing, and our SOS predicates
  // don't support infinities.  Therefore, we need some case analysis.  First, we move all the sentinels to the end,
  // sorted in decreasing order of index.  Different sentinels will be placed at different orders of infinity,
  // with earlier indices further away, so our order will place larger infinities last.
  bool parity = 0;
  COMPARATOR(0,1)
  COMPARATOR(2,3)
  COMPARATOR(0,2)
  COMPARATOR(1,3)
  COMPARATOR(1,2)
  if (!is_sentinel(x2)) // One infinity: A finite circle contains infinity iff it is inside out, so we reduce to an orientation test
    return parity^triangle_oriented(x0,x1,x2);
  else if (!is_sentinel(x1)) // Two infinities: also an orientation test, but with the last point at infinity
    return parity^segment_to_direction_oriented(x0,x1,x2);
  else // Three infinities: the finite point no longer matters.
    return parity^directions_oriented(x1,x2);
}
Exemple #4
0
GEODE_COLD GEODE_PURE static inline bool triangle_oriented_sentinels(Perturbed2 x0, Perturbed2 x1, Perturbed2 x2) {
  // Move large sentinels last
  bool parity = 0;
  COMPARATOR(0,1)
  COMPARATOR(1,2)
  COMPARATOR(0,1)
  // Triangle orientation tests reduce to segment vs. direction and direction vs. direction when infinities are involved
  return parity ^ (!is_sentinel(x1) ? segment_to_direction_oriented(x0,x1,x2)   // one sentinel
                                    :           directions_oriented(   x1,x2)); // two or three sentinels
}
      void CacheStat::dump_stat(cache_stat* stats, int32_t count,
                                cache_stat* last_stats, cache_stat* total_stat,
                                const StatDumpFilter* filter, bool& should_dump)
      {
        cache_stat* pstat;

        for (int i = 0; i < count; ++i)
        {
          pstat = stats + i;

          if (is_sentinel(pstat)) // reach one stat record start
          {
            if (sentinel_valid(pstat))
            {
              should_dump = filter->ok(get_time(pstat));
            }
            else        // sentinel is invalid. it's the end of whole last stat.
            {
              memset(last_stats, 0, CACHE_STAT_SIZE * TAIR_MAX_AREA_COUNT);
              if (should_dump)
              {
                print_total_stat(total_stat);      // print last total stat
                total_stat->reset();
                fprintf(stderr, "\t============== ONE WHOLE STAT END ================\n");
              }
              should_dump = false;
            }

            if (should_dump)
            {
              print_total_stat(total_stat);      // print last total stat
              total_stat->reset();
              print_sentinel(pstat); // print sentinel
            }
          }
          else if (should_dump)
          {
            print_and_add_total_stat(pstat, last_stats, total_stat); // just print
          }
        }
      }
Exemple #6
0
 remaining_time remaining_milliseconds() const
 {
     if(is_sentinel())
     {
         return remaining_time(win32::infinite);
     }
     else if(relative)
     {
         unsigned long const now=win32::GetTickCount();
         unsigned long const elapsed=now-start;
         return remaining_time((elapsed<milliseconds)?(milliseconds-elapsed):0);
     }
     else
     {
         system_time const now=get_system_time();
         if(abs_time<=now)
         {
             return remaining_time(0);
         }
         return remaining_time((abs_time-now).total_milliseconds()+1);
     }
 }
 S const & se() const
 {
     RANGES_ASSERT(is_sentinel());
     return ranges::get<1>(data_);
 }
 I const & it() const
 {
     RANGES_ASSERT(!is_sentinel());
     return ranges::get<0>(data_);
 }