Creating a 2D Cylinder with Java Graphics

user_10723706 0
Viewed 132

I'm trying to make a cylinder using Java Graphics and the paintComponent() method. The user of the application can select which shape they want (in this case it's a cylinder) and input the dimensions they want for the shape. After they input the dimensions and click the submit button, another window will open with the image drawn on it.

My current issue is getting the shape made correctly. I'm currently trying to make two ovals and connect them using two lines. The base will be a red oval and everything else will have no color.

When you submit the dimensions for the cylinder, the sides are never the correct length or in the correct position on the Y-Axis. An example can be view here: Cylinder with incorrect sides

The dimensions for this cylinder: 200 height, 50 radius.

What the cylinder should look like: enter image description here

300 height, 300 radius

I'll be working on adding the minimal version of the program for testing. However, for right now I'll be providing what the code is for the cylinder itself and the paintComponent() method.

Cylinder:

    import java.awt.Color;

public class Cylinder extends Circle {
    private int length;

    public Cylinder(int radius, int length, Color color) {
        super(radius, length, color);
        this.length = length;
        this.radius = radius;
    }
    
    public Cylinder(int newX, int newY, int newRadius, int newLength) {
        super(newX, newY, newRadius);
        length = newLength;
    }

    public int getLength() {
        return length;
    }

    public void setLength(int length) {
        this.length = length;
    }

    public int calcArea() {
        return (int) Math.ceil( 2 * 3.14 * radius * radius + 2 * 3.14 * radius * length);
    }

    public int calcVolume() {
        return (int) Math.ceil(3.14 * radius * radius * length);
    }
    
    public DrawFigure drawFigure() {
        DrawFigure cylinder1 = new DrawFigure(4, getRadius(), length);
        return cylinder1;
    }

    public String toString() {
        return "Length = " + length + " " + super.toString();
    } 
}

DrawFigure (paintComponent is the last method):

import java.awt.Color;
import java.awt.Graphics;

import javax.swing.JPanel;

public class DrawFigure extends JPanel {
    int type;
    int length, width, height, radius;
    
    public DrawFigure() {
        super();
        type = 5;
    }
    
    public DrawFigure(int myType, int myWidth, int myLength, int myHeight) { // Box and Rectangle
        super();
        type = myType;
        length = myLength;
        width = myWidth;
        height = myHeight;
    }
    
    public DrawFigure(int x, int y, int myType, int myWidth, int myLength, int myHeight) {
        super();
        type = myType;
        length = myLength;
        width = myWidth;
        height = myHeight;
    }

    
    public DrawFigure(int myType, int myRadius, int myHeight) {
        super();
        type = myType;
        radius = myRadius;
        height = myHeight;
    }
    
    public void paintComponent(Graphics g) {
        super.paintComponent(g);
        
        if (type == 1) { // Draw Rectangle

        } else if (type == 2) { // Draw Box

        } else if(type == 3) { // Draw Circle
            
        } else if(type == 4) { // Draw Cylinder
            g.setColor(Color.BLACK);
            g.drawOval(135,  65, radius, radius - radius / 2);
            
            // Base
            g.setColor(Color.RED);
            g.fillOval(135, 65 + height, radius, radius / 2);
            
            g.setColor(Color.BLACK);
            g.drawLine(135, 65 + height + (height /4), 135, 135);
            
            g.setColor(Color.BLACK);
            g.drawLine(135 + radius, 65 + height + (height /4), 135 + radius, 135);
            return;
            
        }
    }
}

Full code for the program:

swing java
1 Answers

Okay, so drawing an oval extends from the x/y position, with a positive width/height, that would make the oval draw right/down from the x/y position, for example...

enter image description here

So, assuming we start at 0x0, this would mean that the lines would need to start at a y position of radius / 4, given that you're using radius for the width and radius / 2 for the height (I'm not going to mention how that is confusing). This will allow the lines to "appear" that they join the outer edge of the oval (and draw down)

The lines would then be height long. This means the bottom oval would then need to start at height - (radius / 4) ... okay, I had to go and double check this, but remember, the line ends at (radius / 4) + height, this also means that the cylinder is the height + (radius / 2) high in total.

height=200, radius=50

enter image description here

height=300, radius=300

enter image description here

This prevents scenario where radius / 4 is greater than height, because that would just be a mess

Runnable example...

import java.awt.Color;
import java.awt.Dimension;
import java.awt.EventQueue;
import java.awt.Graphics;
import java.awt.Graphics2D;
import javax.swing.JFrame;
import javax.swing.JPanel;

public class Main {

    public static void main(String[] args) {
        new Main();
    }

    public Main() {
        EventQueue.invokeLater(new Runnable() {
            @Override
            public void run() {
                JFrame frame = new JFrame();
                frame.add(new DrawPane(300, 300));
                frame.pack();
                frame.setLocationRelativeTo(null);
                frame.setVisible(true);
            }
        });
    }

    public class DrawPane extends JPanel {

        int height, radius;

        public DrawPane(int myRadius, int myHeight) {
            super();
            radius = myRadius;
            height = myHeight;
        }

        @Override
        public Dimension getPreferredSize() {
            return new Dimension(400, 400);
        }

        public void paintComponent(Graphics g) {
            super.paintComponent(g);
            Graphics2D g2d = (Graphics2D) g.create();

            int x = (getWidth() - radius) / 2;
            int y = (getHeight() - (height + (radius / 4))) / 2;

            g2d.translate(x, y);

            g2d.setColor(Color.LIGHT_GRAY);
            g2d.drawRect(0, 0, radius, height + (radius / 4));

            // Base
            g2d.setColor(Color.RED);
            g2d.fillOval(0, height - (radius / 4), radius, radius / 2);

            g2d.setColor(Color.BLACK);
            g2d.drawOval(0, 0, radius, radius / 2);

            g2d.setColor(Color.BLACK);
            g2d.drawLine(0, radius / 4, 0, height);
            g2d.drawLine(radius, radius / 4, radius, height);

            g2d.dispose();
        }
    }
}
user_9924840
Related