Introducción a esta sección:
Anteriormente dedicamos 13 subsecciones a explicar en detalle la mayoría de las API comunes de la clase Paint en Android. A partir de esta sección vamos a explicar algunas API comunes de Canvas (lienzo). En
8.3.1 Explicación detallada de las tres clases de herramientas de dibujo ya hemos enumerado algunos de los métodos que podemos invocar; clasifiquémoslos:
- Familia de métodos drawXxx: Dibuja en el área de dibujo actual con ciertos valores de coordenadas. Además, las capas se superponen, es decir, la capa dibujada después cubrirá a la capa dibujada antes.
- Familia de métodos clipXXX: Recorta (clip) una nueva área de dibujo dentro del área de dibujo actual; esta área de dibujo se convierte en el área de dibujo actual del objeto canvas. Por ejemplo: clipRect(new Rect()), entonces esa región rectangular es el área de dibujo actual del canvas.
- Familia de métodos getXxx: Obtiene algunos valores relacionados con Canvas, como ancho, alto, densidad de pantalla, etc.
- save(),restore(),saveLayer(),restoreToCountMétodos como () para guardar y restaurar capas
- translate(traslación),scale(escala),rotate(rotación),skew(inclinación).
Por supuesto, también hay otros métodos dispersos. Bien, a partir de esta sección elegiré algunas API que me parezcan interesantes para aprender.
Y en esta sección primero les traigotranslate(traslación),scale(escala),rotate(rotación),skew(inclinación)save(),restoreasí como la explicación detallada de ()!
Documentación oficial de la API:Canvas
Además, primero debemos aclarar la dirección de los ejes X e Y en Canvas:
1.translate (traslación)
Método:translate(float dx, float dy)
Análisis: Traslación; mueve elorigen de coordenadas del lienzohacia la izquierda/derecha en x, y hacia arriba/abajo en y; la posición predeterminada del canvas está en (0,0).
Parámetros: dx es la distancia de desplazamiento horizontal, dy es la distancia de desplazamiento vertical.
Ejemplo de uso:
for(int i=0; i < 5; i++) {
canvas.drawCircle(50, 50, 50, mPaint);
canvas.translate(100, 100);
}
Efecto de ejecución:

2.rotate (rotación)
Método:rotate(float degrees) / rotate(float degrees, float px, float py)
Análisis: Rota degrees grados alrededor del origen de coordenadas; si el valor es positivo, es en sentido horario.
Parámetros: degrees es el ángulo de rotación, px y py son las coordenadas del punto central de rotación especificado (px, py).
Ejemplo de uso:
Rect rect = new Rect(50,0,150,50);
canvas.translate(200, 200);
for(int i = 0; i < 36;i++){
canvas.rotate(10);
canvas.drawRect(rect, mPaint);
}
Efecto de ejecución:

Análisis del código:
Aquí primero llamamos a translate(200,200) para mover el origen de coordenadas del canvas a (200,200), y luego dibujamos, por lo que el resultado del dibujo se puede mostrar completamente en el lienzo. Si hubiéramos configurado rotate con (10,200,200), habría sido un resultado como este:

¿Tienes dudas, verdad? Esto involucra el concepto de múltiples capas de Canvas; lo explicaremos más adelante.
3.scale (escala)
Método:scale(float sx, float sy) / scale(float sx, float sy, float px, float py)
Análisis: Escala el lienzo.
Parámetros: sx es la proporción de escala horizontal, sy es la proporción de escala vertical, px y py, no lo sé tampoco,Los decimales reducen, Los enteros amplían
Ejemplo de uso:
canvas.drawBitmap(bmp,0,0,mPaint); canvas.scale(0.8f, 0.8f); canvas.drawBitmap(bmp, 0, 0, mPaint); canvas.scale(0.8f, 0.8f); canvas.drawBitmap(bmp,0,0,mPaint);
Efecto de ejecución:

4.skew (inclinación)
Método:skew(float sx, float sy)
Análisis: Inclinación; también se puede traducir como sesgado/cortado, distorsión.
Parámetros: sx es el ángulo correspondiente de inclinación en la dirección del eje X, sy es el ángulo correspondiente de inclinación en la dirección del eje Y. ¡Ambos valores son valores de tan! ¡Son valores de tan! ¡Son valores de tan! Por ejemplo, si se quiere inclinar 60 grados en la dirección del eje X, entonces el valor decimal corresponde a: tan 60 = raíz de 3 = 1.732.
Ejemplo de uso:
canvas.drawBitmap(bmp,0,0,mPaint); canvas.translate(200, 200); canvas.skew(0.2f,-0.8f); canvas.drawBitmap(bmp,0,0,mPaint);
Efecto de ejecución:

