New College Project

[Roberto Favaro]

Workin on a college project involving line clipping of a shape.Here's my work in progress.I want to add a few extras but cant think where to start.Any suggestions appreciated.Tnx in advance

import java.applet.*;
import java.awt.*;
import java.awt.event.*;
import java.util.* ;
import java.lang.Math;
 
public class LineClipping extends Applet implements MouseMotionListener, MouseListener
{
    private int m_x1,
                m_x2,
                m_y1,
                m_y2;
 
    private int m_x,
                m_y,
                m_height,
                m_width;
 
    private Vector m_stack = new Vector();
 
    public void init()
    {
this.setSize(1000,500);
    m_width = 200;
    m_height = 100;
 
addMouseListener(this);
   addMouseMotionListener(this);
 
   //repaint();
}
 
    public void paint(Graphics g)
    {
m_x = (int) ((this.getWidth() / 2) - (m_width / 2));
    m_y = (int) ((this.getHeight() / 2) - (m_height / 2));
 
g.setColor(Color.blue);
        g.fillRect(m_x, m_y, m_width, m_height);
        g.fillPolygon(m_poly);
 
        for(int i = 0;i < m_stack.size(); i++)
    {
int x1, y1, x2, y2;
 
    x1 = ((Line)(m_stack.elementAt(i))).getX1();
    y1 = ((Line)(m_stack.elementAt(i))).getY1();
    x2 = ((Line)(m_stack.elementAt(i))).getX2();
    y2 = ((Line)(m_stack.elementAt(i))).getY2();
 
    bresenham(x1 + m_x, y1 + m_y, x2 + m_x, y2 + m_y, false);   // draw line
        }
}
 
public void writePixel(int x, int y, boolean flag)
{
Graphics g = this.getGraphics();
 
        if (flag == true)
        {
g.setXORMode(Color.WHITE);   // this changes my color to xor when the line is inside the rectangle
        }
        else
        {
            g.setColor(Color.BLACK);
        }
g.drawLine(x,y,x,y);
}
 
    public void mouseDragged(MouseEvent e)
    {
bresenham(m_x1, m_y1, m_x2, m_y2, true);
    m_x2 = e.getX();
    m_y2 = e.getY();
    bresenham(m_x1, m_y1, m_x2, m_y2, true);   // draw line
    }
 
    public void mousePressed(MouseEvent e)
    {
    m_x1 = m_x2 = e.getX();
    m_y1 = m_y2 = e.getY();
        bresenham(m_x1, m_y1, m_x2, m_y2, true);   // draw line
    }
 
    public void mouseReleased(MouseEvent e)
    {
    m_x2 = e.getX();
    m_y2 = e.getY();
        bresenham(m_x1, m_y1, m_x2, m_y2, true);   // draw line
 
        cohenSutherland(m_x1, m_y1, m_x2, m_y2);
    }
 
    public void mouseMoved(MouseEvent e) {}
 
    public void mouseEntered(MouseEvent e) {}
 
    public void mouseExited(MouseEvent e) {}
 
