ARM intrinsics 实战（1）：全局标定-2

最新推荐文章于 2023-11-21 20:54:11 发布
最新推荐文章于 2023-11-21 20:54:11 发布
阅读量137 收藏
点赞数
分类专栏： ARM 文章标签： arm开发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/s_trive_/article/details/131695948
版权

前言

关于全局标定的介绍以及这篇文章中的用到的部分代码的完整代码可以参考我上一篇文章，这里贴下链接：
https://blog.csdn.net/s_trive_/article/details/131548298?spm=1001.2014.3001.5502

这篇文章主要是为了测试一下三种寻址方式的快慢，以及完整的全局标定代码，另外，为了方便后续的多线程加速，会把相关的代码都放在一个函数，。

完成目标

（1）测试三种寻址方式的快慢
（2）完成完整的全局标定，并且结果无误。

三种寻址方式

三种寻址方式主要包括：
举例：假如我有一个4*4的矩阵，矩阵中的元素为1-64，一次读取四个元素
第一种寻址：1，2，3，4
第二种寻址：1，5，9，13
第三种寻址：1，2，5，6

前期准备

如果只是单纯的读取数据的话，个人觉得三种方式没有太大区别，个人认为主要的区别应该在于读取之后，后续的处理。例如：
在对图像去噪时，往往会用到33邻域，如果我要将图像中的每个像素值替换为该像素的33邻域像素值之和的均值。
考虑到寄存器是128位，数据是32位，即一次只能读取4个数据。

这块遇到了一点问题，意见不统一，我觉得应该采用以空间换时间的思路，例如：
我要对一个640480的矩阵中的每个元素的邻域进行加权求和的操作，那么我是不是可以将这个矩阵改写成一个3072008的一个矩阵，改写后矩阵的每一行就是原像矩阵中每一个像素的8个邻域像素。
个人觉得应该去改变数据结构去适应加速算法。
另外，因为项目进度的原因，目前项目的操作动都是只针对单个像素操作，不涉及邻域信息。这块只能暂时先搁置，后面有时间再来做验证，如果有大佬知道这块的机理，还望不吝赐教。

全局标定

上篇文章说过，全局标定其实就是给每个像素减去一个偏差值，这篇文章主要讲述，怎么计算偏差值，以及将计算偏差值与全局标定放在一个函数里。

数学原理

偏差值的计算公式其实就是，通过相位计算距离公式。
先贴下，相位计算距离的公式：其中，d是距离，f是频率，c是光速，ψ是相位偏移。
在这里插入图片描述
但在实际应用中，这个公式会有一点变形，这里先贴下，c的代码：

 double phase2distance(double phase, int modulation_frequency)
    {
        double unambiguous_range = 0.5 * 299792458 / (modulation_frequency * 1000);
        double coef_rad = unambiguous_range / (2 * M_PI);
        double distance = (phase + M_PI) * coef_rad;
        return distance;
    }

这里加pi的原因为，原来相位的范围是-pi-pi，加pi使其相位范围变到0-2pi，因为距离值不能为负。

汇编逻辑

定义变量（相位，频率）–加载数据–加减乘除的逻辑
注意：neon对pi的定义：
这块我没有找到相关的概念，我这里采用的是和c++中一样，定义一个常量。
还有就是再编写neon代码前，要对计算做尽可能的优化，以减少计算步骤，还有尽可能的减少除法和减法的步骤。

neon代码

我这里将上述的步骤改写为：
d=(ψ/f)*(c/4pi)
主要是因为ψ和f是传入的参数，其余的都是固定值可以私下计算后将结果作为值传入，这样就只需要进行一次除法和一次乘法。
其实这块只需要计算一次，根本用不上neon加速。但出于学习的目的，还是写一下。
直接贴代码：

