Not sure if it can do quite what you're looking for, but maybe check out Lee Byron's Mesh library.

Thank you, I have that library.  The problem is that it deals with points and is bounded by the canvas, I need something which can be bound by an area and build a mesh within that area.  I do appreciate the help, though.

I think you need constrained delaunay triangulation.
I think poly2tri should help as there's a java version.

I always use the triangulation code from the Processing hacks section. It still works well for basic triangulation. Although for more advanced triangulation, indeed poly2tri is perhaps more suited. For smoothing I also point you towards the smooth function for Polygon2D in Toxiclibs. Also see the PolySmooth example supplied with the lib.

Thank you both, I appreciate the help.  I will try triangulate.  I feel like an idiot, though, I can't figure out how to get the poly2tri for java from the Google code site.  I would appreciate help here.

I am also interested by this library, too, so let's see if I can get it.
The Google Code page has a Downloads link. Nothing interesting there... Only image files and PDF.
OK, let's follow the link on the Java word. It leads to the Mercurial (a DVCS) repository interface. Looks like that's a project delivering only sources... Unless they keep a jar somewhere in the repository, some projects do that.
I have Hg, with some other major VCS, it is useful in such circumstances... But it is annoying to install it just for getting one project, and Google Code doesn't offer a "download current state" like GitHub does. So let's explore it with the Web interface.
Aha! In repository > snapshots, I see jar files! If I click on poly2tri-core-0.1.1-SNAPSHOT.jar, I get a message telling me it cannot be displayed. But there is a View raw file link. Right-click on the link, Save as..., and on the disk! I rename it to poly2tri.jar and drop it in <sketchbook path>/libraries/poly2tri/library/poly2tri.jar

Now, fire Processing. Sketch > Import library > poly2tri
Got a bunch of imports. Let's play!

Well, it was a bit harder than expected, because there is no documentation. There is a JavaDoc, but there are nearly no useful comments, so it is just a list of classes and method, useless.
I had to rely on the code itself to figure out how to use the library, and it is probably not the best way...

Anyway, here is a simple test code:

