java 三次样条插值画光滑曲线例子

java 三次样条插值画光滑曲线例子

主要是做数值拟合，根据sin函数采点，取得数据后在java中插值并在swing中画出曲线，下面为截图不光滑和光滑曲线前后对比：

代码：

执行类：

 package com.yang.logic;

 import java.util.ArrayList;

 import java.util.Collections;

 import java.util.Comparator;

 import java.util.List;

 import com.yang.logic.Drawlineforspline.Mypanel;

 public class Testspline {

     // 根据X排序

     class SortByX implements Comparator {

         public int compare(Object obj1, Object obj2) {

             PointStruct point1 = (PointStruct) obj1;

             PointStruct point2 = (PointStruct) obj2;

             if (point1.dx > point2.dx)

                 return 1;

             else

                 return 0;

         }

     }

     //转化成数组

     public static ArrayList<Double> getArrayfList(List<PointStruct> l, String type) {

         ArrayList<Double> tmplist = new ArrayList<Double>();

         for (PointStruct p : l) {

             if (type == "ix") {

                 tmplist.add((double) p.ix);

             } else if (type == "iy") {

                 tmplist.add((double) p.iy);

             } else if (type == "dx") {

                 tmplist.add(p.dx);

             } else if (type == "dy") {

                 tmplist.add(p.dy);

             }

         }

         return tmplist;

     }

     public static void main(String[] args) {

         //将来做插值的点列表

         List <PointStruct> pl=new  ArrayList<PointStruct>();

         //【1】 模拟 sin函数值  做初始化特定点（插值点或样条），  曲线将来就穿过下面几点

         //        0.1    1    2    3    4

         //        0.099833417    0.841470985    0.909297427    0.141120008    0.61802

         pl.add(new PointStruct(0.1,0.099833417));

         pl.add(new PointStruct(1,0.841470985));

         pl.add(new PointStruct(2,0.909297427));

         pl.add(new PointStruct(3,0.141120008));

         pl.add(new PointStruct(4,0.61802));

         //【2】 添加 需要的未知点（新插值点）， 为了使曲线光滑  采用小的步长 填充在已知点之间

         List <PointStruct> target=new  ArrayList<PointStruct>();

         double step=0.1;

         for(int k=0;k<pl.size();k++){

             if((k+1)<pl.size()){

                 double tmpd=0;

                 while(tmpd<pl.get(k+1).dx){

                     tmpd=tmpd+step;

                     target.add(new PointStruct(tmpd,0.0));

                 }

             }

         }

         //把点集合转化成为 x,y 各自的坐标点 Double[]集合

         ArrayList tmp_x = getArrayfList(pl,"dx");

         ArrayList tmp_y = getArrayfList(pl,"dy");

         Double[] xspline=new Double[tmp_x.size()];

         Double[] yspline=new Double[tmp_x.size()];

         for(int e=0;e<tmp_x.size();e++){

             xspline[e]=(Double) tmp_x.get(e);

             yspline[e]=(Double) tmp_y.get(e);

         } 

         //【3】根据 插值点初始化插值对象,并用spline样条函数进行计算（做三次样条插值运算）

         Interpolation ip = new Interpolation(xspline, yspline);

         for(int j=0;j<target.size();j++){

             target.get(j).dy=ip.spline(target.get(j).dx);

         }

         //把新生成的样条添加到点集合中  做以后画图用

         pl.addAll(target);

         //根据x点的大小进行点集合的排序

         Testspline t2=new Testspline();

         Collections.sort(pl, t2.new SortByX());

         //因为结果太小，所有必要放大一定度数，同时 Java画图最像是整数，所有把双精度转成整形

         int intScale=100;

         for(PointStruct p:pl){

              p.ix=(int) (p.dx*intScale);

              p.iy=(int) (p.dy*intScale);

         }

         //查看中间结果 即画图所用到的所有点

         int times=0;

         for(PointStruct p:pl){

             System.out.println(" order： :"+times++ +"  p.ix:"+p.ix+"    p.iy:"+p.iy);

         }

         //【4】 调用画图类 画图

         Drawlineforspline dlfs=new Drawlineforspline(pl);

         Mypanel myp=dlfs.new Mypanel();

         dlfs.add(myp); 

     }

 }

依赖类：

