/*
Copyright 2000 by Ralph Hartley
This software is licenced under the terms of the
Gnu Public Licence
*/
import java.awt.*;
import java.util.*;
import java.awt.geom.*;
import java.awt.image.*;
import javax.swing.*;

public class Mapping implements Dragable,java.io.Serializable{

  private static final long serialVersionUID = Version.getSUID();

  public int stacnt  = 0;
  public Vertex[] spoint;
  float[][] im;
  int stacntplus = 0;
  public boolean degenerate = false;

  static public double maxslope = 20;

  public boolean isVertical = false;

  double[] xcoif,ycoif;
  boolean solved = false;
  float[][] mapx;
  transient int selected = -1;
  transient int[] dragpos;
  transient int oldi;
  transient int oldj;
  transient java.awt.Graphics draggraphics;
  transient double dscale=1;

  static public double beta;
  static public double theta;
  static public double sideoff;
  static public double mindist;
  static public double linethresh;

  HashSet nearverticals = new HashSet();

  int wide1 = 0;
  int wide2 = 0;
  AffineTransform overlaytrans = null;
  boolean tchanged = false;

  double maxdist = 0;

  int width = -1;
  int height = -1;

  static double MAXERR = 0.0001;
  static int MAXINTS = 15;

  transient QuadTree tree = null;

//  transient SoftReference scoords = new SoftReference(null);
//  transient SoftReference spixels = new SoftReference(null);

  transient public SegEditor editor = null;

  public Mapping(int snum,boolean isVertical){
    this.isVertical = isVertical;
    spoint = new Vertex[snum+1];
    im = new float[snum+1][2];
  }

  public boolean used(Vertex station) {
    for (int i=0;i<stacnt;i++)
      if (spoint[i]==station) return(true);
    return(false);
  }

  public void remove(Vertex station) {
    for (int i=0;i<stacnt;i++)
      if (spoint[i]==station)
        unmark(i);
  }

  public void setScale(double scale) {
    setOverlayTrans();
    if (overlaytrans==null||isVertical)
      overlaytrans = AffineTransform.getScaleInstance(scale,-scale);
  }

  public double getScale() {
    if (overlaytrans==null) return(Segment.defscale);
    return(overlaytrans.getScaleX());
  }

  void adjustCount() {
    if (stacnt>(spoint.length-10)) {
      solved = false;
      Vertex[] nsp = new Vertex[spoint.length * 2];
      float[][] nim = new float[spoint.length * 2][];
      for (int i=0;i<stacnt;i++) {
        nsp[i] = spoint[i];
        nim[i] = im[i];
      }
      for (int i=stacnt; i<spoint.length*2; i++)
        nim[i] = new float[2];
      spoint = nsp;
      im = nim;
    }
    else if (stacnt<(spoint.length/3) && spoint.length>30) {
      solved=false;
      Vertex[] nsp = new Vertex[spoint.length/2];
      float[][] nim = new float[spoint.length/2][];
      for (int i=0;i<spoint.length/2;i++) {
        nsp[i] = spoint[i];
        nim[i] = im[i];
      }
      spoint = nsp;
      im = nim;
    }
  }

  public void reattachStations(Survey survey) {
    for (int i=0;i<stacnt;i++) {
      spoint[i] = survey.getStation(spoint[i]);
    }
    solved = false;
  }

