F# F中的Kinect骨架跟踪问题#

我正在使用由提供的F#骨架跟踪模板。C#中的模板也能做同样的事情，所以我知道硬件还可以

我正在使用

该程序将偶尔跟踪一次，但没有一致的模式。从昨晚开始我就一直在玩代码，所以我想找人来确认另一个系统上的相同行为，或者寻找关于如何更改代码的任何指针

提前谢谢

这是模板代码：

#light

open System
open System.Windows
open System.Windows.Media.Imaging
open Microsoft.Kinect
open System.Diagnostics

let sensor = KinectSensor.KinectSensors.[0]

//The main canvas that is handling the ellipses
let canvas = new System.Windows.Controls.Canvas()
canvas.Background <- System.Windows.Media.Brushes.Transparent

let ds : byte = Convert.ToByte(1)
let dummySkeleton : Skeleton = new Skeleton(TrackingState = SkeletonTrackingState.Tracked)

// Thanks to Richard Minerich (@rickasaurus) for helping me figure out
// some array concepts in F#.
let mutable pixelData : byte array = [| |]
let mutable skeletons : Skeleton array = [| |]

//Right hand ellipse
let rhEllipse = new System.Windows.Shapes.Ellipse()
rhEllipse.Height <- 20.0
rhEllipse.Width <- 20.0
rhEllipse.Fill <- System.Windows.Media.Brushes.Red
rhEllipse.Stroke <- System.Windows.Media.Brushes.White

//Left hand ellipse
let lhEllipse = new System.Windows.Shapes.Ellipse()
lhEllipse.Height <- 20.0
lhEllipse.Width <- 20.0
lhEllipse.Fill <- System.Windows.Media.Brushes.Red
lhEllipse.Stroke <- System.Windows.Media.Brushes.White

//Head ellipse
let hEllipse = new System.Windows.Shapes.Ellipse()
hEllipse.Height <- 20.0
hEllipse.Width <- 20.0
hEllipse.Fill <- System.Windows.Media.Brushes.Red
hEllipse.Stroke <- System.Windows.Media.Brushes.White

canvas.Children.Add(rhEllipse) |> ignore
canvas.Children.Add(lhEllipse) |> ignore
canvas.Children.Add(hEllipse) |> ignore

let grid = new System.Windows.Controls.Grid()

let winImage = new System.Windows.Controls.Image()
winImage.Height <- 600.0
winImage.Width <- 800.0

grid.Children.Add(winImage) |> ignore
grid.Children.Add(canvas) |> ignore

//Video frame is ready to be processed.
let VideoFrameReady (sender : obj) (args: ColorImageFrameReadyEventArgs) = 
    let receivedData = ref false

    using (args.OpenColorImageFrame()) (fun r -> 
        if (r <> null) then
            (
                pixelData <- Array.create r.PixelDataLength ds
                //Array.Resize(ref pixelData, r.PixelDataLength)
                r.CopyPixelDataTo(pixelData)
                receivedData := true
        )

        if (receivedData <> ref false) then
            (
        winImage.Source <- BitmapSource.Create(640, 480, 96.0, 96.0, Media.PixelFormats.Bgr32, null, pixelData, 640 * 4)
    )
    )

//Required to correlate the skeleton data to the PC screen
//IMPORTANT NOTE: Code for vector scaling was imported from the Coding4Fun Kinect Toolkit
//available here: http://c4fkinect.codeplex.com/
//I only used this part to avoid adding an extra reference.
let ScaleVector (length : float32, position : float32)  =
    let value = (((length / 1.0f) / 2.0f) * position) + (length / 2.0f)
    if value > length then
        length
    elif value < 0.0f then
        0.0f
    else
        value

//This will set the ellipse positions depending on the passed instance and joint
let SetEllipsePosition (ellipse : System.Windows.Shapes.Ellipse, joint : Joint) =
    let vector = new Microsoft.Kinect.SkeletonPoint(X = ScaleVector(640.0f, joint.Position.X), Y=ScaleVector(480.0f, -joint.Position.Y),Z=joint.Position.Z)
    let mutable uJoint = joint
    uJoint.TrackingState <- JointTrackingState.Tracked
    uJoint.Position <- vector

    System.Windows.Controls.Canvas.SetLeft(ellipse,(float uJoint.Position.X))
    System.Windows.Controls.Canvas.SetTop(ellipse,(float uJoint.Position.Y))

