Introducción de esta sección:
Esta sección continúa con la serie detallada de dibujo en Android: Explicación detallada de la API de Canvas (Parte 2). Hoy explicaremos la familia de métodos ClipXxx en Canvas. Podemos ver que en la documentación se nos proporcionan tres tipos de métodos Clip:clipPath( ),clipRect( ),clipRegion( );
Mediante diferentes combinaciones de Path, Rect y Region, se pueden admitir áreas de recorte de casi cualquier forma.
Path: Pueden ser curvas abiertas o cerradas, figuras geométricas complejas formadas por líneas.
Rect: Área rectangular.
Region: Puede entenderse como una combinación de regiones; por ejemplo, se pueden sumar, restar, unir, XOR, etc.
Region.Op define los tipos de operaciones entre regiones que admite Region. Lo explicaremos más adelante. Además, hay que señalar que normalmente entendemos el recorte como hacer Clip sobre una figura ya existente, pero en Android, al hacer Clip sobre el Canvas, debe hacerse antes de dibujar. Si se hace Clip sobre el Canvas después de dibujar, no afectará a las figuras ya dibujadas. Recuerda que Clip es sobre el Canvas, ¡no sobre la figura! Bueno, sin más preámbulos, ¡comencemos con el contenido de esta sección!
Documentación oficial de la API:Canvas
1. Explicación detallada del método de combinación Region.Op
En realidad, la dificultad no es otra que esta: Region representa un área, es decir, una región cerrada en la capa del Canvas. Por supuesto, si tienes tiempo puedes estudiar esta clase por tu cuenta, pero generalmente solo nos interesa uno de sus valores de enumeración:Op
A continuación, veamos la función de cada valor de enumeración. Supongamos dos áreas de recorte A y B, y llamamos al valor de enumeración correspondiente de Region.Op:
DIFFERENCE: de A y Bdiferenciarango, es decir, A - B; solo se mostrará el contenido dibujado dentro de este rango.
INTERSECT: es decir, de A y Bintersecciónrango; solo se mostrará el contenido dibujado dentro de este rango.
UNION: es decir, de A y Buniónrango, es decir, se mostrará el contenido dibujado en el área incluida por ambos.
XOR: de A y Bcomplementorango; en este ejemplo, es el área de A excluyendo a B; solo se mostrará el contenido dibujado dentro de este rango.
REVERSE_DIFFERENCE: de B y Adiferenciarango, es decir, B - A; solo se mostrará el contenido dibujado dentro de este rango.
REPLACE: Independientemente de la relación de conjuntos entre A y B, todo el rango de B se mostrará; si hay intersección con A, se superpondrá al rango de intersección de A.
Si has estudiado conjuntos, un diagrama de Venn lo aclararía todo. ¿No lo has estudiado? No importa, escribamos un ejemplo para probar el resultado correspondiente. Escribe un método para inicializar el pincel y dibujar rectángulos:
private void init() {
mPaint = new Paint();
mPaint.setAntiAlias(true);
mPaint.setStrokeWidth(6);
mPaint.setColor(getResources().getColor(R.color.blush));
}
private void drawScene(Canvas canvas){
canvas.drawRect(0, 0, 200, 200, mPaint);
}
Op.DIFFERENCE:
canvas.clipRect(10, 10, 110, 110); //第一个 canvas.clipRect(50, 50, 150, 150, Region.Op.DIFFERENCE); //第二个 drawScene(canvas);
Resultado:

Tomando sucesivamente (10,10) y (50,50) como puntos de inicio, se recortaron dos rectángulos de 100*100. El resultado del recorte es:
Diferencia de A y B = A - (la parte donde A y B se intersectan)
Op.INTERSECT:
canvas.clipRect(10, 10, 110, 110); //第一个 canvas.clipRect(50, 50, 150, 150, Region.Op.INTERSECT); //第二个 drawScene(canvas);
Resultado:

Tomando sucesivamente (10,10) y (50,50) como puntos de inicio, se recortaron dos rectángulos de 100*100. El resultado del recorte es:Intersección de A y B = la parte donde A y B se intersectan
Op.UNION:
canvas.clipRect(10, 10, 110, 110); //第一个 canvas.clipRect(40, 40, 140, 140, Region.Op.UNION); //第二个 drawScene(canvas);
Resultado:

Tomando sucesivamente (10,10) y (50,50) como puntos de inicio, se recortaron dos rectángulos de 100*100. El resultado del recorte es:Unión de A y B = área de A + área de B
Op.XOR:
canvas.clipRect(10, 10, 110, 110); //第一个 canvas.clipRect(50, 50, 150, 150, Region.Op.XOR); //第二个 drawScene(canvas);
Resultado:

Tomando sucesivamente (10,10) y (50,50) como puntos de inicio, se recortaron dos rectángulos de 100*100. El resultado del recorte es:Complemento de A y B = unión de A y B - intersección de A y B
Op.REVERSE_DIFFERENCE:
canvas.clipRect(10, 10, 110, 110); //第一个 canvas.clipRect(50, 50, 150, 150, Region.Op.REVERSE_DIFFERENCE); //第二个 drawScene(canvas);
Resultado:

Tomando sucesivamente (10,10) y (50,50) como puntos de inicio, se recortaron dos rectángulos de 100*100. El resultado del recorte es:Diferencia de B y A = B - intersección de A y B
Op.REPLACE
canvas.clipRect(10, 10, 110, 110); //第一个 canvas.clipRect(50, 50, 150, 150, Region.Op.REPLACE); //第二个 drawScene(canvas);
Resultado:

Tomando sucesivamente (10,10) y (50,50) como puntos de inicio, se recortaron dos rectángulos de 100*100. El resultado del recorte es:Independientemente de la relación de conjuntos entre A y B, todo el rango de B se mostrará; si hay intersección con A, se superpondrá al rango de intersección de A.
2. Ejemplos de uso de Region.Op:
Ejemplo de referencia de:Aprendizaje de gráficos 2D en Android (II), Sección de Canvas 2, Recorte de Canvas y Region, RegionIterator
Captura del efecto de ejecución:

Código de la parte clave MyView.java:
/**
* Created by Jay on 2015/11/10 0010.
*/
public class MyView extends View{
private Bitmap mBitmap = null;
private int limitLength = 0; //
private int width;
private int heigth;
private static final int CLIP_HEIGHT = 50;
private boolean status = HIDE;//显示还是隐藏的状态,最开始为HIDE
private static final boolean SHOW = true;//显示图片
private static final boolean HIDE = false;//隐藏图片
public MyView(Context context) {
this(context, null);
}
public MyView(Context context, AttributeSet attrs) {
super(context, attrs);
mBitmap = BitmapFactory.decodeResource(getResources(), R.mipmap.img_meizi);
limitLength = width = mBitmap.getWidth();
heigth = mBitmap.getHeight();
}
public MyView(Context context, AttributeSet attrs, int defStyleAttr) {
super(context, attrs, defStyleAttr);
}
@Override
protected void onDraw(Canvas canvas) {
Region region = new Region();
int i = 0;
while (i * CLIP_HEIGHT <= heigth) {//计算clip的区域
if (i % 2 == 0) {
region.union(new Rect(0, i * CLIP_HEIGHT, limitLength, (i + 1) * CLIP_HEIGHT));
} else {
region.union(new Rect(width - limitLength, i * CLIP_HEIGHT, width, (i + 1)
* CLIP_HEIGHT));
}
i++;
}
canvas.clipRegion(region);
canvas.drawBitmap(mBitmap, 0, 0, new Paint());
if (status == HIDE) {//如果此时是隐藏
limitLength -= 10;
if(limitLength <= 0)
status=SHOW;
} else {//如果此时是显示
limitLength += 5;
if(limitLength >= width)
status=HIDE;
}
invalidate();
}
}
Análisis de la implementación:
Al inicializar, se obtienen el ancho y el alto, y luego se itera. Se puede entender como dividir la imagen en líneas una a una. La condición del bucle es: i * la altura de cada línea no sea mayor que la altura. Luego, cada línea se divide en dos casos; se llama a union de Region, que en realidad es el método de recorte con modo de combinación UNION. Finalmente, se juzga si la imagen debe mostrarse en ese momento, se manejan de manera diferente los casos de ocultar y mostrar, y al final se llama a invalidate() para redibujar. ¡Es bastante simple, compréndelo por ti mismo!
Además, hay que señalar: la transformación del Canvas no tiene efecto sobre clipRegion.
3. Explicación detallada del método clipRect:
clipRect proporciona siete métodos sobrecargados:

Los parámetros se presentan a continuación::
rect: Objeto Rect, utilizado para definir el rango del área de recorte. Rect y RectF tienen funciones similares; solo difieren en la precisión y en los métodos que proporcionan.
left: Posición izquierda del área de recorte rectangular.
top: Posición superior del área de recorte rectangular.
right: Posición derecha del área de recorte rectangular.
bottom: Posición inferior del área de recorte rectangular.
op: Método de combinación del área de recorte.
Los cuatro valores anteriores pueden ser de tipo flotante o entero.
Ejemplo de uso:
mPaint = new Paint();
mPaint.setAntiAlias(true);
mPaint.setColor(Color.BLACK);
mPaint.setTextSize(60);
canvas.translate(300,300);
canvas.clipRect(100, 100, 300, 300); //设置显示范围
canvas.drawColor(Color.WHITE); //白色背景
canvas.drawText("双11,继续吃我的狗粮...", 150, 300, mPaint); //绘制字符串
Resultado de ejecución:

Del ejemplo anterior, ¿te has dado cuenta? clipRect se ve afectado por la transformación del Canvas. La zona blanca es la zona no dibujada, por lo que clipRect recorta el lienzo, y nuestro dibujo se realiza sobre este lienzo recortado. ¡Lo que supere esa área no se mostrará!
4. Explicación detallada del método clipPath:
En comparación con clipRect, clipPath solo tiene dos métodos sobrecargados. Su uso es muy simple: dibuja un Path y pásalo.

Ejemplo de uso:
Aquí reutilizamos el ejemplo de ImageView circular que escribimos anteriormente en ImageView.
Código de implementación:
ImageView personalizado: RoundImageView.java
/**
* Created by coder-pig on 2015/7/18 0018.
*/
public class RoundImageView extends ImageView {
private Bitmap mBitmap;
private Rect mRect = new Rect();
private PaintFlagsDrawFilter pdf = new PaintFlagsDrawFilter(0, Paint.ANTI_ALIAS_FLAG);
private Paint mPaint = new Paint();
private Path mPath=new Path();
public RoundImageView(Context context, AttributeSet attrs) {
super(context, attrs);
init();
}
//传入一个Bitmap对象
public void setBitmap(Bitmap bitmap) {
this.mBitmap = bitmap;
}
private void init() {
mPaint.setStyle(Paint.Style.STROKE);
mPaint.setFlags(Paint.ANTI_ALIAS_FLAG);
mPaint.setAntiAlias(true);// 抗锯尺
}
@Override
protected void onDraw(Canvas canvas) {
super.onDraw(canvas);
if(mBitmap == null)
{
return;
}
mRect.set(0,0,getWidth(),getHeight());
canvas.save();
canvas.setDrawFilter(pdf);
mPath.addCircle(getWidth() / 2, getWidth() / 2, getHeight() / 2, Path.Direction.CCW);
canvas.clipPath(mPath, Region.Op.REPLACE);
canvas.drawBitmap(mBitmap, null, mRect, mPaint);
canvas.restore();
}
}
Código de diseño:activity_main.xml:
<com.jay.demo.imageviewdemo.RoundImageView
android:id="@+id/img_round"
android:layout_width="200dp"
android:layout_height="200dp"
android:layout_margin="5px"/>
MainActivity.java:
public class MainActivity extends AppCompatActivity {
private RoundImageView img_round;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
img_round = (RoundImageView) findViewById(R.id.img_round);
Bitmap bitmap = BitmapFactory.decodeResource(getResources(),R.mipmap.meinv);
img_round.setBitmap(bitmap);
}
}
Captura del efecto de ejecución:

Además, el ImageView con esquinas redondeadas creado con este método tendrá un aliasing evidente, incluso si configuras el antialias para Paint y Canvas no sirve. Si tus requisitos son altos, puedes usar Xfermode-PorterDuff para configurar la mezcla de imágenes y así básicamente no habrá aliasing. Ver:Tutorial básico de introducción a Android — 8.3.6 API de Paint — Explicación detallada de Xfermode y PorterDuff (III)
5. Descarga del código de ejemplo de esta sección:
CanvasDemo2.zip
XfermodeDemo1.zip
Resumen de esta sección:
Bien, en esta sección hemos explicado los tres métodos de recorte en Canvas: clipPath(), clipRect(), clipRegion(). La dificultad debería estar en el último: los seis modos diferentes de combinación de Op. En realidad no es difícil, es solo el concepto de conjuntos. Si lo pones al principio y lo asimilas, estará bien. clipPath() y clipRect() no tienen ninguna dificultad. Ah, hoy es el 11.11, no sé si te cortaste las manos comprando.

