声波通信开源项SinVoice介绍三

2024-02-20 10:40
文章标签 介绍 通信 开源 声波 sinvoice

本文主要是介绍声波通信开源项SinVoice介绍三，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！


    前两篇介绍了声波验证/通信的原理和声音播放的实现，这一篇将介绍最重要，也是最难懂的东西，就是SinVoice是如何对这些数字进行编码传输的。

    因为源代码中加入了大量的难以区分的回调函数，为了阅读方便，我进行了部分的重命名和代码的整理，大家不要感到诧异。

    首先给出项目的结构：

    


    这篇文章重点介绍是Encoder类、SinGenerator类，Buffer类。

    在前面的文章中，我们了解到SinVoiceplayer是我们直接接触和使用的类，使用SinVoicePlayer.play(text)方法就可以非常容易的播放出我们想要传输的数字的对应音频信号，然后进行解析即可。在SinVoicePlayer中，是通过调用PcmPlayer的start()方法，进行播放操作的，而在pcmPlayer中，则是又调用AudioTrace来实现最终的音频播放功能。通过对AudioTrace的一层层封装，最终实现了SinVoicePlayer的简单调用。

    既然AudioTrace是最终进行音频播放的类，那么，要进行播放的数据从哪里来的呢？

    答案就是，数据来自Encoder类、SinGenerator类和Buffer类。

    下面是Encoder的代码，代码经过了整理

[java]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. /* 
  2.  * Copyright (C) 2013 gujicheng 
  3.  *  
  4.  * Licensed under the GPL License Version 2.0; 
  5.  * you may not use this file except in compliance with the License. 
  6.  *  
  7.  * If you have any question, please contact me. 
  8.  *  
  9.  ************************************************************************* 
  10.  **                   Author information                                ** 
  11.  ************************************************************************* 
  12.  ** Email: gujicheng197@126.com                                         ** 
  13.  ** QQ   : 29600731                                                     ** 
  14.  ** Weibo: http://weibo.com/gujicheng197                                ** 
  15.  ************************************************************************* 
  16.  */  
  17. package com.libra.sinvoice;  
  18.   
  19. import java.util.List;  
  20.   
  21. import com.libra.sinvoice.Buffer.BufferData;  
  22.   
  23. /** 
  24.  *  
  25.  * @ClassName: com.libra.sinvoice.Encoder 
  26.  * @Description: 编码器 
  27.  * @author zhaokaiqiang 
  28.  * @date 2014-11-16 下午1:32:17 
  29.  *  
  30.  */  
  31. public class Encoder implements SinGenerator.SinGeneratorCallback {  
  32.   
  33.     private final static String TAG = "Encoder";  
  34.     private final static int STATE_ENCODING = 1;  
  35.     private final static int STATE_STOPED = 2;  
  36.   
  37.     // index 0, 1, 2, 3, 4, 5, 6  
  38.     // circleCount 31, 28, 25, 22, 19, 15, 10  
  39.     private final static int[] CODE_FREQUENCY = { 1422, 1575, 1764, 2004, 2321,  
  40.             2940, 4410 };  
  41.     private int mState;  
  42.   
  43.     private SinGenerator mSinGenerator;  
  44.   
  45.     private EncoderCallback encoderCallback;  
  46.   
  47.     public static interface EncoderCallback {  
  48.   
  49.         void freeEncodeBuffer(BufferData buffer);  
  50.   
  51.         BufferData getEncodeBuffer();  
  52.     }  
  53.   
  54.     public Encoder(EncoderCallback callback, int sampleRate, int bits,  
  55.             int bufferSize) {  
  56.         encoderCallback = callback;  
  57.         mState = STATE_STOPED;  
  58.         mSinGenerator = new SinGenerator(this, sampleRate, bits, bufferSize);  
  59.     }  
  60.   
  61.     public final static int getMaxCodeCount() {  
  62.         return CODE_FREQUENCY.length;  
  63.     }  
  64.   
  65.     public final boolean isStoped() {  
  66.         return (STATE_STOPED == mState);  
  67.     }  
  68.   
  69.     // content of input from 0 to (CODE_FREQUENCY.length-1)  
  70.     public void encode(List<Integer> codes, int duration) {  
  71.         if (STATE_STOPED == mState) {  
  72.             mState = STATE_ENCODING;  
  73.   
  74.             mSinGenerator.start();  
  75.             for (int index : codes) {  
  76.                 if (STATE_ENCODING == mState) {  
  77.                     if (index >= 0 && index < CODE_FREQUENCY.length) {  
  78.                         // 使用正弦发生器编码  
  79.                         mSinGenerator.gen(CODE_FREQUENCY[index], duration);  
  80.                     } else {  
  81.                         LogHelper.d(TAG, "code index error");  
  82.                     }  
  83.                 } else {  
  84.                     LogHelper.d(TAG, "encode force stop");  
  85.                     break;  
  86.                 }  
  87.             }  
  88.             mSinGenerator.stop();  
  89.   
  90.         }  
  91.     }  
  92.   
  93.     public void stop() {  
  94.         if (STATE_ENCODING == mState) {  
  95.             mState = STATE_STOPED;  
  96.             mSinGenerator.stop();  
  97.         }  
  98.     }  
  99.   
  100.     @Override  
  101.     public BufferData getGenBuffer() {  
  102.         if (null != encoderCallback) {  
  103.             return encoderCallback.getEncodeBuffer();  
  104.         }  
  105.         return null;  
  106.     }  
  107.   
  108.     @Override  
  109.     public void freeGenBuffer(BufferData buffer) {  
  110.         if (null != encoderCallback) {  
  111.             encoderCallback.freeEncodeBuffer(buffer);  
  112.         }  
  113.     }  
  114. }  

    关于这个类，主要是以下几点：

    1.这个类实现了SinGenerator.SinGeneratorCallback接口，这个接口其实是SinGenerator类里面的，这个接口主要完成的数据的获取与释放，在下面的代码中我将会说明

    2.数组CODE_FREQUENCY中存放的数字分别代表从0到6对应的频率，不同的数据会根据不同的频率进行编码，circleCount 31, 28, 25, 22, 19, 15, 10 是指在编码的过程中，对应频率的正弦波在一个周期内的取样数量，每个周期的取样数量x周期总数＝总取样数。

    还记得之前的DEFAULT_GEN_DURATION＝100吗，这个变量指的就是每一个数字对应的音频持续的时间，100代表100毫秒，也就是0.1秒。我们说过，默认的采样率使用的是44.1KHZ，这是1s内采样44100次，如果需要播放100毫秒，那么就只需要采样44100/10=4410次，因为

