Someone please help me solve this problem thanks

#include "opencv2/highgui/highgui.hpp"
#include <iostream>

using namespace cv;
using namespace std;


IplImage *rotateImage(const IplImage *src, int angleDegrees, double zoom)
{    
    IplImage *imageRotated = cvCloneImage(src);


    CvMat* rot_mat = cvCreateMat(2,3,CV_32FC1);

    // Compute rotation matrix
    CvPoint2D32f center = cvPoint2D32f( cvGetSize(imageRotated).width/2, cvGetSize(imageRotated).height/2 );
    cv2DRotationMatrix( center, angleDegrees, zoom, rot_mat );

    // Do the transformation
    cvWarpAffine( src, imageRotated, rot_mat );

    return imageRotated;
}


int main()
{

          IplImage* img;
          IplImage* rotated_img;

          int angle=0;
          int zoom=24;

          //creating the window with 2 track bars
          cvNamedWindow("MyWindow");
          cvCreateTrackbar("Angle", "MyWindow", &angle, 360, 0);
          cvCreateTrackbar("Zoom", "MyWindow", &zoom, 99, 0);

          while(true){
              //load the original image
              img = cvLoadImage("C:/MyPic.jpg");

              //rotate the image
              rotated_img=rotateImage( img, angle, (zoom+1)/25.0 );

              //display the rotated image
              cvShowImage("MyWindow", rotated_img); 

              //clean up
              cvReleaseImage(&img);
              cvReleaseImage(&rotated_img);

              //if user press 'ESC' button, program quit the while loop
              int c=cvWaitKey(50);               
              if(c==27) break;
          }


          cvDestroyWindow("MyWindow");

          return 0;
}

Some one please help me i tried many ways but did not work

#include <opencv/cvaux.h>
#include <opencv/highgui.h>
#include <opencv/cxcore.h>
#include <stdio.h>
#include <stdlib.h>

include "stdafx.h"

include <cv.h>

include <highgui.h>

//This function threshold the HSV image and create a binary image IplImage* GetThresholdedImage(IplImage* imgHSV){
IplImage* imgThresh=cvCreateImage(cvGetSize(imgHSV),IPL_DEPTH_8U, 1); cvInRangeS(imgHSV, cvScalar(170,160,60), cvScalar(180,256,256), imgThresh); return imgThresh; }

int main(){ CvCapture* capture =0;

  capture = cvCaptureFromCAM(0);
  if(!capture){
        printf("Capture failure\n");
        return -1;
  }

  IplImage* frame=0;

　 cvNamedWindow("Video");
cvNamedWindow("Ball");

  //iterate through each frames of the video      
  while(true){

        frame = cvQueryFrame(capture);            
        if(!frame) break;

        frame=cvCloneImage(frame); 
        cvSmooth(frame, frame, CV_GAUSSIAN,3,3); //smooth the original image using Gaussian kernel

        IplImage* imgHSV = cvCreateImage(cvGetSize(frame), IPL_DEPTH_8U, 3); 
        cvCvtColor(frame, imgHSV, CV_BGR2HSV); //Change the color format from BGR to HSV
        IplImage* imgThresh = GetThresholdedImage(imgHSV);

        cvSmooth(imgThresh, imgThresh, CV_GAUSSIAN,3,3); //smooth the binary image using Gaussian kernel

        cvShowImage("Ball", imgThresh);            
        cvShowImage("Video", frame);

        //Clean up used images
        cvReleaseImage(&imgHSV);
        cvReleaseImage(&imgThresh);            
        cvReleaseImage(&frame);

        //Wait 50mS
        int c = cvWaitKey(10);
        //If 'ESC' is pressed, break the loop
        if((char)c==27 ) break;      
  }

  cvDestroyAllWindows() ;
  cvReleaseCapture(&capture);     

  return 0;

}

/** * @function findContours_Demo.cpp * @brief Demo code to find contours in an image * @author OpenCV team */

include "opencv2/highgui/highgui.hpp"

include "opencv2/imgproc/imgproc.hpp"

include <iostream>

include <stdio.h>

include <stdlib.h>

using namespace cv; using namespace std;

Mat src; Mat src_gray; int thresh = 100; int max_thresh = 255; RNG rng(12345);

/// Function header void thresh_callback(int, void* );

/* * @function main */ int main( int, char* argv ) { /// Load source image and convert it to gray src = imread( argv[1], 1 );

/// Convert image to gray and blur it cvtColor( src, src_gray, COLOR_BGR2GRAY ); blur( src_gray, src_gray, Size(3,3) );

/// Create Window const char* source_window = "Source"; namedWindow( source_window, WINDOW_AUTOSIZE ); imshow( source_window, src );

createTrackbar( " Canny thresh:", "Source", &thresh, max_thresh, thresh_callback ); thresh_callback( 0, 0 );

waitKey(0); return(0); }

/* * @function thresh_callback */ void thresh_callback(int, void ) { Mat canny_output; vector<vector<point> > contours; vector<vec4i> hierarchy;

/// Detect edges using canny Canny( src_gray, canny_output, thresh, thresh*2, 3 ); /// Find contours findContours( canny_output, contours, hierarchy, RETR_TREE, CHAIN_APPROX_SIMPLE, Point(0, 0) );

/// Draw contours Mat drawing = Mat::zeros( canny_output.size(), CV_8UC3 ); for( size_t i = 0; i< contours.size(); i++ ) { Scalar color = Scalar( rng.uniform(0, 255), rng.uniform(0,255), rng.uniform(0,255) ); drawContours( drawing, contours, (int)i, color, 2, 8, hierarchy, 0, Point() ); }

/// Show in a window namedWindow( "Contours", WINDOW_AUTOSIZE ); imshow( "Contours", drawing ); }