c++实现PCA(BIL, BSQ, BIP三种格式数据)

最新推荐文章于 2024-05-07 15:07:40 发布
最新推荐文章于 2024-05-07 15:07:40 发布
阅读量580 收藏 5
点赞数 1
文章标签： 其他
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jikechong/article/details/80557116
版权

pca主成份分析：将协方差变形: cov(x,y) = 1/(n-1)*( 求和xi*yi - n*x*y)

BSQ格式：

 

//将协方差变形: cov(x,y) = 1/(n-1)*( 求和xi*yi - n*x*y)
 

 

 

template <typename T>   
void BSQCovAndMeanOMP(HANDLE hReadFile,ulong HW,ulong Width,ulong Height,int Bands,double* mean,double* cov,CProgressCtrl* bar)
{
	ulong readBytes = 0;
	ulong BT = Bands * sizeof(T);
	long proSize = SIZE16M;
	if(GetMemoryInfoG() >= 2) proSize = SIZE32M;
	int kernel = GetKCount();
	MALLOC2(double,meanK,kernel,Bands);
	MALLOC2(double,covK,kernel,(1 + Bands) * Bands /2); //分配上三角
	long k = proSize / BT; //BT比小于16M
	ulong offsetT = (HW - k) * sizeof(T);
	ulong KT = k * sizeof(T);
	T* pTImg = (T*)malloc(Bands * KT);
	ulong BenOffset = 0;
	ulong HW2 = HW / k;
	for (ulong y = 0; y < HW2; y++)
	{
		bar->SetPos(int(3 + y*1.0/HW2 *80));//设定进度条位置99%
		SetFilePointer(hReadFile ,BenOffset,NULL,FILE_BEGIN);
		T* pTBuf = pTImg;
		//读
		for (int i = 0; i < Bands; i++)
		{
			ReadFile(hReadFile,(LPVOID)pTBuf,KT,&readBytes,NULL);
			pTBuf += k;
			SetFilePointer(hReadFile ,offsetT,NULL,FILE_CURRENT);
		}
		#pragma omp parallel for num_threads(kernel)
		for (long ik = 0; ik < k; ik++)
		{
			int kId = omp_get_thread_num();
			double* pCovK = covK[kId];
			double* pMeanK = meanK[kId];
			T* pIBuf = pTImg + ik;
			T* pJBuf = NULL;
			for (int i = 0; i < Bands; i++)
			{
				pJBuf = pIBuf;
				for (int j = i; j < Bands; j++)
				{
					*pCovK++ += *pIBuf * *pJBuf;
					pJBuf += k;
				}
				pMeanK[i] += *pIBuf;
				pIBuf += k;
			}
		}
		BenOffset += KT;
	}
	k = HW - k * HW2;
	if (k != 0)
	{
		SetFilePointer(hReadFile ,BenOffset,NULL,FILE_BEGIN);
		KT = k * sizeof(T);
		offsetT = (HW - k) * sizeof(T);
		T* pTBuf = pTImg;
		//读
		for (int i = 0; i < Bands; i++)
		{
			ReadFile(hReadFile,(LPVOID)pTBuf,KT,&readBytes,NULL);
			pTBuf += k;
			SetFilePointer(hReadFile ,offsetT,NULL,FILE_CURRENT);
		}
		if (k < kernel) kernel = k;
		#pragma omp parallel for num_threads(kernel)
		for (long ik = 0; ik < k; ik++)
		{
			int kId = omp_get_thread_num();
			double* pCovK = covK[kId];
			double* pMeanK = meanK[kId];
			T* pIBuf = pTImg + ik;
			T* pJBuf = NULL;
			for (int i = 0; i < Bands; i++)
			{
				pJBuf = pIBuf;
				for (int j = i; j < Bands; j++)
				{
					*pCovK++ += *pIBuf * *pJBuf;
					pJBuf += k;
				}
				pMeanK[i] += *pIBuf;
				pIBuf += k;
			}
		}
	}
	free(pTImg);
	//求均值
	#pragma omp parallel for
	for (int i = 0; i < Bands; i++) 
	{
		double sum = 0;
		for (int kid = 0; kid < kernel; kid++) sum += meanK[kid][i];
		mean [i] = sum / HW;
	}
	FREE2(meanK,kernel);
	//求协方差
	HW2 = HW - 1;
	double** pCovK = (double**)malloc(kernel * sizeof(double));
	for (int kid = 0; kid < kernel; kid++) pCovK[kid] = covK[kid];  //存放的是地址
	double* pCovData = cov;
	double* p2CovData = NULL;
	for (int i = 0; i < Bands; i++)
	{
		double sum;
		double temp = HW * mean[i];
		for (int j = i; j < Bands; j++)
		{
			sum = 0;
			for (int kid = 0; kid < kernel; kid++) sum += *pCovK[kid]++;  //求和
			*pCovData++ = (sum - temp * mean[j]) / HW2;
		}
		if (i >= Bands - 1) break;
		p2CovData = cov + i + 1;
		for (int j = 0; j <= i; j++)
		{
			*pCovData++ = *p2CovData;
			p2CovData  += Bands;
		}
	}
	free(pCovK);
	FREE2(covK,kernel);
}
template <typename T>   //保存pca数据(非ENVI格式)
void BSQSavePcaDataOMP(HANDLE hReadFile,HANDLE hWriteFile,int* BLUT,ulong HW,ulong Width,ulong Height,int Bands,int reductBand,double* eiv)
{
	ulong readBytes = 0;
	ulong writeBytes = 0;
	ulong BT = Bands * sizeof(T);
	long proSize = SIZE16M;
	if(GetMemoryInfoG() >= 2) proSize = SIZE32M;
	int kernel = GetKCount();
	MALLOC2(T,KernelR,kernel,Bands);
	MALLOC2(float,KernelPcaR,kernel,reductBand);
	long k = proSize / BT; //BT比小于16M
	ulong offsetT = (HW - k) * sizeof(T);
	ulong offsetF = (HW - k) * sizeof(float);
	ulong KT = k * sizeof(T);
	ulong KF = k * sizeof(float);
	ulong BenTOffset = 0;
	ulong BenFOffset = 0;
	T* pTImg = (T*)malloc(k * BT);
	float* pFImg = (float*)malloc(KF * reductBand);
	ulong HW2 = HW / k;
	for (ulong y = 0; y < HW2; y++)
	{
		SetFilePointer(hReadFile ,BenTOffset,NULL,FILE_BEGIN);
		SetFilePointer(hWriteFile,BenFOffset,NULL,FILE_BEGIN);
		T* pTBuf = pTImg;
		for (int i = 0; i < Bands; i++)
		{
			ReadFile(hReadFile,(LPVOID)pTBuf,KT,&readBytes,NULL);
			SetFilePointer(hReadFile ,offsetT,NULL,FILE_CURRENT);
			pTBuf += k;
		}
		#pragma omp parallel for num_threads(kernel)
		for (long ik = 0; ik < k; ik++)
		{
			int kId = omp_get_thread_num();
			T* r = KernelR[kId];
			float* pcaR = KernelPcaR[kId];
			T* pIBuf = pTImg + ik;
			float* pJBuf = pFImg + ik;
			for (int i = 0; i < Bands; i++)
			{
				r[i] = *pIBuf;
				pIBuf += k;
			}
			ExcetPca<T>(r,eiv,BLUT,pcaR,Bands,reductBand);
			for(int i = 0; i < reductBand; i++)
			{
				*pJBuf = pcaR[i];
				pJBuf += k;
			}
		}
		float* pFBuf = pFImg;
		for (int i = 0; i < reductBand; i++)
		{
			WriteFile(hWriteFile,(LPVOID)pFBuf,KF,&writeBytes,NULL);
			SetFilePointer(hWriteFile ,offsetF,NULL,FILE_CURRENT);
			pFBuf += k;
		}
		BenTOffset += KT;
		BenFOffset += KF;
	}
	k = HW - k * HW2;
	if (k != 0)
	{
		SetFilePointer(hReadFile ,BenTOffset,NULL,FILE_BEGIN);
		SetFilePointer(hWriteFile,BenFOffset,NULL,FILE_BEGIN);
		KT = k * sizeof(T);
		KF = k * sizeof(float);
		offsetT = (HW - k) * sizeof(T);
		offsetF = (HW - k) * sizeof(float);
		T* pTBuf = pTImg;
		for (int i = 0; i < Bands; i++)
		{
			ReadFile(hReadFile,(LPVOID)pTBuf,KT,&readBytes,NULL);
			SetFilePointer(hReadFile ,offsetT,NULL,FILE_CURRENT);
			pTBuf += k;
		}
		if (k < kernel) kernel = k;
		#pragma omp parallel for num_threads(kernel)
		for (long ik = 0; ik < k; ik++)
		{
			int kId = omp_get_thread_num();
			T* r = KernelR[kId];
			float* pcaR = KernelPcaR[kId];
			T* pIBuf = pTImg + ik;
			float* pJBuf = pFImg + ik;
			for (int i = 0; i < Bands; i++)
			{
				r[i] = *pIBuf;
				pIBuf += k;
			}
			ExcetPca<T>(r,eiv,BLUT,pcaR,Bands,reductBand);
			for(int i = 0; i < reductBand; i++)
			{
				*pJBuf = pcaR[i];
				pJBuf += k;
			}
		}
		float* pFBuf = pFImg;
		for (int i = 0; i < reductBand; i++)
		{
			WriteFile(hWriteFile,(LPVOID)pFBuf,KF,&writeBytes,NULL);
			SetFilePointer(hWriteFile ,offsetF,NULL,FILE_CURRENT);
			pFBuf += k;
		}
	}
	FREE2(KernelR,kernel);
	FREE2(KernelPcaR,kernel);
	free(pTImg);
	free(pFImg);
}
template <typename T>   //保存pca数据（ENVI格式数据）
void BSQSaveRMPcaDataOMP(HANDLE hReadFile,HANDLE hWriteFile,int* BLUT,ulong HW,ulong Width,ulong Height,int Bands,int reductBand,double* eiv)
{
	ulong readBytes = 0;
	ulong writeBytes = 0;
	ulong RBD = sizeof(double) * reductBand;
	double* mean = (double*)malloc(RBD);
	memset(mean,0,RBD);
	int kernel = GetKCount();
	MALLOC2(T,KernelR,kernel,Bands);
	MALLOC2(float,KernelPcaR,kernel,reductBand);
	MALLOC2(double,meanK,kernel,reductBand);
	ulong BT = Bands * sizeof(T);
	long proSize = SIZE16M;
	if(GetMemoryInfoG() >= 2) proSize = SIZE32M;
	long k = proSize / BT; //BT比小于16M
	ulong offsetT = (HW - k) * sizeof(T);
	ulong offsetF = (HW - k) * sizeof(float);
	ulong KT = k * sizeof(T);
	ulong KF = k * sizeof(float);
	ulong BenTOffset = 0;
	ulong BenFOffset = 0;
	T* pTImg = (T*)malloc(k * BT);
	float* pFImg = (float*)malloc(KF * reductBand);
	ulong HW2 = HW / k;
	for (ulong y = 0; y < HW2; y++)
	{
		SetFilePointer(hReadFile ,BenTOffset,NULL,FILE_BEGIN);
		SetFilePointer(hWriteFile,BenFOffset,NULL,FILE_BEGIN);
		T* pTBuf = pTImg;
		for (int i = 0; i < Bands; i++)
		{
			ReadFile(hReadFile,(LPVOID)pTBuf,KT,&readBytes,NULL);
			SetFilePointer(hReadFile ,offsetT,NULL,FILE_CURRENT);
			pTBuf += k;
		}
		#pragma omp parallel for num_threads(kernel)
		for (long ik = 0; ik < k; ik++)
		{
			int kId = omp_get_thread_num();
			T* r = KernelR[kId];
			float* pcaR = KernelPcaR[kId];
			T* pIBuf = pTImg + ik;
			float* pJBuf = pFImg + ik;
			for (int i = 0; i < Bands; i++)
			{
				r[i] = *pIBuf;
				pIBuf += k;
			}
			ExcetPca<T>(r,eiv,BLUT,pcaR,Bands,reductBand,meanK[kId]);
			for(int i = 0; i < reductBand; i++)
			{
				*pJBuf = pcaR[i];
				pJBuf += k;
			}
		}
		float* pFBuf = pFImg;
		for (int i = 0; i < reductBand; i++)
		{
			WriteFile(hWriteFile,(LPVOID)pFBuf,KF,&writeBytes,NULL);
			SetFilePointer(hWriteFile ,offsetF,NULL,FILE_CURRENT);
			pFBuf += k;
		}
		BenTOffset += KT;
		BenFOffset += KF;
	}
	k = HW - k * HW2;
	if (k != 0)
	{
		SetFilePointer(hReadFile ,BenTOffset,NULL,FILE_BEGIN);
		SetFilePointer(hWriteFile,BenFOffset,NULL,FILE_BEGIN);
		KT = k * sizeof(T);
		KF = k * sizeof(float);
		offsetT = (HW - k) * sizeof(T);
		offsetF = (HW - k) * sizeof(float);
		T* pTBuf = pTImg;
		for (int i = 0; i < Bands; i++)
		{
			ReadFile(hReadFile,(LPVOID)pTBuf,KT,&readBytes,NULL);
			SetFilePointer(hReadFile ,offsetT,NULL,FILE_CURRENT);
			pTBuf += k;
		}
		if (k < kernel) kernel = k;
		#pragma omp parallel for num_threads(kernel)
		for (long ik = 0; ik < k; ik++)
		{
			int kId = omp_get_thread_num();
			T* r = KernelR[kId];
			float* pcaR = KernelPcaR[kId];
			T* pIBuf = pTImg + ik;
			float* pJBuf = pFImg + ik;
			for (int i = 0; i < Bands; i++)
			{
				r[i] = *pIBuf;
				pIBuf += k;
			}
			ExcetPca<T>(r,eiv,BLUT,pcaR,Bands,reductBand,meanK[kId]);
			for(int i = 0; i < reductBand; i++)
			{
				*pJBuf = pcaR[i];
				pJBuf += k;
			}
		}
		float* pFBuf = pFImg;
		for (int i = 0; i < reductBand; i++)
		{
			WriteFile(hWriteFile,(LPVOID)pFBuf,KF,&writeBytes,NULL);
			SetFilePointer(hWriteFile ,offsetF,NULL,FILE_CURRENT);
			pFBuf += k;
		}
	}
	FREE2(KernelR,kernel);
	FREE2(KernelPcaR,kernel);
	free(pTImg);
	#pragma omp parallel for
	for (int i = 0; i < reductBand; i++)
	{
		double sum = 0;
		for (int kid = 0; kid < kernel; kid++) sum += meanK[kid][i];
		mean [i] = sum / HW;
	}
	FREE2(meanK,kernel);
	//去均值
	SetFilePointer(hWriteFile,0,NULL,FILE_BEGIN);
	k = proSize / sizeof(float);
	KF = k * sizeof(float);
	pFImg = (float*)realloc(pFImg,proSize);
	HW2 = HW / k;
	ulong k1  = HW - k * HW2;
	ulong K1F = k1 * sizeof(float);
	for (int i = 0; i < Bands; i++)
	{
		for (ulong x = 0; x < HW2; x++)
		{
			ReadFile(hWriteFile,(LPVOID)pFImg,KF,&readBytes,NULL);
			#pragma omp parallel for num_threads(kernel)
			for (long ik = 0; ik < k; ik++)
			{
				float* pFBuf = pFImg + ik;
				*pFBuf = *pFBuf - mean[i];
			}
			SetFilePointer(hWriteFile ,-KF,NULL,FILE_CURRENT);
			WriteFile(hWriteFile,(LPVOID)pFImg,KF,&writeBytes,NULL);
		}
		if(k1 != 0)
		{
			ReadFile(hWriteFile,(LPVOID)pFImg,K1F,&readBytes,NULL);
			#pragma omp parallel for num_threads(kernel)
			for (long ik = 0; ik < k1; ik++)
			{
				float* pFBuf = pFImg + ik;
				*pFBuf = *pFBuf - mean[i];
			}
			SetFilePointer(hWriteFile ,-K1F,NULL,FILE_CURRENT);
			WriteFile(hWriteFile,(LPVOID)pFImg,K1F,&writeBytes,NULL);
		}
	}
	free(pFImg);
	free(mean);
}
 

 

 


                

        

        

    




    

      

        

            

              
                
                  small山炮
                
              
            

            

                关注
              
            

        

        

          
    
            
  • 
              
                
                
                
                
                    1
                
              
              
    点赞
    
            
    • 
            
  • 
              
                
                
                
              
              
    踩
    
            
    • 
            
  • 
              
                
                
                
                
                    5
                
              
              
    
                
    
                  
                    收藏
                  
                
    
              
    
              
    
                
    
                  觉得还不错?
                  
                    一键收藏
                  
                 
                
    
              
    
            
    • 
          
  • 
            
    
              
              
            
    
              
              
              
                    0
              
            
            
    评论
    
          
    • 
          
  • 
          
    • 
          
  • 
            
              
            
              
    
            
              
                
            
    
          
    • 
        

      

      










                



	

		

			

				
					
