精华内容
下载资源
问答
  • 傻瓜式调整曲线采样数值,阴影7.7.7 高光245.245.245 灰场133.133.133 正片叠底→变暗滤色→变亮 明度→减少皮肤的影响

    傻瓜式调整曲线的采样数值,阴影7.7.7   高光245.245.245 灰场133.133.133

     

     

    正片叠底→变暗

    滤色→变亮

     明度→减少对皮肤的影响

    展开全文
  • 利用Matlab对采样数据进行曲线拟合

    千次阅读 2019-03-14 08:11:42
    我们在做数据处理或者采集的时候难免会遇到实际值和采样结果之间存在误差的情况,这就需要我们通过实验结果进行曲线拟合,从而得到较为准确的结果。 这几天在做变换器的时候就遇到了处理器采样结果和实际输入电压...

    我们在做数据处理或者采集的时候难免会遇到实际值和采样结果之间存在误差的情况,这就需要我们通过对实验结果进行曲线拟合,从而得到较为准确的结果。
    这几天在做变换器的时候就遇到了处理器采样结果和实际输入电压不匹配,通过分析初步分为是采集的电压经过调理电路以后,调理前和调理后不完全是按照电路比例来计算的,从而导致出现了检测结果的误差。
    通过测试发现二者之间的 差距不是一个固定的数值,所以采用曲线拟合的方式对二者之间的误差进行拟合,并求解其表达式。

    借助Matlab的数学工具既可以轻松的实现。具体步骤如下

    工具软件:Matlab2016

    步骤一:将数据输入到Matlab的命令窗口,并保存到一个变量中,如果数据量较大,也可以使用导入Excel的方式进行。

    x=[10.6,21.1,30.3,39.6,50.5,60.5,69.6,81.3,90.3,101.1,112.07,120.7,129.3,140.1,151.1,162,170.7,181.5,190.2,201.2]
    y=[8.5,18.5,26.3,35.5,46.3,56.2,67.0,78.3,85.4,94.5,104.5,112.4,121.5,131.8,141.6,152.1,161.6,170.8,179.1,189.3]
    步骤二:输入cftool命令调用曲线拟合工具箱
    在这里插入图片描述
    1:选择坐标的数据
    2:选择要拟合出来的曲线的类型,也可以自己定义
    3:如果自己定义,则在该处注明函数表达式,待求未知数用a,b,c等代替
    4:待求系数
    5:曲线拟合

    展开全文
  • 我用seabron.distplot函数画出了一个离散序列的概率密度曲线,现在想对曲线进行固定 间隔采样,求出离散概率密度序列,请问下大神怎么做,谢了
  • 以前电子竞赛时写的程序,绝对可以用。M3 ARM控制ADC采样,并且通过TFT液晶显示采样曲线图。
  • VTK笔记——样条曲线插值采样

    千次阅读 2019-02-01 16:35:15
    有时候我们想通过有限的点得到更多的点,比如用这些点来生成三角形,就需要用到曲线插值。最常见的是样条曲线插值。

    有时候我们想通过在样条曲线上得到更多的点,比如用这些点来与另一条曲线连通生成三角条,让曲线在可视化的时候分辨率更高,等等,就需要用到曲线插值采用。最常见的是样条曲线插值采样。
    曲线已经有了情况下(关于如何生成样条曲线,可参照VTK笔记——拟合样条曲线(Parametric Spline)),
    在这里插入图片描述
    接下来要在曲线上取更多的点。

    曲线方程

    直线,两点就可形成一条直线。通过数学表示的直线方程,可以求得直线上任意一点的坐标。同理,曲线也是如此。
    vtk中,vtkParametricSpline包含有曲线方程,
    vtkParametricSpline::Evaluate
    vtkParametricSpline API及描述
    通常,根据需求的不同,有两种方式

    方式一

    点的个数n固定,求步长step。

    	vtkSmartPointer<vtkPoints> outPoints =
    		vtkSmartPointer<vtkPoints>::New();
    	int pointsCnt = 11; // n = 11
    	double step = 1.0 / (pointsCnt - 1);
    	// Fix bug: the result points n probably not enough
    	//for (double i = 0; i <= 1; i += step)
    	//{
    	//	double u[] = {i, 0, 0};
    	//	double p[3];
    	//	spline->Evaluate(u, p, NULL);
    	//	outPoints->InsertNextPoint(p);
    	//}
    	for (int i = 0; i < n; i++)
    	{
    		double u[3] = { i * step, 0, 0 }, p[3];
    		spline->Evaluate(u, p, nullptr);
    		outPoints->InsertNextPoint(p);
    	}
    }
    

    在这里插入图片描述

    方式二

    步长step一定,求点n的个数

    #define DIS(p1, p2) (sqrt((p1[0]-p2[0])*(p1[0]-p2[0]) + (p1[1]-p2[1])*(p1[1]-p2[1]) + (p1[2]-p2[2])*(p1[2]-p2[2])))
    	vtkSmartPointer<vtkPoints> outPoints =
    		vtkSmartPointer<vtkPoints>::New();
    
    	double totalLen = DIS(p0, p1) + DIS(p1, p2);
    	double start = 0;
    	double step = .5;
    
    	while (start <= totalLen)
    	{
    		double u[] = { start/totalLen, 0, 0 };
    		double p[3];
    		spline->Evaluate(u, p, NULL);
    		outPoints->InsertNextPoint(p);
    		start += step;
    	}
    

    在这里插入图片描述

    示例代码

    #include <vtkPolyData.h>
    #include <vtkSmartPointer.h>
    #include <vtkPolyDataMapper.h>
    #include <vtkActor.h>
    #include <vtkRenderWindow.h>
    #include <vtkRenderer.h>
    #include <vtkRenderWindowInteractor.h>
    #include <vtkProperty.h>
    #include <vtkParametricSpline.h>
    #include <vtkParametricFunctionSource.h>
    #include <vtkSphereSource.h>
    #include <vtkGlyph3DMapper.h>
    
    int main(int, char *[])
    {
    	double p0[3] = { 1.0, 0.0, 0.0 };
    	double p1[3] = { 3.0, 2.0, 0.0 };
    	double p2[3] = { 5.0, 0.0, 0.0 };
    
    	vtkSmartPointer<vtkPoints> points =
    		vtkSmartPointer<vtkPoints>::New();
    	points->InsertNextPoint(p0);
    	points->InsertNextPoint(p1);
    	points->InsertNextPoint(p2);
    
    	vtkSmartPointer<vtkParametricSpline> spline =
    		vtkSmartPointer<vtkParametricSpline>::New();
    	spline->SetPoints(points);
    
    	// Method1
    #if (0)
    	vtkSmartPointer<vtkPoints> outPoints =
    		vtkSmartPointer<vtkPoints>::New();
    	int pointsCnt = 11;
    	double step = 1.0 / (pointsCnt-1);
    	for (double i = 0; i <= 1; i = i + step)
    	{
    		double u[] = {i, 0, 0};
    		double p[3];
    		spline->Evaluate(u, p, NULL);
    		outPoints->InsertNextPoint(p);
    	}
    #else
    	// Method2
    #define DIS(p1, p2) (sqrt((p1[0]-p2[0])*(p1[0]-p2[0]) + (p1[1]-p2[1])*(p1[1]-p2[1]) + (p1[2]-p2[2])*(p1[2]-p2[2])))
    	vtkSmartPointer<vtkPoints> outPoints =
    		vtkSmartPointer<vtkPoints>::New();
    
    	double totalLen = DIS(p0, p1) + DIS(p1, p2);
    	double start = 0;
    	double step = .3;
    
    	while (start <= totalLen)
    	{
    		double u[] = { start/totalLen, 0, 0 };
    		double p[3];
    		spline->Evaluate(u, p, NULL);
    		outPoints->InsertNextPoint(p);
    		start += step;
    	}
    #endif
    
    	vtkSmartPointer<vtkParametricSpline> outSpline =
    		vtkSmartPointer<vtkParametricSpline>::New();
    	outSpline->SetPoints(outPoints);
    
    	vtkSmartPointer<vtkParametricFunctionSource> functionSource =
    		vtkSmartPointer<vtkParametricFunctionSource>::New();
    	functionSource->SetParametricFunction(outSpline);
    	functionSource->Update();
    
    	vtkSmartPointer<vtkPolyDataMapper> splineMapper =
    		vtkSmartPointer<vtkPolyDataMapper>::New();
    	splineMapper->SetInputConnection(functionSource->GetOutputPort());
    
    	vtkSmartPointer<vtkActor> splineActor =
    		vtkSmartPointer<vtkActor>::New();
    	splineActor->SetMapper(splineMapper);
    
    	vtkSmartPointer<vtkSphereSource> sphereSource =
    		vtkSmartPointer<vtkSphereSource>::New();
    	sphereSource->SetPhiResolution(21);
    	sphereSource->SetThetaResolution(21);
    	sphereSource->SetRadius(.05);
    
    	vtkSmartPointer<vtkPolyData> splinePointsData =
    		vtkSmartPointer<vtkPolyData>::New();
    	splinePointsData->SetPoints(outPoints);
    
    	vtkSmartPointer<vtkGlyph3DMapper> splinePointsMapper =
    		vtkSmartPointer<vtkGlyph3DMapper>::New();
    	splinePointsMapper->SetInputData(splinePointsData);
    	splinePointsMapper->SetSourceConnection(sphereSource->GetOutputPort());
    
    	vtkSmartPointer<vtkActor> pointsActor =
    		vtkSmartPointer<vtkActor>::New();
    	pointsActor->SetMapper(splinePointsMapper);
    	pointsActor->GetProperty()->SetColor(1, 0, 0);
    
    	vtkSmartPointer<vtkRenderer> renderer =
    		vtkSmartPointer<vtkRenderer>::New();
    	vtkSmartPointer<vtkRenderWindow> renderWindow =
    		vtkSmartPointer<vtkRenderWindow>::New();
    	renderWindow->SetSize(600, 600);
    	renderWindow->AddRenderer(renderer);
    	vtkSmartPointer<vtkRenderWindowInteractor> renderWindowInteractor =
    		vtkSmartPointer<vtkRenderWindowInteractor>::New();
    	renderWindowInteractor->SetRenderWindow(renderWindow);
    
    	renderer->AddActor(splineActor);
    	renderer->AddActor(pointsActor);
    
    	renderWindow->Render();
    	renderWindowInteractor->Start();
    
    	return EXIT_SUCCESS;
    }
    

    Example Download

    Reference
    vtkParametricSpline Class Reference
    在这里插入图片描述

    展开全文
  • 快速分段3次样条曲线拟合和折线重采样算法实现cheungmine (保留所有权利。本文可以在互联网上转载,但不允许出版和印刷) 本文采用3次样条函数,用分段插值的快速计算方法,实现了用鼠标在屏幕上绘制任意光滑的...

    快速分段3次样条曲线拟合和折线重采样算法实现

    cheungmine 

    (保留所有权利。本文可以在互联网上转载,但不允许出版和印刷)

     

    本文采用3次样条函数,用分段插值的快速计算方法,实现了用鼠标在屏幕上绘制任意光滑的曲线,并同时使用折线重采样的拟合方法,去除多余的插值点。本文所叙述的算法,可以用来绘制等高线等光滑曲线,并且由于采用了折线的重采样,以最小的数据量保证了绘图的精确度。

     

    本文以作者2002年根据《计算方法》(同济大学出版社)一书所述的算法为基础修改而得,因为时间久远,这里不再叙述什么是张力样条的具体公式。仅仅对张力样条做简单介绍。

     

    1 问题的提出

     

    在曲线数字化,或绘制曲线的应用中,通常要求曲线是光滑的,并且通过控制点。这在高等数学里,有专门的术语描述--导数的连续性。我们这里做个形象的比喻:拿一根弹性强的硬钢丝,通过固定在木板上的一系列点,就得到一条满足我们要求的光滑的曲线。当我们在钢丝的2端,施加巨大的拉力,可以看到,钢丝在固定点处的光滑程度越来越小,直到变为折线段。这个力就是张力。我们用一个系数表示,就是张力系数f。张力系数是张力的倒数,当f=0时,张力最大,曲线退化为折线段。当f=1,基本类似抛物线。比较合适的取值是:

    f=0.1666667

     

     

    2 样条函数

     

           关于样条函数,我实在忘记原理了。请读者自行学习原理的部分。实际当中,通常是用分段拟合的方法:

           给定木板上(p0,p1,p2,p3)4个固定点,要求样条钢丝依次通过这4个点,我们就可以确定p1,p2之间的样条函数公式。根据这个公式和一定的步长step,就可以插值出p1,p2之间的一系列点q1,q2,...,qn。依次用线段连接这些点,就得到用折线段按拟合出来的样条曲线。步长越小,拟合出的折点越多,越接近曲线的真实值。然而数据量就越多。

     

     

     

     

    3 分段拟合方法

     

           给点一系列固定点p0,p1,p2,...,pn-3,pn-2,pn-1,依次采样上面的分段拟合方法:

    1)  拟合p0,p1,p2,p3得到p1,p2间的点:q11,q12,q13,...,q1m。

    2)  拟合q1m,p2,p3,p4得到p2,p3间的点:q21,q22,q23,...,q2n。

    3)  拟合q2n,p3,p4,p5得到p3,p4间的点:q31,q32,q33,...,q3w。

    4)  ...

    按上面的方法,一直拟合出:pn-3,pn-2间的点。

     

    上面这些拟合点和原来的控制点,按次序就构成了整条函数曲线的拟合折线。采样这种拟合方法,计算量小,极易编制程序。

     

    4 拟合的精度

    但是,这种拟合得出的精度受步长的限制,我们一方面想提高精度Precision,只有把step设置的很小。又不想增加很大的数据量。这是矛盾的:

    Precision <-> 1/step

     

           这种等间距step的拟合方式,无论在曲线的平缓处,还是转弯处,都采用了一样的拟合步长。而通常我们只希望在曲线的平缓处只要少量的几个点就可以达到我们的要求。而在转弯处,用密集些的点拟合。

     

           因此引入了重采样的方法,去除一些不必要的点。重采样的依据就是:

           设折线段上一系列点p0,p1,p2,...,pm,pn。分别计算p1,p2,...,pm到直线p0,pn的距离。如果这些距离的最大值pk,小于某个限值dist,则曲线上的点p1,p2,...,pm都不是必要的,我们只要保留p0,pn即可。(式1)

    如果pk大于我们规定的限值dist,则分别以(p0,p1,p2,...,pk-2,pk-1,pk)和(pk,pk+1,pk+2,...,pm,pn)作为2条新的折线重新计算上面的(式1)。

     

    在编制程序的时候,使用递归可以很容易解决这个问题。在我提供的测试程序中,可以看到2种情况(重采样和不重采样)下的点数是相差很大的。

     

     

     

    5 结论

     

           到此,我们近乎完美地解决问题:采样分段样条插值,并且采用重采样,减小数据量,同时保证精度不受损失。

     

    6 下面就是完整的代码。我采样C语言写的

    /*==============================================================================

         cheungmine - All rights reserved

         April 5, 2009

    ==============================================================================*/

    #include <stdio.h>

    #include <float.h>

    #include <assert.h>

    #include <math.h>

     

    #ifndef CG_BIPI

    #define CG_BIPI        6.28318530717958647692

    #endif

     

    #ifndef IN

    #define IN

    #endif

     

    #ifndef OUT

    #define OUT

    #endif

     

    #ifndef INOUT

    #define INOUT

    #endif

     

    /* Vertex structure */

    typedef struct                      

    {

         double  x, y;

    } cg_vertex_t;

     

    /**

     * CG_vertex_get_dist_to_line

     *  计算点到直线的距离和垂足ft

     */

    double CG_vertex_get_dist_to_line (

                  IN const cg_vertex_t  *pt,

                  IN const cg_vertex_t  *start,

                  IN const cg_vertex_t  *end,

                  OUT cg_vertex_t       *ft)

    {

         double a1 = pt->x - start->x;

         double a2 = pt->y - start->y;

         double s = sqrt(a1*a1 + a2*a2);

     

         a1 = atan2(a2, a1);

         if(a1 < 0) a1 += CG_BIPI;

     

         a2 = atan2((end->y-start->y), (end->x-start->x));

         if(a2 < 0) a2 += CG_BIPI;

     

         a1 = fabs(sin(a1-a2)) * s;

     

         if (ft){

             s *= cos(a1-a2);

             ft->x = start->x + s*cos(a2);

             ft->y = start->y + s*sin(a2);

         }

         return a1;

    }

     

     

     

    /*===========================================================================

                                     Spline3 Functions

    ===========================================================================*/

    /* 返回pl的点到直线[start,end]的最大距离点的索引imax和最大距离smax */

    static int max_dist_at(

                       const   cg_vertex_t* start,

                       const   cg_vertex_t* end,

                       const   cg_vertex_t* pl, int np,

                       double *smax)

    {

         int     i, imax = 0;

         double  s;

         *smax = 0;

     

         // 计算全部点到直线的距离, 找出最大的点

         for(i=0; i<np; i++){

             s = CG_vertex_get_dist_to_line(&pl[i], start, end, 0);

             if (s > *smax){

                  *smax = s;

                  imax = i;

             }

         }

         return imax;

    }

     

    /* 递归重采样方法*/

    static void resample_recursive(

                       const  cg_vertex_t* start,

                       const  cg_vertex_t* end,

                       const  cg_vertex_t* pl,

                       int    np,

                       cg_vertex_t *pout,

                       int   *nout,

                       const double *dist)

    {

         double smax;

         int    imax;

         if (np==0) return;

         imax = max_dist_at(start, end, pl, np, &smax);

         if (imax==0||imax==np-1) return;

         if (smax<*dist) return;

     

         resample_recursive( start, &pl[imax], pl, imax, pout, nout, dist);

     

         pout[(*nout)++] = pl[imax];

     

         resample_recursive( &pl[imax], end, &pl[imax+1], np-imax-1, pout, nout, dist);

    }

     

    /**

     * CG_vertices_fit_resample

     * 曲线重采样拟合, 返回拟合之后的pout数组的点数

     */

    int CGAL_CALL CG_vertices_fit_resample (

                           IN const  cg_vertex_t* start, /* 折线或多边形的起点*/

                           IN const  cg_vertex_t* end,   /* 折线或多边形的终点*/

                           IN const  cg_vertex_t* mids,  /* 折线或多边形的中间点数组*/

                           IN      int            nmid,  /* 折线或多边形的中间点数组的点数*/

                           OUT   cg_vertex_t*     pout,  /* 返回拟合后的中间点数组, 点数组由客户分配,

                                                                 至少与输入的中间点数组的点数相同*/

                           IN   double            dist   /* 拟合的最小距离, 必须指定>0的有效值*/                   

    )

    {

         int  nout = 0;

     

         resample_recursive(start, end, mids, nmid, pout, &nout, &dist);

     

         return nout;

    }

     

    /**

     * CG_vertex_insert_pt_spline

     * 计算张力样条插值点: p1, p2之间的点, 返回插值点数目

     * p0-----p1........p2------p3

     * 本程序为减少数据复制, 采用points数组返回插值点或拟合后的值,

     * 因此调用者必须分配足够的空间以存储中间计算结果和返回的值

     * 必须满足:

     *            size > (|p1,p2|/step)*2

     * 如果设置的step太小, 系统则自动根据size/2来调整step, 确保

     * 计算能正确进行

     */

    int CGAL_CALL CG_vertex_insert_pt_spline (

                           IN   double         step,    /* 插值的步长, 必须指定有效的步长*/

                           IN   cg_vertex_t    p0,      /* 起点*/

                           IN   cg_vertex_t    p1,      /* 插值段的起点*/

                           IN   cg_vertex_t    p2,      /* 插值段的终点*/

                           IN   cg_vertex_t    p3,      /* 终点*/

                           IN OUT cg_vertex_t *points,  /* 返回的插值点数组, 数组由调用者分配*/

                           IN   int            size,    /* 插值点数组的最大尺寸, 此尺寸必须足够容纳2倍的插值点数*/

                           IN   double         ratio,  /* 张力系数[0,1], 最佳0.1666667. -1 为取默认.1666667 */

                           IN   double         dist     /* 拟合的最小距离, 必须>0. <=0 不拟合*/

                       )

    {

         int     i, count, at;

         double  x, y, ca, sa, s12, h1, h2, h3, u1, u2, v1, v3, d1, d2, D, M1, M2;

         cg_vertex_t  end = {p2.x, p2.y};

     

         // 必须计算p1,p2距离, 确保不会溢出

         d1 = p2.x-p1.x;

         d2 = p2.y-p1.y;

         s12 = sqrt(d1*d1 + d2*d2);

     

         // p1,p2距离太小, 返回

         if (dist>0 && s12 < dist)

             return 0;

     

         // 步距离太长, 计算p1与p2中点即可

         if (step > s12/2 ){        

             points[0].x = (p2.x+p1.x)/2;

             points[0].y = (p2.y+p1.y)/2;

             return 1;

         }

     

         // 平移原点至p1

         p0.x -= p1.x;

         p0.y -= p1.y;

         p2.x = d1;

         p2.y = d2;

         p3.x -= p1.x;

         p3.y -= p1.y;

     

         // 旋转至p1->p2为x轴方向

         ca = p2.x / s12;   // cos(a)

         sa = p2.y / s12;   // sin(a)

     

         x = p0.x * ca + p0.y * sa;

         p0.y = -p0.x * sa + p0.y * ca;

         p0.x = x;

         p2.x = s12;

         p2.y = 0;

         x = p3.x * ca + p3.y * sa;

         p3.y = -p3.x * sa + p3.y * ca;

         p3.x = x;

     

         // 判断是否是单值函数

         if ( p0.x * p2.x >= 0 || p2.x * (p2.x-p3.x) >= 0 )

              return 0;

     

         // 计算系数, 这里为清晰起见, 没有优化代码

         h1 = -p0.x;

         h2 = p2.x;

         h3 = p3.x - p2.x;

         u1 = h2/(h1+h2);   // u1=p2.x/(p2.x-p0.x);

         u2 = h2/(h2+h3);   // u2=p2.x/(p3.x-p1.x);

     

         v1 = -p0.y;

         v3 = p3.y;

     

         d1 = -6.0*p0.y/((h1+h2)*p0.x);

         d2 = 6.0*p3.y/(h3*p3.x);

         D  = 4.0-u1*u2;

     

         if(D < 0.001)

             return 0;

     

         M1 = (2*d1-u1*d2)/D;

         M2 = (2*d2-u2*d1)/D;

     

         // 计算插值点数, 如果点数超过size/2, 则自动增大step

         count = (int) floor((s12+step/2)/step);

         if (count > size/2){

             count = size/2;

             step=s12/(count+1);

         }

     

         // 张力系数, 最佳=0.16666667

         if(ratio<0) ratio = 0.16666667;

     

         x = 0.0;

         y = 0.0;

         at = (dist>0 && count<=size/2)? count:0; 

         for(i=0; i < count; i++){

             x += step;

             y =  ratio*x*(M1*(h2-x)*(x-2*h2)+M2*(x-h2)*(x+h2))/h2;

             points[at+i].x = x*ca - y*sa + p1.x;

             points[at+i].y = x*sa + y*ca + p1.y;

         }

     

         // 需要重采样: p1 as start, p2 as end

         if (dist>0)

             count = CG_vertices_fit_resample(&p1, &end, points+at, count, points, dist);

     

         return count;

    }

     

    7 我还提供了一个MFC的测试程序。你只要用鼠标在上面点即可。测试程序演示如何调用上面的函数,实现绘制连续样条曲线。测试程序在下面的链接可以下载得到:

    http://download.csdn.net/source/1177219

     

    程序没实现封闭的样条曲线。在封闭部分有:

    pn-3~~~~qw~pn-2=====pn-1=====p0=====p1~q1~~~~p2

    其中为做曲线计算的部分以=====表示。读者可以多次调用CG_vertex_insert_pt_spline以分别计算拟合pn-2=====pn-1、pn-1=====p0和p0=====p1段的曲线。

     

     

    2009-4-5 by win32 -cheungmine -sdk

     

     

    展开全文
  • matlab采样函数,上采样/下采样,插值/抽取

    万次阅读 多人点赞 2018-07-10 21:34:16
    最近实验需不同长度的数据进行采样点数统一的处理,由于数据长短不一,最后需要规整成一样的长度,不是整数倍的抽取或者插值,所以处理比较麻烦。 现在的考虑有三种方式: (1)采样数据中长度最小值,其他...
  • 曲线振荡很频繁,比例度盘要放大, 曲线漂浮绕大湾,比例度盘往小扳, 曲线偏离回复慢,积分时间往下降, 曲线波动周期长,积分时间再加长, 曲线振荡频率快,先把微分降下来, 动差大来波动慢,微分时间应加长...
  • 采样定理

    2020-01-03 09:58:12
    转自Zero to One博主 采样定理在1928年由美国电信工程师H....香农这一定理加以明确地说明并正式作为定理引用,因此在许多文献中又称为香农采样定理。 奈奎斯特采样定理解释了采样率和所测信号...
  • 刚用Simulink,肯定大家都会有过曲线有锯齿、有毛刺、不平滑、不光滑,或者说是图像不精确,或者说是采样点数太少,如下图所示。(我写这么多种描述,是因为看到好多人的描述都不是我想到的,搜了半天…所以想着自己...
  • 4)数据合成:SMOTE(Synthetic Minority Oversampling Technique)即合成少数类过采样技术,它是基于随机过采样算法的一种改进方案,,SMOTE算法的基本思想是少数类样本进行分析并根据少数类样本人工合成新样本...
  • 超级采样 Supersampling 方式汇总

    万次阅读 2015-05-01 14:27:22
    不像现实中的物体有连续光滑的曲线,锯齿的产生是因为电脑显示给浏览者的是大量的正方形。这些“像素”都是一样大的,每个都有一种颜色。一条线只能被显示成像素的集合,因此出现了锯齿,除非是绝对水平或垂直的线。...
  • 利用S3C44B0X处理器,完全不知道该怎么做,求各位大神给点提示什么的[img=https://forum.csdn.net/PointForum/ui/scripts/csdn/Plugin/001/face/10.gif][/img]
  • 信号的采样

    千次阅读 2014-09-16 15:22:31
    2048HZ信号来说是过采样了,事实上只要信号不混叠就好(满足尼奎斯特采样定理),所以可以采样的信号作抽取,即是所谓的“降采样”。在现场中采样往往受具体条件的限止,或者不存在300HZ的采样率,或调试非常...
  • 图像的上采样(upsampling)与下采样(subsampled)

    万次阅读 多人点赞 2017-11-05 18:34:04
    参考: http://blog.csdn.net/majinlei121/article/details/46742339 ...  缩小图像(或称为下采样(subsampled)或降采样(downsampled))的主要目的有两个:1、使得图像符合显示区域的大小;2、生成
  • 通过跑R-L负载可以变频器硬件电流采样部分进行检查,一般而言,R-L负载的电流比较正弦,通过软件示波器读取采样到的电流AD值,然后绘制曲线就可以知道采样准不准了。 比如下面两张图,第一张图的波形比较正弦、...
  • DataScience:严重不均衡数据集进行多种采样策略(随机过抽样、SMOTE过采样、SMOTETomek综合采样、改变样本权重等)简介、经验总结之详细攻略 目录 严重不均衡数据集进行多种采样策略(随机过抽样、SMOTE过...
  • 采样的基本原理
  • 目录 0 引言 1 曲线控件属性 2 曲线控件的使用 ...采样点数:曲线在整个控件宽度范围,从左到右显示一轮的点数; 采样深度:一个采样数据的占的字节。 “ 1Byte”、 “ 2Byte”可选,默认为 1B
  • 光谱数据重采样

    2018-10-11 10:21:11
    matlab代码,用于高光谱、多光谱数据重采样,内容清晰
  • 本篇文章中有着详细的解答,我想大家看完这篇文章定会大家有帮助~ 香农采样定理是这样描述的:采样频率fs至少为关心的信号最高频率的2倍。采样频率的一半称为奈奎斯特频率。采样频率的一半也称为分析带宽,或简称...
  • 采样和没有过采样的区别

    千次阅读 2014-07-31 11:36:48
    原文地址:过采样和没有过采样的区别作者:玄子  ...仿真了1024条载波在有过采样和没有的时候的BER曲线,可以看看多大差别啊。第一张图过采样因子为4,4QAM映射,没有调制到高频上去,小小的clip了一下。
  • 低通采样定理与带通采样定理

    千次阅读 多人点赞 2019-12-06 21:29:24
    一、(低通)采样定理 如何从抽样信号中恢复原连续信号、在什么条件下才可以无失真地由采样信号恢复原连续信号,著名的采样定理对此作了明确的回答。 采样定理在通信系统、信息传输理论、数字信号处理等方面...
  • 关于OpenCV的上采样和下采样

    千次阅读 2018-12-18 10:13:05
    2、生成对应图像的缩略图(最直观的理解,所以深度学习领域被卷积核之后的特征图叫下采样,从尺寸角度来看,大部分确实会缩小尺寸)。 上采样(upsampling)(或称为放大图像(分割领域,GAN领域直观理解的尺寸也...
  • 常用的电流采样计算方法有平均值采样法和有效值采样法。现将这两种电流采样算法进行分析比较。 硬件连接示意图 交流220V通过全桥整流滤波后变为直流310V,直流310V给后端负载供电,采样电阻Rs串联在直流回路的...
  • Metropolis 采样算法

    万次阅读 多人点赞 2018-02-11 11:17:07
    Metropolis 采样算法简介 Metropolis 采样算法思路 Metropolis 采样算法步骤 Metropolis 采样算法实例 后记 参考文献 前言 Metropolis 采样算法解决的问题是:从一个复杂的目标分布获取近似的样本。 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 32,865
精华内容 13,146
关键字:

对曲线采样