System.AccessViolationException throw if captures hand about openposedotnet HOT 33 CLOSED

    protected override void WorkConsumer(StdSharedPtr<Datum>[] datumsPtr)
    {
        try
        {
            // User's displaying/saving/other processing here
            // datum.cvOutputData: rendered frame with pose or heatmaps
            // datum.poseKeypoints: Array<float> with the estimated pose
            if (datumsPtr != null && datumsPtr.Length != 0)
            {
                var datum = datumsPtr[0].Get();

                var rightHandVector = RetrieveHandData(BodyPart.Right, datum);

                var leftHandVector = RetrieveHandData(BodyPart.Left, datum);

                ProcessData(rightHandVector, leftHandVector);

                DisplayResults(datum);
            }
        }
        catch (Exception e)
        {
            Stop();
            LogHelper.Error($"{MethodBase.GetCurrentMethod()?.Name}: {e.Message}");
        }
    }

    private static Vector2 RetrieveHandData(BodyPart whichSide, Datum datum)
    {
        var handVector = Vector2.Zero;

        try
        {
            switch (whichSide)
            {
                case BodyPart.Right:
                {
                    var handKeyPoints = datum.HandKeyPoints[1];

                    handVector = new Vector2(handKeyPoints[new[] {0, 10, 0}], // 10 = middleJoint2
                                             handKeyPoints[new[] {0, 10, 1}]);
                    break;
                }
                case BodyPart.Left:
                {
                    var handKeyPoints = datum.HandKeyPoints[0];

                    handVector = new Vector2(handKeyPoints[new[] {0, 10, 0}], // 10 = middleJoint2
                                             handKeyPoints[new[] {0, 10, 1}]);
                    break;
                }
                default:
                    handVector = default;
                    break;
            }
        }
        catch (Exception e)
        {
            LogHelper.Info($"{MethodBase.GetCurrentMethod()?.Name}: {whichSide} {e.Message}");
        }

        return handVector;
    }

// Required flags to enable heatmaps
Flags.Body = 0;
Flags.Hand = true;
Flags.HandDetector = 2;

