Main.java Source code

Introduction

Here is the source code for Main.java

Source

//package com.java2s;
/*
 *    Copyright (C) 2016 Murat Demir <mopened@gmail.com>
 *
 *    This program is free software: you can redistribute it and/or modify
 *    it under the terms of the GNU General Public License as published by
 *    the Free Software Foundation, either version 3 of the License, or
 *    (at your option) any later version.
 *
 *    This program is distributed in the hope that it will be useful,
 *    but WITHOUT ANY WARRANTY; without even the implied warranty of
 *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *    GNU General Public License for more details.
 *
 *    You should have received a copy of the GNU General Public License
 *    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

import android.graphics.Bitmap;

import android.graphics.Canvas;
import android.graphics.Matrix;

import android.graphics.Rect;

public class Main {
    public static Bitmap transform(Matrix scaler, Bitmap source, int targetWidth, int targetHeight, boolean scaleUp,
            boolean fitInScreen) {
        if (fitInScreen) {
            source = scaleTo(scaler, source, targetWidth, targetHeight, true);
        }
        int deltaX = source.getWidth() - targetWidth;
        int deltaY = source.getHeight() - targetHeight;
        if ((!scaleUp || fitInScreen) && (deltaX < 0 || deltaY < 0)) {
            Bitmap b2 = Bitmap.createBitmap(targetWidth, targetHeight, Bitmap.Config.ARGB_8888);
            Canvas c = new Canvas(b2);

            int deltaXHalf = Math.max(0, deltaX / 2);
            int deltaYHalf = Math.max(0, deltaY / 2);
            Rect src = new Rect(deltaXHalf, deltaYHalf, deltaXHalf + Math.min(targetWidth, source.getWidth()),
                    deltaYHalf + Math.min(targetHeight, source.getHeight()));
            int dstX = (targetWidth - src.width()) / 2;
            int dstY = (targetHeight - src.height()) / 2;
            Rect dst = new Rect(dstX, dstY, targetWidth - dstX, targetHeight - dstY);
            c.drawBitmap(source, src, dst, null);
            source.recycle();
            return b2;
        }

        Bitmap b1 = scaleTo(scaler, source, targetWidth, targetHeight, false);

        int dx1 = Math.max(0, b1.getWidth() - targetWidth);
        int dy1 = Math.max(0, b1.getHeight() - targetHeight);

        Bitmap b2 = Bitmap.createBitmap(b1, dx1 / 2, dy1 / 2, targetWidth, targetHeight);
        b1.recycle();

        return b2;
    }

    public static Bitmap scaleTo(Matrix scaler, Bitmap source, int targetWidth, int targetHeight,
            boolean fitInScreen) {
        float bitmapWidthF = source.getWidth();
        float bitmapHeightF = source.getHeight();

        float bitmapAspect = bitmapWidthF / bitmapHeightF;
        float viewAspect = (float) targetWidth / targetHeight;

        float scale = 0;
        float scaleH = targetHeight / bitmapHeightF;
        float scaleW = targetWidth / bitmapWidthF;

        if (fitInScreen && scaleH < scaleW) {
            scale = scaleH;
        } else if (fitInScreen && scaleH >= scaleW) {
            scale = scaleW;
        } else if (bitmapAspect > viewAspect) {
            scale = scaleH;
        } else {
            scale = scaleW;
        }

        if (scale != 0 && (scale < .9F || scale > 1F)) {
            scaler.setScale(scale, scale);
        } else {
            scaler = null;
        }

        Bitmap b1;
        if (scaler != null) {
            // this is used for minithumb and crop, so we want to filter here.
            b1 = Bitmap.createBitmap(source, 0, 0, source.getWidth(), source.getHeight(), scaler, true);
            source.recycle();
        } else {
            b1 = source;
        }
        return b1;
    }
}