Main.java Source code

Introduction

Here is the source code for Main.java

Source

//package com.java2s;

import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;

import android.graphics.Rect;

public class Main {
    /** Used to smoothly resize images */
    private static Paint antiAliasPaint = null;
    /** Default canvas used to interact with bitmaps */
    private static Canvas canvas = new Canvas();

    /**
     * Load the image at {@code imagePath} as a {@link Bitmap}, scaling it to
     * the specified size and preserving the aspect ratio.
     * @param imagePath Path of the image to load.
     * @param width Required width of the resulting {@link Bitmap}.
     * @param height Required height of the resulting {@link Bitmap}.
     * @return {@link Bitmap} representing the image at {@code imagePath}.
     */
    public static Bitmap getIconFromImage(String imagePath, int width, int height) {
        return loadResizedBitmap(imagePath, width, height, true, false);
    }

    /**
     * Load the image at {@code imagePath} as a {@link Bitmap}, scaling it to
     * the specified size and preserving the aspect ratio.
     * @param imagePath Path of the image to load.
     * @param width Required width of the resulting {@link Bitmap}.
     * @param height Required height of the resulting {@link Bitmap}.
     * @param fill {@code true} to fill the empty space with transparent color.
     * @param crop {@code true} to crop the image, {@code false} to resize without cutting the image.
     * @return {@link Bitmap} representing the image at {@code imagePath}.
     */
    public static Bitmap loadResizedBitmap(String imagePath, int width, int height, boolean fill, boolean crop) {
        Bitmap retVal;

        BitmapFactory.Options opts = new BitmapFactory.Options();
        opts.inSampleSize = getScale(imagePath, width, height);
        opts.inJustDecodeBounds = false;

        Bitmap image = BitmapFactory.decodeFile(imagePath, opts);

        if (image == null) {
            return null;
        }

        if (image.getWidth() != width || image.getHeight() != height) {
            //Image need to be resized.
            //         int scaledWidth = image.getWidth();
            //         int scaledHeight = image.getHeight();
            //         final float factorWidth = scaledWidth / width;
            //         final float factorHeight = scaledHeight / height;
            //final float factor = (scaledWidth / width) - (scaledHeight / height);
            //         final long factor = (scaledWidth * height) - (scaledHeight * width);
            //         if ((crop && factor > 0) || (factor < 0)) {
            //            scaledHeight = (scaledHeight * width) / scaledWidth;
            //            scaledWidth = width;
            //         } else {
            //            scaledWidth = (scaledWidth * height) / scaledHeight;
            //            scaledHeight = height;
            //         }
            int scaledWidth = (image.getWidth() * height) / image.getHeight();
            int scaledHeight; // = (image.getHeight() * width) / image.getWidth();
            if ((crop && scaledWidth > width) || (!crop && scaledWidth < width)) {
                scaledHeight = height;
            } else {
                scaledWidth = width;
                scaledHeight = (image.getHeight() * width) / image.getWidth();
            }
            //image = Bitmap.createScaledBitmap(image, scaledWidth, scaledHeight, true);

            Rect src = new Rect(0, 0, image.getWidth(), image.getHeight());
            Rect dst = new Rect(0, 0, scaledWidth, scaledHeight);

            if (fill) {
                retVal = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888);
                dst.offset((width - scaledWidth) / 2, (height - scaledHeight) / 2);
            } else {
                retVal = Bitmap.createBitmap(scaledWidth, scaledHeight, Bitmap.Config.ARGB_8888);
            }
            retVal.eraseColor(Color.TRANSPARENT);

            synchronized (canvas) {
                if (antiAliasPaint == null) {
                    antiAliasPaint = new Paint();
                    antiAliasPaint.setAntiAlias(true);
                    antiAliasPaint.setFilterBitmap(true);
                    antiAliasPaint.setDither(true);
                }
                canvas.setBitmap(retVal);
                canvas.drawBitmap(image, src, dst, antiAliasPaint);
            }

            image.recycle();
        } else {
            //No need to scale.
            retVal = image;
        }

        return retVal;
    }

    private static int getScale(String imagePath, int desiredWidth, int desiredHeight) {
        //Get image size
        BitmapFactory.Options imageInfo = new BitmapFactory.Options();
        imageInfo.inJustDecodeBounds = true;
        BitmapFactory.decodeFile(imagePath, imageInfo);

        //Compute the scaling factor
        int scale = 1;
        int width = imageInfo.outWidth;
        int height = imageInfo.outHeight;
        //if (size < imageInfo.outHeight) size = imageInfo.outHeight;
        //while (size/(scale*2) >= ICON_SIZE) {
        while (width / (scale * 2) >= desiredWidth && height / (scale * 2) >= desiredHeight) {
            scale = scale * 2;
        }

        return scale;
    }
}