Duvida em calcular e mostrar os 4 vertices de um Retangulo (x1,y1)->(x1,y1)->(x1,y1)->(x1,y1)

Java

18/04/2014

Tenho a classe Retangulo
public abstract class Retangulo {

   // numero de lados de um retangulo = 4
    protected final int mNLados;
  // centro onde contem um ponto com eixo(x,y) == (0,0)
    protected Ponto mCentro;
 // rotacao do retangulo =0
    protected double mRotacao;
 //  largura ou comprimento
    protected double largura;
  // altura
    protected double altura;

    public Retangulo (double x, double y, double larguras, double alturas, double rotacao, int n_lados) {
        mNLados = n_lados;
        mCentro = new Ponto(x, y);
        mRotacao = rotacao;
        largura = larguras;
        altura = alturas;
    }



A Minha duvida é neste metodo getVertices, dá erro, provavelmente(altura e largura)
 public List<Ponto> getVertices() {
        ArrayList<Ponto> vertices = new ArrayList<>();

        double increment = 360.0 / mNLados;
        for (int i = 0; i < mNLados; ++i) {
            vertices.add(new Ponto(Math.cos((mRotacao + increment * i) * Math.PI / 180) * largura+ mCentro.getX(),
                    Math.sin((mRotacao + increment * i) * Math.PI / 180) * altura+ mCentro.getY()));
        }

        return vertices;
    }
}


Tenho aqui o metodo StringtoString() para mostrar os vertices

[code= java]

@Override
public String toString() {
StringBuilder str = new StringBuilder();
DecimalFormat df = new DecimalFormat("#.00");

str.append("C");
for (Ponto vertice : getVertices()) {
str.append("->").append(vertice);
}
str.append(";");

return str.toString();
}
[/code]

O output para :
largura/comprimento = 10
altura= 5

terá que ser:
Retangulo{(-5,00, -2,50) -> (5,00, -2,50) -> (5,00, 2,50) -> (-5,00, 2,50)}
Sandra Mirador

Sandra Mirador

Curtidas 0

Respostas

Sandra Mirador

Sandra Mirador

18/04/2014

sendo as coordenadas dos vértices do retângulo são:

vertice 1 - (comprimento / 2, altura / 2);
vertice 2 - (-comprimento / 2, altura / 2);
vertice 3 - (-comprimento / 2, -altura / 2);
vertice 4 - (comprimento / 2, -altura / 2);
centro - (0, 0)
GOSTEI 0
Sandra Mirador

Sandra Mirador

18/04/2014

Foi testado assim


public class Main {

    public static void main(String[] args) {
        
        System.out.println("\tRETANGULO");
        Retangulo r = new Retangulo(0, 0, 10, 5, 0, 4);
        System.out.println(r+"\n");

    }
    
}


e sai assim:

RETANGULO
C->(0,00, 0,00)->(0,00, 0,00)->(0,00, 0,00)->(0,00, 0,00);
GOSTEI 0
Sandra Mirador

Sandra Mirador

18/04/2014

usei como base essas coordenadas dos vértices do retângulo:
vertice 1 - (largura / 2, altura / 2);
vertice 2 - (-largura / 2, altura / 2);
vertice 3 - (-largura / 2, -altura / 2);
vertice 4 - (largura / 2, -altura / 2);
centro - (0, 0)


public List<Ponto> getVertices() {
            List<Ponto> vertices = new ArrayList<>();
            Ponto p1 = new Ponto(
                            (((-largura / 2) * Math.cos(Math.toRadians(mRotacao))) - (altura / 2) * Math.sin(Math.toRadians(mRotacao))) + mCentro.getX(),
                            (((-largura / 2) * Math.sin(Math.toRadians(mRotacao))) + (altura / 2) * Math.cos(Math.toRadians(mRotacao))) + mCentro.getY()
            );
            vertices.add(p1);
            p1 = new Ponto(
                            (((largura / 2) * Math.cos(Math.toRadians(mRotacao))) - (altura / 2) * Math.sin(Math.toRadians(mRotacao))) + mCentro.getX(),
                            (((largura / 2) * Math.sin(Math.toRadians(mRotacao))) + (altura / 2) * Math.cos(Math.toRadians(mRotacao))) + mCentro.getY()
            );
            vertices.add(p1);
            p1 = new Ponto(
                            (((largura / 2) * Math.cos(Math.toRadians(mRotacao))) - (-altura / 2) * Math.sin(Math.toRadians(mRotacao))) + mCentro.getX(),
                            (((largura / 2) * Math.sin(Math.toRadians(mRotacao))) + (-altura / 2) * Math.cos(Math.toRadians(mRotacao))) + mCentro.getY()
            );
            vertices.add(p1);
            p1 = new Ponto(
                            (((-largura / 2) * Math.cos(Math.toRadians(mRotacao))) - (-altura / 2) * Math.sin(Math.toRadians(mRotacao))) + mCentro.getX(),
                            (((-largura / 2) * Math.sin(Math.toRadians(mRotacao))) + (-altura / 2) * Math.cos(Math.toRadians(mRotacao))) + mCentro.getY()
            );
            vertices.add(p1);
            return vertices;
    }