  public void btrans(Point2D p,Point2D res) {
    if (isVertical) {
      overlaytrans.transform(p,res);
      return;
    }
    double x = (float)p.getX();
    double y = (float)p.getY();

    int i;
    double u = xcoif[stacntplus] + xcoif[stacntplus+1] * x + xcoif[stacntplus+2] *y;
    double v = ycoif[stacntplus] + ycoif[stacntplus+1] * x + ycoif[stacntplus+2] *y;

    for (i=0;i<stacntplus;i++) {
      double localh = h(x-mapx[i][0],y-mapx[i][1]);
      u += xcoif[i] * localh;
      v += ycoif[i] * localh;
    }

    res.setLocation(u,v);
  }

/*                 
  public double[] getMorphData(Point2D p) {

    double x = (float)p.getX();
    double y = (float)p.getY();

    double u = xcoif[stacntplus] + xcoif[stacntplus+1] * x + xcoif[stacntplus+2] *y;
    double v = ycoif[stacntplus] + ycoif[stacntplus+1] * x + ycoif[stacntplus+2] *y;

    for (int i=0;i<stacntplus;i++) {
      double localh = h(x-mapx[i][0],y-mapx[i][1]);
      u += xcoif[i] * localh;
      v += ycoif[i] * localh;
    }

    double[][] grad = new double[2][2];

    getGrad(grad,u,v);
    System.out.println("grad = "+grad);

    double[] res = new double[4];

    res[0] = u;
    res[1] = v;
    res[2] = Math.atan2(grad[0][0]+grad[1][1],grad[0][1]-grad[1][0]);
    res[3] = Math.sqrt(grad[0][1]*grad[1][0] - grad[1][1]*grad[0][0]);

    System.out.println(" det = "+(grad[0][0]*grad[1][1]-grad[0][1]*grad[1][0]));

    System.out.println("res x = "+res[0]+" y = "+res[1]+
      " theta = "+ res[2]*180/Math.PI + " scale = "+ res[3]);

    return(res);
  }
*/               
/**
 * Finish the drag perminantly fixing the selected item at the
 * location of the last move.
 * Return true if succesfull, otherwize item is still selected.
 * @return boolean
 */
  public void fix() {
    if (draggraphics==null) return;
    im[selected][0] = oldi;
    im[selected][1] = oldj;
//    if (editor!=null) editor.select(spoint[selected]);    (it is already selected)
    setOverlayTrans();
//    System.out.println("trans = "+overlaytrans);
  }

  public void delete() {
    if (draggraphics==null) return;
    if (stacnt!=0) {
      unmark(selected);
      setOverlayTrans();
    }
  }

  public void unmark(int p) {
    solved=false;
    for (int i=p;i<stacnt-1;i++) {
      spoint[i] = spoint[i+1];
      im[i][0] = im[i+1][0];
      im[i][1] = im[i+1][1];
    }
    stacnt--;
    adjustCount();
  }

  public void setSelection(Vertex v) {
    selected = -1;
    if (v==null) return;
    for (int i=0;i<stacnt;i++)
      if (v==spoint[i]) selected = i;
//    if (editor!=null) editor.select(spoint[selected]);
  }

  public void locate(Object what,int x,int y){
    if (isVertical) {
      ErrorLog.log("This segment is marked as 'vertical',\n"+
        	   "meaning that it is a cross section.\n"+
        	   "Point based morphing is not implemented\nfor cross sections.");
      return;
    }
    Vertex v = null;
    if (what instanceof Vertex) v = (Vertex)what;
    else return;
    for (int i=0;i<stacnt;i++) {
      if (v==spoint[i]) return;
//      if (checkVertical(v,spoint)) return;;
    }
    solved = false;
    spoint[stacnt] = v;
    im[stacnt][0] = x;
    im[stacnt][1] = y;
    stacnt++;

    adjustCount();

    setOverlayTrans();

    selected = stacnt-1;

//    if (editor!=null) editor.select(spoint[selected]);
  }

