package whuang;
import cs3.*;
import java.awt.Color;
import java.awt.Rectangle;

public class WWSlaveObject7 implements java.io.Serializable
{
  private int nmax;
  private Color[] colormap;
  
  public WWSlaveObject7() {
    super();
    nmax = 60;
    colormap = new Color[nmax + 1];
    for (int lcv=0;lcv<=60;lcv++) {
      float r = (lcv - 30);
      r = (r<0)? -r-10: r-10;
      if (r<0) r=0; if (r>10) r=10;
      float g = (lcv - 20);
      g = (g<0)? g+20: -g+20;
      if (g<0) g=0; if (g>10) g=10;
      float b = (lcv - 40);
      b = (b<0)? b+20: -b+20;
      if (b<0) b=0; if (b>10) b=10;

      colormap[lcv] = new Color(r/10f,g/10f,b/10f);
    }
   }

   public int calculate(Complex c) {
     Complex iter = c;
     int maxtries = 60;
     int tries = 0;
     while ((tries < maxtries) && iter.lessThan(2.0)) {
       iter = iter.square().add(c);
       //System.out.println(iter.strval());
       tries++;
     }
     //System.out.println("innum="+c.strval()+" "+tries);
     if ((tries == maxtries) && iter.lessThan(2.0))
       return(-1);
     else
       return(tries);
   }

   private int xmin, xmax, ymin, ymax; 
  
   public void setrect(int xi, int xa, int yi, int ya) {
     xmin = xi; xmax = xa; ymin = yi; ymax = ya;
   }

   public PixelBuffer rectcalc(
        double remin, double reinc, double immax, double iminc) {
      PixelBuffer answer = new PixelBuffer(new Rectangle(xmin,ymin,
        xmax-xmin,ymax-ymin));
     double imtemp, retemp;

     imtemp = immax;
     for (int ylcv = ymin; ylcv < ymax; ylcv++) {
       retemp = remin;
       for (int xlcv = xmin; xlcv < xmax; xlcv++) {
         int clr = calculate(new Complex(retemp,imtemp));
         if (clr == -1)
           answer.plot(xlcv,ylcv,Color.black);
         else
           answer.plot(xlcv,ylcv,colormap[clr]);
         retemp += reinc;
       }
       imtemp -= iminc;
     }

     return(answer);
   }

   private boolean allsame;
   public PixelBuffer rectcalc2(
        double remin, double reinc, double immax, double iminc) {
     allsame = true; 
     int xdiff = xmax-xmin;
     int ydiff = ymax-ymin;
     if (xdiff<3 || ydiff<3 || (xdiff<40 && ydiff<40 && 
           (xdiff<8 || ydiff<8))) {
       // just do it.
       return(rectcalc(remin,reinc,immax,iminc)); 
     } else {
       PixelBuffer answer = new PixelBuffer(new Rectangle(xmin,ymin,
         xmax-xmin,ymax-ymin));
       // the border thing.
       
       double imtemp, retemp;
       int xlcv, ylcv, clr;

       int base = calculate(new Complex(remin,immax));
       if (base == -1) answer.plot(xmin,ymin,Color.black);
         else answer.plot(xmin,ymin,colormap[base]);

       // y minimum
       retemp = remin+reinc;
       for (xlcv = xmin+1; xlcv < xmax; xlcv++) {
         clr = calculate(new Complex(retemp,immax));
         if (clr == -1) answer.plot(xlcv,ymin,Color.black);
           else answer.plot(xlcv,ymin,colormap[clr]);
         if (allsame && (clr != base)) allsame = false;
         retemp += reinc;
       }

       // x minimum
       imtemp = immax-iminc;
       for (ylcv = ymin+1; ylcv < ymax; ylcv++) {
         clr = calculate(new Complex(remin,imtemp));
         if (clr == -1) answer.plot(xmin,ylcv,Color.black);
           else answer.plot(xmin,ylcv,colormap[clr]);
         if (allsame && (clr != base)) allsame = false;
         imtemp -= iminc;
       }

       // y maximum
       imtemp = immax-iminc*(double)(ymax-ymin-1);
       retemp = remin+reinc;
       for (xlcv = xmin+1; xlcv < xmax; xlcv++) {
         clr = calculate(new Complex(retemp,imtemp));
         if (clr == -1) answer.plot(xlcv,ymax-1,Color.black);
           else answer.plot(xlcv,ymax-1,colormap[clr]);
         if (allsame && (clr != base)) allsame = false;
         retemp += reinc;
       }

       // x maximum
       retemp = remin+reinc*(double)(xmax-xmin-1);
       imtemp = immax-iminc;
       for (ylcv = ymin+1; ylcv < ymax-1; ylcv++) {
         clr = calculate(new Complex(retemp,imtemp));
         if (clr == -1) answer.plot(xmax-1,ylcv,Color.black);
           else answer.plot(xmax-1,ylcv,colormap[clr]);
         if (allsame && (clr != base)) allsame = false;
         imtemp -= iminc;
       }

       if (allsame) {
         for (ylcv = ymin+1; ylcv < ymax-1; ylcv++) 
             for (xlcv = xmin+1; xlcv < xmax-1; xlcv++) {
           if (base == -1) answer.plot(xlcv,ylcv,Color.black);
             else answer.plot(xlcv,ylcv,colormap[base]);
         }
       }
 
       return(answer);
     }
   }

   public boolean allsamep() {
     return(allsame);
   }

}