 # [Resolvido] Erro no cálculo de vértices de um pentágono inscrito na circunferência de raio r

## Recommended Posts Olá a todos,

eu tenho o seguinte construtor da classe poligono

```
public Poligono
{
private Ponto2D centro;

}

centro = centro
}

```

eu tenho o seguinte construtor da classe pentágono,

```public Pentagono(Ponto2D centro, float lado) extends Poligono{
}
```

calcular raio visto, que o pentágono deverá ser inscrito numa circunferência de raio r

```
@Override
return raio;
}

```

depois tenho as seguinte formula para calcular os seguinte vertices do pentagono

http://postimg.org/image/m3ujskind/

e depois ao calcular os vertices apartir da formula no seguinte codigo em baixo,

```@Override
public List<Ponto2D> getVertices() {

double graus = 360.0 / numeroDeLados;

Ponto2D p1 = new Ponto2D(
(float)  mCentro.getY()
);

p1 = new Ponto2D(
(float) mCentro.getX(),
);

p1 = new Ponto2D(
(float) ((1/4 * ( - 1 - Math.sqrt(5)) * lado * Math.cos(radianos)) - (1/4 * (-1 - Math.sqrt(5)) * lado)  * Math.sin(radianos)) + mCentro.getX(),
(float)  mCentro.getY()
);

p1 = new Ponto2D(
(float) ((((-1/2 * Math.sqrt(1 + 2 / Math.sqrt(5))) * lado) * Math.sin(radianos)) - (-1/2 * Math.sqrt(1 + 2 / Math.sqrt(5))) * lado * Math.cos(radianos))+ mCentro.getY()
);

p1 = new Ponto2D(
(float) ((((-1/2 * Math.sqrt(1 + 2 / Math.sqrt(5))) * lado) * Math.sin(radianos)) - (-1/2 * Math.sqrt(1 + 2 / Math.sqrt(5))) * lado * Math.cos(radianos)) + mCentro.getY()
);

return vertices;
}```

só que quando testo o programa no main e o resultado não sai igual a formula

C->[0.00,0.00]->[0.00,0.00]->[0.00,0.00]->[-3.15,0.00]->[-1.61,0.00];

Alguma ajuda ou dica, eu agradeceria

##### Share on other sites Alguma ajuda ou dica, eu agradeceria

o código que te apresentei num outro tópico faz exactamente o que o nome do tópico faz : "calculo de vertices de um pentagono inscrito na circunferencia de raio r" através de um método muito mais simples.

Qual a razão de utilizar essa fórmula ?

• 1

 IRC : sim, é algo que ainda existe >> #p@p

##### Share on other sites eu pretendo usar esse calculo porque de facto, o outro método genérico dá para calcular os vértices dos polígonos regulares mas o problema é qua alguns cálculos de vértices, não está saindo correto, por isso optei por fazer pela formula, houve muitas alterações no projeto, e acabei optando pelo calculo dos vertices pela formula

##### Share on other sites o outro método dá e funciona correctamente para o cálculo dos vértices dos poligonos inscritos numa circunferência.

para o cálculo dos vértices dos restantes, basta fazer override da função e aplicar o método apropriado para o caso particular

como um pentágono recai sobre o primeiro caso, todo este tópico é irrelevante

 IRC : sim, é algo que ainda existe >> #p@p

##### Share on other sites como houve algumas alterações no projeto, com a ajuda do prof, conseguimos fazer assim,

```public abstract class PoligonoRegular extends Poligono {

super(centro);
throw new IllegalArgumentException("Número inválido de lados. Por favor introduza um número maior ");
}
float calculaAngulo = 360 / numeroDeLados;
Ponto2d verticeTopo = new Ponto2d(centro.x, centro.y + raioCirculo);
if (numeroDeLados % 2 == 0) //numero par de lados tem que rodar para ficar com o lado de baixo horizontal
{
verticeTopo = rodar(centro, verticeTopo, calculaAngulo / 2.0F);
}
for (int i = 1; i < numeroDeLados; i++) {
verticeTopo = rodar(centro, verticeTopo, calculaAngulo);
}
}

public class Triangulo extends PoligonoRegular {
public Triangulo(Ponto2d centro, float lado) {
}
```

mas o nosso problema recai em calcular o método para rodar dois pontos de eixo, tal como está indicado em baixo

```verticeTopo = rodar(centro, verticeTopo, calculaAngulo);

private Ponto2D rodar(Ponto2D centro, Ponto2D verticeTopo, float graus) {

}

```

mas optamos por criar uma método aparte para calcular os vertices

##### Share on other sites Eu consigui fazer assim, como está indicado em baixo,

```public Ponto2D rodar2Ponto(Ponto2D centro, Ponto2D verticeTopo, float graus) {

double dx = (centro.mX - verticeTopo.mX);
double dy = (centro.mY - verticeTopo.mY);

centro.mX = (float) (verticeTopo.mX + (dx * Math.cos(radianos) - dy * Math.sin(radianos)));
centro.mY = (float) (verticeTopo.mY + (dx * Math.sin(radianos) + dy * Math.cos(radianos)));

return centro;
}

return raio;
}

public List<Ponto2D> getVertices() {

float calculaAngulo = 360 / numeroDeLados;
Ponto2D verticeTopo = new Ponto2D(mCentro.getX(), mCentro.getY() + raioCirculo);

if (numeroDeLados % 2 == 0) //numero par de lados tem que rodar para ficar com o lado de baixo horizontal
{
verticeTopo = rodar2Ponto(mCentro, verticeTopo, calculaAngulo / 2.0F);
}

for (int i = 1; i < numeroDeLados; i++) {
verticeTopo = rodar2Ponto(mCentro, verticeTopo, calculaAngulo);
}
return vertices;
}
```

está a funcionar mas os cálculos que aparecem no output não está correto tipo assim

um output de um triângulo inscrito numa circunferência raio r e 10 cm de lado

seria

j: (0,00, 5,77) -> (-5,00, -2,89) -> (5,00, -2,89)

clica aqui para ver o desenho

http://www.wolframalpha.com/input/?i=listplot[[0.00,5.77],[-5.00,-2.89],[5.00,-2.89],[0.00,5.77]]

mas no meu output:

[[0.00,4.33],[3.75,6.50],[3.75,6.50],[0.00,4.33]]

http://www.wolframalpha.com/input/?i=listplot[[0.00,4.33],[3.75,6.50],[3.75,6.50],[0.00,4.33]]

## Create an account

Register a new account

×

• #### Revista PROGRAMAR

• Wiki
• IRC
×
• Create New...