morse

最新推荐文章于 2024-01-09 09:58:11 发布
最新推荐文章于 2024-01-09 09:58:11 发布
阅读量789 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/nan_009/article/details/44683593
版权 
#include "evaluator.h"
#include "integralline.h"

using namespace std;

extern VTK vtk;
extern vector<CriticalPoint> criticalpoints, minpoints, saddles1, saddles2, maxpoints;
vector<Arcline*> Saddle2MaxMS1, Saddle1MinMS1, Saddle1MaxMS1;
extern multimap<Vertex*, Arcline*> mapVtx2Arc;

bool isBackground(Vector3D pos) {
	DataIndex idx;
	signed char bgflag;
	
	idx.x=int(pos.x+0.5); idx.y=int(pos.y+0.5); idx.z=int(pos.z+0.5);
	bgflag = vtk.bgflag[idx.x+vtk.dimX*idx.y+vtk.dimY*idx.z];
	if (bgflag == FLAGBG || bgflag == FLAGBORDER)
		return true;
	/*

	idx.x=pos.x; idx.y=pos.y; idx.z=pos.z;
	bgflag = vtk.bgflag[idx.x+vtk.dimX*idx.y+vtk.dimY*idx.z];
	if (bgflag == FLAGBG || bgflag == FLAGBORDER)
		return true;
	idx.x=pos.x+1; idx.y=pos.y; idx.z=pos.z;
	bgflag = vtk.bgflag[idx.x+vtk.dimX*idx.y+vtk.dimY*idx.z];
	if (bgflag == FLAGBG || bgflag == FLAGBORDER)
		return true;
	idx.x=pos.x; idx.y=pos.y+1; idx.z=pos.z;
	bgflag = vtk.bgflag[idx.x+vtk.dimX*idx.y+vtk.dimY*idx.z];
	if (bgflag == FLAGBG || bgflag == FLAGBORDER)
		return true;
	idx.x=pos.x+1; idx.y=pos.y+1; idx.z=pos.z;
	bgflag = vtk.bgflag[idx.x+vtk.dimX*idx.y+vtk.dimY*idx.z];
	if (bgflag == FLAGBG || bgflag == FLAGBORDER)
		return true;
	idx.x=pos.x; idx.y=pos.y; idx.z=pos.z+1;
	bgflag = vtk.bgflag[idx.x+vtk.dimX*idx.y+vtk.dimY*idx.z];
	if (bgflag == FLAGBG || bgflag == FLAGBORDER)
		return true;
	idx.x=pos.x+1; idx.y=pos.y; idx.z=pos.z+1;
	bgflag = vtk.bgflag[idx.x+vtk.dimX*idx.y+vtk.dimY*idx.z];
	if (bgflag == FLAGBG || bgflag == FLAGBORDER)
		return true;
	idx.x=pos.x; idx.y=pos.y+1; idx.z=pos.z+1;
	bgflag = vtk.bgflag[idx.x+vtk.dimX*idx.y+vtk.dimY*idx.z];
	if (bgflag == FLAGBG || bgflag == FLAGBORDER)
		return true;
	idx.x=pos.x+1; idx.y=pos.y+1; idx.z=pos.z+1;
	bgflag = vtk.bgflag[idx.x+vtk.dimX*idx.y+vtk.dimY*idx.z];
	if (bgflag == FLAGBG || bgflag == FLAGBORDER)
		return true;*/
	return false;
}

