public static Snap.Orientation GetStandardOrientation(Snap.Orientation ori)
{
var result = ori;
if (!IsUseOrientation(ori))
{
var vectors = new List <Snap.Vector>();
var identiry = Snap.Orientation.Identity;
vectors.Add(identiry.AxisX);
vectors.Add(identiry.AxisY);
vectors.Add(identiry.AxisZ);
vectors.Add(-identiry.AxisX);
vectors.Add(-identiry.AxisY);
vectors.Add(-identiry.AxisZ);
var axisXs = vectors.Where(u => SnapEx.Helper.Equals(u, ori.AxisX)).ToList();
var axisYs = vectors.Where(u => SnapEx.Helper.Equals(u, ori.AxisY)).ToList();
var axisZs = vectors.Where(u => SnapEx.Helper.Equals(u, ori.AxisZ)).ToList();
if (axisXs.Count > 0 && axisYs.Count > 0 && axisZs.Count > 0)
{
result = new Snap.Orientation(axisXs.First(), axisYs.First(), axisZs.First());
}
}
return(result);
}
public override Snap.NX.Face GetChamferFace()
{
if (ChamferFace != null)
{
return(ChamferFace);
}
Snap.NX.Face result = null;
var results = new List <Snap.NX.Face>();
if (BaseFace != null)
{
var baseFOriention = new Snap.Orientation(BaseFace.GetFaceDirection());
var v1 = Snap.Vector.Unit(baseFOriention.AxisX);
var v2 = Snap.Vector.Unit(baseFOriention.AxisY);
var v3 = Snap.Vector.Unit(v1 + v2);
var v4 = v3.Copy(Snap.Geom.Transform.CreateRotation(new Snap.Position(), BaseFace.GetFaceDirection(), 90)).Unitize();
var chamferFaces = ElecBody.Faces.Where(u => u.ObjectSubType == Snap.NX.ObjectTypes.SubType.FacePlane && Snap.Compute.Distance(u, BaseFace) < SnapEx.Helper.Tolerance).ToList();
chamferFaces.ForEach(u =>
{
var faceDir = u.GetFaceDirection();
if (SnapEx.Helper.Equals(v3, faceDir, SnapEx.Helper.Tolerance) ||
SnapEx.Helper.Equals(-v3, faceDir, SnapEx.Helper.Tolerance) ||
SnapEx.Helper.Equals(-v4, faceDir, SnapEx.Helper.Tolerance) ||
SnapEx.Helper.Equals(v4, faceDir, SnapEx.Helper.Tolerance)
)
{
results.Add(u);
}
});
}
result = results.FirstOrDefault();
if (results.Count > 1)
{
var baseFaceBoxUV = BaseFace.BoxUV;
var elecBasePos = BaseFace.Position((baseFaceBoxUV.MinU + baseFaceBoxUV.MaxU) / 2, (baseFaceBoxUV.MinV + baseFaceBoxUV.MaxV) / 2);
var faceDirection = BaseFace.GetFaceDirection();
var plane = new Snap.Geom.Surface.Plane(elecBasePos, faceDirection);
foreach (var u in results)
{
var uv = u.BoxUV;
var cneterPoint = u.Position((uv.MaxU + uv.MinU) / 2, (uv.MaxV + uv.MaxV) / 2);
var resullt = Snap.Compute.ClosestPoints(cneterPoint, plane);
var dir = Snap.Vector.Unit(resullt.Point1 - resullt.Point2);
if (SnapEx.Helper.Equals(dir, -faceDirection) && Snap.Compute.Distance(BaseFace, u) < SnapEx.Helper.Tolerance)
{
result = u;
break;
}
}
}
ChamferFace = result;
return(result);
}
/// <summary>
/// 实际尺寸
/// </summary>
public string GetElecSize(Snap.Orientation ori)
{
var elecBox = _body.AcsToWcsBox3d(ori);
return(string.Format("{0}x{1}x{2}",
Math.Round(Math.Abs(elecBox.MaxX - elecBox.MinX), 4)
, Math.Round(Math.Abs(elecBox.MaxY - elecBox.MinY), 4)
, Math.Round(Math.Abs(elecBox.MaxZ - elecBox.MinZ), 4)
));
}
public static Snap.Geom.Transform GetElecTransWcsToAcs(Snap.Vector baseDir, Snap.Orientation wcs)
{
var wcsOrientation = GetStandardOrientation(wcs);
var acsOrientation = Snap.Orientation.Identity;
var transR = Snap.Geom.Transform.CreateRotation(acsOrientation, wcsOrientation);
var baseFaceOrientation = new Snap.Orientation(-baseDir.Copy(transR));
baseFaceOrientation = GetSidelongOrientation(baseFaceOrientation);
transR = Snap.Geom.Transform.Composition(transR, Snap.Geom.Transform.CreateRotation(acsOrientation, baseFaceOrientation));
return(transR);
}
/// <summary>
/// 获取象限类型
/// </summary>
public QuadrantType GetQuadrantType(Snap.Orientation wcs, QuadrantType defaultQ = QuadrantType.First)
{
var result = defaultQ;
var chamferFace = GetChamferFace();
if (chamferFace != null && BaseFace != null)
{
var dir = chamferFace.GetFaceDirection().Copy(GetElecTransWcsToAcs(BaseFace.GetFaceDirection(), wcs));
result = SnapEx.Helper.GetQuadrantType(dir);
}
return(result);
}
public static void WriteLine(Snap.Orientation myOrientation)
{
Vector axisX = myOrientation.AxisX;
Vector axisY = myOrientation.AxisY;
Vector axisZ = myOrientation.AxisZ;
Write("AxisX = ( " + Snap.Number.ToString(axisX.X) + ", " + Snap.Number.ToString(axisX.Y) + ", " + Snap.Number.ToString(axisX.Z) + " )");
Write("\n");
Write("AxisY = ( " + Snap.Number.ToString(axisY.X) + ", " + Snap.Number.ToString(axisY.Y) + ", " + Snap.Number.ToString(axisY.Z) + " )");
Write("\n");
Write("AxisZ = ( " + Snap.Number.ToString(axisZ.X) + ", " + Snap.Number.ToString(axisZ.Y) + ", " + Snap.Number.ToString(axisZ.Z) + " )");
Write("\n");
}
public Snap.Geom.Box3d GetBox3d()
{
if (Electrode != null)
{
var topFaceDir = -Electrode.BaseFace.GetFaceDirection();
var topFaceOrientation = new Snap.Orientation(topFaceDir);
topFaceOrientation = Electrode.GetSidelongOrientation(topFaceOrientation);
var quadrantType = EactConfig.ConfigData.GetInstance().QuadrantType;
var transQ = Snap.Geom.Transform.CreateRotation(new Snap.Position(), topFaceDir, SnapEx.Helper.CAngle(Electrode.GetQuadrantType(quadrantType), quadrantType));
return(_body.AcsToWcsBox3d(topFaceOrientation));
}
return(_body.AcsToWcsBox3d());
}
public static Snap.Geom.Box3d AcsToWcsBox3d(Snap.Geom.Box3d box, Snap.Orientation wcs)
{
var corners = new List <Snap.Position>();
box.Corners.ToList().ForEach(u => {
var acsOrientation = Snap.Orientation.Identity;
var wcsOrientation = wcs;
var transR = Snap.Geom.Transform.CreateRotation(acsOrientation, wcsOrientation);
corners.Add(u.Copy(transR));
});
var xList = Enumerable.Select(corners, u => u.X).ToList();
var yList = Enumerable.Select(corners, u => u.Y).ToList();
var zList = Enumerable.Select(corners, u => u.Z).ToList();
return(new Snap.Geom.Box3d(xList.Min(), yList.Min(), zList.Min(), xList.Max(), yList.Max(), zList.Max()));
}
public static bool IsUseOrientation(Snap.Orientation ori)
{
var result = true;
List <double> list = new List <double>();
list.AddRange(ori.AxisX.Array);
list.AddRange(ori.AxisY.Array);
list.AddRange(ori.AxisZ.Array);
foreach (var item in list)
{
if (!(System.Math.Round(item) == item))
{
result = false;
break;
}
}
return(result);
}
/// <summary>
/// 创建摄像机
/// </summary>
public static ModelingView CreateCamera(ViewType viewType, double[] martrix)
{
var viewName = Enum.GetName(viewType.GetType(), viewType);
Session theSession = Session.GetSession();
Part workPart = theSession.Parts.Work;
Part displayPart = theSession.Parts.Display;
var or = new Snap.Orientation(
new Snap.Vector(martrix[0], martrix[1], martrix[2])
, new Snap.Vector(martrix[3], martrix[4], martrix[5]));
var modelingView = workPart.ModelingViews.ToArray().FirstOrDefault(u => u.Name == viewName);
var camera = workPart.Cameras.ToArray().FirstOrDefault(u => u.Name == viewName);
if (modelingView != null && camera != null)
{
Snap.NX.NXObject.Wrap(camera.Tag).Delete();
Snap.NX.NXObject.Wrap(modelingView.Tag).Delete();
}
{
var ufSession = NXOpen.UF.UFSession.GetUFSession();
var ds = new List <double>();
ds.AddRange(or.AxisX.Array);
ds.AddRange(or.AxisY.Array);
SnapEx.Ex.UC6434("", 4, NXOpen.Tag.Null, ds.ToArray());
//ufSession.View.SetViewMatrix("", 4, NXOpen.Tag.Null, martrix);
#region createCamera Code
NXOpen.Tag workView;
ufSession.View.AskWorkView(out workView);
string workViewName;
ufSession.Obj.AskName(workView, out workViewName);
SnapEx.Ex.UC6450(workViewName, viewName, 0, 0);
SnapEx.Ex.UC6449(workViewName);
#endregion
modelingView = workPart.ModelingViews.ToArray().FirstOrDefault(u => u.Name == viewName);
}
return(modelingView);
}
/// <summary>
/// 获取摄像机视角
/// </summary>
public static Snap.Orientation GetCameraOrientation(Snap.Orientation ori, Electrode elec = null)
{
var wcsOrientation = Electrode.GetStandardOrientation(Snap.Globals.WcsOrientation);
var acsOrientation = Snap.Orientation.Identity;
var transR = Snap.Geom.Transform.CreateRotation(acsOrientation, wcsOrientation);
var X = new Snap.Vector(ori.AxisX.X, ori.AxisX.Y, ori.AxisX.Z).Copy(transR);
var Y = new Snap.Vector(ori.AxisY.X, ori.AxisY.Y, ori.AxisY.Z).Copy(transR);
if (elec != null)
{
var baseDirOrientation = Electrode.GetSidelongOrientation(new Snap.Orientation(-elec.BaseFace.GetFaceDirection()));
var transR1 = Snap.Geom.Transform.CreateRotation(baseDirOrientation, wcsOrientation);
X = X.Copy(transR1);
Y = Y.Copy(transR1);
}
return(new Snap.Orientation(X, Y));
}
/// <summary>
/// 获取基准角
/// </summary>
public static Snap.NX.Face GetBaseCornerFace(Snap.Position startPoint, Snap.Position endPoint, Snap.NX.Body body)
{
Snap.NX.Face result = null;
Snap.Position basePoint = (startPoint + endPoint) / 2;
Snap.NX.Face baseFace = GetBaseFace(startPoint, endPoint, body);
var faces = body.Faces.ToList();
if (baseFace != null)
{
faces.Remove(baseFace);
var baseFaceDir = new Snap.Orientation(baseFace.GetFaceDirection());
var tempFaces = new List <Snap.NX.Face>();
faces.Where(u => u.ObjectSubType == Snap.NX.ObjectTypes.SubType.FacePlane).ToList().ForEach(u =>
{
var director = u.GetFaceDirection();
var angle = Snap.Vector.Angle(baseFaceDir.AxisX, director);
if (Math.Abs(angle - 45) < _tolerance ||
Math.Abs(angle - 135) < _tolerance
)
{
tempFaces.Add(u);
}
});
if (tempFaces.Count > 1)
{
tempFaces.RemoveAll(u => u.Box.MaxZ <= basePoint.Z);
}
if (tempFaces.Count > 0)
{
result = tempFaces.FirstOrDefault();
}
}
return(result);
}
/// <summary>
/// 获取侧放矩阵
/// </summary>
public static Snap.Orientation GetSidelongOrientation(Snap.Orientation baseDirOrientation)
{
var or = GetStandardOrientation(baseDirOrientation);
var identity = Snap.Orientation.Identity;
Snap.Vector x = or.AxisX;
Snap.Vector y = or.AxisY;
if (SnapEx.Helper.Equals(or.AxisZ, -identity.AxisY))
{
x = identity.AxisX;
y = identity.AxisZ;
}
else if (SnapEx.Helper.Equals(or.AxisZ, identity.AxisY))
{
x = -identity.AxisX;
y = identity.AxisZ;
}
else if (SnapEx.Helper.Equals(or.AxisZ, -identity.AxisX))
{
x = -identity.AxisY;
y = identity.AxisZ;
}
else if (SnapEx.Helper.Equals(or.AxisZ, identity.AxisX))
{
x = identity.AxisY;
y = identity.AxisZ;
}
else if (SnapEx.Helper.Equals(or.AxisZ, -identity.AxisZ))
{
x = identity.AxisX;
y = -identity.AxisY;
}
else
{
return(or);
}
return(new Snap.Orientation(x, y));
}
/// <summary>
/// 获取所有的侧面
/// </summary>
protected static List <Snap.NX.Face> GetBaseSideFaces(Snap.NX.Face baseFace, List <Snap.NX.Face> allSideFaces)
{
var result = new List <Snap.NX.Face>();
var faceDirection = baseFace.GetFaceDirection();
var baseFaceCenterPoint = baseFace.GetCenterPoint();
var orientation = new Snap.Orientation(faceDirection);
var firstFace = allSideFaces.Where(u => SnapEx.Helper.Equals(u.GetFaceDirection(), -orientation.AxisY));
var twoFace = allSideFaces.Where(u => SnapEx.Helper.Equals(u.GetFaceDirection(), orientation.AxisX));
var threeFace = allSideFaces.Where(u => SnapEx.Helper.Equals(u.GetFaceDirection(), orientation.AxisY));
var fourFace = allSideFaces.Where(u => SnapEx.Helper.Equals(u.GetFaceDirection(), -orientation.AxisX));
Action <List <Snap.NX.Face> > action = itemFace => {
if (itemFace.Count() > 1)
{
var fFace = itemFace
.Where(u => Snap.Compute.Distance(u, baseFace) < SnapEx.Helper.Tolerance)
.OrderByDescending(u => Snap.Compute.Distance(baseFaceCenterPoint, ((Snap.NX.Face.Plane)u).Geometry))
.ThenByDescending(u => u.GetPlaneProjectArea())
.FirstOrDefault();
if (fFace != null)
{
result.Add(fFace);
}
}
else
{
result.AddRange(itemFace);
}
};
action(firstFace.ToList());
action(twoFace.ToList());
action(threeFace.ToList());
action(fourFace.ToList());
return(result);
}
public override string ElecCuttingSize(EactConfig.ConfigData configData, double matchJiajuValue, Snap.Orientation topOrientation = null)
{
var str = _body.GetAttrValue("UP_ELECTRODE_SPECIFICATION");
var strs = str.Split('X').ToList();
if (strs.Count >= 3)
{
return(string.Format("{0}x{1}x{2}",
strs[0].Trim()
, strs[1].Trim()
, strs[2].Trim()
));
}
return(base.ElecCuttingSize(configData, matchJiajuValue, topOrientation));
}
/// <summary>
/// 获取象限类型
/// </summary>
public static QuadrantType GetQuadrantType(Snap.Position position, Snap.Position center, Snap.Orientation orientation)
{
QuadrantType type = QuadrantType.First;
var x = position.X - center.X;
var y = position.Y - center.Y;
if (x > 0 && y > 0) //第一象限
{
type = QuadrantType.First;
}
else if (x < 0 && y > 0) //第二象限
{
type = QuadrantType.Second;
}
else if (x < 0 && y < 0) //第三象限
{
type = QuadrantType.Three;
}
else //第四象限
{
type = QuadrantType.Four;
}
return(type);
}
public static Snap.Geom.Box3d AcsToWcsBox3d(this Snap.NX.NXObject obj, Snap.Orientation wcs)
{
return(AcsToWcsBox3d(obj.Box, wcs));
}
/// <summary>
/// 设置刻字内容
/// </summary>
public void SetText(string text, ElecManage.Electrode ele)
{
ele.GetChamferFace();
if (ele.ChamferFace != null)
{
List <NXOpen.Tag> peripheral;
List <List <NXOpen.Tag> > innerCircumference;
Helper.GetOutlineCurve(ele.BaseFace, out peripheral, out innerCircumference);
if (!(peripheral.Count > 0 && ele.BaseSideFaces.Count > 0))
{
return;
}
var list = peripheral.ToList();
if (list.Count > 2)
{
list = list.OrderByDescending(u => Snap.NX.Edge.Wrap(u).ArcLength).Take(2).ToList();
}
var edge = Snap.NX.Edge.Wrap(list.OrderByDescending(u => Snap.Compute.Distance(ele.ChamferFace, Snap.NX.NXObject.Wrap(u))).FirstOrDefault());
var minDistance = double.MaxValue;
innerCircumference.ForEach(u => {
u.ForEach(m => {
var tmpDistance = Snap.Compute.Distance(edge, Snap.NX.NXObject.Wrap(m));
if (minDistance > tmpDistance)
{
minDistance = tmpDistance;
}
});
});
var textCenterPoint = (edge.StartPoint + edge.EndPoint) / 2;
var face = ele.BaseSideFaces.OrderBy(u => Snap.Compute.Distance(textCenterPoint, u)).FirstOrDefault();
var yDir = Snap.Vector.Unit(-face.GetFaceDirection());
textCenterPoint = textCenterPoint.Copy(Snap.Geom.Transform.CreateTranslation((minDistance * 2 / 5) * yDir));
var textOri = new Snap.Orientation(Snap.Vector.Cross(yDir, Snap.Orientation.Identity.AxisZ), yDir);
var trans = Snap.Geom.Transform.CreateRotation(textOri, Snap.Orientation.Identity);
trans = Snap.Geom.Transform.Composition(trans, Snap.Geom.Transform.CreateTranslation(textCenterPoint - Snap.Position.Origin));
var textNxObject = Snap.NX.NXObject.Wrap(SnapEx.Create.CreateNode(text, Snap.Position.Origin));
textNxObject.Move(trans);
var eData = new EdmDraw.DraftingEnvironmentData();
var mpi = eData.mpi;
var mpr = eData.mpr;
var ufSession = NXOpen.UF.UFSession.GetUFSession();
ufSession.Drf.AskObjectPreferences(textNxObject.NXOpenTag, eData.mpi, eData.mpr, out eData.radiusValue, out eData.diameterValue);
//设置尺寸
var textStyle = new Snap.NX.TextStyle();
textStyle.SetFont("chinesef", Snap.NX.TextStyle.FontType.NX);
//文字对齐位置 首选项→公共→文字→对齐位置
mpi[30] = (int)textStyle.AlignmentPosition;
//文字样式 首选项→公共→文字→文本参数→字体(将字体设置为blockfont)
mpi[88] = textStyle.FontIndex;
//文字样式 首选项→公共→文字→文本参数→设置字宽(粗细)
mpi[89] = 0;
//字大小
mpr[44] = 3.5;
//文本长宽比
mpr[45] = 0.5;
//字体间距
mpr[46] = 0.1;
textStyle.AlignmentPosition = Snap.NX.TextStyle.AlignmentPositions.MidCenter;
ufSession.Drf.SetObjectPreferences(textNxObject.NXOpenTag, eData.mpi, eData.mpr, eData.radiusValue, eData.diameterValue);
Helper.SetCamText(OperTag, new List <NXOpen.Tag> {
textNxObject.NXOpenTag
});
}
}
/// <summary>
/// 开料尺寸
/// </summary>
public virtual string ElecCuttingSize(EactConfig.ConfigData configData, double matchJiajuValue, Snap.Orientation topOrientation = null)
{
double blankstock = configData.PQBlankStock;
if (Entry.Edition == 1)
{
return(string.Format("{0}x{1}x{2}",
KL_SIZE_LEN
, KL_SIZE_WIDTH
, KL_SIZE_HEIGHT
));
}
Snap.Geom.Box3d elecBox;
if (topOrientation == null)
{
elecBox = GetBox3d();
}
else
{
elecBox = _body.AcsToWcsBox3d(topOrientation);
}
if (configData.Edition == 5)
{
var x = (int)Math.Ceiling(Math.Round(Math.Abs(elecBox.MaxX - elecBox.MinX), 4) + (configData.FZXBlankStock * 2));
var y = (int)Math.Ceiling(Math.Round(Math.Abs(elecBox.MaxY - elecBox.MinY), 4) + (configData.FZYBlankStock * 2));
var z = (int)Math.Ceiling(Math.Round(Math.Abs(elecBox.MaxZ - elecBox.MinZ), 4) + (configData.FZZBlankStock * 2));
if (configData.IsFZX5Integral && x % 5 != 0)
{
x = x - (x % 5) + 5;
}
if (configData.IsFZY5Integral && y % 5 != 0)
{
y = y - (y % 5) + 5;
}
if (configData.IsFZZ5Integral && z % 5 != 0)
{
z = z - (z % 5) + 5;
}
return(string.Format("{0}x{1}x{2}", x, y, z));
}
else
{
var z = (int)Math.Ceiling(Math.Round(Math.Abs(elecBox.MaxZ - elecBox.MinZ), 4) + (matchJiajuValue));
if (z % 5 != 0)
{
z = z - (z % 5) + 5;
}
return(string.Format("{0}x{1}x{2}",
(int)Math.Ceiling(Math.Round(Math.Abs(elecBox.MaxX - elecBox.MinX), 4) + (blankstock * 2))
, (int)Math.Ceiling(Math.Round(Math.Abs(elecBox.MaxY - elecBox.MinY), 4) + (blankstock * 2))
, z
));
}
}