// Required flags to enable heatmaps
Flags.Body = 1;
Flags.Hand = false;
Flags.HandDetector = 0;

    private static void ConfigureWrapper(Wrapper<Datum> opWrapper)
    {
        try
        {
            // Configuring OpenPose

            // logging_level
            OpenPose.CheckBool(0 <= Flags.LoggingLevel && Flags.LoggingLevel <= 255, "Wrong logging_level value.");
            ConfigureLog.PriorityThreshold = (Priority)Flags.LoggingLevel;
            Profiler.SetDefaultX((ulong)Flags.ProfileSpeed);
            
            // // For debugging
            // // Print all logging messages
            // ConfigureLog.PriorityThreshold = Priority.None;
            // // Print out speed values faster
            // Profiler.setDefaultX(100);

            // Applying user defined configuration - GFlags to program variables
            // producerType
            Flags.Camera = 1;
            var (producerType, producerString) = OpenPose.FlagsToProducer(Flags.ImageDir, Flags.Video, Flags.IpCamera, Flags.Camera, Flags.FlirCamera, Flags.FlirCameraIndex);

            // cameraSize
            var cameraSize = OpenPose.FlagsToPoint(Flags.CameraResolution, "-1x-1");
            
            // outputSize
            var outputSize = OpenPose.FlagsToPoint(Flags.OutputResolution, "-1x-1");
            
            // netInputSize
            var netInputSize = OpenPose.FlagsToPoint(Flags.NetResolution, "-1x-1");
            
            // faceNetInputSize
            var faceNetInputSize = OpenPose.FlagsToPoint(Flags.FaceNetResolution, "368x368 (multiples of 16)");
            
            // handNetInputSize
            var handNetInputSize = OpenPose.FlagsToPoint(Flags.HandNetResolution, "368x368 (multiples of 16)");
            
            // poseMode
            var poseMode = OpenPose.FlagsToPoseMode(Flags.Body);
            
            // poseModel
            var poseModel = OpenPose.FlagsToPoseModel(Flags.ModelPose);
            
            // JSON saving
            if (!string.IsNullOrEmpty(Flags.WriteKeyPoint))
            {
                LogHelper.Info("Flag `write_keypoint` is deprecated and will eventually be removed. Please, use `write_json` instead.", Priority.Max);
            }

            // key point Scale
            var keypointScale = OpenPose.FlagsToScaleMode(Flags.KeyPointScale);
            
            // heatmaps to add
            var heatMapTypes = OpenPose.FlagsToHeatMaps(Flags.HeatmapsAddParts, Flags.HeatmapsAddBackground, Flags.HeatmapsAddPAFs);
            var heatMapScale = OpenPose.FlagsToHeatMapScaleMode(Flags.HeatmapsScale);
            
            // >1 camera view?
            var multipleView = Flags.Enable3D || Flags.Views3D > 1 || Flags.FlirCamera;
            
            // Face and hand detectors
            var faceDetector = OpenPose.FlagsToDetector(Flags.FaceDetector);
            var handDetector = OpenPose.FlagsToDetector(Flags.HandDetector);
            
            // disable Google Logging
            const bool enableGoogleLogging = false;

            // Initializing the user custom classes
            // GUI (Display)
            var wUserOutput = new StdSharedPtr<UserWorkerConsumer<Datum>>(new WUserOutput());

            // Add custom processing
            opWrapper.SetWorker(WorkerType.Output, wUserOutput);

            // Pose configuration (use WrapperStructPose{} for default and recommended configuration)
            Flags.NumGpu = 1;
            //Flags.NumGpuStart = 1; // throws exception
            Flags.NumberPeopleMax = 1;
            Flags.FpsMax = 60;
            var pose = new WrapperStructPose(poseMode,
                                             netInputSize,
                                             outputSize,
                                             keypointScale,
                                             Flags.NumGpu,
                                             Flags.NumGpuStart,
                                             Flags.ScaleNumber,
                                             (float)Flags.ScaleGap,
                                             OpenPose.FlagsToRenderMode(Flags.RenderPose, multipleView),
                                             poseModel,
                                             !Flags.DisableBlending,
                                             (float)Flags.AlphaPose,
                                             (float)Flags.AlphaHeatmap,
                                             Flags.PartToShow,
                                             Flags.ModelFolder,
                                             heatMapTypes,
                                             heatMapScale,
                                             Flags.PartCandidates,
                                             (float)Flags.RenderThreshold,
                                             Flags.NumberPeopleMax,
                                             Flags.MaximizePositives,
                                             Flags.FpsMax,
                                             Flags.PrototxtPath,
                                             Flags.CaffeModelPath,
                                             (float)Flags.UpsamplingRatio,
                                             enableGoogleLogging);

            // Face configuration (use op::WrapperStructFace{} to disable it)
            //Flags.Face = true;
            var face = new WrapperStructFace(Flags.Face,
                                             faceDetector,
                                             faceNetInputSize,
                                             OpenPose.FlagsToRenderMode(Flags.FaceRender, multipleView, Flags.RenderPose),
                                             (float)Flags.FaceAlphaPose,
                                             (float)Flags.FaceAlphaHeatmap,
                                             (float)Flags.FaceRenderThreshold);

            // Hand configuration (use op::WrapperStructHand{} to disable it)
            Flags.Hand = true;
            var hand = new WrapperStructHand(Flags.Hand,
                                             handDetector,
                                             handNetInputSize,
                                             Flags.HandScaleNumber,
                                             (float) Flags.HandScaleRange,
                                             OpenPose.FlagsToRenderMode(Flags.HandRender, multipleView, Flags.RenderPose),
                                             (float) Flags.HandAlphaPose,
                                             (float) Flags.HandAlphaHeatmap,
                                             (float) Flags.HandRenderThreshold);

            // Extra functionality configuration (use op::WrapperStructExtra{} to disable it)
            //Flags.Enable3D = true; // throws exception
            var extra = new WrapperStructExtra(Flags.Enable3D,
                                               Flags.MinViews3D,
                                               Flags.Identification,
                                               Flags.Tracking,
                                               Flags.IkThreads);

            // Producer (use default to disable any input)
            Flags.ProcessRealTime = true;
            var input = new WrapperStructInput(producerType,
                                               producerString,
                                               Flags.FrameFirst,
                                               Flags.FrameStep,
                                               Flags.FrameLast,
                                               Flags.ProcessRealTime,
                                               Flags.FrameFlip,
                                               Flags.FrameRotate,
                                               Flags.FramesRepeat,
                                               cameraSize,
                                               Flags.CameraParameterPath,
                                               Flags.FrameUndistort,
                                               Flags.Views3D);

            // Output (comment or use default argument to disable any output)
            var output = new WrapperStructOutput(Flags.CliVerbose,
                                                 Flags.WriteKeyPoint,
                                                 OpenPose.StringToDataFormat(Flags.WriteKeyPointFormat),
                                                 Flags.WriteJson,
                                                 Flags.WriteCocoJson,
                                                 Flags.WriteCocoJsonVariants,
                                                 Flags.WriteCocoJsonVariant,
                                                 Flags.WriteImages,
                                                 Flags.WriteImagesFormat,
                                                 Flags.WriteVideo,
                                                 Flags.WriteVideoFps,
                                                 Flags.WriteVideoWithAudio,
                                                 Flags.WriteHeatmaps,
                                                 Flags.WriteHeatmapsFormat,
                                                 Flags.WriteVideoAdam,
                                                 Flags.WriteBvh,
                                                 Flags.UdpHost,
                                                 Flags.UdpPort);

            // No GUI. Equivalent to: opWrapper.configure(op::WrapperStructGui{});
            opWrapper.Configure(pose);
            opWrapper.Configure(face);
            opWrapper.Configure(hand);
            opWrapper.Configure(extra);
            opWrapper.Configure(input);
            opWrapper.Configure(output);

            // No GUI. Equivalent to: opWrapper.configure(op::WrapperStructGui{});
            // Set to single-thread (for sequential processing and/or debugging and/or reducing latency)
            Flags.DisableMultiThread = false;
            if (Flags.DisableMultiThread)
            {
                opWrapper.DisableMultiThreading();
            }
        }
        catch (Exception e)
        {
            LogHelper.Error($"{nameof(ConfigureWrapper)} {e.Message}");
        }
    }