PointStruct

 package com.yang.logic;

 public class PointStruct {

     double dx;

     double dy;

     int ix;

     int iy;

     public PointStruct(double dx, double dy) {

         this.dx = dx;

         this.dy = dy;

     }

     public PointStruct(int ix, int iy) {

         this.ix = ix;

         this.iy = iy;

     }

     public PointStruct(double dx, double dy,boolean round) {

         this.ix = RoundF(dx);

         this.iy = RoundF(dy);

     }

     public int RoundF(double a){

         return (int) Math.round(a);

     }

 }

Interpolation

 package com.yang.logic;

 import java.util.Arrays;

 public class Interpolation {

     private int n;

     private Double[] xs;

     private Double[] ys;

     private boolean sp_initialized;

     private double[] sp_y2s;

     public Interpolation(Double[] _xs, Double[] _ys) {

         this.n = _xs.length;

         this.xs = Arrays.copyOf(_xs, _xs.length);

         this.ys = Arrays.copyOf(_ys, _ys.length);

         this.sp_initialized = false;

     } 

     public double spline(double x)

     {

         if (!this.sp_initialized) {

             // Assume Natural Spline Interpolation

             double p, qn, sig, un;

             double[] us;

             us = new double[n-1];

             sp_y2s = new double[n];

             us[0] = sp_y2s[0] = 0.0;

             for (int i=1; i<=n-2; i++) {

                 sig = (xs[i] - xs[i-1]) / (xs[i+1] - xs[i-1]);

                 p = sig * sp_y2s[i-1] + 2.0;

                 sp_y2s[i] = (sig - 1.0) / p;

                 us[i] = (ys[i+1] - ys[i]) / (xs[i+1] - xs[i]) - (ys[i] - ys[i-1]) / (xs[i] - xs[i-1]);

                 us[i] = (6.0 * us[i] / (xs[i+1] - xs[i-1]) - sig * us[i-1]) / p;

             }

             qn = un = 0.0;

             sp_y2s[n-1] = (un - qn * us[n-2]) / (qn * sp_y2s[n-2] + 1.0);

             for (int k=n-2; k>=0; k--) {

                 sp_y2s[k] = sp_y2s[k] * sp_y2s[k+1] + us[k];

             }

             this.sp_initialized = true;

         }

         int klo, khi, k;

         double h, b, a;

         klo = 0;

         khi = n-1;

         while (khi-klo > 1) {

             k = (khi+klo) >> 1;

             if (xs[k] > x)

                 khi = k;

             else

                 klo = k;

         }

         h = xs[khi] - xs[klo];

         if (h == 0.0) {

             throw new ArithmeticException();

         }

         a = (xs[khi] - x) / h;

         b = (x - xs[klo]) / h;

         return a*ys[klo] + b*ys[khi] + ((a*a*a-a)*sp_y2s[klo]+(b*b*b-b)*sp_y2s[khi])*(h*h)/6.0;

     }

 }

Drawlineforspline

 package com.yang.logic;

 import java.awt.Color;

 import java.awt.Graphics;

 import java.util.List;

 import javax.swing.JFrame;

 import javax.swing.JPanel;

 public class Drawlineforspline extends JFrame{

     private static final long serialVersionUID = 1L;

     List <PointStruct>plist;

     public Drawlineforspline(){

         init();

     }

     public Drawlineforspline(List<PointStruct> plist){

         init();

         this.plist=plist;

     }    

     private void init(){

         this.setTitle("drawline");

         this.setBounds(200, 200, 500, 400);

         this.setBackground(Color.white);

         this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

         this.setLocationRelativeTo(null);

         this.setVisible(true);

     }

     public class Mypanel extends JPanel{

         public void paint(Graphics g){

             g.setColor(Color.red);

             //System.out.println(plist.size());

             for(int i=0;i<plist.size()-1;i++){

                 g.drawLine(plist.get(i).ix, plist.get(i).iy, plist.get(i+1).ix, plist.get(i+1).iy);

             }

         }

     }

 }

代码下载地址

转载请注明 http://www.cnblogs.com/rojas/p/4595509.html

巴特西

java 三次样条插值画光滑曲线例子

最新文章

热门文章

巴特西

java 三次样条插值 画光滑曲线 例子

最新文章

热门文章

java 三次样条插值画光滑曲线例子