#define MAXSTEP 0.1
#define EPS 1e-14
void Arcline::Connect2SaddleToMaxDiscrete() {
	Point3D p, testp;
	Vector3D dir, pos, dstep;
	double pval, testval, step, l;
	double dist;
	unsigned int path,i,j,num,dimX=vtk.dimX, dimY=vtk.dimY, dimZ=vtk.dimZ;
	LineSeg* pseg;
	for (path=0; path<2; ++path) {
		clear();
		pseg = new LineSeg;
		LineSeg& seg = *pseg;
		pos.x=start->x; pos.y=start->y; pos.z=start->z;
		seg.push_back(pos);
		num=0;
		p.Set(start->x,start->y,start->z);
		testp.Set(start->x,start->y,start->z);
		CriticalPoint cp = (*start);
		cp.Classify();
		dir = cp.axis;
		if (path>0) {
			dir.x=-dir.x; dir.y=-dir.y; dir.z=-dir.z;
		}
		while (1) {
			pos.x = p.x+dir.x*MAXSTEP;
			pos.y = p.y+dir.y*MAXSTEP;
			pos.z = p.z+dir.z*MAXSTEP;
			if (pos.x < 0 || pos.x > dimX-1 ||
				pos.y < 0 || pos.y > dimY-1 ||
				pos.z < 0 || pos.z > dimZ-1)
			{
				break;
			}
			pval = EvaluateVal(p);
			step = MAXSTEP;
			while (step>=EPS) {
				pos.x = p.x+dir.x*step;
				pos.y = p.y+dir.y*step;
				pos.z = p.z+dir.z*step;
				testp.Update(pos.x, pos.y, pos.z);
				testval = EvaluateVal(testp);
				step*=0.618;
				if (testval > pval) {
					pos.x = p.x+dir.x*step;
					pos.y = p.y+dir.y*step;
					pos.z = p.z+dir.z*step;
					p.Update(pos.x,pos.y,pos.z);
					if (pval>=EvaluateVal(p)) {
						p.Update(testp.x,testp.y,testp.z);
					}
					dir = EvaluateGradient(p);
					l=NORM2(dir.x,dir.y,dir.z);
					if (l>0) {
						l=1.0/sqrt(l);
						dir.x*=l; dir.y*=l; dir.z*=l;
					}
					break;
				}
			}
			// Reach a max point
			if (step < EPS) {
				dist = MAXSTEP;
				for (i=0; i<maxpoints.size(); ++i) {
					dstep.x=maxpoints[i].x-p.x;
					dstep.y=maxpoints[i].y-p.y;
					dstep.z=maxpoints[i].z-p.z;
					if (NORM2(dstep.x,dstep.y,dstep.z)<dist) {
						j=i;
						dist = NORM2(dstep.x,dstep.y,dstep.z);
					}
				}
				// connect to the max
				if (dist<MAXSTEP) {
					pos.x=maxpoints[j].x;
					pos.y=maxpoints[j].y;
					pos.z=maxpoints[j].z;
					seg.push_back(pos);
				}
				else {
					CriticalPoint newmax;
					newmax.x=pos.x; newmax.y=pos.y; newmax.z=pos.z;
					newmax.type=CriticalPoint::Max;
					maxpoints.push_back(newmax);
					criticalpoints.push_back(newmax);
					seg.push_back(pos);
					printf(" %.16f,%.16f,%.16f\n",pos.x,pos.y,pos.z);
				}
				break;
			}
			else {
				dstep.x=seg[num].x-pos.x;
				dstep.y=seg[num].y-pos.y;
				dstep.z=seg[num].z-pos.z;
				if (NORM2(dstep.x,dstep.y,dstep.z)>MAXSTEP*MAXSTEP) {
					seg.push_back(pos);
					++num;
				}
			}
		}
		addSeg(pseg);
	}
}

