int main( int argc, char** argv )
{
CommandLineParser parser( argc, argv, keys );
String tracker_algorithm = parser.get<String>( 0 );
String video_name = parser.get<String>( 1 );
if( tracker_algorithm.empty() || video_name.empty() )
{
help();
return -1;
}
//open the capture
VideoCapture cap;
cap.open( video_name );
if( !cap.isOpened() )
{
help();
cout << "***Could not initialize capturing...***\n";
cout << "Current parameter's value: \n";
parser.printMessage();
return -1;
}
Mat frame;
paused = true;
namedWindow( "Tracking API", 1 );
setMouseCallback( "Tracking API", onMouse, 0 );
//instantiates the specific Tracker
Ptr<Tracker> tracker = Tracker::create( tracker_algorithm );
if( tracker == NULL )
{
cout << "***Error in the instantiation of the tracker...***\n";
return -1;
}
//get the first frame
cap >> frame;
frame.copyTo( image );
imshow( "Tracking API", image );
bool initialized = false;
for ( ;; )
{
if( !paused )
{
cap >> frame;
frame.copyTo( image );
if( !initialized && selectObject )
{
//initializes the tracker
if( !tracker->init( frame, boundingBox ) )
{
cout << "***Could not initialize tracker...***\n";
return -1;
}
initialized = true;
}
else if( initialized )
{
//updates the tracker
if( tracker->update( frame, boundingBox ) )
{
rectangle( image, boundingBox, Scalar( 255, 0, 0 ), 2, 1 );
}
}
imshow( "Tracking API", image );
}
char c = (char) waitKey( 2 );
if( c == 'q' )
break;
if( c == 'p' )
paused = !paused;
}
int main(int argc, char *argv[])
{
CommandLineParser parser(argc, argv, keys);
string datasetRootPath = parser.get<string>(0);
int datasetID = parser.get<int>(1);
if (datasetRootPath.empty())
{
help();
return -1;
}
Mat frame;
paused = false;
namedWindow("GOTURN Tracking", 0);
setMouseCallback("GOTURN Tracking", onMouse, 0);
//Create GOTURN tracker
Ptr<Tracker> tracker = Tracker::create("GOTURN");
//Load and init full ALOV300++ dataset with a given datasetID, as alternative you can use loadAnnotatedOnly(..)
//to load only frames with labled ground truth ~ every 5-th frame
Ptr<cv::datasets::TRACK_alov> dataset = TRACK_alov::create();
dataset->load(datasetRootPath);
dataset->initDataset(datasetID);
//Read first frame
dataset->getNextFrame(frame);
frame.copyTo(image);
rectangle(image, boundingBox, Scalar(255, 0, 0), 2, 1);
imshow("GOTURN Tracking", image);
bool initialized = false;
paused = true;
int frameCounter = 0;
//Time measurment
int64 e3 = getTickCount();
for (;;)
{
if (!paused)
{
//Time measurment
int64 e1 = getTickCount();
if (initialized){
if (!dataset->getNextFrame(frame))
break;
frame.copyTo(image);
}
if (!initialized && selectObjects)
{
//Initialize the tracker and add targets
if (!tracker->init(frame, boundingBox))
{
cout << "Tracker Init Error!!!";
return 0;
}
rectangle(frame, boundingBox, Scalar(0, 0, 255), 2, 1);
initialized = true;
}
else if (initialized)
{
//Update all targets
if (tracker->update(frame, boundingBox))
{
rectangle(frame, boundingBox, Scalar(0, 0, 255), 2, 1);
}
}
imshow("GOTURN Tracking", frame);
frameCounter++;
//Time measurment
int64 e2 = getTickCount();
double t1 = (e2 - e1) / getTickFrequency();
cout << frameCounter << "\tframe : " << t1 * 1000.0 << "ms" << endl;
}
char c = (char)waitKey(2);
if (c == 'q')
break;
if (c == 'p')
paused = !paused;
}
//Time measurment
int64 e4 = getTickCount();
double t2 = (e4 - e3) / getTickFrequency();
cout << "Average Time for Frame: " << t2 * 1000.0 / frameCounter << "ms" << endl;
cout << "Average FPS: " << 1.0 / t2*frameCounter << endl;
waitKey(0);
return 0;
}
int main(int argc,char **argv)
{
try
{
if (readArguments (argc,argv)==false) {
return 0;
}
//parse arguments
;
//read from camera or from file
if (TheInputVideo=="live") {
//Deepak changed the index from 0 to 1
// TheVideoCapturer.open(0);
TheVideoCapturer.open(1);
waitTime=10;
}
else TheVideoCapturer.open(TheInputVideo);
//check video is open
if (!TheVideoCapturer.isOpened()) {
cerr<<"Could not open video"<<endl;
return -1;
}
//read first image to get the dimensions
TheVideoCapturer>>TheInputImage;
//read camera parameters if passed
if (TheIntrinsicFile!="") {
TheCameraParameters.readFromXMLFile(TheIntrinsicFile);
TheCameraParameters.resize(TheInputImage.size());
}
//Configure other parameters
if (ThePyrDownLevel>0)
MDetector.pyrDown(ThePyrDownLevel);
//Create gui
cv::namedWindow("thres",1);
cv::namedWindow("in",1);
MDetector.getThresholdParams( ThresParam1,ThresParam2);
MDetector.setCornerRefinementMethod(MarkerDetector::LINES);
iThresParam1=ThresParam1;
iThresParam2=ThresParam2;
cv::createTrackbar("ThresParam1", "in",&iThresParam1, 13, cvTackBarEvents);
cv::createTrackbar("ThresParam2", "in",&iThresParam2, 13, cvTackBarEvents);
char key=0;
int index=0;
//capture until press ESC or until the end of the video
while ( key!=27 && TheVideoCapturer.grab())
{
TheVideoCapturer.retrieve( TheInputImage);
//copy image
index++; //number of images captured
double tick = (double)getTickCount();//for checking the speed
//Detection of markers in the image passed
MDetector.detect(TheInputImage,TheMarkers,TheCameraParameters,TheMarkerSize);
//chekc the speed by calculating the mean speed of all iterations
AvrgTime.first+=((double)getTickCount()-tick)/getTickFrequency();
AvrgTime.second++;
cout<<"Time detection="<<1000*AvrgTime.first/AvrgTime.second<<" milliseconds"<<endl;
//print marker info and draw the markers in image
TheInputImage.copyTo(TheInputImageCopy);
for (unsigned int i=0;i<TheMarkers.size();i++) {
cout<<TheMarkers[i]<<endl;
TheMarkers[i].draw(TheInputImageCopy,Scalar(0,0,255),1);
}
if (TheMarkers.size() >= 4){
try{
cv::Mat t0 = TheMarkers[0].Tvec;
cv::Mat t1 = TheMarkers[1].Tvec;
cv::Mat t2 = TheMarkers[2].Tvec;
cv::Mat t3 = TheMarkers[3].Tvec;
float x_len = (t0.at<float>(0,0) - t1.at<float>(0,0));
float y_len = (t0.at<float>(1,0) - t1.at<float>(1,0));
float z_len = (t0.at<float>(2,0) - t1.at<float>(2,0));
float distancesq_len = x_len*x_len+y_len*y_len+z_len*z_len;
float distance_len = sqrt(distancesq_len);
float x_width = (t1.at<float>(0,0) - t2.at<float>(0,0));
float y_width = (t1.at<float>(1,0) - t2.at<float>(1,0));
float z_width = (t1.at<float>(2,0) - t2.at<float>(2,0));
float distancesq_width = x_width*x_width+y_width*y_width+z_width*z_width;
float distance_width = sqrt(distancesq_width);
cout<<"Length:"<<distance_len<<endl;
cout<<"Width:"<<distance_width<<endl;
cout<<"Perimeter:"<<(2*distance_len + 2*distance_width)<<endl;
cout<<"Area:"<<distance_len*distance_width<<endl;
}
catch (std::exception& e){
cout<<e.what()<<endl;
}
}
//print other rectangles that contains no valid markers
// for (unsigned int i=0;i<MDetector.getCandidates().size();i++) {
// aruco::Marker m( MDetector.getCandidates()[i],999);
// m.draw(TheInputImageCopy,cv::Scalar(255,0,0));
// }
//draw a 3d cube in each marker if there is 3d info
if ( TheCameraParameters.isValid())
for (unsigned int i=0;i<TheMarkers.size();i++) {
CvDrawingUtils::draw3dCube(TheInputImageCopy,TheMarkers[i],TheCameraParameters);
CvDrawingUtils::draw3dAxis(TheInputImageCopy,TheMarkers[i],TheCameraParameters);
}
//DONE! Easy, right?
cout<<endl<<endl<<endl;
//show input with augmented information and the thresholded image
cv::imshow("in",TheInputImageCopy);
cv::imshow("thres",MDetector.getThresholdedImage());
key=cv::waitKey(waitTime);//wait for key to be pressed
}
} catch (std::exception &ex)
{
cout<<"Exception :"<<ex.what()<<endl;
}
}
vector<string> showCharSelection(Mat image, vector<Rect> charRegions, string state)
{
int curCharIdx = 0;
vector<string> humanInputs(charRegions.size());
for (int i = 0; i < charRegions.size(); i++)
humanInputs[i] = SPACE;
RegexRule regex_rule("", "[\\pL\\pN]", "", "");
int16_t waitkey = waitKey(50);
while (waitkey != ENTER_KEY_ONE && waitkey != ENTER_KEY_TWO && waitkey != ESCAPE_KEY)
{
Mat imgCopy(image.size(), image.type());
image.copyTo(imgCopy);
cvtColor(imgCopy, imgCopy, CV_GRAY2BGR);
rectangle(imgCopy, charRegions[curCharIdx], Scalar(0, 255, 0), 1);
imshow("Character selector", imgCopy);
if ((char) waitkey == LEFT_ARROW_KEY)
curCharIdx--;
else if ((char) waitkey == RIGHT_ARROW_KEY)
curCharIdx++;
else if (waitkey == SPACE_KEY)
{
humanInputs[curCharIdx] = " ";
curCharIdx++;
}
else if (waitkey > 0 && regex_rule.match(utf8chr(waitkey))) // Verify that it's an actual character
{
// Save the character to disk
humanInputs[curCharIdx] = utf8chr(waitkey);
curCharIdx++;
if (curCharIdx >= charRegions.size())
{
waitkey = ENTER_KEY_ONE;
break;
}
}
if (curCharIdx < 0)
curCharIdx = 0;
if (curCharIdx >= charRegions.size())
curCharIdx = charRegions.size() -1;
waitkey = waitKey(50);
}
if (waitkey == ENTER_KEY_ONE || waitkey == ENTER_KEY_TWO)
{
// Save all the inputs
for (int i = 0; i < charRegions.size(); i++)
{
if (humanInputs[i] != SPACE)
cout << "Tagged " << state << " char code: '" << humanInputs[i] << "' at char position: " << i << endl;
}
}
destroyWindow("Character selector");
return humanInputs;
}
int main(int argc,char **argv)
{
try
{
if ( readArguments (argc,argv)==false) return 0;
//parse arguments
TheBoardConfig.readFromFile(TheBoardConfigFile);
//read from camera or from file
if (TheInputVideo=="live") {
TheVideoCapturer.open(0);
waitTime=10;
}
else TheVideoCapturer.open(TheInputVideo);
//check video is open
if (!TheVideoCapturer.isOpened()) {
cerr<<"Could not open video"<<endl;
return -1;
}
//read first image to get the dimensions
TheVideoCapturer>>TheInputImage;
//Open outputvideo
if ( TheOutVideoFilePath!="")
VWriter.open(TheOutVideoFilePath,VideoWriter::fourcc('M','J','P','G'),15,TheInputImage.size());
//read camera parameters if passed
if (TheIntrinsicFile!="") {
TheCameraParameters.readFromXMLFile(TheIntrinsicFile);
TheCameraParameters.resize(TheInputImage.size());
}
//Create gui
cv::namedWindow("thres",1);
cv::namedWindow("in",1);
TheBoardDetector.setParams(TheBoardConfig,TheCameraParameters,TheMarkerSize);
TheBoardDetector.getMarkerDetector().getThresholdParams( ThresParam1,ThresParam2);
TheBoardDetector.getMarkerDetector().enableErosion(true);//for chessboards
iThresParam1=ThresParam1;
iThresParam2=ThresParam2;
cv::createTrackbar("ThresParam1", "in",&iThresParam1, 13, cvTackBarEvents);
cv::createTrackbar("ThresParam2", "in",&iThresParam2, 13, cvTackBarEvents);
char key=0;
int index=0;
//capture until press ESC or until the end of the video
while ( key!=27 && TheVideoCapturer.grab())
{
TheVideoCapturer.retrieve( TheInputImage);
TheInputImage.copyTo(TheInputImageCopy);
index++; //number of images captured
double tick = (double)getTickCount();//for checking the speed
//Detection of the board
float probDetect=TheBoardDetector.detect(TheInputImage);
//chekc the speed by calculating the mean speed of all iterations
AvrgTime.first+=((double)getTickCount()-tick)/getTickFrequency();
AvrgTime.second++;
cout<<"Time detection="<<1000*AvrgTime.first/AvrgTime.second<<" milliseconds"<<endl;
//print marker borders
for (unsigned int i=0;i<TheBoardDetector.getDetectedMarkers().size();i++)
TheBoardDetector.getDetectedMarkers()[i].draw(TheInputImageCopy,Scalar(0,0,255),1);
//print board
if (TheCameraParameters.isValid()) {
if ( probDetect>0.2) {
CvDrawingUtils::draw3dAxis( TheInputImageCopy,TheBoardDetector.getDetectedBoard(),TheCameraParameters);
//draw3dBoardCube( TheInputImageCopy,TheBoardDetected,TheIntriscCameraMatrix,TheDistorsionCameraParams);
}
}
//DONE! Easy, right?
//show input with augmented information and the thresholded image
cv::imshow("in",TheInputImageCopy);
cv::imshow("thres",TheBoardDetector.getMarkerDetector().getThresholdedImage());
//write to video if required
if ( TheOutVideoFilePath!="") {
//create a beautiful compiosed image showing the thresholded
//first create a small version of the thresholded image
cv::Mat smallThres;
cv::resize( TheBoardDetector.getMarkerDetector().getThresholdedImage(),smallThres,cvSize(TheInputImageCopy.cols/3,TheInputImageCopy.rows/3));
cv::Mat small3C;
cv::cvtColor(smallThres,small3C,COLOR_GRAY2BGR);
cv::Mat roi=TheInputImageCopy(cv::Rect(0,0,TheInputImageCopy.cols/3,TheInputImageCopy.rows/3));
small3C.copyTo(roi);
VWriter<<TheInputImageCopy;
// cv::imshow("TheInputImageCopy",TheInputImageCopy);
}
key=cv::waitKey(waitTime);//wait for key to be pressed
processKey(key);
}
} catch (std::exception &ex)
{
cout<<"Exception :"<<ex.what()<<endl;
}
}
// Takes a directory full of single char images, and plops them on a big tif files
// Also creates a box file so Tesseract can recognize it
int main( int argc, const char** argv )
{
string inDir;
int tile_width;
int tile_height;
TCLAP::CmdLine cmd("OpenAlpr OCR Training Prep Utility", ' ', "1.0.0");
TCLAP::UnlabeledValueArg<std::string> inputDirArg( "input_dir", "Folder containing individual character images", true, "", "input_dir_path" );
TCLAP::ValueArg<int> tileWidthArg("","tile_width","Width (in pixels) for each character tile. Default=50",false, 50 ,"tile_width_px");
TCLAP::ValueArg<int> tileHeightArg("","tile_height","Height (in pixels) for each character tile. Default=60",false, 60 ,"tile_height_px");
try
{
cmd.add( inputDirArg );
cmd.add( tileWidthArg );
cmd.add( tileHeightArg );
if (cmd.parse( argc, argv ) == false)
{
// Error occured while parsing. Exit now.
return 1;
}
inDir = inputDirArg.getValue();
tile_width = tileWidthArg.getValue();
tile_height = tileHeightArg.getValue();
}
catch (TCLAP::ArgException &e) // catch any exceptions
{
std::cerr << "error: " << e.error() << " for arg " << e.argId() << std::endl;
return 1;
}
if (DirectoryExists(inDir.c_str()) == false)
{
printf("Input dir does not exist\n");
return 1;
}
const int CHAR_PADDING_HORIZONTAL = 0;
const int CHAR_PADDING_VERTICAL = 0;
const int X_OFFSET = 5;
const int Y_OFFSET = 5;
const int PAGE_MARGIN_X = 70;
const int PAGE_MARGIN_Y = 70;
const int HORIZONTAL_RESOLUTION = 3500;
const int MAX_VERTICAL_RESOLUTION = 6000; // Maximum vertical size before chopping into additional pages.
const int TILE_WIDTH = tile_width;
const int TILE_HEIGHT = tile_height;
const int FIXED_CHAR_HEIGHT = 40; // RESIZE all characters to this height
vector<string> files = getFilesInDir(inDir.c_str());
sort( files.begin(), files.end(), stringCompare );
for (int i = 0; i< files.size(); i++)
{
if (hasEnding(files[i], ".png") || hasEnding(files[i], ".jpg"))
{
}
else
{
std::cerr << "Non-image file detected in this directory. This must be removed first" << std::endl;
return 1;
}
}
int tiles_per_row = ((float) (HORIZONTAL_RESOLUTION - (PAGE_MARGIN_X * 2))) / ((float) TILE_WIDTH) + 1;
int lines = files.size() / (tiles_per_row);
int vertical_resolution = ((lines + 1) * TILE_HEIGHT) + (PAGE_MARGIN_Y * 2) ;
cout << tiles_per_row << " : " << vertical_resolution << endl;
Mat bigTif = Mat::zeros(Size(HORIZONTAL_RESOLUTION, vertical_resolution), CV_8U);
bitwise_not(bigTif, bigTif);
stringstream boxFileOut;
for (int i = 0; i< files.size(); i++)
{
int col = i % tiles_per_row;
int line = i / tiles_per_row;
int xPos = (col * TILE_WIDTH) + PAGE_MARGIN_X;
int yPos = (line * TILE_HEIGHT) + PAGE_MARGIN_Y;
if (hasEnding(files[i], ".png") || hasEnding(files[i], ".jpg"))
{
string fullpath = inDir + "/" + files[i];
cout << "Processing file: " << (i + 1) << " of " << files.size() << " (" << files[i] << ")" << endl;
string::iterator utf_iterator = files[i].begin();
int cp = utf8::next(utf_iterator, files[i].end());
string charcode = utf8chr(cp);
Mat characterImg = imread(fullpath);
Mat charImgCopy = Mat::zeros(Size(150, 150), characterImg.type());
bitwise_not(charImgCopy, charImgCopy);
characterImg.copyTo(charImgCopy(Rect(X_OFFSET, Y_OFFSET, characterImg.cols, characterImg.rows)));
cvtColor(charImgCopy, charImgCopy, CV_BGR2GRAY);
bitwise_not(charImgCopy, charImgCopy);
vector<vector<Point> > contours;
//imshow("copy", charImgCopy);
findContours(charImgCopy, contours, CV_RETR_EXTERNAL, CV_CHAIN_APPROX_SIMPLE);
float minHeightPercent = 0.35;
int minHeight = (int) (((float) characterImg.rows) * minHeightPercent);
vector<Rect> tallEnoughRects;
for (int c = 0; c < contours.size(); c++)
{
Rect tmpRect = boundingRect(contours[c]);
if (tmpRect.height > minHeight)
tallEnoughRects.push_back( tmpRect );
}
int xMin = 9999999, xMax = 0, yMin = 9999999, yMax = 0;
// Combine all the "tall enough" rectangles into one super rectangle
for (int r = 0; r < tallEnoughRects.size(); r++)
{
if (tallEnoughRects[r].x < xMin)
xMin = tallEnoughRects[r].x;
if (tallEnoughRects[r].y < yMin)
yMin = tallEnoughRects[r].y;
if (tallEnoughRects[r].x + tallEnoughRects[r].width > xMax)
xMax = tallEnoughRects[r].x + tallEnoughRects[r].width;
if (tallEnoughRects[r].y + tallEnoughRects[r].height > yMax)
yMax = tallEnoughRects[r].y + tallEnoughRects[r].height;
}
Rect tallestRect(xMin, yMin, xMax - xMin, yMax - yMin);
//cout << tallestRect.x << ":" << tallestRect.y << " -- " << tallestRect.width << ":" << tallestRect.height << endl;
Rect cropRect(0, tallestRect.y - Y_OFFSET, tallestRect.width, tallestRect.height);
//cout << "Cropped: " << cropRect.x << ":" << cropRect.y << " -- " << cropRect.width << ":" << cropRect.height << endl;
Mat cropped(characterImg, cropRect);
cvtColor(cropped, cropped, CV_BGR2GRAY);
Rect destinationRect(xPos, yPos, tallestRect.width, tallestRect.height);
//cout << "1" << endl;
cropped.copyTo(bigTif(destinationRect));
int x1 = destinationRect.x - CHAR_PADDING_HORIZONTAL;
int y1 = (vertical_resolution - destinationRect.y - destinationRect.height) - CHAR_PADDING_VERTICAL;
int x2 = (destinationRect.x + destinationRect.width) + CHAR_PADDING_HORIZONTAL;
int y2 = (vertical_resolution - destinationRect.y) + CHAR_PADDING_VERTICAL;
//0 70 5602 85 5636 0
boxFileOut << charcode << " " << x1 << " " << y1 << " ";
boxFileOut << x2 << " " << y2 ;
boxFileOut << " 0" << endl;
//rectangle(characterImg, tallestRect, Scalar(0, 255, 0));
//imshow("characterImg", cropped);
waitKey(2);
}
}
imwrite("combined.tif", bigTif);
ofstream boxFile("combined.box", std::ios::out);
boxFile << boxFileOut.str();
}
//Called on each new image from the topic
void rgbCallback(const sensor_msgs::ImageConstPtr& msg_ptr) {
//Convert the image to OpenCV form
try {
ptr_rgb = cv_bridge::toCvCopy(msg_ptr, "bgr8");
ptr_rgb->image.copyTo(*rgb_image);
} catch (cv_bridge::Exception& e) {
ROS_ERROR("cv_bridge exception: %s", e.what());
}
waitKey(2);
//Create a test image
if(first)
{
imwrite("test.jpg", *rgb_image);
// cvSaveImage("test.jpg" ,cv_image);
first = false;
}
//try {
//ptr_hue = cv_bridge::toCvCopy(msg_ptr, "8UC1");
//imshow(ptr_ccs->image);
//ptr_hue->image.copyTo(*hue_image);
//} catch (cv_bridge::Exception& e) {
// ROS_ERROR("cv_bridge exception: %s", e.what());
//}
//Create a HSV image from the RGB image
cvtColor(*rgb_image, *hsv_image, CV_BGR2HSV);
//Split the three image channels into separate matrices
vector <Mat> planes;
split(*hsv_image, planes);
*hue_image = planes[0];
*sat_image = planes[1];
*int_image = planes[2];
//Upper and lower bounds on hue values
int rangeMin = (mean_color - window_size)%255;
int rangeMax = (mean_color + window_size)%255;
//int otherRangeMin = (other_mean_color - window_size)%255;
//int otherRangeMax = (other_mean_color + window_size)%255;
if(rangeMin > rangeMax){
int temp = rangeMax;
rangeMax = rangeMin;
//It looks like the should be =temp
rangeMin = rangeMax;
}
/*
if(otherRangeMin > otherRangeMax){
int temp = otherRangeMax;
otherRangeMax = otherRangeMin;
//It looks like the should be =temp
otherRangeMin = otherRangeMax;
}
*/
//Create a binary image from the threshold
inRange(*hue_image, Scalar((double)rangeMin),Scalar((double)rangeMax), *back_img);
*color_cc_image = Scalar(0);
//Apply blur
back_img->copyTo(*hue_image);
Size ksize = Size(2 * blurKernel + 1,2 * blurKernel + 1);
GaussianBlur(*back_img, *blurred_image, ksize, -1, -1);
//attempts at adaptive thresholding
Mat* sat_image; //input image -> satuation space
//adaptiveThreshold(*blurred_image, *temp_blurred_image, 255, ADAPTIVE_THRESH_GAUSSIAN_C, THRESH_BINARY, 3, .5);
//threshold(*blurred_image, *temp_blurred_image, THRESH_OTSU, 255, THRESH_BINARY);
threshold(*blurred_image, *temp_blurred_image, 110, 255, THRESH_BINARY);
convertScaleAbs(*temp_blurred_image, *back_img, 1, 0);
hue_image->copyTo(*copy_image);
if (display_image_){
imshow(color_topic, *back_img);
}
getConnectedComponents();
//Find Connected Components (this will populate the contour vector and perform ordering)
/*
findContours(*back_img, contours, hierarchy, CV_RETR_CCOMP, CV_CHAIN_APPROX_NONE, Point());
if(!contours.empty())
numCC = getThresholdConnectedComponents();
//I'm adding this
if (contours.empty()){
inRange(*hue_image, Scalar((double)otherRangeMin),Scalar((double)otherRangeMax), *back_img);
*color_cc_image = Scalar(0);
back_img->copyTo(*hue_image);
Size ksize = Size(2 * blurKernel + 1,2 * blurKernel + 1);
GaussianBlur(*back_img, *blurred_image, ksize, -1, -1);
Mat* sat_image;
threshold(*blurred_image, *temp_blurred_image, 110, 255, THRESH_BINARY);
convertScaleAbs(*temp_blurred_image, *back_img, 1, 0);
hue_image->copyTo(*copy_image);
findContours(*back_img, contours, hierarchy, CV_RETR_CCOMP, CV_CHAIN_APPROX_NONE, Point());
if(!contours.empty())
numCC = getThresholdConnectedComponents();
}
*/
//Draw connected components
for (int i = 0; (i < (int)comps.size()) && (comps[i].idx >= 0) && (comps[i].idx < (int)contours.size()); i++) {
Scalar color( (rand()&255), (rand()&255), (rand()&255) );
drawContours(*color_cc_image, contours, comps[i].idx, color, 3, 8, hierarchy,0, Point());
drawContours(*hue_image, contours, 0, comps[i].idx, 3, 8, hierarchy,0, Point());
}
getMoments();
blobTracker->updateKalmanFiltersConnectedComponents();
if (numCC > 0)
blobTracker->getFilteredBlobs(true);
else
blobTracker->getFilteredBlobs(false);
//cv::imshow("cam",hue_image);
//Draw Filtered Blobs
RotatedRect box;
Point pt;
//Image_msgs::FeatureMoments moments;
//moments.num = 0;
/*
for(int i=0; i < 1; i++) //replaced MAX_FEATURES with 1
{
FeatureBlob ftemp;
blobTracker->filters_[i].getFiltered(ftemp);
//cout << "valid? " << ftemp.getValid() << endl;
if(ftemp.getValid() && display_image_)
{
//cout << "Should be displaying something!" << endl;
Mat firstTemp, secondTemp;
ftemp.getValues(firstTemp, secondTemp);
pt.x = firstTemp.at<float>(0,0); pt.y = firstTemp.at<float>(1,0);
blobTracker->getBoxFromCov(pt, secondTemp, box);
if (box.size.width > 0 && box.size.height > 0 && box.size.width < width && box.size.height < height)
{
ellipse(*rgb_image, box, CV_RGB(0,0,255), 3, 8);
circle(*rgb_image, pt, 3, CV_RGB(255, 0, 0), -1, 8);
}
}
} */
pt.x = pos_x;
pt.y = pos_y;
circle(*rgb_image, pt, 3, CV_RGB(255, 0, 0), -1, 8);
//image_pub_.publish(moments);
if (display_image_) {
imshow("Color Blobs", *rgb_image);
imshow("Connected Components", *color_cc_image);
}
waitKey(2);
}
void pnpTask(const vector<char>& pointsMask, const Mat& objectPoints, const Mat& imagePoints,
const Parameters& params, vector<int>& inliers, Mat& rvec, Mat& tvec,
const Mat& rvecInit, const Mat& tvecInit, Mutex& resultsMutex)
{
Mat modelObjectPoints(1, MIN_POINTS_COUNT, CV_32FC3), modelImagePoints(1, MIN_POINTS_COUNT, CV_32FC2);
for (int i = 0, colIndex = 0; i < (int)pointsMask.size(); i++)
{
if (pointsMask[i])
{
Mat colModelImagePoints = modelImagePoints(Rect(colIndex, 0, 1, 1));
imagePoints.col(i).copyTo(colModelImagePoints);
Mat colModelObjectPoints = modelObjectPoints(Rect(colIndex, 0, 1, 1));
objectPoints.col(i).copyTo(colModelObjectPoints);
colIndex = colIndex+1;
}
}
//filter same 3d points, hang in solvePnP
double eps = 1e-10;
int num_same_points = 0;
for (int i = 0; i < MIN_POINTS_COUNT; i++)
for (int j = i + 1; j < MIN_POINTS_COUNT; j++)
{
if (norm(modelObjectPoints.at<Vec3f>(0, i) - modelObjectPoints.at<Vec3f>(0, j)) < eps)
num_same_points++;
}
if (num_same_points > 0)
return;
Mat localRvec, localTvec;
rvecInit.copyTo(localRvec);
tvecInit.copyTo(localTvec);
solvePnP(modelObjectPoints, modelImagePoints, params.camera.intrinsics, params.camera.distortion, localRvec, localTvec,
params.useExtrinsicGuess, params.flags);
vector<Point2f> projected_points;
projected_points.resize(objectPoints.cols);
projectPoints(objectPoints, localRvec, localTvec, params.camera.intrinsics, params.camera.distortion, projected_points);
Mat rotatedPoints;
project3dPoints(objectPoints, localRvec, localTvec, rotatedPoints);
vector<int> localInliers;
for (int i = 0; i < objectPoints.cols; i++)
{
Point2f p(imagePoints.at<Vec2f>(0, i)[0], imagePoints.at<Vec2f>(0, i)[1]);
if ((norm(p - projected_points[i]) < params.reprojectionError)
&& (rotatedPoints.at<Vec3f>(0, i)[2] > 0)) //hack
{
localInliers.push_back(i);
}
}
if (localInliers.size() > inliers.size())
{
resultsMutex.lock();
inliers.clear();
inliers.resize(localInliers.size());
memcpy(&inliers[0], &localInliers[0], sizeof(int) * localInliers.size());
localRvec.copyTo(rvec);
localTvec.copyTo(tvec);
resultsMutex.unlock();
}
}
// match histograms of 'src' to that of 'dst', according to both masks
void Preprocessor::histMatchRGB(cv::Mat& src, const cv::Mat& src_mask, const cv::Mat& dst, const cv::Mat& dst_mask)
{
#ifdef BTM_DEBUG
namedWindow("original source",CV_WINDOW_AUTOSIZE);
imshow("original source",src);
namedWindow("original query",CV_WINDOW_AUTOSIZE);
imshow("original query",dst);
#endif
vector<Mat> chns;
split(src,chns);
vector<Mat> chns1;
split(dst,chns1);
Mat src_hist = Mat::zeros(1,256,CV_64FC1);
Mat dst_hist = Mat::zeros(1,256,CV_64FC1);
Mat src_cdf = Mat::zeros(1,256,CV_64FC1);
Mat dst_cdf = Mat::zeros(1,256,CV_64FC1);
Mat Mv(1,256,CV_8UC1);
uchar* M = Mv.ptr<uchar>();
for(int i=0;i<3;i++) {
src_hist.setTo(0);
dst_hist.setTo(0);
src_cdf.setTo(0);
src_cdf.setTo(0);
double* _src_cdf = src_cdf.ptr<double>();
double* _dst_cdf = dst_cdf.ptr<double>();
double* _src_hist = src_hist.ptr<double>();
double* _dst_hist = dst_hist.ptr<double>();
do1ChnHist(chns[i],src_mask,_src_hist,_src_cdf);
do1ChnHist(chns1[i],dst_mask,_dst_hist,_dst_cdf);
uchar last = 0;
for(int j=0;j<src_cdf.cols;j++) {
double F1j = _src_cdf[j];
for(uchar k = last; k<dst_cdf.cols; k++) {
double F2k = _dst_cdf[k];
if(abs(F2k - F1j) < HISTMATCH_EPSILON || F2k > F1j) {
M[j] = k;
last = k;
break;
}
}
}
Mat lut(1,256,CV_8UC1,M);
LUT(chns[i],lut,chns[i]);
}
Mat res;
merge(chns,res);
#ifdef BTM_DEBUG
namedWindow("matched",CV_WINDOW_AUTOSIZE);
imshow("matched",res);
waitKey(0);
#endif
res.copyTo(src);
}
//This colors the segmentations
void floodFillPostprocess( Mat& img, const Scalar& colorDiff=Scalar::all(1) )
{
CV_Assert( !img.empty() );
RNG rng = theRNG();
Mat src_gray, canny_output, mask;
cvtColor( img, src_gray, CV_BGR2GRAY );
Canny( src_gray, canny_output, thresh, 2*thresh, 3 );
/*//If other line finders uncomment the switch below
Mat dst;
int scale = 1;
int delta = 0;
int ddepth = CV_16S;
int kernel_size = 3;
Laplacian( src_gray, dst, ddepth, kernel_size, scale, delta, BORDER_DEFAULT );
convertScaleAbs( dst, canny_output );
/*
switch (lineFinder)
{
case '0':
Canny( src_gray, canny_output, thresh, 2*thresh, 3 );
break;
// Other Line finding For mask ... Not useful but looks cool
// Laplacian
case '1':
Laplacian( src_gray, dst, ddepth, kernel_size, scale, delta, BORDER_DEFAULT );
convertScaleAbs( dst, canny_output );
break;
case '2':
//Sobel
/// Generate grad_x and grad_y
Mat grad_x, grad_y;
Mat abs_grad_x, abs_grad_y;
/// Gradient X
//Scharr( src_gray, grad_x, ddepth, 1, 0, scale, delta, BORDER_DEFAULT );
Sobel( src_gray, grad_x, ddepth, 1, 0, 3, scale, delta, BORDER_DEFAULT );
convertScaleAbs( grad_x, abs_grad_x );
/// Gradient Y
//Scharr( src_gray, grad_y, ddepth, 0, 1, scale, delta, BORDER_DEFAULT );
Sobel( src_gray, grad_y, ddepth, 0, 1, 3, scale, delta, BORDER_DEFAULT );
convertScaleAbs( grad_y, abs_grad_y );
/// Total Gradient (approximate)
addWeighted( abs_grad_x, 0.5, abs_grad_y, 0.5, 0, canny_output );
break;
}
*/
copyMakeBorder( canny_output, mask, 1, 1, 1, 1, BORDER_REPLICATE, 1 );
int numregions = 0;
vector<Rect> regions;
vector<Mat> Masks;
Rect region;
//Mat temp2;
//original.copyTo(temp2);
for( int y = 0; y < img.rows; y++ )
{
for( int x = 0; x < img.cols; x++ )
{
if( mask.at<uchar>(y+1, x+1) == 0 )
{
Scalar newVal( rng(256), rng(256), rng(256) );
floodFill( img, mask, Point(x,y), newVal, ®ion, colorDiff, colorDiff, 4 ); //FLOODFILL_MASK_ONLY +
if ((region.height * region.width > 250))
{
if(rects) rectangle( img, Point(region.x,region.y), Point(region.x + region.width, region.y + region.height), Scalar( rng.uniform(0, 255), rng.uniform(0,255), rng.uniform(0,255) ), 2, 8, 0 );
regions.push_back(region);
Masks.push_back(mask);
numregions++;
}
}
}
}
//cout << "Number of regions: " << numregions << "\tSize of Region Vector: " << regions.size() << endl;
//imshow( "meanshift", img );
//imshow( "Regions ROIs", temp2);
// createTrackbar( " Canny thresh:", "Mask", &thresh, max_thresh, meanShiftSegmentation );
if(display)
{
//mask = Scalar::all(0);
//imshow("mask", mask);
Mat temp2;
original.copyTo( temp2, canny_output);
//imshow("Mask", temp2);
//imshow("Mask After", mask);
vector<Rect>::iterator it;
string filename;
vector<Mat>::iterator itt;
itt = Masks.begin();
it = regions.begin();
//just to show first ROI
Mat temp;
imshow("ROI", img( *it ));
original.copyTo(temp);
cout << "Region[" << numregions << "] Values (x,y,row,cols): " << it->x << "\t\t" << it->y << "\t\t" << it->height << "\t\t" << it->width << endl;
rectangle( temp, Point(it->x,it->y), Point(it->x + it->width, it->y + it->height), Scalar( rng.uniform(0, 255), rng.uniform(0,255), rng.uniform(0,255) ), 2, 8, 0 );
imshow( "meanshift", temp );
moveWindow("meanshift", 40,40);
moveWindow("ROI",700,40);
for ( ; it+1 < regions.end() ; )
{
switch ( (char)waitKey(10) )
{
case 27:
it = regions.end();
running = false;
break;
case 'q': case 'Q':
it = regions.end();
display = false;
cvDestroyWindow("meanshift");
cvDestroyWindow("ROI");
break;
case 'i': case 'I':
it++;
itt++;
imshow("ROI", img( *it ));
original.copyTo(temp);
cout << "Region[" << numregions << "] Values (x,y,row,cols): " << it->x << "\t\t" << it->y << "\t\t" << it->height << "\t\t" << it->width << endl;
rectangle( temp, Point(it->x,it->y), Point(it->x + it->width, it->y + it->height), Scalar( rng.uniform(0, 255), rng.uniform(0,255), rng.uniform(0,255) ), 2, 8, 0 );
imshow( "meanshift", temp );
//imshow( "Masks", *itt );
break;
case 's': case 'S':
cout << "Name of New file: " << endl;
cin >> filename;
filename = "./data/imageDatabase/" + filename + ".png";
if (imwrite( filename, original(*it)) )
cout << "File: \"" << filename << "\" is saved!" << endl;
else cout << "File Save Error" << endl;
break;
case 'o': case 'O':
string name;
ObjRec.matchObsvToDB( original(*it), name );
break;
}
}
}
}
int main(int argc, char *argv[])
{
#ifdef WIN32
_CrtSetDbgFlag ( _CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF ); // dump leaks at return
//_CrtSetBreakAlloc(287);
#endif
string verboseLevelConsole;
string verboseLevelImages;
bool useFileList = false;
bool useImgs = false;
bool useDirectory = false;
bool useGroundtruth = false;
vector<path> inputPaths;
path inputFilelist;
path inputDirectory;
vector<path> inputFilenames;
path configFilename;
shared_ptr<ImageSource> imageSource;
path outputPicsDir; // TODO: ImageLogger vs ImageSinks? (see AdaptiveTracking.cpp)
path groundtruthDir; // TODO: Make more dynamic wrt landmark format. a) What about the loading-flags (1_Per_Folder etc) we have? b) Expose those flags to cmdline? c) Make a LmSourceLoader and he knows about a LM_TYPE (each corresponds to a Parser/Loader class?)
// TODO Also, sometimes we might have the face-box annotated but not LMs, sometimes only LMs and no Facebox.
string groundtruthType;
try {
po::options_description desc("Allowed options");
desc.add_options()
("help,h",
"produce help message")
("verbose,v", po::value<string>(&verboseLevelConsole)->implicit_value("DEBUG")->default_value("INFO","show messages with INFO loglevel or below."),
"specify the verbosity of the console output: PANIC, ERROR, WARN, INFO, DEBUG or TRACE")
("verbose-images,w", po::value<string>(&verboseLevelImages)->implicit_value("INTERMEDIATE")->default_value("FINAL","write images with FINAL loglevel or below."),
"specify the verbosity of the image output: FINAL, INTERMEDIATE, INFO, DEBUG or TRACE")
("config,c", po::value<path>(&configFilename)->required(),
"path to a config (.cfg) file")
("input,i", po::value<vector<path>>(&inputPaths)->required(),
"input from one or more files, a directory, or a .lst/.txt-file containing a list of images")
("groundtruth,g", po::value<path>(&groundtruthDir),
"load ground truth landmarks from the given folder along with the images and output statistics of the detection results")
("groundtruth-type,t", po::value<string>(&groundtruthType),
"specify the type of landmarks to load: lst, ibug")
("output-dir,o", po::value<path>(&outputPicsDir)->default_value("."),
"output directory for the result images")
;
po::positional_options_description p;
p.add("input", -1);
po::variables_map vm;
po::store(po::command_line_parser(argc, argv).options(desc).positional(p).run(), vm);
po::notify(vm);
if (vm.count("help")) {
cout << "Usage: ffpDetectApp [options]\n";
cout << desc;
return EXIT_SUCCESS;
}
if (vm.count("groundtruth")) {
useGroundtruth = true;
if (!vm.count("groundtruth-type")) {
cout << "You have specified to use ground truth. Please also specify the type of the landmarks to load via --groundtruth-type or -t." << endl;
return EXIT_SUCCESS;
}
}
} catch(std::exception& e) {
cout << e.what() << endl;
return EXIT_FAILURE;
}
loglevel logLevel;
if(boost::iequals(verboseLevelConsole, "PANIC")) logLevel = loglevel::PANIC;
else if(boost::iequals(verboseLevelConsole, "ERROR")) logLevel = loglevel::ERROR;
else if(boost::iequals(verboseLevelConsole, "WARN")) logLevel = loglevel::WARN;
else if(boost::iequals(verboseLevelConsole, "INFO")) logLevel = loglevel::INFO;
else if(boost::iequals(verboseLevelConsole, "DEBUG")) logLevel = loglevel::DEBUG;
else if(boost::iequals(verboseLevelConsole, "TRACE")) logLevel = loglevel::TRACE;
else {
cout << "Error: Invalid loglevel." << endl;
return EXIT_FAILURE;
}
imagelogging::loglevel imageLogLevel;
if(boost::iequals(verboseLevelImages, "FINAL")) imageLogLevel = imagelogging::loglevel::FINAL;
else if(boost::iequals(verboseLevelImages, "INTERMEDIATE")) imageLogLevel = imagelogging::loglevel::INTERMEDIATE;
else if(boost::iequals(verboseLevelImages, "INFO")) imageLogLevel = imagelogging::loglevel::INFO;
else if(boost::iequals(verboseLevelImages, "DEBUG")) imageLogLevel = imagelogging::loglevel::DEBUG;
else if(boost::iequals(verboseLevelImages, "TRACE")) imageLogLevel = imagelogging::loglevel::TRACE;
else {
cout << "Error: Invalid image loglevel." << endl;
return EXIT_FAILURE;
}
Loggers->getLogger("classification").addAppender(make_shared<logging::ConsoleAppender>(logLevel));
Loggers->getLogger("imageio").addAppender(make_shared<logging::ConsoleAppender>(logLevel));
Loggers->getLogger("imageprocessing").addAppender(make_shared<logging::ConsoleAppender>(logLevel));
Loggers->getLogger("detection").addAppender(make_shared<logging::ConsoleAppender>(logLevel));
Loggers->getLogger("shapemodels").addAppender(make_shared<logging::ConsoleAppender>(logLevel));
Loggers->getLogger("ffpDetectApp").addAppender(make_shared<logging::ConsoleAppender>(logLevel));
Logger appLogger = Loggers->getLogger("ffpDetectApp");
appLogger.debug("Verbose level for console output: " + logging::loglevelToString(logLevel));
appLogger.debug("Verbose level for image output: " + imagelogging::loglevelToString(imageLogLevel));
appLogger.debug("Using config: " + configFilename.string());
appLogger.debug("Using output directory: " + outputPicsDir.string());
if(outputPicsDir == ".") {
appLogger.info("Writing output images into current directory.");
}
ImageLoggers->getLogger("detection").addAppender(make_shared<imagelogging::ImageFileWriter>(imageLogLevel, outputPicsDir));
ImageLoggers->getLogger("app").addAppender(make_shared<imagelogging::ImageFileWriter>(imageLogLevel, outputPicsDir / "final"));
if (inputPaths.size() > 1) {
// We assume the user has given several, valid images
useImgs = true;
inputFilenames = inputPaths;
} else if (inputPaths.size() == 1) {
// We assume the user has given either an image, directory, or a .lst-file
if (inputPaths[0].extension().string() == ".lst" || inputPaths[0].extension().string() == ".txt") { // check for .lst or .txt first
useFileList = true;
inputFilelist = inputPaths.front();
} else if (boost::filesystem::is_directory(inputPaths[0])) { // check if it's a directory
useDirectory = true;
inputDirectory = inputPaths.front();
} else { // it must be an image
useImgs = true;
inputFilenames = inputPaths;
}
} else {
appLogger.error("Please either specify one or several files, a directory, or a .lst-file containing a list of images to run the program!");
return EXIT_FAILURE;
}
if (useFileList==true) {
appLogger.info("Using file-list as input: " + inputFilelist.string());
shared_ptr<ImageSource> fileListImgSrc; // TODO VS2013 change to unique_ptr, rest below also
try {
fileListImgSrc = make_shared<FileListImageSource>(inputFilelist.string(), "C:\\Users\\Patrik\\Documents\\GitHub\\data\\fddb\\originalPics\\", ".jpg");
} catch(const std::runtime_error& e) {
appLogger.error(e.what());
return EXIT_FAILURE;
}
imageSource = fileListImgSrc;
}
if (useImgs==true) {
//imageSource = make_shared<FileImageSource>(inputFilenames);
//imageSource = make_shared<RepeatingFileImageSource>("C:\\Users\\Patrik\\GitHub\\data\\firstrun\\ws_8.png");
appLogger.info("Using input images: ");
vector<string> inputFilenamesStrings; // Hack until we use vector<path> (?)
for (const auto& fn : inputFilenames) {
appLogger.info(fn.string());
inputFilenamesStrings.push_back(fn.string());
}
shared_ptr<ImageSource> fileImgSrc;
try {
fileImgSrc = make_shared<FileImageSource>(inputFilenamesStrings);
} catch(const std::runtime_error& e) {
appLogger.error(e.what());
return EXIT_FAILURE;
}
imageSource = fileImgSrc;
}
if (useDirectory==true) {
appLogger.info("Using input images from directory: " + inputDirectory.string());
try {
imageSource = make_shared<DirectoryImageSource>(inputDirectory.string());
} catch(const std::runtime_error& e) {
appLogger.error(e.what());
return EXIT_FAILURE;
}
}
// Load the ground truth
// Either a) use if/else for imageSource or labeledImageSource, or b) use an EmptyLandmarkSoure
shared_ptr<LabeledImageSource> labeledImageSource;
shared_ptr<NamedLandmarkSource> landmarkSource;
if (useGroundtruth) {
vector<path> groundtruthDirs; groundtruthDirs.push_back(groundtruthDir); // Todo: Make cmdline use a vector<path>
shared_ptr<LandmarkFormatParser> landmarkFormatParser;
if(boost::iequals(groundtruthType, "lst")) {
landmarkFormatParser = make_shared<LstLandmarkFormatParser>();
landmarkSource = make_shared<DefaultNamedLandmarkSource>(LandmarkFileGatherer::gather(imageSource, string(), GatherMethod::SEPARATE_FILES, groundtruthDirs), landmarkFormatParser);
} else if(boost::iequals(groundtruthType, "ibug")) {
landmarkFormatParser = make_shared<IbugLandmarkFormatParser>();
landmarkSource = make_shared<DefaultNamedLandmarkSource>(LandmarkFileGatherer::gather(imageSource, ".pts", GatherMethod::ONE_FILE_PER_IMAGE_SAME_DIR, groundtruthDirs), landmarkFormatParser);
} else {
cout << "Error: Invalid ground truth type." << endl;
return EXIT_FAILURE;
}
} else {
landmarkSource = make_shared<EmptyLandmarkSource>();
}
labeledImageSource = make_shared<NamedLabeledImageSource>(imageSource, landmarkSource);
ptree pt;
try {
read_info(configFilename.string(), pt);
} catch(const boost::property_tree::ptree_error& error) {
appLogger.error(error.what());
return EXIT_FAILURE;
}
string morphableModelFile;
string morphableModelVertexMappingFile;
shapemodels::MorphableModel mm;
try {
ptree ptFeaturePointValidation = pt.get_child("featurePointValidation");
morphableModelFile = ptFeaturePointValidation.get<string>("morphableModel");
morphableModelVertexMappingFile = ptFeaturePointValidation.get<string>("morphableModelVertexMapping");
mm = shapemodels::MorphableModel::loadScmModel("C:\\Users\\Patrik\\Documents\\GitHub\\bsl_model_first\\SurreyLowResGuosheng\\NON3448\\ShpVtxModelBin_NON3448.scm", "C:\\Users\\Patrik\\Documents\\GitHub\\featurePoints_SurreyScm.txt");
} catch (const boost::property_tree::ptree_error& error) {
appLogger.error(error.what());
return EXIT_FAILURE;
}
FddbLandmarkSink landmarkSink("annotatedList.txt");
landmarkSink.open(outputPicsDir.string() + "/final/" + "detectedFaces.txt");
// ---
boost::interprocess::managed_shared_memory managed_shm(boost::interprocess::open_only, "CameraInputMem");
//catch (boost::interprocess::interprocess_exception& e)
typedef boost::interprocess::allocator<uchar, boost::interprocess::managed_shared_memory::segment_manager> CharAllocator;
typedef boost::interprocess::vector<uchar, CharAllocator> IpcVec;
const CharAllocator alloc_inst(managed_shm.get_segment_manager());
typedef boost::interprocess::allocator<float, boost::interprocess::managed_shared_memory::segment_manager> FloatAllocator;
typedef boost::interprocess::vector<float, FloatAllocator> FloatVec;
vector<float> landmarksX;
vector<float> landmarksY;
shapemodels::CameraEstimation cameraEstimation(mm);
vector<imageio::ModelLandmark> landmarks;
cv::namedWindow("win");
while (true) {
std::pair<IpcVec*, std::size_t> s = managed_shm.find<IpcVec>("EncodedImage"); // check for s.second != 1?
vector<uchar> vimg;
for (const auto& e : *s.first) {
vimg.push_back(e);
}
cv::Mat img2 = cv::imdecode(vimg, -1); // opt.: 3rd: a *Mat for no reallocation every frame
if (img2.rows <= 0 || img2.cols <= 0) {
continue;
}
std::pair<FloatVec*, std::size_t> sX = managed_shm.find<FloatVec>("LandmarksX"); // check for s.second != 1?
std::pair<FloatVec*, std::size_t> sY = managed_shm.find<FloatVec>("LandmarksY"); // check for s.second != 1?
landmarksX.clear();
landmarksY.clear();
if (sX.second == 1 && sY.second == 1) {
for (const auto& lm : *sX.first) {
landmarksX.push_back(lm);
}
for (const auto& lm : *sY.first) {
landmarksY.push_back(lm);
}
for (int i = 0; i < landmarksX.size(); ++i) {
cv::circle(img2, cv::Point((int)landmarksX[i], (int)landmarksY[i]), 1, cv::Scalar(0,255,0), -1);
}
landmarks.clear();
landmarks.emplace_back(imageio::ModelLandmark("right.eye.corner_outer", landmarksX[19], landmarksY[19]));
landmarks.emplace_back(imageio::ModelLandmark("right.eye.corner_inner", landmarksX[22], landmarksY[22]));
landmarks.emplace_back(imageio::ModelLandmark("left.eye.corner_outer", landmarksX[28], landmarksY[28]));
landmarks.emplace_back(imageio::ModelLandmark("left.eye.corner_inner", landmarksX[25], landmarksY[25]));
landmarks.emplace_back(imageio::ModelLandmark("center.nose.tip", landmarksX[13], landmarksY[13]));
landmarks.emplace_back(imageio::ModelLandmark("right.lips.corner", landmarksX[31], landmarksY[31]));
landmarks.emplace_back(imageio::ModelLandmark("left.lips.corner", landmarksX[37], landmarksY[37]));
int max_d = std::max(img2.rows, img2.cols); // should be the focal length? (don't forget the aspect ratio!). TODO Read in Hartley-Zisserman what this is
//int max_d = 700;
Mat camMatrix = (cv::Mat_<double>(3,3) << max_d, 0, img2.cols/2.0,
0, max_d, img2.rows/2.0,
0, 0, 1.0);
pair<Mat, Mat> rotTransRodr = cameraEstimation.estimate(landmarks, camMatrix);
Mat rvec = rotTransRodr.first;
Mat tvec = rotTransRodr.second;
Mat rotation_matrix(3, 3, CV_64FC1);
cv::Rodrigues(rvec, rotation_matrix);
rotation_matrix.convertTo(rotation_matrix, CV_32FC1);
Mat translation_vector = tvec;
translation_vector.convertTo(translation_vector, CV_32FC1);
camMatrix.convertTo(camMatrix, CV_32FC1);
for (const auto& p : landmarks) {
cv::rectangle(img2, cv::Point(cvRound(p.getX()-2.0f), cvRound(p.getY()-2.0f)), cv::Point(cvRound(p.getX()+2.0f), cvRound(p.getY()+2.0f)), cv::Scalar(255, 0, 0));
}
//vector<Point2f> projectedPoints;
//projectPoints(modelPoints, rvec, tvec, camMatrix, vector<float>(), projectedPoints); // same result as below
Mat extrinsicCameraMatrix = Mat::zeros(4, 4, CV_32FC1);
Mat extrRot = extrinsicCameraMatrix(cv::Range(0, 3), cv::Range(0, 3));
rotation_matrix.copyTo(extrRot);
Mat extrTrans = extrinsicCameraMatrix(cv::Range(0, 3), cv::Range(3, 4));
translation_vector.copyTo(extrTrans);
extrinsicCameraMatrix.at<float>(3, 3) = 1;
Mat intrinsicCameraMatrix = Mat::zeros(4, 4, CV_32FC1);
Mat intrinsicCameraMatrixMain = intrinsicCameraMatrix(cv::Range(0, 3), cv::Range(0, 3));
camMatrix.copyTo(intrinsicCameraMatrixMain);
intrinsicCameraMatrix.at<float>(3, 3) = 1;
vector<Point3f> points3d;
for (const auto& landmark : landmarks) {
points3d.emplace_back(mm.getShapeModel().getMeanAtPoint(landmark.getName()));
}
for (const auto& v : points3d) {
Mat vertex(v);
Mat vertex_homo = Mat::ones(4, 1, CV_32FC1);
Mat vertex_homo_coords = vertex_homo(cv::Range(0, 3), cv::Range(0, 1));
vertex.copyTo(vertex_homo_coords);
Mat v2 = rotation_matrix * vertex;
Mat v3 = v2 + translation_vector;
Mat v3_mat = extrinsicCameraMatrix * vertex_homo;
Mat v4 = camMatrix * v3;
Mat v4_mat = intrinsicCameraMatrix * v3_mat;
Point3f v4p(v4);
Point2f v4p2d(v4p.x/v4p.z, v4p.y/v4p.z); // if != 0
Point3f v4p_homo(v4_mat(cv::Range(0, 3), cv::Range(0, 1)));
Point2f v4p2d_homo(v4p_homo.x/v4p_homo.z, v4p_homo.y/v4p_homo.z); // if != 0
cv::rectangle(img2, cv::Point(cvRound(v4p2d_homo.x-2.0f), cvRound(v4p2d_homo.y-2.0f)), cv::Point(cvRound(v4p2d_homo.x+2.0f), cvRound(v4p2d_homo.y+2.0f)), cv::Scalar(255, 0, 0));
}
std::shared_ptr<render::Mesh> meshToDraw = std::make_shared<render::Mesh>(mm.getMean());
const float aspect = (float)img2.cols/(float)img2.rows; // 640/480
render::Camera camera(Vec3f(0.0f, 0.0f, 0.0f), /*horizontalAngle*/0.0f*(CV_PI/180.0f), /*verticalAngle*/0.0f*(CV_PI/180.0f), render::Frustum(-1.0f*aspect, 1.0f*aspect, -1.0f, 1.0f, /*zNear*/-0.1f, /*zFar*/-100.0f));
render::SoftwareRenderer r(img2.cols, img2.rows, camera); // 640, 480
//r.setModelTransform(render::utils::MatrixUtils::createScalingMatrix(1.0f/140.0f, 1.0f/140.0f, 1.0f/140.0f));
r.setObjectToScreenTransform(intrinsicCameraMatrix * extrinsicCameraMatrix);
r.draw(meshToDraw, nullptr);
Mat buff = r.getImage();
Mat buffWithoutAlpha;
//buff.convertTo(buffWithoutAlpha, CV_BGRA2BGR);
cvtColor(buff, buffWithoutAlpha, cv::COLOR_BGRA2BGR);
Mat weighted = img2.clone(); // get the right size
cv::addWeighted(img2, 0.7, buffWithoutAlpha, 0.3, 0.0, weighted);
//return std::make_pair(translation_vector, rotation_matrix);
img2 = weighted;
}
cv::imshow("win", img2);
cv::waitKey(5);
}
// ---
std::chrono::time_point<std::chrono::system_clock> start, end;
Mat img;
while(labeledImageSource->next()) {
start = std::chrono::system_clock::now();
appLogger.info("Starting to process " + labeledImageSource->getName().string());
img = labeledImageSource->getImage();
end = std::chrono::system_clock::now();
int elapsed_mseconds = std::chrono::duration_cast<std::chrono::milliseconds>(end-start).count();
appLogger.debug("Finished face-detection. Elapsed time: " + lexical_cast<string>(elapsed_mseconds) + "ms.\n");
// Log the image with the max positive of every feature
ImageLogger appImageLogger = ImageLoggers->getLogger("app");
appImageLogger.setCurrentImageName(labeledImageSource->getName().stem().string());
appImageLogger.intermediate(img, doNothing, "AllFfpMaxPos");
LandmarkCollection groundtruth = labeledImageSource->getLandmarks();
end = std::chrono::system_clock::now();
elapsed_mseconds = std::chrono::duration_cast<std::chrono::milliseconds>(end-start).count();
appLogger.info("Finished processing " + labeledImageSource->getName().string() + ". Elapsed time: " + lexical_cast<string>(elapsed_mseconds) + "ms.\n");
//landmarkSink.add(labeledImageSource->getName().string(), faces, scores);
}
landmarkSink.close();
appLogger.info("Finished!");
return 0;
}
//////////////////////////////////////////////////////////////////////////
// do convolution in Frequency domain
// @return final image after convolution
//////////////////////////////////////////////////////////////////////////
bool cvFFTConvolution(const Mat& channel, const Mat& kernel, Mat& conv)
{
//create complex image and kernel
//////////////////////////////////////////////////////////////////////////
Mat complexImg(channel.rows, channel.cols, CV_32FC2);
vector<Mat> vec_mat(2);
vec_mat[0] = channel.clone();
vec_mat[1] = channel.clone();
vec_mat[1].setTo(0);
merge(vec_mat, complexImg);
//////////////////////////////////////////////////////////////////////////
Mat complexKernel(kernel.rows, kernel.cols, CV_32FC2);
kernel.copyTo(vec_mat[0]);
kernel.copyTo(vec_mat[1]);
vec_mat[1].setTo(0);
vec_mat[1] = kernel.clone();
merge(vec_mat, complexKernel);
//////////////////////////////////////////////////////////////////////////
/*int dft_M = getOptimalDFTSize(channel.rows*2-1);
int dft_N = getOptimalDFTSize(channel.cols*2-1);*/
Mat dft_A(channel.rows, channel.cols, CV_32FC2);
dft_A.setTo(0);
Mat dft_B(kernel.rows, kernel.cols, CV_32FC2);
dft_B.setTo(0);
//////////////////////////////////////////////////////////////////////////
// do dft for image
//////////////////////////////////////////////////////////////////////////
Mat tmp = dft_A(Rect(0, 0, channel.cols, channel.rows));
complexImg.copyTo(tmp);
dft(dft_A, dft_A, CV_DXT_FORWARD);
//////////////////////////////////////////////////////////////////////////
// do dft for kernel
//////////////////////////////////////////////////////////////////////////
tmp = dft_B(Rect(0, 0, kernel.cols, kernel.rows));
complexKernel.copyTo(tmp);
//do dft
dft(dft_B, dft_B, CV_DXT_FORWARD);
//shift kernel to center
Mat dft_BB = dft_B.clone();
ShiftDFT(dft_B, dft_BB);
dft_BB.copyTo(dft_B);
//////////////////////////////////////////////////////////////////////////
// do convolution
//////////////////////////////////////////////////////////////////////////
mulSpectrums(dft_A, dft_B, dft_A, CV_DXT_MUL_CONJ);
//do inverse dft
dft(dft_A, dft_A, CV_DXT_INV_SCALE, channel.rows);
split(dft_A, vec_mat);
pow(vec_mat[0], 2, vec_mat[0]);
pow(vec_mat[1], 2, vec_mat[1]);
vec_mat[0] += vec_mat[1];
pow(vec_mat[0], 2, vec_mat[0]);
//copy back
vec_mat[0].copyTo(conv);
return true;
}
std::vector<KeyPoint> findPaper (Mat frame, double avgBright) {
Mat colors[3];
Mat colored;
Mat copy;
frame.copyTo(colored);
cvtColor(colored,colored,CV_BGR2HSV);
split(frame,colors);
copy = frame;
cvtColor(frame,frame,CV_BGR2GRAY);
GaussianBlur(frame,frame,Size(3,3),0);
for(int parameter = 10; parameter > 0; parameter--) {
double offset = 1;
std:vector<KeyPoint> points;
std::vector<KeyPoint> allPoints;
FAST(frame,allPoints,parameter);
do {
points = std::vector<KeyPoint>(allPoints);
std::vector<int> keep(points.size());
for (std::vector<KeyPoint>::iterator it = points.begin(); it != points.end(); it++) {
KeyPoint pt = *it;
Vec3b at = colored.at<Vec3b>(pt.pt);
int numRed = 0;
int numWhite = 0;
double dr[8] = { 0, -1,-1, -1, 0, 1, 1, 1};
double dc[8] = { 1, 1, 0, -1,-1,-1, 0, 1};
std::vector<int> deltaRow (dr, dr+sizeof(dr)/sizeof(int));
std::vector<int> deltaCol (dc, dc+sizeof(dc)/sizeof(int));
for(unsigned int i = 0; i < deltaRow.size(); i++) {
KeyPoint delta = pt;
int rowAdd = offset;
int colAdd = offset;
delta.pt.x = pt.pt.x + (int) (deltaRow[i] * rowAdd);
delta.pt.y = pt.pt.y + (int) (deltaCol[i] * colAdd);
if(delta.pt.x < 0 || delta.pt.y < 0 || delta.pt.x >= frame.cols || delta.pt.y >= frame.rows) {
continue;
}
int colorCode = 0;
Vec3b neighbor = colored.at<Vec3b>(delta.pt);
int count = 0;
for(int i = 0; i < 3; i++) {
if((int)neighbor[i] == 255){count++;}
}
if(count >= 2){
continue;
}
if((neighbor[0] > LOW_RED || neighbor[0] < HIGH_RED) && neighbor[1] > 73 && neighbor[2] > 50) {
numRed++;
colorCode = 1;
} else if( neighbor[2] > avgBright) {
numWhite++;
colorCode = 2;
}
if(colorCode == 0) {
colored.at<Vec3b>(delta.pt)[0]= 3;
colored.at<Vec3b>(delta.pt)[1] = 100;
colored.at<Vec3b>(delta.pt)[2] = 50;
} else if (colorCode == 1) {
colored.at<Vec3b>(delta.pt)[0]= 100;
colored.at<Vec3b>(delta.pt)[1] = 255;
colored.at<Vec3b>(delta.pt)[2] = 255;
} else if (colorCode == 2) {
colored.at<Vec3b>(delta.pt)[0]= 10;
colored.at<Vec3b>(delta.pt)[1] = 255;
colored.at<Vec3b>(delta.pt)[2] = 255;
}
}
if(numRed != 5 ||( numWhite != 3 )) {
keep[it - points.begin()] = -1;
}
}
int size = points.size();
int trueIndex = 0;
int loopIndex = 0;
while(trueIndex < size) {
if(keep[trueIndex] == -1) {
points.erase(points.begin()+loopIndex);
trueIndex++;
} else {
loopIndex++;
trueIndex++;
}
}
offset++;
} while(points.size() != 4 && offset < 20);
if(points.size() == 4){return points;}
}
}
//----------------------------------------------------------------------------------------------------------
void RunTracking::trackFilteredObject(TrackedPiece &piece, Mat &cameraFeed, Mat &threshold_image){
vector <TrackedPiece> pieces;
Mat temp;
threshold_image.copyTo(temp);
//these two vectors needed for output of findContours
vector< vector<Point> > contours;
vector<Vec4i> hierarchy;
//find contours of filtered image using openCV findContours function
findContours(temp,contours,hierarchy,CV_RETR_CCOMP,CV_CHAIN_APPROX_SIMPLE );
//use moments method to find our filtered object
bool objectFound = false;
if (hierarchy.size() > 0) {
int numObjects = hierarchy.size();
// cout << "Num objects: " << numObjects << endl;
// cout << "Max Num objects: " << MAX_NUM_OBJECTS << endl;
// threshholed to calculate movement
const int thresh = 40;
//saves max area of each contour detected so only the largest one will be tracked
double maxArea = 0;
// temporary piece for contours found
TrackedPiece tmp;
//if number of objects greater than MAX_NUM_OBJECTS we have a noisy filter
if(numObjects < MAX_NUM_OBJECTS){
// for each object (contour) detected
for (int index = 0; index >= 0; index = hierarchy[index][0]) {
// get the moment of the contour
Moments moment = moments((cv::Mat)contours[index]);
// get the area from the moment
double area = moment.m00;
// cout << "Area " << index << " is: " << area << endl;
// if the area is less than MIN_OBJECT_AREA then it is probably just noise
// it must also be large than the max area found so far since we only want the largest area.
if(area > MIN_OBJECT_AREA && area > maxArea){
// set new max area
maxArea = area;
// Clear previous objects found so only one (the biggest) is detected
pieces.clear();
int xPos = moment.m10/area;
int yPos = moment.m01/area;
tmp.setXPos(xPos);
tmp.setYPos(yPos);
tmp.setName(piece.getName());
tmp.setColor(piece.getColor());
//cout << piece.getName() << ": x: " << xPos << " y: " << yPos << endl;
//cout << "LastPos: x: " << piece.getLastxPos() << " y: " << piece.getLastyPos() << endl;
pieces.push_back(tmp);
objectFound = true;
}
}
//let user know you found an object and check for movement
if(objectFound ==true){
// Update piece location (tmp piece should now be biggest contour found)
piece.setXPos(tmp.getXPos());
piece.setYPos(tmp.getYPos());
/*
* Movement checking moved to timerTick
*
// Check for movement (tmp piece should now be biggest contour found)
if(tmp.getXPos() > (piece.getLastxPos() + thresh) || tmp.getXPos() < (piece.getLastxPos() - thresh))
{
piece.setLastxPos(tmp.getXPos());
cout << piece.getName() << ": X movement" << endl;
}
if(tmp.getYPos() > (piece.getLastyPos() + thresh) || tmp.getYPos() < (piece.getLastyPos() - thresh))
{
piece.setLastyPos(tmp.getYPos());
cout << piece.getName() << ": Y movement." << endl;
}
*/
//draw object location on screen
drawObject(pieces,cameraFeed);}
}else putText(cameraFeed,"TOO MUCH NOISE! ADJUST FILTER",Point(0,50),1,2,Scalar(0,0,255),2);
}
}
//Hue callback is not currently used
void hueCallback(const sensor_msgs::ImageConstPtr& msg_ptr) {
try {
ptr_hue = cv_bridge::toCvCopy(msg_ptr, "8UC1");
//imshow(ptr_hue->image);
ptr_hue->image.copyTo(*hue_image);
} catch (cv_bridge::Exception& e) {
ROS_ERROR("cv_bridge exception: %s", e.what());
}
int rangeMin = (mean_color - window_size)%255;
int rangeMax = (mean_color + window_size)%255;
//int otherRangeMin = (other_mean_color - window_size)%255;
//int otherRangeMax = (other_mean_color + window_size)%255;
if(rangeMin > rangeMax){
int temp = rangeMax;
rangeMax = rangeMin;
rangeMin = rangeMax;
}
/*
if(otherRangeMin > otherRangeMax){
int temp = otherRangeMax;
otherRangeMax = otherRangeMin;
otherRangeMin = otherRangeMax;
}
*/
cout << "range: " << rangeMin << " " << rangeMax << endl;
inRange(*hue_image, Scalar((double)rangeMin),Scalar((double)rangeMax), *back_img);
*color_cc_image = Scalar(0);
back_img->copyTo(*hue_image);
Size ksize = Size(2 * blurKernel + 1,2 * blurKernel + 1);
GaussianBlur(*back_img, *blurred_image, ksize, -1, -1);
//attempts at adaptive thresholding
//adaptiveThreshold(*blurred_image, *temp_blurred_image, 255, ADAPTIVE_THRESH_GAUSSIAN_C, THRESH_BINARY, 3, .5);
//threshold(*blurred_image, *temp_blurred_image, THRESH_OTSU, 255, THRESH_BINARY);
threshold(*blurred_image, *temp_blurred_image, 110, 255, THRESH_BINARY);
convertScaleAbs(*temp_blurred_image, *back_img, 1, 0);
hue_image->copyTo(*copy_image);
if (display_image_){
imshow(color_topic, *back_img);
}
getConnectedComponents();
//Find Connected Components
//I added this-it used to be just getConnectedComponent
/*
findContours(*back_img, contours, hierarchy, CV_RETR_CCOMP, CV_CHAIN_APPROX_NONE, Point());
if(!contours.empty())
numCC = getThresholdConnectedComponents();
if (contours.empty()){
inRange(*hue_image, Scalar((double)otherRangeMin),Scalar((double)otherRangeMax), *back_img);
*color_cc_image = Scalar(0);
back_img->copyTo(*hue_image);
Size ksize = Size(2 * blurKernel + 1,2 * blurKernel + 1);
GaussianBlur(*back_img, *blurred_image, ksize, -1, -1);
Mat* sat_image;
threshold(*blurred_image, *temp_blurred_image, 110, 255, THRESH_BINARY);
convertScaleAbs(*temp_blurred_image, *back_img, 1, 0);
hue_image->copyTo(*copy_image);
findContours(*back_img, contours, hierarchy, CV_RETR_CCOMP, CV_CHAIN_APPROX_NONE, Point());
if(!contours.empty())
numCC = getThresholdConnectedComponents();
}
*/
for (int i = 0; (i < (int)comps.size()) && (comps[i].idx >= 0) && (comps[i].idx < (int)contours.size()); i++) {
Scalar color( (rand()&255), (rand()&255), (rand()&255) );
drawContours(*color_cc_image, contours, comps[i].idx, color, 3, 8, hierarchy,0, Point());
drawContours(*hue_image, contours, 0, comps[i].idx, 3, 8, hierarchy,0, Point());
}
getMoments();
blobTracker->updateKalmanFiltersConnectedComponents();
if (numCC > 0)
blobTracker->getFilteredBlobs(true);
else
blobTracker->getFilteredBlobs(false);
//cv::imshow("cam",hue_image);
//Draw Filtered Blobs
RotatedRect box;
Point pt;
//Image_msgs::FeatureMoments moments;
//moments.num = 0;
for(int i=0; i<MAX_FEATURES; i++)
{
FeatureBlob ftemp;
blobTracker->filters_[i].getFiltered(ftemp);
//cout << "valid? " << ftemp.getValid() << endl;
if(ftemp.getValid() && display_image_)
{
//cout << "Should be displaying something!" << endl;
Mat firstTemp, secondTemp;
ftemp.getValues(firstTemp, secondTemp);
pt.x = firstTemp.at<float>(0,0); pt.y = firstTemp.at<float>(1,0);
blobTracker->getBoxFromCov(pt, secondTemp, box);
if (box.size.width > 0 && box.size.height > 0 && box.size.width < width && box.size.height < height)
{
int octopus;
//ellipse(*rgb_image, box, CV_RGB(0,255,255), 3, 8);
//circle(*rgb_image, pt, 3, CV_RGB(255, 255, 255), -1, 8);
}
}
}
//image_pub_.publish(moments);
if (display_image_) {
imshow("Color Blobs", *rgb_image);
imshow("Connected Components", *color_cc_image);
}
waitKey(2);
}
void init(Mat _intrinsics, Mat _distCoeffs)
{
_intrinsics.copyTo(intrinsics);
_distCoeffs.copyTo(distortion);
}
int main(int argc, const char* argv[])
{
//Read command line inputs to determine how the program will execute
ProgParams params;
parseCommandInputs(argc, argv, params);
//start mjpeg stream thread
pthread_create(&MJPEG, NULL, VideoCap, ¶ms);
//Create Local Processing Image Variables
Mat img, thresholded, output;
//initialize variables so processing loop is false;
targets.matchStart = false;
targets.validFrame = false;
targets.hotLeftOrRight = 0;
progRun = false;
struct timespec start, end;
//run loop forever
while (true)
{
//check if program is allowed to run
//this bool, is enabled by the mjpeg thread
//once it is up to 10fps
if (params.Process && progRun)
{
//start clock to determine our processing time;
clock_gettime(CLOCK_REALTIME, &start);
pthread_mutex_lock(&frameMutex);
if (!frame.empty())
{
frame.copyTo(img);
pthread_mutex_unlock(&frameMutex);
thresholded = ThresholdImage(img);
//Lock Targets and determine goals
pthread_mutex_lock(&targetMutex);
findTarget(img, thresholded, targets, params);
CalculateDist(targets);
if(params.Debug)
{
cout<<"Vert: "<<targets.VertGoal<<endl;
cout<<"Horiz: "<<targets.HorizGoal<<endl;
cout<<"Hot Goal: "<<targets.HotGoal<<endl;
cout<<"Dist:" <<targets.targetDistance<<endl<<endl;
}
pthread_mutex_unlock(&targetMutex);
clock_gettime(CLOCK_REALTIME, &end);
if(params.Timer)
cout << "It took " << diffClock(start,end) << " seconds to process frame \n";
}
pthread_mutex_unlock(&frameMutex);
if(params.Visualize)
waitKey(5);
}
usleep(1000); //20000 sleep for 5ms); // run 40 times a second
}
//if we end the process code, wait for threads to end
pthread_join(MJPEG, NULL);
//done
return 0;
}
void cv::solvePnPRansac(InputArray _opoints, InputArray _ipoints,
InputArray _cameraMatrix, InputArray _distCoeffs,
OutputArray _rvec, OutputArray _tvec, bool useExtrinsicGuess,
int iterationsCount, float reprojectionError, int minInliersCount,
OutputArray _inliers, int flags)
{
Mat opoints = _opoints.getMat(), ipoints = _ipoints.getMat();
Mat cameraMatrix = _cameraMatrix.getMat(), distCoeffs = _distCoeffs.getMat();
CV_Assert(opoints.isContinuous());
CV_Assert(opoints.depth() == CV_32F);
CV_Assert((opoints.rows == 1 && opoints.channels() == 3) || opoints.cols*opoints.channels() == 3);
CV_Assert(ipoints.isContinuous());
CV_Assert(ipoints.depth() == CV_32F);
CV_Assert((ipoints.rows == 1 && ipoints.channels() == 2) || ipoints.cols*ipoints.channels() == 2);
_rvec.create(3, 1, CV_64FC1);
_tvec.create(3, 1, CV_64FC1);
Mat rvec = _rvec.getMat();
Mat tvec = _tvec.getMat();
Mat objectPoints = opoints.reshape(3, 1), imagePoints = ipoints.reshape(2, 1);
if (minInliersCount <= 0)
minInliersCount = objectPoints.cols;
cv::pnpransac::Parameters params;
params.iterationsCount = iterationsCount;
params.minInliersCount = minInliersCount;
params.reprojectionError = reprojectionError;
params.useExtrinsicGuess = useExtrinsicGuess;
params.camera.init(cameraMatrix, distCoeffs);
params.flags = flags;
vector<int> localInliers;
Mat localRvec, localTvec;
rvec.copyTo(localRvec);
tvec.copyTo(localTvec);
if (objectPoints.cols >= pnpransac::MIN_POINTS_COUNT)
{
parallel_for(BlockedRange(0,iterationsCount), cv::pnpransac::PnPSolver(objectPoints, imagePoints, params,
localRvec, localTvec, localInliers));
}
if (localInliers.size() >= (size_t)pnpransac::MIN_POINTS_COUNT)
{
if (flags != CV_P3P)
{
int i, pointsCount = (int)localInliers.size();
Mat inlierObjectPoints(1, pointsCount, CV_32FC3), inlierImagePoints(1, pointsCount, CV_32FC2);
for (i = 0; i < pointsCount; i++)
{
int index = localInliers[i];
Mat colInlierImagePoints = inlierImagePoints(Rect(i, 0, 1, 1));
imagePoints.col(index).copyTo(colInlierImagePoints);
Mat colInlierObjectPoints = inlierObjectPoints(Rect(i, 0, 1, 1));
objectPoints.col(index).copyTo(colInlierObjectPoints);
}
solvePnP(inlierObjectPoints, inlierImagePoints, params.camera.intrinsics, params.camera.distortion, localRvec, localTvec, true, flags);
}
localRvec.copyTo(rvec);
localTvec.copyTo(tvec);
if (_inliers.needed())
Mat(localInliers).copyTo(_inliers);
}
else
{
tvec.setTo(Scalar(0));
Mat R = Mat::eye(3, 3, CV_64F);
Rodrigues(R, rvec);
if( _inliers.needed() )
_inliers.release();
}
return;
}
position DetectColor(string color, int sizeC)
{
// std::cout << "detector_Color" << std::endl;
std::vector<std::vector<cv::Point> > contours;
position coordinate;
coordinate.x = 0;
coordinate.z = 0;
RNG rng(12345);
std::vector<cv::Vec4i> hierarchy;
Point2f MaxRegCenter;
Mat temimg;
globalImage.copyTo(temimg);
if (temimg.size().width != 0)
{
int iLowH, iLowS, iLowV, iHighH, iHighS, iHighV;
if (color == "red")
{
iLowH = 0;
iLowS = 177;
iLowV = 237;
iHighH = 0;
iHighS = 255;
iHighV = 255;
}
else if (color == "blue")
{
//abi roshan
// ROS_INFO("blue");
// iLowH = 98;
// iLowS = 50;
// iLowV = 80;
// iHighH = 137;
// iHighS = 255;
// iHighV = 255;
//abi tire
iLowH = 98;
iLowS = 100;
iLowV = 175;
iHighH = 111;
iHighS = 199;
iHighV = 254;
// //abi tire
// iLowH = 103;
// iLowS = 120;
// iLowV = 175;
// iHighH = 111;
// iHighS = 199;
// iHighV = 254;
//??????????
// iLowH = 98;
// iLowS = 50;
// iLowV = 80;
// iHighH = 111;
// iHighS = 255;
// iHighV = 254;
}
else if (color == "yellow")
{
ROS_INFO("yelloqw");
iLowH = 25;
iLowS = 34;
iLowV = 101;
iHighH = 40;
iHighS = 254;
iHighV = 254;
}
else if ((color == "black"))
{
iLowH = 104;
iLowS = 0;
iLowV = 0;
iHighH = 104;
iHighS = 9;
iHighV = 80;
}
else if ((color == "green"))
{
//sabze roshan
// iLowH = 41;
// iLowS = 52;
// iLowV = 170;
// iHighH = 85;
// iHighS = 225;
// iHighV = 224;
//sabze tire
iLowH = 41;
iLowS = 41;
iLowV = 98;
iHighH = 102;
iHighS = 253;
iHighV = 203;
//sabz
// iLowH = 41;
// iLowS = 41;
// iLowV = 98;
// iHighH = 102;
// iHighS = 253;
// iHighV = 223;
}
Mat imgHSV;
Mat imgThresholded = Mat::zeros( globalImage.size(), CV_8UC3 );
ROS_INFO("detectcolo4");
int thresh = 100;
int max_thresh = 255;
cvtColor(temimg, imgHSV, COLOR_BGR2HSV); //Convert the captured frame from BGR to HSV
ROS_INFO("slam2");
inRange(imgHSV, Scalar(iLowH, iLowS, iLowV), Scalar(iHighH, iHighS, iHighV), imgThresholded); //Threshold the image
//morphological opening (removes small objects from the foreground)
Mat medianImg;
medianBlur(imgThresholded, medianImg, 21);
imshow("medianImg", medianImg);
waitKey(10);
Canny( medianImg, medianImg, thresh, thresh * 2, 3 );
cv::findContours( medianImg, contours, hierarchy, CV_RETR_TREE, CV_CHAIN_APPROX_SIMPLE, cv::Point(0, 0) );
// cv::drawContours(globalImage, contours, -1, Scalar::all(255), CV_FILLED);
// ROS_INFO("570");
// std::cout<<globalImage.size().width<<" width "<<globalImage.size().height<<" height "<<imgThresholded.size().width<<" width "<<imgThresholded.size().height<<" heith "<<std::endl;
// Mat resultimg = globalImage & imgThresholded;
// cvNamedWindow( "object_position", 1);
// cv::imshow("object_position",imgThresholded);
////////////////////>>>>>>>>>>> accecing contours <<<<<<<<<<<<<<<<<<<<<<
//// >>>>>>>> find centers
/// Get the moments
if (contours.size() != 0)
{
vector<Moments> mu(contours.size() );
for ( int i = 0; i < contours.size(); i++ )
{
mu[i] = moments( contours[i], false );
}
/// Get the mass centers:
vector<Point2f> centers( contours.size() ); // mc -> centers
for ( int i = 0; i < contours.size(); i++ )
{
centers[i] = Point2f( mu[i].m10 / mu[i].m00 , mu[i].m01 / mu[i].m00 );
}
/// Draw contours
Mat drawing = Mat::zeros( imgThresholded.size(), CV_8UC3 );
/// Calculate the area with the moments 00 and compare with the result of the OpenCV function
const float bad_point = std::numeric_limits<float>::quiet_NaN();
float MaxArea = -1;
int MaxAreaIdx = -1;
for ( int i = 0; i < contours.size(); i++ )
{
//printf(" * Contour[%d] - Area (M_00) = %.2f - Area OpenCV: %.2f - Length: %.2f \n", i, mu[i].m00, contourArea(contours[i]), arcLength( contours[i], true ) );
// if (contourArea(contours[i]) > 100)
// {
if ( contourArea(contours[i]) > MaxArea)
{
MaxArea = contourArea(contours[i]);
MaxAreaIdx = i;
// Scalar color = Scalar( rng.uniform(0, 255), rng.uniform(0, 255), rng.uniform(0, 255) );
// drawContours( imgThresholded, contours, i, color, 2, 8, hierarchy, 0, Point() );
// circle( imgThresholded, centers[i], 4, color, -1, 8, 0 );
}
//}
}
//Scalar color = Scalar( rng.uniform(0, 255), rng.uniform(0,255), rng.uniform(0,255) );
//drawContours( drawing, contours, i, color, 2, 8, hierarchy, 0, Point() );
//circle( drawing, mc[i], 4, color, -1, 8, 0 );
//?
if (MaxArea != -1)
{
MaxRegCenter = centers[MaxArea];
//?MaxRegCenter = centers[MaxArea];
}
if (MaxAreaIdx != -1)
{
if (contours[MaxAreaIdx].size() > sizeC)
{
ROS_INFO("contoursize %d",sizeC);
// Mat drawing = Mat::zeros(imgThresholded.size(), CV_8UC3 );
Scalar color = Scalar( rng.uniform(0, 255), rng.uniform(0, 255), rng.uniform(0, 255) );
drawContours( drawing, contours, MaxAreaIdx, color, 2, 8, hierarchy, 0, Point() );
circle( drawing, centers[MaxAreaIdx], 4, color, -1, 8, 0 );
coordinate = calcPosition(contours[MaxAreaIdx]);
std::cout<<coordinate.x<<" coordinatex "<<coordinate.y<<" coordinatey "<<coordinate.z<<" coordinate.z "<<endl;
}
}
if (drawing.size().width != 0)
{
imshow( "Contours2", drawing );
waitKey(10);
}
boost::this_thread::sleep(boost::posix_time::milliseconds(1000));
cout << "fshow_countours2" << endl;
}
}
return coordinate;
}
int main(int argc, char* argv[])
{
//-------------------------------------------------------------------image enhacment tests
//Mat orignal, contrast, histogram, grey;
//orignal = imread("C:\\Users\\user212\\Documents\\Visual Studio 2015\\Projects\\projectTestOpenCV\\projectTestOpenCV\\test\\test_image_enhacement_opreationsimg.jpg", CV_LOAD_IMAGE_COLOR);
//if (orignal.empty())
//{
// std::cout << "!!! Failed imread(): image not found" << std::endl;
// // don't let the execution continue, else imshow() will crash.
//}
//
////contrast adjustment
// orignal.convertTo(contrast,-1,2.2,50);
// if (contrast.empty())
// {
// std::cout << "!!! Failed to convertto(): image not found" << std::endl;
// // don't let the execution continue, else imshow() will crash.
// }
////histogram adjustment
// /// Convert to grayscale
// cvtColor(orignal, grey, CV_BGR2GRAY);
// /// Apply Histogram Equalization
// equalizeHist(grey, histogram);
//namedWindow("Original Image", 0);
//namedWindow("Contrast adjustments", 0);
//namedWindow("Histogram adjustments", 0);
//while (1) {
//
// imshow("Original Image", orignal);
// imshow("Contrast adjustments", contrast);
// imshow("Histogram adjustments", histogram);
// switch (waitKey(10))
// {
// case 32:
// //capture image at space bar
// //imwrite("test\\/orignal1.jpg", orignal);
// //imwrite("test\\/contrast1.jpg", contrast);
// imwrite("test\\/histogram1.jpg", histogram);
// break;
// case 27:
// //exit at escape
// return 0;
// }
//}
//------------------------------------------------------------------- image segmentation + init camera
//
// //global variables
// Mat frame /*camera feed*/, res /*processed image*/, mask /*mask*/;
//
// Ptr<BackgroundSubtractor> pMOG; //MOG Background subtractor
// Ptr<BackgroundSubtractor> pMOG2; //MOG2 Background subtractor
// Ptr<BackgroundSubtractorGMG> pGMG; //MOG2 Background subtractor
//
// //pMOG = new BackgroundSubtractorMOG(100,5,0,1);
// pMOG2 = new BackgroundSubtractorMOG2(1000,0,1);
// //pGMG = new BackgroundSubtractorGMG();
//
// //for reading saved file
// //char fileName[100] = "C:\\opencv\\/myVideo.avi"; //Gate1_175_p1.avi"; //mm2.avi"; //";//_p1.avi";
// //VideoCapture stream1(fileName);
//
// //camera initializer
// VideoCapture cap;
// cap.open(0);
//
// //unconditional loop
// while (true) {
//
// cap >> frame;
// //contrast adjustment+brightness
// //frame.convertTo(frame, -1, 0.5,0);
//
//
//
// res = frame;
//
// /////////////////////////////////////////using MOG -> constructor(set_input_frame, get_output_mask_here, learning_rate)
// //pMOG->operator()(frame, mask, 0.8);
// ////enhancment of mask
// //Mat histogram, grey;
// ///// Convert to grayscale
// ////cvtColor(frame, grey, CV_BGR2GRAY);
//
// ///// Apply Histogram Equalization
// //equalizeHist(mask, histogram);
//
// ////test for channels in image matrix
// ////std::cout << mask.channels() << endl;
// ////std::cout << histogram.channels() << endl;
//
// /////////////////////////////////////////using MOG2 -> constructor(set_input_frame, get_output_mask_here, learning_rate)
// pMOG2->operator()(frame,mask,0.6);
//
// //enhancment of mask
// Mat mask_histogram,grey,mask_salt,res_histogram, res_salt;
// //Convert to grayscale
// //cvtColor(frame, grey, CV_BGR2GRAY);
//
// //Apply Histogram Equalization
// equalizeHist(mask, mask_histogram);
//
// //salt pepper removal using median blurring
// medianBlur(mask, mask_salt, 5);
//
// //test for channels in image matrix
// //std::cout << mask.channels() << endl;
// //std::cout << histogram.channels() << endl;
//
// /////////////////////////////////////////using GMG/////////////////////////////////////////
// //pGMG->operator()(frame, mask);
//
// //imshow("frame", frame);
// //imshow("mask", mask);
// //imshow("histogram enhanced mask", mask_histogram);
//
// imshow("salt", mask_salt);
//
// //????????????????? here frame from previous 10th last frame needs to be copied using max to current frame??????????????????
// frame.copyTo(res, mask);
//
// frame.copyTo(res_histogram, mask_histogram);
// frame.copyTo(res_salt, mask_salt);
//
// /*imshow("No image enhancment", res);
// imshow("Histogram Equalized", res_histogram);
// imshow("Salt fixed", res_salt);
//*/
// //listen for 10ms for a key to be pressed
// switch (waitKey(10))
// {
// case 32:
//
// //capture image at space bar
// imwrite("captured_image\\/unprocessed.jpg", frame);
// imwrite("captured_image\\/mask with histogram enhanced.jpg", mask_histogram);
// imwrite("captured_image\\/mask with salt removed.jpg", mask_salt);
// imwrite("captured_image\\/processed.jpg", res);
//
// imshow("captured", res);
// imshow("captured", mask_salt);
//
// break;
//
// case 27:
// //exit at esc
// return 0;
// }
//
// }
//
/////////////////////////////////////////////////////////////////background model calculation
//global variables
Mat frame /* camera feed */,
processed_image /* processed image */,
initial_mask /* initial mask returned by MOG backgroud subtractor */,
histogram_mask /* mask after histogram equalziation */,
noise_free_mask /* mask after noise removal of salt and peper */,
history[100],
res
;
int counter_history = 0; /*sliding window history counter*/
//MOG Background subtractor initialziation
//constructor paramters : history size, number of gaussain mixtures, background ratio, noise strength)
/*Ptr<BackgroundSubtractor> pMOG;
pMOG = new BackgroundSubtractorMOG(100,5,0,1);*/
//MOG2 Background subtractor initialziation
//constructor paramters : history size, threshold value, shadow detection
Ptr<BackgroundSubtractor> pMOG2;
pMOG2 = new BackgroundSubtractorMOG2(300,0, 0);
//camera initializer
VideoCapture cap;
cap.open(0);
//sliding window history logic
while (1) {
//transfer feed to pre-intialized matrix
cap >> frame;
//image enhancement of gain (contrast) and bias (brightness) adustments
//constructor : resulting (enhanced) image, ??, alpha/gain, beta/bias
//frame.convertTo(frame, -1, 0.5, 0);
//make a copy of frame for later comparision
frame.copyTo(res);
//exit if buffer exceeds 100
if (counter_history == 100) {
std::cout << "Applciation timed out. buffer exceeded 100 frames." << counter_history << endl;
return 0;
}
//make a copy of frame for sliding window history
waitKey(1); //buffer for not crashing system
frame.copyTo(history[counter_history]);
//wait untill 10th frame is obtained. to initialize history array
if (counter_history > 10) {
//output frame number for debugging purposes
std::cout << "Frame feed No. " << counter_history << endl;
////MOG implenetation
////constructor : input image, resulting mask, learning_rate
// pMOG->operator()(frame, initial_mask, 0.8);
//
// //enhancment of mask using histogram equlzation - constructor : input image (1 channel), output image (1 channel)
// //Apply Histogram Equalization
// equalizeHist(initial_mask, histogram_mask);
// //noise reduction of salt and pepper using median blurring
// //constructor - input image (1 channel), output image (1 channel), k size (?)
// medianBlur(initial_mask, noise_free_mask, 5); //using input without histogram initialization
// //medianBlur(histogram_mask, noise_free_mask, 5); //using input with histogram initialization
// //test for checking channels in image matrix
// ////std::cout << initial_mask.channels() << endl;
// ////std::cout << histogram_mask.channels() << endl;
//MOG2 implementation (image segmentation)
//constructor : input image, resulting mask, learning_rate
pMOG2->operator()(frame, initial_mask, 0.2);
//enhancment of mask using histogram equlzation
//constructor : input image (1 channel), output image (1 channel)
equalizeHist(initial_mask, histogram_mask);
//noise reduction of salt and pepper using median blurring
//constructor - input image (1 channel), output image (1 channel), k size (?)
medianBlur(initial_mask, noise_free_mask, 5); //using input without histogram initialization
//medianBlur(histogram_mask, noise_free_mask, 5); //using input with histogram initialization
//test for channels in image matrix
//std::cout << mask.channels() << endl;
//std::cout << histogram.channels() << endl;
//Morphological opreations
//dilation
//constructor : input image (1 channel), dilated image (1 image)
dilate(noise_free_mask, noise_free_mask, MORPH_CROSS);
//erosion
//constructor : input image (1 channel), dilated image (1 image)
erode(noise_free_mask, noise_free_mask, MORPH_CROSS);
//Alpha Channel usage for traspareny addition of mask. smoothening
//alpha is the transperny value. value of stimulated alpha channel
//reconsider this?????
/*double alpha=0.05, beta;
beta = (0.5 - alpha);
addWeighted(frame, alpha, history[counter_history - 10], beta, 0.0, history[counter_history - 10]);*/
//Overwrite last frame from sliding window using generated mask of segmentation
history[counter_history - 10].copyTo(frame ,noise_free_mask);
//output results
imshow("Orignal Image", res);
imshow("Final processed image", frame);
imshow("Final mask", noise_free_mask);
}
//event handling on preview
switch (waitKey(10))
{
//capture image at space bar
case 32:
//freeze output window from feed
imshow("Orignal Image", res);
imshow("Final processed image", frame);
imshow("Final mask", noise_free_mask);
std::cout << "Image written from feed. frame no. " << counter_history << endl;
imwrite("test\\captured_image\\/orignal iamge.jpg", res);
imwrite("test\\captured_image\\/final processed image.jpg", frame);
imwrite("test\\captured_image\\/final mask.jpg", noise_free_mask);
break;
//exit at esc
case 27:
return 0;
}
//increment frame count
counter_history++;
}
//unconditional loop for uninterupted webcam feed
while (false) {
cap >> frame;
//image enhancement of gain (contrast) and bias (brightness) adustments
//constructor : resulting (enhanced) image, ??, alpha/gain, beta/bias
frame.convertTo(frame, -1, 0.5,0);
////MOG implenetation
////constructor : input image, resulting mask, learning_rate
// pMOG->operator()(frame, initial_mask, 0.8);
//
// //enhancment of mask using histogram equlzation - constructor : input image (1 channel), output image (1 channel)
// //Apply Histogram Equalization
// equalizeHist(initial_mask, histogram_mask);
// //noise reduction of salt and pepper using median blurring
// //constructor - input image (1 channel), output image (1 channel), k size (?)
// medianBlur(initial_mask, noise_free_mask, 5); //using input without histogram initialization
// //medianBlur(histogram_mask, noise_free_mask, 5); //using input with histogram initialization
// //test for checking channels in image matrix
// ////std::cout << initial_mask.channels() << endl;
// ////std::cout << histogram_mask.channels() << endl;
//MOG2 implementation
//constructor : input image, resulting mask, learning_rate
pMOG2->operator()(frame, initial_mask,0.6);
//enhancment of mask using histogram equlzation
//constructor : input image (1 channel), output image (1 channel)
equalizeHist(initial_mask, histogram_mask);
//noise reduction of salt and pepper using median blurring
//constructor - input image (1 channel), output image (1 channel), k size (?)
medianBlur(initial_mask, noise_free_mask, 5); //using input without histogram initialization
//medianBlur(histogram_mask, noise_free_mask, 5); //using input with histogram initialization
//test for channels in image matrix
//std::cout << mask.channels() << endl;
//std::cout << histogram.channels() << endl;
//preview tempororary results
//imshow("salt", noise_free_mask);
//????????????????? here frame from previous 10th last frame needs to be copied using max to current frame??????????????????
//frame.copyTo(processed_image, noise_free_mask);
//imshow("captured", noise_free_mask);
//event handling on preview
switch (waitKey(10))
{
//capture image at space bar
case 32:
//imwrite("test\\captured_image\\/processed_image.jpg", noise_free_mask); //save image as jepg
imshow("captured", processed_image); // show image in seprate windo
break;
//exit at esc
case 27:
return 0;
}
}
}
// Create a grayscale face image that has a standard size and contrast & brightness.
// "srcImg" should be a copy of the whole color camera frame, so that it can draw the eye positions onto.
// If 'doLeftAndRightSeparately' is true, it will process left & right sides seperately,
// so that if there is a strong light on one side but not the other, it will still look OK.
// Performs Face Preprocessing as a combination of:
// - geometrical scaling, rotation and translation using Eye Detection,
// - smoothing away image noise using a Bilateral Filter,
// - standardize the brightness on both left and right sides of the face independently using separated Histogram Equalization,
// - removal of background and hair using an Elliptical Mask.
// Returns either a preprocessed face square image or NULL (ie: couldn't detect the face and 2 eyes).
// If a face is found, it can store the rect coordinates into 'storeFaceRect' and 'storeLeftEye' & 'storeRightEye' if given,
// and eye search regions into 'searchedLeftEye' & 'searchedRightEye' if given.
Mat getPreprocessedFace(Mat &srcImg, int desiredFaceWidth, CascadeClassifier &faceCascade, CascadeClassifier &eyeCascade1, CascadeClassifier &eyeCascade2, bool doLeftAndRightSeparately, Rect *storeFaceRect, Point *storeLeftEye, Point *storeRightEye, Rect *searchedLeftEye, Rect *searchedRightEye)
{
// Use square faces.
int desiredFaceHeight = desiredFaceWidth;
// Mark the detected face region and eye search regions as invalid, in case they aren't detected.
if (storeFaceRect)
storeFaceRect->width = -1;
if (storeLeftEye)
storeLeftEye->x = -1;
if (storeRightEye)
storeRightEye->x= -1;
if (searchedLeftEye)
searchedLeftEye->width = -1;
if (searchedRightEye)
searchedRightEye->width = -1;
// Find the largest face.
Rect faceRect;
detectLargestObject(srcImg, faceCascade, faceRect,SCALEDWIDTH);
// Check if a face was detected.
if (faceRect.width > 0) {
// Give the face rect to the caller if desired.
if (storeFaceRect)
*storeFaceRect = faceRect;
Mat faceImg = srcImg(faceRect); // Get the detected face image.
// If the input image is not grayscale, then convert the BGR or BGRA color image to grayscale.
Mat gray;
if (faceImg.channels() == 3) {
cvtColor(faceImg, gray, CV_BGR2GRAY);
}
else if (faceImg.channels() == 4) {
cvtColor(faceImg, gray, CV_BGRA2GRAY);
}
else {
// Access the input image directly, since it is already grayscale.
gray = faceImg;
}
// Search for the 2 eyes at the full resolution, since eye detection needs max resolution possible!
Point leftEye, rightEye;
detectBothEyes(gray, eyeCascade1, eyeCascade2, leftEye, rightEye, searchedLeftEye, searchedRightEye);
// Give the eye results to the caller if desired.
if (storeLeftEye)
*storeLeftEye = leftEye;
if (storeRightEye)
*storeRightEye = rightEye;
// Check if both eyes were detected.
if (leftEye.x >= 0 && rightEye.x >= 0) {
// Make the face image the same size as the training images.
// Since we found both eyes, lets rotate & scale & translate the face so that the 2 eyes
// line up perfectly with ideal eye positions. This makes sure that eyes will be horizontal,
// and not too far left or right of the face, etc.
// Get the center between the 2 eyes.
Point2f eyesCenter = Point2f( (leftEye.x + rightEye.x) * 0.5f, (leftEye.y + rightEye.y) * 0.5f );
// Get the angle between the 2 eyes.
double dy = (rightEye.y - leftEye.y);
double dx = (rightEye.x - leftEye.x);
double len = sqrt(dx*dx + dy*dy);
double angle = atan2(dy, dx) * 180.0/CV_PI; // Convert from radians to degrees.
// Hand measurements shown that the left eye center should ideally be at roughly (0.19, 0.14) of a scaled face image.
const double DESIRED_RIGHT_EYE_X = (1.0f - DESIRED_LEFT_EYE_X);
// Get the amount we need to scale the image to be the desired fixed size we want.
double desiredLen = (DESIRED_RIGHT_EYE_X - DESIRED_LEFT_EYE_X) * desiredFaceWidth;
double scale = desiredLen / len;
// Get the transformation matrix for rotating and scaling the face to the desired angle & size.
Mat rot_mat = getRotationMatrix2D(eyesCenter, angle, scale);
// Shift the center of the eyes to be the desired center between the eyes.
rot_mat.at<double>(0, 2) += desiredFaceWidth * 0.5f - eyesCenter.x;
rot_mat.at<double>(1, 2) += desiredFaceHeight * DESIRED_LEFT_EYE_Y - eyesCenter.y;
// Rotate and scale and translate the image to the desired angle & size & position!
// Note that we use 'w' for the height instead of 'h', because the input face has 1:1 aspect ratio.
Mat warped = Mat(desiredFaceHeight, desiredFaceWidth, CV_8U, Scalar(128)); // Clear the output image to a default grey.
warpAffine(gray, warped, rot_mat, warped.size());
//imshow("warped", warped);
// Give the image a standard brightness and contrast, in case it was too dark or had low contrast.
if (!doLeftAndRightSeparately) {
// Do it on the whole face.
equalizeHist(warped, warped);
}
else {
// Do it seperately for the left and right sides of the face.
equalizeLeftAndRightHalves(warped);
}
//imshow("equalized", warped);
// Use the "Bilateral Filter" to reduce pixel noise by smoothing the image, but keeping the sharp edges in the face.
Mat filtered = Mat(warped.size(), CV_8U);
bilateralFilter(warped, filtered, 0, 20.0, 2.0);
//imshow("filtered", filtered);
// Filter out the corners of the face, since we mainly just care about the middle parts.
// Draw a filled ellipse in the middle of the face-sized image.
Mat mask = Mat(warped.size(), CV_8U, Scalar(0)); // Start with an empty mask.
Point faceCenter = Point( desiredFaceWidth/2, cvRound(desiredFaceHeight * FACE_ELLIPSE_CY) );
Size size = Size( cvRound(desiredFaceWidth * FACE_ELLIPSE_W), cvRound(desiredFaceHeight * FACE_ELLIPSE_H) );
ellipse(mask, faceCenter, size, 0, 0, 360, Scalar(255), CV_FILLED);
//imshow("mask", mask);
// Use the mask, to remove outside pixels.
Mat dstImg = Mat(warped.size(), CV_8U, Scalar(128)); // Clear the output image to a default gray.
/*
namedWindow("filtered");
imshow("filtered", filtered);
namedWindow("dstImg");
imshow("dstImg", dstImg);
namedWindow("mask");
imshow("mask", mask);
*/
// Apply the elliptical mask on the face.
filtered.copyTo(dstImg, mask); // Copies non-masked pixels from filtered to dstImg.
//imshow("dstImg", dstImg);
return dstImg;
}
/*
else {
// Since no eyes were found, just do a generic image resize.
resize(gray, tmpImg, Size(w,h));
}
*/
}
return Mat();
}
void findFeaturePoint(Mat src, vector<Point>& point, vector<Rect>& rect_res,
int FLAG) {
LOGD_ERR("findFeaturePoint Enter");
char name[10];
sprintf(name, "Step %d", FLAG);
Mat src_mask = Mat(src.size(), CV_8U);
Mat thresholdRes = Mat(src.size(), CV_8U);
Mat thresholdResCopy = Mat(src.size(), CV_8U);
eclipseMask(src, src_mask);
if (FLAG)
equalizeLeftAndRightHalves(src_mask);
//imshow("After Equalize", src_mask);
double minVal = 0;
double maxVal = 0;
minMaxLoc(src_mask, &minVal, &maxVal, NULL, NULL);
//threshold(src, threRes, maxVal-10, 255, THRESH_BINARY);
threshold(src_mask, thresholdRes, minVal + 7.5, 255, THRESH_BINARY);
thresholdRes.copyTo(thresholdResCopy);
//LOGD_ERR("Threshold Over");
//imshow(name, thresholdRes);
vector<Vec4i> hierarchy;
vector < vector<Point2i> > contours;
findContours(thresholdResCopy.rowRange(0, thresholdRes.rows / 2), contours,
hierarchy, CV_RETR_LIST, CV_CHAIN_APPROX_SIMPLE);
//LOGD_ERR("findContours Over");
sort(contours.begin(), contours.end(), my_cmp);
//LOGD_ERR("sort Over");
//cout << contours.size() << endl;
//LOGD_ERR(contours.size());
Rect rect;
if (contours.size() < 2)
return;
switch (FLAG) {
case 0:
for (int i = 0; i < 2; i++) {
rect = boundingRect(contours[i]);
point.push_back(
Point((rect.tl().x + rect.br().x) * 0.5,
(rect.tl().y + rect.br().y) * 0.5));
rect_res.push_back(rect);
//rectangle(src, rect, M_RED);
}
break;
case 1:
Mat subThreshold;
int MAX_RIGHT_I = 0, MAX_RIGHT_J = 0;
int MAX_LEFT_I = 1000, MAX_LEFT_J = 1000;
float curV;
for (int k = 0; k < 2; k++) {
rect = boundingRect(contours[k]);
subThreshold =
thresholdRes.colRange(rect.tl().x, rect.br().x).rowRange(
rect.tl().y, rect.br().y);
//imshow("SSS",subThreshold);
for (int i = 0; i < subThreshold.size().height; i++)
for (int j = 0; j < subThreshold.size().width; j++) {
try {
curV = subThreshold.data[i * subThreshold.size().width
* subThreshold.channels() + j];
} catch (cv::Exception& e) {
cout << e.what() << endl;
}
if (curV <= 10) {
if (j >= MAX_RIGHT_J) {
MAX_RIGHT_I = i;
MAX_RIGHT_J = j;
}
if (j <= MAX_LEFT_J) {
MAX_LEFT_I = i;
MAX_LEFT_J = j;
}
}
}
point.push_back(
Point(MAX_LEFT_J + rect.tl().x, MAX_LEFT_I + rect.tl().y));
point.push_back(
Point(MAX_RIGHT_J + rect.tl().x,
MAX_RIGHT_I + rect.tl().y));
rect_res.push_back(rect);
//rectangle(src, rect, M_RED);
}
break;
}
LOGD_ERR("findFeaturePoint Exit");
}
void useFile() {
string filename("");
cout << "Filename : ";
getline(cin, filename);
Mat img;
//Check if errors
if(!loadImage(img, filename)) {
return;
}
cout << "Load successful !\n\n";
//Display initial picture
namedWindow("initial picture", WINDOW_AUTOSIZE);
imshow("initial picture", img);
waitKey(0); //Wait before next step
destroyWindow("initial picture");
//Display grayscale picture
namedWindow("grayscale picture", WINDOW_AUTOSIZE);
convertImageToGrayScale(img);
imshow("grayscale picture", img);
waitKey(0); //Wait before next step
destroyWindow("grayscale picture");
saveImage("1_grayscale", img);
//Display reduce picture
string window("before reduce picture"), window2("after reduce picture");
namedWindow(window, WINDOW_AUTOSIZE);
int angle(100),
electrodes_width(10), electrodes_height(6),
width(img.size().width), height(img.size().height);
Mat baseImg;
img.copyTo(baseImg);
createTrackbar("angle (%)", window, &angle, 100);
createTrackbar("width", window, &electrodes_width, width);
createTrackbar("height", window, &electrodes_height, height);
while(static_cast<char>(waitKey(1)) != 13) {
baseImg.copyTo(img);
reduceImage(img, angle, (double)electrodes_height / (double)electrodes_width);
imshow(window, baseImg);
imshow(window2, img);
}
destroyWindow(window);
destroyWindow(window2);
saveImage("2_reduce", img);
//Display pixelise picture
window = "before pixelise picture";
window2 = "after pixelise picture";
namedWindow(window, WINDOW_AUTOSIZE);
Mat zoomImg;
img.copyTo(baseImg);
int zoom(1);
createTrackbar("zoom", window, &zoom, 20);
while(static_cast<char>(waitKey(1)) != 13) {
baseImg.copyTo(img);
pixeliseImage(img, electrodes_width, electrodes_height);
img.copyTo(zoomImg);
extendImage(zoomImg, zoom);
imshow(window, baseImg);
imshow(window2, zoomImg);
}
destroyWindow(window);
destroyWindow(window2);
saveImage("3_pixelise", img);
//Display reverse picture
namedWindow("reverse picture", WINDOW_AUTOSIZE);
reverseImage(img);
saveImage("4_reverse", img);
extendImage(img, zoom);
imshow("reverse picture", img);
waitKey(0); //Wait before next step
destroyWindow("reverse picture");
}
void CV_BilateralFilterTest::reference_bilateral_filter(const Mat &src, Mat &dst, int d,
double sigma_color, double sigma_space, int borderType)
{
int cn = src.channels();
int i, j, k, maxk, radius;
double minValSrc = -1, maxValSrc = 1;
const int kExpNumBinsPerChannel = 1 << 12;
int kExpNumBins = 0;
float lastExpVal = 1.f;
float len, scale_index;
Size size = src.size();
dst.create(size, src.type());
CV_Assert( (src.type() == CV_32FC1 || src.type() == CV_32FC3) &&
src.type() == dst.type() && src.size() == dst.size() &&
src.data != dst.data );
if( sigma_color <= 0 )
sigma_color = 1;
if( sigma_space <= 0 )
sigma_space = 1;
double gauss_color_coeff = -0.5/(sigma_color*sigma_color);
double gauss_space_coeff = -0.5/(sigma_space*sigma_space);
if( d <= 0 )
radius = cvRound(sigma_space*1.5);
else
radius = d/2;
radius = MAX(radius, 1);
d = radius*2 + 1;
// compute the min/max range for the input image (even if multichannel)
minMaxLoc( src.reshape(1), &minValSrc, &maxValSrc );
if(std::abs(minValSrc - maxValSrc) < FLT_EPSILON)
{
src.copyTo(dst);
return;
}
// temporary copy of the image with borders for easy processing
Mat temp;
copyMakeBorder( src, temp, radius, radius, radius, radius, borderType );
patchNaNs(temp);
// allocate lookup tables
vector<float> _space_weight(d*d);
vector<int> _space_ofs(d*d);
float* space_weight = &_space_weight[0];
int* space_ofs = &_space_ofs[0];
// assign a length which is slightly more than needed
len = (float)(maxValSrc - minValSrc) * cn;
kExpNumBins = kExpNumBinsPerChannel * cn;
vector<float> _expLUT(kExpNumBins+2);
float* expLUT = &_expLUT[0];
scale_index = kExpNumBins/len;
// initialize the exp LUT
for( i = 0; i < kExpNumBins+2; i++ )
{
if( lastExpVal > 0.f )
{
double val = i / scale_index;
expLUT[i] = (float)std::exp(val * val * gauss_color_coeff);
lastExpVal = expLUT[i];
}
else
expLUT[i] = 0.f;
}
// initialize space-related bilateral filter coefficients
for( i = -radius, maxk = 0; i <= radius; i++ )
for( j = -radius; j <= radius; j++ )
{
double r = std::sqrt((double)i*i + (double)j*j);
if( r > radius )
continue;
space_weight[maxk] = (float)std::exp(r*r*gauss_space_coeff);
space_ofs[maxk++] = (int)(i*(temp.step/sizeof(float)) + j*cn);
}
for( i = 0; i < size.height; i++ )
{
const float* sptr = (const float*)(temp.data + (i+radius)*temp.step) + radius*cn;
float* dptr = (float*)(dst.data + i*dst.step);
if( cn == 1 )
{
for( j = 0; j < size.width; j++ )
{
float sum = 0, wsum = 0;
float val0 = sptr[j];
for( k = 0; k < maxk; k++ )
{
float val = sptr[j + space_ofs[k]];
float alpha = (float)(std::abs(val - val0)*scale_index);
int idx = cvFloor(alpha);
alpha -= idx;
float w = space_weight[k]*(expLUT[idx] + alpha*(expLUT[idx+1] - expLUT[idx]));
sum += val*w;
wsum += w;
}
dptr[j] = (float)(sum/wsum);
}
}
else
{
assert( cn == 3 );
for( j = 0; j < size.width*3; j += 3 )
{
float sum_b = 0, sum_g = 0, sum_r = 0, wsum = 0;
float b0 = sptr[j], g0 = sptr[j+1], r0 = sptr[j+2];
for( k = 0; k < maxk; k++ )
{
const float* sptr_k = sptr + j + space_ofs[k];
float b = sptr_k[0], g = sptr_k[1], r = sptr_k[2];
float alpha = (float)((std::abs(b - b0) +
std::abs(g - g0) + std::abs(r - r0))*scale_index);
int idx = cvFloor(alpha);
alpha -= idx;
float w = space_weight[k]*(expLUT[idx] + alpha*(expLUT[idx+1] - expLUT[idx]));
sum_b += b*w; sum_g += g*w; sum_r += r*w;
wsum += w;
}
wsum = 1.f/wsum;
b0 = sum_b*wsum;
g0 = sum_g*wsum;
r0 = sum_r*wsum;
dptr[j] = b0; dptr[j+1] = g0; dptr[j+2] = r0;
}
}
}
}
static bool to(PyObject* obj, vector<_Tp>& value, const char* name="<unknown>")
{
typedef typename DataType<_Tp>::channel_type _Cp;
if(!obj || obj == Py_None)
return true;
if (PyArray_Check(obj))
{
Mat m;
pyopencv_to(obj, m, name);
m.copyTo(value);
}
if (!PySequence_Check(obj))
return false;
PyObject *seq = PySequence_Fast(obj, name);
if (seq == NULL)
return false;
int i, j, n = (int)PySequence_Fast_GET_SIZE(seq);
value.resize(n);
int type = DataType<_Tp>::type;
int depth = CV_MAT_DEPTH(type), channels = CV_MAT_CN(type);
PyObject** items = PySequence_Fast_ITEMS(seq);
for( i = 0; i < n; i++ )
{
PyObject* item = items[i];
PyObject* seq_i = 0;
PyObject** items_i = &item;
_Cp* data = (_Cp*)&value[i];
if( channels == 2 && PyComplex_CheckExact(item) )
{
Py_complex c = PyComplex_AsCComplex(obj);
data[0] = saturate_cast<_Cp>(c.real);
data[1] = saturate_cast<_Cp>(c.imag);
continue;
}
if( channels > 1 )
{
if( PyArray_Check(item))
{
Mat src;
pyopencv_to(item, src, name);
if( src.dims != 2 || src.channels() != 1 ||
((src.cols != 1 || src.rows != channels) &&
(src.cols != channels || src.rows != 1)))
break;
Mat dst(src.rows, src.cols, depth, data);
src.convertTo(dst, type);
if( dst.data != (uchar*)data )
break;
continue;
}
seq_i = PySequence_Fast(item, name);
if( !seq_i || (int)PySequence_Fast_GET_SIZE(seq_i) != channels )
{
Py_XDECREF(seq_i);
break;
}
items_i = PySequence_Fast_ITEMS(seq_i);
}
for( j = 0; j < channels; j++ )
{
PyObject* item_ij = items_i[j];
if( PyInt_Check(item_ij))
{
int v = PyInt_AsLong(item_ij);
if( v == -1 && PyErr_Occurred() )
break;
data[j] = saturate_cast<_Cp>(v);
}
else if( PyFloat_Check(item_ij))
{
double v = PyFloat_AsDouble(item_ij);
if( PyErr_Occurred() )
break;
data[j] = saturate_cast<_Cp>(v);
}
else
break;
}
Py_XDECREF(seq_i);
if( j < channels )
break;
}
Py_DECREF(seq);
return i == n;
}
int main(int argc, char** argv)
{
VideoCapture capture;
char* video = argv[1];
int flag = arg_parse(argc, argv);
capture.open(video);
if(!capture.isOpened()) {
fprintf(stderr, "Could not initialize capturing..\n");
return -1;
}
int frame_num = 0;
TrackInfo trackInfo;
DescInfo hogInfo, hofInfo, mbhInfo;
InitTrackInfo(&trackInfo, track_length, init_gap);
InitDescInfo(&hogInfo, 8, false, patch_size, nxy_cell, nt_cell);
InitDescInfo(&hofInfo, 9, true, patch_size, nxy_cell, nt_cell);
InitDescInfo(&mbhInfo, 8, false, patch_size, nxy_cell, nt_cell);
SeqInfo seqInfo;
InitSeqInfo(&seqInfo, video);
if(flag)
seqInfo.length = end_frame - start_frame + 1;
// fprintf(stderr, "video size, length: %d, width: %d, height: %d\n", seqInfo.length, seqInfo.width, seqInfo.height);
if(show_track == 1)
namedWindow("DenseTrack", 0);
Mat image, prev_grey, grey;
std::vector<float> fscales(0);
std::vector<Size> sizes(0);
std::vector<Mat> prev_grey_pyr(0), grey_pyr(0), flow_pyr(0);
std::vector<Mat> prev_poly_pyr(0), poly_pyr(0); // for optical flow
std::vector<std::list<Track> > xyScaleTracks;
int init_counter = 0; // indicate when to detect new feature points
while(true) {
Mat frame;
int i, j, c;
// get a new frame
capture >> frame;
if(frame.empty())
break;
if(frame_num < start_frame || frame_num > end_frame) {
frame_num++;
continue;
}
if(frame_num == start_frame) {
image.create(frame.size(), CV_8UC3);
grey.create(frame.size(), CV_8UC1);
prev_grey.create(frame.size(), CV_8UC1);
InitPry(frame, fscales, sizes);
BuildPry(sizes, CV_8UC1, prev_grey_pyr);
BuildPry(sizes, CV_8UC1, grey_pyr);
BuildPry(sizes, CV_32FC2, flow_pyr);
BuildPry(sizes, CV_32FC(5), prev_poly_pyr);
BuildPry(sizes, CV_32FC(5), poly_pyr);
xyScaleTracks.resize(scale_num);
frame.copyTo(image);
cvtColor(image, prev_grey, CV_BGR2GRAY);
for(int iScale = 0; iScale < scale_num; iScale++) {
if(iScale == 0)
prev_grey.copyTo(prev_grey_pyr[0]);
else
resize(prev_grey_pyr[iScale-1], prev_grey_pyr[iScale], prev_grey_pyr[iScale].size(), 0, 0, INTER_LINEAR);
// dense sampling feature points
std::vector<Point2f> points(0);
DenseSample(prev_grey_pyr[iScale], points, quality, min_distance);
// save the feature points
std::list<Track>& tracks = xyScaleTracks[iScale];
for(i = 0; i < points.size(); i++)
tracks.push_back(Track(points[i], trackInfo, hogInfo, hofInfo, mbhInfo));
}
// compute polynomial expansion
my::FarnebackPolyExpPyr(prev_grey, prev_poly_pyr, fscales, 7, 1.5);
frame_num++;
continue;
}
init_counter++;
frame.copyTo(image);
cvtColor(image, grey, CV_BGR2GRAY);
// compute optical flow for all scales once
my::FarnebackPolyExpPyr(grey, poly_pyr, fscales, 7, 1.5);
my::calcOpticalFlowFarneback(prev_poly_pyr, poly_pyr, flow_pyr, 10, 2);
for(int iScale = 0; iScale < scale_num; iScale++) {
if(iScale == 0)
grey.copyTo(grey_pyr[0]);
else
resize(grey_pyr[iScale-1], grey_pyr[iScale], grey_pyr[iScale].size(), 0, 0, INTER_LINEAR);
int width = grey_pyr[iScale].cols;
int height = grey_pyr[iScale].rows;
// compute the integral histograms
DescMat* hogMat = InitDescMat(height+1, width+1, hogInfo.nBins);
HogComp(prev_grey_pyr[iScale], hogMat->desc, hogInfo);
DescMat* hofMat = InitDescMat(height+1, width+1, hofInfo.nBins);
HofComp(flow_pyr[iScale], hofMat->desc, hofInfo);
DescMat* mbhMatX = InitDescMat(height+1, width+1, mbhInfo.nBins);
DescMat* mbhMatY = InitDescMat(height+1, width+1, mbhInfo.nBins);
MbhComp(flow_pyr[iScale], mbhMatX->desc, mbhMatY->desc, mbhInfo);
// track feature points in each scale separately
std::list<Track>& tracks = xyScaleTracks[iScale];
for (std::list<Track>::iterator iTrack = tracks.begin(); iTrack != tracks.end();) {
int index = iTrack->index;
Point2f prev_point = iTrack->point[index];
int x = std::min<int>(std::max<int>(cvRound(prev_point.x), 0), width-1);
int y = std::min<int>(std::max<int>(cvRound(prev_point.y), 0), height-1);
Point2f point;
point.x = prev_point.x + flow_pyr[iScale].ptr<float>(y)[2*x];
point.y = prev_point.y + flow_pyr[iScale].ptr<float>(y)[2*x+1];
if(point.x <= 0 || point.x >= width || point.y <= 0 || point.y >= height) {
iTrack = tracks.erase(iTrack);
continue;
}
//added **********
std::vector<Point2f> trajectory(trackInfo.length+1);
for(int i = 0; i <= trackInfo.length; ++i)
{
trajectory[i] = iTrack->point[i]*fscales[iScale];
}
//done
// get the descriptors for the feature point
RectInfo rect;
GetRect(prev_point, rect, width, height, hogInfo);
GetDesc(hogMat, rect, hogInfo, iTrack->hog, index);
GetDesc(hofMat, rect, hofInfo, iTrack->hof, index);
GetDesc(mbhMatX, rect, mbhInfo, iTrack->mbhX, index);
GetDesc(mbhMatY, rect, mbhInfo, iTrack->mbhY, index);
iTrack->addPoint(point);
// draw the trajectories at the first scale
if(show_track == 1 && iScale == 0)
DrawTrack(iTrack->point, iTrack->index, fscales[iScale], image);
// if the trajectory achieves the maximal length
if(iTrack->index >= trackInfo.length) {
std::vector<Point2f> trajectory(trackInfo.length+1);
for(int i = 0; i <= trackInfo.length; ++i)
trajectory[i] = iTrack->point[i]*fscales[iScale];
float mean_x(0), mean_y(0), var_x(0), var_y(0), length(0);
if(IsValid(trajectory, mean_x, mean_y, var_x, var_y, length)) {
// printf("%d\t%f\t%f\t%f\t%f\t%f\t%f\t", frame_num, mean_x, mean_y, var_x, var_y, length, fscales[iScale]);
// for spatio-temporal pyramid
/* dont need this features
printf("%f\t", std::min<float>(std::max<float>(mean_x/float(seqInfo.width), 0), 0.999));
printf("%f\t", std::min<float>(std::max<float>(mean_y/float(seqInfo.height), 0), 0.999));
printf("%f\t", std::min<float>(std::max<float>((frame_num - trackInfo.length/2.0 - start_frame)/float(seqInfo.length), 0), 0.999));
// output the trajectory
for (int i = 0; i < trackInfo.length; ++i)
printf("%f\t%f\t", trajectory[i].x,trajectory[i].y);
*/
/* dont need this features
PrintDesc(iTrack->hog, hogInfo, trackInfo);
PrintDesc(iTrack->hof, hofInfo, trackInfo);
PrintDesc(iTrack->mbhX, mbhInfo, trackInfo);
PrintDesc(iTrack->mbhY, mbhInfo, trackInfo);
*/
printf("\n");
}
iTrack = tracks.erase(iTrack);
continue;
}
++iTrack;
}
ReleDescMat(hogMat);
ReleDescMat(hofMat);
ReleDescMat(mbhMatX);
ReleDescMat(mbhMatY);
if(init_counter != trackInfo.gap)
continue;
// detect new feature points every initGap frames
std::vector<Point2f> points(0);
for(std::list<Track>::iterator iTrack = tracks.begin(); iTrack != tracks.end(); iTrack++)
points.push_back(iTrack->point[iTrack->index]);
DenseSample(grey_pyr[iScale], points, quality, min_distance);
// save the new feature points
for(i = 0; i < points.size(); i++)
tracks.push_back(Track(points[i], trackInfo, hogInfo, hofInfo, mbhInfo));
}
init_counter = 0;
grey.copyTo(prev_grey);
for(i = 0; i < scale_num; i++) {
grey_pyr[i].copyTo(prev_grey_pyr[i]);
poly_pyr[i].copyTo(prev_poly_pyr[i]);
}
frame_num++;
if( show_track == 1 ) {
imshow( "DenseTrack", image);
c = cvWaitKey(3);
if((char)c == 27) break;
}
}
if( show_track == 1 )
destroyWindow("DenseTrack");
return 0;
}
int main( int argc, char** argv)
{
string face_cascade_name = "../xintai.xml";
CascadeClassifier face_cascade;
if(!face_cascade.load( face_cascade_name ) )
{
std::cout<<"can not load the face model "<<std::endl;
return -1;
}
string image_path = "/home/yuanyang/workspace/face_align_one_millisecond/face_landmark_data/lfpw/trainset/";
fs::path input_path( image_path );
if(!fs::exists(input_path))
{
std::cout<<"input_path "<<input_path<<" not exist "<<std::endl;
}
if(!fs::is_directory(input_path))
{
std::cout<<"input_path is not a directory "<<input_path<<std::endl;
}
FacedetWithFilter fff;
fff.init("../svm_w.xml","../svm_b.xml");
fff.setConfidenceParas( 2.0, 0.1, -10); //²ÎÊýÒâÒåŒûÀකÒå
/* load face detector from dlib */
dlib::frontal_face_detector detector = dlib::get_frontal_face_detector();
fs::directory_iterator end_it;
for( fs::directory_iterator file_iter(input_path); file_iter != end_it; file_iter++ )
{
fs::path s = *(file_iter);
string basename = fs::basename( s );
string pathname = file_iter->path().string();
string extname = fs::extension( *(file_iter) );
if( extname!=".jpg" &&
extname!=".png")
{
//std::cout<<"do no support ext name "<<extname<<std::endl;
continue;
}
Mat im = imread( pathname );
dlib::cv_image<dlib::bgr_pixel> input_im(im);
dlib::array2d<dlib::bgr_pixel> img;
dlib::assign_image( img, input_im );
int min_ = 50;
int max_ = min( im.cols, im.rows);
double scale_factor = 1.05;
fff.setDetectionParas( min_ , max_ , scale_factor, 0.1); //Œì²âµÄ²ÎÊý
vector<Rect> faces;
faces.reserve(10);
Mat cp1,cp2,cp3;
im.copyTo(cp1);
im.copyTo(cp2);
im.copyTo(cp3);
fff.setConfidenceParas(2.5, 0.2, -10);
double t = cv::getTickCount();
fff.detectAndFilter( im , faces);
// fff.detectFace(im , faces );
t = (double)cv::getTickCount() - t;
std::cout<<"time duration pico det and filter is "<<t/cv::getTickFrequency()<<std::endl;
t = cv::getTickCount();
fff.detectFace(im , faces );
t = (double)cv::getTickCount() - t;
std::cout<<"time duration pico det is "<<t/cv::getTickFrequency()<<std::endl;
for(int c=0;c<faces.size();c++)
{
rectangle( cp1, faces[c], Scalar(255,0,0));
}
imshow("pico", cp1 );
/* haar boost
* */
vector<Rect> faces2;
t = (double)getTickCount();
face_cascade.detectMultiScale( im, faces2, scale_factor, 2, 0, Size(min_,min_), Size(max_,max_) );
t = (double)getTickCount() - t;
std::cout<<"time duration haarboost is "<<t/getTickFrequency()<<std::endl;
for(int c=0;c<faces2.size();c++)
{
rectangle( cp2, faces2[c], Scalar(0,255,0));
}
imshow("haar", cp2 );
/* dlib face detect */
t = (double)cv::getTickCount();
std::vector<dlib::rectangle> dets = detector(img);
t = (double)cv::getTickCount() - t;
std::cout<<"time duration in dlib is "<<t/(double)cv::getTickFrequency()<<std::endl;
for (unsigned long j = 0; j < dets.size(); ++j)
{
int top_ = dets[j].top();
int left_ = dets[j].left();
int width_ = dets[j].width();
int height_ = dets[j].height();
rectangle( cp3, Rect( left_, top_, width_, height_ ), Scalar(0,0,255));
}
imshow("shog",cp3);
waitKey(0);
}
return 0;
}
int main(int argvc, char** argv){
Mat mask(3,3,CV_32F), mask1;
VideoCapture video_in;
mask = Mat(3, 3, CV_32F, gauss);
scaleAdd(mask, 1/16.0, Mat::zeros(3,3,CV_32F), mask1);
mask = mask1;
int cont = 0;
video_in.open("tiltshiftvideo_entrada.mp4");
width = video_in.get(CV_CAP_PROP_FRAME_WIDTH);
height = video_in.get(CV_CAP_PROP_FRAME_HEIGHT);
vertical_slider = height/2;
vertical_slider_max = height;
center_slider = height/2;
center_slider_max = height;
VideoWriter video_out("tiltshiftvideo_saida.avi",CV_FOURCC('M','J','P','G'),10,Size(width,height),true);
namedWindow("tiltshiftvideo", 1);
sprintf( TrackbarName, "Alpha x %d", alfa_slider_max );
createTrackbar( TrackbarName, "tiltshiftvideo",&alfa_slider,alfa_slider_max,on_trackbar_blend );
//on_trackbar_blend(alfa_slider, 0 );
sprintf( TrackbarName, "DistCenter x %d", center_slider_max );
createTrackbar( TrackbarName, "tiltshiftvideo",¢er_slider, center_slider_max, on_trackbar_center );
//on_trackbar_center(center_slider, 0 );
sprintf( TrackbarName, "VertPosi x %d", vertical_slider_max );
createTrackbar( TrackbarName, "tiltshiftvideo", &vertical_slider, vertical_slider_max, on_trackbar_vert );
//on_trackbar_vert(vertical_slider, 0 );
if(!video_in.isOpened()){
return -1;
}
for(;;) {
// video_in >> original;
bool bSuccess = video_in.read(original); // read a new frame from video
if (!bSuccess){
cout << "Cannot read the frame from video file" << endl;
break;
}
if(cont == 6){
filter2D(original, desfocada, original.depth(), mask, Point(1,1), 0);
filter2D(desfocada, desfocada, desfocada.depth(), mask, Point(1,1), 0);
filter2D(desfocada, desfocada, desfocada.depth(), mask, Point(1,1), 0);
filter2D(desfocada, desfocada, desfocada.depth(), mask, Point(1,1), 0);
filter2D(desfocada, desfocada, desfocada.depth(), mask, Point(1,1), 0);
filter2D(desfocada, desfocada, desfocada.depth(), mask, Point(1,1), 0);
desfocada.copyTo(desf_cpy);
original = increase_colour_saturation(original);
on_trackbar_blend(alfa_slider, 0 );
on_trackbar_center(center_slider, 0 );
on_trackbar_vert(vertical_slider, 0 );
if(waitKey(30)>=0) break;
cont = 0;
video_out.write(blended);
}
cont++;
}
return 0;
}
//--------------------------------------【main( )函数】-----------------------------------------
// 描述：控制台应用程序的入口函数，我们的程序从这里开始执行
//-------------------------------------------------------------------------------------------------
int main( )
{
//【1】以灰度模式读取原始图像并显示
Mat srcImage = imread("1.jpg", 0);
if(!srcImage.data ) { printf("读取图片错误，请确定目录下是否有imread函数指定图片存在~！ \n"); return false; }
imshow("原始图像" , srcImage);
ShowHelpText();
//【2】将输入图像延扩到最佳的尺寸，边界用0补充
int m = getOptimalDFTSize( srcImage.rows );
int n = getOptimalDFTSize( srcImage.cols );
//将添加的像素初始化为0.
Mat padded;
copyMakeBorder(srcImage, padded, 0, m - srcImage.rows, 0, n - srcImage.cols, BORDER_CONSTANT, Scalar::all(0));
//【3】为傅立叶变换的结果(实部和虚部)分配存储空间。
//将planes数组组合合并成一个多通道的数组complexI
Mat planes[] = {Mat_<float>(padded), Mat::zeros(padded.size(), CV_32F)};
Mat complexI;
merge(planes, 2, complexI);
//【4】进行就地离散傅里叶变换
dft(complexI, complexI);
//【5】将复数转换为幅值，即=> log(1 + sqrt(Re(DFT(I))^2 + Im(DFT(I))^2))
split(complexI, planes); // 将多通道数组complexI分离成几个单通道数组，planes[0] = Re(DFT(I), planes[1] = Im(DFT(I))
magnitude(planes[0], planes[1], planes[0]);// planes[0] = magnitude
Mat magnitudeImage = planes[0];
//【6】进行对数尺度(logarithmic scale)缩放
magnitudeImage += Scalar::all(1);
log(magnitudeImage, magnitudeImage);//求自然对数
//【7】剪切和重分布幅度图象限
//若有奇数行或奇数列，进行频谱裁剪
magnitudeImage = magnitudeImage(Rect(0, 0, magnitudeImage.cols & -2, magnitudeImage.rows & -2));
//重新排列傅立叶图像中的象限，使得原点位于图像中心
int cx = magnitudeImage.cols/2;
int cy = magnitudeImage.rows/2;
Mat q0(magnitudeImage, Rect(0, 0, cx, cy)); // ROI区域的左上
Mat q1(magnitudeImage, Rect(cx, 0, cx, cy)); // ROI区域的右上
Mat q2(magnitudeImage, Rect(0, cy, cx, cy)); // ROI区域的左下
Mat q3(magnitudeImage, Rect(cx, cy, cx, cy)); // ROI区域的右下
//交换象限（左上与右下进行交换）
Mat tmp;
q0.copyTo(tmp);
q3.copyTo(q0);
tmp.copyTo(q3);
//交换象限（右上与左下进行交换）
q1.copyTo(tmp);
q2.copyTo(q1);
tmp.copyTo(q2);
//【8】归一化，用0到1之间的浮点值将矩阵变换为可视的图像格式
normalize(magnitudeImage, magnitudeImage, 0, 1, CV_MINMAX);
//【9】显示效果图
imshow("频谱幅值", magnitudeImage);
waitKey();
return 0;
}
int main( int argc, char** argv ){
//capture the video from web cam
VideoCapture cap(0);
// if not success, exit program
if ( !cap.isOpened() ){
cout << "Cannot open the web cam" << endl;
return -1;
}
//set height and width of capture frame
cap.set(CV_CAP_PROP_FRAME_WIDTH,FRAME_WIDTH);
cap.set(CV_CAP_PROP_FRAME_HEIGHT,FRAME_HEIGHT);
//create a window called "Control"
namedWindow("Control", CV_WINDOW_AUTOSIZE);
//Create trackbars in "Control" window
cvCreateTrackbar("LowH", "Control", &iLowH, 179); //Hue (0 - 179)
cvCreateTrackbar("HighH", "Control", &iHighH, 179);
cvCreateTrackbar("LowS", "Control", &iLowS, 255); //Saturation (0 - 255)
cvCreateTrackbar("HighS", "Control", &iHighS, 255);
cvCreateTrackbar("LowV", "Control", &iLowV, 255); //Value (0 - 255)
cvCreateTrackbar("HighV", "Control", &iHighV, 255);
while (true){
Mat imgOriginal;
bool bSuccess = cap.read(imgOriginal); // read a new frame from video
if (!bSuccess){ //if not success, break loop
cout << "Cannot read a frame from video stream" << endl;
break;
}
//Convert the captured frame from BGR to HSV
Mat imgHSV;
cvtColor(imgOriginal, imgHSV, COLOR_BGR2HSV);
//Threshold the image
Mat imgThresholded;
inRange(imgHSV, Scalar(iLowH, iLowS, iLowV), Scalar(iHighH, iHighS, iHighV), imgThresholded);
//morphological opening (remove small objects from the foreground)
erode(imgThresholded, imgThresholded, getStructuringElement(MORPH_ELLIPSE, Size(5, 5)) );
dilate( imgThresholded, imgThresholded, getStructuringElement(MORPH_ELLIPSE, Size(5, 5)) );
//morphological closing (fill small holes in the foreground)
dilate( imgThresholded, imgThresholded, getStructuringElement(MORPH_ELLIPSE, Size(5, 5)) );
erode(imgThresholded, imgThresholded, getStructuringElement(MORPH_ELLIPSE, Size(5, 5)) );
//these two vectors needed for output of findContours
vector< vector<Point> > contours;
vector<Vec4i> hierarchy;
Mat imgContour;
imgThresholded.copyTo(imgContour);
//find contours of filtered image using openCV findContours function
findContours(imgContour,contours,hierarchy,CV_RETR_CCOMP,CV_CHAIN_APPROX_SIMPLE );
//use moments method to find our filtered object
double refArea = 0;
if (hierarchy.size() > 0) {
int numObjects = hierarchy.size();
for (int index = 0; index >= 0; index = hierarchy[index][0]) {
Moments moment = moments((cv::Mat)contours[index]);
double area = moment.m00;
if(area>MIN_OBJECT_AREA){ //jika area kontur lebih besar dari minimum area object maka gambar lingkaran dan tulis koordinat
double x = moment.m10/area;
double y = moment.m01/area;
//double r = sqrt(area/3.14); //jari2 lingkaran
double keliling = arcLength( contours[index], true );
drawContours( imgOriginal, contours, index, Scalar(0,0,255), 1, 8, hierarchy);
putText(imgOriginal, intToString(x) + "," + intToString(y), Point(x,y+20), FONT_HERSHEY_COMPLEX, 0.5, Scalar(0, 255, 0), 1, 8);
putText(imgOriginal, "Luas: " + intToString(area), Point(x,y+40), FONT_HERSHEY_COMPLEX, 0.5, Scalar(0, 255, 0), 1, 8);
putText(imgOriginal, "Keliling: " + intToString(keliling), Point(x,y+60), FONT_HERSHEY_COMPLEX, 0.5, Scalar(0, 255, 0), 1, 8);
}//end if
}//end for
}//end if
//imshow("Contour", imgContour);
//show the thresholded image
imshow("Thresholded Image", imgThresholded);
//show the original image
imshow("Original", imgOriginal);
if (waitKey(5) == 27) {//wait for 'esc' key press for 30ms. If 'esc' key is pressed, break loop
cout << "esc key is pressed by user" << endl;
break;
}
} //end while
return 0;
}
