自定控件实现雷达监测功能

最新推荐文章于 2020-06-04 16:34:31 发布
最新推荐文章于 2020-06-04 16:34:31 发布
阅读量368 收藏 2
点赞数
分类专栏： Android
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_29342787/article/details/103523753
版权

需求：雷达分为单点避障雷达和多点避障雷达，单点避障雷达又分为前后避障，多点避障雷达也分为前后避障，前避障和后避障都涉及到8个方向的避障，例如前避障的4个角度分别为-30～-15，-15～0，0～15，15～30。4个区间的雷达探测距离分别<10m（显示红红红）,10-15m（显示黄黄红）,>15m（显示绿绿绿）三个区间，等于25.5米则为无效点。效果如图所示，左图为单点避障雷达效果，右图为多点雷达效果。

                                             

1.设置自定义控件相关的属性，在attr文件中：

<declare-styleable name="RadarView">
    <attr name="firstColor" format="color" />//第一层的颜色
    <attr name="secondColor" format="color" />//第二层的颜色
    <attr name="thirdColor" format="color" />//第三层的颜色
    <attr name="stroke_width" format="dimension" />//圆弧的宽度
    <attr name="divider_width" format="dimension" />//圆弧之间的间隔
    <attr name="text_color_1" format="color" />//实时变化的距离的颜色
    <attr name="text_color_2" format="color" />//10M，15M的文字颜色
    <attr name="text_size_1" format="dimension" />//上面对应的文字的大小
    <attr name="text_size_2" format="dimension" />//上面对应的文字的大小
</declare-styleable>

2.开始自定义控件

package com.example.myapplication3;

import android.content.Context;
import android.content.res.TypedArray;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.graphics.Path;
import android.graphics.Rect;
import android.graphics.RectF;
import android.support.v4.content.ContextCompat;
import android.util.AttributeSet;
import android.util.SparseIntArray;
import android.view.View;

import java.util.Locale;

/**
 * @author Kit Zuo
 * 2428382937@qq.com
 * @create 2019/12/05
 * @Desc 自定义控件实现避障雷达图
 */
public class RadarView extends View {
    private float text_size_1;
    private float text_size_2;
    private float stroke_width;
    private float divide_width;
    private int textColor_1;
    private int textColor_2;
    private int thirdColor;
    private int secondColor;
    private int firstColor;
    private Paint mFirstPaint;
    private Paint mSecondPaint;
    private Paint mThirdPaint;
    private Paint mTextPaint;
    private Paint mLinePaint;
    // 半径
    private float inner_radius = 100f;
    // 中心点
    private float centerX = 100f;
    private float centerY = 100f;
    // 开始角度
    private RectF rect_first;
    private RectF rect_second;
    private RectF rect_third;
    private float start_angle = 270;
    private static final float origin_angel = -60f;
    private static final float angel_divider = 30f;
    private float radius_third;
    private float radius_second;
    private Path path;//多点前避障的path
    private Path path_back;多点后避障的path
    private Path path_single;//单点前避障的path
    private Path path_single_back;//单点后避障的path
    private boolean isShowBac = true;//是否连接了后避障雷达
    private boolean isRadarType_multi = true;//是否是多点避障雷达
    private static final int multi_count = 4;//显示的角度区间个数
    private float angle;

    public RadarView(Context context) {
        this(context, null);
    }

    public RadarView(Context context, AttributeSet attrs) {
        this(context, attrs, 0);
    }

    public RadarView(Context context, AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
        TypedArray typedArray = context.obtainStyledAttributes(attrs, R.styleable.RadarView);
        this.firstColor = typedArray.getColor(R.styleable.RadarView_firstColor, Color.parseColor("#ff0000"));
        this.secondColor = typedArray.getColor(R.styleable.RadarView_secondColor, Color.parseColor("#ffcc00"));
        this.thirdColor = typedArray.getColor(R.styleable.RadarView_thirdColor, Color.parseColor("#00ff00"));
        this.textColor_1 = typedArray.getColor(R.styleable.RadarView_text_color_1, Color.parseColor("#ff6600"));
        this.textColor_2 = typedArray.getColor(R.styleable.RadarView_text_color_2, Color.parseColor("#ffffff"));
        this.stroke_width = typedArray.getDimension(R.styleable.RadarView_stroke_width, 30);
        this.divide_width = typedArray.getDimension(R.styleable.RadarView_divider_width, 60);
        this.text_size_1 = typedArray.getDimension(R.styleable.RadarView_text_size_1, 20);
        this.text_size_2 = typedArray.getDimension(R.styleable.RadarView_text_size_2, 30);
        typedArray.recycle();
        init();
    }

