import java.awt.*;
public class LevelSet{

  final double PARAM=0.05;
  int error=0;
  double ww,hh;
  int numberofpoint=0;
  Polygon boundbox;
  Vertex Head;
  Vertex Tail;
  double scale=100.0;
  
  double height=400.0;

 public  LevelSet()
    {
      this.listinitialize();
    }
  public LevelSet(int ww,int hh)
    {
      this.listinitialize();
      
    }
  public void listinitialize()
    {
      double nx,ny;
      System.gc();
      numberofpoint=0;
      boundbox = new Polygon();
      
      Head = new Vertex();
      Tail = new Vertex();
      Init(Head,Tail);
    }
  public int UpdateLevelSetDistance(int i,double Level){
        
    
    Vertex now;    
    now = Head;
    DoubleVector dumnow;
    double dx,dy,dummy;
    while(next(now)!=Tail){
      now = next(now);
      
      now.time = new DoubleVector(now.x,now.y);
      dx = now.x -(Level*now.normal.x);
      dy = now.y -(Level*now.normal.y);
      dumnow = ChangeINTEGER(new DoubleVector(dx,dy));
      if(boundbox.contains((int)(dumnow.x),(int)(dumnow.y))){
      
	now.x = dx;
	now.y = dy;
      }
    }
    
    double ddist= 1000.0;
    
    now = Head;
    Vertex nnn = Head;
    while(next(now)!=Tail){
      now = next(now);
      nnn = Head;
      while(next(nnn)!=Tail){
	nnn = next(nnn);
	
	ddist = Math.sqrt(Math.pow(scale*(now.x - nnn.init.x),2.0) + 
			  Math.pow(scale*(now.y - nnn.init.y),2.0));
	if(((int)(ddist))<((int)((((double)(i))*scale*Level))) && nnn != now ){
	  
	  now.sw=100;
	  break;
	}
      }
      
    }
    
    Vertex exback,exnext;
    now = Head;
    while(next(now)!=Tail){
      now = next(now);
      if(now.sw==100){
	if(now.extreme==1)
	  if(next(now)!=Tail){
	    if(back(now)!=Head){
	      if(Math.abs(next(now).k)>Math.abs(back(now).k)){
		next(now).extreme = 1;
		next(now).time = now.time;
	      }else{
		back(now).extreme = 1;
		back(now).time = now.time;
	      }
	    }else{
	      if(Math.abs(next(now).k)>Math.abs(back(Tail).k)){
		next(now).extreme = 1;
		next(now).time = now.time;
	      }else{
		    back(Tail).extreme = 1;
		    back(Tail).time = now.time;
	      }
	    }
	      }else{
		if(back(now)!=Head){
		  if(Math.abs(next(Head).k)>Math.abs(back(now).k)){
		    next(Head).extreme = 1;
		    next(Head).time = now.time;
		  }else{
		    back(now).extreme = 1;
		    back(now).time = now.time;
		  }
		}else{
		  return 1;
		}
		
	      }
	exback = back(now);
	exnext = next(now);
	exback.next = exnext;
	exnext.back = exback;
	now = exback;
	numberofpoint--;
	if(next(now)==Tail || numberofpoint < 4)break;
      }
    }
    
    
    return 0;
    
    
    

  }
  

  
 private void changeextreme(Vertex now){
   if(next(next(now))==Tail){
     if(now.k<next(next(Head)).k){
       now.extreme = 1;
     }else{
       next(next(Head)).extreme = 1;
     }
   }else{
     if(now.k<next(next(now)).k){
       now.extreme = 1;
     }else{
       next(next(now)).extreme = 1;
     }
   }
 
 } 
  
