心电波形图EcgView

已于 2025-01-16 13:37:35 修改
阅读量429 收藏 3
点赞数 3
分类专栏： web前端 文章标签： 音视频 Canvas 波形图 听诊器 电压值
于 2024-06-19 13:34:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhijiandedaima/article/details/139800536
版权

在这里插入图片描述

前言：

心电图是被记录在布满大小方格的纸上，所以想要知道心电图怎么看，首要的是知道这些格子代表的意义。这些方格中每一条细竖线相隔1mm，每一条细横线也是相隔1mm，它们围成了1mm见方的小格。粗线是每五个小格一条，每条粗线之间相隔就是5mm，横竖粗线又构成了大方格。

心电图记录纸是按照国际规定的标准速度移动的，移动速度为25mm/s，也就是说横向的每个小细格代表0.04s；每两条粗线之间的距离就是代表0.2s。

国际上对记录心电图时的外加电压也是有规定的，即外加1mV电压时，基线就应该准确地抬高10个小格，也就是说，每个小横格表示0.1mV，而每个大格就表示0.5mV，每两个大格就代表了这1mV。

特点：

  • 走纸速度固定：25mm/s
  • 一屏显示的数据量不确定；
  • 以下采用的是心电（ECG）的知识，填充的是心音（PCG）的数据，所以采样率是8000；

1、Android实现：

网格图：

import android.content.Context;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.util.AttributeSet;
import android.view.View;


public class GridView extends View {
    private int width, height;
    private int row = 5;
    private Paint paint;

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

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

    public GridView(Context context, AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
        paint = new Paint();
        paint.setAntiAlias(true);
        paint.setStyle(Paint.Style.FILL);
    }

    @Override
    protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
//        super.onLayout(changed, left, top, right, bottom);
        width = getWidth();
        height = getHeight();
    }

    @Override
    protected void onDraw(Canvas canvas) {
//        super.onDraw(canvas);
        paint.setStrokeWidth(2);
        drawGird(canvas, row * 5, Color.parseColor("#D7D7D7"));
        paint.setStrokeWidth(4);
        drawGird(canvas, row, Color.parseColor("#D7D7D7"));
    }

    private void drawGird(Canvas canvas, int cols, int color) {
        paint.setColor(color);
        float rowSpace = height * 1f / cols;
        //画竖线
        for (int i = 0; i * rowSpace <= width; i++) {
            canvas.drawLine(i * rowSpace, 0, i * rowSpace, height, paint);
        }
        //画横线
        for (int i = 0; i <= cols; i++) {
            canvas.drawLine(0, i * rowSpace, width, i * rowSpace, paint);
        }
    }
//    @Override
//    protected void onSizeChanged(int w, int h, int oldw, int oldh) {
//        super.onSizeChanged(w, h, oldw, oldh);
//        width = w;
//        height = h;
//        invalidate();
//    }
}

波形图：

package com.kl.analyze.view.wave;

import android.content.Context;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.graphics.PixelFormat;
import android.graphics.PorterDuff;
import android.graphics.Rect;
import android.util.AttributeSet;
import android.util.Log;
import android.view.SurfaceHolder;
import android.view.SurfaceHolder.Callback;
import android.view.SurfaceView;
import android.view.View;

import androidx.annotation.NonNull;
import androidx.core.content.ContextCompat;

