public List <double[]> getPointCoordinatesFromLusas()
{
List <double[]> pointsCoordinates = new List <double[]>();
IFSelection userInp = lusas.getSelection();
object points = userInp.getObjects("points");
object[] pointsArray = (object[])points;
//check if selection is at least one point
if (pointsArray.Length < 1)
{
MessageBox.Show("please select at least one point", "", MessageBoxButtons.OK);
return(null);
}
for (int i = 0; i < pointsArray.Length; i++)
{
IFPoint point = (IFPoint)pointsArray[i];
double[] position = new double[3];
//point.getXYZ(ref position);
position[0] = point.getX();
position[1] = point.getY();
position[2] = point.getZ();
pointsCoordinates.Add(position);
}
return(pointsCoordinates);
}
/***************************************************/
/**** Public Methods ****/
/***************************************************/
public static Node ToNode(this IFPoint lusasPoint,
HashSet <string> groupNames, Dictionary <string, Constraint6DOF> constraint6DOFs)
{
HashSet <string> tags = new HashSet <string>(IsMemberOf(lusasPoint, groupNames));
List <string> supportAssignments = GetAttributeAssignments(lusasPoint, "Support");
Constraint6DOF nodeConstraint = null;
if (!(supportAssignments.Count() == 0))
{
constraint6DOFs.TryGetValue(supportAssignments[0], out nodeConstraint);
}
Node node = new Node
{
Position = new Point {
X = lusasPoint.getX(), Y = lusasPoint.getY(), Z = lusasPoint.getZ()
},
Name = "",
Support = nodeConstraint
};
node.Tags = tags;
string adapterID = lusasPoint.getID().ToString();
node.SetAdapterId(typeof(LusasId), adapterID);
return(node);
}
/***************************************************/
/**** Private Methods ****/
/***************************************************/
private IFPoint CreatePoint(Node node)
{
if (!CheckPropertyError(node, x => x.Position, true))
{
return(null);
}
Point position = node.Position;
IFDatabaseOperations databasePoint = d_LusasData.createPoint(
position.X, position.Y, position.Z);
IFPoint lusasPoint = d_LusasData.getPointByNumber(d_LusasData.getLargestPointID());
int adapterIdName = lusasPoint.getID();
node.SetAdapterId(typeof(LusasId), adapterIdName);
if (!(node.Tags.Count == 0))
{
AssignObjectSet(lusasPoint, node.Tags);
}
if (!(node.Support == null))
{
IFAttribute lusasSupport = d_LusasData.getAttribute("Support", System.Convert.ToInt32(node.Support.AdapterId <int>(typeof(LusasId))));
lusasSupport.assignTo(lusasPoint);
}
return(lusasPoint);
}
/***************************************************/
/**** Private Methods ****/
/***************************************************/
private int DeletePoints(IEnumerable <object> ids)
{
int success = 1;
if (ids != null)
{
List <int> indicies = ids.Cast <int>().ToList();
foreach (int index in indicies)
{
IFPoint lusasPoint = d_LusasData.getPointByNumber(index);
if (lusasPoint.getHOFs().Count() > 0)
{
//Engine.Base.Compute.RecordWarning(index + @" has higher order features(HOFs)
//and cannot be deleted");
}
else
{
d_LusasData.Delete(lusasPoint);
}
}
}
else
{
d_LusasData.deletePoints();
}
return(success);
}
/***************************************************/
public static Point ToPoint(this IFPoint lusasPoint)
{
Point point = new Point {
X = lusasPoint.getX(), Y = lusasPoint.getY(), Z = lusasPoint.getZ()
};
return(point);
}
/***************************************************/
/**** Private Methods ****/
/***************************************************/
private static Node GetNode(IFLine lusasLine, int nodeIndex, Dictionary <string, Node> nodes)
{
Node node;
IFPoint lusasPoint = lusasLine.getLOFs()[nodeIndex];
nodes.TryGetValue(lusasPoint.getID().ToString(), out node);
return(node);
}
/***************************************************/
/**** Public Methods ****/
/***************************************************/
public static Point ToPoint(this IFPoint lusasPoint, HashSet <string> groupNames)
{
HashSet <string> tags = new HashSet <string>(IsMemberOf(lusasPoint, groupNames));
Point point = new Point {
X = lusasPoint.getX(), Y = lusasPoint.getY(), Z = lusasPoint.getZ()
};
return(point);
}
/***************************************************/
/**** Private Methods ****/
/***************************************************/
private List <IFPoint> ReadLusasPoints(List <string> ids = null)
{
object[] lusasPoints = d_LusasData.getObjects("Point");
List <IFPoint> lusasPointList = new List <IFPoint>();
for (int i = 0; i < lusasPoints.Count(); i++)
{
IFPoint lusasPoint = (IFPoint)lusasPoints[i];
lusasPointList.Add(lusasPoint);
}
return(lusasPointList);
}
/***************************************************/
protected bool Update(IEnumerable <Node> nodes)
{
foreach (Node node in nodes)
{
IFPoint lusasPoint = d_LusasData.getPointByNumber(node.AdapterId <int>(typeof(LusasId)));
if (lusasPoint == null)
{
return(false);
}
}
return(true);
}
public List <List <double[]> > getSurfaceCoordinatesFromLusas()
{
IFSelection userInp = lusas.getSelection();
//check if selection is at least one point
if (userInp.countSurfaces() < 1)
{
MessageBox.Show("please select at least one point", "", MessageBoxButtons.OK);
return(null);
}
//create collection to popoulate surfaces
List <List <double[]> > surfaces = new List <List <double[]> >();
for (int i = 0; i < userInp.countSurfaces(); i++)
{
//gereate array of ids
List <int> pointIds = new List <int>();
//generate collection for populating vertices
List <double[]> vertexes = new List <double[]>();
IFSurface surface = userInp.getSurface(i);
object[] lines = surface.getLOFs() as object[];
for (int l = 0; l < lines.Length; l++)
{
IFLine line = lines[l] as IFLine;
object[] points = line.getLOFs() as object[];
for (int k = 0; k < points.Length; k++)
{
IFPoint point = points[k] as IFPoint;
int id = point.getID();
if (!pointIds.Contains(id))
{
pointIds.Add(id);
double[] position = new double[3];
position[0] = point.getX();
position[1] = point.getY();
position[2] = point.getZ();
//point.getXYZ(position[0],position[1],position[2]);
vertexes.Add(position);
}
}
}
surfaces.Add(vertexes);
}
return(surfaces);
}
/***************************************************/
private IFPoint CreatePoint(Point point)
{
if (point != null)
{
Node newNode = new Node {
Position = new Point {
X = point.X, Y = point.Y, Z = point.Z
}
};
IFPoint newPoint = CreatePoint(newNode);
return(newPoint);
}
return(null);
}
/***************************************************/
/**** Private methods ****/
/***************************************************/
private bool CreateCollection(IEnumerable <Node> nodes)
{
if (nodes != null)
{
CreateTags(nodes);
ReduceRuntime(true);
foreach (Node node in nodes)
{
IFPoint lusasPoint = CreatePoint(node);
}
ReduceRuntime(false);
}
return(true);
}
/***************************************************/
/**** Private Methods ****/
/***************************************************/
private List <Point> ReadPoints(List <string> ids = null)
{
object[] lusasPoints = d_LusasData.getObjects("Point");
List <Point> points = new List <Point>();
if (!(lusasPoints.Count() == 0))
{
HashSet <string> groupNames = ReadTags();
for (int i = 0; i < lusasPoints.Count(); i++)
{
IFPoint lusasPoint = (IFPoint)lusasPoints[i];
Point point = Adapters.Lusas.Convert.ToPoint(lusasPoint, groupNames);
points.Add(point);
}
}
return(points);
}
/***************************************************/
/**** Private Methods ****/
/***************************************************/
private IFLine CreateEdge(Edge edge, IFPoint startPoint, IFPoint endPoint)
{
IFLine lusasLine = d_LusasData.createLineByPoints(startPoint, endPoint);
int adapterIdName = lusasLine.getID();
edge.SetAdapterId(typeof(LusasId), adapterIdName);
if (!(edge.Tags.Count == 0))
{
AssignObjectSet(lusasLine, edge.Tags);
}
if (!(edge.Support == null))
{
IFAttribute lusasSupport = d_LusasData.getAttribute("Support", edge.Support.AdapterId <int>(typeof(LusasId)));
lusasSupport.assignTo(lusasLine);
}
return(lusasLine);
}
/***************************************************/
private bool CreateCollection(IEnumerable <Point> points)
{
if (points != null)
{
List <Point> distinctPoints = Engine.Adapters.Lusas.Query.GetDistinctPoints(points);
List <Point> existingPoints = ReadPoints();
List <Point> lusasPoints = distinctPoints.Except(existingPoints).ToList();
ReduceRuntime(true);
foreach (Point point in lusasPoints)
{
IFPoint lusasPoint = CreatePoint(point);
}
ReduceRuntime(false);
}
return(true);
}
/***************************************************/
/**** Private Methods ****/
/***************************************************/
private static IEnumerable <Node> GetPointAssignments(IEnumerable <IFAssignment> lusasAssignments,
Dictionary <string, Node> nodes)
{
List <Node> assignedNodes = new List <Node>();
Node node;
foreach (IFAssignment lusasAssignment in lusasAssignments)
{
if (lusasAssignment.getDatabaseObject() is IFPoint)
{
IFPoint lusasPoint = (IFPoint)lusasAssignment.getDatabaseObject();
nodes.TryGetValue(lusasPoint.getID().ToString(), out node);
assignedNodes.Add(node);
}
else
{
AssignmentWarning(lusasAssignment);
}
}
return(assignedNodes);
}
/***************************************************/
/**** Private Methods ****/
/***************************************************/
private List <Node> ReadNodes(List <string> ids = null)
{
object[] lusasPoints = d_LusasData.getObjects("Point");
List <Node> nodes = new List <Node>();
if (!(lusasPoints.Count() == 0))
{
HashSet <string> groupNames = ReadTags();
IEnumerable <Constraint6DOF> constraints6DOFList = Read6DOFConstraints();
Dictionary <string, Constraint6DOF> constraints6DOF = constraints6DOFList.ToDictionary(
x => x.Name.ToString());
for (int i = 0; i < lusasPoints.Count(); i++)
{
IFPoint lusasPoint = (IFPoint)lusasPoints[i];
Node node = Adapters.Lusas.Convert.ToNode(lusasPoint, groupNames, constraints6DOF);
nodes.Add(node);
}
}
return(nodes);
}
/***************************************************/
/**** Private Methods ****/
/***************************************************/
private IFLine CreateLine(Bar bar)
{
if (!CheckPropertyError(bar, b => b.StartNode, true) || !CheckPropertyError(bar, b => b.EndNode, true) ||
!CheckPropertyError(bar, b => b.StartNode.Position, true) || !CheckPropertyError(bar, b => b.EndNode.Position, true))
{
return(null);
}
if (
bar.FEAType == BarFEAType.CompressionOnly ||
bar.FEAType == BarFEAType.TensionOnly)
{
Engine.Base.Compute.RecordError("Lusas does not support " + bar.FEAType.ToString() + " Bars");
return(null);
}
string startNodeId = GetAdapterId <string>(bar.StartNode);
string endNodeId = GetAdapterId <string>(bar.EndNode);
if (string.IsNullOrEmpty(startNodeId) || string.IsNullOrEmpty(endNodeId))
{
Engine.Base.Compute.RecordError("Could not find the ids for at least one end node for at least one Bar. Bar not created.");
return(null);
}
IFPoint startPoint = d_LusasData.getPointByNumber(bar.StartNode.AdapterId <int>(typeof(LusasId)));
IFPoint endPoint = d_LusasData.getPointByNumber(bar.EndNode.AdapterId <int>(typeof(LusasId)));
IFLine lusasLine = d_LusasData.createLineByPoints(startPoint, endPoint);
int adapterIdName = lusasLine.getID();
bar.SetAdapterId(typeof(LusasId), adapterIdName);
if (bar.Tags.Count != 0)
{
AssignObjectSet(lusasLine, bar.Tags);
}
if (CheckPropertyWarning(bar, b => b.SectionProperty) && !Engine.Adapters.Lusas.Query.InvalidSectionProperty(bar.SectionProperty))
{
if (!Engine.Adapters.Lusas.Query.InvalidSectionProfile(bar.SectionProperty))
{
//Needed in case the SectionProfile is null and was not created
if (d_LusasData.existsAttribute("Line Geometric", bar.SectionProperty.AdapterId <int>(typeof(LusasId))))
{
IFAttribute lusasGeometricLine = d_LusasData.getAttribute("Line Geometric", bar.SectionProperty.AdapterId <int>(typeof(LusasId)));
lusasGeometricLine.assignTo(lusasLine);
}
if (CheckPropertyWarning(bar, b => b.SectionProperty.Material))
{
if (bar.SectionProperty.Material is IOrthotropic)
{
Engine.Base.Compute.RecordWarning($"Orthotropic Material {bar.SectionProperty.Material.DescriptionOrName()} cannot be assigned to Bar {bar.AdapterId<int>(typeof(LusasId))}, " +
$"orthotropic materials can only be applied to 2D and 3D elements in Lusas.");
}
else if (bar.SectionProperty.Material is IIsotropic)
{
if (d_LusasData.existsAttribute("Material", bar.SectionProperty.Material.AdapterId <int>(typeof(LusasId))))
{
IFAttribute lusasMaterial = d_LusasData.getAttribute("Material", bar.SectionProperty.Material.AdapterId <int>(typeof(LusasId)));
lusasMaterial.assignTo(lusasLine);
}
}
}
}
}
if (bar.Support != null)
{
IFAttribute lusasSupport = d_LusasData.getAttribute("Support", System.Convert.ToInt32(bar.Support.AdapterId <int>(typeof(LusasId))));
lusasSupport.assignTo(lusasLine);
IFLocalCoord barLocalAxis = CreateLocalCoordinate(lusasLine);
barLocalAxis.assignTo(lusasLine);
}
if (bar.Fragments.Contains(typeof(MeshSettings1D)))
{
IFAssignment meshAssignment = m_LusasApplication.newAssignment();
meshAssignment.setAllDefaults();
if (bar.OrientationAngle != 0 && bar.FEAType == BarFEAType.Axial)
{
Engine.Base.Compute.RecordWarning(
"Orientation angle not supported in Lusas for " + bar.FEAType +
" element types, this information will be lost when pushed to Lusas");
}
meshAssignment.setBetaAngle(bar.OrientationAngle);
MeshSettings1D meshSettings1D = bar.FindFragment <MeshSettings1D>();
IFMeshAttr mesh = d_LusasData.getMesh(
meshSettings1D.Name + "\\" + bar.FEAType.ToString() + "|" + CreateReleaseString(bar.Release));
mesh.assignTo(lusasLine, meshAssignment);
}
if (bar.Offset != null)
{
Engine.Base.Compute.RecordWarning("Offsets are currently unsupported.");
}
return(lusasLine);
}
/***************************************************/
private bool CreateCollection(IEnumerable <Edge> edges)
{
if (edges != null)
{
List <Point> allPoints = new List <Point>();
//Check List<Curve> is not null and Curve is not invalid (i.e. not a Line)
List <Edge> validEdges = edges.Where(x => CheckPropertyError(x, y => y.Curve))
.Where(x => !Engine.Adapters.Lusas.Query.InvalidEdge(x)).ToList();
List <Edge> distinctEdges = new List <Edge>();
//Check Curve is not a null
foreach (Edge edge in validEdges)
{
if (!(edge.Curve == null))
{
distinctEdges.Add(edge);
}
}
distinctEdges = Engine.Adapters.Lusas.Query.GetDistinctEdges(distinctEdges);
foreach (Edge edge in distinctEdges)
{
allPoints.Add(edge.Curve.IStartPoint());
allPoints.Add(edge.Curve.IEndPoint());
}
List <Point> distinctPoints = Engine.Adapters.Lusas.Query.GetDistinctPoints(allPoints);
List <Point> existingPoints = ReadPoints();
List <Point> pointsToPush = distinctPoints.Except(
existingPoints, new PointDistanceComparer()).ToList();
ReduceRuntime(true);
foreach (Point point in pointsToPush)
{
IFPoint lusasPoint = CreatePoint(point);
}
ReduceRuntime(false);
List <IFPoint> lusasPoints = ReadLusasPoints();
List <Point> points = new List <Point>();
foreach (IFPoint point in lusasPoints)
{
points.Add(Adapters.Lusas.Convert.ToPoint(point));
}
CreateTags(distinctEdges);
ReduceRuntime(true);
foreach (Edge edge in distinctEdges)
{
IFPoint startPoint = lusasPoints[points.FindIndex(
m => m.Equals(edge.Curve.IStartPoint().ClosestPoint(points)))];
IFPoint endPoint = lusasPoints[points.FindIndex(
m => m.Equals(edge.Curve.IEndPoint().ClosestPoint(points)))];
IFLine lusasLine = CreateEdge(edge, startPoint, endPoint);
}
ReduceRuntime(false);
}
return(true);
}
