1. ArrayList<PVector> a=new ArrayList();void setup(){size(400,400);smooth();stroke(255);}
2. void draw(){while(a.size()>200)a.remove(0);background(0);for(int i=0;i<a.size()-1;i++){
3. line(a.get(i).x,a.get(i).y,a.get(i+1).x,a.get(i+1).y);}a.add(new PVector(mouseX,mouseY,0));}

Drawing that was said section are likely ideal. But it is difficult.

It uses the remembered locations to draw lines between them.

The code you posted is drawing yellow circles at various positions, but it does not remember those positions.
You need to understand how my ArrayList remembers the mouse positions, and do the same thing to remember the positions of the yellow circles.
Then you can draw lines between those positions too.

My code is written in a compact format so that you are forced to decode it and work with it so that you understand it in detail.

I   should   understand   ArrayList .  It   is   difficult   for   it   to   be   understood   because   I   am   studying ,  but   wants   to   challenge   it   by   all   means .
I   want   to   complete   it   by   all   means   by   the   end   of   today ....

I   understood   that   you   should   let   you   paint   pictures   newly   after   having   let   you   memorize   the   position   of   the   last   yellow   circle .

Thank   you   for   being   able   to   tell   me   kindly .  I   thank   you   heartily .  English   is   poor ,  too ,  and   I 'm  sorry .

1. final int num = 50;
2. int[] x = new int[num];
3. int[] y = new int[num];
4.   
5. void setup()
6. {
7.   size(800, 600);
8.   smooth();
9. }
10.   
11. void draw()
12. {
13.   background(0);
14.  
15.   // Shadow
16. //  stroke(160);
17. //  for(int i = 0; i < num - 1; i++)
18. //  {
19. //    strokeWeight(i + 1);
20. //    line(x[i] + 10, y[i] + 10, x[i + 1] + 10, y[i + 1] + 10);
21. //  }
22.  
23.   // Outline
24.   stroke(0);
25.   for(int i = 0; i < num - 1; i++)
26.   {
27.     strokeWeight(i + 10);
28.     line(x[i], y[i], x[i + 1], y[i + 1]);
29.   }
30.    
31.   // Fill
32.   stroke(255);
33.   for(int i = 0; i < num - 1; i++)
34.   {
35.     strokeWeight(i + 1);
36.     line(x[i], y[i], x[i + 1], y[i + 1]);
37.   }
38. }
39.  
40. void mouseMoved()
41. {
42.   for(int i = num - 1; i > 0; i--)
43.   {
44.     x[i] = x[i-1];
45.     y[i] = y[i-1];
46.   }
47.   x[0] = mouseX;
48.   y[0] = mouseY;
49. }

1. /**
2.  * Brightness Tracking 
3.  * by Golan Levin. 
4.  * Position Remembering and Line Drawing added by TfGuy44
5.  * Tracks the brightest pixel in a live video signal. 
6.  * Done for takuya.tatsui because he couldn't work it out himself.
7.  */
8. 
   
9. 
   
10. import processing.video.*;
11. 
    
12. Capture video;
13. ArrayList<PVector> a=new ArrayList();
14. 
    
15. void setup() {
16.   size(640, 480);
17.   // Uses the default video input, see the reference if this causes an error
18.   video = new Capture(this, width, height);
19.   video.start();  
20.   stroke(255);
21.   smooth();
22. }
23. 
    
24. void draw() {
25.   while(a.size()>200)a.remove(0);
26.   if (video.available()) {
27.     video.read();
28.     image(video, 0, 0, width, height); // Draw the webcam video onto the screen
29.     int brightestX = 0; // X-coordinate of the brightest video pixel
30.     int brightestY = 0; // Y-coordinate of the brightest video pixel
31.     float brightestValue = 0; // Brightness of the brightest video pixel
32.     // Search for the brightest pixel: For each row of pixels in the video image and
33.     // for each pixel in the yth row, compute each pixel's index in the video
34.     video.loadPixels();
35.     int index = 0;
36.     for (int y = 0; y < video.height; y++) {
37.       for (int x = 0; x < video.width; x++) {
38.         // Get the color stored in the pixel
39.         int pixelValue = video.pixels[index];
40.         // Determine the brightness of the pixel
41.         float pixelBrightness = brightness(pixelValue);
42.         // If that value is brighter than any previous, then store the
43.         // brightness of that pixel, as well as its (x,y) location
44.         if (pixelBrightness > brightestValue) {
45.           brightestValue = pixelBrightness;
46.           brightestY = y;
47.           brightestX = x;
48.           a.add(new PVector(x,y,0) );
49.         }
50.         index++;
51.       }
52.     }
53.     for(int i=0;i<a.size()-1;i++) {
54.       strokeWeight(i);
55.       line(a.get(i).x, a.get(i).y, a.get(i+1).x, a.get(i+1).y);
56.     }    
57.     // Draw a large, yellow circle at the brightest pixel
58.     strokeWeight(1);
59.     fill(255, 204, 0, 128);
60.     ellipse(brightestX, brightestY, 200, 200);
61.   }
62. }