SimplexDevelopment/Polarize
1
0
Fork 0
mirror of https://github.com/SimplexDevelopment/Polarize.git synced 2024-12-22 12:27:37 +00:00
Code Issues Packages Projects Releases Wiki Activity

Full Documentation

Browse Source 
Fully Documented
Also added option for adjacent and opposite sides of the triangle based on our finite point P(r,Theta) and/or P(r,Theta,Phi)
This commit is contained in:
Paul Reilly 2023-04-17 16:32:15 -05:00
parent 043fbfeeb6
commit 913832557e
12 changed files with 327 additions and 48 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
Commons/src/main/java/io/github/simplexdev/polarize/api/IQuaternion.java
View File

@ -90,11 +90,31 @@ public interface IQuaternion {
*/
double getMagnitude();
/**
* Returns the angular rotation of this quaternion.
*
* @return the angular rotation of this quaternion
*/
double getW();
/**
* Returns the x component of this quaternion.
*
* @return the x component of this quaternion
*/
double getX();
/**
* Returns the y component of this quaternion.
*
* @return the y component of this quaternion
*/
double getY();
/**
* Returns the z component of this quaternion.
*
* @return the z component of this quaternion
*/
double getZ();
}

3
Commons/src/main/java/io/github/simplexdev/polarize/api/IVector.java
View File

