/// <summary>
/// TODO
/// </summary>
/// <param name="boxCenter"></param>
/// <returns></returns>
private bool FixMatrix(Point3d boxCenter)
{
var flag = false;
if (AsymmetryVector.Z.IsLessThanTol() &&
(AsymmetryVector.X + AsymmetryVector.Y > 0 ||
(AsymmetryVector.X + AsymmetryVector.Y).IsLessThanTol() &&
AsymmetryVector.X > 0))
{
var matrix3D = Matrix3d.Rotation(3.14159265358979, new Vector3d(0, 1, 0), boxCenter);
LayMatrix = matrix3D * LayMatrix;
AsymmetryVector = AsymmetryVector.TransformBy(matrix3D);
flag = true;
}
if (AsymmetryVector.Y.IsLessThanTol())
{
if (!AsymmetryVector.X.IsLessThanTol() && AsymmetryVector.X > 0)
{
var matrix3D1 = Matrix3d.Rotation(3.14159265358979, new Vector3d(0, 0, 1), boxCenter);
LayMatrix = matrix3D1 * LayMatrix;
AsymmetryVector = AsymmetryVector.TransformBy(matrix3D1);
flag = true;
}
}
else if (AsymmetryVector.Y > 0)
{
var matrix3D2 = Matrix3d.Rotation(3.14159265358979, new Vector3d(0, 0, 1), boxCenter);
LayMatrix = matrix3D2 * LayMatrix;
AsymmetryVector = AsymmetryVector.TransformBy(matrix3D2);
flag = true;
}
return(flag);
}
/// <summary>
/// TODO
/// </summary>
/// <param name="compEnt"></param>
/// <returns></returns>
public bool Equals(EntInfo compEnt)
{
if (!IsEqualSize(compEnt))
{
return(false);
}
if (Asymmetry != 0.0 || compEnt.Asymmetry != 0.0)
{
return(Asymmetry.IsEqualSize(compEnt.Asymmetry) &&
AsymmetryVector.IsEqualTo(compEnt.AsymmetryVector, CalcTol.UnitVector) &&
Math.Sign(AsymmetryVector.X) == Math.Sign(compEnt.AsymmetryVector.X) &&
Math.Sign(AsymmetryVector.Y) == Math.Sign(compEnt.AsymmetryVector.Y) &&
Math.Sign(AsymmetryVector.Z) == Math.Sign(compEnt.AsymmetryVector.Z));
}
return(true);
}
/// <summary>
/// TODO
/// </summary>
/// <param name="mirCheck"></param>
/// <returns></returns>
public bool IsMirrorOf(EntInfo y)
{
if (Asymmetry == 0 || y.Asymmetry == 0)
{
return(false);
}
if (AsymmetryVector.IsEqualTo(y.AsymmetryVector, CalcTol.UnitVector))
{
if (!AsymmetryVector.X.IsEqualTo(y.AsymmetryVector.X))
{
return(true);
}
if (!AsymmetryVector.Y.IsEqualTo(y.AsymmetryVector.Y))
{
return(true);
}
if (!AsymmetryVector.Z.IsEqualTo(y.AsymmetryVector.Z))
{
return(true);
}
return(false);
}
if (!AsymmetryVector.X.IsEqualTo(y.AsymmetryVector.X))
{
return(true);
}
if (!AsymmetryVector.Y.IsEqualTo(y.AsymmetryVector.Y))
{
return(true);
}
if (!AsymmetryVector.Z.IsEqualTo(y.AsymmetryVector.Z))
{
return(true);
}
return(false);
}
/// <summary>
/// TODO
/// </summary>
/// <param name="acSol"></param>
private void ReadEntity(Solid3d acSol, Database acCurDb, Transaction acTrans)
{
RcName = acSol.GetPartName();
ParentHandle = acSol.GetParent();
ChildHandles = acSol.GetChildren();
IsSweep = acSol.GetIsSweep();
IsMirror = acSol.GetIsMirror();
RcInfo = acSol.GetPartInfo();
RcQtyOf = acSol.GetQtyOf();
RcQtyTotal = acSol.GetQtyTotal();
TxDirection = acSol.GetTextureDirection();
GetRotationMatrices(acSol);
GetLayMatrix(acSol);
if (LayMatrix == new Matrix3d())
{
LayMatrix = GetAbstractMatrix(acSol);
}
using (var solCopy = acSol.Clone() as Solid3d)
{
if (solCopy != null)
{
if (LayMatrix != Matrix3d.Identity)
{
solCopy.TransformBy(LayMatrix);
}
//Get Volume & Extents
Extents = solCopy.GetBounds();
MinExt = Extents.MinPoint;
MaxExt = Extents.MaxPoint;
Centroid = solCopy.MassProperties.Centroid;
Box = Extents.Volume();
Volume = acSol.Volume();
}
}
var identity = Matrix3d.Identity;
if ((MaxExt.Z + MinExt.Z) / 2 < 0)
{
var vector3D = new Vector3d(0, 1, 0);
identity = Matrix3d.Rotation(3.14159265358979, vector3D, new Point3d());
LayMatrix *= identity;
}
if (IsBox)
{
Asymmetry = 0;
}
else
{
var boxCen = GetBoxCenter(MinExt, MaxExt).RoundToTolerance();
AsymmetryVector = boxCen.GetVectorTo(Centroid.RoundToTolerance());
AsymmetryVector = AsymmetryVector.TransformBy(identity);
Asymmetry = AsymmetryVector.Length;
if (!Asymmetry.IsLessThanTol())
{
Asymmetry = Asymmetry.RoundToTolerance();
}
else
{
Asymmetry = 0;
}
AsymmetryVector = AsymmetryVector.RoundToTolerance();
if (Asymmetry > 0)
{
FixMatrix(boxCen);
}
AsymString = AsymVStr(AsymmetryVector);
}
//Get length, width, thickness
if (IsSweep)
{
//TODO
}
else
{
var measures = new List <double>(3)
{
MaxExt.X - MinExt.X,
MaxExt.Y - MinExt.Y,
MaxExt.Z - MinExt.Z
};
measures.Sort();
if (TxDirection == TextureDirection.Across)
{
Width = measures[2].RoundToTolerance();
Length = measures[1].RoundToTolerance();
}
else
{
Length = measures[2].RoundToTolerance();
Width = measures[1].RoundToTolerance();
}
Thickness = measures[0].RoundToTolerance();
}
//Add the XData
acSol.AddXData(this, acCurDb, acTrans);
}
/// <summary>
/// TODO
/// </summary>
/// <returns></returns>
public override int GetHashCode()
{
return(Length.GetHashCode() + Width.GetHashCode() + Thickness.GetHashCode() +
Volume.GetHashCode() + Asymmetry.GetHashCode() +
(Asymmetry == 0.0 ? 0 : AsymmetryVector.GetHashCode()));
}
