Ejemplo n.º 1
0
  private void setOutput() {
    if (points == null) return;

    // if init points have no labels, all the points and segments
    // of the polygon don't get labels either: in this case we only
    // have the polygon itself as output object
    if (!labelPointsAndSegments) {
      output = new GeoElement[1];
      output[0] = poly;
    }
    // otherwise: points and segments are also output objects
    else {
      // size = poly + points + segments
      GeoSegmentND[] segments = poly.getSegments();
      GeoPoint[] points = poly.getPoints();
      int size = 1 + segments.length + points.length;

      output = new GeoElement[size];
      int k = 0;
      output[k] = poly;

      for (int i = 0; i < segments.length; i++) {
        output[++k] = (GeoElement) segments[i];
      }

      for (int i = 0; i < points.length; i++) {
        output[++k] = points[i];
      }
    }
  }
Ejemplo n.º 2
0
 public final String toString() {
   // Michael Borcherds 2008-03-30
   // simplified to allow better Chinese translation
   if (poly != null)
     return app.getPlain("SegmentABofC", P.getLabel(), Q.getLabel(), poly.getNameDescription());
   else return app.getPlain("SegmentAB", P.getLabel(), Q.getLabel());
 }
Ejemplo n.º 3
0
  public AlgoPolygonOperation(
      Construction cons,
      String[] labels,
      GeoPolygon inPoly0,
      GeoPolygon inPoly1,
      int operationType) {

    super(cons);

    ev = cons.getApplication().getEuclidianView();
    this.operationType = operationType;
    this.inPoly0 = inPoly0;
    this.inPoly1 = inPoly1;
    points = new GeoPoint[0];
    poly = new GeoPolygon(cons, points);

    labelPointsAndSegments = true;

    setInputOutput();
    compute();

    // labels given by user or loaded from file
    int labelsLength = labels == null ? 0 : labels.length;

    // poly.setLabel(labels[0]);
    labelsNeedIniting = true;

    if (labelPointsAndSegments) {
      poly.initLabels(labels);
    } else if (labelsLength == 1) {
      poly.setLabel(labels[0]);
    } else {
      poly.setLabel(null);
    }

    labelsNeedIniting = false;
  }
Ejemplo n.º 4
0
  protected void setInputOutput() {

    input = new GeoElement[2];
    input[0] = inPoly0;
    input[1] = inPoly1;

    // set dependencies
    for (int i = 0; i < input.length; i++) {
      input[i].addAlgorithm(this);
    }
    cons.addToAlgorithmList(this);

    // setOutput(); done in compute

    // parent of output
    poly.setParentAlgorithm(this);
    cons.addToAlgorithmList(this);
  }
Ejemplo n.º 5
0
  private void updateSegmentsAndPointsLabels(int oldPointNumber) {
    if (labelsNeedIniting) return;

    // set labels only when points have labels
    /*
    labelPointsAndSegments = labelPointsAndSegments || A.isLabelSet() || B.isLabelSet();


    boolean pointsSegmentsShowLabel = labelPointsAndSegments &&
    		(A.isEuclidianVisible() && A.isLabelVisible() ||
    		 B.isEuclidianVisible() && B.isLabelVisible());

     */

    boolean pointsSegmentsShowLabel = true;

    // set labels for points only if the original points had labels
    if (labelPointsAndSegments) {
      for (int i = 0; i < points.length; i++) {
        if (!points[i].isLabelSet()) {
          points[i].setLabel(null);
          points[i].setLabelVisible(pointsSegmentsShowLabel);
        }
      }
    }

    // update all segments and set labels for new segments
    GeoSegmentND[] segments = poly.getSegments();
    for (int i = 0; i < segments.length; i++) {
      GeoElement seg = (GeoElement) segments[i];
      if (labelPointsAndSegments) {
        if (!seg.isLabelSet()) {
          seg.setLabel(null);
          seg.setAuxiliaryObject(true);
          seg.setLabelVisible(pointsSegmentsShowLabel);
        } else {
          pointsSegmentsShowLabel = pointsSegmentsShowLabel || seg.isLabelVisible();
        }
      }

      seg.getParentAlgorithm().update();
    }
  }