public class FixedSizedConcurrentQueue<TValue> : IProducerConsumerCollection<TValue>, IReadOnlyCollection<TValue>
{
    private readonly ConcurrentQueue<TValue> queue;

    private readonly object syncObject = new object();

    public int Size { get; }

    public bool IsEmpty => queue.IsEmpty;

    public int Count => queue.Count;

    bool ICollection.IsSynchronized => ((ICollection) queue).IsSynchronized;

    object ICollection.SyncRoot => ((ICollection) queue).SyncRoot;

    public FixedSizedConcurrentQueue(int size)
    {
        queue = new ConcurrentQueue<TValue>();
        Size = size;
    }

    public FixedSizedConcurrentQueue(int size, IEnumerable<TValue> collection)
    {
        queue = new ConcurrentQueue<TValue>(collection);
        Size = size;
    }

    // Not supported until .NET Standard 2.1
    public void Clear() => queue.Clear();

    public void CopyTo(TValue[] array, int index) => queue.CopyTo(array, index);

    void ICollection.CopyTo(Array array, int index) => ((ICollection) queue).CopyTo(array, index);

    public IEnumerator<TValue> GetEnumerator() => queue.GetEnumerator();

    IEnumerator IEnumerable.GetEnumerator() => ((IEnumerable<TValue>) this).GetEnumerator();

    public TValue[] ToArray() => queue.ToArray();

    public bool TryAdd(TValue item)
    {
        Enqueue(item);
        return true;
    }

    bool IProducerConsumerCollection<TValue>.TryTake(out TValue item) => TryDequeue(out item);

    public void Enqueue(TValue obj)
    {
        queue.Enqueue(obj);
        lock (syncObject)
        {
            while (queue.Count > Size)
            {
                queue.TryDequeue(out _);
            }
        }
    }

    public bool TryDequeue(out TValue result) => queue.TryDequeue(out result);

    public bool TryPeek(out TValue result) => queue.TryPeek(out result);
}

                var left = datum.HandKeyPoints[0];
                if (left.Volume != 0)
                {
                    //left.NumberDimensions
                    OpenPose.Log($"Left hand keypoints: {left[new[] { 0, 10, 0 }]}", Priority.High);
                }