//Triggered when a new skeleton frame is ready for processing
let SkeletonFrameReady (sender : obj) (args: SkeletonFrameReadyEventArgs) = 
    let receivedData = ref false

    using (args.OpenSkeletonFrame()) (fun r -> 
        if (r <> null) then
            (
                skeletons <- Array.create r.SkeletonArrayLength dummySkeleton
                r.CopySkeletonDataTo(skeletons)

                for i in skeletons do
                    Debug.WriteLine(i.TrackingState.ToString())

                receivedData := true
        )

        if (receivedData <> ref false) then
            (
                for i in skeletons do
                    if i.TrackingState <> SkeletonTrackingState.NotTracked then
                        (
                        let currentSkeleton = i

                        SetEllipsePosition(hEllipse, currentSkeleton.Joints.[JointType.Head])
                        SetEllipsePosition(lhEllipse, currentSkeleton.Joints.[JointType.HandLeft])
                        SetEllipsePosition(rhEllipse, currentSkeleton.Joints.[JointType.HandRight])
                   )
        )
        )


let WindowLoaded (sender : obj) (args: RoutedEventArgs) = 
    sensor.Start()
    sensor.ColorStream.Enable()
    sensor.SkeletonStream.Enable()
    sensor.ColorFrameReady.AddHandler(new EventHandler<ColorImageFrameReadyEventArgs>(VideoFrameReady))
    sensor.SkeletonFrameReady.AddHandler(new EventHandler<SkeletonFrameReadyEventArgs>(SkeletonFrameReady))

let WindowUnloaded (sender : obj) (args: RoutedEventArgs) = 
    sensor.Stop()

//Defining the structure of the test window
let window = new Window()
window.Width <- 800.0
window.Height <- 600.0
window.Title <- "Kinect Skeleton Application"
window.Loaded.AddHandler(new RoutedEventHandler(WindowLoaded))
window.Unloaded.AddHandler(new RoutedEventHandler(WindowUnloaded))
window.Content <- grid
window.Show()

[<STAThread()>]
do 
    let app = new Application() in
    app.Run(window) |> ignore

#灯
开放系统
开放系统
打开System.Windows.Media.Imaging
打开Microsoft.Kinect
开放系统诊断
let sensor=KinectSensor.KinectSensors。[0]
//处理椭圆的主画布
让canvas=new System.Windows.Controls.canvas（）
canvas.Background我最后根据这篇文章重写了它，骨架跟踪现在开始工作了。仍然对为什么原始代码不能正常工作感兴趣

// Learn more about F# at http://fsharp.net
#light

open System
open System.Windows
open System.Windows.Media.Imaging
open System.Windows.Threading
open Microsoft.Kinect
open System.Diagnostics

