public static Polygon3D buildPolygon(LineData ld, Vector points) {

    int size = ld.size();

    int[] cxr = new int[size];
    int[] cyr = new int[size];
    int[] czr = new int[size];
    Point3D[] normals = new Point3D[size];

    for (int i = 0; i < size; i++) {

      int num = ld.getIndex(i);

      Point3D p = (Point3D) points.elementAt(num);

      // real coordinates
      cxr[i] = (int) (p.x);
      cyr[i] = (int) (p.y);
      czr[i] = (int) (p.z);

      normals[i] = p.getNormal();
    }

    Polygon3D p3dr = new Polygon3D(size, cxr, cyr, czr, normals);

    return p3dr;
  }
Beispiel #2
0
 /**
  * @param a
  * @param b
  * @return
  */
 public static Point3D plus(Point3D a, Point3D b) {
   Point3D c = new Point3D(a.x, a.x, a.x);
   c.x = a.x + b.x;
   c.y = a.y + b.y;
   c.z = a.z + b.z;
   return c;
 }
Beispiel #3
0
  public static void main(String[] args) {
    Point3D p1 = new Point3D(0.0, 0.0, 0.0);
    Point3D p2 = new Point3D(4.0, 4.0, 4.0);
    Line3D l1 = new Line3D(p1, p2);

    Point3D p3 = new Point3D(0.0, 4.0, 4.0);
    Point3D p4 = new Point3D(4.0, 0.0, 0.0);
    Line3D l2 = new Line3D(p3, p4);

    System.out.println("p1: " + p1);
    System.out.println("p2: " + p2);
    System.out.println("l1: " + l1);
    System.out.println("l1.intersection(p2): " + l1.intersection(p2));
    System.out.println("p2.intersection(l1): " + p2.intersection(l1));
    System.out.println("l2: " + l2);
    System.out.println("l2.intersection(l1): " + l2.intersection(l1));
    System.out.println("l1.intersection(l2): " + l1.intersection(l2));

    System.out.println("Object3D c1 = l1.union(l2)");
    Object3D c1 = l1.union(l2);
    System.out.println("c1: \n" + c1.toString());
    System.out.println("p1.union(p4): \n" + p1.union(p4));
    System.out.println("c1.intersection(p1.union(p4))");
    System.out.println(c1.intersection(p1.union(p4)));

    System.out.println("c1.union(p3):\n" + c1.union(p3));
  }
Beispiel #4
0
 /**
  * @param a
  * @param b
  * @return
  */
 public static Point3D div(Point3D a, double b) {
   Point3D c = new Point3D(a.x, a.x, a.x);
   c.x = a.x / b;
   c.y = a.y / b;
   c.z = a.z / b;
   return c;
 }
Beispiel #5
0
  private void dehomog(Point3D pA, Point3D pB, Point3D pC, int color, boolean fill) {
    Vec3D vA = pA.dehomog();
    Vec3D vB = pB.dehomog();
    Vec3D vC = pC.dehomog();

    cropScene(vA, vB, vC, color, fill);
  }
  public Point3D update(float time) {
    elapsedTime += time;
    if (elapsedTime == 0) {
      returnPos = pos1;
    } else if (elapsedTime >= 10) // traveling to a planet will take 10 seconds
    {
      returnPos.set(pos4.x, pos4.y, pos4.z);
    } else {
      float t = elapsedTime / 10f;

      returnPos.x =
          (1.0f - t) * (1.0f - t) * (1.0f - t) * pos1.x
              + 3 * (1.0f - t) * (1.0f - t) * t * pos2.x
              + 3 * (1.0f - t) * t * t * pos3.x
              + t * t * t * pos4.x;
      returnPos.y =
          (1.0f - t) * (1.0f - t) * (1.0f - t) * pos1.y
              + 3 * (1.0f - t) * (1.0f - t) * t * pos2.y
              + 3 * (1.0f - t) * t * t * pos3.y
              + t * t * t * pos4.y;
      returnPos.z =
          (1.0f - t) * (1.0f - t) * (1.0f - t) * pos1.z
              + 3 * (1.0f - t) * (1.0f - t) * t * pos2.z
              + 3 * (1.0f - t) * t * t * pos3.z
              + t * t * t * pos4.z;
    }

    return returnPos;
  }