void distance_offset_correction_neon(float *mat, float *result, int n, float phase, int32_t *modulation_frequency)
    {
        /// 计算偏差
        ///**********************************************************************
        //*号内代码，完全没必要采用neon实现，因为只是单个值的计算，不涉及到向量，这里仅作学习用，扩展成向量后，计算
        // 定义变量,,,,neon的变量前缀统一为_,其余部分和c相同。
        float32x4_t _c = vdupq_n_f32(299792458.0);
        float32x4_t _neon_pi = vdupq_n_f32(3.14159265358979323846);
        float32x4_t _four = vdupq_n_f32(4.f);
        float32x4_t _thousand = vdupq_n_f32(1000.0);
        float32x4_t _phase = vdupq_n_f32(phase);
        // neon中，将int32转换为float
        int32x4_t _modulation_frequency_int = vld1q_s32(modulation_frequency);
        float32x4_t _modulation_frequency_float = vcvtq_f32_s32(_modulation_frequency_int);
        // 如果是int16位，则需要先将int16扩展位int32位  int32x4_t vec1 = vmovl_s16(vget_low_s16(loaded)); int32x4_t vec2 = vmovl_s16(vget_high_s16(loaded));
        float32x4_t _coef_rad = vmulq_f32(_four, _neon_pi);
        _coef_rad = vmulq_f32(_coef_rad, _thousand);
        _coef_rad = vdivq_f32(_c, _coef_rad); // vdivq_f32(a,b)=a/b
        _phase = vaddq_f32(_phase, _neon_pi); 
        float32x4_t _distance = vdivq_f32(_phase, _modulation_frequency_float);
        _distance = vmulq_f32(_distance, _coef_rad);
        //std::cout << "--neon---------_distance-----------=" << _distance[0] <<  std::endl;
        ///***********************************************************************
        全局标定
        for (int i = 0; i < n; i += 4)
        {
            float32x4_t mat_vec = vld1q_f32(mat + i);
            float32x4_t result_vec = vsubq_f32(mat_vec, _distance);
            vst1q_f32(result + i, result_vec);
            //std::cout << "---------------result= " << std::endl<< " " << *(result+i) << std::endl;
        }
    }

已测试，与c++的结果一致。
下面贴下完整代码，随着代码量的逐渐增加，为了方便后续的管理，以后就要写结构了。
总体的工作量比较简单，目前代码结构总体上就两个部分，一个是主函数，一个是算法库。
算法库部分“
algorithm_neon.h

#include <arm_neon.h>
#include "opencv2/opencv.hpp"
#include <stdio.h>


namespace tof_neon
{
    void distance_offset_correction_c(cv::Mat m1, float scalar, cv::Mat result, float phase, int modulation_frequency);
    void distance_offset_correction_neon(float *mat, float *result, int n, float phase, int32_t *modulation_frequency);
}

algorithm_neon.cpp

 #include <arm_neon.h>
#include <algorithm_neon.h>

float c = 299792458.0;
float neon_pi = 3.14159265358979323846;

namespace tof_neon
{
    void distance_offset_correction_c(cv::Mat m1, float scalar, cv::Mat result, float phase, int modulation_frequency)
    {
        // 计算偏差值
        double unambiguous_range = 0.5 * 299792458 / (modulation_frequency * 1000);
        double coef_rad = unambiguous_range / (2 * M_PI);
        double distance = (phase + M_PI) * coef_rad;
        //std::cout << "--neon---------_distance-----------=" << distance <<  std::endl;
        // 全局标定
        for (int i = 0; i < m1.rows; i++) // 矩阵行数循环
        {
            for (int j = 0; j < m1.cols; j++) // 矩阵列数循环
            {
                result.at<float>(i, j) = m1.at<float>(i, j) - distance;
            }
        }
        // for (int i = 0; i < 20; i += 4)
        // {
        //     std::cout << "---------------result= " << std::endl<< " " << result.at<float>(0, i)<< std::endl;
        // }
    }

