android: create circular image with picasso

Android Problem Overview

The question had been asked and there had been a promise made for the very version of Picasso that I am using: How do I send a circular bitmap to an ImageView using Picasso? I am new to Picasso and only thing I have used is

Picasso.with(context).load(url).resize(w, h).into(imageview);

I have already found https://gist.github.com/julianshen/5829333 but I am not sure how to combine it with the line above in a non-awkward way.

Android Solutions

Solution 1 - Android

Research a bit before as there are answers available. Anyhow, follow This Link and read it carefully to know how to use it.

try this:

import com.squareup.picasso.Transformation;

public class CircleTransform implements Transformation {
	@Override
	public Bitmap transform(Bitmap source) {
		int size = Math.min(source.getWidth(), source.getHeight());

		int x = (source.getWidth() - size) / 2;
		int y = (source.getHeight() - size) / 2;

		Bitmap squaredBitmap = Bitmap.createBitmap(source, x, y, size, size);
		if (squaredBitmap != source) {
			source.recycle();
		}

		Bitmap bitmap = Bitmap.createBitmap(size, size, source.getConfig());

		Canvas canvas = new Canvas(bitmap);
		Paint paint = new Paint();
		BitmapShader shader = new BitmapShader(squaredBitmap,
				Shader.TileMode.CLAMP, Shader.TileMode.CLAMP);
		paint.setShader(shader);
		paint.setAntiAlias(true);

		float r = size / 2f;
		canvas.drawCircle(r, r, r, paint);

		squaredBitmap.recycle();
		return bitmap;
	}

	@Override
	public String key() {
		return "circle";
	}
}

then simply apply it like:

Picasso.with(activity).load(mayorShipImageLink).transform(new CircleTransform()).into(ImageView);

Solution 2 - Android

here is something that's provided by the support-v4 library! Look into RoundedBitmapDrawable. No need to roll your own:

Picasso.with(context).load(url)
                        .resize(w, h)
                        .into(myImageView, new Callback() {
                            @Override
                            public void onSuccess() {
                                Bitmap imageBitmap = ((BitmapDrawable) myImageView.getDrawable()).getBitmap();
                                RoundedBitmapDrawable imageDrawable = RoundedBitmapDrawableFactory.create(getResources(), imageBitmap);
                                imageDrawable.setCircular(true);
                                imageDrawable.setCornerRadius(Math.max(imageBitmap.getWidth(), imageBitmap.getHeight()) / 2.0f);
                                myImageView.setImageDrawable(imageDrawable);
                            }
                            @Override
                            public void onError() {
                                myImageView.setImageResource(R.drawable.default_image);
                            }
                        });

Note: Picasso also has a .transform(customTransformation) call that you could theoretically use, however, I had issues with that. This above works. Good luck!

Solution 3 - Android

There is a transformation library for Picasso.

Just add gradle dependency

implementation 'jp.wasabeef:picasso-transformations:2.4.0'

End use it

Picasso.with(context)
       .load(url)
       .resize(w, h)
       .transform(new CropCircleTransformation())
       .into(imageview);

Wiki: Picasso Transformations

Solution 4 - Android

Another alternative I found was this guys library. It works standalone, or in conjunction with Picasso. I chose the Picasso route, like below:

https://github.com/vinc3m1/RoundedImageView

Transformation transformation = new RoundedTransformationBuilder()
          .borderColor(Color.BLACK)
          .borderWidthDp(3)
          .cornerRadiusDp(30)
          .oval(false)
          .build();

Picasso.with(context)
    .load(url)
    .fit()
    .transform(transformation)
    .into(imageView);

Worked for me!

Solution 5 - Android

I have tried all solutions above but none of them gives me circle transform without cropping picture..those solution will work only for images with same width and height..this is my solution on above

first ------

