                                  const uint3                  field_size,
                                  const uint32_t               output_count,
                                  const uint2                  chunks,
-                                 const float3                 scale)
+                                 const float3                 scale,
+                                 const float                  threshold)
   {
     if (threadIdx.x == 0) {
       uint32_t output_count_clamped = min(output_count, pyramid[8].x);
       if (output_count_clamped) {
         extractP<<<(output_count_clamped + 255) / 256, 256>>>(output,
                                                               pyramid,
+                                                              field,
                                                               index_cases,
                                                               index_table,
                                                               field_row_stride,

  if (output_buffer) {
    ::runExtractionP<<<1, 32, 0, stream>>>(reinterpret_cast<float*>(output_buffer),
                                           ctx->pyramid,
                                           ctx->index_cases_d,
                                           ctx->tables->index_table,
                                           field_row_stride,

                                           make_uint2(ctx->chunks.x, ctx->chunks.y),
                                           make_float3(1.f/ctx->cells.x,
                                                       1.f/ctx->cells.y,
                                                       1.f/ctx->cells.z),
                                           threshold);
  }
}
