精华内容
下载资源
问答
  • 图片,很显然这是一个扇形图,相信大家对做扇形图得心应手,可能对做扇形动画有一定难度,不急,下面给出代码和思路。 针对项目用的扇形动画,在这个基础上我做了一下封装。 核心代码如下: -(instancetype)...
  • c#雷达扫描 圆和扇形的背景都有 不用图片都是graphic 可以设置线圈 角度等 非常好用 c#雷达扫描 圆和扇形的背景都有 不用图片都是graphic 可以设置线圈 角度等 非常好用
  • , int nPoints) 3、圆弧 / 扇形: // 绘制一个圆弧(弧线) void drawArc(int x, int y, int width, int height, int startAngle, int arcAngle) // 填充一个圆弧(扇形) void fillArc(int x, int y, int width, int...

    本文链接: https://blog.csdn.net/xietansheng/article/details/55669157

    Java Swing 图形界面开发(目录)

    1. Graphics 绘图画布

    Graphics 类相当于一个画布,每个 Swing 组件都通过 Graphics 对象来绘制显示。绘图的原点位于组件的左上角,如下图所示:

    Graphics坐标

    Graphics类中常用的绘制相关方法:

    ○ 参数 / 设置:

    // 创建 Graphics 的副本
    Graphics create()
    // 回收 Graphics
    void dispose()
    
    // 设置画笔颜色
    void setColor(Color c)
    // 擦除某一区域(擦除后显示背景色)
    void clearRect(int x, int y, int width, int height)
    

    1、线段 / 折线:

    // 绘制一条线段(如果两点为同一点,则绘制点)
    void drawLine(int x1, int y1, int x2, int y2)
    // 根据给定的多个点坐标绘制折线
    void drawPolyline(int xPoints[], int yPoints[], int nPoints)
    

    2、矩形 / 多边形:

    // 绘制一个矩形(空心)
    void drawRect(int x, int y, int width, int height)
    // 填充一个矩形(实心)
    void fillRect(int x, int y, int width, int height)
    
    // 绘制一个圆角矩形
    void drawRoundRect(int x, int y, int width, int height, int arcWidth, int arcHeight)
    // 填充一个圆角矩形
    void fillRoundRect(int x, int y, int width, int height, int arcWidth, int arcHeight)
    
    // 绘制一个3D矩形
    void draw3DRect(int x, int y, int width, int height, boolean raised)
    // 填充一个3D矩形
    void fill3DRect(int x, int y, int width, int height, boolean raised)
    
    // 根据给定的多个点坐标绘制一个多边形(首尾相连)
    void drawPolygon(int xPoints[], int yPoints[], int nPoints)
    // 根据给定的多个点坐标填充一个多边形(首尾相连)
    void fillPolygon(int xPoints[], int yPoints[], int nPoints)
    

    3、圆弧 / 扇形:

    // 绘制一个圆弧(弧线)
    void drawArc(int x, int y, int width, int height, int startAngle, int arcAngle)
    // 填充一个圆弧(扇形)
    void fillArc(int x, int y, int width, int height, int startAngle, int arcAngle)
    

    4、椭圆:

    // 绘制一个椭圆
    void drawOval(int x, int y, int width, int height)
    // 填充一个椭圆
    void fillOval(int x, int y, int width, int height)
    

    5、图片

    /*
     * 先读取图片
     */
    // 方法一: 通过 java.awt.Toolkit 工具类来读取本地、网络 或 内存中 的 图片(支持 GIF、JPEG 或 PNG)
    Image image = Toolkit.getDefaultToolkit().getImage(String filename);
    Image image = Toolkit.getDefaultToolkit().getImage(URL url);
    Image image = Toolkit.getDefaultToolkit().createImage(byte[] imageData);
    
    // 方法二: 通过 javax.imageio.ImageIO 工具类读取本地、网络 或 内存中 的 图片(BufferedImage 继承自 Image)
    BufferedImage bufImage = ImageIO.read(File input);
    BufferedImage bufImage = ImageIO.read(URL input);
    BufferedImage bufImage = ImageIO.read(InputStream input);
    
    /*
     * PS_01: 图片宽高: BufferedImage 可以通过 bufImage.getWidth() 和 bufImage.getHeight() 方法直接获取图片的宽高;
     *                 Image 获取宽高需要另外传入一个 ImageObserver 参数。
     *
     * PS_02: 图片裁剪: BufferedImage 通过 bufImage.getSubimage(int x, int y, int w, int h) 方法可以截取图片的
     *                 任意一部分,返回一个新的 BufferedImage 实例。
     *
     * PS_03: 图片缩放: Image 通过 image.getScaledInstance(int width, int height, int hints) 方法可以对图片进行
     *                 缩放,返回新的一个 Image 实例。
     */
    
    // 绘制一张图片(所有组件类实现了 ImageObserver 接口,即组件实例即为 ImageObserver)
    boolean drawImage(Image image, int x, int y, int width, int height, ImageObserver observer)
    

    6、文本

    // 设置字体(字体、样式、大小)
    void setFont(Font font)
    // 绘制一段文本,其中 (x, y) 坐标指的是文本序列的 左下角 的位置
    void drawString(String str, int x, int y)
    

    2. Graphics2D

    在 Swing 组件的实际绘制中通常使用的是 Graphics 的一个子类 Graphics2D, 该类中提供了更为丰富的接口来绘制更为复杂的需求。

    Graphics2D类中的部分方法:

    1、参数 / 设置

    // 设置背景(擦除后显示该背景)
    void setBackground(Color color)
    // 设置笔画的轮廓特性(如画笔宽度、实线、虚线等)
    void setStroke(Stroke s)
    

    2、绘制结果的变换

    // 平移
    void translate(int x, int y)
    // 旋转
    void rotate(double theta, double originX, double originY)
    // 缩放
    void scale(double sx, double sy)
    
    // 将图片经过指定变换后绘制显示
    boolean drawImage(Image image, AffineTransform xform, ImageObserver obs)
    

    3. 自定义组件, 绘图演示

    package com.xiets.drawdemo;
    
    import javax.swing.*;
    import java.awt.*;
    
    public class Main {
    
        public static void main(String[] args) {
            /*
             * 在 AWT 的事件队列线程中创建窗口和组件, 确保线程安全,
             * 即 组件创建、绘制、事件响应 需要处于同一线程。
             */
            EventQueue.invokeLater(new Runnable() {
                @Override
                public void run() {
                    // 创建窗口对象
                    MyFrame frame = new MyFrame();
                    // 显示窗口
                    frame.setVisible(true);
                }
            });
        }
    
        /**
         * 窗口
         */
        public static class MyFrame extends JFrame {
    
            public static final String TITLE = "Java图形绘制";
    
            public static final int WIDTH = 250;
            public static final int HEIGHT = 300;
    
            public MyFrame() {
                super();
                initFrame();
            }
    
            private void initFrame() {
                // 设置 窗口标题 和 窗口大小
                setTitle(TITLE);
                setSize(WIDTH, HEIGHT);
    
                // 设置窗口关闭按钮的默认操作(点击关闭时退出进程)
                setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
    
                // 把窗口位置设置到屏幕的中心
                setLocationRelativeTo(null);
    
                // 设置窗口的内容面板
                MyPanel panel = new MyPanel(this);
                setContentPane(panel);
            }
    
        }
    
        /**
         * 内容面板
         */
        public static class MyPanel extends JPanel {
    
            private MyFrame frame;
    
            public MyPanel(MyFrame frame) {
                super();
                this.frame = frame;
            }
    
            /**
             * 绘制面板的内容: 创建 JPanel 后会调用一次该方法绘制内容,
             * 之后如果数据改变需要重新绘制, 可调用 updateUI() 方法触发
             * 系统再次调用该方法绘制更新 JPanel 的内容。
             */
            @Override
            protected void paintComponent(Graphics g) {
                super.paintComponent(g);
    
                // 重新调用 Graphics 的绘制方法绘制时将自动擦除旧的内容
    
                /* 自行打开下面注释查看各绘制效果 */
    
                // 1. 线段 / 折线
                drawLine(g);
    
                // 2. 矩形 / 多边形
                // drawRect(g);
    
                // 3. 圆弧 / 扇形
                // drawArc(g);
    
                // 4. 椭圆
                // drawOval(g);
    
                // 5. 图片
                // drawImage(g);
    
                // 6. 文本
                // drawString(g);
            }
    
            /**
             * 1. 线段 / 折线
             */
            private void drawLine(Graphics g) {
                frame.setTitle("1. 线段 / 折线");
    
                // 创建 Graphics 的副本, 需要改变 Graphics 的参数,
                // 这里必须使用副本, 避免影响到 Graphics 原有的设置
                Graphics2D g2d = (Graphics2D) g.create();
    
                // 抗锯齿
                g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
                // 设置画笔颜色
                g2d.setColor(Color.RED);
    
                // 1. 两点绘制线段: 点(20, 50), 点(200, 50)
                g2d.drawLine(50, 50, 200, 50);
    
                // 2. 多点绘制折线: 点(50, 100), 点(100, 130), 点(150, 70), 点(200, 100)
                int[] xPoints = new int[] { 50, 100, 150, 200 };
                int[] yPoints = new int[] { 100, 120, 80, 100 };
                int nPoints = 4;
                g2d.drawPolyline(xPoints, yPoints, nPoints);
    
                // 3. 两点绘制线段(设置线宽为5px): 点(50, 150), 点(200, 150)
                BasicStroke bs1 = new BasicStroke(5);       // 笔画的轮廓(画笔宽度/线宽为5px)
                g2d.setStroke(bs1);
                g2d.drawLine(50, 150, 200, 150);
    
                // 4. 绘制虚线: 将虚线分为若干段( 实线段 和 空白段 都认为是一段), 实线段 和 空白段 交替绘制,
                //             绘制的每一段(包括 实线段 和 空白段)的 长度 从 dash 虚线模式数组中取值(从首
                //             元素开始循环取值), 下面数组即表示每段长度分别为: 5px, 10px, 5px, 10px, ...
                float[] dash = new float[] { 5, 10 };
                BasicStroke bs2 = new BasicStroke(
                        1,                      // 画笔宽度/线宽
                        BasicStroke.CAP_SQUARE,
                        BasicStroke.JOIN_MITER,
                        10.0f,
                        dash,                   // 虚线模式数组
                        0.0f
                );
                g2d.setStroke(bs2);
                g2d.drawLine(50, 200, 200, 200);
    
                // 自己创建的副本用完要销毁掉
                g2d.dispose();
            }
    
            /**
             * 2. 矩形 / 多边形
             */
            private void drawRect(Graphics g) {
                frame.setTitle("2. 矩形 / 多边形");
                Graphics2D g2d = (Graphics2D) g.create();
    
                g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
                g2d.setColor(Color.GRAY);
    
                // 1. 绘制一个矩形: 起点(30, 20), 宽80, 高100
                g2d.drawRect(30, 20, 80, 100);
    
                // 2. 填充一个矩形
                g2d.fillRect(140, 20, 80, 100);
    
                // 3. 绘制一个圆角矩形: 起点(30, 150), 宽80, 高100, 圆角宽30, 圆角高30
                g2d.drawRoundRect(30, 150, 80, 100, 30, 30);
    
                // 4. 绘制一个多边形(收尾相连): 点(140, 150), 点(180, 250), 点(220, 200)
                int[] xPoints = new int[] { 140, 180, 220};
                int[] yPoints = new int[] { 150,  250, 200};
                int nPoints = 3;
                g2d.drawPolygon(xPoints, yPoints, nPoints);
    
                g2d.dispose();
            }
    
            /**
             * 3. 圆弧 / 扇形
             */
            private void drawArc(Graphics g) {
                frame.setTitle("3. 圆弧 / 扇形");
                Graphics2D g2d = (Graphics2D) g.create();
    
                g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
                g2d.setColor(Color.RED);
    
                // 1. 绘制一条圆弧: 椭圆的外切矩形 左上角坐标为(0, 0), 宽100, 高100,
                //                弧的开始角度为0度, 需要绘制的角度数为-90度,
                //                椭圆右边水平线为0度, 逆时针为正角度, 顺时针为负角度
                g2d.drawArc(0, 0, 100, 100, 0, -90);
    
                // 2. 绘制一个圆: 圆的外切矩形 左上角坐标为(120, 20), 宽高为100
                g2d.drawArc(120, 20, 100, 100, 0, 360);
    
                g2d.setColor(Color.GRAY);
    
                // 3. 填充一个扇形
                g2d.fillArc(80, 150, 100, 100, 90, 270);
    
                g2d.dispose();
            }
    
            /**
             * 4. 椭圆 (实际上通过绘制360度的圆弧/扇形也能达到绘制圆/椭圆的效果)
             */
            private void drawOval(Graphics g) {
                frame.setTitle("4. 椭圆");
                Graphics2D g2d = (Graphics2D) g.create();
    
                g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
                g2d.setColor(Color.RED);
    
                // 1. 绘制一个圆: 圆的外切矩形 左上角坐标为(0, 0), 宽高为100
                g2d.drawOval(0, 0, 100, 100);
    
                g2d.setColor(Color.GRAY);
    
                // 2. 填充一个椭圆
                g2d.fillOval(120, 100, 100, 150);
    
                g2d.dispose();
            }
    
            /**
             * 5. 图片
             */
            private void drawImage(Graphics g) {
                frame.setTitle("5. 图片");
                Graphics2D g2d = (Graphics2D) g.create();
    
                // 从本地读取一张图片
                String filepath = "demo.jpg";
                Image image = Toolkit.getDefaultToolkit().getImage(filepath);
    
                // 绘制图片(如果宽高传的不是图片原本的宽高, 则图片将会适当缩放绘制)
                g2d.drawImage(image, 50, 50, image.getWidth(this), image.getHeight(this), this);
    
                g2d.dispose();
            }
    
            /**
             * 6. 文本
             */
            private void drawString(Graphics g) {
                frame.setTitle("6. 文本");
                Graphics2D g2d = (Graphics2D) g.create();
    
                g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
    
                // 设置字体样式, null 表示使用默认字体, Font.PLAIN 为普通样式, 大小为 25px
                g2d.setFont(new Font(null, Font.PLAIN, 25));
    
                // 绘制文本, 其中坐标参数指的是文本绘制后的 左下角 的位置
                // 首次绘制需要初始化字体, 可能需要较耗时
                g2d.drawString("Hello World!", 20, 60);
                g2d.drawString("你好, 世界!", 20, 120);
    
                g2d.dispose();
            }
    
        }
    
    }
    

    结果展示:

    result.png

    4. 把组件上绘制的内容保存为图片

    // import javax.imageio.ImageIO;
    // import java.awt.image.BufferedImage;
    
    // 获取到需要保存内容的组件(面板)
    JPanel panel = (JPanel) frame.getContentPane();
    
    // 创建一个与面板等宽高的缓存图片
    BufferedImage image = new BufferedImage(
            panel.getWidth(), 
            panel.getHeight(), 
            BufferedImage.TYPE_INT_ARGB
    );
    
    // 获取缓存图片的画布
    Graphics2D g2d = image.createGraphics();
    
    // 把面板的内容画到画布中
    panel.paint(g2d);
    
    try {
        // 把缓存图片保存到本地文件
        ImageIO.write(image, "png", new File("panel.png"));
    } catch (Exception e) {
        e.printStackTrace();
    }
    

    扩展: Java图片操作 — 图片的读取、绘制、缩放、裁剪、保存

    展开全文
  • 想做一个图片进度条以画扇形的方式从无到有显示出来,想请教一下具体的思路方法?求大神指导啊。。
  • css已经越来越强大了 ,可以使用它来绘制各种简单的形状,用于代替图片显示,这次的分享主要用到画圆,扇形,下面我们来看一下如何使用css画扇形。通过css画扇形:div{border-radius:80px 0 0;width: 80px;height: ...

    css已经越来越强大了 ,可以使用它来绘制各种简单的形状,用于代替图片显示,这次的分享主要用到画圆,扇形,下面我们来看一下如何使用css画扇形。

    a760d759005171a886766a7de43f8cac.png

    通过css画扇形:

    div{

    border-radius:80px 0 0;

    width: 80px;

    height: 80px;

    background: #666;

    }

    效果图:

    f9aabc30839053bb3e9333489ea33fb2.png

    实现原理:左上角是圆角,其余三个角都是直角:左上角的值为宽和高一样的值,其他三个角的值不变(等于0)。

    border-radius 属性是一个最多可指定四个 border -*- radius 属性的复合属性

    语法:border-radius: 1-4 length|% / 1-4 length|%;

    每个半径的四个值的顺序是:左上角,右上角,右下角,左下角。如果省略左下角,右上角是相同的。如果省略右下角,左上角是相同的。如果省略右上角,左上角是相同的。

    属性值:length 定义弯道的形状。

    % 使用%定义角落的形状。

    展开全文
  • 动画菜单、图标拖拽、图片滑动、自定义scrollview等模块处理--------3 项目框架说明图 习惯性的用eclipse,不知道是自己真的老了,还是eclipse打包出来的apk总是比AS小的原因,需要AS源码的朋友记得Q我哈,...

    项目初衷

    由于所在的公司比较注重项目安全性,所以在项目同步这块几乎没有涉足,乘工作之余敲一个简单的app,起名为EasyLive,目的于熟悉一些工作之外的有趣知识点和巩固自己的基础知识。

    项目内容

    以打造一款兼容性较为完整的android万能播放器为基础,后期再不断的添加一些生活中有趣的功能点,并不定期的将项目同步到github上,以供大家共同修改和指教。

    目录

    集成准备------------------------------------------------------------------------------1
    前端UI设计---------------------------------------------------------------------------2
    动画菜单、图标拖拽、图片滑动、自定义scrollview等模块处理--------3

    项目框架说明图

    习惯性的用eclipse,不知道是自己真的老了,还是eclipse打包出来的apk总是比AS小的原因,需要AS源码的朋友记得Q我哈,或者来个大神直接贡献到git上与我们一起分享(地址)。

     

    自定义scrollview实现滑动监听(伤陌1991

    package com.minghui.easyapp.scrollview;
    
    import android.content.Context;
    import android.util.AttributeSet;
    import android.widget.ScrollView;
    
    public class ObserveScrollView extends ScrollView {
    
    	private ScrollListener mListener;
    
    	public static interface ScrollListener {// 声明接口,用于传递数据
    		public void scrollOritention(int l, int t, int oldl, int oldt);
    	}
    
    	public ObserveScrollView(Context context, AttributeSet attrs, int defStyle) {
    		super(context, attrs, defStyle);
    		// TODO Auto-generated constructor stub
    	}
    
    	public ObserveScrollView(Context context, AttributeSet attrs) {
    		super(context, attrs);
    		// TODO Auto-generated constructor stub
    	}
    
    	public ObserveScrollView(Context context) {
    		super(context);
    		// TODO Auto-generated constructor stub
    	}
    
    	@Override
    	protected void onScrollChanged(int l, int t, int oldl, int oldt) {
    		// TODO Auto-generated method stub
    		super.onScrollChanged(l, t, oldl, oldt);
    		if (mListener != null) {
    			mListener.scrollOritention(l, t, oldl, oldt);
    		}
    	}
    
    	public void setScrollListener(ScrollListener l) {
    		this.mListener = l;
    	}
    
    }

    3D图片滑动倾斜放大倒影(大神连接

    //主要代码
    public boolean createReflectedImages() {
    		// The gap we want between the reflection and the original image
    		final int reflectionGap = 4;
    
    		int index = 0;
    		for (int imageId : mImageIds) {
    			Bitmap originalImage = BitmapFactory.decodeResource(
    					mContext.getResources(), imageId);
    			int width = originalImage.getWidth();
    			int height = originalImage.getHeight();
    			// This will not scale but will flip on the Y axis
    			Matrix matrix = new Matrix();
    			matrix.preScale(1, -1);
    
    			// Create a Bitmap with the flip matrix applied to it.
    			// We only want the bottom half of the image
    			Bitmap reflectionImage = Bitmap.createBitmap(originalImage, 0,
    					height / 2, width, height / 2, matrix, false);
    
    			// Create a new bitmap with same width but taller to fit
    			// reflection
    			Bitmap bitmapWithReflection = Bitmap.createBitmap(width,
    					(height + height / 2), Config.ARGB_8888);
    
    			// Create a new Canvas with the bitmap that's big enough for
    			// the image plus gap plus reflection
    			Canvas canvas = new Canvas(bitmapWithReflection);
    			// Draw in the original image
    			canvas.drawBitmap(originalImage, 0, 0, null);
    			// Draw in the gap
    			Paint deafaultPaint = new Paint();
    			canvas.drawRect(0, height, width, height + reflectionGap,
    					deafaultPaint);
    			// Draw in the reflection
    			canvas.drawBitmap(reflectionImage, 0, height + reflectionGap, null);
    
    			// Create a shader that is a linear gradient that covers the
    			// reflection
    			Paint paint = new Paint();
    			LinearGradient shader = new LinearGradient(0,
    					originalImage.getHeight(), 0,
    					bitmapWithReflection.getHeight() + reflectionGap,
    					0x70ffffff, 0x00ffffff, TileMode.CLAMP);
    			// Set the paint to use this shader (linear gradient)
    			paint.setShader(shader);
    			// Set the Transfer mode to be porter duff and destination in
    			paint.setXfermode(new PorterDuffXfermode(Mode.DST_IN));
    			// Draw a rectangle using the paint with our linear gradient
    			canvas.drawRect(0, height, width, bitmapWithReflection.getHeight()
    					+ reflectionGap, paint);
    
    			BitmapDrawable bd = new BitmapDrawable(bitmapWithReflection);
    			bd.setAntiAlias(true);
    
    			ImageView imageView = new ImageView(mContext);
    			// imageView.setImageBitmap(bitmapWithReflection);
    			imageView.setImageDrawable(bd);
    			imageView.setLayoutParams(new GalleryFlow.LayoutParams(280, 460));
    			imageView.setPadding(0, 40, 0, 0);
    			// imageView.setScaleType(ScaleType.MATRIX);
    			mImages[index++] = imageView;
    
    		}
    		return true;
    	}

    自由拖拽图标(龙旋

    package com.minghui.easyapp.dragview;
    
    import android.annotation.SuppressLint;
    import android.content.Context;
    import android.util.AttributeSet;
    import android.util.Log;
    import android.view.MotionEvent;
    import android.widget.ImageView;
    
    /**
     * 随意拖动的view
     */
    
    @SuppressLint("AppCompatCustomView")
    public class DragView extends ImageView {
    
    	private int width;
    	private int height;
    	private int screenWidth;
    	private int screenHeight;
    	private Context context;
    
    	// 是否拖动
    	private boolean isDrag = false;
    
    	public boolean isDrag() {
    		return isDrag;
    	}
    
    	public DragView(Context context, AttributeSet attrs) {
    		super(context, attrs);
    		this.context = context;
    	}
    
    	@Override
    	protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
    		super.onMeasure(widthMeasureSpec, heightMeasureSpec);
    		width = getMeasuredWidth();
    		height = getMeasuredHeight();
    		screenWidth = ScreenUtil.getScreenWidth(context);
    		screenHeight = ScreenUtil.getScreenHeight(context)
    				- getStatusBarHeight();
    
    	}
    
    	public int getStatusBarHeight() {
    		int resourceId = getResources().getIdentifier("status_bar_height",
    				"dimen", "android");
    		return getResources().getDimensionPixelSize(resourceId);
    	}
    
    	private float downX;
    	private float downY;
    
    	@Override
    	public boolean onTouchEvent(MotionEvent event) {
    		super.onTouchEvent(event);
    		if (this.isEnabled()) {
    			switch (event.getAction()) {
    			case MotionEvent.ACTION_DOWN:
    				isDrag = false;
    				downX = event.getX();
    				downY = event.getY();
    				break;
    			case MotionEvent.ACTION_MOVE:
    				Log.e("kid", "ACTION_MOVE");
    				final float xDistance = event.getX() - downX;
    				final float yDistance = event.getY() - downY;
    				int l,
    				r,
    				t,
    				b;
    				// 当水平或者垂直滑动距离大于10,才算拖动事件
    				if (Math.abs(xDistance) > 10 || Math.abs(yDistance) > 10) {
    					Log.e("kid", "Drag");
    					isDrag = true;
    					l = (int) (getLeft() + xDistance);
    					r = l + width;
    					t = (int) (getTop() + yDistance);
    					b = t + height;
    					// 不划出边界判断,此处应按照项目实际情况,因为本项目需求移动的位置是手机全屏,
    					// 所以才能这么写,如果是固定区域,要得到父控件的宽高位置后再做处理
    					if (l < 0) {
    						l = 0;
    						r = l + width;
    					} else if (r > screenWidth) {
    						r = screenWidth;
    						l = r - width;
    					}
    					if (t < 0) {
    						t = 0;
    						b = t + height;
    					} else if (b > screenHeight) {
    						b = screenHeight;
    						t = b - height;
    					}
    
    					this.layout(l, t, r, b);
    				}
    				break;
    			case MotionEvent.ACTION_UP:
    				setPressed(false);
    				break;
    			case MotionEvent.ACTION_CANCEL:
    				setPressed(false);
    				break;
    			}
    			return true;
    		}
    		return false;
    	}
    
    }

    形动画菜单(洒家卖蘑菇

    package com.minghui.easyapp.utils;
    
    import android.animation.AnimatorSet;
    import android.animation.ObjectAnimator;
    import android.view.View;
    import android.view.animation.BounceInterpolator;
    
    public class NvaAnimator {
    	/**
    	 * 打开菜单 view:动画控件 index:第几个控件 num:有几个控件 radius:扇形半径
    	 */
    	public static void openAnim(View view, int index, int num, int radius,
    			boolean isRadians) {
    		if (view.getVisibility() != View.VISIBLE) {
    			view.setVisibility(View.VISIBLE);
    		}
    		final int translationX;
    		final int translationY;
    		if (isRadians) {
    			double angle = Math.toRadians(180) / (num - 1) * index;
    			translationX = -(int) (radius * Math.cos(angle));
    			translationY = -(int) (radius * Math.sin(angle));
    		} else {
    			translationX = index * 80 + 20 * index;
    			translationY = 0;
    		}
    		ObjectAnimator one = ObjectAnimator.ofFloat(view, "translationX", 0,
    				translationX);
    		ObjectAnimator two = ObjectAnimator.ofFloat(view, "translationY", 0,
    				translationY);
    		ObjectAnimator three = ObjectAnimator.ofFloat(view, "rotation", 0, 360);
    		ObjectAnimator four = ObjectAnimator.ofFloat(view, "scaleX", 0f, 1f);
    		ObjectAnimator five = ObjectAnimator.ofFloat(view, "scaleY", 0f, 1f);
    		ObjectAnimator six = ObjectAnimator.ofFloat(view, "alpha", 0f, 1);
    		AnimatorSet set = new AnimatorSet();
    		if (isRadians) {
    			set.playTogether(one, two, three, four, five, six);
    		} else {
    			set.playTogether(one, two, six);
    		}
    		set.setDuration(2000);
    		// 回弹效果
    		set.setInterpolator(new BounceInterpolator());
    		set.start();
    	}
    
    	/**
    	 * 关闭扇形菜单
    	 * 
    	 * @param view
    	 * @param index
    	 * @param num
    	 * @param radius
    	 */
    	public static void closeAnim(View view, int index, int num, int radius,
    			boolean isRadians) {
    		if (view.getVisibility() != View.VISIBLE) {
    			view.setVisibility(View.VISIBLE);
    		}
    		final int translationX;
    		final int translationY;
    		if (isRadians) {
    			double angle = Math.toRadians(180) / (num - 1) * index;
    			translationX = -(int) (radius * Math.cos(angle));
    			translationY = -(int) (radius * Math.sin(angle));
    		} else {
    			translationX = index * 80 + 20 * index;
    			translationY = 0;
    		}
    		ObjectAnimator one = ObjectAnimator.ofFloat(view, "translationX",
    				translationX, 0);
    		ObjectAnimator two = ObjectAnimator.ofFloat(view, "translationY",
    				translationY, 0);
    		ObjectAnimator three = ObjectAnimator.ofFloat(view, "rotation", 0, 360);
    		ObjectAnimator four = ObjectAnimator.ofFloat(view, "scaleX", 1f, 0f);
    		ObjectAnimator five = ObjectAnimator.ofFloat(view, "scaleY", 1f, 0f);
    		ObjectAnimator six = ObjectAnimator.ofFloat(view, "alpha", 1f, 0f);
    
    		AnimatorSet set = new AnimatorSet();
    		if (isRadians) {
    			set.playTogether(one, two, three, four, five, six);
    		} else {
    			set.playTogether(one, two, six);
    		}
    		set.setDuration(2000);
    		// 回弹效果
    		set.setInterpolator(new BounceInterpolator());
    		set.start();
    	}
    }

    纠正摄像头渲染方向(郑海波

        //判断是否有前摄像头    
        @TargetApi(9)
    	private int FindFrontCamera() {
    		int cameraCount = 0;
    		Camera.CameraInfo cameraInfo = new Camera.CameraInfo();
    		cameraCount = Camera.getNumberOfCameras(); // get cameras number
    
    		for (int camIdx = 0; camIdx < cameraCount; camIdx++) {
    			Camera.getCameraInfo(camIdx, cameraInfo); // get camerainfo
    			if (cameraInfo.facing == Camera.CameraInfo.CAMERA_FACING_FRONT) { // ��������ͷ�ķ�λ��Ŀǰ�ж���ֵ�����ֱ�ΪCAMERA_FACING_FRONTǰ�ú�CAMERA_FACING_BACK����
    				return camIdx;
    			}
    		}
    		return -1;
    	}
        //判断是否有后摄像头
    	@TargetApi(9)
    	private int FindBackCamera() {
    		int cameraCount = 0;
    		Camera.CameraInfo cameraInfo = new Camera.CameraInfo();
    		cameraCount = Camera.getNumberOfCameras(); // get cameras number
    
    		for (int camIdx = 0; camIdx < cameraCount; camIdx++) {
    			Camera.getCameraInfo(camIdx, cameraInfo); // get camerainfo
    			if (cameraInfo.facing == Camera.CameraInfo.CAMERA_FACING_BACK) { // ��������ͷ�ķ�λ��Ŀǰ�ж���ֵ�����ֱ�ΪCAMERA_FACING_FRONTǰ�ú�CAMERA_FACING_BACK����
    				return camIdx;
    			}
    		}
    		return -1;
    	}
    
        /**
    	 * 根据横竖屏自动调节preview方向,Starting from API level 14, this method can be called
    	 * when preview is active.
    	 * 
    	 * @param activity
    	 * @param cameraId
    	 * @param camera
    	 */
    	public static void setCameraDisplayOrientation(Activity activity,
    			int cameraId, Camera camera) {
    		Camera.CameraInfo info = new Camera.CameraInfo();
    		Camera.getCameraInfo(cameraId, info);
    		int rotation = activity.getWindowManager().getDefaultDisplay()
    				.getRotation();
    
    		// degrees the angle that the picture will be rotated clockwise. Valid
    		// values are 0, 90, 180, and 270.
    		// The starting position is 0 (landscape).
    		int degrees = 0;
    		switch (rotation) {
    		case Surface.ROTATION_0:
    			degrees = 0;
    			break;
    		case Surface.ROTATION_90:
    			degrees = 90;
    			break;
    		case Surface.ROTATION_180:
    			degrees = 180;
    			break;
    		case Surface.ROTATION_270:
    			degrees = 270;
    			break;
    		}
    		int result;
    		if (info.facing == Camera.CameraInfo.CAMERA_FACING_FRONT) {
    			result = (info.orientation + degrees) % 360;
    			result = (360 - result) % 360; // compensate the mirror
    		} else {
    			// back-facing
    			result = (info.orientation - degrees + 360) % 360;
    		}
    		camera.setDisplayOrientation(result);
    	}

    20181219第二版demo---添加了扇形动画菜单+自由拖拽图标+3D图片滑动倾斜放大倒影+自定义scrollview实现滑动监听等。

    这里是项目更新demohttps://github.com/Life1412378121/EasyLive

    THE END 感谢您的查看,如喜欢,欢迎您的star/fork ,小菜我叫吴明辉,期待与您一同打造一个无广告甚至免费的万能播放器。
     

    展开全文
  • 文章目录绘制曲线绘制四分之一的圆弧绘制四分之一扇形绘制一个圆等分成num份根据数据的饼图绘制在画布中心的一段文字(下划线)绘制饼状图绘制图片帧动画canvas的转换 绘制曲线 /* * 1、体验曲线的绘制 * 2、线是由...

    绘制曲线

        /*
        * 1、体验曲线的绘制
        * 2、线是由点构成的
        * 3、曲线可以由数学公式得来
        *
        * 公式:y=x/2
        * 公式:y=(x+2)^2
        * 公式:y=sin(x)
        * */
    
        for(var i=0;i<600;i++){
            var x=i;
            // var y=x/2;
            // var y=Math.pow(x-100+2,2)/20;
            var y=50*Math.sin(x/10)+150;
            ctx.lineTo(x,y);
        }
        ctx.strokeStyle="blueviolet";
        ctx.stroke();
    

    在这里插入图片描述

    绘制四分之一的圆弧

        /*
        * 绘制圆弧
        * 确定圆心 坐标 x y
        * 确定圆半径 r
        * 确定起始绘制的位置和结束绘制的位置 确定弧的长度和位置 startAngle endAngle
        * 取得绘制的方向 direction 默认是顺时针方向-->false   逆时针--->true
        * */
    
        //在中心位置画一个半径150px的圆弧左下角
        var w=ctx.canvas.width;
        var h=ctx.canvas.height;
        ctx.arc(w/2,h/2,150,Math.PI/2,Math.PI,false);
        ctx.strokeStyle="blueviolet";
        ctx.stroke();
    

    在这里插入图片描述

    绘制四分之一扇形

        //在中心位置画一个半径150px的圆弧右上角 扇形 边 填充
        var w=ctx.canvas.width;
        var h=ctx.canvas.height;
    
        //把起点放在圆心位置
        ctx.moveTo(w/2,h/2);
        ctx.arc(w/2,h/2,150,0,-Math.PI/2,true);
        ctx.fillStyle="lightskyblue";
        ctx.fill();
    

    在这里插入图片描述

    绘制一个圆等分成num份

    <script>
        var myCanvas=document.querySelector("canvas");
        var ctx=myCanvas.getContext("2d");
    
        var canvasWidth=ctx.canvas.width;
        var canvasHeight=ctx.canvas.height;
    
        //分成多少等份
        var num=360;
    
        //半径
        var radius=150;
    
        //一份多少弧度
        var angle=Math.PI*2/num;
    
        //坐标原点
        var x0=canvasWidth/2;
        var y0=canvasHeight/2;
    
        //获取随机颜色
        var getRandomColor=function () {
            var r=Math.floor(Math.random()*256);
            var g=Math.floor(Math.random()*256);
            var b=Math.floor(Math.random()*256);
            return "rgb("+r+",+"+g+","+b+")";
        };
    
        //上一次绘制的结束弧度等于当前次的起始弧度
        for(var i=0;i<num;i++){
            var startAngle=i*angle;
            var endAngle=(i+1)*angle;
            ctx.beginPath();
            ctx.moveTo(x0,y0);
            ctx.arc(x0,y0,radius,startAngle,endAngle);
            //随机颜色
            ctx.fillStyle=getRandomColor();
            ctx.fill();
        }
    </script>
    

    在这里插入图片描述

    根据数据的饼图

    根据占比设置每个扇形起止angle

        //转换弧度+绘制图形
        var startAngle=0;
        var endAngle=0;
        data.forEach(function (item,i) {
            endAngle=startAngle+Math.PI*2*(item/total);
            ctx.beginPath();
            ctx.moveTo(x0,y0);
            ctx.arc(x0,y0,radius,startAngle,endAngle);
            ctx.fillStyle=getRandomColor();
            ctx.fill();
            startAngle=endAngle;
        });
    

    绘制在画布中心的一段文字(下划线)

        var str="乐程_NB";
        ctx.beginPath();
        ctx.font="40px 华文行楷";
        ctx.textAlign="center";//水平-->center left right start end
        ctx.textBaseline="middle";//垂直-->top bottom middle
        ctx.strokeText(str,x0,y0);
        var width=ctx.measureText(str).width;//文本宽度
        ctx.moveTo(x0-width/2,y0+20);
        ctx.lineTo(x0+width/2,y0+20);
        ctx.stroke();
    

    在这里插入图片描述

    绘制饼状图

    <!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>Title</title>
        <style>
            canvas{
                border:1px solid lightskyblue;
            }
        </style>
    </head>
    <body>
    <canvas width="600" height="400"></canvas>
    <script>
        /*
        * 绘制饼状图
        * 根据数据绘制一个饼状图
        * 绘制标题 从扇形的弧中心伸出一条横线 在横线的上面写上标题
        * 在画布的左上角 绘制说明 一个扇形一样的颜色的矩形 旁边是文字说明
        * */
    
        var PieChart=function (ctx) {
            //绘制工具
            this.ctx=ctx||document.querySelector("canvas").getContext("2d");
    
            //绘制饼状图的中心
            this.w=this.ctx.canvas.width;
            this.h=this.ctx.canvas.height;
    
            //圆心
            this.x0=this.w/2+60;
            this.y0=this.h/2;
    
            //半径
            this.radius=150;
    
            //伸出去的线的长度
            this.outLine=20;
    
            //说明的矩形大小
            this.rectW=30;
            this.rectH=16;
            this.space=20;
        }
        PieChart.prototype.init=function(data){
            //准备数据
            this.drawPie(data);
        };
    
        //绘制饼状图
        PieChart.prototype.drawPie=function (data) {
            var that=this;
            //转化弧度
            var angleList=this.transformAngle(data);
    
            //绘制饼图
            var startAngle=0;
            angleList.forEach(function (item,i) {
                //当前弧度结束要等于下一次的起始弧度
                var endAngle=startAngle+item.angle;
    
                that.ctx.beginPath();
                that.ctx.moveTo(that.x0,that.y0);
                that.ctx.arc(that.x0,that.y0,that.radius,startAngle,endAngle);
                var color=that.ctx.fillStyle=that.getRandomColor();
                that.ctx.fill();
                that.drawTitle(startAngle,item.angle,color,item.title)
                startAngle=endAngle;
    
                that.drawDesc(i,item.title);
            });
        };
    
        //转换弧度
        PieChart.prototype.transformAngle=function (data) {
            //返回的数据内容包含弧度的
            var total=0;
            data.forEach(function (item,i) {
                total+=item.num;
            });
    
            //计算弧度,并且追加到当前的对象内容
            data.forEach(function (item,i) {
                var angle=Math.PI*2*(item.num/total);
                item.angle=angle;
            });
            return data;
        };
    
        //绘制标题
        PieChart.prototype.drawTitle=function(startAngle,angle,color,title){
            /*
            * 确定伸出去的线,通过圆心点,通过伸出去的点 确定这条线
            * 确定伸出去的点,需要确定伸出去的线的长度
            * 固定伸出去的线的长度
            * 计算这个点的坐标
            * 根据角度和斜边的长度
            * 使用弧度,当前扇形的起始弧度+对应的弧度的一半
            * 半径+伸出去的长度
            *
            * outX=this.x0+edge*cos(startAngle+angle/2);
            * outY=this.y0+edge*sin(startAngle+angle/2);
            * */
    
            //斜边
            var edge=this.radius+this.outLine;
            //出去点的x坐标
            var outX=this.x0+edge*Math.cos(startAngle+angle/2);
            //出去点的y坐标
            var outY=this.y0+edge*Math.sin(startAngle+angle/2);
    
            this.ctx.beginPath();
            this.ctx.moveTo(this.x0,this.y0);
            this.ctx.lineTo(outX,outY);
            this.ctx.strokeStyle=color;
            this.ctx.stroke();
    
            //绘制文字和下划线
            //线的方向怎么判断-->伸出去的点在x0的哪边,线的方向就是哪边
            //结束的点坐标和文字大小
            this.ctx.font="14px Microsoft YaHei";
            var textWidth=this.ctx.measureText(title).width;
            if(outX>=this.x0){
                //右
                this.ctx.moveTo(outX,outY);
                this.ctx.lineTo(outX+textWidth,outY);
                this.ctx.textAlign="left";
            }
            else{
                //左
                this.ctx.moveTo(outX,outY);
                this.ctx.lineTo(outX-textWidth,outY);
                this.ctx.textAlign="right";
            }
            this.ctx.strokeStyle=color;
            this.ctx.stroke();
            this.ctx.textBaseline="bottom";
            this.ctx.fillText(title,outX,outY);
        }
    
        //绘制说明
        PieChart.prototype.drawDesc=function(index,title){
            //绘制说明
            //矩形的大小
            //距离上和左边的间距
            //矩形之间的距离
    
            //绘制矩形
            this.ctx.fillRect(this.space,this.space+index*(this.rectH+10),this.rectW,this.rectH);
            this.ctx.fill();
    
            //绘制文字
            this.ctx.font="12px Microsoft YaHei";
            this.ctx.beginPath();//重新开一条路径
            this.ctx.textAlign="left";
            this.ctx.textBaseline="top";
            this.ctx.fillText(title,this.space+this.rectW+10,this.space+index*(this.rectH+10));
        }
    
        //产生随机颜色
        PieChart.prototype.getRandomColor=function () {
            var r=Math.floor(Math.random()*256);
            var g=Math.floor(Math.random()*256);
            var b=Math.floor(Math.random()*256);
    
            return 'rgb('+r+','+g+','+b+')';
        };
    
        var data = [
            {
                title: '15-20岁',
                num: 6
            },
            {
                title: '20-25岁',
                num: 30
            },
            {
                title: '25-30岁',
                num: 10
            },
            {
                title: '30以上',
                num: 8
            }
        ];
    
        var pieChart=new PieChart();
        pieChart.init(data);
    
    </script>
    </body>
    </html>
    

    在这里插入图片描述

    绘制图片

        //创建对象
        var img=new Image();
    
        //绑定加载完成事件
        img.onload=function () {
            //实现图片绘制
            console.log(img);
    
            //绘制图片的三种方式
    
            //三个参数
            //图片对象
            //绘制在画布上的坐标x y
            // ctx.drawImage(img,100,100);
    
            //五个参数
            //图片对象
            //绘制在画布上的坐标x y
            //图片的大小 不是裁剪 是缩放
            // ctx.drawImage(img,100,100,200,200);
    
            /*
            * 九个参数
            * 图片对象
            * 图片上定位的坐标 x y
            * 在图片上截取多大的区域 w h
            * 绘制在画布上的坐标 x y
            * 图片的大小 不是裁剪 是缩放
            * */
            ctx.drawImage(img,20,20,50,50,100,100,400,400);
        };
    
        //设置图片路径
        img.src="01.jpg";
    

    帧动画

        var img=new Image();
        img.onload=function () {
            //图片加载完成
            //动态地去获取当前图片的尺寸
            var imgWidth=img.width;
            var imgHeight=img.height;
    
            //计算出每一个小人的尺寸
            var personWidth=imgWidth/4;
            var personHeight=imgHeight/4;
    
            //位截取图片
            //帧动画,在规定的时间间隔更换显示的图片 根据图片的索引
            var index=0;
    
            //绘制在画布的中心
            //图片绘制的起始点
            var x0=canvasWidth/2-personWidth/2;
            var y0=canvasHeight/2-personHeight/2;
    
            ctx.drawImage(img,0,0,personWidth,personHeight,x0,y0,personWidth,personHeight);
            setInterval(function () {
                index++;
                ctx.clearRect(0,0,ctx.canvas.width,ctx.canvas.height);
                ctx.drawImage(img,index*personWidth,0,personWidth,personHeight,x0,y0,personWidth,personHeight);
                if(index>=3){
                    index=0;
                }
            },100);
    
        };
    
        //图片路径
        img.src="04.png";
    

    在这里插入图片描述

    
    <!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>Title</title>
        <style>
            canvas {
                border: 1px solid #ccc;
            }
        </style>
    </head>
    <body>
    <canvas width="600" height="400"></canvas>
    <script>
        var Person=function (ctx) {
            //绘制工具
            this.ctx=ctx||document.querySelector("canvas").getContext("2d");
    
            //图片路径
            this.src="04.png";
    
            //行走相关参数
            this.stepSize=10;
    
            //0-前  1-左 2-右 3-后 和图片的行数包含的图片对应上
            this.direction=0;
    
            //x轴方向偏移步数
            this.stepX=0;
    
            //y轴方向偏移步数
            this.stepY=0;
    
            //初始化方法
            this.init();
        }
    
        Person.prototype.init=function () {
            var that=this;
    
            //加载图片
            this.loadImage(function (image) {
                //图片的大小
                that.imageWidth=image.width;
                that.imageHeight=image.height;
    
                //人物的大小
                that.personWidth=that.imageWidth/4;
                that.personHeight=that.imageHeight/4;
    
                //绘制图片的起点
                that.x0=that.imageWidth/2-that.personWidth/2;
                that.y0=that.imageHeight/2-that.personHeight/2;
    
                //默认绘制在中心位置正面朝外
                that.ctx.drawImage(image,0,0,that.personWidth,that.personHeight,that.x0,that.y0,that.personWidth,that.personHeight);
    
                //3、能通过方向键去控制人物行走----document.onkeyDown--->keyCode
                that.index=0;
                var add=3;
                setInterval(function () {
                    var code=parseInt(Math.random()*4+37);
                    if(code==40){
                        //前
                        that.direction=0;
                        that.stepY+=add;
                        that.drawImage(image);
                    }else if(code==37){
                        //左
                        that.direction=1;
                        that.stepX-=add;
                        that.drawImage(image);
                    }else if(code==39){
                        //右
                        that.direction=2;
                        that.stepX+=add;
                        that.drawImage(image);
                    }else if(code==38){
                        //后
                        that.direction=3;
                        that.stepY-=add;
                        that.drawImage(image);
                    }
                },200);
            });
        };
    
        //加载图片
        Person.prototype.loadImage=function (callback) {
            var image=new Image();
            image.onload=function () {
                callback&&callback(image);
            };
            image.src=this.src;
        };
    
        //绘制图片
        Person.prototype.drawImage=function (image) {
            this.index++;
            this.ctx.clearRect(0,0,this.ctx.canvas.width,this.ctx.canvas.height);
    
            //绘图
            //在精灵图上的定位x  索引
            //在精灵图上的定位y  方向
            this.ctx.drawImage(image,this.index*this.personWidth,
                                this.direction*this.personHeight,
                                this.personWidth,this.personHeight,
                                this.x0+this.stepX*this.stepSize,
                                this.y0+this.stepY*this.stepSize,
                                this.personWidth,this.personHeight);
    
            //超出索引
            if(this.index>=3){
                this.index=0;
            }
        };
    
        new Person();
    </script>
    </body>
    </html>
    

    canvas的转换

        var startAngle=0;
        ctx.translate(200,200);
        setInterval(function () {
            startAngle+=Math.PI/180;
            ctx.rotate(startAngle);
            ctx.strokeStyle=getRandomColor();
            ctx.strokeRect(-50,-50,150,150);
        },500);
    
        function getRandomColor() {
            var r=Math.floor(Math.random()*256);
            var g=Math.floor(Math.random()*256);
            var b=Math.floor(Math.random()*256);
    
            return "rgb("+r+","+g+","+b+")";
        }
    

    在这里插入图片描述

    展开全文
  • 排列成扇形前后翻转的flash图片展示,鼠标点击的时候,图片从前边翻转到后边,显示出所遮挡的图片,可制作成Flash相册、画廊和图片展示,本Flash源码来自国外网站。
  • 今天要分享的这款CSS3图片特效没有那么绚丽,它的功能非常简单,当你把鼠标移到图片上时,多张图片便会由原先的叠在一起变成展开状态,展开过程中伴随CSS3动画,展开的形状是扇形。这款简单的CSS3图片层叠展开动画...
  • /*扇形统计图*/ $image = imagecreatetruecolor(100, 100); /*创建画布*/ /*设置画布需要的颜色*/ $white = imagecolorallocate($image,0xff,0xff,0xff); $gray = imagecolorallocate($image, 0xc0, 0xc0, 0xc0...
  • [Unity]利用Mesh在Unity中绘制扇形图片

    千次阅读 2016-12-31 22:46:56
    背景最近碰到个功能, 要一个扇形图案, 如下图: 美术原图: 需求是这个图形跟随角色, 在角色背后, 并且每个角色的扇形角度可能不同。 So, NGUI和UGUI很好用的FilledType是用不了了..解决过程去网上搜了下Unity...
  • //画扇形,也就画圆,只不过是设置角度的大小,形成一个扇形 aColor = [UIColor colorWithRed:0 green:1 blue:1 alpha:1]; CGContextSetFillColorWithColor(context, aColor.CGColor);//填充颜色 //以10为半径...
  • /*扇形统计图*/$image = imagecreatetruecolor(100, 100); /*创建画布*//*设置画布需要的颜色*/$white = imagecolorallocate($image,0xff,0xff,0xff);$gray = imagecolorallocate($image, 0xc0, 0xc0, 0xc0);$...
  • 1. Graphics 绘图画布 Graphics 类相当于一个画布,每个 Swing 组件都通过 Graphics 对象来绘制显示。绘图的原点位于组件的左上角,如下图所示: Graphics类中常用的绘制相关方法: ...// 设置
  • 文章目录引言I、三角形II、圆角矩形III、 扇形和椭圆 引言 绘制文字 /*写文字*/ CGContextSetRGBFillColor (context, 1, 0, 0, 1.0);//设置填充颜色 [@"图片:" drawInRect:CGRectMake(10, 340+180, 80, 20...
  • 安卓自定义view中 绘画基本图形点线面,矩形,方形,圆,扇形,文字及沿着特定方向布局,自定义圆角ImageView图片等等相关api使用方法及举例,图片压缩处理逻辑 本文旨在介绍自定义View的实现及流程 着重介绍安卓中...
  • * PS_01: 图片宽高: BufferedImage 可以通过 bufImage.getWidth() 和 bufImage.getHeight() 方法直接获取图片的宽高; * Image 获取宽高需要另外传入一个 ImageObserver 参数。 * * PS_02: 图片裁剪: ...
  • [Unity]利用Mesh在Unity中绘制扇形图片2

    千次阅读 2017-01-08 22:50:37
    之前那篇文章后,和同事又就这个问题讨论了一下,发现,其实不需要那么死心眼n个三角形,因为图片本身除了圆以外的地方都是透明的, 出来也没事。 这样的话, 其实可以把正方形的图片分成4个三角形,这样的话,...

空空如也

空空如也

1 2 3 4 5 ... 13
收藏数 246
精华内容 98
关键字:

扇形画图片