En graficación por computadora necesitamos una forma de representar o describir la
geometría de una escena. El modelado geométrico estudia justo esto, cómo
representar, crear y modificar dichas formas.
Vértices, aristas y caras
Las primitivas geométricas o de dibujo son las formas geométricas más simples (atómicas)
con las que se puede dibujar. Las primitivas más usadas por la mayoría del
hardware gráfico son:
los puntos (vértices), las líneas (aristas) y los triángulos (caras).
Los puntos o vértices nos permiten representar localidades utilizando vectores de 2 o 3
dimensiones, un ejemplo, es el uso de estas primitivas para modelar sistemas de
partículas, donde cada partícula es representada por un punto.
Ejemplo de un sistema de partículas usando puntos.
Por otra parte, una línea o arista, conecta dos vértices, de manera que podemos formar
distintas figuras con un conjunto de líneas, al unir una serie de puntos, así como también
modelar un sistema de partículas, o representar campos vectoriales en 2D y 3D, asociando
cada vector con una línea.
Visualización de un campo vectorial usando líneas.
Por último, tenemos a los triángulos, donde cada triángulo consta de tres vértices unidos
por tres aristas, formando así una cara.
Se opto por esta figura en especial ya que tienen la propiedad de ser coplanarios,
puesto que tres puntos definen un plano, evitando así ambigüedad en cómo deben ser dibujados, lo
cual puede llevar a inconsistencias con el sombreado. Además de ser es el polígono más
simple y que cualquier polígono puede ser triangulado.
Ejemplo de figura (moño) formada con cuatro puntos no coplanarios.
Mallas poligonales
Intuitivamente, una malla poligonal, es una red de polígonos, los cuales están conectados
entre sí por medio de vértices y aristas compartidas para formar así una superficie continua.
Las mallas poligonales surgen naturalmente de la necesidad de representar objetos más complejos,
las más usadas en graficación son las mallas triangulares
(triangle mesh)
o cuadrangulares (quad mesh). Sin embargo, a la hora de renderizar, siempre se utilizan
las primitivas de dibujo, por lo que los cuadriláteros terminarían siendo divididos en dos
triángulos, convirtiéndose en una malla de triángulos. Por esta razón, cuando mencionemos una
malla nos referiremos a una malla triangular.
Ejemplo de modelo descrito con una malla triángular. Puedes mover la posición de la
cámara con el ratón o dedo, así como alejarla o acercarla con la rueda del ratón.
Las mallas poligonales son una de las representaciones más usadas, y una de las razones
principales es porque es sencillo convertir otro tipo de representación a una malla poligonal.
Además de que dibujar triángulos es más fácil de optimizar que dibujar alguna otra figura
más compleja. Como consecuencia las tarjetas de video han evolucionado en esta dirección
para renderizar de forma más eficiente las mallas poligonales.
Por otro lado, una limitación que tiene al ser una representación discreta, es
que las mallas o modelos representan las superficies curvas de manera aproximada,
no obstante, podemos observar con el interactivo que con un buen
número de caras planas,
podemos visualizar superficies curvas sin ningún problema.
Otra desventaja es que no puede compactarse, por lo que para representar un modelo muy
detallado se necesitará una gran cantidad de datos, como podemos observar en la figura
. Además de que no es tan sencillo de modelar a comparación
de otro tipo de representación como superficies implícitas o paramétricas.
Modelo Suzanne de Blender.
Malla con 290 caras triangulares (izquierda) y 15,744 caras triangulares (derecha).
El lector puede mover la cámara, así como alejarla o acercarla, esto último usando la rueda del
ratón.
La descripción mínima de una malla es con un conjunto de triángulos y las posiciones de los
vértices que los conforman. Aunado a esto, la mayoría de los programas suelen
agregar más información en los vértices, aristas o caras, para poder realizar el sombreado
(shading), mapeo de texturas y otro tipo de operaciones.
La manera más común es guardar los atributos (posición, la normal, coordenadas de textura,
colores) en cada vértice, donde cada atributo o parámetro
cambia a lo largo de la superficie, al ser interpolados a lo largo de ésta.
Entonces, para poder representar una malla, necesitamos construir una estructura de datos
que nos permita almacenar y organizar la descripción de la malla de manera eficiente.
Si bien, existe una variedad de estructuras que podemos utilizar dependiendo del las operaciones
que se van a efectuar sobre la malla, nosotros nos enfocaremos en dos de las más usadas.
Podemos representar a una malla triangular simple almacenando cada uno de los triángulos que
la componen como triángulos independientes:
Triángulo {
Vector3 coordenadas[3];
}
Por lo que su estructura de datos correspondería a una lista o un arreglo de triángulos,
donde cada triángulo guarda las coordenadas de cada uno de sus vértices. A esta forma
de almacenamiento se le conoce como caras independientes. Podemos ver un ejemplo
con tan solo tres triángulos en la , obsérvese que
el vértice $\mathbf{v}_1$ es guardado 3 veces, y los otros 2 veces, sumando un
total de $9$ vértices (tres vértices por triángulo).
Malla triangular representada con caras independientes (Izquierda) y
vértices compartidos (Derecha)
Otra forma de representar una malla es separando la información, almacenando a cada vértice
como una estructura independiente y a los triángulos como otra que contenga los índices que
hacen referencia a los vértices que lo conforman:
Triángulo {
int índices[3];
}
Vértice {
Vector3 coordenadas; // Aquí podemos agregar más atributos
}
entonces la estructura de datos correspondería a una lista o un arreglo de vértices y
otra lista o arreglo de triángulos, de esta manera toda la información
de cada vértice
compartido se almacena una sola vez y cada triángulo se representa con tres índices de la
lista de vértices.
A este tipo de estructura se le conoce como indexed triangle mesh o de
vértices compartidos.
Como podemos notar, esta estructura nos permite ahorrar más espacio de almacenamiento,
así como llevar un mejor control de los atributos del vértice.
Por otra parte, un problema que tiene esta implementación es que no permite discontinuidad
de color o alguna otra propiedad, ya que dos polígonos que comparten el mismo vértice,
terminan utilizando la misma información, produciendo un efecto de suavizado en el color de
la superficie. Un ejemplo sencillo es el que se muestra en la .
(Caja azul) Normales compartidas,
(Caja Roja) Normales independientes.
Puedes mover la posición de la cámara con el ratón o dedo.
En donde podemos observar dos cajas. La caja azul utiliza esta misma implementación,
provocando un efecto de suavizado en su color ya que los vértices de las esquinas comparten
la misma normal. Y con la caja roja se soluciona este problema al crear una discontinuidad
geométrica entre estos vértices, se separan las caras duplicando los
vértices de las esquinas, pudiendo así calcular las normales correctamente y
producir una buena iluminación.
Otra desventaja es que toma un poco más de tiempo en acceder a cada vértice, ya que primero se
necesita ver el índice y luego con éste obtenerlo, a diferencia de la primera estructura, donde
se puede acceder directamente.
Tira y abanico de triángulos
La forma de representar una malla de manera más compacta es usando las primitivas de
tira de triángulos o triangle strip y abanico de triángulos o triangle fan.
El primero, consta de una secuencia de triángulos, en donde con los primeros tres vértices
se construye el primer triángulo, y cada nuevo vértice define un nuevo triángulo tomando los dos
últimos vértices del triángulo anterior. Para ser más específicos, dada la lista de vértices
$\{\mathbf{v}_0, \mathbf{v}_1, ..., \mathbf{v}_n\}$, el triángulo $i$ está representado
por los vértices $\{\mathbf{v}_i, \mathbf{v}_{i+1}, \mathbf{v}_{i+2}\}$
(Ver ).
Tira de triángulos
Mientras que para la segunda primitiva, su primer vértice corresponde al vértice común que
compartirán todos los triángulos, donde el triángulo $i$ está representado por los vértices
$\{\mathbf{v}_0, \mathbf{v}_{i+1}, \mathbf{v}_{i+2}\}$ (Ver ).
Abanico de triángulos
De tal forma que con $n$ vértices se obtienen $n-2$ triángulos, usando cualquiera de las
dos primitivas. Por otro lado, si el modelo esta formado por varios strips, éstos suelen unirse
por medio de triángulos degenerados (triángulos con área igual a cero) como se muestra en la
.
Representación de malla uniendo dos tiras de triángulos especificando al triángulo
degenerado $(\mathbf{v}_3, \mathbf{v}_4, \mathbf{v}_3)$en la lista de vértices.
Orientación
Otro punto importante a considerar es la orientación de las caras, para así distinguir
el lado exterior o frontal del lado interior o trasero.
En particular, para un solo triángulo podemos definir su orientación de acuerdo al orden en
que los vértices están listados, esto puede ser en sentido de las manecillas del reloj y en
sentido contrario a las manecillas, como podemos observar en la .
Nótese que las caras $f_1$ y $f_2$ tienen la misma orientación sí y solo sí la arista
compartida aparece descrita en cada cara con sus vértices en orden contrario.
Por lo que la cara que se estaría viendo sería la frontal, y estaría definida en un cierto
sentido, el cual suele ser en contra de las
Orientación de las caras.
manecillas. A esto se lo conoce como
winding direction y los triángulos usan la regla de la mano derecha.
Se dice que una malla está orientada consistentemente si todos los triángulos que la componen
tienen la misma orientación, coincidiendo en qué lado es el frontal, y esto se cumple solamente sí
cada par de triángulos adyacentes están orientados consistentemente. No obstante existen superficies no
orientables, como la banda de Möbius.
Esta propiedad nos permite calcular las normales de las caras de manera correcta. Además
de otras aplicaciones, como en el renderizado de objetos transparentes o para
descartar aquellas caras de la malla que no sean visibles, ya que
si una cara está definida en sentido contrario a las caras frontales, sabemos que se trata de
una cara interior o trasera, la cual no es visible. Por ejemplo, si imaginamos un cubo sólido,
sin importar su dirección, solo seremos capaces de ver a lo más $3$ de sus caras.
Curvas de Bézier
Las curvas de Bézier son una de las representaciones más usadas en GC para trazar
"curvas libres" (free-form curves).
El algoritmo fue desarrollado de manera
independiente por Paul de Casteljau y Pierre Bézier para ser usado dentro de la industria
automotríz. Son llamadas curvas de Bézier debido a que las políticas de privacidad de la empresa
en la que trabajaba de Casteljau le impidieron publicar su trabajo antes.
Una curva de Bézier es una curva polinomial que se aproxima a un conjunto de puntos, llamados
puntos de control, una forma de representarlas es la siguiente.
Dados $n+1$ puntos $P_0, P_1, ..., P_n$ la curva de Bézier es definida por la ecuación
paramétrica:
$$ P(t) = \sum_{i = 0}^n B^{n}_{i} (t) P_i \quad t \in [0,1]$$
donde $P_i$ son los puntos de control y los coeficientes $B^{n}_{i} $ son los polinomios
de Bernstein.
Un polinomio de Bernstein de grado $n$ se define como
$$ B^{n}_{i}(t) = \binom{n}{i} t^{i} (1-t)^{n-i} \quad i = 0, ..., n$$
donde $\binom{n}{i}$ es el coeficiente binomial, y se define como $\binom{n}{i} = \dfrac{n!}{(n-i)!i!}$,
sin embargo, al tener factoriales
se opta por utilizar el patrón de números producido por el triángulo
de Pascal () y se calcula de manera recursiva.
Triángulo de Pascal hasta n = 7.
Las propiedades de los polinomios de Bernstein nos dicen mucho sobre el comportamiento
o forma de las curvas de Bézier, analizaremos algunas de ellas más adelante.
Se dice que una curva es de grado $n$ si es controlada por $n+1$ puntos de control,
por lo que mientras más puntos de control tenga, más flexibilidad tendrá la curva.
Sin embargo, el uso de conjuntos grandes de puntos puede resultar
muy costoso, ya que el grado de los polinomios aumentaría.
Una solución sería uniendo curvas de grados menores.
Empecemos con dos puntos, siendo una curva de Bézier de grado 1.
Sean $P_0$ y $P_1$ dos puntos de control, la curva es un segmento de línea descrito
por la interpolación lineal del punto $P_0$ al punto $P_1$
$$ \begin{aligned}
P(t) =& B^{1}_{0} (t) P_0 + B^{1}_{1} (t) P_1 \\
=& \binom{1}{0} t^0 (1-t)^1 P_0 + \binom{1}{1} t^1(1-t)^0 P_1 \\
=& (1-t)P_0 + tP_1 \quad t \in [0,1]
\end{aligned}
$$
Curva de Bézier de grado 1: Interpolación lineal de dos puntos dado
el parámetro $t$, con $t\in[0,1]$.
Siendo más específicos, si tomamos dos puntos de la forma $P_0 = (x_0,y_0)$ y
$P_1 = (x_1, y_1)$, entonces las coordenadas del punto $P(t) = (x,y)$ en la curva
están dadas por
$$ x' = (1-t)x_0 + tx_1 \quad \text{ y } \quad y' = (1-t)y_0 + ty_1$$
Análogamente para puntos tridimensionales, se realiza una interpolación lineal sobre
cada una de sus coordenadas.
Dados los puntos de control $P_0$, $P_1$ y $P_2$, se define la curva de Bézier de grado
$2$ o cuadrática como
$$P(t) = B^{2}_{0} (t) P_0 + B^{2}_{1} (t) P_1 + B^{2}_{2} (t) P_2 \\ $$
Algoritmo de Casteljau. Construcción de una curva de Bézier de grado 2, con $t\in[0,1]$.
esta expresión puede reescribirse de forma matricial como
$$
\begin{aligned}
P(t) &=
\begin{bmatrix}
(1-t)^2 & t(1-t) & t^2
\end{bmatrix}
\begin{bmatrix}
P_0 \\
P_1 \\
P_2
\end{bmatrix}
\\
&=
\begin{bmatrix}
1 & t & t^2
\end{bmatrix}
\begin{bmatrix}
1 & 0 & 0 \\
-2 & 2 & 0 \\
1 & -2 & 1
\end{bmatrix}
\begin{bmatrix}
P_0 \\
P_1 \\
P_2
\end{bmatrix}
\end{aligned}
$$
donde se multiplica la base $\{1, t, t^2\}$ con los coeficientes obtenidos por
los polinomios (desarrollados) de Bernstein, lo cual suele ser util para
simplificar los cálculos en la implementación.
Dados los puntos de control $P_0$, $P_1$, $P_2$ y $P_3$, se define la curva de Bézier de grado
$3$ o cúbica como
Como hemos podido observar de los interactivos por cada punto adicional, se
agrega además un paso de interpolación.
El algoritmo descrito por los interactivos es el algoritmo de Casteljau y es
una forma de trazar (o aproximar) las curvas de Bézier.
Comienza entonces uniendo los puntos de control adyacentes
para después encontrar el valor en $t$ de cada segmento mediante la interpolación
de sus extremos, dejando un conjunto de $n-1$ puntos. De nuevo, estos puntos son
unidos con líneas y son interpolados en $t$, obteniendo un nuevo
grupo de $n-2$ puntos. Y esto continua hasta terminar con un solo punto, el cual es
el punto final sobre la curva.
Curva de Bézier de grado 4. Se invita al lector a mover los puntos de control arrastrándolos,
así como modificar el valor de $t$. Además de poder agregar puntos de control arbitrarios
con el botón $+$ y eliminar puntos de control con el botón $-$ aumentando o disminuyendo
el grado de la curva.
En la se muestran los polinomios de Bernstein de
grado 1, 2 y 3, los cuales también son llamados como blending functions o
funciones mezcladoras, ya que especifican los valores de peso o influencia que tendrán
sobre sus respectivos puntos de control.
Pues como hemos podido notar en las fórmulas, cada uno de los puntos de control se
corresponde con un polinomio de Bernstein. De modo que la influencia o pesos asociados a
los puntos de control son mezclados para obtener los puntos finales en la curva.
Observando las gráficas nos podemos dar una idea de la influencia que tiene cada
punto de control sobre cada punto de la curva.
Por ejemplo, para $n=1$ (la interpolación
lineal) $(a)$ se muestran las curvas $(1-t)$ y $t$,
vemos que $(1-t)$ empieza en $1$ y termina en $0$, en cambio notamos que $t$ empieza en $0$
y termina en $1$, esto quiere decir que cuando $t=0$, entonces $t= P_0$, y cuando $t$ incrementa,
el peso o influencia de $P_0$ disminuye, mientras que el peso $P_1$ incrementa a medida
que $t$ se acerque a $1$. Finalmente cuando $t=1$ alcanza a $P_1$. Este comportamiento
lo podemos apreciar en los interactivos.
Polinomios de Bernstein de grado 1 (a), 2 (b) y 3 (c). Siendo las
funciones de mezcladoras utilizadas para la construcción de curvas de Bézier.
Graficado con Geogebra Copyright (C) International GeoGebra Institute, 2013.
En general esto se mantiene para todas las curvas de Bézier, es decir, siempre se cumple que
$B^{n}_{0}(0) = 1$ y $B^{n}_{n}(n) = 1$, por lo que la curva solo interpola (pasa por) el primer
y el último punto de control, ya que $P_0$ y $P_n$ son los únicos puntos donde algún polinomio
tiene un valor igual a $1$. Además, la curva es tangente al vector $P_1-P_0$ cuando $t=0$ y
al vector $P_n-P_{n-1}$ cuando $t= 1.$
Mientras que la forma de la curva es aproximada o influenciada por los otros puntos,
por ejemplo para $n=2$, $(b)$, el polinomio $(2t(1-t))$ empieza
en $0,$ después alcanza su punto máximo en $0.5$ y vuelve a terminar en $0,$ dándole así un cierto
peso a $P_1$ cuando $0 < t < 1$. Análogamente con los polinomios de grado $3$,
$(c)$.
La simetría es una propiedad que podemos notar fácilmente e implica que podemos revertir
el orden de los puntos de control y seguir obteniendo la misma curva. Esto, también
se aprecia en las gráficas de la al rededor de $t= 0.5.$
Una propiedad muy importante es la partición de unidad, esto es que los polinomios
de Bernstein suman uno para cualquier valor $t$,
lo cual podemos apreciar mediante la expansión binomial
$$\sum_{i = 0}^n B^{n}_{i} (t) = [(1-t) + t]^n = 1$$
entonces cualquier punto en la curva (o la curva en sí) es una combinación convexa afín
de los puntos de control. Por tanto, todos los puntos estarán dentro del polígono
convexo formado por los puntos de control.
Y siendo una combinación afín, tiene una invariancia afín, esto es que podemos
transformar una curva de Bézier $\alpha$ al aplicar una transformación afín $T$, es decir,
una transformación lineal con una traslación (se verán más a detalle en el
Capítulo 4),
sobre cada uno de sus puntos, dicho de otro modo,
la curva de Bézier asociada a los puntos de control
$ T(P_0), T(P_1), ..., T(P_n)$ es precisamente $T(\alpha)$. Lo cual es fundamental
en graficación para la manipulación de puntos, permitiéndonos también ahorrar memoria al
únicamente almacenar los puntos de control.
Además, podemos ver que cuando se mueve un punto de control, toda la curva es
afectada, se dice entonces que los puntos tienen un control global. Lo
cual no suele ser una característica muy deseada para diseñar curvas, pues se
prefiere que cuando se edite algún punto de control varie sólo en cercanías del
punto modificado, sin alterar la forma del resto de la curva. A esto se le
conoce como control local, lo cual puede ser solucionado con las splines
(funciones polinómicas a trozos).
Parches de Bezier
Canoa. Ejemplo de un modelo que se puede hacer con parches de Bézier.
Puedes mover la posición de la cámara con el ratón o dedo, así como acercarte o alejarte
con la rueda del ratón.
Los parches o superficies de Bézier son una extensión natural de las curvas de Bézier.
Una analogía es un triángulo o un polígono, el cual es una extensión de una línea pasando
de una a dos dimensiones.
Ahora, en vez de interpolar una secuencia de puntos, podemos pensarlo como una manera
de interpolar una secuencia de curvas de Bézier, necesitando ahora dos parámetros para
definir la superficie.
Una superficie o parche de Bézier se define como el producto cartesiano o tensorial
$$
\begin{aligned}
P(u,v) =& \sum^m_{i = 0} \sum^n_{j = 0} B^m_{i}(u) B^n_{j}(v) P_{ij}
\quad (u,v) \in [0,1]^2
\end{aligned}
$$
donde $B^{m}_{i}$ y $B^{n}_{j}$ son los polinomios de Bernstein de grado $m$ y $n$
respectivamente, los cuales actúan como funciones mezcladoras sobre los puntos de
control $P_{ij}$. Notemos que el domino de la superficie es rectangular. Por esta
razón es que suelen ser llamados como parches.
Si mantenemos el parámetro $u$ constante y recorremos la superficie con $v$ de $0$ a $1$,
se traza una curva de Bézier que se encuentra en la superficie, y lo mismo ocurre con
el parámetro $v$.
Siendo más específicos, un parche de Bézier de grado $(m\times n)$ está definido por
$(m+1)\times(n+1)$ puntos de control como
$$
P(u,v) = \sum^m_{i = 0} \sum^n_{j = 0} \binom{m}{i} \binom{n}{j}
u^{i}(1-u)^{m-i} v^{j}(1-v)^{n-j} P_{ij}
\quad (u,v) \in [0,1]^2
$$
Empecemos de nuevo con el más sencillo, extendiendo la interpolación lineal a una
interpolación bilineal. Es decir, en lugar de interpolar dos puntos,
se interpolan cuatro y en lugar de utilizar al parámetro $t$ usaremos dos
parámetros $u$ y $v$. Sean $P_{00}, P_{01}, P_{10}$ y $P_{11}$ los puntos de control, entonces
$u$ interpola a $P_{00}$ con $P_{01}$ y a $P_{10}$ con $P_{11}$ como sigue
$$ Q_0 = (1-u)P_{00} + uP_{01} \quad Q_1 = (1-u)P_{10} + u^P_{11}$$
Parche de Bézier de grado $(1 \times 1)$. Interpolación bilineal usando cuatro puntos.
Finalmente los puntos obtenidos $Q_0$ y $Q_1$ son interpolados por el parámetro $v$,
teniendo
$$
\begin{aligned}
P(u,v) &= (1-v)Q_0 + vQ_1 \\
&= (1-u)(1-v)P_{00} + u(1-v)P_{01} + (1-u)vP_{10} + uvP_{11}
\end{aligned}
$$
con los valores de $(u,v) \in [0,1]^2$.
Y así como con las curvas de Bézier, donde para obtener los puntos sobre la
curva se realizan repetidas interpolaciones lineales. Ahora, para obtener las superficies
de Bézier se realizan repetidas interpolaciones bilineales.
Supongamos que queremos obtener los puntos de un parche de grado $(2\times2)$ o bicuadrático
definido por un arreglo rectangular de $3\times3$ puntos de control $P_{ij}$.
Entonces, para encontrar un punto sobre la superficie dados $u$ y $v,$
primero se interpolan bilinealmente los puntos de control cercanos para así obtener
cuatro puntos intermedios $P^1_{ij}$, ver .
Formando ahora un parche de Bézier de $2\times2$ puntos. Por último
esos cuatro puntos son interpolados bilinealmente para encontrar el punto sobre la
superficie $P^2_{00}$.
Algoritmo de Casteljau.
Proceso para obtener un punto $P(u,v) = P^2_{00}$ sobre un parche de Bézier grado $(2\times2)$
definido con nueve puntos de control $P^0_{ij}$.
Este proceso recursivo es una extensión del algoritmo de Casteljau y se aplica de manera análoga
para parches de Bézier de grado $m \times n$ con $m=n$, teniendo puntos de control $P_{ij}$, con $i,j \in \{0,..,n\}$.
Este caso suele ser el más común y simplifica un poco la implementación.
Sin embargo, también podemos tener el caso en el que tengamos distintos grados para $m$ y $n$,
en particular, con puntos de control $P_{ij}$ con $i \in \{0,...,m\}$ y $j \in \{0,...,n\}$.
Para este tipo de superficies el algoritmo necesita tener una variación.
De la podemos ver que con el algoritmo de
Casteljau no se puede llegar a encontrar al punto sobre la superficie, ya que después de
haberlo
realizado $k = \text{min}(m,n)$ veces, los puntos intermedios $P^{k}_{ij}$ terminan
formando una polígono de control de forma curva. Por lo que ahora se procede a encontrar
al punto en la superficie con el algoritmo univariable de Casteljau, es decir, para curvas.
Algoritmo de Casteljau. Proceso para obtener al punto $P(u,v) = P^4_{00}$ sobre un
parche de Bézier de grado $(3\times 4)$.
Por último, ya que los parches son una extensión natural de las curvas de Bézier, éstos heredan
sus mismas propiedades, enlistadas a continuación
El parche interpola las esquinas de sus puntos de control, esto se puede ver fácilmente
con $(u,v) = (0,0)$, $(u,v) = (0,1)$, $(u,v) = (1,0)$ y $(u,v) = (1,1)$.
La superficie está siempre dentro del polígono convexo formado por los puntos de control.
Es invariante bajo transformaciones afines, es decir, podemos transformar la superficie
aplicando la función de transformación sobre sus puntos de control.
La superficie es tangente a los vectores formados por los puntos de las esquinas y
los puntos adyacentes.
El parche puede ser computado y/o subdividido recursivamente con el algoritmo de Casteljau.
Por otra parte, para construir objetos más complicados varios parches de Bézier pueden
ser unidos o "cosidos" para formarlos.
Parche de Bézier. Se invita al lector a cambiar de superficie
dando clic en el botón Otra, o bien modificando las dimensiones de $m$ y $n.$
Modifica la visualización de la superficie dando clic sobre las opciones: Puntos de control,
Puntos en el parche y/o Parche de Bézier.
Puedes mover la posición de la cámara con el ratón o dedo, así como acercar y alejarte con
la rueda del ratón.
