home *** CD-ROM | disk | FTP | other *** search
/ S283 Planetary Science &… the Search for Life CD 3 / 0_CD-ROM.iso / install / jre1_3 / lib / rt.jar / sun / awt / geom / Curve.class (.txt) < prev    next >
Encoding:
Java Class File  |  1979-12-31  |  8.3 KB  |  671 lines
  1. package sun.awt.geom;
  2.  
  3. import java.awt.geom.CubicCurve2D;
  4. import java.awt.geom.PathIterator;
  5. import java.awt.geom.QuadCurve2D;
  6. import java.awt.geom.Rectangle2D;
  7. import java.util.Vector;
  8.  
  9. public abstract class Curve {
  10.    public static final int INCREASING = 1;
  11.    public static final int DECREASING = -1;
  12.    protected int direction;
  13.    public static final double TMIN = 0.001;
  14.  
  15.    public static void insertMove(Vector var0, double var1, double var3) {
  16.       var0.add(new Order0(var1, var3));
  17.    }
  18.  
  19.    public static void insertLine(Vector var0, double var1, double var3, double var5, double var7) {
  20.       if (var3 < var7) {
  21.          var0.add(new Order1(var1, var3, var5, var7, 1));
  22.       } else if (var3 > var7) {
  23.          var0.add(new Order1(var5, var7, var1, var3, -1));
  24.       }
  25.  
  26.    }
  27.  
  28.    public static void insertQuad(Vector var0, double var1, double var3, double[] var5) {
  29.       double var6 = var5[3];
  30.       if (var3 > var6) {
  31.          Order2.insert(var0, var5, var5[2], var6, var5[0], var5[1], var1, var3, -1);
  32.       } else {
  33.          if (var3 == var6 && var3 == var5[1]) {
  34.             return;
  35.          }
  36.  
  37.          Order2.insert(var0, var5, var1, var3, var5[0], var5[1], var5[2], var6, 1);
  38.       }
  39.  
  40.    }
  41.  
  42.    public static void insertCubic(Vector var0, double var1, double var3, double[] var5) {
  43.       double var6 = var5[5];
  44.       if (var3 > var6) {
  45.          Order3.insert(var0, var5, var5[4], var6, var5[2], var5[3], var5[0], var5[1], var1, var3, -1);
  46.       } else {
  47.          if (var3 == var6 && var3 == var5[1] && var3 == var5[3]) {
  48.             return;
  49.          }
  50.  
  51.          Order3.insert(var0, var5, var1, var3, var5[0], var5[1], var5[2], var5[3], var5[4], var6, 1);
  52.       }
  53.  
  54.    }
  55.  
  56.    public static int crossingsForLine(double var0, double var2, double var4, double var6, double var8, double var10) {
  57.       if (var6 > var10) {
  58.          return 0 - crossingsForLine(var0, var2, var8, var10, var4, var6);
  59.       } else if (var6 == var10) {
  60.          return 0;
  61.       } else if (!(var2 < var6) && !(var2 >= var10)) {
  62.          if (var0 >= var4 && var0 >= var8) {
  63.             return 0;
  64.          } else {
  65.             double var12 = (var2 - var6) / (var10 - var6);
  66.             return var0 < var4 + var12 * (var8 - var4) ? 1 : 0;
  67.          }
  68.       } else {
  69.          return 0;
  70.       }
  71.    }
  72.  
  73.    public static int crossingsForQuad(double var0, double var2, double var4, double var6, double[] var8) {
  74.       double var9 = var8[0];
  75.       double var11 = var8[1];
  76.       double var13 = var8[2];
  77.       double var15 = var8[3];
  78.       if (var2 < var6 && var2 < var11 && var2 < var15) {
  79.          return 0;
  80.       } else if (var2 >= var6 && var2 >= var11 && var2 >= var15) {
  81.          return 0;
  82.       } else if (var0 >= var4 && var0 >= var9 && var0 >= var13) {
  83.          return 0;
  84.       } else if (var0 < var4 && var0 < var9 && var0 < var13) {
  85.          if (var6 < var15) {
  86.             return var2 >= var6 && var2 < var15 ? 1 : 0;
  87.          } else if (!(var15 < var6)) {
  88.             return 0;
  89.          } else {
  90.             return var2 >= var15 && var2 < var6 ? -1 : 0;
  91.          }
  92.       } else {
  93.          double[] var17 = new double[3];
  94.          double[] var18 = new double[3];
  95.          Order2.getEqn(var17, var4, var8[0], var8[2]);
  96.          Order2.getEqn(var18, var6, var8[1], var8[3]);
  97.          System.arraycopy(var18, 0, var8, 0, 3);
  98.          var8[0] -= var2;
  99.          int var19 = QuadCurve2D.solveQuadratic(var8, var8);
  100.          int var20 = 0;
  101.  
  102.          for(int var21 = 0; var21 < var19; ++var21) {
  103.             double var22 = var8[var21];
  104.             if (var22 >= (double)0.0F && var22 <= (double)1.0F) {
  105.                double var24 = (var17[2] * var22 + var17[1]) * var22 + var17[0];
  106.                if (var0 <= var24) {
  107.                   var24 = (double)2.0F * var18[2] * var22 + var18[1];
  108.                   if (var24 > (double)0.0F) {
  109.                      ++var20;
  110.                   } else if (var24 < (double)0.0F) {
  111.                      --var20;
  112.                   }
  113.                }
  114.             }
  115.          }
  116.  
  117.          return var20;
  118.       }
  119.    }
  120.  
  121.    public static int crossingsForCubic(double var0, double var2, double var4, double var6, double[] var8) {
  122.       double var9 = var8[0];
  123.       double var11 = var8[1];
  124.       double var13 = var8[2];
  125.       double var15 = var8[3];
  126.       double var17 = var8[4];
  127.       double var19 = var8[5];
  128.       if (var2 < var6 && var2 < var11 && var2 < var15 && var2 < var19) {
  129.          return 0;
  130.       } else if (var2 >= var6 && var2 >= var11 && var2 >= var15 && var2 >= var19) {
  131.          return 0;
  132.       } else if (var0 >= var4 && var0 >= var9 && var0 >= var13 && var0 >= var17) {
  133.          return 0;
  134.       } else if (var0 < var4 && var0 < var9 && var0 < var13 && var0 < var17) {
  135.          if (var6 < var19) {
  136.             return var2 >= var6 && var2 < var19 ? 1 : 0;
  137.          } else if (!(var19 < var6)) {
  138.             return 0;
  139.          } else {
  140.             return var2 >= var19 && var2 < var6 ? -1 : 0;
  141.          }
  142.       } else {
  143.          double[] var21 = new double[4];
  144.          double[] var22 = new double[4];
  145.          Order3.getEqn(var21, var4, var8[0], var8[2], var8[4]);
  146.          Order3.getEqn(var22, var6, var8[1], var8[3], var8[5]);
  147.          System.arraycopy(var22, 0, var8, 0, 4);
  148.          var8[0] -= var2;
  149.          int var23 = CubicCurve2D.solveCubic(var8, var8);
  150.          int var24 = 0;
  151.  
  152.          for(int var25 = 0; var25 < var23; ++var25) {
  153.             double var26 = var8[var25];
  154.             if (var26 >= (double)0.0F && var26 <= (double)1.0F) {
  155.                double var28 = ((var21[3] * var26 + var21[2]) * var26 + var21[1]) * var26 + var21[0];
  156.                if (var0 <= var28) {
  157.                   var28 = ((double)3.0F * var22[3] * var26 + (double)2.0F * var22[2]) * var26 + var22[1];
  158.                   if (var28 > (double)0.0F) {
  159.                      ++var24;
  160.                   } else if (var28 < (double)0.0F) {
  161.                      --var24;
  162.                   }
  163.                }
  164.             }
  165.          }
  166.  
  167.          return var24;
  168.       }
  169.    }
  170.  
  171.    public static int crossingsForPath(PathIterator var0, double var1, double var3) {
  172.       double var5 = (double)0.0F;
  173.       double var7 = (double)0.0F;
  174.       double var9 = (double)0.0F;
  175.       double var11 = (double)0.0F;
  176.       int var17 = 0;
  177.  
  178.       for(double[] var18 = new double[6]; !var0.isDone(); var0.next()) {
  179.          switch (var0.currentSegment(var18)) {
  180.             case 0:
  181.                if (var11 != var7) {
  182.                   var17 += crossingsForLine(var1, var3, var9, var11, var5, var7);
  183.                }
  184.  
  185.                var5 = var9 = var18[0];
  186.                var7 = var11 = var18[1];
  187.                break;
  188.             case 1:
  189.                double var20 = var18[0];
  190.                double var22 = var18[1];
  191.                var17 += crossingsForLine(var1, var3, var9, var11, var20, var22);
  192.                var9 = var20;
  193.                var11 = var22;
  194.                break;
  195.             case 2:
  196.                double var19 = var18[2];
  197.                double var21 = var18[3];
  198.                var17 += crossingsForQuad(var1, var3, var9, var11, var18);
  199.                var9 = var19;
  200.                var11 = var21;
  201.                break;
  202.             case 3:
  203.                double var13 = var18[4];
  204.                double var15 = var18[5];
  205.                var17 += crossingsForCubic(var1, var3, var9, var11, var18);
  206.                var9 = var13;
  207.                var11 = var15;
  208.                break;
  209.             case 4:
  210.                if (var11 != var7) {
  211.                   var17 += crossingsForLine(var1, var3, var9, var11, var5, var7);
  212.                }
  213.  
  214.                var9 = var5;
  215.                var11 = var7;
  216.          }
  217.       }
  218.  
  219.       if (var11 != var7) {
  220.          var17 += crossingsForLine(var1, var3, var9, var11, var5, var7);
  221.       }
  222.  
  223.       return var17;
  224.    }
  225.  
  226.    public Curve(int var1) {
  227.       this.direction = var1;
  228.    }
  229.  
  230.    public final int getDirection() {
  231.       return this.direction;
  232.    }
  233.  
  234.    public final Curve getWithDirection(int var1) {
  235.       return this.direction == var1 ? this : this.getReversedCurve();
  236.    }
  237.  
  238.    public static double round(double var0) {
  239.       return var0;
  240.    }
  241.  
  242.    public static double firstValidRoot(double[] var0, int var1) {
  243.       for(int var2 = 0; var2 < var1; ++var2) {
  244.          double var3 = var0[var2];
  245.          if (var3 >= (double)0.0F && var3 <= (double)1.0F) {
  246.             return var3;
  247.          }
  248.       }
  249.  
  250.       return (double)0.0F;
  251.    }
  252.  
  253.    public static int orderof(double var0, double var2) {
  254.       if (var0 < var2) {
  255.          return -1;
  256.       } else {
  257.          return var0 > var2 ? 1 : 0;
  258.       }
  259.    }
  260.  
  261.    public static long signeddiffbits(double var0, double var2) {
  262.       return Double.doubleToLongBits(var0) - Double.doubleToLongBits(var2);
  263.    }
  264.  
  265.    public static long diffbits(double var0, double var2) {
  266.       return Math.abs(Double.doubleToLongBits(var0) - Double.doubleToLongBits(var2));
  267.    }
  268.  
  269.    public static double prev(double var0) {
  270.       return Double.longBitsToDouble(Double.doubleToLongBits(var0) - 1L);
  271.    }
  272.  
  273.    public static double next(double var0) {
  274.       return Double.longBitsToDouble(Double.doubleToLongBits(var0) + 1L);
  275.    }
  276.  
  277.    public String toString() {
  278.       return "Curve[" + this.getOrder() + ", " + "(" + round(this.getX0()) + ", " + round(this.getY0()) + "), " + this.controlPointString() + "(" + round(this.getX1()) + ", " + round(this.getY1()) + "), " + (this.direction == 1 ? "D" : "U") + "]";
  279.    }
  280.  
  281.    public String controlPointString() {
  282.       return "";
  283.    }
  284.  
  285.    public abstract int getOrder();
  286.  
  287.    public abstract double getXTop();
  288.  
  289.    public abstract double getYTop();
  290.  
  291.    public abstract double getXBot();
  292.  
  293.    public abstract double getYBot();
  294.  
  295.    public abstract double getXMin();
  296.  
  297.    public abstract double getXMax();
  298.  
  299.    public abstract double getX0();
  300.  
  301.    public abstract double getY0();
  302.  
  303.    public abstract double getX1();
  304.  
  305.    public abstract double getY1();
  306.  
  307.    public abstract double XforY(double var1);
  308.  
  309.    public abstract double TforY(double var1);
  310.  
  311.    public abstract double XforT(double var1);
  312.  
  313.    public abstract double YforT(double var1);
  314.  
  315.    public abstract double dXforT(double var1, int var3);
  316.  
  317.    public abstract double dYforT(double var1, int var3);
  318.  
  319.    public abstract double nextVertical(double var1, double var3);
  320.  
  321.    public int crossingsFor(double var1, double var3) {
  322.       return !(var3 >= this.getYTop()) || !(var3 < this.getYBot()) || !(var1 < this.getXMax()) || !(var1 < this.getXMin()) && !(var1 < this.XforY(var3)) ? 0 : 1;
  323.    }
  324.  
  325.    public boolean accumulateCrossings(Crossings var1) {
  326.       double var2 = var1.getXHi();
  327.       if (this.getXMin() >= var2) {
  328.          return false;
  329.       } else {
  330.          double var4 = var1.getXLo();
  331.          double var6 = var1.getYLo();
  332.          double var8 = var1.getYHi();
  333.          double var10 = this.getYTop();
  334.          double var12 = this.getYBot();
  335.          double var14;
  336.          double var16;
  337.          if (var10 < var6) {
  338.             if (var12 <= var6) {
  339.                return false;
  340.             }
  341.  
  342.             var16 = var6;
  343.             var14 = this.TforY(var6);
  344.          } else {
  345.             if (var10 >= var8) {
  346.                return false;
  347.             }
  348.  
  349.             var16 = var10;
  350.             var14 = (double)0.0F;
  351.          }
  352.  
  353.          double var18;
  354.          double var20;
  355.          if (var12 > var8) {
  356.             var20 = var8;
  357.             var18 = this.TforY(var8);
  358.          } else {
  359.             var20 = var12;
  360.             var18 = (double)1.0F;
  361.          }
  362.  
  363.          boolean var22 = false;
  364.          boolean var23 = false;
  365.  
  366.          while(true) {
  367.             double var24 = this.XforT(var14);
  368.             if (var24 < var2) {
  369.                if (var23 || var24 > var4) {
  370.                   return true;
  371.                }
  372.  
  373.                var22 = true;
  374.             } else {
  375.                if (var22) {
  376.                   return true;
  377.                }
  378.  
  379.                var23 = true;
  380.             }
  381.  
  382.             if (var14 >= var18) {
  383.                if (var22) {
  384.                   var1.record(var16, var20, this.direction);
  385.                }
  386.  
  387.                return false;
  388.             }
  389.  
  390.             var14 = this.nextVertical(var14, var18);
  391.          }
  392.       }
  393.    }
  394.  
  395.    public abstract void enlarge(Rectangle2D var1);
  396.  
  397.    public Curve getSubCurve(double var1, double var3) {
  398.       return this.getSubCurve(var1, var3, this.direction);
  399.    }
  400.  
  401.    public abstract Curve getReversedCurve();
  402.  
  403.    public abstract Curve getSubCurve(double var1, double var3, int var5);
  404.  
  405.    public int compareTo(Curve var1, double[] var2) {
  406.       double var3 = var2[0];
  407.       double var5 = var2[1];
  408.       var5 = Math.min(Math.min(var5, this.getYBot()), var1.getYBot());
  409.       if (var5 <= var2[0]) {
  410.          System.err.println("this == " + this);
  411.          System.err.println("that == " + var1);
  412.          System.out.println("target range = " + var2[0] + "=>" + var2[1]);
  413.          throw new InternalError("backstepping from " + var2[0] + " to " + var5);
  414.       } else {
  415.          var2[1] = var5;
  416.          if (this.getXMax() <= var1.getXMin()) {
  417.             return this.getXMin() == var1.getXMax() ? 0 : -1;
  418.          } else if (this.getXMin() >= var1.getXMax()) {
  419.             return 1;
  420.          } else {
  421.             double var7 = this.TforY(var3);
  422.             double var9 = this.YforT(var7);
  423.             if (var9 < var3) {
  424.                var7 = this.refineTforY(var7, var9, var3);
  425.                var9 = this.YforT(var7);
  426.             }
  427.  
  428.             double var11 = this.TforY(var5);
  429.             if (this.YforT(var11) < var3) {
  430.                var11 = this.refineTforY(var11, this.YforT(var11), var3);
  431.             }
  432.  
  433.             double var13 = var1.TforY(var3);
  434.             double var15 = var1.YforT(var13);
  435.             if (var15 < var3) {
  436.                var13 = var1.refineTforY(var13, var15, var3);
  437.                var15 = var1.YforT(var13);
  438.             }
  439.  
  440.             double var17 = var1.TforY(var5);
  441.             if (var1.YforT(var17) < var3) {
  442.                var17 = var1.refineTforY(var17, var1.YforT(var17), var3);
  443.             }
  444.  
  445.             double var19 = this.XforT(var7);
  446.             double var21 = var1.XforT(var13);
  447.             double var23 = Math.max(Math.abs(var3), Math.abs(var5));
  448.             double var25 = Math.max(var23 * 1.0E-14, 1.0E-300);
  449.             if (this.fairlyClose(var19, var21)) {
  450.                double var27 = var25;
  451.                double var29 = Math.min(var25 * 1.0E13, (var5 - var3) * 0.1);
  452.  
  453.                double var31;
  454.                label99:
  455.                for(var31 = var3 + var25; var31 <= var5; var31 += var27) {
  456.                   if (!this.fairlyClose(this.XforY(var31), var1.XforY(var31))) {
  457.                      var31 -= var27;
  458.  
  459.                      while(true) {
  460.                         var27 /= (double)2.0F;
  461.                         double var33 = var31 + var27;
  462.                         if (var33 <= var31) {
  463.                            break label99;
  464.                         }
  465.  
  466.                         if (this.fairlyClose(this.XforY(var33), var1.XforY(var33))) {
  467.                            var31 = var33;
  468.                         }
  469.                      }
  470.                   }
  471.  
  472.                   if ((var27 *= (double)2.0F) > var29) {
  473.                      var27 = var29;
  474.                   }
  475.                }
  476.  
  477.                if (var31 > var3) {
  478.                   if (var31 < var5) {
  479.                      var2[1] = var31;
  480.                   }
  481.  
  482.                   return 0;
  483.                }
  484.             }
  485.  
  486.             if (var25 <= (double)0.0F) {
  487.                System.out.println("ymin = " + var25);
  488.             }
  489.  
  490.             while(var7 < var11 && var13 < var17) {
  491.                double var42 = this.nextVertical(var7, var11);
  492.                double var44 = this.XforT(var42);
  493.                double var45 = this.YforT(var42);
  494.                double var46 = var1.nextVertical(var13, var17);
  495.                double var35 = var1.XforT(var46);
  496.                double var37 = var1.YforT(var46);
  497.  
  498.                try {
  499.                   if (this.findIntersect(var1, var2, var25, 0, 0, var7, var19, var9, var42, var44, var45, var13, var21, var15, var46, var35, var37)) {
  500.                      break;
  501.                   }
  502.                } catch (Throwable var40) {
  503.                   System.err.println("Error: " + var40);
  504.                   System.err.println("y range was " + var2[0] + "=>" + var2[1]);
  505.                   System.err.println("s y range is " + var9 + "=>" + var45);
  506.                   System.err.println("t y range is " + var15 + "=>" + var37);
  507.                   System.err.println("ymin is " + var25);
  508.                   return 0;
  509.                }
  510.  
  511.                if (var45 < var37) {
  512.                   if (var45 > var2[0]) {
  513.                      if (var45 < var2[1]) {
  514.                         var2[1] = var45;
  515.                      }
  516.                      break;
  517.                   }
  518.  
  519.                   var7 = var42;
  520.                   var19 = var44;
  521.                   var9 = var45;
  522.                } else {
  523.                   if (var37 > var2[0]) {
  524.                      if (var37 < var2[1]) {
  525.                         var2[1] = var37;
  526.                      }
  527.                      break;
  528.                   }
  529.  
  530.                   var13 = var46;
  531.                   var21 = var35;
  532.                   var15 = var37;
  533.                }
  534.             }
  535.  
  536.             double var43 = (var2[0] + var2[1]) / (double)2.0F;
  537.             return orderof(this.XforY(var43), var1.XforY(var43));
  538.          }
  539.       }
  540.    }
  541.  
  542.    public boolean findIntersect(Curve var1, double[] var2, double var3, int var5, int var6, double var7, double var9, double var11, double var13, double var15, double var17, double var19, double var21, double var23, double var25, double var27, double var29) {
  543.       if (!(var11 > var29) && !(var23 > var17)) {
  544.          if (!(Math.min(var9, var15) > Math.max(var21, var27)) && !(Math.max(var9, var15) < Math.min(var21, var27))) {
  545.             if (var13 - var7 > 0.001) {
  546.                double var31 = (var7 + var13) / (double)2.0F;
  547.                double var33 = this.XforT(var31);
  548.                double var35 = this.YforT(var31);
  549.                if (var31 == var7 || var31 == var13) {
  550.                   System.out.println("s0 = " + var7);
  551.                   System.out.println("s1 = " + var13);
  552.                   throw new InternalError("no s progress!");
  553.                }
  554.  
  555.                if (var25 - var19 > 0.001) {
  556.                   double var37 = (var19 + var25) / (double)2.0F;
  557.                   double var39 = var1.XforT(var37);
  558.                   double var41 = var1.YforT(var37);
  559.                   if (var37 == var19 || var37 == var25) {
  560.                      System.out.println("t0 = " + var19);
  561.                      System.out.println("t1 = " + var25);
  562.                      throw new InternalError("no t progress!");
  563.                   }
  564.  
  565.                   if (var35 >= var23 && var41 >= var11 && this.findIntersect(var1, var2, var3, var5 + 1, var6 + 1, var7, var9, var11, var31, var33, var35, var19, var21, var23, var37, var39, var41)) {
  566.                      return true;
  567.                   }
  568.  
  569.                   if (var35 >= var41 && this.findIntersect(var1, var2, var3, var5 + 1, var6 + 1, var7, var9, var11, var31, var33, var35, var37, var39, var41, var25, var27, var29)) {
  570.                      return true;
  571.                   }
  572.  
  573.                   if (var41 >= var35 && this.findIntersect(var1, var2, var3, var5 + 1, var6 + 1, var31, var33, var35, var13, var15, var17, var19, var21, var23, var37, var39, var41)) {
  574.                      return true;
  575.                   }
  576.  
  577.                   if (var17 >= var41 && var29 >= var35 && this.findIntersect(var1, var2, var3, var5 + 1, var6 + 1, var31, var33, var35, var13, var15, var17, var37, var39, var41, var25, var27, var29)) {
  578.                      return true;
  579.                   }
  580.                } else {
  581.                   if (var35 >= var23 && this.findIntersect(var1, var2, var3, var5 + 1, var6, var7, var9, var11, var31, var33, var35, var19, var21, var23, var25, var27, var29)) {
  582.                      return true;
  583.                   }
  584.  
  585.                   if (var29 >= var35 && this.findIntersect(var1, var2, var3, var5 + 1, var6, var31, var33, var35, var13, var15, var17, var19, var21, var23, var25, var27, var29)) {
  586.                      return true;
  587.                   }
  588.                }
  589.             } else if (var25 - var19 > 0.001) {
  590.                double var53 = (var19 + var25) / (double)2.0F;
  591.                double var55 = var1.XforT(var53);
  592.                double var57 = var1.YforT(var53);
  593.                if (var53 == var19 || var53 == var25) {
  594.                   System.out.println("t0 = " + var19);
  595.                   System.out.println("t1 = " + var25);
  596.                   throw new InternalError("no t progress!");
  597.                }
  598.  
  599.                if (var57 >= var11 && this.findIntersect(var1, var2, var3, var5, var6 + 1, var7, var9, var11, var13, var15, var17, var19, var21, var23, var53, var55, var57)) {
  600.                   return true;
  601.                }
  602.  
  603.                if (var17 >= var57 && this.findIntersect(var1, var2, var3, var5, var6 + 1, var7, var9, var11, var13, var15, var17, var53, var55, var57, var25, var27, var29)) {
  604.                   return true;
  605.                }
  606.             } else {
  607.                double var54 = var15 - var9;
  608.                double var56 = var17 - var11;
  609.                double var58 = var27 - var21;
  610.                double var59 = var29 - var23;
  611.                double var60 = var21 - var9;
  612.                double var61 = var23 - var11;
  613.                double var43 = var58 * var56 - var59 * var54;
  614.                if (var43 != (double)0.0F) {
  615.                   double var45 = (double)1.0F / var43;
  616.                   double var47 = (var58 * var61 - var59 * var60) * var45;
  617.                   double var49 = (var54 * var61 - var56 * var60) * var45;
  618.                   if (var47 >= (double)0.0F && var47 <= (double)1.0F && var49 >= (double)0.0F && var49 <= (double)1.0F) {
  619.                      var47 = var7 + var47 * (var13 - var7);
  620.                      var49 = var19 + var49 * (var25 - var19);
  621.                      if (var47 < (double)0.0F || var47 > (double)1.0F || var49 < (double)0.0F || var49 > (double)1.0F) {
  622.                         System.out.println("Uh oh!");
  623.                      }
  624.  
  625.                      double var51 = (this.YforT(var47) + var1.YforT(var49)) / (double)2.0F;
  626.                      if (var51 <= var2[1] && var51 > var2[0]) {
  627.                         var2[1] = var51;
  628.                         return true;
  629.                      }
  630.                   }
  631.                }
  632.             }
  633.  
  634.             return false;
  635.          } else {
  636.             return false;
  637.          }
  638.       } else {
  639.          return false;
  640.       }
  641.    }
  642.  
  643.    public double refineTforY(double var1, double var3, double var5) {
  644.       double var7 = (double)1.0F;
  645.  
  646.       while(true) {
  647.          double var9 = (var1 + var7) / (double)2.0F;
  648.          if (var9 == var1 || var9 == var7) {
  649.             return var7;
  650.          }
  651.  
  652.          double var11 = this.YforT(var9);
  653.          if (var11 < var5) {
  654.             var1 = var9;
  655.          } else {
  656.             if (!(var11 > var5)) {
  657.                return var7;
  658.             }
  659.  
  660.             var7 = var9;
  661.          }
  662.       }
  663.    }
  664.  
  665.    public boolean fairlyClose(double var1, double var3) {
  666.       return Math.abs(var1 - var3) < Math.max(Math.abs(var1), Math.abs(var3)) * 1.0E-10;
  667.    }
  668.  
  669.    public abstract int getSegment(double[] var1);
  670. }
  671.