import cv2 as cv 
import numpy as np 
img = cv.imread('image.jpg', cv.IMREAD_GRAYSCALE)
img = cv.medianBlur(img,33)
assert img is not None, "file could not be read, check with os.path.exists()"
image = cv.adaptiveThreshold(img,255,cv.ADAPTIVE_THRESH_GAUSSIAN_C,\
            cv.THRESH_BINARY,73,2)
blur = cv.blur(image,(5,5))
circles = cv.HoughCircles(blur,cv.HOUGH_GRADIENT,1,20,
                            param1=50,param2=30,minRadius=30)
circles = np.uint16(np.around(circles))
for i in circles[0,:]:
    # draw the outer circle
    cv.circle(circles,(i[0],i[1]),i[2],(0,255,0),2)
    # draw the center of the circle
    cv.circle(circles,(i[0],i[1]),2,(0,0,255),3)
cv.imshow('Objects Detected',blur)
cv.waitKey(0)

//Circle fitting (Simple Least Square)
void FitCircle( const std::vector<cv::Point> &Ps, cv::Point2f &C, float &r )
{
	cv::Mat A( (int)Ps.size(), 3, CV_32F );
	cv::Mat B( (int)Ps.size(), 1, CV_32F );
	for( int i=0; i<Ps.size(); ++i )
	{
		const auto &P = Ps[i];
		A.at<float>( i,0 ) = (float)P.x;
		A.at<float>( i,1 ) = (float)P.y;
		A.at<float>( i,2 ) = 1.0f;
		B.at<float>( i ) = (float)(P.x*P.x + P.y*P.y);
	}
	cv::Mat X;
	cv::solve( A,B, X, cv::DECOMP_SVD );
	C.x = X.at<float>(0) * 0.5f;
	C.y = X.at<float>(1) * 0.5f;
	r = sqrt( X.at<float>(2) + C.x*C.x + C.y*C.y );
}
int main()
{
	//Load image as gray-scale
	cv::Mat SrcImg = cv::imread( "SpotLight.png", cv::IMREAD_GRAYSCALE );
	if( SrcImg.empty() )return 0;
	cv::imshow( "Src", SrcImg );
	//Decide threshold value range [Min,Max) to try
	int Min=0, Max=255;
	{
		unsigned int Hist[256] = { 0 };
		for( int y=0; y<SrcImg.rows; ++y )
		{
			const unsigned char *p = SrcImg.ptr<unsigned char>(y);
			for( int x=0; x<SrcImg.cols; ++x, ++p )
			{	++Hist[ *p ];	}
		}
		{//Decide Min
			unsigned int Thresh = cvRound( SrcImg.rows * SrcImg.cols * 0.9 );
			unsigned int Sum = 0;
			while( Sum < Thresh ){	Sum += Hist[Min];	++Min;	}
		}
		//Decide Max
		while( Hist[Max]==0 ){	--Max;	}
	}
	
	//Try for each threshold
	for( int Thresh=Min; Thresh<Max-1; ++Thresh )
	{
		//Binalize
		cv::Mat Bin;
		cv::threshold( SrcImg, Bin, Thresh, 255, cv::THRESH_BINARY );
		//Fit circle to largest contour
		//to evaluate how close the binalization result shape is to a circle
		cv::Point2f Center;
		float Radius;
		double FittingErr = 0;
		{
			//Extract Largest Contour
			std::vector< std::vector<cv::Point> > Conts;
			cv::findContours( Bin, Conts, cv::RETR_EXTERNAL, cv::CHAIN_APPROX_NONE );
			if( Conts.empty() )continue;
			int iLargestCont = 0;
			double MaxArea = 0;
			for( int i=0; i<Conts.size(); ++i )
			{
				double Area = cv::contourArea( Conts[i] );
				if( Area >= MaxArea ){	MaxArea = Area;	iLargestCont = i;	}
			}
			//Fit circle to the Contour and evaluate the fitting result
			FitCircle( Conts[iLargestCont], Center, Radius );
			for( const auto &P : Conts[iLargestCont] )
			{
				double dx = (double)P.x - Center.x;
				double dy = (double)P.y - Center.y;
				double e = fabs( sqrt(dx*dx + dy*dy) - Radius );
				FittingErr += e;
			}
			FittingErr /= Conts[iLargestCont].size();
		}
		//Check if Contour shape is "enoughly circle"
		if( FittingErr <= 0.5 )
		{	//Show Result
			cv::Mat Show;
			std::cout << "Thresh = " << Thresh << std::endl;
			cv::cvtColor( SrcImg, Show, cv::COLOR_GRAY2BGR );
			Show.setTo( cv::Scalar(0,0,255), Bin );
			cv::imshow( "Result", Show );
			cv::waitKey();
			return 0;
		}
	}
	//
	std::cout << "(All try Failed)" << std::endl;
	return 0;
}