Jump to content
mirador_22

[Resolvido] Explicação sobre - polígono inscrito numa circunferência

Recommended Posts

mirador_22

Estou desenvolvendo um projeto sobre formas geométricas em Java e depois em JavaFX e tenho uma duvida em relação a inscrever um polígono regular numa circunferência:

-> Um polígono está inscrito numa circunferência se todos os seus vértices forem pontos da circunferência?

-> Qualquer triângulo pode sempre inscrever-se numa circunferência, basta determinar circuncento (ponto de encontro de mediatriz - centro da circunferência )

-> pelo que percebi, terei que calcular um método para verificar se os vértices calculados pertence ao ponto da circunferência?

-> e no calculo de cada vértice, terei que multiplicar o valor dos vértices calculados com raio da circunferência?

Agradecia desde, a sua atenção

Share this post


Link to post
Share on other sites
mirador_22

Consegui está formula para calcular a circunferência através do raio da circunferência e agora como vou inscrever um polígono nessa circunferência


private float calcularRaio(float lado, int numeroDeLado) {
       float raio = (float) (lado / 2 * Math.sin(Math.PI / numeroDeLado));
       return raio;
   }

float circunferencia = ((2 * Math.PI) * raio)); 

Share this post


Link to post
Share on other sites
Rui Carlos

-> pelo que percebi, terei que calcular um método para verificar se os vértices calculados pertence ao ponto da circunferência?

-> e no calculo de cada vértice, terei que multiplicar o valor dos vértices calculados com raio da circunferência?

Não percebi bem a dúvida, mas falaste em polígonos regulares, e qualquer polígono regular pode ser inscrito numa circunferência. Adicionalmente, calcular o raio da circunferência é relativamente simples.

Era capaz de ajudar se indicasses os inputs do problema, e os outputs esperados (assuma que a dúvida esteja algures em obter os outputs a partir dos inputs).

Share this post


Link to post
Share on other sites
mirador_22

é assim, os inputs serão os lado e números de lados, para calcular o raio do de um polígono regular e

Um ponto para estar inscrito na circunferência terá que estar a uma distância inferior ao raio. Calculei a distância entre os dois pontos usando o teorema de pitágoras http://www.brasilescola.com/matematica/distancia-entre-dois-pontos.htm

//Ou seja, sendo
float x = mCentro.getX() - p.getX();
float y = mCentro.getY() - p.getY();

//Estará no círculo se
Math.sqrt(x*x + y*y) <= raioCirculo;

Onde r é qualquer número positivo <= raio.

Ponto2D p = new Ponto2D(Math.cos(radianos) * r + mCentro.getX(), Math.sin(radianos) * r + mCentro.getY());

A minha duvida agora é como esse r é qualquer número positivo <= raio.

poderia ficar assim:

float r = Math.sqrt(x*x + y*y);

if(r <= raioCirculo){

Ponto2D p = new Ponto2D(Math.cos(radianos) * r + mCentro.getX(), Math.sin(radianos) * r + mCentro.getY());
}

Edited by mirador_22

Share this post


Link to post
Share on other sites
Rui Carlos

Não estou a conseguir acompanhar a maior parte do raciocínio que estás a seguir... nem consegui perceber o que queres fazer.

Em todo o caso, parece-me que que estás a confundir círculo com circunferência. O <= aparece quando tens círculos. Para circunferências deves usar o ==.

Share this post


Link to post
Share on other sites
edazevedo

Estava aqui a tentar perceber onde precisas de ajuda. Os teus cálculos parecem-me bem.

Tu pretendes efetuar o desenho de um polígono e um circulo com base no input do tamanho do lado e do numero de lados?

Ou com base no tamanho do lado e do numero de lados, verificar a circunferência onde o polígono fica circunscrito e com o input de um novo ponto indicar se ele está ou não dentro da circunferência?

Share this post


Link to post
Share on other sites
mirador_22

falei com o meu prof de teoria, ele me disse que:

para considerar se um dado ponto p de coordenadas (x,y) pertence (de forma aproximada) ao polígono terei de:

1. determinar o centro c, de coordenadas (xc, yc) e o raio r da circunferência envolvente do polígono (aquela em que todos os vértices do polígono estão sobre a circunferência, ou, dito de forma correcta, aquela em que todos os vértices do polígono estão inscritos na circunferência)

2. Determinar a distância euclidiana d entre o ponto p(x,y) e o centro da circunferência c(xc,yc).

3. Se d<=r vai considerar que p pertence (de forma aproximada) ao polígono, caso contrário vai considerar que não pertence.

Edited by mirador_22

Share this post


Link to post
Share on other sites
mirador_22

falei com o meu prof de laboratório e ele disse isso:

para escrever um poligono numa circunferência primeiro devemos:

ter em conta o numero de lado se for par começamos no eixo dos x e se for impar no eixo dos y

como já temos o raio que tbm é o valor de x para os poligonos com numero de lado par e 0 para y

desta forma para calcular o outro vertice

basta ter o angulo e o raio

sin teta = cateto oposto / hipotenusa

cos teta = cateto adjacente / hipotenusa

Edited by mirador_22

Share this post


Link to post
Share on other sites
mirador_22

Rui Carlos, de fato estou de acordo contigo, o meu prof disse o mesmo, que eu tinha que diferenciar circulo e circunferência

uma circunferência é o conjunto de pontos à distância de um raio r de um ponto central p de coordenadas (x,y),

enquanto um circulo é o conjunto de pontos a uma distância d <= r (d sempre menor ou igual ao raio da circunferência que delimita o circulo)

Não estou a conseguir acompanhar a maior parte do raciocínio que estás a seguir... nem consegui perceber o que queres fazer.

Em todo o caso, parece-me que que estás a confundir círculo com circunferência. O <= aparece quando tens círculos. Para circunferências deves usar o ==.

edazevedo, posso afirmar que a minha duvida é a mesma que mencionaste na resposta anterior, mas só os meus prof,só estão a pôr-me a fazer asneira e confusão,

Estava aqui a tentar perceber onde precisas de ajuda. Os teus cálculos parecem-me bem.

Tu pretendes efetuar o desenho de um polígono e um circulo com base no input do tamanho do lado e do numero de lados?

Ou com base no tamanho do lado e do numero de lados, verificar a circunferência onde o polígono fica circunscrito e com o input de um novo ponto indicar se ele está ou não dentro da circunferência?

Edited by mirador_22

Share this post


Link to post
Share on other sites
HappyHippyHippo

-> Um polígono está inscrito numa circunferência se todos os seus vértices forem pontos da circunferência?

sim

-> Qualquer triângulo pode sempre inscrever-se numa circunferência, basta determinar circuncento (ponto de encontro de mediatriz - centro da circunferência )

sim e não.

sim porque é possível criar uma circunferência que passe por todos os pontos do triângulo mas somente um triângulo equilátero é que terá a mesma centroide

-> pelo que percebi, terei que calcular um método para verificar se os vértices calculados pertence ao ponto da circunferência?

uma resposta depende da pergunta ...

-> e no calculo de cada vértice, terei que multiplicar o valor dos vértices calculados com raio da circunferência?

já apresentaste diversos tópicos sobre o teu problema e já te foi dada a solução da criação das formas (programaticamente) no primeiro, não percebo a razão de continuares a criares tópicos ...


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

Share this post


Link to post
Share on other sites
mirador_22

sim

sim e não.

sim porque é possível criar uma circunferência que passe por todos os pontos do triângulo mas somente um triângulo equilátero é que terá a mesma centroide

uma resposta depende da pergunta ...

já apresentaste diversos tópicos sobre o teu problema e já te foi dada a solução da criação das formas (programaticamente) no primeiro, não percebo a razão de continuares a criares tópicos ...

o meu problema é que os meus prof, de laboratório e de teoria, estão a dizer que de fato, o código funciona mas que não estou a seguir a logica

para escrever um poligono numa circunferência primeiro devemos:

ter em conta o numero de lado se for par começamos no eixo dos x e se for impar no eixo dos y

como já temos o raio que tbm é o valor de x para os poligonos com numero de lado par e 0 para y

desta forma para calcular o outro vertice

basta ter o angulo e o raio

sin teta = cateto oposto / hipotenusa

cos teta = cateto adjacente / hipotenusa