[<STAThread>]
do
    let sensor = KinectSensor.KinectSensors.[0]
    sensor.SkeletonStream.Enable()
    sensor.Start()

    // Set-up the WPF window and its contents
    let width = 1024.
    let height = 768.
    let w = Window(Width=width, Height=height)
    let g = Controls.Grid()
    let c = Controls.Canvas()
    let hd = Shapes.Rectangle(Fill=Media.Brushes.Red, Width=15., Height=15.)
    let rh = Shapes.Rectangle(Fill=Media.Brushes.Blue, Width=15., Height=15.)
    let lh = Shapes.Rectangle(Fill=Media.Brushes.Green, Width=15., Height=15.)
    ignore <| c.Children.Add hd
    ignore <| c.Children.Add rh
    ignore <| c.Children.Add lh
    ignore <| g.Children.Add c
    w.Content <- g

    w.Unloaded.Add(fun args -> sensor.Stop())

    let getDisplayPosition w h (joint : Joint) =
        let x = ((w * (float)joint.Position.X + 2.0) / 4.0) + (w/2.0)
        let y = ((h * -(float)joint.Position.Y + 2.0) / 4.0) + (h/2.0)
        System.Console.WriteLine("X:" + x.ToString() + " Y:" + y.ToString())
        new Point(x,y)

    let draw (joint : Joint) (sh : System.Windows.Shapes.Shape) =
        let p = getDisplayPosition width height joint
        sh.Dispatcher.Invoke(DispatcherPriority.Render, Action(fun () -> System.Windows.Controls.Canvas.SetLeft(sh, p.X))) |> ignore
        sh.Dispatcher.Invoke(DispatcherPriority.Render, Action(fun () -> System.Windows.Controls.Canvas.SetTop(sh, p.Y))) |> ignore

    let drawJoints (sk : Skeleton) =
        draw (sk.Joints.Item(JointType.Head)) hd
        draw (sk.Joints.Item(JointType.WristRight)) rh
        draw (sk.Joints.Item(JointType.WristLeft)) lh

    let skeleton (sensor : KinectSensor) =
        let rec loop () =
            async {
                let! args = Async.AwaitEvent sensor.SkeletonFrameReady
                use frame = args.OpenSkeletonFrame()
                let skeletons : Skeleton[] = Array.zeroCreate(frame.SkeletonArrayLength)
                frame.CopySkeletonDataTo(skeletons)
                skeletons 
                |> Seq.filter (fun s -> s.TrackingState <> SkeletonTrackingState.NotTracked)
                |> Seq.iter  (fun s ->  drawJoints s)
                return! loop ()
            }
        loop ()

    skeleton sensor |> Async.Start

    let a = Application()
    ignore <| a.Run(w)

//了解更多关于F#at的信息http://fsharp.net
#轻的
开放系统
开放系统
打开System.Windows.Media.Imaging
打开System.Windows.Threading
打开Microsoft.Kinect
开放系统诊断
[]
做
let sensor=KinectSensor.KinectSensors。[0]
sensor.SkeletonStream.Enable（）
sensor.Start（）
//设置WPF窗口及其内容
让宽度=1024。
让高度=768。
设w=窗（宽=宽，高=高）
设g=Controls.Grid（）
设c=Controls.Canvas（）
设hd=Shapes.Rectangle（填充=Media.brushs.Red，宽度=15，高度=15。）
设rh=Shapes.Rectangle（填充=Media.brusks.Blue，宽度=15，高度=15。）
设lh=Shapes.Rectangle（填充=Media.brushs.Green，宽度=15，高度=15。）
忽视
let drawJoints（sk：骨架）=
图纸（sk接头项目（接头类型头部））hd
图纸（sk.接头.项目（接头类型.右侧））右侧
图纸（sk.接头.项目（接头类型.手腕左））左侧
let骨架（传感器：KinectSensor）=
让rec循环（）=
异步的{
让！args=Async.AwaitEvent sensor.SkeletonFrameReady
使用frame=args.OpenSkeletonFrame（）
let skeletons:Skeleton[]=Array.zeroCreate（frame.skeletonarraylelength）
frame.CopySkeletonDataTo（骨架）
骷髅
|>Seq.filter（趣味s->s.TrackingState SkeletonTrackingState.NotTracking）
|>序号：iter（乐趣->图纸）
返回！循环（）
}
循环（）
骨架传感器|>异步启动
设a=Application（）
忽略在F#中，您在模块内声明的任何值绑定（例如，
let
或
do
）将在第一次打开模块或从其他模块访问模块时执行。如果您熟悉C#，可以将这些值绑定看作是在类型构造函数（即
静态
构造函数）中执行的

我怀疑代码的第二个版本（而不是第一个版本）起作用的原因是，在第二个版本中，您正在创建
窗口
，并从运行应用程序消息循环的STA线程中绘制形状。在第一个版本中，我猜代码是在其他线程上执行的，这就是它不能按预期工作的原因

代码的第二个版本没有问题，但更规范的F#方法是将函数（
getDisplayPosition
，
draw
，等等）从顶级
do
绑定中提升出来。这使得代码更易于阅读，因为这些函数显然没有捕获在
do
中创建的任何本地值