diff --git a/Filtered_kernel/include/CGAL/internal/Static_filters/Do_intersect_3.h b/Filtered_kernel/include/CGAL/internal/Static_filters/Do_intersect_3.h
index 7e60d752c17..60236923265 100644
--- a/Filtered_kernel/include/CGAL/internal/Static_filters/Do_intersect_3.h
+++ b/Filtered_kernel/include/CGAL/internal/Static_filters/Do_intersect_3.h
@@ -130,179 +130,6 @@ public:
 
       if(is_indeterminate(ub)) return Base::operator()(s,b);
       else return ub.sup();
-
-      // -----------------------------------
-      // treat x coord
-      // -----------------------------------
-      double dmin, dmax, tmin, tmax;
-      if ( qx >= px )  // this is input and needs no epsilon
-      {
-        if(px > bxmax) return false; // segment on the right of bbox
-        if(qx < bxmin) return false; // segment on the left of bbox
-
-        tmax = bxmax - px;
-        
-        dmax = qx - px;
-        if ( bxmin < px ) // tmin < 0 means px is in the x-range of bbox
-        {
-          tmin = 0;
-          dmin = 1;
-        } else {
-          tmin = bxmin - px;
-          dmin = dmax;
-        }
-      }
-      else
-      {
-        if(qx > bxmax) return false; // segment on the right of bbox
-        if(px < bxmin) return false; // segment on the left of bbox
-
-        tmax = px - bxmin;
-
-        dmax = px - qx;
-        if ( px < bxmax ) // tmin < 0 means px is in the x-range of bbox
-        {
-          tmin = 0;
-          dmin = 1;
-        } else {
-          tmin = px - bxmax;
-          dmin = dmax;
-        }
-      }   
-
-      double m = CGAL::abs(tmin), m2;
-      m2 = CGAL::abs(tmax); if(m2 > m) { m = m2; }
-      m2 = CGAL::abs(dmin); if(m2 > m) { m = m2; }
-
-      if(m < 7e-294) {
-        // underflow in the computation of 'error'
-        return Base::operator()(s,b);
-      }
-
-      const double EPS_1 = 3.55618e-15;
-
-      double error =  EPS_1 * m;
-
-      switch(sign_with_error( tmax - dmax, error)) {
-      case POSITIVE:
-        tmax = 1;
-        dmax = 1;
-        break;
-      case NEGATIVE:
-        break;
-      default:
-        // ambiguity of the comparison tmax > dmin
-        // let's call the exact predicate
-        return Base::operator()(s,b);
-      }
-
-      // -----------------------------------
-      // treat y coord
-      // -----------------------------------
-      double d_, tmin_, tmax_;
-      if ( qy >= py )   // this is input and needs no epsilon
-      {
-        tmin_ = bymin - py;
-        tmax_ = bymax - py;
-        d_ = qy - py;
-      }
-      else
-      {
-        tmin_ = py - bymax;
-        tmax_ = py - bymin;
-        d_ = py - qy;
-      }
-    
-      m2 = CGAL::abs(tmin_); if(m2 > m) { m = m2; }
-      m2 = CGAL::abs(tmax_); if(m2 > m) { m = m2; }
-      m2 = CGAL::abs(d_); if(m2 > m) { m = m2; }
-
-      if(m < 3e-147) {
-        // underflow in the computation of 'error'
-        return Base::operator()(s,b);
-      }
-      
-      error =  EPS_1 * m * m;
-
-      if(m > 1e153) { /* sqrt(max_double [hadamard]/2) */ 
-        // potential overflow on the computation of 'sign1' and 'sign2'
-        return Base::operator()(s,b);
-      }
-      Sign sign1 = sign_with_error( (d_*tmin) - (dmin*tmax_) , error);
-      Sign sign2 = sign_with_error( (dmax*tmin_) - (d_*tmax) , error);
-
-      if(sign1 == POSITIVE || sign2 == POSITIVE) 
-        return false; // We are *sure* the segment is outside the box, on one
-                      // side or the other.
-      if(sign1 == ZERO || sign2 == ZERO) {
-        return Base::operator()(s,b); // We are *unsure*: one *may be*
-                                      // positive.
-      }
-
-      // Here we are sure the two signs are negative. We can continue with
-      // the rest of the function...
-
-      // epsilons needed
-      switch(sign_with_error((dmin*tmin_) - (d_*tmin) , error)) {
-      case POSITIVE:
-        tmin = tmin_;
-        dmin = d_;
-        break;
-      case NEGATIVE:
-        break;
-      default: // uncertainty
-        return Base::operator()(s,b);
-      }
-    
-      // epsilons needed
-      switch(sign_with_error((d_*tmax) - (dmax*tmax_) , error)) {
-      case POSITIVE:
-        tmax = tmax_;
-        dmax = d_;
-      case NEGATIVE:
-        break;
-      default: // uncertainty
-        return Base::operator()(s,b);
-      }
-    
-      // -----------------------------------
-      // treat z coord
-      // -----------------------------------
-      if ( qz >= pz )   // this is input and needs no epsilon
-      {
-        tmin_ = bzmin - pz;
-        tmax_ = bzmax - pz;
-        d_ = qz - pz;
-      }
-      else
-      {
-        tmin_ = pz - bzmax;
-        tmax_ = pz - bzmin;
-        d_ = pz - qz;
-      }
-    
-      m2 = CGAL::abs(tmin_); if(m2 > m) { m = m2; }
-      m2 = CGAL::abs(tmax_); if(m2 > m) { m = m2; }
-      m2 = CGAL::abs(d_); if(m2 > m) { m = m2; }
-
-      // m may have changed
-      error =  EPS_1 * m * m;
-    
-      if(m > 1e153) { /* sqrt(max_double [hadamard]/2) */ 
-        // potential overflow on the computation of 'sign1' and 'sign2'
-        return Base::operator()(s,b);
-      }
-      sign1 = sign_with_error( (dmin*tmax_) - (d_*tmin) , error);
-      sign2 = sign_with_error( (d_*tmax) - (dmax*tmin_) , error);
-      if(sign1 == NEGATIVE || sign2 == NEGATIVE) {
-        return false; // We are *sure* the segment is outside the box, on one
-                      // side or the other.
-      }
-      if(sign1 == ZERO || sign2 == ZERO) {
-        return Base::operator()(s,b); // We are *unsure*: one *may be*
-                                      // negative.
-      }
-      return true; // We are *sure* the two signs are positive.
     }
     return Base::operator()(s,b);
   }