para considerar se um dado ponto p de coordenadas (x,y) pertence (de forma aproximada) ao polígono terei de:

1. determinar o centro c, de coordenadas (xc, yc) e o raio r da circunferência envolvente do polígono (aquela em que todos os vértices do polígono estão sobre a circunferência, ou, dito de forma correcta, aquela em que todos os vértices do polígono estão inscritos na circunferência)

2. Determinar a distância euclidiana d entre o ponto p(x,y) e o centro da circunferência c(xc,yc).

3. Se d<=r vai considerar que p pertence (de forma aproximada) ao polígono, caso contrário vai considerar que não pertence.

Edited by mirador_22

Share this post


Link to post
Share on other sites
HappyHippyHippo

o meu problema é que os meus prof, de laboratório e de teoria, estão a dizer que de fato, o código funciona mas que não estou a seguir a logica

hahahahahaha

está correcto e bem mais simples do que o método que eles imaginaram, mas como não percebem então está mal ??? sinceramente ...

a única coisa que o código não faz é rodar 90 graus caso o número de lados for ímpar ...

EDIT : volto a apresentar o código já fornecido só com a pequenas alterações como a rotação do 90 graus para FG com número impar de lados:

import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.List;

public class Ponto {
 private double mX;
 private double mY;

 public Ponto() {
   mX = 0;
   mY = 0;
 }

 public Ponto(double x, double y) {
   mX = x;
   mY = y;
 }

 public double getX() {
   return mX;
 }

 public double getY() {
   return mY;
 }

 public void setX(double x) {
   mX = x;
 }

 public void setY(double y) {
   mY = y;
 }

 public void setPosicao(double x, double y) {
   mX = x;
   mY = y;
 }

 public void mover(double x, double y) {
   mX += x;
   mY += y;
 }

 /// Rodar sobre o ponto (0, 0)
 public void rodar(double graus) {
     double normal_vector = Math.sqrt(mX * mX + mY * mY);
     double angulo_actual = Math.acos(mX / normal_vector) * 180 / Math.PI;
     if (mY < 0)
         angulo_actual = -angulo_actual;
     mX = Math.cos((angulo_actual + graus) * Math.PI / 180) * normal_vector;
     mY = Math.sin((angulo_actual + graus) * Math.PI / 180) * normal_vector;
 }

 /// Rodar sobre o ponto (x, y)
 public void rodar(double graus, double x, double y) {
     mX -= x;
     mY -= y;
     rodar(graus);
     mX += x;
     mY += y;
 }

 /// Rodar sobre o ponto "eixo"
 public void rodar(double graus, Ponto eixo) {
     rodar(graus, eixo.getX(), eixo.getY());
 }

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

   str.append("(")
      .append(df.format(mX))
      .append(", ")
      .append(df.format(mY))
      .append(")");

   return str.toString();
 }
}

public abstract class FiguraGeometrica {
 private final int mNLados;

 private Ponto mCentro;
 private double mRotacao;
 private int mNLados;
 private double mLado;

 protected FiguraGeometrica(double x, double y, double rotacao, double tamanho_lado, int n_lados) {
   mNLados = n_lados;

   mCentro = new Ponto(x, y);
   mRotacao = rotacao;
   mLado = tamanho_lado / (2 * Math.sin(Math.PI / mNLados));
 }

 protected FiguraGeometrica(Ponto centro, double rotacao, double tamanho_lado, int n_lados) {
   mNLados = n_lados;

   mCentro = centro;
   mRotacao = rotacao;
   mLado = tamanho_lado / (2 * Math.sin(Math.PI / mNLados));
 }

 public Ponto getPosicao() {
   return mCentro;
 }

 public void setPosicao(double x, double y) {
   mCentro.setPosicao(x, y);
 }

 public void setPosicao(Ponto centro) {
   mCentro = centro;
 }

 public void mover(double x, double y) {
   mCentro.mover(x, y);
 }

 public double getRaio() {
   return mRaio;
 }

 public void setRaio(double raio) {
   mRaio = raio;
 }

 public void escalar(double factor) {
    if (factor > 0) // prevenir valores inválidos
       mRaio *= factor;
 }

