Cómo dar forma hexagonal para ImageView . Es posible hacer de la misma manera ? Si es así, cómo. Si esto no es posible a través de este, a continuación, cómo podía lograrse esto ?

<shape xmlns:android="http//schemas.android.com/apk/res/android"
       android:shape="hexagon">
  <solid android:color="#ffffffff" />
  <size android:width="60dp"
        android:height="40dp" />
</shape>

Captura de pantalla

Cómo dar forma hexagonal para ImageView

Aquí yo no puedo hacer enmascaramiento de imagen porque no puedo detectar que la porción de mapa de bits que debo de cultivos para obtener la forma hexagonal de mapa de bits. Así que estoy buscando la respuesta a dar forma hexagonal para ImageView

  • hola, ¿ te las arreglas para llegar a una solución a esto ?
  • Aún no
  • hizo u mirada en este
  • pero todos ellos son de dibujar la figura en el imageview, no hacer que la estructura de imageview para el hexágono, quiero hacer la forma de imageview para hexágono, de modo que cualquier imagen pondré establecería como en el hexágono en el que
  • he intentado enmascarar la imagen.?? Por favor reffer a este enlace stackoverflow.com/questions/5299452/…
  • No estoy tratando con GLSurfaceView

InformationsquelleAutor N Sharma | 2014-03-24