在matlab中求协方差,MATLAB如何使用cov函数计算样本数据的协方差

				
			

			

				

					weixin_29112009的博客
				

				

					03-16
					
					3978
					
				

			

		

		

			
				
MATLAB如何使用cov函数计算样本数据的协方差【语法说明】cov(X)：如果X为向量，函数返回向量的方差；如果X为m×n矩阵，则每行是一组观测值，每列是一个随机变量在各次观测时的值，共有n个随机变量，m组观测值。函数返回这n个随机变量的协方差矩阵，其对角线元素为各随机变量的方差。cov(X,Y)：相当于cov([X(:),Y(:)])。X和Y被转换为向量，分别被当作一个随机变量的观测值，函数返...

			
		

	



                

              
                



	

		

			

				
					
主成分分析pca  c++代码实现（详细注释）

				
			

			

				

					然、的博客
				

				

					05-26
					
					5463
					
				

			

		

		

			
				
参考代码：
PCA算法的原理以及c++实现（Eigen库实现）源码
（我的代码基本都来自与这个，只不过改了改输入输出和加了点注释）
参考知识点：
1、主成分分析（PCA）原理详解
2、（还有很多，基本上看了CSDN的所有pca讲解，就不继续列出了）
pca.cpp的步骤：
1、对所有样本进行中心化(去均值操作);
2、计算样本的协方差矩阵;
3、对协方差矩阵做特征值分解;
4、取最大的特征值所对应的特征向量;
5、将原样本矩阵与投影矩阵相乘: X*V即为降维后数据集X’ ;
6、输出:降维后的数据集X’
7

			
		

	



                


  
              

                


	

		

			

				
					
