De los cuales los espejos reflejarán un haz de luz

Question

Hola trato de entender este problema. Tengo 4 números que describen el láser.

$lx$ , $ly$ , $dx$ , $dy$ donde $lx, ly$ son la posición inicial y $dx, dy$ son la dirección.

y a continuación tengo $n$ número de espejos. t $x1, x2, y1, y2$ que describen la posición de los espejos.

por ejemplo

1 1 1 0
3
4.5 0.5 5.5 1.5
4 4 6 5
5.5 2.5 4.5 3.5

Y debo designar la cuenta de los rebotes de los espejos.

imagen por ejemplo

En este caso sólo 1 y 3 espejos

¿Cómo puedo hacer esto?

Answer 1

Puedes seguir estos pasos:

1) Comprueba qué espejos interseccionan la línea que representa el rayo; si no se interseca ningún espejo, sal;

2) para cada espejo intersecado, calcular el punto de intersección y su distancia al punto de inicio del haz;

3) tomar el punto de intersección más cercano al punto de inicio del rayo (éste será el punto de inicio del rayo reflejado) y calcular la dirección del rayo reflejado;

4) Repetir a partir de 1) con el rayo reflejado como nuevo rayo.

Los pasos 1) a 3) requieren un conocimiento estándar de la geometría analítica y se pueden realizar de varias maneras diferentes: por favor, pregunte en caso de que necesite más consejos.

EDITAR.

Para comprobar si un espejo con puntos finales $P$ y $Q$ es intersecado por el rayo, se podría, por ejemplo, encontrar la ecuación cartesiana del rayo, en la forma $f(x,y)=0$ y, a continuación, calcular $f(P)$ y $f(Q)$ la línea que representa el rayo cruza el segmento $PQ$ si y sólo si $f(P)\cdot f(Q)<0$ .

A continuación, encuentre la intersección entre la línea de la viga y la línea $PQ$ . La dirección del haz reflejado viene dada entonces por $$ 2{\vec d\cdot \vec m\over \vec m\cdot \vec m}\vec m-\vec d, $$ donde $\vec d=(d_x,dy)$ es el vector de dirección del rayo incidente, $\vec m=(x_P - x_Q, y_P - y_Q)$ es el vector que une los puntos extremos del espejo y $\cdot$ se utiliza para el producto escalar de vectores.

EJEMPLO.

Voy a mostrar este procedimiento para los datos dados en la pregunta.

La ecuación de la recta con punto de partida $(l_x,l_y)=(1,1)$ y la dirección $(d_x,d_y)=(1,0)$ es $f(x,y)=0$ , donde: $$ f(x,y)=(y-l_y)d_x-(x-l_x)d_y,\quad\hbox{that is:}\quad f(x,y)=y-1. $$

Calculemos $f(x_1,y_1)\cdot f(x_2,y_2)$ para todas las réplicas que tengan puntos finales $(x_1,y_1)$ y $(x_2,y_2)$ .

Espejo 1: $f(4.5, 0.5)\cdot f(5.5, 1.5)=-0.5\cdot0.5=-0.25$ ;

Espejo 2: $f(4, 4)\cdot f(6, 5)=3\cdot4=12$ ;

Espejo 3: $f(5.5, 2.5)\cdot f(4.5, 3.5)=1.5\cdot2.5=3.75$ .

Como puede ver, sólo el espejo 1 es intersecado por el rayo (resultado negativo).

Ahora podemos calcular el punto de intersección $(x_B,y_B)$ entre el haz de luz y el espejo 1: $$ \begin{align} x_B=&{d_y l_x x_1 - d_x l_y x_1 - d_y l_x x_2 + d_x l_y x_2 - d_x x_2 y_1 + d_x x_1 y_2\over d_y x_1 - d_y x_2 - d_x y_1 + d_x y_2}=5,\\ y_B=&{d_y l_x y_1 - d_x l_y y_1 - d_y x_2 y_1 - d_y l_x y_2 + d_x l_y y_2 + d_y x_1 y_2\over d_y x_1 - d_y x_2 - d_x y_1 + d_x y_2}=1. \end{align} $$

