3949 lines
152 KiB
C#
3949 lines
152 KiB
C#
// <auto-generated>
|
|
// Generated by the protocol buffer compiler. DO NOT EDIT!
|
|
// source: mediapipe/util/tracking/tone_estimation.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/tone_estimation.proto</summary>
|
|
public static partial class ToneEstimationReflection {
|
|
|
|
#region Descriptor
|
|
/// <summary>File descriptor for mediapipe/util/tracking/tone_estimation.proto</summary>
|
|
public static pbr::FileDescriptor Descriptor {
|
|
get { return descriptor; }
|
|
}
|
|
private static pbr::FileDescriptor descriptor;
|
|
|
|
static ToneEstimationReflection() {
|
|
byte[] descriptorData = global::System.Convert.FromBase64String(
|
|
string.Concat(
|
|
"Ci1tZWRpYXBpcGUvdXRpbC90cmFja2luZy90b25lX2VzdGltYXRpb24ucHJv",
|
|
"dG8SCW1lZGlhcGlwZRopbWVkaWFwaXBlL3V0aWwvdHJhY2tpbmcvdG9uZV9t",
|
|
"b2RlbHMucHJvdG8ilwUKClRvbmVDaGFuZ2USKwoJZ2Fpbl9iaWFzGAEgASgL",
|
|
"MhgubWVkaWFwaXBlLkdhaW5CaWFzTW9kZWwSKgoGYWZmaW5lGAIgASgLMhou",
|
|
"bWVkaWFwaXBlLkFmZmluZVRvbmVNb2RlbBI6ChFtaXh0dXJlX2dhaW5fYmlh",
|
|
"cxgDIAEoCzIfLm1lZGlhcGlwZS5NaXh0dXJlR2FpbkJpYXNNb2RlbBI5Cg5t",
|
|
"aXh0dXJlX2FmZmluZRgEIAEoCzIhLm1lZGlhcGlwZS5NaXh0dXJlQWZmaW5l",
|
|
"VG9uZU1vZGVsEhwKFG1peHR1cmVfZG9tYWluX3NpZ21hGAUgASgCEhcKDGZy",
|
|
"YWNfY2xpcHBlZBgGIAEoAjoBMBIWCg5sb3dfcGVyY2VudGlsZRgIIAEoAhIa",
|
|
"ChJsb3dfbWlkX3BlcmNlbnRpbGUYCSABKAISFgoObWlkX3BlcmNlbnRpbGUY",
|
|
"CiABKAISGwoTaGlnaF9taWRfcGVyY2VudGlsZRgLIAEoAhIXCg9oaWdoX3Bl",
|
|
"cmNlbnRpbGUYDCABKAISGQoKbG9nX2RvbWFpbhgNIAEoCDoFZmFsc2USLwoE",
|
|
"dHlwZRgOIAEoDjIaLm1lZGlhcGlwZS5Ub25lQ2hhbmdlLlR5cGU6BVZBTElE",
|
|
"Ej0KD3N0YWJpbGl0eV9zdGF0cxgPIAEoCzIkLm1lZGlhcGlwZS5Ub25lQ2hh",
|
|
"bmdlLlN0YWJpbGl0eVN0YXRzGlUKDlN0YWJpbGl0eVN0YXRzEhMKC251bV9p",
|
|
"bmxpZXJzGAEgASgFEhcKD2lubGllcl9mcmFjdGlvbhgCIAEoAhIVCg1pbmxp",
|
|
"ZXJfd2VpZ2h0GAMgASgBIh4KBFR5cGUSCQoFVkFMSUQQABILCgdJTlZBTElE",
|
|
"EAoi0gEKEFRvbmVNYXRjaE9wdGlvbnMSIgoUbWluX21hdGNoX3BlcmNlbnRp",
|
|
"bGUYASABKAI6BDAuMDESIgoUbWF4X21hdGNoX3BlcmNlbnRpbGUYAiABKAI6",
|
|
"BDAuOTkSIgoWbWF0Y2hfcGVyY2VudGlsZV9zdGVwcxgDIAEoBToCMTASGAoM",
|
|
"cGF0Y2hfcmFkaXVzGAQgASgFOgIxOBIdChBtYXhfZnJhY19jbGlwcGVkGAUg",
|
|
"ASgCOgMwLjQSGQoKbG9nX2RvbWFpbhgIIAEoCDoFZmFsc2UiiQEKD0NsaXBN",
|
|
"YXNrT3B0aW9ucxIaCgxtaW5fZXhwb3N1cmUYASABKAI6BDAuMDISGgoMbWF4",
|
|
"X2V4cG9zdXJlGAIgASgCOgQwLjk4Eh8KFG1heF9jbGlwcGVkX2NoYW5uZWxz",
|
|
"GAQgASgFOgExEh0KEmNsaXBfbWFza19kaWFtZXRlchgFIAEoBToBNSKBBwoV",
|
|
"VG9uZUVzdGltYXRpb25PcHRpb25zEjcKEnRvbmVfbWF0Y2hfb3B0aW9ucxgB",
|
|
"IAEoCzIbLm1lZGlhcGlwZS5Ub25lTWF0Y2hPcHRpb25zEjUKEWNsaXBfbWFz",
|
|
"a19vcHRpb25zGAIgASgLMhoubWVkaWFwaXBlLkNsaXBNYXNrT3B0aW9ucxIi",
|
|
"ChRzdGF0c19sb3dfcGVyY2VudGlsZRgDIAEoAjoEMC4wNRIlChhzdGF0c19s",
|
|
"b3dfbWlkX3BlcmNlbnRpbGUYBCABKAI6AzAuMhIhChRzdGF0c19taWRfcGVy",
|
|
"Y2VudGlsZRgFIAEoAjoDMC41EiYKGXN0YXRzX2hpZ2hfbWlkX3BlcmNlbnRp",
|
|
"bGUYBiABKAI6AzAuOBIjChVzdGF0c19oaWdoX3BlcmNlbnRpbGUYByABKAI6",
|
|
"BDAuOTUSGwoPaXJsc19pdGVyYXRpb25zGAggASgFOgIxMBJQChdzdGFibGVf",
|
|
"Z2Fpbl9iaWFzX2JvdW5kcxgJIAEoCzIvLm1lZGlhcGlwZS5Ub25lRXN0aW1h",
|
|
"dGlvbk9wdGlvbnMuR2FpbkJpYXNCb3VuZHMSWQoPZG93bnNhbXBsZV9tb2Rl",
|
|
"GAogASgOMi8ubWVkaWFwaXBlLlRvbmVFc3RpbWF0aW9uT3B0aW9ucy5Eb3du",
|
|
"c2FtcGxlTW9kZToPRE9XTlNBTVBMRV9OT05FEh4KEWRvd25zYW1wbGluZ19z",
|
|
"aXplGAsgASgFOgMyNTYSHAoRZG93bnNhbXBsZV9mYWN0b3IYDCABKAI6ATIa",
|
|
"uwEKDkdhaW5CaWFzQm91bmRzEiEKE21pbl9pbmxpZXJfZnJhY3Rpb24YASAB",
|
|
"KAI6BDAuNzUSHgoRbWluX2lubGllcl93ZWlnaHQYAiABKAI6AzAuNRIYCgps",
|
|
"b3dlcl9nYWluGAMgASgCOgQwLjc1EhkKCnVwcGVyX2dhaW4YBCABKAI6BTEu",
|
|
"MzM0EhgKCmxvd2VyX2JpYXMYBSABKAI6BC0wLjISFwoKdXBwZXJfYmlhcxgG",
|
|
"IAEoAjoDMC4yIncKDkRvd25zYW1wbGVNb2RlEhMKD0RPV05TQU1QTEVfTk9O",
|
|
"RRABEhoKFkRPV05TQU1QTEVfVE9fTUFYX1NJWkUQAhIYChRET1dOU0FNUExF",
|
|
"X0JZX0ZBQ1RPUhADEhoKFkRPV05TQU1QTEVfVE9fTUlOX1NJWkUQBCIvCglU",
|
|
"b25lTWF0Y2gSEAoIY3Vycl92YWwYASABKAISEAoIcHJldl92YWwYAiABKAIi",
|
|
"UgoOUGF0Y2hUb25lTWF0Y2gSKAoKdG9uZV9tYXRjaBgBIAMoCzIULm1lZGlh",
|
|
"cGlwZS5Ub25lTWF0Y2gSFgoLaXJsc193ZWlnaHQYAiABKAI6ATE="));
|
|
descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData,
|
|
new pbr::FileDescriptor[] { global::Mediapipe.ToneModelsReflection.Descriptor, },
|
|
new pbr::GeneratedClrTypeInfo(null, null, new pbr::GeneratedClrTypeInfo[] {
|
|
new pbr::GeneratedClrTypeInfo(typeof(global::Mediapipe.ToneChange), global::Mediapipe.ToneChange.Parser, new[]{ "GainBias", "Affine", "MixtureGainBias", "MixtureAffine", "MixtureDomainSigma", "FracClipped", "LowPercentile", "LowMidPercentile", "MidPercentile", "HighMidPercentile", "HighPercentile", "LogDomain", "Type", "StabilityStats" }, null, new[]{ typeof(global::Mediapipe.ToneChange.Types.Type) }, null, new pbr::GeneratedClrTypeInfo[] { new pbr::GeneratedClrTypeInfo(typeof(global::Mediapipe.ToneChange.Types.StabilityStats), global::Mediapipe.ToneChange.Types.StabilityStats.Parser, new[]{ "NumInliers", "InlierFraction", "InlierWeight" }, null, null, null, null)}),
|
|
new pbr::GeneratedClrTypeInfo(typeof(global::Mediapipe.ToneMatchOptions), global::Mediapipe.ToneMatchOptions.Parser, new[]{ "MinMatchPercentile", "MaxMatchPercentile", "MatchPercentileSteps", "PatchRadius", "MaxFracClipped", "LogDomain" }, null, null, null, null),
|
|
new pbr::GeneratedClrTypeInfo(typeof(global::Mediapipe.ClipMaskOptions), global::Mediapipe.ClipMaskOptions.Parser, new[]{ "MinExposure", "MaxExposure", "MaxClippedChannels", "ClipMaskDiameter" }, null, null, null, null),
|
|
new pbr::GeneratedClrTypeInfo(typeof(global::Mediapipe.ToneEstimationOptions), global::Mediapipe.ToneEstimationOptions.Parser, new[]{ "ToneMatchOptions", "ClipMaskOptions", "StatsLowPercentile", "StatsLowMidPercentile", "StatsMidPercentile", "StatsHighMidPercentile", "StatsHighPercentile", "IrlsIterations", "StableGainBiasBounds", "DownsampleMode", "DownsamplingSize", "DownsampleFactor" }, null, new[]{ typeof(global::Mediapipe.ToneEstimationOptions.Types.DownsampleMode) }, null, new pbr::GeneratedClrTypeInfo[] { new pbr::GeneratedClrTypeInfo(typeof(global::Mediapipe.ToneEstimationOptions.Types.GainBiasBounds), global::Mediapipe.ToneEstimationOptions.Types.GainBiasBounds.Parser, new[]{ "MinInlierFraction", "MinInlierWeight", "LowerGain", "UpperGain", "LowerBias", "UpperBias" }, null, null, null, null)}),
|
|
new pbr::GeneratedClrTypeInfo(typeof(global::Mediapipe.ToneMatch), global::Mediapipe.ToneMatch.Parser, new[]{ "CurrVal", "PrevVal" }, null, null, null, null),
|
|
new pbr::GeneratedClrTypeInfo(typeof(global::Mediapipe.PatchToneMatch), global::Mediapipe.PatchToneMatch.Parser, new[]{ "ToneMatch", "IrlsWeight" }, null, null, null, null)
|
|
}));
|
|
}
|
|
#endregion
|
|
|
|
}
|
|
#region Messages
|
|
/// <summary>
|
|
/// Capture tone change between two frames and per-frame tone statistics.
|
|
/// The estimated tone change describes the transformation of color intensities
|
|
/// from the current to the previous frame.
|
|
/// Next tag: 16
|
|
/// </summary>
|
|
public sealed partial class ToneChange : pb::IMessage<ToneChange>
|
|
#if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
|
|
, pb::IBufferMessage
|
|
#endif
|
|
{
|
|
private static readonly pb::MessageParser<ToneChange> _parser = new pb::MessageParser<ToneChange>(() => new ToneChange());
|
|
private pb::UnknownFieldSet _unknownFields;
|
|
private int _hasBits0;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public static pb::MessageParser<ToneChange> Parser { get { return _parser; } }
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public static pbr::MessageDescriptor Descriptor {
|
|
get { return global::Mediapipe.ToneEstimationReflection.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 ToneChange() {
|
|
OnConstruction();
|
|
}
|
|
|
|
partial void OnConstruction();
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public ToneChange(ToneChange other) : this() {
|
|
_hasBits0 = other._hasBits0;
|
|
gainBias_ = other.gainBias_ != null ? other.gainBias_.Clone() : null;
|
|
affine_ = other.affine_ != null ? other.affine_.Clone() : null;
|
|
mixtureGainBias_ = other.mixtureGainBias_ != null ? other.mixtureGainBias_.Clone() : null;
|
|
mixtureAffine_ = other.mixtureAffine_ != null ? other.mixtureAffine_.Clone() : null;
|
|
mixtureDomainSigma_ = other.mixtureDomainSigma_;
|
|
fracClipped_ = other.fracClipped_;
|
|
lowPercentile_ = other.lowPercentile_;
|
|
lowMidPercentile_ = other.lowMidPercentile_;
|
|
midPercentile_ = other.midPercentile_;
|
|
highMidPercentile_ = other.highMidPercentile_;
|
|
highPercentile_ = other.highPercentile_;
|
|
logDomain_ = other.logDomain_;
|
|
type_ = other.type_;
|
|
stabilityStats_ = other.stabilityStats_ != null ? other.stabilityStats_.Clone() : null;
|
|
_unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public ToneChange Clone() {
|
|
return new ToneChange(this);
|
|
}
|
|
|
|
/// <summary>Field number for the "gain_bias" field.</summary>
|
|
public const int GainBiasFieldNumber = 1;
|
|
private global::Mediapipe.GainBiasModel gainBias_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public global::Mediapipe.GainBiasModel GainBias {
|
|
get { return gainBias_; }
|
|
set {
|
|
gainBias_ = value;
|
|
}
|
|
}
|
|
|
|
/// <summary>Field number for the "affine" field.</summary>
|
|
public const int AffineFieldNumber = 2;
|
|
private global::Mediapipe.AffineToneModel affine_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public global::Mediapipe.AffineToneModel Affine {
|
|
get { return affine_; }
|
|
set {
|
|
affine_ = value;
|
|
}
|
|
}
|
|
|
|
/// <summary>Field number for the "mixture_gain_bias" field.</summary>
|
|
public const int MixtureGainBiasFieldNumber = 3;
|
|
private global::Mediapipe.MixtureGainBiasModel mixtureGainBias_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public global::Mediapipe.MixtureGainBiasModel MixtureGainBias {
|
|
get { return mixtureGainBias_; }
|
|
set {
|
|
mixtureGainBias_ = value;
|
|
}
|
|
}
|
|
|
|
/// <summary>Field number for the "mixture_affine" field.</summary>
|
|
public const int MixtureAffineFieldNumber = 4;
|
|
private global::Mediapipe.MixtureAffineToneModel mixtureAffine_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public global::Mediapipe.MixtureAffineToneModel MixtureAffine {
|
|
get { return mixtureAffine_; }
|
|
set {
|
|
mixtureAffine_ = value;
|
|
}
|
|
}
|
|
|
|
/// <summary>Field number for the "mixture_domain_sigma" field.</summary>
|
|
public const int MixtureDomainSigmaFieldNumber = 5;
|
|
private readonly static float MixtureDomainSigmaDefaultValue = 0F;
|
|
|
|
private float mixtureDomainSigma_;
|
|
/// <summary>
|
|
/// TODO: Implement.
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public float MixtureDomainSigma {
|
|
get { if ((_hasBits0 & 1) != 0) { return mixtureDomainSigma_; } else { return MixtureDomainSigmaDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 1;
|
|
mixtureDomainSigma_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "mixture_domain_sigma" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasMixtureDomainSigma {
|
|
get { return (_hasBits0 & 1) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "mixture_domain_sigma" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearMixtureDomainSigma() {
|
|
_hasBits0 &= ~1;
|
|
}
|
|
|
|
/// <summary>Field number for the "frac_clipped" field.</summary>
|
|
public const int FracClippedFieldNumber = 6;
|
|
private readonly static float FracClippedDefaultValue = 0F;
|
|
|
|
private float fracClipped_;
|
|
/// <summary>
|
|
/// Fraction of clipped pixels in [0, 1].
|
|
/// A pixel is considered clipped if more than
|
|
/// ToneEstimationOptions::max_clipped_channels are over-
|
|
/// or under exposed.
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public float FracClipped {
|
|
get { if ((_hasBits0 & 2) != 0) { return fracClipped_; } else { return FracClippedDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 2;
|
|
fracClipped_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "frac_clipped" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasFracClipped {
|
|
get { return (_hasBits0 & 2) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "frac_clipped" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearFracClipped() {
|
|
_hasBits0 &= ~2;
|
|
}
|
|
|
|
/// <summary>Field number for the "low_percentile" field.</summary>
|
|
public const int LowPercentileFieldNumber = 8;
|
|
private readonly static float LowPercentileDefaultValue = 0F;
|
|
|
|
private float lowPercentile_;
|
|
/// <summary>
|
|
/// [low|mid|high]_percentile's.
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public float LowPercentile {
|
|
get { if ((_hasBits0 & 4) != 0) { return lowPercentile_; } else { return LowPercentileDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 4;
|
|
lowPercentile_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "low_percentile" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasLowPercentile {
|
|
get { return (_hasBits0 & 4) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "low_percentile" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearLowPercentile() {
|
|
_hasBits0 &= ~4;
|
|
}
|
|
|
|
/// <summary>Field number for the "low_mid_percentile" field.</summary>
|
|
public const int LowMidPercentileFieldNumber = 9;
|
|
private readonly static float LowMidPercentileDefaultValue = 0F;
|
|
|
|
private float lowMidPercentile_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public float LowMidPercentile {
|
|
get { if ((_hasBits0 & 8) != 0) { return lowMidPercentile_; } else { return LowMidPercentileDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 8;
|
|
lowMidPercentile_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "low_mid_percentile" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasLowMidPercentile {
|
|
get { return (_hasBits0 & 8) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "low_mid_percentile" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearLowMidPercentile() {
|
|
_hasBits0 &= ~8;
|
|
}
|
|
|
|
/// <summary>Field number for the "mid_percentile" field.</summary>
|
|
public const int MidPercentileFieldNumber = 10;
|
|
private readonly static float MidPercentileDefaultValue = 0F;
|
|
|
|
private float midPercentile_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public float MidPercentile {
|
|
get { if ((_hasBits0 & 16) != 0) { return midPercentile_; } else { return MidPercentileDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 16;
|
|
midPercentile_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "mid_percentile" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasMidPercentile {
|
|
get { return (_hasBits0 & 16) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "mid_percentile" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearMidPercentile() {
|
|
_hasBits0 &= ~16;
|
|
}
|
|
|
|
/// <summary>Field number for the "high_mid_percentile" field.</summary>
|
|
public const int HighMidPercentileFieldNumber = 11;
|
|
private readonly static float HighMidPercentileDefaultValue = 0F;
|
|
|
|
private float highMidPercentile_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public float HighMidPercentile {
|
|
get { if ((_hasBits0 & 32) != 0) { return highMidPercentile_; } else { return HighMidPercentileDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 32;
|
|
highMidPercentile_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "high_mid_percentile" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasHighMidPercentile {
|
|
get { return (_hasBits0 & 32) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "high_mid_percentile" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearHighMidPercentile() {
|
|
_hasBits0 &= ~32;
|
|
}
|
|
|
|
/// <summary>Field number for the "high_percentile" field.</summary>
|
|
public const int HighPercentileFieldNumber = 12;
|
|
private readonly static float HighPercentileDefaultValue = 0F;
|
|
|
|
private float highPercentile_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public float HighPercentile {
|
|
get { if ((_hasBits0 & 64) != 0) { return highPercentile_; } else { return HighPercentileDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 64;
|
|
highPercentile_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "high_percentile" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasHighPercentile {
|
|
get { return (_hasBits0 & 64) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "high_percentile" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearHighPercentile() {
|
|
_hasBits0 &= ~64;
|
|
}
|
|
|
|
/// <summary>Field number for the "log_domain" field.</summary>
|
|
public const int LogDomainFieldNumber = 13;
|
|
private readonly static bool LogDomainDefaultValue = false;
|
|
|
|
private bool logDomain_;
|
|
/// <summary>
|
|
/// If set, all models are estimated in log domain, specifically
|
|
/// intensity I is transformed via log(1.0 + I) := I'
|
|
/// Consequently after apply the models, intensity needs to be transformed
|
|
/// back to visible range via exp(I') - 1.0.
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool LogDomain {
|
|
get { if ((_hasBits0 & 128) != 0) { return logDomain_; } else { return LogDomainDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 128;
|
|
logDomain_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "log_domain" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasLogDomain {
|
|
get { return (_hasBits0 & 128) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "log_domain" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearLogDomain() {
|
|
_hasBits0 &= ~128;
|
|
}
|
|
|
|
/// <summary>Field number for the "type" field.</summary>
|
|
public const int TypeFieldNumber = 14;
|
|
private readonly static global::Mediapipe.ToneChange.Types.Type TypeDefaultValue = global::Mediapipe.ToneChange.Types.Type.Valid;
|
|
|
|
private global::Mediapipe.ToneChange.Types.Type type_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public global::Mediapipe.ToneChange.Types.Type Type {
|
|
get { if ((_hasBits0 & 256) != 0) { return type_; } else { return TypeDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 256;
|
|
type_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "type" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasType {
|
|
get { return (_hasBits0 & 256) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "type" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearType() {
|
|
_hasBits0 &= ~256;
|
|
}
|
|
|
|
/// <summary>Field number for the "stability_stats" field.</summary>
|
|
public const int StabilityStatsFieldNumber = 15;
|
|
private global::Mediapipe.ToneChange.Types.StabilityStats stabilityStats_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public global::Mediapipe.ToneChange.Types.StabilityStats StabilityStats {
|
|
get { return stabilityStats_; }
|
|
set {
|
|
stabilityStats_ = value;
|
|
}
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public override bool Equals(object other) {
|
|
return Equals(other as ToneChange);
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool Equals(ToneChange other) {
|
|
if (ReferenceEquals(other, null)) {
|
|
return false;
|
|
}
|
|
if (ReferenceEquals(other, this)) {
|
|
return true;
|
|
}
|
|
if (!object.Equals(GainBias, other.GainBias)) return false;
|
|
if (!object.Equals(Affine, other.Affine)) return false;
|
|
if (!object.Equals(MixtureGainBias, other.MixtureGainBias)) return false;
|
|
if (!object.Equals(MixtureAffine, other.MixtureAffine)) return false;
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(MixtureDomainSigma, other.MixtureDomainSigma)) return false;
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(FracClipped, other.FracClipped)) return false;
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(LowPercentile, other.LowPercentile)) return false;
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(LowMidPercentile, other.LowMidPercentile)) return false;
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(MidPercentile, other.MidPercentile)) return false;
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(HighMidPercentile, other.HighMidPercentile)) return false;
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(HighPercentile, other.HighPercentile)) return false;
|
|
if (LogDomain != other.LogDomain) return false;
|
|
if (Type != other.Type) return false;
|
|
if (!object.Equals(StabilityStats, other.StabilityStats)) 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 (gainBias_ != null) hash ^= GainBias.GetHashCode();
|
|
if (affine_ != null) hash ^= Affine.GetHashCode();
|
|
if (mixtureGainBias_ != null) hash ^= MixtureGainBias.GetHashCode();
|
|
if (mixtureAffine_ != null) hash ^= MixtureAffine.GetHashCode();
|
|
if (HasMixtureDomainSigma) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(MixtureDomainSigma);
|
|
if (HasFracClipped) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(FracClipped);
|
|
if (HasLowPercentile) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(LowPercentile);
|
|
if (HasLowMidPercentile) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(LowMidPercentile);
|
|
if (HasMidPercentile) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(MidPercentile);
|
|
if (HasHighMidPercentile) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(HighMidPercentile);
|
|
if (HasHighPercentile) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(HighPercentile);
|
|
if (HasLogDomain) hash ^= LogDomain.GetHashCode();
|
|
if (HasType) hash ^= Type.GetHashCode();
|
|
if (stabilityStats_ != null) hash ^= StabilityStats.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 (gainBias_ != null) {
|
|
output.WriteRawTag(10);
|
|
output.WriteMessage(GainBias);
|
|
}
|
|
if (affine_ != null) {
|
|
output.WriteRawTag(18);
|
|
output.WriteMessage(Affine);
|
|
}
|
|
if (mixtureGainBias_ != null) {
|
|
output.WriteRawTag(26);
|
|
output.WriteMessage(MixtureGainBias);
|
|
}
|
|
if (mixtureAffine_ != null) {
|
|
output.WriteRawTag(34);
|
|
output.WriteMessage(MixtureAffine);
|
|
}
|
|
if (HasMixtureDomainSigma) {
|
|
output.WriteRawTag(45);
|
|
output.WriteFloat(MixtureDomainSigma);
|
|
}
|
|
if (HasFracClipped) {
|
|
output.WriteRawTag(53);
|
|
output.WriteFloat(FracClipped);
|
|
}
|
|
if (HasLowPercentile) {
|
|
output.WriteRawTag(69);
|
|
output.WriteFloat(LowPercentile);
|
|
}
|
|
if (HasLowMidPercentile) {
|
|
output.WriteRawTag(77);
|
|
output.WriteFloat(LowMidPercentile);
|
|
}
|
|
if (HasMidPercentile) {
|
|
output.WriteRawTag(85);
|
|
output.WriteFloat(MidPercentile);
|
|
}
|
|
if (HasHighMidPercentile) {
|
|
output.WriteRawTag(93);
|
|
output.WriteFloat(HighMidPercentile);
|
|
}
|
|
if (HasHighPercentile) {
|
|
output.WriteRawTag(101);
|
|
output.WriteFloat(HighPercentile);
|
|
}
|
|
if (HasLogDomain) {
|
|
output.WriteRawTag(104);
|
|
output.WriteBool(LogDomain);
|
|
}
|
|
if (HasType) {
|
|
output.WriteRawTag(112);
|
|
output.WriteEnum((int) Type);
|
|
}
|
|
if (stabilityStats_ != null) {
|
|
output.WriteRawTag(122);
|
|
output.WriteMessage(StabilityStats);
|
|
}
|
|
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 (gainBias_ != null) {
|
|
output.WriteRawTag(10);
|
|
output.WriteMessage(GainBias);
|
|
}
|
|
if (affine_ != null) {
|
|
output.WriteRawTag(18);
|
|
output.WriteMessage(Affine);
|
|
}
|
|
if (mixtureGainBias_ != null) {
|
|
output.WriteRawTag(26);
|
|
output.WriteMessage(MixtureGainBias);
|
|
}
|
|
if (mixtureAffine_ != null) {
|
|
output.WriteRawTag(34);
|
|
output.WriteMessage(MixtureAffine);
|
|
}
|
|
if (HasMixtureDomainSigma) {
|
|
output.WriteRawTag(45);
|
|
output.WriteFloat(MixtureDomainSigma);
|
|
}
|
|
if (HasFracClipped) {
|
|
output.WriteRawTag(53);
|
|
output.WriteFloat(FracClipped);
|
|
}
|
|
if (HasLowPercentile) {
|
|
output.WriteRawTag(69);
|
|
output.WriteFloat(LowPercentile);
|
|
}
|
|
if (HasLowMidPercentile) {
|
|
output.WriteRawTag(77);
|
|
output.WriteFloat(LowMidPercentile);
|
|
}
|
|
if (HasMidPercentile) {
|
|
output.WriteRawTag(85);
|
|
output.WriteFloat(MidPercentile);
|
|
}
|
|
if (HasHighMidPercentile) {
|
|
output.WriteRawTag(93);
|
|
output.WriteFloat(HighMidPercentile);
|
|
}
|
|
if (HasHighPercentile) {
|
|
output.WriteRawTag(101);
|
|
output.WriteFloat(HighPercentile);
|
|
}
|
|
if (HasLogDomain) {
|
|
output.WriteRawTag(104);
|
|
output.WriteBool(LogDomain);
|
|
}
|
|
if (HasType) {
|
|
output.WriteRawTag(112);
|
|
output.WriteEnum((int) Type);
|
|
}
|
|
if (stabilityStats_ != null) {
|
|
output.WriteRawTag(122);
|
|
output.WriteMessage(StabilityStats);
|
|
}
|
|
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 (gainBias_ != null) {
|
|
size += 1 + pb::CodedOutputStream.ComputeMessageSize(GainBias);
|
|
}
|
|
if (affine_ != null) {
|
|
size += 1 + pb::CodedOutputStream.ComputeMessageSize(Affine);
|
|
}
|
|
if (mixtureGainBias_ != null) {
|
|
size += 1 + pb::CodedOutputStream.ComputeMessageSize(MixtureGainBias);
|
|
}
|
|
if (mixtureAffine_ != null) {
|
|
size += 1 + pb::CodedOutputStream.ComputeMessageSize(MixtureAffine);
|
|
}
|
|
if (HasMixtureDomainSigma) {
|
|
size += 1 + 4;
|
|
}
|
|
if (HasFracClipped) {
|
|
size += 1 + 4;
|
|
}
|
|
if (HasLowPercentile) {
|
|
size += 1 + 4;
|
|
}
|
|
if (HasLowMidPercentile) {
|
|
size += 1 + 4;
|
|
}
|
|
if (HasMidPercentile) {
|
|
size += 1 + 4;
|
|
}
|
|
if (HasHighMidPercentile) {
|
|
size += 1 + 4;
|
|
}
|
|
if (HasHighPercentile) {
|
|
size += 1 + 4;
|
|
}
|
|
if (HasLogDomain) {
|
|
size += 1 + 1;
|
|
}
|
|
if (HasType) {
|
|
size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) Type);
|
|
}
|
|
if (stabilityStats_ != null) {
|
|
size += 1 + pb::CodedOutputStream.ComputeMessageSize(StabilityStats);
|
|
}
|
|
if (_unknownFields != null) {
|
|
size += _unknownFields.CalculateSize();
|
|
}
|
|
return size;
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void MergeFrom(ToneChange other) {
|
|
if (other == null) {
|
|
return;
|
|
}
|
|
if (other.gainBias_ != null) {
|
|
if (gainBias_ == null) {
|
|
GainBias = new global::Mediapipe.GainBiasModel();
|
|
}
|
|
GainBias.MergeFrom(other.GainBias);
|
|
}
|
|
if (other.affine_ != null) {
|
|
if (affine_ == null) {
|
|
Affine = new global::Mediapipe.AffineToneModel();
|
|
}
|
|
Affine.MergeFrom(other.Affine);
|
|
}
|
|
if (other.mixtureGainBias_ != null) {
|
|
if (mixtureGainBias_ == null) {
|
|
MixtureGainBias = new global::Mediapipe.MixtureGainBiasModel();
|
|
}
|
|
MixtureGainBias.MergeFrom(other.MixtureGainBias);
|
|
}
|
|
if (other.mixtureAffine_ != null) {
|
|
if (mixtureAffine_ == null) {
|
|
MixtureAffine = new global::Mediapipe.MixtureAffineToneModel();
|
|
}
|
|
MixtureAffine.MergeFrom(other.MixtureAffine);
|
|
}
|
|
if (other.HasMixtureDomainSigma) {
|
|
MixtureDomainSigma = other.MixtureDomainSigma;
|
|
}
|
|
if (other.HasFracClipped) {
|
|
FracClipped = other.FracClipped;
|
|
}
|
|
if (other.HasLowPercentile) {
|
|
LowPercentile = other.LowPercentile;
|
|
}
|
|
if (other.HasLowMidPercentile) {
|
|
LowMidPercentile = other.LowMidPercentile;
|
|
}
|
|
if (other.HasMidPercentile) {
|
|
MidPercentile = other.MidPercentile;
|
|
}
|
|
if (other.HasHighMidPercentile) {
|
|
HighMidPercentile = other.HighMidPercentile;
|
|
}
|
|
if (other.HasHighPercentile) {
|
|
HighPercentile = other.HighPercentile;
|
|
}
|
|
if (other.HasLogDomain) {
|
|
LogDomain = other.LogDomain;
|
|
}
|
|
if (other.HasType) {
|
|
Type = other.Type;
|
|
}
|
|
if (other.stabilityStats_ != null) {
|
|
if (stabilityStats_ == null) {
|
|
StabilityStats = new global::Mediapipe.ToneChange.Types.StabilityStats();
|
|
}
|
|
StabilityStats.MergeFrom(other.StabilityStats);
|
|
}
|
|
_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 (gainBias_ == null) {
|
|
GainBias = new global::Mediapipe.GainBiasModel();
|
|
}
|
|
input.ReadMessage(GainBias);
|
|
break;
|
|
}
|
|
case 18: {
|
|
if (affine_ == null) {
|
|
Affine = new global::Mediapipe.AffineToneModel();
|
|
}
|
|
input.ReadMessage(Affine);
|
|
break;
|
|
}
|
|
case 26: {
|
|
if (mixtureGainBias_ == null) {
|
|
MixtureGainBias = new global::Mediapipe.MixtureGainBiasModel();
|
|
}
|
|
input.ReadMessage(MixtureGainBias);
|
|
break;
|
|
}
|
|
case 34: {
|
|
if (mixtureAffine_ == null) {
|
|
MixtureAffine = new global::Mediapipe.MixtureAffineToneModel();
|
|
}
|
|
input.ReadMessage(MixtureAffine);
|
|
break;
|
|
}
|
|
case 45: {
|
|
MixtureDomainSigma = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 53: {
|
|
FracClipped = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 69: {
|
|
LowPercentile = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 77: {
|
|
LowMidPercentile = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 85: {
|
|
MidPercentile = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 93: {
|
|
HighMidPercentile = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 101: {
|
|
HighPercentile = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 104: {
|
|
LogDomain = input.ReadBool();
|
|
break;
|
|
}
|
|
case 112: {
|
|
Type = (global::Mediapipe.ToneChange.Types.Type) input.ReadEnum();
|
|
break;
|
|
}
|
|
case 122: {
|
|
if (stabilityStats_ == null) {
|
|
StabilityStats = new global::Mediapipe.ToneChange.Types.StabilityStats();
|
|
}
|
|
input.ReadMessage(StabilityStats);
|
|
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 (gainBias_ == null) {
|
|
GainBias = new global::Mediapipe.GainBiasModel();
|
|
}
|
|
input.ReadMessage(GainBias);
|
|
break;
|
|
}
|
|
case 18: {
|
|
if (affine_ == null) {
|
|
Affine = new global::Mediapipe.AffineToneModel();
|
|
}
|
|
input.ReadMessage(Affine);
|
|
break;
|
|
}
|
|
case 26: {
|
|
if (mixtureGainBias_ == null) {
|
|
MixtureGainBias = new global::Mediapipe.MixtureGainBiasModel();
|
|
}
|
|
input.ReadMessage(MixtureGainBias);
|
|
break;
|
|
}
|
|
case 34: {
|
|
if (mixtureAffine_ == null) {
|
|
MixtureAffine = new global::Mediapipe.MixtureAffineToneModel();
|
|
}
|
|
input.ReadMessage(MixtureAffine);
|
|
break;
|
|
}
|
|
case 45: {
|
|
MixtureDomainSigma = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 53: {
|
|
FracClipped = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 69: {
|
|
LowPercentile = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 77: {
|
|
LowMidPercentile = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 85: {
|
|
MidPercentile = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 93: {
|
|
HighMidPercentile = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 101: {
|
|
HighPercentile = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 104: {
|
|
LogDomain = input.ReadBool();
|
|
break;
|
|
}
|
|
case 112: {
|
|
Type = (global::Mediapipe.ToneChange.Types.Type) input.ReadEnum();
|
|
break;
|
|
}
|
|
case 122: {
|
|
if (stabilityStats_ == null) {
|
|
StabilityStats = new global::Mediapipe.ToneChange.Types.StabilityStats();
|
|
}
|
|
input.ReadMessage(StabilityStats);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
#region Nested types
|
|
/// <summary>Container for nested types declared in the ToneChange message type.</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public static partial class Types {
|
|
/// <summary>
|
|
/// ToneChange type indicates whether highest degree of freedom (DOF)
|
|
/// model estimation was deemed stable, in which case ToneChange::Type is set
|
|
/// to VALID.
|
|
/// If a model was deemed not stable (according to *StabilityBounds in
|
|
/// ToneEstimationOptions), it is set to the lower dof type which was deemed
|
|
/// stable.
|
|
/// </summary>
|
|
public enum Type {
|
|
[pbr::OriginalName("VALID")] Valid = 0,
|
|
/// <summary>
|
|
/// Identity model, gain bias unrealiable.
|
|
/// </summary>
|
|
[pbr::OriginalName("INVALID")] Invalid = 10,
|
|
}
|
|
|
|
/// <summary>
|
|
/// Stats based on stability analysis.
|
|
/// </summary>
|
|
public sealed partial class StabilityStats : pb::IMessage<StabilityStats>
|
|
#if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
|
|
, pb::IBufferMessage
|
|
#endif
|
|
{
|
|
private static readonly pb::MessageParser<StabilityStats> _parser = new pb::MessageParser<StabilityStats>(() => new StabilityStats());
|
|
private pb::UnknownFieldSet _unknownFields;
|
|
private int _hasBits0;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public static pb::MessageParser<StabilityStats> Parser { get { return _parser; } }
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public static pbr::MessageDescriptor Descriptor {
|
|
get { return global::Mediapipe.ToneChange.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 StabilityStats() {
|
|
OnConstruction();
|
|
}
|
|
|
|
partial void OnConstruction();
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public StabilityStats(StabilityStats other) : this() {
|
|
_hasBits0 = other._hasBits0;
|
|
numInliers_ = other.numInliers_;
|
|
inlierFraction_ = other.inlierFraction_;
|
|
inlierWeight_ = other.inlierWeight_;
|
|
_unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public StabilityStats Clone() {
|
|
return new StabilityStats(this);
|
|
}
|
|
|
|
/// <summary>Field number for the "num_inliers" field.</summary>
|
|
public const int NumInliersFieldNumber = 1;
|
|
private readonly static int NumInliersDefaultValue = 0;
|
|
|
|
private int numInliers_;
|
|
/// <summary>
|
|
/// Number of tone matches that were iniliers (used for tone estimation).
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public int NumInliers {
|
|
get { if ((_hasBits0 & 1) != 0) { return numInliers_; } else { return NumInliersDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 1;
|
|
numInliers_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "num_inliers" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasNumInliers {
|
|
get { return (_hasBits0 & 1) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "num_inliers" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearNumInliers() {
|
|
_hasBits0 &= ~1;
|
|
}
|
|
|
|
/// <summary>Field number for the "inlier_fraction" field.</summary>
|
|
public const int InlierFractionFieldNumber = 2;
|
|
private readonly static float InlierFractionDefaultValue = 0F;
|
|
|
|
private float inlierFraction_;
|
|
/// <summary>
|
|
/// Fraction of tone matches that were inliers.
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public float InlierFraction {
|
|
get { if ((_hasBits0 & 2) != 0) { return inlierFraction_; } else { return InlierFractionDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 2;
|
|
inlierFraction_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "inlier_fraction" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasInlierFraction {
|
|
get { return (_hasBits0 & 2) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "inlier_fraction" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearInlierFraction() {
|
|
_hasBits0 &= ~2;
|
|
}
|
|
|
|
/// <summary>Field number for the "inlier_weight" field.</summary>
|
|
public const int InlierWeightFieldNumber = 3;
|
|
private readonly static double InlierWeightDefaultValue = 0D;
|
|
|
|
private double inlierWeight_;
|
|
/// <summary>
|
|
/// Total IRLS weight summed over all inliers.
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public double InlierWeight {
|
|
get { if ((_hasBits0 & 4) != 0) { return inlierWeight_; } else { return InlierWeightDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 4;
|
|
inlierWeight_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "inlier_weight" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasInlierWeight {
|
|
get { return (_hasBits0 & 4) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "inlier_weight" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearInlierWeight() {
|
|
_hasBits0 &= ~4;
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public override bool Equals(object other) {
|
|
return Equals(other as StabilityStats);
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool Equals(StabilityStats other) {
|
|
if (ReferenceEquals(other, null)) {
|
|
return false;
|
|
}
|
|
if (ReferenceEquals(other, this)) {
|
|
return true;
|
|
}
|
|
if (NumInliers != other.NumInliers) return false;
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(InlierFraction, other.InlierFraction)) return false;
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(InlierWeight, other.InlierWeight)) 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 (HasNumInliers) hash ^= NumInliers.GetHashCode();
|
|
if (HasInlierFraction) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(InlierFraction);
|
|
if (HasInlierWeight) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(InlierWeight);
|
|
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 (HasNumInliers) {
|
|
output.WriteRawTag(8);
|
|
output.WriteInt32(NumInliers);
|
|
}
|
|
if (HasInlierFraction) {
|
|
output.WriteRawTag(21);
|
|
output.WriteFloat(InlierFraction);
|
|
}
|
|
if (HasInlierWeight) {
|
|
output.WriteRawTag(25);
|
|
output.WriteDouble(InlierWeight);
|
|
}
|
|
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 (HasNumInliers) {
|
|
output.WriteRawTag(8);
|
|
output.WriteInt32(NumInliers);
|
|
}
|
|
if (HasInlierFraction) {
|
|
output.WriteRawTag(21);
|
|
output.WriteFloat(InlierFraction);
|
|
}
|
|
if (HasInlierWeight) {
|
|
output.WriteRawTag(25);
|
|
output.WriteDouble(InlierWeight);
|
|
}
|
|
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 (HasNumInliers) {
|
|
size += 1 + pb::CodedOutputStream.ComputeInt32Size(NumInliers);
|
|
}
|
|
if (HasInlierFraction) {
|
|
size += 1 + 4;
|
|
}
|
|
if (HasInlierWeight) {
|
|
size += 1 + 8;
|
|
}
|
|
if (_unknownFields != null) {
|
|
size += _unknownFields.CalculateSize();
|
|
}
|
|
return size;
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void MergeFrom(StabilityStats other) {
|
|
if (other == null) {
|
|
return;
|
|
}
|
|
if (other.HasNumInliers) {
|
|
NumInliers = other.NumInliers;
|
|
}
|
|
if (other.HasInlierFraction) {
|
|
InlierFraction = other.InlierFraction;
|
|
}
|
|
if (other.HasInlierWeight) {
|
|
InlierWeight = other.InlierWeight;
|
|
}
|
|
_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: {
|
|
NumInliers = input.ReadInt32();
|
|
break;
|
|
}
|
|
case 21: {
|
|
InlierFraction = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 25: {
|
|
InlierWeight = input.ReadDouble();
|
|
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: {
|
|
NumInliers = input.ReadInt32();
|
|
break;
|
|
}
|
|
case 21: {
|
|
InlierFraction = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 25: {
|
|
InlierWeight = input.ReadDouble();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
}
|
|
|
|
}
|
|
#endregion
|
|
|
|
}
|
|
|
|
public sealed partial class ToneMatchOptions : pb::IMessage<ToneMatchOptions>
|
|
#if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
|
|
, pb::IBufferMessage
|
|
#endif
|
|
{
|
|
private static readonly pb::MessageParser<ToneMatchOptions> _parser = new pb::MessageParser<ToneMatchOptions>(() => new ToneMatchOptions());
|
|
private pb::UnknownFieldSet _unknownFields;
|
|
private int _hasBits0;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public static pb::MessageParser<ToneMatchOptions> Parser { get { return _parser; } }
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public static pbr::MessageDescriptor Descriptor {
|
|
get { return global::Mediapipe.ToneEstimationReflection.Descriptor.MessageTypes[1]; }
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
pbr::MessageDescriptor pb::IMessage.Descriptor {
|
|
get { return Descriptor; }
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public ToneMatchOptions() {
|
|
OnConstruction();
|
|
}
|
|
|
|
partial void OnConstruction();
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public ToneMatchOptions(ToneMatchOptions other) : this() {
|
|
_hasBits0 = other._hasBits0;
|
|
minMatchPercentile_ = other.minMatchPercentile_;
|
|
maxMatchPercentile_ = other.maxMatchPercentile_;
|
|
matchPercentileSteps_ = other.matchPercentileSteps_;
|
|
patchRadius_ = other.patchRadius_;
|
|
maxFracClipped_ = other.maxFracClipped_;
|
|
logDomain_ = other.logDomain_;
|
|
_unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public ToneMatchOptions Clone() {
|
|
return new ToneMatchOptions(this);
|
|
}
|
|
|
|
/// <summary>Field number for the "min_match_percentile" field.</summary>
|
|
public const int MinMatchPercentileFieldNumber = 1;
|
|
private readonly static float MinMatchPercentileDefaultValue = 0.01F;
|
|
|
|
private float minMatchPercentile_;
|
|
/// <summary>
|
|
/// ToneChange's are fit to ToneMatches extracted from matching patches, using
|
|
/// order statistics of their corresponding intensities. Matches are defined by
|
|
/// having the same percentile of ordered intensities. If any member of the
|
|
/// ToneMatch is below under or above over-exposed the match is discarded
|
|
/// (based on parameters min and max_exposure above).
|
|
/// Matches are extracted from min_match_percentile to max_match_percentile in
|
|
/// #match_percentile_steps equidistant steps.
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public float MinMatchPercentile {
|
|
get { if ((_hasBits0 & 1) != 0) { return minMatchPercentile_; } else { return MinMatchPercentileDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 1;
|
|
minMatchPercentile_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "min_match_percentile" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasMinMatchPercentile {
|
|
get { return (_hasBits0 & 1) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "min_match_percentile" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearMinMatchPercentile() {
|
|
_hasBits0 &= ~1;
|
|
}
|
|
|
|
/// <summary>Field number for the "max_match_percentile" field.</summary>
|
|
public const int MaxMatchPercentileFieldNumber = 2;
|
|
private readonly static float MaxMatchPercentileDefaultValue = 0.99F;
|
|
|
|
private float maxMatchPercentile_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public float MaxMatchPercentile {
|
|
get { if ((_hasBits0 & 2) != 0) { return maxMatchPercentile_; } else { return MaxMatchPercentileDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 2;
|
|
maxMatchPercentile_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "max_match_percentile" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasMaxMatchPercentile {
|
|
get { return (_hasBits0 & 2) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "max_match_percentile" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearMaxMatchPercentile() {
|
|
_hasBits0 &= ~2;
|
|
}
|
|
|
|
/// <summary>Field number for the "match_percentile_steps" field.</summary>
|
|
public const int MatchPercentileStepsFieldNumber = 3;
|
|
private readonly static int MatchPercentileStepsDefaultValue = 10;
|
|
|
|
private int matchPercentileSteps_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public int MatchPercentileSteps {
|
|
get { if ((_hasBits0 & 4) != 0) { return matchPercentileSteps_; } else { return MatchPercentileStepsDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 4;
|
|
matchPercentileSteps_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "match_percentile_steps" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasMatchPercentileSteps {
|
|
get { return (_hasBits0 & 4) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "match_percentile_steps" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearMatchPercentileSteps() {
|
|
_hasBits0 &= ~4;
|
|
}
|
|
|
|
/// <summary>Field number for the "patch_radius" field.</summary>
|
|
public const int PatchRadiusFieldNumber = 4;
|
|
private readonly static int PatchRadiusDefaultValue = 18;
|
|
|
|
private int patchRadius_;
|
|
/// <summary>
|
|
/// Patch radius from which order statistics are collected.
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public int PatchRadius {
|
|
get { if ((_hasBits0 & 8) != 0) { return patchRadius_; } else { return PatchRadiusDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 8;
|
|
patchRadius_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "patch_radius" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasPatchRadius {
|
|
get { return (_hasBits0 & 8) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "patch_radius" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearPatchRadius() {
|
|
_hasBits0 &= ~8;
|
|
}
|
|
|
|
/// <summary>Field number for the "max_frac_clipped" field.</summary>
|
|
public const int MaxFracClippedFieldNumber = 5;
|
|
private readonly static float MaxFracClippedDefaultValue = 0.4F;
|
|
|
|
private float maxFracClipped_;
|
|
/// <summary>
|
|
/// Only matches with not too many pixels over- or underexposed are used.
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public float MaxFracClipped {
|
|
get { if ((_hasBits0 & 16) != 0) { return maxFracClipped_; } else { return MaxFracClippedDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 16;
|
|
maxFracClipped_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "max_frac_clipped" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasMaxFracClipped {
|
|
get { return (_hasBits0 & 16) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "max_frac_clipped" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearMaxFracClipped() {
|
|
_hasBits0 &= ~16;
|
|
}
|
|
|
|
/// <summary>Field number for the "log_domain" field.</summary>
|
|
public const int LogDomainFieldNumber = 8;
|
|
private readonly static bool LogDomainDefaultValue = false;
|
|
|
|
private bool logDomain_;
|
|
/// <summary>
|
|
/// If set matches will be collected in the log domain.
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool LogDomain {
|
|
get { if ((_hasBits0 & 32) != 0) { return logDomain_; } else { return LogDomainDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 32;
|
|
logDomain_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "log_domain" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasLogDomain {
|
|
get { return (_hasBits0 & 32) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "log_domain" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearLogDomain() {
|
|
_hasBits0 &= ~32;
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public override bool Equals(object other) {
|
|
return Equals(other as ToneMatchOptions);
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool Equals(ToneMatchOptions other) {
|
|
if (ReferenceEquals(other, null)) {
|
|
return false;
|
|
}
|
|
if (ReferenceEquals(other, this)) {
|
|
return true;
|
|
}
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(MinMatchPercentile, other.MinMatchPercentile)) return false;
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(MaxMatchPercentile, other.MaxMatchPercentile)) return false;
|
|
if (MatchPercentileSteps != other.MatchPercentileSteps) return false;
|
|
if (PatchRadius != other.PatchRadius) return false;
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(MaxFracClipped, other.MaxFracClipped)) return false;
|
|
if (LogDomain != other.LogDomain) 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 (HasMinMatchPercentile) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(MinMatchPercentile);
|
|
if (HasMaxMatchPercentile) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(MaxMatchPercentile);
|
|
if (HasMatchPercentileSteps) hash ^= MatchPercentileSteps.GetHashCode();
|
|
if (HasPatchRadius) hash ^= PatchRadius.GetHashCode();
|
|
if (HasMaxFracClipped) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(MaxFracClipped);
|
|
if (HasLogDomain) hash ^= LogDomain.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 (HasMinMatchPercentile) {
|
|
output.WriteRawTag(13);
|
|
output.WriteFloat(MinMatchPercentile);
|
|
}
|
|
if (HasMaxMatchPercentile) {
|
|
output.WriteRawTag(21);
|
|
output.WriteFloat(MaxMatchPercentile);
|
|
}
|
|
if (HasMatchPercentileSteps) {
|
|
output.WriteRawTag(24);
|
|
output.WriteInt32(MatchPercentileSteps);
|
|
}
|
|
if (HasPatchRadius) {
|
|
output.WriteRawTag(32);
|
|
output.WriteInt32(PatchRadius);
|
|
}
|
|
if (HasMaxFracClipped) {
|
|
output.WriteRawTag(45);
|
|
output.WriteFloat(MaxFracClipped);
|
|
}
|
|
if (HasLogDomain) {
|
|
output.WriteRawTag(64);
|
|
output.WriteBool(LogDomain);
|
|
}
|
|
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 (HasMinMatchPercentile) {
|
|
output.WriteRawTag(13);
|
|
output.WriteFloat(MinMatchPercentile);
|
|
}
|
|
if (HasMaxMatchPercentile) {
|
|
output.WriteRawTag(21);
|
|
output.WriteFloat(MaxMatchPercentile);
|
|
}
|
|
if (HasMatchPercentileSteps) {
|
|
output.WriteRawTag(24);
|
|
output.WriteInt32(MatchPercentileSteps);
|
|
}
|
|
if (HasPatchRadius) {
|
|
output.WriteRawTag(32);
|
|
output.WriteInt32(PatchRadius);
|
|
}
|
|
if (HasMaxFracClipped) {
|
|
output.WriteRawTag(45);
|
|
output.WriteFloat(MaxFracClipped);
|
|
}
|
|
if (HasLogDomain) {
|
|
output.WriteRawTag(64);
|
|
output.WriteBool(LogDomain);
|
|
}
|
|
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 (HasMinMatchPercentile) {
|
|
size += 1 + 4;
|
|
}
|
|
if (HasMaxMatchPercentile) {
|
|
size += 1 + 4;
|
|
}
|
|
if (HasMatchPercentileSteps) {
|
|
size += 1 + pb::CodedOutputStream.ComputeInt32Size(MatchPercentileSteps);
|
|
}
|
|
if (HasPatchRadius) {
|
|
size += 1 + pb::CodedOutputStream.ComputeInt32Size(PatchRadius);
|
|
}
|
|
if (HasMaxFracClipped) {
|
|
size += 1 + 4;
|
|
}
|
|
if (HasLogDomain) {
|
|
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(ToneMatchOptions other) {
|
|
if (other == null) {
|
|
return;
|
|
}
|
|
if (other.HasMinMatchPercentile) {
|
|
MinMatchPercentile = other.MinMatchPercentile;
|
|
}
|
|
if (other.HasMaxMatchPercentile) {
|
|
MaxMatchPercentile = other.MaxMatchPercentile;
|
|
}
|
|
if (other.HasMatchPercentileSteps) {
|
|
MatchPercentileSteps = other.MatchPercentileSteps;
|
|
}
|
|
if (other.HasPatchRadius) {
|
|
PatchRadius = other.PatchRadius;
|
|
}
|
|
if (other.HasMaxFracClipped) {
|
|
MaxFracClipped = other.MaxFracClipped;
|
|
}
|
|
if (other.HasLogDomain) {
|
|
LogDomain = other.LogDomain;
|
|
}
|
|
_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: {
|
|
MinMatchPercentile = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 21: {
|
|
MaxMatchPercentile = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 24: {
|
|
MatchPercentileSteps = input.ReadInt32();
|
|
break;
|
|
}
|
|
case 32: {
|
|
PatchRadius = input.ReadInt32();
|
|
break;
|
|
}
|
|
case 45: {
|
|
MaxFracClipped = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 64: {
|
|
LogDomain = 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: {
|
|
MinMatchPercentile = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 21: {
|
|
MaxMatchPercentile = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 24: {
|
|
MatchPercentileSteps = input.ReadInt32();
|
|
break;
|
|
}
|
|
case 32: {
|
|
PatchRadius = input.ReadInt32();
|
|
break;
|
|
}
|
|
case 45: {
|
|
MaxFracClipped = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 64: {
|
|
LogDomain = input.ReadBool();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
}
|
|
|
|
public sealed partial class ClipMaskOptions : pb::IMessage<ClipMaskOptions>
|
|
#if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
|
|
, pb::IBufferMessage
|
|
#endif
|
|
{
|
|
private static readonly pb::MessageParser<ClipMaskOptions> _parser = new pb::MessageParser<ClipMaskOptions>(() => new ClipMaskOptions());
|
|
private pb::UnknownFieldSet _unknownFields;
|
|
private int _hasBits0;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public static pb::MessageParser<ClipMaskOptions> Parser { get { return _parser; } }
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public static pbr::MessageDescriptor Descriptor {
|
|
get { return global::Mediapipe.ToneEstimationReflection.Descriptor.MessageTypes[2]; }
|
|
}
|
|
|
|
[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 ClipMaskOptions() {
|
|
OnConstruction();
|
|
}
|
|
|
|
partial void OnConstruction();
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public ClipMaskOptions(ClipMaskOptions other) : this() {
|
|
_hasBits0 = other._hasBits0;
|
|
minExposure_ = other.minExposure_;
|
|
maxExposure_ = other.maxExposure_;
|
|
maxClippedChannels_ = other.maxClippedChannels_;
|
|
clipMaskDiameter_ = other.clipMaskDiameter_;
|
|
_unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public ClipMaskOptions Clone() {
|
|
return new ClipMaskOptions(this);
|
|
}
|
|
|
|
/// <summary>Field number for the "min_exposure" field.</summary>
|
|
public const int MinExposureFieldNumber = 1;
|
|
private readonly static float MinExposureDefaultValue = 0.02F;
|
|
|
|
private float minExposure_;
|
|
/// <summary>
|
|
/// Over/Under exposure setting. Pixels that are clipped due to limited
|
|
/// dynamic range are masked out from analysis. Values specified w.r.t.
|
|
/// [0, 1] range.
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public float MinExposure {
|
|
get { if ((_hasBits0 & 1) != 0) { return minExposure_; } else { return MinExposureDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 1;
|
|
minExposure_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "min_exposure" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasMinExposure {
|
|
get { return (_hasBits0 & 1) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "min_exposure" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearMinExposure() {
|
|
_hasBits0 &= ~1;
|
|
}
|
|
|
|
/// <summary>Field number for the "max_exposure" field.</summary>
|
|
public const int MaxExposureFieldNumber = 2;
|
|
private readonly static float MaxExposureDefaultValue = 0.98F;
|
|
|
|
private float maxExposure_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public float MaxExposure {
|
|
get { if ((_hasBits0 & 2) != 0) { return maxExposure_; } else { return MaxExposureDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 2;
|
|
maxExposure_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "max_exposure" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasMaxExposure {
|
|
get { return (_hasBits0 & 2) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "max_exposure" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearMaxExposure() {
|
|
_hasBits0 &= ~2;
|
|
}
|
|
|
|
/// <summary>Field number for the "max_clipped_channels" field.</summary>
|
|
public const int MaxClippedChannelsFieldNumber = 4;
|
|
private readonly static int MaxClippedChannelsDefaultValue = 1;
|
|
|
|
private int maxClippedChannels_;
|
|
/// <summary>
|
|
/// A pixel can have clipped color values in atmost max_clipped_channels before
|
|
/// it will be labeled as clipped.
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public int MaxClippedChannels {
|
|
get { if ((_hasBits0 & 4) != 0) { return maxClippedChannels_; } else { return MaxClippedChannelsDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 4;
|
|
maxClippedChannels_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "max_clipped_channels" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasMaxClippedChannels {
|
|
get { return (_hasBits0 & 4) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "max_clipped_channels" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearMaxClippedChannels() {
|
|
_hasBits0 &= ~4;
|
|
}
|
|
|
|
/// <summary>Field number for the "clip_mask_diameter" field.</summary>
|
|
public const int ClipMaskDiameterFieldNumber = 5;
|
|
private readonly static int ClipMaskDiameterDefaultValue = 5;
|
|
|
|
private int clipMaskDiameter_;
|
|
/// <summary>
|
|
/// Over-exposure tends to show blooming (neighboring pixels are affected by
|
|
/// over-exposure as well). For robustness mask of clipped pixels is dilated
|
|
/// with structuring element of diameter clip_mask_diam.
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public int ClipMaskDiameter {
|
|
get { if ((_hasBits0 & 8) != 0) { return clipMaskDiameter_; } else { return ClipMaskDiameterDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 8;
|
|
clipMaskDiameter_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "clip_mask_diameter" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasClipMaskDiameter {
|
|
get { return (_hasBits0 & 8) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "clip_mask_diameter" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearClipMaskDiameter() {
|
|
_hasBits0 &= ~8;
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public override bool Equals(object other) {
|
|
return Equals(other as ClipMaskOptions);
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool Equals(ClipMaskOptions other) {
|
|
if (ReferenceEquals(other, null)) {
|
|
return false;
|
|
}
|
|
if (ReferenceEquals(other, this)) {
|
|
return true;
|
|
}
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(MinExposure, other.MinExposure)) return false;
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(MaxExposure, other.MaxExposure)) return false;
|
|
if (MaxClippedChannels != other.MaxClippedChannels) return false;
|
|
if (ClipMaskDiameter != other.ClipMaskDiameter) 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 (HasMinExposure) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(MinExposure);
|
|
if (HasMaxExposure) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(MaxExposure);
|
|
if (HasMaxClippedChannels) hash ^= MaxClippedChannels.GetHashCode();
|
|
if (HasClipMaskDiameter) hash ^= ClipMaskDiameter.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 (HasMinExposure) {
|
|
output.WriteRawTag(13);
|
|
output.WriteFloat(MinExposure);
|
|
}
|
|
if (HasMaxExposure) {
|
|
output.WriteRawTag(21);
|
|
output.WriteFloat(MaxExposure);
|
|
}
|
|
if (HasMaxClippedChannels) {
|
|
output.WriteRawTag(32);
|
|
output.WriteInt32(MaxClippedChannels);
|
|
}
|
|
if (HasClipMaskDiameter) {
|
|
output.WriteRawTag(40);
|
|
output.WriteInt32(ClipMaskDiameter);
|
|
}
|
|
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 (HasMinExposure) {
|
|
output.WriteRawTag(13);
|
|
output.WriteFloat(MinExposure);
|
|
}
|
|
if (HasMaxExposure) {
|
|
output.WriteRawTag(21);
|
|
output.WriteFloat(MaxExposure);
|
|
}
|
|
if (HasMaxClippedChannels) {
|
|
output.WriteRawTag(32);
|
|
output.WriteInt32(MaxClippedChannels);
|
|
}
|
|
if (HasClipMaskDiameter) {
|
|
output.WriteRawTag(40);
|
|
output.WriteInt32(ClipMaskDiameter);
|
|
}
|
|
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 (HasMinExposure) {
|
|
size += 1 + 4;
|
|
}
|
|
if (HasMaxExposure) {
|
|
size += 1 + 4;
|
|
}
|
|
if (HasMaxClippedChannels) {
|
|
size += 1 + pb::CodedOutputStream.ComputeInt32Size(MaxClippedChannels);
|
|
}
|
|
if (HasClipMaskDiameter) {
|
|
size += 1 + pb::CodedOutputStream.ComputeInt32Size(ClipMaskDiameter);
|
|
}
|
|
if (_unknownFields != null) {
|
|
size += _unknownFields.CalculateSize();
|
|
}
|
|
return size;
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void MergeFrom(ClipMaskOptions other) {
|
|
if (other == null) {
|
|
return;
|
|
}
|
|
if (other.HasMinExposure) {
|
|
MinExposure = other.MinExposure;
|
|
}
|
|
if (other.HasMaxExposure) {
|
|
MaxExposure = other.MaxExposure;
|
|
}
|
|
if (other.HasMaxClippedChannels) {
|
|
MaxClippedChannels = other.MaxClippedChannels;
|
|
}
|
|
if (other.HasClipMaskDiameter) {
|
|
ClipMaskDiameter = other.ClipMaskDiameter;
|
|
}
|
|
_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: {
|
|
MinExposure = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 21: {
|
|
MaxExposure = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 32: {
|
|
MaxClippedChannels = input.ReadInt32();
|
|
break;
|
|
}
|
|
case 40: {
|
|
ClipMaskDiameter = 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 13: {
|
|
MinExposure = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 21: {
|
|
MaxExposure = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 32: {
|
|
MaxClippedChannels = input.ReadInt32();
|
|
break;
|
|
}
|
|
case 40: {
|
|
ClipMaskDiameter = input.ReadInt32();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
}
|
|
|
|
/// <summary>
|
|
/// Next tag: 13
|
|
/// </summary>
|
|
public sealed partial class ToneEstimationOptions : pb::IMessage<ToneEstimationOptions>
|
|
#if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
|
|
, pb::IBufferMessage
|
|
#endif
|
|
{
|
|
private static readonly pb::MessageParser<ToneEstimationOptions> _parser = new pb::MessageParser<ToneEstimationOptions>(() => new ToneEstimationOptions());
|
|
private pb::UnknownFieldSet _unknownFields;
|
|
private int _hasBits0;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public static pb::MessageParser<ToneEstimationOptions> Parser { get { return _parser; } }
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public static pbr::MessageDescriptor Descriptor {
|
|
get { return global::Mediapipe.ToneEstimationReflection.Descriptor.MessageTypes[3]; }
|
|
}
|
|
|
|
[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 ToneEstimationOptions() {
|
|
OnConstruction();
|
|
}
|
|
|
|
partial void OnConstruction();
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public ToneEstimationOptions(ToneEstimationOptions other) : this() {
|
|
_hasBits0 = other._hasBits0;
|
|
toneMatchOptions_ = other.toneMatchOptions_ != null ? other.toneMatchOptions_.Clone() : null;
|
|
clipMaskOptions_ = other.clipMaskOptions_ != null ? other.clipMaskOptions_.Clone() : null;
|
|
statsLowPercentile_ = other.statsLowPercentile_;
|
|
statsLowMidPercentile_ = other.statsLowMidPercentile_;
|
|
statsMidPercentile_ = other.statsMidPercentile_;
|
|
statsHighMidPercentile_ = other.statsHighMidPercentile_;
|
|
statsHighPercentile_ = other.statsHighPercentile_;
|
|
irlsIterations_ = other.irlsIterations_;
|
|
stableGainBiasBounds_ = other.stableGainBiasBounds_ != null ? other.stableGainBiasBounds_.Clone() : null;
|
|
downsampleMode_ = other.downsampleMode_;
|
|
downsamplingSize_ = other.downsamplingSize_;
|
|
downsampleFactor_ = other.downsampleFactor_;
|
|
_unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public ToneEstimationOptions Clone() {
|
|
return new ToneEstimationOptions(this);
|
|
}
|
|
|
|
/// <summary>Field number for the "tone_match_options" field.</summary>
|
|
public const int ToneMatchOptionsFieldNumber = 1;
|
|
private global::Mediapipe.ToneMatchOptions toneMatchOptions_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public global::Mediapipe.ToneMatchOptions ToneMatchOptions {
|
|
get { return toneMatchOptions_; }
|
|
set {
|
|
toneMatchOptions_ = value;
|
|
}
|
|
}
|
|
|
|
/// <summary>Field number for the "clip_mask_options" field.</summary>
|
|
public const int ClipMaskOptionsFieldNumber = 2;
|
|
private global::Mediapipe.ClipMaskOptions clipMaskOptions_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public global::Mediapipe.ClipMaskOptions ClipMaskOptions {
|
|
get { return clipMaskOptions_; }
|
|
set {
|
|
clipMaskOptions_ = value;
|
|
}
|
|
}
|
|
|
|
/// <summary>Field number for the "stats_low_percentile" field.</summary>
|
|
public const int StatsLowPercentileFieldNumber = 3;
|
|
private readonly static float StatsLowPercentileDefaultValue = 0.05F;
|
|
|
|
private float statsLowPercentile_;
|
|
/// <summary>
|
|
/// Percentiles for tone statistics.
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public float StatsLowPercentile {
|
|
get { if ((_hasBits0 & 1) != 0) { return statsLowPercentile_; } else { return StatsLowPercentileDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 1;
|
|
statsLowPercentile_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "stats_low_percentile" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasStatsLowPercentile {
|
|
get { return (_hasBits0 & 1) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "stats_low_percentile" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearStatsLowPercentile() {
|
|
_hasBits0 &= ~1;
|
|
}
|
|
|
|
/// <summary>Field number for the "stats_low_mid_percentile" field.</summary>
|
|
public const int StatsLowMidPercentileFieldNumber = 4;
|
|
private readonly static float StatsLowMidPercentileDefaultValue = 0.2F;
|
|
|
|
private float statsLowMidPercentile_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public float StatsLowMidPercentile {
|
|
get { if ((_hasBits0 & 2) != 0) { return statsLowMidPercentile_; } else { return StatsLowMidPercentileDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 2;
|
|
statsLowMidPercentile_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "stats_low_mid_percentile" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasStatsLowMidPercentile {
|
|
get { return (_hasBits0 & 2) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "stats_low_mid_percentile" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearStatsLowMidPercentile() {
|
|
_hasBits0 &= ~2;
|
|
}
|
|
|
|
/// <summary>Field number for the "stats_mid_percentile" field.</summary>
|
|
public const int StatsMidPercentileFieldNumber = 5;
|
|
private readonly static float StatsMidPercentileDefaultValue = 0.5F;
|
|
|
|
private float statsMidPercentile_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public float StatsMidPercentile {
|
|
get { if ((_hasBits0 & 4) != 0) { return statsMidPercentile_; } else { return StatsMidPercentileDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 4;
|
|
statsMidPercentile_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "stats_mid_percentile" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasStatsMidPercentile {
|
|
get { return (_hasBits0 & 4) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "stats_mid_percentile" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearStatsMidPercentile() {
|
|
_hasBits0 &= ~4;
|
|
}
|
|
|
|
/// <summary>Field number for the "stats_high_mid_percentile" field.</summary>
|
|
public const int StatsHighMidPercentileFieldNumber = 6;
|
|
private readonly static float StatsHighMidPercentileDefaultValue = 0.8F;
|
|
|
|
private float statsHighMidPercentile_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public float StatsHighMidPercentile {
|
|
get { if ((_hasBits0 & 8) != 0) { return statsHighMidPercentile_; } else { return StatsHighMidPercentileDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 8;
|
|
statsHighMidPercentile_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "stats_high_mid_percentile" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasStatsHighMidPercentile {
|
|
get { return (_hasBits0 & 8) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "stats_high_mid_percentile" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearStatsHighMidPercentile() {
|
|
_hasBits0 &= ~8;
|
|
}
|
|
|
|
/// <summary>Field number for the "stats_high_percentile" field.</summary>
|
|
public const int StatsHighPercentileFieldNumber = 7;
|
|
private readonly static float StatsHighPercentileDefaultValue = 0.95F;
|
|
|
|
private float statsHighPercentile_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public float StatsHighPercentile {
|
|
get { if ((_hasBits0 & 16) != 0) { return statsHighPercentile_; } else { return StatsHighPercentileDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 16;
|
|
statsHighPercentile_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "stats_high_percentile" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasStatsHighPercentile {
|
|
get { return (_hasBits0 & 16) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "stats_high_percentile" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearStatsHighPercentile() {
|
|
_hasBits0 &= ~16;
|
|
}
|
|
|
|
/// <summary>Field number for the "irls_iterations" field.</summary>
|
|
public const int IrlsIterationsFieldNumber = 8;
|
|
private readonly static int IrlsIterationsDefaultValue = 10;
|
|
|
|
private int irlsIterations_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public int IrlsIterations {
|
|
get { if ((_hasBits0 & 32) != 0) { return irlsIterations_; } else { return IrlsIterationsDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 32;
|
|
irlsIterations_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "irls_iterations" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasIrlsIterations {
|
|
get { return (_hasBits0 & 32) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "irls_iterations" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearIrlsIterations() {
|
|
_hasBits0 &= ~32;
|
|
}
|
|
|
|
/// <summary>Field number for the "stable_gain_bias_bounds" field.</summary>
|
|
public const int StableGainBiasBoundsFieldNumber = 9;
|
|
private global::Mediapipe.ToneEstimationOptions.Types.GainBiasBounds stableGainBiasBounds_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public global::Mediapipe.ToneEstimationOptions.Types.GainBiasBounds StableGainBiasBounds {
|
|
get { return stableGainBiasBounds_; }
|
|
set {
|
|
stableGainBiasBounds_ = value;
|
|
}
|
|
}
|
|
|
|
/// <summary>Field number for the "downsample_mode" field.</summary>
|
|
public const int DownsampleModeFieldNumber = 10;
|
|
private readonly static global::Mediapipe.ToneEstimationOptions.Types.DownsampleMode DownsampleModeDefaultValue = global::Mediapipe.ToneEstimationOptions.Types.DownsampleMode.DownsampleNone;
|
|
|
|
private global::Mediapipe.ToneEstimationOptions.Types.DownsampleMode downsampleMode_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public global::Mediapipe.ToneEstimationOptions.Types.DownsampleMode DownsampleMode {
|
|
get { if ((_hasBits0 & 64) != 0) { return downsampleMode_; } else { return DownsampleModeDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 64;
|
|
downsampleMode_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "downsample_mode" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasDownsampleMode {
|
|
get { return (_hasBits0 & 64) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "downsample_mode" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearDownsampleMode() {
|
|
_hasBits0 &= ~64;
|
|
}
|
|
|
|
/// <summary>Field number for the "downsampling_size" field.</summary>
|
|
public const int DownsamplingSizeFieldNumber = 11;
|
|
private readonly static int DownsamplingSizeDefaultValue = 256;
|
|
|
|
private int downsamplingSize_;
|
|
/// <summary>
|
|
/// Specify the size of either dimension here, the frame will be
|
|
/// downsampled to fit downsampling_size.
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public int DownsamplingSize {
|
|
get { if ((_hasBits0 & 128) != 0) { return downsamplingSize_; } else { return DownsamplingSizeDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 128;
|
|
downsamplingSize_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "downsampling_size" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasDownsamplingSize {
|
|
get { return (_hasBits0 & 128) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "downsampling_size" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearDownsamplingSize() {
|
|
_hasBits0 &= ~128;
|
|
}
|
|
|
|
/// <summary>Field number for the "downsample_factor" field.</summary>
|
|
public const int DownsampleFactorFieldNumber = 12;
|
|
private readonly static float DownsampleFactorDefaultValue = 2F;
|
|
|
|
private float downsampleFactor_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public float DownsampleFactor {
|
|
get { if ((_hasBits0 & 256) != 0) { return downsampleFactor_; } else { return DownsampleFactorDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 256;
|
|
downsampleFactor_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "downsample_factor" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasDownsampleFactor {
|
|
get { return (_hasBits0 & 256) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "downsample_factor" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearDownsampleFactor() {
|
|
_hasBits0 &= ~256;
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public override bool Equals(object other) {
|
|
return Equals(other as ToneEstimationOptions);
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool Equals(ToneEstimationOptions other) {
|
|
if (ReferenceEquals(other, null)) {
|
|
return false;
|
|
}
|
|
if (ReferenceEquals(other, this)) {
|
|
return true;
|
|
}
|
|
if (!object.Equals(ToneMatchOptions, other.ToneMatchOptions)) return false;
|
|
if (!object.Equals(ClipMaskOptions, other.ClipMaskOptions)) return false;
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(StatsLowPercentile, other.StatsLowPercentile)) return false;
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(StatsLowMidPercentile, other.StatsLowMidPercentile)) return false;
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(StatsMidPercentile, other.StatsMidPercentile)) return false;
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(StatsHighMidPercentile, other.StatsHighMidPercentile)) return false;
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(StatsHighPercentile, other.StatsHighPercentile)) return false;
|
|
if (IrlsIterations != other.IrlsIterations) return false;
|
|
if (!object.Equals(StableGainBiasBounds, other.StableGainBiasBounds)) return false;
|
|
if (DownsampleMode != other.DownsampleMode) return false;
|
|
if (DownsamplingSize != other.DownsamplingSize) return false;
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(DownsampleFactor, other.DownsampleFactor)) 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 (toneMatchOptions_ != null) hash ^= ToneMatchOptions.GetHashCode();
|
|
if (clipMaskOptions_ != null) hash ^= ClipMaskOptions.GetHashCode();
|
|
if (HasStatsLowPercentile) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(StatsLowPercentile);
|
|
if (HasStatsLowMidPercentile) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(StatsLowMidPercentile);
|
|
if (HasStatsMidPercentile) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(StatsMidPercentile);
|
|
if (HasStatsHighMidPercentile) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(StatsHighMidPercentile);
|
|
if (HasStatsHighPercentile) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(StatsHighPercentile);
|
|
if (HasIrlsIterations) hash ^= IrlsIterations.GetHashCode();
|
|
if (stableGainBiasBounds_ != null) hash ^= StableGainBiasBounds.GetHashCode();
|
|
if (HasDownsampleMode) hash ^= DownsampleMode.GetHashCode();
|
|
if (HasDownsamplingSize) hash ^= DownsamplingSize.GetHashCode();
|
|
if (HasDownsampleFactor) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(DownsampleFactor);
|
|
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 (toneMatchOptions_ != null) {
|
|
output.WriteRawTag(10);
|
|
output.WriteMessage(ToneMatchOptions);
|
|
}
|
|
if (clipMaskOptions_ != null) {
|
|
output.WriteRawTag(18);
|
|
output.WriteMessage(ClipMaskOptions);
|
|
}
|
|
if (HasStatsLowPercentile) {
|
|
output.WriteRawTag(29);
|
|
output.WriteFloat(StatsLowPercentile);
|
|
}
|
|
if (HasStatsLowMidPercentile) {
|
|
output.WriteRawTag(37);
|
|
output.WriteFloat(StatsLowMidPercentile);
|
|
}
|
|
if (HasStatsMidPercentile) {
|
|
output.WriteRawTag(45);
|
|
output.WriteFloat(StatsMidPercentile);
|
|
}
|
|
if (HasStatsHighMidPercentile) {
|
|
output.WriteRawTag(53);
|
|
output.WriteFloat(StatsHighMidPercentile);
|
|
}
|
|
if (HasStatsHighPercentile) {
|
|
output.WriteRawTag(61);
|
|
output.WriteFloat(StatsHighPercentile);
|
|
}
|
|
if (HasIrlsIterations) {
|
|
output.WriteRawTag(64);
|
|
output.WriteInt32(IrlsIterations);
|
|
}
|
|
if (stableGainBiasBounds_ != null) {
|
|
output.WriteRawTag(74);
|
|
output.WriteMessage(StableGainBiasBounds);
|
|
}
|
|
if (HasDownsampleMode) {
|
|
output.WriteRawTag(80);
|
|
output.WriteEnum((int) DownsampleMode);
|
|
}
|
|
if (HasDownsamplingSize) {
|
|
output.WriteRawTag(88);
|
|
output.WriteInt32(DownsamplingSize);
|
|
}
|
|
if (HasDownsampleFactor) {
|
|
output.WriteRawTag(101);
|
|
output.WriteFloat(DownsampleFactor);
|
|
}
|
|
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 (toneMatchOptions_ != null) {
|
|
output.WriteRawTag(10);
|
|
output.WriteMessage(ToneMatchOptions);
|
|
}
|
|
if (clipMaskOptions_ != null) {
|
|
output.WriteRawTag(18);
|
|
output.WriteMessage(ClipMaskOptions);
|
|
}
|
|
if (HasStatsLowPercentile) {
|
|
output.WriteRawTag(29);
|
|
output.WriteFloat(StatsLowPercentile);
|
|
}
|
|
if (HasStatsLowMidPercentile) {
|
|
output.WriteRawTag(37);
|
|
output.WriteFloat(StatsLowMidPercentile);
|
|
}
|
|
if (HasStatsMidPercentile) {
|
|
output.WriteRawTag(45);
|
|
output.WriteFloat(StatsMidPercentile);
|
|
}
|
|
if (HasStatsHighMidPercentile) {
|
|
output.WriteRawTag(53);
|
|
output.WriteFloat(StatsHighMidPercentile);
|
|
}
|
|
if (HasStatsHighPercentile) {
|
|
output.WriteRawTag(61);
|
|
output.WriteFloat(StatsHighPercentile);
|
|
}
|
|
if (HasIrlsIterations) {
|
|
output.WriteRawTag(64);
|
|
output.WriteInt32(IrlsIterations);
|
|
}
|
|
if (stableGainBiasBounds_ != null) {
|
|
output.WriteRawTag(74);
|
|
output.WriteMessage(StableGainBiasBounds);
|
|
}
|
|
if (HasDownsampleMode) {
|
|
output.WriteRawTag(80);
|
|
output.WriteEnum((int) DownsampleMode);
|
|
}
|
|
if (HasDownsamplingSize) {
|
|
output.WriteRawTag(88);
|
|
output.WriteInt32(DownsamplingSize);
|
|
}
|
|
if (HasDownsampleFactor) {
|
|
output.WriteRawTag(101);
|
|
output.WriteFloat(DownsampleFactor);
|
|
}
|
|
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 (toneMatchOptions_ != null) {
|
|
size += 1 + pb::CodedOutputStream.ComputeMessageSize(ToneMatchOptions);
|
|
}
|
|
if (clipMaskOptions_ != null) {
|
|
size += 1 + pb::CodedOutputStream.ComputeMessageSize(ClipMaskOptions);
|
|
}
|
|
if (HasStatsLowPercentile) {
|
|
size += 1 + 4;
|
|
}
|
|
if (HasStatsLowMidPercentile) {
|
|
size += 1 + 4;
|
|
}
|
|
if (HasStatsMidPercentile) {
|
|
size += 1 + 4;
|
|
}
|
|
if (HasStatsHighMidPercentile) {
|
|
size += 1 + 4;
|
|
}
|
|
if (HasStatsHighPercentile) {
|
|
size += 1 + 4;
|
|
}
|
|
if (HasIrlsIterations) {
|
|
size += 1 + pb::CodedOutputStream.ComputeInt32Size(IrlsIterations);
|
|
}
|
|
if (stableGainBiasBounds_ != null) {
|
|
size += 1 + pb::CodedOutputStream.ComputeMessageSize(StableGainBiasBounds);
|
|
}
|
|
if (HasDownsampleMode) {
|
|
size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) DownsampleMode);
|
|
}
|
|
if (HasDownsamplingSize) {
|
|
size += 1 + pb::CodedOutputStream.ComputeInt32Size(DownsamplingSize);
|
|
}
|
|
if (HasDownsampleFactor) {
|
|
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(ToneEstimationOptions other) {
|
|
if (other == null) {
|
|
return;
|
|
}
|
|
if (other.toneMatchOptions_ != null) {
|
|
if (toneMatchOptions_ == null) {
|
|
ToneMatchOptions = new global::Mediapipe.ToneMatchOptions();
|
|
}
|
|
ToneMatchOptions.MergeFrom(other.ToneMatchOptions);
|
|
}
|
|
if (other.clipMaskOptions_ != null) {
|
|
if (clipMaskOptions_ == null) {
|
|
ClipMaskOptions = new global::Mediapipe.ClipMaskOptions();
|
|
}
|
|
ClipMaskOptions.MergeFrom(other.ClipMaskOptions);
|
|
}
|
|
if (other.HasStatsLowPercentile) {
|
|
StatsLowPercentile = other.StatsLowPercentile;
|
|
}
|
|
if (other.HasStatsLowMidPercentile) {
|
|
StatsLowMidPercentile = other.StatsLowMidPercentile;
|
|
}
|
|
if (other.HasStatsMidPercentile) {
|
|
StatsMidPercentile = other.StatsMidPercentile;
|
|
}
|
|
if (other.HasStatsHighMidPercentile) {
|
|
StatsHighMidPercentile = other.StatsHighMidPercentile;
|
|
}
|
|
if (other.HasStatsHighPercentile) {
|
|
StatsHighPercentile = other.StatsHighPercentile;
|
|
}
|
|
if (other.HasIrlsIterations) {
|
|
IrlsIterations = other.IrlsIterations;
|
|
}
|
|
if (other.stableGainBiasBounds_ != null) {
|
|
if (stableGainBiasBounds_ == null) {
|
|
StableGainBiasBounds = new global::Mediapipe.ToneEstimationOptions.Types.GainBiasBounds();
|
|
}
|
|
StableGainBiasBounds.MergeFrom(other.StableGainBiasBounds);
|
|
}
|
|
if (other.HasDownsampleMode) {
|
|
DownsampleMode = other.DownsampleMode;
|
|
}
|
|
if (other.HasDownsamplingSize) {
|
|
DownsamplingSize = other.DownsamplingSize;
|
|
}
|
|
if (other.HasDownsampleFactor) {
|
|
DownsampleFactor = other.DownsampleFactor;
|
|
}
|
|
_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 (toneMatchOptions_ == null) {
|
|
ToneMatchOptions = new global::Mediapipe.ToneMatchOptions();
|
|
}
|
|
input.ReadMessage(ToneMatchOptions);
|
|
break;
|
|
}
|
|
case 18: {
|
|
if (clipMaskOptions_ == null) {
|
|
ClipMaskOptions = new global::Mediapipe.ClipMaskOptions();
|
|
}
|
|
input.ReadMessage(ClipMaskOptions);
|
|
break;
|
|
}
|
|
case 29: {
|
|
StatsLowPercentile = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 37: {
|
|
StatsLowMidPercentile = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 45: {
|
|
StatsMidPercentile = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 53: {
|
|
StatsHighMidPercentile = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 61: {
|
|
StatsHighPercentile = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 64: {
|
|
IrlsIterations = input.ReadInt32();
|
|
break;
|
|
}
|
|
case 74: {
|
|
if (stableGainBiasBounds_ == null) {
|
|
StableGainBiasBounds = new global::Mediapipe.ToneEstimationOptions.Types.GainBiasBounds();
|
|
}
|
|
input.ReadMessage(StableGainBiasBounds);
|
|
break;
|
|
}
|
|
case 80: {
|
|
DownsampleMode = (global::Mediapipe.ToneEstimationOptions.Types.DownsampleMode) input.ReadEnum();
|
|
break;
|
|
}
|
|
case 88: {
|
|
DownsamplingSize = input.ReadInt32();
|
|
break;
|
|
}
|
|
case 101: {
|
|
DownsampleFactor = 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 10: {
|
|
if (toneMatchOptions_ == null) {
|
|
ToneMatchOptions = new global::Mediapipe.ToneMatchOptions();
|
|
}
|
|
input.ReadMessage(ToneMatchOptions);
|
|
break;
|
|
}
|
|
case 18: {
|
|
if (clipMaskOptions_ == null) {
|
|
ClipMaskOptions = new global::Mediapipe.ClipMaskOptions();
|
|
}
|
|
input.ReadMessage(ClipMaskOptions);
|
|
break;
|
|
}
|
|
case 29: {
|
|
StatsLowPercentile = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 37: {
|
|
StatsLowMidPercentile = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 45: {
|
|
StatsMidPercentile = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 53: {
|
|
StatsHighMidPercentile = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 61: {
|
|
StatsHighPercentile = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 64: {
|
|
IrlsIterations = input.ReadInt32();
|
|
break;
|
|
}
|
|
case 74: {
|
|
if (stableGainBiasBounds_ == null) {
|
|
StableGainBiasBounds = new global::Mediapipe.ToneEstimationOptions.Types.GainBiasBounds();
|
|
}
|
|
input.ReadMessage(StableGainBiasBounds);
|
|
break;
|
|
}
|
|
case 80: {
|
|
DownsampleMode = (global::Mediapipe.ToneEstimationOptions.Types.DownsampleMode) input.ReadEnum();
|
|
break;
|
|
}
|
|
case 88: {
|
|
DownsamplingSize = input.ReadInt32();
|
|
break;
|
|
}
|
|
case 101: {
|
|
DownsampleFactor = input.ReadFloat();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
#region Nested types
|
|
/// <summary>Container for nested types declared in the ToneEstimationOptions message type.</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public static partial class Types {
|
|
/// <summary>
|
|
/// We support down-sampling of an incoming frame before running the
|
|
/// resolution dependent part of the tone estimation.
|
|
/// tracking if desired).
|
|
/// </summary>
|
|
public enum DownsampleMode {
|
|
/// <summary>
|
|
/// no downsampling.
|
|
/// </summary>
|
|
[pbr::OriginalName("DOWNSAMPLE_NONE")] DownsampleNone = 1,
|
|
/// <summary>
|
|
/// downsizes frame such that frame_size ==
|
|
/// </summary>
|
|
[pbr::OriginalName("DOWNSAMPLE_TO_MAX_SIZE")] DownsampleToMaxSize = 2,
|
|
/// <summary>
|
|
/// downsampling_size.
|
|
/// frame_size := max(width, height).
|
|
/// </summary>
|
|
[pbr::OriginalName("DOWNSAMPLE_BY_FACTOR")] DownsampleByFactor = 3,
|
|
/// <summary>
|
|
/// downsizes frame such that frame_size ==
|
|
/// </summary>
|
|
[pbr::OriginalName("DOWNSAMPLE_TO_MIN_SIZE")] DownsampleToMinSize = 4,
|
|
}
|
|
|
|
public sealed partial class GainBiasBounds : pb::IMessage<GainBiasBounds>
|
|
#if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
|
|
, pb::IBufferMessage
|
|
#endif
|
|
{
|
|
private static readonly pb::MessageParser<GainBiasBounds> _parser = new pb::MessageParser<GainBiasBounds>(() => new GainBiasBounds());
|
|
private pb::UnknownFieldSet _unknownFields;
|
|
private int _hasBits0;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public static pb::MessageParser<GainBiasBounds> Parser { get { return _parser; } }
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public static pbr::MessageDescriptor Descriptor {
|
|
get { return global::Mediapipe.ToneEstimationOptions.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 GainBiasBounds() {
|
|
OnConstruction();
|
|
}
|
|
|
|
partial void OnConstruction();
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public GainBiasBounds(GainBiasBounds other) : this() {
|
|
_hasBits0 = other._hasBits0;
|
|
minInlierFraction_ = other.minInlierFraction_;
|
|
minInlierWeight_ = other.minInlierWeight_;
|
|
lowerGain_ = other.lowerGain_;
|
|
upperGain_ = other.upperGain_;
|
|
lowerBias_ = other.lowerBias_;
|
|
upperBias_ = other.upperBias_;
|
|
_unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public GainBiasBounds Clone() {
|
|
return new GainBiasBounds(this);
|
|
}
|
|
|
|
/// <summary>Field number for the "min_inlier_fraction" field.</summary>
|
|
public const int MinInlierFractionFieldNumber = 1;
|
|
private readonly static float MinInlierFractionDefaultValue = 0.75F;
|
|
|
|
private float minInlierFraction_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public float MinInlierFraction {
|
|
get { if ((_hasBits0 & 1) != 0) { return minInlierFraction_; } else { return MinInlierFractionDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 1;
|
|
minInlierFraction_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "min_inlier_fraction" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasMinInlierFraction {
|
|
get { return (_hasBits0 & 1) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "min_inlier_fraction" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearMinInlierFraction() {
|
|
_hasBits0 &= ~1;
|
|
}
|
|
|
|
/// <summary>Field number for the "min_inlier_weight" field.</summary>
|
|
public const int MinInlierWeightFieldNumber = 2;
|
|
private readonly static float MinInlierWeightDefaultValue = 0.5F;
|
|
|
|
private float minInlierWeight_;
|
|
/// <summary>
|
|
/// Accept 2% intensity difference as valid inlier.
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public float MinInlierWeight {
|
|
get { if ((_hasBits0 & 2) != 0) { return minInlierWeight_; } else { return MinInlierWeightDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 2;
|
|
minInlierWeight_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "min_inlier_weight" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasMinInlierWeight {
|
|
get { return (_hasBits0 & 2) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "min_inlier_weight" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearMinInlierWeight() {
|
|
_hasBits0 &= ~2;
|
|
}
|
|
|
|
/// <summary>Field number for the "lower_gain" field.</summary>
|
|
public const int LowerGainFieldNumber = 3;
|
|
private readonly static float LowerGainDefaultValue = 0.75F;
|
|
|
|
private float lowerGain_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public float LowerGain {
|
|
get { if ((_hasBits0 & 4) != 0) { return lowerGain_; } else { return LowerGainDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 4;
|
|
lowerGain_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "lower_gain" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasLowerGain {
|
|
get { return (_hasBits0 & 4) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "lower_gain" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearLowerGain() {
|
|
_hasBits0 &= ~4;
|
|
}
|
|
|
|
/// <summary>Field number for the "upper_gain" field.</summary>
|
|
public const int UpperGainFieldNumber = 4;
|
|
private readonly static float UpperGainDefaultValue = 1.334F;
|
|
|
|
private float upperGain_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public float UpperGain {
|
|
get { if ((_hasBits0 & 8) != 0) { return upperGain_; } else { return UpperGainDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 8;
|
|
upperGain_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "upper_gain" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasUpperGain {
|
|
get { return (_hasBits0 & 8) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "upper_gain" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearUpperGain() {
|
|
_hasBits0 &= ~8;
|
|
}
|
|
|
|
/// <summary>Field number for the "lower_bias" field.</summary>
|
|
public const int LowerBiasFieldNumber = 5;
|
|
private readonly static float LowerBiasDefaultValue = -0.2F;
|
|
|
|
private float lowerBias_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public float LowerBias {
|
|
get { if ((_hasBits0 & 16) != 0) { return lowerBias_; } else { return LowerBiasDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 16;
|
|
lowerBias_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "lower_bias" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasLowerBias {
|
|
get { return (_hasBits0 & 16) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "lower_bias" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearLowerBias() {
|
|
_hasBits0 &= ~16;
|
|
}
|
|
|
|
/// <summary>Field number for the "upper_bias" field.</summary>
|
|
public const int UpperBiasFieldNumber = 6;
|
|
private readonly static float UpperBiasDefaultValue = 0.2F;
|
|
|
|
private float upperBias_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public float UpperBias {
|
|
get { if ((_hasBits0 & 32) != 0) { return upperBias_; } else { return UpperBiasDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 32;
|
|
upperBias_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "upper_bias" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasUpperBias {
|
|
get { return (_hasBits0 & 32) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "upper_bias" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearUpperBias() {
|
|
_hasBits0 &= ~32;
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public override bool Equals(object other) {
|
|
return Equals(other as GainBiasBounds);
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool Equals(GainBiasBounds other) {
|
|
if (ReferenceEquals(other, null)) {
|
|
return false;
|
|
}
|
|
if (ReferenceEquals(other, this)) {
|
|
return true;
|
|
}
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(MinInlierFraction, other.MinInlierFraction)) return false;
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(MinInlierWeight, other.MinInlierWeight)) return false;
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(LowerGain, other.LowerGain)) return false;
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(UpperGain, other.UpperGain)) return false;
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(LowerBias, other.LowerBias)) return false;
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(UpperBias, other.UpperBias)) 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 (HasMinInlierFraction) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(MinInlierFraction);
|
|
if (HasMinInlierWeight) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(MinInlierWeight);
|
|
if (HasLowerGain) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(LowerGain);
|
|
if (HasUpperGain) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(UpperGain);
|
|
if (HasLowerBias) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(LowerBias);
|
|
if (HasUpperBias) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(UpperBias);
|
|
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 (HasMinInlierFraction) {
|
|
output.WriteRawTag(13);
|
|
output.WriteFloat(MinInlierFraction);
|
|
}
|
|
if (HasMinInlierWeight) {
|
|
output.WriteRawTag(21);
|
|
output.WriteFloat(MinInlierWeight);
|
|
}
|
|
if (HasLowerGain) {
|
|
output.WriteRawTag(29);
|
|
output.WriteFloat(LowerGain);
|
|
}
|
|
if (HasUpperGain) {
|
|
output.WriteRawTag(37);
|
|
output.WriteFloat(UpperGain);
|
|
}
|
|
if (HasLowerBias) {
|
|
output.WriteRawTag(45);
|
|
output.WriteFloat(LowerBias);
|
|
}
|
|
if (HasUpperBias) {
|
|
output.WriteRawTag(53);
|
|
output.WriteFloat(UpperBias);
|
|
}
|
|
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 (HasMinInlierFraction) {
|
|
output.WriteRawTag(13);
|
|
output.WriteFloat(MinInlierFraction);
|
|
}
|
|
if (HasMinInlierWeight) {
|
|
output.WriteRawTag(21);
|
|
output.WriteFloat(MinInlierWeight);
|
|
}
|
|
if (HasLowerGain) {
|
|
output.WriteRawTag(29);
|
|
output.WriteFloat(LowerGain);
|
|
}
|
|
if (HasUpperGain) {
|
|
output.WriteRawTag(37);
|
|
output.WriteFloat(UpperGain);
|
|
}
|
|
if (HasLowerBias) {
|
|
output.WriteRawTag(45);
|
|
output.WriteFloat(LowerBias);
|
|
}
|
|
if (HasUpperBias) {
|
|
output.WriteRawTag(53);
|
|
output.WriteFloat(UpperBias);
|
|
}
|
|
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 (HasMinInlierFraction) {
|
|
size += 1 + 4;
|
|
}
|
|
if (HasMinInlierWeight) {
|
|
size += 1 + 4;
|
|
}
|
|
if (HasLowerGain) {
|
|
size += 1 + 4;
|
|
}
|
|
if (HasUpperGain) {
|
|
size += 1 + 4;
|
|
}
|
|
if (HasLowerBias) {
|
|
size += 1 + 4;
|
|
}
|
|
if (HasUpperBias) {
|
|
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(GainBiasBounds other) {
|
|
if (other == null) {
|
|
return;
|
|
}
|
|
if (other.HasMinInlierFraction) {
|
|
MinInlierFraction = other.MinInlierFraction;
|
|
}
|
|
if (other.HasMinInlierWeight) {
|
|
MinInlierWeight = other.MinInlierWeight;
|
|
}
|
|
if (other.HasLowerGain) {
|
|
LowerGain = other.LowerGain;
|
|
}
|
|
if (other.HasUpperGain) {
|
|
UpperGain = other.UpperGain;
|
|
}
|
|
if (other.HasLowerBias) {
|
|
LowerBias = other.LowerBias;
|
|
}
|
|
if (other.HasUpperBias) {
|
|
UpperBias = other.UpperBias;
|
|
}
|
|
_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: {
|
|
MinInlierFraction = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 21: {
|
|
MinInlierWeight = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 29: {
|
|
LowerGain = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 37: {
|
|
UpperGain = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 45: {
|
|
LowerBias = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 53: {
|
|
UpperBias = 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: {
|
|
MinInlierFraction = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 21: {
|
|
MinInlierWeight = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 29: {
|
|
LowerGain = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 37: {
|
|
UpperGain = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 45: {
|
|
LowerBias = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 53: {
|
|
UpperBias = input.ReadFloat();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
}
|
|
|
|
}
|
|
#endregion
|
|
|
|
}
|
|
|
|
public sealed partial class ToneMatch : pb::IMessage<ToneMatch>
|
|
#if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
|
|
, pb::IBufferMessage
|
|
#endif
|
|
{
|
|
private static readonly pb::MessageParser<ToneMatch> _parser = new pb::MessageParser<ToneMatch>(() => new ToneMatch());
|
|
private pb::UnknownFieldSet _unknownFields;
|
|
private int _hasBits0;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public static pb::MessageParser<ToneMatch> Parser { get { return _parser; } }
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public static pbr::MessageDescriptor Descriptor {
|
|
get { return global::Mediapipe.ToneEstimationReflection.Descriptor.MessageTypes[4]; }
|
|
}
|
|
|
|
[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 ToneMatch() {
|
|
OnConstruction();
|
|
}
|
|
|
|
partial void OnConstruction();
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public ToneMatch(ToneMatch other) : this() {
|
|
_hasBits0 = other._hasBits0;
|
|
currVal_ = other.currVal_;
|
|
prevVal_ = other.prevVal_;
|
|
_unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public ToneMatch Clone() {
|
|
return new ToneMatch(this);
|
|
}
|
|
|
|
/// <summary>Field number for the "curr_val" field.</summary>
|
|
public const int CurrValFieldNumber = 1;
|
|
private readonly static float CurrValDefaultValue = 0F;
|
|
|
|
private float currVal_;
|
|
/// <summary>
|
|
/// Intensity in current frame.
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public float CurrVal {
|
|
get { if ((_hasBits0 & 1) != 0) { return currVal_; } else { return CurrValDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 1;
|
|
currVal_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "curr_val" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasCurrVal {
|
|
get { return (_hasBits0 & 1) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "curr_val" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearCurrVal() {
|
|
_hasBits0 &= ~1;
|
|
}
|
|
|
|
/// <summary>Field number for the "prev_val" field.</summary>
|
|
public const int PrevValFieldNumber = 2;
|
|
private readonly static float PrevValDefaultValue = 0F;
|
|
|
|
private float prevVal_;
|
|
/// <summary>
|
|
/// Matching intensity in previous frame.
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public float PrevVal {
|
|
get { if ((_hasBits0 & 2) != 0) { return prevVal_; } else { return PrevValDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 2;
|
|
prevVal_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "prev_val" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasPrevVal {
|
|
get { return (_hasBits0 & 2) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "prev_val" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearPrevVal() {
|
|
_hasBits0 &= ~2;
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public override bool Equals(object other) {
|
|
return Equals(other as ToneMatch);
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool Equals(ToneMatch other) {
|
|
if (ReferenceEquals(other, null)) {
|
|
return false;
|
|
}
|
|
if (ReferenceEquals(other, this)) {
|
|
return true;
|
|
}
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(CurrVal, other.CurrVal)) return false;
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(PrevVal, other.PrevVal)) 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 (HasCurrVal) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(CurrVal);
|
|
if (HasPrevVal) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(PrevVal);
|
|
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 (HasCurrVal) {
|
|
output.WriteRawTag(13);
|
|
output.WriteFloat(CurrVal);
|
|
}
|
|
if (HasPrevVal) {
|
|
output.WriteRawTag(21);
|
|
output.WriteFloat(PrevVal);
|
|
}
|
|
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 (HasCurrVal) {
|
|
output.WriteRawTag(13);
|
|
output.WriteFloat(CurrVal);
|
|
}
|
|
if (HasPrevVal) {
|
|
output.WriteRawTag(21);
|
|
output.WriteFloat(PrevVal);
|
|
}
|
|
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 (HasCurrVal) {
|
|
size += 1 + 4;
|
|
}
|
|
if (HasPrevVal) {
|
|
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(ToneMatch other) {
|
|
if (other == null) {
|
|
return;
|
|
}
|
|
if (other.HasCurrVal) {
|
|
CurrVal = other.CurrVal;
|
|
}
|
|
if (other.HasPrevVal) {
|
|
PrevVal = other.PrevVal;
|
|
}
|
|
_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: {
|
|
CurrVal = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 21: {
|
|
PrevVal = 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: {
|
|
CurrVal = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 21: {
|
|
PrevVal = input.ReadFloat();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
}
|
|
|
|
public sealed partial class PatchToneMatch : pb::IMessage<PatchToneMatch>
|
|
#if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
|
|
, pb::IBufferMessage
|
|
#endif
|
|
{
|
|
private static readonly pb::MessageParser<PatchToneMatch> _parser = new pb::MessageParser<PatchToneMatch>(() => new PatchToneMatch());
|
|
private pb::UnknownFieldSet _unknownFields;
|
|
private int _hasBits0;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public static pb::MessageParser<PatchToneMatch> Parser { get { return _parser; } }
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public static pbr::MessageDescriptor Descriptor {
|
|
get { return global::Mediapipe.ToneEstimationReflection.Descriptor.MessageTypes[5]; }
|
|
}
|
|
|
|
[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 PatchToneMatch() {
|
|
OnConstruction();
|
|
}
|
|
|
|
partial void OnConstruction();
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public PatchToneMatch(PatchToneMatch other) : this() {
|
|
_hasBits0 = other._hasBits0;
|
|
toneMatch_ = other.toneMatch_.Clone();
|
|
irlsWeight_ = other.irlsWeight_;
|
|
_unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public PatchToneMatch Clone() {
|
|
return new PatchToneMatch(this);
|
|
}
|
|
|
|
/// <summary>Field number for the "tone_match" field.</summary>
|
|
public const int ToneMatchFieldNumber = 1;
|
|
private static readonly pb::FieldCodec<global::Mediapipe.ToneMatch> _repeated_toneMatch_codec
|
|
= pb::FieldCodec.ForMessage(10, global::Mediapipe.ToneMatch.Parser);
|
|
private readonly pbc::RepeatedField<global::Mediapipe.ToneMatch> toneMatch_ = new pbc::RepeatedField<global::Mediapipe.ToneMatch>();
|
|
/// <summary>
|
|
/// Several intensity matches computed from equal percentiles of matching patch
|
|
/// pairs. No number or particular ordering is assumed.
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public pbc::RepeatedField<global::Mediapipe.ToneMatch> ToneMatch {
|
|
get { return toneMatch_; }
|
|
}
|
|
|
|
/// <summary>Field number for the "irls_weight" field.</summary>
|
|
public const int IrlsWeightFieldNumber = 2;
|
|
private readonly static float IrlsWeightDefaultValue = 1F;
|
|
|
|
private float irlsWeight_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public float IrlsWeight {
|
|
get { if ((_hasBits0 & 1) != 0) { return irlsWeight_; } else { return IrlsWeightDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 1;
|
|
irlsWeight_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "irls_weight" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasIrlsWeight {
|
|
get { return (_hasBits0 & 1) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "irls_weight" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearIrlsWeight() {
|
|
_hasBits0 &= ~1;
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public override bool Equals(object other) {
|
|
return Equals(other as PatchToneMatch);
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool Equals(PatchToneMatch other) {
|
|
if (ReferenceEquals(other, null)) {
|
|
return false;
|
|
}
|
|
if (ReferenceEquals(other, this)) {
|
|
return true;
|
|
}
|
|
if(!toneMatch_.Equals(other.toneMatch_)) return false;
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(IrlsWeight, other.IrlsWeight)) 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;
|
|
hash ^= toneMatch_.GetHashCode();
|
|
if (HasIrlsWeight) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(IrlsWeight);
|
|
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
|
|
toneMatch_.WriteTo(output, _repeated_toneMatch_codec);
|
|
if (HasIrlsWeight) {
|
|
output.WriteRawTag(21);
|
|
output.WriteFloat(IrlsWeight);
|
|
}
|
|
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) {
|
|
toneMatch_.WriteTo(ref output, _repeated_toneMatch_codec);
|
|
if (HasIrlsWeight) {
|
|
output.WriteRawTag(21);
|
|
output.WriteFloat(IrlsWeight);
|
|
}
|
|
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;
|
|
size += toneMatch_.CalculateSize(_repeated_toneMatch_codec);
|
|
if (HasIrlsWeight) {
|
|
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(PatchToneMatch other) {
|
|
if (other == null) {
|
|
return;
|
|
}
|
|
toneMatch_.Add(other.toneMatch_);
|
|
if (other.HasIrlsWeight) {
|
|
IrlsWeight = other.IrlsWeight;
|
|
}
|
|
_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: {
|
|
toneMatch_.AddEntriesFrom(input, _repeated_toneMatch_codec);
|
|
break;
|
|
}
|
|
case 21: {
|
|
IrlsWeight = 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 10: {
|
|
toneMatch_.AddEntriesFrom(ref input, _repeated_toneMatch_codec);
|
|
break;
|
|
}
|
|
case 21: {
|
|
IrlsWeight = input.ReadFloat();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
}
|
|
|
|
#endregion
|
|
|
|
}
|
|
|
|
#endregion Designer generated code
|