コード例 #1
0
ファイル: AlgoLocus.java プロジェクト: tomasp8/geogebra
  public AlgoLocus(Construction cons, String label, GeoPoint2 Q, GeoPoint2 P) {
    super(cons);
    this.movingPoint = P;
    this.locusPoint = Q;

    path = P.getPath();
    pathMover = path.createPathMover();

    QstartPos = new GeoPoint2(cons);
    PstartPos = new GeoPoint2(cons);

    init();
    updateScreenBorders();
    locus = new GeoLocus(cons);
    setInputOutput(); // for AlgoElement
    cons.registerEuclidianViewCE(this);
    compute();

    // we may have created a starting point for the path now
    // make sure that the movingPoint in the main construction
    // uses the correct path parameter for it
    path.pointChanged(P);

    locus.setLabel(label);
  }
コード例 #2
0
ファイル: AlgoLocus.java プロジェクト: tomasp8/geogebra
  private void insertPoint(double x, double y, boolean lineTo) {
    pointCount++;

    //	Application.debug("insertPoint: " + x + ", " + y + ", lineto: " + lineTo);
    locus.insertPoint(x, y, lineTo);
    lastX = x;
    lastY = y;
    lastFarAway = isFarAway(lastX, lastY);
  }
コード例 #3
0
ファイル: AlgoLocus.java プロジェクト: tomasp8/geogebra
  private void buildLocusMacroConstruction(TreeSet<ConstructionElement> locusConsElements) {
    // build macro construction
    macroKernel = new MacroKernel((Kernel) kernel);
    macroKernel.setGlobalVariableLookup(true);

    // tell the macro construction about reserved names:
    // these names will not be looked up in the parent
    // construction
    Iterator<ConstructionElement> it = locusConsElements.iterator();
    while (it.hasNext()) {
      ConstructionElement ce = it.next();
      if (ce.isGeoElement()) {
        GeoElement geo = (GeoElement) ce;
        macroKernel.addReservedLabel(geo.getLabel());
      }
    }

    try {
      // get XML for macro construction of P -> Q
      String locusConsXML = Macro.buildMacroXML((Kernel) kernel, locusConsElements);

      macroKernel.loadXML(locusConsXML);

      // get the copies of P and Q from the macro kernel
      Pcopy = (GeoPoint2) macroKernel.lookupLabel(movingPoint.label);
      Pcopy.setFixed(false);
      Pcopy.setPath(movingPoint.getPath());

      Qcopy = (GeoPoint2) macroKernel.lookupLabel(locusPoint.label);
      macroCons = macroKernel.getConstruction();

      /*
      // make sure that the references to e.g. start/end point of a segment are not
      // changed later on. This is achieved by setting isMacroOutput to true
      it = macroCons.getGeoElementsIterator();
          	while (it.hasNext()) {
           	GeoElement geo = (GeoElement) it.next();
           	geo.isAlgoMacroOutput = true;
          	}
          	Pcopy.isAlgoMacroOutput = false;
          	*/
    } catch (Exception e) {
      e.printStackTrace();
      locus.setUndefined();
      macroCons = null;
    }

    //    	//Application.debug("P: " + P + ", kernel class: " + P.kernel.getClass());
    //    	Application.debug("Pcopy: " + Pcopy  + ", kernel class: " + Pcopy.kernel.getClass());
    //    	//Application.debug("P == Pcopy: " + (P == Pcopy));
    //    	//Application.debug("Q: " + Q  + ", kernel class: " + Q.kernel.getClass());
    //    	Application.debug("Qcopy: " + Qcopy  + ", kernel class: " + Qcopy.kernel.getClass());
    //    	//Application.debug("Q == Qcopy: " + (Q == Qcopy));
  }