private final static int[] CODE_FREQUENCY = { 1422, 1575, 1764, 2004, 2321,2940, 4410 };

    假如我们想给数字0编码，那么我们知道0对应的振动频率就是1422HZ，这个也是一秒钟的，如果是100ms呢？就是142.2HZ，我们使用，142.2x31=4408.2,接近4410次，所以说，我们根据想要生成的音频的频率，就能知道每一个周期内需要采样多少次，就能算出采样的间隔。因为Encoder也只是一个包装类，真正实现编码的是SinGenerator,在这个累里面，我们就可以看到很多的加密细节。

   下面是SinGenerator的代码实现

[java]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. /* 
  2.  * Copyright (C) 2013 gujicheng 
  3.  *  
  4.  * Licensed under the GPL License Version 2.0; 
  5.  * you may not use this file except in compliance with the License. 
  6.  *  
  7.  * If you have any question, please contact me. 
  8.  *  
  9.  ************************************************************************* 
  10.  **                   Author information                                ** 
  11.  ************************************************************************* 
  12.  ** Email: gujicheng197@126.com                                         ** 
  13.  ** QQ   : 29600731                                                     ** 
  14.  ** Weibo: http://weibo.com/gujicheng197                                ** 
  15.  ************************************************************************* 
  16.  */  
  17. package com.libra.sinvoice;  
  18.   
  19. import com.libra.sinvoice.Buffer.BufferData;  
  20.   
  21. /** 
  22.  *  
  23.  * @ClassName: com.libra.sinvoice.SinGenerator 
  24.  * @Description: 正弦波发生器 
  25.  * @author zhaokaiqiang 
  26.  * @date 2014-11-15 下午2:51:34 
  27.  *  
  28.  */  
  29. public class SinGenerator {  
  30.   
  31.     private static final String TAG = "SinGenerator";  
  32.   
  33.     private static final int STATE_START = 1;  
  34.     private static final int STATE_STOP = 2;  
  35.   
  36.     // 2^8时的峰值  
  37.     public static final int BITS_8 = 128;  
  38.     // 默认为2^16时的峰值  
  39.     public static final int BITS_16 = 32768;  
  40.   
  41.     // 采样率  
  42.     public static final int SAMPLE_RATE_8 = 8000;  
  43.     public static final int SAMPLE_RATE_11 = 11250;  
  44.     public static final int SAMPLE_RATE_16 = 16000;  
  45.   
  46.     public static final int UNIT_ACCURACY_1 = 4;  
  47.     public static final int UNIT_ACCURACY_2 = 8;  
  48.   
  49.     private int mState;  
  50.     private int mSampleRate;  
  51.     private int mBits;  
  52.   
  53.     private static final int DEFAULT_BITS = BITS_8;  
  54.     private static final int DEFAULT_SAMPLE_RATE = SAMPLE_RATE_8;  
  55.     private static final int DEFAULT_BUFFER_SIZE = 1024;  
  56.   
  57.     private int mFilledSize;  
  58.     private int mBufferSize;  
  59.     private SinGeneratorCallback sinGeneratorCallback;  
  60.   
  61.     public static interface SinGeneratorCallback {  
  62.   
  63.         BufferData getGenBuffer();  
  64.   
  65.         void freeGenBuffer(BufferData buffer);  
  66.     }  
  67.   
  68.     public SinGenerator(SinGeneratorCallback callback) {  
  69.         this(callback, DEFAULT_SAMPLE_RATE, DEFAULT_BITS, DEFAULT_BUFFER_SIZE);  
  70.     }  
  71.   
  72.     public SinGenerator(SinGeneratorCallback callback, int sampleRate,  
  73.             int bits, int bufferSize) {  
  74.         sinGeneratorCallback = callback;  
  75.   
  76.         mBufferSize = bufferSize;  
  77.         mSampleRate = sampleRate;  
  78.         mBits = bits;  
  79.   
  80.         mFilledSize = 0;  
  81.         mState = STATE_STOP;  
  82.     }  
  83.   
  84.     public void stop() {  
  85.         if (STATE_START == mState) {  
  86.             mState = STATE_STOP;  
  87.         }  
  88.     }  
  89.   
  90.     public void start() {  
  91.         if (STATE_STOP == mState) {  
  92.             mState = STATE_START;  
  93.         }  
  94.     }  
  95.   
  96.     /** 
  97.      * 对数字进行编码 
  98.      *  
  99.      * @param genRate 
  100.      * @param duration 
  101.      */  
  102.     public void gen(int genRate, int duration) {  
  103.         if (STATE_START == mState) {  
  104.   
  105.             // 定值16384  
  106.             int n = mBits / 2;  
  107.             int totalCount = (duration * mSampleRate) / 1000;  
  108.             double per = (genRate / (double) mSampleRate) * 2 * Math.PI;  
  109.             double d = 0;  
  110.   
  111.             LogHelper.d(TAG, "per:" + per + "___genRate:" + genRate);  
  112.             if (null != sinGeneratorCallback) {  
  113.                 mFilledSize = 0;  
  114.                 // 获取要编码的数据  
  115.                 BufferData bufferData = sinGeneratorCallback.getGenBuffer();  
  116.                 if (null != bufferData) {  
  117.                     for (int i = 0; i < totalCount; ++i) {  
  118.   
  119.                         if (STATE_START == mState) {  
  120.   
  121.                             // 算出不同点的正弦值  
  122.                             int out = (int) (Math.sin(d) * n) + 128;  
  123.   
  124.                             // 如果填充数量超过了缓冲区的大小，就重置mFilledSize，释放bufferData  
  125.                             if (mFilledSize >= mBufferSize - 1) {  
  126.                                 // free buffer  
  127.                                 bufferData.setFilledSize(mFilledSize);  
  128.                                 sinGeneratorCallback.freeGenBuffer(bufferData);  
  129.   
  130.                                 mFilledSize = 0;  
  131.                                 bufferData = sinGeneratorCallback  
  132.                                         .getGenBuffer();  
  133.                                 if (null == bufferData) {  
  134.                                     LogHelper.d(TAG, "get null buffer");  
  135.                                     break;  
  136.                                 }  
  137.                             }  
  138.   
  139.                             // 转码为byte类型并保存，& 0xff是为了防止负数转换出现异常  
  140.                             bufferData.byteData[mFilledSize++] = (byte) (out & 0xff);  
  141.                             if (BITS_16 == mBits) {  
  142.                                 bufferData.byteData[mFilledSize++] = (byte) ((out >> 8) & 0xff);  
  143.                             }  
  144.   
  145.                             d += per;  
  146.                         } else {  
  147.                             LogHelper.d(TAG, "sin gen force stop");  
  148.                             break;  
  149.                         }  
  150.                     }  
  151.                 } else {  
  152.                     LogHelper.d(TAG, "get null buffer");  
  153.                 }  
  154.   
  155.                 if (null != bufferData) {  
  156.                     bufferData.setFilledSize(mFilledSize);  
  157.                     sinGeneratorCallback.freeGenBuffer(bufferData);  
  158.                 }  
  159.                 mFilledSize = 0;  
  160.   
  161.             }  
  162.         }  
  163.     }  
  164. }  

     最主要的方法就是gen(),我们对这个方法进行详细的解析。

    1int n = mBits / 2; 在这里定义的n，在后面的代码中参与了运算，n是指我们要创建的正弦函数的峰值，就是最高点的值，mBits的值是2^16/2=32768，在这里将峰值除以二，应该是为了识别率考虑，因为在将n直接赋值为mBits的时候，发出的声音较为尖锐，识别率降低很多，所以，这里选择了mBits/2最为峰值。

    2.int totalCount = (duration * mSampleRate) / 1000;这个是在计算要循环的次数，因为duration＝100，所以采样的总次数是4410，循环执行4410次

    3.double per = (genRate / (double) mSampleRate) * 2 * Math.PI;这个per参数是用来记录在循环的过程中，每次往前步进的距离，这个是和频率相关的。我们以发出数字5为例，从Encoder类中，我们知道5对应的频率是2940HZ，如果我们要声音播放100ms，那么就需要震动294次，也就是294个正弦周期。而这294次，根据44.1KHZ的频率，也就是100ms采样4410次的频率，就可以算出在每个周期里面，需要采样4410/294=15,所以一个周期内采样数量是15次，而一个正弦周期的长度是2PI，所以，使用2PI/15＝0.4186，这个值就是这里的per值。

    4.int out = (int) (Math.sin(d) * n) + 128; 在计算出per之后，在循环中使用变量d对每次的per进行了累加，然后使用前面的计算公式，就可以计算出在采样点处对应的函数值，在完成下面的操作之后，就实现了数字的编码

