**                          errors!*/                            count = 0;                            if( bottom ) count++;                            if( top )    count++;                            if( left )   count++;                            if( right )  count++;                            if( count > 2 ) {                                System.out.println("IsoCurve: Pathological Cell");                                System.out.println("          value="+value);                                System.out.println("          i="+i+", j="+j);                                System.out.println("          tl="+tl+", tr="+tr);                                System.out.println("          bl="+bl+", br="+br);		            } else {                                count = 0;                                if( bottom ) { cell.face[count] = BOTTOM; count++; }                                if( top    ) { cell.face[count] = TOP;    count++; }                                if( left   ) { cell.face[count] = LEFT;   count++; }                                if( right  ) { cell.face[count] = RIGHT;  count++; }                            }                    }                                                           }            }	  }              /**   * Traverse the cells and find One connect countour.   */      protected void getcurve() {            Cell current;            int face = TERMINAL;            int ifcell = -1;            int jfcell = -1;            int icell,jcell;            double bl, br, tl, tr;            int index;            int i;            double d[] = new double[2];                             size = 0;            //System.out.println("getcurve: Number of cells "+cells.size());            if( cells == null || cells.isEmpty() ) return;                        current = (Cell)(cells.firstElement());            if(current.face[0] == TERMINAL && current.face[1] == TERMINAL) {                cells.removeElement(current);                System.out.println("getcurve: Terminal cell removed!");                return;            }/***          Calculate the first point in the new curve*/            icell = current.i;            jcell = current.j;                        ifcell = -1;            jfcell = -1;/***          Check to see if we can loop back on ourselves. ie we have partially**          resolved this curve or we are against a wall.**          Use the terminating wall to start the curve.*/            if( search(icell-1,jcell) == null &&                 ( current.face[0] == LEFT || current.face[1] == LEFT ) ) {                                    	 addDataPoint(LEFT,icell,jcell);                     face = LEFT;                                 } else            if( search(icell+1,jcell) == null &&                 ( current.face[0] == RIGHT || current.face[1] == RIGHT ) ) {                                         addDataPoint(RIGHT,icell,jcell);                     face = RIGHT;            } else            if( search(icell,jcell-nx) == null &&                 ( current.face[0] == BOTTOM || current.face[1] == BOTTOM ) ) {                                         addDataPoint(BOTTOM,icell,jcell);                     face = BOTTOM;                                 } else            if( search(icell,jcell+nx) == null &&                 ( current.face[0] == TOP || current.face[1] == TOP ) ) {                     addDataPoint(TOP,icell,jcell);                     face = TOP;            } else {            	/***          No terminating wall so it does not matter where we start as**          long as it is not a terminal face. Remember the position**          of the cell behind us just in case we loop back as the curve**          must be closed.*/                index = 0;                if( current.face[0] == TERMINAL ) index = 1;                                addDataPoint(current.face[index],icell,jcell);                face = current.face[index];                                if( face == TOP ) {                     ifcell = current.i;                     jfcell = current.j+1;                } else                 if( face == BOTTOM ) {                     ifcell = current.i;                     jfcell = current.j-1;                } else                 if( face == LEFT ) {                     ifcell = current.i-1;                     jfcell = current.j;                } else                 if( face == RIGHT ) {                     ifcell = current.i+1;                     jfcell = current.j;               }            }                        while( current != null ) {                               icell = current.i;               jcell = current.j;                              if( current.face[0] == face )  face = current.face[1];               else                           face = current.face[0];                                         if(face != TERMINAL) addDataPoint(face,icell,jcell);                              if(face == TOP ) {                     jcell++;                     face = BOTTOM;                } else               if(face == BOTTOM ) {                     jcell--;                     face = TOP;                } else               if(face == LEFT ) {                     icell--;                     face = RIGHT;                } else               if(face == RIGHT ) {                     icell++;                     face = LEFT;                }                                cells.removeElement(current);                if( icell == ifcell && jcell == jfcell ) {                     addDataPoint(curve[0], curve[1]);                     current = null;                } else {                     current = search(icell,jcell);                }            }     }  /**   * Return the (x,y) position where the contour cross the cell wall.   * @param wall The cell wall the contour crosses.   * @param icell The x index of the cell position.   * @param jcell The y index of the cell position.   */     protected double[] getPoint(int wall, int icell, int jcell)  {     	double d[] = new double[2];        double bl, br, tl, tr;        int index = icell + jcell*nx;                if(wall == TOP ) {                     tl = grid[index+nx];                     tr = grid[index+nx+1];                     d[1] = (double)(jcell+1);                     d[0] = (double)icell + (value-tl)/(tr-tl);         } else         if(wall == BOTTOM ) {                     bl = grid[index];                     br = grid[index+1];                     d[1] = (double)jcell;                     d[0] = (double)icell + (value-bl)/(br-bl);         } else         if(wall == LEFT ) {                     bl = grid[index];                     tl = grid[index+nx];                     d[1] = (double)jcell + (value-bl)/(tl-bl);                     d[0] = (double)icell;         } else         if(wall == RIGHT ) {                     br = grid[index+1];                     tr = grid[index+1+nx];                     d[1] = (double)jcell + (value-br)/(tr-br);                     d[0] = (double)(icell + 1);         }     	         return  d;         }           /**   * Add a data point to the contour curve.   * @param wall The cell wall the contour crosses.   * @param icell The x index of the cell position.   * @param jcell The y index of the cell position.   */      protected void addDataPoint(int wall, int icell, int jcell)  {     	  double d[];     	       	  d = getPoint(wall,icell,jcell);     	       	  addDataPoint(d[0], d[1]);     }                /**   * Add a data point to the contour curve.   * @param x The x position of the point.   * @param y The y position of the point.   */      protected void addDataPoint(double x,double y) {            if(size >= MAXARRAYSIZE-2) return;            if( curve == null)  {            	curve = new double[ARRAYSIZE];            } else            if(size == curve.length-2 ) {               double tmp[] = new double[2*size];               System.arraycopy(curve,0,tmp,0,size);               curve = tmp;            }                        curve[size] = x;            size++;            curve[size] = y;            size++;     }  /**   * Search for a cell in the contour cell list   * @param icell the x index of the cell   * @param jcell the y index of the cell   */     protected Cell search(int icell, int jcell) {           int i;           Cell current = null;                      if( cells.isEmpty() ) return null;                      for(i=0; i<cells.size(); i++) {               current = (Cell)(cells.elementAt(i));                              if(current.i == icell && current.j == jcell) return current;           }                      return null;          }}/*** This class is a structure class holding information about the* cells that the contour line passes through. Used only with IsoCurve class*/class Cell extends Object {        int i;        int j;        int face[] = new int[2];        boolean visited;        public Cell() {                       i = -1;                       j = -1;                       face[0] = IsoCurve.TERMINAL;                       face[1] = IsoCurve.TERMINAL;		     }}