    private void init() {

        mTextPaint = new Paint();
        mTextPaint.setStyle(Paint.Style.STROKE);
        mTextPaint.setStrokeWidth(2);
        mTextPaint.setAntiAlias(true);
        mTextPaint.setTextSize(text_size_1);
        mTextPaint.setColor(Color.BLACK);
        mTextPaint.setTextAlign(Paint.Align.CENTER);

        int windowHeight = DensityUtil.getWindowHeight(getContext());
        int windowWidth = DensityUtil.getWindowWidth(getContext());
        mThirdPaint = new Paint();
        mThirdPaint.setStyle(Paint.Style.STROKE);
        mThirdPaint.setStrokeWidth(stroke_width);
        mThirdPaint.setAntiAlias(true);

        mSecondPaint = new Paint();
        mSecondPaint.setStyle(Paint.Style.STROKE);
        mSecondPaint.setStrokeWidth(stroke_width);
        mSecondPaint.setAntiAlias(true);

        mFirstPaint = new Paint();
        mFirstPaint.setStyle(Paint.Style.STROKE);
        mFirstPaint.setAntiAlias(true);
        mFirstPaint.setStrokeWidth(stroke_width);

        mLinePaint = new Paint();
        mLinePaint.setStyle(Paint.Style.STROKE);
        mLinePaint.setStrokeWidth(2);
        mLinePaint.setAntiAlias(true);
        mLinePaint.setColor(ContextCompat.getColor(getContext(), R.color.white));

        centerX = windowWidth >> 1;
        centerY = windowHeight >> 1;
        radius_third = inner_radius + divide_width * 2;
        radius_second = inner_radius + divide_width;

        rect_third = new RectF(centerX - radius_third, centerY - radius_third, centerX + radius_third, centerY + radius_third);
        rect_second = new RectF(centerX - radius_second, centerY - radius_second, centerX + radius_second, centerY + radius_second);
        rect_first = new RectF(centerX - inner_radius, centerY - inner_radius, centerX + inner_radius, centerY + inner_radius);

        path = new Path();
        path_back = new Path();
        path_single = new Path();
        path_single_back = new Path();
    }