// 转码为byte类型并保存，& 0xff是为了防止负数转换出现异常

bufferData.byteData[mFilledSize++] = (byte) (out & 0xff);

if (BITS_16 == mBits) {

bufferData.byteData[mFilledSize++] = (byte) ((out >> 8) & 0xff);

}


    我们看到，在保存编码的时候，使用了Buffre类，这个类是对字节数据进行存储的类，用来保存编码完成之后的字节数据，下面我们简单看下这个类的代码

[java]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. /* 
  2.  * Copyright (C) 2013 gujicheng 
  3.  *  
  4.  * Licensed under the GPL License Version 2.0; 
  5.  * you may not use this file except in compliance with the License. 
  6.  *  
  7.  * If you have any question, please contact me. 
  8.  *  
  9.  ************************************************************************* 
  10.  **                   Author information                                ** 
  11.  ************************************************************************* 
  12.  ** Email: gujicheng197@126.com                                         ** 
  13.  ** QQ   : 29600731                                                     ** 
  14.  ** Weibo: http://weibo.com/gujicheng197                                ** 
  15.  ************************************************************************* 
  16.  */  
  17. package com.libra.sinvoice;  
  18.   
  19. import java.util.concurrent.BlockingQueue;  
  20. import java.util.concurrent.LinkedBlockingQueue;  
  21.   
  22. /** 
  23.  *  
  24.  * @ClassName: com.libra.sinvoice.Buffer 
  25.  * @Description: 缓冲器 
  26.  * @author zhaokaiqiang 
  27.  * @date 2014-11-15 下午1:35:46 
  28.  *  
  29.  */  
  30. public class Buffer {  
  31.   
  32.     private final static String TAG = "Buffer";  
  33.     // 生产者队列  
  34.     private BlockingQueue<BufferData> mProducerQueue;  
  35.     // 消费者队列  
  36.     private BlockingQueue<BufferData> mConsumeQueue;  
  37.     // 缓冲区数量  
  38.     private int mBufferCount;  
  39.     // 缓冲区体积  
  40.     private int mBufferSize;  
  41.   
  42.     public Buffer() {  
  43.         this(Common.DEFAULT_BUFFER_COUNT, Common.DEFAULT_BUFFER_SIZE);  
  44.     }  
  45.   
  46.     public Buffer(int bufferCount, int bufferSize) {  
  47.   
  48.         mBufferSize = bufferSize;  
  49.         mBufferCount = bufferCount;  
  50.         mProducerQueue = new LinkedBlockingQueue<BufferData>(mBufferCount);  
  51.         // we want to put the end buffer, so need to add 1  
  52.         mConsumeQueue = new LinkedBlockingQueue<BufferData>(mBufferCount + 1);  
  53.   
  54.         // 初始化生产者队列  
  55.         for (int i = 0; i < mBufferCount; ++i) {  
  56.             try {  
  57.                 mProducerQueue.put(new BufferData(mBufferSize));  
  58.             } catch (InterruptedException e) {  
  59.                 e.printStackTrace();  
  60.             }  
  61.         }  
  62.     }  
  63.   
  64.     public void reset() {  
  65.         // 将生产者的空头结点剔除  
  66.         int size = mProducerQueue.size();  
  67.         for (int i = 0; i < size; ++i) {  
  68.             BufferData data = mProducerQueue.peek();  
  69.             if (null == data || null == data.byteData) {  
  70.                 mProducerQueue.poll();  
  71.             }  
  72.         }  
  73.   
  74.         // 将消费者中的非空数据添加到生产者当中  
  75.         size = mConsumeQueue.size();  
  76.         for (int i = 0; i < size; ++i) {  
  77.             BufferData data = mConsumeQueue.poll();  
  78.             if (null != data && null != data.byteData) {  
  79.                 mProducerQueue.add(data);  
  80.             }  
  81.         }  
  82.   
  83.         LogHelper.d(TAG, "reset ProducerQueue Size:" + mProducerQueue.size()  
  84.                 + "    ConsumeQueue Size:" + mConsumeQueue.size());  
  85.     }  
  86.   
  87.     final public int getEmptyCount() {  
  88.         return mProducerQueue.size();  
  89.     }  
  90.   
  91.     final public int getFullCount() {  
  92.         return mConsumeQueue.size();  
  93.     }  
  94.   
  95.     // 获取生产者的头结点，阻塞式  
  96.     public BufferData getEmpty() {  
  97.         return getImpl(mProducerQueue);  
  98.     }  
  99.   
  100.     // 加入到生产者中  
  101.     public boolean putEmpty(BufferData data) {  
  102.         return putImpl(data, mProducerQueue);  
  103.     }  
  104.   
  105.     // 获取消费者的头结点  
  106.     public BufferData getFull() {  
  107.         return getImpl(mConsumeQueue);  
  108.     }  
  109.   
  110.     // 加入到消费者中  
  111.     public boolean putFull(BufferData data) {  
  112.         return putImpl(data, mConsumeQueue);  
  113.     }  
  114.   
  115.     // 获取队列的头结点  
  116.     private BufferData getImpl(BlockingQueue<BufferData> queue) {  
  117.         if (null != queue) {  
  118.             try {  
  119.                 return queue.take();  
  120.             } catch (InterruptedException e) {  
  121.                 e.printStackTrace();  
  122.             }  
  123.         }  
  124.         return null;  
  125.     }  
  126.   
  127.     // 将数据加入到队列中  
  128.     private boolean putImpl(BufferData data, BlockingQueue<BufferData> queue) {  
  129.         if (null != queue && null != data) {  
  130.             try {  
  131.                 queue.put(data);  
  132.                 return true;  
  133.             } catch (InterruptedException e) {  
  134.                 e.printStackTrace();  
  135.             }  
  136.         }  
  137.         return false;  
  138.     }  
  139.   
  140.     // when mData is null, means it is end of input  
  141.     public static class BufferData {  
  142.         // 数据容器  
  143.         public byte byteData[];  
  144.         // 填充体积  
  145.         private int mFilledSize;  
  146.         // 缓冲最大体积  
  147.         private int mMaxBufferSize;  
  148.         // 静态空缓冲区  
  149.         private static BufferData sEmptyBuffer = new BufferData(0);  
  150.   
  151.         public BufferData(int maxBufferSize) {  
  152.   
  153.             mMaxBufferSize = maxBufferSize;  
  154.             mFilledSize = 0;  
  155.   
  156.             if (maxBufferSize > 0) {  
  157.                 byteData = new byte[mMaxBufferSize];  
  158.             } else {  
  159.                 byteData = null;  
  160.             }  
  161.         }  
  162.   
  163.         /** 
  164.          * 获取空的缓冲区 
  165.          *  
  166.          * @return 
  167.          */  
  168.         public static BufferData getEmptyBuffer() {  
  169.             return sEmptyBuffer;  
  170.         }  
  171.   
  172.         // 重置填充数量  
  173.         final public void reset() {  
  174.             mFilledSize = 0;  
  175.         }  
  176.   
  177.         final public int getMaxBufferSize() {  
  178.             return mMaxBufferSize;  
  179.         }  
  180.   
  181.         // 设置填充数量  
  182.         final public void setFilledSize(int size) {  
  183.             mFilledSize = size;  
  184.         }  
  185.   
  186.         final public int getFilledSize() {  
  187.             return mFilledSize;  
  188.         }  
  189.     }  
  190.   
  191. }  

    Buffer使用两个队列实现了生产者消费者模型，从而保证编译好一个，播放一个，在SinVoicePlayer类里面开了两个线程，分别对两个队列里面的数据进行管理。

    

    这个项目的Demo下载地址https://github.com/ZhaoKaiQiang/SinVoiceDemo

    原文地址：http://blog.csdn.net/zhaokaiqiang1992