Foi testado agora com:
largura/comprimento = 10
altura= 5

e o output está mesmo correto :
Retangulo
(-5,00, -2,50) -> (5,00, -2,50) -> (5,00, 2,50) -> (-5,00, 2,50)
GOSTEI 0
Carlos Proença

Carlos Proença

18/04/2014

Olá Sandra tudo bem?

uma pergunta... qual a ideia do decimal format no seu metodo getVertices?
tentou debugar para ver se os valores passados pelas contas estao corretos?

e se eu entendi... vc tirou o for e deu certo?


att
GOSTEI 0
Sandra Mirador

Sandra Mirador

18/04/2014

Oi Carlos Proença,

o decimal format foi usado no método toString() para aumentar mais duas casas decimais, visto que a altura e o comprimento são inteiros
mas não foi preciso usar...

e se eu entendi... vc tirou o for e deu certo?
Não, na verdade estive a fazer este método em baixo para calcular os vertices dos poligonos regulares(triangulo, quadrado, pentagono, hexagono), mas fiquei com algumas duvidas porque eu ainda não sei como implementar mais um atributo que é o tamanho do poligono que vais ser inserido pelo utilizador, tipo calcular os 3 vertices de um triangulo com tamanho de 10 cm, aí acabei por postar a duvida no forum

public List<Ponto> getVertices() {
        ArrayList<Ponto> vertices = new ArrayList<>();
 
        double increment = 360.0 / mNLados;
        for (int i = 0; i < mNLados; ++i) {
            vertices.add(new Ponto(Math.cos((mRotacao + increment * i) * Math.PI / 180) * largura+ mCentro.getX(),
                    Math.sin((mRotacao + increment * i) * Math.PI / 180) * altura+ mCentro.getY()));
        }
 
        return vertices;
    }
}


com base essas coordenadas dos vértices do retângulo:
vertice 1 - (largura / 2, altura / 2);
vertice 2 - (-largura / 2, altura / 2);
vertice 3 - (-largura / 2, -altura / 2);
vertice 4 - (largura / 2, -altura / 2);
centro - (0, 0)
rotacao=0

Acabei por conseguir fazer este método em baixo que me resolveu, o meu problema, para calculo de vértices de um retângulo com largura 10cm, e altura 5cm
public List<Ponto> getVertices() {
            List<Ponto> vertices = new ArrayList<>();
            Ponto p1 = new Ponto(
                            (((-largura / 2) * Math.cos(Math.toRadians(mRotacao))) - (altura / 2) * Math.sin(Math.toRadians(mRotacao))) + mCentro.getX(),
                            (((-largura / 2) * Math.sin(Math.toRadians(mRotacao))) + (altura / 2) * Math.cos(Math.toRadians(mRotacao))) + mCentro.getY()
            );
            vertices.add(p1);
            p1 = new Ponto(
                            (((largura / 2) * Math.cos(Math.toRadians(mRotacao))) - (altura / 2) * Math.sin(Math.toRadians(mRotacao))) + mCentro.getX(),
                            (((largura / 2) * Math.sin(Math.toRadians(mRotacao))) + (altura / 2) * Math.cos(Math.toRadians(mRotacao))) + mCentro.getY()
            );
            vertices.add(p1);
            p1 = new Ponto(
                            (((largura / 2) * Math.cos(Math.toRadians(mRotacao))) - (-altura / 2) * Math.sin(Math.toRadians(mRotacao))) + mCentro.getX(),
                            (((largura / 2) * Math.sin(Math.toRadians(mRotacao))) + (-altura / 2) * Math.cos(Math.toRadians(mRotacao))) + mCentro.getY()
            );
            vertices.add(p1);
            p1 = new Ponto(
                            (((-largura / 2) * Math.cos(Math.toRadians(mRotacao))) - (-altura / 2) * Math.sin(Math.toRadians(mRotacao))) + mCentro.getX(),
                            (((-largura / 2) * Math.sin(Math.toRadians(mRotacao))) + (-altura / 2) * Math.cos(Math.toRadians(mRotacao))) + mCentro.getY()
            );
            vertices.add(p1);
            return vertices;
    }

Fiz o debug e os valores passados pelas contas estão corretos.
GOSTEI 0
POSTAR