 public double getRotacao() {
   return mRotacao;
 }

 public void setRotacao(double graus) {
   mRotacao = graus;
 }

 public int getLado() {
   return mLado;
 }

 public int getNLados() {
   return mNLados;
 }

 /// Rodar sobre o ponto "mCentro"
 public void rodar(double graus) {
   mRotacao += graus;
 }

 /// Rodar sobre o ponto (x, y)
 public void rodar(double graus, double x, double y) {
   mCentro.rodar(graus, x, y);
   mRotacao += graus;
 }

 /// Rodar sobre o ponto "eixo"
 public void rodar(double graus, Ponto eixo) {
   mCentro.rodar(graus, eixo);
   mRotacao += graus;
 }

 public List<Ponto> getVertices() {
   ArrayList<Ponto> vertices = new ArrayList<>();

   // código adicional que faz rodar 90 graus para figuras geométricas com um
   // número impar de lados
   double inicial = 0;
   if (mNLados % 2 == 1)
     double inicial = 90;

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

   return vertices;
 }

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

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

   return str.toString();
 }
}

public class Triangulo extends FiguraGeometrica {
 private static int NLADOS = 3;

 public Triangulo(double x, double y, double rotacao, double tamanho_lado) {
   super(x, y, rotacao, tamanho_lado, NLADOS);
 }

 public Triangulo(Ponto centro, double rotacao, double tamanho_lado) {
   super(centro, rotacao, tamanho_lado, NLADOS);
 }
}


public class Pentagono extends FiguraGeometrica {
 private static int NLADOS = 5;

 public Triangulo(double x, double y, double rotacao, double tamanho_lado) {
   super(x, y, rotacao, tamanho_lado, NLADOS);
 }

 public Triangulo(Ponto centro, double rotacao, double tamanho_lado) {
   super(centro, rotacao, tamanho_lado, NLADOS);
 }
}

Edited by HappyHippyHippo

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

Share this post


Link to post
Share on other sites
mirador_22

hahahahahaha

está correcto e bem mais simples do que o método que eles imaginaram, mas como não percebem então está mal ??? sinceramente ...

a única coisa que o código não faz é rodar 90 graus caso o número de lados for ímpar ...

EDIT : volto a apresentar o código já fornecido só com a pequenas alterações como a rotação do 90 graus para FG com número impar de lados:

import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.List;

public class Ponto {
 private double mX;
 private double mY;

 public Ponto() {
mX = 0;
mY = 0;
 }

 public Ponto(double x, double y) {
mX = x;
mY = y;
 }

 public double getX() {
return mX;
 }

 public double getY() {
return mY;
 }

 public void setX(double x) {
mX = x;
 }

 public void setY(double y) {
mY = y;
 }

 public void setPosicao(double x, double y) {
mX = x;
mY = y;
 }

 public void mover(double x, double y) {
mX += x;
mY += y;
 }

 /// Rodar sobre o ponto (0, 0)
 public void rodar(double graus) {
  double normal_vector = Math.sqrt(mX * mX + mY * mY);
  double angulo_actual = Math.acos(mX / normal_vector) * 180 / Math.PI;
  if (mY < 0)
	  angulo_actual = -angulo_actual;
  mX = Math.cos((angulo_actual + graus) * Math.PI / 180) * normal_vector;
  mY = Math.sin((angulo_actual + graus) * Math.PI / 180) * normal_vector;
 }

 /// Rodar sobre o ponto (x, y)
 public void rodar(double graus, double x, double y) {
  mX -= x;
  mY -= y;
  rodar(graus);
  mX += x;
  mY += y;
 }

 /// Rodar sobre o ponto "eixo"
 public void rodar(double graus, Ponto eixo) {
  rodar(graus, eixo.getX(), eixo.getY());
 }

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

str.append("(")
   .append(df.format(mX))
   .append(", ")
   .append(df.format(mY))
   .append(")");

return str.toString();
 }
}

public abstract class FiguraGeometrica {
 private final int mNLados;

 private Ponto mCentro;
 private double mRotacao;
 private int mNLados;
 private double mLado;

