package mikera.transformz;
import mikera.matrixx.AMatrix;
import mikera.matrixx.Matrix22;
import mikera.matrixx.Matrix33;
import mikera.matrixx.Matrixx;
import mikera.matrixx.impl.ZeroMatrix;
import mikera.transformz.impl.ConstantTransform;
import mikera.transformz.impl.ConstantTransform3;
import mikera.transformz.impl.ConstantTransform4;
import mikera.transformz.impl.IdentityTranslation;
import mikera.vectorz.AVector;
import mikera.vectorz.Vector3;
/**
* Class containing static utility methods for vector transformations.
*
* @author Mike
*
*/
public class Transformz {
/**
* Creates a 3D scaling transform
*/
public static Matrix33 scale3D(double factor) {
return Matrix33.createScaleMatrix(factor);
}
/**
* Creates a 2D scaling transform
*/
public static Matrix22 scale2D(double factor) {
return Matrix22.createScaleMatrix(factor);
}
/**
* Creates a 2D rotation transform
*/
public static Matrix22 rotate2D(double radians) {
return Matrix22.createRotationMatrix(radians);
}
/**
* Creates an n-dimensional scaling transform
*/
public static AMatrix scale(int dimensions, double factor) {
return Matrixx.createScaleMatrix(dimensions,factor);
}
/**
* Creates an identity translation with the given number of dimensions
*/
public static IdentityTranslation identityTranslation(int dimensions) {
return IdentityTranslation.create(dimensions);
}
/**
* Creates an identity transform with the given number of dimensions
*/
public static ATransform identityTransform(int dimensions) {
return IdentityTranslation.create(dimensions);
}
/**
* Coerce to a transform:
* - vectors translate into constant transforms.
* @param o
* @return
*/
public ATransform toTransform(Object o) {
if (o instanceof ATransform) {
return (ATransform)o;
} else if (o instanceof AVector) {
AVector v=(AVector)o;
return constantTransform(v.length(),v);
}
throw new UnsupportedOperationException("Don't know to to convert to transform: "+o.getClass());
}
/**
* Creates a zero transform (maps every vector to zero)
*/
public static AMatrix zeroTransform(int inputDimensions, int outputDimensions) {
return ZeroMatrix.create(outputDimensions,inputDimensions);
}
public static ATranslation createTranslation(AVector v) {
if (v.length()==3) {
return new Translation3(v);
}
return new Translation(v);
}
public static Translation3 createTranslation(Vector3 v) {
return new Translation3(v);
}
public static Affine34 createAffineTransform(Matrix33 m, AVector v) {
assert(v.length()==3);
return new Affine34(m,v);
}
public static Affine34 createAffineTransform(Matrix33 m, Vector3 v) {
return new Affine34(m,v);
}
public static ATranslation createMutableTranslation(ATranslation t) {
if (t.dimensions()==3) {
// fast path for 3D translation
return new Translation3(t);
}
return new Translation(t);
}
public static AAffineTransform createAffineTransform(AMatrix m, AVector v) {
if (m instanceof Matrix33) {
return createAffineTransform((Matrix33)m,v);
}
return new AffineMN(m,v);
}
public static ATransform constantTransform(int inputDimensions, AVector v) {
int dims=v.length();
switch (dims) {
case 3: return new ConstantTransform3(inputDimensions,v);
case 4: return new ConstantTransform4(inputDimensions,v);
default: return new ConstantTransform(inputDimensions,v);
}
}
public static ATranslation createTranslation(double[] v) {
int dims=v.length;
if (dims==3) {
return new Translation3(v[0],v[1],v[2]);
}
return new Translation(v);
}
}