Aula 7 - Bandeira do Brasil

Lei Federal Nº 5.700
Art. 5º A feitura da Bandeira Nacional obedecerá às seguintes regras (Anexo nº 2):
I - Para cálculo das dimensões, tomar-se-á por base a largura desejada, dividindo-se esta em 14 (quatorze) partes iguais. Cada uma das partes será considerada uma medida ou módulo.
II - O comprimento será de vinte módulos (20M).
III - A distância dos vértices do losango amarelo ao quadro externo será de um módulo e sete décimos (1,7M).
IV - O círculo azul no meio do losango amarelo terá o raio de três módulos e meio (3,5M).
V - O centro dos arcos da faixa branca estará dois módulos (2M) à esquerda do ponto do encontro do prolongamento do diâmetro vertical do círculo com a base do quadro externo (ponto C indicado no Anexo nº 2).
VI - O raio do arco inferior da faixa branca será de oito módulos (8M); o raio do arco superior da faixa branca será de oito módulos e meio (8,5M).
VII - A largura da faixa branca será de meio módulo (0,5M).

void mostraBandeiraBrasil(float x, float y, float l) {
  float mod = l/14;
  fill(0, 168, 89); // Verde
  rect(x-10*mod, y-7*mod, 20*mod, 14*mod); // Retângulo
  fill(255, 204, 41); // Amarelo
  losango(x, y, mod*16.6, mod*11.4);
  fill(62, 64, 149); // Azul
  ellipse(x, y, 7*mod, 7*mod); // Círculo
  // Desenhar as estrelas (Elas tem seu próprio grid)
  float xe = x - 3.5 * mod;
  float ye = y - 3.5 * mod;
  float mode = 0.35 * mod;
  fill(255);
  estrela(xe+2*mode, ye+8.5*mode, mode, 1); // Cão menor - Alpha
  estrela(xe+6*mode, ye+10.5*mode, mode, 2); // Hidra fêmea - Alpha
  estrela(xe+4*mode, ye+12*mode, mode, 4); // Cão maior - Gama
  estrela(xe+2.5*mode, ye+12.5*mode, mode, 1); // Cão maior - Alpha
  estrela(xe+1.5*mode, ye+13.5*mode, mode, 2); // Cão maior - Beta
  estrela(xe+4.5*mode, ye+13.5*mode, mode, 2); // Cão maior - Delta
  estrela(xe+4.5*mode, ye+14.5*mode, mode, 3); // Cão maior - Epsilon
  estrela(xe+6*mode, ye+15.5*mode, mode, 2); // Argus - Alpha
  estrela(xe+10*mode, ye+11.5*mode, mode, 2); // Cruzeiro do sul - Gama
  estrela(xe+9*mode, ye+12.5*mode, mode, 3); // Cruzeiro do sul - Delta
  estrela(xe+9.7*mode, ye+13*mode, mode, 4); // Cruzeiro do sul - Epsilon
  estrela(xe+11*mode, ye+12.5*mode, mode, 2); // Cruzeiro do sul - Beta
  estrela(xe+10.*mode, ye+14.5*mode, mode, 1); // Cruzeiro do sul - Alpha
  estrela(xe+10.*mode, ye+18*mode, mode, 5); // Sigma do Oitante
  estrela(xe+12.4*mode, ye+14.5*mode, mode, 3); // Triangulo Austral - Gama
  estrela(xe+13*mode, ye+15.8*mode, mode, 2); // Triangulo Austral - Alpha
  estrela(xe+13.8*mode, ye+14.6*mode, mode, 3); // Triangulo Austral - Beta
  estrela(xe+15*mode, ye+16.7*mode, mode, 3); // Escorpião - Iota
  estrela(xe+15*mode, ye+15.7*mode, mode, 2); // Escorpião - Teta
  estrela(xe+15*mode, ye+14.7*mode, mode, 3); // Escorpião - Mu
  estrela(xe+16*mode, ye+14.8*mode, mode, 3); // Escorpião - Capa
  estrela(xe+16.8*mode, ye+14.2*mode, mode, 2); // Escorpião - Lambda
  estrela(xe+17.2*mode, ye+13.8*mode, mode, 2); // Escorpião - Epsilon
  estrela(xe+17*mode, ye+12.2*mode, mode, 1); // Escorpião - Alpha
  estrela(xe+19.2*mode, ye+12.5*mode, mode, 3); // Escorpião - Beta
  estrela(xe+13.7*mode, ye+9.5*mode, mode, 3); // Hidra fêmea - Gama
  estrela(xe+14*mode, ye+6.5*mode, mode, 1); // Virgem - Alpha
  // Desenha o bendito arco branco
  beginShape();
  for (float i = 0; i <= 0.1; i += 0.001) {
    if (distancia(x+3.5*mod*sin(PI*i+PI*0.4), y+3.5*mod*cos(PI*i+PI*0.4), x-2*mod+8.5, y+7*mod+8.5)<=8.5*mod&&distancia(x+3.5*mod*sin(PI*i+PI*0.4), y+3.5*mod*cos(PI*i+PI*0.4), x-2*mod+8.0, y+7*mod+8.0)>=8.0*mod) {
      vertex(x+3.5*mod*sin(PI*i+PI*0.4), y+3.5*mod*cos(PI*i+PI*0.4));
    }
  }
  for (float i = 0; i <= 0.35; i += 0.001) {
    if (distancia(x, y, x-2*mod+8.5*mod*sin(PI*i+2.3), y+7*mod+8.5*mod*cos(PI*i+2.3))<=3.5*mod) {
      vertex((x-2*mod)+8.5*mod*sin(PI*i+2.3), (y+7*mod)+8.5*mod*cos(PI*i+2.3));
    }
  }
  for (float i = 0; i <= 0.1; i += 0.001) {
    if (distancia(x+3.5*mod*sin(PI*i+PI*0.4), y+3.5*mod*cos(PI*i+PI*0.4), x-2*mod+8.5, y+7*mod+8.5)<=8.5*mod&&distancia(x+3.5*mod*sin(PI*i+PI*0.4), y+3.5*mod*cos(PI*i+PI*0.4), x-2*mod+8.0, y+7*mod+8.0)>=8.0*mod) {
      vertex(x+3.5*mod*sin(PI*i+PI*1.35), y+3.5*mod*cos(PI*i+PI*1.35));
    }
  }
  for (float i = 0.35; i >= 0; i -= 0.001) {
    if (distancia(x, y, x-2*mod+8.0*mod*sin(PI*i+2.3), y+7*mod+8.0*mod*cos(PI*i+2.3))<=3.5*mod) {
      vertex((x-2*mod)+8.0*mod*sin(PI*i+2.3), (y+7*mod)+8.0*mod*cos(PI*i+2.3));
    }
  }
  endShape();
}

