Introduction à cette section :

Cette section poursuit la série sur le dessin Android, plus précisément API Canvas expliquée (Partie 2). Aujourd'hui, nous allons aborder la famille de méthodes ClipXxx dans Canvas ! Nous pouvons voir que la documentation nous fournit trois types de méthodes Clip :clipPath( ),clipRect( ),clipRegion( );

Grâce à différentes combinaisons de Path, Rect et Region, presque toutes les formes de zone de découpe peuvent être prises en charge !

Path: peut correspondre à des courbes ouvertes ou fermées, à des figures géométriques complexes composées de lignes

Rect: zone rectangulaire

Region: peut être compris comme une combinaison de régions. Par exemple, vous pouvez appliquer une addition, une soustraction, une union, un XOR, etc. à deux régions !

Region.Op définit les types d'opérations entre régions pris en charge par Region ! Nous aborderons cela bientôt. De plus, une chose à noter : ce que nous comprenons habituellement comme le découpage peut être le découpage d'une forme existante, mais dans Android, le découpage est effectué sur le Canvas avant le dessin. Si vous découpez le Canvas après le dessin, cela n'affectera pas les formes déjà dessinées. Rappelez-vous, Clip cible le Canvas, pas les formes ! Bon, assez de digressions, passons directement à cette section !

Documentation officielle de l'API:Canvas


1. Explication détaillée des méthodes de combinaison de Region.Op

En fait, la difficulté n'est rien de plus que ceci : Region représente une zone, une région fermée sur la couche Canvas. Bien sûr, si vous avez le temps, vous pouvez explorer cette classe vous-même petit à petit, mais ce qui nous intéresse généralement, ce n'est qu'une de ses valeurs d'énumération :Op

Ci-dessous, examinons le rôle de chaque valeur d'énumération : supposons que nous ayons deux zones de découpe A et B, et que nous appelons les valeurs d'énumération correspondantes de Region.Op :

DIFFERENCE: la plage dedifférence d'ensemblesde A et B, c'est-à-dire A - B ; seul le contenu dessiné dans cette plage sera affiché ;

INTERSECT: c'est-à-dire la plage d'intersectionde A et B ; seul le contenu dessiné dans cette plage sera affiché

UNION: c.-à-d. la plage d'unionde A et B, c.-à-d. que le contenu de dessin situé dans la plage couverte par les deux sera affiché ;

XOR: la plage de l'ensemble complémentairede A et B ; dans cet exemple, il s'agit de la plage de A excluant B ; seul le contenu dessiné dans cette plage sera affiché ;

REVERSE_DIFFERENCE: la plage de l'ensemble différencede B et A, c.-à-d. B - A ; seul le contenu dessiné dans cette plage sera affiché ;

REPLACE: indépendamment de la relation d'ensemble entre A et B, toute la plage de B sera affichée ; si elle intersecte A, elle écrasera la plage d'intersection de A ;

Si vous avez étudié les ensembles, alors dessiner un diagramme de Venn rendra les choses parfaitement claires. Vous n'avez pas étudié les ensembles ? Pas de problème, écrivons un exemple pour tester les résultats correspondants ! D'abord, écrivons une méthode pour initialiser le pinceau et dessiner des rectangles :

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);

Résultat:

En partant respectivement de (10,10) et (50,50), nous avons découpé deux rectangles de 100*100, et le résultat de découpe obtenu est :

Différence de A et B = A - (la partie où A et B se croisent)


Op.INTERSECT:

canvas.clipRect(10, 10, 110, 110);        //第一个
canvas.clipRect(50, 50, 150, 150, Region.Op.INTERSECT); //第二个
drawScene(canvas);

Résultat:

En partant respectivement de (10,10) et (50,50), nous avons découpé deux rectangles de 100*100, et le résultat de découpe obtenu est :Intersection de A et B = la partie où A et B se croisent


Op.UNION:

canvas.clipRect(10, 10, 110, 110);        //第一个
canvas.clipRect(40, 40, 140, 140, Region.Op.UNION); //第二个
drawScene(canvas);

Résultat:

En partant respectivement de (10,10) et (50,50), nous avons découpé deux rectangles de 100*100, et le résultat de découpe obtenu est :Union de A et B = la surface de A + la surface de B


Op.XOR:

canvas.clipRect(10, 10, 110, 110);        //第一个
canvas.clipRect(50, 50, 150, 150, Region.Op.XOR); //第二个
drawScene(canvas);

Résultat:

En partant respectivement de (10,10) et (50,50), nous avons découpé deux rectangles de 100*100, et le résultat de découpage obtenu est :Complément de A et B = l'union de A et B - l'intersection de A et B


Op.REVERSE_DIFFERENCE:

canvas.clipRect(10, 10, 110, 110);        //第一个
canvas.clipRect(50, 50, 150, 150, Region.Op.REVERSE_DIFFERENCE); //第二个
drawScene(canvas);

Résultat:

En partant respectivement de (10,10) et (50,50), nous avons découpé deux rectangles de 100*100, et le résultat de découpage obtenu est :Différence de B et A = B - (l'intersection de A et B)


Op.REPLACE

canvas.clipRect(10, 10, 110, 110);        //第一个
canvas.clipRect(50, 50, 150, 150, Region.Op.REPLACE); //第二个
drawScene(canvas);

Résultat:

En partant respectivement de (10,10) et (50,50), nous avons découpé deux rectangles de 100*100, et le résultat de découpage obtenu est :Quelle que soit la relation d'ensemble entre A et B, toute la plage de B sera affichée ; si elle intersecte A, elle écrasera la plage d'intersection de A ;


2. Exemples d'utilisation de Region.Op :

Exemple référencé depuis :Apprentissage des graphiques 2D Android (2), Chapitre 2 de Canvas, Découpage et Region dans Canvas, RegionIterator

Capture d'écran de l'effet d'exécution:

Extrait de code clé 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();
    }
}

Analyse de l'implémentation:

Lors de l'initialisation, on récupère la largeur et la hauteur, puis on effectue une boucle. Vous pouvez le voir comme une division de l'image en bandes. La condition de boucle est : i * la hauteur de chaque bande n'est pas supérieure à la hauteur. Ensuite, chaque bande est traitée selon deux cas. Il appelle la méthode union de Region, qui n'est en fait qu'une méthode de découpage avec le mode de combinaison UNION. Enfin, il détermine si l'image est affichée à ce moment, en gérant différemment les cas masqué et affiché. Enfin, il appelle invalidate() pour redessiner ! C'est assez simple ; comprenez-le simplement par vous-même.

Une dernière chose : les transformations de Canvas n'ont aucun effet sur clipRegion.


3. Explication détaillée de la méthode clipRect :

clipRect fournit sept méthodes surchargées :

Les paramètres sont présentés comme suit ::

rect: Un objet Rect, utilisé pour définir l'étendue de la zone de découpe. Rect et RectF ont des fonctionnalités similaires ; ils diffèrent uniquement par la précision et les méthodes fournies.

left: La position gauche de la zone de découpe rectangulaire

top: La position supérieure de la zone de découpe rectangulaire

right: La position droite de la zone de découpe rectangulaire

bottom: La position inférieure de la zone de découpe rectangulaire

op: Le mode de combinaison de la zone de découpe

Les quatre valeurs ci-dessus peuvent être de type float ou integer.

Exemple d'utilisation:

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); //绘制字符串

Résultat de l'exécution:

À partir de l'exemple ci-dessus, avez-vous remarqué quelque chose ? clipRect est affecté par les transformations de Canvas. La zone blanche est la zone non dessinée, donc clipRect découpe le canvas, et notre dessin est effectué sur ce canvas découpé ! Tout ce qui dépasse cette zone n'est pas affiché !


4. Explication détaillée de la méthode clipPath :

Comparé à clipRect, clipPath ne possède que deux méthodes surchargées. Son utilisation est très simple : il suffit de dessiner vous-même un Path et de le passer en paramètre !

Exemple d'utilisation:

Ici, nous réutilisons l'exemple d'ImageView circulaire que nous avons écrit précédemment dans la section ImageView.

Code d'implémentation:

ImageView personnalisée : 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();
    }
}

Code de mise en page :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);
    }
}

Capture d'écran de l'effet d'exécution:

De plus, l'ImageView arrondie réalisée avec cette méthode présentera des bords dentelés évidents. Même si vous activez l'anticrénelage pour Paint et Canvas, cela n'aidera pas. Si vous avez des exigences élevées, vous pouvez utiliser Xfermode-PorterDuff pour définir la composition d'image afin d'obtenir un résultat pratiquement sans bords dentelés. Voir :Tutoriel de base pour débutants Android——8.3.6 API Paint——Explication détaillée de Xfermode et PorterDuff (Partie 3)


5. Télécharger l'exemple de code de cette section :

CanvasDemo2.zip

XfermodeDemo1.zip


Résumé de la section :

Bien, dans cette section nous avons expliqué les trois méthodes de découpage de Canvas : clipPath(), clipRect() et clipRegion(). La difficulté devrait se situer sur la dernière, avec six modes de combinaison Op différents. En réalité, ce n'est pas difficile — c'est juste le concept d'ensembles. Comme elle a été placée au début, une fois digérée, ça va. clipPath() et clipRect(), en revanche, ne présentent pas de réelles difficultés. Au fait, aujourd'hui c'est le Double 11 (jour des célibataires). Avez-vous fait des folies shopping ?