Picasso.with(getActivity())
            .load(url)
            .error(R.drawable.image2)
            .placeholder(R.drawable.ic_drawer)
            .resize(200, 200)
            .transform(new ImageTrans_CircleTransform())
            .into(imageView1);

then do this --------

import android.graphics.Bitmap;
import android.graphics.BitmapShader;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.graphics.Shader.TileMode;

import com.squareup.picasso.Transformation;
public class ImageTrans_CircleTransform implements Transformation {
 @Override
    public Bitmap transform(Bitmap source) {
 if (source == null || source.isRecycled()) {
    	        return null;
    	    }

    	    final int width = source.getWidth() + borderwidth;
    	    final int height = source.getHeight() + borderwidth;

    	    Bitmap canvasBitmap = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888);
    	    BitmapShader shader = new BitmapShader(source, TileMode.CLAMP, TileMode.CLAMP);
    	    Paint paint = new Paint();
    	    paint.setAntiAlias(true);
    	    paint.setShader(shader);

    	    Canvas canvas = new Canvas(canvasBitmap);
    	    float radius = width > height ? ((float) height) / 2f : ((float) width) / 2f;
    	    canvas.drawCircle(width / 2, height / 2, radius, paint);
    	    
    	    //border code
    	    paint.setShader(null);
    	    paint.setStyle(Paint.Style.STROKE);
    	    paint.setColor(bordercolor);
    	    paint.setStrokeWidth(borderwidth);
    	    canvas.drawCircle(width / 2, height / 2, radius - borderwidth / 2, paint);
    	    //--------------------------------------
    	    
    	    if (canvasBitmap != source) {
                source.recycle();
            }
    	    
    	    return canvasBitmap;
}
 @Override
    public String key() {
        return "circle";
    }
}

Solution 6 - Android

Use this library to create a circular imageview. To make a circular ImageView, add this CircularImageView library to your project and add CircularImageView in your layout XML