void setup() {
  size(600, 400);
  background(0);
  noStroke();
}

void draw() {
  mostraBandeiraBrasil(width/2, height/2, height*0.8);
}

void losango(float x, float y, float w, float h) {
  quad(x-w/2, y, x, y-h/2, x+w/2, y, x, y+h/2);
}

void estrela(float x, float y, float mod, int g) { // Para criar as estrelinhas
  float r;
  switch(g) { // A ordem de grandeza em relação ao raio
  case 1: 
    r = 0.3*mod;
    break;
  case 2: 
    r = 0.25*mod;
    break;
  case 3: 
    r = 0.2*mod;
    break;
  case 4: 
    r = 0.14*mod;
    break;
  case 5: 
    r = 0.1*mod;
    break;
  default: 
    r = 0;
  }
  beginShape();  // Estrela de 5 pontas
  vertex(x+r*sin(TAU*0.1), y+r*cos(TAU*0.1));
  vertex(x+r*sin(TAU*0.2)/2, y+r*cos(TAU*0.2)/2);
  vertex(x+r*sin(TAU*0.3), y+r*cos(TAU*0.3));
  vertex(x+r*sin(TAU*0.4)/2, y+r*cos(TAU*0.4)/2);
  vertex(x+r*sin(TAU*0.5), y+r*cos(TAU*0.5));
  vertex(x+r*sin(TAU*0.6)/2, y+r*cos(TAU*0.6)/2);
  vertex(x+r*sin(TAU*0.7), y+r*cos(TAU*0.7));
  vertex(x+r*sin(TAU*0.8)/2, y+r*cos(TAU*0.8)/2);
  vertex(x+r*sin(TAU*0.9), y+r*cos(TAU*0.9));
  vertex(x+r*sin(TAU*1.0)/2, y+r*cos(TAU*1.0)/2);
  endShape();
}

float distancia(float x1, float y1, float x2, float y2) {
  float q1 = (x1 - x2) * (x1 - x2);
  float q2 = (y1 - y2) * (y1 - y2);
  float r = sqrt(q1+q2);
  return r;
}

Para criar a bandeira do Brasil de acordo com a lei, foi criada uma função com os parâmetros X, Y e L, os quais recebem a posição do centro e a largura da bandeira. A função então calcula o valor do módulo de acordo com o Art. 5/I e a partir desse módulo se calcula o valor das outras medidas (O comprimento da bandeira, as dimensões do losango, o raio do círculo).
A função losango foi feita em função da posição, altura e largura o qual recebeu o seu valor já calculado pelos módulos, também pelo centro, os vertices eram +/- metade da altura ou largura do que se pedia alternadamente.
Apesar de não ter sido pedido, também fiz as estrelas, criadas por uma função beginShape()/endShape() no qual faziam vértices com dois raios diferentes alternadamente e colocado no grid. a função recebia a posição, o valor do módulo e a ordem de grandeza da estrela.