public DepthImagePoint[] CalculateConvexHull() { var hull = new DepthImagePoint[100]; // Sort the points by x-coordinate var sortedPoints = Points.Where(HasDepth).OrderBy(p => p.X); // Calculate the lower hull var n = 0; foreach (var p in sortedPoints) { while (n >= 2 && !Util.IsLeftTurn(hull[n - 2], hull[n - 1], p)) n--; hull[n++] = p; } // Calculate the upper hull var min = n + 1; foreach (var p in sortedPoints.Reverse()) { while (n >= min && !Util.IsLeftTurn(hull[n - 2], hull[n - 1], p)) n--; hull[n++] = p; } // Return the hull elements (the last point is the same as the first) return hull.Take(n - 1).ToArray(); }
/// <summary> /// Map PointDepth3D to PointSkeleton3D /// </summary> /// <param name="depthImageFormat"></param> /// <param name="pointDepth3D"></param> /// <returns></returns> public PointSkeleton3D MapDepthPointToSketelonPoint(DepthImageFormat depthImageFormat, PointDepth3D pointDepth3D) { DepthImagePoint point = new DepthImagePoint(); point.X = pointDepth3D.X; point.Y = pointDepth3D.Y; point.Depth = pointDepth3D.Depth; return new PointSkeleton3D(mapper.MapDepthPointToSkeletonPoint(depthImageFormat, point)); }
/// <summary> /// Maps a point in the depth image to a point in the color image. /// </summary> /// <param name="x">x coordinate in the depth image.</param> /// <param name="y">y coordinate in the depth image.</param> /// <param name="depth">correspoinding depth at (x, y).</param> /// <returns></returns> public ColorImagePoint MapDepthPointToColorPoint(int x, int y, int depth) { var dp = new DepthImagePoint() { X = x, Y = y, Depth = depth }; return mapper.MapDepthPointToColorPoint(dif, dp, cif); }
public MainWindow() { InitializeComponent(); _SkeletonBrushes = new Brush[] { Brushes.Black, Brushes.Crimson, Brushes.Indigo, Brushes.DodgerBlue, Brushes.Purple, Brushes.Pink }; KinectSensor.KinectSensors.StatusChanged += KinectSensors_StatusChanged; this.KinectDevice = KinectSensor.KinectSensors.FirstOrDefault(x => x.Status == KinectStatus.Connected); _previousHandPosition = new DepthImagePoint(); }
public SkeletonPoint MapDepthPointToSkeletonPoint(int x, int y, int depth) { var depthPoint = new DepthImagePoint() { X = x, Y = y, Depth = depth }; return MapDepthPointToSkeletonPoint(depthPoint); }
private static SkeletonPoint? FindDepth(KinectSensor sensor, DepthImagePixel[] depthPixels, Point point, int idx) { if (idx >= 0) { if (!depthPixels[idx].IsKnownDepth) return null; var dp = new DepthImagePoint() { X = (int)point.X, Y = (int)point.Y, Depth = depthPixels[idx].Depth }; return sensor.CoordinateMapper.MapDepthPointToSkeletonPoint(DepthImageFormat.Resolution640x480Fps30, dp); } return null; }
public DepthImagePoint GetJointPosition(KinectSensor sensor, AllFramesReadyEventArgs e, JointType jointType) { Skeleton skeleton = GetTrackedSkeleton(e); DepthImagePoint depthPoint = new DepthImagePoint(); JointDetected = false; if (SkeletonDetected == true) { Joint joint = skeleton.Joints[jointType]; JointDetected = true; SkeletonPoint jointPoint = joint.Position; depthPoint = sensor.MapSkeletonPointToDepth(jointPoint, DepthImageFormat.Resolution320x240Fps30); } return depthPoint; }
public CompositePlayer[] Trigger(int wait) { var sp = Task.Run(() => skeleton.GetSkeletons(wait)); var dp = Task.Run(() => { var result = depth.Get(wait, (pixel, point, size) => { if (!pixel.IsKnownDepth) return null; var dip = new DepthImagePoint() { X = point.X, Y = point.Y, Depth = pixel.Depth }; return (DepthImageIndexedPoint?)new DepthImageIndexedPoint() { Index = pixel.PlayerIndex, Point = dip }; }).ToArray().Where(p => p.HasValue).Select(p => p.Value).ToArray(); return result; }); dp.Wait(); var points = dp.Result; Skeleton[] skeletons = new Skeleton[0]; if (points.Any(p => p.Index >= 1 && p.Index <= 6)) { sp.Wait(); skeletons = sp.Result; } return points.GroupBy(p => p.Index).Select(group => new CompositePlayer() { DepthPoints = group.Select(g => g.Point).ToArray(), PlayerId = group.Key, Skeleton = (group.Key >= 1 && group.Key <= 6) ? skeletons[group.Key - 1] : null }).ToArray(); }
public float[] ToColorSpace(CoordinateMapper mapper, DepthImagePoint point, DepthImageFormat format, float zTune = 0) { var sp = mapper.MapDepthPointToSkeletonPoint(format, point); return ToColorSpace(mapper, sp, zTune); }
private Point posionScale(SkeletonPoint point) { DepthImagePoint depthPoint = this._sensor.CoordinateMapper.MapSkeletonPointToDepthPoint(point, DepthImageFormat.Resolution640x480Fps30); return(new Point(depthPoint.X, depthPoint.Y)); }
int find_code(ColorImageFrame colorFrame, DepthImageFrame depthFrame) { ZXing.Kinect.BarcodeReader reader = new ZXing.Kinect.BarcodeReader(); if (colorFrame != null) { //Decode the colorFrame var result = reader.Decode(colorFrame); if (result != null) { string val = result.Text; int code_num = Convert.ToInt32(val); double center_x = result.ResultPoints[0].X + 0.5 * (result.ResultPoints[2].X - result.ResultPoints[0].X); double center_y = result.ResultPoints[0].Y + 0.5 * (result.ResultPoints[2].Y - result.ResultPoints[0].Y); code_size = new Point((result.ResultPoints[2].X - result.ResultPoints[0].X), (result.ResultPoints[2].Y - result.ResultPoints[0].Y)); // Must mirror the coordinate here -- the depth frame comes in mirrored. center_x = 640 - center_x; // Map the color frame onto the depth frame DepthImagePixel[] depthPixel = new DepthImagePixel[depthFrame.PixelDataLength]; depthFrame.CopyDepthImagePixelDataTo(depthPixel); DepthImagePoint[] depthImagePoints = new DepthImagePoint[sensor.DepthStream.FramePixelDataLength]; sensor.CoordinateMapper.MapColorFrameToDepthFrame(sensor.ColorStream.Format, sensor.DepthStream.Format, depthPixel, depthImagePoints); // Get the point in the depth frame at the center of the barcode int center_point_color_index = (int)center_y * 640 + (int)center_x; DepthImagePoint converted_depth_point = depthImagePoints[center_point_color_index]; Point p = new Point(converted_depth_point.X, converted_depth_point.Y); code_points[code_num] = p; Console.WriteLine("Found code " + code_num + " at (" + center_x + ", " + center_y + ") in color coordinates."); Console.WriteLine("Translated to (" + p.X + ", " + p.Y + ") in depth coordinates."); return code_num; } } return -1; }
private void GrayscaleData(byte[] pixelData) { // Mapping depth to color var mapper = new CoordinateMapper(sensor); var depthPoints = new DepthImagePoint[640 * 480]; mapper.MapColorFrameToDepthFrame(ColorImageFormat.RgbResolution640x480Fps30, DepthImageFormat.Resolution640x480Fps30, depthImagePixels, depthPoints); for (int i = 0; i < depthPoints.Length; i++) { var point = depthPoints[i]; if (point.Depth > 600 || KinectSensor.IsKnownPoint(point)) { var pixelDataIndex = i * 4; var maxValue = Math.Max(pixelData[pixelDataIndex], Math.Max(pixelData[pixelDataIndex + 1], pixelData[pixelDataIndex + 2])); pixelData[pixelDataIndex] = maxValue; pixelData[pixelDataIndex + 1] = maxValue; pixelData[pixelDataIndex + 2] = maxValue; } } }
// // Summary: // Tests whether the DepthImagePoint has a known value. // // Parameters: // depthImagePoint: // The DepthImagePoint to test. // // Returns: // Rreturns false if depth value == 0. public static bool IsKnownPoint(DepthImagePoint depthImagePoint);
private DepthImagePoint MapSkeletonPointToDepth(SkeletonPoint skelpoint, DepthImageFormat depthImageFormat) { DepthImagePoint rPoint = new DepthImagePoint(); rPoint.X = 0; rPoint.Y = 0; if (skelpoint.Z > _FLT_EPSILON) { rPoint.X = (int)(0.5 + skelpoint.X * (_NUI_CAMERA_COLOR_NOMINAL_FOCAL_LENGTH_IN_PIXELS / skelpoint.Z) / 640.0); rPoint.Y = (int)(0.5 - skelpoint.Y * (_NUI_CAMERA_COLOR_NOMINAL_FOCAL_LENGTH_IN_PIXELS / skelpoint.Z) / 480.0); return rPoint; } //Taken from: pytools.codeplex.com -> PyKinect-> nui -> __init__.py //def skeleton_to_depth_image(vPoint, scaleX = 1, scaleY = 1): // """Given a Vector4 returns X and Y coordinates fo display on the screen. Returns a tuple depthX, depthY""" // if vPoint.z > _FLT_EPSILON: // ## // ## Center of depth sensor is at (0,0,0) in skeleton space, and // ## and (160,120) in depth image coordinates. Note that positive Y // ## is up in skeleton space and down in image coordinates. // ## // pfDepthX = 0.5 + vPoint.x * ( _NUI_CAMERA_SKELETON_TO_DEPTH_IMAGE_MULTIPLIER_320x240 / vPoint.z ) / 320.0 // pfDepthY = 0.5 - vPoint.y * ( _NUI_CAMERA_SKELETON_TO_DEPTH_IMAGE_MULTIPLIER_320x240 / vPoint.z ) / 240.0 // return pfDepthX * scaleX, pfDepthY * scaleY // return 0.0, 0.0 return rPoint; }
public void TransformDepthTo3D( Byte [] data ) { CoordinateMapper mapper = new CoordinateMapper( device ); DepthImagePoint pixels = new DepthImagePoint(); SkeletonPoint [] points = new SkeletonPoint[ 320 * 120 ]; var p = mapper.MapDepthPointToSkeletonPoint( DepthImageFormat.Resolution640x480Fps30, pixels ); }
void GetCameraPoint(Skeleton first, AllFramesReadyEventArgs e) { using (DepthImageFrame depth = e.OpenDepthImageFrame()) { if (depth == null || kinectSensorChooser1.Kinect == null) { return; } //Map a joint location to a point on the depth map //head DepthImagePoint headDepthPoint = depth.MapFromSkeletonPoint(first.Joints[JointType.Head].Position); //left hand DepthImagePoint leftDepthPoint = depth.MapFromSkeletonPoint(first.Joints[JointType.HandLeft].Position); //right hand DepthImagePoint rightDepthPoint = depth.MapFromSkeletonPoint(first.Joints[JointType.HandRight].Position); //Map a depth point to a point on the color image //head ColorImagePoint headColorPoint = depth.MapToColorImagePoint(headDepthPoint.X, headDepthPoint.Y, ColorImageFormat.RgbResolution640x480Fps30); //left hand ColorImagePoint leftColorPoint = depth.MapToColorImagePoint(leftDepthPoint.X, leftDepthPoint.Y, ColorImageFormat.RgbResolution640x480Fps30); //right hand ColorImagePoint rightColorPoint = depth.MapToColorImagePoint(rightDepthPoint.X, rightDepthPoint.Y, ColorImageFormat.RgbResolution640x480Fps30); //Set location //CameraPosition(headImage, headColorPoint); //CameraPosition(leftEllipse, leftColorPoint); CameraPosition(RightHand, rightColorPoint); CameraPosition(LeftHand, rightColorPoint); #region HoverButton convertir en Check #region menu HoverButton if (stringhb.Equals("menu")) { CheckButton(menuHbCursosProgramacionExtension, RightHand); CheckButton(menuHbCarrerasProfesionales, RightHand); CheckButton(menuHbConsultoriaInvestigacionAplicada, RightHand); CheckButton(menuHbContactenos, RightHand); } #endregion #region cpe HoverButton if (stringhb.Equals("cpe")) { CheckButton(cpeHbComunicacionesInalambricas, RightHand); CheckButton(cpeHbAdministracionLinux, RightHand); CheckButton(cpeHbTelefoniaIpAsterisk, RightHand); CheckButton(cpeHbVozTelefoniaIp, RightHand); } #endregion #region flecha HoverButton if (flecha == true) { CheckButton(flechaHbIzquierda, RightHand); } #endregion #endregion } }
private bool HasDepth(DepthImagePoint point) { return point.Depth > 0; }
void sensor_AllFramesReady(object sender, AllFramesReadyEventArgs e) { using (DepthImageFrame depthFrame = e.OpenDepthImageFrame()) { if (depthFrame == null) { return; } int minDepth = 850; int maxDepth = 4000; System.Drawing.Bitmap outBmp = new System.Drawing.Bitmap(160, 160); BitmapSource depthBitmapSource; BitmapSource processedBitmapSource; //Get the position of interest on the depthmap from skeletal tracking DepthImagePoint rightHandPoint = jointTracker.GetJointPosition(kinectSensorChooser.Kinect, e, JointType.HandRight); if (jointTracker.JointDetected == true) { textResult.Text = "Right hand is being tracked"; int rightHandDepth = rightHandPoint.Depth; if (rightHandDepth < 850) { minDepth = 850; maxDepth = 1500; } else { minDepth = rightHandDepth - 75; maxDepth = rightHandDepth + 75; } depthBitmapSource = sliceDepthImage(depthFrame, minDepth, maxDepth); //Create a bitmap from the depth information System.Drawing.Bitmap depthBmp = depthBitmapSource.ToBitmap(); //Aforge performs image processing here. outBmp = imageProcessor.ProcessFrame(depthBmp, rightHandPoint.X, rightHandPoint.Y); } else { textResult.Text = "No hand detected"; //depthBitmapSource = sliceDepthImage(depthFrame, 850, 1500); System.Drawing.Graphics g = System.Drawing.Graphics.FromImage(outBmp); g.Clear(System.Drawing.Color.Black); } //Create a bitmapsource to show the processed image processedBitmapSource = outBmp.ToBitmapSource(); //Display the images procImageDisplay.Source = processedBitmapSource; } }
void sensor_AllFramesReady(object sender, AllFramesReadyEventArgs e) { if (testnumber == 1) { getSelectedFiles(); startDrag(); testnumber = 0; } drag(); if (closing) { return; } //Get a skeleton Skeleton first = GetFirstSkeleton(e); if (first == null) { return; } //set scaled position //ScalePosition(headImage, first.Joints[JointType.Head]); //ScalePosition(leftEllipse, first.Joints[JointType.HandLeft]); ScalePosition(Cursor, first.Joints[JointType.HandRight]); using (DepthImageFrame depth = e.OpenDepthImageFrame()) { if (depth == null || kinectSensorChooser1.Kinect == null) { return; } float[] skeletonValues = new float[9]; DepthImagePoint leftSkeletalPoint2 = depth.MapFromSkeletonPoint(first.Joints[JointType.HandLeft].Position); DepthImagePoint rightSkeletalPoint2 = depth.MapFromSkeletonPoint(first.Joints[JointType.HandRight].Position); DepthImagePoint headDepthPoint = depth.MapFromSkeletonPoint(first.Joints[JointType.Head].Position); skeletonValues[0] = leftSkeletalPoint2.X; skeletonValues[1] = leftSkeletalPoint2.Y; skeletonValues[2] = leftSkeletalPoint2.Depth; skeletonValues[3] = rightSkeletalPoint2.X; skeletonValues[4] = rightSkeletalPoint2.Y; skeletonValues[5] = rightSkeletalPoint2.Depth; skeletonValues[6] = headDepthPoint.X; skeletonValues[7] = headDepthPoint.Y; skeletonValues[8] = headDepthPoint.Depth; storedSkeletonValues.Add(skeletonValues); System.Windows.Forms.Cursor.Position = new System.Drawing.Point((int)RHPos[0], (int)RHPos[1]); if (!actionWait) { if (!selectActivated) { CheckSwipe(e); } CheckStatic(e); } if (lassoFilesDragging) { //Console.WriteLine("lassofiles dragging"); //myimg_MouseMove(); CursorInCommitBoxZone(); CursorInTrashZone(); } if (selectActivated) { mouseLeftDown(); } } GetCameraPoint(first, e); /*if (selectActivated) * { * FollowPointer(); * } * */ FollowPointer(); }
public void Evaluate(int SpreadMax) { if (this.FInvalidateConnect) { if (runtime != null) { this.runtime.SkeletonFrameReady -= SkeletonReady; } if (this.FInRuntime.PluginIO.IsConnected) { //Cache runtime node this.runtime = this.FInRuntime[0]; if (runtime != null) { this.FInRuntime[0].SkeletonFrameReady += SkeletonReady; } } this.FInvalidateConnect = false; } if (this.FInvalidate) { if (this.lastframe != null) { List <Skeleton> skels = new List <Skeleton>(); float z = float.MaxValue; int id = -1; lock (m_lock) { foreach (Skeleton sk in this.lastframe) { if (sk.TrackingState == SkeletonTrackingState.Tracked) { skels.Add(sk); } } } int cnt = skels.Count; this.FOutCount[0] = cnt; this.FOutPosition.SliceCount = cnt; this.FOutUserIndex.SliceCount = cnt; this.FOutClipped.SliceCount = cnt; this.FOutJointPosition.SliceCount = cnt * 20; this.FOutJointColorPosition.SliceCount = cnt * 20; this.FOutJointDepthPosition.SliceCount = cnt * 20; this.FOutJointState.SliceCount = cnt * 20; this.FOutJointID.SliceCount = cnt * 20; this.FOutJointOrientation.SliceCount = cnt * 20; this.FOutJointWOrientation.SliceCount = cnt * 20; this.FOutJointTo.SliceCount = cnt * 20; this.FOutJointFrom.SliceCount = cnt * 20; this.FOutFrameNumber[0] = this.frameid; int jc = 0; for (int i = 0; i < cnt; i++) { Skeleton sk = skels[i]; this.FOutPosition[i] = new Vector3(sk.Position.X, sk.Position.Y, sk.Position.Z); this.FOutUserIndex[i] = sk.TrackingId; Vector4 clip = Vector4.Zero; clip.X = Convert.ToSingle(sk.ClippedEdges.HasFlag(FrameEdges.Left)); clip.Y = Convert.ToSingle(sk.ClippedEdges.HasFlag(FrameEdges.Right)); clip.Z = Convert.ToSingle(sk.ClippedEdges.HasFlag(FrameEdges.Top)); clip.W = Convert.ToSingle(sk.ClippedEdges.HasFlag(FrameEdges.Bottom)); this.FOutClipped[i] = clip; foreach (Joint joint in sk.Joints) { this.FOutJointFrom[jc] = sk.BoneOrientations[joint.JointType].StartJoint.ToString(); this.FOutJointTo[jc] = sk.BoneOrientations[joint.JointType].EndJoint.ToString(); BoneRotation bo = sk.BoneOrientations[joint.JointType].HierarchicalRotation; BoneRotation bow = sk.BoneOrientations[joint.JointType].AbsoluteRotation; this.FOutJointID[jc] = joint.JointType.ToString(); this.FOutJointPosition[jc] = new Vector3(joint.Position.X, joint.Position.Y, joint.Position.Z); ColorImagePoint cp = this.runtime.Runtime.MapSkeletonPointToColor(joint.Position, ColorImageFormat.RgbResolution640x480Fps30); this.FOutJointColorPosition[jc] = new Vector2(cp.X, cp.Y); DepthImagePoint dp = this.runtime.Runtime.MapSkeletonPointToDepth(joint.Position, DepthImageFormat.Resolution320x240Fps30); this.FOutJointDepthPosition[jc] = new Vector4(dp.X, dp.Y, dp.Depth, dp.PlayerIndex); this.FOutJointOrientation[jc] = new Quaternion(bo.Quaternion.X, bo.Quaternion.Y, bo.Quaternion.Z, bo.Quaternion.W); this.FOutJointWOrientation[jc] = new Quaternion(bow.Quaternion.X, bow.Quaternion.Y, bow.Quaternion.Z, bow.Quaternion.W); this.FOutJointState[jc] = joint.TrackingState.ToString(); jc++; } } } else { this.FOutCount[0] = 0; this.FOutPosition.SliceCount = 0; this.FOutUserIndex.SliceCount = 0; this.FOutJointID.SliceCount = 0; this.FOutJointPosition.SliceCount = 0; this.FOutJointState.SliceCount = 0; this.FOutFrameNumber[0] = 0; this.FOutJointOrientation.SliceCount = 0; this.FOutJointWOrientation.SliceCount = 0; this.FOutJointTo.SliceCount = 0; this.FOutJointFrom.SliceCount = 0; this.FOutJointColorPosition.SliceCount = 0; this.FOutJointDepthPosition.SliceCount = 0; } this.FInvalidate = false; } }
private IEnumerable<DepthImagePoint> MooreNeighbourhood(DepthImagePoint center, DepthImagePoint start) { var x = start.X; var y = start.Y; for (var i = 0; i < 8; i++) { // Circle the center point var dx = x - center.X; var dy = y - center.Y; if (dx + dy != 0) x -= dy; if (dx - dy != 0) y += dx; // Skip pixels outside the image boundaries if (0 <= x && x < Width && 0 <= y && y < Height) { yield return DepthPointAt(x, y); } } }
internal void OnFrameReady(KinectSensor kinectSensor, ColorImageFormat colorImageFormat, byte[] colorImage, DepthImageFormat depthImageFormat, DepthImagePixel[] depthImage, DepthImagePoint[] colorMappedDepthPoints, Skeleton skeletonOfInterest = null) { this.Sensor = kinectSensor; if (this.ColorImageFormat != colorImageFormat) { this.ColorImageFormat = colorImageFormat; } if (this.DepthImageFormat != depthImageFormat) { this.DepthImageFormat = depthImageFormat; } this._colorMappedDepthPoints = colorMappedDepthPoints; OnFrameReadyOverride(kinectSensor, colorImageFormat, colorImage, depthImageFormat, depthImage, skeletonOfInterest); }
public void Update(DepthImagePoint point, double ratioX = 1.0, double ratioY = 1.0) { Update(point.X * ratioX, point.Y * ratioY); }
/// <summary> /// Updates the face tracking information for this skeleton /// </summary> protected override void OnFrameReadyOverride(KinectSensor kinectSensor, ColorImageFormat colorImageFormat, byte[] colorImage, DepthImageFormat depthImageFormat, DepthImagePixel[] depthImage, Skeleton skeletonOfInterest = null) { if (skeletonOfInterest == null || skeletonOfInterest.TrackingState != SkeletonTrackingState.Tracked) { // nothing to do with an untracked skeleton. return; } var mapper = kinectSensor.CoordinateMapper; var depthWidth = kinectSensor.DepthStream.FrameWidth; var headJoint = skeletonOfInterest.Joints[JointType.Head]; var neckJoint = skeletonOfInterest.Joints[JointType.ShoulderCenter]; _headPoint = mapper.MapSkeletonPointToDepthPoint(headJoint.Position, depthImageFormat); _neckPoint = mapper.MapSkeletonPointToDepthPoint(neckJoint.Position, depthImageFormat); _headPoint.X = depthWidth - _headPoint.X; _neckPoint.X = depthWidth - _neckPoint.X; //VerifyFaceTracker(kinectSensor); //BackgroundWorker worker = new BackgroundWorker(); //worker.DoWork += (s, e) => // { //if (this.faceTracker != null) //{ // var shortImage = Helpers.ConvertDepthImagePixelToShort(depthImage); // FaceTrackFrame frame = this.faceTracker.Track( // colorImageFormat, colorImage, depthImageFormat, shortImage, skeletonOfInterest); // UpdateFrame(frame); //} // }; //worker.RunWorkerCompleted += (s, e) => // { // }; //worker.RunWorkerAsync(); }
private void ReconhecerDistancia(DepthImageFrame quadro, byte[] bytesImagem, int maxDistancia) { if (quadro == null || bytesImagem == null) return; using (quadro) { DepthImagePixel[] imagemProfundidade = new DepthImagePixel[quadro.PixelDataLength]; quadro.CopyDepthImagePixelDataTo(imagemProfundidade); DepthImagePoint[] pontosImagemProfundidade = new DepthImagePoint[640 * 480]; Kinect.CoordinateMapper .MapColorFrameToDepthFrame(Kinect.ColorStream.Format, Kinect.DepthStream.Format, imagemProfundidade, pontosImagemProfundidade); for (int i = 0; i < pontosImagemProfundidade.Length; i++) { var point = pontosImagemProfundidade[i]; if (point.Depth < maxDistancia && KinectSensor.IsKnownPoint(point)) { var pixelDataIndex = i * 4; byte maiorValorCor = Math.Max(bytesImagem[pixelDataIndex], Math.Max(bytesImagem[pixelDataIndex + 1], bytesImagem[pixelDataIndex + 2])); bytesImagem[pixelDataIndex] = maiorValorCor; bytesImagem[pixelDataIndex + 1] = maiorValorCor; bytesImagem[pixelDataIndex + 2] = maiorValorCor; } } } }
protected void HitTest(object sender,SkeletonFrameReadyEventArgs e) { if(IsEnabled) using(SkeletonFrame skeletonFrame=e.OpenSkeletonFrame()) if(skeletonFrame!=null){ Skeleton[] skeletons=new Skeleton[skeletonFrame.SkeletonArrayLength]; skeletonFrame.CopySkeletonDataTo(skeletons); Skeleton firstTrackedSkeleton=null; foreach(Skeleton skel in skeletons) if(skel.TrackingState==SkeletonTrackingState.Tracked){ firstTrackedSkeleton=skel; break; } if(firstTrackedSkeleton==null){ IsTracking=false; IsHitting=false; return; } int hittingJointCount=0; JointType firstHittingJoint=JointType.Head; DepthImagePoint firstHittingPoint=new DepthImagePoint(); foreach(JointType joint in Joints){ var jointPoint=sensor.CoordinateMapper.MapSkeletonPointToDepthPoint(firstTrackedSkeleton.Joints[joint].Position,DepthImageFormat.Resolution640x480Fps30); var HitTestResult=jointPoint.X>=SliderBounds.Left&&jointPoint.X<=SliderBounds.Right&&jointPoint.Y>=SliderBounds.Top&&jointPoint.Y<=SliderBounds.Bottom; if(HitTestResult){ if(hittingJointCount==0){ firstHittingJoint=joint; firstHittingPoint=jointPoint; } hittingJointCount++; } } if(hittingJointCount>0&&!IsHitting){ IsHitting=true; OnHitting(new JointHittingEventArgs(firstHittingJoint)); }else if(hittingJointCount==0&&IsHitting){ IsHitting=false; OnLeave(); } if(IsHitting){ if(Orientation==Orientation.Horizontal){ var sliderValue=((firstHittingPoint.X-SliderBounds.Left)/SliderBounds.Width)*Maximum; Value=(int)sliderValue; }else{ var sliderValue=((SliderBounds.Height-firstHittingPoint.Y+SliderBounds.Top)/SliderBounds.Height)*Maximum; Value=(int)sliderValue; } } } return; }
/// <summary> /// Allows the game to perform any initialization it needs to before starting to run. /// This is where it can query for any required services and load any non-graphic /// related content. Calling base.Initialize will enumerate through any components /// and initialize them as well. /// </summary> /// void ProcSide(DepthImagePoint hand, DepthImagePoint Elbow, DepthImagePoint Shoulder, Hand obj, String name) { double UpArm = Math.Sqrt(((Elbow.X - Shoulder.X) * (Elbow.X - Shoulder.X)) + ((Elbow.Y - Shoulder.Y) * (Elbow.Y - Shoulder.Y)) + ((Elbow.Depth - Shoulder.Depth) * (Elbow.Depth - Shoulder.Depth))); double forArmD = (Elbow.Depth - hand.Depth); //(hand.Y < (.8 * Elbow.Y) || Elbow.Y < (Shoulder.Y + (UpArm / 2))) //Console.Write(" {0}, {1}, {2}\n", hand.Depth > Elbow.Depth * 0.92, hand.Depth, Elbow.Depth); if (inMenu == true) { if (hand.X <= 400 && hand.X >= 100 && hand.Y <= 400 && hand.Y >= 300) { menuTimer++; if (menuTimer >= 100) { inMenu = false; } } else if (hand.X <= 720 && hand.X >= 420 && hand.Y <= 400 && hand.Y >= 300) { menuTimer++; if (menuTimer >= 100) { exiting = true; } } else { } } else { if (hand.X <= Shoulder.X + 50 && hand.X >= Shoulder.X - 50 && hand.Y <= Shoulder.Y + 50 && hand.Y >= Shoulder.Y - 50 && hand.Depth <= Shoulder.Depth + 50 && hand.Depth >= Shoulder.Depth - 50) { inMenu = true; } else if (/*(hand.Depth > Elbow.Depth * 0.92) /*&& (hand.Y < (1.3 * Elbow.Y))*/ Shoulder.Depth >= (hand.Depth + 250)) { if (Shoulder.Depth >= (hand.Depth + 325)) { obj.pressed = true; } else { obj.pressed = false; } } else { //Console.Write("{0} Rest\n", name); } //Console.Write("UpArm: {0}, ForArmD: {1}, Y: {2}\n", UpArm, forArmD, hand.Y); } }
private SkeletonPoint? GetExtremeBodyPoint(DepthImageFrame Dif, bool highest) { Skeleton skeleton = getCurrentSkeleton(); if (skeleton != null) { if (skeleton.Joints[JointType.Head].TrackingState != JointTrackingState.Tracked) { return null; } int skeletonIndex = -1; for (int i = 0; i < _skeletons.Count(); i++) { if (_skeletons[i].TrackingId == _id) { skeletonIndex = i + 1; break; } } for (int i = highest ? 0 : _depthPixelData.Count() - 1; highest ? i < _depthPixelData.Count():i >= 0;) { short pixel = _depthPixelData[i]; if ((pixel & DepthImageFrame.PlayerIndexBitmask) == skeletonIndex) { DepthImagePoint dip = new DepthImagePoint(); dip.X = (i % Dif.Width); dip.Y = (i / Dif.Width); dip.Depth = pixel >> DepthImageFrame.PlayerIndexBitmaskWidth; return _kinectSensor.CoordinateMapper.MapDepthPointToSkeletonPoint(DepthImageFormat.Resolution640x480Fps30, dip); } if (highest) { i++; } else { i--; } } } return null; }
/// <summary> /// Callback to help with mapping depth pixel to color pixel data. Uses Kinect sensor's MapDepthToColorImagePoint to /// do the conversion /// </summary> /// <returns> /// The depth to color callback. /// </returns> private int DepthToColorCallback( uint depthFrameWidth, uint depthFrameHeight, uint colorFrameWidth, uint colorFrameHeight, float zoomFactor, Point viewOffset, int depthX, int depthY, ushort depthZ, out int colorX, out int colorY) { int retCode = 0; colorX = 0; colorY = 0; if (this.sensor != null) { var colorPoint = new ColorImagePoint(); try { DepthImagePoint depthImagePoint = new DepthImagePoint() { X = depthX, Y = depthY, Depth = depthZ, }; colorPoint = this.sensor.CoordinateMapper.MapDepthPointToColorPoint( this.sensor.DepthStream.Format, depthImagePoint, this.sensor.ColorStream.Format); } catch (InvalidOperationException e) { string traceStr = string.Format( CultureInfo.CurrentCulture, "Exception on MapDepthToColorImagePoint while translating depth point({0},{1},{2}). Exception={3}", depthX, depthY, depthZ, e.Message); Trace.WriteLineIf(this.traceLevel >= TraceLevel.Error, traceStr, TraceCategory); retCode = -1; } colorX = colorPoint.X; colorY = colorPoint.Y; } else { retCode = -1; } return retCode; }
public void updateHand(DepthImagePoint newP) { P = newP; m_position.X = P.X; m_position.Y = P.Y; }
private void ReconhecerProfundidade(byte[] bytesImagem, int distanciaMaxima, DepthImagePixel[] imagemProfundidade) { DepthImagePoint[] pontosImagemProfundidade = new DepthImagePoint[640 * 480]; kinect.CoordinateMapper.MapColorFrameToDepthFrame(kinect.ColorStream.Format, kinect.DepthStream.Format, imagemProfundidade, pontosImagemProfundidade); for (int i = 0; i < pontosImagemProfundidade.Length; i++) { var point = pontosImagemProfundidade[i]; if (point.Depth < distanciaMaxima && KinectSensor.IsKnownPoint(point)) { var pixelDataIndex = i * 4; byte maiorValorCor = Math.Max(bytesImagem[pixelDataIndex], Math.Max(bytesImagem[pixelDataIndex + 1], bytesImagem[pixelDataIndex + 2])); bytesImagem[pixelDataIndex] = maiorValorCor; bytesImagem[pixelDataIndex + 1] = maiorValorCor; bytesImagem[pixelDataIndex + 2] = maiorValorCor; } } }
public void setJoints(AllFramesReadyEventArgs e, Skeleton skeleton) { using (DepthImageFrame depth = e.OpenDepthImageFrame()) { if (depth != null) { //Map a joint location to a point on the depth map lastHead = currHead; lastNeck = currNeck; lastSpine = currSpine; lastHipCenter = currHipCenter; lastLeftHand = currLeftHand; lastLeftWrist = currLeftWrist; lastLeftElbow = currLeftElbow; lastLeftShoulder = currLeftShoulder; lastRightHand = currRightHand; lastRightWrist = currRightWrist; lastRightElbow = currRightElbow; lastRightShoulder = currRightShoulder; currHead = depth.MapFromSkeletonPoint(skeleton.Joints[JointType.Head].Position); currNeck = depth.MapFromSkeletonPoint(skeleton.Joints[JointType.ShoulderCenter].Position); currSpine = depth.MapFromSkeletonPoint(skeleton.Joints[JointType.Spine].Position); currHipCenter = depth.MapFromSkeletonPoint(skeleton.Joints[JointType.HipCenter].Position); currLeftHand = depth.MapFromSkeletonPoint(skeleton.Joints[JointType.HandLeft].Position); currLeftWrist = depth.MapFromSkeletonPoint(skeleton.Joints[JointType.WristLeft].Position); currLeftElbow = depth.MapFromSkeletonPoint(skeleton.Joints[JointType.ElbowLeft].Position); currLeftShoulder = depth.MapFromSkeletonPoint(skeleton.Joints[JointType.ShoulderLeft].Position); currRightHand = depth.MapFromSkeletonPoint(skeleton.Joints[JointType.HandRight].Position); currRightWrist = depth.MapFromSkeletonPoint(skeleton.Joints[JointType.WristRight].Position); currRightElbow = depth.MapFromSkeletonPoint(skeleton.Joints[JointType.ElbowRight].Position); currRightShoulder = depth.MapFromSkeletonPoint(skeleton.Joints[JointType.ShoulderRight].Position); } } }
public static DepthImagePoint Midpoint(DepthImagePoint p1, DepthImagePoint p2) { return new DepthImagePoint { X = (p1.X + p2.X) / 2, Y = (p1.Y + p2.Y) / 2, Depth = (p1.Depth + p2.Depth) / 2 }; }
public static double GetBodySegmentAngle(DepthImagePoint j1, DepthImagePoint j2, DepthImagePoint j3) { return Vector3.angleBetween(new Vector3(j1.X, j1.Y, 0), new Vector3(j2.X, j2.Y, 0), new Vector3(j3.X, j3.Y, 0)); }
public HandInputEvent(DepthImagePoint leftHand, DepthImagePoint rightHand) { LeftHand = leftHand; RightHand = rightHand; }
private Point SkeletonPointToScreen(SkeletonPoint skelpoint) { DepthImagePoint depthPoint = this.sensor.CoordinateMapper.MapSkeletonPointToDepthPoint(skelpoint, DepthImageFormat.Resolution640x480Fps30); return(new Point(depthPoint.X, depthPoint.Y)); }