Por último, vamos a calcular el vector de dirección del rayo reflejado. El vector del espejo es $\vec m=(x_2 - x_1, y_2 - y_1)=(1,1)$ y el vector de dirección del rayo incidente es $\vec d=(d_x,dy)=(1,0)$ . El vector de dirección del rayo reflejado es entonces: $$ 2{\vec d\cdot \vec m\over \vec m\cdot \vec m}\vec m-\vec d=(0,1). $$

Ahora debes repetir todo el proceso pero con un rayo que empiece en $(5,1)$ y con el vector de dirección $(0,1)$ . Verás que los espejos 2 y 3 son intersecados por la nueva línea del haz (el espejo 1, por supuesto, no debe ser incluido) en los puntos $(5, 4.5)$ y $(5,3)$ respectivamente. Este segundo punto está más cerca del punto de inicio del haz, por lo que la reflexión tiene lugar en el espejo 3, y se puede calcular la dirección del haz reflejado como se ha explicado anteriormente.

Answer 2

Tienes varios problemas que resolver cada vez que el rayo se refleja.

Me gusta utilizar vectores para resolver problemas como éste. Todos los vectores de este problema tienen sólo dos coordenadas. Tendrás que saber cómo sumar dos vectores, cómo restar un vector de otro, cómo tomar el producto escalar de un número y un vector, y cómo tomar el producto interior (también llamado "producto punto") de dos vectores. Es decir, si $u = (u_x, u_y)$ y $v = (v_x, v_y)$ son dos vectores y $r$ es un número, \begin{align} u + v &= (u_x + v_x, u_y + v_y), \\ u - v &= (u_x - v_x, u_y - v_y), \\ rv &= (rv_x, rv_y), \\ u \cdot v &= u_x v_x + u_y v_y. \end{align}

Encuentre el lugar en el que el haz de luz podría intersecar un determinado espejo

Supongo que se le da el punto de partida $p = (p_x,p_y)$ y un vector de dirección $v = (v_x, v_y)$ para el rayo de luz. (Basado en su archivo de entrada y el diagrama, $p_x,p_y,v_x,v_y,$ en ese orden, parecen ser los cuatro números de la primera línea de la entrada).

Construir otro vector $w$ perpendicular a $v.$ Una forma de hacerlo es intercambiar el $x$ y $y$ coordenadas y luego cambiar el signo de una coordenada; por ejemplo, puedes poner $w = (-v_y,v_x).$

También trataremos las posiciones como vectores. Puedes pensar en un "vector de posición" como el vector que da la distancia y la dirección desde $(0,0)$ a un punto, o puede tratar las coordenadas del punto como si fueran coordenadas de un vector.

Dado un espejo con puntos extremos en $a = (a_x,a_y)$ y $b = (b_x,b_y),$ construir los vectores que muestran la distancia y la dirección desde el punto de partida del rayo de luz hasta los puntos finales de los espejos. Estos vectores son las diferencias vectoriales $a - p$ y $b - p.$

Tomar el producto punto de cada uno de los dos últimos vectores con el vector $w$ : \begin{align} r_a &= (a - p) \cdot w, \\ r_b &= (b - p) \cdot w. \end{align} Si los signos de $r_a$ y $r_b$ son iguales (ambos positivos o ambos negativos), el rayo de luz no puede se cruzan con el espejo.

Si los signos de $r_a$ y $r_b$ son opuestos (uno es positivo y otro negativo), entonces el rayo de luz puede se reflejan en el espejo. Hay varias formas de intentar averiguar si realmente se refleja, pero también puedes usar el método que calcula el posible punto de intersección.

