精华内容
下载资源
问答
  • RoundedCorners roundedCorners = new RoundedCorners(10); RequestOptions options = RequestOptions.bitmapTransform(roundedCorners).override(300, 300); Glide.with(Latte.getApplication())...

    首先导入 Glide。具体依赖可以百度

      RoundedCorners roundedCorners = new RoundedCorners(10);
            RequestOptions options = RequestOptions.bitmapTransform(roundedCorners).override(300, 300);
            Glide.with(Latte.getApplication())
                    .load("https://img02.sogoucdn.com/app/a/100520021/41778307d3291ab01cb5db13fe3af3e0")
                    .apply(options)
                    .listener(new RequestListener<Drawable>() {
                        @Override
                        public boolean onLoadFailed(@Nullable GlideException e, Object model, Target<Drawable> target, boolean isFirstResource) {
                            return false;
                        }
    
                        @RequiresApi(api = Build.VERSION_CODES.JELLY_BEAN)
                        @Override
                        public boolean onResourceReady(Drawable resource, Object model, Target<Drawable> target, DataSource dataSource, boolean isFirstResource) {
                            getActivity().runOnUiThread(() -> mImageview.setBackground(resource));
                            return false;
                        }
                    })
                    .submit();
    

    注意回调方法中是子线程,需要在主线程更新 ui

    展开全文
  • Android 用Glide设置图片4个角为圆角

    万次阅读 热门讨论 2018-07-05 15:05:22
    * 除了那几个角不需要圆角的 * * @param leftTop * @param rightTop * @param leftBottom * @param rightBottom */ public void setExceptCorner(boolean leftTop, boolean rightTop, boolean leftBottom, ...

    依赖: compile 'com.github.bumptech.glide:glide:3.8.0'//加载图片依赖       根据你们的实际情况选择依赖版本

    xml布局:
     
    <ImageView
        android:id="@+id/iv_img_shop"
        android:layout_width="120dp"
        android:layout_height="80dp"
        android:scaleType="centerCrop"
        android:src="@drawable/background4" />
     

     

    工具类:

     

     
    public class CornerTransform implements Transformation<Bitmap> {
        private BitmapPool mBitmapPool;
    
        private float radius;
    
        private boolean exceptLeftTop, exceptRightTop, exceptLeftBottom, exceptRightBotoom;
    
        /**
         * 除了那几个角不需要圆角的
         *
         * @param leftTop
         * @param rightTop
         * @param leftBottom
         * @param rightBottom
         */
        public void setExceptCorner(boolean leftTop, boolean rightTop, boolean leftBottom, boolean rightBottom) {
            this.exceptLeftTop = leftTop;
            this.exceptRightTop = rightTop;
            this.exceptLeftBottom = leftBottom;
            this.exceptRightBotoom = rightBottom;
        }
    
        public CornerTransform(Context context, float radius) {
            this.mBitmapPool = Glide.get(context).getBitmapPool();
            this.radius = radius;
        }
    
        @Override
        public Resource<Bitmap> transform(Resource<Bitmap> resource, int outWidth, int outHeight) {
            Bitmap source = resource.get();
            int finalWidth, finalHeight;
            float ratio; //输出目标的宽高或高宽比例
            if (outWidth > outHeight) { //输出宽度>输出高度,求高宽比
                ratio = (float) outHeight / (float) outWidth;
                finalWidth = source.getWidth();
                finalHeight = (int) ((float) source.getWidth() * ratio); //固定原图宽度,求最终高度
                if (finalHeight > source.getHeight()) { //求出的最终高度>原图高度,求宽高比
                    ratio = (float) outWidth / (float) outHeight;
                    finalHeight = source.getHeight();
                    finalWidth = (int) ((float) source.getHeight() * ratio);//固定原图高度,求最终宽度
                }
            } else if (outWidth < outHeight) { //输出宽度 < 输出高度,求宽高比
                ratio = (float) outWidth / (float) outHeight;
                finalHeight = source.getHeight();
                finalWidth = (int) ((float) source.getHeight() * ratio);//固定原图高度,求最终宽度
                if (finalWidth > source.getWidth()) { //求出的最终宽度 > 原图宽度,求高宽比
                    ratio = (float) outHeight / (float) outWidth;
                    finalWidth = source.getWidth();
                    finalHeight = (int) ((float) source.getWidth() * ratio);
                }
            } else { //输出宽度=输出高度
                finalHeight = source.getHeight();
                finalWidth = finalHeight;
            }
    
            //修正圆角
            this.radius *= (float) finalHeight / (float) outHeight;
            Bitmap outBitmap = this.mBitmapPool.get(finalWidth, finalHeight, Bitmap.Config.ARGB_8888);
            if (outBitmap == null) {
                outBitmap = Bitmap.createBitmap(finalWidth, finalHeight, Bitmap.Config.ARGB_8888);
            }
    
            Canvas canvas = new Canvas(outBitmap);
            Paint paint = new Paint();
            //关联画笔绘制的原图bitmap
            BitmapShader shader = new BitmapShader(source, Shader.TileMode.CLAMP, Shader.TileMode.CLAMP);
            //计算中心位置,进行偏移
            int width = (source.getWidth() - finalWidth) / 2;
            int height = (source.getHeight() - finalHeight) / 2;
            if (width != 0 || height != 0) {
                Matrix matrix = new Matrix();
                matrix.setTranslate((float) (-width), (float) (-height));
                shader.setLocalMatrix(matrix);
            }
    
            paint.setShader(shader);
            paint.setAntiAlias(true);
            RectF rectF = new RectF(0.0F, 0.0F, (float) canvas.getWidth(), (float) canvas.getHeight());
            canvas.drawRoundRect(rectF, this.radius, this.radius, paint); //先绘制圆角矩形
    
            if (exceptLeftTop) { //左上角不为圆角
                canvas.drawRect(0, 0, radius, radius, paint);
            }
            if (exceptRightTop) {//右上角不为圆角
                canvas.drawRect(canvas.getWidth() - radius, 0, radius, radius, paint);
            }
    
            if (exceptLeftBottom) {//左下角不为圆角
                canvas.drawRect(0, canvas.getHeight() - radius, radius, canvas.getHeight(), paint);
            }
    
            if (exceptRightBotoom) {//右下角不为圆角
                canvas.drawRect(canvas.getWidth() - radius, canvas.getHeight() - radius, canvas.getWidth(), canvas.getHeight(), paint);
            }
    
            return BitmapResource.obtain(outBitmap, this.mBitmapPool);
        }
    
        @Override
        public String getId() {
            return this.getClass().getName();
        }
    }
     
     

     

     

    在activity或Fragment或适配器中调用:
    CornerTransform transformation = new CornerTransform(context, dip2px(context, 10));
    //只是绘制左上角和右上角圆角
    transformation.setExceptCorner(false, false, false, false);
    
    Glide.with(context)
            .load(HttpContants.URL + list.get(position).getImage())
            .asBitmap()
            .skipMemoryCache(true)
            .placeholder(R.drawable.background4)
            .error(R.drawable.background4)
            .transform(transformation)
            .into(holder.ivImgShop);
     
    还有一个方法:
    public static int dip2px(Context context, float dpValue) {
        final float scale = context.getResources().getDisplayMetrics().density;
        return (int) (dpValue * scale + 0.5f);
    }

     

     

     
    特别注意:设置4个角为圆角的方法
     
     

     

    注意:注释只看红色字体的,代码中的备注是我当时复制的时候带的,我修改代码后没有改注释,只可参考。

    参考资料:https://blog.csdn.net/mchenys/article/details/80284132
    多种形状资料链接:https://github.com/wasabeef/glide-transformations(没看过)
    展开全文
  • Android自定义圆角圆形图片

    千次阅读 2018-03-07 11:44:01
    说起Android里面的自定义圆角圆形图片,已经算是老生常谈的话题了,之前一直使用别人的,最近使用的时候发现自己居然没有一这样属于自己的工具库,实在遗憾,毕竟还是自己的东西用起来最顺手,所以就打造了一,...

    转载请注明出处:http://blog.csdn.net/binbinqq86/article/details/79463977

    说起Android里面的自定义圆角圆形图片,已经算是老生常谈的话题了,之前一直使用别人的,最近使用的时候发现自己居然没有一个这样属于自己的工具库,实在遗憾,毕竟还是自己的东西用起来最顺手,所以就打造了一个,先来看看效果:
    这里写图片描述
    怎么样,还不错吧~支持各种图案,边框,各种圆角。其中原理也是很简单的,无非就是canvas知识的应用。接下来我们一个一个形状来看,首先是圆形,这个应该是最简单的了,直接使用canvas的drawCircle来绘制一个圆形就搞定了,看代码:

    float r = hasBorder ? width / 2f - borderWidth : width / 2f;
    canvas.drawCircle(width / 2f, height / 2f, r, mPaintDrawable);

    其中的r就是圆的半径,这里我们用一个变量hasBorder 来区分是否绘制边框(边框后面细说),drawCircle的前两个参数就是圆心坐标,最后一个参数则是画笔,我们的图片呢???确定这样就能画出来圆形图片???其实图片被我们封装在笔刷里面了:BitmapShader。这个类的使用很简单,官方文档是这样解释的:

    Shader used to draw a bitmap as a texture.
    

    就是使用特定的图片来作为纹理使用。这里就不再详细解释这个类的使用了,不懂的同学可以参考文章最后的链接。其实除了使用BitmapShader还有另外一种方案,就是PorterDuffXfermode,感兴趣的可以参考我之前的一篇文章:http://blog.csdn.net/binbinqq86/article/details/78329238,里面讲述了另外一种实现圆形图片的方案。

    下面来看一下获取Bitmap的方法:

    /**
         * 获取imageview设置的图片(针对大图,此时必须已经处理过了,否则会造成内存溢出)
         * <p>
         * 获取bitmap:
         * 1、如果设置了src为图片则返回该图片,
         * 2、如果设置了src为颜色值则返回颜色值,
         * 3、如果没有设置src,则返回默认颜色值(未设置则为透明)
         *
         * @param drawable
         * @return
         */
        private Bitmap getBitmap(Drawable drawable) {
            Bitmap bitmap = null;
            if (drawable instanceof BitmapDrawable) {
                bitmap = ((BitmapDrawable) drawable).getBitmap();
            } else if (drawable instanceof ColorDrawable) {
                bitmap = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888);
                Canvas c = new Canvas(bitmap);
                int color = ((ColorDrawable) drawable).getColor();
                c.drawARGB(Color.alpha(color), Color.red(color), Color.green(color), Color.blue(color));
            } else {
                bitmap = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888);
                Canvas c = new Canvas(bitmap);
                c.drawARGB(Color.alpha(defaultColor), Color.red(defaultColor), Color.green(defaultColor), Color.blue(defaultColor));
            }
            if (isBlur) {
                //高斯模糊
                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1) {
                    try {
                        bitmap = RSBlur.blur(getContext(), bitmap, (int) blurRadius);
                    } catch (Exception e) {
                        bitmap = FastBlur.blur(bitmap, (int) blurRadius, true);
                    }
                } else {
                    bitmap = FastBlur.blur(bitmap, (int) blurRadius, true);
                }
            }
            return bitmap;
        }

    这里就是获取imageview设置的图片,然后就可以随意绘制我们想要的效果了,这里我们取图片的中间区域进行绘制,可以防止图片跟视图大小不一样(前提是我们已经根据imageView的宽高去缩放过图片了,这里处理的只是绘制部分,类似imageView的centerCrop),看代码:

    /**
         * 处理图片大于或者小于控件的情况
         * (不是针对大图内存溢出的处理,此处的处理只是为了让图片居中绘制——centerCrop:参照imageView的处理)
         *
         * @param bitmap
         */
        private void setUpShader(Bitmap bitmap) {
            mBitmapShader = new BitmapShader(bitmap, Shader.TileMode.CLAMP, Shader.TileMode.CLAMP);
    
            int dWidth = bitmap.getWidth();
            int dHeight = bitmap.getHeight();
    
            int vWidth = width;
            int vHeight = height;
            if (hasBorder) {
                vWidth -= 2 * borderWidth;
                vHeight -= 2 * borderWidth;
            }
            if (dWidth == vWidth && dHeight == vHeight) {
    
            } else {
                float scale = 1.0f;
                float dx = 0, dy = 0;
    
                if (dWidth * vHeight > vWidth * dHeight) {
                    scale = (float) vHeight / (float) dHeight;
                    dx = (vWidth - dWidth * scale) * 0.5f;
                } else {
                    scale = (float) vWidth / (float) dWidth;
                    dy = (vHeight - dHeight * scale) * 0.5f;
                }
    
                mMatrix.setScale(scale, scale);
                if (hasBorder) {//有边框的情况,view视图缩小了,所以需要对图片移动一个边框宽度的处理
                    dx += borderWidth;
                    dy += borderWidth;
                }
                //上一个缩放操作完成之后,进行移动(把图片中心与视图中心对应,这样保证图片居中,而原来图片是左上角对应视图左上角),与pre对应
    
                mMatrix.postTranslate(dx, dy);
    
                mBitmapShader.setLocalMatrix(mMatrix);
            }
    
            mPaintDrawable.setShader(mBitmapShader);
        }

    里面的主要逻辑就是用matrix去设置BitmapShader的缩放效果,这里我们参照的是imageView的源码:

        private void configureBounds() {
            if (mDrawable == null || !mHaveFrame) {
                return;
            }
    
            final int dwidth = mDrawableWidth;
            final int dheight = mDrawableHeight;
    
            final int vwidth = getWidth() - mPaddingLeft - mPaddingRight;
            final int vheight = getHeight() - mPaddingTop - mPaddingBottom;
    
            final boolean fits = (dwidth < 0 || vwidth == dwidth)
                    && (dheight < 0 || vheight == dheight);
    
            if (dwidth <= 0 || dheight <= 0 || ScaleType.FIT_XY == mScaleType) {
                /* If the drawable has no intrinsic size, or we're told to
                    scaletofit, then we just fill our entire view.
                */
                mDrawable.setBounds(0, 0, vwidth, vheight);
                mDrawMatrix = null;
            } else {
                // We need to do the scaling ourself, so have the drawable
                // use its native size.
                mDrawable.setBounds(0, 0, dwidth, dheight);
    
                if (ScaleType.MATRIX == mScaleType) {
                    // Use the specified matrix as-is.
                    //省略...
                } else if (fits) {
                    // The bitmap fits exactly, no transform needed.
                    mDrawMatrix = null;
                } else if (ScaleType.CENTER == mScaleType) {
                    // Center bitmap in view, no scaling.
                    //省略...
                } else if (ScaleType.CENTER_CROP == mScaleType) {
                    mDrawMatrix = mMatrix;
    
                    float scale;
                    float dx = 0, dy = 0;
    
                    if (dwidth * vheight > vwidth * dheight) {
                        scale = (float) vheight / (float) dheight;
                        dx = (vwidth - dwidth * scale) * 0.5f;
                    } else {
                        scale = (float) vwidth / (float) dwidth;
                        dy = (vheight - dheight * scale) * 0.5f;
                    }
    
                    mDrawMatrix.setScale(scale, scale);
                    mDrawMatrix.postTranslate(Math.round(dx), Math.round(dy));
                } else if (ScaleType.CENTER_INSIDE == mScaleType) {
    
                    //省略...
                } else {
                    // Generate the required transform.
    
                    //省略...scaleTypeToScaleToFit(mScaleType));
                }
            }
        }

    矩阵的变换可以参考文章最后的链接,矩阵post,pre,set我在上面的注释也写了,基本上就是set为直接变换,pre和post分别是变换之前和变换之后再进行后续的变换。

    至此,bitmap的准备工作就完成了,我们就可以调用canvas的drawCircle来绘制圆形图片了。上面提到了边框的绘制,这里我们就来说一下,其实原理是一样的,无非就是把画笔paint设置为STOKE模式,并且在计算Rect的四个点的坐标的时候边框和内容要注意一下,可以把边框设置为半透明模式,看看图片是否绘制到边框下面了,如果两者边缘正好贴合,则说明半径或者矩形计算的正确,否则就是计算有误。另外一点就是图片的画笔和边框的最好区分开来,这样各司其职,否则就比较混乱。边框的绘制还有一点需要注意的就是,它的半径是圆心到边框宽度的中间,而不是边缘,因为是空心的。

    下面就是圆角图片了,这个则是调用canvas的drawRoundRect方法,首先第一个参数就是一个矩形,他是圆角的外接矩形,然后就是圆角的x,y半径了,最后一个参数是画笔。圆角的情况一共可以分为15种,四个角全部是圆的,另外就是单个圆角的组合,这里我才用了枚举类型:

     /**
         * 圆角的类型
         * 顺时针1234四个角,四个角可分为1,2,3,4,12,13,14,23,24,34,123,124,134,234,1234十五种情况
         */
        public enum CornerType {
            ALL,
            TOP_LEFT, TOP_RIGHT, BOTTOM_RIGHT, BOTTOM_LEFT,
            TOP_LEFT_TOP_RIGHT, TOP_LEFT_BOTTOM_RIGHT, TOP_LEFT_BOTTOM_LEFT,
            TOP_RIGHT_BOTTOM_RIGHT, TOP_RIGHT_BOTTOM_LEFT, BOTTOM_RIGHT_BOTTOM_LEFT,
            TOP_LEFT_TOP_RIGHT_BOTTOM_RIGHT, TOP_LEFT_TOP_RIGHT_BOTTOM_LEFT, TOP_LEFT_BOTTOM_RIGHT_BOTTOM_LEFT, TOP_RIGHT_BOTTOM_RIGHT_BOTTOM_LEFT
        }

    而这些参数都可以在xml属性中配置,也可以通过代码去set具体的type。下面是具体绘制代码:

                    case ALL:
                        if (hasBorder) {
                            //Math.ceil进位来保证不留白,扩大一点绘制区域
                            RectF rf = new RectF(borderWidth, borderWidth, (float) Math.ceil(width - borderWidth), (float) Math.ceil(height - borderWidth));
    
                            canvas.drawRoundRect(rf, cr, cr, mPaintDrawable);
                        } else {
                            RectF rf = new RectF(0, 0, width, height);
                            //corner为圆心到边缘的距离
                            canvas.drawRoundRect(rf, cornerRadius, cornerRadius, mPaintDrawable);
                        }
                        break;
                    case TOP_LEFT:
                        //分块绘制,也可以采用path来绘制
                        if (hasBorder) {
    //                        path.reset();
    //                        path.moveTo(borderWidth,borderWidth+cr+borderWidth);
    //                        path.addArc(new RectF(borderWidth, borderWidth, cr * 2f + borderWidth, cr * 2f + borderWidth), 180, 90);
    //                        path.lineTo(width-borderWidth,borderWidth);
    //                        path.lineTo(width-borderWidth,height-borderWidth);
    //                        path.lineTo(borderWidth,height-borderWidth);
    //                        path.close();
    //                        canvas.drawPath(path,mPaintDrawable);
    
    //                        canvas.drawRoundRect(new RectF(borderWidth, borderWidth, cr * 2f+borderWidth, cr * 2f+borderWidth),cr,cr,mPaintDrawable);
                            canvas.drawArc(new RectF(borderWidth, borderWidth, cornerRadius * 2f - borderWidth, cr * 2f + borderWidth), 180, 90, true, mPaintDrawable);
                            canvas.drawRect(new RectF(borderWidth, cornerRadius, cornerRadius, height - borderWidth), mPaintDrawable);
                            canvas.drawRect(new RectF(cornerRadius, borderWidth, width - borderWidth, height - borderWidth), mPaintDrawable);
                        } else {
                            //drawRoundRect也可以,不过多绘制了一部分圆
                            canvas.drawRoundRect(new RectF(0, 0, cornerRadius * 2f, cornerRadius * 2f), cornerRadius, cornerRadius, mPaintDrawable);
                            canvas.drawRect(new RectF(0, cornerRadius, cornerRadius, height), mPaintDrawable);
                            canvas.drawRect(new RectF(cornerRadius, 0, width, height), mPaintDrawable);
                        }
                        break;

    这里我只列举了两个情况:全部圆角和左上角圆角,可以看到我们绘制的方案可以多种,单个圆角组合的情况其实就是把图片拆分为不同区块,然后连接起来去绘制,原理就是这么简单!既然可以用path去绘制各种各样的图形,那么我们是不是可以绘制一些特殊形状呢,比如五角星,小熊,三角形,五边形,六边形。。。等等,自己可以随意去扩展了,这里我用了一个OtherType来表示特殊形状:

    /**
         * 其他类型,如五角星,小熊,六边形等等不规则的
         */
        public enum OtherType {
            STAR, BEAR, HEXAGON
        }

    具体使用的时候可以自己根据具体情况去扩展。这里我只列出了六边形:

    path.reset();
    path.moveTo(width * 0.25f, 0);
    path.lineTo(width * 0.75f, 0);
    path.lineTo(width, height * 0.5f);
    path.lineTo(width * 0.75f, height);
    path.lineTo(width * 0.25f, height);
    path.lineTo(0, height * 0.5f);
    path.close();
    canvas.drawPath(path, mPaintDrawable);

    可以看到用到了一些数学知识,尤其是当你画五角星的时候,这些特殊形状基本上都是数学知识的运用和path的api的基本使用。

    最后就是状态的保存与恢复了,防止我们的自定义view出现异常,核心思想就是保存我们设置的属性,然后在恢复的时候去重新绘制就可以恢复销毁之前的原状了。

    @Nullable
        @Override
        protected Parcelable onSaveInstanceState() {
            super.onSaveInstanceState();
            //状态保存
            Bundle bundle = new Bundle();
            bundle.putBoolean("hasBorder", hasBorder);
            bundle.putBoolean("isCircle", isCircle);
            bundle.putBoolean("isBlur", isBlur);
            bundle.putBoolean("isOval", isOval);
    
            bundle.putFloat("cornerRadius", cornerRadius);
            bundle.putFloat("borderWidth", borderWidth);
            bundle.putFloat("blurRadius", blurRadius);
    
            bundle.putInt("borderColor", borderColor);
            bundle.putInt("defaultColor", defaultColor);
    
            bundle.putSerializable("otherType", otherType);
            bundle.putSerializable("cornerType", cornerType);
            return bundle;
        }
    
        @Override
        protected void onRestoreInstanceState(Parcelable state) {
            super.onRestoreInstanceState(state);
            //状态恢复
            if (state instanceof Bundle) {
                Bundle bundle = (Bundle) state;
                setHasBorder(bundle.getBoolean("hasBorder"));
                setCircle(bundle.getBoolean("isCircle"));
                setBlur(bundle.getBoolean("isBlur"));
                setOval(bundle.getBoolean("isOval"));
    
                setCornerRadius(bundle.getFloat("cornerRadius"));
                setBorderWidth(bundle.getFloat("borderWidth"));
                setBlurRadius(bundle.getFloat("blurRadius"));
    
                setBorderColor(bundle.getInt("borderColor"));
                setDefaultColor(bundle.getInt("defaultColor"));
    
                setOtherType((OtherType) bundle.getSerializable("otherType"));
                setCornerType((CornerType) bundle.getSerializable("cornerType"));
            }
            reDraw();
        }

    最后就是自定义属性了:

    <declare-styleable name="baselib_BaseImageView">
            <!--其他一切不规则图案-->
            <attr name="baselib_other_type">
                <enum name="STAR" value="1"/>
                <enum name="BEAR" value="2"/>
                <enum name="HEXAGON" value="3"/>
            </attr>
            <!--顺时针1234四个角,四个角可分为1,2,3,4,12,13,14,23,24,34,123,124,134,234,1234十五种情况-->
            <attr name="baselib_corner_type">
                <enum name="ALL" value="1234"/>
                <enum name="TOP_LEFT" value="1"/>
                <enum name="TOP_RIGHT" value="2"/>
                <enum name="BOTTOM_RIGHT" value="3"/>
                <enum name="BOTTOM_LEFT" value="4"/>
                <enum name="TOP_LEFT_TOP_RIGHT" value="12"/>
                <enum name="TOP_LEFT_BOTTOM_RIGHT" value="13"/>
                <enum name="TOP_LEFT_BOTTOM_LEFT" value="14"/>
                <enum name="TOP_RIGHT_BOTTOM_RIGHT" value="23"/>
                <enum name="TOP_RIGHT_BOTTOM_LEFT" value="24"/>
                <enum name="BOTTOM_RIGHT_BOTTOM_LEFT" value="34"/>
                <enum name="TOP_LEFT_TOP_RIGHT_BOTTOM_RIGHT" value="123"/>
                <enum name="TOP_LEFT_TOP_RIGHT_BOTTOM_LEFT" value="124"/>
                <enum name="TOP_LEFT_BOTTOM_RIGHT_BOTTOM_LEFT" value="134"/>
                <enum name="TOP_RIGHT_BOTTOM_RIGHT_BOTTOM_LEFT" value="234"/>
            </attr>
            <!--椭圆-->
            <attr name="baselib_is_oval" format="boolean"/>
            <!--是否是圆形图片-->
            <attr name="baselib_is_circle" format="boolean"/>
    
            <!--=====================上面是互斥的属性,下面的可以与上面的共存=====================-->
            <!--是否带边框-->
            <attr name="baselib_has_border" format="boolean"/>
            <!--边框颜色-->
            <attr name="baselib_border_color" format="color|reference"/>
            <!--边框宽度-->
            <attr name="baselib_border_width" format="dimension"/>
            <!--圆角的度数(代表所有角,不再单独针对部分圆角的情况提供某一个角的度数)-->
            <attr name="baselib_corner_radius" format="dimension"/>
            <!--是否高斯模糊-->
            <attr name="baselib_is_blur" format="boolean"/>
            <!--高斯模糊半径-->
            <attr name="baselib_blur_radius" format="float"/>
            <!--当图片为空的时候,默认颜色-->
            <attr name="baselib_default_color" format="color|reference"/>
        </declare-styleable>

    所有属性都可以通过代码set和get,而且可以自己扩展,相信这个imageview基本上满足日常开发了,最后如果使用glide加载图片的话,在getBitmap方法里面需要加上一种情况:

    else if (drawable instanceof GlideBitmapDrawable) {
                bitmap = ((GlideBitmapDrawable) drawable).getBitmap();
            } 

    到此整个imageview就讲解完了,老规矩,有疑问的同学可以在下方留言,最后放出源码:

    源码下载

    参考:

    展开全文
  • android中对Bitmap图片设置任意为圆角

    最近项目开发中使用到了圆角图片,网上找到的圆角图片控件大多比较死板,只可以全圆角。其中感觉最好的也就是半圆角 链接在这里。想了一下,我自己在这个的基础上进行了一点改进,使得图片可以设置任意角为圆角。

    先上效果图:


    核心代码

    package fillet.sgn.com.filletimage;
    
    import android.graphics.Bitmap;
    import android.graphics.Canvas;
    import android.graphics.Color;
    import android.graphics.Paint;
    import android.graphics.PorterDuff;
    import android.graphics.PorterDuffXfermode;
    import android.graphics.Rect;
    import android.graphics.RectF;
    
    /**
     * Created by liujinhua on 15/9/7.
     */
    public class BitmapFillet {
    
        public static final int CORNER_NONE = 0;
        public static final int CORNER_TOP_LEFT = 1;
        public static final int CORNER_TOP_RIGHT = 1 << 1;
        public static final int CORNER_BOTTOM_LEFT = 1 << 2;
        public static final int CORNER_BOTTOM_RIGHT = 1 << 3;
        public static final int CORNER_ALL = CORNER_TOP_LEFT | CORNER_TOP_RIGHT | CORNER_BOTTOM_LEFT | CORNER_BOTTOM_RIGHT;
        public static final int CORNER_TOP = CORNER_TOP_LEFT | CORNER_TOP_RIGHT;
        public static final int CORNER_BOTTOM = CORNER_BOTTOM_LEFT | CORNER_BOTTOM_RIGHT;
        public static final int CORNER_LEFT = CORNER_TOP_LEFT | CORNER_BOTTOM_LEFT;
        public static final int CORNER_RIGHT = CORNER_TOP_RIGHT | CORNER_BOTTOM_RIGHT;
    
    
    
        public static Bitmap fillet(Bitmap bitmap, int roundPx,int corners) {
            try {
                // 其原理就是:先建立一个与图片大小相同的透明的Bitmap画板
                // 然后在画板上画出一个想要的形状的区域。
                // 最后把源图片帖上。
                final int width = bitmap.getWidth();
                final int height = bitmap.getHeight();
    
                Bitmap paintingBoard = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888);
                Canvas canvas = new Canvas(paintingBoard);
                canvas.drawARGB(Color.TRANSPARENT, Color.TRANSPARENT, Color.TRANSPARENT, Color.TRANSPARENT);
    
                final Paint paint = new Paint();
                paint.setAntiAlias(true);
                paint.setColor(Color.BLACK);
    
                //画出4个圆角
                final RectF rectF = new RectF(0, 0, width, height);
                canvas.drawRoundRect(rectF, roundPx, roundPx, paint);
    
                //把不需要的圆角去掉
                int notRoundedCorners = corners ^ CORNER_ALL;
                if ((notRoundedCorners & CORNER_TOP_LEFT) != 0) {
                    clipTopLeft(canvas,paint,roundPx,width,height);
                }
                if ((notRoundedCorners & CORNER_TOP_RIGHT) != 0) {
                    clipTopRight(canvas, paint, roundPx, width, height);
                }
                if ((notRoundedCorners & CORNER_BOTTOM_LEFT) != 0) {
                    clipBottomLeft(canvas,paint,roundPx,width,height);
                }
                if ((notRoundedCorners & CORNER_BOTTOM_RIGHT) != 0) {
                    clipBottomRight(canvas, paint, roundPx, width, height);
                }
                paint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.SRC_IN));
    
                //帖子图
                final Rect src = new Rect(0, 0, width, height);
                final Rect dst = src;
                canvas.drawBitmap(bitmap, src, dst, paint);
                return paintingBoard;
            } catch (Exception exp) {
                return bitmap;
            }
        }
    
        private static void clipTopLeft(final Canvas canvas, final Paint paint, int offset, int width, int height) {
            final Rect block = new Rect(0, 0, offset, offset);
            canvas.drawRect(block, paint);
        }
    
        private static void clipTopRight(final Canvas canvas, final Paint paint, int offset, int width, int height) {
            final Rect block = new Rect(width - offset, 0, width, offset);
            canvas.drawRect(block, paint);
        }
    
        private static void clipBottomLeft(final Canvas canvas, final Paint paint, int offset, int width, int height) {
            final Rect block = new Rect(0, height - offset, offset, height);
            canvas.drawRect(block, paint);
        }
    
        private static void clipBottomRight(final Canvas canvas, final Paint paint, int offset, int width, int height) {
            final Rect block = new Rect(width - offset, height - offset, width, height);
            canvas.drawRect(block, paint);
        }
    }


    这是源代码

    展开全文
  • PHP将图片处理成圆角

    千次阅读 2015-10-27 15:27:42
    上一篇文章,我说了关于php吧文字画在图片上的换行方法,这篇说说项目中图片圆角的处理 我们可能在很多项目中,需要对图片进行圆角处理,例如HTML5中,例如Android中; 这里我们说说用PHP对图片进行圆角处理...
  • 透明圆角化背景图片

    千次阅读 2012-06-20 09:32:58
    就是将背景图片也圆化,好像目前在网络上还没有这样的功能应用,我只见过用js方式来实现的,可以参看我的《超圆滑圆角框的半完美解决方案》一文中后面几种JS方案。但是纯CSS方式的实现可是我独家所创,如有雷同,...
  • 刚做一应用,UI设计的效果是需要在Android中用已有的图片画出一矩形图形,并且要在图形上写不同的字样。 参考了上面的博文,制定的实现思路如下: 1、创建一drawable对象,一输出的Bitmap并以此创建一...
  • android设置控件样式(边框颜色,圆角)和图片样式(圆角) 设置布局的背景为 圆角边框: &lt;?xml version="1.0" encoding="utf-8"?&gt; &lt;shape xmlns:android="...
  • 在开发中,添加圆角似乎再常见不过了。不过它带来的性能问题以及离屏渲染问题,也受到部分开发者的注意。 如何才能在不影响性能的前提下添加圆角呢?...通过 UIGraphicsBeginImageContextWithOptions()创建一 Ima...
  • 就是这种效果,边框四个角有这直角的,这是我之前做的一项目里面,用的是css的clip,但是一伪元素只能做一直角,所需就需要四伪元素即两元素,于是我添加了一冗余的元素。现在的页面有很多这种框,...
  • //分别设置左上、右上、左下、右下的圆角半径 .setRoundingParams(RoundingParams.fromCornersRadii( 20 , 25 , 30 , 35 )) //设置圆形圆角参数;RoundingParams.asCircle()是将图像设置成圆形 //....
  • CSS3圆角、盒阴影与边框图片

    千次阅读 2016-11-14 17:14:00
    今天开始整理CSS3的知识 其实应该是昨晚写的,不过好像是急性肠胃炎了,痛的一晚上没睡着,蓝瘦香菇 ...不同浏览器有不同前缀的私有属性,表示属性或规则还没有成为标准 换句话说,官方还没公布标准的时候,各个
  • 表示未读消息数以及在以及在某条信息右上标志小圆形,表示这条消息是未读的状态等等,之前对此内容不熟悉的时候也表示困扰,现在对图片一些操作也写在一工具类中,以方便调用。 按照惯例先来看一下最终效果图: ...
  • //避免Transformation重复设置,导致图片闪烁,同一圆角值的Transformation视为同一对象 return Util.hashCode(getId().hashCode(), Util.hashCode(this.radius)); } private String getId() { return this....
  • 我主要从三方面进行讲述,首先如何通过assets加载透明Png图片,然后是讲述两种方法图片合成和添加相框.最后讲述图像圆角和圆形矩阵显示的效果,文中有详细解释和源码,希望文章对大家有所帮助,如果有错误或不足之处请...
  • 图片角点快速检测算法FAST(翻译)

    千次阅读 2018-05-04 12:09:09
    原始论文链接:Features from Accelerated Segment Test (FAST)多论文对比:Faster and better: a machine learning approach to corner detection1.介绍:FAST是一种由Rosten和Drummond提出的用于检测图片特征点...
  •  背景是css中一重要的的部分,也是需要知道的css的基础知识之一。这里主要介绍有关背景图片的5种常见属性,分别是: (1)、background-color: 指定填充背景的颜色。 (2)、background-image: 引用图片作为...
  • css实现4个角有边框

    千次阅读 2019-10-14 17:00:27
    项目中 很多地方用到,所以抽出来作为一组件 opacity 控制背景的透明度。 this.props.children 渲染其他子元素。 import react from 'react'; import styles from './index.less'; export default ...
  • UIView *view = [[UIView alloc] initWithFrame:CGRectMake(120, 10, 80, 80)]; view.backgroundColor = [UIColor redColor]; [self.view addSubview:view]; UIBezierPath *maskPath = [UIBezierPath
  • Python处理图片需要另外安装 PIL (Python Image Library)库,即 pillow,请自行百度安装。以下代码为Python 3.7 代码。 1. 字符串格式化输出 # 依次打开 1.jpg 到 10.jpg from PIL import I...
  • 关于CSS打造斜角,先说一下历史,在CSS+DIV流行以前,也就是用表格作为网页框架的时候,人们通过在一单元格里加入一斜角图片来来做这种效果的。这种技术现在已经完全过时了,这里不讨论。CSS+DIV兴起以后,出现...
  • CSS3 边界图片详解 border-image-source 属性: 指定要使用的图像。 属性: border-image-source: 指定要使用的图像。 border-image -slice: 指定图像的边界向内偏移 border-image -width:指定图像边界的宽度 ...
  • 第二参数,OutputArray类型的dst,函数调用后的运算结果存在这里,即这参数用于存放Harris点检测的输出结果,和源图片有一样的尺寸和类型。 第三参数,int类型的blockSize,表示邻域的大小,更多的详细信息...
  • // 创建一个相同大小的画布 Paint paint = new Paint();// 定义画笔 paint.setAntiAlias(true);// 设置抗锯齿 paint.setFilterBitmap(true); paint.setDither(true); canvas.drawARGB(0, 0, 0, 0); if ...
  • CSS3的出现,使得我们再也不必浪费时间去制作这些图片了,而且还有其他多优点:* 减少维护的工作量。图片文件的生成、更新、编写网页代码,这些工作都不再需要了。* 提高网页性能。由于不必再发出多余的HTTP请求,...
  • import cv2 import numpy as np ...img=cv2.imread('timg.jpg') #原图为彩色图,可将第二参数变为0,为灰度图 gray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY) gray = np.float32(gray) dst = cv...
  • 为了调试算法方便我用一64*32(像素)的矩形表示tile图片,用这矩形的内接菱形来表示实际被显示出来的tile菱形像素块,因为我建立的程序窗口式640*480,所以只假设游戏世界的大菱形是由10 * 10个tile组成的,也...
  • 超简单的自定义ImageView,支持圆角和直角

    万次阅读 热门讨论 2018-01-25 15:19:25
    1、需求:ImageView显示的图片,上方的两个角是圆角,下方的两个角是直角。 2、这篇文章推荐了三种方式,我选择第三种ClipPath方式,这种方式很精简。 参考:https://www.jianshu.com/p/626dbd93207d 3、先来...
  • 1:因为图中的矩形框是用不同颜色框出来的,我们可以把每一颜色的所有矩形框提取出来,变成二值图像(只有黑色和白 色)。求出此颜色的每矩形的信息。 2:如果按颜色分出来的矩形框只有一,就可以用[x,y]=...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 120,874
精华内容 48,349
关键字:

十个不同的角图片