@@ -337,155 +164,14 @@ public:
     {
       CGAL_BRANCH_PROFILER_BRANCH_1(tmp);
 
-      // -----------------------------------
-      // treat x coord
-      // -----------------------------------
-      double dmin, dmax, tmin, tmax;
-      if ( qx >= px )  // this is input and needs no epsilon
-      {
-        if(px > bxmax) return false; // if tmax < 0, ray on the right of bbox
-        tmax = bxmax - px;
-        
-        dmax = qx - px;
-        if ( bxmin < px ) // tmin < 0 means px is in the x-range of bbox
-        {
-          tmin = 0;
-          dmin = 1;
-        } else {
-          if( px == qx ) return false; // if dmin == 0
-          tmin = bxmin - px;
-          dmin = dmax;
-        }
-      }
-      else
-      {
-        if(px < bxmin) return false; // if tmax < 0, ray on the left of bbox
-        tmax = px - bxmin;
+      const Uncertain<result_type> ub = 
+        do_intersect_bbox_segment_aux<double, true, false, true>
+        (px, py, pz,
+         qx, qy, qz,
+         b);
 
-        dmax = px - qx;
-        if ( px < bxmax ) // tmin < 0 means px is in the x-range of bbox
-        {
-          tmin = 0;
-          dmin = 1;
-        } else {
-          if( px == qx ) return false; // if dmin == 0
-          tmin = px - bxmax;
-          dmin = dmax;
-        }
-      }   
-
-      // -----------------------------------
-      // treat y coord
-      // -----------------------------------
-      double d_, tmin_, tmax_;
-      if ( qy >= py )   // this is input and needs no epsilon
-      {
-        tmin_ = bymin - py;
-        tmax_ = bymax - py;
-        d_ = qy - py;
-      }
-      else
-      {
-        tmin_ = py - bymax;
-        tmax_ = py - bymin;
-        d_ = py - qy;
-      }
-    
-      double m = CGAL::abs(tmin), m2;
-      m2 = CGAL::abs(tmax); if(m2 > m) { m = m2; }
-      m2 = CGAL::abs(dmin); if(m2 > m) { m = m2; }
-      m2 = CGAL::abs(tmin_); if(m2 > m) { m = m2; }
-      m2 = CGAL::abs(tmax_); if(m2 > m) { m = m2; }
-      m2 = CGAL::abs(d_); if(m2 > m) { m = m2; }
-
-      if(m < 3e-147) {
-        // underflow in the computation of 'error'
-        return Base::operator()(r,b);
-      }
-      
-      const double EPS_1 = 3.55618e-15;
-
-      double error =  EPS_1 * m * m;
-
-      if(m > 1e153) { /* sqrt(max_double [hadamard]/2) */ 
-        // potential overflow on the computation of 'sign1' and 'sign2'
-        return Base::operator()(r,b);
-      }
-      Sign sign1 = sign_with_error( (d_*tmin) - (dmin*tmax_) , error);
-      Sign sign2 = sign_with_error( (dmax*tmin_) - (d_*tmax) , error);
-
-      if(sign1 == POSITIVE || sign2 == POSITIVE) 
-        return false; // We are *sure* the ray is outside the box, on one
-                      // side or the other.
-      if(sign1 == ZERO || sign2 == ZERO) {
-        return Base::operator()(r,b); // We are *unsure*: one *may be*
-                                      // positive.
-      }
-
-      // Here we are sure the two signs are negative. We can continue with
-      // the rest of the function...
-
-      // epsilons needed
-      switch(sign_with_error((dmin*tmin_) - (d_*tmin) , error)) {
-      case POSITIVE:
-        tmin = tmin_;
-        dmin = d_;
-        break;
-      case NEGATIVE:
-        break;
-      default: // uncertainty
-        return Base::operator()(r,b);
-      }
-    
-      // epsilons needed
-      switch(sign_with_error((d_*tmax) - (dmax*tmax_) , error)) {
-      case POSITIVE:
-        tmax = tmax_;
-        dmax = d_;
-      case NEGATIVE:
-        break;
-      default: // uncertainty
-        return Base::operator()(r,b);
-      }
-    
-      // -----------------------------------
-      // treat z coord
-      // -----------------------------------
-      if ( qz >= pz )   // this is input and needs no epsilon
-      {
-        tmin_ = bzmin - pz;
-        tmax_ = bzmax - pz;
-        d_ = qz - pz;
-      }
-      else
-      {
-        tmin_ = pz - bzmax;
-        tmax_ = pz - bzmin;
-        d_ = pz - qz;
-      }
-    
-      m2 = CGAL::abs(tmin_); if(m2 > m) { m = m2; }
-      m2 = CGAL::abs(tmax_); if(m2 > m) { m = m2; }
-      m2 = CGAL::abs(d_); if(m2 > m) { m = m2; }
-
-      // m may have changed
-      error =  EPS_1 * m * m;
-    
-      if(m > 1e153) { /* sqrt(max_double [hadamard]/2) */ 
-        // potential overflow on the computation of 'sign1' and 'sign2'
-        return Base::operator()(r,b);
-      }
-      sign1 = sign_with_error( (dmin*tmax_) - (d_*tmin) , error);
-      sign2 = sign_with_error( (d_*tmax) - (dmax*tmin_) , error);
-      if(sign1 == NEGATIVE || sign2 == NEGATIVE) {
-        return false; // We are *sure* the ray is outside the box, on one
-                      // side or the other.
-      }
-      if(sign1 == ZERO || sign2 == ZERO) {
-        return Base::operator()(r,b); // We are *unsure*: one *may be*
-                                      // negative.
-      }
-      return true; // We are *sure* the two signs are positive.
+      if(is_indeterminate(ub)) return Base::operator()(r,b);
+      else return ub.sup();
     }
     return Base::operator()(r,b);
   }