Wes xx mediapipe integration

Packages/com.github.homuler.mediapipe/Runtime/Scripts/Protobuf/Calculators/Image/BilateralFilterCalculator.cs

@@ -0,0 +1,324 @@
+// <auto-generated>
+//     Generated by the protocol buffer compiler.  DO NOT EDIT!
+//     source: mediapipe/calculators/image/bilateral_filter_calculator.proto
+// </auto-generated>
+#pragma warning disable 1591, 0612, 3021
+#region Designer generated code
+
+using pb = global::Google.Protobuf;
+using pbc = global::Google.Protobuf.Collections;
+using pbr = global::Google.Protobuf.Reflection;
+using scg = global::System.Collections.Generic;
+namespace Mediapipe {
+
+  /// <summary>Holder for reflection information generated from mediapipe/calculators/image/bilateral_filter_calculator.proto</summary>
+  public static partial class BilateralFilterCalculatorReflection {
+
+    #region Descriptor
+    /// <summary>File descriptor for mediapipe/calculators/image/bilateral_filter_calculator.proto</summary>
+    public static pbr::FileDescriptor Descriptor {
+      get { return descriptor; }
+    }
+    private static pbr::FileDescriptor descriptor;
+
+    static BilateralFilterCalculatorReflection() {
+      byte[] descriptorData = global::System.Convert.FromBase64String(
+          string.Concat(
+            "Cj1tZWRpYXBpcGUvY2FsY3VsYXRvcnMvaW1hZ2UvYmlsYXRlcmFsX2ZpbHRl",
+            "cl9jYWxjdWxhdG9yLnByb3RvEgltZWRpYXBpcGUaJG1lZGlhcGlwZS9mcmFt",
+            "ZXdvcmsvY2FsY3VsYXRvci5wcm90byKnAQogQmlsYXRlcmFsRmlsdGVyQ2Fs",
+            "Y3VsYXRvck9wdGlvbnMSEwoLc2lnbWFfY29sb3IYASABKAISEwoLc2lnbWFf",
+            "c3BhY2UYAiABKAIyWQoDZXh0EhwubWVkaWFwaXBlLkNhbGN1bGF0b3JPcHRp",
+            "b25zGMHv9HkgASgLMisubWVkaWFwaXBlLkJpbGF0ZXJhbEZpbHRlckNhbGN1",
+            "bGF0b3JPcHRpb25z"));
+      descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData,
+          new pbr::FileDescriptor[] { global::Mediapipe.CalculatorReflection.Descriptor, },
+          new pbr::GeneratedClrTypeInfo(null, null, new pbr::GeneratedClrTypeInfo[] {
+            new pbr::GeneratedClrTypeInfo(typeof(global::Mediapipe.BilateralFilterCalculatorOptions), global::Mediapipe.BilateralFilterCalculatorOptions.Parser, new[]{ "SigmaColor", "SigmaSpace" }, null, null, new pb::Extension[] { global::Mediapipe.BilateralFilterCalculatorOptions.Extensions.Ext }, null)
+          }));
+    }
+    #endregion
+
+  }
+  #region Messages
+  public sealed partial class BilateralFilterCalculatorOptions : pb::IMessage<BilateralFilterCalculatorOptions>
+  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      , pb::IBufferMessage
+  #endif
+  {
+    private static readonly pb::MessageParser<BilateralFilterCalculatorOptions> _parser = new pb::MessageParser<BilateralFilterCalculatorOptions>(() => new BilateralFilterCalculatorOptions());
+    private pb::UnknownFieldSet _unknownFields;
+    private int _hasBits0;
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public static pb::MessageParser<BilateralFilterCalculatorOptions> Parser { get { return _parser; } }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public static pbr::MessageDescriptor Descriptor {
+      get { return global::Mediapipe.BilateralFilterCalculatorReflection.Descriptor.MessageTypes[0]; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    pbr::MessageDescriptor pb::IMessage.Descriptor {
+      get { return Descriptor; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public BilateralFilterCalculatorOptions() {
+      OnConstruction();
+    }
+
+    partial void OnConstruction();
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public BilateralFilterCalculatorOptions(BilateralFilterCalculatorOptions other) : this() {
+      _hasBits0 = other._hasBits0;
+      sigmaColor_ = other.sigmaColor_;
+      sigmaSpace_ = other.sigmaSpace_;
+      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public BilateralFilterCalculatorOptions Clone() {
+      return new BilateralFilterCalculatorOptions(this);
+    }
+
+    /// <summary>Field number for the "sigma_color" field.</summary>
+    public const int SigmaColorFieldNumber = 1;
+    private readonly static float SigmaColorDefaultValue = 0F;
+
+    private float sigmaColor_;
+    /// <summary>
+    /// Max variance in color allowed, based on normalized color values.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public float SigmaColor {
+      get { if ((_hasBits0 & 1) != 0) { return sigmaColor_; } else { return SigmaColorDefaultValue; } }
+      set {
+        _hasBits0 |= 1;
+        sigmaColor_ = value;
+      }
+    }
+    /// <summary>Gets whether the "sigma_color" field is set</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public bool HasSigmaColor {
+      get { return (_hasBits0 & 1) != 0; }
+    }
+    /// <summary>Clears the value of the "sigma_color" field</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public void ClearSigmaColor() {
+      _hasBits0 &= ~1;
+    }
+
+    /// <summary>Field number for the "sigma_space" field.</summary>
+    public const int SigmaSpaceFieldNumber = 2;
+    private readonly static float SigmaSpaceDefaultValue = 0F;
+
+    private float sigmaSpace_;
+    /// <summary>
+    /// Window radius.
+    /// Results in a '(sigma_space*2+1) x (sigma_space*2+1)' size kernel.
+    /// This should be set based on output image pixel space.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public float SigmaSpace {
+      get { if ((_hasBits0 & 2) != 0) { return sigmaSpace_; } else { return SigmaSpaceDefaultValue; } }
+      set {
+        _hasBits0 |= 2;
+        sigmaSpace_ = value;
+      }
+    }
+    /// <summary>Gets whether the "sigma_space" field is set</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public bool HasSigmaSpace {
+      get { return (_hasBits0 & 2) != 0; }
+    }
+    /// <summary>Clears the value of the "sigma_space" field</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public void ClearSigmaSpace() {
+      _hasBits0 &= ~2;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public override bool Equals(object other) {
+      return Equals(other as BilateralFilterCalculatorOptions);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public bool Equals(BilateralFilterCalculatorOptions other) {
+      if (ReferenceEquals(other, null)) {
+        return false;
+      }
+      if (ReferenceEquals(other, this)) {
+        return true;
+      }
+      if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(SigmaColor, other.SigmaColor)) return false;
+      if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(SigmaSpace, other.SigmaSpace)) return false;
+      return Equals(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public override int GetHashCode() {
+      int hash = 1;
+      if (HasSigmaColor) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(SigmaColor);
+      if (HasSigmaSpace) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(SigmaSpace);
+      if (_unknownFields != null) {
+        hash ^= _unknownFields.GetHashCode();
+      }
+      return hash;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public override string ToString() {
+      return pb::JsonFormatter.ToDiagnosticString(this);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public void WriteTo(pb::CodedOutputStream output) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      output.WriteRawMessage(this);
+    #else
+      if (HasSigmaColor) {
+        output.WriteRawTag(13);
+        output.WriteFloat(SigmaColor);
+      }
+      if (HasSigmaSpace) {
+        output.WriteRawTag(21);
+        output.WriteFloat(SigmaSpace);
+      }
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(output);
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+      if (HasSigmaColor) {
+        output.WriteRawTag(13);
+        output.WriteFloat(SigmaColor);
+      }
+      if (HasSigmaSpace) {
+        output.WriteRawTag(21);
+        output.WriteFloat(SigmaSpace);
+      }
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(ref output);
+      }
+    }
+    #endif
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public int CalculateSize() {
+      int size = 0;
+      if (HasSigmaColor) {
+        size += 1 + 4;
+      }
+      if (HasSigmaSpace) {
+        size += 1 + 4;
+      }
+      if (_unknownFields != null) {
+        size += _unknownFields.CalculateSize();
+      }
+      return size;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public void MergeFrom(BilateralFilterCalculatorOptions other) {
+      if (other == null) {
+        return;
+      }
+      if (other.HasSigmaColor) {
+        SigmaColor = other.SigmaColor;
+      }
+      if (other.HasSigmaSpace) {
+        SigmaSpace = other.SigmaSpace;
+      }
+      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public void MergeFrom(pb::CodedInputStream input) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      input.ReadRawMessage(this);
+    #else
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
+            break;
+          case 13: {
+            SigmaColor = input.ReadFloat();
+            break;
+          }
+          case 21: {
+            SigmaSpace = input.ReadFloat();
+            break;
+          }
+        }
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
+            break;
+          case 13: {
+            SigmaColor = input.ReadFloat();
+            break;
+          }
+          case 21: {
+            SigmaSpace = input.ReadFloat();
+            break;
+          }
+        }
+      }
+    }
+    #endif
+
+    #region Extensions
+    /// <summary>Container for extensions for other messages declared in the BilateralFilterCalculatorOptions message type.</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public static partial class Extensions {
+      public static readonly pb::Extension<global::Mediapipe.CalculatorOptions, global::Mediapipe.BilateralFilterCalculatorOptions> Ext =
+        new pb::Extension<global::Mediapipe.CalculatorOptions, global::Mediapipe.BilateralFilterCalculatorOptions>(255670209, pb::FieldCodec.ForMessage(2045361674, global::Mediapipe.BilateralFilterCalculatorOptions.Parser));
+    }
+    #endregion
+
+  }
+
+  #endregion
+
+}
+
+#endregion Designer generated code

Packages/com.github.homuler.mediapipe/Runtime/Scripts/Protobuf/Calculators/Image/BilateralFilterCalculator.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: ae0fb6e19efb6cd89a4b918f64f48880
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.github.homuler.mediapipe/Runtime/Scripts/Protobuf/Calculators/Image/FeatureDetectorCalculator.cs

@@ -0,0 +1,433 @@
+// <auto-generated>
+//     Generated by the protocol buffer compiler.  DO NOT EDIT!
+//     source: mediapipe/calculators/image/feature_detector_calculator.proto
+// </auto-generated>
+#pragma warning disable 1591, 0612, 3021
+#region Designer generated code
+
+using pb = global::Google.Protobuf;
+using pbc = global::Google.Protobuf.Collections;
+using pbr = global::Google.Protobuf.Reflection;
+using scg = global::System.Collections.Generic;
+namespace Mediapipe {
+
+  /// <summary>Holder for reflection information generated from mediapipe/calculators/image/feature_detector_calculator.proto</summary>
+  public static partial class FeatureDetectorCalculatorReflection {
+
+    #region Descriptor
+    /// <summary>File descriptor for mediapipe/calculators/image/feature_detector_calculator.proto</summary>
+    public static pbr::FileDescriptor Descriptor {
+      get { return descriptor; }
+    }
+    private static pbr::FileDescriptor descriptor;
+
+    static FeatureDetectorCalculatorReflection() {
+      byte[] descriptorData = global::System.Convert.FromBase64String(
+          string.Concat(
+            "Cj1tZWRpYXBpcGUvY2FsY3VsYXRvcnMvaW1hZ2UvZmVhdHVyZV9kZXRlY3Rv",
+            "cl9jYWxjdWxhdG9yLnByb3RvEgltZWRpYXBpcGUaJG1lZGlhcGlwZS9mcmFt",
+            "ZXdvcmsvY2FsY3VsYXRvci5wcm90byLkAQogRmVhdHVyZURldGVjdG9yQ2Fs",
+            "Y3VsYXRvck9wdGlvbnMSFAoMb3V0cHV0X3BhdGNoGAEgASgIEhkKDG1heF9m",
+            "ZWF0dXJlcxgCIAEoBToDMjAwEhgKDXB5cmFtaWRfbGV2ZWwYAyABKAU6ATQS",
+            "GQoMc2NhbGVfZmFjdG9yGAQgASgCOgMxLjIyWgoDZXh0EhwubWVkaWFwaXBl",
+            "LkNhbGN1bGF0b3JPcHRpb25zGLCF9YQBIAEoCzIrLm1lZGlhcGlwZS5GZWF0",
+            "dXJlRGV0ZWN0b3JDYWxjdWxhdG9yT3B0aW9ucw=="));
+      descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData,
+          new pbr::FileDescriptor[] { global::Mediapipe.CalculatorReflection.Descriptor, },
+          new pbr::GeneratedClrTypeInfo(null, null, new pbr::GeneratedClrTypeInfo[] {
+            new pbr::GeneratedClrTypeInfo(typeof(global::Mediapipe.FeatureDetectorCalculatorOptions), global::Mediapipe.FeatureDetectorCalculatorOptions.Parser, new[]{ "OutputPatch", "MaxFeatures", "PyramidLevel", "ScaleFactor" }, null, null, new pb::Extension[] { global::Mediapipe.FeatureDetectorCalculatorOptions.Extensions.Ext }, null)
+          }));
+    }
+    #endregion
+
+  }
+  #region Messages
+  public sealed partial class FeatureDetectorCalculatorOptions : pb::IMessage<FeatureDetectorCalculatorOptions>
+  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      , pb::IBufferMessage
+  #endif
+  {
+    private static readonly pb::MessageParser<FeatureDetectorCalculatorOptions> _parser = new pb::MessageParser<FeatureDetectorCalculatorOptions>(() => new FeatureDetectorCalculatorOptions());
+    private pb::UnknownFieldSet _unknownFields;
+    private int _hasBits0;
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public static pb::MessageParser<FeatureDetectorCalculatorOptions> Parser { get { return _parser; } }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public static pbr::MessageDescriptor Descriptor {
+      get { return global::Mediapipe.FeatureDetectorCalculatorReflection.Descriptor.MessageTypes[0]; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    pbr::MessageDescriptor pb::IMessage.Descriptor {
+      get { return Descriptor; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public FeatureDetectorCalculatorOptions() {
+      OnConstruction();
+    }
+
+    partial void OnConstruction();
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public FeatureDetectorCalculatorOptions(FeatureDetectorCalculatorOptions other) : this() {
+      _hasBits0 = other._hasBits0;
+      outputPatch_ = other.outputPatch_;
+      maxFeatures_ = other.maxFeatures_;
+      pyramidLevel_ = other.pyramidLevel_;
+      scaleFactor_ = other.scaleFactor_;
+      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public FeatureDetectorCalculatorOptions Clone() {
+      return new FeatureDetectorCalculatorOptions(this);
+    }
+
+    /// <summary>Field number for the "output_patch" field.</summary>
+    public const int OutputPatchFieldNumber = 1;
+    private readonly static bool OutputPatchDefaultValue = false;
+
+    private bool outputPatch_;
+    /// <summary>
+    /// Set to true if output patches, otherwise only output cv::KeyPoint
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public bool OutputPatch {
+      get { if ((_hasBits0 & 1) != 0) { return outputPatch_; } else { return OutputPatchDefaultValue; } }
+      set {
+        _hasBits0 |= 1;
+        outputPatch_ = value;
+      }
+    }
+    /// <summary>Gets whether the "output_patch" field is set</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public bool HasOutputPatch {
+      get { return (_hasBits0 & 1) != 0; }
+    }
+    /// <summary>Clears the value of the "output_patch" field</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public void ClearOutputPatch() {
+      _hasBits0 &= ~1;
+    }
+
+    /// <summary>Field number for the "max_features" field.</summary>
+    public const int MaxFeaturesFieldNumber = 2;
+    private readonly static int MaxFeaturesDefaultValue = 200;
+
+    private int maxFeatures_;
+    /// <summary>
+    /// The max number of detected features.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public int MaxFeatures {
+      get { if ((_hasBits0 & 2) != 0) { return maxFeatures_; } else { return MaxFeaturesDefaultValue; } }
+      set {
+        _hasBits0 |= 2;
+        maxFeatures_ = value;
+      }
+    }
+    /// <summary>Gets whether the "max_features" field is set</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public bool HasMaxFeatures {
+      get { return (_hasBits0 & 2) != 0; }
+    }
+    /// <summary>Clears the value of the "max_features" field</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public void ClearMaxFeatures() {
+      _hasBits0 &= ~2;
+    }
+
+    /// <summary>Field number for the "pyramid_level" field.</summary>
+    public const int PyramidLevelFieldNumber = 3;
+    private readonly static int PyramidLevelDefaultValue = 4;
+
+    private int pyramidLevel_;
+    /// <summary>
+    /// The number of pyramid levels.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public int PyramidLevel {
+      get { if ((_hasBits0 & 4) != 0) { return pyramidLevel_; } else { return PyramidLevelDefaultValue; } }
+      set {
+        _hasBits0 |= 4;
+        pyramidLevel_ = value;
+      }
+    }
+    /// <summary>Gets whether the "pyramid_level" field is set</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public bool HasPyramidLevel {
+      get { return (_hasBits0 & 4) != 0; }
+    }
+    /// <summary>Clears the value of the "pyramid_level" field</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public void ClearPyramidLevel() {
+      _hasBits0 &= ~4;
+    }
+
+    /// <summary>Field number for the "scale_factor" field.</summary>
+    public const int ScaleFactorFieldNumber = 4;
+    private readonly static float ScaleFactorDefaultValue = 1.2F;
+
+    private float scaleFactor_;
+    /// <summary>
+    /// Pyramid decimation ratio.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public float ScaleFactor {
+      get { if ((_hasBits0 & 8) != 0) { return scaleFactor_; } else { return ScaleFactorDefaultValue; } }
+      set {
+        _hasBits0 |= 8;
+        scaleFactor_ = value;
+      }
+    }
+    /// <summary>Gets whether the "scale_factor" field is set</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public bool HasScaleFactor {
+      get { return (_hasBits0 & 8) != 0; }
+    }
+    /// <summary>Clears the value of the "scale_factor" field</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public void ClearScaleFactor() {
+      _hasBits0 &= ~8;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public override bool Equals(object other) {
+      return Equals(other as FeatureDetectorCalculatorOptions);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public bool Equals(FeatureDetectorCalculatorOptions other) {
+      if (ReferenceEquals(other, null)) {
+        return false;
+      }
+      if (ReferenceEquals(other, this)) {
+        return true;
+      }
+      if (OutputPatch != other.OutputPatch) return false;
+      if (MaxFeatures != other.MaxFeatures) return false;
+      if (PyramidLevel != other.PyramidLevel) return false;
+      if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(ScaleFactor, other.ScaleFactor)) return false;
+      return Equals(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public override int GetHashCode() {
+      int hash = 1;
+      if (HasOutputPatch) hash ^= OutputPatch.GetHashCode();
+      if (HasMaxFeatures) hash ^= MaxFeatures.GetHashCode();
+      if (HasPyramidLevel) hash ^= PyramidLevel.GetHashCode();
+      if (HasScaleFactor) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(ScaleFactor);
+      if (_unknownFields != null) {
+        hash ^= _unknownFields.GetHashCode();
+      }
+      return hash;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public override string ToString() {
+      return pb::JsonFormatter.ToDiagnosticString(this);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public void WriteTo(pb::CodedOutputStream output) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      output.WriteRawMessage(this);
+    #else
+      if (HasOutputPatch) {
+        output.WriteRawTag(8);
+        output.WriteBool(OutputPatch);
+      }
+      if (HasMaxFeatures) {
+        output.WriteRawTag(16);
+        output.WriteInt32(MaxFeatures);
+      }
+      if (HasPyramidLevel) {
+        output.WriteRawTag(24);
+        output.WriteInt32(PyramidLevel);
+      }
+      if (HasScaleFactor) {
+        output.WriteRawTag(37);
+        output.WriteFloat(ScaleFactor);
+      }
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(output);
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+      if (HasOutputPatch) {
+        output.WriteRawTag(8);
+        output.WriteBool(OutputPatch);
+      }
+      if (HasMaxFeatures) {
+        output.WriteRawTag(16);
+        output.WriteInt32(MaxFeatures);
+      }
+      if (HasPyramidLevel) {
+        output.WriteRawTag(24);
+        output.WriteInt32(PyramidLevel);
+      }
+      if (HasScaleFactor) {
+        output.WriteRawTag(37);
+        output.WriteFloat(ScaleFactor);
+      }
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(ref output);
+      }
+    }
+    #endif
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public int CalculateSize() {
+      int size = 0;
+      if (HasOutputPatch) {
+        size += 1 + 1;
+      }
+      if (HasMaxFeatures) {
+        size += 1 + pb::CodedOutputStream.ComputeInt32Size(MaxFeatures);
+      }
+      if (HasPyramidLevel) {
+        size += 1 + pb::CodedOutputStream.ComputeInt32Size(PyramidLevel);
+      }
+      if (HasScaleFactor) {
+        size += 1 + 4;
+      }
+      if (_unknownFields != null) {
+        size += _unknownFields.CalculateSize();
+      }
+      return size;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public void MergeFrom(FeatureDetectorCalculatorOptions other) {
+      if (other == null) {
+        return;
+      }
+      if (other.HasOutputPatch) {
+        OutputPatch = other.OutputPatch;
+      }
+      if (other.HasMaxFeatures) {
+        MaxFeatures = other.MaxFeatures;
+      }
+      if (other.HasPyramidLevel) {
+        PyramidLevel = other.PyramidLevel;
+      }
+      if (other.HasScaleFactor) {
+        ScaleFactor = other.ScaleFactor;
+      }
+      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public void MergeFrom(pb::CodedInputStream input) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      input.ReadRawMessage(this);
+    #else
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
+            break;
+          case 8: {
+            OutputPatch = input.ReadBool();
+            break;
+          }
+          case 16: {
+            MaxFeatures = input.ReadInt32();
+            break;
+          }
+          case 24: {
+            PyramidLevel = input.ReadInt32();
+            break;
+          }
+          case 37: {
+            ScaleFactor = input.ReadFloat();
+            break;
+          }
+        }
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
+            break;
+          case 8: {
+            OutputPatch = input.ReadBool();
+            break;
+          }
+          case 16: {
+            MaxFeatures = input.ReadInt32();
+            break;
+          }
+          case 24: {
+            PyramidLevel = input.ReadInt32();
+            break;
+          }
+          case 37: {
+            ScaleFactor = input.ReadFloat();
+            break;
+          }
+        }
+      }
+    }
+    #endif
+
+    #region Extensions
+    /// <summary>Container for extensions for other messages declared in the FeatureDetectorCalculatorOptions message type.</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public static partial class Extensions {
+      public static readonly pb::Extension<global::Mediapipe.CalculatorOptions, global::Mediapipe.FeatureDetectorCalculatorOptions> Ext =
+        new pb::Extension<global::Mediapipe.CalculatorOptions, global::Mediapipe.FeatureDetectorCalculatorOptions>(278741680, pb::FieldCodec.ForMessage(2229933442, global::Mediapipe.FeatureDetectorCalculatorOptions.Parser));
+    }
+    #endregion
+
+  }
+
+  #endregion
+
+}
+
+#endregion Designer generated code

