drieh nh n

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

 

drieh nh na

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

 

drieh nh nb

7 gelijkbenige driehoeken, hoogte = n

 

drieh nh n na nb

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

header drieh nh

De driehoeken en hun draaipunten, voor de hoogte, het tweede argument in de constructor is n gekozen

 

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

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
 
 

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 ook gebruik van de subclass "Vierk_n"
 
De schets maakt gebruik van 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 Vierkant(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();     
  }     
}