void Arcline::Connect2SaddleToMax() {
	Point3D p, testp;
	Vector3D dir, pos, dstep;
	double pval, testval, step, l;
	double dist;
	unsigned int path,i,j,num,dimX=vtk.dimX, dimY=vtk.dimY, dimZ=vtk.dimZ;
	LineSeg* pseg;
	CriticalPoint* cp = (CriticalPoint*)start;
	cp->Classify();
//	printf("%f %f %f\n", cp->axis.x, cp->axis.y, cp->axis.z);
	for (path=0; path<2; ++path) {
		pseg = new LineSeg;
		LineSeg& seg = *pseg;
		pos.x=((CriticalPoint*)start)->x; pos.y=((CriticalPoint*)start)->y; pos.z=((CriticalPoint*)start)->z;
		seg.push_back(pos);
		num=0;
		p.Set(pos.x,pos.y,pos.z);
		testp.Set(pos.x,pos.y,pos.z);
		dir = cp->axis;
		if (path>0) {
			dir.x=-dir.x; dir.y=-dir.y; dir.z=-dir.z;
		}
		while (1) {
			pos.x = p.x+dir.x*MAXSTEP;
			pos.y = p.y+dir.y*MAXSTEP;
			pos.z = p.z+dir.z*MAXSTEP;
			if (pos.x < 0 || pos.x > dimX-1 ||
				pos.y < 0 || pos.y > dimY-1 ||
				pos.z < 0 || pos.z > dimZ-1)
			{
				break;
			}
			pval = EvaluateVal(p);
			step = MAXSTEP;
			while (step>=EPS) {
				pos.x = p.x+dir.x*step;
				pos.y = p.y+dir.y*step;
				pos.z = p.z+dir.z*step;
				testp.Update(pos.x, pos.y, pos.z);
				testval = EvaluateVal(testp);
				step*=0.618;
				if (testval > pval) {
					pos.x = p.x+dir.x*step;
					pos.y = p.y+dir.y*step;
					pos.z = p.z+dir.z*step;
					p.Update(pos.x,pos.y,pos.z);
					if (pval>=EvaluateVal(p)) {
						p.Update(testp.x,testp.y,testp.z);
					}
					dir = EvaluateGradient(p);
					l=NORM2(dir.x,dir.y,dir.z);
					if (l>0) {
						l=1.0/sqrt(l);
						dir.x*=l; dir.y*=l; dir.z*=l;
					}
					break;
				}
			}
			// Reach a max point
			if (step < EPS) {
				dist = MAXSTEP;
				for (i=0; i<maxpoints.size(); ++i) {
					dstep.x=maxpoints[i].x-p.x;
					dstep.y=maxpoints[i].y-p.y;
					dstep.z=maxpoints[i].z-p.z;
					if (NORM2(dstep.x,dstep.y,dstep.z)<dist) {
						j=i;
						dist = NORM2(dstep.x,dstep.y,dstep.z);
					}
				}
				// connect to the max
				if (dist<MAXSTEP) {
					pos.x=maxpoints[j].x;
					pos.y=maxpoints[j].y;
					pos.z=maxpoints[j].z;
					seg.push_back(pos);
				}
				else {
					//CriticalPoint newmax;
					//newmax.x=pos.x; newmax.y=pos.y; newmax.z=pos.z;
					//newmax.type=CriticalPoint::Max;
					//maxpoints.push_back(newmax);
					//criticalpoints.push_back(newmax);
					//seg.push_back(pos);
					seg.clear();
				//	printf(" %.16f,%.16f,%.16f\n",pos.x,pos.y,pos.z);
				}
				break;
			}
			else {
				dstep.x=seg[num].x-pos.x;
				dstep.y=seg[num].y-pos.y;
				dstep.z=seg[num].z-pos.z;
				if (NORM2(dstep.x,dstep.y,dstep.z)>MAXSTEP*MAXSTEP) {
					seg.push_back(pos);
					++num;
				}
			}
		}
		addSeg(pseg);
	}
}