  public AffineTransform setOverlayTrans() {
    if (isVertical) {
      return(overlaytrans);
    }

    int i,j;
    maxdist=0;
    double dist=0;

    for (i=0;i<stacnt;i++)
      for (j=i+1;j<stacnt;j++) {
        dist = spoint[i].position.hdist(spoint[j].position);
        double vdist = spoint[i].position.vdist(spoint[j].position);
        if (dist==0) unmark(j--);
        else if (vdist>dist*maxslope &&
          !nearverticals.contains(new Line(spoint[i],spoint[j]))) {
          String options[] = {"unmark "+spoint[i].label,"unmark "+spoint[j].label,
        		    "keep both","unmark both"};
          int res = JOptionPane.showOptionDialog(
            null,"Near vertical shots may give bad morphing results",
            "Vertical",0,JOptionPane.QUESTION_MESSAGE,
            null,options,null);
          if (res==0) {
            unmark(i--);
            break;
          }
          if (res==1) unmark(j--);
          if (res==2)
            nearverticals.add(new Line(spoint[i],spoint[j]));
          if (res==3) {
            unmark(j);
            unmark(i--);
            break;
          }
        }
        if (dist>maxdist) {
          maxdist = dist;
          wide1=i;
          wide2=j;
        }
      }
//    System.out.println("wide1 = spoint["+wide1+"] ="+spoint[wide1].label+" at "+spoint[wide1].position + "  " +
//        	       "wide1 = spoint["+wide2+"] ="+spoint[wide2].label+" at "+spoint[wide2].position);
//    System.out.println("dist = "+maxdist);
//    System.out.println("image1 = ("+im[wide1][0]+","+im[wide1][1]+") "+
//        	       "image2 = ("+im[wide2][0]+","+im[wide2][1]+")");

    if (maxdist==0) return(overlaytrans = null);

    double a = ((spoint[wide2].position.X[0]-spoint[wide1].position.X[0])*(im[wide2][0]-im[wide1][0]) -
        	(spoint[wide2].position.X[1]-spoint[wide1].position.X[1])*(im[wide2][1]-im[wide1][1]))/
      (maxdist*maxdist);
    double b = ((spoint[wide2].position.X[1]-spoint[wide1].position.X[1])*(im[wide2][0]-im[wide1][0]) +
        	(spoint[wide2].position.X[0]-spoint[wide1].position.X[0])*(im[wide2][1]-im[wide1][1]))/
      (maxdist*maxdist);

//    System.out.println("a = "+a+" b = "+b);

    AffineTransform newoverlaytrans = 
      new AffineTransform(a,b,b,-a,
        		  im[wide1][0]-a*spoint[wide1].position.X[0]-b*spoint[wide1].position.X[1],
        		  im[wide1][1]-b*spoint[wide1].position.X[0]+a*spoint[wide1].position.X[1]);

    if (overlaytrans==null || !overlaytrans.equals(newoverlaytrans)) {
      overlaytrans = newoverlaytrans;
      tchanged = true;
    }
    return(overlaytrans);
  }

  public void getGrad(double[][] A, double x, double y) {

    A[0][0] = xcoif[stacntplus+1];
    A[0][1] = xcoif[stacntplus+2];
    A[1][0] = ycoif[stacntplus+1];
    A[1][1] = ycoif[stacntplus+2];


    for (int i=0;i<stacntplus;i++) {
      double[] grad = gradh(x-mapx[i][0],y-mapx[i][1]);
      A[0][0] += xcoif[i] * grad[0];
      A[0][1] += xcoif[i] * grad[1];
      A[1][0] += ycoif[i] * grad[0];
      A[1][1] += ycoif[i] * grad[1];
    }

  }
  
// ftrans is the tricky one. The mapping we use does not give
// this directly. So we do it by approximation (Newton).
  public Point2D ftrans(Point2D p,Point2D.Double guess) {
    if (isVertical)
      try {
        return(overlaytrans.inverseTransform(p,guess));
      } catch (NoninvertibleTransformException ex) {ErrorLog.exception(ex,"bad transform (internal error)");}

    // as a starting guess use the location of the closest known point
    double min = (p.getX()-im[0][0])*(p.getX()-im[0][0])+(p.getY()-im[0][1])*(p.getY()-im[0][1]);
    int mini = 0;
    double dist;
    int i;
    for (i=1;i<stacntplus;i++) {
      dist = (p.getX()-im[i][0])*(p.getX()-im[i][0])+(p.getY()-im[i][1])*(p.getY()-im[i][1]);
      if (dist<min) {
        min=dist;
        mini = i;
      }        	
    }        		
    guess.setLocation(mapx[mini][0],mapx[mini][1]);
    Linset jacobian = new Linset(2);
    Point2D q = new Point2D.Double();
//    float[] e = new float[2];
    double[] grad = new double[2];
    float error;
//System.out.println("ftrans");
    for (int j=0;j<MAXINTS;j++) {
      btrans(guess,q);
      jacobian.b[0] = p.getX()-q.getX();
      jacobian.b[1] = p.getY()-q.getY();
      error = (float)(jacobian.b[0]*jacobian.b[0]+jacobian.b[1]*jacobian.b[1]);
//        System.out.println("error = "+error);
      if (error<MAXERR) break;
      getGrad(jacobian.A,guess.getX(),guess.getY());

      jacobian.ludcmp();
      jacobian.lubksb();
      guess.x += jacobian.b[0];
      guess.y += jacobian.b[1];
 
//      if (j==MAXINTS-1) System.out.println("Max ints");
   }
    return guess;
  }