图像处理之PCA（C++）

					
最新发布

				
			

			

				

					qq_45045175的博客
				

				

					05-07
					
					1267
					
				

			

		

		

			
				
本文使用C++借助opencv实现了pca算法，介绍了pca原理、计算过程以及源代码的实现，主要核心是利用opencv中的cv::eigen()对协方差矩阵进行特征值和特征向量的计算，欢迎大家提出问题。

			
		

	





	

		

			

				
					
PCA原理以及算法实现

				
			

			

				

					lanyizheng blog
				

				

					07-31
					
					3272
					
				

			

		

		

			
				
一.算法介绍PCA（Princiapal Component Analysis）,主成分分析，是统计数据分析、特征提取和数据压缩的经典方法，起源于Pearson的早期工作。实际上，PCA主要作用就是将一个存在信息冗余的多维空间变成一个无信息冗余的较低维空间，是一种通用的降维方法。举个例子，从一幅数字图像中取出一个8x8的像素窗口，首先通过逐行扫描，变换到向量xx,其元素为64个像素的灰度值，在实时的

			
		

	



		

			
		



	

		

			

				
					
PCA算法的原理以及c++实现（Eigen库实现）源码

				
			

			

				

					Qer的博客
				

				

					05-14
					
					1万+
					
				

			

		

		

			
				