 protected FiguraGeometrica(double x, double y, double rotacao, double tamanho_lado, int n_lados) {
mNLados = n_lados;

mCentro = new Ponto(x, y);
mRotacao = rotacao;
mLado = tamanho_lado / (2 * Math.sin(Math.PI / mNLados));
 }

 protected FiguraGeometrica(Ponto centro, double rotacao, double tamanho_lado, int n_lados) {
mNLados = n_lados;

mCentro = centro;
mRotacao = rotacao;
mLado = tamanho_lado / (2 * Math.sin(Math.PI / mNLados));
 }

 public Ponto getPosicao() {
return mCentro;
 }

 public void setPosicao(double x, double y) {
mCentro.setPosicao(x, y);
 }

 public void setPosicao(Ponto centro) {
mCentro = centro;
 }

 public void mover(double x, double y) {
mCentro.mover(x, y);
 }

 public double getRaio() {
return mRaio;
 }

 public void setRaio(double raio) {
mRaio = raio;
 }

 public void escalar(double factor) {
 if (factor > 0) // prevenir valores inválidos
	mRaio *= factor;
 }

 public double getRotacao() {
return mRotacao;
 }

 public void setRotacao(double graus) {
mRotacao = graus;
 }

 public int getLado() {
return mLado;
 }

 public int getNLados() {
return mNLados;
 }

 /// Rodar sobre o ponto "mCentro"
 public void rodar(double graus) {
mRotacao += graus;
 }

 /// Rodar sobre o ponto (x, y)
 public void rodar(double graus, double x, double y) {
mCentro.rodar(graus, x, y);
mRotacao += graus;
 }

 /// Rodar sobre o ponto "eixo"
 public void rodar(double graus, Ponto eixo) {
mCentro.rodar(graus, eixo);
mRotacao += graus;
 }

 public List<Ponto> getVertices() {
ArrayList<Ponto> vertices = new ArrayList<>();

// código adicional que faz rodar 90 graus para figuras geométricas com um
// número impar de lados
double inicial = 0;
if (mNLados % 2 == 1)
  double inicial = 90;

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

return vertices;
 }

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

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

return str.toString();
 }
}

public class Triangulo extends FiguraGeometrica {
 private static int NLADOS = 3;

 public Triangulo(double x, double y, double rotacao, double tamanho_lado) {
super(x, y, rotacao, tamanho_lado, NLADOS);
 }

 public Triangulo(Ponto centro, double rotacao, double tamanho_lado) {
super(centro, rotacao, tamanho_lado, NLADOS);
 }
}


public class Pentagono extends FiguraGeometrica {
 private static int NLADOS = 5;

 public Triangulo(double x, double y, double rotacao, double tamanho_lado) {
super(x, y, rotacao, tamanho_lado, NLADOS);
 }

 public Triangulo(Ponto centro, double rotacao, double tamanho_lado) {
super(centro, rotacao, tamanho_lado, NLADOS);
 }
}

O prof nos tinha dito anteriormente que foi feitas algumas alterações no projeto na quais:

a classe FigurasGeometricas só ira receber o ponto, nada mais

public abstract class FigurasGeometricas {

public Ponto2D mCentro;

public FigurasGeometricas(Ponto2D centro) {
	this.mCentro = centro;
}
}

e que as classes filhas serão assim como