Packages/com.github.homuler.mediapipe/Runtime/Scripts/Protobuf/Calculators/Image/FeatureDetectorCalculator.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: d1205294725c4a1f6899f24cabc079e8
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.github.homuler.mediapipe/Runtime/Scripts/Protobuf/Calculators/Image/ImageCloneCalculator.cs

@@ -0,0 +1,266 @@
+// <auto-generated>
+//     Generated by the protocol buffer compiler.  DO NOT EDIT!
+//     source: mediapipe/calculators/image/image_clone_calculator.proto
+// </auto-generated>
+#pragma warning disable 1591, 0612, 3021
+#region Designer generated code
+
+using pb = global::Google.Protobuf;
+using pbc = global::Google.Protobuf.Collections;
+using pbr = global::Google.Protobuf.Reflection;
+using scg = global::System.Collections.Generic;
+namespace Mediapipe {
+
+  /// <summary>Holder for reflection information generated from mediapipe/calculators/image/image_clone_calculator.proto</summary>
+  public static partial class ImageCloneCalculatorReflection {
+
+    #region Descriptor
+    /// <summary>File descriptor for mediapipe/calculators/image/image_clone_calculator.proto</summary>
+    public static pbr::FileDescriptor Descriptor {
+      get { return descriptor; }
+    }
+    private static pbr::FileDescriptor descriptor;
+
+    static ImageCloneCalculatorReflection() {
+      byte[] descriptorData = global::System.Convert.FromBase64String(
+          string.Concat(
+            "CjhtZWRpYXBpcGUvY2FsY3VsYXRvcnMvaW1hZ2UvaW1hZ2VfY2xvbmVfY2Fs",
+            "Y3VsYXRvci5wcm90bxIJbWVkaWFwaXBlGiRtZWRpYXBpcGUvZnJhbWV3b3Jr",
+            "L2NhbGN1bGF0b3IucHJvdG8ikgEKG0ltYWdlQ2xvbmVDYWxjdWxhdG9yT3B0",
+            "aW9ucxIcCg1vdXRwdXRfb25fZ3B1GAEgASgIOgVmYWxzZTJVCgNleHQSHC5t",
+            "ZWRpYXBpcGUuQ2FsY3VsYXRvck9wdGlvbnMYxubgsQEgASgLMiYubWVkaWFw",
+            "aXBlLkltYWdlQ2xvbmVDYWxjdWxhdG9yT3B0aW9ucw=="));
+      descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData,
+          new pbr::FileDescriptor[] { global::Mediapipe.CalculatorReflection.Descriptor, },
+          new pbr::GeneratedClrTypeInfo(null, null, new pbr::GeneratedClrTypeInfo[] {
+            new pbr::GeneratedClrTypeInfo(typeof(global::Mediapipe.ImageCloneCalculatorOptions), global::Mediapipe.ImageCloneCalculatorOptions.Parser, new[]{ "OutputOnGpu" }, null, null, new pb::Extension[] { global::Mediapipe.ImageCloneCalculatorOptions.Extensions.Ext }, null)
+          }));
+    }
+    #endregion
+
+  }
+  #region Messages
+  public sealed partial class ImageCloneCalculatorOptions : pb::IMessage<ImageCloneCalculatorOptions>
+  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      , pb::IBufferMessage
+  #endif
+  {
+    private static readonly pb::MessageParser<ImageCloneCalculatorOptions> _parser = new pb::MessageParser<ImageCloneCalculatorOptions>(() => new ImageCloneCalculatorOptions());
+    private pb::UnknownFieldSet _unknownFields;
+    private int _hasBits0;
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public static pb::MessageParser<ImageCloneCalculatorOptions> Parser { get { return _parser; } }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public static pbr::MessageDescriptor Descriptor {
+      get { return global::Mediapipe.ImageCloneCalculatorReflection.Descriptor.MessageTypes[0]; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    pbr::MessageDescriptor pb::IMessage.Descriptor {
+      get { return Descriptor; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public ImageCloneCalculatorOptions() {
+      OnConstruction();
+    }
+
+    partial void OnConstruction();
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public ImageCloneCalculatorOptions(ImageCloneCalculatorOptions other) : this() {
+      _hasBits0 = other._hasBits0;
+      outputOnGpu_ = other.outputOnGpu_;
+      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public ImageCloneCalculatorOptions Clone() {
+      return new ImageCloneCalculatorOptions(this);
+    }
+
+    /// <summary>Field number for the "output_on_gpu" field.</summary>
+    public const int OutputOnGpuFieldNumber = 1;
+    private readonly static bool OutputOnGpuDefaultValue = false;
+
+    private bool outputOnGpu_;
+    /// <summary>
+    /// Whether the output clone should have pixel data already available on GPU.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public bool OutputOnGpu {
+      get { if ((_hasBits0 & 1) != 0) { return outputOnGpu_; } else { return OutputOnGpuDefaultValue; } }
+      set {
+        _hasBits0 |= 1;
+        outputOnGpu_ = value;
+      }
+    }
+    /// <summary>Gets whether the "output_on_gpu" field is set</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public bool HasOutputOnGpu {
+      get { return (_hasBits0 & 1) != 0; }
+    }
+    /// <summary>Clears the value of the "output_on_gpu" field</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public void ClearOutputOnGpu() {
+      _hasBits0 &= ~1;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public override bool Equals(object other) {
+      return Equals(other as ImageCloneCalculatorOptions);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public bool Equals(ImageCloneCalculatorOptions other) {
+      if (ReferenceEquals(other, null)) {
+        return false;
+      }
+      if (ReferenceEquals(other, this)) {
+        return true;
+      }
+      if (OutputOnGpu != other.OutputOnGpu) return false;
+      return Equals(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public override int GetHashCode() {
+      int hash = 1;
+      if (HasOutputOnGpu) hash ^= OutputOnGpu.GetHashCode();
+      if (_unknownFields != null) {
+        hash ^= _unknownFields.GetHashCode();
+      }
+      return hash;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public override string ToString() {
+      return pb::JsonFormatter.ToDiagnosticString(this);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public void WriteTo(pb::CodedOutputStream output) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      output.WriteRawMessage(this);
+    #else
+      if (HasOutputOnGpu) {
+        output.WriteRawTag(8);
+        output.WriteBool(OutputOnGpu);
+      }
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(output);
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+      if (HasOutputOnGpu) {
+        output.WriteRawTag(8);
+        output.WriteBool(OutputOnGpu);
+      }
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(ref output);
+      }
+    }
+    #endif
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public int CalculateSize() {
+      int size = 0;
+      if (HasOutputOnGpu) {
+        size += 1 + 1;
+      }
+      if (_unknownFields != null) {
+        size += _unknownFields.CalculateSize();
+      }
+      return size;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public void MergeFrom(ImageCloneCalculatorOptions other) {
+      if (other == null) {
+        return;
+      }
+      if (other.HasOutputOnGpu) {
+        OutputOnGpu = other.OutputOnGpu;
+      }
+      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public void MergeFrom(pb::CodedInputStream input) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      input.ReadRawMessage(this);
+    #else
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
+            break;
+          case 8: {
+            OutputOnGpu = input.ReadBool();
+            break;
+          }
+        }
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
+            break;
+          case 8: {
+            OutputOnGpu = input.ReadBool();
+            break;
+          }
+        }
+      }
+    }
+    #endif
+
+    #region Extensions
+    /// <summary>Container for extensions for other messages declared in the ImageCloneCalculatorOptions message type.</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public static partial class Extensions {
+      public static readonly pb::Extension<global::Mediapipe.CalculatorOptions, global::Mediapipe.ImageCloneCalculatorOptions> Ext =
+        new pb::Extension<global::Mediapipe.CalculatorOptions, global::Mediapipe.ImageCloneCalculatorOptions>(372781894, pb::FieldCodec.ForMessage(2982255154, global::Mediapipe.ImageCloneCalculatorOptions.Parser));
+    }
+    #endregion
+
+  }
+
+  #endregion
+
+}
+
+#endregion Designer generated code

Packages/com.github.homuler.mediapipe/Runtime/Scripts/Protobuf/Calculators/Image/ImageCloneCalculator.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: f92c3cfedbfa9983186e6c08f78d206b
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.github.homuler.mediapipe/Runtime/Scripts/Protobuf/Calculators/Image/ImageCroppingCalculator.cs

@@ -0,0 +1,780 @@
+// <auto-generated>
+//     Generated by the protocol buffer compiler.  DO NOT EDIT!
+//     source: mediapipe/calculators/image/image_cropping_calculator.proto
+// </auto-generated>
+#pragma warning disable 1591, 0612, 3021
+#region Designer generated code
+
+using pb = global::Google.Protobuf;
+using pbc = global::Google.Protobuf.Collections;
+using pbr = global::Google.Protobuf.Reflection;
+using scg = global::System.Collections.Generic;
+namespace Mediapipe {
+
+  /// <summary>Holder for reflection information generated from mediapipe/calculators/image/image_cropping_calculator.proto</summary>
+  public static partial class ImageCroppingCalculatorReflection {
+
+    #region Descriptor
+    /// <summary>File descriptor for mediapipe/calculators/image/image_cropping_calculator.proto</summary>
+    public static pbr::FileDescriptor Descriptor {
+      get { return descriptor; }
+    }
+    private static pbr::FileDescriptor descriptor;
+
+    static ImageCroppingCalculatorReflection() {
+      byte[] descriptorData = global::System.Convert.FromBase64String(
+          string.Concat(
+            "CjttZWRpYXBpcGUvY2FsY3VsYXRvcnMvaW1hZ2UvaW1hZ2VfY3JvcHBpbmdf",
+            "Y2FsY3VsYXRvci5wcm90bxIJbWVkaWFwaXBlGiRtZWRpYXBpcGUvZnJhbWV3",
+            "b3JrL2NhbGN1bGF0b3IucHJvdG8i5AMKHkltYWdlQ3JvcHBpbmdDYWxjdWxh",
+            "dG9yT3B0aW9ucxINCgV3aWR0aBgBIAEoBRIOCgZoZWlnaHQYAiABKAUSEwoI",
+            "cm90YXRpb24YAyABKAI6ATASEgoKbm9ybV93aWR0aBgEIAEoAhITCgtub3Jt",
+            "X2hlaWdodBgFIAEoAhIYCg1ub3JtX2NlbnRlcl94GAYgASgCOgEwEhgKDW5v",
+            "cm1fY2VudGVyX3kYByABKAI6ATASVgoLYm9yZGVyX21vZGUYCCABKA4yNC5t",
+            "ZWRpYXBpcGUuSW1hZ2VDcm9wcGluZ0NhbGN1bGF0b3JPcHRpb25zLkJvcmRl",
+            "ck1vZGU6C0JPUkRFUl9aRVJPEhgKEG91dHB1dF9tYXhfd2lkdGgYCSABKAUS",
+            "GQoRb3V0cHV0X21heF9oZWlnaHQYCiABKAUiSwoKQm9yZGVyTW9kZRIWChJC",
+            "T1JERVJfVU5TUEVDSUZJRUQQABIPCgtCT1JERVJfWkVSTxABEhQKEEJPUkRF",
+            "Ul9SRVBMSUNBVEUQAjJXCgNleHQSHC5tZWRpYXBpcGUuQ2FsY3VsYXRvck9w",
+            "dGlvbnMY39aTfSABKAsyKS5tZWRpYXBpcGUuSW1hZ2VDcm9wcGluZ0NhbGN1",
+            "bGF0b3JPcHRpb25z"));
+      descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData,
+          new pbr::FileDescriptor[] { global::Mediapipe.CalculatorReflection.Descriptor, },
+          new pbr::GeneratedClrTypeInfo(null, null, new pbr::GeneratedClrTypeInfo[] {
+            new pbr::GeneratedClrTypeInfo(typeof(global::Mediapipe.ImageCroppingCalculatorOptions), global::Mediapipe.ImageCroppingCalculatorOptions.Parser, new[]{ "Width", "Height", "Rotation", "NormWidth", "NormHeight", "NormCenterX", "NormCenterY", "BorderMode", "OutputMaxWidth", "OutputMaxHeight" }, null, new[]{ typeof(global::Mediapipe.ImageCroppingCalculatorOptions.Types.BorderMode) }, new pb::Extension[] { global::Mediapipe.ImageCroppingCalculatorOptions.Extensions.Ext }, null)
+          }));
+    }
+    #endregion
+
+  }
+  #region Messages
+  public sealed partial class ImageCroppingCalculatorOptions : pb::IMessage<ImageCroppingCalculatorOptions>
+  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      , pb::IBufferMessage
+  #endif
+  {
+    private static readonly pb::MessageParser<ImageCroppingCalculatorOptions> _parser = new pb::MessageParser<ImageCroppingCalculatorOptions>(() => new ImageCroppingCalculatorOptions());
+    private pb::UnknownFieldSet _unknownFields;
+    private int _hasBits0;
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public static pb::MessageParser<ImageCroppingCalculatorOptions> Parser { get { return _parser; } }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public static pbr::MessageDescriptor Descriptor {
+      get { return global::Mediapipe.ImageCroppingCalculatorReflection.Descriptor.MessageTypes[0]; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    pbr::MessageDescriptor pb::IMessage.Descriptor {
+      get { return Descriptor; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public ImageCroppingCalculatorOptions() {
+      OnConstruction();
+    }
+
+    partial void OnConstruction();
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public ImageCroppingCalculatorOptions(ImageCroppingCalculatorOptions other) : this() {
+      _hasBits0 = other._hasBits0;
+      width_ = other.width_;
+      height_ = other.height_;
+      rotation_ = other.rotation_;
+      normWidth_ = other.normWidth_;
+      normHeight_ = other.normHeight_;
+      normCenterX_ = other.normCenterX_;
+      normCenterY_ = other.normCenterY_;
+      borderMode_ = other.borderMode_;
+      outputMaxWidth_ = other.outputMaxWidth_;
+      outputMaxHeight_ = other.outputMaxHeight_;
+      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public ImageCroppingCalculatorOptions Clone() {
+      return new ImageCroppingCalculatorOptions(this);
+    }
+
+    /// <summary>Field number for the "width" field.</summary>
+    public const int WidthFieldNumber = 1;
+    private readonly static int WidthDefaultValue = 0;
+
+    private int width_;
+    /// <summary>
+    /// Output texture buffer dimensions. The values defined in the options will be
+    /// overriden by the WIDTH and HEIGHT input streams if they exist.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public int Width {
+      get { if ((_hasBits0 & 1) != 0) { return width_; } else { return WidthDefaultValue; } }
+      set {
+        _hasBits0 |= 1;
+        width_ = value;
+      }
+    }
+    /// <summary>Gets whether the "width" field is set</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public bool HasWidth {
+      get { return (_hasBits0 & 1) != 0; }
+    }
+    /// <summary>Clears the value of the "width" field</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public void ClearWidth() {
+      _hasBits0 &= ~1;
+    }
+
+    /// <summary>Field number for the "height" field.</summary>
+    public const int HeightFieldNumber = 2;
+    private readonly static int HeightDefaultValue = 0;
+
+    private int height_;
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public int Height {
+      get { if ((_hasBits0 & 2) != 0) { return height_; } else { return HeightDefaultValue; } }
+      set {
+        _hasBits0 |= 2;
+        height_ = value;
+      }
+    }
+    /// <summary>Gets whether the "height" field is set</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public bool HasHeight {
+      get { return (_hasBits0 & 2) != 0; }
+    }
+    /// <summary>Clears the value of the "height" field</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public void ClearHeight() {
+      _hasBits0 &= ~2;
+    }
+
+    /// <summary>Field number for the "rotation" field.</summary>
+    public const int RotationFieldNumber = 3;
+    private readonly static float RotationDefaultValue = 0F;
+
+    private float rotation_;
+    /// <summary>
+    /// Rotation angle is counter-clockwise in radian.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public float Rotation {
+      get { if ((_hasBits0 & 4) != 0) { return rotation_; } else { return RotationDefaultValue; } }
+      set {
+        _hasBits0 |= 4;
+        rotation_ = value;
+      }
+    }
+    /// <summary>Gets whether the "rotation" field is set</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public bool HasRotation {
+      get { return (_hasBits0 & 4) != 0; }
+    }
+    /// <summary>Clears the value of the "rotation" field</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public void ClearRotation() {
+      _hasBits0 &= ~4;
+    }
+
+    /// <summary>Field number for the "norm_width" field.</summary>
+    public const int NormWidthFieldNumber = 4;
+    private readonly static float NormWidthDefaultValue = 0F;
+
+    private float normWidth_;
+    /// <summary>
+    /// Normalized width and height of the output rect. Value is within [0, 1].
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public float NormWidth {
+      get { if ((_hasBits0 & 8) != 0) { return normWidth_; } else { return NormWidthDefaultValue; } }
+      set {
+        _hasBits0 |= 8;
+        normWidth_ = value;
+      }
+    }
+    /// <summary>Gets whether the "norm_width" field is set</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public bool HasNormWidth {
+      get { return (_hasBits0 & 8) != 0; }
+    }
+    /// <summary>Clears the value of the "norm_width" field</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public void ClearNormWidth() {
+      _hasBits0 &= ~8;
+    }
+
+    /// <summary>Field number for the "norm_height" field.</summary>
+    public const int NormHeightFieldNumber = 5;
+    private readonly static float NormHeightDefaultValue = 0F;
+
+    private float normHeight_;
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public float NormHeight {
+      get { if ((_hasBits0 & 16) != 0) { return normHeight_; } else { return NormHeightDefaultValue; } }
+      set {
+        _hasBits0 |= 16;
+        normHeight_ = value;
+      }
+    }
+    /// <summary>Gets whether the "norm_height" field is set</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public bool HasNormHeight {
+      get { return (_hasBits0 & 16) != 0; }
+    }
+    /// <summary>Clears the value of the "norm_height" field</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public void ClearNormHeight() {
+      _hasBits0 &= ~16;
+    }
+
+    /// <summary>Field number for the "norm_center_x" field.</summary>
+    public const int NormCenterXFieldNumber = 6;
+    private readonly static float NormCenterXDefaultValue = 0F;
+
+    private float normCenterX_;
+    /// <summary>
+    /// Normalized location of the center of the output
+    /// rectangle in image coordinates. Value is within [0, 1].
+    /// The (0, 0) point is at the (top, left) corner.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public float NormCenterX {
+      get { if ((_hasBits0 & 32) != 0) { return normCenterX_; } else { return NormCenterXDefaultValue; } }
+      set {
+        _hasBits0 |= 32;
+        normCenterX_ = value;
+      }
+    }
+    /// <summary>Gets whether the "norm_center_x" field is set</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public bool HasNormCenterX {
+      get { return (_hasBits0 & 32) != 0; }
+    }
+    /// <summary>Clears the value of the "norm_center_x" field</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public void ClearNormCenterX() {
+      _hasBits0 &= ~32;
+    }
+
+    /// <summary>Field number for the "norm_center_y" field.</summary>
+    public const int NormCenterYFieldNumber = 7;
+    private readonly static float NormCenterYDefaultValue = 0F;
+
+    private float normCenterY_;
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public float NormCenterY {
+      get { if ((_hasBits0 & 64) != 0) { return normCenterY_; } else { return NormCenterYDefaultValue; } }
+      set {
+        _hasBits0 |= 64;
+        normCenterY_ = value;
+      }
+    }
+    /// <summary>Gets whether the "norm_center_y" field is set</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public bool HasNormCenterY {
+      get { return (_hasBits0 & 64) != 0; }
+    }
+    /// <summary>Clears the value of the "norm_center_y" field</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public void ClearNormCenterY() {
+      _hasBits0 &= ~64;
+    }
+
+    /// <summary>Field number for the "border_mode" field.</summary>
+    public const int BorderModeFieldNumber = 8;
+    private readonly static global::Mediapipe.ImageCroppingCalculatorOptions.Types.BorderMode BorderModeDefaultValue = global::Mediapipe.ImageCroppingCalculatorOptions.Types.BorderMode.BorderZero;
+
+    private global::Mediapipe.ImageCroppingCalculatorOptions.Types.BorderMode borderMode_;
+    /// <summary>
+    /// Specifies behaviour for crops that go beyond image borders.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public global::Mediapipe.ImageCroppingCalculatorOptions.Types.BorderMode BorderMode {
+      get { if ((_hasBits0 & 128) != 0) { return borderMode_; } else { return BorderModeDefaultValue; } }
+      set {
+        _hasBits0 |= 128;
+        borderMode_ = value;
+      }
+    }
+    /// <summary>Gets whether the "border_mode" field is set</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public bool HasBorderMode {
+      get { return (_hasBits0 & 128) != 0; }
+    }
+    /// <summary>Clears the value of the "border_mode" field</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public void ClearBorderMode() {
+      _hasBits0 &= ~128;
+    }
+
+    /// <summary>Field number for the "output_max_width" field.</summary>
+    public const int OutputMaxWidthFieldNumber = 9;
+    private readonly static int OutputMaxWidthDefaultValue = 0;
+
+    private int outputMaxWidth_;
+    /// <summary>
+    /// Specifies limits for the size of the output image. It will be scaled down,
+    /// preserving ratio, to fit within. These do not change which area of the
+    /// input is selected for cropping.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public int OutputMaxWidth {
+      get { if ((_hasBits0 & 256) != 0) { return outputMaxWidth_; } else { return OutputMaxWidthDefaultValue; } }
+      set {
+        _hasBits0 |= 256;
+        outputMaxWidth_ = value;
+      }
+    }
+    /// <summary>Gets whether the "output_max_width" field is set</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public bool HasOutputMaxWidth {
+      get { return (_hasBits0 & 256) != 0; }
+    }
+    /// <summary>Clears the value of the "output_max_width" field</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public void ClearOutputMaxWidth() {
+      _hasBits0 &= ~256;
+    }
+
+    /// <summary>Field number for the "output_max_height" field.</summary>
+    public const int OutputMaxHeightFieldNumber = 10;
+    private readonly static int OutputMaxHeightDefaultValue = 0;
+
+    private int outputMaxHeight_;
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public int OutputMaxHeight {
+      get { if ((_hasBits0 & 512) != 0) { return outputMaxHeight_; } else { return OutputMaxHeightDefaultValue; } }
+      set {
+        _hasBits0 |= 512;
+        outputMaxHeight_ = value;
+      }
+    }
+    /// <summary>Gets whether the "output_max_height" field is set</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public bool HasOutputMaxHeight {
+      get { return (_hasBits0 & 512) != 0; }
+    }
+    /// <summary>Clears the value of the "output_max_height" field</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public void ClearOutputMaxHeight() {
+      _hasBits0 &= ~512;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public override bool Equals(object other) {
+      return Equals(other as ImageCroppingCalculatorOptions);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public bool Equals(ImageCroppingCalculatorOptions other) {
+      if (ReferenceEquals(other, null)) {
+        return false;
+      }
+      if (ReferenceEquals(other, this)) {
+        return true;
+      }
+      if (Width != other.Width) return false;
+      if (Height != other.Height) return false;
+      if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(Rotation, other.Rotation)) return false;
+      if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(NormWidth, other.NormWidth)) return false;
+      if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(NormHeight, other.NormHeight)) return false;
+      if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(NormCenterX, other.NormCenterX)) return false;
+      if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(NormCenterY, other.NormCenterY)) return false;
+      if (BorderMode != other.BorderMode) return false;
+      if (OutputMaxWidth != other.OutputMaxWidth) return false;
+      if (OutputMaxHeight != other.OutputMaxHeight) return false;
+      return Equals(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public override int GetHashCode() {
+      int hash = 1;
+      if (HasWidth) hash ^= Width.GetHashCode();
+      if (HasHeight) hash ^= Height.GetHashCode();
+      if (HasRotation) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(Rotation);
+      if (HasNormWidth) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(NormWidth);
+      if (HasNormHeight) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(NormHeight);
+      if (HasNormCenterX) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(NormCenterX);
+      if (HasNormCenterY) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(NormCenterY);
+      if (HasBorderMode) hash ^= BorderMode.GetHashCode();
+      if (HasOutputMaxWidth) hash ^= OutputMaxWidth.GetHashCode();
+      if (HasOutputMaxHeight) hash ^= OutputMaxHeight.GetHashCode();
+      if (_unknownFields != null) {
+        hash ^= _unknownFields.GetHashCode();
+      }
+      return hash;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public override string ToString() {
+      return pb::JsonFormatter.ToDiagnosticString(this);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public void WriteTo(pb::CodedOutputStream output) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      output.WriteRawMessage(this);
+    #else
+      if (HasWidth) {
+        output.WriteRawTag(8);
+        output.WriteInt32(Width);
+      }
+      if (HasHeight) {
+        output.WriteRawTag(16);
+        output.WriteInt32(Height);
+      }
+      if (HasRotation) {
+        output.WriteRawTag(29);
+        output.WriteFloat(Rotation);
+      }
+      if (HasNormWidth) {
+        output.WriteRawTag(37);
+        output.WriteFloat(NormWidth);
+      }
+      if (HasNormHeight) {
+        output.WriteRawTag(45);
+        output.WriteFloat(NormHeight);
+      }
+      if (HasNormCenterX) {
+        output.WriteRawTag(53);
+        output.WriteFloat(NormCenterX);
+      }
+      if (HasNormCenterY) {
+        output.WriteRawTag(61);
+        output.WriteFloat(NormCenterY);
+      }
+      if (HasBorderMode) {
+        output.WriteRawTag(64);
+        output.WriteEnum((int) BorderMode);
+      }
+      if (HasOutputMaxWidth) {
+        output.WriteRawTag(72);
+        output.WriteInt32(OutputMaxWidth);
+      }
+      if (HasOutputMaxHeight) {
+        output.WriteRawTag(80);
+        output.WriteInt32(OutputMaxHeight);
+      }
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(output);
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+      if (HasWidth) {
+        output.WriteRawTag(8);
+        output.WriteInt32(Width);
+      }
+      if (HasHeight) {
+        output.WriteRawTag(16);
+        output.WriteInt32(Height);
+      }
+      if (HasRotation) {
+        output.WriteRawTag(29);
+        output.WriteFloat(Rotation);
+      }
+      if (HasNormWidth) {
+        output.WriteRawTag(37);
+        output.WriteFloat(NormWidth);
+      }
+      if (HasNormHeight) {
+        output.WriteRawTag(45);
+        output.WriteFloat(NormHeight);
+      }
+      if (HasNormCenterX) {
+        output.WriteRawTag(53);
+        output.WriteFloat(NormCenterX);
+      }
+      if (HasNormCenterY) {
+        output.WriteRawTag(61);
+        output.WriteFloat(NormCenterY);
+      }
+      if (HasBorderMode) {
+        output.WriteRawTag(64);
+        output.WriteEnum((int) BorderMode);
+      }
+      if (HasOutputMaxWidth) {
+        output.WriteRawTag(72);
+        output.WriteInt32(OutputMaxWidth);
+      }
+      if (HasOutputMaxHeight) {
+        output.WriteRawTag(80);
+        output.WriteInt32(OutputMaxHeight);
+      }
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(ref output);
+      }
+    }
+    #endif
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public int CalculateSize() {
+      int size = 0;
+      if (HasWidth) {
+        size += 1 + pb::CodedOutputStream.ComputeInt32Size(Width);
+      }
+      if (HasHeight) {
+        size += 1 + pb::CodedOutputStream.ComputeInt32Size(Height);
+      }
+      if (HasRotation) {
+        size += 1 + 4;
+      }
+      if (HasNormWidth) {
+        size += 1 + 4;
+      }
+      if (HasNormHeight) {
+        size += 1 + 4;
+      }
+      if (HasNormCenterX) {
+        size += 1 + 4;
+      }
+      if (HasNormCenterY) {
+        size += 1 + 4;
+      }
+      if (HasBorderMode) {
+        size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) BorderMode);
+      }
+      if (HasOutputMaxWidth) {
+        size += 1 + pb::CodedOutputStream.ComputeInt32Size(OutputMaxWidth);
+      }
+      if (HasOutputMaxHeight) {
+        size += 1 + pb::CodedOutputStream.ComputeInt32Size(OutputMaxHeight);
+      }
+      if (_unknownFields != null) {
+        size += _unknownFields.CalculateSize();
+      }
+      return size;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public void MergeFrom(ImageCroppingCalculatorOptions other) {
+      if (other == null) {
+        return;
+      }
+      if (other.HasWidth) {
+        Width = other.Width;
+      }
+      if (other.HasHeight) {
+        Height = other.Height;
+      }
+      if (other.HasRotation) {
+        Rotation = other.Rotation;
+      }
+      if (other.HasNormWidth) {
+        NormWidth = other.NormWidth;
+      }
+      if (other.HasNormHeight) {
+        NormHeight = other.NormHeight;
+      }
+      if (other.HasNormCenterX) {
+        NormCenterX = other.NormCenterX;
+      }
+      if (other.HasNormCenterY) {
+        NormCenterY = other.NormCenterY;
+      }
+      if (other.HasBorderMode) {
+        BorderMode = other.BorderMode;
+      }
+      if (other.HasOutputMaxWidth) {
+        OutputMaxWidth = other.OutputMaxWidth;
+      }
+      if (other.HasOutputMaxHeight) {
+        OutputMaxHeight = other.OutputMaxHeight;
+      }
+      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public void MergeFrom(pb::CodedInputStream input) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      input.ReadRawMessage(this);
+    #else
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
+            break;
+          case 8: {
+            Width = input.ReadInt32();
+            break;
+          }
+          case 16: {
+            Height = input.ReadInt32();
+            break;
+          }
+          case 29: {
+            Rotation = input.ReadFloat();
+            break;
+          }
+          case 37: {
+            NormWidth = input.ReadFloat();
+            break;
+          }
+          case 45: {
+            NormHeight = input.ReadFloat();
+            break;
+          }
+          case 53: {
+            NormCenterX = input.ReadFloat();
+            break;
+          }
+          case 61: {
+            NormCenterY = input.ReadFloat();
+            break;
+          }
+          case 64: {
+            BorderMode = (global::Mediapipe.ImageCroppingCalculatorOptions.Types.BorderMode) input.ReadEnum();
+            break;
+          }
+          case 72: {
+            OutputMaxWidth = input.ReadInt32();
+            break;
+          }
+          case 80: {
+            OutputMaxHeight = input.ReadInt32();
+            break;
+          }
+        }
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
+            break;
+          case 8: {
+            Width = input.ReadInt32();
+            break;
+          }
+          case 16: {
+            Height = input.ReadInt32();
+            break;
+          }
+          case 29: {
+            Rotation = input.ReadFloat();
+            break;
+          }
+          case 37: {
+            NormWidth = input.ReadFloat();
+            break;
+          }
+          case 45: {
+            NormHeight = input.ReadFloat();
+            break;
+          }
+          case 53: {
+            NormCenterX = input.ReadFloat();
+            break;
+          }
+          case 61: {
+            NormCenterY = input.ReadFloat();
+            break;
+          }
+          case 64: {
+            BorderMode = (global::Mediapipe.ImageCroppingCalculatorOptions.Types.BorderMode) input.ReadEnum();
+            break;
+          }
+          case 72: {
+            OutputMaxWidth = input.ReadInt32();
+            break;
+          }
+          case 80: {
+            OutputMaxHeight = input.ReadInt32();
+            break;
+          }
+        }
+      }
+    }
+    #endif
+
+    #region Nested types
+    /// <summary>Container for nested types declared in the ImageCroppingCalculatorOptions message type.</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public static partial class Types {
+      public enum BorderMode {
+        /// <summary>
+        /// First unspecified value is required by the guideline. See details here:
+        /// https://developers.google.com/protocol-buffers/docs/style#enums
+        /// </summary>
+        [pbr::OriginalName("BORDER_UNSPECIFIED")] BorderUnspecified = 0,
+        [pbr::OriginalName("BORDER_ZERO")] BorderZero = 1,
+        [pbr::OriginalName("BORDER_REPLICATE")] BorderReplicate = 2,
+      }
+
+    }
+    #endregion
+
+    #region Extensions
+    /// <summary>Container for extensions for other messages declared in the ImageCroppingCalculatorOptions message type.</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public static partial class Extensions {
+      public static readonly pb::Extension<global::Mediapipe.CalculatorOptions, global::Mediapipe.ImageCroppingCalculatorOptions> Ext =
+        new pb::Extension<global::Mediapipe.CalculatorOptions, global::Mediapipe.ImageCroppingCalculatorOptions>(262466399, pb::FieldCodec.ForMessage(2099731194, global::Mediapipe.ImageCroppingCalculatorOptions.Parser));
+    }
+    #endregion
+
+  }
+
+  #endregion
+
+}
+
+#endregion Designer generated code