@ -109,10 +109,9 @@ public interface IVector {
* vectors. The distance is calculated from the X Y Z mods as
* sqrt(distanceSquared(vector));
*
* @see #distanceSquared(IVector)
*
* @param vector The vector to get the distance between.
* @return The distance between this vector and the vector passed in.
* @see #distanceSquared(IVector)
*/
double distance(@NotNull IVector vector);

3
Commons/src/main/java/io/github/simplexdev/polarize/api/units/Phi.java
View File

@ -12,8 +12,7 @@ package io.github.simplexdev.polarize.api.units;
* @see <a href="https://en.wikipedia.org/wiki/Azimuth">Azimuth</a>
*/
@FunctionalInterface
public interface Phi
{
public interface Phi {
/**
* This method returns a double value representing the azimuth.

3
Commons/src/main/java/io/github/simplexdev/polarize/api/units/Radius.java
View File

@ -12,8 +12,7 @@ package io.github.simplexdev.polarize.api.units;
* @see <a href="https://en.wikipedia.org/wiki/Radius">Radius</a>
*/
@FunctionalInterface
public interface Radius
{
public interface Radius {
/**
* This method returns a double value representing the length of the radius.
*

8
Commons/src/main/java/io/github/simplexdev/polarize/api/units/Theta.java
View File

@ -1,6 +1,14 @@
package io.github.simplexdev.polarize.api.units;
/**
* This is a functional interface representing a mathematical angle Theta, which returns the zenith value.
*/
@FunctionalInterface
public interface Theta {
/**
* This method returns a double value representing the zenith angle.
*
* @return the zenith angle as a double.
*/
double getZenith();
}

5
Commons/src/main/java/io/github/simplexdev/polarize/math/Quaternion.java
View File

@ -3,7 +3,10 @@ package io.github.simplexdev.polarize.math;
import io.github.simplexdev.polarize.api.IQuaternion;
public class Quaternion implements IQuaternion {
private double w, x, y, z;
private final double w;
private final double x;
private final double y;
private final double z;
public Quaternion(double w, double x, double y, double z) {
this.w = w;

36
Commons/src/main/java/io/github/simplexdev/polarize/polar/Delta.java
View File

@ -3,27 +3,63 @@ package io.github.simplexdev.polarize.polar;
import io.github.simplexdev.polarize.api.units.Phi;
import io.github.simplexdev.polarize.api.units.Theta;
/**
* Represents a modifier that can be used in rotations of polar and spherical units.
* <p>
* Typically, these are used in full rotations along the unit circle / unit sphere,
* but can be used in any degree of rotation.
*/
public class Delta {
private final Theta theta;
private final Phi phi;
/**
* Creates a new Delta with the given theta and phi modifiers.
*
* @param theta the theta modifier.
* @param phi the phi modifier.
*/
public Delta(double theta, double phi) {
this.theta = () -> theta;
this.phi = () -> phi;
}
/**
* Returns an object that represents the theta modifier.
*
* @return an object that represents the theta modifier.
* @see Theta
*/
public Theta getTheta() {
return theta;
}
/**
* Returns an object that represents the phi modifier.
*
* @return an object that represents the phi modifier.
* @see Phi
*/
public Phi getPhi() {
return phi;
}
/**
* Returns the theta modifier.
* This is a double value for easier access.
*
* @return the theta modifier.
*/
public double theta() {
return theta.getZenith();
}
/**
* Returns the phi modifier.
* This is a double value for easier access.
*
* @return the phi modifier.
*/
public double phi() {
return phi.getAzimuth();
}

59
Commons/src/main/java/io/github/simplexdev/polarize/polar/PolarUnit.java
View File

@ -3,28 +3,87 @@ package io.github.simplexdev.polarize.polar;
import io.github.simplexdev.polarize.api.units.Radius;
import io.github.simplexdev.polarize.api.units.Theta;
/**
* Represents a unit in polar coordinates.
*/
public class PolarUnit {
private final Radius radius;
private final Theta theta;
/**
* Creates a new PolarUnit with the given radius and angle theta.
*
* @param radius the radius of the unit.
* @param theta the angle theta of the unit.
*/
public PolarUnit(double radius, double theta) {
this.radius = () -> radius;
this.theta = () -> theta;
}
/**
* Returns the radius object of this unit.
* <p>
* This is an object which represents the variable r, which
* represents the radius of the unit circle in 2d space.
*
* @return the radius object of this unit.
*/
public Radius getRadius() {
return radius;
}
/**
* Returns the angle object theta of this unit.
* <p>
* This is an object which represents the variable theta, which
* represents an angle on the unit circle in 2d space.
*
* @return the angle object theta of this unit.
*/
public Theta getTheta() {
return theta;
}
/**
* Returns the radius of this unit.
* This is formatted as a double for quick access.
*
* @return the radius of this unit.
*/
public double radius() {
return radius.length();
}
/**
* Returns the angle theta of this unit.
* This is formatted as a double for quick access.
*
* @return the angle theta of this unit.
*/
public double theta() {
return theta.getZenith();
}
/**
* Returns the adjacent side of the triangle formed by this unit in 2d space.
* <p>
* The adjacent side is the side adjacent the angle theta.
*
* @return the adjacent side of the triangle formed by this unit in 2d space.
*/
public double adjacent() {
return radius() * Math.cos(theta());
}
/**
* Returns the opposite side of the triangle formed by this unit in 2d space.
* <p>
* The opposite side is the side opposite the angle theta.
*
* @return the opposite side of the triangle formed by this unit in 2d space.
*/
public double opposite() {
return radius() * Math.sin(theta());
}
}

83
Commons/src/main/java/io/github/simplexdev/polarize/polar/SphericalUnit.java
View File

@ -3,39 +3,122 @@ package io.github.simplexdev.polarize.polar;
import io.github.simplexdev.polarize.api.units.Phi;
import io.github.simplexdev.polarize.api.units.Radius;
import io.github.simplexdev.polarize.api.units.Theta;
import io.github.simplexdev.polarize.cartesian.CartesianUnit;
import io.github.simplexdev.polarize.util.Polarizer;
/**
* A class that represents a spherical unit.
*/
public class SphericalUnit {
private final Radius radius;
private final Theta theta;
private final Phi phi;
/**
* Creates a new SphericalUnit with the given radius, theta, and phi.
*
* @param radius The radius of the unit.
* @param theta The theta of the unit.
* @param phi The phi of the unit.
*/
public SphericalUnit(double radius, double theta, double phi) {
this.radius = () -> radius;
this.theta = () -> theta;
this.phi = () -> phi;
}
/**
* Returns the radius object of the unit.
* <p>
* This is an object which represents the variable r, which
* represents the radius of the unit sphere in 3d space.
*
* @return The radius object of the unit.
* @see Radius
*/
public Radius getRadius() {
return this.radius;
}
/**
* Returns the theta object of the unit.
* <p>
* This is an object which represents the variable theta, which
* represents the angle of the unit sphere in 3d space.
*
* @return The theta object of the unit.
* @see Theta
*/
public Theta getTheta() {
return this.theta;
}
/**
* Returns the phi object of the unit.
* <p>
* This is an object which represents the variable phi, which
* represents the angle of the unit sphere in 3d space.
*
* @return The phi object of the unit.
* @see Phi
*/
public Phi getPhi() {
return this.phi;
}
/**
* Returns the radius of the unit.
* This is formatted as a double for quick access.
*
* @return The radius of the unit.
*/
public double radius() {
return this.radius.length();
}
/**
* Returns the theta of the unit.
* This is formatted as a double for quick access.
*
* @return The theta of the unit.
*/
public double theta() {
return this.theta.getZenith();
}
/**
* Returns the phi of the unit.
* This is formatted as a double for quick access.
*
* @return The phi of the unit.
*/
public double phi() {
return this.phi.getAzimuth();
}
/**
* Returns the adjacent side of the unit.
* <p>
* This is calculated from a translation to Cartesian units,
* and returning the X value.
*
* @return The adjacent side of the unit.
*/
public double adjacent() {
CartesianUnit unit = Polarizer.toCartesianUnit(this);
return unit.getPoint3D().getX();
}
/**
* Returns the opposite side of the unit.
* <p>
* This is calculated from a translation to Cartesian units,
* and returning the Z value.
*
* @return The opposite side of the unit.
*/
public double opposite() {
CartesianUnit unit = Polarizer.toCartesianUnit(this);
return unit.getPoint3D().getZ();
}
}

42
Commons/src/main/java/io/github/simplexdev/polarize/util/Polarizer.java
View File

@ -14,8 +14,7 @@ import io.github.simplexdev.polarize.polar.SphericalUnit;
* This class provides static methods for converting between different polar coordinate systems and their Cartesian equivalents.
* It includes methods for converting to and from polar coordinates in 2D and 3D, as well as to and from spherical coordinates.
*/
public class Polarizer
{
public class Polarizer {
private Polarizer() {
throw new AssertionError();
}
@ -31,8 +30,7 @@ public class Polarizer
* @see <a href="https://en.wikipedia.org/wiki/Polar_coordinate_system">Polar coordinate system</a>
* @see <a href="https://en.wikipedia.org/wiki/Cartesian_coordinate_system">Cartesian coordinate system</a>
*/
public static CartesianUnit toCartesianUnit(PolarUnit unit)
{
public static CartesianUnit toCartesianUnit(PolarUnit unit) {
double x = unit.radius() * Math.sin(unit.theta());
double z = unit.radius() * Math.cos(unit.theta());
return new CartesianUnit(x, 0, z);
@ -50,8 +48,7 @@ public class Polarizer
* @see <a href="https://en.wikipedia.org/wiki/Spherical_coordinate_system">Spherical coordinate system</a>
* @see <a href="https://en.wikipedia.org/wiki/Cartesian_coordinate_system">Cartesian coordinate system</a>
*/
public static CartesianUnit toCartesianUnit(IScalar scalar, Theta theta)
{
public static CartesianUnit toCartesianUnit(IScalar scalar, Theta theta) {
double x = scalar.getMagnitude() * Math.sin(theta.getZenith());
double z = scalar.getMagnitude() * Math.cos(theta.getZenith());
return new CartesianUnit(x, 0, z);
@ -69,8 +66,7 @@ public class Polarizer
* @see <a href="https://en.wikipedia.org/wiki/Spherical_coordinate_system">Spherical coordinate system</a>
* @see <a href="https://en.wikipedia.org/wiki/Cartesian_coordinate_system">Cartesian coordinate system</a>
*/
public static CartesianUnit toCartesianUnit(double radius, double theta)
{
public static CartesianUnit toCartesianUnit(double radius, double theta) {
double x = radius * Math.sin(theta);
double z = radius * Math.cos(theta);
return new CartesianUnit(x, 0, z);
@ -87,8 +83,7 @@ public class Polarizer
* @see <a href="https://en.wikipedia.org/wiki/Spherical_coordinate_system">Spherical coordinate system</a>
* @see <a href="https://en.wikipedia.org/wiki/Cartesian_coordinate_system">Cartesian coordinate system</a>
*/
public static CartesianUnit toCartesianUnit(SphericalUnit unit)
{
public static CartesianUnit toCartesianUnit(SphericalUnit unit) {
double x = unit.radius() * Math.sin(unit.theta()) * Math.cos(unit.phi());
double y = unit.radius() * Math.cos(unit.theta());
double z = unit.radius() * Math.sin(unit.theta()) * Math.sin(unit.phi());
@ -103,8 +98,7 @@ public class Polarizer
* @param phi the phi coordinate of the vector
* @return the CartesianUnit representation of the vector
*/
public static CartesianUnit toCartesianUnit(IScalar scalar, Theta theta, Phi phi)
{
public static CartesianUnit toCartesianUnit(IScalar scalar, Theta theta, Phi phi) {
double x = scalar.getMagnitude() * Math.sin(theta.getZenith()) * Math.cos(phi.getAzimuth());
double y = scalar.getMagnitude() * Math.cos(theta.getZenith());
double z = scalar.getMagnitude() * Math.sin(theta.getZenith()) * Math.sin(phi.getAzimuth());
@ -119,8 +113,7 @@ public class Polarizer
* @param phi the phi angle in radians of the spherical coordinate
* @return the corresponding CartesianUnit
*/
public static CartesianUnit toCartesianUnit(double radius, double theta, double phi)
{
public static CartesianUnit toCartesianUnit(double radius, double theta, double phi) {
double x = radius * Math.sin(theta) * Math.cos(phi);
double y = radius * Math.cos(theta);
double z = radius * Math.sin(theta) * Math.sin(phi);
@ -133,8 +126,7 @@ public class Polarizer
* @param unit the CartesianUnit to be converted
* @return a PolarUnit representing the same point as the input CartesianUnit
*/
public static PolarUnit toPolarUnit(CartesianUnit unit)
{
public static PolarUnit toPolarUnit(CartesianUnit unit) {
double radius = Math.sqrt(
unit.getPoint2D().getX() * unit.getPoint2D().getX()
+ unit.getPoint2D().getZ() * unit.getPoint2D().getZ());
@ -150,8 +142,7 @@ public class Polarizer
* @param vector the {@link IVector} representing the radius of the resulting {@link PolarUnit}
* @return a {@link PolarUnit} representing the same point as the given {@link CartesianUnit}
*/
public static PolarUnit toPolarUnit(CartesianUnit unit, IVector vector)
{
public static PolarUnit toPolarUnit(CartesianUnit unit, IVector vector) {
double radius = vector.length();
double theta = Math.atan2(unit.getPoint2D().getX(), unit.getPoint2D().getZ());
return new PolarUnit(radius, theta);
@ -164,8 +155,7 @@ public class Polarizer
* @param vector the vector used as a reference for the polar coordinates
* @return a PolarUnit representing the polar coordinates of the given point
*/
public static PolarUnit toPolarUnit(IPoint2D point, IVector vector)
{
public static PolarUnit toPolarUnit(IPoint2D point, IVector vector) {
double radius = vector.length();
double theta = Math.atan2(point.getX(), point.getZ());
return new PolarUnit(radius, theta);
@ -178,8 +168,7 @@ public class Polarizer
* @param z the z-coordinate of the point
* @return a {@code PolarUnit} representing the polar coordinates of the point
*/
public static PolarUnit toPolarUnit(double x, double z)
{
public static PolarUnit toPolarUnit(double x, double z) {
double radius = Math.sqrt(x * x + z * z);
double theta = Math.atan2(x, z);
return new PolarUnit(radius, theta);
@ -191,8 +180,7 @@ public class Polarizer
* @param unit the CartesianUnit to be converted.
* @return the SphericalUnit representing the same point as the input CartesianUnit.
*/
public static SphericalUnit toSphericalUnit(CartesianUnit unit)
{
public static SphericalUnit toSphericalUnit(CartesianUnit unit) {
double radius = Math.sqrt(
unit.getPoint3D().getX() * unit.getPoint3D().getX()
+ unit.getPoint3D().getY() * unit.getPoint3D().getY()
@ -209,8 +197,7 @@ public class Polarizer
* @param vector the vector to use for the conversion
* @return a new {@link SphericalUnit} representing the point in spherical coordinates
*/
public static SphericalUnit toSphericalUnit(IPoint3D point, IVector vector)
{
public static SphericalUnit toSphericalUnit(IPoint3D point, IVector vector) {
double radius = vector.length();
double theta = Math.acos(point.getY() / radius);
double phi = Math.atan2(point.getX(), point.getZ());
@ -225,8 +212,7 @@ public class Polarizer
* @param z the z-coordinate
* @return a new {@code SphericalUnit} representing the converted spherical coordinates
*/
public static SphericalUnit toSphericalUnit(double x, double y, double z)
{
public static SphericalUnit toSphericalUnit(double x, double y, double z) {
double radius = Math.sqrt(x * x + y * y + z * z);
double theta = Math.acos(y / radius);
double phi = Math.atan2(x, z);

95
Commons/src/main/java/io/github/simplexdev/polarize/util/Rotator.java
View File

@ -7,13 +7,33 @@ import io.github.simplexdev.polarize.math.Point2D;
import io.github.simplexdev.polarize.math.Point3D;
import io.github.simplexdev.polarize.math.Quaternion;
import io.github.simplexdev.polarize.polar.Delta;
import io.github.simplexdev.polarize.polar.PolarUnit;
import io.github.simplexdev.polarize.polar.SphericalUnit;
/**
* A utility class for rotating points in 2d and 3d space.
* This class supports rotations for Cartesian, Spherical, and Polar coordinates.
* <p>
* Typically, rotations in polar / spherical units are done with delta values.
* The rotations in Cartesian units are done with a quaternion.
*/
public class Rotator {
/**
* This class should not be instantiated.
*/
private Rotator() {
throw new AssertionError();
}
/**
* Rotates a point in 3d space using spherical units.
* The returned result is a point in 3d space represented by {@link IPoint3D}.
* This will rotate the point around the x-axis.
*
* @param point the point to rotate.
* @param unit the spherical unit to rotate the point with.
* @return the rotated point.
*/
public static IPoint3D rotateX(IPoint3D point, SphericalUnit unit) {
double x = point.getX();
double y = point.getY() * Math.cos(unit.theta()) - point.getZ() * Math.sin(unit.theta());
@ -22,6 +42,15 @@ public class Rotator {
return new Point3D(x, y, z);
}
/**
* Rotates a point in 3d space using spherical units.
* The returned result is a point in 3d space represented by {@link IPoint3D}.
* This will rotate the point around the y-axis.
*
* @param point the point to rotate.
* @param unit the spherical unit to rotate the point with.
* @return the rotated point.
*/
public static IPoint3D rotateY(IPoint3D point, SphericalUnit unit) {
double x = point.getX() * Math.cos(unit.phi()) - point.getZ() * Math.sin(unit.phi());
double y = point.getY();
@ -30,6 +59,15 @@ public class Rotator {
return new Point3D(x, y, z);
}
/**
* Rotates a point in 3d space using spherical units.
* The returned result is a point in 3d space represented by {@link IPoint3D}.
* This will rotate the point around the z-axis.
*
* @param point the point to rotate.
* @param unit the spherical unit to rotate the point with.
* @return the rotated point.
*/
public static IPoint3D rotateZ(IPoint3D point, SphericalUnit unit) {
double x = point.getX() * Math.cos(unit.theta()) - point.getY() * Math.sin(unit.theta());
double y = point.getX() * Math.sin(unit.theta()) + point.getY() * Math.cos(unit.theta());
@ -38,6 +76,16 @@ public class Rotator {
return new Point3D(x, y, z);
}
/**
* Rotates a point in 3d space using spherical units.
* The returned result is a point in 3d space represented by {@link IPoint3D}.
* This will rotate the point around the x-axis, y-axis, and z-axis.
*
* @param point the point to rotate.
* @param delta the delta values to rotate the point with.
* @param unit the spherical unit to rotate the point with.
* @return the rotated point.
*/
public static IPoint3D fullRotation(IPoint3D point, Delta delta, SphericalUnit unit) {
double r = unit.radius() * Math.cos(unit.theta() + delta.theta()) * Math.cos(unit.phi() + delta.phi());
double theta = Math.atan2(point.getX(), point.getZ()) + delta.theta();
@ -50,24 +98,59 @@ public class Rotator {
return new Point3D(xRot, yRot, zRot);
}
public static IPoint2D rotateX(IPoint2D point, SphericalUnit unit) {
/**
* Rotates a point in 2d space using spherical units.
* The returned result is a point in 2d space represented by {@link IPoint2D}.
* This will rotate the point around the x-axis.
*
* @param point the point to rotate.
* @param unit the polar unit to rotate the point with.
* @return the rotated point.
*/
public static IPoint2D rotateX(IPoint2D point, PolarUnit unit) {
double x = point.getZ() * Math.cos(unit.theta()) - point.getX() * Math.sin(unit.theta());
double z = point.getZ() * Math.sin(unit.theta()) + point.getX() * Math.cos(unit.theta());
return new Point2D(x, z);
}
public static IPoint2D rotateZ(IPoint2D point, SphericalUnit unit) {
/**
* Rotates a point in 2d space using spherical units.
* The returned result is a point in 2d space represented by {@link IPoint2D}.
* This will rotate the point around the y-axis.
*
* @param point the point to rotate.
* @param unit the polar unit to rotate the point with.
* @return the rotated point.
*/
public static IPoint2D rotateZ(IPoint2D point, PolarUnit unit) {
double x = point.getX() * Math.cos(unit.theta()) - point.getZ() * Math.sin(unit.theta());
double z = point.getX() * Math.sin(unit.theta()) + point.getZ() * Math.cos(unit.theta());
return new Point2D(x, z);
}
/**
* Rotates a point in 2d space using spherical units.
* The returned result is a point in 2d space represented by {@link IPoint2D}.
* This will rotate the point around the x-axis and z-axis.
*
* @param point the point to rotate.
* @param unit the polar unit to rotate the point with.
* @return the rotated point.
*/
public static IPoint2D fullRotation(IPoint2D point, SphericalUnit unit) {
double x = point.getX() * Math.cos(unit.theta()) - point.getZ() * Math.sin(unit.theta());
double z = point.getX() * Math.sin(unit.theta()) + point.getZ() * Math.cos(unit.theta());
return new Point2D(x, z);
}
/**
* Rotates a point in 3d space using a quaternion.
* The returned result is a point in 3d space represented by {@link IPoint3D}.
*
* @param point the point to rotate.
* @param quaternion the quaternion to rotate the point with.
* @return the rotated point.
*/
public static IPoint3D rotate(IPoint3D point, IQuaternion quaternion) {
IQuaternion pQuat = new Quaternion(0.0, point.getX(), point.getY(), point.getZ());
@ -78,6 +161,14 @@ public class Rotator {
return new Point3D(w.getX(), w.getY(), w.getZ());
}
/**
* Rotates a point in 2d space using a quaternion.
* The returned result is a point in 2d space represented by {@link IPoint2D}.
*
* @param point the point to rotate.
* @param quaternion the quaternion to rotate the point with.
* @return the rotated point.
*/
public static IPoint2D rotate(IPoint2D point, IQuaternion quaternion) {
IQuaternion pQuat = new Quaternion(0.0, point.getX(), 0.0, point.getZ());

16
Commons/src/main/java/io/github/simplexdev/polarize/util/Utilities.java
View File

@ -1,11 +1,6 @@
package io.github.simplexdev.polarize.util;
public class Utilities
{
private Utilities() {
throw new AssertionError();
}
public class Utilities {
/**
* The value of pi divided by 4.
* This represents 45 degrees in radians.
@ -31,6 +26,9 @@ public class Utilities
* This represents 360 degrees in radians.
*/
public static final double RADIAN_360 = Math.PI * 2;
private Utilities() {
throw new AssertionError();
}
/**
* Calculates the magnitude of a vector in 2D Cartesian coordinate system.
@ -39,8 +37,7 @@ public class Utilities
* @param z the z-coordinate of the vector
* @return the magnitude of the vector
*/
public static double magnitudeOf(double x, double z)
{
public static double magnitudeOf(double x, double z) {
return Math.sqrt(x * x + z * z);
}
@ -52,8 +49,7 @@ public class Utilities
* @param z the z-coordinate of the vector
* @return the magnitude of the vector
*/
public static double magnitudeOf(double x, double y, double z)
{
public static double magnitudeOf(double x, double y, double z) {
return Math.sqrt(x * x + y * y + z * z);
}
}