  Rectangle2D btransBounds(Rectangle2D box,AffineTransform trans, double margin) {
    Point2D pos = new Point2D.Double(box.getX(),box.getY());
    ttrans(pos,pos,trans);
    Rectangle2D res = new Rectangle2D.Double(pos.getX(),pos.getY(),0,0);
    pos.setLocation(box.getX(),box.getMaxY());
    ttrans(pos,pos,trans);
    res.add(pos);
    pos.setLocation(box.getMaxX(),box.getY());
    ttrans(pos,pos,trans);
    res.add(pos);
    pos.setLocation(box.getMaxX(),box.getMaxY());
    ttrans(pos,pos,trans);
    res.add(pos);
    res.add(res.getX()-margin,res.getY()-margin);
    res.add(res.getMaxX()+margin,res.getMaxY()+margin);
    return(res);
  }

  public void ttrans(Point2D pos,Point2D res,AffineTransform trans) {
    try {
      trans.inverseTransform(pos,res);
    } catch (java.awt.geom.NoninvertibleTransformException ex) {
      ErrorLog.exception(ex);
    }
    btrans(res,res);
  }

  public BufferedImage getImage(Image raw,AffineTransform trans,
        			Rectangle2D bounds,Polygon boundary,
        			String str,
        			boolean transparent) throws CookKillException {

    if (raw==null) return(null);

    adjustCount();

//    solve();
//    message.setText("Building quadtree "+str);
    CartoFrame.message.setText("Reading "+str);

    int pixels[] = null;
//    int width=-1,height=-1;

    try {
      for (/*width= -1*/;width<=0;width = raw.getWidth(null)) Thread.sleep(50);
      for (/*height= -1*/;height<=0;height = raw.getHeight(null)) Thread.sleep(50);
    } catch(InterruptedException e){ErrorLog.exception(e);};
    pixels = new int[width*height];
    PixelGrabber pg = new PixelGrabber(raw,0,0,width,height,pixels,0,width);
    try {
      pg.grabPixels();
    } catch(InterruptedException e){ErrorLog.exception(e);};
    pixels[0] = 0;

    CartoFrame.message.setText("Morphing "+str);

    int w = (int)bounds.getWidth() + 1;
    int h = (int)bounds.getHeight() + 1;

    int[] tpixels = new int[w*h];
    int x,y;
    int progress = -1;

    if (tree==null) tree = new QuadTree(this,trans,bounds,boundary);
    int[][][] coords = tree.getCoords();
    tree = null;
    int[] pos=null;

    for (x=0;x<w;x++) {
      if (x*20/w > progress) {
        if (Carto.kill==Carto.COOKKILL) {
          throw new CookKillException();
        }
        progress = x*20/w;
        CartoFrame.message.setText(str + " %" + (5*progress));
      }
      for (y=0;y<h;y++) {
        int p = x+w*y;
        pos = coords[x][y];
        if (pos[0]>=0 && pos[0]<width-1 &&   //check for karma - a bad boundary could fail.
            pos[1]>=0 && pos[1]<height-1) {
          tpixels[p] = pixels[pos[0]+pos[1]*width];
          if (transparent &&
              (0==((~tpixels[p])&((1<<24)-1))))
            tpixels[p]=0;
        }
        else tpixels[p]=0;
      }
    }

//System.out.println("mapping done by getimage");
//    message.setText("Finishing "+str);
    pixels = null;
    coords = null;
    BufferedImage res = new BufferedImage(w,h,BufferedImage.TYPE_INT_ARGB);
    res.getRaster().setDataElements(0,0,w,h,tpixels);
    tpixels = null;
    return(res);
  }

  double[] gradh(double x, double y) {
    double[] res = new double[2];
    if (x==0 && y==0) { res[0]=res[1]=0.0; return res;}
    double mag = theta*(1+Math.log(x*x+y*y));
    res[0]= x*mag;
    res[1]= y*mag;
    return res;
  }

  double h(double x, double y) {
    return (theta*(x*x+y*y)*Math.log(x*x+y*y+mindist));
  }

  double hsq(double xsq) {
    return (theta*xsq*Math.log(xsq+mindist));
  }

