MANUAL TÉCNICO

“Trazo de círculos”
En el proyecto creado en NetBeans TrazarCirculo, se crearon cuatro clases, las cuales son:

 HerramientasLineas.java
 LienzoDibujo.java
 PanelLienzoDibujo.java
 Main.java

En la clase HerramientasLineas.java viene la lógica del programa, y a continuación se

detallara sobre el código de la misma.

/*Declaración de librerias*/

import java.awt.Color;
import java.awt.image.BufferedImage;
import java.awt.image.WritableRaster;

/*Declaración de clase principal*/

public class HerramientasLineas {

/*Declaración de variables*/
private static BufferedImage imagen;
private static WritableRaster raster;
private static int alto;
private static int ancho;

/*El método setMedidas para colocar las medidias de la imagen y obtener un

raster, que es un panel segmentado*/

public static void setMedidas (int nuevoAlto, int nuevoAncho) {

alto = nuevoAlto;
ancho = nuevoAncho;
imagen = new BufferedImage (alto, ancho, BufferedImage.TYPE_INT_RGB);
raster = imagen.getRaster();
}
/*Se crea el método directo que como parametros espera recibir valores
enteros de las variables xc (x de origen), yc (y de origen) y r (radio)*/

public static BufferedImage directo(int xc, int yc, int r )

{
/*Se declaran variables locales que se van a emplear para realizar las
operaciones que se muestra en este mismo método*/
int x; double y1, y2;
for (x = xc-r; x <= xc+r; x+=2)
{
/*Este ciclo for se emplea para comenzar a pintar los primeros puntos
realizando las operaciones matematicas*/

y1 = yc + Math.sqrt ((float)r *r - (x-xc)* (x-xc));

y2 = yc - Math.sqrt ((float)r *r - (x-xc)* (x-xc));
putPixel(x,y1,0);
putPixel(x,y2,0);
}
/*Se asegura que se nos devuelva la imagen*/
return imagen;
}
/*Se crea el método incremental que va a tener como parametros xc, yc y r que
son de tipo entero*/

public static BufferedImage incremental(int xc, int yc, int r)

{

/*Se crean variables locales que sera utilizadas por este método para hacer
operaciones pertinentes de mismo*/
float dt,cc,cs,x,y,t; int tx,ty;
dt=(float)1/r;
cc=(float)Math.cos(dt); cs=(float)Math.sin(dt);
x=0; y=r;

while(y>=Math.abs(x))
{

/*Se imprimen los pixels con redondeo después de haber verificado si y es

mayor o igual al valor absoluto de x*/
tx=Math.round(x);
ty=Math.round(y);
putPixel(xc+tx,yc+ty,0);
putPixel(xc-tx,yc+ty,0);
putPixel(xc+tx,yc-ty,0);
putPixel(xc-tx,yc-ty,0);
putPixel(xc+ty,yc+tx,0);
putPixel(xc+ty,yc-tx,0);
putPixel(xc-ty,yc+tx,0);
putPixel(xc-ty,yc-tx,0);
t=x;
x=x*cc-y*cs;
y=y*cc+t*cs;
} /*Nos regresa la imagen*/
return imagen; }
/*Se crea el método Bresenham con tres parámetros xc, yc y r*/

public static BufferedImage bresenham(int xc, int yc, int r)

{
/*Se crean variables locales para que sean empleadas en este método*/
int p,x,y;
x=0; y=r;
p=(int) ((float) 5 / 4 - r);

/*Se crea una condicion de tipo while par air hacienda validaciones*/

while(y>x)
{
putPixel(xc+x,yc+y,0);
putPixel(xc-x,yc+y,0);
putPixel(xc+x,yc-y,0);
putPixel(xc-x,yc-y,0);
putPixel(xc+y,yc+x,0);
putPixel(xc+y,yc-x,0);
putPixel(xc-y,yc+x,0);
putPixel(xc-y,yc-x,0);
if(p<0)
p+=2*x+3;
else
{
p+=2*(x-y)+5; y--;
}

x++;

/*Regresa la imagen*/

return imagen;
}

/*Método putPixel hace que se vayan pintando los pixels*/

public static void putPixel(int x, double y,int num){

int [] colors = {
255,255,255,255
};
imagen.getRaster().setPixel(x,(int) (imagen.getHeight() - 1 -
y),colors);
}

}
El siguiente código es el de LienzoDibujo.java, se detalla su contenido:
/*Declaración de las librerias importadas*/
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.image.BufferedImage;
import javax.swing.*;

/*Declaración de la clase principal LienzoDibujo que hereda de JFrame y esta

implementando
ActionListener en la clase*/
public class LienzoDibujo extends JFrame implements ActionListener {

/*Declarición de variables de la clase */

private JMenuBar barra;

private JMenu dibujarCirculo;
private JMenuItem CirculoDirecto;
private JMenuItem CirculoIncremental;
private JMenuItem CirculoBresenham;
private PanelLienzoDibujo panel;

/*Constructor de objeto tipo LienzoDibujo*/

public LienzoDibujo () {
super ("Dibujo de circulos");
setSize (800,600);
cargarComponentes();
setDefaultCloseOperation (EXIT_ON_CLOSE);
setLocationRelativeTo(null);
setVisible(true);
}
/*Creacion del método cargarComponentes*/

public void cargarComponentes() {

/*Aqui se crean los componentes visuales con sus oyentes para los eventos*/

barra = new JMenuBar ();

dibujarCirculo = new JMenu("Circulos");
CirculoDirecto = new JMenuItem ("Dibujar Circulo con algoritmo
Directo");
CirculoIncremental = new JMenuItem ("Dibujar Circulo con algoritmo
Incremental");
CirculoBresenham = new JMenuItem ("Dibujar Circulo con algoritmo
Bresenham");

CirculoDirecto.addActionListener(this);
CirculoIncremental.addActionListener(this);
CirculoBresenham.addActionListener(this);

dibujarCirculo.add(CirculoDirecto);
dibujarCirculo.add(CirculoIncremental);
dibujarCirculo.add(CirculoBresenham);
 barra.add(dibujarCirculo);
setJMenuBar(barra);
panel = new PanelLienzoDibujo(800,600);
add(panel);

/*Se crea la clase actionPerformed que es fundamental para poder realizar los
eventos. En esta clase, se contemplan todos los eventos que van a suceder
dentro de nuestra ventana, por ejemplo, al presionar alguno de los botones de
la lista, el oyente que esta implementado dará la notificación a la clase y
esta llama a este método con las condicionales que tiene*/

public void actionPerformed(ActionEvent e) {

/*Si se oprime la opcion dibujar circulo con algoritmo directo*/
if (e.getSource() == CirculoDirecto) {
int xc = Integer.parseInt (JOptionPane.showInputDialog ("Inserte la x del
origen"));
int yc = Integer.parseInt (JOptionPane.showInputDialog ("Inserte la y del
origen"));
int r = Integer.parseInt (JOptionPane.showInputDialog ("Inserte el radio"));

HerramientasLineas.setMedidas(800,600);
BufferedImage imagen = HerramientasLineas.directo(xc, yc, r);
panel.setImagen(imagen);
panel.repaint();
repaint();

}
/*Si se oprime la opcion dibujar circulo con algoritmo incremental*/

if (e.getSource() == CirculoIncremental) {
int xc = Integer.parseInt (JOptionPane.showInputDialog ("Inserte la x del
origen"));
int yc = Integer.parseInt (JOptionPane.showInputDialog ("Inserte la y del
origen"));
int r = Integer.parseInt (JOptionPane.showInputDialog ("Inserte el radio"));

HerramientasLineas.setMedidas(800,600);
BufferedImage imagen = HerramientasLineas.incremental(xc, yc, r);
panel.setImagen(imagen);
panel.repaint();
repaint();
}

/*Si se oprime la opcion dibujar circulo con algoritmo bresenham*/

if (e.getSource() == CirculoBresenham) {
int xc = Integer.parseInt (JOptionPane.showInputDialog ("Inserte la x del
origen"));
int yc = Integer.parseInt (JOptionPane.showInputDialog ("Inserte la y del
origen"));
int r = Integer.parseInt (JOptionPane.showInputDialog ("Inserte el radio"));
HerramientasLineas.setMedidas(800,600);
BufferedImage imagen = HerramientasLineas.bresenham(xc, yc,r);
panel.setImagen(imagen);
panel.repaint();
repaint();
}
}
}