Add BrushBehavior::BinaryOp::kMin and kMax operators

PiperOrigin-RevId: 867598397

Author: Ink Open Source

ink/brush/brush_behavior.cc

@@ -221,6 +221,8 @@ bool IsValidBehaviorBinaryOp(BrushBehavior::BinaryOp operation) {
   switch (operation) {
     case BrushBehavior::BinaryOp::kProduct:
     case BrushBehavior::BinaryOp::kSum:
+    case BrushBehavior::BinaryOp::kMin:
+    case BrushBehavior::BinaryOp::kMax:
       return true;
   }
   return false;
@@ -677,6 +679,10 @@ std::string ToFormattedString(BrushBehavior::BinaryOp operation) {
       return "kProduct";
     case BrushBehavior::BinaryOp::kSum:
       return "kSum";
+    case BrushBehavior::BinaryOp::kMin:
+      return "kMin";
+    case BrushBehavior::BinaryOp::kMax:
+      return "kMax";
   }
   return absl::StrCat("BinaryOp(", static_cast<int>(operation), ")");
 }

ink/brush/brush_behavior.h

@@ -403,6 +403,8 @@ struct BrushBehavior {
   enum class BinaryOp {
     kProduct,  // A * B, or null if either is null
     kSum,      // A + B, or null if either is null
+    kMin,      // min(A, B), or null if either is null
+    kMax,      // max(A, B), or null if either is null
   };
   // LINT.ThenChange(
   //   fuzz_domains.cc:binary_op,

ink/brush/brush_behavior_test.cc

@@ -235,6 +235,8 @@ TEST(BrushBehaviorTest, StringifyOptionalInputProperty) {
 TEST(BrushBehaviorTest, StringifyBinaryOp) {
   EXPECT_EQ(absl::StrCat(BrushBehavior::BinaryOp::kProduct), "kProduct");
   EXPECT_EQ(absl::StrCat(BrushBehavior::BinaryOp::kSum), "kSum");
+  EXPECT_EQ(absl::StrCat(BrushBehavior::BinaryOp::kMin), "kMin");
+  EXPECT_EQ(absl::StrCat(BrushBehavior::BinaryOp::kMax), "kMax");
   EXPECT_EQ(absl::StrCat(static_cast<BrushBehavior::BinaryOp>(147)),
             "BinaryOp(147)");
 }

ink/brush/fuzz_domains.cc

@@ -128,6 +128,8 @@ Domain<BrushBehavior::BinaryOp> ArbitraryBrushBehaviorBinaryOp() {
   return ElementOf({
       BrushBehavior::BinaryOp::kProduct,
       BrushBehavior::BinaryOp::kSum,
+      BrushBehavior::BinaryOp::kMin,
+      BrushBehavior::BinaryOp::kMax,
   });
 }
 // LINT.ThenChange(brush_behavior.h:binary_op)

ink/storage/brush.cc

@@ -56,6 +56,10 @@ proto::BrushBehavior::BinaryOp EncodeBrushBehaviorBinaryOp(
       return proto::BrushBehavior::BINARY_OP_PRODUCT;
     case BrushBehavior::BinaryOp::kSum:
       return proto::BrushBehavior::BINARY_OP_SUM;
+    case BrushBehavior::BinaryOp::kMin:
+      return proto::BrushBehavior::BINARY_OP_MIN;
+    case BrushBehavior::BinaryOp::kMax:
+      return proto::BrushBehavior::BINARY_OP_MAX;
   }
   return proto::BrushBehavior::BINARY_OP_UNSPECIFIED;
 }
@@ -67,6 +71,10 @@ absl::StatusOr<BrushBehavior::BinaryOp> DecodeBrushBehaviorBinaryOp(
       return BrushBehavior::BinaryOp::kProduct;
     case proto::BrushBehavior::BINARY_OP_SUM:
       return BrushBehavior::BinaryOp::kSum;
+    case proto::BrushBehavior::BINARY_OP_MIN:
+      return BrushBehavior::BinaryOp::kMin;
+    case proto::BrushBehavior::BINARY_OP_MAX:
+      return BrushBehavior::BinaryOp::kMax;
     default:
       return absl::InvalidArgumentError(absl::StrCat(
           "invalid ink.proto.BrushBehavior.BinaryOp value: ", binary_op_proto));

ink/storage/proto/brush_family.proto

@@ -948,6 +948,12 @@ message BrushBehavior {
 
     // A + B, or null if either is null
     BINARY_OP_SUM = 2;
+
+    // min(A, B), or null if either is null
+    BINARY_OP_MIN = 3;
+
+    // max(A, B), or null if either is null
+    BINARY_OP_MAX = 4;
   }
   // LINT.ThenChange(../../brush/brush_behavior.h:binary_op)
 

ink/strokes/internal/brush_tip_modeler_helpers.cc

@@ -497,6 +497,18 @@ void ProcessBehaviorNodeImpl(const BrushBehavior::BinaryOpNode& node,
       // the result will be null (NaN).
       *result = first_input + second_input;
       break;
+    case BrushBehavior::BinaryOp::kMin:
+      *result = IsNullBehaviorNodeValue(first_input) ||
+                        IsNullBehaviorNodeValue(second_input)
+                    ? kNullBehaviorNodeValue
+                    : std::min(first_input, second_input);
+      break;
+    case BrushBehavior::BinaryOp::kMax:
+      *result = IsNullBehaviorNodeValue(first_input) ||
+                        IsNullBehaviorNodeValue(second_input)
+                    ? kNullBehaviorNodeValue
+                    : std::max(first_input, second_input);
+      break;
   }
   // If any of the above operations resulted in a non-finite value
   // (e.g. overflow to infinity), treat the result as null.

ink/strokes/internal/brush_tip_modeler_helpers_test.cc

@@ -1342,6 +1342,42 @@ TEST_F(ProcessBehaviorNodeTest, BinaryOpNodeProduct) {
   EXPECT_THAT(stack_, ElementsAre(NullNodeValueMatcher()));
 }
 
+TEST_F(ProcessBehaviorNodeTest, BinaryOpNodeMin) {
+  BrushBehavior::BinaryOpNode binary_op_node = {
+      .operation = BrushBehavior::BinaryOp::kMin};
+
+  stack_.push_back(2.0f);
+  stack_.push_back(3.0f);
+  ProcessBehaviorNode(binary_op_node, context_);
+  EXPECT_THAT(stack_, ElementsAre(2.0f));
+
+  // `kMin` returns null when either of the two inputs is null.
+  stack_.push_back(kNullBehaviorNodeValue);
+  ProcessBehaviorNode(binary_op_node, context_);
+  EXPECT_THAT(stack_, ElementsAre(NullNodeValueMatcher()));
+  stack_.push_back(1.0f);
+  ProcessBehaviorNode(binary_op_node, context_);
+  EXPECT_THAT(stack_, ElementsAre(NullNodeValueMatcher()));
+}
+
+TEST_F(ProcessBehaviorNodeTest, BinaryOpNodeMax) {
+  BrushBehavior::BinaryOpNode binary_op_node = {
+      .operation = BrushBehavior::BinaryOp::kMax};
+
+  stack_.push_back(2.0f);
+  stack_.push_back(3.0f);
+  ProcessBehaviorNode(binary_op_node, context_);
+  EXPECT_THAT(stack_, ElementsAre(3.0f));
+
+  // `kMax` returns null when either of the two inputs is null.
+  stack_.push_back(kNullBehaviorNodeValue);
+  ProcessBehaviorNode(binary_op_node, context_);
+  EXPECT_THAT(stack_, ElementsAre(NullNodeValueMatcher()));
+  stack_.push_back(1.0f);
+  ProcessBehaviorNode(binary_op_node, context_);
+  EXPECT_THAT(stack_, ElementsAre(NullNodeValueMatcher()));
+}
+
 TEST_F(ProcessBehaviorNodeTest, InterpolationNodeLerp) {
   BrushBehavior::InterpolationNode interpolation_node = {
       .interpolation = BrushBehavior::Interpolation::kLerp,