这篇关于声波通信开源项SinVoice介绍三的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/727949。

相关文章

四种Flutter子页面向父组件传递数据的方法介绍

四种Flutter子页面向父组件传递数据的方法介绍

《四种Flutter子页面向父组件传递数据的方法介绍》在Flutter中,如果父组件需要调用子组件的方法,可以通过常用的四种方式实现,文中的示例代码讲解详细,感兴趣的小伙伴可以跟随小编一起学习一下... 目录方法 1：使用 GlobalKey 和 State 调用子组件方法方法 2：通过回调函数（Callb
阅读更多...
Python进阶之Excel基本操作介绍

Python进阶之Excel基本操作介绍

《Python进阶之Excel基本操作介绍》在现实中,很多工作都需要与数据打交道,Excel作为常用的数据处理工具,一直备受人们的青睐,本文主要为大家介绍了一些Python中Excel的基本操作,希望... 目录概述写入使用 xlwt使用 XlsxWriter读取修改概述在现实中，很多工作都需要与数据打交
阅读更多...
java脚本使用不同版本jdk的说明介绍

java脚本使用不同版本jdk的说明介绍

《java脚本使用不同版本jdk的说明介绍》本文介绍了在Java中执行JavaScript脚本的几种方式,包括使用ScriptEngine、Nashorn和GraalVM,ScriptEngine适用... 目录Java脚本使用不同版本jdk的说明1.使用ScriptEngine执行javascript2.
阅读更多...
Python实现NLP的完整流程介绍

