void the_project::project_binary()
{
get_binary = cvCreateImage(image_size, IPL_DEPTH_8U, 1);
int blue=100;
int green=10;
int red=10;
cvCreateTrackbar("blue","win2",&blue,0xff);
cvCreateTrackbar("green","win2",&green,0xff);
cvCreateTrackbar("red","win2",&red,0xff);
cvNamedWindow("win3");
cout << "Press Space to continue...\n";
while(1){
char a = cvWaitKey(10);
if(a==' ')
break;
cvInRangeS(get_change,cvScalarAll(0),CV_RGB(red,green,blue),get_binary);
cvShowImage("win3",get_binary);
}
//cvWaitKey();
get_path = cvCreateImage(image_size,8,1);
cvCopyImage(get_binary,get_path);
}
void OpenCVAdapter::Loop(){
f_loop=true;
cvNamedWindow (windowNameCap.c_str(), CV_WINDOW_AUTOSIZE);
cvNamedWindow (windowNameThr.c_str(), CV_WINDOW_AUTOSIZE);
HWND hWndCap=(HWND)cvGetWindowHandle(windowNameCap.c_str());
HWND hWndThr=(HWND)cvGetWindowHandle(windowNameThr.c_str());
cvCreateTrackbar(trackbarName.c_str(),windowNameThr.c_str(),&trackbarPosition,100,NULL);
cvCreateTrackbar(trackbarName2.c_str(),windowNameThr.c_str(),&trackbarPosition2,200,NULL);
label = new unsigned char[xnum*ynum];
labeled = new short[xnum*ynum];
int fc=0;
for(;f_loop;){
if(f_start){
GetFrame();
LabelFrame();
ProcFrame();
cvShowImage (windowNameThr.c_str(), frame);
}
cvWaitKey (1000/fps);
}
SAFE_DELETE_ARRAY(label);
SAFE_DELETE_ARRAY(labeled);
cvDestroyWindow (windowNameCap.c_str());
cvDestroyWindow (windowNameThr.c_str());
}
int main( int argc, char** argv )
{
char* filename = argv[1];
if( (image = cvLoadImage("5.bmp",1)) == 0 )
return -1;
kernel = cvCreateMat(kernel_size,kernel_size,CV_32FC1);
src = cvCreateImage(cvSize(image->width,image->height),IPL_DEPTH_8U,1);
cvCvtColor(image,src,CV_BGR2GRAY);
dest = cvCloneImage(src);
cvNamedWindow("Process window",1);
cvShowImage("Process window",src);
cvCreateTrackbar("Variance","Process window", &pos_var,50,Process);
cvCreateTrackbar("Pulsation","Process window",&pos_w ,50,Process);
cvCreateTrackbar("Phase","Process window",&pos_phase ,180,Process);
cvWaitKey(0);
cvReleaseImage(&src);
cvReleaseImage(&image);
cvReleaseImage(&dest);
cvDestroyWindow("Process window");
return 0;
}
int main()
{
int low=0,high=128;
CvCapture* capture;
capture = cvCreateCameraCapture(-1);
IplImage *frame,*grey,*res;
char win[]="video_stream";
char win2[]="outline_feed";
cvNamedWindow(win,CV_WINDOW_AUTOSIZE);
cvNamedWindow(win2,CV_WINDOW_AUTOSIZE);
cvCreateTrackbar("Low",win2,&low,128);
cvCreateTrackbar("High",win2,&high,128);
frame=cvQueryFrame(capture);
grey=cvCreateImage(cvSize(frame->width,frame->height),IPL_DEPTH_8U,1);
res=cvCreateImage(cvSize(frame->width,frame->height),IPL_DEPTH_8U,1);
while(1)
{
frame=cvQueryFrame(capture);
cvCvtColor(frame,grey,CV_BGR2GRAY);
cvCanny(grey,res,low,high,3);
cvShowImage(win,frame);
cvShowImage(win2,res);
char c=cvWaitKey(33);
if(c==27)
break;
}
cvReleaseImage(&frame);
cvReleaseImage(&res);
cvReleaseCapture(&capture);
cvDestroyWindow(win);
cvDestroyWindow(win2);
return 0;
}
/////////////////////////////////////////////////////////////////////////////
// Panel::DetectBlob()
// Description: This is the function which finds the largest blob in an
// image. It is used in this application to locate the tag after the
// InRange function is applied to the original image. It has no return
// value but displays a message indicating whether or not there was a
// blob of size specified in the funtion definition below. This value
// may need to be adjusted based on the camera angle and distance to the
// part.
/////////////////////////////////////////////////////////////////////////////
void Panel::DetectBlob(Mat image, bool debug)
{
Mat grayImage, dilatedEroded, dilated, blurred;
cvtColor(image, grayImage, CV_BGR2GRAY);
// Setup SimpleBlobDetector parameters.
std::vector<KeyPoint> keypoints;
if (!debug)
GetKeyPoints(grayImage, keypoints, false);
else
{
namedWindow("Blob", CV_WINDOW_NORMAL);
cvCreateTrackbar("Blob Area", "Blob", &m_blobArea, 2000);
cvCreateTrackbar("Threshhold", "Blob", &m_lowTagThreshold, 255);
while (true)
{
GetKeyPoints(grayImage, keypoints, true);
if (waitKey(50) == 27)
break;
}
}
// Pass/Fail Message
if (!keypoints.empty())
ShowMessage("Tag detected");
else
ShowMessage("No tag detected");
}
int main( int argc, char** argv )
{
char* filename = 0;
help();
filename = argc == 2 ? argv[1] : (char*)"baboon.jpg";
if( (src = cvLoadImage(filename,1)) == 0 )
{
printf("Cannot load file image %s\n", filename);
help();
return -1;
}
dst = cvCloneImage(src);
//create windows for output images
cvNamedWindow("Open/Close",1);
cvNamedWindow("Erode/Dilate",1);
open_close_pos = erode_dilate_pos = max_iters;
cvCreateTrackbar("iterations", "Open/Close",&open_close_pos,max_iters*2+1,OpenClose);
cvCreateTrackbar("iterations", "Erode/Dilate",&erode_dilate_pos,max_iters*2+1,ErodeDilate);
for(;;)
{
int c;
OpenClose(open_close_pos);
ErodeDilate(erode_dilate_pos);
c = cvWaitKey(0);
if( (char)c == 27 )
break;
if( (char)c == 'e' )
element_shape = CV_SHAPE_ELLIPSE;
else if( (char)c == 'r' )
element_shape = CV_SHAPE_RECT;
else if( (char)c == 'c' )
element_shape = CV_SHAPE_CROSS;
else if( (char)c == ' ' )
element_shape = (element_shape + 1) % 3;
}
//release images
cvReleaseImage(&src);
cvReleaseImage(&dst);
//destroy windows
cvDestroyWindow("Open/Close");
cvDestroyWindow("Erode/Dilate");
return 0;
}
int main( int argc, char** argv )
{
char* filename = argc == 2 ? argv[1] : (char*)"baboon.jpg";
if( (src = cvLoadImage(filename,1)) == 0 )
return -1;
printf( "Hot keys: \n"
"\tESC - quit the program\n"
"\tr - use rectangle structuring element\n"
"\te - use elliptic structuring element\n"
"\tc - use cross-shaped structuring element\n"
"\tSPACE - loop through all the options\n" );
dst = cvCloneImage(src);
//create windows for output images
cvNamedWindow("Open/Close",1);
cvNamedWindow("Erode/Dilate",1);
open_close_pos = erode_dilate_pos = max_iters;
cvCreateTrackbar("iterations", "Open/Close",&open_close_pos,max_iters*2+1,OpenClose);
cvCreateTrackbar("iterations", "Erode/Dilate",&erode_dilate_pos,max_iters*2+1,ErodeDilate);
for(;;)
{
int c;
OpenClose(open_close_pos);
ErodeDilate(erode_dilate_pos);
c = cvWaitKey(0);
if( (char)c == 27 )
break;
if( (char)c == 'e' )
element_shape = CV_SHAPE_ELLIPSE;
else if( (char)c == 'r' )
element_shape = CV_SHAPE_RECT;
else if( (char)c == 'c' )
element_shape = CV_SHAPE_CROSS;
else if( (char)c == ' ' )
element_shape = (element_shape + 1) % 3;
}
//release images
cvReleaseImage(&src);
cvReleaseImage(&dst);
//destroy windows
cvDestroyWindow("Open/Close");
cvDestroyWindow("Erode/Dilate");
return 0;
}
int detect_obstacles()
{
CvCapture* capture = 0;
capture = cvCaptureFromCAM(0);
IplImage *frame, *imHSV;
cvNamedWindow("result", 0);
int Hthresh = 0;
int Vthresh = 0;
cvCreateTrackbar("hue thresh", "result", &Hthresh, 10000, NULL);
cvCreateTrackbar("value thresh", "result", &Vthresh, 100, NULL);
IplImage* h_plane ;
IplImage* s_plane ;
IplImage* v_plane ;
for(;;)
{
frame = cvQueryFrame( capture );
if(frame){
cvSmooth(frame, frame, CV_GAUSSIAN, 25, 25, 0, 0);
cvSetImageROI(frame, cvRect(0,(frame->height/2),frame->width, (frame->height/2)));
h_plane = cvCreateImage( cvGetSize(frame ), 8, 1 );
s_plane = cvCreateImage( cvGetSize( frame), 8, 1 );
v_plane = cvCreateImage( cvGetSize( frame ), 8, 1 );
imHSV = cvCreateImage(cvGetSize(frame), IPL_DEPTH_8U, 3);
cvCvtColor(frame,imHSV,CV_BGR2HSV);
cvCvtPixToPlane( imHSV , h_plane, s_plane, v_plane, 0 );
CvHistogram* hist_h,*hist_v;
int h_bins = H_BINS, v_bins = V_BINS;
hist_h = create_histogram(h_plane, H_MAX, &h_bins);
hist_v = create_histogram(v_plane, V_MAX, &v_bins);
if(process_frame(frame, h_plane, v_plane, hist_h, hist_v, Hthresh, Vthresh)==-1)
break;
}
cvReleaseImage(&imHSV );
cvReleaseImage(&h_plane );
cvReleaseImage(&v_plane );
}
cvReleaseCapture( &capture );
cvDestroyWindow("Display");
// cvDestroyWindow("FinalDisplay");
cvDestroyWindow("VDisplay");
cvDestroyWindow("Result");
cvDestroyWindow("Display1");
return 0;
}
bool _stdcall opencvProcess(LPWSTR csInputPath, LPWSTR csOutputPath)
{
char inputPath[SIZE] = "";
WideCharToMultiByte(950, 0, csInputPath, -1, inputPath, SIZE, NULL, NULL);//wchar_t * to char
char outputPath[SIZE] = "";
WideCharToMultiByte(950, 0, csOutputPath, -1, outputPath, SIZE, NULL, NULL);//wchar_t * to char *
//load image
img = cvLoadImage(inputPath, 1);
if(!img)
return false;
else
{
CvSize size = cvGetSize(img);
int xScreen = GetSystemMetrics(SM_CXSCREEN);
int yScreen = GetSystemMetrics(SM_CYSCREEN);
while(size.width + 100 > xScreen || size.height + 100 > yScreen)
{
size.width /= 1.4;
size.height /= 1.4;
}//end while
cvNamedWindow(windowName, 0);
cvResizeWindow(windowName, size.width, size.height);
cvMoveWindow(windowName, (xScreen-size.width)/2, (yScreen-size.height)/2 );
CvSize panelSize = cvSize(600, 135);
cvNamedWindow(ctrlPanel, 1);
cvResizeWindow(ctrlPanel, panelSize.width, panelSize.height);
cvMoveWindow(ctrlPanel, (xScreen-size.width)/2, (yScreen-size.height)/2 );
cvCreateTrackbar("黑白/彩色", ctrlPanel, &isColor, 1, onTrackbar);
cvCreateTrackbar("水平/垂直", ctrlPanel, &isY, 1, onTrackbar);
cvCreateTrackbar("大小", ctrlPanel, &aSize, 7, onTrackbar);
cvShowImage(ctrlPanel, NULL);
onTrackbar(0);
cvWaitKey(0);
//release
cvSaveImage(outputPath, dst);
cvReleaseImage(&dst);
cvReleaseImage(&img);
cvDestroyAllWindows();
return true;
}//end else
return false;
}//end opencvProcess
ImageConverter(): it_(nh_)
{
image_sub_ = it_.subscribe("/camera/rgb/image_raw", 1, &ImageConverter::imageCb, this);
image_pub_ = it_.advertise("/image_converter/output_video", 1);
cvNamedWindow( "Imagen Fuente");
cvNamedWindow( "Imagen filtrada");
// TrackBar
cvCreateTrackbar("Hue Upper","Imagen filtrada",&hupper,360,NULL);
cvCreateTrackbar("Hue Lower","Imagen filtrada",&hlower,360,NULL);
//cvCreateButton("Save",ImageConverter::callbackButton,NULL,CV_PUSH_BUTTON,0);
}
int main( int argc, char** argv )
{
char* filename = argc == 2 ? argv[1] : (char*)"fruits.jpg";
if( (image = cvLoadImage( filename, 1)) == 0 )
return -1;
// Create the output image
cedge = cvCreateImage(cvSize(image->width,image->height), IPL_DEPTH_8U, 3);
// Convert to grayscale
gray = cvCreateImage(cvSize(image->width,image->height), IPL_DEPTH_8U, 1);
edge = cvCreateImage(cvSize(image->width,image->height), IPL_DEPTH_8U, 1);
cvCvtColor(image, gray, CV_BGR2GRAY);
// Create a window
cvNamedWindow(wndname, 1);
// create a toolbar
cvCreateTrackbar(tbarname, wndname, &edge_thresh, 100, on_trackbar);
// Show the image
on_trackbar(0);
// Wait for a key stroke; the same function arranges events processing
cvWaitKey(0);
cvReleaseImage(&image);
cvReleaseImage(&gray);
cvReleaseImage(&edge);
cvDestroyWindow(wndname);
return 0;
}
void COpenCVMFCView::OnThresholding1()
{
// TODO: Add your command handler code here
threImage = cvCloneImage(workImg);
cvFlip(threImage);
threImage0 = cvCloneImage(threImage);
cvNamedWindow(threWin, 0);
cvResizeWindow(threWin, 300, 320);
cvCreateTrackbar( "Thresh", threWin, &Threshold, 255, onThreChange );
onThreChange(0);
cvWaitKey(0);
cvReleaseImage(&threImage);
cvDestroyWindow(threWin);
cvFlip(threImage0);
m_dibFlag = imageReplace(threImage0,&workImg);
m_ImageType = -1;
Invalidate();
}
int main( int argc, char** argv )
{
const char* filename = argc == 2 ? argv[1] : (char*)"stuff.jpg";
// load image and force it to be grayscale
if( (image03 = cvLoadImage(filename, 0)) == 0 )
return -1;
// Create the destination images
image02 = cvCloneImage( image03 );
image04 = cvCloneImage( image03 );
// Create windows.
cvNamedWindow("Source", 1);
cvNamedWindow("Result", 1);
// Show the image.
cvShowImage("Source", image03);
// Create toolbars. HighGUI use.
cvCreateTrackbar( "Threshold", "Result", &slider_pos, 255, process_image );
process_image(0);
// Wait for a key stroke; the same function arranges events processing
cvWaitKey(0);
cvReleaseImage(&image02);
cvReleaseImage(&image03);
cvDestroyWindow("Source");
cvDestroyWindow("Result");
return 0;
}
int readVideoWithATrackbar(char *fileName)
{
cvNamedWindow( "win_1", CV_WINDOW_AUTOSIZE );
g_capture = cvCreateFileCapture( fileName );
int frames = (int) cvGetCaptureProperty(
g_capture,
CV_CAP_PROP_FRAME_COUNT
);
if( frames != 0 ) {
cvCreateTrackbar(
"Position",
"win_1",
&g_slider_position,
frames,
onTrackbarSlide
);
}
IplImage* frame;
while (1) {
frame = cvQueryFrame( g_capture );
if ( !frame ) {
break;
}
cvShowImage( "win_1", frame );
char c = cvWaitKey(33);
if ( c == 27 ) {
break;
}
}
return (0);
}
void AdaptiveHistogramCamshift::ShowControlsGUI()
{
cvNamedWindow(m_controlsGUIWndName.c_str(), 1);
cvNamedWindow("Trackbars", 1);
if (!m_showControlsGUI)
{
cvMoveWindow(m_controlsGUIWndName.c_str(), m_frameSize.width + 10, 0);
cvCreateTrackbar(ControlNames[ControlName_VMin], "Trackbars", &m_vMin, 256, 0);
cvCreateTrackbar(ControlNames[ControlName_VMax], "Trackbars", &m_vMax, 256, 0);
cvCreateTrackbar(ControlNames[ControlName_SMin], "Trackbars", &m_sMin, 256, 0);
cvCreateTrackbar(ControlNames[ControlName_SBox], "Trackbars", &m_sBox, 64, 0);
cvCreateTrackbar(ControlNames[ControlName_AgingFactor], "Trackbars", &m_ageRatio, 100, 0);
cvSetMouseCallback(m_controlsGUIWndName.c_str(), &AdaptiveHistogramCamshift::OnMouse, &m_id);
}
m_showControlsGUI = true;
}
void set_mouse_bar(const char* win_name){
cvCreateTrackbar("avg-range",
win_name,
&g_mouse,
1,
onTrackbarMouse);
}
int main( int argc, char** argv ) {
cvNamedWindow( "Example3", CV_WINDOW_AUTOSIZE );
g_capture = cvCreateFileCapture( argv [1] );
int frames = (int) cvGetCaptureProperty(
g_capture,
CV_CAP_PROP_FRAME_COUNT
);
if( frames!= 0 ) {
cvCreateTrackbar(
"Position",
"Example3",
&g_slider_position,
frames,
onTrackbarSlide
);
}
IplImage* frame;
while(1) {
frame = cvQueryFrame( g_capture );
if( !frame ) break;
cvShowImage( "Example3", frame );
char c = cvWaitKey(33);
if( c == 27 ) break;
}
cvReleaseCapture( &g_capture );
cvDestroyWindow( "Example3" );
return(0);
}
int main()
{
int thresh=25;
CvCapture* capture;
capture = cvCreateCameraCapture(-1);
IplImage *frame,*res;
char win[]="video_stream";
char win2[]="outline_feed";
cvNamedWindow(win,CV_WINDOW_AUTOSIZE);
cvNamedWindow(win2,CV_WINDOW_AUTOSIZE);
cvCreateTrackbar("Threshold",win2,&thresh,128);
while(1)
{
frame=cvQueryFrame(capture);
res = findedge(frame,thresh);
clearnoise(res,0, 3);
clearnoise(res,1, 3);
cvShowImage(win,frame);
cvShowImage(win2,res);
if(cvWaitKey(50)==27)
break;
}
cvReleaseImage(&frame);
cvReleaseImage(&res);
cvReleaseCapture(&capture);
cvDestroyWindow(win);
cvDestroyWindow(win2);
return 0;
}
void ObstacleDetector::interpret() {
if (debug){
cvNamedWindow("Control Box", 1);
}
int s=5;
if (debug) {
cvCreateTrackbar("Kernel 1", "Control Box", &s, 20);
cv::namedWindow("Raw Scan", 0);
cv::imshow("Raw Scan", img);
cv::waitKey(WAIT_TIME);
}
int dilation_size = EXPAND_OBS;
cv::Mat element = cv::getStructuringElement( cv::MORPH_ELLIPSE,
cv::Size( 2*dilation_size + 1, 2*dilation_size+1 ),
cv::Point( dilation_size, dilation_size ) );
cv::dilate(img, img, element);
if (debug) {
cv::namedWindow("Dilate Filter", 1);
cv::imshow("Dilate Filter", img);
cv::waitKey(WAIT_TIME);
}
publishData();
}
// Capture live image stream (e.g., for adjusting object placement).
int camPreview(CvCapture* capture, struct slParams* sl_params, struct slCalib* sl_calib){
// Create a window to display captured frames.
IplImage* cam_frame = cvQueryFrame2(capture, sl_params);
IplImage* proj_frame = cvCreateImage(cvSize(sl_params->proj_w, sl_params->proj_h), IPL_DEPTH_8U, 1);
cvNamedWindow("camWindow", CV_WINDOW_AUTOSIZE);
cvCreateTrackbar("Cam. Gain", "camWindow", &sl_params->cam_gain, 100, NULL);
cvCreateTrackbar("Proj. Gain", "camWindow", &sl_params->proj_gain, 100, NULL);
HWND camWindow = (HWND)cvGetWindowHandle("camWindow");
BringWindowToTop(camWindow);
cvWaitKey(1);
// Capture live image stream.
int cvKey = -1, cvKey_temp = -1;
while(1){
// Project white image.
cvSet(proj_frame, cvScalar(255));
cvScale(proj_frame, proj_frame, 2.*(sl_params->proj_gain/100.), 0);
cvShowImage("projWindow", proj_frame);
cvKey_temp = cvWaitKey(1);
if(cvKey_temp != -1)
cvKey = cvKey_temp;
// Capture next frame and update display window.
cam_frame = cvQueryFrame2(capture, sl_params);
cvScale(cam_frame, cam_frame, 2.*(sl_params->cam_gain/100.), 0);
cvShowImageResampled("camWindow", cam_frame, sl_params->window_w, sl_params->window_h);
cvKey_temp = cvWaitKey(10);
if(cvKey_temp != -1)
cvKey = cvKey_temp;
// Exit on user interaction.
if(cvKey != -1)
break;
}
// Project black image.
cvZero(proj_frame);
cvShowImage("projWindow", proj_frame);
cvKey_temp = cvWaitKey(1);
// Return without errors.
cvDestroyWindow("camWindow");
cvReleaseImage(&proj_frame);
return 0;
}
int main(int argc, char** argv) {
cv::VideoCapture cap(1); // open cam 1
if(!cap.isOpened()) // check if we succeeded
return -1;
cv::namedWindow("input");
cv::namedWindow("mask");
cv::namedWindow("output");
std::cout << "Width: " << cap.get(CV_CAP_PROP_FRAME_WIDTH) << std::endl;
std::cout << "Height: " << cap.get(CV_CAP_PROP_FRAME_HEIGHT) << std::endl;
cvCreateTrackbar("Val Thres", "input", &valHistBinThres, 500, NULL);
cvCreateTrackbar("Sat Thres", "input", &satHistBinThres, 500, NULL);
cvCreateTrackbar("Hue Thres", "input", &hueHistBinThres, 500, NULL);
while(true) {
cv::Mat src;
cap >> src;
std::vector<contour> drawVec;
drawVec.push_back(refTrpz);
cv::Mat tmp;
src.copyTo(tmp);
cv::drawContours(tmp, drawVec, -1, cv::Scalar(255,255,255));
cv::imshow("input", tmp);
cv::Mat obsMask = obs_getObsMask(src);
cv::imshow("mask", obsMask);
cv::Mat edgedet;
cv::blur(obsMask, edgedet, cv::Size(3,3));
cv::Mat detOut;
cv::Canny(edgedet, detOut, 10, 20);
cv::imshow("output", detOut);
if(cv::waitKey(30) > 0) break;
}
return 0;
}
int main( int argc, char** argv )
{
int i, j;
CvMemStorage* storage = cvCreateMemStorage(0);
IplImage* img = cvCreateImage( cvSize(w,w), 8, 1 );
cvZero( img );
for( i=0; i < 6; i++ )
{
int dx = (i%2)*250 - 30;
int dy = (i/2)*150;
CvScalar white = cvRealScalar(255);
CvScalar black = cvRealScalar(0);
if( i == 0 )
{
for( j = 0; j <= 10; j++ )
{
double angle = (j+5)*CV_PI/21;
cvLine(img, cvPoint(cvRound(dx+100+j*10-80*cos(angle)),
cvRound(dy+100-90*sin(angle))),
cvPoint(cvRound(dx+100+j*10-30*cos(angle)),
cvRound(dy+100-30*sin(angle))), white, 1, 8, 0);
}
}
cvEllipse( img, cvPoint(dx+150, dy+100), cvSize(100,70), 0, 0, 360, white, -1, 8, 0 );
cvEllipse( img, cvPoint(dx+115, dy+70), cvSize(30,20), 0, 0, 360, black, -1, 8, 0 );
cvEllipse( img, cvPoint(dx+185, dy+70), cvSize(30,20), 0, 0, 360, black, -1, 8, 0 );
cvEllipse( img, cvPoint(dx+115, dy+70), cvSize(15,15), 0, 0, 360, white, -1, 8, 0 );
cvEllipse( img, cvPoint(dx+185, dy+70), cvSize(15,15), 0, 0, 360, white, -1, 8, 0 );
cvEllipse( img, cvPoint(dx+115, dy+70), cvSize(5,5), 0, 0, 360, black, -1, 8, 0 );
cvEllipse( img, cvPoint(dx+185, dy+70), cvSize(5,5), 0, 0, 360, black, -1, 8, 0 );
cvEllipse( img, cvPoint(dx+150, dy+100), cvSize(10,5), 0, 0, 360, black, -1, 8, 0 );
cvEllipse( img, cvPoint(dx+150, dy+150), cvSize(40,10), 0, 0, 360, black, -1, 8, 0 );
cvEllipse( img, cvPoint(dx+27, dy+100), cvSize(20,35), 0, 0, 360, white, -1, 8, 0 );
cvEllipse( img, cvPoint(dx+273, dy+100), cvSize(20,35), 0, 0, 360, white, -1, 8, 0 );
}
cvNamedWindow( "image", 1 );
cvShowImage( "image", img );
cvFindContours( img, storage, &contours, sizeof(CvContour),
CV_RETR_TREE, CV_CHAIN_APPROX_SIMPLE, cvPoint(0,0) );
// comment this out if you do not want approximation
contours = cvApproxPoly( contours, sizeof(CvContour), storage, CV_POLY_APPROX_DP, 3, 1 );
cvNamedWindow( "contours", 1 );
cvCreateTrackbar( "levels+3", "contours", &levels, 7, on_trackbar );
on_trackbar(0);
cvWaitKey(0);
cvReleaseMemStorage( &storage );
cvReleaseImage( &img );
return 0;
}
OpenniFilter::OpenniFilter() : viewer("PCL OpenNI Viewer")
{
// initialize display
namedWindow(windowTracker, CV_WINDOW_AUTOSIZE);
namedWindow(windowFilter, CV_WINDOW_AUTOSIZE);
setMouseCallback(windowTracker, mouseCallback, this);
// initialize filter windows
namedWindow(windowParam, CV_WINDOW_AUTOSIZE);
// the hue should be in accordence with what user has chosen
cvCreateTrackbar("Hue Deviation", windowParam.c_str(), &iHueDev, 255);
cvCreateTrackbar("LowS", windowParam.c_str(), &iLowS, 255); //Saturation (0 - 255)
cvCreateTrackbar("HighS", windowParam.c_str(), &iHighS, 255);
cvCreateTrackbar("LowV", windowParam.c_str(), &iLowV, 255); //Value (0 - 255)
cvCreateTrackbar("HighV", windowParam.c_str(), &iHighV, 255);
}
int main(int argc, char **argv)
{
int thresh = 128;
int erode = 0;
int dilate = 0;
int do_contour = 0;
IplImage *image_bw = cvCreateImage(SIZE, 8, 1);
IplImage *image_thresh = cvCreateImage(SIZE, 8, 1);
IplImage *image_temp = cvCreateImage(SIZE, 8, 1);
cvNamedWindow("config", CV_WINDOW_AUTOSIZE);
cvCreateTrackbar("threshold", "config", &thresh, 255, NULL);
cvCreateTrackbar("erode", "config", &erode, 10, NULL);
cvCreateTrackbar("dilate", "config", &dilate, 10, NULL);
cvCreateTrackbar("contour", "config", &do_contour, 1, NULL);
CvMemStorage *storage = cvCreateMemStorage();
while (cvWaitKey(10) < 0) {
IplImage *image = freenect_sync_get_rgb_cv(0);
if (!image) {
printf("Error: Kinect not connected?\n");
return -1;
}
cvCvtColor(image, image, CV_RGB2BGR);
cvCvtColor(image, image_bw, CV_RGB2GRAY);
cvThreshold(image_bw, image_thresh, thresh, 255, CV_THRESH_BINARY);
cvErode(image_thresh, image_thresh, NULL, erode);
cvDilate(image_thresh, image_thresh, NULL, dilate);
if (do_contour) {
CvSeq *contours;
cvCopy(image_thresh, image_temp);
cvFindContours(image_temp, storage, &contours);
cvDrawContours(image, contours, CV_RGB(0, 255, 0), CV_RGB(0, 255, 255), 1);
}
cvShowImage("RGB", image);
cvShowImage("BW", image_bw);
cvShowImage("THRESH", image_thresh);
}
return 0;
}
bool _stdcall opencvProcess(LPWSTR csInputPath, LPWSTR csOutputPath)
{
char inputPath[SIZE] = "";
WideCharToMultiByte(950, 0, csInputPath, -1, inputPath, SIZE, NULL, NULL);//wchar_t * to char
char outputPath[SIZE] = "";
WideCharToMultiByte(950, 0, csOutputPath, -1, outputPath, SIZE, NULL, NULL);//wchar_t * to char *
//load image
img = cvLoadImage(inputPath, -1);
if(!img)
return false;
else
{
CvSize size = cvGetSize(img);
int xScreen = GetSystemMetrics(SM_CXSCREEN);
int yScreen = GetSystemMetrics(SM_CYSCREEN);
while(size.width + 100 > xScreen || size.height + 100 > yScreen)
{
size.width /= 1.4;
size.height /= 1.4;
}//end while
size.height += 90;
cvNamedWindow(windowName, 0);
cvResizeWindow(windowName, size.width, size.height);
cvMoveWindow(windowName, (xScreen-size.width)/2, (yScreen-size.height)/2 );
int initValueW = W;
int initValueH = H;
cvCreateTrackbar("寬", windowName, &initValueW, img->width / 10, onTrackbarW);
cvCreateTrackbar("高", windowName, &initValueH, img->height / 10, onTrackbarH);
work();
cvShowImage(windowName, dst);
cvWaitKey();
cvSaveImage(outputPath, dst);
cvDestroyAllWindows();
cvReleaseImage(&img);
cvReleaseImage(&dst);
return true;
}//end else
return false;
}//end opencvProcess
int morphy1(char*filename)
{
//char *filename =argc ==2?argv[1]:(char *)"lena.jpg";
if( (src = cvLoadImage(filename,1)) == 0 )
return -1;
dst=cvCloneImage(src);
cvNamedWindow("Open/Close",1);
cvNamedWindow("Erode/Dilate",1);
open_close_pos = erode_dilate_pos = max_iters; //初始设置，然后往两边偏移
cvCreateTrackbar("iterations","Open/Close",&open_close_pos,max_iters*2+1,OpenClose);
cvCreateTrackbar("iterations","Erode/Dilate",&erode_dilate_pos,max_iters*2+1,ErodeDilate);
for (;;)
{
int c;
OpenClose(open_close_pos);
ErodeDilate(erode_dilate_pos);
c= cvWaitKey(0);
if (c==27) {
break;
}
switch(c)
{
case 'e':
element_shape=CV_SHAPE_ELLIPSE;
break;
case 'r':
element_shape=CV_SHAPE_RECT;
break;
case 't':
element_shape=(element_shape+1)%3;
break;
case 'c':
element_shape=CV_SHAPE_CROSS;
break;
default:
break;
}
}
cvReleaseImage(&src);
cvReleaseImage(&dst);
cvDestroyWindow("Open/Close");
cvDestroyWindow("Erode/Dilate");
return 0;
}
void Open_GUI()
{
int i;
//Make the eye image (in monochrome):
eye_image=cvCreateImageHeader(cvSize(RESOLUTION_WIDTH,RESOLUTION_HEIGHT), 8, 1 );
eye_image->imageData=(char *)malloc(RESOLUTION_WIDTH*RESOLUTION_HEIGHT);
//Make the eye image (in monochrome):
threshold_image = cvCloneImage(eye_image);
//Make the ellipse image (in RGB) :
ellipse_image=cvCreateImageHeader(cvSize(RESOLUTION_WIDTH,RESOLUTION_HEIGHT), 8, 3 );
ellipse_image->imageData=(char *)malloc(RESOLUTION_WIDTH*RESOLUTION_HEIGHT*3);
//Make the scene image:
scene_image=cvCreateImageHeader(cvSize(RESOLUTION_WIDTH,RESOLUTION_HEIGHT), 8, 3 );
scene_image->imageData=(char *)malloc(RESOLUTION_WIDTH*RESOLUTION_HEIGHT*3);
//Make the grayscale scene image:
scene_image_grayscale=cvCreateImageHeader(cvSize(RESOLUTION_WIDTH,RESOLUTION_HEIGHT), 8, 1 );
scene_image_grayscale->imageData=(char *)malloc(RESOLUTION_WIDTH*RESOLUTION_HEIGHT);
//Create the windows
cvNamedWindow(control_window, 1);
cvNamedWindow(ellipse_window, 0);
cvNamedWindow(scene_window, 0);
cvNamedWindow(eye_window, 0);
cvNamedWindow(original_eye_window, 0);
//setup the mouse call back funtion here for calibration
cvSetMouseCallback(scene_window, on_mouse_scene, NULL);
cvSetMouseCallback(eye_window, on_mouse_eye, NULL);
cvCreateTrackbar("Edge Threshold", control_window, &pupil_edge_thres, 255, NULL );
cvCreateTrackbar("Rays Number", control_window, &rays, 180, NULL );
cvCreateTrackbar("Min Feature Candidates", control_window, &min_feature_candidates, 30, NULL );
cvCreateTrackbar("Corneal Window Size",control_window, &cr_window_size, FRAMEH, NULL );
//Init colors
White = CV_RGB(255,255,255);
Red = CV_RGB(255,0,0);
Green = CV_RGB(0,255,0);
Blue = CV_RGB(0,0,255);
Yellow = CV_RGB(255,255,0);
}
int main(int argc, char** argv)
{
if (argc == 1) {
printf("Usage: %s <input> <config>\n", argv[0]);
return 0;
}
char* filename = (argc > 1 ? argv[1] : (char*)"input.jpg");
profile_name = (argc > 2 ? argv[2] : (char*)"blue_goal.yml");
fs = cvOpenFileStorage(profile_name, 0, CV_STORAGE_READ, NULL);
Hmax = cvReadIntByName(fs, NULL, "m_100", m_100);
Hmax = cvReadIntByName(fs, NULL, "Hmax", Hmax);
Smax = cvReadIntByName(fs, NULL, "Smax", Smax);
Vmax = cvReadIntByName(fs, NULL, "Vmax", Vmax);
Hmin = cvReadIntByName(fs, NULL, "Hmin", Hmin);
Smin = cvReadIntByName(fs, NULL, "Smin", Smin);
Vmin = cvReadIntByName(fs, NULL, "Vmin", Vmin);
//minH = cvReadIntByName(fs, NULL, "minH", minH);
printf("%s\n", filename);
img = cvLoadImage(filename, 1);
visy_img_alloc(&img, cvGetSize(img), 8, 1);
imgThreshed = cvCreateImage(cvGetSize(img), 8, 1);
//cvSmooth( imgHSV, imgHSV, CV_GAUSSIAN, 7, 7 );
//cvInRangeS(imgHSV, cvScalar(20, 100, 100), cvScalar(30, 255, 255), imgThreshed);
//cvInRangeS(imgHSV, cvScalar(100, 100, 100), cvScalar(120, 255, 255), imgThreshed);
//cvInRangeS(imgHSV, cvScalar(0.11*256, 0.60*256, 0.20*256, 0),
// cvScalar(0.14*256, 1.00*256, 1.00*256, 0), imgThreshed);
cvNamedWindow("origin", CV_WINDOW_AUTOSIZE);
cvNamedWindow("treshed", CV_WINDOW_AUTOSIZE);
cvNamedWindow("graph", CV_WINDOW_AUTOSIZE);
cvCreateTrackbar("m_100", "treshed", &m_100, 255, onTrack);
cvCreateTrackbar("Hmin", "treshed", &Hmin, 180, onTrack);
cvCreateTrackbar("Smin", "treshed", &Smin, 255, onTrack);
cvCreateTrackbar("Vmin", "treshed", &Vmin, 255, onTrack);
cvCreateTrackbar("Hmax", "treshed", &Hmax, 180, onTrack);
cvCreateTrackbar("Smax", "treshed", &Smax, 255, onTrack);
cvCreateTrackbar("Vmax", "treshed", &Vmax, 255, onTrack);
//cvCreateTrackbar("minH", "treshed", &minH, 255, onTrack);
onTrack(0);
//cvSaveImage("hsv.jpg", imgHSV);
while(cvWaitKey(0) != 97);
return 0;
}
void Kinect::camshiftarr()
{
//cvSetMouseCallback("CamShiftDemo", on_mouse, 0);
cvCreateTrackbar("Vmin", "CamShiftDemo", &vmin, 256, 0);
cvCreateTrackbar("Vmax", "CamShiftDemo", &vmax, 256, 0);
cvCreateTrackbar("Smin", "CamShiftDemo", &smin, 256, 0);
//if (!KinectColorImg)
//{
hsv = cvCreateImage(cvGetSize(KinectColorImg), 8, 3);
hue = cvCreateImage(cvGetSize(KinectColorImg), 8, 1);
mask = cvCreateImage(cvGetSize(KinectColorImg), 8, 1);
backproject = cvCreateImage(cvGetSize(KinectColorImg), 8, 1);
//히스토그램 생성 (채널,size ,표현방식,x축범위,막대간격
hist = cvCreateHist(1, &hdims, CV_HIST_ARRAY, &hranges, 1);
//히스토 그램 출력할 공간 생성 후 초기화
histimg = cvCreateImage(cvSize(320, 200), 8, 3);
cvZero(histimg);
//}
//
//cvCvtColor(KinectColorImg, hsv, CV_BGR2HSV);
////
if (!hsv)
{
hsv = cvCreateImage(cvGetSize(KinectColorImg), 8, 3);
hue = cvCreateImage(cvGetSize(KinectColorImg), 8, 1);
mask = cvCreateImage(cvGetSize(KinectColorImg), 8, 1);
backproject = cvCreateImage(cvGetSize(KinectColorImg), 8, 1);
//히스토그램 생성 (채널,size ,표현방식,x축범위,막대간격
hist = cvCreateHist(1, &hdims, CV_HIST_ARRAY, &hranges, 1);
//히스토 그램 출력할 공간 생성 후 초기화
histimg = cvCreateImage(cvSize(320, 200), 8, 3);
cvZero(histimg);
}
if (trackObject)
{
}
}
int main(int argc, char **argv)
{
ros::init(argc, argv, "image_view");
if (ros::names::remap("image")=="image"){
ROS_WARN("Topic 'image' has not been remapped! Typical command-line usage:\n"
"/t$ rosrun movesense_sensor image_view image:=<image topic>");
}
ros::NodeHandle nh;
ros::NodeHandle local_nh("~");
// Default window name is the resolved topic name
std::string topic = nh.resolveName("image");
local_nh.param("window_name",g_window_name,topic);
// Handle window size
bool autosize;
local_nh.param("autosize",autosize, true);
cv::namedWindow(g_window_name, autosize ? (CV_WINDOW_AUTOSIZE | CV_WINDOW_KEEPRATIO | CV_GUI_EXPANDED) : 0);
// CreateTrackbar
cvCreateTrackbar( "Depth_Min", g_window_name.c_str(), &MIN_DEPTH, 10000);
cvCreateTrackbar( "Depth_Max", g_window_name.c_str(), &MAX_DEPTH, 50000);
// Start the OpenCV window thread so we don't have to waitKey() somewhere
cv::startWindowThread();
// Handle transport
std::string transport;
local_nh.param("image_transport", transport, std::string("raw"));
ROS_INFO_STREAM("Using transport \"" << transport << "\"");
image_transport::ImageTransport it(nh);
image_transport::TransportHints hints(transport, ros::TransportHints(), local_nh);
image_transport::Subscriber sub = it.subscribe(topic, 1, imageCallback, hints);
ros::spin();
cv::destroyWindow(g_window_name);
return 0;
}
