7 gelijkzijdige driehoeken,
hoogte hn  = sqrt(3*n*n/4);

 

drieh nh na

7 gelijkbenige driehoeken,
hoogte hna = sqrt(a*a-n*n/4);

 

7 gelijkbenige driehoeken, hoogte = n

 

3 driehoeken rode hoogte hn = sqrt(3*n*n/4)
blauw hoogte = n
groen hoogte hna = sqrt(a*a-n*n/4);
 
 
 
 
 
 
 
 
De roterende gelijkzijdige driehoeken
gemaakt met class "drieh_nh"
 
 

header drieh nh

                                      De driehoeken in hun draaipunten

 

Driehoek "Drieh_nh"            terug naar de inleiding         zie ook  de voorbeelden gelijkbenige driehoeken    en  driehoeken en cirkels

Zie ook de schetsen met "Drieh_nh" als gouden driehoek     vijfhoeken en gouden driehoeken en gouden driehoeken en rechthoeken

Deze driehoek heeft als extra tweede argument de hoogte van de driehoek
Met Drieh_nh kan je gelijkbenige, gelijkzijdige en rechthoekige driehoeken maken.
Bij een rechthoekige driehoek is de hoogte de  helft van de basis.
 
basis
eerste argument
in de constructor 
hoogte
 tweede argument   
in de constructor
schuine zijde hoeken 
       
n  float hn = sqrt(3*n*n/4);  n 60,     60,    60
n  float hna = sqrt(a*a-n*n/4); float a = sqrt(2*n*n);  69.3 , 41.4, 69.3
n  n float b = sqrt(5*n*n/4);   
n  n/2 a/2  45      90     45
a  a/2 n  45,     90,    45
2*n  n a  45,     90,    45
2*a  a 2*n  45,     90,    45
n h1 = sqrt(nphi*nphi - n*n/4); float nphi = ((1+sqrt(5))/2)*n  72,     36,    72
 nphi h2 = sqrt(n*n - nphi*nphi/4);  n   36,    108,   36
  
hn = sqrt(3*n*n/4)               is de hoogte van de gelijkzijdige driehoek
nphi =  ((1+sqrt(5))/2)*n     is de schuine zijde van de gouden driehoek, maar ook de lengte van de lijn van hoek naar hoek van de vijfhoek met zijde n.
 
h1 is ook de korte straal + lange straal (rk+rl) van de vijfhoek met zijde n.
h2 is ook de lijn k van hoek naar de nphi lijn van de vijfhoek met zijde n.
 
Het eerste argument in de constructor is de basis, het tweede argument is de hoogte van "Driehoek_nh".
 
 

class Drieh_nh extends Vormen { 
  
Drieh_nh(float n_, float h1_, int d_, float x_, float y_, float hoek_, color c1_) {  
 super();  
 n = n_;  
 h1 = h1_; 
 x = x_;  
 y = y_;  
 hoek = hoek_;  
 c1 = c1_;  
 d = d_;  
 } 
  
void display() {  
 fill(c1);  
 pushMatrix();  
 translate(x, y);  
 rotate(radians(hoek));  
 beginShape(); 
 if (d == 0) {vertex(-n/2, h1/2); vertex(0, -h1/2); vertex(n/2, h1/2);}  
 if (d == 1) {vertex(0, 0); vertex(n/2, -h1); vertex(n, 0);}  
 if (d == 2) {vertex(-n/4, h1/2); vertex(n/4, -h1/2); vertex(n*3/4, h1/2);}  
 if (d == 3) {vertex(-n/2, h1); vertex(0, 0); vertex(n/2, h1);}  
 if (d == 4) {vertex(-n*3/4, h1/2); vertex(-n/4, -h1/2); vertex(n/4, h1/2);}  
 if (d == 5) {vertex(-n, 0); vertex(-n/2, -h1); vertex(0, 0);}  
 if (d == 6) {vertex(-n/2, 0); vertex(0, -h1); vertex(n/2, 0);} 
 endShape(CLOSE);  
 popMatrix();  
}  
}
 
schets met 4 roterende gelijkzijdige driehoeken.
De schets maakt gebruik van de subclass   "Rechthoek",  de superclass  ''vormen''
en de bovenstaande class: "Drieh_nh" waarin als tweede argument in de constructor
de hoogte  float hn = sqrt(3*n*n/4); van de gelijkzijdige driehoek is ingevoerd
Zo maak je van "Drieh_nh" een gelijkzijdige driehoek met zijden n

 

Vormen[] vorm = new Vormen[5]
void setup() { 
  //fullScreen(); 
  size(960, 540); 
  float x = width/2; 
  float y = height/2; 
  float n = height/4; 
  float hn = sqrt(3*n*n/4); //de hoogte van de gelijkzijdige driehoek 
  vorm[0] = new Drieh_nh(n, hn, 5, x-n/2, y-n/2, 0, color(255, 0, 0, 100)); 
  vorm[1] = new Drieh_nh(n, hn, 1, x+n/2, y-n/2, 0, color(200, 0, 100, 100)); 
  vorm[2] = new Drieh_nh(n, hn, 1, x-n/2, y+n/2, 180, color(200, 200, 50, 100)); 
  vorm[3] = new Drieh_nh(n, hn, 5, x+n/2, y+n/2, 180, color(200, 200, 50, 100)); 
  vorm[4] = new Rechthoek(n,n,  0, x, y, 0, color(100, 200, 0, 100)); 
} 
 
void draw() { 
  background(#E6FBFF); 
  //assenstelsel 
  stroke(255, 0, 0); 
  line (width/2, 0, width/2, height); 
  line(0, height/2, width, height/2); 
  stroke(0);    
  for (int i =0; i < 5; i++) 
  { 
    vorm[i].display(); 
  }    
  vorm[0].dpRotRe(vorm[0]); 
  vorm[1].dpRotLi(vorm[1]); 
  vorm[3].dpRotRe(vorm[3]); 
  vorm[2].dpRotLi(vorm[2]); 
} 
 
void keyPressed() {      
  if (key == 's') {     
    noLoop(); 
  }        
  if (key == 'r') {        
    loop(); 
  } 
}