void Arcline::Connect1SaddleToMaxDiscrete() {
	Point3D p, testp;
	Vector3D dir, pos, dstep;
	Matrix3x3 hesse,V;
	double pval, testval, step, l, diag[3];
	double dist;
	unsigned int path,i,j,num,dimX=vtk.dimX, dimY=vtk.dimY, dimZ=vtk.dimZ;
	LineSeg* pseg;

	for (path=0; path<2; ++path) {
		clear();
		pseg = new LineSeg;
		LineSeg& seg = *pseg;
		CriticalPoint point = (*start);
		pos.x=point.x; pos.y=point.y; pos.z=point.z;
		seg.push_back(pos);
		num=0;
		p.Set(point.x,point.y,point.z);
		testp.Set(point.x,point.y,point.z);
		hesse = EvaluateHesse(p);
		hesse.SVD(V, diag);
		i=0;
		if (diag[1]>diag[0])
			i=1;
		if (diag[2]>diag[i])
			i=2;
		dir.x=V.val[0][i];
		dir.y=V.val[1][i];
		dir.z=V.val[2][i];
		if (path>0) {
			dir.x=-dir.x; dir.y=-dir.y; dir.z=-dir.z;
		}
		while (1) {
			pos.x = p.x+dir.x*MAXSTEP;
			pos.y = p.y+dir.y*MAXSTEP;
			pos.z = p.z+dir.z*MAXSTEP;
			if (pos.x < 0 || pos.x > dimX-1 ||
				pos.y < 0 || pos.y > dimY-1 ||
				pos.z < 0 || pos.z > dimZ-1)
			{
				break;
			}
			pval = EvaluateVal(p);
			step = MAXSTEP;
			while (step>=EPS) {
				pos.x = p.x+dir.x*step;
				pos.y = p.y+dir.y*step;
				pos.z = p.z+dir.z*step;
				testp.Update(pos.x, pos.y, pos.z);
				testval = EvaluateVal(testp);
				step*=0.618;
				if (testval > pval) {
					pos.x = p.x+dir.x*step;
					pos.y = p.y+dir.y*step;
					pos.z = p.z+dir.z*step;
					p.Update(pos.x,pos.y,pos.z);
					if (pval>=EvaluateVal(p)) {
						p.Update(testp.x,testp.y,testp.z);
					}
					dir = EvaluateGradient(p);
					l=NORM2(dir.x,dir.y,dir.z);
					if (l>0) {
						l=1.0/sqrt(l);
						dir.x*=l; dir.y*=l; dir.z*=l;
					}
					break;
				}
			}
			// Reach a max point
			if (step < EPS) {
				dist = MAXSTEP;
				for (i=0; i<maxpoints.size(); ++i) {
					dstep.x=maxpoints[i].x-p.x;
					dstep.y=maxpoints[i].y-p.y;
					dstep.z=maxpoints[i].z-p.z;
					if (NORM2(dstep.x,dstep.y,dstep.z)<dist) {
						j=i;
						dist = NORM2(dstep.x,dstep.y,dstep.z);
					}
				}
				// connect to the max
				if (dist<MAXSTEP) {
					pos.x=maxpoints[j].x;
					pos.y=maxpoints[j].y;
					pos.z=maxpoints[j].z;
					seg.push_back(pos);
				}
				else {
					CriticalPoint newmax;
					newmax.x=pos.x; newmax.y=pos.y; newmax.z=pos.z;
					newmax.type=CriticalPoint::Max;
					maxpoints.push_back(newmax);
					criticalpoints.push_back(newmax);
					seg.push_back(pos);
					printf(" %.16f,%.16f,%.16f\n",pos.x,pos.y,pos.z);
				}
				break;
			}
			else {
				dstep.x=seg[num].x-pos.x;
				dstep.y=seg[num].y-pos.y;
				dstep.z=seg[num].z-pos.z;
				if (NORM2(dstep.x,dstep.y,dstep.z)>MAXSTEP*MAXSTEP) {
					seg.push_back(pos);
					++num;
				}
			}
		}
		addSeg(pseg);
	}
}