Ejemplo n.º 6
0
  public AlgoJoinPointsSegment(Construction cons, GeoPoint P, GeoPoint Q, GeoPolygon poly) {
    super(cons);

    // make sure that this helper algorithm is updated right after its parent polygon
    if (poly != null) {
      setUpdateAfterAlgo(poly.getParentAlgorithm());
    }

    this.poly = poly;
    this.P = P;
    this.Q = Q;

    s = new GeoSegment(cons, P, Q);
    setInputOutput(); // for AlgoElement

    // compute line through P, Q
    compute();
    setIncidence();
  }
Ejemplo n.º 7
0
  protected final void compute() {

    ArrayList<Double> xcoord = new ArrayList<Double>();
    ArrayList<Double> ycoord = new ArrayList<Double>();
    double[] coords = new double[6];
    double[] oldCoords = new double[6];

    // Convert input polygons to Area objects
    Area a1 = getArea(inPoly0.getPoints());
    Area a2 = getArea(inPoly1.getPoints());

    // test for empty intersection
    Area testArea = getArea(inPoly0.getPoints());
    testArea.intersect(a2);
    if (testArea.isEmpty()) {
      poly.setUndefined();
    }
    // if intersection is non-empty perform operation
    else {
      switch (operationType) {
        case TYPE_INTERSECTION:
          a1.intersect(a2);
          break;
        case TYPE_UNION:
          a1.add(a2);
          break;
        case TYPE_DIFFERENCE:
          a1.subtract(a2);
          break;
      }

      // Iterate through the path of the result
      // and recover the polygon vertices.

      PathIterator it = a1.getPathIterator(null);

      int type = it.currentSegment(coords);
      it.next();
      oldCoords = coords.clone();
      double epsilon = 1E-10;

      while (!it.isDone()) {
        type = it.currentSegment(coords);
        if (type == PathIterator.SEG_CLOSE) {
          break;
        }
        // Sometimes the Path iterator gives two almost identical points and
        // we only want one of them.
        // TODO: Why does this happen???
        if ((double) Math.abs(oldCoords[0] - coords[0]) > epsilon
            || (double) Math.abs(oldCoords[1] - coords[1]) > epsilon) {
          xcoord.add(coords[0]);
          ycoord.add(coords[1]);
        }
        oldCoords = coords.clone();

        it.next();
      }
    }

    // Update the points array to the correct size
    int n = xcoord.size();
    // System.out.println("number of points: " + n);
    int oldPointNumber = points.length;
    if (n != oldPointNumber) {
      updatePointsArray(n);
      poly.setPoints(points);
      setOutput();
    }

    // Set the points to the new polygon vertices
    for (int k = 0; k < n; k++) {
      points[k].setCoords(xcoord.get(k), ycoord.get(k), 1);
      // System.out.println("vertices: " + xcoord.get(k) + " , " + ycoord.get(k));

    }

    // Compute area of poly (this will also set our poly geo to be defined)
    poly.calcArea();

    // update new points and segments
    if (n != oldPointNumber) {
      updateSegmentsAndPointsLabels(oldPointNumber);
    }
  }
