Make SlidingWindowModel non-experimental

PiperOrigin-RevId: 813370022

Author: Ink Open Source

ink/brush/brush_family.cc

@@ -28,6 +28,7 @@
 #include "ink/brush/brush_coat.h"
 #include "ink/brush/brush_paint.h"
 #include "ink/brush/brush_tip.h"
+#include "ink/types/duration.h"
 
 namespace ink {
 
@@ -108,20 +109,17 @@ absl::Status ValidateInputModel(
   return absl::OkStatus();
 }
 
-absl::Status ValidateInputModel(
-    const BrushFamily::ExperimentalSlidingWindowModel& model) {
+absl::Status ValidateInputModel(const BrushFamily::SlidingWindowModel& model) {
   if (!model.window_size.IsFinite() ||
       model.window_size <= Duration32::Zero()) {
-    return absl::InvalidArgumentError(
-        absl::StrCat("`ExperimentalSlidingWindowModel::window_size` must be "
-                     "finite and positive. Got: ",
-                     model.window_size));
+    return absl::InvalidArgumentError(absl::StrCat(
+        "`SlidingWindowModel::window_size` must be finite and positive. Got: ",
+        model.window_size));
   }
   if (model.upsampling_period <= Duration32::Zero()) {
-    return absl::InvalidArgumentError(
-        absl::StrCat("`ExperimentalSlidingWindowModel::upsampling_period` must "
-                     "be positive. Got: ",
-                     model.upsampling_period));
+    return absl::InvalidArgumentError(absl::StrCat(
+        "`SlidingWindowModel::upsampling_period` must be positive. Got: ",
+        model.upsampling_period));
   }
   return absl::OkStatus();
 }
@@ -140,11 +138,9 @@ std::string ToFormattedString(
   return "ExperimentalNaiveModel";
 }
 
-std::string ToFormattedString(
-    const BrushFamily::ExperimentalSlidingWindowModel& model) {
-  return absl::StrCat(
-      "ExperimentalSlidingWindowModel(window_size=", model.window_size,
-      ", upsampling_period=", model.upsampling_period, ")");
+std::string ToFormattedString(const BrushFamily::SlidingWindowModel& model) {
+  return absl::StrCat("SlidingWindowModel(window_size=", model.window_size,
+                      ", upsampling_period=", model.upsampling_period, ")");
 }
 
 }  // namespace

ink/brush/brush_family.h

@@ -57,7 +57,7 @@ class BrushFamily {
   // period must be strictly positive (but may be infinte, to completely disable
   // upsampling). This is an experimental configuration which may be adjusted or
   // removed later.
-  struct ExperimentalSlidingWindowModel {
+  struct SlidingWindowModel {
     // The duration over which to average together nearby raw inputs. Typically
     // this should be somewhere in the 1 ms to 100 ms range, with 20 ms being a
     // reasonable default.
@@ -74,9 +74,8 @@ class BrushFamily {
   // inputs. Raw hardware inputs tend to be noisy, and must be smoothed before
   // being passed into a brush's behaviors and extruded into a mesh in order to
   // get a good-looking stroke.
-  using InputModel =
-      std::variant<SpringModel, ExperimentalRawPositionModel,
-                   ExperimentalNaiveModel, ExperimentalSlidingWindowModel>;
+  using InputModel = std::variant<SpringModel, ExperimentalRawPositionModel,
+                                  ExperimentalNaiveModel, SlidingWindowModel>;
 
   // LINT.ThenChange(../strokes/internal/stroke_input_modeler_test.cc:input_model_types)
 

ink/brush/brush_family_test.cc

@@ -118,12 +118,11 @@ TEST(BrushFamilyTest, StringifyInputModel) {
   EXPECT_EQ(absl::StrCat(
                 BrushFamily::InputModel{BrushFamily::ExperimentalNaiveModel{}}),
             "ExperimentalNaiveModel");
-  EXPECT_EQ(absl::StrCat(BrushFamily::InputModel{
-                BrushFamily::ExperimentalSlidingWindowModel{
-                    .window_size = Duration32::Millis(125),
-                    .upsampling_period = Duration32::Infinite()}}),
-            "ExperimentalSlidingWindowModel(window_size=125ms, "
-            "upsampling_period=inf)");
+  EXPECT_EQ(
+      absl::StrCat(BrushFamily::InputModel{BrushFamily::SlidingWindowModel{
+          .window_size = Duration32::Millis(125),
+          .upsampling_period = Duration32::Infinite()}}),
+      "SlidingWindowModel(window_size=125ms, upsampling_period=inf)");
 }
 
 TEST(BrushFamilyTest, StringifyWithNoId) {
@@ -217,8 +216,7 @@ TEST(BrushFamilyTest, CreateWithTooManyCoats) {
 TEST(BrushFamilyTest, CreateWithInvalidInputModel) {
   std::vector<BrushCoat> coats = {CreateTestCoat()};
   BrushFamily::InputModel input_model = {
-      BrushFamily::ExperimentalSlidingWindowModel{.window_size =
-                                                      Duration32::Zero()}};
+      BrushFamily::SlidingWindowModel{.window_size = Duration32::Zero()}};
   EXPECT_THAT(
       BrushFamily::Create(coats, "", input_model),
       StatusIs(absl::StatusCode::kInvalidArgument, HasSubstr("window_size")));

ink/brush/fuzz_domains.cc

@@ -555,7 +555,7 @@ Domain<BrushFamily::InputModel> ValidBrushFamilyInputModel() {
   return VariantOf(StructOf<BrushFamily::SpringModel>(),
                    StructOf<BrushFamily::ExperimentalRawPositionModel>(),
                    StructOf<BrushFamily::ExperimentalNaiveModel>(),
-                   StructOf<BrushFamily::ExperimentalSlidingWindowModel>(
+                   StructOf<BrushFamily::SlidingWindowModel>(
                        FinitePositiveDuration32(), PositiveDuration32()));
 }
 

ink/brush/internal/jni/brush_family_jni.cc

@@ -52,7 +52,7 @@ using ::ink::jni::ThrowExceptionFromStatus;
 constexpr jint kSpringModel = 1;
 constexpr jint kExperimentalRawPositionModel = 2;
 constexpr jint kExperimentalNaiveModel = 3;
-constexpr jint kExperimentalSlidingWindowModel = 4;
+constexpr jint kSlidingWindowModel = 4;
 
 BrushFamily::InputModel TypeToInputModel(jint input_model_value) {
   switch (input_model_value) {
@@ -62,8 +62,8 @@ BrushFamily::InputModel TypeToInputModel(jint input_model_value) {
       return BrushFamily::ExperimentalRawPositionModel();
     case kExperimentalNaiveModel:
       return BrushFamily::ExperimentalNaiveModel();
-    case kExperimentalSlidingWindowModel:
-      return BrushFamily::ExperimentalSlidingWindowModel();
+    case kSlidingWindowModel:
+      return BrushFamily::SlidingWindowModel();
     default:
       ABSL_CHECK(false) << "Unknown input model value: " << input_model_value;
   }
@@ -78,8 +78,8 @@ jint InputModelType(const BrushFamily::InputModel& input_model) {
       [](const BrushFamily::ExperimentalNaiveModel&) {
         return kExperimentalNaiveModel;
       },
-      [](const BrushFamily::ExperimentalSlidingWindowModel&) {
-        return kExperimentalSlidingWindowModel;
+      [](const BrushFamily::SlidingWindowModel&) {
+        return kSlidingWindowModel;
       },
   };
   return std::visit(visitor, input_model);
@@ -156,7 +156,7 @@ JNI_METHOD(brush, InputModelNative, jlong, createNoParametersModel)
 JNI_METHOD(brush, InputModelNative, jlong, createSlidingWindowModel)
 (JNIEnv* env, jobject object, jlong window_size_millis,
  jint upsampling_frequency_hz) {
-  return NewNativeInputModel({BrushFamily::ExperimentalSlidingWindowModel{
+  return NewNativeInputModel({BrushFamily::SlidingWindowModel{
       .window_size = Duration32::Millis(window_size_millis),
       .upsampling_period = upsampling_frequency_hz > 0
                                ? Duration32::Seconds(1) /
@@ -177,18 +177,16 @@ JNI_METHOD(brush, InputModelNative, jint, getType)
 
 JNI_METHOD(brush, InputModelNative, jlong, getSlidingWindowDurationMillis)
 (JNIEnv* env, jobject object, jlong native_pointer) {
-  return static_cast<jlong>(
-      std::get<BrushFamily::ExperimentalSlidingWindowModel>(
-          CastToInputModel(native_pointer))
-          .window_size.ToMillis());
+  return static_cast<jlong>(std::get<BrushFamily::SlidingWindowModel>(
+                                CastToInputModel(native_pointer))
+                                .window_size.ToMillis());
 }
 
 JNI_METHOD(brush, InputModelNative, jint, getSlidingUpsamplingFrequencyHz)
 (JNIEnv* env, jobject object, jlong native_pointer) {
-  float upsampling_period_seconds =
-      std::get<BrushFamily::ExperimentalSlidingWindowModel>(
-          CastToInputModel(native_pointer))
-          .upsampling_period.ToSeconds();
+  float upsampling_period_seconds = std::get<BrushFamily::SlidingWindowModel>(
+                                        CastToInputModel(native_pointer))
+                                        .upsampling_period.ToSeconds();
   return static_cast<jint>(
       std::min(1.0f / upsampling_period_seconds,
                static_cast<float>(std::numeric_limits<jint>::max())));

ink/brush/type_matchers.cc

@@ -405,10 +405,10 @@ Matcher<BrushFamily::InputModel> BrushFamilyInputModelEqMatcher(
 }
 
 Matcher<BrushFamily::InputModel> BrushFamilyInputModelEqMatcher(
-    const BrushFamily::ExperimentalSlidingWindowModel& input_model) {
-  return VariantWith<BrushFamily::ExperimentalSlidingWindowModel>(Field(
-      "window_size", &BrushFamily::ExperimentalSlidingWindowModel::window_size,
-      Duration32Eq(input_model.window_size)));
+    const BrushFamily::SlidingWindowModel& input_model) {
+  return VariantWith<BrushFamily::SlidingWindowModel>(
+      Field("window_size", &BrushFamily::SlidingWindowModel::window_size,
+            Duration32Eq(input_model.window_size)));
 }
 
 [[maybe_unused]] Matcher<BrushFamily::InputModel> BrushFamilyInputModelEq(

ink/storage/brush.cc

@@ -1322,12 +1322,12 @@ void EncodeBrushFamilyInputModel(
 }
 
 void EncodeBrushFamilyInputModel(
-    const BrushFamily::ExperimentalSlidingWindowModel& model,
+    const BrushFamily::SlidingWindowModel& model,
     proto::BrushFamily::InputModel& model_proto_out) {
-  proto::BrushFamily::ExperimentalSlidingWindowModel* sliding_window_model =
-      model_proto_out.mutable_experimental_sliding_window_model();
+  proto::BrushFamily::SlidingWindowModel* sliding_window_model =
+      model_proto_out.mutable_sliding_window_model();
   sliding_window_model->set_window_size_seconds(model.window_size.ToSeconds());
-  sliding_window_model->set_upsampling_period_seconds(
+  sliding_window_model->set_experimental_upsampling_period_seconds(
       model.upsampling_period.ToSeconds());
 }
 
@@ -1350,14 +1350,13 @@ absl::StatusOr<BrushFamily::InputModel> DecodeBrushFamilyInputModel(
       return BrushFamily::ExperimentalRawPositionModel{};
     case proto::BrushFamily::InputModel::kExperimentalNaiveModel:
       return BrushFamily::ExperimentalNaiveModel{};
-    case proto::BrushFamily::InputModel::kExperimentalSlidingWindowModel:
-      return BrushFamily::ExperimentalSlidingWindowModel{
+    case proto::BrushFamily::InputModel::kSlidingWindowModel:
+      return BrushFamily::SlidingWindowModel{
           .window_size = Duration32::Seconds(
-              model_proto.experimental_sliding_window_model()
-                  .window_size_seconds()),
+              model_proto.sliding_window_model().window_size_seconds()),
           .upsampling_period = Duration32::Seconds(
-              model_proto.experimental_sliding_window_model()
-                  .upsampling_period_seconds()),
+              model_proto.sliding_window_model()
+                  .experimental_upsampling_period_seconds()),
       };
     case proto::BrushFamily::InputModel::INPUT_MODEL_NOT_SET:
       break;

ink/storage/proto/brush_family.proto

@@ -42,11 +42,8 @@ message BrushFamily {
   // version of the code that has removed this feature.
   message ExperimentalNaiveModel {}
 
-  // Averages nearby inputs together within a sliding time window.  This is an
-  // experimental configuration which may be adjusted or removed later. Strokes
-  // generated with this input model might change shape if read with a later
-  // version of the code that has removed this feature.
-  message ExperimentalSlidingWindowModel {
+  // Averages nearby inputs together within a sliding time window.
+  message SlidingWindowModel {
     // The duration over which to average together nearby raw inputs. Typically
     // this should be somewhere in the 1 ms to 100 ms range. The default value
     // is 20 ms.
@@ -55,15 +52,18 @@ message BrushFamily {
     // more than this far apart in time, then additional modeled inputs will be
     // inserted between them. Set this to infinity to disable upsampling.  The
     // default value is 1/180 seconds.
-    optional float upsampling_period_seconds = 2 [default = 0.00555555555];
+    //
+    // This is an experimental field which may be removed later.
+    optional float experimental_upsampling_period_seconds = 2
+        [default = 0.00555555555];
   }
 
   message InputModel {
     oneof input_model {
       SpringModel spring_model = 2;
       ExperimentalRawPositionModel experimental_raw_position_model = 3;
       ExperimentalNaiveModel experimental_naive_model = 4;
-      ExperimentalSlidingWindowModel experimental_sliding_window_model = 5;
+      SlidingWindowModel sliding_window_model = 5;
     }
     // Was legacy InputModel type, reserved needs to be outside oneof
     reserved 1;

ink/strokes/internal/stroke_input_modeler.cc

@@ -44,7 +44,7 @@ absl_nonnull std::unique_ptr<StrokeInputModeler> CreateInputModeler(
 }
 
 absl_nonnull std::unique_ptr<StrokeInputModeler> CreateInputModeler(
-    const BrushFamily::ExperimentalSlidingWindowModel& sliding_window_model) {
+    const BrushFamily::SlidingWindowModel& sliding_window_model) {
   return std::make_unique<SlidingWindowInputModeler>(
       sliding_window_model.window_size, sliding_window_model.upsampling_period);
 }

ink/strokes/internal/stroke_input_modeler_test.cc

@@ -406,11 +406,11 @@ INSTANTIATE_TEST_SUITE_P(
         {"RawPositionModel", {BrushFamily::ExperimentalRawPositionModel{}}},
         {"NaiveModel", {BrushFamily::ExperimentalNaiveModel{}}},
         {"SlidingWindowModel_250ms_100ms",
-         {BrushFamily::ExperimentalSlidingWindowModel{
+         {BrushFamily::SlidingWindowModel{
              .window_size = Duration32::Millis(250),
              .upsampling_period = Duration32::Millis(100)}}},
         {"SlidingWindowModel_1500ms_inf",
-         {BrushFamily::ExperimentalSlidingWindowModel{
+         {BrushFamily::SlidingWindowModel{
              .window_size = Duration32::Millis(1500),
              .upsampling_period = Duration32::Infinite()}}},
     }),