int main(int argc, const char * argv[])
{
VideoCaptureManager capture;
AlgorithmHolder detector;
FaceDetector face;
cv::namedWindow("Capture", CV_WINDOW_OPENGL|CV_WINDOW_AUTOSIZE|CV_WINDOW_FREERATIO);
//! assigns callback for mouse events
cv::setMouseCallback("Capture", mouseCallback);
cv::Mat_< unsigned char > frame;
while(1) {
capture.read(frame);
if(!frame.empty()){
// detector.detect(frame);
face.detect(frame);
if(cv::waitKey( 30 ) > 27){
std::cerr << detector.select() << std::endl;
}
cv::imshow( "Capture", frame);
}
}
}
/**
* @brief Main
*
* @param[in] argc
* @param[in] argv
*
* @returns 1
*
*/
int main( int argc, const char* argv[] ) {
if (argc < 4) {
banner();
help();
cerr << "ERR: missing parameters" << endl;
return -3;
}
string config_f(argv[1]);
string* config_e = NULL;
int i = 2;
if (argc == 5) {
config_e = new string(argv[i++]);
}
string infile(argv[i++]);
string outfile(argv[i++]);
FaceDetector* detector;
if (config_e != NULL) {
detector = new FaceDetector(config_f, *config_e);
} else {
detector = new FaceDetector(config_f);
}
delete config_e;
try {
Mat img = matrix_io_load(infile);
Mat cropped;
if (detector->detect(img, cropped)) {
matrix_io_save(cropped, outfile);
} else {
//cerr << "ERR: no face found.." << endl;
return 1;
}
delete detector;
}
catch (int e) {
cerr << "ERR: Exception #" << e << endl;
return -e;
}
return 0;
}
int main( int argc, const char* argv[] )
{
signal(SIGSEGV, sig_handler); // Segmentation fault (core dump) OS Signal handler
signal(SIGABRT, sig_handler); // Aborted (core dump)
try{
#ifdef OMP_ENABLE
omp_set_nested(true);
#endif;
tsm::Vector< tsm::Vector<char> > *args = getArguments((char**) argv, argc);
while( args->length < 2 || args->length > 3 ){
char arguments[200];
printf("Please set your arguments [image model settings]: ");
fgets(arguments, 199, stdin);
args = getArguments(arguments);
}
std::string *image_path = new std::string(args->data[0].data);
std::string *model_path = new std::string(args->data[1].data);
std::string *settings_path = ( args->length > 2 ) ? new std::string(args->data[2].data) : nullptr;
#ifdef TIME_PROFILE
double readDataTime = omp_get_wtime();
#endif
OpenCVHandler<float> imageHandler;
imageHandler.imagePath = image_path;
if( !imageHandler.readImage() ) throw ERROR_READ_IMAGE_CODE;
// Read Image
Image<uint8_t> *image = (Image<uint8_t>*) imageHandler.cv2ArrayImage();
if( !image ) throw ERROR_READ_IMAGE_CODE;
// Read settings
Settings<float> *settings = xmlReader<float>::readXMLSettings(settings_path);
if( !settings ) throw ERROR_READ_SETTINGS_CODE;
// Read Model
Model<float> *model = xmlReader<float>::readXMLModel(model_path);
if( !model ) throw ERROR_READ_MODEL_CODE;
#ifdef TIME_PROFILE
readDataTime = omp_get_wtime() - readDataTime;
#endif
#ifdef TIME_PROFILE
double detectTime = omp_get_wtime();
#endif
// Face Detection call
FaceDetector<float> *fdetector = new FaceDetector<float>(model, settings, image);
if ( !fdetector->detect() ) throw fdetector->errorCode;
tsm::Vector< Box<float> > *results = fdetector->boxCache->getResults();
#ifdef TIME_PROFILE
detectTime = omp_get_wtime() - detectTime;
#endif
#ifdef TIME_PROFILE
cout << "TSM Face Detection System Time Profile\n";
cout << "1. Read Data : " << readDataTime << "sec\n";
cout << "2. Face Detection : " << detectTime << "sec\n";
#endif
// Return Results
setOutput(results, settings, &imageHandler);
delete model;
delete image;
delete results;
delete settings;
}
catch(int code){
#ifdef PRINT_ERRORS
cout << "TSM System Error Code " << code <<"!\n";
#endif
return code;
}
catch(...){
cout << "TSM System Unkown Error Code!\n";
return ERROR_OS_CODE;
}
return 0;
}
int main(int argc, char ** argv)
{
/**********************************************************************
* Setup
* ********************************************************************
* This block sets up everything needed for the program
*
* *******************************************************************/
//-- YARP Resource finder (used to extract command line arguments)
//---------------------------------------------------------------------
yarp::os::ResourceFinder resourceFinder;
resourceFinder.setVerbose(false);
resourceFinder.configure(argc, argv);
//-- Show usage if requested:
//----------------------------------------------------------------------
if (resourceFinder.check("help"))
{
printUsage();
return 1;
}
//-- Extract can ids from the command line
//----------------------------------------------------------------------
std::vector<int> can_ids;
if (!resourceFinder.check("cans"))
{
std::cerr << "ERROR: no can sequence was specified!" << std::endl;
printUsage();
return 2;
}
std::string can_list = resourceFinder.find("cans").asString();
std::stringstream can_list_ss(can_list);
while ( !can_list_ss.eof())
{
int temp;
can_list_ss >> temp;
can_ids.push_back(temp);
std::cout << "New target added: " << temp << std::endl;
}
//-- Setup YARP
//-----------------------------------------------------------------------
//-- Start yarp server
// yarp::os::Network::init();
// yarp::os::Network::runNameServer(argc, argv);
//-- Setup Turret
//-----------------------------------------------------------------------
//-- Read port from command line
std::string serial_port_name = resourceFinder.find("port").asString();
if (serial_port_name == "")
serial_port_name = "/dev/ttyACM0";
std::cout << "Connecting to serial port: " << serial_port_name << std::endl;
//-- Start turret
Turret myTurret(serial_port_name);
if (!myTurret.start())
{
std::cerr << "[Test] Not able to connect!" << std::endl;
return 3;
}
std::cout << "Turret is now connected" << std::endl;
//-- Create face detector
//-----------------------------------------------------------------------
FaceDetector faceDetector;
std::cout << "Face detector ready. Safety measures enabled!" << std::endl;
//-- Setup webcam
//-----------------------------------------------------------------------
int camera_id = -1;
if (resourceFinder.check("camera"))
camera_id = resourceFinder.find("camera").asInt();
std::cout << "Opening camera: " << camera_id << std::endl;
cv::VideoCapture capture(camera_id);
if(!capture.isOpened())
{
report(ERROR,"Camera failed at opening");
return 4;
}
//-- Setup P controller params
//-----------------------------------------------------------------------
float kpx = 0.02;
float kpy = 0.02;
/**********************************************************************
* Program itself
* ********************************************************************
* This block is the program
*
* *******************************************************************/
//-- For each target
for (int i = 0; i < can_ids.size(); i++)
{
//-- Loop to track targets
//---------------------------------------------------------------------------------------
int error_x = 600, error_y = 600;
do
{
//-- Get image from webcam
cv::Mat frame;
capture.read(frame);
/*
* ***** HERE IS WHERE TARGET IS EXTRACTED
*/
std::vector<cv::Point> targets = getTargetHSV(0, frame);
if (targets.size() > 0)
{
cv::Point target = targets[0];
//-- Calculate error
error_x = frame.cols / 2 - target.x;
error_y = frame.rows / 2 - target.y;
std::cout << "--------------DEBUG--------------------------------" << std::endl;
std::cout << "Error x: " << error_x << std::endl;
std::cout << "Error y: " << error_y << std::endl;
//-- P controller
int move_x = - error_x * kpx;
int move_y = - error_y * kpy;
//-- Command motors
myTurret.movePanInc(move_x);
myTurret.moveTiltInc(move_y);
//-- Plotting target to have feedback
//cv::rectangle(frame, faces[0], cv::Scalar(0, 0, 255));
//cv::circle(frame, cv::Point(center_x, center_y ), 2, cv::Scalar(0, 0, 255), 2);
cv::circle(frame, target, 3, cv::Scalar(255, 0, 0), 2);
}else{
myTurret.seek(); //Seek new targets
}
//-- This is the scope (substitute it by another thing if needed)
cv::circle(frame, cv::Point(frame.cols / 2, frame.rows / 2 ), 2, cv::Scalar(255, 0, 0), 2);
//-- Show on screen things
cv::imshow("out", frame);
char key = cv::waitKey(30);
if ( key == 27 || key == 'q' )
return 0;
} while (abs(error_x) > THRESH_X || abs(error_y) > THRESH_Y );
//-- Safety loop: (Extract faces)
//-------------------------------------------------------------------------------------------
std::vector<cv::Rect> faces;
do
{
//-- Get image from webcam
cv::Mat frame;
capture.read(frame);
faces = faceDetector.detect(frame);
if (faces.size() == 0)
break;
std::cout << "Face detected!! Waiting to shoot..." << std::endl;
//-- calculate center of bounding box
int center_x = faces[0].x + faces[0].width / 2;
int center_y = faces[0].y + faces[0].height / 2;
//-- Plotting
cv::rectangle(frame, faces[0], cv::Scalar(0, 0, 255));
cv::circle(frame, cv::Point(center_x, center_y ), 2, cv::Scalar(0, 0, 255), 2);
cv::imshow("out", frame);
char key = cv::waitKey(30);
if ( key == 27 || key == 'q' )
return 0;
} while (faces.size() > 0 );
//-- All is clear: shoot!!
//---------------------------------------------------------------------------------------------
myTurret.shoot();
std::cout << "Target \"" << can_ids.at(i) << "\" was shot down!" << std::endl;
yarp::os::Time::delay(1);
}
myTurret.destroy();
yarp::os::Network::fini();
return 0;
}
