Wrong Position/Coordinates Of Selected Point On Face

Hi,

I implemented the TrayARay() method instead of AskMinimumDist()
in a new project (see code below).

According to the documentation for TrayARay() the list containing
the returned information is in the order of its distance from the
origin of the ray, the closest first.

That is exactly what I am looking for.

But unfortunately the behavior is the same as with the
AskMinimumDist() method.

I will prepare something for downloading from a cloud service
which demonstrates the the problem and will hopefully allow you
to reproduce the situation I encounter.

By the way as stated in the documentation the caller must free the
array containing the hit list. I have found


UF_free(hit_list)


in the example of the documentation. But how do I implement it
in C#? Or does C# take care of freeing the array?

And here is the TraceARay()-Code:

using System;
using System.Collections.Generic;
using System.Windows.Forms;
using System.Globalization;

using NXOpen;
using NXOpen.UF;
using NXOpen.Utilities;

public class Program
{
// class members
private static Session theSession;
private static UI theUI;
private static UFSession theUfSession;
public static Program theProgram;
public static bool isDisposeCalled;

public static Part workPart;
public static ListingWindow lw;

public static int HighlightObj { get { return 1; } }
public static int UnhighlightObj { get { return 0; } }
public static int MaxNumElemsOfTransMtx { get { return 16; } }

public List ObjListToUnhighlight { get { return objListToUnhighlight; } set { objListToUnhighlight = value; } }

private string msg = string.Empty;
private string caption = string.Empty;
private const int MaxNumElemsOfPoint = 3;
private List objListToUnhighlight = new List();
private string fmt = string.Empty;
private NumberFormatInfo nfi;

///
/// Default NX color palette as found in defauld CDF-file
/// Can be called in NX by: Datei -> Voreinstellungen -> Farbpalette
///
public enum Colors
{
///
/// ID = -1
///
None = -1,

///
/// ID = 78
///
Orange = 78,

///
/// ID = 103
///
Cornflower = 103,

///
/// ID = 181
///
Magenta = 181,

///
/// ID = 186
///
Red = 186,
}

public enum RetValPointSubfunc
{
Back = 1,
Cancel = 2,
PositionReturned = 5,
NoActivePart = 7,
DisallowedState = 8 // unable to bring up dialog
}

//------------------------------------------------------------------------------
// Constructor
//------------------------------------------------------------------------------
public Program()
{
try
{
theSession = Session.GetSession();
theUI = UI.GetUI();
theUfSession = UFSession.GetUFSession();
isDisposeCalled = false;

lw = theSession.ListingWindow;
workPart = theSession.Parts.Work;
nfi = new CultureInfo("en-US", false).NumberFormat;
}
catch (NXOpen.NXException ex)
{
// ---- Enter your exception handling code here -----
// UI.GetUI().NXMessageBox.Show("Message", NXMessageBox.DialogType.Error, ex.Message);
}
}

//------------------------------------------------------------------------------
// Explicit Activation
// This entry point is used to activate the application explicitly
//------------------------------------------------------------------------------
public static int Main(string[] args)
{
int retValue = 0;
try
{
theProgram = new Program();

//TODO: Add your application code here
Session.UndoMarkId markId1;
markId1 = theSession.SetUndoMark(Session.MarkVisibility.Visible, "NXJ");

lw.Open();

theProgram.Execute();
theProgram.CleanUp();

lw.Close();

theProgram.Dispose();
}
catch (NXOpen.NXException ex)
{
// ---- Enter your exception handling code here -----

}
return retValue;
}

//------------------------------------------------------------------------------
// Following method disposes all the class members
//------------------------------------------------------------------------------
public void Dispose()
{
try
{
if (isDisposeCalled == false)
{
//TODO: Add your application code here
}
isDisposeCalled = true;
}
catch (NXOpen.NXException ex)
{
// ---- Enter your exception handling code here -----

}
}

public static int GetUnloadOption(string arg)
{
//Unloads the image explicitly, via an unload dialog
//return System.Convert.ToInt32(Session.LibraryUnloadOption.Explicitly);

//Unloads the image immediately after execution within NX
return System.Convert.ToInt32(Session.LibraryUnloadOption.Immediately);

//Unloads the image when the NX session terminates
// return System.Convert.ToInt32(Session.LibraryUnloadOption.AtTermination);
}

public void Execute()
{
var msg = "TestTraceARay()" + Environment.NewLine + "##################";

lw.WriteLine(msg);

DialogResult dlgResult = DialogResult.None;
var i = 1;

while (dlgResult != DialogResult.No)
{
if (ObjListToUnhighlight.Count > 0)
DeleteTempObjects();

msg = Environment.NewLine + Environment.NewLine
+ "### Run-No.: " + i.ToString()
+ Environment.NewLine + Environment.NewLine;
lw.WriteLine(msg);

var pointSelected = new double[MaxNumElemsOfPoint];

//pointSelected = PickPoint();

var title = "Select point on face";
var resp = UFConstants.UF_UI_CANCEL;

var faceTag = SelectPointOnFace(title, pointSelected, out resp);

if ( resp != UFConstants.UF_UI_OBJECT_SELECTED
&& resp != UFConstants.UF_UI_OBJECT_SELECTED_BY_NAME)
{
msg = "Invalid selection!";
caption = "Error";
dlgResult = MessageBox.Show(msg, caption, MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}

msg = ">>>>> SelectPointOnFace() returns: " + Environment.NewLine + Environment.NewLine
+ "Selected face: F(" + faceTag.ToString() + ")" + Environment.NewLine
+ "Cursor position: P = ("
+ pointSelected[0].ToString("F3", nfi) + ", "
+ pointSelected[1].ToString("F3", nfi) + ", "
+ pointSelected[2].ToString("F3", nfi) + ")"
+ Environment.NewLine + Environment.NewLine;
lw.WriteLine(msg);

//DisplayTemporaryAsterisk(pointSelected, Colors.Orange);

AskPosOnObj(faceTag, pointSelected);

i++;

msg = "Once again?";
caption = "Question";
dlgResult = MessageBox.Show(msg, caption, MessageBoxButtons.YesNo, MessageBoxIcon.Question);
}
}

///
/// Unhighlights objects and deletes temporary objects.
///
public void CleanUp()
{
DialogResult dlgResult = DialogResult.None;

var msg = "Delete temporary objects and unhighlight faces?";
var titleMsgBoxQuestion = "Question";
dlgResult = MessageBox.Show(msg, titleMsgBoxQuestion, MessageBoxButtons.YesNo, MessageBoxIcon.Question);

if (dlgResult == DialogResult.Yes)
DeleteTempObjects();
}

private void DeleteTempObjects()
{
theUfSession.Disp.SetHighlights(ObjListToUnhighlight.Count, ObjListToUnhighlight.ToArray(), UnhighlightObj);

ObjListToUnhighlight.Clear();

workPart.Views.Refresh();
}

///
/// Select point on face.
///
/// Title of the selecting dialog.
/// Cursor position.
/// Tag of the selected face.
private Tag SelectPointOnFace(string title, double[] cp, out int resp)
{
Tag faceTag = Tag.Null;
//int resp = 0;
var theView = Tag.Null;
UFUi.SelInitFnT ip = FaceInitProc;

theUfSession.Ui.LockUgAccess
(UFConstants.UF_UI_FROM_CUSTOM);

theUfSession.Ui.SelectWithSingleDialog
("Select a face",
title,
UFConstants.UF_UI_SEL_SCOPE_ANY_IN_ASSEMBLY,
ip,
IntPtr.Zero,
out resp,
out faceTag,
cp,
out theView);

theUfSession.Ui.UnlockUgAccess(UFConstants.UF_UI_FROM_CUSTOM);

if(faceTag != Tag.Null)
AddObjectToUnhighlightList(faceTag);

return faceTag;
}

private int FaceInitProc(IntPtr select, IntPtr userData)
{
const int numTriples = 1;
UFUi.Mask[] maskTriples = new UFUi.Mask[numTriples];
maskTriples[0].object_type = UFConstants.UF_solid_type;
maskTriples[0].object_subtype = UFConstants.UF_solid_face_subtype;
maskTriples[0].solid_type = UFConstants.UF_UI_SEL_FEATURE_ANY_FACE;

theUfSession.Ui.SetSelMask
(select,
UFUi.SelMaskAction.SelMaskClearAndEnableSpecific,
numTriples,
maskTriples);

return UFConstants.UF_UI_SEL_SUCCESS;
}

///
/// Calculates the position of a point on an object provided by its cursor position.
///
/// Tag of the object (here: the selected face) the point should lie on.
/// (Cursor) position of the point.
private void AskPosOnObj(Tag obj, double[] loc)
{
double[] cp = new double[] { 0, 0, 0 };
UFCurve.Line lp;
double[] sp = new double[MaxNumElemsOfPoint];
double[] ep = new double[MaxNumElemsOfPoint];

lp.start_point = sp;
lp.end_point = ep;

MapAbs2View(loc);

lp.start_point[0] = loc[0];
lp.start_point[1] = loc[1];
lp.start_point[2] = loc[2] + 10000;

lp.end_point[0] = loc[0];
lp.end_point[1] = loc[1];
lp.end_point[2] = loc[2] - 10000;

MapView2Abs(lp.start_point);
MapView2Abs(lp.end_point);

var givenPoint = new double[MaxNumElemsOfPoint];
givenPoint[0] = lp.start_point[0];
givenPoint[1] = lp.start_point[1];
givenPoint[2] = lp.start_point[2];

var rayDir = new double[MaxNumElemsOfPoint];
rayDir[0] = lp.end_point[0] - lp.start_point[0];
rayDir[1] = lp.end_point[1] - lp.start_point[1];
rayDir[2] = lp.end_point[2] - lp.start_point[2];

var facePointPairs = new List>();

var numHitResults = TraceARay(givenPoint, rayDir, facePointPairs);

msg = ">>>>> TraceARay() returns: " + Environment.NewLine + Environment.NewLine
+ "NumHitResults = " + numHitResults.ToString() + Environment.NewLine
//+ "givenPoint = (" + givenPoint[0] + ", " + givenPoint[1] + ", " + givenPoint[2] + ")" + Environment.NewLine
//+ "rayDir = lp.end_point - lp.start_point = (" + rayDir[0] + ", " + rayDir[1] + ", " + rayDir[2] + ")"
+ Environment.NewLine;

int i = 1;
foreach (var item in facePointPairs)
{
msg += i.ToString() + ": [face, point] = [F("
+ item.Item1.Tag
+ "), P("
+ item.Item2[0].ToString("F3", nfi) + ", "
+ item.Item2[1].ToString("F3", nfi) + ", "
+ item.Item2[2].ToString("F3", nfi) + ")]"
+ Environment.NewLine;

i++;
}

lw.WriteLine(msg);
}

///
/// Maps point in coordinates of the view to absolute coordinates.
///
/// Point to be mapped in coordinates of the view.
/// Point in absolute coordinates
private double[] MapView2Abs(double[] c)
{
var vname = string.Empty;
double[] absMx = new double[] { 0, 0, 0, 1, 0, 0, 0, 1, 0 };
double[] vw = new double[] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
double[] mx = new double[] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
var irc = 0;

theUfSession.Ui.AskLastPickedView(out vname);
var wp = theSession.Parts.Work;
NXOpen.View lastViewPicked = wp.ModelingViews.FindObject(vname) as ModelingView;

Matrix3x3 vmx = lastViewPicked.Matrix;
vw[3] = vmx.Xx;
vw[4] = vmx.Xy;
vw[5] = vmx.Xz;
vw[6] = vmx.Yx;
vw[7] = vmx.Yy;
vw[8] = vmx.Yz;
vw[9] = vmx.Zx;
vw[10] = vmx.Zy;
vw[11] = vmx.Zz;
theUfSession.Trns.CreateCsysMappingMatrix(vw, absMx, mx, out irc);
theUfSession.Trns.MapPosition(c, mx);

return c;
}

///
/// Maps point from absolute coordinates to view coordinates.
///
/// Point to be mapped in absolute coordinates.
/// Point in coordinates of the view.
private double[] MapAbs2View(double[] c)
{
var vname = string.Empty;
double[] absMx = new double[] { 0, 0, 0, 1, 0, 0, 0, 1, 0 };
double[] vw = new double[] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
double[] mx = new double[] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
var irc = 0;

theUfSession.Ui.AskLastPickedView(out vname);
var wp = theSession.Parts.Work;
NXOpen.View lastViewPicked = wp.ModelingViews.FindObject(vname) as ModelingView;

Matrix3x3 vmx = lastViewPicked.Matrix;
vw[3] = vmx.Xx;
vw[4] = vmx.Xy;
vw[5] = vmx.Xz;
vw[6] = vmx.Yx;
vw[7] = vmx.Yy;
vw[8] = vmx.Yz;
vw[9] = vmx.Zx;
vw[10] = vmx.Zy;
vw[11] = vmx.Zz;

theUfSession.Trns.CreateCsysMappingMatrix(absMx, vw, mx, out irc);
theUfSession.Trns.MapPosition(c, mx);

return c;
}

private int TraceARay(double[] givenPoint, double[] rayDir, List> facePointPairs)
{
var bodyList = workPart.Bodies.ToArray(); // Get the list of bodies
int numBodies = bodyList.Length;
Tag[] bodies = new Tag[numBodies];
double[] origin = new double[MaxNumElemsOfPoint];
double[] transform = new double[MaxNumElemsOfTransMtx];
int numDesired = 6;
int numResult;
UFModl.RayHitPointInfo[] hitList;

var i = 0;
foreach (var body in bodyList)
{
bodies[i] = body.Tag;
i++;
}

theUfSession.Mtx4.Identity(transform);

// UF_CALL(UF_MODL_trace_a_ray(3, bodies, point, raydir, transform, 6, &hits_found, &hit_list));
theUfSession.Modl.TraceARay(numBodies, bodies, givenPoint, rayDir, transform, numDesired, out numResult, out hitList);

if (numResult > 0)
{
foreach (var hit in hitList)
{
Face face = (Face)NXObjectManager.Get(hit.hit_face);

var t = new Tuple(face, hit.hit_point);
facePointPairs.Add(t);

if (face != null)
{
theUfSession.Disp.SetHighlight(face.Tag, HighlightObj);
AddObjectToUnhighlightList(face.Tag);

DisplayTemporaryAsterisk(hit.hit_point, Colors.Cornflower);
}
}
}

return numResult;
}

///
/// Adds objects to list being unhighlighted at the end of the program.
///
/// Tag of the object to be added.
private void AddObjectToUnhighlightList(Tag objTag)
{
if(!objListToUnhighlight.Contains(objTag))
objListToUnhighlight.Add(objTag);
}

///
/// Displays an asterix at the given position.
///
/// coordinates to be displayed
/// color of the point to be displayed
private void DisplayTemporaryAsterisk(double[] coords, Colors color = Colors.Cornflower)
{
// UFDisp.ViewType:
// -----------------
// UF_DISP_USE_VIEW_TAG = 0
// Display in view specified by its tag
//
//UF_DISP_USE_ACTIVE_PLUS = 1
//Use the active view plus drawing views
//
//UF_DISP_USE_CURSOR = 2
//Use the position of the last cursor
//
//UF_DISP_USE_ACTIVE_MINUS = 3
//Use only active views no drawing views
//
//UF_DISP_USE_WORK_VIEW = 4
//Use the work view

UFObj.DispProps attrib = new UFObj.DispProps();
attrib.blank_status = UFConstants.UF_OBJ_BLANKED;
attrib.color = (int)color;
attrib.line_width = UFConstants.UF_OBJ_WIDTH_NORMAL;
theUfSession.Disp.DisplayTemporaryPoint(Tag.Null,
UFDisp.ViewType.UseActivePlus,
coords,
ref attrib,
UFDisp.PolyMarker.Asterisk);
}

private string GetStringRetVal(int retVal)
{
var retValString = string.Empty;

switch (retVal)
{
case (int) RetValPointSubfunc.Back:
retValString = "Back!";
break;
case (int) RetValPointSubfunc.Cancel:
retValString = "Cancel!";
break;
case (int) RetValPointSubfunc.PositionReturned:
retValString = "Position returned!";
break;
case (int) RetValPointSubfunc.NoActivePart:
retValString = "No active part!";
break;
case (int) RetValPointSubfunc.DisallowedState:
retValString = "Disallowed state, unable to bring up dialog!";
break;
default:
break;
}

return retValString;
}

}