El punto de reflexión, es decir, el punto en el que el rayo de luz chocaría con el espejo (si es que lo hace) está en el vector de posición $$ p' = \left(\frac{r_b}{r_b - r_a}\right) a - \left(\frac{r_a}{r_b - r_a} \right) b. $$ La distancia y la dirección de $p'$ de $p$ es $p' - p.$ Tomar el producto punto de esto con el vector de dirección del rayo de luz: $$ d = (p' - p) \cdot v. $$ El número $d$ es una especie de medida de la distancia del punto de reflexión desde el punto de partida del rayo de luz. Si es positivo, el rayo de luz va hacia el espejo; si es negativo, el rayo de luz se aleja del espejo.

Determina en qué espejo se refleja el haz de luz

Para cada espejo, sigue el procedimiento para encontrar el punto de intersección del haz de luz. Ignora el espejo si encuentras que $r_a$ y $r_b$ tienen el mismo signo o si $d$ es negativo. El espejo con el menor valor positivo de $d$ es la que reflejará el rayo de luz.

Por supuesto, si no encuentra ningún espejo con un valor positivo de $d,$ no hay reflexión.

Construir el haz de luz reflejado

Ahora tienes un nuevo punto de partida para el rayo de luz reflejado: es el vector de posición $p'$ donde el rayo de luz entrante se cruzó con el espejo.

Una forma de encontrar la dirección del rayo reflejado es la siguiente. Dados los puntos extremos del espejo, $a$ y $b,$ construir un vector $m= (m_x, m_y)$ que da la dirección y la longitud de la superficie del espejo: $$ m = b - a. $$ Construir un segundo vector $n = (n_x, n_y)$ perpendicular (normal) al espejo: $$ n = (-m_y, m_x). $$ Tome el producto punto de cada uno de estos vectores con el vector $v,$ dividido por el producto punto de $m$ con él mismo; esto te da un número por el que se multiplica cada vector para obtener dos nuevos vectores, así: \begin{align} m' &= \left(\frac{v \cdot m}{m\cdot m}\right) m, \\ n' &= \left(\frac{v \cdot n}{m\cdot m}\right) n. \end{align} (Puede utilizar $n\cdot n$ en lugar de $m\cdot m$ si quieres; son el mismo número).

Los vectores $m'$ y $n'$ son componentes del vector $v$ paralelo al espejo y perpendicular a él. Es decir, se suman al vector original: $v = m' + n'.$ Para obtener la dirección del rayo reflejado, se invierte la componente de la dirección del rayo de luz que es perpendicular al espejo: el nuevo vector de dirección es $$ v' = m' - n'.$$

Ahora tienes una posición de partida $p'$ y una dirección $v'$ del rayo reflejado; repite el procedimiento desde el paso "encuentra dónde el rayo de luz podría intersecar un espejo particular" hasta que no haya más reflexiones.

---

En el procedimiento anterior, he tratado de describir lo que es cada nueva posición o vector para que cuando estés depurando tu programa, puedas comprobar los pasos uno a uno para verificar que están produciendo los resultados que deberían. Si hay un error en mi explicación o un error en tu implementación del mismo, podrás identificar exactamente qué parte del algoritmo estaba mal.

Answer 3

Aquí hay un programa Matlab comentado que he hecho y 3 ejemplos de figuras que muestran haces con reflexiones múltiples generados por él (el tercero es con unos 250 espejos dispuestos a lo largo de una curva elíptica a la que se aproximan segmentos).

Imagino que la "idiosincrasia" de Matlab no será un problema demasiado grande para un adepto a C++ como tú.

Me gustaría subrayar 3 pasos esenciales de este programa (estoy dispuesto a dar más información a petición), con las siguientes anotaciones:

$B=\binom{x_B}{y_B}$ $E=\binom{x_E}{y_E}$ para el inicio y el final del espejo en estudio, $J$ para el punto de impacto en este espejo, $I(x_I,y_I)$ para el punto de impacto anterior, y $\binom{dxi}{dyi}$ el unidad vector director de $IJ$ .

Aquí están estos 3 pasos:

• 1) El cálculo del vector director (unitario) $\binom{dxo}{dyo}$ del nuevo rayo, obteniendo primero el vector director normalizado del espejo : $\vec{D_1}:=\vec{D}/\|\vec{D}\|$ con $\vec{D}=\binom{x_E-x_B}{y_E-y_B}$ ; entonces expresando la matriz de simetría con respecto a este espejo bajo la llamada forma Householder $M=I_2-2D_1D_1^T$ ( https://en.wikipedia.org/wiki/Householder_transformation ), y por último, obteniendo el vector director bajo la forma $\binom{dxo}{dyo}=-M*\binom{dxi}{dyi}$ con un signo menos esencial para proceder en la dirección correcta.

• 2) El cálculo de la longitud $A$ del segmento de línea $IJ$ entre el punto de impacto anterior $I (x_I,y_I)$ y punto de impacto $J$ en la línea BE. Este cálculo utiliza también una herramienta del álgebra lineal, es decir, los determinantes. Basta con expresar la alineación de los puntos $B,J,E$ bajo la siguiente condición de alineación clásica:

$$\tag{1} \begin{vmatrix}x_B&x_J&x_E\\y_B&y_J&y_E\\1&1&1\end{vmatrix}=\begin{vmatrix}x_B&(x_{I}+A.dxi)&x_E\\y_B&(y_{I}+A.dyi)&y_E\\1&1&1\end{vmatrix}=0,$$