Beispiel #7
0
 /**
  * @param a
  * @param b
  * @return
  */
 public static Point3D moins(Point3D a, Point3D b) {
   Point3D c = new Point3D((a.x - b.x), (a.y - b.y), (a.z - b.z));
   c.x = a.x - b.x;
   c.y = a.y - b.y;
   c.z = a.z - b.z;
   return c;
 }
Beispiel #8
0
 /**
  * @param a
  * @param b
  * @return
  */
 public static Point3D fois(Point3D a, double b) {
   Point3D c = new Point3D(a.x, a.x, a.x);
   c.x = a.x * b;
   c.y = a.y * b;
   c.z = a.z * b;
   return c;
 }
Beispiel #9
0
  public boolean isEqual(Point3D other) {
    if ((Math.abs(Double.parseDouble(x) - Double.parseDouble(other.getX())) <= Epsilon)
        && (Math.abs(Double.parseDouble(y) - Double.parseDouble(other.getY())) <= Epsilon)
        && (Math.abs(Double.parseDouble(z) - Double.parseDouble(other.getZ())) <= Epsilon))
      return true;

    return false;
  }
Beispiel #10
0
 /*
  *  Connects the letters by going along the Z axis
  */
 public static void ConnectLetters(Graphics g, Object letter) {
   Point3D topPoint = new Point3D(0, 0, 0);
   for (int i = 0; i < letter.vertices.length; i++) {
     Move3D(letter.vertices[i], letter.aT, CAMERA);
     topPoint.SetCoords(letter.vertices[i].x, letter.vertices[i].y, -1);
     Draw3D(g, topPoint, letter.aT, CAMERA);
   }
 }
Beispiel #11
0
 /*
  *  Takes in an object and a height and connects all the points of the object
  *  from the floor to the specified height
  */
 public static void ConnectWalls(Graphics g, Object floorObject, double y) {
   Point3D topPoint = new Point3D(0, 0, 0);
   for (int i = 0; i < floorObject.vertices.length; i++) {
     Move3D(floorObject.vertices[i], floorObject.aT, CAMERA);
     topPoint.SetCoords(floorObject.vertices[i].x, y, floorObject.vertices[i].z);
     Draw3D(g, topPoint, floorObject.aT, CAMERA);
   }
 }
Beispiel #12
0
  public static void main(String[] args) {
    Point3D p1 = new Point3D(1, 2, 3);
    Point3D p2 = new Point3D(1, 2, 3);

    System.out.println(p1);
    System.out.println(p2);
    System.out.println("p1==p2?" + (p1 == p2));
    System.out.println("p1.equals(p2)?" + (p1.equals(p2)));
  }
  @Override
  public float distanceFromCameraToPoint(Point3D point3D) {
    float distance;

    Point3D fromCoordinates = cameraSettings.getRealFromCoordinates();
    distance = fromCoordinates.distanceTo(point3D);

    return distance;
  }
  private static void DoConvertDMS2D(String pointFile, String saveFile) {
    FileReader in = null;
    BufferedReader reader = null;
    int cntLine = 0;

    FileWriter out = null;
    BufferedWriter writer = null;
    try {
      out = new FileWriter(saveFile);
    } catch (IOException e) {
      e.printStackTrace();
    }
    writer = new BufferedWriter(out);

    try {
      in = new FileReader(pointFile);
      reader = new BufferedReader(in);
      String str;
      Point3D pt3d = null;
      while (true) {
        str = reader.readLine();
        if (str == null) break;
        cntLine++;
        pt3d = Point3D.Create(str);
        if (cntLine % 1000000 == 0) {
          System.out.println("cnt : " + (cntLine));
          writer.flush();
        }

        if (pt3d != null) {
          writer.write(
              String.format("%.9f", pt3d.GetX())
                  + " "
                  + String.format("%.9f", pt3d.GetY())
                  + " "
                  + String.format("%.3f", pt3d.GetZ()));
          writer.newLine();

        } else {
          System.out.println("Err : " + str);
        }
      }
      System.out.println("Lines : " + cntLine);
    } catch (Exception e) {
      e.printStackTrace();
    } finally {
      try {
        in.close();
        writer.flush();
        out.flush();
        out.close();
      } catch (IOException e) {
        e.printStackTrace();
      }
    }
  }