今天学习了PCA算法，把自己的理解写在这里，一方面希望如果理解有什么偏差，大家能给予指正，另一方面希望能和大家一起共享知识。
假设有一个多样本高维度的样本集，例如m个样本，每个样本维度为n
我们想通过降维算法来降低维度到k（0


（1）首先理解正交基分解：
我们默认一个n维向量v=（x1,x2,x3……xn）是一个n维空间的以n个单位基底（1,0,0,……），（0,1,0,0……）…

			
		

	





	

		

			

				
					
主成份分析（PCA）基本原理/步骤及其C++ 实现与优化（结合Eigen矩阵库）

				
			

			

				

					shaozhenghan的博客
				

				

					07-29
					
					2348
					
				

			

		

		

			
				
主成份分析是常用的降维方法，其他降维方法还有线性判别分析LDA，二者的区别见：https://www.cnblogs.com/pinard/p/6244265.html   简要说就是：

1.PCA将原始数据投影到方差最大的方向，LDA将数据投影到不同样本的中心点距离最大的方向。

2. PCA是无监督降维，LDA是有监督降维。

3. 若分类主要依赖均值而非方差，则LDA效果好，反之PCA效果...

			
		

	





	

		

			

				
					
c++ 实现 pca算法 详细注释

				
			

			

				

					05-26
				

			

		

		

			
				
