Einführung in diesen Abschnitt:

Dieser Abschnitt setzt die Android-Zeichenserie fort, genauer gesagt Canvas-API erklärt (Teil 2). Heute besprechen wir die ClipXxx-Methodenfamilie in Canvas! Wir können sehen, dass die Dokumentation uns drei Arten von Clip-Methoden bietet:clipPath( ),clipRect( ),clipRegion( );

Durch verschiedene Kombinationen von Path, Rect und Region kann nahezu jede Form eines Clipping-Bereichs unterstützt werden!

Path: Kann offene oder geschlossene Kurven sein, komplexe geometrische Figuren, die aus Linien zusammengesetzt sind

Rect: Rechteckiger Bereich

Region: Kann als Regionskombination verstanden werden. Zum Beispiel kann man zwei Regionen addieren, subtrahieren, vereinigen, per XOR verknüpfen usw.!

Region.Op definiert die Arten von Operationen zwischen Regionen, die von Region unterstützt werden! Darauf gehen wir gleich ein. Außerdem sollte man eines beachten: Was wir üblicherweise unter Clipping verstehen, ist vielleicht das Beschneiden einer vorhandenen Form, aber in Android wird das Clipping auf dem Canvas vor dem Zeichnen durchgeführt. Wenn man den Canvas nach dem Zeichnen clippt, wirkt sich das nicht auf die bereits gezeichneten Formen aus. Denken Sie daran: Clip zielt auf den Canvas, nicht auf die Formen! Gut, genug geschwafelt, steigen wir direkt in diesen Abschnitt ein!

Offizielle API-Dokumentation:Canvas


1. Detaillierte Erklärung der Kombinationsmethoden von Region.Op

Eigentlich ist die Schwierigkeit nichts weiter als das: Region repräsentiert einen Bereich, einen geschlossenen Bereich auf der Canvas-Ebene. Wenn Sie Zeit haben, können Sie sich natürlich selbst langsam in diese Klasse einarbeiten, aber was uns im Allgemeinen interessiert, ist nur einer ihrer Enum-Werte:Op

Schauen wir uns im Folgenden die Rolle jedes Enum-Werts an: Angenommen, wir haben zwei Clipping-Bereiche A und B, und wir rufen die entsprechenden Enum-Werte von Region.Op auf:

DIFFERENCE: DerDifferenzmengebereich von A und B, d. h. A - B; nur Inhalte, die innerhalb dieses Bereichs gezeichnet werden, werden angezeigt;

INTERSECT: d. h. derSchnittmengenbereich von A und B; nur Inhalte, die innerhalb dieses Bereichs gezeichnet werden, werden angezeigt

UNION: d. h., derVereinigungsbereich von A und B, d. h., der Zeichnungsinhalt innerhalb des von beiden abgedeckten Bereichs wird angezeigt;

XOR: derKomplementmengenbereich von A und B; in diesem Beispiel ist es der Bereich von A ohne B; nur Inhalte, die innerhalb dieses Bereichs gezeichnet werden, werden angezeigt;

REVERSE_DIFFERENCE: derDifferenzmengenbereich von B und A, d. h. B - A; nur Inhalte, die innerhalb dieses Bereichs gezeichnet werden, werden angezeigt;

REPLACE: Unabhängig von der Mengenbeziehung zwischen A und B wird der gesamte Bereich von B angezeigt; wenn er sich mit A schneidet, überschreibt er den Schnittbereich von A;

Wenn du Mengenlehre studiert hast, dann wird ein Venn-Diagramm es glasklar machen. Noch keine Mengenlehre studiert? Kein Problem, schreiben wir ein Beispiel, um die entsprechenden Ergebnisse zu testen! Schreiben wir zuerst eine Methode, um den Pinsel zu initialisieren und Rechtecke zu zeichnen:

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

Ergebnis:

Ausgehend von (10,10) bzw. (50,50) haben wir zwei 100*100-Rechtecke geclippt, und das resultierende Clipping-Ergebnis ist:

Differenz von A und B = A - (der Teil, in dem sich A und B schneiden)


Op.INTERSECT:

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

Ergebnis:

Ausgehend von (10,10) bzw. (50,50) haben wir zwei 100*100-Rechtecke geclippt, und das resultierende Clipping-Ergebnis ist:Schnittmenge von A und B = der Teil, in dem sich A und B schneiden


Op.UNION:

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

Ergebnis:

Ausgehend von (10,10) bzw. (50,50) haben wir zwei 100*100-Rechtecke geclippt, und das resultierende Clipping-Ergebnis ist:Vereinigung von A und B = Fläche von A + Fläche von B


Op.XOR:

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

Ergebnis:

Ausgehend von (10,10) bzw. (50,50) haben wir zwei 100*100-Rechtecke geclippt, und das resultierende Clipping-Ergebnis ist:Komplement von A und B = die Vereinigung von A und B - die Schnittmenge von A und B


Op.REVERSE_DIFFERENCE:

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

Ergebnis:

Ausgehend von (10,10) bzw. (50,50) haben wir zwei 100*100-Rechtecke geclippt, und das resultierende Clipping-Ergebnis ist:Differenz von B und A = B - (die Schnittmenge von A und B)


Op.REPLACE

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

Ergebnis:

Ausgehend von (10,10) bzw. (50,50) haben wir zwei 100*100-Rechtecke geclippt, und das resultierende Clipping-Ergebnis ist:Unabhängig von der Mengenbeziehung zwischen A und B wird der gesamte Bereich von B angezeigt; wenn er A schneidet, überschreibt er den Schnittbereich von A;


2. Region.Op Anwendungsbeispiele:

Beispiel entnommen aus:Android 2D Graphics Learning (2), Canvas Kapitel 2, Canvas-Clipping und Region, RegionIterator

Screenshot des Laufeffekts:

Wichtiges Code-Snippet 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();
    }
}

Implementierungsanalyse:

Während der Initialisierung werden Breite und Höhe ermittelt, dann wird eine Schleife ausgeführt. Man kann es sich so vorstellen, dass das Bild in Streifen aufgeteilt wird. Die Schleifenbedingung ist: i * die Höhe jedes Streifens ist nicht größer als die Höhe. Dann wird jeder Streifen in zwei Fällen behandelt. Es ruft die union-Methode von Region auf, die eigentlich nur eine Clipping-Methode mit dem Kombinationsmodus UNION ist. Schließlich wird ermittelt, ob das Bild zu diesem Zeitpunkt angezeigt wird, wobei die Fälle „verborgen“ und „angezeigt“ unterschiedlich behandelt werden. Zum Schluss wird invalidate() aufgerufen, um neu zu zeichnen! Es ist ziemlich einfach; verstehen Sie es einfach selbst.

Noch eine Sache: Canvas-Transformationen haben keine Auswirkung auf clipRegion.


3. Detaillierte Erklärung der clipRect-Methode:

clipRect bietet sieben überladene Methoden:

Die Parameter werden wie folgt eingeführt::

rect: Ein Rect-Objekt, das verwendet wird, um den Bereich des Clipping-Bereichs zu definieren. Rect und RectF sind in ihrer Funktionalität ähnlich; sie unterscheiden sich nur in der Präzision und den bereitgestellten Methoden.

left: Die linke Position des rechteckigen Clipping-Bereichs

top: Die obere Position des rechteckigen Clipping-Bereichs

right: Die rechte Position des rechteckigen Clipping-Bereichs

bottom: Die untere Position des rechteckigen Clipping-Bereichs

op: Der Kombinationsmodus des Clipping-Bereichs

Die oben genannten vier Werte können float oder integer sein.

Anwendungsbeispiel:

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

Ausführungsergebnis:

Ist Ihnen am obigen Beispiel etwas aufgefallen? clipRect wird von Canvas-Transformationen beeinflusst. Der weiße Bereich ist der nicht gezeichnete Bereich, also schneidet clipRect die Canvas zu, und unser Zeichnen wird auf dieser zugeschnittenen Canvas ausgeführt! Alles außerhalb dieses Bereichs wird nicht angezeigt!


4. Detaillierte Erklärung der clipPath-Methode:

Im Vergleich zu clipRect hat clipPath nur zwei überladene Methoden. Es ist sehr einfach zu verwenden: Zeichnen Sie einfach selbst einen Path und übergeben Sie ihn!

Anwendungsbeispiel:

Hier verwenden wir das kreisförmige ImageView-Beispiel wieder, das wir zuvor im Abschnitt ImageView geschrieben haben.

Implementierungscode:

Benutzerdefinierte ImageView: 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();
    }
}

Layout-Code: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);
    }
}

Screenshot des Laufeffekts:

Darüber hinaus weist die mit dieser Methode erstellte abgerundete ImageView deutliche gezackte Kanten auf. Selbst wenn Sie Antialiasing für Paint und Canvas aktivieren, hilft das nicht. Wenn Sie hohe Anforderungen haben, können Sie Xfermode-PorterDuff verwenden, um die Bildkomposition festzulegen und so praktisch ohne gezackte Kanten zu erreichen. Siehe:Android Grundlagen-Einsteigertutorial——8.3.6 Paint API——Detaillierte Erklärung von Xfermode und PorterDuff (Teil 3)


5. Beispielcode für diesen Abschnitt herunterladen:

CanvasDemo2.zip

XfermodeDemo1.zip


Zusammenfassung des Abschnitts:

Also gut, in diesem Abschnitt haben wir die drei Clipping-Methoden in Canvas erklärt: clipPath(), clipRect() und clipRegion(). Die Schwierigkeit dürfte bei der letzten liegen, mit sechs verschiedenen Op-Kombinationsmodi. Eigentlich ist sie nicht schwierig – es ist nur das Konzept von Mengen. Da sie am Anfang platziert wurde, ist alles in Ordnung, sobald Sie sie verdaut haben. clipPath() und clipRect() hingegen haben keine wirklichen Schwierigkeiten. Übrigens ist heute Double 11 (Singles' Day). Waren Sie auf Shopping-Tour?