java类android.graphics.Matrix的实例源码

@Test public void exifTransverse() {
  Request data = new Request.Builder(URI_1).rotate(-45).build();
  Bitmap source = Bitmap.createBitmap(10, 10, ARGB_8888);
  Bitmap result = transformResult(data, source, ORIENTATION_TRANSVERSE);
  ShadowBitmap shadowBitmap = shadowOf(result);
  assertThat(shadowBitmap.getCreatedFromBitmap()).isSameAs(source);

  Matrix matrix = shadowBitmap.getCreatedFromMatrix();
  ShadowMatrix shadowMatrix = shadowOf(matrix);
  assertThat(shadowMatrix.getPostOperations()).containsExactly("scale -1.0 1.0");
  assertThat(shadowMatrix.getPreOperations()).containsExactly("rotate 270.0");
}

public static void mapPoints(Matrix matrix, float[] points)
{
  float[] m = { 0.0F, 0.0F, 0.0F, 0.0F, 0.0F, 0.0F, 0.0F, 0.0F, 0.0F };
  matrix.getValues(m);

  points[0] = (points[0] * m[0] + m[2]);
  points[1] = (points[1] * m[4] + m[5]);

  if (points.length == 4) {
    points[2] = (points[2] * m[0] + m[2]);
    points[3] = (points[3] * m[4] + m[5]);
  }
}

private void overlay(Bitmap bm1, Bitmap bm2) {
    // Combine bitmaps
    bmOverlay = Bitmap.createBitmap(bm1.getWidth(), bm1.getHeight(), bm1.getConfig());
    Canvas canvas = new Canvas(bmOverlay);
    Paint paint = new Paint();
    paint.setAlpha(128);
    canvas.drawBitmap(bm1, new Matrix(), null);
    canvas.drawBitmap(bm2, 0, 0, paint);
}

Fling(int velocityX, int velocityY) {
    setState(State.FLING);
    scroller = new CompatScroller(context);
    matrix.getValues(m);

    int startX = (int) m[Matrix.MTRANS_X];
    int startY = (int) m[Matrix.MTRANS_Y];
    int minX, maxX, minY, maxY;

    if (getImageWidth() > viewWidth) {
        minX = viewWidth - (int) getImageWidth();
        maxX = 0;

    } else {
        minX = maxX = startX;
    }

    if (getImageHeight() > viewHeight) {
        minY = viewHeight - (int) getImageHeight();
        maxY = 0;

    } else {
        minY = maxY = startY;
    }

    scroller.fling(startX, startY, velocityX, velocityY, minX,
            maxX, minY, maxY);
    currX = startX;
    currY = startY;
}

public static Bitmap rotateBitmap(Bitmap bitmap, int degress, boolean needRecycle) {
    Matrix m = new Matrix();
    m.postRotate((float)degress);
    Bitmap bm = Bitmap.createBitmap(bitmap, 0, 0, bitmap.getWidth(), bitmap.getHeight(), m, true);
    if(needRecycle) {
        bitmap.recycle();
    }

    return bm;
}

/**
 * Performs boundary checking and fixes the image matrix if it
 * is out of bounds.
 */
private void fixTrans() {
    matrix.getValues(m);
    float transX = m[Matrix.MTRANS_X];
    float transY = m[Matrix.MTRANS_Y];

    float fixTransX = getFixTrans(transX, viewWidth, getImageWidth());
    float fixTransY = getFixTrans(transY, viewHeight, getImageHeight());

    if (fixTransX != 0 || fixTransY != 0) {
        matrix.postTranslate(fixTransX, fixTransY);
    }
}