  double hrange(float[] mapx, Rectangle2D zone) {

    int outcode = zone.outcode(mapx[0],mapx[1]);
    double mindistsq = 0;
    if (0!=(outcode & Rectangle2D.OUT_LEFT))
      mindistsq += (mapx[0]-zone.getX())*(mapx[0]-zone.getX());
    else if (0!=(outcode & Rectangle2D.OUT_RIGHT))
      mindistsq += (mapx[0]-zone.getMaxX())*(mapx[0]-zone.getMaxX());
    if (0!=(outcode & Rectangle2D.OUT_TOP))
      mindistsq += (mapx[1]-zone.getY())*(mapx[1]-zone.getY());
    else if (0!=(outcode & Rectangle2D.OUT_BOTTOM))
      mindistsq += (mapx[1]-zone.getMaxY())*(mapx[1]-zone.getMaxY());

    double maxdistsq;
    if (mapx[0]>zone.getX()+zone.getWidth()/2.0)
      maxdistsq = (mapx[0] - zone.getX()) * (mapx[0] - zone.getX());
    else 
      maxdistsq = (mapx[0] - zone.getMaxX()) * (mapx[0] - zone.getMaxX());

    if (mapx[1]>zone.getY()+zone.getHeight()/2.0)
      maxdistsq += (mapx[1] - zone.getY()) * (mapx[1] - zone.getY());
    else 
      maxdistsq += (mapx[1] - zone.getMaxY()) * (mapx[1] - zone.getMaxY());

    double minh = hsq(mindistsq);
    double maxh = hsq(maxdistsq);

    System.out.println("mind = "+Math.sqrt(mindistsq)+" h ="+minh+"maxd = "+Math.sqrt(maxdistsq)+" h ="+maxh);

    if (mindistsq<1/Math.E && maxdistsq<1/Math.E) return(minh-maxh);
    if (mindistsq<1/Math.E && maxdistsq>1/Math.E) {
      if (minh<maxh) return(maxh-theta*2.0/Math.E);
      else return(minh-theta*2.0/Math.E);
    }
    return(maxh-minh);
  }

/**
 * provisionally move the selected item.
 * Return true if the new position is OK
 * @param x float
 * @param y float
 */
public void move(int x,int y)
{
  if (draggraphics==null) return;
  showStation(draggraphics,oldi/dscale,oldj/dscale);
        
  oldi = (int)im[selected][0]+x-dragpos[0];
  oldj = (int)im[selected][1]+y-dragpos[1];

  showStation(draggraphics,oldi/dscale,oldj/dscale);

  solved=false;

  if (editor!=null) editor.select(spoint[selected]);
}
        
/**
 * select the item closest to the position given. Return true if an
 * item was selected. g is a graphics object on which to display the process.
 * @return boolean
 * @param e java.awt.Event
 */
public boolean select(int x,int y, java.awt.Graphics g)
{
        float dist;
        
        dragpos=new int[2];
        dragpos[0] = x;
        dragpos[1] = y;

        if (stacnt==0) return false;

//        int oldselect = selected;
        selected = 0;
        float min = (dragpos[0]-im[0][0])*(dragpos[0]-im[0][0])+(dragpos[1]-im[0][1])*(dragpos[1]-im[0][1]);

        for (int i=1;i<stacnt;i++) {
        	dist = (dragpos[0]-im[i][0])*(dragpos[0]-im[i][0])+(dragpos[1]-im[i][1])*(dragpos[1]-im[i][1]);
        	if (dist<min) {
        		min=dist;
        		selected = i;
        	}		
        }

//        if (editor!=null) editor.select(spoint[selected]);

        draggraphics = g;
        g.setXORMode(java.awt.Color.white);
        oldi = (int)im[selected][0];
        oldj = (int)im[selected][1];

               showStation(g,oldi/dscale,oldj/dscale);
        return true;
}        

  public void showStation(Graphics g,double x,double y){
    x *= dscale;
    y *= dscale;
    g.drawLine((int)(x+8),(int)(y+4),(int)(x-8),(int)(y+4));
    g.drawLine((int)(x+8),(int)(y+4),(int)x,(int)(y-8));
    g.drawLine((int)(x-8),(int)(y+4),(int)x,(int)(y-8));
  }

  public void paint(Graphics g,double scale) {
    dscale = scale;
    for (int i=0;i<stacnt;i++) {
      if (i==selected) g.setColor(Segment.selectc);
      showStation(g,im[i][0],im[i][1]);
      g.drawString(spoint[i].label,(int)(im[i][0]*dscale+5),(int)(im[i][1]*dscale+5));
      if (i==selected) g.setColor(Segment.stationc);
    }
  }

