6211 lines
251 KiB
C#
6211 lines
251 KiB
C#
// <auto-generated>
|
|
// Generated by the protocol buffer compiler. DO NOT EDIT!
|
|
// source: mediapipe/util/tracking/tracking.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/tracking.proto</summary>
|
|
public static partial class TrackingReflection {
|
|
|
|
#region Descriptor
|
|
/// <summary>File descriptor for mediapipe/util/tracking/tracking.proto</summary>
|
|
public static pbr::FileDescriptor Descriptor {
|
|
get { return descriptor; }
|
|
}
|
|
private static pbr::FileDescriptor descriptor;
|
|
|
|
static TrackingReflection() {
|
|
byte[] descriptorData = global::System.Convert.FromBase64String(
|
|
string.Concat(
|
|
"CiZtZWRpYXBpcGUvdXRpbC90cmFja2luZy90cmFja2luZy5wcm90bxIJbWVk",
|
|
"aWFwaXBlGittZWRpYXBpcGUvdXRpbC90cmFja2luZy9tb3Rpb25fbW9kZWxz",
|
|
"LnByb3RvIuUICg5Nb3Rpb25Cb3hTdGF0ZRINCgVwb3NfeBgBIAEoAhINCgVw",
|
|
"b3NfeRgCIAEoAhINCgV3aWR0aBgDIAEoAhIOCgZoZWlnaHQYBCABKAISEAoF",
|
|
"c2NhbGUYBSABKAI6ATESEwoIcm90YXRpb24YHiABKAI6ATASLAoEcXVhZBgi",
|
|
"IAEoCzIeLm1lZGlhcGlwZS5Nb3Rpb25Cb3hTdGF0ZS5RdWFkEhQKDGFzcGVj",
|
|
"dF9yYXRpbxgjIAEoAhIfChByZXF1ZXN0X2dyb3VwaW5nGCUgASgIOgVmYWxz",
|
|
"ZRItCg5wbnBfaG9tb2dyYXBoeRgkIAEoCzIVLm1lZGlhcGlwZS5Ib21vZ3Jh",
|
|
"cGh5EgoKAmR4GAcgASgCEgoKAmR5GAggASgCEhYKDmtpbmV0aWNfZW5lcmd5",
|
|
"GBEgASgCEhQKDHByaW9yX3dlaWdodBgJIAEoAhJKCgx0cmFja19zdGF0dXMY",
|
|
"CiABKA4yJS5tZWRpYXBpcGUuTW90aW9uQm94U3RhdGUuVHJhY2tTdGF0dXM6",
|
|
"DUJPWF9VTlRSQUNLRUQSIwoXc3BhdGlhbF9wcmlvcl9ncmlkX3NpemUYCyAB",
|
|
"KAU6AjEwEhkKDXNwYXRpYWxfcHJpb3IYDCADKAJCAhABEh4KEnNwYXRpYWxf",
|
|
"Y29uZmlkZW5jZRgNIAMoAkICEAESEgoKcHJpb3JfZGlmZhgOIAEoAhIYChBt",
|
|
"b3Rpb25fZGlzcGFyaXR5GA8gASgCEiEKGWJhY2tncm91bmRfZGlzY3JpbWlu",
|
|
"YXRpb24YECABKAISFwoPaW5saWVyX2NlbnRlcl94GBIgASgCEhcKD2lubGll",
|
|
"cl9jZW50ZXJfeRgTIAEoAhISCgppbmxpZXJfc3VtGBggASgCEhQKDGlubGll",
|
|
"cl9yYXRpbxgZIAEoAhIUCgxpbmxpZXJfd2lkdGgYFiABKAISFQoNaW5saWVy",
|
|
"X2hlaWdodBgXIAEoAhIWCgppbmxpZXJfaWRzGBogAygNQgIQARIfChNpbmxp",
|
|
"ZXJfaWRfbWF0Y2hfcG9zGB8gAygNQgIQARIZCg1pbmxpZXJfbGVuZ3RoGBsg",
|
|
"AygNQgIQARIXCgtvdXRsaWVyX2lkcxgcIAMoDUICEAESIAoUb3V0bGllcl9p",
|
|
"ZF9tYXRjaF9wb3MYICADKA1CAhABEhsKE3RyYWNraW5nX2NvbmZpZGVuY2UY",
|
|
"ISABKAISMwoIaW50ZXJuYWwYHSABKAsyIS5tZWRpYXBpcGUuTW90aW9uQm94",
|
|
"SW50ZXJuYWxTdGF0ZRoYCgRRdWFkEhAKCHZlcnRpY2VzGAEgAygCIocBCgtU",
|
|
"cmFja1N0YXR1cxIRCg1CT1hfVU5UUkFDS0VEEAASDQoJQk9YX0VNUFRZEAES",
|
|
"EwoPQk9YX05PX0ZFQVRVUkVTEAISDwoLQk9YX1RSQUNLRUQQAxISCg5CT1hf",
|
|
"RFVQTElDQVRFRBAEEhwKGEJPWF9UUkFDS0VEX09VVF9PRl9CT1VORBAFSgQI",
|
|
"FBAVSgQIFRAWIrwBChZNb3Rpb25Cb3hJbnRlcm5hbFN0YXRlEhEKBXBvc194",
|
|
"GAEgAygCQgIQARIRCgVwb3NfeRgCIAMoAkICEAESDgoCZHgYAyADKAJCAhAB",
|
|
"Eg4KAmR5GAQgAygCQgIQARIVCgljYW1lcmFfZHgYBSADKAJCAhABEhUKCWNh",
|
|
"bWVyYV9keRgGIAMoAkICEAESFAoIdHJhY2tfaWQYByADKAVCAhABEhgKDGlu",
|
|
"bGllcl9zY29yZRgIIAMoAkICEAEinRMKEFRyYWNrU3RlcE9wdGlvbnMSYgoQ",
|
|
"dHJhY2tpbmdfZGVncmVlcxgcIAEoDjIrLm1lZGlhcGlwZS5UcmFja1N0ZXBP",
|
|
"cHRpb25zLlRyYWNraW5nRGVncmVlczobVFJBQ0tJTkdfREVHUkVFX1RSQU5T",
|
|
"TEFUSU9OEiYKF3RyYWNrX29iamVjdF9hbmRfY2FtZXJhGCAgASgIOgVmYWxz",
|
|
"ZRIaCg9pcmxzX2l0ZXJhdGlvbnMYASABKAU6ATUSGwoNc3BhdGlhbF9zaWdt",
|
|
"YRgCIAEoAjoEMC4xNRIfChBtaW5fbW90aW9uX3NpZ21hGAMgASgCOgUwLjAw",
|
|
"MhIiChVyZWxhdGl2ZV9tb3Rpb25fc2lnbWEYBCABKAI6AzAuMxIpChptb3Rp",
|
|
"b25fZGlzcGFyaXR5X2xvd19sZXZlbBgGIAEoAjoFMC4wMDgSKgobbW90aW9u",
|
|
"X2Rpc3Bhcml0eV9oaWdoX2xldmVsGAcgASgCOgUwLjAxNhIcCg9kaXNwYXJp",
|
|
"dHlfZGVjYXkYCCABKAI6AzAuOBIgChNtb3Rpb25fcHJpb3Jfd2VpZ2h0GAkg",
|
|
"ASgCOgMwLjISMgojYmFja2dyb3VuZF9kaXNjcmltaW5hdGlvbl9sb3dfbGV2",
|
|
"ZWwYCiABKAI6BTAuMDA0EjMKJGJhY2tncm91bmRfZGlzY3JpbWluYXRpb25f",
|
|
"aGlnaF9sZXZlbBgLIAEoAjoFMC4wMDgSLAofaW5saWVyX2NlbnRlcl9yZWxh",
|
|
"dGl2ZV9kaXN0YW5jZRgMIAEoAjoDMC4xEiAKE2lubGllcl9zcHJpbmdfZm9y",
|
|
"Y2UYDSABKAI6AzAuMxItCiBraW5ldGljX2NlbnRlcl9yZWxhdGl2ZV9kaXN0",
|
|
"YW5jZRgOIAEoAjoDMC40EiEKFGtpbmV0aWNfc3ByaW5nX2ZvcmNlGA8gASgC",
|
|
"OgMwLjUSNgona2luZXRpY19zcHJpbmdfZm9yY2VfbWluX2tpbmV0aWNfZW5l",
|
|
"cmd5GBUgASgCOgUwLjAwMxIjChZ2ZWxvY2l0eV91cGRhdGVfd2VpZ2h0GBAg",
|
|
"ASgCOgMwLjcSHgoSbWF4X3RyYWNrX2ZhaWx1cmVzGBEgASgFOgIxMBIcCg5l",
|
|
"eHBhbnNpb25fc2l6ZRgSIAEoAjoEMC4wNRIeChFpbmxpZXJfbG93X3dlaWdo",
|
|
"dBgTIAEoAjoDMjUwEh8KEmlubGllcl9oaWdoX3dlaWdodBgUIAEoAjoDNTAw",
|
|
"EiIKFGtpbmV0aWNfZW5lcmd5X2RlY2F5GBYgASgCOgQwLjk4EiIKFXByaW9y",
|
|
"X3dlaWdodF9pbmNyZWFzZRgXIAEoAjoDMC4yEiEKEmxvd19raW5ldGljX2Vu",
|
|
"ZXJneRgYIAEoAjoFMC4wMDESIgoTaGlnaF9raW5ldGljX2VuZXJneRgZIAEo",
|
|
"AjoFMC4wMDQSJAoVcmV0dXJuX2ludGVybmFsX3N0YXRlGBogASgIOgVmYWxz",
|
|
"ZRIzCiV1c2VfcG9zdF9lc3RpbWF0aW9uX3dlaWdodHNfZm9yX3N0YXRlGB0g",
|
|
"ASgIOgR0cnVlEiQKFWNvbXB1dGVfc3BhdGlhbF9wcmlvchgbIAEoCDoFZmFs",
|
|
"c2USSwoTaXJsc19pbml0aWFsaXphdGlvbhgeIAEoCzIuLm1lZGlhcGlwZS5U",
|
|
"cmFja1N0ZXBPcHRpb25zLklybHNJbml0aWFsaXphdGlvbhIrChxzdGF0aWNf",
|
|
"bW90aW9uX3RlbXBvcmFsX3JhdGlvGCEgASgCOgUwLjAwMxJuCiZjYW5jZWxf",
|
|
"dHJhY2tpbmdfd2l0aF9vY2NsdXNpb25fb3B0aW9ucxgiIAEoCzI+Lm1lZGlh",
|
|
"cGlwZS5UcmFja1N0ZXBPcHRpb25zLkNhbmNlbFRyYWNraW5nV2l0aE9jY2x1",
|
|
"c2lvbk9wdGlvbnMSLwojb2JqZWN0X3NpbWlsYXJpdHlfbWluX2NvbnRkX2lu",
|
|
"bGllcnMYIyABKAU6AjMwEiYKGGJveF9zaW1pbGFyaXR5X21heF9zY2FsZRgk",
|
|
"IAEoAjoEMS4wNRIoChtib3hfc2ltaWxhcml0eV9tYXhfcm90YXRpb24YJSAB",
|
|
"KAI6AzAuMhImChlxdWFkX2hvbW9ncmFwaHlfbWF4X3NjYWxlGCYgASgCOgMx",
|
|
"LjISKQoccXVhZF9ob21vZ3JhcGh5X21heF9yb3RhdGlvbhgnIAEoAjoDMC4z",
|
|
"EkcKEWNhbWVyYV9pbnRyaW5zaWNzGCggASgLMiwubWVkaWFwaXBlLlRyYWNr",
|
|
"U3RlcE9wdGlvbnMuQ2FtZXJhSW50cmluc2ljcxIiChNmb3JjZWRfcG5wX3Ry",
|
|
"YWNraW5nGCkgASgIOgVmYWxzZRpZChJJcmxzSW5pdGlhbGl6YXRpb24SGAoJ",
|
|
"YWN0aXZhdGVkGAEgASgIOgVmYWxzZRISCgZyb3VuZHMYAiABKAU6AjUwEhUK",
|
|
"BmN1dG9mZhgDIAEoAjoFMC4wMDUagQEKIkNhbmNlbFRyYWNraW5nV2l0aE9j",
|
|
"Y2x1c2lvbk9wdGlvbnMSGAoJYWN0aXZhdGVkGAEgASgIOgVmYWxzZRIiChVt",
|
|
"aW5fbW90aW9uX2NvbnRpbnVpdHkYAiABKAI6AzAuNBIdChBtaW5faW5saWVy",
|
|
"X3JhdGlvGAMgASgCOgMwLjEafAoQQ2FtZXJhSW50cmluc2ljcxIKCgJmeBgB",
|
|
"IAEoAhIKCgJmeRgCIAEoAhIKCgJjeBgDIAEoAhIKCgJjeRgEIAEoAhIKCgJr",
|
|
"MBgFIAEoAhIKCgJrMRgGIAEoAhIKCgJrMhgHIAEoAhIJCgF3GAggASgFEgkK",
|
|
"AWgYCSABKAUi5gIKD1RyYWNraW5nRGVncmVlcxIfChtUUkFDS0lOR19ERUdS",
|
|
"RUVfVFJBTlNMQVRJT04QABIgChxUUkFDS0lOR19ERUdSRUVfQ0FNRVJBX1ND",
|
|
"QUxFEAESIwofVFJBQ0tJTkdfREVHUkVFX0NBTUVSQV9ST1RBVElPThACEikK",
|
|
"JVRSQUNLSU5HX0RFR1JFRV9DQU1FUkFfUk9UQVRJT05fU0NBTEUQAxImCiJU",
|
|
"UkFDS0lOR19ERUdSRUVfQ0FNRVJBX1BFUlNQRUNUSVZFEAQSIAocVFJBQ0tJ",
|
|
"TkdfREVHUkVFX09CSkVDVF9TQ0FMRRAFEiMKH1RSQUNLSU5HX0RFR1JFRV9P",
|
|
"QkpFQ1RfUk9UQVRJT04QBhIpCiVUUkFDS0lOR19ERUdSRUVfT0JKRUNUX1JP",
|
|
"VEFUSU9OX1NDQUxFEAcSJgoiVFJBQ0tJTkdfREVHUkVFX09CSkVDVF9QRVJT",
|
|
"UEVDVElWRRAI"));
|
|
descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData,
|
|
new pbr::FileDescriptor[] { global::Mediapipe.MotionModelsReflection.Descriptor, },
|
|
new pbr::GeneratedClrTypeInfo(null, null, new pbr::GeneratedClrTypeInfo[] {
|
|
new pbr::GeneratedClrTypeInfo(typeof(global::Mediapipe.MotionBoxState), global::Mediapipe.MotionBoxState.Parser, new[]{ "PosX", "PosY", "Width", "Height", "Scale", "Rotation", "Quad", "AspectRatio", "RequestGrouping", "PnpHomography", "Dx", "Dy", "KineticEnergy", "PriorWeight", "TrackStatus", "SpatialPriorGridSize", "SpatialPrior", "SpatialConfidence", "PriorDiff", "MotionDisparity", "BackgroundDiscrimination", "InlierCenterX", "InlierCenterY", "InlierSum", "InlierRatio", "InlierWidth", "InlierHeight", "InlierIds", "InlierIdMatchPos", "InlierLength", "OutlierIds", "OutlierIdMatchPos", "TrackingConfidence", "Internal" }, null, new[]{ typeof(global::Mediapipe.MotionBoxState.Types.TrackStatus) }, null, new pbr::GeneratedClrTypeInfo[] { new pbr::GeneratedClrTypeInfo(typeof(global::Mediapipe.MotionBoxState.Types.Quad), global::Mediapipe.MotionBoxState.Types.Quad.Parser, new[]{ "Vertices" }, null, null, null, null)}),
|
|
new pbr::GeneratedClrTypeInfo(typeof(global::Mediapipe.MotionBoxInternalState), global::Mediapipe.MotionBoxInternalState.Parser, new[]{ "PosX", "PosY", "Dx", "Dy", "CameraDx", "CameraDy", "TrackId", "InlierScore" }, null, null, null, null),
|
|
new pbr::GeneratedClrTypeInfo(typeof(global::Mediapipe.TrackStepOptions), global::Mediapipe.TrackStepOptions.Parser, new[]{ "TrackingDegrees", "TrackObjectAndCamera", "IrlsIterations", "SpatialSigma", "MinMotionSigma", "RelativeMotionSigma", "MotionDisparityLowLevel", "MotionDisparityHighLevel", "DisparityDecay", "MotionPriorWeight", "BackgroundDiscriminationLowLevel", "BackgroundDiscriminationHighLevel", "InlierCenterRelativeDistance", "InlierSpringForce", "KineticCenterRelativeDistance", "KineticSpringForce", "KineticSpringForceMinKineticEnergy", "VelocityUpdateWeight", "MaxTrackFailures", "ExpansionSize", "InlierLowWeight", "InlierHighWeight", "KineticEnergyDecay", "PriorWeightIncrease", "LowKineticEnergy", "HighKineticEnergy", "ReturnInternalState", "UsePostEstimationWeightsForState", "ComputeSpatialPrior", "IrlsInitialization", "StaticMotionTemporalRatio", "CancelTrackingWithOcclusionOptions", "ObjectSimilarityMinContdInliers", "BoxSimilarityMaxScale", "BoxSimilarityMaxRotation", "QuadHomographyMaxScale", "QuadHomographyMaxRotation", "CameraIntrinsics", "ForcedPnpTracking" }, null, new[]{ typeof(global::Mediapipe.TrackStepOptions.Types.TrackingDegrees) }, null, new pbr::GeneratedClrTypeInfo[] { new pbr::GeneratedClrTypeInfo(typeof(global::Mediapipe.TrackStepOptions.Types.IrlsInitialization), global::Mediapipe.TrackStepOptions.Types.IrlsInitialization.Parser, new[]{ "Activated", "Rounds", "Cutoff" }, null, null, null, null),
|
|
new pbr::GeneratedClrTypeInfo(typeof(global::Mediapipe.TrackStepOptions.Types.CancelTrackingWithOcclusionOptions), global::Mediapipe.TrackStepOptions.Types.CancelTrackingWithOcclusionOptions.Parser, new[]{ "Activated", "MinMotionContinuity", "MinInlierRatio" }, null, null, null, null),
|
|
new pbr::GeneratedClrTypeInfo(typeof(global::Mediapipe.TrackStepOptions.Types.CameraIntrinsics), global::Mediapipe.TrackStepOptions.Types.CameraIntrinsics.Parser, new[]{ "Fx", "Fy", "Cx", "Cy", "K0", "K1", "K2", "W", "H" }, null, null, null, null)})
|
|
}));
|
|
}
|
|
#endregion
|
|
|
|
}
|
|
#region Messages
|
|
/// <summary>
|
|
/// Next tag: 38
|
|
/// </summary>
|
|
public sealed partial class MotionBoxState : pb::IMessage<MotionBoxState>
|
|
#if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
|
|
, pb::IBufferMessage
|
|
#endif
|
|
{
|
|
private static readonly pb::MessageParser<MotionBoxState> _parser = new pb::MessageParser<MotionBoxState>(() => new MotionBoxState());
|
|
private pb::UnknownFieldSet _unknownFields;
|
|
private int _hasBits0;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public static pb::MessageParser<MotionBoxState> Parser { get { return _parser; } }
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public static pbr::MessageDescriptor Descriptor {
|
|
get { return global::Mediapipe.TrackingReflection.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 MotionBoxState() {
|
|
OnConstruction();
|
|
}
|
|
|
|
partial void OnConstruction();
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public MotionBoxState(MotionBoxState other) : this() {
|
|
_hasBits0 = other._hasBits0;
|
|
posX_ = other.posX_;
|
|
posY_ = other.posY_;
|
|
width_ = other.width_;
|
|
height_ = other.height_;
|
|
scale_ = other.scale_;
|
|
rotation_ = other.rotation_;
|
|
quad_ = other.quad_ != null ? other.quad_.Clone() : null;
|
|
aspectRatio_ = other.aspectRatio_;
|
|
requestGrouping_ = other.requestGrouping_;
|
|
pnpHomography_ = other.pnpHomography_ != null ? other.pnpHomography_.Clone() : null;
|
|
dx_ = other.dx_;
|
|
dy_ = other.dy_;
|
|
kineticEnergy_ = other.kineticEnergy_;
|
|
priorWeight_ = other.priorWeight_;
|
|
trackStatus_ = other.trackStatus_;
|
|
spatialPriorGridSize_ = other.spatialPriorGridSize_;
|
|
spatialPrior_ = other.spatialPrior_.Clone();
|
|
spatialConfidence_ = other.spatialConfidence_.Clone();
|
|
priorDiff_ = other.priorDiff_;
|
|
motionDisparity_ = other.motionDisparity_;
|
|
backgroundDiscrimination_ = other.backgroundDiscrimination_;
|
|
inlierCenterX_ = other.inlierCenterX_;
|
|
inlierCenterY_ = other.inlierCenterY_;
|
|
inlierSum_ = other.inlierSum_;
|
|
inlierRatio_ = other.inlierRatio_;
|
|
inlierWidth_ = other.inlierWidth_;
|
|
inlierHeight_ = other.inlierHeight_;
|
|
inlierIds_ = other.inlierIds_.Clone();
|
|
inlierIdMatchPos_ = other.inlierIdMatchPos_.Clone();
|
|
inlierLength_ = other.inlierLength_.Clone();
|
|
outlierIds_ = other.outlierIds_.Clone();
|
|
outlierIdMatchPos_ = other.outlierIdMatchPos_.Clone();
|
|
trackingConfidence_ = other.trackingConfidence_;
|
|
internal_ = other.internal_ != null ? other.internal_.Clone() : null;
|
|
_unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public MotionBoxState Clone() {
|
|
return new MotionBoxState(this);
|
|
}
|
|
|
|
/// <summary>Field number for the "pos_x" field.</summary>
|
|
public const int PosXFieldNumber = 1;
|
|
private readonly static float PosXDefaultValue = 0F;
|
|
|
|
private float posX_;
|
|
/// <summary>
|
|
/// Position (top-left corner) and fixed size of the current MotionBox,
|
|
/// specified w.r.t. normalized domain (in [0, 1] along both dimensions).
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public float PosX {
|
|
get { if ((_hasBits0 & 1) != 0) { return posX_; } else { return PosXDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 1;
|
|
posX_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "pos_x" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasPosX {
|
|
get { return (_hasBits0 & 1) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "pos_x" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearPosX() {
|
|
_hasBits0 &= ~1;
|
|
}
|
|
|
|
/// <summary>Field number for the "pos_y" field.</summary>
|
|
public const int PosYFieldNumber = 2;
|
|
private readonly static float PosYDefaultValue = 0F;
|
|
|
|
private float posY_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public float PosY {
|
|
get { if ((_hasBits0 & 2) != 0) { return posY_; } else { return PosYDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 2;
|
|
posY_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "pos_y" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasPosY {
|
|
get { return (_hasBits0 & 2) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "pos_y" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearPosY() {
|
|
_hasBits0 &= ~2;
|
|
}
|
|
|
|
/// <summary>Field number for the "width" field.</summary>
|
|
public const int WidthFieldNumber = 3;
|
|
private readonly static float WidthDefaultValue = 0F;
|
|
|
|
private float width_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public float Width {
|
|
get { if ((_hasBits0 & 4) != 0) { return width_; } else { return WidthDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 4;
|
|
width_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "width" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasWidth {
|
|
get { return (_hasBits0 & 4) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "width" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearWidth() {
|
|
_hasBits0 &= ~4;
|
|
}
|
|
|
|
/// <summary>Field number for the "height" field.</summary>
|
|
public const int HeightFieldNumber = 4;
|
|
private readonly static float HeightDefaultValue = 0F;
|
|
|
|
private float height_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public float Height {
|
|
get { if ((_hasBits0 & 8) != 0) { return height_; } else { return HeightDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 8;
|
|
height_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "height" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasHeight {
|
|
get { return (_hasBits0 & 8) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "height" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearHeight() {
|
|
_hasBits0 &= ~8;
|
|
}
|
|
|
|
/// <summary>Field number for the "scale" field.</summary>
|
|
public const int ScaleFieldNumber = 5;
|
|
private readonly static float ScaleDefaultValue = 1F;
|
|
|
|
private float scale_;
|
|
/// <summary>
|
|
/// Optional degrees of freedom; scale and rotation w.r.t. center of the box,
|
|
/// i.e. [pos_x, pos_y] + 0.5 * [width, height].
|
|
/// To activate see TrackStepOptions::TrackingDegrees.
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public float Scale {
|
|
get { if ((_hasBits0 & 16) != 0) { return scale_; } else { return ScaleDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 16;
|
|
scale_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "scale" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasScale {
|
|
get { return (_hasBits0 & 16) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "scale" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearScale() {
|
|
_hasBits0 &= ~16;
|
|
}
|
|
|
|
/// <summary>Field number for the "rotation" field.</summary>
|
|
public const int RotationFieldNumber = 30;
|
|
private readonly static float RotationDefaultValue = 0F;
|
|
|
|
private float rotation_;
|
|
/// <summary>
|
|
/// in radians.
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public float Rotation {
|
|
get { if ((_hasBits0 & 1048576) != 0) { return rotation_; } else { return RotationDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 1048576;
|
|
rotation_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "rotation" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasRotation {
|
|
get { return (_hasBits0 & 1048576) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "rotation" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearRotation() {
|
|
_hasBits0 &= ~1048576;
|
|
}
|
|
|
|
/// <summary>Field number for the "quad" field.</summary>
|
|
public const int QuadFieldNumber = 34;
|
|
private global::Mediapipe.MotionBoxState.Types.Quad quad_;
|
|
/// <summary>
|
|
/// This field is only used when we try to track under
|
|
/// TRACKING_DEGREE_OBJECT_PERSPECTIVE.
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public global::Mediapipe.MotionBoxState.Types.Quad Quad {
|
|
get { return quad_; }
|
|
set {
|
|
quad_ = value;
|
|
}
|
|
}
|
|
|
|
/// <summary>Field number for the "aspect_ratio" field.</summary>
|
|
public const int AspectRatioFieldNumber = 35;
|
|
private readonly static float AspectRatioDefaultValue = 0F;
|
|
|
|
private float aspectRatio_;
|
|
/// <summary>
|
|
/// Aspect ratio (width / height) for the tracked rectangle in physical space.
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public float AspectRatio {
|
|
get { if ((_hasBits0 & 4194304) != 0) { return aspectRatio_; } else { return AspectRatioDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 4194304;
|
|
aspectRatio_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "aspect_ratio" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasAspectRatio {
|
|
get { return (_hasBits0 & 4194304) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "aspect_ratio" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearAspectRatio() {
|
|
_hasBits0 &= ~4194304;
|
|
}
|
|
|
|
/// <summary>Field number for the "request_grouping" field.</summary>
|
|
public const int RequestGroupingFieldNumber = 37;
|
|
private readonly static bool RequestGroupingDefaultValue = false;
|
|
|
|
private bool requestGrouping_;
|
|
/// <summary>
|
|
/// Whether we want this box to be potentially grouped with other boxes
|
|
/// to track together. This is useful for tracking small boxes that lie
|
|
/// on a plane. For example, when we detect a plane,
|
|
/// track the plane, then all boxes within the plane can share the same
|
|
/// homography transform.
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool RequestGrouping {
|
|
get { if ((_hasBits0 & 8388608) != 0) { return requestGrouping_; } else { return RequestGroupingDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 8388608;
|
|
requestGrouping_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "request_grouping" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasRequestGrouping {
|
|
get { return (_hasBits0 & 8388608) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "request_grouping" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearRequestGrouping() {
|
|
_hasBits0 &= ~8388608;
|
|
}
|
|
|
|
/// <summary>Field number for the "pnp_homography" field.</summary>
|
|
public const int PnpHomographyFieldNumber = 36;
|
|
private global::Mediapipe.Homography pnpHomography_;
|
|
/// <summary>
|
|
/// For quad tracking using pnp solver,
|
|
/// Whether we use perspective-n-points to track quad between frames.
|
|
/// That mode requires:
|
|
/// 1. The quad which is being tracked is an rectangle in the physical world.
|
|
/// 2. The `asepct_ratio` field has to be set in MotionBoxState.
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public global::Mediapipe.Homography PnpHomography {
|
|
get { return pnpHomography_; }
|
|
set {
|
|
pnpHomography_ = value;
|
|
}
|
|
}
|
|
|
|
/// <summary>Field number for the "dx" field.</summary>
|
|
public const int DxFieldNumber = 7;
|
|
private readonly static float DxDefaultValue = 0F;
|
|
|
|
private float dx_;
|
|
/// <summary>
|
|
/// Object velocity in x and y, specified as normalized spatial unit per
|
|
/// standard frame period (here calibrated w.r.t. kTrackingDefaultFps = 30
|
|
/// FPS), that is 33.3 ms. Object velocity refers to velocity after
|
|
/// subtracting camera motion.
|
|
/// If current frame period is 66.67 ms (i.e. 15 fps); actual velocity is
|
|
/// obtained by multipling with a factor of 2. Similar for 60 fps factor
|
|
/// is 0.5f.
|
|
/// Standard frame period is chosen for legacy reasons to keep TrackStepOptions
|
|
/// defaults.
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public float Dx {
|
|
get { if ((_hasBits0 & 32) != 0) { return dx_; } else { return DxDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 32;
|
|
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 & 32) != 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 &= ~32;
|
|
}
|
|
|
|
/// <summary>Field number for the "dy" field.</summary>
|
|
public const int DyFieldNumber = 8;
|
|
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 & 64) != 0) { return dy_; } else { return DyDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 64;
|
|
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 & 64) != 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 &= ~64;
|
|
}
|
|
|
|
/// <summary>Field number for the "kinetic_energy" field.</summary>
|
|
public const int KineticEnergyFieldNumber = 17;
|
|
private readonly static float KineticEnergyDefaultValue = 0F;
|
|
|
|
private float kineticEnergy_;
|
|
/// <summary>
|
|
/// Weighted average of object velocity magnitude of inlier points (expressed
|
|
/// in normalized spatial units per standard frame period).
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public float KineticEnergy {
|
|
get { if ((_hasBits0 & 8192) != 0) { return kineticEnergy_; } else { return KineticEnergyDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 8192;
|
|
kineticEnergy_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "kinetic_energy" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasKineticEnergy {
|
|
get { return (_hasBits0 & 8192) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "kinetic_energy" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearKineticEnergy() {
|
|
_hasBits0 &= ~8192;
|
|
}
|
|
|
|
/// <summary>Field number for the "prior_weight" field.</summary>
|
|
public const int PriorWeightFieldNumber = 9;
|
|
private readonly static float PriorWeightDefaultValue = 0F;
|
|
|
|
private float priorWeight_;
|
|
/// <summary>
|
|
/// Specifies how valid the prior was in the last step.
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public float PriorWeight {
|
|
get { if ((_hasBits0 & 128) != 0) { return priorWeight_; } else { return PriorWeightDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 128;
|
|
priorWeight_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "prior_weight" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasPriorWeight {
|
|
get { return (_hasBits0 & 128) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "prior_weight" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearPriorWeight() {
|
|
_hasBits0 &= ~128;
|
|
}
|
|
|
|
/// <summary>Field number for the "track_status" field.</summary>
|
|
public const int TrackStatusFieldNumber = 10;
|
|
private readonly static global::Mediapipe.MotionBoxState.Types.TrackStatus TrackStatusDefaultValue = global::Mediapipe.MotionBoxState.Types.TrackStatus.BoxUntracked;
|
|
|
|
private global::Mediapipe.MotionBoxState.Types.TrackStatus trackStatus_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public global::Mediapipe.MotionBoxState.Types.TrackStatus TrackStatus {
|
|
get { if ((_hasBits0 & 256) != 0) { return trackStatus_; } else { return TrackStatusDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 256;
|
|
trackStatus_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "track_status" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasTrackStatus {
|
|
get { return (_hasBits0 & 256) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "track_status" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearTrackStatus() {
|
|
_hasBits0 &= ~256;
|
|
}
|
|
|
|
/// <summary>Field number for the "spatial_prior_grid_size" field.</summary>
|
|
public const int SpatialPriorGridSizeFieldNumber = 11;
|
|
private readonly static int SpatialPriorGridSizeDefaultValue = 10;
|
|
|
|
private int spatialPriorGridSize_;
|
|
/// <summary>
|
|
/// Spatial prior (presence of inliers, i.e. where is the object located within
|
|
/// the box that is currently being tracked) as a pair of
|
|
/// a) prior (in [0, 1]) and
|
|
/// b) confidence (number of features converted to score within
|
|
/// [0, 1]).
|
|
/// Prior is defined over a grid of size spatial_prior_grid_size x
|
|
/// spatial_prior_grid_size.
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public int SpatialPriorGridSize {
|
|
get { if ((_hasBits0 & 512) != 0) { return spatialPriorGridSize_; } else { return SpatialPriorGridSizeDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 512;
|
|
spatialPriorGridSize_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "spatial_prior_grid_size" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasSpatialPriorGridSize {
|
|
get { return (_hasBits0 & 512) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "spatial_prior_grid_size" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearSpatialPriorGridSize() {
|
|
_hasBits0 &= ~512;
|
|
}
|
|
|
|
/// <summary>Field number for the "spatial_prior" field.</summary>
|
|
public const int SpatialPriorFieldNumber = 12;
|
|
private static readonly pb::FieldCodec<float> _repeated_spatialPrior_codec
|
|
= pb::FieldCodec.ForFloat(98);
|
|
private readonly pbc::RepeatedField<float> spatialPrior_ = new pbc::RepeatedField<float>();
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public pbc::RepeatedField<float> SpatialPrior {
|
|
get { return spatialPrior_; }
|
|
}
|
|
|
|
/// <summary>Field number for the "spatial_confidence" field.</summary>
|
|
public const int SpatialConfidenceFieldNumber = 13;
|
|
private static readonly pb::FieldCodec<float> _repeated_spatialConfidence_codec
|
|
= pb::FieldCodec.ForFloat(106);
|
|
private readonly pbc::RepeatedField<float> spatialConfidence_ = new pbc::RepeatedField<float>();
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public pbc::RepeatedField<float> SpatialConfidence {
|
|
get { return spatialConfidence_; }
|
|
}
|
|
|
|
/// <summary>Field number for the "prior_diff" field.</summary>
|
|
public const int PriorDiffFieldNumber = 14;
|
|
private readonly static float PriorDiffDefaultValue = 0F;
|
|
|
|
private float priorDiff_;
|
|
/// <summary>
|
|
/// Difference score between previous prior and current prior (in [0, 1]).
|
|
/// Currently not used.
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public float PriorDiff {
|
|
get { if ((_hasBits0 & 1024) != 0) { return priorDiff_; } else { return PriorDiffDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 1024;
|
|
priorDiff_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "prior_diff" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasPriorDiff {
|
|
get { return (_hasBits0 & 1024) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "prior_diff" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearPriorDiff() {
|
|
_hasBits0 &= ~1024;
|
|
}
|
|
|
|
/// <summary>Field number for the "motion_disparity" field.</summary>
|
|
public const int MotionDisparityFieldNumber = 15;
|
|
private readonly static float MotionDisparityDefaultValue = 0F;
|
|
|
|
private float motionDisparity_;
|
|
/// <summary>
|
|
/// Score determining how much predicted motion disagrees with measured motion.
|
|
/// If measured motion deviates strongly from predicted motion, disparity is
|
|
/// +/-1, if motion agrees with predicted motion, disparity is 0.
|
|
/// Sign indicates measured motion is accelerating (> 0)
|
|
/// or de-accelerating (< 0) w.r.t. predicted motion.
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public float MotionDisparity {
|
|
get { if ((_hasBits0 & 2048) != 0) { return motionDisparity_; } else { return MotionDisparityDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 2048;
|
|
motionDisparity_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "motion_disparity" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasMotionDisparity {
|
|
get { return (_hasBits0 & 2048) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "motion_disparity" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearMotionDisparity() {
|
|
_hasBits0 &= ~2048;
|
|
}
|
|
|
|
/// <summary>Field number for the "background_discrimination" field.</summary>
|
|
public const int BackgroundDiscriminationFieldNumber = 16;
|
|
private readonly static float BackgroundDiscriminationDefaultValue = 0F;
|
|
|
|
private float backgroundDiscrimination_;
|
|
/// <summary>
|
|
/// Score determining how discriminative estimated motion model is.
|
|
/// In [0, 1] where 0 no discrimination w.r.t. background and 1
|
|
/// high discrimination.
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public float BackgroundDiscrimination {
|
|
get { if ((_hasBits0 & 4096) != 0) { return backgroundDiscrimination_; } else { return BackgroundDiscriminationDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 4096;
|
|
backgroundDiscrimination_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "background_discrimination" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasBackgroundDiscrimination {
|
|
get { return (_hasBits0 & 4096) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "background_discrimination" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearBackgroundDiscrimination() {
|
|
_hasBits0 &= ~4096;
|
|
}
|
|
|
|
/// <summary>Field number for the "inlier_center_x" field.</summary>
|
|
public const int InlierCenterXFieldNumber = 18;
|
|
private readonly static float InlierCenterXDefaultValue = 0F;
|
|
|
|
private float inlierCenterX_;
|
|
/// <summary>
|
|
/// Center of mass for inliers after tracking (center of feature that were used
|
|
/// for motion estimation)
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public float InlierCenterX {
|
|
get { if ((_hasBits0 & 16384) != 0) { return inlierCenterX_; } else { return InlierCenterXDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 16384;
|
|
inlierCenterX_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "inlier_center_x" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasInlierCenterX {
|
|
get { return (_hasBits0 & 16384) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "inlier_center_x" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearInlierCenterX() {
|
|
_hasBits0 &= ~16384;
|
|
}
|
|
|
|
/// <summary>Field number for the "inlier_center_y" field.</summary>
|
|
public const int InlierCenterYFieldNumber = 19;
|
|
private readonly static float InlierCenterYDefaultValue = 0F;
|
|
|
|
private float inlierCenterY_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public float InlierCenterY {
|
|
get { if ((_hasBits0 & 32768) != 0) { return inlierCenterY_; } else { return InlierCenterYDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 32768;
|
|
inlierCenterY_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "inlier_center_y" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasInlierCenterY {
|
|
get { return (_hasBits0 & 32768) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "inlier_center_y" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearInlierCenterY() {
|
|
_hasBits0 &= ~32768;
|
|
}
|
|
|
|
/// <summary>Field number for the "inlier_sum" field.</summary>
|
|
public const int InlierSumFieldNumber = 24;
|
|
private readonly static float InlierSumDefaultValue = 0F;
|
|
|
|
private float inlierSum_;
|
|
/// <summary>
|
|
/// Approximate number of inliers (each features scores a zero [outlier]
|
|
/// or one [inlier]).
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public float InlierSum {
|
|
get { if ((_hasBits0 & 262144) != 0) { return inlierSum_; } else { return InlierSumDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 262144;
|
|
inlierSum_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "inlier_sum" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasInlierSum {
|
|
get { return (_hasBits0 & 262144) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "inlier_sum" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearInlierSum() {
|
|
_hasBits0 &= ~262144;
|
|
}
|
|
|
|
/// <summary>Field number for the "inlier_ratio" field.</summary>
|
|
public const int InlierRatioFieldNumber = 25;
|
|
private readonly static float InlierRatioDefaultValue = 0F;
|
|
|
|
private float inlierRatio_;
|
|
/// <summary>
|
|
/// Ratio of above inlier_sum to average inlier_sum across last states.
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public float InlierRatio {
|
|
get { if ((_hasBits0 & 524288) != 0) { return inlierRatio_; } else { return InlierRatioDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 524288;
|
|
inlierRatio_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "inlier_ratio" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasInlierRatio {
|
|
get { return (_hasBits0 & 524288) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "inlier_ratio" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearInlierRatio() {
|
|
_hasBits0 &= ~524288;
|
|
}
|
|
|
|
/// <summary>Field number for the "inlier_width" field.</summary>
|
|
public const int InlierWidthFieldNumber = 22;
|
|
private readonly static float InlierWidthDefaultValue = 0F;
|
|
|
|
private float inlierWidth_;
|
|
/// <summary>
|
|
/// Extent (width and height of inliers).
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public float InlierWidth {
|
|
get { if ((_hasBits0 & 65536) != 0) { return inlierWidth_; } else { return InlierWidthDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 65536;
|
|
inlierWidth_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "inlier_width" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasInlierWidth {
|
|
get { return (_hasBits0 & 65536) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "inlier_width" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearInlierWidth() {
|
|
_hasBits0 &= ~65536;
|
|
}
|
|
|
|
/// <summary>Field number for the "inlier_height" field.</summary>
|
|
public const int InlierHeightFieldNumber = 23;
|
|
private readonly static float InlierHeightDefaultValue = 0F;
|
|
|
|
private float inlierHeight_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public float InlierHeight {
|
|
get { if ((_hasBits0 & 131072) != 0) { return inlierHeight_; } else { return InlierHeightDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 131072;
|
|
inlierHeight_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "inlier_height" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasInlierHeight {
|
|
get { return (_hasBits0 & 131072) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "inlier_height" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearInlierHeight() {
|
|
_hasBits0 &= ~131072;
|
|
}
|
|
|
|
/// <summary>Field number for the "inlier_ids" field.</summary>
|
|
public const int InlierIdsFieldNumber = 26;
|
|
private static readonly pb::FieldCodec<uint> _repeated_inlierIds_codec
|
|
= pb::FieldCodec.ForUInt32(210);
|
|
private readonly pbc::RepeatedField<uint> inlierIds_ = new pbc::RepeatedField<uint>();
|
|
/// <summary>
|
|
/// Set of current inlier tracking ids.
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public pbc::RepeatedField<uint> InlierIds {
|
|
get { return inlierIds_; }
|
|
}
|
|
|
|
/// <summary>Field number for the "inlier_id_match_pos" field.</summary>
|
|
public const int InlierIdMatchPosFieldNumber = 31;
|
|
private static readonly pb::FieldCodec<uint> _repeated_inlierIdMatchPos_codec
|
|
= pb::FieldCodec.ForUInt32(250);
|
|
private readonly pbc::RepeatedField<uint> inlierIdMatchPos_ = new pbc::RepeatedField<uint>();
|
|
/// <summary>
|
|
/// Corresponding x,y coordinates for each inlier.
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public pbc::RepeatedField<uint> InlierIdMatchPos {
|
|
get { return inlierIdMatchPos_; }
|
|
}
|
|
|
|
/// <summary>Field number for the "inlier_length" field.</summary>
|
|
public const int InlierLengthFieldNumber = 27;
|
|
private static readonly pb::FieldCodec<uint> _repeated_inlierLength_codec
|
|
= pb::FieldCodec.ForUInt32(218);
|
|
private readonly pbc::RepeatedField<uint> inlierLength_ = new pbc::RepeatedField<uint>();
|
|
/// <summary>
|
|
/// Corresponding inlier score (currently: length of inlier observed).
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public pbc::RepeatedField<uint> InlierLength {
|
|
get { return inlierLength_; }
|
|
}
|
|
|
|
/// <summary>Field number for the "outlier_ids" field.</summary>
|
|
public const int OutlierIdsFieldNumber = 28;
|
|
private static readonly pb::FieldCodec<uint> _repeated_outlierIds_codec
|
|
= pb::FieldCodec.ForUInt32(226);
|
|
private readonly pbc::RepeatedField<uint> outlierIds_ = new pbc::RepeatedField<uint>();
|
|
/// <summary>
|
|
/// Set of outlier ids.
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public pbc::RepeatedField<uint> OutlierIds {
|
|
get { return outlierIds_; }
|
|
}
|
|
|
|
/// <summary>Field number for the "outlier_id_match_pos" field.</summary>
|
|
public const int OutlierIdMatchPosFieldNumber = 32;
|
|
private static readonly pb::FieldCodec<uint> _repeated_outlierIdMatchPos_codec
|
|
= pb::FieldCodec.ForUInt32(258);
|
|
private readonly pbc::RepeatedField<uint> outlierIdMatchPos_ = new pbc::RepeatedField<uint>();
|
|
/// <summary>
|
|
/// Corresponding x,y coordinates for each outlier.
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public pbc::RepeatedField<uint> OutlierIdMatchPos {
|
|
get { return outlierIdMatchPos_; }
|
|
}
|
|
|
|
/// <summary>Field number for the "tracking_confidence" field.</summary>
|
|
public const int TrackingConfidenceFieldNumber = 33;
|
|
private readonly static float TrackingConfidenceDefaultValue = 0F;
|
|
|
|
private float trackingConfidence_;
|
|
/// <summary>
|
|
/// Confidence of box tracked in the range [0, 1], with 0 being least
|
|
/// confident, and 1 being most confident. A reasonable threshold is 0.5
|
|
/// to filter out unconfident boxes.
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public float TrackingConfidence {
|
|
get { if ((_hasBits0 & 2097152) != 0) { return trackingConfidence_; } else { return TrackingConfidenceDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 2097152;
|
|
trackingConfidence_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "tracking_confidence" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasTrackingConfidence {
|
|
get { return (_hasBits0 & 2097152) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "tracking_confidence" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearTrackingConfidence() {
|
|
_hasBits0 &= ~2097152;
|
|
}
|
|
|
|
/// <summary>Field number for the "internal" field.</summary>
|
|
public const int InternalFieldNumber = 29;
|
|
private global::Mediapipe.MotionBoxInternalState internal_;
|
|
/// <summary>
|
|
/// Additional internal state.
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public global::Mediapipe.MotionBoxInternalState Internal {
|
|
get { return internal_; }
|
|
set {
|
|
internal_ = value;
|
|
}
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public override bool Equals(object other) {
|
|
return Equals(other as MotionBoxState);
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool Equals(MotionBoxState other) {
|
|
if (ReferenceEquals(other, null)) {
|
|
return false;
|
|
}
|
|
if (ReferenceEquals(other, this)) {
|
|
return true;
|
|
}
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(PosX, other.PosX)) return false;
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(PosY, other.PosY)) return false;
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(Width, other.Width)) return false;
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(Height, other.Height)) return false;
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(Scale, other.Scale)) return false;
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(Rotation, other.Rotation)) return false;
|
|
if (!object.Equals(Quad, other.Quad)) return false;
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(AspectRatio, other.AspectRatio)) return false;
|
|
if (RequestGrouping != other.RequestGrouping) return false;
|
|
if (!object.Equals(PnpHomography, other.PnpHomography)) return false;
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(Dx, other.Dx)) return false;
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(Dy, other.Dy)) return false;
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(KineticEnergy, other.KineticEnergy)) return false;
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(PriorWeight, other.PriorWeight)) return false;
|
|
if (TrackStatus != other.TrackStatus) return false;
|
|
if (SpatialPriorGridSize != other.SpatialPriorGridSize) return false;
|
|
if(!spatialPrior_.Equals(other.spatialPrior_)) return false;
|
|
if(!spatialConfidence_.Equals(other.spatialConfidence_)) return false;
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(PriorDiff, other.PriorDiff)) return false;
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(MotionDisparity, other.MotionDisparity)) return false;
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(BackgroundDiscrimination, other.BackgroundDiscrimination)) return false;
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(InlierCenterX, other.InlierCenterX)) return false;
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(InlierCenterY, other.InlierCenterY)) return false;
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(InlierSum, other.InlierSum)) return false;
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(InlierRatio, other.InlierRatio)) return false;
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(InlierWidth, other.InlierWidth)) return false;
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(InlierHeight, other.InlierHeight)) return false;
|
|
if(!inlierIds_.Equals(other.inlierIds_)) return false;
|
|
if(!inlierIdMatchPos_.Equals(other.inlierIdMatchPos_)) return false;
|
|
if(!inlierLength_.Equals(other.inlierLength_)) return false;
|
|
if(!outlierIds_.Equals(other.outlierIds_)) return false;
|
|
if(!outlierIdMatchPos_.Equals(other.outlierIdMatchPos_)) return false;
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(TrackingConfidence, other.TrackingConfidence)) return false;
|
|
if (!object.Equals(Internal, other.Internal)) 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 (HasPosX) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(PosX);
|
|
if (HasPosY) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(PosY);
|
|
if (HasWidth) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(Width);
|
|
if (HasHeight) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(Height);
|
|
if (HasScale) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(Scale);
|
|
if (HasRotation) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(Rotation);
|
|
if (quad_ != null) hash ^= Quad.GetHashCode();
|
|
if (HasAspectRatio) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(AspectRatio);
|
|
if (HasRequestGrouping) hash ^= RequestGrouping.GetHashCode();
|
|
if (pnpHomography_ != null) hash ^= PnpHomography.GetHashCode();
|
|
if (HasDx) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(Dx);
|
|
if (HasDy) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(Dy);
|
|
if (HasKineticEnergy) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(KineticEnergy);
|
|
if (HasPriorWeight) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(PriorWeight);
|
|
if (HasTrackStatus) hash ^= TrackStatus.GetHashCode();
|
|
if (HasSpatialPriorGridSize) hash ^= SpatialPriorGridSize.GetHashCode();
|
|
hash ^= spatialPrior_.GetHashCode();
|
|
hash ^= spatialConfidence_.GetHashCode();
|
|
if (HasPriorDiff) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(PriorDiff);
|
|
if (HasMotionDisparity) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(MotionDisparity);
|
|
if (HasBackgroundDiscrimination) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(BackgroundDiscrimination);
|
|
if (HasInlierCenterX) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(InlierCenterX);
|
|
if (HasInlierCenterY) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(InlierCenterY);
|
|
if (HasInlierSum) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(InlierSum);
|
|
if (HasInlierRatio) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(InlierRatio);
|
|
if (HasInlierWidth) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(InlierWidth);
|
|
if (HasInlierHeight) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(InlierHeight);
|
|
hash ^= inlierIds_.GetHashCode();
|
|
hash ^= inlierIdMatchPos_.GetHashCode();
|
|
hash ^= inlierLength_.GetHashCode();
|
|
hash ^= outlierIds_.GetHashCode();
|
|
hash ^= outlierIdMatchPos_.GetHashCode();
|
|
if (HasTrackingConfidence) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(TrackingConfidence);
|
|
if (internal_ != null) hash ^= Internal.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 (HasPosX) {
|
|
output.WriteRawTag(13);
|
|
output.WriteFloat(PosX);
|
|
}
|
|
if (HasPosY) {
|
|
output.WriteRawTag(21);
|
|
output.WriteFloat(PosY);
|
|
}
|
|
if (HasWidth) {
|
|
output.WriteRawTag(29);
|
|
output.WriteFloat(Width);
|
|
}
|
|
if (HasHeight) {
|
|
output.WriteRawTag(37);
|
|
output.WriteFloat(Height);
|
|
}
|
|
if (HasScale) {
|
|
output.WriteRawTag(45);
|
|
output.WriteFloat(Scale);
|
|
}
|
|
if (HasDx) {
|
|
output.WriteRawTag(61);
|
|
output.WriteFloat(Dx);
|
|
}
|
|
if (HasDy) {
|
|
output.WriteRawTag(69);
|
|
output.WriteFloat(Dy);
|
|
}
|
|
if (HasPriorWeight) {
|
|
output.WriteRawTag(77);
|
|
output.WriteFloat(PriorWeight);
|
|
}
|
|
if (HasTrackStatus) {
|
|
output.WriteRawTag(80);
|
|
output.WriteEnum((int) TrackStatus);
|
|
}
|
|
if (HasSpatialPriorGridSize) {
|
|
output.WriteRawTag(88);
|
|
output.WriteInt32(SpatialPriorGridSize);
|
|
}
|
|
spatialPrior_.WriteTo(output, _repeated_spatialPrior_codec);
|
|
spatialConfidence_.WriteTo(output, _repeated_spatialConfidence_codec);
|
|
if (HasPriorDiff) {
|
|
output.WriteRawTag(117);
|
|
output.WriteFloat(PriorDiff);
|
|
}
|
|
if (HasMotionDisparity) {
|
|
output.WriteRawTag(125);
|
|
output.WriteFloat(MotionDisparity);
|
|
}
|
|
if (HasBackgroundDiscrimination) {
|
|
output.WriteRawTag(133, 1);
|
|
output.WriteFloat(BackgroundDiscrimination);
|
|
}
|
|
if (HasKineticEnergy) {
|
|
output.WriteRawTag(141, 1);
|
|
output.WriteFloat(KineticEnergy);
|
|
}
|
|
if (HasInlierCenterX) {
|
|
output.WriteRawTag(149, 1);
|
|
output.WriteFloat(InlierCenterX);
|
|
}
|
|
if (HasInlierCenterY) {
|
|
output.WriteRawTag(157, 1);
|
|
output.WriteFloat(InlierCenterY);
|
|
}
|
|
if (HasInlierWidth) {
|
|
output.WriteRawTag(181, 1);
|
|
output.WriteFloat(InlierWidth);
|
|
}
|
|
if (HasInlierHeight) {
|
|
output.WriteRawTag(189, 1);
|
|
output.WriteFloat(InlierHeight);
|
|
}
|
|
if (HasInlierSum) {
|
|
output.WriteRawTag(197, 1);
|
|
output.WriteFloat(InlierSum);
|
|
}
|
|
if (HasInlierRatio) {
|
|
output.WriteRawTag(205, 1);
|
|
output.WriteFloat(InlierRatio);
|
|
}
|
|
inlierIds_.WriteTo(output, _repeated_inlierIds_codec);
|
|
inlierLength_.WriteTo(output, _repeated_inlierLength_codec);
|
|
outlierIds_.WriteTo(output, _repeated_outlierIds_codec);
|
|
if (internal_ != null) {
|
|
output.WriteRawTag(234, 1);
|
|
output.WriteMessage(Internal);
|
|
}
|
|
if (HasRotation) {
|
|
output.WriteRawTag(245, 1);
|
|
output.WriteFloat(Rotation);
|
|
}
|
|
inlierIdMatchPos_.WriteTo(output, _repeated_inlierIdMatchPos_codec);
|
|
outlierIdMatchPos_.WriteTo(output, _repeated_outlierIdMatchPos_codec);
|
|
if (HasTrackingConfidence) {
|
|
output.WriteRawTag(141, 2);
|
|
output.WriteFloat(TrackingConfidence);
|
|
}
|
|
if (quad_ != null) {
|
|
output.WriteRawTag(146, 2);
|
|
output.WriteMessage(Quad);
|
|
}
|
|
if (HasAspectRatio) {
|
|
output.WriteRawTag(157, 2);
|
|
output.WriteFloat(AspectRatio);
|
|
}
|
|
if (pnpHomography_ != null) {
|
|
output.WriteRawTag(162, 2);
|
|
output.WriteMessage(PnpHomography);
|
|
}
|
|
if (HasRequestGrouping) {
|
|
output.WriteRawTag(168, 2);
|
|
output.WriteBool(RequestGrouping);
|
|
}
|
|
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 (HasPosX) {
|
|
output.WriteRawTag(13);
|
|
output.WriteFloat(PosX);
|
|
}
|
|
if (HasPosY) {
|
|
output.WriteRawTag(21);
|
|
output.WriteFloat(PosY);
|
|
}
|
|
if (HasWidth) {
|
|
output.WriteRawTag(29);
|
|
output.WriteFloat(Width);
|
|
}
|
|
if (HasHeight) {
|
|
output.WriteRawTag(37);
|
|
output.WriteFloat(Height);
|
|
}
|
|
if (HasScale) {
|
|
output.WriteRawTag(45);
|
|
output.WriteFloat(Scale);
|
|
}
|
|
if (HasDx) {
|
|
output.WriteRawTag(61);
|
|
output.WriteFloat(Dx);
|
|
}
|
|
if (HasDy) {
|
|
output.WriteRawTag(69);
|
|
output.WriteFloat(Dy);
|
|
}
|
|
if (HasPriorWeight) {
|
|
output.WriteRawTag(77);
|
|
output.WriteFloat(PriorWeight);
|
|
}
|
|
if (HasTrackStatus) {
|
|
output.WriteRawTag(80);
|
|
output.WriteEnum((int) TrackStatus);
|
|
}
|
|
if (HasSpatialPriorGridSize) {
|
|
output.WriteRawTag(88);
|
|
output.WriteInt32(SpatialPriorGridSize);
|
|
}
|
|
spatialPrior_.WriteTo(ref output, _repeated_spatialPrior_codec);
|
|
spatialConfidence_.WriteTo(ref output, _repeated_spatialConfidence_codec);
|
|
if (HasPriorDiff) {
|
|
output.WriteRawTag(117);
|
|
output.WriteFloat(PriorDiff);
|
|
}
|
|
if (HasMotionDisparity) {
|
|
output.WriteRawTag(125);
|
|
output.WriteFloat(MotionDisparity);
|
|
}
|
|
if (HasBackgroundDiscrimination) {
|
|
output.WriteRawTag(133, 1);
|
|
output.WriteFloat(BackgroundDiscrimination);
|
|
}
|
|
if (HasKineticEnergy) {
|
|
output.WriteRawTag(141, 1);
|
|
output.WriteFloat(KineticEnergy);
|
|
}
|
|
if (HasInlierCenterX) {
|
|
output.WriteRawTag(149, 1);
|
|
output.WriteFloat(InlierCenterX);
|
|
}
|
|
if (HasInlierCenterY) {
|
|
output.WriteRawTag(157, 1);
|
|
output.WriteFloat(InlierCenterY);
|
|
}
|
|
if (HasInlierWidth) {
|
|
output.WriteRawTag(181, 1);
|
|
output.WriteFloat(InlierWidth);
|
|
}
|
|
if (HasInlierHeight) {
|
|
output.WriteRawTag(189, 1);
|
|
output.WriteFloat(InlierHeight);
|
|
}
|
|
if (HasInlierSum) {
|
|
output.WriteRawTag(197, 1);
|
|
output.WriteFloat(InlierSum);
|
|
}
|
|
if (HasInlierRatio) {
|
|
output.WriteRawTag(205, 1);
|
|
output.WriteFloat(InlierRatio);
|
|
}
|
|
inlierIds_.WriteTo(ref output, _repeated_inlierIds_codec);
|
|
inlierLength_.WriteTo(ref output, _repeated_inlierLength_codec);
|
|
outlierIds_.WriteTo(ref output, _repeated_outlierIds_codec);
|
|
if (internal_ != null) {
|
|
output.WriteRawTag(234, 1);
|
|
output.WriteMessage(Internal);
|
|
}
|
|
if (HasRotation) {
|
|
output.WriteRawTag(245, 1);
|
|
output.WriteFloat(Rotation);
|
|
}
|
|
inlierIdMatchPos_.WriteTo(ref output, _repeated_inlierIdMatchPos_codec);
|
|
outlierIdMatchPos_.WriteTo(ref output, _repeated_outlierIdMatchPos_codec);
|
|
if (HasTrackingConfidence) {
|
|
output.WriteRawTag(141, 2);
|
|
output.WriteFloat(TrackingConfidence);
|
|
}
|
|
if (quad_ != null) {
|
|
output.WriteRawTag(146, 2);
|
|
output.WriteMessage(Quad);
|
|
}
|
|
if (HasAspectRatio) {
|
|
output.WriteRawTag(157, 2);
|
|
output.WriteFloat(AspectRatio);
|
|
}
|
|
if (pnpHomography_ != null) {
|
|
output.WriteRawTag(162, 2);
|
|
output.WriteMessage(PnpHomography);
|
|
}
|
|
if (HasRequestGrouping) {
|
|
output.WriteRawTag(168, 2);
|
|
output.WriteBool(RequestGrouping);
|
|
}
|
|
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 (HasPosX) {
|
|
size += 1 + 4;
|
|
}
|
|
if (HasPosY) {
|
|
size += 1 + 4;
|
|
}
|
|
if (HasWidth) {
|
|
size += 1 + 4;
|
|
}
|
|
if (HasHeight) {
|
|
size += 1 + 4;
|
|
}
|
|
if (HasScale) {
|
|
size += 1 + 4;
|
|
}
|
|
if (HasRotation) {
|
|
size += 2 + 4;
|
|
}
|
|
if (quad_ != null) {
|
|
size += 2 + pb::CodedOutputStream.ComputeMessageSize(Quad);
|
|
}
|
|
if (HasAspectRatio) {
|
|
size += 2 + 4;
|
|
}
|
|
if (HasRequestGrouping) {
|
|
size += 2 + 1;
|
|
}
|
|
if (pnpHomography_ != null) {
|
|
size += 2 + pb::CodedOutputStream.ComputeMessageSize(PnpHomography);
|
|
}
|
|
if (HasDx) {
|
|
size += 1 + 4;
|
|
}
|
|
if (HasDy) {
|
|
size += 1 + 4;
|
|
}
|
|
if (HasKineticEnergy) {
|
|
size += 2 + 4;
|
|
}
|
|
if (HasPriorWeight) {
|
|
size += 1 + 4;
|
|
}
|
|
if (HasTrackStatus) {
|
|
size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) TrackStatus);
|
|
}
|
|
if (HasSpatialPriorGridSize) {
|
|
size += 1 + pb::CodedOutputStream.ComputeInt32Size(SpatialPriorGridSize);
|
|
}
|
|
size += spatialPrior_.CalculateSize(_repeated_spatialPrior_codec);
|
|
size += spatialConfidence_.CalculateSize(_repeated_spatialConfidence_codec);
|
|
if (HasPriorDiff) {
|
|
size += 1 + 4;
|
|
}
|
|
if (HasMotionDisparity) {
|
|
size += 1 + 4;
|
|
}
|
|
if (HasBackgroundDiscrimination) {
|
|
size += 2 + 4;
|
|
}
|
|
if (HasInlierCenterX) {
|
|
size += 2 + 4;
|
|
}
|
|
if (HasInlierCenterY) {
|
|
size += 2 + 4;
|
|
}
|
|
if (HasInlierSum) {
|
|
size += 2 + 4;
|
|
}
|
|
if (HasInlierRatio) {
|
|
size += 2 + 4;
|
|
}
|
|
if (HasInlierWidth) {
|
|
size += 2 + 4;
|
|
}
|
|
if (HasInlierHeight) {
|
|
size += 2 + 4;
|
|
}
|
|
size += inlierIds_.CalculateSize(_repeated_inlierIds_codec);
|
|
size += inlierIdMatchPos_.CalculateSize(_repeated_inlierIdMatchPos_codec);
|
|
size += inlierLength_.CalculateSize(_repeated_inlierLength_codec);
|
|
size += outlierIds_.CalculateSize(_repeated_outlierIds_codec);
|
|
size += outlierIdMatchPos_.CalculateSize(_repeated_outlierIdMatchPos_codec);
|
|
if (HasTrackingConfidence) {
|
|
size += 2 + 4;
|
|
}
|
|
if (internal_ != null) {
|
|
size += 2 + pb::CodedOutputStream.ComputeMessageSize(Internal);
|
|
}
|
|
if (_unknownFields != null) {
|
|
size += _unknownFields.CalculateSize();
|
|
}
|
|
return size;
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void MergeFrom(MotionBoxState other) {
|
|
if (other == null) {
|
|
return;
|
|
}
|
|
if (other.HasPosX) {
|
|
PosX = other.PosX;
|
|
}
|
|
if (other.HasPosY) {
|
|
PosY = other.PosY;
|
|
}
|
|
if (other.HasWidth) {
|
|
Width = other.Width;
|
|
}
|
|
if (other.HasHeight) {
|
|
Height = other.Height;
|
|
}
|
|
if (other.HasScale) {
|
|
Scale = other.Scale;
|
|
}
|
|
if (other.HasRotation) {
|
|
Rotation = other.Rotation;
|
|
}
|
|
if (other.quad_ != null) {
|
|
if (quad_ == null) {
|
|
Quad = new global::Mediapipe.MotionBoxState.Types.Quad();
|
|
}
|
|
Quad.MergeFrom(other.Quad);
|
|
}
|
|
if (other.HasAspectRatio) {
|
|
AspectRatio = other.AspectRatio;
|
|
}
|
|
if (other.HasRequestGrouping) {
|
|
RequestGrouping = other.RequestGrouping;
|
|
}
|
|
if (other.pnpHomography_ != null) {
|
|
if (pnpHomography_ == null) {
|
|
PnpHomography = new global::Mediapipe.Homography();
|
|
}
|
|
PnpHomography.MergeFrom(other.PnpHomography);
|
|
}
|
|
if (other.HasDx) {
|
|
Dx = other.Dx;
|
|
}
|
|
if (other.HasDy) {
|
|
Dy = other.Dy;
|
|
}
|
|
if (other.HasKineticEnergy) {
|
|
KineticEnergy = other.KineticEnergy;
|
|
}
|
|
if (other.HasPriorWeight) {
|
|
PriorWeight = other.PriorWeight;
|
|
}
|
|
if (other.HasTrackStatus) {
|
|
TrackStatus = other.TrackStatus;
|
|
}
|
|
if (other.HasSpatialPriorGridSize) {
|
|
SpatialPriorGridSize = other.SpatialPriorGridSize;
|
|
}
|
|
spatialPrior_.Add(other.spatialPrior_);
|
|
spatialConfidence_.Add(other.spatialConfidence_);
|
|
if (other.HasPriorDiff) {
|
|
PriorDiff = other.PriorDiff;
|
|
}
|
|
if (other.HasMotionDisparity) {
|
|
MotionDisparity = other.MotionDisparity;
|
|
}
|
|
if (other.HasBackgroundDiscrimination) {
|
|
BackgroundDiscrimination = other.BackgroundDiscrimination;
|
|
}
|
|
if (other.HasInlierCenterX) {
|
|
InlierCenterX = other.InlierCenterX;
|
|
}
|
|
if (other.HasInlierCenterY) {
|
|
InlierCenterY = other.InlierCenterY;
|
|
}
|
|
if (other.HasInlierSum) {
|
|
InlierSum = other.InlierSum;
|
|
}
|
|
if (other.HasInlierRatio) {
|
|
InlierRatio = other.InlierRatio;
|
|
}
|
|
if (other.HasInlierWidth) {
|
|
InlierWidth = other.InlierWidth;
|
|
}
|
|
if (other.HasInlierHeight) {
|
|
InlierHeight = other.InlierHeight;
|
|
}
|
|
inlierIds_.Add(other.inlierIds_);
|
|
inlierIdMatchPos_.Add(other.inlierIdMatchPos_);
|
|
inlierLength_.Add(other.inlierLength_);
|
|
outlierIds_.Add(other.outlierIds_);
|
|
outlierIdMatchPos_.Add(other.outlierIdMatchPos_);
|
|
if (other.HasTrackingConfidence) {
|
|
TrackingConfidence = other.TrackingConfidence;
|
|
}
|
|
if (other.internal_ != null) {
|
|
if (internal_ == null) {
|
|
Internal = new global::Mediapipe.MotionBoxInternalState();
|
|
}
|
|
Internal.MergeFrom(other.Internal);
|
|
}
|
|
_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: {
|
|
PosX = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 21: {
|
|
PosY = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 29: {
|
|
Width = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 37: {
|
|
Height = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 45: {
|
|
Scale = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 61: {
|
|
Dx = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 69: {
|
|
Dy = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 77: {
|
|
PriorWeight = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 80: {
|
|
TrackStatus = (global::Mediapipe.MotionBoxState.Types.TrackStatus) input.ReadEnum();
|
|
break;
|
|
}
|
|
case 88: {
|
|
SpatialPriorGridSize = input.ReadInt32();
|
|
break;
|
|
}
|
|
case 98:
|
|
case 101: {
|
|
spatialPrior_.AddEntriesFrom(input, _repeated_spatialPrior_codec);
|
|
break;
|
|
}
|
|
case 106:
|
|
case 109: {
|
|
spatialConfidence_.AddEntriesFrom(input, _repeated_spatialConfidence_codec);
|
|
break;
|
|
}
|
|
case 117: {
|
|
PriorDiff = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 125: {
|
|
MotionDisparity = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 133: {
|
|
BackgroundDiscrimination = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 141: {
|
|
KineticEnergy = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 149: {
|
|
InlierCenterX = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 157: {
|
|
InlierCenterY = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 181: {
|
|
InlierWidth = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 189: {
|
|
InlierHeight = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 197: {
|
|
InlierSum = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 205: {
|
|
InlierRatio = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 210:
|
|
case 208: {
|
|
inlierIds_.AddEntriesFrom(input, _repeated_inlierIds_codec);
|
|
break;
|
|
}
|
|
case 218:
|
|
case 216: {
|
|
inlierLength_.AddEntriesFrom(input, _repeated_inlierLength_codec);
|
|
break;
|
|
}
|
|
case 226:
|
|
case 224: {
|
|
outlierIds_.AddEntriesFrom(input, _repeated_outlierIds_codec);
|
|
break;
|
|
}
|
|
case 234: {
|
|
if (internal_ == null) {
|
|
Internal = new global::Mediapipe.MotionBoxInternalState();
|
|
}
|
|
input.ReadMessage(Internal);
|
|
break;
|
|
}
|
|
case 245: {
|
|
Rotation = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 250:
|
|
case 248: {
|
|
inlierIdMatchPos_.AddEntriesFrom(input, _repeated_inlierIdMatchPos_codec);
|
|
break;
|
|
}
|
|
case 258:
|
|
case 256: {
|
|
outlierIdMatchPos_.AddEntriesFrom(input, _repeated_outlierIdMatchPos_codec);
|
|
break;
|
|
}
|
|
case 269: {
|
|
TrackingConfidence = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 274: {
|
|
if (quad_ == null) {
|
|
Quad = new global::Mediapipe.MotionBoxState.Types.Quad();
|
|
}
|
|
input.ReadMessage(Quad);
|
|
break;
|
|
}
|
|
case 285: {
|
|
AspectRatio = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 290: {
|
|
if (pnpHomography_ == null) {
|
|
PnpHomography = new global::Mediapipe.Homography();
|
|
}
|
|
input.ReadMessage(PnpHomography);
|
|
break;
|
|
}
|
|
case 296: {
|
|
RequestGrouping = input.ReadBool();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
#if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
|
|
uint tag;
|
|
while ((tag = input.ReadTag()) != 0) {
|
|
switch(tag) {
|
|
default:
|
|
_unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
|
|
break;
|
|
case 13: {
|
|
PosX = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 21: {
|
|
PosY = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 29: {
|
|
Width = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 37: {
|
|
Height = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 45: {
|
|
Scale = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 61: {
|
|
Dx = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 69: {
|
|
Dy = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 77: {
|
|
PriorWeight = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 80: {
|
|
TrackStatus = (global::Mediapipe.MotionBoxState.Types.TrackStatus) input.ReadEnum();
|
|
break;
|
|
}
|
|
case 88: {
|
|
SpatialPriorGridSize = input.ReadInt32();
|
|
break;
|
|
}
|
|
case 98:
|
|
case 101: {
|
|
spatialPrior_.AddEntriesFrom(ref input, _repeated_spatialPrior_codec);
|
|
break;
|
|
}
|
|
case 106:
|
|
case 109: {
|
|
spatialConfidence_.AddEntriesFrom(ref input, _repeated_spatialConfidence_codec);
|
|
break;
|
|
}
|
|
case 117: {
|
|
PriorDiff = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 125: {
|
|
MotionDisparity = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 133: {
|
|
BackgroundDiscrimination = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 141: {
|
|
KineticEnergy = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 149: {
|
|
InlierCenterX = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 157: {
|
|
InlierCenterY = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 181: {
|
|
InlierWidth = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 189: {
|
|
InlierHeight = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 197: {
|
|
InlierSum = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 205: {
|
|
InlierRatio = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 210:
|
|
case 208: {
|
|
inlierIds_.AddEntriesFrom(ref input, _repeated_inlierIds_codec);
|
|
break;
|
|
}
|
|
case 218:
|
|
case 216: {
|
|
inlierLength_.AddEntriesFrom(ref input, _repeated_inlierLength_codec);
|
|
break;
|
|
}
|
|
case 226:
|
|
case 224: {
|
|
outlierIds_.AddEntriesFrom(ref input, _repeated_outlierIds_codec);
|
|
break;
|
|
}
|
|
case 234: {
|
|
if (internal_ == null) {
|
|
Internal = new global::Mediapipe.MotionBoxInternalState();
|
|
}
|
|
input.ReadMessage(Internal);
|
|
break;
|
|
}
|
|
case 245: {
|
|
Rotation = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 250:
|
|
case 248: {
|
|
inlierIdMatchPos_.AddEntriesFrom(ref input, _repeated_inlierIdMatchPos_codec);
|
|
break;
|
|
}
|
|
case 258:
|
|
case 256: {
|
|
outlierIdMatchPos_.AddEntriesFrom(ref input, _repeated_outlierIdMatchPos_codec);
|
|
break;
|
|
}
|
|
case 269: {
|
|
TrackingConfidence = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 274: {
|
|
if (quad_ == null) {
|
|
Quad = new global::Mediapipe.MotionBoxState.Types.Quad();
|
|
}
|
|
input.ReadMessage(Quad);
|
|
break;
|
|
}
|
|
case 285: {
|
|
AspectRatio = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 290: {
|
|
if (pnpHomography_ == null) {
|
|
PnpHomography = new global::Mediapipe.Homography();
|
|
}
|
|
input.ReadMessage(PnpHomography);
|
|
break;
|
|
}
|
|
case 296: {
|
|
RequestGrouping = input.ReadBool();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
#region Nested types
|
|
/// <summary>Container for nested types declared in the MotionBoxState message type.</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public static partial class Types {
|
|
/// <summary>
|
|
/// Tracking status indicating result of tracking:
|
|
/// UNTRACKED: Box can not be tracked
|
|
/// (either out of bound or too many tracking failures).
|
|
/// EMPTY: Box has size of <= 0 along at least on of its dimensions
|
|
/// (collapsed).
|
|
/// NO_FEATURES: No features found within the box, tracking is not possible.
|
|
/// TRACKED: Successful tracking.
|
|
/// DUPLICATED: Successful tracked, but duplicated from previous result as
|
|
/// frame was duplicated.
|
|
/// BOX_TRACKED_OUT_OF_BOUND: Successful tracked, out of bound from screen
|
|
/// area. Will advance by camera motion. Only used for static objects.
|
|
/// </summary>
|
|
public enum TrackStatus {
|
|
[pbr::OriginalName("BOX_UNTRACKED")] BoxUntracked = 0,
|
|
[pbr::OriginalName("BOX_EMPTY")] BoxEmpty = 1,
|
|
[pbr::OriginalName("BOX_NO_FEATURES")] BoxNoFeatures = 2,
|
|
[pbr::OriginalName("BOX_TRACKED")] BoxTracked = 3,
|
|
[pbr::OriginalName("BOX_DUPLICATED")] BoxDuplicated = 4,
|
|
[pbr::OriginalName("BOX_TRACKED_OUT_OF_BOUND")] BoxTrackedOutOfBound = 5,
|
|
}
|
|
|
|
public sealed partial class Quad : pb::IMessage<Quad>
|
|
#if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
|
|
, pb::IBufferMessage
|
|
#endif
|
|
{
|
|
private static readonly pb::MessageParser<Quad> _parser = new pb::MessageParser<Quad>(() => new Quad());
|
|
private pb::UnknownFieldSet _unknownFields;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public static pb::MessageParser<Quad> Parser { get { return _parser; } }
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public static pbr::MessageDescriptor Descriptor {
|
|
get { return global::Mediapipe.MotionBoxState.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 Quad() {
|
|
OnConstruction();
|
|
}
|
|
|
|
partial void OnConstruction();
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public Quad(Quad other) : this() {
|
|
vertices_ = other.vertices_.Clone();
|
|
_unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public Quad Clone() {
|
|
return new Quad(this);
|
|
}
|
|
|
|
/// <summary>Field number for the "vertices" field.</summary>
|
|
public const int VerticesFieldNumber = 1;
|
|
private static readonly pb::FieldCodec<float> _repeated_vertices_codec
|
|
= pb::FieldCodec.ForFloat(13);
|
|
private readonly pbc::RepeatedField<float> vertices_ = new pbc::RepeatedField<float>();
|
|
/// <summary>
|
|
/// Vertex 0 is according to x_0 = vertices(0), y_0 = vertices(1)
|
|
/// Vertex 1 is according to x_1 = vertices(2), y_1 = vertices(3)
|
|
/// Vertex 2 is according to x_2 = vertices(4), y_2 = vertices(5)
|
|
/// Vertex 3 is according to x_3 = vertices(6), y_3 = vertices(7)
|
|
/// Order of vertices should be aligned in counter-clockwise manner
|
|
/// 0---------3
|
|
/// | |
|
|
/// | |
|
|
/// 1---------2
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public pbc::RepeatedField<float> Vertices {
|
|
get { return vertices_; }
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public override bool Equals(object other) {
|
|
return Equals(other as Quad);
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool Equals(Quad other) {
|
|
if (ReferenceEquals(other, null)) {
|
|
return false;
|
|
}
|
|
if (ReferenceEquals(other, this)) {
|
|
return true;
|
|
}
|
|
if(!vertices_.Equals(other.vertices_)) 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 ^= vertices_.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
|
|
vertices_.WriteTo(output, _repeated_vertices_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) {
|
|
vertices_.WriteTo(ref output, _repeated_vertices_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 += vertices_.CalculateSize(_repeated_vertices_codec);
|
|
if (_unknownFields != null) {
|
|
size += _unknownFields.CalculateSize();
|
|
}
|
|
return size;
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void MergeFrom(Quad other) {
|
|
if (other == null) {
|
|
return;
|
|
}
|
|
vertices_.Add(other.vertices_);
|
|
_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: {
|
|
vertices_.AddEntriesFrom(input, _repeated_vertices_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: {
|
|
vertices_.AddEntriesFrom(ref input, _repeated_vertices_codec);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
}
|
|
|
|
}
|
|
#endregion
|
|
|
|
}
|
|
|
|
/// <summary>
|
|
/// Captures additional internal state info about the tracking.
|
|
/// </summary>
|
|
public sealed partial class MotionBoxInternalState : pb::IMessage<MotionBoxInternalState>
|
|
#if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
|
|
, pb::IBufferMessage
|
|
#endif
|
|
{
|
|
private static readonly pb::MessageParser<MotionBoxInternalState> _parser = new pb::MessageParser<MotionBoxInternalState>(() => new MotionBoxInternalState());
|
|
private pb::UnknownFieldSet _unknownFields;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public static pb::MessageParser<MotionBoxInternalState> Parser { get { return _parser; } }
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public static pbr::MessageDescriptor Descriptor {
|
|
get { return global::Mediapipe.TrackingReflection.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 MotionBoxInternalState() {
|
|
OnConstruction();
|
|
}
|
|
|
|
partial void OnConstruction();
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public MotionBoxInternalState(MotionBoxInternalState other) : this() {
|
|
posX_ = other.posX_.Clone();
|
|
posY_ = other.posY_.Clone();
|
|
dx_ = other.dx_.Clone();
|
|
dy_ = other.dy_.Clone();
|
|
cameraDx_ = other.cameraDx_.Clone();
|
|
cameraDy_ = other.cameraDy_.Clone();
|
|
trackId_ = other.trackId_.Clone();
|
|
inlierScore_ = other.inlierScore_.Clone();
|
|
_unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public MotionBoxInternalState Clone() {
|
|
return new MotionBoxInternalState(this);
|
|
}
|
|
|
|
/// <summary>Field number for the "pos_x" field.</summary>
|
|
public const int PosXFieldNumber = 1;
|
|
private static readonly pb::FieldCodec<float> _repeated_posX_codec
|
|
= pb::FieldCodec.ForFloat(10);
|
|
private readonly pbc::RepeatedField<float> posX_ = new pbc::RepeatedField<float>();
|
|
/// <summary>
|
|
/// Stores all motion vectors that were used for tracking
|
|
/// as packed arrays, capturing position, object motion, camera motion,
|
|
/// tracking id and corresponding inlier weight.
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public pbc::RepeatedField<float> PosX {
|
|
get { return posX_; }
|
|
}
|
|
|
|
/// <summary>Field number for the "pos_y" field.</summary>
|
|
public const int PosYFieldNumber = 2;
|
|
private static readonly pb::FieldCodec<float> _repeated_posY_codec
|
|
= pb::FieldCodec.ForFloat(18);
|
|
private readonly pbc::RepeatedField<float> posY_ = new pbc::RepeatedField<float>();
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public pbc::RepeatedField<float> PosY {
|
|
get { return posY_; }
|
|
}
|
|
|
|
/// <summary>Field number for the "dx" field.</summary>
|
|
public const int DxFieldNumber = 3;
|
|
private static readonly pb::FieldCodec<float> _repeated_dx_codec
|
|
= pb::FieldCodec.ForFloat(26);
|
|
private readonly pbc::RepeatedField<float> dx_ = new pbc::RepeatedField<float>();
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public pbc::RepeatedField<float> Dx {
|
|
get { return dx_; }
|
|
}
|
|
|
|
/// <summary>Field number for the "dy" field.</summary>
|
|
public const int DyFieldNumber = 4;
|
|
private static readonly pb::FieldCodec<float> _repeated_dy_codec
|
|
= pb::FieldCodec.ForFloat(34);
|
|
private readonly pbc::RepeatedField<float> dy_ = new pbc::RepeatedField<float>();
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public pbc::RepeatedField<float> Dy {
|
|
get { return dy_; }
|
|
}
|
|
|
|
/// <summary>Field number for the "camera_dx" field.</summary>
|
|
public const int CameraDxFieldNumber = 5;
|
|
private static readonly pb::FieldCodec<float> _repeated_cameraDx_codec
|
|
= pb::FieldCodec.ForFloat(42);
|
|
private readonly pbc::RepeatedField<float> cameraDx_ = new pbc::RepeatedField<float>();
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public pbc::RepeatedField<float> CameraDx {
|
|
get { return cameraDx_; }
|
|
}
|
|
|
|
/// <summary>Field number for the "camera_dy" field.</summary>
|
|
public const int CameraDyFieldNumber = 6;
|
|
private static readonly pb::FieldCodec<float> _repeated_cameraDy_codec
|
|
= pb::FieldCodec.ForFloat(50);
|
|
private readonly pbc::RepeatedField<float> cameraDy_ = new pbc::RepeatedField<float>();
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public pbc::RepeatedField<float> CameraDy {
|
|
get { return cameraDy_; }
|
|
}
|
|
|
|
/// <summary>Field number for the "track_id" field.</summary>
|
|
public const int TrackIdFieldNumber = 7;
|
|
private static readonly pb::FieldCodec<int> _repeated_trackId_codec
|
|
= pb::FieldCodec.ForInt32(58);
|
|
private readonly pbc::RepeatedField<int> trackId_ = new pbc::RepeatedField<int>();
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public pbc::RepeatedField<int> TrackId {
|
|
get { return trackId_; }
|
|
}
|
|
|
|
/// <summary>Field number for the "inlier_score" field.</summary>
|
|
public const int InlierScoreFieldNumber = 8;
|
|
private static readonly pb::FieldCodec<float> _repeated_inlierScore_codec
|
|
= pb::FieldCodec.ForFloat(66);
|
|
private readonly pbc::RepeatedField<float> inlierScore_ = new pbc::RepeatedField<float>();
|
|
/// <summary>
|
|
/// Within [0, 1]. 0 = outlier; 1 = inlier.
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public pbc::RepeatedField<float> InlierScore {
|
|
get { return inlierScore_; }
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public override bool Equals(object other) {
|
|
return Equals(other as MotionBoxInternalState);
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool Equals(MotionBoxInternalState other) {
|
|
if (ReferenceEquals(other, null)) {
|
|
return false;
|
|
}
|
|
if (ReferenceEquals(other, this)) {
|
|
return true;
|
|
}
|
|
if(!posX_.Equals(other.posX_)) return false;
|
|
if(!posY_.Equals(other.posY_)) return false;
|
|
if(!dx_.Equals(other.dx_)) return false;
|
|
if(!dy_.Equals(other.dy_)) return false;
|
|
if(!cameraDx_.Equals(other.cameraDx_)) return false;
|
|
if(!cameraDy_.Equals(other.cameraDy_)) return false;
|
|
if(!trackId_.Equals(other.trackId_)) return false;
|
|
if(!inlierScore_.Equals(other.inlierScore_)) 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 ^= posX_.GetHashCode();
|
|
hash ^= posY_.GetHashCode();
|
|
hash ^= dx_.GetHashCode();
|
|
hash ^= dy_.GetHashCode();
|
|
hash ^= cameraDx_.GetHashCode();
|
|
hash ^= cameraDy_.GetHashCode();
|
|
hash ^= trackId_.GetHashCode();
|
|
hash ^= inlierScore_.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
|
|
posX_.WriteTo(output, _repeated_posX_codec);
|
|
posY_.WriteTo(output, _repeated_posY_codec);
|
|
dx_.WriteTo(output, _repeated_dx_codec);
|
|
dy_.WriteTo(output, _repeated_dy_codec);
|
|
cameraDx_.WriteTo(output, _repeated_cameraDx_codec);
|
|
cameraDy_.WriteTo(output, _repeated_cameraDy_codec);
|
|
trackId_.WriteTo(output, _repeated_trackId_codec);
|
|
inlierScore_.WriteTo(output, _repeated_inlierScore_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) {
|
|
posX_.WriteTo(ref output, _repeated_posX_codec);
|
|
posY_.WriteTo(ref output, _repeated_posY_codec);
|
|
dx_.WriteTo(ref output, _repeated_dx_codec);
|
|
dy_.WriteTo(ref output, _repeated_dy_codec);
|
|
cameraDx_.WriteTo(ref output, _repeated_cameraDx_codec);
|
|
cameraDy_.WriteTo(ref output, _repeated_cameraDy_codec);
|
|
trackId_.WriteTo(ref output, _repeated_trackId_codec);
|
|
inlierScore_.WriteTo(ref output, _repeated_inlierScore_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 += posX_.CalculateSize(_repeated_posX_codec);
|
|
size += posY_.CalculateSize(_repeated_posY_codec);
|
|
size += dx_.CalculateSize(_repeated_dx_codec);
|
|
size += dy_.CalculateSize(_repeated_dy_codec);
|
|
size += cameraDx_.CalculateSize(_repeated_cameraDx_codec);
|
|
size += cameraDy_.CalculateSize(_repeated_cameraDy_codec);
|
|
size += trackId_.CalculateSize(_repeated_trackId_codec);
|
|
size += inlierScore_.CalculateSize(_repeated_inlierScore_codec);
|
|
if (_unknownFields != null) {
|
|
size += _unknownFields.CalculateSize();
|
|
}
|
|
return size;
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void MergeFrom(MotionBoxInternalState other) {
|
|
if (other == null) {
|
|
return;
|
|
}
|
|
posX_.Add(other.posX_);
|
|
posY_.Add(other.posY_);
|
|
dx_.Add(other.dx_);
|
|
dy_.Add(other.dy_);
|
|
cameraDx_.Add(other.cameraDx_);
|
|
cameraDy_.Add(other.cameraDy_);
|
|
trackId_.Add(other.trackId_);
|
|
inlierScore_.Add(other.inlierScore_);
|
|
_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: {
|
|
posX_.AddEntriesFrom(input, _repeated_posX_codec);
|
|
break;
|
|
}
|
|
case 18:
|
|
case 21: {
|
|
posY_.AddEntriesFrom(input, _repeated_posY_codec);
|
|
break;
|
|
}
|
|
case 26:
|
|
case 29: {
|
|
dx_.AddEntriesFrom(input, _repeated_dx_codec);
|
|
break;
|
|
}
|
|
case 34:
|
|
case 37: {
|
|
dy_.AddEntriesFrom(input, _repeated_dy_codec);
|
|
break;
|
|
}
|
|
case 42:
|
|
case 45: {
|
|
cameraDx_.AddEntriesFrom(input, _repeated_cameraDx_codec);
|
|
break;
|
|
}
|
|
case 50:
|
|
case 53: {
|
|
cameraDy_.AddEntriesFrom(input, _repeated_cameraDy_codec);
|
|
break;
|
|
}
|
|
case 58:
|
|
case 56: {
|
|
trackId_.AddEntriesFrom(input, _repeated_trackId_codec);
|
|
break;
|
|
}
|
|
case 66:
|
|
case 69: {
|
|
inlierScore_.AddEntriesFrom(input, _repeated_inlierScore_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: {
|
|
posX_.AddEntriesFrom(ref input, _repeated_posX_codec);
|
|
break;
|
|
}
|
|
case 18:
|
|
case 21: {
|
|
posY_.AddEntriesFrom(ref input, _repeated_posY_codec);
|
|
break;
|
|
}
|
|
case 26:
|
|
case 29: {
|
|
dx_.AddEntriesFrom(ref input, _repeated_dx_codec);
|
|
break;
|
|
}
|
|
case 34:
|
|
case 37: {
|
|
dy_.AddEntriesFrom(ref input, _repeated_dy_codec);
|
|
break;
|
|
}
|
|
case 42:
|
|
case 45: {
|
|
cameraDx_.AddEntriesFrom(ref input, _repeated_cameraDx_codec);
|
|
break;
|
|
}
|
|
case 50:
|
|
case 53: {
|
|
cameraDy_.AddEntriesFrom(ref input, _repeated_cameraDy_codec);
|
|
break;
|
|
}
|
|
case 58:
|
|
case 56: {
|
|
trackId_.AddEntriesFrom(ref input, _repeated_trackId_codec);
|
|
break;
|
|
}
|
|
case 66:
|
|
case 69: {
|
|
inlierScore_.AddEntriesFrom(ref input, _repeated_inlierScore_codec);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
}
|
|
|
|
/// <summary>
|
|
/// Next tag: 42
|
|
/// </summary>
|
|
public sealed partial class TrackStepOptions : pb::IMessage<TrackStepOptions>
|
|
#if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
|
|
, pb::IBufferMessage
|
|
#endif
|
|
{
|
|
private static readonly pb::MessageParser<TrackStepOptions> _parser = new pb::MessageParser<TrackStepOptions>(() => new TrackStepOptions());
|
|
private pb::UnknownFieldSet _unknownFields;
|
|
private int _hasBits0;
|
|
private int _hasBits1;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public static pb::MessageParser<TrackStepOptions> Parser { get { return _parser; } }
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public static pbr::MessageDescriptor Descriptor {
|
|
get { return global::Mediapipe.TrackingReflection.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 TrackStepOptions() {
|
|
OnConstruction();
|
|
}
|
|
|
|
partial void OnConstruction();
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public TrackStepOptions(TrackStepOptions other) : this() {
|
|
_hasBits0 = other._hasBits0;
|
|
_hasBits1 = other._hasBits1;
|
|
trackingDegrees_ = other.trackingDegrees_;
|
|
trackObjectAndCamera_ = other.trackObjectAndCamera_;
|
|
irlsIterations_ = other.irlsIterations_;
|
|
spatialSigma_ = other.spatialSigma_;
|
|
minMotionSigma_ = other.minMotionSigma_;
|
|
relativeMotionSigma_ = other.relativeMotionSigma_;
|
|
motionDisparityLowLevel_ = other.motionDisparityLowLevel_;
|
|
motionDisparityHighLevel_ = other.motionDisparityHighLevel_;
|
|
disparityDecay_ = other.disparityDecay_;
|
|
motionPriorWeight_ = other.motionPriorWeight_;
|
|
backgroundDiscriminationLowLevel_ = other.backgroundDiscriminationLowLevel_;
|
|
backgroundDiscriminationHighLevel_ = other.backgroundDiscriminationHighLevel_;
|
|
inlierCenterRelativeDistance_ = other.inlierCenterRelativeDistance_;
|
|
inlierSpringForce_ = other.inlierSpringForce_;
|
|
kineticCenterRelativeDistance_ = other.kineticCenterRelativeDistance_;
|
|
kineticSpringForce_ = other.kineticSpringForce_;
|
|
kineticSpringForceMinKineticEnergy_ = other.kineticSpringForceMinKineticEnergy_;
|
|
velocityUpdateWeight_ = other.velocityUpdateWeight_;
|
|
maxTrackFailures_ = other.maxTrackFailures_;
|
|
expansionSize_ = other.expansionSize_;
|
|
inlierLowWeight_ = other.inlierLowWeight_;
|
|
inlierHighWeight_ = other.inlierHighWeight_;
|
|
kineticEnergyDecay_ = other.kineticEnergyDecay_;
|
|
priorWeightIncrease_ = other.priorWeightIncrease_;
|
|
lowKineticEnergy_ = other.lowKineticEnergy_;
|
|
highKineticEnergy_ = other.highKineticEnergy_;
|
|
returnInternalState_ = other.returnInternalState_;
|
|
usePostEstimationWeightsForState_ = other.usePostEstimationWeightsForState_;
|
|
computeSpatialPrior_ = other.computeSpatialPrior_;
|
|
irlsInitialization_ = other.irlsInitialization_ != null ? other.irlsInitialization_.Clone() : null;
|
|
staticMotionTemporalRatio_ = other.staticMotionTemporalRatio_;
|
|
cancelTrackingWithOcclusionOptions_ = other.cancelTrackingWithOcclusionOptions_ != null ? other.cancelTrackingWithOcclusionOptions_.Clone() : null;
|
|
objectSimilarityMinContdInliers_ = other.objectSimilarityMinContdInliers_;
|
|
boxSimilarityMaxScale_ = other.boxSimilarityMaxScale_;
|
|
boxSimilarityMaxRotation_ = other.boxSimilarityMaxRotation_;
|
|
quadHomographyMaxScale_ = other.quadHomographyMaxScale_;
|
|
quadHomographyMaxRotation_ = other.quadHomographyMaxRotation_;
|
|
cameraIntrinsics_ = other.cameraIntrinsics_ != null ? other.cameraIntrinsics_.Clone() : null;
|
|
forcedPnpTracking_ = other.forcedPnpTracking_;
|
|
_unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public TrackStepOptions Clone() {
|
|
return new TrackStepOptions(this);
|
|
}
|
|
|
|
/// <summary>Field number for the "tracking_degrees" field.</summary>
|
|
public const int TrackingDegreesFieldNumber = 28;
|
|
private readonly static global::Mediapipe.TrackStepOptions.Types.TrackingDegrees TrackingDegreesDefaultValue = global::Mediapipe.TrackStepOptions.Types.TrackingDegrees.TrackingDegreeTranslation;
|
|
|
|
private global::Mediapipe.TrackStepOptions.Types.TrackingDegrees trackingDegrees_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public global::Mediapipe.TrackStepOptions.Types.TrackingDegrees TrackingDegrees {
|
|
get { if ((_hasBits0 & 67108864) != 0) { return trackingDegrees_; } else { return TrackingDegreesDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 67108864;
|
|
trackingDegrees_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "tracking_degrees" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasTrackingDegrees {
|
|
get { return (_hasBits0 & 67108864) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "tracking_degrees" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearTrackingDegrees() {
|
|
_hasBits0 &= ~67108864;
|
|
}
|
|
|
|
/// <summary>Field number for the "track_object_and_camera" field.</summary>
|
|
public const int TrackObjectAndCameraFieldNumber = 32;
|
|
private readonly static bool TrackObjectAndCameraDefaultValue = false;
|
|
|
|
private bool trackObjectAndCamera_;
|
|
/// <summary>
|
|
/// If set and one of the TRACKING_DEGREE_OBJECT degrees are set also applies
|
|
/// camera motion in addition to the object motion.
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool TrackObjectAndCamera {
|
|
get { if ((_hasBits0 & 268435456) != 0) { return trackObjectAndCamera_; } else { return TrackObjectAndCameraDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 268435456;
|
|
trackObjectAndCamera_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "track_object_and_camera" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasTrackObjectAndCamera {
|
|
get { return (_hasBits0 & 268435456) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "track_object_and_camera" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearTrackObjectAndCamera() {
|
|
_hasBits0 &= ~268435456;
|
|
}
|
|
|
|
/// <summary>Field number for the "irls_iterations" field.</summary>
|
|
public const int IrlsIterationsFieldNumber = 1;
|
|
private readonly static int IrlsIterationsDefaultValue = 5;
|
|
|
|
private int irlsIterations_;
|
|
/// <summary>
|
|
/// Number of iterations to iteratively estimate model and re-estimate
|
|
/// influence of each vector.
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public int IrlsIterations {
|
|
get { if ((_hasBits0 & 1) != 0) { return irlsIterations_; } else { return IrlsIterationsDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 1;
|
|
irlsIterations_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "irls_iterations" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasIrlsIterations {
|
|
get { return (_hasBits0 & 1) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "irls_iterations" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearIrlsIterations() {
|
|
_hasBits0 &= ~1;
|
|
}
|
|
|
|
/// <summary>Field number for the "spatial_sigma" field.</summary>
|
|
public const int SpatialSigmaFieldNumber = 2;
|
|
private readonly static float SpatialSigmaDefaultValue = 0.15F;
|
|
|
|
private float spatialSigma_;
|
|
/// <summary>
|
|
/// Gaussian spatial prior sigma relative to box size.
|
|
/// For motivation, see this plot: http://goo.gl/BCfcy.
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public float SpatialSigma {
|
|
get { if ((_hasBits0 & 2) != 0) { return spatialSigma_; } else { return SpatialSigmaDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 2;
|
|
spatialSigma_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "spatial_sigma" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasSpatialSigma {
|
|
get { return (_hasBits0 & 2) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "spatial_sigma" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearSpatialSigma() {
|
|
_hasBits0 &= ~2;
|
|
}
|
|
|
|
/// <summary>Field number for the "min_motion_sigma" field.</summary>
|
|
public const int MinMotionSigmaFieldNumber = 3;
|
|
private readonly static float MinMotionSigmaDefaultValue = 0.002F;
|
|
|
|
private float minMotionSigma_;
|
|
/// <summary>
|
|
/// Gaussian velocity prior sigma. It is computed as the maximum of the
|
|
/// absolute minimum sigma (in normalized domain) and the relative sigma
|
|
/// w.r.t. previous motion.
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public float MinMotionSigma {
|
|
get { if ((_hasBits0 & 4) != 0) { return minMotionSigma_; } else { return MinMotionSigmaDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 4;
|
|
minMotionSigma_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "min_motion_sigma" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasMinMotionSigma {
|
|
get { return (_hasBits0 & 4) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "min_motion_sigma" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearMinMotionSigma() {
|
|
_hasBits0 &= ~4;
|
|
}
|
|
|
|
/// <summary>Field number for the "relative_motion_sigma" field.</summary>
|
|
public const int RelativeMotionSigmaFieldNumber = 4;
|
|
private readonly static float RelativeMotionSigmaDefaultValue = 0.3F;
|
|
|
|
private float relativeMotionSigma_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public float RelativeMotionSigma {
|
|
get { if ((_hasBits0 & 8) != 0) { return relativeMotionSigma_; } else { return RelativeMotionSigmaDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 8;
|
|
relativeMotionSigma_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "relative_motion_sigma" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasRelativeMotionSigma {
|
|
get { return (_hasBits0 & 8) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "relative_motion_sigma" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearRelativeMotionSigma() {
|
|
_hasBits0 &= ~8;
|
|
}
|
|
|
|
/// <summary>Field number for the "motion_disparity_low_level" field.</summary>
|
|
public const int MotionDisparityLowLevelFieldNumber = 6;
|
|
private readonly static float MotionDisparityLowLevelDefaultValue = 0.008F;
|
|
|
|
private float motionDisparityLowLevel_;
|
|
/// <summary>
|
|
/// Settings for motion disparity. Difference between previous and current
|
|
/// motion magnitude is scored linearly, from motion_disparity_low_level to
|
|
/// motion_disparity_high_level (mapped to score of 0 and 1 respectively).
|
|
/// Motivation is to ensure acceleration between frames are within reasonable
|
|
/// bounds.
|
|
/// Represents a maximum acceleration of around 4 - 5 pixels per frame in 360p
|
|
/// video to be unpenalized, with accelerations of around >= 10 pixels being
|
|
/// considered inconsitent with prediction.
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public float MotionDisparityLowLevel {
|
|
get { if ((_hasBits0 & 16) != 0) { return motionDisparityLowLevel_; } else { return MotionDisparityLowLevelDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 16;
|
|
motionDisparityLowLevel_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "motion_disparity_low_level" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasMotionDisparityLowLevel {
|
|
get { return (_hasBits0 & 16) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "motion_disparity_low_level" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearMotionDisparityLowLevel() {
|
|
_hasBits0 &= ~16;
|
|
}
|
|
|
|
/// <summary>Field number for the "motion_disparity_high_level" field.</summary>
|
|
public const int MotionDisparityHighLevelFieldNumber = 7;
|
|
private readonly static float MotionDisparityHighLevelDefaultValue = 0.016F;
|
|
|
|
private float motionDisparityHighLevel_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public float MotionDisparityHighLevel {
|
|
get { if ((_hasBits0 & 32) != 0) { return motionDisparityHighLevel_; } else { return MotionDisparityHighLevelDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 32;
|
|
motionDisparityHighLevel_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "motion_disparity_high_level" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasMotionDisparityHighLevel {
|
|
get { return (_hasBits0 & 32) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "motion_disparity_high_level" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearMotionDisparityHighLevel() {
|
|
_hasBits0 &= ~32;
|
|
}
|
|
|
|
/// <summary>Field number for the "disparity_decay" field.</summary>
|
|
public const int DisparityDecayFieldNumber = 8;
|
|
private readonly static float DisparityDecayDefaultValue = 0.8F;
|
|
|
|
private float disparityDecay_;
|
|
/// <summary>
|
|
/// Motion disparity decays across frames. Disparity of previous frame decays
|
|
/// over time. If disparity in current frame is not higher, i.e. the larger
|
|
/// of the current and decayed disparity is taken.
|
|
/// Motivation is, that if acceleration was unreasonable high (and we likely
|
|
/// lost tracking) we enter a stage of trying to regain tracking by looking for
|
|
/// vectors that agree with the previous prediction.
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public float DisparityDecay {
|
|
get { if ((_hasBits0 & 64) != 0) { return disparityDecay_; } else { return DisparityDecayDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 64;
|
|
disparityDecay_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "disparity_decay" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasDisparityDecay {
|
|
get { return (_hasBits0 & 64) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "disparity_decay" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearDisparityDecay() {
|
|
_hasBits0 &= ~64;
|
|
}
|
|
|
|
/// <summary>Field number for the "motion_prior_weight" field.</summary>
|
|
public const int MotionPriorWeightFieldNumber = 9;
|
|
private readonly static float MotionPriorWeightDefaultValue = 0.2F;
|
|
|
|
private float motionPriorWeight_;
|
|
/// <summary>
|
|
/// Object motion is given as linear combination of previous and measured
|
|
/// motion depending on the motion_disparity (a high disparity is giving high
|
|
/// weight to the previous motion).
|
|
/// We enforce at least a minimum of the below motion_prior_weight regardless
|
|
/// of the motion disparity.
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public float MotionPriorWeight {
|
|
get { if ((_hasBits0 & 128) != 0) { return motionPriorWeight_; } else { return MotionPriorWeightDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 128;
|
|
motionPriorWeight_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "motion_prior_weight" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasMotionPriorWeight {
|
|
get { return (_hasBits0 & 128) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "motion_prior_weight" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearMotionPriorWeight() {
|
|
_hasBits0 &= ~128;
|
|
}
|
|
|
|
/// <summary>Field number for the "background_discrimination_low_level" field.</summary>
|
|
public const int BackgroundDiscriminationLowLevelFieldNumber = 10;
|
|
private readonly static float BackgroundDiscriminationLowLevelDefaultValue = 0.004F;
|
|
|
|
private float backgroundDiscriminationLowLevel_;
|
|
/// <summary>
|
|
/// Settings for motion discrimination.
|
|
///
|
|
/// Current motion magnitude is scored linearly,
|
|
/// from background_discrimination_low_level to
|
|
/// background_discrimination_high_level (mapped to score of 0 and 1
|
|
/// respectively).
|
|
/// Motivation is that high object motions are easy to discriminate from the
|
|
/// background, whereas small object motions are virtually indistinguishable.
|
|
/// Represents a range of 2 - 4 pixels for 360p video.
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public float BackgroundDiscriminationLowLevel {
|
|
get { if ((_hasBits0 & 256) != 0) { return backgroundDiscriminationLowLevel_; } else { return BackgroundDiscriminationLowLevelDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 256;
|
|
backgroundDiscriminationLowLevel_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "background_discrimination_low_level" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasBackgroundDiscriminationLowLevel {
|
|
get { return (_hasBits0 & 256) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "background_discrimination_low_level" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearBackgroundDiscriminationLowLevel() {
|
|
_hasBits0 &= ~256;
|
|
}
|
|
|
|
/// <summary>Field number for the "background_discrimination_high_level" field.</summary>
|
|
public const int BackgroundDiscriminationHighLevelFieldNumber = 11;
|
|
private readonly static float BackgroundDiscriminationHighLevelDefaultValue = 0.008F;
|
|
|
|
private float backgroundDiscriminationHighLevel_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public float BackgroundDiscriminationHighLevel {
|
|
get { if ((_hasBits0 & 512) != 0) { return backgroundDiscriminationHighLevel_; } else { return BackgroundDiscriminationHighLevelDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 512;
|
|
backgroundDiscriminationHighLevel_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "background_discrimination_high_level" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasBackgroundDiscriminationHighLevel {
|
|
get { return (_hasBits0 & 512) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "background_discrimination_high_level" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearBackgroundDiscriminationHighLevel() {
|
|
_hasBits0 &= ~512;
|
|
}
|
|
|
|
/// <summary>Field number for the "inlier_center_relative_distance" field.</summary>
|
|
public const int InlierCenterRelativeDistanceFieldNumber = 12;
|
|
private readonly static float InlierCenterRelativeDistanceDefaultValue = 0.1F;
|
|
|
|
private float inlierCenterRelativeDistance_;
|
|
/// <summary>
|
|
/// Spring force settings. If difference between predicted center of the box in
|
|
/// the next frame and the predicted center of the inliers deviates by more
|
|
/// than inlier_center_relative_distance times the box [width|height]
|
|
/// a spring force is applied to the box. The amount of force is spring_force
|
|
/// times the difference.
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public float InlierCenterRelativeDistance {
|
|
get { if ((_hasBits0 & 1024) != 0) { return inlierCenterRelativeDistance_; } else { return InlierCenterRelativeDistanceDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 1024;
|
|
inlierCenterRelativeDistance_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "inlier_center_relative_distance" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasInlierCenterRelativeDistance {
|
|
get { return (_hasBits0 & 1024) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "inlier_center_relative_distance" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearInlierCenterRelativeDistance() {
|
|
_hasBits0 &= ~1024;
|
|
}
|
|
|
|
/// <summary>Field number for the "inlier_spring_force" field.</summary>
|
|
public const int InlierSpringForceFieldNumber = 13;
|
|
private readonly static float InlierSpringForceDefaultValue = 0.3F;
|
|
|
|
private float inlierSpringForce_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public float InlierSpringForce {
|
|
get { if ((_hasBits0 & 2048) != 0) { return inlierSpringForce_; } else { return InlierSpringForceDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 2048;
|
|
inlierSpringForce_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "inlier_spring_force" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasInlierSpringForce {
|
|
get { return (_hasBits0 & 2048) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "inlier_spring_force" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearInlierSpringForce() {
|
|
_hasBits0 &= ~2048;
|
|
}
|
|
|
|
/// <summary>Field number for the "kinetic_center_relative_distance" field.</summary>
|
|
public const int KineticCenterRelativeDistanceFieldNumber = 14;
|
|
private readonly static float KineticCenterRelativeDistanceDefaultValue = 0.4F;
|
|
|
|
private float kineticCenterRelativeDistance_;
|
|
/// <summary>
|
|
/// Same as above, but for the center of large motion magnitudes.
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public float KineticCenterRelativeDistance {
|
|
get { if ((_hasBits0 & 4096) != 0) { return kineticCenterRelativeDistance_; } else { return KineticCenterRelativeDistanceDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 4096;
|
|
kineticCenterRelativeDistance_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "kinetic_center_relative_distance" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasKineticCenterRelativeDistance {
|
|
get { return (_hasBits0 & 4096) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "kinetic_center_relative_distance" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearKineticCenterRelativeDistance() {
|
|
_hasBits0 &= ~4096;
|
|
}
|
|
|
|
/// <summary>Field number for the "kinetic_spring_force" field.</summary>
|
|
public const int KineticSpringForceFieldNumber = 15;
|
|
private readonly static float KineticSpringForceDefaultValue = 0.5F;
|
|
|
|
private float kineticSpringForce_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public float KineticSpringForce {
|
|
get { if ((_hasBits0 & 8192) != 0) { return kineticSpringForce_; } else { return KineticSpringForceDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 8192;
|
|
kineticSpringForce_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "kinetic_spring_force" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasKineticSpringForce {
|
|
get { return (_hasBits0 & 8192) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "kinetic_spring_force" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearKineticSpringForce() {
|
|
_hasBits0 &= ~8192;
|
|
}
|
|
|
|
/// <summary>Field number for the "kinetic_spring_force_min_kinetic_energy" field.</summary>
|
|
public const int KineticSpringForceMinKineticEnergyFieldNumber = 21;
|
|
private readonly static float KineticSpringForceMinKineticEnergyDefaultValue = 0.003F;
|
|
|
|
private float kineticSpringForceMinKineticEnergy_;
|
|
/// <summary>
|
|
/// Spring force towards large motions is only applied when kinetic energy is
|
|
/// above the specified threshold.
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public float KineticSpringForceMinKineticEnergy {
|
|
get { if ((_hasBits0 & 524288) != 0) { return kineticSpringForceMinKineticEnergy_; } else { return KineticSpringForceMinKineticEnergyDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 524288;
|
|
kineticSpringForceMinKineticEnergy_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "kinetic_spring_force_min_kinetic_energy" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasKineticSpringForceMinKineticEnergy {
|
|
get { return (_hasBits0 & 524288) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "kinetic_spring_force_min_kinetic_energy" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearKineticSpringForceMinKineticEnergy() {
|
|
_hasBits0 &= ~524288;
|
|
}
|
|
|
|
/// <summary>Field number for the "velocity_update_weight" field.</summary>
|
|
public const int VelocityUpdateWeightFieldNumber = 16;
|
|
private readonly static float VelocityUpdateWeightDefaultValue = 0.7F;
|
|
|
|
private float velocityUpdateWeight_;
|
|
/// <summary>
|
|
/// Bias of old velocity during update step.
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public float VelocityUpdateWeight {
|
|
get { if ((_hasBits0 & 16384) != 0) { return velocityUpdateWeight_; } else { return VelocityUpdateWeightDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 16384;
|
|
velocityUpdateWeight_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "velocity_update_weight" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasVelocityUpdateWeight {
|
|
get { return (_hasBits0 & 16384) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "velocity_update_weight" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearVelocityUpdateWeight() {
|
|
_hasBits0 &= ~16384;
|
|
}
|
|
|
|
/// <summary>Field number for the "max_track_failures" field.</summary>
|
|
public const int MaxTrackFailuresFieldNumber = 17;
|
|
private readonly static int MaxTrackFailuresDefaultValue = 10;
|
|
|
|
private int maxTrackFailures_;
|
|
/// <summary>
|
|
/// Maximum number of frames considered to be tracking failures ->
|
|
/// If over threshold, box is considered untrackable.
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public int MaxTrackFailures {
|
|
get { if ((_hasBits0 & 32768) != 0) { return maxTrackFailures_; } else { return MaxTrackFailuresDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 32768;
|
|
maxTrackFailures_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "max_track_failures" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasMaxTrackFailures {
|
|
get { return (_hasBits0 & 32768) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "max_track_failures" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearMaxTrackFailures() {
|
|
_hasBits0 &= ~32768;
|
|
}
|
|
|
|
/// <summary>Field number for the "expansion_size" field.</summary>
|
|
public const int ExpansionSizeFieldNumber = 18;
|
|
private readonly static float ExpansionSizeDefaultValue = 0.05F;
|
|
|
|
private float expansionSize_;
|
|
/// <summary>
|
|
/// Domain used for tracking is always larger than the current box.
|
|
/// If current motion is not negligible, box is expanded in the direction the
|
|
/// motion, otherwise expanded in all directions by the amount specified below
|
|
/// (w.r.t. normalized domain).
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public float ExpansionSize {
|
|
get { if ((_hasBits0 & 65536) != 0) { return expansionSize_; } else { return ExpansionSizeDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 65536;
|
|
expansionSize_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "expansion_size" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasExpansionSize {
|
|
get { return (_hasBits0 & 65536) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "expansion_size" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearExpansionSize() {
|
|
_hasBits0 &= ~65536;
|
|
}
|
|
|
|
/// <summary>Field number for the "inlier_low_weight" field.</summary>
|
|
public const int InlierLowWeightFieldNumber = 19;
|
|
private readonly static float InlierLowWeightDefaultValue = 250F;
|
|
|
|
private float inlierLowWeight_;
|
|
/// <summary>
|
|
/// Features are scored based on the magnitude of their irls weights, mapped to
|
|
/// [0, 1] using the following range. The range represents roughly 3 - 1.5
|
|
/// pixels error for 360p video.
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public float InlierLowWeight {
|
|
get { if ((_hasBits0 & 131072) != 0) { return inlierLowWeight_; } else { return InlierLowWeightDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 131072;
|
|
inlierLowWeight_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "inlier_low_weight" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasInlierLowWeight {
|
|
get { return (_hasBits0 & 131072) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "inlier_low_weight" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearInlierLowWeight() {
|
|
_hasBits0 &= ~131072;
|
|
}
|
|
|
|
/// <summary>Field number for the "inlier_high_weight" field.</summary>
|
|
public const int InlierHighWeightFieldNumber = 20;
|
|
private readonly static float InlierHighWeightDefaultValue = 500F;
|
|
|
|
private float inlierHighWeight_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public float InlierHighWeight {
|
|
get { if ((_hasBits0 & 262144) != 0) { return inlierHighWeight_; } else { return InlierHighWeightDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 262144;
|
|
inlierHighWeight_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "inlier_high_weight" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasInlierHighWeight {
|
|
get { return (_hasBits0 & 262144) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "inlier_high_weight" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearInlierHighWeight() {
|
|
_hasBits0 &= ~262144;
|
|
}
|
|
|
|
/// <summary>Field number for the "kinetic_energy_decay" field.</summary>
|
|
public const int KineticEnergyDecayFieldNumber = 22;
|
|
private readonly static float KineticEnergyDecayDefaultValue = 0.98F;
|
|
|
|
private float kineticEnergyDecay_;
|
|
/// <summary>
|
|
/// Kinetic energy decays over time by the specified rate.
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public float KineticEnergyDecay {
|
|
get { if ((_hasBits0 & 1048576) != 0) { return kineticEnergyDecay_; } else { return KineticEnergyDecayDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 1048576;
|
|
kineticEnergyDecay_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "kinetic_energy_decay" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasKineticEnergyDecay {
|
|
get { return (_hasBits0 & 1048576) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "kinetic_energy_decay" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearKineticEnergyDecay() {
|
|
_hasBits0 &= ~1048576;
|
|
}
|
|
|
|
/// <summary>Field number for the "prior_weight_increase" field.</summary>
|
|
public const int PriorWeightIncreaseFieldNumber = 23;
|
|
private readonly static float PriorWeightIncreaseDefaultValue = 0.2F;
|
|
|
|
private float priorWeightIncrease_;
|
|
/// <summary>
|
|
/// Amount by which prior is increased/decreased in case of valid/invalid
|
|
/// measurements.
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public float PriorWeightIncrease {
|
|
get { if ((_hasBits0 & 2097152) != 0) { return priorWeightIncrease_; } else { return PriorWeightIncreaseDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 2097152;
|
|
priorWeightIncrease_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "prior_weight_increase" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasPriorWeightIncrease {
|
|
get { return (_hasBits0 & 2097152) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "prior_weight_increase" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearPriorWeightIncrease() {
|
|
_hasBits0 &= ~2097152;
|
|
}
|
|
|
|
/// <summary>Field number for the "low_kinetic_energy" field.</summary>
|
|
public const int LowKineticEnergyFieldNumber = 24;
|
|
private readonly static float LowKineticEnergyDefaultValue = 0.001F;
|
|
|
|
private float lowKineticEnergy_;
|
|
/// <summary>
|
|
/// We map the amount of present kinetic energy linearly to the domain [0, 1]
|
|
/// describing if an object is static (0) or moving (1).
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public float LowKineticEnergy {
|
|
get { if ((_hasBits0 & 4194304) != 0) { return lowKineticEnergy_; } else { return LowKineticEnergyDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 4194304;
|
|
lowKineticEnergy_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "low_kinetic_energy" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasLowKineticEnergy {
|
|
get { return (_hasBits0 & 4194304) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "low_kinetic_energy" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearLowKineticEnergy() {
|
|
_hasBits0 &= ~4194304;
|
|
}
|
|
|
|
/// <summary>Field number for the "high_kinetic_energy" field.</summary>
|
|
public const int HighKineticEnergyFieldNumber = 25;
|
|
private readonly static float HighKineticEnergyDefaultValue = 0.004F;
|
|
|
|
private float highKineticEnergy_;
|
|
/// <summary>
|
|
/// ~3 pix
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public float HighKineticEnergy {
|
|
get { if ((_hasBits0 & 8388608) != 0) { return highKineticEnergy_; } else { return HighKineticEnergyDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 8388608;
|
|
highKineticEnergy_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "high_kinetic_energy" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasHighKineticEnergy {
|
|
get { return (_hasBits0 & 8388608) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "high_kinetic_energy" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearHighKineticEnergy() {
|
|
_hasBits0 &= ~8388608;
|
|
}
|
|
|
|
/// <summary>Field number for the "return_internal_state" field.</summary>
|
|
public const int ReturnInternalStateFieldNumber = 26;
|
|
private readonly static bool ReturnInternalStateDefaultValue = false;
|
|
|
|
private bool returnInternalState_;
|
|
/// <summary>
|
|
/// Outputs internal state to MotionBoxState.
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool ReturnInternalState {
|
|
get { if ((_hasBits0 & 16777216) != 0) { return returnInternalState_; } else { return ReturnInternalStateDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 16777216;
|
|
returnInternalState_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "return_internal_state" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasReturnInternalState {
|
|
get { return (_hasBits0 & 16777216) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "return_internal_state" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearReturnInternalState() {
|
|
_hasBits0 &= ~16777216;
|
|
}
|
|
|
|
/// <summary>Field number for the "use_post_estimation_weights_for_state" field.</summary>
|
|
public const int UsePostEstimationWeightsForStateFieldNumber = 29;
|
|
private readonly static bool UsePostEstimationWeightsForStateDefaultValue = true;
|
|
|
|
private bool usePostEstimationWeightsForState_;
|
|
/// <summary>
|
|
/// Specifies which weights are stored in the internal state. By default
|
|
/// post-estimation weights are stored, otherwise pre-estimation weights
|
|
/// are stored.
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool UsePostEstimationWeightsForState {
|
|
get { if ((_hasBits0 & 134217728) != 0) { return usePostEstimationWeightsForState_; } else { return UsePostEstimationWeightsForStateDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 134217728;
|
|
usePostEstimationWeightsForState_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "use_post_estimation_weights_for_state" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasUsePostEstimationWeightsForState {
|
|
get { return (_hasBits0 & 134217728) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "use_post_estimation_weights_for_state" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearUsePostEstimationWeightsForState() {
|
|
_hasBits0 &= ~134217728;
|
|
}
|
|
|
|
/// <summary>Field number for the "compute_spatial_prior" field.</summary>
|
|
public const int ComputeSpatialPriorFieldNumber = 27;
|
|
private readonly static bool ComputeSpatialPriorDefaultValue = false;
|
|
|
|
private bool computeSpatialPrior_;
|
|
/// <summary>
|
|
/// Computes spatial grid of inliers and stores it in the MotionBoxState.
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool ComputeSpatialPrior {
|
|
get { if ((_hasBits0 & 33554432) != 0) { return computeSpatialPrior_; } else { return ComputeSpatialPriorDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 33554432;
|
|
computeSpatialPrior_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "compute_spatial_prior" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasComputeSpatialPrior {
|
|
get { return (_hasBits0 & 33554432) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "compute_spatial_prior" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearComputeSpatialPrior() {
|
|
_hasBits0 &= ~33554432;
|
|
}
|
|
|
|
/// <summary>Field number for the "irls_initialization" field.</summary>
|
|
public const int IrlsInitializationFieldNumber = 30;
|
|
private global::Mediapipe.TrackStepOptions.Types.IrlsInitialization irlsInitialization_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public global::Mediapipe.TrackStepOptions.Types.IrlsInitialization IrlsInitialization {
|
|
get { return irlsInitialization_; }
|
|
set {
|
|
irlsInitialization_ = value;
|
|
}
|
|
}
|
|
|
|
/// <summary>Field number for the "static_motion_temporal_ratio" field.</summary>
|
|
public const int StaticMotionTemporalRatioFieldNumber = 33;
|
|
private readonly static float StaticMotionTemporalRatioDefaultValue = 0.003F;
|
|
|
|
private float staticMotionTemporalRatio_;
|
|
/// <summary>
|
|
/// Ratio between static motion and temporal scale. This is actually
|
|
/// the threshold on speed, under which we consider static (non-moving object).
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public float StaticMotionTemporalRatio {
|
|
get { if ((_hasBits0 & 536870912) != 0) { return staticMotionTemporalRatio_; } else { return StaticMotionTemporalRatioDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 536870912;
|
|
staticMotionTemporalRatio_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "static_motion_temporal_ratio" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasStaticMotionTemporalRatio {
|
|
get { return (_hasBits0 & 536870912) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "static_motion_temporal_ratio" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearStaticMotionTemporalRatio() {
|
|
_hasBits0 &= ~536870912;
|
|
}
|
|
|
|
/// <summary>Field number for the "cancel_tracking_with_occlusion_options" field.</summary>
|
|
public const int CancelTrackingWithOcclusionOptionsFieldNumber = 34;
|
|
private global::Mediapipe.TrackStepOptions.Types.CancelTrackingWithOcclusionOptions cancelTrackingWithOcclusionOptions_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public global::Mediapipe.TrackStepOptions.Types.CancelTrackingWithOcclusionOptions CancelTrackingWithOcclusionOptions {
|
|
get { return cancelTrackingWithOcclusionOptions_; }
|
|
set {
|
|
cancelTrackingWithOcclusionOptions_ = value;
|
|
}
|
|
}
|
|
|
|
/// <summary>Field number for the "object_similarity_min_contd_inliers" field.</summary>
|
|
public const int ObjectSimilarityMinContdInliersFieldNumber = 35;
|
|
private readonly static int ObjectSimilarityMinContdInliersDefaultValue = 30;
|
|
|
|
private int objectSimilarityMinContdInliers_;
|
|
/// <summary>
|
|
/// If number of continued inliers is less than this number, then the object
|
|
/// motion model will fall back to translation model.
|
|
/// Set this min_continued_inliers threshold to a low number to make sure
|
|
/// they follow local object rotation and scale, but it may result in un-robust
|
|
/// rotation and scale estimation if the threshold is too low. Recommend that
|
|
/// you don't set a number < 4.
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public int ObjectSimilarityMinContdInliers {
|
|
get { if ((_hasBits0 & 1073741824) != 0) { return objectSimilarityMinContdInliers_; } else { return ObjectSimilarityMinContdInliersDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 1073741824;
|
|
objectSimilarityMinContdInliers_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "object_similarity_min_contd_inliers" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasObjectSimilarityMinContdInliers {
|
|
get { return (_hasBits0 & 1073741824) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "object_similarity_min_contd_inliers" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearObjectSimilarityMinContdInliers() {
|
|
_hasBits0 &= ~1073741824;
|
|
}
|
|
|
|
/// <summary>Field number for the "box_similarity_max_scale" field.</summary>
|
|
public const int BoxSimilarityMaxScaleFieldNumber = 36;
|
|
private readonly static float BoxSimilarityMaxScaleDefaultValue = 1.05F;
|
|
|
|
private float boxSimilarityMaxScale_;
|
|
/// <summary>
|
|
/// Maximum acceptable scale component of object similarity transform.
|
|
/// Minimum scale is computed as 1.0 / max_scale.
|
|
/// Exclusive for tracking a box with similarity.
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public float BoxSimilarityMaxScale {
|
|
get { if ((_hasBits0 & -2147483648) != 0) { return boxSimilarityMaxScale_; } else { return BoxSimilarityMaxScaleDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= -2147483648;
|
|
boxSimilarityMaxScale_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "box_similarity_max_scale" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasBoxSimilarityMaxScale {
|
|
get { return (_hasBits0 & -2147483648) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "box_similarity_max_scale" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearBoxSimilarityMaxScale() {
|
|
_hasBits0 &= ~-2147483648;
|
|
}
|
|
|
|
/// <summary>Field number for the "box_similarity_max_rotation" field.</summary>
|
|
public const int BoxSimilarityMaxRotationFieldNumber = 37;
|
|
private readonly static float BoxSimilarityMaxRotationDefaultValue = 0.2F;
|
|
|
|
private float boxSimilarityMaxRotation_;
|
|
/// <summary>
|
|
/// Maximum acceptable object similarity rotation in radians.
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public float BoxSimilarityMaxRotation {
|
|
get { if ((_hasBits1 & 1) != 0) { return boxSimilarityMaxRotation_; } else { return BoxSimilarityMaxRotationDefaultValue; } }
|
|
set {
|
|
_hasBits1 |= 1;
|
|
boxSimilarityMaxRotation_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "box_similarity_max_rotation" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasBoxSimilarityMaxRotation {
|
|
get { return (_hasBits1 & 1) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "box_similarity_max_rotation" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearBoxSimilarityMaxRotation() {
|
|
_hasBits1 &= ~1;
|
|
}
|
|
|
|
/// <summary>Field number for the "quad_homography_max_scale" field.</summary>
|
|
public const int QuadHomographyMaxScaleFieldNumber = 38;
|
|
private readonly static float QuadHomographyMaxScaleDefaultValue = 1.2F;
|
|
|
|
private float quadHomographyMaxScale_;
|
|
/// <summary>
|
|
/// Homography transform will first be projected to similarity, and the scale
|
|
/// component of the similarity transform should be within the range of
|
|
/// [1.0 / max_scale, max_scale].
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public float QuadHomographyMaxScale {
|
|
get { if ((_hasBits1 & 2) != 0) { return quadHomographyMaxScale_; } else { return QuadHomographyMaxScaleDefaultValue; } }
|
|
set {
|
|
_hasBits1 |= 2;
|
|
quadHomographyMaxScale_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "quad_homography_max_scale" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasQuadHomographyMaxScale {
|
|
get { return (_hasBits1 & 2) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "quad_homography_max_scale" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearQuadHomographyMaxScale() {
|
|
_hasBits1 &= ~2;
|
|
}
|
|
|
|
/// <summary>Field number for the "quad_homography_max_rotation" field.</summary>
|
|
public const int QuadHomographyMaxRotationFieldNumber = 39;
|
|
private readonly static float QuadHomographyMaxRotationDefaultValue = 0.3F;
|
|
|
|
private float quadHomographyMaxRotation_;
|
|
/// <summary>
|
|
/// The rotation component of the projected similarity should be smaller than
|
|
/// this maximum rotation threshold.
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public float QuadHomographyMaxRotation {
|
|
get { if ((_hasBits1 & 4) != 0) { return quadHomographyMaxRotation_; } else { return QuadHomographyMaxRotationDefaultValue; } }
|
|
set {
|
|
_hasBits1 |= 4;
|
|
quadHomographyMaxRotation_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "quad_homography_max_rotation" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasQuadHomographyMaxRotation {
|
|
get { return (_hasBits1 & 4) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "quad_homography_max_rotation" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearQuadHomographyMaxRotation() {
|
|
_hasBits1 &= ~4;
|
|
}
|
|
|
|
/// <summary>Field number for the "camera_intrinsics" field.</summary>
|
|
public const int CameraIntrinsicsFieldNumber = 40;
|
|
private global::Mediapipe.TrackStepOptions.Types.CameraIntrinsics cameraIntrinsics_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public global::Mediapipe.TrackStepOptions.Types.CameraIntrinsics CameraIntrinsics {
|
|
get { return cameraIntrinsics_; }
|
|
set {
|
|
cameraIntrinsics_ = value;
|
|
}
|
|
}
|
|
|
|
/// <summary>Field number for the "forced_pnp_tracking" field.</summary>
|
|
public const int ForcedPnpTrackingFieldNumber = 41;
|
|
private readonly static bool ForcedPnpTrackingDefaultValue = false;
|
|
|
|
private bool forcedPnpTracking_;
|
|
/// <summary>
|
|
/// Specifically for quad tracking (aka TRACKING_DEGREE_OBJECT_PERSPECTIVE
|
|
/// mode), if aspect_ratio field is set in start pos, pnp tracking will be
|
|
/// deployed. If aspect_ratio is unknown (not set), but forced_pnp_tracking is
|
|
/// true, we will first estimate the aspect ratio for the 3D quadrangle, then
|
|
/// perform pnp tracking. If aspect_ratio is unknown and pnp tracking is not
|
|
/// forced, general homography tracking will be deployed.
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool ForcedPnpTracking {
|
|
get { if ((_hasBits1 & 8) != 0) { return forcedPnpTracking_; } else { return ForcedPnpTrackingDefaultValue; } }
|
|
set {
|
|
_hasBits1 |= 8;
|
|
forcedPnpTracking_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "forced_pnp_tracking" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasForcedPnpTracking {
|
|
get { return (_hasBits1 & 8) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "forced_pnp_tracking" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearForcedPnpTracking() {
|
|
_hasBits1 &= ~8;
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public override bool Equals(object other) {
|
|
return Equals(other as TrackStepOptions);
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool Equals(TrackStepOptions other) {
|
|
if (ReferenceEquals(other, null)) {
|
|
return false;
|
|
}
|
|
if (ReferenceEquals(other, this)) {
|
|
return true;
|
|
}
|
|
if (TrackingDegrees != other.TrackingDegrees) return false;
|
|
if (TrackObjectAndCamera != other.TrackObjectAndCamera) return false;
|
|
if (IrlsIterations != other.IrlsIterations) return false;
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(SpatialSigma, other.SpatialSigma)) return false;
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(MinMotionSigma, other.MinMotionSigma)) return false;
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(RelativeMotionSigma, other.RelativeMotionSigma)) return false;
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(MotionDisparityLowLevel, other.MotionDisparityLowLevel)) return false;
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(MotionDisparityHighLevel, other.MotionDisparityHighLevel)) return false;
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(DisparityDecay, other.DisparityDecay)) return false;
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(MotionPriorWeight, other.MotionPriorWeight)) return false;
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(BackgroundDiscriminationLowLevel, other.BackgroundDiscriminationLowLevel)) return false;
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(BackgroundDiscriminationHighLevel, other.BackgroundDiscriminationHighLevel)) return false;
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(InlierCenterRelativeDistance, other.InlierCenterRelativeDistance)) return false;
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(InlierSpringForce, other.InlierSpringForce)) return false;
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(KineticCenterRelativeDistance, other.KineticCenterRelativeDistance)) return false;
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(KineticSpringForce, other.KineticSpringForce)) return false;
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(KineticSpringForceMinKineticEnergy, other.KineticSpringForceMinKineticEnergy)) return false;
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(VelocityUpdateWeight, other.VelocityUpdateWeight)) return false;
|
|
if (MaxTrackFailures != other.MaxTrackFailures) return false;
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(ExpansionSize, other.ExpansionSize)) return false;
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(InlierLowWeight, other.InlierLowWeight)) return false;
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(InlierHighWeight, other.InlierHighWeight)) return false;
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(KineticEnergyDecay, other.KineticEnergyDecay)) return false;
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(PriorWeightIncrease, other.PriorWeightIncrease)) return false;
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(LowKineticEnergy, other.LowKineticEnergy)) return false;
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(HighKineticEnergy, other.HighKineticEnergy)) return false;
|
|
if (ReturnInternalState != other.ReturnInternalState) return false;
|
|
if (UsePostEstimationWeightsForState != other.UsePostEstimationWeightsForState) return false;
|
|
if (ComputeSpatialPrior != other.ComputeSpatialPrior) return false;
|
|
if (!object.Equals(IrlsInitialization, other.IrlsInitialization)) return false;
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(StaticMotionTemporalRatio, other.StaticMotionTemporalRatio)) return false;
|
|
if (!object.Equals(CancelTrackingWithOcclusionOptions, other.CancelTrackingWithOcclusionOptions)) return false;
|
|
if (ObjectSimilarityMinContdInliers != other.ObjectSimilarityMinContdInliers) return false;
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(BoxSimilarityMaxScale, other.BoxSimilarityMaxScale)) return false;
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(BoxSimilarityMaxRotation, other.BoxSimilarityMaxRotation)) return false;
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(QuadHomographyMaxScale, other.QuadHomographyMaxScale)) return false;
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(QuadHomographyMaxRotation, other.QuadHomographyMaxRotation)) return false;
|
|
if (!object.Equals(CameraIntrinsics, other.CameraIntrinsics)) return false;
|
|
if (ForcedPnpTracking != other.ForcedPnpTracking) 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 (HasTrackingDegrees) hash ^= TrackingDegrees.GetHashCode();
|
|
if (HasTrackObjectAndCamera) hash ^= TrackObjectAndCamera.GetHashCode();
|
|
if (HasIrlsIterations) hash ^= IrlsIterations.GetHashCode();
|
|
if (HasSpatialSigma) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(SpatialSigma);
|
|
if (HasMinMotionSigma) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(MinMotionSigma);
|
|
if (HasRelativeMotionSigma) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(RelativeMotionSigma);
|
|
if (HasMotionDisparityLowLevel) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(MotionDisparityLowLevel);
|
|
if (HasMotionDisparityHighLevel) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(MotionDisparityHighLevel);
|
|
if (HasDisparityDecay) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(DisparityDecay);
|
|
if (HasMotionPriorWeight) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(MotionPriorWeight);
|
|
if (HasBackgroundDiscriminationLowLevel) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(BackgroundDiscriminationLowLevel);
|
|
if (HasBackgroundDiscriminationHighLevel) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(BackgroundDiscriminationHighLevel);
|
|
if (HasInlierCenterRelativeDistance) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(InlierCenterRelativeDistance);
|
|
if (HasInlierSpringForce) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(InlierSpringForce);
|
|
if (HasKineticCenterRelativeDistance) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(KineticCenterRelativeDistance);
|
|
if (HasKineticSpringForce) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(KineticSpringForce);
|
|
if (HasKineticSpringForceMinKineticEnergy) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(KineticSpringForceMinKineticEnergy);
|
|
if (HasVelocityUpdateWeight) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(VelocityUpdateWeight);
|
|
if (HasMaxTrackFailures) hash ^= MaxTrackFailures.GetHashCode();
|
|
if (HasExpansionSize) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(ExpansionSize);
|
|
if (HasInlierLowWeight) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(InlierLowWeight);
|
|
if (HasInlierHighWeight) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(InlierHighWeight);
|
|
if (HasKineticEnergyDecay) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(KineticEnergyDecay);
|
|
if (HasPriorWeightIncrease) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(PriorWeightIncrease);
|
|
if (HasLowKineticEnergy) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(LowKineticEnergy);
|
|
if (HasHighKineticEnergy) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(HighKineticEnergy);
|
|
if (HasReturnInternalState) hash ^= ReturnInternalState.GetHashCode();
|
|
if (HasUsePostEstimationWeightsForState) hash ^= UsePostEstimationWeightsForState.GetHashCode();
|
|
if (HasComputeSpatialPrior) hash ^= ComputeSpatialPrior.GetHashCode();
|
|
if (irlsInitialization_ != null) hash ^= IrlsInitialization.GetHashCode();
|
|
if (HasStaticMotionTemporalRatio) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(StaticMotionTemporalRatio);
|
|
if (cancelTrackingWithOcclusionOptions_ != null) hash ^= CancelTrackingWithOcclusionOptions.GetHashCode();
|
|
if (HasObjectSimilarityMinContdInliers) hash ^= ObjectSimilarityMinContdInliers.GetHashCode();
|
|
if (HasBoxSimilarityMaxScale) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(BoxSimilarityMaxScale);
|
|
if (HasBoxSimilarityMaxRotation) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(BoxSimilarityMaxRotation);
|
|
if (HasQuadHomographyMaxScale) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(QuadHomographyMaxScale);
|
|
if (HasQuadHomographyMaxRotation) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(QuadHomographyMaxRotation);
|
|
if (cameraIntrinsics_ != null) hash ^= CameraIntrinsics.GetHashCode();
|
|
if (HasForcedPnpTracking) hash ^= ForcedPnpTracking.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 (HasIrlsIterations) {
|
|
output.WriteRawTag(8);
|
|
output.WriteInt32(IrlsIterations);
|
|
}
|
|
if (HasSpatialSigma) {
|
|
output.WriteRawTag(21);
|
|
output.WriteFloat(SpatialSigma);
|
|
}
|
|
if (HasMinMotionSigma) {
|
|
output.WriteRawTag(29);
|
|
output.WriteFloat(MinMotionSigma);
|
|
}
|
|
if (HasRelativeMotionSigma) {
|
|
output.WriteRawTag(37);
|
|
output.WriteFloat(RelativeMotionSigma);
|
|
}
|
|
if (HasMotionDisparityLowLevel) {
|
|
output.WriteRawTag(53);
|
|
output.WriteFloat(MotionDisparityLowLevel);
|
|
}
|
|
if (HasMotionDisparityHighLevel) {
|
|
output.WriteRawTag(61);
|
|
output.WriteFloat(MotionDisparityHighLevel);
|
|
}
|
|
if (HasDisparityDecay) {
|
|
output.WriteRawTag(69);
|
|
output.WriteFloat(DisparityDecay);
|
|
}
|
|
if (HasMotionPriorWeight) {
|
|
output.WriteRawTag(77);
|
|
output.WriteFloat(MotionPriorWeight);
|
|
}
|
|
if (HasBackgroundDiscriminationLowLevel) {
|
|
output.WriteRawTag(85);
|
|
output.WriteFloat(BackgroundDiscriminationLowLevel);
|
|
}
|
|
if (HasBackgroundDiscriminationHighLevel) {
|
|
output.WriteRawTag(93);
|
|
output.WriteFloat(BackgroundDiscriminationHighLevel);
|
|
}
|
|
if (HasInlierCenterRelativeDistance) {
|
|
output.WriteRawTag(101);
|
|
output.WriteFloat(InlierCenterRelativeDistance);
|
|
}
|
|
if (HasInlierSpringForce) {
|
|
output.WriteRawTag(109);
|
|
output.WriteFloat(InlierSpringForce);
|
|
}
|
|
if (HasKineticCenterRelativeDistance) {
|
|
output.WriteRawTag(117);
|
|
output.WriteFloat(KineticCenterRelativeDistance);
|
|
}
|
|
if (HasKineticSpringForce) {
|
|
output.WriteRawTag(125);
|
|
output.WriteFloat(KineticSpringForce);
|
|
}
|
|
if (HasVelocityUpdateWeight) {
|
|
output.WriteRawTag(133, 1);
|
|
output.WriteFloat(VelocityUpdateWeight);
|
|
}
|
|
if (HasMaxTrackFailures) {
|
|
output.WriteRawTag(136, 1);
|
|
output.WriteInt32(MaxTrackFailures);
|
|
}
|
|
if (HasExpansionSize) {
|
|
output.WriteRawTag(149, 1);
|
|
output.WriteFloat(ExpansionSize);
|
|
}
|
|
if (HasInlierLowWeight) {
|
|
output.WriteRawTag(157, 1);
|
|
output.WriteFloat(InlierLowWeight);
|
|
}
|
|
if (HasInlierHighWeight) {
|
|
output.WriteRawTag(165, 1);
|
|
output.WriteFloat(InlierHighWeight);
|
|
}
|
|
if (HasKineticSpringForceMinKineticEnergy) {
|
|
output.WriteRawTag(173, 1);
|
|
output.WriteFloat(KineticSpringForceMinKineticEnergy);
|
|
}
|
|
if (HasKineticEnergyDecay) {
|
|
output.WriteRawTag(181, 1);
|
|
output.WriteFloat(KineticEnergyDecay);
|
|
}
|
|
if (HasPriorWeightIncrease) {
|
|
output.WriteRawTag(189, 1);
|
|
output.WriteFloat(PriorWeightIncrease);
|
|
}
|
|
if (HasLowKineticEnergy) {
|
|
output.WriteRawTag(197, 1);
|
|
output.WriteFloat(LowKineticEnergy);
|
|
}
|
|
if (HasHighKineticEnergy) {
|
|
output.WriteRawTag(205, 1);
|
|
output.WriteFloat(HighKineticEnergy);
|
|
}
|
|
if (HasReturnInternalState) {
|
|
output.WriteRawTag(208, 1);
|
|
output.WriteBool(ReturnInternalState);
|
|
}
|
|
if (HasComputeSpatialPrior) {
|
|
output.WriteRawTag(216, 1);
|
|
output.WriteBool(ComputeSpatialPrior);
|
|
}
|
|
if (HasTrackingDegrees) {
|
|
output.WriteRawTag(224, 1);
|
|
output.WriteEnum((int) TrackingDegrees);
|
|
}
|
|
if (HasUsePostEstimationWeightsForState) {
|
|
output.WriteRawTag(232, 1);
|
|
output.WriteBool(UsePostEstimationWeightsForState);
|
|
}
|
|
if (irlsInitialization_ != null) {
|
|
output.WriteRawTag(242, 1);
|
|
output.WriteMessage(IrlsInitialization);
|
|
}
|
|
if (HasTrackObjectAndCamera) {
|
|
output.WriteRawTag(128, 2);
|
|
output.WriteBool(TrackObjectAndCamera);
|
|
}
|
|
if (HasStaticMotionTemporalRatio) {
|
|
output.WriteRawTag(141, 2);
|
|
output.WriteFloat(StaticMotionTemporalRatio);
|
|
}
|
|
if (cancelTrackingWithOcclusionOptions_ != null) {
|
|
output.WriteRawTag(146, 2);
|
|
output.WriteMessage(CancelTrackingWithOcclusionOptions);
|
|
}
|
|
if (HasObjectSimilarityMinContdInliers) {
|
|
output.WriteRawTag(152, 2);
|
|
output.WriteInt32(ObjectSimilarityMinContdInliers);
|
|
}
|
|
if (HasBoxSimilarityMaxScale) {
|
|
output.WriteRawTag(165, 2);
|
|
output.WriteFloat(BoxSimilarityMaxScale);
|
|
}
|
|
if (HasBoxSimilarityMaxRotation) {
|
|
output.WriteRawTag(173, 2);
|
|
output.WriteFloat(BoxSimilarityMaxRotation);
|
|
}
|
|
if (HasQuadHomographyMaxScale) {
|
|
output.WriteRawTag(181, 2);
|
|
output.WriteFloat(QuadHomographyMaxScale);
|
|
}
|
|
if (HasQuadHomographyMaxRotation) {
|
|
output.WriteRawTag(189, 2);
|
|
output.WriteFloat(QuadHomographyMaxRotation);
|
|
}
|
|
if (cameraIntrinsics_ != null) {
|
|
output.WriteRawTag(194, 2);
|
|
output.WriteMessage(CameraIntrinsics);
|
|
}
|
|
if (HasForcedPnpTracking) {
|
|
output.WriteRawTag(200, 2);
|
|
output.WriteBool(ForcedPnpTracking);
|
|
}
|
|
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 (HasIrlsIterations) {
|
|
output.WriteRawTag(8);
|
|
output.WriteInt32(IrlsIterations);
|
|
}
|
|
if (HasSpatialSigma) {
|
|
output.WriteRawTag(21);
|
|
output.WriteFloat(SpatialSigma);
|
|
}
|
|
if (HasMinMotionSigma) {
|
|
output.WriteRawTag(29);
|
|
output.WriteFloat(MinMotionSigma);
|
|
}
|
|
if (HasRelativeMotionSigma) {
|
|
output.WriteRawTag(37);
|
|
output.WriteFloat(RelativeMotionSigma);
|
|
}
|
|
if (HasMotionDisparityLowLevel) {
|
|
output.WriteRawTag(53);
|
|
output.WriteFloat(MotionDisparityLowLevel);
|
|
}
|
|
if (HasMotionDisparityHighLevel) {
|
|
output.WriteRawTag(61);
|
|
output.WriteFloat(MotionDisparityHighLevel);
|
|
}
|
|
if (HasDisparityDecay) {
|
|
output.WriteRawTag(69);
|
|
output.WriteFloat(DisparityDecay);
|
|
}
|
|
if (HasMotionPriorWeight) {
|
|
output.WriteRawTag(77);
|
|
output.WriteFloat(MotionPriorWeight);
|
|
}
|
|
if (HasBackgroundDiscriminationLowLevel) {
|
|
output.WriteRawTag(85);
|
|
output.WriteFloat(BackgroundDiscriminationLowLevel);
|
|
}
|
|
if (HasBackgroundDiscriminationHighLevel) {
|
|
output.WriteRawTag(93);
|
|
output.WriteFloat(BackgroundDiscriminationHighLevel);
|
|
}
|
|
if (HasInlierCenterRelativeDistance) {
|
|
output.WriteRawTag(101);
|
|
output.WriteFloat(InlierCenterRelativeDistance);
|
|
}
|
|
if (HasInlierSpringForce) {
|
|
output.WriteRawTag(109);
|
|
output.WriteFloat(InlierSpringForce);
|
|
}
|
|
if (HasKineticCenterRelativeDistance) {
|
|
output.WriteRawTag(117);
|
|
output.WriteFloat(KineticCenterRelativeDistance);
|
|
}
|
|
if (HasKineticSpringForce) {
|
|
output.WriteRawTag(125);
|
|
output.WriteFloat(KineticSpringForce);
|
|
}
|
|
if (HasVelocityUpdateWeight) {
|
|
output.WriteRawTag(133, 1);
|
|
output.WriteFloat(VelocityUpdateWeight);
|
|
}
|
|
if (HasMaxTrackFailures) {
|
|
output.WriteRawTag(136, 1);
|
|
output.WriteInt32(MaxTrackFailures);
|
|
}
|
|
if (HasExpansionSize) {
|
|
output.WriteRawTag(149, 1);
|
|
output.WriteFloat(ExpansionSize);
|
|
}
|
|
if (HasInlierLowWeight) {
|
|
output.WriteRawTag(157, 1);
|
|
output.WriteFloat(InlierLowWeight);
|
|
}
|
|
if (HasInlierHighWeight) {
|
|
output.WriteRawTag(165, 1);
|
|
output.WriteFloat(InlierHighWeight);
|
|
}
|
|
if (HasKineticSpringForceMinKineticEnergy) {
|
|
output.WriteRawTag(173, 1);
|
|
output.WriteFloat(KineticSpringForceMinKineticEnergy);
|
|
}
|
|
if (HasKineticEnergyDecay) {
|
|
output.WriteRawTag(181, 1);
|
|
output.WriteFloat(KineticEnergyDecay);
|
|
}
|
|
if (HasPriorWeightIncrease) {
|
|
output.WriteRawTag(189, 1);
|
|
output.WriteFloat(PriorWeightIncrease);
|
|
}
|
|
if (HasLowKineticEnergy) {
|
|
output.WriteRawTag(197, 1);
|
|
output.WriteFloat(LowKineticEnergy);
|
|
}
|
|
if (HasHighKineticEnergy) {
|
|
output.WriteRawTag(205, 1);
|
|
output.WriteFloat(HighKineticEnergy);
|
|
}
|
|
if (HasReturnInternalState) {
|
|
output.WriteRawTag(208, 1);
|
|
output.WriteBool(ReturnInternalState);
|
|
}
|
|
if (HasComputeSpatialPrior) {
|
|
output.WriteRawTag(216, 1);
|
|
output.WriteBool(ComputeSpatialPrior);
|
|
}
|
|
if (HasTrackingDegrees) {
|
|
output.WriteRawTag(224, 1);
|
|
output.WriteEnum((int) TrackingDegrees);
|
|
}
|
|
if (HasUsePostEstimationWeightsForState) {
|
|
output.WriteRawTag(232, 1);
|
|
output.WriteBool(UsePostEstimationWeightsForState);
|
|
}
|
|
if (irlsInitialization_ != null) {
|
|
output.WriteRawTag(242, 1);
|
|
output.WriteMessage(IrlsInitialization);
|
|
}
|
|
if (HasTrackObjectAndCamera) {
|
|
output.WriteRawTag(128, 2);
|
|
output.WriteBool(TrackObjectAndCamera);
|
|
}
|
|
if (HasStaticMotionTemporalRatio) {
|
|
output.WriteRawTag(141, 2);
|
|
output.WriteFloat(StaticMotionTemporalRatio);
|
|
}
|
|
if (cancelTrackingWithOcclusionOptions_ != null) {
|
|
output.WriteRawTag(146, 2);
|
|
output.WriteMessage(CancelTrackingWithOcclusionOptions);
|
|
}
|
|
if (HasObjectSimilarityMinContdInliers) {
|
|
output.WriteRawTag(152, 2);
|
|
output.WriteInt32(ObjectSimilarityMinContdInliers);
|
|
}
|
|
if (HasBoxSimilarityMaxScale) {
|
|
output.WriteRawTag(165, 2);
|
|
output.WriteFloat(BoxSimilarityMaxScale);
|
|
}
|
|
if (HasBoxSimilarityMaxRotation) {
|
|
output.WriteRawTag(173, 2);
|
|
output.WriteFloat(BoxSimilarityMaxRotation);
|
|
}
|
|
if (HasQuadHomographyMaxScale) {
|
|
output.WriteRawTag(181, 2);
|
|
output.WriteFloat(QuadHomographyMaxScale);
|
|
}
|
|
if (HasQuadHomographyMaxRotation) {
|
|
output.WriteRawTag(189, 2);
|
|
output.WriteFloat(QuadHomographyMaxRotation);
|
|
}
|
|
if (cameraIntrinsics_ != null) {
|
|
output.WriteRawTag(194, 2);
|
|
output.WriteMessage(CameraIntrinsics);
|
|
}
|
|
if (HasForcedPnpTracking) {
|
|
output.WriteRawTag(200, 2);
|
|
output.WriteBool(ForcedPnpTracking);
|
|
}
|
|
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 (HasTrackingDegrees) {
|
|
size += 2 + pb::CodedOutputStream.ComputeEnumSize((int) TrackingDegrees);
|
|
}
|
|
if (HasTrackObjectAndCamera) {
|
|
size += 2 + 1;
|
|
}
|
|
if (HasIrlsIterations) {
|
|
size += 1 + pb::CodedOutputStream.ComputeInt32Size(IrlsIterations);
|
|
}
|
|
if (HasSpatialSigma) {
|
|
size += 1 + 4;
|
|
}
|
|
if (HasMinMotionSigma) {
|
|
size += 1 + 4;
|
|
}
|
|
if (HasRelativeMotionSigma) {
|
|
size += 1 + 4;
|
|
}
|
|
if (HasMotionDisparityLowLevel) {
|
|
size += 1 + 4;
|
|
}
|
|
if (HasMotionDisparityHighLevel) {
|
|
size += 1 + 4;
|
|
}
|
|
if (HasDisparityDecay) {
|
|
size += 1 + 4;
|
|
}
|
|
if (HasMotionPriorWeight) {
|
|
size += 1 + 4;
|
|
}
|
|
if (HasBackgroundDiscriminationLowLevel) {
|
|
size += 1 + 4;
|
|
}
|
|
if (HasBackgroundDiscriminationHighLevel) {
|
|
size += 1 + 4;
|
|
}
|
|
if (HasInlierCenterRelativeDistance) {
|
|
size += 1 + 4;
|
|
}
|
|
if (HasInlierSpringForce) {
|
|
size += 1 + 4;
|
|
}
|
|
if (HasKineticCenterRelativeDistance) {
|
|
size += 1 + 4;
|
|
}
|
|
if (HasKineticSpringForce) {
|
|
size += 1 + 4;
|
|
}
|
|
if (HasKineticSpringForceMinKineticEnergy) {
|
|
size += 2 + 4;
|
|
}
|
|
if (HasVelocityUpdateWeight) {
|
|
size += 2 + 4;
|
|
}
|
|
if (HasMaxTrackFailures) {
|
|
size += 2 + pb::CodedOutputStream.ComputeInt32Size(MaxTrackFailures);
|
|
}
|
|
if (HasExpansionSize) {
|
|
size += 2 + 4;
|
|
}
|
|
if (HasInlierLowWeight) {
|
|
size += 2 + 4;
|
|
}
|
|
if (HasInlierHighWeight) {
|
|
size += 2 + 4;
|
|
}
|
|
if (HasKineticEnergyDecay) {
|
|
size += 2 + 4;
|
|
}
|
|
if (HasPriorWeightIncrease) {
|
|
size += 2 + 4;
|
|
}
|
|
if (HasLowKineticEnergy) {
|
|
size += 2 + 4;
|
|
}
|
|
if (HasHighKineticEnergy) {
|
|
size += 2 + 4;
|
|
}
|
|
if (HasReturnInternalState) {
|
|
size += 2 + 1;
|
|
}
|
|
if (HasUsePostEstimationWeightsForState) {
|
|
size += 2 + 1;
|
|
}
|
|
if (HasComputeSpatialPrior) {
|
|
size += 2 + 1;
|
|
}
|
|
if (irlsInitialization_ != null) {
|
|
size += 2 + pb::CodedOutputStream.ComputeMessageSize(IrlsInitialization);
|
|
}
|
|
if (HasStaticMotionTemporalRatio) {
|
|
size += 2 + 4;
|
|
}
|
|
if (cancelTrackingWithOcclusionOptions_ != null) {
|
|
size += 2 + pb::CodedOutputStream.ComputeMessageSize(CancelTrackingWithOcclusionOptions);
|
|
}
|
|
if (HasObjectSimilarityMinContdInliers) {
|
|
size += 2 + pb::CodedOutputStream.ComputeInt32Size(ObjectSimilarityMinContdInliers);
|
|
}
|
|
if (HasBoxSimilarityMaxScale) {
|
|
size += 2 + 4;
|
|
}
|
|
if (HasBoxSimilarityMaxRotation) {
|
|
size += 2 + 4;
|
|
}
|
|
if (HasQuadHomographyMaxScale) {
|
|
size += 2 + 4;
|
|
}
|
|
if (HasQuadHomographyMaxRotation) {
|
|
size += 2 + 4;
|
|
}
|
|
if (cameraIntrinsics_ != null) {
|
|
size += 2 + pb::CodedOutputStream.ComputeMessageSize(CameraIntrinsics);
|
|
}
|
|
if (HasForcedPnpTracking) {
|
|
size += 2 + 1;
|
|
}
|
|
if (_unknownFields != null) {
|
|
size += _unknownFields.CalculateSize();
|
|
}
|
|
return size;
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void MergeFrom(TrackStepOptions other) {
|
|
if (other == null) {
|
|
return;
|
|
}
|
|
if (other.HasTrackingDegrees) {
|
|
TrackingDegrees = other.TrackingDegrees;
|
|
}
|
|
if (other.HasTrackObjectAndCamera) {
|
|
TrackObjectAndCamera = other.TrackObjectAndCamera;
|
|
}
|
|
if (other.HasIrlsIterations) {
|
|
IrlsIterations = other.IrlsIterations;
|
|
}
|
|
if (other.HasSpatialSigma) {
|
|
SpatialSigma = other.SpatialSigma;
|
|
}
|
|
if (other.HasMinMotionSigma) {
|
|
MinMotionSigma = other.MinMotionSigma;
|
|
}
|
|
if (other.HasRelativeMotionSigma) {
|
|
RelativeMotionSigma = other.RelativeMotionSigma;
|
|
}
|
|
if (other.HasMotionDisparityLowLevel) {
|
|
MotionDisparityLowLevel = other.MotionDisparityLowLevel;
|
|
}
|
|
if (other.HasMotionDisparityHighLevel) {
|
|
MotionDisparityHighLevel = other.MotionDisparityHighLevel;
|
|
}
|
|
if (other.HasDisparityDecay) {
|
|
DisparityDecay = other.DisparityDecay;
|
|
}
|
|
if (other.HasMotionPriorWeight) {
|
|
MotionPriorWeight = other.MotionPriorWeight;
|
|
}
|
|
if (other.HasBackgroundDiscriminationLowLevel) {
|
|
BackgroundDiscriminationLowLevel = other.BackgroundDiscriminationLowLevel;
|
|
}
|
|
if (other.HasBackgroundDiscriminationHighLevel) {
|
|
BackgroundDiscriminationHighLevel = other.BackgroundDiscriminationHighLevel;
|
|
}
|
|
if (other.HasInlierCenterRelativeDistance) {
|
|
InlierCenterRelativeDistance = other.InlierCenterRelativeDistance;
|
|
}
|
|
if (other.HasInlierSpringForce) {
|
|
InlierSpringForce = other.InlierSpringForce;
|
|
}
|
|
if (other.HasKineticCenterRelativeDistance) {
|
|
KineticCenterRelativeDistance = other.KineticCenterRelativeDistance;
|
|
}
|
|
if (other.HasKineticSpringForce) {
|
|
KineticSpringForce = other.KineticSpringForce;
|
|
}
|
|
if (other.HasKineticSpringForceMinKineticEnergy) {
|
|
KineticSpringForceMinKineticEnergy = other.KineticSpringForceMinKineticEnergy;
|
|
}
|
|
if (other.HasVelocityUpdateWeight) {
|
|
VelocityUpdateWeight = other.VelocityUpdateWeight;
|
|
}
|
|
if (other.HasMaxTrackFailures) {
|
|
MaxTrackFailures = other.MaxTrackFailures;
|
|
}
|
|
if (other.HasExpansionSize) {
|
|
ExpansionSize = other.ExpansionSize;
|
|
}
|
|
if (other.HasInlierLowWeight) {
|
|
InlierLowWeight = other.InlierLowWeight;
|
|
}
|
|
if (other.HasInlierHighWeight) {
|
|
InlierHighWeight = other.InlierHighWeight;
|
|
}
|
|
if (other.HasKineticEnergyDecay) {
|
|
KineticEnergyDecay = other.KineticEnergyDecay;
|
|
}
|
|
if (other.HasPriorWeightIncrease) {
|
|
PriorWeightIncrease = other.PriorWeightIncrease;
|
|
}
|
|
if (other.HasLowKineticEnergy) {
|
|
LowKineticEnergy = other.LowKineticEnergy;
|
|
}
|
|
if (other.HasHighKineticEnergy) {
|
|
HighKineticEnergy = other.HighKineticEnergy;
|
|
}
|
|
if (other.HasReturnInternalState) {
|
|
ReturnInternalState = other.ReturnInternalState;
|
|
}
|
|
if (other.HasUsePostEstimationWeightsForState) {
|
|
UsePostEstimationWeightsForState = other.UsePostEstimationWeightsForState;
|
|
}
|
|
if (other.HasComputeSpatialPrior) {
|
|
ComputeSpatialPrior = other.ComputeSpatialPrior;
|
|
}
|
|
if (other.irlsInitialization_ != null) {
|
|
if (irlsInitialization_ == null) {
|
|
IrlsInitialization = new global::Mediapipe.TrackStepOptions.Types.IrlsInitialization();
|
|
}
|
|
IrlsInitialization.MergeFrom(other.IrlsInitialization);
|
|
}
|
|
if (other.HasStaticMotionTemporalRatio) {
|
|
StaticMotionTemporalRatio = other.StaticMotionTemporalRatio;
|
|
}
|
|
if (other.cancelTrackingWithOcclusionOptions_ != null) {
|
|
if (cancelTrackingWithOcclusionOptions_ == null) {
|
|
CancelTrackingWithOcclusionOptions = new global::Mediapipe.TrackStepOptions.Types.CancelTrackingWithOcclusionOptions();
|
|
}
|
|
CancelTrackingWithOcclusionOptions.MergeFrom(other.CancelTrackingWithOcclusionOptions);
|
|
}
|
|
if (other.HasObjectSimilarityMinContdInliers) {
|
|
ObjectSimilarityMinContdInliers = other.ObjectSimilarityMinContdInliers;
|
|
}
|
|
if (other.HasBoxSimilarityMaxScale) {
|
|
BoxSimilarityMaxScale = other.BoxSimilarityMaxScale;
|
|
}
|
|
if (other.HasBoxSimilarityMaxRotation) {
|
|
BoxSimilarityMaxRotation = other.BoxSimilarityMaxRotation;
|
|
}
|
|
if (other.HasQuadHomographyMaxScale) {
|
|
QuadHomographyMaxScale = other.QuadHomographyMaxScale;
|
|
}
|
|
if (other.HasQuadHomographyMaxRotation) {
|
|
QuadHomographyMaxRotation = other.QuadHomographyMaxRotation;
|
|
}
|
|
if (other.cameraIntrinsics_ != null) {
|
|
if (cameraIntrinsics_ == null) {
|
|
CameraIntrinsics = new global::Mediapipe.TrackStepOptions.Types.CameraIntrinsics();
|
|
}
|
|
CameraIntrinsics.MergeFrom(other.CameraIntrinsics);
|
|
}
|
|
if (other.HasForcedPnpTracking) {
|
|
ForcedPnpTracking = other.ForcedPnpTracking;
|
|
}
|
|
_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: {
|
|
IrlsIterations = input.ReadInt32();
|
|
break;
|
|
}
|
|
case 21: {
|
|
SpatialSigma = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 29: {
|
|
MinMotionSigma = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 37: {
|
|
RelativeMotionSigma = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 53: {
|
|
MotionDisparityLowLevel = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 61: {
|
|
MotionDisparityHighLevel = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 69: {
|
|
DisparityDecay = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 77: {
|
|
MotionPriorWeight = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 85: {
|
|
BackgroundDiscriminationLowLevel = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 93: {
|
|
BackgroundDiscriminationHighLevel = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 101: {
|
|
InlierCenterRelativeDistance = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 109: {
|
|
InlierSpringForce = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 117: {
|
|
KineticCenterRelativeDistance = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 125: {
|
|
KineticSpringForce = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 133: {
|
|
VelocityUpdateWeight = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 136: {
|
|
MaxTrackFailures = input.ReadInt32();
|
|
break;
|
|
}
|
|
case 149: {
|
|
ExpansionSize = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 157: {
|
|
InlierLowWeight = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 165: {
|
|
InlierHighWeight = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 173: {
|
|
KineticSpringForceMinKineticEnergy = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 181: {
|
|
KineticEnergyDecay = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 189: {
|
|
PriorWeightIncrease = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 197: {
|
|
LowKineticEnergy = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 205: {
|
|
HighKineticEnergy = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 208: {
|
|
ReturnInternalState = input.ReadBool();
|
|
break;
|
|
}
|
|
case 216: {
|
|
ComputeSpatialPrior = input.ReadBool();
|
|
break;
|
|
}
|
|
case 224: {
|
|
TrackingDegrees = (global::Mediapipe.TrackStepOptions.Types.TrackingDegrees) input.ReadEnum();
|
|
break;
|
|
}
|
|
case 232: {
|
|
UsePostEstimationWeightsForState = input.ReadBool();
|
|
break;
|
|
}
|
|
case 242: {
|
|
if (irlsInitialization_ == null) {
|
|
IrlsInitialization = new global::Mediapipe.TrackStepOptions.Types.IrlsInitialization();
|
|
}
|
|
input.ReadMessage(IrlsInitialization);
|
|
break;
|
|
}
|
|
case 256: {
|
|
TrackObjectAndCamera = input.ReadBool();
|
|
break;
|
|
}
|
|
case 269: {
|
|
StaticMotionTemporalRatio = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 274: {
|
|
if (cancelTrackingWithOcclusionOptions_ == null) {
|
|
CancelTrackingWithOcclusionOptions = new global::Mediapipe.TrackStepOptions.Types.CancelTrackingWithOcclusionOptions();
|
|
}
|
|
input.ReadMessage(CancelTrackingWithOcclusionOptions);
|
|
break;
|
|
}
|
|
case 280: {
|
|
ObjectSimilarityMinContdInliers = input.ReadInt32();
|
|
break;
|
|
}
|
|
case 293: {
|
|
BoxSimilarityMaxScale = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 301: {
|
|
BoxSimilarityMaxRotation = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 309: {
|
|
QuadHomographyMaxScale = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 317: {
|
|
QuadHomographyMaxRotation = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 322: {
|
|
if (cameraIntrinsics_ == null) {
|
|
CameraIntrinsics = new global::Mediapipe.TrackStepOptions.Types.CameraIntrinsics();
|
|
}
|
|
input.ReadMessage(CameraIntrinsics);
|
|
break;
|
|
}
|
|
case 328: {
|
|
ForcedPnpTracking = input.ReadBool();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
#if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
|
|
uint tag;
|
|
while ((tag = input.ReadTag()) != 0) {
|
|
switch(tag) {
|
|
default:
|
|
_unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
|
|
break;
|
|
case 8: {
|
|
IrlsIterations = input.ReadInt32();
|
|
break;
|
|
}
|
|
case 21: {
|
|
SpatialSigma = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 29: {
|
|
MinMotionSigma = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 37: {
|
|
RelativeMotionSigma = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 53: {
|
|
MotionDisparityLowLevel = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 61: {
|
|
MotionDisparityHighLevel = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 69: {
|
|
DisparityDecay = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 77: {
|
|
MotionPriorWeight = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 85: {
|
|
BackgroundDiscriminationLowLevel = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 93: {
|
|
BackgroundDiscriminationHighLevel = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 101: {
|
|
InlierCenterRelativeDistance = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 109: {
|
|
InlierSpringForce = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 117: {
|
|
KineticCenterRelativeDistance = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 125: {
|
|
KineticSpringForce = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 133: {
|
|
VelocityUpdateWeight = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 136: {
|
|
MaxTrackFailures = input.ReadInt32();
|
|
break;
|
|
}
|
|
case 149: {
|
|
ExpansionSize = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 157: {
|
|
InlierLowWeight = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 165: {
|
|
InlierHighWeight = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 173: {
|
|
KineticSpringForceMinKineticEnergy = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 181: {
|
|
KineticEnergyDecay = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 189: {
|
|
PriorWeightIncrease = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 197: {
|
|
LowKineticEnergy = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 205: {
|
|
HighKineticEnergy = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 208: {
|
|
ReturnInternalState = input.ReadBool();
|
|
break;
|
|
}
|
|
case 216: {
|
|
ComputeSpatialPrior = input.ReadBool();
|
|
break;
|
|
}
|
|
case 224: {
|
|
TrackingDegrees = (global::Mediapipe.TrackStepOptions.Types.TrackingDegrees) input.ReadEnum();
|
|
break;
|
|
}
|
|
case 232: {
|
|
UsePostEstimationWeightsForState = input.ReadBool();
|
|
break;
|
|
}
|
|
case 242: {
|
|
if (irlsInitialization_ == null) {
|
|
IrlsInitialization = new global::Mediapipe.TrackStepOptions.Types.IrlsInitialization();
|
|
}
|
|
input.ReadMessage(IrlsInitialization);
|
|
break;
|
|
}
|
|
case 256: {
|
|
TrackObjectAndCamera = input.ReadBool();
|
|
break;
|
|
}
|
|
case 269: {
|
|
StaticMotionTemporalRatio = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 274: {
|
|
if (cancelTrackingWithOcclusionOptions_ == null) {
|
|
CancelTrackingWithOcclusionOptions = new global::Mediapipe.TrackStepOptions.Types.CancelTrackingWithOcclusionOptions();
|
|
}
|
|
input.ReadMessage(CancelTrackingWithOcclusionOptions);
|
|
break;
|
|
}
|
|
case 280: {
|
|
ObjectSimilarityMinContdInliers = input.ReadInt32();
|
|
break;
|
|
}
|
|
case 293: {
|
|
BoxSimilarityMaxScale = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 301: {
|
|
BoxSimilarityMaxRotation = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 309: {
|
|
QuadHomographyMaxScale = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 317: {
|
|
QuadHomographyMaxRotation = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 322: {
|
|
if (cameraIntrinsics_ == null) {
|
|
CameraIntrinsics = new global::Mediapipe.TrackStepOptions.Types.CameraIntrinsics();
|
|
}
|
|
input.ReadMessage(CameraIntrinsics);
|
|
break;
|
|
}
|
|
case 328: {
|
|
ForcedPnpTracking = input.ReadBool();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
#region Nested types
|
|
/// <summary>Container for nested types declared in the TrackStepOptions message type.</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public static partial class Types {
|
|
/// <summary>
|
|
/// Degrees of freedom being used for tracking. By default tracker only uses
|
|
/// translation. Additionally scale and rotation from the camera motion
|
|
/// and / or object motion can be taken into account.
|
|
/// </summary>
|
|
public enum TrackingDegrees {
|
|
[pbr::OriginalName("TRACKING_DEGREE_TRANSLATION")] TrackingDegreeTranslation = 0,
|
|
/// <summary>
|
|
/// Additional tracking degrees according to camera motion.
|
|
/// </summary>
|
|
[pbr::OriginalName("TRACKING_DEGREE_CAMERA_SCALE")] TrackingDegreeCameraScale = 1,
|
|
[pbr::OriginalName("TRACKING_DEGREE_CAMERA_ROTATION")] TrackingDegreeCameraRotation = 2,
|
|
[pbr::OriginalName("TRACKING_DEGREE_CAMERA_ROTATION_SCALE")] TrackingDegreeCameraRotationScale = 3,
|
|
/// <summary>
|
|
/// TODO: Implement!
|
|
/// </summary>
|
|
[pbr::OriginalName("TRACKING_DEGREE_CAMERA_PERSPECTIVE")] TrackingDegreeCameraPerspective = 4,
|
|
/// <summary>
|
|
/// Tracking degrees modeling object motion. Note that additional
|
|
/// object degrees of freedom are only applied when estimation is deemed
|
|
/// stable, in particular sufficient inliers are present.
|
|
/// By default, does NOT apply camera motion. If that is desired set
|
|
/// the flag: track_object_and_camera to true.
|
|
/// </summary>
|
|
[pbr::OriginalName("TRACKING_DEGREE_OBJECT_SCALE")] TrackingDegreeObjectScale = 5,
|
|
[pbr::OriginalName("TRACKING_DEGREE_OBJECT_ROTATION")] TrackingDegreeObjectRotation = 6,
|
|
[pbr::OriginalName("TRACKING_DEGREE_OBJECT_ROTATION_SCALE")] TrackingDegreeObjectRotationScale = 7,
|
|
[pbr::OriginalName("TRACKING_DEGREE_OBJECT_PERSPECTIVE")] TrackingDegreeObjectPerspective = 8,
|
|
}
|
|
|
|
/// <summary>
|
|
/// Irls initialization by performing several rounds of RANSAC to preselect
|
|
/// features for motion estimation scoring outliers low and inliers to be at
|
|
/// least of median inlier weight.
|
|
/// </summary>
|
|
public sealed partial class IrlsInitialization : pb::IMessage<IrlsInitialization>
|
|
#if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
|
|
, pb::IBufferMessage
|
|
#endif
|
|
{
|
|
private static readonly pb::MessageParser<IrlsInitialization> _parser = new pb::MessageParser<IrlsInitialization>(() => new IrlsInitialization());
|
|
private pb::UnknownFieldSet _unknownFields;
|
|
private int _hasBits0;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public static pb::MessageParser<IrlsInitialization> Parser { get { return _parser; } }
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public static pbr::MessageDescriptor Descriptor {
|
|
get { return global::Mediapipe.TrackStepOptions.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 IrlsInitialization() {
|
|
OnConstruction();
|
|
}
|
|
|
|
partial void OnConstruction();
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public IrlsInitialization(IrlsInitialization other) : this() {
|
|
_hasBits0 = other._hasBits0;
|
|
activated_ = other.activated_;
|
|
rounds_ = other.rounds_;
|
|
cutoff_ = other.cutoff_;
|
|
_unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public IrlsInitialization Clone() {
|
|
return new IrlsInitialization(this);
|
|
}
|
|
|
|
/// <summary>Field number for the "activated" field.</summary>
|
|
public const int ActivatedFieldNumber = 1;
|
|
private readonly static bool ActivatedDefaultValue = false;
|
|
|
|
private bool activated_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool Activated {
|
|
get { if ((_hasBits0 & 1) != 0) { return activated_; } else { return ActivatedDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 1;
|
|
activated_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "activated" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasActivated {
|
|
get { return (_hasBits0 & 1) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "activated" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearActivated() {
|
|
_hasBits0 &= ~1;
|
|
}
|
|
|
|
/// <summary>Field number for the "rounds" field.</summary>
|
|
public const int RoundsFieldNumber = 2;
|
|
private readonly static int RoundsDefaultValue = 50;
|
|
|
|
private int rounds_;
|
|
/// <summary>
|
|
/// Rounds of RANSAC.
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public int Rounds {
|
|
get { if ((_hasBits0 & 2) != 0) { return rounds_; } else { return RoundsDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 2;
|
|
rounds_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "rounds" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasRounds {
|
|
get { return (_hasBits0 & 2) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "rounds" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearRounds() {
|
|
_hasBits0 &= ~2;
|
|
}
|
|
|
|
/// <summary>Field number for the "cutoff" field.</summary>
|
|
public const int CutoffFieldNumber = 3;
|
|
private readonly static float CutoffDefaultValue = 0.005F;
|
|
|
|
private float cutoff_;
|
|
/// <summary>
|
|
/// Normalized cutoff threshold for a vector to be considered an inlier.
|
|
/// </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public float Cutoff {
|
|
get { if ((_hasBits0 & 4) != 0) { return cutoff_; } else { return CutoffDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 4;
|
|
cutoff_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "cutoff" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasCutoff {
|
|
get { return (_hasBits0 & 4) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "cutoff" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearCutoff() {
|
|
_hasBits0 &= ~4;
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public override bool Equals(object other) {
|
|
return Equals(other as IrlsInitialization);
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool Equals(IrlsInitialization other) {
|
|
if (ReferenceEquals(other, null)) {
|
|
return false;
|
|
}
|
|
if (ReferenceEquals(other, this)) {
|
|
return true;
|
|
}
|
|
if (Activated != other.Activated) return false;
|
|
if (Rounds != other.Rounds) return false;
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(Cutoff, other.Cutoff)) 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 (HasActivated) hash ^= Activated.GetHashCode();
|
|
if (HasRounds) hash ^= Rounds.GetHashCode();
|
|
if (HasCutoff) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(Cutoff);
|
|
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 (HasActivated) {
|
|
output.WriteRawTag(8);
|
|
output.WriteBool(Activated);
|
|
}
|
|
if (HasRounds) {
|
|
output.WriteRawTag(16);
|
|
output.WriteInt32(Rounds);
|
|
}
|
|
if (HasCutoff) {
|
|
output.WriteRawTag(29);
|
|
output.WriteFloat(Cutoff);
|
|
}
|
|
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 (HasActivated) {
|
|
output.WriteRawTag(8);
|
|
output.WriteBool(Activated);
|
|
}
|
|
if (HasRounds) {
|
|
output.WriteRawTag(16);
|
|
output.WriteInt32(Rounds);
|
|
}
|
|
if (HasCutoff) {
|
|
output.WriteRawTag(29);
|
|
output.WriteFloat(Cutoff);
|
|
}
|
|
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 (HasActivated) {
|
|
size += 1 + 1;
|
|
}
|
|
if (HasRounds) {
|
|
size += 1 + pb::CodedOutputStream.ComputeInt32Size(Rounds);
|
|
}
|
|
if (HasCutoff) {
|
|
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(IrlsInitialization other) {
|
|
if (other == null) {
|
|
return;
|
|
}
|
|
if (other.HasActivated) {
|
|
Activated = other.Activated;
|
|
}
|
|
if (other.HasRounds) {
|
|
Rounds = other.Rounds;
|
|
}
|
|
if (other.HasCutoff) {
|
|
Cutoff = other.Cutoff;
|
|
}
|
|
_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: {
|
|
Activated = input.ReadBool();
|
|
break;
|
|
}
|
|
case 16: {
|
|
Rounds = input.ReadInt32();
|
|
break;
|
|
}
|
|
case 29: {
|
|
Cutoff = input.ReadFloat();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
#if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
|
|
uint tag;
|
|
while ((tag = input.ReadTag()) != 0) {
|
|
switch(tag) {
|
|
default:
|
|
_unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
|
|
break;
|
|
case 8: {
|
|
Activated = input.ReadBool();
|
|
break;
|
|
}
|
|
case 16: {
|
|
Rounds = input.ReadInt32();
|
|
break;
|
|
}
|
|
case 29: {
|
|
Cutoff = input.ReadFloat();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
}
|
|
|
|
/// <summary>
|
|
/// Different control parameters to terminate tracking when
|
|
/// occlusion occurs.
|
|
/// </summary>
|
|
public sealed partial class CancelTrackingWithOcclusionOptions : pb::IMessage<CancelTrackingWithOcclusionOptions>
|
|
#if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
|
|
, pb::IBufferMessage
|
|
#endif
|
|
{
|
|
private static readonly pb::MessageParser<CancelTrackingWithOcclusionOptions> _parser = new pb::MessageParser<CancelTrackingWithOcclusionOptions>(() => new CancelTrackingWithOcclusionOptions());
|
|
private pb::UnknownFieldSet _unknownFields;
|
|
private int _hasBits0;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public static pb::MessageParser<CancelTrackingWithOcclusionOptions> Parser { get { return _parser; } }
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public static pbr::MessageDescriptor Descriptor {
|
|
get { return global::Mediapipe.TrackStepOptions.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 CancelTrackingWithOcclusionOptions() {
|
|
OnConstruction();
|
|
}
|
|
|
|
partial void OnConstruction();
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public CancelTrackingWithOcclusionOptions(CancelTrackingWithOcclusionOptions other) : this() {
|
|
_hasBits0 = other._hasBits0;
|
|
activated_ = other.activated_;
|
|
minMotionContinuity_ = other.minMotionContinuity_;
|
|
minInlierRatio_ = other.minInlierRatio_;
|
|
_unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public CancelTrackingWithOcclusionOptions Clone() {
|
|
return new CancelTrackingWithOcclusionOptions(this);
|
|
}
|
|
|
|
/// <summary>Field number for the "activated" field.</summary>
|
|
public const int ActivatedFieldNumber = 1;
|
|
private readonly static bool ActivatedDefaultValue = false;
|
|
|
|
private bool activated_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool Activated {
|
|
get { if ((_hasBits0 & 1) != 0) { return activated_; } else { return ActivatedDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 1;
|
|
activated_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "activated" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasActivated {
|
|
get { return (_hasBits0 & 1) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "activated" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearActivated() {
|
|
_hasBits0 &= ~1;
|
|
}
|
|
|
|
/// <summary>Field number for the "min_motion_continuity" field.</summary>
|
|
public const int MinMotionContinuityFieldNumber = 2;
|
|
private readonly static float MinMotionContinuityDefaultValue = 0.4F;
|
|
|
|
private float minMotionContinuity_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public float MinMotionContinuity {
|
|
get { if ((_hasBits0 & 2) != 0) { return minMotionContinuity_; } else { return MinMotionContinuityDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 2;
|
|
minMotionContinuity_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "min_motion_continuity" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasMinMotionContinuity {
|
|
get { return (_hasBits0 & 2) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "min_motion_continuity" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearMinMotionContinuity() {
|
|
_hasBits0 &= ~2;
|
|
}
|
|
|
|
/// <summary>Field number for the "min_inlier_ratio" field.</summary>
|
|
public const int MinInlierRatioFieldNumber = 3;
|
|
private readonly static float MinInlierRatioDefaultValue = 0.1F;
|
|
|
|
private float minInlierRatio_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public float MinInlierRatio {
|
|
get { if ((_hasBits0 & 4) != 0) { return minInlierRatio_; } else { return MinInlierRatioDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 4;
|
|
minInlierRatio_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "min_inlier_ratio" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasMinInlierRatio {
|
|
get { return (_hasBits0 & 4) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "min_inlier_ratio" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearMinInlierRatio() {
|
|
_hasBits0 &= ~4;
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public override bool Equals(object other) {
|
|
return Equals(other as CancelTrackingWithOcclusionOptions);
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool Equals(CancelTrackingWithOcclusionOptions other) {
|
|
if (ReferenceEquals(other, null)) {
|
|
return false;
|
|
}
|
|
if (ReferenceEquals(other, this)) {
|
|
return true;
|
|
}
|
|
if (Activated != other.Activated) return false;
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(MinMotionContinuity, other.MinMotionContinuity)) return false;
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(MinInlierRatio, other.MinInlierRatio)) 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 (HasActivated) hash ^= Activated.GetHashCode();
|
|
if (HasMinMotionContinuity) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(MinMotionContinuity);
|
|
if (HasMinInlierRatio) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(MinInlierRatio);
|
|
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 (HasActivated) {
|
|
output.WriteRawTag(8);
|
|
output.WriteBool(Activated);
|
|
}
|
|
if (HasMinMotionContinuity) {
|
|
output.WriteRawTag(21);
|
|
output.WriteFloat(MinMotionContinuity);
|
|
}
|
|
if (HasMinInlierRatio) {
|
|
output.WriteRawTag(29);
|
|
output.WriteFloat(MinInlierRatio);
|
|
}
|
|
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 (HasActivated) {
|
|
output.WriteRawTag(8);
|
|
output.WriteBool(Activated);
|
|
}
|
|
if (HasMinMotionContinuity) {
|
|
output.WriteRawTag(21);
|
|
output.WriteFloat(MinMotionContinuity);
|
|
}
|
|
if (HasMinInlierRatio) {
|
|
output.WriteRawTag(29);
|
|
output.WriteFloat(MinInlierRatio);
|
|
}
|
|
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 (HasActivated) {
|
|
size += 1 + 1;
|
|
}
|
|
if (HasMinMotionContinuity) {
|
|
size += 1 + 4;
|
|
}
|
|
if (HasMinInlierRatio) {
|
|
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(CancelTrackingWithOcclusionOptions other) {
|
|
if (other == null) {
|
|
return;
|
|
}
|
|
if (other.HasActivated) {
|
|
Activated = other.Activated;
|
|
}
|
|
if (other.HasMinMotionContinuity) {
|
|
MinMotionContinuity = other.MinMotionContinuity;
|
|
}
|
|
if (other.HasMinInlierRatio) {
|
|
MinInlierRatio = other.MinInlierRatio;
|
|
}
|
|
_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: {
|
|
Activated = input.ReadBool();
|
|
break;
|
|
}
|
|
case 21: {
|
|
MinMotionContinuity = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 29: {
|
|
MinInlierRatio = input.ReadFloat();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
#if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
|
|
uint tag;
|
|
while ((tag = input.ReadTag()) != 0) {
|
|
switch(tag) {
|
|
default:
|
|
_unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
|
|
break;
|
|
case 8: {
|
|
Activated = input.ReadBool();
|
|
break;
|
|
}
|
|
case 21: {
|
|
MinMotionContinuity = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 29: {
|
|
MinInlierRatio = input.ReadFloat();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
}
|
|
|
|
/// <summary>
|
|
/// Pre-calibrated camera intrinsics parameters, including focal length, center
|
|
/// point, distortion coefficients (only 3 radial factors) and image width /
|
|
/// height. The image formation model is described here:
|
|
/// https://docs.opencv.org/2.4/doc/tutorials/calib3d/camera_calibration/camera_calibration.html
|
|
/// Only used for quad tracking mode. Leave it empty if unknown.
|
|
/// </summary>
|
|
public sealed partial class CameraIntrinsics : pb::IMessage<CameraIntrinsics>
|
|
#if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
|
|
, pb::IBufferMessage
|
|
#endif
|
|
{
|
|
private static readonly pb::MessageParser<CameraIntrinsics> _parser = new pb::MessageParser<CameraIntrinsics>(() => new CameraIntrinsics());
|
|
private pb::UnknownFieldSet _unknownFields;
|
|
private int _hasBits0;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public static pb::MessageParser<CameraIntrinsics> Parser { get { return _parser; } }
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public static pbr::MessageDescriptor Descriptor {
|
|
get { return global::Mediapipe.TrackStepOptions.Descriptor.NestedTypes[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 CameraIntrinsics() {
|
|
OnConstruction();
|
|
}
|
|
|
|
partial void OnConstruction();
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public CameraIntrinsics(CameraIntrinsics other) : this() {
|
|
_hasBits0 = other._hasBits0;
|
|
fx_ = other.fx_;
|
|
fy_ = other.fy_;
|
|
cx_ = other.cx_;
|
|
cy_ = other.cy_;
|
|
k0_ = other.k0_;
|
|
k1_ = other.k1_;
|
|
k2_ = other.k2_;
|
|
w_ = other.w_;
|
|
h_ = other.h_;
|
|
_unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public CameraIntrinsics Clone() {
|
|
return new CameraIntrinsics(this);
|
|
}
|
|
|
|
/// <summary>Field number for the "fx" field.</summary>
|
|
public const int FxFieldNumber = 1;
|
|
private readonly static float FxDefaultValue = 0F;
|
|
|
|
private float fx_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public float Fx {
|
|
get { if ((_hasBits0 & 1) != 0) { return fx_; } else { return FxDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 1;
|
|
fx_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "fx" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasFx {
|
|
get { return (_hasBits0 & 1) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "fx" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearFx() {
|
|
_hasBits0 &= ~1;
|
|
}
|
|
|
|
/// <summary>Field number for the "fy" field.</summary>
|
|
public const int FyFieldNumber = 2;
|
|
private readonly static float FyDefaultValue = 0F;
|
|
|
|
private float fy_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public float Fy {
|
|
get { if ((_hasBits0 & 2) != 0) { return fy_; } else { return FyDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 2;
|
|
fy_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "fy" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasFy {
|
|
get { return (_hasBits0 & 2) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "fy" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearFy() {
|
|
_hasBits0 &= ~2;
|
|
}
|
|
|
|
/// <summary>Field number for the "cx" field.</summary>
|
|
public const int CxFieldNumber = 3;
|
|
private readonly static float CxDefaultValue = 0F;
|
|
|
|
private float cx_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public float Cx {
|
|
get { if ((_hasBits0 & 4) != 0) { return cx_; } else { return CxDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 4;
|
|
cx_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "cx" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasCx {
|
|
get { return (_hasBits0 & 4) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "cx" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearCx() {
|
|
_hasBits0 &= ~4;
|
|
}
|
|
|
|
/// <summary>Field number for the "cy" field.</summary>
|
|
public const int CyFieldNumber = 4;
|
|
private readonly static float CyDefaultValue = 0F;
|
|
|
|
private float cy_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public float Cy {
|
|
get { if ((_hasBits0 & 8) != 0) { return cy_; } else { return CyDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 8;
|
|
cy_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "cy" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasCy {
|
|
get { return (_hasBits0 & 8) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "cy" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearCy() {
|
|
_hasBits0 &= ~8;
|
|
}
|
|
|
|
/// <summary>Field number for the "k0" field.</summary>
|
|
public const int K0FieldNumber = 5;
|
|
private readonly static float K0DefaultValue = 0F;
|
|
|
|
private float k0_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public float K0 {
|
|
get { if ((_hasBits0 & 16) != 0) { return k0_; } else { return K0DefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 16;
|
|
k0_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "k0" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasK0 {
|
|
get { return (_hasBits0 & 16) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "k0" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearK0() {
|
|
_hasBits0 &= ~16;
|
|
}
|
|
|
|
/// <summary>Field number for the "k1" field.</summary>
|
|
public const int K1FieldNumber = 6;
|
|
private readonly static float K1DefaultValue = 0F;
|
|
|
|
private float k1_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public float K1 {
|
|
get { if ((_hasBits0 & 32) != 0) { return k1_; } else { return K1DefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 32;
|
|
k1_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "k1" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasK1 {
|
|
get { return (_hasBits0 & 32) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "k1" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearK1() {
|
|
_hasBits0 &= ~32;
|
|
}
|
|
|
|
/// <summary>Field number for the "k2" field.</summary>
|
|
public const int K2FieldNumber = 7;
|
|
private readonly static float K2DefaultValue = 0F;
|
|
|
|
private float k2_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public float K2 {
|
|
get { if ((_hasBits0 & 64) != 0) { return k2_; } else { return K2DefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 64;
|
|
k2_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "k2" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasK2 {
|
|
get { return (_hasBits0 & 64) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "k2" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearK2() {
|
|
_hasBits0 &= ~64;
|
|
}
|
|
|
|
/// <summary>Field number for the "w" field.</summary>
|
|
public const int WFieldNumber = 8;
|
|
private readonly static int WDefaultValue = 0;
|
|
|
|
private int w_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public int W {
|
|
get { if ((_hasBits0 & 128) != 0) { return w_; } else { return WDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 128;
|
|
w_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "w" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasW {
|
|
get { return (_hasBits0 & 128) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "w" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearW() {
|
|
_hasBits0 &= ~128;
|
|
}
|
|
|
|
/// <summary>Field number for the "h" field.</summary>
|
|
public const int HFieldNumber = 9;
|
|
private readonly static int HDefaultValue = 0;
|
|
|
|
private int h_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public int H {
|
|
get { if ((_hasBits0 & 256) != 0) { return h_; } else { return HDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 256;
|
|
h_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "h" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool HasH {
|
|
get { return (_hasBits0 & 256) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "h" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void ClearH() {
|
|
_hasBits0 &= ~256;
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public override bool Equals(object other) {
|
|
return Equals(other as CameraIntrinsics);
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public bool Equals(CameraIntrinsics other) {
|
|
if (ReferenceEquals(other, null)) {
|
|
return false;
|
|
}
|
|
if (ReferenceEquals(other, this)) {
|
|
return true;
|
|
}
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(Fx, other.Fx)) return false;
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(Fy, other.Fy)) return false;
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(Cx, other.Cx)) return false;
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(Cy, other.Cy)) return false;
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(K0, other.K0)) return false;
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(K1, other.K1)) return false;
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(K2, other.K2)) return false;
|
|
if (W != other.W) return false;
|
|
if (H != other.H) 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 (HasFx) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(Fx);
|
|
if (HasFy) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(Fy);
|
|
if (HasCx) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(Cx);
|
|
if (HasCy) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(Cy);
|
|
if (HasK0) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(K0);
|
|
if (HasK1) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(K1);
|
|
if (HasK2) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(K2);
|
|
if (HasW) hash ^= W.GetHashCode();
|
|
if (HasH) hash ^= H.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 (HasFx) {
|
|
output.WriteRawTag(13);
|
|
output.WriteFloat(Fx);
|
|
}
|
|
if (HasFy) {
|
|
output.WriteRawTag(21);
|
|
output.WriteFloat(Fy);
|
|
}
|
|
if (HasCx) {
|
|
output.WriteRawTag(29);
|
|
output.WriteFloat(Cx);
|
|
}
|
|
if (HasCy) {
|
|
output.WriteRawTag(37);
|
|
output.WriteFloat(Cy);
|
|
}
|
|
if (HasK0) {
|
|
output.WriteRawTag(45);
|
|
output.WriteFloat(K0);
|
|
}
|
|
if (HasK1) {
|
|
output.WriteRawTag(53);
|
|
output.WriteFloat(K1);
|
|
}
|
|
if (HasK2) {
|
|
output.WriteRawTag(61);
|
|
output.WriteFloat(K2);
|
|
}
|
|
if (HasW) {
|
|
output.WriteRawTag(64);
|
|
output.WriteInt32(W);
|
|
}
|
|
if (HasH) {
|
|
output.WriteRawTag(72);
|
|
output.WriteInt32(H);
|
|
}
|
|
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 (HasFx) {
|
|
output.WriteRawTag(13);
|
|
output.WriteFloat(Fx);
|
|
}
|
|
if (HasFy) {
|
|
output.WriteRawTag(21);
|
|
output.WriteFloat(Fy);
|
|
}
|
|
if (HasCx) {
|
|
output.WriteRawTag(29);
|
|
output.WriteFloat(Cx);
|
|
}
|
|
if (HasCy) {
|
|
output.WriteRawTag(37);
|
|
output.WriteFloat(Cy);
|
|
}
|
|
if (HasK0) {
|
|
output.WriteRawTag(45);
|
|
output.WriteFloat(K0);
|
|
}
|
|
if (HasK1) {
|
|
output.WriteRawTag(53);
|
|
output.WriteFloat(K1);
|
|
}
|
|
if (HasK2) {
|
|
output.WriteRawTag(61);
|
|
output.WriteFloat(K2);
|
|
}
|
|
if (HasW) {
|
|
output.WriteRawTag(64);
|
|
output.WriteInt32(W);
|
|
}
|
|
if (HasH) {
|
|
output.WriteRawTag(72);
|
|
output.WriteInt32(H);
|
|
}
|
|
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 (HasFx) {
|
|
size += 1 + 4;
|
|
}
|
|
if (HasFy) {
|
|
size += 1 + 4;
|
|
}
|
|
if (HasCx) {
|
|
size += 1 + 4;
|
|
}
|
|
if (HasCy) {
|
|
size += 1 + 4;
|
|
}
|
|
if (HasK0) {
|
|
size += 1 + 4;
|
|
}
|
|
if (HasK1) {
|
|
size += 1 + 4;
|
|
}
|
|
if (HasK2) {
|
|
size += 1 + 4;
|
|
}
|
|
if (HasW) {
|
|
size += 1 + pb::CodedOutputStream.ComputeInt32Size(W);
|
|
}
|
|
if (HasH) {
|
|
size += 1 + pb::CodedOutputStream.ComputeInt32Size(H);
|
|
}
|
|
if (_unknownFields != null) {
|
|
size += _unknownFields.CalculateSize();
|
|
}
|
|
return size;
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
public void MergeFrom(CameraIntrinsics other) {
|
|
if (other == null) {
|
|
return;
|
|
}
|
|
if (other.HasFx) {
|
|
Fx = other.Fx;
|
|
}
|
|
if (other.HasFy) {
|
|
Fy = other.Fy;
|
|
}
|
|
if (other.HasCx) {
|
|
Cx = other.Cx;
|
|
}
|
|
if (other.HasCy) {
|
|
Cy = other.Cy;
|
|
}
|
|
if (other.HasK0) {
|
|
K0 = other.K0;
|
|
}
|
|
if (other.HasK1) {
|
|
K1 = other.K1;
|
|
}
|
|
if (other.HasK2) {
|
|
K2 = other.K2;
|
|
}
|
|
if (other.HasW) {
|
|
W = other.W;
|
|
}
|
|
if (other.HasH) {
|
|
H = other.H;
|
|
}
|
|
_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: {
|
|
Fx = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 21: {
|
|
Fy = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 29: {
|
|
Cx = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 37: {
|
|
Cy = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 45: {
|
|
K0 = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 53: {
|
|
K1 = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 61: {
|
|
K2 = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 64: {
|
|
W = input.ReadInt32();
|
|
break;
|
|
}
|
|
case 72: {
|
|
H = input.ReadInt32();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
#if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
|
|
void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
|
|
uint tag;
|
|
while ((tag = input.ReadTag()) != 0) {
|
|
switch(tag) {
|
|
default:
|
|
_unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
|
|
break;
|
|
case 13: {
|
|
Fx = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 21: {
|
|
Fy = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 29: {
|
|
Cx = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 37: {
|
|
Cy = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 45: {
|
|
K0 = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 53: {
|
|
K1 = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 61: {
|
|
K2 = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 64: {
|
|
W = input.ReadInt32();
|
|
break;
|
|
}
|
|
case 72: {
|
|
H = input.ReadInt32();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
}
|
|
|
|
}
|
|
#endregion
|
|
|
|
}
|
|
|
|
#endregion
|
|
|
|
}
|
|
|
|
#endregion Designer generated code
|