public static void WriteDeviceConfig <T>(this PXCMCapture.Device device, T metaData, CaptureMode captureMode) where T : DS4Meta
{
int backLightCompensation = device.QueryColorBackLightCompensation();
int brightness = device.QueryColorBrightness();
int contrast = device.QueryColorContrast();
PXCMRangeF32 depthRange = device.QueryDepthSensorRange();
float minDepthRange = depthRange.min;
float maxDepthRange = depthRange.max;
ushort confidenceThreshold = device.QueryDepthConfidenceThreshold();
bool autoExposure = device.QueryColorAutoExposure();
bool autoPowerline = device.QueryColorAutoPowerLineFrequency();
int colorExposure = device.QueryColorExposure();
int colorGain = device.QueryColorGain();
float depthExposure = device.QueryDSLeftRightExposure();
int depthGain = device.QueryDSLeftRightGain();
var depthExposureInfo = device.QueryDSLeftRightExposureInfo();
bool depthAutoExposure = depthExposureInfo.automatic;
metaData.DeviceConfig.BackLightCompensation = backLightCompensation;
metaData.DeviceConfig.minDepthRange = minDepthRange;
metaData.DeviceConfig.maxDepthRange = maxDepthRange;
metaData.DeviceConfig.colorAutoExposure = autoExposure;
metaData.DeviceConfig.depthAutoExposure = depthAutoExposure;
metaData.DeviceConfig.ColorExposure = (float)colorExposure;
metaData.DeviceConfig.ColorGain = colorGain;
if (metaData.DeviceConfig.DepthExposure == 0)
{
metaData.DeviceConfig.DepthExposure = 33.3f;
metaData.DeviceConfig.DepthGain = 1;
}
//{
// BackLightCompensation = backLightCompensation,
// Brightness = brightness,
// Contrast = contrast,
// minDepthRange = minDepthRange,
// maxDepthRange = maxDepthRange,
// confidenceThreshold = confidenceThreshold,
// autoPowerline = autoPowerline,
// colorAutoExposure = autoExposure,
// depthAutoExposure = depthAutoExposure,
// ColorExposure = (float)colorExposure,
// ColorGain = colorGain,
// DepthExposure = depthExposure,
// DepthGain = depthGain
//};
metaData.CaptureMode = captureMode.ToString().ToLower();
}
public static CameraSettings ReadFrom(PXCMCapture.Device device)
{
CameraSettings result = new CameraSettings();
result.DepthConfidenceThreshold = device.QueryDepthConfidenceThreshold();
result.IVCAMAccuracy = (int)device.QueryIVCAMAccuracy();
result.IVCAMFilterOption = device.QueryIVCAMFilterOption();
result.IVCAMLaserPower = device.QueryIVCAMLaserPower();
result.IVCAMMotionRangeTradeOff = device.QueryIVCAMMotionRangeTradeOff();
result.changed = false;
return(result);
}
public void SimplePipeline()
{
PXCMSenseManager pp = m_form.Session.CreateSenseManager();
if (pp == null)
{
throw new Exception("PXCMSenseManager null");
}
// Set Source & Landmark Profile Index
PXCMCapture.DeviceInfo info;
if (m_form.GetRecordState())
{
pp.captureManager.SetFileName(m_form.GetFileName(), true);
if (m_form.Devices.TryGetValue(m_form.GetCheckedDevice(), out info))
{
pp.captureManager.FilterByDeviceInfo(info);
}
}
else if (m_form.GetPlaybackState())
{
pp.captureManager.SetFileName(m_form.GetFileName(), false);
PXCMCaptureManager cmanager = pp.QueryCaptureManager();
if (cmanager == null)
{
throw new Exception("PXCMCaptureManager null");
}
cmanager.SetRealtime(false);
}
else
{
if (m_form.Devices.TryGetValue(m_form.GetCheckedDevice(), out info))
{
pp.captureManager.FilterByDeviceInfo(info);
Tuple <PXCMImage.ImageInfo, PXCMRangeF32> selectedRes = m_form.GetCheckedColorResolution();
var set = new PXCMCapture.Device.StreamProfileSet();
set.color.frameRate = selectedRes.Item2;
set.color.imageInfo.format = selectedRes.Item1.format;
set.color.imageInfo.width = selectedRes.Item1.width;
set.color.imageInfo.height = selectedRes.Item1.height;
pp.captureManager.FilterByStreamProfiles(set);
}
}
// Set Module
pp.EnableFace();
PXCMFaceModule faceModule = pp.QueryFace();
if (faceModule == null)
{
Debug.Assert(faceModule != null);
return;
}
PXCMFaceConfiguration moduleConfiguration = faceModule.CreateActiveConfiguration();
if (moduleConfiguration == null)
{
Debug.Assert(moduleConfiguration != null);
return;
}
PXCMFaceConfiguration.TrackingModeType mode = m_form.GetCheckedProfile().Contains("3D")
? PXCMFaceConfiguration.TrackingModeType.FACE_MODE_COLOR_PLUS_DEPTH
: PXCMFaceConfiguration.TrackingModeType.FACE_MODE_COLOR;
moduleConfiguration.SetTrackingMode(mode);
moduleConfiguration.strategy = PXCMFaceConfiguration.TrackingStrategyType.STRATEGY_RIGHT_TO_LEFT;
moduleConfiguration.detection.maxTrackedFaces = m_form.NumDetection;
moduleConfiguration.landmarks.maxTrackedFaces = m_form.NumLandmarks;
moduleConfiguration.pose.maxTrackedFaces = m_form.NumPose;
PXCMFaceConfiguration.ExpressionsConfiguration econfiguration = moduleConfiguration.QueryExpressions();
if (econfiguration == null)
{
throw new Exception("ExpressionsConfiguration null");
}
econfiguration.properties.maxTrackedFaces = m_form.NumExpressions;
econfiguration.EnableAllExpressions();
moduleConfiguration.detection.isEnabled = m_form.IsDetectionEnabled();
moduleConfiguration.landmarks.isEnabled = m_form.IsLandmarksEnabled();
moduleConfiguration.pose.isEnabled = m_form.IsPoseEnabled();
if (m_form.IsExpressionsEnabled())
{
econfiguration.Enable();
}
PXCMFaceConfiguration.RecognitionConfiguration qrecognition = moduleConfiguration.QueryRecognition();
if (qrecognition == null)
{
throw new Exception("PXCMFaceConfiguration.RecognitionConfiguration null");
}
if (m_form.IsRecognitionChecked())
{
qrecognition.Enable();
}
moduleConfiguration.EnableAllAlerts();
moduleConfiguration.SubscribeAlert(FaceAlertHandler);
pxcmStatus applyChangesStatus = moduleConfiguration.ApplyChanges();
m_form.UpdateStatus("Init Started", MainForm.Label.StatusLabel);
if (applyChangesStatus < pxcmStatus.PXCM_STATUS_NO_ERROR || pp.Init() < pxcmStatus.PXCM_STATUS_NO_ERROR)
{
m_form.UpdateStatus("Init Failed", MainForm.Label.StatusLabel);
}
else
{
using (PXCMFaceData moduleOutput = faceModule.CreateOutput())
{
Debug.Assert(moduleOutput != null);
PXCMCapture.Device.StreamProfileSet profiles;
PXCMCaptureManager cmanager = pp.QueryCaptureManager();
if (cmanager == null)
{
throw new Exception("capture manager null");
}
PXCMCapture.Device device = cmanager.QueryDevice();
if (device == null)
{
throw new Exception("device null");
}
device.QueryStreamProfileSet(PXCMCapture.StreamType.STREAM_TYPE_DEPTH, 0, out profiles);
CheckForDepthStream(profiles, faceModule);
ushort threshold = device.QueryDepthConfidenceThreshold();
int filter_option = device.QueryIVCAMFilterOption();
int range_tradeoff = device.QueryIVCAMMotionRangeTradeOff();
device.SetDepthConfidenceThreshold(1);
device.SetIVCAMFilterOption(6);
device.SetIVCAMMotionRangeTradeOff(21);
if (m_form.IsMirrored())
{
device.SetMirrorMode(PXCMCapture.Device.MirrorMode.MIRROR_MODE_HORIZONTAL);
}
else
{
device.SetMirrorMode(PXCMCapture.Device.MirrorMode.MIRROR_MODE_DISABLED);
}
m_form.UpdateStatus("Streaming", MainForm.Label.StatusLabel);
m_timer = new FPSTimer(m_form);
while (!m_form.Stopped)
{
if (pp.AcquireFrame(true) < pxcmStatus.PXCM_STATUS_NO_ERROR)
{
break;
}
bool isConnected = pp.IsConnected();
DisplayDeviceConnection(isConnected);
if (isConnected)
{
PXCMCapture.Sample sample = pp.QueryFaceSample();
if (sample == null)
{
pp.ReleaseFrame();
continue;
}
DisplayPicture(sample.color);
moduleOutput.Update();
if (moduleConfiguration.QueryRecognition().properties.isEnabled)
{
UpdateRecognition(moduleOutput);
}
m_form.DrawGraphics(moduleOutput);
m_form.UpdatePanel();
}
pp.ReleaseFrame();
}
device.SetDepthConfidenceThreshold(threshold);
device.SetIVCAMFilterOption(filter_option);
device.SetIVCAMMotionRangeTradeOff(range_tradeoff);
}
moduleConfiguration.UnsubscribeAlert(FaceAlertHandler);
moduleConfiguration.ApplyChanges();
m_form.UpdateStatus("Stopped", MainForm.Label.StatusLabel);
}
moduleConfiguration.Dispose();
pp.Close();
pp.Dispose();
}