  public DoubleVector getLaplace(Vertex backn,Vertex now,Vertex nextn){
  /*  DoubleVector v1 = Normalize(new DoubleVector((-now.x + backn.x),
						 (-now.y + backn.y)));
    DoubleVector v2 = Normalize(new DoubleVector((-now.x + nextn.x),
						 (-now.y + nextn.y)));*/
    DoubleVector v1 = new DoubleVector((-now.x + backn.x)/2.0,
				       (-now.y + backn.y)/2.0);
    
    DoubleVector v2 = new DoubleVector((-now.x + nextn.x)/2.0,
						 (-now.y + nextn.y)/2.0);
    return new DoubleVector((v1.x+v2.x),(v1.y+v2.y));
  
  
  }
  public int UpdateforLaplace(double epcilon){
    Vertex now = next(Head);
	now.mid = getLaplace(back(Tail),now,next(now));
	
	while(next(next(now))!=Tail){
	    now  = next(now);
	    now.mid = getLaplace(back(now),now,next(now));
	}
	now  = next(now);
	now.mid = getLaplace(back(now),now,next(Head));
		
	
	now = Head;
	
	
	while(next(now)!=Tail){
	    now  = next(now);
	    now.time = new DoubleVector(now.x,now.y);
	    now.x += epcilon*now.mid.x;
	    now.y += epcilon*now.mid.y;
	    	    	    
	}
	
	return 0;
    }

 private DoubleVector Normalize(DoubleVector v)
    {
      v.size = Math.sqrt((v.x)*(v.x)+(v.y)*(v.y));
      if(v.size!=0){
	v.x = (double)(v.x/v.size);
	v.y = (double)(v.y/v.size);
	v.size = 1.0;
      }else{
        v.size = 0.0;
      }
      return v;
    }
 private void Init(Vertex h,Vertex t)
    {
      h.next = new Vertex();
      t.back = new Vertex();
      h.next = t;
      t.back = h;
    }
  
  private double Distance(Vertex p1,Vertex p2)
    {
      DoubleVector v1 = new DoubleVector(p1.x,p1.y);
	DoubleVector v2 = new DoubleVector(p2.x,p2.y);
	return Distance(v1,v2);
    }
  private double Distance(DoubleVector v1,DoubleVector v2)
  {
    DoubleVector v = new DoubleVector((v2.x-v1.x),(v2.y-v1.y));
    return ((double)(Math.sqrt((v.x*v.x)+(v.y*v.y))));
  }
  
  private Vertex next(Vertex now)
    {
      return (now.next);
    }
  private Vertex back(Vertex now)
    {
      return (now.back);
    }
  public void Append(DoubleVector dv,int ex)
    {
      Vertex now = new Vertex(dv.x,dv.y);
      now.extreme = ex;
      Vertex dummy = Tail.back;
      now.next = Tail;
      Tail.back = now;
      now.back = dummy;
      dummy.next =now;
      numberofpoint++;
      
    }

   public void Append(DoubleVector dv,DoubleVector dtangent,DoubleVector dnormal)
    {
      Vertex now = new Vertex(dv.x,dv.y);
      
      now.normal = new DoubleVector(dnormal.x,dnormal.y);
      now.tangent = new DoubleVector(dtangent.x,dtangent.y);
      Vertex dummy = Tail.back;
      now.next = Tail;
      Tail.back = now;
      now.back = dummy;
      dummy.next =now;
      numberofpoint++;
      
    }
  public void Append(DoubleVector dv,DoubleVector dnormal)
    {
      Vertex now = new Vertex(dv.x,dv.y);
      
      now.normal = new DoubleVector(dnormal.x,dnormal.y);
      
      Vertex dummy = Tail.back;
      now.next = Tail;
      Tail.back = now;
      now.back = dummy;
      dummy.next =now;
      numberofpoint++;
      
    }
  
  private DoubleVector ChangeINTEGER(DoubleVector dv){
     double dx,dy;
      dx = ((double)((scale)*dv.x)+20.0);
      dy = (height- 
		(double)((scale)*dv.y) -20.0);
      return new DoubleVector(dx,dy);
  }
  public void Append(DoubleVector dv,int ex,DoubleVector dn,double dk)
    {
      DoubleVector dint = ChangeINTEGER(dv);
      boundbox.addPoint((int)(dint.x),(int)(dint.y));
      Vertex now = new Vertex(dv.x,dv.y);
      now.extreme = ex;
      now.k = dk;
      now.init = new DoubleVector(dv.x,dv.y);
      now.normal = new DoubleVector(dn.x,dn.y);
      Vertex dummy = Tail.back;
      now.next = Tail;
      Tail.back = now;
      now.back = dummy;
      dummy.next =now;
      numberofpoint++;
      
    }
  
  

  private double VertexSize(Vertex dv){
   return Math.sqrt((dv.x*dv.x+dv.y*dv.y));
 }
  private double VectorSize(DoubleVector dv){
   return Math.sqrt((dv.x*dv.x+dv.y*dv.y));
 }
}