Java Vector3D.subtract方法代码示例

import org.apache.commons.math3.geometry.euclidean.threed.Vector3D; //导入方法依赖的package包/类
@Override
public Set<Vector3D> fill(List<Vector3D> vertices) {
    Set<Vector3D> result = new HashSet<>();

    if (vertices.isEmpty()) return result;

    Vector3D pivot = vertices.get(0);

    for (int i = 1; i < vertices.size() - 1; ++i) {
        Vector3D current = vertices.get(i);
        Vector3D next = vertices.get(i + 1);

        Vector3D currentToNext = next.subtract(current);
        double dist = current.distance(next);
        double jump = getJump(pivot, current, next);

        for (double j = 0; j <= dist; j += jump) {
            Vector3D interpolated = current.add(currentToNext.scalarMultiply(j / dist));
            Set<Vector3D> linePoints = algorithm.draw(pivot, interpolated);
            result.addAll(linePoints);
        }
    }

    return result;
}
 

import org.apache.commons.math3.geometry.euclidean.threed.Vector3D; //导入方法依赖的package包/类
@Override
public Set<Vector3D> draw(Vector3D from, Vector3D to) {
    Set<Vector3D> result = new HashSet<>();
    double dist = from.distance(to);
    Vector3D between = to.subtract(from);

    for (double i = 0; i <= dist; ++i) {
        Vector3D interpolated = from.add(between.scalarMultiply(i / dist));

        result.add(interpolated);
    }
    return result;
}
 

import org.apache.commons.math3.geometry.euclidean.threed.Vector3D; //导入方法依赖的package包/类
private double cotangent(Vector3D a, Vector3D b, Vector3D c) {
    Vector3D ba = a.subtract(b);
    Vector3D bc = c.subtract(b);

    return ba.dotProduct(bc) / bc.crossProduct(ba).getNorm();
}
 

import org.apache.commons.math3.geometry.euclidean.threed.Vector3D; //导入方法依赖的package包/类
@Override
public double[] getRayIntersection(Vector3D rayOrigin, Vector3D rayDir) {

	// See http://www.lighthouse3d.com/tutorials/maths/ray-triangle-intersection/
	double[] result = new double[1];

	Vector3D e1 = this.verts[1].pos.subtract(this.verts[0].pos);
	Vector3D e2 = this.verts[2].pos.subtract(this.verts[0].pos);

	Vector3D h = rayDir.crossProduct(e2);

	double a = e1.dotProduct(h);

	if (a > -0.00001 && a < 0.00001) {
		result[0] = -1;
		return result;
	}

	double f = 1.0 / a;

	Vector3D s = rayOrigin.subtract(this.verts[0].pos);

	double u = f * s.dotProduct(h);

	if (u < 0.0 || u > 1.0) {
		result[0] = -1;
		return result;
	}

	Vector3D q = s.crossProduct(e1);

	double v = f * rayDir.dotProduct(q);

	if (v < 0.0 || u + v > 1.0) {
		result[0] = -1;
		return result;
	}

	double t = f * e2.dotProduct(q);

	if (t > 0.00001) {
		result[0] = t;
		return result;
	}

	result[0] = -1;
	return result;
}
 

import org.apache.commons.math3.geometry.euclidean.threed.Vector3D; //导入方法依赖的package包/类
@Override
public double[] getRayIntersection(Vector3D rayOrigin, Vector3D rayDir) {

	// TODO 4: Source?

	Vector3D origin = rayOrigin.subtract(this.center);

	double[] result = new double[2];

	// Compute A, B and C coefficients:
	double a = rayDir.dotProduct(rayDir);
	double b = 2 * rayDir.dotProduct(origin);
	double c = origin.dotProduct(origin) - this.radius * this.radius;

	// Find discriminant:
	double disc = b * b - 4 * a * c;

	// if discriminant is negative there are no real roots, so return
	// false as ray misses sphere:
	if (disc < 0) {
		result[0] = -1;
		return result;
	}

	// compute q:
	double distSqrt = Math.sqrt(disc);

	double q = 0;

	if (b < 0) {
		q = (-b - distSqrt) / 2;
	} else {
		q = (-b + distSqrt) / 2;
	}

	double t0 = q / a;
	double t1 = c / q;

	if (t0 > t1) {
		double temp = t0;
		t0 = t1;
		t1 = temp;
	}

	// if t1 is less than zero, the object is in the ray's negative direction
	// and consequently the ray misses the sphere
	if (t1 < 0) {
		result[0] = -1;
		return result;
	}

	// if t0 is less than zero, the intersection point is at t1
	if (t0 < 0) {
		result[0] = t1;
		return result;
	}

	// else the intersection point is at t0
	else {
		result[0] = t0;
		return result;
	}
}
 

import org.apache.commons.math3.geometry.euclidean.threed.Vector3D; //导入方法依赖的package包/类
HashSet<VisiblePoint> getVisiblePoints(Vector3D rayOrigin) {

		HashSet<VisiblePoint> result = new HashSet<>();

		for (Vector3D testPoint : vtps) {

			Vector3D rayDir = testPoint.subtract(rayOrigin);

			if (rayDir.getNorm() == 0) {
				continue;
			}

			rayDir = rayDir.normalize();

			// Otherwise, check for intersection with a primitive using the kdtree:
			RaySceneIntersection intersect = scene.getIntersection(rayOrigin, rayDir, false);

			// TODO 4: Try to get true incidence angle
			double incidenceAngle = (Math.PI / 4);

			double intersectDistance = Double.MAX_VALUE;

			if (intersect != null) {
				intersectDistance = rayOrigin.distance(intersect.point);
				incidenceAngle = intersect.prim.getIncidenceAngle_rad(rayOrigin, rayDir);
			}

			double testpointRayDistance = Vector3D.crossProduct(rayDir, testPoint.subtract(rayOrigin)).getNorm();

			if (testpointRayDistance < cfg_hitTolerance_m && rayOrigin.distance(testPoint) <= intersectDistance + cfg_hitTolerance_m) {

				VisiblePoint rsc = new VisiblePoint();
				rsc.angle = incidenceAngle;
				rsc.pos = testPoint;

				result.add(rsc);
			}
		}

		return result;
	}