5154 lines
195 KiB
C#
5154 lines
195 KiB
C#
// <auto-generated>
|
|
// Generated by the protocol buffer compiler. DO NOT EDIT!
|
|
// source: mediapipe/util/tracking/region_flow.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/region_flow.proto</summary>
|
|
public static partial class RegionFlowReflection {
|
|
|
|
#region Descriptor
|
|
/// <summary>File descriptor for mediapipe/util/tracking/region_flow.proto</summary>
|
|
public static pbr::FileDescriptor Descriptor {
|
|
get { return descriptor; }
|
|
}
|
|
private static pbr::FileDescriptor descriptor;
|
|
|
|
static RegionFlowReflection() {
|
|
byte[] descriptorData = global::System.Convert.FromBase64String(
|
|
string.Concat(
|
|
"CiltZWRpYXBpcGUvdXRpbC90cmFja2luZy9yZWdpb25fZmxvdy5wcm90bxIJ",
|
|
"bWVkaWFwaXBlIh8KD1BhdGNoRGVzY3JpcHRvchIMCgRkYXRhGAEgAygCIicK",
|
|
"F0JpbmFyeUZlYXR1cmVEZXNjcmlwdG9yEgwKBGRhdGEYASABKAwiRAoVVGVt",
|
|
"cG9yYWxJUkxTU21vb3RoaW5nEhUKCndlaWdodF9zdW0YASABKAI6ATASFAoJ",
|
|
"dmFsdWVfc3VtGAIgASgCOgEwIpkEChFSZWdpb25GbG93RmVhdHVyZRIMCgF4",
|
|
"GAEgASgCOgEwEgwKAXkYAiABKAI6ATASDQoCZHgYAyABKAI6ATASDQoCZHkY",
|
|
"BCABKAI6ATASFAoIdHJhY2tfaWQYDSABKAU6Ai0xEhkKDnRyYWNraW5nX2Vy",
|
|
"cm9yGAUgASgCOgEwEhYKC2lybHNfd2VpZ2h0GAYgASgCOgExEhoKD2Nvcm5l",
|
|
"cl9yZXNwb25zZRgLIAEoAjoBMBI2ChJmZWF0dXJlX2Rlc2NyaXB0b3IYByAB",
|
|
"KAsyGi5tZWRpYXBpcGUuUGF0Y2hEZXNjcmlwdG9yEjwKGGZlYXR1cmVfbWF0",
|
|
"Y2hfZGVzY3JpcHRvchgIIAEoCzIaLm1lZGlhcGlwZS5QYXRjaERlc2NyaXB0",
|
|
"b3ISNwoNaW50ZXJuYWxfaXJscxgKIAEoCzIgLm1lZGlhcGlwZS5UZW1wb3Jh",
|
|
"bElSTFNTbW9vdGhpbmcSDQoFbGFiZWwYDiABKAkSDQoFZmxhZ3MYDyABKAUS",
|
|
"EgoKZmVhdHVyZV9pZBgQIAEoBRIRCgZvY3RhdmUYESABKAU6ATASRQoZYmlu",
|
|
"YXJ5X2ZlYXR1cmVfZGVzY3JpcHRvchgSIAEoCzIiLm1lZGlhcGlwZS5CaW5h",
|
|
"cnlGZWF0dXJlRGVzY3JpcHRvciIeCgVGbGFncxIVChFGTEFHX0JST0tFTl9U",
|
|
"UkFDSxABKgQICRAKKgQIDBANIr0ECg9SZWdpb25GbG93RnJhbWUSOgoLcmVn",
|
|
"aW9uX2Zsb3cYASADKAsyJS5tZWRpYXBpcGUuUmVnaW9uRmxvd0ZyYW1lLlJl",
|
|
"Z2lvbkZsb3cSHQoSbnVtX3RvdGFsX2ZlYXR1cmVzGAIgASgFOgEwEh0KDnVu",
|
|
"c3RhYmxlX2ZyYW1lGAQgASgIOgVmYWxzZRISCgpibHVyX3Njb3JlGAcgASgC",
|
|
"EhMKC2ZyYW1lX3dpZHRoGAggASgFEhQKDGZyYW1lX2hlaWdodBgJIAEoBRJE",
|
|
"ChBibG9ja19kZXNjcmlwdG9yGAogASgLMioubWVkaWFwaXBlLlJlZ2lvbkZs",
|
|
"b3dGcmFtZS5CbG9ja0Rlc2NyaXB0b3IaqAEKClJlZ2lvbkZsb3cSEQoJcmVn",
|
|
"aW9uX2lkGAEgAigFEhUKCmNlbnRyb2lkX3gYAiABKAI6ATASFQoKY2VudHJv",
|
|
"aWRfeRgDIAEoAjoBMBIRCgZmbG93X3gYBCABKAI6ATASEQoGZmxvd195GAUg",
|
|
"ASgCOgEwEi0KB2ZlYXR1cmUYByADKAsyHC5tZWRpYXBpcGUuUmVnaW9uRmxv",
|
|
"d0ZlYXR1cmUqBAgGEAcabgoPQmxvY2tEZXNjcmlwdG9yEhMKC2Jsb2NrX3dp",
|
|
"ZHRoGAEgASgFEhQKDGJsb2NrX2hlaWdodBgCIAEoBRIXCgxudW1fYmxvY2tz",
|
|
"X3gYAyABKAU6ATASFwoMbnVtX2Jsb2Nrc195GAQgASgFOgEwKgQIAxAEKgQI",
|
|
"BRAGKgQIBhAHIpwDChVSZWdpb25GbG93RmVhdHVyZUxpc3QSLQoHZmVhdHVy",
|
|
"ZRgBIAMoCzIcLm1lZGlhcGlwZS5SZWdpb25GbG93RmVhdHVyZRITCgtmcmFt",
|
|
"ZV93aWR0aBgCIAEoBRIUCgxmcmFtZV9oZWlnaHQYAyABKAUSFwoIdW5zdGFi",
|
|
"bGUYBCABKAg6BWZhbHNlEh8KFGRpc3RhbmNlX2Zyb21fYm9yZGVyGAUgASgF",
|
|
"OgEwEhIKCmJsdXJfc2NvcmUYBiABKAISGgoLbG9uZ190cmFja3MYByABKAg6",
|
|
"BWZhbHNlEiYKG2ZyYWNfbG9uZ19mZWF0dXJlc19yZWplY3RlZBgIIAEoAjoB",
|
|
"MBIeChJ2aXN1YWxfY29uc2lzdGVuY3kYCSABKAI6Ai0xEhkKDnRpbWVzdGFt",
|
|
"cF91c2VjGAogASgDOgEwEhYKC21hdGNoX2ZyYW1lGAsgASgFOgEwEhwKDWlz",
|
|
"X2R1cGxpY2F0ZWQYDCABKAg6BWZhbHNlEiYKHmFjdGl2ZWx5X2Rpc2NhcmRl",
|
|
"ZF90cmFja2VkX2lkcxgNIAMoBSKAAwoMU2FsaWVudFBvaW50EhcKDG5vcm1f",
|
|
"cG9pbnRfeBgBIAEoAjoBMBIXCgxub3JtX3BvaW50X3kYAiABKAI6ATASRAoE",
|
|
"dHlwZRgLIAEoDjIoLm1lZGlhcGlwZS5TYWxpZW50UG9pbnQuU2FsaWVudFBv",
|
|
"aW50VHlwZToMVFlQRV9JTkNMVURFEhEKBGxlZnQYAyABKAI6AzAuMxITCgZi",
|
|
"b3R0b20YBCABKAI6AzAuMxISCgVyaWdodBgJIAEoAjoDMC4zEhAKA3RvcBgK",
|
|
"IAEoAjoDMC4zEhIKBndlaWdodBgFIAEoAjoCMTUSEgoKbm9ybV9tYWpvchgG",
|
|
"IAEoAhISCgpub3JtX21pbm9yGAcgASgCEg0KBWFuZ2xlGAggASgCIlMKEFNh",
|
|
"bGllbnRQb2ludFR5cGUSEAoMVFlQRV9JTkNMVURFEAESFQoRVFlQRV9FWENM",
|
|
"VURFX0xFRlQQAhIWChJUWVBFX0VYQ0xVREVfUklHSFQQAyoKCKCcARCAgICA",
|
|
"AiJHChFTYWxpZW50UG9pbnRGcmFtZRImCgVwb2ludBgBIAMoCzIXLm1lZGlh",
|
|
"cGlwZS5TYWxpZW50UG9pbnQqCgignAEQgICAgAJCIQodY29tLmdvb2dsZS5t",
|
|
"ZWRpYXBpcGUudHJhY2tpbmdQAQ=="));
|
|
descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData,
|
|
new pbr::FileDescriptor[] { },
|
|
new pbr::GeneratedClrTypeInfo(null, null, new pbr::GeneratedClrTypeInfo[] {
|
|
new pbr::GeneratedClrTypeInfo(typeof(global::Mediapipe.PatchDescriptor), global::Mediapipe.PatchDescriptor.Parser, new[]{ "Data" }, null, null, null, null),
|
|
new pbr::GeneratedClrTypeInfo(typeof(global::Mediapipe.BinaryFeatureDescriptor), global::Mediapipe.BinaryFeatureDescriptor.Parser, new[]{ "Data" }, null, null, null, null),
|
|
new pbr::GeneratedClrTypeInfo(typeof(global::Mediapipe.TemporalIRLSSmoothing), global::Mediapipe.TemporalIRLSSmoothing.Parser, new[]{ "WeightSum", "ValueSum" }, null, null, null, null),
|
|
new pbr::GeneratedClrTypeInfo(typeof(global::Mediapipe.RegionFlowFeature), global::Mediapipe.RegionFlowFeature.Parser, new[]{ "X", "Y", "Dx", "Dy", "TrackId", "TrackingError", "IrlsWeight", "CornerResponse", "FeatureDescriptor", "FeatureMatchDescriptor", "InternalIrls", "Label", "Flags", "FeatureId", "Octave", "BinaryFeatureDescriptor" }, null, new[]{ typeof(global::Mediapipe.RegionFlowFeature.Types.Flags) }, null, null),
|
|
new pbr::GeneratedClrTypeInfo(typeof(global::Mediapipe.RegionFlowFrame), global::Mediapipe.RegionFlowFrame.Parser, new[]{ "RegionFlow", "NumTotalFeatures", "UnstableFrame", "BlurScore", "FrameWidth", "FrameHeight", "BlockDescriptor" }, null, null, null, new pbr::GeneratedClrTypeInfo[] { new pbr::GeneratedClrTypeInfo(typeof(global::Mediapipe.RegionFlowFrame.Types.RegionFlow), global::Mediapipe.RegionFlowFrame.Types.RegionFlow.Parser, new[]{ "RegionId", "CentroidX", "CentroidY", "FlowX", "FlowY", "Feature" }, null, null, null, null),
|
|
new pbr::GeneratedClrTypeInfo(typeof(global::Mediapipe.RegionFlowFrame.Types.BlockDescriptor), global::Mediapipe.RegionFlowFrame.Types.BlockDescriptor.Parser, new[]{ "BlockWidth", "BlockHeight", "NumBlocksX", "NumBlocksY" }, null, null, null, null)}),
|
|
new pbr::GeneratedClrTypeInfo(typeof(global::Mediapipe.RegionFlowFeatureList), global::Mediapipe.RegionFlowFeatureList.Parser, new[]{ "Feature", "FrameWidth", "FrameHeight", "Unstable", "DistanceFromBorder", "BlurScore", "LongTracks", "FracLongFeaturesRejected", "VisualConsistency", "TimestampUsec", "MatchFrame", "IsDuplicated", "ActivelyDiscardedTrackedIds" }, null, null, null, null),
|
|
new pbr::GeneratedClrTypeInfo(typeof(global::Mediapipe.SalientPoint), global::Mediapipe.SalientPoint.Parser, new[]{ "NormPointX", "NormPointY", "Type", "Left", "Bottom", "Right", "Top", "Weight", "NormMajor", "NormMinor", "Angle" }, null, new[]{ typeof(global::Mediapipe.SalientPoint.Types.SalientPointType) }, null, null),
|
|
new pbr::GeneratedClrTypeInfo(typeof(global::Mediapipe.SalientPointFrame), global::Mediapipe.SalientPointFrame.Parser, new[]{ "Point" }, null, null, null, null)
|
|
}));
|
|
}
|
|
#endregion
|
|
|
|
}
|
|
#region Messages
|
|
/// <summary>
|
|
/// Captures additional information about a RegionFlowFeature's
|
|
/// surrounding patch.
|
|
/// Using MotionEstimation::RetrieveRegionFlowFeatureList or
|
|
/// ComputeRegionFlowFeatureDescriptors the patch descriptor has the folling
|
|
/// layout:
|
|
/// (9 dimensional: 3 mean intensities, 3x3 covariance matrix, (only store upper
|
|
/// half (6 elems) in column major order, i.e. indices for data in patch
|
|
/// descriptor refer to:
|
|
/// mean: 0 1 2, covariance: 3 4 5
|
|
/// 6 7
|
|
/// 8
|
|
/// </summary>
|
|
public sealed partial class PatchDescriptor : pb::IMessage<PatchDescriptor>
|
|
#if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
|
|
, pb::IBufferMessage
|
|
#endif
|
|
{
|
|
private static readonly pb::MessageParser<PatchDescriptor> _parser = new pb::MessageParser<PatchDescriptor>(() => new PatchDescriptor());
|
|
private pb::UnknownFieldSet _unknownFields;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public static pb::MessageParser<PatchDescriptor> Parser { get { return _parser; } }
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public static pbr::MessageDescriptor Descriptor {
|
|
get { return global::Mediapipe.RegionFlowReflection.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 PatchDescriptor() {
|
|
OnConstruction();
|
|
}
|
|
|
|
partial void OnConstruction();
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public PatchDescriptor(PatchDescriptor other) : this() {
|
|
data_ = other.data_.Clone();
|
|
_unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public PatchDescriptor Clone() {
|
|
return new PatchDescriptor(this);
|
|
}
|
|
|
|
/// <summary>Field number for the "data" field.</summary>
|
|
public const int DataFieldNumber = 1;
|
|
private static readonly pb::FieldCodec<float> _repeated_data_codec
|
|
= pb::FieldCodec.ForFloat(13);
|
|
private readonly pbc::RepeatedField<float> data_ = new pbc::RepeatedField<float>();
|
|
/// <summary>
|
|
/// The actual feature descriptor.
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public pbc::RepeatedField<float> Data {
|
|
get { return data_; }
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public override bool Equals(object other) {
|
|
return Equals(other as PatchDescriptor);
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool Equals(PatchDescriptor other) {
|
|
if (ReferenceEquals(other, null)) {
|
|
return false;
|
|
}
|
|
if (ReferenceEquals(other, this)) {
|
|
return true;
|
|
}
|
|
if(!data_.Equals(other.data_)) 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 ^= data_.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
|
|
data_.WriteTo(output, _repeated_data_codec);
|
|
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) {
|
|
data_.WriteTo(ref output, _repeated_data_codec);
|
|
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 += data_.CalculateSize(_repeated_data_codec);
|
|
if (_unknownFields != null) {
|
|
size += _unknownFields.CalculateSize();
|
|
}
|
|
return size;
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void MergeFrom(PatchDescriptor other) {
|
|
if (other == null) {
|
|
return;
|
|
}
|
|
data_.Add(other.data_);
|
|
_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:
|
|
case 13: {
|
|
data_.AddEntriesFrom(input, _repeated_data_codec);
|
|
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:
|
|
case 13: {
|
|
data_.AddEntriesFrom(ref input, _repeated_data_codec);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
}
|
|
|
|
/// <summary>
|
|
/// Binary feature descriptor for a particular feature.
|
|
/// For example: orb
|
|
/// http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.370.4395&rep=rep1&type=pdf
|
|
/// </summary>
|
|
public sealed partial class BinaryFeatureDescriptor : pb::IMessage<BinaryFeatureDescriptor>
|
|
#if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
|
|
, pb::IBufferMessage
|
|
#endif
|
|
{
|
|
private static readonly pb::MessageParser<BinaryFeatureDescriptor> _parser = new pb::MessageParser<BinaryFeatureDescriptor>(() => new BinaryFeatureDescriptor());
|
|
private pb::UnknownFieldSet _unknownFields;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public static pb::MessageParser<BinaryFeatureDescriptor> Parser { get { return _parser; } }
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public static pbr::MessageDescriptor Descriptor {
|
|
get { return global::Mediapipe.RegionFlowReflection.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 BinaryFeatureDescriptor() {
|
|
OnConstruction();
|
|
}
|
|
|
|
partial void OnConstruction();
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public BinaryFeatureDescriptor(BinaryFeatureDescriptor other) : this() {
|
|
data_ = other.data_;
|
|
_unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public BinaryFeatureDescriptor Clone() {
|
|
return new BinaryFeatureDescriptor(this);
|
|
}
|
|
|
|
/// <summary>Field number for the "data" field.</summary>
|
|
public const int DataFieldNumber = 1;
|
|
private readonly static pb::ByteString DataDefaultValue = pb::ByteString.Empty;
|
|
|
|
private pb::ByteString data_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public pb::ByteString Data {
|
|
get { return data_ ?? DataDefaultValue; }
|
|
set {
|
|
data_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "data" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasData {
|
|
get { return data_ != null; }
|
|
}
|
|
/// <summary>Clears the value of the "data" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearData() {
|
|
data_ = null;
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public override bool Equals(object other) {
|
|
return Equals(other as BinaryFeatureDescriptor);
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool Equals(BinaryFeatureDescriptor other) {
|
|
if (ReferenceEquals(other, null)) {
|
|
return false;
|
|
}
|
|
if (ReferenceEquals(other, this)) {
|
|
return true;
|
|
}
|
|
if (Data != other.Data) 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 (HasData) hash ^= Data.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 (HasData) {
|
|
output.WriteRawTag(10);
|
|
output.WriteBytes(Data);
|
|
}
|
|
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 (HasData) {
|
|
output.WriteRawTag(10);
|
|
output.WriteBytes(Data);
|
|
}
|
|
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 (HasData) {
|
|
size += 1 + pb::CodedOutputStream.ComputeBytesSize(Data);
|
|
}
|
|
if (_unknownFields != null) {
|
|
size += _unknownFields.CalculateSize();
|
|
}
|
|
return size;
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void MergeFrom(BinaryFeatureDescriptor other) {
|
|
if (other == null) {
|
|
return;
|
|
}
|
|
if (other.HasData) {
|
|
Data = other.Data;
|
|
}
|
|
_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: {
|
|
Data = input.ReadBytes();
|
|
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: {
|
|
Data = input.ReadBytes();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
}
|
|
|
|
/// <summary>
|
|
/// Internal datastructure used during temporal IRLS smoothing.
|
|
/// </summary>
|
|
public sealed partial class TemporalIRLSSmoothing : pb::IMessage<TemporalIRLSSmoothing>
|
|
#if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
|
|
, pb::IBufferMessage
|
|
#endif
|
|
{
|
|
private static readonly pb::MessageParser<TemporalIRLSSmoothing> _parser = new pb::MessageParser<TemporalIRLSSmoothing>(() => new TemporalIRLSSmoothing());
|
|
private pb::UnknownFieldSet _unknownFields;
|
|
private int _hasBits0;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public static pb::MessageParser<TemporalIRLSSmoothing> Parser { get { return _parser; } }
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public static pbr::MessageDescriptor Descriptor {
|
|
get { return global::Mediapipe.RegionFlowReflection.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 TemporalIRLSSmoothing() {
|
|
OnConstruction();
|
|
}
|
|
|
|
partial void OnConstruction();
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public TemporalIRLSSmoothing(TemporalIRLSSmoothing other) : this() {
|
|
_hasBits0 = other._hasBits0;
|
|
weightSum_ = other.weightSum_;
|
|
valueSum_ = other.valueSum_;
|
|
_unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public TemporalIRLSSmoothing Clone() {
|
|
return new TemporalIRLSSmoothing(this);
|
|
}
|
|
|
|
/// <summary>Field number for the "weight_sum" field.</summary>
|
|
public const int WeightSumFieldNumber = 1;
|
|
private readonly static float WeightSumDefaultValue = 0F;
|
|
|
|
private float weightSum_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public float WeightSum {
|
|
get { if ((_hasBits0 & 1) != 0) { return weightSum_; } else { return WeightSumDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 1;
|
|
weightSum_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "weight_sum" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasWeightSum {
|
|
get { return (_hasBits0 & 1) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "weight_sum" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearWeightSum() {
|
|
_hasBits0 &= ~1;
|
|
}
|
|
|
|
/// <summary>Field number for the "value_sum" field.</summary>
|
|
public const int ValueSumFieldNumber = 2;
|
|
private readonly static float ValueSumDefaultValue = 0F;
|
|
|
|
private float valueSum_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public float ValueSum {
|
|
get { if ((_hasBits0 & 2) != 0) { return valueSum_; } else { return ValueSumDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 2;
|
|
valueSum_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "value_sum" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasValueSum {
|
|
get { return (_hasBits0 & 2) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "value_sum" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearValueSum() {
|
|
_hasBits0 &= ~2;
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public override bool Equals(object other) {
|
|
return Equals(other as TemporalIRLSSmoothing);
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool Equals(TemporalIRLSSmoothing other) {
|
|
if (ReferenceEquals(other, null)) {
|
|
return false;
|
|
}
|
|
if (ReferenceEquals(other, this)) {
|
|
return true;
|
|
}
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(WeightSum, other.WeightSum)) return false;
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(ValueSum, other.ValueSum)) 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 (HasWeightSum) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(WeightSum);
|
|
if (HasValueSum) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(ValueSum);
|
|
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 (HasWeightSum) {
|
|
output.WriteRawTag(13);
|
|
output.WriteFloat(WeightSum);
|
|
}
|
|
if (HasValueSum) {
|
|
output.WriteRawTag(21);
|
|
output.WriteFloat(ValueSum);
|
|
}
|
|
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 (HasWeightSum) {
|
|
output.WriteRawTag(13);
|
|
output.WriteFloat(WeightSum);
|
|
}
|
|
if (HasValueSum) {
|
|
output.WriteRawTag(21);
|
|
output.WriteFloat(ValueSum);
|
|
}
|
|
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 (HasWeightSum) {
|
|
size += 1 + 4;
|
|
}
|
|
if (HasValueSum) {
|
|
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(TemporalIRLSSmoothing other) {
|
|
if (other == null) {
|
|
return;
|
|
}
|
|
if (other.HasWeightSum) {
|
|
WeightSum = other.WeightSum;
|
|
}
|
|
if (other.HasValueSum) {
|
|
ValueSum = other.ValueSum;
|
|
}
|
|
_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: {
|
|
WeightSum = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 21: {
|
|
ValueSum = 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: {
|
|
WeightSum = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 21: {
|
|
ValueSum = input.ReadFloat();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
}
|
|
|
|
/// <summary>
|
|
/// Tracked feature at location (x,y) with flow (dx, dy) and patch based
|
|
/// error (sum of absolute value of intensity difference).
|
|
/// Next tag: 19
|
|
/// </summary>
|
|
public sealed partial class RegionFlowFeature : pb::IExtendableMessage<RegionFlowFeature>
|
|
#if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
|
|
, pb::IBufferMessage
|
|
#endif
|
|
{
|
|
private static readonly pb::MessageParser<RegionFlowFeature> _parser = new pb::MessageParser<RegionFlowFeature>(() => new RegionFlowFeature());
|
|
private pb::UnknownFieldSet _unknownFields;
|
|
private pb::ExtensionSet<RegionFlowFeature> _extensions;
|
|
private pb::ExtensionSet<RegionFlowFeature> _Extensions { get { return _extensions; } }
|
|
private int _hasBits0;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public static pb::MessageParser<RegionFlowFeature> Parser { get { return _parser; } }
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public static pbr::MessageDescriptor Descriptor {
|
|
get { return global::Mediapipe.RegionFlowReflection.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 RegionFlowFeature() {
|
|
OnConstruction();
|
|
}
|
|
|
|
partial void OnConstruction();
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public RegionFlowFeature(RegionFlowFeature other) : this() {
|
|
_hasBits0 = other._hasBits0;
|
|
x_ = other.x_;
|
|
y_ = other.y_;
|
|
dx_ = other.dx_;
|
|
dy_ = other.dy_;
|
|
trackId_ = other.trackId_;
|
|
trackingError_ = other.trackingError_;
|
|
irlsWeight_ = other.irlsWeight_;
|
|
cornerResponse_ = other.cornerResponse_;
|
|
featureDescriptor_ = other.featureDescriptor_ != null ? other.featureDescriptor_.Clone() : null;
|
|
featureMatchDescriptor_ = other.featureMatchDescriptor_ != null ? other.featureMatchDescriptor_.Clone() : null;
|
|
internalIrls_ = other.internalIrls_ != null ? other.internalIrls_.Clone() : null;
|
|
label_ = other.label_;
|
|
flags_ = other.flags_;
|
|
featureId_ = other.featureId_;
|
|
octave_ = other.octave_;
|
|
binaryFeatureDescriptor_ = other.binaryFeatureDescriptor_ != null ? other.binaryFeatureDescriptor_.Clone() : null;
|
|
_unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
|
|
_extensions = pb::ExtensionSet.Clone(other._extensions);
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public RegionFlowFeature Clone() {
|
|
return new RegionFlowFeature(this);
|
|
}
|
|
|
|
/// <summary>Field number for the "x" field.</summary>
|
|
public const int XFieldNumber = 1;
|
|
private readonly static float XDefaultValue = 0F;
|
|
|
|
private float x_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public float X {
|
|
get { if ((_hasBits0 & 1) != 0) { return x_; } else { return XDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 1;
|
|
x_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "x" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasX {
|
|
get { return (_hasBits0 & 1) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "x" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearX() {
|
|
_hasBits0 &= ~1;
|
|
}
|
|
|
|
/// <summary>Field number for the "y" field.</summary>
|
|
public const int YFieldNumber = 2;
|
|
private readonly static float YDefaultValue = 0F;
|
|
|
|
private float y_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public float Y {
|
|
get { if ((_hasBits0 & 2) != 0) { return y_; } else { return YDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 2;
|
|
y_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "y" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasY {
|
|
get { return (_hasBits0 & 2) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "y" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearY() {
|
|
_hasBits0 &= ~2;
|
|
}
|
|
|
|
/// <summary>Field number for the "dx" field.</summary>
|
|
public const int DxFieldNumber = 3;
|
|
private readonly static float DxDefaultValue = 0F;
|
|
|
|
private float dx_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public float Dx {
|
|
get { if ((_hasBits0 & 4) != 0) { return dx_; } else { return DxDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 4;
|
|
dx_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "dx" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasDx {
|
|
get { return (_hasBits0 & 4) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "dx" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearDx() {
|
|
_hasBits0 &= ~4;
|
|
}
|
|
|
|
/// <summary>Field number for the "dy" field.</summary>
|
|
public const int DyFieldNumber = 4;
|
|
private readonly static float DyDefaultValue = 0F;
|
|
|
|
private float dy_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public float Dy {
|
|
get { if ((_hasBits0 & 8) != 0) { return dy_; } else { return DyDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 8;
|
|
dy_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "dy" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasDy {
|
|
get { return (_hasBits0 & 8) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "dy" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearDy() {
|
|
_hasBits0 &= ~8;
|
|
}
|
|
|
|
/// <summary>Field number for the "track_id" field.</summary>
|
|
public const int TrackIdFieldNumber = 13;
|
|
private readonly static int TrackIdDefaultValue = -1;
|
|
|
|
private int trackId_;
|
|
/// <summary>
|
|
/// Features that belong to the same feature track are assigned a unique id
|
|
/// and are identified via it.
|
|
/// Note, this id is only unique within the lifetime of a RegionFlowComputation
|
|
/// object. That is, if distribution or parallelization using multiple
|
|
/// instances was used, the ids are only unique within that instance context.
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public int TrackId {
|
|
get { if ((_hasBits0 & 128) != 0) { return trackId_; } else { return TrackIdDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 128;
|
|
trackId_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "track_id" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasTrackId {
|
|
get { return (_hasBits0 & 128) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "track_id" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearTrackId() {
|
|
_hasBits0 &= ~128;
|
|
}
|
|
|
|
/// <summary>Field number for the "tracking_error" field.</summary>
|
|
public const int TrackingErrorFieldNumber = 5;
|
|
private readonly static float TrackingErrorDefaultValue = 0F;
|
|
|
|
private float trackingError_;
|
|
/// <summary>
|
|
/// Tracking error as patch intensity residual (SSD).
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public float TrackingError {
|
|
get { if ((_hasBits0 & 16) != 0) { return trackingError_; } else { return TrackingErrorDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 16;
|
|
trackingError_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "tracking_error" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasTrackingError {
|
|
get { return (_hasBits0 & 16) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "tracking_error" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearTrackingError() {
|
|
_hasBits0 &= ~16;
|
|
}
|
|
|
|
/// <summary>Field number for the "irls_weight" field.</summary>
|
|
public const int IrlsWeightFieldNumber = 6;
|
|
private readonly static float IrlsWeightDefaultValue = 1F;
|
|
|
|
private float irlsWeight_;
|
|
/// <summary>
|
|
/// Inverse of registration error (in pixels), after parametric motion model
|
|
/// fitting. Values are in [0, 1e6].
|
|
/// Low values correspond to outliers, high values to inliers.
|
|
/// Set by MotionEstimation::EstimateMotions*
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public float IrlsWeight {
|
|
get { if ((_hasBits0 & 32) != 0) { return irlsWeight_; } else { return IrlsWeightDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 32;
|
|
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 & 32) != 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 &= ~32;
|
|
}
|
|
|
|
/// <summary>Field number for the "corner_response" field.</summary>
|
|
public const int CornerResponseFieldNumber = 11;
|
|
private readonly static float CornerResponseDefaultValue = 0F;
|
|
|
|
private float cornerResponse_;
|
|
/// <summary>
|
|
/// Corner response (computed as minimum eigenvalue of
|
|
/// block filtered 2nd moment matrix).
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public float CornerResponse {
|
|
get { if ((_hasBits0 & 64) != 0) { return cornerResponse_; } else { return CornerResponseDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 64;
|
|
cornerResponse_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "corner_response" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasCornerResponse {
|
|
get { return (_hasBits0 & 64) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "corner_response" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearCornerResponse() {
|
|
_hasBits0 &= ~64;
|
|
}
|
|
|
|
/// <summary>Field number for the "feature_descriptor" field.</summary>
|
|
public const int FeatureDescriptorFieldNumber = 7;
|
|
private global::Mediapipe.PatchDescriptor featureDescriptor_;
|
|
/// <summary>
|
|
/// Patch feature descriptors. *For internal use only*. External clients should
|
|
/// not rely on their contents.
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public global::Mediapipe.PatchDescriptor FeatureDescriptor {
|
|
get { return featureDescriptor_; }
|
|
set {
|
|
featureDescriptor_ = value;
|
|
}
|
|
}
|
|
|
|
/// <summary>Field number for the "feature_match_descriptor" field.</summary>
|
|
public const int FeatureMatchDescriptorFieldNumber = 8;
|
|
private global::Mediapipe.PatchDescriptor featureMatchDescriptor_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public global::Mediapipe.PatchDescriptor FeatureMatchDescriptor {
|
|
get { return featureMatchDescriptor_; }
|
|
set {
|
|
featureMatchDescriptor_ = value;
|
|
}
|
|
}
|
|
|
|
/// <summary>Field number for the "internal_irls" field.</summary>
|
|
public const int InternalIrlsFieldNumber = 10;
|
|
private global::Mediapipe.TemporalIRLSSmoothing internalIrls_;
|
|
/// <summary>
|
|
/// Internal datastructure used temporally during temporal IRLS smoothing.
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public global::Mediapipe.TemporalIRLSSmoothing InternalIrls {
|
|
get { return internalIrls_; }
|
|
set {
|
|
internalIrls_ = value;
|
|
}
|
|
}
|
|
|
|
/// <summary>Field number for the "label" field.</summary>
|
|
public const int LabelFieldNumber = 14;
|
|
private readonly static string LabelDefaultValue = "";
|
|
|
|
private string label_;
|
|
/// <summary>
|
|
/// Optional label for debugging purposes.
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public string Label {
|
|
get { return label_ ?? LabelDefaultValue; }
|
|
set {
|
|
label_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "label" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasLabel {
|
|
get { return label_ != null; }
|
|
}
|
|
/// <summary>Clears the value of the "label" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearLabel() {
|
|
label_ = null;
|
|
}
|
|
|
|
/// <summary>Field number for the "flags" field.</summary>
|
|
public const int FlagsFieldNumber = 15;
|
|
private readonly static int FlagsDefaultValue = 0;
|
|
|
|
private int flags_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public int Flags {
|
|
get { if ((_hasBits0 & 256) != 0) { return flags_; } else { return FlagsDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 256;
|
|
flags_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "flags" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasFlags {
|
|
get { return (_hasBits0 & 256) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "flags" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearFlags() {
|
|
_hasBits0 &= ~256;
|
|
}
|
|
|
|
/// <summary>Field number for the "feature_id" field.</summary>
|
|
public const int FeatureIdFieldNumber = 16;
|
|
private readonly static int FeatureIdDefaultValue = 0;
|
|
|
|
private int featureId_;
|
|
/// <summary>
|
|
/// Unique feature id per RegionFlowComputation object.
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public int FeatureId {
|
|
get { if ((_hasBits0 & 512) != 0) { return featureId_; } else { return FeatureIdDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 512;
|
|
featureId_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "feature_id" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasFeatureId {
|
|
get { return (_hasBits0 & 512) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "feature_id" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearFeatureId() {
|
|
_hasBits0 &= ~512;
|
|
}
|
|
|
|
/// <summary>Field number for the "octave" field.</summary>
|
|
public const int OctaveFieldNumber = 17;
|
|
private readonly static int OctaveDefaultValue = 0;
|
|
|
|
private int octave_;
|
|
/// <summary>
|
|
/// octave (pyramid layer) from which the keypoint has been extracted
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public int Octave {
|
|
get { if ((_hasBits0 & 1024) != 0) { return octave_; } else { return OctaveDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 1024;
|
|
octave_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "octave" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasOctave {
|
|
get { return (_hasBits0 & 1024) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "octave" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearOctave() {
|
|
_hasBits0 &= ~1024;
|
|
}
|
|
|
|
/// <summary>Field number for the "binary_feature_descriptor" field.</summary>
|
|
public const int BinaryFeatureDescriptorFieldNumber = 18;
|
|
private global::Mediapipe.BinaryFeatureDescriptor binaryFeatureDescriptor_;
|
|
/// <summary>
|
|
/// Feature descriptor for the current feature.
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public global::Mediapipe.BinaryFeatureDescriptor BinaryFeatureDescriptor {
|
|
get { return binaryFeatureDescriptor_; }
|
|
set {
|
|
binaryFeatureDescriptor_ = value;
|
|
}
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public override bool Equals(object other) {
|
|
return Equals(other as RegionFlowFeature);
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool Equals(RegionFlowFeature other) {
|
|
if (ReferenceEquals(other, null)) {
|
|
return false;
|
|
}
|
|
if (ReferenceEquals(other, this)) {
|
|
return true;
|
|
}
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(X, other.X)) return false;
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(Y, other.Y)) return false;
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(Dx, other.Dx)) return false;
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(Dy, other.Dy)) return false;
|
|
if (TrackId != other.TrackId) return false;
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(TrackingError, other.TrackingError)) return false;
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(IrlsWeight, other.IrlsWeight)) return false;
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(CornerResponse, other.CornerResponse)) return false;
|
|
if (!object.Equals(FeatureDescriptor, other.FeatureDescriptor)) return false;
|
|
if (!object.Equals(FeatureMatchDescriptor, other.FeatureMatchDescriptor)) return false;
|
|
if (!object.Equals(InternalIrls, other.InternalIrls)) return false;
|
|
if (Label != other.Label) return false;
|
|
if (Flags != other.Flags) return false;
|
|
if (FeatureId != other.FeatureId) return false;
|
|
if (Octave != other.Octave) return false;
|
|
if (!object.Equals(BinaryFeatureDescriptor, other.BinaryFeatureDescriptor)) return false;
|
|
if (!Equals(_extensions, other._extensions)) {
|
|
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 (HasX) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(X);
|
|
if (HasY) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(Y);
|
|
if (HasDx) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(Dx);
|
|
if (HasDy) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(Dy);
|
|
if (HasTrackId) hash ^= TrackId.GetHashCode();
|
|
if (HasTrackingError) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(TrackingError);
|
|
if (HasIrlsWeight) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(IrlsWeight);
|
|
if (HasCornerResponse) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(CornerResponse);
|
|
if (featureDescriptor_ != null) hash ^= FeatureDescriptor.GetHashCode();
|
|
if (featureMatchDescriptor_ != null) hash ^= FeatureMatchDescriptor.GetHashCode();
|
|
if (internalIrls_ != null) hash ^= InternalIrls.GetHashCode();
|
|
if (HasLabel) hash ^= Label.GetHashCode();
|
|
if (HasFlags) hash ^= Flags.GetHashCode();
|
|
if (HasFeatureId) hash ^= FeatureId.GetHashCode();
|
|
if (HasOctave) hash ^= Octave.GetHashCode();
|
|
if (binaryFeatureDescriptor_ != null) hash ^= BinaryFeatureDescriptor.GetHashCode();
|
|
if (_extensions != null) {
|
|
hash ^= _extensions.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 (HasX) {
|
|
output.WriteRawTag(13);
|
|
output.WriteFloat(X);
|
|
}
|
|
if (HasY) {
|
|
output.WriteRawTag(21);
|
|
output.WriteFloat(Y);
|
|
}
|
|
if (HasDx) {
|
|
output.WriteRawTag(29);
|
|
output.WriteFloat(Dx);
|
|
}
|
|
if (HasDy) {
|
|
output.WriteRawTag(37);
|
|
output.WriteFloat(Dy);
|
|
}
|
|
if (HasTrackingError) {
|
|
output.WriteRawTag(45);
|
|
output.WriteFloat(TrackingError);
|
|
}
|
|
if (HasIrlsWeight) {
|
|
output.WriteRawTag(53);
|
|
output.WriteFloat(IrlsWeight);
|
|
}
|
|
if (featureDescriptor_ != null) {
|
|
output.WriteRawTag(58);
|
|
output.WriteMessage(FeatureDescriptor);
|
|
}
|
|
if (featureMatchDescriptor_ != null) {
|
|
output.WriteRawTag(66);
|
|
output.WriteMessage(FeatureMatchDescriptor);
|
|
}
|
|
if (internalIrls_ != null) {
|
|
output.WriteRawTag(82);
|
|
output.WriteMessage(InternalIrls);
|
|
}
|
|
if (HasCornerResponse) {
|
|
output.WriteRawTag(93);
|
|
output.WriteFloat(CornerResponse);
|
|
}
|
|
if (HasTrackId) {
|
|
output.WriteRawTag(104);
|
|
output.WriteInt32(TrackId);
|
|
}
|
|
if (HasLabel) {
|
|
output.WriteRawTag(114);
|
|
output.WriteString(Label);
|
|
}
|
|
if (HasFlags) {
|
|
output.WriteRawTag(120);
|
|
output.WriteInt32(Flags);
|
|
}
|
|
if (HasFeatureId) {
|
|
output.WriteRawTag(128, 1);
|
|
output.WriteInt32(FeatureId);
|
|
}
|
|
if (HasOctave) {
|
|
output.WriteRawTag(136, 1);
|
|
output.WriteInt32(Octave);
|
|
}
|
|
if (binaryFeatureDescriptor_ != null) {
|
|
output.WriteRawTag(146, 1);
|
|
output.WriteMessage(BinaryFeatureDescriptor);
|
|
}
|
|
if (_extensions != null) {
|
|
_extensions.WriteTo(output);
|
|
}
|
|
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 (HasX) {
|
|
output.WriteRawTag(13);
|
|
output.WriteFloat(X);
|
|
}
|
|
if (HasY) {
|
|
output.WriteRawTag(21);
|
|
output.WriteFloat(Y);
|
|
}
|
|
if (HasDx) {
|
|
output.WriteRawTag(29);
|
|
output.WriteFloat(Dx);
|
|
}
|
|
if (HasDy) {
|
|
output.WriteRawTag(37);
|
|
output.WriteFloat(Dy);
|
|
}
|
|
if (HasTrackingError) {
|
|
output.WriteRawTag(45);
|
|
output.WriteFloat(TrackingError);
|
|
}
|
|
if (HasIrlsWeight) {
|
|
output.WriteRawTag(53);
|
|
output.WriteFloat(IrlsWeight);
|
|
}
|
|
if (featureDescriptor_ != null) {
|
|
output.WriteRawTag(58);
|
|
output.WriteMessage(FeatureDescriptor);
|
|
}
|
|
if (featureMatchDescriptor_ != null) {
|
|
output.WriteRawTag(66);
|
|
output.WriteMessage(FeatureMatchDescriptor);
|
|
}
|
|
if (internalIrls_ != null) {
|
|
output.WriteRawTag(82);
|
|
output.WriteMessage(InternalIrls);
|
|
}
|
|
if (HasCornerResponse) {
|
|
output.WriteRawTag(93);
|
|
output.WriteFloat(CornerResponse);
|
|
}
|
|
if (HasTrackId) {
|
|
output.WriteRawTag(104);
|
|
output.WriteInt32(TrackId);
|
|
}
|
|
if (HasLabel) {
|
|
output.WriteRawTag(114);
|
|
output.WriteString(Label);
|
|
}
|
|
if (HasFlags) {
|
|
output.WriteRawTag(120);
|
|
output.WriteInt32(Flags);
|
|
}
|
|
if (HasFeatureId) {
|
|
output.WriteRawTag(128, 1);
|
|
output.WriteInt32(FeatureId);
|
|
}
|
|
if (HasOctave) {
|
|
output.WriteRawTag(136, 1);
|
|
output.WriteInt32(Octave);
|
|
}
|
|
if (binaryFeatureDescriptor_ != null) {
|
|
output.WriteRawTag(146, 1);
|
|
output.WriteMessage(BinaryFeatureDescriptor);
|
|
}
|
|
if (_extensions != null) {
|
|
_extensions.WriteTo(ref output);
|
|
}
|
|
if (_unknownFields != null) {
|
|
_unknownFields.WriteTo(ref output);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public int CalculateSize() {
|
|
int size = 0;
|
|
if (HasX) {
|
|
size += 1 + 4;
|
|
}
|
|
if (HasY) {
|
|
size += 1 + 4;
|
|
}
|
|
if (HasDx) {
|
|
size += 1 + 4;
|
|
}
|
|
if (HasDy) {
|
|
size += 1 + 4;
|
|
}
|
|
if (HasTrackId) {
|
|
size += 1 + pb::CodedOutputStream.ComputeInt32Size(TrackId);
|
|
}
|
|
if (HasTrackingError) {
|
|
size += 1 + 4;
|
|
}
|
|
if (HasIrlsWeight) {
|
|
size += 1 + 4;
|
|
}
|
|
if (HasCornerResponse) {
|
|
size += 1 + 4;
|
|
}
|
|
if (featureDescriptor_ != null) {
|
|
size += 1 + pb::CodedOutputStream.ComputeMessageSize(FeatureDescriptor);
|
|
}
|
|
if (featureMatchDescriptor_ != null) {
|
|
size += 1 + pb::CodedOutputStream.ComputeMessageSize(FeatureMatchDescriptor);
|
|
}
|
|
if (internalIrls_ != null) {
|
|
size += 1 + pb::CodedOutputStream.ComputeMessageSize(InternalIrls);
|
|
}
|
|
if (HasLabel) {
|
|
size += 1 + pb::CodedOutputStream.ComputeStringSize(Label);
|
|
}
|
|
if (HasFlags) {
|
|
size += 1 + pb::CodedOutputStream.ComputeInt32Size(Flags);
|
|
}
|
|
if (HasFeatureId) {
|
|
size += 2 + pb::CodedOutputStream.ComputeInt32Size(FeatureId);
|
|
}
|
|
if (HasOctave) {
|
|
size += 2 + pb::CodedOutputStream.ComputeInt32Size(Octave);
|
|
}
|
|
if (binaryFeatureDescriptor_ != null) {
|
|
size += 2 + pb::CodedOutputStream.ComputeMessageSize(BinaryFeatureDescriptor);
|
|
}
|
|
if (_extensions != null) {
|
|
size += _extensions.CalculateSize();
|
|
}
|
|
if (_unknownFields != null) {
|
|
size += _unknownFields.CalculateSize();
|
|
}
|
|
return size;
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void MergeFrom(RegionFlowFeature other) {
|
|
if (other == null) {
|
|
return;
|
|
}
|
|
if (other.HasX) {
|
|
X = other.X;
|
|
}
|
|
if (other.HasY) {
|
|
Y = other.Y;
|
|
}
|
|
if (other.HasDx) {
|
|
Dx = other.Dx;
|
|
}
|
|
if (other.HasDy) {
|
|
Dy = other.Dy;
|
|
}
|
|
if (other.HasTrackId) {
|
|
TrackId = other.TrackId;
|
|
}
|
|
if (other.HasTrackingError) {
|
|
TrackingError = other.TrackingError;
|
|
}
|
|
if (other.HasIrlsWeight) {
|
|
IrlsWeight = other.IrlsWeight;
|
|
}
|
|
if (other.HasCornerResponse) {
|
|
CornerResponse = other.CornerResponse;
|
|
}
|
|
if (other.featureDescriptor_ != null) {
|
|
if (featureDescriptor_ == null) {
|
|
FeatureDescriptor = new global::Mediapipe.PatchDescriptor();
|
|
}
|
|
FeatureDescriptor.MergeFrom(other.FeatureDescriptor);
|
|
}
|
|
if (other.featureMatchDescriptor_ != null) {
|
|
if (featureMatchDescriptor_ == null) {
|
|
FeatureMatchDescriptor = new global::Mediapipe.PatchDescriptor();
|
|
}
|
|
FeatureMatchDescriptor.MergeFrom(other.FeatureMatchDescriptor);
|
|
}
|
|
if (other.internalIrls_ != null) {
|
|
if (internalIrls_ == null) {
|
|
InternalIrls = new global::Mediapipe.TemporalIRLSSmoothing();
|
|
}
|
|
InternalIrls.MergeFrom(other.InternalIrls);
|
|
}
|
|
if (other.HasLabel) {
|
|
Label = other.Label;
|
|
}
|
|
if (other.HasFlags) {
|
|
Flags = other.Flags;
|
|
}
|
|
if (other.HasFeatureId) {
|
|
FeatureId = other.FeatureId;
|
|
}
|
|
if (other.HasOctave) {
|
|
Octave = other.Octave;
|
|
}
|
|
if (other.binaryFeatureDescriptor_ != null) {
|
|
if (binaryFeatureDescriptor_ == null) {
|
|
BinaryFeatureDescriptor = new global::Mediapipe.BinaryFeatureDescriptor();
|
|
}
|
|
BinaryFeatureDescriptor.MergeFrom(other.BinaryFeatureDescriptor);
|
|
}
|
|
pb::ExtensionSet.MergeFrom(ref _extensions, other._extensions);
|
|
_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:
|
|
if (!pb::ExtensionSet.TryMergeFieldFrom(ref _extensions, input)) {
|
|
_unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
|
|
}
|
|
break;
|
|
case 13: {
|
|
X = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 21: {
|
|
Y = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 29: {
|
|
Dx = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 37: {
|
|
Dy = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 45: {
|
|
TrackingError = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 53: {
|
|
IrlsWeight = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 58: {
|
|
if (featureDescriptor_ == null) {
|
|
FeatureDescriptor = new global::Mediapipe.PatchDescriptor();
|
|
}
|
|
input.ReadMessage(FeatureDescriptor);
|
|
break;
|
|
}
|
|
case 66: {
|
|
if (featureMatchDescriptor_ == null) {
|
|
FeatureMatchDescriptor = new global::Mediapipe.PatchDescriptor();
|
|
}
|
|
input.ReadMessage(FeatureMatchDescriptor);
|
|
break;
|
|
}
|
|
case 82: {
|
|
if (internalIrls_ == null) {
|
|
InternalIrls = new global::Mediapipe.TemporalIRLSSmoothing();
|
|
}
|
|
input.ReadMessage(InternalIrls);
|
|
break;
|
|
}
|
|
case 93: {
|
|
CornerResponse = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 104: {
|
|
TrackId = input.ReadInt32();
|
|
break;
|
|
}
|
|
case 114: {
|
|
Label = input.ReadString();
|
|
break;
|
|
}
|
|
case 120: {
|
|
Flags = input.ReadInt32();
|
|
break;
|
|
}
|
|
case 128: {
|
|
FeatureId = input.ReadInt32();
|
|
break;
|
|
}
|
|
case 136: {
|
|
Octave = input.ReadInt32();
|
|
break;
|
|
}
|
|
case 146: {
|
|
if (binaryFeatureDescriptor_ == null) {
|
|
BinaryFeatureDescriptor = new global::Mediapipe.BinaryFeatureDescriptor();
|
|
}
|
|
input.ReadMessage(BinaryFeatureDescriptor);
|
|
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:
|
|
if (!pb::ExtensionSet.TryMergeFieldFrom(ref _extensions, ref input)) {
|
|
_unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
|
|
}
|
|
break;
|
|
case 13: {
|
|
X = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 21: {
|
|
Y = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 29: {
|
|
Dx = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 37: {
|
|
Dy = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 45: {
|
|
TrackingError = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 53: {
|
|
IrlsWeight = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 58: {
|
|
if (featureDescriptor_ == null) {
|
|
FeatureDescriptor = new global::Mediapipe.PatchDescriptor();
|
|
}
|
|
input.ReadMessage(FeatureDescriptor);
|
|
break;
|
|
}
|
|
case 66: {
|
|
if (featureMatchDescriptor_ == null) {
|
|
FeatureMatchDescriptor = new global::Mediapipe.PatchDescriptor();
|
|
}
|
|
input.ReadMessage(FeatureMatchDescriptor);
|
|
break;
|
|
}
|
|
case 82: {
|
|
if (internalIrls_ == null) {
|
|
InternalIrls = new global::Mediapipe.TemporalIRLSSmoothing();
|
|
}
|
|
input.ReadMessage(InternalIrls);
|
|
break;
|
|
}
|
|
case 93: {
|
|
CornerResponse = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 104: {
|
|
TrackId = input.ReadInt32();
|
|
break;
|
|
}
|
|
case 114: {
|
|
Label = input.ReadString();
|
|
break;
|
|
}
|
|
case 120: {
|
|
Flags = input.ReadInt32();
|
|
break;
|
|
}
|
|
case 128: {
|
|
FeatureId = input.ReadInt32();
|
|
break;
|
|
}
|
|
case 136: {
|
|
Octave = input.ReadInt32();
|
|
break;
|
|
}
|
|
case 146: {
|
|
if (binaryFeatureDescriptor_ == null) {
|
|
BinaryFeatureDescriptor = new global::Mediapipe.BinaryFeatureDescriptor();
|
|
}
|
|
input.ReadMessage(BinaryFeatureDescriptor);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
public TValue GetExtension<TValue>(pb::Extension<RegionFlowFeature, TValue> extension) {
|
|
return pb::ExtensionSet.Get(ref _extensions, extension);
|
|
}
|
|
public pbc::RepeatedField<TValue> GetExtension<TValue>(pb::RepeatedExtension<RegionFlowFeature, TValue> extension) {
|
|
return pb::ExtensionSet.Get(ref _extensions, extension);
|
|
}
|
|
public pbc::RepeatedField<TValue> GetOrInitializeExtension<TValue>(pb::RepeatedExtension<RegionFlowFeature, TValue> extension) {
|
|
return pb::ExtensionSet.GetOrInitialize(ref _extensions, extension);
|
|
}
|
|
public void SetExtension<TValue>(pb::Extension<RegionFlowFeature, TValue> extension, TValue value) {
|
|
pb::ExtensionSet.Set(ref _extensions, extension, value);
|
|
}
|
|
public bool HasExtension<TValue>(pb::Extension<RegionFlowFeature, TValue> extension) {
|
|
return pb::ExtensionSet.Has(ref _extensions, extension);
|
|
}
|
|
public void ClearExtension<TValue>(pb::Extension<RegionFlowFeature, TValue> extension) {
|
|
pb::ExtensionSet.Clear(ref _extensions, extension);
|
|
}
|
|
public void ClearExtension<TValue>(pb::RepeatedExtension<RegionFlowFeature, TValue> extension) {
|
|
pb::ExtensionSet.Clear(ref _extensions, extension);
|
|
}
|
|
|
|
#region Nested types
|
|
/// <summary>Container for nested types declared in the RegionFlowFeature message type.</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public static partial class Types {
|
|
/// <summary>
|
|
/// Flags indicating specific statuses.
|
|
/// </summary>
|
|
public enum Flags {
|
|
/// <summary>
|
|
/// Used for long feature tracks if track id
|
|
/// </summary>
|
|
[pbr::OriginalName("FLAG_BROKEN_TRACK")] FlagBrokenTrack = 1,
|
|
}
|
|
|
|
}
|
|
#endregion
|
|
|
|
}
|
|
|
|
/// <summary>
|
|
/// RegionFlowFrame is a optical flow representation where each region has a
|
|
/// consistent optical flow (adheres to local translational model).
|
|
/// Regions are arranged in a regular grid according to BlockDescriptor.
|
|
/// Next tag: 11.
|
|
/// </summary>
|
|
public sealed partial class RegionFlowFrame : pb::IExtendableMessage<RegionFlowFrame>
|
|
#if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
|
|
, pb::IBufferMessage
|
|
#endif
|
|
{
|
|
private static readonly pb::MessageParser<RegionFlowFrame> _parser = new pb::MessageParser<RegionFlowFrame>(() => new RegionFlowFrame());
|
|
private pb::UnknownFieldSet _unknownFields;
|
|
private pb::ExtensionSet<RegionFlowFrame> _extensions;
|
|
private pb::ExtensionSet<RegionFlowFrame> _Extensions { get { return _extensions; } }
|
|
private int _hasBits0;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public static pb::MessageParser<RegionFlowFrame> Parser { get { return _parser; } }
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public static pbr::MessageDescriptor Descriptor {
|
|
get { return global::Mediapipe.RegionFlowReflection.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 RegionFlowFrame() {
|
|
OnConstruction();
|
|
}
|
|
|
|
partial void OnConstruction();
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public RegionFlowFrame(RegionFlowFrame other) : this() {
|
|
_hasBits0 = other._hasBits0;
|
|
regionFlow_ = other.regionFlow_.Clone();
|
|
numTotalFeatures_ = other.numTotalFeatures_;
|
|
unstableFrame_ = other.unstableFrame_;
|
|
blurScore_ = other.blurScore_;
|
|
frameWidth_ = other.frameWidth_;
|
|
frameHeight_ = other.frameHeight_;
|
|
blockDescriptor_ = other.blockDescriptor_ != null ? other.blockDescriptor_.Clone() : null;
|
|
_unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
|
|
_extensions = pb::ExtensionSet.Clone(other._extensions);
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public RegionFlowFrame Clone() {
|
|
return new RegionFlowFrame(this);
|
|
}
|
|
|
|
/// <summary>Field number for the "region_flow" field.</summary>
|
|
public const int RegionFlowFieldNumber = 1;
|
|
private static readonly pb::FieldCodec<global::Mediapipe.RegionFlowFrame.Types.RegionFlow> _repeated_regionFlow_codec
|
|
= pb::FieldCodec.ForMessage(10, global::Mediapipe.RegionFlowFrame.Types.RegionFlow.Parser);
|
|
private readonly pbc::RepeatedField<global::Mediapipe.RegionFlowFrame.Types.RegionFlow> regionFlow_ = new pbc::RepeatedField<global::Mediapipe.RegionFlowFrame.Types.RegionFlow>();
|
|
/// <summary>
|
|
/// Sorted by id for quick lookup.
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public pbc::RepeatedField<global::Mediapipe.RegionFlowFrame.Types.RegionFlow> RegionFlow {
|
|
get { return regionFlow_; }
|
|
}
|
|
|
|
/// <summary>Field number for the "num_total_features" field.</summary>
|
|
public const int NumTotalFeaturesFieldNumber = 2;
|
|
private readonly static int NumTotalFeaturesDefaultValue = 0;
|
|
|
|
private int numTotalFeatures_;
|
|
/// <summary>
|
|
/// Total number of features in all RegionFlow's.
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public int NumTotalFeatures {
|
|
get { if ((_hasBits0 & 1) != 0) { return numTotalFeatures_; } else { return NumTotalFeaturesDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 1;
|
|
numTotalFeatures_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "num_total_features" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasNumTotalFeatures {
|
|
get { return (_hasBits0 & 1) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "num_total_features" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearNumTotalFeatures() {
|
|
_hasBits0 &= ~1;
|
|
}
|
|
|
|
/// <summary>Field number for the "unstable_frame" field.</summary>
|
|
public const int UnstableFrameFieldNumber = 4;
|
|
private readonly static bool UnstableFrameDefaultValue = false;
|
|
|
|
private bool unstableFrame_;
|
|
/// <summary>
|
|
/// If set, indicates that the frame's region flow is unstable.
|
|
/// (not enough features or coverage too low).
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool UnstableFrame {
|
|
get { if ((_hasBits0 & 2) != 0) { return unstableFrame_; } else { return UnstableFrameDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 2;
|
|
unstableFrame_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "unstable_frame" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasUnstableFrame {
|
|
get { return (_hasBits0 & 2) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "unstable_frame" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearUnstableFrame() {
|
|
_hasBits0 &= ~2;
|
|
}
|
|
|
|
/// <summary>Field number for the "blur_score" field.</summary>
|
|
public const int BlurScoreFieldNumber = 7;
|
|
private readonly static float BlurScoreDefaultValue = 0F;
|
|
|
|
private float blurScore_;
|
|
/// <summary>
|
|
/// Blur score of the current frame is defined as the n-th percentile
|
|
/// of the corneress of the input frame evaluated over regions of high
|
|
/// corneress. For details see BlurScoreOptions in
|
|
/// region_flow_computation.proto.
|
|
/// The actual value is pretty meaningless, but relative to the blur score
|
|
/// of other frames one can detect blurry frames, e.g. by a 'significant'
|
|
/// local maxima in a sequence of blur_scores.
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public float BlurScore {
|
|
get { if ((_hasBits0 & 4) != 0) { return blurScore_; } else { return BlurScoreDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 4;
|
|
blurScore_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "blur_score" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasBlurScore {
|
|
get { return (_hasBits0 & 4) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "blur_score" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearBlurScore() {
|
|
_hasBits0 &= ~4;
|
|
}
|
|
|
|
/// <summary>Field number for the "frame_width" field.</summary>
|
|
public const int FrameWidthFieldNumber = 8;
|
|
private readonly static int FrameWidthDefaultValue = 0;
|
|
|
|
private int frameWidth_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public int FrameWidth {
|
|
get { if ((_hasBits0 & 8) != 0) { return frameWidth_; } else { return FrameWidthDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 8;
|
|
frameWidth_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "frame_width" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasFrameWidth {
|
|
get { return (_hasBits0 & 8) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "frame_width" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearFrameWidth() {
|
|
_hasBits0 &= ~8;
|
|
}
|
|
|
|
/// <summary>Field number for the "frame_height" field.</summary>
|
|
public const int FrameHeightFieldNumber = 9;
|
|
private readonly static int FrameHeightDefaultValue = 0;
|
|
|
|
private int frameHeight_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public int FrameHeight {
|
|
get { if ((_hasBits0 & 16) != 0) { return frameHeight_; } else { return FrameHeightDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 16;
|
|
frameHeight_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "frame_height" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasFrameHeight {
|
|
get { return (_hasBits0 & 16) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "frame_height" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearFrameHeight() {
|
|
_hasBits0 &= ~16;
|
|
}
|
|
|
|
/// <summary>Field number for the "block_descriptor" field.</summary>
|
|
public const int BlockDescriptorFieldNumber = 10;
|
|
private global::Mediapipe.RegionFlowFrame.Types.BlockDescriptor blockDescriptor_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public global::Mediapipe.RegionFlowFrame.Types.BlockDescriptor BlockDescriptor {
|
|
get { return blockDescriptor_; }
|
|
set {
|
|
blockDescriptor_ = value;
|
|
}
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public override bool Equals(object other) {
|
|
return Equals(other as RegionFlowFrame);
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool Equals(RegionFlowFrame other) {
|
|
if (ReferenceEquals(other, null)) {
|
|
return false;
|
|
}
|
|
if (ReferenceEquals(other, this)) {
|
|
return true;
|
|
}
|
|
if(!regionFlow_.Equals(other.regionFlow_)) return false;
|
|
if (NumTotalFeatures != other.NumTotalFeatures) return false;
|
|
if (UnstableFrame != other.UnstableFrame) return false;
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(BlurScore, other.BlurScore)) return false;
|
|
if (FrameWidth != other.FrameWidth) return false;
|
|
if (FrameHeight != other.FrameHeight) return false;
|
|
if (!object.Equals(BlockDescriptor, other.BlockDescriptor)) return false;
|
|
if (!Equals(_extensions, other._extensions)) {
|
|
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 ^= regionFlow_.GetHashCode();
|
|
if (HasNumTotalFeatures) hash ^= NumTotalFeatures.GetHashCode();
|
|
if (HasUnstableFrame) hash ^= UnstableFrame.GetHashCode();
|
|
if (HasBlurScore) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(BlurScore);
|
|
if (HasFrameWidth) hash ^= FrameWidth.GetHashCode();
|
|
if (HasFrameHeight) hash ^= FrameHeight.GetHashCode();
|
|
if (blockDescriptor_ != null) hash ^= BlockDescriptor.GetHashCode();
|
|
if (_extensions != null) {
|
|
hash ^= _extensions.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
|
|
regionFlow_.WriteTo(output, _repeated_regionFlow_codec);
|
|
if (HasNumTotalFeatures) {
|
|
output.WriteRawTag(16);
|
|
output.WriteInt32(NumTotalFeatures);
|
|
}
|
|
if (HasUnstableFrame) {
|
|
output.WriteRawTag(32);
|
|
output.WriteBool(UnstableFrame);
|
|
}
|
|
if (HasBlurScore) {
|
|
output.WriteRawTag(61);
|
|
output.WriteFloat(BlurScore);
|
|
}
|
|
if (HasFrameWidth) {
|
|
output.WriteRawTag(64);
|
|
output.WriteInt32(FrameWidth);
|
|
}
|
|
if (HasFrameHeight) {
|
|
output.WriteRawTag(72);
|
|
output.WriteInt32(FrameHeight);
|
|
}
|
|
if (blockDescriptor_ != null) {
|
|
output.WriteRawTag(82);
|
|
output.WriteMessage(BlockDescriptor);
|
|
}
|
|
if (_extensions != null) {
|
|
_extensions.WriteTo(output);
|
|
}
|
|
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) {
|
|
regionFlow_.WriteTo(ref output, _repeated_regionFlow_codec);
|
|
if (HasNumTotalFeatures) {
|
|
output.WriteRawTag(16);
|
|
output.WriteInt32(NumTotalFeatures);
|
|
}
|
|
if (HasUnstableFrame) {
|
|
output.WriteRawTag(32);
|
|
output.WriteBool(UnstableFrame);
|
|
}
|
|
if (HasBlurScore) {
|
|
output.WriteRawTag(61);
|
|
output.WriteFloat(BlurScore);
|
|
}
|
|
if (HasFrameWidth) {
|
|
output.WriteRawTag(64);
|
|
output.WriteInt32(FrameWidth);
|
|
}
|
|
if (HasFrameHeight) {
|
|
output.WriteRawTag(72);
|
|
output.WriteInt32(FrameHeight);
|
|
}
|
|
if (blockDescriptor_ != null) {
|
|
output.WriteRawTag(82);
|
|
output.WriteMessage(BlockDescriptor);
|
|
}
|
|
if (_extensions != null) {
|
|
_extensions.WriteTo(ref output);
|
|
}
|
|
if (_unknownFields != null) {
|
|
_unknownFields.WriteTo(ref output);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public int CalculateSize() {
|
|
int size = 0;
|
|
size += regionFlow_.CalculateSize(_repeated_regionFlow_codec);
|
|
if (HasNumTotalFeatures) {
|
|
size += 1 + pb::CodedOutputStream.ComputeInt32Size(NumTotalFeatures);
|
|
}
|
|
if (HasUnstableFrame) {
|
|
size += 1 + 1;
|
|
}
|
|
if (HasBlurScore) {
|
|
size += 1 + 4;
|
|
}
|
|
if (HasFrameWidth) {
|
|
size += 1 + pb::CodedOutputStream.ComputeInt32Size(FrameWidth);
|
|
}
|
|
if (HasFrameHeight) {
|
|
size += 1 + pb::CodedOutputStream.ComputeInt32Size(FrameHeight);
|
|
}
|
|
if (blockDescriptor_ != null) {
|
|
size += 1 + pb::CodedOutputStream.ComputeMessageSize(BlockDescriptor);
|
|
}
|
|
if (_extensions != null) {
|
|
size += _extensions.CalculateSize();
|
|
}
|
|
if (_unknownFields != null) {
|
|
size += _unknownFields.CalculateSize();
|
|
}
|
|
return size;
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void MergeFrom(RegionFlowFrame other) {
|
|
if (other == null) {
|
|
return;
|
|
}
|
|
regionFlow_.Add(other.regionFlow_);
|
|
if (other.HasNumTotalFeatures) {
|
|
NumTotalFeatures = other.NumTotalFeatures;
|
|
}
|
|
if (other.HasUnstableFrame) {
|
|
UnstableFrame = other.UnstableFrame;
|
|
}
|
|
if (other.HasBlurScore) {
|
|
BlurScore = other.BlurScore;
|
|
}
|
|
if (other.HasFrameWidth) {
|
|
FrameWidth = other.FrameWidth;
|
|
}
|
|
if (other.HasFrameHeight) {
|
|
FrameHeight = other.FrameHeight;
|
|
}
|
|
if (other.blockDescriptor_ != null) {
|
|
if (blockDescriptor_ == null) {
|
|
BlockDescriptor = new global::Mediapipe.RegionFlowFrame.Types.BlockDescriptor();
|
|
}
|
|
BlockDescriptor.MergeFrom(other.BlockDescriptor);
|
|
}
|
|
pb::ExtensionSet.MergeFrom(ref _extensions, other._extensions);
|
|
_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:
|
|
if (!pb::ExtensionSet.TryMergeFieldFrom(ref _extensions, input)) {
|
|
_unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
|
|
}
|
|
break;
|
|
case 10: {
|
|
regionFlow_.AddEntriesFrom(input, _repeated_regionFlow_codec);
|
|
break;
|
|
}
|
|
case 16: {
|
|
NumTotalFeatures = input.ReadInt32();
|
|
break;
|
|
}
|
|
case 32: {
|
|
UnstableFrame = input.ReadBool();
|
|
break;
|
|
}
|
|
case 61: {
|
|
BlurScore = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 64: {
|
|
FrameWidth = input.ReadInt32();
|
|
break;
|
|
}
|
|
case 72: {
|
|
FrameHeight = input.ReadInt32();
|
|
break;
|
|
}
|
|
case 82: {
|
|
if (blockDescriptor_ == null) {
|
|
BlockDescriptor = new global::Mediapipe.RegionFlowFrame.Types.BlockDescriptor();
|
|
}
|
|
input.ReadMessage(BlockDescriptor);
|
|
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:
|
|
if (!pb::ExtensionSet.TryMergeFieldFrom(ref _extensions, ref input)) {
|
|
_unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
|
|
}
|
|
break;
|
|
case 10: {
|
|
regionFlow_.AddEntriesFrom(ref input, _repeated_regionFlow_codec);
|
|
break;
|
|
}
|
|
case 16: {
|
|
NumTotalFeatures = input.ReadInt32();
|
|
break;
|
|
}
|
|
case 32: {
|
|
UnstableFrame = input.ReadBool();
|
|
break;
|
|
}
|
|
case 61: {
|
|
BlurScore = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 64: {
|
|
FrameWidth = input.ReadInt32();
|
|
break;
|
|
}
|
|
case 72: {
|
|
FrameHeight = input.ReadInt32();
|
|
break;
|
|
}
|
|
case 82: {
|
|
if (blockDescriptor_ == null) {
|
|
BlockDescriptor = new global::Mediapipe.RegionFlowFrame.Types.BlockDescriptor();
|
|
}
|
|
input.ReadMessage(BlockDescriptor);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
public TValue GetExtension<TValue>(pb::Extension<RegionFlowFrame, TValue> extension) {
|
|
return pb::ExtensionSet.Get(ref _extensions, extension);
|
|
}
|
|
public pbc::RepeatedField<TValue> GetExtension<TValue>(pb::RepeatedExtension<RegionFlowFrame, TValue> extension) {
|
|
return pb::ExtensionSet.Get(ref _extensions, extension);
|
|
}
|
|
public pbc::RepeatedField<TValue> GetOrInitializeExtension<TValue>(pb::RepeatedExtension<RegionFlowFrame, TValue> extension) {
|
|
return pb::ExtensionSet.GetOrInitialize(ref _extensions, extension);
|
|
}
|
|
public void SetExtension<TValue>(pb::Extension<RegionFlowFrame, TValue> extension, TValue value) {
|
|
pb::ExtensionSet.Set(ref _extensions, extension, value);
|
|
}
|
|
public bool HasExtension<TValue>(pb::Extension<RegionFlowFrame, TValue> extension) {
|
|
return pb::ExtensionSet.Has(ref _extensions, extension);
|
|
}
|
|
public void ClearExtension<TValue>(pb::Extension<RegionFlowFrame, TValue> extension) {
|
|
pb::ExtensionSet.Clear(ref _extensions, extension);
|
|
}
|
|
public void ClearExtension<TValue>(pb::RepeatedExtension<RegionFlowFrame, TValue> extension) {
|
|
pb::ExtensionSet.Clear(ref _extensions, extension);
|
|
}
|
|
|
|
#region Nested types
|
|
/// <summary>Container for nested types declared in the RegionFlowFrame message type.</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public static partial class Types {
|
|
/// <summary>
|
|
/// Next tag: 8
|
|
/// </summary>
|
|
public sealed partial class RegionFlow : pb::IExtendableMessage<RegionFlow>
|
|
#if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
|
|
, pb::IBufferMessage
|
|
#endif
|
|
{
|
|
private static readonly pb::MessageParser<RegionFlow> _parser = new pb::MessageParser<RegionFlow>(() => new RegionFlow());
|
|
private pb::UnknownFieldSet _unknownFields;
|
|
private pb::ExtensionSet<RegionFlow> _extensions;
|
|
private pb::ExtensionSet<RegionFlow> _Extensions { get { return _extensions; } }
|
|
private int _hasBits0;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public static pb::MessageParser<RegionFlow> Parser { get { return _parser; } }
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public static pbr::MessageDescriptor Descriptor {
|
|
get { return global::Mediapipe.RegionFlowFrame.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 RegionFlow() {
|
|
OnConstruction();
|
|
}
|
|
|
|
partial void OnConstruction();
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public RegionFlow(RegionFlow other) : this() {
|
|
_hasBits0 = other._hasBits0;
|
|
regionId_ = other.regionId_;
|
|
centroidX_ = other.centroidX_;
|
|
centroidY_ = other.centroidY_;
|
|
flowX_ = other.flowX_;
|
|
flowY_ = other.flowY_;
|
|
feature_ = other.feature_.Clone();
|
|
_unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
|
|
_extensions = pb::ExtensionSet.Clone(other._extensions);
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public RegionFlow Clone() {
|
|
return new RegionFlow(this);
|
|
}
|
|
|
|
/// <summary>Field number for the "region_id" field.</summary>
|
|
public const int RegionIdFieldNumber = 1;
|
|
private readonly static int RegionIdDefaultValue = 0;
|
|
|
|
private int regionId_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public int RegionId {
|
|
get { if ((_hasBits0 & 1) != 0) { return regionId_; } else { return RegionIdDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 1;
|
|
regionId_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "region_id" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasRegionId {
|
|
get { return (_hasBits0 & 1) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "region_id" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearRegionId() {
|
|
_hasBits0 &= ~1;
|
|
}
|
|
|
|
/// <summary>Field number for the "centroid_x" field.</summary>
|
|
public const int CentroidXFieldNumber = 2;
|
|
private readonly static float CentroidXDefaultValue = 0F;
|
|
|
|
private float centroidX_;
|
|
/// <summary>
|
|
/// Mean anchor point (centroid) of flow vector and mean flow.
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public float CentroidX {
|
|
get { if ((_hasBits0 & 2) != 0) { return centroidX_; } else { return CentroidXDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 2;
|
|
centroidX_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "centroid_x" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasCentroidX {
|
|
get { return (_hasBits0 & 2) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "centroid_x" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearCentroidX() {
|
|
_hasBits0 &= ~2;
|
|
}
|
|
|
|
/// <summary>Field number for the "centroid_y" field.</summary>
|
|
public const int CentroidYFieldNumber = 3;
|
|
private readonly static float CentroidYDefaultValue = 0F;
|
|
|
|
private float centroidY_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public float CentroidY {
|
|
get { if ((_hasBits0 & 4) != 0) { return centroidY_; } else { return CentroidYDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 4;
|
|
centroidY_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "centroid_y" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasCentroidY {
|
|
get { return (_hasBits0 & 4) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "centroid_y" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearCentroidY() {
|
|
_hasBits0 &= ~4;
|
|
}
|
|
|
|
/// <summary>Field number for the "flow_x" field.</summary>
|
|
public const int FlowXFieldNumber = 4;
|
|
private readonly static float FlowXDefaultValue = 0F;
|
|
|
|
private float flowX_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public float FlowX {
|
|
get { if ((_hasBits0 & 8) != 0) { return flowX_; } else { return FlowXDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 8;
|
|
flowX_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "flow_x" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasFlowX {
|
|
get { return (_hasBits0 & 8) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "flow_x" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearFlowX() {
|
|
_hasBits0 &= ~8;
|
|
}
|
|
|
|
/// <summary>Field number for the "flow_y" field.</summary>
|
|
public const int FlowYFieldNumber = 5;
|
|
private readonly static float FlowYDefaultValue = 0F;
|
|
|
|
private float flowY_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public float FlowY {
|
|
get { if ((_hasBits0 & 16) != 0) { return flowY_; } else { return FlowYDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 16;
|
|
flowY_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "flow_y" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasFlowY {
|
|
get { return (_hasBits0 & 16) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "flow_y" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearFlowY() {
|
|
_hasBits0 &= ~16;
|
|
}
|
|
|
|
/// <summary>Field number for the "feature" field.</summary>
|
|
public const int FeatureFieldNumber = 7;
|
|
private static readonly pb::FieldCodec<global::Mediapipe.RegionFlowFeature> _repeated_feature_codec
|
|
= pb::FieldCodec.ForMessage(58, global::Mediapipe.RegionFlowFeature.Parser);
|
|
private readonly pbc::RepeatedField<global::Mediapipe.RegionFlowFeature> feature_ = new pbc::RepeatedField<global::Mediapipe.RegionFlowFeature>();
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public pbc::RepeatedField<global::Mediapipe.RegionFlowFeature> Feature {
|
|
get { return feature_; }
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public override bool Equals(object other) {
|
|
return Equals(other as RegionFlow);
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool Equals(RegionFlow other) {
|
|
if (ReferenceEquals(other, null)) {
|
|
return false;
|
|
}
|
|
if (ReferenceEquals(other, this)) {
|
|
return true;
|
|
}
|
|
if (RegionId != other.RegionId) return false;
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(CentroidX, other.CentroidX)) return false;
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(CentroidY, other.CentroidY)) return false;
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(FlowX, other.FlowX)) return false;
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(FlowY, other.FlowY)) return false;
|
|
if(!feature_.Equals(other.feature_)) return false;
|
|
if (!Equals(_extensions, other._extensions)) {
|
|
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 (HasRegionId) hash ^= RegionId.GetHashCode();
|
|
if (HasCentroidX) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(CentroidX);
|
|
if (HasCentroidY) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(CentroidY);
|
|
if (HasFlowX) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(FlowX);
|
|
if (HasFlowY) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(FlowY);
|
|
hash ^= feature_.GetHashCode();
|
|
if (_extensions != null) {
|
|
hash ^= _extensions.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 (HasRegionId) {
|
|
output.WriteRawTag(8);
|
|
output.WriteInt32(RegionId);
|
|
}
|
|
if (HasCentroidX) {
|
|
output.WriteRawTag(21);
|
|
output.WriteFloat(CentroidX);
|
|
}
|
|
if (HasCentroidY) {
|
|
output.WriteRawTag(29);
|
|
output.WriteFloat(CentroidY);
|
|
}
|
|
if (HasFlowX) {
|
|
output.WriteRawTag(37);
|
|
output.WriteFloat(FlowX);
|
|
}
|
|
if (HasFlowY) {
|
|
output.WriteRawTag(45);
|
|
output.WriteFloat(FlowY);
|
|
}
|
|
feature_.WriteTo(output, _repeated_feature_codec);
|
|
if (_extensions != null) {
|
|
_extensions.WriteTo(output);
|
|
}
|
|
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 (HasRegionId) {
|
|
output.WriteRawTag(8);
|
|
output.WriteInt32(RegionId);
|
|
}
|
|
if (HasCentroidX) {
|
|
output.WriteRawTag(21);
|
|
output.WriteFloat(CentroidX);
|
|
}
|
|
if (HasCentroidY) {
|
|
output.WriteRawTag(29);
|
|
output.WriteFloat(CentroidY);
|
|
}
|
|
if (HasFlowX) {
|
|
output.WriteRawTag(37);
|
|
output.WriteFloat(FlowX);
|
|
}
|
|
if (HasFlowY) {
|
|
output.WriteRawTag(45);
|
|
output.WriteFloat(FlowY);
|
|
}
|
|
feature_.WriteTo(ref output, _repeated_feature_codec);
|
|
if (_extensions != null) {
|
|
_extensions.WriteTo(ref output);
|
|
}
|
|
if (_unknownFields != null) {
|
|
_unknownFields.WriteTo(ref output);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public int CalculateSize() {
|
|
int size = 0;
|
|
if (HasRegionId) {
|
|
size += 1 + pb::CodedOutputStream.ComputeInt32Size(RegionId);
|
|
}
|
|
if (HasCentroidX) {
|
|
size += 1 + 4;
|
|
}
|
|
if (HasCentroidY) {
|
|
size += 1 + 4;
|
|
}
|
|
if (HasFlowX) {
|
|
size += 1 + 4;
|
|
}
|
|
if (HasFlowY) {
|
|
size += 1 + 4;
|
|
}
|
|
size += feature_.CalculateSize(_repeated_feature_codec);
|
|
if (_extensions != null) {
|
|
size += _extensions.CalculateSize();
|
|
}
|
|
if (_unknownFields != null) {
|
|
size += _unknownFields.CalculateSize();
|
|
}
|
|
return size;
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void MergeFrom(RegionFlow other) {
|
|
if (other == null) {
|
|
return;
|
|
}
|
|
if (other.HasRegionId) {
|
|
RegionId = other.RegionId;
|
|
}
|
|
if (other.HasCentroidX) {
|
|
CentroidX = other.CentroidX;
|
|
}
|
|
if (other.HasCentroidY) {
|
|
CentroidY = other.CentroidY;
|
|
}
|
|
if (other.HasFlowX) {
|
|
FlowX = other.FlowX;
|
|
}
|
|
if (other.HasFlowY) {
|
|
FlowY = other.FlowY;
|
|
}
|
|
feature_.Add(other.feature_);
|
|
pb::ExtensionSet.MergeFrom(ref _extensions, other._extensions);
|
|
_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:
|
|
if (!pb::ExtensionSet.TryMergeFieldFrom(ref _extensions, input)) {
|
|
_unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
|
|
}
|
|
break;
|
|
case 8: {
|
|
RegionId = input.ReadInt32();
|
|
break;
|
|
}
|
|
case 21: {
|
|
CentroidX = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 29: {
|
|
CentroidY = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 37: {
|
|
FlowX = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 45: {
|
|
FlowY = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 58: {
|
|
feature_.AddEntriesFrom(input, _repeated_feature_codec);
|
|
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:
|
|
if (!pb::ExtensionSet.TryMergeFieldFrom(ref _extensions, ref input)) {
|
|
_unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
|
|
}
|
|
break;
|
|
case 8: {
|
|
RegionId = input.ReadInt32();
|
|
break;
|
|
}
|
|
case 21: {
|
|
CentroidX = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 29: {
|
|
CentroidY = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 37: {
|
|
FlowX = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 45: {
|
|
FlowY = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 58: {
|
|
feature_.AddEntriesFrom(ref input, _repeated_feature_codec);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
public TValue GetExtension<TValue>(pb::Extension<RegionFlow, TValue> extension) {
|
|
return pb::ExtensionSet.Get(ref _extensions, extension);
|
|
}
|
|
public pbc::RepeatedField<TValue> GetExtension<TValue>(pb::RepeatedExtension<RegionFlow, TValue> extension) {
|
|
return pb::ExtensionSet.Get(ref _extensions, extension);
|
|
}
|
|
public pbc::RepeatedField<TValue> GetOrInitializeExtension<TValue>(pb::RepeatedExtension<RegionFlow, TValue> extension) {
|
|
return pb::ExtensionSet.GetOrInitialize(ref _extensions, extension);
|
|
}
|
|
public void SetExtension<TValue>(pb::Extension<RegionFlow, TValue> extension, TValue value) {
|
|
pb::ExtensionSet.Set(ref _extensions, extension, value);
|
|
}
|
|
public bool HasExtension<TValue>(pb::Extension<RegionFlow, TValue> extension) {
|
|
return pb::ExtensionSet.Has(ref _extensions, extension);
|
|
}
|
|
public void ClearExtension<TValue>(pb::Extension<RegionFlow, TValue> extension) {
|
|
pb::ExtensionSet.Clear(ref _extensions, extension);
|
|
}
|
|
public void ClearExtension<TValue>(pb::RepeatedExtension<RegionFlow, TValue> extension) {
|
|
pb::ExtensionSet.Clear(ref _extensions, extension);
|
|
}
|
|
|
|
}
|
|
|
|
/// <summary>
|
|
/// Region flow is estimated using a grid of equal sized bins as regions.
|
|
/// BlockDescriptor specifies size of bins/blocks.
|
|
/// </summary>
|
|
public sealed partial class BlockDescriptor : pb::IMessage<BlockDescriptor>
|
|
#if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
|
|
, pb::IBufferMessage
|
|
#endif
|
|
{
|
|
private static readonly pb::MessageParser<BlockDescriptor> _parser = new pb::MessageParser<BlockDescriptor>(() => new BlockDescriptor());
|
|
private pb::UnknownFieldSet _unknownFields;
|
|
private int _hasBits0;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public static pb::MessageParser<BlockDescriptor> Parser { get { return _parser; } }
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public static pbr::MessageDescriptor Descriptor {
|
|
get { return global::Mediapipe.RegionFlowFrame.Descriptor.NestedTypes[1]; }
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
pbr::MessageDescriptor pb::IMessage.Descriptor {
|
|
get { return Descriptor; }
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public BlockDescriptor() {
|
|
OnConstruction();
|
|
}
|
|
|
|
partial void OnConstruction();
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public BlockDescriptor(BlockDescriptor other) : this() {
|
|
_hasBits0 = other._hasBits0;
|
|
blockWidth_ = other.blockWidth_;
|
|
blockHeight_ = other.blockHeight_;
|
|
numBlocksX_ = other.numBlocksX_;
|
|
numBlocksY_ = other.numBlocksY_;
|
|
_unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public BlockDescriptor Clone() {
|
|
return new BlockDescriptor(this);
|
|
}
|
|
|
|
/// <summary>Field number for the "block_width" field.</summary>
|
|
public const int BlockWidthFieldNumber = 1;
|
|
private readonly static int BlockWidthDefaultValue = 0;
|
|
|
|
private int blockWidth_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public int BlockWidth {
|
|
get { if ((_hasBits0 & 1) != 0) { return blockWidth_; } else { return BlockWidthDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 1;
|
|
blockWidth_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "block_width" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasBlockWidth {
|
|
get { return (_hasBits0 & 1) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "block_width" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearBlockWidth() {
|
|
_hasBits0 &= ~1;
|
|
}
|
|
|
|
/// <summary>Field number for the "block_height" field.</summary>
|
|
public const int BlockHeightFieldNumber = 2;
|
|
private readonly static int BlockHeightDefaultValue = 0;
|
|
|
|
private int blockHeight_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public int BlockHeight {
|
|
get { if ((_hasBits0 & 2) != 0) { return blockHeight_; } else { return BlockHeightDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 2;
|
|
blockHeight_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "block_height" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasBlockHeight {
|
|
get { return (_hasBits0 & 2) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "block_height" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearBlockHeight() {
|
|
_hasBits0 &= ~2;
|
|
}
|
|
|
|
/// <summary>Field number for the "num_blocks_x" field.</summary>
|
|
public const int NumBlocksXFieldNumber = 3;
|
|
private readonly static int NumBlocksXDefaultValue = 0;
|
|
|
|
private int numBlocksX_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public int NumBlocksX {
|
|
get { if ((_hasBits0 & 4) != 0) { return numBlocksX_; } else { return NumBlocksXDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 4;
|
|
numBlocksX_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "num_blocks_x" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasNumBlocksX {
|
|
get { return (_hasBits0 & 4) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "num_blocks_x" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearNumBlocksX() {
|
|
_hasBits0 &= ~4;
|
|
}
|
|
|
|
/// <summary>Field number for the "num_blocks_y" field.</summary>
|
|
public const int NumBlocksYFieldNumber = 4;
|
|
private readonly static int NumBlocksYDefaultValue = 0;
|
|
|
|
private int numBlocksY_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public int NumBlocksY {
|
|
get { if ((_hasBits0 & 8) != 0) { return numBlocksY_; } else { return NumBlocksYDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 8;
|
|
numBlocksY_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "num_blocks_y" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasNumBlocksY {
|
|
get { return (_hasBits0 & 8) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "num_blocks_y" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearNumBlocksY() {
|
|
_hasBits0 &= ~8;
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public override bool Equals(object other) {
|
|
return Equals(other as BlockDescriptor);
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool Equals(BlockDescriptor other) {
|
|
if (ReferenceEquals(other, null)) {
|
|
return false;
|
|
}
|
|
if (ReferenceEquals(other, this)) {
|
|
return true;
|
|
}
|
|
if (BlockWidth != other.BlockWidth) return false;
|
|
if (BlockHeight != other.BlockHeight) return false;
|
|
if (NumBlocksX != other.NumBlocksX) return false;
|
|
if (NumBlocksY != other.NumBlocksY) 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 (HasBlockWidth) hash ^= BlockWidth.GetHashCode();
|
|
if (HasBlockHeight) hash ^= BlockHeight.GetHashCode();
|
|
if (HasNumBlocksX) hash ^= NumBlocksX.GetHashCode();
|
|
if (HasNumBlocksY) hash ^= NumBlocksY.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 (HasBlockWidth) {
|
|
output.WriteRawTag(8);
|
|
output.WriteInt32(BlockWidth);
|
|
}
|
|
if (HasBlockHeight) {
|
|
output.WriteRawTag(16);
|
|
output.WriteInt32(BlockHeight);
|
|
}
|
|
if (HasNumBlocksX) {
|
|
output.WriteRawTag(24);
|
|
output.WriteInt32(NumBlocksX);
|
|
}
|
|
if (HasNumBlocksY) {
|
|
output.WriteRawTag(32);
|
|
output.WriteInt32(NumBlocksY);
|
|
}
|
|
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 (HasBlockWidth) {
|
|
output.WriteRawTag(8);
|
|
output.WriteInt32(BlockWidth);
|
|
}
|
|
if (HasBlockHeight) {
|
|
output.WriteRawTag(16);
|
|
output.WriteInt32(BlockHeight);
|
|
}
|
|
if (HasNumBlocksX) {
|
|
output.WriteRawTag(24);
|
|
output.WriteInt32(NumBlocksX);
|
|
}
|
|
if (HasNumBlocksY) {
|
|
output.WriteRawTag(32);
|
|
output.WriteInt32(NumBlocksY);
|
|
}
|
|
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 (HasBlockWidth) {
|
|
size += 1 + pb::CodedOutputStream.ComputeInt32Size(BlockWidth);
|
|
}
|
|
if (HasBlockHeight) {
|
|
size += 1 + pb::CodedOutputStream.ComputeInt32Size(BlockHeight);
|
|
}
|
|
if (HasNumBlocksX) {
|
|
size += 1 + pb::CodedOutputStream.ComputeInt32Size(NumBlocksX);
|
|
}
|
|
if (HasNumBlocksY) {
|
|
size += 1 + pb::CodedOutputStream.ComputeInt32Size(NumBlocksY);
|
|
}
|
|
if (_unknownFields != null) {
|
|
size += _unknownFields.CalculateSize();
|
|
}
|
|
return size;
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void MergeFrom(BlockDescriptor other) {
|
|
if (other == null) {
|
|
return;
|
|
}
|
|
if (other.HasBlockWidth) {
|
|
BlockWidth = other.BlockWidth;
|
|
}
|
|
if (other.HasBlockHeight) {
|
|
BlockHeight = other.BlockHeight;
|
|
}
|
|
if (other.HasNumBlocksX) {
|
|
NumBlocksX = other.NumBlocksX;
|
|
}
|
|
if (other.HasNumBlocksY) {
|
|
NumBlocksY = other.NumBlocksY;
|
|
}
|
|
_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: {
|
|
BlockWidth = input.ReadInt32();
|
|
break;
|
|
}
|
|
case 16: {
|
|
BlockHeight = input.ReadInt32();
|
|
break;
|
|
}
|
|
case 24: {
|
|
NumBlocksX = input.ReadInt32();
|
|
break;
|
|
}
|
|
case 32: {
|
|
NumBlocksY = input.ReadInt32();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
#if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
|
|
uint tag;
|
|
while ((tag = input.ReadTag()) != 0) {
|
|
switch(tag) {
|
|
default:
|
|
_unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
|
|
break;
|
|
case 8: {
|
|
BlockWidth = input.ReadInt32();
|
|
break;
|
|
}
|
|
case 16: {
|
|
BlockHeight = input.ReadInt32();
|
|
break;
|
|
}
|
|
case 24: {
|
|
NumBlocksX = input.ReadInt32();
|
|
break;
|
|
}
|
|
case 32: {
|
|
NumBlocksY = input.ReadInt32();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
}
|
|
|
|
}
|
|
#endregion
|
|
|
|
}
|
|
|
|
/// <summary>
|
|
/// Encapsulates a list of features with associated flow.
|
|
/// Can be extracted from RegionFlow via GetRegionFlowFeatureList
|
|
/// declared in region_flow.h. This is the essential (additional) information
|
|
/// required by Cropper using wobble_suppression with displacements.
|
|
/// Next tag: 14
|
|
/// </summary>
|
|
public sealed partial class RegionFlowFeatureList : pb::IMessage<RegionFlowFeatureList>
|
|
#if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
|
|
, pb::IBufferMessage
|
|
#endif
|
|
{
|
|
private static readonly pb::MessageParser<RegionFlowFeatureList> _parser = new pb::MessageParser<RegionFlowFeatureList>(() => new RegionFlowFeatureList());
|
|
private pb::UnknownFieldSet _unknownFields;
|
|
private int _hasBits0;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public static pb::MessageParser<RegionFlowFeatureList> Parser { get { return _parser; } }
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public static pbr::MessageDescriptor Descriptor {
|
|
get { return global::Mediapipe.RegionFlowReflection.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 RegionFlowFeatureList() {
|
|
OnConstruction();
|
|
}
|
|
|
|
partial void OnConstruction();
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public RegionFlowFeatureList(RegionFlowFeatureList other) : this() {
|
|
_hasBits0 = other._hasBits0;
|
|
feature_ = other.feature_.Clone();
|
|
frameWidth_ = other.frameWidth_;
|
|
frameHeight_ = other.frameHeight_;
|
|
unstable_ = other.unstable_;
|
|
distanceFromBorder_ = other.distanceFromBorder_;
|
|
blurScore_ = other.blurScore_;
|
|
longTracks_ = other.longTracks_;
|
|
fracLongFeaturesRejected_ = other.fracLongFeaturesRejected_;
|
|
visualConsistency_ = other.visualConsistency_;
|
|
timestampUsec_ = other.timestampUsec_;
|
|
matchFrame_ = other.matchFrame_;
|
|
isDuplicated_ = other.isDuplicated_;
|
|
activelyDiscardedTrackedIds_ = other.activelyDiscardedTrackedIds_.Clone();
|
|
_unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public RegionFlowFeatureList Clone() {
|
|
return new RegionFlowFeatureList(this);
|
|
}
|
|
|
|
/// <summary>Field number for the "feature" field.</summary>
|
|
public const int FeatureFieldNumber = 1;
|
|
private static readonly pb::FieldCodec<global::Mediapipe.RegionFlowFeature> _repeated_feature_codec
|
|
= pb::FieldCodec.ForMessage(10, global::Mediapipe.RegionFlowFeature.Parser);
|
|
private readonly pbc::RepeatedField<global::Mediapipe.RegionFlowFeature> feature_ = new pbc::RepeatedField<global::Mediapipe.RegionFlowFeature>();
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public pbc::RepeatedField<global::Mediapipe.RegionFlowFeature> Feature {
|
|
get { return feature_; }
|
|
}
|
|
|
|
/// <summary>Field number for the "frame_width" field.</summary>
|
|
public const int FrameWidthFieldNumber = 2;
|
|
private readonly static int FrameWidthDefaultValue = 0;
|
|
|
|
private int frameWidth_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public int FrameWidth {
|
|
get { if ((_hasBits0 & 1) != 0) { return frameWidth_; } else { return FrameWidthDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 1;
|
|
frameWidth_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "frame_width" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasFrameWidth {
|
|
get { return (_hasBits0 & 1) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "frame_width" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearFrameWidth() {
|
|
_hasBits0 &= ~1;
|
|
}
|
|
|
|
/// <summary>Field number for the "frame_height" field.</summary>
|
|
public const int FrameHeightFieldNumber = 3;
|
|
private readonly static int FrameHeightDefaultValue = 0;
|
|
|
|
private int frameHeight_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public int FrameHeight {
|
|
get { if ((_hasBits0 & 2) != 0) { return frameHeight_; } else { return FrameHeightDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 2;
|
|
frameHeight_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "frame_height" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasFrameHeight {
|
|
get { return (_hasBits0 & 2) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "frame_height" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearFrameHeight() {
|
|
_hasBits0 &= ~2;
|
|
}
|
|
|
|
/// <summary>Field number for the "unstable" field.</summary>
|
|
public const int UnstableFieldNumber = 4;
|
|
private readonly static bool UnstableDefaultValue = false;
|
|
|
|
private bool unstable_;
|
|
/// <summary>
|
|
/// Set from corresponding RegionFlowFrame field.
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool Unstable {
|
|
get { if ((_hasBits0 & 4) != 0) { return unstable_; } else { return UnstableDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 4;
|
|
unstable_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "unstable" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasUnstable {
|
|
get { return (_hasBits0 & 4) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "unstable" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearUnstable() {
|
|
_hasBits0 &= ~4;
|
|
}
|
|
|
|
/// <summary>Field number for the "distance_from_border" field.</summary>
|
|
public const int DistanceFromBorderFieldNumber = 5;
|
|
private readonly static int DistanceFromBorderDefaultValue = 0;
|
|
|
|
private int distanceFromBorder_;
|
|
/// <summary>
|
|
/// Records the minimum distance from the image border for each feature and
|
|
/// matching feature (if enforced > 0).
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public int DistanceFromBorder {
|
|
get { if ((_hasBits0 & 8) != 0) { return distanceFromBorder_; } else { return DistanceFromBorderDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 8;
|
|
distanceFromBorder_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "distance_from_border" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasDistanceFromBorder {
|
|
get { return (_hasBits0 & 8) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "distance_from_border" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearDistanceFromBorder() {
|
|
_hasBits0 &= ~8;
|
|
}
|
|
|
|
/// <summary>Field number for the "blur_score" field.</summary>
|
|
public const int BlurScoreFieldNumber = 6;
|
|
private readonly static float BlurScoreDefaultValue = 0F;
|
|
|
|
private float blurScore_;
|
|
/// <summary>
|
|
/// Set from corresponding RegionFlowFrame field.
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public float BlurScore {
|
|
get { if ((_hasBits0 & 16) != 0) { return blurScore_; } else { return BlurScoreDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 16;
|
|
blurScore_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "blur_score" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasBlurScore {
|
|
get { return (_hasBits0 & 16) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "blur_score" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearBlurScore() {
|
|
_hasBits0 &= ~16;
|
|
}
|
|
|
|
/// <summary>Field number for the "long_tracks" field.</summary>
|
|
public const int LongTracksFieldNumber = 7;
|
|
private readonly static bool LongTracksDefaultValue = false;
|
|
|
|
private bool longTracks_;
|
|
/// <summary>
|
|
/// If set, indicates, that features represent long tracks, i.e. each feature
|
|
/// has a valid track_id() >= 0.
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool LongTracks {
|
|
get { if ((_hasBits0 & 32) != 0) { return longTracks_; } else { return LongTracksDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 32;
|
|
longTracks_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "long_tracks" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasLongTracks {
|
|
get { return (_hasBits0 & 32) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "long_tracks" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearLongTracks() {
|
|
_hasBits0 &= ~32;
|
|
}
|
|
|
|
/// <summary>Field number for the "frac_long_features_rejected" field.</summary>
|
|
public const int FracLongFeaturesRejectedFieldNumber = 8;
|
|
private readonly static float FracLongFeaturesRejectedDefaultValue = 0F;
|
|
|
|
private float fracLongFeaturesRejected_;
|
|
/// <summary>
|
|
/// If long_tracks, stores number of long feature tracks that got rejected in
|
|
/// this frame, as their patches were deemed inconsistent with the track's very
|
|
/// first extracted patch.
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public float FracLongFeaturesRejected {
|
|
get { if ((_hasBits0 & 64) != 0) { return fracLongFeaturesRejected_; } else { return FracLongFeaturesRejectedDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 64;
|
|
fracLongFeaturesRejected_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "frac_long_features_rejected" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasFracLongFeaturesRejected {
|
|
get { return (_hasBits0 & 64) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "frac_long_features_rejected" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearFracLongFeaturesRejected() {
|
|
_hasBits0 &= ~64;
|
|
}
|
|
|
|
/// <summary>Field number for the "visual_consistency" field.</summary>
|
|
public const int VisualConsistencyFieldNumber = 9;
|
|
private readonly static float VisualConsistencyDefaultValue = -1F;
|
|
|
|
private float visualConsistency_;
|
|
/// <summary>
|
|
/// Measures visual consistency between adjacent frames. In particular, stores
|
|
/// the absolute *change* in visual difference between two adjancent frame
|
|
/// pairs, i.e. the modulus of the 2nd derivative of the frame appearance.
|
|
/// Normalized w.r.t. number of channels and total pixels of the underlying
|
|
/// frame.
|
|
/// In particular for sudden changes (e.g. shot boundaries) this value will
|
|
/// be significantly non-zero (> 0.05).
|
|
/// Negative value per default indicates no consistency has been computed.
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public float VisualConsistency {
|
|
get { if ((_hasBits0 & 128) != 0) { return visualConsistency_; } else { return VisualConsistencyDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 128;
|
|
visualConsistency_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "visual_consistency" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasVisualConsistency {
|
|
get { return (_hasBits0 & 128) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "visual_consistency" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearVisualConsistency() {
|
|
_hasBits0 &= ~128;
|
|
}
|
|
|
|
/// <summary>Field number for the "timestamp_usec" field.</summary>
|
|
public const int TimestampUsecFieldNumber = 10;
|
|
private readonly static long TimestampUsecDefaultValue = 0L;
|
|
|
|
private long timestampUsec_;
|
|
/// <summary>
|
|
/// Timestamp in micro seconds of the underlying frame, that is the frame
|
|
/// for which the source features (not matching features) were computed.
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public long TimestampUsec {
|
|
get { if ((_hasBits0 & 256) != 0) { return timestampUsec_; } else { return TimestampUsecDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 256;
|
|
timestampUsec_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "timestamp_usec" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasTimestampUsec {
|
|
get { return (_hasBits0 & 256) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "timestamp_usec" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearTimestampUsec() {
|
|
_hasBits0 &= ~256;
|
|
}
|
|
|
|
/// <summary>Field number for the "match_frame" field.</summary>
|
|
public const int MatchFrameFieldNumber = 11;
|
|
private readonly static int MatchFrameDefaultValue = 0;
|
|
|
|
private int matchFrame_;
|
|
/// <summary>
|
|
/// Denotes the frame that flow was computed w.r.t. to, locally to the current
|
|
/// frame. For example, if current frame is N, N + match_frame is the matching
|
|
/// frame that flow was computed to.
|
|
/// Values < 0 indicate backward tracking, while values > 0 indicate forward
|
|
/// tracking. By default, for empty feature lists, matching frame is the
|
|
/// same as current frame, i.e. match_frame = 0.
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public int MatchFrame {
|
|
get { if ((_hasBits0 & 512) != 0) { return matchFrame_; } else { return MatchFrameDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 512;
|
|
matchFrame_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "match_frame" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasMatchFrame {
|
|
get { return (_hasBits0 & 512) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "match_frame" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearMatchFrame() {
|
|
_hasBits0 &= ~512;
|
|
}
|
|
|
|
/// <summary>Field number for the "is_duplicated" field.</summary>
|
|
public const int IsDuplicatedFieldNumber = 12;
|
|
private readonly static bool IsDuplicatedDefaultValue = false;
|
|
|
|
private bool isDuplicated_;
|
|
/// <summary>
|
|
/// Set, if frame is estimated to be an exact duplicate of the previous frame.
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool IsDuplicated {
|
|
get { if ((_hasBits0 & 1024) != 0) { return isDuplicated_; } else { return IsDuplicatedDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 1024;
|
|
isDuplicated_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "is_duplicated" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasIsDuplicated {
|
|
get { return (_hasBits0 & 1024) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "is_duplicated" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearIsDuplicated() {
|
|
_hasBits0 &= ~1024;
|
|
}
|
|
|
|
/// <summary>Field number for the "actively_discarded_tracked_ids" field.</summary>
|
|
public const int ActivelyDiscardedTrackedIdsFieldNumber = 13;
|
|
private static readonly pb::FieldCodec<int> _repeated_activelyDiscardedTrackedIds_codec
|
|
= pb::FieldCodec.ForInt32(104);
|
|
private readonly pbc::RepeatedField<int> activelyDiscardedTrackedIds_ = new pbc::RepeatedField<int>();
|
|
/// <summary>
|
|
/// Stores all the tracked ids that have been discarded actively in this frame.
|
|
/// This information will be popluated via RegionFlowFeatureList, so that the
|
|
/// downstreaming modules can receive it and use it to avoid misjudgement on
|
|
/// tracking continuity.
|
|
/// Discard reason:
|
|
/// (1) A tracked feature has too long track, which might create drift.
|
|
/// (2) A tracked feature in a highly densed area, which provides little value.
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public pbc::RepeatedField<int> ActivelyDiscardedTrackedIds {
|
|
get { return activelyDiscardedTrackedIds_; }
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public override bool Equals(object other) {
|
|
return Equals(other as RegionFlowFeatureList);
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool Equals(RegionFlowFeatureList other) {
|
|
if (ReferenceEquals(other, null)) {
|
|
return false;
|
|
}
|
|
if (ReferenceEquals(other, this)) {
|
|
return true;
|
|
}
|
|
if(!feature_.Equals(other.feature_)) return false;
|
|
if (FrameWidth != other.FrameWidth) return false;
|
|
if (FrameHeight != other.FrameHeight) return false;
|
|
if (Unstable != other.Unstable) return false;
|
|
if (DistanceFromBorder != other.DistanceFromBorder) return false;
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(BlurScore, other.BlurScore)) return false;
|
|
if (LongTracks != other.LongTracks) return false;
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(FracLongFeaturesRejected, other.FracLongFeaturesRejected)) return false;
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(VisualConsistency, other.VisualConsistency)) return false;
|
|
if (TimestampUsec != other.TimestampUsec) return false;
|
|
if (MatchFrame != other.MatchFrame) return false;
|
|
if (IsDuplicated != other.IsDuplicated) return false;
|
|
if(!activelyDiscardedTrackedIds_.Equals(other.activelyDiscardedTrackedIds_)) 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 ^= feature_.GetHashCode();
|
|
if (HasFrameWidth) hash ^= FrameWidth.GetHashCode();
|
|
if (HasFrameHeight) hash ^= FrameHeight.GetHashCode();
|
|
if (HasUnstable) hash ^= Unstable.GetHashCode();
|
|
if (HasDistanceFromBorder) hash ^= DistanceFromBorder.GetHashCode();
|
|
if (HasBlurScore) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(BlurScore);
|
|
if (HasLongTracks) hash ^= LongTracks.GetHashCode();
|
|
if (HasFracLongFeaturesRejected) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(FracLongFeaturesRejected);
|
|
if (HasVisualConsistency) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(VisualConsistency);
|
|
if (HasTimestampUsec) hash ^= TimestampUsec.GetHashCode();
|
|
if (HasMatchFrame) hash ^= MatchFrame.GetHashCode();
|
|
if (HasIsDuplicated) hash ^= IsDuplicated.GetHashCode();
|
|
hash ^= activelyDiscardedTrackedIds_.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
|
|
feature_.WriteTo(output, _repeated_feature_codec);
|
|
if (HasFrameWidth) {
|
|
output.WriteRawTag(16);
|
|
output.WriteInt32(FrameWidth);
|
|
}
|
|
if (HasFrameHeight) {
|
|
output.WriteRawTag(24);
|
|
output.WriteInt32(FrameHeight);
|
|
}
|
|
if (HasUnstable) {
|
|
output.WriteRawTag(32);
|
|
output.WriteBool(Unstable);
|
|
}
|
|
if (HasDistanceFromBorder) {
|
|
output.WriteRawTag(40);
|
|
output.WriteInt32(DistanceFromBorder);
|
|
}
|
|
if (HasBlurScore) {
|
|
output.WriteRawTag(53);
|
|
output.WriteFloat(BlurScore);
|
|
}
|
|
if (HasLongTracks) {
|
|
output.WriteRawTag(56);
|
|
output.WriteBool(LongTracks);
|
|
}
|
|
if (HasFracLongFeaturesRejected) {
|
|
output.WriteRawTag(69);
|
|
output.WriteFloat(FracLongFeaturesRejected);
|
|
}
|
|
if (HasVisualConsistency) {
|
|
output.WriteRawTag(77);
|
|
output.WriteFloat(VisualConsistency);
|
|
}
|
|
if (HasTimestampUsec) {
|
|
output.WriteRawTag(80);
|
|
output.WriteInt64(TimestampUsec);
|
|
}
|
|
if (HasMatchFrame) {
|
|
output.WriteRawTag(88);
|
|
output.WriteInt32(MatchFrame);
|
|
}
|
|
if (HasIsDuplicated) {
|
|
output.WriteRawTag(96);
|
|
output.WriteBool(IsDuplicated);
|
|
}
|
|
activelyDiscardedTrackedIds_.WriteTo(output, _repeated_activelyDiscardedTrackedIds_codec);
|
|
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) {
|
|
feature_.WriteTo(ref output, _repeated_feature_codec);
|
|
if (HasFrameWidth) {
|
|
output.WriteRawTag(16);
|
|
output.WriteInt32(FrameWidth);
|
|
}
|
|
if (HasFrameHeight) {
|
|
output.WriteRawTag(24);
|
|
output.WriteInt32(FrameHeight);
|
|
}
|
|
if (HasUnstable) {
|
|
output.WriteRawTag(32);
|
|
output.WriteBool(Unstable);
|
|
}
|
|
if (HasDistanceFromBorder) {
|
|
output.WriteRawTag(40);
|
|
output.WriteInt32(DistanceFromBorder);
|
|
}
|
|
if (HasBlurScore) {
|
|
output.WriteRawTag(53);
|
|
output.WriteFloat(BlurScore);
|
|
}
|
|
if (HasLongTracks) {
|
|
output.WriteRawTag(56);
|
|
output.WriteBool(LongTracks);
|
|
}
|
|
if (HasFracLongFeaturesRejected) {
|
|
output.WriteRawTag(69);
|
|
output.WriteFloat(FracLongFeaturesRejected);
|
|
}
|
|
if (HasVisualConsistency) {
|
|
output.WriteRawTag(77);
|
|
output.WriteFloat(VisualConsistency);
|
|
}
|
|
if (HasTimestampUsec) {
|
|
output.WriteRawTag(80);
|
|
output.WriteInt64(TimestampUsec);
|
|
}
|
|
if (HasMatchFrame) {
|
|
output.WriteRawTag(88);
|
|
output.WriteInt32(MatchFrame);
|
|
}
|
|
if (HasIsDuplicated) {
|
|
output.WriteRawTag(96);
|
|
output.WriteBool(IsDuplicated);
|
|
}
|
|
activelyDiscardedTrackedIds_.WriteTo(ref output, _repeated_activelyDiscardedTrackedIds_codec);
|
|
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 += feature_.CalculateSize(_repeated_feature_codec);
|
|
if (HasFrameWidth) {
|
|
size += 1 + pb::CodedOutputStream.ComputeInt32Size(FrameWidth);
|
|
}
|
|
if (HasFrameHeight) {
|
|
size += 1 + pb::CodedOutputStream.ComputeInt32Size(FrameHeight);
|
|
}
|
|
if (HasUnstable) {
|
|
size += 1 + 1;
|
|
}
|
|
if (HasDistanceFromBorder) {
|
|
size += 1 + pb::CodedOutputStream.ComputeInt32Size(DistanceFromBorder);
|
|
}
|
|
if (HasBlurScore) {
|
|
size += 1 + 4;
|
|
}
|
|
if (HasLongTracks) {
|
|
size += 1 + 1;
|
|
}
|
|
if (HasFracLongFeaturesRejected) {
|
|
size += 1 + 4;
|
|
}
|
|
if (HasVisualConsistency) {
|
|
size += 1 + 4;
|
|
}
|
|
if (HasTimestampUsec) {
|
|
size += 1 + pb::CodedOutputStream.ComputeInt64Size(TimestampUsec);
|
|
}
|
|
if (HasMatchFrame) {
|
|
size += 1 + pb::CodedOutputStream.ComputeInt32Size(MatchFrame);
|
|
}
|
|
if (HasIsDuplicated) {
|
|
size += 1 + 1;
|
|
}
|
|
size += activelyDiscardedTrackedIds_.CalculateSize(_repeated_activelyDiscardedTrackedIds_codec);
|
|
if (_unknownFields != null) {
|
|
size += _unknownFields.CalculateSize();
|
|
}
|
|
return size;
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void MergeFrom(RegionFlowFeatureList other) {
|
|
if (other == null) {
|
|
return;
|
|
}
|
|
feature_.Add(other.feature_);
|
|
if (other.HasFrameWidth) {
|
|
FrameWidth = other.FrameWidth;
|
|
}
|
|
if (other.HasFrameHeight) {
|
|
FrameHeight = other.FrameHeight;
|
|
}
|
|
if (other.HasUnstable) {
|
|
Unstable = other.Unstable;
|
|
}
|
|
if (other.HasDistanceFromBorder) {
|
|
DistanceFromBorder = other.DistanceFromBorder;
|
|
}
|
|
if (other.HasBlurScore) {
|
|
BlurScore = other.BlurScore;
|
|
}
|
|
if (other.HasLongTracks) {
|
|
LongTracks = other.LongTracks;
|
|
}
|
|
if (other.HasFracLongFeaturesRejected) {
|
|
FracLongFeaturesRejected = other.FracLongFeaturesRejected;
|
|
}
|
|
if (other.HasVisualConsistency) {
|
|
VisualConsistency = other.VisualConsistency;
|
|
}
|
|
if (other.HasTimestampUsec) {
|
|
TimestampUsec = other.TimestampUsec;
|
|
}
|
|
if (other.HasMatchFrame) {
|
|
MatchFrame = other.MatchFrame;
|
|
}
|
|
if (other.HasIsDuplicated) {
|
|
IsDuplicated = other.IsDuplicated;
|
|
}
|
|
activelyDiscardedTrackedIds_.Add(other.activelyDiscardedTrackedIds_);
|
|
_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: {
|
|
feature_.AddEntriesFrom(input, _repeated_feature_codec);
|
|
break;
|
|
}
|
|
case 16: {
|
|
FrameWidth = input.ReadInt32();
|
|
break;
|
|
}
|
|
case 24: {
|
|
FrameHeight = input.ReadInt32();
|
|
break;
|
|
}
|
|
case 32: {
|
|
Unstable = input.ReadBool();
|
|
break;
|
|
}
|
|
case 40: {
|
|
DistanceFromBorder = input.ReadInt32();
|
|
break;
|
|
}
|
|
case 53: {
|
|
BlurScore = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 56: {
|
|
LongTracks = input.ReadBool();
|
|
break;
|
|
}
|
|
case 69: {
|
|
FracLongFeaturesRejected = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 77: {
|
|
VisualConsistency = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 80: {
|
|
TimestampUsec = input.ReadInt64();
|
|
break;
|
|
}
|
|
case 88: {
|
|
MatchFrame = input.ReadInt32();
|
|
break;
|
|
}
|
|
case 96: {
|
|
IsDuplicated = input.ReadBool();
|
|
break;
|
|
}
|
|
case 106:
|
|
case 104: {
|
|
activelyDiscardedTrackedIds_.AddEntriesFrom(input, _repeated_activelyDiscardedTrackedIds_codec);
|
|
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: {
|
|
feature_.AddEntriesFrom(ref input, _repeated_feature_codec);
|
|
break;
|
|
}
|
|
case 16: {
|
|
FrameWidth = input.ReadInt32();
|
|
break;
|
|
}
|
|
case 24: {
|
|
FrameHeight = input.ReadInt32();
|
|
break;
|
|
}
|
|
case 32: {
|
|
Unstable = input.ReadBool();
|
|
break;
|
|
}
|
|
case 40: {
|
|
DistanceFromBorder = input.ReadInt32();
|
|
break;
|
|
}
|
|
case 53: {
|
|
BlurScore = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 56: {
|
|
LongTracks = input.ReadBool();
|
|
break;
|
|
}
|
|
case 69: {
|
|
FracLongFeaturesRejected = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 77: {
|
|
VisualConsistency = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 80: {
|
|
TimestampUsec = input.ReadInt64();
|
|
break;
|
|
}
|
|
case 88: {
|
|
MatchFrame = input.ReadInt32();
|
|
break;
|
|
}
|
|
case 96: {
|
|
IsDuplicated = input.ReadBool();
|
|
break;
|
|
}
|
|
case 106:
|
|
case 104: {
|
|
activelyDiscardedTrackedIds_.AddEntriesFrom(ref input, _repeated_activelyDiscardedTrackedIds_codec);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
}
|
|
|
|
/// <summary>
|
|
/// For TYPE_INCLUDE:
|
|
/// During retargeting and stabilization salient points introduce constraints
|
|
/// that will try to keep the normalized location in the rectangle
|
|
/// frame_size - normalized bounds.
|
|
/// For this soft constraints are used, therefore the weight specifies
|
|
/// how "important" the salient point is (higher is better).
|
|
/// In particular for each point p the retargeter introduces two pairs of
|
|
/// constraints of the form:
|
|
/// x - slack < width - right
|
|
/// and x + slack > 0 + left, with slack > 0
|
|
/// where the weight specifies the importance of the slack.
|
|
///
|
|
/// For TYPE_EXCLUDE_*:
|
|
/// Similar to above, but constraints are introduced to keep
|
|
/// the point to the left of the left bound OR the right of the right bound.
|
|
/// In particular:
|
|
/// x - slack < left OR
|
|
/// x + slack >= right
|
|
/// Similar to above, the weight specifies the importance of the slack.
|
|
///
|
|
/// Note: Choosing a too high weight can lead to
|
|
/// jerkiness as the stabilization essentially starts tracking the salient point.
|
|
/// </summary>
|
|
public sealed partial class SalientPoint : pb::IExtendableMessage<SalientPoint>
|
|
#if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
|
|
, pb::IBufferMessage
|
|
#endif
|
|
{
|
|
private static readonly pb::MessageParser<SalientPoint> _parser = new pb::MessageParser<SalientPoint>(() => new SalientPoint());
|
|
private pb::UnknownFieldSet _unknownFields;
|
|
private pb::ExtensionSet<SalientPoint> _extensions;
|
|
private pb::ExtensionSet<SalientPoint> _Extensions { get { return _extensions; } }
|
|
private int _hasBits0;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public static pb::MessageParser<SalientPoint> Parser { get { return _parser; } }
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public static pbr::MessageDescriptor Descriptor {
|
|
get { return global::Mediapipe.RegionFlowReflection.Descriptor.MessageTypes[6]; }
|
|
}
|
|
|
|
[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 SalientPoint() {
|
|
OnConstruction();
|
|
}
|
|
|
|
partial void OnConstruction();
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public SalientPoint(SalientPoint other) : this() {
|
|
_hasBits0 = other._hasBits0;
|
|
normPointX_ = other.normPointX_;
|
|
normPointY_ = other.normPointY_;
|
|
type_ = other.type_;
|
|
left_ = other.left_;
|
|
bottom_ = other.bottom_;
|
|
right_ = other.right_;
|
|
top_ = other.top_;
|
|
weight_ = other.weight_;
|
|
normMajor_ = other.normMajor_;
|
|
normMinor_ = other.normMinor_;
|
|
angle_ = other.angle_;
|
|
_unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
|
|
_extensions = pb::ExtensionSet.Clone(other._extensions);
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public SalientPoint Clone() {
|
|
return new SalientPoint(this);
|
|
}
|
|
|
|
/// <summary>Field number for the "norm_point_x" field.</summary>
|
|
public const int NormPointXFieldNumber = 1;
|
|
private readonly static float NormPointXDefaultValue = 0F;
|
|
|
|
private float normPointX_;
|
|
/// <summary>
|
|
/// Normalized location of the point (within domain [0, 1] x [0, 1].
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public float NormPointX {
|
|
get { if ((_hasBits0 & 1) != 0) { return normPointX_; } else { return NormPointXDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 1;
|
|
normPointX_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "norm_point_x" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasNormPointX {
|
|
get { return (_hasBits0 & 1) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "norm_point_x" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearNormPointX() {
|
|
_hasBits0 &= ~1;
|
|
}
|
|
|
|
/// <summary>Field number for the "norm_point_y" field.</summary>
|
|
public const int NormPointYFieldNumber = 2;
|
|
private readonly static float NormPointYDefaultValue = 0F;
|
|
|
|
private float normPointY_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public float NormPointY {
|
|
get { if ((_hasBits0 & 2) != 0) { return normPointY_; } else { return NormPointYDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 2;
|
|
normPointY_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "norm_point_y" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasNormPointY {
|
|
get { return (_hasBits0 & 2) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "norm_point_y" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearNormPointY() {
|
|
_hasBits0 &= ~2;
|
|
}
|
|
|
|
/// <summary>Field number for the "type" field.</summary>
|
|
public const int TypeFieldNumber = 11;
|
|
private readonly static global::Mediapipe.SalientPoint.Types.SalientPointType TypeDefaultValue = global::Mediapipe.SalientPoint.Types.SalientPointType.TypeInclude;
|
|
|
|
private global::Mediapipe.SalientPoint.Types.SalientPointType type_;
|
|
/// <summary>
|
|
/// Salient point type. By default we try to frame the salient point within
|
|
/// the bounding box specified by left, bottom, right, top. Alternatively, one
|
|
/// can choose to exclude the point. For details, see discussion above.
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public global::Mediapipe.SalientPoint.Types.SalientPointType Type {
|
|
get { if ((_hasBits0 & 1024) != 0) { return type_; } else { return TypeDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 1024;
|
|
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 & 1024) != 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 &= ~1024;
|
|
}
|
|
|
|
/// <summary>Field number for the "left" field.</summary>
|
|
public const int LeftFieldNumber = 3;
|
|
private readonly static float LeftDefaultValue = 0.3F;
|
|
|
|
private float left_;
|
|
/// <summary>
|
|
/// Bounds are specified in normalized coordinates [0, 1], FROM the specified
|
|
/// border. Opposing bounds (e.g. left and right) may not add to values
|
|
/// larger than 1.
|
|
/// Default bounds center salient point within centering third of the frame.
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public float Left {
|
|
get { if ((_hasBits0 & 4) != 0) { return left_; } else { return LeftDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 4;
|
|
left_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "left" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasLeft {
|
|
get { return (_hasBits0 & 4) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "left" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearLeft() {
|
|
_hasBits0 &= ~4;
|
|
}
|
|
|
|
/// <summary>Field number for the "bottom" field.</summary>
|
|
public const int BottomFieldNumber = 4;
|
|
private readonly static float BottomDefaultValue = 0.3F;
|
|
|
|
private float bottom_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public float Bottom {
|
|
get { if ((_hasBits0 & 8) != 0) { return bottom_; } else { return BottomDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 8;
|
|
bottom_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "bottom" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasBottom {
|
|
get { return (_hasBits0 & 8) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "bottom" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearBottom() {
|
|
_hasBits0 &= ~8;
|
|
}
|
|
|
|
/// <summary>Field number for the "right" field.</summary>
|
|
public const int RightFieldNumber = 9;
|
|
private readonly static float RightDefaultValue = 0.3F;
|
|
|
|
private float right_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public float Right {
|
|
get { if ((_hasBits0 & 256) != 0) { return right_; } else { return RightDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 256;
|
|
right_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "right" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasRight {
|
|
get { return (_hasBits0 & 256) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "right" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearRight() {
|
|
_hasBits0 &= ~256;
|
|
}
|
|
|
|
/// <summary>Field number for the "top" field.</summary>
|
|
public const int TopFieldNumber = 10;
|
|
private readonly static float TopDefaultValue = 0.3F;
|
|
|
|
private float top_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public float Top {
|
|
get { if ((_hasBits0 & 512) != 0) { return top_; } else { return TopDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 512;
|
|
top_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "top" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasTop {
|
|
get { return (_hasBits0 & 512) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "top" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearTop() {
|
|
_hasBits0 &= ~512;
|
|
}
|
|
|
|
/// <summary>Field number for the "weight" field.</summary>
|
|
public const int WeightFieldNumber = 5;
|
|
private readonly static float WeightDefaultValue = 15F;
|
|
|
|
private float weight_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public float Weight {
|
|
get { if ((_hasBits0 & 16) != 0) { return weight_; } else { return WeightDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 16;
|
|
weight_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "weight" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasWeight {
|
|
get { return (_hasBits0 & 16) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "weight" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearWeight() {
|
|
_hasBits0 &= ~16;
|
|
}
|
|
|
|
/// <summary>Field number for the "norm_major" field.</summary>
|
|
public const int NormMajorFieldNumber = 6;
|
|
private readonly static float NormMajorDefaultValue = 0F;
|
|
|
|
private float normMajor_;
|
|
/// <summary>
|
|
/// In addition salient point can represent a region of interest (defined as
|
|
/// ellipse of size norm_major x norm_minor (normalized to [0, 1] domain)
|
|
/// which orientation is given by angle (in radians in [0, pi]).
|
|
/// Due to aspect ratio change of the normalized domain, it is recommended that
|
|
/// transformations to other domains are done via the ScaleSalientPoint
|
|
/// function.
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public float NormMajor {
|
|
get { if ((_hasBits0 & 32) != 0) { return normMajor_; } else { return NormMajorDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 32;
|
|
normMajor_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "norm_major" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasNormMajor {
|
|
get { return (_hasBits0 & 32) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "norm_major" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearNormMajor() {
|
|
_hasBits0 &= ~32;
|
|
}
|
|
|
|
/// <summary>Field number for the "norm_minor" field.</summary>
|
|
public const int NormMinorFieldNumber = 7;
|
|
private readonly static float NormMinorDefaultValue = 0F;
|
|
|
|
private float normMinor_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public float NormMinor {
|
|
get { if ((_hasBits0 & 64) != 0) { return normMinor_; } else { return NormMinorDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 64;
|
|
normMinor_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "norm_minor" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasNormMinor {
|
|
get { return (_hasBits0 & 64) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "norm_minor" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearNormMinor() {
|
|
_hasBits0 &= ~64;
|
|
}
|
|
|
|
/// <summary>Field number for the "angle" field.</summary>
|
|
public const int AngleFieldNumber = 8;
|
|
private readonly static float AngleDefaultValue = 0F;
|
|
|
|
private float angle_;
|
|
/// <summary>
|
|
/// Angle of major axis with x-axis (counter-clock wise, in radians).
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public float Angle {
|
|
get { if ((_hasBits0 & 128) != 0) { return angle_; } else { return AngleDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 128;
|
|
angle_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "angle" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasAngle {
|
|
get { return (_hasBits0 & 128) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "angle" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearAngle() {
|
|
_hasBits0 &= ~128;
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public override bool Equals(object other) {
|
|
return Equals(other as SalientPoint);
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool Equals(SalientPoint other) {
|
|
if (ReferenceEquals(other, null)) {
|
|
return false;
|
|
}
|
|
if (ReferenceEquals(other, this)) {
|
|
return true;
|
|
}
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(NormPointX, other.NormPointX)) return false;
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(NormPointY, other.NormPointY)) return false;
|
|
if (Type != other.Type) return false;
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(Left, other.Left)) return false;
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(Bottom, other.Bottom)) return false;
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(Right, other.Right)) return false;
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(Top, other.Top)) return false;
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(Weight, other.Weight)) return false;
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(NormMajor, other.NormMajor)) return false;
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(NormMinor, other.NormMinor)) return false;
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(Angle, other.Angle)) return false;
|
|
if (!Equals(_extensions, other._extensions)) {
|
|
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 (HasNormPointX) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(NormPointX);
|
|
if (HasNormPointY) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(NormPointY);
|
|
if (HasType) hash ^= Type.GetHashCode();
|
|
if (HasLeft) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(Left);
|
|
if (HasBottom) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(Bottom);
|
|
if (HasRight) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(Right);
|
|
if (HasTop) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(Top);
|
|
if (HasWeight) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(Weight);
|
|
if (HasNormMajor) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(NormMajor);
|
|
if (HasNormMinor) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(NormMinor);
|
|
if (HasAngle) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(Angle);
|
|
if (_extensions != null) {
|
|
hash ^= _extensions.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 (HasNormPointX) {
|
|
output.WriteRawTag(13);
|
|
output.WriteFloat(NormPointX);
|
|
}
|
|
if (HasNormPointY) {
|
|
output.WriteRawTag(21);
|
|
output.WriteFloat(NormPointY);
|
|
}
|
|
if (HasLeft) {
|
|
output.WriteRawTag(29);
|
|
output.WriteFloat(Left);
|
|
}
|
|
if (HasBottom) {
|
|
output.WriteRawTag(37);
|
|
output.WriteFloat(Bottom);
|
|
}
|
|
if (HasWeight) {
|
|
output.WriteRawTag(45);
|
|
output.WriteFloat(Weight);
|
|
}
|
|
if (HasNormMajor) {
|
|
output.WriteRawTag(53);
|
|
output.WriteFloat(NormMajor);
|
|
}
|
|
if (HasNormMinor) {
|
|
output.WriteRawTag(61);
|
|
output.WriteFloat(NormMinor);
|
|
}
|
|
if (HasAngle) {
|
|
output.WriteRawTag(69);
|
|
output.WriteFloat(Angle);
|
|
}
|
|
if (HasRight) {
|
|
output.WriteRawTag(77);
|
|
output.WriteFloat(Right);
|
|
}
|
|
if (HasTop) {
|
|
output.WriteRawTag(85);
|
|
output.WriteFloat(Top);
|
|
}
|
|
if (HasType) {
|
|
output.WriteRawTag(88);
|
|
output.WriteEnum((int) Type);
|
|
}
|
|
if (_extensions != null) {
|
|
_extensions.WriteTo(output);
|
|
}
|
|
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 (HasNormPointX) {
|
|
output.WriteRawTag(13);
|
|
output.WriteFloat(NormPointX);
|
|
}
|
|
if (HasNormPointY) {
|
|
output.WriteRawTag(21);
|
|
output.WriteFloat(NormPointY);
|
|
}
|
|
if (HasLeft) {
|
|
output.WriteRawTag(29);
|
|
output.WriteFloat(Left);
|
|
}
|
|
if (HasBottom) {
|
|
output.WriteRawTag(37);
|
|
output.WriteFloat(Bottom);
|
|
}
|
|
if (HasWeight) {
|
|
output.WriteRawTag(45);
|
|
output.WriteFloat(Weight);
|
|
}
|
|
if (HasNormMajor) {
|
|
output.WriteRawTag(53);
|
|
output.WriteFloat(NormMajor);
|
|
}
|
|
if (HasNormMinor) {
|
|
output.WriteRawTag(61);
|
|
output.WriteFloat(NormMinor);
|
|
}
|
|
if (HasAngle) {
|
|
output.WriteRawTag(69);
|
|
output.WriteFloat(Angle);
|
|
}
|
|
if (HasRight) {
|
|
output.WriteRawTag(77);
|
|
output.WriteFloat(Right);
|
|
}
|
|
if (HasTop) {
|
|
output.WriteRawTag(85);
|
|
output.WriteFloat(Top);
|
|
}
|
|
if (HasType) {
|
|
output.WriteRawTag(88);
|
|
output.WriteEnum((int) Type);
|
|
}
|
|
if (_extensions != null) {
|
|
_extensions.WriteTo(ref output);
|
|
}
|
|
if (_unknownFields != null) {
|
|
_unknownFields.WriteTo(ref output);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public int CalculateSize() {
|
|
int size = 0;
|
|
if (HasNormPointX) {
|
|
size += 1 + 4;
|
|
}
|
|
if (HasNormPointY) {
|
|
size += 1 + 4;
|
|
}
|
|
if (HasType) {
|
|
size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) Type);
|
|
}
|
|
if (HasLeft) {
|
|
size += 1 + 4;
|
|
}
|
|
if (HasBottom) {
|
|
size += 1 + 4;
|
|
}
|
|
if (HasRight) {
|
|
size += 1 + 4;
|
|
}
|
|
if (HasTop) {
|
|
size += 1 + 4;
|
|
}
|
|
if (HasWeight) {
|
|
size += 1 + 4;
|
|
}
|
|
if (HasNormMajor) {
|
|
size += 1 + 4;
|
|
}
|
|
if (HasNormMinor) {
|
|
size += 1 + 4;
|
|
}
|
|
if (HasAngle) {
|
|
size += 1 + 4;
|
|
}
|
|
if (_extensions != null) {
|
|
size += _extensions.CalculateSize();
|
|
}
|
|
if (_unknownFields != null) {
|
|
size += _unknownFields.CalculateSize();
|
|
}
|
|
return size;
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void MergeFrom(SalientPoint other) {
|
|
if (other == null) {
|
|
return;
|
|
}
|
|
if (other.HasNormPointX) {
|
|
NormPointX = other.NormPointX;
|
|
}
|
|
if (other.HasNormPointY) {
|
|
NormPointY = other.NormPointY;
|
|
}
|
|
if (other.HasType) {
|
|
Type = other.Type;
|
|
}
|
|
if (other.HasLeft) {
|
|
Left = other.Left;
|
|
}
|
|
if (other.HasBottom) {
|
|
Bottom = other.Bottom;
|
|
}
|
|
if (other.HasRight) {
|
|
Right = other.Right;
|
|
}
|
|
if (other.HasTop) {
|
|
Top = other.Top;
|
|
}
|
|
if (other.HasWeight) {
|
|
Weight = other.Weight;
|
|
}
|
|
if (other.HasNormMajor) {
|
|
NormMajor = other.NormMajor;
|
|
}
|
|
if (other.HasNormMinor) {
|
|
NormMinor = other.NormMinor;
|
|
}
|
|
if (other.HasAngle) {
|
|
Angle = other.Angle;
|
|
}
|
|
pb::ExtensionSet.MergeFrom(ref _extensions, other._extensions);
|
|
_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:
|
|
if (!pb::ExtensionSet.TryMergeFieldFrom(ref _extensions, input)) {
|
|
_unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
|
|
}
|
|
break;
|
|
case 13: {
|
|
NormPointX = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 21: {
|
|
NormPointY = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 29: {
|
|
Left = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 37: {
|
|
Bottom = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 45: {
|
|
Weight = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 53: {
|
|
NormMajor = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 61: {
|
|
NormMinor = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 69: {
|
|
Angle = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 77: {
|
|
Right = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 85: {
|
|
Top = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 88: {
|
|
Type = (global::Mediapipe.SalientPoint.Types.SalientPointType) input.ReadEnum();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
#if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
|
|
uint tag;
|
|
while ((tag = input.ReadTag()) != 0) {
|
|
switch(tag) {
|
|
default:
|
|
if (!pb::ExtensionSet.TryMergeFieldFrom(ref _extensions, ref input)) {
|
|
_unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
|
|
}
|
|
break;
|
|
case 13: {
|
|
NormPointX = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 21: {
|
|
NormPointY = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 29: {
|
|
Left = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 37: {
|
|
Bottom = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 45: {
|
|
Weight = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 53: {
|
|
NormMajor = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 61: {
|
|
NormMinor = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 69: {
|
|
Angle = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 77: {
|
|
Right = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 85: {
|
|
Top = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 88: {
|
|
Type = (global::Mediapipe.SalientPoint.Types.SalientPointType) input.ReadEnum();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
public TValue GetExtension<TValue>(pb::Extension<SalientPoint, TValue> extension) {
|
|
return pb::ExtensionSet.Get(ref _extensions, extension);
|
|
}
|
|
public pbc::RepeatedField<TValue> GetExtension<TValue>(pb::RepeatedExtension<SalientPoint, TValue> extension) {
|
|
return pb::ExtensionSet.Get(ref _extensions, extension);
|
|
}
|
|
public pbc::RepeatedField<TValue> GetOrInitializeExtension<TValue>(pb::RepeatedExtension<SalientPoint, TValue> extension) {
|
|
return pb::ExtensionSet.GetOrInitialize(ref _extensions, extension);
|
|
}
|
|
public void SetExtension<TValue>(pb::Extension<SalientPoint, TValue> extension, TValue value) {
|
|
pb::ExtensionSet.Set(ref _extensions, extension, value);
|
|
}
|
|
public bool HasExtension<TValue>(pb::Extension<SalientPoint, TValue> extension) {
|
|
return pb::ExtensionSet.Has(ref _extensions, extension);
|
|
}
|
|
public void ClearExtension<TValue>(pb::Extension<SalientPoint, TValue> extension) {
|
|
pb::ExtensionSet.Clear(ref _extensions, extension);
|
|
}
|
|
public void ClearExtension<TValue>(pb::RepeatedExtension<SalientPoint, TValue> extension) {
|
|
pb::ExtensionSet.Clear(ref _extensions, extension);
|
|
}
|
|
|
|
#region Nested types
|
|
/// <summary>Container for nested types declared in the SalientPoint message type.</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public static partial class Types {
|
|
public enum SalientPointType {
|
|
[pbr::OriginalName("TYPE_INCLUDE")] TypeInclude = 1,
|
|
[pbr::OriginalName("TYPE_EXCLUDE_LEFT")] TypeExcludeLeft = 2,
|
|
[pbr::OriginalName("TYPE_EXCLUDE_RIGHT")] TypeExcludeRight = 3,
|
|
}
|
|
|
|
}
|
|
#endregion
|
|
|
|
}
|
|
|
|
/// <summary>
|
|
/// Aggregates SalientPoint's for a frame.
|
|
/// </summary>
|
|
public sealed partial class SalientPointFrame : pb::IExtendableMessage<SalientPointFrame>
|
|
#if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
|
|
, pb::IBufferMessage
|
|
#endif
|
|
{
|
|
private static readonly pb::MessageParser<SalientPointFrame> _parser = new pb::MessageParser<SalientPointFrame>(() => new SalientPointFrame());
|
|
private pb::UnknownFieldSet _unknownFields;
|
|
private pb::ExtensionSet<SalientPointFrame> _extensions;
|
|
private pb::ExtensionSet<SalientPointFrame> _Extensions { get { return _extensions; } }
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public static pb::MessageParser<SalientPointFrame> Parser { get { return _parser; } }
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public static pbr::MessageDescriptor Descriptor {
|
|
get { return global::Mediapipe.RegionFlowReflection.Descriptor.MessageTypes[7]; }
|
|
}
|
|
|
|
[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 SalientPointFrame() {
|
|
OnConstruction();
|
|
}
|
|
|
|
partial void OnConstruction();
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public SalientPointFrame(SalientPointFrame other) : this() {
|
|
point_ = other.point_.Clone();
|
|
_unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
|
|
_extensions = pb::ExtensionSet.Clone(other._extensions);
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public SalientPointFrame Clone() {
|
|
return new SalientPointFrame(this);
|
|
}
|
|
|
|
/// <summary>Field number for the "point" field.</summary>
|
|
public const int PointFieldNumber = 1;
|
|
private static readonly pb::FieldCodec<global::Mediapipe.SalientPoint> _repeated_point_codec
|
|
= pb::FieldCodec.ForMessage(10, global::Mediapipe.SalientPoint.Parser);
|
|
private readonly pbc::RepeatedField<global::Mediapipe.SalientPoint> point_ = new pbc::RepeatedField<global::Mediapipe.SalientPoint>();
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public pbc::RepeatedField<global::Mediapipe.SalientPoint> Point {
|
|
get { return point_; }
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public override bool Equals(object other) {
|
|
return Equals(other as SalientPointFrame);
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool Equals(SalientPointFrame other) {
|
|
if (ReferenceEquals(other, null)) {
|
|
return false;
|
|
}
|
|
if (ReferenceEquals(other, this)) {
|
|
return true;
|
|
}
|
|
if(!point_.Equals(other.point_)) return false;
|
|
if (!Equals(_extensions, other._extensions)) {
|
|
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 ^= point_.GetHashCode();
|
|
if (_extensions != null) {
|
|
hash ^= _extensions.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
|
|
point_.WriteTo(output, _repeated_point_codec);
|
|
if (_extensions != null) {
|
|
_extensions.WriteTo(output);
|
|
}
|
|
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) {
|
|
point_.WriteTo(ref output, _repeated_point_codec);
|
|
if (_extensions != null) {
|
|
_extensions.WriteTo(ref output);
|
|
}
|
|
if (_unknownFields != null) {
|
|
_unknownFields.WriteTo(ref output);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public int CalculateSize() {
|
|
int size = 0;
|
|
size += point_.CalculateSize(_repeated_point_codec);
|
|
if (_extensions != null) {
|
|
size += _extensions.CalculateSize();
|
|
}
|
|
if (_unknownFields != null) {
|
|
size += _unknownFields.CalculateSize();
|
|
}
|
|
return size;
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void MergeFrom(SalientPointFrame other) {
|
|
if (other == null) {
|
|
return;
|
|
}
|
|
point_.Add(other.point_);
|
|
pb::ExtensionSet.MergeFrom(ref _extensions, other._extensions);
|
|
_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:
|
|
if (!pb::ExtensionSet.TryMergeFieldFrom(ref _extensions, input)) {
|
|
_unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
|
|
}
|
|
break;
|
|
case 10: {
|
|
point_.AddEntriesFrom(input, _repeated_point_codec);
|
|
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:
|
|
if (!pb::ExtensionSet.TryMergeFieldFrom(ref _extensions, ref input)) {
|
|
_unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
|
|
}
|
|
break;
|
|
case 10: {
|
|
point_.AddEntriesFrom(ref input, _repeated_point_codec);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
public TValue GetExtension<TValue>(pb::Extension<SalientPointFrame, TValue> extension) {
|
|
return pb::ExtensionSet.Get(ref _extensions, extension);
|
|
}
|
|
public pbc::RepeatedField<TValue> GetExtension<TValue>(pb::RepeatedExtension<SalientPointFrame, TValue> extension) {
|
|
return pb::ExtensionSet.Get(ref _extensions, extension);
|
|
}
|
|
public pbc::RepeatedField<TValue> GetOrInitializeExtension<TValue>(pb::RepeatedExtension<SalientPointFrame, TValue> extension) {
|
|
return pb::ExtensionSet.GetOrInitialize(ref _extensions, extension);
|
|
}
|
|
public void SetExtension<TValue>(pb::Extension<SalientPointFrame, TValue> extension, TValue value) {
|
|
pb::ExtensionSet.Set(ref _extensions, extension, value);
|
|
}
|
|
public bool HasExtension<TValue>(pb::Extension<SalientPointFrame, TValue> extension) {
|
|
return pb::ExtensionSet.Has(ref _extensions, extension);
|
|
}
|
|
public void ClearExtension<TValue>(pb::Extension<SalientPointFrame, TValue> extension) {
|
|
pb::ExtensionSet.Clear(ref _extensions, extension);
|
|
}
|
|
public void ClearExtension<TValue>(pb::RepeatedExtension<SalientPointFrame, TValue> extension) {
|
|
pb::ExtensionSet.Clear(ref _extensions, extension);
|
|
}
|
|
|
|
}
|
|
|
|
#endregion
|
|
|
|
}
|
|
|
|
#endregion Designer generated code
|