  public void solve() {
    if (solved) return;

    tree = null;

    if (isVertical) {
      if (overlaytrans==null) overlaytrans = AffineTransform.getScaleInstance(1,-1);
      return;
    }
    solved = true;

    int i,j;

    double dist = 0;

//    System.out.println("Debug data:");
//    System.out.println("p1 = "+spoint[p1].label+" at "+spoint[p1].position + "  " +
//        	       "p2 = "+spoint[p2].label+" at "+spoint[p2].position);
//    System.out.println("dist = "+maxdist);
//    System.out.println("image1 = ("+im[p1][0]+","+im[p1][1]+")"+" image2 = ("+im[p2][0]+","+im[p2][1]+")");

    degenerate = true;
    double x0 = spoint[wide1].position.X[0];
    double x1 = spoint[wide2].position.X[0];
    double y0 = spoint[wide1].position.X[1];
    double y1 = spoint[wide2].position.X[1];
    double co = x0*(y1-y0) - y0*(x1-x0);
//    double den = Math.sqrt((x0-x1)*(x0-x1)+(y0-y1)*(y0-y1));
    for (i=0;i<stacnt;i++) {
      dist = (spoint[i].position.X[0]*(y0-y1) + spoint[i].position.X[1]*(x1-x0) + co)/maxdist;
//    System.out.println("spoint["+i+"] = "+spoint[i].label+" at "+spoint[i].position +
//        	       " dist = "+dist);
      if (dist<0) dist = -dist;
      if (dist>maxdist*linethresh) degenerate = false;
    }

    if (degenerate) {
      spoint[stacnt] = new Vertex(new Vect((x0+x1)/2+(y0-y1),
        				   (y0+y1)/2+(x1-x0),
        				   0));
      im[stacnt][0] = (im[wide1][0]+im[wide2][0])/2 + im[wide2][1] -im[wide1][1];
      im[stacnt][1] = (im[wide1][1]+im[wide2][1])/2 + im[wide1][0] -im[wide2][0];
      stacntplus = stacnt+1;
//      System.out.println("map point = "+spoint[stacnt].position+" imgpoint = ("+im[stacnt][0]+","+im[stacnt][1]+")");
    }
    else stacntplus = stacnt;

     mapx = new float[stacntplus][2];
     for (i=0;i<stacntplus;i++) {
       mapx[i][0] = (float)spoint[i].position.X[0];
       mapx[i][1] = (float)spoint[i].position.X[1];
     }

     Linset set = new Linset(stacntplus+3);
//System.out.println("solve setting up matrix");
     for (i=0;i<stacntplus;i++) {
       set.A[i][stacntplus] = 1.0;
       set.A[stacntplus][i] = 1.0;
       set.A[i][stacntplus+1] =
           set.A[stacntplus+1][i] = mapx[i][0];
       set.A[i][stacntplus+2] = 
           set.A[stacntplus+2][i] = mapx[i][1];

       for (j=0;j<stacntplus;j++) {
         set.A[i][j] = h(mapx[j][0]-mapx[i][0],mapx[j][1]-mapx[i][1]);
         if (i==j) set.A[i][j] = 1.0/beta;
       }
     }

     for (i=stacntplus;i<stacntplus+3;i++)
       for (j=stacntplus;j<stacntplus+3;j++)
         set.A[i][j]=0;
     set.ludcmp();
     for (i=0;i<stacntplus;i++)
       set.b[i] = im[i][0];
     for (i=stacntplus;i<stacntplus+3;i++)
       set.b[i] = 0;

     set.lubksb();

     xcoif = new double[stacntplus+3];

     for (i=0;i<stacntplus+3;i++)
       xcoif[i] = set.b[i];
     for (i=0;i<stacntplus;i++)
       set.b[i] = im[i][1];
     for (i=stacntplus;i<stacntplus+3;i++)
       set.b[i] = 0;
     
     set.lubksb();

     ycoif = new double[stacntplus+3];

     for (i=0;i<stacntplus+3;i++)
       ycoif[i] = set.b[i];

//System.out.println("solve done");
//for (i=0;i<stacnt+3;i++)
//System.out.println("xcoif["+i+"] = "+xcoif[i]+" ycoif["+i+"] = "+ycoif[i]);
  }
}