<com.pkmmte.view.CircularImageView
        android:layout_width="250dp"
        android:layout_height="250dp"
        android:src="@drawable/image"
        app:border_color="#EEEEEE"
        app:border_width="4dp"
        app:shadow="true" />`

Then use picasso to load required image into this imageView. Picasso does all the caching you dont need to worry about it

Solution 7 - Android

This one worked for me

<com.androidhub4you.crop.RoundedImageView
        android:id="@+id/imageView_round"
        android:layout_width="100dp"
        android:layout_height="100dp"
        android:layout_marginTop="15dp"
        android:src="@drawable/ic_launcher" />

http://www.androidhub4you.com/2014/10/android-custom-shape-imageview-rounded.html

Solution 8 - Android

Include the xml drawable of type Layer- list with the code below

<layer-list xmlns:android="http://schemas.android.com/apk/res/android">
    <item android:id="@+id/shape_status">
        <shape android:shape="oval">
            <solid android:color="@android:color/black"/>
        </shape>
    </item>
<item android:drawable="@drawable/ic_status_content"/></layer-list>

then use the xml to your ImageView in the android.src

 <ImageView
            android:id="@+id/iconStatus"
            android:layout_width="55dp"
            android:layout_height="55dp"
            android:layout_gravity="right"
            android:src="@drawable/ic_circle_status"
            android:layout_alignParentTop="true"
            android:layout_alignParentEnd="true"/>

Solution 9 - Android

This one is working with the current Picasso 3 snapshot:

class CircleTransformation : Transformation {

  override fun transform(source: RequestHandler.Result): RequestHandler.Result {
    if (source.bitmap == null) {
      return source
    }

    var bitmap: Bitmap

    // since we cant transform hardware bitmaps create a software copy first
    if (VERSION.SDK_INT >= VERSION_CODES.O && source.bitmap!!.config == Config.HARDWARE) {
      val softwareCopy = source.bitmap!!.copy(Config.ARGB_8888, true)
      if (softwareCopy == null) {
        return source
      } else {
        bitmap = softwareCopy
        source.bitmap!!.recycle()
      }
    } else {
      bitmap = source.bitmap!!
    }

    var size = bitmap.width
    // if bitmap is non-square first create square one
    if (size != bitmap.height) {
      var sizeX = size
      var sizeY = bitmap.height
      size = Math.min(sizeY, sizeX)
      sizeX = (sizeX - size) / 2
      sizeY = (sizeY - size) / 2

      val squareSource = Bitmap.createBitmap(bitmap, sizeX, sizeY, size, size)
      bitmap.recycle()
      bitmap = squareSource
    }

    val circleBitmap = Bitmap.createBitmap(size, size, Config.ARGB_8888)
    val canvas = Canvas(circleBitmap)
    val paint = Paint()
    val shader = BitmapShader(bitmap, Shader.TileMode.CLAMP, Shader.TileMode.CLAMP)

    paint.shader = shader
    paint.isAntiAlias = true
    val centerAndRadius = size / 2f
    canvas.drawCircle(centerAndRadius, centerAndRadius, centerAndRadius, paint)

    bitmap.recycle()
    return RequestHandler.Result(circleBitmap, source.loadedFrom, source.exifRotation)
  }

  override fun key(): String {
    return "circleTransformation()"
  }
}

Picasso3 gist: https://gist.github.com/G00fY2/f3fbc468570024930c1fd9eb4cec85a1

Solution 10 - Android

Here is what worked for me with Picasso v2.71828

class CircleTransform : Transformation {
override fun transform(source: Bitmap?): Bitmap? {
    if (source == null) {
        return source
    }

    var bitmap: Bitmap

    // since we cant transform hardware bitmaps create a software copy first
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O && source.config == Bitmap.Config.HARDWARE) {
        val softwareCopy = source.copy(Bitmap.Config.ARGB_8888, true)
        if (softwareCopy == null) {
            return source
        } else {
            bitmap = softwareCopy
            source.recycle()
        }
    } else {
        bitmap = source
    }

    var size = bitmap.width
    // if bitmap is non-square first create square one
    if (size != bitmap.height) {
        var sizeX = size
        var sizeY = bitmap.height
        size = Math.min(sizeY, sizeX)
        sizeX = (sizeX - size) / 2
        sizeY = (sizeY - size) / 2

        val squareSource = Bitmap.createBitmap(bitmap, sizeX, sizeY, size, size)
        bitmap.recycle()
        bitmap = squareSource
    }

    val circleBitmap = Bitmap.createBitmap(size, size, Bitmap.Config.ARGB_8888)
    val canvas = Canvas(circleBitmap)
    val paint = Paint()
    val shader = BitmapShader(bitmap, Shader.TileMode.CLAMP, Shader.TileMode.CLAMP)

    paint.shader = shader
    paint.isAntiAlias = true
    val centerAndRadius = size / 2f
    canvas.drawCircle(centerAndRadius, centerAndRadius, centerAndRadius, paint)

    bitmap.recycle()
    return circleBitmap
}


override fun key(): String {
    return "circleTransformation()"
}

}

Content Type	Original Author	Original Content on Stackoverflow
Question	Katedral Pillon	View Question on Stackoverflow
Solution 1 - Android	Anirudh Sharma	View Answer on Stackoverflow
Solution 2 - Android	goodKode	View Answer on Stackoverflow
Solution 3 - Android	Nikolay Krasilnikov	View Answer on Stackoverflow
Solution 4 - Android	Breeno	View Answer on Stackoverflow
Solution 5 - Android	amit	View Answer on Stackoverflow
Solution 6 - Android	NIPHIN	View Answer on Stackoverflow
Solution 7 - Android	Aditya Vyas-Lakhan	View Answer on Stackoverflow
Solution 8 - Android	Marco Aurelio	View Answer on Stackoverflow
Solution 9 - Android	G00fY	View Answer on Stackoverflow
Solution 10 - Android	chabislav	View Answer on Stackoverflow