Friday, April 18, 2014

Draw simple polygons(Triangle,Square,Rectangle) in Java

package polygon_java;
import java.applet.Applet;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.FlowLayout;
import java.awt.Graphics;
import javax.swing.*;
import java.awt.*;
import java.applet.*;
import java.io.*;
import java.awt.Frame;
import java.awt.event.*;

 public class polygon extends JFrame implements ActionListener
{                           //Class Polygon
JFrame frame;
JButton button1,button2,button3;
JLabel label1,label2,label3;
JTextField text1,text2;
int xarr[]=new int[10];
int yarr[]=new int[10];
int no_sides;
public static void main(String args[])
{
polygon l=new polygon();
l.createframe();
}
public void createframe() //CreateFrame()
{
   frame=new JFrame("Polygon");
   frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
   frame.setSize(400, 400);
   frame.setVisible(true);
   label1= new JLabel("Enter Point Coordinates");
           frame.add(label1);
   label2= new JLabel("X");
   label3= new JLabel("Y");
           frame.setLayout(new FlowLayout());
   frame.add(label2);
   text1=new JTextField();
   text1.setPreferredSize(new Dimension(50,50));
           frame.add(text1);
   frame.add(label3);
   text2=new JTextField();
   text2.setPreferredSize(new Dimension(50,50));
   frame.add(text2);
   button1=new JButton("Enter Next Point");
   button1.addActionListener(this);
   frame.add(button1);
   button2=new JButton("Finish");
   button2.addActionListener(this);
   frame.add(button2);
   button3=new JButton("Clear Polygon");
   button3.addActionListener(this);
   frame.add(button3);
   no_sides=0;
}
public void paint(Graphics g)
{

   g.drawPolygon(xarr, yarr, no_sides);                                                               //DrawPolygon()
}
@Override
public void actionPerformed(ActionEvent event) 
       {
// TODO Auto-generated method stub
if(event.getSource()==button1)
{
int x1=Integer.parseInt(text1.getText());
int y1=Integer.parseInt(text2.getText());
text1.setText(null);
text2.setText(null);
xarr[no_sides]=x1;
yarr[no_sides]=y1;
no_sides++;
}
else if(event.getSource()==button2)
{
int x1=Integer.parseInt(text1.getText());
int y1=Integer.parseInt(text2.getText());
text1.setText(null);
text2.setText(null);
xarr[no_sides]=x1;
yarr[no_sides]=y1;
no_sides++;
paint(frame.getGraphics());
}
else if(event.getSource()==button3)
{
text1.setText(null);
text2.setText(null);
xarr=new int[10];
yarr=new int[10];
no_sides=0;
frame.repaint(); //Repaint()
}
}
}
Output





at No comments:

Scan line polygon filling in QT Creator C++

mainwindow.h file:

 #ifndef MAINWINDOW_H
#define MAINWINDOW_H

 #include <QMainWindow>
#include<QImage>
#include<QRgb>

 namespace Ui {
class MainWindow;
}

 class MainWindow : public QMainWindow
{
    Q_OBJECT

 public:
    explicit MainWindow(QWidget *parent = 0);
    void dda(float,float,float,int ,int ,int ,int ,QRgb);
    ~MainWindow();

 private:
    Ui::MainWindow *ui;
    int n;
    int t;
    int xp;
    int yp;
    int xa[100];
    int ya[100];
    QImage k;
private slots: /*
    void next();
    void draw(); Functions
    void an();
    void check(); */
};

 #endif // MAINWINDOW_H
--------------------------------------------------------------

 mainwindow.cpp file:

 #include "mainwindow.h"
