示例#1
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));
  }
示例#2
0
 /** @see Object3D#intersection(Object3D) */
 public Object3D intersection(Object3D space) {
   double cutxyX = 0.0, cutxzX = 0.0;
   if (space instanceof Point3D) {
     Point3D other = (Point3D) space;
     if ((this.gradeY * other.x + this.offsetY == other.y)
         && (this.gradeZ * other.x + this.offsetZ == other.z)) return (Object3D) other.clone();
     else return Object3DVoid;
   }
   if (space instanceof Line3D) {
     Line3D test = (Line3D) space;
     // Exclusion of parallel lines which never will intersect each others.
     if (test.gradeY == this.gradeY) {
       if (this.offsetY != test.offsetY)
         return Object3DVoid; // parallel lines in x-y area (they will never touch in this
                              // dimension)
     }
     if (test.gradeZ == this.gradeZ) {
       if (this.offsetZ != test.offsetZ)
         return Object3DVoid; // parallel lines in x-z area (they will never touch in this
                              // dimension)
     }
     // mathematical search for the intersection point:
     // has to cut in x-y dimension:
     cutxyX = (this.offsetY - test.offsetY) / (test.gradeY - this.gradeY);
     cutxzX = (this.offsetZ - test.offsetZ) / (test.gradeZ - this.gradeZ);
     if (cutxyX == 0.0 / 0.0) {
       // Parallel lines are caught above.
       // In xy-dimension the lines are matching. (see calculation of cutxyX)
       // Now there are two possibilities:
       // 	- The lines are also matching in dimension xz (cutxzX is NaN too): If the x-ranges of
       // both lines are overlapping "intersection" is true.
       //	- The lines have to cross: Check wether cutxzX  is in x-range of both lines.
       if (cutxzX == 0.0 / 0.0) {
         if (!((this.end.x < test.start.x) // start.x is smaller end.x! (constructor)
             || (this.start.x > test.end.x))) {
           Point3D startx = (this.start.x > test.start.x) ? this.start : test.start;
           Point3D endx = (this.end.x < test.end.x) ? this.end : test.end;
           return new Line3D(startx, endx);
         } else return Object3DVoid;
       } else {
         // on zx-area it's not matching, so we have to check wether the intersection of both
         // lines of the zx-area is within the x-bounds of both lines.
         if ((cutxzX >= this.start.x)
             && (cutxzX <= this.end.x)
             && (cutxzX >= test.start.x)
             && (cutxzX <= test.end.x))
           return new Point3D(
               cutxzX, this.gradeY * cutxzX + this.offsetY, this.gradeZ * cutxzX + this.offsetZ);
         else return Object3DVoid;
       }
     }
     // The lines have an intersection in xy-dimension
     else {
       // this is the other way round:
       // either in xz - dimension the lines are on the same way:
       if (cutxzX == 0.0 / 0.0) {
         // in zx - area the lines are matching in grade and offset.
         // Then we will only have to check, wether the crossing of the lines in
         // xy-dimension is within the x-bounds of both lines.
         if ((cutxyX >= this.start.x)
             && (cutxyX <= this.end.x)
             && (cutxyX >= test.start.x)
             && (cutxyX <= test.end.x))
           return new Point3D(
               cutxyX, cutxyX * this.gradeY + this.offsetY, cutxyX * this.gradeZ + this.offsetZ);
         else return Object3DVoid;
       }
       // The lines are crossing in xy and xz dimension:
       // only if both x values cutxyX and cutxzX are equal and within the
       // x-ranges of both lines this is an intersection:
       else {
         if ((cutxyX == cutxzX)
             && ((cutxyX >= this.start.x) && (cutxyX <= this.end.x))
             && ((cutxyX >= test.start.x) && (cutxyX <= test.end.x))) {
           return new Point3D(
               cutxyX, cutxyX * this.gradeY + this.offsetY, cutxyX * this.gradeZ + this.offsetZ);
         } else return Object3DVoid;
       }
     }
   }
   return space.intersection(this);
 }