Usage:

The Graphics drawPolygon method can be used to draw outline polygons, and the Graphics fillPolygon method can be used to draw filled polygons.
Class:

Graphics
Example Methods:

drawPolygon (int[] XArray, int[] YArray, int N)
fillPolygon (int[] XArray, int[] YArray, int N)

Arguments:

XArray
Array of the horizontal locations of the vertices of the polygon, in pixels.
YArray
Array of the vertical locations of the vertices of the polygon, in pixels.
N
Number of points.


Code:

import java.applet.Applet;
import java.awt.*;

public class Polygon1 extends Applet {

public void paint (Graphics g) {
int Cursor;
int[] XArray = {20, 160, 120, 160, 20, 60};
int[] YArray = {20, 20, 90, 160, 160, 90};
g.drawPolygon (XArray, YArray, 6);
Cursor = 0;
while (Cursor < 6) {
XArray [Cursor] = XArray [Cursor] + 200;
Cursor = Cursor + 1;
}
g.fillPolygon (XArray, YArray, 6);
}

}


Code:

import java.applet.Applet;
import java.awt.*;

public class Polygon2 extends Applet {

public void paint (Graphics g) {
int Cursor;
int[] XArray = {20, 160, 40, 90, 130};
int[] YArray = {50, 50, 120, 20, 120};
g.drawPolygon (XArray, YArray, 5);
Cursor = 0;
while (Cursor < 5) {
XArray [Cursor] = XArray [Cursor] + 180;
Cursor = Cursor + 1;
}
g.fillPolygon (XArray, YArray, 5);
}

}

Answered by Sharad Singh , an ibibo Master, at 5:55 PM on September 25, 2008

There are two ways to draw basic shapes like circles, ovals, lines, arcs, squares, rectangles, rounded rectangles, and polygons. The first is to use specific drawing methods like Graphics.drawOval(). This example uses these methods. The second is to construct a shape and then use Graphics2D.draw() to draw the shape. See the java.awt.geom package for examples that create shapes.

// See e575 The Quintessential Drawing Program
public void paint(Graphics g) {
Graphics2D g2d = (Graphics2D)g;

g2d.drawLine(x1, y1, x2, y2);
g2d.drawOval(x, y, w, h);
g2d.drawRect(x, y, w, h);

// A start angle of 0 represents a 3 o'clock position, 90 represents a 12 o'clock position,
// and -90 (or 270) represents a 6 o'clock position
int startAngle = 45;
int arcAngle = -60;
g2d.drawArc(x, y, w, h, startAngle, arcAngle);

g2d.drawRoundRect(x, y, w, h, arcWidth, arcHeight);

Polygon polygon = new Polygon();
polygon.addPoint(x, y);
// Add more points...
g2d.drawPolygon(polygon);
}

For more visit :

http://www.exampledepot.com/eg s/java.awt/DrawBasic.html

Answered by Ashish Yadav , an ibibo Wizard, at 5:43 PM on September 25, 2008

You can draw polygons and filled polygons using the Graphics class. You have two options when drawing polygons. You can either pass two arrays containing the x and y coordinates of the points in the polygon, or you can pass an instance of a Polygon class:

public abstract void drawPolygon(int[] xPoints, int[] yPoints, int numPoints)
public void drawPolygon(Polygon p)
The applet draws a polygon using an array of points.

Source Code for DrawPoly.java
import java.applet.*;
import java.awt.*;

//
// This applet draws a polygon using an array of points

public class DrawPoly extends Applet
{
// Define an array of X coordinates for the polygon
int xCoords[] = { 10, 40, 60, 30, 10 };

// Define an array of Y coordinates for the polygon
int yCoords[] = { 20, 0, 10, 60, 40 };

public void paint(Graphics g)
{
g.drawPolygon(xCoords, yCoords, 5); // 5 points in polygon
}
}

Answered by Hem@nt .... , an ibibo Master, at 12:31 PM on September 25, 2008

import java.awt.Container;
import java.awt.Graphics;
import java.awt.Polygon;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;

import javax.swing.JFrame;
import javax.swing.JPanel;

public class DrawPolyPanel extends JPanel {
public void paintComponent(Graphics g) {
super.paintComponent(g);

Polygon p = new Polygon();
for (int i = 0; i < 5; i++)
p.addPoint((int) (100 + 50 * Math.cos(i * 2 * Math.PI / 5)),
(int) (100 + 50 * Math.sin(i * 2 * Math.PI / 5)));

g.drawPolygon(p);

Polygon s = new Polygon();
for (int i = 0; i < 360; i++) {
double t = i / 360.0;
s.addPoint((int) (150 + 50 * t * Math.cos(8 * t * Math.PI)),
(int) (150 + 50 * t * Math.sin(8 * t * Math.PI)));
}
g.drawPolygon(s);
}
public static void main(String[] args) {
JFrame frame = new JFrame();
frame.setTitle("DrawPoly");
frame.setSize(350, 250);
frame.addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {
System.exit(0);
}
});
Container contentPane = frame.getContentPane();
contentPane.add(new DrawPolyPanel());

frame.show();
}
}
To fill a poly gon with draw example are as below:

import java.awt.Container;
import java.awt.Graphics;
import java.awt.Polygon;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;

import javax.swing.JFrame;
import javax.swing.JPanel;