    public void mouseClicked(MouseEvent e) {}
 
void bresenham(int x1,int y1,int x2,int y2, boolean flag)
{
int dx, dy, incr1, incr2, xIncr, yIncr, d, x, y, xEnd;
 
    dx = Math.abs(x2 - x1);
    dy = Math.abs(y2 - y1);
 
    if(dx > dy) // use x as incrementor
    {
d     = 2 * dy - dx;
        incr1 = 2 * dy;
        incr2 = 2 * (dy - dx);
 
        if(x1 > x2) // switch end-points
        {
//Swap(x1,x2);
         //Swap(y1,y2);
int temp;
            temp = x1;
            x1 = x2;
            x2 = temp;
            temp = y1;
            y1 = y2;
            y2 = temp;
}
 
        if(y1 < y2) // either slope up or down
        {
            yIncr = 1;
        }
        else
        {
            yIncr = -1;
        }
 
        y = y1;
 
        for(x = x1;x <= x2;x++)
        {
writePixel(x,y,flag);
            if(d < 0)
            {
d += incr1;
            }
            else
            {
                y += yIncr;
                d += incr2;
            }
}
}
    else // use y as incrementor
    {
d = 2 * dx - dy;
        incr1 = 2 * dx;
        incr2 = 2 * (dx - dy);
        if(y1 > y2) // switch end-points
        {
//Swap(x1,x2);
         //Swap(y1,y2);
int temp;
            temp = x1;
            x1 = x2;
            x2 = temp;
            temp = y1;
            y1 = y2;
            y2 = temp;
        }
        if(x1 < x2) // either slope up or down
        {
xIncr = 1;
        }
        else
        {
xIncr = -1;
        }
 
        x = x1;
 
        for(y = y1;y <= y2;y++)
        {
writePixel(x,y,flag);
            if(d < 0)
            {
d += incr1;
            }
            else
            {
x += xIncr;
                d += incr2;
            }
}
}
}
 
public void cohenSutherland(int x1,int y1,int x2,int y2)
{
float m = 0;
int xI_1 = 0, yI_1 = 0, xI_2 = 0, yI_2 = 0;
 
//for each line
xI_1 = x1;
yI_1 = y1;
xI_2 = x2;
yI_2 = y2;
 
boolean drawLineFlag = true;
 if (!trivialAccept())
 {
m = (float)(y2 - y1) / (x2 - x1);
//for each of the line's two endpoints
 
if(!trivialReject()) 
{
// we can use the outcode to make this if/then/else more efficient
if (y1 < m_y)  // endpoint is above window
{
xI_1 = x1 + Math.round((m_y - y1) / m);
yI_1 = m_y;
x1  = xI_1;
y1  = yI_1;
}
else if(y1 > (m_y + m_height)) // endpoint is below window
{
xI_1 = x1 + Math.round(((m_y + m_height) - y1) / m);
yI_1 = (m_y + m_height);
x1  = xI_1;
y1  = yI_1;
}
if(x1 < m_x)
{
xI_1 = m_x;
yI_1 = y1 + Math.round(m * (m_x - x1));
}
else if(x1 > (m_x + m_width))
{
xI_1 = (m_x + m_width);
yI_1 = y1 + Math.round(m * ((m_x + m_width) - x1));
}
if (y2 < m_y)  // endpoint is above window
{
xI_2 = x2 + Math.round((m_y - y2) / m);
yI_2 = m_y;
x2  = xI_2;
y2  = yI_2;
}
else if(y2 > (m_y + m_height))
{
xI_2 = x2 + Math.round(((m_y + m_height) - y2) / m);
yI_2 = (m_y + m_height);
x2  = xI_2;
y2  = yI_2;
}
 
if(x2 < m_x)
{
xI_2 = m_x;
yI_2 = y2 + Math.round(m * (m_x - x2));
}
else if(x2 > (m_x + m_width)) 
{
xI_2 = (m_x + m_width);
yI_2 = y2 + Math.round(m * ((m_x + m_width) - x2));
}
}
else  // trivial reject
{
drawLineFlag = false;
}
if(drawLineFlag)
{
m_stack.add(new Line(xI_1 - m_x, yI_1 - m_y, xI_2 - m_x, yI_2 - m_y));
bresenham(xI_1, yI_1, xI_2, yI_2, true);  
}
}
else
{
m_stack.add(new Line(x1 - m_x, y1 - m_y, x2 - m_x, y2 - m_y));
bresenham(x1, y1, x2, y2, true);   // draw line
}
}
 
public boolean trivialAccept()
{
boolean accept = false;
if((m_x1 >= m_x) && (m_x1 <= m_x + m_width)
&& (m_y1 >= m_y) && (m_y1 <= m_y + m_height)
&& (m_x2 >= m_x) && (m_x2 <= m_x + m_width)
&& (m_y2 >= m_y) && (m_y2 <= m_y + m_height))
accept = true;
return accept;
}
 
public boolean trivialReject()
{
boolean reject = false;
if(m_x1 < m_x  && m_x2 < m_x )
reject = true;
else if( m_y1 < m_y  && m_y2 < m_y)// line is above the rect
reject = true;
else if ((m_x1 > (m_x + m_width)) && (m_x2 > (m_x + m_width))) // line is on the right side of the rect
reject = true;
else if ((m_y1 > (m_y + m_height)) && (m_y2 > (m_y + m_height))) // line is below the rect
reject = true;
 
return reject;
}
}    

import java.awt.event.*;
 
public class Line
{
private int m_x1, m_y1, m_x2, m_y2;
 
public Line(int x1, int y1, int x2, int y2)
{
m_x1 = x1;
m_y1 = y1;
m_x2 = x2;
m_y2 = y2;
}
 
public void setX1(int x1)
{
m_x1 = x1;
}
 
public void setY1(int y1)
{
m_y1 = y1;
}
 
public int getX1()
{
return m_x1;
}
 
public int getY1()
{
return m_y1;
}
 
public void setX2(int x2)
{
m_x2 = x2;
}
 
public void setY2(int y2)
{
m_y2 = y2;
}
 
public int getX2()
{
return m_x2;
}
 
public int getY2()
{
return m_y2;
}
}

[Ulf Dittmer]

That's a fair amount of code. Tell us what it does, and how that is different from what you want it to do. Is it a Java problem, or an algorithm problem, or something else?

[Roberto Favaro]

A rectangle is created in the centre of the window and filled in colour.I may use any click to draw and drag a line on the screen.A line will only be remembered as it is released across the varierents of the rectangle.The line is clipped in size to remember the piece within or partially within the rectangle