private void TcpLoginMsgButtonClick() { Login login = new Login(); login.UserName = "******"; login.PassWord = "******"; byte[] bodys = login.ToByteArray(); string strs = ""; for (int i = 0; i < bodys.Length; i++) { strs = strs + " " + bodys[i]; } int bodycount = bodys.Length; byte[] bodycountbytes = BitConverter.GetBytes(bodycount); byte[] headbackMsgbytes = BitConverter.GetBytes((ushort)TCPEvent.TcpBackLoginMsg); NetMsgBase ba = new NetMsgBase(FrameTools.CombomBinaryArray(bodycountbytes, FrameTools.CombomBinaryArray(headbackMsgbytes, bodys))); TCPMsg msg = new TCPMsg((ushort)TCPEvent.TcpSendLoginMsg, ba); SendMsg(msg); }
private void TcpSendMsgButtonClick() { string body = "body content = asdfasdf"; byte[] data = Encoding.Default.GetBytes(body); int bodycount = body.Length; byte[] bodycountbytes = BitConverter.GetBytes(bodycount); byte[] headbackMsgbytes = BitConverter.GetBytes((ushort)TCPEvent.TcpSendMsgBack); NetMsgBase ba = new NetMsgBase(FrameTools.CombomBinaryArray(bodycountbytes, FrameTools.CombomBinaryArray(headbackMsgbytes, data))); TCPMsg msg = new TCPMsg((ushort)TCPEvent.TcpSendMsg, ba); SendMsg(msg); }
/// <summary> /// This is the method that actually does the work. /// </summary> /// <param name="DA">The DA object is used to retrieve from inputs and store in outputs.</param> protected override void SolveInstance(IGH_DataAccess DA) { // 1. Declare placeholder variables var struts = new List <Curve>(); double tol = 0.0; // 2. Attempt to retrieve input if (!DA.GetDataList(0, struts)) { return; } if (!DA.GetData(1, ref tol)) { return; } // 3. Validate input if (struts == null || struts.Count == 1) { return; } if (tol < 0) { return; } // 4. Call cleaning method var nodes = new Point3dList(); var nodePairs = new List <IndexPair>(); struts = FrameTools.CleanNetwork(struts, tol, out nodes, out nodePairs); // 5. Organize index lists var strutStart = new List <int>(); var strutEnd = new List <int>(); foreach (IndexPair nodePair in nodePairs) { strutStart.Add(nodePair.I); strutEnd.Add(nodePair.J); } // 6. Set output DA.SetDataList(0, struts); DA.SetDataList(1, nodes); DA.SetDataList(2, strutStart); DA.SetDataList(3, strutEnd); }
/// <summary> /// Instace constructor based on a list of curves (i.e. a lattice). /// </summary> public ExoMesh(List <Curve> struts) { m_hulls = new List <ExoHull>(); m_sleeves = new List <ExoSleeve>(); m_plates = new List <ExoPlate>(); m_mesh = new Mesh(); double tol = RhinoDoc.ActiveDoc.ModelAbsoluteTolerance; // First, we convert the struts to a list of unique nodes and node pairs // We use the following lists to extract valid data from the input list var nodeList = new Point3dList(); // List of unique nodes var nodePairList = new List <IndexPair>(); // List of struts, as node index pairs struts = FrameTools.CleanNetwork(struts, tol, out nodeList, out nodePairList); // Set hull locations foreach (Point3d node in nodeList) { m_hulls.Add(new ExoHull(node)); } // Create sleeves, plates and relational indices for (int i = 0; i < struts.Count; i++) { m_sleeves.Add(new ExoSleeve(struts[i], nodePairList[i])); // Construct plates m_plates.Add(new ExoPlate(nodePairList[i].I, struts[i].TangentAtStart)); m_plates.Add(new ExoPlate(nodePairList[i].J, -struts[i].TangentAtEnd)); // Set sleeve relational parameters IndexPair platePair = new IndexPair(m_plates.Count - 2, m_plates.Count - 1); m_sleeves[i].PlatePair = platePair; // Set hull relational parameters m_hulls[nodePairList[i].I].SleeveIndices.Add(i); m_hulls[nodePairList[i].J].SleeveIndices.Add(i); m_hulls[nodePairList[i].I].PlateIndices.Add(platePair.I); m_hulls[nodePairList[i].J].PlateIndices.Add(platePair.J); } }
/// <summary> /// This is the method that actually does the work. /// </summary> /// <param name="DA">The DA object is used to retrieve from inputs and store in outputs.</param> protected override void SolveInstance(IGH_DataAccess DA) { // 1. Retrieve and validate data var cell = new UnitCell(); GeometryBase designSpace = null; Plane orientationPlane = Plane.Unset; double xCellSize = 0; double yCellSize = 0; double zCellSize = 0; double minLength = 0; // the trim tolerance (i.e. minimum strut length) double maxLength = 0; bool strictlyIn = false; if (!DA.GetData(0, ref cell)) { return; } if (!DA.GetData(1, ref designSpace)) { return; } if (!DA.GetData(2, ref orientationPlane)) { return; } if (!DA.GetData(3, ref xCellSize)) { return; } if (!DA.GetData(4, ref yCellSize)) { return; } if (!DA.GetData(5, ref zCellSize)) { return; } if (!DA.GetData(6, ref minLength)) { return; } if (!DA.GetData(7, ref maxLength)) { return; } if (!DA.GetData(8, ref strictlyIn)) { return; } if (!cell.isValid) { return; } if (!designSpace.IsValid) { return; } if (!orientationPlane.IsValid) { return; } if (xCellSize == 0) { return; } if (yCellSize == 0) { return; } if (zCellSize == 0) { return; } if (minLength >= xCellSize || minLength >= yCellSize || minLength >= zCellSize) { AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "Tolerance parameter cannot be larger than the unit cell dimensions."); return; } // 2. Validate the design space int spaceType = FrameTools.ValidateSpace(ref designSpace); if (spaceType == 0) { AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "Design space must be a closed Brep, Mesh or Surface"); return; } double tol = RhinoDoc.ActiveDoc.ModelAbsoluteTolerance; // 3. Compute oriented bounding box and its corner points Box bBox = new Box(); designSpace.GetBoundingBox(orientationPlane, out bBox); Point3d[] bBoxCorners = bBox.GetCorners(); // Set basePlane based on the bounding box Plane basePlane = new Plane(bBoxCorners[0], bBoxCorners[1], bBoxCorners[3]); // 4. Determine number of iterations required to fill the box, and package into array double xLength = bBoxCorners[0].DistanceTo(bBoxCorners[1]); double yLength = bBoxCorners[0].DistanceTo(bBoxCorners[3]); double zLength = bBoxCorners[0].DistanceTo(bBoxCorners[4]); int nX = (int)Math.Ceiling(xLength / xCellSize); // Roundup to next integer if non-integer int nY = (int)Math.Ceiling(yLength / yCellSize); int nZ = (int)Math.Ceiling(zLength / zCellSize); float[] N = new float[3] { nX, nY, nZ }; // 5. Initialize nodeTree var lattice = new Lattice(); // 6. Prepare cell (this is a UnitCell object) cell = cell.Duplicate(); cell.FormatTopology(); // 7. Define iteration vectors in each direction (accounting for Cell Size) Vector3d vectorU = xCellSize * basePlane.XAxis; Vector3d vectorV = yCellSize * basePlane.YAxis; Vector3d vectorW = zCellSize * basePlane.ZAxis; // 8. Map nodes to design space // Loop through the uvw cell grid for (int u = 0; u <= N[0]; u++) { for (int v = 0; v <= N[1]; v++) { for (int w = 0; w <= N[2]; w++) { // Construct cell path in tree GH_Path treePath = new GH_Path(u, v, w); // Fetch the list of nodes to append to, or initialise it var nodeList = lattice.Nodes.EnsurePath(treePath); // This loop maps each node in the cell for (int i = 0; i < cell.Nodes.Count; i++) { double usub = cell.Nodes[i].X; // u-position within unit cell (local) double vsub = cell.Nodes[i].Y; // v-position within unit cell (local) double wsub = cell.Nodes[i].Z; // w-position within unit cell (local) double[] uvw = { u + usub, v + vsub, w + wsub }; // uvw-position (global) // Check if the node belongs to another cell (i.e. it's relative path points outside the current cell) bool isOutsideCell = (cell.NodePaths[i][0] > 0 || cell.NodePaths[i][1] > 0 || cell.NodePaths[i][2] > 0); // Check if current uvw-position is beyond the upper boundary bool isOutsideSpace = (uvw[0] > N[0] || uvw[1] > N[1] || uvw[2] > N[2]); if (isOutsideCell || isOutsideSpace) { nodeList.Add(null); } else { // Compute position vector Vector3d V = uvw[0] * vectorU + uvw[1] * vectorV + uvw[2] * vectorW; var newNode = new LatticeNode(basePlane.Origin + V); // Check if point is inside - use unstrict tolerance, meaning it can be outside the surface by the specified tolerance bool isInside = FrameTools.IsPointInside(designSpace, newNode.Point3d, spaceType, tol, strictlyIn); // Set the node state (it's location wrt the design space) if (isInside) { newNode.State = LatticeNodeState.Inside; } else { newNode.State = LatticeNodeState.Outside; } // Add node to tree nodeList.Add(newNode); } } } } } // 9. Map struts to the node tree lattice.UniformMapping(cell, designSpace, spaceType, N, minLength, maxLength); // 10. Set output DA.SetDataList(0, lattice.Struts); }