コード例 #4
0
ファイル: AlgoLocus.java プロジェクト: tomasp8/geogebra
  // compute locus line
  @Override
  public final void compute() {
    if (!movingPoint.isDefined() || macroCons == null || !path.toGeoElement().isDefined()) {
      locus.setUndefined();
      return;
    }

    locus.clearPoints();
    clearCache();
    pointCount = 0;
    useCache = 0;
    countUpdates = 0;
    lastX = Double.MAX_VALUE;
    lastY = Double.MAX_VALUE;
    maxTimeExceeded = false;
    foundDefined = false;
    boolean prevQcopyDefined = false;
    int max_runs;

    // continuous kernel?
    continuous = kernel.isContinuous();
    macroKernel.setContinuous(continuous);

    // update macro construction with current values of global vars
    resetMacroConstruction();
    macroCons.updateConstruction();

    // use current position of movingPoint to start Pcopy
    pathMover.init(Pcopy);

    if (continuous) {
      // continous constructions may need several parameter run throughs
      // to draw all parts of the locus
      max_runs = GeoLocus.MAX_PATH_RUNS;
    } else {
      max_runs = 1;
    }

    // update Pcopy to compute Qcopy
    pcopyUpdateCascade();
    prevQcopyDefined = Qcopy.isDefined() && !Qcopy.isInfinite();

    // move Pcopy along the path
    // do this until Qcopy comes back to its start position
    // for continuous constructions
    // this may require several runs of Pcopy along the whole path

    int runs = 1;
    int MAX_LOOPS = 2 * PathMover.MAX_POINTS;
    int whileLoops = 0;

    do {
      boolean finishedRun = false;
      while (!finishedRun
          && !maxTimeExceeded
          && pointCount <= PathMover.MAX_POINTS
          && whileLoops <= MAX_LOOPS) {
        whileLoops++;

        // lineTo may be false due to a parameter jump
        // i.e. param in [0,1] gets bigger than 1 and thus jumps to 0
        boolean parameterJump = !pathMover.getNext(Pcopy);
        boolean stepChanged = false;

        // update construction
        pcopyUpdateCascade();

        // Qcopy DEFINED
        if (Qcopy.isDefined() && !Qcopy.isInfinite()) {
          // STANDARD CASE: no parameter jump
          if (!parameterJump) {
            // make steps smaller until distance ok to connect with last point
            while (Qcopy.isDefined()
                && !Qcopy.isInfinite()
                && !distanceOK(Qcopy)
                && !maxTimeExceeded) {
              // go back and try smaller step
              boolean smallerStep = pathMover.smallerStep();
              if (!smallerStep) break;

              stepChanged = true;
              pathMover.stepBack();
              pathMover.getNext(Pcopy);

              // update construction
              pcopyUpdateCascade();
            }

            if (Qcopy.isDefined() && !Qcopy.isInfinite()) {
              // draw point
              insertPoint(Qcopy.inhomX, Qcopy.inhomY, distanceSmall(Qcopy));
              prevQcopyDefined = true;
            }
          }

          // PARAMETER jump: !lineTo
          else {
            // draw point
            insertPoint(Qcopy.inhomX, Qcopy.inhomY, distanceSmall(Qcopy));
            prevQcopyDefined = true;
          }
        }

        // Qcopy NOT DEFINED
        else {
          // check if we moved from defined to undefined case:
          // step back and try with smaller step
          if (prevQcopyDefined && !parameterJump) {
            pathMover.stepBack();
            // set smallest step
            if (!pathMover.smallerStep()) {
              prevQcopyDefined = false;
            } else stepChanged = true;
          }

          // add better undefined case support for continuous curves
          // maybe change orientation of path mover
        }

        // if we didn't decrease the step width increase it
        if (!stepChanged) {
          pathMover.biggerStep();
        }

        // end of run: the next step would pass the start position
        if (!pathMover.hasNext()) {
          if (distanceSmall(QstartPos)) {
            // draw line back to first point when it's close enough
            insertPoint(QstartPos.inhomX, QstartPos.inhomY, true);
            finishedRun = true;
          } else {
            // decrease step until another step is possible
            while (!pathMover.hasNext() && pathMover.smallerStep()) ;

            // no smaller step possible: run finished
            if (!pathMover.hasNext()) finishedRun = true;
          }
        }
      }

      // calculating the steps took too long, so we stopped somewhere
      if (maxTimeExceeded) {
        System.err.println("AlgoLocus: max time exceeded");
        return;
      } else {
        // make sure that Pcopy is back at startPos now
        // look at Qcopy at startPos
        Pcopy.set((GeoElement) PstartPos);
        pcopyUpdateCascade();
        if (Qcopy.inhomX != lastX || Qcopy.inhomY != lastY)
          insertPoint(Qcopy.inhomX, Qcopy.inhomY, distanceSmall(Qcopy));

        //	    		 Application.debug("run: " + runs);
        //	    		 Application.debug("pointCount: " + pointCount);
        //		       	 Application.debug("  startPos: " + QstartPos);
        //		       	 Application.debug("  Qcopy: " + Qcopy);

        // we are finished with all runs
        // if we got back to the start position of Qcopy
        // AND if the direction of moving along the path
        // is positive like in the beginning
        if (pathMover.hasPositiveOrientation()) {
          kernel.setMinPrecision();
          boolean equal = QstartPos.isEqual(Qcopy);
          kernel.resetPrecision();
          if (equal) break;
        }
      }

      pathMover.resetStartParameter();
      runs++;
    } while (runs < max_runs);

    // set defined/undefined
    locus.setDefined(foundDefined);

    //    	System.out.println("  first point: " + locus.getMyPointList().get(0));
    //    	ArrayList list = locus.getMyPointList();
    //    	for (int i=list.size()-10; i < list.size()-1; i++) {
    //    		System.out.println("      point: " + list.get(i));
    //    	}
    //    	System.out.println("  last  point: " + locus.getMyPointList().get(pointCount-1));

    // Application.debug("LOCUS COMPUTE updateCascades: " + countUpdates + ", cache used: " +
    // useCache);
  }