void Arcline::Connect1SaddleToMinDiscrete() {
	Point3D p, testp;
	Vector3D dir, pos, dstep;
	double pval, testval, step, l;
	double dist;
	unsigned int path,i,j,num,dimX=vtk.dimX, dimY=vtk.dimY, dimZ=vtk.dimZ;
	LineSeg* pseg;

	for (path=0; path<2; ++path) {
		clear();
		pseg = new LineSeg;
		LineSeg& seg = *pseg;
		CriticalPoint point = (*start);
		pos.x=point.x; pos.y=point.y; pos.z=point.z;
		seg.push_back(pos);
		num=0;
		p.Set(point.x,point.y,point.z);
		testp.Set(point.x,point.y,point.z);
		dir = point.axis;
		if (path>0) {
			dir.x=-dir.x; dir.y=-dir.y; dir.z=-dir.z;
		}
		while (1) {
			pos.x = p.x+dir.x*MAXSTEP;
			pos.y = p.y+dir.y*MAXSTEP;
			pos.z = p.z+dir.z*MAXSTEP;
			if (pos.x < 0 || pos.x > dimX-1 ||
				pos.y < 0 || pos.y > dimY-1 ||
				pos.z < 0 || pos.z > dimZ-1)
			{
				seg.clear();
				break;
			}
			pval = EvaluateVal(p);
			step = MAXSTEP;
			while (step>=EPS) {
				pos.x = p.x+dir.x*step;
				pos.y = p.y+dir.y*step;
				pos.z = p.z+dir.z*step;
				testp.Update(pos.x, pos.y, pos.z);
				testval = EvaluateVal(testp);
				step*=0.618;
				if (testval < pval) {
					pos.x = p.x+dir.x*step;
					pos.y = p.y+dir.y*step;
					pos.z = p.z+dir.z*step;
					p.Update(pos.x,pos.y,pos.z);
					if (pval<=EvaluateVal(p)) {
						p.Update(testp.x,testp.y,testp.z);
					}
					dir = EvaluateGradient(p);
					l=NORM2(dir.x,dir.y,dir.z);
					if (l>0) {
						l=-1.0/sqrt(l);
						dir.x*=l; dir.y*=l; dir.z*=l;
					}
					break;
				}
			}
			// Reach a max point
			if (step < EPS) {
				dist = MAXSTEP;
				for (i=0; i<minpoints.size(); ++i) {
					dstep.x=minpoints[i].x-p.x;
					dstep.y=minpoints[i].y-p.y;
					dstep.z=minpoints[i].z-p.z;
					if (NORM2(dstep.x,dstep.y,dstep.z)<dist) {
						j=i;
						dist = NORM2(dstep.x,dstep.y,dstep.z);
					}
				}
				// connect to the min
				if (dist<MAXSTEP) {
					pos.x=minpoints[j].x;
					pos.y=minpoints[j].y;
					pos.z=minpoints[j].z;
					seg.push_back(pos);
				}
				else if (isBackground(pos)) {
					seg.clear();
					//line[path].push_back(Vector3D(0,0,0));
				}
				else {
					
					CriticalPoint newmin;
					newmin.x=pos.x; newmin.y=pos.y; newmin.z=pos.z;
					newmin.type=CriticalPoint::Max;
					minpoints.push_back(newmin);
					criticalpoints.push_back(newmin);
					seg.push_back(pos);
					seg.push_back(Vector3D(0,0,0));
					//printf(" %.16f,%.16f,%.16f: %g\n",pos.x,pos.y,pos.z,pval);
					
				}
				break;
			}
			else {
				dstep.x=seg[num].x-pos.x;
				dstep.y=seg[num].y-pos.y;
				dstep.z=seg[num].z-pos.z;
				if (NORM2(dstep.x,dstep.y,dstep.z)>MAXSTEP*MAXSTEP) {
					seg.push_back(pos);
					++num;
				}
			}
		}
		addSeg(pseg);
	}
}
#undef EPS
#undef MAXSTEP

void Arcline::Merge(Arcline* midSeg, Arcline* endSeg) {
	// merge line segments
	for (auto pSeg : midSeg->_lines) {
		addSeg(pSeg);
	}
	for (auto pSeg : endSeg->_lines) {
		addSeg(pSeg);
	}
	for (int i=0; i<_lines.size(); ++i) {
		for (int j=_lines.size()-1; j>i; --j) {
			if (_lines[i]==_lines[j]) {
				for (int k=i; k<=j; ++k) {
					--(_lines[k]->ref);
					_length-=_lines[k]->length;
				}
				_lines.erase(_lines.begin()+i, _lines.begin()+j+1);
				goto erase_map;
			}
		}
	}

erase_map:
	removeFromMap();

	end = endSeg->end;
	mapVtx2Arc.insert(make_pair(start, this));
	mapVtx2Arc.insert(make_pair(end, this));
}

void Arcline::removeFromMap() {
	auto rangeArcs = mapVtx2Arc.equal_range(start);
	for (auto iter = rangeArcs.first; iter!=rangeArcs.second; ++iter) {
		if (iter->second == this) {
			mapVtx2Arc.erase(iter);
			break;
		}
	}
		rangeArcs = mapVtx2Arc.equal_range(end);
	for (auto iter = rangeArcs.first; iter!=rangeArcs.second; ++iter) {
		if (iter->second == this) {
			mapVtx2Arc.erase(iter);
			break;
		}
	}
}