5. El concepto de capas de Canvas y explicación detallada de save() y restore()
Normalmente nos gusta llamar a Canvas "lienzo". Los compañeros siempre piensan que Canvas es un simple papel de dibujo, entonces me pregunto: ¿cómo se hacen las animaciones multicapa con Canvas? En el ejemplo anterior de translate (traslación), ¿por qué drawCircle(50, 50, 50, mPaint); con coordenadas de referencia siempre (50, 50) produce ese efecto? Los compañeros que tengan dudas pueden estar confundiendo el concepto de pantalla con el concepto de Canvas. A continuación, reconstruyamos la escena de la llamada a translate:
Como se muestra en la figura, es el origen de coordenadas del lienzo moviéndose cada vez 100 en los ejes X e Y respectivamente. Entonces, ¿si quisiéramos volver al punto (0,0) para dibujar una nueva figura? ¿Cómo se resuelve? ¿Vamos a usar translate(-100,-100) para volver lentamente? No será que nos vamos a complicar tanto...
Bien, no lo voy a seguir ocultando. Antes de hacer la transformación de traslación, podemos guardar el estado actual del canvas. De hecho, Canvas nos proporciona soporte de capas (Layer), y estas capas (Layer) se gestionan mediante una "estructura de pila".
Cuando llamamos alsave()método, se guarda el estado actual de Canvas y luego se añade como una Layer (capa) a la pila de Canvas. Además, esta Layer (capa) no es una clase concreta, ¡es solo un concepto!
Y cuando llamamos alrestore()método, se restaura el estado anterior de Canvas. En este momento, la pila de capas de Canvas saca la Layer del tope de la pila, y la siguiente Layer pasa al tope. En ese momento, Canvas vuelve al estado de Canvas guardado cuando ese tope estaba en la cima.
En pocas palabras:: save() inserta una Layer en la pila, restore() saca una Layer del tope de la pila; esta Layer representa el estado de Canvas.Es decir, se puede llamar a save() varias veces y también a restore() varias veces, pero el número de llamadas a restoreno puede ser mayor quesave; de lo contrario, provocará un error. Esta es la versión que se encuentra en la mayoría de los sitios web, pero en las pruebas reales no apareció tal problema. Incluso si la cantidad de restore es mayor que la de save, no aparece ningún error. Sospecho que el sistema ha cambiado; luego lo probaré y les mostraré.
Vamos, vamos, escribamos un ejemplo para verificar el efecto de save y restore.
Escribamos un ejemplo:
Código de ejemplo:
canvas.save(); //保存当前canvas的状态 canvas.translate(100, 100); canvas.drawCircle(50, 50, 50, mPaint); canvas.restore(); //恢复保存的Canvas的状态 canvas.drawCircle(50, 50, 50, mPaint);
Resultado de ejecución:
No hace falta decir nada, ¿verdad? El código y el resultado lo explican todo. A continuación, hagámoslo más complicado: ¡una ronda con múltiples save() y restore()!
Código de ejemplo:
canvas.save(); canvas.translate(300, 300); canvas.drawBitmap(bmp, 0, 0, mPaint); canvas.save(); canvas.rotate(45); canvas.drawBitmap(bmp, 0, 0, mPaint); canvas.save(); canvas.rotate(45); canvas.drawBitmap(bmp, 0, 0, mPaint); canvas.save(); canvas.translate(0, 200); canvas.drawBitmap(bmp, 0, 0, mPaint);
Resultado de ejecución:

Análisis de resultados:
Primero se traslada a (300,300) y se dibuja; luego se rota 45 grados y se dibuja; después se rota otros 45 grados y se dibuja; a continuación se traslada (0,200). Durante este proceso, se llama a save() antes de cada dibujo. Al ver esto, puede que tengas una duda: esta última traslación no es un desplazamiento de 200 en y, ¿por qué se convierte en un desplazamiento hacia la izquierda? Jeje, ¿os digo que rotate() rota todo el sistema de ejes? El cambio de los ejes de coordenadas:

Bien, ¿ya entiendes rotate()? Entonces listo. A continuación probemos restore. Añadimos dos restore() antes del último dibujo.
canvas.restore(); canvas.restore(); canvas.translate(0, 200); canvas.drawBitmap(bmp, 0, 0, mPaint);
Resultado de ejecución:

No digo nada, siéntelo por ti mismo. Añadamos otro másrestore()!

Es un poco interesante, vamos de nuevo, sigamos añadiendo.restore()

Hmm, parece que ya no se puede escribirrestore¿verdad? Como solo hemos llamado a save cuatro veces, según lo que se dice en Internet, esto daría un error. ¿Es realmente así? Aquí llamamos a un método que nos proporciona Canvas para obtener cuántas capas Layer hay actualmente en la pila:getSaveCount(); luego añade un Log antes y después de save() y restore() para imprimir el número de capas Layer en la pila:

El resultado es realmente gratificante; después de todo, la práctica da el verdadero conocimiento. Puede que Canvas haya cambiado, o por otra razón; para saberlo habría que mirar el código fuente. Por cuestión de tiempo, aquí nos basta con saber que el número de restore puede ser mayor que el de save, pero aún así se recomienda que el número de restore sea menor que el de save para evitar problemas innecesarios. En cuanto al proceso de empujar y sacar de la pila, no voy a hablar mucho; el autor lo dibuja a mano, ¡es muy fácil de entender!
6. Explicación de saveLayer() y restoreToCount()
En realidad, estos dos métodos son casi lo mismo que save y restore, solo que agregan algunas cosas adicionales sobre la base de estos últimos, como saveLayer(), que tiene varios métodos sobrecargados:
Puedes entenderlo comosave()El método guardael Canvas completo, mientras que saveLayer() puede guardar selectivamente el estado de una región,int saveFlags, este es el que establece qué objeto se guarda. Los valores opcionales son:
| Marca | Descripción |
|---|---|
| ALL_SAVE_FLAG | Guardar todo el estado |
| CLIP_SAVE_FLAG | Guardar el estado de una región recortada |
| CLIP_TO_LAYER_SAVE_FLAG | Guardar el estado dentro del rango preestablecido |
| FULL_COLOR_LAYER_SAVE_FLAG | Guardar la capa de color |
| HAS_ALPHA_LAYER_SAVE_FLAG | Guardar la capa opaca |
| MATRIX_SAVE_FLAG | Guardar el estado de la información de Matrix (translate, rotate, scale, skew) |
PD: Las explicaciones anteriores tienen algunos problemas, el autor tiene un nivel de inglés bajo, puede estar equivocado, si alguien lo sabe, por favor corríjalo, gracias~
Aquí escribimos un ejemplo para verificarlo: elegimosCLIP_TO_LAYER_SAVE_FLAGmodo para escribir un ejemplo
Código de implementación:
RectF bounds = new RectF(0, 0, 400, 400); canvas.saveLayer(bounds, mPaint, Canvas.CLIP_TO_LAYER_SAVE_FLAG); canvas.drawColor(getResources().getColor(R.color.moss_tide)); canvas.drawBitmap(bmp, 200, 200, mPaint); canvas.restoreToCount(1); canvas.drawBitmap(bmp, 300, 200, mPaint);
Resultado de la ejecución:

En cuanto a saveLayer(), lo estudiaremos en detalle cuando lo usemos más adelante~ Por ahora solo tener una idea general~
Luego llegamos a esterestoreToCount(int), este es más simple, directamente pasas el número de capa (Layer) al que quieres restaurar, salta directamente a la capa correspondiente, y al mismo tiempo saca de la pila todas las capas por encima de esa capa, haciendo que esa capa sea la cima de la pila~! Comparado con escribir múltiples restore(), es mucho más conveniente y rápido~
7. Descarga de ejemplos de código de esta sección:
Bueno, el código está escrito para pruebas, no tiene mucho sentido pedirlo, pero quizás los lectores aún lo quieran, así que pondré el enlace.
Descargar código:CanvasDemo.zipQuizás lo que quieren es esta imagen, ¡jaja~

Resumen de esta sección:
Esta sección me tomó varios días de vacilación escribirla, porque al principio el autor no tenía muy claro el concepto de la capa Canvas. Esta tarde, después de terminar mis tareas, ordené mis ideas, y por la noche trabajé horas extras y finalmente escribí este artículo. Creo que debería ayudar a todos a entender Canvas más claramente, y no estarán perdidos al avanzar en controles personalizados~ Jeje, esto es todo por esta sección, si hay algo mal escrito, bienvenido a señalarlo, muchas gracias~
Referencias: Dominar el Canvas de Android – Dibujo básico




Vamos, vamos, escribamos un ejemplo para verificar el efecto de save y restore.
