Descripción general de la teoría del marco de vista de gráficos
I. Resumen
La vista de gráficos proporciona una superficie para administrar e interactuar con una gran cantidad de elementos de gráficos 2D personalizados y un widget de vista para visualizar estos elementos, compatible con el zoom y la rotación.
El marco incluye una arquitectura de propagación de eventos que permite una interacción precisa de doble precisión entre elementos en una escena. Los elementos pueden manejar eventos clave, presionar el mouse, mover, soltar y hacer doble clic, y pueden rastrear el movimiento del mouse.
La vista de gráficos utiliza un árbol BSP (Binary Space Partitioning) para proporcionar un descubrimiento de elementos muy rápido, por lo que puede visualizar escenas grandes en tiempo real, incluso con millones de elementos.
Graphics View se introdujo en Qt 4.2, reemplazando a su predecesor QCanvas.
2. Arquitectura de vista de gráficos
Graphics View proporciona un enfoque basado en elementos para la programación de vista de modelo, muy similar a las clases de conveniencia QTableView, QTreeView y QListView de InterView. Varias vistas pueden observar la misma escena, que contiene elementos de diferentes formas geométricas.
1. La escena
QGraphicsScene proporciona la escena de la vista de gráficos. Las responsabilidades de la escena son las siguientes:
- Proporciona una interfaz rápida para administrar una gran cantidad de artículos
- Propagar el evento a cada elemento
- Administrar el estado del elemento, como la selección y el manejo del enfoque
- Proporciona funcionalidad de representación sin transformar; se utiliza principalmente para la funcionalidad de impresión
La escena actúa como un contenedor para los objetos QGraphicsItem. Los elementos se agregan a la escena llamando a QGraphicsScene::addItem() y luego se recuperan llamando a una de las muchas funciones de descubrimiento de elementos. QGraphicsScene::items() y sus funciones sobrecargadas devuelven todos los elementos contenidos o intersecados por un punto, rectángulo, polígono o ruta vectorial general . QGraphicsScene::itemAt() Devuelve el elemento superior en la posición especificada.Todas las funciones de descubrimiento de elementos devuelven elementos apilados en orden descendente (es decir, el primer elemento devuelto está en la parte superior y el último elemento devuelto está en la parte inferior).
QGraphicsScene scene;
QGraphicsRectItem *rect = scene.addRect(QRectF(0, 0, 100, 100));
QGraphicsItem *item = scene.itemAt(50, 50);
// item == rect
La arquitectura de propagación de eventos de QGraphicsScene programa eventos de escena para su entrega a elementos y administra la propagación entre elementos. Si la escena recibe un evento con el mouse presionado en una determinada ubicación, la escena pasará el evento a cualquier elemento en esa ubicación.
QGraphicsScene también administra ciertos estados de elementos, como la selección y el enfoque de elementos. Puede seleccionar elementos en la Escena llamando a QGraphicsScene::setSelectionArea(), pasando un argumento de cualquier forma. Esta función también se utiliza como base para la selección de bandas elásticas en QGraphicsView. Para obtener una lista de todos los elementos seleccionados actualmente, llame a QGraphicsScene::selectedItems(). Otro estado que maneja QGraphicsScene es si el elemento tiene foco de entrada de teclado. Podemos establecer el foco en un elemento llamando a QGraphicsScene::setFocusItem() o QGraphicsItem::setFocus(), u obtener el elemento actualmente enfocado llamando a QGraphicsScene::focusItem().
Finalmente, QGraphicsScene nos permite representar partes de la escena en el dispositivo de dibujo a través de la función QGraphicsScene::render().
Esto nos proporciona una base para generar imágenes.
2. La vista
QGraphicsView proporciona un control de vista, que puede visualizar el contenido de la escena. Puede agregar múltiples vistas a la misma escena, proporcionando así múltiples vistas para el mismo conjunto de datos. El widget de vista es un área de desplazamiento que proporciona barras de desplazamiento para navegar dentro de una escena grande. Para habilitar la compatibilidad con OpenGL, se puede establecer un QGLWidget como vista llamando a QGraphicsView::setViewport().
QGraphicsScene scene;
myPopulateScene(&scene);
QGraphicsView view(&scene);
view.show();
La vista recibe eventos de entrada del teclado y el mouse, y convierte estos eventos en eventos de escena (convierte las coordenadas utilizadas en coordenadas de escena) y luego envía los eventos a la escena visual.
Usando su matriz de transformación QGraphicsView::transform(), la vista puede transformar el sistema de coordenadas de la escena. Las vistas también permiten funciones de navegación avanzadas como el zoom y la rotación. Para mayor comodidad, QGraphicsView también proporciona funciones para convertir entre coordenadas de vista y escena: QGraphicsView::mapToScene() y QGraphicsView::mapFromScene().
3. Elemento gráfico Elemento
QGraphicsItem es la clase base de elementos gráficos en Scene. La vista de gráficos proporciona algunos elementos estándar para formas de uso común, como rectángulo (QGraphicsItem), elipse (QGraphicsEllipseItem) y elemento de texto (QGraphicsTextItem), pero al escribir elementos personalizados, podemos usar las características más potentes de QGraphicsItem. Solo hereda esta función.
QGraphicsItem admite las siguientes características:
- Pasar el ratón, mover, soltar y hacer doble clic en eventos, así como pasar el ratón por encima, la rueda y los eventos del menú contextual.
- Foco de entrada de teclado y eventos clave
- Arrastrar y soltar Soltar y arrastrar
- Gestión de grupos, relación padre-hijo y método de agrupación QGraphicsItemGroup
- Comprobación de impacto
Los elementos existen en un sistema de coordenadas local. Al igual que QGraphicsView, también proporciona muchas funciones para asignar coordenadas entre elementos y Escena, y coordenadas entre elementos y elementos. Además, al igual que QGraphicsView, puede transformar su sistema de coordenadas utilizando la matriz QGraphicsItem::transform(). Esto es útil para rotar y escalar elementos individuales.
Los artículos pueden contener otros artículos (artículos secundarios). La transformación de un padre es heredada por todos sus hijos. Sin embargo, todas sus funciones (como QGraphicsItem::contains(), QGraphicsItem::boundingRect(), QGraphicsItem::collidesWith()) siguen funcionando en coordenadas locales, independientemente de la transformación acumulativa del elemento.
QGraphicsItem admite la detección de colisiones a través de la función QGraphicsItem::shape() y la función QGraphicsItem::collidesWith(), ambas funciones virtuales. Al devolver la forma del elemento desde QGraphicsItem::shape() como una coordenada local QPainterPath, QGraphicsItem manejará toda la detección de colisiones por usted. Sin embargo, si desea proporcionar su propia detección de colisiones, puede volver a implementar QGraphicsItem::collidesWith().
3. Sistema de coordenadas de vista gráfica
La vista de gráficos se basa en un sistema de coordenadas cartesianas: la posición y la geometría de un elemento en la escena se representan mediante dos conjuntos de números: la coordenada x y la coordenada y. Al ver una escena con una vista sin transformar, una unidad en la escena se representa mediante un píxel en la pantalla.
Nota: dado que la vista de gráfico utiliza el sistema de coordenadas de Qt, no se admite un sistema de coordenadas del eje y inverso (y crece hacia arriba).
Hay tres sistemas de coordenadas disponibles en una vista de gráficos: coordenadas de elementos, coordenadas de escena y coordenadas de vista. Para simplificar la implementación, la Vista de gráficos proporciona funciones convenientes que le permiten mapear entre los tres sistemas de coordenadas.
Al renderizar, las coordenadas de escena de la vista de gráficos corresponden a las coordenadas lógicas de QPainter y las coordenadas de la vista son las mismas que las coordenadas del dispositivo. En la documentación del sistema de coordenadas podemos leer sobre la relación entre las coordenadas lógicas y las coordenadas del dispositivo.
1. Las coordenadas del Item primitivo
Los elementos existen en su propio sistema de coordenadas local. Sus coordenadas suelen estar centradas alrededor del punto central (0,0), que también es el centro de todas las transformaciones. Las primitivas geométricas en el sistema de coordenadas de elementos a menudo se denominan puntos de elementos, líneas de elementos o rectángulos de elementos.
Al crear elementos personalizados, las coordenadas del elemento son lo único de lo que debe preocuparse; QGraphicsScene y QGraphicsView realizarán todas las transformaciones por nosotros. Esto hace que sea muy fácil implementar personalizaciones. Por ejemplo, si recibe un evento mousedown o drag-in, la ubicación del evento se proporciona en las coordenadas del elemento.
Función virtual QGraphicsItem::contains(), si un punto está dentro del Item, devuelve true, de lo contrario devuelve false, acepta el parámetro point en las coordenadas del Item. De manera similar, el rectángulo delimitador y la forma del elemento están en las coordenadas del elemento.
La posición de un elemento At es la coordenada del punto central del elemento en el sistema de coordenadas de su padre; a veces también se denomina coordenadas del padre. En este sentido, la Escena se considera el "padre" de todos los elementos sin padre. La posición del elemento de nivel superior está en coordenadas de escena.
Las coordenadas del elemento secundario son relativas a las coordenadas del elemento principal. Si el elemento secundario no se transforma, la diferencia entre las coordenadas del elemento secundario y las coordenadas del elemento principal es la misma que la distancia entre los elementos en las coordenadas del elemento principal. Por ejemplo: si un hijo no transformado se coloca exactamente en el punto central del padre, los sistemas de coordenadas de ambos hijos serán los mismos. Si la posición del nodo hijo es (10,0), entonces el punto (0,10) del nodo hijo corresponderá al punto (10,10) del nodo padre.
Dado que la posición y la transformación de un elemento son relativas al elemento principal, las coordenadas de un elemento secundario no se ven afectadas por la transformación del principal, aunque la transformación del principal transforma implícitamente al secundario. En el ejemplo anterior, aunque el elemento principal se gira y escala, el punto (0,10) del elemento secundario aún corresponde al punto (10,10) del elemento principal. Sin embargo, en relación con la escena, los elementos secundarios seguirán la transformación y la posición del elemento principal. Si el elemento principal está escalado (2x, 2x), la posición del elemento secundario estará en las coordenadas de la escena (20,0) y su punto (10,0) corresponderá al punto (40,0) en la escena. .
QGraphicsItem::pos() es una de las pocas excepciones.Las funciones de QGraphicsItem operan en las coordenadas del elemento, sin importar cuál sea el elemento o cuál sea su transformación principal. Por ejemplo, el rectángulo delimitador de un elemento (es decir, QGraphicsItem::boundingRect()) siempre se proporciona en las coordenadas del elemento.
2. Escena Coordenadas de la escena
La escena representa el sistema de coordenadas base de todos los elementos. El sistema de coordenadas de escena describe la posición de cada elemento de nivel superior y también forma la base para todos los eventos de escena enviados desde la vista a la escena. Cada elemento de la escena tiene una posición de escena y un rectángulo delimitador (QGraphicsItem::scenePos(), QGraphicsItem::sceneBoundingRect()), además de su posición de elemento local y rectángulo delimitador. La posición de la escena describe la posición del elemento en las coordenadas de la escena, y su rectángulo delimitador de escena forma la base de cómo QGraphicsScene determina qué áreas de la escena han cambiado. Los cambios de escena se comunican a través de la señal QGraphicsScene::changed(), y el parámetro es una lista de rectángulos de escena.
3. Ver ver coordenadas
Las coordenadas de vista son las coordenadas del control. Cada unidad en las coordenadas de la vista corresponde a un píxel. Lo especial de este sistema de coordenadas es que es relativo al widget (o ventana gráfica) y no se ve afectado por la Escena observada. La esquina superior izquierda de la ventana gráfica de QGraphicsView siempre es (0,0) y la esquina inferior derecha siempre es (ancho de la ventana gráfica, altura de la ventana gráfica). Todos los eventos del mouse y los eventos de arrastrar y soltar se reciben inicialmente en forma de coordenadas de vista, y debe asignar estas coordenadas a la escena para interactuar con los elementos.
4. Mapeo de coordenadas
A menudo, cuando se trabaja con elementos en una escena, es útil asignar coordenadas y formas arbitrarias de una escena a un elemento, de un elemento a otro o de una vista a una escena. Por ejemplo, cuando hace clic con el mouse en la ventana gráfica de QGraphicsView, puede preguntarle a la escena qué elemento está debajo del cursor llamando a QGraphicsView::mapToScene(), seguido de QGraphicsScene::itemAt(). Si desea saber dónde se encuentra el elemento en la ventana gráfica, puede llamar a QGraphicsItem::mapToScene() en el elemento y luego llamar a QGraphicsView::mapFromScene() en la vista. Finalmente, si desea encontrar elementos dentro de la elipse de la vista, puede pasar un QPainterPath a mapToScene() y luego pasar la ruta asignada a QGraphicsScene::items().
Al llamar a QGraphicsItem::mapToScene() y QGraphicsItem::mapFromScene(), las coordenadas y las formas se pueden asignar a la escena del elemento. También puede asignar al elemento principal de un elemento llamando a QGraphicsItem::mapToParent() y QGraphicsItem::mapFromParent(), o asignar entre elementos llamando a QGraphicsItem::mapToItem() y QGraphicsItem::mapFromItem(). Todas las funciones de mapeo pueden mapear puntos, rectángulos, polígonos y caminos simultáneamente.
También existe la misma función de mapeo en la vista para el mapeo con Escena. QGraphicsView::mapFromScene() y QGraphicsView::mapToScene(). Para asignar desde una vista a un elemento, primero asigne a la escena y luego asigne desde la escena al elemento.
4. Características clave
1. Escalar y rotar
QGraphicsView admite la misma transformación afín que QPainter a través de QGraphicsView::setMatrix(). Al aplicar transformaciones a las vistas, podemos agregar fácilmente soporte para funciones de navegación comunes, como el zoom y la rotación.
Aquí hay un ejemplo de cómo implementar ranuras de escalado y rotación en una subclase de QGraphicsView:
class View : public QGraphicsView
{
Q_OBJECT
...
public slots:
void zoomIn() {
scale(1.2, 1.2); }
void zoomOut() {
scale(1 / 1.2, 1 / 1.2); }
void rotateLeft() {
rotate(-10); }
void rotateRight() {
rotate(10); }
...
};
Las ranuras se pueden conectar a QToolButtons con autoRepeat habilitado.
QGraphicsView mantiene el centro de la vista alineado cuando cambia la vista.
2. imprimir
Graphics View proporciona impresión de una sola línea a través de sus funciones de renderizado QGraphicsScene::render() y QGraphicsView::render(). Estas funciones proporcionan la misma API: puede hacer que una Escena o Vista represente todo o parte de su contenido en cualquier dispositivo de dibujo pasando un QPainter a cualquiera de las funciones de representación. Este ejemplo muestra cómo usar QPrinter para imprimir toda la escena en una página completa.
QGraphicsScene scene;
scene.addRect(QRectF(0, 0, 100, 200), QPen(Qt::black), QBrush(Qt::green));
QPrinter printer;
if (QPrintDialog(&printer).exec() == QDialog::Accepted) {
QPainter painter(&printer);
painter.setRenderHint(QPainter::Antialiasing);
scene.render(&painter);
}
La diferencia entre las funciones de renderizado de Escena y Vista es que una opera en coordenadas de Escena y la otra opera en coordenadas de Vista. QGraphicsScene::render() normalmente se usa para imprimir un fragmento completo de una escena sin transformar, como dibujar datos geométricos o imprimir un documento de texto. Por otro lado, QGraphicsView::render() es adecuado para realizar capturas de pantalla; su comportamiento predeterminado es utilizar el pintor proporcionado para representar el contenido fuera de la ventana del control.
QGraphicsScene scene;
scene.addRect(QRectF(0, 0, 100, 200), QPen(Qt::black), QBrush(Qt::green));
QPixmap pixmap;
QPainter painter(&pixmap);
painter.setRenderHint(QPainter::Antialiasing);
scene.render(&painter);
painter.end();
pixmap.save("scene.png");
Cuando el tamaño del área de origen y el área de destino no coinciden, el contenido del área de origen se amplía para ajustarse al área de destino. Al pasar Qt::AspectRatioMode a la función de representación que está utilizando, puede optar por mantener o ignorar la relación de aspecto de la escena mientras se amplía el contenido.
3. Arrastra y suelta
Debido a que QGraphicsView hereda QWidget indirectamente, ya proporciona la misma funcionalidad de arrastrar y soltar que proporciona QWidget. Además, para mayor comodidad, el marco de la vista de gráficos proporciona soporte para arrastrar y soltar para la escena y cada elemento. Cuando la vista recibe un arrastre, convierte el evento de arrastrar y soltar en un QGraphicsSceneDragDropEvent, que luego se reenvía a la escena. La escena se hace cargo de la programación de este evento y lo envía al primer elemento debajo del cursor del mouse que acepta la caída.
Para comenzar a arrastrar desde un elemento, cree un objeto QDrag y pase un puntero al widget para comenzar a arrastrar. Varias vistas pueden observar el elemento al mismo tiempo, pero solo una vista puede iniciar el arrastre. En la mayoría de los casos, el arrastre se inicia presionando o moviendo el mouse, por lo que en mousePressEvent() o mouseMoveEvent(), puede obtener el puntero inicial del widget del evento. Por ejemplo:
void CustomItem::mousePressEvent(QGraphicsSceneMouseEvent *event)
{
QMimeData *data = new QMimeData;
data->setColor(Qt::green);
QDrag *drag = new QDrag(event->widget());
drag->setMimeData(data);
drag->start();
}
Para interceptar los eventos de arrastrar y soltar de la Escena, necesitamos volver a implementar QGraphicsScene::dragEnterEvent() y cualquier controlador de eventos requerido por la Escena específica en la subclase QGraphicsItem. Podemos leer más sobre cómo arrastrar y soltar vistas de gráficos en la documentación de los controladores de eventos de cada QGraphicsScene.
Los elementos se pueden arrastrar y soltar llamando a QGraphicsItem::setAcceptDrops(). Para controlar los arrastres entrantes, vuelva a implementar QGraphicsItem::dragEnterEvent(), QGraphicsItem::dragMoveEvent(), QGraphicsItem::dragLeaveEvent() y QGraphicsItem::dropEvent().
4. Puntero del mouse y consejos
Similar a QWidget, QGraphicsItem también es compatible con el mouse (QGraphicsItem::setCursor()) y ToolTip (QGraphicsItem::setToolTip()). Cuando el cursor del mouse ingresa al área del elemento (detectado al llamar a QGraphicsItem::contains()), QGraphicsView activa el puntero del mouse y la información sobre herramientas.
También puede configurar el puntero del mouse predeterminado directamente en la vista llamando a QGraphicsView::setCursor().
5. Animación
La vista de gráfico admite múltiples niveles de animación. Puede ensamblar animaciones fácilmente utilizando marcos de animación. Para hacer esto, necesitamos que nuestros Items hereden QGraphicsObject y asocien QPropertyAnimation con ellos. QPropertyAnimation permite animar cualquier propiedad QObject.
Otra opción es crear un elemento personalizado que herede de QObject y QGraphicsItem. El elemento puede establecer su propio temporizador y controlar la animación en pasos incrementales en QObject::timerEvent().
Una tercera opción es avanzar en la escena llamando a QGraphicsScene::advance(), que a su vez llama a QGraphicsItem::advance(), principalmente por compatibilidad con QCanvas en Qt 3.
6. Representación OpenGL
Para habilitar el renderizado OpenGL, simplemente configure un nuevo QGLWidget como ventana gráfica de QGraphicsView llamando a QGraphicsView::setViewport(). Si desea antialiasing de OpenGL, necesita compatibilidad con el búfer de muestra de OpenGL (consulte QGLFormat::sampleBuffers()).
QGraphicsView view(&scene);
view.setViewport(new QGLWidget(QGLFormat(QGL::SampleBuffers)));
7. Grupo de artículos
Al hacer que un elemento sea un elemento secundario de otro elemento, puede lograr las propiedades más básicas de la agrupación de elementos: todos los elementos se mueven juntos y todas las transformaciones se pueden propagar de elemento principal a elemento secundario.
Además, QGraphicsItemGroup es un elemento especial que combina el manejo de eventos secundarios con una interfaz útil para agregar y eliminar elementos del grupo. Agregar un elemento a un QGraphicsItemGroup mantendrá la posición original y la transformación del elemento, mientras que reorganizar los elementos generalmente hará que los elementos secundarios se reposicionen en relación con el nuevo elemento principal. Para mayor comodidad, puede crear QGraphicsItemGroups llamando a QGraphicsScene::createItemGroup() desde la escena.
8. Piezas y disposición
Qt 4.4 introdujo soporte para elementos con reconocimiento de diseño y geometría a través de qgraphicwidget. Este elemento base especial es similar a QWidget, pero a diferencia de QWidget, no se hereda de QPaintDevice; no se deriva de QGraphicsItem. Esto nos permite escribir widgets completos con eventos, señales y ranuras, sugerencias de tamaño y políticas, y también podemos administrar la geometría de los widgets en el diseño a través de QGraphicsLinearLayout y QGraphicsGridLayout.
1. QGraphicsWidget
Sobre la base de las funciones y las capacidades reducidas de QGraphicsItem, QGraphicsWidget ofrece lo mejor de ambos mundos: las funciones adicionales de QWidget, como estilos, fuentes, paletas, direcciones de diseño y su geometría, y la independencia de resolución y el soporte de transición de QGraphicsItem. Debido a que la vista de gráficos usa coordenadas reales en lugar de números enteros, las funciones de geometría de QGraphicsWidget también pueden operar en QRectF y QPointF. Esto también se aplica a marcos rectos, márgenes y espacios. Por ejemplo, cuando se usa QGraphicsWidget, es muy común especificar márgenes de contenido como (0.5, 0.5, 0.5, 0.5). Se pueden crear tanto componentes de ventanas secundarias como ventanas de "nivel superior"; en algunos casos, ahora podemos usar vistas gráficas para aplicaciones MDI avanzadas.
Se admiten algunas propiedades de QWidget, incluidas las banderas y los atributos de las ventanas, pero no todas. Deberíamos consultar la documentación de la clase QGraphicWidget para obtener una descripción completa de lo que es y no es compatible. Por ejemplo, puede crear ventanas decorativas pasando el indicador de ventana Qt::Window al constructor qgraphicwidget, pero la vista de gráficos actualmente no admite los indicadores Qt::Sheet y Qt::Drawer habituales en macOS.
2. Diseño QGraphics
QGraphicsLayout es parte del marco de diseño de segunda generación diseñado específicamente para qgraphicwidgets. Su API es muy similar a QLayout. Puede administrar widgets y subdiseños en QGraphicsLinearLayout y QGraphicsGridLayout. También puede escribir fácilmente su propio diseño heredando QGraphicsLaytItem usted mismo, o agregar su propio elemento QGraphicsItem al diseño escribiendo una subclase de adaptador de QGraphicsLayoutItem.
9. Soporte para incrustar widgets
La vista de gráficos proporciona un soporte perfecto para incrustar cualquier control en una escena. Se pueden incrustar controles simples como QLineEdit o QPushButton, controles complejos como QTabWidget o incluso ventanas principales completas. Para incrustar un widget en una escena, simplemente llame a QGraphicsScene::addWidget(), o cree una instancia de QGraphicsProxyWidget para incrustar el widget manualmente.
A través de QGraphicsProxyWidget, Graphics View puede integrar profundamente la funcionalidad del widget del cliente, incluido el cursor, la información sobre herramientas, el mouse, la tableta y los eventos del teclado, los widgets secundarios, las animaciones, las ventanas emergentes (por ejemplo, QComboBox o QComplete) y el enfoque y la activación de la entrada del widget. QGraphicsProxyWidget incluso integra el orden de tabulación de los widgets incrustados para que podamos entrar y salir de los widgets incrustados. Incluso podemos incrustar el nuevo QGraphicsView en nuestra escena para proporcionar escenas anidadas complejas.
Al convertir controles incrustados, la vista de gráficos garantiza que los controles conviertan la resolución de forma independiente, lo que permite que las fuentes y los estilos permanezcan legibles cuando se acercan. (Tenga en cuenta que el efecto de la independencia de la resolución depende del estilo).
5. Rendimiento
Para aplicar transformaciones y efectos especiales a los elementos con precisión y rapidez, la vista de gráficos se crea asumiendo que el hardware del usuario puede proporcionar un rendimiento razonable para las instrucciones de coma flotante.
Muchas estaciones de trabajo y computadoras de escritorio están equipadas con el hardware adecuado para acelerar dichos cálculos, pero algunos dispositivos integrados solo pueden proporcionar bibliotecas para manejar operaciones matemáticas o emular instrucciones de punto flotante en el software.
Por lo tanto, algunos tipos de efectos pueden ser más lentos de lo esperado en algunos dispositivos. Esta pérdida de rendimiento se puede compensar optimizando de otras formas, por ejemplo, renderizando una escena usando OpenGL. Sin embargo, si esta optimización también se basa en hardware de punto flotante, el rendimiento se verá afectado.