Beispiel #15
0
  public Point3D normal() {
    if (n == null) {
      Point3D a = new Point3D(p1.x - p0.x, p1.y - p0.y, p1.z - p0.z);
      Point3D b = new Point3D(p2.x - p0.x, p2.y - p0.y, p2.z - p0.z);

      n = a.cross(b).normalize();
    }

    return n;
  }
  public void setDestination(Planet destination, Point3D pos) {
    this.destination = destination;
    this.pos1.set(pos.x, pos.y, pos.z);
    pos4.set(destination.x, 2 * destination.size, -3 * destination.size);
    pos2 = new Point3D(pos1.x, destination.size, pos.z - 500);
    pos3 = new Point3D(pos4.x, destination.size, -500);

    elapsedTime = 0;
    returnPos.set(pos.x, pos.y, pos.z);
  }
  public static void main(String[] args) {

    // Point Construction
    Point3D p1 = new Point3D(1, 2, 4);
    Point3D p2 = new Point3D(2, 1, 5);

    // Output
    System.out.println(p2.distance(p1));
    System.out.println(p2.distanceL1(p1));
  }
 /**
  * Translates the plane by a vector <code>translateVector</code> without changing the original
  * plane.
  *
  * @param translateVector the point or vector by which the object shall be translated
  * @return the resulting translated plane
  */
 public Plane3D translateBy(Point3D translateVector) {
   double additionalDist = normal.getScalarProduct(translateVector);
   double newDist = distance + additionalDist;
   Point3D newDir;
   if (newDist < 0) {
     newDir = normal.reflectOrigin();
     newDist = -newDist;
   } else {
     newDir = normal;
   }
   return new Plane3D(newDist, newDir);
 }
Beispiel #19
0
  /** Returns XYZ coordinates of the point. Z will be set to 0 if Z is missing. */
  Point3D getXYZ() {
    if (isEmptyImpl())
      throw new GeometryException("This operation should not be performed on an empty geometry.");

    Point3D pt = new Point3D();
    pt.x = m_attributes[0];
    pt.y = m_attributes[1];
    if (m_description.hasZ()) pt.z = m_attributes[2];
    else pt.z = VertexDescription.getDefaultValue(Semantics.Z);

    return pt;
  }