Python实现NLP的完整流程介绍

《Python实现NLP的完整流程介绍》这篇文章主要为大家详细介绍了Python实现NLP的完整流程,文中的示例代码讲解详细,具有一定的借鉴价值,感兴趣的小伙伴可以跟随小编一起学习一下... 目录1. 编程安装和导入必要的库2. 文本数据准备3. 文本预处理3.1 小写化3.2 分词（Tokenizatio
阅读更多...
性能测试介绍

性能测试介绍

性能测试是一种测试方法，旨在评估系统、应用程序或组件在现实场景中的性能表现和可靠性。它通常用于衡量系统在不同负载条件下的响应时间、吞吐量、资源利用率、稳定性和可扩展性等关键指标。 为什么要进行性能测试 通过性能测试，可以确定系统是否能够满足预期的性能要求，找出性能瓶颈和潜在的问题，并进行优化和调整。 发现性能瓶颈：性能测试可以帮助发现系统的性能瓶颈，即系统在高负载或高并发情况下可能出现的问题
阅读更多...
水位雨量在线监测系统概述及应用介绍

水位雨量在线监测系统概述及应用介绍

在当今社会，随着科技的飞速发展，各种智能监测系统已成为保障公共安全、促进资源管理和环境保护的重要工具。其中，水位雨量在线监测系统作为自然灾害预警、水资源管理及水利工程运行的关键技术，其重要性不言而喻。 一、水位雨量在线监测系统的基本原理 水位雨量在线监测系统主要由数据采集单元、数据传输网络、数据处理中心及用户终端四大部分构成，形成了一个完整的闭环系统。 数据采集单元：这是系统的“眼睛”，
阅读更多...
Hadoop数据压缩使用介绍