import com.kl.common.base.BaseApp;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class AudioWaveView extends SurfaceView implements Callback, Runnable, Serializable {
    private final List<Short> pointList = Collections.synchronizedList(new LinkedList<>());
    private Paint mPaint;
    private SurfaceHolder mHolder;
    private int mWidth = 0;
    private int mCenterY = 0;
    //网格颜色
    protected int mWaveColor = com.kl.common.R.color.colorPrimary;
    public float[] points;
    private boolean isRunning = false;
    private boolean isDraw = false;
    List<Short> nativeDatas = null;
    volatile ThreadPoolExecutor singleThreadExecutor;//单线程池
    private double zoom;//每一毫米所占像素（mm/px）
    private float gapX = 0.2f;// x轴每个点所占的像素（px）
    private int xSize = 0;// x轴能绘制的点的数量
    private final int FILTER_SIZE = 50;//采样率太高，数据抽稀

    @Override
    public void run() {
        while (isRunning) {
            if (isDraw) {
                drawFrame();
            } else {
                Thread.yield();
            }
        }
    }

    public void addWaveData(short[] waveDataArray) {
        if (!isRunning || waveDataArray == null) {
            return;
        }
        if (nativeDatas == null) {
            nativeDatas = new ArrayList<>();
        }

        for (short waveData : waveDataArray) {
            int maxMidScopeY = 0;// ADC输出值的范围：-32768 ~ 32767，中间值为0
            int gain = 5;//波形增益，5mm/mv
            short y = (short) Math.floor(calcRealMv(maxMidScopeY - waveData) * gain * zoom + mCenterY);
            nativeDatas.add(y);
        }
        if (nativeDatas.size() >= 800) {
            addPointThreadExecutor(nativeDatas);
            nativeDatas = new ArrayList<>();
        }
    }

    private void addPointThreadExecutor(List<Short> nativeDatas) {
        if (!isRunning || nativeDatas == null) {
            return;
        }
        if (singleThreadExecutor == null || singleThreadExecutor.isShutdown()) {
            startSingleThreadExecutor();
            return;
        }
        //Log.e("====>", "singleThreadExecutor.getQueue().size() = " + singleThreadExecutor.getQueue().size());
        if (singleThreadExecutor.getQueue().size() >= 5) {
            Log.e("====>", "singleThreadExecutor.getQueue().size() = " + singleThreadExecutor.getQueue().size());
            return;
        }
        singleThreadExecutor.execute(new Runnable() {
            @Override
            public void run() {
//                Log.d("caowj", "单线程执行");
                List<Short> dataList = nativeDatas;
                synchronized (pointList) {
                    for (int i = 0; i < dataList.size(); i += FILTER_SIZE) {
                        if (pointList.size() >= xSize && xSize > 0) {
                            pointList.remove(0);
                        }

                        pointList.add(dataList.get(i));
                    }
                    isDraw = true;
                }
            }
        });
    }

    synchronized void drawFrame() {
        Canvas canvas = null;
        try {
            if (!isRunning) {
                return;
            }
            canvas = mHolder.lockCanvas();
            if (canvas != null) {
                drawCube(canvas);
            } else {
                Log.w("caowj", "canvas is null");
            }
        } catch (Exception e) {
            isDraw = false;
            Log.w("caowj", "绘制异常：" + e.getMessage());
        } finally {
            if (canvas != null)
                try {
                    mHolder.unlockCanvasAndPost(canvas);
                } catch (Exception e) {
                    e.printStackTrace();
                }
        }
    }

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

    public AudioWaveView(Context context, AttributeSet attributeSet) {
        super(context, attributeSet);
        initView();
    }

    private void initView() {
        Log.d("caowj", "initView  addCallback");
        if (mHolder == null) {
            mHolder = getHolder();
            mHolder.addCallback(this);
//            Log.d("caowj", "initView  addCallback");
            setZOrderOnTop(true);// 设置画布 背景透明
            mHolder.setFormat(PixelFormat.TRANSLUCENT);
        }
        Rect frame = mHolder.getSurfaceFrame();
        mCenterY = frame.centerY();
        mWidth = frame.width();
//        Log.d("caowj", "initView  mCenterY=" + xSize);

        if (mPaint == null) {
            mPaint = new Paint();
            mPaint.setColor(ContextCompat.getColor(BaseApp.instance, mWaveColor));
            mPaint.setAntiAlias(true);
            mPaint.setStrokeWidth(2);
            mPaint.setStrokeCap(Paint.Cap.ROUND);
            mPaint.setStyle(Paint.Style.STROKE);
        }
    }

    public void drawCube(Canvas canvas) {
        canvas.drawColor(Color.TRANSPARENT, PorterDuff.Mode.CLEAR);
        int len = pointList.size();
        if (len >= 2) {
            int index = xSize - len;
//            Log.d("caowj", "drawCube  len=" + len + ",widthSize=" + widthSize + ",index=" + index);
            for (int i = index + 1; i < xSize; i++) {
                float startX = (i - 1) * gapX;
                int mIndex = i - index - 1;
                points[i * 4] = startX;
                points[i * 4 + 1] = pointList.get(mIndex);
                points[i * 4 + 2] = i * gapX;
                points[i * 4 + 3] = pointList.get(i - index);
            }
        }

        mPaint.setColor(ContextCompat.getColor(BaseApp.instance, mWaveColor));

        canvas.drawLines(points, mPaint);
        isDraw = false;
    }

    @Override
    protected void onVisibilityChanged(@NonNull View changedView, int visibility) {
        super.onVisibilityChanged(changedView, visibility);
//        Log.d("caowj", "onVisibilityChanged = " + visibility);
        if (visibility == VISIBLE) {
            isRunning = true;
        } else if (visibility == INVISIBLE) {
            isRunning = false;
        }
    }

    @Override
    protected void onSizeChanged(int w, int h, int oldw, int oldh) {
        super.onSizeChanged(w, h, oldw, oldh);
        mWidth = w;
        mCenterY = h / 2;
//        Log.w("caowj", "onSizeChanged  mCenterY=" + mCenterY + ",mWidth=" + mWidth);
    }

    @Override
    public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {
        Log.d("caowj", "surfaceChanged");
        this.mWidth = width;
        mCenterY = height / 2;

        int maxMillimeter = 25;//纵向最大毫米数（mm）(最小格代表一毫米，有多少格就是多少毫米)
        zoom = (double) height / maxMillimeter;//得到每毫米所占像素  px/mm
        double screenTotalTime = width / zoom * 0.04; //一屏绘制需要的时间（S）；走纸速度25mm/s   ==>  每mm需要0.04S
        int sampleRate = 8000 / FILTER_SIZE;//真实采样率8k，过滤后的采样率
        gapX = (float) (this.mWidth / (sampleRate * screenTotalTime));
        xSize = Math.round(this.mWidth / gapX);
        points = new float[xSize * 4];
        Log.e("caowj", "实时波形：zoom=" + zoom + ",screenTotalTime=" + screenTotalTime + ",width=" + width + ",xSize=" + xSize + ",gapX=" + gapX);
    }

    @Override
    public void surfaceCreated(SurfaceHolder holder) {
        Log.w("caowj", "surfaceCreated");
        initView();
        initViewInvisiable();
    }

    private void initViewInvisiable() {
        isRunning = true;
        Thread thread = new Thread(this);
        thread.start();
        startSingleThreadExecutor();
    }

    @Override
    public void surfaceDestroyed(SurfaceHolder holder) {
        isRunning = false;
        Log.w("caowj", "surfaceDestroyed");
    }

    private float calcRealMv(int point) {
        return (float) (point * 3.3 / 32767);
//        int magnification = 1000;//TODO 放大倍数
//        return (float) (point / magnification * 3.3 / 32767 * 1000);
    }

    private void startSingleThreadExecutor() {
        if (singleThreadExecutor != null && !singleThreadExecutor.isShutdown()) {
            singleThreadExecutor.shutdownNow();
        }
        singleThreadExecutor = new ThreadPoolExecutor(1, 1,
                0L, TimeUnit.MILLISECONDS,
                new ArrayBlockingQueue<>(10));
    }

    public void clearDatas() {
        if (pointList != null) {
            pointList.clear();
        }
        if (nativeDatas != null) {
            nativeDatas.clear();
        }
        startSingleThreadExecutor();
        isDraw = true;
        points = new float[xSize * 4];
        drawFrame();
    }
}

