public TransformationMaxtrix InverseTransformationMatrix(TransformationMaxtrix transform)
{
var swTransform = m_MathUtils.CreateTransFormTransformationMaxtrix(transform);
swTransform = swTransform.IInverse();
return(swTransform.ToTransformationMaxtrix());
}
private void TestDisplayOnBody(TransformationMaxtrix transform, string fileName, string bodyName,
IEnumerable <Point> points = null)
{
Sw.App.WithDocument <object>(fileName,
m =>
{
var body = Sw.Doc.GetBodyByName(m as IPartDoc, bodyName);
var mathTx = (Sw.SldWorks.IGetMathUtility() as IMathUtility).CreateTransFormTransformationMaxtrix(transform);
var tempBody = body.ICopy();
tempBody.ApplyTransform(mathTx as MathTransform);
ManualDisposeToken pointsDispToken = null;
if (points != null)
{
pointsDispToken = Sw.Doc.TempDisplayPoints(m, points.Select(p => p.ToArray()));
}
Sw.Doc.TempDisplayBody(tempBody, m, new SyncFormDisposeToken());
if (pointsDispToken != null)
{
pointsDispToken.Dispose();
}
return(null);
});
}
public Point TransformPoint(Point point, TransformationMaxtrix transform)
{
IMathPoint mathPt = m_MathUtils.CreatePoint(point.ToArray()) as IMathPoint;
var swTransform = m_MathUtils.CreateTransFormTransformationMaxtrix(transform);
mathPt = mathPt.MultiplyTransform(swTransform) as IMathPoint;
return(new Point(mathPt.ArrayData as double[]));
}
public Vector TransformVector(Vector vector, TransformationMaxtrix transform)
{
IMathVector vec = m_MathUtils.CreateVector(vector.ToArray()) as IMathVector;
var swTransform = m_MathUtils.CreateTransFormTransformationMaxtrix(transform);
vec = vec.MultiplyTransform(swTransform) as IMathVector;
return(new Vector(vec.ArrayData as double[]));
}
private double GetHeight(IGeometry geom, Vector dir, TransformationMaxtrix alignTransform,
out Vector newDir, out Point rootPt)
{
Point endPt;
dir = GetExtremePointsAligned(geom, dir, alignTransform, out rootPt, out endPt);
double height = Math.Abs(endPt.Y - rootPt.Y);
//direction might change depending on root point so recalculating the direction to be towards geometry
newDir = new Vector(0, endPt.Y - rootPt.Y, 0);
return(height);
}
public static IMathTransform CreateTransFormTransformationMaxtrix(
this IMathUtility mathUtils, TransformationMaxtrix transform)
{
var arrData = new double[]
{
transform.Rotation.M11, transform.Rotation.M12, transform.Rotation.M13,
transform.Rotation.M21, transform.Rotation.M22, transform.Rotation.M23,
transform.Rotation.M31, transform.Rotation.M32, transform.Rotation.M33,
transform.Translation.X, transform.Translation.Y, transform.Translation.Z,
transform.Scale,
0, 0, 0
};
return(mathUtils.CreateTransform(arrData) as IMathTransform);
}
private Vector GetExtremePointsAligned(IGeometry geom, Vector dir,
TransformationMaxtrix alignTransform, out Point rootPt, out Point endPt)
{
if (alignTransform != null)
{
dir = m_VecMathServ.TransformVector(dir, alignTransform);
}
geom.GetExtremePoints(dir, out rootPt, out endPt);
if (alignTransform != null)
{
rootPt = m_VecMathServ.TransformPoint(rootPt, alignTransform);
endPt = m_VecMathServ.TransformPoint(endPt, alignTransform);
}
return(dir);
}
public CylinderParams GetStockParameters(IGeometry geom, Vector heightDirection)
{
var yAxis = m_DefaultVectors[VectorType_e.Y];
bool isAligned = yAxis.IsSame(heightDirection);
TransformationMaxtrix alignTransform = null;
if (!isAligned)
{
var origin = new Point(0, 0, 0);
alignTransform = m_VecMathServ.GetTransformBetweenVectorsAroundPoint(
heightDirection, yAxis, origin);
}
Vector dir;
Point rootPt;
var height = GetHeight(geom, yAxis, alignTransform, out dir, out rootPt);
Debug.Assert(height != 0);
var perPoints = GetPerimeterPoints(geom, alignTransform).ConvertAll(p => new Nayuki.Point(p.X, p.Z));
var enclosingCirc = Nayuki.SmallestEnclosingCircle.MakeCircle(perPoints);
var circCenter = new Point(enclosingCirc.c.x, rootPt.Y, enclosingCirc.c.y);
if (!isAligned)
{
var inversedAlignTransform = m_VecMathServ.InverseTransformationMatrix(alignTransform);
circCenter = m_VecMathServ.TransformPoint(circCenter, inversedAlignTransform);
dir = m_VecMathServ.TransformVector(dir, inversedAlignTransform);
}
double radius = enclosingCirc.r;
return(new CylinderParams(height, circCenter, dir, radius));
}
private List <Point> GetPerimeterPoints(IGeometry geom, TransformationMaxtrix alignTransform)
{
var perPoints = new List <Point>();
var vectors = new Vector[]
{
m_DefaultVectors[VectorType_e.X],
m_DefaultVectors[VectorType_e.Y],
m_DefaultVectors[VectorType_e.Z]
};
foreach (var vec in vectors)
{
Point startPt;
Point endPt;
GetExtremePointsAligned(geom, vec, alignTransform, out startPt, out endPt);
perPoints.Add(startPt);
perPoints.Add(endPt);
}
return(perPoints);
}
public void TestTransformPoint()
{
var comp = new DoubleEqualityComparerWithTolerance();
var mathServ = new SwVectorMathService(Sw.SldWorks.IGetMathUtility());
var transform = new TransformationMaxtrix(
new RotationMatrix(-0.356591604687574, -0.860646213105648, -0.363497624934811,
0.860646213105648, -0.45399049973947, 0.230609457770521,
-0.363497624934811, -0.230609457770521, 0.902601104948104), new Vector(0, 0, 0), 1);
var pts = new Point[6];
pts[0] = new Point(-0.110883845818614, 0.0605238203210351, -0.0239825852813666);
pts[1] = new Point(-0.0412497473005035, 0.179859854385059, 0.0275862063054218);
pts[2] = new Point(-0.142959784835457, 0.106453187928056, 0.00530736214458289);
pts[3] = new Point(-0.0405325336202925, 0.171216718860278, 0.0419248817887173);
pts[4] = new Point(-0.13321429487189, 0.0821558975737544, 0.0167696845654225);
pts[5] = new Point(-0.0104076774276791, 0.149982352301203, -0.0286994667274928);
var ptsTransf = new Point[6];
for (int i = 0; i < pts.Length; i++)
{
ptsTransf[i] = mathServ.TransformPoint(pts[i], transform);
}
//TestDisplayOnBody(transform, "Data\\t2.sldprt", "Body-Move/Copy2", ptsTransf);
Assert.IsTrue(ptsTransf[0].ToArray().SequenceEqual(new double[] { 0.100347458065948, 0.0734851335523633, 0.0326166720106647 }, comp));
Assert.IsTrue(ptsTransf[1].ToArray().SequenceEqual(new double[] { 0.159477495676095, -0.0525148664476371, 0.0813709089599175 }, comp));
Assert.IsTrue(ptsTransf[2].ToArray().SequenceEqual(new double[] { 0.140667578609346, 0.0734851335523624, 0.0813050851309728 }, comp));
Assert.IsTrue(ptsTransf[3].ToArray().SequenceEqual(new double[] { 0.146570986957314, -0.0525148664476372, 0.092059119028498 }, comp));
Assert.IsTrue(ptsTransf[4].ToArray().SequenceEqual(new double[] { 0.112114520796401, 0.073485133552363, 0.082505342603813 }, comp));
Assert.IsTrue(ptsTransf[5].ToArray().SequenceEqual(new double[] { 0.143225221928054, -0.0525148664476371, 0.0124663445857203 }, comp));
}
