public static PXCMPointI32 GetTrackedPoint(PXCMBlobExtractor.BlobData blobData, BlobUtilityClass.TrackingBlobPoint blobPointToTrack)
{
PXCMPointI32 point = new PXCMPointI32();
switch (blobPointToTrack)
{
case TrackingBlobPoint.BottomPoint:
point = blobData.bottomPoint;
break;
case TrackingBlobPoint.TopPoint:
point = blobData.topPoint;
break;
case TrackingBlobPoint.RightPoint:
point = blobData.rightPoint;
break;
case TrackingBlobPoint.LeftPoint:
point = blobData.leftPoint;
break;
case TrackingBlobPoint.CenterPoint:
//converting to int
point.x = (int)blobData.centerPoint.x;
point.y = (int)blobData.centerPoint.y;
break;
case TrackingBlobPoint.ClosestPoint:
point = blobData.closestPoint;
break;
}
return(point);
}
public static PXCMPointI32 ToPXCMPointI32(this Vector2D v)
{
var ret = new PXCMPointI32();
ret.x = (int)v.x;
ret.y = (int)v.y;
return ret;
}
public static PXCMPointI32 GetTrackedPoint(PXCMBlobExtractor.BlobData blobData, BlobUtilityClass.TrackingBlobPoint blobPointToTrack)
{
PXCMPointI32 point = new PXCMPointI32();
switch (blobPointToTrack)
{
case TrackingBlobPoint.BottomPoint:
point = blobData.bottomPoint;
break;
case TrackingBlobPoint.TopPoint:
point = blobData.topPoint;
break;
case TrackingBlobPoint.RightPoint:
point = blobData.rightPoint;
break;
case TrackingBlobPoint.LeftPoint:
point = blobData.leftPoint;
break;
case TrackingBlobPoint.CenterPoint:
//converting to int
point.x = (int)blobData.centerPoint.x;
point.y = (int)blobData.centerPoint.y;
break;
case TrackingBlobPoint.ClosestPoint:
point = blobData.closestPoint;
break;
}
return point;
}
// 輪郭の点を描画する
void drawContour( PXCMPointI32[] points, int index )
{
var polygon = new Polygon()
{
Stroke = (index == 0) ? Brushes.DarkGray : Brushes.LightGray,
StrokeThickness = 5,
};
// 点と点を線で結ぶ
foreach ( var point in points ){
polygon.Points.Add( new Point( point.x, point.y ) );
}
CanvasHandParts.Children.Add( polygon );
}
public void Evaluate(int SpreadMax)
{
if( (FContext.SliceCount > 0) && (FContext[0].Configured) )
{
processConfig();
// Iterate over blobs from right to left
try
{
Int32 iBlobsNum = FContext[0].blobData.QueryNumberOfBlobs();
FCenter.SliceCount = iBlobsNum;
FOuterPoints.SliceCount = iBlobsNum;
FInnerPoints.SliceCount = iBlobsNum;
FClosest.SliceCount = iBlobsNum;
FBlobsCount[0] = iBlobsNum;
var ImageSize = FContext[0].DepthImageSize;
FImage.SliceCount = iBlobsNum;
PXCMBlobData.IBlob[] blobList = new PXCMBlobData.IBlob[iBlobsNum];
for (int i = 0; i < iBlobsNum; i++)
{
FContext[0].blobData.QueryBlob(i,
PXCMBlobData.SegmentationImageType.SEGMENTATION_IMAGE_DEPTH,
PXCMBlobData.AccessOrderType.ACCESS_ORDER_NEAR_TO_FAR,
out blobList[i]);
// handle extracted blob data
Int32 nContours = blobList[i].QueryNumberOfContours();
if (nContours > 0)
{
//contourPts
for (int k = 0; k < nContours; ++k)
{
PXCMBlobData.IContour ContourData;
blobList[i].QueryContour(k, out ContourData);
int contourSize = ContourData.QuerySize();
PXCMPointI32[] ContourPoints = new PXCMPointI32[contourSize];
ContourData.QueryPoints(out ContourPoints);
if(ContourPoints.Length > 0)
{
if( (ContourData.IsOuter() == true) )
{
FOuterPoints[i].SliceCount = ContourPoints.Length;
for(int index = 0; index < ContourPoints.Length; index++) FOuterPoints[i][index] = new Vector2D(ContourPoints[index].x / (float)ImageSize.x * 2.0f - 1.0f, 1.0f - ContourPoints[index].y / (float)ImageSize.y * 2.0f);
//Parallel.For (0, ContourPoints.Length, index => { FOuterPoints[i][index] = new Vector2D(ContourPoints[index].x / (float)ImageSize.x * 2.0f - 1.0f, 1.0f - ContourPoints[index].y / (float)ImageSize.y * 2.0f); );
}
/*
else
{
FInnerPoints[i].SliceCount = ContourPoints.Length;
for (int p = 0; p < ContourPoints.Length; p++)
{
Parallel.For (0, ContourPoints.Length,
index => { FInnerPoints[i][index] = new Vector2D(ContourPoints[index].x / (float)ImageSize.x * 2.0f - 1.0f, 1.0f - ContourPoints[index].y / (float)ImageSize.y * 2.0f); }
);
}
}
*/
}
}
PXCMImage BlobImage;
if (FContext[0].blobConfig.IsSegmentationImageEnabled() && blobList[i].QuerySegmentationImage(out BlobImage) >= pxcmStatus.PXCM_STATUS_NO_ERROR)
{
PXCMImage.ImageData BlobImageData;
if (BlobImage.AcquireAccess(PXCMImage.Access.ACCESS_READ, PXCMImage.PixelFormat.PIXEL_FORMAT_Y8, out BlobImageData) >= pxcmStatus.PXCM_STATUS_NO_ERROR)
{
FImage[i] = new RSSDKImage();
FImage[i].Source = BlobImage;
FImage[i].Data = BlobImage.GetY8Pixels();
FImage[i].Source = BlobImage;
FImage[i].Width = BlobImage.info.width;
FImage[i].Height = BlobImage.info.height;
FImage[i].Format = PXCMImage.PixelFormat.PIXEL_FORMAT_Y8;
BlobImage.ReleaseAccess(BlobImageData);
}
}
}
FCenter[i] = blobList[i].QueryExtremityPoint(PXCMBlobData.ExtremityType.EXTREMITY_CENTER).ToVector3D();
FClosest[i] = blobList[i].QueryExtremityPoint(PXCMBlobData.ExtremityType.EXTREMITY_CLOSEST).ToVector3D();
}
}
catch (Exception)
{
//Flogger.Log();
}
}
}
public override bool Process(Trigger trigger)
{
trigger.ErrorDetected = false;
if (!SenseToolkitManager.Instance.IsSenseOptionSet(SenseOption.SenseOptionID.VideoDepthStream))
{
trigger.ErrorDetected = true;
Debug.LogError("Blob Analysis Module Not Set");
return(false);
}
if (!(trigger is TrackTrigger))
{
trigger.ErrorDetected = true;
return(false);
}
bool success = false;
// make sure we have valid values
if (RealWorldBoxDimensions.x <= 0)
{
RealWorldBoxDimensions.x = 1;
}
if (RealWorldBoxDimensions.y <= 0)
{
RealWorldBoxDimensions.y = 1;
}
if (RealWorldBoxDimensions.z <= 0)
{
RealWorldBoxDimensions.z = 1;
}
if (SenseToolkitManager.Instance != null && SenseToolkitManager.Instance.Initialized && SenseToolkitManager.Instance.BlobExtractor != null && SenseToolkitManager.Instance.ImageDepthOutput != null)
{
// Setting max distance for this rule and process the image
PXCMBlobExtractor.BlobData _blobData = new PXCMBlobExtractor.BlobData();
SenseToolkitManager.Instance.BlobExtractor.SetMaxDistance(MaxDistance * 10);
var sts = SenseToolkitManager.Instance.BlobExtractor.ProcessImage(SenseToolkitManager.Instance.ImageDepthOutput);
if (sts >= pxcmStatus.PXCM_STATUS_NO_ERROR && SenseToolkitManager.Instance.BlobExtractor.QueryNumberOfBlobs() > 0)
{
if (BlobIndex >= SenseToolkitManager.Instance.BlobExtractor.QueryNumberOfBlobs())
{
return(false);
}
PXCMImage.ImageInfo info = SenseToolkitManager.Instance.ImageDepthOutput.QueryInfo();
info.format = PXCMImage.PixelFormat.PIXEL_FORMAT_Y8;
PXCMImage new_image = SenseToolkitManager.Instance.SenseManager.session.CreateImage(info);
// Process Tracking
SenseToolkitManager.Instance.BlobExtractor.QueryBlobData(BlobIndex, new_image, out _blobData);
new_image.Dispose();
TrackTrigger specificTrigger = (TrackTrigger)trigger;
PXCMPointI32 trackedPoint = BlobUtilityClass.GetTrackedPoint(_blobData, BlobPointToTrack);
PXCMImage.ImageData data;
SenseToolkitManager.Instance.ImageDepthOutput.AcquireAccess(PXCMImage.Access.ACCESS_READ, PXCMImage.PixelFormat.PIXEL_FORMAT_DEPTH_F32, out data);
if (_depthArray == null)
{
_depthArray = new float[SenseToolkitManager.Instance.ImageDepthOutput.info.width * SenseToolkitManager.Instance.ImageDepthOutput.info.height];
}
data.ToFloatArray(0, _depthArray);
float depth = _depthArray[(int)trackedPoint.x + (int)trackedPoint.y * SenseToolkitManager.Instance.ImageDepthOutput.info.width];
if (_pos_uvz == null)
{
_pos_uvz = new PXCMPoint3DF32[1] {
new PXCMPoint3DF32()
};
}
_pos_uvz[0].x = trackedPoint.x;
_pos_uvz[0].y = trackedPoint.y;
_pos_uvz[0].z = depth;
if (_pos3d == null)
{
_pos3d = new PXCMPoint3DF32[1] {
new PXCMPoint3DF32()
};
}
SenseToolkitManager.Instance.Projection.ProjectDepthToCamera(_pos_uvz, _pos3d);
Vector3 position = new Vector3();
position.x = -_pos3d[0].x / 10;
position.y = _pos3d[0].y / 10;
position.z = _pos3d[0].z / 10;
SenseToolkitManager.Instance.ImageDepthOutput.ReleaseAccess(data);
TrackingUtilityClass.ClampToRealWorldInputBox(ref position, RealWorldBoxCenter, RealWorldBoxDimensions);
TrackingUtilityClass.Normalize(ref position, RealWorldBoxCenter, RealWorldBoxDimensions);
if (!float.IsNaN(position.x) && !float.IsNaN(position.y) && !float.IsNaN(position.z))
{
specificTrigger.Position = position;
}
else
{
return(false);
}
success = true;
}
}
else
{
return(false);
}
return(success);
}
public void DisplayContour(PXCMPointI32[] contour, int blobNumber)
{
if (bitmap == null) return;
lock (this)
{
Graphics g = Graphics.FromImage(bitmap);
using (Pen contourColor = new Pen(Color.Blue, 3.0f))
{
for (int i = 0; i < contour.Length; i++)
{
int baseX = (int) contour[i].x;
int baseY = (int) contour[i].y;
if (i + 1 < contour.Length)
{
int x = (int) contour[i + 1].x;
int y = (int) contour[i + 1].y;
g.DrawLine(contourColor, new Point(baseX, baseY), new Point(x, y));
}
else
{
int x = (int)contour[0].x;
int y = (int)contour[0].y;
g.DrawLine(contourColor, new Point(baseX, baseY), new Point(x, y));
}
}
}
g.Dispose();
}
}
/* Displaying Mask Images */
private unsafe void DisplayPicture(PXCMImage depth, PXCMBlobData blobData)
{
if (depth == null)
return;
PXCMImage image = depth;
PXCMImage.ImageInfo info = image.QueryInfo();
int numOfBlobs = blobData.QueryNumberOfBlobs();
if (_maxBlobToShow > numOfBlobs)
{
_maxBlobToShow = numOfBlobs;
}
PXCMBlobData.IBlob[] blobList = new PXCMBlobData.IBlob[_maxBlobToShow];
PXCMPointI32[][] pointOuter = new PXCMPointI32[_maxBlobToShow][];
PXCMPointI32[][] pointInner = new PXCMPointI32[_maxBlobToShow][];
Bitmap picture = new Bitmap(image.info.width, image.info.height, PixelFormat.Format32bppRgb);
PXCMImage.ImageData bdata;
pxcmStatus results = pxcmStatus.PXCM_STATUS_NO_ERROR;
PXCMBlobData.AccessOrderType accessOrder = PXCMBlobData.AccessOrderType.ACCESS_ORDER_LARGE_TO_SMALL;
int accessOrderBy = form.GetAccessOrder();
switch (accessOrderBy)
{
case 1:
accessOrder = PXCMBlobData.AccessOrderType.ACCESS_ORDER_NEAR_TO_FAR;
break;
case 2:
accessOrder = PXCMBlobData.AccessOrderType.ACCESS_ORDER_RIGHT_TO_LEFT;
break;
case 0:
default:
accessOrder = PXCMBlobData.AccessOrderType.ACCESS_ORDER_LARGE_TO_SMALL;
break;
}
Rectangle rect = new Rectangle(0, 0, image.info.width, image.info.height);
BitmapData bitmapdata = picture.LockBits(rect, ImageLockMode.ReadWrite, picture.PixelFormat);
for (int j = 0; j < _maxBlobToShow; j++)
{
byte tmp1 = (Byte)(255 - (255 / (_maxBlobToShow) * j));
results = blobData.QueryBlobByAccessOrder(j, accessOrder, out blobList[j]);
if (results == pxcmStatus.PXCM_STATUS_NO_ERROR)
{
bool isSegmentationImage = true;
results = blobList[j].QuerySegmentationImage(out image);
if (results != pxcmStatus.PXCM_STATUS_NO_ERROR)
{
PXCMImage.ImageInfo imgInfo = new PXCMImage.ImageInfo();
imgInfo.width = 640;
imgInfo.height = 480;
imgInfo.format = PXCMImage.PixelFormat.PIXEL_FORMAT_Y8;
PXCMSession session = PXCMSession.CreateInstance();
if (session != null)
{
image = session.CreateImage(info);
if (image == null) return;
}
image.AcquireAccess(PXCMImage.Access.ACCESS_WRITE, PXCMImage.PixelFormat.PIXEL_FORMAT_Y8, out bdata);
byte* numPtr = (byte*)bitmapdata.Scan0; //dst
byte* numPtr2 = (byte*)bdata.planes[0]; //row
int imagesize = image.info.width * image.info.height;
byte tmp;
for (int i = 0; i < imagesize; i++, numPtr += 4, numPtr2++)
{
tmp = (byte)(0);
numPtr[0] = tmp;
numPtr[1] = tmp;
numPtr[2] = tmp;
numPtr[3] = tmp;
}
image.ReleaseAccess(bdata);
isSegmentationImage = false;
}
results = image.AcquireAccess(PXCMImage.Access.ACCESS_READ_WRITE, PXCMImage.PixelFormat.PIXEL_FORMAT_Y8, out bdata);
if (form.GetBlobState() && isSegmentationImage == true)
{
byte* numPtr = (byte*)bitmapdata.Scan0; //dst
byte* numPtr2 = (byte*)bdata.planes[0]; //row
int imagesize = image.info.width * image.info.height;
for (int i = 0; i < imagesize; i++, numPtr += 4, numPtr2++)
{
byte tmp = (Byte)(numPtr2[0] == 0 ? 0 : tmp1);
tmp |= numPtr[0];
numPtr[0] = tmp;
numPtr[1] = tmp;
numPtr[2] = tmp;
numPtr[3] = 0xff;
}
}
if ((form.GetContourState()))
{
int contourNumber = blobList[j].QueryNumberOfContours();
if (contourNumber > 0)
{
for (int k = 0; k < contourNumber; ++k)
{
int contourSize = blobList[j].QueryContourSize(k);
if (blobList[j].IsContourOuter(k) == true)
blobList[j].QueryContourPoints(k, out pointOuter[j]);
else
{
blobList[j].QueryContourPoints(k, out pointInner[j]);
}
}
if (results == pxcmStatus.PXCM_STATUS_NO_ERROR && form.GetBlobState() == false)
{
byte* numPtr = (byte*)bitmapdata.Scan0; //dst
byte* numPtr2 = (byte*)bdata.planes[0]; //row
int imagesize = image.info.width * image.info.height;
byte tmp;
for (int i = 0; i < imagesize; i++, numPtr += 4, numPtr2++)
{
tmp = (byte)(0);
numPtr[0] = tmp;
numPtr[1] = tmp;
numPtr[2] = tmp;
numPtr[3] = tmp;
}
}
}
}
image.ReleaseAccess(bdata);
image.Dispose();
}
}
picture.UnlockBits(bitmapdata);
form.DisplayBitmap(picture);
///////// that is my polygon zone
Bitmap imageInstance2 = picture;
i++;
Bitmap croppedImage = null;
if (contourMostRight.x > 0) {
int rectWidth = (int)(contourMostRight.x - contourMostLeft.x);
int rectHeight = (int)(contourMostTop.y - contourMostBottom.y);
Rectangle sourceRectangle = new Rectangle(new Point((int)contourMostLeft.x,
(int)contourMostBottom.y),
new Size(rectWidth, rectHeight));
croppedImage = CropImage(imageInstance2, sourceRectangle);
}
String[] origArray = {
"d:\\origG.jpeg",
"d:\\origX.jpeg",
"d:\\origY.jpeg"
};
for (int i = 0; i < origArray.Length; i++)
{
Bitmap orig = null;
if (File.Exists(origArray[i]))
orig = new Bitmap(@origArray[i]);
if (orig != null && croppedImage != null)
{
float diff = 0;
orig = ScaleImage(orig, 150, 100);
croppedImage = ScaleImage(croppedImage, 150, 100);
bool isImageBlank = true;
for (int y = 0; y < orig.Height; y++)
{
for (int x = 0; x < orig.Width; x++)
{
if(croppedImage.GetPixel(x, y).R > 1 && croppedImage.GetPixel(x, y).B > 1
&& croppedImage.GetPixel(x, y).G > 1)
{
isImageBlank = false;
break;
}
}
}
if (!isImageBlank && orig.Size.Width == croppedImage.Size.Width)
{
for (int y = 0; y < orig.Height; y++)
{
for (int x = 0; x < orig.Width; x++)
{
diff += (float)Math.Abs(orig.GetPixel(x, y).R -
croppedImage.GetPixel(x, y).R) / 255;
diff += (float)Math.Abs(orig.GetPixel(x, y).G -
croppedImage.GetPixel(x, y).G) / 255;
diff += (float)Math.Abs(orig.GetPixel(x, y).B -
croppedImage.GetPixel(x, y).B) / 255;
}
}
}
float percentMatch = 100 * diff / (orig.Width * orig.Height * 2);
Console.WriteLine("diff: {0} %", percentMatch);
if (percentMatch >= 90){
Console.WriteLine(origArray[i].ToString());
Environment.Exit(0);
}
}
}
/*
if (croppedImage != null)
{
croppedImage.Save("d:\\cropedImage.jpeg", System.Drawing.Imaging.ImageFormat.Jpeg);
// croppedImage.Save("d:\\origG.jpeg", System.Drawing.Imaging.ImageFormat.Jpeg);
}*/
if (i == 100)
Environment.Exit(0);
picture.Dispose();
for (int i = 0; i < _maxBlobToShow; i++)
{
if (form.GetContourState())
{
if (pointOuter[i] != null && pointOuter[i].Length > 0)
form.DisplayContour(pointOuter[i], i);
if (pointInner[i] != null && pointInner[i].Length > 0)
form.DisplayContour(pointInner[i], i);
}
if (form.GetBlobDataPointsState())
{
form.DisplayBlobDataPoints(blobList[i], i + 1);
}
PXCMPoint3DF32 point = blobList[i].QueryExtremityPoint(PXCMBlobData.ExtremityType.EXTREMITY_CENTER);
contourMostRight = blobList[i].QueryExtremityPoint(PXCMBlobData.ExtremityType.EXTREMITY_LEFT_MOST);
contourMostLeft = blobList[i].QueryExtremityPoint(PXCMBlobData.ExtremityType.EXTREMITY_RIGHT_MOST);
contourMostBottom = blobList[i].QueryExtremityPoint(PXCMBlobData.ExtremityType.EXTREMITY_TOP_MOST);
contourMostTop = blobList[i].QueryExtremityPoint(PXCMBlobData.ExtremityType.EXTREMITY_BOTTOM_MOST);
form.DisplayBlobNumber(point, i + 1);
}
}
public override bool Process(Trigger trigger)
{
trigger.ErrorDetected = false;
if (!SenseToolkitManager.Instance.IsSenseOptionSet(SenseOption.SenseOptionID.VideoDepthStream))
{
trigger.ErrorDetected = true;
Debug.LogError("Depth Stream Not Set");
return(false);
}
if (!(trigger is EventTrigger))
{
trigger.ErrorDetected = true;
return(false);
}
EventTrigger specificTrigger = (EventTrigger)trigger;
specificTrigger.Source = this.name;
bool success = false;
if (SenseToolkitManager.Instance.Initialized && SenseToolkitManager.Instance.BlobExtractor != null && SenseToolkitManager.Instance.ImageDepthOutput != null)
{
// Setting max distance for this rule and process the image
SenseToolkitManager.Instance.BlobExtractor.SetMaxDistance(MaxDistance * 10);
var sts = SenseToolkitManager.Instance.BlobExtractor.ProcessImage(SenseToolkitManager.Instance.ImageDepthOutput);
if (sts == pxcmStatus.PXCM_STATUS_NO_ERROR && SenseToolkitManager.Instance.BlobExtractor.QueryNumberOfBlobs() >= NumberOfBlobs)
{
int numberOfBlobsDetected = SenseToolkitManager.Instance.BlobExtractor.QueryNumberOfBlobs();
int blobsRightlyDetected = 0;
PXCMBlobExtractor.BlobData blobData = new PXCMBlobExtractor.BlobData();
// For each detected blob, project the tracked point to the real world and
// check that it is in our real world box
for (int i = 0; i < numberOfBlobsDetected; i++)
{
PXCMImage.ImageInfo info = SenseToolkitManager.Instance.ImageDepthOutput.QueryInfo();
info.format = PXCMImage.PixelFormat.PIXEL_FORMAT_Y8;
PXCMImage new_image = SenseToolkitManager.Instance.SenseManager.session.CreateImage(info);
// Process Tracking
SenseToolkitManager.Instance.BlobExtractor.QueryBlobData(i, new_image, out blobData);
new_image.Dispose();
PXCMPointI32 trackedPoint = BlobUtilityClass.GetTrackedPoint(blobData, BlobPointToTrack);
PXCMImage.ImageData data;
SenseToolkitManager.Instance.ImageDepthOutput.AcquireAccess(PXCMImage.Access.ACCESS_READ, PXCMImage.PixelFormat.PIXEL_FORMAT_DEPTH_F32, out data);
if (_depthArray == null)
{
_depthArray = new float[SenseToolkitManager.Instance.ImageDepthOutput.info.width * SenseToolkitManager.Instance.ImageDepthOutput.info.height];
}
data.ToFloatArray(0, _depthArray);
float depth = _depthArray[(int)trackedPoint.x + (int)trackedPoint.y * SenseToolkitManager.Instance.ImageDepthOutput.info.width];
if (_pos_uvz == null)
{
_pos_uvz = new PXCMPoint3DF32[1] {
new PXCMPoint3DF32()
};
}
_pos_uvz[0].x = trackedPoint.x;
_pos_uvz[0].y = trackedPoint.y;
_pos_uvz[0].z = depth;
if (_pos3d == null)
{
_pos3d = new PXCMPoint3DF32[1] {
new PXCMPoint3DF32()
};
}
SenseToolkitManager.Instance.Projection.ProjectDepthToCamera(_pos_uvz, _pos3d);
Vector3 position = new Vector3();
position.x = -_pos3d[0].x / 10;
position.y = _pos3d[0].y / 10;
position.z = _pos3d[0].z / 10;
SenseToolkitManager.Instance.ImageDepthOutput.ReleaseAccess(data);
TrackingUtilityClass.ClampToRealWorldInputBox(ref position, RealWorldBoxCenter, RealWorldBoxDimensions);
TrackingUtilityClass.Normalize(ref position, RealWorldBoxCenter, RealWorldBoxDimensions);
if (!float.IsNaN(position.x) && !float.IsNaN(position.y) && !float.IsNaN(position.z))
{
if (position.x > 0 && position.x < 1 &&
position.y > 0 && position.y < 1 &&
position.z > 0 && position.z < 1)
{
blobsRightlyDetected++;
if (blobsRightlyDetected == NumberOfBlobs)
{
break;
}
}
}
else
{
_lastFrameDetected = false;
return(false);
}
}
if (blobsRightlyDetected >= NumberOfBlobs)
{
if (!_lastFrameDetected)
{
success = true;
}
_lastFrameDetected = true;
}
else
{
_lastFrameDetected = false;
}
}
else
{
_lastFrameDetected = false;
}
}
else
{
return(false);
}
return(success);
}
public void Evaluate(int SpreadMax)
{
if( (FSenseWrap.SliceCount > 0) && (FSenseWrap[0].Configured) )
{
var ImageSize = FSenseWrap[0].sm.captureManager.QueryImageSize(PXCMCapture.StreamType.STREAM_TYPE_DEPTH);
// Iterate over blobs from right to left
try
{
Int32 iBlobsNum = FSenseWrap[0].blobData.QueryNumberOfBlobs();
FCenter.SliceCount = iBlobsNum;
FPoints.SliceCount = iBlobsNum;
PXCMBlobData.IBlob[] blobList = new PXCMBlobData.IBlob[iBlobsNum];
PXCMPointI32[][] pointOuter = new PXCMPointI32[iBlobsNum][];
PXCMPointI32[][] pointInner = new PXCMPointI32[iBlobsNum][];
for (int i = 0; i < iBlobsNum; i++)
{
FSenseWrap[0].blobData.QueryBlobByAccessOrder(i,PXCMBlobData.AccessOrderType.ACCESS_ORDER_RIGHT_TO_LEFT, out blobList[i]);
// handle extracted blob data
Int32 nContours = blobList[i].QueryNumberOfContours();
if (nContours > 0)
{
//contourPts
for (int k = 0; k < nContours; ++k)
{
int contourSize = blobList[i].QueryContourSize(k);
if(blobList[i].IsContourOuter(k) == true)
{
blobList[i].QueryContourPoints(k, out pointOuter[i]);
}
else
{
// blobList[i].QueryContourPoints(k, out pointInner[i]);
}
}
//Convert to vector2D, map to vvvv!!!
if (pointOuter[i] != null && pointOuter[i].Length > 0)
{
FPoints[i].SliceCount = pointOuter[i].Length;
for (int p = 0; p < pointOuter[i].Length; p++)
{
var pt = pointOuter[i][p].ToVector2D();
pt.x = pt.x / (float)ImageSize.width * 2.0f - 1.0f;
pt.y = 1.0f - pt.y / (float)ImageSize.height * 2.0f;
FPoints[i][p] = pt;
}
}
}
FCenter[i] = blobList[i].QueryExtremityPoint(PXCMBlobData.ExtremityType.EXTREMITY_CENTER).ToVector3D() / 100;
}
}
catch (Exception)
{
//Flogger.Log();
}
}
}
public void Evaluate(int SpreadMax)
{
if( (FContext.SliceCount > 0) && (FContext[0].Configured) && FContext[0].HandEnabled)
{
processConfig();
/*
if (FContext[0].handImage != null)
{
if (FContext[0].handImage.Source != null)
{
image = FContext[0].handImage.Source;
}
}
*/
try
{
FID.SliceCount = 0;
int numHands = FContext[0].handData.QueryNumberOfHands();
FNumHands[0] = numHands;
FJointsPositionImage.SliceCount = numHands;
FJointsPositionWorld.SliceCount = numHands;
FJointsOrientation.SliceCount = numHands;
FJointsConfidence.SliceCount = numHands;
FIsCalibrated.SliceCount = numHands;
FTracked.SliceCount = numHands;
FOutsideFOV.SliceCount = numHands;
FMovingTooFast.SliceCount = numHands;
FOutsideDepthRange.SliceCount = numHands;
FPointingFingers.SliceCount = numHands;
FOpen.SliceCount = numHands;
FSide.SliceCount = numHands;
FPalmOrientation.SliceCount = numHands;
FPalmRadiusImage.SliceCount = numHands;
FPalmRadiusWorld.SliceCount = numHands;
FBBox.SliceCount = numHands;
FMassCenterImage.SliceCount = numHands;
FMassCenterWorld.SliceCount = numHands;
FHasSegmentationImage.SliceCount = numHands; //!!!
PXCMRotation rotation;
FContext[0].Session.CreateImpl<PXCMRotation>(out rotation);
PXCMCapture.Sample HandSample = FContext[0].sm.QueryHandSample();
if (HandSample != null && HandSample.depth != null)
{
image = HandSample.depth;
if(FImage[0] == null)
{
FImage.SliceCount = 1;
FImage[0] = new RSSDKImage();
}
}
else image = null;
for (int j = 0; j < numHands; j++)
{
int id;
FContext[0].handData.QueryHandId(PXCMHandData.AccessOrderType.ACCESS_ORDER_FIXED, j, out id);
FID.Add(id);
//Get hand by time of appearance
PXCMHandData.IHand handInfo;
FContext[0].handData.QueryHandData(PXCMHandData.AccessOrderType.ACCESS_ORDER_FIXED, j, out handInfo);
if(handInfo != null)
{
if(FEnableContours[0])
{
//Extract Hand Contours
int nContours = handInfo.QueryNumberOfContours();
FContour.SliceCount = nContours;
for(int contourIndex = 0; contourIndex < nContours; contourIndex++)
{
PXCMHandData.IContour contourData;
handInfo.QueryContour(contourIndex, out contourData);
int contourSize = contourData.QuerySize();
if(contourData.IsOuter() && (contourSize>0))
{
PXCMPointI32[] ContourPoints = new PXCMPointI32[contourSize];
if(contourData.QueryPoints(out ContourPoints) == pxcmStatus.PXCM_STATUS_NO_ERROR)
{
FContour[contourIndex].ResizeAndDismiss(ContourPoints.Length);
for(int ContourPointIndex = 0; ContourPointIndex < ContourPoints.Length; ContourPointIndex++)
{
FContour[contourIndex][ContourPointIndex] = new Vector2D(ContourPoints[ContourPointIndex].x / (float)FContext[0].DepthImageSize.x * 2.0f - 1.0f, 1.0f - ContourPoints[ContourPointIndex].y / (float)FContext[0].DepthImageSize.y * 2.0f);
}
}
}
}
}
FIsCalibrated[j] = handInfo.IsCalibrated();
FHasSegmentationImage[j] = handInfo.HasSegmentationImage();
var HasTrackedJoints = handInfo.HasTrackedJoints();
FHasTrackedJoints[j] = HasTrackedJoints;
//check status
PXCMHandData.TrackingStatusType HandTrackingStatus = (PXCMHandData.TrackingStatusType)handInfo.QueryTrackingStatus();
FTracked[j] = HandTrackingStatus.HasFlag(PXCMHandData.TrackingStatusType.TRACKING_STATUS_GOOD);
FOutsideFOV[j] = HandTrackingStatus.HasFlag(PXCMHandData.TrackingStatusType.TRACKING_STATUS_OUT_OF_FOV);
FMovingTooFast[j] = HandTrackingStatus.HasFlag(PXCMHandData.TrackingStatusType.TRACKING_STATUS_HIGH_SPEED);
FOutsideDepthRange[j] = HandTrackingStatus.HasFlag(PXCMHandData.TrackingStatusType.TRACKING_STATUS_OUT_OF_RANGE);
FPointingFingers[j] = HandTrackingStatus.HasFlag(PXCMHandData.TrackingStatusType.TRACKING_STATUS_POINTING_FINGERS);
FOpen[j] = (float) handInfo.QueryOpenness() / 100.0;
FSide[j] = handInfo.QueryBodySide().ToString();
rotation.SetFromQuaternion(handInfo.QueryPalmOrientation());
FPalmOrientation[j] = rotation.QueryEulerAngles().ToVector3D();
FPalmRadiusImage[j] = handInfo.QueryPalmRadiusImage();
FPalmRadiusWorld[j] = handInfo.QueryPalmRadiusWorld();
FBBox[j] = handInfo.QueryBoundingBoxImage().BBox2DtoVVVV(FContext[0].DepthImageSize);
FMassCenterImage[j] = handInfo.QueryMassCenterImage().ToVector2D().Vector2DtoVVVV(FContext[0].DepthImageSize);
FMassCenterWorld[j] = handInfo.QueryMassCenterWorld().ToVector3D();
if( HasTrackedJoints)
{
FJointsPositionImage[j].SliceCount = 0x20;
FJointsPositionWorld[j].SliceCount = 0x20;
FJointsOrientation[j].SliceCount = 0x20;
FJointsConfidence[j].SliceCount = 0x20;
//Iterate Joints
for (int n = 0; n < 0x20; n++)
{
PXCMHandData.JointData jointData;
handInfo.QueryTrackedJoint((PXCMHandData.JointType)n, out jointData);
FJointsPositionImage[j][n] = jointData.positionImage.ToVector3D().Vector3DtoVVVV(FContext[0].DepthImageSize);
FJointsConfidence[j][n] = jointData.confidence / 100;
FJointsPositionWorld[j][n] = jointData.positionWorld.ToVector3D();
rotation.SetFromQuaternion(jointData.globalOrientation);
FJointsOrientation[j][n] = rotation.QueryEulerAngles().ToVector3D();
} // end iterating over joints
}
else
{
FJointsPositionImage[j].SliceCount = 0;
FJointsPositionWorld[j].SliceCount = 0;
FJointsOrientation[j].SliceCount = 0;
}
// blend images with different colors!!!
PXCMImage.ImageData data;
if ( (image != null) && (FHasSegmentationImage[j]) && (handInfo.QuerySegmentationImage(out image) >= pxcmStatus.PXCM_STATUS_NO_ERROR))
{
//FImage.SliceCount++;
if (image.AcquireAccess(PXCMImage.Access.ACCESS_READ, PXCMImage.PixelFormat.PIXEL_FORMAT_Y8, out data) >= pxcmStatus.PXCM_STATUS_NO_ERROR)
{
if(j == 0)
{
FImage[0].Source = image;
FImage[0].Data = image.GetY8Pixels();
FImage[0].Source = image;
FImage[0].Width = image.info.width;
FImage[0].Height = image.info.height;
FImage[0].Format = PXCMImage.PixelFormat.PIXEL_FORMAT_Y8;
}
else
{
var d = image.GetY8Pixels();
for(int e = 0; e < d.Length; e++) FImage[0].Data[e] += d[e];
}
image.ReleaseAccess(data);
}
}
}
}
// if (image != null)
// {
// image.Dispose();
//}
}
catch (Exception e)
{
FLogger.Log(LogType.Debug, "Hand Tracker: " + e.Message.ToString());
}
}
}