public class FillPolyPanel extends JPanel {
public void paintComponent(Graphics g) {
super.paintComponent(g);
int radius = 40;
int centerX = 50;
int centerY = 100;
int angle = 30;

int dx = (int) (radius * Math.cos(angle * Math.PI / 180));
int dy = (int) (radius * Math.sin(angle * Math.PI / 180));

g.fillArc(centerX - radius, centerY - radius, 2 * radius, 2 * radius, angle, 360 - 2 * angle);

Polygon p = new Polygon();
centerX = 150;
for (int i = 0; i < 5; i++)
p.addPoint((int) (centerX + radius * Math.cos(i * 2 * Math.PI / 5)),
(int) (centerY + radius * Math.sin(i * 2 * Math.PI / 5)));

g.fillPolygon(p);

p = new Polygon();
centerX = 250;
for (int i = 0; i < 360; i++) {
double t = i / 360.0;
p.addPoint((int) (centerX + radius * t * Math.cos(8 * t * Math.PI)),
(int) (centerY + radius * t * Math.sin(8 * t * Math.PI)));
}
g.fillPolygon(p);
}
public static void main(String[] args) {
JFrame frame = new JFrame();
frame.setTitle("FillPoly");
frame.setSize(300, 200);
frame.addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {
System.exit(0);
}
});
Container contentPane = frame.getContentPane();
contentPane.add(new FillPolyPanel());

frame.show();
}

}

Answered by shaista , an ibibo Master, at 9:52 AM on September 25, 2008

Well, Sunil it is Polygon noy Plygons.

The Polygon class encapsulates a description of a closed, two-dimensional region within a coordinate space.

This region is bounded by an arbitrary number of line segments, each of which is one side of the polygon. Internally, a polygon comprises of a list of (x, y) coordinate pairs, where each pair defines a vertex of the polygon, and two successive pairs are the endpoints of a line that is a side of the polygon. The first and final pairs of (x, y) points are joined by a line segment that closes the polygon. This Polygon is defined with an even-odd winding rule. See WIND_EVEN_ODD for a definition of the even-odd winding rule. This class's hit-testing methods, which include the contains, intersects and inside methods, use the insideness definition described in the Shape class comments.

Constructor Summary
Polygon()
Creates an empty polygon.
Polygon(int[] xpoints, int[] ypoints, int npoints)
Constructs and initializes a Polygon from the specified parameters.

For more details , Please visit the source site :

http://java.sun.com/j2se/ 1.4.2/docs/api/java/awt/Polygo n.html

Answered by Alok Gupta , an ibibo Guru, at 9:32 AM on September 25, 2008

well,

import java.applet.Applet;
import java.awt.*;

public class Polygon1 extends Applet {

public void paint (Graphics g) {
int Cursor;
int[] XArray = {20, 160, 120, 160, 20, 60};
int[] YArray = {20, 20, 90, 160, 160, 90};
g.drawPolygon (XArray, YArray, 6);
Cursor = 0;
while (Cursor < 6) {
XArray [Cursor] = XArray [Cursor] + 200;
Cursor = Cursor + 1;
}
g.fillPolygon (XArray, YArray, 6);
}

}

Answered by Romi , an ibibo Master, at 9:24 AM on September 25, 2008

well, import org.eclipse.swt.SWT;
import org.eclipse.swt.events.*;
imp ort org.eclipse.swt.layout.*;
imp ort org.eclipse.swt.widgets.*;

/**
* This class demonstrates drawing polygons
*/
public class PolygonExample {
private Text txtWidth = null;
private Text txtHeight = null;

/**
* Runs the application
*/
public void run() {
Display display = new Display();
Shell shell = new Shell(display);
shell.setText("Polygon Example");
createContents(shell);
shell.open();
while (!shell.isDisposed()) {
if (!display.readAndDispatch()) {
display.sleep();
}
}
display.dispose();
}

/**
* Creates the main window's contents
*
* @param shell the main window
*/
private void createContents(Shell shell) {
shell.setLayout(new FillLayout(SWT.VERTICAL));

// Create the canvas to draw the polygons on
Canvas drawingCanvas = new Canvas(shell, SWT.NONE);
drawingCanvas.addPaintListener (new PolygonExamplePaintListener()) ;
}

/**
* This class gets the user input and draws the requested oval
*/
private class PolygonExamplePaintListener implements PaintListener {
public void paintControl(PaintEvent e) {
// Get the canvas for drawing and its dimensions
Canvas canvas = (Canvas) e.widget;
int x = canvas.getBounds().width;
int y = canvas.getBounds().height;

// Set the drawing color
e.gc.setBackground(e.display.g etSystemColor(SWT.COLOR_BLACK) );

// Create the points for drawing a triangle in the upper left
int[] upper_left = { 0, 0, 200, 0, 0, 200};

// Create the points for drawing a triangle in the lower right
int[] lower_right = { x, y, x, y - 200, x - 200, y};

// Draw the triangles
e.gc.fillPolygon(upper_left);
e.gc.fillPolygon(lower_right);
}
}

/**
* The application entry point
*
* @param args the command line arguments
*/
public static void main(String[] args) {
new PolygonExample().run();
}
}


For more: http://www.java2s.com/Code/Jav a/SWT-JFace-Eclipse/Demonstrat esdrawingpolygons.htm

Answered by Satya ~ , an ibibo Master, at 9:19 AM on September 25, 2008