void ConnectAll2SaddleToMaxDiscrete() {
	unsigned int i;

	printf("Connect 2-Saddles to Max Points\n");

	Saddle2MaxMS1.clear();
	Saddle2MaxMS1.resize(saddles2.size());
	for (i=0; i<saddles2.size(); ++i) {
		Saddle2MaxMS1[i]->start = saddles2[i].toVertexPtr();
		if (saddles2[i].type == CriticalPoint::Saddle2) {
			Saddle2MaxMS1[i]->Connect2SaddleToMaxDiscrete();
		}
		printf("%.1f\r",i*100.0/saddles2.size());
	}
}

void ConnectAll2SaddleToMax() {
	unsigned int i;
	
	Saddle2MaxMS1.clear();
	Saddle2MaxMS1.resize(2*saddles2.size());
	printf("Connect 2-Saddles to Max Points: %d\n", Saddle2MaxMS1.size());
	//maxpoints.clear();
	for (i=0; i<saddles2.size(); ++i) {
		Saddle2MaxMS1[2*i] = new Arcline();
		Saddle2MaxMS1[2*i+1] = new Arcline();
		if (saddles2[i].type == CriticalPoint::Saddle2) {
			Saddle2MaxMS1[i]->clear();
			Saddle2MaxMS1[i]->start = (Vertex*) &saddles2[i];
			Saddle2MaxMS1[i]->Connect2SaddleToMax();
		}
		printf("%.1f\r",i*100.0/saddles2.size());
	}
}

void ConnectAll1SaddleToMin() {
	unsigned int i;

	printf("Connect 1-Saddles to Min Points\n");
	
	Saddle1MinMS1.clear();
	Saddle1MinMS1.resize(saddles1.size());
	for (i=0; i<saddles1.size(); ++i) {
		Arcline* pMS = Saddle1MinMS1[i];
		pMS->start = saddles1[i].toVertexPtr();
		//printf("%f %f %f\n",saddles1[i].x,saddles1[i].y,saddles1[i].z);
// 		if (saddles1[i].x<12.55 || saddles1[i].x>12.56 || saddles1[i].y<26.11 || saddles1[i].y>26.12 || saddles1[i].z<17.98 || saddles1[i].z>17.99)
// 			continue;
		if (saddles1[i].type == CriticalPoint::Saddle1) {
			pMS->Connect1SaddleToMinDiscrete();
		}
		if (pMS->size()==0) {
			Saddle1MinMS1.erase(Saddle1MinMS1.begin()+i);
			saddles1.erase(saddles1.begin()+i);
			--i;
		}
		printf("%.1f\r",i*100.0/saddles1.size());
	}
}

void ConnectAll1SaddleToMax() {
	unsigned int i;

	printf("Connect 1-Saddles to Max Points\n");

	Saddle1MaxMS1.clear();
	Saddle1MaxMS1.resize(saddles1.size());
	for (i=0; i<saddles1.size(); ++i) {
		Saddle1MaxMS1[i]->start = saddles1[i].toVertexPtr();
//		printf("%d: %f %f %f\n",i,saddles2[i].x,saddles2[i].y,saddles2[i].z);
		if (saddles1[i].type == CriticalPoint::Saddle1) {
			Saddle1MaxMS1[i]->Connect1SaddleToMaxDiscrete();
		}
		printf("%.1f\r",i*100.0/saddles1.size());
	}
}