Para esta condición, véase por ejemplo ( http://mathworld.wolfram.com/Collinear.html ).

De (1), podemos deducir una expresión para $A$ que se pueden encontrar en el programa. Además, el punto de impacto $J$ no sólo debe estar en línea BE sino dentro de segmento de línea $[BE]$ esto se expresa con la positividad de $d$ que es un producto de determinantes.

• 3) La determinación del espejo que será golpeado primero (si existe...) por el clásico "buffer de profundidad" o la técnica del buffer Z ( https://www.scratchapixel.com/lessons/3d-basic-rendering/rasterization-practical-implementation/visibility-problem-depth-buffer-depth-interpolation ). Véase, por ejemplo, en la esquina noroeste de la primera imagen, el rayo podría chocar con 2 espejos, pero el espejo seleccionado es el primer golpe. Es la parte del programa donde un determinado $Amini$ se minimiza la variable.

Observación: El muy buen texto de @David K tiene las mismas líneas de pensamiento, con una tendencia a utilizar matrices/vectores de manera esencial.

Programa de Matlab:

function allmirrors;

clear all;close all,hold on;axis equal;

Lx=0;Ly=0;plot(Lx,Ly,'*b'); % origin;

dx=rand;dy=rand; % initial direction

% list of mirror endpoints (here a dodecagon);

w=pi/6;r=(1:12)'; M(r,:)=[cos(r*w),sin(r*w),cos((r+1)*w),sin((r+1)*w)];

nbm=size(M,1); % number of mirrors

M=M+0.2*rand(nbm,4); % small perturbation

for k=1:nbm

   plot(M(k,[1,3]),M(k,[2,4]),'k','linesmoothing','on');

end;

A=1000;

Imx=[Lx];Imy=[Ly];

curk=0; % current mirror number on which the ray bumps

h=0; % h = number of rays till now

while A>0.001 && h<100

% depth buffer technique in case there is more than one candidate mirror:

Amini=1000;

for k=1:nbm;

if k ~= curk

[Lxo,Lyo,dxo,dyo,A1]=mirror(k,Lx,Ly,dx,dy,M);

if A1>0 && A1<Amini

Amini=A1;

indi=k;

end; %of internal if

end; %of external if

end;% of for loop

if Amini<999

   [Lx,Ly,dx,dy,A]=mirror(indi,Lx,Ly,dx,dy,M);

   Imx=[Imx,Lx];Imy=[Imy,Ly];

   h=h+1;

   curk=indi;

else

   A=-1;

end;

end; % while

plot(Imx,Imy,'b','linesmoothing','on'); % all the light path

quiver([Lx,Lxo],[Ly,Lyo],[dx,dxo],[dy,dyo],1); % last arrow

%%%%%%%

function [Lxo,Lyo,dxo,dyo,A]=mirror(k,Lxi,Lyi,dxi,dyi,M);

% letters i and o for input and output rays

Lxo=0;Lyo=0;dxo=0;dyo=0;A=0;

x1=M(k,1);x2=M(k,3);y1=M(k,2);y2=M(k,4);

u1=x1-Lxi;v1=y1-Lyi;

u2=x2-Lxi;v2=y2-Lyi;

p=det([u1,v1;dxi,dyi])*det([dxi,dyi;u2,v2]);

% p>0 iff ray hits mirror

A=(u1*v2 - u2*v1)/(dyi*u1 - dyi*u2 - dxi*v1 + dxi*v2) ; % length of ray

if p>0 && A>0

   Lxo=Lxi+A*dxi;Lyo=Lyi+A*dyi;

   N=[x2-x1;y2-y1];N=N/norm(N);

   V=-(eye(2)-2*N*N')*[dxi;dyi]; % symmetry matrix applied to input vector

   dxo=V(1);dyo=V(2);

 else

   A=-1; % then exit from the while loop

end; % if

Answer 4

Así que, básicamente, respondí a esta pregunta antes preguntando si la función/script proporcionada por Jean Marie (una vez más, todo el crédito a él) podría ser utilizado de tal manera que múltiples rayos de luz pueden ser trazados en un espacio de espejo, haciendo efectivamente para una fuente de punto o haz de luz.

Ahora, después de un poco de desconcierto, he encontrado la manera de hacerlo. Haciendo un script de matlab que llame a esta función mientras importa un nuevo conjunto de variables en cada ejecución de la función (usando un bucle for) se puede obtener este resultado. Ver el código proporcionado a continuación.

La función original "allmirrors" proporcionada por Jean marie tiene que ser editada ligeramente para que esto funcione, pero sólo muy ligeramente. Las cosas que hay que cambiar aquí son las siguientes:

1. cambiar el nombre de la función allmirrors por allmirrors(NAME) siendo NOMBRE el nombre del script que utilizará para ejecutar la función.
2. eliminar los comandos close all y clear all de la función.
3. Elimina las definiciones Lx, Ly, dx, dy y M de la función.
4. Añade el siguiente comando para cargar estas variables desde el script principal NOMBRE: load('workspacevars') el nombre workspacevars puede ser cambiado, pero yo usé este. Debe coincidir con el nombre utilizado en el script principal NOMBRE
5. Guarda la función allmirrors con su nombre actual y no la vuelvas a tocar.
6. Cree un nuevo script, llamado NOMBRE, utilizando el código que se proporciona a continuación. En los diferentes bucles for puede proporcionar iteraciones para los cambios en Lx, Ly, dx y dy. Tenga en cuenta que un producto creciente de estos índices (i,j,a,b por defecto) aumenta considerablemente el tiempo de ejecución.
7. Ajuste M de manera que sus espejos estén bien colocados.
8. Ajusta las descripciones de Lx Ly y dx y dy de manera que la fuente de luz que estás describiendo esté bien descrita.
9. Esto debería ser todo. En caso de que haya algún problema, no dude en preguntar.

P.D. El mérito de esta función allmirrors sigue siendo totalmente del Sr. Jean Marie. No pretendo quitarle nada de eso, sólo intento añadir la función de trazar fuentes de luz múltiples. P.P.S. Estoy escribiendo esto ya que había hecho una pregunta sobre esto antes. Creo que es una lástima que el comentario fue eliminado, pero estoy publicando mi solución al problema de todos modos. Espero que a alguien más le sirva esto, así que me gustaría que este comentario pudiera ser publicado :)

    clear all
close all
clc

M=[0 0 1 1];

figure
hold on
for i=1:1;
    Lx=i;
    for j=1:9;
        Ly=i;
        for a=1:1;
            dx=i;
            for b=1:1;
                 dy=i;
              save('workspacevars') 
              allmirrors
            end
        end
    end
end

hold off