Ejemplo n.º 8
0
  /** Fills the list of default geos */
  protected void createDefaultGeoElements() {
    defaultGeoElements = new HashMap<Integer, GeoElement>();

    // free point
    GeoPoint freePoint = new GeoPoint(cons);
    //		freePoint.setLocalVariableLabel(app.getPlain("Point") + strFree);
    freePoint.setPointSize(EuclidianView.DEFAULT_POINT_SIZE);
    freePoint.setPointStyle(EuclidianView.POINT_STYLE_DOT);
    freePoint.setLocalVariableLabel("Point" + strFree);
    freePoint.setObjColor(colPoint);
    freePoint.setPointSize(pointSize);
    defaultGeoElements.put(DEFAULT_POINT_FREE, freePoint);

    // dependent point
    GeoPoint depPoint = new GeoPoint(cons);
    //		depPoint.setLocalVariableLabel(app.getPlain("Point") + strDependent);
    depPoint.setPointSize(EuclidianView.DEFAULT_POINT_SIZE);
    depPoint.setPointStyle(EuclidianView.POINT_STYLE_DOT);
    depPoint.setLocalVariableLabel("Point" + strDependent);
    depPoint.setObjColor(colDepPoint);
    depPoint.setPointSize(pointSize);
    defaultGeoElements.put(DEFAULT_POINT_DEPENDENT, depPoint);

    // point on path
    GeoPoint pathPoint = new GeoPoint(cons);
    //		pathPoint.setLocalVariableLabel(app.getPlain("PointOn"));
    pathPoint.setPointSize(EuclidianView.DEFAULT_POINT_SIZE);
    pathPoint.setPointStyle(EuclidianView.POINT_STYLE_DOT);
    pathPoint.setLocalVariableLabel("PointOn");
    pathPoint.setObjColor(colPathPoint);
    pathPoint.setPointSize(pointSize);
    defaultGeoElements.put(DEFAULT_POINT_ON_PATH, pathPoint);

    // point in region
    GeoPoint regionPoint = new GeoPoint(cons);
    //		regionPoint.setLocalVariableLabel(app.getPlain("PointOn"));
    regionPoint.setPointSize(EuclidianView.DEFAULT_POINT_SIZE);
    regionPoint.setPointStyle(EuclidianView.POINT_STYLE_DOT);
    regionPoint.setLocalVariableLabel("PointInRegion");
    regionPoint.setObjColor(colRegionPoint);
    defaultGeoElements.put(DEFAULT_POINT_IN_REGION, regionPoint);

    // complex number (handled like a point)
    GeoPoint complexPoint = new GeoPoint(cons);
    complexPoint.setPointSize(EuclidianView.DEFAULT_POINT_SIZE);
    complexPoint.setPointStyle(EuclidianView.POINT_STYLE_DOT);
    complexPoint.setLocalVariableLabel("PointOn");
    complexPoint.setObjColor(colComplexPoint);
    complexPoint.setPointSize(pointSize);
    defaultGeoElements.put(DEFAULT_POINT_COMPLEX, complexPoint);

    // line
    GeoLine line = new GeoLine(cons);
    //		line.setLocalVariableLabel(app.getPlain("Line"));
    line.setLocalVariableLabel("Line");
    line.setObjColor(colLine);
    defaultGeoElements.put(DEFAULT_LINE, line);

    GeoFunctionNVar inequality = new GeoFunctionNVar(cons, null);
    // inequality.setLocalVariableLabel("Inequality");
    inequality.setObjColor(colInequality);
    inequality.setAlphaValue(DEFAULT_INEQUALITY_ALPHA);
    defaultGeoElements.put(DEFAULT_INEQUALITY, inequality);

    GeoFunction inequality1var = new GeoFunction(cons);
    // inequality.setLocalVariableLabel("Inequality");
    inequality1var.setObjColor(colInequality);
    inequality1var.setAlphaValue(DEFAULT_INEQUALITY_ALPHA);
    defaultGeoElements.put(DEFAULT_INEQUALITY_1VAR, inequality1var);

    // vector
    GeoVector vector = new GeoVector(cons);
    vector.setLocalVariableLabel("Vector");
    vector.setObjColor(colLine);
    defaultGeoElements.put(DEFAULT_VECTOR, vector);

    // polygon
    GeoPolygon polygon = new GeoPolygon(cons, null);
    //		polygon.setLocalVariableLabel(app.getPlain("Polygon"));
    polygon.setLocalVariableLabel("Polygon");
    polygon.setObjColor(colPolygon);
    polygon.setAlphaValue(DEFAULT_POLYGON_ALPHA);
    defaultGeoElements.put(DEFAULT_POLYGON, polygon);

    // conic
    GeoConic conic = new GeoConic(cons);
    //		conic.setLocalVariableLabel(app.getPlain("Conic"));
    conic.setLocalVariableLabel("Conic");
    conic.setObjColor(colConic);
    defaultGeoElements.put(DEFAULT_CONIC, conic);

    // conic sector
    GeoConicPart conicSector = new GeoConicPart(cons, GeoConicPart.CONIC_PART_SECTOR);
    //		conicSector.setLocalVariableLabel(app.getPlain("Sector"));
    conicSector.setLocalVariableLabel("Sector");
    conicSector.setObjColor(colPolygon);
    conicSector.setAlphaValue(DEFAULT_POLYGON_ALPHA);
    defaultGeoElements.put(DEFAULT_CONIC_SECTOR, conicSector);

    // number
    GeoNumeric number = new GeoNumeric(cons);
    //		number.setLocalVariableLabel(app.getPlain("Numeric"));
    number.setLocalVariableLabel("Numeric");
    number.setSliderFixed(true);
    number.setLabelMode(GeoElement.LABEL_NAME_VALUE);
    /*we have to set min/max/increment/speed here because
    SetEuclideanVisible takes these from default geo*/
    number.setIntervalMax(GeoNumeric.DEFAULT_SLIDER_MAX);
    number.setIntervalMin(GeoNumeric.DEFAULT_SLIDER_MIN);
    number.setAnimationStep(GeoNumeric.DEFAULT_SLIDER_INCREMENT);
    number.setAnimationSpeed(GeoNumeric.DEFAULT_SLIDER_SPEED);
    defaultGeoElements.put(DEFAULT_NUMBER, number);

    // angle
    GeoAngle angle = new GeoAngle(cons);
    //		angle.setLocalVariableLabel(app.getPlain("Angle"));
    angle.setLocalVariableLabel("Angle");
    angle.setSliderFixed(true);
    angle.setObjColor(colAngle);
    angle.setAlphaValue(DEFAULT_ANGLE_ALPHA);
    angle.setArcSize(angleSize);
    /*we have to set min/max/increment/speed here because
    SetEuclideanVisible takes these from default geo*/
    angle.setIntervalMax(GeoAngle.DEFAULT_SLIDER_MAX);
    angle.setIntervalMin(GeoAngle.DEFAULT_SLIDER_MIN);
    angle.setAnimationStep(GeoAngle.DEFAULT_SLIDER_INCREMENT);
    angle.setAnimationSpeed(GeoAngle.DEFAULT_SLIDER_SPEED);
    defaultGeoElements.put(DEFAULT_ANGLE, angle);

    // function
    GeoFunction function = new GeoFunction(cons);
    //		function.setLocalVariableLabel(app.getPlain("Function"));
    function.setLocalVariableLabel("Function");
    function.setObjColor(colFunction);
    defaultGeoElements.put(DEFAULT_FUNCTION, function);

    // locus
    GeoLocus locus = new GeoLocus(cons);
    //		locus.setLocalVariableLabel(app.getPlain("Locus"));
    locus.setLocalVariableLabel("Locus");
    locus.setObjColor(colLocus);
    locus.setLabelVisible(false);
    defaultGeoElements.put(DEFAULT_LOCUS, locus);

    // text
    GeoText text = new GeoText(cons);
    //		text.setLocalVariableLabel(app.getPlain("Text"));
    text.setLocalVariableLabel("Text");
    defaultGeoElements.put(DEFAULT_TEXT, text);

    // image
    GeoImage img = new GeoImage(cons);
    //		img.setLocalVariableLabel(app.getPlain("Image"));
    img.setLocalVariableLabel("Image");
    defaultGeoElements.put(DEFAULT_IMAGE, img);

    // boolean
    GeoBoolean bool = new GeoBoolean(cons);
    //		bool.setLocalVariableLabel(app.getPlain("Boolean"));
    bool.setLocalVariableLabel("Boolean");
    defaultGeoElements.put(DEFAULT_BOOLEAN, bool);

    // list
    GeoList list = new GeoList(cons);
    //		list.setLocalVariableLabel(app.getPlain("List"));
    list.setShowAllProperties(true); // show all properties in the defaults dialog
    list.setLocalVariableLabel("List");
    list.setObjColor(colList);
    list.setAlphaValue(-1); // wait until we have an element in the list
    // then we will use the alphaValue of the first element in the list
    // see GeoList.setAlphaValue() and getAlphaValue()
    defaultGeoElements.put(DEFAULT_LIST, list);
  }
Ejemplo n.º 9
0
 public int getConstructionIndex() {
   if (poly != null) return poly.getConstructionIndex();
   else return super.getConstructionIndex();
 }
Ejemplo n.º 10
0
 public void remove() {
   super.remove();
   if (poly != null) poly.remove();
 }