public override Status StartRun(SidePacket sidePacket)
{
outputStreamPoller = graph.AddOutputStreamPoller <ImageFrame>(outputStream).ConsumeValue();
outputPacket = new ImageFramePacket();
return(graph.StartRun(sidePacket));
}
protected virtual IEnumerator RunGraph()
{
var webCamScreenController = webCamScreen.GetComponent <WebCamScreenController>();
graph.Initialize();
sidePacket = new SidePacket();
sidePacket.Insert("focal_length_pixel", new FloatPacket(webCamScreenController.FocalLengthPx()));
graph.StartRun(sidePacket).AssertOk();
while (true)
{
yield return(new WaitForEndOfFrame());
if (!webCamScreenController.isPlaying())
{
Debug.LogWarning("WebCam is not working");
break;
}
var pixelData = webCamScreenController.GetPixels32();
var width = webCamScreenController.Width();
var height = webCamScreenController.Height();
graph.PushColor32(pixelData, width, height);
graph.RenderOutput(webCamScreenController, pixelData);
}
}
public Status StartRun(SidePacket sidePacket)
{
outputStreamPoller = graph.AddOutputStreamPoller <string>(outputStream).ConsumeValue();
outputPacket = new StringPacket();
return(graph.StartRun(sidePacket));
}
public override Status StartRun(SidePacket sidePacket)
{
outputStreamPoller = graph.AddOutputStreamPoller <GpuBuffer>(outputStream).ConsumeValue();
outputPacket = new GpuBufferPacket();
return(graph.StartRun(sidePacket));
}
public override Status StartRun()
{
handLandmarksStreamPoller = graph.AddOutputStreamPoller <List <NormalizedLandmarkList> >(handLandmarksStream).ConsumeValueOrDie();
handLandmarksPacket = new NormalizedLandmarkListVectorPacket();
handednessStreamPoller = graph.AddOutputStreamPoller <List <ClassificationList> >(handednessStream).ConsumeValueOrDie();
handednessPacket = new ClassificationListVectorPacket();
palmDetectionsStreamPoller = graph.AddOutputStreamPoller <List <Detection> >(palmDetectionsStream).ConsumeValueOrDie();
palmDetectionsPacket = new DetectionVectorPacket();
palmRectsStreamPoller = graph.AddOutputStreamPoller <List <NormalizedRect> >(palmRectsStream).ConsumeValueOrDie();
palmRectsPacket = new NormalizedRectVectorPacket();
handLandmarksPresenceStreamPoller = graph.AddOutputStreamPoller <bool>(handLandmarksPresenceStream).ConsumeValueOrDie();
handLandmarksPresencePacket = new BoolPacket();
palmDetectionsPresenceStreamPoller = graph.AddOutputStreamPoller <bool>(palmDetectionsPresenceStream).ConsumeValueOrDie();
palmDetectionsPresencePacket = new BoolPacket();
sidePacket = new SidePacket();
sidePacket.Emplace("num_hands", new IntPacket(2));
return(graph.StartRun(sidePacket));
}
SidePacket BuildSidePacket(ImageSource imageSource)
{
var sidePacket = new SidePacket();
SetImageTransformationOptions(sidePacket, imageSource);
return(sidePacket);
}
public override Status StartRun(Texture texture)
{
Debug.Log("This graph is for testing official examples. You can customize the graph by editing `official_demo_android.txt` (default is `hand_tracking_mobile.pbtxt`)");
sidePacket = new SidePacket();
sidePacket.Emplace("num_hands", new IntPacket(2));
#if UNITY_ANDROID
var glTextureName = texture.GetNativeTexturePtr();
var textureWidth = texture.width;
var textureHeight = texture.height;
GpuBuffer gpuBuffer = null;
gpuHelper.RunInGlContext(() => {
var glContext = GlContext.GetCurrent();
var glTextureBuffer = new GlTextureBuffer((UInt32)glTextureName, textureWidth, textureHeight,
GpuBufferFormat.kBGRA32, OnReleaseDestinationTexture, glContext);
gpuBuffer = new GpuBuffer(glTextureBuffer);
return(Status.Ok());
}).AssertOk();
outputPacket = new GpuBufferPacket(gpuBuffer);
sidePacket.Emplace(destinationBufferName, outputPacket);
#endif
return(graph.StartRun(sidePacket));
}
public override Status StartRun(SidePacket sidePacket)
{
outputDetectionsStreamPoller = graph.AddOutputStreamPoller <List <Detection> >(outputDetectionsStream).ConsumeValue();
outputDetectionsPacket = new DetectionVectorPacket();
return(graph.StartRun(sidePacket));
}
public void Size_ShouldReturnZero_When_Initialized()
{
using (var sidePacket = new SidePacket())
{
Assert.AreEqual(0, sidePacket.size);
}
}
public override Status StartRun(Texture texture)
{
if (!IsGpuEnabled())
{
return(Status.FailedPrecondition("InstantMotionTracking is not supported on CPU"));
}
stopwatch.Start();
ResetSticker();
imuRotationMatrix = new float[] { 0, 0, 1, 1, 0, 0, 0, 1, 0 };
graph.ObserveOutputStream("asset_3d_matrices", MatrixCallback).AssertOk();
sidePacket = new SidePacket();
sidePacket.Emplace("vertical_fov_radians", new FloatPacket(GetVerticalFovRadians()));
sidePacket.Emplace("aspect_ratio", new FloatPacket(3.0f / 4.0f));
sidePacket.Emplace("texture_3d", new ImageFramePacket(GetImageFrameFromImage(texture3dAsset)));
sidePacket.Emplace("asset_3d", new StringPacket("robot.obj.bytes"));
#if UNITY_ANDROID && !UNITY_EDITOR
SetupOutputPacket(texture);
sidePacket.Emplace(destinationBufferName, outputPacket);
return(graph.StartRun(sidePacket));
#else
return(StartRun());
#endif
}
public void Clear_ShouldDoNothing_When_SizeIsZero()
{
var sidePacket = new SidePacket();
sidePacket.Clear();
Assert.AreEqual(sidePacket.size, 0);
}
public void Erase_ShouldDoNothing_When_KeyDoesNotExist()
{
var sidePacket = new SidePacket();
sidePacket.Erase("value");
Assert.AreEqual(sidePacket.size, 0);
}
SidePacket BuildSidePacket(ImageSource imageSource)
{
var sidePacket = new SidePacket();
SetImageTransformationOptions(sidePacket, imageSource);
sidePacket.Emplace("model_type", new IntPacket((int)modelType));
return(sidePacket);
}
public void Clear_ShouldDoNothing_When_SizeIsZero()
{
using (var sidePacket = new SidePacket())
{
sidePacket.Clear();
Assert.AreEqual(0, sidePacket.size);
}
}
SidePacket BuildSidePacket(ImageSource imageSource)
{
var sidePacket = new SidePacket();
SetImageTransformationOptions(sidePacket, imageSource, true);
sidePacket.Emplace("num_hands", new IntPacket(maxNumHands));
return(sidePacket);
}
public void Erase_ShouldEraseKey_When_KeyExists()
{
var sidePacket = new SidePacket();
sidePacket.Emplace("value", new BoolPacket(true));
Assert.AreEqual(sidePacket.size, 1);
sidePacket.Erase("value");
Assert.AreEqual(sidePacket.size, 0);
}
public void Erase_ShouldDoNothing_When_KeyDoesNotExist()
{
using (var sidePacket = new SidePacket())
{
var count = sidePacket.Erase("value");
Assert.AreEqual(0, sidePacket.size);
Assert.AreEqual(0, count);
}
}
SidePacket BuildSidePacket(ImageSource imageSource)
{
var sidePacket = new SidePacket();
SetImageTransformationOptions(sidePacket, imageSource);
sidePacket.Emplace("model_complexity", new IntPacket((int)modelComplexity));
sidePacket.Emplace("smooth_landmarks", new BoolPacket(smoothLandmarks));
return(sidePacket);
}
SidePacket BuildSidePacket(ImageSource imageSource)
{
var sidePacket = new SidePacket();
SetImageTransformationOptions(sidePacket, imageSource);
sidePacket.Emplace("allowed_labels", new StringPacket(GetAllowedLabels(category)));
sidePacket.Emplace("max_num_objects", new IntPacket(maxNumObjects));
return(sidePacket);
}
public override Status StartRun(SidePacket sidePacket)
{
landmarkStreamPoller = graph.AddOutputStreamPoller <List <Landmark[]> >(landmarkStream).ConsumeValue();
landmarkPresenceStreamPoller = graph.AddOutputStreamPoller <bool>(landmarkPresenceStream).ConsumeValue();
landmarkListPacket = new NormalizedLandmarkListVectorPacket();
landmarkPresencePacket = new BoolPacket();
return(graph.StartRun(sidePacket));
}
public override Status StartRun()
{
Debug.Log("This graph is for testing official examples. You can customize the graph by editing `official_demo_cpu.txt` (default is `hand_tracking_desktop.pbtxt`)");
graph.ObserveOutputStream <ImageFramePacket, ImageFrame>(outputStream, OutputVideoCallback, out outputVideoCallbackHandle).AssertOk();
sidePacket = new SidePacket();
sidePacket.Emplace("num_hands", new IntPacket(2));
return(graph.StartRun(sidePacket));
}
SidePacket BuildSidePacket(ImageSource imageSource)
{
var sidePacket = new SidePacket();
SetImageTransformationOptions(sidePacket, imageSource);
var outputRotation = imageSource.isHorizontallyFlipped ? imageSource.rotation.Reverse() : imageSource.rotation;
sidePacket.Emplace("output_rotation", new IntPacket((int)outputRotation));
return(sidePacket);
}
public void Clear_ShouldClearAllKeys_When_SizeIsNotZero()
{
var sidePacket = new SidePacket();
sidePacket.Emplace("flag", new BoolPacket(true));
sidePacket.Emplace("value", new FloatPacket(1.0f));
Assert.AreEqual(sidePacket.size, 2);
sidePacket.Clear();
Assert.AreEqual(sidePacket.size, 0);
}
public void size_ShouldReturnSize_When_AfterPacketsAreEmplaced()
{
var sidePacket = new SidePacket();
var flagPacket = new BoolPacket(true);
var valuePacket = new FloatPacket(1.0f);
sidePacket.Emplace("flag", flagPacket);
sidePacket.Emplace("value", valuePacket);
Assert.AreEqual(sidePacket.size, 2);
}
public void Initialize_ShouldReturnInternalError_When_CalledWithConfigAndSidePacket_And_ConfigIsSet()
{
var graph = new CalculatorGraph(validConfigText);
var config = CalculatorGraphConfig.Parser.ParseFromTextFormat(validConfigText);
var sidePacket = new SidePacket();
sidePacket.Emplace("flag", new BoolPacket(true));
var status = graph.Initialize(config, sidePacket);
Assert.AreEqual(status.code, Status.StatusCode.Internal);
}
public void Initialize_ShouldReturnOk_When_CalledWithConfigAndSidePacket_And_ConfigIsNotSet()
{
var graph = new CalculatorGraph();
var config = CalculatorGraphConfig.Parser.ParseFromTextFormat(validConfigText);
var sidePacket = new SidePacket();
sidePacket.Emplace("flag", new BoolPacket(true));
var status = graph.Initialize(config, sidePacket);
Assert.True(status.ok);
}
public void Erase_ShouldEraseKey_When_KeyExists()
{
using (var sidePacket = new SidePacket())
{
sidePacket.Emplace("value", new BoolPacket(true));
Assert.AreEqual(1, sidePacket.size);
var count = sidePacket.Erase("value");
Assert.AreEqual(0, sidePacket.size);
Assert.AreEqual(1, count);
}
}
public override Status StartRun(Texture texture)
{
Debug.Log("This graph is for testing official examples. You can customize the graph by editing `official_demo_dekstop_gpu.txt` (default is `hand_tracking_mobile.pbtxt`)");
outputStreamPoller = graph.AddOutputStreamPoller <ImageFrame>(outputStream).ConsumeValueOrDie();
outputPacket = new ImageFramePacket();
sidePacket = new SidePacket();
sidePacket.Emplace("num_hands", new IntPacket(2));
return(graph.StartRun(sidePacket));
}
public void Emplace_ShouldIgnoreValue_When_KeyExists()
{
using (var sidePacket = new SidePacket())
{
var oldValuePacket = new FloatPacket(1.0f);
sidePacket.Emplace("value", oldValuePacket);
Assert.AreEqual(1.0f, sidePacket.At <FloatPacket, float>("value").Get());
var newValuePacket = new FloatPacket(2.0f);
sidePacket.Emplace("value", newValuePacket);
Assert.AreEqual(1.0f, sidePacket.At <FloatPacket, float>("value").Get());
}
}
public void ValidateRequiredSidePackets_ShouldReturnInvalidArgumentError_When_TheConfigRequiresSidePackets_And_SidePacketIsEmpty()
{
using (var config = new ValidatedGraphConfig())
{
config.Initialize(CalculatorGraphConfig.Parser.ParseFromTextFormat(_ObjectronConfigText)).AssertOk();
using (var sidePacket = new SidePacket())
{
using (var status = config.ValidateRequiredSidePackets(sidePacket))
{
Assert.AreEqual(Status.StatusCode.InvalidArgument, status.Code());
}
}
}
}