把别人的代码改了改输入输出和加了点注释。 代码使用说明参考：https://blog.csdn.net/qq_45269116/article/details/106353433

			
		

	





	

		

			

				
					
PCA两种算法matlab+C++.zip_matlab_matlab+c++的PCA两种算法_pca c++实现

				
			

			

				

					09-14
				

			

		

		

			
				
5. 将原始数据投影到这k个主成分上，实现数据的降维。  接着，我们看C++的PCA实现。在C++中，PCA的实现可能需要手动完成上述步骤，通常需要用到线性代数库如Eigen或者BLAS/LAPACK。代码会涉及矩阵运算，包括求解...

			
		

	





	

		

			

				
					
PCA、KPCA数据降维C++实现

				
			

			

				

					08-27
				

			

		

		

			
				
PCA（主成分分析）和KPCA（核主成分分析）是两种广泛应用于数据降维的技术。在机器学习和数据分析领域，这两种方法可以帮助我们减少数据的复杂性，提高模型的效率和准确性，同时保持数据集中的关键信息。  PCA是一种...

			
		

	





	

		

			

				
					
C++实现PCA

				
			

			

				

					11-21
				

			

		

		

			
				
### C++ 实现 PCA（主成分分析）：代码解析与理论知识  #### 一、引言  主成分分析（Principal Component Analysis，PCA）是一种广泛应用于数据挖掘、图像处理、模式识别等多个领域的数据降维方法。它通过寻找数据的...

			
		

	





	

		

			

				
					