#include "ui_mainwindow.h"
#include<QPixmap>
#include<QRgb>
#include<QImage>
void MainWindow::dda(float m,float x,float y, int x0,int y0,
int x1,int y1,QRgb c)
{
    if(x0<=x1 && y0<=y1)
    {
    if(m<=1 && m>=-1)
    {
        while(x<x1)
        {
            y=y+m;
            x=x+1;
            k.setPixel(x,y,c); //setPixel
        }
    }
    else
    {
        while(y<y1)
        {
            y=y+1;
            x=x+1/m;
            k.setPixel(x,y,c); //setPixel
        }
    }
    }
    else if(x1<=x0 && y1<=y0)
    {
    if(m<=1 && m>=-1)
    {
        while(x>x1)
        {
            y=y-m;
            x=x-1;
            k.setPixel(x,y,c); //setPixel
        }
    }
    else
    {
        while(y>y1)
        {
            y=y-1;
            x=x-1/m;
            k.setPixel(x,y,c); //setPixel
        }
    }
    }
    else if(x0<=x1 && y1<=y0)
    {
    if(m<=1 && m>=-1)
    {
        while(x<x1)
        {
            y=y+m;
            x=x+1;
            k.setPixel(x,y,c); //setPixel
        }
    }
    else
    {
        while(y>y1)
        {
            y=y-1;
            x=x-(1/m);
            k.setPixel(x,y,c); //setPixel
        }
    }
    }
    else if(x1<=x0 && y0<=y1)
    {
    if(m<=1 && m>=-1)
    {
        while(x>x1)
        {
            y=y-m;
            x=x-1;
            k.setPixel(x,y,c); //setPixel
        }
    }
    else
    {
        while(y<y1)
        {
            y=y+1;
            x=x+1/m;
            k.setPixel(x,y,c); //setPixel
        }
    }
    }
}

 MainWindow::MainWindow(QWidget *parent) :
    QMainWindow(parent),
    ui(new Ui::MainWindow)
{
    ui->setupUi(this);
    n=0;
    t=0;
    QImage l(500,500,QImage::Format_ARGB32);
    k=l;
  connect(ui->pushButton_3,SIGNAL(clicked()),this,SLOT(an()));
  connect(ui->pushButton,SIGNAL(clicked()),this,SLOT(next()));
  connect(ui->pushButton_2,SIGNAL(clicked()),this,SLOT(draw()));
  connect(ui->pushButton_4,SIGNAL(clicked()),this,SLOT(check()));
}                        //Function connects

 void MainWindow::an()
{
    n=ui->lineEdit->text().toInt();
    ui->lineEdit->hide();
    ui->label->hide();
}

 void MainWindow::next()
{
    int x0,x1,y0,y1;
    x0=ui->lineEdit_2->text().toInt();
    y0=ui->lineEdit_3->text().toInt();
    x1=ui->lineEdit_4->text().toInt();
    y1=ui->lineEdit_5->text().toInt();
    xa[t]=x0;
    ya[t]=y0;
    QString j;
    j=QString::number(x1,'g',6);
    ui->lineEdit_2->setText(j);
    j=QString::number(y1,'g',6);
    ui->lineEdit_3->setText(j);
    ui->lineEdit_4->setText("");
    ui->lineEdit_5->setText("");
    if(t==0)
    {
        xp=x0;
        yp=y0;
    }
    QRgb c;
    c=qRgb(255,0,0); RGB value
    float m,x,y;
    m=y1-y0;
    m=m/(x1-x0);
    x=x0;
    y=y0;
    dda(m,x,y,x0,y0,x1,y1,c);
    ui->label_6->setPixmap(QPixmap::fromImage(k));
   // ui->label_6->show();
    t++;
    if(t>n-2)
    {
        m=yp-y1;
        m=m/(xp-x1);
        x=x1;
        y=y1;
        xa[n-1]=x1;
        ya[n-1]=y1;
        dda(m,x,y,x1,y1,xp,yp,c);
        ui->pushButton->hide();
    }
}

 void MainWindow::draw() //Draw() Function
{
    ui->label_6->setPixmap(QPixmap::fromImage(k));
    ui->label_6->show();
}

 void MainWindow::check() //check() Function
{
    QRgb c;
    c=qRgb(255,0,0);
    int xc[20];
    int count=0;
    for(int i=1;i<100;i++)
    {
        for(int j=0;j<500;j++)
        {
            if(k.pixel(j,i)==c)
            {
                xc[count]=j;
                count++;
                for(int u=0;u<n;u++)
                {
                    if(j==xa[u] && i==ya[u])
                    {
                        xc[count]=j;
                        count++;
                    }
                }
            }
        }
        for(int j=0;j<count;j=j+2)
        {
            dda(0,xc[j],i,xc[j],i,xc[j+1],i,c);
        }
        count=0;
    }
     ui->label_6->setPixmap(QPixmap::fromImage(k));
     ui->label_6->show();
}

 MainWindow::~MainWindow()
{
    delete ui;
}
Output