Packages/com.github.homuler.mediapipe/Runtime/Scripts/Protobuf/Calculators/Image/ImageCroppingCalculator.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: a13242744088532bda684750c576515a
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.github.homuler.mediapipe/Runtime/Scripts/Protobuf/Calculators/Image/ImageTransformationCalculator.cs

@@ -0,0 +1,602 @@
+// <auto-generated>
+//     Generated by the protocol buffer compiler.  DO NOT EDIT!
+//     source: mediapipe/calculators/image/image_transformation_calculator.proto
+// </auto-generated>
+#pragma warning disable 1591, 0612, 3021
+#region Designer generated code
+
+using pb = global::Google.Protobuf;
+using pbc = global::Google.Protobuf.Collections;
+using pbr = global::Google.Protobuf.Reflection;
+using scg = global::System.Collections.Generic;
+namespace Mediapipe {
+
+  /// <summary>Holder for reflection information generated from mediapipe/calculators/image/image_transformation_calculator.proto</summary>
+  public static partial class ImageTransformationCalculatorReflection {
+
+    #region Descriptor
+    /// <summary>File descriptor for mediapipe/calculators/image/image_transformation_calculator.proto</summary>
+    public static pbr::FileDescriptor Descriptor {
+      get { return descriptor; }
+    }
+    private static pbr::FileDescriptor descriptor;
+
+    static ImageTransformationCalculatorReflection() {
+      byte[] descriptorData = global::System.Convert.FromBase64String(
+          string.Concat(
+            "CkFtZWRpYXBpcGUvY2FsY3VsYXRvcnMvaW1hZ2UvaW1hZ2VfdHJhbnNmb3Jt",
+            "YXRpb25fY2FsY3VsYXRvci5wcm90bxIJbWVkaWFwaXBlGi9tZWRpYXBpcGUv",
+            "Y2FsY3VsYXRvcnMvaW1hZ2Uvcm90YXRpb25fbW9kZS5wcm90bxokbWVkaWFw",
+            "aXBlL2ZyYW1ld29yay9jYWxjdWxhdG9yLnByb3RvGh5tZWRpYXBpcGUvZ3B1",
+            "L3NjYWxlX21vZGUucHJvdG8i/gIKJEltYWdlVHJhbnNmb3JtYXRpb25DYWxj",
+            "dWxhdG9yT3B0aW9ucxIXCgxvdXRwdXRfd2lkdGgYASABKAU6ATASGAoNb3V0",
+            "cHV0X2hlaWdodBgCIAEoBToBMBIzCg1yb3RhdGlvbl9tb2RlGAMgASgOMhwu",
+            "bWVkaWFwaXBlLlJvdGF0aW9uTW9kZS5Nb2RlEh4KD2ZsaXBfdmVydGljYWxs",
+            "eRgEIAEoCDoFZmFsc2USIAoRZmxpcF9ob3Jpem9udGFsbHkYBSABKAg6BWZh",
+            "bHNlEi0KCnNjYWxlX21vZGUYBiABKA4yGS5tZWRpYXBpcGUuU2NhbGVNb2Rl",
+            "Lk1vZGUSHgoQY29uc3RhbnRfcGFkZGluZxgHIAEoCDoEdHJ1ZTJdCgNleHQS",
+            "HC5tZWRpYXBpcGUuQ2FsY3VsYXRvck9wdGlvbnMYvv2ReCABKAsyLy5tZWRp",
+            "YXBpcGUuSW1hZ2VUcmFuc2Zvcm1hdGlvbkNhbGN1bGF0b3JPcHRpb25z"));
+      descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData,
+          new pbr::FileDescriptor[] { global::Mediapipe.RotationModeReflection.Descriptor, global::Mediapipe.CalculatorReflection.Descriptor, global::Mediapipe.ScaleModeReflection.Descriptor, },
+          new pbr::GeneratedClrTypeInfo(null, null, new pbr::GeneratedClrTypeInfo[] {
+            new pbr::GeneratedClrTypeInfo(typeof(global::Mediapipe.ImageTransformationCalculatorOptions), global::Mediapipe.ImageTransformationCalculatorOptions.Parser, new[]{ "OutputWidth", "OutputHeight", "RotationMode", "FlipVertically", "FlipHorizontally", "ScaleMode", "ConstantPadding" }, null, null, new pb::Extension[] { global::Mediapipe.ImageTransformationCalculatorOptions.Extensions.Ext }, null)
+          }));
+    }
+    #endregion
+
+  }
+  #region Messages
+  public sealed partial class ImageTransformationCalculatorOptions : pb::IMessage<ImageTransformationCalculatorOptions>
+  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      , pb::IBufferMessage
+  #endif
+  {
+    private static readonly pb::MessageParser<ImageTransformationCalculatorOptions> _parser = new pb::MessageParser<ImageTransformationCalculatorOptions>(() => new ImageTransformationCalculatorOptions());
+    private pb::UnknownFieldSet _unknownFields;
+    private int _hasBits0;
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public static pb::MessageParser<ImageTransformationCalculatorOptions> Parser { get { return _parser; } }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public static pbr::MessageDescriptor Descriptor {
+      get { return global::Mediapipe.ImageTransformationCalculatorReflection.Descriptor.MessageTypes[0]; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    pbr::MessageDescriptor pb::IMessage.Descriptor {
+      get { return Descriptor; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public ImageTransformationCalculatorOptions() {
+      OnConstruction();
+    }
+
+    partial void OnConstruction();
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public ImageTransformationCalculatorOptions(ImageTransformationCalculatorOptions other) : this() {
+      _hasBits0 = other._hasBits0;
+      outputWidth_ = other.outputWidth_;
+      outputHeight_ = other.outputHeight_;
+      rotationMode_ = other.rotationMode_;
+      flipVertically_ = other.flipVertically_;
+      flipHorizontally_ = other.flipHorizontally_;
+      scaleMode_ = other.scaleMode_;
+      constantPadding_ = other.constantPadding_;
+      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public ImageTransformationCalculatorOptions Clone() {
+      return new ImageTransformationCalculatorOptions(this);
+    }
+
+    /// <summary>Field number for the "output_width" field.</summary>
+    public const int OutputWidthFieldNumber = 1;
+    private readonly static int OutputWidthDefaultValue = 0;
+
+    private int outputWidth_;
+    /// <summary>
+    /// Output dimensions. Set to 0 if they should be the same as the input.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public int OutputWidth {
+      get { if ((_hasBits0 & 1) != 0) { return outputWidth_; } else { return OutputWidthDefaultValue; } }
+      set {
+        _hasBits0 |= 1;
+        outputWidth_ = value;
+      }
+    }
+    /// <summary>Gets whether the "output_width" field is set</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public bool HasOutputWidth {
+      get { return (_hasBits0 & 1) != 0; }
+    }
+    /// <summary>Clears the value of the "output_width" field</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public void ClearOutputWidth() {
+      _hasBits0 &= ~1;
+    }
+
+    /// <summary>Field number for the "output_height" field.</summary>
+    public const int OutputHeightFieldNumber = 2;
+    private readonly static int OutputHeightDefaultValue = 0;
+
+    private int outputHeight_;
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public int OutputHeight {
+      get { if ((_hasBits0 & 2) != 0) { return outputHeight_; } else { return OutputHeightDefaultValue; } }
+      set {
+        _hasBits0 |= 2;
+        outputHeight_ = value;
+      }
+    }
+    /// <summary>Gets whether the "output_height" field is set</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public bool HasOutputHeight {
+      get { return (_hasBits0 & 2) != 0; }
+    }
+    /// <summary>Clears the value of the "output_height" field</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public void ClearOutputHeight() {
+      _hasBits0 &= ~2;
+    }
+
+    /// <summary>Field number for the "rotation_mode" field.</summary>
+    public const int RotationModeFieldNumber = 3;
+    private readonly static global::Mediapipe.RotationMode.Types.Mode RotationModeDefaultValue = global::Mediapipe.RotationMode.Types.Mode.Unknown;
+
+    private global::Mediapipe.RotationMode.Types.Mode rotationMode_;
+    /// <summary>
+    /// Counterclockwise rotation mode.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public global::Mediapipe.RotationMode.Types.Mode RotationMode {
+      get { if ((_hasBits0 & 4) != 0) { return rotationMode_; } else { return RotationModeDefaultValue; } }
+      set {
+        _hasBits0 |= 4;
+        rotationMode_ = value;
+      }
+    }
+    /// <summary>Gets whether the "rotation_mode" field is set</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public bool HasRotationMode {
+      get { return (_hasBits0 & 4) != 0; }
+    }
+    /// <summary>Clears the value of the "rotation_mode" field</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public void ClearRotationMode() {
+      _hasBits0 &= ~4;
+    }
+
+    /// <summary>Field number for the "flip_vertically" field.</summary>
+    public const int FlipVerticallyFieldNumber = 4;
+    private readonly static bool FlipVerticallyDefaultValue = false;
+
+    private bool flipVertically_;
+    /// <summary>
+    /// Vertical flipping, applied after rotation.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public bool FlipVertically {
+      get { if ((_hasBits0 & 8) != 0) { return flipVertically_; } else { return FlipVerticallyDefaultValue; } }
+      set {
+        _hasBits0 |= 8;
+        flipVertically_ = value;
+      }
+    }
+    /// <summary>Gets whether the "flip_vertically" field is set</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public bool HasFlipVertically {
+      get { return (_hasBits0 & 8) != 0; }
+    }
+    /// <summary>Clears the value of the "flip_vertically" field</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public void ClearFlipVertically() {
+      _hasBits0 &= ~8;
+    }
+
+    /// <summary>Field number for the "flip_horizontally" field.</summary>
+    public const int FlipHorizontallyFieldNumber = 5;
+    private readonly static bool FlipHorizontallyDefaultValue = false;
+
+    private bool flipHorizontally_;
+    /// <summary>
+    /// Horizontal flipping, applied after rotation.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public bool FlipHorizontally {
+      get { if ((_hasBits0 & 16) != 0) { return flipHorizontally_; } else { return FlipHorizontallyDefaultValue; } }
+      set {
+        _hasBits0 |= 16;
+        flipHorizontally_ = value;
+      }
+    }
+    /// <summary>Gets whether the "flip_horizontally" field is set</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public bool HasFlipHorizontally {
+      get { return (_hasBits0 & 16) != 0; }
+    }
+    /// <summary>Clears the value of the "flip_horizontally" field</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public void ClearFlipHorizontally() {
+      _hasBits0 &= ~16;
+    }
+
+    /// <summary>Field number for the "scale_mode" field.</summary>
+    public const int ScaleModeFieldNumber = 6;
+    private readonly static global::Mediapipe.ScaleMode.Types.Mode ScaleModeDefaultValue = global::Mediapipe.ScaleMode.Types.Mode.Default;
+
+    private global::Mediapipe.ScaleMode.Types.Mode scaleMode_;
+    /// <summary>
+    /// Scale mode.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public global::Mediapipe.ScaleMode.Types.Mode ScaleMode {
+      get { if ((_hasBits0 & 32) != 0) { return scaleMode_; } else { return ScaleModeDefaultValue; } }
+      set {
+        _hasBits0 |= 32;
+        scaleMode_ = value;
+      }
+    }
+    /// <summary>Gets whether the "scale_mode" field is set</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public bool HasScaleMode {
+      get { return (_hasBits0 & 32) != 0; }
+    }
+    /// <summary>Clears the value of the "scale_mode" field</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public void ClearScaleMode() {
+      _hasBits0 &= ~32;
+    }
+
+    /// <summary>Field number for the "constant_padding" field.</summary>
+    public const int ConstantPaddingFieldNumber = 7;
+    private readonly static bool ConstantPaddingDefaultValue = true;
+
+    private bool constantPadding_;
+    /// <summary>
+    /// Padding type. This option is only used when the scale mode is FIT.
+    /// Default is to use BORDER_CONSTANT. If set to false, it will use
+    /// BORDER_REPLICATE instead.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public bool ConstantPadding {
+      get { if ((_hasBits0 & 64) != 0) { return constantPadding_; } else { return ConstantPaddingDefaultValue; } }
+      set {
+        _hasBits0 |= 64;
+        constantPadding_ = value;
+      }
+    }
+    /// <summary>Gets whether the "constant_padding" field is set</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public bool HasConstantPadding {
+      get { return (_hasBits0 & 64) != 0; }
+    }
+    /// <summary>Clears the value of the "constant_padding" field</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public void ClearConstantPadding() {
+      _hasBits0 &= ~64;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public override bool Equals(object other) {
+      return Equals(other as ImageTransformationCalculatorOptions);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public bool Equals(ImageTransformationCalculatorOptions other) {
+      if (ReferenceEquals(other, null)) {
+        return false;
+      }
+      if (ReferenceEquals(other, this)) {
+        return true;
+      }
+      if (OutputWidth != other.OutputWidth) return false;
+      if (OutputHeight != other.OutputHeight) return false;
+      if (RotationMode != other.RotationMode) return false;
+      if (FlipVertically != other.FlipVertically) return false;
+      if (FlipHorizontally != other.FlipHorizontally) return false;
+      if (ScaleMode != other.ScaleMode) return false;
+      if (ConstantPadding != other.ConstantPadding) return false;
+      return Equals(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public override int GetHashCode() {
+      int hash = 1;
+      if (HasOutputWidth) hash ^= OutputWidth.GetHashCode();
+      if (HasOutputHeight) hash ^= OutputHeight.GetHashCode();
+      if (HasRotationMode) hash ^= RotationMode.GetHashCode();
+      if (HasFlipVertically) hash ^= FlipVertically.GetHashCode();
+      if (HasFlipHorizontally) hash ^= FlipHorizontally.GetHashCode();
+      if (HasScaleMode) hash ^= ScaleMode.GetHashCode();
+      if (HasConstantPadding) hash ^= ConstantPadding.GetHashCode();
+      if (_unknownFields != null) {
+        hash ^= _unknownFields.GetHashCode();
+      }
+      return hash;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public override string ToString() {
+      return pb::JsonFormatter.ToDiagnosticString(this);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public void WriteTo(pb::CodedOutputStream output) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      output.WriteRawMessage(this);
+    #else
+      if (HasOutputWidth) {
+        output.WriteRawTag(8);
+        output.WriteInt32(OutputWidth);
+      }
+      if (HasOutputHeight) {
+        output.WriteRawTag(16);
+        output.WriteInt32(OutputHeight);
+      }
+      if (HasRotationMode) {
+        output.WriteRawTag(24);
+        output.WriteEnum((int) RotationMode);
+      }
+      if (HasFlipVertically) {
+        output.WriteRawTag(32);
+        output.WriteBool(FlipVertically);
+      }
+      if (HasFlipHorizontally) {
+        output.WriteRawTag(40);
+        output.WriteBool(FlipHorizontally);
+      }
+      if (HasScaleMode) {
+        output.WriteRawTag(48);
+        output.WriteEnum((int) ScaleMode);
+      }
+      if (HasConstantPadding) {
+        output.WriteRawTag(56);
+        output.WriteBool(ConstantPadding);
+      }
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(output);
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+      if (HasOutputWidth) {
+        output.WriteRawTag(8);
+        output.WriteInt32(OutputWidth);
+      }
+      if (HasOutputHeight) {
+        output.WriteRawTag(16);
+        output.WriteInt32(OutputHeight);
+      }
+      if (HasRotationMode) {
+        output.WriteRawTag(24);
+        output.WriteEnum((int) RotationMode);
+      }
+      if (HasFlipVertically) {
+        output.WriteRawTag(32);
+        output.WriteBool(FlipVertically);
+      }
+      if (HasFlipHorizontally) {
+        output.WriteRawTag(40);
+        output.WriteBool(FlipHorizontally);
+      }
+      if (HasScaleMode) {
+        output.WriteRawTag(48);
+        output.WriteEnum((int) ScaleMode);
+      }
+      if (HasConstantPadding) {
+        output.WriteRawTag(56);
+        output.WriteBool(ConstantPadding);
+      }
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(ref output);
+      }
+    }
+    #endif
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public int CalculateSize() {
+      int size = 0;
+      if (HasOutputWidth) {
+        size += 1 + pb::CodedOutputStream.ComputeInt32Size(OutputWidth);
+      }
+      if (HasOutputHeight) {
+        size += 1 + pb::CodedOutputStream.ComputeInt32Size(OutputHeight);
+      }
+      if (HasRotationMode) {
+        size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) RotationMode);
+      }
+      if (HasFlipVertically) {
+        size += 1 + 1;
+      }
+      if (HasFlipHorizontally) {
+        size += 1 + 1;
+      }
+      if (HasScaleMode) {
+        size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) ScaleMode);
+      }
+      if (HasConstantPadding) {
+        size += 1 + 1;
+      }
+      if (_unknownFields != null) {
+        size += _unknownFields.CalculateSize();
+      }
+      return size;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public void MergeFrom(ImageTransformationCalculatorOptions other) {
+      if (other == null) {
+        return;
+      }
+      if (other.HasOutputWidth) {
+        OutputWidth = other.OutputWidth;
+      }
+      if (other.HasOutputHeight) {
+        OutputHeight = other.OutputHeight;
+      }
+      if (other.HasRotationMode) {
+        RotationMode = other.RotationMode;
+      }
+      if (other.HasFlipVertically) {
+        FlipVertically = other.FlipVertically;
+      }
+      if (other.HasFlipHorizontally) {
+        FlipHorizontally = other.FlipHorizontally;
+      }
+      if (other.HasScaleMode) {
+        ScaleMode = other.ScaleMode;
+      }
+      if (other.HasConstantPadding) {
+        ConstantPadding = other.ConstantPadding;
+      }
+      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public void MergeFrom(pb::CodedInputStream input) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      input.ReadRawMessage(this);
+    #else
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
+            break;
+          case 8: {
+            OutputWidth = input.ReadInt32();
+            break;
+          }
+          case 16: {
+            OutputHeight = input.ReadInt32();
+            break;
+          }
+          case 24: {
+            RotationMode = (global::Mediapipe.RotationMode.Types.Mode) input.ReadEnum();
+            break;
+          }
+          case 32: {
+            FlipVertically = input.ReadBool();
+            break;
+          }
+          case 40: {
+            FlipHorizontally = input.ReadBool();
+            break;
+          }
+          case 48: {
+            ScaleMode = (global::Mediapipe.ScaleMode.Types.Mode) input.ReadEnum();
+            break;
+          }
+          case 56: {
+            ConstantPadding = input.ReadBool();
+            break;
+          }
+        }
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
+            break;
+          case 8: {
+            OutputWidth = input.ReadInt32();
+            break;
+          }
+          case 16: {
+            OutputHeight = input.ReadInt32();
+            break;
+          }
+          case 24: {
+            RotationMode = (global::Mediapipe.RotationMode.Types.Mode) input.ReadEnum();
+            break;
+          }
+          case 32: {
+            FlipVertically = input.ReadBool();
+            break;
+          }
+          case 40: {
+            FlipHorizontally = input.ReadBool();
+            break;
+          }
+          case 48: {
+            ScaleMode = (global::Mediapipe.ScaleMode.Types.Mode) input.ReadEnum();
+            break;
+          }
+          case 56: {
+            ConstantPadding = input.ReadBool();
+            break;
+          }
+        }
+      }
+    }
+    #endif
+
+    #region Extensions
+    /// <summary>Container for extensions for other messages declared in the ImageTransformationCalculatorOptions message type.</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public static partial class Extensions {
+      public static readonly pb::Extension<global::Mediapipe.CalculatorOptions, global::Mediapipe.ImageTransformationCalculatorOptions> Ext =
+        new pb::Extension<global::Mediapipe.CalculatorOptions, global::Mediapipe.ImageTransformationCalculatorOptions>(251952830, pb::FieldCodec.ForMessage(2015622642, global::Mediapipe.ImageTransformationCalculatorOptions.Parser));
+    }
+    #endregion
+
+  }
+
+  #endregion
+
+}
+
+#endregion Designer generated code

