Moved to Contributed Library Questions! Why? Read this.

Making lines is one of the core competences of Processing. So I'm not sure if you have anything specific in mind with regard to the modest maps library (which I haven't used), but if you just want a series of lines then you can use line() or you could use a noFill() beginShape-endShape where each coordinate is a vertex. If your number of coordinates is 50.000+ then I suggest using GLGraphics or a PShape in the Processing beta's in order to maintain a good frameRate.

The problem is the coordinates are coming through a serial input.
If i'll use beginShape- endShape, then I have to store all the previous coordinate values, and I dont know how many times the coordinates will come from the Serial Input.

Any suggestions?

" I dont know how many times the coordinates will come from the Serial Input."
Put them in a PVector, store the PVectors in an ArrayList<PVector>;

Can you please show a simple demonstration code.

Do I have to create a new PVector every time I fetch cordinates from serial input?

Here's a quick fix:

import java.util.List;

// declare & init in same statement:
final static List<PVector> dump = new ArrayList();

void setup() {
  dump.add( new PVector() );  // primitive fields are initialized w/ 0 already
  println(dump);
  
  dump.add( new PVector(20, 20) );  // set latitude and longitude from serial input
  println(dump);
  
  exit();
}

Thanks a ton GoToLoop and PhiLho.

The explanation for that "anomaly" is a little technical. But I'll try! 

Object variables in Java store memory addresses from allocated memory blocks created by keyword new.
Those memory addresses are called pointer references!

When you issue -> coordinates = new PVector (0,0,0);
variable coordinates receive the memory reference of an instance of class PVector.
Then, you store that very reference in the ArrayList referenced by variable dump.
It means both variable coordinates and internal entry from dump reference the same memory address block!

Afterwards, you issue -> coordinates.set(20,20, 0);
Now, since both coordinates and internal ArrayList entry of dump essentially stores the same memory address,
you just changed the contents of both!

To avoid that, you have to create different memory block references for each entry of PVector using  new.
So they are distinct from each other, having different memory addresses!

When you indicate the type of object that is in the ArrayList as discussed above...

...the following code will automatically use every PVector that is in the ArrayList.

See the reference for different display options: http://processing.org/reference/beginShape_.html

Code Example

1. void draw() {
2.   noFill();
3.   stroke(0);
4.   beginShape();
5.   for (PVector p : dump) {
6.     vertex(p.x, p.y);
7.   }
8.   endShape();
9. }

amnon i tried your code but it doesn't seems to be working.

The main problem is that you move the new point by 0.006 while 1 pixel is 1. In other words, your movement is miniscule in terms of the Processing sketch windows. It would take 167 new points to move 1 pixel. Hopefully you get the point, you need to rescale your incoming data in a manner that you can actually see something. For example by using map(). When you work on a sensible scale you see that the code works, although it did need a background() call to function properly.

Also check out the book Visualizing Data by Ben Fry. See: http://processing.org/learning/books/

Adapted Code

1. import java.util.List;
2. final static List<PVector> dump = new ArrayList();
3. float lat, lng;
4.  
5. void setup() {
6.   size(500, 500);
7.   lat = width/2;
8.   lng = height/2;
9.   dump.add( new PVector(lat, lng) );
10.   lat+=random(-15,15);
11.   lng+=random(-15,15);
12.   dump.add( new PVector(lat, lng) );
13. }
14.  
15. void draw() {
16.   background(255);
17.   noFill();
18.   beginShape();
19.   for (PVector p : dump) {
20.     vertex(p.x, p.y);
21.   }
22.   endShape();
23. }
24.  
25. void keyPressed() {
26.   lat+=random(-15,15);
27.   lng+=random(-15,15);
28.   dump.add( new PVector(lat, lng) );
29. }

Ohk.. Got your point. Seems like too much programming took away my common sense..!!

Just a little curious detail ->  lines # 10,11,12 are the same as # 26,27,28.