Not sure what you mean by tolerance but computing the actual intersection points between a line and a circle is a common activity.

I have modified your code and added a method to calculate the intersection points. As the circle moves the intersection points (if any) are shown in red.

1. void setup() {
2.   size(400, 400);
3.   cursor(CROSS);
4.   smooth();
5. }
6. void draw() {
7.   background(255);
8.   stroke(0);
9.   fill(0, 255, 0, 48);
10.   line(30, 30, 250, 250);
11.   // Draw ellipse of diameter 50
12.   ellipse(mouseX, mouseY, 50, 50);
13.   // This fucntion uses the circle radius so 50/2 = 25
14.   float[] intersects = line_circle_p(30, 30, 250, 250, mouseX, mouseY, 25);
15.   fill(0);
16.   if (intersects.length == 0)
17.     text("MISSED", 20, 20);
18.   else
19.     text("INTERSECTION", 20, 20);
20.   fill(255, 0, 0);
21.   noStroke();
22.   for (int i = 0; i < intersects.length; i += 2)
23.     ellipse(intersects[i], intersects[i+1], 6, 6);
24. }
25. 
    
26. /**
27.  * Calculate the points of intersection between a line and a circle. <br>
28.  * An array is returned that contains the intersection points in x, y order.
29.  * If the array is of length: <br>
30.  * 0 then there is no intersection <br>
31.  * 2 there is just one intersection (the line is a tangent to the circle) <br>
32.  * 4 there are two intersections <br>
33.  *
34.  * @param x0
35.  * @param y0
36.  * @param x1
37.  * @param y1
38.  * @param cx centre of circle x position
39.  * @param cy centre of circle y position
40.  * @param r radius of circle
41.  * @return the intersection points as an array (2 elements per intersection)
42.  */
43. public static float[] line_circle_p(float x0, float y0, float x1, float y1, float cx, float cy, float r) {
44.   float[] result = new float[0];
45.   float f = (x1 - x0);
46.   float g = (y1 - y0);
47.   float fSQ = f*f;
48.   float gSQ = g*g;
49.   float fgSQ = fSQ + gSQ;
50.   float xc0 = cx - x0;
51.   float yc0 = cy - y0;
52.   float fygx = f*yc0 - g*xc0;
53.   float root = r*r*fgSQ - fygx*fygx;
54.   if (root > -1E-5) {
55.     float[] temp = null;
56.     int np = 0;
57.     float fxgy = f*xc0 + g*yc0;
58.     if (root < 1E5) {    // tangent so just one point
59.       float t = fxgy / fgSQ;
60.       if (t >= 0 && t <= 1)
61.       temp = new float[] {
62.         x0 + f*t, y0 + g*t
63.       };
64.       np = 2;
65.     }
66.     else {  // possibly two intersections
67.       temp = new float[4];
68.       root = (float) Math.sqrt(root);
69.       float t = (fxgy - root)/fgSQ;
70.       if (t >= 0 && t <= 1) {
71.         temp[np++] = x0 + f*t;
72.         temp[np++] = y0 + g*t;
73.       }
74.       t = (fxgy + root)/fgSQ;
75.       if (t >= 0 && t <= 1) {
76.         temp[np++] = x0 + f*t;
77.         temp[np++] = y0 + g*t;
78.       }
79.     }
80.     if (temp != null) {
81.       result = new float[np];
82.       System.arraycopy(temp, 0, result, 0, np);
83.     }
84.   }
85.   return result;
86. }

Thank you, looks nice.

I dont understand a single line of your method but i guess that shouldn't be a problem :)

All you need to know is how to call the method and what the return values are, but then that is true of most of the methods in Processing.