public ManipulationStates DrawAndMonitorBoundingBox(TrackedItem trackedObject, ushort color, int MaxValue, int MinValue, ushort[] frameData, byte[] depthPixels) { //check to see if we're at the beginning of a row before backing out 5px int BoundBoxStart = trackedObject.Col <= this.ObjectParimeterBuffer ? trackedObject.DepthArrayPointer : trackedObject.DepthArrayPointer - this.ObjectParimeterBuffer; int BoundBoxWidth = (trackedObject.Col + trackedObject.Width + (this.ObjectParimeterBuffer * 2)) >= 512 ? trackedObject.Width : trackedObject.Width + (this.ObjectParimeterBuffer * 2); int closePixelCount = 0; if (trackedObject.TrackedPixels == null) trackedObject.TrackedPixels = new List<TrackedPixel>(); var objectBoundaryCenterIndex = BoundBoxStart + ((trackedObject.Height / 2) * 512) + (BoundBoxWidth / 2); var objectTopBoundaryCenterDepth = frameData[objectBoundaryCenterIndex]; var objectCenterIndex = BoundBoxStart + (BoundBoxWidth / 2); var objectCenterDepth = frameData[objectCenterIndex]; if (!IsCalibrating && trackedObject.TrackedPixels.Count > 0) { foreach (TrackedPixel tp in trackedObject.TrackedPixels) { var test = frameData[tp.PixelIndexInDepthFrame]; if (IsZeroDepth) { if (frameData[tp.PixelIndexInDepthFrame] > 0 && frameData[tp.PixelIndexInDepthFrame] < MaxValue * 4 && tp.OrginalDepthValue > MaxValue * 4) { depthPixels[tp.PixelIndexInDepthFrame] = System.Convert.ToByte(4000 / MapDepthToByte); closePixelCount++; } else if (tp.OrginalDepthValue > MaxValue * 4 && frameData[tp.PixelIndexInDepthFrame] == 0) { depthPixels[tp.PixelIndexInDepthFrame] = System.Convert.ToByte(4000 / MapDepthToByte); closePixelCount++; } else if ((tp.OrginalDepthValue == 0 && frameData[tp.PixelIndexInDepthFrame] > 0) && frameData[tp.PixelIndexInDepthFrame] < MaxValue) { //handle when there is a zero value depth reading that is causing Touched/Released to not be recognized if ((frameData[tp.PixelIndexInDepthFrame] > objectTopBoundaryCenterDepth - this.ObjectParimeterBuffer - 50 && frameData[tp.PixelIndexInDepthFrame] < objectTopBoundaryCenterDepth + this.ObjectParimeterBuffer + 50)) { depthPixels[tp.PixelIndexInDepthFrame] = System.Convert.ToByte(4000 / MapDepthToByte); closePixelCount++; } } else { depthPixels[tp.PixelIndexInDepthFrame] = System.Convert.ToByte(color / MapDepthToByte); } } else { if (tp.OrginalDepthValue > MaxValue && frameData[tp.PixelIndexInDepthFrame] < MaxValue && frameData[tp.PixelIndexInDepthFrame] >= MinValue) { depthPixels[tp.PixelIndexInDepthFrame] = System.Convert.ToByte(4000 / MapDepthToByte); closePixelCount++; } else if (tp.OrginalDepthValue < MaxValue && frameData[tp.PixelIndexInDepthFrame] + 10 < tp.OrginalDepthValue && frameData[tp.PixelIndexInDepthFrame] > MinValue) { depthPixels[tp.PixelIndexInDepthFrame] = System.Convert.ToByte(4000 / MapDepthToByte); closePixelCount++; } else if (tp.OrginalDepthValue == 0 && frameData[tp.PixelIndexInDepthFrame] > 0 && (frameData[tp.PixelIndexInDepthFrame] < MaxValue && frameData[tp.PixelIndexInDepthFrame] >= MinValue)) { //handle when there is a zero value depth reading that is causing Touched/Released to not be recognized if ((frameData[tp.PixelIndexInDepthFrame] > objectTopBoundaryCenterDepth - this.ObjectParimeterBuffer - 50 && frameData[tp.PixelIndexInDepthFrame] < objectTopBoundaryCenterDepth + this.ObjectParimeterBuffer + 50)) { depthPixels[tp.PixelIndexInDepthFrame] = System.Convert.ToByte(4000 / MapDepthToByte); closePixelCount++; } } else { depthPixels[tp.PixelIndexInDepthFrame] = System.Convert.ToByte(color / MapDepthToByte); } } } } else { if (IsZeroDepth) { //Check to see if the top is being interacted with for (int i = BoundBoxStart; i < BoundBoxStart + BoundBoxWidth; i++) { depthPixels[i] = System.Convert.ToByte(color / MapDepthToByte); trackedObject.TrackedPixels.Add(new TrackedPixel() { PixelIndexInDepthFrame = i, OrginalDepthValue = frameData[i] }); if (frameData[i] > 0 && frameData[i] <= MaxValue * 4) { depthPixels[i] = System.Convert.ToByte(4000 / MapDepthToByte); closePixelCount++; //reached in close to pixel in object } } } else { //Check to see if the top is being interacted with for (int i = BoundBoxStart; i < BoundBoxStart + BoundBoxWidth; i++) { depthPixels[i] = System.Convert.ToByte(color / MapDepthToByte); trackedObject.TrackedPixels.Add(new TrackedPixel() { PixelIndexInDepthFrame = i, OrginalDepthValue = frameData[i] }); if (frameData[i] <= MaxValue && frameData[i] >= MinValue) { depthPixels[i] = System.Convert.ToByte(4000 / MapDepthToByte); closePixelCount++; //reached in close to pixel in object } } } var adjustFactorForCameraAngle = 0;// (MaxValue - MinValue) / (trackedObject.Height / 4); //Check to see if the sides of the object have been interacted with for (int i = 1; i < trackedObject.Height / 2; i++) { int tmp = frameData[BoundBoxStart + (i * 512)]; if (trackedObject.Col > 5) //Don't draw or monitor the left edge if we're past the edge of the feed { trackedObject.TrackedPixels.Add(new TrackedPixel() { PixelIndexInDepthFrame = BoundBoxStart + (i * 512), OrginalDepthValue = frameData[BoundBoxStart + (i * 512)] }); depthPixels[BoundBoxStart + (i * 512)] = System.Convert.ToByte(color / MapDepthToByte); if (IsZeroDepth) { if (frameData[BoundBoxStart + (i * 512)] > 0 && frameData[BoundBoxStart + (i * 512)] <= MaxValue - (adjustFactorForCameraAngle * i) * 4) { depthPixels[BoundBoxStart + (i * 512)] = System.Convert.ToByte(4000 / MapDepthToByte); closePixelCount++; } } else { if (frameData[BoundBoxStart + (i * 512)] <= MaxValue - (adjustFactorForCameraAngle * i) && frameData[BoundBoxStart + (i * 512)] >= MinValue) { depthPixels[BoundBoxStart + (i * 512)] = System.Convert.ToByte(4000 / MapDepthToByte); closePixelCount++; } } } if ((trackedObject.Col + trackedObject.Width) < 500) //Don't draw or monitors the objects right edge if we're past the feeds edge { depthPixels[BoundBoxStart + (i * 512) + BoundBoxWidth] = System.Convert.ToByte(color / MapDepthToByte); trackedObject.TrackedPixels.Add(new TrackedPixel() { PixelIndexInDepthFrame = BoundBoxStart + (i * 512) + BoundBoxWidth, OrginalDepthValue = frameData[BoundBoxStart + (i * 512) + BoundBoxWidth] }); if (IsZeroDepth) { if (frameData[BoundBoxStart + (i * 512) + BoundBoxWidth] > 0 && frameData[BoundBoxStart + (i * 512) + BoundBoxWidth] <= MaxValue - (adjustFactorForCameraAngle * i) * 4) { depthPixels[BoundBoxStart + (i * 512) + BoundBoxWidth] = System.Convert.ToByte(4000 / MapDepthToByte); closePixelCount++; } } else { if (frameData[BoundBoxStart + (i * 512) + BoundBoxWidth] <= MaxValue - (adjustFactorForCameraAngle * i) && frameData[BoundBoxStart + (i * 512) + BoundBoxWidth] >= MinValue) { depthPixels[BoundBoxStart + (i * 512) + BoundBoxWidth] = System.Convert.ToByte(4000 / MapDepthToByte); closePixelCount++; } } } } } if (IsCalibrating) { //Sometimes we can have pixels that get into our activte detection range because of sensor noise or object angle. //here we try to learn about that noise so when we actuatly try to detect a touch we have a much more accurate theshold if (trackedObject.DS.NosiePixelCount == 0) trackedObject.DS.NosiePixelCount = 0;//closePixelCount; else { trackedObject.DS.NosiePixelCount = 0;// closePixelCount + trackedObject.DS.NosiePixelCount / 2; } return ManipulationStates.NoTrack; } int w = (trackedObject.DepthArrayPointer + (512 * 10)); int currentIndex = (trackedObject.DepthArrayPointer + (512 * 10)); int numberOfPixelsPerObject = (trackedObject.Height / 4) * trackedObject.Width; int existReadCnt = 0; int notExistsReadCnt = 0; //Scan the object space looking for any signs the object is still there... for (int Y = 0; Y < trackedObject.Height / 4; Y++) { for (int X = 0; X < trackedObject.Width; X++) { ushort depth = frameData[currentIndex + X]; if (IsZeroDepth) { if (depth == 0) { depthPixels[currentIndex + X] = System.Convert.ToByte(4000 / MapDepthToByte); existReadCnt++; } else notExistsReadCnt++; } else { if (depth > 0 && depth <= MaxValue) { depthPixels[currentIndex + X] = System.Convert.ToByte(4000 / MapDepthToByte); existReadCnt++; } //Removed - Replaced to handle when object is on the edge which causes many zero value readings else if ((depth == 0 && objectCenterDepth == 0) && depth <= MaxValue) { depthPixels[currentIndex + X] = System.Convert.ToByte(4000 / MapDepthToByte); existReadCnt++; } else { notExistsReadCnt++; } } } currentIndex = w + (512 * Y); } float res = (float)existReadCnt / (float)numberOfPixelsPerObject; var DeviceIsPresent = true; if (res > .10) { } else { DeviceIsPresent = false; } //Try to confirm action by evaluating how many times we've seen this state if (IsZeroDepth) { if (closePixelCount > trackedObject.DS.NosiePixelCount + 5) { trackedObject.NoTouchSampleCount = 0; trackedObject.TouchSampleCount++; } else { trackedObject.NoTouchSampleCount++; trackedObject.TouchSampleCount = 0; } } else { if (closePixelCount > trackedObject.DS.NosiePixelCount + 5) { trackedObject.NoTouchSampleCount = 0; trackedObject.TouchSampleCount++; } else { trackedObject.NoTouchSampleCount++; trackedObject.TouchSampleCount = 0; } } if (closePixelCount > trackedObject.DS.NosiePixelCount + MissingDataTolerance && !IsCalibrating && trackedObject.TouchSampleCount > 10) { //reset the state trackedObject.TouchSampleCount = 0; //Find out if they are putting the camera back in place if (DeviceIsPresent && !trackedObject.DS.DeviceRemoved && !trackedObject.DS.DeviceReplaced && !trackedObject.DS.Touched) { trackedObject.DS.Touched = true; Debug.WriteLine(trackedObject.ObjectID + " " + ManipulationStates.Touched); return ManipulationStates.Touched; } else if (DeviceIsPresent && trackedObject.DS.DeviceRemoved) { trackedObject.DS.DeviceRemoved = false; trackedObject.DS.DeviceReplaced = true; Debug.WriteLine(trackedObject.ObjectID + " " + ManipulationStates.Replaced); return ManipulationStates.Replaced; } } else if (trackedObject.NoTouchSampleCount > 10) { trackedObject.NoTouchSampleCount = 0; //Find out if they are putting the camera back in place if (DeviceIsPresent && trackedObject.DS.Touched) { trackedObject.DS.Touched = false; Debug.WriteLine(trackedObject.ObjectID + " " + ManipulationStates.Released); return ManipulationStates.Released; } else if (!DeviceIsPresent && !trackedObject.DS.DeviceRemoved) { trackedObject.DS.DeviceRemoved = true; Debug.WriteLine(trackedObject.ObjectID + " " + ManipulationStates.Removed); return ManipulationStates.Removed; } else if (DeviceIsPresent && trackedObject.DS.DeviceReplaced) { trackedObject.DS.Touched = false; trackedObject.DS.DeviceReplaced = false; return ManipulationStates.Released; } } return ManipulationStates.NoTrack; }
private void OnItemInteraction(TrackedItem item, ManipulationStates st) { var handler = this.ItemInteraction; if (handler != null) { var kioskEvent = new KioskStateEventArgs(); kioskEvent.ItemSelected = item.ObjectID; kioskEvent.ItemState = st; kioskEvent.TrackingID = this.CorrelationPlayerId; handler(this, kioskEvent); } }
private void UpdateTrackedObjectCollection(TrackedItem potentialTarget) { var existingTarget = (from targets in objects where ((targets.Col - 5) <= potentialTarget.Col && potentialTarget.Col < (targets.Col + targets.Width)) //DEALING WITH OVER LAP issues below && (potentialTarget.Width < targets.Width + 5 && potentialTarget.Width > targets.Width - 5) || ((potentialTarget.Col + potentialTarget.Width >= targets.Col) && (potentialTarget.Col + potentialTarget.Width) <= (targets.Col + targets.Width)) select targets).FirstOrDefault(); if (existingTarget == null) { potentialTarget.Row = potentialTarget.DepthArrayPointer / 512; potentialTarget.DS = new ItemState(); potentialTarget.ObjectID = "Item" + (objects.Count + 1).ToString(); objects.Add(potentialTarget); // notify any bound elements that the text has changed OnPropertyChanged("ObjectCount"); } else { existingTarget.Col = potentialTarget.Col; existingTarget.Width = potentialTarget.Width; existingTarget.DepthArrayPointer = potentialTarget.DepthArrayPointer; existingTarget.Row = potentialTarget.DepthArrayPointer / 512; } }
public void ProcessDepthFrameData(ushort[] frameData, uint depthFrameDataSize, ushort minDepth, ushort maxDepth) { int x = 512 * (int)SamplingRow; int column = StartColSamplingIndex; int startSampleColIndex = x + StartColSamplingIndex; int endSampleColIndex = x + EndColSamplingIndex; //These are being used to draw vertical lines on the screen for targeting purposes int startColDisplayIndex = StartColSamplingIndex; int endColDisplayIndex = EndColSamplingIndex; ushort minDepthTolerance = (ushort)(ObjectDetectionDepthThreshold - ObjectDepthTolerance < 0 ? 0 : ObjectDetectionDepthThreshold - ObjectDepthTolerance); //TopView variables var startDepthSampleIndexTopView = (int)((ObjectDetectionDepthThreshold - ObjectDepthTolerance) / _millimetersPerRow) * _bytesPerRowTopView; var endDepthSampleIndexTopView = (int)((ObjectDetectionDepthThreshold + ObjectDepthTolerance) / _millimetersPerRow) * _bytesPerRowTopView; var startDepthLineIndexTopView = (int)(ObjectDetectionDepthThreshold / _millimetersPerRow) * _bytesPerRowTopView; var endDepthLineIndexTopView = (int)(ObjectDetectionDepthThreshold / _millimetersPerRow) * _bytesPerRowTopView + _bytesPerRowTopView; var startColDisplayIndexTopView = StartColSamplingIndex; var endColDisplayIndexTopView = EndColSamplingIndex; if (IsCalibrating) objects.Clear(); if (IsWindowVisible) { // convert depth to a visual representation for (int i = 0; i < (int)(depthFrameDataSize / DepthFrameDescription.BytesPerPixel); ++i) { #region TopView draw out Monitoring Area int j = i * _topViewBitsPerPixelConversionValue; _topViewDepthPixels[j] = 0; _topViewDepthPixels[j + 1] = 0; _topViewDepthPixels[j + 2] = 0; //depth Threshold line if (j >= startDepthLineIndexTopView && j <= endDepthLineIndexTopView) { _topViewDepthPixels[j] = 255; _topViewDepthPixels[j + 1] = 128; _topViewDepthPixels[j + 2] = 0; } else if (j >= startDepthSampleIndexTopView && j <= (startDepthSampleIndexTopView + _bytesPerRowTopView)) { ////Depth Thresold - Start Tolerance Line _topViewDepthPixels[j] = 0; _topViewDepthPixels[j + 1] = 0; _topViewDepthPixels[j + 2] = 255; } else if (j >= (endDepthSampleIndexTopView - _bytesPerRowTopView) && j <= endDepthSampleIndexTopView) { ////Depth Thresold - End Tolerance Line _topViewDepthPixels[j] = 0; _topViewDepthPixels[j + 1] = 0; _topViewDepthPixels[j + 2] = 255; } //Columns lines if ((j / _topViewBitsPerPixelConversionValue) == startColDisplayIndexTopView) //left line { _topViewDepthPixels[j] = 255; _topViewDepthPixels[j + 1] = 0; _topViewDepthPixels[j + 2] = 0; startColDisplayIndexTopView += 512; } else if ((j / _topViewBitsPerPixelConversionValue) == endColDisplayIndexTopView) //right line { _topViewDepthPixels[j] = 255; _topViewDepthPixels[j + 1] = 0; _topViewDepthPixels[j + 2] = 0; endColDisplayIndexTopView += 512; } #endregion TopView draw out Monitoring Area // Get the depth for this pixel ushort depth = frameData[i]; if (startSampleColIndex <= i && i <= endSampleColIndex && IsCalibrating) { column++; startSampleColIndex++; if (depth <= ObjectDetectionDepthThreshold && depth >= minDepthTolerance) { var temp = GetTargetWidth(i, endSampleColIndex, MissingDataTolerance, ObjectDetectionDepthThreshold, minDepthTolerance, frameData); if (temp > ObjectSizeThreshold) { var NewObject = new TrackedItem() { DepthArrayPointer = i, Width = temp, Col = column, Row = SamplingRow }; //TopView use this Depth value which represents the actual top left depth of the object(FindTopOfObject will change this index to be the top left of the buffer boundary) var objectActualTopLeftDepthPointer = NewObject.DepthArrayPointer; NewObject.DepthArrayPointer = FindTopOfObject(NewObject.DepthArrayPointer, NewObject.Width, ref NewObject.Height, MissingDataTolerance, ObjectDetectionDepthThreshold, minDepthTolerance, frameData); UpdateTrackedObjectCollection(NewObject); ////Top View - Draw points representing the object buffer ////Yellow box represents the Buffer boundaries around the object ////Green line represents the front of the Object being detected decimal objectTopLeftDepthValue = frameData[objectActualTopLeftDepthPointer]; int topViewBytlesPerPixelOverDepthView = 2; // was 3 for PixelFormats.Bgr32 in cnt + 3 if (objectTopLeftDepthValue <= ObjectDetectionDepthThreshold && objectTopLeftDepthValue >= minDepthTolerance) { //Draw the line representing the object... decimal lineValuePercentOfOverallDepth = Math.Round((objectTopLeftDepthValue / 4000m), 2); var depthRowLocation = (int)(lineValuePercentOfOverallDepth * 424); var objectTopLeftIndex = (depthRowLocation * _bytesPerRowTopView) + (NewObject.Col * _topViewBitsPerPixelConversionValue); var objectBufferTopLeftIndex = (depthRowLocation * _bytesPerRowTopView) + ((ObjectParimeterBuffer * _topViewBitsPerPixelConversionValue) + NewObject.Col * _topViewBitsPerPixelConversionValue); ////object top line for (int cnt = 0; cnt < (NewObject.Width * _topViewBitsPerPixelConversionValue); cnt += _topViewBitsPerPixelConversionValue) //width of object { var bufferOffset = (ObjectParimeterBuffer * _topViewBitsPerPixelConversionValue) / 2; if (objectTopLeftIndex > 0 && objectTopLeftIndex + bufferOffset + cnt + topViewBytlesPerPixelOverDepthView < _maxTopViewDepthIndex) { //green _topViewDepthPixels[objectTopLeftIndex + bufferOffset + cnt] = 0; _topViewDepthPixels[objectTopLeftIndex + bufferOffset + cnt + 1] = 255; _topViewDepthPixels[objectTopLeftIndex + bufferOffset + cnt + 2] = 0; } } ////object buffer box for (int cnt = 0; cnt < (NewObject.Width * _topViewBitsPerPixelConversionValue) + (ObjectParimeterBuffer * _topViewBitsPerPixelConversionValue); cnt += _topViewBitsPerPixelConversionValue) //width of object + Object buffer { //object buffer boundaries var objectTopLeftFrontBufferIndex = objectTopLeftIndex - (InteractionFrontBuffer * _bytesPerRowTopView) / 10; if (objectTopLeftFrontBufferIndex > 0 && objectTopLeftFrontBufferIndex + cnt + topViewBytlesPerPixelOverDepthView < _maxTopViewDepthIndex) { //Yellow _topViewDepthPixels[objectTopLeftFrontBufferIndex + cnt] = 0; _topViewDepthPixels[objectTopLeftFrontBufferIndex + cnt + 1] = 255; _topViewDepthPixels[objectTopLeftFrontBufferIndex + cnt + 2] = 255; } var objectTopLeftBackBufferIndex = objectTopLeftIndex + (InteractionBackBuffer * _bytesPerRowTopView) / 10; if (objectTopLeftBackBufferIndex > 0 && objectTopLeftBackBufferIndex + cnt + topViewBytlesPerPixelOverDepthView < _maxTopViewDepthIndex) { //Yellow _topViewDepthPixels[objectTopLeftBackBufferIndex + cnt] = 0; _topViewDepthPixels[objectTopLeftBackBufferIndex + cnt + 1] = 255; _topViewDepthPixels[objectTopLeftBackBufferIndex + cnt + 2] = 255; } //////side lines of object buffer if (cnt == 0 || cnt == ((NewObject.Width * _topViewBitsPerPixelConversionValue) + (ObjectParimeterBuffer * _topViewBitsPerPixelConversionValue) - _topViewBitsPerPixelConversionValue)) { var sidePixelIndex = objectTopLeftFrontBufferIndex + _bytesPerRowTopView; do { if (sidePixelIndex > 0 && sidePixelIndex + cnt + topViewBytlesPerPixelOverDepthView < _maxTopViewDepthIndex) { //Yellow _topViewDepthPixels[sidePixelIndex + cnt] = 0; _topViewDepthPixels[sidePixelIndex + cnt + 1] = 255; _topViewDepthPixels[sidePixelIndex + cnt + 2] = 255; } sidePixelIndex = sidePixelIndex + _bytesPerRowTopView; } while (sidePixelIndex <= objectTopLeftBackBufferIndex); } } } else { var lineValueDepthOutsideThreshold = depth; decimal lineValueDepthPercentOfOverallDepthOutsideThreshold = Math.Round((lineValueDepthOutsideThreshold / 4000m), 2); var depthValueRowLocationOutsideThreshold = (int)(lineValueDepthPercentOfOverallDepthOutsideThreshold * 424); var depthValueColumnOutsideThreshold = i % 512; var depthValueTopLeftIndexOutsideThreshold = (depthValueRowLocationOutsideThreshold * _bytesPerRowTopView) + (depthValueColumnOutsideThreshold * _topViewBitsPerPixelConversionValue); if (depthValueTopLeftIndexOutsideThreshold > 0 && depthValueTopLeftIndexOutsideThreshold + _topViewBitsPerPixelConversionValue < _maxTopViewDepthIndex) { _topViewDepthPixels[depthValueTopLeftIndexOutsideThreshold] = 255; _topViewDepthPixels[depthValueTopLeftIndexOutsideThreshold + 1] = 255; _topViewDepthPixels[depthValueTopLeftIndexOutsideThreshold + 2] = 255; } } //Jump ahead to the end of the detected object column += temp; i += temp; } _depthPixels[i] = (byte)((4000 / MapDepthToByte)); //turn it white //TopView var lineValueDepth = depth; decimal lineValueDepthPercentOfOverallDepth = Math.Round((lineValueDepth / 4000m), 2); var depthValueRowLocation = (int)(lineValueDepthPercentOfOverallDepth * 424); var depthValueColumn = i % 512; var depthValueTopLeftIndex = (depthValueRowLocation * _bytesPerRowTopView) + (depthValueColumn * _topViewBitsPerPixelConversionValue); if (depthValueTopLeftIndex > 0 && depthValueTopLeftIndex + _topViewBitsPerPixelConversionValue < _maxTopViewDepthIndex) { _topViewDepthPixels[depthValueTopLeftIndex] = 255; _topViewDepthPixels[depthValueTopLeftIndex + 1] = 255; _topViewDepthPixels[depthValueTopLeftIndex + 2] = 255; } } else { _depthPixels[i] = (byte)(depth >= minDepth && depth <= maxDepth ? (depth / MapDepthToByte) : 0); //convert depth to gray scale value //TopView var lineValueDepth = depth; decimal lineValueDepthPercentOfOverallDepth = Math.Round((lineValueDepth / 4000m), 2); var depthValueRowLocation = (int)(lineValueDepthPercentOfOverallDepth * 424); var depthValueColumn = i % 512; var depthValueTopLeftIndex = (depthValueRowLocation * _bytesPerRowTopView) + (depthValueColumn * _topViewBitsPerPixelConversionValue); if (depthValueTopLeftIndex > 0 && depthValueTopLeftIndex + _topViewBitsPerPixelConversionValue < _maxTopViewDepthIndex) { _topViewDepthPixels[depthValueTopLeftIndex] = 128; _topViewDepthPixels[depthValueTopLeftIndex + 1] = 128; _topViewDepthPixels[depthValueTopLeftIndex + 2] = 128; } } } else if (i == startColDisplayIndex) //left line { _depthPixels[i] = (byte)((4000 / MapDepthToByte)); //Move pointer to next row startColDisplayIndex += 512; } else if (i == endColDisplayIndex) //right line { _depthPixels[i] = (byte)((4000 / MapDepthToByte)); //Move pointer to next row endColDisplayIndex += 512; } else { // To convert to a byte, we're mapping the depth value to the byte range. // Values outside the reliable depth range are mapped to 0 (black). //int defaultColor = 0; //if(depth >= minDepth && depth <= maxDepth) // defaultColor = (depth / MapDepthToByte); //_depthPixels[i] = (byte)defaultColor; //(byte)(depth >= minDepth && depth <= maxDepth ? defaultColor : 0); //middle line //if (defaultColor > maxDefaultColor) // maxDefaultColor = defaultColor; // To convert to a byte, we're mapping the depth value to the byte range. // Values outside the reliable depth range are mapped to 0 (black). _depthPixels[i] = (byte)(depth >= minDepth && depth <= maxDepth ? (depth / MapDepthToByte) : 0); //middle line } } } foreach (TrackedItem trackedObj in objects) { var st = DrawAndMonitorBoundingBox( trackedObj, (byte)(4000 / MapDepthToByte), ObjectDetectionDepthThreshold + InteractionFrontBuffer, ObjectDetectionDepthThreshold - InteractionBackBuffer, frameData, _depthPixels); if (st != ManipulationStates.NoTrack) { OnItemInteraction(trackedObj, st); if (!IsCalibrating) _interactions.Insert(0, trackedObj.ObjectID + " " + st.ToString()); } else { OnItemInteraction(trackedObj, st); } } RenderDepthPixels(); }
public bool IsTargetInPlace(TrackedItem trackedObject, int Tolerance, int MaxValue, int MinValue, ushort[] frameData, byte[] depthPixels) { int currentIndex = trackedObject.DepthArrayPointer; int existReadCnt = 0; int notExistsReadCnt = 0; //Scan the object space looking for any signs the object is still there... for (int Y = 0; Y < trackedObject.Height / 2; Y++) { for (int X = 0; X < trackedObject.Width; X++) { ushort depth = frameData[currentIndex + X]; if (depth <= MaxValue) { existReadCnt++; } else { notExistsReadCnt++; } } currentIndex = trackedObject.DepthArrayPointer + (512 * Y); } if (existReadCnt > 10) return true; else return false; }