9 Comentarios

  1. 58

    Tratar este punto de Vista. Es posible que desee ajustar para sus necesidades específicas, sino que se dibuja un hexágono de la máscara con un borde en la parte superior de una vista. El fondo de recursos va debajo de la máscara.

    El resultado:

    Cómo dar forma hexagonal para ImageView

    El código:

    HexagonMaskView.java

    import android.content.Context;
    import android.graphics.Canvas;
    import android.graphics.Color;
    import android.graphics.Path;
    import android.graphics.Region;
    import android.util.AttributeSet;
    import android.view.View;
    public class HexagonMaskView extends View {
    private Path hexagonPath;
    private Path hexagonBorderPath;
    private float radius;
    private float width, height;
    private int maskColor;
    public HexagonMaskView(Context context) {
    super(context);
    init();
    }
    public HexagonMaskView(Context context, AttributeSet attrs) {
    super(context, attrs);
    init();
    }
    public HexagonMaskView(Context context, AttributeSet attrs, int defStyleAttr) {
    super(context, attrs, defStyleAttr);
    init();
    }
    private void init() {
    hexagonPath = new Path();
    hexagonBorderPath = new Path();
    maskColor = 0xFF01FF77;
    }
    public void setRadius(float r) {
    this.radius = r;
    calculatePath();
    }
    public void setMaskColor(int color) {
    this.maskColor = color;
    invalidate();
    }
    private void calculatePath() {
    float triangleHeight = (float) (Math.sqrt(3) * radius / 2);
    float centerX = width/2;
    float centerY = height/2;
    hexagonPath.moveTo(centerX, centerY + radius);
    hexagonPath.lineTo(centerX - triangleHeight, centerY + radius/2);
    hexagonPath.lineTo(centerX - triangleHeight, centerY - radius/2);
    hexagonPath.lineTo(centerX, centerY - radius);
    hexagonPath.lineTo(centerX + triangleHeight, centerY - radius/2);
    hexagonPath.lineTo(centerX + triangleHeight, centerY + radius/2);
    hexagonPath.moveTo(centerX, centerY + radius);
    float radiusBorder = radius - 5;    
    float triangleBorderHeight = (float) (Math.sqrt(3) * radiusBorder / 2);
    hexagonBorderPath.moveTo(centerX, centerY + radiusBorder);
    hexagonBorderPath.lineTo(centerX - triangleBorderHeight, centerY + radiusBorder/2);
    hexagonBorderPath.lineTo(centerX - triangleBorderHeight, centerY - radiusBorder/2);
    hexagonBorderPath.lineTo(centerX, centerY - radiusBorder);
    hexagonBorderPath.lineTo(centerX + triangleBorderHeight, centerY - radiusBorder/2);
    hexagonBorderPath.lineTo(centerX + triangleBorderHeight, centerY + radiusBorder/2);
    hexagonBorderPath.moveTo(centerX, centerY + radiusBorder);
    invalidate();
    }
    @Override
    public void onDraw(Canvas c){
    super.onDraw(c);
    c.clipPath(hexagonBorderPath, Region.Op.DIFFERENCE);
    c.drawColor(Color.WHITE);
    c.save();
    c.clipPath(hexagonPath, Region.Op.DIFFERENCE);
    c.drawColor(maskColor);
    c.save();
    }
    //getting the view size and default radius
    @Override
    public void onMeasure(int widthMeasureSpec, int heightMeasureSpec){
    super.onMeasure(widthMeasureSpec, heightMeasureSpec);
    width = MeasureSpec.getSize(widthMeasureSpec);
    height =  MeasureSpec.getSize(heightMeasureSpec);
    radius = height / 2 - 10;
    calculatePath();
    }
    }

    Actualización 29.07.2016

    Una mejor manera a sólo clip de la fuente de la imagen sin la pintura de la vista completa del fondo. Cambió a un ImageView como clase base para beneficio de la scaleType. Yo también hice algo de código de refactorización.

    import android.content.Context;
    import android.graphics.Canvas;
    import android.graphics.Color;
    import android.graphics.Paint;
    import android.graphics.Path;
    import android.graphics.PorterDuff;
    import android.graphics.Region;
    import android.util.AttributeSet;
    import android.widget.ImageView;
    public class HexagonMaskView extends ImageView {
    private Path hexagonPath;
    private Path hexagonBorderPath;
    private Paint mBorderPaint;
    public HexagonMaskView(Context context) {
    super(context);
    init();
    }
    public HexagonMaskView(Context context, AttributeSet attrs) {
    super(context, attrs);
    init();
    }
    public HexagonMaskView(Context context, AttributeSet attrs, int defStyleAttr) {
    super(context, attrs, defStyleAttr);
    init();
    }
    private void init() {
    this.hexagonPath = new Path();
    this.hexagonBorderPath = new Path();
    this.mBorderPaint = new Paint();
    this.mBorderPaint.setColor(Color.WHITE);
    this.mBorderPaint.setStrokeCap(Paint.Cap.ROUND);
    this.mBorderPaint.setStrokeWidth(50f);
    this.mBorderPaint.setStyle(Paint.Style.STROKE);
    }
    public void setRadius(float radius) {
    calculatePath(radius);
    }
    public void setBorderColor(int color) {
    this.mBorderPaint.setColor(color);
    invalidate();
    }
    private void calculatePath(float radius) {
    float halfRadius = radius / 2f;
    float triangleHeight = (float) (Math.sqrt(3.0) * halfRadius);
    float centerX = getMeasuredWidth() / 2f;
    float centerY = getMeasuredHeight() / 2f;
    this.hexagonPath.reset();
    this.hexagonPath.moveTo(centerX, centerY + radius);
    this.hexagonPath.lineTo(centerX - triangleHeight, centerY + halfRadius);
    this.hexagonPath.lineTo(centerX - triangleHeight, centerY - halfRadius);
    this.hexagonPath.lineTo(centerX, centerY - radius);
    this.hexagonPath.lineTo(centerX + triangleHeight, centerY - halfRadius);
    this.hexagonPath.lineTo(centerX + triangleHeight, centerY + halfRadius);
    this.hexagonPath.close();
    float radiusBorder = radius - 5f;
    float halfRadiusBorder = radiusBorder / 2f;
    float triangleBorderHeight = (float) (Math.sqrt(3.0) * halfRadiusBorder);
    this.hexagonBorderPath.reset();
    this.hexagonBorderPath.moveTo(centerX, centerY + radiusBorder);
    this.hexagonBorderPath.lineTo(centerX - triangleBorderHeight, centerY + halfRadiusBorder);
    this.hexagonBorderPath.lineTo(centerX - triangleBorderHeight, centerY - halfRadiusBorder);
    this.hexagonBorderPath.lineTo(centerX, centerY - radiusBorder);
    this.hexagonBorderPath.lineTo(centerX + triangleBorderHeight, centerY - halfRadiusBorder);
    this.hexagonBorderPath.lineTo(centerX + triangleBorderHeight, centerY + halfRadiusBorder);
    this.hexagonBorderPath.close();
    invalidate();
    }
    @Override
    public void onDraw(Canvas c) {
    c.drawPath(hexagonBorderPath, mBorderPaint);
    c.clipPath(hexagonPath, Region.Op.INTERSECT);
    c.drawColor(Color.TRANSPARENT, PorterDuff.Mode.CLEAR);
    super.onDraw(c);
    }
    @Override
    public void onMeasure(int widthMeasureSpec, int heightMeasureSpec){
    super.onMeasure(widthMeasureSpec, heightMeasureSpec);
    int width = MeasureSpec.getSize(widthMeasureSpec);
    int height = MeasureSpec.getSize(heightMeasureSpec);
    setMeasuredDimension(width, height);
    calculatePath(Math.min(width / 2f, height / 2f) - 10f);
    }
    }

    Ejemplo de diseño:

    <?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"
    android:paddingBottom="@dimen/activity_vertical_margin"
    android:paddingLeft="@dimen/activity_horizontal_margin"
    android:paddingRight="@dimen/activity_horizontal_margin"
    android:paddingTop="@dimen/activity_vertical_margin"
    android:background="@android:color/holo_green_dark">
    <com.scelus.hexagonmaskimproved.HexagonMaskView
    android:id="@+id/image"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:src="@drawable/bear"
    android:background="@android:color/holo_green_light"/>
    </RelativeLayout>

    Cómo dar forma hexagonal para ImageView

    • Gracias. Bonita respuesta, hice lo que puede para aumentar tu puntuación !
    • Cómo llamar a este en el ImageView ? Estoy usando ImageLoader para la carga de la imagen,Puede usted por favor me ayude.
    • Cómo llamar a este en el ImageView ? Estoy usando ImageLoader para la carga de la imagen,Puede usted por favor me ayude.
    • Me estoy poniendo un fondo verde fuera del hexágono, ¿cómo puedo eliminarlo?
    • hay una manera de quitar la región fuera del borde blanco ? Estoy asumiendo que la región es el color de la máscara, pero si se quita el color de la máscara, las cosas se ponen difíciles. Alguna idea sobre la eliminación de la fuera de la región ?
    • su venida a pantalla completa. Si desea reducir el tamaño, que no está funcionando.
    • es allí cualquier manera de tener una radio en la esquina? y hay alguna forma de sombra para el hexagonal de la imagen?
    • hey.. esta solución no funciona en el nivel de la API de 24
    • por favor alguien ayuda 🙁
    • este.mBorderPaint.setColor(Color.TRANSPARENTE);
    • cómo cambiar la parte inferior de la mitad de la frontera de color
    • Gracias budy guardar mi día a día.

  2. 7

    Aquí está mi código de trabajo para esto, se apoya en las sombras:

    import android.annotation.SuppressLint;
    import android.content.Context;
    import android.graphics.Bitmap;
    import android.graphics.BitmapShader;
    import android.graphics.Canvas;
    import android.graphics.Color;
    import android.graphics.Paint;
    import android.graphics.Path;
    import android.graphics.PorterDuff;
    import android.graphics.Shader;
    import android.graphics.drawable.BitmapDrawable;
    import android.util.AttributeSet;
    import android.widget.ImageView;
    public class HexagonImageView extends ImageView {
    private Path hexagonPath;
    private Path hexagonBorderPath;
    private float radius;
    private Bitmap image;
    private int viewWidth;
    private int viewHeight;
    private Paint paint;
    private BitmapShader shader;
    private Paint paintBorder;
    private int borderWidth = 4;
    public HexagonImageView(Context context) {
    super(context);
    setup();
    }
    public HexagonImageView(Context context, AttributeSet attrs) {
    super(context, attrs);
    setup();
    }
    public HexagonImageView(Context context, AttributeSet attrs, int defStyleAttr) {
    super(context, attrs, defStyleAttr);
    setup();
    }
    private void setup() {
    paint = new Paint();
    paint.setAntiAlias(true);
    paintBorder = new Paint();
    setBorderColor(Color.WHITE);
    paintBorder.setAntiAlias(true);
    this.setLayerType(LAYER_TYPE_SOFTWARE, paintBorder);
    paintBorder.setShadowLayer(4.0f, 1.0f, 1.0f, Color.BLACK);
    hexagonPath = new Path();
    hexagonBorderPath = new Path();
    }
    public void setRadius(float r) {
    this.radius = r;
    calculatePath();
    }
    public void setBorderWidth(int borderWidth)  {
    this.borderWidth = borderWidth;
    this.invalidate();
    }
    public void setBorderColor(int borderColor)  {
    if (paintBorder != null)
    paintBorder.setColor(borderColor);
    this.invalidate();
    }
    private void calculatePath() {
    float triangleHeight = (float) (Math.sqrt(3) * radius / 2);
    float centerX = viewWidth/2;
    float centerY = viewHeight/2;
    hexagonBorderPath.moveTo(centerX, centerY + radius);
    hexagonBorderPath.lineTo(centerX - triangleHeight, centerY + radius/2);
    hexagonBorderPath.lineTo(centerX - triangleHeight, centerY - radius/2);
    hexagonBorderPath.lineTo(centerX, centerY - radius);
    hexagonBorderPath.lineTo(centerX + triangleHeight, centerY - radius/2);
    hexagonBorderPath.lineTo(centerX + triangleHeight, centerY + radius/2);
    hexagonBorderPath.moveTo(centerX, centerY + radius);
    float radiusBorder = radius - borderWidth;    
    float triangleBorderHeight = (float) (Math.sqrt(3) * radiusBorder / 2);
    hexagonPath.moveTo(centerX, centerY + radiusBorder);
    hexagonPath.lineTo(centerX - triangleBorderHeight, centerY + radiusBorder/2);
    hexagonPath.lineTo(centerX - triangleBorderHeight, centerY - radiusBorder/2);
    hexagonPath.lineTo(centerX, centerY - radiusBorder);
    hexagonPath.lineTo(centerX + triangleBorderHeight, centerY - radiusBorder/2);
    hexagonPath.lineTo(centerX + triangleBorderHeight, centerY + radiusBorder/2);
    hexagonPath.moveTo(centerX, centerY + radiusBorder);
    invalidate();
    }
    private void loadBitmap()  {
    BitmapDrawable bitmapDrawable = (BitmapDrawable) this.getDrawable();
    if (bitmapDrawable != null)
    image = bitmapDrawable.getBitmap();
    }
    @SuppressLint("DrawAllocation")
    @Override
    public void onDraw(Canvas canvas){
    super.onDraw(canvas);
    loadBitmap();
    //init shader
    if (image != null) {
    canvas.drawColor(Color.TRANSPARENT, PorterDuff.Mode.CLEAR);
    shader = new BitmapShader(Bitmap.createScaledBitmap(image, canvas.getWidth(), canvas.getHeight(), false), Shader.TileMode.CLAMP, Shader.TileMode.CLAMP);
    paint.setShader(shader);
    canvas.drawPath(hexagonBorderPath, paintBorder);
    canvas.drawPath(hexagonPath, paint);
    }
    }
    @Override
    public void onMeasure(int widthMeasureSpec, int heightMeasureSpec){
    super.onMeasure(widthMeasureSpec, heightMeasureSpec);
    int width = measureWidth(widthMeasureSpec);
    int height = measureHeight(heightMeasureSpec, widthMeasureSpec);
    viewWidth = width - (borderWidth * 2);
    viewHeight = height - (borderWidth * 2);
    radius = height / 2 - borderWidth;
    calculatePath();
    setMeasuredDimension(width, height);
    }
    private int measureWidth(int measureSpec)   {
    int result = 0;
    int specMode = MeasureSpec.getMode(measureSpec);
    int specSize = MeasureSpec.getSize(measureSpec);
    if (specMode == MeasureSpec.EXACTLY)  {
    result = specSize;
    }
    else {
    result = viewWidth;
    }
    return result;
    }
    private int measureHeight(int measureSpecHeight, int measureSpecWidth)  {
    int result = 0;
    int specMode = MeasureSpec.getMode(measureSpecHeight);
    int specSize = MeasureSpec.getSize(measureSpecHeight);
    if (specMode == MeasureSpec.EXACTLY) {
    result = specSize;
    }
    else {
    result = viewHeight;
    }
    return (result + 2);
    }
    }
    • El suyo es un trabajo mejor respuesta que la aceptación de uno
  3. 4

    Hay un par de cosas que usted puede intentar:

    • Es posible que desee probar el dibujo de un 9patch en la parte superior de la imagen.

    • También hay este breve tuto por Romain Guy : http://www.curious-creature.org/2012/12/11/android-recipe-1-image-with-rounded-corners/

      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);

      Lugar de utilizar drawRoundRect() método de lienzo, se puede intentar el uso de drawPath() para obtener la forma deseada.

      Espero que esto te pone en la dirección correcta.

    • Sí lo he leído, pero ya no pude lograr de forma Hexagonal de imageview que por lo que pidió aquí
  4. 4

    Ver este ejemplo que es la creación de triángulo, de modo que usted puede conseguir lógica de ella 🙂

    http://looksok.wordpress.com/2013/08/24/android-triangle-arrow-defined-as-an-xml-shape/

    Otra solución que he encontrado pero no a la prueba para probar este también

    @Override
    public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.main);
    TextView tv = (TextView) findViewById(R.id.text);
    Path path = new Path();
    float stdW = 100;
    float stdH = 100;
    float w3 = stdW / 3;
    float h2 = stdH / 2;
    path.moveTo(0, h2);
    h2 -= 6 / 2;
    path.rLineTo(w3, -h2);         path.rLineTo(w3, 0); path.rLineTo(w3, h2);
    path.rLineTo(-w3, h2); path.rLineTo(-w3, 0); path.rLineTo(-w3, -h2);
    Shape s = new PathShape(path, stdW, stdH);
    ShapeDrawable d = new ShapeDrawable(s);
    Paint p = d.getPaint();
    p.setColor(0xffeeeeee);
    p.setStyle(Style.STROKE);
    p.setStrokeWidth(6);
    tv.setBackgroundDrawable(d);
    } 

    Fuente: Grupo de Google

    Tercera solución – Esto podría ser útil para la biblioteca

    PathDrawable es una Imagen que dibuja figuras simples con la Ruta de acceso del objeto.

    • He intentado la solución, es dibujar el hexágono ruta de acceso como el uso que el enfoque anterior. Quiero hacer la forma de imageview para hexágono, de modo que cualquier imagen pondré establecería como en el hexágono en el que
    • hey ver este codebybrian.com/2013/07/28/custom_view_regular_polygons.html puede ayuda
    • Lo he visto ya, también basta con dibujar el hexágono en el imageview pero quiero darles forma de imageview a hexagon
  5. 3

    Su Tarde para relpy.. Pero Espero que ayude a alguien…

      public Bitmap getHexagonShape(Bitmap scaleBitmapImage) {
    //TODO Auto-generated method stub
    int targetWidth = 200;
    int targetHeight =200;
    Bitmap targetBitmap = Bitmap.createBitmap(targetWidth, 
    targetHeight,Bitmap.Config.ARGB_8888);
    Canvas canvas = new Canvas(targetBitmap);
    Path path = new Path();
    float stdW = 200;
    float stdH = 200;
    float w3 =stdW / 2;
    float h2 = stdH / 2;
    float radius=stdH/2-10;
    float triangleHeight = (float) (Math.sqrt(3) * radius / 2);
    float centerX = stdW/2;
    float centerY = stdH/2;
    path.moveTo(centerX, centerY + radius);
    path.lineTo(centerX - triangleHeight, centerY + radius/2);
    path.lineTo(centerX - triangleHeight, centerY - radius/2);
    path.lineTo(centerX, centerY - radius);
    path.lineTo(centerX + triangleHeight, centerY - radius/2);
    path.lineTo(centerX + triangleHeight, centerY + radius/2);
    path.moveTo(centerX, centerY + radius);
    canvas.clipPath(path);
    Bitmap sourceBitmap = scaleBitmapImage;
    canvas.drawBitmap(sourceBitmap, 
    new Rect(0, 0, sourceBitmap.getWidth(),
    sourceBitmap.getHeight()), 
    new Rect(0, 0, targetWidth,
    targetHeight), null);
    return targetBitmap;
    }
    public static Bitmap drawableToBitmap (Drawable drawable) {
    if (drawable instanceof BitmapDrawable) {
    return ((BitmapDrawable)drawable).getBitmap();
    }
    Bitmap bitmap = Bitmap.createBitmap(drawable.getIntrinsicWidth(), drawable.getIntrinsicHeight(), Config.ARGB_8888);
    Canvas canvas = new Canvas(bitmap); 
    drawable.setBounds(0, 0, canvas.getWidth(), canvas.getHeight());
    drawable.draw(canvas);
    return bitmap;
    }

    Llamar a este donde desea utilizar

        Drawable drawable = getResources().getDrawable( R.drawable.placeholder );        
    Bitmap b=getHexagonShape(drawableToBitmap(drawable));
    img=(ImageView)findViewById(R.id.imageView);
    img.setImageBitmap(b);
  6. 1

    La función lee una imagen de mapa de bits de entrada y devuelve un mapa de bits que es hexagonal en forma

    public Bitmap getHexagonShape(Bitmap scaleBitmapImage) {
    //TODO Auto-generated method stub
    int targetWidth = 600;
    int targetHeight = 600;
    Bitmap targetBitmap = Bitmap.createBitmap(targetWidth, 
    targetHeight,Bitmap.Config.ARGB_8888);
    Canvas canvas = new Canvas(targetBitmap);
    Path path = new Path();
    float stdW = 300;
    float stdH = 300;
    float w3 =stdW / 2;
    float h2 = stdH / 2;
    path.moveTo(0, (float) (h2*Math.sqrt(3)/2));
    path.rLineTo(w3/2, -(float) (h2*Math.sqrt(3)/2)); path.rLineTo(w3, 0);   path.rLineTo(w3/2, (float) (h2*Math.sqrt(3)/2));
    path.rLineTo(-w3/2, (float) (h2*Math.sqrt(3)/2)); path.rLineTo(-w3, 0); path.rLineTo(-w3/2, -(float) (h2*Math.sqrt(3)/2));
    canvas.clipPath(path);
    Bitmap sourceBitmap = scaleBitmapImage;
    canvas.drawBitmap(sourceBitmap, 
    new Rect(0, 0, sourceBitmap.getWidth(),
    sourceBitmap.getHeight()), 
    new Rect(0, 0, targetWidth,
    targetHeight), null);
    return targetBitmap;
    }
    • Gracias .. el Código que ME ayude..:)
    • Gracias, pero su parcial hexágono en potraite y su paisaje lleno de hexágono
  7. 1

    No sé si el OP tiene la respuesta que estaba buscando, pero aquí va.

    He de crear una vista personalizada, que se extiende ImageView, que hará el trabajo para usted un poco mejor.
    La respuesta aquí sólo crea un mak en el interior de la ImageView y te obliga a establecer la imagen como fondo

    Mi punto de vista le permite establecer la imagen como un mapa de bits estándar, se encarga de CenterCrop y el escalado de la imagen.
    Lo que realmente establece la máscara fuera de lugar, y con la misma frontera de más de sombra.

    Y si eso no es suficiente, usted puede fácilmente crear formas personalizadas para representar, sólo sería la ampliación de la RenderShape de clase. (4 formas están incluidas en la biblioteca: Círculo, Triángulo, Hexágono y Octógono)

    Tener una mirada en mi github

    Saludos

  8. 1

    He resuelto usando este código:

        private Bitmap getHexagoneCroppedBitmap(Bitmap bitmap, int radius) {
    Bitmap finalBitmap;
    if (bitmap.getWidth() != radius || bitmap.getHeight() != radius)
    finalBitmap = Bitmap.createScaledBitmap(bitmap, radius, radius,
    false);
    else
    finalBitmap = bitmap;
    Bitmap output = Bitmap.createBitmap(finalBitmap.getWidth(),
    finalBitmap.getHeight(), Config.ARGB_8888);
    Canvas canvas = new Canvas(output);
    Paint paint = new Paint();
    final Rect rect = new Rect(0, 0, finalBitmap.getWidth(),
    finalBitmap.getHeight());
    Point point1_draw = new Point(75, 0);
    Point point2_draw = new Point(0, 50);
    Point point3_draw = new Point(0, 100);
    Point point4_draw = new Point(75, 150);
    Point point5_draw = new Point(150, 100);
    Point point6_draw = new Point(150, 50);
    Path path = new Path();
    path.moveTo(point1_draw.x, point1_draw.y);
    path.lineTo(point2_draw.x, point2_draw.y);
    path.lineTo(point3_draw.x, point3_draw.y);
    path.lineTo(point4_draw.x, point4_draw.y);
    path.lineTo(point5_draw.x, point5_draw.y);
    path.lineTo(point6_draw.x, point6_draw.y);
    path.close();
    canvas.drawARGB(0, 0, 0, 0);
    paint.setColor(Color.parseColor("#BAB399"));
    canvas.drawPath(path, paint);
    paint.setXfermode(new PorterDuffXfermode(Mode.SRC_IN));
    canvas.drawBitmap(finalBitmap, rect, rect, paint);
    return output;
    }
  9. 1

    Puede utilizar el Android de Forma ImageView por siamed.

    https://github.com/siyamed/android-shape-imageview

    <com.github.siyamed.shapeimageview.HexagonImageView
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:layout_margin="8dp"
    android:src="@drawable/neo"
    app:siBorderWidth="8dp"
    app:siBorderColor="@color/darkgray"/>

    Por favor, lea la documentación en github, un montón de opciones disponibles.

Dejar respuesta

Please enter your comment!
Please enter your name here