public abstract class PoligonoRegular extends FigurasGeometricas {
protected float lado;
protected int mNLados;
protected List<Ponto2D> vertices;

public PoligonoRegular(Ponto2D centro, float lado, int numeroDeLado) {
		super(centro);
		this.lado = lado;
		this.mNLados= numeroDeLado;
		this.vertices = getVertices();
}

sendo que a classe triangulo e hexagono, irão herdar a classe poligono regular

public Triangulo(Ponto2D centro, float lado) {
	super(centro, lado, 3);
}
public Hexagono(Ponto2D centro, float lado) {
	super(centro, lado, 6);
}

pelo que nao precisamos de rotação e nem de raio no construtor

o raio deve ser calculado calculado na classe PoligonoRegular pela sua formula base com inputs de tamanho de lados e numero de lados do poligono

eis a formula

public float calcularRaio(float lado, int numeroDeLado) {
	float raio = (float) (lado / 2 * Math.sin(Math.PI / numeroDeLado));
	return raio;
}

Aqui neste metodo getVertices

public List<Ponto> getVertices() {

ArrayList<Ponto> vertices = new ArrayList<>();

// código adicional que faz rodar 90 graus para figuras geométricas com um
// número impar de lados
double inicial = 0;
if (mNLados % 2 == 1)
  double inicial = 90;

double increment = 360.0 / mNLados;

  //Falta fazer
double radianos = Math.toRadians(graus); // temos que usar o graus em radianos
  double raio = calcularRaio(lados,mNLados);

for (int i = 0; i < mNLados; ++i) {
  vertices.add(new Ponto(Math.cos((radianos * i + inicial) * Math.PI / 180) * raio + mCentro.getX(),
					   Math.sin((radianos* i + inicial) * Math.PI / 180) * raio + mCentro.getY()));
}
return vertices;
 }

Agora o que não sei, é se o metodo getVertivces(), está certo ou errado com devidas alterações efetuadas no codigo

Edited by mirador_22

Share this post


Link to post
Share on other sites
HappyHippyHippo

então que o professor tomou sentido no que estava a fazer após ver o código que foi apresentado, afinal qual é a dúvida ?

porque se já tens o código todo, não existe mais nada a determinar ...


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

Share this post


Link to post
Share on other sites
mirador_22

então que o professor tomou sentido no que estava a fazer após ver o código que foi apresentado, afinal qual é a dúvida ?

porque se já tens o código todo, não existe mais nada a determinar ...

só pretendia saber se o método

 public List<Ponto> getVertices() 

; está bem implementado cm base nos inputs tamanho de lado e numero de lados, quem fez estas alterações no codigo , fui eu não o prof., ele apenas me disse que eu não estava seguindo a lógica que ele me tinha dito anteriormente

Edited by mirador_22

Share this post


Link to post
Share on other sites
HappyHippyHippo

não, não está. basta ver que o cálculo dos vértices não está a ser incrementado ...

o código que deverias ter seria algo deste género:

   public List<Ponto> getVertices() {
       ArrayList<Ponto> vertices = new ArrayList<>();

       double rot_inicial = 0;
       if (mNumeroLados % 2 == 1)
           double rot_inicial = 90;

       double inc = 360.0 / mNumeroLados;

       for (int i = 0; i < mNumeroLados; ++i)
           vertices.add(new Ponto2D(Math.cos(Math.toRadians(getRotacaoGraus() + rot_inicial + inc * i) * getRaio() * getFactorEscala() + mCentro.getX(),
                                    Math.sin(Math.toRadians(getRotacaoGraus() + rot_inicial + inc * i) * getRaio() * getFactorEscala() + mCentro.getY()));

       return vertices;
   }


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

Share this post


Link to post
Share on other sites
mirador_22

não, não está. basta ver que o cálculo dos vértices não está a ser incrementado ...

o código que deverias ter seria algo deste género:

public List<Ponto> getVertices() {
	ArrayList<Ponto> vertices = new ArrayList<>();

	double rot_inicial = 0;
	if (mNumeroLados % 2 == 1)
		double rot_inicial = 90;

	double inc = 360.0 / mNumeroLados;

	for (int i = 0; i < mNumeroLados; ++i)
		vertices.add(new Ponto2D(Math.cos(Math.toRadians(getRotacaoGraus() + rot_inicial + inc * i) * getRaio() * getFactorEscala() + mCentro.getX(),
								 Math.sin(Math.toRadians(getRotacaoGraus() + rot_inicial + inc * i) * getRaio() * getFactorEscala() + mCentro.getY()));

	return vertices;
}

mas esses métodos seletores

 getRotacaoGraus(),  getRaio() ,  getFactorEscala()

como apareceram no código se não aparecem nos construtores.

eu gostava muito de terminar esses cálculos e esse projeto, mais cada dia aparece mais duvidas, será que é por que cada programador tem a sua lógica de programar

Edited by mirador_22

Share this post


Link to post
Share on other sites
HappyHippyHippo

mas esses métodos seletores como apareceram no código se não aparecem nos construtores.

e ?

lá por não teres essa informação no construtor não quer dizer que não a tenhas !

pensa um bocado, é que sinceramente parece que nem com o código praticamente todo estás disposta a dar o último passo ...


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

Share this post


Link to post
Share on other sites
mirador_22

e ?

lá por não teres essa informação no construtor não quer dizer que não a tenhas !

pensa um bocado, é que sinceramente parece que nem com o código praticamente todo estás disposta a dar o último passo ...

muito bem, só mais uma informação, sendo o

getRaio()

o valor o calculado do raio apartir (lado,numeroLados),

o

getRotacaoGraus()

, e

getFactorEscala()

, como fazer isso

Share this post


Link to post
Share on other sites
mirador_22

e ?

lá por não teres essa informação no construtor não quer dizer que não a tenhas !

pensa um bocado, é que sinceramente parece que nem com o código praticamente todo estás disposta a dar o último passo ...

eu testei o codigo com

getRotacaoGraus return 1

; e

getFatorEscala() return 1

e consegui esses resultados

podes clicar nos link para visualizar os desenhos

http://www.wolframalpha.com/input/?i=listplot[[-0.08,4.76],[-4.08,-2.45],[4.17,-2.31],[-0.08,4.76]]

http://www.wolframalpha.com/input/?i=listplot[[3.53,0.06],[-0.06,3.53],[-3.53,-0.06],[0.06,-3.53],[3.53,0.06]]

http://www.wolframalpha.com/input/?i=listplot[[-0.06,3.23],[-3.09,0.95],[-1.85,-2.65],[1.95,-2.58],[3.06,1.05],[-0.06,3.23]]

http://www.wolframalpha.com/input/?i=listplot[[2.50,0.04],[1.21,2.19],[-1.29,2.14],[-2.50,-0.04],[-1.21,-2.19],[1.29,-2.14],[2.50,0.04]]

e segundo a aplicação teste, feito pelo prof., o output correto seria como esta:

https://s9.postimg.cc/lurdn2x0r/image.jpg

e o mesmo só consegui utilizando a formula base, mas tu disseste que eu não devia se eu ja tenho um metodo

generico para desenhar os poligonos regulares

Triangulo Equilatero

https://s28.postimg.cc/ipg6lvvm1/triangle_equilateral.jpg

Quadrado

https://s28.postimg.cc/bni8zos09/quadrado.jpg

Pentagono

https://s28.postimg.cc/spb31s6vd/pentagon.jpg

Hexagono

https://s28.postimg.cc/xk4s0256x/hexagon.jpg

Edited by Rui Carlos

Share this post


Link to post
Share on other sites
mirador_22

estas a dizer para rodar 1 grau ...

só coloquei para testar e visualizar os desenhos, na logica a rotaçao em torno do eixo(x,y) será 360º graus, ou seja, 0

Edited by mirador_22

Share this post


Link to post
Share on other sites
mirador_22

só coloquei para testar e visualizar os desenhos, na logica a rotaçao em torno do eixo(x,y) será 360º graus, ou seja, 0

estas a dizer para rodar 1 grau ...

eu falei com o prof, o codigo, ja funciona e cria os vertices perfeitamente, com o teu metodo generico e ele me :

Bom, pelo que vi, o método para cálculo genérico dos vertices terá um pequeno

problema quando fazem o ângulo

Math.toRadians(rotacao_inicial + graus * i)

A rotação inicial serve apenas para atribuirem diretamente o primeiro vértice, que

estará em (r, 0) ou em (0, r) sempre referente ao centro.

Depois disso apenas devem usar o raio e terem sempre o novo vértice calculado em função do

vértice anterior.

Vejam por exemplo aqui: http://math.stackexchange.com/questions/35438/maths-find-vertices-when-1-vertex-and-center-point-is-given-in-polygon

Edited by mirador_22

Share this post


Link to post
Share on other sites

Create an account or sign in to comment

You need to be a member in order to leave a comment

Create an account

Sign up for a new account in our community. It's easy!

Register a new account

Sign in

Already have an account? Sign in here.

Sign In Now

×
×
  • Create New...

Important Information

By using this site you accept our Terms of Use and Privacy Policy. We have placed cookies on your device to help make this website better. You can adjust your cookie settings, otherwise we'll assume you're okay to continue.