    void distance_offset_correction_neon(float *mat, float *result, int n, float phase, int32_t *modulation_frequency)
    {
        /// 计算偏差
        ///**********************************************************************
        //*号内代码，完全没必要采用neon实现，因为只是单个值的计算，不涉及到向量，这里仅作学习用，扩展成向量后，计算
        // 定义变量,,,,neon的变量前缀统一为_,其余部分和c相同。
        float32x4_t _c = vdupq_n_f32(299792458.0);
        float32x4_t _neon_pi = vdupq_n_f32(3.14159265358979323846);
        float32x4_t _four = vdupq_n_f32(4.f);
        float32x4_t _thousand = vdupq_n_f32(1000.0);
        float32x4_t _phase = vdupq_n_f32(phase);
        // neon中，将int32转换为float
        int32x4_t _modulation_frequency_int = vld1q_s32(modulation_frequency);
        float32x4_t _modulation_frequency_float = vcvtq_f32_s32(_modulation_frequency_int);
        // 如果是int16位，则需要先将int16扩展位int32位  int32x4_t vec1 = vmovl_s16(vget_low_s16(loaded)); int32x4_t vec2 = vmovl_s16(vget_high_s16(loaded));
        float32x4_t _coef_rad = vmulq_f32(_four, _neon_pi);
        _coef_rad = vmulq_f32(_coef_rad, _thousand);
        _coef_rad = vdivq_f32(_c, _coef_rad); // vdivq_f32(a,b)=a/b
        _phase = vaddq_f32(_phase, _neon_pi); 
        float32x4_t _distance = vdivq_f32(_phase, _modulation_frequency_float);
        _distance = vmulq_f32(_distance, _coef_rad);
        //std::cout << "--neon---------_distance-----------=" << _distance[0] <<  std::endl;
        ///***********************************************************************
        全局标定
        for (int i = 0; i < n; i += 4)
        {
            float32x4_t mat_vec = vld1q_f32(mat + i);
            float32x4_t result_vec = vsubq_f32(mat_vec, _distance);
            vst1q_f32(result + i, result_vec);
            //std::cout << "---------------result= " << std::endl<< " " << *(result+i) << std::endl;
        }
        // for (int i = 0; i < 20; i += 4)
        // {
        //     std::cout << "---------------result= " << std::endl<< " " << *(result+i) << std::endl;
        // }
    }
}

main.cpp

#include <arm_neon.h>
#include <iostream>
#include "algorithm_neon.h"



int main()
{
	// 读入数据
	static int count = 0;
	cv::Mat m1(640, 480, CV_32FC1);
	cv::Mat m2(640, 480, CV_32FC1);
	cv::Mat m3(640, 480, CV_32FC1);
	float a = 1.0;
	for (int i = 0; i < m1.rows; i++) // 矩阵行数循环
	{
		for (int j = 0; j < m1.cols; j++) // 矩阵列数循环
		{

			m1.at<float>(i, j) = a+3000.0;
			m2.at<float>(i, j) = 3065.0 - a;
			m3.at<float>(i, j) = 1.0;
			a = a + 1.0;
		}
	}
	// std::cout << "M1= " << std::endl << " " << m1 << std::endl;
	// std::cout << "M2= " << std::endl << " " << m2 << std::endl;
	// std::cout << "M3= " << std::endl << " " << m3 << std::endl;

	float *ptr_m1 = (float *)m1.data;
	float *ptr_m2 = (float *)m2.data;
	float *ptr_m3 = (float *)m3.data;
	float scalar = 100.0;
    int x=100;
    int32_t *ptr_fre = reinterpret_cast<int32_t*>(&x);
	// 全局标定
	bool test_c = false;
	if (test_c == true)
	{
		for (int i = 0; i < 1; i++)
		{
			//--c
			double t2_c = (double)cv::getTickCount(); // 测时间
			tof_neon::distance_offset_correction_c(m1,scalar, m3,1.0,100);
			t2_c = (double)cv::getTickCount() - t2_c;
			double time2_c = (t2_c * 1000.) / ((double)cv::getTickFrequency());
			std::cout << "--cccccc--------------------------------------time=" << time2_c << " ms. " << std::endl;
		}
	}
	else
	{
		for (int i = 0; i < 1; i++)
		{
			double t2_neon = (double)cv::getTickCount(); // 测时间
			// distance_offset_correction_neon(m1,scalar,m2,64);
			tof_neon::distance_offset_correction_neon(ptr_m1, ptr_m3, 307200,1.0,ptr_fre);
			t2_neon = (double)cv::getTickCount() - t2_neon;
			double time2_neon = (t2_neon * 1000.) / ((double)cv::getTickFrequency());
			std::cout << "--neon--------------------------------------time=" << time2_neon << " ms. " << std::endl;
			// std::cout << "---------------M2= " << std::endl << " " << m2 << std::endl;
			std::cout << "---------------ptr_M3= " << std::endl<< " " << *ptr_m3 << std::endl;
		}
	}
	return 0;
}

遇到的问题

(1)目前遇到的，neon中加载和保存数据，参数都是指针的形式。例如vld1q_s32函数。

(2)c++中的类型转换，除了强制转换外，还有以下几种转换方式。
在这里插入图片描述
（3）neon中的类型转换
上面代码中的int转float，感觉不是很有必要，完全可以直接传入想要的类型的参数。
但出于学习的角度，还是贴一下：
上文中贴了 int32转float32的代码，这块其实要注意下，不同类型所占的字节数，这里因为恰好int32 和float32 所占的字节数都是4，所以也就不涉及其他的转换。
贴下，不同类型所占的字节数。
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