Beispiel #20
0
  /*
   *  Draws and labels the axes
   */
  public static void DrawAxes(Graphics g) {
    String num = "";
    Point2D tmpPoint = new Point2D(0, 0);
    drawPoint drawer = new drawPoint(0, 0);
    // X axis
    Point3D PointToDraw = new Point3D(curWin.RightX, 0, 0);
    Move3D(PointToDraw, IDENTITY, CAMERA);

    PointToDraw.SetCoords(curWin.LeftX, 0, 0);
    Draw3D(g, PointToDraw, IDENTITY, CAMERA);

    for (double i = curWin.LeftX; i <= curWin.RightX; i += 0.5) {
      if (i == 0.0) continue;
      PointToDraw.SetCoords(i, 0, 0);

      num = "" + i;
      Move3D(PointToDraw, IDENTITY, CAMERA);
      drawer = ViewPortToFrameWindow(curPos);
      g.drawString(num, drawer.x, drawer.y);
    }

    // y-axis
    PointToDraw.SetCoords(0, curWin.TopY - 1, 0);
    Move3D(PointToDraw, IDENTITY, CAMERA);

    PointToDraw.SetCoords(0, curWin.BotY, 0);
    Draw3D(g, PointToDraw, IDENTITY, CAMERA);

    for (double i = curWin.BotY; i <= curWin.TopY - 1; i += 0.5) {
      if (i == 0.0) continue;
      PointToDraw.SetCoords(0.1, i, 0);

      num = "" + i;
      Move3D(PointToDraw, IDENTITY, CAMERA);
      drawer = ViewPortToFrameWindow(curPos);
      g.drawString(num, drawer.x, drawer.y);
    }

    // z-axis
    PointToDraw.SetCoords(0, 0, 4); // 4 is to keep it on the screen
    Move3D(PointToDraw, IDENTITY, CAMERA);

    PointToDraw.SetCoords(0, 0, -4); // keep it on the screen
    Draw3D(g, PointToDraw, IDENTITY, CAMERA);

    for (double i = -4.0; i <= 4.0; i += 0.5) {
      if (i == 0.0) continue;
      PointToDraw.SetCoords(0, 0.1, i);

      num = "" + i;
      Move3D(PointToDraw, IDENTITY, CAMERA);
      drawer = ViewPortToFrameWindow(curPos);
      g.drawString(num, drawer.x, drawer.y);
    }
  }
  protected void drawWAll(Color c, IDrawOperation op, Point3D[] wall, int dx, int dy, int dz) {

    Point3D a = new Point3D(0, 0, 0);
    Point3D b = new Point3D(0, 0, 0);
    int[] xs = new int[4];
    int[] ys = new int[4];

    for (int i = 0; i < 4; i++) {
      int j = (i == 3) ? 0 : i + 1;

      a.x = wall[i].x + dx;
      a.y = wall[i].y + dy;
      a.z = wall[i].z + dz;
      b.x = wall[j].x + dx;
      b.y = wall[j].y + dy;
      b.z = wall[j].z + dz;

      checkPoint(a);
      checkPoint(b);

      xs[i] = sx + a.x;
      ys[i] = sy - a.y;
    }

    op.fillPolygone(c, xs, ys, 1.0f);
    op.drawPolygone(Color.black, xs, ys, 1.0f);
  }
 /**
  * Checks if a Plane is close or equal to another one.
  *
  * @param geom the Geometry3D which the object should be compared to
  * @return <code>true</code> if the other plane is close or equal
  */
 public boolean isSimilar(Plane3D geom) {
   Plane3D s = (Plane3D) geom;
   if (Utilities3D.isEqual(distance, s.getDistance())) {
     if (normal.isSimilar(s.getNormalVec())) {
       return true;
     } else if (Utilities3D.isEqual(distance, 0.0)
         && normal.isSimilar(s.getNormalVec().reflectOrigin())) {
       return true;
     } else {
       return false;
     }
   } else {
     return false;
   }
 }
Beispiel #23
0
  Point3D convertFor(Point3D other) {
    Point3D alt0 = new Point3D(this.x, this.y, this.z);
    Point3D alt1 = new Point3D(this.x + World.mapWidth(), this.y, this.z);
    Point3D alt2 = new Point3D(this.x - World.mapWidth(), this.y, this.z);

    double d0 = Point3D.euclideanDistance(alt0, other);
    double d1 = Point3D.euclideanDistance(alt1, other);
    double d2 = Point3D.euclideanDistance(alt2, other);

    if (d0 <= d1 && d0 <= d2) {
      return alt0;
    } else if (d1 <= d0 && d1 <= d2) {
      return alt1;
    } else {
      return alt2;
    }
  }
  /**
   * Constructs a 3D Plane. The location of the plane is determined by <code>distance</code>, the
   * minimal distance of the plane from the origin.
   *
   * @param distance the distance of the plane from the origin
   * @param normal The (direction of the) unit normal vector
   */
  public Plane3D(double distance, Point3D normal) {
    this.distance = distance;
    this.normal = normal.norm();

    if (distance < 0.0) {
      throw new IllegalArgumentException("Cant work with negative distance!");
    }
  }
  @Override
  public Point3D convertToCameraCoordinateSystem(Point3D point3D) {
    Point3D converted = super.convertToCameraCoordinateSystem(point3D);

    double focalLength = cameraSettings.getFocalLength();
    double ratio = focalLength / converted.z;

    double x = ratio * converted.x;
    double y = ratio * converted.y;
    double z = converted.z;

    converted.x = x;
    converted.y = y;
    converted.z = z;

    return converted;
  }
  private void checkPoint(Point3D p) {
    //		double cos = Math.cos(Math.PI/8);
    //		double sin = Math.sin(Math.PI/8);
    //		Point3D p2 = new Point3D(0,0,0);

    // sur l'axe z
    //		p2.x = (int) (p.x*cos+p.y*sin);
    //		p2.y = (int) (-p.x*sin+p.y*cos);
    //		p2.z = p.z;
    //		vx = (int) (pointFuite.x*cos+pointFuite.y*sin);
    //		vy = (int) (-pointFuite.x*sin+pointFuite.y*cos);
    //		vz = (int) (pointFuite.z);

    //		p2.x = (int) (p.x*cos-p.z*sin);
    //		p2.y = (int) (p.y);
    //		p2.z = (int) (-p.x*sin+p.z*cos);

    //		p2.x = (int) (p.x);
    //		p2.y = (int) (p.y*cos-p.z*sin);
    //		p2.z = (int) (p.y*sin+p.z*cos);
    //		vx = (int) (pointFuite.x);
    //		vy = (int) (pointFuite.y*cos-pointFuite.z*sin);
    //		vz = (int) (pointFuite.y*sin+pointFuite.z*cos);

    //		double a = (vy-p2.y) / (vx-p2.x);
    //		double z = Math.min(vz, p2.z);
    //
    //		double var = z / vz;
    //		double yy = 1 - 1/(1+var*1.5);
    //		double d = yy * (vx-p2.x);

    double a = (vy - p.y) / (vx - p.x);
    double z = Math.min(vz, p.z);

    double var = z / vz;
    double yy = 1 - 1 / (1 + var * 1.5);
    double d = yy * (vx - p.x);

    //		p.x = p2.x;
    //		p.y = p2.y;
    //		p.z = p2.z;

    p.x += (int) d;
    p.y += (int) (a * d);
  }