Packages/com.github.homuler.mediapipe/Runtime/Scripts/Protobuf/Calculators/Image/ImageTransformationCalculator.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 71cbf43c2d9742dd5bdc4cc767a65e27
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.github.homuler.mediapipe/Runtime/Scripts/Protobuf/Calculators/Image/MaskOverlayCalculator.cs

@@ -0,0 +1,282 @@
+// <auto-generated>
+//     Generated by the protocol buffer compiler.  DO NOT EDIT!
+//     source: mediapipe/calculators/image/mask_overlay_calculator.proto
+// </auto-generated>
+#pragma warning disable 1591, 0612, 3021
+#region Designer generated code
+
+using pb = global::Google.Protobuf;
+using pbc = global::Google.Protobuf.Collections;
+using pbr = global::Google.Protobuf.Reflection;
+using scg = global::System.Collections.Generic;
+namespace Mediapipe {
+
+  /// <summary>Holder for reflection information generated from mediapipe/calculators/image/mask_overlay_calculator.proto</summary>
+  public static partial class MaskOverlayCalculatorReflection {
+
+    #region Descriptor
+    /// <summary>File descriptor for mediapipe/calculators/image/mask_overlay_calculator.proto</summary>
+    public static pbr::FileDescriptor Descriptor {
+      get { return descriptor; }
+    }
+    private static pbr::FileDescriptor descriptor;
+
+    static MaskOverlayCalculatorReflection() {
+      byte[] descriptorData = global::System.Convert.FromBase64String(
+          string.Concat(
+            "CjltZWRpYXBpcGUvY2FsY3VsYXRvcnMvaW1hZ2UvbWFza19vdmVybGF5X2Nh",
+            "bGN1bGF0b3IucHJvdG8SCW1lZGlhcGlwZRokbWVkaWFwaXBlL2ZyYW1ld29y",
+            "ay9jYWxjdWxhdG9yLnByb3RvIvUBChxNYXNrT3ZlcmxheUNhbGN1bGF0b3JP",
+            "cHRpb25zEk4KDG1hc2tfY2hhbm5lbBgBIAEoDjIzLm1lZGlhcGlwZS5NYXNr",
+            "T3ZlcmxheUNhbGN1bGF0b3JPcHRpb25zLk1hc2tDaGFubmVsOgNSRUQiLgoL",
+            "TWFza0NoYW5uZWwSCwoHVU5LTk9XThAAEgcKA1JFRBABEgkKBUFMUEhBEAIy",
+            "VQoDZXh0EhwubWVkaWFwaXBlLkNhbGN1bGF0b3JPcHRpb25zGILgnHggASgL",
+            "MicubWVkaWFwaXBlLk1hc2tPdmVybGF5Q2FsY3VsYXRvck9wdGlvbnM="));
+      descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData,
+          new pbr::FileDescriptor[] { global::Mediapipe.CalculatorReflection.Descriptor, },
+          new pbr::GeneratedClrTypeInfo(null, null, new pbr::GeneratedClrTypeInfo[] {
+            new pbr::GeneratedClrTypeInfo(typeof(global::Mediapipe.MaskOverlayCalculatorOptions), global::Mediapipe.MaskOverlayCalculatorOptions.Parser, new[]{ "MaskChannel" }, null, new[]{ typeof(global::Mediapipe.MaskOverlayCalculatorOptions.Types.MaskChannel) }, new pb::Extension[] { global::Mediapipe.MaskOverlayCalculatorOptions.Extensions.Ext }, null)
+          }));
+    }
+    #endregion
+
+  }
+  #region Messages
+  public sealed partial class MaskOverlayCalculatorOptions : pb::IMessage<MaskOverlayCalculatorOptions>
+  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      , pb::IBufferMessage
+  #endif
+  {
+    private static readonly pb::MessageParser<MaskOverlayCalculatorOptions> _parser = new pb::MessageParser<MaskOverlayCalculatorOptions>(() => new MaskOverlayCalculatorOptions());
+    private pb::UnknownFieldSet _unknownFields;
+    private int _hasBits0;
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public static pb::MessageParser<MaskOverlayCalculatorOptions> Parser { get { return _parser; } }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public static pbr::MessageDescriptor Descriptor {
+      get { return global::Mediapipe.MaskOverlayCalculatorReflection.Descriptor.MessageTypes[0]; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    pbr::MessageDescriptor pb::IMessage.Descriptor {
+      get { return Descriptor; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public MaskOverlayCalculatorOptions() {
+      OnConstruction();
+    }
+
+    partial void OnConstruction();
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public MaskOverlayCalculatorOptions(MaskOverlayCalculatorOptions other) : this() {
+      _hasBits0 = other._hasBits0;
+      maskChannel_ = other.maskChannel_;
+      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public MaskOverlayCalculatorOptions Clone() {
+      return new MaskOverlayCalculatorOptions(this);
+    }
+
+    /// <summary>Field number for the "mask_channel" field.</summary>
+    public const int MaskChannelFieldNumber = 1;
+    private readonly static global::Mediapipe.MaskOverlayCalculatorOptions.Types.MaskChannel MaskChannelDefaultValue = global::Mediapipe.MaskOverlayCalculatorOptions.Types.MaskChannel.Red;
+
+    private global::Mediapipe.MaskOverlayCalculatorOptions.Types.MaskChannel maskChannel_;
+    /// <summary>
+    /// Selects which channel of the MASK input to use for masking.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public global::Mediapipe.MaskOverlayCalculatorOptions.Types.MaskChannel MaskChannel {
+      get { if ((_hasBits0 & 1) != 0) { return maskChannel_; } else { return MaskChannelDefaultValue; } }
+      set {
+        _hasBits0 |= 1;
+        maskChannel_ = value;
+      }
+    }
+    /// <summary>Gets whether the "mask_channel" field is set</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public bool HasMaskChannel {
+      get { return (_hasBits0 & 1) != 0; }
+    }
+    /// <summary>Clears the value of the "mask_channel" field</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public void ClearMaskChannel() {
+      _hasBits0 &= ~1;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public override bool Equals(object other) {
+      return Equals(other as MaskOverlayCalculatorOptions);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public bool Equals(MaskOverlayCalculatorOptions other) {
+      if (ReferenceEquals(other, null)) {
+        return false;
+      }
+      if (ReferenceEquals(other, this)) {
+        return true;
+      }
+      if (MaskChannel != other.MaskChannel) return false;
+      return Equals(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public override int GetHashCode() {
+      int hash = 1;
+      if (HasMaskChannel) hash ^= MaskChannel.GetHashCode();
+      if (_unknownFields != null) {
+        hash ^= _unknownFields.GetHashCode();
+      }
+      return hash;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public override string ToString() {
+      return pb::JsonFormatter.ToDiagnosticString(this);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public void WriteTo(pb::CodedOutputStream output) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      output.WriteRawMessage(this);
+    #else
+      if (HasMaskChannel) {
+        output.WriteRawTag(8);
+        output.WriteEnum((int) MaskChannel);
+      }
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(output);
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+      if (HasMaskChannel) {
+        output.WriteRawTag(8);
+        output.WriteEnum((int) MaskChannel);
+      }
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(ref output);
+      }
+    }
+    #endif
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public int CalculateSize() {
+      int size = 0;
+      if (HasMaskChannel) {
+        size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) MaskChannel);
+      }
+      if (_unknownFields != null) {
+        size += _unknownFields.CalculateSize();
+      }
+      return size;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public void MergeFrom(MaskOverlayCalculatorOptions other) {
+      if (other == null) {
+        return;
+      }
+      if (other.HasMaskChannel) {
+        MaskChannel = other.MaskChannel;
+      }
+      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public void MergeFrom(pb::CodedInputStream input) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      input.ReadRawMessage(this);
+    #else
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
+            break;
+          case 8: {
+            MaskChannel = (global::Mediapipe.MaskOverlayCalculatorOptions.Types.MaskChannel) input.ReadEnum();
+            break;
+          }
+        }
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
+            break;
+          case 8: {
+            MaskChannel = (global::Mediapipe.MaskOverlayCalculatorOptions.Types.MaskChannel) input.ReadEnum();
+            break;
+          }
+        }
+      }
+    }
+    #endif
+
+    #region Nested types
+    /// <summary>Container for nested types declared in the MaskOverlayCalculatorOptions message type.</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public static partial class Types {
+      public enum MaskChannel {
+        [pbr::OriginalName("UNKNOWN")] Unknown = 0,
+        [pbr::OriginalName("RED")] Red = 1,
+        [pbr::OriginalName("ALPHA")] Alpha = 2,
+      }
+
+    }
+    #endregion
+
+    #region Extensions
+    /// <summary>Container for extensions for other messages declared in the MaskOverlayCalculatorOptions message type.</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public static partial class Extensions {
+      public static readonly pb::Extension<global::Mediapipe.CalculatorOptions, global::Mediapipe.MaskOverlayCalculatorOptions> Ext =
+        new pb::Extension<global::Mediapipe.CalculatorOptions, global::Mediapipe.MaskOverlayCalculatorOptions>(252129282, pb::FieldCodec.ForMessage(2017034258, global::Mediapipe.MaskOverlayCalculatorOptions.Parser));
+    }
+    #endregion
+
+  }
+
+  #endregion
+
+}
+
+#endregion Designer generated code