at 3 comments:

Line with different line styles(Dashed,Dotted,etc) in Java

filename: Line.java 

 import java.awt.BasicStroke;
import java.awt.Graphics;
import java.awt.Graphics2D;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.SwingUtilities;

 class Surface extends JPanel { //Class Surface

     private void doDrawing(Graphics g) {
        
        Graphics2D g2a = (Graphics2D) g; //Line g2a
        Graphics2D g2d = (Graphics2D) g; //Line g2d

         float[] dash1 = {2f, 0f, 2f}; //Line 2
        float[] dash2 = {1f, 1f, 1f}; //Line 3
        float[] dash3 = {4f, 0f, 10f};  //Line 4
        float[] dash4 = {4f, 4f, 1f}; //Line 5
        
        g2d.drawLine(20, 40, 250, 40);
        
        g2a.setStroke(new BasicStroke(3));
        g2a.drawLine(20,240,250,240);

        BasicStroke bs1 = new BasicStroke(1, BasicStroke.CAP_BUTT,
                BasicStroke.JOIN_ROUND, 10.0f, dash1, 4f);

         BasicStroke bs2 = new BasicStroke(1, BasicStroke.CAP_BUTT,
                BasicStroke.JOIN_ROUND, 1.0f, dash2, 2f);

         BasicStroke bs3 = new BasicStroke(1, BasicStroke.CAP_BUTT,
                BasicStroke.JOIN_ROUND, 1.0f, dash3, 2f);

         BasicStroke bs4 = new BasicStroke(1, BasicStroke.CAP_BUTT,
                BasicStroke.JOIN_ROUND, 1.0f, dash4, 2f);
        g2d.setStroke(bs1);
        g2d.drawLine(20, 80,250, 80);

         g2d.setStroke(bs2);
        g2d.drawLine(20, 120, 250, 120);

         g2d.setStroke(bs3);
        g2d.drawLine(20, 160, 250, 160);

         g2d.setStroke(bs4);
        g2d.drawLine(20, 200, 250, 200);

     }

     @Override
    public void paintComponent(Graphics g) {

         super.paintComponent(g);
        doDrawing(g);
    }
}

 public class line extends JFrame { //Class Line

     public line() {

         initUI();
    }
    
    private void initUI() {
        
        setTitle("Line Styles");
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

         add(new Surface());

         setSize(280, 280);
        setLocationRelativeTo(null);        
    }

     public static void main(String[] args) {

         SwingUtilities.invokeLater(new Runnable() {

             @Override
            public void run() {

                 line bs = new line();
                bs.setVisible(true);
            }
        });
    }
Output

at No comments:

Bresenham's circle drawing algorithm in QT Creator C++

circle.h file:

 #ifndef CIRCLE_H
#define CIRCLE_H
#include <QMainWindow>
#include "ui_circle.h"

 namespace Ui {
class circle;
}

 class circle : public QMainWindow
{
Q_OBJECT
public:
explicit circle(QWidget *parent = 0);
~circle();
private:
Ui::circle *ui;
private slots:
void drawcircle();
};
#endif
___________________________________________________________

 circle.cpp file:

 #include "circle.h"
#include "ui_circle.h"
#include"math.h"

 class line //class Line
{
public:
    QImage draw(int x1,int y1,int x2,int y2, QImage img)
    {
    int dx,dy;
    int g;
    if(x2>x1)
    dx=x2-x1;
    else
    dx=x1-x2;
    if(y2>y1)
    dy=y2-y1;
    else
    dy=y1-y2;
    if(dx>=dy)
    {
    g=(2*dy)-dx;
    while(x1!=x2)
    {
    if(g>0)
    {
    if(x1<x2)
    x1++;
    else
    x1--;
    if(y1<y2)
    y1++;
    else
    y1--;
    g=g+(2*(dy-dx));
    img.setPixel(x1,y1,qRgb(255,255,255)); //set Pixel
    }
    else
    {
    if(x1<x2)
    x1++;
    else
    x1--;
    g=g+(2*dy);
    img.setPixel(x1,y1,qRgb(255,255,255));
    }
    }
    }
    if(dx<dy)
    {
    g=(2*dx)-dy;
    while(y1!=y2)
    {
    if(g>=0)
    {
    if(x1<x2)
    x1++;
    else
    x1--;
    if(y1<y2)
    y1++;
    else
    y1--;
    g=g+(2*(dx-dy));
    img.setPixel(x1,y1,qRgb(255,255,255));
    }
    else
    {
    if(y1<y2)
    y1++;
    else
    y1--;
    g=g+(2*dx);
    img.setPixel(x1,y1,qRgb(255,255,255));
    }
    }
    }
    return img;
    }
};

 circle::circle(QWidget *parent) : //Class Circle
    QMainWindow(parent),
    ui(new Ui::circle)
{
    ui->setupUi(this);
    connect(this->ui->pushButton,SIGNAL(clicked()),
    this,SLOT(drawcircle()));
}

 circle::~circle() //Destructor
{
    delete ui;
}

 void circle::drawcircle() //Drawcircle
{
line l1;
int xc,yc;
int x1,y1,x2,y2;
int r;
int d;
QImage img(400,400,QImage::Format_RGB888);
img.fill(Qt::black);
xc = this->ui->textEdit->toPlainText().toInt();
yc = this->ui->textEdit_2->toPlainText().toInt();
r = this->ui->textEdit_3->toPlainText().toInt();
x1=0;
y1=r;
x2=x1;
y2=y1;
d=3-(2*r);
while(x1<y1)
{
x2=x1;
y2=y1;
x1++;
if(d<0)
{
d=d+(4*x1)+6;
}
else
{
y1=y1-1;
d=d+(4*(x1-y1))+10;
}
img=l1.draw(xc+x1,yc+y1,xc+x2,yc+y2,img);
img=l1.draw(xc-x1,yc+y1,xc-x2,yc+y2,img);
img=l1.draw(xc+x1,yc-y1,xc+x2,yc-y2,img);
img=l1.draw(xc-x1,yc-y1,xc-x2,yc-y2,img);
img=l1.draw(xc+y1,yc+x1,xc+y2,yc+x2,img);
img=l1.draw(xc-y1,yc+x1,xc-y2,yc+x2,img);
img=l1.draw(xc+y1,yc-x1,xc+y2,yc-x2,img);
img=l1.draw(xc-y1,yc-x1,xc-y2,yc-x2,img);
}
ui->label_4->setPixmap(QPixmap::fromImage(img));
}
Output

at No comments:

Line drawing method[DDA & Bresenham's Algorithm] in QT Creator C++

line.cpp file: 

#include "line.h"
#include "ui_line.h"
#include<QMessageBox>
#include<QtGui>
#include<QApplication>
#include<QtGui/QLabel>
#include<QPlainTextEdit>
#include<QString>
#include<QLineEdit>
#include<iostream>
#include "math.h"

 line::line(QWidget *parent) :
    QMainWindow(parent),
    ui(new Ui::line)
{
    ui->setupUi(this);
 connect(this>ui>pushButton,SIGNAL(clicked()),this,SLOT(display1()));                      //display() connect
 connect(this>ui>pushButton_2,SIGNAL(clicked()),this,SLOT(clear())); //clear() connect
}

 line::~line() //Destructor
{
    delete ui;
}

 void line::display1() //Display Function
{
    x1=ui->textEdit->toPlainText().toInt();
    y1=ui->textEdit_2->toPlainText().toInt();
    x2=ui->textEdit_3->toPlainText().toInt();
    y2=ui->textEdit_4->toPlainText().toInt();
    int dx=abs(x1-x2);
    int dy=abs(y1-y2);
    display(dx,dy);
    int g=0;
    display(dx,dy,g);
}

 void line::display(int dx,int dy) //Display Overloading
{
    QImage img(291,231,QImage::Format_ARGB32);
    QRgb rgb=qRgb(255,255,255);
    img.fill(QColor(Qt::black).rgb());
    int n;
    float x_1,y_1;
    float x,y;
     if(dx>dy)
         n=dx;
     else
         n=dy;

      x_1=(float)dx/n;
     y_1=(float)dy/n;
     img.setPixel(x1,y1,rgb);
     x=x1;
     y=y1;
     ui->label->setPixmap(QPixmap::fromImage(img));
     for(int i=0;i<n;i++)
     {
         x=x+x_1;
         y=y+y_1;
         img.setPixel(x,y,rgb);
         ui->label->setPixmap(QPixmap::fromImage(img));
     }
}
void line::display(int dx,int dy,int g) //Display Overloading
{

        int x_1,y_1,n;
       x_1=x1;
       y_1=y1;
       this->ui->label_2->clear();
       QImage img(281,221,QImage::Format_ARGB32);
       QRgb rgb=qRgb(255,255,255);
       img.fill(QColor(Qt::black).rgb());
       if(abs(dx)>=abs(dy))
       {
           g=((2*dy)-dx);
           n=abs(dx);
           while(n>=0)
           {
               if(g>=0)
               {
                   img.setPixel(x_1,y_1,rgb);
                   ui->label_2->setPixmap(QPixmap::
                    fromImage(img));
                   x_1=x_1+1;
                   y_1=y_1+1;
                   g=g+2*(dy-dx);

                }
               else
               {
                   img.setPixel(x_1,y_1,rgb);
                   ui->label_2->setPixmap(QPixmap::
                    fromImage(img));
                   x_1=x_1+1;
                   g=g+2*dy;

                }
               n=n-1;
            }
       }
       else
       {
           g=((2*dx)-dy);
           n=dy;
           while(n>=0)
           {
               if(g>=0)
               {
                   x_1=x_1+1;
                   img.setPixel(x_1,y_1,rgb);
                   ui->label_2->setPixmap(QPixmap::
                    fromImage(img));
                   y_1=y_1+1;
                    g=g+(2*(dx-dy));

                }
               else
               {
                   img.setPixel(x_1,y_1,rgb);
                   ui->label_2->setPixmap(QPixmap::
                    fromImage(img));
                   y_1=y_1+1;
                   g=g+(2*dx);
               }
               n=n-1;
            }
       }
}
void line::clear() //clear function
{
    ui->textEdit->setText("");
    ui->textEdit_2->setText("");
    ui->textEdit_3->setText("");
    ui->textEdit_4->setText("");
    ui->label->clear();
    ui->label_2->clear();
}

----------------------------------------------------------------------------------------------------------------------------------

line.h file:

 #ifndef LINE_H
#define LINE_H

 #include <QMainWindow>

 namespace Ui {
class line;
}

 class line : public QMainWindow
{
    Q_OBJECT
    int x1,y1,x2,y2;
    
public:
    explicit line(QWidget *parent = 0);
    ~line();
    
private:
    Ui::line *ui;
private slots:
    void display1(); /*
     void display(int,int); Functions
    void display(int,int,int);
    void clear(); */
};

 #endif // LINE_H
Output
at 3 comments:

Display a Pixel in Qt Creator C++

pixel.h file:

 #ifndef PIXEL_H
#define PIXEL_H

 #include <QMainWindow>

 namespace Ui {
class pixel;
}

 class pixel : public QMainWindow
{
    Q_OBJECT
    
public:
    explicit pixel(QWidget *parent = 0);
    ~pixel();
    
private:
    Ui::pixel *ui;
private slots:
   void draw();
};

 #endif // PIXEL_H
-----------------------------------------------------------------
pixel.cpp file:
#include "pixel.h"
#include "ui_pixel.h"

 pixel::pixel(QWidget *parent) :
    QMainWindow(parent),
    ui(new Ui::pixel)
{
    ui->setupUi(this);
    connect(this->ui->pushButton,SIGNAL(clicked()),this,SLOT(draw()));
//Function connects
}
pixel::~pixel()
{
    delete ui;
}

 void pixel::draw()
{
    int x1,y1;
    x1=this->ui->textEdit->toPlainText().toInt(); //x-coordinate 
    y1=this->ui->textEdit_2->toPlainText().toInt();//y-coordinate
    QRgb value;                    // RGB value
    value= qRgb(255,255,0);
    QImage q(400,400,QImage::Format_RGB32);
    q.setPixel(x1,y1,value);
    this->ui->label_3->setPixmap(QPixmap::fromImage(q));
}
Output
at No comments:
Subscribe to: Posts (Atom)

Perform a suitable assignment using Xen Hypervisor or equivalent open source to configure it. Give necessary GUI.

 To install kvm on Fedora:  yum install kvm  yum install virt-manager libvirt libvirt-python python-virtinst  su -c "yum install @v...