GUID* ofxPS3::getBaseCameraGuids(int* camCount)
{
*camCount = CLEyeGetCameraCount();
GUID* guids = (GUID*)malloc(*camCount * sizeof(GUID));
for (int i=0;i<*camCount;i++)
{
guids[i] = CLEyeGetCameraUUID(i);
}
return guids;
}
CameraControl *
camera_control_new(int cameraID)
{
CameraControl* cc = (CameraControl*) calloc(1, sizeof(CameraControl));
cc->cameraID = cameraID;
#if defined(CAMERA_CONTROL_USE_CL_DRIVER)
int w, h;
int cams = CLEyeGetCameraCount();
if (cams <= cameraID) {
free(cc);
return NULL;
}
GUID cguid = CLEyeGetCameraUUID(cameraID);
cc->camera = CLEyeCreateCamera(cguid,
CLEYE_COLOR_PROCESSED, CLEYE_VGA, 60);
CLEyeCameraGetFrameDimensions(cc->camera, &w, &h);
// Depending on color mode chosen, create the appropriate OpenCV image
cc->frame4ch = cvCreateImage(cvSize(w, h), IPL_DEPTH_8U, 4);
cc->frame3ch = cvCreateImage(cvSize(w, h), IPL_DEPTH_8U, 3);
CLEyeCameraStart(cc->camera);
#else
char *video = psmove_util_get_env_string(PSMOVE_TRACKER_FILENAME_ENV);
if (video) {
psmove_DEBUG("Using '%s' as video input.\n", video);
cc->capture = cvCaptureFromFile(video);
free(video);
} else {
cc->capture = cvCaptureFromCAM(cc->cameraID);
int width, height;
get_metrics(&width, &height);
cvSetCaptureProperty(cc->capture, CV_CAP_PROP_FRAME_WIDTH, width);
cvSetCaptureProperty(cc->capture, CV_CAP_PROP_FRAME_HEIGHT, height);
}
#endif
return cc;
}
void ofxPS3::cameraInitializationLogic()
{
cameraType = PS3;
int camNum = CLEyeGetCameraCount();
for (int i=0;i<camNum;i++)
{
if (CLEyeGetCameraUUID(i) == guid)
{
index = i;
break;
}
}
if (index == -1)
return;
ps3EyeCamera = CLEyeCreateCamera(guid, (depth == 1) ? (cameraPixelMode ? CLEYE_MONO_PROCESSED : CLEYE_MONO_RAW) : (cameraPixelMode ? CLEYE_COLOR_PROCESSED : CLEYE_COLOR_RAW), width * height > 320 * 240 ? CLEYE_VGA : CLEYE_QVGA, framerate);
Sleep(500);
for (int i=0;i<cameraBaseSettings->propertyType.size();i++)
setCameraFeature(cameraBaseSettings->propertyType[i],cameraBaseSettings->propertyFirstValue[i],cameraBaseSettings->propertySecondValue[i],cameraBaseSettings->isPropertyAuto[i],cameraBaseSettings->isPropertyOn[i]);
CLEyeCameraStart(ps3EyeCamera);
}
bool open(int _index) {
close();
int cams = CLEyeGetCameraCount();
std::cout << "CLEyeGetCameraCount() found " << cams << " devices." << std::endl;
if (_index < cams)
{
std::cout << "Attempting to open camera " << _index << " of " << cams << "." << std::endl;
GUID guid = CLEyeGetCameraUUID(_index);
m_eye = CLEyeCreateCamera(guid, CLEYE_COLOR_PROCESSED, CLEYE_VGA, 75);
CLEyeCameraGetFrameDimensions(m_eye, m_width, m_height);
m_frame4ch = cvCreateImage(cvSize(m_width, m_height), IPL_DEPTH_8U, 4);
m_frame = cvCreateImage(cvSize(m_width, m_height), IPL_DEPTH_8U, 3);
CLEyeCameraStart(m_eye);
CLEyeSetCameraParameter(m_eye, CLEYE_AUTO_EXPOSURE, false);
CLEyeSetCameraParameter(m_eye, CLEYE_AUTO_GAIN, false);
m_index = _index;
}
return isOpened();
}
void Demo::startDemo(bool useCsv){
CLEyeCameraCapture *cam[NUMBER_OF_CAMERAS] = { NULL };
srand(GetTickCount());
// Query for number of connected cameras.
int numCams = CLEyeGetCameraCount();
if (numCams == 0) {
printf("No PS3Eye cameras detected\n");
return;
}
printf("Found %d cameras\n", numCams);
for (int i = 0; i < numCams; i++) {
char windowName[64];
GUID guid = CLEyeGetCameraUUID(i); // Get Camera GUID by index
printf(
"Camera %d GUID: [%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x]\n",
i + 1, guid.Data1, guid.Data2, guid.Data3, guid.Data4[0],
guid.Data4[1], guid.Data4[NUMBER_OF_CAMERAS], guid.Data4[3],
guid.Data4[4],
guid.Data4[5], guid.Data4[6], guid.Data4[7]);
sprintf(windowName, "Camera Window %d", i + 1);
int fps = 30;
cam[i] = new CLEyeCameraCapture(windowName, guid, CLEYE_COLOR_PROCESSED,
CLEYE_QVGA, fps, i + 1); // Create a new camera capture.
printf("Starting capture on camera %d\n", i + 1);
cam[i]->setUseCsv(useCsv);
cam[i]->StartCapture(); // Start the capture.
}
printf(
"Just for test!\nUse the following keys to change camera parameters:\n"
"\t'1' - select camera 1\n"
"\t'2' - select camera 2\n"
"\t<ESC> key will exit the program.\n");
CLEyeCameraCapture *pCam = NULL; // Set the camera pointer to NULL
int param = -1, key;
while ((key = cvWaitKey(0)) != 0x1b) { // ESC == 27
switch (key) { // switch the camera
case '1':
printf("Selected camera 1\n");
pCam = cam[0];
break;
case '2':
printf("Selected camera 2\n");
pCam = cam[1];
break;
}
}
for (int i = 0; i < numCams; i++) {
printf("Stopping capture on camera %d\n", i + 1);
cam[i]->StopCapture(); // Stop capture.
delete cam[i]; // delete the cam[i];
}
}
// Main program entry point
int _tmain(int argc, _TCHAR* argv[])
{
CLEyeCameraCapture *cam[2] = { NULL };
srand(GetTickCount());
// Query for number of connected cameras
int numCams = CLEyeGetCameraCount();
if(numCams == 0)
{
cout << "No PS3Eye cameras detected" << endl;
return -1;
}
cout << "Found " << numCams << " cameras" << endl;
for(int i = 0; i < numCams; i++)
{
char windowName[64];
// Query unique camera uuid
GUID guid = CLEyeGetCameraUUID(i);
printf("Camera %d GUID: [%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x]\n",
i+1, guid.Data1, guid.Data2, guid.Data3,
guid.Data4[0], guid.Data4[1], guid.Data4[2],
guid.Data4[3], guid.Data4[4], guid.Data4[5],
guid.Data4[6], guid.Data4[7]);
sprintf(windowName, "Camera Window %d", i+1);
// Create camera capture object
cam[i] = new CLEyeCameraCapture(windowName, guid, CLEYE_COLOR_PROCESSED, CLEYE_QVGA, 180);
cout << "Starting capture on camera " << i+1 << endl;
cam[i]->StartCapture();
}
cout << "Use the following keys to change camera parameters:\n"
"\t'1' - select camera 1\n"
"\t'2' - select camera 2\n"
"\t'g' - select gain parameter\n"
"\t'e' - select exposure parameter\n"
"\t'z' - select zoom parameter\n"
"\t'r' - select rotation parameter\n"
"\t'+' - increment selected parameter\n"
"\t'-' - decrement selected parameter\n" << endl;
// The <ESC> key will exit the program
CLEyeCameraCapture *pCam = NULL;
int param = -1, key;
while((key = cvWaitKey(0)) != 0x1b)
{
switch(key)
{
case 'g': case 'G': cout << "Parameter Gain" << endl; param = CLEYE_GAIN; break;
case 'e': case 'E': cout << "Parameter Exposure" << endl; param = CLEYE_EXPOSURE; break;
case 'z': case 'Z': cout << "Parameter Zoom" << endl; param = CLEYE_ZOOM; break;
case 'r': case 'R': cout << "Parameter Rotation" << endl; param = CLEYE_ROTATION; break;
case '1': cout << "Selected camera 1" << endl; pCam = cam[0]; break;
case '2': cout << "Selected camera 2" << endl; pCam = cam[1]; break;
case '+': if(numCams == 1){
pCam = cam[0];
}
if(pCam) pCam->IncrementCameraParameter(param); break;
case '-': if(numCams == 1){
pCam = cam[0];
}
if(pCam) pCam->DecrementCameraParameter(param); break;
}
}
//delete cams
for(int i = 0; i < numCams; i++)
{
cout << "Stopping capture on camera " << i+1 << endl;
cam[i]->StopCapture();
delete cam[i];
}
return 0;
}
int PS3::GetCameraCount() {
return CLEyeGetCameraCount();
}
int ofxPS3::getCameraBaseCount()
{
return CLEyeGetCameraCount();
}
CameraControl *
camera_control_new_with_settings(int cameraID, int width, int height, int framerate, int cam_type)
{
CameraControl* cc = (CameraControl*) calloc(1, sizeof(CameraControl));
cc->cameraID = cameraID;
if (framerate <= 0) {
framerate = PSMOVE_TRACKER_DEFAULT_FPS;
}
if (cam_type == PSMove_Camera_PS3EYE_BLUEDOT)
{
cc->focl_x = (float)PS3EYE_FOCAL_LENGTH_BLUE;
cc->focl_y = (float)PS3EYE_FOCAL_LENGTH_BLUE;
}
else if (cam_type == PSMove_Camera_PS3EYE_REDDOT)
{
cc->focl_x = (float)PS3EYE_FOCAL_LENGTH_RED;
cc->focl_y = (float)PS3EYE_FOCAL_LENGTH_RED;
}
else if (cam_type == PSMove_Camera_Unknown)
{
cc->focl_x = (float)PS3EYE_FOCAL_LENGTH_BLUE;
cc->focl_y = (float)PS3EYE_FOCAL_LENGTH_BLUE;
}
// Needed for cbb tracker. Will be overwritten by camera calibration files if they exist.
#if defined(CAMERA_CONTROL_USE_CL_DRIVER)
// Windows 32-bit. Either CL_SDK or Registry_requiring
int cams = CLEyeGetCameraCount();
if (cams <= cameraID) {
free(cc);
return NULL;
}
GUID cguid = CLEyeGetCameraUUID(cameraID);
cc->camera = CLEyeCreateCamera(cguid,
CLEYE_COLOR_PROCESSED, CLEYE_VGA, framerate);
CLEyeCameraGetFrameDimensions(cc->camera, &width, &height);
// Depending on color mode chosen, create the appropriate OpenCV image
cc->frame4ch = cvCreateImage(cvSize(width, height), IPL_DEPTH_8U, 4);
cc->frame3ch = cvCreateImage(cvSize(width, height), IPL_DEPTH_8U, 3);
CLEyeCameraStart(cc->camera);
#elif defined(CAMERA_CONTROL_USE_PS3EYE_DRIVER)
// Mac or Windows
// Initialize PS3EYEDriver
ps3eye_init();
int cams = ps3eye_count_connected();
psmove_DEBUG("Found %i ps3eye(s) with CAMERA_CONTROL_USE_PS3EYE_DRIVER.\n", cams);
if (cams <= cameraID) {
free(cc);
return NULL;
}
if (width <= 0 || height <= 0) {
get_metrics(&width, &height);
}
psmove_DEBUG("Attempting to open ps3eye with cameraId, width, height, framerate: %d, %d, %d, %d.\n", cameraID, width, height, framerate);
cc->eye = ps3eye_open(cameraID, width, height, framerate);
if (cc->eye == NULL) {
psmove_WARNING("Failed to open camera ID %d", cameraID);
free(cc);
return NULL;
}
cc->framebgr = cvCreateImage(cvSize(width, height), IPL_DEPTH_8U, 3);
#else
// Assume webcam accessible from OpenCV.
char *video = psmove_util_get_env_string(PSMOVE_TRACKER_FILENAME_ENV);
if (video) {
psmove_DEBUG("Using '%s' as video input.\n", video);
cc->capture = cvCaptureFromFile(video);
free(video);
} else {
cc->capture = cvCaptureFromCAM(cc->cameraID);
if (width <= 0 || height <= 0) {
get_metrics(&width, &height);
}
cvSetCaptureProperty(cc->capture, CV_CAP_PROP_FRAME_WIDTH, width);
cvSetCaptureProperty(cc->capture, CV_CAP_PROP_FRAME_HEIGHT, height);
}
#endif
cc->width = width;
cc->height = height;
cc->deinterlace = PSMove_False;
return cc;
}
// return true to retry later (e.g. after display lost)
static bool MainLoop(bool retryCreate)
{
// Initialize these to nullptr here to handle device lost failures cleanly
ovrTexture * mirrorTexture = nullptr;
OculusTexture * pEyeRenderTexture[2] = { nullptr, nullptr };
DepthBuffer * pEyeDepthBuffer[2] = { nullptr, nullptr };
Scene * roomScene = nullptr;
Camera * mainCam = nullptr;
D3D11_TEXTURE2D_DESC td = {};
ovrHmd HMD;
ovrGraphicsLuid luid;
ovrResult result = ovr_Create(&HMD, &luid);
if (!OVR_SUCCESS(result))
return retryCreate;
ovrHmdDesc hmdDesc = ovr_GetHmdDesc(HMD);
// -------------------------------------------------------------------
// Add: Make Instance that CL Eye Camera Capture Class
CLEyeCameraCapture* cam[2] = { NULL };
// Query for number of connected camera
int numCams = CLEyeGetCameraCount();
if (numCams == 0)
{
printf_s("No PS3Eye Camera detected\n");
goto Done;
}
printf_s("Found %d cameras\n", numCams);
for (int iCam = 0; iCam < numCams; iCam++)
{
char windowName[64];
// Query unique camera uuid
GUID guid = CLEyeGetCameraUUID(iCam);
printf("Camera %d GUID: [%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x]\n",
iCam + 1, guid.Data1, guid.Data2, guid.Data3,
guid.Data4[0], guid.Data4[1], guid.Data4[2],
guid.Data4[3], guid.Data4[4], guid.Data4[5],
guid.Data4[6], guid.Data4[7]);
sprintf_s(windowName, "Camera Window %d", iCam + 1);
// Create camera capture object
cam[iCam] = new CLEyeCameraCapture(windowName, guid, CLEYE_COLOR_RAW, CLEYE_VGA, 30);
cam[iCam]->StartCapture();
}
// -------------------------------------------------------------------
// Setup Device and Graphics
// Note: the mirror window can be any size, for this sample we use 1/2 the HMD resolution
if (!DIRECTX.InitDevice(hmdDesc.Resolution.w / 2, hmdDesc.Resolution.h / 2, reinterpret_cast<LUID*>(&luid)))
goto Done;
// Make the eye render buffers (caution if actual size < requested due to HW limits).
ovrRecti eyeRenderViewport[2];
for (int eye = 0; eye < 2; ++eye)
{
ovrSizei idealSize = ovr_GetFovTextureSize(HMD, (ovrEyeType)eye, hmdDesc.DefaultEyeFov[eye], 1.0f);
pEyeRenderTexture[eye] = new OculusTexture();
if (!pEyeRenderTexture[eye]->Init(HMD, idealSize.w, idealSize.h))
{
if (retryCreate) goto Done;
VALIDATE(OVR_SUCCESS(result), "Failed to create eye texture.");
}
pEyeDepthBuffer[eye] = new DepthBuffer(DIRECTX.Device, idealSize.w, idealSize.h);
eyeRenderViewport[eye].Pos.x = 0;
eyeRenderViewport[eye].Pos.y = 0;
eyeRenderViewport[eye].Size = idealSize;
if (!pEyeRenderTexture[eye]->TextureSet)
{
if (retryCreate) goto Done;
VALIDATE(false, "Failed to create texture.");
}
}
// Create a mirror to see on the monitor.
td.ArraySize = 1;
td.Format = DXGI_FORMAT_R8G8B8A8_UNORM_SRGB;
td.Width = DIRECTX.WinSizeW;
td.Height = DIRECTX.WinSizeH;
td.Usage = D3D11_USAGE_DEFAULT;
td.SampleDesc.Count = 1;
td.MipLevels = 1;
result = ovr_CreateMirrorTextureD3D11(HMD, DIRECTX.Device, &td, 0, &mirrorTexture);
if (!OVR_SUCCESS(result))
{
if (retryCreate) goto Done;
VALIDATE(false, "Failed to create mirror texture.");
}
// Create the room model
roomScene = new Scene(false);
// Create camera
mainCam = new Camera(&XMVectorSet(0.0f, 1.6f, 5.0f, 0), &XMQuaternionIdentity());
// Setup VR components, filling out description
ovrEyeRenderDesc eyeRenderDesc[2];
eyeRenderDesc[0] = ovr_GetRenderDesc(HMD, ovrEye_Left, hmdDesc.DefaultEyeFov[0]);
eyeRenderDesc[1] = ovr_GetRenderDesc(HMD, ovrEye_Right, hmdDesc.DefaultEyeFov[1]);
bool isVisible = true;
DCB portConfig;
portConfig.BaudRate = 115200;
portConfig.Parity = EVENPARITY;
g_seriPort.Start("\\\\.\\COM3", &portConfig);
// Main loop
while (DIRECTX.HandleMessages())
{
XMVECTOR forward = XMVector3Rotate(XMVectorSet(0, 0, -0.05f, 0), mainCam->Rot);
XMVECTOR right = XMVector3Rotate(XMVectorSet(0.05f, 0, 0, 0), mainCam->Rot);
if (DIRECTX.Key['W'] || DIRECTX.Key[VK_UP]) mainCam->Pos = XMVectorAdd(mainCam->Pos, forward);
if (DIRECTX.Key['S'] || DIRECTX.Key[VK_DOWN]) mainCam->Pos = XMVectorSubtract(mainCam->Pos, forward);
if (DIRECTX.Key['D']) mainCam->Pos = XMVectorAdd(mainCam->Pos, right);
if (DIRECTX.Key['A']) mainCam->Pos = XMVectorSubtract(mainCam->Pos, right);
static float Yaw = 0;
if (DIRECTX.Key[VK_LEFT]) mainCam->Rot = XMQuaternionRotationRollPitchYaw(0, Yaw += 0.02f, 0);
if (DIRECTX.Key[VK_RIGHT]) mainCam->Rot = XMQuaternionRotationRollPitchYaw(0, Yaw -= 0.02f, 0);
// Animate the cube
static float cubeClock = 0;
roomScene->Models[0]->Pos = XMFLOAT3(9 * sin(cubeClock), 3, 9 * cos(cubeClock += 0.015f));
// Get both eye poses simultaneously, with IPD offset already included.
ovrPosef EyeRenderPose[2];
ovrVector3f HmdToEyeViewOffset[2] = { eyeRenderDesc[0].HmdToEyeViewOffset,
eyeRenderDesc[1].HmdToEyeViewOffset };
double frameTime = ovr_GetPredictedDisplayTime(HMD, 0);
// Keeping sensorSampleTime as close to ovr_GetTrackingState as possible - fed into the layer
double sensorSampleTime = ovr_GetTimeInSeconds();
ovrTrackingState hmdState = ovr_GetTrackingState(HMD, frameTime, ovrTrue);
ovr_CalcEyePoses(hmdState.HeadPose.ThePose, HmdToEyeViewOffset, EyeRenderPose);
// --------------------------------------------------------------------------
// Add: Get Head Yaw Roll Pitch
float hmdPitch = 0.0f;
float hmdRoll = 0.0f;
float hmdYaw = 0.0f;
OVR::Posef HeadPose = hmdState.HeadPose.ThePose;
HeadPose.Rotation.GetEulerAngles<OVR::Axis_Y, OVR::Axis_X, OVR::Axis_Z>(&hmdYaw, &hmdPitch, &hmdRoll);
SetPos(2, ServoRoll(hmdYaw));
SetPos(3, ServoRoll(hmdPitch));
// --------------------------------------------------------------------------
// Render Scene to Eye Buffers
if (isVisible)
{
for (int eye = 0; eye < 2; ++eye)
{
// Increment to use next texture, just before writing
pEyeRenderTexture[eye]->AdvanceToNextTexture();
// Clear and set up rendertarget
int texIndex = pEyeRenderTexture[eye]->TextureSet->CurrentIndex;
DIRECTX.SetAndClearRenderTarget(pEyeRenderTexture[eye]->TexRtv[texIndex], pEyeDepthBuffer[eye]);
DIRECTX.SetViewport((float)eyeRenderViewport[eye].Pos.x, (float)eyeRenderViewport[eye].Pos.y,
(float)eyeRenderViewport[eye].Size.w, (float)eyeRenderViewport[eye].Size.h);
//Get the pose information in XM format
XMVECTOR eyeQuat = XMVectorSet(EyeRenderPose[eye].Orientation.x, EyeRenderPose[eye].Orientation.y,
EyeRenderPose[eye].Orientation.z, EyeRenderPose[eye].Orientation.w);
XMVECTOR eyePos = XMVectorSet(EyeRenderPose[eye].Position.x, EyeRenderPose[eye].Position.y, EyeRenderPose[eye].Position.z, 0);
// Get view and projection matrices for the Rift camera
XMVECTOR CombinedPos = XMVectorAdd(mainCam->Pos, XMVector3Rotate(eyePos, mainCam->Rot));
Camera finalCam(&CombinedPos, &(XMQuaternionMultiply(eyeQuat,mainCam->Rot)));
XMMATRIX view = finalCam.GetViewMatrix();
ovrMatrix4f p = ovrMatrix4f_Projection(eyeRenderDesc[eye].Fov, 0.2f, 1000.0f, ovrProjection_RightHanded);
XMMATRIX proj = XMMatrixSet(p.M[0][0], p.M[1][0], p.M[2][0], p.M[3][0],
p.M[0][1], p.M[1][1], p.M[2][1], p.M[3][1],
p.M[0][2], p.M[1][2], p.M[2][2], p.M[3][2],
p.M[0][3], p.M[1][3], p.M[2][3], p.M[3][3]);
XMMATRIX prod = XMMatrixMultiply(view, proj);
roomScene->Render(&prod, 1, 1, 1, 1, true);
}
}
// Initialize our single full screen Fov layer.
ovrLayerEyeFov ld = {};
ld.Header.Type = ovrLayerType_EyeFov;
ld.Header.Flags = 0;
for (int eye = 0; eye < 2; ++eye)
{
ld.ColorTexture[eye] = pEyeRenderTexture[eye]->TextureSet;
ld.Viewport[eye] = eyeRenderViewport[eye];
ld.Fov[eye] = hmdDesc.DefaultEyeFov[eye];
ld.RenderPose[eye] = EyeRenderPose[eye];
ld.SensorSampleTime = sensorSampleTime;
}
ovrLayerHeader* layers = &ld.Header;
result = ovr_SubmitFrame(HMD, 0, nullptr, &layers, 1);
// exit the rendering loop if submit returns an error, will retry on ovrError_DisplayLost
if (!OVR_SUCCESS(result))
goto Done;
isVisible = (result == ovrSuccess);
// Render mirror
ovrD3D11Texture* tex = (ovrD3D11Texture*)mirrorTexture;
DIRECTX.Context->CopyResource(DIRECTX.BackBuffer, tex->D3D11.pTexture);
DIRECTX.SwapChain->Present(0, 0);
}
// Release resources
Done:
delete mainCam;
delete roomScene;
if (mirrorTexture) ovr_DestroyMirrorTexture(HMD, mirrorTexture);
for (int eye = 0; eye < 2; ++eye)
{
delete pEyeRenderTexture[eye];
delete pEyeDepthBuffer[eye];
}
DIRECTX.ReleaseDevice();
ovr_Destroy(HMD);
g_seriPort.End();
for (int iCam = 0; iCam < numCams; iCam++)
{
cam[iCam]->StopCapture();
delete cam[iCam];
}
// Retry on ovrError_DisplayLost
return retryCreate || OVR_SUCCESS(result) || (result == ovrError_DisplayLost);
}
//--------------------------------------------------------------
int ofxCLEye::getDeviceCount(){
return CLEyeGetCameraCount();
}