Packages/com.github.homuler.mediapipe/Runtime/Scripts/Protobuf/Calculators/Image/MaskOverlayCalculator.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 93fc4fccc95d0e2309b17186e3a78f13
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.github.homuler.mediapipe/Runtime/Scripts/Protobuf/Calculators/Image/OpencvEncodedImageToImageFrameCalculator.cs

@@ -0,0 +1,270 @@
+// <auto-generated>
+//     Generated by the protocol buffer compiler.  DO NOT EDIT!
+//     source: mediapipe/calculators/image/opencv_encoded_image_to_image_frame_calculator.proto
+// </auto-generated>
+#pragma warning disable 1591, 0612, 3021
+#region Designer generated code
+
+using pb = global::Google.Protobuf;
+using pbc = global::Google.Protobuf.Collections;
+using pbr = global::Google.Protobuf.Reflection;
+using scg = global::System.Collections.Generic;
+namespace Mediapipe {
+
+  /// <summary>Holder for reflection information generated from mediapipe/calculators/image/opencv_encoded_image_to_image_frame_calculator.proto</summary>
+  public static partial class OpencvEncodedImageToImageFrameCalculatorReflection {
+
+    #region Descriptor
+    /// <summary>File descriptor for mediapipe/calculators/image/opencv_encoded_image_to_image_frame_calculator.proto</summary>
+    public static pbr::FileDescriptor Descriptor {
+      get { return descriptor; }
+    }
+    private static pbr::FileDescriptor descriptor;
+
+    static OpencvEncodedImageToImageFrameCalculatorReflection() {
+      byte[] descriptorData = global::System.Convert.FromBase64String(
+          string.Concat(
+            "ClBtZWRpYXBpcGUvY2FsY3VsYXRvcnMvaW1hZ2Uvb3BlbmN2X2VuY29kZWRf",
+            "aW1hZ2VfdG9faW1hZ2VfZnJhbWVfY2FsY3VsYXRvci5wcm90bxIJbWVkaWFw",
+            "aXBlGiRtZWRpYXBpcGUvZnJhbWV3b3JrL2NhbGN1bGF0b3IucHJvdG8izQEK",
+            "L09wZW5DdkVuY29kZWRJbWFnZVRvSW1hZ2VGcmFtZUNhbGN1bGF0b3JPcHRp",
+            "b25zEi8KIGFwcGx5X29yaWVudGF0aW9uX2Zyb21fZXhpZl9kYXRhGAEgASgI",
+            "OgVmYWxzZTJpCgNleHQSHC5tZWRpYXBpcGUuQ2FsY3VsYXRvck9wdGlvbnMY",
+            "jPrYkAEgASgLMjoubWVkaWFwaXBlLk9wZW5DdkVuY29kZWRJbWFnZVRvSW1h",
+            "Z2VGcmFtZUNhbGN1bGF0b3JPcHRpb25z"));
+      descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData,
+          new pbr::FileDescriptor[] { global::Mediapipe.CalculatorReflection.Descriptor, },
+          new pbr::GeneratedClrTypeInfo(null, null, new pbr::GeneratedClrTypeInfo[] {
+            new pbr::GeneratedClrTypeInfo(typeof(global::Mediapipe.OpenCvEncodedImageToImageFrameCalculatorOptions), global::Mediapipe.OpenCvEncodedImageToImageFrameCalculatorOptions.Parser, new[]{ "ApplyOrientationFromExifData" }, null, null, new pb::Extension[] { global::Mediapipe.OpenCvEncodedImageToImageFrameCalculatorOptions.Extensions.Ext }, null)
+          }));
+    }
+    #endregion
+
+  }
+  #region Messages
+  public sealed partial class OpenCvEncodedImageToImageFrameCalculatorOptions : pb::IMessage<OpenCvEncodedImageToImageFrameCalculatorOptions>
+  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      , pb::IBufferMessage
+  #endif
+  {
+    private static readonly pb::MessageParser<OpenCvEncodedImageToImageFrameCalculatorOptions> _parser = new pb::MessageParser<OpenCvEncodedImageToImageFrameCalculatorOptions>(() => new OpenCvEncodedImageToImageFrameCalculatorOptions());
+    private pb::UnknownFieldSet _unknownFields;
+    private int _hasBits0;
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public static pb::MessageParser<OpenCvEncodedImageToImageFrameCalculatorOptions> Parser { get { return _parser; } }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public static pbr::MessageDescriptor Descriptor {
+      get { return global::Mediapipe.OpencvEncodedImageToImageFrameCalculatorReflection.Descriptor.MessageTypes[0]; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    pbr::MessageDescriptor pb::IMessage.Descriptor {
+      get { return Descriptor; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public OpenCvEncodedImageToImageFrameCalculatorOptions() {
+      OnConstruction();
+    }
+
+    partial void OnConstruction();
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public OpenCvEncodedImageToImageFrameCalculatorOptions(OpenCvEncodedImageToImageFrameCalculatorOptions other) : this() {
+      _hasBits0 = other._hasBits0;
+      applyOrientationFromExifData_ = other.applyOrientationFromExifData_;
+      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public OpenCvEncodedImageToImageFrameCalculatorOptions Clone() {
+      return new OpenCvEncodedImageToImageFrameCalculatorOptions(this);
+    }
+
+    /// <summary>Field number for the "apply_orientation_from_exif_data" field.</summary>
+    public const int ApplyOrientationFromExifDataFieldNumber = 1;
+    private readonly static bool ApplyOrientationFromExifDataDefaultValue = false;
+
+    private bool applyOrientationFromExifData_;
+    /// <summary>
+    /// If set, we will attempt to automatically apply the orientation specified by
+    /// the image's EXIF data when loading the image. Otherwise, the image data
+    /// will be loaded as-is.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public bool ApplyOrientationFromExifData {
+      get { if ((_hasBits0 & 1) != 0) { return applyOrientationFromExifData_; } else { return ApplyOrientationFromExifDataDefaultValue; } }
+      set {
+        _hasBits0 |= 1;
+        applyOrientationFromExifData_ = value;
+      }
+    }
+    /// <summary>Gets whether the "apply_orientation_from_exif_data" field is set</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public bool HasApplyOrientationFromExifData {
+      get { return (_hasBits0 & 1) != 0; }
+    }
+    /// <summary>Clears the value of the "apply_orientation_from_exif_data" field</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public void ClearApplyOrientationFromExifData() {
+      _hasBits0 &= ~1;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public override bool Equals(object other) {
+      return Equals(other as OpenCvEncodedImageToImageFrameCalculatorOptions);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public bool Equals(OpenCvEncodedImageToImageFrameCalculatorOptions other) {
+      if (ReferenceEquals(other, null)) {
+        return false;
+      }
+      if (ReferenceEquals(other, this)) {
+        return true;
+      }
+      if (ApplyOrientationFromExifData != other.ApplyOrientationFromExifData) return false;
+      return Equals(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public override int GetHashCode() {
+      int hash = 1;
+      if (HasApplyOrientationFromExifData) hash ^= ApplyOrientationFromExifData.GetHashCode();
+      if (_unknownFields != null) {
+        hash ^= _unknownFields.GetHashCode();
+      }
+      return hash;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public override string ToString() {
+      return pb::JsonFormatter.ToDiagnosticString(this);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public void WriteTo(pb::CodedOutputStream output) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      output.WriteRawMessage(this);
+    #else
+      if (HasApplyOrientationFromExifData) {
+        output.WriteRawTag(8);
+        output.WriteBool(ApplyOrientationFromExifData);
+      }
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(output);
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+      if (HasApplyOrientationFromExifData) {
+        output.WriteRawTag(8);
+        output.WriteBool(ApplyOrientationFromExifData);
+      }
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(ref output);
+      }
+    }
+    #endif
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public int CalculateSize() {
+      int size = 0;
+      if (HasApplyOrientationFromExifData) {
+        size += 1 + 1;
+      }
+      if (_unknownFields != null) {
+        size += _unknownFields.CalculateSize();
+      }
+      return size;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public void MergeFrom(OpenCvEncodedImageToImageFrameCalculatorOptions other) {
+      if (other == null) {
+        return;
+      }
+      if (other.HasApplyOrientationFromExifData) {
+        ApplyOrientationFromExifData = other.ApplyOrientationFromExifData;
+      }
+      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public void MergeFrom(pb::CodedInputStream input) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      input.ReadRawMessage(this);
+    #else
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
+            break;
+          case 8: {
+            ApplyOrientationFromExifData = input.ReadBool();
+            break;
+          }
+        }
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
+            break;
+          case 8: {
+            ApplyOrientationFromExifData = input.ReadBool();
+            break;
+          }
+        }
+      }
+    }
+    #endif
+
+    #region Extensions
+    /// <summary>Container for extensions for other messages declared in the OpenCvEncodedImageToImageFrameCalculatorOptions message type.</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public static partial class Extensions {
+      public static readonly pb::Extension<global::Mediapipe.CalculatorOptions, global::Mediapipe.OpenCvEncodedImageToImageFrameCalculatorOptions> Ext =
+        new pb::Extension<global::Mediapipe.CalculatorOptions, global::Mediapipe.OpenCvEncodedImageToImageFrameCalculatorOptions>(303447308, pb::FieldCodec.ForMessage(2427578466, global::Mediapipe.OpenCvEncodedImageToImageFrameCalculatorOptions.Parser));
+    }
+    #endregion
+
+  }
+
+  #endregion
+
+}
+
+#endregion Designer generated code

Packages/com.github.homuler.mediapipe/Runtime/Scripts/Protobuf/Calculators/Image/OpencvEncodedImageToImageFrameCalculator.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: f36ff1b55f4876f6299dc7fb94d67ad4
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.github.homuler.mediapipe/Runtime/Scripts/Protobuf/Calculators/Image/OpencvImageEncoderCalculator.cs

@@ -0,0 +1,662 @@
+// <auto-generated>
+//     Generated by the protocol buffer compiler.  DO NOT EDIT!
+//     source: mediapipe/calculators/image/opencv_image_encoder_calculator.proto
+// </auto-generated>
+#pragma warning disable 1591, 0612, 3021
+#region Designer generated code
+
+using pb = global::Google.Protobuf;
+using pbc = global::Google.Protobuf.Collections;
+using pbr = global::Google.Protobuf.Reflection;
+using scg = global::System.Collections.Generic;
+namespace Mediapipe {
+
+  /// <summary>Holder for reflection information generated from mediapipe/calculators/image/opencv_image_encoder_calculator.proto</summary>
+  public static partial class OpencvImageEncoderCalculatorReflection {
+
+    #region Descriptor
+    /// <summary>File descriptor for mediapipe/calculators/image/opencv_image_encoder_calculator.proto</summary>
+    public static pbr::FileDescriptor Descriptor {
+      get { return descriptor; }
+    }
+    private static pbr::FileDescriptor descriptor;
+
+    static OpencvImageEncoderCalculatorReflection() {
+      byte[] descriptorData = global::System.Convert.FromBase64String(
+          string.Concat(
+            "CkFtZWRpYXBpcGUvY2FsY3VsYXRvcnMvaW1hZ2Uvb3BlbmN2X2ltYWdlX2Vu",
+            "Y29kZXJfY2FsY3VsYXRvci5wcm90bxIJbWVkaWFwaXBlGiRtZWRpYXBpcGUv",
+            "ZnJhbWV3b3JrL2NhbGN1bGF0b3IucHJvdG8ilAEKI09wZW5DdkltYWdlRW5j",
+            "b2RlckNhbGN1bGF0b3JPcHRpb25zEg8KB3F1YWxpdHkYASABKAUyXAoDZXh0",
+            "EhwubWVkaWFwaXBlLkNhbGN1bGF0b3JPcHRpb25zGP6wwWwgASgLMi4ubWVk",
+            "aWFwaXBlLk9wZW5DdkltYWdlRW5jb2RlckNhbGN1bGF0b3JPcHRpb25zIt0B",
+            "CiNPcGVuQ3ZJbWFnZUVuY29kZXJDYWxjdWxhdG9yUmVzdWx0cxIVCg1lbmNv",
+            "ZGVkX2ltYWdlGAEgASgMEg4KBmhlaWdodBgCIAEoBRINCgV3aWR0aBgDIAEo",
+            "BRJNCgpjb2xvcnNwYWNlGAQgASgOMjkubWVkaWFwaXBlLk9wZW5DdkltYWdl",
+            "RW5jb2RlckNhbGN1bGF0b3JSZXN1bHRzLkNvbG9yU3BhY2UiMQoKQ29sb3JT",
+            "cGFjZRILCgdVTktOT1dOEAASDQoJR1JBWVNDQUxFEAESBwoDUkdCEAI="));
+      descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData,
+          new pbr::FileDescriptor[] { global::Mediapipe.CalculatorReflection.Descriptor, },
+          new pbr::GeneratedClrTypeInfo(null, null, new pbr::GeneratedClrTypeInfo[] {
+            new pbr::GeneratedClrTypeInfo(typeof(global::Mediapipe.OpenCvImageEncoderCalculatorOptions), global::Mediapipe.OpenCvImageEncoderCalculatorOptions.Parser, new[]{ "Quality" }, null, null, new pb::Extension[] { global::Mediapipe.OpenCvImageEncoderCalculatorOptions.Extensions.Ext }, null),
+            new pbr::GeneratedClrTypeInfo(typeof(global::Mediapipe.OpenCvImageEncoderCalculatorResults), global::Mediapipe.OpenCvImageEncoderCalculatorResults.Parser, new[]{ "EncodedImage", "Height", "Width", "Colorspace" }, null, new[]{ typeof(global::Mediapipe.OpenCvImageEncoderCalculatorResults.Types.ColorSpace) }, null, null)
+          }));
+    }
+    #endregion
+
+  }
+  #region Messages
+  public sealed partial class OpenCvImageEncoderCalculatorOptions : pb::IMessage<OpenCvImageEncoderCalculatorOptions>
+  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      , pb::IBufferMessage
+  #endif
+  {
+    private static readonly pb::MessageParser<OpenCvImageEncoderCalculatorOptions> _parser = new pb::MessageParser<OpenCvImageEncoderCalculatorOptions>(() => new OpenCvImageEncoderCalculatorOptions());
+    private pb::UnknownFieldSet _unknownFields;
+    private int _hasBits0;
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public static pb::MessageParser<OpenCvImageEncoderCalculatorOptions> Parser { get { return _parser; } }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public static pbr::MessageDescriptor Descriptor {
+      get { return global::Mediapipe.OpencvImageEncoderCalculatorReflection.Descriptor.MessageTypes[0]; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    pbr::MessageDescriptor pb::IMessage.Descriptor {
+      get { return Descriptor; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public OpenCvImageEncoderCalculatorOptions() {
+      OnConstruction();
+    }
+
+    partial void OnConstruction();
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public OpenCvImageEncoderCalculatorOptions(OpenCvImageEncoderCalculatorOptions other) : this() {
+      _hasBits0 = other._hasBits0;
+      quality_ = other.quality_;
+      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public OpenCvImageEncoderCalculatorOptions Clone() {
+      return new OpenCvImageEncoderCalculatorOptions(this);
+    }
+
+    /// <summary>Field number for the "quality" field.</summary>
+    public const int QualityFieldNumber = 1;
+    private readonly static int QualityDefaultValue = 0;
+
+    private int quality_;
+    /// <summary>
+    /// Quality of the encoding. An integer between (0, 100].
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public int Quality {
+      get { if ((_hasBits0 & 1) != 0) { return quality_; } else { return QualityDefaultValue; } }
+      set {
+        _hasBits0 |= 1;
+        quality_ = value;
+      }
+    }
+    /// <summary>Gets whether the "quality" field is set</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public bool HasQuality {
+      get { return (_hasBits0 & 1) != 0; }
+    }
+    /// <summary>Clears the value of the "quality" field</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public void ClearQuality() {
+      _hasBits0 &= ~1;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public override bool Equals(object other) {
+      return Equals(other as OpenCvImageEncoderCalculatorOptions);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public bool Equals(OpenCvImageEncoderCalculatorOptions other) {
+      if (ReferenceEquals(other, null)) {
+        return false;
+      }
+      if (ReferenceEquals(other, this)) {
+        return true;
+      }
+      if (Quality != other.Quality) return false;
+      return Equals(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public override int GetHashCode() {
+      int hash = 1;
+      if (HasQuality) hash ^= Quality.GetHashCode();
+      if (_unknownFields != null) {
+        hash ^= _unknownFields.GetHashCode();
+      }
+      return hash;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public override string ToString() {
+      return pb::JsonFormatter.ToDiagnosticString(this);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public void WriteTo(pb::CodedOutputStream output) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      output.WriteRawMessage(this);
+    #else
+      if (HasQuality) {
+        output.WriteRawTag(8);
+        output.WriteInt32(Quality);
+      }
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(output);
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+      if (HasQuality) {
+        output.WriteRawTag(8);
+        output.WriteInt32(Quality);
+      }
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(ref output);
+      }
+    }
+    #endif
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public int CalculateSize() {
+      int size = 0;
+      if (HasQuality) {
+        size += 1 + pb::CodedOutputStream.ComputeInt32Size(Quality);
+      }
+      if (_unknownFields != null) {
+        size += _unknownFields.CalculateSize();
+      }
+      return size;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public void MergeFrom(OpenCvImageEncoderCalculatorOptions other) {
+      if (other == null) {
+        return;
+      }
+      if (other.HasQuality) {
+        Quality = other.Quality;
+      }
+      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public void MergeFrom(pb::CodedInputStream input) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      input.ReadRawMessage(this);
+    #else
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
+            break;
+          case 8: {
+            Quality = input.ReadInt32();
+            break;
+          }
+        }
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
+            break;
+          case 8: {
+            Quality = input.ReadInt32();
+            break;
+          }
+        }
+      }
+    }
+    #endif
+
+    #region Extensions
+    /// <summary>Container for extensions for other messages declared in the OpenCvImageEncoderCalculatorOptions message type.</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public static partial class Extensions {
+      public static readonly pb::Extension<global::Mediapipe.CalculatorOptions, global::Mediapipe.OpenCvImageEncoderCalculatorOptions> Ext =
+        new pb::Extension<global::Mediapipe.CalculatorOptions, global::Mediapipe.OpenCvImageEncoderCalculatorOptions>(227563646, pb::FieldCodec.ForMessage(1820509170, global::Mediapipe.OpenCvImageEncoderCalculatorOptions.Parser));
+    }
+    #endregion
+
+  }
+
+  /// <summary>
+  /// TODO: Consider renaming it to EncodedImage.
+  /// </summary>
+  public sealed partial class OpenCvImageEncoderCalculatorResults : pb::IMessage<OpenCvImageEncoderCalculatorResults>
+  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      , pb::IBufferMessage
+  #endif
+  {
+    private static readonly pb::MessageParser<OpenCvImageEncoderCalculatorResults> _parser = new pb::MessageParser<OpenCvImageEncoderCalculatorResults>(() => new OpenCvImageEncoderCalculatorResults());
+    private pb::UnknownFieldSet _unknownFields;
+    private int _hasBits0;
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public static pb::MessageParser<OpenCvImageEncoderCalculatorResults> Parser { get { return _parser; } }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public static pbr::MessageDescriptor Descriptor {
+      get { return global::Mediapipe.OpencvImageEncoderCalculatorReflection.Descriptor.MessageTypes[1]; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    pbr::MessageDescriptor pb::IMessage.Descriptor {
+      get { return Descriptor; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public OpenCvImageEncoderCalculatorResults() {
+      OnConstruction();
+    }
+
+    partial void OnConstruction();
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public OpenCvImageEncoderCalculatorResults(OpenCvImageEncoderCalculatorResults other) : this() {
+      _hasBits0 = other._hasBits0;
+      encodedImage_ = other.encodedImage_;
+      height_ = other.height_;
+      width_ = other.width_;
+      colorspace_ = other.colorspace_;
+      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public OpenCvImageEncoderCalculatorResults Clone() {
+      return new OpenCvImageEncoderCalculatorResults(this);
+    }
+
+    /// <summary>Field number for the "encoded_image" field.</summary>
+    public const int EncodedImageFieldNumber = 1;
+    private readonly static pb::ByteString EncodedImageDefaultValue = pb::ByteString.Empty;
+
+    private pb::ByteString encodedImage_;
+    /// <summary>
+    /// Pixel data encoded as JPEG.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public pb::ByteString EncodedImage {
+      get { return encodedImage_ ?? EncodedImageDefaultValue; }
+      set {
+        encodedImage_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
+      }
+    }
+    /// <summary>Gets whether the "encoded_image" field is set</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public bool HasEncodedImage {
+      get { return encodedImage_ != null; }
+    }
+    /// <summary>Clears the value of the "encoded_image" field</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public void ClearEncodedImage() {
+      encodedImage_ = null;
+    }
+
+    /// <summary>Field number for the "height" field.</summary>
+    public const int HeightFieldNumber = 2;
+    private readonly static int HeightDefaultValue = 0;
+
+    private int height_;
+    /// <summary>
+    /// Height of the image data under #1 once decoded.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public int Height {
+      get { if ((_hasBits0 & 1) != 0) { return height_; } else { return HeightDefaultValue; } }
+      set {
+        _hasBits0 |= 1;
+        height_ = value;
+      }
+    }
+    /// <summary>Gets whether the "height" field is set</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public bool HasHeight {
+      get { return (_hasBits0 & 1) != 0; }
+    }
+    /// <summary>Clears the value of the "height" field</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public void ClearHeight() {
+      _hasBits0 &= ~1;
+    }
+
+    /// <summary>Field number for the "width" field.</summary>
+    public const int WidthFieldNumber = 3;
+    private readonly static int WidthDefaultValue = 0;
+
+    private int width_;
+    /// <summary>
+    /// Width of the image data under #1 once decoded.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public int Width {
+      get { if ((_hasBits0 & 2) != 0) { return width_; } else { return WidthDefaultValue; } }
+      set {
+        _hasBits0 |= 2;
+        width_ = value;
+      }
+    }
+    /// <summary>Gets whether the "width" field is set</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public bool HasWidth {
+      get { return (_hasBits0 & 2) != 0; }
+    }
+    /// <summary>Clears the value of the "width" field</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public void ClearWidth() {
+      _hasBits0 &= ~2;
+    }
+
+    /// <summary>Field number for the "colorspace" field.</summary>
+    public const int ColorspaceFieldNumber = 4;
+    private readonly static global::Mediapipe.OpenCvImageEncoderCalculatorResults.Types.ColorSpace ColorspaceDefaultValue = global::Mediapipe.OpenCvImageEncoderCalculatorResults.Types.ColorSpace.Unknown;
+
+    private global::Mediapipe.OpenCvImageEncoderCalculatorResults.Types.ColorSpace colorspace_;
+    /// <summary>
+    /// Color space used.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public global::Mediapipe.OpenCvImageEncoderCalculatorResults.Types.ColorSpace Colorspace {
+      get { if ((_hasBits0 & 4) != 0) { return colorspace_; } else { return ColorspaceDefaultValue; } }
+      set {
+        _hasBits0 |= 4;
+        colorspace_ = value;
+      }
+    }
+    /// <summary>Gets whether the "colorspace" field is set</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public bool HasColorspace {
+      get { return (_hasBits0 & 4) != 0; }
+    }
+    /// <summary>Clears the value of the "colorspace" field</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public void ClearColorspace() {
+      _hasBits0 &= ~4;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public override bool Equals(object other) {
+      return Equals(other as OpenCvImageEncoderCalculatorResults);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public bool Equals(OpenCvImageEncoderCalculatorResults other) {
+      if (ReferenceEquals(other, null)) {
+        return false;
+      }
+      if (ReferenceEquals(other, this)) {
+        return true;
+      }
+      if (EncodedImage != other.EncodedImage) return false;
+      if (Height != other.Height) return false;
+      if (Width != other.Width) return false;
+      if (Colorspace != other.Colorspace) return false;
+      return Equals(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public override int GetHashCode() {
+      int hash = 1;
+      if (HasEncodedImage) hash ^= EncodedImage.GetHashCode();
+      if (HasHeight) hash ^= Height.GetHashCode();
+      if (HasWidth) hash ^= Width.GetHashCode();
+      if (HasColorspace) hash ^= Colorspace.GetHashCode();
+      if (_unknownFields != null) {
+        hash ^= _unknownFields.GetHashCode();
+      }
+      return hash;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public override string ToString() {
+      return pb::JsonFormatter.ToDiagnosticString(this);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public void WriteTo(pb::CodedOutputStream output) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      output.WriteRawMessage(this);
+    #else
+      if (HasEncodedImage) {
+        output.WriteRawTag(10);
+        output.WriteBytes(EncodedImage);
+      }
+      if (HasHeight) {
+        output.WriteRawTag(16);
+        output.WriteInt32(Height);
+      }
+      if (HasWidth) {
+        output.WriteRawTag(24);
+        output.WriteInt32(Width);
+      }
+      if (HasColorspace) {
+        output.WriteRawTag(32);
+        output.WriteEnum((int) Colorspace);
+      }
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(output);
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+      if (HasEncodedImage) {
+        output.WriteRawTag(10);
+        output.WriteBytes(EncodedImage);
+      }
+      if (HasHeight) {
+        output.WriteRawTag(16);
+        output.WriteInt32(Height);
+      }
+      if (HasWidth) {
+        output.WriteRawTag(24);
+        output.WriteInt32(Width);
+      }
+      if (HasColorspace) {
+        output.WriteRawTag(32);
+        output.WriteEnum((int) Colorspace);
+      }
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(ref output);
+      }
+    }
+    #endif
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public int CalculateSize() {
+      int size = 0;
+      if (HasEncodedImage) {
+        size += 1 + pb::CodedOutputStream.ComputeBytesSize(EncodedImage);
+      }
+      if (HasHeight) {
+        size += 1 + pb::CodedOutputStream.ComputeInt32Size(Height);
+      }
+      if (HasWidth) {
+        size += 1 + pb::CodedOutputStream.ComputeInt32Size(Width);
+      }
+      if (HasColorspace) {
+        size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) Colorspace);
+      }
+      if (_unknownFields != null) {
+        size += _unknownFields.CalculateSize();
+      }
+      return size;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public void MergeFrom(OpenCvImageEncoderCalculatorResults other) {
+      if (other == null) {
+        return;
+      }
+      if (other.HasEncodedImage) {
+        EncodedImage = other.EncodedImage;
+      }
+      if (other.HasHeight) {
+        Height = other.Height;
+      }
+      if (other.HasWidth) {
+        Width = other.Width;
+      }
+      if (other.HasColorspace) {
+        Colorspace = other.Colorspace;
+      }
+      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public void MergeFrom(pb::CodedInputStream input) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      input.ReadRawMessage(this);
+    #else
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
+            break;
+          case 10: {
+            EncodedImage = input.ReadBytes();
+            break;
+          }
+          case 16: {
+            Height = input.ReadInt32();
+            break;
+          }
+          case 24: {
+            Width = input.ReadInt32();
+            break;
+          }
+          case 32: {
+            Colorspace = (global::Mediapipe.OpenCvImageEncoderCalculatorResults.Types.ColorSpace) input.ReadEnum();
+            break;
+          }
+        }
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
+            break;
+          case 10: {
+            EncodedImage = input.ReadBytes();
+            break;
+          }
+          case 16: {
+            Height = input.ReadInt32();
+            break;
+          }
+          case 24: {
+            Width = input.ReadInt32();
+            break;
+          }
+          case 32: {
+            Colorspace = (global::Mediapipe.OpenCvImageEncoderCalculatorResults.Types.ColorSpace) input.ReadEnum();
+            break;
+          }
+        }
+      }
+    }
+    #endif
+
+    #region Nested types
+    /// <summary>Container for nested types declared in the OpenCvImageEncoderCalculatorResults message type.</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public static partial class Types {
+      public enum ColorSpace {
+        [pbr::OriginalName("UNKNOWN")] Unknown = 0,
+        [pbr::OriginalName("GRAYSCALE")] Grayscale = 1,
+        [pbr::OriginalName("RGB")] Rgb = 2,
+      }
+
+    }
+    #endregion
+
+  }
+
+  #endregion
+
+}
+
+#endregion Designer generated code