nan_009
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
广义Morse解析小波变换在机械故障诊断中的应用研究
06-29
提出了一种基于广义Morse小波变换的机械故障诊断方法。研究了广义Morse小波相比常用的Morse小波是一种完全解析特性,因此广义Morse具有其他非解析小波所不具有的优势。将该方法应用于某空分机的故障诊断中,并成功提取出重要的故障特征信息,结果证实了该方法可为机械故障诊断提供一条新途径。
有关小波的几个术语及常见的小波基介绍
热门推荐
彬彬有礼的专栏
01-10 19万+
本篇是这段时间学习小波变换的一个收尾，了解一下常见的小波函数，混个脸熟，知道一下常见的几个术语，有个印象即可，这里就当是先作一个备忘录，以后若有需要再深入研究。
认识小波——MATLAB中国的讲座(笔记)
CLARKYY的博客
04-26 4106
第一部分：什么是小波 https://www.bilibili.com/video/BV1xu411R7yK 现实世界中的数据或信号经常表现出缓慢变化的趋势或者有瞬变的振荡 Real world data or signals frequently exhibit slowly changing trends or oscillations punctuated with transients 图像的平滑区域会被边缘突变或对比度突变打断，无论在感知上还是在提供的信息方面，这些突变通常是数据中最令人感兴趣的部
调制信号的连续小波变换 CWT时频谱图 二次线性Chirp调频信号，蝙蝠的回声定位信号
ktBwcmbF的博客
01-09 390
通过对信号的时频定位能力蛮强的分析，我们可以更好地理解信号的时频特性，进而为相关领域的研究和应用提供有价值的参考。我们将以二次线性Chirp调频信号、蝙蝠的回声定位信号以及日本神户地震数据为例，展示连续小波变换的时频定位能力。【第二部分：二次线性Chirp调频信号的分析】 二次线性Chirp调频信号是一种在频率随时间变化的调制信号，具有丰富的频谱结构。二次线性Chirp调频信号，蝙蝠的回声定位信号，神户地震数据的连续小波变换时频谱图，以看出来解析Morse等小波的时频定位能力蛮强的。
从傅里叶变换，到短时傅里叶变换，再到小波分析（CWT），看这一篇就够了（附MATLAB傻瓜式实现代码）
fengzhuqiaoqiu的博客
11-18 2941
本专栏中讲了很多时频域分析的知识，不过似乎还没有讲过时频域分析是怎样引出的。所以本篇将回归本源，讲一讲从傅里叶变换→短时傅里叶变换→小波分析的过程。为了让大家更直观得理解算法原理和推导过程，这篇文章将主要使用图片案例。
小波变换原理及matlab代码
qq_53399765的博客
07-02 1万+
小波变换原理及matlab代码
小波的选择和小波的分类
alier_chen的博客
09-16 1万+
（1）haar小波 是具有对称性、有限支撑的正交小波，且计算简单，但不是连续小波，只有一阶导数因此在实际应用中受到限制。 （2）morlet小波 是对称的非正交小波，一般在实信号上使用 (实信号就是现实中真实的、可以测量到的信号，如正弦波、信号噪声都是实信号） （3）Mexican hat小波 由高斯函数的二阶导数得到，是对称、非紧支撑的非正交小波，接近人眼视觉的空间特征 （3）gaussi...
MATLAB峭度代码-analytic_wavelet:使用广义Morse小波将JMLilly的用于脊线和元素分析的代码翻译成python
05-20
MATLAB陡度代码analytic_wavelet 使用广义Morse小波将JM Lilly的用于脊线和元素分析的代码翻译成python。 原始的jLab存储库可在以下位置找到： Lilly，JM（2019），jLab：Matlab的数据分析包，版本1.6.6 ,. 请注意，此存储库不会重新实现jLab中的所有代码，而只是重新实现我感兴趣的部分。它也不是直接实现的。 我已经对代码进行了重组，以使API更具描述性，并且对python / numpy更加友好。 我还用内置的numpy和scipy函数替换了自定义函数，在我看来，我可以并且已经将内存布局更改为在Python中更高效（因为numpy是行占主导地位的，而MATLAB是列占主导地位的） 。 这意味着时间轴通常是我代码中的最后一个轴，但是是jLab中的第一个轴。 可以进一步简化使用更多内置的numpy和scipy代码。 从jLab中的函数到analytic_wavelet中的函数/方法的粗略映射。 并非所有的API都能准确映射 实验室 analytic_wavelet 全反式 analytic_transform 机构 振幅 瞬时频
图像压缩——小波变换（Wavelet Transform）从连续小波变换谈到离散小波变换
ChuanjieZhu
11-30 3万+
为什么会出先小波变换 窗口傅立叶变换（短时傅立叶变换）虽然可以部分定位时间，但由于窗口大小是固定的，只适用于频率波动小的平稳信号，不适用于频率波动大的非平稳信号。而小波变换可以根据频率的高低自动调节窗口大小，是一种自适应的时频分析方法，可以进行多分辨率分析。 从连续小波变换说起 连续小波变换（Continuous Wavelet Transform，CWT）的定义如下：
Morse
10-28
Morse
morse_keypress
03-14
morse_keypress概述这是我为实验编写的一个简单应用程序：尝试通过在正常工作（编码等）过程中按下键盘上的按键时听到的点/破折号音频来记住莫尔斯电码。 因此，基本上，当我们按下“ a”之类的键时，我们将收听“ ....
小波怎么选？——看图选
weixin_46180132的博客
06-28 7084
小波分析有两种类型:连续小波和多分辨率小波。哪种小波分析最适合您的工作取决于您想对数据做什么。本主题主要关注一维数据，但是您可以将相同的原则应用于二维数据。 1. 时频分析： 如果你的目标是执行一个详细的时频分析，选择连续小波变换(CWT)。在实现方面，CWT比离散小波变换(DWT)更精细地离散尺度。有关更多信息，请参阅连续和离散小波变换。 1.1 瞬时频率 对于瞬时频率增长较快的信号，连续小波变换优于短时傅里叶变换(STFT)。在下图中，双曲调频的瞬时频率在谱图和cwt衍生的尺度图中被绘制为虚线。 1.
Matlab时频分析之连续小波变换CWT
iceFreedom的博客
05-25 1万+
1. 小波分析介绍 和傅里叶变换比，小波变换和短时傅里叶变换都有着相同的优点，就是可以同时在时域和频域观察信号。所以小波变换在非定常信号的分析中有很大的作用。 和短时傅里叶变换相比，小波变换有着窗口自适应的特点，即高频信号分辨率高（但是频率分辨率差），低频信号频率分辨率高（但是时间分辨率差），而在工程中常常比较关心低频的频率和高频出现的时间，所以近些年用途比较广泛。 在数学上，小波还有正交化等优点，应用领域广泛。 本文只讨论如何利用matlab实现cwt的时频分析 2. 小波分析基本原理 小波的含义，即为时
MATLAB利用小波分析提取周期
WW、forever的博客
07-10 1万+
简介小波分析如何提取周期
Morse理论：拓扑不变性特征匹配原理
alppkk4545的博客
12-21 648
设计精美的宽基线双目相机镇文 Mo’ersi lilun莫尔斯理论(卷名：数学) Morse theory　　微分拓扑的一个重要分支。通常是指两部分内容：一部分是微分流形上可微函数的莫尔斯理论，即临界点理论；另一部分是变分问题的莫尔斯理论，即大范围变分法。确切地说，假设ƒ是n维微分流形M上的实值可微函数，ƒ的临界点p是指梯度向量场gradƒ的零点...
小波基函数的选择和小波构造
jacberg的专栏
01-15 9万+
滤波器组完美重构与小波快速算法。 前面的分析可以知道Vj相当于在j分辨率的逼近，Vj-1相当于j-1分辨率的逼近，这样Wj-1相当于两个分辨率逼近的差。在高分辨率下，我们可以用f在（2^j*t）的采样值来代替向Vj空间的投影，但是这是需要说明的，否则成为“小波的罪恶”，本来在Vj上的投影需要函数对Vj上的基{2^(j/2)*m（2^j*t –n）}投影，用采样值来代替是因为当j足够大的时候，如一
小波变换和小波包变换
赵至柔的博客
06-04 2万+
一、小波变换 1、连续型小波变换 小波变换是一个平方可积函数f(t)f(t)f(t) 与一个时频域上具有良好局部性质的小波函数ψ(t)ψ(t)\psi \left( t \right)的内积： Wf(a,b)=&amp;amp;amp;amp;amp;lt;f,ψa,b&amp;amp;amp;amp;amp;gt;=1a−−√ψ∗(t−ba)dtWf(a,b)=&amp;amp;amp;amp;amp;lt;f,ψa,b&amp;amp;amp;amp;amp;gt;
满意度调查行·知dr.pptx
最新发布
04-25
满意度调查行·知dr.pptx
fpga morse
10-30
Morse代码是一种以信号的短暂和长久的组合来表示字母、数字和标点符号的电码系统。 在FPGA上实现Morse代码的过程可以分为两个步骤：编码和解码。 首先是编码部分，我们需要将字符转换为对应的Morse代码。可以使用...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值