Python使用三种方法实现PCA算法

				
			

			

				

					09-21
				

			

		

		

			
				
PCA（主成分分析）是一种常用于数据降维的统计学方法，它通过线性变换将原始数据转换为一组各维度线性无关的表示，称为主成分。这些主成分是原始特征的线性组合，且第一个主成分具有最大的方差，后续的每个主成分...

			
		

	





	

		

			

				
					
PCA C++实现

				
			

			

				

					06-07
				

			

		

		

			
				
pca的c++实现的代码 啊多发点vadnvvnnvn 树挪死vniubsivu

			
		

	





	

		

			

				
					
PCA算法C++实现

				
			

			

				

					07-31
				

			

		

		

			
				
使用雅克比算法实现PCA降维

			
		

	





	

		

			

				
					
读取BIL、BSQ、BIP文件的代码

				
			

			

				

					03-16
				

			

		

		

			
				
遥感影像处理时，读取BIL、BSQ、BIP文件的代码，可以通过BIL、BSQ、BIP文件的头文件自动读取行列号等信息，以及格式，从而自动读取数据。里面有文档说明

			
		

	





	

		

			

				
					
BIL-BIP-BSQ三种影像数据格式互转工具

				
			

			

				

					06-16
				

			

		

		

			
				
BIL-BIP-BSQ三种影像数据格式互转工具BIL-BIP-BSQ三种影像数据格式互转工具BIL-BIP-BSQ三种影像数据格式互转工具BIL-BIP-BSQ三种影像数据格式互转工具BIL-BIP-BSQ三种影像数据格式互转工具BIL-BIP-BSQ三种影像数据格式互转工具BIL-BIP-BSQ三种影像数据格式互转工具BIL-BIP-BSQ三种影像数据格式互转工具BIL-BIP-BSQ三种影像数据格式互转工具BIL-BIP-BSQ三种影像数据格式互转工具BIL-BIP-BSQ三种影像数据格式互转工具BIL-BIP-BSQ三种影像数据格式互转工具BIL-BIP-BSQ三种影像数据格式互转工具BIL-BIP-BSQ三种影像数据格式互转工具BIL-BIP-BSQ三种影像数据格式互转工具BIL-BIP-BSQ三种影像数据格式互转工具BIL-BIP-BSQ三种影像数据格式互转工具BIL-BIP-BSQ三种影像数据格式互转工具BIL-BIP-BSQ三种影像数据格式互转工具BIL-BIP-BSQ三种影像数据格式互转工具BIL-BIP-BSQ三种影像数据格式互转工具BIL-BIP-BSQ三种影像数据

			
		

	





	

		

			

				
					