    @Override
    protected void onDraw(Canvas canvas) {
        super.onDraw(canvas);
        //-30,-15,-15-0,0-15,15-30
        if (isRadarType_multi) {
//            canvas.save();
//            canvas.rotate(angle,centerX,centerY);
            int size = dataRadar.size();
            if (size >= 0) {
                canvas.save();
                for (int n = 0; n < multi_count; n++) {
                    doColor(n);
                    float start_angle = origin_angel + this.start_angle;
                    canvas.drawArc(rect_second, start_angle, angel_divider, false, mSecondPaint);
                    canvas.drawArc(rect_first, start_angle, angel_divider, false, mFirstPaint);
                    path.addArc(rect_third, start_angle, angel_divider);
                    canvas.drawPath(path, mThirdPaint);
                    double v = Math.PI * (90 - angel_divider) / 180;
                    if (n < 3) {
                        float x_1 = (float) (centerX - (radius_third + stroke_width / 2) * Math.cos(v));
                        float y_1 = (float) (centerY - (radius_third + stroke_width / 2) * Math.sin(v));
                        float x_2 = (float) (centerX - (inner_radius - stroke_width / 2) * Math.cos(v));
                        float y_2 = (float) (centerY - (inner_radius - stroke_width / 2) * Math.sin(v));
                        canvas.drawLine(x_1, y_1, x_2, y_2, mLinePaint);
                    }
                    mTextPaint.setTextSize(text_size_2);
                    mTextPaint.setColor(textColor_2);
                    canvas.drawTextOnPath(String.format(Locale.US, "%.1f", avoid_dis[n]), path, 0, 10, mTextPaint);
                    canvas.rotate(angel_divider, centerX, centerY);
                }
                canvas.restore();
                float y_4 = centerY - (inner_radius - stroke_width / 2);
                float y_7 = centerY - (radius_second - stroke_width / 2);
                mTextPaint.setTextSize(text_size_1);
                mTextPaint.setColor(textColor_1);
                canvas.drawText("15M", centerX, y_7 - divide_width / 2 - 10, mTextPaint);
                canvas.drawText("10M", centerX, y_4 - divide_width / 2 - 10, mTextPaint);
                if (isShowBac) {
                    canvas.save();
                    for (int m = 4; m < multi_count * 2; m++) {
                        doColor(m);
                        float start_angle = 90 - origin_angel;
                        canvas.drawArc(rect_second, start_angle, -angel_divider, false, mSecondPaint);
                        canvas.drawArc(rect_first, start_angle, -angel_divider, false, mFirstPaint);
                        path_back.addArc(rect_third, start_angle, -angel_divider);
                        canvas.drawPath(path_back, mThirdPaint);
                        double v = Math.PI * (90 - angel_divider) / 180;
                        if (m < 7) {
                            float x_1 = (float) (centerX - (radius_third + stroke_width / 2) * Math.cos(v));
                            float y_1 = (float) (centerY + (radius_third + stroke_width / 2) * Math.sin(v));
                            float x_2 = (float) (centerX - (inner_radius - stroke_width / 2) * Math.cos(v));
                            float y_2 = (float) (centerY + (inner_radius - stroke_width / 2) * Math.sin(v));
                            canvas.drawLine(x_1, y_1, x_2, y_2, mLinePaint);
                        }
                        mTextPaint.setTextSize(text_size_2);
                        mTextPaint.setColor(textColor_2);
                        canvas.drawTextOnPath(String.format(Locale.US, "%.1f", avoid_dis_back[m - 4]), path_back, 0, 10, mTextPaint);
                        canvas.rotate(-angel_divider, centerX, centerY);
                    }
                    canvas.restore();
                    float y_5 = centerY + (inner_radius + stroke_width / 2);
                    float y_8 = centerY + (radius_second + stroke_width / 2);
                    mTextPaint.setTextSize(text_size_1);
                    mTextPaint.setColor(textColor_1);
                    canvas.drawText("15M", centerX, y_8 + divide_width / 2 - 10, mTextPaint);
                    canvas.drawText("10M", centerX, y_5 + divide_width / 2 - 10, mTextPaint);
                }
            }
//            canvas.restore();
        } else {
            doColor(8);
            float start_angle = origin_angel + this.start_angle + angel_divider;
            canvas.drawArc(rect_second, start_angle, angel_divider * 2, false, mSecondPaint);
            canvas.drawArc(rect_first, start_angle, angel_divider * 2, false, mFirstPaint);
            path_single.addArc(rect_third, start_angle, angel_divider * 2);
            canvas.drawPath(path_single, mThirdPaint);
            mTextPaint.setTextSize(text_size_2);
            mTextPaint.setColor(textColor_2);
            canvas.drawTextOnPath(String.format(Locale.US, "%.1f", single_avoid), path_single, 0, 10, mTextPaint);
            float y_4 = centerY - (inner_radius - stroke_width / 2);
            float y_7 = centerY - (radius_second - stroke_width / 2);
            mTextPaint.setTextSize(text_size_1);
            mTextPaint.setColor(textColor_1);
            canvas.drawText("15M", centerX, y_7 - divide_width / 2 - 10, mTextPaint);
            canvas.drawText("10M", centerX, y_4 - divide_width / 2 - 10, mTextPaint);
            if (isShowBac) {
                doColor(9);
                float start_angle_single = 90 - origin_angel - angel_divider;
                canvas.drawArc(rect_second, start_angle_single, -angel_divider * 2, false, mSecondPaint);
                canvas.drawArc(rect_first, start_angle_single, -angel_divider * 2, false, mFirstPaint);
                path_single_back.addArc(rect_third, start_angle_single, -angel_divider * 2);
                canvas.drawPath(path_single_back, mThirdPaint);
                mTextPaint.setTextSize(text_size_2);
                mTextPaint.setColor(textColor_2);
                canvas.drawTextOnPath(String.format(Locale.US, "%.1f", single_avoid_back), path_single_back, 0, 10, mTextPaint);
                float y_5 = centerY + (inner_radius + stroke_width / 2);
                float y_8 = centerY + (radius_second + stroke_width / 2);
                mTextPaint.setTextSize(text_size_1);
                mTextPaint.setColor(textColor_1);
                canvas.drawText("15M", centerX, y_8 + divide_width / 2 - 10, mTextPaint);
                canvas.drawText("10M", centerX, y_5 + divide_width / 2 - 10, mTextPaint);
            }
        }
    }

