int main(void)
{
printf( "\n===== Head tracking Tutorial for DARwIn =====\n\n");
change_current_dir();
minIni* ini = new minIni(INI_FILE_PATH);
Image* rgb_ball = new Image(Camera::WIDTH, Camera::HEIGHT, Image::RGB_PIXEL_SIZE);
LinuxCamera::GetInstance()->Initialize(0);
LinuxCamera::GetInstance()->LoadINISettings(ini);
mjpg_streamer* streamer = new mjpg_streamer(Camera::WIDTH, Camera::HEIGHT);
BallTracker tracker = BallTracker();
tracker.LoadINISettings(ini);
httpd::ball_finder = &tracker.finder;
//////////////////// Framework Initialize ////////////////////////////
LinuxArbotixPro linux_arbotixpro(U2D_DEV_NAME);
ArbotixPro arbotixpro(&linux_arbotixpro);
if (MotionManager::GetInstance()->Initialize(&arbotixpro) == false)
{
printf("Fail to initialize Motion Manager!\n");
return 0;
}
MotionManager::GetInstance()->AddModule((MotionModule*)Head::GetInstance());
LinuxMotionTimer::Initialize(MotionManager::GetInstance());
MotionStatus::m_CurrentJoints.SetEnableBodyWithoutHead(false);
MotionManager::GetInstance()->SetEnable(true);
/////////////////////////////////////////////////////////////////////
Head::GetInstance()->m_Joint.SetEnableHeadOnly(true, true);
Head::GetInstance()->m_Joint.SetPGain(JointData::ID_HEAD_PAN, 8);
Head::GetInstance()->m_Joint.SetPGain(JointData::ID_HEAD_TILT, 8);
while (1)
{
Point2D pos;
LinuxCamera::GetInstance()->CaptureFrame();
tracker.Process(LinuxCamera::GetInstance()->fbuffer->m_HSVFrame);
rgb_ball = LinuxCamera::GetInstance()->fbuffer->m_RGBFrame;
for (int i = 0; i < rgb_ball->m_NumberOfPixels; i++)
{
if (tracker.finder.m_result->m_ImageData[i] == 1)
{
rgb_ball->m_ImageData[i * rgb_ball->m_PixelSize + 0] = 255;
rgb_ball->m_ImageData[i * rgb_ball->m_PixelSize + 1] = 0;
rgb_ball->m_ImageData[i * rgb_ball->m_PixelSize + 2] = 0;
}
}
streamer->send_image(rgb_ball);
}
return 0;
}
int main(void)
{
printf( "\n===== Head tracking Tutorial for DARwIn =====\n\n");
change_current_dir();
minIni* ini = new minIni(INI_FILE_PATH);
Image* rgb_ball = new Image(Camera::WIDTH, Camera::HEIGHT, Image::RGB_PIXEL_SIZE);
LinuxCamera::GetInstance()->Initialize(0);
LinuxCamera::GetInstance()->LoadINISettings(ini);
mjpg_streamer* streamer = new mjpg_streamer(Camera::WIDTH, Camera::HEIGHT);
ColorFinder* ball_finder = new ColorFinder();
ball_finder->LoadINISettings(ini);
httpd::ball_finder = ball_finder;
BallTracker tracker = BallTracker();
//////////////////// Framework Initialize ////////////////////////////
LinuxCM730 linux_cm730(U2D_DEV_NAME);
CM730 cm730(&linux_cm730);
if(MotionManager::GetInstance()->Initialize(&cm730) == false)
{
printf("Fail to initialize Motion Manager!\n");
return 0;
}
MotionManager::GetInstance()->AddModule((MotionModule*)Head::GetInstance());
LinuxMotionTimer *motion_timer = new LinuxMotionTimer(MotionManager::GetInstance());
motion_timer->Start();
MotionStatus::m_CurrentJoints.SetEnableBodyWithoutHead(false);
MotionManager::GetInstance()->SetEnable(true);
/////////////////////////////////////////////////////////////////////
Head::GetInstance()->m_Joint.SetEnableHeadOnly(true, true);
Head::GetInstance()->m_Joint.SetPGain(JointData::ID_HEAD_PAN, 8);
Head::GetInstance()->m_Joint.SetPGain(JointData::ID_HEAD_TILT, 8);
struct timeval tval;
gettimeofday(&tval, NULL);
double prevtime = tval.tv_sec + tval.tv_usec / 1000000.0;
while(1)
{
Point2D pos;
LinuxCamera::GetInstance()->CaptureFrame();
tracker.Process(ball_finder->GetPosition(LinuxCamera::GetInstance()->fbuffer->m_HSVFrame));
rgb_ball = LinuxCamera::GetInstance()->fbuffer->m_RGBFrame;
for(int i = 0; i < rgb_ball->m_NumberOfPixels; i++)
{
if(ball_finder->m_result->m_ImageData[i] == 1)
{
rgb_ball->m_ImageData[i*rgb_ball->m_PixelSize + 0] = 255;
rgb_ball->m_ImageData[i*rgb_ball->m_PixelSize + 1] = 0;
rgb_ball->m_ImageData[i*rgb_ball->m_PixelSize + 2] = 0;
}
}
streamer->send_image(rgb_ball);
gettimeofday(&tval, NULL);
double curtime = tval.tv_sec + tval.tv_usec / 1000000.0;
printf("FPS: % 2d\n", (int) (1 / (curtime - prevtime)));
prevtime = curtime;
}
return 0;
}
int main(void)
{
printf( "\n===== Ball following Tutorial for DARwIn =====\n\n");
change_current_dir();
Image* rgb_ball = new Image(Camera::WIDTH, Camera::HEIGHT, Image::RGB_PIXEL_SIZE);
minIni* ini = new minIni(INI_FILE_PATH);
LinuxCamera::GetInstance()->Initialize(0);
LinuxCamera::GetInstance()->LoadINISettings(ini);
mjpg_streamer* streamer = new mjpg_streamer(Camera::WIDTH, Camera::HEIGHT);
ColorFinder* ball_finder = new ColorFinder();
ball_finder->LoadINISettings(ini);
httpd::ball_finder = ball_finder;
BallTracker tracker = BallTracker();
BallFollower follower = BallFollower();
follower.DEBUG_PRINT = true;
//////////////////// Framework Initialize ////////////////////////////
LinuxCM730 linux_cm730(U2D_DEV_NAME);
CM730 cm730(&linux_cm730);
if(MotionManager::GetInstance()->Initialize(&cm730) == false)
{
printf("Fail to initialize Motion Manager!\n");
return 0;
}
MotionManager::GetInstance()->LoadINISettings(ini);
Walking::GetInstance()->LoadINISettings(ini);
MotionManager::GetInstance()->AddModule((MotionModule*)Head::GetInstance());
MotionManager::GetInstance()->AddModule((MotionModule*)Walking::GetInstance());
LinuxMotionTimer *motion_timer = new LinuxMotionTimer(MotionManager::GetInstance());
motion_timer->Start();
/////////////////////////////////////////////////////////////////////
// how to get smooth initialization.
// initialize the CM730, initialize the MotionManager, add the playback object
// to the motion manager, and don't start the motion timer until after
// this is called
// this is an offset into the params below
int n = 0;
// this is what gets written to the CM730 eventually, 5 ints per joint
int param[JointData::NUMBER_OF_JOINTS * 5];
// temporary variables per jointin the Playback object to reflect the
// very first tick of the trajectory so that the JointData is accurately
// reflecting goal position
int wGoalPosition, wStartPosition, wDistance;
// for each joint
for(int id=JointData::ID_R_SHOULDER_PITCH; id<JointData::NUMBER_OF_JOINTS; id++)
{
// get current value (rotation encoder ticks)
wStartPosition = MotionStatus::m_CurrentJoints.GetValue(id);
// get initial value from motion module
wGoalPosition = Walking::GetInstance()->m_Joint.GetValue(id);
// get the absolute value of the distance between start & goal (in ticks)
if( wStartPosition > wGoalPosition )
wDistance = wStartPosition - wGoalPosition;
else
wDistance = wGoalPosition - wStartPosition;
// divide distance by 4 - this is totally dumb because wDistance /= 4 would read so much better
wDistance >>= 2;
// enforce a min distance of 8
if( wDistance < 8 )
wDistance = 8;
// first int among params is the joint id
param[n++] = id;
// next two ints among params are the low and high bytes of the goal position
param[n++] = CM730::GetLowByte(wGoalPosition);
param[n++] = CM730::GetHighByte(wGoalPosition);
// next two ints among params are the low and high bytes of the distance
// which I beleive is not actually used as a distance here, but rather
// as a gain or speed control (there is an implicit "per second" going on here
// , I have a hunch)
param[n++] = CM730::GetLowByte(wDistance);
param[n++] = CM730::GetHighByte(wDistance);
}
// communicate directly with the CM730 board to use presumably
// the MX28::P_GOAL_POSITION_L command,
// my guess is that 5 is the # params per packet
// my guess is that NUMBER_OF_JOINTS-1 is the # packets
// very last thing is ptr to param packet data
cm730.SyncWrite(MX28::P_GOAL_POSITION_L, 5, JointData::NUMBER_OF_JOINTS - 1, param);
printf("Press the ENTER key to begin!\n");
getchar();
Head::GetInstance()->m_Joint.SetEnableHeadOnly(true, true);
Walking::GetInstance()->m_Joint.SetEnableBodyWithoutHead(true, true);
MotionManager::GetInstance()->SetEnable(true);
while(1)
{
Point2D pos;
LinuxCamera::GetInstance()->CaptureFrame();
memcpy(rgb_ball->m_ImageData, LinuxCamera::GetInstance()->fbuffer->m_RGBFrame->m_ImageData, LinuxCamera::GetInstance()->fbuffer->m_RGBFrame->m_ImageSize);
tracker.Process(ball_finder->GetPosition(LinuxCamera::GetInstance()->fbuffer->m_HSVFrame));
follower.Process(tracker.ball_position);
for(int i = 0; i < rgb_ball->m_NumberOfPixels; i++)
{
if(ball_finder->m_result->m_ImageData[i] == 1)
{
rgb_ball->m_ImageData[i*rgb_ball->m_PixelSize + 0] = 255;
rgb_ball->m_ImageData[i*rgb_ball->m_PixelSize + 1] = 0;
rgb_ball->m_ImageData[i*rgb_ball->m_PixelSize + 2] = 0;
}
}
streamer->send_image(rgb_ball);
}
return 0;
}
int main(void)
{
//Register signal and signal handler
signal(SIGINT, signal_callback_handler);
printf( "\n===== Head tracking Tutorial for DARwIn =====\n\n");
change_current_dir();
minIni* ini = new minIni(INI_FILE_PATH);
Image* rgb_ball = new Image(Camera::WIDTH, Camera::HEIGHT, Image::RGB_PIXEL_SIZE);
LinuxCamera::GetInstance()->Initialize(0);
LinuxCamera::GetInstance()->LoadINISettings(ini);
mjpg_streamer* streamer = new mjpg_streamer(Camera::WIDTH, Camera::HEIGHT);
ColorFinder* ball_finder = new ColorFinder();
ball_finder->LoadINISettings(ini);
httpd::ball_finder = ball_finder;
BallTracker tracker = BallTracker();
//////////////////// Framework Initialize ////////////////////////////
if (MotionManager::GetInstance()->Initialize(&arbotixpro) == false)
{
linux_arbotixpro.SetPortName(U2D_DEV_NAME1);
if (MotionManager::GetInstance()->Initialize(&arbotixpro) == false)
{
printf("Fail to initialize Motion Manager!\n");
return 0;
}
}
Walking::GetInstance()->LoadINISettings(ini);
usleep(100);
MotionManager::GetInstance()->LoadINISettings(ini);
MotionManager::GetInstance()->AddModule((MotionModule*)Action::GetInstance());
MotionManager::GetInstance()->AddModule((MotionModule*)Head::GetInstance());
MotionManager::GetInstance()->AddModule((MotionModule*)Walking::GetInstance());
//MotionManager::GetInstance()->StartThread();
//LinuxMotionTimer::Initialize(MotionManager::GetInstance());
LinuxMotionTimer linuxMotionTimer;
linuxMotionTimer.Initialize(MotionManager::GetInstance());
linuxMotionTimer.Start();
MotionStatus::m_CurrentJoints.SetEnableBodyWithoutHead(false);
MotionManager::GetInstance()->SetEnable(true);
/////////////////////////////////////////////////////////////////////
Head::GetInstance()->m_Joint.SetEnableHeadOnly(true, true);
//Head::GetInstance()->m_Joint.SetPGain(JointData::ID_HEAD_PAN, 8);
//Head::GetInstance()->m_Joint.SetPGain(JointData::ID_HEAD_TILT, 8);
while (isRunning)
{
//usleep(10000);
Point2D pos;
LinuxCamera::GetInstance()->CaptureFrame();
tracker.Process(ball_finder->GetPosition(LinuxCamera::GetInstance()->fbuffer->m_HSVFrame));
rgb_ball = LinuxCamera::GetInstance()->fbuffer->m_RGBFrame;
for (int i = 0; i < rgb_ball->m_NumberOfPixels; i++)
{
if (ball_finder->m_result->m_ImageData[i] == 1)
{
rgb_ball->m_ImageData[i * rgb_ball->m_PixelSize + 0] = 255;
rgb_ball->m_ImageData[i * rgb_ball->m_PixelSize + 1] = 0;
rgb_ball->m_ImageData[i * rgb_ball->m_PixelSize + 2] = 0;
}
}
streamer->send_image(rgb_ball);
}
return 0;
}
int main(void)
{
signal(SIGABRT, &sighandler);
signal(SIGTERM, &sighandler);
signal(SIGQUIT, &sighandler);
signal(SIGINT, &sighandler);
change_current_dir();
minIni* ini = new minIni(INI_FILE_PATH);
Image* rgb_output = new Image(Camera::WIDTH, Camera::HEIGHT, Image::RGB_PIXEL_SIZE);
LinuxCamera::GetInstance()->Initialize(0);
LinuxCamera::GetInstance()->SetCameraSettings(CameraSettings()); // set default
LinuxCamera::GetInstance()->LoadINISettings(ini); // load from ini
mjpg_streamer* streamer = new mjpg_streamer(Camera::WIDTH, Camera::HEIGHT);
ColorFinder* ball_finder = new ColorFinder();
ball_finder->LoadINISettings(ini);
httpd::ball_finder = ball_finder;
BallTracker tracker = BallTracker();
BallFollower follower = BallFollower();
ColorFinder* red_finder = new ColorFinder(0, 15, 45, 0, 0.3, 50.0);
red_finder->LoadINISettings(ini, "RED");
httpd::red_finder = red_finder;
ColorFinder* yellow_finder = new ColorFinder(60, 15, 45, 0, 0.3, 50.0);
yellow_finder->LoadINISettings(ini, "YELLOW");
httpd::yellow_finder = yellow_finder;
ColorFinder* blue_finder = new ColorFinder(225, 15, 45, 0, 0.3, 50.0);
blue_finder->LoadINISettings(ini, "BLUE");
httpd::blue_finder = blue_finder;
httpd::ini = ini;
//////////////////// Framework Initialize ////////////////////////////
if(MotionManager::GetInstance()->Initialize(&cm730) == false)
{
linux_cm730.SetPortName(U2D_DEV_NAME1);
if(MotionManager::GetInstance()->Initialize(&cm730) == false)
{
printf("Fail to initialize Motion Manager!\n");
return 0;
}
}
Walking::GetInstance()->LoadINISettings(ini);
MotionManager::GetInstance()->AddModule((MotionModule*)Action::GetInstance());
MotionManager::GetInstance()->AddModule((MotionModule*)Head::GetInstance());
MotionManager::GetInstance()->AddModule((MotionModule*)Walking::GetInstance());
LinuxMotionTimer *motion_timer = new LinuxMotionTimer(MotionManager::GetInstance());
motion_timer->Start();
/////////////////////////////////////////////////////////////////////
MotionManager::GetInstance()->LoadINISettings(ini);
int firm_ver = 0;
if(cm730.ReadByte(JointData::ID_HEAD_PAN, MX28::P_VERSION, &firm_ver, 0) != CM730::SUCCESS)
{
fprintf(stderr, "Can't read firmware version from Dynamixel ID %d!! \n\n", JointData::ID_HEAD_PAN);
exit(0);
}
if(0 < firm_ver && firm_ver < 27)
{
#ifdef MX28_1024
Action::GetInstance()->LoadFile(MOTION_FILE_PATH);
#else
fprintf(stderr, "MX-28's firmware is not support 4096 resolution!! \n");
fprintf(stderr, "Upgrade MX-28's firmware to version 27(0x1B) or higher.\n\n");
exit(0);
#endif
}
else if(27 <= firm_ver)
{
#ifdef MX28_1024
fprintf(stderr, "MX-28's firmware is not support 1024 resolution!! \n");
fprintf(stderr, "Remove '#define MX28_1024' from 'MX28.h' file and rebuild.\n\n");
exit(0);
#else
Action::GetInstance()->LoadFile((char*)MOTION_FILE_PATH);
#endif
}
else
exit(0);
Action::GetInstance()->m_Joint.SetEnableBody(true, true);
MotionManager::GetInstance()->SetEnable(true);
cm730.WriteByte(CM730::P_LED_PANNEL, 0x01|0x02|0x04, NULL);
LinuxActionScript::PlayMP3("../../../Data/mp3/Demonstration ready mode.mp3");
Action::GetInstance()->Start(15);
while(Action::GetInstance()->IsRunning()) usleep(8*1000);
while(1)
{
StatusCheck::Check(cm730);
Point2D ball_pos, red_pos, yellow_pos, blue_pos;
LinuxCamera::GetInstance()->CaptureFrame();
memcpy(rgb_output->m_ImageData, LinuxCamera::GetInstance()->fbuffer->m_RGBFrame->m_ImageData, LinuxCamera::GetInstance()->fbuffer->m_RGBFrame->m_ImageSize);
if(StatusCheck::m_cur_mode == READY || StatusCheck::m_cur_mode == VISION)
{
ball_pos = ball_finder->GetPosition(LinuxCamera::GetInstance()->fbuffer->m_HSVFrame);
red_pos = red_finder->GetPosition(LinuxCamera::GetInstance()->fbuffer->m_HSVFrame);
yellow_pos = yellow_finder->GetPosition(LinuxCamera::GetInstance()->fbuffer->m_HSVFrame);
blue_pos = blue_finder->GetPosition(LinuxCamera::GetInstance()->fbuffer->m_HSVFrame);
unsigned char r, g, b;
for(int i = 0; i < rgb_output->m_NumberOfPixels; i++)
{
r = 0; g = 0; b = 0;
if(ball_finder->m_result->m_ImageData[i] == 1)
{
r = 255;
g = 128;
b = 0;
}
if(red_finder->m_result->m_ImageData[i] == 1)
{
if(ball_finder->m_result->m_ImageData[i] == 1)
{
r = 0;
g = 255;
b = 0;
}
else
{
r = 255;
g = 0;
b = 0;
}
}
if(yellow_finder->m_result->m_ImageData[i] == 1)
{
if(ball_finder->m_result->m_ImageData[i] == 1)
{
r = 0;
g = 255;
b = 0;
}
else
{
r = 255;
g = 255;
b = 0;
}
}
if(blue_finder->m_result->m_ImageData[i] == 1)
{
if(ball_finder->m_result->m_ImageData[i] == 1)
{
r = 0;
g = 255;
b = 0;
}
else
{
r = 0;
g = 0;
b = 255;
}
}
if(r > 0 || g > 0 || b > 0)
{
rgb_output->m_ImageData[i * rgb_output->m_PixelSize + 0] = r;
rgb_output->m_ImageData[i * rgb_output->m_PixelSize + 1] = g;
rgb_output->m_ImageData[i * rgb_output->m_PixelSize + 2] = b;
}
}
}
else if(StatusCheck::m_cur_mode == SOCCER)
{
tracker.Process(ball_finder->GetPosition(LinuxCamera::GetInstance()->fbuffer->m_HSVFrame));
for(int i = 0; i < rgb_output->m_NumberOfPixels; i++)
{
if(ball_finder->m_result->m_ImageData[i] == 1)
{
rgb_output->m_ImageData[i*rgb_output->m_PixelSize + 0] = 255;
rgb_output->m_ImageData[i*rgb_output->m_PixelSize + 1] = 128;
rgb_output->m_ImageData[i*rgb_output->m_PixelSize + 2] = 0;
}
}
}
streamer->send_image(rgb_output);
if(StatusCheck::m_is_started == 0)
continue;
switch(StatusCheck::m_cur_mode)
{
case READY:
break;
case SOCCER:
if(Action::GetInstance()->IsRunning() == 0)
{
Head::GetInstance()->m_Joint.SetEnableHeadOnly(true, true);
Walking::GetInstance()->m_Joint.SetEnableBodyWithoutHead(true, true);
follower.Process(tracker.ball_position);
if(follower.KickBall != 0)
{
Head::GetInstance()->m_Joint.SetEnableHeadOnly(true, true);
Action::GetInstance()->m_Joint.SetEnableBodyWithoutHead(true, true);
if(follower.KickBall == -1)
{
Action::GetInstance()->Start(12); // RIGHT KICK
fprintf(stderr, "RightKick! \n");
}
else if(follower.KickBall == 1)
{
Action::GetInstance()->Start(13); // LEFT KICK
fprintf(stderr, "LeftKick! \n");
}
}
}
break;
case MOTION:
if(LinuxActionScript::m_is_running == 0)
LinuxActionScript::ScriptStart(SCRIPT_FILE_PATH);
break;
case VISION:
int detected_color = 0;
detected_color |= (red_pos.X == -1)? 0 : VisionMode::RED;
detected_color |= (yellow_pos.X == -1)? 0 : VisionMode::YELLOW;
detected_color |= (blue_pos.X == -1)? 0 : VisionMode::BLUE;
if(Action::GetInstance()->IsRunning() == 0)
VisionMode::Play(detected_color);
break;
}
}
return 0;
}
int main(int argc, const char** argv)
{
printf( "\n===== Face tracking Tutorial for DARwIn =====\n\n");
change_current_dir();
minIni* ini = new minIni(INI_FILE_PATH);
Image* rgb_ball = new Image(Camera::WIDTH, Camera::HEIGHT, Image::RGB_PIXEL_SIZE);
LinuxCamera::GetInstance()->Initialize(0);
LinuxCamera::GetInstance()->LoadINISettings(ini);
mjpg_streamer* streamer = new mjpg_streamer(Camera::WIDTH, Camera::HEIGHT);
BallTracker tracker = BallTracker();
//////////////////// Framework Initialize ////////////////////////////
LinuxCM730 linux_cm730(U2D_DEV_NAME);
CM730 cm730(&linux_cm730);
if(MotionManager::GetInstance()->Initialize(&cm730) == false)
{
printf("Fail to initialize Motion Manager!\n");
// return 0;
}
MotionManager::GetInstance()->LoadINISettings(ini);
MotionManager::GetInstance()->AddModule((MotionModule*)Head::GetInstance());
LinuxMotionTimer *motion_timer = new LinuxMotionTimer(MotionManager::GetInstance());
motion_timer->Start();
MotionStatus::m_CurrentJoints.SetEnableBodyWithoutHead(false);
MotionManager::GetInstance()->SetEnable(true);
/////////////////////////////////////////////////////////////////////
//Head::GetInstance()->LoadINISettings(ini);
Head::GetInstance()->m_Joint.SetEnableHeadOnly(true, true);
Head::GetInstance()->m_Joint.SetPGain(JointData::ID_HEAD_PAN, 8);
Head::GetInstance()->m_Joint.SetPGain(JointData::ID_HEAD_TILT, 8);
printf("Press the ENTER key to begin!\n");
getchar();
//parse command line arguments
char ftFile[256],conFile[256],triFile[256];
bool fcheck = false; double scale = 1; int fpd = -1; bool show = true;
if(parse_cmd(argc,argv,ftFile,conFile,triFile,fcheck,scale,fpd)<0)return 0;
//set other tracking parameters
std::vector<int> wSize1(1); wSize1[0] = 7;
std::vector<int> wSize2(3); wSize2[0] = 11; wSize2[1] = 9; wSize2[2] = 7;
int nIter = 5; double clamp=3,fTol=0.01;
FACETRACKER::Tracker model(ftFile);
cv::Mat tri=FACETRACKER::IO::LoadTri(triFile);
cv::Mat con=FACETRACKER::IO::LoadCon(conFile);
//initialize camera and display window
cv::Mat frame,gray,im; double fps=0; char sss[256]; std::string text;
int64 t1,t0 = cvGetTickCount(); int fnum=0;
bool failed = true;
while(1)
{
Point2D pos;
LinuxCamera::GetInstance()->CaptureFrame();
//Create the image header which will contain the converted BYTE image
int channel = 3; //1 for black and white pictures, 3 for colored pictures
int step = LinuxCamera::GetInstance()->fbuffer->m_RGBFrame->m_WidthStep;//depends from the channel
//grab image, resize and flip
IplImage* I = cvCreateImageHeader(cv::Size(LinuxCamera::GetInstance()->fbuffer->m_RGBFrame->m_Width,LinuxCamera::GetInstance()->fbuffer->m_RGBFrame->m_Height), IPL_DEPTH_8U, channel);
//Set the BYTE pointer as attribut of the IplImage --> "converts" BYTE *pData in IplImage *frame
cvSetData(I, LinuxCamera::GetInstance()->fbuffer->m_RGBFrame->m_ImageData, step);
if(!I)continue; frame = I;
if(scale == 1)im = frame;
else cv::resize(frame,im,cv::Size(scale*frame.cols,scale*frame.rows));
cv::flip(im,im,1);
cv::cvtColor(im,gray,CV_RGB2GRAY);
//track this image
std::vector<int> wSize; if(failed)wSize = wSize2; else wSize = wSize1;
if(model.Track(gray,wSize,fpd,nIter,clamp,fTol,fcheck) == 0){
int idx = model._clm.GetViewIdx(); failed = false;
Draw(im,model._shape,con,tri,model._clm._visi[idx]);
pos.X = model._rect.x+ model._rect.width/2;
pos.Y = model._rect.y+ model._rect.height/2;
}else{
if(show){cv::Mat R(im,cvRect(0,0,150,50)); R = cv::Scalar(0,0,255);}
model.FrameReset(); failed = true;
pos.X = -1;
pos.Y = -1;
}
//draw framerate on display image
if(fnum >= 9){
t1 = cvGetTickCount();
fps = 10.0/((double(t1-t0)/cvGetTickFrequency())/1e+6);
t0 = t1; fnum = 0;
}else fnum += 1;
if(show){
sprintf(sss,"%d frames/sec",(int)round(fps)); text = sss;
cv::putText(im,text,cv::Point(10,20),
CV_FONT_HERSHEY_SIMPLEX,0.5,CV_RGB(255,255,255));
}
//show image and check for user input
imshow("Face Tracker",im);
int c = cv::waitKey(10);
if(c == 27)break; else if(char(c) == 'd')model.Save("/home/koreki/Documents/perso/darwin/Linux/project/tutorial/face_tracker/koreki.tracker");//model.FrameReset();
//model.FrameReset();
// pos = facefinder->GetPosition(LinuxCamera::GetInstance()->fbuffer->m_RGBFrame);
tracker.Process(pos);
fprintf(stderr, "posx: %f, posy: %f \r", pos.X, pos.Y);
rgb_ball = LinuxCamera::GetInstance()->fbuffer->m_RGBFrame;
rgb_ball->m_ImageData = im.data;
streamer->send_image(rgb_ball);
}
return 0;
}