精华内容
下载资源
问答
  • SG平滑算法(又称多项式平滑算法

    万次阅读 热门讨论 2018-12-24 22:36:05
    今天是平安夜,闲来无事,那就来写一下SG平滑算法吧! SG平滑算法是由Savizkg和Golag提出来的。基于最小二乘原理的多项式平滑算法,也称卷积平滑。为啥叫多项式平滑呢?且看下去。 下面使用五点平滑算法来说明平滑...

    今天是平安夜,闲来无事,那就来写一下SG平滑算法吧!

    SG平滑算法是由Savizkg和Golag提出来的。基于最小二乘原理的多项式平滑算法,也称卷积平滑。为啥叫多项式平滑呢?且看下去。

     下面使用五点平滑算法来说明平滑过程

    原理很简单如图:

    把光谱一段区间的等波长间隔的5个点记为X集合,多项式平滑就是利用在波长点为Xm-2,Xm-1,Xm,Xm+1,Xm+2的数据的多项式拟合值来取代Xm,,然后依次移动,直到把光谱遍历完。

     首先推五点三次平滑公式,m=2,k= 3

    由上式可得

    再由公式计算B矩阵得

     

     

     

    所以5个平滑公式如图

     

     其他什么7点3次,9点3次,同理可以推导求解。下次补上C++代码,+——+溜了   欢迎留言交流。。

    参考文献:(1)https://blog.csdn.net/qq_20823641/article/details/51537461

                      

    展开全文
  • 指数平滑算法

    2018-02-08 09:17:36
    指数平滑算法
  • 自调整平滑区间粒子滤波平滑算法
  • 前后向平滑算法

    2019-04-18 11:55:11
    前后向平滑算法,基于智能天线波达方向估计的前后向平滑算法
  • Matlab实现三次指数平滑算法Matlab实现三次指数平滑算法Matlab实现三次指数平滑算法Matlab实现三次指数平滑算法Matlab实现三次指数平滑算法
  • 最近使用使用python自己写的语言模型和srilm得到的语言模型做对比,srilm里还是有很多trick的,尤其是平滑算法,集成了很多数据平滑算法,研究的时候,记录一下。 在srilm中有回退和差值两类平滑算法,简单来说,回...

    最近使用使用python自己写的语言模型和srilm得到的语言模型做对比,srilm里还是有很多trick的,尤其是平滑算法,集成了很多数据平滑算法,研究的时候,记录一下。

    在srilm中有回退和差值两类平滑算法,简单来说,回退就是将出现过的ngram的概率打个折扣,将那部分折扣下来的概率均摊为未出现的ngram作为他们的概率,而插值呢,一样是对出现过的ngram打折扣,但是折扣下来的概率值均摊到所有的ngram上。对于那些出现的ngram来说,他们使用最大似然得到的真正概率(频率)A大于使用插值得到的概率B大于使用回退得到的概率C,即

    A>B>C

     

    主要使用的平滑算法

    Good-Turing平滑算法

    Good-Turing算法的思想是,对于出现次数大于某一阈值的ngram使最大似然用频率计算是比较准确的,但是如果小于这个阈值,最大似然估计就不准了。这时候,算法的处理就是利用出现次数较多的N阶元组去调整出现比他少的N阶元组的估计量。算法的

    对于中产(那些发生次数小于阈值的元组)发生了r次,假设它发生了r*次:

                                                                                  \boldsymbol{r}*=\boldsymbol{(r+1)}\frac{N_{r+1}}{N_{r}}

    \boldsymbol{N_{r}}是所有发生次数为r的元组个数,同样\boldsymbol{N_{r+1}}是所有发生次数为r+1的元组个数,一般来说,发生次数为r的元组个数多余发生次数为r+1的元组个数,这里不要弄混发生次数和元组个数,如果做个比喻的话,那元组就是字典的key,元组个数是字典的value,元组个数是key的个数,不太严谨,但是好理解。

    这样的话,对于发生个数为0的元组的计数就不为0了,每个中产的概率都比以前要小了,小的那部分,分给了穷人。这里的发生个数为0指的是在训练集中发生次数为0,即在训练集中没有出现,在测试集中第一次出现,然后用的是在训练集中出现1次的元组来估计,这样那些第一次出现的次数为不为0,实现了平滑。

    证明所有元组概率之和为1的推到如下:

    nr是所有发生次数为r的元组个数,同样nr+1是所有发生次数为r+1的元组个数,一般来说,发生次数为r的元组个数多余发生次数为r+1的元组个数,这里不要弄混发生次数和元组个数,如果做个比喻的话,那元组就是字典的key,元组个数是字典的value,元组个数是key的个数,不太严谨,但是好理解。

    这样的话,对于发生个数为0的元组的计数就不为0了,每个中产的概率都比以前要小了,小的那部分,分给了穷人。这里的发生个数为0指的是在训练集中发生次数为0,即在训练集中没有出现,在测试集中第一次出现,然后用的是在训练集中出现1次的元组来估计,这样那些第一次出现的次数为不为0,实现了平滑。

    证明所有元组概率之和为1的推到如下:

    nr是所有发生次数为r的元组个数,同样nr+1是所有发生次数为r+1的元组个数,一般来说,发生次数为r的元组个数多余发生次数为r+1的元组个数,这里不要弄混发生次数和元组个数,如果做个比喻的话,那元组就是字典的key,元组个数是字典的value,元组个数是key的个数,不太严谨,但是好理解。

    这样的话,对于发生个数为0的元组的计数就不为0了,每个中产的概率都比以前要小了,小的那部分,分给了穷人。这里的发生个数为0指的是在训练集中发生次数为0,即在训练集中没有出现,在测试集中第一次出现,然后用的是在训练集中出现1次的元组来估计,这样那些第一次出现的次数为不为0,实现了平滑。

    证明所有元组概率之和为1的推到如下:

                                                       

    nr是所有发生次数为r的元组个数,同样nr+1是所有发生次数为r+1的元组个数,一般来说,发生次数为r的元组个数多余发生次数为r+1的元组个数,这里不要弄混发生次数和元组个数,如果做个比喻的话,那元组就是字典的key,元组个数是字典的value,元组个数是key的个数,不太严谨,但是好理解。

    这样的话,对于发生个数为0的元组的计数就不为0了,每个中产的概率都比以前要小了,小的那部分,分给了穷人。这里的发生个数为0指的是在训练集中发生次数为0,即在训练集中没有出现,在测试集中第一次出现,然后用的是在训练集中出现1次的元组来估计,这样那些第一次出现的次数为不为0,实现了平滑。

    证明所有元组概率之和为1的推到如下:

                                                  

             

    上式是对于次数为r概率重新估计的元组,概率为θ

    保证概率的总和为1,出现同样次数的元组具有相同的概率,所以总的概率就是出现在不同次数的概率与这个次数的元组总数的乘积之和,即θ(r)N的总和:

                                           

      其中

                                                  \sum (r+1) N_{r+1}=\sum rN_{r}

    因此最后保证了概率之和为1:

                                             

    参考:

    https://blog.csdn.net/hx14301009/article/details/80341095

    https://blog.csdn.net/u010189459/article/details/38236657

    http://www.52nlp.cn/mit-nlp-third-lesson-probabilistic-language-modeling-fifth-part#more-729

    例子: http://blog.sina.com.cn/s/blog_8267db980102wqgc.html

    推导: http://www.cs.cornell.edu/courses/cs6740/2010sp/guides/lec11.pdf

    https://blog.csdn.net/xmdxcsj/article/details/50373554

    展开全文
  • 曲线平滑算法

    万次阅读 2018-08-10 23:57:01
    由于项目开发需要对等值线进行平滑处理,所以研究了线条的平滑算法,经研究查阅资料,可以使用三次B样条曲线方程对线条进行平滑处理,而平滑处理可分为近似拟合和插值拟合两种,两种拟合处理各有其优缺点,以下会做...

    由于项目开发需要对等值线进行平滑处理,所以研究了线条的平滑算法,经研究查阅资料,可以使用三次B样条曲线方程对线条进行平滑处理,而平滑处理可分为近似拟合和插值拟合两种,两种拟合处理各有其优缺点,以下会做说明,可根据实际业务需要进行选取。本次项目开发最终选用了近似拟合算法处理。

    一、三次B样条曲线方程

    B样条曲线的总方程为:

    其中Pi是控制曲线的特征点,Fi,k(t)则是K阶B样条基函数。

    三次B样条曲线方程中基函数为:

    其中\binom{m}{k+1}表示阶乘,化成看的明白的式子就是:

    将基函数带入总方程可换算出三次B样条曲线方程:

    基于上述的三次B样条曲线方程可对曲线进行平滑处理。

    二、三次B样条曲线近似拟合

    近似拟合,平滑后的线条不一定过原始特征点,平滑处理的核心算法如下,算法中对闭合曲线和非闭合曲线分别做了处理:

    // 闭合曲线
    if (line[0] == line[len - 2] && line[1] == line[len - 1]) {
    	for (var n = 0; n < pntLen; n++) {
    		if (n <= pntLen - 4) {
    			for (var t = 0.0; t <= 1.0; t += 0.1) {
    				var a1 =  Math.pow((1 - t), 3) / 6;
    				var a2 =  (3 * Math.pow(t, 3) - 6 * Math.pow(t, 2) + 4) / 6;
    				var a3 = (-3 * Math.pow(t, 3) + 3 * Math.pow(t, 2) + 3 * t + 1) / 6;
    				var a4 =  Math.pow(t, 3) / 6;
    				
    				var x = a1*points[n].x + a2*points[n + 1].x + a3*points[n + 2].x + a4*points[n + 3].x;
    				var y = a1*points[n].y + a2*points[n + 1].y + a3*points[n + 2].y + a4*points[n + 3].y;
    				newPnts.push({x: x, y: y});
    			}
    		} else if (n == pntLen - 3) {
    			for (var t = 0.0; t <= 1.0; t += 0.1) {
    				var a1 =  Math.pow((1 - t), 3) / 6;
    				var a2 =  (3 * Math.pow(t, 3) - 6 * Math.pow(t, 2) + 4) / 6;
    				var a3 = (-3 * Math.pow(t, 3) + 3 * Math.pow(t, 2) + 3 * t + 1) / 6;
    				var a4 =  Math.pow(t, 3) / 6;
    				
    				var x = a1*points[n].x + a2*points[n + 1].x + a3*points[n + 2].x + a4*points[0].x;
    				var y = a1*points[n].y + a2*points[n + 1].y + a3*points[n + 2].y + a4*points[0].y;
    				newPnts.push({x: x, y: y});
    			}
    		} else if (n == pntLen - 2) {
    			for (var t = 0.0; t <= 1.0; t += 0.1) {
    				var a1 =  Math.pow((1 - t), 3) / 6;
    				var a2 =  (3 * Math.pow(t, 3) - 6 * Math.pow(t, 2) + 4) / 6;
    				var a3 = (-3 * Math.pow(t, 3) + 3 * Math.pow(t, 2) + 3 * t + 1) / 6;
    				var a4 =  Math.pow(t, 3) / 6;
    				
    				var x = a1*points[n].x + a2*points[n + 1].x + a3*points[0].x + a4*points[1].x;
    				var y = a1*points[n].y + a2*points[n + 1].y + a3*points[0].y + a4*points[1].y;
    				newPnts.push({x: x, y: y});
    			}
    		} else if (n == pntLen - 1) {
    			for (var t = 0.0; t <= 1.0; t += 0.1) {
    				var a1 =  Math.pow((1 - t), 3) / 6;
    				var a2 =  (3 * Math.pow(t, 3) - 6 * Math.pow(t, 2) + 4) / 6;
    				var a3 = (-3 * Math.pow(t, 3) + 3 * Math.pow(t, 2) + 3 * t + 1) / 6;
    				var a4 =  Math.pow(t, 3) / 6;
    				
    				var x = a1*points[n].x + a2*points[0].x + a3*points[1].x + a4*points[2].x;
    				var y = a1*points[n].y + a2*points[0].y + a3*points[1].y + a4*points[2].y;
    				newPnts.push({x: x, y: y});
    			}
    		}
    	}
    	// 不闭合
    } else {
    	newPnts.push({x: points[0].x, y: points[0].y});
    	for (var n = 0; n < pntLen; n++) {
    		if (n <= pntLen - 4) {
    			for (var t = 0.0; t <= 1.0; t += 0.1) {
    				var a1 =  Math.pow((1 - t), 3) / 6;
    				var a2 =  (3 * Math.pow(t, 3) - 6 * Math.pow(t, 2) + 4) / 6;
    				var a3 = (-3 * Math.pow(t, 3) + 3 * Math.pow(t, 2) + 3 * t + 1) / 6;
    				var a4 =  Math.pow(t, 3) / 6;
    				
    				var x = a1*points[n].x + a2*points[n + 1].x + a3*points[n + 2].x + a4*points[n + 3].x;
    				var y = a1*points[n].y + a2*points[n + 1].y + a3*points[n + 2].y + a4*points[n + 3].y;
    				newPnts.push({x: x, y: y});
    			}
    		}
    	}
    	newPnts.push({x: points[pntLen - 1].x, y: points[pntLen - 1].y});
    }

    三次B样条曲线近似拟合处理的效果图如下,其中红色为原始未平滑处理的曲线,而蓝色为平滑后的曲线。可以看出近似拟合后的曲线平滑的效果较为满意,但是缺点是曲线不过原始特征点 。

    三、三次B样条曲线插值拟合 

    插值拟合,平滑后的曲线过原始特征点,平滑的核心算法如下:

    function getCtrlPoint(pointsArr, index, scaleA, scaleB) {
    	if (!scaleA || !scaleB) {
    		scaleA = 0.15;
    		scaleB = 0.15;
    	}
    
    	// 处理两种极端情形
    	if (index < 1) {
    		var pAx = pointsArr[0].x + (pointsArr[1].x - pointsArr[0].x) * scaleA;
    		var pAy = pointsArr[0].y + (pointsArr[1].y - pointsArr[0].y) * scaleA;
    	} else {
    		var pAx = pointsArr[index].x + (pointsArr[index + 1].x - pointsArr[index - 1].x) * scaleA;
    		var pAy = pointsArr[index].y + (pointsArr[index + 1].y - pointsArr[index - 1].y) * scaleA;
    	}
    
    	if (index > pointsArr.length - 3) {
    		var last = pointsArr.length - 1
    		var pBx = pointsArr[last].x - (pointsArr[last].x - pointsArr[last - 1].x) * scaleB;
    		var pBy = pointsArr[last].y - (pointsArr[last].y - pointsArr[last - 1].y) * scaleB;
    	} else {
    		var pBx = pointsArr[index + 1].x - (pointsArr[index + 2].x - pointsArr[index].x) * scaleB;
    		var pBy = pointsArr[index + 1].y - (pointsArr[index + 2].y - pointsArr[index].y) * scaleB;
    	}
    
    	return {
    		pA: {x: pAx, y: pAy},
    		pB: {x: pBx, y: pBy}
    	}
    }

     三次B样条曲线插值拟合处理的效果图如下,其中红色为原始未平滑处理的曲线,而蓝色为平滑后的曲线。可以看出插值拟合后的曲线平滑的效果不尽如人意,有出现线条打结的情况,但是优点是曲线过原始特征点 。

    参考资料:https://blog.csdn.net/liumangmao1314/article/details/54588155 

    展开全文
  • 2D 折线顶点平滑算法

    2020-01-14 13:07:29
    2D 折线顶点平滑算法—— 平滑折线通常可以通过两种方式: 通过插值,即在新的平滑曲线上,原始的折线点仍保持不变; 通过近似,这意味着新的平滑曲线将近似原始的折线,但原始点不会被保留下来。 本代码对两种...
  • 程序是一个基于RTS平滑的正弦信号滤波平滑算法的对比,Matlab中运行main.m文件即可。具体算法可以参考博客 https://blog.csdn.net/weixin_42647783/article/details/106035691。
  • 基于相干信号源的前向平滑与前后向平滑算法的比较
  • 地形平滑算法

    千次阅读 2017-01-03 17:36:37
    地形平滑算法 2013-06-20 18:33 2486人阅读 评论(0) 收藏 举报  分类: OGRE(41) C/C++(10)  版权声明:本文为博主原创文章,未经博主允许不得转载。 拉出来的地下不平滑...

    地形平滑算法

     2486人阅读 评论(0) 收藏 举报
     分类:
     

    拉出来的地下不平滑怎么办,笨办法就是美工一个顶点一个顶点的调整,而且效果还不好。实际上程序只要实现一个完美平滑算法,随便一刷,地形就平滑了。

    平滑算法最重要的就是不能改变原来的地形的大概结构,

    基本思路,就是和相邻的点取一个混合值。混合公式和alpha混合公式一样。



    海滩边岩石的平滑效果非常好。

    [cpp] view plain copy
    1. #include "SmoothHeightAction.h"  
    2. #include "SceneManipulator.h"  
    3. #include "HitIndicator.h"  
    4. namespace WX {  
    5.   
    6.     //  
    7.   
    8.     SmoothHeightAction::SmoothHeightAction(SceneManipulator* sceneManipulator)  
    9.         : TimeBasedHeightAction(sceneManipulator)  
    10.     {  
    11.     }  
    12.   
    13.     const String& SmoothHeightAction::getName(voidconst  
    14.     {  
    15.         static const String name = "SmoothHeightAction";  
    16.         return name;  
    17.     }  
    18.   
    19.     void SmoothHeightAction::_onBegin(const Point& pt)  
    20.     {  
    21.         TimeBasedHeightAction::_onBegin(pt);  
    22.   
    23.         //computeAverageHeight();  
    24.     }  
    25.   
    26.     void SmoothHeightAction::_onDrag(const Point& pt)  
    27.     {  
    28.         TimeBasedHeightAction::_onDrag(pt);  
    29.   
    30.         //computeAverageHeight();  
    31.     }  
    32.   
    33.     void SmoothHeightAction::computeAverageHeight(void)  
    34.     {  
    35.         //Real totalHeight = 0;  
    36.         //Real totalWeight = 0;  
    37.         //JunctionSelection* selection = static_cast<JunctionSelection*>(  
    38.         //    getSceneManipulator()->_getSelection("JunctionSelection"));  
    39.         //const JunctionSelection::JunctionMap& junctions = selection->getJunctions();  
    40.         //JunctionSelection::JunctionMap::const_iterator it;  
    41.         //for (it = junctions.begin(); it != junctions.end(); ++it)  
    42.         //{  
    43.         //    const JunctionSelection::Junction& junction = it->second;  
    44.         //    totalWeight += junction.weight;  
    45.         //    totalHeight += getTerrainData()->getHeight(junction.x, junction.z) * junction.weight;  
    46.         //}  
    47.         //mAverageHeight = totalWeight ? totalHeight / totalWeight : 0;  
    48.     }  
    49.   
    50.     Real SmoothHeightAction::_computeHeight(const JunctionSelection::Junction& junction, Real seconds)  
    51.     {  
    52.         //Real height = getTerrainData()->getHeight(junction.x, junction.z);  
    53.         //Real diff = mAverageHeight - height;  
    54.         //Real secondsRequest = Ogre::Math::Abs(diff * junction.weight / getSceneManipulator()->_getHeightAdjustSpeed());  
    55.         //if (secondsRequest < seconds)  
    56.         //    return mAverageHeight;  
    57.         //else  
    58.         //    return height + diff * seconds / secondsRequest;  
    59.         return 0;  
    60.     }  
    61.   
    62.     void SmoothHeightAction::_onUpdate(const Point& pt, Real seconds)  
    63.     {  
    64.         // 控制每秒平滑的次数  
    65.         static Real time = 0;  
    66.         time += seconds;  
    67.         if (time > 0.1)  
    68.         {  
    69.             smooth();  
    70.             time = 0;  
    71.         }  
    72.   
    73.         getSceneManipulator()->getHitIndicator("JunctionPoints")->refresh();  
    74.         getSceneManipulator()->getHitIndicator("IntersectPoint")->setHitPoint(pt);  
    75.     }  
    76.   
    77.     void SmoothHeightAction::smooth(void)  
    78.     {  
    79.         // 2012.9.16 luoyinan 实现新的平滑算法,基本思路是和相邻的点取  
    80.         // 一个混合值.再通过多次采样实现完美平滑效果  
    81.   
    82.         JunctionSelection* selection = static_cast<JunctionSelection*>(  
    83.             getSceneManipulator()->_getSelection("JunctionSelection"));  
    84.         //_prepareUpdate(*selection, seconds);  
    85.   
    86.         const JunctionSelection::JunctionMap& junctions = selection->getJunctions();  
    87.         JunctionSelection::JunctionMap::const_iterator it;  
    88.         std::vector<TerrainInfo> terrainInfo;  
    89.   
    90.         float k = 0.98;  
    91.   
    92.         // 从左到右  
    93.         for (it = junctions.begin(); it != junctions.end(); ++it)  
    94.         {  
    95.             const JunctionSelection::Junction& junction = it->second;  
    96.             mModifiedJunctions->add(junction.x, junction.z, 1);  
    97.   
    98.             //  
    99.             if (getTerrainData()->isValidJunction(junction.x-1,junction.z))  
    100.             {  
    101.                 float oldHeight = getTerrainData()->getHeight(junction.x,junction.z);  
    102.                 float newHeight = getTerrainData()->getHeight(junction.x-1,junction.z) * (1-k) + oldHeight * k;  
    103.   
    104.                 TerrainInfo terrInfo;  
    105.                 terrInfo.x = junction.x;  
    106.                 terrInfo.z = junction.z;  
    107.                 terrInfo.oldHeight = junction.height;  
    108.                 terrInfo.nowHeight = newHeight;  
    109.                 terrainInfo.push_back(terrInfo);  
    110.   
    111.                 getTerrainData()->setHeight(junction.x, junction.z, newHeight);  
    112.             }  
    113.         }     
    114.         // 从右到左  
    115.         for (it = junctions.begin(); it != junctions.end(); ++it)  
    116.         {  
    117.             const JunctionSelection::Junction& junction = it->second;  
    118.             mModifiedJunctions->add(junction.x, junction.z, 1);  
    119.   
    120.             //  
    121.             if (getTerrainData()->isValidJunction(junction.x+1,junction.z))  
    122.             {  
    123.                 float oldHeight = getTerrainData()->getHeight(junction.x,junction.z);  
    124.                 float newHeight = getTerrainData()->getHeight(junction.x+1,junction.z) * (1-k) + oldHeight * k;  
    125.   
    126.                 TerrainInfo terrInfo;  
    127.                 terrInfo.x = junction.x;  
    128.                 terrInfo.z = junction.z;  
    129.                 terrInfo.oldHeight = junction.height;  
    130.                 terrInfo.nowHeight = newHeight;  
    131.                 terrainInfo.push_back(terrInfo);  
    132.   
    133.                 getTerrainData()->setHeight(junction.x, junction.z, newHeight);  
    134.             }  
    135.         }     
    136.         // 从上到下  
    137.         for (it = junctions.begin(); it != junctions.end(); ++it)  
    138.         {  
    139.             const JunctionSelection::Junction& junction = it->second;  
    140.             mModifiedJunctions->add(junction.x, junction.z, 1);  
    141.   
    142.             //  
    143.             if (getTerrainData()->isValidJunction(junction.x,junction.z+1))  
    144.             {  
    145.                 float oldHeight = getTerrainData()->getHeight(junction.x,junction.z);  
    146.                 float newHeight = getTerrainData()->getHeight(junction.x,junction.z+1) * (1-k) + oldHeight * k;  
    147.   
    148.                 TerrainInfo terrInfo;  
    149.                 terrInfo.x = junction.x;  
    150.                 terrInfo.z = junction.z;  
    151.                 terrInfo.oldHeight = junction.height;  
    152.                 terrInfo.nowHeight = newHeight;  
    153.                 terrainInfo.push_back(terrInfo);  
    154.   
    155.                 getTerrainData()->setHeight(junction.x, junction.z, newHeight);  
    156.             }  
    157.         }     
    158.         // 从下到上  
    159.         for (it = junctions.begin(); it != junctions.end(); ++it)  
    160.         {  
    161.             const JunctionSelection::Junction& junction = it->second;  
    162.             mModifiedJunctions->add(junction.x, junction.z, 1);  
    163.   
    164.             //  
    165.             if (getTerrainData()->isValidJunction(junction.x,junction.z-1))  
    166.             {  
    167.                 float oldHeight = getTerrainData()->getHeight(junction.x,junction.z);  
    168.                 float newHeight = getTerrainData()->getHeight(junction.x,junction.z-1) * (1-k) + oldHeight * k;  
    169.   
    170.                 TerrainInfo terrInfo;  
    171.                 terrInfo.x = junction.x;  
    172.                 terrInfo.z = junction.z;  
    173.                 terrInfo.oldHeight = junction.height;  
    174.                 terrInfo.nowHeight = newHeight;  
    175.                 terrainInfo.push_back(terrInfo);  
    176.   
    177.                 getTerrainData()->setHeight(junction.x, junction.z, newHeight);  
    178.             }  
    179.         }     
    180.   
    181.         getSceneManipulator()->_fireTerrainHeightChanged(terrainInfo);  
    182.         selection->notifyModified();  
    183.     }  
    184.   
    185. }  
    展开全文
  • 对加权空间平滑算法计算加权因子时需要预估计信源方向的问题,提出了一种新的相干信源波达方向估计的加权空间平滑算法。在计算加权矩阵时不需要知道信源的先验信息,也不需要预估计信源方向,而是对原始阵列进行特殊...
  • 针对煤矿救援机器人利用A*算法规划出来的路径存在转折次数多和路径不够平滑等问题,提出了一种基于改进A*算法的煤矿救援机器人路径平滑算法。首先利用Douglas-Peucker(D-P)算法对A*算法产生的全段路径进行处理,...
  • SG平滑算法记录

    2020-09-20 10:21:24
    SG平滑算法是由Savizkg和Golag提出来的。基于最小二乘原理的多项式平滑算法,也称卷积平滑。 原理 代码实现 使用了MathNet.Numerics包来进行矩阵的计算,以下是实现5点3次的代码 //y为纵坐标 private static double...
  • C# 五点二次 平滑算法 平滑数据 去除数据毛刺 C# 五点二次 平滑算法 平滑数据 去除数据毛刺
  • 子空间平滑算法代码

    2015-02-01 15:12:04
    经典子空间平滑算法 适合初学空间谱估计的人
  • 用于MEMS 陀螺阵列信号处理的OBE平滑算法
  • 基于多尺度分割的对象级影像平滑算法
  • - PAGE PAGE 3 欢迎下载 南京信息工程大学 实验实习报告 实验实习名称实验4 图像平滑算法实现 实验实习日期 2015.6 得分 指导教师 张 辉 计算机系 专业 科学与技术 年级 12 班次 3 姓名 学号 2 一实验目的?...
  • 基于过采样平滑算法的SAR慢运动目标成像
  • 五点三次平滑算法

    2015-06-19 15:21:59
    这里提供一个函数mean5_3(五点三次平滑算法)对数据进行平滑处理
  • 地图轨迹平滑算法

    万次阅读 2016-08-04 00:21:34
    地图轨迹平滑算法,Savitzky-Golay 滤波器
  • 多种自主水下航行器协同定位的NLOS测量平滑算法
  • 针对多目标跟踪中的固定间隔平滑问题,将势概率假设密度(CPHD)滤波器和RTS平滑器相结合,提出了RTS的势概率假设密度滤波平滑算法。考虑到在平滑过程中存在较大的输出延迟问题,采用分段思想,提出了分段RTS的势...
  • 本文为图像平滑算法研究,包括对单色图像和彩色图像的平滑算法
  • 基于三次B样条插值的等值线平滑算法及其应用

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 5,057
精华内容 2,022
关键字:

平滑算法