    private void doColor(int n) {
        int warn_index = dataRadar.get(n + 1);
        if (warn_index >= 1) {
            if (warn_index == 1) {
                mThirdPaint.setColor(thirdColor);
                mSecondPaint.setColor(thirdColor);
                mFirstPaint.setColor(thirdColor);
            } else if (warn_index == 2) {
                mThirdPaint.setColor(secondColor);
                mSecondPaint.setColor(secondColor);
                mFirstPaint.setColor(thirdColor);
            } else if (warn_index == 3) {
                mThirdPaint.setColor(firstColor);
                mSecondPaint.setColor(firstColor);
                mFirstPaint.setColor(firstColor);
            }
        } else {
            mThirdPaint.setColor(thirdColor);
            mSecondPaint.setColor(thirdColor);
            mFirstPaint.setColor(thirdColor);
        }
    }

    public void setCenter(float centerX, float centerY, float inner_radius, float start_angle) {
        this.start_angle = start_angle + 270;
        this.inner_radius = inner_radius;
        this.centerX = centerX;
        this.centerY = centerY;
        rect_third.set(new RectF(centerX - (inner_radius + divide_width * 2), centerY - (inner_radius + divide_width * 2), centerX + (inner_radius + divide_width * 2), centerY + (inner_radius + divide_width * 2)));
        rect_second.set(new RectF(centerX - (inner_radius + divide_width), centerY - (inner_radius + divide_width), centerX + (inner_radius + divide_width), centerY + (inner_radius + divide_width)));
        rect_first.set(new RectF(centerX - inner_radius, centerY - inner_radius, centerX + inner_radius, centerY + inner_radius));
        invalidate();
    }

    private float[] avoid_dis = {25.5f, 25.5f, 25.5f, 25.5f};//多点前避障4个区间的距离
    private float[] avoid_dis_back = {25.5f, 25.5f, 25.5f, 25.5f};//多点后避障4个区间的距离
    private float single_avoid;//单点前避障的探测距离
    private float single_avoid_back;//单点后避障的探测距离

    public void setDir(float[] avoid_dis) {
        this.avoid_dis = avoid_dis;
    }

    public void setDirBack(float[] avoid_dis) {
        this.avoid_dis_back = avoid_dis;
    }

    private SparseIntArray dataRadar = new SparseIntArray();

    public void setDataRadar(SparseIntArray dataRadar) {
        this.dataRadar = dataRadar;
        invalidate();
    }

    public boolean isShowBac() {
        return isShowBac;
    }

    public void setShowBac(boolean showBac) {
        isShowBac = showBac;
    }

    public boolean isRadarType_multi() {
        return isRadarType_multi;
    }

    public void setRadarType_multi(boolean radarType_multi) {
        isRadarType_multi = radarType_multi;
    }

    public float getSingle_avoid() {
        return single_avoid;
    }

    public void setSingle_avoid(float single_avoid) {
        this.single_avoid = single_avoid;
    }

    public float getSingle_avoid_back() {
        return single_avoid_back;
    }

    public void setSingle_avoid_back(float single_avoid_back) {
        this.single_avoid_back = single_avoid_back;
    }

    public void setAngle(float angle) {
        this.angle = angle;
    }
}

3.总结

这个自定义控件虽然非常的简单，用到的都是比较简单的数学知识，但是实际应用比较广泛，也比较有趣，所以记录一下。

