En Android, un ImageView es un rectángulo de forma predeterminada. ¿Cómo puedo hacer un rectángulo redondeado (clip fuera de las 4 esquinas de mi mapa de bits a ser rectángulos redondeados) en el ImageView?

Esto puede ser de ayuda stackoverflow.com/questions/26850780/…
Escondido debajo de mayor edad, más complicado respuestas es lo que creo que debe ser aceptado contestar ahora: RoundedBitmapDrawable, añadió en v4 Apoyo de la Biblioteca de revisión 21.
Usted puede intentar este gadgetsaint.com/android/circular-images-glide-library-android/…
Usted puede hacerlo de forma más sencilla, utilizando sólo la CardView con un ImageView interior – mira el ejemplo aquí stackoverflow.com/a/41479670/4516797
Este de la biblioteca es muy útil.

OriginalEl autor michael | 2010-03-17

30 Comentarios

  1. 518

    Esto es bastante tarde en la respuesta, pero para cualquier persona que está mirando para esto, se puede hacer el siguiente código manualmente redondear las esquinas de las imágenes.

    http://www.ruibm.com/?p=184

    Que este no es mi código, pero lo he utilizado y funciona de maravilla. Yo lo he utilizado como un auxiliar dentro de un ImageHelper clase y la extendió un poco para pasar en la cantidad de calado necesito para una imagen dada.

    Código Final se parece a esto:

    package com.company.app.utils;
    
    import android.graphics.Bitmap;
    import android.graphics.Canvas;
    import android.graphics.Paint;
    import android.graphics.PorterDuffXfermode;
    import android.graphics.Rect;
    import android.graphics.RectF;
    import android.graphics.Bitmap.Config;
    import android.graphics.PorterDuff.Mode;
    
    public class ImageHelper {
        public static Bitmap getRoundedCornerBitmap(Bitmap bitmap, int pixels) {
            Bitmap output = Bitmap.createBitmap(bitmap.getWidth(), bitmap
                    .getHeight(), Config.ARGB_8888);
            Canvas canvas = new Canvas(output);
    
            final int color = 0xff424242;
            final Paint paint = new Paint();
            final Rect rect = new Rect(0, 0, bitmap.getWidth(), bitmap.getHeight());
            final RectF rectF = new RectF(rect);
            final float roundPx = pixels;
    
            paint.setAntiAlias(true);
            canvas.drawARGB(0, 0, 0, 0);
            paint.setColor(color);
            canvas.drawRoundRect(rectF, roundPx, roundPx, paint);
    
            paint.setXfermode(new PorterDuffXfermode(Mode.SRC_IN));
            canvas.drawBitmap(bitmap, rect, rect, paint);
    
            return output;
        }
    }

    Espero que esto ayude a alguien!

    Seguro, yo no veo por qué no?
    Esto no funciona para todos los dispositivos.Qué necesito cambiar en cualquier lugar ?
    Lleva casi 0.03 segundo para hacer que para un 200*200 de la imagen, así que creo que no es la mejor solución.
    Sólo rondas parte superior izquierda y superior derecha de las esquinas. Por qué ?
    No funciona bien cuando se intenta establecer imageview del scaletype, sólo fitXY está trabajando, centerCrop y otros están mostrando resultados impredecibles, nadie aquí tienes mismos problemas?

    OriginalEl autor George Walters II

  2. 192

    Mientras que la respuesta anterior funciona, Romain Guy (un núcleo de desarrollo de Android) muestra un método mejor en su blog que usa menos memoria por el uso de un sombreado no se crea una copia del mapa de bits. La esencia general de la funcionalidad está aquí:

    BitmapShader shader;
    shader = new BitmapShader(bitmap, Shader.TileMode.CLAMP, Shader.TileMode.CLAMP);
    
    Paint paint = new Paint();
    paint.setAntiAlias(true);
    paint.setShader(shader);
    
    RectF rect = new RectF(0.0f, 0.0f, width, height);
    
    //rect contains the bounds of the shape
    //radius is the radius in pixels of the rounded corners
    //paint contains the shader that will texture the shape
    canvas.drawRoundRect(rect, radius, radius, paint);

    Las ventajas de este sobre otros métodos es que:

    • no crear una copia del mapa de bits, que utiliza una gran cantidad de memoria con imágenes de gran tamaño [vs la mayoría de las otras respuestas aquí]
    • apoya antialisasing [vs clipPath método]
    • apoya alfa [vs xfermode+porterduff método]
    • apoya la aceleración de hardware [vs clipPath método]
    • sólo dibuja una vez a la lona [vs xfermode y clippath métodos]

    He creado un RoundedImageView basado en este código que envuelve esta lógica en un ImageView y añade adecuada ScaleType apoyo y una opcional de borde redondeado.

    en su / example / res / layout / rounded_item.xml ¿por qué especificar una imagen src cuando todas las fuentes están codificados ? Buen demo, acaba de manera excesiva.
    la muestra tiene un serio fuera problema de la memoria, al igual que el original de la muestra de Romain Guy. Todavía no sé cuál es la causa, pero al igual que su código, esto es realmente una cosa difícil de encontrar. Si usted no puede ver un crash de la aplicación, porque de OOM, puede girar la aplicación varias veces hasta que se produce (depende de tu dispositivo, ROM, etc…) . Me he informado acerca de esto en el pasado aquí: stackoverflow.com/questions/14109187/…
    Nadie está reportando el problema de la memoria, así que debe ser algo que usted está haciendo fuera de el código es incorrecto. El ejemplo correctamente tiene un conjunto limitado de mapas de bits en el adaptador de sin recreando cada vez que una vista es dibujado. El ejemplo que se muestra aquí es un fragmento de el método draw() en la Imagen, que utiliza la referencia para el mapa de bits original se mantiene y funciona correctamente. Se trata de no el objetivo de cambiar el mapa de bits original, pero sólo se hacen con las esquinas redondeadas. Centro de cultivos funciona bien en el ejemplo así.
    Si usted puede proporcionar capturas de pantalla o dispositivos donde no funciona, o incluso ir tan lejos como el ofrecimiento de una solución y la solicitud de extracción, que sería más productivo. He probado girando varias veces en mis dispositivos y la memoria permanece el mismo.
    Tenga en cuenta que no va a funcionar si el tamaño de la imagen está por encima de 2048 píxeles. El sombreado no admite una textura a ser más que eso.

    OriginalEl autor vinc3m1

  3. 106

    En la v21 de la biblioteca de Compatibilidad ahora hay una solución para esto: se llama RoundedBitmapDrawable.

    Es básicamente igual que una normal Dibujable, excepto que darle un radio de esquina para el recorte con:

    setCornerRadius(float cornerRadius)

    Así, comenzando con Bitmap src y un objetivo ImageView, se vería algo como esto:

    RoundedBitmapDrawable dr = RoundedBitmapDrawableFactory.create(res, src);
    dr.setCornerRadius(cornerRadius);
    imageView.setImageDrawable(dr);
    Muchas gracias, aquí está el siguiente paso: stackoverflow.com/questions/24878740/…
    en realidad hay android.support.v4.graphics.drawable.RoundedBitmapDrawableFactory así v4 también lo admite.
    sí, es en v4 apoyo de la biblioteca, pero no hasta REVISION 21 de la biblioteca de compatibilidad
    Esta es una solución simple y actualizada. Se requiere la menor cantidad de código y de gran extensibilidad. Puede trabajar con imágenes de archivo local, caché dibujable, o incluso con la Volea del NetworkImageView. Estoy muy de acuerdo en que esto debe ser aceptado responder a día de hoy, como @Jonik señaló.
    Unfortutately no funciona con scaleType centerCrop (biblioteca de soporte v25.3.1)

    OriginalEl autor tyczj

  4. 106

    Otra forma fácil es usar un CardView con el radio de la esquina y un ImageView interior:

      <android.support.v7.widget.CardView
                android:layout_width="match_parent"
                android:layout_height="match_parent"
                app:cardCornerRadius="8dp"
                android:layout_margin="5dp"
                android:elevation="10dp">
    
                <ImageView
                    android:id="@+id/roundedImageView"
                    android:layout_width="match_parent"
                    android:layout_height="match_parent"
                    android:src="@drawable/image"
                    android:background="@color/white"
                    android:scaleType="centerCrop"
                    />
            </android.support.v7.widget.CardView>

    Cómo hacer un ImageView con las esquinas redondeadas?

    Parece una buena solución. Pero no clip de imágenes en pre-Chups.
    Lo que si , solo queremos que la radio en la parte superior izquierda y superior derecha de las esquinas y no a todos los rincones ?
    Pruebe el diseño margen inferior con el -10dp valor para ocultar la tarjeta en la parte inferior. O crear su propia vista personalizada
    Muy simple e inteligente manera de aplicar la curva de frontera en cualquier vista.
    Buena solución, pero la elevación sólo es compatible con la api de nivel 21 y por encima de

    OriginalEl autor Taras Vovkovych

  5. 71

    Recorte de formas redondeadas y se añadió a la Ver clase de la API de 21.

    Basta con hacer:

    • Crear una forma redondeada dibujable, algo como esto:

    res/drawable/round_outline.xml

    <shape xmlns:android="http://schemas.android.com/apk/res/android"
        android:shape="rectangle">
        <corners android:radius="10dp" />
        ...
    </shape>
    • Establecer la imagen como su ImageView del fondo:
      android:background="@drawable/round_outline"
    • De acuerdo a este documentación, entonces todo lo que necesita hacer es agregar android:clipToOutline="true"

    Lamentablemente, no hay un error y que el atributo XML no es reconocido. Por suerte, todavía podemos configurar el recorte en Java:

    • En su actividad o fragmento: ImageView.setClipToOutline(true)

    Aquí es lo que se verá así:

    Cómo hacer un ImageView con las esquinas redondeadas?

    Nota:

    Este método funciona para cualquier dibujable forma (no sólo redondeado). Se recortará el ImageView para cualquiera que sea el esquema de la forma que has definido en tu Dibujable xml.

    Nota especial sobre ImageViews

    setClipToOutline() sólo funciona cuando la Vista del fondo es una forma de dibujable. Si este fondo, en la forma que existe, en Vista de que trata la forma del contorno de la frontera para el recorte y a los efectos de sombreado.

    Esto significa, que si usted desea utilizar setClipToOutline() para redondear las esquinas en un ImageView, su imagen debe ser establecido usando android:src en lugar de android:background (desde el fondo debe ser ajustado a su forma redondeada). Si usted DEBE usar de fondo para establecer su imagen en lugar de src, puede utilizar esta solución:

    • De crear un diseño y configurar su fondo y su forma de dibujable
    • Un envoltorio de diseño alrededor de su ImageView (sin relleno)
    • El ImageView (incluyendo cualquier otra cosa en el layout) mostrará ahora con diseño redondeado forma.
    Error:(x) Sin identificador de recursos encontrados para el atributo ‘clipToOutline’ paquete ‘android’
    En lugar android:clipToOutline, uno debe usar android:outlineProvider="background".
    esto es bueno y simple

    OriginalEl autor hungryghost

  6. 51

    He encontrado que ambos métodos fueron muy útiles para venir para arriba con una solución de trabajo. Aquí está mi versión compuesta, que es de píxeles independientes y le permite tener las esquinas del cuadrado con el resto de las esquinas tener el mismo radio (que es lo habitual en el caso de uso).
    Gracias a ambos de las soluciones anteriores:

    public static Bitmap getRoundedCornerBitmap(Context context, Bitmap input, int pixels , int w , int h , boolean squareTL, boolean squareTR, boolean squareBL, boolean squareBR  ) {
    Bitmap output = Bitmap.createBitmap(w, h, Config.ARGB_8888);
    Canvas canvas = new Canvas(output);
    final float densityMultiplier = context.getResources().getDisplayMetrics().density;
    final int color = 0xff424242;
    final Paint paint = new Paint();
    final Rect rect = new Rect(0, 0, w, h);
    final RectF rectF = new RectF(rect);
    //make sure that our rounded corner is scaled appropriately
    final float roundPx = pixels*densityMultiplier;
    paint.setAntiAlias(true);
    canvas.drawARGB(0, 0, 0, 0);
    paint.setColor(color);
    canvas.drawRoundRect(rectF, roundPx, roundPx, paint);
    //draw rectangles over the corners we want to be square
    if (squareTL ){
    canvas.drawRect(0, h/2, w/2, h, paint);
    }
    if (squareTR ){
    canvas.drawRect(w/2, h/2, w, h, paint);
    }
    if (squareBL ){
    canvas.drawRect(0, 0, w/2, h/2, paint);
    }
    if (squareBR ){
    canvas.drawRect(w/2, 0, w, h/2, paint);
    }
    paint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.SRC_IN));
    canvas.drawBitmap(input, 0,0, paint);
    return output;
    }

    También, me pasó por encima ImageView para poner esto en lo que me podría definir en xml.
    Puede que desee agregar en la lógica de que la súper llamada hace aquí, pero me han comentado que ya no es útil, en mi caso.

        @Override
    protected void onDraw(Canvas canvas) {
    //super.onDraw(canvas);
    Drawable drawable = getDrawable();
    Bitmap b =  ((BitmapDrawable)drawable).getBitmap() ;
    Bitmap bitmap = b.copy(Bitmap.Config.ARGB_8888, true);
    int w = getWidth(), h = getHeight();
    Bitmap roundBitmap =  CropImageView.getRoundedCornerBitmap( getContext(), bitmap,10 , w, h , true, false,true, false);
    canvas.drawBitmap(roundBitmap, 0,0 , null);
    }

    Espero que esto ayude!

    bastante impresionante, especialmente la ampliación de la ImageView
    Una forma sencilla de mantener la lógica de la ImageView#onDraw() es la de establecer la esquina redondeada de mapa de bits para la imagen de la ImageView, y dejar el super.onDraw() para dibujar el mapa de bits. He creado una clase RoundedCornerImageView, y su ejemplo de uso es aquí. Por favor, observe que el getRoundedCornerBitmap() he utilizado no es de píxeles independientes.
    Gracias por la RoundedCornerImageView. Yo lo he utilizado pero modificado para ser píxeles densidad de independiente.
    El código fuente de umba del RoundedCornerImageView está aquí: code.google.com/p/android-batsg/source/browse/trunk/…
    Harmer trabajando bien solo 1 editar…hay cuatro condiciones..solo cambio de ellos, como si yo establecido a true,true,false,false establecerá parte inferior de la esquina en lugar de la parte superior de la esquina..de lo contrario, el código está funcionando bien.así squareTL y squareTR son condiciones para squareBL y squareBR respectivamente..y vica-versa.

    OriginalEl autor Caspar Harmer

  7. 45

    He hecho por la Costumbre de ImageView:

    public class RoundRectCornerImageView extends ImageView {
    private float radius = 18.0f;
    private Path path;
    private RectF rect;
    public RoundRectCornerImageView(Context context) {
    super(context);
    init();
    }
    public RoundRectCornerImageView(Context context, AttributeSet attrs) {
    super(context, attrs);
    init();
    }
    public RoundRectCornerImageView(Context context, AttributeSet attrs, int defStyle) {
    super(context, attrs, defStyle);
    init();
    }
    private void init() {
    path = new Path();
    }
    @Override
    protected void onDraw(Canvas canvas) {
    rect = new RectF(0, 0, this.getWidth(), this.getHeight());
    path.addRoundRect(rect, radius, radius, Path.Direction.CW);
    canvas.clipPath(path);
    super.onDraw(canvas);
    }
    }

    Cómo utilizar:

    <com.mypackage.RoundRectCornerImageView
    android:id="@+id/imageView"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:background="@drawable/image"
    android:scaleType="fitXY" />

    De salida:

    Cómo hacer un ImageView con las esquinas redondeadas?

    Espero que esto los ayude.

    esto hace que la borrosidad de la imagen
    funciona incluso con android:scaleType=»centerCrop», simple, no crear nuevo mapa de bits. Gracias!
    Esta solución funciona bien para ImageView con una Imagen de fondo. Pero no funciona para ImageViews que acaba color de fondo y no de la Imagen. Puede usted por favor decirme por qué esta sucediendo ?
    Canvas.clipPath() puede causar java.lang.UnsupportedOperationException en algunos casos. Consulte stackoverflow.com/questions/13248904/…
    Esta solución sólo funciona para el conjunto de imágenes con android:background, pero no android:src.

    OriginalEl autor Hiren Patel

  8. 44

    Redondeado imagen Utilizando ImageLoader aquí

    Crear DisplayImageOptions:

    DisplayImageOptions options = new DisplayImageOptions.Builder()
    //this will make circle, pass the width of image 
    .displayer(new RoundedBitmapDisplayer(getResources().getDimensionPixelSize(R.dimen.image_dimen_menu))) 
    .cacheOnDisc(true)
    .build();
    imageLoader.displayImage(url_for_image,ImageView,options);

    O puede el usuario Picasso de la Biblioteca de la Plaza.

    Picasso.with(mContext)
    .load(com.app.utility.Constants.BASE_URL+b.image)
    .placeholder(R.drawable.profile)
    .error(R.drawable.profile)
    .transform(new RoundedTransformation(50, 4))
    .resizeDimen(R.dimen.list_detail_image_size, R.dimen.list_detail_image_size)
    .centerCrop()
    .into(v.im_user);

    puede descargar RoundedTransformation archivo aquí
    aquí

    No se visualiza la imagen
    El Picasso de la Biblioteca no es bueno, y muy fácil de aplicar, muchas gracias +1
    El Picasso de la biblioteca parece no transformar el «marcador de posición» y «error» de la imagen, así que si tu imagen no se carga (error) o tarda un poco en cargar inicialmente (marcador) no voy a mostrar la imagen como una imagen redondeada. github.com/square/picasso/issues/337
    El RoundedTransformation funciona muy bien!
    Otros útiles picasso transformaciones son proporcionados por esta biblioteca, que contiene también una RoundedCornersTransformation: github.com/wasabeef/picasso-transformations

    OriginalEl autor shailesh

  9. 24

    Como todas las respuestas que parecía demasiado complicado para mí sólo para la vuelta a la esquina pensé y llegué a otra solución que creo que vale la pena compartir, sólo con XML en caso de tener algún espacio alrededor de la imagen:

    Crear un bordeado de forma transparente con contenido como este:

    <?xml version="1.0" encoding="utf-8"?>
    <shape xmlns:android="http://schemas.android.com/apk/res/android"
    android:shape="rectangle">
    <corners 
    android:radius="30dp" />
    <stroke 
    android:color="#ffffffff"
    android:width="10dp" />
    </shape> 

    A continuación, en un RelativeLayout puede que el primer lugar de la imagen y, a continuación, en la misma ubicación por encima de la forma con otro ImageView. La cubierta de la forma debe ser mayor en tamaño por la cantidad de ancho de borde. Tener la precaución de tomar un mayor radio de la esquina como el radio exterior está definido, pero el radio interior es lo que cubre su imagen.

    Espero que ayude a alguien, también.

    Editar como por CQM solicitar la relación de diseño ejemplo:

    <?xml version="1.0" encoding="utf-8"?>
    <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent" >
    <ImageView
    android:id="@+id/imageToShow"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:layout_alignBottom="@+id/imgCorners"
    android:layout_alignLeft="@+id/imgCorners"
    android:layout_alignRight="@+id/imgCorners"
    android:layout_alignTop="@+id/imgCorners"
    android:background="#ffffff"
    android:contentDescription="@string/desc"
    android:padding="5dp"
    android:scaleType="centerCrop" />
    <ImageView
    android:id="@+id/imgCorners"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:adjustViewBounds="true"
    android:contentDescription="@string/desc"
    android:src="@drawable/corners_white" />
    </RelativeLayout>
    usted puede elaborar más sobre esto con más código, especialmente en lo que se hace con la segunda imagen de la vista y donde el «limita de forma» xml está siendo aplicado (como fuente o como fondo?) varias preguntas aquí. Quiero que me guste esta solución ya que me deja el control de las cuatro esquinas de forma independiente
    Aunque parece ser una simple respuesta, por desgracia, añade margen alrededor del «enmascarado» de la imagen vista de que es indeseable efecto secundario.
    sí, pero el mismo funciona con un ImageView basado en un PNG-Imagen con esquinas redondeadas y un fondo transparente o un 9-Patch-Dibujable si usted tiene un indefinido aspecto.
    Yo estoy haciendo la misma manera, y su trabajo; sólo dispuesto a saber si no va a crear ningún problema con la orientación y el teléfono diferente tamaño?
    Si se mantiene la dimensión relativa a la simpatia esto no debe crear un problema.

    OriginalEl autor Christian

  10. 13

    La implementación de mi ImageView con esquinas redondeadas widget, que (abajo|arriba)tamaños de imagen a las dimensiones requeridas. Se utiliza el código de forma CaspNZ.

    public class ImageViewRounded extends ImageView {
    public ImageViewRounded(Context context) {
    super(context);
    }
    public ImageViewRounded(Context context, AttributeSet attrs) {
    super(context, attrs);
    }
    public ImageViewRounded(Context context, AttributeSet attrs, int defStyle) {
    super(context, attrs, defStyle);
    }
    @Override
    protected void onDraw(Canvas canvas) {
    BitmapDrawable drawable = (BitmapDrawable) getDrawable();
    if (drawable == null) {
    return;
    }
    if (getWidth() == 0 || getHeight() == 0) {
    return; 
    }
    Bitmap fullSizeBitmap = drawable.getBitmap();
    int scaledWidth = getMeasuredWidth();
    int scaledHeight = getMeasuredHeight();
    Bitmap mScaledBitmap;
    if (scaledWidth == fullSizeBitmap.getWidth() && scaledHeight == fullSizeBitmap.getHeight()) {
    mScaledBitmap = fullSizeBitmap;
    } else {
    mScaledBitmap = Bitmap.createScaledBitmap(fullSizeBitmap, scaledWidth, scaledHeight, true /* filter */);
    }
    Bitmap roundBitmap = ImageUtilities.getRoundedCornerBitmap(getContext(), mScaledBitmap, 5, scaledWidth, scaledHeight,
    false, false, false, false);
    canvas.drawBitmap(roundBitmap, 0, 0, null);
    }
    }
    Imágenes que son más grandes no escala bien, la imagen comprimida…
    ¿De dónde ImageUtilities?
    ver sorrodos post de abajo

    OriginalEl autor Damjan

  11. 7

    Debe extender ImageView y sacar sus propias rectángulo redondeado.

    Si quieres un marco alrededor de la imagen también puede superponer los fotogramas redondeada en la parte superior de la vista de la imagen en el diseño.

    [editar]Superponer el marco en el op de la imagen original, mediante el uso de un FrameLayout por ejemplo. El primer elemento de la FrameLayout será la imagen que desea conocer redondeado. A continuación, añadir otra ImageView con el marco. La segunda ImageView se mostrará en la parte superior de la original ImageView y por lo tanto de Android va a dibujar su contenido por encima de la orignal ImageView.

    Gracias. Pero no es sólo setDrawable método para ImageView, ¿cómo puedo setDrawable de la ImageView para el contenido de mi imagen y, a continuación, superponer un marco redondeado en la parte superior de la ImageView?
    Lo siento, se me estaba claro. Me refería a la superposición en el diseño: así, (es decir) el uso de un FrameLayout poner ImageView en ella y añadir otro ImageView con la parte redondeada de la trama. De esa manera el primer ImageView mostrará la imagen seleccionada y el segundo ImageFrame mostrará la parte redondeada de la trama.
    Correcto – con FrameLayout puede superponer una imagen/vista con otra. Usted también puede hacer uso de android:primer plano de la etiqueta de FrameLayout.
    Es lamentable que no hay manera más simple de hacer esto…

    OriginalEl autor MrSnowflake

  12. 6

    Apoyos a George Walters II anterior, sólo tomé su respuesta y la extendió un poco de apoyo de redondeo individuales esquinas de manera diferente. Este puede ser optimizado un poco más (algunas de las rects se superponen), pero no mucho.

    Sé que este hilo es un poco antiguo, pero es uno de los principales resultados de las consultas en Google de cómo redondear las esquinas de ImageViews en Android.

    /**
    * Use this method to scale a bitmap and give it specific rounded corners.
    * @param context Context object used to ascertain display density.
    * @param bitmap The original bitmap that will be scaled and have rounded corners applied to it.
    * @param upperLeft Corner radius for upper left.
    * @param upperRight Corner radius for upper right.
    * @param lowerRight Corner radius for lower right.
    * @param lowerLeft Corner radius for lower left.
    * @param endWidth Width to which to scale original bitmap.
    * @param endHeight Height to which to scale original bitmap.
    * @return Scaled bitmap with rounded corners.
    */
    public static Bitmap getRoundedCornerBitmap(Context context, Bitmap bitmap, float upperLeft,
    float upperRight, float lowerRight, float lowerLeft, int endWidth,
    int endHeight) {
    float densityMultiplier = context.getResources().getDisplayMetrics().density;
    //scale incoming bitmap to appropriate px size given arguments and display dpi
    bitmap = Bitmap.createScaledBitmap(bitmap, 
    Math.round(endWidth * densityMultiplier),
    Math.round(endHeight * densityMultiplier), true);
    //create empty bitmap for drawing
    Bitmap output = Bitmap.createBitmap(
    Math.round(endWidth * densityMultiplier),
    Math.round(endHeight * densityMultiplier), Config.ARGB_8888);
    //get canvas for empty bitmap
    Canvas canvas = new Canvas(output);
    int width = canvas.getWidth();
    int height = canvas.getHeight();
    //scale the rounded corners appropriately given dpi
    upperLeft *= densityMultiplier;
    upperRight *= densityMultiplier;
    lowerRight *= densityMultiplier;
    lowerLeft *= densityMultiplier;
    Paint paint = new Paint();
    paint.setAntiAlias(true);
    paint.setColor(Color.WHITE);
    //fill the canvas with transparency
    canvas.drawARGB(0, 0, 0, 0);
    //draw the rounded corners around the image rect. clockwise, starting in upper left.
    canvas.drawCircle(upperLeft, upperLeft, upperLeft, paint);
    canvas.drawCircle(width - upperRight, upperRight, upperRight, paint);
    canvas.drawCircle(width - lowerRight, height - lowerRight, lowerRight, paint);
    canvas.drawCircle(lowerLeft, height - lowerLeft, lowerLeft, paint);
    //fill in all the gaps between circles. clockwise, starting at top.
    RectF rectT = new RectF(upperLeft, 0, width - upperRight, height / 2);
    RectF rectR = new RectF(width / 2, upperRight, width, height - lowerRight);
    RectF rectB = new RectF(lowerLeft, height / 2, width - lowerRight, height);
    RectF rectL = new RectF(0, upperLeft, width / 2, height - lowerLeft);
    canvas.drawRect(rectT, paint);
    canvas.drawRect(rectR, paint);
    canvas.drawRect(rectB, paint);
    canvas.drawRect(rectL, paint);
    //set up the rect for the image
    Rect imageRect = new Rect(0, 0, width, height);
    //set up paint object such that it only paints on Color.WHITE
    paint.setXfermode(new AvoidXfermode(Color.WHITE, 255, AvoidXfermode.Mode.TARGET));
    //draw resized bitmap onto imageRect in canvas, using paint as configured above
    canvas.drawBitmap(bitmap, imageRect, imageRect, paint);
    return output;
    }
    +1 para agregar en la densidad del multiplicador y la adición de soporte para individualmente redondeo de las esquinas. Usé la solución en la parte superior, ya que su solución no acaba de funcionar – pero fue muy útil! Ver mi solución compuesta por debajo:

    OriginalEl autor sorrodos

  13. 6

    Romain Guy es en donde está.

    Record de la versión de la siguiente manera.

    Bitmap bitmap = ((BitmapDrawable) getResources().getDrawable(R.drawable.image)).getBitmap();
    Bitmap bitmapRounded = Bitmap.createBitmap(bitmap.getWidth(), bitmap.getHeight(), bitmap.getConfig());
    Canvas canvas = new Canvas(bitmapRounded);
    Paint paint = new Paint();
    paint.setAntiAlias(true);
    paint.setShader(new BitmapShader(bitmap, Shader.TileMode.CLAMP, Shader.TileMode.CLAMP));
    canvas.drawRoundRect((new RectF(0.0f, 0.0f, bitmap.getWidth(), bitmap.getHeight())), 10, 10, paint);
    imageView.setImageBitmap(bitmapRounded);
    lamentablemente, aunque funciona, pero al igual que el resto de las soluciones aquí, crea un nuevo mapa de bits en lugar de utilizar la actual.
    de verdad que no. bitmapRounded sería utilizado una y otra vez. si usted tuvo acceso a la imagen de la lona, puede utilizar el método de dibujo directamente en lugar de generar un nuevo mapa de bits.
    ¿cómo hacer eso? supongamos que yo no uso especial dibujable y manejar sólo un único mapa de bits y el uso setImageBitmap en el final del proceso. ¿cómo puedo conseguir tal cosa?
    echa un vistazo romain guy ejemplo curious-creature.org/2012/12/11/… y de la aplicación de ejemplo docs.google.com/file/d/0B3dxhm5xm1sia2NfM3VKTXNjUnc/edit
    ambos no cambiar el mapa de bits , pero se envuelve el uso de una costumbre dibujable y un imageview. esto no es lo que pregunté. me preguntó ¿cómo se puede cambiar el mapa de bits en sí.

    OriginalEl autor Alex

  14. 6

    Pura xml solución era suficientemente bueno en mi caso. http://www.techrepublic.com/article/pro-tip-round-corners-on-an-android-imageview-with-this-hack/

    EDITAR

    Aquí está la respuesta, en pocas palabras:

    En el /res/dibujable carpeta, crear un frame.xml archivo. En ella, se define un simple rectángulo con esquinas redondeadas y un transparente centro.

    <?xml version="1.0" encoding="utf-8"?>
    <shape xmlns:android="http://schemas.android.com/apk/res/android" android:shape="rectangle">
    <solid android:color="#00ffffff" />
    <padding android:left="6dp"
    android:top="6dp"
    android:right="6dp"
    android:bottom="6dp" />
    <corners android:radius="12dp" />
    <stroke android:width="6dp" android:color="#ffffffff" />
    </shape>

    En su archivo de diseño de agregar un LinearLayout que contiene una norma ImageView, así como un anidada FrameLayout. El FrameLayout utiliza de relleno, y la costumbre de dibujable para dar la ilusión de esquinas redondeadas.

    <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    android:layout_gravity="center"
    android:gravity="center" 
    android:background="#ffffffff">
    <ImageView
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:padding="6dp"
    android:src="@drawable/tr"/>
    <FrameLayout 
    android:layout_width="wrap_content"
    android:layout_height="wrap_content">
    <ImageView
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:padding="6dp"
    android:src="@drawable/tr"/>
    <ImageView 
    android:src="@drawable/frame"
    android:layout_width="match_parent"
    android:layout_height="match_parent" />
    </FrameLayout>
    </LinearLayout>
    buena idea , yo lo he utilizado para mostrar una onu-Incluso ImageView esquinas

    OriginalEl autor j7nn7k

  15. 5

    La siguiente crea un rectángulo redondeado diseño del objeto que se dibuja un rectángulo redondeado alrededor de cualquier niño de objetos que se colocan en ella. También se muestra cómo crear vistas y layouts mediante programación sin necesidad de utilizar el diseño de los archivos xml.

    package android.example;
    import android.app.Activity;
    import android.graphics.Color;
    import android.os.Bundle;
    import android.util.DisplayMetrics;
    import android.util.TypedValue;
    import android.view.ViewGroup.LayoutParams;
    import android.widget.LinearLayout;
    import android.widget.TextView;
    public class MessageScreen extends Activity {
    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    int mainBackgroundColor = Color.parseColor("#2E8B57");
    int labelTextColor = Color.parseColor("#FF4500");
    int messageBackgroundColor = Color.parseColor("#3300FF");
    int messageTextColor = Color.parseColor("#FFFF00");
    DisplayMetrics metrics = new DisplayMetrics();
    getWindowManager().getDefaultDisplay().getMetrics(metrics);
    float density = metrics.density;
    int minMarginSize = Math.round(density * 8);
    int paddingSize = minMarginSize * 2;
    int maxMarginSize = minMarginSize * 4;
    TextView label = new TextView(this);
    /*
    * The LayoutParams are instructions to the Layout that will contain the
    * View for laying out the View, so you need to use the LayoutParams of
    * the Layout that will contain the View.
    */
    LinearLayout.LayoutParams labelLayoutParams = new LinearLayout.LayoutParams(
    LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT);
    label.setLayoutParams(labelLayoutParams);
    label.setTextSize(TypedValue.COMPLEX_UNIT_SP, 18);
    label.setPadding(paddingSize, paddingSize, paddingSize, paddingSize);
    label.setText(R.string.title);
    label.setTextColor(labelTextColor);
    TextView message = new TextView(this);
    RoundedRectangle.LayoutParams messageLayoutParams = new RoundedRectangle.LayoutParams(
    LayoutParams.FILL_PARENT, LayoutParams.WRAP_CONTENT);
    /*
    * This is one of the calls must made to force a ViewGroup to call its
    * draw method instead of just calling the draw method of its children.
    * This tells the RoundedRectangle to put some extra space around the
    * View.
    */
    messageLayoutParams.setMargins(minMarginSize, paddingSize,
    minMarginSize, maxMarginSize);
    message.setLayoutParams(messageLayoutParams);
    message.setTextSize(TypedValue.COMPLEX_UNIT_SP, paddingSize);
    message.setText(R.string.message);
    message.setTextColor(messageTextColor);
    message.setBackgroundColor(messageBackgroundColor);
    RoundedRectangle messageContainer = new RoundedRectangle(this);
    LinearLayout.LayoutParams messageContainerLayoutParams = new LinearLayout.LayoutParams(
    LayoutParams.FILL_PARENT, LayoutParams.WRAP_CONTENT);
    messageContainerLayoutParams.setMargins(paddingSize, 0, paddingSize, 0);
    messageContainer.setLayoutParams(messageContainerLayoutParams);
    messageContainer.setOrientation(LinearLayout.VERTICAL);
    /*
    * This is one of the calls must made to force a ViewGroup to call its
    * draw method instead of just calling the draw method of its children.
    * This tells the RoundedRectangle to color the the exta space that was
    * put around the View as well as the View. This is exterior color of
    * the RoundedRectangle.
    */
    messageContainer.setBackgroundColor(mainBackgroundColor);
    /*
    * This is one of the calls must made to force a ViewGroup to call its
    * draw method instead of just calling the draw method of its children.
    * This is the interior color of the RoundedRectangle. It must be
    * different than the exterior color of the RoundedRectangle or the
    * RoundedRectangle will not call its draw method.
    */
    messageContainer.setInteriorColor(messageBackgroundColor);
    //Add the message to the RoundedRectangle.
    messageContainer.addView(message);
    //
    LinearLayout main = new LinearLayout(this);
    LinearLayout.LayoutParams mainLayoutParams = new LinearLayout.LayoutParams(
    LayoutParams.FILL_PARENT, LayoutParams.WRAP_CONTENT);
    main.setLayoutParams(mainLayoutParams);
    main.setOrientation(LinearLayout.VERTICAL);
    main.setBackgroundColor(mainBackgroundColor);
    main.addView(label);
    main.addView(messageContainer);
    setContentView(main);
    }
    }

    La clase para RoundedRectangle objeto de diseño es como se define aquí:

    /**
    *  A LinearLayout that draws a rounded rectangle around the child View that was added to it.
    */
    package android.example;
    import android.app.Activity;
    import android.content.Context;
    import android.graphics.Canvas;
    import android.graphics.Paint;
    import android.graphics.Rect;
    import android.graphics.RectF;
    import android.util.AttributeSet;
    import android.util.DisplayMetrics;
    import android.widget.LinearLayout;
    /**
    * A LinearLayout that has rounded corners instead of square corners.
    * 
    * @author Danny Remington
    * 
    * @see LinearLayout
    * 
    */
    public class RoundedRectangle extends LinearLayout {
    private int mInteriorColor;
    public RoundedRectangle(Context p_context) {
    super(p_context);
    }
    public RoundedRectangle(Context p_context, AttributeSet attributeSet) {
    super(p_context, attributeSet);
    }
    //Listener for the onDraw event that occurs when the Layout is drawn.
    protected void onDraw(Canvas canvas) {
    Rect rect = new Rect(0, 0, getWidth(), getHeight());
    RectF rectF = new RectF(rect);
    DisplayMetrics metrics = new DisplayMetrics();
    Activity activity = (Activity) getContext();
    activity.getWindowManager().getDefaultDisplay().getMetrics(metrics);
    float density = metrics.density;
    int arcSize = Math.round(density * 10);
    Paint paint = new Paint();
    paint.setColor(mInteriorColor);
    canvas.drawRoundRect(rectF, arcSize, arcSize, paint);
    }
    /**
    * Set the background color to use inside the RoundedRectangle.
    * 
    * @param Primitive int - The color inside the rounded rectangle.
    */
    public void setInteriorColor(int interiorColor) {
    mInteriorColor = interiorColor;
    }
    /**
    * Get the background color used inside the RoundedRectangle.
    * 
    * @return Primitive int - The color inside the rounded rectangle.
    */
    public int getInteriorColor() {
    return mInteriorColor;
    }
    }

    OriginalEl autor Danny Remington – OMS

  16. 5

    ¿por qué no hacer recortes en draw()?

    Aquí está mi solución:

    • extender RelativeLayout con el recorte
    • poner ImageView (o de otra índole) en el diseño:

    código:

    public class RoundRelativeLayout extends RelativeLayout {
    private final float radius;
    public RoundRelativeLayout(Context context, AttributeSet attrs) {
    super(context, attrs);
    TypedArray attrArray = context.obtainStyledAttributes(attrs,
    R.styleable.RoundRelativeLayout);
    radius = attrArray.getDimension(
    R.styleable.RoundRelativeLayout_radius, 0);
    }
    private boolean isPathValid;
    private final Path path = new Path();
    private Path getRoundRectPath() {
    if (isPathValid) {
    return path;
    }
    path.reset();
    int width = getWidth();
    int height = getHeight();
    RectF bounds = new RectF(0, 0, width, height);
    path.addRoundRect(bounds, radius, radius, Direction.CCW);
    isPathValid = true;
    return path;
    }
    @Override
    protected void dispatchDraw(Canvas canvas) {
    canvas.clipPath(getRoundRectPath());
    super.dispatchDraw(canvas);
    }
    @Override
    public void draw(Canvas canvas) {
    canvas.clipPath(getRoundRectPath());
    super.draw(canvas);
    }
    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
    int oldWidth = getMeasuredWidth();
    int oldHeight = getMeasuredHeight();
    super.onMeasure(widthMeasureSpec, heightMeasureSpec);
    int newWidth = getMeasuredWidth();
    int newHeight = getMeasuredHeight();
    if (newWidth != oldWidth || newHeight != oldHeight) {
    isPathValid = false;
    }
    }
    }
    Me gusta este enfoque. Yo lo he utilizado para crear mi propio RoundImageView. Gracias por este.
    Esto no funciona con hardward aceleración activada, ¿correcto? No veo una solución fácil…
    Por favor puede mostrar cómo hacerlo, por tener el resultado como una imagen, con la posibilidad de añadir un esquema (también conocido como accidente cerebrovascular) de todo el contenido, y también tienen la capacidad de hacer sólo algunas de las esquinas para ser redondeadas?

    OriginalEl autor fishautumn

  17. 5

    De reciente, hay otra manera – mediante Deslizamiento de la API Generada. Toma algo de trabajo inicial, pero luego le da todo el poder de Deslizamiento con la flexibilidad para hacer nada, porque se retuercen el código real así que creo que es una buena solución para el largo plazo. Además, el uso es muy simple y limpio.

    Primera, el programa de instalación Glide versión 4+:

    implementation 'com.github.bumptech.glide:glide:4.6.1'
    annotationProcessor 'com.github.bumptech.glide:compiler:4.6.1'

    A continuación, crear Glid de la aplicación del módulo de clase para desencadenar la anotación de procesamiento:

    @GlideModule
    public final class MyAppGlideModule extends AppGlideModule {}

    A continuación, crear el riel de extensión que realiza el trabajo. Usted puede personalizar para hacer lo que quieras:

    @GlideExtension
    public class MyGlideExtension {
    private MyGlideExtension() {}
    @NonNull
    @GlideOption
    public static RequestOptions roundedCorners(RequestOptions options, @NonNull Context context, int cornerRadius) {
    int px = Math.round(cornerRadius * (context.getResources().getDisplayMetrics().xdpi / DisplayMetrics.DENSITY_DEFAULT));
    return options.transforms(new RoundedCorners(px));
    }
    }

    Después de la adición de estos archivos, la construcción de su proyecto.

    A continuación, utilizar en su código como este:

    GlideApp.with(this)
    .load(imageUrl)
    .roundedCorners(getApplicationContext(), 5)
    .into(imageView);
    No te olvides de agregar un espacio entre RequestOptions y options en params
    Hecho. Gracias por el aporte.

    OriginalEl autor Sir Codesalot

  18. 4

    Muchas gracias a la primera respuesta. Aquí está la versión modificada para convertir una imagen rectangular en un cuadrado de una (y redondeadas) y el color de relleno se pasa como parámetro.

    public static Bitmap getRoundedBitmap(Bitmap bitmap, int pixels, int color) {
    Bitmap inpBitmap = bitmap;
    int width = 0;
    int height = 0;
    width = inpBitmap.getWidth();
    height = inpBitmap.getHeight();
    if (width <= height) {
    height = width;
    } else {
    width = height;
    }
    Bitmap output = Bitmap.createBitmap(width, height, Config.ARGB_8888);
    Canvas canvas = new Canvas(output);
    final Paint paint = new Paint();
    final Rect rect = new Rect(0, 0, width, height);
    final RectF rectF = new RectF(rect);
    final float roundPx = pixels;
    paint.setAntiAlias(true);
    canvas.drawARGB(0, 0, 0, 0);
    paint.setColor(color);
    canvas.drawRoundRect(rectF, roundPx, roundPx, paint);
    paint.setXfermode(new PorterDuffXfermode(Mode.SRC_IN));
    canvas.drawBitmap(inpBitmap, rect, rect, paint);
    return output;
    }

    OriginalEl autor mkm

  19. 4

    Aplicar una forma a su imageView de la siguiente manera:

    <shape xmlns:android="http://schemas.android.com/apk/res/android"
    android:shape="rectangle" >
    <solid android:color="#faf5e6" />
    <stroke
    android:width="1dp"
    android:color="#808080" />
    <corners android:radius="15dp" />
    <padding
    android:bottom="5dp"
    android:left="5dp"
    android:right="5dp"
    android:top="5dp" />
    </shape>

    puede ser útil para usted amigo.

    OriginalEl autor jigar

  20. 3

    Aquí es un simple ejemplo primordial imageView, entonces usted puede utilizar en el diseño de un diseñador de vista previa.

    public class RoundedImageView extends ImageView {
    public RoundedImageView(Context context) {
    super(context);
    }
    public RoundedImageView(Context context, AttributeSet attrs) {
    super(context, attrs);
    }
    public RoundedImageView(Context context, AttributeSet attrs, int defStyleAttr) {
    super(context, attrs, defStyleAttr);
    }
    @TargetApi(Build.VERSION_CODES.LOLLIPOP)
    public RoundedImageView(Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes) {
    super(context, attrs, defStyleAttr, defStyleRes);
    }
    @Override
    public void setImageDrawable(Drawable drawable) {
    float radius = 0.1f;
    Bitmap bitmap = ((BitmapDrawable) drawable).getBitmap();
    RoundedBitmapDrawable rid = RoundedBitmapDrawableFactory.create(getResources(), bitmap);
    rid.setCornerRadius(bitmap.getWidth() * radius);
    super.setImageDrawable(rid);
    }

    }

    Esto es para una rápida solución. Radius se usa en todas las esquinas y es a base de porcentaje de mapa de bits de ancho.

    Acabo de overrided setImageDrawable y de apoyo de uso v4 método para redondeado de mapa de bits imagen.

    Uso:

    <com.example.widgets.RoundedImageView
    android:layout_width="39dp"
    android:layout_height="39dp"
    android:src="@drawable/your_drawable" />

    De vista previa con imageView y personalizado imageView:

    Cómo hacer un ImageView con las esquinas redondeadas?

    Esto está trabajando en todos los casos, gracias. Usted salvó mi día.

    OriginalEl autor deadfish

  21. 2

    Respuesta a la pregunta que se redirige aquí:
    «Cómo crear una circular ImageView en Android?»

    public static Bitmap getRoundBitmap(Bitmap bitmap) {
    int min = Math.min(bitmap.getWidth(), bitmap.getHeight());
    Bitmap bitmapRounded = Bitmap.createBitmap(min, min, bitmap.getConfig());
    Canvas canvas = new Canvas(bitmapRounded);
    Paint paint = new Paint();
    paint.setAntiAlias(true);
    paint.setShader(new BitmapShader(bitmap, Shader.TileMode.CLAMP, Shader.TileMode.CLAMP));
    canvas.drawRoundRect((new RectF(0.0f, 0.0f, min, min)), min/2, min/2, paint);
    return bitmapRounded;
    }

    OriginalEl autor Andrey

  22. 2

    Con la ayuda de glide biblioteca y RoundedBitmapDrawableFactory clase es fácil de lograr. Puede que necesite crear circular marcador de posición de imagen.

        Glide.with(context)
    .load(imgUrl)
    .asBitmap()
    .placeholder(R.drawable.placeholder)
    .error(R.drawable.placeholder)
    .into(new BitmapImageViewTarget(imgProfilePicture) {
    @Override
    protected void setResource(Bitmap resource) {
    RoundedBitmapDrawable drawable = RoundedBitmapDrawableFactory.create(context.getResources(),
    Bitmap.createScaledBitmap(resource, 50, 50, false));
    drawable.setCornerRadius(10); //drawable.setCircular(true);
    imgProfilePicture.setImageDrawable(drawable);
    }
    });

    OriginalEl autor Chitrang

  23. 2

    si la imagen está en internet la mejor manera es usar rastrillo y RoundedBitmapDrawableFactory (API 21 – pero disponible en la biblioteca de soporte), así:

     Glide.with(ctx).load(url).asBitmap().centerCrop().into(new BitmapImageViewTarget(imageView) {
    @Override
    protected void setResource(Bitmap res) {
    RoundedBitmapDrawable bitmapDrawable =
    RoundedBitmapDrawableFactory.create(ctx.getResources(), res);
    bitmapDrawable.setCircular(true);//comment this line and uncomment the next line if you dont want it fully cricular
    //circularBitmapDrawable.setCornerRadius(cornerRadius);
    imageView.setImageDrawable(bitmapDrawable);
    }
    });
    Este es un elegante api, sin embargo, .centerInside parece ser que faltan, por lo tanto quizá es mejor utilizar xml para definir los parámetros de
    Esto también es útil cuando la imagen está en los recursos y necesita utilizar centerCrop

    OriginalEl autor Amir Ziarati

  24. 2

    Si usted está usando Glide Biblioteca de esto sería de gran ayuda:

    Glide.with(getApplicationContext())
    .load(image_url)
    .asBitmap()
    .centerCrop()
    .into(new BitmapImageViewTarget(imageView) {
    @Override
    protected void setResource(Bitmap resource) {
    RoundedBitmapDrawable circularBitmapDrawable =
    RoundedBitmapDrawableFactory.create(getApplicationContext().getResources(), resource);
    circularBitmapDrawable.setCornerRadius(dpToPx(10));
    circularBitmapDrawable.setAntiAlias(true);
    imageView.setImageDrawable(circularBitmapDrawable);
    }
    });
    public int dpToPx(int dp) {
    DisplayMetrics displayMetrics = getApplicationContext().getResources().getDisplayMetrics();
    return Math.round(dp * (displayMetrics.xdpi / DisplayMetrics.DENSITY_DEFAULT));
    }
    No funciona para mí.
    Si el uso de Deslizamiento de la versión 4 y por encima de uso — RequestOptions requestOptions = new RequestOptions(); requestOptions = requestOptions.transforma(nueva CenterCrop(), nueva RoundedCorners(16)), que se Deslizan.con(itemView.getContext()) .de carga(punto.getImage()) .aplicar(requestOptions) .en(mProgramThumbnail);

    OriginalEl autor Anirudh

  25. 2

    Kotlin

    import android.graphics.BitmapFactory
    import android.os.Bundle
    import android.support.v4.graphics.drawable.RoundedBitmapDrawableFactory
    import kotlinx.android.synthetic.main.activity_main.*
    val bitmap = BitmapFactory.decodeResource(resources, R.drawable.myImage)
    val rounded = RoundedBitmapDrawableFactory.create(resources, bitmap)
    rounded.cornerRadius = 20f
    profileImageView.setImageDrawable(rounded)

    Para hacer ImageView Circular podemos cambiar cornerRadius con:

    rounded.isCircular = true

    OriginalEl autor Vahid

  26. 2

    Hay un fresco de la biblioteca que le permite de forma imageviews.

    Aquí está un ejemplo:

    <com.github.siyamed.shapeimageview.mask.PorterShapeImageView
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    app:siShape="@drawable/shape_rounded_rectangle"
    android:src="@drawable/neo"
    app:siSquare="true"/>

    Forma de definición:

    <shape android:shape="rectangle" xmlns:android="http://schemas.android.com/apk/res/android">
    <corners
    android:topLeftRadius="18dp"
    android:topRightRadius="18dp"
    android:bottomLeftRadius="18dp"
    android:bottomRightRadius="18dp" />
    <solid android:color="@color/black" />
    </shape>

    Resultado:

    Cómo hacer un ImageView con las esquinas redondeadas?

    OriginalEl autor grrigore

  27. 1

    Un buen montón de respuestas!

    He seguido este ejemplo, que un par de personas que tienen un poco sugerido: http://www.techrepublic.com/article/pro-tip-round-corners-on-an-android-imageview-with-this-hack/

    Sin embargo, lo que yo necesitaba era un círculo coloreado, detrás de una imagen transparente. Para cualquiera que esté interesado en hacer lo mismo…

    1) Establecer el FrameLayout la anchura y la altura – en mi caso el tamaño de la imagen (50dp).

    2) Coloque el ImageView que tiene la src = «@dibujable/…», por encima de la ImageView que tiene la imagen. Dar un id, en mi caso me llamó iconShape

    3) Dibujable mask.xml debe tener un color sólido de #ffffffff
    4) Si desea cambiar dinámicamente el círculo de color en su código, ¿

    ImageView iv2 = (ImageView) v.findViewById(R.id.iconShape);
    Drawable shape = getResources().getDrawable(R.drawable.mask);
    shape.setColorFilter(Color.BLUE, Mode.MULTIPLY);
    iv2.setImageDrawable(shape);
    Ese ejemplo fue el único que funcionó para mí porque estoy usando un borde redondeado (accidente cerebrovascular)… Así, la imagen no sólo debe ser recortada correctamente, pero se deben respetar los bordes redondeados. El uso de otras muestras, la imagen de respetar el relleno.. pero incluso entonces, la imagen de la superposición de la frontera (accidente cerebrovascular) en los bordes

    OriginalEl autor rharvey

  28. 1

    Usted puede tratar de esta biblioteca – RoundedImageView

    Es:

    Un rápido ImageView que soporta las esquinas redondeadas, óvalos y círculos. Un completo superconjunto de CircleImageView.

    He usado en mi proyecto, y es muy fácil.

    OriginalEl autor Igor Ganapolsky

  29. 1

    Utilizar esto para obtener imagen circular de la frontera-

        public static Bitmap getCircularBitmapWithBorder(Bitmap bitmap, int bordercolor) {
    if (bitmap == null || bitmap.isRecycled()) {
    return null;
    }
    int borderWidth=(int)(bitmap.getWidth()/40);
    final int width = bitmap.getWidth() + borderWidth;
    final int height = bitmap.getHeight() + borderWidth;
    Bitmap canvasBitmap = Bitmap.createBitmap(width, height,
    Bitmap.Config.ARGB_8888);
    BitmapShader shader = new BitmapShader(bitmap, 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);
    paint.setShader(null);
    paint.setStyle(Paint.Style.STROKE);
    paint.setColor(bordercolor);
    paint.setStrokeWidth(borderWidth);
    canvas.drawCircle(width / 2, height / 2, radius - borderWidth / 2,
    paint);
    return canvasBitmap;
    }
    Esto me ayuda a agregar borde blanco para redondeado de la imagen. Gracias

    OriginalEl autor Akshay Paliwal

  30. 1

    Estoy usando una vista personalizada que yo diseño en la parte superior de los otros y que sólo atrae a las 4 pequeñas invertida esquinas en el mismo color que el fondo.

    Ventajas:

    • No asignar un mapa de bits.
    • Obras lo que la Vista que desee aplicar las esquinas redondeadas.
    • Obras para todos API niveles 😉

    Código:

    public class RoundedCornersView extends View {
    private float mRadius;
    private int mColor = Color.WHITE;
    private Paint mPaint;
    private Path mPath;
    public RoundedCornersView(Context context) {
    super(context);
    init();
    }
    public RoundedCornersView(Context context, AttributeSet attrs) {
    super(context, attrs);
    init();
    TypedArray a = context.getTheme().obtainStyledAttributes(
    attrs,
    R.styleable.RoundedCornersView,
    0, 0);
    try {
    setRadius(a.getDimension(R.styleable.RoundedCornersView_radius, 0));
    setColor(a.getColor(R.styleable.RoundedCornersView_cornersColor, Color.WHITE));
    } finally {
    a.recycle();
    }
    }
    private void init() {
    setColor(mColor);
    setRadius(mRadius);
    }
    private void setColor(int color) {
    mColor = color;
    mPaint = new Paint();
    mPaint.setColor(mColor);
    mPaint.setStyle(Paint.Style.FILL);
    mPaint.setAntiAlias(true);
    invalidate();
    }
    private void setRadius(float radius) {
    mRadius = radius;
    RectF r = new RectF(0, 0, 2 * mRadius, 2 * mRadius);
    mPath = new Path();
    mPath.moveTo(0,0);
    mPath.lineTo(0, mRadius);
    mPath.arcTo(r, 180, 90);
    mPath.lineTo(0,0);
    invalidate();
    }
    @Override
    protected void onDraw(Canvas canvas) {
    /*This just draws 4 little inverted corners */
    int w = getWidth();
    int h = getHeight();
    canvas.drawPath(mPath, mPaint);
    canvas.save();
    canvas.translate(w, 0);
    canvas.rotate(90);
    canvas.drawPath(mPath, mPaint);
    canvas.restore();
    canvas.save();
    canvas.translate(w, h);
    canvas.rotate(180);
    canvas.drawPath(mPath, mPaint);
    canvas.restore();
    canvas.translate(0, h);
    canvas.rotate(270);
    canvas.drawPath(mPath, mPaint);
    }
    }

    OriginalEl autor mbonnin

Dejar respuesta

Please enter your comment!
Please enter your name here