Hadoop数据压缩使用介绍

一、压缩原则 （1）运算密集型的Job，少用压缩 （2）IO密集型的Job，多用压缩 二、压缩算法比较 三、压缩位置选择 四、压缩参数配置 1）为了支持多种压缩/解压缩算法，Hadoop引入了编码/解码器 2）要在Hadoop中启用压缩，可以配置如下参数
阅读更多...
阿里开源语音识别SenseVoiceWindows环境部署

阿里开源语音识别SenseVoiceWindows环境部署

SenseVoice介绍 SenseVoice 专注于高精度多语言语音识别、情感辨识和音频事件检测多语言识别： 采用超过 40 万小时数据训练，支持超过 50 种语言，识别效果上优于 Whisper 模型。富文本识别：具备优秀的情感识别，能够在测试数据上达到和超过目前最佳情感识别模型的效果。支持声音事件检测能力，支持音乐、掌声、笑声、哭声、咳嗽、喷嚏等多种常见人机交互事件进行检测。高效推
阅读更多...
图神经网络模型介绍（1）

图神经网络模型介绍（1）

我们将图神经网络分为基于谱域的模型和基于空域的模型，并按照发展顺序详解每个类别中的重要模型。 1.1基于谱域的图神经网络         谱域上的图卷积在图学习迈向深度学习的发展历程中起到了关键的作用。本节主要介绍三个具有代表性的谱域图神经网络：谱图卷积网络、切比雪夫网络和图卷积网络。 （1）谱图卷积网络 卷积定理：函数卷积的傅里叶变换是函数傅里叶变换的乘积，即F{f*g}
阅读更多...
金融业开源技术 术语

金融业开源技术 术语

金融业开源技术  术语 1  范围 本文件界定了金融业开源技术的常用术语。 本文件适用于金融业中涉及开源技术的相关标准及规范性文件制定和信息沟通等活动。
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2