"Reflecție și Refracție" - Processing

ID	Autor	Duplicat din	Ultima modificare
`#4384`	Takacs Robert (RoTak)	-	Duminica, 28 mar 2021, 21:51
Modifică unghiul de incidență cu Left Arrow și Right Arrow.
Modifică indicele de refracție al mediului 1 cu Up Arrow și Down Arrow.
Sincer, habar nu am dacă valorile sunt corecte fizic. Dar arată șmecher.
function setup() {
  createCanvas(400,400);
  angleMode(RADIANS);
  textAlign(LEFT, CENTER);
  background(0);
  sys = new RaySystem(1, 1, 100, 100, PI / 4);
}

  var sys;

function draw() {
  
  sys.update();
  
  drawBack();
  drawText();
  sys.drawRays();
  
  
}

function drawBack(dark)
{
  background(220);
  noStroke();
  fill(color(130 - map(sys.n1, 1, 2.5, 0, 65), 215 - map(sys.n1, 1, 2.5, 0, 100), 230 - map(sys.n1, 1, 2.5, 0, 115)));
  rect(0, 200, 400, 200);
  stroke("#61C1C9");
  strokeWeight(3);
  line(0,200,400,200);
  stroke(0);
  strokeWeight(1);
  fill(0);
}

function drawText()
{
 textSize(10);
 fill(0);
 noStroke();
 text("n1: " + floor(sys.n1 * 100) / 100, 10, 190);
 text("n2: " + floor(sys.n2 * 100) / 100, 10, 210);
 text("unghi incidență (i): " + floor(sys.base.angle * 180 * 100 / PI) / 100, 10, 270);
 if(sys.refrac.exists)
 {
   text("unghi refracție (r): " + floor(sys.refrac.angle * 180 * 100 / PI) / 100, 10, 290);
   text("n1 * sin(i) = n2 * sin(r)", 10, 310);
   text("i < " + floor(asin(sys.n2 / sys.n1) * 180 * 100 / PI) / 100 + " unghiul limită", 10, 330);
 }
 else
 {
  text("nu se refractă! Reflexie totală!", 10, 290);
  text("i > arcsin(n2 / n1)", 10, 310);
  text("i > " + floor(asin(sys.n2 / sys.n1) * 180 * 100 / PI) / 100 + " unghiul limită", 10, 330);
 }
 
 fill(0);
 noStroke();
 triangle(10, 355, 15, 350, 15, 360);
 triangle(30, 355, 25, 350, 25, 360);
 text("unghi incidență", 35, 355);
 
 triangle(13, 370, 10, 380, 16, 380);
 triangle(27, 380, 24, 370, 30, 370);
 text("indice refracție", 35, 375);
 
 fill(0);
}


function keyPressed()
{
 
 if(keyCode === LEFT_ARROW)
 {
   sys.angleMove = -1;
 }
 if(keyCode === RIGHT_ARROW)
 {
   sys.angleMove = 1;
 }
 
 if(keyCode === UP_ARROW)
 {
  sys.indexMove = 1;
 }
 if(keyCode === DOWN_ARROW)
 {
  sys.indexMove = -1; 
 }
}
class RaySystem
{
 constructor(n1, n2, x, y, angle)
 {
  this.n1 = n1;
  this.n2 = n2;
  this.base = new Ray(x, y, angle);
  this.reflec = new Ray(0,0,0);
  this.refrac = new Ray(0,0,0);
  
  this.angleMove = 0;
 }
 
 update()
 {
   this.base.update();
   this.base.moveAngle(this.angleMove, PI / 32);
   this.angleMove = 0;
   
   this.moveIndex(this.indexMove, 0.05);
   this.indexMove = 0;
  
   this.base.calcIntersectionWith("MID");
   
   this.reflec.gainInt(this.base);
   this.reflec.angle = this.base.angle;
   this.reflec.angleReal = PI / 2 - this.reflec.angle;
   this.reflec.calcIntersectionWith("TOP");
   
   this.refrac.gainInt(this.base);
   this.refrac.calcRefractionAngle(this.n1, this.n2, this.base);
   this.refrac.calcIntersectionWith("BOT");
 }
 
 moveIndex(val, prod)
 {
  if(this.n1 + val * prod >= 1 && this.n1 + val * prod <= 2.5)
    {
      this.n1 += val * prod;
    }
 }
 drawRays()
 {
   this.base.Draw("#E8FAA4");
   this.reflec.Draw("#0F37F7");
   this.drawNormal();
   
   if(this.refrac.exists)
   {
     this.refrac.Draw("#15BC27");
   }
 }
 
drawNormal()
{
  stroke("#A0A0A0");
  line(this.base.intX, 0, this.base.intX, 400);
  stroke("0");
}
  
}

class Ray
{
  constructor(x, y, angle) 
  {
    this.x = x;
    this.y = y;
    this.angle = angle;
    this.angleReal = angle - PI / 2;
    this.intX = x;
    this.intY = y;
    this.intersectsMid = false;
    this.exists = true;
  }
  
  update()
  {
    if(mouseX >= 0 && mouseX <= 400) 
    {
      this.x = mouseX;
    }
    if(mouseY >= 0 && mouseY < 200)
    {
      this.y = mouseY;
    }
  }
  
  moveAngle(val, prod)
  {
   if((this.angle + val * prod < PI / 2) && (this.angle + val * prod >= 0))
   {
     this.angle += val * prod;
     this.angleReal += val * prod;
   }
  }
  
  calcIntersectionWith(line)
  {
    if(line == "MID")
      {
        let m = tan(this.angleReal);
        if(m != 0)
        {
          this.intY = 200;
          this.intX = (this.y - 200 + this.x * m) / m;
          this.intersectsMid = true;
        }
        else
        {
          this.intY = y;
          this.intX = 400;
          this.intersectsMid = false;
        }
      }
      
    if(line == "TOP")
    {
      let m = tan(this.angleReal);
      if(m != 0)
      {
        this.intY = 0;
        this.intX = (this.y + this.x * m) / m;
      }
      else
      {
       this.intY = this.y;
       this.intX = 400;
      }
    }
    
    if(line == "BOT")
    {
      let m = tan(this.angleReal);
      if(m != 0)
      {
        this.intY = 400;
        this.intX = (this.y - 400 + this.x * m) / m;
      }
      else
      {
       this.intY = this.y;
       this.intX = 400;
      }
    }
  }
  
  calcRefractionAngle(n1, n2, r)
  {
    let limangle = n2 / n1;
    limangle = asin(limangle);
    
    
    if(r.angle < limangle)
    {
     let temp = n1 * sin(r.angle) / n2;
     this.angle = asin(n1 * sin(r.angle) / n2);
     this.angleReal = this.angle - PI / 2;
     this.exists = true;
    }
    else
    {
      this.exists = false;
    }
    
  }
  
  
  gainInt(r)
  {
   this.x = r.intX;
   this.y = r.intY;
  }
  
  
  Draw(drawcolor)
  {
    stroke(drawcolor);
    strokeWeight(3);
    line(this.x, this.y, this.intX, this.intY);
    stroke("0");
    strokeWeight(1);
  }
}