PCA 实现点云粗配准（python版本）

					
热门推荐

				
			

			

				

					点云侠的博客
				

				

					04-03
					
					29万+
					
				

			

		

		

			
				
python版本的主成分分析（PCA）实现点云粗配准

			
		

	





	

		

			

				
					
协方差cov(X),cov(X,Y)；变异系数c.v

				
			

			

				

					zzhe
				

				

					09-20
					
					2万+
					
				

			

		

		

			
				
目录协方差 cov(x)- x 为一个样本向量- x 为一个样本矩阵协方差 cov(x,y)变异系数 c.v
首先看看 均值，样本方差，样本协方差 公式区别

其中样本方差公式中为什么除的n-1而不是n，样本协方差同样除的是n-1而不是n，请看此处：http://blog.csdn.net/maoersong/article/details/21819957，如果除的是n，那么求的方差就不是随机抽...

			
		

	





	

		

			

				
					
协方差

				
			

			

				

					ycj125513098的博客
				

				

					01-17
					
					3712
					
				

			

		

		

			
				
１。向量的方差与协方差矩阵

cov(x) ：求向量x的方差。

cov(x)为一个数值，数值大小计算公式为S(x)。




cov(x,y) ：求向量x与y的协方差矩阵。

cov(x,y)为2*2矩阵，

[S(x)    C(x,y)

 C(y,x)  S(y) ]

２。矩阵协方差矩阵

cov(X) 

求矩阵X的协方差矩阵。diag(cov

			
		

	





	

		

			

				
					
遥感图像通用数据格式（BSQ\BIL\BIP）的理解

				
			

			

				

					m0_46387817的博客
				

				

					09-08
					
					2万+
					
				

			

		

		

			
				
**
遥感图像通用数据格式（BSQ\BIL\BIP）的理解
**
遥感图像包括多个波段，有多种数据存储格式，其通用格式有三种，即BSQ,BIL和BIP格式。
（1）BSQ（Band sequential ）：像素按波段顺序存储，即先保存第一个波段，保存完毕后再保存第二个波段，以此类推。同一波段内的像素按行列顺序存储。
优势：
①便于进行波段间的运算；
②能够直观表达图像区域的空间分布特征。

（2）BIL（Band interleaved by line ）：像素按行存储，即先保存第一个波段的第一行，再保存

			
		

	





	

		

			

				
					
用c++实现pca算法

				
			

			

				

					06-07
				

			

		

		

			
				
PCA（Principal Component Analysis）是一种经典的线性降维算法，可以用来降低数据的维度，从而更好地进行数据分析和可视化。下面是用C++实现PCA算法的示例代码：  ``` #include  #include  #include   using ...

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值