Packages/com.github.homuler.mediapipe/Runtime/Scripts/Protobuf/Calculators/Image/OpencvImageEncoderCalculator.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: cc4cda9e025bebabcaf5353ea2ba8e59
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.github.homuler.mediapipe/Runtime/Scripts/Protobuf/Calculators/Image/RecolorCalculator.cs

@@ -0,0 +1,446 @@
+// <auto-generated>
+//     Generated by the protocol buffer compiler.  DO NOT EDIT!
+//     source: mediapipe/calculators/image/recolor_calculator.proto
+// </auto-generated>
+#pragma warning disable 1591, 0612, 3021
+#region Designer generated code
+
+using pb = global::Google.Protobuf;
+using pbc = global::Google.Protobuf.Collections;
+using pbr = global::Google.Protobuf.Reflection;
+using scg = global::System.Collections.Generic;
+namespace Mediapipe {
+
+  /// <summary>Holder for reflection information generated from mediapipe/calculators/image/recolor_calculator.proto</summary>
+  public static partial class RecolorCalculatorReflection {
+
+    #region Descriptor
+    /// <summary>File descriptor for mediapipe/calculators/image/recolor_calculator.proto</summary>
+    public static pbr::FileDescriptor Descriptor {
+      get { return descriptor; }
+    }
+    private static pbr::FileDescriptor descriptor;
+
+    static RecolorCalculatorReflection() {
+      byte[] descriptorData = global::System.Convert.FromBase64String(
+          string.Concat(
+            "CjRtZWRpYXBpcGUvY2FsY3VsYXRvcnMvaW1hZ2UvcmVjb2xvcl9jYWxjdWxh",
+            "dG9yLnByb3RvEgltZWRpYXBpcGUaJG1lZGlhcGlwZS9mcmFtZXdvcmsvY2Fs",
+            "Y3VsYXRvci5wcm90bxoabWVkaWFwaXBlL3V0aWwvY29sb3IucHJvdG8iywIK",
+            "GFJlY29sb3JDYWxjdWxhdG9yT3B0aW9ucxJKCgxtYXNrX2NoYW5uZWwYASAB",
+            "KA4yLy5tZWRpYXBpcGUuUmVjb2xvckNhbGN1bGF0b3JPcHRpb25zLk1hc2tD",
+            "aGFubmVsOgNSRUQSHwoFY29sb3IYAiABKAsyEC5tZWRpYXBpcGUuQ29sb3IS",
+            "GgoLaW52ZXJ0X21hc2sYAyABKAg6BWZhbHNlEiMKFWFkanVzdF93aXRoX2x1",
+            "bWluYW5jZRgEIAEoCDoEdHJ1ZSIuCgtNYXNrQ2hhbm5lbBILCgdVTktOT1dO",
+            "EAASBwoDUkVEEAESCQoFQUxQSEEQAjJRCgNleHQSHC5tZWRpYXBpcGUuQ2Fs",
+            "Y3VsYXRvck9wdGlvbnMYjYS1eCABKAsyIy5tZWRpYXBpcGUuUmVjb2xvckNh",
+            "bGN1bGF0b3JPcHRpb25z"));
+      descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData,
+          new pbr::FileDescriptor[] { global::Mediapipe.CalculatorReflection.Descriptor, global::Mediapipe.ColorReflection.Descriptor, },
+          new pbr::GeneratedClrTypeInfo(null, null, new pbr::GeneratedClrTypeInfo[] {
+            new pbr::GeneratedClrTypeInfo(typeof(global::Mediapipe.RecolorCalculatorOptions), global::Mediapipe.RecolorCalculatorOptions.Parser, new[]{ "MaskChannel", "Color", "InvertMask", "AdjustWithLuminance" }, null, new[]{ typeof(global::Mediapipe.RecolorCalculatorOptions.Types.MaskChannel) }, new pb::Extension[] { global::Mediapipe.RecolorCalculatorOptions.Extensions.Ext }, null)
+          }));
+    }
+    #endregion
+
+  }
+  #region Messages
+  public sealed partial class RecolorCalculatorOptions : pb::IMessage<RecolorCalculatorOptions>
+  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      , pb::IBufferMessage
+  #endif
+  {
+    private static readonly pb::MessageParser<RecolorCalculatorOptions> _parser = new pb::MessageParser<RecolorCalculatorOptions>(() => new RecolorCalculatorOptions());
+    private pb::UnknownFieldSet _unknownFields;
+    private int _hasBits0;
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public static pb::MessageParser<RecolorCalculatorOptions> Parser { get { return _parser; } }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public static pbr::MessageDescriptor Descriptor {
+      get { return global::Mediapipe.RecolorCalculatorReflection.Descriptor.MessageTypes[0]; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    pbr::MessageDescriptor pb::IMessage.Descriptor {
+      get { return Descriptor; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public RecolorCalculatorOptions() {
+      OnConstruction();
+    }
+
+    partial void OnConstruction();
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public RecolorCalculatorOptions(RecolorCalculatorOptions other) : this() {
+      _hasBits0 = other._hasBits0;
+      maskChannel_ = other.maskChannel_;
+      color_ = other.color_ != null ? other.color_.Clone() : null;
+      invertMask_ = other.invertMask_;
+      adjustWithLuminance_ = other.adjustWithLuminance_;
+      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public RecolorCalculatorOptions Clone() {
+      return new RecolorCalculatorOptions(this);
+    }
+
+    /// <summary>Field number for the "mask_channel" field.</summary>
+    public const int MaskChannelFieldNumber = 1;
+    private readonly static global::Mediapipe.RecolorCalculatorOptions.Types.MaskChannel MaskChannelDefaultValue = global::Mediapipe.RecolorCalculatorOptions.Types.MaskChannel.Red;
+
+    private global::Mediapipe.RecolorCalculatorOptions.Types.MaskChannel maskChannel_;
+    /// <summary>
+    /// Selects which channel of the MASK input to use for masking.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public global::Mediapipe.RecolorCalculatorOptions.Types.MaskChannel MaskChannel {
+      get { if ((_hasBits0 & 1) != 0) { return maskChannel_; } else { return MaskChannelDefaultValue; } }
+      set {
+        _hasBits0 |= 1;
+        maskChannel_ = value;
+      }
+    }
+    /// <summary>Gets whether the "mask_channel" field is set</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public bool HasMaskChannel {
+      get { return (_hasBits0 & 1) != 0; }
+    }
+    /// <summary>Clears the value of the "mask_channel" field</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public void ClearMaskChannel() {
+      _hasBits0 &= ~1;
+    }
+
+    /// <summary>Field number for the "color" field.</summary>
+    public const int ColorFieldNumber = 2;
+    private global::Mediapipe.Color color_;
+    /// <summary>
+    /// Color to blend into input image where mask is > 0.
+    /// The blending is based on the input image luminosity.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public global::Mediapipe.Color Color {
+      get { return color_; }
+      set {
+        color_ = value;
+      }
+    }
+
+    /// <summary>Field number for the "invert_mask" field.</summary>
+    public const int InvertMaskFieldNumber = 3;
+    private readonly static bool InvertMaskDefaultValue = false;
+
+    private bool invertMask_;
+    /// <summary>
+    /// Swap the meaning of mask values for foreground/background.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public bool InvertMask {
+      get { if ((_hasBits0 & 2) != 0) { return invertMask_; } else { return InvertMaskDefaultValue; } }
+      set {
+        _hasBits0 |= 2;
+        invertMask_ = value;
+      }
+    }
+    /// <summary>Gets whether the "invert_mask" field is set</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public bool HasInvertMask {
+      get { return (_hasBits0 & 2) != 0; }
+    }
+    /// <summary>Clears the value of the "invert_mask" field</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public void ClearInvertMask() {
+      _hasBits0 &= ~2;
+    }
+
+    /// <summary>Field number for the "adjust_with_luminance" field.</summary>
+    public const int AdjustWithLuminanceFieldNumber = 4;
+    private readonly static bool AdjustWithLuminanceDefaultValue = true;
+
+    private bool adjustWithLuminance_;
+    /// <summary>
+    /// Whether to use the luminance of the input image to further adjust the
+    /// blending weight, to help preserve image textures.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public bool AdjustWithLuminance {
+      get { if ((_hasBits0 & 4) != 0) { return adjustWithLuminance_; } else { return AdjustWithLuminanceDefaultValue; } }
+      set {
+        _hasBits0 |= 4;
+        adjustWithLuminance_ = value;
+      }
+    }
+    /// <summary>Gets whether the "adjust_with_luminance" field is set</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public bool HasAdjustWithLuminance {
+      get { return (_hasBits0 & 4) != 0; }
+    }
+    /// <summary>Clears the value of the "adjust_with_luminance" field</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public void ClearAdjustWithLuminance() {
+      _hasBits0 &= ~4;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public override bool Equals(object other) {
+      return Equals(other as RecolorCalculatorOptions);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public bool Equals(RecolorCalculatorOptions other) {
+      if (ReferenceEquals(other, null)) {
+        return false;
+      }
+      if (ReferenceEquals(other, this)) {
+        return true;
+      }
+      if (MaskChannel != other.MaskChannel) return false;
+      if (!object.Equals(Color, other.Color)) return false;
+      if (InvertMask != other.InvertMask) return false;
+      if (AdjustWithLuminance != other.AdjustWithLuminance) return false;
+      return Equals(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public override int GetHashCode() {
+      int hash = 1;
+      if (HasMaskChannel) hash ^= MaskChannel.GetHashCode();
+      if (color_ != null) hash ^= Color.GetHashCode();
+      if (HasInvertMask) hash ^= InvertMask.GetHashCode();
+      if (HasAdjustWithLuminance) hash ^= AdjustWithLuminance.GetHashCode();
+      if (_unknownFields != null) {
+        hash ^= _unknownFields.GetHashCode();
+      }
+      return hash;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public override string ToString() {
+      return pb::JsonFormatter.ToDiagnosticString(this);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public void WriteTo(pb::CodedOutputStream output) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      output.WriteRawMessage(this);
+    #else
+      if (HasMaskChannel) {
+        output.WriteRawTag(8);
+        output.WriteEnum((int) MaskChannel);
+      }
+      if (color_ != null) {
+        output.WriteRawTag(18);
+        output.WriteMessage(Color);
+      }
+      if (HasInvertMask) {
+        output.WriteRawTag(24);
+        output.WriteBool(InvertMask);
+      }
+      if (HasAdjustWithLuminance) {
+        output.WriteRawTag(32);
+        output.WriteBool(AdjustWithLuminance);
+      }
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(output);
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+      if (HasMaskChannel) {
+        output.WriteRawTag(8);
+        output.WriteEnum((int) MaskChannel);
+      }
+      if (color_ != null) {
+        output.WriteRawTag(18);
+        output.WriteMessage(Color);
+      }
+      if (HasInvertMask) {
+        output.WriteRawTag(24);
+        output.WriteBool(InvertMask);
+      }
+      if (HasAdjustWithLuminance) {
+        output.WriteRawTag(32);
+        output.WriteBool(AdjustWithLuminance);
+      }
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(ref output);
+      }
+    }
+    #endif
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public int CalculateSize() {
+      int size = 0;
+      if (HasMaskChannel) {
+        size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) MaskChannel);
+      }
+      if (color_ != null) {
+        size += 1 + pb::CodedOutputStream.ComputeMessageSize(Color);
+      }
+      if (HasInvertMask) {
+        size += 1 + 1;
+      }
+      if (HasAdjustWithLuminance) {
+        size += 1 + 1;
+      }
+      if (_unknownFields != null) {
+        size += _unknownFields.CalculateSize();
+      }
+      return size;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public void MergeFrom(RecolorCalculatorOptions other) {
+      if (other == null) {
+        return;
+      }
+      if (other.HasMaskChannel) {
+        MaskChannel = other.MaskChannel;
+      }
+      if (other.color_ != null) {
+        if (color_ == null) {
+          Color = new global::Mediapipe.Color();
+        }
+        Color.MergeFrom(other.Color);
+      }
+      if (other.HasInvertMask) {
+        InvertMask = other.InvertMask;
+      }
+      if (other.HasAdjustWithLuminance) {
+        AdjustWithLuminance = other.AdjustWithLuminance;
+      }
+      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public void MergeFrom(pb::CodedInputStream input) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      input.ReadRawMessage(this);
+    #else
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
+            break;
+          case 8: {
+            MaskChannel = (global::Mediapipe.RecolorCalculatorOptions.Types.MaskChannel) input.ReadEnum();
+            break;
+          }
+          case 18: {
+            if (color_ == null) {
+              Color = new global::Mediapipe.Color();
+            }
+            input.ReadMessage(Color);
+            break;
+          }
+          case 24: {
+            InvertMask = input.ReadBool();
+            break;
+          }
+          case 32: {
+            AdjustWithLuminance = input.ReadBool();
+            break;
+          }
+        }
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
+            break;
+          case 8: {
+            MaskChannel = (global::Mediapipe.RecolorCalculatorOptions.Types.MaskChannel) input.ReadEnum();
+            break;
+          }
+          case 18: {
+            if (color_ == null) {
+              Color = new global::Mediapipe.Color();
+            }
+            input.ReadMessage(Color);
+            break;
+          }
+          case 24: {
+            InvertMask = input.ReadBool();
+            break;
+          }
+          case 32: {
+            AdjustWithLuminance = input.ReadBool();
+            break;
+          }
+        }
+      }
+    }
+    #endif
+
+    #region Nested types
+    /// <summary>Container for nested types declared in the RecolorCalculatorOptions message type.</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public static partial class Types {
+      public enum MaskChannel {
+        [pbr::OriginalName("UNKNOWN")] Unknown = 0,
+        [pbr::OriginalName("RED")] Red = 1,
+        [pbr::OriginalName("ALPHA")] Alpha = 2,
+      }
+
+    }
+    #endregion
+
+    #region Extensions
+    /// <summary>Container for extensions for other messages declared in the RecolorCalculatorOptions message type.</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public static partial class Extensions {
+      public static readonly pb::Extension<global::Mediapipe.CalculatorOptions, global::Mediapipe.RecolorCalculatorOptions> Ext =
+        new pb::Extension<global::Mediapipe.CalculatorOptions, global::Mediapipe.RecolorCalculatorOptions>(252527117, pb::FieldCodec.ForMessage(2020216938, global::Mediapipe.RecolorCalculatorOptions.Parser));
+    }
+    #endregion
+
+  }
+
+  #endregion
+
+}
+
+#endregion Designer generated code

