web-dev-qa-db-fra.com

Créer une image avec un coin arrondi à l'aide de picasso

Je sais qu'il y a beaucoup de liens disponibles pour faire ImageView Round Corner. Mais j'utilise Picasso bibliothèque pour le chargement d'images .. Je me réfère au lien pour obtenir le résultat. Mais le problème est que je l'utilise dans ListView et pour le LIstView's premier élément ImageView son fonctionne parfaitement mais pour le reste une fois la transformation ne fonctionne pas.

androidimageviewpicasso
32
Akshay

J'utilise cette transformation: https://Gist.github.com/julianshen/58293

Picasso.with(activity).load(url).transform(new CircleTransform()).into(imageView);
44
dasar

Vous pouvez utiliser la classe RoundedCornersTransformation de la bibliothèque picasso-transformations .

Exemple :

final int radius = 5;
final int margin = 5;
final Transformation transformation = new RoundedCornersTransformation(radius, margin);
Picasso.with(activity).load(url).transform(transformation).into(imageView);
29
STB Land

Vous pouvez utiliser cette classe pour créer une image rectangle aux coins arrondis avec Picasso, utilisez-la comme ceci

 Picasso.with(activity).load(url).transform(new RoundedCornersTransform(this)).into(imageView);

Voici la classe RoundedCornersTransform.

package com.demo.picasso;

import Android.graphics.Bitmap;
import Android.graphics.BitmapShader;
import Android.graphics.Canvas;
import Android.graphics.Paint;
import Android.graphics.RectF;

import com.squareup.picasso.Transformation;


public class RoundedCornersTransform 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, BitmapShader.TileMode.CLAMP, BitmapShader.TileMode.CLAMP);
    Paint.setShader(shader);
    Paint.setAntiAlias(true);

    float r = size / 8f;
    canvas.drawRoundRect(new RectF(0, 0, source.getWidth(), source.getHeight()), r, r, Paint);
    squaredBitmap.recycle();
    return bitmap;
}

@Override
public String key() {
    return "rounded_corners";
  }
}
24
stevyhacker

j'ai utilisé RoundedCornersTransformationclass de la bibliothèque picasso-transformations. J'avais un adaptateur personnalisé avec un motif de support de vue dans ma liste. J'ai ajouté la dépendance ci-dessous dans mon build.gradle:

dependencies {
        compile 'jp.wasabeef:picasso-transformations:2.1.0'
}

Et dans mon customArrayAdapter.Java, J'ai ajouté:

Picasso.with(getContext()).load(path).transform(new RoundedCornersTransformation(10,10)).resize(175,300).into(viewHolder.ivImage);
Cela redimensionnerait et donnerait des coins arrondis à vos images.

7
DISHA

Comme dit ici . Vous pouvez utiliser la bibliothèque MaskTransformationclass of picasso-transformations .

Exemple :

final Transformation transformation = new MaskTransformation(getContext(), R.drawable.rounded_convers_transformation);
Picasso.with(activity).load(url).transform(transformation).into(imageView);

res/drawable/round_convers_transformation.xml 

<?xml version="1.0" encoding="utf-8"?>
<shape xmlns:Android="http://schemas.Android.com/apk/res/Android"
       Android:shape="rectangle">
    <corners Android:radius="5dp"/>
    <solid Android:color="@color/black"/>
</shape>

MISE À JOUR: Mais notez que vous devez également .resize(w,h) l'image, car si l'image sera grande, le tour ne sera pas déterminable

5
NickUnuchek

Après la réponse de @ stevyhacker et celle-ci , j'ai trouvé ceci:

import Android.graphics.Bitmap;
import Android.graphics.Canvas;
import Android.graphics.Color;
import Android.graphics.Paint;
import Android.graphics.Path;
import Android.graphics.PorterDuff;
import Android.graphics.PorterDuffXfermode;
import Android.graphics.Rect;
import Android.graphics.RectF;

import com.squareup.picasso.Transformation;


public class RoundedCornersTransform implements Transformation {
    private static Bitmap createRoundedRectBitmap(Bitmap bitmap,
                                                  float topLeftCorner, float topRightCorner,
                                                  float bottomRightCorner, float bottomLeftCorner) {
        Bitmap output = Bitmap.createBitmap(bitmap.getWidth(), bitmap.getHeight(),
                Bitmap.Config.ARGB_8888);
        Canvas canvas = new Canvas(output);

        final int color = Color.WHITE;
        final Paint paint = new Paint();
        final Rect rect = new Rect(0, 0, bitmap.getWidth(), bitmap.getHeight());
        final RectF rectF = new RectF(rect);
        Path path = new Path();
        float[] radii = new float[]{
                topLeftCorner, bottomLeftCorner,
                topRightCorner, topRightCorner,
                bottomRightCorner, bottomRightCorner,
                bottomLeftCorner, bottomLeftCorner
        };

        Paint.setAntiAlias(true);
        canvas.drawARGB(0, 0, 0, 0);
        Paint.setColor(color);
        path.addRoundRect(rectF, radii, Path.Direction.CW);
        canvas.drawPath(path, Paint);
        Paint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.SRC_IN));
        canvas.drawBitmap(bitmap, rect, rect, Paint);
        return output;
    }

    @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();
        }

        float r = size / 4f;

        Bitmap roundedBitmap = createRoundedRectBitmap(squaredBitmap, r, r, r, r);

        squaredBitmap.recycle();

        return roundedBitmap;
    }

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

Utilisez-le comme ceci:

Picasso.with(context).load(url).transform(new RoundedCornersTransform()).into(imageView);

A probablement besoin d'améliorations, alors faites attention!

2
RominaV