2、Vue实现：

<template>
  <div>
    <canvas ref="canvas" width="1140" height="300"></canvas>
    <div>
      <audio ref="audioPlayer" controls @play="startPlay" controlsList="nodownload noplaybackrate"></audio>
    </div>
  </div>
</template>

<script>
import axios from "axios";

export default {
  name: "audioWave",
  props: ['audioUrl'],
  data() {
    return {
      // audioUrl: "http://121.41.225.74:9091/mintti/app/storage/newFile/c19xqqqtd8ywqyaf8gno.wav",
      dataArray: [],
      isPlaying: false,
      interval: 100, // 设置绘制的时间间隔（单位：毫秒）
      fileData: new Int8Array(0),
      index: 0,
      mWidth: 0,
      mHeight: 0,

      audio: null,
      animationId: null,
      lastTime: 0,


      zoom: 0,
      gapX: 0.2,
      xSize: 0,
      maxMillimeter: 5 * 5,
      STEP_SIZE: 50,
      gain: 5,
      maxMidScopeY: 0,
    }
  },
  watch: {
    audioUrl(newVal) {
      // 在组件加载后获取 props 中的参数
      this.downloadAudio()
    }
  },
  mounted() {
    const ctx = this.$refs.canvas.getContext('2d')
    this.drawBg(ctx)
    this.audio = this.$refs.audioPlayer
    this.initParams()
  },
  methods: {
    initParams() {
      this.zoom = this.mHeight / this.maxMillimeter
      let screenTotalTime = this.mWidth / this.zoom * 0.04
      this.gapX = this.mWidth / (8000 / this.STEP_SIZE * screenTotalTime)
      this.xSize = Math.round(this.mWidth / this.gapX)
    },
    // 下载音频文件
    downloadAudio() {
      console.log("音频路径：" + this.audioUrl)
      axios({
        method: 'get',
        url: this.audioUrl,
        responseType: 'arraybuffer'
      }).then(res => {
        if (!res) {
          return;
        }

        console.log("音频下载成功")
        const responseData = res.data.slice(0)
        this.initAudioPlayer(res.data)

        this.dataArray = []
        this.index = 0
        this.fileData = new Int8Array(responseData);
      }).catch(error => {
        console.error('下载音频时出错:', error);
      });
    },

    initAudioPlayer(audioData) {
      // 将 ArrayBuffer 转换为 Uint8Array
      const uint8Array = new Uint8Array(audioData);
      // 创建 Blob 对象
      const blob = new Blob([uint8Array], { type: 'audio/wav' });
      // 创建音频 URL
      const audioURL = URL.createObjectURL(blob);
      // 获取 <audio> 元素
      const audioElement = this.$refs.audioPlayer;
      this.audio = audioElement
      // 设置 <audio> 元素的 src
      audioElement.src = audioURL;

      audioElement.addEventListener('canplaythrough', () => {
        // console.log('音频加载完成, 可流畅播放')
      })
      // 1、play: 播放监听。
      audioElement.addEventListener('play', (e) => {
        console.log("当前视频正在播放中" + this.isPlaying);
      })

      // 2、pause: 暂停监听。
      audioElement.addEventListener('pause', (e) => {
        this.isPlaying = false
        console.log("当前视频已暂停：" + e);
      })

      // 3、seeked: 查找结束。当用户已经移动到新位置时触发
      audioElement.addEventListener('seeked', (e) => {
        this.index = Math.round((this.audio.currentTime * 1000) / 100)
        this.dataArray = []
        console.log("进度条移动到新位置了：" + this.index);
      })

      // 4、监听音频播放完成事件
      audioElement.addEventListener('ended', () => {
        this.isPlaying = false
        console.log('播放结束')
        this.stopPlayback()
      })
    },
    startPlay() {
      if (this.audio && this.fileData.byteLength > 0) {
        // 播放音频
        this.audio.play();
        this.isPlaying = true
        this.timer()
      }
    },

    timer() {
      let curTime = new Date().getTime();
      // console.log("播放状态：" + this.isPlaying)
      // if (this.audio.currentTime > 1) {
      //   this.audio.pause()
      //   return
      // }
      if ((curTime - this.lastTime) >= this.interval && this.isPlaying) {
        // console.log("定时器执行了，耗时：" + (curTime - this.lastTime) + "   播放位置：" + this.audio.currentTime);
        this.lastTime = curTime;
        // 执行数据刷新操作
        this.refreshData();
      }

      this.animationId = window.requestAnimationFrame(() => {
        this.timer()
      });
    },

    refreshData() {
      let i = this.index
      // console.log("文件总长度：" + this.fileData.byteLength + ",,i=" + i)
      if (i * 1600 + 44 > this.fileData.byteLength) {
        this.stopAnimation()
        return
      }
      const byteArray = this.fileData.slice(i * 1600 + 44, (i + 1) * 1600 + 44);
      // console.log("文件读取范围：" + (i * 1600 + 44) + "----" + ((i + 1) * 1600 + 44) + "" + this.fileData.byteLength)
      // 创建一个新的 Uint16Array,长度为 byteArray 的一半
      let shortArray = new Int16Array(byteArray.length / 2)

      //遍历 byteArray,将每两个字节合并成一个短整型
      for (let i = 0; i < byteArray.length; i += 2) {
        shortArray[i / 2] = (byteArray[i] & 0xFF) | (byteArray[i + 1] & 0xFF) << 8;
      }


      for (let i = 0; i < shortArray.length; i += this.STEP_SIZE) {
        // console.log(i + "文件short值：" + shortArray[i])
        if (this.dataArray.length >= this.xSize && this.xSize > 0) {
          this.dataArray.shift()
        }
        this.dataArray.push(shortArray[i])
      }

      this.drawAll();
      this.index += 1;
    },
    stopPlayback() {
      console.log("停止播放-stopPlayback")
      this.isPlaying = false
      this.stopAnimation()
      const ctx = this.$refs.canvas.getContext('2d')
      ctx.clearRect(0, 0, ctx.canvas.width, ctx.canvas.height)
      this.drawBg(ctx)
    },
    stopAnimation() {
      if (this.animationId) {
        cancelAnimationFrame(this.animationId);
        this.animationId = null; // 清除引用  
      }
    },
    drawAll() {
      if (!this.isPlaying) {
        return
      }
      const ctx = this.$refs.canvas.getContext('2d')
      ctx.clearRect(0, 0, ctx.canvas.width, ctx.canvas.height)
      this.drawBg(ctx)
      this.drawWaveform(ctx)
    },
    drawBg(ctx) {
      ctx.lineWidth = 1;
      this.drawGrid(ctx, this.maxMillimeter);

      ctx.lineWidth = 2
      this.drawGrid(ctx, this.maxMillimeter / 5)
    },
    drawGrid(ctx, cols) {
      const { width, height } = ctx.canvas
      this.mWidth = ctx.canvas.width
      this.mHeight = ctx.canvas.height

      ctx.strokeStyle = '#ccc'
      const rowSpace = height / cols;

      // 画竖线
      for (let i = 0; i * rowSpace <= width; i++) {
        ctx.beginPath();
        ctx.moveTo(i * rowSpace, 0);
        ctx.lineTo(i * rowSpace, height);
        ctx.stroke();
      }

      // 画横线
      for (let i = 0; i <= cols; i++) {
        ctx.beginPath();
        ctx.moveTo(0, i * rowSpace);
        ctx.lineTo(width, i * rowSpace);
        ctx.stroke();
      }
    },
    drawWaveform(ctx) {
      ctx.beginPath()
      ctx.lineWidth = 1
      ctx.strokeStyle = '#25ebd7'

      let x = 0
      let len = this.dataArray.length;
      let index = this.xSize - len;
      for (let i = index + 1; i < this.xSize; i++) {
        const mCenterY = this.mHeight / 2;
        const y = Math.floor(this.calcRealMv(this.maxMidScopeY - this.dataArray[i - index - 1]) * this.gain * this.zoom + mCenterY);
        // console.log(`i=${i},position=${i - index - 1},,data=${this.dataArray[i - index - 1]},,y=${y},,mCenterY=${mCenterY}`)
        x = (i - 1) * this.gapX;

        ctx.lineTo(x, y)
        ctx.stroke()
      }
    },
    calcRealMv(point) {
      return point * 3.3 / 32767;
    }
  }
}
</script>
Android心电数据分析,Android 根据心电图(ECG)数据分析绘制心电图
weixin_39602976的博客
05-25 1593
Android 根据心电图(ECG)数据分析(瞎猜)绘制样子差不多的心电图项目中用到心电图分析,使用某仪器测量后得到的心电图数据,分析后放到android项目中,对数据不是很了解,所以只能是解读个大概(样子像就可以了)先来看一些数据吧!由于数据太多我们只放一部分,每一个标签有5000条数据!-21 -28 -30 -27 -24 -31 -24 -24 -28 -18 -20 -25 -28 -...
ECG Viewer
07-01
他是一个Matlab GUI 界面用于查看，处理和注释心电图数据文件，ECG Viewer提供注释数据库，ECG滤波，使用模板匹配和RR间期进行心跳检测。
ECG_Viewer:Matlab GUI，用于检查，处理和注释心电图（ECG）数据文件
05-01
宗旨 ECG Viewer是Matlab GUI，用于检查，处理和注释心电图（ECG）数据文件。 ECG Viewer提供注释数据库，ECG过滤，使用模板匹配的心跳检测以及心跳间隔（IBI或RR）过滤。 该程序最初是使用Matlab 2008b创建的。 ECG Viewer最初由Sourceforge.com托管，已被下载15,000次以上。 维基导航 联络资料 约翰·T·拉姆苏尔（John T.Ramshur）博士 领英（LinkedIn）： : 博客： http ： //www.johnramshur.com 在以下时间，该项目是我硕士论文的一部分： 生物医学工程联合计划孟菲斯大学田纳西大学健康科学中心顾问：Amy de Jongh Curry博士 执照 GNU通用公共许可证3.0
ECG-Viewer:打开并处理原始ECG数据
04-29
ECG Viewer-打开和操作原始ECG数据 作者：达科他·威廉姆斯（Dakota Williams）， ＃＃目录 1.去2. 1.2.不良线索3.批注 致谢 ## 1.设置[顶部] ### 1.1。 先决条件[返回页首]要运行此应用程序，需要Java Runtime Environment（JRE）版本1.6或更高版本。 由于使用了Java虚拟机，因此该程序与平台无关，这意味着该应用程序不依赖于客户端操作系统。 如果需要插件开发，则还需要Java Development Kit（JDK）版本1.6或更高版本。 有关插件的更多信息，请参见本文档的第2.1节。 如果需要编译源代码，则还需要JDK 1.6版或更高版本以及GNU make 。 如果不需要编译，请跳过第1.2节。 下表显示了需求和依存关系的细分。 | General Use | Plugin Developm
ECG Logger Viewer:ECG Logger Viewer 是 ECG Logger 设备的应用软件。-开源
08-08
具有 HRV 功能的新版本 3.1.0.0 心电图记录仪是一款可穿戴式心电监护仪，用于长期（长达 24 小时）心电图数据采集和分析（又名 Holter），具有心电图实时（实时）模式。 ECG Logger 项目旨在为心脏节律动态心电图提供非常低成本的开源“硬件和软件”。 硬件非常简单，基于 Arduino Nano 微控制器，带有两个用于 SD 卡大容量存储和仪表差分放大器的配套板。 它可以帮助监测心律失常综合征，如心动过缓、心动过速、超期收缩或停顿。 警告：在任何情况下，它都不能用来代替专业的体检。 ****************************************************** ************************************ 注意：首先，插入设备，然后启动 ECG Logger Viewer设备连接成功。 另见：心电图记录器：https://sourceforge.net/p/ecg-logger
ecg读取程序
10-06
这是一个ecg读取程序 可以帮你在mit bih的数据进行读取 很好用啊
vue 简易心电图组件
qq_32805013的博客
04-21 1800
vue2 canvas 简易心电图组件
ECGView心电图.zip
04-16
ECGView心电图.zip是一个针对iOS平台的项目，它主要关注的是心电图（Electrocardiogram，简称ECG或EKG）的动态绘制和心电报告的静态显示。在iOS应用开发中，这样的功能通常用于医疗健康类应用，帮助用户监测和记录...
基于Java开发的EcgView心电图查看器设计源码
10-05
例如，本文所述的EcgView心电图查看器设计源码，便是一款运用Java语言开发的工具，它为广大医疗工作者提供了方便快捷的心电图数据查看和分析的能力。该项目包含的文件类型丰富，结构清晰，体现了软件开发中对代码...
基于Android平台的Java心电图(ECG)插件设计源码
09-24
项目中还包括10个PNG图片文件，这些图片文件很可能用作应用的图标、心电图波形的显示图形或者其他界面元素。PNG是一种无损压缩的位图图形格式，非常适合用于互联网上的图像展示，因为它可以在不影响质量的情况下进行...
ecg-view software
01-16
可以查看ECG波形，开发ECG监护软件有查考价值
Open_ECG：ECG .dat文件阅读器：打开任何文件.dat并绘制ECG信号-matlab开发
05-30
在他们的搜索中，所有学生都想从 file.dat 中提取 ECG 信号数据，这样可以帮助他们所有人打开它并处理他们的信号。 用于心电信号数据库； http://www.physionet.org/physiobank/database/mitdb/
心电图模拟器（ECG Simulator2005）
09-07
心电图模拟器（ECG Simulator2005） 心电图模拟器（ECG Simulator2005）
动态心电图分析软件ECG Workstation
02-07
标准12导联心电图同步，自定义同步12导联心电图，时间向量心电图、心室晚电位、心率变异性、QT离散度、成熟的原始心电自动分析诊断算法
心电图控件
05-22
心电图控件 具有放大缩小功能 ECG 自定义的心电图控件
android 绘制三导联心电波形
最新发布
10-15
在Android上绘制三导联的心电图波形通常需要使用Canvas API、View绘制以及一些数据处理库。以下是基本步骤： 1. **创建布局**：在XML布局文件中创建一个ViewGroup，比如LinearLayout或ScrollView，用于容纳心电图...
ECGWaveView心电图
NoClay's Home
08-09 1969
ECGWaveView这是一个心电图的自定义View 项目地址：https://github.com/NoClay/UtilsDemo属性自定义属性如下: <declare-styleable name="ECGWaveView"> <attr name="tableLineColor" format="color"/> 表格线的颜色 <attr nam
ecg ekg
qq_32450111的博客
01-29 413
https://zhidao.baidu.com/question/579501091.html
vue组件
weixin_46592350的博客
06-10 1159
vue心电图
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值