// <auto-generated>
//     Generated by the protocol buffer compiler.  DO NOT EDIT!
//     source: mediapipe/util/tracking/motion_saliency.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/util/tracking/motion_saliency.proto</summary>
  public static partial class MotionSaliencyReflection {

    #region Descriptor
    /// <summary>File descriptor for mediapipe/util/tracking/motion_saliency.proto</summary>
    public static pbr::FileDescriptor Descriptor {
      get { return descriptor; }
    }
    private static pbr::FileDescriptor descriptor;

    static MotionSaliencyReflection() {
      byte[] descriptorData = global::System.Convert.FromBase64String(
          string.Concat(
            "Ci1tZWRpYXBpcGUvdXRpbC90cmFja2luZy9tb3Rpb25fc2FsaWVuY3kucHJv",
            "dG8SCW1lZGlhcGlwZSKlBAoVTW90aW9uU2FsaWVuY3lPcHRpb25zEhcKCmJv",
            "dW5kX2xlZnQYASABKAI6AzAuMxIZCgxib3VuZF9ib3R0b20YAiABKAI6AzAu",
            "MxIYCgtib3VuZF9yaWdodBgPIAEoAjoDMC4zEhYKCWJvdW5kX3RvcBgQIAEo",
            "AjoDMC4zEhsKD3NhbGllbmN5X3dlaWdodBgDIAEoAjoCMjASLQoec2NhbGVf",
            "d2VpZ2h0X2J5X2Zsb3dfbWFnbml0dWRlGAggASgIOgVmYWxzZRIXCgxtaW5f",
            "ZmVhdHVyZXMYBCABKAU6ATUSKgobdXNlX29ubHlfZm9yZWdyb3VuZF9yZWdp",
            "b25zGAkgASgIOgVmYWxzZRIgChRtaW5faXJsc19tb2RlX3dlaWdodBgKIAEo",
            "AjoCMTASHQoSbnVtX3RvcF9pcmxzX21vZGVzGAsgASgFOgEzEhwKD21vZGVf",
            "YmFuZF93aWR0aBgMIAEoAjoDMC4xEiEKFnNlbGVjdGlvbl9mcmFtZV9yYWRp",
            "dXMYBSABKAU6ATUSJwoac2VsZWN0aW9uX3N1cHBvcnRfZGlzdGFuY2UYBiAB",
            "KAI6AzAuMhIkChlzZWxlY3Rpb25fbWluaW11bV9zdXBwb3J0GAcgASgFOgE0",
            "EiMKFWZpbHRlcmluZ19zaWdtYV9zcGFjZRgNIAEoAjoEMC4wNRIfChRmaWx0",
            "ZXJpbmdfc2lnbWFfdGltZRgOIAEoAjoBNQ=="));
      descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData,
          new pbr::FileDescriptor[] { },
          new pbr::GeneratedClrTypeInfo(null, null, new pbr::GeneratedClrTypeInfo[] {
            new pbr::GeneratedClrTypeInfo(typeof(global::Mediapipe.MotionSaliencyOptions), global::Mediapipe.MotionSaliencyOptions.Parser, new[]{ "BoundLeft", "BoundBottom", "BoundRight", "BoundTop", "SaliencyWeight", "ScaleWeightByFlowMagnitude", "MinFeatures", "UseOnlyForegroundRegions", "MinIrlsModeWeight", "NumTopIrlsModes", "ModeBandWidth", "SelectionFrameRadius", "SelectionSupportDistance", "SelectionMinimumSupport", "FilteringSigmaSpace", "FilteringSigmaTime" }, null, null, null, null)
          }));
    }
    #endregion

  }
  #region Messages
  /// <summary>
  /// Next tag: 17
  /// </summary>
  public sealed partial class MotionSaliencyOptions : pb::IMessage<MotionSaliencyOptions>
  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
      , pb::IBufferMessage
  #endif
  {
    private static readonly pb::MessageParser<MotionSaliencyOptions> _parser = new pb::MessageParser<MotionSaliencyOptions>(() => new MotionSaliencyOptions());
    private pb::UnknownFieldSet _unknownFields;
    private int _hasBits0;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public static pb::MessageParser<MotionSaliencyOptions> Parser { get { return _parser; } }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public static pbr::MessageDescriptor Descriptor {
      get { return global::Mediapipe.MotionSaliencyReflection.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 MotionSaliencyOptions() {
      OnConstruction();
    }

    partial void OnConstruction();

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public MotionSaliencyOptions(MotionSaliencyOptions other) : this() {
      _hasBits0 = other._hasBits0;
      boundLeft_ = other.boundLeft_;
      boundBottom_ = other.boundBottom_;
      boundRight_ = other.boundRight_;
      boundTop_ = other.boundTop_;
      saliencyWeight_ = other.saliencyWeight_;
      scaleWeightByFlowMagnitude_ = other.scaleWeightByFlowMagnitude_;
      minFeatures_ = other.minFeatures_;
      useOnlyForegroundRegions_ = other.useOnlyForegroundRegions_;
      minIrlsModeWeight_ = other.minIrlsModeWeight_;
      numTopIrlsModes_ = other.numTopIrlsModes_;
      modeBandWidth_ = other.modeBandWidth_;
      selectionFrameRadius_ = other.selectionFrameRadius_;
      selectionSupportDistance_ = other.selectionSupportDistance_;
      selectionMinimumSupport_ = other.selectionMinimumSupport_;
      filteringSigmaSpace_ = other.filteringSigmaSpace_;
      filteringSigmaTime_ = other.filteringSigmaTime_;
      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public MotionSaliencyOptions Clone() {
      return new MotionSaliencyOptions(this);
    }

    /// <summary>Field number for the "bound_left" field.</summary>
    public const int BoundLeftFieldNumber = 1;
    private readonly static float BoundLeftDefaultValue = 0.3F;

    private float boundLeft_;
    /// <summary>
    /// Standard normalized bounds and weights used to initialize salient points.
    /// See region_flow.proto for details.
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public float BoundLeft {
      get { if ((_hasBits0 & 1) != 0) { return boundLeft_; } else { return BoundLeftDefaultValue; } }
      set {
        _hasBits0 |= 1;
        boundLeft_ = value;
      }
    }
    /// <summary>Gets whether the "bound_left" field is set</summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public bool HasBoundLeft {
      get { return (_hasBits0 & 1) != 0; }
    }
    /// <summary>Clears the value of the "bound_left" field</summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public void ClearBoundLeft() {
      _hasBits0 &= ~1;
    }

    /// <summary>Field number for the "bound_bottom" field.</summary>
    public const int BoundBottomFieldNumber = 2;
    private readonly static float BoundBottomDefaultValue = 0.3F;

    private float boundBottom_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public float BoundBottom {
      get { if ((_hasBits0 & 2) != 0) { return boundBottom_; } else { return BoundBottomDefaultValue; } }
      set {
        _hasBits0 |= 2;
        boundBottom_ = value;
      }
    }
    /// <summary>Gets whether the "bound_bottom" field is set</summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public bool HasBoundBottom {
      get { return (_hasBits0 & 2) != 0; }
    }
    /// <summary>Clears the value of the "bound_bottom" field</summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public void ClearBoundBottom() {
      _hasBits0 &= ~2;
    }

    /// <summary>Field number for the "bound_right" field.</summary>
    public const int BoundRightFieldNumber = 15;
    private readonly static float BoundRightDefaultValue = 0.3F;

    private float boundRight_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public float BoundRight {
      get { if ((_hasBits0 & 16384) != 0) { return boundRight_; } else { return BoundRightDefaultValue; } }
      set {
        _hasBits0 |= 16384;
        boundRight_ = value;
      }
    }
    /// <summary>Gets whether the "bound_right" field is set</summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public bool HasBoundRight {
      get { return (_hasBits0 & 16384) != 0; }
    }
    /// <summary>Clears the value of the "bound_right" field</summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public void ClearBoundRight() {
      _hasBits0 &= ~16384;
    }

    /// <summary>Field number for the "bound_top" field.</summary>
    public const int BoundTopFieldNumber = 16;
    private readonly static float BoundTopDefaultValue = 0.3F;

    private float boundTop_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public float BoundTop {
      get { if ((_hasBits0 & 32768) != 0) { return boundTop_; } else { return BoundTopDefaultValue; } }
      set {
        _hasBits0 |= 32768;
        boundTop_ = value;
      }
    }
    /// <summary>Gets whether the "bound_top" field is set</summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public bool HasBoundTop {
      get { return (_hasBits0 & 32768) != 0; }
    }
    /// <summary>Clears the value of the "bound_top" field</summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public void ClearBoundTop() {
      _hasBits0 &= ~32768;
    }

    /// <summary>Field number for the "saliency_weight" field.</summary>
    public const int SaliencyWeightFieldNumber = 3;
    private readonly static float SaliencyWeightDefaultValue = 20F;

    private float saliencyWeight_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public float SaliencyWeight {
      get { if ((_hasBits0 & 4) != 0) { return saliencyWeight_; } else { return SaliencyWeightDefaultValue; } }
      set {
        _hasBits0 |= 4;
        saliencyWeight_ = value;
      }
    }
    /// <summary>Gets whether the "saliency_weight" field is set</summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public bool HasSaliencyWeight {
      get { return (_hasBits0 & 4) != 0; }
    }
    /// <summary>Clears the value of the "saliency_weight" field</summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public void ClearSaliencyWeight() {
      _hasBits0 &= ~4;
    }

    /// <summary>Field number for the "scale_weight_by_flow_magnitude" field.</summary>
    public const int ScaleWeightByFlowMagnitudeFieldNumber = 8;
    private readonly static bool ScaleWeightByFlowMagnitudeDefaultValue = false;

    private bool scaleWeightByFlowMagnitude_;
    /// <summary>
    /// If set, scales saliency_weight by flow magnitude.
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public bool ScaleWeightByFlowMagnitude {
      get { if ((_hasBits0 & 128) != 0) { return scaleWeightByFlowMagnitude_; } else { return ScaleWeightByFlowMagnitudeDefaultValue; } }
      set {
        _hasBits0 |= 128;
        scaleWeightByFlowMagnitude_ = value;
      }
    }
    /// <summary>Gets whether the "scale_weight_by_flow_magnitude" field is set</summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public bool HasScaleWeightByFlowMagnitude {
      get { return (_hasBits0 & 128) != 0; }
    }
    /// <summary>Clears the value of the "scale_weight_by_flow_magnitude" field</summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public void ClearScaleWeightByFlowMagnitude() {
      _hasBits0 &= ~128;
    }

    /// <summary>Field number for the "min_features" field.</summary>
    public const int MinFeaturesFieldNumber = 4;
    private readonly static int MinFeaturesDefaultValue = 5;

    private int minFeatures_;
    /// <summary>
    /// Minimum number of features within a region to be considered salient.
    /// Only applicable for functions accepting RegionFlowFrames.
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public int MinFeatures {
      get { if ((_hasBits0 & 8) != 0) { return minFeatures_; } else { return MinFeaturesDefaultValue; } }
      set {
        _hasBits0 |= 8;
        minFeatures_ = value;
      }
    }
    /// <summary>Gets whether the "min_features" field is set</summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public bool HasMinFeatures {
      get { return (_hasBits0 & 8) != 0; }
    }
    /// <summary>Clears the value of the "min_features" field</summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public void ClearMinFeatures() {
      _hasBits0 &= ~8;
    }

    /// <summary>Field number for the "use_only_foreground_regions" field.</summary>
    public const int UseOnlyForegroundRegionsFieldNumber = 9;
    private readonly static bool UseOnlyForegroundRegionsDefaultValue = false;

    private bool useOnlyForegroundRegions_;
    /// <summary>
    /// If set, only considers regions flagged as forground.
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public bool UseOnlyForegroundRegions {
      get { if ((_hasBits0 & 256) != 0) { return useOnlyForegroundRegions_; } else { return UseOnlyForegroundRegionsDefaultValue; } }
      set {
        _hasBits0 |= 256;
        useOnlyForegroundRegions_ = value;
      }
    }
    /// <summary>Gets whether the "use_only_foreground_regions" field is set</summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public bool HasUseOnlyForegroundRegions {
      get { return (_hasBits0 & 256) != 0; }
    }
    /// <summary>Clears the value of the "use_only_foreground_regions" field</summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public void ClearUseOnlyForegroundRegions() {
      _hasBits0 &= ~256;
    }

    /// <summary>Field number for the "min_irls_mode_weight" field.</summary>
    public const int MinIrlsModeWeightFieldNumber = 10;
    private readonly static float MinIrlsModeWeightDefaultValue = 10F;

    private float minIrlsModeWeight_;
    /// <summary>
    /// Specifies roughly number of foreground features mapped to one mode,
    /// for mode to be considered salient.
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public float MinIrlsModeWeight {
      get { if ((_hasBits0 & 512) != 0) { return minIrlsModeWeight_; } else { return MinIrlsModeWeightDefaultValue; } }
      set {
        _hasBits0 |= 512;
        minIrlsModeWeight_ = value;
      }
    }
    /// <summary>Gets whether the "min_irls_mode_weight" field is set</summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public bool HasMinIrlsModeWeight {
      get { return (_hasBits0 & 512) != 0; }
    }
    /// <summary>Clears the value of the "min_irls_mode_weight" field</summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public void ClearMinIrlsModeWeight() {
      _hasBits0 &= ~512;
    }

    /// <summary>Field number for the "num_top_irls_modes" field.</summary>
    public const int NumTopIrlsModesFieldNumber = 11;
    private readonly static int NumTopIrlsModesDefaultValue = 3;

    private int numTopIrlsModes_;
    /// <summary>
    /// Only returns the top N irls modes.
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public int NumTopIrlsModes {
      get { if ((_hasBits0 & 1024) != 0) { return numTopIrlsModes_; } else { return NumTopIrlsModesDefaultValue; } }
      set {
        _hasBits0 |= 1024;
        numTopIrlsModes_ = value;
      }
    }
    /// <summary>Gets whether the "num_top_irls_modes" field is set</summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public bool HasNumTopIrlsModes {
      get { return (_hasBits0 & 1024) != 0; }
    }
    /// <summary>Clears the value of the "num_top_irls_modes" field</summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public void ClearNumTopIrlsModes() {
      _hasBits0 &= ~1024;
    }

    /// <summary>Field number for the "mode_band_width" field.</summary>
    public const int ModeBandWidthFieldNumber = 12;
    private readonly static float ModeBandWidthDefaultValue = 0.1F;

    private float modeBandWidth_;
    /// <summary>
    /// Mode finding is performed with a fraction radius of 10% of frame
    /// diameter by default.
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public float ModeBandWidth {
      get { if ((_hasBits0 & 2048) != 0) { return modeBandWidth_; } else { return ModeBandWidthDefaultValue; } }
      set {
        _hasBits0 |= 2048;
        modeBandWidth_ = value;
      }
    }
    /// <summary>Gets whether the "mode_band_width" field is set</summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public bool HasModeBandWidth {
      get { return (_hasBits0 & 2048) != 0; }
    }
    /// <summary>Clears the value of the "mode_band_width" field</summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public void ClearModeBandWidth() {
      _hasBits0 &= ~2048;
    }

    /// <summary>Field number for the "selection_frame_radius" field.</summary>
    public const int SelectionFrameRadiusFieldNumber = 5;
    private readonly static int SelectionFrameRadiusDefaultValue = 5;

    private int selectionFrameRadius_;
    /// <summary>
    /// We filter salient points along the temporal dimension only, keeping those
    /// that have sufficient support (in form of neighboring salient points). For
    /// every salient point in frame n, all points in frames
    /// [n - filtering_frame_radius, n + filtering_frame_radius] are tested,
    /// whether they support the current test point.
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public int SelectionFrameRadius {
      get { if ((_hasBits0 & 16) != 0) { return selectionFrameRadius_; } else { return SelectionFrameRadiusDefaultValue; } }
      set {
        _hasBits0 |= 16;
        selectionFrameRadius_ = value;
      }
    }
    /// <summary>Gets whether the "selection_frame_radius" field is set</summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public bool HasSelectionFrameRadius {
      get { return (_hasBits0 & 16) != 0; }
    }
    /// <summary>Clears the value of the "selection_frame_radius" field</summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public void ClearSelectionFrameRadius() {
      _hasBits0 &= ~16;
    }

    /// <summary>Field number for the "selection_support_distance" field.</summary>
    public const int SelectionSupportDistanceFieldNumber = 6;
    private readonly static float SelectionSupportDistanceDefaultValue = 0.2F;

    private float selectionSupportDistance_;
    /// <summary>
    /// Fractional distance to be considered a supporting salient point for a test
    /// point.
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public float SelectionSupportDistance {
      get { if ((_hasBits0 & 32) != 0) { return selectionSupportDistance_; } else { return SelectionSupportDistanceDefaultValue; } }
      set {
        _hasBits0 |= 32;
        selectionSupportDistance_ = value;
      }
    }
    /// <summary>Gets whether the "selection_support_distance" field is set</summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public bool HasSelectionSupportDistance {
      get { return (_hasBits0 & 32) != 0; }
    }
    /// <summary>Clears the value of the "selection_support_distance" field</summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public void ClearSelectionSupportDistance() {
      _hasBits0 &= ~32;
    }

    /// <summary>Field number for the "selection_minimum_support" field.</summary>
    public const int SelectionMinimumSupportFieldNumber = 7;
    private readonly static int SelectionMinimumSupportDefaultValue = 4;

    private int selectionMinimumSupport_;
    /// <summary>
    /// Minimum number of supporting salient points that need to be present in
    /// order for a point to be considered an inlier.
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public int SelectionMinimumSupport {
      get { if ((_hasBits0 & 64) != 0) { return selectionMinimumSupport_; } else { return SelectionMinimumSupportDefaultValue; } }
      set {
        _hasBits0 |= 64;
        selectionMinimumSupport_ = value;
      }
    }
    /// <summary>Gets whether the "selection_minimum_support" field is set</summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public bool HasSelectionMinimumSupport {
      get { return (_hasBits0 & 64) != 0; }
    }
    /// <summary>Clears the value of the "selection_minimum_support" field</summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public void ClearSelectionMinimumSupport() {
      _hasBits0 &= ~64;
    }

    /// <summary>Field number for the "filtering_sigma_space" field.</summary>
    public const int FilteringSigmaSpaceFieldNumber = 13;
    private readonly static float FilteringSigmaSpaceDefaultValue = 0.05F;

    private float filteringSigmaSpace_;
    /// <summary>
    /// Sigma in space (normalized domain).
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public float FilteringSigmaSpace {
      get { if ((_hasBits0 & 4096) != 0) { return filteringSigmaSpace_; } else { return FilteringSigmaSpaceDefaultValue; } }
      set {
        _hasBits0 |= 4096;
        filteringSigmaSpace_ = value;
      }
    }
    /// <summary>Gets whether the "filtering_sigma_space" field is set</summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public bool HasFilteringSigmaSpace {
      get { return (_hasBits0 & 4096) != 0; }
    }
    /// <summary>Clears the value of the "filtering_sigma_space" field</summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public void ClearFilteringSigmaSpace() {
      _hasBits0 &= ~4096;
    }

    /// <summary>Field number for the "filtering_sigma_time" field.</summary>
    public const int FilteringSigmaTimeFieldNumber = 14;
    private readonly static float FilteringSigmaTimeDefaultValue = 5F;

    private float filteringSigmaTime_;
    /// <summary>
    /// Sigma in time (in frames).
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public float FilteringSigmaTime {
      get { if ((_hasBits0 & 8192) != 0) { return filteringSigmaTime_; } else { return FilteringSigmaTimeDefaultValue; } }
      set {
        _hasBits0 |= 8192;
        filteringSigmaTime_ = value;
      }
    }
    /// <summary>Gets whether the "filtering_sigma_time" field is set</summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public bool HasFilteringSigmaTime {
      get { return (_hasBits0 & 8192) != 0; }
    }
    /// <summary>Clears the value of the "filtering_sigma_time" field</summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public void ClearFilteringSigmaTime() {
      _hasBits0 &= ~8192;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public override bool Equals(object other) {
      return Equals(other as MotionSaliencyOptions);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public bool Equals(MotionSaliencyOptions other) {
      if (ReferenceEquals(other, null)) {
        return false;
      }
      if (ReferenceEquals(other, this)) {
        return true;
      }
      if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(BoundLeft, other.BoundLeft)) return false;
      if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(BoundBottom, other.BoundBottom)) return false;
      if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(BoundRight, other.BoundRight)) return false;
      if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(BoundTop, other.BoundTop)) return false;
      if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(SaliencyWeight, other.SaliencyWeight)) return false;
      if (ScaleWeightByFlowMagnitude != other.ScaleWeightByFlowMagnitude) return false;
      if (MinFeatures != other.MinFeatures) return false;
      if (UseOnlyForegroundRegions != other.UseOnlyForegroundRegions) return false;
      if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(MinIrlsModeWeight, other.MinIrlsModeWeight)) return false;
      if (NumTopIrlsModes != other.NumTopIrlsModes) return false;
      if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(ModeBandWidth, other.ModeBandWidth)) return false;
      if (SelectionFrameRadius != other.SelectionFrameRadius) return false;
      if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(SelectionSupportDistance, other.SelectionSupportDistance)) return false;
      if (SelectionMinimumSupport != other.SelectionMinimumSupport) return false;
      if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(FilteringSigmaSpace, other.FilteringSigmaSpace)) return false;
      if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(FilteringSigmaTime, other.FilteringSigmaTime)) 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 (HasBoundLeft) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(BoundLeft);
      if (HasBoundBottom) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(BoundBottom);
      if (HasBoundRight) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(BoundRight);
      if (HasBoundTop) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(BoundTop);
      if (HasSaliencyWeight) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(SaliencyWeight);
      if (HasScaleWeightByFlowMagnitude) hash ^= ScaleWeightByFlowMagnitude.GetHashCode();
      if (HasMinFeatures) hash ^= MinFeatures.GetHashCode();
      if (HasUseOnlyForegroundRegions) hash ^= UseOnlyForegroundRegions.GetHashCode();
      if (HasMinIrlsModeWeight) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(MinIrlsModeWeight);
      if (HasNumTopIrlsModes) hash ^= NumTopIrlsModes.GetHashCode();
      if (HasModeBandWidth) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(ModeBandWidth);
      if (HasSelectionFrameRadius) hash ^= SelectionFrameRadius.GetHashCode();
      if (HasSelectionSupportDistance) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(SelectionSupportDistance);
      if (HasSelectionMinimumSupport) hash ^= SelectionMinimumSupport.GetHashCode();
      if (HasFilteringSigmaSpace) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(FilteringSigmaSpace);
      if (HasFilteringSigmaTime) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(FilteringSigmaTime);
      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 (HasBoundLeft) {
        output.WriteRawTag(13);
        output.WriteFloat(BoundLeft);
      }
      if (HasBoundBottom) {
        output.WriteRawTag(21);
        output.WriteFloat(BoundBottom);
      }
      if (HasSaliencyWeight) {
        output.WriteRawTag(29);
        output.WriteFloat(SaliencyWeight);
      }
      if (HasMinFeatures) {
        output.WriteRawTag(32);
        output.WriteInt32(MinFeatures);
      }
      if (HasSelectionFrameRadius) {
        output.WriteRawTag(40);
        output.WriteInt32(SelectionFrameRadius);
      }
      if (HasSelectionSupportDistance) {
        output.WriteRawTag(53);
        output.WriteFloat(SelectionSupportDistance);
      }
      if (HasSelectionMinimumSupport) {
        output.WriteRawTag(56);
        output.WriteInt32(SelectionMinimumSupport);
      }
      if (HasScaleWeightByFlowMagnitude) {
        output.WriteRawTag(64);
        output.WriteBool(ScaleWeightByFlowMagnitude);
      }
      if (HasUseOnlyForegroundRegions) {
        output.WriteRawTag(72);
        output.WriteBool(UseOnlyForegroundRegions);
      }
      if (HasMinIrlsModeWeight) {
        output.WriteRawTag(85);
        output.WriteFloat(MinIrlsModeWeight);
      }
      if (HasNumTopIrlsModes) {
        output.WriteRawTag(88);
        output.WriteInt32(NumTopIrlsModes);
      }
      if (HasModeBandWidth) {
        output.WriteRawTag(101);
        output.WriteFloat(ModeBandWidth);
      }
      if (HasFilteringSigmaSpace) {
        output.WriteRawTag(109);
        output.WriteFloat(FilteringSigmaSpace);
      }
      if (HasFilteringSigmaTime) {
        output.WriteRawTag(117);
        output.WriteFloat(FilteringSigmaTime);
      }
      if (HasBoundRight) {
        output.WriteRawTag(125);
        output.WriteFloat(BoundRight);
      }
      if (HasBoundTop) {
        output.WriteRawTag(133, 1);
        output.WriteFloat(BoundTop);
      }
      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 (HasBoundLeft) {
        output.WriteRawTag(13);
        output.WriteFloat(BoundLeft);
      }
      if (HasBoundBottom) {
        output.WriteRawTag(21);
        output.WriteFloat(BoundBottom);
      }
      if (HasSaliencyWeight) {
        output.WriteRawTag(29);
        output.WriteFloat(SaliencyWeight);
      }
      if (HasMinFeatures) {
        output.WriteRawTag(32);
        output.WriteInt32(MinFeatures);
      }
      if (HasSelectionFrameRadius) {
        output.WriteRawTag(40);
        output.WriteInt32(SelectionFrameRadius);
      }
      if (HasSelectionSupportDistance) {
        output.WriteRawTag(53);
        output.WriteFloat(SelectionSupportDistance);
      }
      if (HasSelectionMinimumSupport) {
        output.WriteRawTag(56);
        output.WriteInt32(SelectionMinimumSupport);
      }
      if (HasScaleWeightByFlowMagnitude) {
        output.WriteRawTag(64);
        output.WriteBool(ScaleWeightByFlowMagnitude);
      }
      if (HasUseOnlyForegroundRegions) {
        output.WriteRawTag(72);
        output.WriteBool(UseOnlyForegroundRegions);
      }
      if (HasMinIrlsModeWeight) {
        output.WriteRawTag(85);
        output.WriteFloat(MinIrlsModeWeight);
      }
      if (HasNumTopIrlsModes) {
        output.WriteRawTag(88);
        output.WriteInt32(NumTopIrlsModes);
      }
      if (HasModeBandWidth) {
        output.WriteRawTag(101);
        output.WriteFloat(ModeBandWidth);
      }
      if (HasFilteringSigmaSpace) {
        output.WriteRawTag(109);
        output.WriteFloat(FilteringSigmaSpace);
      }
      if (HasFilteringSigmaTime) {
        output.WriteRawTag(117);
        output.WriteFloat(FilteringSigmaTime);
      }
      if (HasBoundRight) {
        output.WriteRawTag(125);
        output.WriteFloat(BoundRight);
      }
      if (HasBoundTop) {
        output.WriteRawTag(133, 1);
        output.WriteFloat(BoundTop);
      }
      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 (HasBoundLeft) {
        size += 1 + 4;
      }
      if (HasBoundBottom) {
        size += 1 + 4;
      }
      if (HasBoundRight) {
        size += 1 + 4;
      }
      if (HasBoundTop) {
        size += 2 + 4;
      }
      if (HasSaliencyWeight) {
        size += 1 + 4;
      }
      if (HasScaleWeightByFlowMagnitude) {
        size += 1 + 1;
      }
      if (HasMinFeatures) {
        size += 1 + pb::CodedOutputStream.ComputeInt32Size(MinFeatures);
      }
      if (HasUseOnlyForegroundRegions) {
        size += 1 + 1;
      }
      if (HasMinIrlsModeWeight) {
        size += 1 + 4;
      }
      if (HasNumTopIrlsModes) {
        size += 1 + pb::CodedOutputStream.ComputeInt32Size(NumTopIrlsModes);
      }
      if (HasModeBandWidth) {
        size += 1 + 4;
      }
      if (HasSelectionFrameRadius) {
        size += 1 + pb::CodedOutputStream.ComputeInt32Size(SelectionFrameRadius);
      }
      if (HasSelectionSupportDistance) {
        size += 1 + 4;
      }
      if (HasSelectionMinimumSupport) {
        size += 1 + pb::CodedOutputStream.ComputeInt32Size(SelectionMinimumSupport);
      }
      if (HasFilteringSigmaSpace) {
        size += 1 + 4;
      }
      if (HasFilteringSigmaTime) {
        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(MotionSaliencyOptions other) {
      if (other == null) {
        return;
      }
      if (other.HasBoundLeft) {
        BoundLeft = other.BoundLeft;
      }
      if (other.HasBoundBottom) {
        BoundBottom = other.BoundBottom;
      }
      if (other.HasBoundRight) {
        BoundRight = other.BoundRight;
      }
      if (other.HasBoundTop) {
        BoundTop = other.BoundTop;
      }
      if (other.HasSaliencyWeight) {
        SaliencyWeight = other.SaliencyWeight;
      }
      if (other.HasScaleWeightByFlowMagnitude) {
        ScaleWeightByFlowMagnitude = other.ScaleWeightByFlowMagnitude;
      }
      if (other.HasMinFeatures) {
        MinFeatures = other.MinFeatures;
      }
      if (other.HasUseOnlyForegroundRegions) {
        UseOnlyForegroundRegions = other.UseOnlyForegroundRegions;
      }
      if (other.HasMinIrlsModeWeight) {
        MinIrlsModeWeight = other.MinIrlsModeWeight;
      }
      if (other.HasNumTopIrlsModes) {
        NumTopIrlsModes = other.NumTopIrlsModes;
      }
      if (other.HasModeBandWidth) {
        ModeBandWidth = other.ModeBandWidth;
      }
      if (other.HasSelectionFrameRadius) {
        SelectionFrameRadius = other.SelectionFrameRadius;
      }
      if (other.HasSelectionSupportDistance) {
        SelectionSupportDistance = other.SelectionSupportDistance;
      }
      if (other.HasSelectionMinimumSupport) {
        SelectionMinimumSupport = other.SelectionMinimumSupport;
      }
      if (other.HasFilteringSigmaSpace) {
        FilteringSigmaSpace = other.FilteringSigmaSpace;
      }
      if (other.HasFilteringSigmaTime) {
        FilteringSigmaTime = other.FilteringSigmaTime;
      }
      _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: {
            BoundLeft = input.ReadFloat();
            break;
          }
          case 21: {
            BoundBottom = input.ReadFloat();
            break;
          }
          case 29: {
            SaliencyWeight = input.ReadFloat();
            break;
          }
          case 32: {
            MinFeatures = input.ReadInt32();
            break;
          }
          case 40: {
            SelectionFrameRadius = input.ReadInt32();
            break;
          }
          case 53: {
            SelectionSupportDistance = input.ReadFloat();
            break;
          }
          case 56: {
            SelectionMinimumSupport = input.ReadInt32();
            break;
          }
          case 64: {
            ScaleWeightByFlowMagnitude = input.ReadBool();
            break;
          }
          case 72: {
            UseOnlyForegroundRegions = input.ReadBool();
            break;
          }
          case 85: {
            MinIrlsModeWeight = input.ReadFloat();
            break;
          }
          case 88: {
            NumTopIrlsModes = input.ReadInt32();
            break;
          }
          case 101: {
            ModeBandWidth = input.ReadFloat();
            break;
          }
          case 109: {
            FilteringSigmaSpace = input.ReadFloat();
            break;
          }
          case 117: {
            FilteringSigmaTime = input.ReadFloat();
            break;
          }
          case 125: {
            BoundRight = input.ReadFloat();
            break;
          }
          case 133: {
            BoundTop = 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: {
            BoundLeft = input.ReadFloat();
            break;
          }
          case 21: {
            BoundBottom = input.ReadFloat();
            break;
          }
          case 29: {
            SaliencyWeight = input.ReadFloat();
            break;
          }
          case 32: {
            MinFeatures = input.ReadInt32();
            break;
          }
          case 40: {
            SelectionFrameRadius = input.ReadInt32();
            break;
          }
          case 53: {
            SelectionSupportDistance = input.ReadFloat();
            break;
          }
          case 56: {
            SelectionMinimumSupport = input.ReadInt32();
            break;
          }
          case 64: {
            ScaleWeightByFlowMagnitude = input.ReadBool();
            break;
          }
          case 72: {
            UseOnlyForegroundRegions = input.ReadBool();
            break;
          }
          case 85: {
            MinIrlsModeWeight = input.ReadFloat();
            break;
          }
          case 88: {
            NumTopIrlsModes = input.ReadInt32();
            break;
          }
          case 101: {
            ModeBandWidth = input.ReadFloat();
            break;
          }
          case 109: {
            FilteringSigmaSpace = input.ReadFloat();
            break;
          }
          case 117: {
            FilteringSigmaTime = input.ReadFloat();
            break;
          }
          case 125: {
            BoundRight = input.ReadFloat();
            break;
          }
          case 133: {
            BoundTop = input.ReadFloat();
            break;
          }
        }
      }
    }
    #endif

  }

  #endregion

}

#endregion Designer generated code