我不是2022
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
MATLAB算法实战应用案例精讲-【自动驾驶】激光雷达标定
qq_36130719的博客
05-23 1727
激光雷达在自动驾驶中的核心特征可以概括为三维环境感知、高分辨率、抗干扰能力。三维环境感知方面，3D激光雷达能够在短时间内向周围环境发射大量的激光束，探测距离是介于200-300m远距离和最大90°*30°的大视野探测能力；角分辨率最高可达0.05°*0.05°，保证了它在远距离仍然能准确探测、追踪多个目标，距离分辨率可以达到0.1mard，速度分辨率达到10m/s以内。
Android自定义View实现雷达扫描动画
oxygen's blog
10-16 6485
在最近的项目中有用到雷达动画，于是
Android自定义View 多边形能力分析控件，雷达图（蛛网）动态实现
tg_0804的博客
03-13 1736
自定义View实现雷达图还是挺简单的，它能让使用让使用者能一目了然的了解各项指标的变动情形以及好坏趋势。使用得最多的便是Path路径，很适合初学者用来练习。 效果图如下： 下面是实体类的属性： public class RadarMapData { private int count;//数值项数 private String [] titles;//...
【MFC】监测控件信息(动态刷新)
Cain Xcy的博客
06-04 1886
MFC控件数据动态刷新 前言: 今天笔者要分享的是：关于MFC中编辑框控件A改变value，随之改变编辑框控件B的value，此方法是沿用MFC消息响应机制提供的方法，希望对大家的问题有所帮助。 首先先介绍两个通知消息，也是我们今天的主角。 EN_CHANGE: EN_UPDATE: ...
Android动画之雷达扫描效果
01-04
这里决定采用canvas（画布）和paint（画笔）实现了这个简单动画控件。 由图片可以看到有两条交叉的十字线、几个圆圈和一些白点，那么首先定义一下所需的画笔，画布及一些数据 setBackgroundColor(Color....
cesium卫星雷达示例，html,三维开发实例 前端开发
05-21
通过以上技术，开发者可以创建出交互式的、具有卫星雷达图像的3D地球应用，使用户能够探索地球表面的细微变化，这对于环境监测、灾害响应和地质研究等领域具有巨大价值。 在实际项目中，开发者可能还需要关注其他...
c/c++解析SA雷达数据和强度显示
03-18
在C/C++编程领域，开发一个能够解析SA雷达数据并以强度显示的程序是一项复杂的任务。这个项目基于MFC（Microsoft Foundation Classes）框架，MFC是微软提供的一个用于构建Windows应用程序的C++类库，它封装了Windows...
雷达与报文数据综合监视报警系统设计
10-25
第一，系统实时监测雷达和报文数据流，如果在设定时间内ATC自动化系统未收到预期数据，系统将播放预设的声音文件以报警。这使得故障的检测更加迅速，有助于确保设备的安全运行。第二，系统集成了关键字报警模块，当...
微软画图控件 (vs 2008 sp1中自带的MSChart )
03-30
微软画图控件是Visual Studio 2008 SP1中提供的一项强大的图表绘制功能，名为MSChart。这个控件允许开发者在Windows Forms和ASP.NET应用程序中创建丰富的、交互式的图表，以直观地展示各种数据集。在VS 2008 SP1中...
国际化出现数字的点变为逗号的问题
qq_29342787的博客
07-10 2656
当使用DecimalFormat或者使用String.format来格式化数据时，不要使用 String format(Locale.getDefault, String format, Object... args)来格式化数据，需要使用例如Locale.US等不出现逗号的国家来格式化数据。 ...
adb server version (31) doesn't match this client (40); killing... could not read ok from ADB Server
qq_29342787的博客
07-30 1979
这种是因为360手机助手占用了端口好，用任务管理器杀掉就可以了 首先，打开命令行工具，查看失败信息中提示的端口是否被占用（比如我这边提示的是5037） netstat -ano | findstr :5037 如果端口被占用，在任务列表中找到占用端口的进程（可在上一步中查看） tasklist | findstr processID 关闭占用这个端...
HashMap的另类写法
qq_29342787的博客
11-01 848
static Map<String, Integer> map = new HashMap<String, Integer>(8) { { put("DISINVESTMENT", R.mipmap.icon_disinvestments); put("PAY", R.mipmap.icon_recharges...
关于版本回退后怎么还原原来的分支
qq_29342787的博客
10-24 785
如果在reset当前分支到某个节点时发现操作失误，想还原当前操作，回到reset之前的分支，如下图所示： 1.输入git reflog,查看分支所有的操作历史记录 2.查看HEAD@{num},其中num的数值越大，则代表当前的历史分支的时间点越往前，输入git reset --hard 还原历史版本 ...
@BindView-annotated class incorrectly in Android framework package. 包名不能以android开头
qq_29342787的博客
10-31 544
错误: @BindView-annotated class incorrectly in Android framework package. 包名不能以android开头
自定义控件实现区域分割
qq_29342787的博客
08-07 244
待写
Manifest merger failed with multiple errors, see logs问题处理
qq_29342787的博客
11-16 180
进入命令行,输入命令 gradlew processDebugManifest --stacktrace 在mac下执行的命令是：./gradlew processDebugManifest --stacktrace（即在命令前面加上./）
记录一些炫酷的效果
qq_29342787的博客
10-31 127
http://www.cnblogs.com/androidsuperman/p/4209706.html
udp分片报文pcap文件
最新发布
07-18
udp分片报文pcap文件：64kudp大包分成每片658字节总计100片
C# Winform 自定义控件实现仪表盘功能
"c# Winform自定义控件-仪表盘功能的实现文档" 在C#的Windows Forms (Winform) 应用程序开发中，有时需要创建自定义控件以满足特定的设计需求和交互体验。本篇文档详细介绍了如何在C# Winform环境中创建一个自定义...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值