Packages/com.github.homuler.mediapipe/Runtime/Scripts/Protobuf/Calculators/Image/RecolorCalculator.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: ff694e216363cbd5298af642ec6ee04f
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.github.homuler.mediapipe/Runtime/Scripts/Protobuf/Calculators/Image/RotationMode.cs

@@ -0,0 +1,218 @@
+// <auto-generated>
+//     Generated by the protocol buffer compiler.  DO NOT EDIT!
+//     source: mediapipe/calculators/image/rotation_mode.proto
+// </auto-generated>
+#pragma warning disable 1591, 0612, 3021
+#region Designer generated code
+
+using pb = global::Google.Protobuf;
+using pbc = global::Google.Protobuf.Collections;
+using pbr = global::Google.Protobuf.Reflection;
+using scg = global::System.Collections.Generic;
+namespace Mediapipe {
+
+  /// <summary>Holder for reflection information generated from mediapipe/calculators/image/rotation_mode.proto</summary>
+  public static partial class RotationModeReflection {
+
+    #region Descriptor
+    /// <summary>File descriptor for mediapipe/calculators/image/rotation_mode.proto</summary>
+    public static pbr::FileDescriptor Descriptor {
+      get { return descriptor; }
+    }
+    private static pbr::FileDescriptor descriptor;
+
+    static RotationModeReflection() {
+      byte[] descriptorData = global::System.Convert.FromBase64String(
+          string.Concat(
+            "Ci9tZWRpYXBpcGUvY2FsY3VsYXRvcnMvaW1hZ2Uvcm90YXRpb25fbW9kZS5w",
+            "cm90bxIJbWVkaWFwaXBlImgKDFJvdGF0aW9uTW9kZSJYCgRNb2RlEgsKB1VO",
+            "S05PV04QABIOCgpST1RBVElPTl8wEAESDwoLUk9UQVRJT05fOTAQAhIQCgxS",
+            "T1RBVElPTl8xODAQAxIQCgxST1RBVElPTl8yNzAQBEI6CiVjb20uZ29vZ2xl",
+            "Lm1lZGlhcGlwZS5jYWxjdWxhdG9yLnByb3RvQhFSb3RhdGlvbk1vZGVQcm90",
+            "bw=="));
+      descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData,
+          new pbr::FileDescriptor[] { },
+          new pbr::GeneratedClrTypeInfo(null, null, new pbr::GeneratedClrTypeInfo[] {
+            new pbr::GeneratedClrTypeInfo(typeof(global::Mediapipe.RotationMode), global::Mediapipe.RotationMode.Parser, null, null, new[]{ typeof(global::Mediapipe.RotationMode.Types.Mode) }, null, null)
+          }));
+    }
+    #endregion
+
+  }
+  #region Messages
+  /// <summary>
+  /// Counterclockwise rotation.
+  /// </summary>
+  public sealed partial class RotationMode : pb::IMessage<RotationMode>
+  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      , pb::IBufferMessage
+  #endif
+  {
+    private static readonly pb::MessageParser<RotationMode> _parser = new pb::MessageParser<RotationMode>(() => new RotationMode());
+    private pb::UnknownFieldSet _unknownFields;
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public static pb::MessageParser<RotationMode> Parser { get { return _parser; } }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public static pbr::MessageDescriptor Descriptor {
+      get { return global::Mediapipe.RotationModeReflection.Descriptor.MessageTypes[0]; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    pbr::MessageDescriptor pb::IMessage.Descriptor {
+      get { return Descriptor; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public RotationMode() {
+      OnConstruction();
+    }
+
+    partial void OnConstruction();
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public RotationMode(RotationMode other) : this() {
+      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public RotationMode Clone() {
+      return new RotationMode(this);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public override bool Equals(object other) {
+      return Equals(other as RotationMode);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public bool Equals(RotationMode other) {
+      if (ReferenceEquals(other, null)) {
+        return false;
+      }
+      if (ReferenceEquals(other, this)) {
+        return true;
+      }
+      return Equals(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public override int GetHashCode() {
+      int hash = 1;
+      if (_unknownFields != null) {
+        hash ^= _unknownFields.GetHashCode();
+      }
+      return hash;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public override string ToString() {
+      return pb::JsonFormatter.ToDiagnosticString(this);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public void WriteTo(pb::CodedOutputStream output) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      output.WriteRawMessage(this);
+    #else
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(output);
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(ref output);
+      }
+    }
+    #endif
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public int CalculateSize() {
+      int size = 0;
+      if (_unknownFields != null) {
+        size += _unknownFields.CalculateSize();
+      }
+      return size;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public void MergeFrom(RotationMode other) {
+      if (other == null) {
+        return;
+      }
+      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public void MergeFrom(pb::CodedInputStream input) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      input.ReadRawMessage(this);
+    #else
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
+            break;
+        }
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
+            break;
+        }
+      }
+    }
+    #endif
+
+    #region Nested types
+    /// <summary>Container for nested types declared in the RotationMode message type.</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public static partial class Types {
+      public enum Mode {
+        [pbr::OriginalName("UNKNOWN")] Unknown = 0,
+        [pbr::OriginalName("ROTATION_0")] Rotation0 = 1,
+        [pbr::OriginalName("ROTATION_90")] Rotation90 = 2,
+        [pbr::OriginalName("ROTATION_180")] Rotation180 = 3,
+        [pbr::OriginalName("ROTATION_270")] Rotation270 = 4,
+      }
+
+    }
+    #endregion
+
+  }
+
+  #endregion
+
+}
+
+#endregion Designer generated code

Packages/com.github.homuler.mediapipe/Runtime/Scripts/Protobuf/Calculators/Image/RotationMode.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 65197e2f3e760d27e81769f24aa3d458
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.github.homuler.mediapipe/Runtime/Scripts/Protobuf/Calculators/Image/ScaleImageCalculator.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: ed5cb62c3265ade729a48a72ff0e314a
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.github.homuler.mediapipe/Runtime/Scripts/Protobuf/Calculators/Image/SegmentationSmoothingCalculator.cs

@@ -0,0 +1,274 @@
+// <auto-generated>
+//     Generated by the protocol buffer compiler.  DO NOT EDIT!
+//     source: mediapipe/calculators/image/segmentation_smoothing_calculator.proto
+// </auto-generated>
+#pragma warning disable 1591, 0612, 3021
+#region Designer generated code
+
+using pb = global::Google.Protobuf;
+using pbc = global::Google.Protobuf.Collections;
+using pbr = global::Google.Protobuf.Reflection;
+using scg = global::System.Collections.Generic;
+namespace Mediapipe {
+
+  /// <summary>Holder for reflection information generated from mediapipe/calculators/image/segmentation_smoothing_calculator.proto</summary>
+  public static partial class SegmentationSmoothingCalculatorReflection {
+
+    #region Descriptor
+    /// <summary>File descriptor for mediapipe/calculators/image/segmentation_smoothing_calculator.proto</summary>
+    public static pbr::FileDescriptor Descriptor {
+      get { return descriptor; }
+    }
+    private static pbr::FileDescriptor descriptor;
+
+    static SegmentationSmoothingCalculatorReflection() {
+      byte[] descriptorData = global::System.Convert.FromBase64String(
+          string.Concat(
+            "CkNtZWRpYXBpcGUvY2FsY3VsYXRvcnMvaW1hZ2Uvc2VnbWVudGF0aW9uX3Nt",
+            "b290aGluZ19jYWxjdWxhdG9yLnByb3RvEgltZWRpYXBpcGUaJG1lZGlhcGlw",
+            "ZS9mcmFtZXdvcmsvY2FsY3VsYXRvci5wcm90byKyAQomU2VnbWVudGF0aW9u",
+            "U21vb3RoaW5nQ2FsY3VsYXRvck9wdGlvbnMSJgobY29tYmluZV93aXRoX3By",
+            "ZXZpb3VzX3JhdGlvGAEgASgCOgEwMmAKA2V4dBIcLm1lZGlhcGlwZS5DYWxj",
+            "dWxhdG9yT3B0aW9ucxjomfyzASABKAsyMS5tZWRpYXBpcGUuU2VnbWVudGF0",
+            "aW9uU21vb3RoaW5nQ2FsY3VsYXRvck9wdGlvbnM="));
+      descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData,
+          new pbr::FileDescriptor[] { global::Mediapipe.CalculatorReflection.Descriptor, },
+          new pbr::GeneratedClrTypeInfo(null, null, new pbr::GeneratedClrTypeInfo[] {
+            new pbr::GeneratedClrTypeInfo(typeof(global::Mediapipe.SegmentationSmoothingCalculatorOptions), global::Mediapipe.SegmentationSmoothingCalculatorOptions.Parser, new[]{ "CombineWithPreviousRatio" }, null, null, new pb::Extension[] { global::Mediapipe.SegmentationSmoothingCalculatorOptions.Extensions.Ext }, null)
+          }));
+    }
+    #endregion
+
+  }
+  #region Messages
+  public sealed partial class SegmentationSmoothingCalculatorOptions : pb::IMessage<SegmentationSmoothingCalculatorOptions>
+  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      , pb::IBufferMessage
+  #endif
+  {
+    private static readonly pb::MessageParser<SegmentationSmoothingCalculatorOptions> _parser = new pb::MessageParser<SegmentationSmoothingCalculatorOptions>(() => new SegmentationSmoothingCalculatorOptions());
+    private pb::UnknownFieldSet _unknownFields;
+    private int _hasBits0;
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public static pb::MessageParser<SegmentationSmoothingCalculatorOptions> Parser { get { return _parser; } }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public static pbr::MessageDescriptor Descriptor {
+      get { return global::Mediapipe.SegmentationSmoothingCalculatorReflection.Descriptor.MessageTypes[0]; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    pbr::MessageDescriptor pb::IMessage.Descriptor {
+      get { return Descriptor; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public SegmentationSmoothingCalculatorOptions() {
+      OnConstruction();
+    }
+
+    partial void OnConstruction();
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public SegmentationSmoothingCalculatorOptions(SegmentationSmoothingCalculatorOptions other) : this() {
+      _hasBits0 = other._hasBits0;
+      combineWithPreviousRatio_ = other.combineWithPreviousRatio_;
+      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public SegmentationSmoothingCalculatorOptions Clone() {
+      return new SegmentationSmoothingCalculatorOptions(this);
+    }
+
+    /// <summary>Field number for the "combine_with_previous_ratio" field.</summary>
+    public const int CombineWithPreviousRatioFieldNumber = 1;
+    private readonly static float CombineWithPreviousRatioDefaultValue = 0F;
+
+    private float combineWithPreviousRatio_;
+    /// <summary>
+    /// How much to blend in previous mask, based on a probability estimate.
+    /// Range: [0-1]
+    /// 0 = Use only current frame (no blending).
+    /// 1 = Blend in the previous mask based on uncertainty estimate.
+    ///     With ratio at 1, the uncertainty estimate is trusted completely.
+    ///     When uncertainty is high, the previous mask is given higher weight.
+    ///     Therefore, if both ratio and uncertainty are 1, only old mask is used.
+    ///   A pixel is 'uncertain' if its value is close to the middle (0.5 or 127).
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public float CombineWithPreviousRatio {
+      get { if ((_hasBits0 & 1) != 0) { return combineWithPreviousRatio_; } else { return CombineWithPreviousRatioDefaultValue; } }
+      set {
+        _hasBits0 |= 1;
+        combineWithPreviousRatio_ = value;
+      }
+    }
+    /// <summary>Gets whether the "combine_with_previous_ratio" field is set</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public bool HasCombineWithPreviousRatio {
+      get { return (_hasBits0 & 1) != 0; }
+    }
+    /// <summary>Clears the value of the "combine_with_previous_ratio" field</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public void ClearCombineWithPreviousRatio() {
+      _hasBits0 &= ~1;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public override bool Equals(object other) {
+      return Equals(other as SegmentationSmoothingCalculatorOptions);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public bool Equals(SegmentationSmoothingCalculatorOptions other) {
+      if (ReferenceEquals(other, null)) {
+        return false;
+      }
+      if (ReferenceEquals(other, this)) {
+        return true;
+      }
+      if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(CombineWithPreviousRatio, other.CombineWithPreviousRatio)) return false;
+      return Equals(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public override int GetHashCode() {
+      int hash = 1;
+      if (HasCombineWithPreviousRatio) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(CombineWithPreviousRatio);
+      if (_unknownFields != null) {
+        hash ^= _unknownFields.GetHashCode();
+      }
+      return hash;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public override string ToString() {
+      return pb::JsonFormatter.ToDiagnosticString(this);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public void WriteTo(pb::CodedOutputStream output) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      output.WriteRawMessage(this);
+    #else
+      if (HasCombineWithPreviousRatio) {
+        output.WriteRawTag(13);
+        output.WriteFloat(CombineWithPreviousRatio);
+      }
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(output);
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+      if (HasCombineWithPreviousRatio) {
+        output.WriteRawTag(13);
+        output.WriteFloat(CombineWithPreviousRatio);
+      }
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(ref output);
+      }
+    }
+    #endif
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public int CalculateSize() {
+      int size = 0;
+      if (HasCombineWithPreviousRatio) {
+        size += 1 + 4;
+      }
+      if (_unknownFields != null) {
+        size += _unknownFields.CalculateSize();
+      }
+      return size;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public void MergeFrom(SegmentationSmoothingCalculatorOptions other) {
+      if (other == null) {
+        return;
+      }
+      if (other.HasCombineWithPreviousRatio) {
+        CombineWithPreviousRatio = other.CombineWithPreviousRatio;
+      }
+      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public void MergeFrom(pb::CodedInputStream input) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      input.ReadRawMessage(this);
+    #else
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
+            break;
+          case 13: {
+            CombineWithPreviousRatio = input.ReadFloat();
+            break;
+          }
+        }
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
+            break;
+          case 13: {
+            CombineWithPreviousRatio = input.ReadFloat();
+            break;
+          }
+        }
+      }
+    }
+    #endif
+
+    #region Extensions
+    /// <summary>Container for extensions for other messages declared in the SegmentationSmoothingCalculatorOptions message type.</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public static partial class Extensions {
+      public static readonly pb::Extension<global::Mediapipe.CalculatorOptions, global::Mediapipe.SegmentationSmoothingCalculatorOptions> Ext =
+        new pb::Extension<global::Mediapipe.CalculatorOptions, global::Mediapipe.SegmentationSmoothingCalculatorOptions>(377425128, pb::FieldCodec.ForMessage(3019401026, global::Mediapipe.SegmentationSmoothingCalculatorOptions.Parser));
+    }
+    #endregion
+
+  }
+
+  #endregion
+
+}
+
+#endregion Designer generated code

Packages/com.github.homuler.mediapipe/Runtime/Scripts/Protobuf/Calculators/Image/SegmentationSmoothingCalculator.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 6948ac832e6ad049ba49291fe368dbac
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.github.homuler.mediapipe/Runtime/Scripts/Protobuf/Calculators/Image/SetAlphaCalculator.cs

@@ -0,0 +1,267 @@
+// <auto-generated>
+//     Generated by the protocol buffer compiler.  DO NOT EDIT!
+//     source: mediapipe/calculators/image/set_alpha_calculator.proto
+// </auto-generated>
+#pragma warning disable 1591, 0612, 3021
+#region Designer generated code
+
+using pb = global::Google.Protobuf;
+using pbc = global::Google.Protobuf.Collections;
+using pbr = global::Google.Protobuf.Reflection;
+using scg = global::System.Collections.Generic;
+namespace Mediapipe {
+
+  /// <summary>Holder for reflection information generated from mediapipe/calculators/image/set_alpha_calculator.proto</summary>
+  public static partial class SetAlphaCalculatorReflection {
+
+    #region Descriptor
+    /// <summary>File descriptor for mediapipe/calculators/image/set_alpha_calculator.proto</summary>
+    public static pbr::FileDescriptor Descriptor {
+      get { return descriptor; }
+    }
+    private static pbr::FileDescriptor descriptor;
+
+    static SetAlphaCalculatorReflection() {
+      byte[] descriptorData = global::System.Convert.FromBase64String(
+          string.Concat(
+            "CjZtZWRpYXBpcGUvY2FsY3VsYXRvcnMvaW1hZ2Uvc2V0X2FscGhhX2NhbGN1",
+            "bGF0b3IucHJvdG8SCW1lZGlhcGlwZRokbWVkaWFwaXBlL2ZyYW1ld29yay9j",
+            "YWxjdWxhdG9yLnByb3RvIogBChlTZXRBbHBoYUNhbGN1bGF0b3JPcHRpb25z",
+            "EhcKC2FscGhhX3ZhbHVlGAEgASgROgItMTJSCgNleHQSHC5tZWRpYXBpcGUu",
+            "Q2FsY3VsYXRvck9wdGlvbnMYp+HUdyABKAsyJC5tZWRpYXBpcGUuU2V0QWxw",
+            "aGFDYWxjdWxhdG9yT3B0aW9ucw=="));
+      descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData,
+          new pbr::FileDescriptor[] { global::Mediapipe.CalculatorReflection.Descriptor, },
+          new pbr::GeneratedClrTypeInfo(null, null, new pbr::GeneratedClrTypeInfo[] {
+            new pbr::GeneratedClrTypeInfo(typeof(global::Mediapipe.SetAlphaCalculatorOptions), global::Mediapipe.SetAlphaCalculatorOptions.Parser, new[]{ "AlphaValue" }, null, null, new pb::Extension[] { global::Mediapipe.SetAlphaCalculatorOptions.Extensions.Ext }, null)
+          }));
+    }
+    #endregion
+
+  }
+  #region Messages
+  public sealed partial class SetAlphaCalculatorOptions : pb::IMessage<SetAlphaCalculatorOptions>
+  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      , pb::IBufferMessage
+  #endif
+  {
+    private static readonly pb::MessageParser<SetAlphaCalculatorOptions> _parser = new pb::MessageParser<SetAlphaCalculatorOptions>(() => new SetAlphaCalculatorOptions());
+    private pb::UnknownFieldSet _unknownFields;
+    private int _hasBits0;
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public static pb::MessageParser<SetAlphaCalculatorOptions> Parser { get { return _parser; } }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public static pbr::MessageDescriptor Descriptor {
+      get { return global::Mediapipe.SetAlphaCalculatorReflection.Descriptor.MessageTypes[0]; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    pbr::MessageDescriptor pb::IMessage.Descriptor {
+      get { return Descriptor; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public SetAlphaCalculatorOptions() {
+      OnConstruction();
+    }
+
+    partial void OnConstruction();
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public SetAlphaCalculatorOptions(SetAlphaCalculatorOptions other) : this() {
+      _hasBits0 = other._hasBits0;
+      alphaValue_ = other.alphaValue_;
+      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public SetAlphaCalculatorOptions Clone() {
+      return new SetAlphaCalculatorOptions(this);
+    }
+
+    /// <summary>Field number for the "alpha_value" field.</summary>
+    public const int AlphaValueFieldNumber = 1;
+    private readonly static int AlphaValueDefaultValue = -1;
+
+    private int alphaValue_;
+    /// <summary>
+    /// The value to set the alpha channel to (0-255).
+    /// This option is ignored when set to -1 (use image mask instead).
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public int AlphaValue {
+      get { if ((_hasBits0 & 1) != 0) { return alphaValue_; } else { return AlphaValueDefaultValue; } }
+      set {
+        _hasBits0 |= 1;
+        alphaValue_ = value;
+      }
+    }
+    /// <summary>Gets whether the "alpha_value" field is set</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public bool HasAlphaValue {
+      get { return (_hasBits0 & 1) != 0; }
+    }
+    /// <summary>Clears the value of the "alpha_value" field</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public void ClearAlphaValue() {
+      _hasBits0 &= ~1;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public override bool Equals(object other) {
+      return Equals(other as SetAlphaCalculatorOptions);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public bool Equals(SetAlphaCalculatorOptions other) {
+      if (ReferenceEquals(other, null)) {
+        return false;
+      }
+      if (ReferenceEquals(other, this)) {
+        return true;
+      }
+      if (AlphaValue != other.AlphaValue) return false;
+      return Equals(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public override int GetHashCode() {
+      int hash = 1;
+      if (HasAlphaValue) hash ^= AlphaValue.GetHashCode();
+      if (_unknownFields != null) {
+        hash ^= _unknownFields.GetHashCode();
+      }
+      return hash;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public override string ToString() {
+      return pb::JsonFormatter.ToDiagnosticString(this);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public void WriteTo(pb::CodedOutputStream output) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      output.WriteRawMessage(this);
+    #else
+      if (HasAlphaValue) {
+        output.WriteRawTag(8);
+        output.WriteSInt32(AlphaValue);
+      }
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(output);
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+      if (HasAlphaValue) {
+        output.WriteRawTag(8);
+        output.WriteSInt32(AlphaValue);
+      }
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(ref output);
+      }
+    }
+    #endif
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public int CalculateSize() {
+      int size = 0;
+      if (HasAlphaValue) {
+        size += 1 + pb::CodedOutputStream.ComputeSInt32Size(AlphaValue);
+      }
+      if (_unknownFields != null) {
+        size += _unknownFields.CalculateSize();
+      }
+      return size;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public void MergeFrom(SetAlphaCalculatorOptions other) {
+      if (other == null) {
+        return;
+      }
+      if (other.HasAlphaValue) {
+        AlphaValue = other.AlphaValue;
+      }
+      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public void MergeFrom(pb::CodedInputStream input) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      input.ReadRawMessage(this);
+    #else
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
+            break;
+          case 8: {
+            AlphaValue = input.ReadSInt32();
+            break;
+          }
+        }
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
+            break;
+          case 8: {
+            AlphaValue = input.ReadSInt32();
+            break;
+          }
+        }
+      }
+    }
+    #endif
+
+    #region Extensions
+    /// <summary>Container for extensions for other messages declared in the SetAlphaCalculatorOptions message type.</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public static partial class Extensions {
+      public static readonly pb::Extension<global::Mediapipe.CalculatorOptions, global::Mediapipe.SetAlphaCalculatorOptions> Ext =
+        new pb::Extension<global::Mediapipe.CalculatorOptions, global::Mediapipe.SetAlphaCalculatorOptions>(250949799, pb::FieldCodec.ForMessage(2007598394, global::Mediapipe.SetAlphaCalculatorOptions.Parser));
+    }
+    #endregion
+
+  }
+
+  #endregion
+
+}
+
+#endregion Designer generated code

Packages/com.github.homuler.mediapipe/Runtime/Scripts/Protobuf/Calculators/Image/SetAlphaCalculator.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: bc54f36a85ddcff508f2caa3d92d60c1
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/com.github.homuler.mediapipe/Runtime/Scripts/Protobuf/Calculators/Image/WarpAffineCalculator.cs

@@ -0,0 +1,350 @@
+// <auto-generated>
+//     Generated by the protocol buffer compiler.  DO NOT EDIT!
+//     source: mediapipe/calculators/image/warp_affine_calculator.proto
+// </auto-generated>
+#pragma warning disable 1591, 0612, 3021
+#region Designer generated code
+
+using pb = global::Google.Protobuf;
+using pbc = global::Google.Protobuf.Collections;
+using pbr = global::Google.Protobuf.Reflection;
+using scg = global::System.Collections.Generic;
+namespace Mediapipe {
+
+  /// <summary>Holder for reflection information generated from mediapipe/calculators/image/warp_affine_calculator.proto</summary>
+  public static partial class WarpAffineCalculatorReflection {
+
+    #region Descriptor
+    /// <summary>File descriptor for mediapipe/calculators/image/warp_affine_calculator.proto</summary>
+    public static pbr::FileDescriptor Descriptor {
+      get { return descriptor; }
+    }
+    private static pbr::FileDescriptor descriptor;
+
+    static WarpAffineCalculatorReflection() {
+      byte[] descriptorData = global::System.Convert.FromBase64String(
+          string.Concat(
+            "CjhtZWRpYXBpcGUvY2FsY3VsYXRvcnMvaW1hZ2Uvd2FycF9hZmZpbmVfY2Fs",
+            "Y3VsYXRvci5wcm90bxIJbWVkaWFwaXBlGiRtZWRpYXBpcGUvZnJhbWV3b3Jr",
+            "L2NhbGN1bGF0b3IucHJvdG8aHm1lZGlhcGlwZS9ncHUvZ3B1X29yaWdpbi5w",
+            "cm90byK4AgobV2FycEFmZmluZUNhbGN1bGF0b3JPcHRpb25zEkYKC2JvcmRl",
+            "cl9tb2RlGAEgASgOMjEubWVkaWFwaXBlLldhcnBBZmZpbmVDYWxjdWxhdG9y",
+            "T3B0aW9ucy5Cb3JkZXJNb2RlEi0KCmdwdV9vcmlnaW4YAiABKA4yGS5tZWRp",
+            "YXBpcGUuR3B1T3JpZ2luLk1vZGUiSwoKQm9yZGVyTW9kZRIWChJCT1JERVJf",
+            "VU5TUEVDSUZJRUQQABIPCgtCT1JERVJfWkVSTxABEhQKEEJPUkRFUl9SRVBM",
+            "SUNBVEUQAjJVCgNleHQSHC5tZWRpYXBpcGUuQ2FsY3VsYXRvck9wdGlvbnMY",
+            "x7uYsgEgASgLMiYubWVkaWFwaXBlLldhcnBBZmZpbmVDYWxjdWxhdG9yT3B0",
+            "aW9ucw=="));
+      descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData,
+          new pbr::FileDescriptor[] { global::Mediapipe.CalculatorReflection.Descriptor, global::Mediapipe.GpuOriginReflection.Descriptor, },
+          new pbr::GeneratedClrTypeInfo(null, null, new pbr::GeneratedClrTypeInfo[] {
+            new pbr::GeneratedClrTypeInfo(typeof(global::Mediapipe.WarpAffineCalculatorOptions), global::Mediapipe.WarpAffineCalculatorOptions.Parser, new[]{ "BorderMode", "GpuOrigin" }, null, new[]{ typeof(global::Mediapipe.WarpAffineCalculatorOptions.Types.BorderMode) }, new pb::Extension[] { global::Mediapipe.WarpAffineCalculatorOptions.Extensions.Ext }, null)
+          }));
+    }
+    #endregion
+
+  }
+  #region Messages
+  public sealed partial class WarpAffineCalculatorOptions : pb::IMessage<WarpAffineCalculatorOptions>
+  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      , pb::IBufferMessage
+  #endif
+  {
+    private static readonly pb::MessageParser<WarpAffineCalculatorOptions> _parser = new pb::MessageParser<WarpAffineCalculatorOptions>(() => new WarpAffineCalculatorOptions());
+    private pb::UnknownFieldSet _unknownFields;
+    private int _hasBits0;
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public static pb::MessageParser<WarpAffineCalculatorOptions> Parser { get { return _parser; } }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public static pbr::MessageDescriptor Descriptor {
+      get { return global::Mediapipe.WarpAffineCalculatorReflection.Descriptor.MessageTypes[0]; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    pbr::MessageDescriptor pb::IMessage.Descriptor {
+      get { return Descriptor; }
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public WarpAffineCalculatorOptions() {
+      OnConstruction();
+    }
+
+    partial void OnConstruction();
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public WarpAffineCalculatorOptions(WarpAffineCalculatorOptions other) : this() {
+      _hasBits0 = other._hasBits0;
+      borderMode_ = other.borderMode_;
+      gpuOrigin_ = other.gpuOrigin_;
+      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public WarpAffineCalculatorOptions Clone() {
+      return new WarpAffineCalculatorOptions(this);
+    }
+
+    /// <summary>Field number for the "border_mode" field.</summary>
+    public const int BorderModeFieldNumber = 1;
+    private readonly static global::Mediapipe.WarpAffineCalculatorOptions.Types.BorderMode BorderModeDefaultValue = global::Mediapipe.WarpAffineCalculatorOptions.Types.BorderMode.BorderUnspecified;
+
+    private global::Mediapipe.WarpAffineCalculatorOptions.Types.BorderMode borderMode_;
+    /// <summary>
+    /// Pixel extrapolation method.
+    /// When converting image to tensor it may happen that tensor needs to read
+    /// pixels outside image boundaries. Border mode helps to specify how such
+    /// pixels will be calculated.
+    ///
+    /// BORDER_REPLICATE is used by default.
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public global::Mediapipe.WarpAffineCalculatorOptions.Types.BorderMode BorderMode {
+      get { if ((_hasBits0 & 1) != 0) { return borderMode_; } else { return BorderModeDefaultValue; } }
+      set {
+        _hasBits0 |= 1;
+        borderMode_ = value;
+      }
+    }
+    /// <summary>Gets whether the "border_mode" field is set</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public bool HasBorderMode {
+      get { return (_hasBits0 & 1) != 0; }
+    }
+    /// <summary>Clears the value of the "border_mode" field</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public void ClearBorderMode() {
+      _hasBits0 &= ~1;
+    }
+
+    /// <summary>Field number for the "gpu_origin" field.</summary>
+    public const int GpuOriginFieldNumber = 2;
+    private readonly static global::Mediapipe.GpuOrigin.Types.Mode GpuOriginDefaultValue = global::Mediapipe.GpuOrigin.Types.Mode.Default;
+
+    private global::Mediapipe.GpuOrigin.Types.Mode gpuOrigin_;
+    /// <summary>
+    /// For CONVENTIONAL mode for OpenGL, input image starts at bottom and needs
+    /// to be flipped vertically as tensors are expected to start at top.
+    /// (DEFAULT or unset interpreted as CONVENTIONAL.)
+    /// </summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public global::Mediapipe.GpuOrigin.Types.Mode GpuOrigin {
+      get { if ((_hasBits0 & 2) != 0) { return gpuOrigin_; } else { return GpuOriginDefaultValue; } }
+      set {
+        _hasBits0 |= 2;
+        gpuOrigin_ = value;
+      }
+    }
+    /// <summary>Gets whether the "gpu_origin" field is set</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public bool HasGpuOrigin {
+      get { return (_hasBits0 & 2) != 0; }
+    }
+    /// <summary>Clears the value of the "gpu_origin" field</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public void ClearGpuOrigin() {
+      _hasBits0 &= ~2;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public override bool Equals(object other) {
+      return Equals(other as WarpAffineCalculatorOptions);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public bool Equals(WarpAffineCalculatorOptions other) {
+      if (ReferenceEquals(other, null)) {
+        return false;
+      }
+      if (ReferenceEquals(other, this)) {
+        return true;
+      }
+      if (BorderMode != other.BorderMode) return false;
+      if (GpuOrigin != other.GpuOrigin) return false;
+      return Equals(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public override int GetHashCode() {
+      int hash = 1;
+      if (HasBorderMode) hash ^= BorderMode.GetHashCode();
+      if (HasGpuOrigin) hash ^= GpuOrigin.GetHashCode();
+      if (_unknownFields != null) {
+        hash ^= _unknownFields.GetHashCode();
+      }
+      return hash;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public override string ToString() {
+      return pb::JsonFormatter.ToDiagnosticString(this);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public void WriteTo(pb::CodedOutputStream output) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      output.WriteRawMessage(this);
+    #else
+      if (HasBorderMode) {
+        output.WriteRawTag(8);
+        output.WriteEnum((int) BorderMode);
+      }
+      if (HasGpuOrigin) {
+        output.WriteRawTag(16);
+        output.WriteEnum((int) GpuOrigin);
+      }
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(output);
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+      if (HasBorderMode) {
+        output.WriteRawTag(8);
+        output.WriteEnum((int) BorderMode);
+      }
+      if (HasGpuOrigin) {
+        output.WriteRawTag(16);
+        output.WriteEnum((int) GpuOrigin);
+      }
+      if (_unknownFields != null) {
+        _unknownFields.WriteTo(ref output);
+      }
+    }
+    #endif
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public int CalculateSize() {
+      int size = 0;
+      if (HasBorderMode) {
+        size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) BorderMode);
+      }
+      if (HasGpuOrigin) {
+        size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) GpuOrigin);
+      }
+      if (_unknownFields != null) {
+        size += _unknownFields.CalculateSize();
+      }
+      return size;
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public void MergeFrom(WarpAffineCalculatorOptions other) {
+      if (other == null) {
+        return;
+      }
+      if (other.HasBorderMode) {
+        BorderMode = other.BorderMode;
+      }
+      if (other.HasGpuOrigin) {
+        GpuOrigin = other.GpuOrigin;
+      }
+      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
+    }
+
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public void MergeFrom(pb::CodedInputStream input) {
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+      input.ReadRawMessage(this);
+    #else
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
+            break;
+          case 8: {
+            BorderMode = (global::Mediapipe.WarpAffineCalculatorOptions.Types.BorderMode) input.ReadEnum();
+            break;
+          }
+          case 16: {
+            GpuOrigin = (global::Mediapipe.GpuOrigin.Types.Mode) input.ReadEnum();
+            break;
+          }
+        }
+      }
+    #endif
+    }
+
+    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
+      uint tag;
+      while ((tag = input.ReadTag()) != 0) {
+        switch(tag) {
+          default:
+            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
+            break;
+          case 8: {
+            BorderMode = (global::Mediapipe.WarpAffineCalculatorOptions.Types.BorderMode) input.ReadEnum();
+            break;
+          }
+          case 16: {
+            GpuOrigin = (global::Mediapipe.GpuOrigin.Types.Mode) input.ReadEnum();
+            break;
+          }
+        }
+      }
+    }
+    #endif
+
+    #region Nested types
+    /// <summary>Container for nested types declared in the WarpAffineCalculatorOptions message type.</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public static partial class Types {
+      /// <summary>
+      /// Pixel extrapolation methods. See @border_mode.
+      /// </summary>
+      public enum BorderMode {
+        [pbr::OriginalName("BORDER_UNSPECIFIED")] BorderUnspecified = 0,
+        [pbr::OriginalName("BORDER_ZERO")] BorderZero = 1,
+        [pbr::OriginalName("BORDER_REPLICATE")] BorderReplicate = 2,
+      }
+
+    }
+    #endregion
+
+    #region Extensions
+    /// <summary>Container for extensions for other messages declared in the WarpAffineCalculatorOptions message type.</summary>
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
+    public static partial class Extensions {
+      public static readonly pb::Extension<global::Mediapipe.CalculatorOptions, global::Mediapipe.WarpAffineCalculatorOptions> Ext =
+        new pb::Extension<global::Mediapipe.CalculatorOptions, global::Mediapipe.WarpAffineCalculatorOptions>(373693895, pb::FieldCodec.ForMessage(2989551162, global::Mediapipe.WarpAffineCalculatorOptions.Parser));
+    }
+    #endregion
+
+  }
+
+  #endregion
+
+}
+
+#endregion Designer generated code

Packages/com.github.homuler.mediapipe/Runtime/Scripts/Protobuf/Calculators/Image/WarpAffineCalculator.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: bcddb40478ed4e9f49e3f62aef287d88
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: