1949 lines
82 KiB
C#
1949 lines
82 KiB
C#
// <auto-generated>
|
|
// Generated by the protocol buffer compiler. DO NOT EDIT!
|
|
// source: mediapipe/util/tracking/motion_analysis.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_analysis.proto</summary>
|
|
public static partial class MotionAnalysisReflection {
|
|
|
|
#region Descriptor
|
|
/// <summary>File descriptor for mediapipe/util/tracking/motion_analysis.proto</summary>
|
|
public static pbr::FileDescriptor Descriptor {
|
|
get { return descriptor; }
|
|
}
|
|
private static pbr::FileDescriptor descriptor;
|
|
|
|
static MotionAnalysisReflection() {
|
|
byte[] descriptorData = global::System.Convert.FromBase64String(
|
|
string.Concat(
|
|
"Ci1tZWRpYXBpcGUvdXRpbC90cmFja2luZy9tb3Rpb25fYW5hbHlzaXMucHJv",
|
|
"dG8SCW1lZGlhcGlwZRovbWVkaWFwaXBlL3V0aWwvdHJhY2tpbmcvbW90aW9u",
|
|
"X2VzdGltYXRpb24ucHJvdG8aLW1lZGlhcGlwZS91dGlsL3RyYWNraW5nL21v",
|
|
"dGlvbl9zYWxpZW5jeS5wcm90bxo1bWVkaWFwaXBlL3V0aWwvdHJhY2tpbmcv",
|
|
"cmVnaW9uX2Zsb3dfY29tcHV0YXRpb24ucHJvdG8i+AoKFU1vdGlvbkFuYWx5",
|
|
"c2lzT3B0aW9ucxJgCg9hbmFseXNpc19wb2xpY3kYDiABKA4yLy5tZWRpYXBp",
|
|
"cGUuTW90aW9uQW5hbHlzaXNPcHRpb25zLkFuYWx5c2lzUG9saWN5OhZBTkFM",
|
|
"WVNJU19QT0xJQ1lfTEVHQUNZEj0KDGZsb3dfb3B0aW9ucxgBIAEoCzInLm1l",
|
|
"ZGlhcGlwZS5SZWdpb25GbG93Q29tcHV0YXRpb25PcHRpb25zEjoKDm1vdGlv",
|
|
"bl9vcHRpb25zGAIgASgLMiIubWVkaWFwaXBlLk1vdGlvbkVzdGltYXRpb25P",
|
|
"cHRpb25zEjoKEHNhbGllbmN5X29wdGlvbnMYAyABKAsyIC5tZWRpYXBpcGUu",
|
|
"TW90aW9uU2FsaWVuY3lPcHRpb25zEiAKFGVzdGltYXRpb25fY2xpcF9zaXpl",
|
|
"GAQgASgFOgIxNhIzCiRzdWJ0cmFjdF9jYW1lcmFfbW90aW9uX2Zyb21fZmVh",
|
|
"dHVyZXMYBSABKAg6BWZhbHNlEhYKC3RyYWNrX2luZGV4GAYgASgFOgEwEiYK",
|
|
"F2NvbXB1dGVfbW90aW9uX3NhbGllbmN5GAcgASgIOgVmYWxzZRIlChdzZWxl",
|
|
"Y3Rfc2FsaWVuY3lfaW5saWVycxgIIAEoCDoEdHJ1ZRIdCg9maWx0ZXJfc2Fs",
|
|
"aWVuY3kYCSABKAg6BHRydWUSIgoTcG9zdF9pcmxzX3Ntb290aGluZxgKIAEo",
|
|
"CDoFZmFsc2USKQodcmVqZWN0aW9uX3RyYW5zZm9ybV90aHJlc2hvbGQYDSAB",
|
|
"KAI6AjIwElQKFXZpc3VhbGl6YXRpb25fb3B0aW9ucxgLIAEoCzI1Lm1lZGlh",
|
|
"cGlwZS5Nb3Rpb25BbmFseXNpc09wdGlvbnMuVmlzdWFsaXphdGlvbk9wdGlv",
|
|
"bnMSTgoSZm9yZWdyb3VuZF9vcHRpb25zGAwgASgLMjIubWVkaWFwaXBlLk1v",
|
|
"dGlvbkFuYWx5c2lzT3B0aW9ucy5Gb3JlZ3JvdW5kT3B0aW9ucxrFAgoUVmlz",
|
|
"dWFsaXphdGlvbk9wdGlvbnMSLAoedmlzdWFsaXplX3JlZ2lvbl9mbG93X2Zl",
|
|
"YXR1cmVzGAEgASgIOgR0cnVlEicKGHZpc3VhbGl6ZV9zYWxpZW50X3BvaW50",
|
|
"cxgCIAEoCDoFZmFsc2USGQoObGluZV90aGlja25lc3MYBSABKAU6ATQSJgoX",
|
|
"Zm9yZWdyb3VuZF9qZXRfY29sb3JpbmcYAyABKAg6BWZhbHNlEi0KHnZpc3Vh",
|
|
"bGl6ZV9ibHVyX2FuYWx5c2lzX3JlZ2lvbhgEIAEoCDoFZmFsc2USHQoPdmlz",
|
|
"dWFsaXplX3N0YXRzGAYgASgIOgR0cnVlEiEKFm1pbl9sb25nX2ZlYXR1cmVf",
|
|
"dHJhY2sYByABKAU6ATASIgoXbWF4X2xvbmdfZmVhdHVyZV9wb2ludHMYCCAB",
|
|
"KAU6ATAafQoRRm9yZWdyb3VuZE9wdGlvbnMSIQoUZm9yZWdyb3VuZF90aHJl",
|
|
"c2hvbGQYASABKAI6AzAuNRIbChBmb3JlZ3JvdW5kX2dhbW1hGAIgASgCOgEx",
|
|
"EigKGnRocmVzaG9sZF9jb3ZlcmFnZV9zY2FsaW5nGAMgASgIOgR0cnVlIqwB",
|
|
"Cg5BbmFseXNpc1BvbGljeRIaChZBTkFMWVNJU19QT0xJQ1lfTEVHQUNZEAAS",
|
|
"GQoVQU5BTFlTSVNfUE9MSUNZX1ZJREVPEAESIAocQU5BTFlTSVNfUE9MSUNZ",
|
|
"X1ZJREVPX01PQklMRRACEiEKHUFOQUxZU0lTX1BPTElDWV9DQU1FUkFfTU9C",
|
|
"SUxFEAMSHgoaQU5BTFlTSVNfUE9MSUNZX0hZUEVSTEFQU0UQBA=="));
|
|
descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData,
|
|
new pbr::FileDescriptor[] { global::Mediapipe.MotionEstimationReflection.Descriptor, global::Mediapipe.MotionSaliencyReflection.Descriptor, global::Mediapipe.RegionFlowComputationReflection.Descriptor, },
|
|
new pbr::GeneratedClrTypeInfo(null, null, new pbr::GeneratedClrTypeInfo[] {
|
|
new pbr::GeneratedClrTypeInfo(typeof(global::Mediapipe.MotionAnalysisOptions), global::Mediapipe.MotionAnalysisOptions.Parser, new[]{ "AnalysisPolicy", "FlowOptions", "MotionOptions", "SaliencyOptions", "EstimationClipSize", "SubtractCameraMotionFromFeatures", "TrackIndex", "ComputeMotionSaliency", "SelectSaliencyInliers", "FilterSaliency", "PostIrlsSmoothing", "RejectionTransformThreshold", "VisualizationOptions", "ForegroundOptions" }, null, new[]{ typeof(global::Mediapipe.MotionAnalysisOptions.Types.AnalysisPolicy) }, null, new pbr::GeneratedClrTypeInfo[] { new pbr::GeneratedClrTypeInfo(typeof(global::Mediapipe.MotionAnalysisOptions.Types.VisualizationOptions), global::Mediapipe.MotionAnalysisOptions.Types.VisualizationOptions.Parser, new[]{ "VisualizeRegionFlowFeatures", "VisualizeSalientPoints", "LineThickness", "ForegroundJetColoring", "VisualizeBlurAnalysisRegion", "VisualizeStats", "MinLongFeatureTrack", "MaxLongFeaturePoints" }, null, null, null, null),
|
|
new pbr::GeneratedClrTypeInfo(typeof(global::Mediapipe.MotionAnalysisOptions.Types.ForegroundOptions), global::Mediapipe.MotionAnalysisOptions.Types.ForegroundOptions.Parser, new[]{ "ForegroundThreshold", "ForegroundGamma", "ThresholdCoverageScaling" }, null, null, null, null)})
|
|
}));
|
|
}
|
|
#endregion
|
|
|
|
}
|
|
#region Messages
|
|
/// <summary>
|
|
/// Settings for MotionAnalysis. This class computes sparse, locally consistent
|
|
/// flow (referred to as region flow), camera motions, and foreground saliency
|
|
/// (i.e. likely foreground objects moving different from the background).
|
|
/// Next tag: 16
|
|
/// </summary>
|
|
public sealed partial class MotionAnalysisOptions : pb::IMessage<MotionAnalysisOptions>
|
|
#if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
|
|
, pb::IBufferMessage
|
|
#endif
|
|
{
|
|
private static readonly pb::MessageParser<MotionAnalysisOptions> _parser = new pb::MessageParser<MotionAnalysisOptions>(() => new MotionAnalysisOptions());
|
|
private pb::UnknownFieldSet _unknownFields;
|
|
private int _hasBits0;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public static pb::MessageParser<MotionAnalysisOptions> Parser { get { return _parser; } }
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public static pbr::MessageDescriptor Descriptor {
|
|
get { return global::Mediapipe.MotionAnalysisReflection.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 MotionAnalysisOptions() {
|
|
OnConstruction();
|
|
}
|
|
|
|
partial void OnConstruction();
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public MotionAnalysisOptions(MotionAnalysisOptions other) : this() {
|
|
_hasBits0 = other._hasBits0;
|
|
analysisPolicy_ = other.analysisPolicy_;
|
|
flowOptions_ = other.flowOptions_ != null ? other.flowOptions_.Clone() : null;
|
|
motionOptions_ = other.motionOptions_ != null ? other.motionOptions_.Clone() : null;
|
|
saliencyOptions_ = other.saliencyOptions_ != null ? other.saliencyOptions_.Clone() : null;
|
|
estimationClipSize_ = other.estimationClipSize_;
|
|
subtractCameraMotionFromFeatures_ = other.subtractCameraMotionFromFeatures_;
|
|
trackIndex_ = other.trackIndex_;
|
|
computeMotionSaliency_ = other.computeMotionSaliency_;
|
|
selectSaliencyInliers_ = other.selectSaliencyInliers_;
|
|
filterSaliency_ = other.filterSaliency_;
|
|
postIrlsSmoothing_ = other.postIrlsSmoothing_;
|
|
rejectionTransformThreshold_ = other.rejectionTransformThreshold_;
|
|
visualizationOptions_ = other.visualizationOptions_ != null ? other.visualizationOptions_.Clone() : null;
|
|
foregroundOptions_ = other.foregroundOptions_ != null ? other.foregroundOptions_.Clone() : null;
|
|
_unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public MotionAnalysisOptions Clone() {
|
|
return new MotionAnalysisOptions(this);
|
|
}
|
|
|
|
/// <summary>Field number for the "analysis_policy" field.</summary>
|
|
public const int AnalysisPolicyFieldNumber = 14;
|
|
private readonly static global::Mediapipe.MotionAnalysisOptions.Types.AnalysisPolicy AnalysisPolicyDefaultValue = global::Mediapipe.MotionAnalysisOptions.Types.AnalysisPolicy.Legacy;
|
|
|
|
private global::Mediapipe.MotionAnalysisOptions.Types.AnalysisPolicy analysisPolicy_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public global::Mediapipe.MotionAnalysisOptions.Types.AnalysisPolicy AnalysisPolicy {
|
|
get { if ((_hasBits0 & 256) != 0) { return analysisPolicy_; } else { return AnalysisPolicyDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 256;
|
|
analysisPolicy_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "analysis_policy" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasAnalysisPolicy {
|
|
get { return (_hasBits0 & 256) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "analysis_policy" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearAnalysisPolicy() {
|
|
_hasBits0 &= ~256;
|
|
}
|
|
|
|
/// <summary>Field number for the "flow_options" field.</summary>
|
|
public const int FlowOptionsFieldNumber = 1;
|
|
private global::Mediapipe.RegionFlowComputationOptions flowOptions_;
|
|
/// <summary>
|
|
/// Options for the actual motion stabilization
|
|
/// (in order of object usage).
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public global::Mediapipe.RegionFlowComputationOptions FlowOptions {
|
|
get { return flowOptions_; }
|
|
set {
|
|
flowOptions_ = value;
|
|
}
|
|
}
|
|
|
|
/// <summary>Field number for the "motion_options" field.</summary>
|
|
public const int MotionOptionsFieldNumber = 2;
|
|
private global::Mediapipe.MotionEstimationOptions motionOptions_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public global::Mediapipe.MotionEstimationOptions MotionOptions {
|
|
get { return motionOptions_; }
|
|
set {
|
|
motionOptions_ = value;
|
|
}
|
|
}
|
|
|
|
/// <summary>Field number for the "saliency_options" field.</summary>
|
|
public const int SaliencyOptionsFieldNumber = 3;
|
|
private global::Mediapipe.MotionSaliencyOptions saliencyOptions_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public global::Mediapipe.MotionSaliencyOptions SaliencyOptions {
|
|
get { return saliencyOptions_; }
|
|
set {
|
|
saliencyOptions_ = value;
|
|
}
|
|
}
|
|
|
|
/// <summary>Field number for the "estimation_clip_size" field.</summary>
|
|
public const int EstimationClipSizeFieldNumber = 4;
|
|
private readonly static int EstimationClipSizeDefaultValue = 16;
|
|
|
|
private int estimationClipSize_;
|
|
/// <summary>
|
|
/// Clip-size used for (parallelized) motion estimation.
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public int EstimationClipSize {
|
|
get { if ((_hasBits0 & 1) != 0) { return estimationClipSize_; } else { return EstimationClipSizeDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 1;
|
|
estimationClipSize_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "estimation_clip_size" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasEstimationClipSize {
|
|
get { return (_hasBits0 & 1) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "estimation_clip_size" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearEstimationClipSize() {
|
|
_hasBits0 &= ~1;
|
|
}
|
|
|
|
/// <summary>Field number for the "subtract_camera_motion_from_features" field.</summary>
|
|
public const int SubtractCameraMotionFromFeaturesFieldNumber = 5;
|
|
private readonly static bool SubtractCameraMotionFromFeaturesDefaultValue = false;
|
|
|
|
private bool subtractCameraMotionFromFeatures_;
|
|
/// <summary>
|
|
/// If set, camera motion is subtracted from features before output.
|
|
/// Effectively outputs, residual motion w.r.t. background.
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool SubtractCameraMotionFromFeatures {
|
|
get { if ((_hasBits0 & 2) != 0) { return subtractCameraMotionFromFeatures_; } else { return SubtractCameraMotionFromFeaturesDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 2;
|
|
subtractCameraMotionFromFeatures_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "subtract_camera_motion_from_features" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasSubtractCameraMotionFromFeatures {
|
|
get { return (_hasBits0 & 2) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "subtract_camera_motion_from_features" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearSubtractCameraMotionFromFeatures() {
|
|
_hasBits0 &= ~2;
|
|
}
|
|
|
|
/// <summary>Field number for the "track_index" field.</summary>
|
|
public const int TrackIndexFieldNumber = 6;
|
|
private readonly static int TrackIndexDefaultValue = 0;
|
|
|
|
private int trackIndex_;
|
|
/// <summary>
|
|
/// If flow_options().tracking_options().tracking_policy() equals
|
|
/// POLICY_MULTI_FRAME, this flag indicates which RegionFlowFeatureList to use.
|
|
/// Specifically, for frame C, we use the motion from C to C - 1 - track_index.
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public int TrackIndex {
|
|
get { if ((_hasBits0 & 4) != 0) { return trackIndex_; } else { return TrackIndexDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 4;
|
|
trackIndex_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "track_index" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasTrackIndex {
|
|
get { return (_hasBits0 & 4) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "track_index" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearTrackIndex() {
|
|
_hasBits0 &= ~4;
|
|
}
|
|
|
|
/// <summary>Field number for the "compute_motion_saliency" field.</summary>
|
|
public const int ComputeMotionSaliencyFieldNumber = 7;
|
|
private readonly static bool ComputeMotionSaliencyDefaultValue = false;
|
|
|
|
private bool computeMotionSaliency_;
|
|
/// <summary>
|
|
/// If set, compute motion saliency (regions of moving foreground).
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool ComputeMotionSaliency {
|
|
get { if ((_hasBits0 & 8) != 0) { return computeMotionSaliency_; } else { return ComputeMotionSaliencyDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 8;
|
|
computeMotionSaliency_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "compute_motion_saliency" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasComputeMotionSaliency {
|
|
get { return (_hasBits0 & 8) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "compute_motion_saliency" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearComputeMotionSaliency() {
|
|
_hasBits0 &= ~8;
|
|
}
|
|
|
|
/// <summary>Field number for the "select_saliency_inliers" field.</summary>
|
|
public const int SelectSaliencyInliersFieldNumber = 8;
|
|
private readonly static bool SelectSaliencyInliersDefaultValue = true;
|
|
|
|
private bool selectSaliencyInliers_;
|
|
/// <summary>
|
|
/// Selects saliency inliers (only saliency locations with sufficient
|
|
/// spatial and temporal support are kept).
|
|
/// Only applied when compute_motion_saliency is set.
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool SelectSaliencyInliers {
|
|
get { if ((_hasBits0 & 16) != 0) { return selectSaliencyInliers_; } else { return SelectSaliencyInliersDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 16;
|
|
selectSaliencyInliers_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "select_saliency_inliers" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasSelectSaliencyInliers {
|
|
get { return (_hasBits0 & 16) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "select_saliency_inliers" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearSelectSaliencyInliers() {
|
|
_hasBits0 &= ~16;
|
|
}
|
|
|
|
/// <summary>Field number for the "filter_saliency" field.</summary>
|
|
public const int FilterSaliencyFieldNumber = 9;
|
|
private readonly static bool FilterSaliencyDefaultValue = true;
|
|
|
|
private bool filterSaliency_;
|
|
/// <summary>
|
|
/// Performs spatio-temporal filtering of extracted foreground saliency. If
|
|
/// used with above selection of saliency inliers, filtering is performed
|
|
/// *after* inlier selection.
|
|
/// Only applied when compute_motion_saliency is set.
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool FilterSaliency {
|
|
get { if ((_hasBits0 & 32) != 0) { return filterSaliency_; } else { return FilterSaliencyDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 32;
|
|
filterSaliency_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "filter_saliency" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasFilterSaliency {
|
|
get { return (_hasBits0 & 32) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "filter_saliency" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearFilterSaliency() {
|
|
_hasBits0 &= ~32;
|
|
}
|
|
|
|
/// <summary>Field number for the "post_irls_smoothing" field.</summary>
|
|
public const int PostIrlsSmoothingFieldNumber = 10;
|
|
private readonly static bool PostIrlsSmoothingDefaultValue = false;
|
|
|
|
private bool postIrlsSmoothing_;
|
|
/// <summary>
|
|
/// If set, irls weights of motion estimation are spatio-temporally smoothed
|
|
/// after model estimation.
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool PostIrlsSmoothing {
|
|
get { if ((_hasBits0 & 64) != 0) { return postIrlsSmoothing_; } else { return PostIrlsSmoothingDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 64;
|
|
postIrlsSmoothing_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "post_irls_smoothing" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasPostIrlsSmoothing {
|
|
get { return (_hasBits0 & 64) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "post_irls_smoothing" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearPostIrlsSmoothing() {
|
|
_hasBits0 &= ~64;
|
|
}
|
|
|
|
/// <summary>Field number for the "rejection_transform_threshold" field.</summary>
|
|
public const int RejectionTransformThresholdFieldNumber = 13;
|
|
private readonly static float RejectionTransformThresholdDefaultValue = 20F;
|
|
|
|
private float rejectionTransformThreshold_;
|
|
/// <summary>
|
|
/// If a rejection_transform is passed to AddFrameGeneric, features that
|
|
/// do not agree with the transform within below threshold are removed.
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public float RejectionTransformThreshold {
|
|
get { if ((_hasBits0 & 128) != 0) { return rejectionTransformThreshold_; } else { return RejectionTransformThresholdDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 128;
|
|
rejectionTransformThreshold_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "rejection_transform_threshold" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasRejectionTransformThreshold {
|
|
get { return (_hasBits0 & 128) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "rejection_transform_threshold" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearRejectionTransformThreshold() {
|
|
_hasBits0 &= ~128;
|
|
}
|
|
|
|
/// <summary>Field number for the "visualization_options" field.</summary>
|
|
public const int VisualizationOptionsFieldNumber = 11;
|
|
private global::Mediapipe.MotionAnalysisOptions.Types.VisualizationOptions visualizationOptions_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public global::Mediapipe.MotionAnalysisOptions.Types.VisualizationOptions VisualizationOptions {
|
|
get { return visualizationOptions_; }
|
|
set {
|
|
visualizationOptions_ = value;
|
|
}
|
|
}
|
|
|
|
/// <summary>Field number for the "foreground_options" field.</summary>
|
|
public const int ForegroundOptionsFieldNumber = 12;
|
|
private global::Mediapipe.MotionAnalysisOptions.Types.ForegroundOptions foregroundOptions_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public global::Mediapipe.MotionAnalysisOptions.Types.ForegroundOptions ForegroundOptions {
|
|
get { return foregroundOptions_; }
|
|
set {
|
|
foregroundOptions_ = value;
|
|
}
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public override bool Equals(object other) {
|
|
return Equals(other as MotionAnalysisOptions);
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool Equals(MotionAnalysisOptions other) {
|
|
if (ReferenceEquals(other, null)) {
|
|
return false;
|
|
}
|
|
if (ReferenceEquals(other, this)) {
|
|
return true;
|
|
}
|
|
if (AnalysisPolicy != other.AnalysisPolicy) return false;
|
|
if (!object.Equals(FlowOptions, other.FlowOptions)) return false;
|
|
if (!object.Equals(MotionOptions, other.MotionOptions)) return false;
|
|
if (!object.Equals(SaliencyOptions, other.SaliencyOptions)) return false;
|
|
if (EstimationClipSize != other.EstimationClipSize) return false;
|
|
if (SubtractCameraMotionFromFeatures != other.SubtractCameraMotionFromFeatures) return false;
|
|
if (TrackIndex != other.TrackIndex) return false;
|
|
if (ComputeMotionSaliency != other.ComputeMotionSaliency) return false;
|
|
if (SelectSaliencyInliers != other.SelectSaliencyInliers) return false;
|
|
if (FilterSaliency != other.FilterSaliency) return false;
|
|
if (PostIrlsSmoothing != other.PostIrlsSmoothing) return false;
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(RejectionTransformThreshold, other.RejectionTransformThreshold)) return false;
|
|
if (!object.Equals(VisualizationOptions, other.VisualizationOptions)) return false;
|
|
if (!object.Equals(ForegroundOptions, other.ForegroundOptions)) 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 (HasAnalysisPolicy) hash ^= AnalysisPolicy.GetHashCode();
|
|
if (flowOptions_ != null) hash ^= FlowOptions.GetHashCode();
|
|
if (motionOptions_ != null) hash ^= MotionOptions.GetHashCode();
|
|
if (saliencyOptions_ != null) hash ^= SaliencyOptions.GetHashCode();
|
|
if (HasEstimationClipSize) hash ^= EstimationClipSize.GetHashCode();
|
|
if (HasSubtractCameraMotionFromFeatures) hash ^= SubtractCameraMotionFromFeatures.GetHashCode();
|
|
if (HasTrackIndex) hash ^= TrackIndex.GetHashCode();
|
|
if (HasComputeMotionSaliency) hash ^= ComputeMotionSaliency.GetHashCode();
|
|
if (HasSelectSaliencyInliers) hash ^= SelectSaliencyInliers.GetHashCode();
|
|
if (HasFilterSaliency) hash ^= FilterSaliency.GetHashCode();
|
|
if (HasPostIrlsSmoothing) hash ^= PostIrlsSmoothing.GetHashCode();
|
|
if (HasRejectionTransformThreshold) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(RejectionTransformThreshold);
|
|
if (visualizationOptions_ != null) hash ^= VisualizationOptions.GetHashCode();
|
|
if (foregroundOptions_ != null) hash ^= ForegroundOptions.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 (flowOptions_ != null) {
|
|
output.WriteRawTag(10);
|
|
output.WriteMessage(FlowOptions);
|
|
}
|
|
if (motionOptions_ != null) {
|
|
output.WriteRawTag(18);
|
|
output.WriteMessage(MotionOptions);
|
|
}
|
|
if (saliencyOptions_ != null) {
|
|
output.WriteRawTag(26);
|
|
output.WriteMessage(SaliencyOptions);
|
|
}
|
|
if (HasEstimationClipSize) {
|
|
output.WriteRawTag(32);
|
|
output.WriteInt32(EstimationClipSize);
|
|
}
|
|
if (HasSubtractCameraMotionFromFeatures) {
|
|
output.WriteRawTag(40);
|
|
output.WriteBool(SubtractCameraMotionFromFeatures);
|
|
}
|
|
if (HasTrackIndex) {
|
|
output.WriteRawTag(48);
|
|
output.WriteInt32(TrackIndex);
|
|
}
|
|
if (HasComputeMotionSaliency) {
|
|
output.WriteRawTag(56);
|
|
output.WriteBool(ComputeMotionSaliency);
|
|
}
|
|
if (HasSelectSaliencyInliers) {
|
|
output.WriteRawTag(64);
|
|
output.WriteBool(SelectSaliencyInliers);
|
|
}
|
|
if (HasFilterSaliency) {
|
|
output.WriteRawTag(72);
|
|
output.WriteBool(FilterSaliency);
|
|
}
|
|
if (HasPostIrlsSmoothing) {
|
|
output.WriteRawTag(80);
|
|
output.WriteBool(PostIrlsSmoothing);
|
|
}
|
|
if (visualizationOptions_ != null) {
|
|
output.WriteRawTag(90);
|
|
output.WriteMessage(VisualizationOptions);
|
|
}
|
|
if (foregroundOptions_ != null) {
|
|
output.WriteRawTag(98);
|
|
output.WriteMessage(ForegroundOptions);
|
|
}
|
|
if (HasRejectionTransformThreshold) {
|
|
output.WriteRawTag(109);
|
|
output.WriteFloat(RejectionTransformThreshold);
|
|
}
|
|
if (HasAnalysisPolicy) {
|
|
output.WriteRawTag(112);
|
|
output.WriteEnum((int) AnalysisPolicy);
|
|
}
|
|
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 (flowOptions_ != null) {
|
|
output.WriteRawTag(10);
|
|
output.WriteMessage(FlowOptions);
|
|
}
|
|
if (motionOptions_ != null) {
|
|
output.WriteRawTag(18);
|
|
output.WriteMessage(MotionOptions);
|
|
}
|
|
if (saliencyOptions_ != null) {
|
|
output.WriteRawTag(26);
|
|
output.WriteMessage(SaliencyOptions);
|
|
}
|
|
if (HasEstimationClipSize) {
|
|
output.WriteRawTag(32);
|
|
output.WriteInt32(EstimationClipSize);
|
|
}
|
|
if (HasSubtractCameraMotionFromFeatures) {
|
|
output.WriteRawTag(40);
|
|
output.WriteBool(SubtractCameraMotionFromFeatures);
|
|
}
|
|
if (HasTrackIndex) {
|
|
output.WriteRawTag(48);
|
|
output.WriteInt32(TrackIndex);
|
|
}
|
|
if (HasComputeMotionSaliency) {
|
|
output.WriteRawTag(56);
|
|
output.WriteBool(ComputeMotionSaliency);
|
|
}
|
|
if (HasSelectSaliencyInliers) {
|
|
output.WriteRawTag(64);
|
|
output.WriteBool(SelectSaliencyInliers);
|
|
}
|
|
if (HasFilterSaliency) {
|
|
output.WriteRawTag(72);
|
|
output.WriteBool(FilterSaliency);
|
|
}
|
|
if (HasPostIrlsSmoothing) {
|
|
output.WriteRawTag(80);
|
|
output.WriteBool(PostIrlsSmoothing);
|
|
}
|
|
if (visualizationOptions_ != null) {
|
|
output.WriteRawTag(90);
|
|
output.WriteMessage(VisualizationOptions);
|
|
}
|
|
if (foregroundOptions_ != null) {
|
|
output.WriteRawTag(98);
|
|
output.WriteMessage(ForegroundOptions);
|
|
}
|
|
if (HasRejectionTransformThreshold) {
|
|
output.WriteRawTag(109);
|
|
output.WriteFloat(RejectionTransformThreshold);
|
|
}
|
|
if (HasAnalysisPolicy) {
|
|
output.WriteRawTag(112);
|
|
output.WriteEnum((int) AnalysisPolicy);
|
|
}
|
|
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 (HasAnalysisPolicy) {
|
|
size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) AnalysisPolicy);
|
|
}
|
|
if (flowOptions_ != null) {
|
|
size += 1 + pb::CodedOutputStream.ComputeMessageSize(FlowOptions);
|
|
}
|
|
if (motionOptions_ != null) {
|
|
size += 1 + pb::CodedOutputStream.ComputeMessageSize(MotionOptions);
|
|
}
|
|
if (saliencyOptions_ != null) {
|
|
size += 1 + pb::CodedOutputStream.ComputeMessageSize(SaliencyOptions);
|
|
}
|
|
if (HasEstimationClipSize) {
|
|
size += 1 + pb::CodedOutputStream.ComputeInt32Size(EstimationClipSize);
|
|
}
|
|
if (HasSubtractCameraMotionFromFeatures) {
|
|
size += 1 + 1;
|
|
}
|
|
if (HasTrackIndex) {
|
|
size += 1 + pb::CodedOutputStream.ComputeInt32Size(TrackIndex);
|
|
}
|
|
if (HasComputeMotionSaliency) {
|
|
size += 1 + 1;
|
|
}
|
|
if (HasSelectSaliencyInliers) {
|
|
size += 1 + 1;
|
|
}
|
|
if (HasFilterSaliency) {
|
|
size += 1 + 1;
|
|
}
|
|
if (HasPostIrlsSmoothing) {
|
|
size += 1 + 1;
|
|
}
|
|
if (HasRejectionTransformThreshold) {
|
|
size += 1 + 4;
|
|
}
|
|
if (visualizationOptions_ != null) {
|
|
size += 1 + pb::CodedOutputStream.ComputeMessageSize(VisualizationOptions);
|
|
}
|
|
if (foregroundOptions_ != null) {
|
|
size += 1 + pb::CodedOutputStream.ComputeMessageSize(ForegroundOptions);
|
|
}
|
|
if (_unknownFields != null) {
|
|
size += _unknownFields.CalculateSize();
|
|
}
|
|
return size;
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void MergeFrom(MotionAnalysisOptions other) {
|
|
if (other == null) {
|
|
return;
|
|
}
|
|
if (other.HasAnalysisPolicy) {
|
|
AnalysisPolicy = other.AnalysisPolicy;
|
|
}
|
|
if (other.flowOptions_ != null) {
|
|
if (flowOptions_ == null) {
|
|
FlowOptions = new global::Mediapipe.RegionFlowComputationOptions();
|
|
}
|
|
FlowOptions.MergeFrom(other.FlowOptions);
|
|
}
|
|
if (other.motionOptions_ != null) {
|
|
if (motionOptions_ == null) {
|
|
MotionOptions = new global::Mediapipe.MotionEstimationOptions();
|
|
}
|
|
MotionOptions.MergeFrom(other.MotionOptions);
|
|
}
|
|
if (other.saliencyOptions_ != null) {
|
|
if (saliencyOptions_ == null) {
|
|
SaliencyOptions = new global::Mediapipe.MotionSaliencyOptions();
|
|
}
|
|
SaliencyOptions.MergeFrom(other.SaliencyOptions);
|
|
}
|
|
if (other.HasEstimationClipSize) {
|
|
EstimationClipSize = other.EstimationClipSize;
|
|
}
|
|
if (other.HasSubtractCameraMotionFromFeatures) {
|
|
SubtractCameraMotionFromFeatures = other.SubtractCameraMotionFromFeatures;
|
|
}
|
|
if (other.HasTrackIndex) {
|
|
TrackIndex = other.TrackIndex;
|
|
}
|
|
if (other.HasComputeMotionSaliency) {
|
|
ComputeMotionSaliency = other.ComputeMotionSaliency;
|
|
}
|
|
if (other.HasSelectSaliencyInliers) {
|
|
SelectSaliencyInliers = other.SelectSaliencyInliers;
|
|
}
|
|
if (other.HasFilterSaliency) {
|
|
FilterSaliency = other.FilterSaliency;
|
|
}
|
|
if (other.HasPostIrlsSmoothing) {
|
|
PostIrlsSmoothing = other.PostIrlsSmoothing;
|
|
}
|
|
if (other.HasRejectionTransformThreshold) {
|
|
RejectionTransformThreshold = other.RejectionTransformThreshold;
|
|
}
|
|
if (other.visualizationOptions_ != null) {
|
|
if (visualizationOptions_ == null) {
|
|
VisualizationOptions = new global::Mediapipe.MotionAnalysisOptions.Types.VisualizationOptions();
|
|
}
|
|
VisualizationOptions.MergeFrom(other.VisualizationOptions);
|
|
}
|
|
if (other.foregroundOptions_ != null) {
|
|
if (foregroundOptions_ == null) {
|
|
ForegroundOptions = new global::Mediapipe.MotionAnalysisOptions.Types.ForegroundOptions();
|
|
}
|
|
ForegroundOptions.MergeFrom(other.ForegroundOptions);
|
|
}
|
|
_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: {
|
|
if (flowOptions_ == null) {
|
|
FlowOptions = new global::Mediapipe.RegionFlowComputationOptions();
|
|
}
|
|
input.ReadMessage(FlowOptions);
|
|
break;
|
|
}
|
|
case 18: {
|
|
if (motionOptions_ == null) {
|
|
MotionOptions = new global::Mediapipe.MotionEstimationOptions();
|
|
}
|
|
input.ReadMessage(MotionOptions);
|
|
break;
|
|
}
|
|
case 26: {
|
|
if (saliencyOptions_ == null) {
|
|
SaliencyOptions = new global::Mediapipe.MotionSaliencyOptions();
|
|
}
|
|
input.ReadMessage(SaliencyOptions);
|
|
break;
|
|
}
|
|
case 32: {
|
|
EstimationClipSize = input.ReadInt32();
|
|
break;
|
|
}
|
|
case 40: {
|
|
SubtractCameraMotionFromFeatures = input.ReadBool();
|
|
break;
|
|
}
|
|
case 48: {
|
|
TrackIndex = input.ReadInt32();
|
|
break;
|
|
}
|
|
case 56: {
|
|
ComputeMotionSaliency = input.ReadBool();
|
|
break;
|
|
}
|
|
case 64: {
|
|
SelectSaliencyInliers = input.ReadBool();
|
|
break;
|
|
}
|
|
case 72: {
|
|
FilterSaliency = input.ReadBool();
|
|
break;
|
|
}
|
|
case 80: {
|
|
PostIrlsSmoothing = input.ReadBool();
|
|
break;
|
|
}
|
|
case 90: {
|
|
if (visualizationOptions_ == null) {
|
|
VisualizationOptions = new global::Mediapipe.MotionAnalysisOptions.Types.VisualizationOptions();
|
|
}
|
|
input.ReadMessage(VisualizationOptions);
|
|
break;
|
|
}
|
|
case 98: {
|
|
if (foregroundOptions_ == null) {
|
|
ForegroundOptions = new global::Mediapipe.MotionAnalysisOptions.Types.ForegroundOptions();
|
|
}
|
|
input.ReadMessage(ForegroundOptions);
|
|
break;
|
|
}
|
|
case 109: {
|
|
RejectionTransformThreshold = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 112: {
|
|
AnalysisPolicy = (global::Mediapipe.MotionAnalysisOptions.Types.AnalysisPolicy) 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: {
|
|
if (flowOptions_ == null) {
|
|
FlowOptions = new global::Mediapipe.RegionFlowComputationOptions();
|
|
}
|
|
input.ReadMessage(FlowOptions);
|
|
break;
|
|
}
|
|
case 18: {
|
|
if (motionOptions_ == null) {
|
|
MotionOptions = new global::Mediapipe.MotionEstimationOptions();
|
|
}
|
|
input.ReadMessage(MotionOptions);
|
|
break;
|
|
}
|
|
case 26: {
|
|
if (saliencyOptions_ == null) {
|
|
SaliencyOptions = new global::Mediapipe.MotionSaliencyOptions();
|
|
}
|
|
input.ReadMessage(SaliencyOptions);
|
|
break;
|
|
}
|
|
case 32: {
|
|
EstimationClipSize = input.ReadInt32();
|
|
break;
|
|
}
|
|
case 40: {
|
|
SubtractCameraMotionFromFeatures = input.ReadBool();
|
|
break;
|
|
}
|
|
case 48: {
|
|
TrackIndex = input.ReadInt32();
|
|
break;
|
|
}
|
|
case 56: {
|
|
ComputeMotionSaliency = input.ReadBool();
|
|
break;
|
|
}
|
|
case 64: {
|
|
SelectSaliencyInliers = input.ReadBool();
|
|
break;
|
|
}
|
|
case 72: {
|
|
FilterSaliency = input.ReadBool();
|
|
break;
|
|
}
|
|
case 80: {
|
|
PostIrlsSmoothing = input.ReadBool();
|
|
break;
|
|
}
|
|
case 90: {
|
|
if (visualizationOptions_ == null) {
|
|
VisualizationOptions = new global::Mediapipe.MotionAnalysisOptions.Types.VisualizationOptions();
|
|
}
|
|
input.ReadMessage(VisualizationOptions);
|
|
break;
|
|
}
|
|
case 98: {
|
|
if (foregroundOptions_ == null) {
|
|
ForegroundOptions = new global::Mediapipe.MotionAnalysisOptions.Types.ForegroundOptions();
|
|
}
|
|
input.ReadMessage(ForegroundOptions);
|
|
break;
|
|
}
|
|
case 109: {
|
|
RejectionTransformThreshold = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 112: {
|
|
AnalysisPolicy = (global::Mediapipe.MotionAnalysisOptions.Types.AnalysisPolicy) input.ReadEnum();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
#region Nested types
|
|
/// <summary>Container for nested types declared in the MotionAnalysisOptions message type.</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public static partial class Types {
|
|
/// <summary>
|
|
/// Pre-configured policies for MotionAnalysis.
|
|
/// For general use, it is recommended to select an appropiate policy
|
|
/// instead of customizing flow and motion options by hand.
|
|
/// Policies are being kept up to date with appropiate settings.
|
|
/// </summary>
|
|
public enum AnalysisPolicy {
|
|
/// <summary>
|
|
/// Default legacy options. Effectivley no op.
|
|
/// </summary>
|
|
[pbr::OriginalName("ANALYSIS_POLICY_LEGACY")] Legacy = 0,
|
|
/// <summary>
|
|
/// Use for video.
|
|
/// </summary>
|
|
[pbr::OriginalName("ANALYSIS_POLICY_VIDEO")] Video = 1,
|
|
/// <summary>
|
|
/// Use for video on mobile.
|
|
/// </summary>
|
|
[pbr::OriginalName("ANALYSIS_POLICY_VIDEO_MOBILE")] VideoMobile = 2,
|
|
/// <summary>
|
|
/// Use if applied to camera stream on mobile, e.g.
|
|
/// low latency and high throughput.
|
|
/// ASSUMES DOWNSAMPLED INPUT, e.g. from GPU.
|
|
/// </summary>
|
|
[pbr::OriginalName("ANALYSIS_POLICY_CAMERA_MOBILE")] CameraMobile = 3,
|
|
/// <summary>
|
|
/// Use for sped up video / hyperlapse when adding frames with seeds
|
|
/// and rejection transforms. Mostly ups temporal consistency weights
|
|
/// and relaxes stability constraints.
|
|
/// Only recommended to be used as second pass after initial MotionAnalysis
|
|
/// and FrameSelection.
|
|
/// </summary>
|
|
[pbr::OriginalName("ANALYSIS_POLICY_HYPERLAPSE")] Hyperlapse = 4,
|
|
}
|
|
|
|
/// <summary>
|
|
/// Adapts visualization for rendered_results when passed to GetResults.
|
|
/// </summary>
|
|
public sealed partial class VisualizationOptions : pb::IMessage<VisualizationOptions>
|
|
#if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
|
|
, pb::IBufferMessage
|
|
#endif
|
|
{
|
|
private static readonly pb::MessageParser<VisualizationOptions> _parser = new pb::MessageParser<VisualizationOptions>(() => new VisualizationOptions());
|
|
private pb::UnknownFieldSet _unknownFields;
|
|
private int _hasBits0;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public static pb::MessageParser<VisualizationOptions> Parser { get { return _parser; } }
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public static pbr::MessageDescriptor Descriptor {
|
|
get { return global::Mediapipe.MotionAnalysisOptions.Descriptor.NestedTypes[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 VisualizationOptions() {
|
|
OnConstruction();
|
|
}
|
|
|
|
partial void OnConstruction();
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public VisualizationOptions(VisualizationOptions other) : this() {
|
|
_hasBits0 = other._hasBits0;
|
|
visualizeRegionFlowFeatures_ = other.visualizeRegionFlowFeatures_;
|
|
visualizeSalientPoints_ = other.visualizeSalientPoints_;
|
|
lineThickness_ = other.lineThickness_;
|
|
foregroundJetColoring_ = other.foregroundJetColoring_;
|
|
visualizeBlurAnalysisRegion_ = other.visualizeBlurAnalysisRegion_;
|
|
visualizeStats_ = other.visualizeStats_;
|
|
minLongFeatureTrack_ = other.minLongFeatureTrack_;
|
|
maxLongFeaturePoints_ = other.maxLongFeaturePoints_;
|
|
_unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public VisualizationOptions Clone() {
|
|
return new VisualizationOptions(this);
|
|
}
|
|
|
|
/// <summary>Field number for the "visualize_region_flow_features" field.</summary>
|
|
public const int VisualizeRegionFlowFeaturesFieldNumber = 1;
|
|
private readonly static bool VisualizeRegionFlowFeaturesDefaultValue = true;
|
|
|
|
private bool visualizeRegionFlowFeatures_;
|
|
/// <summary>
|
|
/// Visualizes tracked region flow features, colored w.r.t. fitting error.
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool VisualizeRegionFlowFeatures {
|
|
get { if ((_hasBits0 & 1) != 0) { return visualizeRegionFlowFeatures_; } else { return VisualizeRegionFlowFeaturesDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 1;
|
|
visualizeRegionFlowFeatures_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "visualize_region_flow_features" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasVisualizeRegionFlowFeatures {
|
|
get { return (_hasBits0 & 1) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "visualize_region_flow_features" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearVisualizeRegionFlowFeatures() {
|
|
_hasBits0 &= ~1;
|
|
}
|
|
|
|
/// <summary>Field number for the "visualize_salient_points" field.</summary>
|
|
public const int VisualizeSalientPointsFieldNumber = 2;
|
|
private readonly static bool VisualizeSalientPointsDefaultValue = false;
|
|
|
|
private bool visualizeSalientPoints_;
|
|
/// <summary>
|
|
/// Visualizes salient points. Only applicable is compute_motion_saliency is
|
|
/// set to true.
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool VisualizeSalientPoints {
|
|
get { if ((_hasBits0 & 2) != 0) { return visualizeSalientPoints_; } else { return VisualizeSalientPointsDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 2;
|
|
visualizeSalientPoints_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "visualize_salient_points" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasVisualizeSalientPoints {
|
|
get { return (_hasBits0 & 2) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "visualize_salient_points" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearVisualizeSalientPoints() {
|
|
_hasBits0 &= ~2;
|
|
}
|
|
|
|
/// <summary>Field number for the "line_thickness" field.</summary>
|
|
public const int LineThicknessFieldNumber = 5;
|
|
private readonly static int LineThicknessDefaultValue = 4;
|
|
|
|
private int lineThickness_;
|
|
/// <summary>
|
|
/// Line thickness of ellipse when rendering salient points.
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public int LineThickness {
|
|
get { if ((_hasBits0 & 16) != 0) { return lineThickness_; } else { return LineThicknessDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 16;
|
|
lineThickness_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "line_thickness" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasLineThickness {
|
|
get { return (_hasBits0 & 16) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "line_thickness" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearLineThickness() {
|
|
_hasBits0 &= ~16;
|
|
}
|
|
|
|
/// <summary>Field number for the "foreground_jet_coloring" field.</summary>
|
|
public const int ForegroundJetColoringFieldNumber = 3;
|
|
private readonly static bool ForegroundJetColoringDefaultValue = false;
|
|
|
|
private bool foregroundJetColoring_;
|
|
/// <summary>
|
|
/// Instead of green burn in uses jet coloring to indicate magnitude of
|
|
/// foreground motion.
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool ForegroundJetColoring {
|
|
get { if ((_hasBits0 & 4) != 0) { return foregroundJetColoring_; } else { return ForegroundJetColoringDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 4;
|
|
foregroundJetColoring_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "foreground_jet_coloring" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasForegroundJetColoring {
|
|
get { return (_hasBits0 & 4) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "foreground_jet_coloring" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearForegroundJetColoring() {
|
|
_hasBits0 &= ~4;
|
|
}
|
|
|
|
/// <summary>Field number for the "visualize_blur_analysis_region" field.</summary>
|
|
public const int VisualizeBlurAnalysisRegionFieldNumber = 4;
|
|
private readonly static bool VisualizeBlurAnalysisRegionDefaultValue = false;
|
|
|
|
private bool visualizeBlurAnalysisRegion_;
|
|
/// <summary>
|
|
/// If set, only keeps masks of pixels that is used for blur analysis, rest
|
|
/// is set to zero.
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool VisualizeBlurAnalysisRegion {
|
|
get { if ((_hasBits0 & 8) != 0) { return visualizeBlurAnalysisRegion_; } else { return VisualizeBlurAnalysisRegionDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 8;
|
|
visualizeBlurAnalysisRegion_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "visualize_blur_analysis_region" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasVisualizeBlurAnalysisRegion {
|
|
get { return (_hasBits0 & 8) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "visualize_blur_analysis_region" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearVisualizeBlurAnalysisRegion() {
|
|
_hasBits0 &= ~8;
|
|
}
|
|
|
|
/// <summary>Field number for the "visualize_stats" field.</summary>
|
|
public const int VisualizeStatsFieldNumber = 6;
|
|
private readonly static bool VisualizeStatsDefaultValue = true;
|
|
|
|
private bool visualizeStats_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool VisualizeStats {
|
|
get { if ((_hasBits0 & 32) != 0) { return visualizeStats_; } else { return VisualizeStatsDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 32;
|
|
visualizeStats_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "visualize_stats" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasVisualizeStats {
|
|
get { return (_hasBits0 & 32) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "visualize_stats" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearVisualizeStats() {
|
|
_hasBits0 &= ~32;
|
|
}
|
|
|
|
/// <summary>Field number for the "min_long_feature_track" field.</summary>
|
|
public const int MinLongFeatureTrackFieldNumber = 7;
|
|
private readonly static int MinLongFeatureTrackDefaultValue = 0;
|
|
|
|
private int minLongFeatureTrack_;
|
|
/// <summary>
|
|
/// Only long feature tracks with specified minimum length are rendered.
|
|
/// Set to zero to consider all tracks.
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public int MinLongFeatureTrack {
|
|
get { if ((_hasBits0 & 64) != 0) { return minLongFeatureTrack_; } else { return MinLongFeatureTrackDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 64;
|
|
minLongFeatureTrack_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "min_long_feature_track" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasMinLongFeatureTrack {
|
|
get { return (_hasBits0 & 64) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "min_long_feature_track" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearMinLongFeatureTrack() {
|
|
_hasBits0 &= ~64;
|
|
}
|
|
|
|
/// <summary>Field number for the "max_long_feature_points" field.</summary>
|
|
public const int MaxLongFeaturePointsFieldNumber = 8;
|
|
private readonly static int MaxLongFeaturePointsDefaultValue = 0;
|
|
|
|
private int maxLongFeaturePoints_;
|
|
/// <summary>
|
|
/// Only the last N points of a long feature track are rendered. Set to zero
|
|
/// to render all points.
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public int MaxLongFeaturePoints {
|
|
get { if ((_hasBits0 & 128) != 0) { return maxLongFeaturePoints_; } else { return MaxLongFeaturePointsDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 128;
|
|
maxLongFeaturePoints_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "max_long_feature_points" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasMaxLongFeaturePoints {
|
|
get { return (_hasBits0 & 128) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "max_long_feature_points" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearMaxLongFeaturePoints() {
|
|
_hasBits0 &= ~128;
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public override bool Equals(object other) {
|
|
return Equals(other as VisualizationOptions);
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool Equals(VisualizationOptions other) {
|
|
if (ReferenceEquals(other, null)) {
|
|
return false;
|
|
}
|
|
if (ReferenceEquals(other, this)) {
|
|
return true;
|
|
}
|
|
if (VisualizeRegionFlowFeatures != other.VisualizeRegionFlowFeatures) return false;
|
|
if (VisualizeSalientPoints != other.VisualizeSalientPoints) return false;
|
|
if (LineThickness != other.LineThickness) return false;
|
|
if (ForegroundJetColoring != other.ForegroundJetColoring) return false;
|
|
if (VisualizeBlurAnalysisRegion != other.VisualizeBlurAnalysisRegion) return false;
|
|
if (VisualizeStats != other.VisualizeStats) return false;
|
|
if (MinLongFeatureTrack != other.MinLongFeatureTrack) return false;
|
|
if (MaxLongFeaturePoints != other.MaxLongFeaturePoints) 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 (HasVisualizeRegionFlowFeatures) hash ^= VisualizeRegionFlowFeatures.GetHashCode();
|
|
if (HasVisualizeSalientPoints) hash ^= VisualizeSalientPoints.GetHashCode();
|
|
if (HasLineThickness) hash ^= LineThickness.GetHashCode();
|
|
if (HasForegroundJetColoring) hash ^= ForegroundJetColoring.GetHashCode();
|
|
if (HasVisualizeBlurAnalysisRegion) hash ^= VisualizeBlurAnalysisRegion.GetHashCode();
|
|
if (HasVisualizeStats) hash ^= VisualizeStats.GetHashCode();
|
|
if (HasMinLongFeatureTrack) hash ^= MinLongFeatureTrack.GetHashCode();
|
|
if (HasMaxLongFeaturePoints) hash ^= MaxLongFeaturePoints.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 (HasVisualizeRegionFlowFeatures) {
|
|
output.WriteRawTag(8);
|
|
output.WriteBool(VisualizeRegionFlowFeatures);
|
|
}
|
|
if (HasVisualizeSalientPoints) {
|
|
output.WriteRawTag(16);
|
|
output.WriteBool(VisualizeSalientPoints);
|
|
}
|
|
if (HasForegroundJetColoring) {
|
|
output.WriteRawTag(24);
|
|
output.WriteBool(ForegroundJetColoring);
|
|
}
|
|
if (HasVisualizeBlurAnalysisRegion) {
|
|
output.WriteRawTag(32);
|
|
output.WriteBool(VisualizeBlurAnalysisRegion);
|
|
}
|
|
if (HasLineThickness) {
|
|
output.WriteRawTag(40);
|
|
output.WriteInt32(LineThickness);
|
|
}
|
|
if (HasVisualizeStats) {
|
|
output.WriteRawTag(48);
|
|
output.WriteBool(VisualizeStats);
|
|
}
|
|
if (HasMinLongFeatureTrack) {
|
|
output.WriteRawTag(56);
|
|
output.WriteInt32(MinLongFeatureTrack);
|
|
}
|
|
if (HasMaxLongFeaturePoints) {
|
|
output.WriteRawTag(64);
|
|
output.WriteInt32(MaxLongFeaturePoints);
|
|
}
|
|
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 (HasVisualizeRegionFlowFeatures) {
|
|
output.WriteRawTag(8);
|
|
output.WriteBool(VisualizeRegionFlowFeatures);
|
|
}
|
|
if (HasVisualizeSalientPoints) {
|
|
output.WriteRawTag(16);
|
|
output.WriteBool(VisualizeSalientPoints);
|
|
}
|
|
if (HasForegroundJetColoring) {
|
|
output.WriteRawTag(24);
|
|
output.WriteBool(ForegroundJetColoring);
|
|
}
|
|
if (HasVisualizeBlurAnalysisRegion) {
|
|
output.WriteRawTag(32);
|
|
output.WriteBool(VisualizeBlurAnalysisRegion);
|
|
}
|
|
if (HasLineThickness) {
|
|
output.WriteRawTag(40);
|
|
output.WriteInt32(LineThickness);
|
|
}
|
|
if (HasVisualizeStats) {
|
|
output.WriteRawTag(48);
|
|
output.WriteBool(VisualizeStats);
|
|
}
|
|
if (HasMinLongFeatureTrack) {
|
|
output.WriteRawTag(56);
|
|
output.WriteInt32(MinLongFeatureTrack);
|
|
}
|
|
if (HasMaxLongFeaturePoints) {
|
|
output.WriteRawTag(64);
|
|
output.WriteInt32(MaxLongFeaturePoints);
|
|
}
|
|
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 (HasVisualizeRegionFlowFeatures) {
|
|
size += 1 + 1;
|
|
}
|
|
if (HasVisualizeSalientPoints) {
|
|
size += 1 + 1;
|
|
}
|
|
if (HasLineThickness) {
|
|
size += 1 + pb::CodedOutputStream.ComputeInt32Size(LineThickness);
|
|
}
|
|
if (HasForegroundJetColoring) {
|
|
size += 1 + 1;
|
|
}
|
|
if (HasVisualizeBlurAnalysisRegion) {
|
|
size += 1 + 1;
|
|
}
|
|
if (HasVisualizeStats) {
|
|
size += 1 + 1;
|
|
}
|
|
if (HasMinLongFeatureTrack) {
|
|
size += 1 + pb::CodedOutputStream.ComputeInt32Size(MinLongFeatureTrack);
|
|
}
|
|
if (HasMaxLongFeaturePoints) {
|
|
size += 1 + pb::CodedOutputStream.ComputeInt32Size(MaxLongFeaturePoints);
|
|
}
|
|
if (_unknownFields != null) {
|
|
size += _unknownFields.CalculateSize();
|
|
}
|
|
return size;
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void MergeFrom(VisualizationOptions other) {
|
|
if (other == null) {
|
|
return;
|
|
}
|
|
if (other.HasVisualizeRegionFlowFeatures) {
|
|
VisualizeRegionFlowFeatures = other.VisualizeRegionFlowFeatures;
|
|
}
|
|
if (other.HasVisualizeSalientPoints) {
|
|
VisualizeSalientPoints = other.VisualizeSalientPoints;
|
|
}
|
|
if (other.HasLineThickness) {
|
|
LineThickness = other.LineThickness;
|
|
}
|
|
if (other.HasForegroundJetColoring) {
|
|
ForegroundJetColoring = other.ForegroundJetColoring;
|
|
}
|
|
if (other.HasVisualizeBlurAnalysisRegion) {
|
|
VisualizeBlurAnalysisRegion = other.VisualizeBlurAnalysisRegion;
|
|
}
|
|
if (other.HasVisualizeStats) {
|
|
VisualizeStats = other.VisualizeStats;
|
|
}
|
|
if (other.HasMinLongFeatureTrack) {
|
|
MinLongFeatureTrack = other.MinLongFeatureTrack;
|
|
}
|
|
if (other.HasMaxLongFeaturePoints) {
|
|
MaxLongFeaturePoints = other.MaxLongFeaturePoints;
|
|
}
|
|
_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: {
|
|
VisualizeRegionFlowFeatures = input.ReadBool();
|
|
break;
|
|
}
|
|
case 16: {
|
|
VisualizeSalientPoints = input.ReadBool();
|
|
break;
|
|
}
|
|
case 24: {
|
|
ForegroundJetColoring = input.ReadBool();
|
|
break;
|
|
}
|
|
case 32: {
|
|
VisualizeBlurAnalysisRegion = input.ReadBool();
|
|
break;
|
|
}
|
|
case 40: {
|
|
LineThickness = input.ReadInt32();
|
|
break;
|
|
}
|
|
case 48: {
|
|
VisualizeStats = input.ReadBool();
|
|
break;
|
|
}
|
|
case 56: {
|
|
MinLongFeatureTrack = input.ReadInt32();
|
|
break;
|
|
}
|
|
case 64: {
|
|
MaxLongFeaturePoints = 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: {
|
|
VisualizeRegionFlowFeatures = input.ReadBool();
|
|
break;
|
|
}
|
|
case 16: {
|
|
VisualizeSalientPoints = input.ReadBool();
|
|
break;
|
|
}
|
|
case 24: {
|
|
ForegroundJetColoring = input.ReadBool();
|
|
break;
|
|
}
|
|
case 32: {
|
|
VisualizeBlurAnalysisRegion = input.ReadBool();
|
|
break;
|
|
}
|
|
case 40: {
|
|
LineThickness = input.ReadInt32();
|
|
break;
|
|
}
|
|
case 48: {
|
|
VisualizeStats = input.ReadBool();
|
|
break;
|
|
}
|
|
case 56: {
|
|
MinLongFeatureTrack = input.ReadInt32();
|
|
break;
|
|
}
|
|
case 64: {
|
|
MaxLongFeaturePoints = input.ReadInt32();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
}
|
|
|
|
/// <summary>
|
|
/// Describes how to compute foreground from features.
|
|
/// </summary>
|
|
public sealed partial class ForegroundOptions : pb::IMessage<ForegroundOptions>
|
|
#if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
|
|
, pb::IBufferMessage
|
|
#endif
|
|
{
|
|
private static readonly pb::MessageParser<ForegroundOptions> _parser = new pb::MessageParser<ForegroundOptions>(() => new ForegroundOptions());
|
|
private pb::UnknownFieldSet _unknownFields;
|
|
private int _hasBits0;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public static pb::MessageParser<ForegroundOptions> Parser { get { return _parser; } }
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public static pbr::MessageDescriptor Descriptor {
|
|
get { return global::Mediapipe.MotionAnalysisOptions.Descriptor.NestedTypes[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 ForegroundOptions() {
|
|
OnConstruction();
|
|
}
|
|
|
|
partial void OnConstruction();
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public ForegroundOptions(ForegroundOptions other) : this() {
|
|
_hasBits0 = other._hasBits0;
|
|
foregroundThreshold_ = other.foregroundThreshold_;
|
|
foregroundGamma_ = other.foregroundGamma_;
|
|
thresholdCoverageScaling_ = other.thresholdCoverageScaling_;
|
|
_unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public ForegroundOptions Clone() {
|
|
return new ForegroundOptions(this);
|
|
}
|
|
|
|
/// <summary>Field number for the "foreground_threshold" field.</summary>
|
|
public const int ForegroundThresholdFieldNumber = 1;
|
|
private readonly static float ForegroundThresholdDefaultValue = 0.5F;
|
|
|
|
private float foregroundThreshold_;
|
|
/// <summary>
|
|
/// Indicates the *inverse* registration error (i.e. the irls weight)
|
|
/// that is deemed a complete inlier.
|
|
/// Weights in the interval [0, foreground_threshold] (corresponding to
|
|
/// pixel errors in the interval [1 / foreground_threshold, inf])
|
|
/// are mappend to 1 - [0, 1], i.e. foreground threshold is mapped to zero
|
|
/// with weights below the threshold being assigned values > 0.
|
|
/// Therefore, larger values will increase amount of detected foreground
|
|
/// as well as noise.
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public float ForegroundThreshold {
|
|
get { if ((_hasBits0 & 1) != 0) { return foregroundThreshold_; } else { return ForegroundThresholdDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 1;
|
|
foregroundThreshold_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "foreground_threshold" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasForegroundThreshold {
|
|
get { return (_hasBits0 & 1) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "foreground_threshold" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearForegroundThreshold() {
|
|
_hasBits0 &= ~1;
|
|
}
|
|
|
|
/// <summary>Field number for the "foreground_gamma" field.</summary>
|
|
public const int ForegroundGammaFieldNumber = 2;
|
|
private readonly static float ForegroundGammaDefaultValue = 1F;
|
|
|
|
private float foregroundGamma_;
|
|
/// <summary>
|
|
/// By using foreground_gamma < 1.0 you can increase resolution of small
|
|
/// foreground motion at the expense of the resolution of large foreground
|
|
/// motions.
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public float ForegroundGamma {
|
|
get { if ((_hasBits0 & 2) != 0) { return foregroundGamma_; } else { return ForegroundGammaDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 2;
|
|
foregroundGamma_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "foreground_gamma" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasForegroundGamma {
|
|
get { return (_hasBits0 & 2) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "foreground_gamma" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearForegroundGamma() {
|
|
_hasBits0 &= ~2;
|
|
}
|
|
|
|
/// <summary>Field number for the "threshold_coverage_scaling" field.</summary>
|
|
public const int ThresholdCoverageScalingFieldNumber = 3;
|
|
private readonly static bool ThresholdCoverageScalingDefaultValue = true;
|
|
|
|
private bool thresholdCoverageScaling_;
|
|
/// <summary>
|
|
/// Threshold is scaled by coverage, i.e. for frames with large registration
|
|
/// error less forground is visualized.
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool ThresholdCoverageScaling {
|
|
get { if ((_hasBits0 & 4) != 0) { return thresholdCoverageScaling_; } else { return ThresholdCoverageScalingDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 4;
|
|
thresholdCoverageScaling_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "threshold_coverage_scaling" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasThresholdCoverageScaling {
|
|
get { return (_hasBits0 & 4) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "threshold_coverage_scaling" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearThresholdCoverageScaling() {
|
|
_hasBits0 &= ~4;
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public override bool Equals(object other) {
|
|
return Equals(other as ForegroundOptions);
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool Equals(ForegroundOptions other) {
|
|
if (ReferenceEquals(other, null)) {
|
|
return false;
|
|
}
|
|
if (ReferenceEquals(other, this)) {
|
|
return true;
|
|
}
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(ForegroundThreshold, other.ForegroundThreshold)) return false;
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(ForegroundGamma, other.ForegroundGamma)) return false;
|
|
if (ThresholdCoverageScaling != other.ThresholdCoverageScaling) 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 (HasForegroundThreshold) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(ForegroundThreshold);
|
|
if (HasForegroundGamma) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(ForegroundGamma);
|
|
if (HasThresholdCoverageScaling) hash ^= ThresholdCoverageScaling.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 (HasForegroundThreshold) {
|
|
output.WriteRawTag(13);
|
|
output.WriteFloat(ForegroundThreshold);
|
|
}
|
|
if (HasForegroundGamma) {
|
|
output.WriteRawTag(21);
|
|
output.WriteFloat(ForegroundGamma);
|
|
}
|
|
if (HasThresholdCoverageScaling) {
|
|
output.WriteRawTag(24);
|
|
output.WriteBool(ThresholdCoverageScaling);
|
|
}
|
|
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 (HasForegroundThreshold) {
|
|
output.WriteRawTag(13);
|
|
output.WriteFloat(ForegroundThreshold);
|
|
}
|
|
if (HasForegroundGamma) {
|
|
output.WriteRawTag(21);
|
|
output.WriteFloat(ForegroundGamma);
|
|
}
|
|
if (HasThresholdCoverageScaling) {
|
|
output.WriteRawTag(24);
|
|
output.WriteBool(ThresholdCoverageScaling);
|
|
}
|
|
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 (HasForegroundThreshold) {
|
|
size += 1 + 4;
|
|
}
|
|
if (HasForegroundGamma) {
|
|
size += 1 + 4;
|
|
}
|
|
if (HasThresholdCoverageScaling) {
|
|
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(ForegroundOptions other) {
|
|
if (other == null) {
|
|
return;
|
|
}
|
|
if (other.HasForegroundThreshold) {
|
|
ForegroundThreshold = other.ForegroundThreshold;
|
|
}
|
|
if (other.HasForegroundGamma) {
|
|
ForegroundGamma = other.ForegroundGamma;
|
|
}
|
|
if (other.HasThresholdCoverageScaling) {
|
|
ThresholdCoverageScaling = other.ThresholdCoverageScaling;
|
|
}
|
|
_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: {
|
|
ForegroundThreshold = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 21: {
|
|
ForegroundGamma = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 24: {
|
|
ThresholdCoverageScaling = 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 13: {
|
|
ForegroundThreshold = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 21: {
|
|
ForegroundGamma = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 24: {
|
|
ThresholdCoverageScaling = input.ReadBool();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
}
|
|
|
|
}
|
|
#endregion
|
|
|
|
}
|
|
|
|
#endregion
|
|
|
|
}
|
|
|
|
#endregion Designer generated code
|