1. import org.poly2tri.triangulation.point.*;
2. import org.poly2tri.triangulation.util.*;
3. import org.poly2tri.transform.coordinate.*;
4. import org.poly2tri.triangulation.sets.*;
5. import org.poly2tri.triangulation.delaunay.sweep.*;
6. import org.poly2tri.triangulation.delaunay.*;
7. import org.poly2tri.geometry.primitives.*;
8. import org.poly2tri.triangulation.*;
9. import org.poly2tri.geometry.polygon.*;
10. import org.poly2tri.*;
11.  
12. boolean bShowTriangulation;
13. //~ ArrayList<TriangulationPoint> points = new ArrayList<TriangulationPoint>();
14. ArrayList<PolygonPoint> points = new ArrayList<PolygonPoint>();
15. List<DelaunayTriangle> triangles;
16.  
17. void setup()
18. {
19.   size(500, 500);
20.   smooth();
21. }
22.  
23. void draw()
24. {
25.   background(128);
26.   fill(255);
27.   stroke(#0044FF);
28.   strokeWeight(4);
29.   if (points.size() < 3)
30.   {
31.     for (TriangulationPoint point : points)
32.     {
33.       float x = point.getXf();
34.       float y = point.getYf();
35.       ellipse(x, y, 3, 3);
36.     }
37.     return;
38.   }
39.   beginShape();
40.   for (PolygonPoint point : points)
41.   {
42. //~ println("ShPt: " + point);
43.     float x = point.getXf();
44.     float y = point.getYf();
45.     vertex(x, y);
46.   }
47.   endShape(CLOSE);
48.  
49.   if (bShowTriangulation && triangles != null)
50.   {
51.     stroke(#FF7777);
52.     strokeWeight(1);
53.     for (DelaunayTriangle triangle : triangles)
54.     {
55. //~ println("Tr: " + triangle);
56.       float fx = 0, fy = 0;
    
57.       float px = 0, py = 0;
58.       boolean bFirst = true;
59.       for (TriangulationPoint point : triangle.points)
60.       {
61. //~ println("TrPt: " + point);
62.         float x = point.getXf();
63.         float y = point.getYf();
64.         if (bFirst)
65.         {
66.           fx = x; fy = y;
    
67.           bFirst = false;
68.         }
69.         else
70.         {
71.           line(px, py, x, y);
72.         }
73.         px = x; py = y;
74.       }
75.       line(px, py, fx, fy);
    
76.     }
77.   }
78. }
79.  
80. void mousePressed()
81. {
82.   PolygonPoint point = new PolygonPoint((float) mouseX, (float) mouseY);
83.   points.add(point);
84. }
85.  
86. void keyReleased()
87. {
88.   switch (key)
89.   {
90.   case 't':
91.     DoTriangulation();
92.     break;
93.   case 'c':
94.     points.clear();
95.     triangles = null;
96.     bShowTriangulation = false;
97.     break;
98.   }
99. }
100.  
101. void DoTriangulation()
102. {
103.   if (points.size() < 3)
104.     return;
105.  
106.   // Only DTSweep  algorithm available
107.   TriangulationContext<?> context = Poly2Tri.createContext(TriangulationAlgorithm.DTSweep);
108. //~   context.addPoints(points);
109.   Polygon polygon = new Polygon(points);
110.   context.prepareTriangulation(polygon);
111.   Poly2Tri.triangulate(context);
112.  
113.   triangles = context.getTriangles();
114. //~ println("DT: " + triangles);
115. //~   context.clear(); // Remove the points
116.  
117.   bShowTriangulation = true;
118. }

Click to drawn a polygon, once it is closed you can type t to triangulate, c to clear all.
The code needs some more work, to eliminate triangles outside of the polygon.

I had a bad surprise: the library is dependent on another library, a log framework ( SLF4J). I don't think such kind of library should rely on a logger, at least for the released version, but well, you have to download the binary of SLF4J and extract slf4j-api-1.6.1.jar and slf4j-simple-1.6.1.jar next to the poly2tri.jar in the library folder.

thank you very much.  I've run this sketch several times and it seems to skip one side of the polygon and add two points above and outside the polygon every time....why is that?

Ah, yesterday I lazily hand-edited the message to add a last-minute fix for the missing side, but I just forgot the corresponding line() call (using the fx/fy variables) out of three lines to add... I edited it to add it.
And yes, I wrote we have to trim out the extra triangles, which are probably used for construction.
But actually, we have to eliminate all the lines that are outside of the original polygon:

That's only preliminary work to see how the library works, more work have to be done, using unseen library facilities if there are any, or external code (like searching if a given result point is in the list of original points) to get a good result.

OK, just added a save & load facility to ease the tests.
And made a primitive algorithm to eliminate points outside of the shape. Would have been easier if these data structures had proper hashCode/equals methods (thus allowing to use ArrayList.contains()).
Still have to eliminate extra lines... Not there for convex polygons. Actually, I think the algorithm is made for convex stuff, as it takes the points as a cloud, without concept of ordering: if I draw them out of order, it just takes the convex hull of these points.
See the code at http://bazaar.launchpad.net/~philho/+junk/Processing/view/head:/_SmallPrograms/Poly2TriTest/Poly2TriTest.pde

" Sorry for the lack of documentation but there is plenty of examples to look at."
I only found Ardor3D examples, nothing about simple 2D examples.
I suppose I was confused by the "noise" around the usage of Poly2Tri (most of the code being visualization code).
I hadn't expected to find the result in the input set, maybe it would have been cleaner, or clearer to separate them (triangulation returning the result) but I suppose you have good reasons for this design.

Thanks for the simple polygon example, I updated my source linked above, result is much simpler...
I also added the Steiner points (right click).
s allows to save the "drawing", l to reload one design, t to triangulate.

Good!
Despite my criticisms, I find the library well made, and easy to use once the trick is revealed (some JavaDoc comments could help too...).
Feel free to use my code as example (included or linked to) if you think it can be useful to people.