Beispiel #27
0
 public void setVertexAt(int index, Point3D v) {
   Point3D vertex = vertices.get(index);
   // System.out.println("original: " + vertex);
   // System.out.println("new: " + v);
   vertex.setX(v.getX());
   vertex.setY(v.getY());
   vertex.setZ(v.getZ());
 }
Beispiel #28
0
  /*
   * Plots the given equation
   */
  public static void PlotGraph(Graphics g) {
    // start at the low point
    Point3D firstPoint = new Point3D(-1.25, -1.25, 0);
    Point3D secondPoint = new Point3D(-1.25, -1.25, 0);
    double inc = 0.05; // this looked the best
    g.setColor(Color.green);
    for (double y = -1.25; y <= 1.25; y += inc) {
      for (double x = -1.25; x <= 1.25; x += inc) {
        // draw the small square
        firstPoint.SetCoords(x, y, 0);
        secondPoint.SetCoords(x + inc, y + inc, 0);
        DrawSquare(g, firstPoint, secondPoint);
      }
    }

    g.setColor(Color.black);
    DrawAxes(g);
    Branding(g, "z = (x^2) + (y^2) - (x^3) - 8*x*(y^4)");
  }
 /**
  * Scales the plane by a factor.
  *
  * @param scale the scale for this operation
  * @return the scaled object
  */
 public Plane3D scaleBy(double scale) {
   double newDist = distance * scale;
   Point3D newDir;
   if (newDist < 0) {
     newDir = normal.reflectOrigin();
     newDist = -newDist;
   } else {
     newDir = normal;
   }
   return new Plane3D(newDist, newDir);
 }
Beispiel #30
0
  /*
   *  draws a square for the graph
   */
  public static void DrawSquare(Graphics g, Point3D leftPoint, Point3D rightPoint) {
    Point3D PointToDraw =
        new Point3D(leftPoint.x, leftPoint.y, PlotFunction(leftPoint.x, leftPoint.y));
    Move3D(PointToDraw, IDENTITY, CAMERA);

    // leftX -> rightX
    PointToDraw.SetCoords(rightPoint.x, leftPoint.y, PlotFunction(rightPoint.x, leftPoint.y));
    Draw3D(g, PointToDraw, IDENTITY, CAMERA);

    // botY -> topY
    PointToDraw.SetCoords(rightPoint.x, rightPoint.y, PlotFunction(rightPoint.x, rightPoint.y));
    Draw3D(g, PointToDraw, IDENTITY, CAMERA);

    // rightX -> leftX
    PointToDraw.SetCoords(leftPoint.x, rightPoint.y, PlotFunction(leftPoint.x, rightPoint.y));
    Draw3D(g, PointToDraw, IDENTITY, CAMERA);

    // topY -> botY
    PointToDraw.SetCoords(leftPoint.x, leftPoint.y, PlotFunction(leftPoint.x, leftPoint.y));
    Draw3D(g, PointToDraw, IDENTITY, CAMERA);
  }