Find closest point on HoughLine

Given a hough line as {rho: number, theta: number} and a coordinate as {x: number, y: number}, how would I find the closest point on that hough line to the given coordinate?

So in the following sample graphic, I have the blue line and the red dot, and I'm looking for the white cross.

I'm using Typescript, but I'd appreciate answers in any language or format, since this is technically more of a math problem.

White cross is projection of red point C onto the line.

At first get components of normal vector to line

nx = cos(theta)
ny = sin(theta)

and direction vector of line is

dx = -ny
dy = nx

To find this projection, we need some point A at the line. Let's this point is

ax = rho * nx
ay = rho * ny

and get vector AC

acx = cx - ax
acy = cy - ay

Now calculate projection using dot product

coeff = dx*acx + dy*acy
px = ax + dx * coeff
py = ay + dy * coeff

Quick-made Python test (not well tested)

import math
def projection_onto_houghline(rho, theta, cx, cy):
   dx = -math.sin(theta)
   dy = math.cos(theta)
   ax = rho * dy
   ay = -rho * dx
   acx = cx - ax
   acy = cy - ay
   coeff = dx*acx + dy*acy
   px = ax + dx * coeff
   py = ay + dy * coeff
   return(px, py)

print(projection_onto_houghline(math.sqrt(2), math.pi/4, 0, 0))
print(projection_onto_houghline(math.sqrt(2), math.pi/4, 2.5, 2))

(1.0000000000000002, 1.0000000000000002)
(1.2500000000000002, 0.7500000000000002)   

For the red point C, what you should do is

1. Calculate line tangential directional component of the C
2. Add rho * N to 1. (where, N is unit normal vector of the line)

memo (: meaning of above)
For example, if problem is "line is x=x0", what to do?
This case, just modify the x component value of the point C to x0.
Above steps is just doing this but on another coordinate system. Basis of the coordinate system is normal and tangential of the line.

//This code sample is C++, and using OpenCV to visualize
//
#include <random>

class Rnd
{
public:
	Rnd() : m_MT( std::random_device().operator()() ){}
	double GetReal( double Min, double Max ){	return std::uniform_real_distribution<double>( Min,Max )( m_MT );	}
private:
	std::mt19937 m_MT;
};

//main
int main()
{
	constexpr int ImgSize = 320;
	cv::Mat ShowImg = cv::Mat::zeros( ImgSize,ImgSize, CV_8UC3 );

	constexpr int nTest = 3;
	const cv::Scalar DrawColor[nTest] = { {255,96,96}, {0,255,0}, {0,0,255} };

	Rnd rnd;
	for( int i=0; i<nTest; ++i )
	{
		//Line Parameter
		double rho = rnd.GetReal( 10, ImgSize-10 );
		double theta = rnd.GetReal( 0, CV_PI*0.5 );

		cv::Vec2d N{ cos(theta), sin(theta) };  //Line Unit Normal
		cv::Vec2d T{ -N[1], N[0] };  //Line Unit Tangential

		//The Point C
		cv::Vec2d C{ rnd.GetReal( 0, ImgSize ), rnd.GetReal( 0, ImgSize ) };
		//The Answer Point X
		//What you should calculate is this.
		cv::Vec2d X = T*C.dot(T)  +  rho*N;

		{//Draw Result
			{//Draw Line
				cv::Vec2d A = rho * N;
				cv::Vec2d P1 = A - ImgSize * T;
				cv::Vec2d P2 = A + ImgSize * T;
				cv::line( ShowImg, cv::Point(P1), cv::Point(P2), DrawColor[i], 2 );
			}
			{//Draw Point C and X
				cv::circle( ShowImg, cv::Point(C), 5, DrawColor[i], -1 );
				cv::circle( ShowImg, cv::Point(X), 5, DrawColor[i], -1 );
				cv::line( ShowImg, cv::Point(C), cv::Point(X), DrawColor[i]*0.6 );
			}
		}
	}

	cv::imshow( "Result", ShowImg );
	cv::waitKey();
	return 0;
}

This is a result of above code.

• 3 examples are drawn in different colors.
• Lines are drawn slightly thicker