int main(){ FaceTracker F; vector <string> class_name; vector <int> class_label; vector <Rect> face_pos; Mat frame,prev_img,buffer; vector < vector <Point2f> > features; string classifier="fisher"; VideoCapture cap; cap.open("/home/rajeev/Dropbox/vios_team_use/face_recognition/videos/bbt_s04e18_hd.avi"); namedWindow("Features",1); while(1){ cap >> frame; if (frame.empty()) break; F.klt_track_face(class_name, class_label, face_pos, frame, prev_img, features, classifier); frame.copyTo(prev_img); frame.copyTo(buffer); for (int i=0; i<features.size();i++){ for (int j=0; j<features[i].size();j++){ circle(buffer, features[i][j], 2, CV_RGB(0,255,0), 1, 8, 0); } } imshow("Features",frame); if(waitKey(20) == 27) break; } return 0; }
int get_facial_points(Mat& face, vector<Point_<double> >& points) { FaceTracker * tracker = LoadFaceTracker(DefaultFaceTrackerModelPathname().c_str()); FaceTrackerParams *tracker_params = LoadFaceTrackerParams(DefaultFaceTrackerParamsPathname().c_str()); Mat frame_gray; cvtColor(face, frame_gray, CV_RGB2GRAY ); int result = tracker->NewFrame(frame_gray, tracker_params); vector<Point_<double> > shape; Pose pose; if (result >= 1) { points = tracker->getShape(); pose = tracker->getPose(); } else { return 0; } delete tracker; delete tracker_params; return 1; }
void CameraToolBox::toggleMute() { delete _doubleClickTimer; _doubleClickTimer = NULL; FaceTracker* faceTracker = Application::getInstance()->getSelectedFaceTracker(); if (faceTracker) { faceTracker->toggleMute(); } }
DWORD WINAPI KinectWindow::FaceTrackingStaticThread(PVOID lpParam) { KinectWindow* context = static_cast<KinectWindow*>(lpParam); if (context) { FaceTracker* pFaceTracker; context->GetFaceTraker(&pFaceTracker); return pFaceTracker->FaceTrackingThread(); } return 0; }
int main(int, char**) { VideoCapture cap(0); // open the default camera if(!cap.isOpened()) return -1; // check if we succeeded Mat frame; namedWindow("tracking",1); while(true) { cap >> frame; tracker.track(frame); for(auto face_center : tracker.faces_centers){ ellipse( frame, face_center, Size( 5, 5), 0, 0, 360, Scalar( 255, 255, 0 ), 4, 8, 0 ); // could be boxe-rectangle ~ size of face } imshow("tracking", frame); if(waitKey(30) >= 0) break; } return 0; }
int run_image_mode(const Configuration &cfg, const CommandLineArgument<std::string> &image_argument, const CommandLineArgument<std::string> &landmarks_argument) { FaceTracker * tracker = LoadFaceTracker(cfg.model_pathname.c_str()); FaceTrackerParams *tracker_params = LoadFaceTrackerParams(cfg.params_pathname.c_str()); cv::Mat image; cv::Mat_<uint8_t> gray_image = load_grayscale_image(image_argument->c_str(), &image); int result = tracker->NewFrame(gray_image, tracker_params); std::vector<cv::Point_<double> > shape; std::vector<cv::Point3_<double> > shape3; Pose pose; if (result >= cfg.tracking_threshold) { shape = tracker->getShape(); shape3 = tracker->get3DShape(); pose = tracker->getPose(); } if (!have_argument_p(landmarks_argument)) { display_data(cfg, image, shape, pose); } else if (shape.size() > 0) { if (cfg.save_3d_points) save_points3(landmarks_argument->c_str(), shape3); else save_points(landmarks_argument->c_str(), shape); } delete tracker; delete tracker_params; return 0; }
// ------------------------------ void Moustachizer::process(Mat frame) { //circle(frame, Point(300,300), 300, Scalar(255,0,0), 3); Mat grayFrame = frame.clone(); cvtColor(frame, grayFrame, CV_RGB2GRAY); equalizeHist(grayFrame, grayFrame); imshow("grayFrame", grayFrame); faceTracker.search( grayFrame ); for(int i=0; i<faceTracker.faces.size(); i++) { Face face = faceTracker.faces[i]; face.draw( frame ); float scale = (float)face.boundingBox.width / stache.size().width; Mat stache_resized; Mat mask_resized; resize(stache, stache_resized, Size(), scale, scale); resize(mask, mask_resized, Size(), scale, scale); float xpos = face.boundingBox.x; float ypos = face.boundingBox.y + (face.boundingBox.height * .60); Rect pos = Rect(xpos, ypos, stache_resized.size().width, stache_resized.size().height); /* Rect frame = Rect(0, 0, input.size().width, input.size().height); Rect intersection = pos & frame; Mat fg = stache_resized(Rect(0,0,intersection.width,intersection.height)); Mat bg = input(Rect(xpos,ypos,intersection.width,intersection.height)); */ Mat bg = frame(pos); stache_resized.copyTo(bg, mask_resized); } //cvtColor(input, input, CV_GRAY2RGB); imshow("preview", frame); cvWaitKey(1); }
// ------------------------------ int Moustachizer::init(const char* argstr) { faceTracker.init(); const char* fileName = "images/moustache4.jpg"; stache = imread(fileName, 1); // OpenCV can't load 4 channel images, which is a huge pain // so I am pulling out the Value channel from the moustache image // to use as a mask for drawing the moustache into the main frame. Mat hsvimg; cvtColor(stache, hsvimg, CV_RGB2HSV); vector<Mat> hsvchannels; split(hsvimg, hsvchannels); bitwise_not(hsvchannels[2], mask); erode(mask, mask, Mat(), Point(-1,-1), 4); dilate(mask, mask, Mat(), Point(-1,-1), 2); return 0; }
void Head::simulate(float deltaTime, bool isMine, bool billboard) { // Update audio trailing average for rendering facial animations const float AUDIO_AVERAGING_SECS = 0.05f; const float AUDIO_LONG_TERM_AVERAGING_SECS = 30.0f; _averageLoudness = glm::mix(_averageLoudness, _audioLoudness, glm::min(deltaTime / AUDIO_AVERAGING_SECS, 1.0f)); if (_longTermAverageLoudness == -1.0f) { _longTermAverageLoudness = _averageLoudness; } else { _longTermAverageLoudness = glm::mix(_longTermAverageLoudness, _averageLoudness, glm::min(deltaTime / AUDIO_LONG_TERM_AVERAGING_SECS, 1.0f)); } if (isMine) { MyAvatar* myAvatar = static_cast<MyAvatar*>(_owningAvatar); // Only use face trackers when not playing back a recording. if (!myAvatar->isPlaying()) { FaceTracker* faceTracker = Application::getInstance()->getActiveFaceTracker(); _isFaceTrackerConnected = faceTracker != NULL && !faceTracker->isMuted(); if (_isFaceTrackerConnected) { _blendshapeCoefficients = faceTracker->getBlendshapeCoefficients(); if (typeid(*faceTracker) == typeid(DdeFaceTracker)) { if (Menu::getInstance()->isOptionChecked(MenuOption::UseAudioForMouth)) { calculateMouthShapes(); const int JAW_OPEN_BLENDSHAPE = 21; const int MMMM_BLENDSHAPE = 34; const int FUNNEL_BLENDSHAPE = 40; const int SMILE_LEFT_BLENDSHAPE = 28; const int SMILE_RIGHT_BLENDSHAPE = 29; _blendshapeCoefficients[JAW_OPEN_BLENDSHAPE] += _audioJawOpen; _blendshapeCoefficients[SMILE_LEFT_BLENDSHAPE] += _mouth4; _blendshapeCoefficients[SMILE_RIGHT_BLENDSHAPE] += _mouth4; _blendshapeCoefficients[MMMM_BLENDSHAPE] += _mouth2; _blendshapeCoefficients[FUNNEL_BLENDSHAPE] += _mouth3; } applyEyelidOffset(getFinalOrientationInWorldFrame()); } } auto eyeTracker = DependencyManager::get<EyeTracker>(); _isEyeTrackerConnected = eyeTracker->isTracking(); } if (!myAvatar->getStandingHMDSensorMode()) { // Twist the upper body to follow the rotation of the head, but only do this with my avatar, // since everyone else will see the full joint rotations for other people. const float BODY_FOLLOW_HEAD_YAW_RATE = 0.1f; const float BODY_FOLLOW_HEAD_FACTOR = 0.66f; float currentTwist = getTorsoTwist(); setTorsoTwist(currentTwist + (getFinalYaw() * BODY_FOLLOW_HEAD_FACTOR - currentTwist) * BODY_FOLLOW_HEAD_YAW_RATE); } } if (!(_isFaceTrackerConnected || billboard)) { if (!_isEyeTrackerConnected) { // Update eye saccades const float AVERAGE_MICROSACCADE_INTERVAL = 1.0f; const float AVERAGE_SACCADE_INTERVAL = 6.0f; const float MICROSACCADE_MAGNITUDE = 0.002f; const float SACCADE_MAGNITUDE = 0.04f; const float NOMINAL_FRAME_RATE = 60.0f; if (randFloat() < deltaTime / AVERAGE_MICROSACCADE_INTERVAL) { _saccadeTarget = MICROSACCADE_MAGNITUDE * randVector(); } else if (randFloat() < deltaTime / AVERAGE_SACCADE_INTERVAL) { _saccadeTarget = SACCADE_MAGNITUDE * randVector(); } _saccade += (_saccadeTarget - _saccade) * pow(0.5f, NOMINAL_FRAME_RATE * deltaTime); } else { _saccade = glm::vec3(); } // Detect transition from talking to not; force blink after that and a delay bool forceBlink = false; const float TALKING_LOUDNESS = 100.0f; const float BLINK_AFTER_TALKING = 0.25f; if ((_averageLoudness - _longTermAverageLoudness) > TALKING_LOUDNESS) { _timeWithoutTalking = 0.0f; } else if (_timeWithoutTalking < BLINK_AFTER_TALKING && (_timeWithoutTalking += deltaTime) >= BLINK_AFTER_TALKING) { forceBlink = true; } // Update audio attack data for facial animation (eyebrows and mouth) const float AUDIO_ATTACK_AVERAGING_RATE = 0.9f; _audioAttack = AUDIO_ATTACK_AVERAGING_RATE * _audioAttack + (1.0f - AUDIO_ATTACK_AVERAGING_RATE) * fabs((_audioLoudness - _longTermAverageLoudness) - _lastLoudness); _lastLoudness = (_audioLoudness - _longTermAverageLoudness); const float BROW_LIFT_THRESHOLD = 100.0f; if (_audioAttack > BROW_LIFT_THRESHOLD) { _browAudioLift += sqrtf(_audioAttack) * 0.01f; } _browAudioLift = glm::clamp(_browAudioLift *= 0.7f, 0.0f, 1.0f); const float BLINK_SPEED = 10.0f; const float BLINK_SPEED_VARIABILITY = 1.0f; const float BLINK_START_VARIABILITY = 0.25f; const float FULLY_OPEN = 0.0f; const float FULLY_CLOSED = 1.0f; if (_leftEyeBlinkVelocity == 0.0f && _rightEyeBlinkVelocity == 0.0f) { // no blinking when brows are raised; blink less with increasing loudness const float BASE_BLINK_RATE = 15.0f / 60.0f; const float ROOT_LOUDNESS_TO_BLINK_INTERVAL = 0.25f; if (forceBlink || (_browAudioLift < EPSILON && shouldDo(glm::max(1.0f, sqrt(fabs(_averageLoudness - _longTermAverageLoudness)) * ROOT_LOUDNESS_TO_BLINK_INTERVAL) / BASE_BLINK_RATE, deltaTime))) { _leftEyeBlinkVelocity = BLINK_SPEED + randFloat() * BLINK_SPEED_VARIABILITY; _rightEyeBlinkVelocity = BLINK_SPEED + randFloat() * BLINK_SPEED_VARIABILITY; if (randFloat() < 0.5f) { _leftEyeBlink = BLINK_START_VARIABILITY; } else { _rightEyeBlink = BLINK_START_VARIABILITY; } } } else { _leftEyeBlink = glm::clamp(_leftEyeBlink + _leftEyeBlinkVelocity * deltaTime, FULLY_OPEN, FULLY_CLOSED); _rightEyeBlink = glm::clamp(_rightEyeBlink + _rightEyeBlinkVelocity * deltaTime, FULLY_OPEN, FULLY_CLOSED); if (_leftEyeBlink == FULLY_CLOSED) { _leftEyeBlinkVelocity = -BLINK_SPEED; } else if (_leftEyeBlink == FULLY_OPEN) { _leftEyeBlinkVelocity = 0.0f; } if (_rightEyeBlink == FULLY_CLOSED) { _rightEyeBlinkVelocity = -BLINK_SPEED; } else if (_rightEyeBlink == FULLY_OPEN) { _rightEyeBlinkVelocity = 0.0f; } } // use data to update fake Faceshift blendshape coefficients calculateMouthShapes(); DependencyManager::get<Faceshift>()->updateFakeCoefficients(_leftEyeBlink, _rightEyeBlink, _browAudioLift, _audioJawOpen, _mouth2, _mouth3, _mouth4, _blendshapeCoefficients); applyEyelidOffset(getOrientation()); } else { _saccade = glm::vec3(); } if (Menu::getInstance()->isOptionChecked(MenuOption::FixGaze)) { // if debug menu turns off, use no saccade _saccade = glm::vec3(); } _leftEyePosition = _rightEyePosition = getPosition(); if (!billboard) { _faceModel.simulate(deltaTime); if (!_faceModel.getEyePositions(_leftEyePosition, _rightEyePosition)) { static_cast<Avatar*>(_owningAvatar)->getSkeletonModel().getEyePositions(_leftEyePosition, _rightEyePosition); } } _eyePosition = calculateAverageEyePosition(); }
/// <summary> /// Process Kinect window menu commands /// </summary> /// <param name="commanId">ID of the menu item</param> /// <param name="param">Parameter passed in along with the commmand ID</param> /// <param name="previouslyChecked">Check status of menu item before command is issued</param> void KinectSettings::ProcessMenuCommand(WORD commandId, WORD param, bool previouslyChecked) { DWORD ExitCode; FaceTracker* pFaceTracker; InbedAPPs* pFallDetect; DepthInbedAPPs* pDepthInbedApps; LegRaisExcer* pLegRaisExer; HandRaisExcer* pHandRaisExer; m_pKinectWindow->GetFaceTraker(&pFaceTracker); m_pPrimaryView->GetFallDetect(&pFallDetect); m_pDepthStream->GetDepthInbedAPPs(&pDepthInbedApps); m_pPrimaryView->GetLegRaisExcer(&pLegRaisExer); m_pPrimaryView->GetHandRaisExcer(&pHandRaisExer); if (ID_COLORSTREAM_PAUSE == commandId) { // Pause color stream if (m_pColorStream) { m_pColorStream->PauseStream(!previouslyChecked); } } else if (ID_COLORSTREAM_RESOLUTION_START <= commandId && ID_COLORSTREAM_RESOLUTION_END >= commandId) { // Set color stream format and resolution if (!m_pColorStream) { return; } switch (commandId) { case ID_RESOLUTION_RGBRESOLUTION640X480FPS30: m_pColorStream->SetImageType(NUI_IMAGE_TYPE_COLOR); m_pColorStream->SetImageResolution(NUI_IMAGE_RESOLUTION_640x480); break; case ID_RESOLUTION_RGBRESOLUTION1280X960FPS12: m_pColorStream->SetImageType(NUI_IMAGE_TYPE_COLOR); m_pColorStream->SetImageResolution(NUI_IMAGE_RESOLUTION_1280x960); break; case ID_RESOLUTION_YUVRESOLUTION640X480FPS15: m_pColorStream->SetImageType(NUI_IMAGE_TYPE_COLOR_YUV); m_pColorStream->SetImageResolution(NUI_IMAGE_RESOLUTION_640x480); break; case ID_RESOLUTION_INFRAREDRESOLUTION640X480FPS30: m_pColorStream->SetImageType(NUI_IMAGE_TYPE_COLOR_INFRARED); m_pColorStream->SetImageResolution(NUI_IMAGE_RESOLUTION_640x480); break; case ID_RESOLUTION_RAWBAYERRESOLUTION640X480FPS30: m_pColorStream->SetImageType(NUI_IMAGE_TYPE_COLOR_RAW_BAYER); m_pColorStream->SetImageResolution(NUI_IMAGE_RESOLUTION_640x480); break; case ID_RESOLUTION_RAWBAYERRESOLUTION1280X960FPS12: m_pColorStream->SetImageType(NUI_IMAGE_TYPE_COLOR_RAW_BAYER); m_pColorStream->SetImageResolution(NUI_IMAGE_RESOLUTION_1280x960); break; default: return; } m_pColorStream->OpenStream(); } else if (ID_DEPTHSTREAM_PAUSE == commandId) { // Pause depth stream if(m_pDepthStream) { m_pDepthStream->PauseStream(!previouslyChecked); } } else if (ID_DEPTHSTREAM_RANGEMODE_START <= commandId && ID_DEPTHSTREAM_RANGEMODE_END >= commandId) { // Set depth stream range mode bool nearMode = false; switch (commandId) { case ID_RANGEMODE_DEFAULT: nearMode = false; break; case ID_RANGEMODE_NEAR: nearMode = true; break; default: return; } if (m_pDepthStream) { m_pDepthStream->SetNearMode(nearMode); } if (m_pSkeletonStream) { m_pSkeletonStream->SetNearMode(nearMode); } } else if (ID_DEPTHSTREAM_RESOLUTION_START <= commandId && ID_DEPTHSTREAM_RESOLUTION_END >= commandId) { // Set depth stream resolution NUI_IMAGE_RESOLUTION resolution = (NUI_IMAGE_RESOLUTION)(commandId - ID_DEPTHSTREAM_RESOLUTION_START); if (m_pDepthStream) { m_pDepthStream->OpenStream(resolution); } } else if (ID_DEPTHSTREAM_DEPTHTREATMENT_START <= commandId && ID_DEPTHSTREAM_DEPTHTREATMENT_END >= commandId) { // Set depth stream treatment mode DEPTH_TREATMENT treatment = (DEPTH_TREATMENT)(commandId - ID_DEPTHSTREAM_DEPTHTREATMENT_START); if (m_pDepthStream) { m_pDepthStream->SetDepthTreatment(treatment); } } else if (ID_SKELETONSTREAM_PAUSE == commandId) { // Pause skeleton stream if (m_pSkeletonStream) { m_pSkeletonStream->PauseStream(!previouslyChecked); } } else if (ID_SKELETONSTREAM_TRACKINGMODE_START <= commandId && ID_SKELETONSTREAM_TRACKINGMODE_END >= commandId) { // Set skeleton track mode if (!m_pSkeletonStream) { return; } switch (commandId) { case ID_TRACKINGMODE_DEFAULT: m_pSkeletonStream->SetSeatedMode(false); break; case ID_TRACKINGMODE_SEATED: m_pSkeletonStream->SetSeatedMode(true); break; default: return; } } else if (ID_SKELETONSTREAM_CHOOSERMODE_START <= commandId && ID_SKELETONSTREAM_CHOOSERMODE_END >= commandId) { // Set skeleton chooser mode if(!m_pSkeletonStream) { return; } m_pSkeletonStream->SetChooserMode(ConvertCommandIdToChooserMode(commandId)); } else { switch (commandId) { // Bring up camera color setting dialog case ID_CAMERA_COLORSETTINGS: m_pColorSettingsView->ShowView(); break; // Bring up camera exposure setting dialog case ID_CAMERA_EXPOSURESETTINGS: m_pExposureSettingsView->ShowView(); break; // Switch the stream display on primary and secondary stream viewers case ID_VIEWS_SWITCH: if (m_pColorStream && m_pDepthStream) { m_pColorStream->SetStreamViewer(m_pDepthStream->SetStreamViewer(m_pColorStream->SetStreamViewer(nullptr))); } break; case ID_FORCE_OFF_IR: m_pNuiSensor->NuiSetForceInfraredEmitterOff(param); break; //////Recording case ID_RECORDING_AUDIO: if (m_pAudioStream && !m_pAudioStream->GetRecordingStauts()) { m_pAudioStream->SetRecordingStatus(true); } else if (m_pAudioStream && m_pAudioStream->GetRecordingStauts()) { m_pAudioStream->m_pWaveWriter->Stop(); delete(m_pAudioStream->m_pWaveWriter); m_pAudioStream->m_pWaveWriter=NULL; m_pAudioStream->SetRecordingStatus(false); } break; case ID_RECORDING_RGB: if (m_pColorStream && !m_pColorStream->GetRecordingStauts()) { m_pColorStream->SetRecordingStatus(true); } else if (m_pColorStream && m_pColorStream->GetRecordingStauts()) { cvReleaseVideoWriter(&m_pColorStream->m_pwriter); m_pColorStream->m_pwriter=nullptr; m_pColorStream->SetRecordingStatus(false); } break; case ID_RECORDING_DEPTH: if (m_pDepthStream && !m_pDepthStream->GetRecordingStauts()) { m_pDepthStream->SetRecordingStatus(true); } else if (m_pDepthStream && m_pDepthStream->GetRecordingStauts()) { cvReleaseVideoWriter(&m_pDepthStream->m_pwriter); m_pDepthStream->m_pwriter=nullptr; m_pDepthStream->SetRecordingStatus(false); } break; case ID_RECORDING_ALL: ////RGB if (m_pColorStream && !m_pColorStream->GetRecordingStauts()) { m_pColorStream->SetRecordingStatus(true); } else if (m_pColorStream && m_pColorStream->GetRecordingStauts()) { cvReleaseVideoWriter(&m_pColorStream->m_pwriter); m_pColorStream->m_pwriter=nullptr; m_pColorStream->SetRecordingStatus(false); } ////Depth if (m_pDepthStream && !m_pDepthStream->GetRecordingStauts()) { m_pDepthStream->SetRecordingStatus(true); } else if (m_pDepthStream && m_pDepthStream->GetRecordingStauts()) { cvReleaseVideoWriter(&m_pDepthStream->m_pwriter); m_pDepthStream->m_pwriter=nullptr; m_pDepthStream->SetRecordingStatus(false); } //////Audio if (m_pAudioStream && !m_pAudioStream->GetRecordingStauts()) { m_pAudioStream->SetRecordingStatus(true); } else if (m_pAudioStream && m_pAudioStream->GetRecordingStauts()) { m_pAudioStream->m_pWaveWriter->Stop(); delete(m_pAudioStream->m_pWaveWriter); m_pAudioStream->m_pWaveWriter=NULL; m_pAudioStream->SetRecordingStatus(false); } break; ////Recording 3D facial model case ID_RECORDING_3DFACIALMODEL: if (!(pFaceTracker->GetFTRecordingStatus())) pFaceTracker->SetFTRecordingStatus(true); else { pFaceTracker->SetFTRecordingStatus(false); pFaceTracker->ResetAUSUcounts(); pFaceTracker->CloseAUSUfile(); } break; ////Speech recognition dication pad case ID_SPEECHRECOGNITION: /*if (!m_threadRun) {*/ //m_hSpeechRecogThread=CreateThread(NULL, 0, m_pKinectWindow->SpeechRecogStaticThread, (PVOID)m_pKinectWindow, 0, 0); //m_threadRun=true; /* } else {*/ //if (m_hSpeechRecogThread) //{ // CSimpleDict* pSimpleDict; // m_pKinectWindow->GetSimpleDict(&pSimpleDict); // pSimpleDict->~CSimpleDict(); // WaitForSingleObject(m_hSpeechRecogThread, 200); // CloseHandle(m_hSpeechRecogThread); // m_threadRun=false; //} //} break; ////In-bed detection case ID_FALLDETECTION: if (!(pFallDetect->getIsRunFallDetect())) { pFallDetect->setIsRunFallDetect(TRUE); if (!m_FallDetectThreadRun) { m_hFallDetectTxt2SpeechThread = CreateThread(NULL, 0, pFallDetect->Txt2SpeechStaticThread, (PVOID)pFallDetect, 0, 0); m_FallDetectThreadRun = TRUE; } } else { pFallDetect->setIsRunFallDetect(FALSE); if (m_FallDetectThreadRun) { DWORD lpExitCode; GetExitCodeThread(m_hFallDetectTxt2SpeechThread, &lpExitCode); TerminateThread(m_hFallDetectTxt2SpeechThread, lpExitCode); WaitForSingleObject(m_hFallDetectTxt2SpeechThread, 200); CloseHandle(m_hFallDetectTxt2SpeechThread); m_FallDetectThreadRun = FALSE; } } break; case ID_MOVEMENTDETECTION: if (!(pFallDetect->getIsRunMovementDetect())) { pFallDetect->setIsRunMovementDetect(TRUE); } else { pFallDetect->setIsRunMovementDetect(FALSE); } break; case ID_OUTOFBEDDETECTION: break; case ID_LYANGLEDETECTION: if (!(pDepthInbedApps->getIsRunLyAngleDetect())) { pDepthInbedApps->setIsRunLyAngleDetect(TRUE); } else { pDepthInbedApps->setIsRunLyAngleDetect(FALSE); } break; case ID_CALLNURSINGBYHANDRAISING: if (!(pFallDetect->getIsRunHandsMovementRIC())) { pFallDetect->setIsRunHandsMovementRIC(TRUE); if (!m_NurseCallThreadRun) { m_hNurseCallTxt2SpeechThread = CreateThread(NULL, 0, m_pPrimaryView->Txt2SpeechStaticThread, (PVOID)m_pPrimaryView, 0, 0); m_NurseCallThreadRun = TRUE; } } else { pFallDetect->setIsRunHandsMovementRIC(FALSE); if (m_NurseCallThreadRun) { DWORD lpExitCode; GetExitCodeThread(m_hNurseCallTxt2SpeechThread, &lpExitCode); TerminateThread(m_hNurseCallTxt2SpeechThread, lpExitCode); WaitForSingleObject(m_hNurseCallTxt2SpeechThread, 200); CloseHandle(m_hNurseCallTxt2SpeechThread); m_NurseCallThreadRun = FALSE; } } break; case ID_VIEWDETECTIONRECS: if (!m_processFlag) { ViewDetectionRes(); m_processFlag = TRUE; } else { GetViewDetecResProcessStatus(&ExitCode); TerminateProcess(m_pi.hProcess, ExitCode); m_processFlag = FALSE; } break; case ID_STANDMOVELEGOUTWARD: if (!(pLegRaisExer->isRunningExcer())) { Sleep(5000); pLegRaisExer->setRunningExer(TRUE); if (!m_LegRaisexcerThreadRun) { m_hLegRaisExcerTxt2SpeechThread = CreateThread(NULL, 0, pLegRaisExer->Txt2SpeechStaticThread, (PVOID)pLegRaisExer, 0, 0); m_LegRaisexcerThreadRun = TRUE; } } else { pLegRaisExer->setRunningExer(FALSE); pLegRaisExer->Reset(); if (m_LegRaisexcerThreadRun) { DWORD lpExitCode; GetExitCodeThread(m_hLegRaisExcerTxt2SpeechThread, &lpExitCode); TerminateThread(m_hLegRaisExcerTxt2SpeechThread, lpExitCode); WaitForSingleObject(m_hLegRaisExcerTxt2SpeechThread, 200); CloseHandle(m_hLegRaisExcerTxt2SpeechThread); m_LegRaisexcerThreadRun = FALSE; } } break; case ID_STANDARMSLIFTWEIGHTS: if (!(pHandRaisExer->isRunningExcer())) { Sleep(5000); pHandRaisExer->setRunningExer(TRUE); if (!m_HandRaisexcerThreadRun) { m_hHandRaisExcerTxt2SpeechThread = CreateThread(NULL, 0, pHandRaisExer->Txt2SpeechStaticThread, (PVOID)pHandRaisExer, 0, 0); m_HandRaisexcerThreadRun = TRUE; } } else { pHandRaisExer->setRunningExer(FALSE); pHandRaisExer->Reset(); if (m_HandRaisexcerThreadRun) { DWORD lpExitCode; GetExitCodeThread(m_hHandRaisExcerTxt2SpeechThread, &lpExitCode); TerminateThread(m_hHandRaisExcerTxt2SpeechThread, lpExitCode); WaitForSingleObject(m_hHandRaisExcerTxt2SpeechThread, 200); CloseHandle(m_hHandRaisExcerTxt2SpeechThread); m_HandRaisexcerThreadRun = FALSE; } } break; default: break; } } }
int main() { try { FaceTracker faceTracker; faceTracker.Initialize(); faceTracker.Start(true); FatigueDetection fatigueDetection; int simpleCounter = 0; int* IDPtr = faceTracker.GetIDs(); //std::cout << *IDPtr << std::endl; ; for (;;) { IDPtr = faceTracker.GetIDs(); if (simpleCounter % 15 == 0) { /*fatigueDetection.DetectFatigue(faceTracker.GetPose()); fatigueDetection.DetectYawn(faceTracker.GetFaceFeatures());*/ std::cout << '#' << simpleCounter / 15; int personNum = 0; for (personNum; personNum < 6; personNum++) { if (*(IDPtr + personNum) != -1) { std::cout << "\t" << *(IDPtr + personNum) << '\t'; } } std::cout << std::endl; if (faceTracker.FaceFound()) { std::cout << faceTracker.GetFaceFeatures(); std::cout << "Is Yawning? : " << fatigueDetection.DetectYawn(faceTracker.GetFaceFeatures()) << std::endl; } else { std::cout << "FACE NOT FOUND! >:(" << std::endl; personNum = 0; for (personNum; personNum < 6; personNum++) { IDPtr[personNum] = -1; } } std::cout << std::endl; } simpleCounter++; if (cv::waitKey(33) == 'a') { break; } } } catch (FaceTrackerException& error) { std::cout << error.what() << std::endl; } return EXIT_SUCCESS; }
/** @function main */ int main( int argc, const char** argv ) { // check arguements // if(argc < 2) // { // printf("ERROR: Please enter window position x & y\n"); // exit(0); // } // // int windowX = atoi(argv[1]); // usually 5 // int windowY = atoi(argv[2]); // usually 14 int windowX = 1274; // usually 5 int windowY = 280; // usually 14 CvCapture* capture; IplImage* frame; FaceTracker* faceTracker = new FaceTracker("/opt/local/share/OpenCV/haarcascades/haarcascade_frontalface_alt.xml"); capture = cvCaptureFromCAM(2); if(capture) { cvNamedWindow ("img", CV_WINDOW_AUTOSIZE); cvMoveWindow("img", windowX, windowY); //Set the background to black image = cvLoadImage( "../../data/grandTetons_very_small.jpg", CV_LOAD_IMAGE_UNCHANGED) ; //background = cvCreateImage(cvSize(1024, 768),image->depth,image->nChannels); background = cvCreateImage(cvSize(resX, resY),image->depth,image->nChannels); bgMax = Point(0,0); bgMax = Point(background->width-1,background->height-1); cvRectangle(background, Point(0,0), Point(background->width,background->height), cvScalar(0, 0, 0), CV_FILLED, 8, 0); setupParticles(); Face face; face.x = background->width/2; face.y = background->height/2; face.radius = 1; while( true ) { frame = cvQueryFrame( capture ); faceTracker->findFace(frame); if (faceTracker->numFaces) { // scale face position in relation to background width int xPerc = frame->width - faceTracker->face.x; // invert to flip xPerc = (float)xPerc * ((float)image->width/(float)frame->width); xPerc += xOffset; int yPerc = faceTracker->face.y; yPerc = (float)yPerc * ((float)image->height/(float)frame->height); yPerc += yOffset; int rPerc = faceTracker->face.radius; // scale face position in relation to background width rPerc = (float)rPerc * ((float)image->width/(float)frame->width); //printf("x %d y %d r %d\n", xPerc, yPerc, rPerc); face.x = xPerc; face.y = yPerc; face.radius = rPerc; face.radius *= 1.8; cvRectangle(background, Point(0,0), Point(background->width,background->height), cvScalar(0, 0, 0), CV_FILLED, 8, 0); update(&face); // put video behind image cvFlip(frame, NULL, 1); // flip image so it mirrors the user cvSetImageROI(background, cvRect(xOffset, yOffset, image->width-1, image->height)); cvResize(frame, background, CV_INTER_LINEAR); cvResetImageROI(background); } else { face.x = 0; face.y = 0; face.radius = 1; cvRectangle(background, Point(0,0), Point(background->width,background->height), cvScalar(0, 0, 0), CV_FILLED, 8, 0); update(&face); } draw(background); cvShowImage("img", background); int c = waitKey(1); switch (c) { case 'c': case 'C': cursorMode = ( cursorMode + 1 > 1 ) ? 0 : 1 ; break ; case 's': case 'S': springEnabled = !springEnabled ; break ; case 'r': case 'R': reset(); break ; } //cvReleaseImage(&frame); } } else{ printf("ERROR: Camera not loaded\n"); } return 0; }
void AvatarInputs::toggleCameraMute() { FaceTracker* faceTracker = Application::getInstance()->getSelectedFaceTracker(); if (faceTracker) { faceTracker->toggleMute(); } }
int run_video_mode(const Configuration &cfg, const CommandLineArgument<std::string> &image_argument, const CommandLineArgument<std::string> &landmarks_argument) { FaceTracker *tracker = LoadFaceTracker(cfg.model_pathname.c_str()); FaceTrackerParams *tracker_params = LoadFaceTrackerParams(cfg.params_pathname.c_str()); assert(tracker); assert(tracker_params); cv::VideoCapture input(image_argument->c_str()); if (!input.isOpened()) throw make_runtime_error("Unable to open video file '%s'", image_argument->c_str()); cv::Mat image; std::vector<char> pathname_buffer; pathname_buffer.resize(1000); input >> image; int frame_number = 1; while ((image.rows > 0) && (image.cols > 0)) { if (cfg.verbose) { printf(" Frame number %d\r", frame_number); fflush(stdout); } cv::Mat_<uint8_t> gray_image; if (image.type() == cv::DataType<cv::Vec<uint8_t,3> >::type) cv::cvtColor(image, gray_image, CV_BGR2GRAY); else if (image.type() == cv::DataType<uint8_t>::type) gray_image = image; else throw make_runtime_error("Do not know how to convert video frame to a grayscale image."); int result = tracker->Track(gray_image, tracker_params); std::vector<cv::Point_<double> > shape; std::vector<cv::Point3_<double> > shape3D; Pose pose; if (result >= cfg.tracking_threshold) { shape = tracker->getShape(); shape3D = tracker->get3DShape(); pose = tracker->getPose(); } else { tracker->Reset(); } if (!have_argument_p(landmarks_argument)) { display_data(cfg, image, shape, pose); } else if (shape.size() > 0) { snprintf(pathname_buffer.data(), pathname_buffer.size(), landmarks_argument->c_str(), frame_number); if (cfg.save_3d_points) save_points3(pathname_buffer.data(), shape3D); else save_points(pathname_buffer.data(), shape); if (cfg.verbose) display_data(cfg, image, shape, pose); } else if (cfg.verbose) { display_data(cfg, image, shape, pose); } input >> image; frame_number++; } delete tracker; delete tracker_params; return 0; }
// Helpers int run_lists_mode(const Configuration &cfg, const CommandLineArgument<std::string> &image_argument, const CommandLineArgument<std::string> &landmarks_argument) { FaceTracker * tracker = LoadFaceTracker(cfg.model_pathname.c_str()); FaceTrackerParams *tracker_params = LoadFaceTrackerParams(cfg.params_pathname.c_str()); std::list<std::string> image_pathnames = read_list(image_argument->c_str()); std::list<std::string> landmark_pathnames; if (have_argument_p(landmarks_argument)) { landmark_pathnames = read_list(landmarks_argument->c_str()); if (landmark_pathnames.size() != image_pathnames.size()) throw make_runtime_error("Number of pathnames in list '%s' does not match the number in '%s'", image_argument->c_str(), landmarks_argument->c_str()); } std::list<std::string>::const_iterator image_it = image_pathnames.begin(); std::list<std::string>::const_iterator landmarks_it = landmark_pathnames.begin(); const int number_of_images = image_pathnames.size(); int current_image_index = 1; for (; image_it != image_pathnames.end(); image_it++) { if (cfg.verbose) { printf(" Image %d/%d\r", current_image_index, number_of_images); fflush(stdout); } current_image_index++; cv::Mat image; cv::Mat_<uint8_t> gray_image = load_grayscale_image(image_it->c_str(), &image); int result = tracker->NewFrame(gray_image, tracker_params); std::vector<cv::Point_<double> > shape; std::vector<cv::Point3_<double> > shape3D; Pose pose; if (result >= cfg.tracking_threshold) { shape = tracker->getShape(); shape3D = tracker->get3DShape(); pose = tracker->getPose(); } else { tracker->Reset(); } if (!have_argument_p(landmarks_argument)) { display_data(cfg, image, shape, pose); } else if (shape.size() > 0) { if (cfg.save_3d_points) save_points3(landmarks_it->c_str(), shape3D); else save_points(landmarks_it->c_str(), shape); if (cfg.verbose) display_data(cfg, image, shape, pose); } else if (cfg.verbose) { display_data(cfg, image, shape, pose); } if (have_argument_p(landmarks_argument)) landmarks_it++; } delete tracker; delete tracker_params; return 0; }