public static Bitmap getRotatedBitMap(File imageFile) {
    if (imageFile == null || !imageFile.canRead() || !imageFile.exists()) {
        return null;
    }

    Bitmap rotatedBitmap = null;

    try {
        Bitmap srcBitmap = BitmapFactory.decodeFile(imageFile.getAbsolutePath());
        ExifInterface exif = new ExifInterface(imageFile.getName());
        String orientString = exif.getAttribute(ExifInterface.TAG_ORIENTATION);
        int orientation = orientString != null ? Integer.parseInt(orientString) : ExifInterface.ORIENTATION_NORMAL;

        int rotationAngle = 0;
        if (orientation == ExifInterface.ORIENTATION_ROTATE_90) rotationAngle = 90;
        if (orientation == ExifInterface.ORIENTATION_ROTATE_180) rotationAngle = 180;
        if (orientation == ExifInterface.ORIENTATION_ROTATE_270) rotationAngle = 270;

        Matrix matrix = new Matrix();
        matrix.setRotate(rotationAngle, (float) srcBitmap.getWidth() / 2, (float) srcBitmap.getHeight() / 2);
        rotatedBitmap = Bitmap.createBitmap(srcBitmap, 0, 0, srcBitmap.getWidth(), srcBitmap.getHeight(), matrix, true);

    } catch (Exception e) {
        e.printStackTrace();
        CrashlyticsWrapper.log(e);
    }

    return rotatedBitmap;
}

/**
 * Constructor with initialization parameters.
 *
 * @param chart               instance of the chart
 * @param touchMatrix         the touch-matrix of the chart
 * @param dragTriggerDistance the minimum movement distance that will be interpreted as a "drag" gesture in dp (3dp equals
 *                            to about 9 pixels on a 5.5" FHD screen)
 */
public BarLineChartTouchListener(BarLineChartBase<? extends BarLineScatterCandleBubbleData<? extends
        IBarLineScatterCandleBubbleDataSet<? extends Entry>>> chart, Matrix touchMatrix, float dragTriggerDistance) {
    super(chart);
    this.mMatrix = touchMatrix;

    this.mDragTriggerDist = Utils.convertDpToPixel(dragTriggerDistance);

    this.mMinScalePointerDistance = Utils.convertDpToPixel(3.5f);
}

/**
 * 处理图片缩放
 */
private Bitmap setScale(Bitmap a) {
    scale = ((float) (mWidth) / mBitWidth);
    Matrix mMatrix = new Matrix();
    mMatrix.postScale(scale, scale);
    Bitmap bmp = Bitmap.createBitmap(a, 0, 0, a.getWidth(), a.getHeight(),
            mMatrix, true);
    return bmp;
}

/**
 * 获得带倒影的Bitmap
 *
 * @param bitmap 源Bitmap
 * @return 带倒影的Bitmap
 */
public static Bitmap createReflectionBitmap(Bitmap bitmap) {
    final int reflectionGap = 4;
    int width = bitmap.getWidth();
    int height = bitmap.getHeight();

    Matrix matrix = new Matrix();
    matrix.preScale(1, -1);

    Bitmap reflectionImage = Bitmap.createBitmap(bitmap, 0, height / 2,
            width, height / 2, matrix, false);

    Bitmap bitmapWithReflection = Bitmap.createBitmap(width,
            (height + height / 2), Config.ARGB_8888);

    Canvas canvas = new Canvas(bitmapWithReflection);
    canvas.drawBitmap(bitmap, 0, 0, null);
    Paint deafalutPaint = new Paint();
    canvas.drawRect(0, height, width, height + reflectionGap, deafalutPaint);

    canvas.drawBitmap(reflectionImage, 0, height + reflectionGap, null);

    Paint paint = new Paint();
    LinearGradient shader = new LinearGradient(0, bitmap.getHeight(), 0,
            bitmapWithReflection.getHeight() + reflectionGap, 0x70ffffff,
            0x00ffffff, TileMode.CLAMP);
    paint.setShader(shader);
    // Set the Transfer mode to be porter duff and destination in
    paint.setXfermode(new PorterDuffXfermode(Mode.DST_IN));
    // Draw a rectangle using the paint with our linear gradient
    canvas.drawRect(0, height, width, bitmapWithReflection.getHeight()
            + reflectionGap, paint);

    return bitmapWithReflection;
}