风花落
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
【汇编优化】ARM Intrinsic优化
walkingMa的专栏
10-27 814
1、入门介绍 https://blog.csdn.net/sunty2016/article/details/79857825 2、intrinsic头及编译 http://infocenter.arm.com/help/index.jsp?topic=/com.arm.doc.dht0002a/ch01s04s02.html Introducing NEON Development Articl...
【优化系列】ARM优化之Intrinsic汇编方法
CSDN明星博主，认证博客专家，视频、Matlab领域优质创作者。
09-16 1006
DATE: 2020.9.16 文章目录1、参考2、前言3、入门知识4、arm intrinsic头及编译方法5、arm intrinsic数据类型及指令介绍6、指令查找手册 1、参考 【arm】arm neon intrinsic方式编写arm32位汇编 2、前言 3、入门知识 4、arm intrinsic头及编译方法 http://infocenter.arm.com/help/index.jsp?topic=/com.arm.doc.dht0002a/ch01s04s02.html Introd
【知识分享】数字图像相关方法（DIC）：XTDIC三维全场应变测量设备标定方法介绍
ROGER_MM的博客
09-20 1100
新拓三维DIC应变测量产品标定方法介绍，自主研发的DIC软件具有多介质校正功能，可消除通过不同介质之后对实验结果的影响，可实现热浪对畸变影响的控制，振动环境下影响的消除，滤光等，保证实验结果的准确性。
使用freemaster对嵌入式MCU内部全局变量进行标定（自动化）
weixin_43153912的博客
03-16 943
之前挑选MCU内部的标定方案时，大佬告知了一个方案，NXP芯片提供的一个免费标定MCU内部全局变量的软件工具freemaster（只限于NXP的芯片方案），虽然我后续找到了完全不受芯片限制的方案，但是还是有必要记录一下，也许后面还会用到以上代码只是简单写了实现，没有做相关的捕获异常，实际跑起来会有相关问题，仅提供思路给诸位参考，具体信息，建议诸位去参考freemaster相关的英文帮助文档。
ARM intrinsics 实战（1）：全局标定-1
s_trive_的博客
07-12 197
全局标定的数学逻辑很简单，就是给距离矩阵减去一个固定偏差。固定偏差有相应的计算方法。类似于A=B-offset;本项目的数据类型采用的是float32位，处理器是128位。总体完成目标：（1）实测三种寻址方式的快慢。寻址方式有三种，一种是按行读取，一种是按列读取，一种是按小矩阵读取。（2）完成全局标定的ARM intrinsics优化本文目标：跑通ARM intrinsics，并且结果无误。
ARM架构NEON intrinsic函数学习笔记（一）
最新发布
qq_45642593的博客
11-21 144
Neon指令操作的寄存器有两种，一种是128位的寄存器，一种是64位的寄存器（其中64位的寄存器其实就是128位的寄存器没有使用高位的64位而已，其实都是128位的寄存器）。所以以128位寄存器举例的话，一个neon指令，可以simd同时处理16个8bit数据、4个32bit数据、2个64bit数据。其中intrinsic函数是对neon指令的封装，方便使用，连着使用的性能相差不大，但都比手写neon汇编代码带来的性能要差一些。运算操作的最小数据，有8位、16位、32位等。rigister：寄存器。
投影仪标定全局单应矩阵
穿拖鞋的都是大佬
06-19 786
标定步骤： （1）相机和投影仪摆好角度，将打印棋盘贴到白板上。 （2）相机拍摄仅带有打印棋盘的白板，图片命名为“camera1.jpg”；再将投影仪打开，将棋盘图片投射到白板上，相机拍摄投射的棋盘图片，命名为“projector.jpg”； （3）移动白板，改变其相对相机-投影仪的相对位置，重复（2）步骤，不过命名.2jpg; （4）拍摄十组图片后，将cameraX.jpg保存在“cameraCalibdata.txt”,将projectorX。jpg保存到“projectCalibdata.txt”； （
常用NEON 内置函数记录备用
热门推荐
VivienFu的专栏
12-15 2万+
float32x4_t _sum1 = vld1q_f32(outptr);//load outptr地址起始的4个float数据到_sum1 float32x4_t _sum2 = vdupq_n_f32(0.f);//声明_sum2,存储的四个float32都初始化为0 float32x4_t _r02 = vextq_f32(_r00, _r00n, 2)
ARM Neon Intrinsics 学习指北：从入门、进阶到学个通透
tiexieyi9463的博客
03-24 1023
本文同步发表于GiantPandaCV公众号，未经作者允许严禁转载 前言 Neon是ARM平台的向量化计算指令集，通过一条指令完成多个数据的运算达到加速的目的，常用于AI、多媒体等计算密集型任务。 本文主要是一篇对ARM官方资料的导读。笔者根据自己Neon学习经历，将这些资料按照逻辑进行组织，以期减少读者的学习成本。 本文讨论的是Neon 的intrinsics，而非assembly。intrinsics是以类似调用C语言函数的方法调用Neon，并由编译器生成最终的二进制代码，assembly.
利用ARM NEON intrinsic优化常用数学运算
姚光超的专栏
04-14 1万+
ARM NEON是arm平台下的SIMD指令集，利用好这些指令可以使程序获得很大的速度提升。不过对很多人来说，直接利用汇编指令优化代码难度较大，这时就可以利用ARM NEON intrinsic指令，它是底层汇编指令的封装，不需要用户考虑底层寄存器的分配，但同时又可以达到原始汇编指令的性能。 所有的intrinsic指令可以参考博客《ARM Neon Intrinsics各函数介绍》，本...
arm-linux-gnueabihf.tar.gz arm-linux-gnueabihf编译链
03-26
arm-linux-gnueabihf编译链 实测可用，例如德克萨斯的OK系列，如果有问题欢迎在下面留言
NIID-Net:“NIID-Net”的代码
05-30
依赖关系 Python 3.5 PyTorch 0.3.1（如果您使用 PyTorch > 0.3.1，请阅读） 火炬视觉 0.2.1 0.1.8.9 我们为其他依赖项提供了一个 requirements.txt 文件。... |---intrinsics_final | |---images
gcc-arm-none-eabi-6-2017-q1-update-win32.exe|gcc-arm-none-eabi-6-2017-q1-update-win32.exe
09-15
All GCC 6 features, plus latest ...+ Arm PURECODE support for Armv7-M and Armv8-M Mainline + Co-processor intrinsics support + Cortex-M23 and Cortex-M33 support + -mthumb optional for Cortex-M devices
gcc-arm-none-eabi-6-2017-q1-update-linux.tar.bz2
09-15
All GCC 6 features, plus latest ...+ Arm PURECODE support for Armv7-M and Armv8-M Mainline + Co-processor intrinsics support + Cortex-M23 and Cortex-M33 support + -mthumb optional for Cortex-M devices
Arm Neon Intrinsics Reference
02-11
2021Q2
matlab多摄像头标定,一种多摄像机系统标定方法与流程
weixin_39751391的博客
03-26 385
本发明属于机器视觉领域，特别涉及一种多摄像机系统标定方法。背景技术：多摄像机系统在场景重建、运动捕捉和工业测量等领域有着广泛应用，其中一个关键问题是系统的全局标定，确定各个摄像机的内外参数。但对于不同的应用场合，多摄像机排布规则不尽相同，可能会出现邻近摄像机无公共视场的情况。而传统的全局标定方法需要摄像机间存在一定的公共视场，同时标靶需置于摄像机景深之内，限制了其应用范围。对于聚焦较远的摄像机，往...
NEON快速入门
qq_43049432的博客
09-13 935
NEON快速入门
ARM NEON Intrinsics示例
weixin_43274174的博客
06-17 257
[code=csharp] #include <stdio.h> #include <arm_neon.h> int main() { float arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; int len = sizeof(arr) / sizeof(arr[0]); int dim_x4 = len / 4; int left_x4 = len % 4; float *p = arr; // 创建新的指针p指向数组首元素地址,p与arr
ARM架构下使用NEON向量化指令集入门基础
weixin_51568079的博客
10-22 1605
NEON intrinsic
NEON intrinsics not available with the soft-float ABI
06-09
这是一个关于ARM架构软件开发中的问题。NEON是ARM架构中的一种SIMD指令集，可以加速向量操作。soft-float ABI是一种使用软件实现浮点运算的ABI，不支持硬件浮点运算。因此，在使用soft-float ABI时，无法使用NEON...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值